@bridge_gpt/mcp-server 0.2.58 → 0.2.60

package/build/{plan-epic-conductor-eligibility.js → plan-epic-implementer-eligibility.js}

@@ -1,9 +1,9 @@
 /**
- * Combined merge/review conductor-eligibility assessment for `plan-epic` (BAPI-964).
+ * 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 conductor worker is spawned — which children are likely to trip the
+ * 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
@@ -26,17 +26,19 @@ import { CLAUDE_REVIEW_WORKFLOW_RELPATH } from "./claude-review-workflow-drift.j
  * Build the real network-backed classification client that POSTs the complete
  * child set to `/jira/planning/epic-workflow-eligibility` exactly once.
  */
-export function createBridgeEpicConductorEligibilityClient(deps) {
+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) {
-                throw new Error(`epic-workflow-eligibility classification request failed: ${resp.status}`);
+                const errorText = await deps.handleResponse(resp);
+                throw new Error(`epic-workflow-eligibility classification request failed: ${resp.status}: ${errorText}`);
             }
             return (await resp.json());
         },
@@ -92,7 +94,7 @@ function validateChildren(children) {
     return validated;
 }
 /**
- * Assess conductor merge/review eligibility for one frozen epic child set.
+ * 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,
@@ -100,10 +102,10 @@ function validateChildren(children) {
  * to the explicit `unavailable` result, diagnosed with `console.error` (never
  * `console.log`, which is reserved for the MCP stdio transport).
  */
-export async function assessEpicConductorEligibility(children, deps) {
+export async function assessEpicImplementerEligibility(children, deps) {
     const validated = validateChildren(children);
     if (validated === null) {
-        console.error("assessEpicConductorEligibility: malformed child collection; unavailable.");
+        console.error("assessEpicImplementerEligibility: malformed child collection; unavailable.");
         return UNAVAILABLE;
     }
     let response;
@@ -111,7 +113,7 @@ export async function assessEpicConductorEligibility(children, deps) {
         response = await deps.client.classifyChildren(validated.map((child) => ({ child_id: child.id, combined_text: child.combinedText })));
     }
     catch (err) {
-        console.error("assessEpicConductorEligibility: Bridge classification call failed:", err);
+        console.error("assessEpicImplementerEligibility: Bridge classification call failed:", err);
         return UNAVAILABLE;
     }
     if (response === null ||
@@ -124,11 +126,11 @@ export async function assessEpicConductorEligibility(children, deps) {
         !Number.isInteger(response.containment_children) ||
         response.containment_children < 0 ||
         typeof response.reason !== "string") {
-        console.error("assessEpicConductorEligibility: malformed backend response shape; unavailable.");
+        console.error("assessEpicImplementerEligibility: malformed backend response shape; unavailable.");
         return UNAVAILABLE;
     }
     if (response.predictions.length !== validated.length) {
-        console.error("assessEpicConductorEligibility: backend prediction count does not match child count; unavailable.");
+        console.error("assessEpicImplementerEligibility: backend prediction count does not match child count; unavailable.");
         return UNAVAILABLE;
     }
     // The backend is contractually order-preserving; still verify identity and
@@ -143,16 +145,16 @@ export async function assessEpicConductorEligibility(children, deps) {
             !isStringArray(prediction.matched_paths) ||
             typeof prediction.predicted_containment_hazard !== "boolean" ||
             !isStringArray(prediction.matched_hazards)) {
-            console.error("assessEpicConductorEligibility: malformed per-child prediction; unavailable.");
+            console.error("assessEpicImplementerEligibility: malformed per-child prediction; unavailable.");
             return UNAVAILABLE;
         }
         if (prediction.predicted_containment_hazard !== (prediction.matched_hazards.length > 0)) {
-            console.error(`assessEpicConductorEligibility: child ${prediction.child_id} has a containment flag that ` +
+            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("assessEpicConductorEligibility: duplicate child_id in backend response; unavailable.");
+            console.error("assessEpicImplementerEligibility: duplicate child_id in backend response; unavailable.");
             return UNAVAILABLE;
         }
         predictionById.set(prediction.child_id, prediction);
@@ -164,7 +166,7 @@ export async function assessEpicConductorEligibility(children, deps) {
     for (const child of validated) {
         const prediction = predictionById.get(child.id);
         if (!prediction) {
-            console.error(`assessEpicConductorEligibility: backend response is missing child ${child.id}; unavailable.`);
+            console.error(`assessEpicImplementerEligibility: backend response is missing child ${child.id}; unavailable.`);
             return UNAVAILABLE;
         }
         const reviewPathReferenced = child.combinedText.includes(CLAUDE_REVIEW_WORKFLOW_RELPATH);
@@ -172,7 +174,7 @@ export async function assessEpicConductorEligibility(children, deps) {
             // 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(`assessEpicConductorEligibility: child ${child.id} references the review workflow ` +
+            console.error(`assessEpicImplementerEligibility: child ${child.id} references the review workflow ` +
                 "but the backend did not mark it merge-blocked; refusing contradictory result.");
             return UNAVAILABLE;
         }
@@ -197,7 +199,7 @@ export async function assessEpicConductorEligibility(children, deps) {
         });
     }
     if (containmentChildren !== response.containment_children) {
-        console.error("assessEpicConductorEligibility: containment_children count disagrees with the validated " +
+        console.error("assessEpicImplementerEligibility: containment_children count disagrees with the validated " +
             "per-child containment flags; unavailable.");
         return UNAVAILABLE;
     }

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/cli.js

@@ -469,6 +469,27 @@ async function runUpAction(options, sinks, overrides) {
     }
     return launch.exitCode;
 }
+/**
+ * Format one diagnostic as one or more sink lines (BAPI-1237).
+ *
+ * `formatDiagnostic` returns a single string, but a diagnostic's `message` can
+ * itself be multiline — the shared legacy-environment guard's message is its
+ * own fixed header plus one `key -> successor` line per offending key. Writing
+ * that whole string through a single sink call would bury every line after the
+ * first inside one write, so this splits on newline boundaries and lets each
+ * substantive line become its own element — preserving the deterministic order
+ * the guard already produced.
+ *
+ * The final EMPTY element is dropped, never any other: it exists only because
+ * `runLegacyEpicImplementerEnvPreflight`'s formatter ends its block with a
+ * trailing newline, which is block punctuation, not a line to render.
+ */
+function formatDiagnosticLines(diagnostic) {
+    const lines = formatDiagnostic(diagnostic).split("\n");
+    if (lines.length > 0 && lines[lines.length - 1].length === 0)
+        lines.pop();
+    return lines;
+}
 /**
  * The aggregate preflight refusal, as lines.
  *
@@ -482,7 +503,7 @@ export function formatPlanePreflightRefusal(preflight) {
         "plane up REFUSED — preflight found blocking problems:",
         ...preflight.diagnostics
             .filter((d) => d.severity === "blocking")
-            .map((d) => formatDiagnostic(d)),
+            .flatMap((d) => formatDiagnosticLines(d)),
         "",
         `Fix every item above and retry. ${PLANE_NOTHING_STARTED}.`,
     ];
@@ -792,7 +813,8 @@ async function runRuntimeAction(options, overrides) {
         sinks.stderr("");
         sinks.stderr("plane runtime REFUSED — preflight found blocking problems:");
         for (const diagnostic of preflight.diagnostics.filter((d) => d.severity === "blocking")) {
-            sinks.stderr(formatDiagnostic(diagnostic));
+            for (const line of formatDiagnosticLines(diagnostic))
+                sinks.stderr(line);
         }
         sinks.stderr("");
         sinks.stderr(`${PLANE_NOTHING_STARTED}.`);

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/preflight.js

@@ -13,6 +13,7 @@
  */
 import path from "path";
 import { PLANE_SERVER_PORT_ENV_VAR, planeCheckFinding, planeCheckPassed, } from "./types.js";
+import { runLegacyEpicImplementerEnvPreflight } from "../epic-implementer-env.js";
 import { checkPlaneBuildFreshness, checkPlaneRuntimeEntrypoint } from "./build-freshness.js";
 import { checkAlembicHead } from "./alembic-head.js";
 import { manifestHasLiveProcess, planeManifestLifecycle, probeManifestMembers, readPlaneManifest, } from "./manifest.js";
@@ -163,6 +164,50 @@ const ROOT_DEPENDENT_CHECKS = [
     ["alembic-head", "alembic-head", "Database migration head"],
     ["existing-plane", "existing-plane", "Existing plane"],
 ];
+/** Fixed detail for a prerequisite skipped because the legacy-environment guard refused first. */
+const PLANE_LEGACY_ENVIRONMENT_SKIP_DETAIL = "not run — the legacy-environment guard refused first";
+/**
+ * Every prerequisite `runPlanePreflight` short-circuits past when the shared
+ * legacy-environment guard finds an old name (BAPI-1237).
+ *
+ * `repository-root` is included here, unlike {@link ROOT_DEPENDENT_CHECKS}: the
+ * legacy-environment guard is the FIRST check, running even before repository
+ * root is confirmed, so a hit skips everything else the same way a bad root
+ * skips everything after it.
+ */
+const LEGACY_ENVIRONMENT_DEPENDENT_CHECKS = [
+    ["repository-root", "repository-root", "Repository root"],
+    ...ROOT_DEPENDENT_CHECKS,
+];
+/** Fixed remediation for a legacy Conductor / dead-man environment variable still set. */
+export const PLANE_LEGACY_ENVIRONMENT_REMEDIATION = "rename or remove each legacy variable named above to its EPIC_IMPLEMENTER_* successor, then retry.";
+/**
+ * Run the shared legacy Epic Implementer / dead-man environment guard as a
+ * plane preflight check (BAPI-1237).
+ *
+ * Key-only and non-mutating: this adapter never reads a legacy value,
+ * translates a key, deletes a key, or constructs a successor value from a
+ * supplied value. It only asks the shared guard — the same one `epic-implementer-env.ts`
+ * exports for every other guarded entry point — whether any old name is
+ * present in the INJECTED preflight environment, and renders its one fixed
+ * multiline diagnostic as a blocking finding when it is.
+ */
+function checkLegacyEnvironment(env) {
+    const label = "Legacy environment";
+    let captured = "";
+    const hit = runLegacyEpicImplementerEnvPreflight(env, (chunk) => {
+        captured += chunk;
+    });
+    if (hit === 0) {
+        return planeCheckPassed("legacy-environment", label, "no legacy Conductor or dead-man environment variable is set");
+    }
+    return planeCheckFinding({
+        check: "legacy-environment",
+        severity: "blocking",
+        message: captured,
+        remediation: PLANE_LEGACY_ENVIRONMENT_REMEDIATION,
+    }, label, "a legacy Conductor or dead-man environment variable is still set");
+}
 /** Bound on the port probe so a black-holed port cannot stall bring-up. */
 export const PLANE_PORT_PROBE_TIMEOUT_MS = 1_500;
 /**
@@ -188,6 +233,23 @@ export async function runPlanePreflight(repoRoot, deps) {
         outcomes.push(...report.outcomes);
         return report;
     };
+    // BAPI-1237: the shared legacy-environment guard runs FIRST — before
+    // repository inspection, filesystem setup, subprocess execution, port
+    // probing, or credential resolution — so a legacy Conductor/dead-man name
+    // blocks before any of those collaborators run, not merely before launch.
+    const legacyEnvironment = record(checkLegacyEnvironment(deps.env));
+    if (legacyEnvironment.diagnostic) {
+        for (const [check, id, label] of LEGACY_ENVIRONMENT_DEPENDENT_CHECKS) {
+            outcomes.push({
+                check,
+                id,
+                label,
+                status: "skip",
+                detail: PLANE_LEGACY_ENVIRONMENT_SKIP_DETAIL,
+            });
+        }
+        return { ok: false, diagnostics, outcomes };
+    }
     const rootCheck = record(await checkRepositoryRoot(repoRoot, deps));
     // Every remaining check is relative to the repository root. Without a valid
     // one there is nothing coherent left to check, so report and stop here rather
@@ -803,6 +865,12 @@ async function fileExists(filePath, fs) {
  * yield every prerequisite as an explicit unknown.
  */
 export const PLANE_READINESS_DESCRIPTORS = [
+    // BAPI-1237 — the shared legacy-environment guard is the first check
+    // `runPlanePreflight` runs, so it leads this descriptor table too. Omitting
+    // it here would make the check invisible to `epic-implementer readiness` /
+    // `drive-epic` even though it can block `plane up` — exactly the "silence
+    // reads as pass" failure this table exists to rule out.
+    { id: "legacy-environment", label: "Legacy environment" },
     { id: "repository-root", label: "Repository root" },
     { id: "worktree-presence", label: "Git work tree" },
     { id: "claude-login", label: "Claude login" },

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.
  */