@bridge_gpt/mcp-server 0.2.62 → 0.2.66

package/build/executor/http-client.js

@@ -22,17 +22,60 @@ function isCapacityEvidenceRefusal(status, bodyText) {
         return true;
     if (status !== 409)
         return false;
+    return readDetailErrorCode(bodyText) === UNSUPPORTED_TERMINAL_CAPACITY_ERROR_CODE;
+}
+/**
+ * BAPI-1301 (D4a) — the server's stable `error_code` when a covered `/complete`
+ * carries an envelope that does not prove the attempt finished its required
+ * work. The job is still claimed; the executor must report `/fail` (with the
+ * same envelope) instead.
+ */
+export const COMPLETION_EVIDENCE_REFUSES_SUCCESS_ERROR_CODE = "COMPLETION_EVIDENCE_REFUSES_SUCCESS";
+/**
+ * Read the stable `detail.error_code` token from an error body, or null. Only
+ * that one closed token is inspected; nothing else in the body is retained.
+ */
+function readDetailErrorCode(bodyText) {
     try {
         const parsed = JSON.parse(bodyText);
         const detail = parsed && typeof parsed === "object" ? parsed.detail : undefined;
-        return (!!detail &&
-            typeof detail === "object" &&
-            detail.error_code === UNSUPPORTED_TERMINAL_CAPACITY_ERROR_CODE);
+        if (!detail || typeof detail !== "object")
+            return null;
+        const code = detail.error_code;
+        return typeof code === "string" ? code : null;
     }
     catch {
-        return false;
+        return null;
     }
 }
+/**
+ * BAPI-1301 (D4a) — whether a `/complete` response refused SUCCESS for a covered
+ * job because its completion evidence cannot support it: a 409 whose
+ * `error_code` is exactly {@link COMPLETION_EVIDENCE_REFUSES_SUCCESS_ERROR_CODE}.
+ *
+ * Mirrors {@link isCapacityEvidenceRefusal}'s shape, but is exported and NOT
+ * wired into `mapMutationResponse`: the mutation mapping stays unchanged (a 409
+ * still maps to `stale_claim` for every caller that does not ask), and the job
+ * runner — which holds the envelope — decides to re-report as `/fail`. A 409
+ * `STALE_CLAIM` is never a refusal: the claim is gone and a re-send cannot help.
+ */
+export function isCompletionEvidenceRefusal(status, bodyText) {
+    if (status !== 409)
+        return false;
+    return readDetailErrorCode(bodyText) === COMPLETION_EVIDENCE_REFUSES_SUCCESS_ERROR_CODE;
+}
+/**
+ * BAPI-1301 (D4a) — normalize a claim response's `required_capabilities`. Only an
+ * array of strings is admitted; anything else (absent on an older server, null,
+ * malformed) reads as `[]` — "no requirement", which is exactly what an older
+ * server's rows mean. A malformed value can never manufacture a requirement the
+ * executor would then refuse to run.
+ */
+export function normalizeRequiredCapabilities(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.every((entry) => typeof entry === "string") ? [...value] : [];
+}
 /** Bound a server-provided diagnostic snippet included in error strings. */
 function boundedDetail(text) {
     const trimmed = (text ?? "").trim();
@@ -142,6 +185,22 @@ function toConductorGetFetch(fetchLike) {
         };
     };
 }
+/**
+ * BAPI-1301 (D4a) — the completion-contract fields of a terminal report, each
+ * present only when set. Omitting an undefined key (rather than sending it as
+ * `undefined`/`null`) keeps a legacy terminal body byte-identical, which an
+ * older server's strict `extra="forbid"` schema depends on.
+ */
+function completionContractFields(report) {
+    return {
+        ...(report.completion_contract !== undefined
+            ? { completion_contract: report.completion_contract }
+            : {}),
+        ...(report.completion_evidence !== undefined
+            ? { completion_evidence: report.completion_evidence }
+            : {}),
+    };
+}
 export function createExecutorHttpClient(config) {
     const base = config.baseUrl.replace(/\/+$/, "") + "/executor/jobs";
     function keyForRepo(repoName) {
@@ -206,6 +265,12 @@ export function createExecutorHttpClient(config) {
                     if (!job || typeof job !== "object" || typeof job.claim_token !== "string") {
                         return { kind: "fatal", error: "claim returned a malformed job payload" };
                     }
+                    // BAPI-1301 (D4a): the requirement is normalized in place only when
+                    // the server sent the key, so an older server's claim keeps its exact
+                    // shape; a present-but-malformed value reads as "no requirement".
+                    if ("required_capabilities" in job) {
+                        job.required_capabilities = normalizeRequiredCapabilities(job.required_capabilities);
+                    }
                     return { kind: "claimed", job, reconcilerLiveness };
                 }
                 catch {
@@ -229,6 +294,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.
@@ -242,6 +319,11 @@ export function createExecutorHttpClient(config) {
                     local_commit_count: payload.local_commit_count,
                     last_commit_sha: payload.last_commit_sha,
                     telemetry: payload.telemetry,
+                    // BAPI-1301 (D4a): the key is added only when present, so a legacy
+                    // heartbeat body is byte-identical for an older server.
+                    ...(payload.ownership_context !== undefined
+                        ? { ownership_context: payload.ownership_context }
+                        : {}),
                 };
                 const res = await post(`/${job.id}/heartbeat`, body, job.repo_name);
                 status = res.status;
@@ -290,6 +372,7 @@ export function createExecutorHttpClient(config) {
                 local_commit_count: completion.local_commit_count,
                 last_commit_sha: completion.last_commit_sha,
                 telemetry: completion.telemetry,
+                ...completionContractFields(completion),
             };
             return mutate(`/${job.id}/complete`, body, true, job.repo_name);
         },
@@ -300,9 +383,13 @@ 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,
+                ...completionContractFields(failure),
             };
             if (failure.capacity_evidence === undefined) {
                 return mutate(`/${job.id}/fail`, body, false, job.repo_name);

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

@@ -13,6 +13,10 @@
  *    never pushed, so there is nothing to recreate from (TDD §7).
  *  - `BranchMismatch` — a `resume` worktree is on the wrong branch; working there
  *    would corrupt an unrelated branch, so abort rather than proceed (TDD §7).
+ *  - `ContinuationWorktreeMissing` / `ContinuationLineageMismatch` — a parked-child
+ *    continuation (BAPI-1300) could not prove its retained work: the worktree is
+ *    gone, or its HEAD does not descend from the authorized head. Refused before
+ *    any local mutation; never recreated, reset, or cleaned.
  *  - `WorkerFinalizationMissingRemoteBranchAndPr` — an implementation-style job
  *    (BAPI-551) exited cleanly but produced neither a PR URL nor a pushed origin
  *    branch, stranding the implement gate; see `worker-finalization.ts`.
@@ -24,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
@@ -112,10 +117,30 @@ import { normalizeMcpServerNames } from "./observation.js";
 export const MissingVerdictArtifact = "MissingVerdictArtifact";
 export const WorktreeLostBeforePush = "WorktreeLostBeforePush";
 export const BranchMismatch = "BranchMismatch";
+/**
+ * BAPI-1300: a parked-child CONTINUATION found no retained worktree for its
+ * branch. A continuation never recreates one from origin — that would silently
+ * drop unpushed work the continuation exists to carry — so it refuses instead.
+ */
+export const ContinuationWorktreeMissing = "ContinuationWorktreeMissing";
+/**
+ * BAPI-1300: the retained worktree's HEAD does not descend from the head the
+ * continuation was authorized against. Checked BEFORE the WIP checkpoint, so an
+ * unrelated history is never committed onto and never adopted as the new head.
+ */
+export const ContinuationLineageMismatch = "ContinuationLineageMismatch";
 export const WorkerFinalizationMissingRemoteBranchAndPr = "WorkerFinalizationMissingRemoteBranchAndPr";
 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";
 export const WorkerConfigIsolation = "ContractError.WorkerConfigIsolation";
 export const PreSpawnVerification = "ContractError.PreSpawnVerification";
 export const BridgeCredentialUnavailable = "ContractError.BridgeCredentialUnavailable";
@@ -139,6 +164,38 @@ export const StaleArtifactCleanupFailed = "ContractError.StaleArtifactCleanupFai
  * than proceeding on an unverified premise.
  */
 export const WorkerEnvFilePresent = "ContractError.WorkerEnvFilePresent";
+/**
+ * BAPI-1296: a `ci_fix` job could not be run as a FOCUSED repair. Raised before
+ * any worktree effect when the payload's focused contract is missing, malformed,
+ * or carries an explicit prompt (a legacy full-recipe prompt included), and under
+ * the worktree lock when the prepared checkout's repository, branch, or HEAD does
+ * not match the dispatched CI observation. The message carries a fixed
+ * `reason=<code>` token and never ticket, check, or log text. The job is refused
+ * rather than downgraded to `/implement-ticket`: re-running the whole recipe to
+ * fix one check is the cost this contract removes.
+ */
+export const CiFixContext = "ContractError.CiFixContext";
+/**
+ * BAPI-1311: a `rebase` job carrying a `payload.focused_rebase` context could not
+ * be run as a FOCUSED merge-stage repair — an unsupported context version, a
+ * malformed or missing field, a blank server prompt, an identity that does not
+ * match the claimed job, or a claim that lacks the focused capability. Raised
+ * before any worktree effect. The message carries a fixed `reason=<code>` token
+ * and never prompt, ticket, or payload text. The job is refused rather than
+ * reinterpreted as a legacy rebase or downgraded to `/implement-ticket`.
+ */
+export const FocusedRebaseContext = "ContractError.FocusedRebaseContext";
+/**
+ * BAPI-1311: a focused rebase pushed its repair but the post-push wait PROVED it
+ * cannot succeed — a required check concluded red at the pushed head, the pull
+ * request closed or reads unmergeable, or the bound pull request / head / head
+ * branch / base changed. The SAME kind the server records when its completion
+ * verifier rejects a rebase (`REBASE_CONTRACT_ERROR_KIND` in
+ * `api/library/epic_implementer/rebase_completion_contract.py`), so an executor-
+ * observed and a server-observed contract miss read as one state. Unavailable
+ * evidence at the deadline is NOT this kind; it is the ordinary `Timeout`.
+ */
+export const RebaseNotVerified = "ContractError.RebaseNotVerified";
 /**
  * BAPI-1152 — `reconcile_overlap` failure kinds. Each names ONE way the
  * wrapper's merge-into-child could not reach a verified push, so an operator