@wardby/cli 0.6.0 → 0.7.0

package/dist/core/mark-ready.js

@@ -0,0 +1,152 @@
+import { lastPusher } from "./budget-stopped-head.js";
+import { pullRequestOutcome } from "./host-status.js";
+import { MERGE_ORDER_CHECK_NAME } from "./merge-order-check.js";
+const CI_GREEN = new Set(["passing", "none"]);
+/** How far up the run tree (Run.parentRunId) the opt-in may come from. */
+const MAX_ANCESTOR_HOPS = 10;
+const CODING_RUN_SELECT = {
+    runId: true,
+    repository: true,
+    rootCodingRunId: true,
+    markedReadyAt: true,
+    result: true,
+    run: { select: { agentId: true, parentRunId: true, status: true } },
+};
+const passed = (c) => c !== undefined && c.status === "completed" && c.conclusion === "success";
+export async function maybeMarkReady(deps, repository, prNumber, provider = "github") {
+    try {
+        const host = deps.hosts?.[provider];
+        if (!host?.pullRequestOrigin || !host.readOwnChecks || !host.readCi || !host.markReadyForReview)
+            return "off";
+        const links = await deps.db.agentRepository.findMany({
+            where: { provider, repository },
+            select: {
+                agentId: true,
+                access: true,
+                triggers: true,
+                checkName: true,
+                markReadyWhenPassing: true,
+                authorizedVia: true,
+            },
+        });
+        const optedIn = new Set(links
+            .filter((l) => l.access === "write" && l.authorizedVia !== null && l.markReadyWhenPassing)
+            .map((l) => l.agentId));
+        if (optedIn.size === 0)
+            return "off";
+        const reviewChecks = links
+            .filter((l) => l.access === "write" && l.authorizedVia !== null && l.triggers.includes("pull_request") && l.checkName)
+            .map((l) => l.checkName);
+        if (reviewChecks.length === 0)
+            return "not_ready";
+        // readOwnChecks reads at most 10 names; MERGE_ORDER_CHECK_NAME plus the reviewer
+        // check names must fit, or the merge-order check would silently be read as absent.
+        if (reviewChecks.length > 9)
+            return "not_ready";
+        const origin = await host.pullRequestOrigin(repository, prNumber);
+        if (origin.state !== "open" || origin.draft !== true || origin.isFork || !origin.markerRunId)
+            return "not_ready";
+        const marked = await deps.db.codingRun.findUnique({
+            where: { runId: origin.markerRunId },
+            select: CODING_RUN_SELECT,
+        });
+        if (!marked)
+            return "not_ready";
+        const root = marked.rootCodingRunId
+            ? await deps.db.codingRun.findUnique({ where: { runId: marked.rootCodingRunId }, select: CODING_RUN_SELECT })
+            : marked;
+        if (!root || root.repository.toLowerCase() !== repository.toLowerCase())
+            return "not_ready";
+        if (pullRequestOutcome(root.result)?.pullRequestNumber !== prNumber)
+            return "not_ready";
+        if (!(await optedInInRunTree(deps.db, root.run, optedIn)))
+            return "not_ready";
+        if (root.markedReadyAt)
+            return "skipped";
+        if (await lastPushStoppedAtBudget(deps.db, root, prNumber))
+            return "not_ready";
+        const checks = await host.readOwnChecks(repository, origin.headSha, [MERGE_ORDER_CHECK_NAME, ...reviewChecks]);
+        if (!reviewChecks.every((name) => passed(checks.get(name))))
+            return "not_ready";
+        const order = checks.get(MERGE_ORDER_CHECK_NAME);
+        if (order !== undefined && !passed(order))
+            return "not_ready";
+        const ci = await host.readCi(repository, origin.headSha);
+        if (!CI_GREEN.has(ci.state) || ci.truncated)
+            return "not_ready";
+        const claimedAt = new Date();
+        // CodingRun.updatedAt is @updatedAt, so this claim (and a release below) bumps it, which
+        // feeds the merge-order sweep's ordering. Harmless: the sweep re-derives state from the
+        // host each time, it doesn't rely on updatedAt being untouched by mark-ready.
+        const claim = await deps.db.codingRun.updateMany({
+            where: { runId: root.runId, markedReadyAt: null },
+            data: { markedReadyAt: claimedAt },
+        });
+        if (claim.count === 0)
+            return "skipped";
+        const release = () => deps.db.codingRun
+            .updateMany({ where: { runId: root.runId, markedReadyAt: claimedAt }, data: { markedReadyAt: null } })
+            .catch((err) => deps.log?.warn({ err, repository, prNumber }, "could not release the mark-ready claim"));
+        try {
+            const result = await host.markReadyForReview(repository, prNumber, origin.headSha, origin.markerRunId);
+            if (result === "marked") {
+                deps.log?.info({ repository, prNumber }, "marked the pull request ready for review");
+                return "marked";
+            }
+            await release();
+            return "skipped";
+        }
+        catch (err) {
+            await release();
+            throw err;
+        }
+    }
+    catch (err) {
+        deps.log?.warn({ err, repository, prNumber }, "could not mark the pull request ready for review");
+        return "failed";
+    }
+}
+/**
+ * Whether the last run that pushed to the pull request (the root, or a later continuation of it)
+ * stopped at its budget: its pushed changes are unfinished work, so the draft stays a draft. A
+ * continuation that finished the work makes it eligible again.
+ */
+async function lastPushStoppedAtBudget(db, root, prNumber) {
+    return (await lastPusher(db, root, prNumber)).status === "budget_exhausted";
+}
+/**
+ * True when the opener's agent, or an agent up its run tree (bounded, cycle-safe), is opted in.
+ * A coding run's parentRunId is set when a lead delegated to it.
+ */
+async function optedInInRunTree(db, opener, optedIn) {
+    if (optedIn.has(opener.agentId))
+        return true;
+    const seen = new Set();
+    let next = opener.parentRunId ?? null;
+    for (let hop = 0; next && hop < MAX_ANCESTOR_HOPS && !seen.has(next); hop++) {
+        seen.add(next);
+        const run = await db.run.findUnique({ where: { id: next }, select: { agentId: true, parentRunId: true } });
+        if (!run)
+            return false;
+        if (optedIn.has(run.agentId))
+            return true;
+        next = run.parentRunId;
+    }
+    return false;
+}
+/** After a reviewer run ends: evaluate the pull request it reviewed. Null when it reviewed none. */
+export async function markReadyAfterRun(deps, runId) {
+    try {
+        const row = await deps.db.runHostCheck.findUnique({
+            where: { runId },
+            select: { provider: true, repository: true, prNumber: true, verdict: true },
+        });
+        if (!row || row.prNumber === null || !row.verdict)
+            return null;
+        return await maybeMarkReady(deps, row.repository, row.prNumber, row.provider);
+    }
+    catch (err) {
+        deps.log?.warn({ err, runId }, "could not evaluate mark-ready after the run");
+        return "failed";
+    }
+}

package/dist/core/markdown-code.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GitHub-flavoured Markdown with its code removed, so a mention quoted in code
+ * (`` `@app` ``, a fenced or indented block) is documentation, not a request.
+ * Close to CommonMark, not a full parser: when in doubt it keeps text, so a
+ * real mention is never lost to an odd construct.
+ */
+/** `markdown` without its code blocks and inline code spans. */
+export declare function withoutMarkdownCode(markdown: string): string;

package/dist/core/markdown-code.js

@@ -0,0 +1,107 @@
+/**
+ * GitHub-flavoured Markdown with its code removed, so a mention quoted in code
+ * (`` `@app` ``, a fenced or indented block) is documentation, not a request.
+ * Close to CommonMark, not a full parser: when in doubt it keeps text, so a
+ * real mention is never lost to an odd construct.
+ */
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+const INDENTED = /^(?: {4}|\t)/;
+const LIST_ITEM = /^ {0,3}(?:[-*+]|\d{1,9}[.)])(?:\s|$)/;
+const BLANK = /^\s*$/;
+/** Up to three spaces, at least the opening run of the fence's character, then only whitespace. */
+function closesFence(line, fence) {
+    let index = 0;
+    while (index < 3 && line[index] === " ")
+        index += 1;
+    const start = index;
+    while (line[index] === fence.char)
+        index += 1;
+    return index - start >= fence.length && line.slice(index).trim() === "";
+}
+/** Fenced and indented code blocks blanked out, line count kept. */
+function withoutCodeBlocks(markdown) {
+    const out = [];
+    let fence = null;
+    // Indented code needs a blank line before it, and indented text under a
+    // list item is the item's paragraph, not code.
+    let previousBlank = true;
+    let inIndentedCode = false;
+    let inList = false;
+    for (const line of markdown.split(/\r?\n/)) {
+        if (fence) {
+            if (closesFence(line, fence))
+                fence = null;
+            out.push("");
+            continue;
+        }
+        const open = FENCE_OPEN.exec(line);
+        // A backtick fence's info string cannot contain a backtick (CommonMark).
+        if (open && !(open[1][0] === "`" && line.slice(line.indexOf(open[1]) + open[1].length).includes("`"))) {
+            fence = { char: open[1][0], length: open[1].length };
+            inIndentedCode = false;
+            previousBlank = false;
+            out.push("");
+            continue;
+        }
+        if (BLANK.test(line)) {
+            previousBlank = true;
+            out.push(line);
+            continue;
+        }
+        if (INDENTED.test(line) && !inList && (previousBlank || inIndentedCode)) {
+            inIndentedCode = true;
+            previousBlank = false;
+            out.push("");
+            continue;
+        }
+        inIndentedCode = false;
+        if (LIST_ITEM.test(line))
+            inList = true;
+        else if (!INDENTED.test(line) && previousBlank)
+            inList = false;
+        previousBlank = false;
+        out.push(line);
+    }
+    return out;
+}
+/** Inline code spans in one paragraph replaced by a space; an unmatched run of backticks is literal. */
+function withoutCodeSpans(paragraph) {
+    const runs = [];
+    for (let index = 0; index < paragraph.length;) {
+        if (paragraph[index] !== "`") {
+            index += 1;
+            continue;
+        }
+        const start = index;
+        while (paragraph[index] === "`")
+            index += 1;
+        runs.push({ start, end: index });
+    }
+    // A span closes at the next run of exactly the opening run's length.
+    const closer = new Array(runs.length).fill(-1);
+    const nextOfLength = new Map();
+    for (let i = runs.length - 1; i >= 0; i--) {
+        const length = runs[i].end - runs[i].start;
+        closer[i] = nextOfLength.get(length) ?? -1;
+        nextOfLength.set(length, i);
+    }
+    let result = "";
+    let copied = 0;
+    for (let i = 0; i < runs.length; i++) {
+        const close = closer[i];
+        if (close === -1)
+            continue;
+        result += `${paragraph.slice(copied, runs[i].start)} `;
+        copied = runs[close].end;
+        i = close;
+    }
+    return result + paragraph.slice(copied);
+}
+/** `markdown` without its code blocks and inline code spans. */
+export function withoutMarkdownCode(markdown) {
+    return withoutCodeBlocks(markdown)
+        .join("\n")
+        .split(/(\n[ \t]*\n)/)
+        .map((part, i) => (i % 2 === 1 ? part : withoutCodeSpans(part)))
+        .join("");
+}

package/dist/core/memory-tools.js

@@ -10,6 +10,7 @@
  * agents' data.
  */
 import { z } from "zod";
+import { SecretInValueError, SecretCheckUnavailableError } from "./secret-guard.js";
 import { MEMORY_CONTENT_MAX_BYTES, MEMORY_KEY_MAX_BYTES, MEMORY_MAX_KEYS_PER_AGENT, MEMORY_SEARCH_MAX_LIMIT, } from "../providers/memory/types.js";
 export const MEMORY_TOOL_NAMES = new Set([
     "memory_get",
@@ -116,6 +117,12 @@ export async function handleMemoryTool(name, argsJson, agentId, memory) {
                 message: err.issues.map((issue) => `${issue.path.join(".") || "input"}: ${issue.message}`).join("; "),
             });
         }
+        if (err instanceof SecretInValueError) {
+            return JSON.stringify({ error: err.code, message: err.message, secretNames: err.secretNames });
+        }
+        if (err instanceof SecretCheckUnavailableError) {
+            return JSON.stringify({ error: err.code, message: err.message });
+        }
         const code = err instanceof Error ? err.message : "memory_error";
         return JSON.stringify({ error: code, message: MEMORY_ERROR_MESSAGES[code] ?? code });
     }

package/dist/core/merge-order-check.d.ts

@@ -21,6 +21,7 @@
 import type { Run } from "#prisma";
 import type { PullRequestOrigin, ReviewHostRegistry, UpsertNamedCheckInput } from "../providers/review-host/types.js";
 import { type Logger } from "./logger.js";
+import { type MarkReadyDb } from "./mark-ready.js";
 import { type RelatedPullRequestsDb } from "./related-pull-requests.js";
 export declare const MERGE_ORDER_CHECK_NAME = "wardby merge order";
 export interface MergeOrderMember {
@@ -49,7 +50,7 @@ export type MergeOrderVerdict = {
  * as its entry in `set`; only `mergeOrder` is read from it.
  */
 export declare function mergeOrderVerdict(self: MergeOrderMember, set: readonly MergeOrderMember[]): MergeOrderVerdict;
-export type MergeOrderDb = RelatedPullRequestsDb;
+export type MergeOrderDb = RelatedPullRequestsDb & MarkReadyDb;
 export interface MergeOrderSyncDeps {
     db: MergeOrderDb;
     hosts: ReviewHostRegistry | undefined;

package/dist/core/merge-order-check.js

@@ -1,5 +1,6 @@
 import { CODING_CODE_PROVIDER, normalizeGitHubRepository } from "../coding/protocol.js";
 import { logger } from "./logger.js";
+import { maybeMarkReady } from "./mark-ready.js";
 import { collectRelatedPullRequests, runTreeRoot } from "./related-pull-requests.js";
 const moduleLog = logger.child({ module: "merge-order-check" });
 export const MERGE_ORDER_CHECK_NAME = "wardby merge order";
@@ -185,12 +186,18 @@ export async function syncMergeOrderChecks(deps, seedRunId, opts = {}) {
             const verdict = mergeOrderVerdict(self, set);
             if (verdict.status === "skip")
                 continue;
+            const input = mergeOrderCheckInput(self, verdict, steps, target.headSha, leadRunning);
             try {
-                await host.upsertNamedCheck(self.repository, mergeOrderCheckInput(self, verdict, steps, target.headSha, leadRunning));
+                await host.upsertNamedCheck(self.repository, input);
                 log.info({ seedRunId, repository: self.repository, number: self.number, status: verdict.status }, "merge order check posted");
             }
             catch (err) {
                 log.warn({ err, seedRunId, repository: self.repository, number: self.number }, "could not post the merge order check");
+                continue;
+            }
+            if (input.status === "completed" && input.conclusion === "success") {
+                // The last earlier step merged: the pull request may now be ready for review (#287).
+                await maybeMarkReady({ db: deps.db, hosts: deps.hosts, log: deps.log }, self.repository, self.number);
             }
         }
     }

package/dist/core/notification-templates.d.ts

@@ -1,11 +1,5 @@
-/**
- * Deterministic Slack text for workflow notifications. Pure functions: no
- * I/O, no model output. Every string that came from a person or a model
- * (titles, agent names, reasons) is escaped so it cannot become a link or a
- * mention; only canonical tracker/host URLs are formatted as links.
- */
 import type { ThreadSubject, WorkflowPayload } from "./workflow-events.js";
-export type ThreadStatus = "picked up" | "PR open" | "changes requested" | "fixing" | "fix rounds exhausted" | "approved" | "merged ✅" | "closed" | "failed ❌";
+export type ThreadStatus = "picked up" | "PR open" | "changes requested" | "fixing" | "fix rounds exhausted" | "approved" | "merged ✅" | "closed" | "failed ❌" | "blocked ⛔";
 export declare function escapeMrkdwn(s: string): string;
 export declare function nextStatus(prev: ThreadStatus | null, p: WorkflowPayload): ThreadStatus;
 export declare function renderParent(subject: ThreadSubject, status: ThreadStatus): {

package/dist/core/notification-templates.js

@@ -1,3 +1,11 @@
+/**
+ * Deterministic Slack text for workflow notifications. Pure functions: no
+ * I/O, no model output. Every string that came from a person or a model
+ * (titles, agent names, reasons) is escaped so it cannot become a link or a
+ * mention; only canonical tracker/host URLs are formatted as links.
+ */
+import { packageAuditStatusText } from "../coding/registry/audit-mode.js";
+import { packageRefusalWording } from "../coding/registry/refusal-wording.js";
 const TERMINAL = new Set(["merged ✅", "closed"]);
 /** Events that start a new attempt (a new pickup, a new PR) and so reopen a merged/closed thread. */
 const REOPENS = new Set(["issue_picked_up", "pr_opened"]);
@@ -28,8 +36,13 @@ export function nextStatus(prev, p) {
             return p.state === "started" ? "fixing" : "fix rounds exhausted";
         case "pr_closed":
             return p.merged ? "merged ✅" : "closed";
+        case "run_blocked":
+            return "blocked ⛔";
         case "run_failed":
             return "failed ❌";
+        case "packages_audited":
+            // A report about the run, not a step in its workflow.
+            return prev ?? "picked up";
     }
 }
 const section = (text) => ({ type: "section", text: { type: "mrkdwn", text } });
@@ -38,6 +51,19 @@ export function renderParent(subject, status) {
     const text = `${head} — *${status}*`;
     return { text, blocks: [section(text)] };
 }
+/** Refusal lists can exceed Slack's 3,000-character section limit. Keep each line intact. */
+function refusalSections(text) {
+    const parts = [""];
+    for (const line of text.split("\n")) {
+        const last = parts.length - 1;
+        const joined = parts[last] ? parts[last] + "\n" + line : line;
+        if (joined.length > 3000)
+            parts.push(line);
+        else
+            parts[last] = joined;
+    }
+    return parts.map(section);
+}
 export function renderEvent(p, spend) {
     let line;
     switch (p.kind) {
@@ -69,6 +95,12 @@ export function renderEvent(p, spend) {
                 ? `🎉 ${link(p.prUrl, p.prLabel)} merged${p.movedTo ? ` — moved to ${escapeMrkdwn(p.movedTo)}` : ""}`
                 : `⚪ ${link(p.prUrl, p.prLabel)} closed without merging`;
             break;
+        case "run_blocked":
+            line = packageRefusalWording(p.packageRefusals, { slack: true });
+            break;
+        case "packages_audited":
+            line = packageAuditStatusText(p.mode, p, true);
+            break;
         case "run_failed": {
             const who = `*${escapeMrkdwn(p.agentName)}*`;
             line =
@@ -83,7 +115,7 @@ export function renderEvent(p, spend) {
         }
     }
     const text = spend ? `${line}\n_${escapeMrkdwn(spend)}_` : line;
-    return { text, blocks: [section(text)] };
+    return { text, blocks: p.kind === "run_blocked" ? refusalSections(text) : [section(text)] };
 }
 /**
  * The Slack display name for a message about this event: the agent's name
@@ -93,13 +125,15 @@ export function renderEvent(p, spend) {
 export function senderName(p) {
     switch (p.kind) {
         case "issue_picked_up":
+        case "run_blocked":
         case "run_failed":
         case "review_posted":
+        case "packages_audited":
             return p.agentName;
         default:
             return "wardby";
     }
 }
 export function broadcasts(p) {
-    return (p.kind === "pr_closed" && p.merged) || p.kind === "run_failed";
+    return (p.kind === "pr_closed" && p.merged) || p.kind === "run_failed" || p.kind === "run_blocked";
 }

package/dist/core/pull-request-state-sync.js

@@ -6,8 +6,8 @@ export const PR_STATE_SYNC_BATCH = 10;
 /** A row is re-checked at most this often. */
 export const PR_STATE_SYNC_MIN_AGE_MS = 10 * 60_000;
 export async function syncOpenPullRequestStates(db, hosts, trackers, now = new Date()) {
-    // handlePullRequestClosed needs trackers; without them no IssuePullRequest rows are written anyway.
-    if (!hosts || !trackers)
+    // Without trackers the rows (a GitHub issue's, say) are still settled; only tracker actions are skipped.
+    if (!hosts)
         return 0;
     let settled = 0;
     try {

package/dist/core/reconciler.d.ts

@@ -45,8 +45,9 @@ import type { PrismaClient } from "#prisma";
 import type { Executor } from "../providers/executor/types.js";
 import type { ReviewHostRegistry } from "../providers/review-host/types.js";
 import type { IssueTrackerRegistry } from "../providers/issue-tracker/types.js";
+import { type HostStatusDb } from "./host-status.js";
 import { type ReviewStartDeps } from "./host-events.js";
-export type ReconcilerDb = Pick<PrismaClient, "run" | "runHostCheck" | "runHostStatus" | "runIssueStatus" | "agentIssueProject" | "issuePullRequest" | "codingRun" | "agent" | "$transaction" | "$queryRaw">;
+export type ReconcilerDb = Pick<PrismaClient, "run" | "runHostCheck" | "runBudgetEvent" | "runHostStatus" | "runIssueStatus" | "agentIssueProject" | "issuePullRequest" | "codingRun" | "registryFetch" | "registryAuditRecord" | "agent" | "agentRepository" | "$transaction" | "$queryRaw">;
 /**
  * How long after a run finishes before its still-open check counts as
  * orphaned: long enough that the sweep never races `executeRun`'s own
@@ -66,14 +67,14 @@ export declare const ORPHANED_CHECK_MAX_AGE_MS: number;
  * than retried forever; its Re-run button still works. Never queries when
  * no host is configured. `closeOpenHostCheck` is best-effort and never throws.
  */
-export declare function closeOrphanedHostChecks(db: Pick<PrismaClient, "runHostCheck" | "run">, hosts: ReviewHostRegistry | undefined, now?: Date): Promise<void>;
+export declare function closeOrphanedHostChecks(db: Pick<PrismaClient, "runHostCheck" | "run" | "runBudgetEvent">, hosts: ReviewHostRegistry | undefined, now?: Date): Promise<void>;
 /**
  * Completes open mention status comments on the same terms as
  * closeOrphanedHostChecks: the run ended between ORPHANED_CHECK_GRACE_MS and
  * ORPHANED_CHECK_MAX_AGE_MS ago, newest first, at most ORPHANED_CHECK_BATCH per
  * pass. `completeHostStatus` is best-effort and never throws.
  */
-export declare function closeOrphanedHostStatuses(db: Pick<PrismaClient, "runHostStatus" | "run">, hosts: ReviewHostRegistry | undefined, now?: Date): Promise<void>;
+export declare function closeOrphanedHostStatuses(db: HostStatusDb, hosts: ReviewHostRegistry | undefined, now?: Date): Promise<void>;
 /** Runs one reconciliation pass. Returns the number of runs marked `lost`. */
 export declare function reconcileOnce(db: ReconcilerDb, now?: Date, heartbeatTimeoutMs?: number, executor?: Executor, reviewHosts?: ReviewHostRegistry, issueTrackers?: IssueTrackerRegistry, 
 /** What starting a deferred review needs; absent = no deferred-review sweep. */

package/dist/core/reconciler.js

@@ -44,6 +44,7 @@
 import { HEARTBEAT_TIMEOUT_MS, RECONCILE_INTERVAL_MS } from "./timing.js";
 import { prisma as defaultDb } from "./db.js";
 import { logger } from "./logger.js";
+import { stopChildrenOfLostRun } from "./lost-run-children.js";
 import { closeOpenHostCheck } from "./review-host-checks.js";
 import { completeHostStatus } from "./host-status.js";
 import { closeOrphanedIssueStatuses } from "./issue-status.js";
@@ -210,7 +211,11 @@ deferredReviews) {
                 continue;
             let recovered;
             try {
-                recovered = await executor.recover({ runId: run.id, backend: run.executionBackend, id: run.id });
+                recovered = await executor.recover({
+                    runId: run.id,
+                    backend: run.executionBackend,
+                    id: run.executionWorkflowId ?? run.id,
+                });
             }
             catch (err) {
                 reconcilerLog.error({ err, runId: run.id }, "durable run recovery failed");
@@ -225,6 +230,7 @@ deferredReviews) {
             });
             lost += result.count;
             if (result.count > 0) {
+                await stopChildrenOfLostRun(db, executor, run.id);
                 await fileSelfDefect(db, issueTrackers, { ...run, status: "lost", error: reason, finishedAt: now }, SELF_DEFECT_WAIT);
                 await emitRunFinishedEvents(db, {
                     id: run.id,
@@ -243,6 +249,7 @@ deferredReviews) {
         lost += result.count;
         // Only after this pass made the row lost (not when another instance won the race); bounded, never throws.
         if (result.count > 0) {
+            await stopChildrenOfLostRun(db, executor, run.id);
             await fileSelfDefect(db, issueTrackers, { ...run, status: "lost", error: reason, finishedAt: now }, SELF_DEFECT_WAIT);
             await emitRunFinishedEvents(db, {
                 id: run.id,

package/dist/core/related-pull-requests.d.ts

@@ -1,8 +1,8 @@
 /**
  * The pull requests that came from the same request as a run: every pull
  * request opened by a coding run in the same top-level run tree (a lead that
- * fanned out to several repositories), plus any recorded for the same tracker
- * issue (IssuePullRequest). Control-plane rows only.
+ * fanned out to several repositories), plus any recorded for the same Jira or
+ * GitHub issue (IssuePullRequest). Control-plane rows only.
  * Ordered by the delegating agent's declared merge order when any entry has
  * one (CodingRun.mergeOrder; nulls last), then by when each pull request's
  * coding run was dispatched: the lead's delegation order (for a lead with
@@ -47,7 +47,7 @@ export interface RelatedPullRequest {
 }
 export interface RelatedPullRequestGroup {
     pullRequests: RelatedPullRequest[];
-    /** The first well-formed issue seen on the group's coding runs. */
+    /** The first well-formed issue (a Jira or GitHub issue) seen on the group's coding runs. */
     issue?: {
         provider: string;
         key: string;
@@ -111,6 +111,14 @@ export interface OpenSibling {
     number: number;
     openedByRunId: string;
 }
+/**
+ * The continuation hint for a ticket (a GitHub or Jira issue) that already has
+ * open wardby pull requests: one sentence per pull request (up to
+ * MAX_SIBLING_HINTS), then SIBLING_GUIDANCE once, as paragraphs. Built from
+ * stored rows only, with the run id, repository and number re-validated and the
+ * link built here, never taken from issue text. Empty when nothing is hintable.
+ */
+export declare function openPullRequestHints(prs: readonly OpenSibling[]): string;
 /**
  * The group's pull requests a follow-up may continue: stored state "open", or
  * no stored state yet (a same-tree sibling not recorded for an issue), minus

package/dist/core/related-pull-requests.js

@@ -1,8 +1,8 @@
 /**
  * The pull requests that came from the same request as a run: every pull
  * request opened by a coding run in the same top-level run tree (a lead that
- * fanned out to several repositories), plus any recorded for the same tracker
- * issue (IssuePullRequest). Control-plane rows only.
+ * fanned out to several repositories), plus any recorded for the same Jira or
+ * GitHub issue (IssuePullRequest). Control-plane rows only.
  * Ordered by the delegating agent's declared merge order when any entry has
  * one (CodingRun.mergeOrder; nulls last), then by when each pull request's
  * coding run was dispatched: the lead's delegation order (for a lead with
@@ -24,7 +24,7 @@
  */
 import { Prisma } from "#prisma";
 import { CODING_CODE_PROVIDER, normalizeGitHubRepository } from "../coding/protocol.js";
-import { ISSUE_KEY, ISSUE_TRACKER_NAMES, } from "../providers/issue-tracker/types.js";
+import { issueReference, } from "../providers/issue-tracker/types.js";
 import { renderRelatedSection } from "../providers/vcs/github.js";
 import { pullRequestOutcome } from "./host-status.js";
 import { logger } from "./logger.js";
@@ -162,7 +162,8 @@ onlyIssueKey) {
     let issue;
     const issues = new Map();
     for (const r of rows) {
-        if (r.issueProvider && r.issueKey && ISSUE_KEY.test(r.issueKey)) {
+        // A Jira issue and a GitHub issue join the same way: by provider and key, each key re-validated.
+        if (r.issueProvider && r.issueKey && issueReference(r.issueProvider, r.issueKey)) {
             const found = { provider: r.issueProvider, key: r.issueKey };
             issue ??= found;
             issues.set(`${found.provider}\0${found.key}`, found);
@@ -271,16 +272,8 @@ onlyIssueKey) {
 function issueFor(group, trackers) {
     if (!group.issue)
         return undefined;
-    const provider = group.issue.provider;
-    let url;
-    try {
-        url = trackers?.[provider]?.issueUrl(group.issue.key);
-    }
-    catch {
-        url = undefined;
-    }
-    const trackerName = Object.hasOwn(ISSUE_TRACKER_NAMES, provider) ? ISSUE_TRACKER_NAMES[provider] : undefined;
-    return { key: group.issue.key, ...(url ? { url } : {}), ...(trackerName ? { trackerName } : {}) };
+    const tracker = trackers?.[group.issue.provider];
+    return issueReference(group.issue.provider, group.issue.key, tracker ? (key) => tracker.issueUrl(key) : undefined);
 }
 /**
  * After a native run ends, rewrites the Related pull requests section on
@@ -388,6 +381,26 @@ const SAFE_RUN_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
 export const SIBLING_GUIDANCE = "Continue the pull request you were asked about, and a listed open one only when the change requires it. " +
     "Never open a new pull request in a repository that already has an open pull request listed here. Merged or " +
     "closed pull requests are not listed: a change there needs a new pull request.";
+const HINT_REPOSITORY = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+/**
+ * The continuation hint for a ticket (a GitHub or Jira issue) that already has
+ * open wardby pull requests: one sentence per pull request (up to
+ * MAX_SIBLING_HINTS), then SIBLING_GUIDANCE once, as paragraphs. Built from
+ * stored rows only, with the run id, repository and number re-validated and the
+ * link built here, never taken from issue text. Empty when nothing is hintable.
+ */
+export function openPullRequestHints(prs) {
+    const lines = prs
+        .filter((p) => SAFE_RUN_ID.test(p.openedByRunId) &&
+        HINT_REPOSITORY.test(p.repository) &&
+        Number.isSafeInteger(p.number) &&
+        p.number > 0)
+        .slice(0, MAX_SIBLING_HINTS)
+        .map((p) => `This issue already has an open pull request wardby opened: ${p.repository}#${p.number} ` +
+        `(https://github.com/${p.repository}/pull/${p.number}). ` +
+        `To revise it, delegate with continuePriorRun set to exactly "${p.openedByRunId}".`);
+    return lines.length > 0 ? [...lines, SIBLING_GUIDANCE].join("\n\n") : "";
+}
 /**
  * The group's pull requests a follow-up may continue: stored state "open", or
  * no stored state yet (a same-tree sibling not recorded for an issue), minus

package/dist/core/reply-parts.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Splits an agent's reply into comment-sized parts, so a long reply (a plan
+ * posted to an issue, say) can go out in full as numbered follow-up comments
+ * instead of being cut. Pure: numbering, headers and the cut note are the
+ * caller's job; each part is a raw slice of the defused text.
+ */
+export interface ReplyParts {
+    parts: string[];
+    truncated: boolean;
+}
+/** "@" + U+200B before a word character, so a quoted reply pings nobody. */
+export declare function defuseMentions(text: string): string;
+/**
+ * Splits `text` into at most `maxParts` parts of at most `maxChars` each, preferring Markdown heading
+ * boundaries, then blank lines (paragraphs), then single newlines, then a hard cut. Defuses @-mentions.
+ * Never splits inside a fenced code block unless one block alone exceeds maxChars (then hard-cut it).
+ */
+export declare function splitReply(text: string, opts: {
+    maxChars: number;
+    maxParts: number;
+}): ReplyParts;