@bridge_gpt/mcp-server 0.2.65 → 0.2.66

package/build/executor/prompt-spec.js

@@ -114,6 +114,93 @@ function hasControlCharacter(value) {
     }
     return false;
 }
+function sanitizeCiText(value, maxBytes = 512) {
+    const redacted = value
+        .replace(/gh[pousr]_[A-Za-z0-9]{20,}/giu, "[REDACTED]")
+        .replace(/bearer\s+[^\s,;]+/giu, "Bearer [REDACTED]")
+        .replace(/authorization:\s*[^\s,;]+/giu, "Authorization: [REDACTED]")
+        .replace(/https?:\/\/[^\s/@<>]+:[^\s/@<>]+@[^\s<>]+/giu, "[REDACTED URL]")
+        .replace(/https?:\/\/[^\s<>]+\?[^\s<>]+/giu, "[REDACTED URL]");
+    return sliceUtf8(redacted, maxBytes).replace(/[\x00-\x08\x0B-\x1F\x7F]/gu, " ");
+}
+function safeCiSourceRef(raw, repository) {
+    if (typeof raw !== "string" || raw.length > 1024)
+        return null;
+    try {
+        const url = new URL(raw);
+        if (url.protocol !== "https:" || url.hostname !== "github.com" ||
+            url.username || url.password || url.search || url.hash ||
+            !url.pathname.toLowerCase().startsWith(`/${repository.toLowerCase()}/`))
+            return null;
+        return url.toString();
+    }
+    catch {
+        return null;
+    }
+}
+function readCiEvidence(raw, headSha, failing) {
+    if (raw === null || raw === undefined)
+        return { status: "unavailable", reason: "legacy_no_snapshot" };
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return { status: "unavailable", reason: "malformed_snapshot" };
+    }
+    const item = raw;
+    let serializedLength;
+    try {
+        serializedLength = JSON.stringify(item).length;
+    }
+    catch {
+        return { status: "unavailable", reason: "malformed_snapshot" };
+    }
+    if (item.version !== 1 || item.head_sha !== headSha ||
+        typeof item.repository !== "string" || !item.repository ||
+        typeof item.target_branch !== "string" || !item.target_branch ||
+        typeof item.policy_source !== "string" ||
+        typeof item.policy_fingerprint !== "string" ||
+        !Array.isArray(item.required_failures) || item.required_failures.length === 0 ||
+        item.required_failures.length > 20 || serializedLength > 24_000) {
+        return { status: "unavailable", reason: "malformed_snapshot" };
+    }
+    const required = [];
+    for (const candidate of item.required_failures) {
+        if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+            return { status: "unavailable", reason: "malformed_snapshot" };
+        }
+        const record = candidate;
+        if (typeof record.name !== "string" || !failing.has(record.name)) {
+            return { status: "unavailable", reason: "malformed_snapshot" };
+        }
+        required.push({
+            name: record.name,
+            sourceKind: typeof record.source_kind === "string" ? sanitizeCiText(record.source_kind, 32) : "unknown",
+            conclusion: typeof record.conclusion === "string" ? sanitizeCiText(record.conclusion, 32) : "unknown",
+            runId: typeof record.run_id === "number" && Number.isSafeInteger(record.run_id) && record.run_id > 0 ? record.run_id : null,
+            summary: typeof record.summary === "string" ? sanitizeCiText(record.summary) : "",
+            sourceRef: safeCiSourceRef(record.source_ref, item.repository),
+        });
+    }
+    if (required.length !== failing.size ||
+        new Set(required.map(record => record.name)).size !== failing.size) {
+        return { status: "unavailable", reason: "malformed_snapshot" };
+    }
+    const related = Array.isArray(item.related_failures) ? item.related_failures.slice(0, 8)
+        .filter((record) => !!record && typeof record === "object" && !Array.isArray(record))
+        .map((record) => typeof record.name === "string" ? sanitizeCiText(record.name, 200) : "(unnamed)") : [];
+    return {
+        status: "available",
+        policySource: sanitizeCiText(item.policy_source, 32),
+        policyFingerprint: sanitizeCiText(item.policy_fingerprint, 64),
+        repository: sanitizeCiText(item.repository, 200),
+        targetBranch: sanitizeCiText(item.target_branch, 200),
+        headSha,
+        observedAt: typeof item.observed_at === "string" ? sanitizeCiText(item.observed_at, 64) : "unavailable",
+        freshness: typeof item.freshness === "string" ? sanitizeCiText(item.freshness, 64) : "unavailable",
+        coverage: typeof item.coverage === "string" ? sanitizeCiText(item.coverage, 64) : "unknown",
+        availability: typeof item.availability === "string" ? sanitizeCiText(item.availability, 64) : "unavailable",
+        required,
+        related,
+    };
+}
 /** Validate + de-duplicate one check-name list; `null` when a name is unusable. */
 function readCheckNames(raw) {
     if (raw === undefined || raw === null)
@@ -286,21 +373,38 @@ export function readCiFixDispatchContext(job) {
         missingChecks: missing,
         requiredClaimChecks: required,
         logExcerpts,
+        evidence: readCiEvidence(raw.evidence_snapshot, headSha, new Set(failing)),
     };
 }
 function formatCheckList(names, none) {
-    return names.length > 0 ? names.map((name) => `- ${name}`).join("\n") : none;
+    return names.length > 0 ? names.map((name) => `- ${sanitizeCiText(name, 200)}`).join("\n") : none;
 }
-function formatLogExcerpts(excerpts) {
+function formatLogExcerpts(context) {
+    const evidence = context.evidence;
+    const header = evidence.status === "unavailable"
+        ? `CI snapshot UNAVAILABLE (${evidence.reason}).` : [
+        `Policy: ${evidence.policySource} (${evidence.policyFingerprint})`,
+        `Target: ${evidence.repository} ${evidence.targetBranch} @ ${evidence.headSha}`,
+        `Observed: ${evidence.observedAt}; freshness: ${evidence.freshness}`,
+        `Coverage: ${evidence.coverage}; detail: ${evidence.availability}`,
+        "Selected required failures:",
+        ...evidence.required.map((item) => `- ${sanitizeCiText(item.name, 200)} [${item.sourceKind}; run ${item.runId ?? "unavailable"}; ${item.conclusion}]${item.sourceRef ? ` ${item.sourceRef}` : ""}`),
+        "Related failures — contribution not established:",
+        ...evidence.related.map((name) => `- ${name}`),
+    ].join("\n");
+    const excerpts = context.logExcerpts;
     if (excerpts.status === "unavailable") {
-        return ("UNAVAILABLE — no log excerpt was supplied with this job " +
+        return header + "\n## UNTRUSTED PROVIDER DIAGNOSTICS BEGIN ##\n" + ("UNAVAILABLE — no log excerpt was supplied with this job " +
             `(reason: ${excerpts.reason}). No log content is provided below or ` +
             "anywhere else in this prompt. Diagnose from the check names, the code, " +
-            "and local reproduction; do not assume what any log said.");
-    }
-    return excerpts.excerpts
-        .map((e) => `--- check: ${e.check} (source: ${e.source}) ---\n${e.text}`)
-        .join("\n\n");
+            "and local reproduction; do not assume what any log said.") + "\n## UNTRUSTED PROVIDER DIAGNOSTICS END ##";
+    }
+    const summaries = evidence.status === "available"
+        ? evidence.required.filter((item) => item.summary).map((item) => `${sanitizeCiText(item.name, 200)} selected summary: ${item.summary}`)
+        : [];
+    return header + "\n## UNTRUSTED PROVIDER DIAGNOSTICS BEGIN ##\n" +
+        [...summaries, ...excerpts.excerpts.map((e) => `--- check: ${sanitizeCiText(e.check, 200)} (source: ${sanitizeCiText(e.source, 200)}) ---\n${sanitizeCiText(e.text)}`)].join("\n\n") +
+        "\n## UNTRUSTED PROVIDER DIAGNOSTICS END ##";
 }
 /**
  * Explicit "no stale-citation advisory" value (BAPI-722) — never an empty string.
@@ -487,7 +591,7 @@ export async function buildPromptSpecPlaceholderValues(job, spec, context) {
                 const ci = readCiFixDispatchContext(job);
                 values.FAILING_CHECKS = formatCheckList(ci.failingChecks, "(none — no check was observed failing on the dispatched head)");
                 values.MISSING_CHECKS = formatCheckList(ci.missingChecks, "(none — every required check reported on the dispatched head)");
-                values.LOG_EXCERPTS = formatLogExcerpts(ci.logExcerpts);
+                values.LOG_EXCERPTS = formatLogExcerpts(ci);
                 break;
             }
             case "SPEC_CITATION_FRESHNESS_WARNING": {

package/build/executor/runner.js

@@ -151,6 +151,8 @@ export async function runExecutor(options, deps, httpClient, seams = {}) {
             // optional mtime boundary (keeps GC conservative → retains).
             statMtimeMs: deps.statMtimeMs ?? (async () => null),
             platform: deps.platform,
+            // BAPI-1330: finds the per-attempt worker logs for the activity probe.
+            ...(deps.readdir ? { listDir: deps.readdir } : {}),
         }));
     // BAPI-1301 — before the first claim, inspect ownership records left by a
     // previous executor process on this host. Each record holds the real per-job
@@ -557,6 +559,7 @@ export async function runExecutor(options, deps, httpClient, seams = {}) {
      * a failure is reported to stderr and the loop keeps going. It cannot fail a
      * claim, fail a job, or end the run.
      */
+    let latestCorrectionQualification = null;
     const runProcessHeartbeatLoop = async () => {
         const publish = httpClient.processHeartbeat;
         // A client without the capability (every object-literal test fake) simply
@@ -589,10 +592,20 @@ export async function runExecutor(options, deps, httpClient, seams = {}) {
                     ? { claim_mode: "scoped", epic_run_id: observedEpicRunId }
                     : { claim_mode: "scoped" },
         };
+        const baseMetadata = request.metadata;
         // Suppression state: one message per CHANGE of delivery state, so a long
         // outage produces one line rather than one per minute.
         let lastFailed = false;
         for (;;) {
+            request.metadata = {
+                ...baseMetadata,
+                ...(latestCorrectionQualification
+                    ? { correction_intent: latestCorrectionQualification }
+                    : {}),
+                ...(latestCorrectionQualification?.qualified === true
+                    ? { ci_evidence: { version: 1, qualified: true } }
+                    : {}),
+            };
             let outcome;
             try {
                 outcome = await publish.call(httpClient, request);
@@ -781,6 +794,16 @@ export async function runExecutor(options, deps, httpClient, seams = {}) {
     try {
         for (;;) {
             const report = await collectPreflight(options, deps, preflightSeams);
+            latestCorrectionQualification = report.correctionIntentQualified === true &&
+                report.correctionQualificationEvidence?.hook_installed === true &&
+                report.correctionQualificationEvidence.nested_denial === true
+                ? {
+                    version: 1, qualified: true, hook_installed: true,
+                    nested_denial: true,
+                    fixture_id: report.correctionQualificationEvidence.fixture_id,
+                    runtime: report.correctionQualificationEvidence.runtime,
+                }
+                : null;
             // First heartbeat goes out immediately once preflight passes, so a freshly
             // started executor is visible to the server without waiting one interval.
             // Gated on `report.ok` because an executor that preflight refuses is not

package/build/executor/stale-artifacts.js

@@ -25,10 +25,11 @@ export const CONDUCTOR_CRITIQUE_FILE = "critique.md";
 /**
  * The files a prior attempt may leave behind, and the ONLY ones removed here.
  *
- * `worker.lock` and `worker.log` are deliberately absent: the lock is live
- * coordination state, and the log is forensic evidence truncated by its own
- * owner (`worker-log.ts`). The `.conductor/` directory itself and any unrelated
- * file inside it are left untouched.
+ * `worker.lock` and the worker logs are deliberately absent: the lock is live
+ * coordination state, and each attempt's log is forensic evidence that its owner
+ * (`worker-log.ts`) creates exclusively and never truncates (BAPI-1330). The
+ * `.conductor/` directory itself and any unrelated file inside it are left
+ * untouched.
  */
 export const STALE_ATTEMPT_ARTIFACT_FILES = [
     CONDUCTOR_RESULT_FILE,

package/build/executor/types.js

@@ -52,6 +52,7 @@ export const EXECUTOR_CLASSIFICATION_VALUES = [
  * evidence: `rebase` is not a covered job type.
  */
 export const FOCUSED_REBASE_CAPABILITY = "focused_rebase.v1";
+export const SCOPE_WAIT_CAPABILITY = "scope_wait.v1";
 /** The focused context version; the same string as the capability on purpose. */
 export const FOCUSED_REBASE_CONTEXT_VERSION = FOCUSED_REBASE_CAPABILITY;
 /**

package/build/executor/watch-cli.js

@@ -3,7 +3,13 @@
  *
  * Ad-hoc, READ-ONLY attachment to a running (or recently-run) job's worker log:
  * it resolves the local job-log registry record, verifies the log file exists,
- * and `tail -f`s it with inherited stdio. It NEVER sends a signal to the worker
+ * and `tail -f`s it with inherited stdio.
+ *
+ * BAPI-1330: each attempt has its own stable log file. The newest attempt is
+ * watched by default and `--attempt <n>` selects an earlier one. A reference the
+ * registry cannot vouch for — a legacy fixed-alias record, an unknown attempt,
+ * a transcript that was never recorded — is reported by its named reason; the
+ * watch never follows a guessed or shared file. It NEVER sends a signal to the worker
  * process and never owns the execution lifecycle — closing the watch leaves the
  * worker untouched. Missing registry records or missing log files fail loud with
  * actionable stderr text and a non-zero exit code.
@@ -15,7 +21,7 @@ import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { readExecutorJobLogRecord, } from "./job-log-registry.js";
 export function getExecutorWatchUsage() {
     return [
-        "Usage: mcp-server executor watch <job-id>",
+        "Usage: mcp-server executor watch <job-id> [--attempt <n>]",
         "",
         "Attach read-only to a running (or recently-run) executor job's worker log",
         "via `tail -f`. Closing the watch never affects the worker process.",
@@ -24,15 +30,32 @@ export function getExecutorWatchUsage() {
         "  <job-id>        Numeric executor job id to watch.",
         "",
         "Options:",
+        "  --attempt <n>   Watch that attempt's log instead of the newest one.",
         "  -h, --help      Show this help.",
     ].join("\n");
 }
-/** Accept EXACTLY one numeric job id; reject missing/non-numeric/extra args. */
+/**
+ * Accept EXACTLY one numeric job id plus an optional `--attempt <n>` (or
+ * `--attempt=<n>`); reject missing/non-numeric/extra args.
+ */
 export function parseExecutorWatchArgs(argv) {
     const positionals = [];
-    for (const arg of argv) {
+    let attemptRaw;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
         if (arg === "-h" || arg === "--help")
             return { kind: "help" };
+        if (arg === "--attempt" || arg.startsWith("--attempt=")) {
+            if (attemptRaw !== undefined) {
+                return { kind: "error", message: "--attempt may be given only once" };
+            }
+            const value = arg === "--attempt" ? argv[++i] : arg.slice("--attempt=".length);
+            if (value === undefined || !/^[0-9]+$/.test(value)) {
+                return { kind: "error", message: "--attempt requires a non-negative attempt number" };
+            }
+            attemptRaw = value;
+            continue;
+        }
         if (arg.startsWith("-"))
             return { kind: "error", message: `unknown argument: ${arg}` };
         positionals.push(arg);
@@ -47,7 +70,9 @@ export function parseExecutorWatchArgs(argv) {
     if (!/^[0-9]+$/.test(raw)) {
         return { kind: "error", message: `job id must be numeric: '${raw}'` };
     }
-    return { kind: "ok", jobId: Number(raw) };
+    return attemptRaw === undefined
+        ? { kind: "ok", jobId: Number(raw) }
+        : { kind: "ok", jobId: Number(raw), attempt: Number(attemptRaw) };
 }
 /**
  * Spawn `tail -f <log_path>` with inherited stdio for interactive CLI attachment.
@@ -98,14 +123,16 @@ export async function runExecutorWatchCli(argv, overrides = {}) {
     }
     const registryDeps = overrides.registryDeps ?? createDefaultWatchRegistryDeps();
     const readRecord = overrides.readRecord ?? readExecutorJobLogRecord;
-    const record = await readRecord(parsed.jobId, registryDeps);
+    const selector = parsed.attempt === undefined ? {} : { attempt: parsed.attempt };
+    const record = await readRecord(parsed.jobId, registryDeps, selector);
     if (!record.ok) {
-        errorLog(`Error: no worker log registered for job ${parsed.jobId}: ${record.reason}`);
+        errorLog(`Error: worker log for job ${parsed.jobId} is unavailable (${record.code}): ${record.reason}`);
         return 1;
     }
     const logExists = overrides.logExists ?? defaultLogExists;
     if (!(await logExists(record.record.log_path))) {
-        errorLog(`Error: worker log for job ${parsed.jobId} is missing at ${record.record.log_path}`);
+        errorLog(`Error: worker log for job ${parsed.jobId} attempt ${record.record.attempt} is unavailable ` +
+            `(log_file_missing): expected at ${record.record.log_path}`);
         return 1;
     }
     const spawnTail = overrides.spawnTail ?? ((logPath) => spawnTailFollow(logPath));

package/build/executor/worker-command.js

@@ -18,7 +18,7 @@
  * agent's CLI from becoming an operator-visible policy break across all of them.
  */
 import { CiFixContext, ExecutorNamedError } from "./job-errors.js";
-import { isRecoveryJobType } from "./job-types.js";
+import { isRemainingWork, validateCorrectionIntent } from "./correction-dispatch.js";
 /**
  * BAPI-1296: `ci_fix` is the one recovery job with a FOCUSED prompt route. It
  * renders its server-authored `payload.prompt_spec` (the dispatched failing and
@@ -27,11 +27,9 @@ import { isRecoveryJobType } from "./job-types.js";
 export const CI_FIX_JOB_TYPE = "ci_fix";
 /**
  * Resolve the worker prompt for the explicit-prompt and legacy synthesis paths.
- * Uses an explicit non-empty `payload.prompt` verbatim; otherwise, for
- * `implement` and the `remediate`/`rebase` recovery jobs, builds the
- * conservative `/implement-ticket <ticket_key> --auto` prompt. `ci_fix` never
- * resolves here (BAPI-1296): it is refused if it carries an explicit prompt and
- * otherwise falls through to its focused prompt-spec route.
+ * Remaining work first requires a validated bounded correction intent. Only an
+ * initial `implement` job may synthesize `/implement-ticket <ticket_key> --auto`.
+ * `ci_fix` uses the focused prompt-spec route after pre-worktree validation.
  *
  * Structured `payload.prompt_spec` rendering is NOT done here: it needs the
  * prepared worktree/git state, so `job-runner.ts` renders it in the prepared-spawn
@@ -46,29 +44,48 @@ export const CI_FIX_JOB_TYPE = "ci_fix";
  * explicit prompt. It no longer depends on the prompt-spec fall-through.
  */
 /**
- * True for the job types that synthesize `/implement-ticket <KEY> --auto` when no
- * explicit `payload.prompt` is present: the first-pass `implement` plus the
- * `remediate`/`rebase` recovery jobs, which re-enter the SAME correction loop on
- * the ticket's existing branch/PR. Recovery classification is shared with
- * dispatch and worktree reuse via `isRecoveryJobType` (`job-types.ts`) so
- * eligibility cannot drift. Verdict jobs (`spec_review`/`smoke`) are NOT here —
- * they carry an explicit `payload.prompt` and write a fixed-path artifact (T6/T5b).
- *
- * BAPI-1296: `ci_fix` is EXCLUDED even though it stays a recovery job (branch
- * reuse, worktree lock, and finalization policy are unchanged). Re-entering the
- * whole recipe to repair a dispatched check repeated planning and implementation
- * the server had already finished; `ci_fix` now renders its focused prompt spec
- * or is refused by name, and never falls back to this synthesis.
+ * Only the first-pass `implement` job synthesizes the complete workflow.
  */
 export function synthesizesImplementPrompt(jobType) {
-    if (jobType === CI_FIX_JOB_TYPE)
-        return false;
-    return jobType === "implement" || isRecoveryJobType(jobType);
+    return jobType === "implement";
 }
 export function resolveExecutorPrompt(job) {
     const payload = job.payload && typeof job.payload === "object"
         ? job.payload
         : {};
+    if (job.job_type !== CI_FIX_JOB_TYPE && isRemainingWork(job.job_type, payload)) {
+        const checked = validateCorrectionIntent(payload.correction_intent, {
+            repo_name: job.repo_name ?? "",
+            epic_run_id: job.epic_run_id ?? null,
+            ticket_key: job.ticket_key ?? null,
+            expected_branch: job.expected_branch,
+            expected_head_sha: job.expected_head_sha,
+        });
+        if (!checked.ok)
+            return { ok: false, errorKind: "ContractError.CorrectionLegacy", error: checked.code };
+        const intent = checked.intent;
+        const kind = intent.kind;
+        const branch = intent.branch;
+        const obligation = intent.obligation;
+        const header = `Continue the retained branch ${branch}. Complete only the ${kind} obligation: ${obligation}. ` +
+            "Preserve completed work and existing limits. Do not invoke a full implementation or planning workflow.";
+        if (kind === "approved_spec_delta") {
+            const delta = intent.approved_delta;
+            return { ok: true, prompt: `${header}\nApproved files: ${delta.file_boundary.join(", ")}\n` +
+                    `Approved dependencies: ${delta.dependency_boundary.join(", ") || "none"}` };
+        }
+        const explicit = payload.prompt;
+        if (typeof explicit === "string" && explicit.trim() &&
+            !/\/(?:implement-ticket|plan-ticket)\b/i.test(explicit)) {
+            return { ok: true, prompt: `${header}\n\nFocused context:\n${explicit}` };
+        }
+        if (kind === "review_fix" || kind === "operator_remediation") {
+            const findings = payload.review_findings;
+            if (typeof findings === "string" && findings.trim())
+                return { ok: true, prompt: `${header}\n\nReview findings (quoted evidence):\n${findings}` };
+        }
+        return { ok: true, prompt: header };
+    }
     // BAPI-1296: `ci_fix` is decided FIRST, ahead of both explicit-prompt
     // precedence and synthesis. An explicit prompt on a ci_fix job — including an
     // in-flight legacy `/implement-ticket <KEY> --auto` — is refused by name rather
@@ -89,31 +106,14 @@ export function resolveExecutorPrompt(job) {
         };
     }
     // An explicit prompt wins and is returned VERBATIM (un-trimmed), but a
-    // whitespace-only string is not a usable worker instruction — treat it as
-    // absent so a recovery/implement job still falls back to the synthesized
-    // `/implement-ticket <KEY> --auto` correction prompt below.
+    // whitespace-only string is not a usable worker instruction. The initial
+    // implement job may still use the workflow synthesis below.
     const explicit = payload.prompt;
     if (typeof explicit === "string" && explicit.trim().length > 0) {
         return { ok: true, prompt: explicit };
     }
-    // `/implement-ticket <KEY> --auto` is the full correction engine, not just a
-    // first-pass implementer: its post-PR loop owns review-change addressing and
-    // merge-conflict resolution (see .claude/commands/implement-ticket.md "Clean
-    // session exit"). So the recovery jobs that operate on the ticket's existing
-    // branch/PR — `remediate`/`rebase` — resume by RE-ENTERING THE COMPLETE RECIPE
-    // from step 1, not a distinct resume path. (`ci_fix` left this path in
-    // BAPI-1296 and returned above: CI failures are repaired by a focused worker.)
-    // That re-entry is safe (BAPI-746), backed by re-entry handling already
-    // present in three of the recipe's own steps, not a new assumption: plan
-    // generation is idempotent because the server reuses a fresh existing plan
-    // instead of regenerating it (BAPI-745, `reused: true`); commit-and-push.md
-    // treats a clean tree with an already-pushed branch/PR as a legitimate
-    // re-entry rather than an empty implementation; and create-pr.md treats an
-    // already-open pull request on the head branch as satisfying its success
-    // condition. Without synthesizing this command, a code_review
-    // `changes_requested` (near-certain in real runs) enqueues a `remediate` job
-    // that fails `no usable prompt` and strands the run (BAPI-528 Milestone-A gap
-    // #3).
+    // This final synthesis route is for initial feature work only. The remaining
+    // work branch returned a focused prompt or a named refusal above.
     const ticketKey = typeof job.ticket_key === "string" && job.ticket_key.trim().length > 0
         ? job.ticket_key.trim()
         : null;

package/build/executor/worker-finalization.js

@@ -45,9 +45,20 @@
  * so an omitted body opens a PR with no description at all), and — when the
  * provider reports it — sitting at the same pushed head. Anything short of that
  * is `WorkerFinalizationPrNotAttached`, whose guidance names attachment and never
- * suggests removing or re-writing the branch: the commits ARE the completed
- * implementation, and both of the stale-worktree guard's historical remedies
- * would have destroyed them.
+ * suggests removing or re-writing the branch: the commits are durable pushed
+ * work, and both of the stale-worktree guard's historical remedies would have
+ * destroyed them.
+ *
+ * BAPI-1330: publication is not completion. A pushed head and an attached pull
+ * request prove the work was PUBLISHED; they say nothing about whether the
+ * required work is finished or whether any check passed, so no message here
+ * claims either. A clean exit that fails finalization keeps the `clean_exit`
+ * classification the process actually earned — the finalization failure rides
+ * separately as the error kind. And a COVERED attempt (one the server enrolled
+ * in the completion-evidence contract) may not use the existence-only fallback:
+ * without a full worker HEAD, a matching origin tip and a pull request that
+ * reports its head, publication is `unknown`
+ * (`WorkerFinalizationPublicationUnverified`), never `ok`.
  *
  * This check is deliberately fail-CLOSED, unlike the BAPI-586 base check it now
  * shares a lookup with. "The PR could not be verified" and "there is no PR" are
@@ -56,8 +67,10 @@
  * this ticket removes. The reconciler stays the decision-maker — the executor
  * only reports the observation (R14 rule 3).
  */
-import { ReconcileOverlapPushUnfinalized, secretFreeErrorMessage, WorkerFinalizationMissingRemoteBranchAndPr, WorkerFinalizationPrBaseMismatch, WorkerFinalizationPrNotAttached, WorkerFinalizationSavedButUnfinalized, } from "./job-errors.js";
+import { ReconcileOverlapPushUnfinalized, secretFreeErrorMessage, WorkerFinalizationMissingRemoteBranchAndPr, WorkerFinalizationPrBaseMismatch, WorkerFinalizationPrNotAttached, WorkerFinalizationPublicationUnverified, WorkerFinalizationSavedButUnfinalized, } from "./job-errors.js";
 import { isImplementationStyleJobType } from "./job-types.js";
+/** A full, lower-case 40-hex commit SHA. */
+const FULL_SHA_RE = /^[0-9a-f]{40}$/;
 /** The `runCommand` options for one bounded read; `{ cwd }` alone when unbounded. */
 function callOptions(worktreePath, bound) {
     return bound && typeof bound.timeoutMs === "number"
@@ -268,7 +281,7 @@ function evaluatePrBase(job, pr, expectedBase) {
  * means the provider has not yet reflected the push, not that the push is in
  * doubt.
  */
-function evaluatePrContract(pr, workerHeadSha) {
+function evaluatePrContract(pr, workerHeadSha, coveredAttempt = false) {
     if (!pr.found) {
         return {
             ok: false,
@@ -296,6 +309,17 @@ function evaluatePrContract(pr, workerHeadSha) {
             retryable: false,
         };
     }
+    if (coveredAttempt && pr.headRefOid === null) {
+        // BAPI-1330: a legacy attempt accepts a PR whose head the provider did not
+        // report; a covered one cannot, because the PR head is part of what binds
+        // the published work to this attempt's final head.
+        return {
+            ok: false,
+            detail: "its pull request reports no head commit",
+            retryable: true,
+            unverified: true,
+        };
+    }
     if (workerHeadSha && pr.headRefOid !== null && pr.headRefOid !== workerHeadSha) {
         return {
             ok: false,
@@ -317,9 +341,16 @@ function evaluatePrContract(pr, workerHeadSha) {
  *    so the executor failure and the reconciler's observation are searchable as
  *    one state instead of two vocabularies for the same thing.
  * 2. It recommends attachment and says plainly that removing or re-writing the
- *    branch destroys completed work. In the F4 incident the pushed branch WAS the
- *    finished implementation, and both remedies the stale-worktree guard offered
- *    would have thrown it away.
+ *    branch destroys pushed work. In the F4 incident the pushed branch held the
+ *    implementation, and both remedies the stale-worktree guard offered would
+ *    have thrown it away.
+ *
+ * BAPI-1330: it claims ONLY what finalization observed — durable pushed commits
+ * and an unmet pull-request attachment. Whether the required work is finished,
+ * and whether any check passed, is stated as not established here; only the
+ * completion evidence (when the attempt was covered) can speak to either. The
+ * classification is `clean_exit`, because that is how the process ended; the
+ * finalization failure is carried by the error kind, not by rewriting the exit.
  */
 function prNotAttachedFailure(job, branch, workerHeadSha, expectedBase, detail) {
     const label = job.ticket_key ? `${job.ticket_key} (job ${job.id})` : `job ${job.id}`;
@@ -328,14 +359,31 @@ function prNotAttachedFailure(job, branch, workerHeadSha, expectedBase, detail)
     return {
         error_kind: WorkerFinalizationPrNotAttached,
         error_message: `${label} exited cleanly and its HEAD${headLabel} is durable on origin branch '${branch}', ` +
-            `but ${detail}. This is the pr_not_attached state: the implementation is COMPLETE and ` +
-            `published, only its pull request is missing. Recovery: open or attach a pull request for ` +
-            `'${branch}'${baseLabel} with a non-empty description. Removing or re-writing that branch ` +
-            `would destroy finished work — the commits on it are the implementation.`,
-        classification: "crashed",
+            `but ${detail}. This is the pr_not_attached state: the commits are pushed and the pull ` +
+            `request attachment is unmet. Whether the required work is finished, and whether any ` +
+            `check passed, is not established by this observation. Recovery: open or attach a pull ` +
+            `request for '${branch}'${baseLabel} with a non-empty description. Removing or re-writing ` +
+            `that branch would destroy pushed work.`,
+        classification: "clean_exit",
         last_commit_sha: workerHeadSha || undefined,
     };
 }
+/**
+ * BAPI-1330: a covered attempt whose publication could not be PROVEN. Built only
+ * from public identifiers and a fixed detail phrase. It never says a pull request
+ * is absent, because none was observed to be — the verdict is `unknown`.
+ */
+function publicationUnverifiedFailure(job, branch, workerHeadSha, detail) {
+    const label = job.ticket_key ? `${job.ticket_key} (job ${job.id})` : `job ${job.id}`;
+    return {
+        error_kind: WorkerFinalizationPublicationUnverified,
+        error_message: `${label} exited cleanly, but publication of branch '${branch}' could not be verified: ` +
+            `${detail}. Publication, required-work completion and check status are unknown for this ` +
+            `attempt; nothing was observed to be missing and nothing on the branch was changed.`,
+        classification: "clean_exit",
+        last_commit_sha: FULL_SHA_RE.test(workerHeadSha) ? workerHeadSha : undefined,
+    };
+}
 /**
  * `detail` describes a state with NO evidence any work reached origin (branch
  * unresolved, branch absent from origin, or the origin lookup itself failed).
@@ -459,6 +507,17 @@ export async function validateWorkerFinalization(input) {
     // runs unconditionally — including when `hasPrUrl` is true (BAPI-762, AC-5): a
     // PR being open is never accepted as proof this worker's own commit landed.
     const trimmedHeadSha = typeof headSha === "string" ? headSha.trim().toLowerCase() : "";
+    const covered = input.coveredAttempt === true;
+    // BAPI-1330: the existence-only fallback below is a LEGACY concession to
+    // degraded telemetry. A covered attempt cannot bind its final head to anything
+    // without the worker's full HEAD, so it stops here with an `unknown` verdict
+    // rather than accepting "the branch exists" as publication.
+    if (covered && !FULL_SHA_RE.test(trimmedHeadSha)) {
+        return {
+            ok: false,
+            failure: publicationUnverifiedFailure(job, trimmedBranch, trimmedHeadSha, "the worker's full HEAD commit could not be established"),
+        };
+    }
     const attempts = normalizeAttempts(input.originResolveAttempts);
     const retryDelayMs = normalizeRetryDelay(input.originResolveRetryDelayMs);
     const sleep = input.sleep ?? sleepMs;
@@ -518,11 +577,17 @@ export async function validateWorkerFinalization(input) {
         if (refreshedBaseVerdict)
             return { ok: false, failure: refreshedBaseVerdict };
     }
-    let contract = evaluatePrContract(pr, trimmedHeadSha);
+    let contract = evaluatePrContract(pr, trimmedHeadSha, covered);
     for (let attempt = 1; attempt < attempts && !contract.ok && contract.retryable; attempt++) {
         await sleep(retryDelayMs);
         pr = await resolvePrForFinalization(runCommand, worktreePath, trimmedBranch, bound());
-        contract = evaluatePrContract(pr, trimmedHeadSha);
+        contract = evaluatePrContract(pr, trimmedHeadSha, covered);
+    }
+    if (!contract.ok && contract.unverified === true) {
+        return {
+            ok: false,
+            failure: publicationUnverifiedFailure(job, trimmedBranch, trimmedHeadSha, contract.detail),
+        };
     }
     if (!contract.ok) {
         return {