@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

package/dist/lib/lanes/outpost-worktree-pruner.js

@@ -1,1201 +0,0 @@
-/** Safe, host-local cleanup for terminal HQ worktrees on outposts. */
-import { spawnSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-const PRESSURE_THRESHOLD_PERCENT = 78;
-const DEFAULT_MIN_AGE_DAYS = 14;
-const LIVE_STATES = new Set(["running", "queued", "blocked", "awaiting_input", "waiting", "live"]);
-const TERMINAL_STATES = new Set(["done", "failed", "interrupted", "cancelled", "killed", "ended", "lost", "idle"]);
-const REFERENCE_KEYS = /^(cwd|working[_-]?directory|worktree(?:[_-]?path)?|repository[_-]?path|repo[_-]?path)$/i;
-const METADATA_NAMES = new Set(["spawn.json", "session.json", "metadata.json", "state.json"]);
-const THREAD_RECORD_NAME = /^T-[A-Za-z0-9._-]+\.json$/;
-const WORKER_LOG_READ_CHUNK_BYTES = 64 * 1024;
-const WORKER_LOG_CARRY_BYTES = 8 * 1024;
-function command(binary, args, timeoutMs = 15_000) {
-    const result = spawnSync(binary, args, {
-        encoding: "utf8",
-        timeout: timeoutMs,
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    if (result.error || result.status === null) {
-        return { status: -1, stdout: "", stderr: "" };
-    }
-    return {
-        status: result.status,
-        stdout: result.stdout ?? "",
-        stderr: result.stderr ?? "",
-    };
-}
-function git(repo, args, timeoutMs = 15_000) {
-    return command("git", ["-C", repo, ...args], timeoutMs);
-}
-function gitReadOnly(repo, args, timeoutMs = 15_000) {
-    const result = spawnSync("git", ["-C", repo, ...args], {
-        encoding: "utf8",
-        timeout: timeoutMs,
-        stdio: ["ignore", "pipe", "pipe"],
-        env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
-    });
-    if (result.error || result.status === null)
-        return { status: -1, stdout: "", stderr: "" };
-    return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
-}
-function isWithin(parent, child) {
-    const relative = path.relative(parent, child);
-    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
-}
-function safeRealpath(value) {
-    try {
-        return fs.realpathSync(value);
-    }
-    catch {
-        return null;
-    }
-}
-function isPathReferenceKey(key) {
-    return REFERENCE_KEYS.test(key);
-}
-function collectReferences(value, hqRoot, out = []) {
-    if (!value || typeof value !== "object")
-        return out;
-    if (Array.isArray(value)) {
-        for (const child of value)
-            collectReferences(child, hqRoot, out);
-        return out;
-    }
-    for (const [key, child] of Object.entries(value)) {
-        if (isPathReferenceKey(key) && typeof child === "string" && child.trim()) {
-            const raw = child.trim();
-            out.push(path.resolve(path.isAbsolute(raw) ? raw : path.join(hqRoot, raw)));
-        }
-        else {
-            collectReferences(child, hqRoot, out);
-        }
-    }
-    return out;
-}
-function objectState(value) {
-    for (const key of ["state", "status", "liveness_state", "livenessState", "lifecycle_state"]) {
-        const state = value[key];
-        if (typeof state === "string")
-            return state.toLowerCase();
-    }
-    return undefined;
-}
-function isLogPathDelimiter(value) {
-    return /[\s"'\\;&|<>)\]} ,]/.test(value);
-}
-function worktreePathsInLogWindow(text, hqRoot, worktrees, out, atEof) {
-    const absolutePrefix = `${path.resolve(hqRoot, "workspace", "worktrees")}${path.sep}`;
-    const prefixes = [
-        { value: absolutePrefix, absolute: true },
-        { value: "workspace/worktrees/", absolute: false },
-        { value: "./workspace/worktrees/", absolute: false },
-    ];
-    for (const prefix of prefixes) {
-        let offset = 0;
-        while (offset < text.length) {
-            const start = text.indexOf(prefix.value, offset);
-            if (start < 0)
-                break;
-            offset = start + prefix.value.length;
-            if (!prefix.absolute && start > 0 && /[A-Za-z0-9_./-]/.test(text[start - 1]))
-                continue;
-            let end = offset;
-            while (end < text.length && !isLogPathDelimiter(text[end]))
-                end += 1;
-            if (end === text.length && !atEof)
-                continue;
-            const rawPath = text.slice(start, end);
-            const resolved = path.resolve(path.isAbsolute(rawPath) ? rawPath : path.join(hqRoot, rawPath));
-            for (const worktree of worktrees) {
-                if (isWithin(worktree.path, resolved))
-                    out.add(worktree.path);
-            }
-        }
-    }
-}
-function scanPathLogFile(filePath, hqRoot, worktrees) {
-    let fileStat;
-    try {
-        fileStat = fs.lstatSync(filePath);
-    }
-    catch (err) {
-        return err.code === "ENOENT"
-            ? { status: "missing", worktrees: [] }
-            : { status: "failed", worktrees: [] };
-    }
-    if (!fileStat.isFile() || fileStat.isSymbolicLink())
-        return { status: "failed", worktrees: [] };
-    let fd;
-    try {
-        fd = fs.openSync(filePath, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
-    }
-    catch {
-        return { status: "failed", worktrees: [] };
-    }
-    const referencedWorktrees = new Set();
-    let bytesRead = 0;
-    let tail = Buffer.alloc(0);
-    let status;
-    try {
-        const openedStat = fs.fstatSync(fd);
-        if (!openedStat.isFile() || openedStat.dev !== fileStat.dev || openedStat.ino !== fileStat.ino || openedStat.size !== fileStat.size) {
-            return { status: "failed", worktrees: [] };
-        }
-        const chunk = Buffer.allocUnsafe(WORKER_LOG_READ_CHUNK_BYTES);
-        while (true) {
-            const count = fs.readSync(fd, chunk, 0, chunk.length, bytesRead);
-            if (count === 0)
-                break;
-            bytesRead += count;
-            const window = Buffer.concat([tail, chunk.subarray(0, count)]);
-            worktreePathsInLogWindow(window.toString("utf8"), hqRoot, worktrees, referencedWorktrees, false);
-            tail = Buffer.from(window.subarray(Math.max(0, window.length - WORKER_LOG_CARRY_BYTES)));
-        }
-        const finalStat = fs.fstatSync(fd);
-        let pathStat;
-        try {
-            pathStat = fs.lstatSync(filePath);
-        }
-        catch {
-            return { status: "failed", worktrees: [] };
-        }
-        if (!pathStat || pathStat.isSymbolicLink() || finalStat.dev !== openedStat.dev || finalStat.ino !== openedStat.ino ||
-            finalStat.size !== bytesRead || finalStat.mtimeMs !== openedStat.mtimeMs ||
-            pathStat.dev !== finalStat.dev || pathStat.ino !== finalStat.ino || pathStat.size !== finalStat.size || pathStat.mtimeMs !== finalStat.mtimeMs) {
-            return { status: "failed", worktrees: [] };
-        }
-        worktreePathsInLogWindow(tail.toString("utf8"), hqRoot, worktrees, referencedWorktrees, true);
-        status = bytesRead === 0 ? "empty" : "read";
-    }
-    catch {
-        status = "failed";
-    }
-    finally {
-        try {
-            fs.closeSync(fd);
-        }
-        catch {
-            status = "failed";
-        }
-    }
-    return { status, worktrees: [...referencedWorktrees] };
-}
-function validLaneId(laneId) {
-    return Boolean(laneId) && laneId !== "." && laneId !== ".." && !laneId.includes("/") && !laneId.includes("\\");
-}
-function scanWorkerOutLog(hqRoot, laneId, worktrees) {
-    if (!validLaneId(laneId))
-        return { status: "failed", worktrees: [] };
-    const runRoot = path.join(hqRoot, "workspace", "lanes-runs");
-    const runDir = path.join(runRoot, laneId);
-    const logsDir = path.join(runDir, "logs");
-    const workerOut = path.join(logsDir, "worker.out");
-    try {
-        if (!isWithin(runRoot, runDir) || path.dirname(runDir) !== runRoot)
-            return { status: "failed", worktrees: [] };
-        const runStat = fs.lstatSync(runDir);
-        if (!runStat.isDirectory() || runStat.isSymbolicLink())
-            return { status: "failed", worktrees: [] };
-        const logsStat = fs.lstatSync(logsDir);
-        if (!logsStat.isDirectory() || logsStat.isSymbolicLink())
-            return { status: "failed", worktrees: [] };
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return { status: "no_logs_dir", worktrees: [] };
-        return { status: "failed", worktrees: [] };
-    }
-    const scan = scanPathLogFile(workerOut, hqRoot, worktrees);
-    if (scan.status === "missing")
-        return { status: "missing_worker_out", worktrees: [] };
-    return { status: scan.status, worktrees: scan.worktrees };
-}
-function scanClaudeTranscript(sessionId, hqRoot, worktrees) {
-    if (!sessionId || sessionId === "." || sessionId === ".." || /[/\\\0]/.test(sessionId)) {
-        return { status: "failed", worktrees: [] };
-    }
-    const home = path.resolve(process.env.HOME?.trim() || os.homedir());
-    try {
-        const homeStat = fs.lstatSync(home);
-        if (!homeStat.isDirectory() || homeStat.isSymbolicLink())
-            return { status: "failed", worktrees: [] };
-    }
-    catch {
-        return { status: "failed", worktrees: [] };
-    }
-    let homeEntries;
-    try {
-        homeEntries = fs.readdirSync(home, { withFileTypes: true });
-    }
-    catch {
-        return { status: "failed", worktrees: [] };
-    }
-    const transcripts = [];
-    let failed = false;
-    for (const claudeEntry of homeEntries) {
-        if (!claudeEntry.name.startsWith(".claude"))
-            continue;
-        if (claudeEntry.isSymbolicLink()) {
-            failed = true;
-            continue;
-        }
-        if (!claudeEntry.isDirectory())
-            continue;
-        const projectsDir = path.join(home, claudeEntry.name, "projects");
-        let projectsStat;
-        try {
-            projectsStat = fs.lstatSync(projectsDir);
-        }
-        catch (err) {
-            if (err.code !== "ENOENT")
-                failed = true;
-            continue;
-        }
-        if (!projectsStat.isDirectory() || projectsStat.isSymbolicLink()) {
-            failed = true;
-            continue;
-        }
-        let projectEntries;
-        try {
-            projectEntries = fs.readdirSync(projectsDir, { withFileTypes: true });
-        }
-        catch (err) {
-            if (err.code !== "ENOENT")
-                failed = true;
-            continue;
-        }
-        for (const projectEntry of projectEntries) {
-            if (projectEntry.isSymbolicLink()) {
-                failed = true;
-                continue;
-            }
-            if (!projectEntry.isDirectory())
-                continue;
-            const transcriptPath = path.join(projectsDir, projectEntry.name, `${sessionId}.jsonl`);
-            let transcriptStat;
-            try {
-                transcriptStat = fs.lstatSync(transcriptPath);
-            }
-            catch (err) {
-                if (err.code !== "ENOENT")
-                    failed = true;
-                continue;
-            }
-            if (!transcriptStat.isFile() || transcriptStat.isSymbolicLink()) {
-                failed = true;
-                continue;
-            }
-            if (!isWithin(home, transcriptPath)) {
-                failed = true;
-                continue;
-            }
-            transcripts.push(transcriptPath);
-        }
-    }
-    if (failed)
-        return { status: "failed", worktrees: [] };
-    if (transcripts.length === 0)
-        return { status: "missing", worktrees: [] };
-    const referenced = new Set();
-    for (const transcript of transcripts) {
-        const scan = scanPathLogFile(transcript, hqRoot, worktrees);
-        if (scan.status !== "read" && scan.status !== "empty")
-            return { status: "failed", worktrees: [] };
-        for (const worktree of scan.worktrees)
-            referenced.add(worktree);
-    }
-    return { status: "read", worktrees: [...referenced] };
-}
-function hasSpawnRecord(hqRoot, laneId) {
-    if (!validLaneId(laneId))
-        return null;
-    try {
-        fs.lstatSync(path.join(hqRoot, "workspace", "lanes-runs", laneId, "spawn.json"));
-        return true;
-    }
-    catch (err) {
-        const code = err.code;
-        return code === "ENOENT" ? false : null;
-    }
-}
-function createdAtMillis(value) {
-    if (typeof value !== "string" || value.trim() === "")
-        return null;
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : null;
-}
-function noteLiveLane(record, laneId, state, liveLaneIds, liveLaneStates, liveLaneProviders, liveLaneCreatedAt, liveLaneSessionIds, laneHasProviderSession) {
-    liveLaneIds.add(laneId);
-    if (!liveLaneStates.has(laneId))
-        liveLaneStates.set(laneId, state);
-    if (!liveLaneProviders.has(laneId) && typeof record.provider === "string") {
-        liveLaneProviders.set(laneId, record.provider.toLowerCase());
-    }
-    if (!liveLaneCreatedAt.has(laneId))
-        liveLaneCreatedAt.set(laneId, createdAtMillis(record.created_at));
-    if (!liveLaneSessionIds.has(laneId)) {
-        const providerSessionId = record.provider_session_id;
-        if (providerSessionId !== null && providerSessionId !== undefined &&
-            !(typeof providerSessionId === "string" && providerSessionId.trim() === "")) {
-            laneHasProviderSession.add(laneId);
-            liveLaneSessionIds.set(laneId, typeof providerSessionId === "string" ? providerSessionId.trim() : null);
-        }
-        else {
-            liveLaneSessionIds.set(laneId, null);
-        }
-    }
-    else {
-        const providerSessionId = record.provider_session_id;
-        if (providerSessionId !== null && providerSessionId !== undefined &&
-            !(typeof providerSessionId === "string" && providerSessionId.trim() === "")) {
-            if (!laneHasProviderSession.has(laneId) && typeof providerSessionId === "string") {
-                liveLaneSessionIds.set(laneId, providerSessionId.trim());
-            }
-            laneHasProviderSession.add(laneId);
-        }
-    }
-}
-function scanMetadataDirectory(root, hqRoot, liveLaneIds, terminalLaneIds, liveLaneStates, liveLaneProviders, liveLaneCreatedAt, liveLaneSessionIds, laneHasProviderSession, unresolvedAnonymousLiveLaneStartedAt, references) {
-    let complete = true;
-    const visit = (dir) => {
-        let entries;
-        try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
-        }
-        catch (err) {
-            const code = err.code;
-            if (code === "ENOENT")
-                return;
-            complete = false;
-            return;
-        }
-        for (const entry of entries) {
-            if (entry.isSymbolicLink())
-                continue;
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                visit(fullPath);
-                continue;
-            }
-            if (!entry.isFile() || (!METADATA_NAMES.has(entry.name) && !THREAD_RECORD_NAME.test(entry.name)))
-                continue;
-            // Checkpoint threads have cwd references but no lifecycle state; unknown state is retained below.
-            let parsed;
-            try {
-                parsed = JSON.parse(fs.readFileSync(fullPath, "utf8"));
-            }
-            catch (err) {
-                const code = err.code;
-                if (code !== "ENOENT")
-                    complete = false;
-                continue;
-            }
-            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-                continue;
-            const record = parsed;
-            const laneId = typeof record.lane_id === "string" ? record.lane_id : undefined;
-            const state = objectState(record);
-            const laneKnownTerminal = laneId !== undefined && terminalLaneIds.has(laneId);
-            const laneKnownLive = laneId !== undefined && liveLaneIds.has(laneId);
-            const stateLive = state !== undefined && LIVE_STATES.has(state);
-            const stateTerminal = state !== undefined && TERMINAL_STATES.has(state);
-            const stateUnknown = state === undefined;
-            const recordReferences = collectReferences(record, hqRoot);
-            if (stateLive && laneId) {
-                noteLiveLane(record, laneId, state, liveLaneIds, liveLaneStates, liveLaneProviders, liveLaneCreatedAt, liveLaneSessionIds, laneHasProviderSession);
-            }
-            if (stateLive && !laneId && recordReferences.length === 0) {
-                unresolvedAnonymousLiveLaneStartedAt.push(createdAtMillis(record.created_at));
-            }
-            const live = stateLive || laneKnownLive || (!laneKnownTerminal && !stateTerminal && stateUnknown);
-            for (const reference of recordReferences) {
-                references.push({ path: reference, laneId, live });
-            }
-        }
-    };
-    visit(root);
-    return complete;
-}
-function scanLaneReferences(hqRoot, worktrees) {
-    const references = [];
-    const liveLaneIds = new Set();
-    const liveLaneStates = new Map();
-    const liveLaneProviders = new Map();
-    const liveLaneCreatedAt = new Map();
-    const liveLaneSessionIds = new Map();
-    const laneHasProviderSession = new Set();
-    const unresolvedLiveLaneStartedAt = [];
-    const terminalLaneIds = new Set();
-    const laneDir = path.join(hqRoot, "workspace", "lanes", "lanes");
-    let complete = true;
-    let entries = [];
-    try {
-        entries = fs.readdirSync(laneDir, { withFileTypes: true });
-    }
-    catch (err) {
-        const code = err.code;
-        if (code !== "ENOENT")
-            complete = false;
-    }
-    for (const entry of entries) {
-        if (!entry.isFile() || entry.isSymbolicLink() || !entry.name.endsWith(".json"))
-            continue;
-        const fullPath = path.join(laneDir, entry.name);
-        let parsed;
-        try {
-            parsed = JSON.parse(fs.readFileSync(fullPath, "utf8"));
-        }
-        catch (err) {
-            if (err.code !== "ENOENT")
-                complete = false;
-            continue;
-        }
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-            complete = false;
-            continue;
-        }
-        const record = parsed;
-        const laneId = typeof record.lane_id === "string" ? record.lane_id : undefined;
-        const state = typeof record.state === "string" ? record.state.toLowerCase() : "";
-        const live = LIVE_STATES.has(state);
-        const terminal = TERMINAL_STATES.has(state);
-        if (laneId && live) {
-            noteLiveLane(record, laneId, state, liveLaneIds, liveLaneStates, liveLaneProviders, liveLaneCreatedAt, liveLaneSessionIds, laneHasProviderSession);
-        }
-        if (laneId && terminal)
-            terminalLaneIds.add(laneId);
-        const recordReferences = collectReferences(record, hqRoot);
-        if (live && !laneId && recordReferences.length === 0) {
-            unresolvedLiveLaneStartedAt.push(createdAtMillis(record.created_at));
-        }
-        for (const reference of recordReferences) {
-            references.push({ path: reference, laneId, live });
-        }
-    }
-    for (const relative of [path.join("workspace", "lanes-runs"), path.join("workspace", "threads")]) {
-        complete = scanMetadataDirectory(path.join(hqRoot, relative), hqRoot, liveLaneIds, terminalLaneIds, liveLaneStates, liveLaneProviders, liveLaneCreatedAt, liveLaneSessionIds, laneHasProviderSession, unresolvedLiveLaneStartedAt, references) && complete;
-    }
-    for (const laneId of liveLaneIds) {
-        const log = scanWorkerOutLog(hqRoot, laneId, worktrees);
-        for (const worktree of log.worktrees) {
-            references.push({ path: worktree, laneId, live: true, reason: "referenced_by_live_lane_log" });
-        }
-        if (log.status === "failed") {
-            unresolvedLiveLaneStartedAt.push(liveLaneCreatedAt.get(laneId) ?? null);
-            continue;
-        }
-        const provider = liveLaneProviders.get(laneId);
-        const sessionId = liveLaneSessionIds.get(laneId);
-        if (provider === "claude" && laneHasProviderSession.has(laneId)) {
-            if (!sessionId) {
-                unresolvedLiveLaneStartedAt.push(liveLaneCreatedAt.get(laneId) ?? null);
-                continue;
-            }
-            const transcript = scanClaudeTranscript(sessionId, hqRoot, worktrees);
-            for (const worktree of transcript.worktrees) {
-                references.push({ path: worktree, laneId, live: true, reason: "referenced_by_live_lane_log" });
-            }
-            if (transcript.status === "read")
-                continue;
-            unresolvedLiveLaneStartedAt.push(liveLaneCreatedAt.get(laneId) ?? null);
-            continue;
-        }
-        if (log.status === "read")
-            continue;
-        const spawnRecord = hasSpawnRecord(hqRoot, laneId);
-        const neverSpawnedQueuedLane = liveLaneStates.get(laneId) === "queued" &&
-            !laneHasProviderSession.has(laneId) && spawnRecord === false;
-        if ((log.status === "empty" || log.status === "no_logs_dir") && neverSpawnedQueuedLane)
-            continue;
-        unresolvedLiveLaneStartedAt.push(liveLaneCreatedAt.get(laneId) ?? null);
-    }
-    return { references, complete, unresolvedLiveLaneStartedAt };
-}
-function currentProcessUserId() {
-    return typeof process.getuid === "function" ? process.getuid() : null;
-}
-const defaultProcessPathReader = {
-    readdirSync: (entryPath) => fs.readdirSync(entryPath),
-    readlinkSync: (entryPath) => fs.readlinkSync(entryPath),
-    uid: (entryPath) => fs.statSync(entryPath).uid,
-    readFileSync: (entryPath) => fs.readFileSync(entryPath, "utf8"),
-};
-function readProcFile(reader, procRoot, pid, name) {
-    if (!reader.readFileSync)
-        return null;
-    try {
-        return reader.readFileSync(path.join(procRoot, pid, name));
-    }
-    catch {
-        // Missing or unreadable identity metadata disables the exception.
-        return null;
-    }
-}
-function procStatusIdentity(contents) {
-    if (contents === null)
-        return null;
-    const value = (name) => {
-        const prefix = `${name}:`;
-        const line = contents.split(/\r?\n/).find((entry) => entry.startsWith(prefix));
-        return line?.slice(prefix.length).trim() || null;
-    };
-    const numeric = (name) => {
-        const raw = value(name);
-        if (!raw)
-            return null;
-        const parsed = Number(raw.split(/\s+/)[0]);
-        return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
-    };
-    const name = value("Name");
-    const pid = numeric("Pid");
-    const parentPid = numeric("PPid");
-    const uid = numeric("Uid");
-    if (name === null || pid === null || parentPid === null || uid === null)
-        return null;
-    return { name, pid, parentPid, uid };
-}
-/**
- * `sd-pam` is systemd's non-dumpable PAM-session helper. Its cwd link can return
- * EACCES to its own UID, so require the exact proc identity and user-manager
- * ancestry before treating that one cwd as harmless.
- */
-function isSystemdUserSdPamProcess(procRoot, pid, currentUid, ownerUid, reader) {
-    if (currentUid === null || ownerUid !== currentUid)
-        return false;
-    const helper = procStatusIdentity(readProcFile(reader, procRoot, pid, "status"));
-    if (!helper || helper.name !== "(sd-pam)" || helper.pid !== Number(pid) || helper.uid !== currentUid ||
-        readProcFile(reader, procRoot, pid, "comm")?.trim() !== "(sd-pam)")
-        return false;
-    const managerPid = String(helper.parentPid);
-    const manager = procStatusIdentity(readProcFile(reader, procRoot, managerPid, "status"));
-    if (!manager || manager.name !== "systemd" || manager.pid !== helper.parentPid || manager.parentPid !== 1 ||
-        manager.uid !== currentUid || readProcFile(reader, procRoot, managerPid, "comm")?.trim() !== "systemd")
-        return false;
-    const init = procStatusIdentity(readProcFile(reader, procRoot, "1", "status"));
-    if (!init || init.name !== "systemd" || init.pid !== 1 || init.parentPid !== 0 || init.uid !== 0 ||
-        readProcFile(reader, procRoot, "1", "comm")?.trim() !== "systemd")
-        return false;
-    try {
-        return reader.uid(path.join(procRoot, managerPid)) === currentUid && reader.uid(path.join(procRoot, "1")) === 0;
-    }
-    catch {
-        // A vanished or inaccessible parent does not prove the helper identity.
-        return false;
-    }
-}
-function scanProcessPaths(procRoot, childName, currentUid = currentProcessUserId(), reader = defaultProcessPathReader) {
-    const paths = [];
-    let entries;
-    try {
-        entries = reader.readdirSync(procRoot);
-    }
-    catch {
-        return { paths, complete: false };
-    }
-    let complete = true;
-    for (const pid of entries) {
-        if (!/^\d+$/.test(pid))
-            continue;
-        const processDirectory = path.join(procRoot, pid);
-        let ownerUid;
-        try {
-            ownerUid = reader.uid(processDirectory);
-        }
-        catch (err) {
-            const code = err.code;
-            if (code !== "ENOENT" && code !== "ESRCH")
-                complete = false;
-            continue;
-        }
-        const base = path.join(processDirectory, childName);
-        // Foreign UID access stays ignorable; same-UID EACCES is excepted only for a verified sd-pam cwd below.
-        let descriptors;
-        if (childName === "fd") {
-            try {
-                descriptors = reader.readdirSync(base);
-            }
-            catch (err) {
-                const code = err.code;
-                if (code !== "ENOENT" && code !== "ESRCH" &&
-                    !(code === "EACCES" && currentUid !== null && ownerUid !== currentUid))
-                    complete = false;
-                continue;
-            }
-        }
-        else {
-            descriptors = [""];
-        }
-        for (const descriptor of descriptors) {
-            const entryPath = descriptor ? path.join(base, descriptor) : base;
-            try {
-                const target = reader.readlinkSync(entryPath);
-                if (path.isAbsolute(target))
-                    paths.push(path.resolve(target));
-            }
-            catch (err) {
-                const code = err.code;
-                const inaccessibleForeign = code === "EACCES" && currentUid !== null && ownerUid !== currentUid;
-                const knownSystemdCwd = code === "EACCES" && childName === "cwd" &&
-                    isSystemdUserSdPamProcess(procRoot, pid, currentUid, ownerUid, reader);
-                if (code !== "ENOENT" && code !== "ESRCH" && !inaccessibleForeign && !knownSystemdCwd)
-                    complete = false;
-            }
-        }
-    }
-    return { paths, complete };
-}
-function newestModificationTime(root) {
-    let newest = 0;
-    const visit = (entryPath) => {
-        const stat = fs.lstatSync(entryPath);
-        newest = Math.max(newest, stat.mtimeMs);
-        if (!stat.isDirectory())
-            return;
-        for (const child of fs.readdirSync(entryPath))
-            visit(path.join(entryPath, child));
-    };
-    visit(root);
-    return newest;
-}
-function newestLaneGuardModificationTime(candidate) {
-    const rootStat = (() => {
-        try {
-            return fs.lstatSync(candidate.path);
-        }
-        catch {
-            return null;
-        }
-    })();
-    if (!rootStat || !rootStat.isDirectory() || rootStat.isSymbolicLink())
-        return null;
-    const gitDirResult = git(candidate.path, ["rev-parse", "--absolute-git-dir"]);
-    if (gitDirResult.status !== 0)
-        return null;
-    const rawGitDir = gitDirResult.stdout.trim();
-    if (!rawGitDir || !path.isAbsolute(rawGitDir))
-        return null;
-    const gitDir = path.resolve(rawGitDir);
-    let newest = rootStat.mtimeMs;
-    for (const name of ["index", "HEAD"]) {
-        let stat;
-        try {
-            stat = fs.lstatSync(path.join(gitDir, name));
-        }
-        catch {
-            return null;
-        }
-        if (!stat.isFile() || stat.isSymbolicLink())
-            return null;
-        newest = Math.max(newest, stat.mtimeMs);
-    }
-    return newest;
-}
-function parseWorktreeList(stdout) {
-    const result = [];
-    for (const block of stdout.split(/\n\n+/)) {
-        let worktreePath = null;
-        let branch = null;
-        let head = null;
-        let detached = false;
-        for (const line of block.split("\n")) {
-            if (line.startsWith("worktree "))
-                worktreePath = line.slice("worktree ".length);
-            else if (line.startsWith("branch "))
-                branch = line.slice("branch ".length).replace(/^refs\/heads\//, "");
-            else if (line.startsWith("HEAD "))
-                head = line.slice("HEAD ".length);
-            else if (line === "detached")
-                detached = true;
-        }
-        if (worktreePath)
-            result.push({ path: worktreePath, branch, head, detached });
-    }
-    return result;
-}
-function discoverCandidates(hqRoot) {
-    const workspaceRoot = path.join(hqRoot, "workspace", "worktrees");
-    const reposRoot = path.join(hqRoot, "repos");
-    const candidates = [];
-    if (!fs.existsSync(workspaceRoot))
-        return candidates;
-    for (const repoEntry of fs.readdirSync(workspaceRoot, { withFileTypes: true })) {
-        if (!repoEntry.isDirectory() || repoEntry.isSymbolicLink())
-            continue;
-        const repoWorktrees = path.join(workspaceRoot, repoEntry.name);
-        for (const worktreeEntry of fs.readdirSync(repoWorktrees, { withFileTypes: true })) {
-            if (!worktreeEntry.isDirectory() || worktreeEntry.isSymbolicLink())
-                continue;
-            const candidatePath = path.join(repoWorktrees, worktreeEntry.name);
-            if (!fs.existsSync(path.join(candidatePath, ".git")))
-                continue;
-            const top = git(candidatePath, ["rev-parse", "--show-toplevel"]);
-            const common = git(candidatePath, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
-            if (top.status !== 0 || common.status !== 0)
-                continue;
-            const canonicalCandidate = safeRealpath(top.stdout.trim());
-            const canonicalPath = safeRealpath(candidatePath);
-            const commonDir = safeRealpath(common.stdout.trim());
-            if (!canonicalCandidate || !canonicalPath || !commonDir || canonicalCandidate !== canonicalPath)
-                continue;
-            const repo = path.dirname(commonDir);
-            const canonicalRepo = safeRealpath(repo);
-            const canonicalReposRoot = safeRealpath(reposRoot);
-            if (!canonicalRepo || !canonicalReposRoot || !isWithin(canonicalReposRoot, canonicalRepo))
-                continue;
-            const listing = git(canonicalRepo, ["worktree", "list", "--porcelain"]);
-            if (listing.status !== 0)
-                continue;
-            const registered = parseWorktreeList(listing.stdout).find((worktree) => safeRealpath(worktree.path) === canonicalCandidate);
-            if (!registered?.head)
-                continue;
-            candidates.push({ path: canonicalCandidate, repo: canonicalRepo, branch: registered.branch, head: registered.head, detached: registered.detached });
-        }
-    }
-    return candidates;
-}
-function advertisedDefaultBranch(repo) {
-    const remoteHead = git(repo, ["ls-remote", "--symref", "origin", "HEAD"], 10_000);
-    if (remoteHead.status !== 0)
-        return null;
-    const lines = remoteHead.stdout.split(/\r?\n/);
-    const refLine = lines.find((line) => line.startsWith("ref: refs/heads/") && line.endsWith("\tHEAD"));
-    const hashLine = lines.find((line) => /^[0-9a-f]{40,64}\tHEAD$/.test(line));
-    if (!refLine || !hashLine)
-        return null;
-    const ref = refLine.slice("ref: ".length).split("\t", 1)[0];
-    if (!ref || git(repo, ["check-ref-format", ref]).status !== 0)
-        return null;
-    return { ref, hash: hashLine.split("\t", 1)[0] };
-}
-function defaultRemoteBranch(repo) {
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-        const advertised = advertisedDefaultBranch(repo);
-        if (!advertised)
-            return null;
-        const branchName = advertised.ref.slice("refs/heads/".length);
-        const trackingRef = `refs/remotes/origin/${branchName}`;
-        const fetched = git(repo, ["fetch", "--no-tags", "origin", `+${advertised.ref}:${trackingRef}`], 30_000);
-        if (fetched.status !== 0)
-            return null;
-        const local = git(repo, ["rev-parse", "--verify", `${trackingRef}^{commit}`]);
-        if (local.status !== 0)
-            return null;
-        const current = advertisedDefaultBranch(repo);
-        if (!current)
-            return null;
-        if (current.ref === advertised.ref && current.hash === local.stdout.trim()) {
-            return { remote: "origin", ref: local.stdout.trim() };
-        }
-    }
-    return null;
-}
-function remoteBranchConfig(repo, branch) {
-    const remote = git(repo, ["config", "--get", `branch.${branch}.remote`]);
-    const mergeRef = git(repo, ["config", "--get", `branch.${branch}.merge`]);
-    if (remote.status !== 0 || mergeRef.status !== 0)
-        return null;
-    const name = remote.stdout.trim();
-    const merge = mergeRef.stdout.trim();
-    if (!name || name === "." || !merge.startsWith("refs/heads/"))
-        return null;
-    return { remote: name, mergeRef: merge };
-}
-function hasNoUnpushedCommits(candidate, remote) {
-    const result = git(candidate.repo, ["rev-list", "--count", candidate.head, "--not", `--remotes=${remote}`]);
-    return result.status === 0 && result.stdout.trim() === "0";
-}
-function isAncestor(repo, head, base) {
-    const result = git(repo, ["merge-base", "--is-ancestor", head, base]);
-    return result.status === 0;
-}
-function remoteBranchExists(repo, remote, mergeRef) {
-    const branchName = mergeRef.replace(/^refs\/heads\//, "");
-    const result = git(repo, ["ls-remote", "--heads", remote, `refs/heads/${branchName}`], 10_000);
-    if (result.status !== 0)
-        return null;
-    return result.stdout.trim().length > 0;
-}
-function eligibilityReason(candidate, defaultBranches) {
-    const status = gitReadOnly(candidate.path, ["status", "--porcelain=v1", "--untracked-files=all"]);
-    if (status.status !== 0)
-        return "worktree_status_unavailable";
-    if (status.stdout.trim())
-        return "worktree_not_clean";
-    if (!defaultBranches.has(candidate.repo))
-        defaultBranches.set(candidate.repo, defaultRemoteBranch(candidate.repo));
-    const defaultBranch = defaultBranches.get(candidate.repo) ?? null;
-    if (!defaultBranch)
-        return "default_remote_branch_unavailable";
-    if (candidate.detached) {
-        return isAncestor(candidate.repo, candidate.head, defaultBranch.ref) ? null : "detached_commit_not_on_default";
-    }
-    if (!candidate.branch)
-        return "branch_unavailable";
-    if (isAncestor(candidate.repo, candidate.head, defaultBranch.ref))
-        return null;
-    const upstream = remoteBranchConfig(candidate.repo, candidate.branch);
-    if (!upstream)
-        return "upstream_unavailable";
-    if (!hasNoUnpushedCommits(candidate, upstream.remote))
-        return "unpushed_commits";
-    const exists = remoteBranchExists(candidate.repo, upstream.remote, upstream.mergeRef);
-    if (exists === null)
-        return "remote_branch_status_unverified";
-    if (!exists)
-        return null;
-    return "branch_not_merged_or_deleted";
-}
-function refreshCandidate(candidate) {
-    const head = git(candidate.path, ["rev-parse", "--verify", "HEAD"]);
-    const branch = git(candidate.path, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
-    if (head.status !== 0)
-        return null;
-    return {
-        ...candidate,
-        head: head.stdout.trim(),
-        branch: branch.status === 0 ? branch.stdout.trim().replace(/^refs\/heads\//, "") : null,
-        detached: branch.status !== 0,
-    };
-}
-function liveReferenceReason(candidate, liveness, processCwds, processFiles) {
-    if (!liveness.complete)
-        return "lane_session_scan_incomplete";
-    if (!processCwds.complete)
-        return "process_cwd_scan_incomplete";
-    for (const reference of liveness.references) {
-        if (!reference.live)
-            continue;
-        const refPath = safeRealpath(reference.path) ?? path.resolve(reference.path);
-        if (isWithin(candidate.path, refPath))
-            return reference.reason ?? "referenced_by_live_lane";
-    }
-    for (const processCwd of processCwds.paths) {
-        if (isWithin(candidate.path, processCwd))
-            return "process_cwd_under_worktree";
-    }
-    if (!processFiles.complete)
-        return "process_fd_scan_incomplete";
-    for (const processFile of processFiles.paths) {
-        if (isWithin(candidate.path, processFile))
-            return "process_holds_worktree_file_open";
-    }
-    if (liveness.unresolvedLiveLaneStartedAt.length > 0) {
-        if (liveness.unresolvedLiveLaneStartedAt.some((createdAt) => createdAt === null)) {
-            return "live_lane_worktree_unresolved";
-        }
-        const newest = newestLaneGuardModificationTime(candidate);
-        if (newest === null || liveness.unresolvedLiveLaneStartedAt.some((createdAt) => createdAt !== null && newest >= createdAt)) {
-            return "live_lane_worktree_unresolved";
-        }
-    }
-    return null;
-}
-function pnpmStorePath() {
-    const result = command("pnpm", ["store", "path"], 10_000);
-    if (result.status !== 0)
-        return null;
-    const value = result.stdout.trim().split(/\r?\n/).at(-1)?.trim();
-    return value ? path.resolve(value) : null;
-}
-function allowedUserStore(storePath) {
-    const home = path.resolve(process.env.HOME?.trim() || os.homedir());
-    const xdgCache = path.resolve(process.env.XDG_CACHE_HOME?.trim() || path.join(home, ".cache"));
-    const xdgData = path.resolve(process.env.XDG_DATA_HOME?.trim() || path.join(home, ".local", "share"));
-    const allowedRoots = [
-        xdgCache,
-        path.join(home, ".cache"),
-        path.join(xdgData, "pnpm", "store"),
-    ].map((candidate) => safeRealpath(candidate)).filter((value) => value !== null);
-    const canonicalStore = safeRealpath(storePath);
-    return canonicalStore !== null && allowedRoots.some((root) => isWithin(root, canonicalStore));
-}
-function prunePackageStore(procRoot) {
-    const store = pnpmStorePath();
-    if (!store)
-        return { attempted: false, reason: "pnpm_store_path_unavailable" };
-    if (!allowedUserStore(store))
-        return { attempted: false, reason: "pnpm_store_outside_user_cache" };
-    const openFiles = scanProcessPaths(procRoot, "fd");
-    if (!openFiles.complete)
-        return { attempted: false, reason: "process_fd_scan_incomplete" };
-    const canonicalStore = safeRealpath(store);
-    if (!canonicalStore)
-        return { attempted: false, reason: "pnpm_store_path_unavailable" };
-    if (openFiles.paths.some((openPath) => isWithin(canonicalStore, openPath))) {
-        return { attempted: false, reason: "process_holds_pnpm_store_open" };
-    }
-    const result = command("pnpm", ["store", "prune"], 120_000);
-    return result.status === 0
-        ? { attempted: true }
-        : { attempted: true, reason: "pnpm_store_prune_failed" };
-}
-function diskUsedPercent(hqRoot) {
-    try {
-        const stats = fs.statfsSync(hqRoot);
-        if (stats.blocks <= 0)
-            return null;
-        const used = stats.blocks - stats.bfree;
-        return Math.round((used / stats.blocks) * 1000) / 10;
-    }
-    catch {
-        return null;
-    }
-}
-function availableBytes(root) {
-    try {
-        const stats = fs.statfsSync(root);
-        return stats.bavail * stats.bsize;
-    }
-    catch {
-        return null;
-    }
-}
-function acquireRunLock(hqRoot) {
-    const workspace = path.join(hqRoot, "workspace");
-    const lockPath = path.join(workspace, ".outpost-worktree-pruner.lock");
-    fs.mkdirSync(workspace, { recursive: true });
-    const openLock = () => {
-        let fd;
-        try {
-            fd = fs.openSync(lockPath, "wx", 0o600);
-        }
-        catch (err) {
-            const code = err.code;
-            if (code === "EEXIST")
-                return null;
-            throw err;
-        }
-        try {
-            fs.writeSync(fd, `${process.pid}\n`);
-            return { path: lockPath, fd };
-        }
-        catch (err) {
-            let closeError;
-            let unlinkError;
-            try {
-                fs.closeSync(fd);
-            }
-            catch (error) {
-                closeError = error;
-            }
-            try {
-                fs.unlinkSync(lockPath);
-            }
-            catch (error) {
-                if (error.code !== "ENOENT")
-                    unlinkError = error;
-            }
-            if (closeError || unlinkError) {
-                throw new AggregateError([err, ...(closeError ? [closeError] : []), ...(unlinkError ? [unlinkError] : [])], "pruner lock setup failed and cleanup was incomplete");
-            }
-            throw err;
-        }
-    };
-    const lock = openLock();
-    if (lock)
-        return lock;
-    let ownerPid;
-    try {
-        const rawPid = fs.readFileSync(lockPath, "utf8").trim();
-        ownerPid = Number(rawPid);
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return openLock();
-        throw err;
-    }
-    if (!Number.isSafeInteger(ownerPid) || ownerPid <= 0 || ownerPid === process.pid)
-        return null;
-    try {
-        process.kill(ownerPid, 0);
-        return null;
-    }
-    catch (err) {
-        if (err.code !== "ESRCH")
-            return null;
-    }
-    try {
-        fs.unlinkSync(lockPath);
-    }
-    catch (err) {
-        if (err.code !== "ENOENT")
-            return null;
-    }
-    return openLock();
-}
-function releaseRunLock(lock) {
-    fs.closeSync(lock.fd);
-    try {
-        fs.unlinkSync(lock.path);
-    }
-    catch (err) {
-        if (err.code !== "ENOENT")
-            throw err;
-    }
-}
-function emptyResult(options, skipped, pressurePercent) {
-    return {
-        event: "outpost.worktree_pruner.run",
-        trigger: options.trigger,
-        dry_run: options.dryRun,
-        feature_enabled: options.featureEnabled,
-        skipped,
-        ...(pressurePercent === undefined ? {} : { pressure_percent: pressurePercent }),
-        min_age_days: options.minAgeDays,
-        candidates: [],
-        removed: [],
-        kept: [],
-        bytes_freed: 0,
-        bytes_freed_basis: "statfs_available_byte_delta",
-        package_store: { attempted: false, reason: "not_run" },
-    };
-}
-/**
- * Prune only registered worktrees beneath workspace/worktrees after every
- * local, git, age, and liveness check has passed. The function never shells
- * out to rm and never follows symlinks while estimating or checking age.
- */
-export function runOutpostWorktreePruner(options) {
-    const hqRoot = path.resolve(options.hqRoot);
-    const minAgeDays = options.minAgeDays ?? DEFAULT_MIN_AGE_DAYS;
-    if (!Number.isFinite(minAgeDays) || minAgeDays < 1 || minAgeDays > 365) {
-        throw new RangeError("minAgeDays must be between 1 and 365");
-    }
-    if (!options.dryRun && !options.featureEnabled) {
-        return emptyResult({ ...options, minAgeDays }, "feature_flag_off");
-    }
-    let pressurePercent;
-    if (options.trigger === "pressure" && !options.dryRun) {
-        const measuredPressure = (options.readDiskUsedPercent ?? diskUsedPercent)(hqRoot);
-        if (measuredPressure === null)
-            return emptyResult({ ...options, minAgeDays }, "disk_pressure_unavailable");
-        if (measuredPressure < PRESSURE_THRESHOLD_PERCENT) {
-            return emptyResult({ ...options, minAgeDays }, "below_pressure_line", measuredPressure);
-        }
-        pressurePercent = measuredPressure;
-    }
-    const runLock = acquireRunLock(hqRoot);
-    if (!runLock)
-        return emptyResult({ ...options, minAgeDays }, "already_running", pressurePercent ?? undefined);
-    try {
-        const result = {
-            event: "outpost.worktree_pruner.run",
-            trigger: options.trigger,
-            dry_run: options.dryRun,
-            feature_enabled: options.featureEnabled,
-            ...(pressurePercent === undefined ? {} : { pressure_percent: pressurePercent }),
-            min_age_days: minAgeDays,
-            candidates: [],
-            removed: [],
-            kept: [],
-            bytes_freed: 0,
-            bytes_freed_basis: "statfs_available_byte_delta",
-            package_store: { attempted: false, reason: options.dryRun ? "dry_run" : "not_run" },
-        };
-        const worktrees = discoverCandidates(hqRoot);
-        const liveness = scanLaneReferences(hqRoot, worktrees);
-        const procRoot = options.processRoot ?? "/proc";
-        const currentUid = options.processUserId ?? currentProcessUserId();
-        const processCwds = scanProcessPaths(procRoot, "cwd", currentUid, options.processPathReader);
-        const processFiles = scanProcessPaths(procRoot, "fd", currentUid, options.processPathReader);
-        const now = options.now ?? Date.now();
-        const minAgeMs = minAgeDays * 24 * 60 * 60 * 1000;
-        const defaultBranches = new Map();
-        for (const candidate of worktrees) {
-            const keep = (reason) => {
-                result.kept.push({ path: candidate.path, reason });
-            };
-            const liveReason = liveReferenceReason(candidate, liveness, processCwds, processFiles);
-            if (liveReason) {
-                keep(liveReason);
-                continue;
-            }
-            const reason = eligibilityReason(candidate, defaultBranches);
-            if (reason) {
-                keep(reason);
-                continue;
-            }
-            let newestMtime;
-            try {
-                newestMtime = newestModificationTime(candidate.path);
-            }
-            catch {
-                keep("worktree_age_scan_failed");
-                continue;
-            }
-            if (now - newestMtime < minAgeMs) {
-                keep("worktree_too_recent");
-                continue;
-            }
-            result.candidates.push(candidate.path);
-            if (options.dryRun)
-                continue;
-            const freeBefore = availableBytes(hqRoot);
-            const secondLiveness = liveReferenceReason(candidate, scanLaneReferences(hqRoot, worktrees), scanProcessPaths(procRoot, "cwd", currentUid, options.processPathReader), scanProcessPaths(procRoot, "fd", currentUid, options.processPathReader));
-            if (secondLiveness) {
-                result.candidates.pop();
-                keep(secondLiveness);
-                continue;
-            }
-            let latestMtime;
-            try {
-                latestMtime = newestModificationTime(candidate.path);
-            }
-            catch {
-                result.candidates.pop();
-                keep("worktree_age_scan_failed");
-                continue;
-            }
-            if (now - latestMtime < minAgeMs) {
-                result.candidates.pop();
-                keep("worktree_too_recent");
-                continue;
-            }
-            const refreshed = refreshCandidate(candidate);
-            if (!refreshed) {
-                result.candidates.pop();
-                keep("worktree_head_unavailable");
-                continue;
-            }
-            const changedReason = eligibilityReason(refreshed, defaultBranches);
-            if (changedReason) {
-                result.candidates.pop();
-                keep(changedReason);
-                continue;
-            }
-            const removed = git(candidate.repo, ["worktree", "remove", candidate.path], 120_000);
-            if (removed.status !== 0) {
-                result.candidates.pop();
-                keep("git_worktree_remove_failed");
-                continue;
-            }
-            const pruned = git(candidate.repo, ["worktree", "prune"], 30_000);
-            const freeAfter = availableBytes(hqRoot);
-            const bytesFreed = freeBefore !== null && freeAfter !== null ? Math.max(0, freeAfter - freeBefore) : 0;
-            result.removed.push({ path: candidate.path, bytes_freed: bytesFreed });
-            result.bytes_freed += bytesFreed;
-            if (pruned.status !== 0)
-                result.kept.push({ path: candidate.repo, reason: "git_worktree_prune_failed" });
-        }
-        if (!options.dryRun) {
-            const storeSpaceBefore = availableBytes(hqRoot);
-            result.package_store = (options.runPackageStorePrune ?? (() => prunePackageStore(procRoot)))();
-            const storeSpaceAfter = availableBytes(hqRoot);
-            if (result.package_store.attempted && storeSpaceBefore !== null && storeSpaceAfter !== null) {
-                const storeBytesFreed = Math.max(0, storeSpaceAfter - storeSpaceBefore);
-                result.package_store.bytes_freed = storeBytesFreed;
-                result.bytes_freed += storeBytesFreed;
-            }
-        }
-        return result;
-    }
-    finally {
-        releaseRunLock(runLock);
-    }
-}
-export const OUTPOST_WORKTREE_PRUNER_DEFAULT_MIN_AGE_DAYS = DEFAULT_MIN_AGE_DAYS;
-export const OUTPOST_WORKTREE_PRUNER_PRESSURE_THRESHOLD_PERCENT = PRESSURE_THRESHOLD_PERCENT;
-//# sourceMappingURL=outpost-worktree-pruner.js.map