@wardby/cli 0.4.1 → 0.5.1

package/dist/core/host-events.js

@@ -1,8 +1,9 @@
-import { linkedPullRequestAttribution, RESPONSE_PATH_SNAPSHOT_BUDGET } from "./attribution.js";
+import { linkedPullRequestAttribution, openingRunAttribution, RESPONSE_PATH_SNAPSHOT_BUDGET } from "./attribution.js";
 import { checkContinuation, dispatchRun } from "./dispatch.js";
 import { mentionStatusRow, postMentionStatus } from "./host-status.js";
 import { handlePullRequestClosed } from "./issue-bridge.js";
 import { logger } from "./logger.js";
+import { MAX_SIBLING_HINTS, openSiblings, SIBLING_GUIDANCE } from "./related-pull-requests.js";
 import { requiredLevel } from "./repo-access.js";
 import { composeTaskOverride } from "./untrusted-content.js";
 import { DEFAULT_KNOWLEDGE_BUNDLE_PATH, parseConcept, RESERVED_BUNDLE_FILES, } from "../knowledge/concept.js";
@@ -11,7 +12,13 @@ import { spanHash } from "../knowledge/span-hash.js";
 const log = logger.child({ module: "host-events" });
 const MAX_TASK_BODY = 8000;
 const MAX_TITLE = 256;
-const HOST_NAMES = { github: "GitHub" };
+const HOST_NAMES = { github: "GitHub", local: "local repository" };
+/** A deferred review whose head's CI has not finished after this long is started anyway (by the reconciler sweep). */
+export const DEFERRED_REVIEW_MAX_WAIT_MS = 15 * 60_000;
+/** A deferred review row older than this is dropped without starting. */
+export const DEFERRED_REVIEW_MAX_AGE_MS = 24 * 60 * 60_000;
+/** Upper bound on deferred reviews the sweep starts per pass, so a backlog drains over several passes. */
+export const DEFERRED_REVIEW_BATCH = 50;
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -233,6 +240,36 @@ async function verifyCitations(host, event, concepts, budget) {
     }
     return statuses;
 }
+/** The exact phrase every continuation hint uses (a prompt may match it). */
+export function continuePriorRunPhrase(runId) {
+    return `pass continuePriorRun set to exactly "${runId}"`;
+}
+/** The continuation hint a router agent follows to continue a PR's branch instead of opening a new one. */
+export function continuationHint(prNumber, runId) {
+    return (`[This request is a follow-up on PR #${prNumber}, originally opened by wardby run ${runId}. ` +
+        `If you delegate, ${continuePriorRunPhrase(runId)} so the same PR/branch is ` +
+        `continued instead of opening a new one.]`);
+}
+const HINT_RUN_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+const HINT_REPOSITORY = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+/** One hint per open sibling (stored rows only; links built, ids re-validated), then the shared guidance. */
+export function siblingContinuationHints(siblings) {
+    const lines = siblings
+        .filter((s) => HINT_RUN_ID.test(s.openedByRunId) &&
+        HINT_REPOSITORY.test(s.repository) &&
+        Number.isSafeInteger(s.number) &&
+        s.number > 0)
+        .slice(0, MAX_SIBLING_HINTS)
+        .map((s) => `- ${s.repository}#${s.number} (https://github.com/${s.repository}/pull/${s.number}): to change it, ` +
+        `delegate to that repository's coding agent and ${continuePriorRunPhrase(s.openedByRunId)}.`);
+    if (lines.length === 0)
+        return undefined;
+    return [
+        "[This pull request is one of a set wardby opened for the same request. The set's other open pull requests:",
+        ...lines,
+        `${SIBLING_GUIDANCE}]`,
+    ].join("\n");
+}
 /**
  * The mention agent's task text. Deterministic so a prompt can parse it.
  *
@@ -249,15 +286,16 @@ async function verifyCitations(host, event, concepts, budget) {
  * never in the system prompt. composeTaskOverride stores both in the one
  * taskOverride column.
  */
-export function mentionTaskText(event) {
+export function mentionTaskText(event, siblings = []) {
     const kind = event.isPullRequest ? "PR" : "issue";
     const Kind = event.isPullRequest ? "PR" : "Issue";
     const inSubject = event.comment.kind === "subject";
     const sections = [];
     if (event.priorRunId) {
-        sections.push(`[This request is a follow-up on PR #${event.number}, originally opened by wardby run ${event.priorRunId}. ` +
-            `If you delegate, pass continuePriorRun set to exactly "${event.priorRunId}" so the same PR/branch is ` +
-            `continued instead of opening a new one.]`);
+        sections.push(continuationHint(event.number, event.priorRunId));
+        const hints = siblingContinuationHints(siblings);
+        if (hints)
+            sections.push(hints);
     }
     const title = event.subject?.title.replace(/\s+/g, " ").trim().slice(0, MAX_TITLE);
     const description = event.subject?.body.trim() ? event.subject.body.slice(0, MAX_TASK_BODY) : "";
@@ -329,7 +367,23 @@ skipReviewedCommits = false) {
     // One lookup per PR, not per reviewer, and none at all when every reviewer
     // skips this commit: taken at the first actual dispatch.
     let attribution;
-    const linkedAttribution = () => (attribution ??= linkedPullRequestAttribution(deps.db, deps.issueTrackers, { codeProvider: host.provider, repository, number: prNumber }, RESPONSE_PATH_SNAPSHOT_BUDGET));
+    const linkedAttribution = () => (attribution ??= (async () => {
+        const linked = await linkedPullRequestAttribution(deps.db, deps.issueTrackers, { codeProvider: host.provider, repository, number: prNumber }, RESPONSE_PATH_SNAPSHOT_BUDGET);
+        if (linked || !host.pullRequestOrigin)
+            return linked;
+        // Not linked to an issue yet (the lead run that opened it may still be
+        // running): attribute to the issue of the run whose marker the PR carries.
+        try {
+            const origin = await host.pullRequestOrigin(repository, prNumber);
+            return origin.markerRunId
+                ? await openingRunAttribution(deps.db, deps.issueTrackers, origin.markerRunId, RESPONSE_PATH_SNAPSHOT_BUDGET)
+                : undefined;
+        }
+        catch (err) {
+            log.warn({ err, repository, prNumber }, "could not read the pull request's opening run; the review is unattributed");
+            return undefined;
+        }
+    })());
     for (const target of targets) {
         if (skipReviewedCommits && (await alreadyReviewed(deps, repository, prNumber, headSha, target.agentId))) {
             log.info({ repository, prNumber, agentId: target.agentId, headSha }, "review skipped: this commit was already reviewed");
@@ -382,6 +436,62 @@ skipReviewedCommits = false) {
     }
     return runIds;
 }
+/**
+ * CI finished on a pull request's head: re-runs, once per head, each review
+ * that published only a COMMENT while CI there was still running or had not
+ * reported (RunHostCheck.ciPendingAtReview). Waits for the last suite: while
+ * any CI on the head is still pending, a later completion decides. Never
+ * throws; a failure is logged and the delivery is not retried.
+ */
+async function rereviewAfterCi(deps, host, event, prNumber, reviewerLinks) {
+    try {
+        if (!host.readCi)
+            return [];
+        const onHead = await deps.db.runHostCheck.findMany({
+            where: { provider: event.provider, repository: event.repository, prNumber, headSha: event.headSha },
+            select: {
+                runId: true,
+                verdict: true,
+                ciPendingAtReview: true,
+                ciRereviewAt: true,
+                run: { select: { agentId: true } },
+            },
+        });
+        // Once per head and reviewer: an agent already re-run here is never re-run again on it.
+        const rerun = new Set(onHead.filter((r) => r.ciRereviewAt !== null).map((r) => r.run.agentId));
+        const waiting = onHead.filter((r) => r.verdict === "COMMENT" && r.ciPendingAtReview === true && !rerun.has(r.run.agentId));
+        if (waiting.length === 0)
+            return [];
+        const head = await host.pullRequestHead(event.repository, prNumber);
+        if (head.isFork || head.state !== "open" || head.headSha !== event.headSha)
+            return [];
+        const ci = await host.readCi(event.repository, event.headSha);
+        if (ci.state === "pending" || ci.state === "none" || ci.state === "unavailable")
+            return [];
+        // Only reviewers still authorized are claimed, so a denied one keeps its chance for later.
+        const allowed = await authorizedLinks(deps, event, reviewerLinks.filter((l) => waiting.some((r) => r.run.agentId === l.agentId)));
+        const allowedIds = new Set(allowed.map((l) => l.agentId));
+        // Claimed per row, so concurrent completions re-run each review only once.
+        const agentIds = new Set();
+        for (const row of waiting.filter((r) => allowedIds.has(r.run.agentId))) {
+            const claimed = await deps.db.runHostCheck.updateMany({
+                where: { runId: row.runId, ciRereviewAt: null },
+                data: { ciRereviewAt: new Date() },
+            });
+            if (claimed.count > 0)
+                agentIds.add(row.run.agentId);
+        }
+        if (agentIds.size === 0)
+            return [];
+        const targets = reviewTargets(allowed.filter((l) => agentIds.has(l.agentId)));
+        log.info({ repository: event.repository, prNumber, headSha: event.headSha, ci: ci.state }, "CI finished: re-running the review");
+        return await startReviews(deps, host, event.repository, prNumber, event.headSha, targets);
+    }
+    catch (err) {
+        log.warn({ err, repository: event.repository, prNumber }, "could not re-run the review after CI finished");
+        return [];
+    }
+}
 /**
  * Keeps only the links the gate still authorizes: the agent must have an
  * owner, and the owner's current access (or a recorded admin/grandfathered
@@ -406,6 +516,222 @@ async function authorizedLinks(deps, event, links) {
     return kept;
 }
 const reviewTargets = (links) => links.map((l) => ({ agentId: l.agentId, checkName: l.checkName }));
+/** A link that reviews pull requests: write access, the pull_request trigger, and a check to report on. */
+const isReviewerLink = (l) => l.access === "write" && l.triggers.includes("pull_request") && Boolean(l.checkName);
+async function loadLinks(deps, provider, repository) {
+    return (await deps.db.agentRepository.findMany({
+        where: { provider, repository },
+        include: { agent: { select: { ownerId: true } } },
+    }));
+}
+/** CI states that mean "not finished yet" when a head is pushed; `none` also covers checks not registered yet. */
+const CI_NOT_FINISHED_ON_PUSH = new Set(["pending", "none"]);
+/**
+ * pr_updated for reviewers linked with waitForCi: reads CI on the head once.
+ * While it is pending (or nothing has reported yet), records one
+ * DeferredReview row per reviewer and starts nothing; ci_completed, or the
+ * reconciler sweep after DEFERRED_REVIEW_MAX_WAIT_MS, starts it later; CI is
+ * read once more after recording, in case it finished in between. Returns the
+ * links to start now (all of them when CI has already finished, cannot be
+ * read, or the deferral cannot be recorded: as without waitForCi) and the runs
+ * the re-read started.
+ */
+async function deferUntilCi(deps, host, key, links) {
+    const now = { startNow: links, runIds: [] };
+    if (links.length === 0 || !host.readCi)
+        return now;
+    let state;
+    try {
+        state = (await host.readCi(key.repository, key.headSha)).state;
+    }
+    catch (err) {
+        log.warn({ err, repository: key.repository, prNumber: key.prNumber }, "could not read CI; reviewing now");
+        return now;
+    }
+    if (!CI_NOT_FINISHED_ON_PUSH.has(state))
+        return now;
+    try {
+        // Idempotent per head and reviewer: a repeated delivery or a second push event for the same head adds nothing.
+        await deps.db.deferredReview.createMany({
+            data: links.map((l) => ({
+                provider: key.provider,
+                repository: key.repository,
+                prNumber: key.prNumber,
+                headSha: key.headSha,
+                agentId: l.agentId,
+                checkName: l.checkName,
+            })),
+            skipDuplicates: true,
+        });
+    }
+    catch (err) {
+        log.warn({ err, repository: key.repository, prNumber: key.prNumber }, "could not record the deferred review; reviewing now");
+        return now;
+    }
+    log.info({
+        repository: key.repository,
+        prNumber: key.prNumber,
+        headSha: key.headSha,
+        ci: state,
+        agentIds: links.map((l) => l.agentId),
+    }, "review deferred until CI finishes");
+    // CI may have finished between the read above and the insert, with its
+    // ci_completed delivery finding no row yet: read once more and, if it has,
+    // start now (claimed by delete, so a racing delivery starts it once). A
+    // failure leaves the rows for the sweep.
+    const runIds = [];
+    try {
+        const again = (await host.readCi(key.repository, key.headSha)).state;
+        if (!CI_NOT_FINISHED_ON_PUSH.has(again)) {
+            const rows = await deps.db.deferredReview.findMany({
+                where: {
+                    provider: key.provider,
+                    repository: key.repository,
+                    prNumber: key.prNumber,
+                    headSha: key.headSha,
+                    agentId: { in: links.map((l) => l.agentId) },
+                },
+                select: { id: true, agentId: true, checkName: true },
+            });
+            if (rows.length > 0)
+                runIds.push(...(await startDeferred(deps, host, key, rows, links, "ci", "CI finished")));
+        }
+    }
+    catch (err) {
+        log.warn({ err, repository: key.repository, prNumber: key.prNumber }, "could not re-read CI after deferring; the sweep starts the review");
+    }
+    return { startNow: [], runIds };
+}
+/**
+ * Starts deferred reviews for one PR head. The head must still be that sha,
+ * open, and not a fork; otherwise every row is dropped (a newer push records
+ * its own). Each row is claimed by deleting it, so a concurrent ci_completed
+ * delivery or sweep starts each review only once. On `ci`, only reviewers
+ * still authorized are claimed (the rest wait for the sweep); on `sweep` (the
+ * last attempt) every row is claimed and unauthorized or unlinked reviewers
+ * are dropped.
+ */
+async function startDeferred(deps, host, key, rows, reviewerLinks, mode, reason) {
+    const where = { repository: key.repository, prNumber: key.prNumber, headSha: key.headSha };
+    const head = await host.pullRequestHead(key.repository, key.prNumber);
+    if (head.isFork || head.state !== "open" || head.headSha !== key.headSha) {
+        await deps.db.deferredReview.deleteMany({ where: { id: { in: rows.map((r) => r.id) } } });
+        log.info({ ...where, state: head.state }, "deferred review dropped: the pull request moved on or closed");
+        return [];
+    }
+    const allowed = await authorizedLinks(deps, key, reviewerLinks.filter((l) => rows.some((r) => r.agentId === l.agentId)));
+    const allowedIds = new Set(allowed.map((l) => l.agentId));
+    const targets = [];
+    for (const row of rows) {
+        if (mode === "ci" && !allowedIds.has(row.agentId))
+            continue;
+        const claimed = await deps.db.deferredReview.deleteMany({ where: { id: row.id } });
+        if (claimed.count !== 1)
+            continue;
+        if (allowedIds.has(row.agentId))
+            targets.push({ agentId: row.agentId, checkName: row.checkName });
+        else
+            log.info({ ...where, agentId: row.agentId }, "deferred review dropped: the reviewer is no longer linked or authorized");
+    }
+    if (targets.length === 0)
+        return [];
+    log.info({ ...where, agentIds: targets.map((t) => t.agentId), reason }, "starting the deferred review");
+    try {
+        return await startReviews(deps, host, key.repository, key.prNumber, key.headSha, targets, true);
+    }
+    catch (err) {
+        // The rows are already claimed (at most once): make the lost start visible.
+        log.warn({ err, ...where, agentIds: targets.map((t) => t.agentId) }, "claimed deferred reviews could not be started");
+        return [];
+    }
+}
+/**
+ * ci_completed: starts the reviews deferred on this head (see deferUntilCi),
+ * unless CI there is still pending (a later completion decides). Never
+ * throws; a failure is logged and the rows stay for the reconciler sweep.
+ */
+async function startDeferredAfterCi(deps, host, event, prNumber, reviewerLinks) {
+    try {
+        const key = { provider: event.provider, repository: event.repository, prNumber, headSha: event.headSha };
+        const rows = await deps.db.deferredReview.findMany({
+            where: key,
+            select: { id: true, agentId: true, checkName: true },
+        });
+        if (rows.length === 0)
+            return [];
+        if (host.readCi) {
+            const ci = await host.readCi(event.repository, event.headSha);
+            if (ci.state === "pending")
+                return [];
+        }
+        return await startDeferred(deps, host, key, rows, reviewerLinks, "ci", "CI finished");
+    }
+    catch (err) {
+        log.warn({ err, repository: event.repository, prNumber }, "could not start the deferred review after CI finished");
+        return [];
+    }
+}
+/**
+ * The reconciler's fallback for deferred reviews: drops rows older than
+ * DEFERRED_REVIEW_MAX_AGE_MS, and starts (regardless of CI) those waiting
+ * longer than DEFERRED_REVIEW_MAX_WAIT_MS, at most DEFERRED_REVIEW_BATCH per
+ * pass, oldest first. Covers CI that never reported, ran very long, or whose
+ * completion webhook was missed. Never throws; returns the runs started.
+ */
+export async function startDeferredReviews(deps, now = new Date()) {
+    const runIds = [];
+    try {
+        const expired = await deps.db.deferredReview.deleteMany({
+            where: { createdAt: { lt: new Date(now.getTime() - DEFERRED_REVIEW_MAX_AGE_MS) } },
+        });
+        if (expired.count > 0)
+            log.info({ count: expired.count }, "dropped deferred reviews older than 24 h");
+        const providers = Object.keys(deps.hosts);
+        if (providers.length === 0)
+            return runIds;
+        const due = await deps.db.deferredReview.findMany({
+            where: {
+                provider: { in: providers },
+                createdAt: { lte: new Date(now.getTime() - DEFERRED_REVIEW_MAX_WAIT_MS) },
+            },
+            select: {
+                id: true,
+                provider: true,
+                repository: true,
+                prNumber: true,
+                headSha: true,
+                agentId: true,
+                checkName: true,
+            },
+            orderBy: { createdAt: "asc" },
+            take: DEFERRED_REVIEW_BATCH,
+        });
+        const groups = new Map();
+        for (const row of due) {
+            const id = JSON.stringify([row.provider, row.repository, row.prNumber, row.headSha]);
+            groups.set(id, [...(groups.get(id) ?? []), row]);
+        }
+        for (const rows of groups.values()) {
+            const first = rows[0];
+            const provider = first.provider;
+            const key = { provider, repository: first.repository, prNumber: first.prNumber, headSha: first.headSha };
+            const host = deps.hosts[provider];
+            if (!host)
+                continue;
+            try {
+                const reviewerLinks = (await loadLinks(deps, provider, key.repository)).filter(isReviewerLink);
+                runIds.push(...(await startDeferred(deps, host, key, rows, reviewerLinks, "sweep", "CI did not finish within 15 min")));
+            }
+            catch (err) {
+                log.warn({ err, repository: key.repository, prNumber: key.prNumber }, "could not start a deferred review");
+            }
+        }
+    }
+    catch (err) {
+        log.warn({ err }, "deferred review sweep failed");
+    }
+    return runIds;
+}
 export async function routeHostEvent(event, deps) {
     const none = { runIds: [], followUps: [] };
     if (event.kind === "pr_closed") {
@@ -421,11 +747,8 @@ export async function routeHostEvent(event, deps) {
     const host = deps.hosts[event.provider];
     if (!host)
         return none;
-    const links = (await deps.db.agentRepository.findMany({
-        where: { provider: event.provider, repository: event.repository },
-        include: { agent: { select: { ownerId: true } } },
-    }));
-    const reviewerLinks = links.filter((l) => l.access === "write" && l.triggers.includes("pull_request") && l.checkName);
+    const links = await loadLinks(deps, event.provider, event.repository);
+    const reviewerLinks = links.filter(isReviewerLink);
     switch (event.kind) {
         case "push": {
             const watchers = await authorizedLinks(deps, event, links.filter((l) => l.access === "write" && l.triggers.includes("push")));
@@ -495,13 +818,28 @@ export async function routeHostEvent(event, deps) {
         case "pr_updated": {
             if (event.isFork || reviewerLinks.length === 0)
                 return none;
-            const reviewers = reviewTargets(await authorizedLinks(deps, event, reviewerLinks));
-            if (reviewers.length === 0)
+            const allowed = await authorizedLinks(deps, event, reviewerLinks);
+            if (allowed.length === 0)
                 return none;
-            return {
-                runIds: await startReviews(deps, host, event.repository, event.prNumber, event.headSha, reviewers, true),
-                followUps: [],
-            };
+            // Reviewers linked with waitForCi review this head only once its CI finished.
+            const deferral = await deferUntilCi(deps, host, event, allowed.filter((l) => l.waitForCi));
+            const startNow = new Set(deferral.startNow);
+            const reviewers = reviewTargets(allowed.filter((l) => !l.waitForCi || startNow.has(l)));
+            const runIds = [...deferral.runIds];
+            if (reviewers.length > 0) {
+                runIds.push(...(await startReviews(deps, host, event.repository, event.prNumber, event.headSha, reviewers, true)));
+            }
+            return { runIds, followUps: [] };
+        }
+        case "ci_completed": {
+            if (reviewerLinks.length === 0)
+                return none;
+            const runIds = [];
+            for (const prNumber of event.prNumbers) {
+                runIds.push(...(await rereviewAfterCi(deps, host, event, prNumber, reviewerLinks)));
+                runIds.push(...(await startDeferredAfterCi(deps, host, event, prNumber, reviewerLinks)));
+            }
+            return { runIds, followUps: [] };
         }
         case "check_rerun": {
             const owners = reviewerLinks.filter((l) => l.checkName === event.checkName);
@@ -570,13 +908,17 @@ export async function routeHostEvent(event, deps) {
                 };
                 return { runIds: [], followUps: [react, reply] };
             }
+            // Seeded from the PR's validated marker run: the request it belongs to. Stored state only.
+            const siblings = event.isPullRequest && event.priorRunId
+                ? await openSiblings(deps.db, event.priorRunId, { repository: event.repository, number: event.number })
+                : [];
             const dispatched = await dispatchRun({
                 db: deps.db,
                 executor: deps.executor,
                 selfDefects: { db: deps.db, issueTrackers: deps.issueTrackers },
                 agentId: allowed[0].agentId,
                 trigger: "host_event",
-                taskOverride: mentionTaskText(event),
+                taskOverride: mentionTaskText(event, siblings),
                 attribution: event.isPullRequest
                     ? await linkedPullRequestAttribution(deps.db, deps.issueTrackers, { codeProvider: host.provider, repository: event.repository, number: event.number }, RESPONSE_PATH_SNAPSHOT_BUDGET)
                     : undefined,

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

@@ -8,8 +8,10 @@
  * died first, say) still gets one: the reconciler posts the outcome as a new
  * comment. Best effort throughout: nothing here throws.
  */
-import type { Prisma, PrismaClient, Run } from "#prisma";
+import type { Prisma, PrismaClient, Run, RunStatus } from "#prisma";
 import type { CodeReviewHost, ReviewHostProvider, ReviewHostRegistry } from "../providers/review-host/types.js";
+/** The run statuses a run never leaves. */
+export declare const TERMINAL_RUN_STATUSES: readonly RunStatus[];
 export type HostStatusDb = Pick<PrismaClient, "runHostStatus" | "run">;
 export type FinishedRun = Pick<Run, "id" | "status" | "finalText">;
 /** The parts of a CodingRun result this comment uses. */
@@ -23,6 +25,8 @@ export interface PullRequestOutcome {
     codeProvider: string;
     /** The coding sub-run that produced it; set by collectRunOutcome. */
     runId?: string;
+    /** How many of the run's own checks (result.tests) failed; the commands stay in the PR body. */
+    failedChecks?: number;
 }
 /** A sub-run that ended without succeeding. */
 export interface FailedChild {
@@ -36,13 +40,14 @@ export interface FailedChild {
     services?: string[];
 }
 export declare const runLine: (runId: string) => string;
-export declare function workingBody(runId: string): string;
+export declare function workingBody(runId: string, heading?: string): string;
 /** The status row for a mention run, created in the same transaction as the run. */
 export declare function mentionStatusRow(provider: ReviewHostProvider, event: {
     repository: string;
     number: number;
     replyToReviewCommentId?: string;
 }, runId: string): Prisma.RunHostStatusUncheckedCreateInput;
+export declare function pullRequestOutcome(result: unknown): PullRequestOutcome | null;
 export declare function outcomeBody(run: FinishedRun, repository: string, pullRequests: PullRequestOutcome[], failedChildren?: FailedChild[], opts?: {
     budgetSentence?: string;
     noPullRequestText?: string;
@@ -75,4 +80,4 @@ export declare function completeHostStatus(db: HostStatusDb, run: FinishedRun, h
  * once. Does nothing when the row is gone, already has a comment, or is
  * already complete. Never throws.
  */
-export declare function postMentionStatus(db: HostStatusDb, host: CodeReviewHost, runId: string, hosts: ReviewHostRegistry | undefined): Promise<void>;
+export declare function postMentionStatus(db: HostStatusDb, host: CodeReviewHost, runId: string, hosts: ReviewHostRegistry | undefined, heading?: string): Promise<void>;

package/dist/core/host-status.js

@@ -2,16 +2,26 @@ import { CODING_CODE_PROVIDER } from "../coding/protocol.js";
 import { storedServiceNames } from "../coding/services/catalog.js";
 import { SERVICE_UNREADY_CATEGORY, serviceRefusalSentence, serviceUnreadySentence, } from "../coding/services/wording.js";
 import { PROTECTED_PATH_CATEGORY, PROTECTED_PATH_HOST_LINE } from "../coding/protected-path-wording.js";
+import { CONTINUATION_CLOSED_CATEGORY, CONTINUATION_CLOSED_HOST_LINE } from "../coding/continuation-wording.js";
 import { loadBudgetSentence } from "./budget-wording.js";
 import { logger } from "./logger.js";
 import { providerClassOfCategory, providerSentence } from "./provider-wording.js";
 const log = logger.child({ module: "host-status" });
 /** Keeps the edited comment readable; the full reply stays on the run. */
 const MAX_REPLY_CHARS = 2000;
-const TERMINAL = new Set(["succeeded", "failed", "refused", "lost", "budget_exhausted", "cancelled"]);
+/** The run statuses a run never leaves. */
+export const TERMINAL_RUN_STATUSES = [
+    "succeeded",
+    "failed",
+    "refused",
+    "lost",
+    "budget_exhausted",
+    "cancelled",
+];
+const TERMINAL = new Set(TERMINAL_RUN_STATUSES);
 export const runLine = (runId) => `<sub>wardby run \`${runId}\`</sub>`;
-export function workingBody(runId) {
-    return `👀 Working on it.\n\n${runLine(runId)}`;
+export function workingBody(runId, heading = "👀 Working on it.") {
+    return `${heading}\n\n${runLine(runId)}`;
 }
 /** The status row for a mention run, created in the same transaction as the run. */
 export function mentionStatusRow(provider, event, runId) {
@@ -24,7 +34,7 @@ export function mentionStatusRow(provider, event, runId) {
         replyToReviewCommentId: event.replyToReviewCommentId ?? null,
     };
 }
-function pullRequestOutcome(result) {
+export function pullRequestOutcome(result) {
     if (!result || typeof result !== "object")
         return null;
     const r = result;
@@ -40,8 +50,16 @@ function pullRequestOutcome(result) {
         pullRequestNumber: r.pullRequestNumber,
         codeProvider: CODING_CODE_PROVIDER,
         ...(typeof r.pullRequestUrl === "string" ? { pullRequestUrl: r.pullRequestUrl } : {}),
+        ...failedCheckCount(r.tests),
     };
 }
+/** Only a count reaches the comment: test commands are agent-authored and belong in the PR body. */
+function failedCheckCount(tests) {
+    if (!Array.isArray(tests))
+        return {};
+    const failed = tests.filter((t) => t && typeof t === "object" && t.outcome === "failed").length;
+    return failed > 0 ? { failedChecks: failed } : {};
+}
 /** The agent's reply as a quote, cut to MAX_REPLY_CHARS, with @-mentions defused so nobody is pinged. */
 const cutReply = (text) => text.length > MAX_REPLY_CHARS ? `${text.slice(0, MAX_REPLY_CHARS)}…` : text;
 function quoteReply(text) {
@@ -85,13 +103,19 @@ export function outcomeBody(run, repository, pullRequests, failedChildren = [],
                 : null;
         // No path reaches this comment (see coding/protected-path-wording.ts), only the category.
         const protectedPathOf = (c) => c.status === "failed" && c.failureCategory === PROTECTED_PATH_CATEGORY;
+        // A continuation whose PR closed before the sub-run ever spent anything
+        // is stored as "refused" (a preflight refusal), not "failed" -- the
+        // category is the same either way, so both statuses are recognised here.
+        const continuationClosedOf = (c) => (c.status === "failed" || c.status === "refused") && c.failureCategory === CONTINUATION_CLOSED_CATEGORY;
         const providerClasses = new Set(failedChildren.map(providerClassOf).filter((c) => c !== null));
         const serviceSentences = new Set(failedChildren.map(serviceSentenceOf).filter((s) => s !== null));
         const protectedPathFailed = failedChildren.some(protectedPathOf);
+        const continuationClosedFailed = failedChildren.some(continuationClosedOf);
         const other = failedChildren.filter((c) => c.status !== "budget_exhausted" &&
             providerClassOf(c) === null &&
             serviceSentenceOf(c) === null &&
-            !protectedPathOf(c));
+            !protectedPathOf(c) &&
+            !continuationClosedOf(c));
         const lines = [];
         if (outOfBudget.length > 0) {
             lines.push(`A sub-run ran out of budget: ${outOfBudget.map((c) => `\`${c.id}\``).join(", ")}.`);
@@ -106,11 +130,18 @@ export function outcomeBody(run, repository, pullRequests, failedChildren = [],
         }
         if (protectedPathFailed)
             lines.push(PROTECTED_PATH_HOST_LINE);
+        if (continuationClosedFailed)
+            lines.push(CONTINUATION_CLOSED_HOST_LINE);
         if (other.length > 0) {
             lines.push(`A sub-run did not succeed: ${other.map((c) => `\`${c.id}\` (\`${c.status}\`)`).join(", ")}.`);
         }
         return `❌ ${lines.join(" ")}${partial}${quoted}\n\n${footer}`;
     }
+    const failedChecks = pullRequests.reduce((sum, pr) => sum + (pr.failedChecks ?? 0), 0);
+    if (links.length > 0 && failedChecks > 0) {
+        const checks = failedChecks === 1 ? "1 check" : `${failedChecks} checks`;
+        return `⚠️ ${links.join(", ")}, but ${checks} failed in the run: see the pull request's description before merging.\n\n${footer}`;
+    }
     if (links.length > 0)
         return `✅ ${links.join(", ")}.\n\n${footer}`;
     if (opts.replyAsAnswer && reply)
@@ -199,14 +230,14 @@ export async function completeHostStatus(db, run, hosts, opts = {}) {
  * once. Does nothing when the row is gone, already has a comment, or is
  * already complete. Never throws.
  */
-export async function postMentionStatus(db, host, runId, hosts) {
+export async function postMentionStatus(db, host, runId, hosts, heading) {
     try {
         const status = await db.runHostStatus.findUnique({ where: { runId } });
         if (!status || status.commentId || status.completedAt)
             return;
         const posted = await host.comment(status.repository, {
             number: status.number,
-            body: workingBody(runId),
+            body: workingBody(runId, heading),
             ...(status.replyToReviewCommentId ? { replyToReviewCommentId: status.replyToReviewCommentId } : {}),
         });
         const claimed = await db.runHostStatus.updateMany({

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

@@ -11,6 +11,7 @@ import type { PrismaClient } from "#prisma";
 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 interface RouteIssueEventDeps {
     db: IssueEventDb;
@@ -21,12 +22,7 @@ export interface RouteResult {
     runIds: string[];
     followUps: Array<() => Promise<void>>;
 }
-export interface OpenIssuePr {
-    repository: string;
-    number: number;
-    url: string;
-    openedByRunId: string;
-}
+export type OpenIssuePr = OpenSibling;
 type TaskLink = {
     triggerLabels: string[];
     trustedAccountIds: string[];