harnery 0.44.0 → 0.45.1

package/src/core/agents/state/heartbeat-writer.ts

@@ -24,11 +24,6 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
-import {
-  assertCurrentGenerationV3,
-  withGenerationCustodyV3,
-} from "../../events/v3/generation-custody.ts";
-import { liveInstanceIdV3 } from "../../events/v3/live-routing.ts";
 import { canonicalClaimPath } from "../claim-path.ts";
 import { type Heartbeat, heartbeatPath, readHeartbeat } from "./heartbeat-reader.ts";
 import type { TaskState } from "./session-state.ts";
@@ -68,15 +63,12 @@ function mutate(
   instanceId: string,
   fn: (hb: Heartbeat) => Heartbeat,
 ): Heartbeat | null {
-  return withGenerationCustodyV3(coordRoot, [liveInstanceIdV3(instanceId)], () => {
-    const hb = readHeartbeat(coordRoot, instanceId);
-    if (!hb) return null;
-    const next = fn(hb);
-    next.last_heartbeat = nowIsoSeconds();
-    assertCurrentGenerationV3(coordRoot, liveInstanceIdV3(instanceId), hb.v3_generation_id);
-    atomicWrite(heartbeatPath(coordRoot, instanceId), JSON.stringify(next, null, 2));
-    return next;
-  });
+  const hb = readHeartbeat(coordRoot, instanceId);
+  if (!hb) return null;
+  const next = fn(hb);
+  next.last_heartbeat = nowIsoSeconds();
+  atomicWrite(heartbeatPath(coordRoot, instanceId), JSON.stringify(next, null, 2));
+  return next;
 }
 
 export function setTask(coordRoot: string, instanceId: string, task: string): Heartbeat | null {
@@ -108,15 +100,12 @@ export function setIdentityCache(
   name: string,
   agentId: string,
 ): Heartbeat | null {
-  return withGenerationCustodyV3(coordRoot, [liveInstanceIdV3(instanceId)], () => {
-    const heartbeat = readHeartbeat(coordRoot, instanceId);
-    if (!heartbeat) return null;
-    heartbeat.name = name;
-    heartbeat.agent_id = agentId;
-    assertCurrentGenerationV3(coordRoot, liveInstanceIdV3(instanceId), heartbeat.v3_generation_id);
-    atomicWrite(heartbeatPath(coordRoot, instanceId), JSON.stringify(heartbeat, null, 2));
-    return heartbeat;
-  });
+  const heartbeat = readHeartbeat(coordRoot, instanceId);
+  if (!heartbeat) return null;
+  heartbeat.name = name;
+  heartbeat.agent_id = agentId;
+  atomicWrite(heartbeatPath(coordRoot, instanceId), JSON.stringify(heartbeat, null, 2));
+  return heartbeat;
 }
 
 /** Restore the pool-assigned display name on a generation that was
@@ -339,12 +328,6 @@ export function clearCoordinationCache(coordRoot: string, instanceId: string): b
 }
 
 export function healPidmap(coordRoot: string, instanceId: string, pid: number): void {
-  withGenerationCustodyV3(coordRoot, [liveInstanceIdV3(instanceId)], () =>
-    healPidmapUnderCustody(coordRoot, instanceId, pid),
-  );
-}
-
-function healPidmapUnderCustody(coordRoot: string, instanceId: string, pid: number): void {
   const dir = join(coordRoot, ".harnery", "pid-map");
   mkdirSync(dir, { recursive: true });
   const hb = readHeartbeat(coordRoot, instanceId);

package/src/core/agents/state/live-coordination-writer.ts

@@ -5,10 +5,6 @@ import {
   readCoordinationViewV3,
   requireAuthoritySafeCoordinationViewV3,
 } from "../../events/v3/coordination-view.ts";
-import {
-  assertCurrentGenerationV3,
-  withGenerationCustodyV3,
-} from "../../events/v3/generation-custody.ts";
 import { liveInstanceIdV3, resolveLiveEventLedgerRouteV3 } from "../../events/v3/live-routing.ts";
 import { type Heartbeat, readHeartbeat } from "./heartbeat-reader.ts";
 import {
@@ -68,26 +64,6 @@ function materializeLiveCoordinationHeartbeat(
   _adapter: Adapter,
   model: string | undefined,
   force: boolean,
-): Heartbeat | null {
-  return withGenerationCustodyV3(coordRoot, [liveInstanceIdV3(nativeInstanceId)], () =>
-    materializeHeartbeatUnderCustody(
-      coordRoot,
-      nativeInstanceId,
-      nativeSessionId,
-      _adapter,
-      model,
-      force,
-    ),
-  );
-}
-
-function materializeHeartbeatUnderCustody(
-  coordRoot: string,
-  nativeInstanceId: string,
-  nativeSessionId: string,
-  _adapter: Adapter,
-  model: string | undefined,
-  force: boolean,
 ): Heartbeat | null {
   const route = resolveLiveEventLedgerRouteV3(coordRoot);
   if (route.state === "blocked") throw new Error(`event_v3_coordination_view:${route.reason}`);
@@ -157,11 +133,6 @@ function materializeHeartbeatUnderCustody(
     v3_projection_event_id: generation.last_event_id,
     v3_task_state: generation.task_state === "set" ? "set" : "cleared",
   };
-  assertCurrentGenerationV3(
-    coordRoot,
-    liveInstanceIdV3(nativeInstanceId),
-    generation.generation_id,
-  );
   writeHeartbeatCache(coordRoot, nativeInstanceId, materialized);
   return materialized;
 }

package/src/core/agents/state/pidmap.ts

@@ -24,8 +24,6 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
-import { withGenerationCustodyV3 } from "../../events/v3/generation-custody.ts";
-import { liveInstanceIdV3 } from "../../events/v3/live-routing.ts";
 import { checkPidToken, processStartToken } from "./proc-start.ts";
 
 /**
@@ -128,17 +126,6 @@ export function writePidmapRow(
   pid: number,
   instanceId: string,
   platform: string,
-): void {
-  withGenerationCustodyV3(coordRoot, [liveInstanceIdV3(instanceId)], () =>
-    writePidmapRowUnderCustody(coordRoot, pid, instanceId, platform),
-  );
-}
-
-function writePidmapRowUnderCustody(
-  coordRoot: string,
-  pid: number,
-  instanceId: string,
-  platform: string,
 ): void {
   const dir = join(coordRoot, ".harnery", "pid-map");
   const path = join(dir, String(pid));

package/src/core/agents/state/proc-start.ts

@@ -34,9 +34,10 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { coordEnv } from "../../../lib/env.ts";
+import { signalProcessWithHandle, windowsProcessStartToken } from "./process-handle.ts";
 
 /** Which probe answers "when did this process start?" on this machine. */
-export type StartTokenProbe = "procfs" | "ps";
+export type StartTokenProbe = "procfs" | "ps" | "windows";
 
 /**
  * The `ps` probe is text formatted by `strftime("%c", localtime(...))`, so its
@@ -60,6 +61,7 @@ let cachedBootId: string | null | undefined;
 export function startTokenProbe(): StartTokenProbe {
   const override = coordEnv("PID_PROBE");
   if (override === "procfs" || override === "ps") return override;
+  if (process.platform === "win32") return "windows";
   if (cachedProbe === undefined) {
     cachedProbe = existsSync("/proc/self/stat") ? "procfs" : "ps";
   }
@@ -157,7 +159,12 @@ function defaultPsRun(pid: number): { status: number | null; stdout: string } {
  */
 export function processStartToken(pid: number): string | null {
   if (!Number.isFinite(pid) || pid <= 0) return null;
-  return startTokenProbe() === "procfs" ? procfsStartToken(pid) : psStartToken(pid);
+  const probe = startTokenProbe();
+  return probe === "windows"
+    ? windowsProcessStartToken(pid)
+    : probe === "procfs"
+      ? procfsStartToken(pid)
+      : psStartToken(pid);
 }
 
 export type ProcessGenerationVerdict = "same" | "different" | "unknown";
@@ -191,14 +198,12 @@ export function verifyProcessGeneration(
 
 export interface ProcessGenerationSignalDependencies {
   readToken?: ReadProcessStartToken;
-  kill?: (pid: number, signal: NodeJS.Signals | number) => unknown;
+  signalProcess?: typeof signalProcessWithHandle;
 }
 
 /**
- * Recheck the process generation immediately before sending the signal.
- *
- * The process can still exit and its PID can be reused between the token read
- * and the signal. Eliminating that race requires a generation-bound OS handle.
+ * Observations may refuse a signal, but only the retained native process handle
+ * can authorize it. No numeric-PID effect follows the preliminary token read.
  */
 export function signalIfSameGeneration(
   pid: number,
@@ -206,14 +211,12 @@ export function signalIfSameGeneration(
   signal: NodeJS.Signals | number,
   dependencies: ProcessGenerationSignalDependencies = {},
 ): { sent: boolean; verdict: ProcessGenerationVerdict } {
-  const kill = dependencies.kill ?? process.kill;
   const verdict = verifyProcessGeneration(pid, recordedToken, dependencies.readToken);
   if (verdict !== "same") return { sent: false, verdict };
   try {
-    kill(pid, signal);
-    return { sent: true, verdict };
+    return (dependencies.signalProcess ?? signalProcessWithHandle)(pid, recordedToken!, signal);
   } catch {
-    return { sent: false, verdict };
+    return { sent: false, verdict: "unknown" };
   }
 }
 

package/src/core/agents/state/process-handle.ts

@@ -0,0 +1,165 @@
+import { spawnSync } from "node:child_process";
+import { constants } from "node:os";
+import type { ProcessGenerationVerdict } from "./proc-start.ts";
+
+export interface ProcessHandleSignalResult {
+  sent: boolean;
+  verdict: ProcessGenerationVerdict;
+}
+
+interface NativeHelperResult extends ProcessHandleSignalResult {
+  token?: string;
+}
+
+export type NativeProcessHelperRunner = (
+  command: string,
+  args: string[],
+  options: {
+    input: string;
+    encoding: "utf8";
+    timeout: number;
+    maxBuffer: number;
+    windowsHide: boolean;
+  },
+) => { status: number | null; stdout: string | Buffer | null; error?: Error };
+
+// The helper owns the descriptor throughout observation and effect. The second
+// input line authorizes the effect; EOF releases the handle without signaling.
+export const LINUX_PROCESS_HANDLE_SCRIPT = `
+import json, os, pathlib, signal, sys
+result = {"sent": False, "verdict": "unknown"}
+fd = None
+try:
+    request = json.loads(sys.stdin.readline())
+    if not hasattr(os, "pidfd_open") or not hasattr(signal, "pidfd_send_signal"):
+        raise RuntimeError("pidfd support unavailable")
+    fd = os.pidfd_open(request["pid"])
+    stat = pathlib.Path("/proc/%d/stat" % request["pid"]).read_text()
+    ticks = stat[stat.rfind(") ") + 2:].split()[19]
+    boot = pathlib.Path("/proc/sys/kernel/random/boot_id").read_text().strip().replace("-", "")[:8]
+    token = "l%s.%s" % (boot, ticks)
+    result["token"] = token
+    recorded = request.get("token")
+    result["verdict"] = "same" if token == recorded else "different"
+    if request["mode"] == "signal" and result["verdict"] == "same":
+        print(json.dumps({"phase": "verified"}), flush=True)
+        if sys.stdin.readline().strip() == "signal":
+            signal.pidfd_send_signal(fd, request["signal"])
+            result["sent"] = True
+except Exception:
+    pass
+finally:
+    if fd is not None:
+        os.close(fd)
+print(json.dumps(result), flush=True)
+`;
+
+export const WINDOWS_PROCESS_HANDLE_SCRIPT = `
+$ErrorActionPreference = 'Stop'
+$result = @{ sent = $false; verdict = 'unknown' }
+$handle = [IntPtr]::Zero
+try {
+  Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public static class HarneryProcessHandle {
+  [DllImport("kernel32.dll", SetLastError=true)] public static extern IntPtr OpenProcess(uint access, bool inherit, uint processId);
+  [DllImport("kernel32.dll", SetLastError=true)] public static extern bool GetProcessTimes(IntPtr handle, out long creation, out long exit, out long kernel, out long user);
+  [DllImport("kernel32.dll", SetLastError=true)] public static extern bool TerminateProcess(IntPtr handle, uint exitCode);
+  [DllImport("kernel32.dll")] public static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+  [DllImport("kernel32.dll")] public static extern bool CloseHandle(IntPtr handle);
+}
+'@
+  $request = [Console]::In.ReadLine() | ConvertFrom-Json
+  $access = [uint32]0x101000
+  if ($request.mode -eq 'signal') { $access = $access -bor 1 }
+  $handle = [HarneryProcessHandle]::OpenProcess($access, $false, [uint32]$request.pid)
+  if ($handle -eq [IntPtr]::Zero) { throw 'process handle unavailable' }
+  [long]$creation = 0; [long]$exitTime = 0; [long]$kernel = 0; [long]$userTime = 0
+  if (-not [HarneryProcessHandle]::GetProcessTimes($handle, [ref]$creation, [ref]$exitTime, [ref]$kernel, [ref]$userTime)) { throw 'process time unavailable' }
+  $token = 'w' + $creation.ToString([Globalization.CultureInfo]::InvariantCulture)
+  $result.token = $token
+  $result.verdict = if ($token -ceq $request.token) { 'same' } else { 'different' }
+  if ($request.mode -eq 'signal' -and $result.verdict -eq 'same') {
+    [Console]::Out.WriteLine('{"phase":"verified"}')
+    [Console]::Out.Flush()
+    if ([Console]::In.ReadLine() -eq 'signal' -and [HarneryProcessHandle]::WaitForSingleObject($handle, 0) -eq 258) {
+      $result.sent = [HarneryProcessHandle]::TerminateProcess($handle, 1)
+    }
+  }
+} catch {} finally {
+  if ($handle -ne [IntPtr]::Zero) { [void][HarneryProcessHandle]::CloseHandle($handle) }
+}
+$result | ConvertTo-Json -Compress
+`;
+
+function runHelper(
+  request: { mode: "probe" | "signal"; pid: number; token?: string; signal?: number },
+  platform: NodeJS.Platform,
+  run: NativeProcessHelperRunner,
+): NativeHelperResult {
+  const unknown = { sent: false, verdict: "unknown" } as const;
+  if (!Number.isInteger(request.pid) || request.pid <= 0) return unknown;
+  if (platform !== "linux" && platform !== "win32") return unknown;
+  try {
+    const command = platform === "linux" ? "python3" : "powershell.exe";
+    const args =
+      platform === "linux"
+        ? ["-I", "-c", LINUX_PROCESS_HANDLE_SCRIPT]
+        : ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", WINDOWS_PROCESS_HANDLE_SCRIPT];
+    const output = run(command, args, {
+      input: `${JSON.stringify(request)}\nsignal\n`,
+      encoding: "utf8",
+      timeout: 10_000,
+      maxBuffer: 64 * 1024,
+      windowsHide: true,
+    });
+    if (output.error || output.status !== 0) return unknown;
+    const lines = String(output.stdout ?? "")
+      .trim()
+      .split(/\r?\n/);
+    const parsed = JSON.parse(lines.at(-1) ?? "") as NativeHelperResult;
+    if (
+      typeof parsed.sent !== "boolean" ||
+      !["same", "different", "unknown"].includes(parsed.verdict) ||
+      (parsed.sent && parsed.verdict !== "same")
+    )
+      return unknown;
+    return parsed;
+  } catch {
+    return unknown;
+  }
+}
+
+/** Windows creation FILETIME, read from an OpenProcess handle. */
+export function windowsProcessStartToken(
+  pid: number,
+  run: NativeProcessHelperRunner = spawnSync,
+): string | null {
+  const result = runHelper({ mode: "probe", pid }, "win32", run);
+  return typeof result.token === "string" && /^w\d+$/.test(result.token) ? result.token : null;
+}
+
+/** No numeric-PID signaling fallback is permitted when an exact handle fails. */
+export function signalProcessWithHandle(
+  pid: number,
+  recordedToken: string,
+  signal: NodeJS.Signals | number,
+  options: { platform?: NodeJS.Platform; run?: NativeProcessHelperRunner } = {},
+): ProcessHandleSignalResult {
+  const platform = options.platform ?? process.platform;
+  const number = typeof signal === "number" ? signal : constants.signals[signal];
+  if (
+    !Number.isInteger(number) ||
+    number <= 0 ||
+    (platform === "linux" && !/^l[0-9a-f]{8}\.\d+$/.test(recordedToken)) ||
+    (platform === "win32" && (!/^w\d+$/.test(recordedToken) || ![9, 15].includes(number)))
+  )
+    return { sent: false, verdict: "unknown" };
+  const result = runHelper(
+    { mode: "signal", pid, token: recordedToken, signal: number },
+    platform,
+    options.run ?? spawnSync,
+  );
+  return { sent: result.sent, verdict: result.verdict };
+}