@bridge_gpt/mcp-server 0.2.65 → 0.2.66

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 { 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,7 +1529,7 @@ 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);
 }
 /**
@@ -1662,7 +1691,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 +1711,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 +1724,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);
 }
 /**
@@ -2678,8 +2707,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}$/;
 /**
@@ -3086,3 +3136,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/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() {

package/build/conductor/epic-implementer-cli.js

@@ -112,6 +112,9 @@ export function getConductorUsage() {
         "  continuation-receipt --epic-run-id <id> --ticket-key <key> [--request-id <id>] [--json]",
         "                       Read-only: the child's current episode and whether a continuation",
         "                       request's receipt proves it committed (use after a lost response).",
+        "  resume-ci --epic-run-id <id> --ticket-key <key> [--json]",
+        "                       Resume a child parked on a qualified CI stop once CI is green: CI",
+        "                       returns to evaluation with NO new wait, job, or repair allowance.",
         "",
         "supervise options:",
         "  --run-id <id>             Run/session identifier to supervise (required)",
@@ -254,6 +257,8 @@ export function getConductorUsage() {
         "  epic-implementer continue-child --epic-run-id 3f9c2b7e-... --ticket-key BAPI-852",
         "  # The continue-child response was lost — did it commit?",
         "  epic-implementer continuation-receipt --epic-run-id 3f9c2b7e-... --ticket-key BAPI-852",
+        "  # CI finished green after the child parked on an expired CI wait:",
+        "  epic-implementer resume-ci --epic-run-id 3f9c2b7e-... --ticket-key BAPI-852",
     ].join("\n");
 }
 /**
@@ -305,6 +310,8 @@ const VALID_COMMANDS = new Set([
     // BAPI-1300: CLI-only parked-child continuation pair — never registered as MCP tools.
     "continue-child",
     "continuation-receipt",
+    // BAPI-1326: CLI-only allowance-preserving CI resume — never an MCP tool.
+    "resume-ci",
     // Private, and deliberately ABSENT from the usage text: `__hook-bin` exists as
     // the bundled-artifact regression guard for BAPI-772 (mirroring `plane
     // __entrypoint`), not as a supported operator workflow.
@@ -1439,6 +1446,11 @@ export async function runEpicImplementerCli(argv) {
                 const { runContinuationReceiptCommand } = await import("./recovery-cli.js");
                 return await runContinuationReceiptCommand(parsed.argv);
             }
+            case "resume-ci": {
+                // BAPI-1326: delegates only to the pinned CI recovery operation.
+                const { runResumeCiCommand } = await import("./recovery-cli.js");
+                return await runResumeCiCommand(parsed.argv);
+            }
             default:
                 console.error('Error: Unknown command. Run "epic-implementer --help" for usage.');
                 return 1;