@vincemakes/kiso-runtime 1.0.0 → 1.0.2

package/dist/lock-adapter.js

@@ -61,6 +61,7 @@
  * pauses plus SIGSTOP/SIGCONT, and locate the freeze points via
  * ready-marker files (ADR-0050 §test affordances).
  */
+import { execFileSync } from "node:child_process";
 import { closeSync, fsyncSync, linkSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
@@ -78,14 +79,58 @@ export class LockUnavailableError extends Error {
         this.name = "LockUnavailableError";
     }
 }
+/**
+ * ADR-0050 Amendment 1 (Finding R-I-1): the liveness probe is
+ * state-aware. A dead holder can linger in the process table after a
+ * kill — the exiting state (STAT E on macOS: the kill landing while a
+ * pty syscall is blocked, the dead session's terminal left open) or an
+ * un-reaped zombie (STAT Z). POSIX reports BOTH alive to kill(pid, 0)
+ * (they exist until reaped), so the takeover refused a holder that can
+ * never execute another session write. Both states are probed and
+ * judged DEAD. A probe failure (unreadable state) maintains the
+ * pre-amendment behavior — alive, the fail-safe refusal (prefer a false
+ * refusal over a double-write). Live-process semantics and the PID-reuse
+ * rules do not move: a live foreign writer is still refused.
+ *
+ * ADR-0050 Amendment 2 (Finding R-I-p-3): the state letters are matched
+ * ANYWHERE in the state string, not as the first character. The
+ * exit-path linger's ps output is "?E" — the first character is the
+ * no-controlling-terminal marker "?", with the E sitting AFTER it — so
+ * first-character matching judged the finding's own documented shape
+ * alive. The ps state alphabet (macOS + Linux) has no flag letters
+ * "E"/"Z": an occurrence anywhere is the process-state code, and the
+ * holder is dead.
+ */
 function isAlive(pid) {
     try {
         process.kill(pid, 0);
-        return true;
     }
     catch (err) {
         return err.code === "EPERM";
     }
+    const state = processState(pid);
+    // A null state (probe failure) keeps the pre-amendment behavior —
+    // judged alive, the fail-safe refusal.
+    return state === null || (!state.includes("E") && !state.includes("Z"));
+}
+/**
+ * The process state via `ps -o state= -p <pid>` (macOS/Linux) — the
+ * whole state string (a multi-char string like "Ss+" or "?E" is a
+ * combined flag set; the E/Z process-state codes may sit after the "?"
+ * no-tty marker or other flag letters, so the matching in isAlive scans
+ * the whole string). An empty or unreadable state — the process
+ * vanished between the kill and the probe, or ps itself failed —
+ * returns null; isAlive's fail-safe branch then judges the holder alive
+ * (the pre-amendment behavior).
+ */
+function processState(pid) {
+    try {
+        const state = execFileSync("ps", ["-o", "state=", "-p", String(pid)], { encoding: "utf8" }).trim();
+        return state.length > 0 ? state : null;
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Read a lock file's holder identity (round 4 formats, unchanged — the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-runtime",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "kiso runtime — durable multi-turn agent sessions: AgentDefinition, AgentRuntime, AgentSession, Run, append-only JSONL store.",
   "type": "module",
   "license": "MIT",