@indigoai-us/hq-cli 5.313.0 → 5.314.0

package/dist/lib/lanes/blocker-freshness.d.ts

@@ -1,31 +0,0 @@
-import { type ManagerStatusTarget } from "./manager-status-gate.js";
-import { readLanesRegistryFlag } from "./registry-flag.js";
-import type { LaneRecord } from "./types.js";
-export declare const BLOCKER_FRESHNESS_FLAG = "lanes.blocker-freshness";
-export declare const BLOCKER_FRESHNESS_DEFAULT_HOURS = 4;
-export declare const BLOCKER_FRESHNESS_FUTURE_GRACE_MS: number;
-export interface StaleBlocker {
-    key: string;
-    label: string;
-}
-export interface BlockerFreshnessResolution {
-    /** The company-scoped flag value, kept separate from manager applicability. */
-    flagEnabled: boolean;
-    /** True only when the flag is on and this lane has a valid manager target. */
-    enabled: boolean;
-    target?: ManagerStatusTarget;
-    statusPath?: string;
-    windowHours: number;
-    stale: StaleBlocker[];
-    error?: string;
-}
-export interface BlockerFreshnessResolutionOptions {
-    env?: NodeJS.ProcessEnv;
-    now?: number;
-    readFlag?: typeof readLanesRegistryFlag;
-    onError?: (error: unknown) => void;
-}
-export declare function blockerFreshnessFingerprint(stale: readonly StaleBlocker[]): string;
-/** Resolve the flag before touching the manager mapping or status artifact. */
-export declare function resolveBlockerFreshnessForLane(root: string, lane: LaneRecord, options?: BlockerFreshnessResolutionOptions): Promise<BlockerFreshnessResolution>;
-//# sourceMappingURL=blocker-freshness.d.ts.map

package/dist/lib/lanes/blocker-freshness.js

@@ -1,168 +0,0 @@
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import { LanesError } from "./errors.js";
-import { DEFAULT_BLOCKER_FRESHNESS_HOURS, loadLanesConfig } from "./config.js";
-import { resolveManagerStatusTarget } from "./manager-status-gate.js";
-import { readLanesRegistryFlag } from "./registry-flag.js";
-import { resolveLaneCompany } from "./lane-company.js";
-import { assertNoSecretText } from "./text-scan.js";
-export const BLOCKER_FRESHNESS_FLAG = "lanes.blocker-freshness";
-export const BLOCKER_FRESHNESS_DEFAULT_HOURS = DEFAULT_BLOCKER_FRESHNESS_HOURS;
-export const BLOCKER_FRESHNESS_FUTURE_GRACE_MS = 5 * 60 * 1000;
-const TERMINAL_BLOCKER_STATUSES = new Set([
-    "closed",
-    "resolved",
-    "done",
-    "superseded",
-    "cancelled",
-]);
-function isObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function errorCode(error) {
-    return error instanceof LanesError ? error.error : "blocker_freshness_unavailable";
-}
-function reportError(lane, error) {
-    process.stderr.write(`hq lanes: blocker freshness disabled for ${lane.lane_id}: ${errorCode(error)}\n`);
-}
-function failedResolution(flagEnabled, error, onError) {
-    onError(error);
-    return {
-        flagEnabled,
-        enabled: false,
-        windowHours: BLOCKER_FRESHNESS_DEFAULT_HOURS,
-        stale: [],
-        error: errorCode(error),
-    };
-}
-function identityFor(blocker, index) {
-    for (const field of ["id", "item", "what", "reason"]) {
-        const candidate = blocker[field];
-        if (typeof candidate === "string" && candidate.trim().length > 0) {
-            const identity = candidate.trim();
-            assertNoSecretText(`blocker ${field}`, identity);
-            return {
-                key: blockerKey(`${field}:${identity}`),
-                label: identity.slice(0, 120),
-            };
-        }
-    }
-    const identity = `index:${index + 1}`;
-    const label = `blocker ${index + 1}`;
-    assertNoSecretText("blocker label", label);
-    return { key: blockerKey(identity), label };
-}
-function hasClosingTimestamp(blocker) {
-    return [blocker.closed_at, blocker.resolved_at].some((value) => value !== undefined && value !== null && value !== "");
-}
-function blockerKey(label) {
-    return createHash("sha256").update(label, "utf8").digest("hex");
-}
-function readBlockers(statusPath) {
-    let stat;
-    try {
-        stat = fs.lstatSync(statusPath);
-    }
-    catch (error) {
-        throw new LanesError("blocker_freshness_status_unreadable", `Cannot inspect manager status ${statusPath}: ${error instanceof Error ? error.message : String(error)}`, { path: statusPath });
-    }
-    if (!stat.isFile() || stat.isSymbolicLink()) {
-        throw new LanesError("blocker_freshness_status_invalid", `Manager status must be a regular file: ${statusPath}`, { path: statusPath });
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(statusPath, "utf8"));
-    }
-    catch (error) {
-        throw new LanesError("blocker_freshness_status_invalid", `Manager status contains invalid JSON: ${statusPath}`, { path: statusPath, cause: error instanceof Error ? error.name : "UnknownError" });
-    }
-    if (!isObject(parsed) || !Array.isArray(parsed.blockers)) {
-        throw new LanesError("blocker_freshness_status_invalid", `Manager status must contain a top-level blockers array: ${statusPath}`, { path: statusPath });
-    }
-    return parsed.blockers.filter(isObject);
-}
-function isStale(verifiedAt, now, windowHours) {
-    if (typeof verifiedAt !== "string")
-        return true;
-    const verifiedAtMs = Date.parse(verifiedAt);
-    if (!Number.isFinite(verifiedAtMs))
-        return true;
-    if (verifiedAtMs - now > BLOCKER_FRESHNESS_FUTURE_GRACE_MS)
-        return true;
-    return now - verifiedAtMs > windowHours * 60 * 60 * 1000;
-}
-export function blockerFreshnessFingerprint(stale) {
-    const keys = stale.map((item) => item.key).sort();
-    return createHash("sha256").update(JSON.stringify(keys), "utf8").digest("hex");
-}
-/** Resolve the flag before touching the manager mapping or status artifact. */
-export async function resolveBlockerFreshnessForLane(root, lane, options = {}) {
-    const onError = options.onError ?? ((error) => reportError(lane, error));
-    let flagEnabled;
-    try {
-        flagEnabled = await (options.readFlag ?? readLanesRegistryFlag)(BLOCKER_FRESHNESS_FLAG, {
-            company: resolveLaneCompany(root, lane).company ?? undefined,
-            env: options.env,
-        });
-    }
-    catch (error) {
-        return failedResolution(false, error, onError);
-    }
-    if (!flagEnabled) {
-        return {
-            flagEnabled: false,
-            enabled: false,
-            windowHours: BLOCKER_FRESHNESS_DEFAULT_HOURS,
-            stale: [],
-        };
-    }
-    let target;
-    try {
-        target = resolveManagerStatusTarget(root, lane);
-    }
-    catch (error) {
-        return failedResolution(true, error, onError);
-    }
-    if (!target.manager || target.statusPath === undefined) {
-        return {
-            flagEnabled: true,
-            enabled: false,
-            target,
-            windowHours: BLOCKER_FRESHNESS_DEFAULT_HOURS,
-            stale: [],
-        };
-    }
-    let windowHours;
-    let blockers;
-    try {
-        windowHours = loadLanesConfig(root).blocker_freshness_hours;
-        blockers = readBlockers(target.statusPath);
-    }
-    catch (error) {
-        return failedResolution(true, error, onError);
-    }
-    const now = options.now ?? Date.now();
-    const stale = [];
-    try {
-        for (const [index, blocker] of blockers.entries()) {
-            const status = typeof blocker.status === "string" ? blocker.status.trim().toLowerCase() : "";
-            if (TERMINAL_BLOCKER_STATUSES.has(status) || hasClosingTimestamp(blocker))
-                continue;
-            if (!isStale(blocker.verified_at, now, windowHours))
-                continue;
-            stale.push(identityFor(blocker, index));
-        }
-    }
-    catch (error) {
-        return failedResolution(true, error, onError);
-    }
-    return {
-        flagEnabled: true,
-        enabled: true,
-        target,
-        statusPath: target.statusPath,
-        windowHours,
-        stale,
-    };
-}
-//# sourceMappingURL=blocker-freshness.js.map

package/dist/lib/lanes/checked-company-path.d.ts

@@ -1,3 +0,0 @@
-/** The shared HQ/company path validation used by lane tracker mappings. */
-export declare function checkCompanyPath(root: string, company: string, file: string, detailsPath: string): string;
-//# sourceMappingURL=checked-company-path.d.ts.map

package/dist/lib/lanes/checked-company-path.js

@@ -1,39 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { LanesError } from "./errors.js";
-function fail(error, message, details) {
-    throw new LanesError(error, message, details);
-}
-function isWithin(root, candidate) {
-    const relative = path.relative(root, candidate);
-    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
-}
-/** The shared HQ/company path validation used by lane tracker mappings. */
-export function checkCompanyPath(root, company, file, detailsPath) {
-    if (path.isAbsolute(file))
-        return fail("tracker_checks_mapping_invalid", "Mapped path must be relative to the HQ root", { path: detailsPath });
-    const absolute = path.resolve(root, file);
-    const rootReal = fs.realpathSync(root);
-    if (!isWithin(rootReal, absolute))
-        return fail("tracker_checks_mapping_invalid", "Mapped path escapes the HQ root", { path: detailsPath });
-    const relative = path.relative(rootReal, absolute).split(path.sep);
-    if (relative[0] === "companies" && relative[1] !== company) {
-        return fail("tracker_checks_mapping_invalid", "Mapped path crosses the active company boundary", { path: detailsPath });
-    }
-    try {
-        const real = fs.realpathSync(absolute);
-        if (!isWithin(rootReal, real))
-            return fail("tracker_checks_mapping_invalid", "Mapped path resolves outside the HQ root", { path: detailsPath });
-        const realRelative = path.relative(rootReal, real).split(path.sep);
-        if (realRelative[0] === "companies" && realRelative[1] !== company) {
-            return fail("tracker_checks_mapping_invalid", "Mapped path resolves into another company", { path: detailsPath });
-        }
-    }
-    catch (err) {
-        if (err.code !== "ENOENT") {
-            return fail("tracker_checks_mapping_unreadable", `Mapped path could not be checked: ${err instanceof Error ? err.message : String(err)}`, { path: absolute });
-        }
-    }
-    return absolute;
-}
-//# sourceMappingURL=checked-company-path.js.map

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

@@ -1,97 +0,0 @@
-import type { AuthState } from "./accounts.js";
-import type { HostCapacityAccount, HostCapacitySnapshot } from "./host-capacity.js";
-import type { LaneHost, 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"];
-export declare const CLAUDE_RECENT_USAGE_WINDOW_MS: number;
-export interface BalanceHostSnapshot {
-    capacity: HostCapacitySnapshot;
-    lanes: readonly LaneRecord[];
-    /** False means the lane list could not be read; capacity counts may be partial. */
-    laneListAvailable: boolean;
-}
-export interface BalanceHostGap {
-    host: LaneHost | {
-        kind: "unknown";
-        id: "unknown";
-    };
-    reason: string;
-}
-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;
-        queued: number | null;
-        awaiting_input: number | null;
-    };
-    count_source: "lane_list" | "capacity" | "capacity_partial" | "unavailable";
-}
-export interface ClaudeAccountLoad {
-    account: string;
-    target_enabled: boolean;
-    target_logged_in: boolean | null;
-    eligible: boolean;
-    ineligible_reason?: string;
-    quota_reset_at?: string;
-    quota_marker?: string;
-    quota_model?: string;
-    live_lanes: number;
-    counts_complete: boolean;
-    usage: NonNullable<HostCapacityAccount["usage"]> | null;
-    recent_usage_at: string | null;
-    hosts: AccountHostLoad[];
-}
-export interface ClaudeAccountSelection {
-    account: string;
-    signal: "usage" | "recent_usage" | "lane_count" | "explicit";
-    reason: "least_loaded" | "explicit";
-    target_host: LaneHost;
-    considered: ClaudeAccountLoad[];
-    skipped_accounts: Array<{
-        account: string;
-        host: LaneHost;
-        reason: string;
-    }>;
-    unavailable_hosts: BalanceHostGap[];
-}
-export interface BalanceMoveSuggestion {
-    lane_id: string;
-    host: LaneHost;
-    state: LaneRecord["state"];
-    from: string;
-    to: string;
-    reason: "account_load" | "source_unavailable";
-    apply: boolean;
-    skip_reason?: "running_turn" | "state_not_movable" | "no_provider_session" | "pending_resume";
-}
-export declare function selectClaudeAccount(input: {
-    hosts: readonly BalanceHostSnapshot[];
-    targetHost: LaneHost;
-    config: LanesConfig;
-    allowedAccounts?: readonly string[];
-    model?: string;
-    /** Keep the recorded account eligible for its already-running CLI model. */
-    recordedModelAccount?: string;
-    quotaState?: QuotaState;
-    /** Recent completed-run tiebreak; callers pass the default-off hq-flags result. */
-    recentUsageEnabled?: boolean;
-    now?: Date;
-    explicitAccount?: string;
-    unavailableHosts?: readonly BalanceHostGap[];
-}): ClaudeAccountSelection;
-export declare function accountLoadsForReport(input: {
-    hosts: readonly BalanceHostSnapshot[];
-    config: LanesConfig;
-    quotaState?: QuotaState;
-}): ClaudeAccountLoad[];
-export declare function planClaudeBalanceMoves(input: {
-    hosts: readonly BalanceHostSnapshot[];
-    config: LanesConfig;
-}): BalanceMoveSuggestion[];
-//# sourceMappingURL=claude-balance.d.ts.map

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

@@ -1,319 +0,0 @@
-import { LanesError } from "./errors.js";
-import { quotaBlockFor } from "./quota.js";
-export const BALANCE_LIVE_STATES = ["running", "queued", "awaiting_input"];
-export const BALANCE_MOVABLE_STATES = ["interrupted", "done", "awaiting_input"];
-export const CLAUDE_RECENT_USAGE_WINDOW_MS = 5 * 60 * 60 * 1000;
-function sameHost(a, b) {
-    return a.kind === b.kind && a.id === b.id;
-}
-function isBalanceLive(lane) {
-    return BALANCE_LIVE_STATES.includes(lane.state);
-}
-function countLaneStates(lanes, account) {
-    const rows = lanes.filter((lane) => lane.provider === "claude" && lane.account === account && isBalanceLive(lane));
-    const running = rows.filter((lane) => lane.state === "running").length;
-    const queued = rows.filter((lane) => lane.state === "queued").length;
-    const awaiting_input = rows.filter((lane) => lane.state === "awaiting_input").length;
-    return { running, queued, awaiting_input, live: running + queued + awaiting_input };
-}
-function accountHostLoad(host, accountId) {
-    const hostCapacity = host.capacity.providers.claude.accounts[accountId];
-    if (!hostCapacity) {
-        return {
-            host: host.capacity.host,
-            enabled: 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)
-                : { running: null, queued: null, awaiting_input: null },
-            count_source: host.laneListAvailable ? "lane_list" : "unavailable",
-        };
-    }
-    if (host.laneListAvailable) {
-        const counts = countLaneStates(host.lanes, accountId);
-        return {
-            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",
-        };
-    }
-    if (hostCapacity.lane_counts !== undefined) {
-        return {
-            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,
-                queued: hostCapacity.lane_counts.queued,
-                awaiting_input: hostCapacity.lane_counts.awaiting_input,
-            },
-            count_source: "capacity",
-        };
-    }
-    return {
-        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",
-    };
-}
-function usageScore(usage) {
-    if (usage?.five_hour_percent === undefined || usage.weekly_percent === undefined)
-        return null;
-    return Math.max(usage.five_hour_percent, usage.weekly_percent);
-}
-function recentUsageAt(hosts, account, now) {
-    if (hosts.some((host) => !host.laneListAvailable))
-        return null;
-    const nowMs = now.getTime();
-    const cutoff = nowMs - CLAUDE_RECENT_USAGE_WINDOW_MS;
-    let latestAt = null;
-    let latestMs = cutoff - 1;
-    for (const host of hosts) {
-        for (const lane of host.lanes) {
-            if (lane.provider !== "claude" || lane.account !== account ||
-                lane.last_run_usage === undefined || lane.last_run_usage_at === undefined)
-                continue;
-            const atMs = Date.parse(lane.last_run_usage_at);
-            if (!Number.isFinite(atMs) || atMs < cutoff || atMs > nowMs || atMs <= latestMs)
-                continue;
-            latestMs = atMs;
-            latestAt = lane.last_run_usage_at;
-        }
-    }
-    return latestAt;
-}
-function selectionSignal(loads, recentUsageEnabled, laneSnapshotsComplete) {
-    if (loads.length > 0 && loads.every((load) => usageScore(load.usage) !== null))
-        return "usage";
-    return recentUsageEnabled && laneSnapshotsComplete ? "recent_usage" : "lane_count";
-}
-function targetIneligibilityReason(accountId, globalEnabled, allowedAccounts, target) {
-    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)
-        return "login_status_unknown";
-    return undefined;
-}
-function buildLoads(input) {
-    const configAccounts = input.config.providers.claude.accounts;
-    const targetHost = input.target.capacity.host;
-    const skipped = [];
-    const loads = Object.keys(configAccounts).sort().map((account) => {
-        const hosts = input.hosts.map((host) => accountHostLoad(host, account));
-        const targetLoad = hosts.find((host) => sameHost(host.host, targetHost));
-        const configuredModel = configAccounts[account]?.model;
-        const quotaModel = input.model ?? configuredModel ?? input.config.providers.claude.model;
-        const quotaBlock = input.quotaState === undefined
-            ? undefined
-            : quotaBlockFor(input.quotaState, "claude", account, quotaModel, input.now);
-        const ineligible = targetIneligibilityReason(account, configAccounts[account]?.enabled === true, input.allowedAccounts, targetLoad) ?? (account !== input.recordedModelAccount &&
-            input.model !== undefined && configuredModel !== undefined && configuredModel !== input.model
-            ? "model_mismatch"
-            : quotaBlock?.blocked === true
-                ? "quota_held"
-                : undefined);
-        if (ineligible !== undefined)
-            skipped.push({ account, host: targetHost, reason: ineligible });
-        const knownCounts = hosts.flatMap((host) => host.live_lanes === null ? [] : [host.live_lanes]);
-        return {
-            account,
-            target_enabled: targetLoad.enabled && configAccounts[account]?.enabled === true,
-            target_logged_in: targetLoad.logged_in,
-            eligible: ineligible === undefined,
-            ...(ineligible !== undefined ? { ineligible_reason: ineligible } : {}),
-            ...(quotaBlock?.blocked ? {
-                ...(quotaBlock.quota_reset_at !== undefined ? { quota_reset_at: quotaBlock.quota_reset_at } : {}),
-                ...(quotaBlock.marker !== undefined ? { quota_marker: quotaBlock.marker } : {}),
-                ...(quotaBlock.model !== undefined ? { quota_model: quotaBlock.model } : {}),
-            } : {}),
-            live_lanes: knownCounts.reduce((sum, count) => sum + count, 0),
-            counts_complete: hosts.every((host) => host.live_lanes !== null && host.count_source !== "capacity_partial"),
-            usage: input.target.capacity.providers.claude.accounts[account]?.usage ?? null,
-            recent_usage_at: recentUsageAt(input.hosts, account, input.now),
-            hosts,
-        };
-    });
-    return { loads, skipped };
-}
-export function selectClaudeAccount(input) {
-    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,
-            unavailable_hosts: input.unavailableHosts ?? [],
-        });
-    }
-    const now = input.now ?? new Date();
-    const { loads, skipped } = buildLoads({ ...input, target, now });
-    if (input.explicitAccount !== undefined) {
-        const selected = loads.find((load) => load.account === input.explicitAccount);
-        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",
-                account_reasons: skipped,
-                unavailable_hosts: input.unavailableHosts ?? [],
-            });
-        }
-        return {
-            account: input.explicitAccount,
-            signal: "explicit",
-            reason: "explicit",
-            target_host: input.targetHost,
-            considered: loads,
-            skipped_accounts: skipped,
-            unavailable_hosts: [...(input.unavailableHosts ?? [])],
-        };
-    }
-    const eligible = loads.filter((load) => load.eligible);
-    if (eligible.length === 0) {
-        const unknownAccounts = loads
-            .filter((load) => load.ineligible_reason === "login_status_unknown")
-            .map((load) => load.account);
-        const unknownLoginDetail = unknownAccounts.length > 0
-            ? `; login status is unknown for ${unknownAccounts.join(", ")}`
-            : "";
-        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,
-            account_reasons: loads.map((load) => ({
-                account: load.account,
-                reason: load.ineligible_reason ?? "unavailable",
-                ...(load.quota_reset_at !== undefined ? { quota_reset_at: load.quota_reset_at } : {}),
-                ...(load.quota_marker !== undefined ? { marker: load.quota_marker } : {}),
-                ...(load.quota_model !== undefined ? { model: load.quota_model } : {}),
-            })),
-            unavailable_hosts: input.unavailableHosts ?? [],
-        });
-    }
-    const signal = selectionSignal(eligible, input.recentUsageEnabled === true, input.hosts.every((host) => host.laneListAvailable) && (input.unavailableHosts?.length ?? 0) === 0);
-    eligible.sort((a, b) => {
-        if (signal === "usage") {
-            const byUsage = usageScore(a.usage) - usageScore(b.usage);
-            if (byUsage !== 0)
-                return byUsage;
-        }
-        const byLiveLanes = a.live_lanes - b.live_lanes;
-        if (byLiveLanes !== 0)
-            return byLiveLanes;
-        if (signal === "recent_usage") {
-            if (a.recent_usage_at === null && b.recent_usage_at !== null)
-                return -1;
-            if (a.recent_usage_at !== null && b.recent_usage_at === null)
-                return 1;
-            if (a.recent_usage_at !== null && b.recent_usage_at !== null) {
-                const byRecentUsage = Date.parse(a.recent_usage_at) - Date.parse(b.recent_usage_at);
-                if (byRecentUsage !== 0)
-                    return byRecentUsage;
-            }
-        }
-        return a.account.localeCompare(b.account);
-    });
-    return {
-        account: eligible[0].account,
-        signal,
-        reason: "least_loaded",
-        target_host: input.targetHost,
-        considered: loads,
-        skipped_accounts: skipped,
-        unavailable_hosts: [...(input.unavailableHosts ?? [])],
-    };
-}
-export function accountLoadsForReport(input) {
-    const first = input.hosts[0];
-    if (!first)
-        return [];
-    return buildLoads({ hosts: input.hosts, target: first, config: input.config, quotaState: input.quotaState, now: new Date() }).loads.map((load) => ({
-        ...load,
-        eligible: false,
-        ineligible_reason: undefined,
-    }));
-}
-export function planClaudeBalanceMoves(input) {
-    const loads = accountLoadsForReport(input);
-    const projected = new Map(loads.map((load) => [load.account, load.live_lanes]));
-    const lanes = input.hosts.flatMap((host) => host.lanes
-        .filter((lane) => lane.provider === "claude" && lane.account && (isBalanceLive(lane) || BALANCE_MOVABLE_STATES.includes(lane.state)))
-        .map((lane) => ({ lane, host: host.capacity.host })))
-        .sort((a, b) => a.lane.created_at.localeCompare(b.lane.created_at) || a.lane.lane_id.localeCompare(b.lane.lane_id));
-    const suggestions = [];
-    for (const { lane, host } of lanes) {
-        const source = lane.account;
-        const sourceLoad = projected.get(source) ?? 0;
-        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) => ({
-            account,
-            targetStatus: hostSnapshot.capacity.providers.claude.accounts[account],
-            load: projected.get(account) ?? 0,
-        }))
-            .filter((candidate) => candidate.targetStatus?.enabled === true && candidate.targetStatus.logged_in === true)
-            .sort((a, b) => a.load - b.load || a.account.localeCompare(b.account));
-        const sourceUnavailable = sourceStatus.enabled !== true || sourceStatus.logged_in !== true;
-        const target = candidates[0];
-        const laneIsLive = isBalanceLive(lane);
-        if (!target || (!sourceUnavailable && (!laneIsLive || target.load >= sourceLoad)))
-            continue;
-        const movable = BALANCE_MOVABLE_STATES.includes(lane.state);
-        const sessionId = lane.provider_session_id ?? lane.last_resume?.session_id;
-        const skipReason = lane.state === "running"
-            ? "running_turn"
-            : !movable
-                ? "state_not_movable"
-                : lane.pending_resume !== undefined
-                    ? "pending_resume"
-                    : typeof sessionId !== "string" || sessionId.trim() === ""
-                        ? "no_provider_session"
-                        : undefined;
-        suggestions.push({
-            lane_id: lane.lane_id,
-            host,
-            state: lane.state,
-            from: source,
-            to: target.account,
-            reason: sourceUnavailable ? "source_unavailable" : "account_load",
-            apply: skipReason === undefined,
-            ...(skipReason !== undefined ? { skip_reason: skipReason } : {}),
-        });
-        if (skipReason === undefined) {
-            if (laneIsLive) {
-                projected.set(source, Math.max(0, sourceLoad - 1));
-                projected.set(target.account, target.load + 1);
-            }
-        }
-    }
-    return suggestions;
-}
-//# sourceMappingURL=claude-balance.js.map