@wardby/cli 0.4.1 → 0.5.1

package/dist/core/ci-context.js

@@ -0,0 +1,59 @@
+/**
+ * What repo_pr_read tells a reviewer about CI. The note is deterministic and
+ * written here, not by the host, so every reviewer prompt gets the same rule:
+ * CI on the head commit is authoritative about build and tests; the
+ * description's Tests come from Wardby's sandbox, which may have had an
+ * incomplete install.
+ */
+import { FAILING_CONCLUSIONS } from "../providers/review-host/ci.js";
+import { DEPENDENCY_INSTALL_INCOMPLETE } from "../providers/vcs/github.js";
+const MAX_NAMED = 10;
+function named(ci, pick) {
+    const names = ci.checks.filter(pick).map((c) => c.name);
+    const shown = names.slice(0, MAX_NAMED).join(", ");
+    return names.length > MAX_NAMED ? `${shown} and ${names.length - MAX_NAMED} more` : shown;
+}
+export function ciNote(ci, sandboxInstallIncomplete) {
+    const n = ci.checks.length;
+    const plural = `${n} check${n === 1 ? "" : "s"}`;
+    const sandbox = sandboxInstallIncomplete
+        ? ` The description's ${DEPENDENCY_INSTALL_INCOMPLETE.replace(/\.$/, "")} warning means Wardby's sandbox could not install every package, so a failure under its Tests is not evidence against this change.`
+        : "";
+    const statuses = ci.statusesUnavailable && ci.state !== "unavailable"
+        ? " Commit statuses could not be read (often because the App lacks Commit statuses: Read), so only check runs are listed."
+        : "";
+    let main;
+    switch (ci.state) {
+        case "passing":
+            main = `CI passed on this head (${plural}). The description's Tests were run in Wardby's sandbox; where they disagree with CI, CI is authoritative.`;
+            break;
+        case "failing":
+            main = `CI failed on this head: ${named(ci, (c) => c.status === "completed" && FAILING_CONCLUSIONS.has(c.conclusion ?? ""))}. Base build and test findings on these checks, not on the description's Tests.`;
+            break;
+        case "pending":
+            main = `CI is still running on this head (${named(ci, (c) => c.status !== "completed")}). These results are not final: say they were pending; do not report them as passed or failed, and do not use the description's Tests in their place.`;
+            break;
+        case "inconclusive":
+            main = `CI finished without a clear result on this head (${plural}; some were cancelled, stale, or skipped). Do not report the change as failing CI.`;
+            break;
+        case "none":
+            main = "No CI checks or statuses are reported on this head: CI may not be configured, or has not started yet.";
+            break;
+        case "unavailable":
+            main = `CI results could not be read (${ci.unavailableReason ?? "unknown"}). Do not infer CI results from the description.`;
+            break;
+    }
+    return `${main}${statuses}${sandbox}`;
+}
+export function ciForAgent(view) {
+    const ci = view.ci ?? {
+        headSha: view.headSha,
+        state: "unavailable",
+        checks: [],
+        truncated: false,
+        statusesUnavailable: true,
+        unavailableReason: "host_unsupported",
+    };
+    const sandboxInstallIncomplete = (view.body ?? "").includes(`**${DEPENDENCY_INSTALL_INCOMPLETE}**`);
+    return { ...ci, sandboxInstallIncomplete, note: ciNote(ci, sandboxInstallIncomplete) };
+}

package/dist/core/delegation-siblings.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The children one run attempt's delegations have running right now, and a
+ * signal for when any of them finishes. Used with the delegation gate
+ * (serial-gate.ts) under Agent.parallelDelegations: a delegation refused for
+ * budget while a sibling still runs waits for that sibling to finish and
+ * free its hold, then tries again. A delegation that is waiting is not in
+ * flight itself, so two waiting delegations never wait on each other.
+ */
+export interface DelegationSiblings {
+    /** Children started and not yet finished. */
+    readonly inFlight: number;
+    /** How many children have finished so far: pass it to nextFinish to not miss a finish in between. */
+    readonly finishes: number;
+    /** Counts one child as running. Returns its finish, which is idempotent. */
+    start(): () => void;
+    /**
+     * Resolves true once a child finishes after `sinceFinishes` was read (at once if one already
+     * has), or after this call when it is omitted; false after timeoutMs.
+     */
+    nextFinish(timeoutMs: number, sinceFinishes?: number): Promise<boolean>;
+}
+export declare function createDelegationSiblings(): DelegationSiblings;

package/dist/core/delegation-siblings.js

@@ -0,0 +1,40 @@
+export function createDelegationSiblings() {
+    let inFlight = 0;
+    let finishes = 0;
+    const waiters = new Set();
+    return {
+        get inFlight() {
+            return inFlight;
+        },
+        get finishes() {
+            return finishes;
+        },
+        start() {
+            inFlight += 1;
+            let finished = false;
+            return () => {
+                if (finished)
+                    return;
+                finished = true;
+                inFlight -= 1;
+                finishes += 1;
+                for (const wake of [...waiters])
+                    wake();
+            };
+        },
+        nextFinish(timeoutMs, sinceFinishes = finishes) {
+            if (finishes > sinceFinishes)
+                return Promise.resolve(true);
+            return new Promise((resolve) => {
+                const settle = (woken) => {
+                    clearTimeout(timer);
+                    waiters.delete(wake);
+                    resolve(woken);
+                };
+                const wake = () => settle(true);
+                const timer = setTimeout(() => settle(false), Math.max(0, timeoutMs));
+                waiters.add(wake);
+            });
+        },
+    };
+}

package/dist/core/dispatch.d.ts

@@ -4,7 +4,7 @@ import { type AttributionIntent } from "./attribution.js";
 import { type BudgetConstraint } from "./budget-groups.js";
 import { type SelfDefectSink } from "./self-defects.js";
 export type DispatchDb = Pick<PrismaClient, "agent" | "run" | "runHostCheck" | "codingRun" | "task" | "webhook" | "budgetGroup" | "$transaction" | "$queryRaw">;
-export type DispatchTx = Pick<Prisma.TransactionClient, "agent" | "run" | "runHostCheck" | "runHostStatus" | "runIssueStatus" | "codingRun" | "codingService" | "task" | "webhook" | "budgetGroup" | "resourceGrant" | "workItem" | "runAttribution" | "$queryRaw" | "$executeRawUnsafe">;
+export type DispatchTx = Pick<Prisma.TransactionClient, "agent" | "run" | "runHostCheck" | "runHostStatus" | "runIssueStatus" | "codingRun" | "codingService" | "task" | "webhook" | "budgetGroup" | "resourceGrant" | "workItem" | "localPullRequest" | "runAttribution" | "$queryRaw" | "$executeRawUnsafe">;
 type DispatchAgent = Prisma.AgentGetPayload<{
     include: {
         codingProfile: true;
@@ -83,6 +83,14 @@ export interface DispatchRunOptions {
      * e.g. a sub-agent dispatch tool blocking the parent's own turn.
      */
     awaitExecution?: boolean;
+    /**
+     * Called once, right after the persist transaction commits and before the
+     * executor starts the run (refused and failed rows included): the moment
+     * the run row is visible to other transactions. The runner releases its
+     * delegation admission gate here, so a sibling delegation is admitted
+     * while this one's coding run is still starting or queued.
+     */
+    onPersisted?: (run: Run) => void;
 }
 export interface DispatchRunResult {
     run: Run;
@@ -107,6 +115,13 @@ export interface DispatchRunResult {
  * @internal Exported only for the real-PostgreSQL tests.
  */
 export declare function isSerializationConflict(err: unknown): boolean;
+/**
+ * Prisma's interactive-transaction error (P2028): no pooled connection within
+ * `maxWait` ("Unable to start a transaction in the given time"), or the
+ * transaction outlived its timeout. Either way nothing was committed, so the
+ * caller can retry or queue.
+ */
+export declare function isTransactionUnavailable(err: unknown): boolean;
 /**
  * Record an executor-level failure on a run that never reached a terminal
  * state itself. Deliberately idempotent: the same failure can arrive twice —
@@ -124,12 +139,13 @@ export declare function markRunFailedFromExecutorError(db: Pick<DispatchDb, "run
 export declare function budgetExhaustedError(constraint: BudgetConstraint): string;
 /**
  * Attempts for the persist transaction, and the jittered backoff between
- * them, for serialization failures and deadlocks.
+ * them, for serialization failures, deadlocks and transactions that could
+ * not start in time (P2028).
  *
  * @internal Exported only for the real-PostgreSQL tests.
  */
 export declare const PERSIST_ATTEMPTS = 8;
-export type ContinuationRefusal = "unknown_run" | "other_repository" | "no_pull_request";
+export type ContinuationRefusal = "unknown_run" | "other_repository" | "no_pull_request" | "other_owner";
 /** A continuation refused because of the run it names. Its message is fixed text, safe to show the model. */
 export declare class ContinuationRefusedError extends Error {
     readonly reason: ContinuationRefusal;
@@ -152,8 +168,16 @@ export type ContinuationCheck = {
  * run (or its root) is in this database, in that repository, and opened a pull
  * request. A run id read from a pull request can name a run that another
  * deployment sharing the same App made, so check before relying on one.
+ *
+ * `dispatchingOwnerId`, when given (even `null`), additionally fails closed
+ * unless the root's opening agent has that exact owner: a sibling-hint or a
+ * PR's own marker names a run id, but nothing stops it naming a run opened by
+ * another owner's agent in the same repository, and continuing that run would
+ * let this dispatch push to a PR another owner's agent controls. `undefined`
+ * skips the check for callers that only ask "does this deployment know this
+ * run at all" (a user-facing refusal message, not a dispatch).
  */
-export declare function checkContinuation(reader: Pick<DispatchTx, "codingRun">, runId: string, repository: string): Promise<ContinuationCheck>;
+export declare function checkContinuation(reader: Pick<DispatchTx, "codingRun">, runId: string, repository: string, dispatchingOwnerId?: string | null): Promise<ContinuationCheck>;
 /**
  * Persists every detached run input in one transaction, then invokes the
  * executor only after commit. A null result means the caller's transactional

package/dist/core/dispatch.js

@@ -12,6 +12,7 @@ import { DEFAULT_KNOWLEDGE_BUNDLE_PATH } from "../knowledge/concept.js";
 import { KNOWLEDGE_INDEX_READ_MAX_BYTES, knowledgeSection } from "../knowledge/note.js";
 import { logger } from "./logger.js";
 import { CodingModelProviderMismatchError, resolveCodingEntry } from "./run-pricing.js";
+import { CONTENDED_TX_MAX_WAIT_MS } from "./timing.js";
 import { fileSelfDefectForRun } from "./self-defects.js";
 const dispatchLog = logger.child({ module: "dispatch" });
 /** SQLSTATEs worth retrying the persist transaction for: serialization failure, deadlock. */
@@ -52,6 +53,15 @@ export function isSerializationConflict(err) {
     }
     return false;
 }
+/**
+ * Prisma's interactive-transaction error (P2028): no pooled connection within
+ * `maxWait` ("Unable to start a transaction in the given time"), or the
+ * transaction outlived its timeout. Either way nothing was committed, so the
+ * caller can retry or queue.
+ */
+export function isTransactionUnavailable(err) {
+    return Boolean(err && typeof err === "object" && err.code === "P2028");
+}
 /**
  * Record an executor-level failure on a run that never reached a terminal
  * state itself. Deliberately idempotent: the same failure can arrive twice —
@@ -115,7 +125,8 @@ async function reserveCodingBudget(tx, agent, now, options) {
 }
 /**
  * Attempts for the persist transaction, and the jittered backoff between
- * them, for serialization failures and deadlocks.
+ * them, for serialization failures, deadlocks and transactions that could
+ * not start in time (P2028).
  *
  * @internal Exported only for the real-PostgreSQL tests.
  */
@@ -130,6 +141,7 @@ const CONTINUATION_REFUSALS = {
     unknown_run: "Cannot continue an unknown coding run.",
     other_repository: "Cannot continue a coding run from a different repository.",
     no_pull_request: "Cannot continue a coding run that never opened a pull request.",
+    other_owner: "Cannot continue a coding run opened by a different owner's agent.",
 };
 /** A continuation refused because of the run it names. Its message is fixed text, safe to show the model. */
 export class ContinuationRefusedError extends Error {
@@ -140,18 +152,31 @@ export class ContinuationRefusedError extends Error {
         this.name = "ContinuationRefusedError";
     }
 }
+/** Carries the root's opening agent's owner along with the row, for the same-owner check below. */
+const CONTINUATION_ROOT_INCLUDE = { run: { select: { agent: { select: { ownerId: true } } } } };
 /**
  * Whether this deployment can continue coding run `runId` in `repository`: the
  * run (or its root) is in this database, in that repository, and opened a pull
  * request. A run id read from a pull request can name a run that another
  * deployment sharing the same App made, so check before relying on one.
+ *
+ * `dispatchingOwnerId`, when given (even `null`), additionally fails closed
+ * unless the root's opening agent has that exact owner: a sibling-hint or a
+ * PR's own marker names a run id, but nothing stops it naming a run opened by
+ * another owner's agent in the same repository, and continuing that run would
+ * let this dispatch push to a PR another owner's agent controls. `undefined`
+ * skips the check for callers that only ask "does this deployment know this
+ * run at all" (a user-facing refusal message, not a dispatch).
  */
-export async function checkContinuation(reader, runId, repository) {
-    const candidate = await reader.codingRun.findUnique({ where: { runId } });
+export async function checkContinuation(reader, runId, repository, dispatchingOwnerId) {
+    const candidate = await reader.codingRun.findUnique({ where: { runId }, include: CONTINUATION_ROOT_INCLUDE });
     if (!candidate)
         return { ok: false, reason: "unknown_run" };
     const root = candidate.rootCodingRunId
-        ? await reader.codingRun.findUnique({ where: { runId: candidate.rootCodingRunId } })
+        ? await reader.codingRun.findUnique({
+            where: { runId: candidate.rootCodingRunId },
+            include: CONTINUATION_ROOT_INCLUDE,
+        })
         : candidate;
     if (!root)
         return { ok: false, reason: "unknown_run" };
@@ -163,6 +188,14 @@ export async function checkContinuation(reader, runId, repository) {
         rootResult.pullRequestNumber === undefined) {
         return { ok: false, reason: "no_pull_request" };
     }
+    if (dispatchingOwnerId !== undefined) {
+        const rootOwnerId = root.run?.agent?.ownerId ?? null;
+        // A null owner on either side is never treated as a match: an owner-less
+        // agent gets no continuation trust, fail closed either direction.
+        if (dispatchingOwnerId === null || rootOwnerId === null || dispatchingOwnerId !== rootOwnerId) {
+            return { ok: false, reason: "other_owner" };
+        }
+    }
     return {
         ok: true,
         root: {
@@ -177,13 +210,15 @@ export async function checkContinuation(reader, runId, repository) {
  * Resolves a coding run's branch: an override, else a continuation root's
  * (see checkContinuation), else the profile's base.
  */
-async function resolveCodingBranch(reader, options, profile) {
+async function resolveCodingBranch(reader, options, profile, 
+/** The dispatched (continuing) agent's current owner; checkContinuation fails closed against it. */
+ownerId) {
     if (options.continuesCodingRunId === undefined)
         return { baseRef: options.codingBaseRef ?? profile.baseRef };
     if (options.codingBaseRef !== undefined) {
         throw new Error("continuesCodingRunId cannot be combined with codingBaseRef.");
     }
-    const check = await checkContinuation(reader, options.continuesCodingRunId, profile.repository);
+    const check = await checkContinuation(reader, options.continuesCodingRunId, profile.repository, ownerId);
     if (!check.ok)
         throw new ContinuationRefusedError(check.reason);
     const { root } = check;
@@ -199,19 +234,22 @@ const UNREADABLE_DECLARATION = {
     github_file_too_large: `it is larger than ${MAX_SERVICE_DECLARATION_BYTES} bytes`,
     github_file_not_a_file: "it is not a file",
     github_file_not_utf8: "it is not UTF-8 text",
+    local_file_too_large: `it is larger than ${MAX_SERVICE_DECLARATION_BYTES} bytes`,
+    local_file_not_a_file: "it is not a file",
+    local_file_not_utf8: "it is not UTF-8 text",
 };
 /**
  * The knowledge note's input (docs/knowledge.md): the repository's bundle
  * index at the run's base, read before the transaction like the services
  * declaration. Any failure means no note, never a failed dispatch.
  */
-async function readKnowledgeIndex(options, profile, resolvedBranch) {
+async function readKnowledgeIndex(options, profile, resolvedBranch, ownerId) {
     const executor = options.executor;
     if (!executor.readCodingRepositoryFile)
         return undefined;
     try {
         // Resolved here, inside the try: a branch problem is the transaction's to report, not the note's.
-        const branch = resolvedBranch ?? (await resolveCodingBranch(options.db, options, profile));
+        const branch = resolvedBranch ?? (await resolveCodingBranch(options.db, options, profile, ownerId));
         const indexText = await executor.readCodingRepositoryFile({
             repository: profile.repository,
             baseRef: normalizeGitRef(branch.baseRef),
@@ -235,8 +273,8 @@ async function readKnowledgeIndex(options, profile, resolvedBranch) {
  * call, so it runs before the Serializable transaction, which reuses the
  * branch and resolves the services against the catalog and the agent.
  */
-async function readServiceDeclaration(options, profile) {
-    const branch = await resolveCodingBranch(options.db, options, profile);
+async function readServiceDeclaration(options, profile, ownerId) {
+    const branch = await resolveCodingBranch(options.db, options, profile, ownerId);
     const read = { repository: profile.repository, profileBaseRef: profile.baseRef, branch };
     const executor = options.executor;
     if (!executor.readCodingServiceDeclaration)
@@ -312,6 +350,7 @@ export async function dispatchRun(options) {
         where: { id: options.agentId },
         select: {
             kind: true,
+            ownerId: true,
             budgetGroupId: true,
             codingProfile: { select: { repository: true, baseRef: true, services: true } },
         },
@@ -322,11 +361,11 @@ export async function dispatchRun(options) {
     const declarationRead = preview?.kind === "coding" &&
         preview.codingProfile &&
         parseAllowedServiceNames(preview.codingProfile.services).length > 0
-        ? await readServiceDeclaration(options, preview.codingProfile)
+        ? await readServiceDeclaration(options, preview.codingProfile, preview.ownerId ?? null)
         : undefined;
     // The knowledge note's input: the repository's bundle index at the run's base (a network call).
     const knowledgeIndex = preview?.kind === "coding" && preview.codingProfile && options.executor.readCodingRepositoryFile
-        ? await readKnowledgeIndex(options, preview.codingProfile, declarationRead?.branch)
+        ? await readKnowledgeIndex(options, preview.codingProfile, declarationRead?.branch, preview.ownerId ?? null)
         : undefined;
     const persistOnce = () => options.db.$transaction(async (tx) => {
         if (lockGroups)
@@ -438,7 +477,7 @@ export async function dispatchRun(options) {
             const task = composeCodingTask(agent.systemPrompt, request, servicesInstructionNote(services), knowledgeIndex ? knowledgeSection(knowledgeIndex) : undefined);
             const budgetUsd = codingBudget.budgetUsd;
             // Resolved once: before the transaction when the declaration was read from it.
-            const branch = declarationRead?.branch ?? (await resolveCodingBranch(tx, options, agent.codingProfile));
+            const branch = declarationRead?.branch ?? (await resolveCodingBranch(tx, options, agent.codingProfile, agent.ownerId));
             const { baseRef, continuationOf, rootCodingRunId } = branch;
             const headRef = branch.headRef ?? `wardby/run-${run.id}`;
             const input = CodingTaskInputSchema.parse({
@@ -485,6 +524,7 @@ export async function dispatchRun(options) {
                     budgetReservedUsd: budgetUsd,
                     rootCodingRunId,
                     workspaceDiskMb: agent.codingProfile.workspaceDiskMb,
+                    maxTurns: agent.codingProfile.maxTurns,
                     // Fixed here so a run's tracing never changes mid-run.
                     debugTrace: agent.codingProfile.debugTraceUntil != null &&
                         now.getTime() < agent.codingProfile.debugTraceUntil.getTime(),
@@ -510,7 +550,7 @@ export async function dispatchRun(options) {
             })
             : undefined;
         return { run, task };
-    }, { isolationLevel: "Serializable" });
+    }, { isolationLevel: "Serializable", maxWait: CONTENDED_TX_MAX_WAIT_MS });
     let persisted = null;
     for (let attempt = 0; attempt < PERSIST_ATTEMPTS; attempt += 1) {
         try {
@@ -518,13 +558,15 @@ export async function dispatchRun(options) {
             break;
         }
         catch (err) {
-            if (!isSerializationConflict(err) || attempt === PERSIST_ATTEMPTS - 1)
+            const retryable = isSerializationConflict(err) || isTransactionUnavailable(err);
+            if (!retryable || attempt === PERSIST_ATTEMPTS - 1)
                 throw err;
             await new Promise((resolve) => setTimeout(resolve, retryDelayMs(attempt)));
         }
     }
     if (!persisted)
         return null;
+    options.onPersisted?.(persisted.run);
     if (persisted.run.status === "refused" || persisted.run.status === "failed") {
         dispatchLog.warn({ runId: persisted.run.id, agentId: options.agentId, reason: persisted.run.error }, `coding run ${persisted.run.status} at dispatch`);
         return persisted;

package/dist/core/engine-native.d.ts

@@ -17,6 +17,22 @@ export declare class NativeEngine implements Engine {
      */
     private windDown;
     private finish;
+    /**
+     * One turn's tool calls, results in call order. The calls are split into
+     * runs of consecutive calls that `ctx.runsConcurrently` accepts; each such
+     * run of two or more is one concurrent batch, and every other call
+     * (including a lone accepted one) runs alone. Groups run strictly in call
+     * order and nothing is reordered: `[a, x, b]` runs a, then x, then b.
+     * Without `runsConcurrently` every call runs alone, exactly as before.
+     *
+     * Durability (DBOS): a step's id is assigned when the step starts, so every
+     * step here is started in an order fixed by the turn's recorded tool calls
+     * alone, never by timing. A batch's steps are started in one synchronous
+     * pass in call order and awaited with allSettled, not Promise.all, so a
+     * rejection never leaves sibling steps running unawaited (DBOS guidance);
+     * once all have settled, the first rejection by call order is rethrown.
+     */
+    private runToolCalls;
     /**
      * Streams one model turn, applying the mid-stream cutoff against the
      * *cumulative* running total (this extends Phase 1's single-turn

package/dist/core/engine-native.js

@@ -117,13 +117,13 @@ export class NativeEngine {
                 assistantMessage.toolCalls = turn.toolCalls;
             messages.push(assistantMessage);
             if (turn.toolCalls.length > 0) {
+                const results = await this.runToolCalls(ctx, step, turns, turn.toolCalls);
                 for (const [index, toolCall] of turn.toolCalls.entries()) {
-                    const resultJson = await step(`turn:${turns}:tool:${index}`, () => ctx.runSandboxTool(toolCall.name, toolCall.argsJson));
                     messages.push({
                         role: "tool",
                         toolCallId: toolCall.id,
                         name: toolCall.name,
-                        content: wrapUntrustedToolOutput(resultJson),
+                        content: wrapUntrustedToolOutput(results[index]),
                     });
                 }
                 continue;
@@ -162,6 +162,53 @@ export class NativeEngine {
     finish(status, finalText, turns, usage, error) {
         return { status, finalText, turns, usage, ...(error ? { error } : {}) };
     }
+    /**
+     * One turn's tool calls, results in call order. The calls are split into
+     * runs of consecutive calls that `ctx.runsConcurrently` accepts; each such
+     * run of two or more is one concurrent batch, and every other call
+     * (including a lone accepted one) runs alone. Groups run strictly in call
+     * order and nothing is reordered: `[a, x, b]` runs a, then x, then b.
+     * Without `runsConcurrently` every call runs alone, exactly as before.
+     *
+     * Durability (DBOS): a step's id is assigned when the step starts, so every
+     * step here is started in an order fixed by the turn's recorded tool calls
+     * alone, never by timing. A batch's steps are started in one synchronous
+     * pass in call order and awaited with allSettled, not Promise.all, so a
+     * rejection never leaves sibling steps running unawaited (DBOS guidance);
+     * once all have settled, the first rejection by call order is rethrown.
+     */
+    async runToolCalls(ctx, step, turn, toolCalls) {
+        const runCall = (index) => step(`turn:${turn}:tool:${index}`, () => ctx.runSandboxTool(toolCalls[index].name, toolCalls[index].argsJson));
+        const concurrent = ctx.runsConcurrently;
+        const results = new Array(toolCalls.length);
+        let index = 0;
+        while (index < toolCalls.length) {
+            let end = index;
+            if (concurrent) {
+                while (end < toolCalls.length && concurrent(toolCalls[end].name))
+                    end += 1;
+            }
+            if (end - index < 2) {
+                results[index] = await runCall(index);
+                index += 1;
+                continue;
+            }
+            const batch = Array.from({ length: end - index }, (_, offset) => index + offset);
+            engineLog.info({ turn, toolCallIds: batch.map((i) => toolCalls[i].id) }, "running tool calls concurrently");
+            const settled = await Promise.allSettled(batch.map((i) => runCall(i)));
+            const rejections = settled.filter((outcome) => outcome.status === "rejected");
+            for (const extra of rejections.slice(1)) {
+                engineLog.warn({ turn, err: extra.reason }, "concurrent tool call also failed");
+            }
+            if (rejections.length > 0)
+                throw rejections[0].reason;
+            settled.forEach((outcome, position) => {
+                results[batch[position]] = outcome.value;
+            });
+            index = end;
+        }
+        return results;
+    }
     /**
      * Streams one model turn, applying the mid-stream cutoff against the
      * *cumulative* running total (this extends Phase 1's single-turn

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

@@ -9,10 +9,11 @@ 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 OpenSibling } from "./related-pull-requests.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" | "issuePullRequest" | "workItem" | "runAttribution" | "agentIssueProject" | "$transaction" | "$queryRaw">;
+export type HostEventDb = Pick<PrismaClient, "agentRepository" | "deferredReview" | "agent" | "run" | "runHostCheck" | "runHostStatus" | "codingRun" | "task" | "webhook" | "budgetGroup" | "issuePullRequest" | "workItem" | "runAttribution" | "agentIssueProject" | "$transaction" | "$queryRaw">;
 export interface RouteHostEventDeps {
     db: HostEventDb;
     executor: Executor;
@@ -24,6 +25,14 @@ export interface RouteHostEventDeps {
     /** Issue trackers for moving/commenting on the issue a closed PR was opened for; absent → pr_closed is ignored. */
     issueTrackers?: IssueTrackerRegistry;
 }
+/** What starting a review needs: everything routing needs except the mention handle. */
+export type ReviewStartDeps = Omit<RouteHostEventDeps, "mentionHandle">;
+/** A deferred review whose head's CI has not finished after this long is started anyway (by the reconciler sweep). */
+export declare const DEFERRED_REVIEW_MAX_WAIT_MS: number;
+/** A deferred review row older than this is dropped without starting. */
+export declare const DEFERRED_REVIEW_MAX_AGE_MS: number;
+/** Upper bound on deferred reviews the sweep starts per pass, so a backlog drains over several passes. */
+export declare const DEFERRED_REVIEW_BATCH = 50;
 export interface RouteResult {
     runIds: string[];
     /** Cosmetic work to do after the webhook response is sent (reactions, status comments). */
@@ -51,6 +60,12 @@ export declare function mergeTaskText(event: PushEvent, scope: DriftScope | null
 type MentionEvent = Extract<HostEvent, {
     kind: "mention";
 }>;
+/** The exact phrase every continuation hint uses (a prompt may match it). */
+export declare function continuePriorRunPhrase(runId: string): string;
+/** The continuation hint a router agent follows to continue a PR's branch instead of opening a new one. */
+export declare function continuationHint(prNumber: number, runId: string): string;
+/** One hint per open sibling (stored rows only; links built, ids re-validated), then the shared guidance. */
+export declare function siblingContinuationHints(siblings: readonly OpenSibling[]): string | undefined;
 /**
  * The mention agent's task text. Deterministic so a prompt can parse it.
  *
@@ -67,6 +82,14 @@ type MentionEvent = Extract<HostEvent, {
  * never in the system prompt. composeTaskOverride stores both in the one
  * taskOverride column.
  */
-export declare function mentionTaskText(event: MentionEvent): string;
+export declare function mentionTaskText(event: MentionEvent, siblings?: readonly OpenSibling[]): string;
 export declare function unknownPriorRunBody(priorRunId: string): string;
+/**
+ * The reconciler's fallback for deferred reviews: drops rows older than
+ * DEFERRED_REVIEW_MAX_AGE_MS, and starts (regardless of CI) those waiting
+ * longer than DEFERRED_REVIEW_MAX_WAIT_MS, at most DEFERRED_REVIEW_BATCH per
+ * pass, oldest first. Covers CI that never reported, ran very long, or whose
+ * completion webhook was missed. Never throws; returns the runs started.
+ */
+export declare function startDeferredReviews(deps: ReviewStartDeps, now?: Date): Promise<string[]>;
 export declare function routeHostEvent(event: HostEvent, deps: RouteHostEventDeps): Promise<RouteResult>;