@indigoai-us/hq-cli 5.345.62 → 5.345.64

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

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+export declare function registerLanesLinkCommand(lanes: Command): void;
+//# sourceMappingURL=lanes-link.d.ts.map

package/dist/commands/lanes-link.js

@@ -0,0 +1,83 @@
+import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
+import { readLanesRegistryFlagFailOpen } from "../lib/lanes/registry-flag.js";
+import { isLinkedSession, linkedSessionIdFromHookInput, LANE_SESSION_LINKS_FLAG, LaneLinkError, runLaneLinkWithFlag } from "../lib/lanes/links.js";
+function writeJson(value) {
+    process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+function addLinkOptions(command) {
+    return command
+        .option("--json", "Print JSON output (the default)")
+        .option("--session-id <id>", "Act as this session")
+        .option("--link <id>", "Conduct link id")
+        .option("--child <name|all>", "Child name or all children")
+        .option("--name <name>", "Child name")
+        .option("--engine <engine>", "Session engine")
+        .option("--title <title>", "Session title")
+        .option("--host-session <id>", "Host session id")
+        .option("--text <message>", "Message text")
+        .option("--text-file <path>", "Read message text from a file")
+        .option("--state <state>", "Child state")
+        .option("--note <note>", "State note")
+        .option("--timeout <seconds>", "Wait timeout in seconds", (value) => Number(value));
+}
+async function readHookInput() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8");
+}
+function commandError(error) {
+    const code = error instanceof LaneLinkError ? error.code : "internal";
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`hq lanes link: ${message}\n`);
+    writeJson({ error: code, message });
+    process.exitCode = 1;
+}
+export function registerLanesLinkCommand(lanes) {
+    const link = lanes.command("link").description("Link live sessions to a conductor through session inboxes");
+    const commands = ["open", "join", "send", "report", "status", "inbox", "read", "wait", "list", "leave", "close"];
+    for (const subcommand of commands) {
+        addLinkOptions(link.command(subcommand)).action(async (options) => {
+            try {
+                const root = resolveLanesHqRoot(process.env);
+                const enabled = await readLanesRegistryFlagFailOpen(LANE_SESSION_LINKS_FLAG, {
+                    env: process.env,
+                    defaultValue: true,
+                });
+                const result = await runLaneLinkWithFlag(subcommand, { ...options, hqRoot: root, env: process.env }, enabled);
+                writeJson(result.output ?? {});
+                if (result.exitCode !== undefined)
+                    process.exitCode = result.exitCode;
+            }
+            catch (error) {
+                commandError(error);
+            }
+        });
+    }
+    const deliver = link.command("_deliver", { hidden: true })
+        .description("Internal linked-session hook delivery")
+        .requiredOption("--event <event>", "Hook event");
+    deliver.action(async (options) => {
+        // Hook commands must not update/re-exec the CLI inside the provider's time budget.
+        process.env.HQ_NO_UPDATE_CHECK = "1";
+        try {
+            const root = resolveLanesHqRoot(process.env);
+            const input = await readHookInput();
+            const sid = linkedSessionIdFromHookInput(input);
+            if (!sid || !isLinkedSession(root, sid))
+                return;
+            const enabled = await readLanesRegistryFlagFailOpen(LANE_SESSION_LINKS_FLAG, {
+                env: process.env,
+                defaultValue: true,
+            });
+            const result = await runLaneLinkWithFlag("_deliver", { hqRoot: root, env: process.env, event: options.event, input }, enabled);
+            if (result.output)
+                writeJson(result.output);
+        }
+        catch (error) {
+            process.stderr.write(`hq lanes link _deliver: ${error instanceof Error ? error.message : String(error)}\n`);
+            // Hook failures are fail-open; queued messages remain available if delivery failed.
+        }
+    });
+}
+//# sourceMappingURL=lanes-link.js.map

package/dist/commands/lanes-loop.js

@@ -17,12 +17,11 @@ export function startLaneLoopController(ctx, laneId, initialAdmission = false) {
     const entry = process.argv[1];
     if (!entry)
         throw new LanesError("loop_controller_entry_missing", "Cannot resolve the hq CLI entry point for the loop controller", { lane_id: laneId });
-    const child = spawn(process.execPath, [entry, "lanes", "_loop-worker", laneId], {
-        cwd: ctx.hqRoot(),
-        detached: true,
-        stdio: "ignore",
-        env: { ...ctx.env, HQ_LANE_LOOP_CONTROLLER: "1", ...(initialAdmission ? { HQ_LANE_LOOP_INITIAL: "1" } : {}) },
-    });
+    const args = [entry, "lanes", "_loop-worker", laneId];
+    const env = { ...ctx.env, HQ_LANE_LOOP_CONTROLLER: "1", ...(initialAdmission ? { HQ_LANE_LOOP_INITIAL: "1" } : {}) };
+    const child = ctx.spawnProcess
+        ? ctx.spawnProcess(process.execPath, args, { cwd: ctx.hqRoot(), detached: true, windowsHide: true, stdio: ["ignore", 1, 2], env })
+        : spawn(process.execPath, args, { cwd: ctx.hqRoot(), detached: true, stdio: "ignore", env });
     child.unref();
     if (child.pid === undefined)
         throw new LanesError("loop_controller_spawn_failed", "Loop controller did not start", { lane_id: laneId });

package/dist/commands/lanes-questions.js

@@ -5,7 +5,7 @@ import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { appendCappedHistory, createQuestion, isLanesError, listSessionLiveness, parseLivenessState, parseQuestionRecord, parseQuestionStatus, readDaemonPresenceConnected, readLane, readQuestion, wakeAnsweredLaneNow, sessionLiveness, appendDropboxMessage, answerDropboxMessage, laneAcceptsDropboxDelivery, laneIdForAnswerDelivery, writeQuestionBody } from "../lib/lanes/index.js";
 import { resolveQuestionCompanyWithFallback } from "../lib/lanes/questions.js";
 import { LanesError } from "../lib/lanes/errors.js";
-import { applyLoopStallAnswer } from "../lib/lanes/loop.js";
+import { applyLoopStallAnswer, findLoopStallResult } from "../lib/lanes/loop.js";
 export function resolveAnswerChoice(choice, options, freeform) {
     const trimmed = choice.trim();
     if (/^[0-9]+$/.test(trimmed)) {
@@ -801,7 +801,6 @@ export function createLaneQuestionsHandlers(deps) {
             });
             return;
         }
-        throwIfQuestionNotPending(question);
         if (askingLane.state === "awaiting_input") {
             assertLaneRunsHereForOperatorMutation(ctx, askingLane, "wake after answering");
         }
@@ -819,11 +818,27 @@ export function createLaneQuestionsHandlers(deps) {
             throw new LanesError("missing_choice", "--choice or --freeform is required", {});
         }
         const choice = freeform ?? resolveAnswerChoice(opts.choice, body.options, false);
+        const isLoopStallQuestion = body.loop_stall?.lane_id === askingLane.lane_id && askingLane.loop_mode === true;
+        const incomingAnswerKind = freeform ? "freeform" : "option";
+        const incomingNotesMatch = opts.notes
+            ? question.answer?.notes_ref !== undefined && body.notes === opts.notes
+            : question.answer?.notes_ref === undefined;
+        const retryingSameLoopAnswer = isLoopStallQuestion && question.status === "answered" && question.answer?.choice === choice &&
+            question.answer.answer_kind === incomingAnswerKind && incomingNotesMatch &&
+            deps.sameQuestionAnswer(question.answer, { ...question.answer });
+        if (question.status !== "pending" && !retryingSameLoopAnswer)
+            throwIfQuestionNotPending(question);
+        const loopStallResult = isLoopStallQuestion
+            ? findLoopStallResult(path.join(hqRoot, "workspace", "lanes-runs", askingLane.lane_id), questionId)
+            : undefined;
         const at = ctx.now().toISOString();
         const answeredBy = sessionIdFromEnv(ctx.env)
             ? `session:${sessionIdFromEnv(ctx.env)}`
             : "user";
         const updated = casUpdateQuestion(hqRoot, questionId, (current) => {
+            if (retryingSameLoopAnswer && current.status === "answered" && current.answer?.choice === choice &&
+                deps.sameQuestionAnswer(current.answer, question.answer))
+                return current;
             throwIfQuestionNotPending(current);
             assertQuestionCompanyAccess(current, askingLane, requestedCompany, hqRoot);
             const recordedCompany = current.company ?? questionCompany;
@@ -856,7 +871,12 @@ export function createLaneQuestionsHandlers(deps) {
                 },
             };
         });
-        if (body.loop_stall?.lane_id === askingLane.lane_id && askingLane.loop_mode === true) {
+        if (isLoopStallQuestion) {
+            if (!loopStallResult && !retryingSameLoopAnswer) {
+                process.stderr.write(`hq lanes: loop phase for question ${questionId} was already re-enqueued; recording answer as superseded\n`);
+                printJson({ ok: true, action: "questions.answer", lane_id: askingLane.lane_id, question: updated, loop_action: "superseded" });
+                return;
+            }
             const resolved = applyLoopStallAnswer({
                 runDir: path.join(hqRoot, "workspace", "lanes-runs", askingLane.lane_id),
                 questionId,
@@ -866,6 +886,10 @@ export function createLaneQuestionsHandlers(deps) {
             });
             if (!resolved)
                 throw new LanesError("loop_stall_result_missing", `Loop stall result for question ${questionId} is missing`, { question_id: questionId, lane_id: askingLane.lane_id });
+            if (resolved.action === "already_applied") {
+                printJson({ ok: true, action: "questions.answer", lane_id: askingLane.lane_id, question: updated, loop_action: resolved.action });
+                return;
+            }
             const controllerPid = await deps.restartLoopController(ctx, askingLane.lane_id);
             printJson({ ok: true, action: "questions.answer", lane_id: askingLane.lane_id, question: updated, loop_action: resolved.action, controller_pid: controllerPid });
             return;

package/dist/commands/lanes.js

@@ -34,6 +34,7 @@ import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { withCliFeatureUsed } from "../utils/cli-telemetry.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { registerLaneSessionStartCommand } from "./lanes-session-start.js";
+import { registerLanesLinkCommand } from "./lanes-link.js";
 import { laneDepthCap } from "../lib/lanes/depth-cap.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { runResidentCommandWithPackageLease } from "../utils/resident-package-preload.js";
@@ -9431,10 +9432,30 @@ export function registerLanesCommand(parent, deps = {}) {
             }
             const runDirPath = runDir(handlerCtx.hqRoot(), laneId);
             if (loopControllerIsAlive(runDirPath)) {
-                const pid = loopStatus(runDirPath, laneId).pid;
-                if (pid === undefined)
-                    throw new LanesError("loop_controller_pid_missing", `Loop controller for ${laneId} is alive without a recorded pid`, { lane_id: laneId });
-                return pid;
+                let status = loopStatus(runDirPath, laneId);
+                if (status.state === "parked") {
+                    const deadline = Date.now() + 10_000;
+                    while (Date.now() < deadline) {
+                        await new Promise((resolve) => setTimeout(resolve, 100));
+                        status = loopStatus(runDirPath, laneId);
+                        if (status.state !== "parked") {
+                            if (status.pid === undefined)
+                                throw new LanesError("loop_controller_pid_missing", `Loop controller for ${laneId} left parked without a recorded pid`, { lane_id: laneId });
+                            return status.pid;
+                        }
+                        if (!loopControllerIsAlive(runDirPath))
+                            break;
+                    }
+                    if (loopControllerIsAlive(runDirPath) && loopStatus(runDirPath, laneId).state === "parked") {
+                        throw new LanesError("loop_controller_winding_down", `Loop controller for ${laneId} stayed parked while winding down`, { lane_id: laneId });
+                    }
+                }
+                else {
+                    const pid = status.pid;
+                    if (pid === undefined)
+                        throw new LanesError("loop_controller_pid_missing", `Loop controller for ${laneId} is alive without a recorded pid`, { lane_id: laneId });
+                    return pid;
+                }
             }
             return startLaneLoopController(handlerCtx, laneId);
         },
@@ -9534,6 +9555,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .command("lanes")
         .description("Create, supervise, and steer worker lanes; routed decision queue");
     registerLaneSessionStartCommand(lanes);
+    registerLanesLinkCommand(lanes);
     registerLaneChecksCommand(lanes, {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,

package/dist/lib/daemon/catalog.d.ts

@@ -55,6 +55,11 @@ export interface UnitPlan {
     initialDelaySec?: number;
     /** Kill and restart this child after silence on its liveness stream. */
     heartbeatTimeoutMs?: number;
+    /**
+     * Run the unit and its children at macOS background QoS (`taskpolicy -b`):
+     * efficiency cores and throttled disk I/O. For bulk work no user waits on.
+     */
+    backgroundQos?: true;
     command: UnitCommand | null;
     env: Record<string, string>;
     blocked?: UnitBlock;

package/dist/lib/daemon/catalog.js

@@ -252,6 +252,9 @@ function planService(service, ctx) {
                     intervalSec: 900,
                     initialDelaySec: 120,
                     command: { type: "hq", args: ["index", "sync", "--hq-root", ctx.hqRoot ?? ""] },
+                    // A full qmd pass rereads every indexed file; at default priority it
+                    // got HQ listed under macOS "Using Significant Energy".
+                    backgroundQos: true,
                     blocked: firstBlock([[!ctx.hqRoot, NO_HQ_ROOT]]),
                 }),
             ];

package/dist/lib/daemon/run.d.ts

@@ -80,6 +80,12 @@ export declare function syncRunnerSourceForPlan(stagedRunnerPath: string | null,
 }, currentSyncRunnerSource?: SyncRunnerSource | null): SyncRunnerSource;
 /** Whether every executable in the first service plan remains usable after the CLI package is replaced. */
 export declare function daemonPlanCanReleasePackageUseLease(plans: readonly UnitPlan[], replaceablePackageRoots: readonly string[], stagingFailed: boolean, hqBootstrapReady?: boolean): boolean;
+/**
+ * Prefix a unit's command with `taskpolicy -b` on macOS. taskpolicy execs the
+ * command in place, so the pid the supervisor tracks is the unit itself, and
+ * PRIO_DARWIN_BG is inherited by everything the unit spawns (qmd included).
+ */
+export declare function backgroundQosCommand(command: [string, string[]], backgroundQos: boolean, platform?: NodeJS.Platform | string, exists?: (file: string) => boolean): [string, string[]];
 export declare function daemonHqChildCommand(nodeBinary: string, hqBinary: string, args: readonly string[], bootstrapPath: string | null, packagePrefix: string | null): [string, string[]];
 export declare function resolveSyncRunnerPath(): string | null;
 /** The hosted desktop app uses this env value when planning daemon services. */

package/dist/lib/daemon/run.js

@@ -203,6 +203,17 @@ export function daemonPlanCanReleasePackageUseLease(plans, replaceablePackageRoo
         return executablePaths.every((candidate) => replaceablePackageRoots.every((root) => !isPathWithin(root, candidate)));
     });
 }
+const DARWIN_TASKPOLICY = "/usr/sbin/taskpolicy";
+/**
+ * Prefix a unit's command with `taskpolicy -b` on macOS. taskpolicy execs the
+ * command in place, so the pid the supervisor tracks is the unit itself, and
+ * PRIO_DARWIN_BG is inherited by everything the unit spawns (qmd included).
+ */
+export function backgroundQosCommand(command, backgroundQos, platform = process.platform, exists = fs.existsSync) {
+    if (!backgroundQos || platform !== "darwin" || !exists(DARWIN_TASKPOLICY))
+        return command;
+    return [DARWIN_TASKPOLICY, ["-b", command[0], ...command[1]]];
+}
 export function daemonHqChildCommand(nodeBinary, hqBinary, args, bootstrapPath, packagePrefix) {
     return bootstrapPath && packagePrefix
         ? [nodeBinary, [bootstrapPath, packagePrefix, CLI_VERSION, ...args]]
@@ -751,11 +762,12 @@ export async function runDaemon(opts) {
         const command = unit.command;
         if (!command || command.type === "internal")
             throw new Error(`${unit.id} has no process to start`);
-        const [file, args] = command.type === "hq"
+        let [file, args] = command.type === "hq"
             ? daemonHqChildCommand(opts.nodeBinary, opts.hqBinary, command.args, stagedHqChildBootstrap?.bootstrapPath ?? null, cliPackagePrefix)
             : command.type === "node"
                 ? [opts.nodeBinary, [command.script, ...command.args]]
                 : [command.file, command.args];
+        [file, args] = backgroundQosCommand([file, args], unit.backgroundQos === true);
         const logPath = paths.unitLogPath(unit.id);
         const cwd = unit.env.HQ_ROOT && fs.existsSync(unit.env.HQ_ROOT) ? unit.env.HQ_ROOT : home;
         if (unit.heartbeatTimeoutMs && succession) {

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

@@ -0,0 +1,39 @@
+export declare const LANE_SESSION_LINKS_FLAG = "lanes.session-links";
+export declare class LaneLinkError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface LinkOptions {
+    hqRoot: string;
+    sessionId?: string;
+    env?: NodeJS.ProcessEnv;
+    link?: string;
+    child?: string;
+    name?: string;
+    engine?: string;
+    title?: string;
+    hostSession?: string;
+    text?: string;
+    textFile?: string;
+    state?: string;
+    note?: string;
+    timeout?: number;
+    event?: string;
+    input?: string;
+    now?: () => Date;
+    sleep?: (milliseconds: number) => Promise<void>;
+}
+export interface LinkResult {
+    output?: Record<string, unknown>;
+    exitCode?: number;
+}
+export declare function resolveLinkSessionId(root: string, explicit: string | undefined, env?: NodeJS.ProcessEnv): string;
+/** Cheap hook guard used before remote flag lookup or queue access. */
+export declare function linkedSessionIdFromHookInput(input: string): string;
+export declare function isLinkedSession(root: string, sid: string): boolean;
+/** Claims pending files by renaming the whole queue, matching conduct-inbox's no-loss drain. */
+export declare function drainLinkQueue(inbox: string): string;
+export declare function runLaneLink(subcommand: string, options: LinkOptions): Promise<LinkResult>;
+/** Apply the default-on feature gate contract at the command boundary. */
+export declare function runLaneLinkWithFlag(subcommand: string, options: LinkOptions, enabled: boolean): Promise<LinkResult>;
+//# sourceMappingURL=links.d.ts.map