@bridge_gpt/mcp-server 0.2.65 → 0.2.66

package/build/epic-launch-diagnostic.js

@@ -0,0 +1,31 @@
+/** Keep operator-controlled components out of trusted epic-launch refusal text. */
+export function diagnosticComponent(value) {
+    // A short identifier here is a schema-field label, not its stored value.
+    if (/^field '[A-Za-z][A-Za-z0-9]{0,39}'$/.test(value))
+        return value;
+    if (value.length > 512 ||
+        /[\x00-\x1f\x7f]/.test(value) ||
+        /(?:sk[-_][A-Za-z0-9]+|api[-_]?key[-_:=][A-Za-z0-9]+|secret|token|password|bearer|authorization)/i.test(value) ||
+        /%[0-9a-f]{2}/i.test(value) && decodedLooksSensitive(value))
+        return "<redacted>";
+    return value;
+}
+function decodedLooksSensitive(value) {
+    try {
+        const decoded = decodeURIComponent(value);
+        return decoded !== value && diagnosticComponent(decoded) === "<redacted>";
+    }
+    catch {
+        return true;
+    }
+}
+/** URL validation alone permits paths and queries that look like credentials. */
+export function safeEpicLaunchTargetUrl(baseUrl) {
+    try {
+        const url = new URL(baseUrl);
+        return !url.username && !url.password && diagnosticComponent(baseUrl) === baseUrl;
+    }
+    catch {
+        return false;
+    }
+}

package/build/epic-launch-profile.js

@@ -26,11 +26,13 @@
  */
 import os from "node:os";
 import path from "node:path";
+import { createHash } from "node:crypto";
 import { chmod, mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { durablyReplaceCredentialStoreJson, getPrimaryCredentialStorePath, withCredentialStoreLock, } from "./credential-store.js";
 import { validateHttpBaseUrl, describeBaseUrlRejection } from "./base-url.js";
 import { MCP_PACKAGE_NAME } from "./mcp-identity.js";
 import { isTransientNpxEntryPath } from "./mcp-server-invocation.js";
+import { diagnosticComponent } from "./epic-launch-diagnostic.js";
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -45,7 +47,7 @@ export const EPIC_LAUNCH_EXECUTION_MODES = ["local", "durable"];
 /** One-time migration guidance for a profile this build cannot read. */
 export function epicLaunchProfileSetupGuidance(name) {
     return (`Re-run guided setup to (re)write it: npx -y ${MCP_PACKAGE_NAME} install conductor ` +
-        `--launch-profile ${EPIC_LAUNCH_PROFILE_NAME_PATTERN.test(name) ? name : "<name>"} --base-url <url> ...`);
+        `--launch-profile ${EPIC_LAUNCH_PROFILE_NAME_PATTERN.test(name) ? diagnosticComponent(name) : "<name>"} --base-url <url> ...`);
 }
 // ---------------------------------------------------------------------------
 // Validation (pure)
@@ -73,7 +75,7 @@ function malformed(name, field, why) {
     return {
         ok: false,
         kind: "profile-malformed",
-        message: `Epic launch profile '${name}' is unusable: ${field} ${why}. ${epicLaunchProfileSetupGuidance(name)}`,
+        message: `Epic launch profile '${diagnosticComponent(name)}' is unusable: ${diagnosticComponent(field)} ${why}. ${epicLaunchProfileSetupGuidance(name)}`,
     };
 }
 function validateRuntime(name, raw) {
@@ -118,7 +120,7 @@ export function validateEpicLaunchProfile(raw, selector = "<unnamed>") {
         return {
             ok: false,
             kind: "profile-unsupported-version",
-            message: `Epic launch profile '${selector}' uses an unsupported schema version; this build reads ` +
+            message: `Epic launch profile '${diagnosticComponent(selector)}' uses an unsupported schema version; this build reads ` +
                 `version ${EPIC_LAUNCH_PROFILE_VERSION} only. ${epicLaunchProfileSetupGuidance(selector)}`,
         };
     }
@@ -204,23 +206,23 @@ async function readStoreDocument(deps) {
         if (code === "ENOENT") {
             return { ok: true, present: false, document: { version: EPIC_LAUNCH_PROFILE_VERSION, profiles: {} } };
         }
-        return { ok: false, kind: "store-unreadable", message: `Unable to read ${storePath}.` };
+        return { ok: false, kind: "store-unreadable", message: `Unable to read ${diagnosticComponent(storePath)}.` };
     }
     let parsed;
     try {
         parsed = JSON.parse(raw);
     }
     catch {
-        return { ok: false, kind: "store-unreadable", message: `${storePath} is not valid JSON.` };
+        return { ok: false, kind: "store-unreadable", message: `${diagnosticComponent(storePath)} is not valid JSON.` };
     }
     if (!isPlainObject(parsed) || !isPlainObject(parsed.profiles)) {
-        return { ok: false, kind: "store-unreadable", message: `${storePath} has no profiles object.` };
+        return { ok: false, kind: "store-unreadable", message: `${diagnosticComponent(storePath)} has no profiles object.` };
     }
     if (parsed.version !== EPIC_LAUNCH_PROFILE_VERSION) {
         return {
             ok: false,
             kind: "profile-unsupported-version",
-            message: `${storePath} uses an unsupported schema version; this build reads version ` +
+            message: `${diagnosticComponent(storePath)} uses an unsupported schema version; this build reads version ` +
                 `${EPIC_LAUNCH_PROFILE_VERSION} only. ${epicLaunchProfileSetupGuidance("<name>")}`,
         };
     }
@@ -249,7 +251,7 @@ export async function readEpicLaunchProfile(name, deps) {
         return {
             ok: false,
             kind: "profile-missing",
-            message: `No epic launch profile named '${name}' exists on this host. ${epicLaunchProfileSetupGuidance(name)}`,
+            message: `No epic launch profile named '${diagnosticComponent(name)}' exists on this host. ${epicLaunchProfileSetupGuidance(name)}`,
         };
     }
     const validated = validateEpicLaunchProfile(store.document.profiles[name], name);
@@ -259,7 +261,7 @@ export async function readEpicLaunchProfile(name, deps) {
         return {
             ok: false,
             kind: "profile-host-mismatch",
-            message: `Epic launch profile '${name}' was approved on a different host. Profiles are host-local; ` +
+            message: `Epic launch profile '${diagnosticComponent(name)}' was approved on a different host. Profiles are host-local; ` +
                 epicLaunchProfileSetupGuidance(name),
         };
     }
@@ -309,6 +311,34 @@ export async function writeEpicLaunchProfile(profile, deps) {
         return { ok: true, path: storePath, action: existing === undefined ? "created" : "updated" };
     }, (error) => ({ ok: false, kind: "store-write-failed", message: error }));
 }
+/** Safe for text and JSON; no policy recipient or webhook value is retained. */
+export function formatEpicLaunchChannelIdentity(identity) {
+    return identity;
+}
+const pinnedPolicyContents = new WeakMap();
+/** Store selected content once, without making it serializable with the selection. */
+export function pinEpicLaunchPolicy(selection, policy) {
+    pinnedPolicyContents.set(selection, policy);
+    return selection;
+}
+export function getPinnedEpicLaunchPolicy(selection) {
+    return pinnedPolicyContents.get(selection);
+}
+export function epicLaunchPolicyDigest(raw) {
+    return createHash("sha256").update(raw).digest("hex");
+}
+/** Finalize the already selected target after the run's existence is known. */
+export function resolveEpicLaunchSelection(args) {
+    return Object.freeze({
+        baseUrl: args.baseUrl,
+        repoName: args.repoName,
+        targetSource: args.targetSource,
+        profileName: args.profile?.name ?? null,
+        topology: args.topology,
+        policy: Object.freeze(args.policy),
+        escalationChannel: args.escalationChannel,
+    });
+}
 /**
  * Normalize every applicable target source and decide ONE target, before any
  * credential is resolved and before any request is made.
@@ -338,7 +368,7 @@ export function resolveEpicLaunchTarget(inputs) {
     const flag = normalize(inputs.flagBaseUrl, "--base-url");
     if (!flag.ok)
         return { ok: false, kind: "target-invalid", message: flag.message };
-    const env = normalize(inputs.env.BAPI_BASE_URL, "BAPI_BASE_URL");
+    const env = normalize(inputs.profileSource === "profile-env" ? undefined : inputs.env.BAPI_BASE_URL, "BAPI_BASE_URL");
     if (!env.ok)
         return { ok: false, kind: "target-invalid", message: env.message };
     const profile = inputs.profile;
@@ -347,7 +377,7 @@ export function resolveEpicLaunchTarget(inputs) {
             return {
                 ok: false,
                 kind: "target-conflict",
-                message: `--base-url names a different endpoint than launch profile '${profile.name}'. An override ` +
+                message: `--base-url names a different endpoint than launch profile '${diagnosticComponent(profile.name)}'. An override ` +
                     "does not rebind a profile; re-run guided setup to change its target.",
             };
         }
@@ -355,7 +385,7 @@ export function resolveEpicLaunchTarget(inputs) {
             return {
                 ok: false,
                 kind: "target-conflict",
-                message: `BAPI_BASE_URL names a different endpoint than launch profile '${profile.name}'. Unset it, ` +
+                message: `BAPI_BASE_URL names a different endpoint than launch profile '${diagnosticComponent(profile.name)}'. Unset it, ` +
                     "or re-run guided setup to change the profile's target.",
             };
         }
@@ -364,10 +394,10 @@ export function resolveEpicLaunchTarget(inputs) {
             return {
                 ok: false,
                 kind: "repository-conflict",
-                message: `--repo names a different repository than launch profile '${profile.name}'.`,
+                message: `--repo names a different repository than launch profile '${diagnosticComponent(profile.name)}'.`,
             };
         }
-        return { ok: true, baseUrl: profile.baseUrl, source: "profile", repoName: profile.repoName };
+        return { ok: true, baseUrl: profile.baseUrl, source: inputs.profileSource ?? "profile", repoName: profile.repoName };
     }
     if (flag.value !== null && env.value !== null && flag.value !== env.value) {
         return {

package/build/executor/completion-supervision.js

@@ -223,6 +223,11 @@ export function finalizationFacts(outcome) {
         case "WorkerFinalizationMissingRemoteBranchAndPr":
         case "WorkerFinalizationSavedButUnfinalized":
             return { verdict: "unmet", pushSatisfied: false, prSatisfied: false };
+        // BAPI-1330: the worker's full HEAD, or the PR's head, could not be
+        // established. Nothing was observed MISSING, so the verdict is `unknown`
+        // and neither push nor PR is inferred satisfied.
+        case "WorkerFinalizationPublicationUnverified":
+            return { verdict: "unknown", pushSatisfied: false, prSatisfied: false };
         default:
             return { verdict: "unknown", pushSatisfied: false, prSatisfied: false };
     }

package/build/executor/correction-dispatch.js

@@ -0,0 +1,60 @@
+/** BAPI-1328: persisted remaining-work authority, independent of prompt text. */
+export const CORRECTION_INTENT_CAPABILITY = "correction_intent.v1";
+export const CORRECTION_INTENT_VERSION = 1;
+export const CORRECTION_KINDS = [
+    "review_fix", "operator_remediation", "ci_fix", "focused_rebase",
+    "overlap_reconciliation", "approved_spec_delta", "continuation",
+    "required_checks", "finalization", "integration_correction",
+];
+function nonblank(value) {
+    return typeof value === "string" && value.trim().length > 0 && value.length <= 4096;
+}
+function reference(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) &&
+        Object.keys(value).length > 0 && Object.entries(value).every(([key, item]) => nonblank(key) && ((typeof item === "string" && nonblank(item)) ||
+        (typeof item === "number" && Number.isInteger(item))));
+}
+/** A prompt or job type never grants correction authority. */
+export function validateCorrectionIntent(value, row) {
+    const refuse = (code, detail) => ({ ok: false, code, detail });
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return refuse("correction_context_missing", "correction intent is absent");
+    const intent = value;
+    if (intent.version !== CORRECTION_INTENT_VERSION)
+        return refuse("correction_contract_version_unsupported", "unsupported correction intent version");
+    if (!CORRECTION_KINDS.includes(intent.kind))
+        return refuse("correction_contract_invalid", "unknown correction kind");
+    for (const key of ["repo_name", "epic_run_id", "ticket_key"]) {
+        if (!nonblank(row[key]) || intent[key] !== row[key])
+            return refuse("correction_contract_invalid", `${key} differs from row`);
+    }
+    if (!nonblank(intent.branch) || (row.expected_branch && intent.branch !== row.expected_branch))
+        return refuse("correction_context_missing", "retained branch is unavailable or changed");
+    if (!nonblank(intent.head_sha) || (row.expected_head_sha && intent.head_sha !== row.expected_head_sha))
+        return refuse("correction_context_missing", "retained head is unavailable or changed");
+    if (!nonblank(intent.obligation) || !reference(intent.context_ref))
+        return refuse("correction_context_missing", "remaining obligation or context reference is absent");
+    if (intent.resume !== undefined && intent.resume !== null && intent.resume !== false)
+        return refuse("correction_contract_invalid", "unsupported resume metadata");
+    if (intent.kind === "approved_spec_delta") {
+        const delta = intent.approved_delta;
+        if (!delta || typeof delta !== "object" || Array.isArray(delta))
+            return refuse("renewed_scope_approval_required", "approved same-ticket delta is absent");
+        const d = delta;
+        if (!["old_identity", "new_identity", "obligation"].every(key => nonblank(d[key])) ||
+            !["file_boundary", "dependency_boundary"].every(key => Array.isArray(d[key]) && (key !== "file_boundary" || d[key].length > 0) &&
+                d[key].every(nonblank)))
+            return refuse("renewed_scope_approval_required", "approved delta identity or boundary is absent");
+    }
+    return { ok: true, intent };
+}
+export function isRemainingWork(jobType, payload) {
+    if (["remediate", "rebase", "ci_fix", "reconcile_overlap", "resume"].includes(jobType))
+        return true;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return false;
+    const p = payload;
+    return p.correction_intent !== undefined || p.continuation !== undefined ||
+        p.continuation_of_job_id !== undefined || p.finalization !== undefined ||
+        p.remaining_checks !== undefined || p.required_checks_remaining !== undefined;
+}

package/build/executor/env.js

@@ -118,6 +118,7 @@ const SECRET_NAME_FRAGMENTS = ["TOKEN", "SECRET", "PASSWORD", "API_KEY"];
  * without anything in the executor choosing that.
  */
 export const EXPLICIT_DENY_KEYS = [
+    "BAPI_CORRECTION_INTENT_VERSION",
     "BRIDGE_MCP_PROFILE",
     // BAPI-1301: the per-job ownership tag. The executor injects a fresh,
     // unpredictable value AFTER this builder and the adapter have run
@@ -287,6 +288,11 @@ export function buildExecutorBaseWorkerEnv(parentEnv, options = {}) {
     env.POSTGRES_DATABASE = WORKER_SENTINEL_DATABASE_NAME;
     env.POSTGRES_DB = WORKER_SENTINEL_DATABASE_NAME;
     env.PGDATABASE = WORKER_SENTINEL_DATABASE_NAME;
+    if (options.correctionIntentVersion !== undefined) {
+        if (options.correctionIntentVersion !== 1)
+            throw new Error("unsupported correction intent version");
+        env.BAPI_CORRECTION_INTENT_VERSION = "1";
+    }
     if (typeof options.effectiveBaseBranch === "string" &&
         options.effectiveBaseBranch.length > 0) {
         env[PR_BASE_BRANCH_ENV_VAR] = options.effectiveBaseBranch;

package/build/executor/http-client.js

@@ -294,6 +294,18 @@ export function createExecutorHttpClient(config) {
             // 5xx and any other unexpected status are retryable.
             return { kind: "retryable", error: `claim failed (HTTP ${status}): ${boundedDetail(text)}` };
         },
+        async scopeReadiness(job) {
+            const { status, text } = await post(`/${job.id}/scope-readiness`, { repo_name: job.repo_name, claim_token: job.claim_token }, job.repo_name);
+            if (status !== 200)
+                throw new Error(`scope readiness HTTP ${status}`);
+            const parsed = JSON.parse(text);
+            if (!parsed || typeof parsed !== "object" ||
+                !("decision" in parsed) ||
+                !["ready", "waiting", "blocked"].includes(String(parsed.decision))) {
+                throw new Error("scope readiness response malformed");
+            }
+            return parsed;
+        },
         // Heartbeat does NOT go through `mutate()`: it is the one mutation whose
         // response BODY carries information beyond the outcome (the BAPI-731 stop
         // request), so it maps the response itself instead of discarding the body.
@@ -371,6 +383,9 @@ export function createExecutorHttpClient(config) {
                 error_kind: failure.error_kind,
                 error_message: failure.error_message,
                 classification: failure.classification,
+                // BAPI-1330: the observed process exit, only when the runner has one —
+                // a failure without it keeps its exact pre-BAPI-1330 body.
+                ...(failure.exit_code !== undefined ? { exit_code: failure.exit_code } : {}),
                 local_commit_count: failure.local_commit_count,
                 last_commit_sha: failure.last_commit_sha,
                 telemetry: failure.telemetry,

package/build/executor/integration-job.js

@@ -703,13 +703,18 @@ export function buildIntegrationCorrectionJob(action, timeoutSeconds) {
         job_type: "rebase",
         ticket_key: action.epic_key,
         epic_run_id: action.epic_run_id,
-        payload: { prompt: action.correction_prompt ?? "", base_branch: action.base_branch },
+        payload: {
+            prompt: action.correction_prompt ?? "", base_branch: action.base_branch,
+            correction_intent: action.correction_intent ?? null,
+            integration_action_id: action.action_id,
+        },
         expected_branch: action.epic_branch,
         expected_head_sha: action.expected_epic_head_sha,
         lease_expires_at: action.lease_expires_at,
         attempt_count: 1,
         max_attempts: 1,
         timeout_seconds: timeoutSeconds,
+        required_capabilities: ["correction_intent.v1"],
     };
 }
 /**

package/build/executor/job-errors.js

@@ -28,10 +28,11 @@
  *    exited cleanly and its exact HEAD is durable on origin, but no usable pull
  *    request exists for that branch: none is visible, its URL is blank, its
  *    description is blank (BAPI-824 folded in), or it does not yet carry the
- *    pushed head. The work is COMPLETE and PUSHED — only the attachment is
- *    missing — so this kind is deliberately distinct from every other
- *    finalization failure, and its guidance names attachment and warns against
- *    deleting or rebasing the branch; see `worker-finalization.ts`.
+ *    pushed head. The commits are PUSHED and the attachment is missing; whether
+ *    the required work is finished or its checks passed is NOT established by
+ *    this kind (BAPI-1330). It stays distinct from every other finalization
+ *    failure, and its guidance names attachment and warns against deleting or
+ *    rebasing the branch; see `worker-finalization.ts`.
  *  - `WorkerFinalizationSavedButUnfinalized` — an implementation-style job
  *    (BAPI-762) exited cleanly, and an origin branch exists at an authoritative
  *    tip that does NOT match the worker's own HEAD — durable work exists on
@@ -132,6 +133,14 @@ export const WorkerFinalizationMissingRemoteBranchAndPr = "WorkerFinalizationMis
 export const WorkerFinalizationPrBaseMismatch = "WorkerFinalizationPrBaseMismatch";
 export const WorkerFinalizationPrNotAttached = "WorkerFinalizationPrNotAttached";
 export const WorkerFinalizationSavedButUnfinalized = "WorkerFinalizationSavedButUnfinalized";
+/**
+ * BAPI-1330: a COVERED attempt's publication could not be proven — the worker's
+ * full HEAD was unknown, or the pull request reported no head commit. Distinct
+ * from `WorkerFinalizationPrNotAttached` because nothing here was observed to be
+ * missing: the facts needed to decide were unavailable, so the finalization
+ * verdict is `unknown`, never `unmet` and never `ok`.
+ */
+export const WorkerFinalizationPublicationUnverified = "WorkerFinalizationPublicationUnverified";
 export const WorkerConfigIsolation = "ContractError.WorkerConfigIsolation";
 export const PreSpawnVerification = "ContractError.PreSpawnVerification";
 export const BridgeCredentialUnavailable = "ContractError.BridgeCredentialUnavailable";