@wardby/cli 0.6.0 → 0.7.0

package/dist/providers/executor/container.js

@@ -1,7 +1,10 @@
 import { randomUUID } from "node:crypto";
+import { isPackageAuditMode, mergePackageAuditReports, } from "../../coding/registry/audit-mode.js";
 import { mkdir, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { join, resolve, sep } from "node:path";
 import { withBaseCommit } from "../../coding/base-commit.js";
+import { withPullRequestDescription } from "../../coding/pr-description-note.js";
+import { withLinkedIssue } from "../../coding/linked-issue-note.js";
 import { buildClaudeContext, MAX_RECORDED_SKIPS } from "../../coding/claude-context.js";
 import { normalizeCollectExclusions } from "../../coding/collect-exclude.js";
 import { codingProviderForModelProvider } from "../../coding/provider.js";
@@ -10,31 +13,50 @@ import { parseStoredServices, storedServiceNames, workerServices } from "../../c
 import { MAX_SERVICE_DECLARATION_BYTES, SERVICE_DECLARATION_PATH } from "../../coding/services/declaration.js";
 import { SERVICE_UNREADY_CATEGORY, SERVICE_UNREADY_ERROR, serviceUnreadyName, serviceUnreadySentence, } from "../../coding/services/wording.js";
 import { PROTECTED_PATH_CATEGORY, protectedPathFromError, protectedPathSentence, } from "../../coding/protected-path-wording.js";
-import { CONTINUATION_CLOSED_CATEGORY, CONTINUATION_CLOSED_ERROR } from "../../coding/continuation-wording.js";
-import { budgetSentence } from "../../core/budget-wording.js";
+import { budgetStoppedSummary, CONTINUATION_CLOSED_CATEGORY, CONTINUATION_CLOSED_ERROR, WORKER_BUDGET_EXHAUSTED_SUMMARY, } from "../../coding/continuation-wording.js";
+import { CONFLICT_MARKERS_ERROR_PREFIX, MERGE_CONFLICT_CATEGORY, TARGET_MERGE_CATEGORY, TARGET_MERGE_FAILED_ERROR, conflictMarkersPathFromError, conflictMarkersSentence, mergeSentence, withTargetMerge, } from "../../coding/merge-wording.js";
+import { budgetSentence, overrunSentence } from "../../core/budget-wording.js";
 import { fileSelfDefect } from "../../core/self-defects.js";
 import { isTransactionUnavailable } from "../../core/dispatch.js";
+import { topUpCodingBudget } from "../../core/budget-topup.js";
 import { CONTENDED_TX_MAX_WAIT_MS } from "../../core/timing.js";
 import { classifyProviderFailure, providerClassOfCategory, providerSentence, } from "../../core/provider-wording.js";
 import { logger } from "../../core/logger.js";
 import { requiredLevel } from "../../core/repo-access.js";
 import { ensurePrivateDirectory } from "../../core/private-directory.js";
 import { codingRunObserver } from "../../coding/observability.js";
-import { CODING_PROTOCOL_VERSION, CodingRunResultSchema, CodingTaskInputSchema, MAX_CODING_INPUT_BYTES, parseCodingAgentOutputJson, redactAndTruncate, } from "../../coding/protocol.js";
+import { CODING_PROTOCOL_VERSION, CodingRunResultSchema, CodingTaskInputSchema, MAX_CODING_INPUT_BYTES, isLocalRepository, parseCodingWorkerOutputJson, redactAndTruncate, restoredDependencyFolders, sanitizeDependencyCacheReport, } from "../../coding/protocol.js";
 import { parseStoredEntry } from "../llm/catalog-types.js";
 import { resolveCodingEntry } from "../../core/run-pricing.js";
 import { CODING_PROXY_ALIAS, CODING_PROXY_PORT, isImmutableDockerImage } from "../jobs/docker-isolation.js";
 import { normalizeRegistryLockfiles } from "../../coding/registry/lockfiles.js";
-import { ISSUE_KEY, ISSUE_TRACKER_NAMES } from "../issue-tracker/types.js";
+import { warningRefusals } from "../../coding/registry/report.js";
+import { hostBudgetSentence, loadBudgetEvent, ownerBudgetSentence, proxyRefusalDetails, recordBudgetEvent, } from "../../core/budget-events.js";
+import { JobCapacityError, } from "../jobs/types.js";
+import { ISSUE_KEY, issueReference } from "../issue-tracker/types.js";
 import { HEARTBEAT_TIMEOUT_MS } from "../../core/timing.js";
 import { collectRelatedPullRequests } from "../../core/related-pull-requests.js";
+import { isIssueMentionTask } from "../../core/host-status.js";
+import { pullRequestBody, } from "../vcs/github.js";
+import { closingIssueNumber, descriptionSha256 } from "../vcs/pr-description.js";
 const containerLog = logger.child({ module: "container-executor" });
+/** A transcript read and store must not hold up the job's removal for long. */
+const TRANSCRIPT_RECORD_TIMEOUT_MS = 60_000;
 /** A logged context skip path is cut to this many characters: a refused import is reported as written. */
 const MAX_LOGGED_SKIP_PATH_CHARS = 256;
 /** The input path in a spec built only to ask the launcher about capacity; never written or read. */
 const CAPACITY_PROBE_INPUT = "/dev/null";
 const TERMINAL_STATUSES = new Set(["succeeded", "failed", "refused", "lost", "budget_exhausted", "cancelled"]);
 const PROVISIONING_BACKEND = "provisioning";
+/** The longest a no-change fix round's description refresh may hold up the run's terminal write. */
+export const DESCRIPTION_REFRESH_TIMEOUT_MS = 60_000;
+/**
+ * After the cluster refuses a run's launch for capacity, how long this executor leaves the run
+ * waiting in the queue before trying it again (drainCodingQueue starts it every tick meanwhile).
+ */
+export const CAPACITY_RETRY_BACKOFF_MS = 60_000;
+/** How many runs above a root coding run are searched for the mention that started it. */
+const MAX_LINKED_ISSUE_RUN_DEPTH = 8;
 /** Serializes concurrency-slot claims across replicas. Distinct from the OAuth client lock (7412901). */
 const CODING_SLOT_LOCK_SQL = "SELECT 1 AS locked FROM pg_advisory_xact_lock(7412902)";
 /**
@@ -48,6 +70,14 @@ const CODING_SLOT_LOCK_SQL = "SELECT 1 AS locked FROM pg_advisory_xact_lock(7412
  */
 class RunNoLongerActiveError extends Error {
 }
+/** Private sentinel: rolls back requeueAfterCapacityRefusal's transaction with the outcome it carries. */
+class NotRequeuedError extends Error {
+    outcome;
+    constructor(outcome) {
+        super(outcome);
+        this.outcome = outcome;
+    }
+}
 function proxyProtocol(provider) {
     if (provider === "codex")
         return "openai-responses";
@@ -68,6 +98,51 @@ export async function normalizeCollectedLockfiles(provider, workspacePath) {
         proxyBaseUrl: `http://${CODING_PROXY_ALIAS}:${CODING_PROXY_PORT}`,
     });
 }
+/** The worker's dependency cache report, as CodingRunRecord columns: nothing on a run without one. */
+function dependencyCacheRecord(output) {
+    return output.dependencyCache ? { dependencyCacheResult: output.dependencyCache } : {};
+}
+/** What a push records on the run: its base commit, and a pushed branch's name (a local repository). */
+function pushedRecord(finalized) {
+    return {
+        baseSha: finalized.baseCommit,
+        ...(finalized.outcome === "branch_pushed" ? { resultBranch: finalized.headRef } : {}),
+    };
+}
+/** The PR body's dependency cache line: the folders restored from a snapshot (hit or nearest). */
+function restoredDependenciesFor(output) {
+    const folders = restoredDependencyFolders(output.dependencyCache);
+    return folders.length > 0 ? { restoredDependencies: folders } : {};
+}
+/** The stored form of a description outcome: written, replaced, refreshed:<reason>, unchanged, edited_by_hand, skipped:<reason>. */
+export function descriptionOutcomeLabel(outcome) {
+    if (outcome.kind === "refreshed" || outcome.kind === "skipped")
+        return `${outcome.kind}:${outcome.reason}`;
+    return outcome.kind;
+}
+/** A local repository has no pull request: its runs get no description note and record no description outcome. */
+function hasPullRequestDescription(run) {
+    return !isLocalRepository(run.repository);
+}
+/**
+ * A budget-stopped run's stored result names what its kept changes became
+ * (see keepStoppedChanges): the `changesPushed` detail for its status comment,
+ * or nothing when it pushed nothing.
+ */
+function storedChangesPushed(result) {
+    const parsed = CodingRunResultSchema.safeParse(result);
+    if (!parsed.success)
+        return {};
+    const stored = parsed.data;
+    if (stored.outcome === "branch_pushed")
+        return { changesPushed: {} };
+    if (stored.outcome === "pull_request_opened" || stored.outcome === "pull_request_updated") {
+        return { changesPushed: { pullRequestNumber: stored.pullRequestNumber } };
+    }
+    return {};
+}
+/** The longest reading the linked issue may hold up a continuation's launch. */
+export const LINKED_ISSUE_READ_TIMEOUT_MS = 15_000;
 export class PrismaContainerExecutionStore {
     db;
     options;
@@ -96,11 +171,13 @@ export class PrismaContainerExecutionStore {
             return null;
         return {
             runId: row.id,
+            agentId: row.agentId,
             status: row.status,
             agentKind: row.agent.kind,
             agentName: row.agent.name,
             ownerId: row.agent.ownerId,
             task: row.codingRun.task,
+            ...(row.codingRun.request ? { request: row.codingRun.request } : {}),
             repository: row.codingRun.repository,
             baseRef: row.codingRun.baseRef,
             headRef: row.codingRun.headRef,
@@ -115,6 +192,8 @@ export class PrismaContainerExecutionStore {
             mergeOrder: row.codingRun.mergeOrder,
             budgetUsd: Number(row.codingRun.budgetReservedUsd),
             agentBudgetUsd: Number(row.agent.budgetUsd),
+            ...(row.codingRun.budgetBaseUsd == null ? {} : { budgetBaseUsd: Number(row.codingRun.budgetBaseUsd) }),
+            ...(row.codingRun.budgetLimitUsd == null ? {} : { budgetLimitUsd: Number(row.codingRun.budgetLimitUsd) }),
             budgetGroupName: row.agent.budgetGroup?.name ?? null,
             tokensIn: row.tokensIn,
             tokensOut: row.tokensOut,
@@ -129,9 +208,13 @@ export class PrismaContainerExecutionStore {
             toolImage: row.codingRun.toolImage,
             workspaceDiskMb: row.codingRun.workspaceDiskMb,
             debugTrace: row.codingRun.debugTrace,
+            debugTraceMaxMb: row.codingRun.debugTraceMaxMb,
             maxTurns: row.codingRun.maxTurns,
+            maxOutputTokens: row.codingRun.maxOutputTokens,
             repoSkills: row.codingRun.repoSkills,
             claudeBareMode: row.codingRun.claudeBareMode,
+            dependencyCache: row.codingRun.dependencyCache,
+            sessionResume: row.codingRun.sessionResume,
             services: row.codingRun.services,
             failureCategory: row.codingRun.failureCategory,
             profileRepository: row.agent.codingProfile?.repository ?? null,
@@ -150,6 +233,108 @@ export class PrismaContainerExecutionStore {
             ...(pr.mergeOrder !== undefined ? { mergeOrder: pr.mergeOrder } : {}),
         }));
     }
+    async pullRequestMarkedReady(rootRunId) {
+        const root = await this.db.codingRun.findUnique({ where: { runId: rootRunId }, select: { markedReadyAt: true } });
+        return Boolean(root?.markedReadyAt);
+    }
+    async pullRequestDescriptionBaseline(rootRunId) {
+        const root = await this.db.codingRun.findUnique({
+            where: { runId: rootRunId },
+            select: {
+                prDescriptionSha256: true,
+                prDescriptionRunId: true,
+                result: true,
+                repository: true,
+                baseRef: true,
+                headRef: true,
+                dependencyCacheResult: true,
+                issueProvider: true,
+                issueKey: true,
+            },
+        });
+        if (!root)
+            throw new Error("coding_run_not_found");
+        // Legacy pull requests (no recorded author run) carry the root run's own text.
+        const agentTextRunId = root.prDescriptionRunId ?? rootRunId;
+        const source = agentTextRunId === rootRunId
+            ? root.result
+            : (await this.db.codingRun.findUnique({ where: { runId: agentTextRunId }, select: { result: true } }))?.result;
+        const previousAgentText = storedSummary(source);
+        const rootSummary = storedSummary(root.result);
+        const legacySource = root.prDescriptionSha256 === null
+            ? {
+                repository: root.repository,
+                baseRef: root.baseRef,
+                headRef: root.headRef,
+                ...(rootSummary !== undefined ? { summary: rootSummary } : {}),
+                ...(storedField(root.result, "tests") !== undefined ? { tests: storedField(root.result, "tests") } : {}),
+                ...(root.dependencyCacheResult != null ? { dependencyCache: root.dependencyCacheResult } : {}),
+                issueProvider: root.issueProvider,
+                issueKey: root.issueKey,
+            }
+            : undefined;
+        return {
+            recordedSha256: root.prDescriptionSha256,
+            ...(previousAgentText !== undefined ? { previousAgentText } : {}),
+            agentTextRunId,
+            ...(legacySource ? { legacySource } : {}),
+        };
+    }
+    async linkedIssueSource(rootRunId) {
+        const root = await this.db.codingRun.findUnique({
+            where: { runId: rootRunId },
+            select: { issueProvider: true, issueKey: true, run: { select: { parentRunId: true } } },
+        });
+        if (!root)
+            throw new Error("coding_run_not_found");
+        // The mention that started the work is on the root's delegating run, or a run above it.
+        let hostStatus = null;
+        let parentRunId = root.run.parentRunId;
+        for (let depth = 0; parentRunId && depth < MAX_LINKED_ISSUE_RUN_DEPTH; depth++) {
+            const parent = await this.db.run.findUnique({
+                where: { id: parentRunId },
+                select: {
+                    parentRunId: true,
+                    taskOverride: true,
+                    hostStatus: { select: { provider: true, repository: true, number: true } },
+                },
+            });
+            if (!parent)
+                break;
+            if (parent.hostStatus) {
+                const { provider, repository, number } = parent.hostStatus;
+                hostStatus = {
+                    provider,
+                    repository,
+                    number,
+                    issueMention: provider === "github" && isIssueMentionTask(parent.taskOverride, repository, number),
+                };
+                break;
+            }
+            parentRunId = parent.parentRunId;
+        }
+        return { issueProvider: root.issueProvider, issueKey: root.issueKey, hostStatus };
+    }
+    async pullRequestRunIds(rootRunId) {
+        const rows = await this.db.codingRun.findMany({
+            where: { OR: [{ runId: rootRunId }, { rootCodingRunId: rootRunId }] },
+            select: { runId: true, result: true },
+            orderBy: { run: { startedAt: "asc" } },
+        });
+        const pushed = rows.filter((row) => {
+            const outcome = storedField(row.result, "outcome");
+            return outcome === "pull_request_opened" || outcome === "pull_request_updated";
+        });
+        // The root first, whatever the clock says.
+        return [...pushed.filter((row) => row.runId === rootRunId), ...pushed.filter((row) => row.runId !== rootRunId)].map((row) => row.runId);
+    }
+    async recordPullRequestDescription(input) {
+        const written = await this.db.codingRun.updateMany({
+            where: { runId: input.rootRunId, prDescriptionSha256: input.expectedSha256 },
+            data: { prDescriptionSha256: input.sha256, prDescriptionRunId: input.agentTextRunId },
+        });
+        return written.count === 1;
+    }
     async claimProvisioning(runId, claimId) {
         try {
             return await this.db.$transaction(async (tx) => {
@@ -239,6 +424,52 @@ export class PrismaContainerExecutionStore {
             data: { queuedAt: new Date() },
         });
     }
+    async requeueAfterCapacityRefusal(runId, owned) {
+        const holds = [
+            ...(owned.claimId ? [{ jobBackend: PROVISIONING_BACKEND, jobHandle: owned.claimId }] : []),
+            ...(owned.planned ? [{ jobBackend: owned.planned.backend, jobHandle: owned.planned.id }] : []),
+        ];
+        if (holds.length === 0)
+            return "not_owned";
+        try {
+            return await this.db.$transaction(async (tx) => {
+                const run = await tx.run.findUnique({ where: { id: runId }, select: { startedAt: true } });
+                if (!run)
+                    return "not_owned";
+                // queuedAt is the dispatch time, not now: claimProvisioning clears it on every claim, and a
+                // fresh value per refusal would keep a run the cluster refuses forever from timing out.
+                const released = await tx.codingRun.updateMany({
+                    where: { runId, OR: holds, run: { status: { in: ["pending", "running"] } } },
+                    data: { jobBackend: null, jobHandle: null, queuedAt: run.startedAt },
+                });
+                if (released.count !== 1)
+                    return "not_owned";
+                // The pod never started, so its session served no request. A run has one session, and the
+                // next attempt creates its own: drop this one, but never one with spend recorded against it.
+                const session = await tx.codingProxySession.findUnique({
+                    where: { runId },
+                    select: { id: true, _count: { select: { requests: true } } },
+                });
+                if (session && session._count.requests > 0)
+                    throw new NotRequeuedError("spend_recorded");
+                if (session)
+                    await tx.codingProxySession.delete({ where: { id: session.id } });
+                const waiting = await tx.run.updateMany({
+                    where: { id: runId, status: { in: ["pending", "running"] } },
+                    data: { status: "pending", heartbeatAt: null },
+                });
+                // Ended (stopped, say) since the release above: roll the release back too.
+                if (waiting.count !== 1)
+                    throw new NotRequeuedError("not_owned");
+                return "requeued";
+            });
+        }
+        catch (err) {
+            if (err instanceof NotRequeuedError)
+                return err.outcome;
+            throw err;
+        }
+    }
     async persistHandle(runId, claimId, handle) {
         await this.db.$transaction(async (tx) => {
             const coding = await tx.codingRun.findUnique({ where: { runId }, include: { run: true } });
@@ -290,6 +521,11 @@ export class PrismaContainerExecutionStore {
                     resultSchema: CODING_PROTOCOL_VERSION,
                     ...(record.resultBranch ? { resultBranch: record.resultBranch } : {}),
                     ...(record.baseSha ? { baseSha: record.baseSha } : {}),
+                    ...(record.dependencyCacheResult ? { dependencyCacheResult: record.dependencyCacheResult } : {}),
+                    ...(record.prDescriptionOutcome ? { prDescriptionOutcome: record.prDescriptionOutcome } : {}),
+                    ...(record.prDescriptionSha256 && record.prDescriptionRunId
+                        ? { prDescriptionSha256: record.prDescriptionSha256, prDescriptionRunId: record.prDescriptionRunId }
+                        : {}),
                 },
             });
             await tx.run.update({
@@ -308,8 +544,33 @@ export class PrismaContainerExecutionStore {
             await this.selfDefect({ ...finished, status, error: null, finishedAt });
         }
     }
+    async recordBudgetRefusal(runId, sessionId) {
+        const session = await this.db.codingProxySession.findUnique({
+            where: { id: sessionId },
+            select: { budgetRefusal: true },
+        });
+        // The proxy (a less-trusted role) wrote this: keep only well-formed amounts, model and turn.
+        const refusal = proxyRefusalDetails(session?.budgetRefusal);
+        if (!refusal)
+            return;
+        const existing = await this.db.runBudgetEvent.findFirst({
+            where: { runId, details: { path: ["source"], equals: "proxy" } },
+            select: { id: true },
+        });
+        if (existing)
+            return;
+        const coding = await this.db.codingRun.findUnique({ where: { runId }, select: { budgetLimitedBy: true } });
+        await recordBudgetEvent(this.db, runId, (coding?.budgetLimitedBy ?? "run"), refusal);
+    }
+    budgetEvent(runId) {
+        return loadBudgetEvent(this.db, runId);
+    }
+    topUpBudget(runId) {
+        return topUpCodingBudget(this.db, runId);
+    }
     async terminate(runId, status, error, audit) {
         const finishedAt = new Date();
+        let changed = false;
         const agentId = await this.db.$transaction(async (tx) => {
             const updated = await tx.run.updateMany({
                 where: { id: runId, status: { in: ["pending", "running"] } },
@@ -317,6 +578,7 @@ export class PrismaContainerExecutionStore {
             });
             if (!updated.count)
                 return null;
+            changed = true;
             if (audit) {
                 await tx.codingRun.update({
                     where: { runId },
@@ -331,6 +593,7 @@ export class PrismaContainerExecutionStore {
         // After commit, so the failure category is readable; cancelled/refused are skipped inside fileSelfDefect.
         if (agentId)
             await this.selfDefect({ id: runId, agentId, status, error, finishedAt });
+        return changed;
     }
 }
 /** Plain capabilities live only for the short provisioning window. */
@@ -351,6 +614,9 @@ export class RunCapabilityVault {
         this.values.delete(runId);
     }
 }
+/** A run's deduplicated served packages and refusals (see summarizeRegistryFetches), and its package audit. */
+/** The poll interval, at most, while a run with an overrun limit is near its grant. */
+export const TOP_UP_NEAR_POLL_MS = 1_000;
 class PreflightError extends Error {
 }
 /** A refusal by repository authorization; its message is the failure category's prefix (repo_access_*). */
@@ -364,6 +630,11 @@ export class ContainerExecutor {
     now;
     observer;
     startedAt = new Map();
+    /**
+     * When the cluster last refused each queued run's launch for capacity (this.now() ms). Per
+     * process: another replica's drain may start the run again inside the backoff.
+     */
+    capacityRefusedAt = new Map();
     constructor(options) {
         this.options = options;
         this.artifactRoot = resolve(options.artifactRoot);
@@ -415,6 +686,9 @@ export class ContainerExecutor {
         const current = this.active.get(runId);
         if (current)
             return current;
+        // Refused for capacity a moment ago: keep its place and clock in the queue, untouched.
+        if (this.inCapacityBackoff(runId))
+            return;
         this.startedAt.set(runId, this.now().getTime());
         this.emit({ stage: "queued", runId });
         const execution = this.execute(runId).finally(async () => {
@@ -434,10 +708,16 @@ export class ContainerExecutor {
             return;
         if (TERMINAL_STATUSES.has(run.status))
             return this.cleanupTerminal(run);
-        this.emit({ stage: "stopping", runId, jobId: run.jobHandle?.id });
         // Persist the cancellation fence first so a concurrent finisher cannot publish.
         const failure = this.failure("cancelled", { cancelled: true });
-        await this.options.store.terminate(runId, "cancelled", failure.error, failure.audit);
+        // False when the run reached a terminal status after the load above: its finisher owns the
+        // cleanup and the continuation comment (recover() cleans up any terminal run the reconciler sees
+        // later), so stopping now would overwrite a good outcome. "stopping" is emitted only once this
+        // stop owns the run, so it is always followed by its terminal and cleanup events.
+        if (!(await this.options.store.terminate(runId, "cancelled", failure.error, failure.audit)))
+            return;
+        this.emit({ stage: "stopping", runId, jobId: run.jobHandle?.id });
+        await this.recordRefusal(runId, run.proxySessionId);
         this.terminal(run, "cancelled", failure.audit);
         if (run.proxySessionId)
             await this.options.sessions.cancelSession(run.proxySessionId).catch(() => undefined);
@@ -448,10 +728,11 @@ export class ContainerExecutor {
         this.options.capabilities.delete(runId);
         const input = this.preflightForCleanup(run);
         const workspace = input ? await this.options.vcs.recoverWorkspace(input).catch(() => null) : null;
-        if (workspace) {
+        if (workspace)
             await this.options.vcs.cleanup(workspace).catch(() => undefined);
-            await this.options.vcs.notifyContinuationFinished?.(workspace, "failed", { agentName: run.agentName });
-        }
+        const target = workspace ?? this.continuationTargetOf(run);
+        if (target)
+            await this.options.vcs.notifyContinuationFinished?.(target, "failed", { agentName: run.agentName });
         await rm(this.artifactPath(runId), { recursive: true, force: true }).catch(() => undefined);
         this.emit({ stage: "cleanup", runId, jobId: run.jobHandle?.id, cleanupSucceeded: true });
     }
@@ -479,6 +760,9 @@ export class ContainerExecutor {
             await this.abandon(run, "coding_job_status_unavailable");
             return { state: "lost", reason: "coding_job_status_unavailable" };
         }
+        if (status.state === "pending" && status.capacityRefused && this.options.store.requeueAfterCapacityRefusal) {
+            return this.finishCapacityRequeue(run, run.jobHandle);
+        }
         if (status.state === "pending" || status.state === "running") {
             await this.options.store.heartbeat(run.runId);
             return { state: "active" };
@@ -499,9 +783,12 @@ export class ContainerExecutor {
         let sessionId = run.proxySessionId;
         let handle = run.jobHandle;
         let claimId = null;
+        let planned;
         let spendEnabled = Boolean(sessionId);
         try {
-            const prepared = this.preflight(run);
+            // A launched run resumed after a restart is checked the way recover() checks it: its cost so
+            // far may be past the limit (a reply can cost more than its hold), and it is still delivered.
+            const prepared = this.preflight(run, { launched: Boolean(handle) });
             if (!handle) {
                 if (run.provisioningClaim)
                     return;
@@ -559,7 +846,7 @@ export class ContainerExecutor {
                 const spec = this.jobSpec(run, inputArtifact);
                 // Backends whose handle is derivable (Kubernetes) persist it first, so a crash between the
                 // launch and the write still leaves a handle `abandon()` can stop and remove the run with.
-                const planned = this.options.jobs.plannedHandle?.(spec);
+                planned = this.options.jobs.plannedHandle?.(spec);
                 if (planned)
                     await this.options.store.persistHandle(runId, claimId, planned);
                 handle = await this.whileHeartbeating(runId, () => this.options.jobs.launch(spec));
@@ -567,12 +854,15 @@ export class ContainerExecutor {
                     throw new Error("coding_job_handle_mismatch");
                 }
                 await this.options.store.persistHandle(runId, claimId, handle);
+                this.capacityRefusedAt.delete(runId);
                 this.options.capabilities.delete(runId);
                 this.emit({ stage: "launched", runId, jobId: handle.id, budgetReservedUsd: run.budgetUsd });
             }
             let delay = this.options.pollMinMs ?? 250;
             const maximumDelay = this.options.pollMaxMs ?? 5_000;
             let observedRunning = false;
+            // Overrun from available room: asked on each poll until it is granted in full or refused once.
+            let asksForTopUps = run.budgetLimitUsd !== undefined && run.budgetLimitUsd > run.budgetUsd;
             for (;;) {
                 const status = await this.options.jobs.status(handle);
                 if (status.state !== "pending" && status.state !== "running") {
@@ -584,6 +874,17 @@ export class ContainerExecutor {
                     this.emit({ stage: "running", runId, jobId: handle.id });
                 }
                 await this.options.store.heartbeat(runId);
+                if (asksForTopUps && this.options.store.topUpBudget) {
+                    const topUp = await this.options.store.topUpBudget(runId).catch((error) => {
+                        containerLog.warn({ runId, error: safeError(error) }, "coding run top-up failed; asking again next poll");
+                        return { outcome: "not_needed", near: true };
+                    });
+                    if (topUp.outcome === "unavailable" || topUp.outcome === "closed")
+                        asksForTopUps = false;
+                    // Near its grant: poll often, so the next step lands before a request no longer fits.
+                    else if (topUp.near)
+                        delay = Math.min(delay, TOP_UP_NEAR_POLL_MS);
+                }
                 await this.sleep(delay);
                 delay = Math.min(maximumDelay, Math.max(delay + 1, Math.ceil(delay * 1.5)));
                 run = (await this.options.store.load(runId)) ?? run;
@@ -593,6 +894,34 @@ export class ContainerExecutor {
         }
         catch (error) {
             this.options.capabilities.delete(runId);
+            if (error instanceof JobCapacityError && claimId && this.options.store.requeueAfterCapacityRefusal) {
+                // The cluster has no room for the pod (Kubernetes: the namespace quota): the run waits in
+                // the queue again rather than failing. The launcher already removed what it created, so
+                // there is no job to stop; nothing ran, so the session is dropped with the claim and a
+                // fresh one is made on the next attempt.
+                if (sessionId)
+                    await this.options.sessions.cancelSession(sessionId).catch(() => undefined);
+                const requeued = await this.options.store.requeueAfterCapacityRefusal(runId, {
+                    claimId,
+                    ...(planned ? { planned } : {}),
+                });
+                if (requeued !== "spend_recorded") {
+                    if (workspace)
+                        await this.options.vcs.cleanup(workspace).catch(() => undefined);
+                    if (requeued === "requeued") {
+                        // The next attempt writes its own input; this one names a session that is gone.
+                        await rm(this.artifactPath(runId), { recursive: true, force: true }).catch(() => undefined);
+                        this.recordCapacityRefusal(runId);
+                        this.emit({ stage: "queued", runId });
+                        containerLog.info({ runId }, "coding run waiting for capacity: the cluster refused its pod");
+                    }
+                    return;
+                }
+                // Spend against a pod that never started: fail it like any launch error, and stop and remove
+                // the launcher's record through the planned handle so the run is never launched again.
+                if (planned)
+                    handle = planned;
+            }
             if (sessionId)
                 await this.options.sessions.cancelSession(sessionId).catch(() => undefined);
             if (handle)
@@ -603,7 +932,8 @@ export class ContainerExecutor {
                 : !spendEnabled && error instanceof PreflightError
                     ? "refused"
                     : "failed";
-            const failure = outOfBudget ? this.budgetFailure(error) : this.failure(error);
+            await this.recordRefusal(runId, sessionId);
+            const failure = outOfBudget ? await this.budgetFailure(runId, error) : this.failure(error);
             this.emit({
                 stage: "stopping",
                 runId,
@@ -622,7 +952,7 @@ export class ContainerExecutor {
                 await this.options.vcs.cleanup(workspace).catch(() => undefined);
                 await this.options.vcs.notifyContinuationFinished?.(workspace, outOfBudget ? "budget_exhausted" : "failed", {
                     agentName: run.agentName,
-                    ...(outOfBudget ? { budgetSentence: this.budgetSentence(run) } : {}),
+                    ...(outOfBudget ? { budgetSentence: await this.budgetSentence(run) } : {}),
                     ...(unreadyService ? { serviceSentence: serviceUnreadySentence([unreadyService]) } : {}),
                     ...(protectedPath ? { protectedPathSentence: protectedPathSentence(protectedPath) } : {}),
                 });
@@ -687,39 +1017,62 @@ export class ContainerExecutor {
         if (!decision.ok)
             throw new RepoAccessError(`repo_access_${decision.reason}`);
     }
-    /** The originating issue for the PR title/body: control-plane data from the CodingRun row, key re-validated. */
-    issueFor(run) {
+    /**
+     * The CodingRun's recorded issue as the Related section shows it (a Jira or
+     * GitHub issue): control-plane data from the CodingRun row, key re-validated.
+     */
+    recordedIssue(run) {
         const { issueProvider, issueKey } = run;
-        if (!issueProvider || !issueKey || !ISSUE_KEY.test(issueKey))
+        if (!issueProvider || !issueKey)
+            return undefined;
+        return issueReference(issueProvider, issueKey, (key) => this.options.issueUrl?.(issueProvider, key));
+    }
+    /**
+     * The originating tracker issue for the PR title/body. A GitHub issue is not
+     * one: its line comes from issueSourceFor (`From issue #N`).
+     */
+    issueFor(run) {
+        if (run.issueProvider === "github")
             return {};
-        let url;
+        const issue = this.recordedIssue(run);
+        return issue ? { issue } : {};
+    }
+    /**
+     * The PR title/body's originating issue, whichever system it is in: the
+     * CodingRun's tracker issue (issueFor), else the GitHub issue in the same
+     * repository whose mention started the run tree (`From issue #N`). Read from
+     * the root run, so a continuation's rebuilt body keeps the root's line.
+     * Never throws: a failed lookup gives no issue line.
+     */
+    async issueSourceFor(run) {
+        const tracker = this.issueFor(run);
+        if (tracker.issue || !this.options.store.linkedIssueSource)
+            return tracker;
         try {
-            url = this.options.issueUrl?.(issueProvider, issueKey);
+            const status = (await this.options.store.linkedIssueSource(run.rootCodingRunId ?? run.runId)).hostStatus;
+            if (status?.provider === "github" &&
+                status.issueMention === true &&
+                status.repository.toLowerCase() === run.repository.toLowerCase() &&
+                Number.isSafeInteger(status.number) &&
+                status.number > 0) {
+                return { issueNumber: status.number };
+            }
         }
-        catch {
-            url = undefined;
+        catch (err) {
+            containerLog.warn({ err, runId: run.runId }, "could not find the issue the run came from");
         }
-        const trackerName = Object.hasOwn(ISSUE_TRACKER_NAMES, issueProvider)
-            ? ISSUE_TRACKER_NAMES[issueProvider]
-            : undefined;
-        return {
-            issue: {
-                key: issueKey,
-                ...(url?.startsWith("https://") ? { url } : {}),
-                ...(trackerName ? { trackerName } : {}),
-            },
-        };
+        return {};
     }
     /** The new PR's Related pull requests input: earlier PRs of the same request, then this one. Never throws. */
     async relatedFor(run) {
-        // A continuation pushes onto an existing PR, whose body is never rewritten here.
+        // A continuation's Related block is preserved from the current body (the description update keeps it).
         if (run.rootCodingRunId || !this.options.store.relatedPullRequests)
             return {};
         try {
             const earlier = await this.options.store.relatedPullRequests(run.runId);
             if (earlier.length === 0)
                 return {};
-            const { issue } = this.issueFor(run);
+            const issue = this.recordedIssue(run);
             return {
                 related: {
                     entries: [
@@ -753,14 +1106,20 @@ export class ContainerExecutor {
         const entry = resolveCodingEntry(run.provider, run.model);
         return { version: entry.priceVersion, entry: parseStoredEntry(entry) };
     }
-    preflight(run) {
+    /**
+     * `launched`: the run's job was already launched (it is running, or done and
+     * only its push is left). The cost check applies only before launch: one
+     * reply can cost more than its hold, so a launched run may already be past
+     * its limit, and its finished work is still delivered.
+     */
+    preflight(run, options = {}) {
         try {
             if (run.status !== "pending" && run.status !== "running")
                 throw new Error("coding_run_status_invalid");
             if (run.agentKind !== "coding" || !run.ownerId)
                 throw new Error("coding_run_ownership_invalid");
             this.modelTerms(run);
-            if (!Number.isFinite(run.budgetUsd) || run.budgetUsd <= 0 || run.costUsd > run.budgetUsd) {
+            if (!Number.isFinite(run.budgetUsd) || run.budgetUsd <= 0 || (!options.launched && run.costUsd > run.budgetUsd)) {
                 throw new Error("coding_run_budget_invalid");
             }
             const profile = CodingProfileSchema.parse({
@@ -809,11 +1168,19 @@ export class ContainerExecutor {
         // "failed" and is only flipped right before a success or out-of-budget return.
         let outcome = "failed";
         let finishedSummary;
+        // Set with a success that spent past the run's base budget; says so on the host.
+        let overrun = {};
         // Set when a failed job's session relayed a model-provider failure; names it on the host.
         // Only a failed job: a transient provider error the worker retried past did not end the run.
         let providerClass;
         // Set when finalizeChanges refused the collected diff for touching a protected path; names it on the host.
         let protectedPath;
+        // Set when a continuation's merge of its target branch left conflict markers behind; names the file on the host.
+        let conflictMarkersPath;
+        // Set with a success whose push merged the pull request's target branch; says what on the host.
+        let merged = {};
+        // Set when a run stopped at its budget still pushed its changes so far; says so on the host.
+        let changesPushed;
         try {
             if (jobState !== "succeeded") {
                 const collected = await this.options.jobs.collect(handle).catch(() => null);
@@ -822,7 +1189,8 @@ export class ContainerExecutor {
                 // The worker usually fails outright when the proxy refuses a model
                 // request for budget; the session records that refusal.
                 if (await this.outOfBudget(sessionId)) {
-                    const failure = this.budgetFailure(`job_${reason}`, { issues: collected?.diagnosticIssues });
+                    await this.recordRefusal(run.runId, sessionId);
+                    const failure = await this.budgetFailure(run.runId, `job_${reason}`, { issues: collected?.diagnosticIssues });
                     await this.options.store.terminate(run.runId, "budget_exhausted", failure.error, failure.audit);
                     this.terminal(run, "budget_exhausted", failure.audit);
                     outcome = "budget_exhausted";
@@ -834,6 +1202,7 @@ export class ContainerExecutor {
                     ? this.providerFailureOf(run, provider, `job_${reason}`, { issues: collected?.diagnosticIssues })
                     : this.failure(`job_${reason}`, { issues: collected?.diagnosticIssues });
                 providerClass = provider?.class;
+                await this.recordRefusal(run.runId, sessionId);
                 await this.options.store.terminate(run.runId, status, failure.error, failure.audit);
                 this.terminal(run, status, failure.audit);
                 return;
@@ -842,94 +1211,124 @@ export class ContainerExecutor {
             this.emit({ stage: "collected", runId: run.runId, jobId: handle.id });
             if (collected.reason !== "completed" || !collected.resultArtifact)
                 throw new Error("coding_result_missing");
-            const output = parseCodingAgentOutputJson(collected.resultArtifact);
+            const output = parseCodingWorkerOutputJson(collected.resultArtifact);
             if (output.runId !== run.runId)
                 throw new Error("coding_result_run_mismatch");
-            let current = await this.requireCurrent(run.runId);
-            if (current.costUsd > current.budgetUsd || output.outcome === "budget_exhausted") {
+            const current = this.requireActive(await this.requireCurrent(run.runId));
+            // Finished work is delivered even when it cost more than the run's limit (one reply
+            // can cost more than its hold); the status comment then says so (overrunDetails).
+            if (output.outcome === "budget_exhausted") {
                 this.emit({ stage: "budget_cutoff", runId: run.runId, jobId: handle.id });
-                await this.options.store.complete(run.runId, "budget_exhausted", this.resultFor(output, current, "budget_exhausted"));
-                this.terminal(current, "budget_exhausted");
+                const kept = await this.keepStoppedChanges(run, handle, current, output, existingWorkspace);
+                await this.recordRefusal(run.runId, sessionId);
+                if (kept) {
+                    await this.options.store.complete(run.runId, "budget_exhausted", kept.result, kept.record);
+                    this.emit({ stage: kept.finalized.outcome, runId: run.runId, jobId: handle.id });
+                    this.terminal(kept.current, "budget_exhausted");
+                    changesPushed =
+                        kept.finalized.outcome === "branch_pushed" ? {} : { pullRequestNumber: kept.finalized.pullRequestNumber };
+                    if (kept.finalized.outcome === "pull_request_updated" && kept.finalized.targetMerge) {
+                        merged = { mergeSentence: mergeSentence(kept.finalized.targetMerge) };
+                    }
+                    finishedSummary = output.summary;
+                }
+                else {
+                    const latest = await this.requireCurrent(run.runId).catch(() => current);
+                    await this.options.store.complete(run.runId, "budget_exhausted", this.resultFor(output, latest, "budget_exhausted"), dependencyCacheRecord(output));
+                    this.terminal(latest, "budget_exhausted");
+                }
                 outcome = "budget_exhausted";
                 return;
             }
-            if (output.outcome === "no_changes") {
-                await this.options.store.complete(run.runId, "succeeded", this.resultFor(output, current));
+            // A workspace that merged its target branch has that merge to push even when the agent changed nothing.
+            if (output.outcome === "no_changes" && !(await this.mergedTargetBranch(current, existingWorkspace))) {
+                // Before complete: the terminal hook (a no-change fix round's re-review) reads the refreshed body.
+                const description = await this.refreshDescriptionInTime(current, output, existingWorkspace);
+                await this.recordRefusal(run.runId, sessionId);
+                await this.options.store.complete(run.runId, "succeeded", this.resultFor(output, current), {
+                    ...dependencyCacheRecord(output),
+                    ...description,
+                });
                 this.terminal(current, "succeeded");
                 outcome = "succeeded";
+                overrun = this.overrunDetails(current);
                 finishedSummary = output.summary;
                 return;
             }
-            const preparedInput = this.preflight(current);
-            const workspace = existingWorkspace ?? (await this.options.vcs.recoverWorkspace(preparedInput));
-            if (!workspace)
-                throw new Error("coding_workspace_lost");
-            await this.options.jobs.materializeWorkspace(handle, workspace.workspacePath);
-            await normalizeCollectedLockfiles(current.provider, workspace.workspacePath);
-            current = await this.requireCurrent(run.runId);
-            if (current.costUsd > current.budgetUsd) {
-                this.emit({ stage: "budget_cutoff", runId: run.runId, jobId: handle.id });
-                await this.options.store.complete(run.runId, "budget_exhausted", this.resultFor(output, current, "budget_exhausted"));
-                this.terminal(current, "budget_exhausted");
-                outcome = "budget_exhausted";
-                return;
-            }
-            // One more (usually cached) check right before anything is pushed: access
-            // revoked while the run was working stops the push.
-            await this.authorizeRepository(current, { inFlight: true });
-            const report = await this.loadRegistryReport(run.runId);
-            const finalized = await this.options.vcs.finalizeChanges(workspace, {
-                summary: output.summary,
-                tests: output.tests,
-                tag: output.tag,
-                ...report,
-                ...this.issueFor(current),
-                ...(await this.relatedFor(current)),
-            });
+            const pushed = await this.pushChanges(run, handle, current, output, output.summary, existingWorkspace);
+            const { finalized, workspace } = pushed;
+            // An empty diff pushes nothing, so it refreshes the description the way a
+            // worker no_changes does, before complete (the terminal hook reads the body).
+            const description = finalized.outcome === "no_changes"
+                ? await this.refreshDescriptionInTime(pushed.current, output, workspace)
+                : await this.recordDescription(pushed.current, pushed.descriptionState, finalized.outcome === "pull_request_opened" || finalized.outcome === "pull_request_updated"
+                    ? finalized.description
+                    : undefined);
             // A pushed branch (local repository) is a successful run with no pull
             // request; its branch is recorded on the run for the operator to merge.
-            const result = this.resultFor(output, current, finalized.outcome, finalized);
+            const result = this.resultFor(output, pushed.current, finalized.outcome, finalized);
+            await this.recordRefusal(run.runId, sessionId);
             await this.options.store.complete(run.runId, "succeeded", result, {
-                baseSha: finalized.baseCommit,
-                ...(finalized.outcome === "branch_pushed" ? { resultBranch: finalized.headRef } : {}),
+                ...dependencyCacheRecord(output),
+                ...pushedRecord(finalized),
+                ...description,
             });
-            if (finalized.outcome === "pull_request_opened" ||
-                finalized.outcome === "pull_request_updated" ||
-                finalized.outcome === "branch_pushed") {
+            if (finalized.outcome !== "no_changes") {
                 this.emit({ stage: finalized.outcome, runId: run.runId, jobId: handle.id });
             }
-            this.terminal(current, "succeeded");
+            this.terminal(pushed.current, "succeeded");
             outcome = "succeeded";
+            overrun = this.overrunDetails(pushed.current);
+            if (finalized.outcome === "pull_request_updated" && finalized.targetMerge) {
+                merged = { mergeSentence: mergeSentence(finalized.targetMerge) };
+            }
             finishedSummary = output.summary;
         }
         catch (error) {
-            if (await this.outOfBudget(sessionId)) {
-                const failure = this.budgetFailure(error);
+            if (error instanceof Error && error.message === "coding_run_no_longer_active") {
+                // Stopped while its result was collected: the stop already wrote the terminal row.
+                containerLog.info({ runId: run.runId }, "coding run was stopped before its result was published");
+            }
+            else if (await this.outOfBudget(sessionId)) {
+                await this.recordRefusal(run.runId, sessionId);
+                const failure = await this.budgetFailure(run.runId, error);
                 await this.options.store.terminate(run.runId, "budget_exhausted", failure.error, failure.audit);
                 this.terminal(run, "budget_exhausted", failure.audit);
                 outcome = "budget_exhausted";
             }
             else {
+                await this.recordRefusal(run.runId, sessionId);
                 const failure = this.failure(error);
                 await this.options.store.terminate(run.runId, "failed", failure.error, failure.audit);
                 this.terminal(run, "failed", failure.audit);
                 protectedPath = protectedPathFromError(error) ?? undefined;
+                conflictMarkersPath = conflictMarkersPathFromError(error) ?? undefined;
             }
         }
         finally {
+            if (run.sessionResume)
+                await this.recordTranscript(run, handle);
             await this.options.jobs.remove(handle).catch(() => undefined);
             const input = this.preflightForCleanup(run);
             const workspace = existingWorkspace ?? (input ? await this.options.vcs.recoverWorkspace(input).catch(() => null) : null);
-            if (workspace) {
+            if (workspace)
                 await this.options.vcs.cleanup(workspace).catch(() => undefined);
-                await this.options.vcs.notifyContinuationFinished?.(workspace, outcome, {
+            // A run another process launched has no workspace here; its pull request still gets the final status.
+            const target = workspace ?? this.continuationTargetOf(run);
+            if (target) {
+                await this.options.vcs.notifyContinuationFinished?.(target, outcome, {
                     summary: finishedSummary,
                     agentName: run.agentName,
-                    ...(outcome === "budget_exhausted" ? { budgetSentence: this.budgetSentence(run) } : {}),
+                    ...(outcome === "succeeded" ? { ...merged, ...overrun } : {}),
+                    ...(outcome === "budget_exhausted" ? { budgetSentence: await this.budgetSentence(run) } : {}),
+                    ...(outcome === "budget_exhausted" && changesPushed ? { changesPushed, ...merged } : {}),
                     ...(outcome === "failed" && providerClass ? { providerSentence: providerSentence(providerClass) } : {}),
                     ...(outcome === "failed" && protectedPath
                         ? { protectedPathSentence: protectedPathSentence(protectedPath) }
                         : {}),
+                    ...(outcome === "failed" && conflictMarkersPath
+                        ? { conflictMarkersSentence: conflictMarkersSentence(conflictMarkersPath) }
+                        : {}),
                 });
             }
             await rm(this.artifactPath(run.runId), { recursive: true, force: true }).catch(() => undefined);
@@ -937,6 +1336,412 @@ export class ContainerExecutor {
             await this.notifyTerminal(run.runId);
         }
     }
+    /** Whether the run's workspace merged its pull request's target branch (PreparedWorkspace.targetMerge). */
+    async mergedTargetBranch(run, existingWorkspace) {
+        if (!run.rootCodingRunId)
+            return false;
+        if (existingWorkspace)
+            return Boolean(existingWorkspace.targetMerge);
+        try {
+            return Boolean((await this.options.vcs.recoverWorkspace(this.preflight(run, { launched: true })))?.targetMerge);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Pushes a finished job's changes: copies the job's workspace into the run's,
+     * then, right before finalizeChanges pushes, checks again that the owner still
+     * has access and that the run was not stopped meanwhile. Shared by a finished
+     * run and one stopped at its budget; throws whatever stops the push.
+     */
+    async pushChanges(run, handle, collectedFor, output, summary, existingWorkspace, options = {}) {
+        const preparedInput = this.preflight(collectedFor, { launched: true });
+        const workspace = existingWorkspace ?? (await this.options.vcs.recoverWorkspace(preparedInput));
+        if (!workspace)
+            throw new Error("coding_workspace_lost");
+        await this.options.jobs.materializeWorkspace(handle, workspace.workspacePath);
+        await normalizeCollectedLockfiles(collectedFor.provider, workspace.workspacePath);
+        const current = await this.requireCurrent(run.runId);
+        // One more (usually cached) check right before anything is pushed: access
+        // revoked while the run was working stops the push.
+        await this.authorizeRepository(current, { inFlight: true });
+        // And a run stopped while its result was collected (stop_run, a cancelled task) pushes nothing.
+        this.requireActive(await this.requireCurrent(run.runId));
+        const report = await this.pullRequestRegistryReport(current);
+        // keepDescription: a continuation's existing description is left as it is (no update, no proposal).
+        const descriptionState = options.keepDescription ? null : await this.descriptionStateFor(current);
+        const finalized = await this.options.vcs.finalizeChanges(workspace, {
+            summary,
+            tests: output.tests,
+            tag: output.tag,
+            ...report,
+            ...restoredDependenciesFor(output),
+            ...(await this.issueSourceFor(current)),
+            ...(await this.relatedFor(current)),
+            ...(descriptionState && "baseline" in descriptionState
+                ? { description: { baseline: descriptionState.baseline } }
+                : {}),
+        });
+        return { current, workspace, finalized, descriptionState };
+    }
+    /**
+     * A run stopped at its budget whose worker exited cleanly keeps its changes so
+     * far: they are pushed as the usual draft (or branch), with a summary that says
+     * the work is unfinished. A fresh pull request's description starts with that
+     * summary; a continuation leaves its pull request's description alone (the
+     * status comment says the run stopped), and pushes nothing onto a pull request
+     * that is no longer a draft. Null when there was nothing to push or the push
+     * failed or was skipped for any reason: the run then ends out of budget without
+     * them. Once pushed, the pushed outcome is always returned. Throws only when the
+     * run was stopped meanwhile (the stop wrote its terminal row).
+     */
+    async keepStoppedChanges(run, handle, current, output, existingWorkspace) {
+        const summary = budgetStoppedSummary(output.summary, current.request);
+        const continuesPullRequest = Boolean(current.rootCodingRunId) && hasPullRequestDescription(current);
+        let pushed;
+        try {
+            let workspace = existingWorkspace;
+            if (continuesPullRequest) {
+                workspace ??= await this.options.vcs.recoverWorkspace(this.preflight(current, { launched: true }));
+                if (!workspace)
+                    throw new Error("coding_workspace_lost");
+                if (!(await this.continuationStillDraft(current, workspace))) {
+                    containerLog.info({ runId: run.runId }, "a run stopped at its budget pushes nothing onto a pull request that is no longer a draft");
+                    return null;
+                }
+            }
+            pushed = await this.pushChanges(run, handle, current, output, summary, workspace, {
+                keepDescription: continuesPullRequest,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === "coding_run_no_longer_active")
+                throw error;
+            containerLog.warn({ runId: run.runId, reason: describeFailure(error) }, "could not push the changes of a run stopped at its budget; it ends without them");
+            return null;
+        }
+        const { finalized } = pushed;
+        if (finalized.outcome === "no_changes")
+            return null;
+        // Pushed: from here on the run records the pushed outcome whatever else fails.
+        const description = await this.recordDescription(pushed.current, pushed.descriptionState, finalized.outcome === "pull_request_opened" || finalized.outcome === "pull_request_updated"
+            ? finalized.description
+            : undefined).catch(() => ({}));
+        let result;
+        try {
+            result = this.resultFor({ ...output, summary }, pushed.current, finalized.outcome, finalized);
+        }
+        catch (error) {
+            containerLog.warn({ runId: run.runId, reason: describeFailure(error) }, "could not record the worker's summary and tests of a budget-stopped run; recording its push alone");
+            result = this.resultFor({
+                ...output,
+                summary: budgetStoppedSummary(WORKER_BUDGET_EXHAUSTED_SUMMARY, current.request),
+                tests: [],
+                tag: undefined,
+            }, pushed.current, finalized.outcome, finalized);
+        }
+        return {
+            current: pushed.current,
+            finalized,
+            result,
+            record: { ...dependencyCacheRecord(output), ...pushedRecord(finalized), ...description },
+        };
+    }
+    /**
+     * The pull request description a continuation run is about to replace, for
+     * its task. Undefined for a fresh run or when it cannot be loaded: the run
+     * goes ahead without the note.
+     */
+    async currentDescriptionText(run) {
+        const store = this.options.store;
+        if (!run.rootCodingRunId || !hasPullRequestDescription(run) || !store.pullRequestDescriptionBaseline) {
+            return undefined;
+        }
+        try {
+            return (await store.pullRequestDescriptionBaseline(run.rootCodingRunId)).previousAgentText;
+        }
+        catch (err) {
+            containerLog.debug({ err, runId: run.runId }, "could not load the pull request description for the task");
+            return undefined;
+        }
+    }
+    /**
+     * The issue a continuation's pull request was opened for, read for its task
+     * the way the first run had it: the root run's Jira issue, else the GitHub
+     * issue whose mention started the work (same repository), else the issue the
+     * description wardby last wrote closes (same repository). Each candidate is
+     * read in turn until one is an issue. Undefined for a fresh or local run, or
+     * on any failure: the run goes ahead without it.
+     */
+    async linkedIssueFor(run, description) {
+        const store = this.options.store;
+        const read = this.options.readLinkedIssue;
+        if (!run.rootCodingRunId || !hasPullRequestDescription(run) || !read || !store.linkedIssueSource)
+            return undefined;
+        let timer;
+        const timedOut = new Promise((resolve) => {
+            timer = setTimeout(() => {
+                containerLog.warn({ runId: run.runId }, "reading the linked issue timed out; continuing without it");
+                resolve(undefined);
+            }, LINKED_ISSUE_READ_TIMEOUT_MS);
+        });
+        try {
+            return await Promise.race([this.readLinkedIssue(run, run.rootCodingRunId, description, read), timedOut]);
+        }
+        catch (err) {
+            containerLog.warn({ err, runId: run.runId }, "could not read the linked issue; continuing without it");
+            return undefined;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async readLinkedIssue(run, rootRunId, description, read) {
+        const source = await this.options.store.linkedIssueSource(rootRunId);
+        const candidates = [];
+        if (source.issueProvider === "jira" && source.issueKey && ISSUE_KEY.test(source.issueKey)) {
+            candidates.push({ provider: "jira", key: source.issueKey });
+        }
+        const status = source.hostStatus;
+        if (status?.provider === "github" &&
+            status.repository.toLowerCase() === run.repository.toLowerCase() &&
+            Number.isSafeInteger(status.number) &&
+            status.number > 0) {
+            candidates.push({ provider: "github", repository: run.repository, number: status.number });
+        }
+        const closed = closingIssueNumber(description, run.repository);
+        if (closed !== undefined && !candidates.some((ref) => ref.provider === "github" && ref.number === closed)) {
+            candidates.push({ provider: "github", repository: run.repository, number: closed });
+        }
+        for (const ref of candidates) {
+            let issue;
+            try {
+                issue = await read(ref);
+            }
+            catch (err) {
+                // The next candidate may still be readable.
+                containerLog.warn({ err, runId: run.runId, issue: ref }, "could not read a linked issue candidate");
+                continue;
+            }
+            if (!issue)
+                continue;
+            return ref.provider === "github"
+                ? { kind: "github", number: ref.number, title: issue.title, body: issue.body }
+                : { kind: "jira", key: ref.key, title: issue.title, body: issue.body };
+        }
+        return undefined;
+    }
+    /**
+     * A fix round's description baseline (null: no description flow -- a fresh
+     * run, or a store without it). Never throws: a load failure is recorded as
+     * skipped:error and the push goes ahead without a description update.
+     */
+    /**
+     * Whether a continuation's pull request is still a draft: the host's answer
+     * when it has one, else the root run's record of wardby marking it ready.
+     * A failed record lookup counts as not a draft (nothing unfinished is pushed).
+     */
+    async continuationStillDraft(run, workspace) {
+        const draft = await this.options.vcs.continuationPullRequestDraft?.(workspace).catch(() => undefined);
+        if (draft !== undefined)
+            return draft;
+        const store = this.options.store;
+        if (!run.rootCodingRunId || !store.pullRequestMarkedReady)
+            return true;
+        try {
+            return !(await store.pullRequestMarkedReady(run.rootCodingRunId));
+        }
+        catch (err) {
+            containerLog.warn({ err, runId: run.runId }, "could not read whether the pull request was marked ready");
+            return false;
+        }
+    }
+    async descriptionStateFor(run) {
+        const store = this.options.store;
+        if (!run.rootCodingRunId || !hasPullRequestDescription(run) || !store.pullRequestDescriptionBaseline)
+            return null;
+        let stored;
+        try {
+            stored = await store.pullRequestDescriptionBaseline(run.rootCodingRunId);
+        }
+        catch (err) {
+            containerLog.warn({ err, runId: run.runId }, "could not load the pull request description baseline");
+            return { failed: true };
+        }
+        const { legacySource, ...baseline } = stored;
+        if (baseline.recordedSha256 !== null || !legacySource)
+            return { baseline };
+        const legacySha256 = await this.legacyDescriptionSha256(run.rootCodingRunId, legacySource);
+        return { baseline: legacySha256 ? { ...baseline, legacySha256 } : baseline };
+    }
+    /**
+     * A legacy pull request's description as its root run wrote it, rebuilt from
+     * stored records (the final message, tests, packages, dependency cache line
+     * and issue line; the Related section is not hashed), and hashed. Undefined
+     * when the root stored no final message, or on any failure: the description
+     * then counts as edited, the safe direction. A lock file line the root's
+     * refusal warning may have carried is not stored, so such a description
+     * never matches.
+     */
+    async legacyDescriptionSha256(rootRunId, source) {
+        if (!source.summary)
+            return undefined;
+        try {
+            const tests = storedTests(source.tests);
+            const restored = source.dependencyCache === undefined
+                ? []
+                : restoredDependencyFolders(sanitizeDependencyCacheReport(source.dependencyCache));
+            const body = pullRequestBody({
+                repository: source.repository,
+                baseRef: source.baseRef,
+                headRef: source.headRef,
+                runId: rootRunId,
+                summary: source.summary,
+                ...(tests.length > 0 ? { tests } : {}),
+                ...(await this.loadRegistryReport(rootRunId)),
+                ...(restored.length > 0 ? { restoredDependencies: restored } : {}),
+                ...this.issueFor({ issueProvider: source.issueProvider ?? null, issueKey: source.issueKey ?? null }),
+            });
+            return descriptionSha256(body);
+        }
+        catch (err) {
+            containerLog.debug({ err, rootRunId }, "could not rebuild a legacy pull request description");
+            return undefined;
+        }
+    }
+    /**
+     * The Packages section's input: on a continuation, every package installed
+     * by the runs that pushed to the pull request plus this run (merged in run
+     * order); refusals are this run's only, since they describe the current
+     * state. A fresh run, or a failed listing, reports this run's alone.
+     */
+    async pullRequestRegistryReport(run) {
+        const own = await this.loadRegistryReport(run.runId);
+        const store = this.options.store;
+        if (!run.rootCodingRunId || !hasPullRequestDescription(run) || !store.pullRequestRunIds)
+            return own;
+        let earlier;
+        try {
+            earlier = (await store.pullRequestRunIds(run.rootCodingRunId)).filter((id) => id !== run.runId);
+        }
+        catch (err) {
+            containerLog.warn({ err, runId: run.runId }, "could not list the pull request's runs; listing this run's packages");
+            return own;
+        }
+        const reports = await Promise.all(earlier.map((id) => this.loadRegistryReport(id)));
+        const packages = mergePackages([...reports.map((report) => report.packages ?? []), own.packages ?? []]);
+        // Package audit mode is cumulative like packages: the banner stays on the
+        // pull request once any of its runs had the mode.
+        const packageAudit = mergePackageAuditReports([...reports.map((report) => report.packageAudit), own.packageAudit]);
+        return {
+            ...(packages.length > 0 ? { packages } : {}),
+            ...(own.packageRefusals ? { packageRefusals: own.packageRefusals } : {}),
+            ...(packageAudit ? { packageAudit } : {}),
+        };
+    }
+    /**
+     * The run's description columns for store.complete. A fresh run that wrote
+     * its PR records the hash on its own (root) row; a fix round that wrote or
+     * kept wardby's text compare-and-sets the root's hash. Never throws.
+     */
+    async recordDescription(run, state, outcome) {
+        if (!hasPullRequestDescription(run))
+            return {};
+        if (!run.rootCodingRunId) {
+            return outcome?.kind === "written"
+                ? { prDescriptionOutcome: "written", prDescriptionSha256: outcome.sha256, prDescriptionRunId: run.runId }
+                : {};
+        }
+        if (!state)
+            return {};
+        if ("failed" in state)
+            return { prDescriptionOutcome: "skipped:error" };
+        if (!outcome || outcome.kind === "written")
+            return {};
+        const label = descriptionOutcomeLabel(outcome);
+        if (outcome.kind !== "replaced" && outcome.kind !== "refreshed" && outcome.kind !== "unchanged") {
+            return { prDescriptionOutcome: label };
+        }
+        const store = this.options.store;
+        if (!store.recordPullRequestDescription)
+            return { prDescriptionOutcome: label };
+        try {
+            const won = await store.recordPullRequestDescription({
+                rootRunId: run.rootCodingRunId,
+                expectedSha256: state.baseline.recordedSha256,
+                sha256: outcome.sha256,
+                agentTextRunId: outcome.agentTextRunId,
+            });
+            // A lost race leaves the root's hash as the other write left it: the next
+            // round sees a mismatch and falls back to a comment, the safe direction.
+            if (!won) {
+                containerLog.warn({ runId: run.runId, rootRunId: run.rootCodingRunId }, "pull request description hash changed meanwhile; not recorded");
+            }
+            return { prDescriptionOutcome: label };
+        }
+        catch (err) {
+            containerLog.warn({ err, runId: run.runId }, "could not record the pull request description hash");
+            return { prDescriptionOutcome: "skipped:error" };
+        }
+    }
+    /**
+     * refreshDescriptionWithoutPush, capped at DESCRIPTION_REFRESH_TIMEOUT_MS so a
+     * slow host cannot hold up store.complete; a timeout is skipped:error.
+     */
+    async refreshDescriptionInTime(run, output, existingWorkspace) {
+        let timer;
+        const timedOut = new Promise((resolve) => {
+            timer = setTimeout(() => {
+                containerLog.warn({ runId: run.runId, timeoutMs: DESCRIPTION_REFRESH_TIMEOUT_MS }, "pull request description refresh timed out");
+                resolve({ prDescriptionOutcome: "skipped:error" });
+            }, DESCRIPTION_REFRESH_TIMEOUT_MS);
+        });
+        try {
+            return await Promise.race([this.refreshDescriptionWithoutPush(run, output, existingWorkspace), timedOut]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * A fix round that changed nothing still re-derives its PR description (no
+     * push). Never throws: any failure is recorded as skipped:error.
+     */
+    async refreshDescriptionWithoutPush(run, output, existingWorkspace) {
+        const vcs = this.options.vcs;
+        if (!run.rootCodingRunId || !hasPullRequestDescription(run) || !vcs.refreshPullRequestDescription)
+            return {};
+        const state = await this.descriptionStateFor(run);
+        if (!state || "failed" in state)
+            return this.recordDescription(run, state, undefined);
+        try {
+            const input = this.preflightForCleanup(run);
+            // Only the pull request is needed: a run another process launched has no workspace here.
+            const workspace = existingWorkspace ??
+                (input ? await vcs.recoverWorkspace(input).catch(() => null) : null) ??
+                this.continuationTargetOf(run);
+            if (!workspace)
+                throw new Error("coding_workspace_lost");
+            // The same in-flight access check a push gets: a revoked owner's run edits nothing.
+            await this.authorizeRepository(run, { inFlight: true });
+            const details = {
+                summary: output.summary,
+                tests: output.tests,
+                tag: output.tag,
+                ...(await this.pullRequestRegistryReport(run)),
+                ...restoredDependenciesFor(output),
+                ...(await this.issueSourceFor(run)),
+                description: { baseline: state.baseline },
+            };
+            const outcome = await vcs.refreshPullRequestDescription(workspace, details);
+            return await this.recordDescription(run, state, outcome);
+        }
+        catch (err) {
+            containerLog.warn({ err, runId: run.runId }, "could not refresh the pull request description");
+            return { prDescriptionOutcome: "skipped:error" };
+        }
+    }
     /** Runs the onCodingRunTerminal hook; nothing it does, throws, or rejects reaches the caller. */
     async notifyTerminal(runId) {
         const hook = this.options.onCodingRunTerminal;
@@ -956,10 +1761,15 @@ export class ContainerExecutor {
         try {
             const report = await this.options.registryReport?.(runId);
             const packages = Array.isArray(report?.packages) ? report.packages : [];
-            const packageRefusals = Array.isArray(report?.packageRefusals) ? report.packageRefusals : [];
+            // A listing-only refusal is for get_run and the agent, not the PR (see LISTING_REFUSAL_FILENAME).
+            const packageRefusals = Array.isArray(report?.packageRefusals) ? warningRefusals(report.packageRefusals) : [];
+            const packageAudit = isPackageAuditMode(report?.packageAuditMode)
+                ? { mode: report.packageAuditMode, entries: Array.isArray(report.packageAudit) ? report.packageAudit : [] }
+                : undefined;
             return {
                 ...(packages.length > 0 ? { packages } : {}),
                 ...(packageRefusals.length > 0 ? { packageRefusals } : {}),
+                ...(packageAudit ? { packageAudit } : {}),
             };
         }
         catch {
@@ -1081,12 +1891,89 @@ export class ContainerExecutor {
     async warmUp() {
         await this.options.jobs.warmUp?.();
     }
+    /**
+     * Throws coding_run_no_longer_active once something else made the run terminal (a stop's
+     * cancellation fence): nothing may then be pushed, opened, or rewritten on the host for it.
+     */
+    requireActive(run) {
+        if (TERMINAL_STATUSES.has(run.status))
+            throw new Error("coding_run_no_longer_active");
+        return run;
+    }
     async requireCurrent(runId) {
         const current = await this.options.store.load(runId);
         if (!current)
             throw new Error("coding_run_not_found");
         return current;
     }
+    /**
+     * Recovery's half of a capacity refusal: the launcher recorded it, but the process died before the
+     * store put the run back in the queue. The planned handle the attempt persisted is the ownership
+     * proof; the run waits in the queue again, never reported ended.
+     */
+    async finishCapacityRequeue(run, planned) {
+        const outcome = await this.options.store.requeueAfterCapacityRefusal(run.runId, { planned });
+        if (outcome === "spend_recorded") {
+            await this.abandon(run, "coding_ambiguous_provisioning");
+            return { state: "lost", reason: "coding_ambiguous_provisioning" };
+        }
+        if (outcome === "not_owned") {
+            const current = await this.options.store.load(run.runId);
+            if (!current || !TERMINAL_STATUSES.has(current.status))
+                return { state: "active" };
+            await this.cleanupTerminal(current);
+            return { state: "terminal" };
+        }
+        // The session went with the requeue; the rest of what the dead attempt left is removed here.
+        this.options.capabilities.delete(run.runId);
+        const input = this.preflightForCleanup(run);
+        const workspace = input ? await this.options.vcs.recoverWorkspace(input).catch(() => null) : null;
+        if (workspace)
+            await this.options.vcs.cleanup(workspace).catch(() => undefined);
+        await rm(this.artifactPath(run.runId), { recursive: true, force: true }).catch(() => undefined);
+        this.emit({ stage: "queued", runId: run.runId });
+        containerLog.info({ runId: run.runId }, "coding run waiting for capacity: recovered a refusal its process left");
+        return { state: "active" };
+    }
+    /**
+     * After drainCodingQueue failed a queued run (coding_queue_timeout): releases what an earlier
+     * attempt the cluster refused left behind, as stop() does for a queued run. A refused
+     * continuation already marked its pull request as being worked on; that check is finished
+     * here. Best effort; the artifact is removed only where this process wrote it.
+     */
+    async cleanupQueueTimeout(runId) {
+        this.capacityRefusedAt.delete(runId);
+        this.options.capabilities.delete(runId);
+        const run = await this.options.store.load(runId);
+        if (run) {
+            const input = this.preflightForCleanup(run);
+            const workspace = input ? await this.options.vcs.recoverWorkspace(input).catch(() => null) : null;
+            if (workspace)
+                await this.options.vcs.cleanup(workspace).catch(() => undefined);
+            const target = workspace ?? this.continuationTargetOf(run);
+            if (target)
+                await this.options.vcs.notifyContinuationFinished?.(target, "failed", { agentName: run.agentName });
+        }
+        await rm(this.artifactPath(runId), { recursive: true, force: true }).catch(() => undefined);
+    }
+    recordCapacityRefusal(runId) {
+        const now = this.now().getTime();
+        // Drop the ones whose backoff is over, so runs that never come back (timed out in the queue) do not pile up.
+        for (const [id, at] of this.capacityRefusedAt) {
+            if (now - at >= CAPACITY_RETRY_BACKOFF_MS)
+                this.capacityRefusedAt.delete(id);
+        }
+        this.capacityRefusedAt.set(runId, now);
+    }
+    inCapacityBackoff(runId) {
+        const at = this.capacityRefusedAt.get(runId);
+        if (at === undefined)
+            return false;
+        if (this.now().getTime() - at < CAPACITY_RETRY_BACKOFF_MS)
+            return true;
+        this.capacityRefusedAt.delete(runId);
+        return false;
+    }
     /**
      * False when the launcher reports this run's job would not fit the cluster right now; the run
      * is then queued and drainCodingQueue retries it. Launchers and stores without the hooks, and
@@ -1128,6 +2015,10 @@ export class ContainerExecutor {
             // A run keeps the tool image it was dispatched with; rows from before CodingRun.toolImage use the default.
             ...(provider === "claude-code" ? { toolImage: run.toolImage ?? this.options.claudeToolRunnerImage } : {}),
             inputArtifact,
+            // Only when on: every other run's spec stays exactly what it was.
+            ...(run.dependencyCache ? { dependencyCache: true } : {}),
+            // Claude Code only: the launcher gives the SDK's config dir, where the session grows, its own scratch.
+            ...(run.sessionResume && provider === "claude-code" ? { sessionResume: true } : {}),
             timeoutSec: run.timeoutSec,
             limits: { ...this.options.limits, ...(run.workspaceDiskMb ? { diskMb: run.workspaceDiskMb } : {}) },
             labels: {},
@@ -1154,8 +2045,13 @@ export class ContainerExecutor {
         const destination = join(directory, "input.json");
         const temporary = join(directory, `.input-${randomUUID()}.tmp`);
         const services = parseStoredServices(run.services);
-        const task = withBaseCommit(run.task, workspace.baseCommit);
-        if (task === run.task && /^[0-9a-f]{40}$/.test(workspace.baseCommit)) {
+        const withCommit = withBaseCommit(run.task, workspace.baseCommit);
+        const description = await this.currentDescriptionText(run);
+        // The ticket first, then the description: each is cut to what's left of the task's budget.
+        // The target-branch merge note (conflicts to resolve) comes before the ticket and the description.
+        const withMerge = withTargetMerge(withCommit, workspace.targetMerge, run.headRef);
+        const task = withPullRequestDescription(withLinkedIssue(withMerge, await this.linkedIssueFor(run, description)), description);
+        if (withCommit === run.task && /^[0-9a-f]{40}$/.test(workspace.baseCommit)) {
             containerLog.warn({ event: "coding.base_commit_omitted", runId: run.runId }, "the coding task left no room for the base commit line");
         }
         // A repository context read must never fail a run ("the run never fails because of context"):
@@ -1179,17 +2075,31 @@ export class ContainerExecutor {
             headRef: run.headRef,
             task,
             model: run.model,
-            budgetUsd: run.budgetUsd,
+            // The run's limit, not its grant: the proxy enforces the grant, and top-ups raise it while
+            // the job runs. Claude Code's own budget stop (its SDK maxBudgetUsd) is set from this, so it
+            // never stops a run before a top-up can; Codex has no stop of its own.
+            budgetUsd: run.budgetLimitUsd ?? run.budgetUsd,
             deadlineAt: deadlineAt.toISOString(),
             continuationOf: run.rootCodingRunId ? { runId: run.rootCodingRunId } : undefined,
             // Only when true: an untraced run's input stays exactly what older workers expect.
             ...(run.debugTrace ? { debugTrace: true } : {}),
+            // Only on a traced run whose agent sets a cap: every other run's input stays exactly what older workers expect.
+            ...(run.debugTrace && run.debugTraceMaxMb ? { debugTraceMaxMb: run.debugTraceMaxMb } : {}),
             // Only when the agent sets one: every other run's input stays exactly what older workers expect.
             ...(run.maxTurns ? { maxTurns: run.maxTurns } : {}),
+            // Only when the agent sets one: every other run's input stays exactly what older workers expect.
+            ...(run.maxOutputTokens ? { maxOutputTokens: run.maxOutputTokens } : {}),
             // Only when off: every other run's input stays exactly what older workers expect.
             ...(run.repoSkills === false ? { repoSkills: false } : {}),
             // Only when off: every other run's input stays exactly what older workers expect.
             ...(run.claudeBareMode === false ? { claudeBareMode: false } : {}),
+            // Only when on: every other run's input stays exactly what older workers expect. The volume
+            // size (the job spec's limits.diskMb) bounds what the cache may restore.
+            ...(run.dependencyCache
+                ? { dependencyCache: true, diskMb: run.workspaceDiskMb ?? this.options.limits.diskMb }
+                : {}),
+            // Only when on: every other run's input stays exactly what older workers expect.
+            ...(run.sessionResume && run.provider === "claude-code" ? { sessionResume: true } : {}),
             // Only when there are some: every other run's input stays exactly what older workers expect.
             ...(services.length > 0 ? { services: workerServices(services) } : {}),
             // Only when there is something to load: every other run's input stays exactly what older workers expect.
@@ -1231,6 +2141,58 @@ export class ContainerExecutor {
     artifactPath(runId) {
         return resolve(this.artifactRoot, runId);
     }
+    /**
+     * A continuation's pull request from the run record alone, for the host-side
+     * finish signals when the workspace is gone (another control-plane process
+     * launched the run). Null for a fresh run: it has no pull request yet.
+     */
+    continuationTargetOf(run) {
+        if (!run.rootCodingRunId)
+            return null;
+        return {
+            runId: run.runId,
+            repository: run.repository,
+            baseRef: run.baseRef,
+            headRef: run.headRef,
+            continuation: { rootRunId: run.rootCodingRunId },
+        };
+    }
+    /**
+     * Session resume: never throws, never changes the run's outcome. The recorder redacts; only a status
+     * code is logged. The run capability is already gone from the vault, so it is not passed (the recorder
+     * removes its fixed token shape).
+     */
+    async recordTranscript(run, handle) {
+        const recorder = this.options.transcripts;
+        if (!recorder)
+            return;
+        const jobs = this.options.jobs;
+        let timer;
+        try {
+            const recording = Promise.resolve()
+                .then(() => recorder.record({
+                runId: run.runId,
+                agentId: run.agentId,
+                provider: run.provider,
+                read: (maxBytes) => jobs.readTranscript ? jobs.readTranscript(handle, maxBytes) : Promise.resolve(undefined),
+            }))
+                .catch(() => "failed");
+            const timeout = new Promise((resolve) => {
+                timer = setTimeout(() => resolve("timeout"), TRANSCRIPT_RECORD_TIMEOUT_MS);
+                timer.unref();
+            });
+            const result = await Promise.race([recording, timeout]);
+            if (result !== "stored")
+                containerLog.info({ runId: run.runId, transcript: result }, "run transcript not stored");
+        }
+        catch {
+            // never changes the run's outcome
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
     preflightForCleanup(run) {
         if (!Array.isArray(run.protectedPaths) || !run.protectedPaths.every((path) => typeof path === "string"))
             return null;
@@ -1255,6 +2217,7 @@ export class ContainerExecutor {
         const failure = this.failure(reason);
         await this.options.store.terminate(run.runId, "lost", failure.error, failure.audit);
         this.terminal(run, "lost", failure.audit);
+        await this.recordRefusal(run.runId, run.proxySessionId);
         if (run.proxySessionId)
             await this.options.sessions.cancelSession(run.proxySessionId).catch(() => undefined);
         if (run.jobHandle) {
@@ -1264,14 +2227,17 @@ export class ContainerExecutor {
         }
         const input = this.preflightForCleanup(run);
         const workspace = input ? await this.options.vcs.recoverWorkspace(input).catch(() => null) : null;
-        if (workspace) {
+        if (workspace)
             await this.options.vcs.cleanup(workspace).catch(() => undefined);
-            await this.options.vcs.notifyContinuationFinished?.(workspace, "failed", { agentName: run.agentName });
-        }
+        const target = workspace ?? this.continuationTargetOf(run);
+        if (target)
+            await this.options.vcs.notifyContinuationFinished?.(target, "failed", { agentName: run.agentName });
         await rm(this.artifactPath(run.runId), { recursive: true, force: true }).catch(() => undefined);
         this.emit({ stage: "cleanup", runId: run.runId, jobId: run.jobHandle?.id, cleanupSucceeded: true });
     }
     async cleanupTerminal(run) {
+        // A run another path ended (or one recovered after a crash) still gets its refusal; the copy is idempotent.
+        await this.recordRefusal(run.runId, run.proxySessionId);
         if (run.proxySessionId)
             await this.options.sessions.cancelSession(run.proxySessionId).catch(() => undefined);
         if (run.jobHandle) {
@@ -1301,7 +2267,9 @@ export class ContainerExecutor {
             const protectedPathFailed = run.status === "failed" && run.failureCategory === PROTECTED_PATH_CATEGORY;
             await this.options.vcs.notifyContinuationFinished?.(workspace, outcome, {
                 agentName: run.agentName,
-                ...(outcome === "budget_exhausted" ? { budgetSentence: this.budgetSentence(run) } : {}),
+                ...(outcome === "succeeded" ? this.overrunDetails(run) : {}),
+                ...(outcome === "budget_exhausted" ? { budgetSentence: await this.budgetSentence(run) } : {}),
+                ...(outcome === "budget_exhausted" ? storedChangesPushed(run.result) : {}),
                 ...(providerClass ? { providerSentence: providerSentence(providerClass) } : {}),
                 ...(unreadyServices ? { serviceSentence: serviceUnreadySentence(unreadyServices) } : {}),
                 ...(protectedPathFailed ? { protectedPathSentence: protectedPathSentence(null) } : {}),
@@ -1310,6 +2278,16 @@ export class ContainerExecutor {
         await rm(this.artifactPath(run.runId), { recursive: true, force: true }).catch(() => undefined);
         this.emit({ stage: "cleanup", runId: run.runId, jobId: run.jobHandle?.id, cleanupSucceeded: true });
     }
+    /**
+     * Records the session's budget refusal on the run, at every ending: a run the proxy refused once may
+     * still finish, fail for another reason, or be stopped. A session with no refusal adds nothing.
+     * Best effort; never throws.
+     */
+    async recordRefusal(runId, sessionId) {
+        if (!sessionId)
+            return;
+        await this.options.store.recordBudgetRefusal?.(runId, sessionId).catch(() => undefined);
+    }
     /** Whether the proxy refused this run's session for budget. Never throws. */
     async outOfBudget(sessionId) {
         if (!sessionId || !this.options.sessions.budgetExhausted)
@@ -1337,11 +2315,23 @@ export class ContainerExecutor {
             audit: { failureCategory: `provider_${provider.class}`, diagnosticId: logged.audit.diagnosticId },
         };
     }
+    /** The overrun sentence for a finished run that spent past its base budget, as status details. */
+    overrunDetails(run) {
+        if (run.budgetBaseUsd === undefined)
+            return {};
+        const sentence = overrunSentence(run.costUsd, run.budgetBaseUsd, run.budgetLimitUsd ?? run.budgetUsd);
+        return sentence ? { overrunSentence: sentence } : {};
+    }
     /** The host-safe sentence for a run that ran out of budget. */
-    budgetSentence(run) {
+    async budgetSentence(run) {
+        const loaded = await this.options.store.budgetEvent?.(run.runId).catch(() => null);
+        if (loaded)
+            return hostBudgetSentence(loaded.event);
         return budgetSentence({
             runBudgetUsd: run.budgetUsd,
             agentBudgetUsd: run.agentBudgetUsd ?? run.budgetUsd,
+            baseBudgetUsd: run.budgetBaseUsd,
+            limitUsd: run.budgetLimitUsd,
             budgetGroupName: run.budgetGroupName,
         });
     }
@@ -1349,10 +2339,13 @@ export class ContainerExecutor {
      * A failure the proxy's budget refusal caused. The failure itself is still
      * logged under its diagnostic id, so the operator keeps the real reason.
      */
-    budgetFailure(error, options = {}) {
+    async budgetFailure(runId, error, options = {}) {
         const logged = this.failure(error, options);
+        const loaded = await this.options.store.budgetEvent?.(runId).catch(() => null);
         return {
-            error: "coding_budget_exhausted",
+            error: loaded
+                ? `coding_budget_exhausted: ${ownerBudgetSentence(loaded.event, loaded.agentName)}`
+                : "coding_budget_exhausted",
             audit: { failureCategory: "budget", diagnosticId: logged.audit.diagnosticId },
         };
     }
@@ -1365,6 +2358,7 @@ export class ContainerExecutor {
         }
     }
     terminal(run, outcome, audit) {
+        this.capacityRefusedAt.delete(run.runId);
         this.emit({
             stage: "terminal",
             runId: run.runId,
@@ -1449,6 +2443,10 @@ const CATEGORY_BY_PREFIX = [
     // Checked before the generic "vcs_" fallback: the collected diff touched a
     // path this agent may not edit, not a generic workspace/git failure.
     ["vcs_protected_path:", PROTECTED_PATH_CATEGORY],
+    // A continuation's target-branch merge (git.ts): conflict markers left in a
+    // conflicted file, or a target branch that could not be fetched or merged.
+    [CONFLICT_MARKERS_ERROR_PREFIX, MERGE_CONFLICT_CATEGORY],
+    [TARGET_MERGE_FAILED_ERROR, TARGET_MERGE_CATEGORY],
     // A continuation whose pull request was merged or closed: nothing pushed (coding/continuation-wording.ts).
     [CONTINUATION_CLOSED_ERROR, CONTINUATION_CLOSED_CATEGORY],
     // A provider whose worker images this deployment doesn't configure (codex or claude-code): configuration.
@@ -1507,6 +2505,53 @@ function failureCategory(error) {
         return "cancelled";
     return "executor";
 }
+/** A stored CodingRun result's summary (the agent-written description text), when it has one. */
+function storedSummary(result) {
+    const summary = storedField(result, "summary");
+    return typeof summary === "string" ? summary : undefined;
+}
+/** One field of a stored JSON object; undefined when it isn't an object. */
+function storedField(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value[key];
+}
+/** Stored test results the PR body can list (command + outcome); anything else is dropped. */
+function storedTests(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((test) => {
+        const command = storedField(test, "command");
+        const outcome = storedField(test, "outcome");
+        return typeof command === "string" && (outcome === "passed" || outcome === "failed" || outcome === "skipped")
+            ? [{ command, outcome }]
+            : [];
+    });
+}
+/**
+ * Packages from several runs' reports, in order: one entry per ecosystem +
+ * name + version, first appearance first, accepted advisories merged.
+ */
+function mergePackages(lists) {
+    const merged = new Map();
+    for (const list of lists) {
+        for (const pkg of list) {
+            const key = `${pkg.ecosystem}\0${pkg.name}\0${pkg.version}`;
+            const existing = merged.get(key);
+            if (!existing) {
+                merged.set(key, {
+                    ...pkg,
+                    ...(pkg.acceptedAdvisories ? { acceptedAdvisories: [...pkg.acceptedAdvisories] } : {}),
+                });
+                continue;
+            }
+            if (pkg.acceptedAdvisories?.length) {
+                existing.acceptedAdvisories = [...new Set([...(existing.acceptedAdvisories ?? []), ...pkg.acceptedAdvisories])];
+            }
+        }
+    }
+    return [...merged.values()];
+}
 function stableJson(value) {
     if (Array.isArray(value))
         return `[${value.map(stableJson).join(",")}]`;