@indigoai-us/hq-cli 5.167.0 → 5.169.0

package/dist/lib/daemon/updater.js

@@ -3,56 +3,77 @@
  * replaces the boxes' `hq-cli-update.timer` and `*-codex-update.timer`:
  *
  * 1. Update the hq CLI through the shared self-update path (same install
- *    routing, lock and convergence check as every other CLI update).
- * 2. Update Codex when it is installed as a global npm package and behind.
+ *    routing, lock and convergence check as every other CLI update), when it
+ *    is a global install this process may replace.
+ * 2. Update the Claude, Codex and Grok CLIs the login user installed, each
+ *    through its own update route. A copy this user cannot write (root's
+ *    under /usr) is reported and left alone.
  * 3. After a CLI update, ask the daemon to restart itself so the supervisor and
- *    every service run the new version.
+ *    every service run the new version. The remote-control hosts notice an
+ *    updated Claude or Codex on disk themselves and restart once idle.
  */
 import { spawnSync } from "node:child_process";
-import semver from "semver";
-export const CODEX_PACKAGE = "@openai/codex";
+import * as fs from "node:fs";
+import { locateTool, toolUpdateCommand } from "./tools.js";
 export async function runDaemonUpdater(deps) {
     let ok = true;
-    const cli = await deps.updateCli();
     // The restart stops this process too, so it is requested only once all the
-    // updater's work (including a global npm install of Codex) is done.
+    // updater's work (every tool install) is done.
     let restart = false;
-    switch (cli.action) {
-        case "updated":
-            deps.log(`hq CLI updated to ${cli.latest ?? "the latest version"}; the daemon restarts onto it once Codex is checked`);
-            restart = true;
-            break;
-        case "update-failed":
-        case "update-ineffective":
-            deps.log(`hq CLI update to ${cli.latest ?? "latest"} did not take effect (${cli.action})`);
+    if (deps.updateCli === null) {
+        deps.log("hq CLI: not a global install, so it is updated with the project or app that owns it");
+    }
+    else {
+        const cli = await deps.updateCli();
+        switch (cli.action) {
+            case "updated":
+                deps.log(`hq CLI updated to ${cli.latest ?? "the latest version"}; the daemon restarts onto it once the tools are checked`);
+                restart = true;
+                break;
+            case "update-failed":
+            case "update-ineffective":
+                deps.log(`hq CLI update to ${cli.latest ?? "latest"} did not take effect (${cli.action})`);
+                ok = false;
+                break;
+            default:
+                deps.log(`hq CLI: ${cli.action === "current" ? "up to date" : cli.action}`);
+        }
+    }
+    const updated = [];
+    for (const tool of deps.tools) {
+        const outcome = updateTool(tool, deps.log);
+        if (outcome === "failed")
             ok = false;
-            break;
-        default:
-            deps.log(`hq CLI: ${cli.action === "current" ? "up to date" : cli.action}`);
+        if (outcome === "updated")
+            updated.push(tool.name);
     }
-    if (!updateCodex(deps))
-        ok = false;
     if (restart)
         deps.requestDaemonRestart();
-    return { ok };
+    return { ok, updated };
 }
-/** Update Codex when it is a global npm install and behind; false when that update failed. */
-function updateCodex(deps) {
-    const installed = deps.codex.installedVersion();
-    if (installed === null)
-        return true;
-    const latest = deps.codex.latestVersion();
-    if (latest === null || !semver.valid(installed) || !semver.valid(latest) || !semver.gt(latest, installed)) {
-        deps.log(`Codex ${installed}: nothing to update`);
-        return true;
+function updateTool(tool, log) {
+    const before = tool.locate();
+    if (!before) {
+        log(`${tool.name}: not installed`);
+        return "skipped";
+    }
+    if (!before.writable) {
+        log(`${tool.name} at ${before.path} belongs to another account, so it is not updated as this user`);
+        return "skipped";
+    }
+    const result = tool.update(before);
+    if (!result.ok) {
+        log(`${tool.name} update failed: ${result.detail ?? "unknown error"}`);
+        return "failed";
     }
-    const result = deps.codex.install();
-    if (result.ok) {
-        deps.log(`Codex updated ${installed} -> ${latest}`);
-        return true;
+    const after = tool.locate();
+    const from = before.version ?? "unknown version";
+    if (after?.version && after.version !== before.version) {
+        log(`${tool.name} updated ${from} -> ${after.version}`);
+        return "updated";
     }
-    deps.log(`Codex update ${installed} -> ${latest} failed: ${result.detail ?? "unknown error"}`);
-    return false;
+    log(`${tool.name} ${from}: up to date`);
+    return "current";
 }
 /**
  * The variables for the updater's own CLI update. Every supervised service
@@ -64,39 +85,55 @@ export function updaterEnv(vars) {
     delete copy.HQ_NO_UPDATE_CHECK;
     return copy;
 }
-function npm(args) {
-    const r = spawnSync(process.platform === "win32" ? "npm.cmd" : "npm", args, {
-        encoding: "utf8",
-        timeout: 10 * 60_000,
-        windowsHide: true,
-        shell: process.platform === "win32",
-    });
-    return { status: r.status, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
-}
-/** Codex through the global npm install, the way the boxes install it. */
-export function npmCodexUpdater() {
+function hostProbe(env, home) {
     return {
-        installedVersion: () => {
-            const r = npm(["ls", "-g", CODEX_PACKAGE, "--depth=0", "--json"]);
+        home,
+        env,
+        exists: (p) => {
             try {
-                const parsed = JSON.parse(r.stdout);
-                return parsed.dependencies?.[CODEX_PACKAGE]?.version ?? null;
+                fs.accessSync(p, fs.constants.X_OK);
+                return true;
             }
             catch {
-                return null;
+                return false;
             }
         },
-        latestVersion: () => {
-            const r = npm(["view", CODEX_PACKAGE, "version"]);
-            const v = r.status === 0 ? r.stdout.trim() : "";
-            return v || null;
+        realpath: (p) => fs.realpathSync(p),
+        writable: (dir) => {
+            try {
+                fs.accessSync(dir, fs.constants.W_OK);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        version: (bin) => {
+            const r = spawnSync(bin, ["--version"], { encoding: "utf8", env, timeout: 30_000, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+            return { status: r.status, stdout: r.stdout ?? "" };
         },
-        install: () => {
-            const r = npm(["install", "-g", `${CODEX_PACKAGE}@latest`]);
+    };
+}
+/** The real updater for one tool, run as this (the login) user. */
+export function hostToolUpdater(name, env, home) {
+    const probe = hostProbe(env, home);
+    return {
+        name,
+        locate: () => locateTool(name, probe),
+        update: (install) => {
+            const cmd = toolUpdateCommand(name, install);
+            const r = spawnSync(cmd.file, cmd.args, {
+                encoding: "utf8",
+                env: { ...env, ...cmd.env },
+                timeout: 10 * 60_000,
+                stdio: ["ignore", "pipe", "pipe"],
+                windowsHide: true,
+                shell: process.platform === "win32" && cmd.file === "npm",
+            });
             if (r.status === 0)
                 return { ok: true };
-            const tail = r.stderr.trim().split("\n").slice(-3).join(" ").slice(0, 400);
-            return { ok: false, detail: tail || `npm exited ${r.status ?? "by signal"}` };
+            const tail = `${r.stderr ?? ""}\n${r.stdout ?? ""}`.trim().split("\n").slice(-3).join(" ").slice(0, 400);
+            return { ok: false, detail: tail || (r.error ? r.error.message : `${cmd.file} exited ${r.status ?? "by signal"}`) };
         },
     };
 }

package/dist/lib/lanes/mesh-events.d.ts

@@ -42,6 +42,7 @@
  * of opening a browser nobody is watching, and the watcher records
  * `mesh_event_failed` and moves on. No credential file is read here.
  */
+import { LanesError } from "./errors.js";
 import type { LaneCompanyRef, LaneEnvelope, LaneRecord, TerminalLaneState } from "./types.js";
 export declare const LANE_MESH_EVENTS: readonly ["lane_started", "lane_progress", "lane_question", "lane_question_at_user", "lane_ask", "lane_blocked", "lane_done", "lane_failed", "lane_interrupted", "lane_cancelled", "lane_killed"];
 export type LaneMeshEvent = (typeof LANE_MESH_EVENTS)[number];
@@ -73,6 +74,8 @@ export interface LaneMesh {
     ensureLaneThread?: (company: LaneCompanyRef, lane: LaneRecord, laneStatus?: string, signal?: AbortSignal) => Promise<string>;
     appendThreadEvent: (company: LaneCompanyRef, threadId: string, event: LaneMeshEvent, payload: Record<string, unknown>, signal?: AbortSignal) => Promise<void>;
     patchStoryStatus: (company: LaneCompanyRef, projectId: string, storyId: string, status: string) => Promise<void>;
+    /** Read-only Board membership check before a command writes lane state. */
+    assertProjectStoriesOnBoard?: (company: LaneCompanyRef, projectId: string, storyIds: readonly string[]) => Promise<void>;
 }
 export interface CreateLaneMeshOptions {
     /** False for detached callers (the watcher). See the token note above. */
@@ -88,6 +91,7 @@ export interface CreateLaneMeshOptions {
         status: string;
     }) => Promise<void>;
 }
+export declare function storyNotOnBoardError(company: LaneCompanyRef, projectId: string, storyId: string): LanesError;
 export declare function createLaneMesh(opts?: CreateLaneMeshOptions): LaneMesh;
 /** Resolve the explicit mesh attribution before falling back to the lane tenant. */
 export declare function laneMeshCompany(lane: Pick<LaneRecord, "company" | "mesh_company">): LaneCompanyRef | undefined;

package/dist/lib/lanes/mesh-events.js

@@ -220,6 +220,31 @@ function isProjectViewNotFound(error) {
     return (candidate.code === "PROJECT_VIEW_NOT_FOUND" ||
         (typeof candidate.message === "string" && candidate.message.includes("PROJECT_VIEW_NOT_FOUND")));
 }
+function isUnknownProjectStory(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const candidate = error;
+    return (candidate.status === 400 &&
+        candidate.code === "PROJECT_VIEW_INVALID" &&
+        typeof candidate.message === "string" &&
+        candidate.message.includes("Unknown story"));
+}
+function shellQuote(value) {
+    return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+export function storyNotOnBoardError(company, projectId, storyId) {
+    const command = "hq mesh project ensure " + shellQuote(projectId) +
+        " --company " + shellQuote(company.slug) +
+        " --stories-file '<prd.json>'";
+    const message = "Story " + JSON.stringify(storyId) + " is not on the Work Mesh Board for project " +
+        JSON.stringify(projectId) + ". Add it to the project PRD, then run: " + command;
+    return new LanesError("story_not_on_board", message, {
+        message,
+        project_id: projectId,
+        story_id: storyId,
+        command,
+    });
+}
 function isAlreadyRegistered(error) {
     if (!error || typeof error !== "object")
         return false;
@@ -293,18 +318,61 @@ export function createLaneMesh(opts = {}) {
                 senior: { kind: lane.senior.kind, id: lane.senior.id },
                 laneVersion: lane.version,
             };
-            const ensured = await ensureLaneMeshThread(tok, resolved, lane.project_id, descriptor, isMeshLaneStatus(laneStatus) ? laneStatus : "running", signal);
-            return ensured.threadId;
+            try {
+                const ensured = await ensureLaneMeshThread(tok, resolved, lane.project_id, descriptor, isMeshLaneStatus(laneStatus) ? laneStatus : "running", signal);
+                return ensured.threadId;
+            }
+            catch (error) {
+                if (lane.story_id && isUnknownProjectStory(error)) {
+                    throw storyNotOnBoardError(company, lane.project_id, lane.story_id);
+                }
+                throw error;
+            }
         },
         async appendThreadEvent(company, threadId, event, payload, signal) {
             const wire = toWireThreadEvent(event, payload);
             const tok = await token();
             await appendThreadEvent(tok, company.uid, threadId, wire.eventKind, wire.payload, signal);
         },
+        async assertProjectStoriesOnBoard(company, projectId, storyIds) {
+            if (storyIds.length === 0)
+                return;
+            const tok = await token();
+            let view;
+            try {
+                view = await getProjectView(tok, company.uid, projectId);
+            }
+            catch (error) {
+                // A missing Board has a separate, established repair path in
+                // patchStoryStatus. Keep it available; an existing Board is strict.
+                if (isProjectViewNotFound(error))
+                    return;
+                throw error;
+            }
+            if (view.companyUid !== company.uid || view.projectId !== projectId) {
+                throw new LanesError("project_board_scope_mismatch", "Work Mesh returned a Board for a different company or project", { project_id: projectId });
+            }
+            for (const storyId of storyIds) {
+                if (!view.stories.some((story) => story.id === storyId)) {
+                    throw storyNotOnBoardError(company, projectId, storyId);
+                }
+            }
+        },
         async patchStoryStatus(company, projectId, storyId, status) {
             const tok = await token();
+            const patch = async () => {
+                try {
+                    await patchStoryStatus(tok, company.uid, projectId, storyId, status);
+                }
+                catch (error) {
+                    if (isUnknownProjectStory(error)) {
+                        throw storyNotOnBoardError(company, projectId, storyId);
+                    }
+                    throw error;
+                }
+            };
             try {
-                await patchStoryStatus(tok, company.uid, projectId, storyId, status);
+                await patch();
             }
             catch (error) {
                 if (!isProjectViewNotFound(error))
@@ -316,7 +384,7 @@ export function createLaneMesh(opts = {}) {
                     storyId,
                     status,
                 });
-                await patchStoryStatus(tok, company.uid, projectId, storyId, status);
+                await patch();
             }
         },
     };

package/dist/lib/lanes/outpost-pruner-install.d.ts

@@ -0,0 +1,37 @@
+export declare const OUTPOST_PRUNER_PRESSURE_SERVICE = "hq-outpost-worktree-pruner-pressure.service";
+export declare const OUTPOST_PRUNER_PRESSURE_TIMER = "hq-outpost-worktree-pruner-pressure.timer";
+export declare const OUTPOST_PRUNER_DAILY_SERVICE = "hq-outpost-worktree-pruner-daily.service";
+export declare const OUTPOST_PRUNER_DAILY_TIMER = "hq-outpost-worktree-pruner-daily.timer";
+export declare const OUTPOST_PRUNER_MIN_AGE_DAYS = 14;
+export interface OutpostPrunerInstallOptions {
+    systemdRoot: string;
+    hqRoot: string;
+    nodeBinary?: string;
+    hqBinary?: string;
+    home?: string;
+    flagApiUrl?: string;
+    companyUid?: string;
+    enable?: boolean;
+    runCommand?: (command: string, args: string[]) => {
+        status: number;
+        stdout?: string;
+        stderr?: string;
+    };
+}
+export interface OutpostPrunerInstallResult {
+    ok: true;
+    action: "outpost-pruner.install" | "outpost-pruner.uninstall";
+    systemd_root: string;
+    units: string[];
+    written?: boolean;
+    enabled?: boolean;
+    removed?: boolean;
+}
+export declare function renderOutpostPrunerPressureTimer(): string;
+export declare function renderOutpostPrunerDailyTimer(): string;
+export declare function defaultOutpostPrunerSystemdDir(home?: string): string;
+export declare function installOutpostPrunerTimers(options: OutpostPrunerInstallOptions): OutpostPrunerInstallResult;
+export declare function uninstallOutpostPrunerTimers(options: Pick<OutpostPrunerInstallOptions, "systemdRoot" | "runCommand"> & {
+    disable?: boolean;
+}): OutpostPrunerInstallResult;
+//# sourceMappingURL=outpost-pruner-install.d.ts.map

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

@@ -0,0 +1,226 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { resolveHqBinary, resolveNodeBinary } from "../mesh/live/daemon/install.js";
+import { SYSTEMD_PATH_ENV } from "../service-manager/systemd.js";
+export const OUTPOST_PRUNER_PRESSURE_SERVICE = "hq-outpost-worktree-pruner-pressure.service";
+export const OUTPOST_PRUNER_PRESSURE_TIMER = "hq-outpost-worktree-pruner-pressure.timer";
+export const OUTPOST_PRUNER_DAILY_SERVICE = "hq-outpost-worktree-pruner-daily.service";
+export const OUTPOST_PRUNER_DAILY_TIMER = "hq-outpost-worktree-pruner-daily.timer";
+export const OUTPOST_PRUNER_MIN_AGE_DAYS = 14;
+function shellQuote(value) {
+    return /^[A-Za-z0-9_./:-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function systemdEnvironment(name, value) {
+    if (/[\r\n\0]/.test(value))
+        throw new TypeError(`${name} contains a line break or NUL`);
+    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%");
+    return `Environment="${name}=${escaped}"`;
+}
+function writeIfChanged(filePath, contents) {
+    try {
+        if (fs.readFileSync(filePath, "utf8") === contents)
+            return false;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== "ENOENT")
+            throw err;
+    }
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        fs.writeFileSync(temporary, contents, { encoding: "utf8", mode: 0o644 });
+        fs.renameSync(temporary, filePath);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch (unlinkError) {
+            if (unlinkError.code !== "ENOENT") {
+                process.stderr.write(`outpost pruner install: temporary unit cleanup failed (${unlinkError.code ?? "Error"})\n`);
+            }
+        }
+        throw err;
+    }
+    return true;
+}
+function unlinkIfExists(filePath) {
+    try {
+        fs.unlinkSync(filePath);
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return false;
+        throw err;
+    }
+}
+function runSystemctl(args, run) {
+    const result = run("systemctl", args);
+    if (result.status !== 0)
+        throw new Error(`systemctl ${args.join(" ")} failed (${result.status})`);
+}
+function pnpmBinaryDirs() {
+    const resolved = [];
+    for (const directory of (process.env.PATH ?? "").split(path.delimiter).filter(Boolean)) {
+        const binary = path.join(directory, "pnpm");
+        try {
+            fs.accessSync(binary, fs.constants.X_OK);
+            for (const candidate of [path.resolve(directory), path.dirname(fs.realpathSync(binary))]) {
+                if (!resolved.includes(candidate))
+                    resolved.push(candidate);
+            }
+            break;
+        }
+        catch {
+            // Keep looking. The full interactive-shell PATH is not copied into units.
+        }
+    }
+    return resolved;
+}
+function unitPathEnv(hqBinary, nodeBinary) {
+    const dirs = [
+        ...pnpmBinaryDirs(),
+        path.dirname(path.resolve(hqBinary)),
+        path.dirname(path.resolve(nodeBinary)),
+        ...SYSTEMD_PATH_ENV.split(":"),
+    ];
+    return [...new Set(dirs)].filter(Boolean).join(":");
+}
+function renderService(opts) {
+    const command = [
+        opts.nodeBinary,
+        opts.hqBinary,
+        "lanes",
+        "outpost-pruner",
+        "run",
+        "--trigger",
+        opts.trigger,
+        "--min-age-days",
+        String(OUTPOST_PRUNER_MIN_AGE_DAYS),
+    ].map(shellQuote).join(" ");
+    return `[Unit]
+Description=HQ outpost worktree pruning (${opts.trigger})
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+ExecStart=${command}
+WorkingDirectory=${shellQuote(opts.hqRoot)}
+Nice=10
+Environment=HOME=${shellQuote(opts.home)}
+Environment=PATH=${shellQuote(opts.pathEnv)}
+Environment=HQ_ROOT=${shellQuote(opts.hqRoot)}
+Environment=HQ_NO_UPDATE_CHECK=1
+${opts.flagEnvironment}
+KillMode=process
+
+[Install]
+WantedBy=default.target
+`;
+}
+export function renderOutpostPrunerPressureTimer() {
+    return `[Unit]
+Description=Check HQ outpost disk pressure for safe worktree cleanup
+
+[Timer]
+OnBootSec=2min
+OnUnitActiveSec=5min
+AccuracySec=30s
+Persistent=true
+Unit=${OUTPOST_PRUNER_PRESSURE_SERVICE}
+
+[Install]
+WantedBy=timers.target
+`;
+}
+export function renderOutpostPrunerDailyTimer() {
+    return `[Unit]
+Description=Daily HQ outpost safe worktree cleanup
+
+[Timer]
+OnCalendar=*-*-* 03:10:00
+RandomizedDelaySec=10min
+AccuracySec=1min
+Persistent=true
+Unit=${OUTPOST_PRUNER_DAILY_SERVICE}
+
+[Install]
+WantedBy=timers.target
+`;
+}
+export function defaultOutpostPrunerSystemdDir(home = os.homedir()) {
+    return path.join(home, ".config", "systemd", "user");
+}
+export function installOutpostPrunerTimers(options) {
+    const nodeBinary = options.nodeBinary ?? resolveNodeBinary();
+    const hqBinary = options.hqBinary ?? resolveHqBinary();
+    const home = options.home ?? os.homedir();
+    const flagApiUrl = (options.flagApiUrl ?? process.env.HQ_FLAGS_API_URL ?? "").trim();
+    const companyUid = (options.companyUid ?? process.env.HQ_COMPANY_UID ?? "").trim();
+    if (!flagApiUrl || !companyUid) {
+        throw new TypeError("install requires HQ_FLAGS_API_URL and HQ_COMPANY_UID for the timer services");
+    }
+    const flagEnvironment = [
+        systemdEnvironment("HQ_FLAGS_API_URL", flagApiUrl),
+        systemdEnvironment("HQ_COMPANY_UID", companyUid),
+    ].join("\n");
+    const pathEnv = unitPathEnv(hqBinary, nodeBinary);
+    const units = [
+        [OUTPOST_PRUNER_PRESSURE_SERVICE, renderService({ trigger: "pressure", nodeBinary, hqBinary, hqRoot: options.hqRoot, home, pathEnv, flagEnvironment })],
+        [OUTPOST_PRUNER_PRESSURE_TIMER, renderOutpostPrunerPressureTimer()],
+        [OUTPOST_PRUNER_DAILY_SERVICE, renderService({ trigger: "daily", nodeBinary, hqBinary, hqRoot: options.hqRoot, home, pathEnv, flagEnvironment })],
+        [OUTPOST_PRUNER_DAILY_TIMER, renderOutpostPrunerDailyTimer()],
+    ];
+    let written = false;
+    for (const [name, contents] of units) {
+        written = writeIfChanged(path.join(options.systemdRoot, name), contents) || written;
+    }
+    let enabled = false;
+    if (options.enable) {
+        if (!options.runCommand)
+            throw new Error("--enable needs a systemctl runner");
+        runSystemctl(["--user", "daemon-reload"], options.runCommand);
+        runSystemctl(["--user", "enable", "--now", OUTPOST_PRUNER_PRESSURE_TIMER, OUTPOST_PRUNER_DAILY_TIMER], options.runCommand);
+        enabled = true;
+    }
+    return {
+        ok: true,
+        action: "outpost-pruner.install",
+        systemd_root: options.systemdRoot,
+        units: units.map(([name]) => path.join(options.systemdRoot, name)),
+        written,
+        enabled,
+    };
+}
+export function uninstallOutpostPrunerTimers(options) {
+    if (options.disable) {
+        if (!options.runCommand)
+            throw new Error("--disable needs a systemctl runner");
+        runSystemctl(["--user", "disable", "--now", OUTPOST_PRUNER_PRESSURE_TIMER, OUTPOST_PRUNER_DAILY_TIMER], options.runCommand);
+    }
+    const units = [
+        OUTPOST_PRUNER_PRESSURE_SERVICE,
+        OUTPOST_PRUNER_PRESSURE_TIMER,
+        OUTPOST_PRUNER_DAILY_SERVICE,
+        OUTPOST_PRUNER_DAILY_TIMER,
+    ];
+    let removed = false;
+    for (const name of units) {
+        removed = unlinkIfExists(path.join(options.systemdRoot, name)) || removed;
+    }
+    if (options.disable && options.runCommand)
+        runSystemctl(["--user", "daemon-reload"], options.runCommand);
+    return {
+        ok: true,
+        action: "outpost-pruner.uninstall",
+        systemd_root: options.systemdRoot,
+        units: units.map((name) => path.join(options.systemdRoot, name)),
+        removed,
+    };
+}
+//# sourceMappingURL=outpost-pruner-install.js.map

package/dist/lib/lanes/outpost-worktree-pruner-flag.d.ts

@@ -0,0 +1,19 @@
+import { createFlagClient } from "@indigoai-us/hq-flags-client";
+export declare const OUTPOST_WORKTREE_PRUNER_FLAG = "outpost.worktree-pruner";
+export declare const OUTPOST_WORKTREE_PRUNER_FLAG_FALLBACK = false;
+export declare const OUTPOST_WORKTREE_PRUNER_FLAG_TIMEOUT_MS = 5000;
+export interface OutpostPrunerFlagClient {
+    ready(): Promise<void>;
+    isEnabled(flagKey: string, options?: {
+        fallback?: boolean;
+    }): boolean;
+    close(): void;
+}
+export interface OutpostPrunerFlagDependencies {
+    env?: NodeJS.ProcessEnv;
+    createClient?: typeof createFlagClient;
+    getToken?: () => string | Promise<string>;
+    reportFailure?: (error: unknown) => void;
+}
+export declare function outpostWorktreePrunerEnabled(dependencies?: OutpostPrunerFlagDependencies): Promise<boolean>;
+//# sourceMappingURL=outpost-worktree-pruner-flag.d.ts.map