@indigoai-us/hq-cli 5.345.17 → 5.345.19

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [5.345.19] — 2026-10-06
+- Fix installation and updates of the published hq-anywhere pack through its built-in alias while continuing to reject reserved names from user-supplied remote sources.
+- With `hq-anywhere-runtime` enabled, hqd now starts on Windows through the user-scoped named-pipe host and refuses service only when secure pipe setup or ACL verification fails. `hq doctor` describes unsafe named-pipe startup as an ACL setup failure and recommends the daemon install or restart action based on service state.
+
+## [5.345.18] — 2026-10-06
+- Git Bash forwarders now keep slash commands intact and convert file path arguments that hq needs on Windows.
+- Lane placement and Claude account-balance refusals now show the requested placement, actual host, balance host when different, and the model values and sources used for an unavailable-account decision.
+
 ## [5.345.17] — 2026-10-06
 - Git Bash forwarders now keep slash commands intact and convert file path arguments that hq needs on Windows.
 

package/assets/scaffold/core/scripts/hq-delegate-grant.sh

@@ -35,16 +35,23 @@ die()   { echo "hq-delegate-grant: $*" >&2; exit 1; }
 
 command -v jq >/dev/null 2>&1 || die "jq is required but not installed"
 
-# jq.exe's binary mode avoids CRT newline conversion without changing real CR bytes.
+# jq.exe on MSYS may use CRT text mode unless --binary is supported.
 case "${OSTYPE:-}:${MSYSTEM:-}" in
   msys*:*|*:MINGW*)
     jq() {
-      local stdout_file stderr_file status
+      local stdout_file stderr_file status binary_supported
       stdout_file="$(mktemp)" || return $?
       stderr_file="$(mktemp)" || { status=$?; rm -f "$stdout_file"; return "$status"; }
-      if command jq --binary "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
-      command sed -b 's/\r$//' "$stdout_file"
-      command sed -b 's/\r$//' "$stderr_file" >&2
+      if command jq --binary -n 'null' >/dev/null 2>&1; then binary_supported=1; else binary_supported=0; fi
+      if [[ "$binary_supported" == 1 ]]; then
+        if command jq --binary "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
+        command cat "$stdout_file"
+        command cat "$stderr_file" >&2
+      else
+        if command jq "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
+        command sed -b 's/\r$//' "$stdout_file"
+        command sed -b 's/\r$//' "$stderr_file" >&2
+      fi
       rm -f "$stdout_file" "$stderr_file"
       return "$status"
     }

package/assets/scaffold/core/scripts/hq-delegate-send.sh

@@ -40,16 +40,23 @@ die()   { echo "hq-delegate-send: $*" >&2; exit 1; }
 
 command -v jq >/dev/null 2>&1 || die "jq is required but not installed"
 
-# jq.exe's binary mode avoids CRT newline conversion without changing real CR bytes.
+# jq.exe on MSYS may use CRT text mode unless --binary is supported.
 case "${OSTYPE:-}:${MSYSTEM:-}" in
   msys*:*|*:MINGW*)
     jq() {
-      local stdout_file stderr_file status
+      local stdout_file stderr_file status binary_supported
       stdout_file="$(mktemp)" || return $?
       stderr_file="$(mktemp)" || { status=$?; rm -f "$stdout_file"; return "$status"; }
-      if command jq --binary "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
-      command sed -b 's/\r$//' "$stdout_file"
-      command sed -b 's/\r$//' "$stderr_file" >&2
+      if command jq --binary -n 'null' >/dev/null 2>&1; then binary_supported=1; else binary_supported=0; fi
+      if [[ "$binary_supported" == 1 ]]; then
+        if command jq --binary "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
+        command cat "$stdout_file"
+        command cat "$stderr_file" >&2
+      else
+        if command jq "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
+        command sed -b 's/\r$//' "$stdout_file"
+        command sed -b 's/\r$//' "$stderr_file" >&2
+      fi
       rm -f "$stdout_file" "$stderr_file"
       return "$status"
     }

package/assets/scaffold/core/scripts/hq-job-probe.sh

@@ -120,16 +120,23 @@ done
 command -v yq >/dev/null 2>&1 || die "yq is required (mikefarah/yq)"
 command -v jq >/dev/null 2>&1 || die "jq is required"
 
-# jq.exe's binary mode avoids CRT newline conversion without changing real CR bytes.
+# jq.exe on MSYS may use CRT text mode unless --binary is supported.
 case "${OSTYPE:-}:${MSYSTEM:-}" in
   msys*:*|*:MINGW*)
     jq() {
-      local stdout_file stderr_file status
+      local stdout_file stderr_file status binary_supported
       stdout_file="$(mktemp)" || return $?
       stderr_file="$(mktemp)" || { status=$?; rm -f "$stdout_file"; return "$status"; }
-      if command jq --binary "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
-      command sed -b 's/\r$//' "$stdout_file"
-      command sed -b 's/\r$//' "$stderr_file" >&2
+      if command jq --binary -n 'null' >/dev/null 2>&1; then binary_supported=1; else binary_supported=0; fi
+      if [[ "$binary_supported" == 1 ]]; then
+        if command jq --binary "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
+        command cat "$stdout_file"
+        command cat "$stderr_file" >&2
+      else
+        if command jq "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
+        command sed -b 's/\r$//' "$stdout_file"
+        command sed -b 's/\r$//' "$stderr_file" >&2
+      fi
       rm -f "$stdout_file" "$stderr_file"
       return "$status"
     }

package/assets/scaffold/core/scripts/jobs-validate.sh

@@ -40,16 +40,23 @@ command -v jq >/dev/null 2>&1 || {
   exit 2
 }
 
-# jq.exe's binary mode avoids CRT newline conversion without changing real CR bytes.
+# jq.exe on MSYS may use CRT text mode unless --binary is supported.
 case "${OSTYPE:-}:${MSYSTEM:-}" in
   msys*:*|*:MINGW*)
     jq() {
-      local stdout_file stderr_file status
+      local stdout_file stderr_file status binary_supported
       stdout_file="$(mktemp)" || return $?
       stderr_file="$(mktemp)" || { status=$?; rm -f "$stdout_file"; return "$status"; }
-      if command jq --binary "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
-      command sed -b 's/\r$//' "$stdout_file"
-      command sed -b 's/\r$//' "$stderr_file" >&2
+      if command jq --binary -n 'null' >/dev/null 2>&1; then binary_supported=1; else binary_supported=0; fi
+      if [[ "$binary_supported" == 1 ]]; then
+        if command jq --binary "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
+        command cat "$stdout_file"
+        command cat "$stderr_file" >&2
+      else
+        if command jq "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
+        command sed -b 's/\r$//' "$stdout_file"
+        command sed -b 's/\r$//' "$stderr_file" >&2
+      fi
       rm -f "$stdout_file" "$stderr_file"
       return "$status"
     }

package/assets/scaffold/core/scripts/session-journal.sh

@@ -128,16 +128,65 @@ resolve_session_key() {
 }
 
 # Read-modify-write on the counter must not interleave across concurrent tasks.
+reclaim_stale_counter_lock() {
+  local lockdir="$1" owner_pid current_owner claim stale_dir suffix=0
+  owner_pid="$(cat "$lockdir/pid" 2>/dev/null || true)"
+  case "$owner_pid" in ''|*[!0-9]*) return 1 ;; esac
+  [ "$owner_pid" -gt 1 ] 2>/dev/null || return 1
+  kill -0 "$owner_pid" 2>/dev/null && return 1
+
+  claim="${lockdir}.reclaim"
+  mkdir "$claim" 2>/dev/null || return 1
+  if ! printf '%s\n' "$$" > "$claim/pid" 2>/dev/null; then
+    rmdir "$claim" 2>/dev/null || true
+    return 1
+  fi
+
+  current_owner="$(cat "$lockdir/pid" 2>/dev/null || true)"
+  if [ "$current_owner" = "$owner_pid" ] && ! kill -0 "$owner_pid" 2>/dev/null; then
+    stale_dir="${lockdir}.stale.$$.$RANDOM"
+    while [ -e "$stale_dir" ]; do
+      suffix=$((suffix + 1))
+      stale_dir="${lockdir}.stale.$$.$RANDOM.$suffix"
+    done
+    if mv "$lockdir" "$stale_dir" 2>/dev/null; then
+      rm -rf "$stale_dir" 2>/dev/null || true
+      rm -rf "$claim" 2>/dev/null || true
+      return 0
+    fi
+  fi
+
+  rm -rf "$claim" 2>/dev/null || true
+  return 1
+}
+
 with_counter_lock() {
   local lockdir="$1"; shift
-  local i=0
-  while ! mkdir "$lockdir" 2>/dev/null; do
+  local i=0 acquired=0 rc=0 tries="${HQ_JOURNAL_COUNTER_LOCK_TRIES:-250}"
+  case "$tries" in ''|*[!0-9]*) tries=250 ;; esac
+  while [ "$i" -lt "$tries" ]; do
+    if mkdir "$lockdir" 2>/dev/null; then
+      acquired=1
+      if ! printf '%s\n' "$$" > "$lockdir/pid" 2>/dev/null; then
+        rm -rf "$lockdir" 2>/dev/null || true
+        return 0
+      fi
+      break
+    fi
+    reclaim_stale_counter_lock "$lockdir" && continue
     i=$((i + 1))
-    [ "$i" -ge 50 ] && break
-    sleep 0.02 2>/dev/null || sleep 1
+    [ "$i" -ge "$tries" ] || sleep 0.02 2>/dev/null || sleep 1
   done
-  "$@"
-  rmdir "$lockdir" 2>/dev/null || true
+  if [ "$acquired" -ne 1 ]; then
+    warn "tool-counter: lock remained busy; skipped update"
+    return 0
+  fi
+
+  "$@" || rc=$?
+  if [ "$(cat "$lockdir/pid" 2>/dev/null || true)" = "$$" ]; then
+    rm -rf "$lockdir" 2>/dev/null || true
+  fi
+  return "$rc"
 }
 
 counter_read_raw() {

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

@@ -210,7 +210,7 @@ function runToolCounter(root, action, sessionArg, env, now, writers) {
                 fs.writeFileSync(counter, `${readCounter(counter) + 1}\n`);
             }
             catch (error) {
-                reportDirectoryWriteFailure(error, 346);
+                reportDirectoryWriteFailure(error, 395);
             }
         });
     }
@@ -223,7 +223,7 @@ function runToolCounter(root, action, sessionArg, env, now, writers) {
                 fs.writeFileSync(counter, "0\n");
             }
             catch (error) {
-                reportDirectoryWriteFailure(error, 354);
+                reportDirectoryWriteFailure(error, 403);
             }
         });
     }

package/dist/commands/lanes-accounts.js

@@ -197,6 +197,7 @@ export function createLaneAccountsHandlers(deps) {
                     target_host: host.capacity.host,
                     error: isLanesError(err) ? err.error : "claude_account_balance_selection_failed",
                     message: dispatchErrorMessage(err),
+                    ...(isLanesError(err) ? { details: err.details } : {}),
                 };
             }
         });

package/dist/commands/lanes.js

@@ -3472,14 +3472,20 @@ async function runCreate(ctx, opts) {
         const targetHost = placementBalanceHostOverride ?? placementHostOverride ?? (outpostId !== undefined
             ? { kind: "outpost", id: outpostId }
             : laneHostFromCtx(ctx));
+        const actualTargetHost = placementHostOverride ?? (outpostId !== undefined
+            ? { kind: "outpost", id: outpostId }
+            : { kind: "local", id: ctx.hostname() });
         balanceTargetHost = targetHost;
         balanceHostLoad = await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config);
         const selected = selectClaudeAccount({
             hosts: balanceHostLoad.snapshots,
             targetHost,
+            actualTargetHost,
+            requestedPlacement: placementToApply ?? null,
             config,
             quotaState: loadQuotaState(hqRoot),
             ...(modelToValidate !== undefined ? { model: modelToValidate } : {}),
+            requestedModelSource: cliModel !== undefined ? "flag" : profileModel !== undefined ? "profile" : "default",
             recentUsageEnabled: await readClaudeAccountBalanceSignalsEnabled(ctx, company ?? undefined),
             now: ctx.now(),
             ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
@@ -3523,12 +3529,18 @@ async function runCreate(ctx, opts) {
                 const hosts = balanceHostLoad.snapshots.map((host) => host.capacity.host.kind === localHost.kind && host.capacity.host.id === localHost.id
                     ? refreshedLocal
                     : host);
+                const actualTargetHostForPersist = placementHostOverride ?? (outpostId !== undefined
+                    ? { kind: "outpost", id: outpostId }
+                    : { kind: "local", id: ctx.hostname() });
                 const selected = selectClaudeAccount({
                     hosts,
                     targetHost: balanceTargetHost,
+                    actualTargetHost: actualTargetHostForPersist,
+                    requestedPlacement: placementToApply ?? null,
                     config,
                     quotaState: loadQuotaState(hqRoot),
                     ...(modelToValidate !== undefined ? { model: modelToValidate } : {}),
+                    requestedModelSource: cliModel !== undefined ? "flag" : profileModel !== undefined ? "profile" : "default",
                     recentUsageEnabled: await readClaudeAccountBalanceSignalsEnabled(ctx, company ?? undefined),
                     now: ctx.now(),
                     ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
@@ -6802,6 +6814,11 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
     // Repair keeps an account-derived model pinned through the move; plain
     // automatic rebalancing resolves each candidate's account default itself.
     const selectionModel = preservedModel ?? pinnedModel ?? profileModel;
+    const selectionModelSource = preservedModel !== undefined || pinnedModel !== undefined
+        ? "lane"
+        : profileModel !== undefined
+            ? "profile"
+            : "default";
     const model = resolveLaneModel({
         cliModel: pinnedModel,
         profileModel,
@@ -6829,11 +6846,14 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
     const selectionInput = {
         hosts: balanceHosts.snapshots,
         targetHost: lane.host,
+        actualTargetHost: lane.host,
+        requestedPlacement: null,
         config,
         quotaState: loadQuotaState(hqRoot),
         recentUsageEnabled: await readClaudeAccountBalanceSignalsEnabled(ctx, lane.company ?? undefined),
         now: ctx.now(),
         ...(selectionModel !== undefined ? { model: selectionModel } : {}),
+        requestedModelSource: selectionModelSource,
         unavailableHosts: balanceHosts.unavailableHosts,
     };
     let selected;

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

@@ -46,6 +46,8 @@ export interface ResolveLatestOptions {
 export type Transport = 'npm' | 'git' | 'local' | 'marketplace';
 /** Prefix that routes a source through the HQ marketplace transport (US-006). */
 export declare const MARKETPLACE_PREFIX = "marketplace:";
+/** Pinned source allowed to claim the reserved hq-anywhere pack name via its CLI alias. */
+export declare const PINNED_HQ_ANYWHERE_SOURCE = "github:indigoai-us/hq-packages#packages/hq-pack-hq-anywhere";
 export declare function classify(source: string): Transport;
 /**
  * Parse a git source's '#<...>' fragment into { url, subpath, ref }.
@@ -411,6 +413,8 @@ export declare function runScanPackages(hqRoot: string, opts?: {
 }): void;
 export interface InstallPackOptions {
     allowHooks?: boolean;
+    /** Internal grant used only by the @indigoai-us/hq-anywhere CLI alias. */
+    allowPinnedHqAnywhereName?: true;
     /** Company context for online authorization of install-time MCP secret refs. */
     company?: string;
     /**

package/dist/commands/pack-install.js

@@ -112,6 +112,8 @@ async function latestWithDiskCache(cacheKey, opts, refresh) {
 }
 /** Prefix that routes a source through the HQ marketplace transport (US-006). */
 export const MARKETPLACE_PREFIX = 'marketplace:';
+/** Pinned source allowed to claim the reserved hq-anywhere pack name via its CLI alias. */
+export const PINNED_HQ_ANYWHERE_SOURCE = 'github:indigoai-us/hq-packages#packages/hq-pack-hq-anywhere';
 export function classify(source) {
     // US-006: marketplace:<slug>[@version] is recognized BEFORE the legacy
     // registry fallback and ahead of every other transport. The slug is resolved
@@ -1727,10 +1729,16 @@ async function installPackWithoutLease(source, opts) {
                 });
                 break;
         }
-        // Only an explicit local directory source may use the reserved bundled
-        // pack name. Publisher is self-declared package metadata and is not proof
-        // of registry identity, so remote transports never receive this exception.
-        const pkg = validateManifest(fetched.payloadDir, hqVersion, { allowReservedName: transport === 'local' });
+        // Local directories retain their existing reserved-name behavior. For
+        // remote sources, publisher is self-declared and cannot prove registry
+        // identity, so accept the reserved name only when the top-level CLI alias
+        // supplied its internal grant for the exact pinned GitHub source.
+        const allowPinnedAliasName = transport === 'git' &&
+            source === PINNED_HQ_ANYWHERE_SOURCE &&
+            opts.allowPinnedHqAnywhereName === true;
+        const pkg = validateManifest(fetched.payloadDir, hqVersion, {
+            allowReservedName: transport === 'local' || allowPinnedAliasName,
+        });
         // M0 — pack-to-pack dependency pre-flight. Runs BEFORE any prompts or writes
         // so a missing/unsatisfied `requires.packs` aborts with no partial state, and
         // before we bother the operator with hook/MCP trust prompts for a pack that

package/dist/commands/packs.js

@@ -26,7 +26,7 @@ import chalk from 'chalk';
 import semverSatisfies from 'semver/functions/satisfies.js';
 import { findHqRoot } from '../utils/manifest.js';
 import { resolveHqRoot as resolveDetectedHqRoot } from './doctor.js';
-import { classify, resolveLatest, resolveLatestMarketplace, runScanPackages, installPack, } from './pack-install.js';
+import { classify, PINNED_HQ_ANYWHERE_SOURCE, resolveLatest, resolveLatestMarketplace, runScanPackages, installPack, } from './pack-install.js';
 import { contributionLinks, linkStatus, listInstalledPacks, findDependentPacks, readPackManifest, unwirePack, unwirePackMcp, readHqVersion, readRecommendedPackages, packagesDir, } from '../utils/pack-contributions.js';
 import { syncCodexPackHooks, syncCodexPackSkills } from '../lib/install/codex-pack-contributions.js';
 function resolveRoot(opts) {
@@ -267,6 +267,9 @@ async function runUpdate(name, opts) {
                     allowMcp: opts.yes || opts.allowMcp,
                     followBranch: opts.branch,
                     quiet: wantsJson(opts),
+                    ...(pname === 'hq-anywhere' && source === PINNED_HQ_ANYWHERE_SOURCE
+                        ? { allowPinnedHqAnywhereName: true }
+                        : {}),
                 });
             }
             finally {

package/dist/commands/pkg-install.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { peekHqApiKey, requireApiKeyCapability, } from '../utils/resolve-vault-credential.js';
-import { MARKETPLACE_PREFIX, installPack, sourceMatchesPackPattern, } from './pack-install.js';
+import { MARKETPLACE_PREFIX, PINNED_HQ_ANYWHERE_SOURCE, installPack, sourceMatchesPackPattern, } from './pack-install.js';
 import { anywhereRuntimeEnabled } from './anywhere-runtime-flag.js';
 /**
  * True when `source` installs through the marketplace — an explicit
@@ -99,11 +99,12 @@ export function registerPackageInstallCommand(parent) {
                     console.error(chalk.red('Install failed:'), 'HQ Anywhere installation is disabled by the hq-anywhere-runtime flag.');
                     process.exit(1);
                 }
-                await installPack('github:indigoai-us/hq-packages#packages/hq-pack-hq-anywhere', {
+                await installPack(PINNED_HQ_ANYWHERE_SOURCE, {
                     company: opts.company,
                     allowHooks: opts.allowHooks,
                     allowMcp: opts.allowMcp,
                     followBranch: opts.branch,
+                    allowPinnedHqAnywhereName: true,
                 });
                 return;
             }

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

@@ -21,8 +21,8 @@ export interface DaemonLockConflictOutcome {
 }
 /** Preserve the legacy lock failure unless Anywhere explicitly enables the no-op behavior. */
 export declare function daemonLockConflictOutcome(lock: DaemonLockResult, anywhereEnabled: boolean): DaemonLockConflictOutcome | null;
-/** Node's Windows named-pipe API uses a default DACL that is not user-scoped. */
-export declare function hqdStartupRefusal(platform: NodeJS.Platform, anywhereEnabled: boolean): string | null;
+/** hqd is available on every platform while Anywhere is enabled; its listener fails closed if setup is unsafe. */
+export declare function shouldStartHqd(anywhereEnabled: boolean): boolean;
 /** Route an updater request through the daemon's existing graceful handoff. */
 export declare function handoffForPackageUpdateRequest(requested: boolean, restartDaemon: () => void): void;
 export interface RunDaemonOptions {

package/dist/lib/daemon/run.js

@@ -63,11 +63,9 @@ export function daemonLockConflictOutcome(lock, anywhereEnabled) {
             : "another hq daemon is starting up.\n",
     };
 }
-/** Node's Windows named-pipe API uses a default DACL that is not user-scoped. */
-export function hqdStartupRefusal(platform, anywhereEnabled) {
-    if (platform !== "win32" || !anywhereEnabled)
-        return null;
-    return "hqd is disabled on Windows because the default named-pipe ACL grants read access to Everyone and Anonymous accounts.";
+/** hqd is available on every platform while Anywhere is enabled; its listener fails closed if setup is unsafe. */
+export function shouldStartHqd(anywhereEnabled) {
+    return anywhereEnabled;
 }
 /** Route an updater request through the daemon's existing graceful handoff. */
 export function handoffForPackageUpdateRequest(requested, restartDaemon) {
@@ -838,8 +836,7 @@ export async function runDaemon(opts) {
     // hqd: the session/company socket every runtime talks to (hq-anywhere US-008).
     let hqd = null;
     let hqdShutdown = null;
-    if (anywhereRuntimeEnabled()) {
-        const refusal = hqdStartupRefusal(platform, true);
+    if (shouldStartHqd(anywhereRuntimeEnabled())) {
         try {
             const startConfig = readDaemonConfig(paths.configPath);
             hqd = await startHqdServer({
@@ -852,10 +849,7 @@ export async function runDaemon(opts) {
             });
         }
         catch (err) {
-            if (refusal && err.message === refusal)
-                log("error", refusal);
-            else
-                log("error", `hqd socket did not start; services run without it: ${err.message}`);
+            log("error", `hqd socket did not start; services run without it: ${err.message}`);
         }
     }
     // US-012: 60s presence heartbeat with version and session count.

package/dist/lib/doctor/checks/anywhere.js

@@ -182,7 +182,7 @@ function runtimeHealthCheck(health, healthUnsupported = false, serviceState) {
         ? "Windows named pipe (mode and owner are not reported)"
         : `mode ${socket.mode ?? "unknown"}; owner matches current user: ${socket.ownerMatchesUser === null ? "unknown" : socket.ownerMatchesUser ? "yes" : "no"}; user-only: ${socket.userOnly === null ? "unknown" : socket.userOnly ? "yes" : "no"}`;
     const unreachableMessage = socket.transport === "windows_named_pipe"
-        ? `hqd is not reachable on ${socket.path}; Windows daemon startup is refused because named-pipe ACLs are unsupported`
+        ? `hqd is not reachable on ${socket.path}; secure Windows named-pipe setup may have refused an unsafe ACL`
         : `hqd is not reachable on ${socket.path}; version, uptime, flag state, and cwd binding are unavailable`;
     const socketNotUserOnly = health.reachable && socket.transport === "unix_socket" && (socket.userOnly !== true || socket.ownerMatchesUser !== true);
     const warningNotes = [
@@ -192,7 +192,7 @@ function runtimeHealthCheck(health, healthUnsupported = false, serviceState) {
     const message = health.reachable
         ? `hqd reachable; version ${health.version ?? "unknown"}; uptime ${health.uptimeMs === null ? "unknown" : `${new Intl.NumberFormat("en-US").format(health.uptimeMs)} ms`}; runtime flag ${flagLabel}; last successful flag read ${age} ago; held through read error: ${flag.heldThroughReadError ? "yes" : "no"}; cwd binding ${binding}; socket ${socket.path}; ${socketSecurity}${warningNotes.length ? `; ${warningNotes.join("; ")}` : ""}`
         : unreachableMessage;
-    const remediation = !health.reachable && socket.transport === "unix_socket" && serviceState
+    const remediation = !health.reachable && serviceState
         ? serviceState.installed ? REMEDIATION.daemonRestart : REMEDIATION.daemonInstall
         : healthUnsupported || socketNotUserOnly ? REMEDIATION.daemonRestart : undefined;
     return {

package/dist/lib/lanes/claude-balance.d.ts

@@ -1,6 +1,6 @@
 import type { AuthState } from "./accounts.js";
 import type { HostCapacityAccount, HostCapacitySnapshot } from "./host-capacity.js";
-import type { LaneHost, LaneRecord, LanesConfig } from "./types.js";
+import type { LaneHost, LanePlacementPolicy, LaneRecord, LanesConfig } from "./types.js";
 import { type QuotaState } from "./quota.js";
 export declare const BALANCE_LIVE_STATES: readonly ["running", "queued", "awaiting_input"];
 export declare const BALANCE_MOVABLE_STATES: readonly ["interrupted", "done", "awaiting_input"];
@@ -81,6 +81,10 @@ export declare function selectClaudeAccount(input: {
     recentUsageEnabled?: boolean;
     now?: Date;
     explicitAccount?: string;
+    requestedModelSource?: "flag" | "profile" | "lane" | "default";
+    requestedPlacement?: LanePlacementPolicy | null;
+    /** Actual host where the lane would run; targetHost may be a distinct balance host. */
+    actualTargetHost?: LaneHost;
     unavailableHosts?: readonly BalanceHostGap[];
 }): ClaudeAccountSelection;
 export declare function accountLoadsForReport(input: {

package/dist/lib/lanes/claude-balance.js

@@ -119,6 +119,9 @@ function targetIneligibilityReason(accountId, globalEnabled, allowedAccounts, ta
         return "login_status_unknown";
     return undefined;
 }
+function configModelForAccount(config, accountId) {
+    return config.providers.claude.accounts[accountId]?.model;
+}
 function buildLoads(input) {
     const configAccounts = input.config.providers.claude.accounts;
     const targetHost = input.target.capacity.host;
@@ -156,10 +159,16 @@ function buildLoads(input) {
     return { loads, skipped };
 }
 export function selectClaudeAccount(input) {
+    const actualTargetHost = input.actualTargetHost ?? input.targetHost;
+    const placementDetails = {
+        requested_placement: input.requestedPlacement ?? null,
+        target_host: actualTargetHost,
+        ...(sameHost(actualTargetHost, input.targetHost) ? {} : { balance_host: input.targetHost }),
+    };
     const target = input.hosts.find((host) => sameHost(host.capacity.host, input.targetHost));
     if (!target) {
         throw new LanesError("claude_account_balance_target_host_unavailable", `Cannot verify Claude accounts on target host ${input.targetHost.kind}:${input.targetHost.id}`, {
-            target_host: input.targetHost,
+            ...placementDetails,
             unavailable_hosts: input.unavailableHosts ?? [],
         });
     }
@@ -170,8 +179,16 @@ export function selectClaudeAccount(input) {
         if (!selected || !selected.eligible) {
             throw new LanesError("claude_account_balance_account_unavailable", `Explicit Claude account ${JSON.stringify(input.explicitAccount)} is unavailable on ${input.targetHost.kind}:${input.targetHost.id}`, {
                 account: input.explicitAccount,
-                target_host: input.targetHost,
                 reason: selected?.ineligible_reason ?? "unknown_account",
+                ...placementDetails,
+                compared: {
+                    requested_model: input.model ?? configModelForAccount(input.config, input.explicitAccount) ?? input.config.providers.claude.model ?? null,
+                    requested_model_source: input.requestedModelSource ?? "default",
+                    account_model: configModelForAccount(input.config, input.explicitAccount) ?? null,
+                    account_model_source: `personal/lanes/config.json#providers.claude.accounts.${input.explicitAccount}.model`,
+                    host: input.targetHost,
+                    reason: selected?.ineligible_reason ?? "unknown_account",
+                },
                 account_reasons: skipped,
                 unavailable_hosts: input.unavailableHosts ?? [],
             });
@@ -196,7 +213,7 @@ export function selectClaudeAccount(input) {
             : "";
         throw new LanesError("claude_account_balance_no_eligible_account", `No enabled, logged-in Claude account is available on ${input.targetHost.kind}:${input.targetHost.id}${unknownLoginDetail}`, {
             provider: "claude",
-            target_host: input.targetHost,
+            ...placementDetails,
             account_reasons: loads.map((load) => ({
                 account: load.account,
                 reason: load.ineligible_reason ?? "unavailable",

package/dist/lib/lanes/spawn.js

@@ -334,11 +334,18 @@ function selectSpawnAccount(input) {
         const selection = selectClaudeAccount({
             hosts: [{ capacity, lanes, laneListAvailable: true }],
             targetHost: lane.host,
+            actualTargetHost: lane.host,
+            requestedPlacement: null,
             config,
             quotaState: loadQuotaState(hqRoot),
             ...((recordedModel ?? pinnedModel ?? profileModel) !== undefined
                 ? { model: recordedModel ?? pinnedModel ?? profileModel }
                 : {}),
+            requestedModelSource: recordedModel !== undefined || pinnedModel !== undefined
+                ? "lane"
+                : profileModel !== undefined
+                    ? "profile"
+                    : "default",
         });
         return {
             account: resolveAccount(lane.provider, selection.account, config, context),

package/package.json

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