@bridge_gpt/mcp-server 0.2.45 → 0.2.48

package/build/conduct-epic/bridge-client.js

@@ -236,6 +236,7 @@ const INDEX_SCOPE_FRESHNESS_VALUES = new Set([
     "blocked",
     "failed",
     "unavailable",
+    "unobserved_advance",
 ]);
 /**
  * Read the server's freshness verdict, failing CLOSED.
@@ -424,6 +425,78 @@ export async function getIndexScopeStatus(access, scopeId, fetchImpl = globalThi
         },
     };
 }
+/**
+ * The bounded outcomes `POST /jira/index-scope/catch-up` may report (BAPI-932).
+ *
+ * Three are successes — the scope was behind and every replayed commit passed
+ * the gate (`repaired`); it was already current and nothing was written
+ * (`already_current`); it was pinned correctly but not yet indexed, so the
+ * existing scheduler was asked to re-drive the parse (`parse_scheduled`). The
+ * rest are refusals, and a refusal leaves both watermarks byte-identical.
+ */
+export const INDEX_SCOPE_CATCH_UP_OUTCOMES = [
+    "repaired",
+    "already_current",
+    "parse_scheduled",
+    "race_lost",
+    "blocked",
+    "history_limit_exceeded",
+    "refused_lifecycle",
+    "invalid_scope",
+    "unavailable",
+    // Route-minted, before the service is reached.
+    "unknown_index_scope",
+    "epic_shadow_index_lookup_failed",
+    "scope_does_not_belong_to_repository",
+];
+/**
+ * `POST /jira/index-scope/catch-up` — replay a scope's missed observations.
+ *
+ * Fails CLOSED in the same two ways the rest of this client does: a soft-envelope
+ * refusal becomes a `BridgeResult` failure, and an unrecognized `outcome` narrows
+ * to `null` rather than being passed through. A `null` outcome with `ok: true`
+ * cannot happen — an unrecognized success is downgraded to a failure, because
+ * "the server said something we do not understand" must never be read by a
+ * conductor as "the repair worked".
+ */
+export async function catchUpIndexScope(access, request, fetchImpl = globalThis.fetch) {
+    const result = await wrap(access, () => {
+        const url = buildConductorJiraUrl(access.baseUrl, "/index-scope/catch-up");
+        return fetchConductorJsonPostWithTimeout(url, postHeaders(access), JSON.stringify({ repo_name: access.repoName, scope_id: request.scopeId }), CONDUCTOR_FETCH_TIMEOUT_MS, fetchImpl);
+    });
+    if (!result.ok)
+        return result;
+    if (!isRecord(result.value))
+        return { ok: false, status: null, error: GENERIC_ERROR };
+    const body = result.value;
+    const rawOutcome = body["outcome"];
+    const outcome = typeof rawOutcome === "string" && INDEX_SCOPE_CATCH_UP_OUTCOMES.includes(rawOutcome)
+        ? rawOutcome
+        : null;
+    const ok = body["ok"] === true;
+    if (ok && outcome === null) {
+        // A success we cannot name is not a success we may act on.
+        return { ok: false, status: null, error: GENERIC_ERROR };
+    }
+    if (!ok && outcome === null) {
+        // A refusal we cannot name still refuses; surface the server's own error
+        // token when it gave one, exactly as the soft-envelope helper would.
+        const refusal = softEnvelopeFailure(body);
+        if (refusal)
+            return refusal;
+        return { ok: false, status: null, error: GENERIC_ERROR };
+    }
+    return {
+        ok: true,
+        value: {
+            ok,
+            outcome,
+            reason: nullableString(body["reason"]) ?? null,
+            required_commit_sha: nullableString(body["required_commit_sha"]) ?? null,
+            parse_scheduled: body["parse_scheduled"] === true,
+        },
+    };
+}
 function nullableNumber(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : null;
 }

package/build/conduct-epic/cli.js

@@ -39,7 +39,7 @@ import { runGhCommand } from "../conductor/pr-discovery.js";
 import { getDefaultSpawnTerminalTabForPlatform, detectTerminal, createDefaultStartTicketsDeps, } from "../start-tickets.js";
 import { resolveWorktrunkBinary } from "../start-tickets-prereqs.js";
 import { resolveRequiredStartTicketsRepoName } from "../start-tickets-repo.js";
-import { bootstrapIndexScope, getConfigFieldBaseBranch, getConductorReadiness, getIndexScopeLifecycle, getIndexScopeStatus, getEffectiveSupervisorConfig, getEffectiveSupervisorSetup, getEpicRunState, getParseStatus, getPrReviewStatus, heartbeatIndexScope, pollCiChecks, putSupervisorConfigDefaults, reclaimIndexScope, recoverIndexScope, resolveCiChecks, retireIndexScope, } from "./bridge-client.js";
+import { bootstrapIndexScope, getConfigFieldBaseBranch, getConductorReadiness, getIndexScopeLifecycle, catchUpIndexScope, getIndexScopeStatus, getEffectiveSupervisorConfig, getEffectiveSupervisorSetup, getEpicRunState, getParseStatus, getPrReviewStatus, heartbeatIndexScope, pollCiChecks, putSupervisorConfigDefaults, reclaimIndexScope, recoverIndexScope, resolveCiChecks, retireIndexScope, } from "./bridge-client.js";
 import { appendTicketJournal, createInitialConductEpicCheckpoint, readConductEpicCheckpoint, resolveConductEpicCheckpointPath, resolveConductEpicLockPath, writeConductEpicCheckpointAtomic, CONDUCT_EPIC_REVIEW_VERDICTLESS_CEILING, CONDUCT_EPIC_TICKET_STATUSES, } from "./checkpoint-store.js";
 import { acquireConductEpicLock, inspectConductEpicLock, isConductEpicLockOwnerAlive, } from "./lock.js";
 import { discoverConductEpicPrState, discoverTicketWorktree, parseGitWorktreePorcelain, } from "./pr-state.js";
@@ -56,7 +56,7 @@ import { createExecFileRunCommand, firstOutputLine as firstLine, lsRemoteSha, no
 export { normalizeCommitSha };
 /** Epic and ticket keys accepted by every verb. */
 export const CONDUCT_EPIC_KEY_PATTERN = /^[A-Z]+-[0-9]+$/;
-/** The five verb families. `checkpoint set` is two tokens, one verb. */
+/** The verb families. `checkpoint set` is two tokens, one verb. */
 export const CONDUCT_EPIC_VERBS = [
     "init",
     "status",
@@ -66,6 +66,7 @@ export const CONDUCT_EPIC_VERBS = [
     "recover",
     "retire",
     "reclaim",
+    "catch-up",
 ];
 /** Per-ticket fields `checkpoint set` may assign. */
 const TICKET_FIELDS = [
@@ -190,6 +191,16 @@ export function getConductEpicUsage() {
         "      readable for post-mortem for the whole retention window. Idempotent.",
         "      `finish` does this for you; this verb is for retiring without finishing.",
         "",
+        "  catch-up <EPIC> [--scope <id>] [--checkpoint-path <p>] [--json]",
+        "      GUARDED CATCH-UP: replay merges the server never observed, so a scope",
+        "      stranded behind its epic branch can be repaired without waiting for the",
+        "      next ticket to merge. Every replayed commit goes through the SAME AC-10",
+        "      gate a merge webhook would have used — this replays verified merge",
+        "      evidence, it does NOT force the branch into the index, and there is no",
+        "      --force, --override, or skip-guard flag on purpose. A refusal leaves both",
+        "      commit watermarks untouched and schedules no parse. Running it twice",
+        "      leaves the same state as running it once.",
+        "",
         "  reclaim <EPIC> [--scope <id>] [--override-retention] [--checkpoint-path <p>] [--json]",
         "      Ask the server to schedule the scope's teardown: three Pinecone",
         "      namespaces, six parse-table slices, three config rows, and a retained",
@@ -224,6 +235,11 @@ const VERB_FLAGS = {
     recover: ["--scope", "--checkpoint-path", "--json"],
     retire: ["--scope", "--checkpoint-path", "--json"],
     reclaim: ["--scope", "--override-retention", "--checkpoint-path", "--json"],
+    // BAPI-932. NOTE the flags that are deliberately absent: there is no --force,
+    // no --override, and no --skip-guards, and adding one would defeat the point of
+    // the verb. Catch-up replays commits the SERVER reads through the unchanged
+    // AC-10 gate; it cannot make that gate say yes.
+    "catch-up": ["--scope", "--checkpoint-path", "--json"],
 };
 /**
  * Parse and fully validate argv BEFORE any I/O.
@@ -255,7 +271,8 @@ export function parseConductEpicArgs(argv) {
         argv[0] === "spawn" ||
         argv[0] === "recover" ||
         argv[0] === "retire" ||
-        argv[0] === "reclaim") {
+        argv[0] === "reclaim" ||
+        argv[0] === "catch-up") {
         verb = argv[0];
         rest = argv.slice(1);
     }
@@ -1762,6 +1779,13 @@ function renderScopeFreshnessLines(scope) {
         blocked: "Index refresh is BLOCKED — this advance will not be indexed.",
         failed: "Index generation FAILED for this scope.",
         unavailable: "Index freshness is unavailable — treat as not fresh.",
+        unobserved_advance: "The epic branch has advanced BEYOND what this index scope observed.",
+    };
+    // The action line sits immediately under the headline so the output reads
+    // status -> action -> evidence. `unobserved_advance` is the one state that is
+    // actionable rather than merely informative: it is repairable in place.
+    const action = {
+        unobserved_advance: "  Attempting guarded catch-up — replaying the missed merges through the same gate.",
     };
     const refusal = {
         advance_blocked_base_merge: "the base branch was merged forward into the epic branch, which would move the branch's pinned cut point",
@@ -1771,10 +1795,14 @@ function renderScopeFreshnessLines(scope) {
     };
     const lines = [
         headline[scope.freshness_status] ?? "Index freshness is unknown — treat as not fresh.",
-        `  lifecycle:      ${scope.lifecycle_state ?? "unknown"}`,
-        `  Required commit: ${scope.required_commit_sha ?? "none"}`,
-        `  Indexed commit:  ${scope.indexed_commit_sha ?? "none"}`,
     ];
+    const actionLine = action[scope.freshness_status];
+    if (actionLine !== undefined)
+        lines.push(actionLine);
+    lines.push(`  lifecycle:      ${scope.lifecycle_state ?? "unknown"}`, `  Required commit: ${scope.required_commit_sha ?? "none"}`, `  Indexed commit:  ${scope.indexed_commit_sha ?? "none"}`);
+    if (scope.freshness_status === "unobserved_advance") {
+        lines.push("  Both watermarks agree — at a commit the branch has left behind, which is", "  why this is not `fresh`. Run `conduct-epic catch-up <EPIC>` to repair it.");
+    }
     if (scope.blocked_reason !== null) {
         lines.push(`  Reason:          ${scope.blocked_reason} — ${refusal[scope.blocked_reason] ?? "the server refused this branch advance"}`);
         lines.push("  A human must resolve the branch before the epic can continue.");
@@ -2529,6 +2557,122 @@ export async function runConductEpicRecover(deps, options) {
         `  lease expires: ${recovered.value.lease_expires_at ?? "unknown"}`,
     ]);
 }
+/**
+ * `conduct-epic catch-up` — replay a scope's MISSED merge observations.
+ *
+ * The verb that rescues an ALREADY-stranded epic. Row 5 of `conduct-epic` calls
+ * the same endpoint automatically when `status` reports `unobserved_advance`, so
+ * the common case self-heals on a tick; this verb exists for the epic that is
+ * stranded right now and should not have to wait for one.
+ *
+ * It is a guarded catch-up, and the wording here is deliberate everywhere it
+ * appears: it replays verified merge evidence through the server's own AC-10
+ * gate. It cannot force anything, and no flag will ever let it.
+ */
+export async function runConductEpicCatchUp(deps, options) {
+    const accessProbe = await resolveAccess(deps);
+    if (!accessProbe.ok)
+        return emitFailure(deps, options.json, [accessProbe.error]);
+    const checkpointPath = resolveCheckpointPath(deps, await resolveRepoNameForPath(deps), options.epicKey, options.checkpointPath);
+    const target = await resolveLifecycleScope(deps, options, checkpointPath);
+    if (!target.ok)
+        return emitFailure(deps, options.json, [target.reason]);
+    const result = await catchUpIndexScope(accessProbe.access, { scopeId: target.scopeId }, deps.fetchImpl);
+    if (!result.ok) {
+        return emitFailure(deps, options.json, [
+            `The guarded catch-up could not run: ${result.error}`,
+        ]);
+    }
+    const value = result.value;
+    const payload = {
+        ok: value.ok,
+        epic_key: options.epicKey,
+        scope_id: target.scopeId,
+        outcome: value.outcome,
+        reason: value.reason,
+        required_commit_sha: value.required_commit_sha,
+        parse_scheduled: value.parse_scheduled,
+    };
+    const lines = renderCatchUpLines(value, target.scopeId);
+    return value.ok
+        ? emitSuccess(deps, options.json, payload, lines)
+        : emitFailure(deps, options.json, lines, payload);
+}
+/**
+ * Render one guarded catch-up outcome as distinct, bounded operator lines.
+ *
+ * Every outcome gets its own sentence rather than collapsing into "it did not
+ * work": the three successes call for different next steps (nothing, poll, poll),
+ * and the refusals call for genuinely different human action — a controlled AC-10
+ * block needs the BRANCH fixed, a history-limit refusal needs a fresh scope, and
+ * an `unavailable` needs the provider to come back.
+ */
+function renderCatchUpLines(value, scopeId) {
+    const pin = `  Required commit: ${value.required_commit_sha ?? "unknown"}`;
+    switch (value.outcome) {
+        case "repaired":
+            return [
+                `Guarded catch-up repaired index scope ${scopeId}.`,
+                "  Every replayed merge passed the AC-10 gate.",
+                pin,
+                value.parse_scheduled
+                    ? "  A re-parse is scheduled. Poll `conduct-epic status` until freshness reads `fresh`."
+                    : "  No re-parse was scheduled; poll `conduct-epic status` for the scope's own state.",
+            ];
+        case "already_current":
+            return [
+                `Index scope ${scopeId} is already current. Nothing was written.`,
+                pin,
+            ];
+        case "parse_scheduled":
+            return [
+                `Index scope ${scopeId} was already pinned at its branch head; no advance was needed.`,
+                value.parse_scheduled
+                    ? "  A re-parse is scheduled. Poll `conduct-epic status` until freshness reads `fresh`."
+                    : `  No re-parse was scheduled (${value.reason ?? "the scope is not schedulable right now"}).`,
+                pin,
+            ];
+        case "race_lost":
+            return [
+                `Another observation already owns this scope's target; the catch-up did nothing.`,
+                "  This is the safe outcome of a race, not a failure. Poll `conduct-epic status`.",
+                pin,
+            ];
+        case "blocked":
+            return [
+                `Guarded catch-up REFUSED to advance index scope ${scopeId}.`,
+                `  Reason: ${value.reason ?? "the server refused this branch advance"}`,
+                "  Both commit watermarks are unchanged and no parse was scheduled.",
+                "  A human must resolve the branch itself; there is no override.",
+                pin,
+            ];
+        case "history_limit_exceeded":
+            return [
+                `Index scope ${scopeId} is too far behind its epic branch to replay.`,
+                "  Refusing rather than replaying unbounded history. Cut a fresh scope.",
+                pin,
+            ];
+        case "refused_lifecycle":
+            return [
+                `Index scope ${scopeId} cannot take a catch-up in its current state.`,
+                `  Reason: ${value.reason ?? "unknown"}`,
+                pin,
+            ];
+        case "unavailable":
+            return [
+                `The guarded catch-up could not read the epic branch for scope ${scopeId}.`,
+                `  Reason: ${value.reason ?? "unknown"}`,
+                "  An unread branch is never a current one. Retry once the provider recovers.",
+                pin,
+            ];
+        default:
+            return [
+                `The guarded catch-up did not repair index scope ${scopeId}.`,
+                `  Outcome: ${value.outcome ?? "unknown"}  Reason: ${value.reason ?? "unknown"}`,
+                pin,
+            ];
+    }
+}
 /** `conduct-epic retire` — start the retention clock; delete nothing. */
 export async function runConductEpicRetire(deps, options) {
     const accessProbe = await resolveAccess(deps);
@@ -2677,5 +2821,7 @@ export async function runConductEpicCli(argv, overrides = {}) {
             return runConductEpicRetire(deps, options);
         case "reclaim":
             return runConductEpicReclaim(deps, options);
+        case "catch-up":
+            return runConductEpicCatchUp(deps, options);
     }
 }

package/build/conductor/cli.js

@@ -614,11 +614,11 @@ export async function runCheckMessagesCommand(argv) {
 const DIAGNOSTIC_BOOL_FLAGS = new Set(["--json", "--help"]);
 const DOCTOR_BOOL_FLAGS = new Set([...DIAGNOSTIC_BOOL_FLAGS, "--no-deny-probe"]);
 /**
- * Run the strictly read-only `doctor` command. Combines ledger health, git hook
- * health, and epic-tick schedule enablement status. `--json` emits the full
- * report with `epic_tick` alongside `git_hooks` at the top level.
- * `--no-deny-probe` skips the deny-enforcement preflight (no headless agent
- * spawn); the report then carries an explicit skipped state, never enforced.
+ * Run the strictly read-only `doctor` command. Combines ledger health and git
+ * hook health. `--json` emits the full report with `git_hooks` alongside the
+ * ledger fields at the top level. `--no-deny-probe` skips the deny-enforcement
+ * preflight (no headless agent spawn); the report then carries an explicit
+ * skipped state, never enforced.
  */
 export async function runDoctorCommand(argv, deps = {}) {
     const { bools } = tokenizeFlags(argv, new Set(), DOCTOR_BOOL_FLAGS);
@@ -626,11 +626,10 @@ export async function runDoctorCommand(argv, deps = {}) {
         console.log(getConductorUsage());
         return 0;
     }
-    // scheduleDeps omitted: buildConductorDoctorReport lazily loads schedule-run.
     // A caller may inject deps (e.g. a fake deny inspector in tests) to stay hermetic.
     const report = await buildConductorDoctorReport(bools.has("--no-deny-probe") ? { ...deps, skipDenyProbe: true } : deps);
     if (bools.has("--json")) {
-        console.log(JSON.stringify({ ...report.ledger, git_hooks: report.git_hooks, epic_tick: report.epic_tick, mcp_profile: report.mcp_profile, native_ledger: report.native_ledger, deny_enforcement: report.deny_enforcement }));
+        console.log(JSON.stringify({ ...report.ledger, git_hooks: report.git_hooks, mcp_profile: report.mcp_profile, native_ledger: report.native_ledger, deny_enforcement: report.deny_enforcement }));
         return 0;
     }
     console.log(formatConductorDoctorReport(report));

package/build/conductor/doctor.js

@@ -1,11 +1,10 @@
 /**
  * Combined, strictly read-only conductor doctor report (BAPI-395, BAPI-418).
  *
- * Extends the existing SQLite ledger health report with local git hook health
- * and Epic Supervisor schedule enablement status. Missing hooks and non-worktree
- * directories are reported as a degraded OPTIONAL capability — never a fatal
- * failure. This module performs NO writes: no hook installation, no schema
- * migration, no event emission, and no scheduler unit creation.
+ * Extends the existing SQLite ledger health report with local git hook health.
+ * Missing hooks and non-worktree directories are reported as a degraded
+ * OPTIONAL capability — never a fatal failure. This module performs NO writes:
+ * no hook installation, no schema migration, and no event emission.
  */
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
@@ -179,84 +178,6 @@ export async function collectConductorNativeLedgerSafe(deps = {}) {
         };
     }
 }
-/**
- * Inspect the local schedule metadata store for a registered epic-tick schedule.
- * Strictly read-only: composes orchestrateScheduleList (read-only list path) and
- * never creates, updates, or deletes any unit. A missing or erroring schedule is
- * mapped to a degraded state, never a thrown exception.
- *
- * Schedule-run is loaded lazily via dynamic import to avoid eagerly pulling its
- * node:fs/promises dependency into the module graph when doctor.ts is imported.
- */
-export async function inspectEpicTickSchedule(deps, orchestrateListOverride) {
-    try {
-        // Lazily import schedule-run to avoid pulling node:fs/promises into the graph
-        // when doctor.ts is first imported (which would break node:fs mocks in tests).
-        const schedRun = orchestrateListOverride
-            ? null
-            : await import("../schedule-run.js");
-        const doList = orchestrateListOverride
-            ? orchestrateListOverride
-            : (d) => schedRun.orchestrateScheduleList({ json: false }, d);
-        const resolvedDeps = orchestrateListOverride
-            ? deps
-            : (deps ?? schedRun.createDefaultScheduleRunDeps());
-        const commandLabel = schedRun
-            ? schedRun.scheduleCommandLabel
-            : (m) => m.command ?? (m.idea_file ? "full-automation" : "(unknown)");
-        const runStatus = schedRun
-            ? schedRun.latestRunStatus
-            : (m) => {
-                const h = m.run_history;
-                return h && h.length > 0 ? h[h.length - 1].status : "";
-            };
-        const report = await doList(resolvedDeps);
-        const entry = report.entries.find((e) => commandLabel(e.metadata) === "epic-tick");
-        if (!entry) {
-            // The healthy state. Epic Conductor v2 reconciles server-side; there is
-            // nothing for an operator to schedule locally.
-            return {
-                registered: false,
-                backend: null,
-                next_fire_iso: null,
-                latest_run_status: null,
-                degraded: false,
-                warnings: [],
-            };
-        }
-        // A registered epic-tick schedule is a dead timer: the v1 command throws
-        // EPIC_TICK_V1_FROZEN on every fire (see conductor/errors.ts). Anyone who has
-        // one registered followed the old advice and is now firing a no-op on a timer.
-        const m = entry.metadata;
-        const latest = runStatus(m);
-        return {
-            registered: true,
-            backend: m.backend ?? null,
-            next_fire_iso: m.run_at_iso ?? null,
-            latest_run_status: latest || null,
-            degraded: true,
-            warnings: [
-                "An epic-tick schedule is registered, but the v1 `conductor epic-tick` " +
-                    "path is frozen (EPIC_TICK_V1_FROZEN) — it advances nothing. Cancel it: " +
-                    `\`npx -y ${MCP_PACKAGE_NAME} schedule-run cancel --id ` +
-                    `${entry.metadata.id ?? "<id>"}\`. ` +
-                    "Epic Conductor v2 reconciles server-side; run jobs locally with " +
-                    `\`npx -y ${MCP_PACKAGE_NAME} executor --repo <name>\`.`,
-            ],
-        };
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-            registered: false,
-            backend: null,
-            next_fire_iso: null,
-            latest_run_status: null,
-            degraded: true,
-            warnings: [`Failed to inspect epic-tick schedule: ${msg}`],
-        };
-    }
-}
 /**
  * Inspect the BRIDGE_MCP_PROFILE environment variable and warn when a
  * conductor/epic context is detected but the resolved groups omit `conductor`.
@@ -270,14 +191,12 @@ export async function inspectEpicTickSchedule(deps, orchestrateListOverride) {
  * operator to REPLACE the variable — which would have destroyed the worker's
  * other groups. The remediation now says ADD.
  */
-export function inspectMcpProfile(env, epicTick) {
+export function inspectMcpProfile(env) {
     const raw = env.BRIDGE_MCP_PROFILE;
     const raw_profile = raw === undefined ? MCP_PROFILE_UNSET : raw;
     const groups = resolveProfiles(raw);
     const active_groups = Array.from(groups);
-    const conductor_context_detected = env.BAPI_CONDUCTOR_ENABLED === "1" ||
-        env.BAPI_CONDUCTOR_ENABLED === "true" ||
-        epicTick.registered;
+    const conductor_context_detected = env.BAPI_CONDUCTOR_ENABLED === "1" || env.BAPI_CONDUCTOR_ENABLED === "true";
     const degraded = conductor_context_detected && !groups.has("conductor");
     const warnings = [];
     if (degraded) {
@@ -350,13 +269,12 @@ export function inspectLocalMerge(runCommand) {
 }
 /**
  * Build the combined read-only doctor report. Composes the existing ledger
- * doctor, git hook inspection, and the epic-tick schedule enablement check.
- * Never mutates the ledger, the hooks, the schema, or the OS scheduler.
+ * doctor and the git hook inspection. Never mutates the ledger, the hooks, or
+ * the schema.
  */
 export async function buildConductorDoctorReport(deps = {}) {
     const inspectHooks = deps.inspectHooks ?? inspectConductorGitHooks;
-    const epicTick = await inspectEpicTickSchedule(deps.scheduleDeps, deps.orchestrateList);
-    const mcp_profile = inspectMcpProfile(deps.env ?? process.env, epicTick);
+    const mcp_profile = inspectMcpProfile(deps.env ?? process.env);
     // Resolve the ledger once so the native-load probe reflects the same report —
     // through the SHARED collector (BAPI-775), so the installer's read-only probe
     // and this report cannot diverge in their interpretation of the binding.
@@ -371,7 +289,6 @@ export async function buildConductorDoctorReport(deps = {}) {
     return {
         ledger,
         git_hooks: inspectHooks(deps.hooksDeps),
-        epic_tick: epicTick,
         mcp_profile,
         local_merge: inspectLocalMerge(deps.runCommand),
         native_ledger,
@@ -409,12 +326,12 @@ async function inspectDenyEnforcementSafe(inspect) {
     }
 }
 /**
- * Render the combined doctor report as human-readable text: ledger health,
- * git hooks section, and an Epic Supervisor Schedule section using semantic
- * status tags consistent with the git hooks section's visual hierarchy.
+ * Render the combined doctor report as human-readable text: ledger health and
+ * a git hooks section, using semantic status tags for a consistent visual
+ * hierarchy across sections.
  */
 export function formatConductorDoctorReport(report) {
-    const { ledger, git_hooks, epic_tick, mcp_profile, local_merge, native_ledger, deny_enforcement, claude_login } = report;
+    const { ledger, git_hooks, mcp_profile, local_merge, native_ledger, deny_enforcement, claude_login } = report;
     const lines = [
         "Conductor ledger doctor",
         "───────────────────────",
@@ -458,26 +375,6 @@ export function formatConductorDoctorReport(report) {
             lines.push(`  - ${w}`);
     }
     lines.push("");
-    lines.push("Epic Supervisor Schedule (v1 epic-tick — frozen)");
-    lines.push("───────────────────────────────────────────────");
-    // Inverted on purpose: no schedule is the healthy state. Epic Conductor v2
-    // reconciles server-side, so a registered epic-tick unit is a dead timer.
-    const registeredTag = epic_tick.registered
-        ? "[WARNING] registered — dead timer, remove it"
-        : "[SUCCESS] none registered (v1 is frozen)";
-    lines.push(`epic-tick schedule:    ${registeredTag}`);
-    if (epic_tick.registered) {
-        lines.push(`backend:               ${epic_tick.backend ?? "n/a"}`);
-        lines.push(`next fire:             ${epic_tick.next_fire_iso ?? "n/a"}`);
-        lines.push(`latest run status:     ${epic_tick.latest_run_status ?? "n/a"}`);
-    }
-    lines.push(`degraded:              ${epic_tick.degraded}`);
-    if (epic_tick.warnings.length > 0) {
-        lines.push("epic-tick warnings:");
-        for (const w of epic_tick.warnings)
-            lines.push(`  - ${w}`);
-    }
-    lines.push("");
     lines.push("Epic Conductor v2 reconciles epics server-side — nothing to schedule");
     lines.push("locally. To execute claimed jobs on this machine, run:");
     lines.push(`  npx -y ${MCP_PACKAGE_NAME} executor --repo <name>`);