@indigoai-us/hq-cli 5.314.0 → 5.316.0

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

@@ -0,0 +1,1201 @@
+/** 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