@bridge_gpt/mcp-server 0.2.65 → 0.2.67

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

@@ -18,10 +18,31 @@ import { normalizePrNumber, normalizeSha } from "./git-ci-types.js";
 import { ConductorValidationError } from "./errors.js";
 import { parseContinuationStatusResult, parseContinueParkedChildResult, } from "./epic-child-continuation.js";
 import { resolveDeclaredRunBaseBranch } from "./run-branch.js";
+import { safeEpicLaunchTargetUrl } from "../epic-launch-diagnostic.js";
+import { validateHttpBaseUrl } from "../base-url.js";
+import { RERUN_CI_CHECK_STATUSES, RERUN_CI_NOT_RUNNABLE_REASONS, RERUN_CI_OUTCOMES, isCiResumeRefusalCode, } from "./repair-contract.js";
 /** Default Bridge API base URL when `BAPI_BASE_URL` is unset. */
 export const CONDUCTOR_DEFAULT_BASE_URL = "https://bridgegpt-api.com";
 /** Default per-request timeout for conductor Bridge API calls. */
 export const CONDUCTOR_FETCH_TIMEOUT_MS = 30_000;
+/** Keep an explicit readiness target from borrowing a key bound to another ambient endpoint. */
+export function readinessEndpointEnvironments(env, baseUrl) {
+    if (baseUrl === undefined)
+        return { reportEnv: env, resolverEnv: env };
+    const ambientBase = env.BAPI_BASE_URL ? validateHttpBaseUrl(env.BAPI_BASE_URL) : null;
+    const ambientMatchesOverride = ambientBase?.ok && ambientBase.baseUrl === baseUrl;
+    return {
+        reportEnv: { ...env, BAPI_BASE_URL: baseUrl, BAPI_EPIC_LAUNCH_PROFILE: undefined,
+            BAPI_API_KEY: ambientMatchesOverride ? env.BAPI_API_KEY : undefined },
+        resolverEnv: {
+            ...env,
+            BAPI_EPIC_LAUNCH_PROFILE: undefined,
+            // Never manufacture an ambient key's endpoint pairing. A stored key
+            // still passes its own binding check against the explicit target.
+            BAPI_BASE_URL: ambientMatchesOverride ? baseUrl : undefined,
+        },
+    };
+}
 /**
  * Resolve `{ repoName, apiKey, baseUrl }` from the environment, the shared repo
  * resolver, and the shared credential store. Never throws and never embeds the
@@ -91,9 +112,11 @@ export async function resolveEpicLaunchBridgeApiAccess(selection, deps = {}) {
     const platform = deps.platform ?? process.platform;
     const readFileImpl = deps.readFile ?? ((p) => readFile(p, "utf-8"));
     const statImpl = deps.stat ?? ((p) => stat(p));
+    const environmentProfile = env.BAPI_EPIC_LAUNCH_PROFILE?.trim();
+    const profileName = selection.profileName ?? (environmentProfile || undefined);
     let profile = null;
-    if (selection.profileName !== undefined) {
-        const read = await readEpicLaunchProfile(selection.profileName, {
+    if (profileName !== undefined) {
+        const read = await readEpicLaunchProfile(profileName, {
             env,
             homedir,
             readFile: readFileImpl,
@@ -107,11 +130,13 @@ export async function resolveEpicLaunchBridgeApiAccess(selection, deps = {}) {
         flagBaseUrl: selection.baseUrl,
         flagRepo: deps.repoName,
         profile,
+        profileSource: selection.profileName !== undefined ? "profile" : profile ? "profile-env" : undefined,
         env,
         defaultBaseUrl: CONDUCTOR_DEFAULT_BASE_URL,
     });
     if (!target.ok)
         return { ok: false, kind: target.kind, error: target.message };
+    const reportableTarget = safeEpicLaunchTargetUrl(target.baseUrl) ? { baseUrl: target.baseUrl } : {};
     const repoName = target.repoName ||
         deps.repoName?.trim() ||
         (await resolveStartTicketsRepoName({ env, cwd, readFile: readFileImpl }));
@@ -120,6 +145,7 @@ export async function resolveEpicLaunchBridgeApiAccess(selection, deps = {}) {
             ok: false,
             kind: "repo-missing",
             error: "could not resolve repo name (set BAPI_REPO_NAME or add a valid .bridge/config)",
+            ...reportableTarget,
         };
     }
     let cred;
@@ -127,15 +153,15 @@ export async function resolveEpicLaunchBridgeApiAccess(selection, deps = {}) {
         cred = await resolveEpicLaunchCredential(repoName, target.baseUrl, { env, homedir, platform, readFile: readFileImpl, stat: statImpl }, { productionBaseUrl: CONDUCTOR_DEFAULT_BASE_URL });
     }
     catch {
-        return { ok: false, kind: "credentials-unavailable", error: "failed to resolve Bridge API credentials" };
+        return { ok: false, kind: "credentials-unavailable", error: "failed to resolve Bridge API credentials", ...reportableTarget };
     }
     if (!cred.ok) {
         const bindingFailure = cred.kind === "binding-unbound" || cred.kind === "binding-mismatch" || cred.kind === "ambient-key-unbound";
         // The binding messages are fixed sentences naming the target KEY and the
         // store path only; the generic store failures stay generic as before.
         return bindingFailure
-            ? { ok: false, kind: "credential-unbound", error: cred.error }
-            : { ok: false, kind: "credentials-unavailable", error: "Bridge API credentials unavailable" };
+            ? { ok: false, kind: "credential-unbound", error: cred.error, ...reportableTarget }
+            : { ok: false, kind: "credentials-unavailable", error: "Bridge API credentials unavailable", ...reportableTarget };
     }
     return {
         ok: true,
@@ -1478,6 +1504,9 @@ async function postRepairRequest(access, apiPath, body, fetchImpl) {
     // The server's refusal explanation is the operator-facing message here.
     { readErrorField: true });
 }
+function withGuard(body, guard) {
+    return guard === undefined ? body : { ...body, guard };
+}
 /**
  * POST `/jira/epic-runs/runs/{epic_run_id}/scope-reparse` — re-drive the run's
  * OWN index scope through the retry-reparse lifecycle. Body: `{repo_name,
@@ -1487,7 +1516,7 @@ async function postRepairRequest(access, apiPath, body, fetchImpl) {
 export async function scopeReparse(access, request, fetchImpl = globalThis.fetch) {
     requireNonEmptyString(request.epicRunId);
     requireNonEmptyString(request.scopeId);
-    const parsed = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/scope-reparse`, { scope_id: request.scopeId }, fetchImpl);
+    const parsed = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/scope-reparse`, withGuard({ scope_id: request.scopeId }, request.guard), fetchImpl);
     return parseScopeReparseResult(parsed);
 }
 /**
@@ -1500,9 +1529,120 @@ export async function dispatchRemediation(access, request, fetchImpl = globalThi
     requireNonEmptyString(request.epicRunId);
     requireNonEmptyString(request.ticketKey);
     requireNonEmptyString(request.context);
-    const parsed = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/tickets/${encodeURIComponent(request.ticketKey)}/dispatch-remediation`, { context: request.context }, fetchImpl);
+    const parsed = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/tickets/${encodeURIComponent(request.ticketKey)}/dispatch-remediation`, withGuard({ context: request.context }, request.guard), fetchImpl);
     return parseDispatchRemediationResult(parsed);
 }
+// ---------------------------------------------------------------------------
+// BAPI-1388 — `rerun-ci`
+// ---------------------------------------------------------------------------
+/** The synthetic code an old server's missing route is reported under. */
+export const RERUN_CI_ROUTE_UNAVAILABLE_CODE = "RERUN_CI_ROUTE_UNAVAILABLE";
+/** The fixed operator text for a server that has no `rerun-ci` route. */
+export const RERUN_CI_ROUTE_UNAVAILABLE_MESSAGE = "rerun-ci is not available on this server; upgrade the Bridge API server before using it";
+const RERUN_CI_HEAD_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+function parseRerunCiCheck(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new ConductorBridgeApiError("server");
+    }
+    const c = value;
+    const status = c["status"];
+    if (typeof status !== "string" ||
+        !RERUN_CI_CHECK_STATUSES.includes(status)) {
+        throw new ConductorBridgeApiError("server");
+    }
+    const reason = c["reason"];
+    if (reason !== undefined &&
+        reason !== null &&
+        (typeof reason !== "string" ||
+            !RERUN_CI_NOT_RUNNABLE_REASONS.includes(reason))) {
+        throw new ConductorBridgeApiError("server");
+    }
+    const optionalPositive = (field) => {
+        const v = c[field];
+        if (v === undefined || v === null)
+            return null;
+        if (typeof v !== "number" || !Number.isSafeInteger(v) || v <= 0) {
+            throw new ConductorBridgeApiError("server");
+        }
+        return v;
+    };
+    const optionalText = (field) => {
+        const v = c[field];
+        if (v === undefined || v === null)
+            return null;
+        if (typeof v !== "string")
+            throw new ConductorBridgeApiError("server");
+        return v;
+    };
+    return {
+        name: optionalText("name"),
+        workflow_identity: optionalText("workflow_identity"),
+        run_id: optionalPositive("run_id"),
+        status: status,
+        reason: (reason ?? null),
+        job_id: optionalPositive("job_id"),
+    };
+}
+/**
+ * Strictly parse a `rerun-ci` success body. Anything short of the contract — an
+ * unknown outcome or per-check status, a malformed head, a non-list `checks` —
+ * throws, so a malformed answer is never read as a success.
+ */
+export function parseRerunCiResult(parsed) {
+    const p = parseRepairBase(parsed);
+    const outcome = p["outcome"];
+    const checks = p["checks"];
+    const head = p["head_sha"];
+    if (typeof p["ticket_key"] !== "string" ||
+        typeof outcome !== "string" ||
+        !RERUN_CI_OUTCOMES.includes(outcome) ||
+        !Array.isArray(checks) ||
+        (head !== undefined && head !== null && (typeof head !== "string" || !RERUN_CI_HEAD_RE.test(head)))) {
+        throw new ConductorBridgeApiError("server");
+    }
+    return {
+        epic_run_id: p["epic_run_id"],
+        ticket_key: p["ticket_key"],
+        before: parseRepairNullableString(p["before"]),
+        after: parseRepairNullableString(p["after"]),
+        committed: p["committed"],
+        event_recorded: p["event_recorded"],
+        outcome: outcome,
+        head_sha: typeof head === "string" ? head : null,
+        checks: checks.map(parseRerunCiCheck),
+    };
+}
+/**
+ * POST `/jira/epic-runs/runs/{epic_run_id}/tickets/{ticket_key}/rerun-ci` — body
+ * `{repo_name, guard}` and nothing else: no context, check list, or run id, because
+ * the SERVER decides what is re-runnable from its own fresh, head-bound CI read.
+ *
+ * A generic `{"detail":"Not Found"}` 404 or a 405 means the server predates the
+ * route; it is reported under {@link RERUN_CI_ROUTE_UNAVAILABLE_CODE} so no caller
+ * can read it as a refusal of THIS ticket or as a success (following
+ * {@link classifySupervisorBootstrapFailure}). A structured 404 — notably
+ * `TICKET_NOT_IN_RUN` — keeps its own code and stays a refusal.
+ */
+export async function rerunCi(access, request, fetchImpl = globalThis.fetch) {
+    requireNonEmptyString(request.epicRunId);
+    requireNonEmptyString(request.ticketKey);
+    let parsed;
+    try {
+        parsed = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/tickets/${encodeURIComponent(request.ticketKey)}/rerun-ci`, { guard: request.guard }, fetchImpl);
+    }
+    catch (err) {
+        if (err instanceof ConductorBridgeApiError &&
+            !err.errorCode &&
+            (err.status === 404 || err.status === 405)) {
+            throw new ConductorBridgeApiError("http", err.status, {
+                errorCode: RERUN_CI_ROUTE_UNAVAILABLE_CODE,
+                bodyPreview: RERUN_CI_ROUTE_UNAVAILABLE_MESSAGE,
+            });
+        }
+        throw err;
+    }
+    return parseRerunCiResult(parsed);
+}
 /**
  * POST `/jira/epic-runs/runs/{epic_run_id}/merge-child` — body EXACTLY
  * `{repo_name, pr_number}`. The server composes the head, gate, and action key.
@@ -1662,7 +1802,7 @@ function parseResumeRunResult(parsed) {
 export async function scopeCatchUp(access, request, fetchImpl = globalThis.fetch) {
     requireNonEmptyString(request.epicRunId);
     requireNonEmptyString(request.scopeId);
-    const parsed = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/scope-catch-up`, { scope_id: request.scopeId }, fetchImpl);
+    const parsed = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/scope-catch-up`, withGuard({ scope_id: request.scopeId }, request.guard), fetchImpl);
     return parseScopeCatchUpResult(parsed);
 }
 /**
@@ -1682,7 +1822,7 @@ export async function patchPolicy(access, request, fetchImpl = globalThis.fetch)
         Object.keys(patch).length === 0) {
         throw new ConductorBridgeApiError("invalid-input");
     }
-    const parsed = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/patch-policy`, { merge_patch: patch }, fetchImpl);
+    const parsed = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/patch-policy`, withGuard({ merge_patch: patch }, request.guard), fetchImpl);
     return parsePatchPolicyResult(parsed);
 }
 /**
@@ -1695,7 +1835,7 @@ export async function resumeRun(access, request, fetchImpl = globalThis.fetch) {
     if (typeof request.clearQuarantine !== "boolean") {
         throw new ConductorBridgeApiError("invalid-input");
     }
-    const parsed = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/resume-run`, { clear_quarantine: request.clearQuarantine }, fetchImpl);
+    const parsed = await postRepairRequest(access, `${epicRunApiPath(request.epicRunId)}/resume-run`, withGuard({ clear_quarantine: request.clearQuarantine }, request.guard), fetchImpl);
     return parseResumeRunResult(parsed);
 }
 /**
@@ -2440,6 +2580,20 @@ function requireBool(o, key) {
         throw readinessShapeError();
     return v;
 }
+/**
+ * An optional boolean field as a spreadable fragment: `{}` when the key is absent,
+ * `{ [key]: value }` when it is a boolean, and a shape error for anything else —
+ * including an explicit `null`. Spreading keeps an absent field ABSENT rather than
+ * present-as-`undefined`.
+ */
+function optionalBoolField(o, key) {
+    if (!(key in o) || o[key] === undefined)
+        return {};
+    const v = o[key];
+    if (typeof v !== "boolean")
+        throw readinessShapeError();
+    return { [key]: v };
+}
 function requireInt(o, key) {
     const v = o[key];
     if (typeof v !== "number" || !Number.isInteger(v))
@@ -2588,6 +2742,15 @@ function parseRequiredChecksVerification(sup, requiredChecksCount) {
         required_checks_evidence_fresh: fresh,
     };
 }
+/** Optional boolean: absent/null from an older server, a non-boolean fails closed. */
+function parseOptionalBool(o, key) {
+    const v = o[key];
+    if (v === undefined || v === null)
+        return null;
+    if (typeof v !== "boolean")
+        throw readinessShapeError();
+    return v;
+}
 /** Optional positive-integer threshold: absent/null from an older server. */
 function parseOptionalPositiveInt(o, key) {
     const v = o[key];
@@ -2637,6 +2800,9 @@ export function parseConductorReadinessResponse(body) {
             // Absent on a pre-BAPI-694 server, where no repository default can exist.
             review_policy_present: sup.review_policy_present === true,
             ...parseRequiredChecksVerification(sup, requiredChecksCount),
+            required_checks_retired_gate_configured: parseOptionalBool(sup, "required_checks_retired_gate_configured"),
+            required_checks_ci_workflow_absent: parseOptionalBool(sup, "required_checks_ci_workflow_absent"),
+            required_checks_review_workflow_absent: parseOptionalBool(sup, "required_checks_review_workflow_absent"),
         },
         github: {
             credentials_readable: requireBool(gh, "credentials_readable"),
@@ -2678,8 +2844,29 @@ export function parseConductorReadinessResponse(body) {
             const evidence = parseAdmissionEvidence(root);
             return evidence === undefined ? {} : { admission_evidence: evidence };
         })(),
+        ...(() => {
+            const diagnostics = parseReadinessDiagnostics(root);
+            return diagnostics === undefined ? {} : { diagnostics };
+        })(),
     };
 }
+function parseReadinessDiagnostics(body) {
+    if (body.diagnostics === undefined || body.diagnostics === null)
+        return undefined;
+    if (!Array.isArray(body.diagnostics) || body.diagnostics.length > 64)
+        throw readinessShapeError();
+    return body.diagnostics.map((entry) => {
+        const item = requireObject(entry);
+        if (typeof item.id !== "string" || !/^[a-z][a-z0-9_.-]{0,79}$/.test(item.id))
+            throw readinessShapeError();
+        const severity = item.severity === "mandatory" || item.severity === "advisory" ? item.severity : null;
+        const applicability = item.applicability === "applicable" || item.applicability === "inapplicable"
+            ? item.applicability : null;
+        const verdict = item.verdict === "passed" || item.verdict === "failed" || item.verdict === "unknown"
+            ? item.verdict : "unknown";
+        return { id: item.id, severity, applicability, verdict };
+    });
+}
 const ADMISSION_EVIDENCE_OWNERS = new Set(["operator", "repository_admin", "bridge_operations"]);
 const BOUNDED_TOKEN = /^[a-z0-9][a-z0-9_.:-]{0,79}$/;
 /**
@@ -2841,6 +3028,11 @@ function parseConductorCiWorkflow(body) {
         probe_succeeded: requireBool(o, "probe_succeeded"),
         workflow_present: requireBool(o, "workflow_present"),
         migration_guard_present: requireBool(o, "migration_guard_present"),
+        // BAPI-1359: OPTIONAL so a newer CLI still reads an older server. An absent
+        // key stays `undefined` — never materialized as a default — and a present key
+        // must be a real boolean (`null`, strings, numbers, and objects all reject).
+        ...optionalBoolField(o, "migration_guard_required"),
+        ...optionalBoolField(o, "migration_chain_probe_succeeded"),
     };
 }
 /**
@@ -3086,3 +3278,173 @@ export function classifySupervisorBootstrapFailure(err) {
         return "server";
     return "rejected";
 }
+const CI_STOP_REASONS = new Set(["wait_expired", "verdict_unavailable", "repair_exhausted"]);
+const RESUME_CI_AUDIT_WARNING_MAX = 200;
+function isPlainRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNonNegativeInt(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function nullableNonNegativeInt(value) {
+    return value === null || value === undefined || isNonNegativeInt(value);
+}
+function nullableString(value) {
+    return value === null || value === undefined || typeof value === "string";
+}
+function parseCiResumeOperation(value) {
+    if (!isPlainRecord(value))
+        throw new ConductorBridgeApiError("server");
+    const v = value;
+    if (typeof v.resumed_at !== "string" ||
+        !CI_STOP_REASONS.has(v.stop_reason) ||
+        !isNonNegativeInt(v.park_generation) ||
+        !isNonNegativeInt(v.resulting_park_generation) ||
+        v.resulting_park_generation !== v.park_generation + 1 ||
+        v.resumed_gate !== "ci" ||
+        v.ci_gate_status !== "in_progress" ||
+        v.allowance_effect !== "repair_allowances_preserved" ||
+        !isNonNegativeInt(v.preserved_attempts) ||
+        !nullableNonNegativeInt(v.preserved_ci_infra_rerun_attempts_used) ||
+        !nullableNonNegativeInt(v.preserved_entry_attempts) ||
+        !nullableString(v.deadline_at) ||
+        !(v.deadline_source === null || v.deadline_source === undefined ||
+            v.deadline_source === "original_gate" || v.deadline_source === "post_repair") ||
+        // The three fixed consequences are part of the contract, not decoration: a
+        // response claiming an extended deadline, a created job, or a CI pass is not
+        // a resume-ci success and is refused as malformed.
+        v.deadline_extended !== false ||
+        v.jobs_created !== 0 ||
+        v.ci_passed_by_action !== false) {
+        throw new ConductorBridgeApiError("server");
+    }
+    return {
+        resumed_at: v.resumed_at,
+        stop_reason: v.stop_reason,
+        park_generation: v.park_generation,
+        resulting_park_generation: v.resulting_park_generation,
+        resumed_gate: "ci",
+        ci_gate_status: "in_progress",
+        allowance_effect: "repair_allowances_preserved",
+        preserved_attempts: v.preserved_attempts,
+        preserved_ci_infra_rerun_attempts_used: (v.preserved_ci_infra_rerun_attempts_used ?? null),
+        preserved_entry_attempts: (v.preserved_entry_attempts ?? null),
+        deadline_at: (v.deadline_at ?? null),
+        deadline_source: (v.deadline_source ?? null),
+        deadline_extended: false,
+        jobs_created: 0,
+        ci_passed_by_action: false,
+    };
+}
+function parseCiResumeCurrentState(value) {
+    if (!isPlainRecord(value))
+        throw new ConductorBridgeApiError("server");
+    const v = value;
+    if (!nullableString(v.ticket_status) ||
+        !nullableString(v.current_gate) ||
+        !nullableString(v.ci_gate_status) ||
+        typeof v.held_by_run_control !== "boolean") {
+        throw new ConductorBridgeApiError("server");
+    }
+    return {
+        ticket_status: (v.ticket_status ?? null),
+        current_gate: (v.current_gate ?? null),
+        ci_gate_status: (v.ci_gate_status ?? null),
+        held_by_run_control: v.held_by_run_control,
+    };
+}
+/**
+ * Strictly parse a `resume-ci` success body. Anything short of the full
+ * contract — an unknown outcome, a missing history or current-state block, a
+ * non-boolean audit flag, an over-long warning — throws, and the caller treats
+ * that as an uncertain outcome, never as success.
+ */
+export function parseResumeCiResult(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") ||
+        typeof v.audit_recorded !== "boolean" ||
+        !(v.audit_warning === null || v.audit_warning === undefined ||
+            (typeof v.audit_warning === "string" && v.audit_warning.length <= RESUME_CI_AUDIT_WARNING_MAX))) {
+        throw new ConductorBridgeApiError("server");
+    }
+    return {
+        epic_run_id: v.epic_run_id,
+        ticket_key: v.ticket_key,
+        outcome: v.outcome,
+        operation: parseCiResumeOperation(v.operation),
+        current: parseCiResumeCurrentState(v.current),
+        audit_recorded: v.audit_recorded,
+        audit_warning: (v.audit_warning ?? null),
+    };
+}
+/**
+ * POST `/jira/epic-runs/runs/{epic_run_id}/tickets/{ticket_key}/resume-ci`.
+ *
+ * Sends the pinned operation key and stop binding only in the authenticated
+ * body. Never throws for an HTTP or transport outcome: every response is
+ * classified into a {@link ResumeCiPostOutcome}, so the caller — not this
+ * function — decides whether an uncertain outcome is retried with the SAME
+ * operation.
+ */
+export async function resumeCiTicket(access, request, fetchImpl = globalThis.fetch, timeoutMs = CONDUCTOR_FETCH_TIMEOUT_MS) {
+    requireNonEmptyString(request.epicRunId);
+    requireNonEmptyString(request.ticketKey);
+    requireNonEmptyString(request.operationKey);
+    requireNonNegativeSafeInteger(request.expectedRowVersion);
+    const url = buildConductorJiraUrl(access.baseUrl, `${continuationChildPath(request.epicRunId, request.ticketKey)}/resume-ci`);
+    const body = JSON.stringify({
+        repo_name: access.repoName,
+        expected_row_version: request.expectedRowVersion,
+        operation_key: request.operationKey,
+        stop_binding: request.stopBinding,
+    });
+    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: parseResumeCiResult(parsed) };
+            }
+            catch {
+                return { kind: "uncertain", reason: "malformed", status: resp.status };
+            }
+        }
+        const errorCode = parsedOk ? safeDetailErrorCode(parsed) : null;
+        if (errorCode !== null && isCiResumeRefusalCode(errorCode)) {
+            return { kind: "refused", status: resp.status, errorCode };
+        }
+        if (resp.status >= 500) {
+            return { kind: "uncertain", reason: "server", status: resp.status };
+        }
+        return { kind: "rejected", status: resp.status, errorCode };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/build/conductor/bring-up-facts.js

@@ -1,5 +1,5 @@
 /** The pinned operator runbook every remedy below points into. */
-export const BRING_UP_RUNBOOK = "docs/claude/epic-implementer-v2-operator-runbook.md";
+export const BRING_UP_RUNBOOK = "docs/epic-implementer/operator-runbook.md";
 /**
  * The client-derived refusal vocabulary, IN REFUSAL ORDER.
  *

package/build/conductor/doctor.js

@@ -822,9 +822,9 @@ export function formatConductorDoctorReport(report) {
             lines.push(`  - ${w}`);
     }
     lines.push("");
-    lines.push("Epic Conductor v2 reconciles epics server-side — nothing to schedule");
-    lines.push("locally. To execute claimed jobs on this machine, run:");
-    lines.push(`  npx -y ${MCP_PACKAGE_NAME} executor --repo <name>`);
+    lines.push("The Epic Implementer reconciles epics server-side — nothing to schedule");
+    lines.push("locally. To execute a run's claimed jobs on this machine, run:");
+    lines.push(`  npx -y ${MCP_PACKAGE_NAME} executor --repo <name> --epic-run-id <run-id>`);
     lines.push("");
     lines.push("MCP Profile (optional, local)");
     lines.push("─────────────────────────────");

package/build/conductor/epic-child-continuation.js

@@ -222,21 +222,74 @@ export function parseContinuationStatusResult(value) {
         receipt,
     };
 }
-/** Directory holding recovery references: beside the user credential store. */
-export function getContinuationReferenceDirectory(deps = {}) {
+/** The namespace (subdirectory) of the parked-child continuation references. */
+export const CONTINUATION_REFERENCE_NAMESPACE = "epic-child-continuations";
+/**
+ * Directory holding one namespace of recovery references, beside the user
+ * credential store. BAPI-1326's `resume-ci` keeps its pinned operations in its
+ * own namespace through this same store, so the two recoveries share one file
+ * format, one permission model, and one atomic-write path.
+ */
+export function getRecoveryReferenceDirectory(namespace, deps = {}) {
     const credentials = getPrimaryCredentialStorePath({
         env: deps.env ?? process.env,
         homedir: deps.homedir ?? os.homedir,
     });
-    return path.join(path.dirname(credentials), "epic-child-continuations");
+    return path.join(path.dirname(credentials), namespace);
+}
+/** Directory holding continuation recovery references. */
+export function getContinuationReferenceDirectory(deps = {}) {
+    return getRecoveryReferenceDirectory(CONTINUATION_REFERENCE_NAMESPACE, deps);
 }
 function referenceFileName(epicRunId, ticketKey) {
     // Hashed so an arbitrary run id or ticket key can never form a path segment.
     const digest = createHash("sha256").update(`${epicRunId}\u0000${ticketKey}`, "utf8").digest("hex");
     return `${digest.slice(0, 32)}.json`;
 }
+/** The file one (run, ticket) reference occupies within a namespace. */
+export function getRecoveryReferencePath(namespace, epicRunId, ticketKey, deps = {}) {
+    return path.join(getRecoveryReferenceDirectory(namespace, deps), referenceFileName(epicRunId, ticketKey));
+}
 export function getContinuationReferencePath(epicRunId, ticketKey, deps = {}) {
-    return path.join(getContinuationReferenceDirectory(deps), referenceFileName(epicRunId, ticketKey));
+    return getRecoveryReferencePath(CONTINUATION_REFERENCE_NAMESPACE, epicRunId, ticketKey, deps);
+}
+/** Read one namespaced reference as parsed JSON, or `null` when absent or unreadable. */
+export async function readRecoveryReferenceFile(namespace, key, deps = {}) {
+    const read = deps.readFile ?? fsReadFile;
+    let text;
+    try {
+        text = (await read(getRecoveryReferencePath(namespace, key.epicRunId, key.ticketKey, deps), "utf8"));
+    }
+    catch {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+/** Durably write one namespaced reference (0700 directory, 0600 file, write-then-rename). */
+export async function writeRecoveryReferenceFile(namespace, key, content, deps = {}) {
+    const mkdir = deps.mkdir ?? fsMkdir;
+    const writeFile = deps.writeFile ?? fsWriteFile;
+    const rename = deps.rename ?? fsRename;
+    await mkdir(getRecoveryReferenceDirectory(namespace, deps), { recursive: true, mode: 0o700 });
+    const target = getRecoveryReferencePath(namespace, key.epicRunId, key.ticketKey, deps);
+    const temp = `${target}.${process.pid}.tmp`;
+    await writeFile(temp, `${JSON.stringify(content, null, 2)}\n`, { mode: 0o600 });
+    await rename(temp, target);
+}
+/** Remove one namespaced reference. Never throws. */
+export async function clearRecoveryReferenceFile(namespace, key, deps = {}) {
+    const unlink = deps.unlink ?? fsUnlink;
+    try {
+        await unlink(getRecoveryReferencePath(namespace, key.epicRunId, key.ticketKey, deps));
+    }
+    catch {
+        // Already gone — nothing to clear.
+    }
 }
 function parseReference(raw) {
     if (!isRecord(raw) || raw.version !== 1 || !isRecord(raw.bindings))
@@ -276,44 +329,18 @@ function parseReference(raw) {
 }
 /** Read the in-flight reference for a child, or `null` when none (or unusable). */
 export async function readContinuationReference(epicRunId, ticketKey, deps = {}) {
-    const read = deps.readFile ?? fsReadFile;
-    let text;
-    try {
-        text = (await read(getContinuationReferencePath(epicRunId, ticketKey, deps), "utf8"));
-    }
-    catch {
-        return null;
-    }
-    try {
-        return parseReference(JSON.parse(text));
-    }
-    catch {
-        return null;
-    }
+    const raw = await readRecoveryReferenceFile(CONTINUATION_REFERENCE_NAMESPACE, { epicRunId, ticketKey }, deps);
+    return raw === null ? null : parseReference(raw);
 }
 /** Durably write a reference (0700 directory, 0600 file, write-then-rename). */
 export async function writeContinuationReference(reference, deps = {}, key = reference.bindings) {
-    const mkdir = deps.mkdir ?? fsMkdir;
-    const writeFile = deps.writeFile ?? fsWriteFile;
-    const rename = deps.rename ?? fsRename;
-    const dir = getContinuationReferenceDirectory(deps);
-    await mkdir(dir, { recursive: true, mode: 0o700 });
     // ``key`` only names the file (the caller may address the run by its epic key);
     // the stored bindings are always the exact, fingerprinted ones.
-    const target = getContinuationReferencePath(key.epicRunId, key.ticketKey, deps);
-    const temp = `${target}.${process.pid}.tmp`;
-    await writeFile(temp, `${JSON.stringify(reference, null, 2)}\n`, { mode: 0o600 });
-    await rename(temp, target);
+    await writeRecoveryReferenceFile(CONTINUATION_REFERENCE_NAMESPACE, key, reference, deps);
 }
 /** Remove a child's reference once its outcome is authoritative. Never throws. */
 export async function clearContinuationReference(epicRunId, ticketKey, deps = {}) {
-    const unlink = deps.unlink ?? fsUnlink;
-    try {
-        await unlink(getContinuationReferencePath(epicRunId, ticketKey, deps));
-    }
-    catch {
-        // Already gone — nothing to clear.
-    }
+    await clearRecoveryReferenceFile(CONTINUATION_REFERENCE_NAMESPACE, { epicRunId, ticketKey }, deps);
 }
 /** A fresh request id: a UUID, which satisfies the server's request-id bound. */
 export function newContinuationRequestId() {