@bridge_gpt/mcp-server 0.2.57 → 0.2.59

package/build/conductor/repair-contract.js

@@ -1,10 +1,11 @@
 /**
- * The shared contract for the run-addressed operator repair verbs (BAPI-1154):
- * `scope-reparse`, `dispatch-remediation`, and `merge-child`.
+ * The shared contract for the six run-addressed operator repair verbs: BAPI-1154's
+ * `scope-reparse`, `dispatch-remediation`, and `merge-child`, and BAPI-1176's
+ * `scope-catch-up`, `patch-policy`, and `resume-run`.
  *
  * CLI-only, exactly like the BAPI-872 recovery verbs: none of these names is ever
  * registered as an MCP tool (`index-static.test.ts` pins that). This module is the
- * TypeScript mirror of `api/library/epic_conductor/operator_repair_contract.py` —
+ * TypeScript mirror of `api/library/epic_implementer/operator_repair_contract.py` —
  * the verb names, the CLOSED refusal-code table, the driver-context byte cap, and
  * the bounded result shapes the Bridge client returns. A parity test keeps the two
  * aligned; the CLI renders the server's code and never infers ownership or state
@@ -16,11 +17,17 @@
 export const VERB_SCOPE_REPARSE = "scope-reparse";
 export const VERB_DISPATCH_REMEDIATION = "dispatch-remediation";
 export const VERB_MERGE_CHILD = "merge-child";
+export const VERB_SCOPE_CATCH_UP = "scope-catch-up";
+export const VERB_PATCH_POLICY = "patch-policy";
+export const VERB_RESUME_RUN = "resume-run";
 /** Every repair verb, in the order an operator meets them. */
 export const OPERATOR_REPAIR_VERBS = [
     VERB_SCOPE_REPARSE,
     VERB_DISPATCH_REMEDIATION,
     VERB_MERGE_CHILD,
+    VERB_SCOPE_CATCH_UP,
+    VERB_PATCH_POLICY,
+    VERB_RESUME_RUN,
 ];
 /**
  * The ONE cap on driver context, in UTF-8 BYTES — the same number the server
@@ -29,7 +36,24 @@ export const OPERATOR_REPAIR_VERBS = [
  * see the operator's complete instruction or none of it.
  */
 export const DRIVER_CONTEXT_MAX_BYTES = 16384;
-/** The closed refusal-code vocabulary, mirroring the server table. */
+/**
+ * The ONE cap on a `patch-policy` merge patch, in UTF-8 BYTES — the same number the
+ * server enforces (`POLICY_PATCH_MAX_BYTES` in `operator_repair_contract.py`). The
+ * CLI checks the patch file's raw bytes before decoding it, so an over-cap patch is
+ * never parsed, printed, or transmitted.
+ */
+export const POLICY_PATCH_MAX_BYTES = 16384;
+/**
+ * The closed refusal-code vocabulary, mirroring the server table.
+ *
+ * Deliberately NOT every code a repair verb can render. `patch-policy` and
+ * `resume-run` run the server's established posture and unattended-activation
+ * checks, and `resume-run` its run-control validation; those refuse with their OWN
+ * structured codes (for example `RUN_CONTROL_MALFORMED`). Such pass-through codes
+ * are not members of this table, yet the CLI renders them exactly like the closed
+ * codes: every refusal is classified from the server's structured `error_code`,
+ * never from this list and never from error prose.
+ */
 export const OPERATOR_REPAIR_REFUSAL_CODES = [
     "TICKET_NOT_IN_RUN",
     "DRIVER_CONTEXT_INVALID",
@@ -50,6 +74,16 @@ export const OPERATOR_REPAIR_REFUSAL_CODES = [
     "MERGE_GATE_UNRESOLVABLE",
     "MERGE_NOT_COMPLETED",
     "MERGE_COMPLETION_REFUSED",
+    // BAPI-1176
+    "SCOPE_CATCH_UP_REFUSED",
+    "SCOPE_CATCH_UP_UNAVAILABLE",
+    "POLICY_PATCH_INVALID",
+    "POLICY_PATH_NOT_PATCHABLE",
+    "POLICY_CHANGED_CONCURRENTLY",
+    "RUN_NOT_RESUMABLE",
+    "RUN_STOPPED",
+    "QUARANTINE_CLEARANCE_REQUIRED",
+    "RUN_CONTROL_CONFLICT",
 ];
 /** True when `code` is one of the closed repair refusal codes. */
 export function isOperatorRepairRefusalCode(code) {

package/build/conductor/spec-review-producer.js

@@ -3,7 +3,7 @@
  *
  * Emits the spec re-review verdict (`spec_review.passed` /
  * `spec_review.changes_requested`) into the LOCAL conductor ledger, correlated
- * to the spec-review run via `BAPI_CONDUCTOR_RUN_ID`. The Epic Supervisor's
+ * to the spec-review run via `BAPI_EPIC_IMPLEMENTER_RUN_ID`. The Epic Supervisor's
  * reconcile pass folds these signals: `passed` → `reviewing → ready` (proceed to
  * implementation), `changes_requested` → `blocked` (escalate; do NOT implement).
  *
@@ -11,7 +11,7 @@
  * ledger is a per-worker SQLite file (`~/.config/bridge/events.db`). The
  * Heroku-hosted Bridge API backend has no access to it. So — exactly like the
  * PR-review producer ({@link ./pr-review-producer}) — the verdict is emitted by
- * the LOCAL spec-review run, whose environment carries `BAPI_CONDUCTOR_RUN_ID`
+ * the LOCAL spec-review run, whose environment carries `BAPI_EPIC_IMPLEMENTER_RUN_ID`
  * (injected at dispatch time by {@link ../review-tickets}.orchestrateReviewTickets
  * when an epic identity is present). This corrects the original BAPI-445 plan,
  * which proposed emitting from the backend review webhook
@@ -64,15 +64,15 @@ export function buildSpecReviewVerdictEventInput(ticketKey, verdict, reason, run
 }
 /**
  * Emit a spec re-review verdict for `ticketKey` into the local conductor ledger,
- * correlated to the spec-review run via `BAPI_CONDUCTOR_RUN_ID` (read from the
+ * correlated to the spec-review run via `BAPI_EPIC_IMPLEMENTER_RUN_ID` (read from the
  * injected env). Idempotent: deduped by `event_type` + `run_id`, so re-emitting
  * the same run's verdict is a no-op. A missing run id still emits (uncorrelated)
  * but is logged in the result so callers can detect the misconfiguration.
  */
 export async function emitSpecReviewVerdict(ticketKey, verdict, reason, deps = {}) {
     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 run_id = deps.env?.BAPI_EPIC_IMPLEMENTER_RUN_ID?.trim() || null;
+    const worker_id = deps.env?.BAPI_EPIC_IMPLEMENTER_WORKER_ID?.trim() || null;
     const eventType = verdict === "passed" ? SPEC_REVIEW_PASSED : SPEC_REVIEW_CHANGES_REQUESTED;
     const event = buildSpecReviewVerdictEventInput(ticketKey, verdict, reason, run_id, worker_id);
     const decision = await emitIfNew(event, {
@@ -83,6 +83,6 @@ export async function emitSpecReviewVerdict(ticketKey, verdict, reason, deps = {
         emitted: decision.emitted,
         event_type: eventType,
         run_id,
-        reason: run_id ? reason : `${reason} (warning: no BAPI_CONDUCTOR_RUN_ID — verdict uncorrelated)`,
+        reason: run_id ? reason : `${reason} (warning: no BAPI_EPIC_IMPLEMENTER_RUN_ID — verdict uncorrelated)`,
     };
 }

package/build/conductor/store.js

@@ -191,16 +191,16 @@ function parseBoundedInt(raw, fallback, min, max) {
 }
 /**
  * Resolve store configuration from environment with safe defaults and bounds.
- *   - `BAPI_CONDUCTOR_BUSY_TIMEOUT_MS` (default 10000, clamped [250, 120000]).
- *   - `BAPI_CONDUCTOR_RETENTION_DAYS` (default 30). A value <= 0 DISABLES
+ *   - `BAPI_EPIC_IMPLEMENTER_BUSY_TIMEOUT_MS` (default 10000, clamped [250, 120000]).
+ *   - `BAPI_EPIC_IMPLEMENTER_RETENTION_DAYS` (default 30). A value <= 0 DISABLES
  *     age-based retention; positive values are clamped to [1, 3650].
- *   - `BAPI_CONDUCTOR_RETENTION_MAX_ROWS` (default 50000). A value <= 0 DISABLES
+ *   - `BAPI_EPIC_IMPLEMENTER_RETENTION_MAX_ROWS` (default 50000). A value <= 0 DISABLES
  *     the row cap; positive values are clamped to [100, 10000000].
  */
 export function resolveConductorStoreConfig(env = process.env) {
-    const busy_timeout_ms = parseBoundedInt(env.BAPI_CONDUCTOR_BUSY_TIMEOUT_MS, BUSY_TIMEOUT_DEFAULT, BUSY_TIMEOUT_MIN, BUSY_TIMEOUT_MAX);
+    const busy_timeout_ms = parseBoundedInt(env.BAPI_EPIC_IMPLEMENTER_BUSY_TIMEOUT_MS, BUSY_TIMEOUT_DEFAULT, BUSY_TIMEOUT_MIN, BUSY_TIMEOUT_MAX);
     // Retention days: <= 0 disables (sentinel 0); positive values clamped.
-    const rawDays = env.BAPI_CONDUCTOR_RETENTION_DAYS;
+    const rawDays = env.BAPI_EPIC_IMPLEMENTER_RETENTION_DAYS;
     let retention_days = RETENTION_DAYS_DEFAULT;
     if (rawDays !== undefined && rawDays.trim().length > 0) {
         const parsed = Number.parseInt(rawDays.trim(), 10);
@@ -215,7 +215,7 @@ export function resolveConductorStoreConfig(env = process.env) {
         }
     }
     // Retention max rows: <= 0 disables (sentinel 0); positive values clamped.
-    const rawRows = env.BAPI_CONDUCTOR_RETENTION_MAX_ROWS;
+    const rawRows = env.BAPI_EPIC_IMPLEMENTER_RETENTION_MAX_ROWS;
     let retention_max_rows = RETENTION_MAX_ROWS_DEFAULT;
     if (rawRows !== undefined && rawRows.trim().length > 0) {
         const parsed = Number.parseInt(rawRows.trim(), 10);
@@ -230,7 +230,7 @@ export function resolveConductorStoreConfig(env = process.env) {
         }
     }
     // Message relay cooldown: <= 0 disables (sentinel 0); positive values clamped.
-    const rawCooldown = env.BAPI_CONDUCTOR_MESSAGE_COOLDOWN_MS;
+    const rawCooldown = env.BAPI_EPIC_IMPLEMENTER_MESSAGE_COOLDOWN_MS;
     let message_cooldown_ms = MESSAGE_COOLDOWN_DEFAULT_MS;
     if (rawCooldown !== undefined && rawCooldown.trim().length > 0) {
         const parsed = Number.parseInt(rawCooldown.trim(), 10);
@@ -1211,7 +1211,7 @@ export async function sendWorkerMessage(input, config = resolveConductorStoreCon
         : config.message_cooldown_ms;
     const source = typeof input.source === "string" && input.source.trim().length > 0
         ? input.source.trim()
-        : "conductor-supervisor";
+        : "epic-implementer-supervisor";
     const producer = typeof input.producer === "string" && input.producer.trim().length > 0
         ? input.producer.trim()
         : "worker-message-relay";
@@ -1334,7 +1334,7 @@ export async function checkWorkerMessages(input, config = resolveConductorStoreC
                     continue;
                 insertRelayAuditEvent(db, {
                     id: `message.delivered:${row.id}`,
-                    source: "conductor-worker",
+                    source: "epic-implementer-worker",
                     type: "message.delivered",
                     run_id: row.run_id,
                     worker_id: row.worker_id,
@@ -1349,7 +1349,7 @@ export async function checkWorkerMessages(input, config = resolveConductorStoreC
                 toAcked.run({ seq: row.seq });
                 insertRelayAuditEvent(db, {
                     id: `message.acked:${row.id}`,
-                    source: "conductor-worker",
+                    source: "epic-implementer-worker",
                     type: "message.acked",
                     run_id: row.run_id,
                     worker_id: row.worker_id,

package/build/conductor/supervisor-config.js

@@ -65,13 +65,13 @@ const POLL_LIMIT_MAX = 1000;
  * tests/builds.
  */
 export function resolveSupervisorConfig(overrides = {}, env = process.env) {
-    const wake_interval_ms = clampOverride(overrides.wake_interval_ms, parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_WAKE_INTERVAL_MS, WAKE_INTERVAL_DEFAULT_MS, WAKE_INTERVAL_MIN_MS, WAKE_INTERVAL_MAX_MS), WAKE_INTERVAL_MIN_MS, WAKE_INTERVAL_MAX_MS);
-    const global_timeout_ms = clampOverride(overrides.global_timeout_ms, parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_GLOBAL_TIMEOUT_MS, GLOBAL_TIMEOUT_DEFAULT_MS, GLOBAL_TIMEOUT_MIN_MS, GLOBAL_TIMEOUT_MAX_MS), GLOBAL_TIMEOUT_MIN_MS, GLOBAL_TIMEOUT_MAX_MS);
-    const escalation_cooldown_ms = clampOverride(overrides.escalation_cooldown_ms, parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_ESCALATION_COOLDOWN_MS, ESCALATION_COOLDOWN_DEFAULT_MS, ESCALATION_COOLDOWN_MIN_MS, ESCALATION_COOLDOWN_MAX_MS), ESCALATION_COOLDOWN_MIN_MS, ESCALATION_COOLDOWN_MAX_MS);
-    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);
-    const poll_limit = parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_SUPERVISOR_POLL_LIMIT, POLL_LIMIT_DEFAULT, POLL_LIMIT_MIN, POLL_LIMIT_MAX);
+    const wake_interval_ms = clampOverride(overrides.wake_interval_ms, parseBoundedSupervisorInt(env.BAPI_EPIC_IMPLEMENTER_WAKE_INTERVAL_MS, WAKE_INTERVAL_DEFAULT_MS, WAKE_INTERVAL_MIN_MS, WAKE_INTERVAL_MAX_MS), WAKE_INTERVAL_MIN_MS, WAKE_INTERVAL_MAX_MS);
+    const global_timeout_ms = clampOverride(overrides.global_timeout_ms, parseBoundedSupervisorInt(env.BAPI_EPIC_IMPLEMENTER_GLOBAL_TIMEOUT_MS, GLOBAL_TIMEOUT_DEFAULT_MS, GLOBAL_TIMEOUT_MIN_MS, GLOBAL_TIMEOUT_MAX_MS), GLOBAL_TIMEOUT_MIN_MS, GLOBAL_TIMEOUT_MAX_MS);
+    const escalation_cooldown_ms = clampOverride(overrides.escalation_cooldown_ms, parseBoundedSupervisorInt(env.BAPI_EPIC_IMPLEMENTER_ESCALATION_COOLDOWN_MS, ESCALATION_COOLDOWN_DEFAULT_MS, ESCALATION_COOLDOWN_MIN_MS, ESCALATION_COOLDOWN_MAX_MS), ESCALATION_COOLDOWN_MIN_MS, ESCALATION_COOLDOWN_MAX_MS);
+    const quiet_after_ms = parseBoundedSupervisorInt(env.BAPI_EPIC_IMPLEMENTER_QUIET_AFTER_MS, QUIET_AFTER_DEFAULT_MS, QUIET_AFTER_MIN_MS, QUIET_AFTER_MAX_MS);
+    const liveness_stalled_after_ms = parseBoundedSupervisorInt(env.BAPI_EPIC_IMPLEMENTER_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_EPIC_IMPLEMENTER_DEAD_AFTER_MS, DEAD_AFTER_DEFAULT_MS, DEAD_AFTER_MIN_MS, DEAD_AFTER_MAX_MS);
+    const poll_limit = parseBoundedSupervisorInt(env.BAPI_EPIC_IMPLEMENTER_SUPERVISOR_POLL_LIMIT, POLL_LIMIT_DEFAULT, POLL_LIMIT_MIN, POLL_LIMIT_MAX);
     return {
         wake_interval_ms,
         global_timeout_ms,
@@ -95,19 +95,19 @@ function clampOverride(override, base, min, max) {
 function resolveStallThresholds(env) {
     return {
         // A worker that never starts should surface quickly.
-        not_started: parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_STALL_NOT_STARTED_MS, 15 * MINUTE_MS, MINUTE_MS, HOUR_MS),
+        not_started: parseBoundedSupervisorInt(env.BAPI_EPIC_IMPLEMENTER_STALL_NOT_STARTED_MS, 15 * MINUTE_MS, MINUTE_MS, HOUR_MS),
         // Active work (tests/builds) is given a long, tolerant budget.
-        active: parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_STALL_ACTIVE_MS, 2 * HOUR_MS, 10 * MINUTE_MS, 12 * HOUR_MS),
+        active: parseBoundedSupervisorInt(env.BAPI_EPIC_IMPLEMENTER_STALL_ACTIVE_MS, 2 * HOUR_MS, 10 * MINUTE_MS, 12 * HOUR_MS),
         // Already-stalled workers re-escalate on a slower cadence.
-        stalled: parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_STALL_STALLED_MS, 30 * MINUTE_MS, 5 * MINUTE_MS, 6 * HOUR_MS),
+        stalled: parseBoundedSupervisorInt(env.BAPI_EPIC_IMPLEMENTER_STALL_STALLED_MS, 30 * MINUTE_MS, 5 * MINUTE_MS, 6 * HOUR_MS),
         // Blocked workers may legitimately wait a long time (human input, deps).
-        blocked: parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_STALL_BLOCKED_MS, 24 * HOUR_MS, 30 * MINUTE_MS, 7 * 24 * HOUR_MS),
+        blocked: parseBoundedSupervisorInt(env.BAPI_EPIC_IMPLEMENTER_STALL_BLOCKED_MS, 24 * HOUR_MS, 30 * MINUTE_MS, 7 * 24 * HOUR_MS),
         // A done candidate that never gets verified should surface.
-        candidate_done: parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_STALL_CANDIDATE_DONE_MS, 30 * MINUTE_MS, 5 * MINUTE_MS, 6 * HOUR_MS),
+        candidate_done: parseBoundedSupervisorInt(env.BAPI_EPIC_IMPLEMENTER_STALL_CANDIDATE_DONE_MS, 30 * MINUTE_MS, 5 * MINUTE_MS, 6 * HOUR_MS),
         // Verification (CI) gets a long, tolerant budget like active work.
-        verifying: parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_STALL_VERIFYING_MS, 2 * HOUR_MS, 10 * MINUTE_MS, 12 * HOUR_MS),
+        verifying: parseBoundedSupervisorInt(env.BAPI_EPIC_IMPLEMENTER_STALL_VERIFYING_MS, 2 * HOUR_MS, 10 * MINUTE_MS, 12 * HOUR_MS),
         // Unknown-state workers surface on a moderate cadence.
-        unknown: parseBoundedSupervisorInt(env.BAPI_CONDUCTOR_STALL_UNKNOWN_MS, 30 * MINUTE_MS, 5 * MINUTE_MS, 6 * HOUR_MS),
+        unknown: parseBoundedSupervisorInt(env.BAPI_EPIC_IMPLEMENTER_STALL_UNKNOWN_MS, 30 * MINUTE_MS, 5 * MINUTE_MS, 6 * HOUR_MS),
         // Terminal states never "stall"; large sentinels keep arithmetic uniform.
         complete: Number.MAX_SAFE_INTEGER,
         failed: Number.MAX_SAFE_INTEGER,

package/build/conductor/supervisor-ledger.js

@@ -86,11 +86,11 @@ export async function emitSupervisorAssessmentIfNew(input, deps = {}) {
     };
     const event = {
         id: eventId,
-        source: "conductor-supervisor",
+        source: "epic-implementer-supervisor",
         type: "supervisor.assessment",
         run_id: input.run_id,
         worker_id: input.idempotency.worker_id ?? input.worker_id ?? null,
-        producer: "conductor-supervisor",
+        producer: "epic-implementer-supervisor",
         observed_via: "supervisor",
         data: {
             summary: `supervisor assessment: ${input.idempotency.reason}`,

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

@@ -40,7 +40,7 @@ export function buildSupervisorEscalationWorkerMessage(candidate, assessment, st
             status: "escalated",
             details,
         },
-        source: "conductor-supervisor",
+        source: "epic-implementer-supervisor",
         producer: "worker-message-relay",
     };
 }
@@ -71,7 +71,7 @@ export function buildSupervisorRemediationWorkerMessage(input) {
                 truncated: input.truncated,
             },
         },
-        source: "conductor-supervisor",
+        source: "epic-implementer-supervisor",
         producer: "worker-message-relay",
     };
 }

package/build/conductor/worker-ledger-cli.js

@@ -6,12 +6,12 @@
  * Every worker-facing ledger operation (`check_messages`, and the
  * `wait_for_done_gate` event emit) therefore runs through this module, which
  * shells out to the packaged `conductor-bin.js` CLI executed by the conductor
- * Node runtime captured at dispatch time in `CONDUCTOR_NODE_PATH`. Conductor-OWNED
+ * Node runtime captured at dispatch time in `EPIC_IMPLEMENTER_NODE_PATH`. Conductor-OWNED
  * processes (the CLI itself, the supervisor/epic runtimes) keep calling
  * `store.ts` directly — they legitimately own the native load.
  *
- * Hard-fail contract: when `CONDUCTOR_NODE_PATH` is missing/invalid or
- * `BAPI_CONDUCTOR_CLI_FILE` is absent, this boundary throws a typed
+ * Hard-fail contract: when `EPIC_IMPLEMENTER_NODE_PATH` is missing/invalid or
+ * `BAPI_EPIC_IMPLEMENTER_CLI_FILE` is absent, this boundary throws a typed
  * {@link ConductorLedgerSubprocessRuntimeError} rather than silently falling back
  * to the worker's own `process.execPath`. Falling back would re-introduce the
  * native load into the worker Node — the exact failure mode this slice removes.
@@ -33,9 +33,9 @@ import { isAbsolute as pathIsAbsolute } from "node:path";
 import { ConductorLedgerSubprocessRuntimeError, ConductorWorkerContextRequiredError, } from "./errors.js";
 import { makeProducerDedupeKey, makeStableProducerEventId, } from "./producer-ledger.js";
 /** The env key that carries the captured conductor Node executable path. */
-export const CONDUCTOR_NODE_PATH_ENV = "CONDUCTOR_NODE_PATH";
+export const EPIC_IMPLEMENTER_NODE_PATH_ENV = "EPIC_IMPLEMENTER_NODE_PATH";
 /** The (pre-existing) env key that carries the packaged `conductor-bin.js` path. */
-export const BAPI_CONDUCTOR_CLI_FILE_ENV = "BAPI_CONDUCTOR_CLI_FILE";
+export const BAPI_EPIC_IMPLEMENTER_CLI_FILE_ENV = "BAPI_EPIC_IMPLEMENTER_CLI_FILE";
 /**
  * Bounded stdout buffer for a conductor CLI response. Conductor JSON responses
  * (message batches / emit summaries) are small; 8 MiB is generous headroom while
@@ -60,9 +60,9 @@ function nonEmpty(value) {
 /**
  * Validate and resolve the worker-ledger subprocess runtime from the environment.
  *
- * `CONDUCTOR_NODE_PATH` must be set, non-empty, and an ABSOLUTE path (a relative
+ * `EPIC_IMPLEMENTER_NODE_PATH` must be set, non-empty, and an ABSOLUTE path (a relative
  * value like `node` / `./node` is rejected as `invalid` — it must never resolve
- * against `PATH` or the worker cwd). `BAPI_CONDUCTOR_CLI_FILE` must be set and
+ * against `PATH` or the worker cwd). `BAPI_EPIC_IMPLEMENTER_CLI_FILE` must be set and
  * non-empty. On any failure this throws a typed
  * {@link ConductorLedgerSubprocessRuntimeError}; it NEVER falls back to
  * `process.execPath`.
@@ -83,24 +83,24 @@ export function resolveWorkerLedgerCliRuntime(deps = {}) {
     const isAbsolute = deps.isAbsolute ?? pathIsAbsolute;
     // `undefined` specifically — an env var SET to "" is present-but-invalid and
     // falls through to the fail-loud path below.
-    if (env[CONDUCTOR_NODE_PATH_ENV] === undefined &&
-        env[BAPI_CONDUCTOR_CLI_FILE_ENV] === undefined) {
+    if (env[EPIC_IMPLEMENTER_NODE_PATH_ENV] === undefined &&
+        env[BAPI_EPIC_IMPLEMENTER_CLI_FILE_ENV] === undefined) {
         throw new ConductorWorkerContextRequiredError([
-            CONDUCTOR_NODE_PATH_ENV,
-            BAPI_CONDUCTOR_CLI_FILE_ENV,
+            EPIC_IMPLEMENTER_NODE_PATH_ENV,
+            BAPI_EPIC_IMPLEMENTER_CLI_FILE_ENV,
         ]);
     }
-    const nodePathRaw = env[CONDUCTOR_NODE_PATH_ENV];
+    const nodePathRaw = env[EPIC_IMPLEMENTER_NODE_PATH_ENV];
     if (!nonEmpty(nodePathRaw)) {
-        throw new ConductorLedgerSubprocessRuntimeError("missing", CONDUCTOR_NODE_PATH_ENV);
+        throw new ConductorLedgerSubprocessRuntimeError("missing", EPIC_IMPLEMENTER_NODE_PATH_ENV);
     }
     const nodePath = nodePathRaw.trim();
     if (!isAbsolute(nodePath)) {
-        throw new ConductorLedgerSubprocessRuntimeError("invalid", CONDUCTOR_NODE_PATH_ENV);
+        throw new ConductorLedgerSubprocessRuntimeError("invalid", EPIC_IMPLEMENTER_NODE_PATH_ENV);
     }
-    const cliFileRaw = env[BAPI_CONDUCTOR_CLI_FILE_ENV];
+    const cliFileRaw = env[BAPI_EPIC_IMPLEMENTER_CLI_FILE_ENV];
     if (!nonEmpty(cliFileRaw)) {
-        throw new ConductorLedgerSubprocessRuntimeError("cli_missing", BAPI_CONDUCTOR_CLI_FILE_ENV);
+        throw new ConductorLedgerSubprocessRuntimeError("cli_missing", BAPI_EPIC_IMPLEMENTER_CLI_FILE_ENV);
     }
     return { nodePath, cliFile: cliFileRaw.trim() };
 }
@@ -129,14 +129,14 @@ export function execConductorCli(subcommandArgs, stdin, deps = {}) {
                 if (error) {
                     // A non-zero exit, spawn failure, or timeout kill — never surface the
                     // raw error text (it can carry paths/secrets). Fixed reason only.
-                    reject(new ConductorLedgerSubprocessRuntimeError("spawn_failed", CONDUCTOR_NODE_PATH_ENV));
+                    reject(new ConductorLedgerSubprocessRuntimeError("spawn_failed", EPIC_IMPLEMENTER_NODE_PATH_ENV));
                     return;
                 }
                 resolve(stdout);
             });
         }
         catch {
-            reject(new ConductorLedgerSubprocessRuntimeError("spawn_failed", CONDUCTOR_NODE_PATH_ENV));
+            reject(new ConductorLedgerSubprocessRuntimeError("spawn_failed", EPIC_IMPLEMENTER_NODE_PATH_ENV));
             return;
         }
         if (stdin !== undefined) {
@@ -169,7 +169,7 @@ export function parseCliJsonStdout(stdout) {
         return JSON.parse(stdout);
     }
     catch {
-        throw new ConductorLedgerSubprocessRuntimeError("malformed_stdout", CONDUCTOR_NODE_PATH_ENV);
+        throw new ConductorLedgerSubprocessRuntimeError("malformed_stdout", EPIC_IMPLEMENTER_NODE_PATH_ENV);
     }
 }
 /**

package/build/conductor-bundle-artifacts.js

@@ -29,7 +29,7 @@ const EPIC_SLUG_RE = /^[A-Za-z][A-Za-z0-9_-]*$/;
 const PLACEHOLDER_RE = /TBD-\d+/;
 /**
  * The conductor's hard spec bound, mirroring `_SPEC_REVIEW_TICKET_SPEC_MAX_CHARS`
- * (64,000) in `api/library/epic_conductor/reconciler.py`. Since PR #848 the
+ * (64,000) in `api/library/epic_implementer/reconciler.py`. Since PR #848 the
  * reconciler marks overflow beyond its own bound visibly (no silent loss), so
  * this authoring guard exists only to reject a spec the conductor itself could
  * not accept. For Jira-backed tickets the practical limit binds far earlier:
@@ -576,7 +576,7 @@ function findCycle(keys, edgeKeys) {
  */
 const PY_WHITESPACE = /[\t\n\v\f\r \x1c-\x1f\x85\xa0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]+/g;
 /**
- * Mirror `normalize_ticket_spec()` (`api/library/epic_conductor/spec_hash.py`)
+ * Mirror `normalize_ticket_spec()` (`api/library/epic_implementer/spec_hash.py`)
  * so a cosmetic diff never triggers a Jira rewrite.
  *
  * Because whitespace collapses, a pure reflow/indent edit is deliberately NOT a

package/build/cursor-agent-progress.js

@@ -0,0 +1,72 @@
+/** Human-readable progress for headless Cursor runs without exposing tool payloads. */
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+/** Only render assistant prose and tool NAMES; tool arguments/results may contain secrets. */
+export function formatCursorProgressEvent(event) {
+    if (event.type === "system" && event.subtype === "init") {
+        return "Cursor agent started. Progress will appear below.\n";
+    }
+    if (event.type === "assistant") {
+        const content = event.message?.content;
+        const prose = (Array.isArray(content) ? content : [])
+            .filter((item) => item && item.type === "text" && typeof item.text === "string")
+            .map((item) => item.text)
+            .join("");
+        return prose ? `${prose}\n` : null;
+    }
+    if (event.type === "tool_call" && event.subtype === "started") {
+        const call = event.tool_call;
+        const name = call && typeof call === "object" && !Array.isArray(call)
+            ? Object.keys(call)[0]
+            : undefined;
+        if (!name)
+            return "Working with a tool...\n";
+        const label = name.replace(/ToolCall$/, "").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+        return `Using ${label}...\n`;
+    }
+    return null;
+}
+async function main(argv) {
+    const args = argv[0] === "--" ? argv.slice(1) : argv;
+    if (args[0] !== "cursor-agent") {
+        process.stderr.write("cursor-agent-progress expects cursor-agent as its child command.\n");
+        return 2;
+    }
+    const child = spawn(args[0], args.slice(1), { stdio: ["inherit", "pipe", "inherit"] });
+    const forwardSignal = (signal) => child.kill(signal);
+    process.on("SIGINT", forwardSignal);
+    process.on("SIGTERM", forwardSignal);
+    const completion = new Promise((resolve) => {
+        child.once("close", (code, signal) => resolve(code ?? (signal ? 128 : 1)));
+        child.once("error", () => resolve(1));
+    });
+    const lines = createInterface({ input: child.stdout });
+    let sawAssistantText = false;
+    for await (const line of lines) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const rendered = formatCursorProgressEvent(event);
+        if (rendered) {
+            if (event.type === "assistant")
+                sawAssistantText = true;
+            process.stdout.write(rendered);
+        }
+        if (event.type === "result" && !sawAssistantText && typeof event.result === "string") {
+            process.stdout.write(`${event.result}\n`);
+        }
+    }
+    const exit = await completion;
+    process.off("SIGINT", forwardSignal);
+    process.off("SIGTERM", forwardSignal);
+    return exit;
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    void main(process.argv.slice(2)).then((code) => { process.exitCode = code; });
+}