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

package/dist/commands/lanes-stories.js

@@ -1,347 +0,0 @@
-import { activeLaneStories, laneStories, laneStory, storyWarning } from "../lib/lanes/stories.js";
-import { LanesError } from "../lib/lanes/errors.js";
-import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
-export function createLaneStoryHandlers(deps) {
-    const { assertLaneRunsHereForOperatorMutation, casUpdateLane, combinedStoryWarning, emitLaneMeshEvent, ensureLaneThreadRecord, printJson, readLane, storyBoardCheck, storyNotOnBoardWarning, updateLane, validateProjectStories, } = deps;
-    function storyCommandTarget(lane, storyId, project) {
-        const projectId = project?.trim() || lane.project_id;
-        const normalizedStoryId = storyId.trim();
-        if (!projectId) {
-            throw new LanesError("missing_project", "--project is required", {});
-        }
-        if (!normalizedStoryId) {
-            throw new LanesError("missing_story", "<story-id> is required", {});
-        }
-        const story = laneStory(lane, projectId, normalizedStoryId);
-        if (!story) {
-            throw new LanesError("story_not_on_lane", `Story ${projectId}/${normalizedStoryId} is not carried by lane ${lane.lane_id}`, { lane_id: lane.lane_id, project_id: projectId, story_id: normalizedStoryId });
-        }
-        return { projectId, storyId: normalizedStoryId, story };
-    }
-    function reviewableStoryTarget(lane, storyId, project) {
-        const target = storyCommandTarget(lane, storyId, project);
-        if (target.story.status === "done") {
-            throw new LanesError("story_already_done", `Story ${target.projectId}/${target.storyId} is done and cannot be moved to review`, { lane_id: lane.lane_id, project_id: target.projectId, story_id: target.storyId });
-        }
-        return target;
-    }
-    function updateCarriedStory(lane, projectId, storyId, status, at, extras = {}) {
-        const stories = laneStories(lane).map((story) => story.project_id === projectId && story.story_id === storyId
-            ? {
-                ...story,
-                status,
-                updated_at: at,
-                blocked_reason: extras.blocked_reason,
-                verified_at: extras.verified_at,
-                verified_by: extras.verified_by,
-            }
-            : story);
-        return {
-            ...lane,
-            project_id: projectId,
-            story_id: storyId,
-            stories,
-        };
-    }
-    function addCarriedStory(lane, projectId, storyId, at) {
-        if (laneStory(lane, projectId, storyId)) {
-            throw new LanesError("story_already_on_lane", `Story ${projectId}/${storyId} is already carried by lane ${lane.lane_id}`, {
-                lane_id: lane.lane_id,
-                project_id: projectId,
-                story_id: storyId,
-            });
-        }
-        return {
-            ...lane,
-            ...(lane.story_id.trim() ? {} : { project_id: projectId, story_id: storyId }),
-            stories: [
-                ...laneStories(lane),
-                { project_id: projectId, story_id: storyId, status: "in_progress", added_at: at, updated_at: at },
-            ],
-        };
-    }
-    function callerMayVerifyStory(ctx, lane) {
-        const callerLaneId = ctx.env.HQ_LANE_ID?.trim();
-        if (callerLaneId) {
-            return lane.senior.kind === "lane" && lane.senior.id === callerLaneId;
-        }
-        if (lane.senior.kind === "user")
-            return true;
-        if (lane.senior.kind === "lane")
-            return false;
-        return sessionIdFromEnv(ctx.env) === lane.senior.id;
-    }
-    async function ensureStoryThread(ctx, lane, projectId, storyId = lane.story_id) {
-        const company = lane.mesh_company ?? lane.company;
-        if (!company)
-            return lane;
-        return ensureLaneThreadRecord(ctx, lane, projectId, storyId);
-    }
-    async function ensureStoryThreadForTransition(ctx, lane, projectId, storyId) {
-        try {
-            return { lane: await ensureStoryThread(ctx, lane, projectId, storyId) };
-        }
-        catch (err) {
-            const warning = storyNotOnBoardWarning(err);
-            if (warning === undefined)
-                throw err;
-            return { lane, warning };
-        }
-    }
-    async function emitStoryTransition(ctx, lane, projectId, storyId, event, status, payload = {}, skipStoryStatusPatch = false) {
-        const company = lane.mesh_company ?? lane.company;
-        if (!company)
-            return;
-        const ready = await ensureStoryThread(ctx, lane, projectId, storyId);
-        if (!ready.thread_id)
-            return;
-        await emitLaneMeshEvent(ctx, company, ready.thread_id, event, {
-            lane_id: ready.lane_id,
-            project_id: projectId,
-            story_id: storyId,
-            ...payload,
-            lane_status: lane.state,
-        });
-        if (!skipStoryStatusPatch && projectId?.trim() && storyId?.trim()) {
-            await ctx.mesh.patchStoryStatus(company, projectId, storyId, status === "blocked" ? "in_progress" : status);
-        }
-    }
-    function sameCommittedStory(current, expected, projectId, storyId) {
-        const currentStory = laneStory(current, projectId, storyId);
-        const expectedStory = laneStory(expected, projectId, storyId);
-        return (current.project_id === expected.project_id &&
-            current.story_id === expected.story_id &&
-            JSON.stringify(currentStory) === JSON.stringify(expectedStory));
-    }
-    async function commitStoryTransition(ctx, before, next, projectId, storyId, event, status, payload = {}, skipStoryStatusPatch = false) {
-        try {
-            await emitStoryTransition(ctx, next, projectId, storyId, event, status, payload, skipStoryStatusPatch);
-            return undefined;
-        }
-        catch (err) {
-            const warning = storyNotOnBoardWarning(err);
-            if (warning !== undefined)
-                return warning;
-            try {
-                const current = readLane(ctx.hqRoot(), next.lane_id);
-                if (!sameCommittedStory(current, next, projectId, storyId)) {
-                    throw new LanesError("story_transition_rollback_conflict", `Story ${projectId}/${storyId} changed while mesh publication failed`, { lane_id: next.lane_id, project_id: projectId, story_id: storyId });
-                }
-                updateLane(ctx.hqRoot(), next.lane_id, current.version, "command", (latest) => {
-                    if (!sameCommittedStory(latest, next, projectId, storyId)) {
-                        throw new LanesError("story_transition_rollback_conflict", `Story ${projectId}/${storyId} changed before rollback`, { lane_id: next.lane_id, project_id: projectId, story_id: storyId });
-                    }
-                    return {
-                        ...latest,
-                        project_id: before.project_id,
-                        story_id: before.story_id,
-                        stories: before.stories,
-                    };
-                });
-            }
-            catch (rollbackErr) {
-                process.stderr.write(`hq lanes: story transition rollback failed for ${next.lane_id}/${projectId}/${storyId}: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}\n`);
-            }
-            throw err;
-        }
-    }
-    async function runStoryList(ctx, laneId) {
-        const lane = readLane(ctx.hqRoot(), laneId);
-        printJson({
-            ok: true,
-            action: "story.list",
-            lane_id: laneId,
-            stories: laneStories(lane),
-            active_stories: activeLaneStories(lane),
-            story_warning: storyWarning(lane) ?? null,
-        });
-    }
-    async function runStoryAdd(ctx, laneId, storyId, opts) {
-        const hqRoot = ctx.hqRoot();
-        let lane = readLane(hqRoot, laneId);
-        assertLaneRunsHereForOperatorMutation(ctx, lane, "update story status for");
-        const projectId = opts.project?.trim() || lane.project_id;
-        if (!projectId)
-            throw new LanesError("missing_project", "--project is required", {});
-        const normalizedStoryId = storyId.trim();
-        if (!normalizedStoryId)
-            throw new LanesError("missing_story", "<story-id> is required", {});
-        if (ctx.storyLedgerEnabled()) {
-            validateProjectStories(hqRoot, projectId, [normalizedStoryId], lane.company?.slug);
-        }
-        const company = lane.mesh_company ?? lane.company;
-        const warnings = [];
-        let storyKnownAbsent = false;
-        if (company) {
-            const boardCheck = await storyBoardCheck(ctx, company, projectId, [normalizedStoryId]);
-            if (boardCheck.warning !== undefined)
-                warnings.push(boardCheck.warning);
-            storyKnownAbsent = boardCheck.absentStoryIds.has(normalizedStoryId);
-        }
-        const at = ctx.now().toISOString();
-        const thread = await ensureStoryThreadForTransition(ctx, lane, projectId, normalizedStoryId);
-        lane = thread.lane;
-        if (thread.warning !== undefined)
-            warnings.push(thread.warning);
-        const before = lane;
-        const next = casUpdateLane(hqRoot, laneId, (current) => {
-            assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
-            const added = addCarriedStory(current, projectId, normalizedStoryId, at);
-            return {
-                ...added,
-                no_story_reason: undefined,
-            };
-        });
-        const transitionWarning = await commitStoryTransition(ctx, before, next, projectId, normalizedStoryId, "lane_started", "in_progress", {}, storyKnownAbsent);
-        if (transitionWarning !== undefined)
-            warnings.push(transitionWarning);
-        const finalLane = readLane(hqRoot, laneId);
-        printJson({
-            ok: true,
-            action: "story.add",
-            lane_id: laneId,
-            project_id: projectId,
-            story_id: normalizedStoryId,
-            status: "in_progress",
-            story_warning: combinedStoryWarning(finalLane, warnings),
-            lane: finalLane,
-        });
-    }
-    async function runStoryStart(ctx, laneId, storyId, opts) {
-        const hqRoot = ctx.hqRoot();
-        let lane = readLane(hqRoot, laneId);
-        assertLaneRunsHereForOperatorMutation(ctx, lane, "update story status for");
-        const target = storyCommandTarget(lane, storyId, opts.project);
-        if (target.story.status === "done") {
-            throw new LanesError("story_already_done", `Story ${target.projectId}/${target.storyId} is done and cannot be started again`, {
-                lane_id: laneId,
-                project_id: target.projectId,
-                story_id: target.storyId,
-            });
-        }
-        const at = ctx.now().toISOString();
-        const warnings = [];
-        const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
-        lane = thread.lane;
-        if (thread.warning !== undefined)
-            warnings.push(thread.warning);
-        const before = lane;
-        const next = casUpdateLane(hqRoot, laneId, (current) => {
-            assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
-            return updateCarriedStory(current, target.projectId, target.storyId, "in_progress", at);
-        });
-        const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_started", "in_progress");
-        if (transitionWarning !== undefined)
-            warnings.push(transitionWarning);
-        const finalLane = readLane(hqRoot, laneId);
-        printJson({ ok: true, action: "story.start", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "in_progress", story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
-    }
-    async function runStoryReview(ctx, laneId, storyId, opts) {
-        const hqRoot = ctx.hqRoot();
-        let lane = readLane(hqRoot, laneId);
-        assertLaneRunsHereForOperatorMutation(ctx, lane, "update story status for");
-        const target = reviewableStoryTarget(lane, storyId, opts.project);
-        const at = ctx.now().toISOString();
-        const warnings = [];
-        const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
-        lane = thread.lane;
-        if (thread.warning !== undefined)
-            warnings.push(thread.warning);
-        const before = lane;
-        const next = casUpdateLane(hqRoot, laneId, (current) => {
-            assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
-            reviewableStoryTarget(current, target.storyId, target.projectId);
-            return updateCarriedStory(current, target.projectId, target.storyId, "review", at);
-        });
-        const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_progress", "review", { detail: "Story moved to review" });
-        if (transitionWarning !== undefined)
-            warnings.push(transitionWarning);
-        const finalLane = readLane(hqRoot, laneId);
-        printJson({
-            ok: true,
-            action: "story.review",
-            lane_id: laneId,
-            project_id: target.projectId,
-            story_id: target.storyId,
-            status: "review",
-            story_warning: combinedStoryWarning(finalLane, warnings),
-            lane: finalLane,
-        });
-    }
-    async function runStoryBlock(ctx, laneId, storyId, opts) {
-        const hqRoot = ctx.hqRoot();
-        let lane = readLane(hqRoot, laneId);
-        assertLaneRunsHereForOperatorMutation(ctx, lane, "update story status for");
-        const target = storyCommandTarget(lane, storyId, opts.project);
-        if (target.story.status === "done") {
-            throw new LanesError("story_already_done", `Story ${target.projectId}/${target.storyId} is done and cannot be blocked again`, {
-                lane_id: laneId,
-                project_id: target.projectId,
-                story_id: target.storyId,
-            });
-        }
-        const reason = opts.reason?.trim();
-        if (!reason)
-            throw new LanesError("missing_block_reason", "--reason is required", {});
-        const at = ctx.now().toISOString();
-        const warnings = [];
-        const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
-        lane = thread.lane;
-        if (thread.warning !== undefined)
-            warnings.push(thread.warning);
-        const before = lane;
-        const next = casUpdateLane(hqRoot, laneId, (current) => {
-            assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
-            return updateCarriedStory(current, target.projectId, target.storyId, "blocked", at, { blocked_reason: reason });
-        });
-        const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_blocked", "blocked", { blocked_reason: reason });
-        if (transitionWarning !== undefined)
-            warnings.push(transitionWarning);
-        const finalLane = readLane(hqRoot, laneId);
-        printJson({ ok: true, action: "story.block", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "blocked", blocked_reason: reason, story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
-    }
-    async function runStoryDone(ctx, laneId, storyId, opts) {
-        const hqRoot = ctx.hqRoot();
-        let lane = readLane(hqRoot, laneId);
-        assertLaneRunsHereForOperatorMutation(ctx, lane, "update story status for");
-        if (!opts.verified) {
-            throw new LanesError("senior_verification_required", "Only a senior may mark a story done; pass --verified after reviewing or merging it", { lane_id: laneId });
-        }
-        if (!callerMayVerifyStory(ctx, lane)) {
-            throw new LanesError("senior_verification_required", `Caller is not the senior for lane ${laneId}`, {
-                lane_id: laneId,
-                senior: lane.senior,
-            });
-        }
-        const target = storyCommandTarget(lane, storyId, opts.project);
-        if (target.story.status !== "review") {
-            throw new LanesError("story_not_ready_for_verification", `Story ${target.projectId}/${target.storyId} must be in review before senior verification`, {
-                lane_id: laneId,
-                project_id: target.projectId,
-                story_id: target.storyId,
-                status: target.story.status,
-            });
-        }
-        const at = ctx.now().toISOString();
-        const warnings = [];
-        const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
-        lane = thread.lane;
-        if (thread.warning !== undefined)
-            warnings.push(thread.warning);
-        const before = lane;
-        const next = casUpdateLane(hqRoot, laneId, (current) => {
-            assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
-            return updateCarriedStory(current, target.projectId, target.storyId, "done", at, {
-                verified_at: at,
-                verified_by: current.senior,
-            });
-        });
-        const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_done", "done", { summary: "Senior verification complete" });
-        if (transitionWarning !== undefined)
-            warnings.push(transitionWarning);
-        const finalLane = readLane(hqRoot, laneId);
-        printJson({ ok: true, action: "story.done", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "done", verified: true, story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
-    }
-    return { runStoryList, runStoryAdd, runStoryStart, runStoryReview, runStoryBlock, runStoryDone };
-}
-//# sourceMappingURL=lanes-stories.js.map

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

@@ -1,7 +0,0 @@
-import type { Ctx, MonitorCheckOptions, LaneWaitCommandOptions, LaneWatchHandlerDeps, LaneWatchOptions } from "./lanes-shared.js";
-export declare function createLaneWatchHandlers(deps: LaneWatchHandlerDeps): {
-    runWatch: (ctx: Ctx, laneIds: string[], opts: LaneWatchOptions) => Promise<number>;
-    runMonitorCheck: (ctx: Ctx, opts: MonitorCheckOptions) => Promise<number>;
-    runWait: (ctx: Ctx, opts: LaneWaitCommandOptions) => Promise<number>;
-};
-//# sourceMappingURL=lanes-watch.d.ts.map

package/dist/commands/lanes-watch.js

@@ -1,216 +0,0 @@
-import { accountStatus, coveredLaneIds, loadLanesConfig, MAX_WATCHED_LANES, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, monitorReminderText, runLaneWatch, } from "../lib/lanes/index.js";
-import { LEAD_LANE_KEEP_ALIVE_FLAG } from "../lib/lanes/keep-alive.js";
-import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
-import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
-import { isLanesError, LanesError } from "../lib/lanes/errors.js";
-import { LANE_WAIT_INVALID_INPUT_EXIT_CODE, LANE_WAIT_TIMEOUT_EXIT_CODE, runLaneWait, } from "../lib/lanes/wait.js";
-const MONITOR_ACTIVE_LANE_STATES = new Set([
-    "running",
-    "queued",
-    "awaiting_input",
-    "blocked",
-]);
-function resolveMonitorEngine(requested, env) {
-    const value = requested?.trim().toLowerCase() ||
-        env.HQ_CONDUCT_ENGINE?.trim().toLowerCase() ||
-        "claude";
-    if (!MONITOR_ENGINES.includes(value)) {
-        throw new LanesError("monitor_invalid_engine", `Unknown monitor-check engine ${JSON.stringify(value)}. Accepted: ${MONITOR_ENGINES.join(", ")}`, { accepted: [...MONITOR_ENGINES], value });
-    }
-    return value;
-}
-function monitorCallsForLaneIds(laneIds) {
-    const calls = [];
-    for (let offset = 0; offset < laneIds.length; offset += MAX_WATCHED_LANES) {
-        const chunk = laneIds.slice(offset, offset + MAX_WATCHED_LANES);
-        calls.push({
-            command: `hq lanes watch ${chunk.join(" ")}`,
-            timeout_ms: MONITOR_MAX_TIMEOUT_MS,
-            persistent: true,
-        });
-    }
-    return calls;
-}
-function laneWaitHumanLine(result) {
-    const details = Object.entries(result.change)
-        .filter(([key]) => key !== "type")
-        .map(([key, value]) => `${key}=${String(value)}`)
-        .join(" ");
-    return `lane=${result.lane_id} change=${result.change.type}${details ? ` ${details}` : ""} at=${result.at}`;
-}
-export function createLaneWatchHandlers(deps) {
-    const { laneHostFromCtx, loadAllLanes, loadClaudeBalanceHostSnapshots, printJson, readOutpostCapacity, } = deps;
-    async function runWatch(ctx, laneIds, opts) {
-        const rawInterval = opts.intervalMs === undefined ? undefined : Number(opts.intervalMs);
-        const hqRoot = ctx.hqRoot();
-        await runLaneWatch(hqRoot, laneIds, {
-            intervalMs: rawInterval,
-            sleep: ctx.sleep,
-            keepAliveEnabled: (lane) => readLanesRegistryFlag(LEAD_LANE_KEEP_ALIVE_FLAG, {
-                company: resolveLaneCompany(hqRoot, lane).company ?? undefined,
-                env: ctx.env,
-            }),
-            readAccountStatuses: async (lanes) => {
-                if (lanes.length === 0)
-                    return [];
-                const config = loadLanesConfig(hqRoot);
-                const currentHost = laneHostFromCtx(ctx);
-                const currentHostname = ctx.hostname().trim();
-                const isCurrentHost = (host) => (host.kind === currentHost.kind && host.id === currentHost.id) ||
-                    (host.kind === "local" && host.id === currentHostname);
-                const remoteOutpostIds = [...new Set(lanes
-                        .filter((lane) => lane.host.kind === "outpost" && !isCurrentHost(lane.host))
-                        .map((lane) => lane.host.id))];
-                const remoteOutposts = await Promise.all(remoteOutpostIds.map(async (id) => [id, await readOutpostCapacity(ctx, id)]));
-                const outpostSnapshots = new Map(remoteOutposts);
-                const remoteLocalLanes = lanes.filter((lane) => lane.host.kind === "local" && !isCurrentHost(lane.host));
-                const remoteLocalHosts = remoteLocalLanes.length > 0
-                    ? await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config)
-                    : undefined;
-                const localStatusCache = new Map();
-                return lanes.map((lane) => {
-                    if (config.providers[lane.provider].accounts[lane.account] === undefined) {
-                        throw new LanesError("watch_account_unconfigured", `Lane ${lane.lane_id} records unconfigured ${lane.provider} account ${lane.account}`, { lane_id: lane.lane_id, provider: lane.provider, account: lane.account, host: lane.host });
-                    }
-                    let loggedIn;
-                    if (isCurrentHost(lane.host)) {
-                        const key = JSON.stringify([lane.provider, lane.account, currentHost.kind, currentHost.id]);
-                        if (!localStatusCache.has(key)) {
-                            localStatusCache.set(key, accountStatus(lane.provider, lane.account, config, {
-                                existsSync: ctx.existsSync,
-                                probe: ctx.probeProvider,
-                                env: ctx.env,
-                                hostname: currentHostname,
-                            }).logged_in);
-                        }
-                        loggedIn = localStatusCache.get(key);
-                    }
-                    else if (lane.host.kind === "outpost") {
-                        loggedIn = outpostSnapshots.get(lane.host.id)?.providers[lane.provider].accounts[lane.account]?.logged_in;
-                    }
-                    else {
-                        const snapshot = remoteLocalHosts?.snapshots.find((candidate) => candidate.capacity.host.kind === lane.host.kind &&
-                            candidate.capacity.host.id === lane.host.id);
-                        if (!snapshot) {
-                            const gap = remoteLocalHosts?.unavailableHosts.find((candidate) => candidate.host.kind === lane.host.kind && candidate.host.id === lane.host.id);
-                            throw new LanesError("watch_account_host_unavailable", `Cannot check ${lane.provider} account ${lane.account} on ${lane.host.kind}:${lane.host.id}${gap ? `: ${gap.reason}` : ""}`, { lane_id: lane.lane_id, provider: lane.provider, account: lane.account, host: lane.host });
-                        }
-                        loggedIn = snapshot.capacity.providers[lane.provider].accounts[lane.account]?.logged_in;
-                    }
-                    if (loggedIn === undefined) {
-                        throw new LanesError("watch_account_unconfigured", `Lane ${lane.lane_id} records unconfigured ${lane.provider} account ${lane.account} on ${lane.host.kind}:${lane.host.id}`, { lane_id: lane.lane_id, provider: lane.provider, account: lane.account, host: lane.host });
-                    }
-                    return {
-                        lane_id: lane.lane_id,
-                        provider: lane.provider,
-                        account: lane.account,
-                        host: lane.host,
-                        logged_in: loggedIn,
-                    };
-                });
-            },
-            writeLine: (line) => console.log(opts.json ? JSON.stringify({ event: line }) : line),
-            writeAccountEvent: (event) => console.log(opts.json ? JSON.stringify(event) : `account_logged_out provider=${event.provider} account=${event.account} host=${event.host.kind}:${event.host.id} lane_ids=${event.lane_ids.join(",")}`),
-            writeError: (line) => process.stderr.write(`${line}\n`),
-        });
-        return 0;
-    }
-    async function runMonitorCheck(ctx, opts) {
-        if (opts.reminder) {
-            console.log(monitorReminderText());
-            return 0;
-        }
-        const sessionId = opts.session?.trim();
-        if (!sessionId) {
-            throw new LanesError("monitor_session_required", "hq lanes monitor-check requires --session <id> unless --reminder is used");
-        }
-        const engine = resolveMonitorEngine(opts.engine, ctx.env);
-        const activeLanes = loadAllLanes(ctx.hqRoot()).filter((lane) => lane.senior.kind === "session" &&
-            lane.senior.id === sessionId &&
-            MONITOR_ACTIVE_LANE_STATES.has(lane.state));
-        if (engine !== "claude") {
-            if (opts.json) {
-                printJson({
-                    ok: true,
-                    action: "monitor-check",
-                    session_id: sessionId,
-                    engine,
-                    active_lane_ids: activeLanes.map((lane) => lane.lane_id),
-                    covered_lane_ids: [],
-                    uncovered_lane_ids: [],
-                    skipped: "engine_has_no_claude_monitor",
-                });
-            }
-            return 0;
-        }
-        if (activeLanes.length === 0) {
-            if (opts.json) {
-                printJson({
-                    ok: true,
-                    action: "monitor-check",
-                    session_id: sessionId,
-                    engine,
-                    active_lane_ids: [],
-                    covered_lane_ids: [],
-                    uncovered_lane_ids: [],
-                });
-            }
-            return 0;
-        }
-        const evidence = await ctx.monitorEvidence(sessionId);
-        if (evidence.sessionId !== sessionId) {
-            throw new LanesError("monitor_evidence_session_mismatch", `Monitor evidence was for ${JSON.stringify(evidence.sessionId)}, expected ${JSON.stringify(sessionId)}`);
-        }
-        const covered = coveredLaneIds(evidence, ctx.now());
-        const activeIds = activeLanes.map((lane) => lane.lane_id);
-        const uncovered = activeIds.filter((laneId) => !covered.has(laneId));
-        const monitorCalls = monitorCallsForLaneIds(uncovered);
-        if (opts.json) {
-            printJson({
-                ok: uncovered.length === 0,
-                action: "monitor-check",
-                session_id: sessionId,
-                engine,
-                active_lane_ids: activeIds,
-                covered_lane_ids: activeIds.filter((laneId) => covered.has(laneId)),
-                uncovered_lane_ids: uncovered,
-                monitor_call: monitorCalls.length === 1 ? monitorCalls[0] : null,
-                monitor_calls: monitorCalls,
-            });
-        }
-        else if (uncovered.length > 0) {
-            for (const laneId of uncovered)
-                console.log(`uncovered lane: ${laneId}`);
-            for (const monitorCall of monitorCalls) {
-                console.log(`Monitor(command=${JSON.stringify(monitorCall.command)}, timeout_ms=${monitorCall.timeout_ms}, persistent=true)`);
-            }
-        }
-        return uncovered.length > 0 ? MONITOR_UNCOVERED_EXIT_CODE : 0;
-    }
-    async function runWait(ctx, opts) {
-        const timeoutSeconds = opts.timeout === undefined ? Number.NaN : Number(opts.timeout);
-        try {
-            const result = await runLaneWait(ctx.hqRoot(), opts.any ?? [], opts.for ?? [], timeoutSeconds * 1000, { now: ctx.now, sleep: ctx.sleep });
-            if (result) {
-                console.log(opts.json ? JSON.stringify(result) : laneWaitHumanLine(result));
-                return 0;
-            }
-            console.log(opts.json
-                ? JSON.stringify({ ok: false, error: "wait_timeout" })
-                : "wait_timeout");
-            return LANE_WAIT_TIMEOUT_EXIT_CODE;
-        }
-        catch (err) {
-            if (!isLanesError(err) || err.error !== "wait_invalid_input")
-                throw err;
-            const output = { ok: false, error: err.error, message: err.message };
-            if (opts.json)
-                console.log(JSON.stringify(output));
-            else
-                process.stderr.write(`${err.message}\n`);
-            return LANE_WAIT_INVALID_INPUT_EXIT_CODE;
-        }
-    }
-    return { runWatch, runMonitorCheck, runWait };
-}
-//# sourceMappingURL=lanes-watch.js.map