dw-sdlc 0.6.0 → 0.9.0

package/dist/commands/pr-ship.js

@@ -0,0 +1,183 @@
+// `dw-sdlc pr ship [<n>]`, the Ship script: reads one pull request through gh, decides the Action it
+// needs next, performs it when it is the script's and reads again, then answers the first Action that
+// is not, as a line or one JSON document, with an exit code that names whose turn it is.
+import { parseArgs } from "node:util";
+import { repositoryRoot, resolveConfig, STRICTNESS } from "../agentic-config.js";
+import { decide, devCommand, hostArgs, isScriptAction, readyToMerge, REVIEW, shellLine } from "../pr/decide.js";
+import { CannotRun, gh, namedProblem, read, readAgain, said } from "../pr/read.js";
+export const summary = "decide the Action one pull request needs next, as a line or JSON";
+const USAGE = `Usage: dw-sdlc pr ship [<n>] [-R owner/name] [--merge] [--review full|off] [--dry-run] [--json] [--verbose]
+
+Reads pull request <n> through gh, the one of the current branch as gh pr view resolves it when <n>
+is omitted, and answers the Action it needs next: the status, the action, whose turn it is and why.
+The script performs its own Actions, each at most once and then reads again: it updates a branch
+behind its base, marks a draft ready once nothing else holds it back, and squash merges a pull
+request ready to merge under pr.merge auto in .ai/agentic.config.json or with --merge for this call;
+under ask, the default, it parks with the merge command. A head without a ${REVIEW} success
+gets the Review depth --review names for this call, else pr.review: under full, the default, the
+agent reviews it with the command pr.reviewCommand names, /code-review by default; under off the
+script posts the success itself, its description saying why.
+--dry-run performs nothing: it parks at the first Action the script would perform, listed under
+performed. One line, or one document with --json; --verbose adds the state as read to the document
+under facts. Needs an authenticated gh.
+
+Exit 0 done, 10 the agent's turn, 20 wait, 30 the dev's turn, 2 when it cannot run.`;
+const EXIT = { done: 0, act: 10, wait: 20, park: 30 };
+const REMEDIES = { clock: "unset it: it stands in for the clock in tests" };
+function parseCli(argv) {
+    try {
+        const { values, positionals } = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            options: {
+                help: { type: "boolean", short: "h" },
+                json: { type: "boolean" },
+                verbose: { type: "boolean" },
+                merge: { type: "boolean" },
+                review: { type: "string" },
+                "dry-run": { type: "boolean" },
+                repo: { type: "string", short: "R" }
+            }
+        });
+        const [number, ...more] = positionals;
+        const { repo } = values;
+        const review = STRICTNESS.review.find((depth) => depth === values.review);
+        if (values.help !== true) {
+            if (more.length > 0) {
+                return { error: `name one pull request, not ${positionals.length}` };
+            }
+            const problem = namedProblem(number, repo);
+            if (problem !== undefined) {
+                return { error: problem };
+            }
+            if (values.review !== undefined && review === undefined) {
+                return { error: `--review takes ${STRICTNESS.review.join(" or ")}, not ${JSON.stringify(values.review)}` };
+            }
+        }
+        return {
+            help: values.help === true,
+            json: values.json === true,
+            verbose: values.verbose === true,
+            merge: values.merge === true,
+            review,
+            dryRun: values["dry-run"] === true,
+            number: number === undefined ? undefined : Number(number),
+            repo
+        };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** The time the decision reads: DW_SDLC_NOW, an ISO 8601 time a test sets, else the system clock. */
+function now() {
+    const given = process.env.DW_SDLC_NOW?.trim();
+    if (given === undefined || given === "") {
+        return Date.now();
+    }
+    const time = Date.parse(given);
+    if (Number.isNaN(time)) {
+        throw new CannotRun(`DW_SDLC_NOW is ${JSON.stringify(given)}, not an ISO 8601 time`, REMEDIES.clock);
+    }
+    return time;
+}
+/** How a reason names each script Action: what the script would do, the act, and the state it acts on. */
+const NAMED = {
+    "update-branch": { would: "update the branch", act: "the update", still: "the branch still reads behind its base" },
+    "mark-ready": { would: "mark it ready", act: "the mark-ready", still: "the pull request still reads as a draft" },
+    "mark-reviewed": {
+        would: "mark it reviewed",
+        act: "the mark-reviewed",
+        still: `the head still carries no ${REVIEW} success`
+    },
+    merge: { would: "merge it", act: "the merge", still: "the pull request still reads open" }
+};
+/** A script Action the call leaves to the dev, `reason` saying why; a merge parks as ready-to-merge. */
+function handedOver(pr, policy, answer, action, reason) {
+    if (action === "merge") {
+        return { ...readyToMerge(pr, policy, reason), blockers: answer.blockers };
+    }
+    return { ...answer, status: "park", actor: "dev", reason, command: devCommand(pr, action, policy) };
+}
+/**
+ * Reads and decides until the Action is not the script's. Each script Action runs at most once, then the
+ * pull request is read again; under --dry-run, or when an Action comes round again, it is the dev's.
+ */
+function ship(cli, policy) {
+    let pr = read(cli, "pr ship");
+    const performed = [];
+    const refusals = {};
+    for (;;) {
+        const answer = decide(pr, now(), policy);
+        const { action } = answer;
+        if (!isScriptAction(action)) {
+            return { pr, answer, performed };
+        }
+        // -R names the repository, so the checkout the script runs in plays no part.
+        const args = hostArgs(pr, action, policy, true);
+        const command = shellLine(["gh", ...args]);
+        const { would, act, still } = NAMED[action];
+        if (cli.dryRun) {
+            performed.push({ action, command, ok: null });
+            return {
+                pr,
+                answer: handedOver(pr, policy, answer, action, `the script would ${would}; --dry-run performs nothing`),
+                performed
+            };
+        }
+        if (performed.some((done) => done.action === action)) {
+            const refusal = refusals[action];
+            const reason = refusal === undefined ? `${act} ran, and ${still}` : `gh refused ${act}: ${refusal}`;
+            return { pr, answer: handedOver(pr, policy, answer, action, reason), performed };
+        }
+        const result = gh(args);
+        performed.push({ action, command, ok: result.status === 0 });
+        if (result.status !== 0) {
+            refusals[action] = said(result.stderr) || `gh exited ${result.status}`;
+        }
+        pr = readAgain(pr);
+    }
+}
+/** `<status> <action>: <reason>`, the action dropped when it repeats the status, then the recheck and the command. */
+function lineOf({ status, action, reason, command, recheckAfter }) {
+    const label = status === action ? status : `${status} ${action}`;
+    const recheck = recheckAfter === undefined ? "" : `, recheck in ${recheckAfter} s`;
+    return `${label}: ${reason}${recheck}${command === undefined ? "" : ` — ${command}`}`;
+}
+function documentOf(pr, answer, performed, verbose) {
+    const facts = verbose ? { facts: pr } : {};
+    return { pr: pr.url, head: pr.head, base: pr.base, ...answer, performed, ...facts };
+}
+export function run(argv) {
+    const cli = parseCli(argv);
+    if ("error" in cli) {
+        process.stderr.write(`dw-sdlc pr ship: ${cli.error}\n\n${USAGE}\n`);
+        return 2;
+    }
+    if (cli.help) {
+        process.stdout.write(`${USAGE}\n`);
+        return 0;
+    }
+    // An invalid config layer resolves to ask and full, like every other strictest setting.
+    const declared = resolveConfig(repositoryRoot(process.cwd())).config.pr;
+    const policy = {
+        merge: cli.merge ? "auto" : declared.merge,
+        review: cli.review === undefined ? { depth: declared.review, source: "config" } : { depth: cli.review, source: "flag" },
+        reviewCommand: declared.reviewCommand
+    };
+    let shipped;
+    try {
+        shipped = ship(cli, policy);
+    }
+    catch (error) {
+        if (error instanceof CannotRun) {
+            process.stderr.write(`dw-sdlc pr ship: ${error.message} — ${error.remedy}\n`);
+            return 2;
+        }
+        throw error;
+    }
+    const { pr, answer, performed } = shipped;
+    const output = cli.json ? JSON.stringify(documentOf(pr, answer, performed, cli.verbose), null, 2) : lineOf(answer);
+    process.stdout.write(`${output}\n`);
+    return EXIT[answer.status];
+}

package/dist/commands/references-sync.js

@@ -6,6 +6,7 @@ import { existsSync, linkSync, mkdirSync, readdirSync, readFileSync, renameSync,
 import { extname, join } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { parseArgs } from "node:util";
+import { repositoryFreeEnv } from "../git-env.js";
 import { readPins, resolveRef } from "../pins.js";
 import { REFERENCES_FILE, readReferences } from "../references-key.js";
 import { renderBlock, withBlock } from "../router-block.js";
@@ -133,13 +134,11 @@ async function lock(root, seconds) {
         rmSync(own, { force: true });
     }
 }
-/** The variables that tie git to one repository, as git itself lists them. */
-const REPOSITORY_VARS = new Set((spawnSync("git", ["rev-parse", "--local-env-vars"], { encoding: "utf8" }).stdout ?? "").split("\n").filter(Boolean));
 function git(args, cwd) {
-    // Each call finds its repository from `cwd`: the GIT_DIR a git hook exports would aim it at the
-    // hook's repository. A missing credential fails the fetch instead of waiting on a prompt nobody sees.
-    const env = Object.fromEntries(Object.entries(process.env).filter(([name]) => !REPOSITORY_VARS.has(name)));
-    const result = spawnSync("git", args, { cwd, encoding: "utf8", env: { ...env, GIT_TERMINAL_PROMPT: "0" } });
+    // Each call finds its repository from `cwd`. A missing credential fails the fetch instead of waiting
+    // on a prompt nobody sees.
+    const env = { ...repositoryFreeEnv(), GIT_TERMINAL_PROMPT: "0" };
+    const result = spawnSync("git", args, { cwd, encoding: "utf8", env });
     // git's error on one line, so each Reference stays one line of the report.
     const err = (result.stderr ?? "")
         .split("\n")

package/dist/drift.d.ts

@@ -0,0 +1,17 @@
+import type { Gate } from "./agentic-config.ts";
+import type { Failure } from "./report.ts";
+import { type Status } from "./run-command.ts";
+/** What a Step answered, and one failure per file it created, changed or deleted. */
+export type Watched<T> = {
+    result: T;
+    failures: Failure[];
+};
+/** Steps run under watch, and what the watch found. */
+export type DriftWatch = {
+    /** Runs one Step by `run` between two records of the tree. */
+    step: <T>(command: string, run: () => Promise<T>) => Promise<Watched<T>>;
+    /** `fail` once a Step drifted, `error` once the tree could not be recorded, `pass` otherwise. */
+    status: () => Status;
+};
+/** A watch over the Steps of `gate` at `root`; under `gate.drift: "allow"` it only runs them. */
+export declare function watchDrift(root: string, gate: Gate): DriftWatch;

package/dist/drift.js

@@ -0,0 +1,68 @@
+// Drift: a file a Step creates, changes or deletes while the Gate runs. Before and after each Step the
+// Gate records the tree of every file git tracks or would track, never against HEAD, so an ignored
+// file never drifts and an edit made before the run sits in both records.
+import { stoppedBy } from "./run-command.js";
+import { git, workingTree } from "./working-tree.js";
+const REMEDIES = {
+    drift: "commit the change, or make the Step only read",
+    cannotWatch: 'run the Gate in a git checkout, or set gate.drift to "allow"'
+};
+/** What a letter of `git diff-tree --name-status` did to the file; T is a change of type, as a link to a file. */
+const CHANGES = { A: "created", D: "deleted", M: "changed", T: "changed" };
+/** One failure per file that differs between the trees `before` and `after`, naming `command`. */
+function drifted(root, command, before, after) {
+    if (before === after) {
+        return [];
+    }
+    const diff = git(root, ["diff-tree", "-r", "-z", "--no-renames", "--name-status", before, after]);
+    if ("error" in diff) {
+        return diff;
+    }
+    // NUL-terminated pairs: the letter, then the path, which may hold any byte but NUL.
+    return [...diff.out.matchAll(/([A-Z])\0([^\0]+)\0/g)].map(([, letter = "", file = ""]) => {
+        const message = `${JSON.stringify(command)} ${CHANGES[letter] ?? "changed"} it`;
+        return { file, rule: "drift", message, remedy: REMEDIES.drift };
+    });
+}
+/** A watch over the Steps of `gate` at `root`; under `gate.drift: "allow"` it only runs them. */
+export function watchDrift(root, gate) {
+    let status = "pass";
+    let watching = gate.drift !== "allow";
+    /** The tree after the last Step, the record before the next: nothing runs between two Steps. */
+    let last;
+    /** The one failure of a tree that cannot be recorded; the watch stops there. */
+    const cannotWatch = (command, error) => {
+        watching = false;
+        status = "error";
+        const message = `cannot watch ${JSON.stringify(command)}: ${error}`;
+        return [{ rule: "drift", message, remedy: REMEDIES.cannotWatch }];
+    };
+    const step = async (command, run) => {
+        if (!watching) {
+            return { result: await run(), failures: [] };
+        }
+        const before = last === undefined ? workingTree(root) : { tree: last };
+        const result = await run();
+        if ("error" in before) {
+            return { result, failures: cannotWatch(command, before.error) };
+        }
+        if (stoppedBy() !== undefined) {
+            // A signal cut the Step short and ends the Gate, so nothing is compared after it.
+            return { result, failures: [] };
+        }
+        const after = workingTree(root);
+        if ("error" in after) {
+            return { result, failures: cannotWatch(command, after.error) };
+        }
+        last = after.tree;
+        const found = drifted(root, command, before.tree, after.tree);
+        if ("error" in found) {
+            return { result, failures: cannotWatch(command, found.error) };
+        }
+        if (found.length > 0) {
+            status = "fail";
+        }
+        return { result, failures: found };
+    };
+    return { step, status: () => status };
+}

package/dist/gate-cache.d.ts

@@ -0,0 +1,13 @@
+import type { Gate } from "./agentic-config.ts";
+/** A checkout's fingerprint and the file its last green run is stamped in. */
+export type Fingerprint = {
+    key: string;
+    stampFile: string;
+};
+/** The fingerprint of the checkout at `root` judged by `gate`, or why it has none. */
+export declare function fingerprint(root: string, gate: Gate): Fingerprint | {
+    error: string;
+};
+/** Whether the last green run of this checkout was stamped with this fingerprint. */
+export declare function isGreen({ key, stampFile }: Fingerprint): boolean;
+export declare function stampGreen({ key, stampFile }: Fingerprint): void;

package/dist/gate-cache.js

@@ -0,0 +1,39 @@
+// The Gate's cache. A checkout's fingerprint is its working tree's content and the Gate that judges
+// it. A green run stamps it in the checkout's own git dir, so each worktree keeps its own stamp.
+import { createHash } from "node:crypto";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { packageVersion } from "./package-version.js";
+import { workingTree } from "./working-tree.js";
+const STAMP_FILE = "dw-sdlc-gate.green";
+/** The fingerprint of the checkout at `root` judged by `gate`, or why it has none. */
+export function fingerprint(root, gate) {
+    const found = workingTree(root);
+    if ("error" in found) {
+        return found;
+    }
+    try {
+        const judge = createHash("sha256").update(JSON.stringify({ version: packageVersion(), gate }));
+        return { key: `${found.tree} ${judge.digest("hex")}`, stampFile: join(found.gitDir, STAMP_FILE) };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** Whether the last green run of this checkout was stamped with this fingerprint. */
+export function isGreen({ key, stampFile }) {
+    try {
+        return readFileSync(stampFile, "utf8").trim() === key;
+    }
+    catch {
+        return false;
+    }
+}
+export function stampGreen({ key, stampFile }) {
+    try {
+        writeFileSync(stampFile, `${key}\n`);
+    }
+    catch {
+        // A stamp that cannot be written only means the next run does not skip.
+    }
+}

package/dist/git-env.d.ts

@@ -0,0 +1,2 @@
+/** This process's environment without the variables that tie git to one repository, as git lists them. */
+export declare function repositoryFreeEnv(): NodeJS.ProcessEnv;

package/dist/git-env.js

@@ -0,0 +1,10 @@
+// The environment a git command runs under to find its repository from its own directory, as a git
+// hook's GIT_DIR or GIT_INDEX_FILE would otherwise aim it at the hook's repository.
+import { spawnSync } from "node:child_process";
+let repositoryVars;
+/** This process's environment without the variables that tie git to one repository, as git lists them. */
+export function repositoryFreeEnv() {
+    repositoryVars ??= new Set((spawnSync("git", ["rev-parse", "--local-env-vars"], { encoding: "utf8" }).stdout ?? "").split("\n").filter(Boolean));
+    const vars = repositoryVars;
+    return Object.fromEntries(Object.entries(process.env).filter(([name]) => !vars.has(name)));
+}

package/dist/markdown.d.ts

@@ -25,6 +25,25 @@ export declare function codeSpans(text: string): string[];
 export declare function prose(text: string): string;
 /** Every link target in the prose of `text`, its angle brackets dropped, with its 1-based line. */
 export declare function links(text: string): Link[];
+/** A value of a frontmatter, with its 1-based line. */
+export type FrontmatterValue = {
+    value: string;
+    line: number;
+};
+/** A top-level key of a frontmatter: the value after its colon, and the items of the block list under it. */
+export type FrontmatterEntry = FrontmatterValue & {
+    items: FrontmatterValue[];
+};
+/**
+ * The top-level keys of the frontmatter `text` opens with, none when it opens with none. A key written
+ * twice is read where it first appears.
+ */
+export declare function frontmatter(text: string): Map<string, FrontmatterEntry>;
+/**
+ * The values a list key names: comma-separated after its colon, in `[…]` or not, or else its items. A comma
+ * inside a glob's `{…}` separates none, and an empty value is dropped.
+ */
+export declare function frontmatterList(key: FrontmatterEntry | undefined): FrontmatterValue[];
 /** The anchors of each markdown file read so far, by path. */
 export type Anchors = Map<string, Set<string>>;
 /** The anchors of the headings of `path` under `root`; none when it is not a file. */

package/dist/markdown.js

@@ -1,6 +1,6 @@
 // The parts of a markdown file the Checks read: its ATX headings with the anchors GitHub gives them,
-// the rows of a table under a heading, its links, and its prose with the code masked; and the anchors
-// of a file on disk. A line inside a fenced code block is never any of them.
+// the rows of a table under a heading, its links, its prose with the code masked and the keys of its
+// frontmatter; and the anchors of a file on disk. A line inside a fenced code block is never any of them.
 import { readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 /** A code fence at any indent, so one inside a list item counts. */
@@ -103,6 +103,50 @@ export function links(text) {
         return targets.map((target) => ({ target: target.replace(/^<(.*)>$/, "$1"), line: index + 1 }));
     });
 }
+/** A scalar as YAML reads it: the text between its quotes, or else the text before a ` #` comment. */
+function scalar(text) {
+    const quoted = /^\s*(["'])(.*?)\1\s*(#.*)?$/.exec(text);
+    return quoted?.[2] ?? text.replace(/(^|\s)#.*$/, "").trim();
+}
+/**
+ * The top-level keys of the frontmatter `text` opens with, none when it opens with none. A key written
+ * twice is read where it first appears.
+ */
+export function frontmatter(text) {
+    const keys = new Map();
+    const lines = text.split("\n");
+    if (lines[0]?.trim() !== "---") {
+        return keys;
+    }
+    let current;
+    for (let index = 1; index < lines.length && lines[index]?.trim() !== "---"; index++) {
+        const line = lines[index] ?? "";
+        const [, name, rest = ""] = /^([\w-]+):(.*)$/.exec(line) ?? [];
+        const item = /^\s*-(?:\s+(.*))?$/.exec(line);
+        if (name !== undefined) {
+            current = keys.has(name) ? undefined : { value: scalar(rest), line: index + 1, items: [] };
+            if (current !== undefined) {
+                keys.set(name, current);
+            }
+        }
+        else if (item !== null) {
+            current?.items.push({ value: scalar(item[1] ?? ""), line: index + 1 });
+        }
+    }
+    return keys;
+}
+/**
+ * The values a list key names: comma-separated after its colon, in `[…]` or not, or else its items. A comma
+ * inside a glob's `{…}` separates none, and an empty value is dropped.
+ */
+export function frontmatterList(key) {
+    if (key === undefined) {
+        return [];
+    }
+    const inline = key.value.replace(/^\[(.*)\]$/, "$1");
+    const values = inline === "" ? key.items : inline.split(/,(?![^{]*\})/).map((value) => ({ value: scalar(value), line: key.line }));
+    return values.filter(({ value }) => value !== "");
+}
 /** The anchors of the headings of `path` under `root`; none when it is not a file. */
 export function anchorsOf(root, path, cache) {
     let anchors = cache.get(path);

package/dist/package-version.d.ts

@@ -0,0 +1,2 @@
+/** This package's version; throws when its manifest names none. */
+export declare function packageVersion(): string;

package/dist/package-version.js

@@ -0,0 +1,13 @@
+// The version of this package, read from its own manifest: one directory above `src/` in the source
+// and above `dist/` in what npm installs.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseObject } from "./json-text.js";
+/** This package's version; throws when its manifest names none. */
+export function packageVersion() {
+    const manifest = parseObject(readFileSync(join(import.meta.dirname, "..", "package.json"), "utf8"));
+    if (typeof manifest?.version !== "string") {
+        throw new Error("dw-sdlc's package.json names no version");
+    }
+    return manifest.version;
+}

package/dist/pr/decide.d.ts

@@ -0,0 +1,59 @@
+import type { PrMerge, PrReview } from "../agentic-config.ts";
+import type { PrState } from "./state.ts";
+export type Status = "act" | "wait" | "park" | "done";
+export type Actor = "script" | "agent" | "dev";
+export type Action = "done" | "stop" | "wait" | "fix-conflicts" | "update-branch" | "fix-ci" | "address-review" | "review" | "mark-reviewed" | "unverified" | "ci-stuck" | "awaiting-reply" | "mark-ready" | "awaiting-author" | "awaiting-approval" | "ready-to-merge" | "merge";
+/** The Actions the script performs itself, each one gh command. */
+export type ScriptAction = "update-branch" | "mark-ready" | "mark-reviewed" | "merge";
+/** Where a Review depth comes from: the dev's `--review` for this call, or `pr.review`. */
+export type DepthSource = "flag" | "config";
+/**
+ * What the decision reads beside the pull request: who merges it, how closely a Review reads it, and
+ * the slash command a `full` Review runs.
+ */
+export type Policy = {
+    merge: PrMerge;
+    review: {
+        depth: PrReview;
+        source: DepthSource;
+    };
+    reviewCommand: string;
+};
+/** An Action the pull request needs beside the one its answer names, so one push can fix several. */
+export type Blocker = {
+    action: Action;
+    actor: Actor;
+    reason: string;
+    details?: Record<string, unknown>;
+};
+export type Answer = Blocker & {
+    status: Status;
+    /** A shell-quoted command, when there is one to run. */
+    command?: string;
+    /** Seconds to wait before calling again. */
+    recheckAfter?: number;
+    blockers: Blocker[];
+};
+/** The commit status a clean review of the head leaves on it. */
+export declare const REVIEW = "dw-sdlc/review";
+/** Its one state: a failure or a pending status would turn the pull request unstable. */
+export declare const REVIEW_STATE = "success";
+/** The words as one POSIX shell command line, each word that needs it single-quoted. */
+export declare function shellLine(words: string[]): string;
+/**
+ * The gh arguments that post the `dw-sdlc/review` success on the head, `description` saying how it was
+ * read. The path names the repository, so the call reads the same from any checkout.
+ */
+export declare function reviewStatusArgs(pr: PrState, description: string): string[];
+export declare function isScriptAction(action: Action): action is ScriptAction;
+/**
+ * The gh arguments of a script Action, `-R` naming the repository when `named`. The update merges the
+ * base in, never --rebase, which rewrites the branch on GitHub; the merge names the head it read.
+ */
+export declare function hostArgs(pr: PrState, action: ScriptAction, policy: Policy, named: boolean): string[];
+/** The command a script Action leaves the dev to run, from a checkout of the repository. */
+export declare function devCommand(pr: PrState, action: ScriptAction, policy: Policy): string;
+/** The merge left to the dev, `reason` saying why it is theirs. */
+export declare function readyToMerge(pr: PrState, policy: Policy, reason: string): Omit<Answer, "blockers">;
+/** The Action `pr` needs at `now`, milliseconds since the epoch, under `policy`. */
+export declare function decide(pr: PrState, now: number, policy: Policy): Answer;