harnery 0.45.1 → 0.45.2

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",
-  };
-}

package/src/core/resources/service.ts

@@ -1,25 +1,17 @@
-import { randomUUID } from "node:crypto";
-import {
-  closeSync,
-  existsSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  rmSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
+import { existsSync, rmSync } from "node:fs";
 import { hostname } from "node:os";
 import { resolve } from "node:path";
+import { 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,
+  type ServiceStopFields,
+  serviceStartRefusal,
+} from "../agents/state/service-process.ts";
 import { resolveBinName } from "../config.ts";
 import { closeProcessLoggers, legacyLogFields, processLogger } from "../storage/logger.ts";
-import { stateDirMode, stateFileMode } from "../storage/modes.ts";
 import {
   RESOURCE_SERVICE_STATUS_SCHEMA_VERSION,
   type ResourceSamplerState,
@@ -27,25 +19,13 @@ import {
   type ResourceServiceStatusRecord,
 } from "./contract.ts";
 import { sampleResources } from "./sampler.ts";
-import {
-  type ResourceProcessDependencies,
-  readResourceServiceStatus,
-  resourceProcessLiveness,
-} from "./service-status.ts";
+import { readResourceServiceStatus } from "./service-status.ts";
 import { resourcePaths, writePrivateJsonAtomic } from "./storage.ts";
 
 export const RESOURCE_SERVICE_DEFAULT_INTERVAL_MS = 2_000;
 const RESOURCE_SERVICE_MIN_INTERVAL_MS = 500;
 const RESOURCE_SERVICE_MAX_INTERVAL_MS = 60_000;
 
-interface ResourceServiceLease {
-  pid: number;
-  start_token?: string;
-  host: string;
-  nonce: string;
-  created_at: string;
-}
-
 export interface RunResourceServiceInput {
   coordRoot: string;
   intervalMs?: number;
@@ -55,37 +35,15 @@ export interface RunResourceServiceInput {
   wait?: (milliseconds: number) => Promise<void>;
 }
 
-export interface ResourceServiceStopResult extends ResourceServiceStatus {
-  signal_sent: boolean;
-  signal_verdict: ProcessGenerationVerdict;
-}
+export type ResourceServiceStopResult = ResourceServiceStatus & ServiceStopFields;
 
 export function requestResourceServiceStop(
   coordRootRaw: string,
-  dependencies: ResourceProcessDependencies & ProcessGenerationSignalDependencies = {},
+  dependencies: ServiceProcessDependencies = {},
 ): ResourceServiceStopResult {
   const coordRoot = resolve(coordRootRaw);
-  const paths = resourcePaths(coordRoot);
-  const status = readResourceServiceStatus(coordRoot, Date.now(), dependencies);
-  mkdirSync(paths.root, { recursive: true, mode: stateDirMode() });
-  writePrivateJsonAtomic(paths.stop, {
-    requested_at: new Date().toISOString(),
-    requested_by_pid: process.pid,
-  });
-  const signal =
-    status.liveness === "running" && status.record?.host === hostname()
-      ? signalIfSameGeneration(
-          status.record.pid,
-          status.record.start_token,
-          "SIGTERM",
-          dependencies,
-        )
-      : { sent: false, verdict: status.generation };
-  return {
-    ...readResourceServiceStatus(coordRoot, Date.now(), dependencies),
-    signal_sent: signal.sent,
-    signal_verdict: signal.verdict,
-  };
+  const read = () => readResourceServiceStatus(coordRoot, Date.now(), dependencies);
+  return requestServiceStop(read(), read, resourcePaths(coordRoot).stop, dependencies);
 }
 
 export async function runResourceService(
@@ -93,15 +51,13 @@ export async function runResourceService(
 ): Promise<ResourceServiceStatusRecord> {
   const coordRoot = resolve(input.coordRoot);
   const current = readResourceServiceStatus(coordRoot);
-  if (current.liveness === "unknown") throw unknownResourceOwnerError();
-  if (current.liveness === "running")
-    throw new Error(`resource observer is already running under pid ${current.record?.pid}`);
+  if (current.liveness !== "stopped") throw startRefusal(current.record?.pid, current.liveness);
   const paths = resourcePaths(coordRoot);
   const intervalMs = normalizeInterval(input.intervalMs);
   const now = input.now ?? (() => new Date());
   const sample = input.sample ?? sampleResources;
   const wait = input.wait ?? delay;
-  const lease = acquireLease(coordRoot, now());
+  const lease = acquireServiceLease(paths.lease, startRefusal);
   rmSync(paths.stop, { force: true });
   const startedAt = now().toISOString();
   const daemonStartToken = processStartToken(process.pid);
@@ -178,84 +134,18 @@ export async function runResourceService(
     try {
       await closeProcessLoggers();
     } finally {
-      releaseLease(paths.lease, lease.nonce);
+      lease.release();
     }
   }
   return status;
 }
 
-function acquireLease(coordRoot: string, now: Date): ResourceServiceLease {
-  const paths = resourcePaths(coordRoot);
-  mkdirSync(paths.root, { recursive: true, mode: stateDirMode() });
-  for (let attempt = 0; attempt < 2; attempt++) {
-    const daemonStartToken = processStartToken(process.pid);
-    const lease: ResourceServiceLease = {
-      pid: process.pid,
-      ...(daemonStartToken ? { start_token: daemonStartToken } : {}),
-      host: hostname(),
-      nonce: randomUUID(),
-      created_at: now.toISOString(),
-    };
-    try {
-      const fd = openSync(paths.lease, "wx", stateFileMode());
-      try {
-        writeFileSync(fd, `${JSON.stringify(lease)}\n`, "utf8");
-      } finally {
-        closeSync(fd);
-      }
-      return lease;
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
-      const existing = readLease(paths.lease);
-      const liveness = existing ? leaseIsLive(existing) : "unknown";
-      if (liveness === "unknown") throw unknownResourceOwnerError();
-      if (existing && liveness === "running") {
-        throw new Error(`resource observer lease is held by pid ${existing.pid}`);
-      }
-      try {
-        unlinkSync(paths.lease);
-      } catch {
-        // A concurrent starter may have replaced or removed the stale lease.
-      }
-    }
-  }
-  throw new Error("resource observer could not acquire its singleton lease");
-}
-
-function releaseLease(path: string, nonce: string): void {
-  const current = readLease(path);
-  if (current?.nonce !== nonce) return;
-  try {
-    unlinkSync(path);
-  } catch {
-    // A missing lease is already released.
-  }
-}
-
-function readLease(path: string): ResourceServiceLease | undefined {
-  try {
-    const value = JSON.parse(readFileSync(path, "utf8")) as ResourceServiceLease;
-    return value &&
-      Number.isSafeInteger(value.pid) &&
-      value.pid > 0 &&
-      typeof value.host === "string" &&
-      value.host.length > 0 &&
-      typeof value.nonce === "string" &&
-      value.nonce.length > 0
-      ? value
-      : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function leaseIsLive(lease: ResourceServiceLease): ResourceServiceStatus["liveness"] {
-  return resourceProcessLiveness(lease).liveness;
-}
-
-function unknownResourceOwnerError(): Error {
-  return new Error(
-    `resource observer process identity is unknown; run ${resolveBinName()} supervisor stop to write the durable stop request before starting again`,
+function startRefusal(pid: number | undefined, liveness: ServiceLiveness): Error {
+  return serviceStartRefusal(
+    "resource observer",
+    `${resolveBinName()} supervisor stop`,
+    pid,
+    liveness,
   );
 }
 

package/src/core/resources/status.ts

@@ -6,13 +6,14 @@ import {
   type PressureAssessment,
   type PressureHysteresisState,
 } from "../diagnostics/contract.ts";
+import { installedHarneryBuild } from "../events/v3/runtime-build.ts";
 import {
   SUPERVISOR_PRESSURE_SCHEMA_VERSION,
   type SupervisorCapability,
   type SupervisorPressureRecord,
   type SupervisorStatus,
 } from "../supervisor/contract.ts";
-import { installedSupervisorBuild, readSupervisorStatus } from "../supervisor/status.ts";
+import { readSupervisorStatus } from "../supervisor/status.ts";
 import { supervisorPaths } from "../supervisor/storage.ts";
 import {
   RESOURCE_SNAPSHOT_SCHEMA_VERSION,
@@ -465,7 +466,7 @@ function unknownWriterState(): ResourceStatus["writer"] {
     generation: "unknown",
     liveness: "unknown",
     running_build: null,
-    installed_build: installedSupervisorBuild(),
+    installed_build: installedHarneryBuild(),
     restart_needed: true,
     build_status: "running build unknown; restart needed",
   };

package/src/core/semantic/service.ts

@@ -225,13 +225,19 @@ export async function ensureSemanticServiceRunning(
 
 export function requestSemanticServiceStop(coordRootRaw: string): SemanticServiceStatus {
   const coordRoot = resolve(coordRootRaw);
+  const status = readSemanticServiceStatus(coordRoot);
   mkdirSync(semanticPaths(coordRoot).root, { recursive: true, mode: stateDirMode() });
   writePrivateJsonAtomic(semanticPaths(coordRoot).stop, {
     requested_at: new Date().toISOString(),
     requested_by_pid: process.pid,
   });
-  // This record has no generation witness. The durable request is the stop
-  // authority; a numeric PID cannot authorize an additional signal.
+  if (status.running && status.record?.host === hostname()) {
+    try {
+      process.kill(status.record.pid, "SIGTERM");
+    } catch {
+      // The durable stop request remains for a racing or restarted daemon.
+    }
+  }
   return readSemanticServiceStatus(coordRoot);
 }
 

package/src/core/servers/index.ts

@@ -598,26 +598,6 @@ export interface StopResult {
 
 export interface ServerProcessDependencies extends ProcessGenerationSignalDependencies {
   probePid?: (pid: number) => boolean;
-  /** Numeric signal, used for the process group and in tests. */
-  kill?: (pid: number, signal: NodeJS.Signals) => void;
-}
-
-/** Recheck the generation, then signal. A supplied `kill` replaces the handle path. */
-function signalVerified(
-  pid: number,
-  token: string | undefined,
-  name: NodeJS.Signals,
-  dependencies: ServerProcessDependencies,
-): { sent: boolean; verdict: ProcessGenerationVerdict } {
-  if (!dependencies.kill) return signalIfSameGeneration(pid, token, name, dependencies);
-  const verdict = verifyProcessGeneration(pid, token, dependencies.readToken);
-  if (verdict !== "same") return { sent: false, verdict };
-  try {
-    dependencies.kill(pid, name);
-    return { sent: true, verdict };
-  } catch {
-    return { sent: false, verdict };
-  }
 }
 
 /**
@@ -680,7 +660,7 @@ export async function stopServer(
       const result =
         target.pid === record.pid
           ? signalServerLeader(target.pid, target.token, name, dependencies)
-          : signalVerified(target.pid, target.token, name, dependencies);
+          : signalIfSameGeneration(target.pid, target.token, name, dependencies);
       if (result.verdict !== "same") return refuse(target.pid, result.verdict);
     }
     const observed = await waitForExit(targets, name === "SIGTERM" ? graceMs : 2_000, dependencies);
@@ -706,13 +686,13 @@ function signalServerLeader(
   // The leader's generation authorizes its group. A failed group signal must
   // not reuse that observation for the direct-PID fallback.
   const kill = dependencies.kill ?? process.kill;
-  const group = signalVerified(pid, token, name, {
+  const group = signalIfSameGeneration(pid, token, name, {
     readToken: dependencies.readToken,
     kill: (leader, signal) => kill(-leader, signal),
   });
   return group.sent || group.verdict !== "same"
     ? group
-    : signalVerified(pid, token, name, dependencies);
+    : signalIfSameGeneration(pid, token, name, dependencies);
 }
 
 async function waitForExit(