@indigoai-us/hq-cli 5.345.50 → 5.345.52

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [5.345.52] — 2026-10-08
+- Improves recovery from disk-full sync failures by using the updated hq-cloud rescue staging flow.
+
+## [5.345.51] — 2026-10-08
+
+- Multi-company session locking now defaults on across native CLI readers; an explicit false flag value remains the kill switch.
+
+- The Codex skill bridge regression suite now checks that the repo `.agents/skills` mirror exposes every skill from the Claude listing source once.
+- `hq lanes message`, `resume` and `grant` now reach an Outpost-hosted lane that has no local record even when the owner's lane store is too large for one hierarchy read. The lane, its senior, its siblings and its children are read in bounded parts instead of the command failing with `lane_not_found`.
+- HQ CLI compares LaunchAgent plists before writing or reloading them, attributes jobs to an installed HQ.app, uses its signed launcher when available, and migrates legacy Node-first agents once.
+
 ## [5.345.50] — 2026-10-08
 - The lane keep-alive audit now admits every `done` stop envelope and splits the unrestarted ones by keep-alive eligibility: a stop keep-alive is specified not to wake is reported as `finished_story` or `idle_no_queued_work` instead of being counted as a liveness failure. `stopped_and_not_restarted_on_their_own` keeps its name and its value on the stops the audit already reported.
 - A finished standing lane that receives queued work long after it stopped now gets the normal grace period measured from when that work appeared, so a normal exit from `idle_no_queued_work` is no longer reported as a keep-alive liveness failure.

package/dist/commands/core-hq-session-native.js

@@ -781,11 +781,11 @@ export async function runHqSessionFast(argv, _stdin, cwd, hqRoot) {
         || (commandArgs[0] === "get" && commandArgs[1] === "company_slugs");
     let enabled = false;
     if (needsMultiCompanyFlag) {
-        const [{ fastFlagEnabled }, { MULTI_COMPANY_SESSION_LOCK_FLAG }] = await Promise.all([
+        const [{ fastFlagEnabledDefaultOn }, { MULTI_COMPANY_SESSION_LOCK_FLAG }] = await Promise.all([
             import("../native-fast-route.js"),
             import("../lib/cli-flag-keys.js"),
         ]);
-        enabled = await fastFlagEnabled(MULTI_COMPANY_SESSION_LOCK_FLAG);
+        enabled = await fastFlagEnabledDefaultOn(MULTI_COMPANY_SESSION_LOCK_FLAG);
     }
     const result = executeHqSession(argv, { cwd, hqRoot }, { multiCompanyLockEnabled: enabled });
     if (result.stdout)

package/dist/commands/core-resolve-company-native.js

@@ -4,7 +4,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { awkCannotOpenFileDiagnostic } from "../lib/core-utils/awk-diagnostics.js";
 import { buildCmdExeSpawnPlan, isWindowsBatchFile } from "../utils/windows-spawn.js";
-import { fastFlagEnabled } from "../native-fast-route.js";
+import { fastFlagEnabledDefaultOn } from "../native-fast-route.js";
 export const RESOLVE_COMPANY_ASSET = "core/scripts/resolve-company.sh";
 export const RESOLVE_COMPANY_HELP = [
     "hq-core: public",
@@ -603,7 +603,7 @@ export async function runResolveCompanyFast(args, stdin, cwd, hqRoot, _commandNa
         hqRoot,
         stdin: actualStdin,
         stdinIsTty: process.stdin.isTTY === true,
-        multiCompanyLockEnabled: await fastFlagEnabled("hooks.multi-company-session-lock"),
+        multiCompanyLockEnabled: await fastFlagEnabledDefaultOn("hooks.multi-company-session-lock"),
     });
     process.stdout.write(result.stdout);
     if (result.stderr.length)

package/dist/commands/lanes.js

@@ -947,6 +947,7 @@ function laneListQueryFlags(query) {
         ...(query.laneUlids?.length ? ["--lane-ulid"] : []),
         ...(query.active ? ["--active"] : []),
         ...(query.hierarchy?.length ? ["--hierarchy"] : []),
+        ...(query.senior !== undefined ? ["--senior"] : []),
         ...(query.snapshot ? ["--snapshot"] : []),
     ];
 }
@@ -1404,6 +1405,7 @@ function normalizedLaneListQuery(query) {
         ...(laneUlids === undefined ? {} : { laneUlids }),
         ...(query.active ? { active: true } : {}),
         ...(hierarchy === undefined ? {} : { hierarchy }),
+        ...(query.senior === undefined ? {} : { senior: query.senior }),
         ...(query.snapshot ? { snapshot: true } : {}),
         ...(query.strictSnapshot ? { strictSnapshot: true } : {}),
         ...(query.includeForeignHostRows ? { includeForeignHostRows: true } : {}),
@@ -1503,6 +1505,48 @@ async function readOutpostLaneRecords(ctx, outpostId, requestedQuery = {}, dispa
     }
     return invocationMemo.getOrCreate(outpostId, query, () => readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOptions));
 }
+/**
+ * Read the owner rows the hire-grant context for `laneId` is built from.
+ *
+ * The owner's `--hierarchy` selector also returns every lane that shares the
+ * target's company and project, so on a store with hundreds of lanes in one
+ * project the response reaches the Outpost exec output limit and the read
+ * fails before a single row is parsed. When that happens, and the target has a
+ * lane senior, assemble the rows the context builder needs from bounded reads
+ * every owner CLI supports: the target and its senior by id, the senior's
+ * direct children (the target's siblings) and the target's own children by
+ * `--senior`. The owner rejects `--senior` together with `--snapshot`, so the
+ * two `--senior` reads use the plain JSON list; the dispatched command sets
+ * HQ_LANES_REMOTE_READ=1, which keeps that list from refreshing remote
+ * mirrors, and the view-only fields it adds are stripped before parsing. A
+ * session-senior target needs same-company profile rows that no bounded
+ * filter selects, so its oversized read stays an error.
+ */
+async function readOutpostLaneHierarchy(ctx, outpostId, laneId) {
+    let tooLarge;
+    try {
+        return await readOutpostLaneRecords(ctx, outpostId, { hierarchy: [laneId], snapshot: true });
+    }
+    catch (err) {
+        if (!isLanesError(err) || err.error !== "outpost_lane_list_too_large")
+            throw err;
+        tooLarge = err;
+    }
+    const targets = await readOutpostLaneRecords(ctx, outpostId, { laneIds: [laneId], snapshot: true });
+    const target = targets.find((lane) => lane.lane_id === laneId);
+    if (target === undefined)
+        return targets;
+    if (target.senior.kind !== "lane" || !target.senior.id) {
+        throw new LanesError(tooLarge.error, `${tooLarge.message}; lane ${laneId} has a ${target.senior.kind} senior, whose hierarchy cannot be read in bounded parts`, { ...tooLarge.details, lane_id: laneId, senior: target.senior });
+    }
+    const seniorId = target.senior.id;
+    const [seniorRows, siblings, children] = await Promise.all([
+        readOutpostLaneRecords(ctx, outpostId, { laneIds: [seniorId], snapshot: true }),
+        readOutpostLaneRecords(ctx, outpostId, { senior: `lane:${seniorId}` }),
+        readOutpostLaneRecords(ctx, outpostId, { senior: `lane:${laneId}` }),
+    ]);
+    return mergeOwnerLaneRecords([...targets, ...seniorRows, ...siblings], children);
+}
 /** Refresh this host's selected Outpost mirrors in one bounded owner query per Outpost. */
 async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds, options = {}) {
     const result = {
@@ -1829,9 +1873,12 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
     for (const outpostId of lookupOutpostIds) {
         let ownerLanes;
         try {
-            ownerLanes = await readOutpostLaneRecords(ctx, outpostId, hostlessUlidLookup
-                ? { laneUlids: [requestedUlid], snapshot: true }
-                : { hierarchy: [laneId], snapshot: true });
+            // The hierarchy read is shared with the grant context built after
+            // resolution, so one owner round trip serves both whenever the Outpost
+            // exec output limit can carry the owner's response.
+            ownerLanes = hostlessUlidLookup
+                ? await readOutpostLaneRecords(ctx, outpostId, { laneUlids: [requestedUlid], snapshot: true })
+                : await readOutpostLaneHierarchy(ctx, outpostId, laneId);
             probedOutpostIds.push(outpostId);
         }
         catch (err) {
@@ -4665,20 +4712,14 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
     let grantContext;
     let grantHierarchy;
     if (action === "grant") {
-        const ownerHierarchy = mergeOwnerLaneRecords(loadAllLanes(ctx.hqRoot()), await readOutpostLaneRecords(ctx, outpostId, {
-            hierarchy: [lane.lane_id],
-            snapshot: true,
-        }));
+        const ownerHierarchy = mergeOwnerLaneRecords(loadAllLanes(ctx.hqRoot()), await readOutpostLaneHierarchy(ctx, outpostId, lane.lane_id));
         const hierarchy = await hierarchyWithVerifiedRemoteSenior(ctx, ctx.hqRoot(), lane, ownerHierarchy);
         grantHierarchy = hierarchy;
         grantContext = createOutpostHireGrantContext(lane, hierarchy);
     }
     else if ((action === "resume" && lane.senior.kind === "lane") ||
         (action === "message" && (lane.senior.kind === "lane" || lane.senior.kind === "session"))) {
-        const ownerHierarchy = mergeOwnerLaneRecords(loadAllLanes(ctx.hqRoot()), await readOutpostLaneRecords(ctx, outpostId, {
-            hierarchy: [lane.lane_id],
-            snapshot: true,
-        }));
+        const ownerHierarchy = mergeOwnerLaneRecords(loadAllLanes(ctx.hqRoot()), await readOutpostLaneHierarchy(ctx, outpostId, lane.lane_id));
         const hierarchy = await hierarchyWithVerifiedRemoteSenior(ctx, ctx.hqRoot(), lane, ownerHierarchy);
         grantContext = createOutpostHireGrantContext(lane, hierarchy, action === "message" ? options.supersededMessageCallerId : undefined, action === "message" ? options.supersededMessageSessionId : undefined);
     }

package/dist/commands/secrets.js

@@ -145,7 +145,7 @@ import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { removeCacheEntry, clearAllCache } from "../utils/secrets-cache.js";
 import { isHqCliChild, releaseChildWrapperPackageUseLeaseAfterStart } from "../utils/child-wrapper-lease.js";
 import { resolveDefaultHqRoot } from "../utils/hq-root-resolver.js";
-import { fastFlagEnabled } from "../native-fast-route.js";
+import { fastFlagEnabledDefaultOn } from "../native-fast-route.js";
 import { MULTI_COMPANY_SESSION_LOCK_FLAG } from "../lib/cli-flag-keys.js";
 import { resolveSessionId } from "../lib/core-utils/session-id.js";
 import { secretsExecChildExitCode } from "../utils/child-wrapper-exit.js";
@@ -1249,7 +1249,7 @@ export function registerSecretsCommand(program) {
                 process.exit(1);
             }
             const keys = parseSecretNameList(_opts.only);
-            const multiCompanyLockEnabled = await fastFlagEnabled(MULTI_COMPANY_SESSION_LOCK_FLAG);
+            const multiCompanyLockEnabled = await fastFlagEnabledDefaultOn(MULTI_COMPANY_SESSION_LOCK_FLAG);
             const sessionLock = multiCompanyLockEnabled ? readSessionCompanyLock(process.env) : undefined;
             const parentScope = secrets.opts();
             const inheritedCompany = parentScope.company;

package/dist/commands/workers.js

@@ -7,7 +7,7 @@ import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { vaultApiFetch, getCompanyUid } from "./secrets.js";
 import { GROUP_ID_PATTERN, EMAIL_PATTERN, toSharedFolderGlob } from "./_patterns.js";
 import { findHqRoot } from "../utils/manifest.js";
-import { fastFlagEnabled } from "../native-fast-route.js";
+import { fastFlagEnabledDefaultOn } from "../native-fast-route.js";
 import { MULTI_COMPANY_SESSION_LOCK_FLAG } from "../lib/cli-flag-keys.js";
 import { resolveSessionId } from "../lib/core-utils/session-id.js";
 export { readWorkerRegistry } from "../lib/workers-registry/read.js";
@@ -198,7 +198,7 @@ async function runWorkersShare(workerId, opts) {
 }
 async function runWorkersList(opts) {
     const hqRoot = findHqRoot();
-    const enabled = await fastFlagEnabled(MULTI_COMPANY_SESSION_LOCK_FLAG);
+    const enabled = await fastFlagEnabledDefaultOn(MULTI_COMPANY_SESSION_LOCK_FLAG);
     const lockedCompanies = resolveActiveCompanies(hqRoot, enabled);
     if (enabled && opts.company && denyWorkerCompanyOutsideLock(opts.company, lockedCompanies))
         return;