@indigoai-us/hq-cli 5.203.0 → 5.205.0

package/dist/lib/lanes/account-home.d.ts

@@ -0,0 +1,8 @@
+import type { AccountConfig } from "./types.js";
+export type EffectiveAccountHome = {
+    home: string;
+    source: "host" | "default";
+};
+/** Resolve the account home for this host; an empty host identity fails back to the default. */
+export declare function effectiveAccountHome(account: AccountConfig, hostname?: string): EffectiveAccountHome;
+//# sourceMappingURL=account-home.d.ts.map

package/dist/lib/lanes/account-home.js

@@ -0,0 +1,10 @@
+import * as os from "node:os";
+/** Resolve the account home for this host; an empty host identity fails back to the default. */
+export function effectiveAccountHome(account, hostname = os.hostname()) {
+    const host = hostname.trim();
+    const hostHome = host ? account.hosts?.[host]?.home : undefined;
+    return hostHome === undefined
+        ? { home: account.home, source: "default" }
+        : { home: hostHome, source: "host" };
+}
+//# sourceMappingURL=account-home.js.map

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/admission.js

@@ -137,6 +137,12 @@ export function hasActivePendingResume(lane, nowMs) {
         return false;
     if (lane.state === "queued" && pending.trigger === "answered_questions")
         return false;
+    if (lane.state === "queued" &&
+        lane.keep_alive === true &&
+        pending.trigger === "resume" &&
+        pending.resumed_from === "done" &&
+        lane.keep_alive_last_resume_at === pending.at)
+        return false;
     const reservedAt = Date.parse(pending.at);
     const ageMs = nowMs - reservedAt;
     return Number.isFinite(reservedAt) && ageMs >= 0 && ageMs < ADMISSION_RESERVATION_GRACE_MS;

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/hire-grants.d.ts

@@ -1,4 +1,5 @@
 import { type LaneRecord } from "./types.js";
+import { LanesError } from "./errors.js";
 export declare const LANE_HIRE_GRANTS_FLAG = "lanes.hire-grants";
 export type LaneHireGrantRow = Pick<LaneRecord, "lane_id" | "state" | "senior" | "hire_grant">;
 export declare function aliveDirectChildren<T extends LaneHireGrantRow>(lanes: readonly T[], parentLaneId: string): T[];
@@ -9,6 +10,9 @@ export interface HireGrantAdmissionSnapshot {
     parentGrant: number;
     availableChildGrant: number;
 }
+/** Shared refusal logic for resuming a terminal lane under an active senior. */
+export declare function terminalChildResumeHireGrantError(current: LaneRecord, snapshot: HireGrantAdmissionSnapshot): LanesError | null;
+export declare function hireGrantCapacityError(parent: LaneRecord, children: readonly LaneRecord[]): LanesError;
 /** Keep the occupancy snapshot and the resulting lane write in one parent-lock scope. */
 export declare function withHireGrantAdmission<T>(hqRoot: string, parentLaneId: string, fn: (snapshot: HireGrantAdmissionSnapshot) => T): T;
 export interface HireGrantBackfillRow {

package/dist/lib/lanes/hire-grants.js

@@ -10,6 +10,68 @@ export function aliveDirectChildren(lanes, parentLaneId) {
 export function assignedChildHireGrants(children, exceptLaneId) {
     return children.reduce((sum, child) => child.lane_id === exceptLaneId ? sum : sum + (child.hire_grant ?? 0), 0);
 }
+/** Shared refusal logic for resuming a terminal lane under an active senior. */
+export function terminalChildResumeHireGrantError(current, snapshot) {
+    if (!isTerminalLaneState(current.state))
+        return null;
+    const { parent, children, parentGrant, availableChildGrant } = snapshot;
+    if (isTerminalLaneState(parent.state)) {
+        return new LanesError("hire_grant_senior_inactive", `Senior lane ${parent.lane_id} is ${parent.state} and cannot resume child lanes`, { senior_lane_id: parent.lane_id, state: parent.state });
+    }
+    if (children.length >= parentGrant)
+        return hireGrantCapacityError(parent, children);
+    const requestedGrant = current.hire_grant ?? 0;
+    if (requestedGrant > availableChildGrant) {
+        return new LanesError("hire_grant_carve_exceeded", `Senior lane ${parent.lane_id} has ${availableChildGrant} unassigned hire grant remaining, but terminal child ${current.lane_id} needs ${requestedGrant} to resume. Ask its senior for more: write an ask envelope with the desired total grant and why; the senior runs hq lanes grant ${parent.lane_id} --hire <n>.`, {
+            senior_lane_id: parent.lane_id,
+            parent_grant: parentGrant,
+            alive_children: children.map((child) => child.lane_id),
+            assigned_child_grants: assignedChildHireGrants(children),
+            requested_hire_grant: requestedGrant,
+            available_hire_grant: availableChildGrant,
+            ask_guidance: {
+                envelope: "decision=ask; include the desired total grant and the reason",
+                senior_command: `hq lanes grant ${parent.lane_id} --hire <n>`,
+            },
+        });
+    }
+    return null;
+}
+export function hireGrantCapacityError(parent, children) {
+    const grant = parent.hire_grant ?? 0;
+    const grantor = (parent.senior.kind === "lane" || parent.senior.kind === "session") &&
+        parent.senior.id
+        ? { kind: parent.senior.kind, id: parent.senior.id }
+        : null;
+    const grantorReason = grantor
+        ? undefined
+        : parent.senior.kind === "user"
+            ? "senior_is_user"
+            : "parent_senior_missing_id";
+    const capacity = children.length === grant
+        ? `is at its hire grant (${children.length} of ${grant} alive children)`
+        : `has exhausted its hire grant (${children.length} alive children; grant ${grant})`;
+    const grantCommand = `hq lanes grant ${parent.lane_id} --hire <n>`;
+    const authorityGuidance = grantor
+        ? `Its senior ${grantor.kind} ${grantor.id} can raise it with: ${grantCommand}`
+        : parent.senior.kind === "user"
+            ? `Its senior is the user and can raise it with: ${grantCommand}`
+            : `No senior is recorded, so an operator must resolve ownership before running: ${grantCommand}`;
+    const message = `Lane ${parent.lane_id} ${capacity}. ${authorityGuidance}`;
+    return new LanesError("hire_grant_exhausted", message, {
+        senior_lane_id: parent.lane_id,
+        parent_grant: grant,
+        alive_children: children.map((child) => child.lane_id),
+        alive_child_count: children.length,
+        grantor,
+        ...(grantorReason ? { grantor_reason: grantorReason } : {}),
+        message,
+        ask_guidance: {
+            envelope: "decision=ask; include the desired total grant and the reason",
+            senior_command: grantCommand,
+        },
+    });
+}
 /** Keep the occupancy snapshot and the resulting lane write in one parent-lock scope. */
 export function withHireGrantAdmission(hqRoot, parentLaneId, fn) {
     return withLaneHireLocks(hqRoot, [parentLaneId], () => {

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

@@ -3,7 +3,7 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { assignedChildHireGrants, aliveDirectChildren, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, withHireGrantAdmission } from "./hire-grants.js";
+export { assignedChildHireGrants, aliveDirectChildren, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
 export type { HireGrantBackfillRow } from "./hire-grants.js";
 export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneOccupiesRunningSlot, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
 export type { AdmissionCapReason, AdmissionHost } from "./admission.js";
@@ -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

@@ -3,7 +3,7 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { assignedChildHireGrants, aliveDirectChildren, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, withHireGrantAdmission } from "./hire-grants.js";
+export { assignedChildHireGrants, aliveDirectChildren, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
 export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneOccupiesRunningSlot, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
 export { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "./host-capacity.js";
 export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STORY_STATUSES, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.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/keep-alive.d.ts

@@ -0,0 +1,8 @@
+export declare const LEAD_LANE_KEEP_ALIVE_FLAG = "lanes.lead-keep-alive";
+export declare const LEAD_LANE_KEEP_ALIVE_DEFAULT_ENABLED = false;
+export declare const LEAD_LANE_KEEP_ALIVE_MAX_RESUMES = 24;
+export declare const LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS: number;
+export declare const LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS: number;
+export declare const LEAD_LANE_KEEP_ALIVE_RESUME_TEXT = "Automatic keep-alive resume: your last turn ended with decision done and story_complete false. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
+export declare function leadLaneKeepAliveBackoffMs(attempt: number): number;
+//# sourceMappingURL=keep-alive.d.ts.map

package/dist/lib/lanes/keep-alive.js

@@ -0,0 +1,14 @@
+export const LEAD_LANE_KEEP_ALIVE_FLAG = "lanes.lead-keep-alive";
+export const LEAD_LANE_KEEP_ALIVE_DEFAULT_ENABLED = false;
+export const LEAD_LANE_KEEP_ALIVE_MAX_RESUMES = 24;
+export const LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS = 5 * 60 * 1000;
+export const LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS = 60 * 60 * 1000;
+export const LEAD_LANE_KEEP_ALIVE_RESUME_TEXT = "Automatic keep-alive resume: your last turn ended with decision done and story_complete false. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
+export function leadLaneKeepAliveBackoffMs(attempt) {
+    if (!Number.isSafeInteger(attempt) || attempt < 1) {
+        throw new RangeError("keep-alive attempt must be a positive safe integer");
+    }
+    const exponential = LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS * 2 ** (attempt - 1);
+    return Math.min(exponential, LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS);
+}
+//# sourceMappingURL=keep-alive.js.map

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/outpost-dispatch.d.ts

@@ -37,6 +37,7 @@ export interface OutpostLaneCommand {
     model?: string;
     effort?: string;
     worker?: string;
+    keepAlive?: boolean;
     hire?: string;
     grantContext?: string;
     compact?: boolean;

package/dist/lib/lanes/outpost-dispatch.js

@@ -154,6 +154,8 @@ export function buildOutpostLaneCommand(input) {
         if (value !== undefined)
             args.push(flag, value);
     }
+    if (input.action === "resume" && input.keepAlive === true)
+        args.push("--keep-alive");
     if (input.compact === false)
         args.push("--no-compact");
     return withRemoteHqDir(joinCommandParts(args));

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

@@ -17,6 +17,7 @@ export interface WorkerProfileMeta {
     max_concurrent?: number;
     source?: string;
     accounts?: string[];
+    keep_alive?: boolean;
 }
 export interface WorkerProfile {
     id: string;