tickmarkr 2.7.2 → 2.7.4

package/dist/cli/commands/verify.js

@@ -7,7 +7,7 @@ import { allAdapters, probeAll, readDoctor, rolePools, writeDoctor } from "../..
 import { channelKey } from "../../adapters/types.js";
 import { loadConfig } from "../../config/config.js";
 import { captureBaseline, detectGateCommands, staleFileCountCommands } from "../../gates/baseline.js";
-import { getVerdictStore, runnerInputsHash } from "../../gates/cache.js";
+import { getVerdictStore, lockfileKeyBytes, runnerInputsHash } from "../../gates/cache.js";
 import { modelProvider } from "../../gates/review.js";
 import { runGates } from "../../gates/run-gates.js";
 import { getTask, loadGraph } from "../../graph/graph.js";
@@ -92,7 +92,7 @@ export function baselineCachePath(cwd, baseSha, commands) {
     const lockParts = [];
     for (const file of LOCKFILES) {
         const path = join(cwd, file);
-        lockParts.push(file, existsSync(path) ? readFileSync(path) : "<absent>");
+        lockParts.push(file, existsSync(path) ? lockfileKeyBytes(file, readFileSync(path)) : "<absent>");
     }
     const commandParts = Object.entries(commands).sort(([a], [b]) => a.localeCompare(b)).map(([name, command]) => `${name}\0${command}\0`);
     return join(realpathSync(tmpdir()), "tickmarkr-verify", "cache", `baseline-${baseSha.slice(0, 12)}-${hashParts(lockParts)}-${hashParts(commandParts)}-${runnerInputsHash()}.json`);

package/dist/gates/cache.d.ts

@@ -5,6 +5,7 @@ export declare const DEFAULT_VERDICT_CACHE_BOUND = 128;
 export declare function setVerdictCacheBoundForTests(bound: number | undefined): void;
 export declare function resetVerdictCacheBoundForTests(): void;
 export declare const LOCKFILES: readonly ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb"];
+export declare function lockfileKeyBytes(file: string, bytes: Buffer): Buffer | string;
 export declare function lockfileHash(worktree: string): string;
 export declare function canonicalJson(obj: unknown): string;
 export declare function baselineIdentity(baseline?: Baseline): string;

package/dist/gates/cache.js

@@ -23,6 +23,32 @@ export const LOCKFILES = [
     "bun.lock",
     "bun.lockb",
 ];
+// Queue row 122: a version-only bump rewrites an npm v2/v3 lockfile's root `version` and `packages[""].version` and nothing
+// a dependency resolves from, so those two fields leave the key; every other byte keys as written. Other lockfile kinds, a
+// v1 or unversioned npm lockfile, and an unparseable one key on their raw bytes, which can only miss, never falsely hit.
+export function lockfileKeyBytes(file, bytes) {
+    if (file !== "package-lock.json" && file !== "npm-shrinkwrap.json")
+        return bytes;
+    let lock;
+    try {
+        lock = JSON.parse(bytes.toString("utf8"));
+    }
+    catch {
+        return bytes;
+    }
+    if (!lock || typeof lock !== "object" || Array.isArray(lock))
+        return bytes;
+    const { version: _version, ...rest } = lock;
+    if (rest.lockfileVersion !== 2 && rest.lockfileVersion !== 3)
+        return bytes;
+    const packages = rest.packages;
+    const own = packages?.[""];
+    if (own && typeof own === "object" && !Array.isArray(own)) {
+        const { version: _ownVersion, ...ownRest } = own;
+        rest.packages = { ...packages, "": ownRest };
+    }
+    return canonicalJson(rest);
+}
 export function lockfileHash(worktree) {
     const hash = createHash("sha256");
     let found = false;
@@ -31,7 +57,7 @@ export function lockfileHash(worktree) {
         if (existsSync(p)) {
             found = true;
             try {
-                hash.update(file).update("\0").update(readFileSync(p)).update("\0");
+                hash.update(file).update("\0").update(lockfileKeyBytes(file, readFileSync(p))).update("\0");
             }
             catch {
                 hash.update(file).update("\0unreadable\0");

package/dist/run/daemon.d.ts

@@ -263,6 +263,8 @@ export declare function verifyIntegrationTipCached(intWt: string, commands: Reco
     signal?: AbortSignal;
     evidence?: GateEvidenceOptions;
 }): Promise<boolean>;
+type WorkerProcessTree = "empty" | "running" | "unmeasurable";
+export declare function observeWorkerProcessTree(marker: string, cwd: string): Promise<WorkerProcessTree>;
 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

package/dist/run/daemon.js

@@ -34,7 +34,7 @@ import { executionSignal, remainingExecutionMs, withExecutionBudget, withoutExec
 import { repairSelectionDecision, repairSelectionEnabled } from "./repair-selection.js";
 import { failureDisposition, reserveInfrastructureRetry } from "./recovery.js";
 import { runEnvironment } from "./environment.js";
-import { addDetachedWorktree, changeRepresented, cleanupRunWorktrees, deriveForkCap, FORK_CAP_ENV, gitHead, linkNodeModules, npmDependencyInstallCommand, npmDependencyManifestChanged, PRESERVE_COMMIT_SUBJECT, PRESERVE_PRODUCER_TRAILER, preserveWorktree, producerFields, removeWorktree, resolvedCapacity, runWithForkBudget, runWithVerificationBudget, sameCapacity, sameVerification, sh, shGit, SUITE_PARENT_ENV, verificationProtocol, WORKTREE_LAYOUT_CONTRACT, WORKTREES_DIR, worktreePath } from "./git.js";
+import { addDetachedWorktree, changeRepresented, cleanupRunWorktrees, deriveForkCap, FORK_CAP_ENV, gitHead, linkNodeModules, npmDependencyInstallCommand, npmDependencyManifestChanged, PRESERVE_COMMIT_SUBJECT, PRESERVE_PRODUCER_TRAILER, preserveWorktree, producerFields, removeWorktree, resolvedCapacity, runWithForkBudget, runWithVerificationBudget, sameCapacity, sameVerification, sh, shell, shGit, SUITE_PARENT_ENV, verificationProtocol, WORKTREE_LAYOUT_CONTRACT, WORKTREES_DIR, worktreePath } from "./git.js";
 import { MASK } from "./redact.js";
 import { runInteractiveSeed } from "./interactive-seed.js";
 import { classifyRepairDisposition, resolveScopeHints } from "./repair-disposition.js";
@@ -1237,8 +1237,9 @@ async function gateCommitSubject(base, head, wt) {
 // OBS-737 needs. A readable process table with no marker root is measured empty; a failed or empty
 // table is unmeasurable. Descendants are closed over PPID because not every child retains the
 // dispatch-script marker in its own argv.
-async function observeWorkerProcessTree(marker, cwd) {
-    const snapshot = await shGit("ps -Awwo pid=,ppid=,command=", cwd, 15_000);
+export async function observeWorkerProcessTree(marker, cwd) {
+    // queue row 113: `ps` is not git, so the payload entry — the own-git entry's pin probes are two SYNC git spawns per call
+    const snapshot = await shell("ps -Awwo pid=,ppid=,command=", cwd, 15_000);
     if (snapshot.code !== 0)
         return "unmeasurable";
     const rows = [];
@@ -1327,7 +1328,8 @@ export const resetLiveSuiteCountForTests = () => { liveSuiteCountForTests = unde
 export async function liveSuiteCount(repoRoot) {
     if (liveSuiteCountForTests)
         return liveSuiteCountForTests(repoRoot);
-    const snapshot = await shGit("ps -Aww -o pid=,ppid=,state=,command=", repoRoot, 15_000);
+    // queue row 113: `ps` is not git, so the payload entry — the own-git entry's pin probes are two SYNC git spawns per call
+    const snapshot = await shell("ps -Aww -o pid=,ppid=,state=,command=", repoRoot, 15_000);
     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

package/dist/run/stall.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { execFile } from "node:child_process";
 import { isAbsolute, relative, sep } from "node:path";
-import { activeShellIdentities, processIdentity, resolveActiveShellIdentities, shGit, SUITE_PARENT_ENV } from "./git.js";
+import { activeShellIdentities, processIdentity, resolveActiveShellIdentities, shell, SUITE_PARENT_ENV } from "./git.js";
 // OBS-82: normalize known presentation tokens before measuring transcript extent or filtering an
 // LLM-bound transcript. This remains a closed allowlist — ANSI/VT escapes, braille-range spinner
 // glyphs, and elapsed-time tokens bound to time-unit suffixes. Every other byte passes through
@@ -71,7 +71,8 @@ export async function reapOwnedProcessGroup(group, cwd, ownership) {
         return reapWorkerProcesses(group, cwd, ownership);
     if (group === undefined)
         return null;
-    const own = await shGit(`ps -o pgid= -p ${process.pid}`, cwd, 5_000);
+    // queue row 113: `ps` is not git, so the payload entry — the own-git entry's pin probes are two SYNC git spawns per call
+    const own = await shell(`ps -o pgid= -p ${process.pid}`, cwd, 5_000);
     // An in-process driver fixture (or a non-isolating host) can share the daemon's
     // group. It is not an owned worker group: let the driver's close retire that slot.
     if (own.code !== 0 || !/^\d+$/.test(own.stdout.trim()) || Number(own.stdout.trim()) === group)
@@ -87,7 +88,7 @@ export async function reapOwnedProcessGroup(group, cwd, ownership) {
     // SIGKILL delivery and process retirement are asynchronous. Bound the confirmation
     // grace, retaining names if a process is still present after it.
     for (let probe = 0; probe < 5; probe++) {
-        const snapshot = await shGit("ps -Awwo pid=,pgid=,stat=", cwd, 5_000);
+        const snapshot = await shell("ps -Awwo pid=,pgid=,stat=", cwd, 5_000);
         if (snapshot.code !== 0)
             return null;
         survivors = snapshot.stdout.split("\n").flatMap((line) => {
@@ -377,9 +378,9 @@ let linuxClockTickMs;
 function linuxProcessCpuMs(pid, cwd) {
     if (!existsSync("/proc/self/stat"))
         return Promise.resolve(undefined);
-    // shGit, not sh: the accountant samples at 100ms cadence and must not run the operator's login
-    // profile (nvm/pyenv/direnv side effects included) on every sample.
-    linuxClockTickMs ??= shGit("getconf CLK_TCK", cwd, 15_000).then((r) => {
+    // shell (login false), not sh: the accountant samples at 100ms cadence and must not run the operator's login
+    // profile (nvm/pyenv/direnv side effects included). Not shGit either: getconf is not git (queue row 113).
+    linuxClockTickMs ??= shell("getconf CLK_TCK", cwd, 15_000).then((r) => {
         const ticks = r.code === 0 ? Number(r.stdout.trim()) : Number.NaN;
         return Number.isFinite(ticks) && ticks > 0 ? 1_000 / ticks : undefined;
     });
@@ -403,12 +404,21 @@ function linuxProcessCpuMs(pid, cwd) {
 // finds that root and its descendants. An empty tree is measurable zero; a failed or unparseable
 // snapshot is undefined because missing evidence can never prove inactivity.
 async function workerTreeCpuSnapshot(marker, cwd, group, identities) {
-    const snapshot = await shGit("ps -Awwo pid=,ppid=,time=,command=", cwd, 15_000);
+    // queue row 113: `ps` is not git, so the payload entry — the own-git entry's pin probes are two SYNC git spawns per call
+    // ONE snapshot carries the group column too (it was a second `ps -Awwo pid=,pgid=` per sample).
+    const snapshot = await shell("ps -Awwo pid=,ppid=,pgid=,time=,command=", cwd, 15_000);
     if (snapshot.code !== 0)
         return undefined;
     const rows = [];
+    const grouped = [];
     for (const line of snapshot.stdout.split("\n")) {
-        const m = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(line);
+        // Group membership reads EVERY row, as the separate group snapshot did; a CPU row also needs a parseable time.
+        const ids = /^\s*(\d+)\s+(\d+)\s+(\d+)(?:\s|$)/.exec(line);
+        if (!ids)
+            continue;
+        if (group !== undefined && Number(ids[3]) === group)
+            grouped.push(ids[1]);
+        const m = /^\s*(\d+)\s+(\d+)\s+\d+\s+(\S+)\s+(.*)$/.exec(line);
         if (!m)
             continue;
         const cpu = parsePsCpu(m[3]);
@@ -420,16 +430,8 @@ async function workerTreeCpuSnapshot(marker, cwd, group, identities) {
     const tree = new Set(rows.filter((p) => p.cmd.includes(marker)).map((p) => p.pid));
     // CPU presentation matching is intentionally broader than authority to signal a process.
     const owned = new Set(rows.filter((p) => p.cmd === `bash ${marker}` || p.cmd === `/bin/bash ${marker}`).map((p) => p.pid));
-    if (group !== undefined) {
-        const groups = await shGit("ps -Awwo pid=,pgid=", cwd, 15_000);
-        if (groups.code !== 0)
-            return undefined;
-        for (const line of groups.stdout.split("\n")) {
-            const row = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
-            if (row && Number(row[2]) === group)
-                tree.add(row[1]);
-        }
-    }
+    for (const pid of grouped)
+        tree.add(pid);
     // ps output is not topologically ordered; relax the parent -> child closure until stable.
     for (let grew = true; grew;) {
         grew = false;

package/package.json

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