@indigoai-us/hq-cli 5.201.2 → 5.201.4

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [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
+
+- A flag-registry worker whose startup fails because the working directory was deleted or its package files were being replaced no longer creates a Sentry issue. Other flag-registry worker errors remain visible with a worker tag.
+
 ## [5.201.2] — 2026-09-25
 
 ### Changed

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/flag-registry.js

@@ -6,6 +6,7 @@
  * keep a short-lived, offline CLI alive until the client's network deadline.
  */
 import { Worker } from "node:worker_threads";
+import * as Sentry from "@sentry/node";
 import { isFlagSnapshot, readLocalOverride, resolveFlag, } from "@indigoai-us/hq-flags-client";
 import { readMachineCompanyBinding } from "./work-context/company.js";
 import { readSessionState } from "./work-context/state.js";
@@ -116,12 +117,19 @@ export function kickFlagRegistryReadiness(dependencies = {}) {
     const companyIdentifiers = [companyUid, company.companySlug].filter((value) => Boolean(value));
     processReader = processSnapshotReader(companyIdentifiers);
     try {
-        const worker = (dependencies.createWorker ?? ((filename, options) => new Worker(filename, options)))(new URL("./flag-registry-worker.js", import.meta.url), {
-            workerData: {
-                endpoint,
-                ...(companyUid ? { companyUid } : {}),
-                ...(company.companySlug ? { companyIdentifiers: [company.companySlug] } : {}),
-            },
+        // The SDK's child-process integration captures every Worker error unless
+        // its process-wide captureWorkerErrors option is disabled. Scope only this
+        // worker so the reporting boundary can classify its startup errors without
+        // changing capture for unrelated workers.
+        const worker = Sentry.withScope((scope) => {
+            scope.setTag("worker", "flag-registry");
+            return (dependencies.createWorker ?? ((filename, options) => new Worker(filename, options)))(new URL("./flag-registry-worker.js", import.meta.url), {
+                workerData: {
+                    endpoint,
+                    ...(companyUid ? { companyUid } : {}),
+                    ...(company.companySlug ? { companyIdentifiers: [company.companySlug] } : {}),
+                },
+            });
         });
         worker.on("message", (value) => {
             if (isFlagSnapshot(value))

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/dist/sentry.js

@@ -20,7 +20,14 @@ import { installTreeTornSentryTagsFor, sentryFingerprintFor, sentryMcpCollisionC
  * Consistent with the swallow-EPIPE posture established in #138.
  */
 export function epipeAwareBeforeSend(event, hint) {
-    if (isEpipe(hint?.originalException))
+    const flagRegistryWorkerEvent = isFlagRegistryWorkerEvent(event);
+    if (flagRegistryWorkerEvent) {
+        if (isExpectedFlagRegistryWorkerStartupFailure(hint?.originalException))
+            return null;
+        event.level = "warning";
+        event.tags = { ...event.tags, worker: "flag-registry" };
+    }
+    if (!flagRegistryWorkerEvent && isEpipe(hint?.originalException))
         return null;
     // Path-independent belt for environmental filesystem failures (ENOSPC /
     // EDQUOT / EROFS — a full disk, exhausted quota, or read-only mount, e.g.
@@ -31,7 +38,7 @@ export function epipeAwareBeforeSend(event, hint) {
     // either. handleTopLevelError already prints an actionable message for the
     // boundary route; dropping the event here suppresses the fatal regardless of
     // route, while the CLI still exits non-zero. HQ-CLI-R (Sentry 7671416365).
-    if (environmentalFsErrorMessage(hint?.originalException))
+    if (!flagRegistryWorkerEvent && environmentalFsErrorMessage(hint?.originalException))
         return null;
     // Path-independent belt for an IN-PROCESS incomplete-install module-load
     // failure — hq-cli's own globally installed tree is not intact at load time
@@ -50,7 +57,7 @@ export function epipeAwareBeforeSend(event, hint) {
     // node_modules, so an hq-cli packaging fault (a dist/ miss, or a bare miss the
     // requirer does NOT declare — a possible undeclared/peer dependency) and the
     // path-less unattributable shape are NOT dropped here and stay captured.
-    if (incompleteInstallMessage(hint?.originalException))
+    if (!flagRegistryWorkerEvent && incompleteInstallMessage(hint?.originalException))
         return null;
     // An incomplete-install shape that is NOT suppressed (a bare miss the requirer
     // does not declare, or a path-less loader/resolver ENOENT) should still arrive
@@ -95,6 +102,27 @@ export function epipeAwareBeforeSend(event, hint) {
     }
     return beforeSend(event, hint);
 }
+function isFlagRegistryWorkerEvent(event) {
+    return event.tags?.worker === "flag-registry" && Boolean(event.exception?.values?.some((value) => value.mechanism?.type === "auto.child_process.worker_thread"));
+}
+function isExpectedFlagRegistryWorkerStartupFailure(error) {
+    if (typeof error !== "object" || error === null)
+        return false;
+    const details = error;
+    if (details.code === "ENOENT" && details.syscall === "uv_cwd") {
+        const stack = typeof details.stack === "string" ? details.stack : "";
+        return stack.includes("node:internal/main/worker_thread") && /\bat process\.cwd \(/.test(stack);
+    }
+    if (details.code !== "MODULE_NOT_FOUND" && details.code !== "ERR_MODULE_NOT_FOUND") {
+        return false;
+    }
+    const message = typeof details.message === "string" ? details.message : "";
+    const missingModule = /Cannot find module\s+['"]([^'"]+)['"]/.exec(message)?.[1];
+    if (!missingModule)
+        return false;
+    return missingModule.replaceAll("\\", "/").endsWith("/flag-registry-worker.js") ||
+        missingModule === "flag-registry-worker.js";
+}
 /**
  * Tests substitute only the transport so the real SDK lifecycle can be
  * exercised without an ingest request. Production callers pass nothing.

package/package.json

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