@bridge_gpt/mcp-server 0.2.69 → 0.2.70

package/build/executor/job-runner.js

@@ -4,7 +4,7 @@ import { createHash, randomUUID } from "node:crypto";
 import path from "node:path";
 import { findWorktreeByBranch, parseGitWorktreePorcelain } from "./worktree-inspection.js";
 import { resolveExecutorBranch, configureExecutorBranch } from "./worktree.js";
-import { renderWorkerVerificationGuidance, renderWorkerPrBaseGuidance } from "./worker-verification-guidance.js";
+import { renderWorkerVerificationGuidance, renderWorkerPrBaseGuidance, renderWorkerTimeBudgetGuidance } from "./worker-verification-guidance.js";
 /**
  * Claimed-job execution engine (BAPI-534 core, BAPI-535 job behaviors; TDD §7/§8/§9).
  *
@@ -21,11 +21,13 @@ import { renderWorkerVerificationGuidance, renderWorkerPrBaseGuidance } from "./
  * `spec_review`, plus per-job worker-log tee, watch registry, and optional
  * read-only viewer tabs wired around every spawned worker.
  */
-import { rm, readdir, lstat, unlink, realpath } from "node:fs/promises";
+import { rm, readdir, lstat, unlink, realpath, rename as fsRename, stat as fsStat } from "node:fs/promises";
+import { provisionWorktreeSettingsExclude } from "./permissions.js";
 import os from "node:os";
-import { runHeartbeatLoop } from "./heartbeat.js";
-import { isExecutorNamedError, toExecutorFailure, RebaseNotVerified, secretFreeErrorMessage, MissingVerdictArtifact, PackagedRecipeUndeliverable, PreSpawnVerification, RequiredMcpRegistration, McpSurfaceMismatch, WorkerStartupFatal, WORKER_STARTUP_FATAL_MESSAGE, WorkerEndedWithPendingBackgroundWork, WORKER_ENDED_WITH_PENDING_BACKGROUND_WORK_MESSAGE, formatMcpSurfaceMismatch, ClaudeNotAuthenticated, CLAUDE_NOT_AUTHENTICATED_MESSAGE, ExecutorAdapterUnavailable, ExecutorNamedError, WorktreeBusy, StaleArtifactCleanupFailed, CiFixContext, WORKTREE_BUSY_MESSAGE, WorkerEnvFilePresent, WORKER_ENV_FILE_PRESENT_MESSAGE, } from "./job-errors.js";
-import { buildConductorMergeAccessForExecutorJob, buildDefaultMergeLocalDeps, runExecutorMergeJob, MERGE_RETRYABLE, MERGE_FAILED, } from "./merge-job.js";
+import { runHeartbeatLoop, sendImmediateHeartbeat } from "./heartbeat.js";
+import { cleanupReportPermitsRecordRemoval, retryWakeCleanupReport, submitCleanupReport, } from "./cleanup-report.js";
+import { isExecutorNamedError, toExecutorFailure, RebaseNotVerified, secretFreeErrorMessage, secretFreeWorktreeMessage, WorktreeSetupRefused, MissingVerdictArtifact, PackagedRecipeUndeliverable, PreSpawnVerification, RequiredMcpRegistration, McpSurfaceMismatch, WorkerStartupFatal, WORKER_STARTUP_FATAL_MESSAGE, WorkerEndedWithPendingBackgroundWork, WORKER_ENDED_WITH_PENDING_BACKGROUND_WORK_MESSAGE, formatMcpSurfaceMismatch, ClaudeNotAuthenticated, CLAUDE_NOT_AUTHENTICATED_MESSAGE, ExecutorAdapterUnavailable, ExecutorNamedError, WorktreeBusy, StaleArtifactCleanupFailed, CiFixContext, WORKTREE_BUSY_MESSAGE, WorkerEnvFilePresent, WORKER_ENV_FILE_PRESENT_MESSAGE, } from "./job-errors.js";
+import { buildConductorMergeAccessForExecutorJob, buildMergeLocalDepsForJob, runExecutorMergeJob, MERGE_RETRYABLE, MERGE_FAILED, MERGE_ACCESS_UNAVAILABLE, MERGE_FLOW_ERROR, MERGE_FLOW_TIMEOUT, MERGE_NO_OUTCOME, } from "./merge-job.js";
 import { createProductionCiRerunDeps, runCiRerunJob, } from "./ci-rerun-job.js";
 import { createProductionGateQualificationDeps, runGateQualificationJob, GATE_QUALIFICATION_FAILED, GATE_QUALIFICATION_INTERRUPTED, } from "./gate-qualification-job.js";
 import { createObservationState } from "./observation.js";
@@ -34,8 +36,8 @@ import { resolveExecutorAgentAdapter } from "../agent-launchers/executor-adapter
 import { redactAdapterDiagnostic } from "../agent-launchers/executor-adapter.js";
 import { resolveExecutorAgentId } from "./agent-identity.js";
 import { closeStdinBounded, createProcessTerminationController, runProcessWithTimeout, writeStdinBounded, } from "./process.js";
-import { buildNotLaunchedEnvelope, claimRequiresCompletionEvidence, COMPLETION_CONTRACT_MARKER_VALUES, isCoveredJobType, MAX_EVENT_BYTES, runtimeMatchesSupported, successRefusalReason, verificationVerdictFromFacts, } from "./completion-contract.js";
-import { COMPLETION_CAUSE_ERROR_KINDS, EOF_DRAIN_BOUND_MS, STDIN_CLOSE_GRACE_MS, finalizationFacts, finalizationObligations, planCompletionAllowance, readCompletionBinding, readDeclaredChecks, readOptionalWatchers, readRequiredVerification, } from "./completion-supervision.js";
+import { buildNotLaunchedEnvelope, claimRequiresCleanupReport, claimRequiresCompletionEvidence, COMPLETION_CONTRACT_MARKER_VALUES, isCoveredJobType, MAX_EVENT_BYTES, runtimeMatchesSupported, successRefusalReason, verificationVerdictFromFacts, } from "./completion-contract.js";
+import { COMPLETION_CAUSE_ERROR_KINDS, EOF_DRAIN_BOUND_MS, STDIN_CLOSE_GRACE_MS, finalizationFacts, finalizationObligations, planCompletionAllowance, readCompletionBinding, readDeclaredChecks, readOptionalWatchers, readRequiredVerification, renderApprovedVerificationGuidance, } from "./completion-supervision.js";
 import { compareFinalArtifact, createRequiredVerificationRunner, createSupervisedCommandLauncher, observeFinalArtifact, OWNERSHIP_POLL_MS, preCheckArtifactState, toCompletionCheckFact, } from "./required-verification.js";
 import { createClosureSupervisor, createRequiredWorkLedger } from "./required-work-ledger.js";
 import { buildCleanupVerdict, CLEANUP_RESIDUALS_NOT_COVERED, createDefaultOwnershipRecordFs, createDescendantTracker, createMacProcessInspector, createOwnershipToken, hostIdentityDigest, ownershipTokenDigest, removeOwnershipRecord, runOwnedProcessSweep, withOwnershipTag, writeOwnershipRecord, } from "./process-containment.js";
@@ -51,6 +53,8 @@ import { buildGenericSuccessResult, CI_FIX_CLAIMS_STATUS_KEY, readCiFixResultArt
 import { sendTerminalMutationWithRetry } from "./terminal-mutation.js";
 import { removeStaleVerdictArtifacts } from "./stale-artifacts.js";
 import { stripWorkerEnvFiles } from "./env-file-guard.js";
+import { formatWorkerDatabaseDropFailedLine, formatWorkerDatabaseUnavailableLine, } from "./worker-database.js";
+import { formatWorkerCliLauncherUnavailableLine } from "./worker-cli-launcher.js";
 import { isVerdictJobType, readVerdictArtifact } from "./verdict-artifact.js";
 import { createWorkerLogClaimId, createWorkerLogTee, closeWorkerLogTee, distinctWorkerLogSessionIds, formatWorkerLogSessionInvariantWarning, teeAsyncIterable, } from "./worker-log.js";
 import { acquireExecutorWorktreeLock, } from "./worktree-lock.js";
@@ -61,12 +65,14 @@ import { cleanupInterruptedWorktree } from "./interrupted-worktree.js";
 import { lazyProviderCheckPoller, runReconcileOverlapJob, } from "./reconcile-overlap-job.js";
 import { resolveExecutorJobBaseBranch } from "./base-branch.js";
 import { resolveExecutorJobIndexScope } from "./index-scope.js";
-import { readFocusedPullRequest, validateWorkerFinalization } from "./worker-finalization.js";
+import { deliveryHoldOf, readFocusedPullRequest, resolveOriginBranchSha, validateWorkerFinalization, } from "./worker-finalization.js";
+import { DELIVERY_OUTCOME_READ_TIMEOUT_MS, fetchServerDeliveryOutcome, } from "./delivery-outcome.js";
 import { FOCUSED_REBASE_JOB_TYPE, focusedRebaseContextError, hasFocusedRebaseContext, validateFocusedRebaseContext, waitForFocusedRebase, } from "./rebase-finalization.js";
 import { ensureExecutorWorktree, finalizeRetainedExecutorWorktree, } from "./worktree.js";
-import { CI_FIX_JOB_TYPE, resolveExecutorPrompt, resolveWorkerPermissionPosture, } from "./worker-command.js";
+import { CI_FIX_JOB_TYPE, renderCiFixOperatorNote, resolveExecutorPrompt, resolveWorkerPermissionPosture, } from "./worker-command.js";
 import { CORRECTION_INTENT_CAPABILITY, isRemainingWork, validateCorrectionIntent, } from "./correction-dispatch.js";
 import { collectGitTelemetry, collectRemoteTrackingSha, createMcpSurfaceObserver, evaluatePreSpawnGitVerification, formatWorkerRateLimitAdvisory, normalizeMcpServerNames, } from "./observation.js";
+import { failureReasonCode, isFailureReasonCode } from "./failure-reason-codes.js";
 import { readCustomizedCommands, TERMINAL_CAPACITY_PROTOCOL_VERSIONS, TERMINAL_CAPACITY_RUNTIME_CONTRACTS, TERMINAL_CAPACITY_RUNTIMES, } from "./types.js";
 import { resolvePackagedRecipes } from "./packaged-recipe.js";
 import { probeInstalledCorrectionHook } from "./preflight.js";
@@ -90,6 +96,71 @@ const ENV_FILE_TRACKED_LOOKUP_TIMEOUT_MS = 5_000;
 const ENV_FILE_TRACKED_LOOKUP_FAILED_MESSAGE = "[executor] tracked env-file lookup unavailable; exempting nothing";
 /** Default runtime for the no-op smoke process (ms). */
 const DEFAULT_SMOKE_DURATION_MS = 100;
+/**
+ * BAPI-1426: implementation-style job types that never read a delivery outcome.
+ * `reconcile_overlap`'s push is the wrapper's own, not a ticket delivery attempt.
+ * BAPI-1516: `ci_fix` is excluded too. A repair is judged by its own completion
+ * contract (a provider-observed push plus dispatched-check claims), not by ticket
+ * delivery readiness. An older server still guards `ci_fix`; the executor then
+ * reports success and that server's refusal parks the ticket as before, which the
+ * reconciler's green-head lane recovers once the PR head is green.
+ */
+const DELIVERY_OUTCOME_EXCLUDED_JOB_TYPES = new Set([
+    "reconcile_overlap",
+    "ci_fix",
+]);
+/** BAPI-1426: the outcome used when the read could not run or failed. */
+const DELIVERY_OUTCOME_UNAVAILABLE = { bound: "unknown", unavailable: true };
+/**
+ * BAPI-1426: read the server-confirmed delivery outcome for a finalizing
+ * implementation-style job. Returns undefined (no read at all) for a job with no
+ * ticket or branch, and for the excluded job types above. Bounded by
+ * `remainingMs`; never throws.
+ */
+async function readDeliveryOutcomeForFinalization(params) {
+    const { job, branch, deps, seams } = params;
+    const env = params.resolvedBaseUrl !== undefined && params.resolvedBaseUrl.trim() !== ""
+        ? { ...deps.env, BAPI_BASE_URL: params.resolvedBaseUrl }
+        : deps.env;
+    if (!isImplementationStyleJobType(job.job_type) || DELIVERY_OUTCOME_EXCLUDED_JOB_TYPES.has(job.job_type)) {
+        return undefined;
+    }
+    const trimmedBranch = typeof branch === "string" ? branch.trim() : "";
+    if (!trimmedBranch || !job.ticket_key)
+        return undefined;
+    const budgetMs = Math.min(DELIVERY_OUTCOME_READ_TIMEOUT_MS, params.remainingMs());
+    if (budgetMs <= 0)
+        return DELIVERY_OUTCOME_UNAVAILABLE;
+    try {
+        if (seams.fetchDeliveryOutcome)
+            return await seams.fetchDeliveryOutcome(job, trimmedBranch);
+        return await fetchServerDeliveryOutcome(job, trimmedBranch, {
+            fetch: deps.fetch,
+            accessDeps: {
+                env,
+                cwd: deps.cwd,
+                homedir: deps.homedir,
+                platform: deps.platform,
+                readFile: deps.readFile,
+                stat: deps.stat,
+            },
+            timeoutMs: budgetMs,
+            setTimer: deps.setTimer,
+            clearTimer: deps.clearTimer,
+        });
+    }
+    catch {
+        return DELIVERY_OUTCOME_UNAVAILABLE;
+    }
+}
+/**
+ * BAPI-1426: a finalization failure may carry its own telemetry (the delivery
+ * hold marker). It is merged over the observation snapshot instead of being
+ * replaced by it; a failure without telemetry keeps the snapshot unchanged.
+ */
+function withFailureTelemetry(snapshot, failureTelemetry) {
+    return failureTelemetry ? { ...snapshot, ...failureTelemetry } : snapshot;
+}
 /** ProcessClassification maps 1:1 onto the wire ExecutorClassification. */
 function toWireClassification(c) {
     return c;
@@ -507,6 +578,7 @@ export async function defaultRunMergeForClaimed(job, deps, options, controls) {
                 error_kind: MERGE_RETRYABLE,
                 error_message: accessResult.error,
                 classification: "crashed",
+                telemetry: { failure_reason_code: MERGE_ACCESS_UNAVAILABLE },
             },
         };
     }
@@ -514,12 +586,19 @@ export async function defaultRunMergeForClaimed(job, deps, options, controls) {
         access: accessResult.access,
         // Thread the overall-timeout abort signal into local merge deps WITHOUT
         // changing the local `gh` credential model (the signal is not a credential).
-        localMergeDeps: buildDefaultMergeLocalDeps(deps, controls?.signal),
+        // BAPI-1453: the same signal bounds the post-`gh_pr_view_failed` permission
+        // probe, so it can never outlive the merge flow's own timeout.
+        // BAPI-1461: resolved when the job runs, with the stored-entry fallback for
+        // an executor started in the person's own session. A durable-host service
+        // executor declared itself with --scrub-inherited-github-credentials and
+        // never reads a stored GitHub credential.
+        localMergeDeps: await buildMergeLocalDepsForJob(job, deps, { allowStoredEntry: options.scrubInheritedGithubCredentials !== true }, controls?.signal),
         // BAPI-951: the executor's own configured base — resolveExecutorJobBaseBranch
         // (called inside runExecutorMergeJob) resolves the CHILD PR's base from the
         // job's persisted run base, falling back to this value for a legacy job.
         repositoryBaseBranch: options.baseBranch,
         epicIntegrationAdvisoryLog: deps.errorLog,
+        diagnosticLog: deps.errorLog,
         cwd: deps.cwd,
     });
 }
@@ -1205,7 +1284,7 @@ async function runMergeJob(job, httpClient, options, deps, ownership, observatio
                 error_kind: MERGE_RETRYABLE,
                 error_message: `merge flow timed out after ${timeoutSeconds} seconds`,
                 classification: "timeout",
-                telemetry: observation.snapshot(),
+                telemetry: { failure_reason_code: MERGE_FLOW_TIMEOUT, ...observation.snapshot() },
             }),
             deps,
             options,
@@ -1223,7 +1302,7 @@ async function runMergeJob(job, httpClient, options, deps, ownership, observatio
                 error_kind: MERGE_FAILED,
                 error_message: secretFreeErrorMessage(flowError),
                 classification: "crashed",
-                telemetry: observation.snapshot(),
+                telemetry: { failure_reason_code: MERGE_FLOW_ERROR, ...observation.snapshot() },
             }),
             deps,
             options,
@@ -1242,7 +1321,7 @@ async function runMergeJob(job, httpClient, options, deps, ownership, observatio
                 error_kind: MERGE_FAILED,
                 error_message: "merge flow completed without an outcome",
                 classification: "crashed",
-                telemetry: observation.snapshot(),
+                telemetry: { failure_reason_code: MERGE_NO_OUTCOME, ...observation.snapshot() },
             }),
             deps,
             options,
@@ -1271,7 +1350,13 @@ async function runMergeJob(job, httpClient, options, deps, ownership, observatio
     }
     const terminal = await sendTerminalMutationWithAuthReport({
         kind: "fail",
-        send: () => httpClient.fail(job, { ...outcome.failure, telemetry: observation.snapshot() }),
+        // BAPI-1453: MERGE the builder's telemetry with the snapshot rather than
+        // replacing it, so `failure_reason_code` survives. Observation state never
+        // carries a code, so the snapshot cannot overwrite it.
+        send: () => httpClient.fail(job, {
+            ...outcome.failure,
+            telemetry: { ...outcome.failure.telemetry, ...observation.snapshot() },
+        }),
         deps,
         options,
         ownership,
@@ -1519,13 +1604,68 @@ function resolveStaleBranchClassification(payload) {
         return "unknown";
     return raw.trim() === PR_NOT_ATTACHED_REASON_CODE ? "succeeded_pr_not_attached" : "unknown";
 }
-/** The `/fail` payload for a failed worktree preparation. */
+/**
+ * BAPI-1530: structured worktree outcomes the executor reports as the named,
+ * deterministic `WorktreeSetupRefused`. A fetch, ref-resolution, or unclassified
+ * failure (`unavailable` or no kind at all) keeps `WorktreeError` so the server's
+ * legacy crash and transient handling is unchanged.
+ */
+const SETUP_REFUSAL_KINDS = new Set([
+    "stale_branch",
+    "lineage_refused",
+    "setup_refused",
+]);
+/**
+ * Display-only reason codes. They are set from structured outcomes only and read
+ * by no disposition decision; a deliberate refusal with no accurate display
+ * category (lock, authority, occupied destination) carries none.
+ */
+function worktreeDisplayReasonCode(kind) {
+    switch (kind) {
+        case "stale_branch":
+            return failureReasonCode("worktree_stale_branch");
+        case "lineage_refused":
+            return failureReasonCode("worktree_lineage_refused");
+        case "unavailable":
+            return failureReasonCode("worktree_fetch_failed");
+        default:
+            return undefined;
+    }
+}
+/**
+ * The `/fail` payload for a failed worktree preparation. The message is redacted
+ * and bounded here, before it reaches the server or a log line, so raw Worktrunk
+ * stderr never crosses the boundary. A named failure that already carries its own
+ * secret-free message is returned as it is.
+ */
 function jobWorktreeFailure(wt) {
-    return (wt.failure ?? {
-        error_kind: "WorktreeError",
-        error_message: wt.error,
+    if (wt.failure)
+        return wt.failure;
+    const refused = wt.failureKind !== undefined && SETUP_REFUSAL_KINDS.has(wt.failureKind);
+    const displayCode = worktreeDisplayReasonCode(wt.failureKind);
+    return {
+        error_kind: refused ? WorktreeSetupRefused : "WorktreeError",
+        error_message: secretFreeWorktreeMessage(wt.error),
         classification: "crashed",
-    });
+        ...(displayCode ? { telemetry: { failure_reason_code: displayCode } } : {}),
+    };
+}
+/** The payload key the reconciler stamps with a fenced child's resume head (BAPI-1530). */
+const FENCED_RESUME_HEAD_KEY = "fenced_implement_resume_head_sha";
+/**
+ * BAPI-1530: the SERVER-AUTHORED resume head from the job payload, or `null`.
+ * Absent, malformed, or non-SHA values degrade to the ordinary guarded
+ * fresh-dispatch path: absence proves nothing about the server's version and
+ * triggers no renaming.
+ */
+function readFencedResumeHead(payload) {
+    if (!payload || typeof payload !== "object")
+        return null;
+    const raw = payload[FENCED_RESUME_HEAD_KEY];
+    if (typeof raw !== "string")
+        return null;
+    const head = raw.trim().toLowerCase();
+    return /^[0-9a-f]{40}$/.test(head) ? head : null;
 }
 /**
  * Prepare a job's worktree. A job the server dispatched as a parked-child
@@ -1775,6 +1915,9 @@ async function prepareSpawn(job, httpClient, options, deps, seams, preparation)
         // `implement` retry acts on it; `ensureExecutorWorktree` re-checks that.
         // Spread only when present so an ordinary job keeps its exact legacy policy.
         ...(job.prior_attempt_head_sha ? { priorAttemptHeadSha: job.prior_attempt_head_sha } : {}),
+        // BAPI-1530: forwarded separately from the claim's prior-attempt head so
+        // same-row retry preservation keeps its own semantics.
+        ...(readFencedResumeHead(job.payload) ? { fencedImplementResumeHeadSha: readFencedResumeHead(job.payload) } : {}),
     });
     if (!wt.ok) {
         await httpClient.fail(job, jobWorktreeFailure(wt));
@@ -1971,9 +2114,11 @@ async function renderVerifiedCiFixPrompt(params) {
             workBranch: branch,
             baseBranch,
             runCommand: deps.runCommand,
-            comparisonSha: ciFix.headSha,
+            comparisonSha: ciFix.failingHeadSha ?? ciFix.headSha,
+            timeoutSeconds: params.timeoutSeconds,
+            deferComparisonGuidance: true,
         });
-        return { ok: true, prompt };
+        return { ok: true, prompt: prompt + ciFixProvenanceGuidance(ciFix) + renderCiFixOperatorNote(job.payload) };
     }
     catch (err) {
         return {
@@ -1982,8 +2127,57 @@ async function renderVerifiedCiFixPrompt(params) {
         };
     }
 }
+/**
+ * BAPI-1514: the provenance line for a focused ci_fix prompt. It separates the
+ * ORIGINAL failing head (`failingHeadSha`) from the head the supplied evidence
+ * describes (`evidenceHeadSha` on a refreshed payload, else the legacy anchor),
+ * and never calls the evidence stale when it describes the start head itself.
+ */
+function ciFixProvenanceGuidance(ciFix) {
+    const original = ciFix.failingHeadSha;
+    if (ciFix.evidenceHeadSha) {
+        const evidence = ciFix.evidenceHeadSha;
+        if (!original || original === evidence) {
+            return "\n\nSupplied CI logs and snapshots describe the evidence head " + evidence +
+                ", the head this repair was dispatched against. Re-verify the affected behavior at the execution head.";
+        }
+        return "\n\nOriginal failing head " + original + "; evidence head " + evidence +
+            "; the supplied CI logs and snapshots describe the evidence head, the head this repair was dispatched against." +
+            " Inspect the diff from the original failing head for context and re-verify the affected behavior at the execution head.";
+    }
+    if (!original)
+        return "";
+    if (original === ciFix.headSha) {
+        return "\n\nSupplied CI logs and snapshots describe the failing head " + original +
+            ", the head this repair was dispatched against. Re-verify the affected behavior at the execution head.";
+    }
+    return "\n\nSupplied CI logs and snapshots describe the failing head " + original +
+        " and may predate this pushed checkout. Inspect the diff from that anchor and re-verify the affected behavior at the execution head.";
+}
 /** BAPI-1311: cap on any one focused finalization read, before the deadline clamp. */
 const FOCUSED_FINALIZATION_READ_MAX_MS = 120_000;
+/** BAPI-1473: bound on the pre-launch origin-tip read for a focused rebase. */
+const FOCUSED_REBASE_START_TIP_READ_MAX_MS = 30_000;
+/**
+ * BAPI-1473: the work branch's authoritative origin tip just before a focused
+ * rebase worker launches, as a full lower-case SHA, or null when it cannot be
+ * established. Never throws; null keeps the existing post-push wait.
+ */
+async function readFocusedRebaseStartTip(deps, worktreePath, branch, remainingMs) {
+    const timeoutMs = Math.min(FOCUSED_REBASE_START_TIP_READ_MAX_MS, remainingMs());
+    if (timeoutMs <= 0)
+        return null;
+    try {
+        const lookup = await resolveOriginBranchSha(deps.runCommand, worktreePath, branch, { timeoutMs });
+        if (lookup.state !== "found")
+            return null;
+        const sha = lookup.sha.trim().toLowerCase();
+        return /^[0-9a-f]{40}$/.test(sha) ? sha : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * BAPI-1311 — run the focused rebase's post-push wait and, unless it is `ready`,
  * report the job's ONE terminal outcome.
@@ -2057,6 +2251,7 @@ async function superviseFocusedRebaseWait(params) {
             expectedBaseBranch: params.expectedBaseBranch,
             readPullRequest: (timeoutMs) => readFocusedPullRequest(deps.runCommand, params.worktreePath, params.context.prNumber, { timeoutMs }),
             pollChecks,
+            ...(params.readDelivery ? { readDelivery: params.readDelivery } : {}),
             now: deps.now,
             sleep: deps.sleep,
             signal,
@@ -2135,6 +2330,20 @@ async function superviseFocusedRebaseWait(params) {
  * returns BEFORE either the deny layer or MCP provisioning runs — neither ever
  * touches a worktree that will not become a runnable worker.
  */
+/**
+ * BAPI-1453 — the single executor log line for a pre-spawn refusal: the job id,
+ * the closed reason, and the bounded dirty-path evidence from the observation
+ * snapshot. Paths are already repository-relative, length-bounded,
+ * control-escaped, and redaction-checked by `parseDirtyPathEvidence`, and are
+ * JSON-quoted here so the line stays one line.
+ */
+export function formatPreSpawnRefusalLine(job, reason, telemetry) {
+    const code = isFailureReasonCode(reason) ? reason : "unknown";
+    const paths = Array.isArray(telemetry.dirty_paths) ? telemetry.dirty_paths : [];
+    const overflow = typeof telemetry.dirty_paths_overflow_count === "number" ? telemetry.dirty_paths_overflow_count : 0;
+    return (`pre-spawn verification refused job_id=${job.id} reason=${code} ` +
+        `dirty_paths=${JSON.stringify(paths)} dirty_paths_overflow_count=${overflow}`);
+}
 /** Reserve the branch before Worktrunk can mutate it; lock an existing tree before preparation. */
 async function runSpawnJob(job, httpClient, options, deps, ownership, observation, seams, control, driver) {
     const originalHttp = httpClient;
@@ -2221,20 +2430,37 @@ async function runSpawnJob(job, httpClient, options, deps, ownership, observatio
         }
     };
     try {
-        return await runReservedSpawnJob(job, httpClient, options, deps, ownership, observation, seams, control, driver, undefined, undefined, reserve);
+        return await runReservedSpawnJob(job, httpClient, options, deps, ownership, observation, seams, control, driver, undefined, undefined, reserve, timeout.timeoutSeconds);
     }
     finally {
         await retainedLock?.release();
         await reservation?.release();
     }
 }
+/**
+ * The filesystem boundary for exclude provisioning, built from the runner's
+ * injected deps. A deps builder that omits the optional `rename`/`removeFile`
+ * seams gets the real operation, matching the worktree-lock fallback direction.
+ */
+function excludeProvisioningDeps(deps) {
+    return {
+        readFile: deps.readFile,
+        writeFile: deps.writeFile,
+        mkdir: deps.mkdir,
+        stat: deps.stat ?? ((filePath) => fsStat(filePath)),
+        rename: deps.rename ?? ((from, to) => fsRename(from, to)),
+        removeFile: deps.removeFile ?? ((filePath) => rm(filePath, { force: true })),
+    };
+}
 async function runReservedSpawnJob(job, httpClient, options, deps, ownership, observation, seams, control, 
 /**
  * BAPI-1152: an optional spawn-job driver (`reconcile_overlap`). It runs inside
  * the SAME lock and the SAME prepared-spawn path as every other spawn job, so it
  * adds no second worktree entry and no second worker launcher.
  */
-driver, retainedLock, preparation, reserve) {
+driver, retainedLock, preparation, reserve, 
+/** Successful total budget resolved before preparation, never remaining time. */
+resolvedTimeoutSeconds) {
     // A server-owned read precedes every worktree reset/cut and worker launch.
     // Only this boundary can authorize a no-charge pre-work wait; a later plan
     // retrieval failure is ordinary bounded worker failure.
@@ -2290,9 +2516,7 @@ driver, retainedLock, preparation, reserve) {
             claude: {
                 readFile: deps.readFile,
                 denyProvisioningDeps: {
-                    readFile: deps.readFile,
-                    writeFile: deps.writeFile,
-                    mkdir: deps.mkdir,
+                    ...excludeProvisioningDeps(deps),
                     homedir: deps.homedir,
                 },
             },
@@ -2377,6 +2601,18 @@ driver, retainedLock, preparation, reserve) {
             return { status: "failed", reason: "focused_rebase_context" };
         }
     }
+    // BAPI-1451: provision the shared git exclude BEFORE any lock acquisition. The
+    // retained-worktree lock (inside `reserve()`) and the fresh-worktree lock both
+    // write `.conductor/` artifacts, and so do the recently-failed file and
+    // pre-spawn verification. The executor clone's common `info/exclude` covers
+    // both retained and newly prepared linked worktrees. A warning is logged and
+    // the job continues unchanged: no failure reason, alert, cleanup, or early
+    // return — dirty-worktree refusal stays with pre-spawn verification.
+    {
+        const provisioned = await (seams.provisionWorktreeSettingsExclude ?? provisionWorktreeSettingsExclude)(deps.cwd, excludeProvisioningDeps(deps));
+        if (provisioned.warning)
+            deps.errorLog(provisioned.warning);
+    }
     // Acquire ownership only after read-only admission and contract validation.
     if (reserve) {
         const held = await reserve();
@@ -2505,6 +2741,7 @@ driver, retainedLock, preparation, reserve) {
             const rendered = await renderVerifiedCiFixPrompt({
                 job,
                 ciFix: prep.ciFix,
+                timeoutSeconds: resolvedTimeoutSeconds,
                 publication: prep.publication, preparation,
                 worktreePath,
                 branch,
@@ -2521,7 +2758,7 @@ driver, retainedLock, preparation, reserve) {
             readyPrep = { ...prep, prompt: rendered.prompt };
         }
         if (["implement", "resume", "remediate", "rebase", "ci_fix"].includes(job.job_type)) {
-            readyPrep = { ...readyPrep, comparisonSha: prep.ciFix?.headSha ??
+            readyPrep = { ...readyPrep, comparisonSha: prep.ciFix?.failingHeadSha ?? prep.ciFix?.headSha ??
                     await captureComparisonSha(worktreePath, deps) };
             if (!prep.ciFix && isRemainingWork(job.job_type, job.payload)) {
                 if (job.job_type === "resume" || prep.priorWork) {
@@ -2568,6 +2805,9 @@ driver, retainedLock, preparation, reserve) {
             });
             return { status: "failed", reason: "stale_artifact_cleanup" };
         }
+        // `.conductor/` is excluded through the executor-provisioned common
+        // `info/exclude` (see the spawn-entry provisioning above), independently of
+        // any repository `.gitignore`.
         try {
             await (seams.writeRecentlyFailedTestsFile ?? writeRecentlyFailedTestsFile)(worktreePath, job.payload?.recently_failed_tests);
         }
@@ -2615,10 +2855,167 @@ driver, retainedLock, preparation, reserve) {
         //      touching it, and the two steps above are what establish that it cannot.
         spawnLifecycle.deregisterLiveWorker?.();
         spawnLifecycle.deregisterLiveWorker = undefined;
+        // BAPI-1479 — the job database and launcher go AFTER the worker is
+        // contained (supervision has settled by now) and BEFORE the worktree lock is
+        // released. A drop failure is one bounded, non-fatal line on the executor's
+        // stderr; it never changes the job's result.
+        await spawnLifecycle.releaseWorkerResources?.().catch(() => undefined);
         await spawnLifecycle.closeWorkerLog?.();
         await worktreeLock.release();
     }
 }
+/**
+ * BAPI-1479: the job types whose worker gets a disposable database and the
+ * own-build launcher — the PR-producing worker jobs, which are the ones that run
+ * the repository's tests. Verdict-only and driver-owned jobs keep the sentinel.
+ */
+const WORKER_RESOURCE_JOB_TYPES = new Set([
+    "implement", "resume", "remediate", "ci_fix", "rebase",
+]);
+/**
+ * BAPI-1479 — provision the job's disposable database and own-build launcher
+ * before the worker's spawn shape is built.
+ *
+ * Runs under the SAME heartbeat, server-stop, and timeout supervision as a
+ * driver phase, and an executor shutdown aborts it through the live-worker
+ * registry (which is sticky, so a shutdown that already started still reaches
+ * it). It never stops a job for a missing prerequisite: an unavailable database
+ * or launcher logs ONE bounded non-fatal line and the worker spawns with the
+ * sentinel database and the inherited `PATH`, exactly as before. Only the
+ * existing interruptions end the job here — lease loss, a server stop, or the job
+ * timeout — and they report through the existing outcomes, never a new code.
+ *
+ * Whatever was created is registered on `lifecycle.releaseWorkerResources` the
+ * moment it exists, so `runSpawnJob`'s `finally` drops it on every exit path.
+ */
+async function prepareWorkerResources(params) {
+    const { job, deps, lifecycle } = params;
+    const jobId = String(job.id);
+    const resources = deps.workerResources;
+    if (!resources)
+        return { kind: "ready" };
+    let target;
+    let disposeLauncher;
+    let launcherDirectory;
+    let released = false;
+    lifecycle.releaseWorkerResources = async () => {
+        if (released)
+            return;
+        released = true;
+        if (target) {
+            const dropped = await resources.dropDatabase(target).catch(() => ({ kind: "failed" }));
+            if (dropped.kind !== "dropped") {
+                try {
+                    deps.errorLog(formatWorkerDatabaseDropFailedLine(jobId, target.name));
+                }
+                catch { /* sink */ }
+            }
+        }
+        if (disposeLauncher)
+            await disposeLauncher().catch(() => undefined);
+    };
+    // An executor shutdown aborts provisioning the same way it terminates a worker.
+    const shutdown = new AbortController();
+    const deregister = params.control?.liveWorkers.register({
+        requestTermination: () => shutdown.abort(),
+    });
+    let phase;
+    try {
+        phase = await superviseDriverPhase({
+            job,
+            httpClient: params.httpClient,
+            options: params.options,
+            deps,
+            ownership: params.ownership,
+            observation: params.observation,
+            control: params.control,
+            timeoutSeconds: Math.max(1, Math.ceil(params.remainingMs() / 1000)),
+            collectTelemetry: params.collectTelemetry,
+            run: async (signal) => {
+                // Combined by hand: `AbortSignal.any` is not available on Node 18.
+                const combined = new AbortController();
+                const abortCombined = () => combined.abort();
+                if (signal.aborted || shutdown.signal.aborted)
+                    combined.abort();
+                signal.addEventListener("abort", abortCombined, { once: true });
+                shutdown.signal.addEventListener("abort", abortCombined, { once: true });
+                const cancel = combined.signal;
+                const provisioned = await resources
+                    .provisionDatabase({ jobId, worktreePath: params.worktreePath, signal: cancel })
+                    .catch(() => ({ kind: "unavailable", category: "create_failed" }));
+                if (provisioned.kind === "provisioned") {
+                    target = provisioned.target;
+                }
+                else {
+                    try {
+                        deps.errorLog(formatWorkerDatabaseUnavailableLine(jobId, provisioned.category));
+                        // A created database whose rollback failed stays for the host operator.
+                        if ("retainedName" in provisioned && provisioned.retainedName) {
+                            deps.errorLog(formatWorkerDatabaseDropFailedLine(jobId, provisioned.retainedName));
+                        }
+                    }
+                    catch { /* sink */ }
+                }
+                if (cancel.aborted)
+                    return;
+                const launcher = await resources
+                    .createLauncher({ jobId })
+                    .catch(() => ({ kind: "unavailable", reason: "wrapper_unverified" }));
+                if (launcher.kind === "available") {
+                    disposeLauncher = launcher.dispose;
+                    if (!released)
+                        launcherDirectory = launcher.directory;
+                    else
+                        await launcher.dispose().catch(() => undefined);
+                }
+                else {
+                    try {
+                        deps.errorLog(formatWorkerCliLauncherUnavailableLine(jobId, launcher.reason));
+                    }
+                    catch { /* sink */ }
+                }
+            },
+        });
+    }
+    finally {
+        deregister?.();
+    }
+    if (phase.kind === "abandoned") {
+        return { kind: "interrupted", result: { status: "abandoned", reason: params.ownership.abandonReason } };
+    }
+    if (phase.kind === "server_stop") {
+        await params.httpClient.fail(job, {
+            error_kind: "ServerStopRequested",
+            error_message: "the server requested this run stop before the worker started",
+            classification: "killed",
+            telemetry: params.observation.snapshot(),
+        });
+        params.ownership.abandoned = true;
+        params.ownership.abandonReason = "server_stop";
+        return { kind: "interrupted", result: { status: "abandoned", reason: "server_stop" } };
+    }
+    if (phase.kind === "timeout") {
+        await params.httpClient.fail(job, {
+            error_kind: "Timeout",
+            error_message: `${job.job_type} exceeded the job timeout before the worker started`,
+            classification: "timeout",
+            telemetry: params.observation.snapshot(),
+        });
+        return { kind: "interrupted", result: { status: "failed", reason: "timeout" } };
+    }
+    // An executor shutdown during provisioning: spawn nothing new with a
+    // half-prepared target. The sticky registry terminates the worker on
+    // registration anyway, so continuing with the sentinel keeps the existing
+    // shutdown semantics while the database (if any) is dropped by the `finally`.
+    if (shutdown.signal.aborted)
+        return { kind: "ready" };
+    // `kind: "error"` is an unexpected throw from the seam itself: degrade.
+    return {
+        kind: "ready",
+        ...(target ? { workerDatabase: target } : {}),
+        ...(launcherDirectory ? { workerLauncherDirectory: launcherDirectory } : {}),
+    };
+}
 function retainedHeadPublisher(params) {
     return async () => {
         const { job, branch, worktreePath, prep, deps, ownership, observation, remainingMs } = params;
@@ -2700,7 +3097,8 @@ async function runPreparedSpawn(params) {
     // an envelope, rather than run under the legacy contract that the server
     // would then refuse to accept.
     const covered = claimIsCovered(job);
-    if (covered && (!isCoveredJobType(job.job_type) || driver)) {
+    const policyRebase = job.job_type === "rebase" && job.required_capabilities?.includes("required_verification.ci_deferral.v2");
+    if (covered && ((!isCoveredJobType(job.job_type) && !policyRebase) || driver)) {
         return await refuseCoveredClaimBeforeLaunch({
             job, httpClient, options, deps, ownership, observation, control,
             runtime: unrecognizedRuntime(adapter),
@@ -2797,6 +3195,15 @@ async function runPreparedSpawn(params) {
     if (job.job_type === "implement" && !isRemainingWork(job.job_type, job.payload)) {
         prompt += "\n\n" + renderWorkerVerificationGuidance(prep.comparisonSha);
     }
+    // The locked ci_fix renderer deferred trusted guidance. All existing prompt
+    // additions precede comparison guidance and the final total-budget block.
+    if (prep.ciFix) {
+        prompt += "\n\n" + renderWorkerVerificationGuidance(prep.comparisonSha) +
+            "\n\n" + renderWorkerTimeBudgetGuidance(timeout.timeoutSeconds);
+    }
+    const approvedVerificationGuidance = renderApprovedVerificationGuidance(job.payload);
+    if (approvedVerificationGuidance)
+        prompt += "\n\n" + approvedVerificationGuidance;
     // --- Pre-spawn git verification (FAIL-CLOSED, BAPI-731 WS-E) ---------
     // FIRST of the pre-spawn contracts, and deliberately BEFORE every
     // executor-owned write to the worktree (deny layer, MCP provisioning, worker
@@ -2809,7 +3216,9 @@ async function runPreparedSpawn(params) {
     // failing check. It does NOT replace or weaken the existing hard-reset /
     // untracked-clean / head-verify behavior in `worktree-core.ts`; it is an
     // additional independent check on top of them.
-    const preSpawnTelemetry = await collectGitTelemetry({ runCommand: deps.runCommand, now: deps.now }, worktreePath, effectiveBaseBranch);
+    const preSpawnTelemetry = await collectGitTelemetry({ runCommand: deps.runCommand, now: deps.now }, worktreePath, effectiveBaseBranch, 
+    // BAPI-1453: a refusal must name the files it found.
+    { includeDirtyPaths: true });
     // BAPI-1152: a driver proves its own pre-spawn state (a reconciliation worker
     // may start inside an in-progress merge, which the generic "clean at the
     // prepared commit" check would refuse by design).
@@ -2827,12 +3236,28 @@ async function runPreparedSpawn(params) {
             observation.setAttemptEndSha(verification.observedSha);
         }
         observation.setGitTelemetry(preSpawnTelemetry);
+        // BAPI-1453: one executor log line naming the job, the reason, and the
+        // bounded dirty-path evidence. The paths come from the SAME observation
+        // snapshot the `/fail` body carries, never from a second copy, and never
+        // reach `error_message` (fixed strings and validated SHAs only).
+        const refusalTelemetry = observation.snapshot();
+        try {
+            deps.errorLog(formatPreSpawnRefusalLine(job, verification.reason, refusalTelemetry));
+        }
+        catch {
+            /* supplemental logging cannot change the refusal */
+        }
         await httpClient.fail(job, {
             error_kind: PreSpawnVerification,
             error_message: verification.message,
             classification: "crashed",
             ...commitResidue(preSpawnTelemetry),
-            telemetry: observation.snapshot(),
+            // Builder-owned code first; the spawn-path wrapper then layers the
+            // snapshot over it, so both survive.
+            telemetry: {
+                ...(isFailureReasonCode(verification.reason) ? { failure_reason_code: verification.reason } : {}),
+                ...refusalTelemetry,
+            },
         });
         return { status: "failed", reason: "pre_spawn_verification" };
     }
@@ -3141,6 +3566,29 @@ async function runPreparedSpawn(params) {
     // is denied at the env builder and cannot reach `spawnShape.env`. It stays out
     // of `argv` entirely: it is a routing declaration, not a command-line input,
     // and argv is world-readable via `ps`.
+    // --- Worker resources (BAPI-1479) --------------------------------------
+    // The job's disposable database and own-build launcher, prepared ONCE for this
+    // prepared job, before the one spawn shape both the covered and legacy launches
+    // use. A retry of the job is a fresh claim with a fresh execution, so it gets
+    // fresh resources; nothing is recovered from an earlier execution's state.
+    // Driver-owned jobs (their worker runs a server-rendered reconciliation) and
+    // verdict-only jobs keep the sentinel database.
+    let workerResources = {};
+    if (!driver && WORKER_RESOURCE_JOB_TYPES.has(job.job_type)) {
+        const prepared = await prepareWorkerResources({
+            job, httpClient, options: jobOptions, deps, ownership, observation, control,
+            worktreePath, remainingMs, lifecycle, collectTelemetry: driverTelemetry,
+        });
+        if (prepared.kind === "interrupted") {
+            await closeWorkerLog();
+            await finalizeRegistry();
+            return prepared.result;
+        }
+        workerResources = {
+            ...(prepared.workerDatabase ? { workerDatabase: prepared.workerDatabase } : {}),
+            ...(prepared.workerLauncherDirectory ? { workerLauncherDirectory: prepared.workerLauncherDirectory } : {}),
+        };
+    }
     const invocation = adapter.headlessInvocation;
     if (invocation?.supported !== true) {
         await closeWorkerLog();
@@ -3175,6 +3623,8 @@ async function runPreparedSpawn(params) {
             ...(driver?.omitWorkerBranch ? {} : { workerBranch: branch }),
             ...(correctionWork ? { correctionIntentVersion: 1 } : {}),
             ...(driverStep ? { declaredTouchedFiles: driverStep.declaredTouchedFiles } : {}),
+            // BAPI-1479 — explicit, executor-provisioned values; never read from `parentEnv`.
+            ...workerResources,
             parentEnv: deps.env,
         });
         assertUsableSpawnShape(spawnShape, adapter);
@@ -3309,6 +3759,15 @@ async function runPreparedSpawn(params) {
     // the covered attempt launch through it, so there is still exactly one place a
     // worker can be started, always from the verified spawn shape. Only a covered
     // attempt asks for a held stdin; the legacy options stay byte-identical.
+    // BAPI-1473: a focused rebase records the work branch's ORIGIN tip immediately
+    // before its worker launches. When finalization later proves the origin tip is
+    // still exactly this SHA, the worker pushed nothing (it only renewed evidence),
+    // so there is no post-push evidence to wait for. Read with the same
+    // authoritative `git ls-remote` finalization uses, never a local tracking ref
+    // and never `job.expected_head_sha`. Unknown (null) keeps the existing wait.
+    const focusedRebaseStartTip = prep.focusedRebase
+        ? await readFocusedRebaseStartTip(deps, worktreePath, branch, remainingMs)
+        : null;
     const spawnWorker = (spawnOptions) => deps.spawnProcess(spawnShape.executable, spawnShape.argv, {
         cwd: worktreePath,
         env: spawnOptions.env,
@@ -3342,11 +3801,29 @@ async function runPreparedSpawn(params) {
         if (!spawnShape.stdinMessages?.initial) {
             return await refuse("unsupported_runtime", "the executor adapter produced no held-stdin prompt message for a covered job");
         }
+        // BAPI-1504 — a job stamped with `cleanup_report.v1` is only safe to run on a
+        // client that can deliver the report; refusing here, before any worker exists,
+        // names the missing capability in the envelope instead of launching a job whose
+        // interruption could never be proven clean.
+        if (claimRequiresCleanupReport(job.required_capabilities) && typeof httpClient.reportCleanup !== "function") {
+            await closeWorkerLog();
+            await finalizeRegistry();
+            return await refuseCoveredClaimBeforeLaunch({
+                job, httpClient, options, deps, ownership, observation, control,
+                runtime, dispatchHeadSha, reason: "unsupported_runtime",
+                message: "this executor cannot deliver cleanup reports (cleanup_report.v1); update the executor",
+                missingCapabilities: ["cleanup_report"],
+            });
+        }
         // BAPI-1302 (D4c) — the server-stamped declaration is validated WHOLE,
         // before any allowance is reserved or a worker exists. A truncated,
         // malformed, unsupported or server-refused declaration never launches work
         // against a partial set of checks.
         const verificationRead = readRequiredVerification(job.payload);
+        if (verificationRead.kind === "ok" && verificationRead.declaration.policyVersion === 2 &&
+            !job.required_capabilities?.includes("required_verification.ci_deferral.v2")) {
+            return await refuse("declaration_refused", "CI-deferral capability was not negotiated; refusing to launch");
+        }
         if (verificationRead.kind === "refused") {
             deps.errorLog(`[executor] job ${job.id}: required-verification declaration refused (${verificationRead.reason})`);
             return await refuse("declaration_refused", "the job's required-verification declaration is unusable; refusing to launch");
@@ -3761,11 +4238,24 @@ async function runPreparedSpawn(params) {
         // its push never landed on origin and no PR was opened (e.g. it backgrounded
         // a slow push and returned early). Convert that into a fail-loud executor
         // failure rather than silently reporting success.
+        //
+        // BAPI-1426: a managed ticket's server-confirmed delivery outcome is read
+        // first, so an intentional held checkpoint finalizes as a `/fail` with its
+        // completion cause instead of a missing-PR failure or a success.
+        const deliveryOutcome = await readDeliveryOutcomeForFinalization({
+            job,
+            branch,
+            deps,
+            seams,
+            remainingMs,
+            resolvedBaseUrl: options.resolvedBaseUrl,
+        });
         const finalization = await validateWorkerFinalization({
             job,
             branch,
             worktreePath,
             result: genericResult,
+            ...(deliveryOutcome !== undefined ? { deliveryOutcome } : {}),
             publishRetainedHead: retainedHeadPublisher({ job, branch, worktreePath, prep, deps, ownership, observation, remainingMs, httpClient, options: jobOptions, control }),
             runCommand: deps.runCommand,
             headSha: git.last_commit_sha,
@@ -3791,7 +4281,7 @@ async function runPreparedSpawn(params) {
                     // finalization failure; it is never rewritten to look like a crash.
                     ...observedExitCode(procResult.exitCode),
                     ...commitResidue(git),
-                    telemetry: observation.snapshot(),
+                    telemetry: withFailureTelemetry(observation.snapshot(), finalization.failure.telemetry),
                 }),
                 deps,
                 options,
@@ -3808,11 +4298,38 @@ async function runPreparedSpawn(params) {
         // supervision a worker gets, bounded by the job's ORIGINAL absolute deadline.
         // It launches no worker, enqueues nothing, and resets nothing: a pending check
         // is waited on, never repaired again. Only `ready` reaches `/complete`, once.
-        if (prep.focusedRebase) {
+        //
+        // BAPI-1473: two narrower successful ends, both still submitting `/complete`
+        // exactly once below and leaving the server's completion contract and
+        // delivery guard as the authority:
+        // - NO PUSH: the verified origin tip equals the tip recorded before launch,
+        //   so the worker only renewed evidence. Skip the post-push wait.
+        // - DEFERRED CI: the wait itself ends `ready` while required checks are still
+        //   pending when the server's readiness at the pushed head shows renewed
+        //   evidence with only `remote_ci` deferrals (`readDelivery` below).
+        // Neither is merge behavior: the merge guard keeps the child in `merging`
+        // until readiness is `complete`, which needs green checks at the head.
+        const focusedRebasePushedNothing = prep.focusedRebase !== undefined &&
+            focusedRebaseStartTip !== null &&
+            typeof finalization.pushedHeadSha === "string" &&
+            finalization.pushedHeadSha.trim().toLowerCase() === focusedRebaseStartTip;
+        if (focusedRebasePushedNothing) {
+            deps.errorLog(`[executor] job ${job.id}: focused rebase pushed nothing (origin tip unchanged); ` +
+                "skipping the post-push wait and submitting completion once for the server to decide");
+        }
+        if (prep.focusedRebase && !focusedRebasePushedNothing) {
             const focusedTerminal = await superviseFocusedRebaseWait({
                 job, httpClient, options, jobOptions, deps, ownership, observation, seams, control,
                 context: prep.focusedRebase,
                 pushedHeadSha: finalization.pushedHeadSha ?? null,
+                readDelivery: () => readDeliveryOutcomeForFinalization({
+                    job,
+                    branch,
+                    deps,
+                    seams,
+                    remainingMs,
+                    resolvedBaseUrl: options.resolvedBaseUrl,
+                }),
                 expectedBaseBranch: effectiveBaseBranch,
                 worktreePath,
                 jobDeadlineMs,
@@ -4015,6 +4532,7 @@ export function unlaunchedVerification(read) {
     const facts = {
         provenance,
         declaration_digest: digest,
+        ...(read.kind === "ok" && read.declaration.policyVersion === 2 ? { deferred_obligation_identities: read.declaration.deferredIdentities ?? [] } : {}),
         tested_head_sha: null,
         artifact: "not_observed",
         commands: [],
@@ -4073,7 +4591,7 @@ async function refuseCoveredClaimBeforeLaunch(input) {
         finalization: "unknown",
         verification: unlaunched.verification,
         cleanup: buildCleanupVerdict("confirmed", 0, []),
-        missingCapabilities: [],
+        missingCapabilities: input.missingCapabilities ?? [],
         ...(unlaunched.facts ? { verificationFacts: unlaunched.facts } : {}),
     });
     const cause = envelope.cause ?? "required_work_incomplete";
@@ -4159,6 +4677,90 @@ async function runCoveredAttempt(params) {
         optionalWatchers: readOptionalWatchers(job.payload),
         obligations,
     });
+    // --- Ownership persisted BEFORE the spawn (BAPI-1504) ---------------------------
+    // A job stamped with `cleanup_report.v1` stores `NULL` ownership only if no worker
+    // was ever spawned, which lets the server read a null as proof of that. So the
+    // server must hold this attempt's ownership (token digest, `worker: null`) before
+    // the worker exists. The local record above was written first.
+    const requiresCleanupReport = claimRequiresCleanupReport(job.required_capabilities);
+    if (requiresCleanupReport) {
+        const abandonBeforeLaunch = async (result) => {
+            await closeWorkerLog();
+            await finalizeRegistry();
+            await removeOwnershipRecord(stateDir, job.id, recordFs).catch(() => undefined);
+            return result;
+        };
+        const notLaunched = async (message) => {
+            await closeWorkerLog();
+            await finalizeRegistry();
+            await removeOwnershipRecord(stateDir, job.id, recordFs).catch(() => undefined);
+            return await refuseCoveredClaimBeforeLaunch({
+                job, httpClient, options, deps, ownership, observation, control,
+                runtime: params.runtime, dispatchHeadSha: params.dispatchHeadSha,
+                reason: "not_launched", message,
+            });
+        };
+        const preSpawnContext = {
+            version: 1,
+            token_digest: tokenDigest,
+            host_digest: hostDigest,
+            worker: null,
+        };
+        // Transient failures retry only inside the existing dead-man window; the window
+        // is measured from the last successful beat and is never extended by a retry.
+        for (;;) {
+            let beat;
+            try {
+                beat = await sendImmediateHeartbeat({
+                    job,
+                    httpClient,
+                    deps,
+                    ownership,
+                    observation,
+                    collectTelemetry: () => collectGitTelemetry({ runCommand: deps.runCommand, now: deps.now }, worktreePath, effectiveBaseBranch),
+                    ownershipContext: preSpawnContext,
+                });
+            }
+            catch {
+                beat = { kind: "transient" };
+            }
+            if (beat.kind === "accepted")
+                break;
+            if (beat.kind === "stale_claim") {
+                return await abandonBeforeLaunch({ status: "abandoned", reason: "stale_claim" });
+            }
+            if (beat.kind === "server_stop") {
+                // Report first, then mark the claim abandoned, exactly as the post-spawn
+                // server-stop path does: an abandoned claim skips the terminal report.
+                const stopped = await notLaunched("the server requested this run stop before the worker launched");
+                ownership.abandoned = true;
+                ownership.abandonReason = "server_stop";
+                return stopped.status === "failed" ? { status: "abandoned", reason: "server_stop" } : stopped;
+            }
+            if (beat.kind === "auth_fatal") {
+                control?.reportAuthFatal?.({
+                    jobId: job.id,
+                    repoName: job.repo_name,
+                    category: "heartbeat",
+                    httpStatus: beat.httpStatus,
+                });
+                return await abandonBeforeLaunch({ status: "abandoned", reason: "auth_fatal" });
+            }
+            // transient
+            if (deps.now() - ownership.lastSuccessfulHeartbeatAt >= options.deadmanMs) {
+                return await notLaunched("ownership could not be recorded with the server before launch; not launching the worker");
+            }
+            await deps.sleep(Math.min(jobOptions.heartbeatIntervalMs, 5_000));
+        }
+        // The claim, the run, and the executor can all change while the beat was in
+        // flight; check once more immediately before the spawn.
+        if (ownership.abandoned) {
+            return await abandonBeforeLaunch({ status: "abandoned", reason: ownership.abandonReason });
+        }
+        if (control?.liveWorkers.isShutdownRequested() === true) {
+            return await notLaunched("the executor is shutting down; not launching the worker");
+        }
+    }
     // --- Spawn (held stdin) ---------------------------------------------------
     let proc;
     try {
@@ -4451,7 +5053,7 @@ async function runCoveredAttempt(params) {
             send: () => httpClient.fail(job, {
                 ...failure,
                 ...commitResidue(git),
-                telemetry: observation.snapshot(),
+                telemetry: withFailureTelemetry(observation.snapshot(), failure.telemetry),
                 completion_contract: SUPPORTED_COMPLETION_MARKER,
                 completion_evidence: envelope,
                 ...extra,
@@ -4467,6 +5069,53 @@ async function runCoveredAttempt(params) {
         // The terminal report is acknowledged (or ownership is gone): only now does
         // the job-level heartbeat end, and only now is the restart record retired.
         await endHeartbeat();
+        // BAPI-1504 — a lost claim after a CONFIRMED sweep: deliver the cleanup fact
+        // before the record can be removed. The first attempt is awaited (bounded by
+        // the HTTP client); a retained outcome continues in the background and the
+        // record stays until a terminal server answer.
+        if (requiresCleanupReport &&
+            claimIsCovered(job) &&
+            result.status === "abandoned" &&
+            (result.reason === "stale_claim" || result.reason === "deadman") &&
+            cleanup.verdict === "confirmed" &&
+            cleanup.survivors === 0) {
+            const first = await submitCleanupReport({
+                httpClient, jobId: job.id, repoName: job.repo_name, ownershipToken: token, path: "wake",
+            });
+            if (cleanupReportPermitsRecordRemoval(first)) {
+                await removeOwnershipRecord(stateDir, job.id, recordFs).catch(() => undefined);
+            }
+            else if (first.kind === "retained" && first.retryable) {
+                const retry = retryWakeCleanupReport({
+                    httpClient,
+                    jobId: job.id,
+                    repoName: job.repo_name,
+                    ownershipToken: token,
+                    firstResult: first,
+                    intervalMs: jobOptions.heartbeatIntervalMs,
+                    shouldStop: () => control?.liveWorkers.isShutdownRequested() === true,
+                    deps: {
+                        now: deps.now,
+                        sleep: deps.sleep,
+                        diagnostic: (d) => deps.errorLog(`[executor] ${d.event} job=${d.jobId}`),
+                    },
+                    onTerminal: () => removeOwnershipRecord(stateDir, job.id, recordFs).catch(() => undefined),
+                });
+                if (control?.trackBackground)
+                    control.trackBackground(retry);
+                else
+                    void retry;
+            }
+            // Any other retained outcome keeps the record for the next start.
+            return result;
+        }
+        // BAPI-1504 — an abandoned covered attempt whose sweep did NOT confirm keeps
+        // its record, so the next start can sweep again and report only then.
+        if (requiresCleanupReport &&
+            result.status === "abandoned" &&
+            (result.reason === "stale_claim" || result.reason === "deadman")) {
+            return result;
+        }
         await removeOwnershipRecord(stateDir, job.id, recordFs).catch(() => undefined);
         return result;
     };
@@ -4552,6 +5201,7 @@ async function runCoveredAttempt(params) {
         verificationFacts = {
             provenance: declaration.provenance,
             declaration_digest: declaration.digest,
+            ...(declaration.policyVersion === 2 ? { deferred_obligation_identities: declaration.deferredIdentities ?? [] } : {}),
             tested_head_sha: null,
             artifact: "not_observed",
             commands: [],
@@ -4631,6 +5281,7 @@ async function runCoveredAttempt(params) {
         verificationFacts = {
             provenance: "declared",
             declaration_digest: declaration.digest,
+            ...(declaration.policyVersion === 2 ? { deferred_obligation_identities: declaration.deferredIdentities ?? [] } : {}),
             tested_head_sha: before.head,
             artifact,
             commands: declaredOrderFacts(checks, runFacts).map(toCompletionCheckFact),
@@ -4657,11 +5308,22 @@ async function runCoveredAttempt(params) {
                 ? { ...ciResult.fields, ...executorResult, [CI_FIX_CLAIMS_STATUS_KEY]: ciResult.status }
                 : { ...executorResult, [CI_FIX_CLAIMS_STATUS_KEY]: ciResult.status };
     }
+    // BAPI-1426: the server-confirmed delivery outcome, read under the same
+    // absolute deadline as the finalization reads below.
+    const deliveryOutcome = await readDeliveryOutcomeForFinalization({
+        job,
+        branch,
+        deps,
+        seams,
+        remainingMs: () => Math.max(0, plan.deadlineAtMs - deps.now()),
+        resolvedBaseUrl: options.resolvedBaseUrl,
+    });
     const finalization = await validateWorkerFinalization({
         job,
         branch,
         worktreePath,
         result: genericResult,
+        ...(deliveryOutcome !== undefined ? { deliveryOutcome } : {}),
         publishRetainedHead: retainedHeadPublisher({ job, branch, worktreePath, prep, deps, ownership, observation, httpClient, options: jobOptions, control,
             remainingMs: () => Math.max(0, plan.deadlineAtMs - deps.now()) }),
         callTimeoutMs: () => Math.min(120_000, Math.max(0, plan.deadlineAtMs - deps.now())),
@@ -4672,8 +5334,17 @@ async function runCoveredAttempt(params) {
         // the existence-only legacy fallback is refused here.
         coveredAttempt: true,
     });
-    const facts = finalizationFacts(finalization.ok ? { ok: true } : { ok: false, errorKind: finalization.failure.error_kind });
-    const envelope = envelopeWith({
+    // BAPI-1426: a server-confirmed delivery hold proved the push (origin equals
+    // the worker HEAD and the server's preserved head) and deliberately left the
+    // pull request unmet. Its completion cause is set on the envelope so the
+    // envelope, `successRefusalReason` and the `/fail` error kind all agree. A
+    // stronger cause the envelope already derived (cleanup, a locally failed
+    // check, unfinished tasks) is kept.
+    const deliveryHold = finalization.ok ? null : deliveryHoldOf(finalization.failure);
+    const facts = deliveryHold
+        ? { verdict: "unmet", pushSatisfied: true, prSatisfied: false }
+        : finalizationFacts(finalization.ok ? { ok: true } : { ok: false, errorKind: finalization.failure.error_kind });
+    const derivedEnvelope = envelopeWith({
         finalization: facts.verdict,
         verification,
         missing: [],
@@ -4681,6 +5352,14 @@ async function runCoveredAttempt(params) {
         prSatisfied: facts.prSatisfied,
         ...(verificationFacts ? { verificationFacts } : {}),
     });
+    const deliveryHoldCause = deliveryHold
+        ? deliveryHold.outcome === "verification_failed"
+            ? "required_check_failed"
+            : "required_work_incomplete"
+        : null;
+    const envelope = deliveryHoldCause !== null && derivedEnvelope.cause === null
+        ? { ...derivedEnvelope, cause: deliveryHoldCause }
+        : derivedEnvelope;
     // --- Phase 5: terminal report -----------------------------------------------------
     const lateStronger = await strongerOutcome();
     if (lateStronger)
@@ -4723,6 +5402,11 @@ async function runCoveredAttempt(params) {
         ...observedExitCode(procResult.exitCode),
     };
     const cause = envelope.cause;
+    if (cause && !finalization.ok && deliveryHold && cause === deliveryHoldCause) {
+        // BAPI-1426: the intentional delivery hold keeps its own bounded message and
+        // hold marker; its error kind already equals the envelope's cause.
+        return finish(await failWith({ ...finalization.failure, error_kind: COMPLETION_CAUSE_ERROR_KINDS[cause], ...observedExit }, envelope));
+    }
     if (cause) {
         return finish(await failWith({
             error_kind: COMPLETION_CAUSE_ERROR_KINDS[cause],