@bridge_gpt/mcp-server 0.2.62 → 0.2.66

package/build/executor/job-types.js

@@ -4,8 +4,8 @@
  * 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. Each recovery worker requires a versioned focused
+ * correction intent; `ci_fix` also uses its focused prompt spec. 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,10 +22,13 @@
  * `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-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
- * `worker-command.ts`, and `job-runner.ts` dispatches it to its own body.
+ * `ci_fix` stays a recovery job for branch reuse, the worktree lock, and
+ * finalization. `job-runner.ts` renders its server-authored focused prompt spec
+ * after the correction intent is validated.
+ *
+ * `reconcile_overlap` is a recovery job for worktree reuse and prompt
+ * resolution. Its server-rendered focused prompt is available only after
+ * validating the correction intent, and `job-runner.ts` dispatches its body.
  *
  * BAPI-1160: `ci_rerun` is DELIBERATELY ABSENT from this set and from
  * `SPAWN_JOB_TYPES` below. It is a deterministic actuator — one bounded

package/build/executor/preflight.js

@@ -1,8 +1,17 @@
 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 { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { defaultResolveBinPath } from "../start-tickets-conductor.js";
+import { CORRECTION_INTENT_CAPABILITY } from "./correction-dispatch.js";
 import { resolveAllExecutorApiAccess, resolveBaseUrl, EXECUTOR_BASE_URL_REQUIRED_MESSAGE, } from "./credentials.js";
+import { FOCUSED_REBASE_CAPABILITY, SCOPE_WAIT_CAPABILITY } from "./types.js";
 /**
  * Environment override for the deny probe's headless timeout (BAPI-722).
  *
@@ -80,6 +89,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 {
@@ -94,6 +160,62 @@ function refusedPreflight(fatalFindings, warnings, adapter) {
         adapter,
     };
 }
+const CORRECTION_HOOK_FIXTURE_ID = "correction-entry-nested-v1";
+/** Exercise the packaged hook process, including a nested-agent entry attempt. */
+export function probeInstalledCorrectionHook(worktreePath, binPath = defaultResolveBinPath("worker-guard-hook-bin.js")) {
+    const args = [binPath, "--worktree-root", worktreePath,
+        "--correction-intent-version", "1"];
+    const env = { ...process.env, BAPI_CORRECTION_INTENT_VERSION: "1" };
+    const fixtures = [
+        { payload: { tool_name: "Skill", tool_input: { skill: "bridge-implement-ticket" } }, status: 2 },
+        { payload: { tool_name: "Task", tool_input: { prompt: "/implement-ticket BAPI-1 --auto" } }, status: 2 },
+        { payload: { tool_name: "Read", tool_input: { file_path: "commands/src/implement-ticket.md" } }, status: 2 },
+        { payload: { tool_name: "mcp__bridge_api__request_plan_generation", tool_input: {} }, status: 2 },
+        { payload: { tool_name: "mcp__bridge_api__get_plan", tool_input: { ticket_number: "BAPI-1" } }, status: 0 },
+    ];
+    return fixtures.every(({ payload, status }) => {
+        const result = spawnSync(process.execPath, args, {
+            input: JSON.stringify(payload), encoding: "utf8", env, timeout: 5000,
+        });
+        return result.error === undefined && result.status === status;
+    });
+}
+export async function qualifyCorrectionIntentRuntime(adapter, deps, probeHook = probeInstalledCorrectionHook) {
+    if (adapter.identity.strategyId !== "claude-strict-mcp-v1" ||
+        adapter.denyEnforcement?.supported !== true || !deps.writeFile || !deps.mkdir) {
+        return { qualified: false, evidence: null };
+    }
+    const worktree = await (deps.mkdtemp ?? mkdtemp)(join((deps.tmpdir ?? tmpdir)(), "bridge-correction-hook-"));
+    try {
+        const bin = defaultResolveBinPath("worker-guard-hook-bin.js");
+        const installed = await adapter.denyEnforcement.value.provisionWorktreeDenyLayer({
+            worktreePath: worktree, baseBranch: "main", homedir: deps.homedir(),
+            workerBranch: "feature/probe", workerGuardHookBinPath: bin,
+            correctionIntentVersion: 1,
+        });
+        const settings = await deps.readFile(join(worktree, ".claude", "settings.local.json"));
+        const hookInstalled = installed.ok && settings.includes(bin) &&
+            settings.includes("--correction-intent-version 1") && settings.includes("PreToolUse");
+        const nestedDenial = hookInstalled && probeHook(worktree, bin);
+        return {
+            qualified: hookInstalled && nestedDenial,
+            evidence: {
+                version: 1, hook_installed: hookInstalled, nested_denial: nestedDenial,
+                fixture_id: CORRECTION_HOOK_FIXTURE_ID,
+                runtime: `${adapter.identity.adapterId}:${process.version}`,
+            },
+        };
+    }
+    catch {
+        return { qualified: false, evidence: null };
+    }
+    finally {
+        if (deps.rmRecursive)
+            await deps.rmRecursive(worktree);
+        else
+            await rm(worktree, { recursive: true, force: true });
+    }
+}
 /**
  * Collect the executor preflight report. Populates the manifest fields and
  * accumulates fatal findings — the runner refuses to claim when any exist.
@@ -116,7 +238,15 @@ export async function collectExecutorPreflight(options, deps, seams = {}) {
             // preflight's own injected `readFile` keeps the inspection hermetic in
             // tests and read-only in production — the adapter never opens a file
             // handle this module did not hand it.
-            claude: { readFile: deps.readFile },
+            claude: {
+                readFile: deps.readFile,
+                ...(deps.writeFile && deps.mkdir ? {
+                    denyProvisioningDeps: {
+                        readFile: deps.readFile, writeFile: deps.writeFile,
+                        mkdir: deps.mkdir, homedir: deps.homedir,
+                    },
+                } : {}),
+            },
         }));
     const resolution = resolveAdapter(agentId);
     if (!resolution.supported) {
@@ -346,6 +476,30 @@ 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}`);
+    }
+    let correction = {
+        qualified: false, evidence: null,
+    };
+    if (fatalFindings.length === 0) {
+        try {
+            correction = await qualifyCorrectionIntentRuntime(adapter, deps);
+        }
+        catch {
+            correction = { qualified: false, evidence: null };
+        }
+    }
+    if (!correction.qualified) {
+        warnings.push("correction intent not advertised: installed nested hook unverified");
+    }
     return {
         ok: fatalFindings.length === 0,
         fatalFindings,
@@ -356,6 +510,11 @@ export async function collectExecutorPreflight(options, deps, seams = {}) {
         ghAuthed,
         denyEnforced,
         adapter: adapterInspection.inspection,
+        completionEvidenceQualified: completion.qualified,
+        completionEvidenceRefusal: completion.refusal,
+        completionRuntime: completion.runtime,
+        correctionIntentQualified: correction.qualified,
+        correctionQualificationEvidence: correction.evidence,
     };
 }
 /**
@@ -379,6 +538,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 +560,25 @@ 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,
+            SCOPE_WAIT_CAPABILITY,
+            ...(report.correctionIntentQualified === true ? [CORRECTION_INTENT_CAPABILITY] : []),
+            ...(report.correctionIntentQualified === true ? ["ci_evidence.v1"] : []),
+        ],
     };
 }