@bridge_gpt/mcp-server 0.2.16 → 0.2.18

package/build/conductor/bridge-api-client.js

@@ -74,16 +74,174 @@ export function buildConductorJiraUrl(baseUrl, apiPath, params = {}) {
     }
     return url.toString();
 }
-/** Sanitized HTTP error for conductor Bridge API calls — never leaks secrets. */
+const CONDUCTOR_BRIDGE_API_ERROR_KINDS = [
+    "invalid-input",
+    "network",
+    "timeout",
+    "unauthorized",
+    "server",
+    "http",
+];
+/** Max length of the sanitized body preview embedded in error diagnostics. */
+const CONDUCTOR_ERROR_PREVIEW_MAX = 200;
+/**
+ * Redact obvious secret-shaped tokens from a diagnostic preview string so a
+ * backend message that happens to echo a token/header never reaches a log line.
+ */
+function redactErrorPreview(text) {
+    return text
+        .replace(/sk-[A-Za-z0-9_-]{8,}/g, "[REDACTED]")
+        .replace(/(Bearer|X-API-Key|api[_-]?key)\b\s*[:=]?\s*\S+/gi, "$1 [REDACTED]");
+}
+/** Collapse whitespace, redact secrets, and bound a string to the preview cap. */
+function boundedErrorPreview(text) {
+    const redacted = redactErrorPreview(text).replace(/\s+/g, " ").trim();
+    return redacted.length > CONDUCTOR_ERROR_PREVIEW_MAX
+        ? `${redacted.slice(0, CONDUCTOR_ERROR_PREVIEW_MAX)}…`
+        : redacted;
+}
+/**
+ * Extract sanitized diagnostics from a parsed backend error body. Recognizes the
+ * FastAPI/backend shapes `{ detail: { error_code, message } }`,
+ * `{ detail: "..." }`, and `{ error_code, message }`; any other shape yields a
+ * bounded stringified preview. Never throws and never returns raw/unbounded text.
+ */
+export function extractSanitizedErrorDiagnostics(body) {
+    if (typeof body === "string") {
+        const trimmed = body.trim();
+        return trimmed ? { bodyPreview: boundedErrorPreview(trimmed) } : {};
+    }
+    if (!body || typeof body !== "object") {
+        return {};
+    }
+    const record = body;
+    const detail = record["detail"];
+    let errorCode;
+    let message;
+    if (detail && typeof detail === "object") {
+        const d = detail;
+        if (typeof d["error_code"] === "string")
+            errorCode = d["error_code"];
+        if (typeof d["message"] === "string")
+            message = d["message"];
+    }
+    else if (typeof detail === "string") {
+        message = detail;
+    }
+    if (!errorCode && typeof record["error_code"] === "string") {
+        errorCode = record["error_code"];
+    }
+    if (!message && typeof record["message"] === "string") {
+        message = record["message"];
+    }
+    const diagnostics = {};
+    if (errorCode)
+        diagnostics.errorCode = boundedErrorPreview(errorCode);
+    if (message)
+        diagnostics.bodyPreview = boundedErrorPreview(message);
+    return diagnostics;
+}
+/** Redact exact secret substrings (e.g. the API key from the request headers). */
+function redactDiagnosticValues(diagnostics, secrets) {
+    const scrub = (text) => {
+        let out = text;
+        for (const secret of secrets) {
+            if (secret && secret.length >= 4)
+                out = out.split(secret).join("[REDACTED]");
+        }
+        return out;
+    };
+    const out = {};
+    if (diagnostics.errorCode)
+        out.errorCode = scrub(diagnostics.errorCode);
+    if (diagnostics.bodyPreview)
+        out.bodyPreview = scrub(diagnostics.bodyPreview);
+    return out;
+}
+/**
+ * Best-effort read of a non-2xx response body into sanitized diagnostics. Never
+ * throws — a missing/invalid/non-JSON body simply yields `{}`. Any auth-header
+ * values in `headers` (e.g. `X-API-Key`) are additionally redacted from the
+ * preview so a body that echoes the credential can never surface it.
+ */
+async function readSanitizedErrorDiagnostics(resp, headers = {}) {
+    try {
+        const diagnostics = extractSanitizedErrorDiagnostics(await resp.json());
+        const secrets = Object.entries(headers)
+            .filter(([k]) => /key|authorization|token/i.test(k))
+            .map(([, v]) => v);
+        return redactDiagnosticValues(diagnostics, secrets);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Sanitized HTTP error for conductor Bridge API calls — never leaks secrets.
+ *
+ * Construction is backward-compatible in two forms:
+ *   - `new ConductorBridgeApiError(kind, status?, diagnostics?)` — the canonical
+ *     form; builds a message from the coarse kind plus optional HTTP status,
+ *     backend `error_code`, and a bounded secret-redacted message preview.
+ *   - `new ConductorBridgeApiError("some legacy message")` — a bare message
+ *     string (not one of the known kinds) is preserved verbatim as the error
+ *     message, with `kind` defaulting to `"http"` and no diagnostic fields set.
+ */
 export class ConductorBridgeApiError extends Error {
     kind;
     status;
-    constructor(kind, status) {
-        super(`Conductor Bridge API request failed (${kind}${typeof status === "number" ? `, status ${status}` : ""})`);
+    errorCode;
+    bodyPreview;
+    constructor(kindOrMessage, status, diagnostics) {
+        const isKnownKind = CONDUCTOR_BRIDGE_API_ERROR_KINDS.includes(kindOrMessage);
+        const errorCode = diagnostics?.errorCode;
+        const bodyPreview = diagnostics?.bodyPreview;
+        if (isKnownKind) {
+            const parts = [
+                `Conductor Bridge API request failed (${kindOrMessage}${typeof status === "number" ? `, status ${status}` : ""})`,
+            ];
+            if (errorCode)
+                parts.push(`code=${errorCode}`);
+            if (bodyPreview)
+                parts.push(bodyPreview);
+            super(parts.join(": "));
+        }
+        else {
+            // Legacy/backward-compatible bare-message construction.
+            super(kindOrMessage);
+        }
         this.name = "ConductorBridgeApiError";
-        this.kind = kind;
-        this.status = status;
+        this.kind = (isKnownKind ? kindOrMessage : "http");
+        if (typeof status === "number")
+            this.status = status;
+        if (errorCode)
+            this.errorCode = errorCode;
+        if (bodyPreview)
+            this.bodyPreview = bodyPreview;
+    }
+}
+/**
+ * Build a bounded, secret-free diagnostic string from an unknown thrown error
+ * for tick warnings/logs. For a {@link ConductorBridgeApiError} it surfaces the
+ * coarse kind, HTTP status, backend error code, and sanitized message preview
+ * (never a stack, raw body, or secret). For any other Error it returns the
+ * constructor name; non-Errors fall back to `fallback`.
+ */
+export function safeDiagnosticMessage(err, fallback) {
+    if (err instanceof ConductorBridgeApiError) {
+        const parts = [`kind=${err.kind}`];
+        if (typeof err.status === "number")
+            parts.push(`status=${err.status}`);
+        if (err.errorCode)
+            parts.push(`code=${err.errorCode}`);
+        if (err.bodyPreview)
+            parts.push(err.bodyPreview);
+        return parts.join(" ");
+    }
+    if (err instanceof Error) {
+        return err.constructor.name;
     }
+    return fallback;
 }
 /** GET auth headers. The API key travels ONLY in a header, never in the URL. */
 function conductorGetHeaders(access) {
@@ -108,13 +266,14 @@ export async function fetchConductorJsonWithTimeout(url, headers, timeoutMs, fet
             throw new ConductorBridgeApiError(controller.signal.aborted ? "timeout" : "network");
         }
         if (!resp.ok) {
+            const diagnostics = await readSanitizedErrorDiagnostics(resp, headers);
             if (resp.status === 401 || resp.status === 403) {
-                throw new ConductorBridgeApiError("unauthorized", resp.status);
+                throw new ConductorBridgeApiError("unauthorized", resp.status, diagnostics);
             }
             if (resp.status >= 500) {
-                throw new ConductorBridgeApiError("server", resp.status);
+                throw new ConductorBridgeApiError("server", resp.status, diagnostics);
             }
-            throw new ConductorBridgeApiError("http", resp.status);
+            throw new ConductorBridgeApiError("http", resp.status, diagnostics);
         }
         try {
             return await resp.json();
@@ -252,13 +411,14 @@ async function fetchConductorJsonWithMethodAndTimeout(method, url, headers, body
             throw new ConductorBridgeApiError(controller.signal.aborted ? "timeout" : "network");
         }
         if (!resp.ok) {
+            const diagnostics = await readSanitizedErrorDiagnostics(resp, headers);
             if (resp.status === 401 || resp.status === 403) {
-                throw new ConductorBridgeApiError("unauthorized", resp.status);
+                throw new ConductorBridgeApiError("unauthorized", resp.status, diagnostics);
             }
             if (resp.status >= 500) {
-                throw new ConductorBridgeApiError("server", resp.status);
+                throw new ConductorBridgeApiError("server", resp.status, diagnostics);
             }
-            throw new ConductorBridgeApiError("http", resp.status);
+            throw new ConductorBridgeApiError("http", resp.status, diagnostics);
         }
         try {
             return await resp.json();
@@ -508,6 +668,26 @@ export async function fetchActiveEpicRuns(access, fetchImpl = globalThis.fetch)
     }
     return [];
 }
+/**
+ * PATCH `/jira/epic-runs/runs/{identifier}` to transition an epic run's
+ * lifecycle status. Drives the same backend `update_epic_run` CAS path the
+ * manual close-out used: passing `expectedStatus` makes the transition a safe
+ * compare-and-swap (a stale status surfaces as a sanitized
+ * {@link ConductorBridgeApiError} — HTTP 400 VALIDATION — rather than clobbering
+ * a concurrent terminal transition). Prefer passing the concrete run UUID as
+ * `epicKey` when the runtime has it. Returns the normalized {@link EpicRunRecord}.
+ */
+export async function updateEpicRunStatus(access, request, fetchImpl = globalThis.fetch) {
+    requireNonEmptyString(request.epicKey);
+    const url = buildConductorJiraUrl(access.baseUrl, epicRunApiPath(request.epicKey));
+    const body = JSON.stringify({
+        repo_name: access.repoName,
+        status: request.status,
+        ...(request.expectedStatus ? { expected_status: request.expectedStatus } : {}),
+    });
+    const parsed = await fetchConductorJsonPatchWithTimeout(url, conductorPostHeaders(access), body, CONDUCTOR_FETCH_TIMEOUT_MS, fetchImpl);
+    return parsed;
+}
 // ---------------------------------------------------------------------------
 // Per-ticket CAS status advancement
 // ---------------------------------------------------------------------------

package/build/conductor/claude-hook.js

@@ -3,8 +3,11 @@
  *
  * This is a dependency-light command-hook entrypoint registered into a spawned
  * Claude worker's `.claude/settings.local.json` by `start-tickets`. Claude Code
- * invokes it for lifecycle events (SessionStart, Stop, SubagentStop,
- * Notification, optionally PreToolUse), passing the native hook JSON on stdin.
+ * invokes it for lifecycle events (SessionStart, SessionEnd, Notification,
+ * optionally PreToolUse), passing the native hook JSON on stdin. `Stop` and
+ * `SubagentStop` are intentionally NOT registered/emitted: they are per-turn /
+ * per-subagent events, not session-terminal (BAPI-507 N-1); only `SessionEnd`
+ * is a true session end and maps to `run.stopped`.
  * The writer:
  *
  *   1. reads + parses the native Claude hook payload from stdin,
@@ -50,15 +53,30 @@ export function resolveClaudeHookEventName(payload) {
 /**
  * Map a Claude lifecycle event name to a canonical conductor semantic type.
  * Unknown events map to `null` (the caller then skips emission).
+ *
+ * BAPI-507 (N-1): `Stop` and `SubagentStop` are intentionally ignored (→ null).
+ * Claude Code fires `Stop` at the end of EACH assistant turn and `SubagentStop`
+ * at each Task-subagent completion — NOT only at session termination. Mapping
+ * them to `run.stopped` folded a ticket to `ready_for_review` from minutes into
+ * the session, while the worker was still implementing with no branch pushed and
+ * no PR. The only true session-terminal event is `SessionEnd`, which maps to
+ * `run.stopped`. (Verified against the Claude Code lifecycle-hook contract:
+ * `SessionEnd` fires once when the session ends; `Stop`/`SubagentStop` are
+ * per-turn/per-subagent.)
  */
 export function mapClaudeHookEventToSemanticType(eventName) {
     switch (eventName) {
         case "SessionStart":
             return "run.started";
-        case "Stop":
+        case "SessionEnd":
+            // The one true session-terminal event: the worker's session has ended.
             return "run.stopped";
+        case "Stop":
+            // Per-turn boundary, NOT session end — deliberately ignored (BAPI-507 N-1).
+            return null;
         case "SubagentStop":
-            return "run.stopped";
+            // Per-subagent completion, NOT session end — deliberately ignored.
+            return null;
         case "Notification":
             return "agent.notification";
         case "PreToolUse":

package/build/conductor/cli.js

@@ -18,6 +18,7 @@ import { ConductorValidationError, toConductorErrorEnvelope } from "./errors.js"
 import { emitConductorEvent, purgeConductorLedger, sendWorkerMessage, checkWorkerMessages, } from "./store.js";
 import { SEMANTIC_EVENT_TYPES } from "./taxonomy.js";
 import { installConductorGitHooks } from "./git-hooks.js";
+import { runFileScopeGuardCli } from "./file-scope-guard.js";
 import { runPostCommitHookProducer, runReferenceTransactionHookProducer } from "./git-producer.js";
 import { buildConductorDoctorReport, formatConductorDoctorReport } from "./doctor.js";
 import { resolveSupervisorConfig } from "./supervisor-config.js";
@@ -46,14 +47,14 @@ export function getConductorUsage() {
         "  git-hook post-commit Run the post-commit producer (invoked by the installed hook)",
         "  git-hook reference-transaction --phase <p> --stdin-file <f>",
         "                       Run the reference-transaction producer (invoked by the hook)",
+        "  file-scope-guard     Warn-only: compare the branch diff against the declared",
+        "                       touched-file set (always exits 0; never blocks a PR)",
         "",
         "supervise options:",
         "  --run-id <id>             Run/session identifier to supervise (required)",
         "  --wake-interval-ms <n>    Deterministic event-poll cadence (clamped 30000..60000)",
         "  --global-timeout-ms <n>   Total wall-clock ceiling for the run",
-        "  --llm-budget-calls <n>    Max LLM judgment calls per run before degraded-only mode",
         "  --escalation-cooldown-ms <n>  Min gap between escalations for the same worker+reason",
-        "  --no-llm                  Deterministic-only mode (never call the LLM judgment boundary)",
         "",
         "install-git-hooks notes:",
         "  Hooks are LOCAL, unversioned, opportunistic, and bypassable. Missing hooks are a",
@@ -151,6 +152,7 @@ const VALID_COMMANDS = new Set([
     "purge",
     "install-git-hooks",
     "git-hook",
+    "file-scope-guard",
 ]);
 /**
  * Parse the top-level conductor argv into a subcommand (without a CLI
@@ -925,10 +927,9 @@ const SUPERVISE_VALUE_FLAGS = new Set([
     "--run-id",
     "--wake-interval-ms",
     "--global-timeout-ms",
-    "--llm-budget-calls",
     "--escalation-cooldown-ms",
 ]);
-const SUPERVISE_BOOL_FLAGS = new Set(["--no-llm", "--help"]);
+const SUPERVISE_BOOL_FLAGS = new Set(["--help"]);
 /** Parse a required positive-integer flag, raising a sanitized error otherwise. */
 function parsePositiveIntFlag(values, flag) {
     const raw = values.get(flag);
@@ -946,9 +947,8 @@ function parsePositiveIntFlag(values, flag) {
 /**
  * Parse `supervise` flags. `--run-id` is required and must be non-empty /
  * non-whitespace. Numeric overrides are validated as non-negative integers (the
- * config resolver clamps them to safe bounds); `--no-llm` selects
- * deterministic-only mode. Malformed input raises a sanitized
- * {@link ConductorValidationError}.
+ * config resolver clamps them to safe bounds). Malformed input raises a
+ * sanitized {@link ConductorValidationError}.
  */
 export function parseSuperviseArgs(argv) {
     const { values, bools } = tokenizeFlags(argv, SUPERVISE_VALUE_FLAGS, SUPERVISE_BOOL_FLAGS);
@@ -966,14 +966,9 @@ export function parseSuperviseArgs(argv) {
     const globalTimeout = parsePositiveIntFlag(values, "--global-timeout-ms");
     if (globalTimeout !== undefined)
         overrides.global_timeout_ms = globalTimeout;
-    const llmCalls = parsePositiveIntFlag(values, "--llm-budget-calls");
-    if (llmCalls !== undefined)
-        overrides.llm_max_calls = llmCalls;
     const cooldown = parsePositiveIntFlag(values, "--escalation-cooldown-ms");
     if (cooldown !== undefined)
         overrides.escalation_cooldown_ms = cooldown;
-    if (bools.has("--no-llm"))
-        overrides.llm_enabled = false;
     return { runId: runIdRaw.trim(), overrides, help: false };
 }
 /**
@@ -990,7 +985,7 @@ export async function runSuperviseCommand(argv) {
     }
     const config = resolveSupervisorConfig(parsed.overrides);
     console.log(`[supervisor] starting run=${parsed.runId} wake=${config.wake_interval_ms}ms ` +
-        `global_timeout=${config.global_timeout_ms}ms llm=${config.llm_enabled ? `on(${config.llm_max_calls})` : "off"}`);
+        `global_timeout=${config.global_timeout_ms}ms`);
     const { runSupervisor } = await import("./supervisor-runtime.js");
     const result = await runSupervisor({ run_id: parsed.runId, config });
     return result.exit_code;
@@ -1056,6 +1051,9 @@ export async function runConductorCli(argv) {
                 return runInstallGitHooksCommand(parsed.argv);
             case "git-hook":
                 return await runGitHookCommand(parsed.argv);
+            case "file-scope-guard":
+                // BAPI-507 (N-2): warn-only worker file-scope guard. Always exits 0.
+                return runFileScopeGuardCli();
             default:
                 console.error('Error: Unknown command. Run "conductor --help" for usage.');
                 return 1;

package/build/conductor/done-gate.js

@@ -403,10 +403,15 @@ export function normalizeReviewSnapshot(raw) {
     const headSha = typeof detail.head_sha === "string" && detail.head_sha.trim().length > 0
         ? detail.head_sha.trim()
         : null;
+    // BAPI-493 (D-5): head-scope the dedupe hash so two otherwise-identical review
+    // snapshots observed on DIFFERENT PR heads hash differently (the producer dedupe
+    // dimension was not head-scoped before). Uses the already-normalized local
+    // `headSha` (trimmed string or null) so a missing head stays deterministic.
     const reviewStateHash = stableJsonHash({
         review_decision: reviewDecision,
         approvals,
         sticky_verdict: stickyVerdict,
+        head_sha: headSha,
     });
     return { review_decision: reviewDecision, approvals, sticky_verdict: stickyVerdict, head_sha: headSha, review_state_hash: reviewStateHash };
 }

package/build/conductor/epic-reconcile.js

@@ -19,6 +19,21 @@
  */
 import { computeReadySet, decideRemediation, DEFAULT_MAX_SPEC_REVIEW_ATTEMPTS } from "./epic-state.js";
 import { extractMergeActionIdentityFromGateEvent } from "./merge-ledger.js";
+/**
+ * Sanitize a thrown value into a single-line, bounded diagnostic string for a
+ * tick warning (BAPI-487 Requirement 2). Surfaces the real `err.message` (the
+ * remediation messages — `remediate: no PR binding for <KEY>`, `remediate: no
+ * head_sha for PR <N>` — are safe, secret-free text) instead of the opaque
+ * constructor name that hid the true failure for an entire smoke test. Collapses
+ * whitespace (defeating multiline log injection), caps length, and falls back to
+ * the constructor name for an empty message or `fallback` for a non-Error throw.
+ */
+export function safeDiagnosticMessage(err, fallback) {
+    const raw = err instanceof Error
+        ? (err.message.trim() || err.constructor.name)
+        : fallback;
+    return raw.replace(/\s+/g, " ").slice(0, 500);
+}
 // ---------------------------------------------------------------------------
 // reconcileEpic
 // ---------------------------------------------------------------------------
@@ -43,10 +58,23 @@ export async function reconcileEpic(access, observed, plan, deps, supervisorConf
         catch (err) {
             const safeMsg = err instanceof Error ? err.constructor.name : "cas error";
             result.warnings.push(`cas-error folding ${signal.signal_type} for ${signal.ticket_key}: ${safeMsg}`);
+            // BAPI-500: the fold CAS did not durably run, so any PREDICTED post-fold
+            // row version for this ticket is unconfirmed. Clear it so the same-pass
+            // remediation CAS falls back to the tick-start snapshot instead of trusting
+            // a snapshot+1 that was never written.
+            observed.ticket_post_fold_row_versions?.delete(signal.ticket_key);
             continue;
         }
         if (casResult.ok) {
             result.signals_folded += 1;
+            // BAPI-500: confirm the post-fold row version from the ACTUAL CAS response
+            // (never the tick-start snapshot or a re-derived `+ 1`), so a follow-on
+            // remediation CAS in this same pass CASes against the durable snapshot+1.
+            // Keyed per ticket — one status CAS per ticket per tick. Do NOT touch
+            // `observed.ticket_row_versions`; it stays the tick-start snapshot so
+            // callers can distinguish fallback values from same-pass post-fold values.
+            observed.ticket_post_fold_row_versions ??= new Map();
+            observed.ticket_post_fold_row_versions.set(signal.ticket_key, casResult.ticket_status.row_version);
             deps.log(`[epic-reconcile] folded ${signal.signal_type} for ${signal.ticket_key} → ${signal.next_status}`);
             // BAPI-442: fire teardown + Jira transition strictly after merge.succeeded
             // CAS → done. Both are fail-open: errors are logged and never abort the pass.
@@ -66,18 +94,25 @@ export async function reconcileEpic(access, observed, plan, deps, supervisorConf
             }
         }
         else {
-            // CAS conflict: another tick already advanced this ticket — non-fatal
+            // CAS conflict: another tick already advanced this ticket — non-fatal.
+            // BAPI-500: the predicted post-fold version is unconfirmed (the real row
+            // version is whatever the other writer left), so clear it and let the
+            // same-pass remediation CAS fall back to the tick-start snapshot.
+            observed.ticket_post_fold_row_versions?.delete(signal.ticket_key);
             result.warnings.push(`cas-conflict folding ${signal.signal_type} for ${signal.ticket_key}`);
         }
     }
-    // Step 1.5: Seed planned status rows for every plan node (idempotent — ON CONFLICT DO NOTHING)
+    // Step 1.5: Seed planned status rows for every plan node. Idempotent: the
+    // backend read-back no-ops a re-seed of an existing row (A6/BAPI-507), so a
+    // normal multi-tick run no longer produces per-node seed warnings. When a seed
+    // DOES fail, the warning carries safe backend diagnostics (status/code/message
+    // preview) rather than the opaque `ConductorBridgeApiError` constructor name.
     for (const ticket of plan.tickets) {
         try {
             await deps.seedTicketStatus(observed.epic_key, ticket.ticket_key, plan.plan_version);
         }
         catch (err) {
-            const safeMsg = err instanceof Error ? err.constructor.name : "seed error";
-            result.warnings.push(`seed-error for ${ticket.ticket_key}: ${safeMsg}`);
+            result.warnings.push(`seed-error for ${ticket.ticket_key}: ${safeDiagnosticMessage(err, "seed error")}`);
         }
     }
     // Step 2: Compute the ready-set (pure — never calls LLM)
@@ -307,18 +342,30 @@ export async function reconcileEpic(access, observed, plan, deps, supervisorConf
                 }
                 // The attempt being recorded is the next one (1-based).
                 const attempt = counters.attempts + 1;
-                const attemptKind = decision;
                 // The folding reason frames the nudge (message type + digest). Default to
                 // the review path when the ledger no longer carries the blocking event.
                 // spec_review.changes_requested is impossible here (skipped above) but
                 // narrow explicitly so the remediation seams keep their tight reason type.
+                // BAPI-494: `merge.conflict` is normalized as a first-class reason.
                 const blockedReason = observed.ticket_blocked_reasons?.get(ticketKey);
-                const reason = blockedReason === "ci.failed" ? "ci.failed" : "review.changes_requested";
+                const normalizedReason = blockedReason === "ci.failed"
+                    ? "ci.failed"
+                    : blockedReason === "merge.conflict"
+                        ? "merge.conflict"
+                        : "review.changes_requested";
+                // BAPI-494: a conflict ALWAYS redispatches a resume-mode worker (it needs a
+                // working tree to rebase + resolve, not a message), regardless of whether the
+                // original worker is still alive — so the alive-worker nudge is forced to a
+                // redispatch here. Budget-exhaustion escalation already fired above, so at this
+                // point the budget is not exhausted. CI/review keep their liveness-driven
+                // nudge-vs-redispatch decision unchanged.
+                const attemptKind = normalizedReason === "merge.conflict" ? "redispatch" : decision;
                 // A nudge needs a worker to address it to. The liveness scan already
                 // resolved the worker id from the same heartbeat that proved the worker
                 // alive; if it is missing we cannot relay, so skip BEFORE recording an
                 // attempt — otherwise the CAS would burn a budget unit with nothing sent.
-                if (decision === "nudge" && !liveness.workerId) {
+                // A redispatch (including every conflict) needs no worker id, so it is exempt.
+                if (attemptKind === "nudge" && !liveness.workerId) {
                     result.warnings.push(`remediation nudge skipped for ${ticketKey}: alive worker has no worker_id`);
                     continue;
                 }
@@ -329,10 +376,10 @@ export async function reconcileEpic(access, observed, plan, deps, supervisorConf
                 // the pass still runs (crash-replay safe).
                 let casOutcome;
                 try {
-                    casOutcome = await remediateCas(observed.epic_key, ticketKey, attemptKind, reason);
+                    casOutcome = await remediateCas(observed.epic_key, ticketKey, attemptKind, normalizedReason);
                 }
                 catch (err) {
-                    const safeMsg = err instanceof Error ? err.constructor.name : "remediate error";
+                    const safeMsg = safeDiagnosticMessage(err, "remediate error");
                     result.warnings.push(`remediate-cas-failed for ${ticketKey} (${attemptKind}): ${safeMsg}`);
                     continue;
                 }
@@ -342,16 +389,18 @@ export async function reconcileEpic(access, observed, plan, deps, supervisorConf
                     result.warnings.push(`remediation replay swallowed for ${ticketKey} (${attemptKind})`);
                     continue;
                 }
-                if (decision === "nudge") {
-                    await sendNudge(observed.epic_key, ticketKey, attempt, casOutcome.reviewDigest, casOutcome.truncated, reason, liveness.workerId);
+                if (attemptKind === "nudge") {
+                    // Nudge is CI/review only (conflict never nudges), so narrow the reason.
+                    const nudgeReason = normalizedReason === "ci.failed" ? "ci.failed" : "review.changes_requested";
+                    await sendNudge(observed.epic_key, ticketKey, attempt, casOutcome.reviewDigest, casOutcome.truncated, nudgeReason, liveness.workerId);
                 }
                 else {
                     await resumeDispatch(observed.epic_key, ticketKey, attempt);
                 }
-                deps.log(`[epic-reconcile] remediation ${decision} ${ticketKey} attempt=${attempt}`);
+                deps.log(`[epic-reconcile] remediation ${attemptKind} ${ticketKey} attempt=${attempt} reason=${normalizedReason}`);
             }
             catch (err) {
-                const safeMsg = err instanceof Error ? err.constructor.name : "remediation error";
+                const safeMsg = safeDiagnosticMessage(err, "remediation error");
                 result.warnings.push(`remediation-error for ${ticketKey}: ${safeMsg}`);
             }
         }