@bridge_gpt/mcp-server 0.2.60 → 0.2.65

package/build/plan-discovery.js

@@ -0,0 +1,137 @@
+/**
+ * BAPI-1285: find an epic's plan DAG from the epic key alone.
+ *
+ * Identity comes from ONE place: `{docs_dir}/epic-plans/<dir>/epic-plan.meta.json`,
+ * a file holding `{"epic_key": "<KEY>"}` that `emit-epic-implementer-bundle
+ * finalize` writes beside the DAG. Discovery never guesses. It does not match a
+ * folder slug, a child ticket key, `sibling-ticket-manifest.json`, or anything
+ * inside the DAG — every one of those is a way to hand the wrong plan to a run
+ * that then creates real tickets' worth of work.
+ *
+ * Every filesystem read goes through the injected {@link PlanDiscoveryFs}, so a
+ * unit test reaches no real disk. Nothing here throws for a filesystem failure:
+ * an unreadable or malformed entry is named in `skipped` with a fixed reason and
+ * never with raw error text, which can carry paths or secrets.
+ */
+import path from "node:path";
+import { EPIC_KEY_PATTERN } from "./drive-epic-key.js";
+/** Why a metadata file was named but not counted. Fixed vocabulary, never raw text. */
+export const PLAN_DISCOVERY_SKIP_REASONS = [
+    "unreadable",
+    "malformed-json",
+    "not-an-object",
+    "missing-or-non-string-epic-key",
+    "missing-dag",
+    "unlistable-directory",
+];
+const META_FILE = "epic-plan.meta.json";
+const DAG_FILE = "epic-plan.dag.json";
+function isEnoent(err) {
+    return (typeof err === "object" && err !== null && err.code === "ENOENT");
+}
+function byPath(a, b) {
+    return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+}
+/**
+ * Discover the one plan DAG whose metadata names `epicKey`.
+ *
+ * - An invalid requested key returns `plan_not_found` before any filesystem call.
+ * - A missing `epic-plans/` directory is `plan_not_found`, not an error.
+ * - Exactly one match with a sibling DAG is `found`; two or more is
+ *   `plan_ambiguous` with every candidate, sorted; zero is `plan_not_found`.
+ */
+export async function discoverEpicPlan(epicKey, docsDir, fs) {
+    const epicPlansDir = path.resolve(docsDir, "epic-plans");
+    const notFound = (skipped = []) => ({
+        status: "plan_not_found",
+        epic_plans_dir: epicPlansDir,
+        skipped: [...skipped].sort(byPath),
+    });
+    if (!EPIC_KEY_PATTERN.test(epicKey))
+        return notFound();
+    const skipped = [];
+    const candidates = [];
+    let planDirs;
+    try {
+        planDirs = await fs.readdir(epicPlansDir);
+    }
+    catch (err) {
+        if (isEnoent(err))
+            return notFound();
+        return notFound([{ path: epicPlansDir, reason: "unlistable-directory" }]);
+    }
+    for (const planDir of planDirs) {
+        // Real directories only. A symlink could point outside the docs directory,
+        // and a file is not a plan folder.
+        if (planDir.isSymbolicLink?.() === true || !planDir.isDirectory())
+            continue;
+        const dirPath = path.join(epicPlansDir, planDir.name);
+        let files;
+        try {
+            files = await fs.readdir(dirPath);
+        }
+        catch (err) {
+            if (!isEnoent(err))
+                skipped.push({ path: dirPath, reason: "unlistable-directory" });
+            continue;
+        }
+        const isRegular = (entry) => entry.isFile() && entry.isSymbolicLink?.() !== true;
+        const meta = files.find((entry) => entry.name === META_FILE && isRegular(entry));
+        if (meta === undefined)
+            continue;
+        const metaPath = path.join(dirPath, META_FILE);
+        let raw;
+        try {
+            raw = await fs.readFile(metaPath);
+        }
+        catch {
+            skipped.push({ path: metaPath, reason: "unreadable" });
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            skipped.push({ path: metaPath, reason: "malformed-json" });
+            continue;
+        }
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            skipped.push({ path: metaPath, reason: "not-an-object" });
+            continue;
+        }
+        const key = parsed.epic_key;
+        if (typeof key !== "string") {
+            skipped.push({ path: metaPath, reason: "missing-or-non-string-epic-key" });
+            continue;
+        }
+        // Exact comparison, and both sides must satisfy the shared pattern. Metadata
+        // naming a key the CLI would reject is never a match.
+        if (!EPIC_KEY_PATTERN.test(key) || key !== epicKey)
+            continue;
+        const dag = files.find((entry) => entry.name === DAG_FILE && isRegular(entry));
+        if (dag === undefined) {
+            skipped.push({ path: metaPath, reason: "missing-dag" });
+            continue;
+        }
+        candidates.push(path.join(dirPath, DAG_FILE));
+    }
+    candidates.sort();
+    if (candidates.length === 1) {
+        return {
+            status: "found",
+            path: candidates[0],
+            epic_plans_dir: epicPlansDir,
+            skipped: [...skipped].sort(byPath),
+        };
+    }
+    if (candidates.length >= 2) {
+        return {
+            status: "plan_ambiguous",
+            candidates,
+            epic_plans_dir: epicPlansDir,
+            skipped: [...skipped].sort(byPath),
+        };
+    }
+    return notFound(skipped);
+}

package/build/plan-epic-implementer-eligibility.js

@@ -18,7 +18,7 @@
  *
  * Fails open, deliberately: any validation failure, classification failure, or
  * internal contradiction (a review-subset child the backend did not also mark
- * merge-blocked) becomes the explicit `unavailable` result — never a fabricated
+ * workflow-modifying) becomes the explicit `unavailable` result — never a fabricated
  * zero count. A caller that cannot get a real answer must say so, not guess.
  */
 import { CLAUDE_REVIEW_WORKFLOW_RELPATH } from "./claude-review-workflow-drift.js";
@@ -172,7 +172,7 @@ export async function assessEpicImplementerEligibility(children, deps) {
         const reviewPathReferenced = child.combinedText.includes(CLAUDE_REVIEW_WORKFLOW_RELPATH);
         if (reviewPathReferenced && !prediction.predicted_workflow_modified) {
             // Subset invariant violated: a child naming claude-review.yml itself must
-            // also be in the broader merge-blocked set. Publishing this as a
+            // also be in the broader workflow-modifying set. Publishing this as a
             // "review-only" child would contradict the merge count, so refuse instead.
             console.error(`assessEpicImplementerEligibility: child ${child.id} references the review workflow ` +
                 "but the backend did not mark it merge-blocked; refusing contradictory result.");

package/build/plane/cli.js

@@ -24,6 +24,7 @@ import { shutdownPlane, formatPlaneShutdown } from "./shutdown.js";
 import { launchPlaneSupervisor, runPlaneRuntime, PLANE_RUNTIME_TWO_PHASE_FLAG, } from "./supervisor.js";
 import { createMemberLogDeps, createPlaneClock, createPlaneExecFile, createPlaneFsDeps, createPlaneProcessDeps, createPlaneSpawn, probeAutomationHealth, probeTcpPort, registerSignalHandler, resolveHomedir, resolveHostname, resolveNodeExecutable, resolvePackageEntrypoint, } from "./defaults.js";
 import { resolveBapiCredentials } from "../credential-store.js";
+import { listRunExecutorRecords, verifyRunExecutorProcess } from "../executor-launch.js";
 import { resolveRequiredStartTicketsRepoName } from "../start-tickets-repo.js";
 /** Upper bound on executor lanes. Guards a typo from forking a fleet. */
 export const PLANE_MAX_EXECUTORS = 32;
@@ -386,16 +387,48 @@ async function runDownAction(sinks, overrides) {
         (injected.ok ? sinks.stdout : sinks.stderr)(injected.text);
         return injected.ok ? 0 : 1;
     }
+    const fs = createPlaneFsDeps();
+    const proc = createPlaneProcessDeps();
+    const execFile = createPlaneExecFile();
+    const endpoint = resolvePlaneServerEndpoint(process.env);
     const result = await shutdownPlane(repoRoot, {
-        fs: createPlaneFsDeps(),
-        proc: createPlaneProcessDeps(),
+        fs,
+        proc,
         clock: createPlaneClock(),
         stopBoundRun: stopBoundEpicRun,
+        // BAPI-1279 — stop the run-scoped executors drive-epic started here that
+        // target THIS plane's endpoint (the same rule `plane up` binds by).
+        runExecutors: {
+            list: () => listRunExecutorRecords(repoRoot, fs),
+            targetsThisPlane: (baseUrl) => endpoint.ok && urlNamesLoopbackPort(baseUrl, endpoint.endpoint.port),
+            verify: (record) => verifyRunExecutorProcess(record, { isAlive: proc.isAlive, execFile }, repoRoot),
+        },
     });
     const text = formatPlaneShutdown(result);
     (result.ok ? sinks.stdout : sinks.stderr)(text);
     return result.ok ? 0 : 1;
 }
+/** Loopback spellings that reach the plane's `127.0.0.1` bind. */
+const PLANE_LOOPBACK_HOSTNAMES = new Set([
+    "127.0.0.1",
+    "localhost",
+    "[::1]",
+    "::1",
+]);
+/** Does `baseUrl` name a loopback `http` endpoint on `port`? Pure. */
+function urlNamesLoopbackPort(baseUrl, port) {
+    let url;
+    try {
+        url = new URL(baseUrl);
+    }
+    catch {
+        return false;
+    }
+    if (url.protocol !== "http:")
+        return false;
+    const actual = url.port === "" ? 80 : Number(url.port);
+    return PLANE_LOOPBACK_HOSTNAMES.has(url.hostname) && actual === port;
+}
 /**
  * `plane down`'s pre-signal run-stop capability (BAPI-872).
  *
@@ -699,7 +732,8 @@ export async function launchPlaneControlPlane(args) {
         const lines = outcome.result.ok
             ? ["plane up FAILED: the runtime exited before the control plane was ready"]
             : formatPlaneLaunchFailure(outcome.result);
-        return { ok: false, lines };
+        const foreignReconciler = outcome.result.ok ? undefined : outcome.result.foreignReconciler;
+        return { ok: false, lines, ...(foreignReconciler !== undefined ? { foreignReconciler } : {}) };
     }
     return {
         ok: true,

package/build/plane/member-logs.js

@@ -82,6 +82,9 @@ export const PLANE_MEMBER_STARTUP_FAILURES = {
     // socket that was never part of the contract.
     heartbeatReadinessTimeout: "it did not publish a durable heartbeat in time",
     readinessUnestablished: "its readiness baseline could not be established",
+    // BAPI-1279 — the pre-spawn guard found another instance's reconciler live on
+    // the shared database, so the worker was never started.
+    foreignReconcilerLive: "another reconciler is already live on this database",
 };
 const ALLOWED_STARTUP_FAILURES = new Set(Object.values(PLANE_MEMBER_STARTUP_FAILURES));
 /** Substituted for any reason not in the allow-list. Never echoes the input. */

package/build/plane/member-roster.js

@@ -238,7 +238,13 @@ export function buildPlaneMemberRoster(params) {
             String(endpoint.port),
         ],
         cwd,
-        env,
+        // BAPI-1279 — the server member runs NO scheduler. `main.py` starts one
+        // whenever DISABLE_SCHEDULER is unset, and that scheduler ticks the
+        // reconciler: the plane would run two reconcilers of its own, and the
+        // pre-worker foreign-reconciler guard would see this server's heartbeat
+        // and refuse the plane's own worker. The `worker` member below is the one
+        // reconciler, exactly as a Heroku web dyno leaves scheduling to `worker:`.
+        env: { ...env, DISABLE_SCHEDULER: "true" },
         logPath: relativeLogPathFor("server"),
         readiness: {
             kind: "tcp",

package/build/plane/shutdown.js

@@ -110,6 +110,9 @@ export async function shutdownPlane(repoRoot, deps) {
                 message: "no run-stop capability was configured for this wind-down",
             }))
         : { kind: "unbound" };
+    // BAPI-1279 — the run-scoped executors that target this plane go first, while
+    // its server can still take their final job reports.
+    messages.push(...(await stopRunScopedExecutors(deps)));
     if (!isAnythingAlive(manifest, deps.proc, deps.selfPid)) {
         const cleared = await clearPlaneManifest(repoRoot, manifest.planeId, deps.fs);
         if (!cleared.ok) {
@@ -127,7 +130,7 @@ export async function shutdownPlane(repoRoot, deps) {
             escalated: false,
             manifestCleared: cleared.removed,
             members: reportMembers(manifest, deps.proc),
-            messages: ["Every recorded plane process was already gone; manifest cleared."],
+            messages: [...messages, "Every recorded plane process was already gone; manifest cleared."],
             runShutdown,
         };
     }
@@ -175,6 +178,61 @@ export async function shutdownPlane(repoRoot, deps) {
         runShutdown,
     };
 }
+/**
+ * Signal every verified run-scoped executor that targets this plane (BAPI-1279).
+ *
+ * Returns the message lines to report. SIGTERM reaches the executor's relay,
+ * which forwards it, so the executor drains its job and releases its worktree
+ * lock exactly as on any graceful stop. Never throws.
+ */
+async function stopRunScopedExecutors(deps) {
+    const runExecutors = deps.runExecutors;
+    if (runExecutors === undefined)
+        return [];
+    let listed;
+    try {
+        listed = await runExecutors.list();
+    }
+    catch {
+        return ["Run-scoped executors: the .bridge/executors/ records could not be read; none were stopped."];
+    }
+    const lines = [];
+    let stopped = 0;
+    const skipped = [];
+    for (const record of listed.records) {
+        if (!runExecutors.targetsThisPlane(record.baseUrl)) {
+            skipped.push(`run ${record.epicRunId} (targets ${record.baseUrl}, not this plane)`);
+            continue;
+        }
+        let state;
+        try {
+            state = await runExecutors.verify(record);
+        }
+        catch {
+            state = "unknown";
+        }
+        if (state === "dead")
+            continue;
+        if (state !== "verified") {
+            skipped.push(`run ${record.epicRunId} (pid ${record.pid} could not be verified as its executor)`);
+            continue;
+        }
+        if (deps.proc.signal(record.pid, "SIGTERM") === "sent")
+            stopped += 1;
+        else
+            skipped.push(`run ${record.epicRunId} (pid ${record.pid} could not be signalled)`);
+    }
+    for (const name of listed.malformed)
+        skipped.push(`${name} (unreadable record)`);
+    if (stopped > 0) {
+        lines.push(`Stopped ${stopped} run-scoped executor(s) targeting this plane. Their runs remain ` +
+            "server-side and resume when an executor and a reconciler are back.");
+    }
+    if (skipped.length > 0) {
+        lines.push(`Run-scoped executors left running: ${skipped.join("; ")}.`);
+    }
+    return lines;
+}
 /**
  * Deliver a signal to the whole plane.
  *

package/build/plane/supervisor.js

@@ -263,7 +263,16 @@ export async function launchPlaneSupervisor(params, deps) {
     // member logs, and this channel carries only attributed events and banners.
     let controlReadyAnnounced = false;
     let lanesFailedAnnounced = false;
+    let foreignReconciler;
     const readStdout = createLineReader((line) => {
+        if (line.startsWith(`${PLANE_FOREIGN_RECONCILER_MARKER}:`)) {
+            // Private. The runtime already explained the refusal on stderr; this
+            // carries only the fact and whether the rollback was confirmed.
+            foreignReconciler = {
+                rolledBack: line === `${PLANE_FOREIGN_RECONCILER_MARKER}:rolled-back`,
+            };
+            return;
+        }
         if (line === PLANE_CONTROL_READY_MARKER) {
             // Private, exactly like the ready marker: forwarding it would put an
             // internal token in the operator's terminal.
@@ -359,6 +368,7 @@ export async function launchPlaneSupervisor(params, deps) {
         return {
             ok: false,
             error,
+            ...(foreignReconciler !== undefined ? { foreignReconciler } : {}),
             startup: {
                 exitCode: outcome.code,
                 signal: outcome.signal,
@@ -405,6 +415,110 @@ export const PLANE_CONTROL_READY_MARKER = "__bapi_plane_control_ready__";
  * alive, serving a committed run, and never going to start a lane.
  */
 export const PLANE_LANES_FAILED_MARKER = "__bapi_plane_lanes_failed__";
+/**
+ * The pre-worker guard found another reconciler LIVE on the shared database
+ * (BAPI-1279), and the plane refused before spawning its own.
+ *
+ * Private, like the other markers, and followed by `:rolled-back` or
+ * `:rollback-incomplete` so the launcher can say whether nothing was left
+ * running — a claim it may make only after a CONFIRMED rollback.
+ */
+export const PLANE_FOREIGN_RECONCILER_MARKER = "__bapi_plane_foreign_reconciler__";
+/**
+ * How often a live reconciler writes its heartbeat: `tick()` runs on
+ * `IntervalTrigger(seconds=30)` in `api/library/scheduled_jobs.py` and writes
+ * the heartbeat first. A second read one interval (plus slack) after the first
+ * therefore sees a live reconciler's row advance.
+ */
+export const PLANE_RECONCILER_HEARTBEAT_INTERVAL_MS = 30_000;
+/** Slack added to the interval so a tick that runs a little late still lands. */
+export const PLANE_RECONCILER_HEARTBEAT_SLACK_MS = 5_000;
+/**
+ * The bound on waiting for a fresh-but-still row to go stale. The server's
+ * stale window (`RECONCILER_STALE_SECONDS`) is 120 seconds; 150 covers it from
+ * the first read with room for the read cadence.
+ */
+export const PLANE_FOREIGN_RECONCILER_WAIT_MS = 150_000;
+/** Poll interval while waiting for a stopped reconciler's row to go stale. */
+export const PLANE_FOREIGN_RECONCILER_POLL_MS = 5_000;
+/**
+ * Is another reconciler LIVE on this database? (BAPI-1279)
+ *
+ * Runs after the server member is ready — the heartbeat lives in the database,
+ * and this process reads it only through a Bridge API server — and before the
+ * worker is spawned, so a refusal never starts a second transition authority.
+ *
+ * The read is deployment-wide (no instance id), because the question is about
+ * ANY reconciler. A row that is not fresh is clear. A fresh row is read again
+ * one heartbeat interval later: if it advanced, a reconciler is ticking and the
+ * plane refuses. If it did not, it belongs to a reconciler that just stopped
+ * (heartbeat rows are not deleted on shutdown), so the guard waits — bounded —
+ * for it to go stale, then clears. Any read that cannot answer is `unsafe`:
+ * spawning is allowed only when the reads establish that it is safe.
+ */
+export async function guardForeignReconciler(input) {
+    const { deps } = input;
+    const intervalMs = input.intervalMs ?? PLANE_RECONCILER_HEARTBEAT_INTERVAL_MS + PLANE_RECONCILER_HEARTBEAT_SLACK_MS;
+    const budgetMs = input.waitBudgetMs ?? PLANE_FOREIGN_RECONCILER_WAIT_MS;
+    const pollMs = input.pollMs ?? PLANE_FOREIGN_RECONCILER_POLL_MS;
+    const startedAt = deps.clock.now().getTime();
+    const elapsed = () => deps.clock.now().getTime() - startedAt;
+    // One read, retrying only a route that is still warming.
+    const read = async () => {
+        for (;;) {
+            const observation = await deps.probeHealth({
+                baseUrl: input.baseUrl,
+                repoName: input.repoName,
+                apiKey: input.apiKey,
+                component: "reconciler",
+            });
+            const result = observation.result;
+            if (result.kind === "state") {
+                return { kind: "row", state: result.state, observedAtMs: observation.observedAtMs };
+            }
+            if (result.kind !== "unavailable" || elapsed() >= budgetMs) {
+                return { kind: "unsafe", reason: `the reconciler heartbeat could not be read (${result.kind})` };
+            }
+            await deps.clock.sleep(pollMs);
+        }
+    };
+    const first = await read();
+    if (first.kind === "unsafe")
+        return first;
+    if (first.state === "unknown") {
+        return { kind: "unsafe", reason: "the server could not read the reconciler heartbeat" };
+    }
+    if (first.state !== "fresh")
+        return { kind: "clear" };
+    const firstSeen = first.observedAtMs;
+    if (firstSeen === null) {
+        return { kind: "unsafe", reason: "a fresh reconciler heartbeat carried no timestamp" };
+    }
+    await deps.clock.sleep(intervalMs);
+    for (;;) {
+        const next = await read();
+        if (next.kind === "unsafe")
+            return next;
+        if (next.state === "unknown") {
+            return { kind: "unsafe", reason: "the server could not read the reconciler heartbeat" };
+        }
+        if (next.observedAtMs !== null && next.observedAtMs > firstSeen)
+            return { kind: "foreign-live" };
+        if (next.state !== "fresh")
+            return { kind: "clear" };
+        if (elapsed() >= budgetMs) {
+            return {
+                kind: "unsafe",
+                reason: `a recent reconciler heartbeat did not go stale within ${Math.round(budgetMs / 1000)}s`,
+            };
+        }
+        await deps.clock.sleep(pollMs);
+    }
+}
+/** Operator-facing reason for the foreign-reconciler refusal. Fixed prose. */
+export const PLANE_FOREIGN_RECONCILER_REASON = "another reconciler is already ticking this database (its heartbeat advanced), so this " +
+    "plane's worker was NOT started — two reconcilers on one database are two transition " +
+    "authorities";
 /**
  * Private argv flag selecting the two-phase lifecycle on `plane __runtime`.
  *
@@ -448,6 +562,10 @@ export async function runPlaneRuntime(repoRoot, roster, deps) {
         updatedAt: deps.clock.now().toISOString(),
     };
     const started = [];
+    // BAPI-1279 — whether the most recent rollback was CONFIRMED complete. Read
+    // only by the foreign-reconciler refusal, which may say nothing was left
+    // running only when this is true.
+    let lastRollbackConfirmed = true;
     /**
      * Has {@link PLANE_CONTROL_READY_MARKER} been announced? (BAPI-1102)
      *
@@ -695,6 +813,29 @@ export async function runPlaneRuntime(repoRoot, roster, deps) {
                 }
                 baseline = outcome.baseline;
                 baselineElapsedMs = outcome.elapsedMs;
+                // BAPI-1279 — never start a second reconciler on a shared database. The
+                // server member is up by now (it is first in the roster), so the check
+                // can read the heartbeat; the worker is not spawned until it clears.
+                // `plane up` and drive-epic's cold start both reach this, so both get it.
+                if (spec.name === "worker" && readiness.component === "reconciler") {
+                    const guard = await guardForeignReconciler({
+                        deps,
+                        baseUrl: readiness.baseUrl,
+                        repoName: readiness.repoName,
+                        apiKey: spec.env.BAPI_API_KEY ?? "",
+                    });
+                    if (guard.kind === "foreign-live") {
+                        const failed = await finishPartialStart(spec.name, PLANE_FOREIGN_RECONCILER_REASON, {
+                            log: opened.stream,
+                            failure: PLANE_MEMBER_STARTUP_FAILURES.foreignReconcilerLive,
+                        });
+                        deps.sinks.stdout(`${PLANE_FOREIGN_RECONCILER_MARKER}:${lastRollbackConfirmed ? "rolled-back" : "rollback-incomplete"}`);
+                        return failed;
+                    }
+                    if (guard.kind === "unsafe") {
+                        return finishPartialStart(spec.name, `${guard.reason}, so it could not be confirmed that no other reconciler is live`, { log: opened.stream, failure: PLANE_MEMBER_STARTUP_FAILURES.readinessUnestablished });
+                    }
+                }
             }
             let child;
             try {
@@ -1015,6 +1156,7 @@ export async function runPlaneRuntime(repoRoot, roster, deps) {
                 clock: deps.clock,
                 selfPid: deps.selfPid,
             });
+            lastRollbackConfirmed = result.ok;
             if (!result.ok)
                 deps.sinks.stderr(`Rollback incomplete: ${result.message}`);
         }
@@ -1172,6 +1314,12 @@ function describeBaselineFailure(reason) {
  * sitting out the remaining budget. A worker that crashed on its first tick is
  * the case this readiness gate exists for, and reporting it two minutes late as
  * a timeout would describe the symptom rather than the cause.
+ *
+ * BAPI-1260 — what this does NOT prove. A member that is ready here is a
+ * PROCESS fact about this plane's own identified member. It is not an enrolled
+ * actor handshake: whether an actor can consume a privileged operation is the
+ * server's `durable_actor` admission evidence, and `drive-epic` keeps the two
+ * separate — process readiness admits scoped lanes, never dependent dispatch.
  */
 export async function waitForMemberReady(spec, deps, pollIntervalMs = 250, isAlive = () => true, heartbeat = {}) {
     if (!spec.readiness)