harnery 0.45.0 → 0.45.2

package/src/core/governor/service.ts

@@ -10,30 +10,28 @@ import {
   renameSync,
   rmSync,
   statSync,
-  unlinkSync,
   writeFileSync,
 } from "node:fs";
 import { hostname } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { coordEnv } from "../../lib/env.ts";
+import { type ProcessGenerationVerdict, processStartToken } from "../agents/state/proc-start.ts";
 import {
-  type ProcessGenerationSignalDependencies,
-  type ProcessGenerationVerdict,
-  processStartToken,
-  signalIfSameGeneration,
-} from "../agents/state/proc-start.ts";
+  acquireServiceLease,
+  requestServiceStop,
+  type ServiceLiveness,
+  type ServiceProcessDependencies,
+  serviceStartRefusal,
+} from "../agents/state/service-process.ts";
 import { resolveBinName } from "../config.ts";
+import { installedHarneryBuild } from "../events/v3/runtime-build.ts";
 import { type NormalizedPolicy, normalizePolicy, type PolicyIsolation } from "../policy/index.ts";
 import { closeProcessLoggers, legacyLogFields, processLogger } from "../storage/logger.ts";
 import { stateDirMode, stateFileMode } from "../storage/modes.ts";
 import { RotatingTextSink } from "../storage/process-log.ts";
 import type { RunWorkItemInput } from "../work/index.ts";
 import { type GovernorRunReport, type GovernorStopReason, runGovernor } from "./runner.ts";
-import {
-  currentGovernorServiceBuild,
-  governorServiceBuildStatus,
-  observeGovernorServiceProcess,
-} from "./service-read.ts";
+import { readGovernorServiceRuntime, readGovernorServiceStatus } from "./service-read.ts";
 import { type GovernorRecord, readGovernor } from "./state.ts";
 
 export const GOVERNOR_SERVICE_CONFIG_SCHEMA_VERSION = 1 as const;
@@ -101,10 +99,6 @@ export interface GovernorServiceBuild {
   revision: string;
 }
 
-export interface GovernorServiceProcessDependencies extends ProcessGenerationSignalDependencies {
-  probePid?: (pid: number) => boolean;
-}
-
 export interface GovernorServiceStatusRecord {
   schema_version: typeof GOVERNOR_SERVICE_STATUS_SCHEMA_VERSION;
   pid: number;
@@ -173,27 +167,13 @@ export interface RunGovernorServiceDaemonInput {
   onLog?: (line: string) => void;
 }
 
-interface ServiceLease {
-  pid: number;
-  start_token?: string;
-  running_build?: GovernorServiceBuild;
-  host: string;
-  nonce: string;
-  created_at: string;
-}
-
 export function configureGovernorService(
   input: ConfigureGovernorServiceInput,
 ): GovernorServiceConfig {
   const coordRoot = resolve(input.coordRoot);
-  const active = readStatusRecord(coordRoot);
-  if (!active && existsSync(serviceStatusPath(coordRoot))) {
-    throw serviceStartRefusal(coordRoot, undefined, "unknown");
-  }
-  if (active) {
-    const liveness = statusOwnerIsLive(active);
-    if (liveness !== "stopped") throw serviceStartRefusal(coordRoot, active.pid, liveness);
-  }
+  const current = readGovernorServiceStatus(coordRoot);
+  if (current.liveness !== "stopped")
+    throw startRefusal(coordRoot, current.record?.pid, current.liveness);
   const goalIds = unique(input.goalIds.map((value) => value.trim()).filter(Boolean));
   if (goalIds.length < 1 || goalIds.length > MAX_GOALS) {
     throw new Error(`governor service requires from 1 to ${MAX_GOALS} unique goal ids`);
@@ -249,65 +229,12 @@ export function readGovernorServiceConfig(coordRootRaw: string): GovernorService
   return config;
 }
 
-export function readGovernorServiceRuntime(
-  coordRootRaw: string,
-): GovernorServiceRuntime | undefined {
-  const coordRoot = resolve(coordRootRaw);
-  if (!existsSync(serviceRuntimePath(coordRoot))) return undefined;
-  const runtime = readBoundedJson<GovernorServiceRuntime>(
-    serviceRuntimePath(coordRoot),
-    "governor service runtime",
-  );
-  if (
-    runtime.schema_version !== GOVERNOR_SERVICE_RUNTIME_SCHEMA_VERSION ||
-    !validTimestamp(runtime.config_created_at) ||
-    !validTimestamp(runtime.updated_at) ||
-    !runtime.goals ||
-    typeof runtime.goals !== "object" ||
-    Array.isArray(runtime.goals)
-  ) {
-    throw new Error("governor service runtime has an unsupported schema");
-  }
-  return runtime;
-}
-
-export function readGovernorServiceStatus(
-  coordRootRaw: string,
-  dependencies: GovernorServiceProcessDependencies = {},
-): GovernorServiceStatus {
-  const coordRoot = resolve(coordRootRaw);
-  const record = readStatusRecord(coordRoot);
-  let config: GovernorServiceConfig | undefined;
-  let runtime: GovernorServiceRuntime | undefined;
-  try {
-    config = readGovernorServiceConfig(coordRoot);
-  } catch {
-    // A service has no usable configuration until explicitly configured.
-  }
-  try {
-    runtime = readGovernorServiceRuntime(coordRoot);
-  } catch {
-    // Status remains readable when recoverable runtime state is corrupt.
-  }
-  const observation = observeGovernorServiceProcess(record, dependencies);
-  if (!record && existsSync(serviceStatusPath(coordRoot))) observation.liveness = "unknown";
-  return {
-    running: observation.liveness === "running" && record?.state !== "stopped",
-    stale: observation.liveness === "stopped" && record !== undefined && record.state !== "stopped",
-    ...observation,
-    ...governorServiceBuildStatus(record),
-    record,
-    config,
-    runtime,
-  };
-}
-
 export async function spawnGovernorService(coordRootRaw: string): Promise<GovernorServiceStatus> {
   const coordRoot = resolve(coordRootRaw);
   readGovernorServiceConfig(coordRoot);
   const current = readGovernorServiceStatus(coordRoot);
   if (current.liveness !== "stopped") {
-    throw serviceStartRefusal(coordRoot, current.record?.pid, current.liveness);
+    throw startRefusal(coordRoot, current.record?.pid, current.liveness);
   }
   mkdirSync(serviceDir(coordRoot), { recursive: true, mode: stateDirMode() });
   const sharedLogs = coordEnv("SHARED_LOGS") !== "0";
@@ -347,31 +274,19 @@ export async function spawnGovernorService(coordRootRaw: string): Promise<Govern
 
 export function requestGovernorServiceStop(
   coordRootRaw: string,
-  dependencies: GovernorServiceProcessDependencies = {},
+  dependencies: ServiceProcessDependencies = {},
 ): GovernorServiceStatus {
   const coordRoot = resolve(coordRootRaw);
   const status = readGovernorServiceStatus(coordRoot, dependencies);
   if ((status.record?.state === "stopped" || !status.record) && status.liveness === "stopped") {
     return { ...status, signal_sent: false, signal_verdict: status.generation };
   }
-  writePrivateJsonAtomic(serviceStopPath(coordRoot), {
-    requested_at: new Date().toISOString(),
-    requested_by_pid: process.pid,
-  });
-  const signal =
-    status.record?.host === hostname() && status.record.state !== "stopped"
-      ? signalIfSameGeneration(
-          status.record.pid,
-          status.record.start_token,
-          "SIGTERM",
-          dependencies,
-        )
-      : { sent: false, verdict: status.generation };
-  return {
-    ...readGovernorServiceStatus(coordRoot, dependencies),
-    signal_sent: signal.sent,
-    signal_verdict: signal.verdict,
-  };
+  return requestServiceStop(
+    status,
+    () => readGovernorServiceStatus(coordRoot, dependencies),
+    serviceStopPath(coordRoot),
+    dependencies,
+  );
 }
 
 export async function runGovernorServiceSweep(
@@ -519,22 +434,21 @@ export async function runGovernorServiceDaemon(
 ): Promise<GovernorServiceStatusRecord> {
   const coordRoot = resolve(input.coordRoot);
   const config = readGovernorServiceConfig(coordRoot);
-  const existing = readStatusRecord(coordRoot);
-  if (!existing && existsSync(serviceStatusPath(coordRoot))) {
-    throw serviceStartRefusal(coordRoot, undefined, "unknown");
-  }
-  if (existing) {
-    const liveness = statusOwnerIsLive(existing);
-    if (liveness !== "stopped") throw serviceStartRefusal(coordRoot, existing.pid, liveness);
-  }
-  const release = acquireServiceLease(coordRoot);
+  const current = readGovernorServiceStatus(coordRoot);
+  if (current.liveness !== "stopped")
+    throw startRefusal(coordRoot, current.record?.pid, current.liveness);
+  const { release } = acquireServiceLease(
+    serviceLeasePath(coordRoot),
+    (pid, liveness) => startRefusal(coordRoot, pid, liveness),
+    { running_build: installedHarneryBuild() },
+  );
   rmSync(serviceStopPath(coordRoot), { force: true });
   const now = new Date().toISOString();
   const status: GovernorServiceStatusRecord = {
     schema_version: GOVERNOR_SERVICE_STATUS_SCHEMA_VERSION,
     pid: process.pid,
     start_token: processStartToken(process.pid) ?? undefined,
-    running_build: currentGovernorServiceBuild(),
+    running_build: installedHarneryBuild(),
     host: hostname(),
     nonce: randomUUID(),
     state: "starting",
@@ -781,114 +695,16 @@ function normalizeIsolation(value: unknown): PolicyIsolation | undefined {
   throw new Error("service isolation must be shared, worktree, sandbox, or remote");
 }
 
-function acquireServiceLease(coordRoot: string): () => void {
-  const path = serviceLeasePath(coordRoot);
-  mkdirSync(dirname(path), { recursive: true, mode: stateDirMode() });
-  const owner: ServiceLease = {
-    pid: process.pid,
-    start_token: processStartToken(process.pid) ?? undefined,
-    running_build: currentGovernorServiceBuild(),
-    host: hostname(),
-    nonce: randomUUID(),
-    created_at: new Date().toISOString(),
-  };
-  const acquire = (): boolean => {
-    try {
-      const fd = openSync(path, "wx", stateFileMode());
-      try {
-        writeFileSync(fd, `${JSON.stringify(owner)}\n`, "utf8");
-      } finally {
-        closeSync(fd);
-      }
-      return true;
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
-      return false;
-    }
-  };
-  if (!acquire()) {
-    const existing = readLease(path);
-    const liveness = existing ? leaseOwnerIsLive(existing) : "unknown";
-    if (liveness !== "stopped") {
-      throw serviceStartRefusal(coordRoot, existing?.pid, liveness);
-    }
-    unlinkSync(path);
-    if (!acquire()) throw new Error("governor service lease raced with another process");
-  }
-  return () => {
-    try {
-      const existing = readLease(path);
-      if (existing?.nonce === owner.nonce) unlinkSync(path);
-    } catch {
-      // A stale lease is recoverable by the next explicit service start.
-    }
-  };
-}
-
-function readLease(path: string): ServiceLease | null {
-  try {
-    const value = JSON.parse(readFileSync(path, "utf8")) as Partial<ServiceLease>;
-    return Number.isSafeInteger(value.pid) &&
-      (value.pid ?? 0) > 0 &&
-      typeof value.host === "string" &&
-      typeof value.nonce === "string" &&
-      typeof value.created_at === "string"
-      ? ({
-          ...value,
-          start_token: typeof value.start_token === "string" ? value.start_token : undefined,
-        } as ServiceLease)
-      : null;
-  } catch {
-    return null;
-  }
-}
-
-function leaseOwnerIsLive(lease: ServiceLease): GovernorServiceStatus["liveness"] {
-  return observeGovernorServiceProcess({ ...lease, state: "running" }).liveness;
-}
-
-function readStatusRecord(coordRoot: string): GovernorServiceStatusRecord | undefined {
-  if (!existsSync(serviceStatusPath(coordRoot))) return undefined;
-  try {
-    const value = readBoundedJson<GovernorServiceStatusRecord>(
-      serviceStatusPath(coordRoot),
-      "governor service status",
-    );
-    if (
-      value.schema_version !== GOVERNOR_SERVICE_STATUS_SCHEMA_VERSION ||
-      !Number.isSafeInteger(value.pid) ||
-      value.pid < 1 ||
-      typeof value.host !== "string" ||
-      typeof value.nonce !== "string" ||
-      !validTimestamp(value.started_at) ||
-      !validTimestamp(value.heartbeat_at)
-    ) {
-      return undefined;
-    }
-    return {
-      ...value,
-      start_token: typeof value.start_token === "string" ? value.start_token : undefined,
-    };
-  } catch {
-    return undefined;
-  }
-}
-
-function statusOwnerIsLive(record: GovernorServiceStatusRecord): GovernorServiceStatus["liveness"] {
-  return observeGovernorServiceProcess(record).liveness;
-}
-
-function serviceStartRefusal(
+function startRefusal(
   coordRoot: string,
   pid: number | undefined,
-  liveness: GovernorServiceStatus["liveness"],
+  liveness: ServiceLiveness,
 ): Error {
-  const reason =
-    liveness === "unknown"
-      ? `governor service process generation is unknown${pid ? ` for pid ${pid}` : ""}`
-      : `governor service process is still running under pid ${pid}`;
-  return new Error(
-    `${reason}; run \`${resolveBinName(coordRoot)} governor service stop\` to write a durable stop request before starting or reconfiguring it`,
+  return serviceStartRefusal(
+    "governor service",
+    `${resolveBinName(coordRoot)} governor service stop`,
+    pid,
+    liveness,
   );
 }
 

package/src/core/hooks/cli.ts

@@ -844,6 +844,9 @@ async function main(): Promise<number> {
   if (eventName === "runtime-context-retry") {
     return runRuntimeContextRetryWorker(coordRoot, adapter, extra);
   }
+  if (eventName === SESSION_MAINTENANCE_EVENT) {
+    return runSessionMaintenanceWorker(coordRoot, adapter);
+  }
   const ledgerRoute = resolveLiveEventLedgerRouteV3(coordRoot);
 
   // Always log a breadcrumb, useful when an event_type maps to null or owner
@@ -1274,7 +1277,7 @@ function recordContextTelemetry(run: HookRun): void {
 }
 
 async function handleSessionStarted(run: HookRun): Promise<void> {
-  const { coordRoot, adapter, behavior, payload, owner, sessionId, data } = run;
+  const { coordRoot, adapter, payload, owner, sessionId, data } = run;
   // A configured backup runs out of process and is freshness-gated per host.
   // Startup never waits for restic or a remote provider; the child owns no
   // hook stdio, so the harness is not held open until it finishes. A failed
@@ -1285,52 +1288,10 @@ async function handleSessionStarted(run: HookRun): Promise<void> {
   } catch (err) {
     logError(coordRoot, err, { phase: "backup-schedule" });
   }
-  // Effect (journal-maintaining adapters): prune stale journal archives +
-  // sweep orphans. The recovery-cue is merged into the session-start
-  // additionalContext inside emitSessionStartSystemMessage.
-  if (behavior.journalMaintenance) journalJanitor(coordRoot);
-  imageJanitor(coordRoot);
-  // Session start is the only caller of the artifact janitor and the storage
-  // maintenance pass, so both load here instead of on every tool call.
-  const { autoCleanArtifacts } = await import("../artifacts/index.ts");
-  const { autoCleanEventV3Archives } = await import("../events/v3/archive-retention.ts");
-  const { createAutomaticMaintenanceComposition, runAutomaticMaintenancePass } = await import(
-    "../storage/maintenance-providers.ts"
-  );
-  // Effect: throttled hourly artifact sweep (see autoCleanArtifacts). It
-  // deletes expired workspaces, plus unheld workspaces over the per-bundle
-  // ceiling or repository budget once they have been idle past
-  // artifacts.idle_grace_hours. Each deletion is rechecked first and recorded
-  // in .harnery/artifact-deletions.jsonl. Best-effort like every janitor
-  // here: a failure logs and never blocks session start.
-  try {
-    autoCleanArtifacts(coordRoot);
-  } catch (err) {
-    logError(coordRoot, err, { phase: "artifact-auto-clean" });
-  }
-  // Effect: apply the same daily throttle to closed V3 epochs. The newest
-  // recovery epochs remain protected by the archive retention policy.
-  try {
-    autoCleanEventV3Archives(coordRoot);
-  } catch (err) {
-    logError(coordRoot, err, { phase: "event-v3-archive-auto-clean" });
-  }
-  // Plan one bounded, claim-first global slice from cached pressure only.
-  // Existing owner janitors above remain the only active executors until
-  // each provider receives a separate production activation.
-  try {
-    await runAutomaticMaintenancePass(
-      createAutomaticMaintenanceComposition(coordRoot, {
-        journal: () => {
-          if (behavior.journalMaintenance) journalJanitor(coordRoot);
-        },
-        images: () => imageJanitor(coordRoot),
-        artifacts: () => autoCleanArtifacts(coordRoot),
-      }),
-    );
-  } catch (err) {
-    logError(coordRoot, err, { phase: "storage-maintenance-auto" });
-  }
+  // Storage maintenance can walk large stores. It runs in a detached worker so
+  // session start emits its context without waiting for it; an adapter that
+  // stops a slow hook would otherwise drop that context entirely.
+  scheduleSessionMaintenance(coordRoot, adapter);
   let recovery: PreparedContextRecovery | null = null;
   if (payload?.source === "compact") {
     try {
@@ -1814,6 +1775,83 @@ async function handleCompletedResponse(run: CompletedResponseRun): Promise<numbe
   return 0;
 }
 
+const SESSION_MAINTENANCE_EVENT = "session-maintenance";
+
+function scheduleSessionMaintenance(coordRoot: string, adapter: Adapter): void {
+  const modulePath = process.argv[1];
+  if (!modulePath) return;
+  try {
+    const child = spawn(
+      process.execPath,
+      [modulePath, SESSION_MAINTENANCE_EVENT, "--adapter", adapter],
+      {
+        cwd: coordRoot,
+        detached: true,
+        stdio: "ignore",
+        env: childEnv(coordRoot),
+      },
+    );
+    child.unref();
+  } catch (err) {
+    logError(coordRoot, err, { phase: "session-maintenance-spawn" });
+  }
+}
+
+/**
+ * Session-start storage maintenance, run out of the hook's process. Every step
+ * is best-effort and throttled by its own stamp: a failure logs and never
+ * reaches the session.
+ */
+async function runSessionMaintenanceWorker(
+  coordRoot: string,
+  adapter: Adapter | null,
+): Promise<number> {
+  const journalMaintenance = adapter ? adapterBehavior(adapter).journalMaintenance : false;
+  // Effect (journal-maintaining adapters): prune stale journal archives +
+  // sweep orphans. The recovery cue is read separately at session start.
+  if (journalMaintenance) journalJanitor(coordRoot);
+  imageJanitor(coordRoot);
+  const { autoCleanArtifacts } = await import("../artifacts/index.ts");
+  const { autoCleanEventV3Archives } = await import("../events/v3/archive-retention.ts");
+  const { createAutomaticMaintenanceComposition, runAutomaticMaintenancePass } = await import(
+    "../storage/maintenance-providers.ts"
+  );
+  // Effect: throttled hourly artifact sweep (see autoCleanArtifacts). It
+  // deletes expired workspaces, plus unheld workspaces over the per-bundle
+  // ceiling or repository budget once they have been idle past
+  // artifacts.idle_grace_hours. Each deletion is rechecked first and recorded
+  // in .harnery/artifact-deletions.jsonl.
+  try {
+    autoCleanArtifacts(coordRoot);
+  } catch (err) {
+    logError(coordRoot, err, { phase: "artifact-auto-clean" });
+  }
+  // Effect: apply the same daily throttle to closed V3 epochs. The newest
+  // recovery epochs remain protected by the archive retention policy.
+  try {
+    autoCleanEventV3Archives(coordRoot);
+  } catch (err) {
+    logError(coordRoot, err, { phase: "event-v3-archive-auto-clean" });
+  }
+  // Plan one bounded, claim-first global slice from cached pressure only.
+  // Existing owner janitors above remain the only active executors until
+  // each provider receives a separate production activation.
+  try {
+    await runAutomaticMaintenancePass(
+      createAutomaticMaintenanceComposition(coordRoot, {
+        journal: () => {
+          if (journalMaintenance) journalJanitor(coordRoot);
+        },
+        images: () => imageJanitor(coordRoot),
+        artifacts: () => autoCleanArtifacts(coordRoot),
+      }),
+    );
+  } catch (err) {
+    logError(coordRoot, err, { phase: "storage-maintenance-auto" });
+  }
+  return 0;
+}
+
 function scheduleRuntimeContextRetry(
   coordRoot: string,
   adapter: Adapter,

package/src/core/hooks/resolve/owner.ts

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { coordEnv } from "../../../lib/env.ts";
 import { resolveOwnerBySessionEnv } from "../../agents/coord-client.ts";
 import { readLiveCoordinationRow } from "../../agents/state/live-coordination-view.ts";
-import { checkPidToken } from "../../agents/state/proc-start.ts";
+import { verifyProcessGeneration } from "../../agents/state/proc-start.ts";
 
 /**
  * Resolve the canonical `instance_id` for the current hook invocation.
@@ -98,7 +98,7 @@ export function resolveOwner(opts: {
           // A row whose start token disagrees with the process now holding this
           // pid is about a different, earlier process. Believing it hands this
           // session another agent's identity, so walk past it.
-          const recycled = checkPidToken(pid, startToken || undefined) === "mismatch";
+          const recycled = verifyProcessGeneration(pid, startToken) === "different";
           if (owner && owner.length > 0 && !recycled) {
             return {
               instance_id: owner,

package/src/core/resources/sampler.ts

@@ -5,7 +5,7 @@ import { basename, join } from "node:path";
 import { performance } from "node:perf_hooks";
 import { readLiveCoordinationRows } from "../agents/state/live-coordination-view.ts";
 import { parsePidmapRow } from "../agents/state/pidmap.ts";
-import { checkPidToken } from "../agents/state/proc-start.ts";
+import { verifyProcessGeneration } from "../agents/state/proc-start.ts";
 import {
   RESOURCE_SNAPSHOT_SCHEMA_VERSION,
   type ResourceProcessGroup,
@@ -386,7 +386,8 @@ function readOwnershipAnchors(
       if (!byPid.has(pid)) continue;
       try {
         const row = parsePidmapRow(readFileSync(join(directory, entry), "utf8"));
-        if (!row.instanceId || checkPidToken(pid, row.startToken) === "mismatch") continue;
+        if (!row.instanceId || verifyProcessGeneration(pid, row.startToken) === "different")
+          continue;
         anchors.set(pid, { kind: "agent", id: row.instanceId, source: "pid-map" });
       } catch {
         // An unreadable or racing row cannot prove ownership.

package/src/core/resources/service-status.ts

@@ -1,9 +1,8 @@
 import { existsSync } from "node:fs";
-import { hostname } from "node:os";
 import {
-  type ProcessGenerationVerdict,
-  verifyProcessGeneration,
-} from "../agents/state/proc-start.ts";
+  observeServiceProcess,
+  type ServiceProcessDependencies,
+} from "../agents/state/service-process.ts";
 import {
   RESOURCE_SERVICE_STATUS_SCHEMA_VERSION,
   type ResourceServiceStatus,
@@ -13,15 +12,10 @@ import { readResourceServiceRecord, resourcePaths } from "./storage.ts";
 
 const STALE_HEARTBEAT_MS = 15_000;
 
-export interface ResourceProcessDependencies {
-  readToken?: (pid: number) => string | null;
-  probePid?: (pid: number) => unknown;
-}
-
 export function readResourceServiceStatus(
   coordRoot: string,
   nowMs = Date.now(),
-  dependencies: ResourceProcessDependencies = {},
+  dependencies: ServiceProcessDependencies = {},
 ): ResourceServiceStatus {
   const paths = resourcePaths(coordRoot);
   const record = readResourceServiceRecord(coordRoot);
@@ -37,13 +31,11 @@ export function readResourceServiceStatus(
   }
   const heartbeatAt = Date.parse(record.heartbeat_at);
   const stale = !Number.isFinite(heartbeatAt) || nowMs - heartbeatAt > STALE_HEARTBEAT_MS;
-  const owner = resourceProcessLiveness(record, dependencies);
-  const liveness =
-    owner.generation === "same" && record.state === "stopped" ? "stopped" : owner.liveness;
+  const { generation, liveness } = observeServiceProcess(record, dependencies);
   return {
     running: liveness === "running" && !stale,
     stale,
-    generation: owner.generation,
+    generation,
     liveness,
     record,
     status_path: paths.service,
@@ -62,24 +54,3 @@ function validRecord(
     typeof value.heartbeat_at === "string"
   );
 }
-
-export function resourceProcessLiveness(
-  owner: { pid: number; host: string; start_token?: string },
-  dependencies: ResourceProcessDependencies = {},
-): { generation: ProcessGenerationVerdict; liveness: ResourceServiceStatus["liveness"] } {
-  if (owner.host !== hostname()) return { generation: "unknown", liveness: "unknown" };
-  try {
-    (dependencies.probePid ?? ((pid) => process.kill(pid, 0)))(owner.pid);
-  } catch (error) {
-    return {
-      generation: "unknown",
-      liveness: (error as NodeJS.ErrnoException).code === "ESRCH" ? "stopped" : "unknown",
-    };
-  }
-  const generation = verifyProcessGeneration(owner.pid, owner.start_token, dependencies.readToken);
-  return {
-    generation,
-    liveness:
-      generation === "same" ? "running" : generation === "different" ? "stopped" : "unknown",
-  };
-}