@indigoai-us/hq-cli 5.201.3 → 5.201.4

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [5.201.4] — 2026-09-25
+
+### Fixed
+
+- Claude account balancing on lane resume now respects the attached worker
+  profile's account pin, skips accounts pinned to a different model, and treats
+  `--account` naming the current account as a keep request for message/resume.
+
 ## [5.201.3] — 2026-09-25
 
 ### Fixed

package/dist/commands/lanes.js

@@ -4905,8 +4905,26 @@ function applyResumeProfileAndEffort(current, next, input) {
     }
 }
 function recordResumeSetup(ctx, lane, input) {
+    if (input.cliModel !== undefined) {
+        const model = input.cliModel.trim();
+        if (!model)
+            throw new LanesError("empty_model", "--model is empty or whitespace-only", { value: input.cliModel });
+        const config = loadLanesConfig(ctx.hqRoot());
+        const account = lane.account === undefined
+            ? undefined
+            : config.providers[lane.provider].accounts[lane.account];
+        if (account === undefined) {
+            throw new AccountResolutionError("unknown_account", `Lane ${lane.lane_id} records account ${JSON.stringify(lane.account)} which is not configured for ${lane.provider}`, { provider: lane.provider, account: lane.account ?? "", enabled: [] });
+        }
+        validateLaneModel(lane.provider, model, account.home, {
+            readFileSync: ctx.readFileSync,
+            probe: ctx.probeProvider,
+            env: ctx.env,
+        });
+    }
     if (input.profile === undefined &&
         input.effort === undefined &&
+        input.cliModel === undefined &&
         input.meshCompany === undefined)
         return lane;
     return casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => {
@@ -4915,6 +4933,10 @@ function recordResumeSetup(ctx, lane, input) {
         }
         const next = { ...current };
         applyResumeProfileAndEffort(current, next, input);
+        if (input.cliModel !== undefined) {
+            next.model = input.cliModel.trim();
+            next.model_source = "cli";
+        }
         if (input.meshCompany !== undefined) {
             if (current.company === null)
                 next.mesh_company = input.meshCompany;
@@ -5147,7 +5169,7 @@ async function prepareAccountMove(ctx, lane, input) {
         return { lane: moved, from, to: target, copy, queued };
     }, ctx.sleep);
 }
-async function selectAutomaticClaudeResumeAccount(ctx, lane) {
+async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile) {
     if (lane.provider !== "claude")
         return undefined;
     if (!await ctx.laneClaudeAccountBalanceEnabled(lane.company)) {
@@ -5171,6 +5193,16 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane) {
     }
     const hqRoot = ctx.hqRoot();
     const config = loadLanesConfig(hqRoot);
+    const profile = workerProfile?.profile ?? (lane.worker_profile !== undefined
+        ? loadWorkerProfile(hqRoot, lane.worker_profile)
+        : undefined);
+    const profileDefaultsApply = profile !== undefined && profile.meta.provider === lane.provider;
+    const profileAccount = profileDefaultsApply ? profile?.meta.account : undefined;
+    const profileAccounts = profileDefaultsApply ? profile?.meta.accounts : undefined;
+    const profilePin = profileAccounts ?? (profileAccount === undefined ? undefined : [profileAccount]);
+    const allowedAccounts = profilePin !== undefined && lane.admission_accounts !== undefined
+        ? profilePin.filter((account) => lane.admission_accounts.includes(account))
+        : profilePin ?? lane.admission_accounts;
     const currentConfig = lane.account === undefined
         ? undefined
         : config.providers.claude.accounts[lane.account];
@@ -5181,20 +5213,71 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane) {
             probe: ctx.probeProvider,
             env: ctx.env,
         }).logged_in;
+    const pinnedModel = workerProfile !== undefined
+        ? lane.model_source === "cli" ? lane.model : undefined
+        : lane.model_source === undefined || lane.model_source === "cli"
+            ? lane.model
+            : undefined;
+    const model = resolveLaneModel({
+        cliModel: pinnedModel,
+        profileModel: profileDefaultsApply ? profile?.meta.model : undefined,
+        accountModel: lane.account === undefined ? undefined : config.providers.claude.accounts[lane.account]?.model,
+        providerModel: config.providers.claude.model,
+    });
     const accountNeedsRepair = currentConfig?.enabled !== true || currentLogin === false;
     const mayRebalance = BALANCE_MOVABLE_STATES.includes(lane.state);
     if (!accountNeedsRepair && !mayRebalance)
         return undefined;
     const balanceHosts = await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config);
+    const targetHost = balanceHosts.snapshots.find((host) => host.capacity.host.kind === lane.host.kind && host.capacity.host.id === lane.host.id);
+    const currentTargetAccount = lane.account === undefined
+        ? undefined
+        : targetHost?.capacity.providers.claude.accounts[lane.account];
+    if (profilePin !== undefined &&
+        lane.account !== undefined &&
+        allowedAccounts?.includes(lane.account) &&
+        currentConfig?.enabled === true &&
+        currentTargetAccount?.enabled === true &&
+        currentTargetAccount.logged_in === true &&
+        (model === undefined || currentConfig.model === undefined || currentConfig.model === model))
+        return undefined;
     const selected = selectClaudeAccount({
         hosts: balanceHosts.snapshots,
         targetHost: lane.host,
         config,
-        ...(lane.admission_accounts !== undefined ? { allowedAccounts: lane.admission_accounts } : {}),
+        ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
+        ...(model !== undefined ? { model } : {}),
         unavailableHosts: balanceHosts.unavailableHosts,
     });
     return { ...selected, selected_at: ctx.now().toISOString() };
 }
+function accountRequestKeepsCurrentLane(lane, rawAccount) {
+    const raw = rawAccount.trim();
+    const colon = raw.indexOf(":");
+    const requestedProvider = colon > 0 ? raw.slice(0, colon) : undefined;
+    const requestedAccount = colon > 0 ? raw.slice(colon + 1) : raw;
+    return requestedAccount.length > 0 &&
+        requestedAccount === lane.account &&
+        (requestedProvider === undefined || requestedProvider === lane.provider);
+}
+function assertCurrentResumeAccountAvailable(ctx, lane) {
+    const config = loadLanesConfig(ctx.hqRoot());
+    const account = lane.account === undefined
+        ? undefined
+        : config.providers[lane.provider].accounts[lane.account];
+    if (account === undefined || !account.enabled) {
+        throw new AccountResolutionError(account === undefined ? "unknown_account" : "account_disabled", account === undefined
+            ? `Lane ${lane.lane_id} records account ${JSON.stringify(lane.account)} which is not configured for ${lane.provider}`
+            : `Account ${JSON.stringify(lane.account)} is disabled${account.disabled_reason ? `: ${account.disabled_reason}` : ""}`, { provider: lane.provider, account: lane.account ?? "", ...(account?.disabled_reason !== undefined ? { reason: account.disabled_reason } : {}) });
+    }
+    if (accountStatus(lane.provider, lane.account, config, {
+        existsSync: ctx.existsSync,
+        probe: ctx.probeProvider,
+        env: ctx.env,
+    }).logged_in !== true) {
+        throw new LanesError("account_not_logged_in", `Account ${lane.account} for ${lane.provider} is not logged in (no credential file)`, { provider: lane.provider, account: lane.account, lane_id: lane.lane_id });
+    }
+}
 async function runMessage(ctx, laneId, opts) {
     const hqRoot = ctx.hqRoot();
     const text = opts.text;
@@ -5215,16 +5298,19 @@ async function runMessage(ctx, laneId, opts) {
     // The final state transition repeats this check under the senior lock.
     await withResumeHireAdmission(ctx, lane, () => undefined);
     lane = laneWithRecoveredProviderSession(hqRoot, lane);
-    // An account move is refused on its own terms first: a running lane and a
-    // provider without session resume get the move's named errors, not the
-    // generic delivery refusal below.
-    if (opts.account !== undefined && lane.state === "running") {
+    const keepCurrentAccount = opts.account !== undefined && accountRequestKeepsCurrentLane(lane, opts.account);
+    if (keepCurrentAccount)
+        assertCurrentResumeAccountAvailable(ctx, lane);
+    // A real account move is refused on its own terms first: a running lane and
+    // a provider without session resume get the move's named errors, not the
+    // generic delivery refusal below. Naming the current account is a keep.
+    if (opts.account !== undefined && !keepCurrentAccount && lane.state === "running") {
         throw new LanesError("lane_running", `Lane ${laneId} is running; stop it or wait for it to exit before moving its session`, {
             lane_id: laneId,
             state: lane.state,
         });
     }
-    if (opts.account !== undefined && !providerSupportsSessionResume(lane.provider)) {
+    if (opts.account !== undefined && !keepCurrentAccount && !providerSupportsSessionResume(lane.provider)) {
         throw new LanesError("provider_session_not_portable", `Provider ${lane.provider} has no session resume, so a lane cannot move between its accounts`, { lane_id: laneId, provider: lane.provider });
     }
     // One decision point for how a follow-up reaches this lane (delivery.ts).
@@ -5239,6 +5325,9 @@ async function runMessage(ctx, laneId, opts) {
             message,
         });
     }
+    if (keepCurrentAccount && opts.model !== undefined && mechanism !== "resume") {
+        throw new LanesError("model_requires_resume", "--model with --account requires a message that resumes the lane", { lane_id: laneId, state: lane.state });
+    }
     if (opts.worker !== undefined && mechanism === "dropbox") {
         throw new LanesError("worker_profile_requires_resume", `Lane ${laneId} is still running; --worker can only be applied when message starts a resumed provider turn`, { lane_id: laneId, state: lane.state });
     }
@@ -5252,12 +5341,12 @@ async function runMessage(ctx, laneId, opts) {
         throw new LanesError("model_requires_account", "--model on hq lanes message is only accepted together with --account", {});
     }
     const automaticAccountSelection = opts.account === undefined && mechanism === "resume"
-        ? await selectAutomaticClaudeResumeAccount(ctx, lane)
+        ? await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile)
         : undefined;
     const resumeEffort = resolveResumeEffort(ctx, lane, {
         cliEffort,
         profile: resumeProfile,
-        account: opts.account ?? automaticAccountSelection?.account,
+        account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.account,
         model: opts.model,
     });
     const messageId = mintMessageId();
@@ -5280,7 +5369,7 @@ async function runMessage(ctx, laneId, opts) {
     let resumed = null;
     let move = null;
     let queuedOnAdmission = false;
-    if (opts.account !== undefined) {
+    if (opts.account !== undefined && !keepCurrentAccount) {
         // A moved message is always a resume on the target account: a running
         // lane (the dropbox mechanism) is refused inside prepareAccountMove.
         move = await prepareAccountMove(ctx, lane, {
@@ -5321,13 +5410,14 @@ async function runMessage(ctx, laneId, opts) {
             }
         }
     }
-    if (resumeProfile !== undefined && opts.account === undefined) {
+    if (resumeProfile !== undefined && (opts.account === undefined || keepCurrentAccount)) {
         validateResumeProfileModel(ctx, lane, resumeProfile.profile);
     }
-    if (move === null && (resumeProfile !== undefined || resumeEffort !== undefined)) {
+    if (move === null && (resumeProfile !== undefined || resumeEffort !== undefined || (keepCurrentAccount && opts.model !== undefined))) {
         lane = recordResumeSetup(ctx, lane, {
             ...(resumeProfile !== undefined ? { profile: resumeProfile } : {}),
             ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+            ...(keepCurrentAccount && opts.model !== undefined ? { cliModel: opts.model } : {}),
         });
     }
     if (move?.queued) {
@@ -5751,20 +5841,23 @@ async function runResume(ctx, laneId, opts) {
     const resumeProfile = opts.worker !== undefined
         ? resolveResumeProfile(ctx, lane, opts.worker)
         : undefined;
-    if (resumeProfile !== undefined && opts.account === undefined) {
+    const keepCurrentAccount = opts.account !== undefined && accountRequestKeepsCurrentLane(lane, opts.account);
+    if (keepCurrentAccount)
+        assertCurrentResumeAccountAvailable(ctx, lane);
+    if (resumeProfile !== undefined && (opts.account === undefined || keepCurrentAccount)) {
         validateResumeProfileModel(ctx, lane, resumeProfile.profile);
     }
     const automaticAccountSelection = opts.account === undefined
-        ? await selectAutomaticClaudeResumeAccount(ctx, lane)
+        ? await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile)
         : undefined;
     const resumeEffort = resolveResumeEffort(ctx, lane, {
         cliEffort,
         profile: resumeProfile,
-        account: opts.account ?? automaticAccountSelection?.account,
+        account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.account,
         model: opts.model,
     });
     let move = null;
-    if (opts.account !== undefined) {
+    if (opts.account !== undefined && !keepCurrentAccount) {
         move = await prepareAccountMove(ctx, lane, {
             account: opts.account,
             cliModel: opts.model?.trim() || undefined,
@@ -5805,6 +5898,7 @@ async function runResume(ctx, laneId, opts) {
     lane = recordResumeSetup(ctx, lane, {
         ...(move === null && resumeProfile !== undefined ? { profile: resumeProfile } : {}),
         ...(move === null && resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+        ...(move === null && keepCurrentAccount && opts.model !== undefined ? { cliModel: opts.model } : {}),
         ...(requestedMeshCompany !== undefined
             ? { meshCompany: requestedMeshCompany, threadId: meshThreadId }
             : {}),

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

@@ -67,6 +67,7 @@ export declare function selectClaudeAccount(input: {
     targetHost: LaneHost;
     config: LanesConfig;
     allowedAccounts?: readonly string[];
+    model?: string;
     explicitAccount?: string;
     unavailableHosts?: readonly BalanceHostGap[];
 }): ClaudeAccountSelection;

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

@@ -91,7 +91,10 @@ function buildLoads(input) {
     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);
+        const configuredModel = configAccounts[account]?.model;
+        const ineligible = targetIneligibilityReason(account, configAccounts[account]?.enabled === true, input.allowedAccounts, targetLoad) ?? (input.model !== undefined && configuredModel !== undefined && configuredModel !== input.model
+            ? "model_mismatch"
+            : undefined);
         if (ineligible !== undefined)
             skipped.push({ account, host: targetHost, reason: ineligible });
         const knownCounts = hosts.flatMap((host) => host.live_lanes === null ? [] : [host.live_lanes]);

package/package.json

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