@bridge_gpt/mcp-server 0.2.68 → 0.2.70

package/build/v2-readiness-requirements.js

@@ -0,0 +1,552 @@
+import { mergeReadinessPrerequisites, formatReadinessPrerequisites } from "./conductor/readiness-prerequisites.js";
+import { READINESS_PREREQUISITE_BY_ID, READINESS_LEGACY_IDS } from "./readiness-prerequisites.generated.js";
+/**
+ * The v2 readiness requirement catalog and its row projection (BAPI-1452).
+ *
+ * Moved out of `drive-epic.ts` so the requirement-to-row projection has ONE
+ * shared, explicitly typed home that both the launch classifier
+ * (`classifyV2Readiness` in `drive-epic.ts`) and the advisory readiness report
+ * (`conductor/readiness.ts`) can read without either importing the other. The
+ * predicates and remedies are unchanged from their `drive-epic.ts` versions;
+ * what is new is the explicit `governedRowIds` list on every requirement.
+ *
+ * ## Blocking is applicability, never status
+ *
+ * A readiness row is `blocking` exactly when an APPLICABLE requirement lists its
+ * ID. A failing row no requirement governs stays non-blocking, and a passing
+ * governed row stays blocking — the flag says "this row can refuse this launch",
+ * not "this row is red". The unattended-only requirements are inapplicable for
+ * `--attended` and `--into-base`, so their rows are informational there.
+ *
+ * Dependency-light by design: no CLI orchestration, no filesystem, no process
+ * execution. It imports the readiness response type, the shared remedy
+ * formatter, the readiness-check constructor, and the merge credential key
+ * names (from the dependency-free `conductor/merge-credential.ts`), nothing else.
+ */
+import { gateProfileWaivesCiWorkflow, isProviderRepositoryIdentity, } from "./conductor/bridge-api-client.js";
+import { repositoryWorkflowRemedy } from "./conductor/repository-workflow-remedy.js";
+import { LOCAL_MERGE_CREDENTIAL_ENV_KEYS } from "./conductor/merge-credential.js";
+import { createReadinessCheckSafely } from "./readiness-check.js";
+/**
+ * The v2 readiness predicate, as a list so a failure can name what is missing.
+ *
+ * These are the facts v2 actually needs to drive an epic: a stored supervisor
+ * posture, a reconciler that is ticking, a provisioned and live executor, and
+ * complete GitHub App credentials. Each is read from the SERVER's report and
+ * never re-derived locally — two implementations of one classification drift,
+ * and a CLI that disagreed with the server about whether v2 can run would be
+ * worse than no check at all.
+ */
+const LEGACY_V2_READINESS_REQUIREMENTS = [
+    {
+        id: "supervisor_setup",
+        governedRowIds: ["server.supervisor-setup"],
+        describe: "supervisor setup stored for this repository",
+        satisfied: (r) => r.supervisor.setup_present,
+    },
+    {
+        id: "supervisor_config",
+        governedRowIds: ["server.supervisor-config"],
+        describe: "supervisor configuration stored for this repository",
+        satisfied: (r) => r.supervisor.config_present,
+    },
+    {
+        id: "github_credentials",
+        governedRowIds: ["server.github-credentials"],
+        describe: "GitHub App credentials that resolve completely",
+        satisfied: (r) => r.github.credentials_complete,
+    },
+    {
+        id: "reconciler_live",
+        governedRowIds: ["server.worker-present", "server.single-transition-authority", "server.reconciler-liveness"],
+        describe: "a reconciler that is ticking and not stale",
+        // BAPI-1279 — launch liveness is a DEPLOYMENT fact. The `bring_up` block
+        // reads the reconciler's process heartbeat deployment-wide, so a repository
+        // that has never run an epic still reads live when the worker is healthy.
+        // The repository-scoped `reconciler` section ("is this repository's work
+        // moving?", from `epic_runs.last_tick_at`) is only the fallback for a server
+        // too old to report `bring_up`.
+        satisfied: (r) => r.bring_up
+            ? r.bring_up.heartbeat_readable && r.bring_up.worker_present &&
+                r.bring_up.single_transition_authority
+            : r.reconciler.liveness_readable && !r.reconciler.stale,
+    },
+    {
+        id: "executor_live",
+        governedRowIds: ["server.executor-readiness"],
+        describe: "an executor provisioned and reporting ready",
+        // BAPI-1279 — diagnostic only. drive-epic starts (or, for a durable profile,
+        // verifies) the run's executor itself once the run exists.
+        advisoryOnly: true,
+        satisfied: (r) => r.executor.liveness_readable && r.executor.ready === true,
+    },
+    // BAPI-1102 — the three unattended prerequisites, in the order `setup-epic`
+    // refuses them, so readiness and the refusal name the same first blocker.
+    //
+    // Each reads the SERVER's `unattended` block and re-derives nothing. A server
+    // that does not report the block (older than BAPI-1102) leaves every one of
+    // them UNSATISFIED: "could not be read" is not "holds", and these authorize an
+    // unattended merge.
+    //
+    // The FIRST of them therefore carries the older-server remedy too, because it
+    // is the one an unreported block always blocks on, and telling that operator
+    // to set a consent flag would send them to fix something that may already be
+    // set — the server simply never said (BAPI-1102 review).
+    {
+        id: "unattended_consent",
+        governedRowIds: ["server.unattended-posture"],
+        describe: "repository consent to unattended Epic Implementer runs",
+        unattendedOnly: true,
+        // No fixed `remedy`: this requirement's action always depends on WHY.
+        remedyFor: (r) => r.unattended === null || r.unattended === undefined
+            ? "This Bridge API deploy does not report a repository's unattended " +
+                "prerequisites, so they could not be confirmed. Retry readiness, or use --attended."
+            : "Unattended runs are off for this repository. Turn on 'Allow unattended " +
+                "Epic Implementer runs' on the repository's Setup page in the Bridge " +
+                "admin panel, or pass --attended. Retry readiness after changing the setting.",
+        satisfied: (r) => r.unattended?.conductor_allowed === true,
+    },
+    {
+        id: "unattended_notify_default",
+        governedRowIds: ["server.unattended-notify-default"],
+        describe: "an escalation channel (a verified notify webhook or the account email)",
+        unattendedOnly: true,
+        remedy: "Supply a --policy-file declaring notify.webhook_url, or add an email address " +
+            "to the account so escalation alerts can be emailed, or pass --attended. " +
+            "notify.local_sink does not satisfy this.",
+        // BAPI-1274 — the account's email address is an escalation channel when no
+        // webhook is declared; the server reports its presence, never the address.
+        satisfied: (r) => r.unattended?.notify_webhook_default_declared === true ||
+            r.unattended?.escalation_email_available === true,
+    },
+    {
+        id: "repository_readiness",
+        governedRowIds: ["server.repository-workflow-readiness"],
+        describe: "confirmed review and epic-implementer-ci workflows on the default branch",
+        unattendedOnly: true,
+        // BAPI-1359 (Miss 38): the remedy names the SPECIFIC missing item, from the
+        // same shared formatter the readiness row and the setup-epic refusal use. The
+        // fixed install-command sentence that stood here could never clear a missing
+        // migration-guard job — no install step creates one — so it is gone from this
+        // refusal.
+        //
+        // BAPI-1390: the server decides which files are required (the review file
+        // only for a `verdict_protocol` run; the CI lane file only for a repository
+        // with no STORED gate profile and no `no_ci_gate`), and `satisfied` reads that
+        // decision as given. The remedy waives the CI file the same way, so a stored
+        // profile is never told to add a file it does not need. Gate-profile WARNINGS
+        // (epic-branch rows) are not requirements and are never read here.
+        remedyFor: (r) => repositoryWorkflowRemedy(gateProfileWaivesCiWorkflow(r) ? { ...r, conductor_ci_workflow: null } : r),
+        satisfied: (r) => r.unattended?.repository_readiness_confirmed === true,
+    },
+    // BAPI-1135 — merge-execution eligibility is deliberately NOT a requirement here.
+    //
+    // It was one, and it made `drive-epic` refuse EVERY repository the moment it
+    // shipped. The requirement could only be keyed on repository facts, because
+    // this layer keeps the composed run policy opaque to itself — and no
+    // repository carries the merge workflow until epic child 4 lands it. So both
+    // states resolved the same way: an upgraded server reported
+    // `merge_workflow_present: false` (`not_eligible`), an older one reported no
+    // block at all (`could_not_verify`), and either made `selectConductor` return
+    // `not_ready` and `classifyV2Readiness` return `operator_blocked` — for
+    // `--attended`, `--into-base` and `local`-mode runs alike, with a remedy
+    // naming a flag that does not exist yet.
+    //
+    // That is exactly the failure `selectConductor`'s own docstring warns about,
+    // and it contradicts the compatibility guarantee the rest of this slice keeps:
+    // nothing changes for a run that does not declare `github_actions`.
+    //
+    // Eligibility is still enforced, at the three layers that can actually see the
+    // declared mode: `setup-epic`'s pre-create refusal (which reads the composed
+    // policy), the approval route's server-side gate, and — authoritatively — the
+    // before-merge preflight. Readiness still REPORTS the facts as diagnostic
+    // rows, which inform without blocking. Reinstating a requirement here belongs
+    // with child 4, once a repository can actually satisfy it.
+];
+/** The three additive outcomes are authoritative; absent or unknown never denies. */
+const NEW_IDS = ['server.indexed-workflows', 'server.unattended-notify-default', 'server.test-command'];
+export const V2_READINESS_REQUIREMENTS = [
+    ...LEGACY_V2_READINESS_REQUIREMENTS.map(req => {
+        const id = READINESS_LEGACY_IDS[req.id] ?? req.id;
+        const descriptor = READINESS_PREREQUISITE_BY_ID.get(id);
+        return { ...req, id, describe: descriptor?.label ?? req.describe,
+            governedRowIds: req.governedRowIds.map(row => READINESS_LEGACY_IDS[row] ?? row),
+            ...(req.id === 'repository_readiness' ? { satisfied: (r) => r.prerequisites !== undefined ? true : req.satisfied(r) } : {}),
+            ...(req.id === 'unattended_notify_default' ? {
+                satisfied: (r) => !r.prerequisites?.some(p => p.id === id && p.check_status === 'not_met' && p.impact === 'blocking'),
+                remedyFor: (r) => r.prerequisites?.find(p => p.id === id)?.fix ?? 'Retry readiness.',
+            } : {}),
+        };
+    }),
+    ...NEW_IDS.filter(id => id !== 'server.unattended-notify-default').map(id => ({
+        id, describe: READINESS_PREREQUISITE_BY_ID.get(id).label, governedRowIds: [id], unattendedOnly: true,
+        satisfied: (r) => !r.prerequisites?.some(p => p.id === id && p.check_status === 'not_met' && p.impact === 'blocking'),
+        remedyFor: (r) => r.prerequisites?.find(p => p.id === id)?.fix ?? 'Retry readiness.',
+    })),
+];
+// ---------------------------------------------------------------------------
+// BAPI-1452: launch capability evidence
+// ---------------------------------------------------------------------------
+/** Stable row IDs for the launch summary, in render order. */
+export const UNATTENDED_POSTURE_ROW_ID = "server.unattended-posture";
+export const MERGE_CREDENTIAL_CAPABILITY_ROW_ID = "conductor.merge-credential-capability";
+export const WORKTREE_PREPARATION_ROW_ID = "conductor.worktree-preparation";
+export const RESOLVED_MERGE_MODE_ROW_ID = "server.resolved-merge-mode";
+export const PROVIDER_REPOSITORY_ROW_ID = "server.provider-repository";
+/** The exact Setup-page control name, kept visible in every posture refusal. */
+export const UNATTENDED_POSTURE_SETUP_CONTROL = "Allow unattended Epic Implementer runs";
+/**
+ * BAPI-1452 — the two launch capability requirements.
+ *
+ * The credential requirement does not apply to a `github_actions` run: no local
+ * credential merges there, so its row is informational. Both are unattended-only,
+ * because they protect an unattended merge and an unattended worker's commits.
+ */
+const LEGACY_V2_LAUNCH_EVIDENCE_REQUIREMENTS = [
+    {
+        id: "merge_credential_capability",
+        describe: "a merge credential that has push and can read pull requests",
+        unattendedOnly: true,
+        appliesTo: (evidence) => evidence.credential.kind !== "github_actions",
+        governedRowIds: [MERGE_CREDENTIAL_CAPABILITY_ROW_ID],
+    },
+    {
+        id: "worktree_preparation",
+        describe: "an executor clone whose shared git exclude can be prepared",
+        unattendedOnly: true,
+        appliesTo: () => true,
+        governedRowIds: [WORKTREE_PREPARATION_ROW_ID],
+    },
+];
+export const V2_LAUNCH_EVIDENCE_REQUIREMENTS = LEGACY_V2_LAUNCH_EVIDENCE_REQUIREMENTS.map(req => {
+    const id = READINESS_LEGACY_IDS[req.id] ?? req.id;
+    return { ...req, id, describe: READINESS_PREREQUISITE_BY_ID.get(id).label };
+});
+/** True when the context opts out of unattended operation. */
+function optedOut(context) {
+    return context.attended === true || context.intoBase === true;
+}
+/**
+ * The row IDs that are blocking in this context: the union of every APPLICABLE
+ * requirement's governed rows. Advisory requirements never contribute.
+ */
+export function applicableGovernedRowIds(context) {
+    const ids = new Set();
+    const out = optedOut(context);
+    for (const req of V2_READINESS_REQUIREMENTS) {
+        if (req.advisoryOnly === true)
+            continue;
+        if (out && req.unattendedOnly === true)
+            continue;
+        for (const id of req.governedRowIds)
+            ids.add(id);
+    }
+    if (context.launchEvidence !== undefined && !out) {
+        for (const req of V2_LAUNCH_EVIDENCE_REQUIREMENTS) {
+            if (!req.appliesTo(context.launchEvidence))
+                continue;
+            for (const id of req.governedRowIds)
+                ids.add(id);
+        }
+    }
+    return ids;
+}
+/** Every row ID any requirement governs, applicable or not. */
+const ALL_GOVERNED_ROW_IDS = new Set([
+    ...V2_READINESS_REQUIREMENTS.flatMap((req) => req.governedRowIds),
+    ...V2_LAUNCH_EVIDENCE_REQUIREMENTS.flatMap((req) => req.governedRowIds),
+]);
+/** True when some requirement governs this row ID (BAPI-1452). */
+export function isGovernedReadinessRowId(id) {
+    return ALL_GOVERNED_ROW_IDS.has(id);
+}
+/**
+ * Project requirement applicability onto rows: `blocking` is membership in an
+ * applicable requirement's governed row IDs, and nothing else. Status is never
+ * read.
+ */
+export function projectReadinessRowBlocking(checks, context = {}) {
+    const governed = applicableGovernedRowIds(context);
+    return checks.map((check) => ({ ...check, blocking: governed.has(check.id) }));
+}
+/** The credential configuration key a mode reads. Never the deprecated alias. */
+export function launchCredentialKey(mode) {
+    return LOCAL_MERGE_CREDENTIAL_ENV_KEYS[mode];
+}
+const UNVERIFIED_CREDENTIAL_COPY = {
+    probe_unavailable: {
+        detail: "GitHub gave no usable answer to the capability check (rate limit, outage, timeout, or an inconclusive status)",
+        remedy: "Retry drive-epic shortly. The merge itself still checks the credential before it runs.",
+    },
+    gh_unavailable: {
+        detail: "the GitHub CLI (gh) could not be run on this host, so the credential could not be checked",
+        remedy: "Install the GitHub CLI (gh) on the host that runs the executor; local merges run through it.",
+    },
+    repository_unresolved: {
+        detail: "the server could not resolve this repository's GitHub owner/name, so there was nothing to check against",
+        remedy: "Fix the repository's GitHub App credentials (owner and repository) in Bridge, then retry drive-epic.",
+    },
+    mode_unresolved: {
+        detail: "the server could not resolve which merge execution mode a new run would use",
+        remedy: "Check the supervisor configuration's merge execution setting, then retry drive-epic.",
+    },
+    server_fields_missing: {
+        detail: "this Bridge API deploy does not report the resolved merge mode or the provider repository",
+        remedy: "Try again later. If drive-epic keeps refusing, email info@bridgegpt.ai so merge capability can be verified before launch.",
+    },
+    external_executor_plane: {
+        detail: "a plane lane runs this run's executor, so this launcher cannot check that executor's credential",
+        remedy: "Check the merge credential where the plane runs (`epic-implementer doctor` on that host).",
+    },
+    external_executor_durable: {
+        detail: "the durable launch profile's host runs this run's executor, so this launcher cannot check its credential",
+        remedy: "Check the merge credential on the durable executor host (`epic-implementer doctor` there).",
+    },
+};
+/** The merge credential row. Value-free: names keys and `owner/name`, never a token. */
+function credentialCheck(evidence) {
+    const base = {
+        id: MERGE_CREDENTIAL_CAPABILITY_ROW_ID,
+        source: "conductor",
+        label: "Merge credential capability",
+    };
+    if (evidence === null) {
+        return createReadinessCheckSafely({
+            ...base,
+            status: "skip",
+            detail: "not checked — this launch is attended, so no unattended merge runs",
+        });
+    }
+    switch (evidence.kind) {
+        case "verified": {
+            const key = launchCredentialKey(evidence.mode);
+            return createReadinessCheckSafely({
+                ...base,
+                status: "pass",
+                detail: `${key} has push and can read pull requests on ${evidence.repository}. ` +
+                    "Branch protection and rulesets are still checked at merge time.",
+            });
+        }
+        case "github_actions":
+            return createReadinessCheckSafely({
+                ...base,
+                status: "skip",
+                detail: "merges run through the GitHub Actions merge workflow, so no local merge credential is checked",
+            });
+        case "credential_missing": {
+            const key = launchCredentialKey(evidence.mode);
+            return createReadinessCheckSafely({
+                ...base,
+                status: "fail",
+                detail: `${key} is not set in the environment drive-epic starts the executor with`,
+                remediation: `Set ${key} in the environment you run drive-epic from, then run drive-epic again. ` +
+                    "Bridge never stores it.",
+            });
+        }
+        case "credential_invalid": {
+            const key = launchCredentialKey(evidence.mode);
+            return createReadinessCheckSafely({
+                ...base,
+                status: "fail",
+                detail: `${key} is set but is not a usable credential (malformed, or rejected by GitHub)`,
+                remediation: `Replace ${key} with a valid token, then run drive-epic again.`,
+            });
+        }
+        case "no_access": {
+            const key = launchCredentialKey(evidence.mode);
+            return createReadinessCheckSafely({
+                ...base,
+                status: "fail",
+                detail: `${key} cannot push to ${evidence.repository} or cannot read its pull requests`,
+                remediation: `Give the account behind ${key} push (write) access to ${evidence.repository}, ` +
+                    "or use a token that has it, then run drive-epic again.",
+            });
+        }
+        case "unverified": {
+            const copy = UNVERIFIED_CREDENTIAL_COPY[evidence.reason];
+            return createReadinessCheckSafely({
+                ...base,
+                status: "warn",
+                detail: `Capability not verified: ${copy.detail}`,
+                remediation: copy.remedy,
+            });
+        }
+    }
+}
+/** The worktree-preparation row. Never carries the absolute exclude path. */
+function worktreeCheck(evidence) {
+    const base = {
+        id: WORKTREE_PREPARATION_ROW_ID,
+        source: "conductor",
+        label: "Worktree preparation",
+    };
+    if (evidence === null) {
+        return createReadinessCheckSafely({
+            ...base,
+            status: "skip",
+            detail: "not checked — this launch is attended",
+        });
+    }
+    switch (evidence.kind) {
+        case "ready":
+            return createReadinessCheckSafely({
+                ...base,
+                status: "pass",
+                detail: evidence.present
+                    ? "the executor clone's shared git exclude already lists the executor's entries"
+                    : "the executor clone's shared git exclude can be written when the executor prepares it",
+            });
+        case "blocked":
+            return createReadinessCheckSafely({
+                ...base,
+                status: "fail",
+                detail: "the executor clone's shared git exclude is missing the executor's entries and cannot be written",
+                remediation: "Make the clone's .git/info/exclude (or its info directory) writable by the user that runs the " +
+                    "executor, then run drive-epic again.",
+            });
+        case "unverified":
+            return createReadinessCheckSafely({
+                ...base,
+                status: "warn",
+                detail: evidence.reason === "inspection_unavailable"
+                    ? "Capability not verified: the executor clone's shared git exclude could not be inspected"
+                    : evidence.reason === "external_executor_plane"
+                        ? "Capability not verified: a plane lane owns this run's executor clone, so this launcher cannot inspect it"
+                        : "Capability not verified: the durable launch profile's host owns this run's executor clone, so this launcher cannot inspect it",
+                remediation: evidence.reason === "inspection_unavailable"
+                    ? "The executor still prepares the exclude itself at startup; run `epic-implementer doctor` if workers later commit executor files."
+                    : "That executor still prepares its own clone at startup; inspect it on the host that runs it.",
+            });
+    }
+}
+/** The Setup-page posture row, from the server's unattended fact only. */
+export function unattendedPostureCheck(readiness) {
+    const requirement = V2_READINESS_REQUIREMENTS.find((req) => req.id === "server.unattended-posture");
+    const remedy = requirement?.remedyFor?.(readiness) ??
+        `Turn on '${UNATTENDED_POSTURE_SETUP_CONTROL}' on the repository's Setup page in the Bridge admin panel.`;
+    const base = {
+        id: UNATTENDED_POSTURE_ROW_ID,
+        source: "server",
+        label: "Unattended posture (Setup page)",
+    };
+    if (readiness.unattended === null || readiness.unattended === undefined) {
+        return createReadinessCheckSafely({
+            ...base,
+            status: "fail",
+            detail: "this Bridge API deploy does not report the Setup-page unattended switch",
+            remediation: remedy,
+        });
+    }
+    return readiness.unattended.conductor_allowed === true
+        ? createReadinessCheckSafely({
+            ...base,
+            status: "pass",
+            detail: `'${UNATTENDED_POSTURE_SETUP_CONTROL}' is on for this repository`,
+        })
+        : createReadinessCheckSafely({
+            ...base,
+            status: "fail",
+            detail: `'${UNATTENDED_POSTURE_SETUP_CONTROL}' is off for this repository, so an unattended run is refused`,
+            remediation: remedy,
+        });
+}
+/** The resolved merge mode, as a supporting fact. Absent or null is a warning, never a default. */
+export function resolvedMergeModeCheck(readiness) {
+    const base = { id: RESOLVED_MERGE_MODE_ROW_ID, source: "server", label: "Resolved merge mode" };
+    const mode = readiness.resolved_merge_execution_mode;
+    if (mode === undefined) {
+        return createReadinessCheckSafely({
+            ...base,
+            status: "warn",
+            detail: "Capability not verified: this Bridge API deploy does not report the resolved merge mode",
+            remediation: UNVERIFIED_CREDENTIAL_COPY.server_fields_missing.remedy,
+        });
+    }
+    if (mode === null) {
+        return createReadinessCheckSafely({
+            ...base,
+            status: "warn",
+            detail: "Capability not verified: the server could not resolve a supported merge mode",
+            remediation: UNVERIFIED_CREDENTIAL_COPY.mode_unresolved.remedy,
+        });
+    }
+    return createReadinessCheckSafely({ ...base, status: "pass", detail: `a new run merges in ${mode} mode` });
+}
+/** The provider repository, as a supporting fact. */
+export function providerRepositoryCheck(readiness) {
+    const base = { id: PROVIDER_REPOSITORY_ROW_ID, source: "server", label: "Provider repository" };
+    const repository = readiness.provider_repository;
+    if (repository === undefined) {
+        return createReadinessCheckSafely({
+            ...base,
+            status: "warn",
+            detail: "Capability not verified: this Bridge API deploy does not report the provider repository",
+            remediation: UNVERIFIED_CREDENTIAL_COPY.server_fields_missing.remedy,
+        });
+    }
+    if (!isProviderRepositoryIdentity(repository)) {
+        return createReadinessCheckSafely({
+            ...base,
+            status: "warn",
+            detail: "Capability not verified: the server could not resolve this repository's GitHub owner/name",
+            remediation: UNVERIFIED_CREDENTIAL_COPY.repository_unresolved.remedy,
+        });
+    }
+    return createReadinessCheckSafely({ ...base, status: "pass", detail: `GitHub repository ${repository}` });
+}
+/**
+ * The launch readiness rows, in render order: posture, merge credential
+ * capability, worktree preparation, then the supporting facts. `blocking` is
+ * projected from requirement applicability only.
+ */
+export function buildLaunchReadinessChecks(readiness, context) {
+    const evidence = optedOut(context) ? undefined : context.launchEvidence;
+    return projectReadinessRowBlocking([
+        unattendedPostureCheck(readiness),
+        credentialCheck(evidence?.credential ?? null),
+        worktreeCheck(evidence?.worktree ?? null),
+        resolvedMergeModeCheck(readiness),
+        providerRepositoryCheck(readiness),
+    ], context);
+}
+/** The two launch-evidence rows a launch can be refused on. */
+export const LAUNCH_EVIDENCE_ROW_IDS = [
+    MERGE_CREDENTIAL_CAPABILITY_ROW_ID,
+    WORKTREE_PREPARATION_ROW_ID,
+];
+/**
+ * The first PROVEN launch-evidence blocker: a failing row an applicable
+ * requirement governs. Unverified evidence is a warning and never returned.
+ */
+export function firstLaunchEvidenceBlocker(checks) {
+    for (const id of LAUNCH_EVIDENCE_ROW_IDS) {
+        const check = checks.find((c) => c.id === id);
+        if (check && check.status === "fail" && check.blocking)
+            return check;
+    }
+    return null;
+}
+/**
+ * The applicability label a readiness row renders with (BAPI-1452).
+ *
+ * `Blocking` only for a FAILED row an applicable requirement governs; `Warning`
+ * for any warning (unknown evidence is never green); `Informational` for a row
+ * no applicable requirement governs; `OK` for a passing governed row.
+ */
+export function readinessApplicabilityLabel(check) {
+    if (check.detail === 'unknown')
+        return "Couldn't check";
+    if (check.detail === 'not_met' && !check.blocking)
+        return 'Not met';
+    if (check.status === "fail" && check.blocking)
+        return "Blocking";
+    if (check.status === "warn")
+        return "Warning";
+    if (!check.blocking || check.status === "fail" || check.status === "skip")
+        return "Informational";
+    return "OK";
+}
+/** Render the compact launch summary drive-epic prints before creating a run. */
+export function formatLaunchReadinessSummary(checks, options = {}) {
+    return formatReadinessPrerequisites(mergeReadinessPrerequisites(checks, options.prerequisites), options);
+}

package/build/version.generated.js

@@ -1,4 +1,4 @@
 // AUTO-GENERATED — do not edit manually. Regenerate with: npm run build
-export const VERSION = "0.2.68";
-export const BUILD_COMMIT = "2aef1c5656bc";
-export const LAUNCHER_ARGS = ["-y", "--prefer-offline", "@bridge_gpt/mcp-server@0.2.68", "serve"];
+export const VERSION = "0.2.70";
+export const BUILD_COMMIT = "7fb22e3a1d7b";
+export const LAUNCHER_ARGS = ["-y", "--prefer-offline", "@bridge_gpt/mcp-server@0.2.70", "serve"];