@bridge_gpt/mcp-server 0.2.14 → 0.2.18

package/build/conductor/merge-ledger.js

@@ -16,82 +16,27 @@
  * It performs NO privileged action and never handles VCS write credentials.
  */
 import { createHash } from "node:crypto";
-import { normalizePrNumber, normalizeRepoName, normalizeSha } from "./git-ci-types.js";
+import { getMergeIdentity } from "./event-accessors.js";
+import { buildGateIdentity, makeMergeActionKey, } from "./merge-identity.js";
 import { emitConductorEvent, openReadonlyConductorDatabaseIfExists, } from "./store.js";
-/**
- * Compose the stable gate-identity segment, mirroring the Python
- * `normalize_gate_identity`: `{name}@{config_hash}` when a hash is present
- * (lower-cased), otherwise just the gate name.
- */
-export function buildGateIdentity(gateName, configHash) {
-    const name = gateName.trim();
-    const hash = typeof configHash === "string" ? configHash.trim() : "";
-    return hash ? `${name}@${hash.toLowerCase()}` : name;
-}
-/**
- * Build the deterministic action key. Normalizes repo / PR / head SHA exactly as
- * the Python side does (lower-cased SHA, trimmed repo, positive integer PR) so the
- * conductor-computed key and the API-recomputed key are byte-identical. Throws on
- * any invalid component. The branch name is never part of the key.
- */
-export function makeMergeActionKey(repo, prNumber, headSha, gateIdentity) {
-    const r = normalizeRepoName(repo);
-    const pr = normalizePrNumber(prNumber);
-    const sha = normalizeSha(headSha);
-    const gate = (gateIdentity ?? "").trim();
-    if (r === null || pr === null || sha === null || gate.length === 0) {
-        throw new Error("invalid merge action key component");
-    }
-    return `merge:${r}:${pr}:${sha}:${gate}`;
-}
+// BAPI-493: the merge-identity primitives now live in the dependency-light
+// `merge-identity.ts` module (so the typed event-accessor layer can build a
+// MergeActionIdentity without an import cycle). They are re-exported here so
+// existing importers (`supervisor-merge.ts`, tests) keep a stable API surface.
+export { buildGateIdentity, makeMergeActionKey };
 /**
  * Resolve the immutable merge identity from a `gate.met` event. Returns `null`
  * unless the event is a worker-scoped `gate.met` carrying a complete PR binding
  * (repo, pr_number, head_sha, gate_name). Run-level or incomplete events yield
  * `null`. Branch-name fields, if present, are ignored.
+ *
+ * BAPI-493: canonical parsing now lives in the typed accessor layer — this is a
+ * thin compatibility wrapper over {@link getMergeIdentity} so `supervisor-merge.ts`
+ * and other callers keep an unchanged call site while the hand-rolled
+ * `data.details` reader is retired.
  */
 export function extractMergeActionIdentityFromGateEvent(event) {
-    if (event.type !== "gate.met")
-        return null;
-    // Worker scope is required — a run-level gate.met never binds a specific worker.
-    if (typeof event.worker_id !== "string" || event.worker_id.trim().length === 0) {
-        return null;
-    }
-    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;
-    }
-    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 actionKey = makeMergeActionKey(repo, prNumber, headSha, gateIdentity);
-    return {
-        repo,
-        pr_number: prNumber,
-        head_sha: headSha,
-        gate_name: gateName,
-        config_hash: configHash,
-        required_checks: requiredChecks,
-        gate_identity: gateIdentity,
-        action_key: actionKey,
-        gate_event: {
-            id: typeof event.id === "string" ? event.id : undefined,
-            seq: typeof event.seq === "number" ? event.seq : undefined,
-            time: typeof event.time === "string" ? event.time : undefined,
-        },
-    };
+    return getMergeIdentity(event);
 }
 /**
  * Derive a deterministic, UUID-shaped event id from the event type plus action

package/build/conductor/plan.js

@@ -31,12 +31,16 @@ import { stableJsonHash } from "./git-ci-types.js";
  *
  *   - Trims outer whitespace from every `ticket_key` (nodes and edges).
  *   - Sorts each node's `depends_on` array alphabetically.
+ *   - Sorts each node's `touched_files` array alphabetically, when present.
  *   - Sorts `nodes` lexicographically by normalized `ticket_key`.
  *   - Sorts `edges` lexicographically by `from` then `to`.
+ *   - Sorts each edge's `overlap_files` array alphabetically, when present.
  *
  * The canonical form is fed to {@link hashPlan} / `stableJsonHash`, which
  * additionally sorts object keys recursively, so two independently constructed
- * equal plans always produce a byte-identical SHA-256 digest.
+ * equal plans always produce a byte-identical SHA-256 digest. Only fields
+ * already present on the input are normalized — canonicalization never
+ * derives new data from filesystem, git, network, or LLM state.
  */
 export function canonicalizePlanDAG(plan) {
     const nodes = plan.nodes
@@ -44,10 +48,16 @@ export function canonicalizePlanDAG(plan) {
         ...node,
         ticket_key: node.ticket_key.trim(),
         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() }))
+        .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);

package/build/conductor/pr-discovery.js

@@ -11,6 +11,7 @@
  */
 import { execFileSync } from "node:child_process";
 import { normalizePrNumber, normalizeRepoName, normalizeSha } from "./git-ci-types.js";
+import { parseGhPrMergeabilityFields } from "./github-mergeability.js";
 import { getGitWorktreeContext } from "./git-inspection.js";
 /** Bounded timeout for the one-shot `gh` lookup. */
 export const GH_COMMAND_TIMEOUT_MS = 5_000;
@@ -30,7 +31,13 @@ export function runGhCommand(args, options = {}) {
         return { ok: false, stdout: "" };
     }
 }
-const GH_PR_VIEW_ARGS = ["pr", "view", "--json", "number,headRefOid,headRefName,url,state"];
+const 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",
+];
 /**
  * Perform a one-shot `gh pr view` lookup for the current branch's PR. Returns a
  * normalized {@link DiscoveredPr} or `null` when gh is unavailable, there is no
@@ -55,10 +62,13 @@ export function discoverPrWithGhCli(options = {}, deps = {}) {
     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();

package/build/conductor/supervisor-config.js

@@ -2,15 +2,10 @@
  * Supervisor configuration resolution (BAPI-396, conductor C4).
  *
  * Centralizes the supervisor's wake cadence, global timeout, per-state stall
- * thresholds, liveness thresholds, escalation cooldown, and LLM budget caps.
- * All values are resolved from `process.env` with conservative, bounded defaults
- * following the style of {@link resolveConductorStoreConfig} in `store.ts`:
- * malformed values fall back to the default and excessive values are clamped.
- *
- * Token discipline: the WAKE cadence (frequent, deterministic event polling) is
- * intentionally separate from the LLM cadence (judgment-triggered only). The
- * deterministic loop runs every `wake_interval_ms`; the LLM is consulted at most
- * `llm_max_calls` times per run and only for ambiguous escalation candidates.
+ * thresholds, liveness thresholds, and escalation cooldown. All values are
+ * resolved from `process.env` with conservative, bounded defaults following the
+ * style of {@link resolveConductorStoreConfig} in `store.ts`: malformed values
+ * fall back to the default and excessive values are clamped.
  */
 const MINUTE_MS = 60_000;
 const HOUR_MS = 60 * MINUTE_MS;
@@ -36,13 +31,6 @@ const LIVENESS_STALLED_AFTER_MAX_MS = 4 * HOUR_MS;
 const DEAD_AFTER_DEFAULT_MS = 2 * HOUR_MS;
 const DEAD_AFTER_MIN_MS = 10 * MINUTE_MS;
 const DEAD_AFTER_MAX_MS = 24 * HOUR_MS;
-// --- LLM budget. ----------------------------------------------------------
-const LLM_MAX_CALLS_DEFAULT = 10;
-const LLM_MAX_CALLS_MIN = 0;
-const LLM_MAX_CALLS_MAX = 1000;
-const LLM_TIMEOUT_DEFAULT_MS = 30_000;
-const LLM_TIMEOUT_MIN_MS = 1_000;
-const LLM_TIMEOUT_MAX_MS = 120_000;
 /**
  * Parse a bounded integer from an env-style string. Mirrors `parseBoundedInt`
  * in `store.ts`: blank/undefined/non-finite/float-with-fraction/non-numeric
@@ -68,19 +56,6 @@ export function parseBoundedSupervisorInt(raw, fallback, min, max) {
 const POLL_LIMIT_DEFAULT = 200;
 const POLL_LIMIT_MIN = 1;
 const POLL_LIMIT_MAX = 1000;
-/** Truthy parse for boolean-ish env strings (`0`/`false`/`off`/`no` => false). */
-function parseBoolEnv(raw, fallback) {
-    if (raw === undefined)
-        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;
-}
 /**
  * Resolve the supervisor configuration. Precedence per field: a direct override
  * (when provided and valid) wins over the environment, which wins over the
@@ -96,13 +71,6 @@ export function resolveSupervisorConfig(overrides = {}, env = process.env) {
     const quiet_after_ms = parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_QUIET_AFTER_MS, QUIET_AFTER_DEFAULT_MS, QUIET_AFTER_MIN_MS, QUIET_AFTER_MAX_MS);
     const liveness_stalled_after_ms = parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_LIVENESS_STALLED_AFTER_MS, LIVENESS_STALLED_AFTER_DEFAULT_MS, LIVENESS_STALLED_AFTER_MIN_MS, LIVENESS_STALLED_AFTER_MAX_MS);
     const dead_after_ms = parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_DEAD_AFTER_MS, DEAD_AFTER_DEFAULT_MS, DEAD_AFTER_MIN_MS, DEAD_AFTER_MAX_MS);
-    // LLM is enabled by default but degrades cleanly. A direct `llm_enabled:false`
-    // override (e.g. CLI `--no-llm`) forces deterministic-only mode.
-    const llm_enabled = overrides.llm_enabled !== undefined
-        ? 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_DEFAULT, POLL_LIMIT_MIN, POLL_LIMIT_MAX);
     return {
         wake_interval_ms,
@@ -114,9 +82,6 @@ export function resolveSupervisorConfig(overrides = {}, env = process.env) {
             dead_after_ms,
         },
         escalation_cooldown_ms,
-        llm_enabled,
-        llm_max_calls,
-        llm_timeout_ms,
         poll_limit,
     };
 }

package/build/conductor/supervisor-escalation.js

@@ -34,8 +34,7 @@ function elapsedSinceSignal(worker, now) {
  * Inspect run state and return deterministic escalation candidates. Reasons:
  * `worker_not_started`, `worker_stalled`, `worker_blocked`, `worker_dead`,
  * `candidate_done_stuck`, `verification_stalled`, and `global_timeout`. Terminal
- * workers never produce candidates. `ambiguous` marks candidates that benefit
- * from an LLM judgment (long-running stalls) vs. unambiguous ones.
+ * workers never produce candidates.
  */
 export function findSupervisorEscalationCandidates(state, config, now) {
     const candidates = [];
@@ -59,7 +58,6 @@ export function findSupervisorEscalationCandidates(state, config, now) {
                 state: worker.state,
                 liveness: worker.liveness,
                 elapsed_ms: elapsed,
-                ambiguous: false,
                 context: baseContext,
             });
             continue;
@@ -82,7 +80,6 @@ export function findSupervisorEscalationCandidates(state, config, now) {
                         state: worker.state,
                         liveness: worker.liveness,
                         elapsed_ms: elapsed,
-                        ambiguous: false,
                         context: baseContext,
                     });
                 }
@@ -95,7 +92,6 @@ export function findSupervisorEscalationCandidates(state, config, now) {
                     state: worker.state,
                     liveness: worker.liveness,
                     elapsed_ms: elapsed,
-                    ambiguous: false,
                     context: { ...baseContext, blocked_reason: worker.blocked_reason },
                 });
                 break;
@@ -107,7 +103,6 @@ export function findSupervisorEscalationCandidates(state, config, now) {
                     state: worker.state,
                     liveness: worker.liveness,
                     elapsed_ms: elapsed,
-                    ambiguous: true,
                     context: baseContext,
                 });
                 break;
@@ -124,7 +119,6 @@ export function findSupervisorEscalationCandidates(state, config, now) {
                         state: worker.state,
                         liveness: worker.liveness,
                         elapsed_ms: elapsed,
-                        ambiguous: true,
                         context: baseContext,
                     });
                 }
@@ -141,7 +135,6 @@ export function findSupervisorEscalationCandidates(state, config, now) {
                         state: worker.state,
                         liveness: worker.liveness,
                         elapsed_ms: elapsed,
-                        ambiguous: true,
                         context: baseContext,
                     });
                 }
@@ -160,7 +153,6 @@ export 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,
@@ -176,23 +168,20 @@ function cooldownWindowFor(now, cooldownMs) {
     return String(Math.floor(now / width));
 }
 /**
- * Decide whether a candidate should be emitted now. A candidate is SUPPRESSED
+ * Decide whether a candidate should be emitted now. A candidate is a DUPLICATE
  * when an escalation for the same worker + reason was already emitted (or hit a
  * duplicate) within the SAME cooldown window. Returns the cooldown window
  * identifier the caller must pass to `makeSupervisorIdempotencyKey` so the
- * idempotency key and the suppression check agree.
+ * idempotency key and the duplicate check agree.
  */
 export 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"));
+        // 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 };
 }
 /**
@@ -227,18 +216,13 @@ function formatElapsed(ms) {
 }
 /**
  * Render a concise, SECRET-FREE terminal escalation line. Includes run id,
- * worker id, reason, state, liveness, elapsed time, and optional LLM-drafted
- * text. Never includes raw payloads or full JSON dumps.
+ * worker id, reason, state, liveness, and elapsed time. Never includes raw
+ * payloads or full JSON dumps.
  */
-export function formatEscalationForTerminal(runId, candidate, draftText) {
+export 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) {
-        // Single-line the drafted text so the terminal stays scannable.
-        line += ` :: ${draftText.replace(/\s+/g, " ").trim()}`;
-    }
-    return line;
+    return `[supervisor] run=${runId}${worker} reason=${candidate.reason}${stateBit}${liveBit}${elapsed}`;
 }

package/build/conductor/supervisor-ledger.js

@@ -6,9 +6,8 @@
  * concurrent retries, each event carries a deterministic id derived from a
  * STABLE idempotency key. The key is built only from normalized dimensions
  * (run id, optional worker id, reason, kind, cooldown window) — it deliberately
- * EXCLUDES raw event payloads and any LLM free text, so two assessments with
- * different draft text but the same decision collide on the `events.id` UNIQUE
- * constraint instead of double-emitting.
+ * EXCLUDES raw event payloads, so two assessments for the same decision
+ * collide on the `events.id` UNIQUE constraint instead of double-emitting.
  *
  * This module performs NO privileged action: it only writes an audit event to
  * the local ledger.
@@ -22,7 +21,7 @@ function normalizeDimension(value) {
 /**
  * Build a stable idempotency key from normalized dimensions. Whitespace and
  * case are normalized; empty/undefined `worker_id` collapses to a fixed
- * run-level token. NO raw payload or LLM free text ever enters the key.
+ * run-level token. NO raw payload ever enters the key.
  */
 export function makeSupervisorIdempotencyKey(meta) {
     const parts = [
@@ -75,8 +74,7 @@ export async function emitSupervisorAssessmentIfNew(input, deps = {}) {
     const emitEvent = deps.emitEvent ?? emitConductorEvent;
     const idempotencyKey = makeSupervisorIdempotencyKey(input.idempotency);
     const eventId = makeSupervisorAssessmentEventId(idempotencyKey);
-    // Build secret-free assessment details. The assessment carries only the
-    // classification/decision and optional short drafted text — never raw payload.
+    // Build secret-free deterministic assessment details — never raw payload.
     const details = {
         ...(input.details ?? {}),
         idempotency_key: idempotencyKey,
@@ -85,12 +83,7 @@ export async function emitSupervisorAssessmentIfNew(input, deps = {}) {
         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,
     };
-    if (input.assessment.draft_escalation_text) {
-        details.draft_escalation_text = input.assessment.draft_escalation_text;
-    }
     const event = {
         id: eventId,
         source: "conductor-supervisor",
@@ -101,7 +94,7 @@ export 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,
         },

package/build/conductor/supervisor-message-relay.js

@@ -28,11 +28,8 @@ export function buildSupervisorEscalationWorkerMessage(candidate, assessment, st
         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,
@@ -40,7 +37,7 @@ export function buildSupervisorEscalationWorkerMessage(candidate, assessment, st
         cause_seq: state.last_seq,
         payload: {
             summary: `supervisor escalation: ${candidate.reason}`,
-            status: assessment.should_escalate ? "escalated" : "noted",
+            status: "escalated",
             details,
         },
         source: "conductor-supervisor",

package/build/conductor/supervisor-notification.js

@@ -23,7 +23,7 @@ export async function dispatchSupervisorNotification(epicRunId, candidate, asses
             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 = {

package/build/conductor/supervisor-runtime.js

@@ -12,13 +12,10 @@
  *   2. supervisor_projection — the resumable operational mirror (this loop owns
  *      writes; crash/restart re-hydrates from it).
  *   3. supervisor.assessment events — AUDIT ONLY; never override raw truth.
- *   4. LLM judgment context — DISPOSABLE; advisory text only, never persisted as
- *      truth and never able to execute an action.
  *
- * The deterministic loop owns correctness. The LLM is consulted only to classify
- * AMBIGUOUS stalls and draft escalation text, within a per-run budget, and
- * degrades to deterministic-only behavior whenever it is disabled, exhausted, or
- * fails.
+ * The deterministic loop owns correctness and always escalates a detected
+ * candidate (BAPI-496): there is no LLM judgment boundary and no suppression
+ * path.
  */
 import { waitForConductorEvent, getSupervisorSnapshot, upsertSupervisorProjection, sendWorkerMessage, } from "./store.js";
 import { emitSupervisorAssessmentIfNew } from "./supervisor-ledger.js";
@@ -26,36 +23,18 @@ import { sendSupervisorEscalationWorkerMessageIfNew } from "./supervisor-message
 import { resolveSupervisorConfig } from "./supervisor-config.js";
 import { hydrateSupervisorRunStateFromSnapshot, applyConductorEventToSupervisorState, applySupervisorHousekeeping, isSupervisorRunTerminal, hasSupervisorGlobalTimeoutElapsed, toSupervisorProjectionInput, } from "./supervisor-state.js";
 import { findSupervisorEscalationCandidates, shouldEmitEscalation, recordEscalationResult, formatEscalationForTerminal, } from "./supervisor-escalation.js";
-import { assessSupervisorCandidate } from "./supervisor-judgment.js";
 import { makeSupervisorIdempotencyKey } from "./supervisor-ledger.js";
-import { createDefaultSupervisorJudgmentClient } from "./supervisor-judgment-python.js";
 import { resolveConductorBridgeApiAccess, } from "./bridge-api-client.js";
 import { extractMergeActionIdentityFromGateEvent } from "./merge-ledger.js";
 import { processGateMetMerge } from "./supervisor-merge.js";
 import { dispatchSupervisorNotification } from "./supervisor-notification.js";
 import { ConductorValidationError } from "./errors.js";
-/** Compact, secret-free worker snapshot for the judgment request. */
-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,
-    };
-}
-/** Deterministic (degraded) assessment for an unambiguous candidate. */
+/** Deterministic assessment for an escalation candidate. */
 function deterministicAssessment(candidate) {
     return {
         classification: "stuck",
         confidence: 1,
-        should_escalate: true,
         reason: candidate.reason,
-        draft_escalation_text: null,
-        source: "degraded",
     };
 }
 /** Resolve the terminal run status from worker outcomes. */
@@ -64,20 +43,20 @@ function terminalStatus(state) {
     return anyFailed ? "failed" : "complete";
 }
 /**
- * Process the escalation pipeline for the current state: find candidates, assess
- * ambiguous ones (within budget), emit idempotent assessment events, print
+ * Process the escalation pipeline for the current state: find candidates,
+ * deterministically assess them, emit idempotent assessment events, print
  * terminal lines for newly-emitted escalations, and record outcomes. Returns
  * nothing; it mutates `state`.
  */
-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) {
         const decision = shouldEmitEscalation(state, candidate, config, now);
         if (!decision.emit)
             continue;
-        // Compute the idempotency key up front so EVERY decision in this window —
-        // including an LLM "do not escalate" — can be recorded under it.
+        // Compute the idempotency key up front so the decision in this window can
+        // be recorded under it.
         const idempotency = {
             run_id: state.run_id,
             worker_id: candidate.worker_id,
@@ -86,28 +65,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) {
-            // The judgment declined to escalate. Record a `suppressed` decision for
-            // this cooldown window so the candidate is NOT re-judged every wake
-            // interval — without this, a persistently-ambiguous worker would re-query
-            // the LLM each tick, exhaust the per-run budget, and then escalate anyway
-            // once the degraded fallback kicks in. The decision stands until the
-            // window rolls over.
-            recordEscalationResult(state, candidate, decision.cooldown_window, idempotencyKey, "suppressed", now);
-            continue;
-        }
         let outcome = "skipped";
         try {
             const result = await deps.emitAssessment({
@@ -145,7 +104,7 @@ async function processEscalations(state, config, client, deps) {
         // Only print on a genuinely NEW escalation — never re-spam a duplicate after
         // a crash/restart within the same cooldown window.
         if (outcome === "emitted") {
-            deps.log(formatEscalationForTerminal(state.run_id, candidate, assessment.draft_escalation_text));
+            deps.log(formatEscalationForTerminal(state.run_id, candidate));
             // S7: dispatch an out-of-band human notification for newly emitted escalations.
             // Best-effort: a failure must never stop supervising.
             if (deps.dispatchNotification) {
@@ -179,7 +138,6 @@ export 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;
@@ -304,7 +262,7 @@ export async function runSupervisor(options, deps = {}) {
             // Housekeeping (liveness + state-specific stalls) runs every iteration so a
             // timeout with no events still advances liveness/stall state.
             applySupervisorHousekeeping(state, config, now());
-            await processEscalations(state, config, judgmentClient, {
+            await processEscalations(state, config, {
                 emitAssessment,
                 sendWorkerMessage: sendMessage,
                 log,

package/build/conductor/supervisor-state.js

@@ -48,11 +48,6 @@ export 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),
@@ -93,15 +88,8 @@ export function hydrateSupervisorRunStateFromSnapshot(snapshot, runId, config, n
         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,
@@ -536,11 +524,10 @@ function compactWorker(worker) {
  * holds compact worker summaries (never raw event data); `gates` holds gate
  * metadata; `assessment` holds the latest assessment or null; and `summary`
  * holds the FULL resumable supervisor state (worker watchdog states, liveness,
- * last seq, escalation history, LLM budget usage, run start/deadline metadata).
+ * last seq, escalation history, run start/deadline metadata).
  *
  * The serialized summary is secret-free by construction: it is built only from
- * the compact state fields above — never from raw payloads, secrets, or LLM
- * prompts.
+ * the compact state fields above — never from raw payloads or secrets.
  */
 export function toSupervisorProjectionInput(state) {
     const summary = {
@@ -553,7 +540,6 @@ export 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,

package/build/conductor/supervisor-types.js

@@ -3,8 +3,8 @@
  * (BAPI-396, conductor C4).
  *
  * These are pure TypeScript type declarations with NO runtime behavior so every
- * supervisor module (config, reducer, escalation, judgment, runtime) can depend
- * on them freely without import cycles or side effects.
+ * supervisor module (config, reducer, escalation, runtime) can depend on them
+ * freely without import cycles or side effects.
  *
  * Vocabulary split — the supervisor tracks two ORTHOGONAL axes per worker:
  *   - {@link WatchdogState}: the worker's progress through the run lifecycle