@bridge_gpt/mcp-server 0.2.65 → 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/epic-launch-diagnostic.js

@@ -0,0 +1,31 @@
+/** Keep operator-controlled components out of trusted epic-launch refusal text. */
+export function diagnosticComponent(value) {
+    // A short identifier here is a schema-field label, not its stored value.
+    if (/^field '[A-Za-z][A-Za-z0-9]{0,39}'$/.test(value))
+        return value;
+    if (value.length > 512 ||
+        /[\x00-\x1f\x7f]/.test(value) ||
+        /(?:sk[-_][A-Za-z0-9]+|api[-_]?key[-_:=][A-Za-z0-9]+|secret|token|password|bearer|authorization)/i.test(value) ||
+        /%[0-9a-f]{2}/i.test(value) && decodedLooksSensitive(value))
+        return "<redacted>";
+    return value;
+}
+function decodedLooksSensitive(value) {
+    try {
+        const decoded = decodeURIComponent(value);
+        return decoded !== value && diagnosticComponent(decoded) === "<redacted>";
+    }
+    catch {
+        return true;
+    }
+}
+/** URL validation alone permits paths and queries that look like credentials. */
+export function safeEpicLaunchTargetUrl(baseUrl) {
+    try {
+        const url = new URL(baseUrl);
+        return !url.username && !url.password && diagnosticComponent(baseUrl) === baseUrl;
+    }
+    catch {
+        return false;
+    }
+}

package/build/epic-launch-profile.js

@@ -26,11 +26,13 @@
  */
 import os from "node:os";
 import path from "node:path";
+import { createHash } from "node:crypto";
 import { chmod, mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { durablyReplaceCredentialStoreJson, getPrimaryCredentialStorePath, withCredentialStoreLock, } from "./credential-store.js";
 import { validateHttpBaseUrl, describeBaseUrlRejection } from "./base-url.js";
 import { MCP_PACKAGE_NAME } from "./mcp-identity.js";
 import { isTransientNpxEntryPath } from "./mcp-server-invocation.js";
+import { diagnosticComponent } from "./epic-launch-diagnostic.js";
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -45,7 +47,7 @@ export const EPIC_LAUNCH_EXECUTION_MODES = ["local", "durable"];
 /** One-time migration guidance for a profile this build cannot read. */
 export function epicLaunchProfileSetupGuidance(name) {
     return (`Re-run guided setup to (re)write it: npx -y ${MCP_PACKAGE_NAME} install conductor ` +
-        `--launch-profile ${EPIC_LAUNCH_PROFILE_NAME_PATTERN.test(name) ? name : "<name>"} --base-url <url> ...`);
+        `--launch-profile ${EPIC_LAUNCH_PROFILE_NAME_PATTERN.test(name) ? diagnosticComponent(name) : "<name>"} --base-url <url> ...`);
 }
 // ---------------------------------------------------------------------------
 // Validation (pure)
@@ -73,7 +75,7 @@ function malformed(name, field, why) {
     return {
         ok: false,
         kind: "profile-malformed",
-        message: `Epic launch profile '${name}' is unusable: ${field} ${why}. ${epicLaunchProfileSetupGuidance(name)}`,
+        message: `Epic launch profile '${diagnosticComponent(name)}' is unusable: ${diagnosticComponent(field)} ${why}. ${epicLaunchProfileSetupGuidance(name)}`,
     };
 }
 function validateRuntime(name, raw) {
@@ -118,7 +120,7 @@ export function validateEpicLaunchProfile(raw, selector = "<unnamed>") {
         return {
             ok: false,
             kind: "profile-unsupported-version",
-            message: `Epic launch profile '${selector}' uses an unsupported schema version; this build reads ` +
+            message: `Epic launch profile '${diagnosticComponent(selector)}' uses an unsupported schema version; this build reads ` +
                 `version ${EPIC_LAUNCH_PROFILE_VERSION} only. ${epicLaunchProfileSetupGuidance(selector)}`,
         };
     }
@@ -204,23 +206,23 @@ async function readStoreDocument(deps) {
         if (code === "ENOENT") {
             return { ok: true, present: false, document: { version: EPIC_LAUNCH_PROFILE_VERSION, profiles: {} } };
         }
-        return { ok: false, kind: "store-unreadable", message: `Unable to read ${storePath}.` };
+        return { ok: false, kind: "store-unreadable", message: `Unable to read ${diagnosticComponent(storePath)}.` };
     }
     let parsed;
     try {
         parsed = JSON.parse(raw);
     }
     catch {
-        return { ok: false, kind: "store-unreadable", message: `${storePath} is not valid JSON.` };
+        return { ok: false, kind: "store-unreadable", message: `${diagnosticComponent(storePath)} is not valid JSON.` };
     }
     if (!isPlainObject(parsed) || !isPlainObject(parsed.profiles)) {
-        return { ok: false, kind: "store-unreadable", message: `${storePath} has no profiles object.` };
+        return { ok: false, kind: "store-unreadable", message: `${diagnosticComponent(storePath)} has no profiles object.` };
     }
     if (parsed.version !== EPIC_LAUNCH_PROFILE_VERSION) {
         return {
             ok: false,
             kind: "profile-unsupported-version",
-            message: `${storePath} uses an unsupported schema version; this build reads version ` +
+            message: `${diagnosticComponent(storePath)} uses an unsupported schema version; this build reads version ` +
                 `${EPIC_LAUNCH_PROFILE_VERSION} only. ${epicLaunchProfileSetupGuidance("<name>")}`,
         };
     }
@@ -249,7 +251,7 @@ export async function readEpicLaunchProfile(name, deps) {
         return {
             ok: false,
             kind: "profile-missing",
-            message: `No epic launch profile named '${name}' exists on this host. ${epicLaunchProfileSetupGuidance(name)}`,
+            message: `No epic launch profile named '${diagnosticComponent(name)}' exists on this host. ${epicLaunchProfileSetupGuidance(name)}`,
         };
     }
     const validated = validateEpicLaunchProfile(store.document.profiles[name], name);
@@ -259,7 +261,7 @@ export async function readEpicLaunchProfile(name, deps) {
         return {
             ok: false,
             kind: "profile-host-mismatch",
-            message: `Epic launch profile '${name}' was approved on a different host. Profiles are host-local; ` +
+            message: `Epic launch profile '${diagnosticComponent(name)}' was approved on a different host. Profiles are host-local; ` +
                 epicLaunchProfileSetupGuidance(name),
         };
     }
@@ -309,6 +311,34 @@ export async function writeEpicLaunchProfile(profile, deps) {
         return { ok: true, path: storePath, action: existing === undefined ? "created" : "updated" };
     }, (error) => ({ ok: false, kind: "store-write-failed", message: error }));
 }
+/** Safe for text and JSON; no policy recipient or webhook value is retained. */
+export function formatEpicLaunchChannelIdentity(identity) {
+    return identity;
+}
+const pinnedPolicyContents = new WeakMap();
+/** Store selected content once, without making it serializable with the selection. */
+export function pinEpicLaunchPolicy(selection, policy) {
+    pinnedPolicyContents.set(selection, policy);
+    return selection;
+}
+export function getPinnedEpicLaunchPolicy(selection) {
+    return pinnedPolicyContents.get(selection);
+}
+export function epicLaunchPolicyDigest(raw) {
+    return createHash("sha256").update(raw).digest("hex");
+}
+/** Finalize the already selected target after the run's existence is known. */
+export function resolveEpicLaunchSelection(args) {
+    return Object.freeze({
+        baseUrl: args.baseUrl,
+        repoName: args.repoName,
+        targetSource: args.targetSource,
+        profileName: args.profile?.name ?? null,
+        topology: args.topology,
+        policy: Object.freeze(args.policy),
+        escalationChannel: args.escalationChannel,
+    });
+}
 /**
  * Normalize every applicable target source and decide ONE target, before any
  * credential is resolved and before any request is made.
@@ -338,7 +368,7 @@ export function resolveEpicLaunchTarget(inputs) {
     const flag = normalize(inputs.flagBaseUrl, "--base-url");
     if (!flag.ok)
         return { ok: false, kind: "target-invalid", message: flag.message };
-    const env = normalize(inputs.env.BAPI_BASE_URL, "BAPI_BASE_URL");
+    const env = normalize(inputs.profileSource === "profile-env" ? undefined : inputs.env.BAPI_BASE_URL, "BAPI_BASE_URL");
     if (!env.ok)
         return { ok: false, kind: "target-invalid", message: env.message };
     const profile = inputs.profile;
@@ -347,7 +377,7 @@ export function resolveEpicLaunchTarget(inputs) {
             return {
                 ok: false,
                 kind: "target-conflict",
-                message: `--base-url names a different endpoint than launch profile '${profile.name}'. An override ` +
+                message: `--base-url names a different endpoint than launch profile '${diagnosticComponent(profile.name)}'. An override ` +
                     "does not rebind a profile; re-run guided setup to change its target.",
             };
         }
@@ -355,7 +385,7 @@ export function resolveEpicLaunchTarget(inputs) {
             return {
                 ok: false,
                 kind: "target-conflict",
-                message: `BAPI_BASE_URL names a different endpoint than launch profile '${profile.name}'. Unset it, ` +
+                message: `BAPI_BASE_URL names a different endpoint than launch profile '${diagnosticComponent(profile.name)}'. Unset it, ` +
                     "or re-run guided setup to change the profile's target.",
             };
         }
@@ -364,10 +394,10 @@ export function resolveEpicLaunchTarget(inputs) {
             return {
                 ok: false,
                 kind: "repository-conflict",
-                message: `--repo names a different repository than launch profile '${profile.name}'.`,
+                message: `--repo names a different repository than launch profile '${diagnosticComponent(profile.name)}'.`,
             };
         }
-        return { ok: true, baseUrl: profile.baseUrl, source: "profile", repoName: profile.repoName };
+        return { ok: true, baseUrl: profile.baseUrl, source: inputs.profileSource ?? "profile", repoName: profile.repoName };
     }
     if (flag.value !== null && env.value !== null && flag.value !== env.value) {
         return {

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

@@ -223,6 +223,15 @@ export function finalizationFacts(outcome) {
         case "WorkerFinalizationMissingRemoteBranchAndPr":
         case "WorkerFinalizationSavedButUnfinalized":
             return { verdict: "unmet", pushSatisfied: false, prSatisfied: false };
+        // BAPI-1330: the worker's full HEAD, or the PR's head, could not be
+        // established. Nothing was observed MISSING, so the verdict is `unknown`
+        // 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/correction-dispatch.js

@@ -0,0 +1,60 @@
+/** BAPI-1328: persisted remaining-work authority, independent of prompt text. */
+export const CORRECTION_INTENT_CAPABILITY = "correction_intent.v1";
+export const CORRECTION_INTENT_VERSION = 1;
+export const CORRECTION_KINDS = [
+    "review_fix", "operator_remediation", "ci_fix", "focused_rebase",
+    "overlap_reconciliation", "approved_spec_delta", "continuation",
+    "required_checks", "finalization", "integration_correction",
+];
+function nonblank(value) {
+    return typeof value === "string" && value.trim().length > 0 && value.length <= 4096;
+}
+function reference(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) &&
+        Object.keys(value).length > 0 && Object.entries(value).every(([key, item]) => nonblank(key) && ((typeof item === "string" && nonblank(item)) ||
+        (typeof item === "number" && Number.isInteger(item))));
+}
+/** A prompt or job type never grants correction authority. */
+export function validateCorrectionIntent(value, row) {
+    const refuse = (code, detail) => ({ ok: false, code, detail });
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return refuse("correction_context_missing", "correction intent is absent");
+    const intent = value;
+    if (intent.version !== CORRECTION_INTENT_VERSION)
+        return refuse("correction_contract_version_unsupported", "unsupported correction intent version");
+    if (!CORRECTION_KINDS.includes(intent.kind))
+        return refuse("correction_contract_invalid", "unknown correction kind");
+    for (const key of ["repo_name", "epic_run_id", "ticket_key"]) {
+        if (!nonblank(row[key]) || intent[key] !== row[key])
+            return refuse("correction_contract_invalid", `${key} differs from row`);
+    }
+    if (!nonblank(intent.branch) || (row.expected_branch && intent.branch !== row.expected_branch))
+        return refuse("correction_context_missing", "retained branch is unavailable or changed");
+    if (!nonblank(intent.head_sha) || (row.expected_head_sha && intent.head_sha !== row.expected_head_sha))
+        return refuse("correction_context_missing", "retained head is unavailable or changed");
+    if (!nonblank(intent.obligation) || !reference(intent.context_ref))
+        return refuse("correction_context_missing", "remaining obligation or context reference is absent");
+    if (intent.resume !== undefined && intent.resume !== null && intent.resume !== false)
+        return refuse("correction_contract_invalid", "unsupported resume metadata");
+    if (intent.kind === "approved_spec_delta") {
+        const delta = intent.approved_delta;
+        if (!delta || typeof delta !== "object" || Array.isArray(delta))
+            return refuse("renewed_scope_approval_required", "approved same-ticket delta is absent");
+        const d = delta;
+        if (!["old_identity", "new_identity", "obligation"].every(key => nonblank(d[key])) ||
+            !["file_boundary", "dependency_boundary"].every(key => Array.isArray(d[key]) && (key !== "file_boundary" || d[key].length > 0) &&
+                d[key].every(nonblank)))
+            return refuse("renewed_scope_approval_required", "approved delta identity or boundary is absent");
+    }
+    return { ok: true, intent };
+}
+export function isRemainingWork(jobType, payload) {
+    if (["remediate", "rebase", "ci_fix", "reconcile_overlap", "resume"].includes(jobType))
+        return true;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return false;
+    const p = payload;
+    return p.correction_intent !== undefined || p.continuation !== undefined ||
+        p.continuation_of_job_id !== undefined || p.finalization !== undefined ||
+        p.remaining_checks !== undefined || p.required_checks_remaining !== undefined;
+}

package/build/executor/env.js

@@ -118,6 +118,7 @@ const SECRET_NAME_FRAGMENTS = ["TOKEN", "SECRET", "PASSWORD", "API_KEY"];
  * without anything in the executor choosing that.
  */
 export const EXPLICIT_DENY_KEYS = [
+    "BAPI_CORRECTION_INTENT_VERSION",
     "BRIDGE_MCP_PROFILE",
     // BAPI-1301: the per-job ownership tag. The executor injects a fresh,
     // unpredictable value AFTER this builder and the adapter have run
@@ -287,6 +288,11 @@ export function buildExecutorBaseWorkerEnv(parentEnv, options = {}) {
     env.POSTGRES_DATABASE = WORKER_SENTINEL_DATABASE_NAME;
     env.POSTGRES_DB = WORKER_SENTINEL_DATABASE_NAME;
     env.PGDATABASE = WORKER_SENTINEL_DATABASE_NAME;
+    if (options.correctionIntentVersion !== undefined) {
+        if (options.correctionIntentVersion !== 1)
+            throw new Error("unsupported correction intent version");
+        env.BAPI_CORRECTION_INTENT_VERSION = "1";
+    }
     if (typeof options.effectiveBaseBranch === "string" &&
         options.effectiveBaseBranch.length > 0) {
         env[PR_BASE_BRANCH_ENV_VAR] = options.effectiveBaseBranch;
@@ -323,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 {
@@ -294,6 +314,18 @@ export function createExecutorHttpClient(config) {
             // 5xx and any other unexpected status are retryable.
             return { kind: "retryable", error: `claim failed (HTTP ${status}): ${boundedDetail(text)}` };
         },
+        async scopeReadiness(job) {
+            const { status, text } = await post(`/${job.id}/scope-readiness`, { repo_name: job.repo_name, claim_token: job.claim_token }, job.repo_name);
+            if (status !== 200)
+                throw new Error(`scope readiness HTTP ${status}`);
+            const parsed = JSON.parse(text);
+            if (!parsed || typeof parsed !== "object" ||
+                !("decision" in parsed) ||
+                !["ready", "waiting", "blocked"].includes(String(parsed.decision))) {
+                throw new Error("scope readiness response malformed");
+            }
+            return parsed;
+        },
         // Heartbeat does NOT go through `mutate()`: it is the one mutation whose
         // response BODY carries information beyond the outcome (the BAPI-731 stop
         // request), so it maps the response itself instead of discarding the body.
@@ -371,6 +403,9 @@ export function createExecutorHttpClient(config) {
                 error_kind: failure.error_kind,
                 error_message: failure.error_message,
                 classification: failure.classification,
+                // BAPI-1330: the observed process exit, only when the runner has one —
+                // a failure without it keeps its exact pre-BAPI-1330 body.
+                ...(failure.exit_code !== undefined ? { exit_code: failure.exit_code } : {}),
                 local_commit_count: failure.local_commit_count,
                 last_commit_sha: failure.last_commit_sha,
                 telemetry: failure.telemetry,

package/build/executor/integration-job.js

@@ -703,13 +703,18 @@ export function buildIntegrationCorrectionJob(action, timeoutSeconds) {
         job_type: "rebase",
         ticket_key: action.epic_key,
         epic_run_id: action.epic_run_id,
-        payload: { prompt: action.correction_prompt ?? "", base_branch: action.base_branch },
+        payload: {
+            prompt: action.correction_prompt ?? "", base_branch: action.base_branch,
+            correction_intent: action.correction_intent ?? null,
+            integration_action_id: action.action_id,
+        },
         expected_branch: action.epic_branch,
         expected_head_sha: action.expected_epic_head_sha,
         lease_expires_at: action.lease_expires_at,
         attempt_count: 1,
         max_attempts: 1,
         timeout_seconds: timeoutSeconds,
+        required_capabilities: ["correction_intent.v1"],
     };
 }
 /**

package/build/executor/job-errors.js

@@ -28,10 +28,11 @@
  *    exited cleanly and its exact HEAD is durable on origin, but no usable pull
  *    request exists for that branch: none is visible, its URL is blank, its
  *    description is blank (BAPI-824 folded in), or it does not yet carry the
- *    pushed head. The work is COMPLETE and PUSHED — only the attachment is
- *    missing — so this kind is deliberately distinct from every other
- *    finalization failure, and its guidance names attachment and warns against
- *    deleting or rebasing the branch; see `worker-finalization.ts`.
+ *    pushed head. The commits are PUSHED and the attachment is missing; whether
+ *    the required work is finished or its checks passed is NOT established by
+ *    this kind (BAPI-1330). It stays distinct from every other finalization
+ *    failure, and its guidance names attachment and warns against deleting or
+ *    rebasing the branch; see `worker-finalization.ts`.
  *  - `WorkerFinalizationSavedButUnfinalized` — an implementation-style job
  *    (BAPI-762) exited cleanly, and an origin branch exists at an authoritative
  *    tip that does NOT match the worker's own HEAD — durable work exists on
@@ -40,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
@@ -132,6 +138,32 @@ export const WorkerFinalizationMissingRemoteBranchAndPr = "WorkerFinalizationMis
 export const WorkerFinalizationPrBaseMismatch = "WorkerFinalizationPrBaseMismatch";
 export const WorkerFinalizationPrNotAttached = "WorkerFinalizationPrNotAttached";
 export const WorkerFinalizationSavedButUnfinalized = "WorkerFinalizationSavedButUnfinalized";
+/**
+ * BAPI-1330: a COVERED attempt's publication could not be proven — the worker's
+ * full HEAD was unknown, or the pull request reported no head commit. Distinct
+ * from `WorkerFinalizationPrNotAttached` because nothing here was observed to be
+ * missing: the facts needed to decide were unavailable, so the finalization
+ * 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";
@@ -273,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}.
  *