@indigoai-us/hq-cli 5.345.54 → 5.345.56

package/dist/lib/lanes/reaper.js

@@ -0,0 +1,403 @@
+/** Session-start orphan lane sweep. Every destructive action is opt-in and gated. */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { laneRunsOnHost } from "./admission.js";
+import { laneRunDir, isPidRecordAlive, readPidRecord, readProcStarttime } from "./spawn.js";
+import { readAllLanes, readLane } from "./store.js";
+import { LanesError } from "./errors.js";
+export const DEFAULT_REAP_MIN_AGE_MINUTES = 120;
+export const REAP_SINGLE_FLIGHT_LOCK_STALE_MS = 60 * 60 * 1000;
+export const REAP_RECENT_SWEEP_MS = 30 * 60 * 1000;
+const SESSION_COMMANDS = new Set(["claude", "codex", "codex-code-mode-host", "grok", "grok-cli"]);
+const staleMarkerSnapshots = new WeakMap();
+function safeHostComponent(hostname) {
+    return hostname.replace(/[^A-Za-z0-9._-]/g, "_") || "unknown-host";
+}
+function reaperStateDirectory() {
+    const stateRoot = process.env.HQ_LANES_REAPER_STATE_HOME?.trim() ||
+        process.env.XDG_STATE_HOME?.trim() || path.join(os.homedir(), ".local", "state");
+    return path.join(stateRoot, "hq-cli", "lanes-reaper");
+}
+export function parseReapMinAge(value) {
+    if (value === undefined)
+        return DEFAULT_REAP_MIN_AGE_MINUTES;
+    const invalid = (message) => {
+        throw new LanesError("lane_reap_min_age_invalid", message, { value });
+    };
+    if (!/^(0|[1-9]\d*)$/.test(value))
+        invalid("--min-age must be a non-negative whole number of minutes");
+    const minutes = Number(value);
+    if (!Number.isSafeInteger(minutes) || minutes > Math.floor(Number.MAX_SAFE_INTEGER / 60_000)) {
+        invalid("--min-age is outside the supported range");
+    }
+    return minutes;
+}
+function readProcesses() {
+    const result = spawnSync("ps", ["-ww", "-axo", "pid=,ppid=,args="], { encoding: "utf8", windowsHide: true });
+    if (result.status !== 0)
+        throw new Error(`ps failed: ${result.stderr.trim()}`);
+    return result.stdout.split("\n").flatMap((line) => {
+        const match = /^\s*(\d+)\s+(\d+)\s+(.*)$/.exec(line);
+        if (!match)
+            return [];
+        return [{ pid: Number(match[1]), ppid: Number(match[2]), args: match[3] ?? "" }];
+    });
+}
+export function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ESRCH")
+            return false;
+        if (code !== "EPERM")
+            throw err;
+    }
+    const result = spawnSync("ps", ["-p", String(pid), "-o", "stat="], { encoding: "utf8", windowsHide: true });
+    return result.status === 0 && !/^\s*Z/.test(result.stdout);
+}
+function sessionCommand(args) {
+    const argv = args.trim().split(/\s+/);
+    const base = (value) => value?.split(/[\\/]/).at(-1);
+    const executable = base(argv[0]);
+    const isSessionName = (value) => {
+        const name = value?.toLowerCase() ?? "";
+        return SESSION_COMMANDS.has(name) || /^(codex|grok|claude)(?:[-.]|$)/.test(name);
+    };
+    if (isSessionName(executable))
+        return true;
+    if (["bash", "sh", "zsh", "dash", "ksh", "node"].includes(executable ?? "") && isSessionName(base(argv[1])))
+        return true;
+    if (executable === "env" && isSessionName(base(argv[1])))
+        return true;
+    return false;
+}
+function ancestryReachesSession(pid, processes) {
+    const byPid = new Map(processes.map((proc) => [proc.pid, proc]));
+    const worker = byPid.get(pid);
+    let current = worker ? byPid.get(worker.ppid) : undefined;
+    const seen = new Set();
+    for (let hops = 0; current && current.pid > 1 && hops < 64; hops += 1) {
+        if (seen.has(current.pid))
+            return true;
+        seen.add(current.pid);
+        if (sessionCommand(current.args))
+            return true;
+        current = byPid.get(current.ppid);
+    }
+    return false;
+}
+function descendantPids(rootPid, processes) {
+    const children = new Map();
+    for (const proc of processes)
+        children.set(proc.ppid, [...(children.get(proc.ppid) ?? []), proc.pid]);
+    const output = [];
+    const visit = (pid, seen) => {
+        for (const child of children.get(pid) ?? []) {
+            if (seen.has(child))
+                continue;
+            seen.add(child);
+            visit(child, seen);
+            output.push(child);
+        }
+    };
+    visit(rootPid, new Set([rootPid]));
+    return output;
+}
+function processGroup(pid) {
+    const result = spawnSync("ps", ["-p", String(pid), "-o", "pgid="], { encoding: "utf8", windowsHide: true });
+    if (result.status !== 0)
+        return null;
+    const value = Number(result.stdout.trim());
+    return Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+function processGroupPids(groupId) {
+    const result = spawnSync("ps", ["-ww", "-e", "-o", "pid=,pgid="], { encoding: "utf8", windowsHide: true });
+    if (result.status !== 0)
+        return null;
+    return result.stdout.split("\n").flatMap((line) => {
+        const match = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
+        return match && Number(match[2]) === groupId ? [Number(match[1])] : [];
+    });
+}
+function stopTree(rootPid, rootStarttime, processes, deps) {
+    const targets = [...descendantPids(rootPid, processes), rootPid];
+    const readStart = deps.readStarttime ?? readProcStarttime;
+    const expectedStarttimes = new Map(targets.map((pid) => [pid, pid === rootPid ? rootStarttime : readStart(pid)]));
+    const identityMatches = (pid) => {
+        const expected = expectedStarttimes.get(pid);
+        return expected !== undefined && expected !== null && readStart(pid) === expected;
+    };
+    const signal = (pid, value) => {
+        if (!identityMatches(pid))
+            return;
+        try {
+            process.kill(pid, value);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== "ESRCH" && code !== "EPERM")
+                throw err;
+        }
+    };
+    const sleep = deps.sleep ?? ((ms) => { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); });
+    const groupId = processGroup(rootPid);
+    const groupMembersAtStart = groupId === rootPid ? processGroupPids(groupId) : [];
+    const groupStarttimes = new Map((groupMembersAtStart ?? []).map((pid) => [pid, pid === rootPid ? rootStarttime : readStart(pid)]));
+    const sameGroupRemains = () => {
+        if (groupId !== rootPid)
+            return false;
+        const current = processGroupPids(groupId);
+        if (current === null)
+            return false;
+        return current.some((pid) => {
+            const expected = groupStarttimes.get(pid);
+            return expected !== undefined && expected !== null && readStart(pid) === expected;
+        });
+    };
+    const signalGroup = (value, requireRootIdentity = true) => {
+        if (groupId !== rootPid || (requireRootIdentity && !identityMatches(rootPid)))
+            return;
+        try {
+            process.kill(-groupId, value);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== "ESRCH" && code !== "EPERM" && code !== "EINVAL")
+                throw err;
+        }
+    };
+    // A detached worker group includes grandchildren that a PPID snapshot can miss.
+    signalGroup("SIGTERM");
+    for (const pid of targets)
+        signal(pid, "SIGTERM");
+    sleep(500);
+    const remainingGroup = groupId === rootPid ? processGroupPids(groupId) : [];
+    if (remainingGroup !== null && remainingGroup.length > 0 && sameGroupRemains())
+        signalGroup("SIGKILL", false);
+    for (const pid of targets)
+        signal(pid, "SIGKILL");
+    const isAlive = deps.isAlive ?? isProcessRunning;
+    const liveGroupMembers = () => {
+        if (groupId !== rootPid)
+            return [];
+        const members = processGroupPids(groupId);
+        return members === null ? [rootPid] : members.filter(isAlive);
+    };
+    const hasLiveTargets = () => targets.some(isAlive) || liveGroupMembers().length > 0;
+    for (let attempt = 0; attempt < 50 && hasLiveTargets(); attempt += 1) {
+        sleep(20);
+    }
+    return { targets, remaining: [...new Set([...targets.filter(isAlive), ...liveGroupMembers()])] };
+}
+function localRun(lane, hostname) {
+    if (!laneRunsOnHost(lane, { hostname, outpostId: null }))
+        return false;
+    return true;
+}
+export async function classifyLocalLanes(root, now, minAgeMinutes, deps = {}) {
+    const hostname = deps.hostname?.() ?? os.hostname();
+    const processes = (deps.processes ?? readProcesses)();
+    const alive = deps.isAlive ?? isProcessRunning;
+    const readStart = deps.readStarttime ?? readProcStarttime;
+    const result = [];
+    for (const lane of readAllLanes(root)) {
+        if (!localRun(lane, hostname))
+            continue;
+        const ageMs = now.getTime() - Date.parse(lane.created_at);
+        const age = Number.isFinite(ageMs) ? Math.max(0, Math.floor(ageMs / 60_000)) : 0;
+        const finding = { lane_id: lane.lane_id, orphaned: false, reason: "not_a_candidate", age_minutes: age };
+        const laneRunDirectory = laneRunDir(root, lane.lane_id);
+        const workerRecord = readPidRecord(path.join(laneRunDirectory, "worker.pid"));
+        const watcherRecord = readPidRecord(path.join(laneRunDirectory, "watcher.pid"));
+        const markerRecords = new Map();
+        const staleState = [];
+        for (const [marker, record] of [["worker.pid", workerRecord], ["watcher.pid", watcherRecord]]) {
+            if (!record || isPidRecordAlive(record, alive, readStart))
+                continue;
+            staleState.push(marker);
+            markerRecords.set(marker, record);
+        }
+        if (staleState.length)
+            finding.stale_state = staleState;
+        staleMarkerSnapshots.set(finding, markerRecords);
+        if (lane.senior.kind !== "session" || !lane.senior.id)
+            finding.reason = "senior_is_not_a_session";
+        else {
+            finding.session_id = lane.senior.id;
+            const sessionState = deps.sessionState?.(root, lane.senior.id, now) ?? null;
+            if (sessionState !== "ended" && sessionState !== "lost")
+                finding.reason = sessionState === "live" ? "senior_session_alive" : "senior_session_not_proven_dead";
+            else if (lane.state !== "running")
+                finding.reason = "lane_not_running";
+            else if (lane.keep_alive === true || lane.keep_alive_standing === true)
+                finding.reason = "keep_alive";
+            else if (lane.senior_history.some((entry) => entry.reason === "reparented"))
+                finding.reason = "lane_adopted_or_reparented";
+            else if (age < minAgeMinutes)
+                finding.reason = "under_minimum_age";
+            else {
+                const worker = workerRecord;
+                if (!worker) {
+                    finding.reason = "no_worker_pid";
+                }
+                else if (worker.starttime === undefined) {
+                    finding.pid = worker.pid;
+                    finding.reason = "worker_process_starttime_missing";
+                }
+                else {
+                    const starttime = worker.starttime ?? null;
+                    finding.pid = worker.pid;
+                    finding.process_starttime = starttime;
+                    const workerAlive = isPidRecordAlive(worker, alive, readStart);
+                    if (!workerAlive) {
+                        finding.reason = "worker_process_gone_or_pid_reused";
+                        finding.stale_state = staleState;
+                    }
+                    else if (ancestryReachesSession(worker.pid, processes))
+                        finding.reason = "process_has_live_session_ancestor";
+                    else {
+                        finding.orphaned = true;
+                        finding.reason = `senior_session_${sessionState};worker_process_has_no_session_ancestor`;
+                    }
+                }
+            }
+        }
+        result.push(finding);
+    }
+    return result.sort((a, b) => b.age_minutes - a.age_minutes || a.lane_id.localeCompare(b.lane_id));
+}
+export async function reapLocalLanes(root, options, deps = {}) {
+    const nowFn = deps.now ?? (() => new Date());
+    const now = nowFn();
+    const stateDir = reaperStateDirectory();
+    fs.mkdirSync(stateDir, { recursive: true });
+    const host = safeHostComponent(deps.hostname?.() ?? os.hostname());
+    const lockDir = path.join(stateDir, `.lock-${host}`);
+    try {
+        fs.mkdirSync(lockDir);
+    }
+    catch (err) {
+        if (err.code !== "EEXIST")
+            throw err;
+        const lockAge = now.getTime() - fs.statSync(lockDir).mtimeMs;
+        if (lockAge <= REAP_SINGLE_FLIGHT_LOCK_STALE_MS)
+            return { ok: true, action: "lanes.reap", generated_at: now.toISOString(), min_age_minutes: options.minAgeMinutes, mode: options.stop ? "stop" : options.applyStaleState ? "apply_stale_state" : "report", stop_enabled: false, skipped: "already_running", lanes: [] };
+        const retiredLock = `${lockDir}.stale-${process.pid}-${now.getTime()}`;
+        try {
+            fs.renameSync(lockDir, retiredLock);
+        }
+        catch {
+            return { ok: true, action: "lanes.reap", generated_at: now.toISOString(), min_age_minutes: options.minAgeMinutes, mode: "report", stop_enabled: false, skipped: "already_running", lanes: [] };
+        }
+        fs.rmSync(retiredLock, { recursive: true, force: true });
+        try {
+            fs.mkdirSync(lockDir);
+        }
+        catch {
+            return { ok: true, action: "lanes.reap", generated_at: now.toISOString(), min_age_minutes: options.minAgeMinutes, mode: "report", stop_enabled: false, skipped: "already_running", lanes: [] };
+        }
+    }
+    const stamp = path.join(stateDir, `.last-sweep-${host}`);
+    if (!options.stop && !options.applyStaleState) {
+        try {
+            const stampText = fs.readFileSync(stamp, "utf8").trim();
+            const stampedAt = /^\d+$/.test(stampText) ? Number(stampText) : fs.statSync(stamp).mtimeMs;
+            const age = now.getTime() - stampedAt;
+            if (age >= 0 && age < REAP_RECENT_SWEEP_MS) {
+                fs.rmSync(lockDir, { recursive: true, force: true });
+                return { ok: true, action: "lanes.reap", generated_at: now.toISOString(), min_age_minutes: options.minAgeMinutes, mode: "report", stop_enabled: false, skipped: "recent_sweep", lanes: [] };
+            }
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+    }
+    try {
+        const findings = await classifyLocalLanes(root, now, options.minAgeMinutes, deps);
+        const isAlive = deps.isAlive ?? isProcessRunning;
+        const readStart = deps.readStarttime ?? readProcStarttime;
+        const clearStaleMarkerIfUnchanged = (finding, marker) => {
+            const expected = staleMarkerSnapshots.get(finding)?.get(marker);
+            if (!expected)
+                return;
+            const markerPath = path.join(laneRunDir(root, finding.lane_id), marker);
+            const current = readPidRecord(markerPath);
+            if (!current || current.pid !== expected.pid || current.starttime !== expected.starttime)
+                return;
+            if (isPidRecordAlive(current, isAlive, readStart))
+                return;
+            fs.rmSync(markerPath, { force: true });
+        };
+        let stopEnabled = false;
+        for (const finding of findings) {
+            if (finding.stale_state?.length && options.applyStaleState) {
+                for (const marker of finding.stale_state)
+                    if (marker.endsWith(".pid"))
+                        clearStaleMarkerIfUnchanged(finding, marker);
+            }
+            if (!finding.orphaned || !options.stop || finding.pid === undefined) {
+                if (finding.orphaned && options.stop)
+                    finding.would_stop = true;
+                continue;
+            }
+            const lane = readLane(root, finding.lane_id);
+            const enabled = await (deps.stopEnabled?.(lane) ?? false);
+            stopEnabled ||= enabled;
+            if (!enabled) {
+                finding.would_stop = true;
+                continue;
+            }
+            if (!deps.stopLane)
+                throw new Error("--stop requires the normal lane stop path");
+            const current = readLane(root, finding.lane_id);
+            const currentNow = nowFn();
+            const currentAge = currentNow.getTime() - Date.parse(current.created_at);
+            if (!localRun(current, deps.hostname?.() ?? os.hostname()) || current.state !== "running" ||
+                current.senior.kind !== "session" || !current.senior.id || current.senior.id !== finding.session_id ||
+                current.keep_alive === true || current.keep_alive_standing === true ||
+                current.senior_history.some((entry) => entry.reason === "reparented") ||
+                !Number.isFinite(currentAge) || currentAge < options.minAgeMinutes * 60_000) {
+                finding.orphaned = false;
+                finding.reason = "lane_protection_changed_before_stop";
+                continue;
+            }
+            const currentState = deps.sessionState?.(root, current.senior.id, currentNow) ?? null;
+            if (currentState !== "ended" && currentState !== "lost") {
+                finding.orphaned = false;
+                finding.reason = currentState === "live" ? "senior_session_alive" : "senior_session_not_proven_dead";
+                continue;
+            }
+            const rec = readPidRecord(path.join(laneRunDir(root, current.lane_id), "worker.pid"));
+            if (!rec || rec.pid !== finding.pid || rec.starttime !== finding.process_starttime || rec.starttime == null || !isPidRecordAlive(rec, isAlive, readStart)) {
+                finding.orphaned = false;
+                finding.reason = "worker_pid_changed_before_stop";
+                continue;
+            }
+            const processes = (deps.processes ?? readProcesses)();
+            if (ancestryReachesSession(finding.pid, processes)) {
+                finding.orphaned = false;
+                finding.reason = "process_has_live_session_ancestor";
+                continue;
+            }
+            const { remaining } = stopTree(rec.pid, rec.starttime, processes, deps);
+            await deps.stopLane(current.lane_id, options.reason);
+            finding.stop_complete = remaining.length === 0;
+            finding.stopped = finding.stop_complete;
+            if (!finding.stop_complete)
+                finding.stop_error = `process_tree_stop_incomplete:${remaining.join(",")}`;
+        }
+        fs.writeFileSync(stamp, `${now.getTime()}\n`);
+        return { ok: true, action: "lanes.reap", generated_at: now.toISOString(), min_age_minutes: options.minAgeMinutes, mode: options.stop ? "stop" : options.applyStaleState ? "apply_stale_state" : "report", stop_enabled: stopEnabled, lanes: findings };
+    }
+    finally {
+        fs.rmSync(lockDir, { recursive: true, force: true });
+    }
+}
+/** Internal alias used by session-start hooks; it has no shell or OS-specific dependency. */
+export const runSessionStartReap = reapLocalLanes;
+//# sourceMappingURL=reaper.js.map

package/dist/lib/lanes/registry-flag.d.ts

@@ -11,6 +11,8 @@ export interface LanesFlagClient {
 }
 export type LanesFlagClientFactory = (options: FlagClientOptions) => LanesFlagClient;
 export interface ReadLanesFlagOptions {
+    /** Fallback for a missing registry row; kill switches should normally use true. */
+    defaultValue?: boolean;
     company?: LaneCompanyRef | null;
     companyUidSource?: string;
     env?: NodeJS.ProcessEnv;

package/dist/lib/lanes/registry-flag.js

@@ -155,7 +155,7 @@ async function readRegistryValue(flagKey, endpoint, options) {
             rememberFailure(error);
         }
         try {
-            resolution = client.explain(flagKey, { fallback: false });
+            resolution = client.explain(flagKey, { fallback: options.defaultValue ?? false });
         }
         catch (error) {
             rememberFailure(error);

package/dist/lib/lanes/spawn.d.ts

@@ -128,6 +128,8 @@ export declare function readProcStarttimeDetailed(pid: number): {
     starttime: number | null;
     error: string | null;
 };
+/** macOS has no /proc; use ps's process start time as the PID identity token. */
+export declare function parsePsStarttime(value: string): number | null;
 export declare function readProcStarttime(pid: number): number | null;
 export declare function parsePidRecord(text: string): PidRecord | null;
 export declare function readPidRecord(filePath: string): PidRecord | null;

package/dist/lib/lanes/spawn.js

@@ -31,6 +31,7 @@ import { appendCappedHistory, listLaneIds, readLane, retryUpdateLane } from "./s
 import { managerStatusGateHeartbeat } from "./manager-status-gate.js";
 import { LANE_QUOTA_ACCOUNT_FAILOVER_FLAG } from "./flag-keys.js";
 import { readLanesRegistryFlagFailOff } from "./registry-flag.js";
+import { LANE_WORKER_EXIT_PATH_ENV } from "./worker-process.js";
 import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
 import { LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT } from "./keep-alive.js";
 import { copySessionFiles, planSessionCopy } from "./move-account.js";
@@ -932,6 +933,16 @@ export function readProcStarttimeDetailed(pid) {
     }
     catch (err) {
         const code = err.code;
+        if (code === "ENOENT" && process.platform === "darwin") {
+            const result = spawnSync("ps", ["-p", String(pid), "-o", "lstart="], {
+                encoding: "utf8",
+                windowsHide: true,
+            });
+            const starttime = parsePsStarttime(result.status === 0 ? result.stdout : "");
+            return starttime === null
+                ? { starttime: null, error: result.status === 0 ? "invalid_ps_starttime" : "ENOENT" }
+                : { starttime, error: null };
+        }
         if (code === "ENOENT")
             return { starttime: null, error: "ENOENT" };
         process.stderr.write(`hq lanes: failed to read starttime for pid ${pid}: ${err instanceof Error ? err.message : String(err)}\n`);
@@ -941,6 +952,14 @@ export function readProcStarttimeDetailed(pid) {
         };
     }
 }
+/** macOS has no /proc; use ps's process start time as the PID identity token. */
+export function parsePsStarttime(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    const parsed = Date.parse(trimmed);
+    return Number.isFinite(parsed) ? parsed : null;
+}
 export function readProcStarttime(pid) {
     return readProcStarttimeDetailed(pid).starttime;
 }
@@ -1698,6 +1717,17 @@ function spawnDetached(spawnProcess, command, args, env, cwd, stdoutPath, stderr
             closeFd(errFd, stderrPath);
     }
 }
+function spawnTrackedWorker(spawnProcess, command, args, env, cwd, stdoutPath, stderrPath, exitPath) {
+    try {
+        fs.unlinkSync(exitPath);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const runnerPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../dist/lib/lanes/worker-process.js");
+    return spawnDetached(spawnProcess, process.execPath, [runnerPath, command, ...args], { ...env, [LANE_WORKER_EXIT_PATH_ENV]: exitPath }, cwd, stdoutPath, stderrPath);
+}
 function requireDetached(proveDetached, pid, kind) {
     const proof = proveDetached(pid);
     if (proof.detached)
@@ -2572,7 +2602,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     let workerPid;
     let watcherPid;
     try {
-        workerPid = spawnDetached(spawnProcess, command.command, command.args, childEnv, hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"));
+        workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
         writePidRecord(path.join(runDir, "worker.pid"), {
             pid: workerPid,
             starttime: readProcStarttime(workerPid) ?? undefined,
@@ -2881,7 +2911,7 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
     const previous = readSpawnManifest(runDir);
     let workerPid;
     try {
-        workerPid = spawnDetached(spawnProcess, command.command, command.args, childEnv, hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"));
+        workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
         writePidRecord(path.join(runDir, "worker.pid"), {
             pid: workerPid,
             starttime: readProcStarttime(workerPid) ?? undefined,

package/dist/lib/lanes/status-fields.d.ts

@@ -0,0 +1,12 @@
+import { type LaneRecord } from "./types.js";
+export interface LaneStatusRowFields {
+    last_line: string | null;
+    pr: string | null;
+    inbox_pending: number | null;
+    elapsed_s: number | null;
+    exit: number | null;
+}
+export type LaneStatusRow = LaneRecord & Partial<LaneStatusRowFields>;
+/** Bounded, local-only status data. Remote-owned lanes report null for file-backed fields. */
+export declare function readLaneStatusRowFields(hqRoot: string, lane: LaneRecord, nowMs?: number, local?: boolean): LaneStatusRowFields;
+//# sourceMappingURL=status-fields.d.ts.map