harnery 0.45.0 → 0.45.2

package/src/core/context/observation.ts

@@ -1,11 +1,13 @@
 /**
  * Repository observation contract shared by context recovery and workflow proof.
  *
- * This module has no runtime imports so read-only consumers (the Codec
- * dashboard, proof readers) can use it without reaching the Git-running
- * snapshot code in ./index.ts.
+ * This module runs no Git and touches no files, so read-only consumers (the
+ * Codec dashboard, proof readers) can use it without reaching the
+ * Git-running snapshot code in ./index.ts.
  */
 
+import { isAbsolute } from "node:path";
+
 export type RepoObservation = "ok" | "unavailable" | "partial";
 
 export interface RepoSnapshot {
@@ -20,10 +22,39 @@ export interface RepoSnapshot {
   dirty_paths_truncated?: boolean;
 }
 
-/** Only explicitly successful observations can establish repository drift. */
-export function observationsComparable(
-  a: { observation?: string },
-  b: { observation?: string },
-): boolean {
-  return a.observation === "ok" && b.observation === "ok";
+/**
+ * Every reason two snapshots cannot establish repository drift. Only an empty
+ * list lets a caller compare branch, HEAD and dirty paths; anything else
+ * leaves the whole comparison unknown.
+ */
+export function repoComparisonProblems(
+  a: RepoSnapshot,
+  b: RepoSnapshot,
+  labels: readonly [string, string],
+): string[] {
+  const sides = [
+    [labels[0], a],
+    [labels[1], b],
+  ] as const;
+  const failed = sides.flatMap(([label, repo]) =>
+    repo.observation === "ok"
+      ? []
+      : [
+          // Snapshots recorded before observations existed carry none.
+          `${label} snapshot is ${repo.observation ?? "unavailable"}${repo.observation_detail ? ` (${repo.observation_detail})` : ""}`,
+        ],
+  );
+  if (failed.length > 0) return failed;
+  const problems: string[] = [];
+  if (a.dirty_paths_truncated || b.dirty_paths_truncated) {
+    problems.push("dirty path list is truncated");
+  }
+  if (!a.root || !b.root || !isAbsolute(a.root) || !isAbsolute(b.root)) {
+    problems.push("repository root is unknown");
+  } else if (a.root !== b.root) {
+    problems.push("repository roots differ");
+  }
+  if (!a.branch?.trim() || !b.branch?.trim()) problems.push("branch is unknown");
+  if (!a.head?.trim() || !b.head?.trim()) problems.push("HEAD is unknown");
+  return problems;
 }

package/src/core/events/v3/authority-outbox.ts

@@ -16,7 +16,6 @@ import { fsyncParentDirectory } from "../../workflow/durable-record.ts";
 import { canonicalJsonV3, sha256V3 } from "./canonical.ts";
 import type { EventV3 } from "./contract.ts";
 import { liveGenesisIdV3 } from "./control.ts";
-import { assertCurrentGenerationV3, withGenerationCustodyV3 } from "./generation-custody.ts";
 import { assertEventV3 } from "./validate.ts";
 import { ensureEventV3Layout, eventV3Paths, writeEventV3 } from "./writer.ts";
 
@@ -155,32 +154,9 @@ export function publishAuthorityTransactionV3(
   coordRoot: string,
   transaction: AuthorityTransactionV3,
   fence: AuthorityEpochFenceV3 = {},
-): AuthorityTransactionV3 {
-  return withGenerationCustodyV3(
-    coordRoot,
-    [transaction.actor_instance_id, transaction.subject_instance_id],
-    () => publishAuthorityTransactionWithCustodyV3(coordRoot, transaction, fence),
-  );
-}
-
-function publishAuthorityTransactionWithCustodyV3(
-  coordRoot: string,
-  transaction: AuthorityTransactionV3,
-  fence: AuthorityEpochFenceV3,
 ): AuthorityTransactionV3 {
   validateTransaction(transaction);
   const paths = ensureEventV3Layout(coordRoot);
-  const committedPath = authorityCommittedPath(paths.authorityOutbox, transaction.transaction_id);
-  if (existsSync(committedPath)) {
-    if (
-      readAuthorityReceiptV3(committedPath).transaction_digest !==
-      sha256V3(`${canonicalJsonV3(transaction)}\n`)
-    ) {
-      throw new Error("authority committed transaction conflicts with this transaction");
-    }
-    return transaction;
-  }
-  assertTransactionGeneration(coordRoot, transaction);
   if (fence.expectedGenesisId && liveGenesisIdV3(coordRoot) !== fence.expectedGenesisId) {
     throw new Error("authority transaction epoch was replaced before publication");
   }
@@ -209,26 +185,6 @@ export function reconcileAuthorityTransactionV3(
   transactionId: string,
   reconciler: AuthorityReconcilerV3,
   fence: AuthorityEpochFenceV3 = {},
-): AuthorityReceiptV3 {
-  assertTransactionId(transactionId);
-  const paths = ensureEventV3Layout(coordRoot);
-  const committedPath = authorityCommittedPath(paths.authorityOutbox, transactionId);
-  if (existsSync(committedPath)) return readAuthorityReceiptV3(committedPath);
-  const transaction = readAuthorityTransactionV3(
-    authorityReadyPath(paths.authorityOutbox, transactionId),
-  );
-  return withGenerationCustodyV3(
-    coordRoot,
-    [transaction.actor_instance_id, transaction.subject_instance_id],
-    () => reconcileAuthorityTransactionWithCustodyV3(coordRoot, transactionId, reconciler, fence),
-  );
-}
-
-function reconcileAuthorityTransactionWithCustodyV3(
-  coordRoot: string,
-  transactionId: string,
-  reconciler: AuthorityReconcilerV3,
-  fence: AuthorityEpochFenceV3,
 ): AuthorityReceiptV3 {
   assertTransactionId(transactionId);
   const paths = ensureEventV3Layout(coordRoot);
@@ -236,10 +192,8 @@ function reconcileAuthorityTransactionWithCustodyV3(
   if (existsSync(committedPath)) return readAuthorityReceiptV3(committedPath);
   const readyPath = authorityReadyPath(paths.authorityOutbox, transactionId);
   const transaction = readAuthorityTransactionV3(readyPath);
-  assertTransactionGeneration(coordRoot, transaction);
   const current = reconciler.readStateDigest();
   if (current === transaction.expected_prior_state_digest) {
-    assertTransactionGeneration(coordRoot, transaction);
     reconciler.apply(transaction.mutation, transaction.transaction_id);
   } else if (current !== transaction.desired_state_digest) {
     throw new Error("authority transaction prior state conflicts with current state");
@@ -247,7 +201,6 @@ function reconcileAuthorityTransactionWithCustodyV3(
   if (reconciler.readStateDigest() !== transaction.desired_state_digest) {
     throw new Error("authority transaction did not reach its declared desired state");
   }
-  assertTransactionGeneration(coordRoot, transaction);
   const event = JSON.parse(transaction.event_row) as unknown;
   assertEventV3(event);
   const durability = writeEventV3(coordRoot, event, {
@@ -277,15 +230,6 @@ function reconcileAuthorityTransactionWithCustodyV3(
   return receipt;
 }
 
-function assertTransactionGeneration(coordRoot: string, transaction: AuthorityTransactionV3): void {
-  const event = JSON.parse(transaction.event_row) as EventV3;
-  assertCurrentGenerationV3(
-    coordRoot,
-    transaction.actor_instance_id,
-    "generation_id" in event.scope ? event.scope.generation_id : undefined,
-  );
-}
-
 export function listPendingAuthorityTransactionsV3(coordRoot: string): AuthorityTransactionV3[] {
   const outbox = eventV3Paths(coordRoot).authorityOutbox;
   if (!existsSync(outbox)) return [];

package/src/core/events/v3/producers/coordination-recorder.ts

@@ -33,7 +33,6 @@ import { markObservedClockRegressionV3 } from "../clock-order.ts";
 import type { EventV3 } from "../contract.ts";
 import { type EventV3WriteMode, readEventV3ControlState } from "../control.ts";
 import { fingerprintContextV3 } from "../fingerprint-keys.ts";
-import { assertCurrentGenerationV3, withGenerationCustodyV3 } from "../generation-custody.ts";
 import { clockIdV3, spanIdV3 } from "../ids.ts";
 import { closeSpanStateV3, type OpenSpanStateV3, openSpanStateV3 } from "../span-state.ts";
 import { EVENT_V3_LEDGER_RELATIVE_ROOT } from "../writer.ts";
@@ -104,7 +103,6 @@ export interface RecordCoordinationAuthorityV3Input<
   bridge?: "codex-wsl";
   expected_prior_state_digest: `sha256:${string}`;
   desired_state_digest: `sha256:${string}`;
-  expected_generation_id?: `gen_${string}`;
   monotonic_ns?: string;
   observed_at?: string;
   reconciler: AuthorityReconcilerV3;
@@ -131,16 +129,6 @@ export type RecordCoordinationAuthorityV3Result =
  */
 export function recordCoordinationAuthorityV3<S extends CoordinationAuthoritySignalV3>(
   input: RecordCoordinationAuthorityV3Input<S>,
-): RecordCoordinationAuthorityV3Result {
-  return withGenerationCustodyV3(
-    input.coordRoot,
-    [input.actor_instance_id, input.subject_instance_id],
-    () => recordCoordinationAuthorityWithCustodyV3(input),
-  );
-}
-
-function recordCoordinationAuthorityWithCustodyV3<S extends CoordinationAuthoritySignalV3>(
-  input: RecordCoordinationAuthorityV3Input<S>,
 ): RecordCoordinationAuthorityV3Result {
   const control = readEventV3ControlState(input.coordRoot);
   if (control.state !== input.mode) return { state: "gate_closed", reason: control.state };
@@ -153,8 +141,6 @@ function recordCoordinationAuthorityWithCustodyV3<S extends CoordinationAuthorit
   if (
     !hook ||
     hook.terminal ||
-    (input.expected_generation_id !== undefined &&
-      hook.generation_id !== input.expected_generation_id) ||
     hook.instance_id !== input.actor_instance_id ||
     !hook.last_event_id
   ) {
@@ -342,7 +328,6 @@ function recordCoordinationAuthorityWithCustodyV3<S extends CoordinationAuthorit
       mutation: normalized.mutation,
       event: normalized.event,
     });
-    assertCurrentGenerationV3(input.coordRoot, state.actor_instance_id, state.generation_id);
     if (input.signal === "wait-ended" && waitId) delete state.open_waits[waitId];
     state.pending = { source_id: sourceId, transaction };
     publishCoordinationState(path, state);

package/src/core/events/v3/producers/recorder.ts

@@ -43,7 +43,6 @@ import { markObservedClockRegressionV3 } from "../clock-order.ts";
 import type { EventV3 } from "../contract.ts";
 import { type EventV3WriteMode, readEventV3ControlState } from "../control.ts";
 import { fingerprintContextV3 } from "../fingerprint-keys.ts";
-import { withGenerationCustodyV3 } from "../generation-custody.ts";
 import {
   attestationIdV3,
   clockIdV3,
@@ -659,17 +658,6 @@ function processHookSignalLocked(
   input: RecordHookSignalV3Input,
   sessionHash: `hid_${string}`,
   path: string,
-): RecordHookSignalV3Result {
-  return withGenerationCustodyV3(input.coordRoot, [input.instance_id], () =>
-    processHookSignalWithCustodyLocked(control, input, sessionHash, path),
-  );
-}
-
-function processHookSignalWithCustodyLocked(
-  control: OpenHookControlStateV3,
-  input: RecordHookSignalV3Input,
-  sessionHash: `hid_${string}`,
-  path: string,
 ): RecordHookSignalV3Result {
   const behavior = adapterBehavior(input.adapter);
   const rootId = control.genesis.event.scope.root_id as `root_${string}`;
@@ -3221,14 +3209,6 @@ function suppressClosedSpanSignal(
  */
 export function recordApprovedSessionEndV3(
   input: RecordApprovedSessionEndV3Input,
-): RecordApprovedSessionEndV3Result {
-  return withGenerationCustodyV3(input.coordRoot, [input.instance_id], () =>
-    recordApprovedSessionEndWithCustodyV3(input),
-  );
-}
-
-function recordApprovedSessionEndWithCustodyV3(
-  input: RecordApprovedSessionEndV3Input,
 ): RecordApprovedSessionEndV3Result {
   const control = readEventV3ControlState(input.coordRoot);
   if (control.state !== input.mode) {
@@ -3576,81 +3556,77 @@ export function reanchorArchivedHookProducersV3(
   for (const archived of listArchivedHookProducerStatesV3(input.archivedEpoch)) {
     const previous = archived.state;
     if (previous.terminal || !previous.started_event_id) continue;
-    withGenerationCustodyV3(input.coordRoot, [previous.instance_id], () => {
-      const path = producerStatePath(input.coordRoot, previous.adapter, archived.sessionHash);
-      const lease = acquireStateLeaseWithRetry(input.coordRoot, path, 40);
-      if (!lease) {
-        throw new Error(`event_v3_rotation_reanchor_busy:${previous.instance_id}`);
+    const path = producerStatePath(input.coordRoot, previous.adapter, archived.sessionHash);
+    const lease = acquireStateLeaseWithRetry(input.coordRoot, path, 40);
+    if (!lease) {
+      throw new Error(`event_v3_rotation_reanchor_busy:${previous.instance_id}`);
+    }
+    try {
+      if (existsSync(path)) {
+        const current = readProducerState(path);
+        if (current.epoch_genesis_id === genesisId) continue;
       }
-      try {
-        if (existsSync(path)) {
-          const current = readProducerState(path);
-          if (current.epoch_genesis_id === genesisId) return;
-        }
-        const sourceEvent = `${previous.adapter}.epoch-rotation-reanchor`;
-        const rotationInput: RecordHookSignalV3Input = {
-          coordRoot: input.coordRoot,
-          mode: input.mode,
-          signal: "session-start",
-          payload: {
-            raw: {},
-            ...(previous.current_native_turn_id
-              ? { turn_id: previous.current_native_turn_id }
-              : {}),
-            ...(adapterBehavior(previous.adapter).tracksExecutionMode && previous.cursor_mode
-              ? { cursor_mode: previous.cursor_mode }
-              : {}),
-          },
-          adapter: previous.adapter,
-          instance_id: previous.instance_id,
-          producer_id: "prd_agent-hook",
-          build_id: input.build_id,
-          platform: input.platform,
-          observed_at: observedAt,
-          writerOptions: { expectedGenesisId: genesisId },
-        };
-        const state = newProducerState(
-          rotationInput,
-          previous.session_id,
-          epochId,
-          boundaryEventId as `evt_${string}`,
-          genesisId,
-        );
-        const sessionStart = buildMidFlightSessionStart(rotationInput, state, rootId);
-        if (sessionStart.event_type !== "session.started") {
-          throw new Error("rotation re-anchor session start could not be normalized");
-        }
-        sessionStart.provenance = {
-          ...sessionStart.provenance,
+      const sourceEvent = `${previous.adapter}.epoch-rotation-reanchor`;
+      const rotationInput: RecordHookSignalV3Input = {
+        coordRoot: input.coordRoot,
+        mode: input.mode,
+        signal: "session-start",
+        payload: {
+          raw: {},
+          ...(previous.current_native_turn_id ? { turn_id: previous.current_native_turn_id } : {}),
+          ...(adapterBehavior(previous.adapter).tracksExecutionMode && previous.cursor_mode
+            ? { cursor_mode: previous.cursor_mode }
+            : {}),
+        },
+        adapter: previous.adapter,
+        instance_id: previous.instance_id,
+        producer_id: "prd_agent-hook",
+        build_id: input.build_id,
+        platform: input.platform,
+        observed_at: observedAt,
+        writerOptions: { expectedGenesisId: genesisId },
+      };
+      const state = newProducerState(
+        rotationInput,
+        previous.session_id,
+        epochId,
+        boundaryEventId as `evt_${string}`,
+        genesisId,
+      );
+      const sessionStart = buildMidFlightSessionStart(rotationInput, state, rootId);
+      if (sessionStart.event_type !== "session.started") {
+        throw new Error("rotation re-anchor session start could not be normalized");
+      }
+      sessionStart.provenance = {
+        ...sessionStart.provenance,
+        source_event: sourceEvent,
+        attestation: "derived",
+        confidence: "high",
+        attribution: {
+          method: "session_env",
+          state: "verified",
+          subject_instance_id: state.instance_id,
+        },
+      };
+      sessionStart.payload.resume = {
+        state: "unknown",
+        reason: "epoch_rotation_reanchor",
+      };
+      assertEventV3(sessionStart);
+      commitEventLocked(rotationInput, state, path, sessionStart);
+      sessions += 1;
+
+      if (previous.current_turn_id && previous.current_turn_span) {
+        commitMidFlightTurnStart(rotationInput, state, path, rootId, {
           source_event: sourceEvent,
-          attestation: "derived",
           confidence: "high",
-          attribution: {
-            method: "session_env",
-            state: "verified",
-            subject_instance_id: state.instance_id,
-          },
-        };
-        sessionStart.payload.resume = {
-          state: "unknown",
-          reason: "epoch_rotation_reanchor",
-        };
-        assertEventV3(sessionStart);
-        commitEventLocked(rotationInput, state, path, sessionStart);
-        sessions += 1;
-
-        if (previous.current_turn_id && previous.current_turn_span) {
-          commitMidFlightTurnStart(rotationInput, state, path, rootId, {
-            source_event: sourceEvent,
-            confidence: "high",
-            attribution_method: "session_env",
-          });
-          turns += 1;
-        }
-      } finally {
-        lease.release();
+          attribution_method: "session_env",
+        });
+        turns += 1;
       }
-    });
+    } finally {
+      lease.release();
+    }
   }
   return { sessions, turns };
 }
@@ -3888,9 +3864,7 @@ export function readJoinableHookProducerStateV3(
   instanceId: `inst_${string}`,
 ): HookProducerStateV3 | undefined {
   const direct = readHookProducerStateV3(coordRoot, adapter, nativeSessionId);
-  // A terminal native session belonging to this actor is stale authority,
-  // not permission to adopt a replacement published under the same instance.
-  if (direct?.instance_id === instanceId) return direct.terminal ? undefined : direct;
+  if (direct?.instance_id === instanceId && !direct.terminal) return direct;
   const byInstance = readHookProducerStateByInstanceV3(coordRoot, instanceId);
   return byInstance?.adapter === adapter && !byInstance.terminal ? byInstance : undefined;
 }

package/src/core/events/v3/runtime-build.ts

@@ -40,3 +40,65 @@ export function currentHarneryRuntimeBuild(): string {
 export function harneryPackageRoot(): string {
   return resolve(dirname(fileURLToPath(import.meta.url)), "../../../..");
 }
+
+export interface HarneryBuild {
+  version: string;
+  revision: string;
+}
+
+/** The installed package version and runtime revision; "unknown" when unreadable. */
+export function installedHarneryBuild(): HarneryBuild {
+  let version = "unknown";
+  let revision = "unknown";
+  try {
+    const manifest = JSON.parse(
+      readFileSync(resolve(harneryPackageRoot(), "package.json"), "utf8"),
+    ) as { version?: unknown };
+    if (typeof manifest.version === "string" && manifest.version.length <= 100)
+      version = manifest.version;
+  } catch {
+    // Missing package metadata cannot establish that a running build is current.
+  }
+  try {
+    revision = currentHarneryRuntimeBuild();
+  } catch {
+    // Status still reports the unavailable build instead of guessing a match.
+  }
+  return { version, revision };
+}
+
+export interface ServiceBuildStatus {
+  running_build: HarneryBuild | null;
+  installed_build: HarneryBuild;
+  restart_needed: boolean;
+  build_status: string;
+}
+
+/** A missing or unknown running build, or any difference, means restart. */
+export function serviceBuildStatus(recorded: unknown): ServiceBuildStatus {
+  const installed_build = installedHarneryBuild();
+  const candidate = recorded as Partial<HarneryBuild> | undefined;
+  const known = (value: unknown): value is string =>
+    typeof value === "string" && value.length > 0 && value.length <= 100 && value !== "unknown";
+  const running_build =
+    candidate && known(candidate.version) && known(candidate.revision)
+      ? { version: candidate.version, revision: candidate.revision }
+      : null;
+  const restart_needed =
+    running_build === null ||
+    installed_build.version === "unknown" ||
+    installed_build.revision === "unknown" ||
+    running_build.version !== installed_build.version ||
+    running_build.revision !== installed_build.revision;
+  return {
+    running_build,
+    installed_build,
+    restart_needed,
+    build_status:
+      running_build === null
+        ? "running build unknown; restart needed"
+        : restart_needed
+          ? "restart needed"
+          : "current",
+  };
+}

package/src/core/governor/index.ts

@@ -63,13 +63,12 @@ export {
   type RunGovernorServiceDaemonInput,
   type RunGovernorServiceSweepInput,
   readGovernorServiceConfig,
-  readGovernorServiceRuntime,
-  readGovernorServiceStatus,
   requestGovernorServiceStop,
   runGovernorServiceDaemon,
   runGovernorServiceSweep,
   spawnGovernorService,
 } from "./service.ts";
+export { readGovernorServiceRuntime, readGovernorServiceStatus } from "./service-read.ts";
 export {
   assertGovernorId,
   type CreateGovernorInput,

package/src/core/governor/service-read.ts

@@ -1,21 +1,20 @@
 import { closeSync, existsSync, openSync, readFileSync, readSync, statSync } from "node:fs";
-import { hostname } from "node:os";
 import { join, resolve } from "node:path";
 import { gunzipSync } from "node:zlib";
 import { coordEnv } from "../../lib/env.ts";
+import type { ProcessGenerationVerdict } from "../agents/state/proc-start.ts";
 import {
-  type ProcessGenerationVerdict,
-  verifyProcessGeneration,
-} from "../agents/state/proc-start.ts";
-import { currentHarneryRuntimeBuild } from "../events/v3/runtime-build.ts";
+  observeServiceProcess,
+  type ServiceLiveness,
+  type ServiceProcessDependencies,
+} from "../agents/state/service-process.ts";
+import { serviceBuildStatus } from "../events/v3/runtime-build.ts";
 import { createStorageCatalog } from "../storage/catalog.ts";
 import type { HarneryLogRecordV1 } from "../storage/jsonl.ts";
 import { parseLogRecord } from "../storage/jsonl.ts";
 import { familyLogDirectory, readSegmentManifest } from "../storage/segments.ts";
 import type {
-  GovernorServiceBuild,
   GovernorServiceConfig,
-  GovernorServiceProcessDependencies,
   GovernorServiceRuntime,
   GovernorServiceStatus,
   GovernorServiceStatusRecord,
@@ -25,106 +24,6 @@ const MAX_FILE_BYTES = 512 * 1024;
 const MAX_LOG_RECORDS = 10_000;
 const MAX_GOALS = 100;
 
-export function currentGovernorServiceBuild(): GovernorServiceBuild {
-  let version = "unknown";
-  let revision = "unknown";
-  try {
-    const manifest = JSON.parse(
-      readFileSync(new URL("../../../package.json", import.meta.url), "utf8"),
-    ) as {
-      version?: unknown;
-    };
-    if (typeof manifest.version === "string" && manifest.version.length <= 100) {
-      version = manifest.version;
-    }
-  } catch {
-    // Missing package metadata cannot establish that the running build is current.
-  }
-  try {
-    revision = currentHarneryRuntimeBuild();
-  } catch {
-    // Status still reports the unavailable build instead of guessing a match.
-  }
-  return { version, revision };
-}
-
-export function governorServiceBuildStatus(
-  record: GovernorServiceStatusRecord | undefined,
-): Pick<
-  GovernorServiceStatus,
-  "running_build" | "installed_build" | "restart_needed" | "build_status"
-> {
-  const installed_build = currentGovernorServiceBuild();
-  const candidate = record?.running_build;
-  const running_build =
-    candidate &&
-    typeof candidate.version === "string" &&
-    candidate.version.length > 0 &&
-    candidate.version.length <= 100 &&
-    typeof candidate.revision === "string" &&
-    candidate.revision.length > 0 &&
-    candidate.revision.length <= 100 &&
-    candidate.version !== "unknown" &&
-    candidate.revision !== "unknown"
-      ? candidate
-      : null;
-  const restart_needed =
-    running_build === null ||
-    installed_build.version === "unknown" ||
-    installed_build.revision === "unknown" ||
-    running_build.version !== installed_build.version ||
-    running_build.revision !== installed_build.revision;
-  return {
-    running_build,
-    installed_build,
-    restart_needed,
-    build_status:
-      running_build === null
-        ? "running build unknown; restart needed"
-        : restart_needed
-          ? "restart needed"
-          : "current",
-  };
-}
-
-/** An unknown token or process probe cannot establish a running or stopped owner. */
-export function observeGovernorServiceProcess(
-  record: Pick<GovernorServiceStatusRecord, "pid" | "host" | "state" | "start_token"> | undefined,
-  dependencies: GovernorServiceProcessDependencies = {},
-): { generation: ProcessGenerationVerdict; liveness: GovernorServiceStatus["liveness"] } {
-  if (!record) return { generation: "unknown", liveness: "stopped" };
-  const generation =
-    record.host === hostname()
-      ? verifyProcessGeneration(record.pid, record.start_token, dependencies.readToken)
-      : "unknown";
-  if (record.host !== hostname()) return { generation, liveness: "unknown" };
-  try {
-    const present = (dependencies.probePid ?? probePid)(record.pid);
-    if (!present) return { generation, liveness: "stopped" };
-  } catch (error) {
-    return {
-      generation,
-      liveness: (error as NodeJS.ErrnoException).code === "ESRCH" ? "stopped" : "unknown",
-    };
-  }
-  return {
-    generation,
-    liveness:
-      generation === "same"
-        ? record.state === "stopped"
-          ? "stopped"
-          : "running"
-        : generation === "different"
-          ? "stopped"
-          : "unknown",
-  };
-}
-
-function probePid(pid: number): boolean {
-  process.kill(pid, 0);
-  return true;
-}
-
 export function readGovernorServiceConfig(coordRootRaw: string): GovernorServiceConfig {
   const coordRoot = resolve(coordRootRaw);
   const config = readBoundedJson<GovernorServiceConfig>(
@@ -175,7 +74,7 @@ export function readGovernorServiceRuntime(
 
 export function readGovernorServiceStatus(
   coordRootRaw: string,
-  dependencies: GovernorServiceProcessDependencies = {},
+  dependencies: ServiceProcessDependencies = {},
 ): GovernorServiceStatus {
   const coordRoot = resolve(coordRootRaw);
   const record = readStatusRecord(coordRoot);
@@ -191,15 +90,17 @@ export function readGovernorServiceStatus(
   } catch {
     // Runtime is recoverable and must not make the dashboard unreadable.
   }
-  const observation = observeGovernorServiceProcess(record, dependencies);
-  if (!record && existsSync(join(serviceDir(coordRoot), "status.json"))) {
-    observation.liveness = "unknown";
-  }
+  const observation: { generation: ProcessGenerationVerdict; liveness: ServiceLiveness } = record
+    ? observeServiceProcess(record, dependencies)
+    : {
+        generation: "unknown",
+        liveness: existsSync(join(serviceDir(coordRoot), "status.json")) ? "unknown" : "stopped",
+      };
   return {
-    running: observation.liveness === "running" && record?.state !== "stopped",
+    running: observation.liveness === "running",
     stale: observation.liveness === "stopped" && record !== undefined && record.state !== "stopped",
     ...observation,
-    ...governorServiceBuildStatus(record),
+    ...serviceBuildStatus(record?.running_build),
     record,
     config,
     runtime,