@bridge_gpt/mcp-server 0.2.68 → 0.2.70

package/build/conductor/pr-ci-producer.js

@@ -558,7 +558,7 @@ export async function resolveDispatchRunIdForBinding(access, binding, fetchImpl
     for (const run of activeRuns) {
         try {
             const state = await fetchEpicRunState(access, run.epic_key, fetchImpl);
-            const dispatch = state.dispatches.find((d) => d.ticket_key === ticketKey && d.run_id !== null);
+            const dispatch = (state.dispatches ?? []).find((d) => d.ticket_key === ticketKey && d.run_id !== null);
             if (dispatch?.run_id)
                 return dispatch.run_id;
         }

package/build/conductor/readiness-cli.js

@@ -44,15 +44,15 @@ import { runDefaultPlanePreflight } from "../plane/cli.js";
 import { planeNotApplicableForTarget } from "../plane/endpoint.js";
 import { resolvePlaneServerEndpoint } from "../plane/member-roster.js";
 /** Fixed notice emitted to stderr when a source could not be collected. */
-export const READINESS_COLLECTION_NOTICE = "one or more readiness sources could not be collected; the affected prerequisites are reported as failures.";
+export const READINESS_COLLECTION_NOTICE = "one or more readiness sources could not be collected; the affected prerequisites are reported as warnings.";
 /** Usage text for `epic-implementer readiness`. */
 export function getReadinessUsage() {
     return [
         "Usage: epic-implementer readiness [--json] [--no-deny-probe] [--base-url <url>] [--epic-run-id <id>]",
         "",
-        "Read-only ADVISORY report of every conductor prerequisite, consolidated from the",
+        "Read-only ADVISORY report of every Epic Implementer prerequisite, consolidated from the",
         "Bridge install checklist, the epic-implementer doctor, the plane preflight, and the",
-        "server conductor-readiness collector. Each prerequisite reports pass/warn/fail/skip",
+        "server's Epic Implementer readiness collector. Each prerequisite reports pass/warn/fail/skip",
         "and, on a failure, exactly ONE named remediation.",
         "",
         "The claude-review workflow row is assessed for a NEW feature-branch run's first",
@@ -65,6 +65,7 @@ export function getReadinessUsage() {
         "the only route-selection gate and the server-side admission the only hard refusal.",
         "",
         "Options:",
+        "  --all             Show every visible prerequisite; default shows actionable rows",
         "  --json            Print the versioned structured report as JSON",
         "  --no-deny-probe   Accepted for parity with `epic-implementer doctor`; inert here, because",
         "                    this command never spawns the deny-enforcement probe",
@@ -78,10 +79,12 @@ export function getReadinessUsage() {
 }
 /** Parse `epic-implementer readiness` argv. Unknown flags and positionals are errors. */
 export function parseReadinessArgs(argv) {
-    const parsed = { json: false, help: false, noDenyProbe: false };
+    const parsed = { all: false, json: false, help: false, noDenyProbe: false };
     for (let index = 0; index < argv.length; index++) {
         const token = argv[index];
-        if (token === "--json")
+        if (token === "--all")
+            parsed.all = true;
+        else if (token === "--json")
             parsed.json = true;
         else if (token === "--no-deny-probe")
             parsed.noDenyProbe = true;
@@ -194,6 +197,8 @@ async function collectProductionReport(repoRoot, env, baseUrl, epicRunId) {
             // `verdict_protocol` whenever that cannot be established. This is a
             // prospective assessment, not a prediction or authorization of any run.
             reviewPolicySource,
+            // BAPI-1465: an explicit run id also scopes the effective-review-mode row.
+            ...(epicRunId !== undefined ? { epicRunId } : {}),
             readWorkflowFile: () => fsReadFile(claudeReviewWorkflowPath(repoRoot), "utf-8"),
             projectRoot: repoRoot,
             installDoctorDeps: {
@@ -267,7 +272,7 @@ export async function runConductorReadinessCommand(argv, deps = {}) {
         });
     }
     else {
-        sinks.stdout(formatConductorReadinessGateReport(report));
+        sinks.stdout(formatConductorReadinessGateReport(report, { all: parsed.all }));
     }
     // Advisory: the exit code is a constant, never derived from a check status.
     return 0;

package/build/conductor/readiness-prerequisites.js

@@ -0,0 +1,41 @@
+/** Canonical merging and bounded rendering; provider details never become public text. */
+import { READINESS_PREREQUISITE_BY_ID, READINESS_LEGACY_IDS, READINESS_PREREQUISITE_CATALOG } from '../readiness-prerequisites.generated.js';
+import { READINESS_PREREQUISITE_FIXES } from '../printed-remedy-commands.js';
+import { createReadinessCheckSafely } from '../readiness-check.js';
+export function mergeReadinessPrerequisites(checks, server = []) {
+    const rows = new Map();
+    for (const check of checks) {
+        const id = check.id.startsWith('server.diagnostic-') ? 'server.diagnostics'
+            : check.id.startsWith('server.gate-profile-warning-') ? 'server.gate-profile-warnings'
+                : READINESS_LEGACY_IDS[check.id] ?? check.id;
+        const descriptor = READINESS_PREREQUISITE_BY_ID.get(id);
+        if (!descriptor)
+            continue;
+        const unknown = check.status === 'warn' || (check.status === 'fail' && /unknown|unread|unavailable|could not|unreported|unreachable/i.test(check.detail ?? ''));
+        const status = check.status === 'pass' ? 'met' : check.status === 'skip' ? 'not_applicable' : unknown ? 'unknown' : 'not_met';
+        const impact = status === 'met' || status === 'not_applicable' ? 'info' : unknown || check.blocking !== true ? 'warning' : descriptor.impact;
+        const fix = impact === 'info' ? '' : descriptor.scope === 'self_host' ? READINESS_PREREQUISITE_FIXES.self_host : READINESS_PREREQUISITE_FIXES.retry;
+        const item = { ...descriptor, check_status: status, impact, fix };
+        const previous = rows.get(id);
+        if (!previous || previous.check_status === 'met')
+            rows.set(id, item);
+    }
+    for (const item of server)
+        rows.set(item.id, item);
+    return READINESS_PREREQUISITE_CATALOG.flatMap(d => rows.has(d.id) ? [rows.get(d.id)] : []);
+}
+export function prerequisiteChecks(items) {
+    return items.map(p => createReadinessCheckSafely({ id: p.id, source: 'server', label: p.label,
+        status: p.check_status === 'met' ? 'pass' : p.check_status === 'not_applicable' ? 'skip' : p.check_status === 'unknown' || p.impact !== 'blocking' ? 'warn' : 'fail',
+        blocking: p.impact === 'blocking', detail: p.check_status,
+        ...(p.fix ? { remediation: p.fix } : {}) }));
+}
+export function formatReadinessPrerequisites(items, options = {}) {
+    const visible = items.filter(p => !options.isProduction || p.scope === 'customer');
+    const blockers = visible.filter(p => p.check_status === 'not_met' && p.impact === 'blocking');
+    const warnings = visible.filter(p => ['not_met', 'unknown'].includes(p.check_status) && p.impact === 'warning');
+    const verdict = blockers.length ? `Not ready: ${blockers.length} blocking` : warnings.length ? `Ready, with ${warnings.length} warnings` : 'Ready to launch';
+    const selected = options.all ? visible : [...blockers, ...warnings];
+    const state = { met: 'Met', not_met: 'Not met', unknown: "Couldn't check", not_applicable: 'Not applicable' };
+    return [verdict, ...selected.flatMap(p => [`  ${p.label}: ${state[p.check_status]}`, ...(p.fix && ['not_met', 'unknown'].includes(p.check_status) ? [`    ${p.fix}`] : [])])];
+}