@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/lib/lanes/outpost-hire-cache.js

@@ -0,0 +1,153 @@
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS = 60_000;
+const CACHE_RELATIVE_PATH = path.join("workspace", "lanes-runs", ".cache", "outpost-hire-summaries.json");
+export function outpostHireSummaryCachePath(hqRoot) {
+    return path.join(hqRoot, CACHE_RELATIVE_PATH);
+}
+export function outpostHireSummaryCacheKey(outpostId, laneId) {
+    return JSON.stringify([outpostId, laneId]);
+}
+export function readOutpostHireSummaryCache(hqRoot, nowMs) {
+    return readCache(hqRoot, nowMs, false);
+}
+/** Reads the last validated summaries even after their freshness window expires. */
+export function readOutpostHireSummaryCacheIncludingStale(hqRoot, nowMs) {
+    return readCache(hqRoot, nowMs, true);
+}
+function readCache(hqRoot, nowMs, includeStale) {
+    const filePath = outpostHireSummaryCachePath(hqRoot);
+    let contents;
+    try {
+        contents = fs.readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        if (isMissingFile(err))
+            return new Map();
+        console.warn(`Ignoring unreadable Outpost hire summary cache at ${filePath}: ${errorText(err)}`);
+        return new Map();
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch (err) {
+        console.warn(`Ignoring malformed Outpost hire summary cache at ${filePath}: ${errorText(err)}`);
+        return new Map();
+    }
+    if (!Array.isArray(parsed)) {
+        console.warn(`Ignoring malformed Outpost hire summary cache at ${filePath}: expected an array`);
+        return new Map();
+    }
+    const entries = new Map();
+    const duplicates = new Set();
+    for (const value of parsed) {
+        const entry = parseCacheEntry(value, nowMs, includeStale);
+        if (!entry)
+            continue;
+        const key = outpostHireSummaryCacheKey(entry.outpost_id, entry.lane_id);
+        if (entries.has(key)) {
+            entries.delete(key);
+            duplicates.add(key);
+            continue;
+        }
+        if (!duplicates.has(key))
+            entries.set(key, entry);
+    }
+    return entries;
+}
+export function writeOutpostHireSummaryCache(hqRoot, updates, nowMs, existingEntries) {
+    if (updates.length === 0)
+        return;
+    const filePath = outpostHireSummaryCachePath(hqRoot);
+    const cached = new Map(existingEntries ?? readOutpostHireSummaryCache(hqRoot, nowMs));
+    for (const update of updates) {
+        const entry = {
+            outpost_id: update.outpost_id,
+            lane_id: update.lane_id,
+            hire_grant: update.hire_grant,
+            hire_alive_children: update.hire_alive_children,
+            hire: update.hire,
+            hire_summary: update.hire_summary,
+            cached_at: new Date(nowMs).toISOString(),
+        };
+        if (!parseCacheEntry(entry, nowMs))
+            continue;
+        cached.set(outpostHireSummaryCacheKey(entry.outpost_id, entry.lane_id), entry);
+    }
+    const directory = path.dirname(filePath);
+    let temporaryPath;
+    try {
+        fs.mkdirSync(directory, { recursive: true });
+        temporaryPath = path.join(directory, `.outpost-hire-summaries.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
+        fs.writeFileSync(temporaryPath, `${JSON.stringify([...cached.values()])}\n`, {
+            encoding: "utf8",
+            mode: 0o600,
+        });
+        fs.renameSync(temporaryPath, filePath);
+    }
+    catch (err) {
+        if (temporaryPath) {
+            try {
+                fs.unlinkSync(temporaryPath);
+            }
+            catch (cleanupErr) {
+                if (!isMissingFile(cleanupErr)) {
+                    console.warn(`Could not remove temporary Outpost hire summary cache ${temporaryPath}: ${errorText(cleanupErr)}`);
+                }
+            }
+        }
+        console.warn(`Could not write Outpost hire summary cache at ${filePath}: ${errorText(err)}`);
+    }
+}
+function parseCacheEntry(value, nowMs, includeStale = false) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const entry = value;
+    const allowedKeys = new Set([
+        "outpost_id",
+        "lane_id",
+        "hire_grant",
+        "hire_alive_children",
+        "hire",
+        "hire_summary",
+        "cached_at",
+    ]);
+    if (Object.keys(entry).length !== allowedKeys.size || Object.keys(entry).some((key) => !allowedKeys.has(key))) {
+        return undefined;
+    }
+    if (typeof entry.outpost_id !== "string" || !entry.outpost_id.trim() ||
+        typeof entry.lane_id !== "string" || !entry.lane_id.trim() ||
+        !Number.isSafeInteger(entry.hire_grant) || entry.hire_grant < 0 ||
+        !Number.isSafeInteger(entry.hire_alive_children) || entry.hire_alive_children < 0 ||
+        typeof entry.cached_at !== "string") {
+        return undefined;
+    }
+    const cachedAt = Date.parse(entry.cached_at);
+    if (!Number.isFinite(cachedAt) ||
+        cachedAt > nowMs ||
+        (!includeStale && nowMs - cachedAt > OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS)) {
+        return undefined;
+    }
+    const hire = `${entry.hire_alive_children}/${entry.hire_grant}`;
+    const hireSummary = `hire ${hire}`;
+    if (entry.hire !== hire || entry.hire_summary !== hireSummary)
+        return undefined;
+    return {
+        outpost_id: entry.outpost_id,
+        lane_id: entry.lane_id,
+        hire_grant: entry.hire_grant,
+        hire_alive_children: entry.hire_alive_children,
+        hire,
+        hire_summary: hireSummary,
+        cached_at: entry.cached_at,
+    };
+}
+function isMissingFile(err) {
+    return err !== null && typeof err === "object" && "code" in err && err.code === "ENOENT";
+}
+function errorText(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+//# sourceMappingURL=outpost-hire-cache.js.map

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

@@ -0,0 +1,33 @@
+export declare const OUTPOST_ID_MARKER_PATH = "/etc/outpost/outpost-id";
+export declare const OUTPOST_ID_MARKER_DIR = "/etc/outpost";
+export type OutpostIdentityValue = {
+    kind: "id";
+    id: string;
+} | {
+    kind: "unknown";
+} | {
+    kind: "not_outpost";
+};
+export interface OutpostIdentityMarkerStore {
+    read(): OutpostIdentityValue;
+    /** Return false if another writer already created the marker. */
+    createIfMissing(id: string): boolean;
+}
+export interface OutpostIdentityMarkerWriterOptions {
+    markerDir?: string;
+    markerPath?: string;
+    run?: (input: {
+        id: string;
+        markerDir: string;
+        markerPath: string;
+        script: string;
+    }) => {
+        status: number | null;
+        error?: Error;
+        stderr?: string;
+    };
+}
+export declare function validateOutpostIdentityId(id: string): void;
+export declare function backfillOutpostIdentityMarker(expectedId: string, store: OutpostIdentityMarkerStore): "created" | "unchanged";
+export declare function createOutpostIdentityMarkerIfMissing(id: string, options?: OutpostIdentityMarkerWriterOptions): boolean;
+//# sourceMappingURL=outpost-identity.d.ts.map

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

@@ -0,0 +1,59 @@
+import { spawnSync } from "node:child_process";
+import { LanesError } from "./errors.js";
+export const OUTPOST_ID_MARKER_PATH = "/etc/outpost/outpost-id";
+export const OUTPOST_ID_MARKER_DIR = "/etc/outpost";
+const SAFE_OUTPOST_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+export function validateOutpostIdentityId(id) {
+    if (id !== id.trim() || !SAFE_OUTPOST_ID.test(id)) {
+        throw new LanesError("outpost_identity_id_invalid", "Outpost identity must be a single-line id containing only letters, numbers, hyphens, or underscores", { value: id });
+    }
+}
+export function backfillOutpostIdentityMarker(expectedId, store) {
+    validateOutpostIdentityId(expectedId);
+    const current = store.read();
+    if (current.kind === "id") {
+        if (current.id !== expectedId) {
+            throw outpostIdentityMismatch(expectedId, current.id);
+        }
+        return "unchanged";
+    }
+    if (current.kind === "not_outpost") {
+        throw new LanesError("outpost_identity_not_host", `This host has no ${OUTPOST_ID_MARKER_DIR} directory; identity backfill only runs on an Outpost`, { expected_id: expectedId, marker_path: OUTPOST_ID_MARKER_PATH });
+    }
+    let created;
+    try {
+        created = store.createIfMissing(expectedId);
+    }
+    catch (err) {
+        const after = store.read();
+        if (after.kind === "id" && after.id === expectedId)
+            return "unchanged";
+        if (after.kind === "id")
+            throw outpostIdentityMismatch(expectedId, after.id);
+        throw new LanesError("outpost_identity_backfill_failed", `Could not write ${OUTPOST_ID_MARKER_PATH}: ${err instanceof Error ? err.message : String(err)}`, { expected_id: expectedId, marker_path: OUTPOST_ID_MARKER_PATH });
+    }
+    const after = store.read();
+    if (after.kind === "id") {
+        if (after.id !== expectedId)
+            throw outpostIdentityMismatch(expectedId, after.id);
+        return created ? "created" : "unchanged";
+    }
+    throw new LanesError("outpost_identity_backfill_failed", `Backfill did not create ${OUTPOST_ID_MARKER_PATH} with expected value ${expectedId}`, { expected_id: expectedId, marker_path: OUTPOST_ID_MARKER_PATH });
+}
+export function createOutpostIdentityMarkerIfMissing(id, options = {}) {
+    validateOutpostIdentityId(id);
+    const markerDir = options.markerDir ?? OUTPOST_ID_MARKER_DIR;
+    const markerPath = options.markerPath ?? OUTPOST_ID_MARKER_PATH;
+    const script = `umask 022; install -d -m 0755 "$2" && set -C && printf '%s\\n' "$1" > "$3"`;
+    const result = options.run?.({ id, markerDir, markerPath, script }) ?? spawnSync("sudo", ["-n", "sh", "-c", script, "hq-outpost-identity", id, markerDir, markerPath], { encoding: "utf8" });
+    if (result.error) {
+        throw new LanesError("outpost_identity_backfill_failed", `Could not run sudo to write ${OUTPOST_ID_MARKER_PATH}: ${result.error.message}`, { expected_id: id, marker_path: OUTPOST_ID_MARKER_PATH });
+    }
+    if (result.status === 0)
+        return true;
+    return false;
+}
+function outpostIdentityMismatch(expectedId, actualId) {
+    return new LanesError("outpost_identity_mismatch", `Refusing to replace ${OUTPOST_ID_MARKER_PATH}: it contains ${actualId}, expected ${expectedId}`, { expected_id: expectedId, actual_id: actualId, marker_path: OUTPOST_ID_MARKER_PATH });
+}
+//# sourceMappingURL=outpost-identity.js.map

package/dist/lib/lanes/outpost-profile-repin.d.ts

@@ -0,0 +1,17 @@
+import { type SeniorRef } from "./types.js";
+declare const PROFILE_REPIN_CONTEXT_SCHEMA: "hq-lane-profile-repin-context.v1";
+export interface OutpostProfileRepinContext {
+    schema_version: typeof PROFILE_REPIN_CONTEXT_SCHEMA;
+    lane_id: string;
+    expected_senior: SeniorRef;
+    actor: string;
+    reason: "resume --worker";
+}
+export declare function createOutpostProfileRepinContext(input: {
+    laneId: string;
+    expectedSenior: SeniorRef;
+    actor: string;
+}): string;
+export declare function parseOutpostProfileRepinContext(encoded: string, expectedLaneId: string): OutpostProfileRepinContext;
+export {};
+//# sourceMappingURL=outpost-profile-repin.d.ts.map

package/dist/lib/lanes/outpost-profile-repin.js

@@ -0,0 +1,84 @@
+import { LanesError } from "./errors.js";
+import { isSeniorKind } from "./types.js";
+const PROFILE_REPIN_CONTEXT_SCHEMA = "hq-lane-profile-repin-context.v1";
+const MAX_CONTEXT_BYTES = 4 * 1024;
+function contextError(message) {
+    return new LanesError("worker_profile_repin_context_invalid", message, {});
+}
+function parseSenior(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    if (Object.keys(record).some((key) => key !== "kind" && key !== "id"))
+        return null;
+    if (!isSeniorKind(record.kind))
+        return null;
+    if (record.id !== undefined &&
+        (typeof record.id !== "string" || !record.id.trim() || record.id.trim() !== record.id))
+        return null;
+    if ((record.kind === "session" || record.kind === "lane") && record.id === undefined)
+        return null;
+    if (record.kind === "user" && record.id !== undefined)
+        return null;
+    return record.id === undefined
+        ? { kind: record.kind }
+        : { kind: record.kind, id: record.id };
+}
+export function createOutpostProfileRepinContext(input) {
+    const context = {
+        schema_version: PROFILE_REPIN_CONTEXT_SCHEMA,
+        lane_id: input.laneId,
+        expected_senior: input.expectedSenior.id === undefined
+            ? { kind: input.expectedSenior.kind }
+            : { kind: input.expectedSenior.kind, id: input.expectedSenior.id },
+        actor: input.actor,
+        reason: "resume --worker",
+    };
+    const encoded = Buffer.from(JSON.stringify(context), "utf8").toString("base64url");
+    if (Buffer.byteLength(encoded, "utf8") > MAX_CONTEXT_BYTES) {
+        throw contextError(`Profile re-pin context for lane ${input.laneId} is too large`);
+    }
+    return encoded;
+}
+export function parseOutpostProfileRepinContext(encoded, expectedLaneId) {
+    if (encoded.length === 0 ||
+        encoded.length > MAX_CONTEXT_BYTES ||
+        !/^[A-Za-z0-9_-]+$/.test(encoded)) {
+        throw contextError("Profile re-pin context must be bounded base64url text");
+    }
+    let raw;
+    try {
+        const decoded = Buffer.from(encoded, "base64url");
+        if (decoded.toString("base64url") !== encoded) {
+            throw new Error("non-canonical base64url");
+        }
+        raw = JSON.parse(decoded.toString("utf8"));
+    }
+    catch {
+        throw contextError("Profile re-pin context is not valid base64url JSON");
+    }
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        throw contextError("Profile re-pin context must be a JSON object");
+    }
+    const record = raw;
+    if (Object.keys(record).some((key) => !["schema_version", "lane_id", "expected_senior", "actor", "reason"].includes(key))) {
+        throw contextError("Profile re-pin context contains unknown fields");
+    }
+    const expectedSenior = parseSenior(record.expected_senior);
+    if (record.schema_version !== PROFILE_REPIN_CONTEXT_SCHEMA ||
+        record.lane_id !== expectedLaneId ||
+        expectedSenior === null ||
+        typeof record.actor !== "string" ||
+        !record.actor.trim() ||
+        record.reason !== "resume --worker") {
+        throw contextError(`Profile re-pin context is invalid for lane ${expectedLaneId}`);
+    }
+    return {
+        schema_version: PROFILE_REPIN_CONTEXT_SCHEMA,
+        lane_id: expectedLaneId,
+        expected_senior: expectedSenior,
+        actor: record.actor,
+        reason: "resume --worker",
+    };
+}
+//# sourceMappingURL=outpost-profile-repin.js.map

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,238 @@
+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";
+import { resolveFlagRegistryEndpoint } from "../flag-registry-endpoint.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 companyUid = (options.companyUid ?? process.env.HQ_COMPANY_UID ?? "").trim();
+    const companyUidSource = options.companyUid !== undefined
+        ? "install option companyUid"
+        : "HQ_COMPANY_UID";
+    if (!companyUid) {
+        throw new TypeError("install requires HQ_COMPANY_UID for the timer services");
+    }
+    if (!companyUid.startsWith("cmp_")) {
+        process.stderr.write(`${JSON.stringify({
+            event: "outpost.worktree_pruner.install_invalid_company_uid",
+            source: companyUidSource,
+            expected_prefix: "cmp_",
+        })}\n`);
+        throw new TypeError(`${companyUidSource} must start with cmp_ before installing the timer services`);
+    }
+    const flagApiUrl = resolveFlagRegistryEndpoint(options.flagApiUrl);
+    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-registry-worker-approval.d.ts

@@ -0,0 +1,18 @@
+import { type SeniorRef } from "./types.js";
+declare const APPROVAL_CONTEXT_SCHEMA: "hq-lane-registry-worker-approval-context.v1";
+export interface OutpostRegistryWorkerApprovalContext {
+    schema_version: typeof APPROVAL_CONTEXT_SCHEMA;
+    lane_id: string;
+    expected_senior: SeniorRef;
+    actor: string;
+    checkpoint: string;
+    reason: string;
+    approval_id: string;
+    registry_worker_id: string;
+    worker_yaml_sha256: string;
+    at: string;
+}
+export declare function createOutpostRegistryWorkerApprovalContext(input: Omit<OutpostRegistryWorkerApprovalContext, "schema_version">): string;
+export declare function parseOutpostRegistryWorkerApprovalContext(encoded: string, expectedLaneId: string): OutpostRegistryWorkerApprovalContext;
+export {};
+//# sourceMappingURL=outpost-registry-worker-approval.d.ts.map