@bridge_gpt/mcp-server 0.2.60 → 0.2.65

package/build/executor/job-types.js

@@ -4,8 +4,10 @@
  * Single source of truth for which claimed job types the executor spawns and
  * which of those are RECOVERY jobs. Recovery jobs (`remediate`/`ci_fix`/`rebase`/
  * `reconcile_overlap`) resume the ticket's existing branch/PR rather than cutting
- * a fresh branch off base — the first three through the `/implement-ticket <KEY>
- * --auto` correction loop, `reconcile_overlap` through its own job body. Dispatch
+ * a fresh branch off base — `remediate`/`rebase` through the `/implement-ticket
+ * <KEY> --auto` correction loop, `ci_fix` through its focused prompt spec
+ * (BAPI-1296: never the full recipe), `reconcile_overlap` through its own job
+ * body. Dispatch
  * (`job-runner.ts` `runClaimedJob`), prompt synthesis (`worker-command.ts`
  * `resolveExecutorPrompt`), and worktree reuse (`job-runner.ts` `prepareSpawn` →
  * `worktree.ts` `ensureExecutorWorktree`) all read from here so the recovery /
@@ -22,6 +24,12 @@
  * `reconcile_overlap`). They work on the ticket's EXISTING branch/PR, so the
  * executor reuses that branch instead of cutting a fresh one off base.
  *
+ * BAPI-1296: `ci_fix` stays a recovery job — and an implementation-style job
+ * below — for branch reuse, the worktree lock, and finalization, but prompt
+ * selection no longer follows recovery membership for it: `worker-command.ts`
+ * refuses to synthesize `/implement-ticket` for `ci_fix`, and `job-runner.ts`
+ * renders its server-authored focused prompt spec instead.
+ *
  * BAPI-1152: `reconcile_overlap` is a recovery job for worktree reuse and prompt
  * resolution, but it does NOT re-enter `/implement-ticket`: it always carries an
  * explicit server-rendered `payload.prompt`, which wins over the synthesis in

package/build/executor/observation.js

@@ -288,8 +288,10 @@ function parseRateLimitEvent(obj) {
  * Stated exactly once per line so an operator reading it cold understands what
  * happens next without cross-referencing the runbook.
  */
-const RATE_LIMIT_CONSEQUENCE_TEXT = "The executor keeps claiming: a worker that hits the ceiling fails fast and its " +
-    "job classifies as a worker failure under the normal retry budget.";
+const RATE_LIMIT_CONSEQUENCE_TEXT = "This warning is advisory only and triggers no waiting. Automatic capacity " +
+    "waiting happens only when the worker then fails with the supported terminal " +
+    "rejection and the server advertised capacity recovery for this job; otherwise " +
+    "the failure follows ordinary failure handling.";
 /** Fixed runbook reference appended to every rate-limit diagnostic (BAPI-898). */
 const RATE_LIMIT_RUNBOOK_REFERENCE = "See docs/claude/epic-implementer-v2-operator-runbook.md §8.";
 /**
@@ -354,6 +356,67 @@ export function parseClaudeStreamJsonLine(line) {
 function pickString(value) {
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
+/**
+ * The exact status that marks a terminal rejection. `allowed_warning`,
+ * `blocked`, and any unknown status are NOT terminal capacity: the first is a
+ * warning, and the others are not part of the supported contract.
+ */
+const TERMINAL_CAPACITY_REJECTED_STATUS = "rejected";
+/** Closed shape for a `rateLimitType` token the terminal parser will accept. */
+const TERMINAL_CAPACITY_LIMIT_TYPE_PATTERN = /^[a-z0-9_]{1,64}$/;
+/**
+ * Map the provider's limit window to a normalized cause. Long windows (the
+ * weekly ceilings) are account quota; shorter windows are rate limits.
+ */
+function terminalCapacityCauseFor(rateLimitType) {
+    return rateLimitType.startsWith("seven_day") ? "quota_exhausted" : "rate_limit_exhausted";
+}
+/**
+ * Parse ONE stream-json line for the supported terminal-capacity event, or
+ * `undefined` for anything else (BAPI-1258).
+ *
+ * Accepts only `{"type":"rate_limit_event","rate_limit_info":{"status":"rejected",
+ * "rateLimitType":<closed token>, "resetsAt"?:<number>}}`. Unknown event types,
+ * unknown statuses, malformed tokens, and malformed reset values all yield
+ * `undefined` (a bad reset drops only the reset, not the rejection). Never
+ * throws: a failure here only means "no confirmed evidence".
+ */
+export function parseClaudeTerminalCapacityLine(line, nowMs) {
+    try {
+        const trimmed = typeof line === "string" ? line.trim() : "";
+        if (trimmed.length === 0)
+            return undefined;
+        const parsed = JSON.parse(trimmed);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return undefined;
+        const obj = parsed;
+        if (obj.type !== "rate_limit_event")
+            return undefined;
+        const info = obj.rate_limit_info;
+        if (!info || typeof info !== "object" || Array.isArray(info))
+            return undefined;
+        const record = info;
+        if (record.status !== TERMINAL_CAPACITY_REJECTED_STATUS)
+            return undefined;
+        const rateLimitType = record.rateLimitType;
+        if (typeof rateLimitType !== "string" || !TERMINAL_CAPACITY_LIMIT_TYPE_PATTERN.test(rateLimitType)) {
+            return undefined;
+        }
+        if (!Number.isFinite(nowMs))
+            return undefined;
+        const observation = {
+            cause: terminalCapacityCauseFor(rateLimitType),
+            observed_at: new Date(nowMs).toISOString(),
+        };
+        const resetAt = normalizeRateLimitResetAt(record.resetsAt, nowMs);
+        if (resetAt !== undefined)
+            observation.retry_not_before = resetAt;
+        return observation;
+    }
+    catch {
+        return undefined;
+    }
+}
 // ---------------------------------------------------------------------------
 // MCP surface assertion (BAPI-790)
 // ---------------------------------------------------------------------------
@@ -528,8 +591,11 @@ export function createMcpSurfaceObserver(expectedServerNames, parseInitEvent) {
 export const MAX_BUFFERED_ADVISORY_LINE_CHARS = 1_048_576;
 /**
  * Create the observation state. When `advisoryParserEnabled` is false, stdout is
- * still timestamped (`last_stdout_at`) but never parsed — proving the advisory
- * parser is not load-bearing.
+ * still timestamped (`last_stdout_at`) but never parsed for advisory hints —
+ * proving the advisory parser is not load-bearing. The separate BAPI-1258
+ * terminal-capacity parser still reads lines unless
+ * `terminalCapacityParserEnabled` is `false`; it only ever yields "no evidence"
+ * on bad input, so ordinary success never depends on it either.
  */
 export function createObservationState(deps, options) {
     let git = {};
@@ -544,6 +610,15 @@ export function createObservationState(deps, options) {
      * — leaves this unchanged.
      */
     let rateLimit;
+    /**
+     * BAPI-1258: the terminal-capacity channel. The FIRST rejection fixes the
+     * cause and `observed_at`; a repeat of the same cause may only carry a later
+     * reset forward. A rejection with a DIFFERENT cause makes the evidence
+     * contradictory, and contradictory evidence is never reported.
+     */
+    let terminalCapacity;
+    let terminalCapacityContradictory = false;
+    const terminalCapacityParserEnabled = options.terminalCapacityParserEnabled !== false;
     /** Residual partial line carried across stdout chunks (BAPI-828). */
     let buffer = "";
     /** True while skipping the remainder of a line that blew the size cap. */
@@ -579,10 +654,37 @@ export function createObservationState(deps, options) {
             }
         }
     };
+    const consumeTerminalCapacityLine = (line) => {
+        if (terminalCapacityContradictory)
+            return;
+        const observed = parseClaudeTerminalCapacityLine(line, deps.now());
+        if (observed === undefined)
+            return;
+        if (terminalCapacity === undefined) {
+            terminalCapacity = observed;
+            return;
+        }
+        if (terminalCapacity.cause !== observed.cause) {
+            terminalCapacityContradictory = true;
+            terminalCapacity = undefined;
+            return;
+        }
+        if (observed.retry_not_before !== undefined &&
+            (terminalCapacity.retry_not_before === undefined ||
+                observed.retry_not_before > terminalCapacity.retry_not_before)) {
+            terminalCapacity = { ...terminalCapacity, retry_not_before: observed.retry_not_before };
+        }
+    };
+    const consumeLine = (line) => {
+        if (options.advisoryParserEnabled)
+            consumeAdvisoryLine(line);
+        if (terminalCapacityParserEnabled)
+            consumeTerminalCapacityLine(line);
+    };
     return {
         recordStdout(chunk) {
             advisory.last_stdout_at = new Date(deps.now()).toISOString();
-            if (!options.advisoryParserEnabled)
+            if (!options.advisoryParserEnabled && !terminalCapacityParserEnabled)
                 return;
             if (typeof chunk !== "string" || chunk.length === 0)
                 return;
@@ -605,7 +707,7 @@ export function createObservationState(deps, options) {
             buffer += input;
             let newlineAt = buffer.indexOf("\n");
             while (newlineAt !== -1) {
-                consumeAdvisoryLine(buffer.slice(0, newlineAt));
+                consumeLine(buffer.slice(0, newlineAt));
                 buffer = buffer.slice(newlineAt + 1);
                 newlineAt = buffer.indexOf("\n");
             }
@@ -625,7 +727,7 @@ export function createObservationState(deps, options) {
             // is harmless: a truncated line does not parse, and the first-wins guard
             // above makes a repeat parse of a complete line a no-op.
             if (buffer.length > 0)
-                consumeAdvisoryLine(buffer);
+                consumeLine(buffer);
         },
         setGitTelemetry(telemetry) {
             git = telemetry;
@@ -667,5 +769,10 @@ export function createObservationState(deps, options) {
                 residue.attempt_end_sha = attemptEndSha;
             return residue;
         },
+        terminalCapacity() {
+            if (terminalCapacityContradictory || terminalCapacity === undefined)
+                return undefined;
+            return { ...terminalCapacity };
+        },
     };
 }

package/build/executor/preflight.js

@@ -1,8 +1,11 @@
 import { DEFAULT_PROBE_TIMEOUT_MS } from "../agent-capabilities/types.js";
 import { inspectExecutorAgentAdapter, inspectionForFailedResolution, } from "../agent-launchers/executor-adapter-inspection.js";
 import { resolveExecutorAgentAdapter } from "../agent-launchers/executor-adapter-registry.js";
+import { resolveCompletionEvidenceCapability } from "../agent-launchers/executor-adapter.js";
+import { COMPLETION_EVIDENCE_CAPABILITY, REQUIRED_VERIFICATION_CAPABILITY, runtimeMatchesSupported, } from "./completion-contract.js";
 import { resolveExecutorAgentId } from "./agent-identity.js";
 import { resolveAllExecutorApiAccess, resolveBaseUrl, EXECUTOR_BASE_URL_REQUIRED_MESSAGE, } from "./credentials.js";
+import { FOCUSED_REBASE_CAPABILITY } from "./types.js";
 /**
  * Environment override for the deny probe's headless timeout (BAPI-722).
  *
@@ -80,6 +83,63 @@ export function createDenyProbeCache() {
         },
     };
 }
+/** Bound on a completion-evidence refusal reason (it is logged every cycle). */
+const COMPLETION_REFUSAL_MAX_CHARS = 200;
+/**
+ * BAPI-1301 (D4a) — decide whether this executor may advertise
+ * `completion_evidence.v1`.
+ *
+ * Probes the installed runtime through the adapter's declared probe and compares
+ * it with BOTH the adapter's declared identity and the approved identity the
+ * executor's lifecycle parser was measured against. Every mismatched field is
+ * named in the bounded reason; values are safe by construction (a parsed version
+ * or the `unrecognized` placeholder, closed platform ids, fixed schema names).
+ * Never throws and never produces a fatal finding.
+ */
+export async function evaluateCompletionEvidenceQualification(adapter, deps) {
+    const bounded = (text) => text.slice(0, COMPLETION_REFUSAL_MAX_CHARS);
+    const capability = resolveCompletionEvidenceCapability(adapter);
+    if (!capability.supported) {
+        return { qualified: false, refusal: bounded(capability.reason), runtime: null };
+    }
+    let probed;
+    try {
+        probed = await capability.value.probeRuntime({
+            runCommand: deps.runCommand,
+            platform: deps.platform,
+            // Absent → the adapter's default (`process.arch`); injectable for tests.
+            ...(deps.arch !== undefined ? { arch: deps.arch } : {}),
+        });
+    }
+    catch {
+        probed = null;
+    }
+    if (probed === null) {
+        return { qualified: false, refusal: "runtime identity probe did not run", runtime: null };
+    }
+    const declared = capability.value.runtime;
+    const mismatches = [];
+    for (const key of ["adapter", "cli_version", "platform", "event_schema"]) {
+        if (probed[key] !== declared[key]) {
+            mismatches.push(`${key} ${String(probed[key]).slice(0, 40)} != ${declared[key]}`);
+        }
+    }
+    if (mismatches.length > 0) {
+        return {
+            qualified: false,
+            refusal: bounded(`probed runtime differs from the approved identity: ${mismatches.join("; ")}`),
+            runtime: probed,
+        };
+    }
+    if (!runtimeMatchesSupported(probed)) {
+        return {
+            qualified: false,
+            refusal: "adapter-declared runtime is not the approved completion-evidence runtime",
+            runtime: probed,
+        };
+    }
+    return { qualified: true, refusal: null, runtime: probed };
+}
 /** Fail-fast report shape for a preflight that refused before probing. */
 function refusedPreflight(fatalFindings, warnings, adapter) {
     return {
@@ -346,6 +406,16 @@ export async function collectExecutorPreflight(options, deps, seams = {}) {
         }
     }
     warnings.push(...adapterInspection.inspection.warnings);
+    // --- Completion-evidence qualification (never fatal, BAPI-1301) --------
+    // Last, and outside `fatalFindings` on purpose: an executor that cannot
+    // supervise required work to completion is still a correct executor for every
+    // other job. It simply omits `completion_evidence.v1` from its claim manifest,
+    // and the server's claim filter keeps covered work away from it. One bounded
+    // line says why, so an operator expecting covered work can see the cause.
+    const completion = await evaluateCompletionEvidenceQualification(adapter, deps);
+    if (!completion.qualified && completion.refusal !== null) {
+        warnings.push(`completion evidence not advertised: ${completion.refusal}`);
+    }
     return {
         ok: fatalFindings.length === 0,
         fatalFindings,
@@ -356,6 +426,9 @@ export async function collectExecutorPreflight(options, deps, seams = {}) {
         ghAuthed,
         denyEnforced,
         adapter: adapterInspection.inspection,
+        completionEvidenceQualified: completion.qualified,
+        completionEvidenceRefusal: completion.refusal,
+        completionRuntime: completion.runtime,
     };
 }
 /**
@@ -379,6 +452,15 @@ export async function collectExecutorPreflight(options, deps, seams = {}) {
  * `undefined`-valued. For the same reason `repo_wide` is never serialized as
  * `false`: `false` is the server's default and means "not an opt-out", so
  * sending it would add a key that carries no information.
+ *
+ * BAPI-1301 (D4a) adds a third optional key, `capabilities`, under the same
+ * rule: `["completion_evidence.v1"]` only when preflight qualified the runtime.
+ *
+ * BAPI-1311 makes `capabilities` ADDITIVE: `focused_rebase.v1` is advertised by
+ * every executor this function builds a manifest for — a manifest is only built
+ * once ordinary preflight permits claiming — independently of completion-evidence
+ * qualification. The completion tokens keep their exact conditional behavior and
+ * order; the focused token is appended after them.
  */
 export function buildClaimManifest(report, options, freeSlots) {
     return {
@@ -392,5 +474,22 @@ export function buildClaimManifest(report, options, freeSlots) {
         disk_free_gb: report.diskFreeGb ?? 0,
         ...(options.epicRunIds !== undefined ? { epic_run_ids: options.epicRunIds } : {}),
         ...(options.repoWide === true ? { repo_wide: true } : {}),
+        // BAPI-1301 (D4a): advertised ONLY when preflight qualified the exact
+        // runtime; otherwise the key is absent (never `[]`), keeping the manifest's
+        // `Object.keys()` shape for every unqualified executor and older server.
+        // BAPI-1302 (D4c): a qualified executor also runs declared checks itself
+        // (`required-verification.ts`), so it advertises that it can claim a job
+        // carrying a required-verification declaration. An older server drops the
+        // unknown token (`normalize_declared_capabilities`), so it is safe to send.
+        // BAPI-1311: the focused-rebase token rides every claiming manifest, after
+        // any completion tokens. It is NOT a completion-evidence statement — rebase is
+        // not a covered job type — so it never waits on that qualification. An older
+        // server drops the unknown token (`normalize_declared_capabilities`).
+        capabilities: [
+            ...(report.completionEvidenceQualified === true
+                ? [COMPLETION_EVIDENCE_CAPABILITY, REQUIRED_VERIFICATION_CAPABILITY]
+                : []),
+            FOCUSED_REBASE_CAPABILITY,
+        ],
     };
 }