@indigoai-us/hq-cli 5.256.0 → 5.258.0

package/dist/commands/lanes.js

@@ -21,6 +21,7 @@ import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
 import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
 import { registerLaneTrackerImportCommand } from "./lanes-import.js";
+import { registerLaneRepoMergeHoldCommand } from "./lanes-hold.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
@@ -60,7 +61,7 @@ import { SESSION_MOVE_REASON } from "../lib/lanes/move-account.js";
 import { managerStatusGateEnabledForLane, resolveManagerStatusGateForLane, } from "../lib/lanes/manager-status-gate.js";
 import { ensureSessionHome } from "../lib/lanes/session-relink.js";
 import { defaultProbe, validateProfileLaneModel, validateLaneModel, } from "../lib/lanes/models.js";
-import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, spawnLaneWorker, laneRunDir, readSpawnManifest, stopLaneProcesses, } from "../lib/lanes/spawn.js";
+import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, spawnLaneWorker, spawnEnvelopeRepairRequest, laneRunDir, readSpawnManifest, stopLaneProcesses, } from "../lib/lanes/spawn.js";
 import { handOffInstallHere } from "../lib/daemon/handoff.js";
 export { spawnLaneWorker };
 export { questionBodyAbsPath };
@@ -6892,6 +6893,12 @@ export function registerLanesCommand(parent, deps = {}) {
             return body;
         },
     }, wrap);
+    registerLaneRepoMergeHoldCommand(lanes, {
+        hqRoot: ctx.hqRoot,
+        resolveCompany: ctx.resolveCompany,
+        now: ctx.now,
+        env: ctx.env,
+    }, wrap);
     registerOutpostPrunerCommand(lanes);
     const noStoryOption = new Option("--no-story <reason>", "Create a lane without a story and record why");
     noStoryOption.attributeName = () => "noStory";
@@ -7148,6 +7155,28 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (laneId) => {
         printJson(await messageHandlers.recoverQueuedMessages(ctx, laneId));
     }));
+    lanes
+        .command("_spawn-envelope-repair", { hidden: true })
+        .action(wrap(async () => {
+        let payload;
+        try {
+            payload = JSON.parse(ctx.readStdin());
+        }
+        catch (err) {
+            throw new LanesError("repair_request_invalid", `Envelope repair request is invalid JSON: ${err instanceof Error ? err.message : String(err)}`, {});
+        }
+        printJson(spawnEnvelopeRepairRequest(ctx.hqRoot(), payload, {
+            env: ctx.env,
+            hostname: ctx.hostname(),
+            existsSync: ctx.existsSync,
+            spawnProcess: ctx.spawnProcess,
+            proveDetached: ctx.proveDetached,
+            killProcess: ctx.killProcess,
+            resolveMachineIdentity: ctx.resolveMachineIdentity,
+            runCompaction: ctx.runCompaction,
+            locateTranscript: ctx.locateTranscript,
+        }));
+    }));
     lanes
         .command("_monitor-message", { hidden: true })
         .argument("<lane-id>", "Lane id")

package/dist/commands/packs.js

@@ -23,11 +23,21 @@ import { spawnSync } from 'child_process';
 import chalk from 'chalk';
 import semverSatisfies from 'semver/functions/satisfies.js';
 import { findHqRoot } from '../utils/manifest.js';
+import { resolveHqRoot as resolveDetectedHqRoot } from './doctor.js';
 import { classify, resolveLatest, resolveLatestMarketplace, runScanPackages, installPack, } from './pack-install.js';
 import { contributionLinks, linkStatus, listInstalledPacks, findDependentPacks, readPackManifest, unwirePack, unwirePackMcp, readHqVersion, readRecommendedPackages, packagesDir, } from '../utils/pack-contributions.js';
 function resolveRoot(opts) {
     return opts.hqRoot ? path.resolve(opts.hqRoot) : findHqRoot();
 }
+function resolvePackListRoot(opts) {
+    if (opts.hqRoot)
+        return path.resolve(opts.hqRoot);
+    const hqRoot = resolveDetectedHqRoot(process.cwd());
+    if (!hqRoot) {
+        throw new Error('hq packages: not inside an HQ tree. Run this command from inside your HQ root or pass --hq-root <path>.');
+    }
+    return hqRoot;
+}
 /** JSON when --json or when piped (non-TTY); human-readable on a terminal. */
 function wantsJson(opts) {
     return opts.json === true || !process.stdout.isTTY;
@@ -377,7 +387,7 @@ export function registerPacksListCommand(parent) {
         .option('--eval-conditionals', 'Evaluate catalog conditional predicates (runs bash)')
         .action(async (opts) => {
         try {
-            const view = await buildListView(resolveRoot(opts), !!opts.checkUpdates, !!opts.evalConditionals, !!opts.refresh);
+            const view = await buildListView(resolvePackListRoot(opts), !!opts.checkUpdates, !!opts.evalConditionals, !!opts.refresh);
             if (wantsJson(opts))
                 emitJson(view);
             else

package/dist/commands/reindex.js

@@ -1,10 +1,11 @@
 /**
- * hq reindex — surface namespaced skills, mirror the personal overlay into
- * core/, regenerate the workers registry, and converge HQ-owned hook trust for
- * Codex, Grok, and Claude Code.
+ * hq reindex — surface namespaced skills and commands, clean up retired
+ * personal-overlay mirror links, capture coding-harness session logs, regenerate
+ * the workers registry, and converge HQ-owned hook trust for Codex, Grok, and
+ * Claude Code.
  *
- * Thin wrapper over @indigoai-us/hq-cloud's reindex(), which execs the bundled
- * scripts/reindex.sh against the HQ root. This command is what the hq-core
+ * Thin wrapper over @indigoai-us/hq-cloud's native TypeScript reindex(), which
+ * runs against the HQ root. This command is what the hq-core
  * reindex hook shim calls on Stop / PostToolUse, and what sync()/rescue() call
  * after they change on-disk sources.
  *

package/dist/lib/agent-kit/paths.d.ts

@@ -5,7 +5,7 @@
  *   ~/.hq-agent/host-key.pub         Ed25519 public key, SPKI PEM
  *   ~/.hq-agent/machine-creds.json   credentials + hostKeyPath/companySlug/apiBaseUrl, 0600
  *   ~/.hq-agent/kit.json             kit install settings (hq root, intervals)
- *   ~/.hq-agent/state/               component-{sync,mesh,inbox}, last-heartbeat.json
+ *   ~/.hq-agent/state/               component-{sync,inbox}, last-heartbeat.json
  *   ~/.hq-agent/inbox/               mirrored inbox items (one JSON per message)
  *   ~/.hq-agent/attachments/<scope>/ message attachments fetched on demand (0700 / 0600)
  *   ~/.hq-agent/logs/*.log           one log per kit service

package/dist/lib/agent-kit/paths.js

@@ -5,7 +5,7 @@
  *   ~/.hq-agent/host-key.pub         Ed25519 public key, SPKI PEM
  *   ~/.hq-agent/machine-creds.json   credentials + hostKeyPath/companySlug/apiBaseUrl, 0600
  *   ~/.hq-agent/kit.json             kit install settings (hq root, intervals)
- *   ~/.hq-agent/state/               component-{sync,mesh,inbox}, last-heartbeat.json
+ *   ~/.hq-agent/state/               component-{sync,inbox}, last-heartbeat.json
  *   ~/.hq-agent/inbox/               mirrored inbox items (one JSON per message)
  *   ~/.hq-agent/attachments/<scope>/ message attachments fetched on demand (0700 / 0600)
  *   ~/.hq-agent/logs/*.log           one log per kit service

package/dist/lib/agent-kit/run/heartbeat.d.ts

@@ -1,12 +1,10 @@
 /**
  * Kit service: heartbeat reporter.
  *
- * Every 60 s POST /v1/agents/{uid}/heartbeat with
- * `{ components: { sync, mesh, inbox }, cliVersion, hostInfo }` — the
- * external-agent body from api-contract v1, mirroring the hosted box's
- * hq-agent-heartbeat.sh (which folds per-component stamp files into one
- * beat). Component values are read from the stamps the other three services
- * write; a missing or stale stamp reports `error`, never silence.
+ * Every 60 s POST /v1/agents/{uid}/heartbeat with the enabled component status
+ * values (`sync` and `inbox`), plus cliVersion and hostInfo. The external-agent
+ * body mirrors the hosted box's hq-agent-heartbeat.sh, which folds per-component
+ * stamp files into one beat. A missing or stale enabled stamp reports `error`.
  *
  * The last successful beat is recorded at state/last-heartbeat.json so
  * `hq agent probe` can report its age.

package/dist/lib/agent-kit/run/heartbeat.js

@@ -1,12 +1,10 @@
 /**
  * Kit service: heartbeat reporter.
  *
- * Every 60 s POST /v1/agents/{uid}/heartbeat with
- * `{ components: { sync, mesh, inbox }, cliVersion, hostInfo }` — the
- * external-agent body from api-contract v1, mirroring the hosted box's
- * hq-agent-heartbeat.sh (which folds per-component stamp files into one
- * beat). Component values are read from the stamps the other three services
- * write; a missing or stale stamp reports `error`, never silence.
+ * Every 60 s POST /v1/agents/{uid}/heartbeat with the enabled component status
+ * values (`sync` and `inbox`), plus cliVersion and hostInfo. The external-agent
+ * body mirrors the hosted box's hq-agent-heartbeat.sh, which folds per-component
+ * stamp files into one beat. A missing or stale enabled stamp reports `error`.
  *
  * The last successful beat is recorded at state/last-heartbeat.json so
  * `hq agent probe` can report its age.

package/dist/lib/lanes/envelope-repair-dispatch.d.ts

@@ -0,0 +1,26 @@
+import type { LaneRecord } from "./types.js";
+import type { EnvelopeRepairSpawnInput } from "./spawn.js";
+interface EnvelopeRepairDispatchResult {
+    error?: Error;
+    status: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+}
+interface EnvelopeRepairDispatchOptions {
+    encoding: "utf8";
+    timeout: number;
+    input: string;
+    env: NodeJS.ProcessEnv;
+}
+export interface EnvelopeRepairDispatchDeps {
+    env?: NodeJS.ProcessEnv;
+    spawnSync?: (command: string, args: string[], options: EnvelopeRepairDispatchOptions) => EnvelopeRepairDispatchResult;
+}
+/**
+ * Dispatch repair into the currently installed CLI. A watcher can stay alive
+ * across upgrades, so repair must not call its in-memory spawn implementation.
+ */
+export declare function spawnEnvelopeRepairViaCurrentCli(hqRoot: string, lane: LaneRecord, input: EnvelopeRepairSpawnInput, deps?: EnvelopeRepairDispatchDeps): number;
+export {};
+//# sourceMappingURL=envelope-repair-dispatch.d.ts.map

package/dist/lib/lanes/envelope-repair-dispatch.js

@@ -0,0 +1,74 @@
+import { spawnSync as nodeSpawnSync } from "node:child_process";
+import * as path from "node:path";
+import { LanesError } from "./errors.js";
+/**
+ * Dispatch repair into the currently installed CLI. A watcher can stay alive
+ * across upgrades, so repair must not call its in-memory spawn implementation.
+ */
+export function spawnEnvelopeRepairViaCurrentCli(hqRoot, lane, input, deps = {}) {
+    const request = {
+        lane_id: lane.lane_id,
+        input: {
+            ...(input.session_id !== undefined ? { session_id: input.session_id } : {}),
+            envelopePath: input.envelopePath,
+            error: input.error,
+            rawText: input.rawText,
+            ...(input.missing !== undefined ? { missing: input.missing } : {}),
+        },
+    };
+    const run = deps.spawnSync ?? ((command, args, options) => {
+        const result = nodeSpawnSync(command, args, options);
+        return {
+            ...(result.error !== undefined ? { error: result.error } : {}),
+            status: result.status,
+            signal: result.signal,
+            stdout: result.stdout ?? "",
+            stderr: result.stderr ?? "",
+        };
+    });
+    const env = deps.env ?? process.env;
+    const cliEntry = env.HQ_LANE_CLI_ENTRY?.trim();
+    if (!cliEntry || !path.isAbsolute(cliEntry) || path.resolve(cliEntry) !== cliEntry) {
+        throw new LanesError("repair_cli_entry_invalid", "Lane watcher has no valid absolute hq CLI entrypoint for envelope repair", { lane_id: lane.lane_id });
+    }
+    const result = run(process.execPath, [cliEntry, "lanes", "_spawn-envelope-repair"], {
+        encoding: "utf8",
+        timeout: 120_000,
+        input: JSON.stringify(request),
+        env: {
+            ...env,
+            HQ_ROOT: hqRoot,
+            HQ_NO_UPDATE_CHECK: "1",
+            HQ_TELEMETRY: "0",
+        },
+    });
+    if (result.error) {
+        throw new LanesError("repair_cli_spawn_failed", `Current hq CLI could not start the envelope repair: ${result.error.message}`, { lane_id: lane.lane_id });
+    }
+    if (result.status !== 0) {
+        const detail = result.stderr.trim() || `exit ${result.status ?? result.signal ?? "without status"}`;
+        throw new LanesError("repair_cli_failed", `Current hq CLI envelope repair failed: ${detail}`, { lane_id: lane.lane_id, status: result.status, signal: result.signal });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout);
+    }
+    catch (err) {
+        throw new LanesError("repair_cli_result_invalid", `Current hq CLI returned invalid envelope repair JSON: ${err instanceof Error ? err.message : String(err)}`, { lane_id: lane.lane_id });
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new LanesError("repair_cli_result_invalid", "Current hq CLI returned an invalid envelope repair result", { lane_id: lane.lane_id });
+    }
+    const response = parsed;
+    if (!Number.isInteger(response.pid) ||
+        Number(response.pid) <= 0 ||
+        !Array.isArray(response.profile_warnings) ||
+        !response.profile_warnings.every((warning) => Array.isArray(warning) && warning.every((field) => typeof field === "string"))) {
+        throw new LanesError("repair_cli_result_invalid", "Current hq CLI returned an invalid envelope repair result", { lane_id: lane.lane_id });
+    }
+    for (const warning of response.profile_warnings) {
+        input.onProfileWarning?.(warning);
+    }
+    return Number(response.pid);
+}
+//# sourceMappingURL=envelope-repair-dispatch.js.map

package/dist/lib/lanes/registry-flag.d.ts

@@ -17,6 +17,7 @@ export interface ReadLanesFlagOptions {
     getToken?: () => string | Promise<string>;
     reportFailure?: (error: unknown) => void;
 }
+export declare function readLanesFlagLocalOverride(flagKey: string, env?: NodeJS.ProcessEnv): boolean | null;
 /**
  * Read a lanes flag once for each company identity in this CLI process. The
  * cache contains only an in-flight or settled boolean promise; it is never

package/dist/lib/lanes/registry-flag.js

@@ -3,6 +3,9 @@ import { ensureCognitoIdToken } from "../../utils/cognito-session.js";
 import { FLAG_REGISTRY_DEFAULT_ENDPOINT, resolveFlagRegistryEndpoint, } from "../flag-registry-endpoint.js";
 export const LANES_FLAG_API_DEFAULT_ENDPOINT = FLAG_REGISTRY_DEFAULT_ENDPOINT;
 export const LANES_FLAG_READ_TIMEOUT_MS = 5_000;
+export function readLanesFlagLocalOverride(flagKey, env = process.env) {
+    return readLocalOverride(flagKey, env);
+}
 const registryReads = new Map();
 class MissingFlagTokenError extends Error {
     constructor() {
@@ -37,7 +40,7 @@ function cacheKey(flagKey, company, endpoint) {
  */
 export async function readLanesRegistryFlag(flagKey, options = {}) {
     const env = options.env ?? process.env;
-    const localOverride = readLocalOverride(flagKey, env);
+    const localOverride = readLanesFlagLocalOverride(flagKey, env);
     if (localOverride !== null)
         return localOverride;
     const endpoint = resolveFlagRegistryEndpoint(undefined, env);

package/dist/lib/lanes/spawn.d.ts

@@ -68,6 +68,8 @@ export type ProveDetachedFn = (pid: number) => DetachProof;
 export type KillProcessFn = (pid: number, signal?: NodeJS.Signals) => void;
 export interface SpawnLaneDeps {
     env?: NodeJS.ProcessEnv;
+    /** Absolute CLI entry captured when the watcher is armed; tests may inject it. */
+    hqCliEntry?: string;
     hostname?: string;
     /** The caller's host scope for admission checks; reconcile supplies its resolved host. */
     admissionHost?: AdmissionHost;
@@ -311,6 +313,16 @@ export interface EnvelopeRepairSpawnInput {
     /** Repair-only warning hook for profile metadata ignored during recovery. */
     onProfileWarning?: (fields: readonly string[]) => void;
 }
+/**
+ * Handle the private request sent by an older, long-running watcher to the
+ * currently installed `hq` executable. The persisted repair attempt is the
+ * authorization for this one-shot spawn; the request cannot select an
+ * arbitrary lane or write outside that lane's envelope directory.
+ */
+export declare function spawnEnvelopeRepairRequest(hqRoot: string, rawRequest: unknown, deps?: SpawnLaneDeps): {
+    pid: number;
+    profile_warnings: string[][];
+};
 /** How the spec §4 repair turn reaches the provider (recorded as `envelope_repair.mode`). */
 export type EnvelopeRepairMode = "resume" | "fresh_turn";
 /**

package/dist/lib/lanes/spawn.js

@@ -1508,10 +1508,15 @@ export function armLaneWatcher(hqRoot, laneId, deps = {}) {
     const runDir = laneRunDir(hqRoot, laneId);
     const logsDir = path.join(runDir, "logs");
     ensureDir(logsDir);
+    const cliEntry = deps.hqCliEntry?.trim() || process.argv[1]?.trim();
+    if (!cliEntry) {
+        throw new LanesError("watcher_cli_entry_unavailable", "Cannot arm the lane watcher without the current hq CLI entrypoint", { lane_id: laneId });
+    }
     const watcherPid = spawnDetached(spawnProcess, process.execPath, [watcherMainPath(), laneId], {
         ...env,
         HQ_ROOT: hqRoot,
         HQ_LANE_ID: laneId,
+        HQ_LANE_CLI_ENTRY: path.resolve(cliEntry),
     }, hqRoot, path.join(logsDir, "watcher.out"), path.join(logsDir, "watcher.err"));
     writePidRecord(path.join(runDir, "watcher.pid"), {
         pid: watcherPid,
@@ -2228,6 +2233,88 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     }
     return laneLaunchResult(readLane(hqRoot, lane.lane_id));
 }
+/**
+ * Handle the private request sent by an older, long-running watcher to the
+ * currently installed `hq` executable. The persisted repair attempt is the
+ * authorization for this one-shot spawn; the request cannot select an
+ * arbitrary lane or write outside that lane's envelope directory.
+ */
+export function spawnEnvelopeRepairRequest(hqRoot, rawRequest, deps = {}) {
+    const invalid = (message) => {
+        throw new LanesError("repair_request_invalid", message, {});
+    };
+    if (!rawRequest || typeof rawRequest !== "object" || Array.isArray(rawRequest)) {
+        return invalid("Envelope repair request must be an object");
+    }
+    const request = rawRequest;
+    if (Object.keys(request).some((key) => key !== "lane_id" && key !== "input")) {
+        return invalid("Envelope repair request has unknown fields");
+    }
+    if (typeof request.lane_id !== "string" ||
+        !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(request.lane_id)) {
+        return invalid("Envelope repair request must include a lane_id");
+    }
+    if (!request.input || typeof request.input !== "object" || Array.isArray(request.input)) {
+        return invalid("Envelope repair request input must be an object");
+    }
+    const rawInput = request.input;
+    const allowedInputFields = new Set([
+        "session_id",
+        "envelopePath",
+        "error",
+        "rawText",
+        "missing",
+    ]);
+    if (Object.keys(rawInput).some((key) => !allowedInputFields.has(key))) {
+        return invalid("Envelope repair request input has unknown fields");
+    }
+    if (typeof rawInput.envelopePath !== "string" ||
+        !path.isAbsolute(rawInput.envelopePath) ||
+        path.resolve(rawInput.envelopePath) !== rawInput.envelopePath ||
+        typeof rawInput.error !== "string" ||
+        !rawInput.error.trim() ||
+        typeof rawInput.rawText !== "string" ||
+        (rawInput.session_id !== undefined &&
+            rawInput.session_id !== null &&
+            (typeof rawInput.session_id !== "string" || !rawInput.session_id.trim())) ||
+        (rawInput.missing !== undefined && typeof rawInput.missing !== "boolean")) {
+        return invalid("Envelope repair request input has invalid fields");
+    }
+    const lane = readLane(hqRoot, request.lane_id);
+    const repair = lane.envelope_repair;
+    if (lane.state !== "running" || !repair?.attempted || repair.succeeded) {
+        throw new LanesError("repair_request_not_authorized", `Lane ${lane.lane_id} has no pending envelope repair attempt`, { lane_id: lane.lane_id });
+    }
+    if (repair.first_error !== rawInput.error) {
+        throw new LanesError("repair_request_stale", `Lane ${lane.lane_id} envelope repair request no longer matches its recorded error`, { lane_id: lane.lane_id });
+    }
+    const envelopeDir = path.resolve(laneRunDir(hqRoot, lane.lane_id), "envelopes");
+    const envelopePath = path.resolve(rawInput.envelopePath);
+    if (path.dirname(envelopePath) !== envelopeDir ||
+        !path.basename(envelopePath).endsWith(".json") ||
+        typeof repair.envelope_ref !== "string" ||
+        path.posix.dirname(repair.envelope_ref) !== "envelopes" ||
+        !path.posix.basename(repair.envelope_ref).endsWith(".json")) {
+        throw new LanesError("repair_request_path_invalid", `Lane ${lane.lane_id} envelope repair request does not name a lane envelope`, { lane_id: lane.lane_id });
+    }
+    const recordedEnvelopePath = path.resolve(laneRunDir(hqRoot, lane.lane_id), repair.envelope_ref);
+    if (envelopePath !== recordedEnvelopePath) {
+        throw new LanesError("repair_request_envelope_mismatch", `Lane ${lane.lane_id} envelope repair request does not match the recorded repair slot`, { lane_id: lane.lane_id, envelope_ref: repair.envelope_ref });
+    }
+    const warnings = [];
+    const input = {
+        envelopePath,
+        error: rawInput.error,
+        rawText: rawInput.rawText,
+        ...(typeof rawInput.session_id === "string" || rawInput.session_id === null
+            ? { session_id: rawInput.session_id }
+            : {}),
+        ...(typeof rawInput.missing === "boolean" ? { missing: rawInput.missing } : {}),
+        onProfileWarning: (fields) => warnings.push([...fields]),
+    };
+    const pid = spawnEnvelopeRepair(hqRoot, lane, input, deps);
+    return { pid, profile_warnings: warnings };
+}
 /**
  * `resume`: claude and codex continue the recorded session with the repair
  * prompt. `fresh_turn`: grok gets a new single-turn invocation on the same

package/dist/lib/lanes/watcher-main.d.ts

@@ -5,5 +5,7 @@
  * Usage: node watcher-main.js <lane-id>
  * Requires HQ_ROOT in the environment.
  */
-export {};
+import { type EnvelopeRepairDispatchDeps } from "./envelope-repair-dispatch.js";
+import type { WatcherLoopDeps } from "./watcher.js";
+export declare function watcherMainDeps(hqRoot: string, laneId: string, env?: NodeJS.ProcessEnv, repairDispatchDeps?: Pick<EnvelopeRepairDispatchDeps, "spawnSync">): WatcherLoopDeps;
 //# sourceMappingURL=watcher-main.d.ts.map

package/dist/lib/lanes/watcher-main.js

@@ -6,12 +6,33 @@
  * Requires HQ_ROOT in the environment.
  */
 import { spawnSync } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { runWatcherLoop } from "./watcher.js";
+import { spawnEnvelopeRepairViaCurrentCli, } from "./envelope-repair-dispatch.js";
 import { LanesError } from "./errors.js";
 import { openMeshTransport } from "../mesh/client.js";
 import { CompanySelectionError } from "../../utils/company-selection-error.js";
+export function watcherMainDeps(hqRoot, laneId, env = process.env, repairDispatchDeps = {}) {
+    const cliEntry = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../index.js");
+    return {
+        resolveQuestionActiveCompany,
+        spawnRepair: (root, lane, input) => spawnEnvelopeRepairViaCurrentCli(root, lane, input, { ...repairDispatchDeps, env }),
+        recoverQueuedMessages: async () => {
+            const result = spawnSync(process.execPath, [cliEntry, "lanes", "_recover-queued-messages", laneId], {
+                env,
+                encoding: "utf8",
+                timeout: 120_000,
+            });
+            if (result.error)
+                throw result.error;
+            if (result.status !== 0) {
+                throw new Error(`recovery command exited ${result.status ?? result.signal ?? "without status"}: ${(result.stderr ?? "").trim()}`);
+            }
+        },
+    };
+}
 async function resolveQuestionActiveCompany() {
     try {
         const { company } = await openMeshTransport({});
@@ -30,25 +51,14 @@ function main() {
         process.stderr.write("hq lanes watcher: requires lane id argv and HQ_ROOT in the environment\n");
         process.exit(1);
     }
-    const cliEntry = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../index.js");
-    void runWatcherLoop(hqRoot, laneId, {
-        resolveQuestionActiveCompany,
-        recoverQueuedMessages: async () => {
-            const result = spawnSync(process.execPath, [cliEntry, "lanes", "_recover-queued-messages", laneId], {
-                env: process.env,
-                encoding: "utf8",
-                timeout: 120_000,
-            });
-            if (result.error)
-                throw result.error;
-            if (result.status !== 0) {
-                throw new Error(`recovery command exited ${result.status ?? result.signal ?? "without status"}: ${(result.stderr ?? "").trim()}`);
-            }
-        },
-    }).catch((err) => {
+    void runWatcherLoop(hqRoot, laneId, watcherMainDeps(hqRoot, laneId, process.env)).catch((err) => {
         process.stderr.write(`hq lanes watcher: ${err instanceof Error ? err.message : String(err)}${err instanceof Error && err.stack ? `\n${err.stack}` : ""}\n`);
         process.exit(1);
     });
 }
-main();
+const invokedEntryPath = process.argv[1] ? path.resolve(process.argv[1]) : undefined;
+const currentModule = realpathSync(fileURLToPath(import.meta.url));
+if (invokedEntryPath && existsSync(invokedEntryPath) && realpathSync(invokedEntryPath) === currentModule) {
+    main();
+}
 //# sourceMappingURL=watcher-main.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.256.0",
+  "version": "5.258.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {