@indigoai-us/hq-cli 5.345.45 → 5.345.46

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [5.345.46] — 2026-10-08
+- Global Claude hooks installed by `hq install --global` now point `HQ_ROOT` and `CLAUDE_PROJECT_DIR` at the HQ root. Sessions outside the HQ folder now load HQ policies, and hook state stays inside HQ instead of creating a `workspace/` folder in the project. To update an existing install, re-run `hq install --global --runtime claude`.
+- `hq install --global --runtime codex` now trusts the HQ hooks it registers in `~/.codex/hooks.json`. Codex skips untrusted hooks, so before this HQ hooks never ran in Codex sessions outside the HQ folder. Only HQ entries are trusted; other hooks in the file are left alone. If Codex cannot be reached, the install still completes and tells you to approve the hooks with `/hooks`.
+- The local HQ MCP server (`hq mcp serve`) now uses your existing HQ sign-in when you have not run `hq mcp login`, so HQ tools work in Claude and Codex outside the HQ folder without a second browser login. This needs the matching hq-pro change that lets the hosted connector accept the HQ sign-in.
+- The HQ background service no longer switches HQ Anywhere off when one re-read of your HQ Anywhere setting times out. It keeps the last value it read for up to 30 minutes; turning the setting off still applies on the next successful read.
+- Sync restart checks now count settled restarts across the full one-hour window and leave out only the unsettled tail.
+- `hq lanes stop` and `hq lanes reparent` now resolve lanes on registered Outposts and dispatch mutations to the owning host, including lanes without a primary mirror.
+
 ## [5.345.45] — 2026-10-07
 - A failed automatic CLI update now pauses automatic updates for 24 hours, including for newer releases, instead of retrying on every command. `hq rescue` still updates on request. Processes started by an update can no longer start another install, and update package-manager processes run with Corepack settings that cannot change your default pnpm version.
 

package/dist/commands/install-global.d.ts

@@ -1,5 +1,6 @@
 import { Command } from 'commander';
 import { AnywhereRuntimeDisabledError } from './anywhere-runtime-flag.js';
+import { type RuntimeHookTrustResult } from '../utils/hook-trust.js';
 import { type HookTarget } from '../lib/install/claude-targets.js';
 export interface GlobalInstallOptions {
     /** HQ checkout to install from (absolute). */
@@ -78,6 +79,8 @@ export interface GlobalCommandOpts {
     /** Root-discovery seams used by command tests and wrappers. */
     home?: string;
     cwd?: string;
+    /** Test seam for trusting the Codex hooks a global install registers. */
+    trustCodexHooks?: (cwd: string, keys: readonly string[]) => Promise<RuntimeHookTrustResult>;
 }
 export declare function resolveInstallRoot(explicit: string | undefined, options?: {
     env?: NodeJS.ProcessEnv;

package/dist/commands/install-global.js

@@ -23,10 +23,11 @@ import { grokConnectorInstructions } from '../lib/install/grok-targets.js';
 import { readRegistry, registryDir, registryFile, writeRegistry } from '../lib/registry/registry.js';
 import { readCompaniesManifestMap } from '../lib/work-context/repo-remote.js';
 import { resolveDefaultHqRoot } from '../utils/hq-root-resolver.js';
+import { trustCodexUserHooks } from '../utils/hook-trust.js';
 import { DAEMON_LAUNCHD_LABEL, DAEMON_SYSTEMD_UNIT, DAEMON_WINDOWS_TASK, SYSTEM_UNIT_DIR } from '../lib/daemon/install.js';
 import { readDaemonConfig } from '../lib/daemon/config.js';
 import { daemonPaths } from '../lib/daemon/paths.js';
-import { addAgentsMdBlock, addCodexHooks, classifyLegacySkills, codexAdapterPath, codexCharterSource, codexTargets, hasAllCodexHooks, HQ_OWNED_MARKER, LEGACY_BACKUP_NAME, LEGACY_SKILLS_NAME, removeAgentsMdBlock, removeCodexHooks, } from '../lib/install/codex-targets.js';
+import { addAgentsMdBlock, addCodexHooks, classifyLegacySkills, codexAdapterPath, codexCharterSource, codexHookTrustKeys, codexTargets, hasAllCodexHooks, HQ_OWNED_MARKER, LEGACY_BACKUP_NAME, LEGACY_SKILLS_NAME, removeAgentsMdBlock, removeCodexHooks, } from '../lib/install/codex-targets.js';
 import { addClaudeMdBlock, addHqHooks, charterPath, claudeTargets, hasAllHqHooks, HQ_ANYWHERE_PACK, HQ_MCP_SERVER_NAME, hqSkillsSource, lineDiff, masterHookPath, shimPath, MCP_SUBPROCESS_PATH, removeClaudeMdBlock, removeHqHooks, SKILL_LINK_PREFIX, } from '../lib/install/claude-targets.js';
 /** True when an hq daemon unit (launchd plist or systemd unit) exists. */
 export function isDaemonInstalled(home, platform = process.platform, queryTask = (task) => spawnSync('schtasks.exe', ['/Query', '/TN', task], { encoding: 'utf8', windowsHide: true }).status === 0) {
@@ -1074,8 +1075,9 @@ export async function runInstallGlobal(opts) {
         }
     }
     const install = runtime === 'codex' ? installGlobalCodex : installGlobalClaude;
+    const hqRoot = resolveInstallRoot(opts.hqRoot, { env, cwd: opts.cwd, home: opts.home });
     install({
-        hqRoot: resolveInstallRoot(opts.hqRoot, { env, cwd: opts.cwd, home: opts.home }),
+        hqRoot,
         home: opts.home,
         dryRun: opts.dryRun,
         via: opts.via,
@@ -1084,6 +1086,26 @@ export async function runInstallGlobal(opts) {
         env,
         log: opts.log,
     });
+    if (runtime === 'codex' && !opts.dryRun)
+        await trustInstalledCodexHooks(hqRoot, opts);
+}
+/**
+ * Codex skips untrusted hooks, so the hooks.json entries written above do
+ * nothing until they are trusted. Trust exactly those entries; on failure keep
+ * the install and tell the user how to finish.
+ */
+async function trustInstalledCodexHooks(hqRoot, opts) {
+    const log = opts.log ?? ((l) => console.log(l));
+    const home = resolveEnv({ home: opts.home }).home;
+    const hooksJson = codexTargets(home).hooksJson;
+    const keys = codexHookTrustKeys(JSON.parse(fs.readFileSync(hooksJson, 'utf-8')), hooksJson, hqRoot);
+    const result = await (opts.trustCodexHooks ?? trustCodexUserHooks)(home, keys);
+    if (result.status === 'trusted')
+        log(`  hooks: trusted ${result.trusted} HQ hook(s) in Codex`);
+    else if (result.status === 'failed') {
+        log(`  hooks: Codex hooks are not trusted yet (${result.reason ?? 'unknown error'}), so Codex will skip them.`);
+        log('  To finish, open Codex and approve the HQ hooks with /hooks, or re-run `hq install --global --runtime codex`.');
+    }
 }
 export function registerUninstallCommand(program) {
     program

package/dist/commands/lanes.js

@@ -1856,11 +1856,13 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
             const companyMatches = !hostlessUlidLookup || ownerLookupGate === true || (ownerLookupGate === "check-company" &&
                 laneCompany !== undefined && laneCompany !== null &&
                 await options.allowHostlessOwnerLookup(laneCompany));
-            if (lane.host.kind === "local" && ((!hostlessUlidLookup && lane.lane_id === laneId &&
+            const exactOutpostOwnedMatch = !hostlessUlidLookup &&
+                lane.lane_id === laneId && lane.host.kind === "outpost" && lane.host.id === outpostId;
+            if (exactOutpostOwnedMatch || (lane.host.kind === "local" && ((!hostlessUlidLookup && lane.lane_id === laneId &&
                 sanitizeHostComponent(lane.host.id) === hostSuffix) ||
                 (hostlessUlidLookup && laneUlidPart(lane.lane_id) === requestedUlid &&
                     sanitizeHostComponent(lane.host.id) === recordedSuffix &&
-                    companyMatches))) {
+                    companyMatches)))) {
                 matches.push({ outpostId, lane });
             }
         }
@@ -1914,7 +1916,7 @@ function commandLaneNotFound(laneId, outpostHint, details = {}) {
     const hint = outpostHint
         ? "; pass --outpost <id> to confirm a registered Outpost"
         : "";
-    return new LanesError("lane_not_found", `Lane ${laneId} was not found locally or on a registered Outpost with a matching host suffix${hint}`, { lane_id: laneId, ...details });
+    return new LanesError("lane_not_found", `Could not resolve lane ${laneId}: no matching local record or reachable registered Outpost owner record was found${hint}`, { lane_id: laneId, ...details });
 }
 async function loadClaudeBalanceHostSnapshots(ctx, hqRoot, config, options = {}) {
     const localHost = laneHostFromCtx(ctx);
@@ -4931,7 +4933,9 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
         if (action === "reparent") {
             for (const descendantId of changedDescendantIds) {
                 const ownerDescendant = await readOutpostLaneSnapshot(ctx, outpostId, descendantId);
-                descendants.push(syncLaneRecordFromOwner(ctx.hqRoot(), descendantId, outpostId, ownerDescendant, undefined, { allowNonTerminal: true }));
+                descendants.push(behavior.syncPrimary === false
+                    ? dispatchedOwnerLane(ctx, descendantId, outpostId, ownerDescendant, behavior)
+                    : syncLaneRecordFromOwner(ctx.hqRoot(), descendantId, outpostId, ownerDescendant, undefined, { allowNonTerminal: true }));
             }
         }
         const questionCancellation = action === "resume" && lane.state === "awaiting_input" && behavior.afterFallbackResume
@@ -7515,11 +7519,21 @@ function archiveResumeMessage(hqRoot, laneId, message) {
     fs.writeFileSync(path.join(dir, `${message.message_id}.resume.jsonl`), `${JSON.stringify(message)}\n`, "utf8");
 }
 async function runReparent(ctx, laneId, opts) {
-    const hqRoot = ctx.hqRoot();
     if (!opts.senior) {
         throw new LanesError("missing_senior", "--senior is required", {});
     }
-    const initial = readLane(hqRoot, laneId);
+    const target = await resolveCommandLaneTarget(ctx, laneId);
+    const initial = target.lane;
+    if (target.remoteOnly) {
+        await dispatchOutpostLaneCommand(ctx, initial, "reparent", {
+            senior: opts.senior,
+            reason: opts.reason,
+        }, {
+            syncPrimary: false,
+            expectedOwnerHost: target.ownerHost,
+        });
+        return;
+    }
     if (initial.host.kind === "outpost" && !laneRunsHere(initial, reconcileHostFromCtx(ctx))) {
         await dispatchOutpostLaneCommand(ctx, initial, "reparent", {
             senior: opts.senior,
@@ -7527,7 +7541,7 @@ async function runReparent(ctx, laneId, opts) {
         });
         return;
     }
-    const result = await reparentOnOwner(ctx, laneId, opts);
+    const result = await reparentOnOwner(ctx, initial.lane_id, opts);
     printJson({
         ok: true,
         action: "reparent",
@@ -8138,7 +8152,7 @@ async function dispatchPrimaryLaneMessage(ctx, laneId, options) {
         printJson(response);
     return response;
 }
-async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false) {
+async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false, behavior = {}) {
     if (lane.host.kind !== "outpost") {
         throw new LanesError("outpost_dispatch_failed", `Lane ${lane.lane_id} has no Outpost host to dispatch stop to`, { lane_id: lane.lane_id });
     }
@@ -8170,6 +8184,14 @@ async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false) {
     const commandId = dispatched.commandId?.trim();
     const ownerError = ownerErrorFromOutput(dispatched.stdout);
     if (isDefiniteOutpostLaneNotFound(dispatched, lane.lane_id, ownerError)) {
+        if (behavior.syncPrimary === false) {
+            throw new LanesError("lane_not_found", ownerError.message, {
+                ...ownerError.details,
+                lane_id: lane.lane_id,
+                outpost_id: outpostId,
+                command_id: commandId,
+            });
+        }
         const at = ctx.now().toISOString();
         const updated = markRemoteLaneLost(ctx.hqRoot(), lane.lane_id, outpostId, at, "command", reason);
         if (updated.terminal_reason !== "remote_lost") {
@@ -8284,7 +8306,9 @@ async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false) {
         state = ownerLane.state;
         cancelledQuestions = parseRemoteCancelledQuestionIds(remote.cancelled_questions, lane.lane_id, outpostId, commandId);
     }
-    const updated = syncLaneRecordFromOwner(ctx.hqRoot(), lane.lane_id, outpostId, ownerLane);
+    const updated = behavior.syncPrimary === false
+        ? ownerLane
+        : syncLaneRecordFromOwner(ctx.hqRoot(), lane.lane_id, outpostId, ownerLane);
     if (!quiet)
         printJson({
             ok: true,
@@ -8312,9 +8336,14 @@ async function runStop(ctx, laneId, reason, quiet = false) {
     if (operatorReason !== undefined)
         assertNoSecretText("stop reason", operatorReason);
     const hqRoot = ctx.hqRoot();
-    const lane = readLane(hqRoot, laneId);
+    const target = await resolveCommandLaneTarget(ctx, laneId);
+    const lane = target.lane;
     if (!quiet && lane.state !== "queued" && !isTerminalLaneState(lane.state)) {
-        process.stderr.write(stopTerminalWarning(laneId));
+        process.stderr.write(stopTerminalWarning(lane.lane_id));
+    }
+    if (target.remoteOnly) {
+        await dispatchOutpostLaneStop(ctx, lane, operatorReason, quiet, { syncPrimary: false });
+        return;
     }
     if (lane.host.kind === "outpost" && !laneRunsHereForOperatorMutation(ctx, lane)) {
         await dispatchOutpostLaneStop(ctx, lane, operatorReason, quiet);

package/dist/lib/anywhere-person-setting.d.ts

@@ -10,6 +10,17 @@ export interface ReadHqAnywherePersonSettingOptions {
 }
 /** Returns null when the person preference cannot be read; callers must fail closed. */
 export declare function readHqAnywherePersonSetting(options?: ReadHqAnywherePersonSettingOptions): Promise<boolean | null>;
+/**
+ * Wrap a setting reader so a failed read (null) returns the last successfully
+ * read value for `graceMs`. A long-running caller such as hqd re-reads every
+ * minute, and one slow request would otherwise switch HQ Anywhere off for
+ * every session. A newly read value, including off, always applies at once;
+ * with no successful read inside the window the result stays null (closed).
+ */
+export declare function stickyPersonSettingReader(read: () => Promise<boolean | null>, options: {
+    graceMs: number;
+    now?: () => number;
+}): () => Promise<boolean | null>;
 export declare function evaluateAnywhereRuntime(flagEnabled: boolean, setting: boolean | null): {
     enabled: boolean;
     setting: boolean | null;

package/dist/lib/anywhere-person-setting.js

@@ -28,6 +28,25 @@ export async function readHqAnywherePersonSetting(options = {}) {
         return null;
     }
 }
+/**
+ * Wrap a setting reader so a failed read (null) returns the last successfully
+ * read value for `graceMs`. A long-running caller such as hqd re-reads every
+ * minute, and one slow request would otherwise switch HQ Anywhere off for
+ * every session. A newly read value, including off, always applies at once;
+ * with no successful read inside the window the result stays null (closed).
+ */
+export function stickyPersonSettingReader(read, options) {
+    const now = options.now ?? Date.now;
+    let last = null;
+    return async () => {
+        const value = await read();
+        if (value !== null) {
+            last = { value, at: now() };
+            return value;
+        }
+        return last && now() - last.at <= options.graceMs ? last.value : null;
+    };
+}
 export function evaluateAnywhereRuntime(flagEnabled, setting) {
     return { enabled: flagEnabled && setting === true, setting };
 }

package/dist/lib/daemon/ops/mcp.d.ts

@@ -13,7 +13,16 @@ export interface McpToolResult {
 }
 export declare function jsonResult(value: unknown): McpToolResult;
 export declare function resolveHqMcpEndpoint(env?: NodeJS.ProcessEnv): URL;
-export declare function defaultMcpToken(): Promise<string>;
+/** Test seams for {@link defaultMcpToken}. */
+export interface McpTokenDeps {
+    tokenSource?: () => string;
+    mcpAudienceToken?: () => Promise<string>;
+    cognitoToken?: (options: {
+        tokenSource: "person" | "machine";
+        interactive: false;
+    }) => Promise<string>;
+}
+export declare function defaultMcpToken(deps?: McpTokenDeps): Promise<string>;
 export interface HqMcpBridgeOptions {
     endpoint?: URL;
     env?: NodeJS.ProcessEnv;

package/dist/lib/daemon/ops/mcp.js

@@ -27,24 +27,31 @@ export function resolveHqMcpEndpoint(env = process.env) {
         throw error;
     }
 }
-export async function defaultMcpToken() {
-    const { ensureCognitoToken, resolveCognitoTokenSource } = await import("../../../utils/cognito-session.js");
-    if (resolveCognitoTokenSource() !== "machine") {
-        const { getMcpAudienceToken, McpOAuthError } = await import("../mcp-oauth.js");
+export async function defaultMcpToken(deps = {}) {
+    const session = deps.tokenSource && deps.cognitoToken ? null : await import("../../../utils/cognito-session.js");
+    const tokenSource = deps.tokenSource ?? session.resolveCognitoTokenSource;
+    const cognitoToken = deps.cognitoToken ?? ((options) => session.ensureCognitoToken(options));
+    if (tokenSource() !== "machine") {
+        const mcpAudienceToken = deps.mcpAudienceToken ?? (async () => (await import("../mcp-oauth.js")).getMcpAudienceToken());
         try {
-            return await getMcpAudienceToken();
+            return await mcpAudienceToken();
         }
-        catch (error) {
-            if (error instanceof McpOAuthError)
-                throw new McpOpError(error.code, error.message);
-            throw new McpOpError("hq_mcp_auth_required", "Hosted MCP sign-in is required. Run `hq mcp login` and retry.");
+        catch {
+            // No `hq mcp login`: hosted hq-mcp also accepts the HQ sign-in client,
+            // so reuse the session hq-cli and the desktop app already hold.
+        }
+        try {
+            return await cognitoToken({ tokenSource: "person", interactive: false });
+        }
+        catch {
+            throw new McpOpError("hq_mcp_auth_required", "Sign in to HQ with `hq login`, then retry.");
         }
     }
     try {
         // Send this box's existing machine token. The hosted hq-mcp audience check
         // accepts it only when it was issued for hqMcpMachineClient; otherwise the
         // server rejects it. This helper does not inspect the credential's client ID.
-        return await ensureCognitoToken({ tokenSource: "machine", interactive: false });
+        return await cognitoToken({ tokenSource: "machine", interactive: false });
     }
     catch {
         throw new McpOpError("hq_mcp_auth_required", "An hq-mcp machine token is unavailable. Configure this box with hq-pro's hqMcpMachineClient ID, then retry the daemon call.");

package/dist/lib/daemon/run.js

@@ -14,7 +14,7 @@ import { fileURLToPath } from "node:url";
 import { loadCachedTokens } from "@indigoai-us/hq-cloud";
 import { CLI_VERSION } from "../../cli-version.js";
 import { anywhereRuntimeEnabled } from "../../commands/anywhere-runtime-flag.js";
-import { anywhereRuntimeAllowed } from "../anywhere-person-setting.js";
+import { anywhereRuntimeAllowed, readHqAnywherePersonSetting, stickyPersonSettingReader } from "../anywhere-person-setting.js";
 import { currentPackageUseLeaseInstall, currentPackageUseUpdateRequested } from "../../utils/package-use-lease.js";
 import { isLocalDependencyInstall, resolveRunningInstall } from "../../utils/version-gate.js";
 import { agentKitPaths } from "../agent-kit/paths.js";
@@ -77,6 +77,8 @@ export function handoffForPackageUpdateRequest(requested, restartDaemon) {
 const LEGACY_PROBE_TTL_MS = 60_000;
 /** A flag read that has not answered by then counts as off. */
 const HANDOFF_FLAG_TIMEOUT_MS = 10_000;
+/** How long hqd keeps the last read HQ Anywhere setting when a re-read fails. */
+const HQD_PERSON_SETTING_GRACE_MS = 30 * 60_000;
 export function syncRunnerSourceForPlan(stagedRunnerPath, hqCloud, legacyBundledRunnerPath = null, staged = { version: null }, currentSyncRunnerSource = null) {
     // A managed copy lives in the daemon directory, so it survives a CLI
     // replacement. Before lease release pickHqCloud returns it only when it is
@@ -838,13 +840,17 @@ export async function runDaemon(opts) {
     // hqd: the session/company socket every runtime talks to (hq-anywhere US-008).
     let hqdShutdown = null;
     let stopHeartbeat = () => { };
+    const readPersonSetting = stickyPersonSettingReader(() => readHqAnywherePersonSetting({
+        env,
+        onError: (name) => log("warn", `hqd person setting read failed (${name}); keeping the last read value for up to ${HQD_PERSON_SETTING_GRACE_MS / 60_000} minutes`),
+    }), { graceMs: HQD_PERSON_SETTING_GRACE_MS });
     const hqdListener = await startHqdRuntimeListener({
         isEnabled: async () => shouldStartHqd(await anywhereRuntimeAllowed(env, {
             refreshFlag: async () => {
                 const { refreshFlagRegistrySnapshot } = await import("../flag-registry.js");
                 await refreshFlagRegistrySnapshot(5_000);
             },
-            onError: (name) => log("warn", `hqd person setting read failed (${name}); runtime remains off`),
+            readSetting: readPersonSetting,
         })),
         startServer: async () => {
             const startConfig = readDaemonConfig(paths.configPath);

package/dist/lib/doctor/checks/sync-runtime.d.ts

@@ -1,5 +1,7 @@
 import type { CheckResult } from "../types.js";
 export declare const SYNC_RUNTIME_WINDOW_MS: number;
+/** Ignore timing and restart signals until a newly started receiver has settled. */
+export declare const SYNC_RUNTIME_RESTART_WARMUP_MS: number;
 export interface SyncRuntimeOptions {
     now: number;
     conflictCount?: number;

package/dist/lib/doctor/checks/sync-runtime.js

@@ -11,6 +11,8 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { currentSyncLogFamily, SYNC_LOG_GENERATIONS, syncLogBasePaths, syncLogGenerationPath, } from "../../../utils/sync-log-sources.js";
 export const SYNC_RUNTIME_WINDOW_MS = 60 * 60_000;
+/** Ignore timing and restart signals until a newly started receiver has settled. */
+export const SYNC_RUNTIME_RESTART_WARMUP_MS = 20 * 60_000;
 const LAG_SECONDS = 15 * 60;
 const LAG_MIN_RECEIPTS = 3;
 const RESTART_MIN_STARTS = 4;
@@ -62,7 +64,9 @@ function lineTimestamp(line) {
 /** Classify the last hour of sync log lines into privacy-safe results. */
 export function analyzeSyncRuntimeLog(lines, options) {
     const since = options.now - SYNC_RUNTIME_WINDOW_MS;
-    let slowReceipts = 0;
+    const contextSince = since - SYNC_RUNTIME_RESTART_WARMUP_MS;
+    const slowReceiptTimes = [];
+    const receiverStartTimes = [];
     let denied = 0;
     let starts = 0;
     let deviceLimited = 0;
@@ -70,35 +74,45 @@ export function analyzeSyncRuntimeLog(lines, options) {
         const time = lineTimestamp(line);
         if (time === null)
             continue;
-        if (!Number.isFinite(time) || time < since || time > options.now)
+        if (!Number.isFinite(time) || time < contextSince || time > options.now)
             continue;
         const stamp = TIMESTAMP.exec(line);
         const rest = stamp ? line.slice(stamp[0].length) : line;
-        if (DEVICE_LIMIT.test(rest))
+        if (time >= since && DEVICE_LIMIT.test(rest))
             deviceLimited += 1;
         const record = parseRecord(rest);
         if (!record)
             continue;
         const event = record.event;
-        if (event === "fanout.receive") {
+        if (event === "receiver.start") {
+            receiverStartTimes.push(time);
+            const settledAt = time + SYNC_RUNTIME_RESTART_WARMUP_MS;
+            // The lower bound preserves a full hour of settled restarts; the upper
+            // bound applies the 20-minute settle rule and excludes only the tail.
+            if (settledAt >= since && settledAt <= options.now)
+                starts += 1;
+        }
+        else if (event === "fanout.receive" && time >= since) {
             const latency = record.latencySeconds;
             if (typeof latency === "number" && latency > LAG_SECONDS)
-                slowReceipts += 1;
-        }
-        else if (event === "receiver.start") {
-            starts += 1;
+                slowReceiptTimes.push(time);
         }
-        if ((record.type === "receiver" || record.type === "error" ||
-            (typeof event === "string" && event.startsWith("receiver."))) &&
+        if (time >= since &&
+            (record.type === "receiver" || record.type === "error" ||
+                (typeof event === "string" && event.startsWith("receiver."))) &&
             PERMISSION.test(JSON.stringify(record.err ?? record.message ?? ""))) {
             denied += 1;
         }
     }
+    // Startup can temporarily expose queued receive latency and restart events
+    // while the receiver is warming its backlog. Only judge receipts outside the
+    // warm-up interval following the most recent preceding start.
+    const slowReceipts = slowReceiptTimes.filter((time) => !receiverStartTimes.some((start) => start <= time && time - start < SYNC_RUNTIME_RESTART_WARMUP_MS)).length;
     const conflicts = options.conflictCount ?? 0;
     const checks = [
         { id: "realtime-lag", reasonCode: "realtime-lag-stuck", failing: slowReceipts >= LAG_MIN_RECEIPTS, count: slowReceipts, label: "incoming changes delayed over 15 minutes" },
         { id: "receiver-permission", reasonCode: "receiver-permission-denied", failing: denied > 0, count: denied, label: "cloud permission refusals" },
-        { id: "runner-restarts", reasonCode: "runner-restart-loop", failing: starts >= RESTART_MIN_STARTS, count: starts, label: "sync runner starts" },
+        { id: "runner-restarts", reasonCode: "runner-restart-loop", failing: starts >= RESTART_MIN_STARTS, count: starts, label: "settled sync runner starts" },
         { id: "device-limit", reasonCode: "device-limit-backoff", failing: deviceLimited > 0, count: deviceLimited, label: "device-limit backoffs" },
         { id: "conflicts", reasonCode: "repeated-conflicts", failing: conflicts >= CONFLICT_MIN_COUNT, count: conflicts, label: "unresolved conflicts" },
     ];
@@ -197,7 +211,7 @@ export function defaultSyncRuntimeResults(now, hqHome = path.join(os.homedir(),
     const logFile = family === null ? paths.desktop : paths[family];
     let lines;
     try {
-        lines = readWindowLines(logFile, options.now - SYNC_RUNTIME_WINDOW_MS, family === "daemon");
+        lines = readWindowLines(logFile, options.now - SYNC_RUNTIME_WINDOW_MS - SYNC_RUNTIME_RESTART_WARMUP_MS, family === "daemon");
     }
     catch {
         return [

package/dist/lib/install/claude-targets.js

@@ -50,9 +50,14 @@ export function hqSkillsSource(hqRoot) {
 /** The exact hook command registered for one event (absolute path, quoted). */
 export function hookCommand(hqRoot, event, target = 'master') {
     const skipInsideRoot = `if [ -d "\${CLAUDE_PROJECT_DIR:-}" ] && [ "\${CLAUDE_PROJECT_DIR}" -ef ${shellQuote(hqRoot)} ]; then exit 0; fi; cwd=$(pwd -P 2>/dev/null || pwd); while [ -n "$cwd" ]; do if [ -f "$cwd/core/core.yaml" ] && [ -f "$cwd/companies/manifest.yaml" ]; then exit 0; fi; [ "$cwd" = / ] && break; cwd=\${cwd%/*}; [ -n "$cwd" ] || cwd=/; done; `;
+    // Many HQ hooks take their root from CLAUDE_PROJECT_DIR (some before HQ_ROOT). In a
+    // foreign project that is the user's folder, so they load no policies and write
+    // workspace/ state there. Point both at HQ; the payload's cwd still names the
+    // folder the session is working in.
+    const rootEnv = `HQ_ROOT=${shellQuote(hqRoot)} CLAUDE_PROJECT_DIR=${shellQuote(hqRoot)} `;
     if (target === 'shim')
-        return `${skipInsideRoot}exec /bin/sh ${shellQuote(shimPath(hqRoot))} ${shellQuote(event)} --runtime claude`;
-    return `${skipInsideRoot}BASH_ENV=/dev/null exec bash ${shellQuote(masterHookPath(hqRoot))} ${shellQuote(event)}`;
+        return `${skipInsideRoot}${rootEnv}exec /bin/sh ${shellQuote(shimPath(hqRoot))} ${shellQuote(event)} --runtime claude`;
+    return `${skipInsideRoot}${rootEnv}BASH_ENV=/dev/null exec bash ${shellQuote(masterHookPath(hqRoot))} ${shellQuote(event)}`;
 }
 /** Quote one argument for the POSIX shell used by Claude Code command hooks. */
 function shellQuote(value) {

package/dist/lib/install/codex-targets.d.ts

@@ -30,6 +30,12 @@ type Doc = Record<string, unknown>;
 export declare function addCodexHooks(doc: Doc, hqRoot: string, target?: HookTarget): Doc;
 /** Remove only HQ adapter entries; drop containers this left empty. */
 export declare function removeCodexHooks(doc: Doc, hqRoot: string): Doc;
+/**
+ * Codex trust keys (`<hooks.json>:<snake_event>:<group>:<hook>`) for the HQ
+ * entries in a hooks.json document. Foreign entries are left out so install
+ * never trusts a hook the user added themselves.
+ */
+export declare function codexHookTrustKeys(doc: Doc, hooksJsonPath: string, hqRoot: string): string[];
 export declare function hasAllCodexHooks(doc: Doc, hqRoot: string, target?: HookTarget): boolean;
 export type LegacySkillsMirror = {
     kind: 'absent';

package/dist/lib/install/codex-targets.js

@@ -155,6 +155,31 @@ export function removeCodexHooks(doc, hqRoot) {
         next.hooks = hooks;
     return next;
 }
+/**
+ * Codex trust keys (`<hooks.json>:<snake_event>:<group>:<hook>`) for the HQ
+ * entries in a hooks.json document. Foreign entries are left out so install
+ * never trusts a hook the user added themselves.
+ */
+export function codexHookTrustKeys(doc, hooksJsonPath, hqRoot) {
+    const hooks = doc.hooks;
+    if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks))
+        return [];
+    const keys = [];
+    for (const [event, value] of Object.entries(hooks)) {
+        if (!Array.isArray(value))
+            continue;
+        const snake = event.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+        value.forEach((group, g) => {
+            if (!group || !Array.isArray(group.hooks))
+                return;
+            group.hooks.forEach((entry, h) => {
+                if (isAdapterEntry(entry, hqRoot))
+                    keys.push(`${hooksJsonPath}:${snake}:${g}:${h}`);
+            });
+        });
+    }
+    return keys;
+}
 export function hasAllCodexHooks(doc, hqRoot, target = 'master') {
     return addCodexHooks(doc, hqRoot, target) === doc;
 }

package/dist/utils/hook-trust.d.ts

@@ -53,6 +53,13 @@ export interface RuntimeHookTrustResult {
 export declare function createCodexAppServerClient(cwd: string, executable?: string, args?: string[]): Promise<CodexRpcClient>;
 /** Trust only hooks declared by this HQ root's project `.codex/` layer. */
 export declare function trustCodexProjectHooks(hqRoot: string, deps?: HookTrustDependencies): Promise<RuntimeHookTrustResult>;
+/**
+ * Trust the user-scope hooks `hq install --global --runtime codex` registered
+ * in ~/.codex/hooks.json, named by their Codex keys (`<file>:<event>:<group>:<hook>`).
+ * Codex skips untrusted hooks, so without this HQ stays inert in every session
+ * outside the HQ folder. Other hooks in the same file are never trusted here.
+ */
+export declare function trustCodexUserHooks(cwd: string, keys: readonly string[], deps?: HookTrustDependencies): Promise<RuntimeHookTrustResult>;
 /**
  * Mark this HQ root as a trusted Claude Code workspace.
  *

package/dist/utils/hook-trust.js

@@ -181,10 +181,37 @@ export async function trustCodexProjectHooks(hqRoot, deps = DEFAULT_DEPS) {
     if (!fs.existsSync(path.join(hqRoot, '.codex'))) {
         return { runtime: 'codex', status: 'skipped', trusted: 0, reason: 'project .codex layer absent' };
     }
+    return trustCodexHooks(hqRoot, deps, (hooks) => {
+        const projectHooks = hqProjectHooks(hqRoot, hooks);
+        return projectHooks.length === 0
+            ? { skip: 'no HQ project hooks discovered' }
+            : { hooks: projectHooks };
+    });
+}
+/**
+ * Trust the user-scope hooks `hq install --global --runtime codex` registered
+ * in ~/.codex/hooks.json, named by their Codex keys (`<file>:<event>:<group>:<hook>`).
+ * Codex skips untrusted hooks, so without this HQ stays inert in every session
+ * outside the HQ folder. Other hooks in the same file are never trusted here.
+ */
+export async function trustCodexUserHooks(cwd, keys, deps = DEFAULT_DEPS) {
+    if (keys.length === 0) {
+        return { runtime: 'codex', status: 'skipped', trusted: 0, reason: 'no HQ user hooks registered' };
+    }
+    return trustCodexHooks(cwd, deps, (hooks) => {
+        const byKey = new Map(hooks.filter((hook) => hook.source === 'user' && !hook.isManaged).map((hook) => [hook.key, hook]));
+        const missing = keys.filter((key) => !byKey.has(key));
+        if (missing.length > 0)
+            return { fail: `Codex did not discover: ${missing.join(', ')}` };
+        return { hooks: keys.map((key) => byKey.get(key)) };
+    });
+}
+/** List hooks for `cwd`, trust and enable the selected ones, then verify. */
+async function trustCodexHooks(cwd, deps, select) {
     let client;
     try {
-        client = await deps.createCodexClient(hqRoot);
-        const discovered = hooksFromListResponse(await client.request('hooks/list', { cwds: [hqRoot] }));
+        client = await deps.createCodexClient(cwd);
+        const discovered = hooksFromListResponse(await client.request('hooks/list', { cwds: [cwd] }));
         if (discovered.errors.length > 0) {
             return {
                 runtime: 'codex',
@@ -193,19 +220,18 @@ export async function trustCodexProjectHooks(hqRoot, deps = DEFAULT_DEPS) {
                 reason: discovered.errors.join('; '),
             };
         }
-        const projectHooks = hqProjectHooks(hqRoot, discovered.hooks);
-        if (projectHooks.length === 0) {
-            return {
-                runtime: 'codex',
-                status: 'skipped',
-                trusted: 0,
-                reason: 'no HQ project hooks discovered',
-            };
+        const selection = select(discovered.hooks);
+        if ('skip' in selection) {
+            return { runtime: 'codex', status: 'skipped', trusted: 0, reason: selection.skip };
+        }
+        if ('fail' in selection) {
+            return { runtime: 'codex', status: 'failed', trusted: 0, reason: selection.fail };
         }
-        // Converge every HQ project hook to trusted AND enabled. A hook that is
+        const selected = selection.hooks;
+        // Converge every selected HQ hook to trusted AND enabled. A hook that is
         // already trusted but was toggled off would otherwise silently stay
-        // disabled forever — reindex is the convergence point, so it re-enables.
-        const pending = projectHooks.filter((hook) => hook.trustStatus === 'untrusted' || hook.trustStatus === 'modified' || !hook.enabled);
+        // disabled forever; reindex and install are the convergence points.
+        const pending = selected.filter((hook) => hook.trustStatus === 'untrusted' || hook.trustStatus === 'modified' || !hook.enabled);
         if (pending.length === 0) {
             return { runtime: 'codex', status: 'unchanged', trusted: 0 };
         }
@@ -220,7 +246,7 @@ export async function trustCodexProjectHooks(hqRoot, deps = DEFAULT_DEPS) {
             edits: [{ keyPath: 'hooks.state', value: state, mergeStrategy: 'upsert' }],
             reloadUserConfig: true,
         });
-        const verified = hooksFromListResponse(await client.request('hooks/list', { cwds: [hqRoot] }));
+        const verified = hooksFromListResponse(await client.request('hooks/list', { cwds: [cwd] }));
         const verifiedByKey = new Map(verified.hooks.map((hook) => [hook.key, hook]));
         const stillPending = pending
             .filter((hook) => {

package/package.json

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