@wardby/cli 0.5.3 → 0.6.0

package/dist/core/host-events.js

@@ -1,9 +1,18 @@
+/**
+ * Host-neutral routing of code-review host events (GitHub App webhooks today)
+ * to the native agents linked to that repository. Adapters normalise their
+ * payloads into HostEvent (providers/review-host/github-events.ts); this
+ * module decides which agents run. See
+ * docs/private/2026-09-25-code-review-host-design.md §6.3.
+ */
+import { Prisma } from "#prisma";
 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 { syncMergeOrderChecksForPullRequest } from "./merge-order-check.js";
+import { MAX_SIBLING_HINTS, openSiblings, runTreeRoot, 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";
@@ -338,6 +347,11 @@ export function unknownPriorRunBody(priorRunId) {
         "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.");
 }
+/** A review run's task: the head to review, plus any extra context its trigger adds. */
+export function reviewTaskText(repository, prNumber, headSha, context) {
+    const task = `Review pull request #${prNumber} in ${repository} (head ${headSha}).`;
+    return context ? composeTaskOverride(`${task}\n\n${context.task}`, context.untrustedContext) : task;
+}
 /** Run states that already cover a commit: a review of it is under way or done. */
 const COVERING_REVIEW_STATUSES = ["pending", "running", "succeeded"];
 /**
@@ -360,9 +374,16 @@ async function alreadyReviewed(deps, repository, prNumber, headSha, agentId) {
     });
     return prior !== null;
 }
-async function startReviews(deps, host, repository, prNumber, headSha, targets, 
+/** Starts one review run per target on a pull request head; returns the started run ids. */
+export async function startReviews(deps, host, repository, prNumber, headSha, targets, 
 /** True for automatic triggers; an explicit re-run or `@wardby review` always runs. */
-skipReviewedCommits = false) {
+skipReviewedCommits = false, 
+/**
+ * Extra context for this review: `task` (written by wardby, trusted) is appended to the
+ * review task; `untrustedContext` (anything a model or a person wrote) travels separately,
+ * delivered as data.
+ */
+context) {
     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.
@@ -404,7 +425,7 @@ skipReviewedCommits = false) {
                 selfDefects: { db: deps.db, issueTrackers: deps.issueTrackers },
                 agentId: target.agentId,
                 trigger: "host_event",
-                taskOverride: `Review pull request #${prNumber} in ${repository} (head ${headSha}).`,
+                taskOverride: reviewTaskText(repository, prNumber, headSha, context),
                 attribution: await linkedAttribution(),
                 afterPersist: checkId
                     ? async (tx, run) => {
@@ -590,6 +611,7 @@ async function deferUntilCi(deps, host, key, links) {
                     prNumber: key.prNumber,
                     headSha: key.headSha,
                     agentId: { in: links.map((l) => l.agentId) },
+                    reason: "ci",
                 },
                 select: { id: true, agentId: true, checkName: true },
             });
@@ -606,8 +628,8 @@ async function deferUntilCi(deps, host, key, links) {
  * 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
+ * delivery or sweep starts each review only once. On `ci` and `request`, 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.
  */
@@ -623,7 +645,7 @@ async function startDeferred(deps, host, key, rows, reviewerLinks, mode, reason)
     const allowedIds = new Set(allowed.map((l) => l.agentId));
     const targets = [];
     for (const row of rows) {
-        if (mode === "ci" && !allowedIds.has(row.agentId))
+        if (mode !== "sweep" && !allowedIds.has(row.agentId))
             continue;
         const claimed = await deps.db.deferredReview.deleteMany({ where: { id: row.id } });
         if (claimed.count !== 1)
@@ -647,14 +669,16 @@ async function startDeferred(deps, host, key, rows, reviewerLinks, mode, reason)
 }
 /**
  * ci_completed: starts the reviews deferred on this head (see deferUntilCi),
- * unless CI there is still pending (a later completion decides). Never
+ * unless CI there is still pending (a later completion decides). Rows still
+ * waiting for their delegating run (reason "request") are not CI's to start:
+ * startDeferredForRequest hands them over once that run is terminal. 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,
+            where: { ...key, reason: "ci" },
             select: { id: true, agentId: true, checkName: true },
         });
         if (rows.length === 0)
@@ -676,9 +700,21 @@ async function startDeferredAfterCi(deps, host, event, prNumber, reviewerLinks)
  * 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.
+ * completion webhook was missed. Rows waiting for a delegating run (reason
+ * "request") are released the same way once they are that old, but only when
+ * that run is terminal (or gone): a lead the reconciler marked lost never
+ * reaches its finalizer. Never throws; returns the runs started.
  */
 export async function startDeferredReviews(deps, now = new Date()) {
+    const providers = Object.keys(deps.hosts);
+    const runIds = await sweepCiRows(deps, providers, now);
+    // Outside the CI half's try: a failure there never keeps request rows from being released.
+    if (providers.length > 0)
+        runIds.push(...(await sweepRequestRows(deps, providers, now)));
+    return runIds;
+}
+/** The sweep's half for expiry and CI rows: drops rows past the max age, then starts CI rows past the max wait. */
+async function sweepCiRows(deps, providers, now) {
     const runIds = [];
     try {
         const expired = await deps.db.deferredReview.deleteMany({
@@ -686,12 +722,12 @@ export async function startDeferredReviews(deps, now = new Date()) {
         });
         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 },
+                reason: "ci",
                 createdAt: { lte: new Date(now.getTime() - DEFERRED_REVIEW_MAX_WAIT_MS) },
             },
             select: {
@@ -732,6 +768,214 @@ export async function startDeferredReviews(deps, now = new Date()) {
     }
     return runIds;
 }
+/** The sweep's half for request rows: releases those older than the max wait whose delegating run is terminal or gone. */
+async function sweepRequestRows(deps, providers, now) {
+    const runIds = [];
+    try {
+        // Joined in the query, so leads still running never fill the batch ahead of finished ones.
+        const leads = await deps.db.$queryRaw `
+      SELECT DISTINCT d."leadRunId"
+      FROM "DeferredReview" d
+      LEFT JOIN "Run" r ON r."id" = d."leadRunId"
+      WHERE d."reason" = 'request'
+        AND d."leadRunId" IS NOT NULL
+        AND d."provider" IN (${Prisma.join(providers)})
+        AND d."createdAt" <= ${new Date(now.getTime() - DEFERRED_REVIEW_MAX_WAIT_MS)}
+        AND (r."id" IS NULL OR r."status"::text NOT IN ('pending', 'running'))
+      LIMIT ${DEFERRED_REVIEW_BATCH}`;
+        for (const { leadRunId } of leads)
+            runIds.push(...(await releaseRequestRows(deps, leadRunId, "sweep")));
+    }
+    catch (err) {
+        log.warn({ err }, "deferred review sweep failed for reviews waiting on a delegating run");
+    }
+    return runIds;
+}
+/**
+ * The run whose finish a review of this pull request waits for: the root of
+ * the run tree when the PR's opening coding run was delegated (it has a
+ * parent run) and that root is not terminal yet; otherwise null (a
+ * non-delegated coding PR, a finished request, or an unknown marker). A lead's
+ * delegate_to_* calls block until each child is terminal, so a terminal root
+ * means every sibling coding run of the request has finished and opened its
+ * pull request. A continuation's marker resolves to its root coding run, then
+ * up that run's parents. `repository`, when given, must be the coding run's.
+ */
+export async function requestLeadRunId(db, prMarkerRunId, repository) {
+    const root = await runTreeRoot(db, prMarkerRunId, repository);
+    if (!root || root.isOpener || !RUN_NOT_FINISHED.has(root.status))
+        return null;
+    return root.id;
+}
+/** Run statuses that mean the delegating run has not finished. */
+const RUN_NOT_FINISHED = new Set(["pending", "running"]);
+/**
+ * pr_updated for a pull request a delegated coding run opened, while the
+ * request's lead run is still running: records one DeferredReview row per
+ * reviewer (reason "request", with or without waitForCi) and starts nothing;
+ * the lead's finalizer (startDeferredForRequest) or the sweep starts them.
+ * Returns null, to review as without it, for any other pull request, or when
+ * the lead cannot be resolved or the deferral cannot be recorded.
+ */
+async function deferUntilRequest(deps, host, key, links, 
+/** The pull request's origin, read at most once per event (shared with the merge order check). */
+readOrigin) {
+    if (links.length === 0 || !readOrigin)
+        return null;
+    let leadRunId;
+    try {
+        const origin = await readOrigin();
+        if (!origin.markerRunId)
+            return null;
+        leadRunId = await requestLeadRunId(deps.db, origin.markerRunId, key.repository);
+    }
+    catch (err) {
+        log.warn({ err, repository: key.repository, prNumber: key.prNumber }, "could not read the pull request's delegating run; reviewing as usual");
+        return null;
+    }
+    if (!leadRunId)
+        return null;
+    const head = { provider: key.provider, repository: key.repository, prNumber: key.prNumber, headSha: key.headSha };
+    try {
+        // Idempotent per head and reviewer, like deferUntilCi.
+        await deps.db.deferredReview.createMany({
+            data: links.map((l) => ({ ...head, agentId: l.agentId, checkName: l.checkName, reason: "request", leadRunId })),
+            skipDuplicates: true,
+        });
+        // A row this head already had for CI waits for the request too: released only when both are done.
+        await deps.db.deferredReview.updateMany({
+            where: { ...head, agentId: { in: links.map((l) => l.agentId) }, reason: "ci" },
+            data: { reason: "request", leadRunId },
+        });
+    }
+    catch (err) {
+        log.warn({ err, repository: key.repository, prNumber: key.prNumber }, "could not record the deferred review; reviewing as usual");
+        return null;
+    }
+    log.info({ ...head, leadRunId, agentIds: links.map((l) => l.agentId) }, "review deferred until the delegating run finishes");
+    // The lead may have finished between the lookup and the insert, its
+    // finalizer finding no row yet: check once more (rows are claimed by
+    // delete, so a racing finalizer starts each review once). A failure leaves
+    // the rows for the sweep.
+    const runIds = [];
+    try {
+        const lead = await deps.db.run.findUnique({ where: { id: leadRunId }, select: { status: true } });
+        if (!lead || !RUN_NOT_FINISHED.has(lead.status)) {
+            runIds.push(...(await releaseRequestRows(deps, leadRunId, "request")));
+        }
+    }
+    catch (err) {
+        log.warn({ err, repository: key.repository, prNumber: key.prNumber, leadRunId }, "could not re-check the delegating run after deferring; the sweep starts the review");
+    }
+    return { runIds };
+}
+/**
+ * The delegating run `leadRunId` is terminal (it succeeded, failed, or was
+ * cancelled): releases every review that waited for it. A reviewer linked
+ * with waitForCi whose head's CI is still pending is handed to CI (the row
+ * becomes reason "ci", its max wait counted from now); every other row is
+ * started (claimed by delete, so concurrent releases start each review once).
+ * Called from the lead's finalizer, after the related pull requests sections
+ * were rewritten. Never throws.
+ */
+export async function startDeferredForRequest(deps, leadRunId) {
+    try {
+        await releaseRequestRows(deps, leadRunId, "request");
+    }
+    catch (err) {
+        log.warn({ err, leadRunId }, "could not start the reviews waiting for the delegating run");
+    }
+}
+async function releaseRequestRows(deps, leadRunId, mode) {
+    const rows = await deps.db.deferredReview.findMany({
+        where: { leadRunId, reason: "request" },
+        select: {
+            id: true,
+            provider: true,
+            repository: true,
+            prNumber: true,
+            headSha: true,
+            agentId: true,
+            checkName: true,
+        },
+        orderBy: { createdAt: "asc" },
+    });
+    const groups = new Map();
+    for (const row of rows) {
+        const id = JSON.stringify([row.provider, row.repository, row.prNumber, row.headSha]);
+        groups.set(id, [...(groups.get(id) ?? []), row]);
+    }
+    const runIds = [];
+    for (const group of groups.values()) {
+        const first = group[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 releaseRequestHead(deps, host, key, group, reviewerLinks, mode)));
+        }
+        catch (err) {
+            log.warn({ err, repository: key.repository, prNumber: key.prNumber, leadRunId }, "could not start a review waiting for the delegating run");
+        }
+    }
+    return runIds;
+}
+/** One head's request rows: hands waitForCi rows with CI still pending to CI, starts the rest. */
+async function releaseRequestHead(deps, host, key, rows, reviewerLinks, mode) {
+    const waitsForCi = new Set(reviewerLinks.filter((l) => l.waitForCi).map((l) => l.agentId));
+    let ciRows = rows.filter((r) => waitsForCi.has(r.agentId));
+    if (ciRows.length > 0 && host.readCi) {
+        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");
+        }
+        if (state === undefined || !CI_NOT_FINISHED_ON_PUSH.has(state))
+            ciRows = [];
+    }
+    else
+        ciRows = [];
+    const startNow = rows.filter((r) => !ciRows.includes(r));
+    const runIds = startNow.length > 0
+        ? await startDeferred(deps, host, key, startNow, reviewerLinks, mode, "the delegating run finished")
+        : [];
+    if (ciRows.length === 0 || !host.readCi)
+        return runIds;
+    const ids = ciRows.map((r) => r.id);
+    // Only a row still waiting for the request flips: a concurrent release that claimed it already started it.
+    await deps.db.deferredReview.updateMany({
+        where: { id: { in: ids }, reason: "request" },
+        data: { reason: "ci", createdAt: new Date() },
+    });
+    log.info({
+        repository: key.repository,
+        prNumber: key.prNumber,
+        headSha: key.headSha,
+        agentIds: ciRows.map((r) => r.agentId),
+    }, "the delegating run finished; review deferred until CI finishes");
+    // As in deferUntilCi: CI may have finished before the flip, its ci_completed skipping the request row.
+    try {
+        const again = (await host.readCi(key.repository, key.headSha)).state;
+        if (!CI_NOT_FINISHED_ON_PUSH.has(again)) {
+            const handed = await deps.db.deferredReview.findMany({
+                where: { id: { in: ids }, reason: "ci" },
+                select: { id: true, agentId: true, checkName: true },
+            });
+            if (handed.length > 0) {
+                runIds.push(...(await startDeferred(deps, host, key, handed, reviewerLinks, "ci", "CI finished")));
+            }
+        }
+    }
+    catch (err) {
+        log.warn({ err, repository: key.repository, prNumber: key.prNumber }, "could not re-read CI after the delegating run finished; the sweep starts the review");
+    }
+    return runIds;
+}
 export async function routeHostEvent(event, deps) {
     const none = { runIds: [], followUps: [] };
     if (event.kind === "pr_closed") {
@@ -742,7 +986,18 @@ export async function routeHostEvent(event, deps) {
             number: event.prNumber,
             merged: event.merged,
         });
-        return none;
+        // The merge order checks of the sets this PR is a step of, after the response. Never throws.
+        if (!deps.hosts[event.provider]?.upsertNamedCheck)
+            return none;
+        const pr = { repository: event.repository, number: event.prNumber };
+        return {
+            runIds: [],
+            followUps: [
+                () => syncMergeOrderChecksForPullRequest(deps, pr, {
+                    closed: { ...pr, merged: event.merged },
+                }),
+            ],
+        };
     }
     const host = deps.hosts[event.provider];
     if (!host)
@@ -816,11 +1071,30 @@ export async function routeHostEvent(event, deps) {
             return { runIds, followUps: [] };
         }
         case "pr_updated": {
-            if (event.isFork || reviewerLinks.length === 0)
+            if (event.isFork)
                 return none;
+            // Read at most once per event, by the request deferral and the merge order check alike.
+            let origin;
+            const readOrigin = host.pullRequestOrigin
+                ? () => (origin ??= host.pullRequestOrigin(event.repository, event.prNumber))
+                : undefined;
+            // A new head needs the merge order check re-posted (check runs are per commit), on every
+            // path below, a review held for the delegating run included. After the response; never throws.
+            const followUps = host.upsertNamedCheck && readOrigin
+                ? [
+                    () => syncMergeOrderChecksForPullRequest(deps, { repository: event.repository, number: event.prNumber }, { origin: { repository: event.repository, number: event.prNumber, read: readOrigin } }),
+                ]
+                : [];
+            if (reviewerLinks.length === 0)
+                return { runIds: [], followUps };
             const allowed = await authorizedLinks(deps, event, reviewerLinks);
             if (allowed.length === 0)
-                return none;
+                return { runIds: [], followUps };
+            // A PR a delegated coding run opened is reviewed once the whole request
+            // finished, so its sibling PRs exist and the related section is current (#259).
+            const request = await deferUntilRequest(deps, host, event, allowed, readOrigin);
+            if (request)
+                return { runIds: request.runIds, 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);
@@ -829,7 +1103,7 @@ export async function routeHostEvent(event, deps) {
             if (reviewers.length > 0) {
                 runIds.push(...(await startReviews(deps, host, event.repository, event.prNumber, event.headSha, reviewers, true)));
             }
-            return { runIds, followUps: [] };
+            return { runIds, followUps };
         }
         case "ci_completed": {
             if (reviewerLinks.length === 0)

package/dist/core/issue-bridge.js

@@ -11,6 +11,7 @@
 import { Prisma } from "#prisma";
 import { projectOf, } from "../providers/issue-tracker/types.js";
 import { logger } from "./logger.js";
+import { dedupeKeys, emitWorkflowEvent } from "./workflow-events.js";
 const log = logger.child({ module: "issue-bridge" });
 export const pullRequestGlobalId = (pr) => `wardby:pr:${pr.codeProvider}:${pr.repository}#${pr.number}`;
 /**
@@ -77,10 +78,13 @@ export async function recordPullRequests(db, tracker, input) {
     const notes = [];
     try {
         let newlyOpened = false;
+        const opened = [];
         for (const pr of input.pullRequests) {
             const state = await ensurePair(db, input, pr);
-            if (state === "created" && pr.outcome === "pull_request_opened")
+            if (state === "created" && pr.outcome === "pull_request_opened") {
                 newlyOpened = true;
+                opened.push(pr);
+            }
             if (state !== "created" && state !== "open")
                 continue;
             try {
@@ -95,15 +99,28 @@ export async function recordPullRequests(db, tracker, input) {
             }
         }
         const target = input.onPullRequestOpened;
+        let movedTo = null;
         if (target && newlyOpened) {
             try {
-                await tracker.transitionTo(input.issueKey, target);
+                const moved = await tracker.transitionTo(input.issueKey, target);
+                movedTo = moved.toStatus || target;
             }
             catch (err) {
                 log.warn({ err, issueKey: input.issueKey, target }, "could not move the issue after a pull request opened");
                 notes.push(`Could not move ${input.issueKey} to "${target}"; it may need a manual move.`);
             }
         }
+        // Only pairs this call newly recorded, so a retried completion does not notify twice. Never throws.
+        for (const pr of opened) {
+            await emitWorkflowEvent({
+                dedupeKey: dedupeKeys.prOpened(pr.codeProvider, pr.repository, pr.number),
+                runId: pr.openedByRunId,
+                agentId: input.agentId,
+                workItem: { provider: input.issueProvider, key: input.issueKey },
+                pullRequest: { codeProvider: pr.codeProvider, repository: pr.repository, number: pr.number },
+                payload: { kind: "pr_opened", prLabel: `${pr.repository}#${pr.number}`, prUrl: pr.url, movedTo },
+            });
+        }
     }
     catch (err) {
         log.warn({ err, issueKey: input.issueKey }, "could not bridge the pull requests to the issue");
@@ -128,6 +145,23 @@ export async function handlePullRequestClosed(db, trackers, pr) {
     // Not caught: nothing is claimed yet, and a throw rolls back the delivery so it is redelivered.
     const rows = await db.issuePullRequest.findMany({ where: { ...where, state: "open" } });
     for (const row of rows) {
+        // Exactly once per claimed row, from the finally below, even when a later step throws: the row is no
+        // longer open, so nothing would retry it. Never throws.
+        const emitClosed = (movedTo) => emitWorkflowEvent({
+            dedupeKey: dedupeKeys.prClosed(pr.codeProvider, pr.repository, pr.number),
+            agentId: row.agentId,
+            workItem: { provider: row.issueProvider, key: row.issueKey },
+            pullRequest: { codeProvider: pr.codeProvider, repository: pr.repository, number: pr.number },
+            payload: {
+                kind: "pr_closed",
+                prLabel: `${row.repository}#${row.number}`,
+                prUrl: row.url,
+                merged: pr.merged,
+                movedTo,
+            },
+        });
+        let claimedRow = false;
+        let movedTo = null;
         try {
             const claimed = await db.issuePullRequest.updateMany({
                 where: { id: row.id, state: "open" },
@@ -135,6 +169,7 @@ export async function handlePullRequestClosed(db, trackers, pr) {
             });
             if (claimed.count === 0)
                 continue;
+            claimedRow = true;
             const tracker = trackers[row.issueProvider];
             if (!tracker)
                 continue;
@@ -166,6 +201,7 @@ export async function handlePullRequestClosed(db, trackers, pr) {
                 if (target) {
                     try {
                         const moved = await tracker.transitionTo(row.issueKey, target);
+                        movedTo = moved.toStatus;
                         markdown += ` Moved to ${moved.toStatus}.`;
                     }
                     catch (err) {
@@ -185,5 +221,9 @@ export async function handlePullRequestClosed(db, trackers, pr) {
         catch (err) {
             log.warn({ err, issueKey: row.issueKey, ...where }, "could not bridge the closed pull request to the issue");
         }
+        finally {
+            if (claimedRow)
+                await emitClosed(movedTo);
+        }
     }
 }

package/dist/core/issue-events.js

@@ -4,6 +4,7 @@ import { issueStatusRow, postIssueWorkingStatus } from "./issue-status.js";
 import { logger } from "./logger.js";
 import { openSiblingsForIssue, SIBLING_GUIDANCE } from "./related-pull-requests.js";
 import { composeTaskOverride } from "./untrusted-content.js";
+import { dedupeKeys, emitWorkflowEvent } from "./workflow-events.js";
 const log = logger.child({ module: "issue-events" });
 const MAX_TASK_BODY = 8000;
 const RUN_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
@@ -93,7 +94,7 @@ export async function routeIssueEvent(event, deps) {
         return result;
     const links = (await deps.db.agentIssueProject.findMany({
         where: { provider: event.provider, projectKey: event.projectKey },
-        include: { agent: { select: { ownerId: true, kind: true } } },
+        include: { agent: { select: { ownerId: true, kind: true, name: true } } },
     }));
     const bot = await tracker.botAccountId();
     // One snapshot per event, taken lazily on the first dispatch so an event no link matches costs nothing.
@@ -139,6 +140,16 @@ export async function routeIssueEvent(event, deps) {
             const runId = dispatched.run.id;
             result.runIds.push(runId);
             result.followUps.push(() => postIssueWorkingStatus(deps.db, deps.trackers, runId));
+            // describeKind shows only admin-configured values, so the trigger is safe to show in chat.
+            const trigger = matched.map((k) => describeKind(event, k, link)).join("; ");
+            const agentName = link.agent.name;
+            result.followUps.push(() => emitWorkflowEvent({
+                dedupeKey: dedupeKeys.issuePickedUp(runId),
+                runId,
+                agentId: link.agentId,
+                workItem: { provider: event.provider, key: event.issueKey },
+                payload: { kind: "issue_picked_up", agentName, trigger },
+            }));
             log.info({ issueKey: event.issueKey, agentId: link.agentId, runId, kinds: matched }, "issue run dispatched");
         }
         catch (err) {

package/dist/core/issue-status.js

@@ -22,12 +22,23 @@ export function toJiraMarkdown(text) {
 export function issueStatusRow(event, runId, visibilityRole) {
     return { runId, provider: "jira", issueKey: event.issueKey, visibilityRole };
 }
+/**
+ * Cents from $1 up ($12.34, $1234.50); below $1, two significant digits with at
+ * least two decimals so fractions of a cent stay readable ($0.50, $0.12, $0.0035).
+ * Never exponent form.
+ */
+const usd = (amount) => {
+    const abs = Math.abs(amount);
+    const decimals = abs === 0 || abs >= 1 ? 2 : Math.max(2, 1 - Math.floor(Math.log10(abs)));
+    // Trailing zeros past the cents are noise ($0.010, $0.100 from rounding up).
+    return `$${amount.toFixed(Math.min(decimals, 20)).replace(/(\.\d\d\d*?)0+$/, "$1")}`;
+};
 export function formatSpendLine(input) {
-    const parts = [`Agent spend: $${input.treeUsd.toFixed(4)} this run`];
+    const parts = [`Agent spend: ${usd(input.treeUsd)} this run`];
     if (input.issueUsd !== null)
-        parts.push(`$${input.issueUsd.toFixed(4)} on this issue so far`);
+        parts.push(`${usd(input.issueUsd)} on this issue so far`);
     if (input.models.length > 0)
-        parts.push(input.models.map((m) => `${m.model} $${m.costUsd.toFixed(4)}`).join(", "));
+        parts.push(input.models.map((m) => `${m.model} ${usd(m.costUsd)}`).join(", "));
     return parts.join(" · ");
 }
 /** The whole run tree under `runId` (every depth), the issue's total across all its runs, and the tree's models. */