@bridge_gpt/mcp-server 0.2.66 → 0.2.68

package/build/executor/job-runner.js

@@ -1,3 +1,10 @@
+import { writeRecentlyFailedTestsFile } from "./recently-failed-tests-file.js";
+import { guardedFastForwardPush } from "./guarded-fast-forward-push.js";
+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";
 /**
  * Claimed-job execution engine (BAPI-534 core, BAPI-535 job behaviors; TDD §7/§8/§9).
  *
@@ -14,26 +21,29 @@
  * `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 } from "node:fs/promises";
+import { rm, readdir, lstat, unlink, realpath } from "node:fs/promises";
 import os from "node:os";
 import { runHeartbeatLoop } from "./heartbeat.js";
-import { isExecutorNamedError, toExecutorFailure, RebaseNotVerified, secretFreeErrorMessage, MissingVerdictArtifact, PreSpawnVerification, RequiredMcpRegistration, McpSurfaceMismatch, WorkerStartupFatal, WORKER_STARTUP_FATAL_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 { 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 { 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";
 import { getWorktreeMcpRegistrationTargets, normalizeWorktreePathForRegistration, provisionMcpRegistrationForWorktree, } from "../mcp-provisioning.js";
 import { resolveExecutorAgentAdapter } from "../agent-launchers/executor-adapter-registry.js";
 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, SUPPORTED_COMPLETION_RUNTIME, COMPLETION_CONTRACT_MARKER_VALUES, isCoveredJobType, MAX_EVENT_BYTES, runtimeMatchesSupported, successRefusalReason, verificationVerdictFromFacts, } from "./completion-contract.js";
-import { COMPLETION_CAUSE_ERROR_KINDS, EOF_DRAIN_BOUND_MS, finalizationFacts, finalizationObligations, planCompletionAllowance, readCompletionBinding, readDeclaredChecks, readOptionalWatchers, readRequiredVerification, } from "./completion-supervision.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 { 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";
 import { resolveCompletionEvidenceCapability } from "../agent-launchers/executor-adapter.js";
-import { prepareResumeSpawn, prepareRetainedContinuationWorktree, readContinuationBinding, } from "./resume-pre-spawn.js";
-import { ciFixContextError, readCiFixDispatchContext, renderPromptSpecPrompt, } from "./prompt-spec.js";
+import { autoCheckpointDirtyState, PRIOR_ATTEMPT_WIP_COMMIT_MESSAGE, prepareResumeSpawn, prepareRetainedContinuationWorktree, readContinuationBinding, verifyContinuationHeadLineage, } from "./resume-pre-spawn.js";
+import { buildEpicWorkaroundWorkerInstruction, ciFixContextError, readCiFixDispatchContext, renderPromptSpecPrompt, } from "./prompt-spec.js";
+/** BAPI-1399: the job type whose worker implements ticket requirements from scratch. */
+const WORKAROUND_CONTRACT_JOB_TYPES = new Set(["implement"]);
 import { defaultResolveBinPath } from "../start-tickets-conductor.js";
 /** The packaged bin basename of the deterministic worker guard (BAPI-1020). */
 const WORKER_GUARD_BIN_FILENAME = "worker-guard-hook-bin.js";
@@ -45,7 +55,7 @@ import { isVerdictJobType, readVerdictArtifact } from "./verdict-artifact.js";
 import { createWorkerLogClaimId, createWorkerLogTee, closeWorkerLogTee, distinctWorkerLogSessionIds, formatWorkerLogSessionInvariantWarning, teeAsyncIterable, } from "./worker-log.js";
 import { acquireExecutorWorktreeLock, } from "./worktree-lock.js";
 import { resolveExecutorStateDir, activateJobLog, deactivateJobLog, registerExecutorJobLog, markExecutorJobLogFinished, } from "./job-log-registry.js";
-import { executorViewerTabsEnabled, openExecutorViewerTab } from "./viewer-tabs.js";
+import { EXECUTOR_JOB_END_LOG_CHUNK, executorViewerTabsEnabled, openExecutorViewerTab, } from "./viewer-tabs.js";
 import { isImplementationStyleJobType, isRecoveryJobType, isSpawnJobType } from "./job-types.js";
 import { cleanupInterruptedWorktree } from "./interrupted-worktree.js";
 import { lazyProviderCheckPoller, runReconcileOverlapJob, } from "./reconcile-overlap-job.js";
@@ -54,11 +64,11 @@ import { resolveExecutorJobIndexScope } from "./index-scope.js";
 import { readFocusedPullRequest, validateWorkerFinalization } from "./worker-finalization.js";
 import { FOCUSED_REBASE_JOB_TYPE, focusedRebaseContextError, hasFocusedRebaseContext, validateFocusedRebaseContext, waitForFocusedRebase, } from "./rebase-finalization.js";
 import { ensureExecutorWorktree, finalizeRetainedExecutorWorktree, } from "./worktree.js";
-import { buildPrBaseContractLaunchInstruction } from "../pr-base-contract.js";
 import { CI_FIX_JOB_TYPE, 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 { TERMINAL_CAPACITY_PROTOCOL_VERSIONS, TERMINAL_CAPACITY_RUNTIME_CONTRACTS, TERMINAL_CAPACITY_RUNTIMES, } from "./types.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";
 import { isRecognizedServerName, MCP_SERVER_NAME } from "../mcp-identity.js";
 /**
@@ -89,7 +99,10 @@ function classificationToErrorKind(c) {
         case "timeout":
             return "Timeout";
         case "killed":
-            return "Killed";
+            // Legacy terminal disposition retries WorkerCrashed but has no Killed
+            // branch. Keep the established retry signal while the classification
+            // records that the executor deliberately ended the process.
+            return "WorkerCrashed";
         default:
             return "WorkerCrashed";
     }
@@ -540,6 +553,46 @@ function createNoopProcess(deps, durationMs, message) {
         },
     };
 }
+/**
+ * Bounded newline assembly of worker stdout into whole lines for a
+ * {@link RequiredWorkLedger} (BAPI-1301 covered path, BAPI-1364 legacy
+ * observation). A line that outgrows the event bound is handed over once (the
+ * ledger marks it `stream_oversize`) and the rest of it is discarded up to its
+ * newline. `onLine` runs after each completed line is ingested.
+ */
+function createLedgerLineFeeder(ledger, onLine) {
+    let lineBuffer = "";
+    let discardingOversize = false;
+    return {
+        feed: (chunk) => {
+            lineBuffer += chunk;
+            let newline;
+            while ((newline = lineBuffer.indexOf("\n")) >= 0) {
+                const line = lineBuffer.slice(0, newline);
+                lineBuffer = lineBuffer.slice(newline + 1);
+                if (discardingOversize) {
+                    discardingOversize = false;
+                    continue;
+                }
+                ledger.ingestLine(line);
+                onLine?.();
+            }
+            if (!discardingOversize && lineBuffer.length > MAX_EVENT_BYTES) {
+                ledger.ingestLine(lineBuffer);
+                lineBuffer = "";
+                discardingOversize = true;
+            }
+            else if (discardingOversize) {
+                lineBuffer = "";
+            }
+        },
+        flush: () => {
+            if (!discardingOversize && lineBuffer.length > 0)
+                ledger.ingestLine(lineBuffer);
+            lineBuffer = "";
+        },
+    };
+}
 /**
  * Run the process and heartbeat loop concurrently; return the process outcome.
  *
@@ -551,11 +604,22 @@ function createNoopProcess(deps, durationMs, message) {
  */
 async function superviseProcess(params) {
     const isDoneRef = { value: false };
+    const heartbeatStop = new AbortController();
+    const heartbeatDeps = params.cancelHeartbeatSleepOnExit ? { ...params.deps, sleep: (ms) => new Promise((resolve) => {
+            if (heartbeatStop.signal.aborted) {
+                resolve();
+                return;
+            }
+            let timer;
+            const done = () => { params.deps.clearTimer(timer); heartbeatStop.signal.removeEventListener("abort", done); resolve(); };
+            timer = params.deps.setTimer(done, ms);
+            heartbeatStop.signal.addEventListener("abort", done, { once: true });
+        }) } : params.deps;
     const hb = runHeartbeatLoop({
         job: params.job,
         httpClient: params.httpClient,
         options: params.options,
-        deps: params.deps,
+        deps: heartbeatDeps,
         ownership: params.ownership,
         proc: params.proc,
         observation: params.observation,
@@ -569,7 +633,10 @@ async function superviseProcess(params) {
         ...(params.terminationController
             ? { terminationController: params.terminationController }
             : {}),
-        onStdout: (chunk) => params.observation.recordStdout(chunk),
+        onStdout: (chunk) => {
+            params.observation.recordStdout(chunk);
+            params.onStdoutObserved?.(chunk);
+        },
         ...(mcpSurface
             ? {
                 onStdoutTerminationCheck: (chunk) => {
@@ -580,8 +647,10 @@ async function superviseProcess(params) {
             : {}),
     });
     isDoneRef.value = true;
+    heartbeatStop.abort();
     const loopOutcome = await hb;
-    params.observation.setExitCode(result.exitCode);
+    if (params.recordProcessExit !== false)
+        params.observation.setExitCode(result.exitCode);
     if (loopOutcome.kind === "auth_fatal") {
         // BAPI-1021 (AC-5): notify the runner immediately with ONLY the bounded
         // identifiers — never carried onto `result` itself, so the process's own
@@ -717,7 +786,11 @@ control) {
     // any /fail that has no envelope gets the truthful "not launched" envelope and
     // keeps its own error kind; reports that already carry one are untouched.
     if (claimIsCovered(job)) {
-        httpClient = withNotLaunchedEnvelopeFallback(httpClient, job);
+        httpClient = withNotLaunchedEnvelopeFallback(httpClient, job, {
+            jobTimeRuntime: () => jobTimeCompletionRuntimes.get(ownership) ?? null,
+            preflightRuntime: _report?.completionEvidenceQualified === true ? (_report.completionRuntime ?? null) : null,
+            agentId: resolveExecutorAgentId(options.agentId),
+        });
     }
     // `merge` is a deterministic executor action: dispatched BEFORE any worktree
     // ensure/recreate or worker-spawn logic — it ensures no worktree and spawns no
@@ -738,6 +811,13 @@ control) {
     if (job.job_type === "ci_rerun") {
         return runCiRerunExecutorJob(job, httpClient, options, deps, ownership, observation, seams, control);
     }
+    // BAPI-1391: `gate_qualification` is the run-less, deterministic gate
+    // qualification, dispatched here beside `ci_rerun` for the same reasons: no
+    // worktrunk worktree, no worker, and no fallback to one. `job-types.ts` keeps
+    // it out of `SPAWN_JOB_TYPES` and `RECOVERY_JOB_TYPES`.
+    if (job.job_type === "gate_qualification") {
+        return runGateQualificationExecutorJob(job, httpClient, options, deps, ownership, observation, seams, control);
+    }
     // BAPI-1152: `reconcile_overlap` takes its OWN branch, after `merge`/`smoke`
     // and before the generic spawn path. It needs a prepared, locked worktree like
     // a spawn job, but its body is the reconcile module's state machine: the
@@ -775,6 +855,124 @@ control) {
     });
     return { status: "failed", reason: "unsupported_job_type" };
 }
+/**
+ * Bound on waiting for a killed `gate_qualification` body to finish its own
+ * teardown (terminating a running command, removing the detached checkout)
+ * before the terminal report is sent.
+ */
+const GATE_QUALIFICATION_SETTLE_MAX_MS = 180_000;
+/**
+ * Run a deterministic `gate_qualification` job (BAPI-1391).
+ *
+ * The same lifecycle as {@link runCiRerunExecutorJob}: the payload timeout is
+ * resolved first, the body runs as a flow under {@link superviseProcess} (the
+ * one ownership, heartbeat, dead-man, and timeout protocol), and every terminal
+ * report goes through {@link sendTerminalMutationWithAuthReport}.
+ *
+ * The completion carries only the bounded result envelope from
+ * `gate-qualification-job.ts`. An inability goes to `/fail` with a closed
+ * error kind and fixed text; command output never reaches either.
+ */
+async function runGateQualificationExecutorJob(job, httpClient, options, deps, ownership, observation, seams, control) {
+    const timeout = resolveJobTimeoutSeconds(job, options.defaultJobTimeoutSeconds);
+    if (!timeout.ok) {
+        await httpClient.fail(job, {
+            error_kind: "ContractError.Timeout",
+            error_message: timeout.error,
+            classification: "crashed",
+        });
+        return { status: "failed", reason: "timeout_contract" };
+    }
+    const timeoutSeconds = timeout.timeoutSeconds;
+    const runGateQualification = seams.runGateQualification ??
+        ((claimed, input) => runGateQualificationJob(claimed, input, createProductionGateQualificationDeps({
+            deps,
+            options,
+            registerLive: (controller) => control?.liveWorkers.register(controller),
+            ownershipHeld: () => !ownership.abandoned,
+        })));
+    const flow = createFlowProcess((signal) => runGateQualification(job, { timeoutSeconds, signal }), (result) => result.ok);
+    const procResult = await superviseProcess({
+        job,
+        httpClient,
+        options,
+        deps,
+        ownership,
+        observation,
+        proc: flow.proc,
+        timeoutSeconds,
+        collectTelemetry: async () => ({}),
+        control,
+    });
+    // A killed flow keeps running until its own `finally` has terminated any
+    // command and removed the detached checkout. Wait for that, bounded, so the
+    // terminal report never races the teardown of a checkout it describes.
+    let settleTimer;
+    try {
+        await Promise.race([
+            flow.settled,
+            new Promise((resolve) => {
+                settleTimer = deps.setTimer(resolve, GATE_QUALIFICATION_SETTLE_MAX_MS);
+            }),
+        ]);
+    }
+    finally {
+        if (settleTimer !== undefined)
+            deps.clearTimer(settleTimer);
+    }
+    if (ownership.abandoned) {
+        return { status: "abandoned", reason: ownership.abandonReason };
+    }
+    const sendFail = async (errorKind, message, classification) => {
+        const terminal = await sendTerminalMutationWithAuthReport({
+            kind: "fail",
+            send: () => httpClient.fail(job, {
+                error_kind: errorKind,
+                error_message: message,
+                classification,
+                telemetry: observation.snapshot(),
+            }),
+            deps,
+            options,
+            ownership,
+            log: deps.log,
+        }, job, control);
+        return terminalToRunResult(terminal, "failed");
+    };
+    if (procResult.classification === "timeout") {
+        return sendFail(GATE_QUALIFICATION_FAILED, "gate_qualification exceeded its job timeout", "timeout");
+    }
+    const outcome = flow.getOutcome();
+    if (outcome === undefined) {
+        // Killed without a timeout (a server stop) — the commands were cut short —
+        // or the body threw, which it is built never to do.
+        return procResult.serverStopRequested
+            ? sendFail(GATE_QUALIFICATION_INTERRUPTED, "gate qualification was stopped before it finished", "killed")
+            : sendFail(GATE_QUALIFICATION_FAILED, "gate_qualification completed without an outcome", "crashed");
+    }
+    if (outcome.ok) {
+        const completion = {
+            job_type: "gate_qualification",
+            exit_code: 0,
+            classification: "clean_exit",
+            // The bounded result envelope, verbatim. The backend model is
+            // `extra="forbid"` and recomputes the outcome against the STORED payload.
+            result: outcome.result,
+            telemetry: observation.snapshot(),
+        };
+        const terminal = await sendTerminalMutationWithAuthReport({
+            kind: "complete",
+            send: () => httpClient.complete(job, completion),
+            deps,
+            options,
+            ownership,
+            log: deps.log,
+        }, job, control);
+        return terminalToRunResult(terminal, "completed");
+    }
+    // An inability: a closed error kind and fixed text, never command output.
+    return sendFail(outcome.failure.errorKind, outcome.failure.message, "crashed");
+}
 /**
  * Run a deterministic `ci_rerun` job (BAPI-1160).
  *
@@ -1193,6 +1391,8 @@ async function superviseDriverPhase(params) {
         ownership: params.ownership,
         observation: params.observation,
         proc: flow.proc,
+        cancelHeartbeatSleepOnExit: true,
+        recordProcessExit: false,
         timeoutSeconds: Math.max(1, params.timeoutSeconds),
         collectTelemetry: params.collectTelemetry,
         control: params.control,
@@ -1357,7 +1557,19 @@ async function ensureJobWorktree(job, options, deps, seams, policy) {
         return { ok: false, error: failure.error_message, failure };
     }
 }
-async function prepareSpawn(job, httpClient, options, deps, seams) {
+/** Advisory comparison capture; never reads a payload-provided replacement. */
+async function captureComparisonSha(worktreePath, deps) {
+    try {
+        const result = await deps.runCommand("git", ["-C", worktreePath, "rev-parse", "HEAD"]);
+        const sha = result.stdout.trim();
+        if (result.exitCode === 0 && /^[a-fA-F0-9]{40}$/.test(sha))
+            return sha.toLowerCase();
+    }
+    catch { /* advisory only */ }
+    deps.errorLog("[executor] immutable comparison SHA unavailable; disclose the discovery gap in the attempt transcript.");
+    return undefined;
+}
+async function prepareSpawn(job, httpClient, options, deps, seams, preparation) {
     // A continuation passes no local head here (`head === undefined`): its retained
     // worktree was already proven by `prepareRetainedContinuationWorktree` →
     // `verifyContinuationHeadLineage`, which refuses before spawn unless HEAD
@@ -1365,12 +1577,23 @@ async function prepareSpawn(job, httpClient, options, deps, seams) {
     // `correction_intent.head_sha`, including one the server derived for a first
     // attempt with no bound ticket head (BAPI-1344). The spawn source is always
     // that retained worktree, never an origin checkout.
-    const refuseCorrectionDrift = async (branch, head) => {
+    const refuseCorrectionDrift = async (branch, head, publication, worktreePath) => {
         if (!isRemainingWork(job.job_type, job.payload))
             return null;
         const intent = job.payload?.correction_intent;
         if (branch === intent.branch && (head === undefined || head === intent.head_sha))
             return null;
+        if (preparation && publication && worktreePath && publication.jobId === job.id &&
+            publication.preparationId === preparation.preparationId && publication.branch === branch &&
+            branch === intent.branch && head === publication.to_sha && head !== intent.head_sha &&
+            typeof intent.head_sha === "string" && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(intent.head_sha)) {
+            try {
+                const proof = await deps.runCommand("git", ["merge-base", "--is-ancestor", intent.head_sha, head], { cwd: worktreePath });
+                if (proof.exitCode === 0)
+                    return null;
+            }
+            catch { /* fail closed */ }
+        }
         const reason = "correction_context_missing";
         await httpClient.fail(job, {
             error_kind: "ContractError.CorrectionLegacy",
@@ -1461,13 +1684,14 @@ async function prepareSpawn(job, httpClient, options, deps, seams) {
         }
         const wt = await ensureJobWorktree(job, options, deps, seams, {
             reuseExistingBranch: isRecoveryJobType(job.job_type),
+            preparation,
             staleBranchClassification: resolveStaleBranchClassification(job.payload),
         });
         if (!wt.ok) {
             await httpClient.fail(job, jobWorktreeFailure(wt));
             return { ok: false, result: { status: "failed", reason: "worktree_create_failed" } };
         }
-        const drift = await refuseCorrectionDrift(wt.branch, readContinuationBinding(job) ? undefined : wt.expectedHeadSha);
+        const drift = await refuseCorrectionDrift(wt.branch, readContinuationBinding(job) ? undefined : wt.expectedHeadSha, wt.publication, wt.worktreePath);
         if (drift)
             return drift;
         return {
@@ -1476,6 +1700,7 @@ async function prepareSpawn(job, httpClient, options, deps, seams) {
             branch: wt.branch,
             prompt: "",
             expectedHeadSha: wt.expectedHeadSha,
+            ...(wt.publication ? { publication: wt.publication } : {}),
             ciFix,
         };
     }
@@ -1540,17 +1765,22 @@ async function prepareSpawn(job, httpClient, options, deps, seams) {
     const reuseExistingBranch = isRecoveryJobType(job.job_type);
     const wt = await ensureJobWorktree(job, options, deps, seams, {
         reuseExistingBranch,
+        preparation,
         // BAPI-862: hand the guard the reconciler's own reading of why this branch
         // may already carry commits. Read from the SERVER-minted payload field and
         // validated against a closed set — never inferred locally, and never taken
         // from worker output (R14 rules 3 and 4).
         staleBranchClassification: resolveStaleBranchClassification(job.payload),
+        // BAPI-1367: the server-minted (and client-normalized) prior head. Only an
+        // `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 } : {}),
     });
     if (!wt.ok) {
         await httpClient.fail(job, jobWorktreeFailure(wt));
         return { ok: false, result: { status: "failed", reason: "worktree_create_failed" } };
     }
-    const drift = await refuseCorrectionDrift(wt.branch, readContinuationBinding(job) ? undefined : wt.expectedHeadSha);
+    const drift = await refuseCorrectionDrift(wt.branch, readContinuationBinding(job) ? undefined : wt.expectedHeadSha, wt.publication, wt.worktreePath);
     if (drift)
         return drift;
     // Explicit/synthesized prompt wins verbatim, preserving existing behavior.
@@ -1563,6 +1793,8 @@ async function prepareSpawn(job, httpClient, options, deps, seams) {
             branch: wt.branch,
             prompt: explicit.prompt,
             expectedHeadSha: wt.expectedHeadSha,
+            ...(wt.publication ? { publication: wt.publication } : {}),
+            ...(wt.priorWork ? { priorWork: wt.priorWork } : {}),
             ...(focusedRebase ? { focusedRebase } : {}),
         };
     }
@@ -1578,6 +1810,7 @@ async function prepareSpawn(job, httpClient, options, deps, seams) {
             workBranch: wt.branch,
             baseBranch: options.baseBranch,
             runCommand: deps.runCommand,
+            deferComparisonGuidance: true,
         });
         return {
             ok: true,
@@ -1585,6 +1818,8 @@ async function prepareSpawn(job, httpClient, options, deps, seams) {
             branch: wt.branch,
             prompt: rendered,
             expectedHeadSha: wt.expectedHeadSha,
+            ...(wt.publication ? { publication: wt.publication } : {}),
+            ...(wt.priorWork ? { priorWork: wt.priorWork } : {}),
         };
     }
     catch (err) {
@@ -1599,6 +1834,93 @@ async function prepareSpawn(job, httpClient, options, deps, seams) {
         return { ok: false, result: { status: "failed", reason: "prompt_contract" } };
     }
 }
+/** The first twelve characters of a SHA — safe, supporting evidence only. */
+function shortSha(sha) {
+    return sha.slice(0, 12);
+}
+/**
+ * BAPI-1367 — the continuation wording prepended to a retried `implement` prompt.
+ *
+ * States the work state first (this is prior-attempt work, not a fresh start),
+ * says whether uncommitted files survived as a WIP checkpoint or were unavailable
+ * because the worktree was recreated from the pushed branch, and leaves the
+ * resolved prompt untouched after it. Short SHAs are the only identifiers used.
+ */
+export function buildPriorAttemptContinuationNotice(params) {
+    const { branch, priorWork, checkpointed, ticketKey } = params;
+    const recreated = priorWork.kind === "recreated_from_pushed_branch";
+    const command = ticketKey ? `/implement-ticket ${ticketKey} --auto` : "/implement-ticket";
+    const files = recreated
+        ? "Prior uncommitted files were unavailable on this host: the worktree was recreated from the pushed branch, so only committed work is present."
+        : checkpointed
+            ? "Prior uncommitted files were saved as a WIP checkpoint commit so nothing was lost."
+            : "The retained worktree was clean, so no WIP checkpoint was needed.";
+    return (`CONTINUATION: this is a retry. An earlier attempt of this job left work on branch '${branch}' ` +
+        `(its recorded head was ${shortSha(priorWork.priorHeadSha)}). You are continuing that prior-attempt ` +
+        `work, not starting ${command} from base: read the branch's existing commits first, keep what is ` +
+        `correct, and finish only what is missing. ${files} The original instructions follow unchanged.\n\n`);
+}
+/**
+ * BAPI-1367 — finish a prior-attempt resume UNDER THE WORKTREE LOCK.
+ *
+ * Order is the contract: prove the retained HEAD descends from the recorded prior
+ * head, WIP-checkpoint dirty files (a checkpoint commits onto whatever HEAD is, so
+ * lineage must be proven first), then finalize — which pins `expectedHeadSha` to
+ * the POST-checkpoint head and provisions command assets. No destructive Git
+ * command is ever issued. Diagnostics carry the job id, attempt number, and short
+ * SHAs only — never the prompt or a full hash.
+ */
+async function resumePriorAttemptUnderLock(params) {
+    const { job, prep, options, deps, worktreePath, branch } = params;
+    const priorWork = prep.priorWork;
+    const resumeSeams = buildResumeSeams(deps, options);
+    try {
+        await verifyContinuationHeadLineage(worktreePath, priorWork.priorHeadSha, resumeSeams);
+        const checkpoint = await autoCheckpointDirtyState(worktreePath, resumeSeams, PRIOR_ATTEMPT_WIP_COMMIT_MESSAGE);
+        const finalized = await finalizeRetainedExecutorWorktree(worktreePath, branch, deps);
+        if (!finalized.ok) {
+            return {
+                ok: false,
+                failure: {
+                    error_kind: "WorktreeError",
+                    error_message: finalized.error,
+                    classification: "crashed",
+                },
+            };
+        }
+        const notice = buildPriorAttemptContinuationNotice({
+            branch,
+            priorWork,
+            checkpointed: checkpoint.committed,
+            ticketKey: job.ticket_key,
+        });
+        deps.errorLog(`[executor] job ${job.id}: attempt ${job.attempt_count} resuming prior-attempt work ` +
+            `(prior head ${shortSha(priorWork.priorHeadSha)}, resumed at ${shortSha(finalized.expectedHeadSha)}` +
+            `${checkpoint.committed ? ", dirty files checkpointed" : ""})`);
+        if (priorWork.kind === "recreated_from_pushed_branch") {
+            deps.errorLog(`[executor] job ${job.id}: attempt ${job.attempt_count} worktree recreated from the pushed ` +
+                `branch; prior uncommitted files were unavailable (prior head ${shortSha(priorWork.priorHeadSha)})`);
+        }
+        return {
+            ok: true,
+            prep: {
+                ...prep,
+                prompt: `${notice}${prep.prompt}`,
+                expectedHeadSha: finalized.expectedHeadSha,
+            },
+        };
+    }
+    catch (err) {
+        const failure = isExecutorNamedError(err)
+            ? toExecutorFailure(err)
+            : {
+                error_kind: "WorktreeError",
+                error_message: secretFreeErrorMessage(err),
+                classification: "crashed",
+            };
+        return { ok: false, failure };
+    }
+}
 /**
  * BAPI-1296 — verify a prepared `ci_fix` checkout against its dispatched CI
  * context and render the focused prompt, UNDER THE WORKTREE LOCK.
@@ -1632,7 +1954,15 @@ async function renderVerifiedCiFixPrompt(params) {
         return { ok: false, error: ciFixContextError(job, "head_unreadable") };
     }
     if (head !== ciFix.headSha) {
-        return { ok: false, error: ciFixContextError(job, "stale_head") };
+        const fact = params.publication;
+        const context = params.preparation;
+        if (!context || !fact || fact.jobId !== job.id || fact.preparationId !== context.preparationId ||
+            fact.branch !== branch || fact.to_sha !== head || fact.from_sha !== ciFix.headSha) {
+            return { ok: false, error: ciFixContextError(job, "stale_head") };
+        }
+        const proof = await deps.runCommand("git", ["merge-base", "--is-ancestor", ciFix.headSha, head], { cwd: worktreePath });
+        if (proof.exitCode !== 0)
+            return { ok: false, error: ciFixContextError(job, "stale_head") };
     }
     const renderPrompt = seams.renderPromptSpecPrompt ?? renderPromptSpecPrompt;
     try {
@@ -1641,6 +1971,7 @@ async function renderVerifiedCiFixPrompt(params) {
             workBranch: branch,
             baseBranch,
             runCommand: deps.runCommand,
+            comparisonSha: ciFix.headSha,
         });
         return { ok: true, prompt };
     }
@@ -1804,13 +2135,106 @@ 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.
  */
-async function runSpawnJob(job, httpClient, options, deps, ownership, observation, seams, control, 
+/** 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;
+    let diagnosticWarningSent = false;
+    const failWithTelemetry = async (failedJob, body) => {
+        let telemetry = { ...body.telemetry, ...observation.snapshot() };
+        try {
+            const diagnostics = observation.workerDiagnostics();
+            if (diagnostics)
+                telemetry = { ...telemetry, worker_diagnostics: diagnostics };
+        }
+        catch {
+            if (!diagnosticWarningSent) {
+                diagnosticWarningSent = true;
+                try {
+                    deps.errorLog(`[executor] job ${job.id} ${new Date(deps.now()).toISOString()}: diagnostics unavailable (collection_failed)`);
+                }
+                catch { /* supplemental sink */ }
+            }
+        }
+        return originalHttp.fail(failedJob, { ...body, telemetry });
+    };
+    httpClient = new Proxy(originalHttp, { get(target, key) {
+            if (key === "fail")
+                return failWithTelemetry;
+            const value = Reflect.get(target, key);
+            return typeof value === "function" ? value.bind(target) : value;
+        } });
+    const originalDeps = deps;
+    deps = { ...deps, errorLog: (message) => {
+            try {
+                originalDeps.errorLog(`[executor] job ${job.id} ${new Date(originalDeps.now()).toISOString()}: ${message}`);
+            }
+            catch { /* supplemental logging cannot fail the job */ }
+        } };
+    const resolved = resolveExecutorBranch(job);
+    if (!resolved.ok)
+        return runReservedSpawnJob(job, httpClient, options, deps, ownership, observation, seams, control, driver);
+    const timeout = resolveJobTimeoutSeconds(job, options.defaultJobTimeoutSeconds);
+    if (!timeout.ok)
+        return runReservedSpawnJob(job, httpClient, options, deps, ownership, observation, seams, control, driver);
+    const deadline = deps.now() + timeout.timeoutSeconds * 1000;
+    const boundedDeps = { ...deps, runCommand: async (file, args, opts) => {
+            const remaining = deadline - deps.now();
+            if (remaining <= 0 || ownership.abandoned)
+                throw new Error("preparation unavailable");
+            return deps.runCommand(file, args, { ...opts, timeoutMs: Math.min(opts?.timeoutMs ?? 120_000, remaining) });
+        } };
+    const acquire = seams.acquireWorktreeLock ?? acquireExecutorWorktreeLock;
+    let reservation;
+    let retainedLock;
+    const reserve = async () => {
+        try {
+            const common = await boundedDeps.runCommand("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], { cwd: deps.cwd });
+            if (common.exitCode !== 0 || !path.isAbsolute(common.stdout.trim()))
+                throw new Error("reservation unavailable");
+            const reservationPath = path.join(common.stdout.trim(), "executor-preparation", createHash("sha256").update(resolved.branch).digest("hex"));
+            const request = (worktreePath) => ({ worktreePath, jobId: job.id, claimToken: job.claim_token,
+                executorId: options.executorId, ownerPid: process.pid, acquiredAt: nowIso(deps) });
+            const reserved = await acquire(request(reservationPath), buildWorktreeLockSeams(deps));
+            if (!reserved.acquired) {
+                deps.errorLog(`[executor] worktree already held job_id=${job.id} held_by=job_id=${reserved.owner?.jobId ?? "unknown"}`);
+                return null;
+            }
+            reservation = reserved;
+            const entries = await boundedDeps.runCommand("git", ["worktree", "list", "--porcelain"], { cwd: deps.cwd });
+            if (entries.exitCode !== 0)
+                throw new Error("worktree discovery unavailable");
+            const retained = findWorktreeByBranch(parseGitWorktreePorcelain(entries.stdout), resolved.branch);
+            if (retained) {
+                const held = await acquire(request(retained), buildWorktreeLockSeams(deps));
+                if (!held.acquired)
+                    throw new Error("worktree busy");
+                retainedLock = held;
+            }
+            const preparationId = randomUUID();
+            const preparation = { jobId: job.id, preparationId, branch: resolved.branch,
+                remainingMs: () => Math.max(0, deadline - deps.now()), mayMutate: () => !ownership.abandoned,
+                recordPublication: (fact) => observation.recordPublication(fact) };
+            return { retainedLock, preparation, deps: boundedDeps };
+        }
+        catch {
+            return null;
+        }
+    };
+    try {
+        return await runReservedSpawnJob(job, httpClient, options, deps, ownership, observation, seams, control, driver, undefined, undefined, reserve);
+    }
+    finally {
+        await retainedLock?.release();
+        await reservation?.release();
+    }
+}
+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) {
+driver, retainedLock, preparation, reserve) {
     // 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.
@@ -1931,11 +2355,94 @@ driver) {
             });
         return { status: "failed", reason: "permission_posture_contract" };
     }
+    const executionDeps = deps;
+    // Focused payload admission also precedes every lock/filesystem mutation.
+    if (job.job_type === CI_FIX_JOB_TYPE) {
+        try {
+            (seams.readCiFixDispatchContext ?? readCiFixDispatchContext)(job);
+        }
+        catch (err) {
+            const failure = isExecutorNamedError(err) ? toExecutorFailure(err) : { error_kind: CiFixContext, error_message: secretFreeErrorMessage(err), classification: "crashed" };
+            deps.errorLog(failure.error_message);
+            await httpClient.fail(job, failure);
+            return { status: "failed", reason: "ci_fix_context" };
+        }
+    }
+    if (job.job_type === FOCUSED_REBASE_JOB_TYPE && hasFocusedRebaseContext(job)) {
+        const validation = validateFocusedRebaseContext(job);
+        if (!validation.ok) {
+            const failure = toExecutorFailure(focusedRebaseContextError(job, validation.reason));
+            deps.errorLog(failure.error_message);
+            await httpClient.fail(job, failure);
+            return { status: "failed", reason: "focused_rebase_context" };
+        }
+    }
+    // Acquire ownership only after read-only admission and contract validation.
+    if (reserve) {
+        const held = await reserve();
+        if (!held) {
+            if (ownership.abandoned)
+                return { status: "abandoned", reason: ownership.abandonReason };
+            await httpClient.fail(job, { error_kind: WorktreeBusy, error_message: WORKTREE_BUSY_MESSAGE,
+                classification: "crashed", telemetry: observation.snapshot() });
+            return { status: "failed", reason: "worktree_busy" };
+        }
+        retainedLock = held.retainedLock;
+        preparation = held.preparation;
+        deps = held.deps;
+    }
     // --- Worktree + prompt (resume pre-spawn protocol or standard) -------
-    const prep = await prepareSpawn(job, httpClient, jobOptions, deps, seams);
+    let prep;
+    if (preparation) {
+        const phase = await superviseDriverPhase({ job, httpClient, options: jobOptions, deps, ownership, observation, control,
+            timeoutSeconds: Math.max(1, Math.ceil(preparation.remainingMs() / 1000)), collectTelemetry: async () => ({}),
+            run: async (signal) => {
+                const allowed = preparation.mayMutate;
+                const context = { ...preparation, mayMutate: () => allowed() && !signal.aborted };
+                const phaseDeps = { ...deps, runCommand: (file, args, opts) => deps.runCommand(file, args, { ...opts, signal }) };
+                return prepareSpawn(job, httpClient, jobOptions, phaseDeps, seams, context);
+            } });
+        if (phase.kind !== "result") {
+            if (phase.kind === "abandoned")
+                return { status: "abandoned", reason: ownership.abandonReason };
+            await httpClient.fail(job, { error_kind: phase.kind === "server_stop" ? "ServerStopRequested" : phase.kind === "timeout" ? "Timeout" : "WorktreeError",
+                error_message: "executor preparation stopped; retained work preserved", classification: phase.kind === "timeout" ? "timeout" : phase.kind === "server_stop" ? "killed" : "crashed" });
+            if (phase.kind === "server_stop") {
+                ownership.abandoned = true;
+                ownership.abandonReason = "server_stop";
+                return { status: "abandoned", reason: "server_stop" };
+            }
+            return { status: "failed", reason: "preparation_stopped" };
+        }
+        prep = phase.value;
+    }
+    else
+        prep = await prepareSpawn(job, httpClient, jobOptions, deps, seams);
     if (!prep.ok)
         return prep.result;
+    deps = executionDeps;
+    if (preparation)
+        prep = { ...prep, deadlineMs: deps.now() + preparation.remainingMs() };
     const { worktreePath, branch } = prep;
+    let retainedPathMatches = !retainedLock || path.resolve(retainedLock.owner.worktreePath) === path.resolve(worktreePath);
+    if (!retainedPathMatches && retainedLock) {
+        try {
+            retainedPathMatches = await realpath(retainedLock.owner.worktreePath) === await realpath(worktreePath);
+        }
+        catch { /* unreadable identity fails closed */ }
+    }
+    if (!retainedPathMatches) {
+        await httpClient.fail(job, { error_kind: WorktreeBusy, error_message: WORKTREE_BUSY_MESSAGE, classification: "crashed" });
+        return { status: "failed", reason: "worktree_lock_path_changed" };
+    }
+    if (preparation) {
+        const routing = await configureExecutorBranch(worktreePath, branch, deps);
+        if (routing) {
+            await httpClient.fail(job, { error_kind: "WorktreeError", error_message: routing,
+                classification: "crashed", telemetry: observation.snapshot() });
+            return { status: "failed", reason: "push_routing" };
+        }
+    }
     // --- Worktree mutual exclusion (FAIL-CLOSED, BAPI-793) ----------------
     // The FIRST thing that happens once a canonical worktree path exists, and
     // ahead of every executor-owned write to it: the deny layer, MCP
@@ -1946,15 +2453,10 @@ driver) {
     // are now created exclusively, and refusal still returns from HERE rather
     // than anywhere downstream.
     //
-    // Known residual window, stated rather than papered over: `prepareSpawn`
-    // above already ran `ensureWorktree`, which hard-resets and cleans the tree.
-    // Its path comes back FROM Worktrunk, so there is no path to lock before it
-    // without duplicating Worktrunk's layout rules here — a copy that would go
-    // wrong silently. Dispatch exclusion and same-ticket claim serialization
-    // (the Python half of this ticket) are what shrink that window; this lock is
-    // what makes everything after it safe.
+    // The branch reservation covers not-yet-created worktrees; retained trees
+    // already hold this same worktree lock before preparation.
     const acquireLock = seams.acquireWorktreeLock ?? acquireExecutorWorktreeLock;
-    const worktreeLock = await acquireLock({
+    const worktreeLock = retainedLock ?? await acquireLock({
         worktreePath,
         jobId: job.id,
         claimToken: job.claim_token,
@@ -1985,10 +2487,25 @@ driver) {
         // a refused ci_fix leaves the worktree exactly as preparation left it. The
         // verified, rendered prompt replaces preparation's empty placeholder.
         let readyPrep = prep;
+        // --- Prior-attempt resume (BAPI-1367) --------------------------------
+        // Inside the lock, and BEFORE artifact cleanup and every executor-owned write:
+        // prove the retained head's lineage, WIP-checkpoint any dirty files, and only
+        // then pin the pre-spawn expectation to the POST-checkpoint head. Pinning
+        // earlier (to base or to the lineage anchor) would make the BAPI-731
+        // assertion refuse the very checkpoint this step just made.
+        if (prep.priorWork) {
+            const resumed = await resumePriorAttemptUnderLock({ job, prep, options, deps, worktreePath, branch });
+            if (!resumed.ok) {
+                await httpClient.fail(job, resumed.failure);
+                return { status: "failed", reason: "prior_attempt_resume_failed" };
+            }
+            readyPrep = resumed.prep;
+        }
         if (prep.ciFix) {
             const rendered = await renderVerifiedCiFixPrompt({
                 job,
                 ciFix: prep.ciFix,
+                publication: prep.publication, preparation,
                 worktreePath,
                 branch,
                 baseBranch: effectiveBaseBranch,
@@ -2003,6 +2520,22 @@ driver) {
             }
             readyPrep = { ...prep, prompt: rendered.prompt };
         }
+        if (["implement", "resume", "remediate", "rebase", "ci_fix"].includes(job.job_type)) {
+            readyPrep = { ...readyPrep, comparisonSha: prep.ciFix?.headSha ??
+                    await captureComparisonSha(worktreePath, deps) };
+            if (!prep.ciFix && isRemainingWork(job.job_type, job.payload)) {
+                if (job.job_type === "resume" || prep.priorWork) {
+                    // Resume preparation owns retained continuation text, including seam-
+                    // supplied text. Do not reconstruct it from the earlier payload.
+                    readyPrep = { ...readyPrep, prompt: readyPrep.prompt + "\n\n" + renderWorkerVerificationGuidance(readyPrep.comparisonSha) };
+                }
+                else {
+                    const final = resolveExecutorPrompt(job, { comparisonSha: readyPrep.comparisonSha, diagnostic: deps.errorLog });
+                    readyPrep = { ...readyPrep, prompt: final.ok ? final.prompt :
+                            readyPrep.prompt + "\n\n" + renderWorkerVerificationGuidance(readyPrep.comparisonSha) };
+                }
+            }
+        }
         // --- Stale verdict artifacts (BAPI-814/D1) --------------------------
         // Inside the lock and BEFORE the worker spawns, on the SHARED attempt path,
         // so every job type routed through `runSpawnJob` is covered — `implement`,
@@ -2035,6 +2568,15 @@ driver) {
             });
             return { status: "failed", reason: "stale_artifact_cleanup" };
         }
+        try {
+            await (seams.writeRecentlyFailedTestsFile ?? writeRecentlyFailedTestsFile)(worktreePath, job.payload?.recently_failed_tests);
+        }
+        catch {
+            await httpClient.fail(job, { error_kind: "ContractError.RecentlyFailedTests",
+                error_message: "Recent failure resolver file could not be safely confirmed",
+                classification: "crashed" });
+            return { status: "failed", reason: "recently_failed_tests_file" };
+        }
         return await runPreparedSpawn({
             job,
             httpClient,
@@ -2077,6 +2619,32 @@ driver) {
         await worktreeLock.release();
     }
 }
+function retainedHeadPublisher(params) {
+    return async () => {
+        const { job, branch, worktreePath, prep, deps, ownership, observation, remainingMs } = params;
+        if (!prep.publicationBaseline)
+            return { status: "refused", reason: "invalid_input" };
+        const phase = await superviseDriverPhase({ job, httpClient: params.httpClient, options: params.options, deps, ownership, observation, control: params.control,
+            timeoutSeconds: Math.max(1, Math.ceil(remainingMs() / 1000)), collectTelemetry: async () => ({}),
+            run: async (signal) => {
+                const result = await guardedFastForwardPush({ branch, expectedOriginSha: prep.publicationBaseline,
+                    worktreePath, runCommand: deps.runCommand, env: deps.env, remainingMs, signal,
+                    mayMutate: () => !ownership.abandoned && !signal.aborted });
+                if (result.status === "published")
+                    observation.recordPublication({ ...result,
+                        jobId: job.id, preparationId: prep.publication?.preparationId ?? "finalization", branch });
+                return result;
+            } });
+        if (phase.kind !== "result") {
+            if (phase.kind === "server_stop") {
+                ownership.abandoned = true;
+                ownership.abandonReason = "server_stop";
+            }
+            return { status: "refused", reason: phase.kind === "error" ? "remote_rejected" : "timeout" };
+        }
+        return phase.value;
+    };
+}
 /**
  * Run a spawn job whose worktree is already prepared AND exclusively locked.
  *
@@ -2103,8 +2671,18 @@ async function runPreparedSpawn(params) {
     // base contract's "when you open the pull request" instruction would re-add the
     // new-PR step the focused prompt deliberately excludes.
     let prompt = isImplementationStyleJobType(job.job_type) && !prep.ciFix && !prep.focusedRebase
-        ? `${prep.prompt} ${buildPrBaseContractLaunchInstruction()}`
+        ? `${prep.prompt} ${renderWorkerPrBaseGuidance()}`
         : prep.prompt;
+    // BAPI-1399: a worker that implements ticket requirements is told the
+    // minor-versus-core workaround contract in the same launch prompt. Repair jobs
+    // (`ci_fix`, a focused rebase, `reconcile_overlap`) and a focused remaining-work
+    // correction implement no new requirement, so their prompts stay as they are.
+    if (WORKAROUND_CONTRACT_JOB_TYPES.has(job.job_type) &&
+        !prep.ciFix &&
+        !prep.focusedRebase &&
+        !isRemainingWork(job.job_type, job.payload)) {
+        prompt = `${prompt} ${buildEpicWorkaroundWorkerInstruction(job.ticket_key)}`;
+    }
     // --- Timeout contract ------------------------------------------------
     const timeout = resolveJobTimeoutSeconds(job, options.defaultJobTimeoutSeconds);
     if (!timeout.ok) {
@@ -2136,12 +2714,26 @@ async function runPreparedSpawn(params) {
     // finish the whole job here (a clean, green reconciliation pushes with no
     // worker at all), or hand back the ONE worker it needs and the pre-spawn state
     // it has already proven. The job's overall timeout budget spans every phase.
-    const jobDeadlineMs = deps.now() + timeout.timeoutSeconds * 1000;
+    const jobDeadlineMs = prep.deadlineMs ?? deps.now() + timeout.timeoutSeconds * 1000;
     const remainingMs = () => Math.max(0, jobDeadlineMs - deps.now());
+    if (!driver) {
+        try {
+            const remote = await deps.runCommand("git", ["ls-remote", "--exit-code", "origin", `refs/heads/${branch}`], { cwd: worktreePath, timeoutMs: Math.min(120_000, remainingMs()) });
+            const fields = remote.stdout.trim().split(/\s+/);
+            if (remote.exitCode === 0 && fields.length === 2 && fields[1] === `refs/heads/${branch}` && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(fields[0])) {
+                prep.publicationBaseline = isRecoveryJobType(job.job_type) ? prep.expectedHeadSha : fields[0];
+            }
+        }
+        catch { /* no eligible lease baseline */ }
+    }
     const driverBaseContext = {
         worktreePath,
         branch,
         preparedHeadSha: prep.expectedHeadSha,
+        preparationPublication: prep.publication,
+        recordPublication: (fact) => observation.recordPublication({
+            ...fact, jobId: job.id, preparationId: prep.publication?.preparationId ?? "finalization", branch,
+        }),
         effectiveBaseBranch,
     };
     const driverTelemetry = () => collectGitTelemetry({ runCommand: deps.runCommand, now: deps.now }, worktreePath, effectiveBaseBranch);
@@ -2174,6 +2766,37 @@ async function runPreparedSpawn(params) {
         // launch instruction would tell a worker with no push authority to open a PR.
         prompt = driverStep.prompt;
     }
+    // --- Packaged recipe delivery (BAPI-1392) ------------------------------
+    // Applied ONCE, to the final prompt, so a command-bearing prompt makes the worker
+    // follow the CURRENT packaged recipe instead of a stale committed copy (command
+    // provisioning is fill-only, BAPI-664). Prompt expansion reaches both launch
+    // transports because each carries exactly this string. Nothing is written under
+    // the worktree. Only the two command-bearing prompts are eligible — the initial
+    // `implement` synthesis and the server-built `spec_review` prompt. Every focused,
+    // driver-rendered and remaining-work prompt is left byte-identical, as is any
+    // prompt that names no recognized, non-customized Bridge command.
+    if (!driverStep &&
+        !prep.ciFix &&
+        !prep.focusedRebase &&
+        (job.job_type === "implement" || job.job_type === "spec_review") &&
+        !isRemainingWork(job.job_type, job.payload)) {
+        const recipes = resolvePackagedRecipes(prompt, readCustomizedCommands(job.payload));
+        if (!recipes.ok) {
+            deps.errorLog(`[executor] job ${job.id}: ${recipes.error}`);
+            await httpClient.fail(job, {
+                error_kind: PackagedRecipeUndeliverable,
+                error_message: recipes.error,
+                classification: "crashed",
+            });
+            return { status: "failed", reason: "packaged_recipe_undeliverable" };
+        }
+        prompt = recipes.prompt;
+    }
+    // Trusted starter context is appended AFTER packaged-command expansion, never
+    // inserted into command arguments or scanned through untrusted server evidence.
+    if (job.job_type === "implement" && !isRemainingWork(job.job_type, job.payload)) {
+        prompt += "\n\n" + renderWorkerVerificationGuidance(prep.comparisonSha);
+    }
     // --- 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
@@ -2363,6 +2986,7 @@ async function runPreparedSpawn(params) {
     if (logClaimId !== null) {
         try {
             tee = await createTee(worktreePath, {
+                now: deps.now,
                 mkdir: deps.mkdir,
                 writeFile: deps.writeFile,
                 appendFile: deps.appendFile,
@@ -2381,6 +3005,8 @@ async function runPreparedSpawn(params) {
         // this attempt has no transcript, which is said once, without detail.
         deps.errorLog(`worker log unavailable for job ${job.id} (allocation_failed); the attempt continues.`);
     }
+    if (tee)
+        observation.allocateAttemptLog(tee.identity, tee.available);
     const teeClaimId = tee?.identity.claimId;
     // BAPI-828 — idempotent worker-log closure, defined the moment a tee could
     // exist. Every terminal branch below calls this instead of `closeWorkerLogTee`
@@ -2398,6 +3024,22 @@ async function runPreparedSpawn(params) {
         // THIS attempt's entry is removed (BAPI-1330).
         if (teeClaimId !== undefined)
             deactivateJobLog(job.id, teeClaimId);
+        // BAPI-1397 (F2): one fixed end-of-job line, AFTER deactivation so nothing
+        // else can append behind it, on every terminal path (this closure is the
+        // single idempotent close every branch and the `finally` backstop share).
+        // The read-only viewer tab stops following the log when it reads it. Written
+        // straight to the attempt's own file rather than through the tee, so a failed
+        // write cannot mark the transcript unavailable; it is never fatal.
+        if (tee &&
+            deps.appendFile &&
+            (tee.unavailableReason === undefined || tee.unavailableReason === "append_failed")) {
+            try {
+                await deps.appendFile(tee.logPath, EXECUTOR_JOB_END_LOG_CHUNK);
+            }
+            catch {
+                deps.errorLog(`executor viewer: could not mark job ${job.id}'s worker log as ended (non-fatal)`);
+            }
+        }
         await closeWorkerLogTee(tee);
     };
     lifecycle.closeWorkerLog = closeWorkerLog;
@@ -2440,6 +3082,8 @@ async function runPreparedSpawn(params) {
                     workerLogPath: tee.logPath,
                     worktreePath,
                     ticketKey: job.ticket_key ?? undefined,
+                    // BAPI-1397 (F2): the tab is titled `<TICKET> · <job type>`.
+                    jobType: job.job_type,
                     runCommand: deps.runCommand,
                     cwd: deps.cwd,
                 });
@@ -2681,6 +3325,9 @@ async function runPreparedSpawn(params) {
             })
             : null;
         const runtime = probed ?? unrecognizedRuntime(adapter);
+        // Carry the probe identity into any later not-launched report for this job.
+        if (probed !== null)
+            jobTimeCompletionRuntimes.set(ownership, probed);
         const refuse = async (reason, message) => {
             await closeWorkerLog();
             await finalizeRegistry();
@@ -2725,10 +3372,24 @@ async function runPreparedSpawn(params) {
             plan,
             runtime,
             nudge: (ids) => capability.value.buildWatcherNudge(ids),
+            ...(capability.value.buildCompletionWindowNudge
+                ? { windowNudge: (ids) => capability.value.buildCompletionWindowNudge(ids) }
+                : {}),
             dispatchHeadSha,
             stripEnvFiles: stripWorktreeEnvFiles,
         });
     }
+    // BAPI-1364: an observe-only ledger for a legacy run of a covered job type. It
+    // never enters `runCoveredAttempt()` and never enables the completion contract;
+    // it only lets a clean exit be checked for required background work still live.
+    const legacyLedger = isCoveredJobType(job.job_type)
+        ? createRequiredWorkLedger({
+            binding: readCompletionBinding(job, null).binding,
+            lifecycleSupported: true,
+            optionalWatchers: readOptionalWatchers(job.payload),
+        })
+        : null;
+    const legacyLineFeeder = legacyLedger ? createLedgerLineFeeder(legacyLedger) : null;
     let proc;
     try {
         proc = spawnWorker({ env: spawnShape.env });
@@ -2789,16 +3450,19 @@ async function runPreparedSpawn(params) {
         proc: supervisedProc,
         // BAPI-1152: a driver's worker gets what is LEFT of the job budget, since the
         // pre-worker phase has already spent some of it.
-        timeoutSeconds: driver ? Math.max(1, Math.ceil(remainingMs() / 1000)) : timeout.timeoutSeconds,
+        timeoutSeconds: Math.max(1, Math.ceil(remainingMs() / 1000)),
         collectTelemetry,
         collectRemoteMarker,
         mcpSurface,
+        ...(legacyLineFeeder ? { onStdoutObserved: legacyLineFeeder.feed } : {}),
         // The SAME controller the registry holds, so an executor shutdown, a timeout,
         // and an MCP containment refusal all converge on one `SIGTERM` and one grace
         // timer for this child (BAPI-828).
         terminationController,
         control,
     });
+    // Flush a trailing partial stdout line so the observe-only ledger sees it.
+    legacyLineFeeder?.flush();
     // --- Adapter lifecycle (EXPLICIT, BAPI-781) ---------------------------
     // Consumed rather than assumed. Claude declares `{ kind: "none" }` and so
     // nothing runs here — which is correct, because BAPI-790 deleted the per-job
@@ -2895,7 +3559,7 @@ async function runPreparedSpawn(params) {
         await httpClient.fail(job, {
             error_kind: McpSurfaceMismatch,
             error_message: formatMcpSurfaceMismatch(surfaceVerdict.expected, surfaceVerdict.observed),
-            classification: "crashed",
+            classification: toWireClassification(procResult.classification),
             ...commitResidue(finalTelemetry),
             telemetry: observation.snapshot(),
         });
@@ -3028,6 +3692,32 @@ async function runPreparedSpawn(params) {
             await finalizeRegistry();
             return terminalToRunResult(terminal, "completed");
         }
+        // BAPI-1364: a legacy worker that ended its (headless) session while the
+        // structured stream still showed a required background command with no
+        // terminal notification can never receive that command's result. Report it
+        // before generic success, the ci_fix artifact merge, or finalization can hide
+        // it. Only the fixed kind and message are sent: no event text, command, path,
+        // or output. A matching terminal task_notification leaves nothing pending.
+        if (legacyLedger?.observeLiveRequiredWork() === "live_required_work") {
+            deps.errorLog(`[executor] job ${job.id}: worker exited cleanly with required background work still live`);
+            await finalizeRegistry();
+            const terminal = await sendTerminalMutationWithAuthReport({
+                kind: "fail",
+                send: () => httpClient.fail(job, {
+                    error_kind: WorkerEndedWithPendingBackgroundWork,
+                    error_message: WORKER_ENDED_WITH_PENDING_BACKGROUND_WORK_MESSAGE,
+                    classification: "crashed",
+                    ...observedExitCode(procResult.exitCode),
+                    ...commitResidue(git),
+                    telemetry: observation.snapshot(),
+                }),
+                deps,
+                options,
+                ownership,
+                log: deps.log,
+            }, job, control);
+            return terminalToRunResult(terminal, "failed");
+        }
         // Non-verdict spawn jobs (`implement`, `resume`, and the recovery jobs
         // `remediate`/`ci_fix`/`rebase`) use the generic success-result construction;
         // the verdict-artifact path above stays limited to verdict jobs like
@@ -3076,8 +3766,10 @@ async function runPreparedSpawn(params) {
             branch,
             worktreePath,
             result: genericResult,
+            publishRetainedHead: retainedHeadPublisher({ job, branch, worktreePath, prep, deps, ownership, observation, remainingMs, httpClient, options: jobOptions, control }),
             runCommand: deps.runCommand,
             headSha: git.last_commit_sha,
+            callTimeoutMs: () => Math.max(1, Math.min(FOCUSED_FINALIZATION_READ_MAX_MS, remainingMs())),
             expectedBaseBranch: effectiveBaseBranch,
             // BAPI-1311: a focused rebase's finalization reads are bounded by the
             // claim's remaining absolute deadline; every other job keeps the legacy,
@@ -3181,7 +3873,8 @@ async function runPreparedSpawn(params) {
     // BAPI-1152: an interrupted worker (timeout or kill) can leave a stale
     // `index.lock` or an in-progress merge behind — the BAPI-1111 residue that made
     // the next job's reset fail. Removed for EVERY spawn job, never with a hard
-    // reset; only a driver (`reconcile_overlap`) additionally resets to its anchor.
+    // reset; reconcile_overlap additionally discards unpublished wrapper merge
+    // state, while preserving successful or ambiguous publication.
     if (procResult.classification === "timeout" || procResult.classification === "killed") {
         await cleanupInterruptedWorktree(worktreePath, {
             runCommand: deps.runCommand,
@@ -3233,6 +3926,15 @@ const DESCENDANT_SAMPLE_INTERVAL_MS = 2_000;
 const INITIAL_PROMPT_WRITE_BOUND_MS = 30_000;
 /** Bound on closing the held stdin once the closure rule fires. */
 const STDIN_CLOSE_BOUND_MS = 5_000;
+/**
+ * BAPI-1395 — how long a worker may keep running after the completion window
+ * closed its stdin before the one termination path is requested. Equal to the
+ * grace the allowance plan already leaves between the hold deadline and the
+ * process timer (the measured CLI stops its own tasks within ~0.4 s of EOF).
+ * The request is also capped at the worker deadline, so the existing 20 s
+ * cleanup reservation that follows the worker's exit is never eaten into.
+ */
+const POST_WINDOW_EXIT_GRACE_MS = STDIN_CLOSE_GRACE_MS;
 const SUPPORTED_COMPLETION_MARKER = COMPLETION_CONTRACT_MARKER_VALUES[0];
 /**
  * BAPI-1330 — the worker's observed exit code as a `/fail` field. Omitted (never
@@ -3255,22 +3957,25 @@ function observedExitCode(exitCode) {
 function claimIsCovered(job) {
     return claimRequiresCompletionEvidence(job.required_capabilities);
 }
-/**
- * Wrap the client so a covered claim's /fail without an envelope carries the
- * "not launched" envelope (BAPI-1301). Every other call passes straight through.
- */
-function withNotLaunchedEnvelopeFallback(httpClient, job) {
+/** Exported for the covered-job runtime tests; not part of the executor's public surface. */
+export function withNotLaunchedEnvelopeFallback(httpClient, job, runtimeSources) {
     const wrapped = Object.create(httpClient);
     wrapped.fail = (claimed, failure) => {
         if (failure.completion_evidence !== undefined)
             return httpClient.fail(claimed, failure);
         const { binding } = readCompletionBinding(job, typeof job.expected_head_sha === "string" ? job.expected_head_sha : null);
         const unlaunched = unlaunchedVerification(readRequiredVerification(job.payload));
+        // The runtime actually probed, never the measured baseline: the job-time probe
+        // when it ran, then the qualified preflight runtime, then an unrecognized one.
+        // A runtime that does not satisfy the predicate makes the report a truthful
+        // refusal, so the server accepts it and still never reads it as success.
+        const runtime = runtimeSources.jobTimeRuntime() ?? runtimeSources.preflightRuntime ?? unrecognizedRuntimeForAgent(runtimeSources.agentId);
         const envelope = buildNotLaunchedEnvelope({
             binding,
-            runtime: { ...SUPPORTED_COMPLETION_RUNTIME },
+            runtime: { ...runtime },
             verification: unlaunched.verification,
             residuals: CLEANUP_RESIDUALS_NOT_COVERED,
+            unsupportedRuntime: !runtimeMatchesSupported(runtime),
             ...(unlaunched.facts ? { verificationFacts: unlaunched.facts } : {}),
         });
         return httpClient.fail(claimed, {
@@ -3281,6 +3986,12 @@ function withNotLaunchedEnvelopeFallback(httpClient, job) {
     };
     return wrapped;
 }
+/**
+ * The covered-job runtime probe's identity per job, recorded before launch so a
+ * later not-launched report stamps what was actually probed (BAPI-1386). Keyed by
+ * the job's ownership state, which both the wrapper and the spawn path share.
+ */
+const jobTimeCompletionRuntimes = new WeakMap();
 /**
  * The verification a covered report carries when no declared check ran
  * (BAPI-1302): before launch, after a worker failure, or on a stop.
@@ -3327,8 +4038,11 @@ function declaredOrderFacts(checks, runFacts) {
 }
 /** An identity that cannot match the supported runtime, for truthful refusal envelopes. */
 function unrecognizedRuntime(adapter) {
+    return unrecognizedRuntimeForAgent(adapter.identity.agentId);
+}
+function unrecognizedRuntimeForAgent(agentId) {
     return {
-        adapter: adapter.identity.agentId,
+        adapter: agentId,
         cli_version: "unrecognized",
         platform: "unrecognized",
         event_schema: "unrecognized",
@@ -3490,7 +4204,14 @@ async function runCoveredAttempt(params) {
     // --- Ownership lifetime: one heartbeat for the whole attempt ---------------
     let childLive = true;
     let workerStartedAt = null;
-    const tracker = proc.pid !== undefined ? createDescendantTracker({ inspector, rootPid: proc.pid }) : null;
+    const tracker = proc.pid !== undefined
+        ? createDescendantTracker({
+            inspector,
+            rootPid: proc.pid,
+            // Only the job id and the live count: never the token, a command, or stdout.
+            onOverflow: (liveDescendants) => deps.errorLog(`descendant tracker overflow job=${job.id} live_descendants=${liveDescendants}; cleanup cannot be confirmed`),
+        })
+        : null;
     if (proc.pid !== undefined) {
         void inspector
             .identity(proc.pid)
@@ -3555,9 +4276,20 @@ async function runCoveredAttempt(params) {
         void tracker.sample().finally(scheduleSample);
     // --- Held-stdin closure supervision -----------------------------------------
     const stdinDeps = { now: deps.now, setTimer: deps.setTimer, clearTimer: deps.clearTimer };
+    // BAPI-1395: a worker that ignores the stdin EOF the completion window sent is
+    // ended through the existing termination controller, not a second kill path.
+    let postWindowExitTimer;
     const supervisor = createClosureSupervisor({
         ledger,
         deps: stdinDeps,
+        ...(params.windowNudge ? { buildWindowNudge: params.windowNudge } : {}),
+        onWindowExpiry: () => {
+            const graceMs = Math.max(0, Math.min(POST_WINDOW_EXIT_GRACE_MS, plan.workerDeadlineAtMs - deps.now()));
+            postWindowExitTimer = deps.setTimer(() => {
+                postWindowExitTimer = undefined;
+                terminationController.requestTermination("completion_window");
+            }, graceMs);
+        },
         writeMessage: (line) => writeStdinBounded(proc, line, { deadlineAtMs: plan.holdDeadlineAtMs, deps: stdinDeps }),
         closeStdin: async () => {
             await closeStdinBounded(proc, {
@@ -3568,33 +4300,9 @@ async function runCoveredAttempt(params) {
         buildNudge: params.nudge,
         deadlineAtMs: plan.holdDeadlineAtMs,
     });
-    // The authoritative consumer: whole lines into the ledger, bounded. A line
-    // that outgrows the event bound is handed over once (the ledger marks it
-    // `stream_oversize`) and the rest of it is discarded up to its newline.
-    let lineBuffer = "";
-    let discardingOversize = false;
-    const authoritativeStdout = (chunk) => {
-        lineBuffer += chunk;
-        let newline;
-        while ((newline = lineBuffer.indexOf("\n")) >= 0) {
-            const line = lineBuffer.slice(0, newline);
-            lineBuffer = lineBuffer.slice(newline + 1);
-            if (discardingOversize) {
-                discardingOversize = false;
-                continue;
-            }
-            ledger.ingestLine(line);
-            supervisor.onActivity();
-        }
-        if (!discardingOversize && lineBuffer.length > MAX_EVENT_BYTES) {
-            ledger.ingestLine(lineBuffer);
-            lineBuffer = "";
-            discardingOversize = true;
-        }
-        else if (discardingOversize) {
-            lineBuffer = "";
-        }
-    };
+    // The authoritative consumer: whole lines into the ledger, bounded.
+    const lineFeeder = createLedgerLineFeeder(ledger, () => supervisor.onActivity());
+    const authoritativeStdout = lineFeeder.feed;
     const runPromise = runProcessWithTimeout(supervisedProc, Math.max(1, Math.ceil(plan.workerWindowMs / 1000)), deps, {
         termGraceMs: jobOptions.termGraceMs,
         terminationController,
@@ -3619,15 +4327,27 @@ async function runCoveredAttempt(params) {
         // Transport failed before any work: nothing the worker did can be
         // evidence. Stop it through the one termination path.
         ledger.recordTransportFailure(true);
-        terminationController.requestTermination();
+        terminationController.requestTermination("executor_abort");
     }
     const procResult = await runPromise;
+    const closedReason = supervisor.state().closedReason;
+    // A termination request has already latched the effective cause. Closing
+    // stdin later must not overwrite an earlier shutdown or containment stop.
+    const processEndCause = procResult.endCause && procResult.endCause !== "worker_exit"
+        ? procResult.endCause
+        : closedReason === "window" ? "completion_window"
+            : closedReason === "deadline" ? "job_timeout"
+                : closedReason === "abort" ? "executor_abort"
+                    : "worker_exit";
+    console.error(`[executor] End cause ${processEndCause}`);
     childLive = false;
     if (sampleTimer !== undefined)
         deps.clearTimer(sampleTimer);
+    if (postWindowExitTimer !== undefined)
+        deps.clearTimer(postWindowExitTimer);
+    postWindowExitTimer = undefined;
     supervisor.dispose();
-    if (!discardingOversize && lineBuffer.length > 0)
-        ledger.ingestLine(lineBuffer);
+    lineFeeder.flush();
     ledger.recordStreamEnd(procResult.authoritativeStreamError || procResult.exitUnconfirmed
         ? "stream_error"
         : (procResult.stdoutEnd ?? "eof"));
@@ -3671,18 +4391,21 @@ async function runCoveredAttempt(params) {
     const verificationRead = readRequiredVerification(job.payload);
     const declaration = verificationRead.kind === "ok" ? verificationRead.declaration : null;
     const checks = declaration?.checks ?? [];
-    const envelopeWith = (facts) => ledger.buildEnvelope({
-        runtime: params.runtime,
-        finalHeadSha,
-        finalization: facts.finalization,
-        verification: facts.verification,
-        cleanup,
-        missingCapabilities: facts.missing,
-        satisfiedObligations: [
-            ...(facts.pushSatisfied ? [obligations[0]] : []),
-            ...(facts.prSatisfied ? [obligations[1]] : []),
-        ],
-        ...(facts.verificationFacts ? { verificationFacts: facts.verificationFacts } : {}),
+    const envelopeWith = (facts) => ({
+        ...ledger.buildEnvelope({
+            runtime: params.runtime,
+            finalHeadSha,
+            finalization: facts.finalization,
+            verification: facts.verification,
+            cleanup,
+            missingCapabilities: facts.missing,
+            satisfiedObligations: [
+                ...(facts.pushSatisfied ? [obligations[0]] : []),
+                ...(facts.prSatisfied ? [obligations[1]] : []),
+            ],
+            ...(facts.verificationFacts ? { verificationFacts: facts.verificationFacts } : {}),
+        }),
+        end_cause: processEndCause,
     });
     const unverifiedEnvelope = () => {
         const unlaunched = unlaunchedVerification(verificationRead);
@@ -3763,7 +4486,7 @@ async function runCoveredAttempt(params) {
                 error_kind: "ServerStopRequested",
                 error_message: "the server requested this run stop; the owned worker was terminated",
                 classification: "killed",
-            }, unverifiedEnvelope());
+            }, { ...unverifiedEnvelope(), end_cause: "server_stop" });
             ownership.abandoned = true;
             ownership.abandonReason = "server_stop";
             return finish(result.status === "failed" ? { status: "abandoned", reason: "server_stop" } : result);
@@ -3778,7 +4501,7 @@ async function runCoveredAttempt(params) {
         return finish(await failWith({
             error_kind: McpSurfaceMismatch,
             error_message: formatMcpSurfaceMismatch(surfaceVerdict.expected, surfaceVerdict.observed),
-            classification: "crashed",
+            classification: toWireClassification(procResult.classification),
         }, unverifiedEnvelope()));
     }
     if (surfaceVerdict.kind === "absent" &&
@@ -3939,6 +4662,9 @@ async function runCoveredAttempt(params) {
         branch,
         worktreePath,
         result: genericResult,
+        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())),
         runCommand: deps.runCommand,
         headSha: git.last_commit_sha,
         expectedBaseBranch: effectiveBaseBranch,