@wardby/cli 0.2.1 → 0.4.0

package/dist/core/dispatch.js

@@ -1,6 +1,18 @@
-import { CODING_PROTOCOL_VERSION, CodingTaskInputSchema, normalizeGitHubRepository, publicCodingRunResult, composeCodingTask, } from "../coding/protocol.js";
-import { assertCodingProviderModel } from "../coding/provider.js";
+import { CODING_PROTOCOL_VERSION, CodingTaskInputSchema, normalizeGitHubRepository, normalizeGitRef, publicCodingRunResult, composeCodingTask, } from "../coding/protocol.js";
+import { assertCodingProvider, assertCodingProviderModel } from "../coding/provider.js";
+import { ModelUnavailableError, entryOf } from "../providers/llm/catalog-types.js";
+import { parseAllowedServiceNames, workerServices } from "../coding/services/catalog.js";
+import { MAX_SERVICE_DECLARATION_BYTES, ServiceDeclarationError, parseServiceDeclaration, } from "../coding/services/declaration.js";
+import { servicesInstructionNote } from "../coding/services/note.js";
+import { resolveRunServices } from "../coding/services/resolve.js";
+import { DECLARATION_UNAVAILABLE_SENTENCE, LAUNCHER_UNSUPPORTED_SENTENCE, invalidDeclarationSentence, serviceRefusal, } from "../coding/services/wording.js";
+import { attributeRun } from "./attribution.js";
+import { effectiveBudgetForRun, MIN_RESERVATION_USD } from "./budget-groups.js";
+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 { fileSelfDefectForRun } from "./self-defects.js";
 const dispatchLog = logger.child({ module: "dispatch" });
 /** SQLSTATEs worth retrying the persist transaction for: serialization failure, deadlock. */
 const RETRYABLE_SQLSTATES = new Set(["40001", "40P01"]);
@@ -15,6 +27,10 @@ const RETRYABLE_SQLSTATES = new Set(["40001", "40P01"]);
  *   (Prisma 7) -- Prisma 6's engine put 40001 at meta.code, still accepted;
  * - at COMMIT (e.g. SSI write skew): an unwrapped DriverAdapterError, no
  *   code or meta, with the SQLSTATE at cause.originalCode.
+ * Also a unique violation (P2002) on WorkItem: concurrent first dispatches
+ * attributed to one new issue each insert its WorkItem, and Postgres reports
+ * the loser as 23505 rather than 40001. The retry finds the committed row.
+ * Unique violations on other models are real errors and are not retried.
  *
  * @internal Exported only for the real-PostgreSQL tests.
  */
@@ -24,6 +40,8 @@ export function isSerializationConflict(err) {
     const candidate = err;
     if (candidate.code === "P2034")
         return true;
+    if (candidate.code === "P2002")
+        return candidate.meta?.modelName === "WorkItem";
     if (candidate.code === "P2010") {
         const sqlState = candidate.meta?.driverAdapterError?.cause?.originalCode;
         return (typeof sqlState === "string" && RETRYABLE_SQLSTATES.has(sqlState)) || candidate.meta?.code === "40001";
@@ -42,8 +60,8 @@ export function isSerializationConflict(err) {
  * the conditional `updateMany` makes the second call match zero rows rather
  * than overwrite whatever landed in between.
  */
-export async function markRunFailedFromExecutorError(db, runId, err) {
-    await db.run.updateMany({
+export async function markRunFailedFromExecutorError(db, runId, err, selfDefects) {
+    const updated = await db.run.updateMany({
         where: { id: runId, status: { in: ["pending", "running"] } },
         data: {
             status: "failed",
@@ -51,6 +69,232 @@ export async function markRunFailedFromExecutorError(db, runId, err) {
             finishedAt: new Date(),
         },
     });
+    // Only the call that made the row failed files (the duplicate call matches zero rows); bounded, never throws.
+    if (updated.count > 0)
+        await fileSelfDefectForRun(selfDefects, runId);
+}
+/**
+ * The `Run.error` of a coding run refused at dispatch because a budget
+ * constraint has nothing left: `budget_group_exhausted:<period>` or
+ * `run_tree_exhausted`, then a sentence for people.
+ */
+export function budgetExhaustedError(constraint) {
+    if (constraint === "run-tree") {
+        return "run_tree_exhausted: the run tree's shared budget is spent; the run was not started.";
+    }
+    return (`budget_group_exhausted:${constraint}: the agent's budget group has no ${constraint} budget left ` +
+        "(recorded spend plus live in-flight runs' holds have reached its cap); the run was not started.");
+}
+/**
+ * Serializes grouped coding dispatches (security review I1). Under
+ * Serializable, a row lock taken after the transaction's first read cannot
+ * queue anything: the snapshot is already fixed, so each waiter wakes up
+ * with a stale view and aborts. LOCK TABLE is the one statement that takes
+ * no snapshot, so as the transaction's first statement it makes a waiter's
+ * snapshot start only after the previous holder committed. SHARE ROW
+ * EXCLUSIVE conflicts with itself and with writes to BudgetGroup rows, but not
+ * with the ROW SHARE that foreign-key checks from Agent take, so attaching
+ * agents to groups is not blocked. It serializes grouped coding dispatches
+ * across all groups; each holds it only for one short transaction.
+ */
+const GROUP_DISPATCH_LOCK_SQL = 'LOCK TABLE "BudgetGroup" IN SHARE ROW EXCLUSIVE MODE';
+/**
+ * A coding run's budget reservation: the requested ceiling (override or the
+ * agent's budgetUsd) tightened by its budget group and run tree, where every
+ * live in-flight run's unspent hold already counts as spent. Rounded down to
+ * CodingRun.budgetReservedUsd's 6 decimal places; less than that is refused.
+ */
+async function reserveCodingBudget(tx, agent, now, options) {
+    const effective = await effectiveBudgetForRun(tx, agent, now, options.parentRunId);
+    const requested = options.budgetUsdOverride ?? Number(agent.budgetUsd);
+    const budgetUsd = Math.floor(Math.min(requested, effective.effectiveBudgetUsd) / MIN_RESERVATION_USD) * MIN_RESERVATION_USD;
+    if (budgetUsd < MIN_RESERVATION_USD && effective.exhaustedBy) {
+        return { budgetUsd: 0, refusal: budgetExhaustedError(effective.exhaustedBy) };
+    }
+    return { budgetUsd };
+}
+/**
+ * Attempts for the persist transaction, and the jittered backoff between
+ * them, for serialization failures and deadlocks.
+ *
+ * @internal Exported only for the real-PostgreSQL tests.
+ */
+export const PERSIST_ATTEMPTS = 8;
+const RETRY_BASE_MS = 20;
+const RETRY_MAX_MS = 250;
+function retryDelayMs(attempt) {
+    const ceiling = Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** attempt);
+    return Math.floor(ceiling / 2 + Math.random() * (ceiling / 2));
+}
+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.",
+};
+/** A continuation refused because of the run it names. Its message is fixed text, safe to show the model. */
+export class ContinuationRefusedError extends Error {
+    reason;
+    constructor(reason) {
+        super(CONTINUATION_REFUSALS[reason]);
+        this.reason = reason;
+        this.name = "ContinuationRefusedError";
+    }
+}
+/**
+ * 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.
+ */
+export async function checkContinuation(reader, runId, repository) {
+    const candidate = await reader.codingRun.findUnique({ where: { runId } });
+    if (!candidate)
+        return { ok: false, reason: "unknown_run" };
+    const root = candidate.rootCodingRunId
+        ? await reader.codingRun.findUnique({ where: { runId: candidate.rootCodingRunId } })
+        : candidate;
+    if (!root)
+        return { ok: false, reason: "unknown_run" };
+    if (normalizeGitHubRepository(root.repository) !== normalizeGitHubRepository(repository)) {
+        return { ok: false, reason: "other_repository" };
+    }
+    const rootResult = publicCodingRunResult(root.result);
+    if ((rootResult?.outcome !== "pull_request_opened" && rootResult?.outcome !== "pull_request_updated") ||
+        rootResult.pullRequestNumber === undefined) {
+        return { ok: false, reason: "no_pull_request" };
+    }
+    return {
+        ok: true,
+        root: {
+            runId: root.runId,
+            baseRef: root.baseRef,
+            headRef: root.headRef,
+            pullRequestNumber: rootResult.pullRequestNumber,
+        },
+    };
+}
+/**
+ * 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) {
+    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);
+    if (!check.ok)
+        throw new ContinuationRefusedError(check.reason);
+    const { root } = check;
+    return {
+        baseRef: root.baseRef,
+        headRef: root.headRef,
+        continuationOf: { runId: root.runId },
+        rootCodingRunId: root.runId,
+    };
+}
+/** Read failures that are the file's fault rather than the host's: reported as an invalid declaration. */
+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",
+};
+/**
+ * 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) {
+    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 indexText = await executor.readCodingRepositoryFile({
+            repository: profile.repository,
+            baseRef: normalizeGitRef(branch.baseRef),
+            path: `${DEFAULT_KNOWLEDGE_BUNDLE_PATH}/index.md`,
+            maxBytes: KNOWLEDGE_INDEX_READ_MAX_BYTES,
+        });
+        return indexText ? { bundlePath: DEFAULT_KNOWLEDGE_BUNDLE_PATH, indexText } : undefined;
+    }
+    catch (err) {
+        if (err instanceof Error && err.message in UNREADABLE_DECLARATION) {
+            dispatchLog.info({ repository: profile.repository, reason: err.message }, "knowledge index unreadable; dispatching without it");
+            return undefined;
+        }
+        dispatchLog.warn({ err, repository: profile.repository }, "knowledge index read failed; dispatching without it");
+        return undefined;
+    }
+}
+/**
+ * Coding-run services (docs/coding-services.md): resolves the run's branch and
+ * reads the repository's declaration from its base, then parses it. A network
+ * 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);
+    const read = { repository: profile.repository, profileBaseRef: profile.baseRef, branch };
+    const executor = options.executor;
+    if (!executor.readCodingServiceDeclaration)
+        return { ...read, outcome: { kind: "none" } };
+    let text;
+    try {
+        text = await executor.readCodingServiceDeclaration({
+            repository: profile.repository,
+            baseRef: normalizeGitRef(branch.baseRef),
+        });
+    }
+    catch (err) {
+        const reason = UNREADABLE_DECLARATION[err instanceof Error ? err.message : ""];
+        if (reason) {
+            return {
+                ...read,
+                outcome: {
+                    kind: "refused",
+                    refusal: serviceRefusal("service_declaration_invalid", invalidDeclarationSentence(reason)),
+                },
+            };
+        }
+        dispatchLog.warn({ err, agentId: options.agentId }, "could not read the repository's service declaration");
+        return {
+            ...read,
+            outcome: {
+                kind: "refused",
+                refusal: serviceRefusal("service_declaration_unavailable", DECLARATION_UNAVAILABLE_SENTENCE),
+            },
+        };
+    }
+    if (text === null)
+        return { ...read, outcome: { kind: "none" } };
+    try {
+        return { ...read, outcome: { kind: "declared", services: parseServiceDeclaration(text) } };
+    }
+    catch (err) {
+        if (!(err instanceof ServiceDeclarationError))
+            throw err;
+        return {
+            ...read,
+            outcome: {
+                kind: "refused",
+                refusal: serviceRefusal("service_declaration_invalid", invalidDeclarationSentence(err.reason)),
+            },
+        };
+    }
+}
+/** Inside the transaction: the run's services, or the refusal that stops it. */
+async function resolveDispatchServices(tx, outcome, allowed, executor, provider, request, instructions) {
+    if (outcome.kind === "refused")
+        return { refusal: outcome.refusal };
+    if (outcome.kind === "none" || outcome.services.length === 0)
+        return { services: [] };
+    if (executor.supportsCodingServices?.(provider) !== true) {
+        return { refusal: serviceRefusal("service_launcher_unsupported", LAUNCHER_UNSUPPORTED_SENTENCE) };
+    }
+    return resolveRunServices({ findMany: (args) => tx.codingService.findMany(args) }, outcome.services, parseAllowedServiceNames(allowed), request, instructions);
 }
 /**
  * Persists every detached run input in one transaction, then invokes the
@@ -59,7 +303,34 @@ export async function markRunFailedFromExecutorError(db, runId, err) {
  */
 export async function dispatchRun(options) {
     const now = options.now ?? new Date();
+    // Read outside the transaction only to decide whether to take the group
+    // dispatch lock before the transaction's first read, and whether to read the
+    // repository's service declaration (a network call); everything the run is
+    // built from is re-read inside. If the agent changes in between, the
+    // Serializable transaction still refuses a conflicting commit.
+    const preview = await options.db.agent.findUnique({
+        where: { id: options.agentId },
+        select: {
+            kind: true,
+            budgetGroupId: true,
+            codingProfile: { select: { repository: true, baseRef: true, services: true } },
+        },
+    });
+    const lockGroups = preview?.kind === "coding" && preview.budgetGroupId != null;
+    // Only an agent allowed some service reads the repository's declaration; any
+    // other coding agent never calls the host for it and gets no services.
+    const declarationRead = preview?.kind === "coding" &&
+        preview.codingProfile &&
+        parseAllowedServiceNames(preview.codingProfile.services).length > 0
+        ? await readServiceDeclaration(options, preview.codingProfile)
+        : 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)
+        : undefined;
     const persistOnce = () => options.db.$transaction(async (tx) => {
+        if (lockGroups)
+            await tx.$executeRawUnsafe(GROUP_DISPATCH_LOCK_SQL);
         if (options.lockAgent) {
             const locked = await tx.$queryRaw `
         SELECT "id" FROM "Agent" WHERE "id" = ${options.agentId} FOR UPDATE SKIP LOCKED
@@ -78,6 +349,52 @@ export async function dispatchRun(options) {
         if (options.taskOverride !== undefined && agent.kind !== "native") {
             throw new Error("taskOverride can only be supplied for a native agent.");
         }
+        // A coding run's services are resolved, and its budget reserved, here,
+        // at dispatch (E-01): the container only ever checks the run's own
+        // reservation. A native run computes its effective budget in
+        // executeRun's load step instead.
+        let codingBudget;
+        let codingEntry;
+        let modelFailure;
+        let services = [];
+        let servicesRefusal;
+        if (agent.kind === "coding") {
+            if (!agent.codingProfile)
+                throw new Error(`Coding agent "${agent.id}" has no coding profile.`);
+            // An unknown coding provider is a broken profile, not a catalog state: still thrown.
+            assertCodingProvider(agent.codingProfile.provider);
+            // Recorded on the run row below: the run is billed at this entry for its whole life.
+            // A model the catalog cannot run (missing, disabled, or another provider's) fails
+            // the run here instead of throwing: the run row commits with the reason, so the
+            // caller's own writes stand (a scheduler's lastScheduledAt, a mention's status
+            // row) and the owner sees why in list_runs, rather than a rolled-back
+            // transaction that a scheduler would retry on every tick.
+            try {
+                codingEntry = resolveCodingEntry(agent.codingProfile.provider, agent.model);
+            }
+            catch (err) {
+                if (!(err instanceof ModelUnavailableError || err instanceof CodingModelProviderMismatchError))
+                    throw err;
+                modelFailure = err.message;
+            }
+            if (!modelFailure && declarationRead) {
+                if (declarationRead.repository !== agent.codingProfile.repository ||
+                    declarationRead.profileBaseRef !== agent.codingProfile.baseRef) {
+                    // The declaration was read for a profile that changed before this transaction.
+                    throw new Error("The coding agent's repository or base branch changed during dispatch; try again.");
+                }
+                // A missing request fails below, with its own error.
+                const request = options.codingTask ?? agent.codingProfile.defaultTask ?? "";
+                const resolved = await resolveDispatchServices(tx, declarationRead.outcome, agent.codingProfile.services, options.executor, agent.codingProfile.provider, request, agent.systemPrompt);
+                if ("refusal" in resolved)
+                    servicesRefusal = resolved.refusal;
+                else
+                    services = resolved.services;
+            }
+            if (!modelFailure && !servicesRefusal)
+                codingBudget = await reserveCodingBudget(tx, agent, now, options);
+        }
+        const refusal = servicesRefusal ?? codingBudget?.refusal;
         const run = await tx.run.create({
             data: {
                 agentId: agent.id,
@@ -86,46 +403,44 @@ export async function dispatchRun(options) {
                 parentRunId: options.parentRunId,
                 grantedParentMemoryKeys: options.grantedParentMemoryKeys ?? [],
                 taskOverride: options.taskOverride,
+                triggeredById: options.triggeredById ?? null,
+                // Failed before it starts, like a native run whose model the
+                // runner's load step finds unavailable: zero spend, never started.
+                ...(modelFailure ? { status: "failed", error: modelFailure, finishedAt: now } : {}),
+                // Refused before it starts, the same terminal status (and zero
+                // spend) as a native run whose budget is gone at turn 1.
+                ...(refusal ? { status: "refused", error: refusal, finishedAt: now } : {}),
+                ...(codingEntry
+                    ? {
+                        pricingVersion: codingEntry.priceVersion,
+                        // entryOf returns plain JSON data (fresh array, no Dates); the interface's readonly
+                        // efforts array is all that keeps it from matching Prisma's Json input type.
+                        pricingSnapshot: entryOf(codingEntry),
+                    }
+                    : {}),
             },
         });
-        if (agent.kind === "coding") {
-            if (!agent.codingProfile)
-                throw new Error(`Coding agent "${agent.id}" has no coding profile.`);
+        if (options.afterPersist)
+            await options.afterPersist(tx, run);
+        const attributed = await attributeRun(tx, run.id, {
+            parentRunId: options.parentRunId,
+            continuesCodingRunId: options.continuesCodingRunId,
+            intent: options.attribution,
+        }, now);
+        if (agent.kind === "coding" && agent.codingProfile && codingBudget && !refusal) {
+            // Checked above too; repeated so the provider type narrows here.
             assertCodingProviderModel(agent.codingProfile.provider, agent.model);
             const request = options.codingTask ?? agent.codingProfile.defaultTask;
             if (!request)
                 throw new Error(`Coding agent "${agent.id}" requires a task.`);
-            // The worker sees only the task text, so the agent's own instructions ride in it.
-            const task = composeCodingTask(agent.systemPrompt, request);
-            const budgetUsd = options.budgetUsdOverride ?? Number(agent.budgetUsd);
-            let baseRef = options.codingBaseRef ?? agent.codingProfile.baseRef;
-            let headRef = `wardby/run-${run.id}`;
-            let continuationOf;
-            let rootCodingRunId;
-            if (options.continuesCodingRunId !== undefined) {
-                if (options.codingBaseRef !== undefined) {
-                    throw new Error("continuesCodingRunId cannot be combined with codingBaseRef.");
-                }
-                const candidate = await tx.codingRun.findUnique({ where: { runId: options.continuesCodingRunId } });
-                if (!candidate)
-                    throw new Error("Cannot continue an unknown coding run.");
-                const root = candidate.rootCodingRunId
-                    ? await tx.codingRun.findUnique({ where: { runId: candidate.rootCodingRunId } })
-                    : candidate;
-                if (!root)
-                    throw new Error("Cannot continue an unknown coding run.");
-                if (normalizeGitHubRepository(root.repository) !== normalizeGitHubRepository(agent.codingProfile.repository)) {
-                    throw new Error("Cannot continue a coding run from a different repository.");
-                }
-                const rootResult = publicCodingRunResult(root.result);
-                if (rootResult?.outcome !== "pull_request_opened" && rootResult?.outcome !== "pull_request_updated") {
-                    throw new Error("Cannot continue a coding run that never opened a pull request.");
-                }
-                baseRef = root.baseRef;
-                headRef = root.headRef;
-                continuationOf = { runId: root.runId };
-                rootCodingRunId = root.runId;
-            }
+            // The worker sees only the task text, so the agent's own instructions, and the
+            // services note, ride in it.
+            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 { baseRef, continuationOf, rootCodingRunId } = branch;
+            const headRef = branch.headRef ?? `wardby/run-${run.id}`;
             const input = CodingTaskInputSchema.parse({
                 schemaVersion: CODING_PROTOCOL_VERSION,
                 runId: run.id,
@@ -137,16 +452,23 @@ export async function dispatchRun(options) {
                 budgetUsd,
                 deadlineAt: new Date(now.getTime() + agent.codingProfile.timeoutSec * 1000).toISOString(),
                 continuationOf,
+                ...(services.length > 0 ? { services: workerServices(services) } : {}),
             });
-            const workerImage = options.executor.resolveCodingWorkerImage?.({
+            const imageSelector = {
                 provider: agent.codingProfile.provider,
                 toolchain: agent.codingProfile.toolchain,
                 toolchainVersion: agent.codingProfile.toolchainVersion,
                 workerImageRef: agent.codingProfile.workerImageRef,
-            });
+            };
+            const workerImage = options.executor.resolveCodingWorkerImage?.(imageSelector);
+            // Claude Code's commands run in its tool runner, so the toolchain picks that image too; fixed
+            // here with the worker image so the run keeps both however the deployment changes later.
+            const toolImage = options.executor.resolveCodingToolImage?.(imageSelector) ?? null;
             await tx.codingRun.create({
                 data: {
                     runId: run.id,
+                    issueProvider: attributed?.provider ?? null,
+                    issueKey: attributed?.key ?? null,
                     task: input.task,
                     repository: input.repository,
                     baseRef: input.baseRef,
@@ -154,18 +476,26 @@ export async function dispatchRun(options) {
                     provider: agent.codingProfile.provider,
                     model: input.model,
                     timeoutSec: agent.codingProfile.timeoutSec,
-                    allowedEgress: agent.codingProfile.allowedEgress,
                     protectedPaths: agent.codingProfile.protectedPaths,
+                    collectExclude: agent.codingProfile.collectExclude,
+                    packageAllowlist: agent.codingProfile.packageAllowlist,
+                    packagePolicy: agent.codingProfile.packagePolicy,
                     workerImage,
+                    toolImage,
                     budgetReservedUsd: budgetUsd,
                     rootCodingRunId,
                     workspaceDiskMb: agent.codingProfile.workspaceDiskMb,
+                    // Fixed here so a run's tracing never changes mid-run.
+                    debugTrace: agent.codingProfile.debugTraceUntil != null &&
+                        now.getTime() < agent.codingProfile.debugTraceUntil.getTime(),
+                    services,
                 },
             });
         }
-        else if (options.codingTask !== undefined ||
-            options.codingBaseRef !== undefined ||
-            options.continuesCodingRunId !== undefined) {
+        else if (agent.kind !== "coding" &&
+            (options.codingTask !== undefined ||
+                options.codingBaseRef !== undefined ||
+                options.continuesCodingRunId !== undefined)) {
             throw new Error("Coding overrides cannot be supplied for a native agent.");
         }
         const task = options.task
@@ -182,24 +512,29 @@ export async function dispatchRun(options) {
         return { run, task };
     }, { isolationLevel: "Serializable" });
     let persisted = null;
-    for (let attempt = 0; attempt < 3; attempt += 1) {
+    for (let attempt = 0; attempt < PERSIST_ATTEMPTS; attempt += 1) {
         try {
             persisted = await persistOnce();
             break;
         }
         catch (err) {
-            if (!isSerializationConflict(err) || attempt === 2)
+            if (!isSerializationConflict(err) || attempt === PERSIST_ATTEMPTS - 1)
                 throw err;
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs(attempt)));
         }
     }
     if (!persisted)
         return null;
+    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;
+    }
     const runStart = async () => {
         try {
             await options.executor.start(persisted.run.id);
         }
         catch (err) {
-            await markRunFailedFromExecutorError(options.db, persisted.run.id, err).catch((err2) => dispatchLog.error({ err: err2, runId: persisted.run.id }, "failed to persist executor start failure"));
+            await markRunFailedFromExecutorError(options.db, persisted.run.id, err, options.selfDefects).catch((err2) => dispatchLog.error({ err: err2, runId: persisted.run.id }, "failed to persist executor start failure"));
         }
     };
     if (options.awaitExecution) {