@bridge_gpt/mcp-server 0.2.58 → 0.2.59

package/build/plan-epic-implementer-eligibility.js

@@ -0,0 +1,215 @@
+/**
+ * Combined merge/review Epic Implementer eligibility assessment for `plan-epic` (BAPI-964).
+ *
+ * Runs once the epic decomposition's child manifest is frozen and every
+ * sub-task's exploration text is written, so this module can predict — before
+ * any Epic Implementer worker is spawned — which children are likely to trip the
+ * runtime workflow-file merge guard (`api/library/vcs/epic_implementer_merge_service.py`)
+ * and which of those additionally touch `claude-review.yml` itself, where
+ * automated review cannot run at all (BAPI-941's supply-chain preflight refuses
+ * to review a workflow that differs from the base branch's copy).
+ *
+ * The BROADER merge classification is delegated entirely to the Python
+ * classifier via one Bridge API call for the complete child set — this module
+ * never reimplements "what counts as a workflow file". The NARROWER review
+ * subclass is classified locally by checking each child's combined text for the
+ * full `CLAUDE_REVIEW_WORKFLOW_RELPATH`, imported (not re-declared) from
+ * `claude-review-workflow-drift.js`.
+ *
+ * Fails open, deliberately: any validation failure, classification failure, or
+ * internal contradiction (a review-subset child the backend did not also mark
+ * merge-blocked) becomes the explicit `unavailable` result — never a fabricated
+ * zero count. A caller that cannot get a real answer must say so, not guess.
+ */
+import { CLAUDE_REVIEW_WORKFLOW_RELPATH } from "./claude-review-workflow-drift.js";
+/**
+ * Build the real network-backed classification client that POSTs the complete
+ * child set to `/jira/planning/epic-workflow-eligibility` exactly once.
+ */
+export function createBridgeEpicImplementerEligibilityClient(deps) {
+    return {
+        async classifyChildren(children) {
+            const fetchImpl = deps.fetchImpl ?? fetch;
+            // S3 backend route seam: keep the existing endpoint until its API migration.
+            const resp = await fetchImpl(deps.buildUrl("/planning/epic-workflow-eligibility"), {
+                method: "POST",
+                headers: await deps.getPostHeaders(),
+                body: JSON.stringify({ repo_name: deps.repoName, children }),
+            });
+            if (!resp.ok) {
+                const errorText = await deps.handleResponse(resp);
+                throw new Error(`epic-workflow-eligibility classification request failed: ${resp.status}: ${errorText}`);
+            }
+            return (await resp.json());
+        },
+    };
+}
+const UNAVAILABLE = { status: "unavailable" };
+function isNonBlankString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+/** Shape-validate an evidence array: every element must be a string. */
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+/** Treat a missing/undefined optional field as empty text; reject a non-string value. */
+function optionalTextOrNull(value) {
+    if (value === undefined || value === null)
+        return "";
+    return typeof value === "string" ? value : null;
+}
+/** Deterministically assemble one child's scan text from its authoritative fields. */
+function buildCombinedText(child) {
+    return [child.title, child.scope, child.description, child.requirements]
+        .filter((part) => typeof part === "string" && part.length > 0)
+        .join("\n\n");
+}
+/** Validate the child collection at the module boundary. `null` means malformed. */
+function validateChildren(children) {
+    if (!Array.isArray(children) || children.length === 0)
+        return null;
+    const validated = [];
+    for (const child of children) {
+        if (child === null || typeof child !== "object")
+            return null;
+        if (!isNonBlankString(child.id) || !isNonBlankString(child.title))
+            return null;
+        const scope = optionalTextOrNull(child.scope);
+        const description = optionalTextOrNull(child.description);
+        const requirements = optionalTextOrNull(child.requirements);
+        if (scope === null || description === null || requirements === null)
+            return null;
+        validated.push({
+            id: child.id,
+            title: child.title,
+            combinedText: buildCombinedText({
+                id: child.id,
+                title: child.title,
+                scope,
+                description,
+                requirements,
+            }),
+        });
+    }
+    return validated;
+}
+/**
+ * Assess Epic Implementer merge/review eligibility for one frozen epic child set.
+ *
+ * Sends the complete ordered child set to the injected Bridge client exactly
+ * once. Never throws — every failure path (malformed input, client rejection,
+ * malformed backend response, an internal merge/review contradiction) resolves
+ * to the explicit `unavailable` result, diagnosed with `console.error` (never
+ * `console.log`, which is reserved for the MCP stdio transport).
+ */
+export async function assessEpicImplementerEligibility(children, deps) {
+    const validated = validateChildren(children);
+    if (validated === null) {
+        console.error("assessEpicImplementerEligibility: malformed child collection; unavailable.");
+        return UNAVAILABLE;
+    }
+    let response;
+    try {
+        response = await deps.client.classifyChildren(validated.map((child) => ({ child_id: child.id, combined_text: child.combinedText })));
+    }
+    catch (err) {
+        console.error("assessEpicImplementerEligibility: Bridge classification call failed:", err);
+        return UNAVAILABLE;
+    }
+    if (response === null ||
+        typeof response !== "object" ||
+        !Array.isArray(response.predictions) ||
+        !Number.isInteger(response.total_children) ||
+        response.total_children < 0 ||
+        !Number.isInteger(response.predicted_workflow_children) ||
+        response.predicted_workflow_children < 0 ||
+        !Number.isInteger(response.containment_children) ||
+        response.containment_children < 0 ||
+        typeof response.reason !== "string") {
+        console.error("assessEpicImplementerEligibility: malformed backend response shape; unavailable.");
+        return UNAVAILABLE;
+    }
+    if (response.predictions.length !== validated.length) {
+        console.error("assessEpicImplementerEligibility: backend prediction count does not match child count; unavailable.");
+        return UNAVAILABLE;
+    }
+    // The backend is contractually order-preserving; still verify identity and
+    // order rather than trusting it, so a reordered/duplicate/unknown response
+    // never silently mislabels a child's prediction.
+    const predictionById = new Map();
+    for (const prediction of response.predictions) {
+        if (prediction === null ||
+            typeof prediction !== "object" ||
+            !isNonBlankString(prediction.child_id) ||
+            typeof prediction.predicted_workflow_modified !== "boolean" ||
+            !isStringArray(prediction.matched_paths) ||
+            typeof prediction.predicted_containment_hazard !== "boolean" ||
+            !isStringArray(prediction.matched_hazards)) {
+            console.error("assessEpicImplementerEligibility: malformed per-child prediction; unavailable.");
+            return UNAVAILABLE;
+        }
+        if (prediction.predicted_containment_hazard !== (prediction.matched_hazards.length > 0)) {
+            console.error(`assessEpicImplementerEligibility: child ${prediction.child_id} has a containment flag that ` +
+                "disagrees with whether matched hazard evidence is present; unavailable.");
+            return UNAVAILABLE;
+        }
+        if (predictionById.has(prediction.child_id)) {
+            console.error("assessEpicImplementerEligibility: duplicate child_id in backend response; unavailable.");
+            return UNAVAILABLE;
+        }
+        predictionById.set(prediction.child_id, prediction);
+    }
+    const affectedChildren = [];
+    let reviewSubsetChildren = 0;
+    let predictedWorkflowChildren = 0;
+    let containmentChildren = 0;
+    for (const child of validated) {
+        const prediction = predictionById.get(child.id);
+        if (!prediction) {
+            console.error(`assessEpicImplementerEligibility: backend response is missing child ${child.id}; unavailable.`);
+            return UNAVAILABLE;
+        }
+        const reviewPathReferenced = child.combinedText.includes(CLAUDE_REVIEW_WORKFLOW_RELPATH);
+        if (reviewPathReferenced && !prediction.predicted_workflow_modified) {
+            // Subset invariant violated: a child naming claude-review.yml itself must
+            // also be in the broader merge-blocked set. Publishing this as a
+            // "review-only" child would contradict the merge count, so refuse instead.
+            console.error(`assessEpicImplementerEligibility: child ${child.id} references the review workflow ` +
+                "but the backend did not mark it merge-blocked; refusing contradictory result.");
+            return UNAVAILABLE;
+        }
+        if (prediction.predicted_workflow_modified) {
+            predictedWorkflowChildren += 1;
+            if (reviewPathReferenced)
+                reviewSubsetChildren += 1;
+        }
+        if (prediction.predicted_containment_hazard)
+            containmentChildren += 1;
+        // A child is affected — and therefore included — when it is workflow-modifying,
+        // containment-flagged, or both. Skip only a child that is neither.
+        if (!prediction.predicted_workflow_modified && !prediction.predicted_containment_hazard)
+            continue;
+        affectedChildren.push({
+            id: child.id,
+            title: child.title,
+            matchedPaths: [...prediction.matched_paths],
+            requiresHandReview: reviewPathReferenced,
+            requiresContainmentReview: prediction.predicted_containment_hazard,
+            matchedHazards: [...prediction.matched_hazards],
+        });
+    }
+    if (containmentChildren !== response.containment_children) {
+        console.error("assessEpicImplementerEligibility: containment_children count disagrees with the validated " +
+            "per-child containment flags; unavailable.");
+        return UNAVAILABLE;
+    }
+    return {
+        status: "assessed",
+        totalChildren: validated.length,
+        predictedWorkflowChildren,
+        reason: response.reason,
+        reviewSubsetChildren,
+        containmentChildren,
+        affectedChildren,
+    };
+}

package/build/plan-execution-ledger.js

@@ -43,6 +43,10 @@ export const PLAN_PROVENANCE_CLASSES = [
     "rendered_ui_review",
     "test_gap_review",
     "final_plan_review",
+    // BAPI-1223: the optimized posture's combined review/test stage. ONE class, not
+    // a test/review pair, because a single agent authors one contiguous body with
+    // interleaved test and review steps plus its deterministic floor repairs.
+    "combined_review_test",
 ];
 export const PLAN_PHASES = [
     "produce",
@@ -107,6 +111,10 @@ export const PLAN_CLASS_OWNERSHIP = Object.freeze({
     rendered_ui_review: "pre_pr_verification",
     test_gap_review: "pre_pr_verification",
     final_plan_review: "pre_pr_verification",
+    // BAPI-1223: mixed test and review work in one body. Both halves are settled
+    // by the phase that RUNS them, which is the same phase that owns the separate
+    // classes this one replaces — so the route change moves no ownership.
+    combined_review_test: "pre_pr_verification",
 });
 export const PRE_PR_VERIFICATION_LIMITS = Object.freeze({
     maxCorrectionTurns: 3,

package/build/plane/member-roster.js

@@ -13,7 +13,7 @@
  * - the dead-man observer is a SEPARATE member in its own OS process (R-1,
  *   BAPI-1029): the plane contains exactly one ordinary worker and exactly one
  *   dead-man-only observer, and only the observer's environment carries
- *   `CONDUCTOR_DEAD_MAN_ONLY`. The two are built from distinct environment
+ *   `EPIC_IMPLEMENTER_DEAD_MAN_ONLY`. The two are built from distinct environment
  *   objects so the observer flag can never reach the worker by reference —
  *   a plane whose "worker" is a second observer has nothing reconciling it.
  *   Independence here is process-level on ONE host; separate-host isolation is
@@ -132,7 +132,7 @@ export function resolvePlaneServerEndpoint(env) {
  * Build a child environment: a copy of the parent plus the resolved values the
  * existing processes already expect.
  *
- * `CONDUCTOR_DEAD_MAN_ONLY` is explicitly deleted rather than merely left
+ * `EPIC_IMPLEMENTER_DEAD_MAN_ONLY` is explicitly deleted rather than merely left
  * unset. An operator who exported it in this shell to run an observer would
  * otherwise silently turn the plane's reconciler worker into a second observer,
  * and the run would sit there with nothing reconciling it.
@@ -146,7 +146,7 @@ export function buildPlaneChildEnv(parentEnv, context) {
     env.BAPI_REPO_NAME = context.repoName;
     env.BAPI_BASE_URL = context.endpoint.baseUrl;
     env.BAPI_API_KEY = context.bridgeApiKey;
-    delete env.CONDUCTOR_DEAD_MAN_ONLY;
+    delete env[PLANE_OBSERVER_MODE_ENV];
     return env;
 }
 /**
@@ -159,7 +159,7 @@ export function buildPlaneChildEnv(parentEnv, context) {
  * the precise failure `buildPlaneChildEnv`'s `delete` exists to prevent, arrived
  * at from the other direction.
  *
- * Any `CONDUCTOR_DEADMAN_CHANNEL_TYPE` / `CONDUCTOR_DEADMAN_DESTINATION_REF` the
+ * Any `EPIC_IMPLEMENTER_DEADMAN_CHANNEL_TYPE` / `EPIC_IMPLEMENTER_DEADMAN_DESTINATION_REF` the
  * operator exported is inherited through the copy and is never read, echoed,
  * placed in argv, or written to the manifest here: the observer resolves its own
  * alert channel from its environment, exactly as a hand-started observer does.
@@ -251,7 +251,7 @@ export function buildPlaneMemberRoster(params) {
      * The independent dead-man observer (R-1, BAPI-1029).
      *
      * The SAME `worker.py` the ordinary worker runs, in its own OS process, with
-     * `CONDUCTOR_DEAD_MAN_ONLY=true` in its environment and nowhere else. No shell
+     * `EPIC_IMPLEMENTER_DEAD_MAN_ONLY=true` in its environment and nowhere else. No shell
      * string: `PLANE_OBSERVER_COMMAND` remains operator-facing prose while the
      * spawn is an executable plus an argument vector, so the mode flag never
      * passes through a shell that could log it or reorder it.

package/build/plane/supervisor.js

@@ -106,7 +106,7 @@ export function createLineReader(onLine) {
  * Rebuild the instance identity a spawned member publishes under.
  *
  * Mirrors `_resolve_process_instance_id` in
- * `api/library/epic_conductor/reconciler.py` exactly, because the string has to
+ * `api/library/epic_implementer/reconciler.py` exactly, because the string has to
  * MATCH: `DYNO` when that variable is set and non-blank after trimming,
  * otherwise `<hostname>:<pid>`, truncated to 128 characters. Python resolves it
  * once at import from the process's own environment and pid; this rebuilds it

package/build/plane/types.js

@@ -12,7 +12,7 @@
  *
  * - **R-1, the dead-man observer is a same-host, separate-process member**
  *   (BAPI-1029, superseding R-3). The observer runs `worker.py` with
- *   `CONDUCTOR_DEAD_MAN_ONLY=true` in its OWN OS process, owned by the plane
+ *   `EPIC_IMPLEMENTER_DEAD_MAN_ONLY=true` in its OWN OS process, owned by the plane
  *   lifecycle: it has a member name, a log path, and a manifest record, and
  *   `plane status` / `plane down` treat it like every other member. Its failure
  *   domain is independent at the PROCESS level — killing the reconciler leaves
@@ -143,15 +143,15 @@ export const PLANE_ID_ENV_VAR = "BAPI_PLANE_ID";
  * session-background FALLBACK still starts the observer by hand, and because an
  * operator debugging the plane needs to know exactly what the observer member is.
  */
-export const PLANE_OBSERVER_COMMAND = "CONDUCTOR_DEAD_MAN_ONLY=true python worker.py";
+export const PLANE_OBSERVER_COMMAND = "EPIC_IMPLEMENTER_DEAD_MAN_ONLY=true python worker.py";
 /** Env var that puts `worker.py` into dead-man-only mode. Observer member ONLY. */
-export const PLANE_OBSERVER_MODE_ENV = "CONDUCTOR_DEAD_MAN_ONLY";
+export const PLANE_OBSERVER_MODE_ENV = "EPIC_IMPLEMENTER_DEAD_MAN_ONLY";
 /** The exact value {@link PLANE_OBSERVER_MODE_ENV} is set to for the observer. */
 export const PLANE_OBSERVER_MODE_VALUE = "true";
 /** Env var naming the observer's alert channel type. */
-export const PLANE_OBSERVER_CHANNEL_TYPE_ENV = "CONDUCTOR_DEADMAN_CHANNEL_TYPE";
+export const PLANE_OBSERVER_CHANNEL_TYPE_ENV = "EPIC_IMPLEMENTER_DEADMAN_CHANNEL_TYPE";
 /** Env var naming the env var that holds the observer's destination URL. */
-export const PLANE_OBSERVER_DESTINATION_ENV = "CONDUCTOR_DEADMAN_DESTINATION_REF";
+export const PLANE_OBSERVER_DESTINATION_ENV = "EPIC_IMPLEMENTER_DEADMAN_DESTINATION_REF";
 /** Build a {@link PlaneCheckReport} for a check that ran and passed. */
 export function planeCheckPassed(check, label, detail) {
     return {

package/build/readiness-check.js

@@ -147,7 +147,7 @@ const POSIX_PATH_ROOTS = [
  * Deliberately narrow: it catches the obvious leak (`/Users/...`, `/private/tmp/...`,
  * `C:\\...`) without rejecting the relative, repository-conventional paths
  * remediations legitimately name (`.github/workflows/claude-review.yml`,
- * `docs/claude/epic-conductor-v2-operator-runbook.md`) or the approved setup
+ * `docs/claude/epic-implementer-v2-operator-runbook.md`) or the approved setup
  * URLs (`https://host/setup`) — note the Windows drive alternative requires a
  * word boundary before the letter, so the `s:/` inside `https://` is not a hit.
  */