@bridge_gpt/mcp-server 0.2.69 → 0.2.70

package/build/conductor/bridge-api-client.js

@@ -1,3 +1,5 @@
+import { READINESS_PREREQUISITE_BY_ID } from "../readiness-prerequisites.generated.js";
+import { READINESS_PREREQUISITE_FIXES } from "../printed-remedy-commands.js";
 /**
  * TypeScript-side Bridge API access layer for the conductor producer (BAPI-395).
  *
@@ -193,6 +195,31 @@ const CONDUCTOR_BRIDGE_API_ERROR_KINDS = [
 ];
 /** Max length of the sanitized body preview embedded in error diagnostics. */
 const CONDUCTOR_ERROR_PREVIEW_MAX = 200;
+/** BAPI-1455 — the stable readiness refusal code for a proven-missing local schema object. */
+export const SCHEMA_INCOMPATIBLE_ERROR_CODE = "SCHEMA_INCOMPATIBLE";
+/** BAPI-1455 — the bound for that refusal's server-authored explanation. */
+const SCHEMA_REFUSAL_PREVIEW_MAX = 2000;
+/** Whether a readiness read failed because the local schema is proven incompatible. */
+export function isSchemaIncompatibleError(err) {
+    return err instanceof ConductorBridgeApiError && err.errorCode === SCHEMA_INCOMPATIBLE_ERROR_CODE;
+}
+/** BAPI-1455 — the fixed repair route. Never `alembic stamp`, never a downgrade. */
+export const SCHEMA_INCOMPATIBLE_REPAIR_ROUTE = "Write a reviewed, forward-only Alembic migration that restores the missing objects, " +
+    "or rebuild the local database only with the owner's explicit consent.";
+/**
+ * The operator lines for a `SCHEMA_INCOMPATIBLE` readiness refusal. The server's
+ * explanation (applied stamp and missing objects, from its maintained list) is
+ * shown when present; the heading and the repair route are fixed text.
+ */
+export function formatSchemaIncompatibleRefusal(subject, err) {
+    return [
+        `${subject}: REFUSED (schema-incompatible) — Local schema incompatible. ` +
+            "Launch-critical schema objects are missing, so no run was created.",
+        ...(err.bodyPreview ? [`  ${err.bodyPreview}`] : []),
+        `  Repair: ${SCHEMA_INCOMPATIBLE_REPAIR_ROUTE}`,
+        "  A migration stamp is not proof of schema; `alembic stamp` cannot restore missing DDL.",
+    ];
+}
 /**
  * Redact obvious secret-shaped tokens from a diagnostic preview string so a
  * backend message that happens to echo a token/header never reaches a log line.
@@ -243,11 +270,9 @@ function stripWebhookUrlsDeep(value, depth = 0) {
     return out;
 }
 /** Collapse whitespace, redact secrets, and bound a string to the preview cap. */
-function boundedErrorPreview(text) {
+function boundedErrorPreview(text, max = CONDUCTOR_ERROR_PREVIEW_MAX) {
     const redacted = redactErrorPreview(text).replace(/\s+/g, " ").trim();
-    return redacted.length > CONDUCTOR_ERROR_PREVIEW_MAX
-        ? `${redacted.slice(0, CONDUCTOR_ERROR_PREVIEW_MAX)}…`
-        : redacted;
+    return redacted.length > max ? `${redacted.slice(0, max)}…` : redacted;
 }
 /** Max number of FastAPI `loc` components rendered into a diagnostic path. */
 const CONDUCTOR_VALIDATION_LOC_MAX_PARTS = 8;
@@ -369,7 +394,9 @@ async function readSanitizedErrorDiagnostics(resp, headers = {}, options = {}) {
     try {
         const parsed = stripWebhookUrlsDeep(await resp.json());
         const diagnostics = extractSanitizedErrorDiagnostics(parsed);
-        if (options.readErrorField && !diagnostics.bodyPreview) {
+        const codeAllowed = options.readErrorFieldOnlyFor === undefined ||
+            (diagnostics.errorCode !== undefined && options.readErrorFieldOnlyFor.includes(diagnostics.errorCode));
+        if (options.readErrorField && codeAllowed && !diagnostics.bodyPreview) {
             // BAPI-1154: opt-in only. The route layer's `_http_error` envelope carries
             // its server-authored explanation in `detail.error`, which the shared
             // extractor deliberately does not read (pinned by its own tests). The
@@ -382,7 +409,7 @@ async function readSanitizedErrorDiagnostics(resp, headers = {}, options = {}) {
                 ? detail["error"]
                 : undefined;
             if (typeof error === "string" && error.trim()) {
-                diagnostics.bodyPreview = boundedErrorPreview(error.trim());
+                diagnostics.bodyPreview = boundedErrorPreview(error.trim(), options.errorFieldPreviewMax);
             }
         }
         const secrets = Object.entries(headers)
@@ -488,7 +515,7 @@ export function conductorGetHeaders(access) {
  * non-2xx response — never including the response body, headers, or API key. The
  * timer is always cleared.
  */
-export async function fetchConductorJsonWithTimeout(url, headers, timeoutMs, fetchImpl = globalThis.fetch) {
+export async function fetchConductorJsonWithTimeout(url, headers, timeoutMs, fetchImpl = globalThis.fetch, errorOptions = {}) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
@@ -501,7 +528,7 @@ export async function fetchConductorJsonWithTimeout(url, headers, timeoutMs, fet
             throw new ConductorBridgeApiError(controller.signal.aborted ? "timeout" : "network");
         }
         if (!resp.ok) {
-            const diagnostics = await readSanitizedErrorDiagnostics(resp, headers);
+            const diagnostics = await readSanitizedErrorDiagnostics(resp, headers, errorOptions);
             if (resp.status === 401 || resp.status === 403) {
                 throw new ConductorBridgeApiError("unauthorized", resp.status, diagnostics);
             }
@@ -1037,6 +1064,41 @@ export async function fetchActiveEpicRuns(access, fetchImpl = globalThis.fetch)
     }
     return [];
 }
+/** Every status after which a run can still do work. */
+const NON_TERMINAL_EPIC_RUN_STATUSES = ["planning", "pending_approval", "active", "blocked"];
+const NON_TERMINAL_EPIC_RUN_PAGE_LIMIT = 100;
+/**
+ * The ids of every non-terminal epic run the server holds for the access's
+ * repository (BAPI-1496 plane cleanup). `null` unless the answer is CONCLUSIVE:
+ * any failed read, malformed body, or full page (which may hide more runs)
+ * returns `null`, never a shorter list. Never throws.
+ */
+export async function listNonTerminalEpicRunIds(access, fetchImpl = globalThis.fetch) {
+    const ids = [];
+    try {
+        for (const status of NON_TERMINAL_EPIC_RUN_STATUSES) {
+            const url = buildConductorJiraUrl(access.baseUrl, `${EPIC_RUNS_API_PREFIX}/runs`, {
+                repo_name: access.repoName,
+                status,
+                limit: String(NON_TERMINAL_EPIC_RUN_PAGE_LIMIT),
+            });
+            const parsed = await fetchConductorJsonWithTimeout(url, conductorGetHeaders(access), CONDUCTOR_FETCH_TIMEOUT_MS, fetchImpl);
+            const runs = parsed && typeof parsed === "object" ? parsed.runs : undefined;
+            if (!Array.isArray(runs) || runs.length >= NON_TERMINAL_EPIC_RUN_PAGE_LIMIT)
+                return null;
+            for (const run of runs) {
+                const id = run && typeof run === "object" ? run.epic_run_id : undefined;
+                if (typeof id !== "string" || id.length === 0)
+                    return null;
+                ids.push(id);
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return ids;
+}
 /**
  * POST `/jira/epic-runs/runs` to create the durable epic run row.
  *
@@ -1327,6 +1389,7 @@ export async function postContinueParkedChild(access, request, fetchImpl = globa
         request_fingerprint: request.requestFingerprint,
         ...(request.reason ? { reason: request.reason } : {}),
         ...(request.workerExitProof ? { worker_exit_proof: request.workerExitProof } : {}),
+        ...(request.driverContext !== undefined ? { driver_context: request.driverContext } : {}),
     });
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -1416,9 +1479,15 @@ export async function postGrantContinuation(access, request, fetchImpl = globalT
         typeof body.replayed === "boolean" &&
         grant && typeof grant === "object" &&
         grant.request_id === request.requestId) {
+        const fields = body;
+        const replayed = fields.replayed;
         return {
             kind: "result", requestId: request.requestId,
-            replayed: body.replayed,
+            replayed,
+            committed: typeof fields.committed === "boolean" ? fields.committed : !replayed,
+            sourceParkGeneration: typeof fields.source_park_generation === "number"
+                ? fields.source_park_generation : null,
+            gate: typeof fields.gate === "string" ? fields.gate : null,
         };
     }
     if (response.status >= 500 || response.ok) {
@@ -1584,6 +1653,75 @@ export async function dispatchRemediation(access, request, fetchImpl = globalThi
     const parsed = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/tickets/${encodeURIComponent(request.ticketKey)}/dispatch-remediation`, withGuard({ context: request.context }, request.guard), fetchImpl);
     return parseDispatchRemediationResult(parsed);
 }
+function parseHandoffResolutionRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new ConductorBridgeApiError("server");
+    }
+    const r = value;
+    const steps = r["steps"];
+    if (!Array.isArray(steps) ||
+        !steps.every((step) => typeof step === "number" && Number.isSafeInteger(step) && step > 0) ||
+        typeof r["binding_attempt_id"] !== "string" ||
+        typeof r["evidence_revision"] !== "number" ||
+        typeof r["epic_head_sha"] !== "string" ||
+        typeof r["evidence_ref"] !== "string" ||
+        typeof r["actor"] !== "string" ||
+        (r["kind"] !== "verified" && r["kind"] !== "risk_accepted") ||
+        typeof r["reason"] !== "string" ||
+        typeof r["at"] !== "string") {
+        throw new ConductorBridgeApiError("server");
+    }
+    return {
+        steps: steps,
+        binding_attempt_id: r["binding_attempt_id"],
+        evidence_revision: r["evidence_revision"],
+        epic_head_sha: r["epic_head_sha"],
+        evidence_ref: r["evidence_ref"],
+        actor: r["actor"],
+        kind: r["kind"],
+        reason: r["reason"],
+        at: r["at"],
+    };
+}
+function parseResolveHandoffResult(parsed) {
+    const p = parseRepairBase(parsed);
+    const remaining = p["remaining_unresolved"];
+    if (typeof p["ticket_key"] !== "string" ||
+        !Array.isArray(p["resolutions"]) ||
+        typeof remaining !== "number" ||
+        !Number.isSafeInteger(remaining) ||
+        remaining < 0) {
+        throw new ConductorBridgeApiError("server");
+    }
+    return {
+        epic_run_id: p["epic_run_id"],
+        ticket_key: p["ticket_key"],
+        committed: p["committed"],
+        event_recorded: p["event_recorded"],
+        resolutions: p["resolutions"].map(parseHandoffResolutionRecord),
+        remaining_unresolved: remaining,
+    };
+}
+/**
+ * POST `/jira/epic-runs/runs/{epic_run_id}/tickets/{ticket_key}/resolve-handoff`
+ * (BAPI-1494) — body `{repo_name, steps, kind, evidence_ref, reason}` and nothing
+ * else. There is no actor field: the SERVER records the verified request actor.
+ */
+export async function resolveHandoff(access, request, fetchImpl = globalThis.fetch) {
+    requireNonEmptyString(request.epicRunId);
+    requireNonEmptyString(request.ticketKey);
+    const parsed = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/tickets/${encodeURIComponent(request.ticketKey)}/resolve-handoff`, {
+        steps: request.steps,
+        kind: request.kind,
+        evidence_ref: request.evidenceRef,
+        reason: request.reason,
+    }, fetchImpl);
+    return parseResolveHandoffResult(parsed);
+}
+/** The synthetic code an old server's missing escalate route is reported under. */
+export const ESCALATE_ROUTE_UNAVAILABLE_CODE = "ESCALATE_ROUTE_UNAVAILABLE";
+/** The fixed operator text for a server that has no `escalate` route. */
+export const ESCALATE_ROUTE_UNAVAILABLE_MESSAGE = "escalate is not available on this server; the Bridge API server needs an upgrade before using it";
 export async function escalateTicket(access, request, fetchImpl = globalThis.fetch) {
     requireNonEmptyString(request.epicRunId);
     requireNonEmptyString(request.ticketKey);
@@ -1591,7 +1729,22 @@ export async function escalateTicket(access, request, fetchImpl = globalThis.fet
     requireNonEmptyString(request.actionNeeded);
     if (request.actionNeeded.length > 300)
         throw new ConductorBridgeApiError("server");
-    const result = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/tickets/${encodeURIComponent(request.ticketKey)}/escalate`, { cause: request.cause, action_needed: request.actionNeeded }, fetchImpl);
+    let result;
+    try {
+        result = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/tickets/${encodeURIComponent(request.ticketKey)}/escalate`, { cause: request.cause, action_needed: request.actionNeeded }, fetchImpl);
+    }
+    catch (err) {
+        // An untyped 404/405 means the server predates the route; a server-coded
+        // refusal keeps its own code and reason.
+        if (err instanceof ConductorBridgeApiError && !err.errorCode &&
+            (err.status === 404 || err.status === 405)) {
+            throw new ConductorBridgeApiError("http", err.status, {
+                errorCode: ESCALATE_ROUTE_UNAVAILABLE_CODE,
+                bodyPreview: ESCALATE_ROUTE_UNAVAILABLE_MESSAGE,
+            });
+        }
+        throw err;
+    }
     const value = result;
     if (!value || !["created", "deduplicated", "suppressed"].includes(value.status) ||
         !Number.isSafeInteger(value.notification_id) || value.notification_id <= 0 ||
@@ -2259,6 +2412,149 @@ function safeStringArray(value) {
         return [];
     return value.filter((v) => typeof v === "string" && v !== "");
 }
+// ---------------------------------------------------------------------------
+// BAPI-1510 — already-merged child detection and skipped-child audit clients
+// ---------------------------------------------------------------------------
+export const CHILD_MERGE_CLASSIFICATIONS = ["done", "probably_done", "not_done", "unknown"];
+export const CHILD_MERGE_EVIDENCE_SOURCES = ["delivery_binding", "feature_branch", "none"];
+export const CHILD_MERGE_ANCESTRY_VALUES = ["covered", "behind", "unknown", "not_checked"];
+export const CHILD_MERGE_REASONS = [
+    "merged_on_cut_commit",
+    "merged_without_delivery_record",
+    "merged_after_index",
+    "ancestry_unknown",
+    "no_merged_pr_found",
+    "binding_ambiguous",
+    "provider_unavailable",
+    "binding_read_failed",
+    "merge_sha_unavailable",
+    "ancestry_unavailable_for_provider",
+    "deadline_exceeded",
+];
+const FULL_COMMIT_SHA_PATTERN = /^[0-9a-f]{40}$/;
+function isOneOf(allowed, value) {
+    return typeof value === "string" && allowed.includes(value);
+}
+/**
+ * POST `/jira/epic-runs/child-merge-status`: read-only classification of plan
+ * children against one indexed cut commit. Creates no run, event, or charge.
+ *
+ * The response is validated strictly: a missing, duplicated, or reordered child,
+ * an out-of-vocabulary value, a malformed PR number or SHA, or an echoed cut that
+ * differs from the requested one is a protocol error. A malformed body must never
+ * reach plan trimming.
+ */
+export async function classifyChildMergeStatus(access, request, fetchImpl = globalThis.fetch) {
+    const url = buildConductorJiraUrl(access.baseUrl, `${EPIC_RUNS_API_PREFIX}/child-merge-status`);
+    const parsed = await fetchConductorJsonPostWithTimeout(url, conductorPostHeaders(access), JSON.stringify({
+        repo_name: access.repoName,
+        epic_key: request.epicKey,
+        child_keys: [...request.childKeys],
+        cut_commit_sha: request.cutCommitSha,
+    }), CONDUCTOR_FETCH_TIMEOUT_MS, fetchImpl);
+    return parseChildMergeStatusResponse(parsed, request);
+}
+/** Strict parse of the classification body; throws a sanitized error on any deviation. */
+export function parseChildMergeStatusResponse(parsed, request) {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new ConductorBridgeApiError("server");
+    }
+    const p = parsed;
+    const cut = p["cut_commit_sha"];
+    const children = p["children"];
+    if (typeof cut !== "string" || cut !== request.cutCommitSha || !Array.isArray(children)) {
+        throw new ConductorBridgeApiError("server");
+    }
+    if (children.length !== request.childKeys.length) {
+        throw new ConductorBridgeApiError("server");
+    }
+    const seen = new Set();
+    const results = [];
+    for (let i = 0; i < children.length; i += 1) {
+        const raw = children[i];
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+            throw new ConductorBridgeApiError("server");
+        }
+        const c = raw;
+        const key = c["ticket_key"];
+        if (typeof key !== "string" || key !== request.childKeys[i] || seen.has(key)) {
+            throw new ConductorBridgeApiError("server");
+        }
+        seen.add(key);
+        const pr = c["pr_number"];
+        const sha = c["merge_commit_sha"];
+        if (!isOneOf(CHILD_MERGE_CLASSIFICATIONS, c["classification"]) ||
+            !isOneOf(CHILD_MERGE_EVIDENCE_SOURCES, c["evidence_source"]) ||
+            !isOneOf(CHILD_MERGE_ANCESTRY_VALUES, c["ancestry"]) ||
+            !isOneOf(CHILD_MERGE_REASONS, c["reason"]) ||
+            !(pr === null || (typeof pr === "number" && Number.isSafeInteger(pr) && pr > 0)) ||
+            !(sha === null || (typeof sha === "string" && FULL_COMMIT_SHA_PATTERN.test(sha)))) {
+            throw new ConductorBridgeApiError("server");
+        }
+        results.push({
+            ticket_key: key,
+            classification: c["classification"],
+            evidence_source: c["evidence_source"],
+            pr_number: pr,
+            merge_commit_sha: sha,
+            ancestry: c["ancestry"],
+            reason: c["reason"],
+        });
+    }
+    return { cut_commit_sha: cut, children: results };
+}
+export const SKIPPED_CHILD_OUTCOMES = ["recorded", "already_recorded", "refused"];
+export const SKIPPED_CHILD_REFUSAL_REASONS = [
+    "not_skippable",
+    "child_present_in_plan",
+    "run_context_unavailable",
+];
+/**
+ * POST `/jira/epic-runs/{epic_run_id}/skipped-children`: audit-only record of
+ * children a newly created run left out. The body carries repository identity,
+ * child keys, and confirmation booleans only; the server derives every fact.
+ */
+export async function recordSkippedChildren(access, epicRunId, children, fetchImpl = globalThis.fetch) {
+    const url = buildConductorJiraUrl(access.baseUrl, `${EPIC_RUNS_API_PREFIX}/${encodeURIComponent(epicRunId)}/skipped-children`);
+    const parsed = await fetchConductorJsonPostWithTimeout(url, conductorPostHeaders(access), JSON.stringify({
+        repo_name: access.repoName,
+        children: children.map((c) => ({
+            ticket_key: c.ticketKey,
+            operator_confirmed: c.operatorConfirmed,
+        })),
+    }), CONDUCTOR_FETCH_TIMEOUT_MS, fetchImpl);
+    return parseRecordSkippedChildrenResponse(parsed, children.map((c) => c.ticketKey));
+}
+/** Strict parse of the recording body; throws a sanitized error on any deviation. */
+export function parseRecordSkippedChildrenResponse(parsed, expectedKeys) {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new ConductorBridgeApiError("server");
+    }
+    const results = parsed["results"];
+    if (!Array.isArray(results) || results.length !== expectedKeys.length) {
+        throw new ConductorBridgeApiError("server");
+    }
+    const out = [];
+    for (let i = 0; i < results.length; i += 1) {
+        const raw = results[i];
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+            throw new ConductorBridgeApiError("server");
+        }
+        const r = raw;
+        const reason = r["reason"];
+        if (r["ticket_key"] !== expectedKeys[i] ||
+            !isOneOf(SKIPPED_CHILD_OUTCOMES, r["outcome"]) ||
+            !(reason === null || reason === undefined || isOneOf(SKIPPED_CHILD_REFUSAL_REASONS, reason))) {
+            throw new ConductorBridgeApiError("server");
+        }
+        out.push({
+            ticket_key: expectedKeys[i],
+            outcome: r["outcome"],
+            reason: (reason ?? null),
+        });
+    }
+    return { results: out };
+}
 /** Non-negative safe integer, or 0 for anything else (absent field included). */
 function safeCount(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : 0;
@@ -2615,6 +2911,40 @@ export const REQUIRED_CHECKS_VERIFICATIONS = new Set([
     "unknown_name",
     "unverifiable",
 ]);
+export function parseReadinessPrerequisites(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const seen = new Set();
+    const result = [];
+    for (const item of raw) {
+        if (typeof item !== 'object' || item === null || Array.isArray(item))
+            return undefined;
+        const r = item;
+        const d = typeof r.id === 'string' ? READINESS_PREREQUISITE_BY_ID.get(r.id) : undefined;
+        if (!d || seen.has(d.id) || Object.keys(r).sort().join(',') !== 'check_status,fix,id,impact,label,scope' || r.label !== d.label || r.scope !== d.scope ||
+            !['met', 'not_met', 'unknown', 'not_applicable'].includes(String(r.check_status)) || !['blocking', 'warning', 'info'].includes(String(r.impact)) ||
+            typeof r.fix !== 'string' || !Object.values(READINESS_PREREQUISITE_FIXES).includes(r.fix) ||
+            (r.check_status === 'unknown' && r.impact === 'blocking'))
+            return undefined;
+        seen.add(d.id);
+        result.push(r);
+    }
+    return result;
+}
+export const ESCALATION_CHANNELS = ["webhook", "email", "none", "unknown"];
+export const WEBHOOK_LAST_DELIVERIES = ["failed", "handed_off", "queued", "unknown"];
+/** BAPI-1452 — the three supported merge execution modes, as the server reports them. */
+export const RESOLVED_MERGE_EXECUTION_MODES = ["local", "machine_token", "github_actions"];
+/**
+ * BAPI-1452 — a provider repository identity: exactly one `/`, each side
+ * starting with an alphanumeric and bounded, no whitespace, control
+ * characters, URL syntax, or path traversal.
+ */
+const PROVIDER_REPOSITORY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}\/[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
+/** True when `value` is a well-formed `owner/name` provider identity (BAPI-1452). */
+export function isProviderRepositoryIdentity(value) {
+    return typeof value === "string" && PROVIDER_REPOSITORY_PATTERN.test(value);
+}
 /** BAPI-1260 — one mandatory-evidence verdict. Only `confirmed` ever holds. */
 export const ADMISSION_EVIDENCE_VERDICTS = [
     "confirmed",
@@ -2892,6 +3222,9 @@ export function parseConductorReadinessResponse(body) {
     const thr = requireObject(root.thresholds);
     const requiredChecksCount = requireInt(sup, "required_checks_count");
     return {
+        ...(typeof root.is_production === 'boolean' ? { is_production: root.is_production } : {}),
+        ...(root.is_production === undefined || typeof root.is_production === 'boolean'
+            ? { prerequisites: parseReadinessPrerequisites(root.prerequisites) } : {}),
         repo_name: repoName,
         supervisor: {
             setup_present: requireBool(sup, "setup_present"),
@@ -2966,8 +3299,51 @@ export function parseConductorReadinessResponse(body) {
             const diagnostics = parseReadinessDiagnostics(root);
             return diagnostics === undefined ? {} : { diagnostics };
         })(),
+        ...parseLaunchMergeFacts(root),
+        ...parseEscalationObservations(root),
     };
 }
+/**
+ * BAPI-1495 — the closed escalation observations. Absent stays absent (an older
+ * server). A present value outside the closed set is dropped rather than rejecting
+ * the read: the wording seam reads a dropped field as unknown.
+ */
+function parseEscalationObservations(body) {
+    const out = {};
+    if (ESCALATION_CHANNELS.includes(body.escalation_channel)) {
+        out.escalation_channel = body.escalation_channel;
+    }
+    if (body.webhook_last_delivery === null) {
+        out.webhook_last_delivery = null;
+    }
+    else if (WEBHOOK_LAST_DELIVERIES.includes(body.webhook_last_delivery)) {
+        out.webhook_last_delivery = body.webhook_last_delivery;
+    }
+    return out;
+}
+/**
+ * BAPI-1452 — parse the two additive launch facts.
+ *
+ * Absent keys stay absent (an older server). A PRESENT value that is not a
+ * supported mode, or not a well-formed `owner/name`, becomes `null` rather
+ * than rejecting the whole readiness read: these facts only feed a launch
+ * warning, and losing every other readiness fact over one malformed additive
+ * field would be the wrong trade. `null` is never read as a usable default.
+ */
+function parseLaunchMergeFacts(body) {
+    const out = {};
+    if (Object.prototype.hasOwnProperty.call(body, "resolved_merge_execution_mode")) {
+        const mode = body.resolved_merge_execution_mode;
+        out.resolved_merge_execution_mode = RESOLVED_MERGE_EXECUTION_MODES.includes(mode)
+            ? mode
+            : null;
+    }
+    if (Object.prototype.hasOwnProperty.call(body, "provider_repository")) {
+        const repository = body.provider_repository;
+        out.provider_repository = isProviderRepositoryIdentity(repository) ? repository : null;
+    }
+    return out;
+}
 function parseReadinessDiagnostics(body) {
     if (body.diagnostics === undefined || body.diagnostics === null)
         return undefined;
@@ -3246,6 +3622,7 @@ export function parseEpicBranchCiReadiness(body) {
     });
     return {
         effective_review_mode: enumOrNull(o.effective_review_mode, EFFECTIVE_REVIEW_MODES),
+        effective_review_mode_scope: o.effective_review_mode_scope === "run" ? "run" : "repository",
         decision,
         evidence,
         no_ci_warning: requireBool(o, "no_ci_warning"),
@@ -3380,20 +3757,96 @@ function parseUnattended(body) {
         escalation_email_available: o.escalation_email_available === true,
     };
 }
-/**
- * GET `/jira/epic-runs/conductor-readiness?repo_name=<repo>`.
- *
- * The API key travels ONLY in `X-API-Key`; `repo_name` is URL-encoded into the
- * query string because the endpoint scopes on it. Fails closed on transport,
- * auth, and shape errors alike.
- */
-export async function fetchConductorReadiness(access, fetchImpl = globalThis.fetch) {
+export async function fetchConductorReadiness(access, fetchImpl = globalThis.fetch, options = {}) {
     const url = buildConductorJiraUrl(access.baseUrl, `${EPIC_RUNS_API_PREFIX}/conductor-readiness`, {
         repo_name: access.repoName,
+        ...(options.epicRunId ? { epic_run_id: options.epicRunId } : {}),
+    });
+    // BAPI-1455 — a `SCHEMA_INCOMPATIBLE` refusal explains itself in
+    // `detail.error` (the applied stamp, the missing objects, the repair route),
+    // so that field is read, with room for the object names.
+    const body = await fetchConductorJsonWithTimeout(url, conductorGetHeaders(access), CONDUCTOR_FETCH_TIMEOUT_MS, fetchImpl, {
+        readErrorField: true,
+        errorFieldPreviewMax: SCHEMA_REFUSAL_PREVIEW_MAX,
+        readErrorFieldOnlyFor: [SCHEMA_INCOMPATIBLE_ERROR_CODE],
     });
-    const body = await fetchConductorJsonWithTimeout(url, conductorGetHeaders(access), CONDUCTOR_FETCH_TIMEOUT_MS, fetchImpl);
     return parseConductorReadinessResponse(body);
 }
+/** The answer for every failure: an older server, a non-200, a timeout, a bad body. */
+export const REPOSITORY_USAGE_ADVISORY_UNAVAILABLE = Object.freeze({
+    state: "unavailable",
+    utilization_percent: null,
+    status: null,
+    observed_at: null,
+    resets_at: null,
+    stale: null,
+});
+/** Same size as the plane freshness probes' bound, so no launch read waits longer. */
+export const REPOSITORY_USAGE_ADVISORY_TIMEOUT_MS = 30_000;
+const USAGE_ADVISORY_STATES = new Set([
+    "observed",
+    "below_warning_threshold",
+    "absent",
+    "unavailable",
+]);
+const USAGE_ADVISORY_FIELD_MAX = 64;
+function boundedUsageString(value) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value !== "string" || value.length > USAGE_ADVISORY_FIELD_MAX)
+        return undefined;
+    return value;
+}
+/** Validate a usage-advisory body. `null` when any field is out of contract. */
+export function parseRepositoryUsageAdvisory(body) {
+    if (body === null || typeof body !== "object" || Array.isArray(body))
+        return null;
+    const o = body;
+    if (typeof o.state !== "string" || !USAGE_ADVISORY_STATES.has(o.state))
+        return null;
+    const percent = o.utilization_percent;
+    let utilization = null;
+    if (percent !== undefined && percent !== null) {
+        if (typeof percent !== "number" || !Number.isInteger(percent) || percent < 0 || percent > 100)
+            return null;
+        utilization = percent;
+    }
+    const status = boundedUsageString(o.status);
+    const observedAt = boundedUsageString(o.observed_at);
+    const resetsAt = boundedUsageString(o.resets_at);
+    if (status === undefined || observedAt === undefined || resetsAt === undefined)
+        return null;
+    if (observedAt !== null && Number.isNaN(Date.parse(observedAt)))
+        return null;
+    let stale = null;
+    if (o.stale !== undefined && o.stale !== null) {
+        if (typeof o.stale !== "boolean")
+            return null;
+        stale = o.stale;
+    }
+    const state = o.state;
+    if (state === "observed" && (utilization === null || status === null))
+        return null;
+    return { state, utilization_percent: utilization, status, observed_at: observedAt, resets_at: resetsAt, stale };
+}
+/**
+ * GET `/jira/epic-runs/usage-advisory?repo_name=<repo>`. NEVER throws: a 404
+ * from an older server, any other non-200, a transport failure, a timeout, or a
+ * malformed body is {@link REPOSITORY_USAGE_ADVISORY_UNAVAILABLE}. The launch
+ * preview turns that into a warning row; it can never change a launch decision.
+ */
+export async function fetchRepositoryUsageAdvisory(access, fetchImpl = globalThis.fetch) {
+    try {
+        const url = buildConductorJiraUrl(access.baseUrl, `${EPIC_RUNS_API_PREFIX}/usage-advisory`, {
+            repo_name: access.repoName,
+        });
+        const body = await fetchConductorJsonWithTimeout(url, conductorGetHeaders(access), REPOSITORY_USAGE_ADVISORY_TIMEOUT_MS, fetchImpl);
+        return parseRepositoryUsageAdvisory(body) ?? REPOSITORY_USAGE_ADVISORY_UNAVAILABLE;
+    }
+    catch {
+        return REPOSITORY_USAGE_ADVISORY_UNAVAILABLE;
+    }
+}
 const ROW_OUTCOMES = new Set(["created", "changed", "preserved"]);
 function optionalRowOutcome(o, key) {
     const v = o[key];
@@ -3766,6 +4219,126 @@ export async function resumeCiTicket(access, request, fetchImpl = globalThis.fet
         clearTimeout(timer);
     }
 }
+/** The closed refusal table of `regenerate-plan`; `CONFLICT` is the stale row version. */
+export const REGENERATE_PLAN_REFUSAL_CODES = [
+    "PLAN_REGEN_NOT_ELIGIBLE",
+    "PLAN_REGEN_OPERATION_CONFLICT",
+    "PLAN_REGEN_ANSWERED_CONFLICT",
+    "PLAN_REGEN_STALE_PARK",
+    "PLAN_REGEN_ALLOWANCE_SPENT",
+    "PLAN_REGEN_ROUTE_NOT_ALLOWED",
+    "PLAN_REGEN_RUN_NOT_ACTIVE",
+    "PLAN_REGEN_BUSY",
+    "PLAN_REGEN_SCHEMA_UNAVAILABLE",
+    "SPEC_SNAPSHOT_UNAVAILABLE",
+    "TICKET_NOT_IN_RUN",
+    "NOT_FOUND",
+    "CONFLICT",
+];
+/** True when `code` is one of the closed `regenerate-plan` refusal codes. */
+export function isRegeneratePlanRefusalCode(code) {
+    return REGENERATE_PLAN_REFUSAL_CODES.includes(code);
+}
+/** Strictly parse a `regenerate-plan` success body; anything short of the contract throws. */
+export function parseRegeneratePlanResult(value) {
+    if (!isPlainRecord(value))
+        throw new ConductorBridgeApiError("server");
+    const v = value;
+    if (typeof v.epic_run_id !== "string" || !v.epic_run_id ||
+        typeof v.ticket_key !== "string" || !v.ticket_key ||
+        (v.outcome !== "committed" && v.outcome !== "replayed" && v.outcome !== "answered_replay") ||
+        (v.accepted_route !== "test" && v.accepted_route !== "implementation") ||
+        !isNonNegativeInt(v.answered_park_generation) ||
+        !isNonNegativeInt(v.row_version) ||
+        !nullableString(v.ticket_status) ||
+        v.plan_ready !== false) {
+        throw new ConductorBridgeApiError("server");
+    }
+    return {
+        epic_run_id: v.epic_run_id,
+        ticket_key: v.ticket_key,
+        outcome: v.outcome,
+        accepted_route: v.accepted_route,
+        answered_park_generation: v.answered_park_generation,
+        row_version: v.row_version,
+        ticket_status: (v.ticket_status ?? null),
+        plan_ready: false,
+    };
+}
+/**
+ * POST `/jira/epic-runs/runs/{epic_run_id}/tickets/{ticket_key}/regenerate-plan`.
+ *
+ * Sends the pinned operation key and park generation only in the authenticated
+ * body. Never throws for an HTTP or transport outcome: every response is
+ * classified into a {@link RegeneratePlanPostOutcome}, so the caller — not this
+ * function — decides whether an uncertain outcome is retried with the SAME
+ * operation. It never falls back to another mutation.
+ */
+export async function regeneratePlanTicket(access, request, fetchImpl = globalThis.fetch, timeoutMs = CONDUCTOR_FETCH_TIMEOUT_MS) {
+    requireNonEmptyString(request.epicRunId);
+    requireNonEmptyString(request.ticketKey);
+    requireNonEmptyString(request.operationKey);
+    requireNonEmptyString(request.reason);
+    requireNonNegativeSafeInteger(request.expectedRowVersion);
+    requireNonNegativeSafeInteger(request.parkGeneration);
+    const url = buildConductorJiraUrl(access.baseUrl, `${continuationChildPath(request.epicRunId, request.ticketKey)}/regenerate-plan`);
+    const body = JSON.stringify({
+        repo_name: access.repoName,
+        route: request.route,
+        reason: request.reason,
+        expected_row_version: request.expectedRowVersion,
+        park_generation: request.parkGeneration,
+        operation_key: request.operationKey,
+    });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        let resp;
+        try {
+            resp = await fetchImpl(url, {
+                method: "POST",
+                headers: conductorPostHeaders(access),
+                body,
+                signal: controller.signal,
+            });
+        }
+        catch {
+            return { kind: "uncertain", reason: controller.signal.aborted ? "timeout" : "network" };
+        }
+        let parsed;
+        let parsedOk = true;
+        try {
+            parsed = await resp.json();
+        }
+        catch {
+            parsedOk = false;
+        }
+        if (resp.status >= 200 && resp.status < 300) {
+            if (!parsedOk)
+                return { kind: "uncertain", reason: "malformed", status: resp.status };
+            try {
+                return { kind: "result", result: parseRegeneratePlanResult(parsed) };
+            }
+            catch {
+                return { kind: "uncertain", reason: "malformed", status: resp.status };
+            }
+        }
+        const errorCode = parsedOk ? safeDetailErrorCode(parsed) : null;
+        if (errorCode !== null && isRegeneratePlanRefusalCode(errorCode)) {
+            return { kind: "refused", status: resp.status, errorCode };
+        }
+        if (errorCode === null && (resp.status === 404 || resp.status === 405)) {
+            return { kind: "unsupported_server", status: resp.status };
+        }
+        if (resp.status >= 500) {
+            return { kind: "uncertain", reason: "server", status: resp.status };
+        }
+        return { kind: "rejected", status: resp.status, errorCode };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 // ---------------------------------------------------------------------------
 // BAPI-1391 — gate profile, provider history, capability probe, qualification
 // ---------------------------------------------------------------------------
@@ -4162,3 +4735,9 @@ export async function fetchConductorGateQualificationJob(access, jobId, fetchImp
     const body = await fetchConductorJsonWithTimeout(gateProfileUrl(access, `qualification/${encodeURIComponent(String(jobId))}/`), conductorGetHeaders(access), CONDUCTOR_FETCH_TIMEOUT_MS, fetchImpl);
     return parseConductorGateQualificationJob(body, access.repoName, jobId);
 }
+/** Authenticated read-only preview of the same effective policy sent at creation. */
+export async function previewLaunchReadiness(access, policyJson, fetchImpl = globalThis.fetch) {
+    const url = buildConductorJiraUrl(access.baseUrl, `${EPIC_RUNS_API_PREFIX}/launch-readiness`);
+    const body = await fetchConductorJsonPostWithTimeout(url, conductorPostHeaders(access), JSON.stringify({ repo_name: access.repoName, policy_json: policyJson }), CONDUCTOR_FETCH_TIMEOUT_MS, fetchImpl);
+    return parseConductorReadinessResponse(body);
+}