tickmarkr 2.6.9 → 2.7.0

package/dist/run/daemon.d.ts

@@ -253,8 +253,8 @@ export declare function verifyIntegrationTipCached(intWt: string, commands: Reco
 type SuitePidProbe = (pid: number) => number | undefined;
 /** Count full-suite roots in one process-table snapshot. The probes are arguments so the ownership
  * rules remain testable on hosts that forbid process inspection; production supplies cwd and the
- * inherited TICKMARKR_SUITE_PARENT marker from the process itself. */
-export declare function countLiveSuites(snapshot: string, repoRoot: string, daemonPid?: number, cwdForPid?: (pid: number) => string | undefined, suiteParentForPid?: SuitePidProbe): number;
+ * inherited TICKMARKR_SUITE_PARENT marker from one batched async probe (suite-census.ts, queue row 103). */
+export declare function countLiveSuites(snapshot: string, repoRoot: string, daemonPid: number, cwdForPid: (pid: number) => string | undefined, suiteParentForPid: SuitePidProbe): number;
 export declare const setLiveSuiteCountForTests: (probe: (repoRoot: string) => Promise<number>) => void;
 export declare const resetLiveSuiteCountForTests: () => void;
 /** Live full-suite roots attributable to this repository or this daemon. Ancestors are excluded so

package/dist/run/daemon.js

@@ -9,6 +9,7 @@ import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+import { batchedProcessProbes, runnerPids } from "./suite-census.js";
 import { stringify } from "yaml";
 import { BOOTSTRAP_FAILURE_RE, classifyDeadChannel, classifyTransientCapacity, trailerPattern, writePrompt } from "../adapters/prompt.js";
 import { allAdapters, getAdapter, probeAll, readDoctor, rolePools } from "../adapters/registry.js";
@@ -1243,48 +1244,14 @@ async function observeWorkerProcessTree(marker, cwd) {
     }
     return tree.size === 0 ? "empty" : "running";
 }
-function processCwd(pid) {
-    try {
-        return realpathSync(readlinkSync(`/proc/${pid}/cwd`));
-    }
-    catch { /* Darwin has no /proc */ }
-    try {
-        const out = execFileSync("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], {
-            encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5_000,
-        });
-        const path = out.split("\n").find((line) => line.startsWith("n"))?.slice(1);
-        return path ? realpathSync(path) : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function processSuiteParent(pid) {
-    try {
-        const env = readFileSync(`/proc/${pid}/environ`, "utf8").split("\0");
-        const value = env.find((entry) => entry.startsWith(`${SUITE_PARENT_ENV}=`))?.slice(SUITE_PARENT_ENV.length + 1);
-        return value && /^\d+$/.test(value) ? Number(value) : undefined;
-    }
-    catch { /* Darwin has no /proc process environments */ }
-    try {
-        const out = execFileSync("ps", ["eww", "-p", String(pid), "-o", "command="], {
-            encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5_000,
-        });
-        const value = new RegExp(`(?:^|\\s)${SUITE_PARENT_ENV}=(\\d+)(?:\\s|$)`).exec(out)?.[1];
-        return value ? Number(value) : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 const pathAtOrBelow = (root, candidate) => {
     const rel = relative(root, candidate);
     return rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
 };
 /** Count full-suite roots in one process-table snapshot. The probes are arguments so the ownership
  * rules remain testable on hosts that forbid process inspection; production supplies cwd and the
- * inherited TICKMARKR_SUITE_PARENT marker from the process itself. */
-export function countLiveSuites(snapshot, repoRoot, daemonPid = process.pid, cwdForPid = processCwd, suiteParentForPid = processSuiteParent) {
+ * inherited TICKMARKR_SUITE_PARENT marker from one batched async probe (suite-census.ts, queue row 103). */
+export function countLiveSuites(snapshot, repoRoot, daemonPid, cwdForPid, suiteParentForPid) {
     const rows = [];
     for (const line of snapshot.split("\n")) {
         const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(line);
@@ -1344,7 +1311,11 @@ export async function liveSuiteCount(repoRoot) {
     if (liveSuiteCountForTests)
         return liveSuiteCountForTests(repoRoot);
     const snapshot = await shGit("ps -Aww -o pid=,ppid=,state=,command=", repoRoot, 15_000);
-    return snapshot.code === 0 ? countLiveSuites(snapshot.stdout, repoRoot) : 0;
+    if (snapshot.code !== 0)
+        return 0;
+    // row 103: one batched async probe per snapshot — a synchronous lsof/ps per pid held this loop 44–46 s
+    const probes = await batchedProcessProbes(runnerPids(snapshot.stdout));
+    return countLiveSuites(snapshot.stdout, repoRoot, process.pid, probes.cwd, probes.suiteParent);
 }
 const OBSERVE_CHUNK_BYTES = 64 * 1024;
 const OBSERVE_BUDGET_BYTES = 256 * 1024 * 1024;

package/dist/run/suite-census.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Queue row 103 (D-1553): the live-suite census asks each runner-looking process for its cwd and its inherited
+ * TICKMARKR_SUITE_PARENT marker. It used to ask one pid at a time with a synchronous `lsof` and `ps`, which held the
+ * daemon's event loop 44–46 s under a full suite (the stall traces recorded for queue row 8). Here every pid is answered by /proc where it
+ * exists (Linux, child-free), else by ONE async `lsof` and ONE async `ps eww`, plus one more `lsof` for suite parents
+ * not already probed — the census asks for a parent's cwd too. The answers feed countLiveSuites' existing lookups.
+ */
+export type ProbeExec = (file: string, args: readonly string[]) => Promise<string>;
+/** The pids of every live (non-zombie) row of a `ps -o pid=,ppid=,state=,command=` snapshot whose command is a runner. */
+export declare function runnerPids(snapshot: string): number[];
+/** The /proc reads, injectable so the Linux branch is testable anywhere; each throws where /proc has no entry. */
+export interface ProcReader {
+    cwd(pid: number): string;
+    environ(pid: number): string;
+}
+export interface CensusProbes {
+    cwd: (pid: number) => string | undefined;
+    suiteParent: (pid: number) => number | undefined;
+}
+export declare function batchedProcessProbes(pids: readonly number[], exec?: ProbeExec, proc?: ProcReader): Promise<CensusProbes>;

package/dist/run/suite-census.js

@@ -0,0 +1,100 @@
+import { execFile } from "node:child_process";
+import { readFileSync, readlinkSync, realpathSync } from "node:fs";
+import { isRunnerCommand } from "./lease.js";
+import { SUITE_PARENT_ENV } from "./git.js";
+// A pid that exits between the snapshot and the probe makes lsof/ps exit non-zero while still printing every other
+// row, so an ordinary non-zero exit (a numeric code, no signal) keeps whatever was printed. D-1564: a timeout, a kill, a
+// spawn failure or an output-cap overflow is no answer — the base's execFileSync threw there and discarded any partial
+// output, so these answer nothing even when they buffered rows first.
+// D-1561: execFile can also throw SYNCHRONOUSLY (EPERM, EAGAIN under fork pressure); the base's per-pid try/catch answered
+// that as "unknown", so this probe never throws or rejects either — it answers nothing.
+const probeExec = (file, args) => new Promise((resolve) => {
+    try {
+        execFile(file, [...args], { encoding: "utf8", timeout: 15_000, maxBuffer: 16 * 1024 * 1024 }, (error, stdout) => resolve(error && (error.killed || error.signal || typeof error.code !== "number") ? "" : String(stdout ?? "")));
+    }
+    catch {
+        resolve("");
+    }
+});
+/** The pids of every live (non-zombie) row of a `ps -o pid=,ppid=,state=,command=` snapshot whose command is a runner. */
+export function runnerPids(snapshot) {
+    const pids = [];
+    for (const line of snapshot.split("\n")) {
+        const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(line);
+        if (match && !match[3].startsWith("Z") && isRunnerCommand(match[4]))
+            pids.push(Number(match[1]));
+    }
+    return pids;
+}
+const procReader = {
+    cwd: (pid) => realpathSync(readlinkSync(`/proc/${pid}/cwd`)),
+    environ: (pid) => readFileSync(`/proc/${pid}/environ`, "utf8"),
+};
+export async function batchedProcessProbes(pids, exec = probeExec, proc = procReader) {
+    // the census never rejects, whatever exec does (queue row 103's closed case table, D-1561)
+    const ask = async (file, args) => { try {
+        return await exec(file, args);
+    }
+    catch {
+        return "";
+    } };
+    const cwds = new Map();
+    const parents = new Map();
+    const parentIn = (text) => new RegExp(`(?:^|\\s)${SUITE_PARENT_ENV}=(\\d+)(?:\\s|$)`).exec(text)?.[1];
+    // D-1567 batch poisoning: lsof and ps fail the WHOLE command for one -p member they cannot take (a marker of 22 digits
+    // prints as 1e+21, 310 nines as Infinity; ps refuses one above int32), erasing every other pid's answer. The base probed
+    // per pid, so such a pid lost only its own answer: it stays unanswered here and never joins a batch.
+    const probeable = (pid) => Number.isSafeInteger(pid) && pid > 0 && pid <= 2_147_483_647;
+    const probeCwds = async (wanted) => {
+        const rest = [];
+        for (const pid of wanted.filter(probeable)) {
+            try {
+                cwds.set(pid, proc.cwd(pid));
+            }
+            catch {
+                rest.push(pid);
+            } // Darwin has no /proc
+        }
+        if (rest.length === 0)
+            return;
+        let pid;
+        for (const line of (await ask("lsof", ["-a", "-p", rest.join(","), "-d", "cwd", "-Fn"])).split("\n")) {
+            if (line.startsWith("p"))
+                pid = Number(line.slice(1));
+            else if (line.startsWith("n") && pid !== undefined) {
+                try {
+                    cwds.set(pid, realpathSync(line.slice(1)));
+                }
+                catch { /* the directory is gone */ }
+            }
+        }
+    };
+    const probeParents = async (wanted) => {
+        const rest = [];
+        for (const pid of wanted.filter(probeable)) {
+            try {
+                // the base's exact rule (7c8009772 daemon.ts:1418-1423, D-1558): ONE NUL-delimited entry, its WHOLE value digits —
+                // a joined string would let another variable's text, or a value with trailing junk, pass for the marker
+                const value = proc.environ(pid).split("\0").find((entry) => entry.startsWith(`${SUITE_PARENT_ENV}=`))?.slice(SUITE_PARENT_ENV.length + 1);
+                if (value && /^\d+$/.test(value))
+                    parents.set(pid, Number(value));
+            }
+            catch {
+                rest.push(pid);
+            } // Darwin has no /proc process environments
+        }
+        if (rest.length === 0)
+            return;
+        for (const line of (await ask("ps", ["eww", "-p", rest.join(","), "-o", "pid=,command="])).split("\n")) {
+            const row = /^\s*(\d+)\s+(.*)$/.exec(line);
+            const value = row ? parentIn(row[2]) : undefined;
+            if (row && value)
+                parents.set(Number(row[1]), Number(value));
+        }
+    };
+    const unique = [...new Set(pids)];
+    await probeCwds(unique);
+    await probeParents(unique);
+    await probeCwds([...new Set(parents.values())].filter((pid) => !cwds.has(pid)));
+    return { cwd: (pid) => cwds.get(pid), suiteParent: (pid) => parents.get(pid) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "2.6.9",
+  "version": "2.7.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",