@indigoai-us/hq-cli 5.203.0 → 5.204.0

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

@@ -19,7 +19,7 @@ export declare const CLAUDE_CREDENTIALS_NAME = ".credentials.json";
  * file here at all.
  */
 export declare const PROVIDER_CREDENTIAL_FILES: Record<LaneProvider, readonly string[]>;
-export type AuthState = "file" | "status" | "absent" | "unknown";
+export type AuthState = "file" | "status" | "absent" | "unknown" | "home_missing";
 export interface AccountStatusProbeResult {
     status: number | null;
     stdout: string;
@@ -27,12 +27,14 @@ export interface AccountStatusProbeResult {
 }
 export interface AccountDeps {
     existsSync: (p: string) => boolean;
+    hostname?: string;
     /** Provider status output is parsed for a boolean only; it is never printed. */
     probe?: (command: string, args: string[], env: NodeJS.ProcessEnv) => AccountStatusProbeResult;
     env?: NodeJS.ProcessEnv;
 }
 export interface AccountResolveContext {
     hqRoot?: string;
+    hostname?: string;
     existsSync?: (p: string) => boolean;
     accountDeps?: Omit<AccountDeps, "existsSync">;
     loadLanes?: (hqRoot: string) => LaneRecord[];
@@ -61,6 +63,7 @@ export interface AccountStatus {
     provider: LaneProvider;
     id: string;
     home: string;
+    home_source?: "host" | "default";
     enabled: boolean;
     disabled_reason?: string;
     /** Present in personal/lanes/config.json. */

package/dist/lib/lanes/accounts.js

@@ -8,6 +8,7 @@
  * module never reads, prints, copies, or hashes credential files.
  */
 import * as fs from "node:fs";
+import { effectiveAccountHome } from "./account-home.js";
 import * as path from "node:path";
 import { AccountResolutionError } from "./errors.js";
 import { isTerminalLaneState } from "./types.js";
@@ -179,11 +180,11 @@ function throwIfQuotaBlocked(block, provider, accountId) {
         quota_reset_at: block.quota_reset_at ?? null,
     });
 }
-function boundAccount(provider, id, account) {
+function boundAccount(provider, id, account, hostname) {
     return {
         provider,
         id,
-        home: account.home,
+        home: effectiveAccountHome(account, hostname).home,
         enabled: true,
         envVar: PROVIDER_HOME_ENV[provider],
     };
@@ -209,6 +210,7 @@ export function selectBalancedAccount(provider, config, ctx = {}) {
             existsSync,
             ...(ctx.accountDeps?.probe ? { probe: ctx.accountDeps.probe } : {}),
             ...(ctx.accountDeps?.env ? { env: ctx.accountDeps.env } : {}),
+            ...(ctx.hostname !== undefined ? { hostname: ctx.hostname } : {}),
         });
         if (status.logged_in === true)
             proven.push(id);
@@ -251,7 +253,7 @@ export function selectBalancedAccount(provider, config, ctx = {}) {
     }))
         .sort(compareEligible);
     const chosen = preferred ?? ranked[0].id;
-    return boundAccount(provider, chosen, providerCfg.accounts[chosen]);
+    return boundAccount(provider, chosen, providerCfg.accounts[chosen], ctx.hostname);
 }
 export function resolveAccount(provider, requestedId, config, ctx = {}) {
     const providerCfg = config.providers[provider];
@@ -276,7 +278,7 @@ export function resolveAccount(provider, requestedId, config, ctx = {}) {
             const block = quotaBlockFor(loadQuotaState(ctx.hqRoot), provider, requestedId, modelForAccount(provider, requestedId, config, ctx), now);
             throwIfQuotaBlocked(block, provider, requestedId);
         }
-        return boundAccount(provider, requestedId, account);
+        return boundAccount(provider, requestedId, account, ctx.hostname);
     }
     return selectBalancedAccount(provider, config, ctx);
 }
@@ -299,12 +301,14 @@ export function accountStatus(provider, accountId, config, deps = defaultAccount
             envVar,
         };
     }
-    const present = hasCredentialFile(provider, account.home, deps.existsSync);
-    let auth_state = authStateFor(provider, present);
-    let logged_in = loggedInFromAuthState(auth_state);
-    if (!present && provider === "claude" && deps.probe !== undefined) {
+    const effective = effectiveAccountHome(account, deps.hostname);
+    const homeExists = deps.existsSync(effective.home);
+    const present = homeExists && hasCredentialFile(provider, effective.home, deps.existsSync);
+    let auth_state = homeExists ? authStateFor(provider, present) : "home_missing";
+    let logged_in = homeExists ? loggedInFromAuthState(auth_state) : false;
+    if (homeExists && !present && provider === "claude" && deps.probe !== undefined) {
         try {
-            const result = deps.probe("claude", ["auth", "status"], { ...(deps.env ?? process.env), CLAUDE_CONFIG_DIR: account.home });
+            const result = deps.probe("claude", ["auth", "status"], { ...(deps.env ?? process.env), CLAUDE_CONFIG_DIR: effective.home });
             const providerStatus = claudeLoginStatus(result);
             if (providerStatus !== null) {
                 auth_state = "status";
@@ -318,7 +322,8 @@ export function accountStatus(provider, accountId, config, deps = defaultAccount
     const status = {
         provider,
         id: accountId,
-        home: account.home,
+        home: effective.home,
+        home_source: effective.source,
         enabled: account.enabled,
         configured: true,
         logged_in,

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

@@ -1,3 +1,4 @@
+import type { AuthState } from "./accounts.js";
 import type { HostCapacityAccount, HostCapacitySnapshot } from "./host-capacity.js";
 import type { LaneHost, LaneRecord, LanesConfig } from "./types.js";
 export declare const CLAUDE_ACCOUNT_BALANCE_FLAG = "lanes.claude-account-balance";
@@ -20,6 +21,8 @@ export interface AccountHostLoad {
     host: LaneHost;
     enabled: boolean;
     logged_in: boolean | null;
+    account_in_snapshot: boolean;
+    auth_state?: AuthState;
     live_lanes: number | null;
     lane_counts: {
         running: number | null;

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

@@ -21,7 +21,8 @@ function accountHostLoad(host, accountId) {
         return {
             host: host.capacity.host,
             enabled: false,
-            logged_in: false,
+            logged_in: null,
+            account_in_snapshot: false,
             live_lanes: host.laneListAvailable ? countLaneStates(host.lanes, accountId).live : null,
             lane_counts: host.laneListAvailable
                 ? countLaneStates(host.lanes, accountId)
@@ -35,6 +36,8 @@ function accountHostLoad(host, accountId) {
             host: host.capacity.host,
             enabled: hostCapacity.enabled,
             logged_in: hostCapacity.logged_in,
+            account_in_snapshot: true,
+            ...(hostCapacity.auth_state !== undefined ? { auth_state: hostCapacity.auth_state } : {}),
             live_lanes: counts.live,
             lane_counts: { running: counts.running, queued: counts.queued, awaiting_input: counts.awaiting_input },
             count_source: "lane_list",
@@ -45,6 +48,8 @@ function accountHostLoad(host, accountId) {
             host: host.capacity.host,
             enabled: hostCapacity.enabled,
             logged_in: hostCapacity.logged_in,
+            account_in_snapshot: true,
+            ...(hostCapacity.auth_state !== undefined ? { auth_state: hostCapacity.auth_state } : {}),
             live_lanes: hostCapacity.lane_counts.live,
             lane_counts: {
                 running: hostCapacity.lane_counts.running,
@@ -58,6 +63,8 @@ function accountHostLoad(host, accountId) {
         host: host.capacity.host,
         enabled: hostCapacity.enabled,
         logged_in: hostCapacity.logged_in,
+        account_in_snapshot: true,
+        ...(hostCapacity.auth_state !== undefined ? { auth_state: hostCapacity.auth_state } : {}),
         live_lanes: hostCapacity.running + hostCapacity.queued,
         lane_counts: { running: hostCapacity.running, queued: hostCapacity.queued, awaiting_input: null },
         count_source: "capacity_partial",
@@ -74,10 +81,16 @@ function selectionSignal(loads) {
         : "lane_count";
 }
 function targetIneligibilityReason(accountId, globalEnabled, allowedAccounts, target) {
-    if (!globalEnabled || !target.enabled)
+    if (!globalEnabled)
         return "disabled";
     if (allowedAccounts !== undefined && !allowedAccounts.includes(accountId))
         return "not_allowed_by_lane";
+    if (!target.account_in_snapshot)
+        return "not_in_snapshot";
+    if (!target.enabled)
+        return "disabled";
+    if (target.auth_state === "home_missing")
+        return "home_missing";
     if (target.logged_in === false)
         return "not_logged_in";
     if (target.logged_in === null)
@@ -203,6 +216,9 @@ export function planClaudeBalanceMoves(input) {
         const hostSnapshot = input.hosts.find((row) => sameHost(row.capacity.host, host));
         if (!hostSnapshot)
             continue;
+        const sourceStatus = hostSnapshot.capacity.providers.claude.accounts[source];
+        if (sourceStatus === undefined)
+            continue;
         const candidates = Object.keys(input.config.providers.claude.accounts)
             .filter((account) => account !== source && input.config.providers.claude.accounts[account]?.enabled === true)
             .map((account) => ({
@@ -212,8 +228,7 @@ export function planClaudeBalanceMoves(input) {
         }))
             .filter((candidate) => candidate.targetStatus?.enabled === true && candidate.targetStatus.logged_in === true)
             .sort((a, b) => a.load - b.load || a.account.localeCompare(b.account));
-        const sourceStatus = hostSnapshot.capacity.providers.claude.accounts[source];
-        const sourceUnavailable = sourceStatus?.enabled !== true || sourceStatus.logged_in !== true;
+        const sourceUnavailable = sourceStatus.enabled !== true || sourceStatus.logged_in !== true;
         const target = candidates[0];
         const laneIsLive = isBalanceLive(lane);
         if (!target || (!sourceUnavailable && (!laneIsLive || target.load >= sourceLoad)))

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

@@ -7,7 +7,7 @@
  * that resolve to the same home are refused (identity-keyed-cap rule).
  */
 import * as fs from "node:fs";
-import { type LaneProvider, type LanesConfig, type LivenessWindows, type ProviderConfig } from "./types.js";
+import { type AccountConfig, type LaneProvider, type LanesConfig, type LivenessWindows, type ProviderConfig } from "./types.js";
 export declare const LANES_CONFIG_REL: string;
 export declare const DEFAULT_MAX_QUEUED = 3;
 export declare const DEFAULT_CPU_BUSY_PAUSE = 0.85;
@@ -55,6 +55,7 @@ export declare function expandHome(home: string, homedir: string): string;
  * not-yet-created spellings of the same directory still collide.
  */
 export declare function canonicalizeHome(home: string, deps?: Pick<ConfigLoadDeps, "homedir" | "realpathSync" | "existsSync">): string;
+export declare function assertUniqueAccountHomes(provider: LaneProvider, accounts: Record<string, AccountConfig>): void;
 export declare function documentedDefaultConfig(deps?: ConfigLoadDeps): LanesConfig;
 export declare function parseLanesConfig(raw: unknown, deps?: ConfigLoadDeps): LanesConfig;
 export declare function lanesConfigPath(hqRoot: string): string;

package/dist/lib/lanes/config.js

@@ -110,6 +110,17 @@ export function canonicalizeHome(home, deps = defaultDeps()) {
     }
     return expanded;
 }
+function canonicalizeHostHome(hostname, home, deps) {
+    if (hostname === os.hostname())
+        return canonicalizeHome(home, deps);
+    if (home === "~" || home.startsWith("~/")) {
+        return home === "~" ? home : `~/${path.posix.normalize(home.slice(2))}`;
+    }
+    if (!path.isAbsolute(home)) {
+        throw new LanesConfigError("invalid_config", `Host-scoped home for remote host ${JSON.stringify(hostname)} must be absolute or start with ~/`, { hostname, home });
+    }
+    return path.normalize(home);
+}
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -143,6 +154,27 @@ function parseAccount(provider, id, raw, deps) {
         home: canonicalizeHome(raw.home, deps),
         enabled: raw.enabled,
     };
+    if (raw.hosts !== undefined) {
+        const field = `providers.${provider}.accounts.${id}.hosts`;
+        if (!isPlainObject(raw.hosts)) {
+            throw new LanesConfigError("invalid_config", `${field} must be an object keyed by non-empty hostnames`, { provider, account: id, field });
+        }
+        const hosts = Object.create(null);
+        for (const [hostname, value] of Object.entries(raw.hosts)) {
+            const hostField = `${field}.${hostname}`;
+            if (hostname.trim().length === 0 || hostname.trim() !== hostname) {
+                throw new LanesConfigError("invalid_config", `${field} hostnames must be non-empty and have no surrounding whitespace`, { provider, account: id, field, hostname });
+            }
+            if (!isPlainObject(value) || Object.keys(value).some((key) => key !== "home")) {
+                throw new LanesConfigError("invalid_config", `${hostField} must be an object containing only a home field`, { provider, account: id, field: hostField });
+            }
+            if (typeof value.home !== "string" || value.home.trim().length === 0) {
+                throw new LanesConfigError("invalid_config", `${hostField}.home must be a non-empty string`, { provider, account: id, field: `${hostField}.home` });
+            }
+            hosts[hostname] = { home: canonicalizeHostHome(hostname, value.home, deps) };
+        }
+        account.hosts = hosts;
+    }
     if (raw.disabled_reason !== undefined) {
         if (typeof raw.disabled_reason !== "string") {
             throw new LanesConfigError("invalid_config", `providers.${provider}.accounts.${id}.disabled_reason must be a string`, { provider, account: id });
@@ -198,19 +230,29 @@ function parsePreferredAccounts(provider, value, accounts) {
     }
     return [...preferred];
 }
-function rejectDuplicateHomes(provider, accounts) {
-    const seen = new Map();
-    for (const [id, account] of Object.entries(accounts)) {
-        const prior = seen.get(account.home);
-        if (prior !== undefined) {
-            throw new LanesConfigError("duplicate_account_home", `providers.${provider} accounts ${JSON.stringify(prior)} and ${JSON.stringify(id)} resolve to the same home ${account.home}`, {
-                provider,
-                accounts: [prior, id],
-                home: account.home,
-            });
+export function assertUniqueAccountHomes(provider, accounts) {
+    const hostnames = new Set(Object.values(accounts).flatMap((account) => Object.keys(account.hosts ?? {})));
+    const check = (hostname) => {
+        const seen = new Map();
+        for (const [id, account] of Object.entries(accounts)) {
+            const home = hostname === undefined
+                ? account.home
+                : account.hosts?.[hostname]?.home ?? account.home;
+            const prior = seen.get(home);
+            if (prior !== undefined) {
+                throw new LanesConfigError("duplicate_account_home", `providers.${provider} accounts ${JSON.stringify(prior)} and ${JSON.stringify(id)} resolve to the same home ${home}${hostname === undefined ? "" : ` on host ${JSON.stringify(hostname)}`}`, {
+                    provider,
+                    accounts: [prior, id],
+                    home,
+                    ...(hostname !== undefined ? { hostname } : {}),
+                });
+            }
+            seen.set(home, id);
         }
-        seen.set(account.home, id);
-    }
+    };
+    check();
+    for (const hostname of hostnames)
+        check(hostname);
 }
 function defaultAccountMap(provider, deps) {
     return {
@@ -240,7 +282,7 @@ function parseProvider(provider, raw, deps) {
             accounts[id] = parseAccount(provider, id, value, deps);
         }
     }
-    rejectDuplicateHomes(provider, accounts);
+    assertUniqueAccountHomes(provider, accounts);
     // default_account is accepted so existing files parse, and ignored for
     // selection. An omitted field is not an error.
     let defaultAccount;

package/dist/lib/lanes/host-capacity.d.ts

@@ -1,7 +1,10 @@
+import { type AuthState } from "./accounts.js";
 import type { LaneHost, LaneProvider, LaneRecord, LanesConfig } from "./types.js";
 export interface HostCapacityAccount {
     enabled: boolean;
     logged_in: boolean | null;
+    /** Absent on snapshots from older CLIs. */
+    auth_state?: AuthState;
     max_running: number;
     running: number;
     queued: number;
@@ -49,6 +52,7 @@ export declare function buildHostCapacitySnapshot(input: {
         stderr: string;
     };
     env?: NodeJS.ProcessEnv;
+    hostname?: string;
     now: Date;
 }): HostCapacitySnapshot;
 /** Reject malformed remote snapshots before they can influence host selection. */

package/dist/lib/lanes/host-capacity.js

@@ -23,12 +23,14 @@ export function buildHostCapacitySnapshot(input) {
                 existsSync: input.existsSync,
                 ...(input.probe !== undefined ? { probe: input.probe } : {}),
                 ...(input.env !== undefined ? { env: input.env } : {}),
+                ...(input.hostname !== undefined ? { hostname: input.hostname } : {}),
             });
             const accountLanes = providerLanes.filter((lane) => lane.account === id);
             const liveLanes = accountLanes.filter((lane) => lane.state === "running" || lane.state === "queued" || lane.state === "awaiting_input");
             accounts[id] = {
                 enabled: account.enabled,
                 logged_in: status.logged_in,
+                auth_state: status.auth_state,
                 max_running: accountMaxRunning(providerConfig, id),
                 running: running.filter((lane) => lane.account === id).length,
                 queued: queued.filter((lane) => lane.account === id).length,
@@ -99,7 +101,9 @@ export function parseHostCapacitySnapshot(raw) {
             const account = objectValue(accountValue);
             if (id.trim() === "" || account === undefined ||
                 typeof account.enabled !== "boolean" ||
-                !(account.logged_in === null || typeof account.logged_in === "boolean")) {
+                !(account.logged_in === null || typeof account.logged_in === "boolean") ||
+                (account.auth_state !== undefined &&
+                    !["file", "status", "absent", "unknown", "home_missing"].includes(account.auth_state))) {
                 throw new LanesError("host_capacity_invalid", `Malformed ${provider} account capacity`, {
                     provider,
                     account: id,
@@ -108,6 +112,9 @@ export function parseHostCapacitySnapshot(raw) {
             accounts[id] = {
                 enabled: account.enabled,
                 logged_in: account.logged_in,
+                ...(account.auth_state !== undefined
+                    ? { auth_state: account.auth_state }
+                    : {}),
                 max_running: requireCount(account.max_running, `${provider}.${id}.max_running`, true),
                 running: requireCount(account.running, `${provider}.${id}.running`),
                 queued: requireCount(account.queued, `${provider}.${id}.queued`),

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

@@ -38,6 +38,8 @@ export { LANE_MESH_EVENTS, WIRE_EVENT_KINDS, createLaneMesh, emitLaneDecisionEve
 export type { CreateLaneMeshOptions, LaneMesh, LaneMeshEvent, WireEventKind, WireThreadEvent, } from "./mesh-events.js";
 export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO, STARVATION_MAX_DEFERRALS, STARVATION_MAX_MS, applyThrottleDecision, busyFractionFromDeltas, cpuTimesSnapshot, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, parseMemAvailableKb, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyFraction, starvationBoundReached, throttleStatePath, writeThrottleState, } from "./throttle.js";
 export type { CpuTimes, ThrottleAdmitReason, ThrottleDecision, ThrottleDeferReason, ThrottleDeps, ThrottleState, } from "./throttle.js";
+export { effectiveAccountHome, } from "./account-home.js";
+export type { EffectiveAccountHome, } from "./account-home.js";
 export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, credentialPaths, hasCredentialFile, isCredentialProven, isLoggedOut, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
 export type { AccountResolveContext, AccountStatus, AuthState, ResolvedAccount, } from "./accounts.js";
 export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";

package/dist/lib/lanes/index.js

@@ -21,6 +21,7 @@ export { SILENCE_MS, WATCHER_DECISION_EVENTS, WATCHER_OUT_MAX_BYTES, WATCHER_POL
 export { ENVELOPE_INVALID_REASON, decideEnvelopeRepair, emitMeshSoft, envelopeQuestionIds, readLatestEnvelopeFile, readLatestEnvelopeRecord, } from "./watcher.js";
 export { LANE_MESH_EVENTS, WIRE_EVENT_KINDS, createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, laneCanEmit, parseLaneMeshEvent, progressEventDue, toWireThreadEvent, } from "./mesh-events.js";
 export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO, STARVATION_MAX_DEFERRALS, STARVATION_MAX_MS, applyThrottleDecision, busyFractionFromDeltas, cpuTimesSnapshot, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, parseMemAvailableKb, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyFraction, starvationBoundReached, throttleStatePath, writeThrottleState, } from "./throttle.js";
+export { effectiveAccountHome, } from "./account-home.js";
 export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, credentialPaths, hasCredentialFile, isCredentialProven, isLoggedOut, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
 export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
 export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";

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

@@ -44,6 +44,7 @@ export interface LivenessDeps {
     readdirSync: (dir: string, options: {
         withFileTypes: true;
     }) => fs.Dirent[];
+    hostname?: () => string;
 }
 export declare function defaultLivenessDeps(): LivenessDeps;
 export declare function defaultSpoolPath(deps?: LivenessDeps): string;

package/dist/lib/lanes/liveness.js

@@ -14,6 +14,7 @@ import * as path from "node:path";
 import { workMeshSpoolPath, workMeshRoot } from "../mesh/live/paths.js";
 import { daemonDir, daemonStatePath } from "../mesh/live/daemon/paths.js";
 import { LanesError } from "./errors.js";
+import { effectiveAccountHome } from "./account-home.js";
 import { DEFAULT_LIVE_WITHIN_MS, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, loadLanesConfig, } from "./config.js";
 import { lanesStoreRoot } from "./store.js";
 export const LIVE_WITHIN_MS = DEFAULT_LIVE_WITHIN_MS;
@@ -39,6 +40,7 @@ export function defaultLivenessDeps() {
         statSync: (file) => fs.statSync(file),
         lstatSync: (file) => fs.lstatSync(file),
         readdirSync: fs.readdirSync.bind(fs),
+        hostname: () => os.hostname(),
     };
 }
 export function defaultSpoolPath(deps = defaultLivenessDeps()) {
@@ -373,7 +375,7 @@ export function sessionLiveness(hqRoot, sessionId, opts = {}) {
     const config = loadLanesConfig(hqRoot);
     const windows = opts.windows ?? config.liveness;
     if (!entry) {
-        return unindexedClaudeSessionLiveness(sessionId, opts.nowMs ?? deps.now(), windows, deps, Object.values(config.providers.claude.accounts).map((account) => account.home));
+        return unindexedClaudeSessionLiveness(sessionId, opts.nowMs ?? deps.now(), windows, deps, Object.values(config.providers.claude.accounts).map((account) => effectiveAccountHome(account, deps.hostname?.()).home));
     }
     const presenceConnected = opts.presenceConnected ?? readDaemonPresenceConnected(deps);
     return classifySessionLiveness(entry, opts.nowMs ?? deps.now(), presenceConnected, windows);

package/dist/lib/lanes/reconcile.js

@@ -10,6 +10,7 @@ import * as path from "node:path";
 import { parseUserYaml } from "../../utils/user-yaml-error.js";
 import { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, } from "./admission.js";
 import { accountStatus, isCredentialProven, resolveAccount } from "./accounts.js";
+import { effectiveAccountHome } from "./account-home.js";
 import { loadLanesConfig, providerQuotaDefaultHoldMs } from "./config.js";
 import { MAX_LANE_DEPTH } from "./constants.js";
 import { AccountResolutionError, LanesError, isLaneVersionConflict } from "./errors.js";
@@ -38,6 +39,13 @@ export const PICKUP_VALIDATION_MAX_AGE_MS = 15 * 60 * 1000;
 export const PICKUP_VALIDATION_TIMEOUT_REASON = "pickup_validation_timeout";
 export const RECONCILE_UNIT_NAME = "hq-lanes-reconcile.service";
 export const RECONCILE_TIMER_NAME = "hq-lanes-reconcile.timer";
+function spawnDepsForHost(deps) {
+    return {
+        ...(deps.spawnLaneDeps ?? {}),
+        hostname: deps.host.hostname,
+        admissionHost: deps.host,
+    };
+}
 function logSkip(skip) {
     process.stderr.write(`hq lanes reconcile: skipped ${skip.kind}${skip.id ? ` ${skip.id}` : ""}: ${skip.why}\n`);
 }
@@ -326,12 +334,16 @@ function availableBalancedAccount(hqRoot, lane, occupying, config, host, profile
             continue;
         if (config.providers[lane.provider].accounts[account]?.enabled !== true)
             continue;
-        const status = accountStatus(lane.provider, account, config);
+        const status = accountStatus(lane.provider, account, config, {
+            hostname: host.hostname,
+            existsSync: (file) => fs.existsSync(file),
+        });
         if (!isCredentialProven(status))
             continue;
         try {
             resolveAccount(lane.provider, account, config, {
                 hqRoot,
+                hostname: host.hostname,
                 ...(pinnedModel !== undefined ? { model: pinnedModel } : {}),
             });
         }
@@ -655,7 +667,7 @@ export async function runPassBody(hqRoot, deps) {
     };
     const readSessionSenior = deps.readSessionSenior ??
         ((sessionId) => defaultReadSessionSenior(hqRoot, sessionId));
-    const configuredClaudeHomes = Object.values(config.providers.claude.accounts).map((account) => account.home);
+    const configuredClaudeHomes = Object.values(config.providers.claude.accounts).map((account) => effectiveAccountHome(account, deps.host.hostname).home);
     const sessionStateCache = new Map();
     const sessionState = (sessionId) => {
         if (sessionStateCache.has(sessionId)) {
@@ -887,7 +899,7 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                 }
                 if (!watcherAlive && !deps.dryRun) {
                     try {
-                        armLaneWatcher(hqRoot, lane.lane_id, deps.spawnLaneDeps ?? {});
+                        armLaneWatcher(hqRoot, lane.lane_id, spawnDepsForHost(deps));
                         summary.heartbeats.push(`${lane.lane_id}:watcher-rearmed`);
                     }
                     catch (err) {
@@ -941,10 +953,10 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                     repairCandidate.envelope === null &&
                     (!repairCandidate.missing || envelopeRepairMode(classified.provider) === "resume")) {
                     const spawnRepair = deps.spawnRepair ??
-                        ((root, repairLane, input) => spawnEnvelopeRepair(root, repairLane, input, deps.spawnLaneDeps));
+                        ((root, repairLane, input) => spawnEnvelopeRepair(root, repairLane, input, spawnDepsForHost(deps)));
                     const repair = decideEnvelopeRepair(hqRoot, lane.lane_id, repairCandidate, nowMs, spawnRepair, () => undefined);
                     if (repair.action === "spawned") {
-                        armLaneWatcher(hqRoot, lane.lane_id, deps.spawnLaneDeps);
+                        armLaneWatcher(hqRoot, lane.lane_id, spawnDepsForHost(deps));
                         summary.heartbeats.push(`${lane.lane_id}:envelope-repair`);
                         continue;
                     }
@@ -969,8 +981,7 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                 if (!deps.dryRun && accountRetryReason && classified.account) {
                     try {
                         const recovered = await retryLaneOnAlternateAccount(hqRoot, classified, accountRetryReason, "reconcile", {
-                            ...(deps.spawnLaneDeps ?? {}),
-                            admissionHost: deps.host,
+                            ...spawnDepsForHost(deps),
                         });
                         summary.dead_host.push({
                             id: lane.lane_id,
@@ -1197,7 +1208,7 @@ async function admitQueued(hqRoot, lanes, summary, deps, now) {
         nowMs,
     });
     const spawnFn = deps.spawn ??
-        ((root, lane) => spawnLaneWorker(root, lane, deps.spawnLaneDeps));
+        ((root, lane) => spawnLaneWorker(root, lane, spawnDepsForHost(deps)));
     const running = lanes.filter((lane) => (lane.state === "running" ||
         hasFreshAdmissionReservation(lane, now.getTime()) ||
         hasActivePendingResume(lane, now.getTime())) &&
@@ -1336,7 +1347,7 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
         const throttle = await decideAdmission(hqRoot, config.throttle, throttleDeps);
         throttleDecision = throttle.decision;
     }
-    const spawnFn = deps.spawn ?? ((root, lane) => spawnLaneWorker(root, lane, deps.spawnLaneDeps));
+    const spawnFn = deps.spawn ?? ((root, lane) => spawnLaneWorker(root, lane, spawnDepsForHost(deps)));
     const nowMs = deps.now().getTime();
     const fallbackAnswerAt = new Date(nowMs).toISOString();
     const answerAtByLane = new Map();

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

@@ -68,6 +68,7 @@ export type ProveDetachedFn = (pid: number) => DetachProof;
 export type KillProcessFn = (pid: number, signal?: NodeJS.Signals) => void;
 export interface SpawnLaneDeps {
     env?: NodeJS.ProcessEnv;
+    hostname?: string;
     /** The caller's host scope for admission checks; reconcile supplies its resolved host. */
     admissionHost?: AdmissionHost;
     /** Provider model catalog dependencies, shared with create in tests. */