@bridge_gpt/mcp-server 0.2.66 → 0.2.67

package/build/conductor/recovery-operations.js

@@ -18,12 +18,12 @@
  * callers: `recovery-cli.ts` and `plane/shutdown.ts`.
  */
 import { randomUUID } from "crypto";
-import { adoptCurrentHeadAndUnparkTicket, completeMergeChild, ConductorBridgeApiError, dispatchRemediation, fetchEpicRunState, mergeChild, patchPolicy, resumeRun, safeDiagnosticMessage, scopeCatchUp, scopeReparse, stopEpicRun, unparkEpicTicket, updateEpicRunStatus, fetchChildContinuationStatus, postContinueParkedChild, resumeCiTicket, REVIEW_HEAD_REFUSAL_CODES, } from "./bridge-api-client.js";
-import { clearGuidedReference, guardForBinding, GUIDED_PAYLOAD_CONFLICT_MESSAGE, GUIDED_REFERENCE_STORE_FAILED_MESSAGE, prepareGuidedRequest, } from "./guided-repair.js";
+import { adoptCurrentHeadAndUnparkTicket, completeMergeChild, ConductorBridgeApiError, dispatchRemediation, fetchEpicRunState, mergeChild, patchPolicy, RERUN_CI_ROUTE_UNAVAILABLE_CODE, RERUN_CI_ROUTE_UNAVAILABLE_MESSAGE, rerunCi, resumeRun, safeDiagnosticMessage, scopeCatchUp, scopeReparse, stopEpicRun, unparkEpicTicket, updateEpicRunStatus, fetchChildContinuationStatus, postContinueParkedChild, resumeCiTicket, REVIEW_HEAD_REFUSAL_CODES, } from "./bridge-api-client.js";
+import { clearGuidedReference, guardForBinding, GUIDED_PAYLOAD_CONFLICT_MESSAGE, GUIDED_REFERENCE_STORE_FAILED_MESSAGE, guidedPayloadDigest, prepareGuidedRequest, } from "./guided-repair.js";
 import { DEFAULT_GATE_NAME } from "./git-ci-types.js";
 import { canonicalSha256, clearContinuationReference, clearRecoveryReferenceFile, computeContinuationFingerprint, readRecoveryReferenceFile, writeRecoveryReferenceFile, isFullSha, newContinuationRequestId, readContinuationReference, writeContinuationReference, } from "./epic-child-continuation.js";
 import { resolveLocalMergeCredential, resolveLocalMergeMethod, runApprovedLocalMerge, } from "./local-merge.js";
-import { RESUME_RUN_UNCONFIRMED_MESSAGE } from "./repair-contract.js";
+import { RERUN_CI_UNCONFIRMED_REASON, RESUME_RUN_UNCONFIRMED_MESSAGE } from "./repair-contract.js";
 /**
  * Bounded total attempts for a ticket-recovery CAS retry loop. Each attempt
  * begins with a fresh, authoritative state read — so this bounds full
@@ -501,6 +501,72 @@ export async function guidedRepairOnce(options, deps = {}) {
         ? { kind: "committed", result, requestId, referenceReused }
         : { kind: "no_op", result, requestId, referenceReused };
 }
+/** The bounded unconfirmed text for a `rerun-ci` whose release write was lost. */
+export const RERUN_CI_COMPENSATION_UNCONFIRMED_MESSAGE = "the server could not confirm whether the workflow runs it did not enqueue are still " +
+    "recorded for this head. Re-read the run explanation before choosing another action";
+/**
+ * Send ONE guided `rerun-ci`, pinned to its displayed binding, through the shared
+ * guided-repair reference (stored BEFORE the first POST; a lost response re-sends
+ * the SAME request). The server decides eligibility and every per-check status;
+ * this layer only classifies the answer.
+ */
+export async function rerunCiRepair(access, options, deps = {}) {
+    const call = deps.rerunCi ?? rerunCi;
+    const outcome = await guidedRepairOnce({
+        binding: options.binding,
+        payloadDigest: guidedPayloadDigest({ ticket_key: options.ticketKey }),
+        send: (guard) => call(access, { epicRunId: options.epicRunId, ticketKey: options.ticketKey, guard }),
+        unconfirmedMessage: "the outcome could not be confirmed: the server may or may not have requested the " +
+            "re-runs. Re-run the SAME command to re-send the same pinned request, or inspect " +
+            "the run read-only",
+    }, deps);
+    switch (outcome.kind) {
+        case "committed":
+        case "no_op":
+            return {
+                kind: "applied",
+                result: outcome.result,
+                requestId: outcome.requestId,
+                referenceReused: outcome.referenceReused,
+            };
+        case "stale":
+            return {
+                kind: "stale",
+                code: outcome.code,
+                message: outcome.message,
+                requestId: outcome.requestId,
+            };
+        case "refused":
+            if (outcome.code === RERUN_CI_ROUTE_UNAVAILABLE_CODE) {
+                return { kind: "unsupported", message: RERUN_CI_ROUTE_UNAVAILABLE_MESSAGE };
+            }
+            if (outcome.code === "ROW_VERSION_CONFLICT" &&
+                outcome.message.includes(RERUN_CI_UNCONFIRMED_REASON)) {
+                return {
+                    kind: "unconfirmed",
+                    reason: "compensation_conflict",
+                    message: RERUN_CI_COMPENSATION_UNCONFIRMED_MESSAGE,
+                    requestId: outcome.requestId,
+                };
+            }
+            return {
+                kind: "refused",
+                code: outcome.code,
+                status: outcome.status,
+                message: outcome.message,
+                requestId: outcome.requestId,
+            };
+        case "unconfirmed":
+            return {
+                kind: "unconfirmed",
+                reason: "transport",
+                message: outcome.message,
+                requestId: outcome.requestId,
+            };
+        default:
+            return { kind: "unavailable", message: outcome.message };
+    }
+}
 const AUTHORITATIVE_OUTCOMES = new Set([
     "committed",
     "already_continued",

package/build/conductor/repair-contract.js

@@ -1,8 +1,8 @@
 /**
- * The shared contract for the seven operator repair verbs: BAPI-1154's
+ * The shared contract for the eight operator repair verbs: BAPI-1154's
  * `scope-reparse`, `dispatch-remediation`, and `merge-child`, BAPI-1176's
- * `scope-catch-up`, `patch-policy`, and `resume-run`, and BAPI-1326's
- * ticket-addressed `resume-ci`.
+ * `scope-catch-up`, `patch-policy`, and `resume-run`, BAPI-1326's
+ * ticket-addressed `resume-ci`, and BAPI-1388's ticket-addressed `rerun-ci`.
  *
  * CLI-only, exactly like the BAPI-872 recovery verbs: none of these names is ever
  * registered as an MCP tool (`index-static.test.ts` pins that). This module is the
@@ -22,6 +22,7 @@ export const VERB_SCOPE_CATCH_UP = "scope-catch-up";
 export const VERB_PATCH_POLICY = "patch-policy";
 export const VERB_RESUME_RUN = "resume-run";
 export const VERB_RESUME_CI = "resume-ci";
+export const VERB_RERUN_CI = "rerun-ci";
 /** Every repair verb, in the order an operator meets them. */
 export const OPERATOR_REPAIR_VERBS = [
     VERB_SCOPE_REPARSE,
@@ -31,6 +32,7 @@ export const OPERATOR_REPAIR_VERBS = [
     VERB_PATCH_POLICY,
     VERB_RESUME_RUN,
     VERB_RESUME_CI,
+    VERB_RERUN_CI,
 ];
 /**
  * The ONE cap on driver context, in UTF-8 BYTES — the same number the server
@@ -156,3 +158,52 @@ export const CI_RESUME_RECEIPT_RETENTION = "latest_only";
 export function isCiResumeRefusalCode(code) {
     return (typeof code === "string" && CI_RESUME_REFUSAL_CODES.includes(code));
 }
+// ---------------------------------------------------------------------------
+// BAPI-1388 — `rerun-ci`
+// ---------------------------------------------------------------------------
+/**
+ * The closed `rerun-ci` refusal subset — mirrors `RERUN_CI_REFUSAL_CODES` in
+ * `operator_repair_contract.py`. It mints no new code: every member already
+ * exists in {@link OPERATOR_REPAIR_REFUSAL_CODES}.
+ */
+export const RERUN_CI_REFUSAL_CODES = [
+    "TICKET_NOT_IN_RUN",
+    "GUIDED_REPAIR_DISABLED",
+    "REPAIR_SUBJECT_STALE",
+    "RUN_NOT_DISPATCHABLE",
+    "TICKET_NOT_REMEDIABLE",
+    "REMEDIATION_JOB_IN_FLIGHT",
+    "REMEDIATION_LANE_BUSY",
+    "REMEDIATION_HELD",
+    "REMEDIATION_NO_PULL_REQUEST",
+    "ROW_VERSION_CONFLICT",
+    "DISPATCH_ENQUEUE_FAILED",
+];
+/** True when `code` is one of the closed `rerun-ci` refusal codes. */
+export function isRerunCiRefusalCode(code) {
+    return (typeof code === "string" && RERUN_CI_REFUSAL_CODES.includes(code));
+}
+/**
+ * The bounded reason a `rerun-ci` `ROW_VERSION_CONFLICT` carries when releasing a
+ * reservation lost its guarded write. Whether the unenqueued workflow runs are
+ * still recorded is UNCONFIRMED; the CLI exits 3.
+ */
+export const RERUN_CI_UNCONFIRMED_REASON = "rerun_ci_unconfirmed";
+/**
+ * The closed per-check outcome vocabulary. None of them says a check is green: a
+ * provider re-run is an action, not a verdict.
+ */
+export const RERUN_CI_CHECK_STATUSES = [
+    "enqueued",
+    "deduplicated",
+    "deferred",
+    "not_re_runnable",
+];
+/** Why one failed check is not re-run: a closed token. */
+export const RERUN_CI_NOT_RUNNABLE_REASONS = [
+    "not_github_actions",
+    "no_workflow_run_id",
+    "claude_review_excluded",
+];
+/** The closed overall outcomes of an applied `rerun-ci`. */
+export const RERUN_CI_OUTCOMES = ["enqueued", "partial", "nothing_to_enqueue"];

package/build/conductor/repository-workflow-remedy.js

@@ -0,0 +1,125 @@
+/** The two fixed workflow files unattended auto-merge reads. Named once here. */
+export const REVIEW_WORKFLOW_PATH = ".github/workflows/claude-review.yml";
+export const CI_WORKFLOW_PATH = ".github/workflows/epic-implementer-ci.yml";
+/** The migration guard's stable job id and its exact checker invocation. */
+export const MIGRATION_GUARD_JOB_ID = "migration-guard";
+export const MIGRATION_GUARD_CHECKER_PATH = "scripts/check_alembic_migration_graph.py";
+export const MIGRATION_GUARD_INVOCATION = `python ${MIGRATION_GUARD_CHECKER_PATH}`;
+const RETRY = "Run the readiness check again, or pass --attended. " +
+    "If it keeps failing, contact Bridge operations.";
+const TEMPLATES = {
+    review_workflow_file: `${REVIEW_WORKFLOW_PATH} is missing from the default branch. Add it, or pass --attended.`,
+    review_run_id_marker: `${REVIEW_WORKFLOW_PATH} does not emit the run-id: marker in its verdict comment. ` +
+        "Add it, or pass --attended.",
+    review_reviewed_sha_marker: `${REVIEW_WORKFLOW_PATH} does not emit the Reviewed-SHA: marker in its verdict comment. ` +
+        "Add it, or pass --attended.",
+    review_workflow_unverifiable: `Bridge could not read ${REVIEW_WORKFLOW_PATH} on the default branch. ${RETRY}`,
+    ci_workflow_file: `${CI_WORKFLOW_PATH} is missing from the default branch. Add it, or pass --attended.`,
+    migration_guard_job: `${CI_WORKFLOW_PATH} has no job with id ${MIGRATION_GUARD_JOB_ID} running ${MIGRATION_GUARD_INVOCATION}. ` +
+        "It is required because this repository has alembic.ini on its default branch, " +
+        `and an equivalent checker at ${MIGRATION_GUARD_CHECKER_PATH} is required too. ` +
+        "Add that job, or pass --attended.",
+    migration_chain_unverifiable: "Bridge could not confirm whether this repository has alembic.ini on its default branch, " +
+        `so it could not decide if the ${MIGRATION_GUARD_JOB_ID} job is required. ${RETRY}`,
+    ci_workflow_unverifiable: `Bridge could not read ${CI_WORKFLOW_PATH} on the default branch. ${RETRY}`,
+    // An older server never reported whether the guard is conditional, so its
+    // guard has always been required. This states that requirement and NOTHING
+    // about alembic.ini: an older server observed no such file.
+    migration_guard_job_legacy: `${CI_WORKFLOW_PATH} has no job with id ${MIGRATION_GUARD_JOB_ID} running ${MIGRATION_GUARD_INVOCATION}. ` +
+        "Add that job, or pass --attended.",
+};
+/** Shown when the report is missing, incomplete, or not in a shape we can name. */
+const UNVERIFIABLE_FALLBACK = "Bridge could not verify the review and CI workflows on the default branch. " + RETRY;
+function classifyReview(w) {
+    if (w === null || w === undefined || typeof w !== "object")
+        return "malformed";
+    if (w.probe_succeeded !== true)
+        return ["review_workflow_unverifiable"];
+    if (w.workflow_present === false)
+        return ["review_workflow_file"];
+    if (w.workflow_present !== true ||
+        typeof w.emits_run_id !== "boolean" ||
+        typeof w.emits_reviewed_sha !== "boolean") {
+        return "malformed";
+    }
+    const missing = [];
+    if (!w.emits_run_id)
+        missing.push("review_run_id_marker");
+    if (!w.emits_reviewed_sha)
+        missing.push("review_reviewed_sha_marker");
+    return missing;
+}
+function classifyCi(c) {
+    if (c === null || c === undefined || typeof c !== "object")
+        return "malformed";
+    if (c.probe_succeeded !== true)
+        return ["ci_workflow_unverifiable"];
+    if (c.workflow_present === false)
+        return ["ci_workflow_file"];
+    if (c.workflow_present !== true || typeof c.migration_guard_present !== "boolean") {
+        return "malformed";
+    }
+    if (c.migration_guard_present)
+        return [];
+    const required = c.migration_guard_required;
+    const chainProbed = c.migration_chain_probe_succeeded;
+    // Older server: neither field reported. The guard was always required there,
+    // and the absent fields must never read as "not required".
+    if (required === undefined && chainProbed === undefined) {
+        return ["migration_guard_job_legacy"];
+    }
+    if (typeof required !== "boolean" || typeof chainProbed !== "boolean")
+        return "malformed";
+    if (chainProbed && !required)
+        return []; // confirmed guard-free
+    if (chainProbed && required)
+        return ["migration_guard_job"];
+    return ["migration_chain_unverifiable"];
+}
+/**
+ * Name the first failing workflow section of a parsed readiness report, its
+ * missing facts in stable order, and one fixed-template message.
+ *
+ * `section: null` with the fallback text means the report is missing or malformed
+ * — "could not verify", never "fine". An empty `missing` with `section: null`
+ * cannot occur: a report with nothing failing yields the fallback only when it is
+ * unreadable, and otherwise the empty result below.
+ */
+export function describeRepositoryWorkflowRemedy(readiness) {
+    const review = classifyReview(readiness?.review_workflow);
+    if (review === "malformed") {
+        return { section: null, missing: [], text: UNVERIFIABLE_FALLBACK };
+    }
+    if (review.length > 0)
+        return build("review_workflow", review);
+    const ci = classifyCi(readiness?.conductor_ci_workflow);
+    if (ci === "malformed") {
+        return { section: null, missing: [], text: UNVERIFIABLE_FALLBACK };
+    }
+    if (ci.length > 0)
+        return build("conductor_ci_workflow", ci);
+    return { section: null, missing: [], text: "" };
+}
+function build(section, missing) {
+    return { section, missing, text: missing.map((token) => TEMPLATES[token]).join(" ") };
+}
+/**
+ * The remedy sentence for a repository whose workflows are not confirmed. Never
+ * empty: a report with nothing to name (the server said unconfirmed but this
+ * client can name no item) gets the unverifiable fallback rather than silence.
+ */
+export function repositoryWorkflowRemedy(readiness) {
+    const described = describeRepositoryWorkflowRemedy(readiness);
+    return described.text === "" ? UNVERIFIABLE_FALLBACK : described.text;
+}
+/**
+ * The remedy for the CI workflow section alone — what the readiness CI row shows
+ * when the migration guard is absent. Same templates, same words as
+ * {@link repositoryWorkflowRemedy}, so the row and the refusals cannot drift.
+ */
+export function ciWorkflowRemedy(c) {
+    const tokens = classifyCi(c);
+    if (tokens === "malformed" || tokens.length === 0)
+        return UNVERIFIABLE_FALLBACK;
+    return tokens.map((token) => TEMPLATES[token]).join(" ");
+}

package/build/conductor/tools.js

@@ -82,9 +82,9 @@ function registerExplainRunTool(registerTool) {
         // is the field list: a caller cannot discover the answer shape from a
         // tool that only says "explain a run", and the whole point of the tool is
         // that the answer is in one place.
-        description: "Explain why a Conductor epic run, or one ticket in it, is stuck. One snapshot: " +
+        description: "Explain why an Epic Implementer run, or one ticket in it, is stuck. One snapshot: " +
             "current gate, latest observation and age, outstanding jobs with queue position, " +
-            "lease owner/expiry, blocker reasons, expected-vs-observed head SHA, committed and " +
+            "lease owner/expiry, blocker reasons, expected/observed head SHA, committed and " +
             "pending disposition, usage ceiling. Pass ticket_key to narrow. Read-only; 404 " +
             "returns status 'unknown'.",
         inputSchema: {

package/build/conductor-bundle-artifacts.js

@@ -27,6 +27,14 @@ import { validateTicketKey } from "./ticket-key-utils.js";
 const EPIC_SLUG_RE = /^[A-Za-z][A-Za-z0-9_-]*$/;
 /** Placeholder node identity written by `decompose-epic.md` before tickets exist. */
 const PLACEHOLDER_RE = /TBD-\d+/;
+/**
+ * A whole plan-node key that is still an authoring placeholder (`TBD-<digits>`),
+ * case-insensitive. Anchored on purpose and stateless (no `g` or `y` flag, so
+ * `.test()` carries no `lastIndex`). This is NOT {@link PLACEHOLDER_RE}: that one
+ * is an unanchored scan of a whole serialized plan, and
+ * {@link findResidualPlaceholder} keeps using it unchanged.
+ */
+export const PLACEHOLDER_NODE_KEY_RE = /^TBD-\d+$/i;
 /**
  * The conductor's hard spec bound, mirroring `_SPEC_REVIEW_TICKET_SPEC_MAX_CHARS`
  * (64,000) in `api/library/epic_implementer/reconciler.py`. Since PR #848 the