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

package/dist/commands/lanes-hold.js

@@ -1,655 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { LanesError } from "../lib/lanes/errors.js";
-import { canonicalRepo, parseMergeCommands } from "../lib/lanes/merge-command.js";
-import { listLaneIds, readLane } from "../lib/lanes/store.js";
-import { appendDropboxMessage } from "../lib/lanes/dropbox.js";
-import { assertNoSecretText } from "../lib/lanes/text-scan.js";
-import { readLanesFlagLocalOverride, readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
-import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
-import { readLaneReview } from "../lib/lanes/reviews.js";
-import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
-export const LANES_REPO_MERGE_HOLD_FLAG = "lanes.repo-merge-hold";
-export const LANES_REVIEW_BEFORE_MERGE_FLAG = "lanes.review-before-merge";
-export const REPO_MERGE_HOLDS_REL = path.join("workspace", "lanes", "holds");
-const HOLD_SCHEMA_VERSION = "hq-lanes-repo-merge-hold.v1";
-const HISTORY_CAP = 50;
-const HOLD_LOCK_WAIT_MS = 5_000;
-const HOLD_LOCK_STALE_MS = 5 * 60_000;
-function fail(error, message, details = {}) {
-    throw new LanesError(error, message, details);
-}
-function holdFilePath(hqRoot, repo) {
-    const [owner, repository] = canonicalRepo(repo).split("/");
-    return path.join(hqRoot, REPO_MERGE_HOLDS_REL, `${owner}__${repository}.json`);
-}
-export function repoMergeHoldPath(hqRoot, repo) {
-    return holdFilePath(hqRoot, repo);
-}
-function nonEmptyText(field, raw) {
-    const value = raw.trim();
-    if (!value)
-        return fail("repo_hold_text_empty", `${field} must not be empty`, { field });
-    assertNoSecretText(field, value);
-    return value;
-}
-function parseUntil(raw, now) {
-    const value = raw.trim();
-    let timestamp;
-    const duration = /^(\d+)([smhd])$/i.exec(value);
-    if (duration) {
-        const amount = Number(duration[1]);
-        const unit = duration[2]?.toLowerCase();
-        const milliseconds = unit === "s" ? 1_000 : unit === "m" ? 60_000 : unit === "h" ? 3_600_000 : 86_400_000;
-        timestamp = now.getTime() + amount * milliseconds;
-    }
-    else {
-        const iso = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,3})?)?(Z|[+-]\d{2}:\d{2})$/.exec(value);
-        if (!iso) {
-            return fail("repo_hold_until_invalid", "Until must be an ISO timestamp or a duration such as 4h", { field: "until" });
-        }
-        const year = Number(iso[1]);
-        const month = Number(iso[2]);
-        const day = Number(iso[3]);
-        const hour = Number(iso[4]);
-        const minute = Number(iso[5]);
-        const second = Number(iso[6] ?? "0");
-        const daysInMonth = new Date(Date.UTC(year, month, 0)).getUTCDate();
-        if (month < 1 || month > 12 || day < 1 || day > daysInMonth ||
-            hour > 23 || minute > 59 || second > 59) {
-            return fail("repo_hold_until_invalid", "Until must be a valid ISO timestamp", { field: "until" });
-        }
-        timestamp = Date.parse(value);
-    }
-    if (!Number.isFinite(timestamp)) {
-        return fail("repo_hold_until_invalid", "Until must be an ISO timestamp or a duration such as 4h", { field: "until" });
-    }
-    if (timestamp <= now.getTime()) {
-        return fail("repo_hold_until_past", "Hold expiry must be in the future", { field: "until" });
-    }
-    return new Date(timestamp).toISOString();
-}
-function isObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function isCanonicalTimestamp(value) {
-    if (typeof value !== "string")
-        return false;
-    const timestamp = Date.parse(value);
-    return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
-}
-function parseHold(raw, file) {
-    if (!isObject(raw))
-        return fail("repo_hold_invalid", "Merge hold record must be an object", { path: file });
-    const company = raw.company;
-    const history = raw.history;
-    if (raw.schema_version !== HOLD_SCHEMA_VERSION || typeof raw.repo !== "string" ||
-        !isObject(company) || typeof company.slug !== "string" || !company.slug.trim() ||
-        typeof company.uid !== "string" || !company.uid.trim() ||
-        typeof raw.reason !== "string" || !raw.reason.trim() ||
-        !isCanonicalTimestamp(raw.set_at) || !isCanonicalTimestamp(raw.until) ||
-        !(raw.set_by_lane === null || typeof raw.set_by_lane === "string") ||
-        !(raw.set_by_session === null || typeof raw.set_by_session === "string") ||
-        !Array.isArray(history) || history.length > HISTORY_CAP ||
-        (raw.released_at !== undefined && !isCanonicalTimestamp(raw.released_at)) ||
-        (raw.released_reason !== undefined && typeof raw.released_reason !== "string")) {
-        return fail("repo_hold_invalid", "Merge hold record has invalid fields", { path: file });
-    }
-    let repo;
-    try {
-        repo = canonicalRepo(raw.repo);
-    }
-    catch {
-        return fail("repo_hold_invalid", "Merge hold record has an invalid repository", { path: file });
-    }
-    if (repo !== raw.repo)
-        return fail("repo_hold_invalid", "Merge hold repository is not canonical", { path: file });
-    if ((raw.released_at === undefined) !== (raw.released_reason === undefined)) {
-        return fail("repo_hold_invalid", "Released merge hold must include both release fields", { path: file });
-    }
-    if (raw.released_at !== undefined && (!raw.released_reason || !raw.released_reason.trim())) {
-        return fail("repo_hold_invalid", "Released merge hold is missing its reason", { path: file });
-    }
-    assertNoSecretText("hold.reason", raw.reason);
-    if (typeof raw.released_reason === "string")
-        assertNoSecretText("hold.released_reason", raw.released_reason);
-    for (const entry of history) {
-        if (!isObject(entry) || !isCanonicalTimestamp(entry.set_at) || !isCanonicalTimestamp(entry.until) ||
-            typeof entry.reason !== "string" || !entry.reason.trim() ||
-            !(entry.set_by_lane === null || typeof entry.set_by_lane === "string") ||
-            !(entry.set_by_session === null || typeof entry.set_by_session === "string") ||
-            (entry.released_at !== undefined && !isCanonicalTimestamp(entry.released_at)) ||
-            (entry.released_reason !== undefined && typeof entry.released_reason !== "string")) {
-            return fail("repo_hold_invalid", "Merge hold history has invalid entries", { path: file });
-        }
-        if ((entry.released_at === undefined) !== (entry.released_reason === undefined)) {
-            return fail("repo_hold_invalid", "Merge hold history release fields are incomplete", { path: file });
-        }
-        if (entry.released_reason !== undefined && !entry.released_reason.trim()) {
-            return fail("repo_hold_invalid", "Merge hold history release reason is empty", { path: file });
-        }
-        assertNoSecretText("hold.history.reason", entry.reason);
-        if (typeof entry.released_reason === "string")
-            assertNoSecretText("hold.history.released_reason", entry.released_reason);
-    }
-    return raw;
-}
-function readHold(hqRoot, repo) {
-    const file = holdFilePath(hqRoot, repo);
-    let contents;
-    try {
-        contents = fs.readFileSync(file, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        return fail("repo_hold_unreadable", "Merge hold record could not be read", { path: file });
-    }
-    let raw;
-    try {
-        raw = JSON.parse(contents);
-    }
-    catch {
-        return fail("repo_hold_invalid", "Merge hold record is not valid JSON", { path: file });
-    }
-    const hold = parseHold(raw, file);
-    if (holdFilePath(hqRoot, hold.repo) !== file) {
-        return fail("repo_hold_invalid", "Merge hold filename does not match its repository", { path: file });
-    }
-    return hold;
-}
-function listHolds(hqRoot) {
-    const directory = path.join(hqRoot, REPO_MERGE_HOLDS_REL);
-    let names;
-    try {
-        names = fs.readdirSync(directory).filter((name) => name.endsWith(".json")).sort();
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        return fail("repo_hold_unreadable", "Merge hold directory could not be read", { path: directory });
-    }
-    return names.map((name) => {
-        const file = path.join(directory, name);
-        let raw;
-        try {
-            raw = JSON.parse(fs.readFileSync(file, "utf8"));
-        }
-        catch {
-            return fail("repo_hold_invalid", "Merge hold record could not be parsed", { path: file });
-        }
-        const hold = parseHold(raw, file);
-        if (holdFilePath(hqRoot, hold.repo) !== file) {
-            return fail("repo_hold_invalid", "Merge hold filename does not match its repository", { path: file });
-        }
-        return hold;
-    });
-}
-function writeHold(hqRoot, hold) {
-    const file = holdFilePath(hqRoot, hold.repo);
-    const directory = path.dirname(file);
-    fs.mkdirSync(directory, { recursive: true });
-    const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
-    try {
-        fs.writeFileSync(temp, `${JSON.stringify(hold, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
-        fs.renameSync(temp, file);
-    }
-    catch (error) {
-        try {
-            fs.rmSync(temp, { force: true });
-        }
-        catch (cleanupError) {
-            process.stderr.write(`hq lanes hold: temporary hold cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}\n`);
-        }
-        throw error;
-    }
-}
-function holdLockOwnerAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return error.code !== "ESRCH";
-    }
-}
-function removeStaleHoldLock(lockPath) {
-    let first;
-    try {
-        first = fs.lstatSync(lockPath);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return true;
-        throw error;
-    }
-    if (Date.now() - first.mtimeMs < HOLD_LOCK_STALE_MS)
-        return false;
-    let pid;
-    try {
-        pid = Number(fs.readFileSync(lockPath, "utf8").split("\n", 1)[0]);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return true;
-        throw error;
-    }
-    if (!Number.isSafeInteger(pid) || pid <= 0 || holdLockOwnerAlive(pid))
-        return false;
-    let second;
-    try {
-        second = fs.lstatSync(lockPath);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return true;
-        throw error;
-    }
-    if (second.dev !== first.dev || second.ino !== first.ino || second.mtimeMs !== first.mtimeMs)
-        return false;
-    try {
-        fs.unlinkSync(lockPath);
-        return true;
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return true;
-        throw error;
-    }
-}
-/** Serialize the read-modify-write cycle so concurrent set/release calls cannot overwrite each other. */
-export async function withRepoMergeHoldRecordLock(recordPath, action) {
-    const lockPath = `${recordPath}.lock`;
-    fs.mkdirSync(path.dirname(recordPath), { recursive: true });
-    const started = Date.now();
-    let fd;
-    let ownedStat;
-    while (fd === undefined) {
-        try {
-            fd = fs.openSync(lockPath, "wx", 0o600);
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-            if (Date.now() - started >= HOLD_LOCK_WAIT_MS) {
-                throw new LanesError("repo_hold_write_busy", "This repository hold is being updated; retry the command", { path: recordPath });
-            }
-            if (!removeStaleHoldLock(lockPath)) {
-                await new Promise((resolve) => setTimeout(resolve, 10));
-            }
-            continue;
-        }
-        try {
-            ownedStat = fs.fstatSync(fd);
-            fs.writeSync(fd, `${process.pid}\n${Date.now()}\n`);
-        }
-        catch (error) {
-            try {
-                fs.closeSync(fd);
-            }
-            catch (closeError) {
-                process.stderr.write(`hq lanes hold: lock close failed for ${lockPath}: ${closeError instanceof Error ? closeError.message : String(closeError)}\n`);
-            }
-            try {
-                const current = fs.lstatSync(lockPath);
-                if (!ownedStat || (current.dev === ownedStat.dev && current.ino === ownedStat.ino))
-                    fs.unlinkSync(lockPath);
-            }
-            catch (cleanupError) {
-                if (cleanupError.code !== "ENOENT") {
-                    process.stderr.write(`hq lanes hold: lock cleanup failed for ${lockPath}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}\n`);
-                }
-            }
-            throw error;
-        }
-    }
-    try {
-        return await action();
-    }
-    finally {
-        try {
-            fs.closeSync(fd);
-        }
-        catch (error) {
-            process.stderr.write(`hq lanes hold: lock close failed for ${lockPath}: ${error instanceof Error ? error.message : String(error)}\n`);
-        }
-        try {
-            const current = fs.lstatSync(lockPath);
-            if (ownedStat && current.dev === ownedStat.dev && current.ino === ownedStat.ino)
-                fs.unlinkSync(lockPath);
-        }
-        catch (error) {
-            if (error.code !== "ENOENT") {
-                process.stderr.write(`hq lanes hold: lock cleanup failed for ${lockPath}: ${error instanceof Error ? error.message : String(error)}\n`);
-            }
-        }
-    }
-}
-function historyEntry(hold) {
-    return {
-        set_at: hold.set_at,
-        until: hold.until,
-        reason: hold.reason,
-        set_by_lane: hold.set_by_lane,
-        set_by_session: hold.set_by_session,
-        ...(hold.released_at ? { released_at: hold.released_at } : {}),
-        ...(hold.released_reason ? { released_reason: hold.released_reason } : {}),
-    };
-}
-function holdView(hold, now) {
-    const expired = Date.parse(hold.until) <= now.getTime();
-    return { ...hold, expired, active: !expired && hold.released_at === undefined };
-}
-function sameCompany(left, right) {
-    return left !== null && left.uid === right.uid && left.slug === right.slug;
-}
-function notifyRunningLocalLanes(hqRoot, company, text) {
-    const warnings = [];
-    let laneIds;
-    try {
-        laneIds = listLaneIds(hqRoot);
-    }
-    catch (error) {
-        return [`Could not list running lanes for dropbox notification: ${error instanceof Error ? error.message : String(error)}`];
-    }
-    for (const laneId of laneIds) {
-        try {
-            const lane = readLane(hqRoot, laneId);
-            if (lane.state !== "running" || lane.host.kind !== "local" || !sameCompany(lane.company, company))
-                continue;
-            appendDropboxMessage(hqRoot, lane.lane_id, { text });
-        }
-        catch (error) {
-            warnings.push(`Could not notify lane ${laneId}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    return warnings;
-}
-function reportNotificationWarnings(warnings) {
-    for (const warning of warnings)
-        console.error(`hq lanes hold: ${warning}`);
-}
-function printJson(value) {
-    console.log(JSON.stringify(value));
-}
-async function reviewCheckContext(hqRoot, deps) {
-    const laneId = deps.env.HQ_LANE_ID?.trim();
-    if (!laneId)
-        return null;
-    const localOverride = readLanesFlagLocalOverride(LANES_REVIEW_BEFORE_MERGE_FLAG, deps.env);
-    if (localOverride === false)
-        return null;
-    const caller = readLane(hqRoot, laneId);
-    const company = resolveLaneCompany(hqRoot, caller).company;
-    if (!company)
-        return null;
-    let enabled = localOverride;
-    if (enabled === null) {
-        let readFailure;
-        let failed = false;
-        try {
-            enabled = await (deps.mergeReviewEnabled ?? ((company) => readLanesRegistryFlag(LANES_REVIEW_BEFORE_MERGE_FLAG, {
-                company,
-                env: deps.env,
-                reportFailure: (error) => {
-                    readFailure = error;
-                    failed = true;
-                },
-            })))(company);
-        }
-        catch (error) {
-            readFailure = error;
-            failed = true;
-        }
-        if (failed) {
-            return fail("review_flag_unreadable", "Review enforcement flag could not be read", {
-                error: readFailure instanceof Error ? readFailure.name : "UnknownError",
-            });
-        }
-    }
-    if (!enabled)
-        return null;
-    for (const juniorId of listLaneIds(hqRoot)) {
-        if (juniorId === laneId)
-            continue;
-        const junior = readLane(hqRoot, juniorId);
-        if (junior.senior.kind === "lane" && junior.senior.id === laneId) {
-            return { laneId, company };
-        }
-    }
-    return null;
-}
-function checkReviewTargets(hqRoot, context, targets) {
-    let unresolved;
-    for (const target of targets) {
-        if (target.unresolvedReason || target.repo === null || target.pr === null) {
-            unresolved ??= target.unresolvedReason ?? "pull request could not be resolved";
-            continue;
-        }
-        const record = readLaneReview(hqRoot, target.repo, target.pr);
-        if (!record) {
-            return { denial: { ok: false, error: "review_record_missing", repo: target.repo, pr: target.pr } };
-        }
-        if (!target.pinnedHead) {
-            return { denial: { ok: false, error: "review_head_unpinned", repo: target.repo, pr: target.pr } };
-        }
-        if (target.pinnedHead !== record.head_sha) {
-            return {
-                denial: {
-                    ok: false,
-                    error: "review_head_mismatch",
-                    repo: target.repo,
-                    pr: target.pr,
-                    reviewed_head: record.head_sha,
-                    merge_head: target.pinnedHead,
-                },
-            };
-        }
-    }
-    return unresolved === undefined ? {} : { unresolved };
-}
-export function registerLaneRepoMergeHoldCommand(lanes, deps, wrap) {
-    const hold = lanes.command("hold").description("Set and enforce repository merge holds");
-    hold.command("set <repo>")
-        .description("Set or replace a repository merge hold")
-        .requiredOption("--company <slug>", "Company that owns this repository hold")
-        .requiredOption("--reason <text>", "Why merges are held")
-        .requiredOption("--until <time>", "Expiry as an ISO timestamp or duration such as 4h")
-        .action(wrap(async (repoArg, options) => {
-        const repo = canonicalRepo(repoArg);
-        const company = await deps.resolveCompany(options.company);
-        const reason = nonEmptyText("reason", options.reason);
-        const env = deps.env;
-        const hqRoot = deps.hqRoot();
-        const hold = await withRepoMergeHoldRecordLock(holdFilePath(hqRoot, repo), () => {
-            const now = deps.now();
-            const until = parseUntil(options.until, now);
-            const previous = readHold(hqRoot, repo);
-            if (previous && (previous.company.uid !== company.uid || previous.company.slug !== company.slug)) {
-                fail("repo_hold_company_mismatch", `A merge hold for ${repo} belongs to another company`, { repo });
-            }
-            const next = {
-                schema_version: HOLD_SCHEMA_VERSION,
-                repo,
-                company,
-                reason,
-                set_at: now.toISOString(),
-                until,
-                set_by_lane: env.HQ_LANE_ID?.trim() || null,
-                set_by_session: sessionIdFromEnv(env) ?? null,
-                history: [...(previous?.history ?? []), ...(previous ? [historyEntry(previous)] : [])].slice(-HISTORY_CAP),
-            };
-            writeHold(hqRoot, next);
-            return next;
-        });
-        const notificationWarnings = notifyRunningLocalLanes(hqRoot, company, `Merge hold on ${repo} until ${hold.until}: ${reason}. \`hq lanes hold check\` can refuse merges when the \`${LANES_REPO_MERGE_HOLD_FLAG}\` gate is enabled.`);
-        reportNotificationWarnings(notificationWarnings);
-        printJson({ action: "lanes.hold.set", hold, ...(notificationWarnings.length ? { notification_warnings: notificationWarnings } : {}) });
-    }));
-    hold.command("list")
-        .description("List active and expired repository merge holds")
-        .option("--json", "Print JSON")
-        .action(wrap(async () => {
-        const now = deps.now();
-        printJson({ action: "lanes.hold.list", holds: listHolds(deps.hqRoot()).map((item) => holdView(item, now)) });
-    }));
-    hold.command("show <repo>")
-        .description("Show a repository merge hold")
-        .action(wrap(async (repoArg) => {
-        const repo = canonicalRepo(repoArg);
-        const record = readHold(deps.hqRoot(), repo);
-        if (!record)
-            fail("repo_hold_not_found", `No merge hold exists for ${repo}`, { repo });
-        printJson({ action: "lanes.hold.show", hold: holdView(record, deps.now()) });
-    }));
-    hold.command("release <repo>")
-        .description("Release an existing repository merge hold")
-        .requiredOption("--reason <text>", "Why the hold is being released")
-        .action(wrap(async (repoArg, options) => {
-        const repo = canonicalRepo(repoArg);
-        const reason = nonEmptyText("reason", options.reason);
-        const hqRoot = deps.hqRoot();
-        const released = await withRepoMergeHoldRecordLock(holdFilePath(hqRoot, repo), () => {
-            const existing = readHold(hqRoot, repo);
-            if (!existing)
-                fail("repo_hold_not_found", `No merge hold exists for ${repo}`, { repo });
-            if (existing.released_at)
-                fail("repo_hold_already_released", `Merge hold for ${repo} is already released`, { repo });
-            const next = {
-                ...existing,
-                released_at: deps.now().toISOString(),
-                released_reason: reason,
-            };
-            writeHold(hqRoot, next);
-            return next;
-        });
-        const notificationWarnings = notifyRunningLocalLanes(hqRoot, released.company, `Merge hold on ${repo} released: ${reason}.`);
-        reportNotificationWarnings(notificationWarnings);
-        printJson({
-            action: "lanes.hold.release",
-            hold: holdView(released, deps.now()),
-            ...(notificationWarnings.length ? { notification_warnings: notificationWarnings } : {}),
-        });
-    }));
-    hold.command("check")
-        .description("Refuse merge commands targeting an actively held repository")
-        .requiredOption("--command <shell-command>", "Command to inspect without executing it")
-        .option("--json", "Print JSON")
-        .action(wrap(async (options) => {
-        if (!options.command.trim())
-            fail("repo_hold_command_empty", "Command to check must not be empty");
-        const hqRoot = deps.hqRoot();
-        const holdFlagOff = readLanesFlagLocalOverride(LANES_REPO_MERGE_HOLD_FLAG, deps.env) === false;
-        let gateWasOff = holdFlagOff;
-        let repoUnresolved = false;
-        let reviewUnresolved;
-        try {
-            let reviewContext = null;
-            if (holdFlagOff) {
-                reviewContext = await reviewCheckContext(hqRoot, deps);
-            }
-            let parsed;
-            try {
-                parsed = parseMergeCommands(options.command);
-            }
-            catch (error) {
-                if (holdFlagOff && !reviewContext) {
-                    printJson({ ok: true, hold_enforcement: "off" });
-                    return;
-                }
-                throw error;
-            }
-            repoUnresolved = parsed.targets.some((target) => target.repo === null);
-            if (holdFlagOff && !reviewContext && !parsed.unparseableMerge) {
-                printJson({ ok: true, hold_enforcement: "off" });
-                return;
-            }
-            const repos = parsed.targets.flatMap((target) => target.repo === null ? [] : [target.repo]);
-            const now = deps.now();
-            if (!holdFlagOff) {
-                const activeHolds = [...new Set(repos)]
-                    .map((repo) => readHold(hqRoot, repo))
-                    .filter((existing) => existing !== null && holdView(existing, now).active);
-                let deniedHold;
-                for (const existing of activeHolds) {
-                    const enabled = await (deps.mergeHoldEnabled ?? ((company) => readLanesRegistryFlag(LANES_REPO_MERGE_HOLD_FLAG, { company, env: deps.env })))(existing.company);
-                    if (!enabled) {
-                        gateWasOff = true;
-                        continue;
-                    }
-                    deniedHold ??= existing;
-                }
-                if (deniedHold) {
-                    printJson({
-                        ok: false,
-                        error: "repo_merge_held",
-                        repo: deniedHold.repo,
-                        reason: deniedHold.reason,
-                        until: deniedHold.until,
-                    });
-                    process.exitCode = 3;
-                    return;
-                }
-            }
-            if (parsed.unparseableMerge) {
-                const activeHolds = listHolds(hqRoot)
-                    .filter((existing) => holdView(existing, now).active);
-                let deniedUnresolvedHold;
-                for (const existing of activeHolds) {
-                    const enabled = await (deps.mergeHoldEnabled ?? ((company) => readLanesRegistryFlag(LANES_REPO_MERGE_HOLD_FLAG, { company, env: deps.env })))(existing.company);
-                    if (enabled) {
-                        deniedUnresolvedHold ??= existing;
-                    }
-                    else {
-                        gateWasOff = true;
-                    }
-                }
-                if (deniedUnresolvedHold) {
-                    printJson({
-                        ok: false,
-                        error: "repo_hold_command_invalid",
-                        repo_unresolved: true,
-                    });
-                    process.exitCode = 3;
-                    return;
-                }
-            }
-            reviewContext ??= await reviewCheckContext(hqRoot, deps);
-            if (reviewContext) {
-                const reviewCheck = checkReviewTargets(hqRoot, reviewContext, parsed.targets);
-                if (reviewCheck.denial) {
-                    printJson(reviewCheck.denial);
-                    process.exitCode = 3;
-                    return;
-                }
-                if (parsed.unparseableMerge) {
-                    printJson({ ok: false, error: "review_record_missing", repo_unresolved: true });
-                    process.exitCode = 3;
-                    return;
-                }
-                reviewUnresolved = reviewCheck.unresolved;
-            }
-            printJson({
-                ok: true,
-                ...(gateWasOff ? { hold_enforcement: "off" } : {}),
-                ...(repoUnresolved ? { repo_unresolved: true } : {}),
-                ...(reviewUnresolved ? { review_unresolved: reviewUnresolved } : {}),
-            });
-        }
-        catch (error) {
-            const checkError = error instanceof LanesError ? error.error : "review_check_failed";
-            const failedGate = checkError.startsWith("review_")
-                ? LANES_REVIEW_BEFORE_MERGE_FLAG
-                : LANES_REPO_MERGE_HOLD_FLAG;
-            console.error(`hq lanes hold check: ${failedGate} could not verify this command (${checkError}); allowing it`);
-            printJson({
-                ok: true,
-                check_error: checkError,
-                ...(gateWasOff ? { hold_enforcement: "off" } : {}),
-                ...(repoUnresolved ? { repo_unresolved: true } : {}),
-                ...(reviewUnresolved ? { review_unresolved: reviewUnresolved } : {}),
-            });
-        }
-    }));
-}
-//# sourceMappingURL=lanes-hold.js.map

package/dist/commands/lanes-kpis.d.ts

@@ -1,11 +0,0 @@
-import { Command } from "commander";
-export interface LaneKpisCommandDeps {
-    hqRoot: () => string;
-    now: () => Date;
-    wrap: WrapHandler;
-}
-type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
-/** Register the operator report command without depending on the large lanes registrar. */
-export declare function registerLaneKpisCommand(parent: Command, deps: LaneKpisCommandDeps): void;
-export {};
-//# sourceMappingURL=lanes-kpis.d.ts.map