@wardby/cli 0.3.0 → 0.4.1

package/dist/core/engine-native.js

@@ -40,13 +40,15 @@ function firstUserMessage(untrustedContext) {
         `${wrapUntrusted(UNTRUSTED_CONTEXT_TAG, untrustedContext)}\n\nBegin.`);
 }
 function zeroUsage() {
-    return { tokensIn: 0, tokensOut: 0, costUsd: 0 };
+    return { tokensIn: 0, tokensOut: 0, costUsd: 0, cachedInputTokens: 0, cacheWriteTokens: 0 };
 }
 function addUsage(a, b) {
     return {
         tokensIn: a.tokensIn + b.inputTokens,
         tokensOut: a.tokensOut + b.outputTokens,
         costUsd: a.costUsd + b.costUsd,
+        cachedInputTokens: a.cachedInputTokens + b.cachedInputTokens,
+        cacheWriteTokens: a.cacheWriteTokens + b.cacheWriteTokens,
     };
 }
 export class NativeEngine {
@@ -102,6 +104,10 @@ export class NativeEngine {
                 return this.finish("failed", lastText, turns, addUsage(cumulative, turn.usage), turn.error);
             }
             cumulative = addUsage(cumulative, turn.usage);
+            await ctx.onProgress?.({
+                turns,
+                usage: { tokensIn: cumulative.tokensIn, tokensOut: cumulative.tokensOut, costUsd: cumulative.costUsd },
+            });
             lastCacheRatio = turn.usage.inputTokens > 0 ? turn.usage.cachedInputTokens / turn.usage.inputTokens : 0;
             if (turn.budgetExceededMidStream) {
                 return this.windDown(ctx, messages, cumulative, turns, turn.text || lastText);
@@ -219,7 +225,7 @@ export class NativeEngine {
         }
         catch (err) {
             return {
-                usage: { inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, costUsd: 0 },
+                usage: { inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, cacheWriteTokens: 0, costUsd: 0 },
                 text,
                 toolCalls,
                 budgetExceededMidStream: false,
@@ -233,7 +239,13 @@ export class NativeEngine {
                 cachedInputTokens: estimatedCachedInput,
             });
             return {
-                usage: { inputTokens, outputTokens: outputTokensSoFar, cachedInputTokens: estimatedCachedInput, costUsd },
+                usage: {
+                    inputTokens,
+                    outputTokens: outputTokensSoFar,
+                    cachedInputTokens: estimatedCachedInput,
+                    cacheWriteTokens: 0,
+                    costUsd,
+                },
                 text,
                 toolCalls,
                 budgetExceededMidStream: true,
@@ -241,7 +253,7 @@ export class NativeEngine {
         }
         if (!usage) {
             return {
-                usage: { inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, costUsd: 0 },
+                usage: { inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, cacheWriteTokens: 0, costUsd: 0 },
                 text,
                 toolCalls,
                 budgetExceededMidStream: false,
@@ -266,6 +278,7 @@ export class NativeEngine {
                 inputTokens: usage.inputTokens,
                 outputTokens: usage.outputTokens,
                 cachedInputTokens: usage.cachedInputTokens ?? 0,
+                cacheWriteTokens: usage.cacheWriteTokens ?? 0,
                 costUsd: usage.costUsd,
             },
             text,

package/dist/core/glob.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Converts a glob pattern (with *, **, and ? support) to a regular expression.
+ * - `*` matches any characters except `/` (one path segment)
+ * - `**` matches any characters including `/` (any depth)
+ * - `?` matches any single character except `/`
+ * - Other regex metacharacters are escaped
+ */
+export declare function globRegex(pattern: string): RegExp;
+/** Whether a repo-relative POSIX path matches a protectedPaths-style glob (*, **, ?). */
+export declare function matchesGlob(path: string, pattern: string): boolean;

package/dist/core/glob.js

@@ -0,0 +1,33 @@
+/**
+ * Converts a glob pattern (with *, **, and ? support) to a regular expression.
+ * - `*` matches any characters except `/` (one path segment)
+ * - `**` matches any characters including `/` (any depth)
+ * - `?` matches any single character except `/`
+ * - Other regex metacharacters are escaped
+ */
+export function globRegex(pattern) {
+    let source = "^";
+    for (let index = 0; index < pattern.length; index += 1) {
+        const character = pattern[index];
+        if (character === "*") {
+            if (pattern[index + 1] === "*") {
+                source += ".*";
+                index += 1;
+            }
+            else {
+                source += "[^/]*";
+            }
+        }
+        else if (character === "?") {
+            source += "[^/]";
+        }
+        else {
+            source += character.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+        }
+    }
+    return new RegExp(`${source}$`);
+}
+/** Whether a repo-relative POSIX path matches a protectedPaths-style glob (*, **, ?). */
+export function matchesGlob(path, pattern) {
+    return globRegex(pattern).test(path);
+}

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

@@ -7,10 +7,12 @@
  */
 import type { PrismaClient } from "#prisma";
 import type { Executor } from "../providers/executor/types.js";
+import type { IssueTrackerRegistry } from "../providers/issue-tracker/types.js";
 import type { HostEvent, ReviewHostRegistry } from "../providers/review-host/types.js";
 import { type RepoAccessGate } from "./repo-access.js";
+import { type DriftScope } from "../knowledge/relevance.js";
 export type { HostEvent };
-export type HostEventDb = Pick<PrismaClient, "agentRepository" | "agent" | "run" | "runHostCheck" | "runHostStatus" | "codingRun" | "task" | "webhook" | "budgetGroup" | "$transaction" | "$queryRaw">;
+export type HostEventDb = Pick<PrismaClient, "agentRepository" | "agent" | "run" | "runHostCheck" | "runHostStatus" | "codingRun" | "task" | "webhook" | "budgetGroup" | "issuePullRequest" | "workItem" | "runAttribution" | "agentIssueProject" | "$transaction" | "$queryRaw">;
 export interface RouteHostEventDeps {
     db: HostEventDb;
     executor: Executor;
@@ -19,6 +21,8 @@ export interface RouteHostEventDeps {
     mentionHandle: string;
     /** Re-checks each link's authorization, and a mention author's own permission, before anything runs. */
     repoAccess: RepoAccessGate;
+    /** Issue trackers for moving/commenting on the issue a closed PR was opened for; absent → pr_closed is ignored. */
+    issueTrackers?: IssueTrackerRegistry;
 }
 export interface RouteResult {
     runIds: string[];
@@ -26,6 +30,24 @@ export interface RouteResult {
     followUps: Array<() => Promise<void>>;
 }
 export declare function isReviewCommand(body: string, mentionHandle: string): boolean;
+type PushEvent = Extract<HostEvent, {
+    kind: "push";
+}>;
+type ConceptCitationStatus = {
+    state: "verified";
+} | {
+    state: "stale";
+    spans: string[];
+} | {
+    state: "unverified";
+};
+/**
+ * The merge watcher's task text. The task holds only trusted facts (repository,
+ * branch, short shas, a fixed instruction); the changed paths came from pushed
+ * commits, so they and the affected concept paths travel as untrusted context.
+ * Commit messages and author names are never included.
+ */
+export declare function mergeTaskText(event: PushEvent, scope: DriftScope | null, bundleComplete?: boolean, citations?: ReadonlyMap<string, ConceptCitationStatus>): string;
 type MentionEvent = Extract<HostEvent, {
     kind: "mention";
 }>;
@@ -46,4 +68,5 @@ type MentionEvent = Extract<HostEvent, {
  * taskOverride column.
  */
 export declare function mentionTaskText(event: MentionEvent): string;
+export declare function unknownPriorRunBody(priorRunId: string): string;
 export declare function routeHostEvent(event: HostEvent, deps: RouteHostEventDeps): Promise<RouteResult>;

package/dist/core/host-events.js

@@ -1,8 +1,13 @@
-import { dispatchRun } from "./dispatch.js";
+import { linkedPullRequestAttribution, 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 { requiredLevel } from "./repo-access.js";
 import { composeTaskOverride } from "./untrusted-content.js";
+import { DEFAULT_KNOWLEDGE_BUNDLE_PATH, parseConcept, RESERVED_BUNDLE_FILES, } from "../knowledge/concept.js";
+import { driftScope } from "../knowledge/relevance.js";
+import { spanHash } from "../knowledge/span-hash.js";
 const log = logger.child({ module: "host-events" });
 const MAX_TASK_BODY = 8000;
 const MAX_TITLE = 256;
@@ -13,6 +18,221 @@ function escapeRegExp(value) {
 export function isReviewCommand(body, mentionHandle) {
     return new RegExp(`(^|[^\\w-])@${escapeRegExp(mentionHandle)}\\s+review(?![\\w-])`, "i").test(body);
 }
+const MAX_BUNDLE_FILES = 200;
+const BUNDLE_FILE_LINES = 2000;
+const MAX_LISTED_CHANGES = 200;
+/** The whole bundle load (listing plus reads) must finish inside GitHub's ~10 s webhook window. */
+const BUNDLE_LOAD_DEADLINE_MS = 4000;
+const BUNDLE_READ_CONCURRENCY = 8;
+/** Most lines read from one cited file; a citation reaching past it cannot be verified. */
+const CITATION_READ_MAX_LINES = 5000;
+const BUNDLE_INCOMPLETE_TEXT = "The knowledge bundle could not be fully read; treat every knowledge concept as possibly affected.";
+/**
+ * The merge watcher's task text. The task holds only trusted facts (repository,
+ * branch, short shas, a fixed instruction); the changed paths came from pushed
+ * commits, so they and the affected concept paths travel as untrusted context.
+ * Commit messages and author names are never included.
+ */
+export function mergeTaskText(event, scope, bundleComplete = true, citations = new Map()) {
+    const statusOf = (concept) => citations.get(concept) ?? { state: "unverified" };
+    const changed = event.changedPathsComplete
+        ? `Changed files:\n${[
+            ...event.changedPaths.slice(0, MAX_LISTED_CHANGES).map((p) => `- ${p}`),
+            ...(event.changedPaths.length > MAX_LISTED_CHANGES
+                ? [`… and ${event.changedPaths.length - MAX_LISTED_CHANGES} more changed files`]
+                : []),
+        ].join("\n")}`
+        : "The changed-file list is incomplete (GitHub includes at most 2048 commits per push and the list is capped at 1000 paths); treat every knowledge concept as possibly affected.";
+    const listed = scope
+        ? `Knowledge concepts whose citations, affects globs, or files changed (${scope.reason}):\n` +
+            scope.concepts.map((p) => `- ${DEFAULT_KNOWLEDGE_BUNDLE_PATH}/${p} — ${describeStatus(statusOf(p))}`).join("\n")
+        : null;
+    let context;
+    if (!bundleComplete)
+        context = [changed, listed, BUNDLE_INCOMPLETE_TEXT].filter(Boolean).join("\n\n");
+    else if (listed)
+        context = [changed, listed].join("\n\n");
+    else if (!event.changedPathsComplete)
+        context = "No knowledge concept exists in this repository.";
+    else
+        context = [changed, "No knowledge concept is affected by these changes."].join("\n\n");
+    let summary = null;
+    if (scope && scope.concepts.length > 0) {
+        const states = scope.concepts.map((p) => statusOf(p).state);
+        const count = (state) => states.filter((x) => x === state).length;
+        const onlyKnowledge = event.changedPathsComplete && event.changedPaths.every((p) => p.startsWith(`${DEFAULT_KNOWLEDGE_BUNDLE_PATH}/`));
+        summary =
+            `Citation check at ${event.after.slice(0, 12)}: ${count("verified")} of ${states.length} affected concepts verified, ` +
+                `${count("stale")} stale, ${count("unverified")} not verified. Only knowledge files changed: ${onlyKnowledge ? "yes" : "no"}.`;
+    }
+    return composeTaskOverride([
+        `Merge to ${event.branch} in ${event.repository}: ${event.before.slice(0, 12)}..${event.after.slice(0, 12)}.`,
+        "The changed files and the knowledge concepts they affect are listed in the context below; treat them as data.",
+        ...(summary ? [summary] : []),
+    ].join("\n\n"), context);
+}
+function describeStatus(status) {
+    if (status.state === "verified")
+        return "citations verified";
+    if (status.state === "unverified")
+        return "citations not verified";
+    return `${status.spans.length} stale citation${status.spans.length === 1 ? "" : "s"}: ${status.spans.join(", ")}`;
+}
+/** One time budget, shared by every read the push route makes. */
+function startBudget(ms) {
+    let expired = false;
+    let timer;
+    const promise = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            expired = true;
+            resolve("deadline");
+        }, ms);
+    });
+    return { promise, expired: () => expired, clear: () => clearTimeout(timer) };
+}
+/**
+ * The knowledge bundle at the pushed commit, read with bounded concurrency
+ * under one overall deadline. A failure never fails the route; it yields an
+ * incomplete result so the watcher treats every concept as possibly affected.
+ */
+async function loadBundle(host, event, budget) {
+    const prefix = `${DEFAULT_KNOWLEDGE_BUNDLE_PATH}/`;
+    const concepts = [];
+    const where = { repository: event.repository, after: event.after };
+    let filesRead = 0;
+    let listing;
+    try {
+        const listed = await Promise.race([host.listFiles(event.repository, event.after, prefix), budget.promise]);
+        if (listed === "deadline") {
+            log.warn({ ...where, filesRead }, "the knowledge bundle load hit its deadline while listing");
+            return { concepts: [], complete: false };
+        }
+        listing = listed;
+    }
+    catch (err) {
+        log.warn({ err, ...where }, "could not read the knowledge bundle");
+        return { concepts: [], complete: false };
+    }
+    let complete = true;
+    if (listing.truncated) {
+        complete = false;
+        log.warn(where, "the knowledge bundle listing is truncated; continuing with the files listed");
+    }
+    const matching = listing.paths.filter((f) => f.startsWith(prefix) && f.endsWith(".md") && !RESERVED_BUNDLE_FILES.has(f.split("/").pop() ?? f));
+    const files = matching.slice(0, MAX_BUNDLE_FILES);
+    if (matching.length > files.length) {
+        complete = false;
+        log.warn({ ...where, listed: matching.length, cap: MAX_BUNDLE_FILES }, "the knowledge bundle exceeds the file cap");
+    }
+    let skipped = 0;
+    let lastError;
+    let next = 0;
+    const worker = async () => {
+        while (!budget.expired() && next < files.length) {
+            const file = files[next++];
+            try {
+                const read = await host.readFile(event.repository, file, event.after, {
+                    startLine: 1,
+                    maxLines: BUNDLE_FILE_LINES,
+                });
+                if (budget.expired())
+                    return;
+                filesRead += 1;
+                if (read.kind !== "file" || read.truncated) {
+                    skipped += 1;
+                    continue;
+                }
+                const parsed = parseConcept(file.slice(prefix.length), read.text);
+                if (parsed.ok)
+                    concepts.push(parsed.concept);
+                else {
+                    // A concept that cannot be parsed might be one the push affects: do not claim the bundle was fully read.
+                    skipped += 1;
+                    lastError = new Error(parsed.error);
+                }
+            }
+            catch (err) {
+                skipped += 1;
+                lastError = err;
+            }
+        }
+    };
+    const workers = Promise.all(Array.from({ length: Math.min(BUNDLE_READ_CONCURRENCY, files.length) }, worker));
+    const outcome = await Promise.race([workers, budget.promise]);
+    if (outcome === "deadline") {
+        log.warn({ ...where, filesRead }, "the knowledge bundle load hit its deadline; continuing with the files read");
+        return { concepts: [...concepts], complete: false };
+    }
+    if (skipped > 0) {
+        complete = false;
+        log.warn({ err: lastError, ...where, skipped }, "skipped knowledge files that could not be read");
+    }
+    return { concepts, complete };
+}
+/**
+ * Whether each concept's citations still match the code at the pushed commit.
+ * Each distinct cited path is read once (raw text, up to the largest cited end
+ * line), with bounded concurrency, inside the budget the bundle load shares.
+ * Anything not checked by the deadline, or that cannot be read, is
+ * "unverified"; this never throws.
+ */
+async function verifyCitations(host, event, concepts, budget) {
+    const needed = new Map();
+    for (const concept of concepts)
+        for (const c of concept.citations) {
+            const lines = c.lines ? Math.min(c.lines[1], CITATION_READ_MAX_LINES) : CITATION_READ_MAX_LINES;
+            needed.set(c.path, Math.max(needed.get(c.path) ?? 0, lines));
+        }
+    const fetched = new Map();
+    const paths = [...needed.keys()];
+    let next = 0;
+    const worker = async () => {
+        while (!budget.expired() && next < paths.length) {
+            const path = paths[next++];
+            try {
+                const read = await host.readFile(event.repository, path, event.after, {
+                    startLine: 1,
+                    maxLines: needed.get(path) ?? CITATION_READ_MAX_LINES,
+                });
+                if (budget.expired())
+                    return;
+                if (read.kind === "file")
+                    fetched.set(path, { text: read.text, truncated: read.truncated });
+            }
+            catch (err) {
+                log.warn({ err, repository: event.repository, after: event.after, path }, "could not read a cited file");
+            }
+        }
+    };
+    try {
+        const workers = Promise.all(Array.from({ length: Math.min(BUNDLE_READ_CONCURRENCY, paths.length) }, worker));
+        if ((await Promise.race([workers, budget.promise])) === "deadline") {
+            log.warn({ repository: event.repository, after: event.after, read: fetched.size, of: paths.length }, "the citation check hit its deadline; the remaining concepts are unverified");
+        }
+    }
+    catch (err) {
+        log.warn({ err, repository: event.repository, after: event.after }, "the citation check failed");
+    }
+    const statuses = new Map();
+    for (const concept of concepts) {
+        const spans = [];
+        let unverified = concept.citations.length === 0;
+        for (const c of concept.citations) {
+            const file = fetched.get(c.path);
+            const beyondRead = c.lines ? c.lines[1] > CITATION_READ_MAX_LINES : true;
+            // A truncated read is only usable for a cited span that fits inside the window read.
+            if (!file || (file.truncated && beyondRead)) {
+                unverified = true;
+                continue;
+            }
+            if (spanHash(file.text, c.lines) !== c.spanHash) {
+                spans.push(c.lines ? `${c.path}#L${c.lines[0]}-L${c.lines[1]}` : c.path);
+            }
+        }
+        statuses.set(concept.path, spans.length > 0 ? { state: "stale", spans } : unverified ? { state: "unverified" } : { state: "verified" });
+    }
+    return statuses;
+}
 /**
  * The mention agent's task text. Deterministic so a prompt can parse it.
  *
@@ -63,6 +283,23 @@ export function mentionTaskText(event) {
     }
     return composeTaskOverride(sections.join("\n\n"), context.length > 0 ? context.join("\n\n") : undefined);
 }
+/**
+ * Whether the run the PR's marker names is one this deployment can continue on
+ * this PR: known here, in this repository, and the one that opened this PR.
+ * The marker is trusted only on a PR the App authored, but every deployment
+ * sharing the App authors such PRs, and the id is only a hint until checked.
+ */
+async function priorRunContinues(deps, event) {
+    if (!event.priorRunId)
+        return false;
+    const check = await checkContinuation(deps.db, event.priorRunId, event.repository);
+    return check.ok && check.root.pullRequestNumber === event.number;
+}
+export function unknownPriorRunBody(priorRunId) {
+    return (`❌ I can't continue this pull request. Its description names wardby run \`${priorRunId}\`, but this wardby ` +
+        "deployment has no record of that run opening this pull request (another wardby deployment may have opened it). " +
+        "Ask the deployment that opened it, or make the change on this branch by hand.");
+}
 /** Run states that already cover a commit: a review of it is under way or done. */
 const COVERING_REVIEW_STATUSES = ["pending", "running", "succeeded"];
 /**
@@ -89,6 +326,10 @@ async function startReviews(deps, host, repository, prNumber, headSha, targets,
 /** True for automatic triggers; an explicit re-run or `@wardby review` always runs. */
 skipReviewedCommits = false) {
     const runIds = [];
+    // 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));
     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");
@@ -106,9 +347,11 @@ skipReviewedCommits = false) {
             const dispatched = await dispatchRun({
                 db: deps.db,
                 executor: deps.executor,
+                selfDefects: { db: deps.db, issueTrackers: deps.issueTrackers },
                 agentId: target.agentId,
                 trigger: "host_event",
                 taskOverride: `Review pull request #${prNumber} in ${repository} (head ${headSha}).`,
+                attribution: await linkedAttribution(),
                 afterPersist: checkId
                     ? async (tx, run) => {
                         await tx.runHostCheck.create({
@@ -165,6 +408,16 @@ async function authorizedLinks(deps, event, links) {
 const reviewTargets = (links) => links.map((l) => ({ agentId: l.agentId, checkName: l.checkName }));
 export async function routeHostEvent(event, deps) {
     const none = { runIds: [], followUps: [] };
+    if (event.kind === "pr_closed") {
+        // Bookkeeping only: no agent runs, so no repository link is consulted.
+        await handlePullRequestClosed(deps.db, deps.issueTrackers, {
+            codeProvider: event.provider,
+            repository: event.repository,
+            number: event.prNumber,
+            merged: event.merged,
+        });
+        return none;
+    }
     const host = deps.hosts[event.provider];
     if (!host)
         return none;
@@ -174,6 +427,71 @@ export async function routeHostEvent(event, deps) {
     }));
     const reviewerLinks = links.filter((l) => l.access === "write" && l.triggers.includes("pull_request") && l.checkName);
     switch (event.kind) {
+        case "push": {
+            const watchers = await authorizedLinks(deps, event, links.filter((l) => l.access === "write" && l.triggers.includes("push")));
+            if (watchers.length === 0)
+                return none;
+            // Loading the bundle is the slow part of the response path; skip it when
+            // no dispatch can happen. The per-dispatch guard below stays authoritative.
+            const busy = new Set((await deps.db.run.findMany({
+                where: { agentId: { in: watchers.map((w) => w.agentId) }, status: { in: ["pending", "running"] } },
+                select: { agentId: true },
+            })).map((r) => r.agentId));
+            if (watchers.every((w) => busy.has(w.agentId))) {
+                log.info({ repository: event.repository, after: event.after }, "push skipped: every watcher has a run in flight");
+                return none;
+            }
+            const budget = startBudget(BUNDLE_LOAD_DEADLINE_MS);
+            let taskOverride;
+            try {
+                const { concepts, complete } = await loadBundle(host, event, budget);
+                const scope = driftScope({
+                    changedPaths: event.changedPaths,
+                    changedPathsComplete: event.changedPathsComplete,
+                    bundlePath: DEFAULT_KNOWLEDGE_BUNDLE_PATH,
+                    concepts,
+                });
+                // Only the concepts the merge affects are checked, and only against a bundle that was fully read.
+                const affected = new Set(scope?.concepts);
+                const citations = complete
+                    ? await verifyCitations(host, event, concepts.filter((c) => affected.has(c.path)), budget)
+                    : new Map();
+                taskOverride = mergeTaskText(event, scope, complete, citations);
+            }
+            finally {
+                budget.clear();
+            }
+            const runIds = [];
+            for (const watcher of watchers) {
+                let dispatched;
+                try {
+                    dispatched = await dispatchRun({
+                        db: deps.db,
+                        executor: deps.executor,
+                        selfDefects: { db: deps.db, issueTrackers: deps.issueTrackers },
+                        agentId: watcher.agentId,
+                        trigger: "host_event",
+                        taskOverride,
+                        lockAgent: true,
+                        // D3: one merge run at a time per watcher; a push during a run is skipped.
+                        beforePersist: async (tx, agent) => !(await tx.run.findFirst({
+                            where: { agentId: agent.id, status: { in: ["pending", "running"] } },
+                            select: { id: true },
+                        })),
+                    });
+                }
+                catch (err) {
+                    log.warn({ err, agentId: watcher.agentId, repository: event.repository, after: event.after }, "merge watcher run could not be dispatched");
+                    continue;
+                }
+                if (dispatched)
+                    runIds.push(dispatched.run.id);
+                else {
+                    log.info({ repository: event.repository, after: event.after, agentId: watcher.agentId }, "push skipped: the watcher has a run in flight");
+                }
+            }
+            return { runIds, followUps: [] };
+        }
         case "pr_updated": {
             if (event.isFork || reviewerLinks.length === 0)
                 return none;
@@ -234,12 +552,34 @@ export async function routeHostEvent(event, deps) {
                     followUps: [react],
                 };
             }
+            if (event.priorRunId && !(await priorRunContinues(deps, event))) {
+                // The PR's marker names a run this deployment cannot continue (most
+                // often one another deployment sharing the App opened). A run would
+                // only fail, or open a second PR, so say why instead of starting one.
+                log.info({ repository: event.repository, number: event.number, priorRunId: event.priorRunId }, "mention refused: the PR's wardby run cannot be continued here");
+                const reply = async () => {
+                    await host
+                        .comment(event.repository, {
+                        number: event.number,
+                        body: unknownPriorRunBody(event.priorRunId ?? ""),
+                        ...(event.replyToReviewCommentId ? { replyToReviewCommentId: event.replyToReviewCommentId } : {}),
+                    })
+                        .catch((err) => {
+                        log.warn({ err, repository: event.repository, number: event.number }, "could not post the refusal");
+                    });
+                };
+                return { runIds: [], followUps: [react, reply] };
+            }
             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),
+                attribution: event.isPullRequest
+                    ? await linkedPullRequestAttribution(deps.db, deps.issueTrackers, { codeProvider: host.provider, repository: event.repository, number: event.number }, RESPONSE_PATH_SNAPSHOT_BUDGET)
+                    : undefined,
                 // Where to report, written with the run: even if this instance dies
                 // before the follow-up below, the run's outcome still gets a comment.
                 afterPersist: async (tx, run) => {

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

@@ -11,12 +11,18 @@
 import type { Prisma, PrismaClient, Run } from "#prisma";
 import type { CodeReviewHost, ReviewHostProvider, ReviewHostRegistry } from "../providers/review-host/types.js";
 export type HostStatusDb = Pick<PrismaClient, "runHostStatus" | "run">;
-type FinishedRun = Pick<Run, "id" | "status" | "finalText">;
+export type FinishedRun = Pick<Run, "id" | "status" | "finalText">;
 /** The parts of a CodingRun result this comment uses. */
 export interface PullRequestOutcome {
     outcome: "pull_request_opened" | "pull_request_updated";
     repository: string;
     pullRequestNumber: number;
+    /** The result's own pull request URL; absent from a malformed result. */
+    pullRequestUrl?: string;
+    /** The code host the repository is on. */
+    codeProvider: string;
+    /** The coding sub-run that produced it; set by collectRunOutcome. */
+    runId?: string;
 }
 /** A sub-run that ended without succeeding. */
 export interface FailedChild {
@@ -29,6 +35,7 @@ export interface FailedChild {
     /** The service names on the coding sub-run (CodingRun.services), for one that never became ready. */
     services?: string[];
 }
+export declare const runLine: (runId: string) => string;
 export declare function workingBody(runId: string): string;
 /** The status row for a mention run, created in the same transaction as the run. */
 export declare function mentionStatusRow(provider: ReviewHostProvider, event: {
@@ -38,7 +45,18 @@ export declare function mentionStatusRow(provider: ReviewHostProvider, event: {
 }, runId: string): Prisma.RunHostStatusUncheckedCreateInput;
 export declare function outcomeBody(run: FinishedRun, repository: string, pullRequests: PullRequestOutcome[], failedChildren?: FailedChild[], opts?: {
     budgetSentence?: string;
+    noPullRequestText?: string;
+    /** The agent's reply IS the answer (no separate reply comment): shown as written, not quoted. */
+    replyAsAnswer?: boolean;
 }): string;
+/** What collectRunOutcome reads: a run's children and, when out of budget, its budget facts. */
+export type RunOutcomeDb = Pick<PrismaClient, "run">;
+/** The parts of a finished run's outcome a status comment reports; shared by GitHub and Jira status comments. */
+export declare function collectRunOutcome(db: RunOutcomeDb, run: FinishedRun): Promise<{
+    pullRequests: PullRequestOutcome[];
+    failedChildren: FailedChild[];
+    budgetSentence?: string;
+}>;
 /**
  * Writes a finished run's outcome to its status comment and marks it
  * complete: edits the comment when it exists; when it does not yet, posts the
@@ -58,4 +76,3 @@ export declare function completeHostStatus(db: HostStatusDb, run: FinishedRun, h
  * already complete. Never throws.
  */
 export declare function postMentionStatus(db: HostStatusDb, host: CodeReviewHost, runId: string, hosts: ReviewHostRegistry | undefined): Promise<void>;
-export {};