@bridge_gpt/mcp-server 0.2.66 → 0.2.67

package/build/epic-implementer-bundle-cli.js

@@ -6,8 +6,8 @@
  * inside `build/pipelines.generated.js`. `mcp_server/src/` does not exist there,
  * so an instruction that told the agent to "call `validateConductorBundleInputs`"
  * would be referencing a path only this repository has. This subcommand is the
- * reachable surface, mirroring how `store-and-approve-epic-plan.md` invokes
- * `setup-epic` rather than hand-rolling HTTP calls.
+ * reachable surface, the same way `setup-epic` is a command rather than
+ * hand-rolled HTTP calls.
  *
  * It holds no policy of its own: it parses argv, delegates to
  * `conductor-bundle-artifacts.ts`, and prints a JSON envelope. All I/O is behind

package/build/executor/cli.js

@@ -37,9 +37,10 @@ const DEFAULT_JOB_TIMEOUT_SECONDS = 20 * 60;
 export const DEFAULT_MAX_CONCURRENT = 1;
 export function getExecutorUsage() {
     return [
-        "Usage: mcp-server executor --repo <name> [--repo <name> ...] [options]",
+        "Usage: mcp-server executor --repo <name> [--repo <name> ...]",
+        "                           (--epic-run-id <id> | --repo-wide) [options]",
         "",
-        "Runs the Epic Conductor v2 local executor: poll → claim → spawn → heartbeat.",
+        "Runs the Epic Implementer local executor: poll → claim → spawn → heartbeat.",
         "",
         "Options:",
         "  --repo <name>                 Repo to serve (repeatable).",

package/build/executor/completion-contract.js

@@ -53,6 +53,37 @@ export const SUPPORTED_COMPLETION_RUNTIME = {
     platform: "darwin-arm64",
     event_schema: "claude-stream-json.lifecycle.v1",
 };
+/** Oldest Claude CLI version whose lifecycle events were measured. */
+export const MIN_CLI_VERSION = "2.1.282";
+/** The four platform ids `<process.platform>-<process.arch>` the executor can produce. */
+export const SUPPORTED_PLATFORMS = ["darwin-arm64", "darwin-x64", "linux-x64", "linux-arm64"];
+/** Names the lifecycle parser version. A constant, never a probed value. */
+export const EVENT_SCHEMA = "claude-stream-json.lifecycle.v1";
+const CLI_VERSION_RE = /^(0|[1-9][0-9]{0,3})\.(0|[1-9][0-9]{0,3})\.(0|[1-9][0-9]{0,5})(?: \(Claude Code\))?$/;
+/**
+ * Parse `major.minor.patch` with an optional exact ` (Claude Code)` suffix into its
+ * numeric triple. Prereleases, whitespace, non-numeric segments, leading zeros, and
+ * non-strings are `null`. Mirror of `normalize_cli_version` in the Python contract.
+ */
+export function parseCliVersion(value) {
+    if (typeof value !== "string")
+        return null;
+    const match = CLI_VERSION_RE.exec(value);
+    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+/** The normalized `major.minor.patch` text, or `null` when the version is not strict. */
+export function normalizeCliVersion(value) {
+    const parsed = parseCliVersion(value);
+    return parsed ? parsed.join(".") : null;
+}
+/** Is version triple `a` at or above `b`? */
+export function cliVersionAtLeast(a, b) {
+    for (let i = 0; i < 3; i += 1) {
+        if (a[i] !== b[i])
+            return a[i] > b[i];
+    }
+    return true;
+}
 export const EVIDENCE_VALUES = ["sufficient", "insufficient"];
 export const INSUFFICIENT_REASON_VALUES = [
     "no_init_event",
@@ -239,13 +270,23 @@ export function isCoveredJobType(jobType) {
 export function claimRequiresCompletionEvidence(requiredCapabilities) {
     return Array.isArray(requiredCapabilities) && requiredCapabilities.includes(COMPLETION_EVIDENCE_CAPABILITY);
 }
+/**
+ * True for the measured baseline or a newer supported runtime: adapter `claude`, the
+ * lifecycle event schema, a closed platform id, and a strict numeric version at or
+ * above {@link MIN_CLI_VERSION}. Mirror of `runtime_matches_supported` in Python.
+ */
 export function runtimeMatchesSupported(runtime) {
     if (!runtime)
         return false;
+    const version = parseCliVersion(runtime.cli_version);
+    const minimum = parseCliVersion(MIN_CLI_VERSION);
     return (runtime.adapter === SUPPORTED_COMPLETION_RUNTIME.adapter &&
-        runtime.cli_version === SUPPORTED_COMPLETION_RUNTIME.cli_version &&
-        runtime.platform === SUPPORTED_COMPLETION_RUNTIME.platform &&
-        runtime.event_schema === SUPPORTED_COMPLETION_RUNTIME.event_schema);
+        runtime.event_schema === EVENT_SCHEMA &&
+        typeof runtime.platform === "string" &&
+        SUPPORTED_PLATFORMS.includes(runtime.platform) &&
+        version !== null &&
+        minimum !== null &&
+        cliVersionAtLeast(version, minimum));
 }
 export function unresolvedRequiredTasks(envelope) {
     return envelope.tasks.filter((t) => t.required && !TASK_RESOLVING_STATES.has(t.state));
@@ -366,7 +407,9 @@ export function buildNotLaunchedEnvelope(input) {
         binding: { ...input.binding },
         session_id: null,
         evidence: "insufficient",
-        insufficient_reasons: ["worker_not_launched"],
+        insufficient_reasons: input.unsupportedRuntime
+            ? ["worker_not_launched", "unsupported_runtime"]
+            : ["worker_not_launched"],
         execution: "unknown",
         verification: input.verification,
         finalization: "unknown",
@@ -381,7 +424,7 @@ export function buildNotLaunchedEnvelope(input) {
         denials: [],
         missing_capabilities: [],
         results_seen: 0,
-        cause: null,
+        cause: input.unsupportedRuntime ? "unsupported_completion_evidence" : null,
         ...(input.verificationFacts ? { verification_facts: input.verificationFacts } : {}),
     };
 }

package/build/executor/completion-supervision.js

@@ -228,6 +228,10 @@ export function finalizationFacts(outcome) {
         // and neither push nor PR is inferred satisfied.
         case "WorkerFinalizationPublicationUnverified":
             return { verdict: "unknown", pushSatisfied: false, prSatisfied: false };
+        // BAPI-1357: the origin lookup could not be trusted, so the branch was not
+        // observed missing either. Unknown, and neither obligation is inferred met.
+        case "WorkerFinalizationOriginUnverifiable":
+            return { verdict: "unknown", pushSatisfied: false, prSatisfied: false };
         default:
             return { verdict: "unknown", pushSatisfied: false, prSatisfied: false };
     }

package/build/executor/env.js

@@ -329,3 +329,22 @@ export function buildExecutorBaseWorkerEnv(parentEnv, options = {}) {
     // per call site.
     return env;
 }
+/**
+ * The environment for a headless agent run that is not a worker job, such as the
+ * executor's deny-enforcement probe (BAPI-1386).
+ *
+ * The probe must see what a worker sees. Spawned from an executor that is itself
+ * running inside a Claude session, it would otherwise inherit that session's
+ * nested-session variables, and the CLI can refuse to start a tool call there. So
+ * this reuses the worker allowlist and worker-injected defaults behind
+ * {@link buildExecutorBaseWorkerEnv} rather than keeping a deny-list of Claude
+ * variable names, which would go stale with every CLI release. No job-specific
+ * option is set: the result carries no branch, base, scope, or correction marker.
+ *
+ * Applied only where the executor builds the deny probe's context. The shared
+ * `runHeadless()` passes its supplied environment through unchanged, so standalone
+ * capability probes are not filtered.
+ */
+export function buildHeadlessAgentEnv(parentEnv) {
+    return buildExecutorBaseWorkerEnv(parentEnv);
+}

package/build/executor/heartbeat.js

@@ -22,7 +22,7 @@
  *    interval. This is TELEMETRY ONLY (R14): the marker is never persisted, never
  *    reported as `last_commit_sha`, and never drives an executor decision — the
  *    reconciler remains the sole consumer and the sole transition authority
- *    (`docs/claude/epic-implementer-standing-rules.md`).
+ *    (`docs/epic-implementer/standing-rules.md`).
  *
  *  - SERVER STOP (WS-B executor half). A heartbeat response carrying the
  *    server's stop request kills the owned worker like `stale_claim` does, but

package/build/executor/http-client.js

@@ -76,6 +76,22 @@ export function normalizeRequiredCapabilities(value) {
         return [];
     return value.every((entry) => typeof entry === "string") ? [...value] : [];
 }
+const FULL_SHA_PATTERN = /^[0-9a-fA-F]{40}$/;
+/**
+ * BAPI-1367 — normalize a claim response's `prior_attempt_head_sha`. Absent or
+ * explicit null reads as null silently (an older server, or no prior head). A
+ * present value that is not a 40-hex string also reads as null, and `onMalformed`
+ * is told once so the caller can warn. The raw value is never passed on, so it
+ * can never reach a log line.
+ */
+export function normalizePriorAttemptHeadSha(value, onMalformed) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value === "string" && FULL_SHA_PATTERN.test(value))
+        return value;
+    onMalformed();
+    return null;
+}
 /** Bound a server-provided diagnostic snippet included in error strings. */
 function boundedDetail(text) {
     const trimmed = (text ?? "").trim();
@@ -271,6 +287,10 @@ export function createExecutorHttpClient(config) {
                     if ("required_capabilities" in job) {
                         job.required_capabilities = normalizeRequiredCapabilities(job.required_capabilities);
                     }
+                    // BAPI-1367: a malformed prior head fails closed to null with one
+                    // bounded warning naming only the job, never the raw value or a SHA.
+                    job.prior_attempt_head_sha = normalizePriorAttemptHeadSha(job.prior_attempt_head_sha, () => (config.warn ?? ((message) => console.error(message)))(`executor: ignoring malformed prior attempt head in the claim for job ${String(job.id)}; ` +
+                        `treating it as a first dispatch.`));
                     return { kind: "claimed", job, reconcilerLiveness };
                 }
                 catch {

package/build/executor/job-errors.js

@@ -41,6 +41,11 @@
  *    work reached origin") because this case has positive proof of recoverable
  *    state: an operator can resume/finalize from the existing branch rather than
  *    re-running from scratch; see `worker-finalization.ts`.
+ *  - `WorkerFinalizationOriginUnverifiable` — an implementation-style job
+ *    (BAPI-1357) exited cleanly, but the origin branch lookup could not be
+ *    trusted (a throw, an expired bound, an unexpected exit, or unusable output).
+ *    The branch was NOT observed absent, so this is distinct from
+ *    `WorkerFinalizationMissingRemoteBranchAndPr`; see `worker-finalization.ts`.
  *  - `ContractError.WorkerConfigIsolation` — a per-job isolated Claude config
  *    directory could not be established (unsupported platform, unsupported auth
  *    layout, unseedable directory, or a missing required MCP registration), so
@@ -141,6 +146,24 @@ export const WorkerFinalizationSavedButUnfinalized = "WorkerFinalizationSavedBut
  * verdict is `unknown`, never `unmet` and never `ok`.
  */
 export const WorkerFinalizationPublicationUnverified = "WorkerFinalizationPublicationUnverified";
+/**
+ * BAPI-1357: the origin branch lookup could not be TRUSTED — the command threw,
+ * its call bound expired, it exited with anything other than "found" (0) or "no
+ * matching ref" (2), or it exited 0 without a usable SHA for the exact ref. The
+ * branch was not observed absent, so this is distinct from
+ * `WorkerFinalizationMissingRemoteBranchAndPr`, which is reserved for an
+ * observed absence. The process itself exited clean. Nothing command-derived
+ * (stderr, error text, host, credentials) is carried by this kind.
+ */
+export const WorkerFinalizationOriginUnverifiable = "WorkerFinalizationOriginUnverifiable";
+/**
+ * BAPI-1364: a LEGACY (non-covered) worker exited cleanly while the structured
+ * stream still showed a required background command with no terminal
+ * notification. The headless session had no later turn, so the command's result
+ * could never reach the worker. Carries only {@link WORKER_ENDED_WITH_PENDING_BACKGROUND_WORK_MESSAGE};
+ * no event text, command, path, or output.
+ */
+export const WorkerEndedWithPendingBackgroundWork = "WorkerEndedWithPendingBackgroundWork";
 export const WorkerConfigIsolation = "ContractError.WorkerConfigIsolation";
 export const PreSpawnVerification = "ContractError.PreSpawnVerification";
 export const BridgeCredentialUnavailable = "ContractError.BridgeCredentialUnavailable";
@@ -282,6 +305,8 @@ export function formatMcpSurfaceMismatch(expected, observed) {
         "Check that the installed Claude CLI supports --strict-mcp-config and that nothing adds MCP " +
         "servers outside the worktree registration.");
 }
+/** The fixed message posted with {@link WorkerEndedWithPendingBackgroundWork}. */
+export const WORKER_ENDED_WITH_PENDING_BACKGROUND_WORK_MESSAGE = "the worker ended its session while a background command was still running";
 /**
  * The fixed message posted with {@link WorkerStartupFatal}.
  *

package/build/executor/job-runner.js

@@ -17,7 +17,7 @@
 import { rm, readdir, lstat, unlink } 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, 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 { createObservationState } from "./observation.js";
@@ -26,13 +26,13 @@ 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, SUPPORTED_COMPLETION_RUNTIME, COMPLETION_CONTRACT_MARKER_VALUES, isCoveredJobType, MAX_EVENT_BYTES, runtimeMatchesSupported, successRefusalReason, verificationVerdictFromFacts, } from "./completion-contract.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, 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 { autoCheckpointDirtyState, PRIOR_ATTEMPT_WIP_COMMIT_MESSAGE, prepareResumeSpawn, prepareRetainedContinuationWorktree, readContinuationBinding, verifyContinuationHeadLineage, } from "./resume-pre-spawn.js";
 import { ciFixContextError, readCiFixDispatchContext, renderPromptSpecPrompt, } from "./prompt-spec.js";
 import { defaultResolveBinPath } from "../start-tickets-conductor.js";
 /** The packaged bin basename of the deterministic worker guard (BAPI-1020). */
@@ -540,6 +540,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.
  *
@@ -569,7 +609,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) => {
@@ -717,7 +760,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
@@ -1545,6 +1592,10 @@ async function prepareSpawn(job, httpClient, options, deps, seams) {
         // 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));
@@ -1563,6 +1614,7 @@ async function prepareSpawn(job, httpClient, options, deps, seams) {
             branch: wt.branch,
             prompt: explicit.prompt,
             expectedHeadSha: wt.expectedHeadSha,
+            ...(wt.priorWork ? { priorWork: wt.priorWork } : {}),
             ...(focusedRebase ? { focusedRebase } : {}),
         };
     }
@@ -1585,6 +1637,7 @@ async function prepareSpawn(job, httpClient, options, deps, seams) {
             branch: wt.branch,
             prompt: rendered,
             expectedHeadSha: wt.expectedHeadSha,
+            ...(wt.priorWork ? { priorWork: wt.priorWork } : {}),
         };
     }
     catch (err) {
@@ -1599,6 +1652,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.
@@ -1985,6 +2125,20 @@ 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,
@@ -2681,6 +2835,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();
@@ -2729,6 +2886,17 @@ async function runPreparedSpawn(params) {
             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 });
@@ -2793,12 +2961,15 @@ async function runPreparedSpawn(params) {
         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
@@ -3028,6 +3199,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
@@ -3255,22 +3452,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 +3481,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 +3533,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",
@@ -3568,33 +3777,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,
@@ -3626,8 +3811,7 @@ async function runCoveredAttempt(params) {
     if (sampleTimer !== undefined)
         deps.clearTimer(sampleTimer);
     supervisor.dispose();
-    if (!discardingOversize && lineBuffer.length > 0)
-        ledger.ingestLine(lineBuffer);
+    lineFeeder.flush();
     ledger.recordStreamEnd(procResult.authoritativeStreamError || procResult.exitUnconfirmed
         ? "stream_error"
         : (procResult.stdoutEnd ?? "eof"));