@wardby/cli 0.6.0 → 0.7.0

package/dist/core/issue-bridge.js

@@ -1,33 +1,40 @@
 /**
  * Links a run's pull requests to the issue that started it: records each
- * issue/PR pair, puts a web link on the issue, and applies the link's
- * configured status move. Provider-neutral: a code host is only ever
- * { provider, repository, number }. The issue key comes from the run tree
- * (RunIssueStatus), never from model output. The status move is a control-plane
+ * issue/PR pair (recordIssuePullRequests, the same for a Jira issue and a
+ * GitHub issue), and for a tracker issue puts a web link on the issue and
+ * applies the link's configured status move. Provider-neutral: a code host is
+ * only ever { provider, repository, number }. The issue key comes from the run
+ * tree (RunIssueStatus, or a GitHub mention's RunHostStatus), never from model
+ * output. The status move is a control-plane
  * action (not gated by allowedTransitions). Nothing here throws, except
  * handlePullRequestClosed's lookup before it has claimed anything (so the
  * webhook delivery is rolled back and redelivered).
  */
 import { Prisma } from "#prisma";
 import { projectOf, } from "../providers/issue-tracker/types.js";
+import { normalizeGitHubRepository } from "../coding/protocol.js";
 import { logger } from "./logger.js";
 import { dedupeKeys, emitWorkflowEvent } from "./workflow-events.js";
 const log = logger.child({ module: "issue-bridge" });
 export const pullRequestGlobalId = (pr) => `wardby:pr:${pr.codeProvider}:${pr.repository}#${pr.number}`;
+/** A GitHub issue's IssuePullRequest key: "<owner>/<repo>#<number>", the repository normalised. */
+export function githubIssueKey(repository, number) {
+    return `${normalizeGitHubRepository(repository)}#${number}`;
+}
 /**
  * Makes sure the issue/PR pair has a row, without ever overwriting one: a new
  * row is "created"; an existing open one gets its url refreshed ("open"); a
  * merged or closed one is left alone ("settled"). A lost create race (P2002)
  * reads back the winner's row. "unknown" when the store could not be read.
  */
-async function ensurePair(db, input, pr) {
+async function ensurePair(db, issue, pr) {
     const where = {
         codeProvider_repository_number_issueProvider_issueKey: {
             codeProvider: pr.codeProvider,
             repository: pr.repository,
             number: pr.number,
-            issueProvider: input.issueProvider,
-            issueKey: input.issueKey,
+            issueProvider: issue.provider,
+            issueKey: issue.key,
         },
     };
     try {
@@ -36,13 +43,13 @@ async function ensurePair(db, input, pr) {
             try {
                 await db.issuePullRequest.create({
                     data: {
-                        issueProvider: input.issueProvider,
-                        issueKey: input.issueKey,
+                        issueProvider: issue.provider,
+                        issueKey: issue.key,
                         codeProvider: pr.codeProvider,
                         repository: pr.repository,
                         number: pr.number,
                         url: pr.url,
-                        agentId: input.agentId,
+                        agentId: pr.agentId,
                         openedByRunId: pr.openedByRunId,
                     },
                 });
@@ -62,10 +69,98 @@ async function ensurePair(db, input, pr) {
         return "open";
     }
     catch (err) {
-        log.warn({ err, issueKey: input.issueKey, repository: pr.repository, number: pr.number }, "could not record the issue/PR pair");
+        log.warn({ err, issueKey: issue.key, repository: pr.repository, number: pr.number }, "could not record the issue/PR pair");
         return "unknown";
     }
 }
+/** Records each pair (ensurePair), in order; each state lines up with its pull request. Never throws. */
+async function recordPairs(db, issue, prs) {
+    const states = [];
+    for (const pr of prs)
+        states.push(await ensurePair(db, issue, pr));
+    return states;
+}
+/**
+ * Notifies pr_opened for each pull request this call newly recorded as opened
+ * (`states` lines up with `prs`), so a retried completion does not notify
+ * twice. One message and dedupe key for every issue provider. Never throws.
+ */
+async function emitNewlyOpened(issue, prs, states, movedTo) {
+    for (const [i, pr] of prs.entries()) {
+        if (states[i] !== "created" || pr.outcome !== "pull_request_opened")
+            continue;
+        await emitWorkflowEvent({
+            dedupeKey: dedupeKeys.prOpened(pr.codeProvider, pr.repository, pr.number),
+            runId: pr.openedByRunId,
+            agentId: pr.agentId,
+            workItem: { provider: issue.provider, key: issue.key },
+            pullRequest: { codeProvider: pr.codeProvider, repository: pr.repository, number: pr.number },
+            payload: { kind: "pr_opened", prLabel: `${pr.repository}#${pr.number}`, prUrl: pr.url, movedTo },
+        });
+    }
+}
+/**
+ * Records the pull requests a run opened or continued for an issue, the same
+ * for every issue provider (a Jira issue, a GitHub issue): one IssuePullRequest
+ * row per issue/PR pair, state "open", never duplicated or overwritten (a
+ * merged or closed pair stays so; an open one gets its url refreshed), and a
+ * pr_opened notification for each newly recorded opened pull request.
+ * handlePullRequestClosed settles the rows. A GitHub issue's key is always
+ * githubIssueKey's, so any lookup of its rows must build the key the same way.
+ * Safe to repeat; never throws.
+ */
+export async function recordIssuePullRequests(db, issue, prs) {
+    try {
+        await emitNewlyOpened(issue, prs, await recordPairs(db, issue, prs), null);
+    }
+    catch (err) {
+        log.warn({ err, issueKey: issue.key }, "could not record the issue's pull requests");
+    }
+}
+/**
+ * The coding runs (of `runIds`) that continued a pull request opened for a
+ * different issue: their PR belongs to that issue, not this one. A
+ * continuation is foreign when its root coding run was dispatched for another
+ * tracked issue (CodingRun.issueKey), or when that root opened a pull request
+ * recorded for a different issue of any provider (IssuePullRequest, which a
+ * GitHub issue's runs also write). A continued PR with no issue, or this same
+ * issue, is fine.
+ */
+export async function continuedForAnotherIssue(db, runIds, issue) {
+    if (runIds.length === 0)
+        return new Set();
+    const rows = await db.codingRun.findMany({
+        where: { runId: { in: runIds } },
+        select: {
+            runId: true,
+            rootCodingRunId: true,
+            rootCodingRun: { select: { issueProvider: true, issueKey: true } },
+        },
+    });
+    const foreign = new Set();
+    const byRoot = new Map();
+    for (const { runId, rootCodingRunId, rootCodingRun: root } of rows) {
+        if (root?.issueKey && (root.issueKey !== issue.key || root.issueProvider !== issue.provider)) {
+            foreign.add(runId);
+        }
+        else if (rootCodingRunId) {
+            byRoot.set(rootCodingRunId, [...(byRoot.get(rootCodingRunId) ?? []), runId]);
+        }
+    }
+    if (byRoot.size > 0) {
+        const recorded = await db.issuePullRequest.findMany({
+            where: { openedByRunId: { in: [...byRoot.keys()] } },
+            select: { openedByRunId: true, issueProvider: true, issueKey: true },
+        });
+        for (const r of recorded) {
+            if (r.issueProvider === issue.provider && r.issueKey === issue.key)
+                continue;
+            for (const runId of byRoot.get(r.openedByRunId) ?? [])
+                foreign.add(runId);
+        }
+    }
+    return foreign;
+}
 /**
  * Returns sentences for the outcome comment (a refused status move); empty
  * when there is nothing to say. Safe to repeat (a retried completion): each
@@ -78,13 +173,13 @@ export async function recordPullRequests(db, tracker, input) {
     const notes = [];
     try {
         let newlyOpened = false;
-        const opened = [];
-        for (const pr of input.pullRequests) {
-            const state = await ensurePair(db, input, pr);
-            if (state === "created" && pr.outcome === "pull_request_opened") {
+        const issue = { provider: input.issueProvider, key: input.issueKey };
+        const records = input.pullRequests.map((pr) => ({ ...pr, agentId: input.agentId }));
+        const states = await recordPairs(db, issue, records);
+        for (const [i, pr] of input.pullRequests.entries()) {
+            const state = states[i];
+            if (state === "created" && pr.outcome === "pull_request_opened")
                 newlyOpened = true;
-                opened.push(pr);
-            }
             if (state !== "created" && state !== "open")
                 continue;
             try {
@@ -111,16 +206,7 @@ export async function recordPullRequests(db, tracker, input) {
             }
         }
         // Only pairs this call newly recorded, so a retried completion does not notify twice. Never throws.
-        for (const pr of opened) {
-            await emitWorkflowEvent({
-                dedupeKey: dedupeKeys.prOpened(pr.codeProvider, pr.repository, pr.number),
-                runId: pr.openedByRunId,
-                agentId: input.agentId,
-                workItem: { provider: input.issueProvider, key: input.issueKey },
-                pullRequest: { codeProvider: pr.codeProvider, repository: pr.repository, number: pr.number },
-                payload: { kind: "pr_opened", prLabel: `${pr.repository}#${pr.number}`, prUrl: pr.url, movedTo },
-            });
-        }
+        await emitNewlyOpened(issue, records, states, movedTo);
     }
     catch (err) {
         log.warn({ err, issueKey: input.issueKey }, "could not bridge the pull requests to the issue");
@@ -129,8 +215,9 @@ export async function recordPullRequests(db, tracker, input) {
 }
 /**
  * A pull request wardby recorded against an issue was merged or closed: marks
- * each still-open pair, and, where the agent's link to the issue's project is
- * still write, comments on the issue (and on merge resolves the web link and
+ * each still-open pair (every issue provider, configured tracker or not),
+ * and, for an issue in a configured tracker where the agent's link to the
+ * issue's project is still write, comments on the issue (and on merge resolves the web link and
  * applies the link's onPullRequestMerged move). Only rows wardby wrote are
  * touched, matched by the host's own identity for the PR — nothing from the
  * PR's text. The row is claimed first (open → merged/closed), so a duplicate
@@ -139,11 +226,14 @@ export async function recordPullRequests(db, tracker, input) {
  * delivery is rolled back and redelivered; never throws after that.
  */
 export async function handlePullRequestClosed(db, trackers, pr) {
-    if (!trackers)
-        return;
     const where = { codeProvider: pr.codeProvider, repository: pr.repository, number: pr.number };
     // Not caught: nothing is claimed yet, and a throw rolls back the delivery so it is redelivered.
-    const rows = await db.issuePullRequest.findMany({ where: { ...where, state: "open" } });
+    // Oldest pair first: pr_closed's dedupe key is per pull request, so the first-recorded issue's event is
+    // the one kept, every delivery alike.
+    const rows = await db.issuePullRequest.findMany({
+        where: { ...where, state: "open" },
+        orderBy: { createdAt: "asc" },
+    });
     for (const row of rows) {
         // Exactly once per claimed row, from the finally below, even when a later step throws: the row is no
         // longer open, so nothing would retry it. Never throws.
@@ -170,7 +260,8 @@ export async function handlePullRequestClosed(db, trackers, pr) {
             if (claimed.count === 0)
                 continue;
             claimedRow = true;
-            const tracker = trackers[row.issueProvider];
+            // A pair with no configured tracker (a GitHub issue's, say) is only marked.
+            const tracker = trackers?.[row.issueProvider];
             if (!tracker)
                 continue;
             const link = await db.agentIssueProject.findUnique({

package/dist/core/issue-events.d.ts

@@ -12,7 +12,7 @@ import type { Executor } from "../providers/executor/types.js";
 import type { IssueEvent, IssueEventKind, IssueTrackerRegistry } from "../providers/issue-tracker/types.js";
 import { type DispatchDb } from "./dispatch.js";
 import { type OpenSibling } from "./related-pull-requests.js";
-export type IssueEventDb = DispatchDb & Pick<PrismaClient, "agentIssueProject" | "runIssueStatus" | "issuePullRequest" | "workItem">;
+export type IssueEventDb = DispatchDb & Pick<PrismaClient, "registryFetch" | "registryAuditRecord" | "runBudgetEvent" | "agentIssueProject" | "runIssueStatus" | "issuePullRequest" | "workItem">;
 export interface RouteIssueEventDeps {
     db: IssueEventDb;
     executor: Executor;

package/dist/core/issue-events.js

@@ -2,12 +2,11 @@ import { RESPONSE_PATH_SNAPSHOT_BUDGET, resolveWorkItem } from "./attribution.js
 import { dispatchRun } from "./dispatch.js";
 import { issueStatusRow, postIssueWorkingStatus } from "./issue-status.js";
 import { logger } from "./logger.js";
-import { openSiblingsForIssue, SIBLING_GUIDANCE } from "./related-pull-requests.js";
+import { openPullRequestHints, openSiblingsForIssue } from "./related-pull-requests.js";
 import { composeTaskOverride } from "./untrusted-content.js";
 import { dedupeKeys, emitWorkflowEvent } from "./workflow-events.js";
 const log = logger.child({ module: "issue-events" });
 const MAX_TASK_BODY = 8000;
-const RUN_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
 /** Only admin-configured values (trigger labels, the target status) appear here: never free text from the actor. */
 function describeKind(event, kind, link) {
     switch (kind) {
@@ -45,14 +44,9 @@ export function issueTaskText(event, matched, issueUrl, link, openPrs = []) {
             "do not also post it with jira_comment; use jira_comment only for other issues or progress notes on long work.",
     ];
     // Control-plane data from stored rows (validated here), never issue text.
-    const hinted = openPrs.filter((p) => RUN_ID_RE.test(p.openedByRunId));
-    for (const pr of hinted) {
-        sections.push(`This issue already has an open pull request wardby opened: ${pr.repository}#${pr.number} ` +
-            `(https://github.com/${pr.repository}/pull/${pr.number}). ` +
-            `To revise it, delegate with continuePriorRun set to exactly "${pr.openedByRunId}".`);
-    }
-    if (hinted.length > 0)
-        sections.push(SIBLING_GUIDANCE);
+    const hints = openPullRequestHints(openPrs);
+    if (hints)
+        sections.push(hints);
     if (matched.includes("mention") && event.comment) {
         sections.push(`Request comment:\n${event.comment.body.slice(0, MAX_TASK_BODY)}`);
     }

package/dist/core/issue-status.d.ts

@@ -7,7 +7,7 @@
 import { Prisma, type PrismaClient } from "#prisma";
 import { type IssueTrackerRegistry } from "../providers/issue-tracker/types.js";
 import { type FinishedRun } from "./host-status.js";
-export type IssueStatusDb = Pick<PrismaClient, "runIssueStatus" | "run" | "agentIssueProject" | "issuePullRequest" | "codingRun" | "$queryRaw">;
+export type IssueStatusDb = Pick<PrismaClient, "registryFetch" | "registryAuditRecord" | "runIssueStatus" | "run" | "runBudgetEvent" | "agentIssueProject" | "issuePullRequest" | "codingRun" | "$queryRaw">;
 export declare function toJiraMarkdown(text: string): string;
 export declare function issueStatusRow(event: {
     issueKey: string;

package/dist/core/issue-status.js

@@ -5,9 +5,9 @@
  * text. Best effort throughout: nothing here throws.
  */
 import { Prisma } from "#prisma";
-import { projectOf } from "../providers/issue-tracker/types.js";
-import { collectRunOutcome, outcomeBody, runLine, workingBody } from "./host-status.js";
-import { recordPullRequests } from "./issue-bridge.js";
+import { projectOf, } from "../providers/issue-tracker/types.js";
+import { collectRunOutcome, fullReplyComments, fullReplyOf, isBlockedByRefusals, JIRA_REPLY_MAX_CHARS, outcomeBody, REPLY_MAX_PARTS, runLine, workingBody, } from "./host-status.js";
+import { continuedForAnotherIssue, recordPullRequests } from "./issue-bridge.js";
 import { logger } from "./logger.js";
 const log = logger.child({ module: "issue-status" });
 const TERMINAL = new Set(["succeeded", "failed", "refused", "lost", "budget_exhausted", "cancelled"]);
@@ -126,26 +126,6 @@ async function currentLink(db, runId, issueKey, provider) {
     });
     return link ? { agentId: run.agentId, ...link } : null;
 }
-/**
- * The coding runs (of `runIds`) that continued a pull request opened for a
- * different issue: their PR belongs to that issue, not this one. A continued
- * PR with no issue, or this same issue, is fine.
- */
-async function continuedForAnotherIssue(db, runIds, issue) {
-    if (runIds.length === 0)
-        return new Set();
-    const rows = await db.codingRun.findMany({
-        where: { runId: { in: runIds } },
-        select: { runId: true, rootCodingRun: { select: { issueProvider: true, issueKey: true } } },
-    });
-    return new Set(rows
-        .filter(({ rootCodingRun: root }) => {
-        if (!root?.issueKey)
-            return false;
-        return root.issueKey !== issue.issueKey || root.issueProvider !== issue.provider;
-    })
-        .map((row) => row.runId));
-}
 export async function completeIssueStatus(db, run, trackers, opts = {}) {
     if (!trackers)
         return;
@@ -164,9 +144,10 @@ export async function completeIssueStatus(db, run, trackers, opts = {}) {
         const writable = link?.access === "write";
         const project = projectOf(status.issueKey);
         let body;
+        let fullReply = null;
         if (writable) {
-            const { pullRequests, failedChildren, budgetSentence } = await collectRunOutcome(db, run);
-            const foreign = await continuedForAnotherIssue(db, pullRequests.flatMap((pr) => (pr.pullRequestUrl && pr.runId ? [pr.runId] : [])), status);
+            const { pullRequests, failedChildren, budgetSentence, packageRefusals, noChanges, packageAudit } = await collectRunOutcome(db, run);
+            const foreign = await continuedForAnotherIssue(db, pullRequests.flatMap((pr) => (pr.pullRequestUrl && pr.runId ? [pr.runId] : [])), { provider: status.provider, key: status.issueKey });
             for (const runId of foreign) {
                 log.info({ runId: run.id, codingRunId: runId, issueKey: status.issueKey }, "not linking a pull request continued from another issue's run");
             }
@@ -191,9 +172,18 @@ export async function completeIssueStatus(db, run, trackers, opts = {}) {
                     pullRequests: bridged,
                 })
                 : { notes: [] };
+            // A blocked status is built from the refusals alone, so the agent's reply is not posted after it.
+            fullReply = isBlockedByRefusals(run, { pullRequests, failedChildren, packageRefusals, noChanges })
+                ? null
+                : fullReplyOf(run, pullRequests, failedChildren);
             const outcome = outcomeBody(run, "", pullRequests, failedChildren, {
                 budgetSentence,
+                packageRefusals,
+                packageAudit,
+                noChanges,
+                fullReplyFollows: true,
                 noPullRequestText: "Done.",
+                fromIssue: true,
                 // One comment per request: this status comment carries the agent's answer.
                 replyAsAnswer: true,
             });
@@ -221,12 +211,50 @@ export async function completeIssueStatus(db, run, trackers, opts = {}) {
         }
         // Unlinked or read-only with no status comment yet: complete the row
         // without posting; never create content where the agent may not write.
-        await db.runIssueStatus.update({ where: { runId: run.id }, data: { commentId, completedAt: new Date() } });
+        // Claims the row in one step, saving a posted comment's id at once so a retry edits it instead of
+        // posting a second one. Only the completion that claims it posts the full reply, so two racing
+        // completions (the run's own and the reconciler's) never post it twice.
+        const claimed = await db.runIssueStatus.updateMany({
+            where: { runId: run.id, completedAt: null },
+            data: { commentId, completedAt: new Date() },
+        });
+        if (claimed.count !== 1) {
+            log.warn({ runId: run.id }, "the issue status comment was completed meanwhile; leaving any full reply to that completion");
+            return;
+        }
+        if (writable && fullReply !== null) {
+            await postFullReply(tracker, status.issueKey, run.id, fullReply, issueKeyProjects, link.commentVisibilityRole);
+        }
     }
     catch (err) {
         log.warn({ err, runId: run.id }, "could not complete the issue status comment");
     }
 }
+/**
+ * Posts the full reply's parts in order, each at most once: the status comment already points to them,
+ * so a failed part is logged and the rest skipped (a gap would misnumber the reply), and the row is still
+ * completed. The full text stays on the run. Never throws.
+ */
+async function postFullReply(tracker, issueKey, runId, reply, issueKeyProjects, visibilityRole) {
+    // Converted first, then split: the conversion lengthens `owner/repo#N` references, and the parts must fit after it.
+    const bodies = fullReplyComments(toJiraMarkdown(reply), {
+        maxChars: JIRA_REPLY_MAX_CHARS,
+        maxParts: REPLY_MAX_PARTS,
+    });
+    for (const [i, body] of bodies.entries()) {
+        try {
+            await tracker.comment(issueKey, {
+                markdown: body,
+                issueKeyProjects,
+                ...(visibilityRole ? { visibilityRole } : {}),
+            });
+        }
+        catch (err) {
+            log.warn({ err, runId, part: i + 1, parts: bodies.length }, "could not post a part of the run's full reply; the rest is skipped, the full text stays on the run");
+            return;
+        }
+    }
+}
 export async function closeOrphanedIssueStatuses(db, trackers, now = new Date()) {
     const providers = Object.keys(trackers ?? {});
     if (!trackers || providers.length === 0)

package/dist/core/logger.d.ts

@@ -9,5 +9,10 @@
  * for the CLI's own output — see cli.ts's stdout/stderr split).
  */
 import pino from "pino";
+/**
+ * Sets the filter every log line passes through on its way to stderr. The native sandbox worker
+ * uses it to redact the secret values it received (native-worker/stderr-redaction.ts).
+ */
+export declare function setLogLineFilter(filter: (line: string) => string): void;
 export declare const logger: pino.Logger<never, boolean>;
 export type Logger = typeof logger;

package/dist/core/logger.js

@@ -42,4 +42,17 @@ function redactErr(error) {
     // last two); an AggregateError adds `aggregateErrors`, hence the walk.
     return redactDeep(pino.stdSerializers.err(error));
 }
-export const logger = pino({ level: process.env.LOG_LEVEL ?? "info", serializers: { err: redactErr } }, pino.destination({ fd: 2, sync: false }));
+/** Applied to every serialized line before it is written. Identity unless a process sets one. */
+let lineFilter = (line) => line;
+/**
+ * Sets the filter every log line passes through on its way to stderr. The native sandbox worker
+ * uses it to redact the secret values it received (native-worker/stderr-redaction.ts).
+ */
+export function setLogLineFilter(filter) {
+    lineFilter = filter;
+}
+export const logger = pino({
+    level: process.env.LOG_LEVEL ?? "info",
+    serializers: { err: redactErr },
+    hooks: { streamWrite: (line) => lineFilter(line) },
+}, pino.destination({ fd: 2, sync: false }));

package/dist/core/lost-run-children.d.ts

@@ -0,0 +1,6 @@
+import type { PrismaClient } from "#prisma";
+import type { Executor } from "../providers/executor/types.js";
+/** The stop reason recorded on every child stopped because its parent run ended lost. */
+export declare const PARENT_LOST_REASON = "parent run lost";
+/** Stops the still-drivable children of a run that ended lost, so none keeps spending for nobody. */
+export declare function stopChildrenOfLostRun(db: Pick<PrismaClient, "run">, executor: Pick<Executor, "stop"> | undefined, runId: string): Promise<number>;

package/dist/core/lost-run-children.js

@@ -0,0 +1,32 @@
+import { DRIVABLE } from "./run-status.js";
+import { logger } from "./logger.js";
+const log = logger.child({ module: "lost-run-children" });
+/** The stop reason recorded on every child stopped because its parent run ended lost. */
+export const PARENT_LOST_REASON = "parent run lost";
+/** Stops the still-drivable children of a run that ended lost, so none keeps spending for nobody. */
+export async function stopChildrenOfLostRun(db, executor, runId) {
+    if (!executor)
+        return 0;
+    let children;
+    try {
+        children = await db.run.findMany({
+            where: { parentRunId: runId, status: { in: [...DRIVABLE] } },
+            select: { id: true },
+        });
+    }
+    catch (err) {
+        log.error({ err, runId }, "could not list the children of a lost run");
+        return 0;
+    }
+    let stopped = 0;
+    for (const child of children) {
+        try {
+            await executor.stop(child.id, PARENT_LOST_REASON);
+            stopped++;
+        }
+        catch (err) {
+            log.error({ err, runId, childRunId: child.id }, "could not stop a child of a lost run");
+        }
+    }
+    return stopped;
+}

package/dist/core/mark-ready.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Marks a draft pull request Wardby's own App opened ready for review once it passes (#287):
+ * every Wardby review check on the head succeeded, CI is green, and the `wardby merge order`
+ * check is success or absent. Opt-in per write link (AgentRepository.markReadyWhenPassing) of
+ * the agent the repository event triggers: the builder that opened the pull request, or a lead
+ * that delegated to it (coding agents cannot link repositories, so a lead's link carries it).
+ * At most once per pull request (CodingRun.markedReadyAt on the opener's root coding run), so
+ * a person moving it back to draft is final. Cheap DB checks first; no host reads unless some
+ * link on the repository opted in.
+ *
+ * The host only confirms the pull request was authored by this App. The trust boundary is
+ * here: the pull request's marker must resolve (through rootCodingRunId) to a root coding run
+ * in this repository, recorded as this pull request, whose agent, or an ancestor agent in its
+ * run tree (Run.parentRunId, at most MAX_ANCESTOR_HOPS up), has an authorized, opted-in write
+ * link on this repository. An opted-in agent outside that run tree never counts. Only
+ * authorized links (authorizedVia set) count, for opting in and for review checks.
+ *
+ * Work a run stopped at its budget pushed (a draft to continue) is never marked ready.
+ *
+ * Never approves, merges, or converts back to draft. Never throws.
+ */
+import type { PrismaClient } from "#prisma";
+import type { ReviewHostRegistry } from "../providers/review-host/types.js";
+import type { Logger } from "./logger.js";
+export type MarkReadyOutcome = "marked" | "off" | "not_ready" | "skipped" | "failed";
+export type MarkReadyDb = Pick<PrismaClient, "agentRepository" | "codingRun" | "run" | "runHostCheck">;
+export interface MarkReadyDeps {
+    db: MarkReadyDb;
+    hosts: ReviewHostRegistry | undefined;
+    log?: Logger;
+}
+export declare function maybeMarkReady(deps: MarkReadyDeps, repository: string, prNumber: number, provider?: string): Promise<MarkReadyOutcome>;
+/** After a reviewer run ends: evaluate the pull request it reviewed. Null when it reviewed none. */
+export declare function markReadyAfterRun(deps: MarkReadyDeps, runId: string): Promise<MarkReadyOutcome | null>;