@indigoai-us/hq-cli 5.253.0 → 5.255.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## [Unreleased]
 
+## [5.255.0] — 2026-09-28
+
+### Changed
+
+- Internal: moved watch, monitor-check, and wait handlers to src/commands/lanes-watch.ts; behavior is unchanged.
+
+## [5.254.0] — 2026-09-28
+
+### Added
+
+- The `lanes.manager-status-gate` flag checks a manager lane's declared
+  status file after each provider turn. It queues at most one corrective
+  resume if the file was not updated. An invalid or out-of-boundary mapping
+  disables the gate for that lane and lets the lane start.
+
+### Fixed
+
+- The end-of-session work report is no longer dropped when the background
+  transcript watcher polls late or adopts a session after a restart. A
+  synthesized `turn_end` now carries the transcript time, capped at now, and
+  is never earlier than the last event sent for the session.
+- `hq db sql --remote` is hidden because remote SQL is not available in this
+  CLI build. Existing scripts get a clear error, and local SQL remains
+  available without `--remote`.
+
 ## [5.253.0] — 2026-09-27
 
 ### Added
@@ -11,6 +36,7 @@
   not own with a plain message. `--as` is unchanged and cannot be combined with `--handle`.
 
 ## [5.252.0] — 2026-09-27
+
 ### Added
 
 - `hq report publish` takes a snapshot of the finished page and publishes it as the report's preview image, using a browser already installed on the computer. A page that names its own preview image keeps it. If no browser is found the report publishes without a preview.

package/dist/command-catalog.generated.d.ts

@@ -1270,7 +1270,7 @@ export declare const COMMAND_CATALOG: readonly [{
         readonly subcommands: readonly [];
     }, {
         readonly name: "sql";
-        readonly description: "Run SQL against the company vault DB (local default; --remote for secrets-injected remote; read-only by default)";
+        readonly description: "Run SQL against the company vault DB (local; read-only by default)";
         readonly aliases: readonly [];
         readonly hidden: false;
         readonly usage: "[options] [sql...]";
@@ -1287,7 +1287,7 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly description: "Allow write/DDL statements (discouraged for ad-hoc DDL)";
         }, {
             readonly flags: "--remote";
-            readonly description: "Use remote tier via vault-bound credentials (not auto-replicated with local)";
+            readonly description: "Remote SQL is not available in this CLI build yet; local queries work without --remote";
         }, {
             readonly flags: "--db-path <path>";
             readonly description: "Dangerous: open a non-canonical DB path (denied unless --allow-cross-company-path)";

package/dist/command-catalog.generated.js

@@ -1619,7 +1619,7 @@ export const COMMAND_CATALOG = [
             },
             {
                 "name": "sql",
-                "description": "Run SQL against the company vault DB (local default; --remote for secrets-injected remote; read-only by default)",
+                "description": "Run SQL against the company vault DB (local; read-only by default)",
                 "aliases": [],
                 "hidden": false,
                 "usage": "[options] [sql...]",
@@ -1641,7 +1641,7 @@ export const COMMAND_CATALOG = [
                     },
                     {
                         "flags": "--remote",
-                        "description": "Use remote tier via vault-bound credentials (not auto-replicated with local)"
+                        "description": "Remote SQL is not available in this CLI build yet; local queries work without --remote"
                     },
                     {
                         "flags": "--db-path <path>",

package/dist/commands/db-sql.js

@@ -4,9 +4,9 @@
  * Default is read-only. Prefer `hq db migrate` for schema changes.
  * Never prints remote connection strings.
  */
+import { Option } from "commander";
 import chalk from "chalk";
 import fs from "node:fs";
-import { runRemoteSql } from "../lib/db/remote-sql.js";
 import { formatSqlResult, runLocalSql } from "../lib/db/sql.js";
 function readSqlArg(sqlArgs, stdinFlag) {
     if (stdinFlag || sqlArgs.length === 0) {
@@ -19,10 +19,10 @@ function readSqlArg(sqlArgs, stdinFlag) {
 }
 export function registerDbSqlCommand(db) {
     db.command("sql")
-        .description("Run SQL against the company vault DB (local default; --remote for secrets-injected remote; read-only by default)")
+        .description("Run SQL against the company vault DB (local; read-only by default)")
         .requiredOption("--company <slug>", "Company slug (tenant scope; required)")
         .option("--write", "Allow write/DDL statements (discouraged for ad-hoc DDL)", false)
-        .option("--remote", "Use remote tier via vault-bound credentials (not auto-replicated with local)", false)
+        .addOption(new Option("--remote", "Remote SQL is not available in this CLI build yet; local queries work without --remote").hideHelp())
         .option("--db-path <path>", "Dangerous: open a non-canonical DB path (denied unless --allow-cross-company-path)")
         .option("--allow-cross-company-path", "Dangerous: permit --db-path outside this company's canonical local DB", false)
         .option("--format <fmt>", "Output format: jsonl | table", "jsonl")
@@ -37,27 +37,13 @@ export function registerDbSqlCommand(db) {
                 process.exitCode = 1;
                 return;
             }
-            const sql = readSqlArg(sqlParts, !!opts.stdin).trim();
-            const format = opts.format === "table" ? "table" : "jsonl";
             if (opts.remote) {
-                // Local and remote are not auto-replicated (v1 limitation).
-                const remoteResult = await runRemoteSql({
-                    company,
-                    sql,
-                    getConnectionConfig: async () => {
-                        throw new Error("no remote binding");
-                    },
-                });
-                console.log(formatSqlResult({
-                    columns: remoteResult.rows[0]
-                        ? Object.keys(remoteResult.rows[0])
-                        : [],
-                    rows: remoteResult.rows,
-                    changes: 0,
-                    readonly: true,
-                }, format));
+                console.error(chalk.red("Error: Remote SQL is not available in this CLI build yet. Local queries work without --remote."));
+                process.exitCode = 1;
                 return;
             }
+            const sql = readSqlArg(sqlParts, !!opts.stdin).trim();
+            const format = opts.format === "table" ? "table" : "jsonl";
             const result = runLocalSql({
                 company,
                 sql,

package/dist/commands/lanes-checks.js

@@ -9,6 +9,7 @@ import { createLocalTrackerStore } from "../lib/lanes/tracker-store.js";
 import { sessionLiveness } from "../lib/lanes/liveness.js";
 import { findOrphanLanes, parseOrphanMinAge } from "../lib/lanes/orphans.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
+import { checkCompanyPath } from "../lib/lanes/checked-company-path.js";
 import { LANES_TRACKER_FLAG } from "./lanes-tracker.js";
 function fail(error, message, details = {}) {
     throw new LanesError(error, message, details);
@@ -56,37 +57,6 @@ function readJsonObject(file, missing = "error") {
         return fail("tracker_checks_input_invalid", "Checks input must be a JSON object", { path: file });
     return parsed;
 }
-function isWithin(root, candidate) {
-    const relative = path.relative(root, candidate);
-    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
-}
-function checkCompanyPath(root, company, file, detailsPath) {
-    if (path.isAbsolute(file))
-        return fail("tracker_checks_mapping_invalid", "Mapped path must be relative to the HQ root", { path: detailsPath });
-    const absolute = path.resolve(root, file);
-    const rootReal = fs.realpathSync(root);
-    if (!isWithin(rootReal, absolute))
-        return fail("tracker_checks_mapping_invalid", "Mapped path escapes the HQ root", { path: detailsPath });
-    const relative = path.relative(rootReal, absolute).split(path.sep);
-    if (relative[0] === "companies" && relative[1] !== company) {
-        return fail("tracker_checks_mapping_invalid", "Mapped path crosses the active company boundary", { path: detailsPath });
-    }
-    try {
-        const real = fs.realpathSync(absolute);
-        if (!isWithin(rootReal, real))
-            return fail("tracker_checks_mapping_invalid", "Mapped path resolves outside the HQ root", { path: detailsPath });
-        const realRelative = path.relative(rootReal, real).split(path.sep);
-        if (realRelative[0] === "companies" && realRelative[1] !== company) {
-            return fail("tracker_checks_mapping_invalid", "Mapped path resolves into another company", { path: detailsPath });
-        }
-    }
-    catch (err) {
-        if (err.code !== "ENOENT") {
-            return fail("tracker_checks_mapping_unreadable", `Mapped path could not be checked: ${err instanceof Error ? err.message : String(err)}`, { path: absolute });
-        }
-    }
-    return absolute;
-}
 function projectFromPrdReference(root, company, raw, registryPath) {
     if (typeof raw !== "string" || raw.trim() === "") {
         return fail("tracker_checks_mapping_invalid", "Team mapping needs a PRD path", { path: registryPath });

package/dist/commands/lanes-message.js

@@ -10,6 +10,7 @@ import { isPidAlive, runWatcherLoop, WATCHER_OUT_MAX_BYTES, watcherOutLogPath, w
 import { laneStories, laneStory, storyWarning } from "../lib/lanes/stories.js";
 import { laneRunDir, probePidRecord, readPidRecord, readProcStarttime, spawnLaneWorker } from "../lib/lanes/spawn.js";
 import { keepAliveExclusion, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
+import { managerStatusGateEnabledForLane } from "../lib/lanes/manager-status-gate.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { accountMoveSummary, accountRequestKeepsCurrentLane, assertCurrentResumeAccountAvailable, recordedResumeEffort, resetKeepAliveProgress, resolveResumeEffort } from "./lanes-shared.js";
 export function createLaneMessageHandlers(deps) {
@@ -285,6 +286,7 @@ export function createLaneMessageHandlers(deps) {
                 markAccepted();
             }
             else {
+                const managerStatusGateEnabled = await managerStatusGateEnabledForLane(hqRoot, lane, { env: ctx.env });
                 const dispatched = await dispatchLaneDelivery(lane, {
                     dropbox: () => {
                         // Live (or about-to-be-live) process: the PreToolUse drain delivers it.
@@ -341,6 +343,7 @@ export function createLaneMessageHandlers(deps) {
                                 }
                                 const started = spawnLaneWorker(hqRoot, lane, {
                                     env: ctx.env,
+                                    managerStatusGateEnabled,
                                     modelDeps: {
                                         readFileSync: ctx.readFileSync,
                                         probe: ctx.probeProvider,

package/dist/commands/lanes-resume.js

@@ -5,6 +5,7 @@ import { parseCliEffort } from "../lib/lanes/effort.js";
 import { parseOutpostHireGrantContext } from "../lib/lanes/hire-grant-dispatch.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { laneStories, laneStory, storyWarning } from "../lib/lanes/stories.js";
+import { managerStatusGateEnabledForLane } from "../lib/lanes/manager-status-gate.js";
 import { spawnLaneWorker } from "../lib/lanes/spawn.js";
 import { accountMoveSummary, accountRequestKeepsCurrentLane, assertCurrentResumeAccountAvailable, hasKeepAliveProgress, recordedResumeEffort, resetKeepAliveProgress, resolveResumeEffort } from "./lanes-shared.js";
 export function createLaneResumeHandlers(deps) {
@@ -281,6 +282,7 @@ export function createLaneResumeHandlers(deps) {
             resumed = lane;
         }
         else {
+            const managerStatusGateEnabled = await managerStatusGateEnabledForLane(hqRoot, lane, { env: ctx.env });
             resumed = await withLaneAdmissionLock(hqRoot, lane.provider, async () => {
                 const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
                 if (admission.action === "refuse" && admission.error)
@@ -327,6 +329,7 @@ export function createLaneResumeHandlers(deps) {
                     }
                     return spawnLaneWorker(hqRoot, lane, {
                         env: ctx.env,
+                        managerStatusGateEnabled,
                         modelDeps: {
                             readFileSync: ctx.readFileSync,
                             probe: ctx.probeProvider,

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

@@ -7,6 +7,7 @@ import type { WatcherLoopDeps } from "../lib/lanes/watcher.js";
 import type { RunCompactionFn } from "../lib/lanes/compaction.js";
 import type { LaneMesh, LaneMeshEvent } from "../lib/lanes/mesh-events.js";
 import type { BalanceHostGap, BalanceHostSnapshot } from "../lib/lanes/claude-balance.js";
+import type { HostCapacitySnapshot } from "../lib/lanes/host-capacity.js";
 import { type ResolvedEffort } from "../lib/lanes/effort.js";
 import type { SessionCopyResult } from "../lib/lanes/move-account.js";
 import type { WorkerProfile } from "../lib/lanes/profile.js";
@@ -223,6 +224,32 @@ export interface Ctx {
     laneTrackerEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     trackerActor: () => string | null;
 }
+export interface LaneWaitCommandOptions {
+    any?: string[];
+    for?: string[];
+    timeout?: string;
+    json?: boolean;
+}
+export interface MonitorCheckOptions {
+    session?: string;
+    engine?: string;
+    json?: boolean;
+    reminder?: boolean;
+}
+export interface LaneWatchOptions {
+    intervalMs?: string;
+    json?: boolean;
+}
+export interface LaneWatchHandlerDeps {
+    laneHostFromCtx(ctx: Ctx): LaneRecord["host"];
+    loadAllLanes(hqRoot: string): LaneRecord[];
+    loadClaudeBalanceHostSnapshots(ctx: Ctx, hqRoot: string, config: LanesConfig): Promise<{
+        snapshots: BalanceHostSnapshot[];
+        unavailableHosts: BalanceHostGap[];
+    }>;
+    printJson(value: unknown): void;
+    readOutpostCapacity(ctx: Ctx, outpostId: string): Promise<HostCapacitySnapshot>;
+}
 export interface PrimaryOwnedOutpostQuestion {
     question: QuestionRecord;
     lane: LaneRecord;

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,215 @@
+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 { 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: lane.company,
+                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

package/dist/commands/lanes.d.ts

@@ -58,7 +58,7 @@ export interface LanesCommandDeps {
     /** Test seam for worker PID identity checks. */
     readStarttime?: (pid: number) => number | null;
     /** Test seams for synchronous dead-worker classification and repair. */
-    watcherLoopDeps?: Pick<WatcherLoopDeps, "sleep" | "spawnRepair">;
+    watcherLoopDeps?: Pick<WatcherLoopDeps, "sleep" | "spawnRepair" | "readManagerStatusGateFlag">;
     stopSleepMs?: (ms: number) => void;
     livenessDeps?: LivenessDeps;
     presenceConnected?: boolean;