@volter/supercode-health 0.1.10 → 0.1.12

package/lib/drift.mjs

@@ -0,0 +1,72 @@
+// Release drift (t_8e109edc): a supercode process still running a release an upgrade replaced. An install replaces a
+// release's files in place, and a long-lived process (the machine daemon, harness serve, message watch, an MCP server, a
+// hosted session's pane, a board owner) keeps the code it started with: it then speaks to processes of the new release
+// as the old, which was behind much of 2026-10-06's trouble ("half the problems are from version mismatches").
+// A process runs a file of a supercode install (the native, `…/@volter/supercode-cli-<os>-<cpu>/bin/supercode`, or
+// node running a file of an `@volter/supercode*` package); when that file was written after the process started (its
+// ctime: an extractor may set a file's mtime, never its ctime), the release on disk is not the one it runs.
+import { realpathSync, statSync } from 'node:fs';
+import { run } from './run.mjs';
+
+/** A supercode install's file: the native, or a script of an @volter/supercode* package. */
+const INSTALL_FILE = /^\/\S*\/node_modules\/@volter\/supercode(?:-[a-z0-9-]+)?\/\S+$/u;
+
+/** The file a command runs: its program, or the script node runs (the first word after node's own flags); only that
+ *  one, never a path in its arguments (a Claude session's `--settings` names supercode's hooks). */
+function ran(command) {
+  const words = command.split(/\s+/u);
+  const node = /(^|\/)node$/u.test(words[0] ?? '');
+  let program = node ? words.slice(1).find((word) => !word.startsWith('-')) : words[0];
+  if (!program?.startsWith('/')) return null;
+  // by its real path: a link (the machine's stable program, a bin link) names an install's file under another name
+  try { program = realpathSync(program); } catch { /* gone: matched as named */ }
+  return INSTALL_FILE.test(program) ? { file: program, native: !node } : null;
+}
+
+/** The inode each native process runs (its `txt` mapping, lsof's first), by pid; empty where lsof cannot say. An
+ *  install that replaced the file gave its path a new inode, while the process still runs the old one. */
+async function runningInodes(pids) {
+  const inodes = new Map();
+  if (!pids.length) return inodes;
+  const answer = await run('lsof', ['-n', '-P', '-a', '-d', 'txt', '-F', 'pi', '-p', pids.join(',')], { timeoutMs: 10_000 }).catch(() => null);
+  let pid = null;
+  for (const line of String(answer?.stdout ?? '').split('\n')) {
+    if (line.startsWith('p')) pid = Number(line.slice(1));
+    else if (line.startsWith('i') && pid && !inodes.has(pid)) inodes.set(pid, Number(line.slice(1)));
+  }
+  return inodes;
+}
+
+/** `ps`'s start time (`lstart`, as `Tue Oct  6 12:09:42 2026`) in ms, or NaN. */
+const startedMs = (lstart) => Date.parse(String(lstart).trim().replace(/\s+/g, ' ').replace(/^\w{3} /, ''));
+
+/**
+ * The running supercode processes (on macOS and Linux) whose install file was written after they started:
+ * `[{ pid, command, file, startedAt, installedAt }]`, newest install first. `rows` (ps lines, for a reading without
+ * ps) is `pid lstart(5 words) command`.
+ */
+export async function staleSupercode({ rows = null } = {}) {
+  const lines = rows ?? String((await run('ps', ['-A', '-ww', '-o', 'pid=,lstart=,command='], { timeoutMs: 10_000 })).stdout ?? '').split('\n');
+  const found = [];
+  for (const line of lines) {
+    const match = /^\s*(\d+)\s+(\w{3}\s+\w{3}\s+\d+\s+[\d:]+\s+\d{4})\s+(.*)$/u.exec(line);
+    if (!match) continue;
+    const [, pid, lstart, command] = match;
+    const program = ran(command);
+    if (program) found.push({ pid: Number(pid), lstart, command, ...program });
+  }
+  // a native is read by the inode it runs, where lsof says it: the strongest reading (a ctime also moves on a chmod)
+  const inodes = rows ? new Map() : await runningInodes(found.filter((row) => row.native).map((row) => row.pid));
+  const stale = [];
+  for (const { pid, lstart, command, file } of found) {
+    const started = startedMs(lstart);
+    let stat;
+    try { stat = statSync(file); } catch { continue; } // a file gone is a removed install, said elsewhere
+    const installed = stat.ctimeMs;
+    if (inodes.has(pid)) {
+      if (inodes.get(pid) === stat.ino) continue;
+    } else if (Number.isNaN(started) || installed <= started + 1000) continue; // ps says a start to the second
+    stale.push({ pid: Number(pid), command: command.slice(0, 200), file, startedAt: new Date(started).toISOString(), installedAt: new Date(installed).toISOString() });
+  }
+  return stale.sort((a, b) => b.installedAt.localeCompare(a.installedAt));
+}

package/lib/features.mjs

@@ -13,6 +13,7 @@ export const FEATURES = [
   { id: 'disk-io', barrier: 'none', platforms: ['darwin', 'linux'], reads: 'device throughput; top writers per process' },
   { id: 'tcp', barrier: 'none', platforms: ['darwin', 'linux', 'win32'], reads: 'sockets per state, ephemeral ports in use, TIME_WAIT by listener and its pid' },
   { id: 'files', barrier: 'none', platforms: ['darwin', 'linux'], reads: 'open files against the system limit' },
+  { id: 'drift', barrier: 'none', platforms: ['darwin', 'linux'], reads: 'running supercode processes whose install was replaced after they started (one ps)' },
   { id: 'services', barrier: 'none', platforms: ['darwin', 'linux'], reads: "configured launchd/systemd user jobs: running, last exit, log silence" },
   { id: 'supercode', barrier: 'integration:machine-daemon', platforms: ['darwin', 'linux', 'win32'], reads: "this machine's supercode connector: answering, server link, stuck launches" },
   { id: 'browser-tabs', barrier: 'integration:browser-controller', platforms: ['darwin', 'linux', 'win32'], reads: "every tab with its owner (controller holder, or the process and session serving its local port) and the renderer serving it" },

package/lib/sample.mjs

@@ -7,6 +7,7 @@ import { daemonCall } from './mail.mjs';
 import { rendererOrigins, originOf, localPort } from './chrome.mjs';
 import { expiredFailures, failureSummary, keyFor, Ledger, runningRelease, sayOnChanges, slowFailures } from './failures.mjs';
 import { healthDir } from './paths.mjs';
+import { staleSupercode } from './drift.mjs';
 import { join } from 'node:path';
 
 const MB = 1024 * 1024;
@@ -384,6 +385,14 @@ export class Sampler {
       });
     });
 
+    if (on.has('drift')) await attempt('drift', async () => {
+      const stale = await staleSupercode();
+      slow.families.add('release');
+      // every stale process this pass found; one no longer found is cleared
+      slow.observations.push({ enumerated: 'release', family: 'release', by: 'suffix', entities: new Set(stale.map((r) => String(r.pid))) });
+      slow.readings.drift = stale;
+      for (const r of stale) slow.observations.push({ key: `release.drift:${r.pid}`, family: 'release', def: alarm('release.drift'), value: 1, met: { warn: true, crit: false, clears: false }, summary: `supercode process ${r.pid} runs a release replaced at ${r.installedAt} (started ${r.startedAt}): ${r.command.slice(0, 120)}`, detail: r });
+    });
     if (on.has('services')) await attempt('services', async () => {
       const list = cfg.services ?? [];
       const jobs = await this.reader.services(list.map((s) => s.label));

package/lib/thresholds.mjs

@@ -32,6 +32,8 @@ export const DEFAULTS = {
     'tcp.timeWaitTarget': { warn: 25, crit: 50, forSec: 30 },
     'files.open': { warn: 70, crit: 90, forSec: 900 },
     'service.down': { forSec: 60 },
+    // a process on a replaced release keeps speaking to the new one as the old: said once it has run so 5 min
+    'release.drift': { forSec: 300 },
     'supercode.connector': { forSec: 60 },
     'supercode.launch': { stuckMin: 5, failedWithinMin: 30 },
     // one failure that keeps happening (the same command or door with the same outcome, the same mail expiry) in the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-health",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "type": "module",
   "description": "Optional machine pack: a cheap, deterministic probe of a machine's vitals that mails the machine's maintainer when a threshold is crossed. Each feature sits behind its own permission barrier.",
   "license": "MIT",
@@ -8,7 +8,8 @@
     ".": "./index.mjs",
     "./bin": "./bin/health.mjs",
     "./format": "./lib/format.mjs",
-    "./paths": "./lib/paths.mjs"
+    "./paths": "./lib/paths.mjs",
+    "./drift": "./lib/drift.mjs"
   },
   "bin": {
     "supercode-health": "./bin/health.mjs"