@indigoai-us/hq-cli 5.345.55 → 5.345.57

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -27,7 +27,7 @@ export interface OutpostDispatchResult {
     stderr: string;
 }
 export interface OutpostLaneCommand {
-    action: "message" | "resume" | "stop" | "show" | "logs" | "grant" | "grant-target" | "reparent-target" | "approve-target" | "repair-company-target";
+    action: "message" | "resume" | "stop" | "show" | "logs" | "grant" | "grant-target" | "reparent-target" | "approve-target" | "repair-company-target" | "blocked-escalation-target";
     laneId: string;
     hqBinary?: string;
     text?: string;
@@ -53,6 +53,8 @@ export interface OutpostLaneCommand {
     json?: boolean;
     callerLaneId?: string;
     callerSessionId?: string;
+    messageId?: string;
+    recipientKind?: "lane" | "session";
 }
 export declare function buildOutpostQuestionAnswerCommand(input: {
     questionId: string;
@@ -114,6 +116,12 @@ export declare function buildOutpostLegacyLaneUlidListCommand(input: {
 /** Read questions on one Outpost, scoped to a company when supplied. */
 export declare function buildOutpostQuestionListCommand(input?: {
     company?: string;
+    sessionId?: string;
+    for?: string;
+    from?: string;
+    project?: string;
+    story?: string;
+    status?: string;
 }): string;
 /** Read one question's body and owner-computed audience from its Outpost. */
 export declare function buildOutpostQuestionShowCommand(questionId: string): string;

package/dist/lib/lanes/outpost-dispatch.js

@@ -121,10 +121,23 @@ export function buildOutpostLegacyLaneUlidListCommand(input) {
 }
 /** Read questions on one Outpost, scoped to a company when supplied. */
 export function buildOutpostQuestionListCommand(input = {}) {
-    const args = ["hq", "lanes", "questions", "list"];
+    const args = [
+        ...(input.sessionId?.trim() ? ["env", `HQ_SESSION_ID=${input.sessionId.trim()}`] : []),
+        "hq", "lanes", "questions", "list",
+    ];
     const company = input.company?.trim();
     if (company)
         args.push("--company", company);
+    for (const [flag, value] of [
+        ["--for", input.for],
+        ["--from", input.from],
+        ["--project", input.project],
+        ["--story", input.story],
+        ["--status", input.status],
+    ]) {
+        if (value !== undefined)
+            args.push(flag, value);
+    }
     return withRemoteHqDir(joinCommandParts(args));
 }
 /** Read one question's body and owner-computed audience from its Outpost. */
@@ -191,12 +204,12 @@ export function buildOutpostIdentityBackfillCommand(expectedId) {
 }
 /** Build the same `hq outposts exec` remote command used by lane pickup. */
 export function buildOutpostLaneCommand(input) {
-    const args = [
-        input.hqBinary?.trim() || "hq",
-        "lanes",
-        input.action,
-        input.laneId,
-    ];
+    const action = input.action === "blocked-escalation-target" ? "_enqueue-blocked-escalation" : input.action;
+    const args = [input.hqBinary?.trim() || "hq", "lanes", action];
+    if (input.action === "blocked-escalation-target")
+        args.push(input.recipientKind ?? "lane", input.laneId);
+    else
+        args.push(input.laneId);
     for (const [flag, value] of [
         ["--text", input.text],
         ["--project", input.project],
@@ -214,6 +227,7 @@ export function buildOutpostLaneCommand(input) {
         ["--senior", input.senior],
         ["--reason", input.reason],
         ["--company", input.company],
+        ["--message-id", input.messageId],
     ]) {
         if (value !== undefined)
             args.push(flag, value);

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

@@ -0,0 +1,58 @@
+import type { LaneRecord } from "./types.js";
+export declare const DEFAULT_REAP_MIN_AGE_MINUTES = 120;
+export declare const REAP_SINGLE_FLIGHT_LOCK_STALE_MS: number;
+export declare const REAP_RECENT_SWEEP_MS: number;
+export interface ReapProcess {
+    pid: number;
+    ppid: number;
+    args: string;
+}
+export interface ReapFinding {
+    lane_id: string;
+    orphaned: boolean;
+    reason: string;
+    age_minutes: number;
+    session_id?: string;
+    pid?: number;
+    process_starttime?: number | null;
+    would_stop?: boolean;
+    stopped?: boolean;
+    stop_complete?: boolean;
+    stop_error?: string;
+    stale_state?: string[];
+}
+export interface ReapDeps {
+    now?: () => Date;
+    hostname?: () => string;
+    processes?: () => ReapProcess[];
+    isAlive?: (pid: number) => boolean;
+    readStarttime?: (pid: number) => number | null;
+    sessionState?: (root: string, sessionId: string, now: Date) => string | null;
+    stopEnabled?: (lane: LaneRecord) => Promise<boolean> | boolean;
+    stopLane?: (laneId: string, reason: string) => Promise<void>;
+    sleep?: (ms: number) => void;
+}
+export declare function parseReapMinAge(value: string | undefined): number;
+export declare function isProcessRunning(pid: number): boolean;
+export declare function classifyLocalLanes(root: string, now: Date, minAgeMinutes: number, deps?: ReapDeps): Promise<ReapFinding[]>;
+export interface ReapOptions {
+    minAgeMinutes: number;
+    stop: boolean;
+    applyStaleState: boolean;
+    reason: string;
+    json: boolean;
+}
+export interface ReapSummary {
+    ok: true;
+    action: "lanes.reap";
+    generated_at: string;
+    min_age_minutes: number;
+    mode: "report" | "apply_stale_state" | "stop";
+    stop_enabled: boolean;
+    skipped?: "already_running" | "recent_sweep";
+    lanes: ReapFinding[];
+}
+export declare function reapLocalLanes(root: string, options: ReapOptions, deps?: ReapDeps): Promise<ReapSummary>;
+/** Internal alias used by session-start hooks; it has no shell or OS-specific dependency. */
+export declare const runSessionStartReap: typeof reapLocalLanes;
+//# sourceMappingURL=reaper.d.ts.map

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/reconcile.d.ts

@@ -40,6 +40,20 @@ export interface ReconcileChange {
     /** The attempted provider PATH when admission found no executable. */
     searched_path?: string;
 }
+export interface BlockedLaneEscalationDelivery {
+    lane_id: string;
+    project_id: string;
+    story_id: string;
+    direct_senior: SeniorRef;
+    recipient: SeniorRef;
+    recipient_host?: LaneRecord["host"];
+    blocked_since: string;
+    at: string;
+    hours: number;
+    blocked_reason: string;
+    message_id: string;
+    text: string;
+}
 export interface ReconcileSummary {
     ok: boolean;
     action: "reconcile";
@@ -57,6 +71,7 @@ export interface ReconcileSummary {
         id: string;
         reason: KeepAliveBlockedReason;
     }>;
+    blocked_escalations: Array<Pick<BlockedLaneEscalationDelivery, "lane_id" | "recipient" | "blocked_since" | "at" | "hours" | "blocked_reason" | "message_id" | "text">>;
     errors: Array<{
         message: string;
         code?: string;
@@ -94,6 +109,10 @@ export interface ReconcileDeps {
     skipAdmissionWithoutCpuSample?: boolean;
     /** Flag reader seam used to assert rollout reads happen before admission locks. */
     readRegistryFlag?: typeof readLanesRegistryFlag;
+    /** Durable delivery seam for six-hour blocked-lane escalation. */
+    deliverBlockedEscalation?: (delivery: BlockedLaneEscalationDelivery) => Promise<void>;
+    /** Read a missing escalation ancestor from the authoritative hierarchy. */
+    resolveEscalationLane?: (laneId: string) => Promise<LaneRecord | null>;
     /** Active-company fallback for questions raised from an unscoped lane. */
     resolveQuestionActiveCompany?: () => Promise<LaneCompanyRef>;
     /** Resume queued messages after this pass wins a local dead-worker CAS. */