@crouton-kit/crouter 0.3.64 → 0.3.65

package/dist/core/__tests__/full/broker-crash-teardown.test.js

@@ -44,7 +44,21 @@ import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { createHarness } from '../helpers/harness.js';
 import { subscribe } from '../../canvas/canvas.js';
-import { isPidAlive } from '../../canvas/pid.js';
+import { isPidAlive, capturePidIdentities } from '../../canvas/pid.js';
+// Diagnostic-only, gated behind CRTR_DEBUG_PID_LIVENESS (same env var as the
+// isRecordedPidAlive trace in pid.ts): logs whether the SIGKILLed pid reads
+// alive and what identity ps reports for it, right at the two moments that
+// matter for the intermittent Linux-only crash-revive wedge — directly after
+// confirming the kill and again just before the grace-elapsed tick — so a real
+// run shows whether the pid was reused during the grace window. No effect on
+// test behavior when the env var is unset.
+function debugLogPidState(label, pid) {
+    if (!process.env.CRTR_DEBUG_PID_LIVENESS)
+        return;
+    const identities = capturePidIdentities([pid]);
+    const identity = identities === null ? 'probe-null' : identities.has(pid) ? JSON.stringify(identities.get(pid)) : 'no-entry';
+    process.stderr.write(`[broker-crash-teardown] ${label}: pid=${pid} isPidAlive=${isPidAlive(pid)} capturePidIdentities=${identity}\n`);
+}
 // crtrd.ts module const (not exported): the fresh-pi-boot grace window the daemon
 // waits before grace-reviving / boot-failing a pi observed dead. Reference:
 // crtrd.ts `REVIVE_GRACE_MS = 20_000`.
@@ -81,9 +95,11 @@ test('CRASH → grace-revive RESUME (one-writer), then clean teardown on close',
     // Actions run: crouter-development/prove-ci-fixes-in-actions). The waitFor's
     // successful resolution already IS the proof of deadness at this point.
     await h.waitFor(() => !isPidAlive(oldPid), { label: 'crashed broker pid is dead' });
+    debugLogPidState('after waitFor(!isPidAlive(oldPid))', oldPid);
     const NOW = 5_000_000;
     await h.tick(NOW); // pid dead, intent null → handleBrokerLiveness → handleLiveWindow marks pending
     assert.equal(h.bootCount(id), boots, 'inside the grace window → NOT yet revived');
+    debugLogPidState('before grace-elapsed tick', oldPid);
     await h.tick(NOW + REVIVE_GRACE_MS + 1); // grace elapsed → reviveNode(resume:true)
     // This is the file's SECOND real broker boot (crash-revive), on an
     // oversubscribed CI runner sharing the host with the other full-tier files'

package/dist/core/canvas/pid.js

@@ -74,17 +74,62 @@ export function isPidAlive(pid) {
  *  discipline: a MISMATCH is the ONLY thing that reads dead, never an absence of
  *  evidence. */
 export function isRecordedPidAlive(pid, expectedIdentity) {
-    if (!isPidAlive(pid))
+    const debug = Boolean(process.env.CRTR_DEBUG_PID_LIVENESS);
+    const alive = isPidAlive(pid);
+    if (!alive) {
+        if (debug)
+            logPidLivenessDecision(pid, alive, expectedIdentity, 'no-probe', 'isPidAlive=false → dead', false);
         return false; // gone/zombie → dead (unchanged path)
-    if (expectedIdentity == null)
+    }
+    if (expectedIdentity == null) {
+        if (debug)
+            logPidLivenessDecision(pid, alive, expectedIdentity, 'no-probe', 'no baseline → trust isPidAlive', true);
         return true; // no baseline → trust isPidAlive (legacy behavior)
+    }
     const current = capturePidIdentities([pid]);
-    if (current == null)
+    if (current == null) {
+        if (debug)
+            logPidLivenessDecision(pid, alive, expectedIdentity, 'probe-null', 'ps probe failed → fail-open alive', true);
         return true; // probe itself failed → fail-open
+    }
     const actual = current.get(pid);
-    if (actual === undefined)
+    if (actual === undefined) {
+        if (debug)
+            logPidLivenessDecision(pid, alive, expectedIdentity, 'no-entry', 'no identity row for pid (race) → fail-open alive', true);
         return true; // present but no identity row (race) → fail-open
-    return actual === expectedIdentity; // different identity → REUSED → dead
+    }
+    const result = actual === expectedIdentity; // different identity → REUSED → dead
+    if (debug)
+        logPidLivenessDecision(pid, alive, expectedIdentity, 'value', result ? 'identity matches expected → alive' : 'identity differs from expected → REUSED → dead', result, actual);
+    return result;
+}
+/** Diagnostic-only decision trace for `isRecordedPidAlive`, gated entirely
+ *  behind `CRTR_DEBUG_PID_LIVENESS` — callers must check the env var
+ *  themselves before calling this so the (tiny) formatting cost is paid ONLY
+ *  when the env var is set; this function does no env check of its own.
+ *  Written to trace the intermittent Linux-only CI crash-revive wedge
+ *  (`broker-crash-teardown.test.ts`'s 'CRASH → grace-revive RESUME'): the
+ *  goal is for a single stderr line per call to make BOTH a passing run ("pid
+ *  read dead → revive") and a wedged run ("read alive via <branch>") fully
+ *  self-explaining, without changing any return value. `capturePidIdentities`
+ *  outcome is reported as one of three DISTINCT cases — `probe-null` (the
+ *  `ps` probe itself failed), `no-entry` (probe succeeded but the map has no
+ *  row for this pid), or `value` (probe succeeded and found an identity,
+ *  printed verbatim) — plus `no-probe` for the two branches that return
+ *  before `capturePidIdentities` is ever called. Kept as permanent
+ *  observability for this primitive, not a throwaway debug print: pid-reuse
+ *  liveness is subtle enough that the next person chasing a wedge here should
+ *  find this already in place. */
+function logPidLivenessDecision(pid, isPidAliveResult, expectedIdentity, probeOutcome, branch, returned, actualIdentity) {
+    const parts = [
+        `pid=${String(pid)}`,
+        `isPidAlive=${isPidAliveResult}`,
+        `expectedIdentity=${expectedIdentity === undefined ? 'undefined' : expectedIdentity === null ? 'null' : JSON.stringify(expectedIdentity)}`,
+        `capturePidIdentities=${probeOutcome}${probeOutcome === 'value' ? `(${JSON.stringify(actualIdentity)})` : ''}`,
+        `branch=${JSON.stringify(branch)}`,
+        `returned=${returned}`,
+    ];
+    process.stderr.write(`[isRecordedPidAlive] ${parts.join(' ')}\n`);
 }
 /** SIGTERM a process GROUP by pid (the negative-pid convention) — best-effort,
  *  swallowing ESRCH (already gone). Shared by triggers.ts (cancel-time reap of

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crouton-kit/crouter",
-  "version": "0.3.64",
+  "version": "0.3.65",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",