@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/commands/lanes-stories.js

@@ -0,0 +1,347 @@
+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

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

@@ -0,0 +1,216 @@
+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