@indigoai-us/hq-cli 5.345.45 → 5.345.47

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [5.345.47] — 2026-10-08
+- `hq files share` now shows the server's reason when a private folder conflicts with its shared folder glob, for example that the glob still has grants or that only its creator or a company admin can replace it.
+- After `hq install --global`, unauthenticated `claude` and `codex` commands show provider-specific sign-in instructions; Codex HTTP 401 transport text is kept in the HQ log.
+- The CLI now stops before updating when a separate pnpm global install shadows the running `hq` command on PATH, preventing an update from modifying the wrong install tree.
+- Keep lanes resumable when a provider quota refusal includes a known reset, and retry them after reset when quota account failover is enabled. Record generic rate limits separately from account quotas, billing refusals, and auth failures.
+- Windows delegate send parity tests now budget the Bash fallback and reuse the runtime probe.
+
+## [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/files.js

@@ -835,7 +835,10 @@ async function runDirectGrant(params) {
             console.error(chalk.red("ACL record not found — the prefix may not have an ACL yet"));
         }
         else if (res.status === 409 && body.code === "ACL_PATTERN_CONFLICT") {
-            console.error(chalk.red(formatAclPatternConflict(canonicalPrefix, body.message)));
+            // hq-pro sends the specific reason (the sibling still has grants, or only
+            // its creator or an admin may replace it) in `error`; older servers used
+            // `message`. Show whichever is present instead of dropping it.
+            console.error(chalk.red(formatAclPatternConflict(canonicalPrefix, body.message ?? body.error)));
         }
         else if (res.status === 409) {
             console.error(chalk.red("Concurrent modification — please retry"));

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). */
@@ -21,6 +22,8 @@ export interface GlobalInstallOptions {
     via?: 'direct' | 'plugin';
     /** Local Claude Code marketplace directory (or HQ_CLAUDE_PLUGIN_MARKETPLACE). */
     marketplaceDir?: string;
+    /** Install the provider PATH wrappers after the hq-anywhere flag check. */
+    installProviderWrappers?: boolean;
     /** GitHub repository for the published HQ plugin marketplace. */
     marketplaceRepository?: string;
     /** Test seam for the Claude Code CLI; production uses `claude`. */
@@ -78,6 +81,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,12 @@ 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 { assertProviderWrappersInstallable, installProviderWrappers, providerWrapperInstallPaths, removeProviderWrappers } from '../lib/install/provider-wrappers.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) {
@@ -347,7 +349,14 @@ export function installGlobalClaude(opts) {
     const env = opts.env ?? process.env;
     const log = opts.log ?? ((l) => console.log(l));
     const hqRoot = opts.hqRoot;
+    const providerBin = path.join(home, '.hq', 'bin');
+    // The wrappers are /bin/sh scripts reached through POSIX startup files, so a
+    // Windows shell would never pick them up. Skip them until a native shim exists.
+    const providerWrappersEnabled = process.platform !== 'win32'
+        && (opts.installProviderWrappers ?? isAnywhereEnabled(home, env));
     assertHqRoot(hqRoot);
+    if (providerWrappersEnabled)
+        assertProviderWrappersInstallable(providerBin);
     const t = claudeTargets(home);
     const prior = readState(t);
     const pluginSource = opts.via === 'plugin' ? resolveClaudePluginSource(opts.marketplaceDir, env, opts.marketplaceRepository) : undefined;
@@ -428,6 +437,8 @@ export function installGlobalClaude(opts) {
     if (pluginSource)
         touched.push(t.settingsJson);
     touched.push(regFile, t.stateFile);
+    if (providerWrappersEnabled)
+        touched.push(...providerWrapperInstallPaths(home));
     if (opts.dryRun) {
         log(`hq install --global --runtime claude --dry-run (HQ root ${hqRoot})`);
         log('Would write:');
@@ -559,6 +570,8 @@ export function installGlobalClaude(opts) {
         seeded: [...new Set([...(prior?.seeded ?? []), ...ownedSeeded])].sort(),
     };
     writeFileAtomic(t.stateFile, `${JSON.stringify(state, null, 2)}\n`);
+    if (providerWrappersEnabled)
+        installProviderWrappers(providerBin, home);
     log(`HQ installed for Claude Code from ${hqRoot}.`);
     log(`  skills linked: ${skills.link.length} new, ${skills.already.length} already present, ${skills.skipped.length} skipped`);
     reportSkippedSkills(skills, log, false);
@@ -633,6 +646,9 @@ export function uninstallGlobalClaude(opts = {}) {
     }
     const pointer = readOrNull(t.hqPointer);
     const codexStillInstalled = fs.existsSync(codexTargets(home).stateFile);
+    const providerBin = path.join(home, '.hq', 'bin');
+    if (!codexStillInstalled)
+        touched.push(path.join(providerBin, 'claude'), path.join(providerBin, 'codex'));
     const pointerOwned = !codexStillInstalled && pointer !== null && pointer.trim() === hqRoot;
     if (pointerOwned)
         touched.push(t.hqPointer);
@@ -655,6 +671,8 @@ export function uninstallGlobalClaude(opts = {}) {
     if (pluginSource && state?.plugin?.marketplaceAdded) {
         runClaude(['marketplace', 'remove', '--scope', 'user', pluginSource.marketplaceName], home, env);
     }
+    if (!codexStillInstalled)
+        removeProviderWrappers(providerBin);
     unregisterClaudeServer({ name: HQ_MCP_SERVER_NAME, pack: HQ_ANYWHERE_PACK, env: { home } });
     if (fs.existsSync(t.settingsJson)) {
         writeConfigAtomic({
@@ -738,7 +756,14 @@ export function installGlobalCodex(opts) {
     const env = opts.env ?? process.env;
     const log = opts.log ?? ((l) => console.log(l));
     const hqRoot = opts.hqRoot;
+    const providerBin = path.join(home, '.hq', 'bin');
+    // The wrappers are /bin/sh scripts reached through POSIX startup files, so a
+    // Windows shell would never pick them up. Skip them until a native shim exists.
+    const providerWrappersEnabled = process.platform !== 'win32'
+        && (opts.installProviderWrappers ?? isAnywhereEnabled(home, env));
     assertCodexHqRoot(hqRoot);
+    if (providerWrappersEnabled)
+        assertProviderWrappersInstallable(providerBin);
     if (!isCodexInstalled({ home })) {
         throw Object.assign(new Error(`Codex is not installed (${path.join(home, '.codex')} is missing).`), {
             expected: true,
@@ -792,6 +817,8 @@ export function installGlobalCodex(opts) {
     if (tomlNext !== tomlDoc || legacyPackServerPresent)
         touched.push(t.configToml);
     touched.push(regFile, t.stateFile);
+    if (providerWrappersEnabled)
+        touched.push(...providerWrapperInstallPaths(home));
     if (opts.dryRun) {
         log(`hq install --global --runtime codex --dry-run (HQ root ${hqRoot})`);
         log('Would write:');
@@ -874,6 +901,8 @@ export function installGlobalCodex(opts) {
         seeded: [...new Set([...(prior?.seeded ?? []), ...ownedSeeded])].sort(),
     };
     writeFileAtomic(t.stateFile, `${JSON.stringify(state, null, 2)}\n`);
+    if (providerWrappersEnabled)
+        installProviderWrappers(providerBin, home);
     log(`HQ installed for Codex from ${hqRoot}.`);
     log(`  skills linked: ${skills.link.length} new, ${skills.already.length} already present, ${skills.skipped.length} skipped`);
     reportSkippedSkills(skills, log, false);
@@ -894,8 +923,11 @@ export function uninstallGlobalCodex(opts = {}) {
         throw new Error('No HQ global install found (no install state and no ~/.hq/root).');
     const regFile = opts.registryFile ?? registryFile(registryDir(home, env));
     const claudeStillInstalled = fs.existsSync(claudeTargets(home).stateFile);
+    const providerBin = path.join(home, '.hq', 'bin');
     const packStillInstalled = fs.existsSync(path.join(hqRoot, 'core', 'packages', 'hq-anywhere', 'package.yaml'));
     const touched = [];
+    if (!claudeStillInstalled)
+        touched.push(path.join(providerBin, 'claude'), path.join(providerBin, 'codex'));
     const tomlDoc = readConfigDoc(t.configToml, codexConfigFormat).doc;
     const servers = tomlDoc.value.mcp_servers;
     if (!packStillInstalled && servers?.[HQ_MCP_SERVER_NAME]?._hqPack === HQ_ANYWHERE_PACK)
@@ -953,6 +985,8 @@ export function uninstallGlobalCodex(opts = {}) {
     }
     if (!packStillInstalled)
         unregisterCodexServer({ name: HQ_MCP_SERVER_NAME, pack: HQ_ANYWHERE_PACK, env: { home } });
+    if (!claudeStillInstalled)
+        removeProviderWrappers(providerBin);
     // Removal re-serializes the TOML (dropping comments). When what is left equals
     // the pre-install document, put the original bytes back.
     const tomlOriginal = state?.configToml.original ?? null;
@@ -1058,11 +1092,11 @@ export function resolveInstallRoot(explicit, options = {}) {
 export async function runInstallGlobal(opts) {
     const runtime = assertRuntime(opts.runtime);
     const env = opts.env ?? process.env;
+    const enabled = await anywhereRuntimeAllowed(env, {
+        ...(opts.personSettingReader ? { readSetting: opts.personSettingReader } : {}),
+        onError: (name) => (opts.log ?? console.log)(`HQ Anywhere person setting unavailable (${name}); access remains off.`),
+    });
     if (runtime === 'chatgpt' || runtime === 'grok' || opts.dryRun) {
-        const enabled = await anywhereRuntimeAllowed(env, {
-            ...(opts.personSettingReader ? { readSetting: opts.personSettingReader } : {}),
-            onError: (name) => (opts.log ?? console.log)(`HQ Anywhere person setting unavailable (${name}); access remains off.`),
-        });
         if (!enabled)
             throw new AnywhereRuntimeDisabledError();
         if (runtime === 'chatgpt' || runtime === 'grok') {
@@ -1074,16 +1108,38 @@ 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,
         marketplaceDir: opts.marketplaceDir,
         marketplaceRepository: opts.marketplaceRepository,
+        installProviderWrappers: enabled,
         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';