@bridge_gpt/mcp-server 0.2.66 → 0.2.68

package/build/conductor/recovery-cli.js

@@ -1,15 +1,16 @@
 /**
- * `conductor` operator recovery and repair verbs — thirteen CLI-only commands.
+ * `conductor` operator recovery and repair verbs — fourteen CLI-only commands.
  *
  * The four BAPI-872 recovery verbs: `stop-run`, `abandon-run`, `unpark`,
  * `adopt-current-head-and-unpark`. The six run-addressed repair verbs: BAPI-1154's
  * `scope-reparse`, `dispatch-remediation`, `merge-child`, and BAPI-1176's
  * `scope-catch-up`, `patch-policy`, `resume-run`. BAPI-1300's parked-child
  * continuation pair: `continue-child` and the read-only `continuation-receipt`.
- * BAPI-1326's allowance-preserving CI resume: `resume-ci`.
+ * BAPI-1326's allowance-preserving CI resume: `resume-ci`. BAPI-1388's guided
+ * provider re-run of failed CI workflow runs: `rerun-ci`.
  *
  * CLI-only by design — this is an explicit ticket non-goal, not an oversight:
- * none of these thirteen command names is ever registered as an MCP tool, tool
+ * none of these fourteen command names is ever registered as an MCP tool, tool
  * description, or generated tool-schema input (`index-static.test.ts` guards
  * this). They exist so an operator (or `plane down`, via
  * `recovery-operations.ts`) can recover a stuck run or ticket WITHOUT
@@ -121,7 +122,7 @@ function parseRunRecoveryArgs(argv) {
     return { epicRunId: epicRunId.trim(), json: bools.has("--json"), help: false };
 }
 function parseTicketRecoveryArgs(argv) {
-    const { values, bools } = tokenizeRecoveryFlags(argv, TICKET_VALUE_FLAGS, RECOVERY_BOOL_FLAGS);
+    const { values, bools } = tokenizeRecoveryFlags(argv, new Set([...TICKET_VALUE_FLAGS, "--reason", "--cleanup-resolution"]), RECOVERY_BOOL_FLAGS);
     if (bools.has("--help")) {
         return { epicRunId: "", ticketKey: "", json: bools.has("--json"), help: true };
     }
@@ -136,6 +137,10 @@ function parseTicketRecoveryArgs(argv) {
     return {
         epicRunId: epicRunId.trim(),
         ticketKey: ticketKey.trim(),
+        ...(values.get("--reason") ? { reason: values.get("--reason").trim() } : {}),
+        ...(values.get("--cleanup-resolution") ? {
+            cleanupResolution: values.get("--cleanup-resolution"),
+        } : {}),
         json: bools.has("--json"),
         help: false,
     };
@@ -262,7 +267,7 @@ export async function runAbandonRunCommand(argv) {
 // unpark / adopt-current-head-and-unpark (shared rendering)
 // ---------------------------------------------------------------------------
 const UNPARK_USAGE = [
-    "Usage: epic-implementer unpark --epic-run-id <id> --ticket-key <key> [--json]",
+    "Usage: epic-implementer unpark --epic-run-id <id> --ticket-key <key> [--cleanup-resolution confirmed|risk_accepted --reason <text>] [--json]",
     "",
     "Move a parked (needs_human) ticket back into its gate machine, once the",
     "operator has resolved what parked it. Retries a bounded number of times on",
@@ -336,6 +341,13 @@ export function renderTicketRecoveryResult(result, json) {
 export async function runUnparkCommand(argv) {
     try {
         const parsed = parseTicketRecoveryArgs(argv);
+        if (parsed.cleanupResolution !== undefined &&
+            !["confirmed", "risk_accepted"].includes(parsed.cleanupResolution)) {
+            throw new ConductorValidationError("--cleanup-resolution must be confirmed or risk_accepted.");
+        }
+        if (parsed.cleanupResolution !== undefined && !parsed.reason) {
+            throw new ConductorValidationError("--cleanup-resolution requires --reason.");
+        }
         if (parsed.help) {
             console.log(UNPARK_USAGE);
             return 0;
@@ -347,6 +359,8 @@ export async function runUnparkCommand(argv) {
         const result = await unparkEpicTicketWithRetry(access, {
             epicRunId: parsed.epicRunId,
             ticketKey: parsed.ticketKey,
+            reason: parsed.reason,
+            cleanupResolution: parsed.cleanupResolution,
         });
         return renderTicketRecoveryResult(result, parsed.json);
     }
@@ -358,6 +372,9 @@ export async function runUnparkCommand(argv) {
 export async function runAdoptCurrentHeadAndUnparkCommand(argv) {
     try {
         const parsed = parseTicketRecoveryArgs(argv);
+        if (parsed.cleanupResolution !== undefined || parsed.reason !== undefined) {
+            throw new ConductorValidationError("Cleanup resolution applies only to unpark.");
+        }
         if (parsed.help) {
             console.log(ADOPT_CURRENT_HEAD_USAGE);
             return 0;
@@ -709,11 +726,13 @@ export async function runScopeReparseCommand(argv) {
 const DISPATCH_REMEDIATION_USAGE = [
     "Usage: epic-implementer dispatch-remediation --epic-run-id <id> --ticket-key <key> --context-file <path> [--json]",
     "",
-    "Dispatch a remediation job for a ticket at code_review (or parked there),",
+    "Dispatch a remediation job for a ticket at code_review or ci (or parked there),",
     "carrying your driver context to the worker. The SERVER chooses the job type",
-    "(remediate, or reconcile_overlap for a conflict/overlap ticket) and admits it",
+    "(remediate, or reconcile_overlap for a conflict/overlap ticket; ci_fix for a CI",
+    "failure the server's FRESH CI read routes to investigation) and admits it",
     "through the reconciler's own strict-serial lane, remediation budget, and",
-    "dedup key. A parked ticket is resumed in the same step.",
+    "dedup key. A parked ticket is resumed in the same step (unguided only). An",
+    "infrastructure CI failure is refused by name and points to rerun-ci.",
     "",
     `--context-file must be non-empty UTF-8 text of at most DRIVER_CONTEXT_MAX_BYTES`,
     `(${DRIVER_CONTEXT_MAX_BYTES} bytes). It is rejected, never truncated, and is never`,
@@ -764,7 +783,7 @@ export async function runDispatchRemediationCommand(argv, deps = {}) {
                     guard,
                 }),
                 label: `ticket ${parsed.ticketKey}`,
-                stateLabel: "code_review gate",
+                stateLabel: "selected gate",
             }, parsed.json);
         }
         const { dispatchRemediationRepair } = await import("./recovery-operations.js");
@@ -777,7 +796,7 @@ export async function runDispatchRemediationCommand(argv, deps = {}) {
             verb: "dispatch-remediation",
             epicRunId: parsed.epicRunId,
             targetLabel: `ticket ${parsed.ticketKey}`,
-            stateLabel: "code_review gate",
+            stateLabel: "selected gate",
         }, parsed.json, (result) => [
             `  job:             ${result.job_type || "unknown"}${result.job_id !== null ? ` (job ${result.job_id})` : ""}`,
         ]);
@@ -787,6 +806,195 @@ export async function runDispatchRemediationCommand(argv, deps = {}) {
         return 1;
     }
 }
+// ---------------------------------------------------------------------------
+// BAPI-1388 — rerun-ci
+// ---------------------------------------------------------------------------
+const RERUN_CI_VALUE_FLAGS = new Set(["--epic-run-id", "--ticket-key", "--binding"]);
+/** Exit codes: 0 applied (including an all-not-re-runnable no-op), 2 refused/stale, 3 unconfirmed, 1 other. */
+export const RERUN_CI_EXIT_OK = 0;
+export const RERUN_CI_EXIT_FAILED = 1;
+export const RERUN_CI_EXIT_REFUSED = 2;
+export const RERUN_CI_EXIT_UNCONFIRMED = 3;
+const RERUN_CI_USAGE = [
+    "Usage: epic-implementer rerun-ci --epic-run-id <id> --ticket-key <key> --binding <token> [--json]",
+    "",
+    "Ask the CI provider to re-run a ticket's FAILED required checks at its bound head,",
+    "for a ticket at ci or parked on it. Copy the command exactly as the run",
+    "explanation rendered it: --binding pins the ticket version and head it showed.",
+    "The SERVER re-reads fresh CI evidence, re-runs each GitHub Actions workflow run at",
+    "most once per head, and reports every failed check as enqueued, deduplicated,",
+    "deferred, or not_re_runnable.",
+    "",
+    "rerun-ci NEVER re-runs the claude-review workflow. It charges no allowance and",
+    "changes no park state, and a re-run is not a verdict: when CI is green, use",
+    "`epic-implementer resume-ci` (a parked ticket) or let the reconciler observe it.",
+    "If the failure is a code defect, use `dispatch-remediation --context-file`.",
+    "",
+    "The request is stored locally before it is sent, so re-running the same command",
+    "after a lost response re-sends the SAME request. A subject that has since changed",
+    "is refused as stale with nothing written.",
+    "",
+    "Exit codes: 0 applied (including a no-op when nothing could be re-run); 2 refused",
+    "or stale; 3 unconfirmed; 1 other failure (including a server without this verb).",
+].join("\n");
+export function parseRerunCiArgs(argv) {
+    const { values, bools } = tokenizeRecoveryFlags(argv, RERUN_CI_VALUE_FLAGS, RECOVERY_BOOL_FLAGS);
+    if (bools.has("--help")) {
+        return { epicRunId: "", ticketKey: "", binding: "", json: bools.has("--json"), help: true };
+    }
+    return {
+        epicRunId: requireFlag(values, "--epic-run-id"),
+        ticketKey: requireFlag(values, "--ticket-key"),
+        binding: requireFlag(values, "--binding"),
+        json: bools.has("--json"),
+        help: false,
+    };
+}
+const RERUN_CI_STATUS_TEXT = {
+    enqueued: "re-run requested",
+    deduplicated: "already requested",
+    deferred: "deferred (not requested; run the verb again after a fresh explain-run)",
+    not_re_runnable: "not re-runnable",
+};
+const RERUN_CI_REASON_TEXT = {
+    not_github_actions: "not a GitHub Actions check",
+    no_workflow_run_id: "no workflow run id",
+    claude_review_excluded: "claude-review is never re-run",
+};
+const RERUN_CI_OUTCOME_TEXT = {
+    enqueued: "re-runs requested",
+    partial: "partially requested (some runs deferred)",
+    nothing_to_enqueue: "nothing to enqueue (no failed check could be re-run)",
+};
+const RERUN_CI_NEXT_ACTION = {
+    enqueued: "Wait for the re-runs to finish, then read `epic-implementer explain-run`. When CI is " +
+        "green use `epic-implementer resume-ci` (a parked ticket); this verb did not mark CI passed.",
+    partial: "Some runs were not requested. Read `epic-implementer explain-run` and, if still " +
+        "offered, re-run the command it renders with its fresh binding.",
+    nothing_to_enqueue: "No re-run was possible. Read `epic-implementer explain-run`; for a code defect use " +
+        "`dispatch-remediation --context-file`.",
+};
+function rerunCiCheckLine(check) {
+    const identity = [
+        check.name ?? "(unnamed check)",
+        check.workflow_identity ? `workflow ${check.workflow_identity}` : null,
+        check.run_id !== null ? `run ${check.run_id}` : null,
+    ]
+        .filter((part) => part !== null)
+        .join(", ");
+    const reason = check.reason ? ` — ${RERUN_CI_REASON_TEXT[check.reason] ?? check.reason}` : "";
+    const job = check.job_id !== null ? ` (job ${check.job_id})` : "";
+    return `    - ${identity}: ${RERUN_CI_STATUS_TEXT[check.status] ?? check.status}${reason}${job}`;
+}
+/**
+ * Exported for tests: render one `rerun-ci` outcome. Success goes to stdout and
+ * every failure to stderr (`--json` included). An unsupported server is NEVER a
+ * success and says it is "not available on this server".
+ */
+export function renderRerunCiOutcome(outcome, parsed, json) {
+    const label = `ticket ${parsed.ticketKey} (run ${parsed.epicRunId})`;
+    if (outcome.kind === "applied") {
+        const result = outcome.result;
+        if (result.committed && !result.event_recorded) {
+            console.error(`Warning: rerun-ci for ${label} COMMITTED, but its operator_verb_applied audit ` +
+                "event was not recorded. The action stands.");
+        }
+        if (json) {
+            console.log(JSON.stringify({
+                ok: true,
+                outcome: "applied",
+                request_id: outcome.requestId,
+                reference_reused: outcome.referenceReused,
+                result,
+            }));
+            return RERUN_CI_EXIT_OK;
+        }
+        const lines = [
+            `rerun-ci (guided) — ${label}`,
+            `  ticket:          ${result.ticket_key}`,
+            `  head:            ${result.head_sha ? "`" + result.head_sha + "`" : "unknown"}`,
+            `  outcome:         ${RERUN_CI_OUTCOME_TEXT[result.outcome] ?? result.outcome}`,
+            "  failed checks:",
+            ...result.checks.map(rerunCiCheckLine),
+            `  next action:     ${RERUN_CI_NEXT_ACTION[result.outcome] ?? "Read `epic-implementer explain-run`."}`,
+            `  request:         ${outcome.requestId}${outcome.referenceReused ? " (re-sent from the local reference)" : ""}`,
+            `  event recorded:  ${result.event_recorded}`,
+        ];
+        console.log(lines.join("\n"));
+        return RERUN_CI_EXIT_OK;
+    }
+    if (outcome.kind === "refused" || outcome.kind === "stale") {
+        const payload = {
+            ok: false,
+            outcome: outcome.kind,
+            code: outcome.code,
+            message: outcome.message,
+            request_id: outcome.requestId,
+            nothing_written: true,
+        };
+        if (json) {
+            console.error(JSON.stringify(payload));
+        }
+        else {
+            console.error(`Refused: rerun-ci for ${label} — ${outcome.code}: ${outcome.message}. ` +
+                (outcome.kind === "stale"
+                    ? "Nothing was written. The run changed since this command was rendered; re-read the run explanation."
+                    : "Nothing was written."));
+        }
+        return RERUN_CI_EXIT_REFUSED;
+    }
+    if (outcome.kind === "unconfirmed") {
+        if (json) {
+            console.error(JSON.stringify({
+                ok: false,
+                outcome: "unconfirmed",
+                reason: outcome.reason,
+                message: outcome.message,
+                request_id: outcome.requestId,
+            }));
+        }
+        else {
+            console.error(`Unconfirmed: rerun-ci for ${label} — ${outcome.message}.`);
+        }
+        return RERUN_CI_EXIT_UNCONFIRMED;
+    }
+    if (json) {
+        console.error(JSON.stringify({ ok: false, outcome: outcome.kind, message: outcome.message }));
+    }
+    else {
+        console.error(`Failed: rerun-ci for ${label} — ${outcome.message}.`);
+    }
+    return RERUN_CI_EXIT_FAILED;
+}
+export async function runRerunCiCommand(argv) {
+    try {
+        const parsed = parseRerunCiArgs(argv);
+        if (parsed.help) {
+            console.log(RERUN_CI_USAGE);
+            return 0;
+        }
+        // Prove the token names THIS command, run, and ticket before credentials are
+        // resolved, so a mismatched binding reaches no one.
+        const binding = checkGuidedBinding(parsed.binding, "rerun-ci", {
+            epicRunId: parsed.epicRunId,
+            ticketKey: parsed.ticketKey,
+        });
+        const access = await resolveRecoveryAccess(parsed.json);
+        if (!access)
+            return RERUN_CI_EXIT_FAILED;
+        const { rerunCiRepair } = await import("./recovery-operations.js");
+        const outcome = await rerunCiRepair(access, {
+            epicRunId: parsed.epicRunId,
+            ticketKey: parsed.ticketKey,
+            binding,
+        });
+        return renderRerunCiOutcome(outcome, parsed, parsed.json);
+    }
+    catch (error) {
+        console.error(`Error: ${toConductorErrorEnvelope(error).message}`);
+        return RERUN_CI_EXIT_FAILED;
+    }
+}
 const MERGE_CHILD_USAGE = [
     "Usage: epic-implementer merge-child --epic-run-id <id> --pr <number> [--json]",
     "",
@@ -1128,11 +1336,11 @@ export async function runResumeRunCommand(argv) {
 // ---------------------------------------------------------------------------
 // continue-child / continuation-receipt (BAPI-1300)
 // ---------------------------------------------------------------------------
-const CONTINUE_CHILD_VALUE_FLAGS = new Set(["--epic-run-id", "--ticket-key", "--reason"]);
+const CONTINUE_CHILD_VALUE_FLAGS = new Set(["--epic-run-id", "--ticket-key", "--reason", "--worker-exit-proof"]);
 const CONTINUATION_RECEIPT_VALUE_FLAGS = new Set(["--epic-run-id", "--ticket-key", "--request-id"]);
 const MAX_REASON_CHARS = 500;
 const CONTINUE_CHILD_USAGE = [
-    "Usage: epic-implementer continue-child --epic-run-id <id> --ticket-key <key> [--reason <text>] [--json]",
+    "Usage: epic-implementer continue-child --epic-run-id <id> --ticket-key <key> [--reason <text> --worker-exit-proof exited|fenced] [--json]",
     "",
     "Continue a parked child's CURRENT park episode without resetting it: the same",
     "attempt resumes on its retained work with only the allowance it has left (no",
@@ -1159,6 +1367,13 @@ function parseContinuationArgs(argv, valueFlags) {
     const epicRunId = requireFlag(values, "--epic-run-id");
     const ticketKey = requireFlag(values, "--ticket-key");
     const reason = values.get("--reason")?.trim();
+    const workerExitProof = values.get("--worker-exit-proof")?.trim();
+    if (workerExitProof !== undefined && workerExitProof !== "exited" && workerExitProof !== "fenced") {
+        throw new ConductorValidationError('Flag "--worker-exit-proof" must be exited or fenced.');
+    }
+    if (workerExitProof !== undefined && !reason) {
+        throw new ConductorValidationError('Flag "--worker-exit-proof" requires --reason.');
+    }
     if (reason !== undefined && reason.length > MAX_REASON_CHARS) {
         throw new ConductorValidationError(`Flag "--reason" must be at most ${MAX_REASON_CHARS} characters.`);
     }
@@ -1170,6 +1385,7 @@ function parseContinuationArgs(argv, valueFlags) {
         epicRunId,
         ticketKey,
         ...(reason ? { reason } : {}),
+        ...(workerExitProof ? { workerExitProof: workerExitProof } : {}),
         ...(requestId ? { requestId } : {}),
         json: bools.has("--json"),
         help: false,
@@ -1387,6 +1603,7 @@ export async function runContinueChildCommand(argv) {
             epicRunId: parsed.epicRunId,
             ticketKey: parsed.ticketKey,
             ...(parsed.reason ? { reason: parsed.reason } : {}),
+            ...(parsed.workerExitProof ? { workerExitProof: parsed.workerExitProof } : {}),
         });
         return renderContinueChildResult(result, parsed, parsed.json);
     }
@@ -1395,6 +1612,60 @@ export async function runContinueChildCommand(argv) {
         return 1;
     }
 }
+/** Explicit, bounded grant for the current parked attempt. */
+export async function runGrantContinuationCommand(argv) {
+    try {
+        const { values, bools } = tokenizeRecoveryFlags(argv, new Set(["--epic-run-id", "--ticket-key", "--extra-continuations", "--extra-seconds", "--reason", "--request-id"]), RECOVERY_BOOL_FLAGS);
+        if (bools.has("--help")) {
+            console.log("Usage: epic-implementer grant-continuation --epic-run-id <id> --ticket-key <key> --reason <text> [--extra-continuations 1] [--extra-seconds <1..3600>] [--request-id <id>] [--json]");
+            return 0;
+        }
+        const epicRunId = requireFlag(values, "--epic-run-id");
+        const ticketKey = requireFlag(values, "--ticket-key");
+        const reason = requireFlag(values, "--reason");
+        const extraContinuations = Number(values.get("--extra-continuations") ?? "0");
+        const extraSeconds = Number(values.get("--extra-seconds") ?? "0");
+        if (!Number.isInteger(extraContinuations) || extraContinuations < 0 || extraContinuations > 1 ||
+            !Number.isInteger(extraSeconds) || extraSeconds < 0 || extraSeconds > 3600 ||
+            (extraContinuations === 0 && extraSeconds === 0) || reason.length > MAX_REASON_CHARS) {
+            throw new ConductorValidationError("Grant amounts or reason are outside the allowed bounds.");
+        }
+        const explicitRequestId = values.get("--request-id");
+        if (explicitRequestId !== undefined && !/^[A-Za-z0-9][A-Za-z0-9._:-]{7,63}$/.test(explicitRequestId)) {
+            throw new ConductorValidationError("--request-id is malformed.");
+        }
+        const json = bools.has("--json");
+        const access = await resolveRecoveryAccess(json);
+        if (!access)
+            return 1;
+        const { grantContinuationOnce } = await import("./recovery-operations.js");
+        const operation = await grantContinuationOnce(access, {
+            epicRunId, ticketKey, extraContinuations, extraSeconds, reason,
+            ...(explicitRequestId !== undefined ? { requestId: explicitRequestId } : {}),
+        });
+        if (operation.kind === "not_parked") {
+            throw new ConductorValidationError("The child is not parked at a continuable gate.");
+        }
+        if (operation.kind === "unavailable") {
+            console.error(`Error: ${operation.message}`);
+            return 1;
+        }
+        const { requestId, outcome: result } = operation;
+        if (json)
+            console.log(JSON.stringify({ ...result, request_id: requestId }));
+        else if (result.kind === "result")
+            console.log(`Grant ${result.replayed ? "replayed" : "committed"}: ${requestId}. The child remains parked.`);
+        else if (result.kind === "unconfirmed")
+            console.error(`Grant outcome unconfirmed. Rerun the same command; it reuses request ${requestId}.`);
+        else
+            console.error(`Grant refused (${result.status}${result.errorCode ? `, ${result.errorCode}` : ""}).`);
+        return result.kind === "result" ? 0 : 1;
+    }
+    catch (error) {
+        console.error(`Error: ${toConductorErrorEnvelope(error).message}`);
+        return 1;
+    }
+}
 export async function runContinuationReceiptCommand(argv) {
     try {
         const parsed = parseContinuationReceiptArgs(argv);
@@ -1653,3 +1924,30 @@ export async function runResumeCiCommand(argv) {
         return RESUME_CI_EXIT_FAILED;
     }
 }
+/** No state mutation: callers halt the affected work before asking a question. */
+export async function runEscalateCommand(argv, deps = {}) {
+    try {
+        const { values, bools } = tokenizeRecoveryFlags(argv, new Set(["--epic-run-id", "--ticket-key", "--cause", "--action-needed"]), RECOVERY_BOOL_FLAGS);
+        if (bools.has("--help")) {
+            console.log("Usage: epic-implementer escalate --epic-run-id <id> --ticket-key <key> --cause <cause> --action-needed <text> [--json]");
+            return 0;
+        }
+        const request = { epicRunId: requireFlag(values, "--epic-run-id"),
+            ticketKey: requireFlag(values, "--ticket-key"), cause: requireFlag(values, "--cause"),
+            actionNeeded: requireFlag(values, "--action-needed") };
+        if (request.actionNeeded.length > 300) {
+            console.error("Error: action-needed exceeds 300 characters");
+            return 1;
+        }
+        const access = await (deps.resolveAccess ?? (() => resolveRecoveryAccess(false)))();
+        if (!access)
+            return 1;
+        const escalate = deps.escalate ?? (await import("./bridge-api-client.js")).escalateTicket;
+        console.log(JSON.stringify(await escalate(access, request)));
+        return 0;
+    }
+    catch {
+        console.error("Error: escalation request refused or unavailable");
+        return 1;
+    }
+}

package/build/conductor/recovery-operations.js

@@ -18,12 +18,12 @@
  * callers: `recovery-cli.ts` and `plane/shutdown.ts`.
  */
 import { randomUUID } from "crypto";
-import { adoptCurrentHeadAndUnparkTicket, completeMergeChild, ConductorBridgeApiError, dispatchRemediation, fetchEpicRunState, mergeChild, patchPolicy, resumeRun, safeDiagnosticMessage, scopeCatchUp, scopeReparse, stopEpicRun, unparkEpicTicket, updateEpicRunStatus, fetchChildContinuationStatus, postContinueParkedChild, resumeCiTicket, REVIEW_HEAD_REFUSAL_CODES, } from "./bridge-api-client.js";
-import { clearGuidedReference, guardForBinding, GUIDED_PAYLOAD_CONFLICT_MESSAGE, GUIDED_REFERENCE_STORE_FAILED_MESSAGE, prepareGuidedRequest, } from "./guided-repair.js";
+import { adoptCurrentHeadAndUnparkTicket, completeMergeChild, ConductorBridgeApiError, dispatchRemediation, fetchEpicRunState, mergeChild, patchPolicy, RERUN_CI_ROUTE_UNAVAILABLE_CODE, RERUN_CI_ROUTE_UNAVAILABLE_MESSAGE, rerunCi, resumeRun, safeDiagnosticMessage, scopeCatchUp, scopeReparse, stopEpicRun, unparkEpicTicket, updateEpicRunStatus, fetchChildContinuationStatus, postContinueParkedChild, postGrantContinuation, resumeCiTicket, REVIEW_HEAD_REFUSAL_CODES, } from "./bridge-api-client.js";
+import { clearGuidedReference, guardForBinding, GUIDED_PAYLOAD_CONFLICT_MESSAGE, GUIDED_REFERENCE_STORE_FAILED_MESSAGE, guidedPayloadDigest, prepareGuidedRequest, } from "./guided-repair.js";
 import { DEFAULT_GATE_NAME } from "./git-ci-types.js";
 import { canonicalSha256, clearContinuationReference, clearRecoveryReferenceFile, computeContinuationFingerprint, readRecoveryReferenceFile, writeRecoveryReferenceFile, isFullSha, newContinuationRequestId, readContinuationReference, writeContinuationReference, } from "./epic-child-continuation.js";
 import { resolveLocalMergeCredential, resolveLocalMergeMethod, runApprovedLocalMerge, } from "./local-merge.js";
-import { RESUME_RUN_UNCONFIRMED_MESSAGE } from "./repair-contract.js";
+import { RERUN_CI_UNCONFIRMED_REASON, RESUME_RUN_UNCONFIRMED_MESSAGE } from "./repair-contract.js";
 /**
  * Bounded total attempts for a ticket-recovery CAS retry loop. Each attempt
  * begins with a fresh, authoritative state read — so this bounds full
@@ -179,6 +179,7 @@ async function ticketRecoveryWithRetry(access, options, mutate) {
                 expectedRowVersion: ticket.row_version,
                 idempotencyKey,
                 reason: options.reason,
+                cleanupResolution: options.cleanupResolution,
             });
         }
         catch (err) {
@@ -501,6 +502,72 @@ export async function guidedRepairOnce(options, deps = {}) {
         ? { kind: "committed", result, requestId, referenceReused }
         : { kind: "no_op", result, requestId, referenceReused };
 }
+/** The bounded unconfirmed text for a `rerun-ci` whose release write was lost. */
+export const RERUN_CI_COMPENSATION_UNCONFIRMED_MESSAGE = "the server could not confirm whether the workflow runs it did not enqueue are still " +
+    "recorded for this head. Re-read the run explanation before choosing another action";
+/**
+ * Send ONE guided `rerun-ci`, pinned to its displayed binding, through the shared
+ * guided-repair reference (stored BEFORE the first POST; a lost response re-sends
+ * the SAME request). The server decides eligibility and every per-check status;
+ * this layer only classifies the answer.
+ */
+export async function rerunCiRepair(access, options, deps = {}) {
+    const call = deps.rerunCi ?? rerunCi;
+    const outcome = await guidedRepairOnce({
+        binding: options.binding,
+        payloadDigest: guidedPayloadDigest({ ticket_key: options.ticketKey }),
+        send: (guard) => call(access, { epicRunId: options.epicRunId, ticketKey: options.ticketKey, guard }),
+        unconfirmedMessage: "the outcome could not be confirmed: the server may or may not have requested the " +
+            "re-runs. Re-run the SAME command to re-send the same pinned request, or inspect " +
+            "the run read-only",
+    }, deps);
+    switch (outcome.kind) {
+        case "committed":
+        case "no_op":
+            return {
+                kind: "applied",
+                result: outcome.result,
+                requestId: outcome.requestId,
+                referenceReused: outcome.referenceReused,
+            };
+        case "stale":
+            return {
+                kind: "stale",
+                code: outcome.code,
+                message: outcome.message,
+                requestId: outcome.requestId,
+            };
+        case "refused":
+            if (outcome.code === RERUN_CI_ROUTE_UNAVAILABLE_CODE) {
+                return { kind: "unsupported", message: RERUN_CI_ROUTE_UNAVAILABLE_MESSAGE };
+            }
+            if (outcome.code === "ROW_VERSION_CONFLICT" &&
+                outcome.message.includes(RERUN_CI_UNCONFIRMED_REASON)) {
+                return {
+                    kind: "unconfirmed",
+                    reason: "compensation_conflict",
+                    message: RERUN_CI_COMPENSATION_UNCONFIRMED_MESSAGE,
+                    requestId: outcome.requestId,
+                };
+            }
+            return {
+                kind: "refused",
+                code: outcome.code,
+                status: outcome.status,
+                message: outcome.message,
+                requestId: outcome.requestId,
+            };
+        case "unconfirmed":
+            return {
+                kind: "unconfirmed",
+                reason: "transport",
+                message: outcome.message,
+                requestId: outcome.requestId,
+            };
+        default:
+            return { kind: "unavailable", message: outcome.message };
+    }
+}
 const AUTHORITATIVE_OUTCOMES = new Set([
     "committed",
     "already_continued",
@@ -631,6 +698,7 @@ export async function continueChildOnce(access, options, deps = {}) {
         requestId: ref.requestId,
         requestFingerprint: ref.requestFingerprint,
         reason: options.reason,
+        workerExitProof: options.workerExitProof,
     });
     if (outcome.kind === "result" && AUTHORITATIVE_OUTCOMES.has(outcome.result.outcome)) {
         await clear();
@@ -658,6 +726,102 @@ export async function continueChildOnce(access, options, deps = {}) {
     }
     return { kind: "unconfirmed", requestId: ref.requestId, reusedReference, transport };
 }
+/** The namespace of pending `grant-continuation` requests (BAPI-1409). */
+export const CONTINUATION_GRANT_REFERENCE_NAMESPACE = "epic-continuation-grants";
+const GRANT_REQUEST_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,63}$/;
+function pendingGrantMatches(raw, wanted) {
+    if (raw === null || typeof raw !== "object")
+        return null;
+    const ref = raw;
+    if (ref.version !== 1 ||
+        ref.repoName !== wanted.repoName ||
+        ref.parkedGate !== wanted.parkedGate ||
+        ref.sourceParkGeneration !== wanted.sourceParkGeneration ||
+        ref.extraContinuations !== wanted.extraContinuations ||
+        ref.extraSeconds !== wanted.extraSeconds ||
+        ref.reason !== wanted.reason ||
+        typeof ref.requestId !== "string" ||
+        !GRANT_REQUEST_ID_RE.test(ref.requestId)) {
+        return null;
+    }
+    return ref.requestId;
+}
+/**
+ * Grant bounded continuation capacity, at most one POST per invocation.
+ *
+ * The request id is pinned locally BEFORE the POST, keyed by run and ticket, and
+ * reused while the park episode, gate, amounts, and reason are unchanged. A rerun
+ * after a lost response therefore replays the same grant (the server answers it
+ * from the stored grant) instead of spending a second one. The reference is
+ * cleared once the outcome is authoritative and kept when it is unconfirmed.
+ */
+export async function grantContinuationOnce(access, options, deps = {}) {
+    const fetchStatus = deps.fetchStatus ?? fetchChildContinuationStatus;
+    const post = deps.post ?? postGrantContinuation;
+    const store = deps.store ?? {};
+    const key = { epicRunId: options.epicRunId, ticketKey: options.ticketKey };
+    let status;
+    try {
+        status = await fetchStatus(access, key);
+    }
+    catch (err) {
+        return { kind: "unavailable", message: safeDiagnosticMessage(err, "could not read the child") };
+    }
+    const current = status.current;
+    if (!current.parked || current.parked_gate === null || current.park_generation === null) {
+        return { kind: "not_parked" };
+    }
+    const wanted = {
+        version: 1,
+        repoName: access.repoName,
+        parkedGate: current.parked_gate,
+        sourceParkGeneration: current.park_generation,
+        extraContinuations: options.extraContinuations,
+        extraSeconds: options.extraSeconds,
+        reason: options.reason,
+    };
+    let requestId = options.requestId ?? null;
+    let reusedReference = false;
+    const pinned = requestId === null;
+    if (pinned) {
+        const stored = pendingGrantMatches(await readRecoveryReferenceFile(CONTINUATION_GRANT_REFERENCE_NAMESPACE, key, store), wanted);
+        if (stored !== null) {
+            requestId = stored;
+            reusedReference = true;
+        }
+        else {
+            requestId = `grant_${(deps.newRequestId ?? randomUUID)()}`;
+            const reference = {
+                ...wanted, requestId, createdAt: new Date().toISOString(),
+            };
+            try {
+                await writeRecoveryReferenceFile(CONTINUATION_GRANT_REFERENCE_NAMESPACE, key, reference, store);
+            }
+            catch {
+                return {
+                    kind: "unavailable",
+                    message: "could not store the local grant reference, so the request was not sent",
+                };
+            }
+        }
+    }
+    const id = requestId;
+    const outcome = await post(access, {
+        epicRunId: options.epicRunId,
+        ticketKey: options.ticketKey,
+        requestId: id,
+        parkedGate: current.parked_gate,
+        expectedRowVersion: current.row_version,
+        sourceParkGeneration: current.park_generation,
+        extraContinuations: options.extraContinuations,
+        extraSeconds: options.extraSeconds,
+        reason: options.reason,
+    });
+    if (pinned && outcome.kind !== "unconfirmed") {
+        await clearRecoveryReferenceFile(CONTINUATION_GRANT_REFERENCE_NAMESPACE, key, store);
+    }
+    return { kind: "posted", requestId: id, reusedReference, outcome };
+}
 /**
  * Read a child's current episode and, when a local recovery reference exists (or
  * `requestId` is given), that request's receipt. One bounded GET; read-only. A