@indigoai-us/hq-cli 5.186.0 → 5.188.0

package/dist/commands/mesh.js

@@ -14,7 +14,7 @@ import chalk from "chalk";
 import { loadCachedTokens, isMachineIdentity } from "../utils/cognito-session.js";
 import * as readline from "node:readline/promises";
 import { STORY_STATUSES, appendThreadEvent, ensureProjectThread, eventPayload, getProjectView, listActiveMembershipCompanies, listActiveThreads, patchStory, putProjectView, registerMeshProject, resolveActiveMembershipCompany, resolveMeshPrincipalUid, warmMeshConversationCache, } from "../lib/mesh/api.js";
-import { closeSupersededProjectThread, ensureMissingBoardStories, ensureProjectBoard, formatStoryStatusChanges, mergeProjectStories, } from "../lib/mesh/project-board.js";
+import { closeSupersededProjectThread, ensureMissingBoardStories, ensureProjectBoard, formatStoryStatusChanges, mergeProjectStories, prdSyncEventsThatChangeBoard, } from "../lib/mesh/project-board.js";
 import { buildPreflightFixtures } from "../lib/work-context/preflight-contract.js";
 import { createCandidatesFetcher, createMigratePoster, createOrganizePoster, createWorkSessionDeliverer, fetchCompanyLive, formatCompanyLiveTable, openMeshTransport, probeMigrationCapabilityForMemberships, requireToken, } from "../lib/mesh/client.js";
 import { clearDefaultCompany, isDefaultCompanyDisabled, readDeviceConfig, recordMigrationCapabilitySnapshot, setRepairHeldWithDefault, setDefaultCompany, } from "../lib/work-context/config.js";
@@ -603,7 +603,25 @@ async function runPrdSync(opts) {
         ...(bound?.projectId ? { project: bound.projectId } : {}),
         touchedPaths: [resolvePath(file)],
     };
+    let toEmit = plan.events;
     if (bound?.companyUid && bound.projectId) {
+        try {
+            const live = await getProjectView(token, bound.companyUid, bound.projectId);
+            toEmit = prdSyncEventsThatChangeBoard(plan.events, live.stories);
+        }
+        catch {
+            // Board unread — emit the snapshot diff; the server drops same-status.
+        }
+        if (toEmit.length === 0) {
+            plan.commit();
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: true, action: "context.prd-sync", changed: 0 }));
+            }
+            else {
+                console.log("Work mesh: prd-sync unchanged");
+            }
+            return;
+        }
         try {
             const source = parseProjectPlan(readFileSync(file, "utf8"), file);
             await ensureMissingBoardStories({
@@ -617,7 +635,7 @@ async function runPrdSync(opts) {
                 description: source.description ?? "",
                 stories: source.stories,
                 repos: source.repos ?? [],
-                requiredIds: plan.events.map((event) => event.taskId),
+                requiredIds: toEmit.map((event) => event.taskId),
             });
         }
         catch (err) {
@@ -625,9 +643,12 @@ async function runPrdSync(opts) {
             console.error(`work-mesh: prd-sync ensure failed; emitting anyway (${reason.slice(0, 160)})`);
         }
     }
+    const alreadyOnBoard = plan.events
+        .filter((event) => !toEmit.some((row) => row.taskId === event.taskId))
+        .map((event) => event.taskId);
     const meshRoot = workMeshHomeRoot();
-    const seqFirst = reserveSessionSeq(sessionId, plan.events.length);
-    const events = plan.events.map((event, index) => buildMeshEmitEvent({
+    const seqFirst = reserveSessionSeq(sessionId, toEmit.length);
+    const events = toEmit.map((event, index) => buildMeshEmitEvent({
         eventId: generateUlid(Date.now() + index),
         kind: "task_status",
         sessionId,
@@ -659,7 +680,7 @@ async function runPrdSync(opts) {
             blocked.add(id);
     }
     const advanced = events.flatMap((event) => (event.eventId && event.taskId && !blocked.has(event.eventId) ? [event.taskId] : []));
-    plan.commit(advanced);
+    plan.commit([...alreadyOnBoard, ...advanced]);
     if (plan.taskId && advanced.includes(plan.taskId)) {
         updateSessionState(sessionId, root, (current) => {
             if (!current)
@@ -673,10 +694,10 @@ async function runPrdSync(opts) {
         });
     }
     if (opts.json) {
-        console.log(JSON.stringify({ ok: true, action: "context.prd-sync", changed: plan.events.length, taskId: plan.taskId }));
+        console.log(JSON.stringify({ ok: true, action: "context.prd-sync", changed: toEmit.length, taskId: plan.taskId }));
         return;
     }
-    console.log(`Work mesh: prd-sync emitted ${plan.events.length} task_status`);
+    console.log(`Work mesh: prd-sync emitted ${toEmit.length} task_status`);
 }
 function noteCallingSessionBound(projectId, company) {
     try {

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

@@ -0,0 +1,82 @@
+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";
+export declare const BALANCE_LIVE_STATES: readonly ["running", "queued", "awaiting_input"];
+export declare const BALANCE_MOVABLE_STATES: readonly ["interrupted", "done", "awaiting_input"];
+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;
+    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;
+    live_lanes: number;
+    counts_complete: boolean;
+    usage: NonNullable<HostCapacityAccount["usage"]> | null;
+    hosts: AccountHostLoad[];
+}
+export interface ClaudeAccountSelection {
+    account: string;
+    signal: "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[];
+    explicitAccount?: string;
+    unavailableHosts?: readonly BalanceHostGap[];
+}): ClaudeAccountSelection;
+export declare function accountLoadsForReport(input: {
+    hosts: readonly BalanceHostSnapshot[];
+    config: LanesConfig;
+}): ClaudeAccountLoad[];
+export declare function planClaudeBalanceMoves(input: {
+    hosts: readonly BalanceHostSnapshot[];
+    config: LanesConfig;
+}): BalanceMoveSuggestion[];
+export declare function assertBalanceApplyEnabled(enabled: boolean): void;
+//# sourceMappingURL=claude-account-balance.d.ts.map

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

@@ -0,0 +1,253 @@
+import { LanesError } from "./errors.js";
+export const CLAUDE_ACCOUNT_BALANCE_FLAG = "lanes.claude-account-balance";
+export const BALANCE_LIVE_STATES = ["running", "queued", "awaiting_input"];
+export const BALANCE_MOVABLE_STATES = ["interrupted", "done", "awaiting_input"];
+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: 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,
+            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,
+            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,
+        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 selectionSignal(loads) {
+    return loads.length > 0 && loads.every((load) => usageScore(load.usage) !== null)
+        ? "usage"
+        : "lane_count";
+}
+function targetIneligibilityReason(accountId, globalEnabled, allowedAccounts, target) {
+    if (!globalEnabled || !target.enabled)
+        return "disabled";
+    if (allowedAccounts !== undefined && !allowedAccounts.includes(accountId))
+        return "not_allowed_by_lane";
+    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 ineligible = targetIneligibilityReason(account, configAccounts[account]?.enabled === true, input.allowedAccounts, targetLoad);
+        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 } : {}),
+            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,
+            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 { loads, skipped } = buildLoads({ ...input, target });
+    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",
+            })),
+            unavailable_hosts: input.unavailableHosts ?? [],
+        });
+    }
+    const signal = selectionSignal(eligible);
+    eligible.sort((a, b) => {
+        if (signal === "usage") {
+            const byUsage = usageScore(a.usage) - usageScore(b.usage);
+            if (byUsage !== 0)
+                return byUsage;
+        }
+        return a.live_lanes - b.live_lanes || 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 }).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 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 sourceStatus = hostSnapshot.capacity.providers.claude.accounts[source];
+        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;
+}
+export function assertBalanceApplyEnabled(enabled) {
+    if (!enabled) {
+        throw new LanesError("claude_account_balance_disabled", `Applying Claude account balance moves requires hq-flags gate ${CLAUDE_ACCOUNT_BALANCE_FLAG}`, { flag: CLAUDE_ACCOUNT_BALANCE_FLAG });
+    }
+}
+//# sourceMappingURL=claude-account-balance.js.map

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

@@ -5,6 +5,19 @@ export interface HostCapacityAccount {
     max_running: number;
     running: number;
     queued: number;
+    /** Exact lane states used for Claude account balancing; absent on older Outposts. */
+    lane_counts?: {
+        running: number;
+        queued: number;
+        awaiting_input: number;
+        live: number;
+    };
+    /** Provider-reported usage, when a host can read a recent sample. */
+    usage?: {
+        five_hour_percent?: number;
+        weekly_percent?: number;
+        sampled_at?: string;
+    };
 }
 export interface HostCapacityProvider {
     max_running: number;
@@ -30,6 +43,12 @@ export declare function buildHostCapacitySnapshot(input: {
     lanes: readonly LaneRecord[];
     config: LanesConfig;
     existsSync: (path: string) => boolean;
+    probe?: (command: string, args: string[], env: NodeJS.ProcessEnv) => {
+        status: number | null;
+        stdout: string;
+        stderr: string;
+    };
+    env?: NodeJS.ProcessEnv;
     now: Date;
 }): HostCapacitySnapshot;
 /** Reject malformed remote snapshots before they can influence host selection. */

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

@@ -21,13 +21,23 @@ export function buildHostCapacitySnapshot(input) {
         for (const [id, account] of Object.entries(providerConfig.accounts)) {
             const status = accountStatus(provider, id, input.config, {
                 existsSync: input.existsSync,
+                ...(input.probe !== undefined ? { probe: input.probe } : {}),
+                ...(input.env !== undefined ? { env: input.env } : {}),
             });
+            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,
                 max_running: accountMaxRunning(providerConfig, id),
                 running: running.filter((lane) => lane.account === id).length,
                 queued: queued.filter((lane) => lane.account === id).length,
+                lane_counts: {
+                    running: liveLanes.filter((lane) => lane.state === "running").length,
+                    queued: liveLanes.filter((lane) => lane.state === "queued").length,
+                    awaiting_input: liveLanes.filter((lane) => lane.state === "awaiting_input").length,
+                    live: liveLanes.length,
+                },
             };
         }
         providers[provider] = {
@@ -101,6 +111,12 @@ export function parseHostCapacitySnapshot(raw) {
                 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`),
+                ...(account.lane_counts !== undefined
+                    ? { lane_counts: parseLaneCounts(account.lane_counts, `${provider}.${id}.lane_counts`) }
+                    : {}),
+                ...(account.usage !== undefined
+                    ? { usage: parseUsage(account.usage, `${provider}.${id}.usage`) }
+                    : {}),
             };
         }
         providers[provider] = {
@@ -118,6 +134,58 @@ export function parseHostCapacitySnapshot(raw) {
         providers,
     };
 }
+function parseLaneCounts(value, field) {
+    const counts = objectValue(value);
+    if (counts === undefined) {
+        throw new LanesError("host_capacity_invalid", `Invalid host capacity field ${field}`, { field });
+    }
+    const running = requireCount(counts.running, `${field}.running`);
+    const queued = requireCount(counts.queued, `${field}.queued`);
+    const awaiting_input = requireCount(counts.awaiting_input, `${field}.awaiting_input`);
+    const live = requireCount(counts.live, `${field}.live`);
+    if (running + queued + awaiting_input !== live) {
+        throw new LanesError("host_capacity_invalid", `Inconsistent host capacity field ${field}`, {
+            field,
+            running,
+            queued,
+            awaiting_input,
+            live,
+        });
+    }
+    return { running, queued, awaiting_input, live };
+}
+function parseUsage(value, field) {
+    const usage = objectValue(value);
+    if (usage === undefined) {
+        throw new LanesError("host_capacity_invalid", `Invalid host capacity field ${field}`, { field });
+    }
+    const parsed = {};
+    for (const key of ["five_hour_percent", "weekly_percent"]) {
+        const percentage = usage[key];
+        if (percentage !== undefined) {
+            if (typeof percentage !== "number" || !Number.isFinite(percentage) || percentage < 0 || percentage > 100) {
+                throw new LanesError("host_capacity_invalid", `Invalid host capacity field ${field}.${key}`, {
+                    field: `${field}.${key}`,
+                    value: percentage ?? null,
+                });
+            }
+            parsed[key] = percentage;
+        }
+    }
+    if (Object.keys(parsed).length === 0) {
+        throw new LanesError("host_capacity_invalid", `Empty host capacity field ${field}`, { field });
+    }
+    if (usage.sampled_at !== undefined) {
+        if (typeof usage.sampled_at !== "string" || !Number.isFinite(Date.parse(usage.sampled_at))) {
+            throw new LanesError("host_capacity_invalid", `Invalid host capacity field ${field}.sampled_at`, {
+                field: `${field}.sampled_at`,
+                value: usage.sampled_at ?? null,
+            });
+        }
+        parsed.sampled_at = usage.sampled_at;
+    }
+    return parsed;
+}
 /**
  * Choose the least-loaded eligible host/account from advisory snapshots. The
  * selected host still runs the shared admission check under its own lock.

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

@@ -10,7 +10,7 @@ export type { AdmissionCapReason, AdmissionHost } from "./admission.js";
 export { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "./host-capacity.js";
 export type { HostCapacityAccount, HostCapacityProvider, HostCapacitySnapshot, HostPlacementChoice, } 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";
-export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneEnvelope, LaneHost, LaneProvider, LanePlacementPolicy, LaneRecord, LaneStory, LaneStoryStatus, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
+export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneAccountSelection, LaneAccountSelectionConsidered, LaneAccountSelectionHostCount, LaneEnvelope, LaneHost, LaneProvider, LanePlacementPolicy, LaneRecord, LaneStory, LaneStoryStatus, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
 export { ACTIVE_LANE_STORY_STATUSES, activeLaneStories, laneStories, laneStory, storyKey, storyStatusForEnvelope, storyWarning, withCurrentStory, withLaneStories, } from "./stories.js";
 export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerAutoCompactTokens, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";
 export type { ConfigLoadDeps, ConfigWriteDeps } from "./config.js";

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -61,12 +61,21 @@ export declare function parseOutpostPickupPayload(raw: unknown): OutpostPickupPa
 export declare function buildOutpostPickupCommand(payloadUrl: string): string;
 /** Bounded, read-only capacity query executed by the target Outpost CLI. */
 export declare function buildOutpostCapacityCommand(): string;
+/** Read the lane records owned by an Outpost for exact per-account state counts. */
+export declare function buildOutpostLaneListCommand(): string;
 /** Commit a queued lane move on the host that currently owns its state. */
 export declare function buildOutpostMoveTargetCommand(input: {
     laneId: string;
     host: LaneHost;
     account: string;
 }): string;
+/** Move an owned Claude session between accounts while leaving its turn parked. */
+export declare function buildOutpostBalanceMoveCommand(input: {
+    laneId: string;
+    account: string;
+    fromAccount: string;
+    expectedState: LaneRecord["state"];
+}): string;
 /** Idempotently backfill the marker on the selected Outpost. */
 export declare function buildOutpostIdentityBackfillCommand(expectedId: string): string;
 /** Build the same `hq outposts exec` remote command used by lane pickup. */

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

@@ -46,6 +46,10 @@ export function buildOutpostPickupCommand(payloadUrl) {
 export function buildOutpostCapacityCommand() {
     return withRemoteHqDir(joinCommandParts(["hq", "lanes", "capacity", "--json"]));
 }
+/** Read the lane records owned by an Outpost for exact per-account state counts. */
+export function buildOutpostLaneListCommand() {
+    return withRemoteHqDir(joinCommandParts(["hq", "lanes", "list", "--json"]));
+}
 /** Commit a queued lane move on the host that currently owns its state. */
 export function buildOutpostMoveTargetCommand(input) {
     return withRemoteHqDir(joinCommandParts([
@@ -61,6 +65,21 @@ export function buildOutpostMoveTargetCommand(input) {
         input.account,
     ]));
 }
+/** Move an owned Claude session between accounts while leaving its turn parked. */
+export function buildOutpostBalanceMoveCommand(input) {
+    return withRemoteHqDir(joinCommandParts([
+        "hq",
+        "lanes",
+        "balance-move-target",
+        input.laneId,
+        "--account",
+        input.account,
+        "--from-account",
+        input.fromAccount,
+        "--expected-state",
+        input.expectedState,
+    ]));
+}
 /** Idempotently backfill the marker on the selected Outpost. */
 export function buildOutpostIdentityBackfillCommand(expectedId) {
     return withRemoteHqDir(joinCommandParts([