@volter/supercode-health 0.1.1 → 0.1.3

package/README.md

@@ -32,10 +32,15 @@ a minute, 24 h) and `probe.log` to `$SUPERCODE_HOME/health`, which defaults to
 
 ## Alarms
 
-`supercode health subscribe sc:<machine>:<harness>:<id>` subscribes a session or board.
-Each raise, escalation and clear mails the subscribers. A still-raised alarm mails again
-every `repeatMin` (60). Mail comes from `sc:<machine>:operator:machine-health` through
-`supercode message remote-deliver`. Undelivered mail is kept and retried for a day.
+`supercode health subscribe sc:<machine>:agent:<name>` subscribes an agent (a maintainer:
+the mailbox delivers to its main session as it is then, so a relaunched main still gets
+it); a session or board address may be subscribed too, and its mail stops reaching it
+when the session ends. Each raise, escalation and clear mails the subscribers. A
+still-raised alarm mails again every `repeatMin` (60). Mail comes from
+`sc:<machine>:operator:machine-health`, filed in each subscriber's mailbox
+(`supercode message file`) after the cycle's reading is written; the mailbox delivers
+it, within its bounds, and `supercode message waiting` / `supercode message expired` list
+what it has not delivered.
 
 ## Config
 

package/bin/health.mjs

@@ -7,7 +7,7 @@
 //   status [--json] [--all]     this machine's latest reading (latest.json)
 //   features [--json]           every feature, on or off, its permission barrier and why
 //   alarms [--json]             the alarms raised now
-//   subscribe <address> | unsubscribe <address>   alarm mail for a session or board address
+//   subscribe <address> | unsubscribe <address>   alarm mail for an agent (sc:<machine>:agent:<name>), session or board
 //   config                      where the config lives and what it currently resolves to
 import { readFileSync } from 'node:fs';
 import { parseArgs } from 'node:util';

package/lib/darwin.mjs

@@ -156,14 +156,20 @@ export async function diskIO() {
 }
 
 /** The user's launchd jobs: label → { pid, lastExit }. */
-export async function services() {
-  const r = await run('/bin/launchctl', ['list'], { timeoutMs: 5000 });
-  if (!r.ok) throw new Error(r.error);
+/** The user's launchd jobs: label → { pid, lastExit, runs }. `runs` counts every spawn since the job was loaded,
+ *  so a KeepAlive job that crashes and respawns between two readings shows as runs rising with a failed last exit,
+ *  where `launchctl list` alone shows a pid and looks running (12 ms per `launchctl print`). */
+export async function services(labels = []) {
   const map = new Map();
-  for (const line of r.stdout.split('\n').slice(1)) {
-    const [pid, status, label] = line.split('\t');
-    if (label) map.set(label, { pid: pid === '-' ? null : Number(pid), lastExit: Number(status) });
-  }
+  const uid = process.getuid?.();
+  await Promise.all(labels.map(async (label) => {
+    const r = await run('/bin/launchctl', ['print', `gui/${uid}/${label}`], { timeoutMs: 5000 });
+    if (!r.ok) return; // not loaded
+    const field = (name) => new RegExp(`^\\t${name} = (.+)$`, 'm').exec(r.stdout)?.[1];
+    const pid = Number(field('pid')) || null;
+    const lastExit = field('last exit code');
+    map.set(label, { pid, lastExit: lastExit == null || /never exited/.test(lastExit) ? 0 : Number.parseInt(lastExit, 10), runs: Number(field('runs')) || 0 });
+  }));
   return map;
 }
 

package/lib/format.mjs

@@ -1,6 +1,6 @@
 // The snapshot as a person reads it: alarms first, then each reading, then which features are off and why.
 const n = (v, unit = '') => (v == null ? '-' : `${v}${unit}`);
-const who = (p) => (p?.session?.address ? ` ← ${p.session.address}` : p?.session?.harness ? ` ← ${p.session.harness} pid ${p.session.agentPid}` : '');
+const who = (p) => (p?.session?.address ? ` ← ${p.session.address}` : p?.session?.harness ? ` ← ${p.session.harness} pid ${p.session.agentPid}` : p?.session?.note ? ` ← (${p.session.note})` : p?.session?.inherited ? ` ← (no agent above; inherited ${p.session.inherited})` : '');
 
 export function formatStatus(s, { all = false } = {}) {
   if (!s) return 'machine health: no reading yet (is the probe running? `supercode health run`)';
@@ -10,7 +10,7 @@ export function formatStatus(s, { all = false } = {}) {
   if (age > 3 * (s.probe?.intervalSec ?? 15)) out.push(`  STALE: the probe has not written for ${age}s; its readings below are old`);
   out.push('', s.alarms.length ? `ALARMS (${s.alarms.length})` : 'ALARMS: none');
   for (const a of s.alarms) out.push(`  ${a.level.toUpperCase().padEnd(4)} ${a.summary}${a.detail?.pid ? ` [${a.detail.command?.slice(0, 80)}${who(a.detail)}]` : ''}  (since ${a.since})`);
-  if (s.maintainers) out.push(`  mailed to: ${s.maintainers.length ? s.maintainers.join(', ') : 'no maintainer subscribed (supercode health subscribe <address>)'}${s.mail?.pending ? ` · ${s.mail.pending} undelivered: ${s.mail.error}` : ''}`);
+  if (s.maintainers) out.push(`  mailed to: ${s.maintainers.length ? s.maintainers.join(', ') : 'no maintainer subscribed (supercode health subscribe <address>)'}${s.mail?.error ? ` · last mail not filed: ${s.mail.error}` : s.mail?.filed ? ` · last mail filed ${s.mail.at} (supercode message waiting lists any not yet delivered)` : ''}`);
   if (r.load) out.push('', `load      ${r.load.one} / ${r.load.five} / ${r.load.fifteen} on ${r.load.cores} cores (${r.load.perCore}× per core)`);
   if (r.memory) {
     const m = r.memory;
@@ -25,6 +25,10 @@ export function formatStatus(s, { all = false } = {}) {
   if (r.renderers) {
     out.push(`renderers ${r.renderers.count} using ${r.renderers.totalMB} MB${r.renderers.orphanedHeadless.length ? `; ${r.renderers.orphanedHeadless.length} orphaned headless browser(s): ${r.renderers.orphanedHeadless.map((p) => p.pid).join(', ')}` : ''}`);
     for (const p of r.renderers.top.slice(0, 3)) out.push(`  ${String(p.cpuPct ?? '-').padStart(4)}%  ${String(p.footprintMB).padStart(6)} MB  ${p.pid}${who(p)}${p.tab ? ` · ${p.tab.url.slice(0, 60)} · ${p.tab.owner}${who(p.tab.server)}` : ' · tab not matched'}`);
+    // Chrome names no renderer per tab (CDP's TargetInfo has no pid): a renderer that holds no storage bucket
+    // cannot be matched, so the tabs no renderer was matched to are listed with their owners instead.
+    const unmatched = (r.browserTabs?.tabs ?? []).filter((t) => !t.renderers.length);
+    if (r.renderers.top.slice(0, 3).some((p) => !p.tab) && unmatched.length) out.push(`  unmatched tabs (one may be served by an unmatched renderer above): ${unmatched.map((t) => `${t.url.slice(0, 50)} · ${t.owner}${who(t.server)}`).join(' | ')}`);
   }
   if (r.browserTabs) {
     out.push(`tabs      ${r.browserTabs.count} open${Object.keys(r.browserTabs.byHolder).length ? ` (${Object.entries(r.browserTabs.byHolder).map(([h, c]) => `${h} ${c}`).join(', ')})` : ''}`);
@@ -41,7 +45,7 @@ export function formatStatus(s, { all = false } = {}) {
     for (const g of t.timeWaitByTarget.slice(0, 3)) out.push(`          TIME_WAIT ${g.count} (${g.pct}%) against ${g.target}${g.listener ? ` · pid ${g.listener.pid} ${g.listener.command.slice(0, 60)}${who(g.listener)}` : ''}`);
   }
   if (r.files) out.push(`files     ${r.files.open} of ${r.files.max} open (${r.files.pct}%)`);
-  if (r.services) for (const sv of r.services) out.push(`service   ${sv.name ?? sv.label}: ${sv.running ? `running pid ${sv.pid}` : `NOT running (last exit ${sv.lastExit})`}${sv.logAgeMin != null ? ` · log written ${sv.logAgeMin} min ago` : ''}`);
+  if (r.services) for (const sv of r.services) out.push(`service   ${sv.name ?? sv.label}: ${sv.crashing ? `CRASH-LOOPING: ${sv.restarts} restarts since the last reading, last exit ${sv.lastExit}, ${sv.runs} runs` : sv.running ? `running pid ${sv.pid}` : `NOT running (last exit ${sv.lastExit})`}${sv.logAgeMin != null ? ` · log written ${sv.logAgeMin} min ago` : ''}`);
   if (r.supercode) {
     const c = r.supercode;
     out.push(`supercode connector ${c.connector ? `${c.connector.running ? 'running' : 'NOT running'}, server sees ${c.connector.connection ?? '-'}${c.connector.notSyncing ? `, ${c.connector.notSyncing} sessions not syncing (${c.connector.lastError})` : ''}` : (c.statusError ?? 'unknown')} · daemon ${c.daemon.answered ? `answered in ${c.daemon.ms} ms` : `NOT answering (${c.daemon.error})`} · launches ${c.launches.read ? `${c.launches.recent} in 24 h, ${c.launches.stuck.length} stuck, ${c.launches.failed.length} failed` : `unread (${c.launches.error})`}`);

package/lib/linux.mjs

@@ -135,11 +135,11 @@ export async function diskIO() {
 export async function services(names = []) {
   const map = new Map();
   if (!names.length) return map;
-  const r = await run('systemctl', ['--user', 'show', '-p', 'Id,MainPID,ExecMainStatus,ActiveState', ...names], { timeoutMs: 5000 });
+  const r = await run('systemctl', ['--user', 'show', '-p', 'Id,MainPID,ExecMainStatus,ActiveState,NRestarts', ...names], { timeoutMs: 5000 });
   if (!r.ok) throw new Error(r.error);
   for (const block of r.stdout.split('\n\n')) {
     const kv = Object.fromEntries(block.split('\n').filter(Boolean).map((l) => [l.slice(0, l.indexOf('=')), l.slice(l.indexOf('=') + 1)]));
-    if (kv.Id) map.set(kv.Id.replace(/\.service$/, ''), { pid: Number(kv.MainPID) || null, lastExit: Number(kv.ExecMainStatus) || 0, active: kv.ActiveState });
+    if (kv.Id) map.set(kv.Id.replace(/\.service$/, ''), { pid: Number(kv.MainPID) || null, lastExit: Number(kv.ExecMainStatus) || 0, active: kv.ActiveState, runs: (Number(kv.NRestarts) || 0) + 1 });
   }
   return map;
 }

package/lib/mail.mjs

@@ -1,50 +1,28 @@
-// Alarm mail through supercode's public mailbox door (`supercode message remote-deliver`), from
-// `sc:<machine>:operator:machine-health`. Undelivered mail stays in the outbox and is retried each cycle,
-// as the machine-events outbox does, until it is a day old.
-import { spawn } from 'node:child_process';
-import { readFileSync, writeFileSync, renameSync } from 'node:fs';
+// Alarm mail, filed in each subscriber's mailbox through supercode's filing door (`supercode message file`), from
+// `sc:<machine>:operator:machine-health`, and delivered by the mailbox (docs/adr/0008-agent-mailbox.md, decision 17;
+// D138 step 6). Filing is a local write: no door, no network, and nothing for the probe to retry. The mailbox resolves
+// an agent address (`sc:<machine>:agent:<name>`) to the agent's main session when it delivers, retries within its
+// bounds, and records what it could not deliver (`supercode message waiting`, `supercode message expired`).
+import { spawnSync } from 'node:child_process';
 
-export class Outbox {
-  constructor({ file, machine, env = process.env }) {
-    Object.assign(this, { file, machine, env });
-    try { this.items = JSON.parse(readFileSync(file, 'utf8')); } catch { this.items = []; }
-    this.error = null;
-  }
-  save() { const temp = `${this.file}.${process.pid}.tmp`; writeFileSync(temp, JSON.stringify(this.items) + '\n', { mode: 0o600 }); renameSync(temp, this.file); }
-  enqueue(to, id, subject, body) { this.items.push({ to, id, subject, body, at: Date.now(), tries: 0 }); this.save(); }
-  async flush() {
-    for (const item of [...this.items]) {
-      if (Date.now() - item.at > 24 * 3_600_000) { this.items = this.items.filter((x) => x !== item); this.error = `dropped undelivered ${item.id} to ${item.to} after a day`; continue; }
-      try { await this.deliver(item); this.items = this.items.filter((x) => x !== item); this.error = null; }
-      catch (error) { item.tries += 1; this.error = `mail to ${item.to}: ${error.message}`; }
-    }
-    this.save();
-    return { pending: this.items.length, error: this.error };
-  }
-  deliver(item) {
-    return new Promise((resolve, reject) => {
-      const child = spawn(this.env.SUPERCODE_BIN || 'supercode', ['message', 'remote-deliver'], { env: this.env, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true, shell: process.platform === 'win32' });
-      let detail = '';
-      const timer = setTimeout(() => { child.kill('SIGTERM'); reject(new Error('delivery timed out; kept for retry')); }, 30_000);
-      child.stdout.on('data', (c) => { detail = (detail + c).slice(-2000); });
-      child.stderr.on('data', (c) => { detail = (detail + c).slice(-2000); });
-      child.once('error', (error) => { clearTimeout(timer); reject(error); });
-      child.once('close', (code) => {
-        clearTimeout(timer);
-        let receipt; try { receipt = JSON.parse(detail.trim().split('\n').at(-1)); } catch { /* none */ }
-        if (code === 0 && receipt?.code === 0) resolve(receipt); else reject(new Error(receipt?.text || detail.trim().slice(-300) || `exit ${code}`));
-      });
-      child.stdin.on('error', () => {});
-      const board = item.to.split(':')[2] === 'board';
-      child.stdin.end(JSON.stringify({ op: 'send', from: `sc:${this.machine}:operator:machine-health`, from_name: 'Machine health', to: item.to, id: item.id, subject: item.subject, queue: board, body: item.body }));
-    });
+/** File one alarm mail for each address. Answers what was filed and the first failure, if any. */
+export function fileAlarm({ machine, env = process.env, to, key, subject, body }) {
+  const filed = [];
+  let error = null;
+  for (const address of to) {
+    const request = { from: `sc:${machine}:operator:machine-health`, from_name: 'Machine health', to: address, id: `${key}-${address}`, subject, body, wake: true };
+    const done = spawnSync(env.SUPERCODE_BIN || 'supercode', ['message', 'file'], { env, input: JSON.stringify(request), encoding: 'utf8', timeout: 10_000, windowsHide: true, shell: process.platform === 'win32' });
+    let answer = null; try { answer = JSON.parse(String(done.stdout ?? '').trim().split('\n').at(-1)); } catch { /* none */ }
+    if (answer?.code === 0) filed.push({ to: address, id: answer.message_id });
+    else error ??= `mail to ${address} was not filed: ${answer?.text || String(done.stderr ?? '').trim().slice(-300) || done.error?.message || `exit ${done.status}`}`;
   }
+  return { filed, error };
 }
 
 const LEVEL = { warn: 'WARN', crit: 'CRIT', none: 'clear' };
 function line(t) {
   const d = t.detail;
-  const who = d?.session?.address ? `; session ${d.session.address}` : d?.session?.harness ? `; under ${d.session.harness} pid ${d.session.agentPid}` : d?.pid ? '; no agent session above it' : '';
+  const who = d?.session?.address ? `; session ${d.session.address}` : d?.session?.harness ? `; under ${d.session.harness} pid ${d.session.agentPid}` : d?.session?.note ? `; ${d.session.note}` : d?.session?.inherited ? `; no agent above it (environment inherited from ${d.session.inherited}, unverified)` : d?.pid ? '; no agent session above it' : '';
   const proc = d?.pid ? ` [pid ${d.pid}: ${d.command}${who}]` : d?.listener ? ` [listener pid ${d.listener.pid}: ${d.listener.command}${d.listener.session?.address ? `; session ${d.listener.session.address}` : ''}]` : '';
   return `${LEVEL[t.to] ?? t.to}${t.from !== 'none' && t.to !== 'none' ? ` (was ${t.from})` : ''} ${t.key}: ${t.summary}${proc}`;
 }

package/lib/probe.mjs

@@ -1,5 +1,6 @@
 // The probe: one per OS user, holding an exclusive pidfile. Every cycle it samples, judges each alarm,
-// writes latest.json (what the doors read) and a minute history, and mails the maintainers on a change.
+// writes latest.json (what the doors read) and a minute history, and then files mail for the maintainers on a change
+// (the mailbox delivers it; nothing the mail does can hold latest.json back).
 // It decides nothing and changes nothing on the machine.
 import { mkdirSync, openSync, closeSync, readFileSync, writeFileSync, renameSync, appendFileSync, statSync, rmSync } from 'node:fs';
 import { hostname } from 'node:os';
@@ -7,7 +8,7 @@ import { healthDir, files as healthFiles, machineName } from './paths.mjs';
 import { DEFAULTS, merge, judge, raised } from './thresholds.mjs';
 import { resolveFeatures } from './features.mjs';
 import { Sampler } from './sample.mjs';
-import { Outbox, compose } from './mail.mjs';
+import { fileAlarm, compose } from './mail.mjs';
 import { run } from './run.mjs';
 
 export async function platformReader(platform = process.platform) {
@@ -76,7 +77,10 @@ export class Probe {
     this.config = loadConfig(this.f.config);
     this.configMtime = this.#mtime(this.f.config);
     this.sampler = new Sampler({ reader: this.reader, platform: this.platform, machine: this.machine, env: this.env, config: this.config });
-    this.outbox = new Outbox({ file: this.f.outbox, machine: this.machine, env: this.env });
+    // Alarm mail queued here by an earlier pack (outbox.json, retried per recipient until a day old) is not resent: a
+    // mail is a reading, superseded by the current one, and its recipients were often sessions that have ended. It is
+    // dropped, and every alarm raised now is mailed again at the first cycle, filed in the maintainers' mailboxes.
+    this.droppedOutbox = this.#dropOutbox();
     this.extras = {
       rusage: this.reader.rusageAvailable ? await this.reader.rusageAvailable() : false,
       supercode: (await run(this.env.SUPERCODE_BIN || 'supercode', ['--version'], { timeoutMs: 10_000, env: this.env })).ok,
@@ -84,7 +88,18 @@ export class Probe {
     const previous = readJson(this.f.latest, null);
     // Alarms raised before a restart stay raised (and are not re-mailed); their windows restart honestly.
     const alive = (pid) => { try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; } };
-    for (const a of (previous?.alarms ?? []).filter((x) => !x.detail?.pid || alive(x.detail.pid))) this.state[a.key] = { key: a.key, family: a.family, level: a.level, warnSince: null, critSince: null, raisedAt: a.since ? Date.parse(a.since) : Date.now(), lastMailAt: Date.now(), restoredUntil: Date.now() + 2 * 60_000, value: a.value, unit: a.unit, summary: a.summary, detail: a.detail };
+    for (const a of (previous?.alarms ?? []).filter((x) => !x.detail?.pid || alive(x.detail.pid))) this.state[a.key] = { key: a.key, family: a.family, level: a.level, warnSince: null, critSince: null, raisedAt: a.since ? Date.parse(a.since) : Date.now(), lastMailAt: this.droppedOutbox ? 0 : Date.now(), restoredUntil: Date.now() + 2 * 60_000, value: a.value, unit: a.unit, summary: a.summary, detail: a.detail };
+  }
+
+  /** Remove an earlier pack's outbox; answers how many mails it held, logged by recipient. */
+  #dropOutbox() {
+    const items = readJson(this.f.outbox, null);
+    if (!Array.isArray(items)) return 0;
+    const counts = {};
+    for (const item of items) counts[item?.to ?? '?'] = (counts[item?.to ?? '?'] ?? 0) + 1;
+    rmSync(this.f.outbox, { force: true });
+    this.log(`dropped ${items.length} undelivered alarm mail(s) an earlier pack queued (superseded by the current reading; the alarms raised now are mailed again): ${Object.entries(counts).map(([to, n]) => `${n} to ${to}`).join(', ') || 'none'}`);
+    return items.length;
   }
 
   #mtime(file) { try { return statSync(file).mtimeMs; } catch { return null; } }
@@ -109,10 +124,8 @@ export class Probe {
     const mail = compose({ machine: this.machine, transitions, reminders, raised: alarms });
     if (mail) {
       for (const a of alarms) this.state[a.key].lastMailAt = now;
-      for (const address of to) this.outbox.enqueue(address, `health-${this.machine}-${now}-${address.split(':').at(-1).slice(0, 12)}`, mail.subject, mail.body);
       this.log(`${mail.subject}${to.length ? '' : ' (no maintainer subscribed)'}\n${mail.body}`);
     }
-    const delivery = this.outbox.items.length ? await this.outbox.flush() : { pending: 0, error: this.outbox.error };
     const snapshot = {
       version: 1, machine: this.machine, platform: this.platform, at: new Date(now).toISOString(),
       probe: { pid: process.pid, intervalSec: this.config.intervalSec, slowIntervalSec: this.config.slowIntervalSec, sampleMs: this.sampleMs, user: this.env.USER ?? null, root: this.reader.isRoot?.() ?? false, config: this.config.source },
@@ -120,10 +133,18 @@ export class Probe {
       alarms,
       transitions: transitions.map((t) => ({ key: t.key, from: t.from, to: t.to, summary: t.summary })),
       maintainers: to,
-      mail: delivery,
+      mail: this.lastMail ?? null,
       readings,
     };
+    // The reading is written first; the mail is filed after it, and what the filing did is written beside it.
     writeAtomic(this.f.latest, snapshot);
+    if (mail && to.length) {
+      const result = fileAlarm({ machine: this.machine, env: this.env, to, key: `health-${this.machine}-${now}`, subject: mail.subject, body: mail.body });
+      this.lastMail = { at: new Date(now).toISOString(), filed: result.filed.length, to: result.filed.map((f) => f.to), error: result.error };
+      if (result.error) this.log(result.error);
+      snapshot.mail = this.lastMail;
+      writeAtomic(this.f.latest, snapshot);
+    }
     if (now - this.lastHistory >= 60_000) { this.#history(snapshot, now); this.lastHistory = now; }
     return snapshot;
   }

package/lib/sample.mjs

@@ -18,6 +18,11 @@ const HARNESS = { claude: 'claude-code', codex: 'codex', gemini: 'gemini', goose
 const RENDERER = /Helper \(Renderer\)|--type=renderer/;
 const BROWSER_MAIN = /(Google Chrome|Chromium|chrome-headless-shell|chrome)(\s|$)/i;
 const LOOPBACK = /^(127\.|::1$|localhost$)/;
+/** The session an agent names on its own command line: `--resume <id>`, `--session-id <id>`, `-r <id>`, `codex resume <id>`. */
+function argvSession(command) {
+  return /(?:--resume|--session-id|\s-r)[=\s]+([0-9a-f]{8}-[0-9a-f-]{27,})/.exec(command)?.[1]
+    ?? /\bresume\s+([0-9a-zA-Z][0-9a-zA-Z-]{7,})/.exec(command)?.[1] ?? null;
+}
 // The slow set's readings and alarm families, by the feature that produces them.
 const SLOW_FEATURE = { disk: 'disk', services: 'services', service: 'services', supercode: 'supercode', browserTabs: 'browser-tabs', tabs: 'browser-tabs', power: 'power' };
 // Every alarm family, by the feature that observes it.
@@ -32,6 +37,8 @@ export class Sampler {
     this.swapRing = [];          // [[at, swapouts]] for the 30-minute sum
     this.diskRing = new Map();   // mount → [[at, freeBytes]] for the fill rate
     this.sessionCache = new Map(); // pid:command → session
+    this.serviceRuns = new Map(); // service label → spawn count at the last reading
+    this.recentListeners = new Map(); // port → when it was last seen listening (its TIME_WAITs outlive it)
     this.topFoot = { at: 0, map: new Map() };
     this.slow = { at: 0, readings: {}, observations: [], families: new Set(), errors: {} };
     this.slowStarted = 0;
@@ -110,8 +117,11 @@ export class Sampler {
         r.footprintSource = ru ? 'footprint' : top != null ? 'footprint (top)' : 'rss';
         r.writeBps = same && dt && ru && prev.written != null && ru.diskWrittenBytes >= prev.written ? (ru.diskWrittenBytes - prev.written) / dt : null;
         nextPrev.set(r.pid, { cpuSec: r.cpuSec, command: r.command, written: ru?.diskWrittenBytes ?? null });
-        const hist = same ? (this.footHistory.get(r.pid) ?? []) : [];
-        hist.push([now, r.footprintBytes]);
+        // Growth compares like with like: a footprint read through a different instrument than the last reading
+        // (another user's process alternates between top's 5-minute map and RSS) starts a new history.
+        let hist = same ? (this.footHistory.get(r.pid) ?? []) : [];
+        if (hist.length && hist.at(-1)[2] !== r.footprintSource) hist = [];
+        hist.push([now, r.footprintBytes, r.footprintSource]);
         while (hist.length && now - hist[0][0] > 130_000) hist.shift();
         this.footHistory.set(r.pid, hist);
         const ago = hist.findLast?.(([at]) => now - at >= 55_000) ?? [...hist].reverse().find(([at]) => now - at >= 55_000);
@@ -225,6 +235,10 @@ export class Sampler {
         if (!['*', '0.0.0.0', '::', '[::]'].includes(s.local.addr)) local.add(s.local.addr);
       }
       const inRange = (port) => port >= range.first && port <= range.last;
+      for (const port of listening) this.recentListeners.set(port, now);
+      const hold = Math.max(4 * timeWaitSec * 1000, 120_000);
+      for (const [port, at] of this.recentListeners) if (now - at > hold) this.recentListeners.delete(port);
+      const wasListening = (port) => this.recentListeners.has(port);
       const wildcard = new Set();
       const used = new Map();
       const add = (addr, port) => { if (!used.has(addr)) used.set(addr, new Set()); used.get(addr).add(port); };
@@ -236,9 +250,11 @@ export class Sampler {
         if (local.has(s.foreign.addr) && inRange(s.foreign.port)) add(s.foreign.addr, s.foreign.port);
         if (s.state !== 'TIME_WAIT') continue;
         // Group each TIME_WAIT by the endpoint it churned against: a listener here (either side), else the remote.
+        // A listener that exited still owns its TIME_WAITs until they drain, so a port counts as a listener for
+        // a while after it was last seen listening; otherwise its alarm would clear while the sockets remain.
         let target;
-        if (listening.has(s.local.port)) target = `:${s.local.port}`;
-        else if ((local.has(s.foreign.addr) || LOOPBACK.test(s.foreign.addr)) && listening.has(s.foreign.port)) target = `:${s.foreign.port}`;
+        if (wasListening(s.local.port)) target = `:${s.local.port}`;
+        else if ((local.has(s.foreign.addr) || LOOPBACK.test(s.foreign.addr)) && wasListening(s.foreign.port)) target = `:${s.foreign.port}`;
         else target = `${s.foreign.addr}:${s.foreign.port}`;
         targets.set(target, (targets.get(target) ?? 0) + 1);
       }
@@ -255,12 +271,13 @@ export class Sampler {
       } else owners = this.owners ?? new Map();
       const timeWaitByTarget = top.map(([target, count]) => {
         const owner = target.startsWith(':') ? owners.get(Number(target.slice(1))) : null;
-        return { target, count, pct: round((count / size) * 100), ...(owner ? { listener: { pid: owner.pid, command: short(owner.command) } } : {}) };
+        const exited = target.startsWith(':') && !listening.has(Number(target.slice(1)));
+        return { target, count, pct: round((count / size) * 100), ...(exited ? { exited: true } : {}), ...(owner ? { listener: { pid: owner.pid, command: short(owner.command) } } : {}) };
       });
       readings.tcp = { states, timeWait: states.TIME_WAIT ?? 0, range: { ...range, size }, timeWaitSec, ephemeral, timeWaitByTarget };
       families.add('tcp');
       for (const e of ephemeral) observations.push({ key: `tcp.ephemeral:${e.addr}`, family: 'tcp', def: alarm('tcp.ephemeral'), value: e.pct, unit: '% of ports', summary: `${e.used} of ${size} ephemeral ports in use on ${e.addr}` });
-      for (const t of timeWaitByTarget) observations.push({ key: `tcp.timeWaitTarget:${t.target}`, family: 'tcp', def, value: t.pct, unit: '% of ports', summary: `${t.count} TIME_WAIT against ${t.target.startsWith(':') ? `listener ${t.target}` : t.target}${t.listener ? ` (pid ${t.listener.pid})` : ''}; range ${size}, TIME_WAIT lasts ${timeWaitSec} s`, detail: t });
+      for (const t of timeWaitByTarget) observations.push({ key: `tcp.timeWaitTarget:${t.target}`, family: 'tcp', def, value: t.pct, unit: '% of ports', summary: `${t.count} TIME_WAIT against ${t.target.startsWith(':') ? `listener ${t.target}${t.exited ? ' (listener has exited; its TIME_WAITs are draining)' : ''}` : t.target}${t.listener ? ` (pid ${t.listener.pid})` : ''}; range ${size}, TIME_WAIT lasts ${timeWaitSec} s`, detail: t });
     });
 
     // ---- the slow set ---------------------------------------------------------------------------------
@@ -327,12 +344,18 @@ export class Sampler {
         const log = s.log?.replace(/^~(?=\/)/, homedir());
         if (log) try { logAgeMin = Math.max(0, round((now - statSync(log).mtimeMs) / 60_000)); } catch { logAgeMin = null; }
         const running = Boolean(job?.pid);
-        const down = !job || (!running && (job.lastExit !== 0 || s.keepAlive !== false));
-        const why = !job ? 'not loaded' : !running ? `not running (last exit ${job.lastExit})` : null;
+        // Down (ADR 0006): not loaded, not running, or failing. A KeepAlive job that crashes and is respawned
+        // always has a pid when read, so failing is runs rising since the last reading with a non-zero last exit.
+        const before = this.serviceRuns.get(s.label);
+        const restarts = job && before != null && job.runs >= before ? job.runs - before : 0;
+        if (job) this.serviceRuns.set(s.label, job.runs);
+        const crashing = Boolean(job && restarts > 0 && job.lastExit !== 0);
+        const down = !job || (!running && (job.lastExit !== 0 || s.keepAlive !== false)) || crashing;
+        const why = !job ? 'not loaded' : !running ? `not running (last exit ${job.lastExit})` : crashing ? `crash-looping: ${restarts} restart${restarts === 1 ? '' : 's'} since the last reading, last exit ${job.lastExit} (${job.runs} runs since loaded)` : null;
         if (down) slow.observations.push({ key: `service.down:${s.label}`, family: 'service', def: alarm('service.down'), value: 1, met: { warn: true, crit: false, clears: false }, summary: `service ${s.name ?? s.label} is ${why}` });
         else slow.observations.push({ key: `service.down:${s.label}`, family: 'service', def: alarm('service.down'), value: 0, met: { warn: false, crit: false, clears: true }, summary: `service ${s.name ?? s.label} running` });
         if (s.log && s.maxSilentMin) slow.observations.push({ key: `service.deaf:${s.label}`, family: 'service', def: { warn: s.maxSilentMin, forSec: 0 }, value: logAgeMin ?? Infinity, unit: 'min silent', summary: logAgeMin == null ? `service ${s.name ?? s.label}: its log ${log} is missing` : `service ${s.name ?? s.label} has written nothing to its log for ${logAgeMin} min` });
-        return { label: s.label, name: s.name ?? null, running, pid: job?.pid ?? null, lastExit: job?.lastExit ?? null, ...(s.log ? { logAgeMin } : {}) };
+        return { label: s.label, name: s.name ?? null, running, pid: job?.pid ?? null, lastExit: job?.lastExit ?? null, runs: job?.runs ?? null, restarts, crashing, ...(s.log ? { logAgeMin } : {}) };
       });
     });
 
@@ -435,27 +458,44 @@ export class Sampler {
       for (let i = 0; i < 40 && p > 1; i += 1) { const r = byPid.get(p); if (!r) break; out.push(r); p = r.ppid; }
       return out;
     };
+    // Who owns a process is the agent above it, named by the agent itself: the session id on its own command
+    // line (`--resume`/`--session-id`, `codex resume`), else the id it sets in its own children's environment.
+    // An environment is never trusted across a tmux server: every pane inherits the variables of whichever
+    // session started that server (measured 2026-10-02: one tmux server credited one Claude session with
+    // dozens of unrelated panes). Above no agent, an inherited id is reported as inherited, never as owner.
     const need = new Set();
     const plan = new Map();
+    const childOf = (pid) => this.procs.rows.find((x) => x.ppid === pid && !AGENT.test(base(x.command)));
     for (const pid of wanted) {
       const r = byPid.get(pid);
       if (!r) continue;
       const cacheKey = `${pid}:${r.command}`;
       if (this.sessionCache.has(cacheKey)) { plan.set(pid, { cacheKey }); continue; }
       const up = chain(pid);
-      const agentIndex = up.findIndex((x) => AGENT.test(base(x.command)));
-      const lineage = agentIndex >= 0 ? up.slice(0, agentIndex + 1) : up.slice(0, 3);
-      for (const x of lineage) need.add(x.pid);
-      plan.set(pid, { cacheKey, lineage, agent: agentIndex >= 0 ? up[agentIndex] : null });
+      const stop = up.findIndex((x) => AGENT.test(base(x.command)) || base(x.command) === 'tmux');
+      const top = stop >= 0 ? up[stop] : null;
+      const agent = top && AGENT.test(base(top.command)) ? top : null;
+      // The agent's direct child on this lineage carries the variables the agent set; for the agent itself, any child.
+      const witness = agent ? (stop > 0 ? up[stop - 1] : childOf(agent.pid)) : (top ? null : r);
+      if (witness) need.add(witness.pid);
+      plan.set(pid, { cacheKey, agent, witness, pane: Boolean(top && !agent) });
     }
     const env = need.size ? await this.#environments([...need]) : new Map();
     for (const [pid, p] of plan) {
       if (!this.sessionCache.has(p.cacheKey)) {
-        let found = null;
-        for (const x of p.lineage) { found = env.get(x.pid); if (found) break; }
-        const harness = p.agent ? (HARNESS[base(p.agent.command)] ?? base(p.agent.command)) : found?.harness ?? null;
-        const session = found ? { harness: found.harness ?? harness, id: found.id, address: found.address ?? `sc:${this.machine}:${found.harness ?? harness}:${found.id}`, agentPid: p.agent?.pid ?? null }
-          : p.agent ? { harness, id: null, address: null, agentPid: p.agent.pid } : null;
+        let session = null;
+        if (p.agent) {
+          const harness = HARNESS[base(p.agent.command)] ?? base(p.agent.command);
+          const seen = p.witness ? env.get(p.witness.pid) : null;
+          const id = argvSession(p.agent.command) ?? (harness === 'codex' ? seen?.codex : harness === 'claude-code' ? seen?.claude : null) ?? null;
+          session = { harness, id, address: id ? `sc:${this.machine}:${harness}:${id}` : null, agentPid: p.agent.pid };
+        } else if (p.pane) {
+          session = { harness: null, id: null, address: null, agentPid: null, note: 'in a tmux pane with no agent above it' };
+        } else {
+          const seen = p.witness ? env.get(p.witness.pid) : null;
+          const inherited = seen?.supercode ?? (seen?.claude ? `sc:${this.machine}:claude-code:${seen.claude}` : seen?.codex ? `sc:${this.machine}:codex:${seen.codex}` : null);
+          if (inherited) session = { harness: null, id: null, address: null, agentPid: null, inherited };
+        }
         this.sessionCache.set(p.cacheKey, session);
         if (this.sessionCache.size > 5000) this.sessionCache.delete(this.sessionCache.keys().next().value);
       }
@@ -471,10 +511,7 @@ export class Sampler {
       const supercode = /(?:^|\s|\0)SUPERCODE_CALLER=(sc:[^\s\0]+)/.exec(text)?.[1];
       const claude = /(?:^|\s|\0)CLAUDE_CODE_SESSION_ID=([0-9a-f-]{36})/.exec(text)?.[1];
       const codex = /(?:^|\s|\0)CODEX_THREAD_ID=([0-9a-zA-Z-]{8,})/.exec(text)?.[1];
-      if (claude) return { harness: 'claude-code', id: claude };
-      if (codex) return { harness: 'codex', id: codex };
-      if (supercode) { const [, , harness, id] = supercode.split(':'); return { harness, id, address: supercode }; }
-      return null;
+      return supercode || claude || codex ? { supercode, claude, codex } : null;
     };
     if (this.platform === 'linux') {
       for (const pid of pids) { try { const found = pick(readFileSync(`/proc/${pid}/environ`, 'utf8')); if (found) map.set(pid, found); } catch { /* another user's */ } }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-health",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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",