@bridge_gpt/mcp-server 0.2.65 → 0.2.67

package/build/executor/job-types.js

@@ -4,10 +4,8 @@
  * Single source of truth for which claimed job types the executor spawns and
  * which of those are RECOVERY jobs. Recovery jobs (`remediate`/`ci_fix`/`rebase`/
  * `reconcile_overlap`) resume the ticket's existing branch/PR rather than cutting
- * a fresh branch off base — `remediate`/`rebase` through the `/implement-ticket
- * <KEY> --auto` correction loop, `ci_fix` through its focused prompt spec
- * (BAPI-1296: never the full recipe), `reconcile_overlap` through its own job
- * body. Dispatch
+ * a fresh branch off base. Each recovery worker requires a versioned focused
+ * correction intent; `ci_fix` also uses its focused prompt spec. Dispatch
  * (`job-runner.ts` `runClaimedJob`), prompt synthesis (`worker-command.ts`
  * `resolveExecutorPrompt`), and worktree reuse (`job-runner.ts` `prepareSpawn` →
  * `worktree.ts` `ensureExecutorWorktree`) all read from here so the recovery /
@@ -24,16 +22,13 @@
  * `reconcile_overlap`). They work on the ticket's EXISTING branch/PR, so the
  * executor reuses that branch instead of cutting a fresh one off base.
  *
- * BAPI-1296: `ci_fix` stays a recovery job — and an implementation-style job
- * below — for branch reuse, the worktree lock, and finalization, but prompt
- * selection no longer follows recovery membership for it: `worker-command.ts`
- * refuses to synthesize `/implement-ticket` for `ci_fix`, and `job-runner.ts`
- * renders its server-authored focused prompt spec instead.
+ * `ci_fix` stays a recovery job for branch reuse, the worktree lock, and
+ * finalization. `job-runner.ts` renders its server-authored focused prompt spec
+ * after the correction intent is validated.
  *
- * BAPI-1152: `reconcile_overlap` is a recovery job for worktree reuse and prompt
- * resolution, but it does NOT re-enter `/implement-ticket`: it always carries an
- * explicit server-rendered `payload.prompt`, which wins over the synthesis in
- * `worker-command.ts`, and `job-runner.ts` dispatches it to its own body.
+ * `reconcile_overlap` is a recovery job for worktree reuse and prompt
+ * resolution. Its server-rendered focused prompt is available only after
+ * validating the correction intent, and `job-runner.ts` dispatches its body.
  *
  * BAPI-1160: `ci_rerun` is DELIBERATELY ABSENT from this set and from
  * `SPAWN_JOB_TYPES` below. It is a deterministic actuator — one bounded

package/build/executor/observation.js

@@ -34,9 +34,14 @@ export async function collectGitTelemetry(deps, worktreePath, baseBranch) {
         /* degraded: omit last_commit_sha */
     }
     try {
+        // `--no-optional-locks`: a plain `git status` refreshes the index and takes
+        // `.git/index.lock`. This runs on every heartbeat against the LIVE worker's
+        // worktree, so without it a worker's own `git add`/`commit` can fail with
+        // "index.lock: File exists".
         const status = await deps.runCommand("git", [
             "-C",
             worktreePath,
+            "--no-optional-locks",
             "status",
             "--porcelain",
         ]);
@@ -293,7 +298,7 @@ const RATE_LIMIT_CONSEQUENCE_TEXT = "This warning is advisory only and triggers
     "rejection and the server advertised capacity recovery for this job; otherwise " +
     "the failure follows ordinary failure handling.";
 /** Fixed runbook reference appended to every rate-limit diagnostic (BAPI-898). */
-const RATE_LIMIT_RUNBOOK_REFERENCE = "See docs/claude/epic-implementer-v2-operator-runbook.md §8.";
+const RATE_LIMIT_RUNBOOK_REFERENCE = "See docs/epic-implementer/operator-runbook.md §8.";
 /**
  * Render the operator-facing rate-limit line (BAPI-828, BAPI-898).
  *

package/build/executor/preflight.js

@@ -2,10 +2,17 @@ import { DEFAULT_PROBE_TIMEOUT_MS } from "../agent-capabilities/types.js";
 import { inspectExecutorAgentAdapter, inspectionForFailedResolution, } from "../agent-launchers/executor-adapter-inspection.js";
 import { resolveExecutorAgentAdapter } from "../agent-launchers/executor-adapter-registry.js";
 import { resolveCompletionEvidenceCapability } from "../agent-launchers/executor-adapter.js";
-import { COMPLETION_EVIDENCE_CAPABILITY, REQUIRED_VERIFICATION_CAPABILITY, runtimeMatchesSupported, } from "./completion-contract.js";
+import { COMPLETION_EVIDENCE_CAPABILITY, REQUIRED_VERIFICATION_CAPABILITY, cliVersionAtLeast, normalizeCliVersion, parseCliVersion, runtimeMatchesSupported, } from "./completion-contract.js";
+import { buildHeadlessAgentEnv } from "./env.js";
 import { resolveExecutorAgentId } from "./agent-identity.js";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { defaultResolveBinPath } from "../start-tickets-conductor.js";
+import { CORRECTION_INTENT_CAPABILITY } from "./correction-dispatch.js";
 import { resolveAllExecutorApiAccess, resolveBaseUrl, EXECUTOR_BASE_URL_REQUIRED_MESSAGE, } from "./credentials.js";
-import { FOCUSED_REBASE_CAPABILITY } from "./types.js";
+import { FOCUSED_REBASE_CAPABILITY, SCOPE_WAIT_CAPABILITY } from "./types.js";
 /**
  * Environment override for the deny probe's headless timeout (BAPI-722).
  *
@@ -117,20 +124,34 @@ export async function evaluateCompletionEvidenceQualification(adapter, deps) {
     if (probed === null) {
         return { qualified: false, refusal: "runtime identity probe did not run", runtime: null };
     }
-    const declared = capability.value.runtime;
+    const declared = capability.value.predicate;
     const mismatches = [];
-    for (const key of ["adapter", "cli_version", "platform", "event_schema"]) {
-        if (probed[key] !== declared[key]) {
-            mismatches.push(`${key} ${String(probed[key]).slice(0, 40)} != ${declared[key]}`);
-        }
+    if (probed.adapter !== declared.adapter) {
+        mismatches.push(`adapter ${String(probed.adapter).slice(0, 40)} != ${declared.adapter}`);
+    }
+    if (probed.event_schema !== declared.event_schema) {
+        mismatches.push(`event_schema ${String(probed.event_schema).slice(0, 40)} != ${declared.event_schema}`);
     }
     if (mismatches.length > 0) {
         return {
             qualified: false,
-            refusal: bounded(`probed runtime differs from the approved identity: ${mismatches.join("; ")}`),
+            refusal: bounded(`probed runtime differs from the declared predicate: ${mismatches.join("; ")}`),
             runtime: probed,
         };
     }
+    // Fixed reasons below: the probed version and platform are never echoed, because
+    // an unparseable value is arbitrary probe output.
+    const version = parseCliVersion(probed.cli_version);
+    const minimum = parseCliVersion(declared.min_cli_version);
+    if (version === null || minimum === null) {
+        return { qualified: false, refusal: "probed CLI version is not a recognized version", runtime: probed };
+    }
+    if (!cliVersionAtLeast(version, minimum)) {
+        return { qualified: false, refusal: "probed CLI version is older than the minimum", runtime: probed };
+    }
+    if (!declared.platforms.includes(probed.platform)) {
+        return { qualified: false, refusal: "probed platform is not a supported platform", runtime: probed };
+    }
     if (!runtimeMatchesSupported(probed)) {
         return {
             qualified: false,
@@ -138,7 +159,12 @@ export async function evaluateCompletionEvidenceQualification(adapter, deps) {
             runtime: probed,
         };
     }
-    return { qualified: true, refusal: null, runtime: probed };
+    // Normalized (suffix stripped) so the retained identity and the envelope carry one form.
+    const normalized = normalizeCliVersion(probed.cli_version);
+    if (normalized === null) {
+        return { qualified: false, refusal: "probed CLI version is not a recognized version", runtime: probed };
+    }
+    return { qualified: true, refusal: null, runtime: { ...probed, cli_version: normalized } };
 }
 /** Fail-fast report shape for a preflight that refused before probing. */
 function refusedPreflight(fatalFindings, warnings, adapter) {
@@ -154,6 +180,68 @@ function refusedPreflight(fatalFindings, warnings, adapter) {
         adapter,
     };
 }
+export const CORRECTION_HOOK_FIXTURE_ID = "correction-entry-nested-v2";
+const spawnCorrectionHook = (args, input, env) => {
+    const result = spawnSync(process.execPath, args, { input, encoding: "utf8", env, timeout: 5000 });
+    return { status: result.status, ...(result.error ? { error: result.error } : {}) };
+};
+/** Exercise the packaged hook process, including a nested-agent entry attempt. */
+export function probeInstalledCorrectionHook(worktreePath, binPath = defaultResolveBinPath("worker-guard-hook-bin.js"), run = spawnCorrectionHook) {
+    const args = [binPath, "--worktree-root", worktreePath,
+        "--correction-intent-version", "1"];
+    const env = { ...process.env, BAPI_CORRECTION_INTENT_VERSION: "1" };
+    const fixtures = [
+        { payload: { tool_name: "Skill", tool_input: { skill: "bridge-implement-ticket" } }, status: 2 },
+        { payload: { tool_name: "Task", tool_input: { prompt: "/implement-ticket BAPI-1 --auto" } }, status: 2 },
+        { payload: { tool_name: "Read", tool_input: { file_path: "commands/src/implement-ticket.md" } }, status: 0 },
+        {
+            payload: { tool_name: "Bash", tool_input: { command: 'claude -p "/implement-ticket BAPI-1"' } },
+            status: 2,
+        },
+        { payload: { tool_name: "mcp__bridge_api__request_plan_generation", tool_input: {} }, status: 2 },
+        { payload: { tool_name: "mcp__bridge_api__get_plan", tool_input: { ticket_number: "BAPI-1" } }, status: 0 },
+    ];
+    return fixtures.every(({ payload, status }) => {
+        const result = run(args, JSON.stringify(payload), env);
+        return result.error === undefined && result.status === status;
+    });
+}
+export async function qualifyCorrectionIntentRuntime(adapter, deps, probeHook = probeInstalledCorrectionHook) {
+    if (adapter.identity.strategyId !== "claude-strict-mcp-v1" ||
+        adapter.denyEnforcement?.supported !== true || !deps.writeFile || !deps.mkdir) {
+        return { qualified: false, evidence: null };
+    }
+    const worktree = await (deps.mkdtemp ?? mkdtemp)(join((deps.tmpdir ?? tmpdir)(), "bridge-correction-hook-"));
+    try {
+        const bin = defaultResolveBinPath("worker-guard-hook-bin.js");
+        const installed = await adapter.denyEnforcement.value.provisionWorktreeDenyLayer({
+            worktreePath: worktree, baseBranch: "main", homedir: deps.homedir(),
+            workerBranch: "feature/probe", workerGuardHookBinPath: bin,
+            correctionIntentVersion: 1,
+        });
+        const settings = await deps.readFile(join(worktree, ".claude", "settings.local.json"));
+        const hookInstalled = installed.ok && settings.includes(bin) &&
+            settings.includes("--correction-intent-version 1") && settings.includes("PreToolUse");
+        const nestedDenial = hookInstalled && probeHook(worktree, bin);
+        return {
+            qualified: hookInstalled && nestedDenial,
+            evidence: {
+                version: 1, hook_installed: hookInstalled, nested_denial: nestedDenial,
+                fixture_id: CORRECTION_HOOK_FIXTURE_ID,
+                runtime: `${adapter.identity.adapterId}:${process.version}`,
+            },
+        };
+    }
+    catch {
+        return { qualified: false, evidence: null };
+    }
+    finally {
+        if (deps.rmRecursive)
+            await deps.rmRecursive(worktree);
+        else
+            await rm(worktree, { recursive: true, force: true });
+    }
+}
 /**
  * Collect the executor preflight report. Populates the manifest fields and
  * accumulates fatal findings — the runner refuses to claim when any exist.
@@ -176,7 +264,15 @@ export async function collectExecutorPreflight(options, deps, seams = {}) {
             // preflight's own injected `readFile` keeps the inspection hermetic in
             // tests and read-only in production — the adapter never opens a file
             // handle this module did not hand it.
-            claude: { readFile: deps.readFile },
+            claude: {
+                readFile: deps.readFile,
+                ...(deps.writeFile && deps.mkdir ? {
+                    denyProvisioningDeps: {
+                        readFile: deps.readFile, writeFile: deps.writeFile,
+                        mkdir: deps.mkdir, homedir: deps.homedir,
+                    },
+                } : {}),
+            },
         }));
     const resolution = resolveAdapter(agentId);
     if (!resolution.supported) {
@@ -341,8 +437,11 @@ export async function collectExecutorPreflight(options, deps, seams = {}) {
             if (denyCapability?.supported !== true) {
                 throw new Error("adapter declares no deny-enforcement capability");
             }
+            // The probe gets a worker-shaped environment so a nested-session variable in
+            // the executor's own process cannot change its verdict (BAPI-1386).
             const verdict = await denyCapability.value.probeEnforcement({
                 timeoutMs: resolveDenyProbeTimeoutMs(deps.env),
+                env: buildHeadlessAgentEnv(deps.env),
             });
             deny = {
                 enforced: verdict.enforced,
@@ -416,10 +515,32 @@ export async function collectExecutorPreflight(options, deps, seams = {}) {
     if (!completion.qualified && completion.refusal !== null) {
         warnings.push(`completion evidence not advertised: ${completion.refusal}`);
     }
+    // One notice per qualifying collection, built only from validated fields: the
+    // adapter id the predicate matched, the normalized version, and a closed platform id.
+    const notices = [];
+    if (completion.qualified && completion.runtime !== null) {
+        notices.push(`completion evidence advertised: ${completion.runtime.adapter} ` +
+            `${completion.runtime.cli_version} ${completion.runtime.platform}`);
+    }
+    let correction = {
+        qualified: false, evidence: null,
+    };
+    if (fatalFindings.length === 0) {
+        try {
+            correction = await qualifyCorrectionIntentRuntime(adapter, deps);
+        }
+        catch {
+            correction = { qualified: false, evidence: null };
+        }
+    }
+    if (!correction.qualified) {
+        warnings.push("correction intent not advertised: installed nested hook unverified");
+    }
     return {
         ok: fatalFindings.length === 0,
         fatalFindings,
         warnings,
+        notices,
         agentVersion,
         wtVersion,
         diskFreeGb,
@@ -429,6 +550,8 @@ export async function collectExecutorPreflight(options, deps, seams = {}) {
         completionEvidenceQualified: completion.qualified,
         completionEvidenceRefusal: completion.refusal,
         completionRuntime: completion.runtime,
+        correctionIntentQualified: correction.qualified,
+        correctionQualificationEvidence: correction.evidence,
     };
 }
 /**
@@ -490,6 +613,9 @@ export function buildClaimManifest(report, options, freeSlots) {
                 ? [COMPLETION_EVIDENCE_CAPABILITY, REQUIRED_VERIFICATION_CAPABILITY]
                 : []),
             FOCUSED_REBASE_CAPABILITY,
+            SCOPE_WAIT_CAPABILITY,
+            ...(report.correctionIntentQualified === true ? [CORRECTION_INTENT_CAPABILITY] : []),
+            ...(report.correctionIntentQualified === true ? ["ci_evidence.v1"] : []),
         ],
     };
 }

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/required-work-ledger.js

@@ -877,6 +877,10 @@ export function createRequiredWorkLedger(init) {
         const readyToClose = resultsSeen > 0 && latestIsResult && !turnOpen && liveRequired.length === 0 && snap.required.length === 0;
         return { readyToClose, liveRequired, liveOptional, activitySeq, latestIsResult };
     };
+    // One predicate for "a required task is still pending", shared by the envelope
+    // and the observe-only query so the two cannot drift apart.
+    const hasPendingRequiredWork = () => effectiveTasks().some(({ o, state }) => o.required && state === "pending");
+    const observeLiveRequiredWork = () => hasPendingRequiredWork() ? "live_required_work" : null;
     const buildEnvelope = (facts) => {
         const reasons = new Set(insufficient);
         if (!lifecycleSupported || !runtimeMatchesSupported(facts.runtime))
@@ -897,7 +901,7 @@ export function createRequiredWorkLedger(init) {
             reasons.add("forced_kill_no_cli_teardown");
         const effective = effectiveTasks();
         // R6: a required task with no terminal after the stream ended is missing evidence.
-        if (effective.some(({ o, state }) => o.required && state === "pending"))
+        if (hasPendingRequiredWork())
             reasons.add("live_required_work");
         // R6b: a stale snapshot, or a snapshot-only task nothing ever explained.
         const snap = liveSnapshotIds();
@@ -993,6 +997,7 @@ export function createRequiredWorkLedger(init) {
         recordDeclarationRefused: () => {
             insufficient.add("declaration_refused");
         },
+        observeLiveRequiredWork,
         buildEnvelope,
     };
 }

package/build/executor/resume-pre-spawn.js

@@ -149,6 +149,8 @@ export function fillResumePromptPlaceholders(template, gitLog, gitDiff) {
 // ---------------------------------------------------------------------------
 /** The deterministic WIP checkpoint message for a continuation. */
 export const CONTINUATION_WIP_COMMIT_MESSAGE = "wip: auto-checkpoint before continuation";
+/** BAPI-1367: the WIP checkpoint message when a retry resumes its prior attempt's work. */
+export const PRIOR_ATTEMPT_WIP_COMMIT_MESSAGE = "wip: auto-checkpoint before retry resume";
 const FULL_SHA = /^[0-9a-f]{40}$/;
 /** Read the continuation binding from a claimed job's payload (pure). */
 export function readContinuationBinding(job) {

package/build/executor/runner.js

@@ -70,7 +70,7 @@ export function formatDispatcherUnavailableDiagnostic(liveness) {
     return (`executor: no fresh reconciler/dispatcher heartbeat is available ` +
         `(reconciler_liveness=${liveness}); the dispatcher may not be running. ` +
         "Check DISABLE_SCHEDULER and GET /automation/health; see " +
-        "docs/claude/epic-implementer-v2-operator-runbook.md. Continuing to poll.");
+        "docs/epic-implementer/operator-runbook.md. Continuing to poll.");
 }
 /** The recovery diagnostic, emitted once when an absent dispatcher comes back. */
 export function formatDispatcherRecoveredDiagnostic() {
@@ -94,7 +94,8 @@ export const PROCESS_HEARTBEAT_INTERVAL_MS = 60_000;
 /** Delivery-failure diagnostic. Bounded, credential-free, stderr-only. */
 export function formatProcessHeartbeatFailureDiagnostic() {
     return ("executor: process-heartbeat delivery is failing; the server may report this " +
-        "executor as stale. Claiming and running jobs are unaffected.");
+        "executor as stale. If the server is unreachable, job heartbeats and claims " +
+        "can fail too, and a running job can lose its lease.");
 }
 /** Emitted once when delivery starts working again. */
 export function formatProcessHeartbeatRecoveredDiagnostic() {
@@ -151,6 +152,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 +560,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 +593,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 +795,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
@@ -796,6 +820,11 @@ export async function runExecutor(options, deps, httpClient, seams = {}) {
             for (const warning of report.warnings) {
                 deps.errorLog(`executor preflight warning: ${warning}`);
             }
+            // BAPI-1386: informational lines (the completion-evidence advertisement) go to
+            // stderr like every other diagnostic here, never stdout.
+            for (const notice of report.notices ?? []) {
+                deps.errorLog(`executor preflight: ${notice}`);
+            }
             if (!report.ok) {
                 deps.errorLog(`executor preflight refused claiming: ${report.fatalFindings.join("; ")}`);
             }

package/build/executor/service-unit.js

@@ -929,7 +929,8 @@ export function resolvePackagedExecutorInvocation(deps) {
 /** User-facing usage for `executor install-service`. */
 export function getExecutorInstallServiceUsage() {
     return [
-        "Usage: mcp-server executor install-service --executor-id <id> --repo <name> [--repo <name> ...] [options]",
+        "Usage: mcp-server executor install-service --executor-id <id> --repo <name> [--repo <name> ...]",
+        "                                           (--epic-run-id <id> | --repo-wide) [options]",
         "",
         "The FILE-GENERATION LEG of durable-host mode. It writes one unit and stops there.",
         "For the supported composed bring-up — planning, consented write, consented start,",
@@ -947,6 +948,11 @@ export function getExecutorInstallServiceUsage() {
         "                                needs a durable identity, so the foreground",
         "                                <hostname>-<pid> default is never used here.",
         "  --repo <name>                 Repo to serve (repeatable; --repos=a,b also works).",
+        "  --epic-run-id <id>            Claim scope: dedicate the unit to an epic run",
+        "                                (repeatable). Or:",
+        "  --repo-wide                   Claim scope: claim from every authorized repo,",
+        "                                unscoped by run. Exactly one of the two is required;",
+        "                                the executor refuses to start without one.",
         "  --base-url <url>              Bridge API endpoint, or set BAPI_BASE_URL.",
         "                                There is NO production default.",
         "",

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;
 /**