@bridge_gpt/mcp-server 0.2.16 → 0.2.18

package/build/conductor-bin.js

@@ -95,6 +95,21 @@ var init_redaction = __esm({
 });
 
 // src/conductor/errors.ts
+function redactDiagnostic(value) {
+  return redactSecretString(value).replace(
+    /(\/(?:Users|home)\/)[^/\s:]+/g,
+    "$1[REDACTED_USER]"
+  );
+}
+function logInternalErrorDiagnostic(error) {
+  try {
+    const name = error instanceof Error ? error.name : typeof error;
+    const rawMessage = error instanceof Error ? error.message : String(error);
+    const message = redactDiagnostic(rawMessage).replace(/\s*\n\s*/g, " ");
+    console.error(`[conductor:INTERNAL_ERROR] [${name}] ${message}`);
+  } catch {
+  }
+}
 function isSqliteBusyError(error) {
   if (!error || typeof error !== "object") return false;
   const code = error.code;
@@ -128,6 +143,7 @@ function toConductorErrorEnvelope(error) {
       message: "Conductor ledger is busy; retry shortly."
     };
   }
+  logInternalErrorDiagnostic(error);
   return {
     error: "INTERNAL_ERROR",
     status: 500,
@@ -186,6 +202,10 @@ var init_taxonomy = __esm({
       "merge.attempted",
       "merge.succeeded",
       "merge.failed",
+      // BAPI-494: a PR that cannot be merged (CONFLICTING/DIRTY). A terminal,
+      // head-scoped blocking signal that folds to `blocked` and routes through the
+      // BAPI-441 remediation pass as a resume-mode redispatch.
+      "merge.conflict",
       "merge.pending_approval",
       // BAPI-440 PR review-state telemetry event types.
       "review.passed",
@@ -1559,6 +1579,13 @@ function normalizePrNumber(value) {
   if (value <= 0) return null;
   return value;
 }
+function normalizeCheckName(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  if (CONTROL_CHAR_RE.test(trimmed)) return null;
+  return trimmed;
+}
 function canonicalize(value) {
   if (Array.isArray(value)) {
     return value.map((item) => canonicalize(item));
@@ -1579,16 +1606,275 @@ function stableJsonHash(value) {
   const json = JSON.stringify(canonical) ?? "null";
   return createHash("sha256").update(json).digest("hex");
 }
-var GIT_HOOK_PRODUCER, CONTROL_CHAR_RE, SHA_RE;
+var GIT_CI_PRODUCER, GIT_HOOK_PRODUCER, REQUIRED_CI_CHECKS_GREEN, REVIEW_STATE, DEFAULT_GATE_NAME, REVIEW_PASSED, REVIEW_CHANGES_REQUESTED, CONTROL_CHAR_RE, SHA_RE;
 var init_git_ci_types = __esm({
   "src/conductor/git-ci-types.ts"() {
     "use strict";
+    GIT_CI_PRODUCER = "git-pr-ci-producer";
     GIT_HOOK_PRODUCER = "git-hook";
+    REQUIRED_CI_CHECKS_GREEN = "required_ci_checks_green";
+    REVIEW_STATE = "review_state";
+    DEFAULT_GATE_NAME = "done";
+    REVIEW_PASSED = "review.passed";
+    REVIEW_CHANGES_REQUESTED = "review.changes_requested";
     CONTROL_CHAR_RE = /[\u0000-\u001F\u007F]/;
     SHA_RE = /^[0-9a-f]{40}$|^[0-9a-f]{64}$/;
   }
 });
 
+// src/conductor/git-inspection.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { basename } from "node:path";
+function runGitCommand(args, options = {}) {
+  try {
+    const stdout = execFileSync2("git", args, {
+      cwd: options.cwd,
+      timeout: options.timeoutMs ?? GIT_COMMAND_TIMEOUT_MS,
+      encoding: "utf-8",
+      maxBuffer: GIT_COMMAND_MAX_BUFFER,
+      // Capture stdout only; ignore stdin and stderr so raw error text (which may
+      // include credentials) is never read back. `shell` defaults to false.
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return { ok: true, stdout: typeof stdout === "string" ? stdout : "" };
+  } catch {
+    return { ok: false, stdout: "" };
+  }
+}
+function firstLine(result) {
+  if (!result.ok) return null;
+  const trimmed = result.stdout.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function sanitizeGitRemoteUrl(url) {
+  if (typeof url !== "string") return null;
+  const trimmed = url.trim();
+  if (trimmed.length === 0) return null;
+  if (/^https?:\/\//i.test(trimmed)) {
+    try {
+      const parsed = new URL(trimmed);
+      parsed.username = "";
+      parsed.password = "";
+      return parsed.toString();
+    } catch {
+      return trimmed.replace(/^(https?:\/\/)[^/@]*@/i, "$1");
+    }
+  }
+  return trimmed;
+}
+function getGitWorktreeContext(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const env = options.env ?? process.env;
+  const topLevel = firstLine(runGitCommand(["rev-parse", "--show-toplevel"], { cwd }));
+  const isWorktree = topLevel !== null;
+  const worktreePath = topLevel ?? cwd;
+  const gitCommonDir = firstLine(runGitCommand(["rev-parse", "--git-common-dir"], { cwd }));
+  const branchRaw = firstLine(runGitCommand(["rev-parse", "--abbrev-ref", "HEAD"], { cwd }));
+  const branch = branchRaw === null || branchRaw === "HEAD" ? null : branchRaw;
+  const headSha = normalizeSha(firstLine(runGitCommand(["rev-parse", "HEAD"], { cwd })) ?? "");
+  const remoteOrigin = sanitizeGitRemoteUrl(
+    firstLine(runGitCommand(["config", "--get", "remote.origin.url"], { cwd })) ?? ""
+  );
+  const repo = normalizeRepoName(env.BAPI_CONDUCTOR_REPO_NAME) ?? normalizeRepoName(env.BAPI_REPO_NAME) ?? normalizeRepoName(basename(worktreePath)) ?? "unknown";
+  return {
+    repo,
+    worktree_path: worktreePath,
+    git_common_dir: gitCommonDir,
+    branch,
+    head_sha: headSha,
+    remote_origin: remoteOrigin,
+    is_worktree: isWorktree
+  };
+}
+function parseCoAuthoredByTrailers(message) {
+  if (typeof message !== "string" || message.length === 0) return [];
+  const out = [];
+  for (const line of message.split(/\r?\n/)) {
+    const match = CO_AUTHOR_RE.exec(line.trim());
+    if (match) {
+      out.push({ name: match[1].trim(), email: match[2].trim() });
+    }
+  }
+  return out;
+}
+function readHeadCommitMetadata(options = {}) {
+  const ref = options.ref ?? "HEAD";
+  const result = runGitCommand(["show", "-s", `--format=${COMMIT_FORMAT}`, ref], { cwd: options.cwd });
+  if (!result.ok) return null;
+  const fields = result.stdout.replace(/\n$/, "").split("");
+  if (fields.length < 10) return null;
+  const [sha, parentsRaw, authorName, authorEmail, committerName, committerEmail, authoredAt, committedAt, subject, body] = fields;
+  const parents = parentsRaw.trim().split(/\s+/).map((p) => normalizeSha(p)).filter((p) => p !== null);
+  const coAuthors = parseCoAuthoredByTrailers(body);
+  return {
+    sha: normalizeSha(sha),
+    parents,
+    author_name: authorName,
+    author_email: authorEmail,
+    committer_name: committerName,
+    committer_email: committerEmail,
+    authored_at: authoredAt,
+    committed_at: committedAt,
+    subject,
+    body,
+    co_authors: coAuthors,
+    attribution_source: coAuthors.length > 0 ? "co-authored-by-trailer" : "commit-author"
+  };
+}
+function parseReferenceTransactionUpdates(stdin) {
+  if (typeof stdin !== "string" || stdin.length === 0) return [];
+  const out = [];
+  for (const line of stdin.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    const parts = trimmed.split(/\s+/);
+    if (parts.length !== 3) continue;
+    const oldSha = normalizeSha(parts[0]);
+    const newSha = normalizeSha(parts[1]);
+    const ref = parts[2];
+    if (oldSha === null || newSha === null) continue;
+    if (ref.length === 0 || REF_CONTROL_CHAR_RE.test(ref)) continue;
+    out.push({ old_sha: oldSha, new_sha: newSha, ref });
+  }
+  return out;
+}
+var GIT_COMMAND_TIMEOUT_MS, GIT_COMMAND_MAX_BUFFER, CO_AUTHOR_RE, COMMIT_FORMAT, REF_CONTROL_CHAR_RE;
+var init_git_inspection = __esm({
+  "src/conductor/git-inspection.ts"() {
+    "use strict";
+    init_git_ci_types();
+    GIT_COMMAND_TIMEOUT_MS = 5e3;
+    GIT_COMMAND_MAX_BUFFER = 10 * 1024 * 1024;
+    CO_AUTHOR_RE = /^co-authored-by:\s*(.+?)\s*<([^<>@\s]+@[^<>\s]+)>\s*$/i;
+    COMMIT_FORMAT = "%H%x1f%P%x1f%an%x1f%ae%x1f%cn%x1f%ce%x1f%aI%x1f%cI%x1f%s%x1f%b";
+    REF_CONTROL_CHAR_RE = /[\u0000-\u001F\u007F]/;
+  }
+});
+
+// src/conductor/file-scope-guard.ts
+import { spawnSync } from "node:child_process";
+function normalizeRepoRelativePath(input) {
+  if (typeof input !== "string") return null;
+  const trimmed = input.trim();
+  if (trimmed.length === 0) return null;
+  if (trimmed.startsWith("/") || trimmed.startsWith("\\") || /^[A-Za-z]:[\\/]/.test(trimmed)) {
+    return null;
+  }
+  let p = trimmed.replace(/\\/g, "/");
+  if (p.startsWith("./")) p = p.slice(2);
+  const segments = p.split("/");
+  if (segments.some((s) => s === "..")) return null;
+  const cleaned = segments.filter((s) => s !== "" && s !== ".").join("/");
+  return cleaned.length > 0 ? cleaned : null;
+}
+function normalizeDeclaredTouchedFiles(list) {
+  if (!Array.isArray(list)) return [];
+  const out = /* @__PURE__ */ new Set();
+  for (const item of list) {
+    const norm = normalizeRepoRelativePath(item);
+    if (norm) out.add(norm);
+  }
+  return Array.from(out).sort();
+}
+function parseDeclaredTouchedFilesFromEnv(env = process.env) {
+  const raw = env[DECLARED_TOUCHED_FILES_ENV];
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    return { specified: false };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { specified: false };
+  }
+  if (!Array.isArray(parsed)) return { specified: false };
+  const files = normalizeDeclaredTouchedFiles(parsed);
+  if (files.length === 0) return { specified: false };
+  return { specified: true, files };
+}
+function collectBranchChangedFiles(opts = {}) {
+  const baseRef = opts.baseRef ?? FILE_SCOPE_GUARD_BASE_REF;
+  const spawn = opts.spawnSyncFn ?? defaultSpawnSync;
+  let result;
+  try {
+    result = spawn("git", ["diff", "--name-only", `${baseRef}...HEAD`], {
+      cwd: opts.cwd,
+      encoding: "utf-8",
+      shell: false
+    });
+  } catch {
+    return { ok: false, files: [] };
+  }
+  if (result.error || result.status !== 0) {
+    return { ok: false, files: [] };
+  }
+  const stdout = typeof result.stdout === "string" ? result.stdout : result.stdout?.toString("utf-8") ?? "";
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of stdout.split("\n")) {
+    const norm = normalizeRepoRelativePath(line);
+    if (norm && !seen.has(norm)) {
+      seen.add(norm);
+      files.push(norm);
+    }
+  }
+  return { ok: true, files };
+}
+function analyzeDiffScope(input) {
+  if (!input.declared.specified) {
+    return { checked: false, outOfScopeFiles: [], warning: null };
+  }
+  const declaredSet = new Set(input.declared.files);
+  const outOfScope = input.changedFiles.filter((f) => !declaredSet.has(f)).sort();
+  if (outOfScope.length === 0) {
+    return { checked: true, outOfScopeFiles: [], warning: null };
+  }
+  const ticket = input.ticketKey && input.ticketKey.trim().length > 0 ? input.ticketKey.trim() : "unknown-ticket";
+  const warning = `[file-scope-guard] ${ticket}: ${outOfScope.length} file(s) changed outside the declared touched-file set (${input.declared.files.length} declared): ${outOfScope.join(", ")}. Warn-only \u2014 PR creation continues.`;
+  return { checked: true, outOfScopeFiles: outOfScope, warning };
+}
+function runFileScopeGuardCli(deps = {}) {
+  const env = deps.env ?? process.env;
+  const writeOut = deps.writeOut ?? ((m) => process.stdout.write(`${m}
+`));
+  const writeErr = deps.writeErr ?? ((m) => process.stderr.write(`${m}
+`));
+  const ticketKey = env[FILE_SCOPE_GUARD_TICKET_KEY_ENV];
+  const declared = parseDeclaredTouchedFilesFromEnv(env);
+  if (!declared.specified) {
+    return 0;
+  }
+  const collected = collectBranchChangedFiles({
+    cwd: deps.cwd,
+    spawnSyncFn: deps.spawnSyncFn
+  });
+  if (!collected.ok) {
+    writeErr(
+      `[file-scope-guard] ${ticketKey ?? "unknown-ticket"}: unable to check file scope (git diff failed); continuing \u2014 PR creation is not blocked.`
+    );
+    return 0;
+  }
+  const analysis = analyzeDiffScope({
+    ticketKey,
+    declared,
+    changedFiles: collected.files
+  });
+  if (analysis.warning) {
+    writeOut(analysis.warning);
+  }
+  return 0;
+}
+var DECLARED_TOUCHED_FILES_ENV, FILE_SCOPE_GUARD_TICKET_KEY_ENV, FILE_SCOPE_GUARD_BASE_REF, defaultSpawnSync;
+var init_file_scope_guard = __esm({
+  "src/conductor/file-scope-guard.ts"() {
+    "use strict";
+    DECLARED_TOUCHED_FILES_ENV = "BAPI_CONDUCTOR_DECLARED_TOUCHED_FILES_JSON";
+    FILE_SCOPE_GUARD_TICKET_KEY_ENV = "BAPI_CONDUCTOR_TICKET_KEY";
+    FILE_SCOPE_GUARD_BASE_REF = "origin/main";
+    defaultSpawnSync = (command, args, options) => spawnSync(command, args, options);
+  }
+});
+
 // src/conductor/producer-ledger.ts
 import { createHash as createHash2 } from "node:crypto";
 function makeProducerDedupeKey(dimensions) {
@@ -4318,14 +4604,6 @@ function parseBoundedSupervisorInt(raw, fallback, min, max) {
   if (!Number.isFinite(parsed)) return fallback;
   return Math.min(max, Math.max(min, parsed));
 }
-function parseBoolEnv(raw, fallback) {
-  if (raw === void 0) return fallback;
-  const v = raw.trim().toLowerCase();
-  if (v.length === 0) return fallback;
-  if (v === "0" || v === "false" || v === "off" || v === "no") return false;
-  if (v === "1" || v === "true" || v === "on" || v === "yes") return true;
-  return fallback;
-}
 function resolveSupervisorConfig(overrides = {}, env = process.env) {
   const wake_interval_ms = clampOverride(
     overrides.wake_interval_ms,
@@ -4378,29 +4656,6 @@ function resolveSupervisorConfig(overrides = {}, env = process.env) {
     DEAD_AFTER_MIN_MS,
     DEAD_AFTER_MAX_MS
   );
-  const llm_enabled = overrides.llm_enabled !== void 0 ? overrides.llm_enabled : parseBoolEnv(env.BAPI_CONDUCTOR_LLM_ENABLED, true);
-  const llm_max_calls = clampOverride(
-    overrides.llm_max_calls,
-    parseBoundedSupervisorInt(
-      env.BAPI_CONDUCTOR_LLM_MAX_CALLS,
-      LLM_MAX_CALLS_DEFAULT,
-      LLM_MAX_CALLS_MIN,
-      LLM_MAX_CALLS_MAX
-    ),
-    LLM_MAX_CALLS_MIN,
-    LLM_MAX_CALLS_MAX
-  );
-  const llm_timeout_ms = clampOverride(
-    overrides.llm_timeout_ms,
-    parseBoundedSupervisorInt(
-      env.BAPI_CONDUCTOR_LLM_TIMEOUT_MS,
-      LLM_TIMEOUT_DEFAULT_MS,
-      LLM_TIMEOUT_MIN_MS,
-      LLM_TIMEOUT_MAX_MS
-    ),
-    LLM_TIMEOUT_MIN_MS,
-    LLM_TIMEOUT_MAX_MS
-  );
   const poll_limit = parseBoundedSupervisorInt(
     env.BAPI_CONDUCTOR_SUPERVISOR_POLL_LIMIT,
     POLL_LIMIT_DEFAULT2,
@@ -4417,9 +4672,6 @@ function resolveSupervisorConfig(overrides = {}, env = process.env) {
       dead_after_ms
     },
     escalation_cooldown_ms,
-    llm_enabled,
-    llm_max_calls,
-    llm_timeout_ms,
     poll_limit
   };
 }
@@ -4483,7 +4735,7 @@ function resolveStallThresholds(env) {
     failed: Number.MAX_SAFE_INTEGER
   };
 }
-var MINUTE_MS, HOUR_MS, WAKE_INTERVAL_DEFAULT_MS, WAKE_INTERVAL_MIN_MS, WAKE_INTERVAL_MAX_MS, GLOBAL_TIMEOUT_DEFAULT_MS, GLOBAL_TIMEOUT_MIN_MS, GLOBAL_TIMEOUT_MAX_MS, ESCALATION_COOLDOWN_DEFAULT_MS, ESCALATION_COOLDOWN_MIN_MS, ESCALATION_COOLDOWN_MAX_MS, QUIET_AFTER_DEFAULT_MS, QUIET_AFTER_MIN_MS, QUIET_AFTER_MAX_MS, LIVENESS_STALLED_AFTER_DEFAULT_MS, LIVENESS_STALLED_AFTER_MIN_MS, LIVENESS_STALLED_AFTER_MAX_MS, DEAD_AFTER_DEFAULT_MS, DEAD_AFTER_MIN_MS, DEAD_AFTER_MAX_MS, LLM_MAX_CALLS_DEFAULT, LLM_MAX_CALLS_MIN, LLM_MAX_CALLS_MAX, LLM_TIMEOUT_DEFAULT_MS, LLM_TIMEOUT_MIN_MS, LLM_TIMEOUT_MAX_MS, POLL_LIMIT_DEFAULT2, POLL_LIMIT_MIN, POLL_LIMIT_MAX2;
+var MINUTE_MS, HOUR_MS, WAKE_INTERVAL_DEFAULT_MS, WAKE_INTERVAL_MIN_MS, WAKE_INTERVAL_MAX_MS, GLOBAL_TIMEOUT_DEFAULT_MS, GLOBAL_TIMEOUT_MIN_MS, GLOBAL_TIMEOUT_MAX_MS, ESCALATION_COOLDOWN_DEFAULT_MS, ESCALATION_COOLDOWN_MIN_MS, ESCALATION_COOLDOWN_MAX_MS, QUIET_AFTER_DEFAULT_MS, QUIET_AFTER_MIN_MS, QUIET_AFTER_MAX_MS, LIVENESS_STALLED_AFTER_DEFAULT_MS, LIVENESS_STALLED_AFTER_MIN_MS, LIVENESS_STALLED_AFTER_MAX_MS, DEAD_AFTER_DEFAULT_MS, DEAD_AFTER_MIN_MS, DEAD_AFTER_MAX_MS, POLL_LIMIT_DEFAULT2, POLL_LIMIT_MIN, POLL_LIMIT_MAX2;
 var init_supervisor_config = __esm({
   "src/conductor/supervisor-config.ts"() {
     "use strict";
@@ -4507,12 +4759,6 @@ var init_supervisor_config = __esm({
     DEAD_AFTER_DEFAULT_MS = 2 * HOUR_MS;
     DEAD_AFTER_MIN_MS = 10 * MINUTE_MS;
     DEAD_AFTER_MAX_MS = 24 * HOUR_MS;
-    LLM_MAX_CALLS_DEFAULT = 10;
-    LLM_MAX_CALLS_MIN = 0;
-    LLM_MAX_CALLS_MAX = 1e3;
-    LLM_TIMEOUT_DEFAULT_MS = 3e4;
-    LLM_TIMEOUT_MIN_MS = 1e3;
-    LLM_TIMEOUT_MAX_MS = 12e4;
     POLL_LIMIT_DEFAULT2 = 200;
     POLL_LIMIT_MIN = 1;
     POLL_LIMIT_MAX2 = 1e3;
@@ -4826,6 +5072,7 @@ __export(bridge_api_client_exports, {
   claimEpicSupervisionLease: () => claimEpicSupervisionLease,
   createEpicTicketStatus: () => createEpicTicketStatus,
   deletePullRequestBranch: () => deletePullRequestBranch,
+  extractSanitizedErrorDiagnostics: () => extractSanitizedErrorDiagnostics,
   fetchActiveEpicRuns: () => fetchActiveEpicRuns,
   fetchConductorConfigField: () => fetchConductorConfigField,
   fetchConductorJsonPatchWithTimeout: () => fetchConductorJsonPatchWithTimeout,
@@ -4843,10 +5090,12 @@ __export(bridge_api_client_exports, {
   recordEpicDispatch: () => recordEpicDispatch,
   remediateEpicTicket: () => remediateEpicTicket,
   resolveConductorBridgeApiAccess: () => resolveConductorBridgeApiAccess,
+  safeDiagnosticMessage: () => safeDiagnosticMessage,
   storeEpicPlan: () => storeEpicPlan,
   transitionEpicDispatch: () => transitionEpicDispatch,
   transitionJiraStatus: () => transitionJiraStatus,
-  triggerRepositoryParse: () => triggerRepositoryParse
+  triggerRepositoryParse: () => triggerRepositoryParse,
+  updateEpicRunStatus: () => updateEpicRunStatus
 });
 import os2 from "node:os";
 import { readFile, stat } from "node:fs/promises";
@@ -4892,6 +5141,78 @@ function buildConductorJiraUrl(baseUrl, apiPath, params = {}) {
   }
   return url.toString();
 }
+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]");
+}
+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)}\u2026` : redacted;
+}
+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;
+}
+function redactDiagnosticValues(diagnostics, secrets) {
+  const scrub = (text) => {
+    let out2 = text;
+    for (const secret of secrets) {
+      if (secret && secret.length >= 4) out2 = out2.split(secret).join("[REDACTED]");
+    }
+    return out2;
+  };
+  const out = {};
+  if (diagnostics.errorCode) out.errorCode = scrub(diagnostics.errorCode);
+  if (diagnostics.bodyPreview) out.bodyPreview = scrub(diagnostics.bodyPreview);
+  return out;
+}
+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 {};
+  }
+}
+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;
+}
 function conductorGetHeaders(access) {
   return { "X-API-Key": access.apiKey };
 }
@@ -4906,13 +5227,14 @@ async function fetchConductorJsonWithTimeout(url, headers, timeoutMs, fetchImpl
       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();
@@ -4992,8 +5314,8 @@ async function fetchPrReviewStatus(access, prNumber, fetchImpl = globalThis.fetc
 }
 function buildConductorVcsUrl(baseUrl, apiPath) {
   const trimmed = baseUrl.replace(/\/+$/, "");
-  const path10 = apiPath.startsWith("/") ? apiPath : `/${apiPath}`;
-  return new URL(`${trimmed}${path10}`).toString();
+  const path9 = apiPath.startsWith("/") ? apiPath : `/${apiPath}`;
+  return new URL(`${trimmed}${path9}`).toString();
 }
 function conductorPostHeaders(access) {
   return { "X-API-Key": access.apiKey, "Content-Type": "application/json" };
@@ -5009,13 +5331,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();
@@ -5213,6 +5536,23 @@ async function fetchActiveEpicRuns(access, fetchImpl = globalThis.fetch) {
   }
   return [];
 }
+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;
+}
 function parseAdvanceEpicTicketStatusResult(parsed) {
   if (!parsed || typeof parsed !== "object") {
     throw new ConductorBridgeApiError("server");
@@ -5356,8 +5696,8 @@ async function transitionEpicDispatch(access, request, fetchImpl = globalThis.fe
   if (request.nextStatus === "run_spawned") {
     requireNonEmptyString(request.runId);
   }
-  const path10 = epicDispatchTransitionApiPath(request.dispatchKey, request.nextStatus);
-  const url = buildConductorJiraUrl(access.baseUrl, path10);
+  const path9 = epicDispatchTransitionApiPath(request.dispatchKey, request.nextStatus);
+  const url = buildConductorJiraUrl(access.baseUrl, path9);
   const body = request.nextStatus === "run_spawned" ? JSON.stringify({ repo_name: access.repoName, run_id: request.runId }) : JSON.stringify({ repo_name: access.repoName });
   const parsed = await fetchConductorJsonPostWithTimeout(
     url,
@@ -5530,7 +5870,7 @@ async function transitionJiraStatus(access, ticketNumber, targetStatus = "auto",
     throw err;
   }
 }
-var CONDUCTOR_DEFAULT_BASE_URL, CONDUCTOR_FETCH_TIMEOUT_MS, ConductorBridgeApiError, EPIC_TICKET_STATUS_VALUES, EPIC_DISPATCH_TRANSITION_STATUSES, EPIC_RUNS_API_PREFIX;
+var CONDUCTOR_DEFAULT_BASE_URL, CONDUCTOR_FETCH_TIMEOUT_MS, CONDUCTOR_BRIDGE_API_ERROR_KINDS, CONDUCTOR_ERROR_PREVIEW_MAX, ConductorBridgeApiError, EPIC_TICKET_STATUS_VALUES, EPIC_DISPATCH_TRANSITION_STATUSES, EPIC_RUNS_API_PREFIX;
 var init_bridge_api_client = __esm({
   "src/conductor/bridge-api-client.ts"() {
     "use strict";
@@ -5540,16 +5880,39 @@ var init_bridge_api_client = __esm({
     init_errors();
     CONDUCTOR_DEFAULT_BASE_URL = "https://bridgegpt-api.com";
     CONDUCTOR_FETCH_TIMEOUT_MS = 3e4;
+    CONDUCTOR_BRIDGE_API_ERROR_KINDS = [
+      "invalid-input",
+      "network",
+      "timeout",
+      "unauthorized",
+      "server",
+      "http"
+    ];
+    CONDUCTOR_ERROR_PREVIEW_MAX = 200;
     ConductorBridgeApiError = class 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 {
+          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;
       }
     };
     EPIC_TICKET_STATUS_VALUES = [
@@ -5568,8 +5931,7 @@ var init_bridge_api_client = __esm({
   }
 });
 
-// src/conductor/merge-ledger.ts
-import { createHash as createHash4 } from "node:crypto";
+// src/conductor/merge-identity.ts
 function buildGateIdentity(gateName, configHash) {
   const name = gateName.trim();
   const hash = typeof configHash === "string" ? configHash.trim() : "";
@@ -5585,33 +5947,101 @@ function makeMergeActionKey(repo, prNumber, headSha, gateIdentity) {
   }
   return `merge:${r}:${pr}:${sha}:${gate}`;
 }
-function extractMergeActionIdentityFromGateEvent(event) {
-  if (event.type !== "gate.met") return null;
-  if (typeof event.worker_id !== "string" || event.worker_id.trim().length === 0) {
-    return null;
+var init_merge_identity = __esm({
+  "src/conductor/merge-identity.ts"() {
+    "use strict";
+    init_git_ci_types();
   }
-  const data = event.data ?? {};
-  const details = data.details;
-  if (!details || typeof details !== "object") return null;
-  const d = details;
-  const repo = normalizeRepoName(d.repo);
-  const prNumber = normalizePrNumber(d.pr_number);
-  const headSha = normalizeSha(d.head_sha);
-  const gateName = typeof d.gate_name === "string" ? d.gate_name.trim() : "";
-  if (repo === null || prNumber === null || headSha === null || gateName.length === 0) {
-    return null;
+});
+
+// src/conductor/event-accessors.ts
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeEventHeadSha(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!/^[0-9a-f]{7,40}$/i.test(trimmed)) return null;
+  return trimmed.toLowerCase();
+}
+function getRawEventDetails(event) {
+  const details = event.data?.details;
+  return isPlainObject2(details) ? details : null;
+}
+function parseHeadObservation(event) {
+  const details = getRawEventDetails(event);
+  return { head_sha: details ? normalizeEventHeadSha(details.head_sha) : null };
+}
+function parseMergeLifecycle(event) {
+  const details = getRawEventDetails(event);
+  const actionKey = details && typeof details.action_key === "string" && details.action_key.trim().length > 0 ? details.action_key.trim() : null;
+  return { action_key: actionKey };
+}
+function parseGateMet(event) {
+  const details = getRawEventDetails(event);
+  if (!details) {
+    return {
+      head_sha: null,
+      repo: null,
+      pr_number: null,
+      gate_name: null,
+      config_hash: null,
+      required_checks: []
+    };
   }
-  const configHash = typeof d.config_hash === "string" && d.config_hash.trim().length > 0 ? d.config_hash.trim() : null;
-  const requiredChecks = Array.isArray(d.required_checks) ? d.required_checks.filter((c) => typeof c === "string" && c.trim().length > 0) : [];
-  const gateIdentity = buildGateIdentity(gateName, configHash);
+  const gateName = typeof details.gate_name === "string" && details.gate_name.trim().length > 0 ? details.gate_name.trim() : null;
+  const configHash = typeof details.config_hash === "string" && details.config_hash.trim().length > 0 ? details.config_hash.trim() : null;
+  const ciCheckStatus = isPlainObject2(details.ci_check_status) ? details.ci_check_status : null;
+  const rawRequiredChecks = Array.isArray(details.required_checks) ? details.required_checks : ciCheckStatus && Array.isArray(ciCheckStatus.required_checks) ? ciCheckStatus.required_checks : [];
+  const requiredChecks = rawRequiredChecks.filter(
+    (c) => typeof c === "string" && c.trim().length > 0
+  );
+  return {
+    head_sha: normalizeSha(details.head_sha),
+    repo: normalizeRepoName(details.repo),
+    pr_number: normalizePrNumber(details.pr_number),
+    gate_name: gateName,
+    config_hash: configHash,
+    required_checks: requiredChecks
+  };
+}
+function parseSpecReview(event) {
+  const details = getRawEventDetails(event);
+  return { head_sha: details ? normalizeEventHeadSha(details.head_sha) : null };
+}
+function parseEmpty() {
+  return EMPTY_DETAILS;
+}
+function getEventDetails(event, expectedType) {
+  if (event.type !== expectedType) return null;
+  const parser = EVENT_PARSERS[expectedType];
+  return parser(event);
+}
+function getHeadSha(event) {
+  const details = getRawEventDetails(event);
+  if (!details) return null;
+  return normalizeEventHeadSha(details.head_sha);
+}
+function getMergeIdentity(event) {
+  if (event.type !== "gate.met") return null;
+  if (typeof event.worker_id !== "string" || event.worker_id.trim().length === 0) {
+    return null;
+  }
+  const details = getEventDetails(event, "gate.met");
+  if (details === null) return null;
+  const { repo, pr_number: prNumber, head_sha: headSha, gate_name: gateName } = details;
+  if (repo === null || prNumber === null || headSha === null || gateName === null) {
+    return null;
+  }
+  const gateIdentity = buildGateIdentity(gateName, details.config_hash);
   const actionKey = makeMergeActionKey(repo, prNumber, headSha, gateIdentity);
   return {
     repo,
     pr_number: prNumber,
     head_sha: headSha,
     gate_name: gateName,
-    config_hash: configHash,
-    required_checks: requiredChecks,
+    config_hash: details.config_hash,
+    required_checks: details.required_checks,
     gate_identity: gateIdentity,
     action_key: actionKey,
     gate_event: {
@@ -5621,6 +6051,49 @@ function extractMergeActionIdentityFromGateEvent(event) {
     }
   };
 }
+var EMPTY_DETAILS, EVENT_PARSERS;
+var init_event_accessors = __esm({
+  "src/conductor/event-accessors.ts"() {
+    "use strict";
+    init_git_ci_types();
+    init_merge_identity();
+    EMPTY_DETAILS = Object.freeze({});
+    EVENT_PARSERS = {
+      "run.started": parseEmpty,
+      "run.heartbeat": parseEmpty,
+      "run.stopped": parseEmpty,
+      "agent.notification": parseEmpty,
+      "tool.intent": parseEmpty,
+      "worktree.changed": parseEmpty,
+      "git.commit_created": parseEmpty,
+      "git.pr_opened": parseHeadObservation,
+      "ci.passed": parseHeadObservation,
+      "ci.failed": parseHeadObservation,
+      "gate.met": parseGateMet,
+      "supervisor.assessment": parseEmpty,
+      "message.sent": parseEmpty,
+      "message.delivered": parseEmpty,
+      "message.acked": parseEmpty,
+      "merge.dry_run": parseMergeLifecycle,
+      "merge.attempted": parseMergeLifecycle,
+      "merge.succeeded": parseHeadObservation,
+      "merge.failed": parseMergeLifecycle,
+      "merge.conflict": parseHeadObservation,
+      "merge.pending_approval": parseMergeLifecycle,
+      "review.passed": parseHeadObservation,
+      "review.changes_requested": parseHeadObservation,
+      "spec_review.passed": parseSpecReview,
+      "spec_review.changes_requested": parseSpecReview,
+      "parse.triggered": parseEmpty
+    };
+  }
+});
+
+// src/conductor/merge-ledger.ts
+import { createHash as createHash4 } from "node:crypto";
+function extractMergeActionIdentityFromGateEvent(event) {
+  return getMergeIdentity(event);
+}
 function makeMergeEventId(eventType, actionKey) {
   const h = createHash4("sha256").update(`${eventType}:${actionKey}`).digest("hex");
   return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
@@ -5692,7 +6165,8 @@ async function emitMergeLedgerEventIfNew(input, deps = {}) {
 var init_merge_ledger = __esm({
   "src/conductor/merge-ledger.ts"() {
     "use strict";
-    init_git_ci_types();
+    init_event_accessors();
+    init_merge_identity();
     init_store();
   }
 });
@@ -5805,13 +6279,899 @@ var init_supervisor_merge = __esm({
   }
 });
 
+// src/conductor/done-gate.ts
+function isPlainObject3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function inactiveConfig(reason) {
+  return {
+    enabled: false,
+    valid: false,
+    reason,
+    conditions: [],
+    config_hash: null,
+    gate_name: DEFAULT_GATE_NAME
+  };
+}
+function coerceConfigObject(value) {
+  if (value === void 0 || value === null) return { kind: "unset" };
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) return { kind: "unset" };
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return { kind: "invalid" };
+    }
+    if (!isPlainObject3(parsed)) return { kind: "invalid" };
+    if (Object.keys(parsed).length === 0) return { kind: "unset" };
+    return { kind: "object", object: parsed };
+  }
+  if (isPlainObject3(value)) {
+    if (Object.keys(value).length === 0) return { kind: "unset" };
+    return { kind: "object", object: value };
+  }
+  return { kind: "invalid" };
+}
+function parseCiChecksCondition(entry) {
+  const rawChecks = entry.required_checks;
+  if (!Array.isArray(rawChecks) || rawChecks.length === 0) return null;
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of rawChecks) {
+    const name = normalizeCheckName(raw);
+    if (name === null) return null;
+    if (seen.has(name)) return null;
+    seen.add(name);
+    normalized.push(name);
+  }
+  return { type: REQUIRED_CI_CHECKS_GREEN, required_checks: normalized };
+}
+function parseReviewStateCondition(entry) {
+  const source = entry.source;
+  if (typeof source !== "string" || !VALID_REVIEW_SOURCES.has(source)) return null;
+  const condition = { type: REVIEW_STATE, source };
+  if (entry.require_sticky_verdict !== void 0) {
+    if (typeof entry.require_sticky_verdict !== "boolean") return null;
+    condition.require_sticky_verdict = entry.require_sticky_verdict;
+  }
+  if (entry.require_native_decision !== void 0) {
+    if (typeof entry.require_native_decision !== "boolean") return null;
+    condition.require_native_decision = entry.require_native_decision;
+  }
+  if (entry.min_approvals !== void 0) {
+    if (typeof entry.min_approvals !== "number" || !Number.isInteger(entry.min_approvals) || entry.min_approvals < 0) return null;
+    condition.min_approvals = entry.min_approvals;
+  }
+  if (entry.logic !== void 0) {
+    if (entry.logic !== "and") return null;
+    condition.logic = "and";
+  }
+  if (condition.source === "combination") {
+    const hasSticky = condition.require_sticky_verdict === true;
+    const hasNative = condition.require_native_decision === true;
+    const hasMin = typeof condition.min_approvals === "number" && condition.min_approvals > 0;
+    if (!hasSticky && !hasNative && !hasMin) return null;
+  }
+  return condition;
+}
+function parseConditions(object) {
+  const raw = object.conditions;
+  if (!Array.isArray(raw) || raw.length === 0) return null;
+  const seenTypes = /* @__PURE__ */ new Set();
+  const parsed = [];
+  for (const entry of raw) {
+    if (!isPlainObject3(entry)) return null;
+    const type = entry.type;
+    if (typeof type !== "string") return null;
+    if (seenTypes.has(type)) return null;
+    if (type === REQUIRED_CI_CHECKS_GREEN) {
+      const condition = parseCiChecksCondition(entry);
+      if (condition === null) return null;
+      seenTypes.add(type);
+      parsed.push(condition);
+    } else if (type === REVIEW_STATE) {
+      const condition = parseReviewStateCondition(entry);
+      if (condition === null) return null;
+      seenTypes.add(type);
+      parsed.push(condition);
+    } else {
+      return null;
+    }
+  }
+  return parsed;
+}
+function parseDoneGateConfig(value) {
+  const coerced = coerceConfigObject(value);
+  if (coerced.kind === "unset") return inactiveConfig("unset");
+  if (coerced.kind === "invalid") return inactiveConfig("malformed");
+  const object = coerced.object;
+  if (object.enabled !== true) {
+    if (object.enabled === false) return inactiveConfig("disabled");
+    return inactiveConfig("invalid: 'enabled' must be the boolean true");
+  }
+  const conditions = parseConditions(object);
+  if (conditions === null) {
+    return inactiveConfig("invalid: conditions must be a non-empty array of valid, non-duplicate condition objects");
+  }
+  const gateName = DEFAULT_GATE_NAME;
+  const configHash = stableJsonHash({
+    gate_name: gateName,
+    conditions: conditions.map((c) => {
+      if (c.type === REQUIRED_CI_CHECKS_GREEN) {
+        return { type: c.type, required_checks: c.required_checks };
+      }
+      const r = { type: c.type, source: c.source };
+      if (c.require_sticky_verdict !== void 0) r.require_sticky_verdict = c.require_sticky_verdict;
+      if (c.require_native_decision !== void 0) r.require_native_decision = c.require_native_decision;
+      if (c.min_approvals !== void 0) r.min_approvals = c.min_approvals;
+      if (c.logic !== void 0) r.logic = c.logic;
+      return r;
+    })
+  });
+  return {
+    enabled: true,
+    valid: true,
+    reason: "active",
+    conditions,
+    config_hash: configHash,
+    gate_name: gateName
+  };
+}
+function asLowerString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim().toLowerCase() : void 0;
+}
+function normalizeOneCheck(name, raw) {
+  const checkName = normalizeCheckName(name);
+  if (checkName === null) return null;
+  if (!isPlainObject3(raw)) {
+    return { name: checkName, complete: false, green: false };
+  }
+  const status = asLowerString(raw.status);
+  const conclusion = asLowerString(raw.conclusion);
+  const explicitComplete = typeof raw.complete === "boolean" ? raw.complete : void 0;
+  const explicitPassed = typeof raw.passed === "boolean" ? raw.passed : void 0;
+  let complete = false;
+  if (explicitComplete !== void 0) {
+    complete = explicitComplete;
+  } else if (conclusion !== void 0 && COMPLETE_STATES.has(conclusion)) {
+    complete = true;
+  } else if (status !== void 0 && COMPLETE_STATES.has(status)) {
+    complete = true;
+  }
+  let green = false;
+  if (complete) {
+    if (explicitPassed === true) {
+      green = true;
+    } else if (conclusion !== void 0 && SUCCESS_STATES.has(conclusion)) {
+      green = true;
+    } else if (conclusion === void 0 && explicitPassed === void 0 && status !== void 0 && SUCCESS_STATES.has(status)) {
+      green = true;
+    }
+  }
+  if (explicitPassed === false) green = false;
+  const state = conclusion ?? status ?? (explicitPassed === true ? "passed" : void 0);
+  const check = { name: checkName, complete, green };
+  if (state !== void 0) check.state = state;
+  return check;
+}
+function normalizeCiSnapshot(response) {
+  const checks = [];
+  const byName = /* @__PURE__ */ new Map();
+  const source = isPlainObject3(response) ? response : void 0;
+  const detail = source && isPlainObject3(source.detail) ? source.detail : void 0;
+  if (source) {
+    const rawChecks = source.checks ?? detail?.checks;
+    if (Array.isArray(rawChecks)) {
+      for (const entry of rawChecks) {
+        if (!isPlainObject3(entry)) continue;
+        const normalized = normalizeOneCheck(entry.name, entry);
+        if (normalized && !byName.has(normalized.name)) {
+          byName.set(normalized.name, normalized);
+          checks.push(normalized);
+        }
+      }
+    } else if (isPlainObject3(rawChecks)) {
+      for (const [name, value] of Object.entries(rawChecks)) {
+        const normalized = normalizeOneCheck(name, value);
+        if (normalized && !byName.has(normalized.name)) {
+          byName.set(normalized.name, normalized);
+          checks.push(normalized);
+        }
+      }
+    }
+  }
+  const unknownChecks = [];
+  const rawUnknown = source ? source.unknown_checks ?? detail?.unknown_checks : void 0;
+  if (Array.isArray(rawUnknown)) {
+    for (const raw of rawUnknown) {
+      const name = normalizeCheckName(raw);
+      if (name !== null && !unknownChecks.includes(name)) unknownChecks.push(name);
+    }
+  }
+  const allComplete = checks.length > 0 && checks.every((c) => c.complete);
+  const allPassed = checks.length > 0 && checks.every((c) => c.green) && unknownChecks.length === 0;
+  const hashInput = {
+    checks: [...checks].sort((a, b) => a.name.localeCompare(b.name)).map((c) => ({ name: c.name, complete: c.complete, green: c.green })),
+    unknown_checks: [...unknownChecks].sort()
+  };
+  return {
+    checks,
+    unknown_checks: unknownChecks,
+    check_state_hash: stableJsonHash(hashInput),
+    all_complete: allComplete,
+    all_passed: allPassed
+  };
+}
+function normalizeReviewSnapshot(raw) {
+  if (!isPlainObject3(raw)) return null;
+  if (raw.available === false) return null;
+  const detail = isPlainObject3(raw.detail) ? raw.detail : null;
+  if (detail === null) return null;
+  const reviewDecision = typeof detail.review_decision === "string" && detail.review_decision.length > 0 ? detail.review_decision : null;
+  const approvals = typeof detail.approvals === "number" && Number.isInteger(detail.approvals) && detail.approvals >= 0 ? detail.approvals : 0;
+  const rawVerdict = detail.sticky_verdict;
+  let stickyVerdict;
+  if (rawVerdict === REVIEW_VERDICT_APPROVED) {
+    stickyVerdict = "approved";
+  } else if (rawVerdict === REVIEW_VERDICT_CHANGES_REQUESTED) {
+    stickyVerdict = "changes_requested";
+  } else if (rawVerdict === REVIEW_VERDICT_UNKNOWN) {
+    stickyVerdict = "unknown";
+  } else {
+    stickyVerdict = null;
+  }
+  const headSha = typeof detail.head_sha === "string" && detail.head_sha.trim().length > 0 ? detail.head_sha.trim() : null;
+  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 };
+}
+function evaluateReviewCondition(condition, snapshot) {
+  if (snapshot === null) {
+    return { passed: false, changesRequested: false, reason: "review snapshot unavailable" };
+  }
+  const source = condition.source;
+  if (source === "sticky_verdict") {
+    if (snapshot.sticky_verdict === "approved") return { passed: true, changesRequested: false, reason: "sticky verdict approved" };
+    if (snapshot.sticky_verdict === "changes_requested") return { passed: false, changesRequested: true, reason: "sticky verdict requests changes" };
+    return { passed: false, changesRequested: false, reason: `sticky verdict not approved: ${snapshot.sticky_verdict ?? "null"}` };
+  }
+  if (source === "native_review_decision") {
+    const dec = snapshot.review_decision?.toUpperCase();
+    if (dec === "APPROVED") return { passed: true, changesRequested: false, reason: "native review decision approved" };
+    if (dec === "CHANGES_REQUESTED") return { passed: false, changesRequested: true, reason: "native review decision requests changes" };
+    return { passed: false, changesRequested: false, reason: `native review decision not approved: ${snapshot.review_decision ?? "null"}` };
+  }
+  if (source === "min_approvals") {
+    const required = typeof condition.min_approvals === "number" ? condition.min_approvals : 1;
+    if (snapshot.approvals >= required) return { passed: true, changesRequested: false, reason: `approvals ${snapshot.approvals} >= ${required}` };
+    return { passed: false, changesRequested: false, reason: `approvals ${snapshot.approvals} < ${required}` };
+  }
+  if (source === "combination") {
+    const requireSticky = condition.require_sticky_verdict === true;
+    const requireNative = condition.require_native_decision === true;
+    const minApprovals = typeof condition.min_approvals === "number" ? condition.min_approvals : 0;
+    const failures = [];
+    let changesRequested = false;
+    if (requireSticky) {
+      if (snapshot.sticky_verdict === "changes_requested") changesRequested = true;
+      if (snapshot.sticky_verdict !== "approved") failures.push(`sticky verdict not approved: ${snapshot.sticky_verdict ?? "null"}`);
+    }
+    if (requireNative) {
+      const dec = snapshot.review_decision?.toUpperCase();
+      if (dec === "CHANGES_REQUESTED") changesRequested = true;
+      if (dec !== "APPROVED") failures.push(`native decision not approved: ${snapshot.review_decision ?? "null"}`);
+    }
+    if (minApprovals > 0 && snapshot.approvals < minApprovals) {
+      failures.push(`approvals ${snapshot.approvals} < ${minApprovals}`);
+    }
+    if (failures.length > 0) return { passed: false, changesRequested, reason: failures.join("; ") };
+    return { passed: true, changesRequested: false, reason: "all combination sources satisfied" };
+  }
+  return { passed: false, changesRequested: false, reason: `unknown review source: ${source}` };
+}
+function failedEvaluation(reason) {
+  return { met: false, reason };
+}
+function evaluateDoneGate(config, binding, snapshot, evaluatedAtIso, reviewSnapshot = null) {
+  if (!config.enabled || !config.valid || config.conditions.length === 0) {
+    return failedEvaluation(`gate inactive: ${config.reason}`);
+  }
+  const headSha = normalizeSha(binding.head_sha);
+  if (headSha === null) {
+    return failedEvaluation("invalid binding: head_sha is not a valid SHA");
+  }
+  const allFailureReasons = [];
+  let checkResults = [];
+  let ciConditionType;
+  let requiredChecks;
+  let reviewResult;
+  const byName = /* @__PURE__ */ new Map();
+  for (const check of snapshot.checks) byName.set(check.name, check);
+  const unknownSet = new Set(snapshot.unknown_checks);
+  for (const condition of config.conditions) {
+    if (condition.type === REQUIRED_CI_CHECKS_GREEN) {
+      ciConditionType = condition.type;
+      requiredChecks = [...condition.required_checks];
+      checkResults = [];
+      const unmet = [];
+      for (const name of condition.required_checks) {
+        const check = byName.get(name);
+        if (!check) {
+          checkResults.push({ name, present: false, complete: false, green: false });
+          unmet.push(unknownSet.has(name) ? `${name} (unknown)` : `${name} (missing)`);
+          continue;
+        }
+        checkResults.push({ name, present: true, complete: check.complete, green: check.green });
+        if (!check.green) {
+          unmet.push(check.complete ? `${name} (not green)` : `${name} (pending)`);
+        }
+      }
+      if (unmet.length > 0) {
+        allFailureReasons.push(`required checks not green: ${unmet.join(", ")}`);
+      }
+    } else if (condition.type === REVIEW_STATE) {
+      reviewResult = evaluateReviewCondition(condition, reviewSnapshot);
+      if (!reviewResult.passed) {
+        allFailureReasons.push(`review condition not met: ${reviewResult.reason}`);
+      }
+    }
+  }
+  if (allFailureReasons.length > 0) {
+    return failedEvaluation(allFailureReasons.join("; "));
+  }
+  const ciCheckStatus = {};
+  if (ciConditionType !== void 0) {
+    ciCheckStatus.condition_type = ciConditionType;
+    ciCheckStatus.required_checks = requiredChecks;
+    ciCheckStatus.check_results = checkResults;
+  }
+  const reviewStatus = {};
+  if (reviewResult !== void 0) {
+    reviewStatus.passed = reviewResult.passed;
+    reviewStatus.reason = reviewResult.reason;
+  }
+  const details = {
+    repo: binding.repo,
+    pr_number: binding.pr_number,
+    head_sha: headSha,
+    gate_name: config.gate_name,
+    config_hash: config.config_hash,
+    evaluated_at: evaluatedAtIso,
+    ci_check_status: ciCheckStatus
+  };
+  if (reviewResult !== void 0) {
+    details.review_status = reviewStatus;
+  }
+  const gateEventData = {
+    summary: `Done gate "${config.gate_name}" met for ${binding.subject}`,
+    status: "met",
+    details
+  };
+  return { met: true, reason: "met", gateEventData };
+}
+var VALID_REVIEW_SOURCES, SUCCESS_STATES, COMPLETE_STATES, REVIEW_VERDICT_APPROVED, REVIEW_VERDICT_CHANGES_REQUESTED, REVIEW_VERDICT_UNKNOWN;
+var init_done_gate = __esm({
+  "src/conductor/done-gate.ts"() {
+    "use strict";
+    init_git_ci_types();
+    VALID_REVIEW_SOURCES = /* @__PURE__ */ new Set(["sticky_verdict", "native_review_decision", "min_approvals", "combination"]);
+    SUCCESS_STATES = /* @__PURE__ */ new Set(["success", "passed", "succeeded"]);
+    COMPLETE_STATES = /* @__PURE__ */ new Set([
+      "completed",
+      "complete",
+      "success",
+      "passed",
+      "succeeded",
+      "failure",
+      "failed",
+      "error",
+      "cancelled",
+      "canceled",
+      "timed_out",
+      "action_required",
+      "neutral",
+      "skipped"
+    ]);
+    REVIEW_VERDICT_APPROVED = "approved";
+    REVIEW_VERDICT_CHANGES_REQUESTED = "changes_requested";
+    REVIEW_VERDICT_UNKNOWN = "unknown";
+  }
+});
+
+// src/conductor/pr-review-producer.ts
+function buildReviewObservationEventInput(binding, snapshot, eventType, reason, runId = null, workerId = null) {
+  return {
+    source: "review",
+    type: eventType,
+    subject: binding.subject,
+    run_id: runId,
+    worker_id: workerId,
+    producer: GIT_CI_PRODUCER,
+    observed_via: REVIEW_PRODUCER_OBSERVED_VIA,
+    data: {
+      summary: eventType === REVIEW_PASSED ? `Review passed for ${binding.subject}` : `Review changes requested for ${binding.subject}`,
+      status: eventType === REVIEW_PASSED ? "passed" : "changes_requested",
+      details: {
+        repo: binding.repo,
+        pr_number: binding.pr_number,
+        head_sha: binding.head_sha,
+        review_decision: snapshot.review_decision,
+        approvals: snapshot.approvals,
+        sticky_verdict: snapshot.sticky_verdict,
+        review_state_hash: snapshot.review_state_hash,
+        reason
+      }
+    }
+  };
+}
+async function observeReviewWithResolved(binding, access, gateConfig, deps = {}) {
+  const fetchStatus = deps.fetchReviewStatus ?? fetchPrReviewStatus;
+  const emitIfNew = deps.emitIfNew ?? emitConductorEventIfNew;
+  const run_id = deps.env?.BAPI_CONDUCTOR_RUN_ID?.trim() || null;
+  const worker_id = deps.env?.BAPI_CONDUCTOR_WORKER_ID?.trim() || null;
+  const result = {
+    snapshot: null,
+    review_passed_emitted: false,
+    review_changes_requested_emitted: false,
+    reason: "observed"
+  };
+  const reviewCondition = gateConfig.conditions.find(
+    (c) => c.type === "review_state"
+  ) ?? null;
+  if (reviewCondition === null) {
+    result.reason = "no-review-condition";
+    return result;
+  }
+  let rawStatus;
+  try {
+    rawStatus = await fetchStatus(access, binding.pr_number);
+  } catch {
+    result.reason = "review-poll-failed";
+    return result;
+  }
+  const snapshot = normalizeReviewSnapshot(rawStatus);
+  result.snapshot = snapshot;
+  if (snapshot === null) {
+    result.reason = "review-snapshot-unavailable";
+    return result;
+  }
+  const evalResult = evaluateReviewCondition(reviewCondition, snapshot);
+  const baseDimensions = {
+    repo: binding.repo,
+    pr_number: binding.pr_number,
+    head_sha: binding.head_sha,
+    review_state_hash: snapshot.review_state_hash
+  };
+  if (evalResult.changesRequested) {
+    const event = buildReviewObservationEventInput(
+      binding,
+      snapshot,
+      REVIEW_CHANGES_REQUESTED,
+      evalResult.reason,
+      run_id,
+      worker_id
+    );
+    const decision = await emitIfNew(event, { event_type: REVIEW_CHANGES_REQUESTED, ...baseDimensions });
+    result.review_changes_requested_emitted = decision.emitted;
+    result.reason = "review changes requested";
+  } else if (evalResult.passed) {
+    const event = buildReviewObservationEventInput(
+      binding,
+      snapshot,
+      REVIEW_PASSED,
+      evalResult.reason,
+      run_id,
+      worker_id
+    );
+    const decision = await emitIfNew(event, { event_type: REVIEW_PASSED, ...baseDimensions });
+    result.review_passed_emitted = decision.emitted;
+    result.reason = "review passed";
+  } else {
+    result.reason = `review not yet passed: ${evalResult.reason}`;
+  }
+  return result;
+}
+var REVIEW_PRODUCER_OBSERVED_VIA;
+var init_pr_review_producer = __esm({
+  "src/conductor/pr-review-producer.ts"() {
+    "use strict";
+    init_git_ci_types();
+    init_done_gate();
+    init_bridge_api_client();
+    init_producer_ledger();
+    REVIEW_PRODUCER_OBSERVED_VIA = "pr-review-producer";
+  }
+});
+
+// src/conductor/github-mergeability.ts
+function normalizeGhMergeabilityValue(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  return trimmed.toUpperCase();
+}
+function parseGhPrMergeabilityFields(record) {
+  return {
+    mergeable: normalizeGhMergeabilityValue(record.mergeable),
+    mergeStateStatus: normalizeGhMergeabilityValue(record.mergeStateStatus)
+  };
+}
+function isPrMergeConflict(mergeability) {
+  return mergeability.mergeable === "CONFLICTING" || mergeability.mergeStateStatus === "DIRTY";
+}
+function isLikelyGhMergeConflictOutput(output) {
+  if (!output) return false;
+  const stdout = typeof output.stdout === "string" ? output.stdout : "";
+  const stderr = typeof output.stderr === "string" ? output.stderr : "";
+  const haystack = `${stdout}
+${stderr}`.toLowerCase();
+  if (haystack.trim().length === 0) return false;
+  return MERGE_CONFLICT_OUTPUT_SIGNATURES.some((sig) => haystack.includes(sig));
+}
+var MERGE_CONFLICT_OUTPUT_SIGNATURES;
+var init_github_mergeability = __esm({
+  "src/conductor/github-mergeability.ts"() {
+    "use strict";
+    MERGE_CONFLICT_OUTPUT_SIGNATURES = [
+      "merge conflict",
+      "merge conflicts",
+      "conflicting",
+      "conflict with the base branch",
+      "not possible to fast-forward",
+      "non-fast-forward",
+      "not mergeable",
+      "is not mergeable",
+      "cannot be cleanly created",
+      "would create a merge conflict"
+    ];
+  }
+});
+
+// src/conductor/pr-discovery.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+function runGhCommand(args, options = {}) {
+  try {
+    const stdout = execFileSync3("gh", args, {
+      cwd: options.cwd,
+      timeout: GH_COMMAND_TIMEOUT_MS,
+      encoding: "utf-8",
+      maxBuffer: 4 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return { ok: true, stdout: typeof stdout === "string" ? stdout : "" };
+  } catch {
+    return { ok: false, stdout: "" };
+  }
+}
+function discoverPrWithGhCli(options = {}, deps = {}) {
+  const runGh = deps.runGh ?? runGhCommand;
+  const result = runGh(GH_PR_VIEW_ARGS, { cwd: options.cwd });
+  if (!result.ok) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(result.stdout);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const record = parsed;
+  const number = typeof record.number === "number" ? record.number : null;
+  const state = typeof record.state === "string" ? record.state : "";
+  if (number === null || state.length === 0) return null;
+  const mergeability = parseGhPrMergeabilityFields(record);
+  const discovered = {
+    number,
+    head_sha: normalizeSha(record.headRefOid),
+    state,
+    mergeable: mergeability.mergeable,
+    mergeStateStatus: mergeability.mergeStateStatus
+  };
+  if (typeof record.headRefName === "string" && record.headRefName.trim().length > 0) {
+    discovered.head_ref = record.headRefName.trim();
+  }
+  if (typeof record.url === "string" && record.url.trim().length > 0) {
+    discovered.url = record.url.trim();
+  }
+  return discovered;
+}
+function makeBinding(repo, prNumber, headSha, extra = {}) {
+  const binding = {
+    repo,
+    pr_number: prNumber,
+    head_sha: headSha,
+    subject: `${repo}#${prNumber}`
+  };
+  if (extra.url !== void 0) binding.url = extra.url;
+  if (extra.head_ref !== void 0) binding.head_ref = extra.head_ref;
+  return binding;
+}
+function resolvePrHeadBinding(input = {}, deps = {}) {
+  const explicitRepo = input.repoName !== void 0 ? normalizeRepoName(input.repoName) : null;
+  if (input.prNumber !== void 0 || input.headSha !== void 0) {
+    const prNumber2 = normalizePrNumber(input.prNumber);
+    const headSha = normalizeSha(input.headSha);
+    if (prNumber2 === null || headSha === null) {
+      return { ok: false, reason: "invalid explicit pr_number or head_sha" };
+    }
+    if (input.repoName !== void 0 && explicitRepo === null) {
+      return { ok: false, reason: "invalid explicit repo_name" };
+    }
+    const repo2 = explicitRepo ?? normalizeRepoName(deps.getContext?.({ cwd: input.cwd, env: input.env })?.repo);
+    if (repo2 === null) {
+      return { ok: false, reason: "could not resolve repo name" };
+    }
+    return { ok: true, binding: makeBinding(repo2, prNumber2, headSha) };
+  }
+  const getContext = deps.getContext ?? getGitWorktreeContext;
+  const context = getContext({ cwd: input.cwd, env: input.env });
+  const repo = explicitRepo ?? normalizeRepoName(context.repo);
+  const localSha = normalizeSha(context.head_sha ?? "");
+  if (repo === null || localSha === null) {
+    return { ok: false, reason: "no local repo/HEAD to bind" };
+  }
+  const pr = discoverPrWithGhCli({ cwd: input.cwd }, deps);
+  if (pr === null) {
+    return { ok: false, reason: "gh unavailable or no PR for current branch" };
+  }
+  if (pr.state.toUpperCase() !== "OPEN") {
+    return { ok: false, reason: `PR is not open (state: ${pr.state})` };
+  }
+  const prNumber = normalizePrNumber(pr.number);
+  if (prNumber === null) {
+    return { ok: false, reason: "discovered PR number is invalid" };
+  }
+  if (pr.head_sha !== null && pr.head_sha !== localSha) {
+    return { ok: false, reason: "PR head SHA does not match local HEAD" };
+  }
+  return {
+    ok: true,
+    binding: makeBinding(repo, prNumber, localSha, { url: pr.url, head_ref: pr.head_ref })
+  };
+}
+var GH_COMMAND_TIMEOUT_MS, GH_PR_VIEW_ARGS;
+var init_pr_discovery = __esm({
+  "src/conductor/pr-discovery.ts"() {
+    "use strict";
+    init_git_ci_types();
+    init_github_mergeability();
+    init_git_inspection();
+    GH_COMMAND_TIMEOUT_MS = 5e3;
+    GH_PR_VIEW_ARGS = [
+      "pr",
+      "view",
+      "--json",
+      // BAPI-494: mergeability fields added to the SAME one-shot call — no new gh process.
+      "number,headRefOid,headRefName,url,state,mergeable,mergeStateStatus"
+    ];
+  }
+});
+
+// src/conductor/pr-ci-producer.ts
+async function _fetchGateConfigDefault(access) {
+  const setup = await fetchEffectiveSupervisorSetup(access);
+  if (setup.source === "none") return void 0;
+  return setup.done_gate_config ?? void 0;
+}
+function buildPrOpenedEventInput(binding, runId = null, workerId = null) {
+  const details = {
+    repo: binding.repo,
+    pr_number: binding.pr_number,
+    head_sha: binding.head_sha
+  };
+  if (binding.head_ref !== void 0) details.head_ref = binding.head_ref;
+  const data = {
+    summary: `PR ${binding.subject} observed`,
+    status: "open",
+    details
+  };
+  if (binding.url !== void 0) data.references = { url: binding.url };
+  return {
+    source: "git",
+    type: "git.pr_opened",
+    subject: binding.subject,
+    run_id: runId,
+    worker_id: workerId,
+    producer: GIT_CI_PRODUCER,
+    observed_via: PRODUCER_OBSERVED_VIA,
+    data
+  };
+}
+function buildCiObservationEventInput(binding, snapshot, runId = null, workerId = null) {
+  if (snapshot.checks.length === 0) return null;
+  const allComplete = snapshot.checks.every((c) => c.complete);
+  if (!allComplete) return null;
+  const allGreen = snapshot.checks.every((c) => c.green);
+  const type = allGreen ? "ci.passed" : "ci.failed";
+  const details = {
+    repo: binding.repo,
+    pr_number: binding.pr_number,
+    head_sha: binding.head_sha,
+    checks: snapshot.checks,
+    unknown_checks: snapshot.unknown_checks,
+    check_state_hash: snapshot.check_state_hash
+  };
+  return {
+    source: "ci",
+    type,
+    subject: binding.subject,
+    run_id: runId,
+    worker_id: workerId,
+    producer: GIT_CI_PRODUCER,
+    observed_via: PRODUCER_OBSERVED_VIA,
+    data: {
+      summary: allGreen ? `CI passed for ${binding.subject}` : `CI failed for ${binding.subject}`,
+      status: allGreen ? "passed" : "failed",
+      details
+    }
+  };
+}
+function buildGateMetEventInput(binding, evaluation, runId = null, workerId = null) {
+  if (!evaluation.met || !evaluation.gateEventData) return null;
+  return {
+    source: "conductor",
+    type: "gate.met",
+    subject: binding.subject,
+    run_id: runId,
+    worker_id: workerId,
+    producer: GIT_CI_PRODUCER,
+    observed_via: PRODUCER_OBSERVED_VIA,
+    data: { ...evaluation.gateEventData }
+  };
+}
+async function observeWithResolved(binding, access, gateConfig, deps) {
+  const emitIfNew = deps.emitIfNew ?? emitConductorEventIfNew;
+  const pollCi = deps.pollCi ?? pollCiChecksForCommit;
+  const now = deps.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  let run_id = deps.env?.BAPI_CONDUCTOR_RUN_ID?.trim() || null;
+  const worker_id = deps.env?.BAPI_CONDUCTOR_WORKER_ID?.trim() || null;
+  if (run_id === null && deps.resolveRunId) {
+    try {
+      run_id = await deps.resolveRunId(access, binding) ?? null;
+    } catch {
+      run_id = null;
+    }
+  }
+  const result = {
+    binding,
+    pr_opened_emitted: false,
+    ci_status: null,
+    ci_emitted: false,
+    gate_met: false,
+    gate_emitted: false,
+    reason: "observed"
+  };
+  const prDecision = await emitIfNew(buildPrOpenedEventInput(binding, run_id, worker_id), {
+    event_type: "git.pr_opened",
+    repo: binding.repo,
+    pr_number: binding.pr_number,
+    head_sha: binding.head_sha
+  });
+  result.pr_opened_emitted = prDecision.emitted;
+  let rawPoll;
+  try {
+    rawPoll = await pollCi(access, binding.head_sha);
+  } catch {
+    result.ci_status = "unavailable";
+    result.reason = "ci-poll-failed";
+    return result;
+  }
+  const snapshot = normalizeCiSnapshot(rawPoll);
+  const ciEvent = buildCiObservationEventInput(binding, snapshot, run_id, worker_id);
+  if (ciEvent === null) {
+    result.ci_status = "pending";
+  } else {
+    result.ci_status = ciEvent.type === "ci.passed" ? "passed" : "failed";
+    const ciDecision = await emitIfNew(ciEvent, {
+      event_type: ciEvent.type,
+      repo: binding.repo,
+      pr_number: binding.pr_number,
+      head_sha: binding.head_sha,
+      ci_check_hash: snapshot.check_state_hash
+    });
+    result.ci_emitted = ciDecision.emitted;
+  }
+  if (!gateConfig.enabled || !gateConfig.valid) {
+    result.reason = `gate inactive: ${gateConfig.reason}`;
+    return result;
+  }
+  let reviewSnapshot = null;
+  try {
+    const reviewObservation = await observeReviewWithResolved(binding, access, gateConfig, {
+      emitIfNew: deps.emitIfNew ?? emitConductorEventIfNew,
+      env: deps.env
+    });
+    reviewSnapshot = reviewObservation.snapshot;
+  } catch {
+    reviewSnapshot = null;
+  }
+  const evaluation = evaluateDoneGate(gateConfig, binding, snapshot, now(), reviewSnapshot);
+  if (!evaluation.met) {
+    result.reason = evaluation.reason;
+    return result;
+  }
+  result.gate_met = true;
+  const gateEvent = buildGateMetEventInput(binding, evaluation, run_id, worker_id);
+  if (gateEvent !== null) {
+    const gateDecision = await emitIfNew(gateEvent, {
+      event_type: "gate.met",
+      repo: binding.repo,
+      pr_number: binding.pr_number,
+      head_sha: binding.head_sha,
+      config_hash: gateConfig.config_hash ?? void 0
+    });
+    result.gate_emitted = gateDecision.emitted;
+    result.gate_event_summary = gateEvent.data?.summary;
+  }
+  result.reason = "gate met";
+  return result;
+}
+async function observePrCiOnce(params = {}, deps = {}) {
+  const resolveBinding = deps.resolveBinding ?? resolvePrHeadBinding;
+  const resolveAccess = deps.resolveAccess ?? (() => resolveConductorBridgeApiAccess({ env: deps.env, cwd: deps.cwd }));
+  const fetchGateConfig = deps.fetchGateConfig ?? _fetchGateConfigDefault;
+  const bindingResult = resolveBinding(
+    { repoName: params.repoName, prNumber: params.prNumber, headSha: params.headSha, cwd: params.cwd ?? deps.cwd, env: deps.env },
+    deps.bindingDeps ?? {}
+  );
+  if (!bindingResult.ok) {
+    return {
+      binding: null,
+      pr_opened_emitted: false,
+      ci_status: null,
+      ci_emitted: false,
+      gate_met: false,
+      gate_emitted: false,
+      reason: `no binding: ${bindingResult.reason}`
+    };
+  }
+  const accessResult = await resolveAccess();
+  if (!accessResult.ok) {
+    return {
+      binding: bindingResult.binding,
+      pr_opened_emitted: false,
+      ci_status: "unavailable",
+      ci_emitted: false,
+      gate_met: false,
+      gate_emitted: false,
+      reason: `access unavailable: ${accessResult.error}`
+    };
+  }
+  let rawConfig;
+  try {
+    rawConfig = await fetchGateConfig(accessResult.access);
+  } catch {
+    rawConfig = void 0;
+  }
+  const gateConfig = parseDoneGateConfig(rawConfig);
+  return observeWithResolved(bindingResult.binding, accessResult.access, gateConfig, deps);
+}
+var PRODUCER_OBSERVED_VIA;
+var init_pr_ci_producer = __esm({
+  "src/conductor/pr-ci-producer.ts"() {
+    "use strict";
+    init_git_ci_types();
+    init_done_gate();
+    init_pr_review_producer();
+    init_bridge_api_client();
+    init_pr_discovery();
+    init_producer_ledger();
+    PRODUCER_OBSERVED_VIA = "pr-ci-producer";
+  }
+});
+
 // src/conductor/local-merge.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 function resolveLocalMergeMethod(value) {
   return typeof value === "string" && MERGE_METHODS.has(value) ? value : "squash";
 }
 function defaultRunCommand(cmd, args, env) {
-  const result = spawnSync2(cmd, args, {
+  const result = spawnSync3(cmd, args, {
     encoding: "utf8",
     env: { ...process.env, ...env },
     timeout: DEFAULT_COMMAND_TIMEOUT_MS
@@ -5924,7 +7284,39 @@ function makeLocalMergeExecutor(options = {}, deps = {}) {
       ghEnv
     );
     if (merge.status !== 0) {
-      const mergeFailReason = merge.timedOut ? "gh_merge_timeout" : "gh_merge_failed";
+      if (merge.timedOut) {
+        const reason = "gh_merge_timeout";
+        return buildResponse(request, "failed", reason, false, [
+          { type: "merge.attempted", status: "attempted", details: baseDetails },
+          { type: "merge.failed", status: "failed", reason, details: baseDetails }
+        ]);
+      }
+      let mergeability = { mergeable: null, mergeStateStatus: null };
+      let isConflict = isLikelyGhMergeConflictOutput(merge);
+      if (!isConflict) {
+        const recheck = run("gh", ["pr", "view", String(pr), "--json", "mergeable,mergeStateStatus"], ghEnv);
+        if (recheck.status === 0) {
+          try {
+            mergeability = parseGhPrMergeabilityFields(JSON.parse(recheck.stdout));
+            isConflict = isPrMergeConflict(mergeability);
+          } catch {
+          }
+        }
+      }
+      if (isConflict) {
+        const reason = "gh_merge_conflict";
+        const conflictDetails = {
+          ...baseDetails,
+          head_sha: expectedSha,
+          ...mergeability.mergeable ? { mergeable: mergeability.mergeable } : {},
+          ...mergeability.mergeStateStatus ? { mergeStateStatus: mergeability.mergeStateStatus } : {}
+        };
+        return buildResponse(request, "failed", reason, false, [
+          { type: "merge.attempted", status: "attempted", details: baseDetails },
+          { type: "merge.conflict", status: "failed", reason, details: conflictDetails }
+        ]);
+      }
+      const mergeFailReason = "gh_merge_failed";
       return buildResponse(request, "failed", mergeFailReason, false, [
         { type: "merge.attempted", status: "attempted", details: baseDetails },
         { type: "merge.failed", status: "failed", reason: mergeFailReason, details: baseDetails }
@@ -5956,6 +7348,7 @@ var init_local_merge = __esm({
   "src/conductor/local-merge.ts"() {
     "use strict";
     init_bridge_api_client();
+    init_github_mergeability();
     MERGE_METHODS = /* @__PURE__ */ new Set(["squash", "merge", "rebase"]);
     DEFAULT_COMMAND_TIMEOUT_MS = 6e4;
   }
@@ -5965,12 +7358,16 @@ var init_local_merge = __esm({
 function isNonTerminal(status) {
   return NON_TERMINAL_STATUSES.has(status);
 }
+function isHeadScopedBlockingSignal(type) {
+  return HEAD_SCOPED_BLOCKING_SIGNALS.has(type);
+}
 function signalToNextStatus(signalType, isReviewRun = false) {
   void isReviewRun;
   if (signalType === "spec_review.passed") return "ready";
   if (signalType === "spec_review.changes_requested") return "blocked";
   if (signalType === "ci.failed") return "blocked";
   if (signalType === "review.changes_requested") return "blocked";
+  if (signalType === "merge.conflict") return "blocked";
   if (signalType === "merge.succeeded") return "done";
   return "ready_for_review";
 }
@@ -6005,6 +7402,49 @@ function extractWorkerLiveness(events, runId, nowMs, windowSeconds) {
   const age = nowMs - new Date(latest.time).getTime();
   return { alive: age <= windowSeconds * 1e3, workerId: latest.worker_id ?? null };
 }
+function classifyTerminalHeadScope(ctx) {
+  const { signalType, eventHeadSha, ticketKey, staleBlockedTickets, staleClearHead } = ctx;
+  if (isHeadScopedBlockingSignal(signalType)) {
+    if (eventHeadSha !== null && staleBlockedTickets.has(ticketKey)) {
+      const clearHead = staleClearHead(ticketKey);
+      if (clearHead !== null && clearHead !== eventHeadSha) return "stale_blocking_signal";
+    }
+    return "current_or_unproven";
+  }
+  if (signalType === "gate.met") {
+    if (eventHeadSha !== null && staleBlockedTickets.has(ticketKey)) {
+      const clearHead = staleClearHead(ticketKey);
+      if (clearHead !== null && clearHead === eventHeadSha) return "stale_block_clear_gate";
+    }
+    return "current_or_unproven";
+  }
+  return "not_head_scoped";
+}
+function resolveTerminalFoldDecision(table, signalType, headScope, foldExists, currentLocalStatus, nextStatus) {
+  const rule = table[signalType];
+  return rule({ headScope, foldExists, currentLocalStatus, nextStatus });
+}
+function eventCarriesPrBinding(event) {
+  if (!PR_BINDING_EVENT_TYPES.has(event.type)) return false;
+  if (getHeadSha(event) !== null) return true;
+  const details = event.data?.details;
+  if (details && typeof details === "object") {
+    const pr = details.pr_number;
+    if (typeof pr === "number" && Number.isFinite(pr)) return true;
+  }
+  return false;
+}
+function buildPrBoundTickets(events, runIdToTicketKey) {
+  const bound = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (!eventCarriesPrBinding(event)) continue;
+    const runId = typeof event.run_id === "string" ? event.run_id : null;
+    const mapped = runId ? runIdToTicketKey.get(runId) : void 0;
+    if (!mapped || mapped.isReview) continue;
+    bound.add(mapped.ticketKey);
+  }
+  return bound;
+}
 function rebuildObservedState(postgresState, events, _now) {
   const { epic_run, ticket_statuses, dispatches } = postgresState;
   const runIdToTicketKey = /* @__PURE__ */ new Map();
@@ -6016,6 +7456,7 @@ function rebuildObservedState(postgresState, events, _now) {
       });
     }
   }
+  const prBoundTickets = buildPrBoundTickets(events, runIdToTicketKey);
   const ticketStatusMap = /* @__PURE__ */ new Map();
   const ticketRowVersionMap = /* @__PURE__ */ new Map();
   const ticketRemediationMap = /* @__PURE__ */ new Map();
@@ -6029,9 +7470,73 @@ function rebuildObservedState(postgresState, events, _now) {
   }
   const unfoldedSignals = [];
   const pendingMergeEvents = [];
+  const ticketPostFoldRowVersionMap = /* @__PURE__ */ new Map();
   const foldedTicketKeys = /* @__PURE__ */ new Set();
-  const mergeQueuedTicketKeys = /* @__PURE__ */ new Set();
+  const mergeQueuedTicketHeadKeys = /* @__PURE__ */ new Set();
+  const mergeQueueKey = (ticketKey, headSha) => `${ticketKey}\0${headSha}`;
   const ticketBlockedReasons = /* @__PURE__ */ new Map();
+  const latestObservedHeadByTicket = /* @__PURE__ */ new Map();
+  const latestGatedHeadByTicket = /* @__PURE__ */ new Map();
+  const latestBlockingHeadByTicket = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const runId = typeof event.run_id === "string" ? event.run_id : null;
+    const mapped = runId ? runIdToTicketKey.get(runId) : void 0;
+    if (!mapped || mapped.isReview) continue;
+    const headSha = getHeadSha(event);
+    if (!headSha) continue;
+    const ticketKey = mapped.ticketKey;
+    if (HEAD_OBSERVATION_TYPES.has(event.type)) {
+      const prev = latestObservedHeadByTicket.get(ticketKey);
+      if (!prev || event.seq >= prev.seq) {
+        latestObservedHeadByTicket.set(ticketKey, { headSha, seq: event.seq });
+      }
+    }
+    if (event.type === "gate.met") {
+      const prev = latestGatedHeadByTicket.get(ticketKey);
+      if (!prev || event.seq >= prev.seq) {
+        latestGatedHeadByTicket.set(ticketKey, { headSha, seq: event.seq, event });
+      }
+    }
+    if (isHeadScopedBlockingSignal(event.type)) {
+      const prev = latestBlockingHeadByTicket.get(ticketKey);
+      if (!prev || event.seq >= prev.seq) {
+        latestBlockingHeadByTicket.set(ticketKey, {
+          headSha,
+          seq: event.seq,
+          reason: event.type
+        });
+      }
+    }
+  }
+  const ticketBlockedHeads = /* @__PURE__ */ new Map();
+  for (const [ticketKey, blocking] of latestBlockingHeadByTicket) {
+    ticketBlockedHeads.set(ticketKey, blocking.headSha);
+  }
+  const staleBlockedTickets = /* @__PURE__ */ new Set();
+  for (const [ticketKey, blocking] of latestBlockingHeadByTicket) {
+    const gated = latestGatedHeadByTicket.get(ticketKey);
+    const observed = latestObservedHeadByTicket.get(ticketKey);
+    const gatedSupersedes = gated !== void 0 && gated.seq > blocking.seq && gated.headSha !== blocking.headSha;
+    const observedSupersedes = observed !== void 0 && observed.seq > blocking.seq && observed.headSha !== blocking.headSha;
+    if (gatedSupersedes || observedSupersedes) {
+      staleBlockedTickets.add(ticketKey);
+      if (ticketStatusMap.get(ticketKey) === "blocked") {
+        ticketStatusMap.set(ticketKey, "ready_for_review");
+      }
+    }
+  }
+  const staleClearHead = (ticketKey) => latestGatedHeadByTicket.get(ticketKey)?.headSha ?? latestObservedHeadByTicket.get(ticketKey)?.headSha ?? null;
+  const dropPendingMergesForTicket = (ticketKey) => {
+    for (let i = pendingMergeEvents.length - 1; i >= 0; i--) {
+      const pending = pendingMergeEvents[i];
+      const pendingRunId = typeof pending.run_id === "string" ? pending.run_id : null;
+      const pendingTicket = pendingRunId ? runIdToTicketKey.get(pendingRunId)?.ticketKey : void 0;
+      if (pendingTicket !== ticketKey) continue;
+      const pendingHead = getHeadSha(pending);
+      if (pendingHead) mergeQueuedTicketHeadKeys.delete(mergeQueueKey(ticketKey, pendingHead));
+      pendingMergeEvents.splice(i, 1);
+    }
+  };
   for (const event of events) {
     if (!TERMINAL_SIGNAL_TYPES.has(event.type)) continue;
     const runId = typeof event.run_id === "string" ? event.run_id : null;
@@ -6041,49 +7546,93 @@ function rebuildObservedState(postgresState, events, _now) {
     const isReview = mapped.isReview;
     const isSpecVerdict = event.type === "spec_review.passed" || event.type === "spec_review.changes_requested";
     if (isReview && !isSpecVerdict) continue;
-    if (event.type === "ci.failed" || event.type === "review.changes_requested") {
-      ticketBlockedReasons.set(ticketKey, event.type);
-    } else if (event.type === "spec_review.changes_requested") {
+    const signalType = event.type;
+    if (signalType === "run.stopped" && !isReview && !prBoundTickets.has(ticketKey)) {
+      continue;
+    }
+    const nextStatus = signalToNextStatus(signalType, isReview);
+    const eventHeadSha = getHeadSha(event);
+    const headScope = classifyTerminalHeadScope({
+      ticketKey,
+      signalType,
+      nextStatus,
+      currentLocalStatus: ticketStatusMap.get(ticketKey),
+      eventHeadSha,
+      staleBlockedTickets,
+      staleClearHead
+    });
+    if (headScope === "stale_blocking_signal") continue;
+    if (isHeadScopedBlockingSignal(signalType)) {
+      ticketBlockedReasons.set(ticketKey, signalType);
+    } else if (signalType === "spec_review.changes_requested") {
       ticketBlockedReasons.set(ticketKey, "spec_review.changes_requested");
     }
     const postgresStatus = ticketStatusMap.get(ticketKey) ?? "planned";
     if (!isNonTerminal(postgresStatus)) continue;
-    if (event.type === "gate.met" && postgresStatus !== "blocked" && !mergeQueuedTicketKeys.has(ticketKey)) {
-      pendingMergeEvents.push(event);
-      mergeQueuedTicketKeys.add(ticketKey);
-    }
-    const signalType = event.type;
-    const nextStatus = signalToNextStatus(signalType, isReview);
-    if (foldedTicketKeys.has(ticketKey)) {
-      const currentLocalStatus = ticketStatusMap.get(ticketKey);
-      const mergeUpgrade = currentLocalStatus === "ready_for_review" && nextStatus === "done";
-      const specRejectUpgrade = signalType === "spec_review.changes_requested" && currentLocalStatus !== "blocked";
-      if (mergeUpgrade || specRejectUpgrade) {
-        const existingIdx = unfoldedSignals.findIndex(
-          (s) => s.ticket_key === ticketKey
-        );
-        if (existingIdx >= 0) {
-          unfoldedSignals[existingIdx] = {
-            ...unfoldedSignals[existingIdx],
-            next_status: nextStatus,
-            signal_type: signalType,
-            event
-          };
-          ticketStatusMap.set(ticketKey, nextStatus);
+    if (signalType === "gate.met" && eventHeadSha !== null) {
+      const latestGate = latestGatedHeadByTicket.get(ticketKey);
+      const isLatestGatedEvent = latestGate !== void 0 && latestGate.event === event;
+      const gateMetClearsStale = headScope === "stale_block_clear_gate";
+      if (isLatestGatedEvent && (postgresStatus !== "blocked" || gateMetClearsStale)) {
+        const key = mergeQueueKey(ticketKey, eventHeadSha);
+        if (!mergeQueuedTicketHeadKeys.has(key)) {
+          pendingMergeEvents.push(event);
+          mergeQueuedTicketHeadKeys.add(key);
         }
       }
+    }
+    const foldExists = foldedTicketKeys.has(ticketKey);
+    const currentLocalStatus = ticketStatusMap.get(ticketKey);
+    const decision = resolveTerminalFoldDecision(
+      TERMINAL_PRECEDENCE,
+      signalType,
+      headScope,
+      foldExists,
+      currentLocalStatus,
+      nextStatus
+    );
+    if (decision.action === "drop") continue;
+    if (decision.action === "select") {
+      if (nextStatus === "blocked" && currentLocalStatus === "blocked") {
+        foldedTicketKeys.add(ticketKey);
+        continue;
+      }
+      const rowVersion = ticketRowVersionMap.get(ticketKey) ?? 0;
+      ticketPostFoldRowVersionMap.set(ticketKey, rowVersion + 1);
+      unfoldedSignals.push({
+        ticket_key: ticketKey,
+        postgres_row_version: rowVersion,
+        next_status: nextStatus,
+        signal_type: signalType,
+        event
+      });
+      ticketStatusMap.set(ticketKey, nextStatus);
+      foldedTicketKeys.add(ticketKey);
       continue;
     }
-    const rowVersion = ticketRowVersionMap.get(ticketKey) ?? 0;
-    unfoldedSignals.push({
-      ticket_key: ticketKey,
-      postgres_row_version: rowVersion,
-      next_status: nextStatus,
-      signal_type: signalType,
-      event
-    });
+    const existingIdx = unfoldedSignals.findIndex((s) => s.ticket_key === ticketKey);
+    if (existingIdx >= 0) {
+      unfoldedSignals[existingIdx] = {
+        ...unfoldedSignals[existingIdx],
+        next_status: nextStatus,
+        signal_type: signalType,
+        event
+      };
+    } else {
+      const rowVersion = ticketRowVersionMap.get(ticketKey) ?? 0;
+      unfoldedSignals.push({
+        ticket_key: ticketKey,
+        postgres_row_version: rowVersion,
+        next_status: nextStatus,
+        signal_type: signalType,
+        event
+      });
+    }
     ticketStatusMap.set(ticketKey, nextStatus);
     foldedTicketKeys.add(ticketKey);
+    if (isHeadScopedBlockingSignal(signalType)) {
+      dropPendingMergesForTicket(ticketKey);
+    }
   }
   return {
     epic_key: epic_run.epic_key,
@@ -6091,16 +7640,19 @@ function rebuildObservedState(postgresState, events, _now) {
     plan_version: epic_run.current_plan_version,
     ticket_statuses: ticketStatusMap,
     ticket_row_versions: ticketRowVersionMap,
+    ticket_post_fold_row_versions: ticketPostFoldRowVersionMap,
     ticket_remediation_counters: ticketRemediationMap,
     ticket_blocked_reasons: ticketBlockedReasons,
+    ticket_blocked_heads: ticketBlockedHeads,
     unfolded_terminal_signals: unfoldedSignals,
     pending_merge_events: pendingMergeEvents
   };
 }
-var NOT_STARTED_STATUS, DONE_STATUSES, NON_TERMINAL_STATUSES, TERMINAL_SIGNAL_TYPES, DEFAULT_MAX_SPEC_REVIEW_ATTEMPTS;
+var NOT_STARTED_STATUS, DONE_STATUSES, NON_TERMINAL_STATUSES, TERMINAL_SIGNAL_TYPES, HEAD_SCOPED_BLOCKING_SIGNALS, DEFAULT_MAX_SPEC_REVIEW_ATTEMPTS, HEAD_OBSERVATION_TYPE_LIST, HEAD_OBSERVATION_TYPES, TERMINAL_PRECEDENCE, PR_BINDING_EVENT_TYPES;
 var init_epic_state = __esm({
   "src/conductor/epic-state.ts"() {
     "use strict";
+    init_event_accessors();
     NOT_STARTED_STATUS = "planned";
     DONE_STATUSES = /* @__PURE__ */ new Set(["done"]);
     NON_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
@@ -6123,15 +7675,105 @@ var init_epic_state = __esm({
       "ci.failed",
       "run.stopped",
       "review.changes_requested",
+      // BAPI-494: an un-mergeable PR folds to `blocked`, head-scoped to the conflict head.
+      "merge.conflict",
       // BAPI-445: pre-implementation spec re-review verdicts, scoped to review runs.
       "spec_review.passed",
       "spec_review.changes_requested"
     ]);
+    HEAD_SCOPED_BLOCKING_SIGNALS = /* @__PURE__ */ new Set([
+      "ci.failed",
+      "review.changes_requested",
+      "merge.conflict"
+    ]);
     DEFAULT_MAX_SPEC_REVIEW_ATTEMPTS = 3;
+    HEAD_OBSERVATION_TYPE_LIST = [
+      "git.pr_opened",
+      "ci.passed",
+      "ci.failed",
+      "review.passed",
+      "review.changes_requested",
+      "gate.met",
+      "merge.succeeded",
+      // BAPI-494: merge.conflict carries a details head SHA, so it is a head
+      // observation (its head can supersede a stale block and be superseded by a rebase).
+      "merge.conflict"
+    ];
+    HEAD_OBSERVATION_TYPES = new Set(HEAD_OBSERVATION_TYPE_LIST);
+    TERMINAL_PRECEDENCE = {
+      "gate.met": ({ foldExists, headScope, currentLocalStatus }) => {
+        if (!foldExists) return { action: "select" };
+        if (headScope === "stale_block_clear_gate" && currentLocalStatus === "blocked") {
+          return { action: "replace", reason: "stale-block-clear gate on the current head" };
+        }
+        return { action: "drop", reason: "gate.met does not override an existing same-tick fold" };
+      },
+      "merge.succeeded": ({ foldExists, currentLocalStatus }) => {
+        if (!foldExists) return { action: "select" };
+        if (currentLocalStatus === "ready_for_review") {
+          return { action: "replace", reason: "merge.succeeded upgrades ready_for_review to done" };
+        }
+        return { action: "drop", reason: "merge.succeeded does not override a non-ready_for_review fold" };
+      },
+      "ci.failed": ({ foldExists, headScope, currentLocalStatus }) => {
+        if (headScope === "stale_blocking_signal") {
+          return { action: "drop", reason: "stale ci.failed on a superseded head" };
+        }
+        if (!foldExists) return { action: "select" };
+        if (currentLocalStatus !== "blocked") {
+          return { action: "replace", reason: "current-head ci.failed dominates a prior non-blocked fold" };
+        }
+        return { action: "drop", reason: "ticket already blocked this tick" };
+      },
+      "review.changes_requested": ({ foldExists, headScope, currentLocalStatus }) => {
+        if (headScope === "stale_blocking_signal") {
+          return { action: "drop", reason: "stale review.changes_requested on a superseded head" };
+        }
+        if (!foldExists) return { action: "select" };
+        if (currentLocalStatus !== "blocked") {
+          return { action: "replace", reason: "current-head review.changes_requested dominates a prior non-blocked fold" };
+        }
+        return { action: "drop", reason: "ticket already blocked this tick" };
+      },
+      "merge.conflict": ({ foldExists, headScope, currentLocalStatus }) => {
+        if (headScope === "stale_blocking_signal") {
+          return { action: "drop", reason: "stale merge.conflict on a superseded head" };
+        }
+        if (!foldExists) return { action: "select" };
+        if (currentLocalStatus !== "blocked") {
+          return { action: "replace", reason: "current-head merge.conflict dominates a prior non-blocked fold" };
+        }
+        return { action: "drop", reason: "ticket already blocked this tick" };
+      },
+      "spec_review.changes_requested": ({ foldExists, currentLocalStatus }) => {
+        if (!foldExists) return { action: "select" };
+        if (currentLocalStatus !== "blocked") {
+          return { action: "replace", reason: "spec-review rejection dominates a prior non-blocked review fold" };
+        }
+        return { action: "drop", reason: "ticket already blocked this tick" };
+      },
+      "spec_review.passed": ({ foldExists }) => {
+        if (!foldExists) return { action: "select" };
+        return { action: "drop", reason: "spec_review.passed does not override an existing same-tick fold" };
+      },
+      "run.stopped": ({ foldExists }) => {
+        if (!foldExists) return { action: "select" };
+        return { action: "drop", reason: "run.stopped does not override an existing same-tick fold" };
+      }
+    };
+    PR_BINDING_EVENT_TYPES = /* @__PURE__ */ new Set([
+      "git.pr_opened",
+      "gate.met",
+      "merge.succeeded"
+    ]);
   }
 });
 
 // src/conductor/epic-reconcile.ts
+function safeDiagnosticMessage2(err, fallback) {
+  const raw = err instanceof Error ? err.message.trim() || err.constructor.name : fallback;
+  return raw.replace(/\s+/g, " ").slice(0, 500);
+}
 async function reconcileEpic(access, observed, plan, deps, supervisorConfig) {
   const result = {
     signals_folded: 0,
@@ -6153,10 +7795,16 @@ async function reconcileEpic(access, observed, plan, deps, supervisorConfig) {
     } 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}`);
+      observed.ticket_post_fold_row_versions?.delete(signal.ticket_key);
       continue;
     }
     if (casResult.ok) {
       result.signals_folded += 1;
+      observed.ticket_post_fold_row_versions ??= /* @__PURE__ */ 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} \u2192 ${signal.next_status}`
       );
@@ -6175,6 +7823,7 @@ async function reconcileEpic(access, observed, plan, deps, supervisorConfig) {
         }
       }
     } else {
+      observed.ticket_post_fold_row_versions?.delete(signal.ticket_key);
       result.warnings.push(`cas-conflict folding ${signal.signal_type} for ${signal.ticket_key}`);
     }
   }
@@ -6182,8 +7831,9 @@ async function reconcileEpic(access, observed, plan, deps, supervisorConfig) {
     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}: ${safeDiagnosticMessage2(err, "seed error")}`
+      );
     }
   }
   const readySet = computeReadySet(plan, observed.ticket_statuses);
@@ -6358,10 +8008,10 @@ async function reconcileEpic(access, observed, plan, deps, supervisorConfig) {
           continue;
         }
         const attempt = counters.attempts + 1;
-        const attemptKind = decision;
         const blockedReason = observed.ticket_blocked_reasons?.get(ticketKey);
-        const reason = blockedReason === "ci.failed" ? "ci.failed" : "review.changes_requested";
-        if (decision === "nudge" && !liveness.workerId) {
+        const normalizedReason = blockedReason === "ci.failed" ? "ci.failed" : blockedReason === "merge.conflict" ? "merge.conflict" : "review.changes_requested";
+        const attemptKind = normalizedReason === "merge.conflict" ? "redispatch" : decision;
+        if (attemptKind === "nudge" && !liveness.workerId) {
           result.warnings.push(
             `remediation nudge skipped for ${ticketKey}: alive worker has no worker_id`
           );
@@ -6369,9 +8019,9 @@ async function reconcileEpic(access, observed, plan, deps, supervisorConfig) {
         }
         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 = safeDiagnosticMessage2(err, "remediate error");
           result.warnings.push(
             `remediate-cas-failed for ${ticketKey} (${attemptKind}): ${safeMsg}`
           );
@@ -6381,24 +8031,25 @@ async function reconcileEpic(access, observed, plan, deps, supervisorConfig) {
           result.warnings.push(`remediation replay swallowed for ${ticketKey} (${attemptKind})`);
           continue;
         }
-        if (decision === "nudge") {
+        if (attemptKind === "nudge") {
+          const nudgeReason = normalizedReason === "ci.failed" ? "ci.failed" : "review.changes_requested";
           await sendNudge(
             observed.epic_key,
             ticketKey,
             attempt,
             casOutcome.reviewDigest,
             casOutcome.truncated,
-            reason,
+            nudgeReason,
             liveness.workerId
           );
         } else {
           await resumeDispatch(observed.epic_key, ticketKey, attempt);
         }
         deps.log(
-          `[epic-reconcile] remediation ${decision} ${ticketKey} attempt=${attempt}`
+          `[epic-reconcile] remediation ${attemptKind} ${ticketKey} attempt=${attempt} reason=${normalizedReason}`
         );
       } catch (err) {
-        const safeMsg = err instanceof Error ? err.constructor.name : "remediation error";
+        const safeMsg = safeDiagnosticMessage2(err, "remediation error");
         result.warnings.push(`remediation-error for ${ticketKey}: ${safeMsg}`);
       }
     }
@@ -6501,11 +8152,8 @@ function buildSupervisorEscalationWorkerMessage(candidate, assessment, state) {
     state: candidate.state,
     liveness: candidate.liveness,
     elapsed_ms: candidate.elapsed_ms,
-    assessment_source: assessment.source
+    assessment_source: "deterministic"
   };
-  if (assessment.draft_escalation_text) {
-    details.draft_escalation_text = assessment.draft_escalation_text;
-  }
   return {
     run_id: state.run_id,
     worker_id: candidate.worker_id,
@@ -6513,7 +8161,7 @@ function buildSupervisorEscalationWorkerMessage(candidate, assessment, state) {
     cause_seq: state.last_seq,
     payload: {
       summary: `supervisor escalation: ${candidate.reason}`,
-      status: assessment.should_escalate ? "escalated" : "noted",
+      status: "escalated",
       details
     },
     source: "conductor-supervisor",
@@ -6559,9 +8207,15 @@ function canonicalizePlanDAG(plan) {
   const nodes = plan.nodes.map((node) => ({
     ...node,
     ticket_key: node.ticket_key.trim(),
-    depends_on: [...node.depends_on].map((k) => k.trim()).sort()
+    depends_on: [...node.depends_on].map((k) => k.trim()).sort(),
+    ...node.touched_files ? { touched_files: [...node.touched_files].sort() } : {}
   })).sort((a, b) => a.ticket_key.localeCompare(b.ticket_key));
-  const edges = [...plan.edges].map((e) => ({ from: e.from.trim(), to: e.to.trim() })).sort((a, b) => {
+  const edges = [...plan.edges].map((e) => ({
+    from: e.from.trim(),
+    to: e.to.trim(),
+    ...e.kind ? { kind: e.kind } : {},
+    ...e.overlap_files ? { overlap_files: [...e.overlap_files].sort() } : {}
+  })).sort((a, b) => {
     const cmp = a.from.localeCompare(b.from);
     return cmp !== 0 ? cmp : a.to.localeCompare(b.to);
   });
@@ -6595,7 +8249,7 @@ async function dispatchSupervisorNotification(epicRunId, candidate, assessment,
       worker_id: candidate.worker_id ?? null,
       elapsed_ms: candidate.elapsed_ms,
       ticket_key: candidate.context?.ticket_key ?? null,
-      draft_text: assessment.draft_escalation_text ?? null
+      classification: assessment.classification
     }
   };
   const headers = {
@@ -6661,13 +8315,8 @@ async function emitSupervisorAssessmentIfNew(input, deps = {}) {
     kind: input.idempotency.kind,
     cooldown_window: input.idempotency.cooldown_window,
     classification: input.assessment.classification,
-    confidence: input.assessment.confidence,
-    should_escalate: input.assessment.should_escalate,
-    assessment_source: input.assessment.source
+    confidence: input.assessment.confidence
   };
-  if (input.assessment.draft_escalation_text) {
-    details.draft_escalation_text = input.assessment.draft_escalation_text;
-  }
   const event = {
     id: eventId,
     source: "conductor-supervisor",
@@ -6678,7 +8327,7 @@ async function emitSupervisorAssessmentIfNew(input, deps = {}) {
     observed_via: "supervisor",
     data: {
       summary: `supervisor assessment: ${input.idempotency.reason}`,
-      status: input.assessment.should_escalate ? "escalated" : "noted",
+      status: "escalated",
       reason: input.idempotency.reason,
       details
     }
@@ -6705,7 +8354,7 @@ var VERSION;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    VERSION = "0.2.16";
+    VERSION = "0.2.18";
   }
 });
 
@@ -7136,7 +8785,7 @@ async function enforcePreflightPrerequisites(deps) {
   }
   return { ok: true };
 }
-var WORKTRUNK_BINARY_OVERRIDE_ENV, WINDOWS_TERMINAL_COMMAND, WINDOWS_POWERSHELL_CANDIDATES, DEFAULT_WINDOWS_WORKTRUNK_BINARY, DEFAULT_POSIX_WORKTRUNK_BINARY, TMUX_COMMAND, GIT_FOR_WINDOWS_BASH_HINT, START_TICKETS_DOCTOR_COMMAND, WORKTRUNK_INSTALL_HINTS, GIT_INSTALL_HINTS, OSASCRIPT_INSTALL_HINTS, TMUX_INSTALL_HINTS, GIT_BASH_INSTALL_HINTS, WINDOWS_LAUNCHER_INSTALL_HINTS, GIT_WORK_TREE_INSTALL_HINTS;
+var WORKTRUNK_BINARY_OVERRIDE_ENV, WINDOWS_TERMINAL_COMMAND, WINDOWS_POWERSHELL_CANDIDATES, DEFAULT_WINDOWS_WORKTRUNK_BINARY, DEFAULT_POSIX_WORKTRUNK_BINARY, TMUX_COMMAND, GIT_FOR_WINDOWS_BASH_HINT, START_TICKETS_DOCTOR_COMMAND, WORKTRUNK_INSTALL_HINTS, GIT_INSTALL_HINTS, OSASCRIPT_INSTALL_HINTS, TMUX_INSTALL_HINTS, GIT_BASH_INSTALL_HINTS, WINDOWS_LAUNCHER_INSTALL_HINTS, GIT_WORK_TREE_INSTALL_HINTS, REVIEW_TICKETS_GIT_INSTALL_HINTS, RIPGREP_SHELL_FUNCTION_CAVEAT, RIPGREP_INSTALL_HINTS;
 var init_start_tickets_prereqs = __esm({
   "src/start-tickets-prereqs.ts"() {
     "use strict";
@@ -7188,6 +8837,17 @@ var init_start_tickets_prereqs = __esm({
       linux: "Run start-tickets from inside a git repository work tree.",
       win32: "Run start-tickets from inside a git repository work tree."
     };
+    REVIEW_TICKETS_GIT_INSTALL_HINTS = {
+      darwin: `${GIT_INSTALL_HINTS.darwin} (or rerun review-tickets with --no-refresh-base to skip the fetch)`,
+      linux: `${GIT_INSTALL_HINTS.linux} (or rerun review-tickets with --no-refresh-base to skip the fetch)`,
+      win32: `${GIT_INSTALL_HINTS.win32} (or rerun review-tickets with --no-refresh-base to skip the fetch)`
+    };
+    RIPGREP_SHELL_FUNCTION_CAVEAT = "a shell function/alias will not satisfy this check \u2014 ripgrep must be installed as a real PATH binary.";
+    RIPGREP_INSTALL_HINTS = {
+      darwin: `brew install ripgrep (${RIPGREP_SHELL_FUNCTION_CAVEAT})`,
+      linux: `Install ripgrep with your distro package manager, e.g. apt install ripgrep (${RIPGREP_SHELL_FUNCTION_CAVEAT})`,
+      win32: `winget install BurntSushi.ripgrep.MSVC (${RIPGREP_SHELL_FUNCTION_CAVEAT})`
+    };
   }
 });
 
@@ -7328,11 +8988,16 @@ function mintStartTicketsWorkerId(ticketKey, agentName, fragment = randomCorrela
   return `${ticketKey}-${sanitizeIdSegment(agentName)}-${fragment}`;
 }
 function buildEpicIdentityEnv(epic) {
-  return {
+  const env = {
     BAPI_CONDUCTOR_EPIC_KEY: epic.epic_key,
     BAPI_CONDUCTOR_EPIC_RUN_ID: epic.epic_run_id,
     BAPI_CONDUCTOR_PLAN_VERSION: String(epic.plan_version)
   };
+  const declared = normalizeDeclaredTouchedFiles(epic.declared_touched_files);
+  if (declared.length > 0) {
+    env.BAPI_CONDUCTOR_DECLARED_TOUCHED_FILES_JSON = JSON.stringify(declared);
+  }
+  return env;
 }
 function defaultResolveBinPath(filename) {
   return fileURLToPath2(new URL(`./${filename}`, import.meta.url));
@@ -7631,6 +9296,7 @@ var DEFAULT_CONDUCTOR_GATE_NAME, CONDUCTOR_TUNING_ENV_KEYS, CONDUCTOR_HOOK_LIFEC
 var init_start_tickets_conductor = __esm({
   "src/start-tickets-conductor.ts"() {
     "use strict";
+    init_file_scope_guard();
     init_mcp_profile();
     init_start_tickets_repo();
     DEFAULT_CONDUCTOR_GATE_NAME = "implement-ticket";
@@ -7644,8 +9310,7 @@ var init_start_tickets_conductor = __esm({
     ];
     CONDUCTOR_HOOK_LIFECYCLE_EVENTS = [
       "SessionStart",
-      "Stop",
-      "SubagentStop",
+      "SessionEnd",
       "Notification"
     ];
     DEFAULT_PRE_TOOL_USE_MATCHER = "*";
@@ -7663,6 +9328,18 @@ import path8 from "path";
 function appendSummaryRowWarning(row, warning) {
   return { ...row, warnings: [...row.warnings ?? [], warning] };
 }
+function validateBranchName(branch) {
+  if (branch.trim().length === 0) return "branch name must not be empty.";
+  if (branch.length > 255) return "branch name must be 255 characters or fewer.";
+  if (branch.startsWith("-")) return "branch name must not start with '-'.";
+  for (let i = 0; i < branch.length; i++) {
+    const code = branch.charCodeAt(i);
+    if (code <= 31 || code === 127) {
+      return "branch name must not contain control characters.";
+    }
+  }
+  return null;
+}
 function resolveBranchForTicket(key, overrides) {
   if (Object.prototype.hasOwnProperty.call(overrides, key)) {
     return overrides[key];
@@ -7687,7 +9364,7 @@ function getDefaultSpawnTerminalTabForPlatform(platform) {
       return spawnUnsupportedPlatformTerminalTab;
   }
 }
-function resolveStartTicketsPlatformConfig(deps, agent, autoApprove = false, conductorEnabled = false, repoName = null) {
+function resolveStartTicketsPlatformConfig(deps, agent, autoApprove = false, conductorEnabled = false, repoName = null, resumeMode = false) {
   if (!isSupportedStartTicketsPlatform(deps.platform)) {
     return { ok: false, error: unsupportedPlatformMessage(deps.platform) };
   }
@@ -7700,7 +9377,7 @@ function resolveStartTicketsPlatformConfig(deps, agent, autoApprove = false, con
       // Inject the resolved repo identity so the spawned worktree session never
       // falls back to the basename-derived repo name (the 403 root cause).
       buildAgentShellCommand: (key, worktreePath, modelAlias) => prependRepoNameEnvAssignment(
-        buildAgentShellCommand(agent, key, worktreePath, platform, autoApprove, modelAlias, conductorEnabled),
+        buildAgentShellCommand(agent, key, worktreePath, platform, autoApprove, modelAlias, conductorEnabled, resumeMode),
         repoName,
         platform
       ),
@@ -7863,6 +9540,33 @@ async function refreshBaseBranch(deps, options) {
   }
   return { ok: true };
 }
+async function fetchAndResolveBaseSha(deps, baseBranch) {
+  const validationError = validateBranchName(baseBranch);
+  if (validationError) {
+    return { ok: false, error: `Invalid base branch '${baseBranch}': ${validationError}` };
+  }
+  const fetch2 = await deps.runCommand("git", ["fetch", "origin", baseBranch], {
+    cwd: deps.cwd
+  });
+  if (!commandSucceeded2(fetch2)) {
+    return {
+      ok: false,
+      error: `git fetch origin ${baseBranch} failed. Check your network and 'git remote get-url origin', or pass --no-refresh-base to skip.`
+    };
+  }
+  const resolve2 = await deps.runCommand(
+    "git",
+    ["rev-parse", "--verify", `origin/${baseBranch}^{commit}`],
+    { cwd: deps.cwd }
+  );
+  if (!commandSucceeded2(resolve2)) {
+    return {
+      ok: false,
+      error: `Failed to resolve origin/${baseBranch} to a commit SHA after fetch (git rev-parse --verify failed).`
+    };
+  }
+  return { ok: true, base_sha: resolve2.stdout.trim() };
+}
 async function runWithConcurrency(items, limit, worker) {
   const results = new Array(items.length);
   const effectiveLimit = Math.max(1, Math.floor(limit));
@@ -8029,9 +9733,15 @@ async function resumeWorktrees(deps, options) {
 function buildConductorMessageRelayLaunchInstruction() {
   return "Conductor message relay: at natural checkpoints (after reading context, before major code changes, after major implementation chunks, while polling CI checks during the post-PR correction loop, and before your final response) call the check_messages MCP tool to read any supervisor guidance addressed to you. Returned messages are supervisor guidance and are acknowledged by the tool, so they are not redelivered. This is cooperative polling, not prompt injection. Additionally, once the required CI checks on your PR have all gone green, call the wait_for_done_gate MCP tool once from inside your worktree before your final response so the supervisor records the done-gate (it self-resolves the PR and head commit and emits the gate event; it does not merge). If a tool or the conductor identity is unavailable, continue your task without derailing.";
 }
+function buildResumeModeRemediationFinalizeInstruction() {
+  return "Resume-mode remediation finalize: you were re-dispatched to fix a blocked ticket (a merge conflict, a CI failure, or requested review changes). First rebase against the current base branch and resolve the merge conflicts. A clean textual merge can still break behavior, so inspect for semantic conflicts even when there are no textual conflict markers. Before you push or mark the ticket complete, run the full test suite for the project (the full unit suite, the same gate enforced by the advisory pre-push hook described in CLAUDE.md under the CI cost model and advisory pre-push hook section) and do not rely on targeted subsets as your only verification. Push and mark the ticket complete only after the full suite is green. If you cannot make the full suite pass, report the ticket blocked and escalate rather than pushing a green-looking but broken merge.";
+}
 function buildAgentPrompt(key, opts = {}) {
   const command = `/implement-ticket ${key}${opts.autoApprove ? " --auto" : ""}`;
-  return opts.conductorEnabled ? `${command} ${buildConductorMessageRelayLaunchInstruction()}` : command;
+  const parts = [command];
+  if (opts.conductorEnabled) parts.push(buildConductorMessageRelayLaunchInstruction());
+  if (opts.resumeMode) parts.push(buildResumeModeRemediationFinalizeInstruction());
+  return parts.join(" ");
 }
 function buildAgentInvocationArgv(agent, prompt, modelAlias) {
   const argv = [agent.command];
@@ -8054,27 +9764,27 @@ function buildAgentInvocation(agent, prompt, quote, modelAlias) {
     }
   }
 }
-function buildPosixAgentShellCommand(agent, key, worktreePath, autoApprove = false, modelAlias, conductorEnabled = false) {
+function buildPosixAgentShellCommand(agent, key, worktreePath, autoApprove = false, modelAlias, conductorEnabled = false, resumeMode = false) {
   const invocation = buildAgentInvocation(
     agent,
-    buildAgentPrompt(key, { autoApprove, conductorEnabled }),
+    buildAgentPrompt(key, { autoApprove, conductorEnabled, resumeMode }),
     (p) => `'${shSquoteInner(p)}'`,
     modelAlias
   );
   return `cd '${shSquoteInner(worktreePath)}' && ${invocation}`;
 }
-function buildPowerShellAgentShellCommand(agent, key, worktreePath, autoApprove = false, modelAlias, conductorEnabled = false) {
+function buildPowerShellAgentShellCommand(agent, key, worktreePath, autoApprove = false, modelAlias, conductorEnabled = false, resumeMode = false) {
   const invocation = buildAgentInvocation(
     agent,
-    buildAgentPrompt(key, { autoApprove, conductorEnabled }),
+    buildAgentPrompt(key, { autoApprove, conductorEnabled, resumeMode }),
     powershellSquote,
     modelAlias
   );
   return `Set-Location -LiteralPath ${powershellSquote(worktreePath)}; ${invocation}`;
 }
-function buildAgentShellCommand(agent, key, worktreePath, platform = "darwin", autoApprove = false, modelAlias, conductorEnabled = false) {
-  if (platform === "win32") return buildPowerShellAgentShellCommand(agent, key, worktreePath, autoApprove, modelAlias, conductorEnabled);
-  return buildPosixAgentShellCommand(agent, key, worktreePath, autoApprove, modelAlias, conductorEnabled);
+function buildAgentShellCommand(agent, key, worktreePath, platform = "darwin", autoApprove = false, modelAlias, conductorEnabled = false, resumeMode = false) {
+  if (platform === "win32") return buildPowerShellAgentShellCommand(agent, key, worktreePath, autoApprove, modelAlias, conductorEnabled, resumeMode);
+  return buildPosixAgentShellCommand(agent, key, worktreePath, autoApprove, modelAlias, conductorEnabled, resumeMode);
 }
 function terminalTitleForTicket(key) {
   return `${key} Implementation`;
@@ -8096,10 +9806,14 @@ function buildTerminalAppleScript(shellCommand, title) {
     "end tell"
   ].join("\n");
 }
-function buildITermAppleScript(shellCommand, title) {
+function itermBadgeShellCommand(badgeText) {
+  const b64 = Buffer.from(badgeText, "utf8").toString("base64");
+  return `printf '\\033]1337;SetBadgeFormat=%s\\007' '${b64}'`;
+}
+function buildITermAppleScript(shellCommand, title, badgeText) {
   const esc = applescriptDquoteInner(shellCommand);
   const titleEsc = applescriptDquoteInner(title);
-  return [
+  const lines = [
     'tell application "iTerm"',
     "    activate",
     "    if (count of windows) = 0 then",
@@ -8108,15 +9822,20 @@ function buildITermAppleScript(shellCommand, title) {
     "        tell current window to set spawnedSession to (current session of (create tab with default profile))",
     "    end if",
     "    tell spawnedSession",
-    `        set name to "${titleEsc}"`,
-    `        write text "${esc}"`,
-    "    end tell",
-    "end tell"
-  ].join("\n");
+    `        set name to "${titleEsc}"`
+  ];
+  if (badgeText) {
+    const badgeEsc = applescriptDquoteInner(itermBadgeShellCommand(badgeText));
+    lines.push(`        write text "${badgeEsc}"`);
+  }
+  lines.push(`        write text "${esc}"`);
+  lines.push("    end tell");
+  lines.push("end tell");
+  return lines.join("\n");
 }
 async function spawnMacOSTerminalTab(deps, terminal, shellCommand, context) {
   const title = terminalTitleForTicket(context?.key ?? "");
-  const script = terminal === "iterm" ? buildITermAppleScript(shellCommand, title) : buildTerminalAppleScript(shellCommand, title);
+  const script = terminal === "iterm" ? buildITermAppleScript(shellCommand, title, context?.key || void 0) : buildTerminalAppleScript(shellCommand, title);
   const result = await deps.runCommand("osascript", ["-e", script]);
   if (commandSucceeded2(result)) return { ok: true };
   const reason = (result.stderr || result.stdout || "").trim();
@@ -8942,7 +10661,9 @@ async function orchestrateStartTickets(deps, options, overrides = {}) {
     agent,
     options.autoApprove,
     options.conductorEnabled ?? false,
-    resolvedRepoName
+    resolvedRepoName,
+    // BAPI-494: resume-mode dispatches get the full-suite remediation finalize prompt.
+    options.resumeMode ?? false
   );
   if (!platformConfig.ok) return { ok: false, error: platformConfig.error };
   const refresh = await refreshBaseBranch(deps, {
@@ -9070,30 +10791,82 @@ var init_start_tickets = __esm({
 });
 
 // src/review-tickets.ts
+function formatBaseFetchFailureBox(baseBranch, error) {
+  const title = "review-tickets: base-branch fetch failed";
+  const reason = error.replace(/\s*Check your network and 'git remote get-url origin', or pass --no-refresh-base to skip\.?\s*$/i, "").trim();
+  const bodyLines = [
+    `Target base branch: origin/${baseBranch}`,
+    `Reason: ${reason}`,
+    "Remediation: check your network and 'git remote get-url origin', or rerun with --no-refresh-base to evaluate in-place."
+  ];
+  const contentWidth = Math.max(title.length + 2, ...bodyLines.map((l) => l.length)) + 2;
+  const horizontal = "\u2500".repeat(contentWidth);
+  const pad = (s) => `\u2502 ${s}${" ".repeat(contentWidth - s.length - 1)}\u2502`;
+  const lines = [
+    `\u256D${horizontal}\u256E`,
+    pad(`\u2716 ${title}`),
+    `\u251C${horizontal}\u2524`,
+    ...bodyLines.map((l) => pad(l)),
+    `\u2570${horizontal}\u256F`
+  ];
+  return `${ANSI_BOLD}${ANSI_WARM_CORAL}${lines.join("\n")}${ANSI_RESET}`;
+}
+async function resolveBatchBaseContext(deps, options) {
+  if (options.noRefreshBase) {
+    return { ok: true, context: { noRefreshBase: true } };
+  }
+  let effectiveBaseBranch = (options.baseBranch ?? "").trim();
+  if (effectiveBaseBranch.length === 0) {
+    try {
+      const accessResult = await resolveStartTicketsBridgeApiAccess(deps);
+      if (accessResult.ok) {
+        const configValue = await fetchStartTicketsConfigField(accessResult.access, "base_branch");
+        if (typeof configValue === "string" && configValue.trim().length > 0) {
+          effectiveBaseBranch = configValue.trim();
+        }
+      }
+    } catch {
+    }
+  }
+  if (effectiveBaseBranch.length === 0) {
+    effectiveBaseBranch = "main";
+  }
+  const fetchResult = await fetchAndResolveBaseSha(deps, effectiveBaseBranch);
+  if (!fetchResult.ok) {
+    return { ok: false, baseBranch: effectiveBaseBranch, error: fetchResult.error };
+  }
+  return {
+    ok: true,
+    context: { baseBranch: effectiveBaseBranch, baseSha: fetchResult.base_sha, noRefreshBase: false }
+  };
+}
 function resolveEffectiveReviewMode(key, options) {
   const override = options.reviewOverrides[key];
   const auto = override?.auto !== void 0 ? override.auto : options.auto;
   const rounds = override?.rounds !== void 0 ? override.rounds : options.rounds !== void 0 ? options.rounds : 2;
   return { auto, rounds };
 }
-function buildReviewTicketPrompt(key, mode) {
+function buildReviewTicketPrompt(key, mode, base = NO_BASE_CONTEXT) {
   const autoFlag = mode.auto ? " --auto" : "";
-  return `/review-ticket ${key}${autoFlag} --rounds=${mode.rounds}`;
+  const baseBranchFlag = base.baseBranch ? ` --base-branch=${base.baseBranch}` : "";
+  const baseShaFlag = base.baseSha ? ` --base-sha=${base.baseSha}` : "";
+  const noRefreshFlag = base.noRefreshBase ? " --no-refresh-base" : "";
+  return `/review-ticket ${key}${autoFlag} --rounds=${mode.rounds}${baseBranchFlag}${baseShaFlag}${noRefreshFlag}`;
 }
-function buildPosixReviewAgentShellCommand(agent, key, mode, cwd, modelAlias) {
-  const prompt = buildReviewTicketPrompt(key, mode);
+function buildPosixReviewAgentShellCommand(agent, key, mode, cwd, modelAlias, base = NO_BASE_CONTEXT) {
+  const prompt = buildReviewTicketPrompt(key, mode, base);
   const invocation = buildAgentInvocation(agent, prompt, (p) => `'${shSquoteInner(p)}'`, modelAlias);
   return `cd '${shSquoteInner(cwd)}' && ${invocation}`;
 }
-function buildPowerShellReviewAgentShellCommand(agent, key, mode, modelAlias) {
-  const prompt = buildReviewTicketPrompt(key, mode);
+function buildPowerShellReviewAgentShellCommand(agent, key, mode, modelAlias, base = NO_BASE_CONTEXT) {
+  const prompt = buildReviewTicketPrompt(key, mode, base);
   return buildAgentInvocation(agent, prompt, powershellSquote, modelAlias);
 }
-function buildReviewAgentShellCommand(agent, key, mode, platform, cwd, modelAlias) {
+function buildReviewAgentShellCommand(agent, key, mode, platform, cwd, modelAlias, base = NO_BASE_CONTEXT) {
   if (platform === "win32") {
-    return buildPowerShellReviewAgentShellCommand(agent, key, mode, modelAlias);
+    return buildPowerShellReviewAgentShellCommand(agent, key, mode, modelAlias, base);
   }
-  return buildPosixReviewAgentShellCommand(agent, key, mode, cwd, modelAlias);
+  return buildPosixReviewAgentShellCommand(agent, key, mode, cwd, modelAlias, base);
 }
 function unsupportedReviewTicketsPlatformMessage(platform) {
   const base = unsupportedPlatformMessage(platform);
@@ -9104,6 +10877,12 @@ async function runReviewTicketsPreflight(deps, options) {
   if (!isSupportedStartTicketsPlatform(deps.platform)) {
     return { ok: false, error: unsupportedReviewTicketsPlatformMessage(deps.platform) };
   }
+  if (!options.noRefreshBase && !await isCommandOnPath(deps, "git")) {
+    return {
+      ok: false,
+      error: "git is required for review-tickets' parent-fetch-once base-branch pin (BAPI-474) but was not found on PATH. Install git, or rerun with --no-refresh-base to skip the fetch and evaluate in-place."
+    };
+  }
   if (deps.platform === "darwin") {
     if (await isCommandOnPath(deps, "osascript")) return { ok: true };
     return {
@@ -9126,10 +10905,18 @@ async function runReviewTicketsPreflight(deps, options) {
     error: "tmux is required to spawn Linux review-tickets sessions but was not found on PATH. Install tmux and retry."
   };
 }
-function buildReviewPlanRows(deps, options, agent, status, overrides = {}) {
+function buildReviewPlanRows(deps, options, agent, status, overrides = {}, baseContext = NO_BASE_CONTEXT) {
   return options.keys.map((key) => {
     const mode = resolveEffectiveReviewMode(key, options);
-    const baseCommand = buildReviewAgentShellCommand(agent, key, mode, deps.platform, deps.cwd, options.modelAlias);
+    const baseCommand = buildReviewAgentShellCommand(
+      agent,
+      key,
+      mode,
+      deps.platform,
+      deps.cwd,
+      options.modelAlias,
+      baseContext
+    );
     let command = baseCommand;
     let runId;
     if (options.epic) {
@@ -9150,6 +10937,11 @@ function buildReviewPlanRows(deps, options, agent, status, overrides = {}) {
     };
   });
 }
+function previewBaseContextFromOptions(options) {
+  if (options.noRefreshBase) return { noRefreshBase: true };
+  if (options.baseBranch) return { baseBranch: options.baseBranch, noRefreshBase: false };
+  return NO_BASE_CONTEXT;
+}
 async function orchestrateReviewTickets(deps, options, overrides = {}) {
   const agent = resolveAgentSpec(options.agentName);
   if (!agent) {
@@ -9165,7 +10957,14 @@ async function orchestrateReviewTickets(deps, options, overrides = {}) {
         error: "epic.dispatch_key cannot be used with multiple keys: dispatch_key is a single-ticket claim and would be re-claimed for each key in the batch. Call orchestrateReviewTickets once per ticket instead."
       };
     }
-    const rows2 = buildReviewPlanRows(deps, options, agent, "dry-run", overrides);
+    const rows2 = buildReviewPlanRows(
+      deps,
+      options,
+      agent,
+      "dry-run",
+      overrides,
+      previewBaseContextFromOptions(options)
+    );
     return { ok: true, rows: rows2 };
   }
   const preflight = await runReviewTicketsPreflight(deps, options);
@@ -9176,13 +10975,28 @@ async function orchestrateReviewTickets(deps, options, overrides = {}) {
       error: "epic.dispatch_key cannot be used with multiple keys: dispatch_key is a single-ticket claim and would be re-claimed for each key in the batch. Call orchestrateReviewTickets once per ticket instead."
     };
   }
+  const resolveContext = overrides.resolveBaseContext ?? resolveBatchBaseContext;
+  const baseContextResult = await resolveContext(deps, options);
+  if (!baseContextResult.ok) {
+    console.error(formatBaseFetchFailureBox(baseContextResult.baseBranch, baseContextResult.error));
+    return { ok: false, error: baseContextResult.error };
+  }
+  const baseContext = baseContextResult.context;
   const terminal = detectTerminal(void 0, deps.env);
   const rows = await runWithConcurrency(
     options.keys,
     options.maxParallel,
     async (key) => {
       const mode = resolveEffectiveReviewMode(key, options);
-      const baseShellCommand = buildReviewAgentShellCommand(agent, key, mode, deps.platform, deps.cwd, options.modelAlias);
+      const baseShellCommand = buildReviewAgentShellCommand(
+        agent,
+        key,
+        mode,
+        deps.platform,
+        deps.cwd,
+        options.modelAlias,
+        baseContext
+      );
       let shellCommand = baseShellCommand;
       let runId;
       if (options.epic) {
@@ -9266,6 +11080,7 @@ async function orchestrateReviewTickets(deps, options, overrides = {}) {
   );
   return { ok: true, rows };
 }
+var NO_BASE_CONTEXT, ANSI_BOLD, ANSI_WARM_CORAL, ANSI_RESET;
 var init_review_tickets = __esm({
   "src/review-tickets.ts"() {
     "use strict";
@@ -9273,6 +11088,10 @@ var init_review_tickets = __esm({
     init_start_tickets_prereqs();
     init_agent_registry();
     init_start_tickets_conductor();
+    NO_BASE_CONTEXT = { noRefreshBase: false };
+    ANSI_BOLD = "\x1B[1m";
+    ANSI_WARM_CORAL = "\x1B[38;5;203m";
+    ANSI_RESET = "\x1B[0m";
   }
 });
 
@@ -9280,9 +11099,12 @@ var init_review_tickets = __esm({
 var epic_runtime_exports = {};
 __export(epic_runtime_exports, {
   buildProductionEpicRuntimeDeps: () => buildProductionEpicRuntimeDeps,
+  parsePrBindingFromGhJson: () => parsePrBindingFromGhJson,
+  resolveTicketPrBindingFromGh: () => resolveTicketPrBindingFromGh,
+  runConductorDoneGatePass: () => runConductorDoneGatePass,
   runEpicTick: () => runEpicTick
 });
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 function defaultLeaseOwner() {
   return `epic-tick-${process.pid}`;
 }
@@ -9295,6 +11117,126 @@ async function defaultDispatchSeam(_epicKey, ticketKey, _attempt = 0) {
 }
 async function defaultPostActionWaitSeam(_epicKey, _ticketKey) {
 }
+function parsePrBindingFromGhJson(stdout) {
+  let pr;
+  try {
+    pr = JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+  const num = pr.number;
+  const sha = pr.headRefOid;
+  const state = typeof pr.state === "string" ? pr.state : "";
+  if (typeof num === "number" && Number.isInteger(num) && num >= 1 && typeof sha === "string" && /^[0-9a-f]{7,40}$/i.test(sha) && state.toUpperCase() === "OPEN") {
+    const mergeability = parseGhPrMergeabilityFields(pr);
+    return {
+      prNumber: num,
+      headSha: sha,
+      mergeable: mergeability.mergeable,
+      mergeStateStatus: mergeability.mergeStateStatus
+    };
+  }
+  return null;
+}
+function resolveTicketPrBindingFromGh(ticketKey, options = {}) {
+  const runGh = options.runGh ?? runGhCommand;
+  const ghRes = runGh(
+    // BAPI-494: mergeability fields added to the SAME per-ticket binding call — the
+    // done-gate reads mergeability inside this existing call, spawning no new gh process.
+    ["pr", "view", `feature/${ticketKey}`, "--json", "number,headRefOid,state,mergeable,mergeStateStatus"],
+    { cwd: options.cwd ?? process.cwd() }
+  );
+  if (ghRes.ok && ghRes.stdout.trim()) {
+    const parsed = parsePrBindingFromGhJson(ghRes.stdout);
+    return parsed ? { ...parsed, headSha: parsed.headSha.toLowerCase() } : null;
+  }
+  return null;
+}
+async function runConductorDoneGatePass(ticketStatuses, deps) {
+  for (const [ticketKey, status] of ticketStatuses) {
+    if (status !== "ready_for_review" && status !== "blocked") continue;
+    const prBinding = deps.resolvePrBinding(ticketKey);
+    if (prBinding === null) {
+      deps.log(`[epic-tick] done-gate poll for ${ticketKey}: skipped (no PR binding)`);
+      continue;
+    }
+    if (status === "blocked") {
+      const blockedHead = deps.resolveBlockedHeadSha?.(ticketKey) ?? null;
+      if (blockedHead === null) {
+        deps.log(
+          `[epic-tick] done-gate re-eval for ${ticketKey}: blocked with no recorded head; polling current head ${prBinding.headSha} fail-closed as recovery`
+        );
+      } else if (blockedHead.toLowerCase() === prBinding.headSha.toLowerCase()) {
+        deps.log(
+          `[epic-tick] done-gate poll for ${ticketKey}: skipped (still blocked on current head ${prBinding.headSha})`
+        );
+        continue;
+      } else {
+        deps.log(
+          `[epic-tick] done-gate re-eval for ${ticketKey}: blocked head ${blockedHead} superseded by current head ${prBinding.headSha}; re-evaluating`
+        );
+      }
+    }
+    const runId = deps.resolveRunId?.(ticketKey) ?? null;
+    const workerId = deps.resolveWorkerId?.(ticketKey) ?? null;
+    if (status === "ready_for_review" && isPrMergeConflict(prBinding)) {
+      try {
+        await deps.emitConflictSignal?.({
+          ticketKey,
+          repoName: deps.access.repoName,
+          prNumber: prBinding.prNumber,
+          headSha: prBinding.headSha,
+          mergeable: prBinding.mergeable,
+          mergeStateStatus: prBinding.mergeStateStatus,
+          runId,
+          workerId
+        });
+        deps.log(
+          `[epic-tick] done-gate conflict for ${ticketKey}: PR #${prBinding.prNumber} not mergeable at head ${prBinding.headSha}; emitted merge.conflict`
+        );
+      } catch (err) {
+        const safeMsg = err instanceof Error ? err.constructor.name : "conflict emit error";
+        deps.errorLog(
+          `[epic-tick] done-gate conflict-signal failed (${safeMsg}) for ${ticketKey}; continuing`
+        );
+      }
+      continue;
+    }
+    const perTicketEnv = {
+      ...deps.env,
+      ...runId ? { BAPI_CONDUCTOR_RUN_ID: runId } : {},
+      ...workerId ? { BAPI_CONDUCTOR_WORKER_ID: workerId } : {}
+    };
+    try {
+      const observeResult = await deps.observePrCi(
+        {
+          repoName: deps.access.repoName,
+          prNumber: prBinding.prNumber,
+          headSha: prBinding.headSha
+        },
+        {
+          env: perTicketEnv,
+          resolveAccess: async () => ({ ok: true, access: deps.access })
+        }
+      );
+      deps.log(`[epic-tick] done-gate poll for ${ticketKey}: ${observeResult.reason}`);
+    } catch (err) {
+      const safeMsg = err instanceof Error ? err.constructor.name : "observe error";
+      deps.errorLog(
+        `[epic-tick] done-gate poll failed (${safeMsg}) for ${ticketKey}; continuing`
+      );
+    }
+  }
+}
+function shouldSelfCompleteEpicRun(plan, observed) {
+  if (plan.tickets.length === 0) return false;
+  for (const ticket of plan.tickets) {
+    if (observed.ticket_statuses.get(ticket.ticket_key) !== "done") {
+      return false;
+    }
+  }
+  return true;
+}
 async function runEpicTick(options, deps = {}) {
   const {
     epic_key,
@@ -9317,6 +11259,17 @@ async function runEpicTick(options, deps = {}) {
   const claimLeaseFn = deps.claimLease ?? claimEpicSupervisionLease;
   const fetchEpicStateFn = deps.fetchEpicState ?? fetchEpicRunState;
   const releaseLease = deps.releaseLease;
+  const env = deps.env ?? process.env;
+  const observePrCiSeamFn = deps.observePrCiSeam ?? observePrCiOnce;
+  const completeEpicRunFn = deps.completeEpicRun ?? (async (acc, epicRunId) => {
+    await updateEpicRunStatus(acc, {
+      epicKey: epicRunId,
+      status: "done",
+      expectedStatus: "active"
+    });
+  });
+  const emitConductorEventFn = deps.emitConductorEvent ?? emitConductorEventIfNew;
+  const isDryRun = env.BAPI_CONDUCTOR_DISPATCH_DRY_RUN === "1";
   const startMs = nowFn();
   let access;
   try {
@@ -9441,7 +11394,6 @@ async function runEpicTick(options, deps = {}) {
       const settleMs = 5e3;
       const fetchParseStatusFn = deps.fetchParseStatus ?? fetchParseStatus;
       const triggerParseFn = deps.triggerParse ?? triggerRepositoryParse;
-      const emitConductorEventFn = deps.emitConductorEvent ?? emitConductorEventIfNew;
       for (let i = 0; i < observed.unfolded_terminal_signals.length; i++) {
         const signal = observed.unfolded_terminal_signals[i];
         if (signal.signal_type !== "merge.succeeded") continue;
@@ -9648,6 +11600,70 @@ async function runEpicTick(options, deps = {}) {
         }
         return null;
       };
+      const resolvePrBinding = (ticketKey) => resolveTicketPrBindingFromGh(ticketKey, { cwd: process.cwd() });
+      const runIdToWorkerId = /* @__PURE__ */ new Map();
+      for (const ev of localEvents) {
+        if (ev.run_id && ev.worker_id && !runIdToWorkerId.has(ev.run_id)) {
+          runIdToWorkerId.set(ev.run_id, ev.worker_id);
+        }
+      }
+      const resolveTicketRunId = (tk) => ticketRunIdMap.get(tk) ?? latestDispatchByTicket.get(tk)?.runId ?? null;
+      const resolveDoneGateWorkerId = (tk) => {
+        const rid = resolveTicketRunId(tk);
+        if (rid && runIdToWorkerId.has(rid)) return runIdToWorkerId.get(rid);
+        return `conductor:${tk}`;
+      };
+      await runConductorDoneGatePass(observed.ticket_statuses, {
+        observePrCi: observePrCiSeamFn,
+        resolvePrBinding,
+        // BAPI-487: re-evaluate a blocked ticket only when its PR head advanced
+        // past the head recorded on its latest blocking signal.
+        resolveBlockedHeadSha: (tk) => observed.ticket_blocked_heads?.get(tk) ?? null,
+        resolveRunId: resolveTicketRunId,
+        resolveWorkerId: resolveDoneGateWorkerId,
+        // BAPI-494: convert a detected conflict into a durable, head-scoped
+        // `merge.conflict` ledger event stamped with the ticket's dispatch run/worker
+        // so the fold correlates it and the remediation pass redispatches. Emitted via
+        // the shared injectable emitter, idempotent per conflict head. Folded next tick
+        // (this pass runs after rebuildObservedState), matching the gate.met latency.
+        emitConflictSignal: (input) => {
+          emitConductorEventFn(
+            {
+              source: MERGE_CONFLICT_EVENT_SOURCE,
+              type: "merge.conflict",
+              subject: input.ticketKey,
+              run_id: input.runId,
+              worker_id: input.workerId,
+              producer: MERGE_CONFLICT_EVENT_PRODUCER,
+              observed_via: "supervisor",
+              time: new Date(nowFn()).toISOString(),
+              data: {
+                summary: `PR #${input.prNumber} for ${input.ticketKey} is not mergeable`,
+                status: "blocked",
+                reason: "merge.conflict",
+                details: {
+                  epic_key,
+                  ticket_key: input.ticketKey,
+                  repo: input.repoName,
+                  pr_number: input.prNumber,
+                  head_sha: input.headSha,
+                  mergeable: input.mergeable,
+                  mergeStateStatus: input.mergeStateStatus
+                }
+              }
+            },
+            {
+              event_type: "merge.conflict",
+              run_id: input.runId ?? void 0,
+              commit_sha: input.headSha
+            }
+          );
+        },
+        access,
+        env,
+        log,
+        errorLog
+      });
       const maxSeqForRun = (runId) => {
         let maxSeq = 0;
         for (const ev of localEvents) {
@@ -9663,25 +11679,50 @@ async function runEpicTick(options, deps = {}) {
           nextStatus,
           planVersion
         }),
-        seedTicketStatus: async (ek, tk, planVersion) => {
+        seedTicketStatus: async (_ek, tk, planVersion) => {
           await createEpicTicketStatus(access, {
-            epicKey: ek,
+            epicKey: epicRunState.epic_run.epic_run_id,
             ticketKey: tk,
             status: "planned",
             planVersion
           });
         },
-        claimDispatchKey: async (ek, tk, planVersion, role, attempt = 0) => recordEpicDispatch(access, {
-          epicKey: ek,
-          ticketKey: tk,
-          planVersion,
-          leaseOwner: lease_owner,
-          ttlSeconds: DEFAULT_DISPATCH_KEY_TTL_SECONDS,
-          attempt,
-          // BAPI-445: a review-role claim appends ":review" to the dispatch key
-          // so the run-id maps above can separate review runs from impl runs.
-          reviewRole: role === "review"
-        }),
+        claimDispatchKey: async (ek, tk, planVersion, role, attempt = 0) => {
+          if (isDryRun) {
+            const suffix = `${role === "review" ? ":review" : ""}${attempt > 0 ? `:r${attempt}` : ""}`;
+            const nowIso2 = new Date(nowFn()).toISOString();
+            log(
+              `[DRY RUN] claiming dispatch key skipped for ${tk} (epic=${ek}, role=${role ?? "implementation"}, attempt=${attempt}); no run_spawned row persisted`
+            );
+            return {
+              ok: true,
+              kind: "claimed",
+              dispatch: {
+                dispatch_key: `dry-run:${ek}:${tk}:v${planVersion}${suffix}`,
+                epic_run_id: ek,
+                ticket_key: tk,
+                plan_version: planVersion,
+                status: "pending",
+                run_id: null,
+                lease_owner,
+                lease_expires_at: null,
+                created_at: nowIso2,
+                updated_at: nowIso2
+              }
+            };
+          }
+          return recordEpicDispatch(access, {
+            epicKey: ek,
+            ticketKey: tk,
+            planVersion,
+            leaseOwner: lease_owner,
+            ttlSeconds: DEFAULT_DISPATCH_KEY_TTL_SECONDS,
+            attempt,
+            // BAPI-445: a review-role claim appends ":review" to the dispatch key
+            // so the run-id maps above can separate review runs from impl runs.
+            reviewRole: role === "review"
+          });
+        },
         // BAPI-445 spec re-review seams. dispatchReviewSeam is wired only when the
         // factory provides it (gate stays off otherwise); the liveness + attempt
         // accessors read the review-scoped maps built above.
@@ -9693,6 +11734,12 @@ async function runEpicTick(options, deps = {}) {
         },
         countReviewAttempts: (tk) => reviewAttemptCounts.get(tk) ?? 0,
         correlateRunId: async (dispatchKey, runId) => {
+          if (isDryRun) {
+            log(
+              `[DRY RUN] correlate run_id skipped for dispatch_key=${dispatchKey} (run_id=${runId}); no run_spawned transition persisted`
+            );
+            return;
+          }
           await transitionEpicDispatch(access, {
             dispatchKey,
             nextStatus: "run_spawned",
@@ -9745,7 +11792,7 @@ async function runEpicTick(options, deps = {}) {
             errorLog(`[epic-tick] teardown: branch-delete failed (${safeMsg}) for ${tk}`);
           }
           try {
-            spawnSync3("git", ["worktree", "remove", "--force", tk], { stdio: "ignore" });
+            spawnSync4("git", ["worktree", "remove", "--force", tk], { stdio: "ignore" });
             log(`[epic-tick] teardown: worktree removed for ${tk}`);
           } catch {
           }
@@ -9770,16 +11817,13 @@ async function runEpicTick(options, deps = {}) {
           return extractWorkerLiveness(localEvents, runId, nowFn(), livenessWindowSeconds);
         },
         remediateCas: async (ek, tk, attemptKind, reason2) => {
-          const prNumber = resolvePrNumber(tk);
-          if (prNumber === null) {
+          const prBinding = resolvePrBinding(tk);
+          if (prBinding === null) {
             throw new Error(`remediate: no PR binding for ${tk}`);
           }
-          const reviewStatus = await fetchPrReviewStatus(access, prNumber);
-          const headSha = reviewStatus?.detail?.head_sha ?? null;
-          if (!headSha) {
-            throw new Error(`remediate: no head_sha for PR ${prNumber}`);
-          }
-          const rowVersion = observed.ticket_row_versions.get(tk) ?? 0;
+          const prNumber = prBinding.prNumber;
+          const headSha = prBinding.headSha;
+          const rowVersion = observed.ticket_post_fold_row_versions?.get(tk) ?? observed.ticket_row_versions.get(tk) ?? 0;
           const idempotencyKey = `remediate:${ek}:${tk}:${rowVersion}`;
           const result = await remediateEpicTicket(access, {
             pr_number: prNumber,
@@ -9840,6 +11884,18 @@ async function runEpicTick(options, deps = {}) {
       for (const w of reconcileResult.warnings) {
         errorLog(`[epic-tick] warning: ${w}`);
       }
+      if (shouldSelfCompleteEpicRun(plan, observed) && observed.unfolded_terminal_signals.length === 0) {
+        try {
+          await completeEpicRunFn(access, epicRunState.epic_run.epic_run_id);
+          log(
+            `[epic-tick] epic=${epic_key} self-completed: all plan tickets done`
+          );
+        } catch (err) {
+          errorLog(
+            `[epic-tick] self-completion CAS failed for epic=${epic_key}: ${safeDiagnosticMessage(err, "self-complete error")}`
+          );
+        }
+      }
     } else {
       log(
         `[epic-tick] no plan available for epic=${epic_key}; skipping dispatch and merge steps`
@@ -9912,6 +11968,7 @@ async function buildProductionEpicRuntimeDeps(epicKey) {
   }
   let cachedPlanVersion = 0;
   const automationMap = /* @__PURE__ */ new Map();
+  const touchedFilesMap = /* @__PURE__ */ new Map();
   const fetchPlan = async (ek, acc) => {
     let response;
     try {
@@ -9925,15 +11982,25 @@ async function buildProductionEpicRuntimeDeps(epicKey) {
     const dag = response.plan_blob;
     cachedPlanVersion = response.plan_version;
     for (const node of dag.nodes) {
+      const nodeKey = node.ticket_key.trim();
       const kind = node.automations?.[0]?.kind;
       if (kind) {
-        automationMap.set(node.ticket_key.trim(), kind);
+        automationMap.set(nodeKey, kind);
+      }
+      const declared = normalizeDeclaredTouchedFiles(node.touched_files);
+      if (declared.length > 0) {
+        touchedFilesMap.set(nodeKey, declared);
       }
     }
-    const tickets = dag.nodes.map((n) => ({
-      ticket_key: n.ticket_key.trim(),
-      depends_on: (n.depends_on ?? []).map((k) => k.trim())
-    }));
+    const tickets = dag.nodes.map((n) => {
+      const nodeKey = n.ticket_key.trim();
+      const declared = touchedFilesMap.get(nodeKey);
+      return {
+        ticket_key: nodeKey,
+        depends_on: (n.depends_on ?? []).map((k) => k.trim()),
+        ...declared && declared.length > 0 ? { touched_files: declared } : {}
+      };
+    });
     const planHash = hashPlan(dag);
     return { plan_hash: planHash, plan_version: response.plan_version, tickets };
   };
@@ -9944,11 +12011,13 @@ async function buildProductionEpicRuntimeDeps(epicKey) {
     const isResume = attempt > 0;
     const kind = automationMap.get(tk) ?? "start-tickets";
     const dispatchDryRun = process.env.BAPI_CONDUCTOR_DISPATCH_DRY_RUN === "1";
+    const declaredTouchedFiles = kind === "review-tickets" ? void 0 : touchedFilesMap.get(tk);
     const identity = {
       epic_key: ek,
       epic_run_id: ek,
       plan_version: cachedPlanVersion,
-      dispatch_key: buildEpicDispatchKey(ek, tk, cachedPlanVersion, attempt)
+      dispatch_key: buildEpicDispatchKey(ek, tk, cachedPlanVersion, attempt),
+      ...declaredTouchedFiles && declaredTouchedFiles.length > 0 ? { declared_touched_files: declaredTouchedFiles } : {}
     };
     const deps = createDefaultStartTicketsDeps();
     let runId;
@@ -9960,7 +12029,11 @@ async function buildProductionEpicRuntimeDeps(epicKey) {
         dryRun: dispatchDryRun,
         maxParallel: 1,
         auto: true,
-        reviewOverrides: {}
+        reviewOverrides: {},
+        // BAPI-474: the Conductor epic-dispatch path stays git-fetch-free — it
+        // already dispatches into the correct worktree/branch context, so the
+        // fresh-base materialization (an interactive-CLI concern) is unneeded here.
+        noRefreshBase: true
       });
       if (!result.ok) {
         throw new Error(`review-tickets dispatch failed: ${result.error}`);
@@ -10029,7 +12102,10 @@ async function buildProductionEpicRuntimeDeps(epicKey) {
       auto: true,
       // Product directive: the spec re-review is `/review-ticket --auto --rounds=2`.
       rounds: 2,
-      reviewOverrides: {}
+      reviewOverrides: {},
+      // BAPI-474: see the sibling dispatchSeam comment — Conductor dispatch stays
+      // git-fetch-free.
+      noRefreshBase: true
     });
     if (!result.ok) {
       throw new Error(`spec re-review dispatch failed: ${result.error}`);
@@ -10074,7 +12150,6 @@ async function buildProductionEpicRuntimeDeps(epicKey) {
       state: null,
       liveness: null,
       elapsed_ms: 0,
-      ambiguous: false,
       context: {}
     };
     const ticketMatch = /^dispatch-orphan:(.+)$/.exec(reason);
@@ -10085,10 +12160,7 @@ async function buildProductionEpicRuntimeDeps(epicKey) {
     const assessment = {
       classification: "stuck",
       confidence: 1,
-      should_escalate: true,
-      reason,
-      draft_escalation_text: null,
-      source: "degraded"
+      reason
     };
     const idempotencyKey = makeSupervisorIdempotencyKey({
       run_id: ek,
@@ -10116,16 +12188,20 @@ async function buildProductionEpicRuntimeDeps(epicKey) {
     // defined inline in the reconcileDeps object in runEpicTick.
   };
 }
-var DEFAULT_LEASE_TTL_SECONDS, DEFAULT_MAX_DRIFT_MS, DEFAULT_DISPATCH_KEY_TTL_SECONDS, ACTIVE_WORKER_STATUSES, PARSE_WAIT_EVENT_SOURCE, PARSE_WAIT_EVENT_PRODUCER;
+var DEFAULT_LEASE_TTL_SECONDS, DEFAULT_MAX_DRIFT_MS, DEFAULT_DISPATCH_KEY_TTL_SECONDS, ACTIVE_WORKER_STATUSES, PARSE_WAIT_EVENT_SOURCE, PARSE_WAIT_EVENT_PRODUCER, MERGE_CONFLICT_EVENT_SOURCE, MERGE_CONFLICT_EVENT_PRODUCER;
 var init_epic_runtime = __esm({
   "src/conductor/epic-runtime.ts"() {
     "use strict";
     init_bridge_api_client();
     init_supervisor_merge();
+    init_pr_ci_producer();
+    init_pr_discovery();
+    init_github_mergeability();
     init_local_merge();
     init_producer_ledger();
     init_epic_state();
     init_epic_reconcile();
+    init_file_scope_guard();
     init_supervisor_message_relay();
     init_store();
     init_plan();
@@ -10141,6 +12217,8 @@ var init_epic_runtime = __esm({
     ACTIVE_WORKER_STATUSES = /* @__PURE__ */ new Set(["dispatched", "running"]);
     PARSE_WAIT_EVENT_SOURCE = "conductor-supervisor";
     PARSE_WAIT_EVENT_PRODUCER = "epic-parse-wait";
+    MERGE_CONFLICT_EVENT_SOURCE = "conductor-supervisor";
+    MERGE_CONFLICT_EVENT_PRODUCER = "epic-mergeability";
   }
 });
 
@@ -10167,11 +12245,6 @@ function createEmptySupervisorRunState(runId, config, now) {
     gates: {},
     latest_assessment: null,
     escalations: [],
-    llm_budget: {
-      enabled: config.llm_enabled,
-      max_calls: config.llm_max_calls,
-      used_calls: 0
-    },
     started_at: startedIso,
     updated_at: startedIso,
     global_deadline_at: msToIso(now + config.global_timeout_ms),
@@ -10196,11 +12269,8 @@ function hydrateSupervisorRunStateFromSnapshot(snapshot, runId, config, now) {
     gates: isPlainRecord(summary.gates) ? summary.gates : {},
     latest_assessment: summary.latest_assessment && typeof summary.latest_assessment === "object" ? summary.latest_assessment : null,
     escalations: Array.isArray(summary.escalations) ? summary.escalations : [],
-    llm_budget: summary.llm_budget && typeof summary.llm_budget === "object" ? {
-      enabled: config.llm_enabled,
-      max_calls: config.llm_max_calls,
-      used_calls: typeof summary.llm_budget.used_calls === "number" ? summary.llm_budget.used_calls : 0
-    } : empty.llm_budget,
+    // A legacy pre-BAPI-496 LLM-budget summary key is intentionally ignored
+    // rather than treated as an error — old projections still carry it.
     started_at: typeof summary.started_at === "string" ? summary.started_at : empty.started_at,
     global_deadline_at: typeof summary.global_deadline_at === "string" ? summary.global_deadline_at : empty.global_deadline_at,
     roster_discovered: summary.roster_discovered === true,
@@ -10520,7 +12590,6 @@ function toSupervisorProjectionInput(state) {
     gates: state.gates,
     latest_assessment: state.latest_assessment,
     escalations: state.escalations,
-    llm_budget: state.llm_budget,
     started_at: state.started_at,
     updated_at: state.updated_at,
     global_deadline_at: state.global_deadline_at,
@@ -10582,7 +12651,6 @@ function findSupervisorEscalationCandidates(state, config, now) {
         state: worker.state,
         liveness: worker.liveness,
         elapsed_ms: elapsed,
-        ambiguous: false,
         context: baseContext
       });
       continue;
@@ -10597,7 +12665,6 @@ function findSupervisorEscalationCandidates(state, config, now) {
             state: worker.state,
             liveness: worker.liveness,
             elapsed_ms: elapsed,
-            ambiguous: false,
             context: baseContext
           });
         }
@@ -10610,7 +12677,6 @@ function findSupervisorEscalationCandidates(state, config, now) {
           state: worker.state,
           liveness: worker.liveness,
           elapsed_ms: elapsed,
-          ambiguous: false,
           context: { ...baseContext, blocked_reason: worker.blocked_reason }
         });
         break;
@@ -10622,7 +12688,6 @@ function findSupervisorEscalationCandidates(state, config, now) {
           state: worker.state,
           liveness: worker.liveness,
           elapsed_ms: elapsed,
-          ambiguous: true,
           context: baseContext
         });
         break;
@@ -10635,7 +12700,6 @@ function findSupervisorEscalationCandidates(state, config, now) {
             state: worker.state,
             liveness: worker.liveness,
             elapsed_ms: elapsed,
-            ambiguous: true,
             context: baseContext
           });
         }
@@ -10649,7 +12713,6 @@ function findSupervisorEscalationCandidates(state, config, now) {
             state: worker.state,
             liveness: worker.liveness,
             elapsed_ms: elapsed,
-            ambiguous: true,
             context: baseContext
           });
         }
@@ -10667,7 +12730,6 @@ function findSupervisorEscalationCandidates(state, config, now) {
       state: null,
       liveness: null,
       elapsed_ms: Math.max(0, now - deadlineMs),
-      ambiguous: false,
       context: {
         run_id: state.run_id,
         deadline_at: state.global_deadline_at,
@@ -10684,10 +12746,9 @@ function cooldownWindowFor(now, cooldownMs) {
 function shouldEmitEscalation(state, candidate, config, now) {
   const cooldownWindow = cooldownWindowFor(now, config.escalation_cooldown_ms);
   const alreadyDecided = state.escalations.some(
-    (record) => record.reason === candidate.reason && (record.worker_id ?? null) === (candidate.worker_id ?? null) && record.cooldown_window === cooldownWindow && // A prior emit/duplicate OR an explicit LLM "do not escalate" (suppressed)
-    // decision in this window is binding — do not re-decide (and, for ambiguous
-    // candidates, do not re-query the LLM) until the window rolls over.
-    (record.outcome === "emitted" || record.outcome === "duplicate" || record.outcome === "suppressed")
+    (record) => record.reason === candidate.reason && (record.worker_id ?? null) === (candidate.worker_id ?? null) && record.cooldown_window === cooldownWindow && // A prior emitted/duplicate decision in this window is binding — do not
+    // re-decide until the window rolls over.
+    (record.outcome === "emitted" || record.outcome === "duplicate")
   );
   return { emit: !alreadyDecided, cooldown_window: cooldownWindow };
 }
@@ -10713,16 +12774,12 @@ function formatElapsed(ms) {
   if (minutes > 0) return `${minutes}m`;
   return `${seconds}s`;
 }
-function formatEscalationForTerminal(runId, candidate, draftText) {
+function formatEscalationForTerminal(runId, candidate) {
   const worker = candidate.worker_id ? ` worker=${candidate.worker_id}` : "";
   const stateBit = candidate.state ? ` state=${candidate.state}` : "";
   const liveBit = candidate.liveness ? ` liveness=${candidate.liveness}` : "";
   const elapsed = ` elapsed=${formatElapsed(candidate.elapsed_ms)}`;
-  let line = `[supervisor] run=${runId}${worker} reason=${candidate.reason}${stateBit}${liveBit}${elapsed}`;
-  if (draftText && draftText.trim().length > 0) {
-    line += ` :: ${draftText.replace(/\s+/g, " ").trim()}`;
-  }
-  return line;
+  return `[supervisor] run=${runId}${worker} reason=${candidate.reason}${stateBit}${liveBit}${elapsed}`;
 }
 var ESCALATION_KIND;
 var init_supervisor_escalation = __esm({
@@ -10732,271 +12789,23 @@ var init_supervisor_escalation = __esm({
   }
 });
 
-// src/conductor/supervisor-judgment.ts
-function asObject(raw) {
-  let value = raw;
-  if (typeof raw === "string") {
-    try {
-      value = JSON.parse(raw);
-    } catch {
-      throw new SupervisorJudgmentError("judgment response is not valid JSON");
-    }
-  }
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw new SupervisorJudgmentError("judgment response must be a JSON object");
-  }
-  return value;
-}
-function parseSupervisorJudgmentResponse(raw) {
-  const obj = asObject(raw);
-  for (const key of Object.keys(obj)) {
-    if (ACTION_LIKE_KEYS.has(key.toLowerCase())) {
-      throw new SupervisorJudgmentError(`judgment response contains forbidden action key "${key}"`);
-    }
-  }
-  const classification = obj.classification;
-  if (typeof classification !== "string" || !ALLOWED_JUDGMENT_CLASSIFICATIONS.has(classification)) {
-    throw new SupervisorJudgmentError("judgment response has an invalid 'classification'");
-  }
-  const confidence = obj.confidence;
-  if (typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
-    throw new SupervisorJudgmentError("judgment response 'confidence' must be a number in [0,1]");
-  }
-  const shouldEscalate = obj.should_escalate;
-  if (typeof shouldEscalate !== "boolean") {
-    throw new SupervisorJudgmentError("judgment response 'should_escalate' must be a boolean");
-  }
-  const reason = obj.reason;
-  if (typeof reason !== "string" || reason.trim().length === 0) {
-    throw new SupervisorJudgmentError("judgment response 'reason' must be a non-empty string");
-  }
-  let draft = null;
-  const draftRaw = obj.draft_escalation_text;
-  if (draftRaw !== null && draftRaw !== void 0) {
-    if (typeof draftRaw !== "string") {
-      throw new SupervisorJudgmentError("judgment response 'draft_escalation_text' must be a string or null");
-    }
-    for (const pattern of ACTION_LIKE_PHRASES) {
-      if (pattern.test(draftRaw)) {
-        throw new SupervisorJudgmentError("judgment draft text claims a privileged action");
-      }
-    }
-    draft = draftRaw;
-  }
-  return {
-    classification,
-    confidence,
-    should_escalate: shouldEscalate,
-    reason,
-    draft_escalation_text: draft
-  };
-}
-function degradedAssessment(candidate, reason) {
-  return {
-    classification: "unknown",
-    confidence: 0,
-    // Degraded mode never SUPPRESSES a surfaced stall: a candidate the
-    // deterministic layer already flagged stays escalated.
-    should_escalate: true,
-    reason: `${candidate.reason}:${reason}`,
-    draft_escalation_text: null,
-    source: "degraded"
-  };
-}
-async function assessSupervisorCandidate(request, config, budget, client) {
-  const candidate = request.candidate;
-  if (!config.llm_enabled || !budget.enabled || budget.max_calls <= 0) {
-    return degradedAssessment(candidate, "llm_disabled");
-  }
-  if (budget.used_calls >= budget.max_calls) {
-    return degradedAssessment(candidate, "budget_exhausted");
-  }
-  budget.used_calls += 1;
-  let response;
-  try {
-    const raw = await client(request);
-    response = parseSupervisorJudgmentResponse(raw);
-  } catch {
-    return degradedAssessment(candidate, "llm_failed");
-  }
-  return {
-    classification: response.classification,
-    confidence: response.confidence,
-    should_escalate: response.should_escalate,
-    reason: response.reason,
-    draft_escalation_text: response.draft_escalation_text,
-    source: "llm"
-  };
-}
-var SupervisorJudgmentError, ALLOWED_JUDGMENT_CLASSIFICATIONS, ACTION_LIKE_KEYS, ACTION_LIKE_PHRASES;
-var init_supervisor_judgment = __esm({
-  "src/conductor/supervisor-judgment.ts"() {
-    "use strict";
-    SupervisorJudgmentError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "SupervisorJudgmentError";
-      }
-    };
-    ALLOWED_JUDGMENT_CLASSIFICATIONS = /* @__PURE__ */ new Set([
-      "progressing",
-      "ambiguous",
-      "stuck",
-      "blocked",
-      "unknown"
-    ]);
-    ACTION_LIKE_KEYS = /* @__PURE__ */ new Set([
-      "executed",
-      "action",
-      "actions",
-      "command",
-      "commands",
-      "kill",
-      "killed",
-      "merge",
-      "merged",
-      "transition",
-      "deleted",
-      "wrote",
-      "mutated",
-      "ran"
-    ]);
-    ACTION_LIKE_PHRASES = [
-      /\bi (?:have )?(?:killed|merged|executed|ran|deleted|restarted|retried|fixed|committed|pushed)\b/i,
-      /\bhas been (?:killed|merged|executed|restarted|deleted)\b/i,
-      /\bworker (?:killed|terminated|restarted)\b/i
-    ];
-  }
-});
-
-// src/conductor/supervisor-judgment-python.ts
-import { spawn as nodeSpawn } from "node:child_process";
-import path9 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-function nonEmpty2(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-function resolveSupervisorJudgmentCommand(env = process.env) {
-  if (nonEmpty2(env.BAPI_CONDUCTOR_PYTHON)) return env.BAPI_CONDUCTOR_PYTHON.trim();
-  return "python3";
-}
-function resolveSupervisorJudgmentCwd(env = process.env) {
-  if (nonEmpty2(env.BAPI_CONDUCTOR_PYTHON_CWD)) return env.BAPI_CONDUCTOR_PYTHON_CWD.trim();
-  const here = fileURLToPath3(import.meta.url);
-  return path9.resolve(path9.dirname(here), "..", "..", "..");
-}
-function buildRequestPayload(request, env) {
-  const payload = {
-    run_id: request.run_id,
-    candidate: request.candidate,
-    worker: request.worker
-  };
-  if (nonEmpty2(env.BAPI_CONDUCTOR_REPO_NAME)) payload.repo_name = env.BAPI_CONDUCTOR_REPO_NAME.trim();
-  if (nonEmpty2(env.BAPI_CONDUCTOR_RUN_ID)) payload.session_id = env.BAPI_CONDUCTOR_RUN_ID.trim();
-  return payload;
-}
-function requestPythonSupervisorJudgment(request, config, deps = {}) {
-  const spawnFn = deps.spawn ?? nodeSpawn;
-  const env = deps.env ?? process.env;
-  const command = resolveSupervisorJudgmentCommand(env);
-  const cwd = resolveSupervisorJudgmentCwd(env);
-  return new Promise((resolve2, reject) => {
-    let settled = false;
-    let stdout = "";
-    let child;
-    try {
-      child = spawnFn(command, ["-m", SUPERVISOR_JUDGMENT_PYTHON_MODULE], {
-        cwd,
-        shell: false,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    } catch {
-      reject(new SupervisorJudgmentError("python judgment process could not be started"));
-      return;
-    }
-    const finish = (fn, value) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      fn(value);
-    };
-    const timer = setTimeout(() => {
-      try {
-        child.kill("SIGKILL");
-      } catch {
-      }
-      finish(reject, new SupervisorJudgmentError("python judgment timed out"));
-    }, config.llm_timeout_ms);
-    child.on(
-      "error",
-      () => finish(reject, new SupervisorJudgmentError("python judgment process error"))
-    );
-    child.stdout?.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.on("close", (code) => {
-      if (code !== 0) {
-        finish(reject, new SupervisorJudgmentError("python judgment exited non-zero"));
-        return;
-      }
-      try {
-        const parsed = parseSupervisorJudgmentResponse(stdout.trim());
-        finish(resolve2, parsed);
-      } catch {
-        finish(reject, new SupervisorJudgmentError("python judgment returned malformed output"));
-      }
-    });
-    try {
-      child.stdin?.write(JSON.stringify(buildRequestPayload(request, env)));
-      child.stdin?.end();
-    } catch {
-      finish(reject, new SupervisorJudgmentError("python judgment stdin write failed"));
-    }
-  });
-}
-function createDefaultSupervisorJudgmentClient(config, deps = {}) {
-  return (request) => requestPythonSupervisorJudgment(request, config, deps);
-}
-var SUPERVISOR_JUDGMENT_PYTHON_MODULE;
-var init_supervisor_judgment_python = __esm({
-  "src/conductor/supervisor-judgment-python.ts"() {
-    "use strict";
-    init_supervisor_judgment();
-    SUPERVISOR_JUDGMENT_PYTHON_MODULE = "src.python.conductor.supervisor_judgment";
-  }
-});
-
 // src/conductor/supervisor-runtime.ts
 var supervisor_runtime_exports = {};
 __export(supervisor_runtime_exports, {
   runSupervisor: () => runSupervisor
 });
-function compactWorkerForJudgment(worker) {
-  if (!worker) return null;
-  return {
-    worker_id: worker.worker_id,
-    ticket_key: worker.ticket_key,
-    state: worker.state,
-    liveness: worker.liveness,
-    last_event_time: worker.last_event_time,
-    last_progress_time: worker.last_progress_time
-  };
-}
 function deterministicAssessment(candidate) {
   return {
     classification: "stuck",
     confidence: 1,
-    should_escalate: true,
-    reason: candidate.reason,
-    draft_escalation_text: null,
-    source: "degraded"
+    reason: candidate.reason
   };
 }
 function terminalStatus(state) {
   const anyFailed = Object.values(state.workers).some((w) => w.state === "failed");
   return anyFailed ? "failed" : "complete";
 }
-async function processEscalations(state, config, client, deps) {
+async function processEscalations(state, config, deps) {
   const now = deps.now();
   const candidates = findSupervisorEscalationCandidates(state, config, now);
   for (const candidate of candidates) {
@@ -11010,26 +12819,8 @@ async function processEscalations(state, config, client, deps) {
       cooldown_window: decision.cooldown_window
     };
     const idempotencyKey = makeSupervisorIdempotencyKey(idempotency);
-    let assessment;
-    if (candidate.ambiguous) {
-      assessment = await assessSupervisorCandidate(
-        {
-          run_id: state.run_id,
-          candidate,
-          worker: candidate.worker_id ? compactWorkerForJudgment(state.workers[candidate.worker_id]) : null
-        },
-        config,
-        state.llm_budget,
-        client
-      );
-    } else {
-      assessment = deterministicAssessment(candidate);
-    }
+    const assessment = deterministicAssessment(candidate);
     state.latest_assessment = assessment;
-    if (!assessment.should_escalate) {
-      recordEscalationResult(state, candidate, decision.cooldown_window, idempotencyKey, "suppressed", now);
-      continue;
-    }
     let outcome = "skipped";
     try {
       const result = await deps.emitAssessment({
@@ -11053,7 +12844,7 @@ async function processEscalations(state, config, client, deps) {
       }
     }
     if (outcome === "emitted") {
-      deps.log(formatEscalationForTerminal(state.run_id, candidate, assessment.draft_escalation_text));
+      deps.log(formatEscalationForTerminal(state.run_id, candidate));
       if (deps.dispatchNotification) {
         try {
           await deps.dispatchNotification(state.run_id, candidate, assessment, idempotencyKey);
@@ -11079,7 +12870,6 @@ async function runSupervisor(options, deps = {}) {
   const upsertProjection = deps.upsertProjection ?? upsertSupervisorProjection;
   const emitAssessment = deps.emitAssessment ?? emitSupervisorAssessmentIfNew;
   const sendMessage = deps.sendWorkerMessage ?? sendWorkerMessage;
-  const judgmentClient = deps.judgmentClient ?? createDefaultSupervisorJudgmentClient(config);
   const resolveBridgeAccess = deps.resolveBridgeAccess ?? (() => resolveConductorBridgeApiAccess());
   const processMerge = deps.processMerge ?? processGateMetMerge;
   const dispatchNotification = deps.dispatchNotification ?? dispatchSupervisorNotification;
@@ -11180,7 +12970,7 @@ async function runSupervisor(options, deps = {}) {
         await processGateMetMerges(sorted);
       }
       applySupervisorHousekeeping(state, config, now());
-      await processEscalations(state, config, judgmentClient, {
+      await processEscalations(state, config, {
         emitAssessment,
         sendWorkerMessage: sendMessage,
         log,
@@ -11225,9 +13015,7 @@ var init_supervisor_runtime = __esm({
     init_supervisor_config();
     init_supervisor_state();
     init_supervisor_escalation();
-    init_supervisor_judgment();
     init_supervisor_ledger();
-    init_supervisor_judgment_python();
     init_bridge_api_client();
     init_merge_ledger();
     init_supervisor_merge();
@@ -11243,6 +13031,7 @@ init_taxonomy();
 import { readFileSync as readFileSync2, unlinkSync } from "node:fs";
 
 // src/conductor/git-hooks.ts
+init_git_inspection();
 import {
   chmodSync,
   existsSync as existsSync2,
@@ -11253,131 +13042,6 @@ import {
 } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-
-// src/conductor/git-inspection.ts
-init_git_ci_types();
-import { execFileSync as execFileSync2 } from "node:child_process";
-import { basename } from "node:path";
-var GIT_COMMAND_TIMEOUT_MS = 5e3;
-var GIT_COMMAND_MAX_BUFFER = 10 * 1024 * 1024;
-function runGitCommand(args, options = {}) {
-  try {
-    const stdout = execFileSync2("git", args, {
-      cwd: options.cwd,
-      timeout: options.timeoutMs ?? GIT_COMMAND_TIMEOUT_MS,
-      encoding: "utf-8",
-      maxBuffer: GIT_COMMAND_MAX_BUFFER,
-      // Capture stdout only; ignore stdin and stderr so raw error text (which may
-      // include credentials) is never read back. `shell` defaults to false.
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    return { ok: true, stdout: typeof stdout === "string" ? stdout : "" };
-  } catch {
-    return { ok: false, stdout: "" };
-  }
-}
-function firstLine(result) {
-  if (!result.ok) return null;
-  const trimmed = result.stdout.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-function sanitizeGitRemoteUrl(url) {
-  if (typeof url !== "string") return null;
-  const trimmed = url.trim();
-  if (trimmed.length === 0) return null;
-  if (/^https?:\/\//i.test(trimmed)) {
-    try {
-      const parsed = new URL(trimmed);
-      parsed.username = "";
-      parsed.password = "";
-      return parsed.toString();
-    } catch {
-      return trimmed.replace(/^(https?:\/\/)[^/@]*@/i, "$1");
-    }
-  }
-  return trimmed;
-}
-function getGitWorktreeContext(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const env = options.env ?? process.env;
-  const topLevel = firstLine(runGitCommand(["rev-parse", "--show-toplevel"], { cwd }));
-  const isWorktree = topLevel !== null;
-  const worktreePath = topLevel ?? cwd;
-  const gitCommonDir = firstLine(runGitCommand(["rev-parse", "--git-common-dir"], { cwd }));
-  const branchRaw = firstLine(runGitCommand(["rev-parse", "--abbrev-ref", "HEAD"], { cwd }));
-  const branch = branchRaw === null || branchRaw === "HEAD" ? null : branchRaw;
-  const headSha = normalizeSha(firstLine(runGitCommand(["rev-parse", "HEAD"], { cwd })) ?? "");
-  const remoteOrigin = sanitizeGitRemoteUrl(
-    firstLine(runGitCommand(["config", "--get", "remote.origin.url"], { cwd })) ?? ""
-  );
-  const repo = normalizeRepoName(env.BAPI_CONDUCTOR_REPO_NAME) ?? normalizeRepoName(env.BAPI_REPO_NAME) ?? normalizeRepoName(basename(worktreePath)) ?? "unknown";
-  return {
-    repo,
-    worktree_path: worktreePath,
-    git_common_dir: gitCommonDir,
-    branch,
-    head_sha: headSha,
-    remote_origin: remoteOrigin,
-    is_worktree: isWorktree
-  };
-}
-var CO_AUTHOR_RE = /^co-authored-by:\s*(.+?)\s*<([^<>@\s]+@[^<>\s]+)>\s*$/i;
-function parseCoAuthoredByTrailers(message) {
-  if (typeof message !== "string" || message.length === 0) return [];
-  const out = [];
-  for (const line of message.split(/\r?\n/)) {
-    const match = CO_AUTHOR_RE.exec(line.trim());
-    if (match) {
-      out.push({ name: match[1].trim(), email: match[2].trim() });
-    }
-  }
-  return out;
-}
-var COMMIT_FORMAT = "%H%x1f%P%x1f%an%x1f%ae%x1f%cn%x1f%ce%x1f%aI%x1f%cI%x1f%s%x1f%b";
-function readHeadCommitMetadata(options = {}) {
-  const ref = options.ref ?? "HEAD";
-  const result = runGitCommand(["show", "-s", `--format=${COMMIT_FORMAT}`, ref], { cwd: options.cwd });
-  if (!result.ok) return null;
-  const fields = result.stdout.replace(/\n$/, "").split("");
-  if (fields.length < 10) return null;
-  const [sha, parentsRaw, authorName, authorEmail, committerName, committerEmail, authoredAt, committedAt, subject, body] = fields;
-  const parents = parentsRaw.trim().split(/\s+/).map((p) => normalizeSha(p)).filter((p) => p !== null);
-  const coAuthors = parseCoAuthoredByTrailers(body);
-  return {
-    sha: normalizeSha(sha),
-    parents,
-    author_name: authorName,
-    author_email: authorEmail,
-    committer_name: committerName,
-    committer_email: committerEmail,
-    authored_at: authoredAt,
-    committed_at: committedAt,
-    subject,
-    body,
-    co_authors: coAuthors,
-    attribution_source: coAuthors.length > 0 ? "co-authored-by-trailer" : "commit-author"
-  };
-}
-var REF_CONTROL_CHAR_RE = /[\u0000-\u001F\u007F]/;
-function parseReferenceTransactionUpdates(stdin) {
-  if (typeof stdin !== "string" || stdin.length === 0) return [];
-  const out = [];
-  for (const line of stdin.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) continue;
-    const parts = trimmed.split(/\s+/);
-    if (parts.length !== 3) continue;
-    const oldSha = normalizeSha(parts[0]);
-    const newSha = normalizeSha(parts[1]);
-    const ref = parts[2];
-    if (oldSha === null || newSha === null) continue;
-    if (ref.length === 0 || REF_CONTROL_CHAR_RE.test(ref)) continue;
-    out.push({ old_sha: oldSha, new_sha: newSha, ref });
-  }
-  return out;
-}
-
-// src/conductor/git-hooks.ts
 var BRIDGE_CONDUCTOR_HOOK_START = "# >>> BRIDGE_CONDUCTOR_HOOK_START >>>";
 var BRIDGE_CONDUCTOR_HOOK_END = "# <<< BRIDGE_CONDUCTOR_HOOK_END <<<";
 var MANAGED_HOOK_NAMES = ["post-commit", "reference-transaction"];
@@ -11532,8 +13196,12 @@ function inspectConductorGitHooks(deps = {}) {
   return { is_worktree: true, hooks_dir, hooks, warnings, degraded };
 }
 
+// src/conductor/cli.ts
+init_file_scope_guard();
+
 // src/conductor/git-producer.ts
 init_git_ci_types();
+init_git_inspection();
 init_producer_ledger();
 var COMMITTED_REF_PHASE = "committed";
 function buildCommitCreatedEventInput(context, metadata) {
@@ -11636,7 +13304,7 @@ async function runReferenceTransactionHookProducer(args, deps = {}) {
 
 // src/conductor/doctor.ts
 init_store();
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 async function inspectEpicTickSchedule(deps, orchestrateListOverride) {
   try {
     const schedRun = orchestrateListOverride ? null : await Promise.resolve().then(() => (init_schedule_run(), schedule_run_exports));
@@ -11706,7 +13374,7 @@ function inspectMcpProfile(env, epicTick) {
 function inspectLocalMerge(runCommand) {
   const run = runCommand ?? ((cmd, args) => {
     try {
-      const r = spawnSync(cmd, args, {
+      const r = spawnSync2(cmd, args, {
         encoding: "utf8",
         timeout: 1e4,
         env: { ...process.env, GH_PROMPT_DISABLED: "1" }
@@ -11856,14 +13524,14 @@ 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",
@@ -11960,7 +13628,8 @@ var VALID_COMMANDS = /* @__PURE__ */ new Set([
   "doctor",
   "purge",
   "install-git-hooks",
-  "git-hook"
+  "git-hook",
+  "file-scope-guard"
 ]);
 function parseConductorArgs(argv) {
   if (argv.length === 0) return { kind: "help" };
@@ -12036,7 +13705,7 @@ function parseJsonFlag(raw, flag) {
     throw new ConductorValidationError(`Flag "${flag}" must be valid JSON.`);
   }
 }
-function isPlainObject2(value) {
+function isPlainObject4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function parseEmitEventArgs(argv, deps = {}) {
@@ -12060,13 +13729,13 @@ function parseEmitEventArgs(argv, deps = {}) {
     const readStdin = deps.readStdin ?? defaultReadStdin;
     const stdinRaw = readStdin();
     const parsed = parseJsonFlag(stdinRaw, "--data-json-stdin");
-    if (!isPlainObject2(parsed)) {
+    if (!isPlainObject4(parsed)) {
       throw new ConductorValidationError('Flag "--data-json-stdin" must be a JSON object.');
     }
     data = { ...parsed };
   } else if (dataJsonRaw !== void 0) {
     const parsed = parseJsonFlag(dataJsonRaw, "--data-json");
-    if (!isPlainObject2(parsed)) {
+    if (!isPlainObject4(parsed)) {
       throw new ConductorValidationError('Flag "--data-json" must be a JSON object.');
     }
     data = { ...parsed };
@@ -12074,10 +13743,10 @@ function parseEmitEventArgs(argv, deps = {}) {
   const rawJsonRaw = values.get("--raw-json");
   if (rawJsonRaw !== void 0) {
     const parsedRaw = parseJsonFlag(rawJsonRaw, "--raw-json");
-    if (!isPlainObject2(parsedRaw)) {
+    if (!isPlainObject4(parsedRaw)) {
       throw new ConductorValidationError('Flag "--raw-json" must be a JSON object.');
     }
-    const existingRaw = isPlainObject2(data.raw) ? data.raw : {};
+    const existingRaw = isPlainObject4(data.raw) ? data.raw : {};
     data.raw = { ...existingRaw, ...parsedRaw };
   }
   const payloadRef = values.get("--payload-ref");
@@ -12167,13 +13836,13 @@ function parseSendMessageArgs(argv, deps = {}) {
   if (payloadStdin) {
     const readStdin = deps.readStdin ?? defaultReadStdin;
     const parsed = parseJsonFlag(readStdin(), "--payload-json-stdin");
-    if (!isPlainObject2(parsed)) {
+    if (!isPlainObject4(parsed)) {
       throw new ConductorValidationError('Flag "--payload-json-stdin" must be a JSON object.');
     }
     payload = { ...parsed };
   } else if (payloadInline !== void 0) {
     const parsed = parseJsonFlag(payloadInline, "--payload-json");
-    if (!isPlainObject2(parsed)) {
+    if (!isPlainObject4(parsed)) {
       throw new ConductorValidationError('Flag "--payload-json" must be a JSON object.');
     }
     payload = { ...parsed };
@@ -12565,10 +14234,9 @@ var SUPERVISE_VALUE_FLAGS = /* @__PURE__ */ new Set([
   "--run-id",
   "--wake-interval-ms",
   "--global-timeout-ms",
-  "--llm-budget-calls",
   "--escalation-cooldown-ms"
 ]);
-var SUPERVISE_BOOL_FLAGS = /* @__PURE__ */ new Set(["--no-llm", "--help"]);
+var SUPERVISE_BOOL_FLAGS = /* @__PURE__ */ new Set(["--help"]);
 function parsePositiveIntFlag(values, flag) {
   const raw = values.get(flag);
   if (raw === void 0) return void 0;
@@ -12595,11 +14263,8 @@ function parseSuperviseArgs(argv) {
   if (wake !== void 0) overrides.wake_interval_ms = wake;
   const globalTimeout = parsePositiveIntFlag(values, "--global-timeout-ms");
   if (globalTimeout !== void 0) overrides.global_timeout_ms = globalTimeout;
-  const llmCalls = parsePositiveIntFlag(values, "--llm-budget-calls");
-  if (llmCalls !== void 0) overrides.llm_max_calls = llmCalls;
   const cooldown = parsePositiveIntFlag(values, "--escalation-cooldown-ms");
   if (cooldown !== void 0) overrides.escalation_cooldown_ms = cooldown;
-  if (bools.has("--no-llm")) overrides.llm_enabled = false;
   return { runId: runIdRaw.trim(), overrides, help: false };
 }
 async function runSuperviseCommand(argv) {
@@ -12610,7 +14275,7 @@ 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"}`
+    `[supervisor] starting run=${parsed.runId} wake=${config.wake_interval_ms}ms global_timeout=${config.global_timeout_ms}ms`
   );
   const { runSupervisor: runSupervisor2 } = await Promise.resolve().then(() => (init_supervisor_runtime(), supervisor_runtime_exports));
   const result = await runSupervisor2({ run_id: parsed.runId, config });
@@ -12671,6 +14336,8 @@ async function runConductorCli(argv) {
         return runInstallGitHooksCommand(parsed.argv);
       case "git-hook":
         return await runGitHookCommand(parsed.argv);
+      case "file-scope-guard":
+        return runFileScopeGuardCli();
       default:
         console.error('Error: Unknown command. Run "conductor --help" for usage.');
         return 1;