@indigoai-us/hq-cli 5.328.0 → 5.330.0

package/dist/commands/lanes-message.js

@@ -297,6 +297,25 @@ export function createLaneMessageHandlers(deps) {
             return;
         }
         assertLaneRunsHereForOperatorMutation(ctx, lane, "message");
+        const projectId = opts.project?.trim() || lane.project_id;
+        const storyId = opts.story?.trim() || lane.story_id;
+        if (opts.story !== undefined && !opts.story.trim()) {
+            throw new LanesError("missing_story", "--story must be non-empty", {});
+        }
+        const refreshProfileSettings = lane.state === "done" &&
+            (projectId !== lane.project_id || storyId !== lane.story_id) &&
+            await deps.reuseProfileRefreshEnabled(ctx, lane);
+        const refreshWorker = opts.worker ?? (refreshProfileSettings ? lane.worker_profile : undefined);
+        let resumeProfile = refreshProfileSettings && refreshWorker !== undefined
+            ? resolveResumeProfile(ctx, lane, refreshWorker, true)
+            : undefined;
+        if (resumeProfile !== undefined) {
+            const providerPinned = lane.provider_source === undefined || lane.provider_source === "cli";
+            const effectiveProvider = providerPinned ? lane.provider : resumeProfile.profile.meta.provider;
+            if (effectiveProvider !== lane.provider) {
+                throw new LanesError("profile_provider_changed", `Worker profile now selects ${effectiveProvider}; this lane runs ${lane.provider}; create a new lane`, { lane_id: lane.lane_id, lane_provider: lane.provider, profile_provider: effectiveProvider });
+            }
+        }
         if (lane.state === "running") {
             const workerPidPath = path.join(laneRunDir(hqRoot, laneId), "worker.pid");
             const workerRecordExists = fs.existsSync(workerPidPath);
@@ -413,8 +432,8 @@ export function createLaneMessageHandlers(deps) {
             if (cliEffort !== undefined && mechanism === "dropbox") {
                 throw new LanesError("lane_effort_requires_resume", `Lane ${laneId} is still running; --effort can only be applied when message starts a resumed provider turn`, { lane_id: laneId, state: lane.state });
             }
-            const resumeProfile = opts.worker !== undefined
-                ? resolveResumeProfile(ctx, lane, opts.worker)
+            resumeProfile ??= refreshWorker !== undefined
+                ? resolveResumeProfile(ctx, lane, refreshWorker, refreshProfileSettings)
                 : undefined;
             if (opts.model !== undefined && opts.account === undefined) {
                 throw new LanesError("model_requires_account", "--model on hq lanes message is only accepted together with --account", {});
@@ -425,6 +444,7 @@ export function createLaneMessageHandlers(deps) {
                 try {
                     automaticAccountSelection = await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile, {
                         tolerateInvalidHostLaneLists: lane.host.kind === "local",
+                        ...(refreshProfileSettings ? { refreshProfileSettings: true } : {}),
                     });
                 }
                 catch (err) {
@@ -446,7 +466,15 @@ export function createLaneMessageHandlers(deps) {
                     automaticAccountSelection = undefined;
                 }
             }
-            const resumeEffort = resolveResumeEffort(ctx, lane, {
+            const profileRefreshAccount = refreshProfileSettings && resumeProfile !== undefined &&
+                lane.account_source !== undefined && lane.account_source !== "cli" &&
+                resumeProfile.profile.meta.provider === lane.provider
+                ? resumeProfile.profile.meta.account ?? (resumeProfile.profile.meta.accounts !== undefined &&
+                    !resumeProfile.profile.meta.accounts.includes(lane.account ?? "")
+                    ? resumeProfile.profile.meta.accounts[0]
+                    : undefined)
+                : undefined;
+            const resumeEffort = refreshProfileSettings && cliEffort === undefined ? undefined : resolveResumeEffort(ctx, lane, {
                 cliEffort,
                 profile: resumeProfile,
                 account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.selection.account,
@@ -454,8 +482,6 @@ export function createLaneMessageHandlers(deps) {
             });
             const messageId = mintMessageId();
             const at = ctx.now().toISOString();
-            const projectId = opts.project?.trim() || lane.project_id;
-            const storyId = opts.story?.trim() || lane.story_id;
             if (opts.story !== undefined && !opts.story.trim()) {
                 throw new LanesError("missing_story", "--story must be non-empty", {});
             }
@@ -589,6 +615,7 @@ export function createLaneMessageHandlers(deps) {
                     account: opts.account,
                     cliModel: opts.model?.trim() || undefined,
                     ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
+                    ...(refreshProfileSettings ? { refreshProfileSettings: true, accountSource: "cli" } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
                     pending: {
@@ -616,6 +643,7 @@ export function createLaneMessageHandlers(deps) {
                             cliModel: undefined,
                             ...(automatic.historyReason !== undefined ? { accountHistoryReason: automatic.historyReason } : {}),
                             ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
+                            ...(refreshProfileSettings ? { refreshProfileSettings: true, accountSource: "balanced" } : {}),
                             ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                             ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
                             pending: {
@@ -638,13 +666,38 @@ export function createLaneMessageHandlers(deps) {
                         lane = persistClaudeAccountSelection(hqRoot, lane, selection);
                     }
                 }
+                if (move === null && profileRefreshAccount !== undefined && profileRefreshAccount !== lane.account) {
+                    move = await prepareAccountMove(ctx, lane, {
+                        account: profileRefreshAccount,
+                        cliModel: undefined,
+                        workerProfile: resumeProfile,
+                        refreshProfileSettings: true,
+                        accountSource: "profile",
+                        ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+                        ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
+                        pending: {
+                            trigger: messageHistoryTrigger,
+                            text: deliveryText,
+                            ...(isMonitorEvent ? { monitor_event: true } : {}),
+                            message_id: messageId,
+                            compact: opts.compact !== false,
+                        },
+                    });
+                    lane = move.lane;
+                    if (move.queued) {
+                        storySwitchDeliveryStarted = true;
+                        deps.onLaneMessageQueued?.(laneId, "account_move");
+                        archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+                    }
+                }
             }
-            if (resumeProfile !== undefined && (opts.account === undefined || keepCurrentAccount)) {
+            if (resumeProfile !== undefined && !refreshProfileSettings && (opts.account === undefined || keepCurrentAccount)) {
                 validateResumeProfileModel(ctx, lane, resumeProfile.profile);
             }
             if (move === null && (resumeProfile !== undefined || resumeEffort !== undefined || (keepCurrentAccount && opts.model !== undefined))) {
                 lane = recordResumeSetup(ctx, lane, {
                     ...(resumeProfile !== undefined ? { profile: resumeProfile } : {}),
+                    ...(refreshProfileSettings ? { refreshProfileSettings: true } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     ...(keepCurrentAccount && opts.model !== undefined ? { cliModel: opts.model } : {}),
                 });

package/dist/commands/lanes-resume.js

@@ -185,6 +185,28 @@ export function createLaneResumeHandlers(deps) {
         const pendingQuestion = lane.state === "awaiting_input"
             ? await deps.hasPendingQuestionForLane(ctx, lane)
             : false;
+        const projectId = opts.project?.trim() || lane.project_id;
+        const storyId = opts.story?.trim() || lane.story_id;
+        if (opts.story !== undefined && !opts.story.trim()) {
+            throw new LanesError("missing_story", "--story must be non-empty", {});
+        }
+        if ((opts.project !== undefined || opts.story !== undefined) && ctx.storyLedgerEnabled()) {
+            validateProjectStories(hqRoot, projectId, [storyId], lane.company?.slug);
+        }
+        const attributionChanged = projectId !== lane.project_id || storyId !== lane.story_id;
+        const refreshProfileSettings = lane.state === "done" && attributionChanged &&
+            await deps.reuseProfileRefreshEnabled(ctx, lane);
+        const refreshWorker = opts.worker ?? (refreshProfileSettings ? lane.worker_profile : undefined);
+        let resumeProfile = refreshProfileSettings && refreshWorker !== undefined
+            ? resolveResumeProfile(ctx, lane, refreshWorker, true)
+            : undefined;
+        if (resumeProfile !== undefined) {
+            const providerPinned = lane.provider_source === undefined || lane.provider_source === "cli";
+            const effectiveProvider = providerPinned ? lane.provider : resumeProfile.profile.meta.provider;
+            if (effectiveProvider !== lane.provider) {
+                throw new LanesError("profile_provider_changed", `Worker profile now selects ${effectiveProvider}; this lane runs ${lane.provider}; create a new lane`, { lane_id: lane.lane_id, lane_provider: lane.provider, profile_provider: effectiveProvider });
+            }
+        }
         const refusal = queuedProfileRecovery || (lane.state === "awaiting_input" && !pendingQuestion)
             ? null
             : resumeCommandRefusal(lane, { allowFailed: opts.fromFailed === true });
@@ -200,15 +222,6 @@ export function createLaneResumeHandlers(deps) {
         const resumedFrom = lane.state;
         const text = opts.text?.trim() ? opts.text : undefined;
         const at = ctx.now().toISOString();
-        const projectId = opts.project?.trim() || lane.project_id;
-        const storyId = opts.story?.trim() || lane.story_id;
-        if (opts.story !== undefined && !opts.story.trim()) {
-            throw new LanesError("missing_story", "--story must be non-empty", {});
-        }
-        if ((opts.project !== undefined || opts.story !== undefined) && ctx.storyLedgerEnabled()) {
-            validateProjectStories(hqRoot, projectId, [storyId], lane.company?.slug);
-        }
-        const attributionChanged = projectId !== lane.project_id || storyId !== lane.story_id;
         const messageId = text !== undefined || attributionChanged ? mintMessageId() : undefined;
         const notice = storySwitchNotice(lane.project_id, lane.story_id, projectId, storyId);
         const deliveryText = notice === undefined ? text : `${notice}${text === undefined ? "" : `\n\n${text}`}`;
@@ -226,8 +239,8 @@ export function createLaneResumeHandlers(deps) {
             }
             meshThreadId = await ctx.mesh.ensureProjectThread(requestedMeshCompany, projectId);
         }
-        const resumeProfile = opts.worker !== undefined
-            ? resolveResumeProfile(ctx, lane, opts.worker)
+        resumeProfile ??= refreshWorker !== undefined
+            ? resolveResumeProfile(ctx, lane, refreshWorker, refreshProfileSettings)
             : undefined;
         const profileRepin = authorizeResumeProfileRepin(ctx, lane, resumeProfile, opts.profileRepinContext);
         const keepAlive = opts.keepAlive === true
@@ -236,7 +249,7 @@ export function createLaneResumeHandlers(deps) {
         const keepCurrentAccount = opts.account !== undefined && accountRequestKeepsCurrentLane(lane, opts.account);
         if (keepCurrentAccount)
             assertCurrentResumeAccountAvailable(ctx, lane);
-        if (resumeProfile !== undefined && (opts.account === undefined || keepCurrentAccount)) {
+        if (resumeProfile !== undefined && !refreshProfileSettings && (opts.account === undefined || keepCurrentAccount)) {
             validateResumeProfileModel(ctx, lane, resumeProfile.profile);
         }
         if (lane.state === "queued" && lane.queued_reason === "worker_profile_changed") {
@@ -262,9 +275,20 @@ export function createLaneResumeHandlers(deps) {
             return;
         }
         const automaticAccountSelection = opts.account === undefined
-            ? await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile, { repairUnavailableAccount: true })
+            ? await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile, {
+                repairUnavailableAccount: true,
+                ...(refreshProfileSettings ? { refreshProfileSettings: true } : {}),
+            })
+            : undefined;
+        const profileRefreshAccount = refreshProfileSettings && resumeProfile !== undefined &&
+            lane.account_source !== undefined && lane.account_source !== "cli" &&
+            resumeProfile.profile.meta.provider === lane.provider
+            ? resumeProfile.profile.meta.account ?? (resumeProfile.profile.meta.accounts !== undefined &&
+                !resumeProfile.profile.meta.accounts.includes(lane.account ?? "")
+                ? resumeProfile.profile.meta.accounts[0]
+                : undefined)
             : undefined;
-        const resumeEffort = resolveResumeEffort(ctx, lane, {
+        const resumeEffort = refreshProfileSettings && cliEffort === undefined ? undefined : resolveResumeEffort(ctx, lane, {
             cliEffort,
             profile: resumeProfile,
             account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.selection.account,
@@ -325,6 +349,7 @@ export function createLaneResumeHandlers(deps) {
                     account: opts.account,
                     cliModel: opts.model?.trim() || undefined,
                     ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
+                    ...(refreshProfileSettings ? { refreshProfileSettings: true, accountSource: "cli" } : {}),
                     ...(profileRepin !== undefined ? { profileRepin } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
@@ -355,6 +380,7 @@ export function createLaneResumeHandlers(deps) {
                             ? { preservedModel: automaticAccountSelection.preservedModel }
                             : {}),
                         ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
+                        ...(refreshProfileSettings ? { refreshProfileSettings: true, accountSource: "balanced" } : {}),
                         ...(profileRepin !== undefined ? { profileRepin } : {}),
                         ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                         ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
@@ -377,8 +403,33 @@ export function createLaneResumeHandlers(deps) {
                     lane = persistClaudeAccountSelection(hqRoot, lane, selection);
                 }
             }
+            else if (profileRefreshAccount !== undefined && profileRefreshAccount !== lane.account) {
+                move = await prepareAccountMove(ctx, lane, {
+                    account: profileRefreshAccount,
+                    cliModel: undefined,
+                    workerProfile: resumeProfile,
+                    refreshProfileSettings: true,
+                    accountSource: "profile",
+                    ...(profileRepin !== undefined ? { profileRepin } : {}),
+                    ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+                    ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
+                    pending: {
+                        trigger: "resume",
+                        resumed_from: resumedFrom,
+                        ...(opts.fromFailed === true ? { from_failed: true } : {}),
+                        ...(failedResumeExpectedSenior !== undefined ? { expected_senior: failedResumeExpectedSenior } : {}),
+                        ...(deliveryText !== undefined ? { text: deliveryText } : {}),
+                        ...(messageId !== undefined ? { message_id: messageId } : {}),
+                        compact: opts.compact !== false,
+                    },
+                });
+                lane = move.lane;
+            }
             lane = recordResumeSetup(ctx, lane, {
-                ...(move === null && resumeProfile !== undefined ? { profile: resumeProfile } : {}),
+                ...(move === null && resumeProfile !== undefined ? {
+                    profile: resumeProfile,
+                    ...(refreshProfileSettings ? { refreshProfileSettings: true } : {}),
+                } : {}),
                 ...(move === null && profileRepin !== undefined ? { profileRepin } : {}),
                 ...(move === null && resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                 ...(keepAlive !== undefined ? { keepAlive } : {}),

package/dist/commands/lanes-shared.d.ts

@@ -107,6 +107,10 @@ export interface PrepareAccountMoveInput {
     /** Copy the session and change account while preserving the between-turn state. */
     deferTurnStart?: boolean;
     accountSelection?: LaneAccountSelection;
+    /** Apply current profile settings during a done-lane story reuse that also moves accounts. */
+    refreshProfileSettings?: boolean;
+    /** Provenance recorded for the account this move selects. */
+    accountSource?: "cli" | "balanced" | "profile";
 }
 export interface RecordResumeSetupInput {
     profile?: ResolvedResumeProfile;
@@ -118,6 +122,8 @@ export interface RecordResumeSetupInput {
     profileRepin?: ResumeProfileRepinAuthorization;
     /** Clear only the recoverable worker_profile_changed queue after its profile is revalidated. */
     clearWorkerProfileChangedQueue?: boolean;
+    /** Apply current profile provider/model/account/effort for a done-lane story reuse. */
+    refreshProfileSettings?: boolean;
 }
 export declare function accountRequestKeepsCurrentLane(lane: LaneRecord, rawAccount: string): boolean;
 export declare function assertCurrentResumeAccountAvailable(ctx: Ctx, lane: LaneRecord): void;
@@ -191,7 +197,8 @@ export interface LaneMessageHandlerDeps {
     resolveActiveQuestionCompany(ctx: Ctx, message?: string): Promise<LaneCompanyRef>;
     hasPendingQuestionForLane(ctx: Ctx, lane: LaneRecord): Promise<boolean>;
     cancelFallbackQuestionsForLane(ctx: Ctx, lane: LaneRecord, trigger: "message" | "resume", at: string): Promise<FallbackQuestionCancellationResult>;
-    resolveResumeProfile(ctx: Ctx, lane: LaneRecord, workerId: string): ResolvedResumeProfile;
+    resolveResumeProfile(ctx: Ctx, lane: LaneRecord, workerId: string, allowProviderChange?: boolean): ResolvedResumeProfile;
+    reuseProfileRefreshEnabled(ctx: Ctx, lane: LaneRecord): Promise<boolean>;
     selectAutomaticClaudeResumeAccount(ctx: Ctx, lane: LaneRecord, workerProfile?: ResolvedResumeProfile, options?: {
         repairUnavailableAccount?: boolean;
         tolerateInvalidHostLaneLists?: boolean;
@@ -203,7 +210,7 @@ export interface LaneMessageHandlerDeps {
     validateResumeProfileModel(ctx: Ctx, lane: LaneRecord, profile: WorkerProfile): void;
     withResumeHireAdmission<T>(ctx: Ctx, lane: LaneRecord, fn: () => T, grantContext?: OutpostHireGrantContext): Promise<T>;
 }
-export interface LaneResumeHandlerDeps extends Pick<LaneMessageHandlerDeps, "onLaneWorkerStarted" | "archiveResumeMessage" | "assertLaneRunsHereForAdmission" | "assertLaneRunsHereForOperatorMutation" | "assessLaneAdmission" | "casUpdateLane" | "laneIsHostedHere" | "laneWithRecoveredProviderSession" | "mintMessageId" | "prepareAccountMove" | "persistClaudeAccountSelection" | "printJson" | "recordResumeSetup" | "resolveCommandLane" | "hasPendingQuestionForLane" | "cancelFallbackQuestionsForLane" | "resolveResumeProfile" | "selectAutomaticClaudeResumeAccount" | "validateResumeProfileModel" | "withResumeHireAdmission"> {
+export interface LaneResumeHandlerDeps extends Pick<LaneMessageHandlerDeps, "onLaneWorkerStarted" | "archiveResumeMessage" | "assertLaneRunsHereForAdmission" | "assertLaneRunsHereForOperatorMutation" | "assessLaneAdmission" | "casUpdateLane" | "laneIsHostedHere" | "laneWithRecoveredProviderSession" | "mintMessageId" | "prepareAccountMove" | "persistClaudeAccountSelection" | "printJson" | "recordResumeSetup" | "resolveCommandLane" | "hasPendingQuestionForLane" | "cancelFallbackQuestionsForLane" | "resolveResumeProfile" | "reuseProfileRefreshEnabled" | "selectAutomaticClaudeResumeAccount" | "validateResumeProfileModel" | "withResumeHireAdmission"> {
     dispatchOutpostLaneCommand(ctx: Ctx, lane: LaneRecord, action: "resume", options: LaneResumeOptions, behavior?: OutpostLaneDispatchBehavior): Promise<void>;
     authorizeFailedResume(ctx: Ctx, lane: LaneRecord, encodedContext?: string): string;
     authorizeResumeProfileRepin(ctx: Ctx, lane: LaneRecord, profile: ResolvedResumeProfile | undefined, encodedContext: string | undefined): ResumeProfileRepinAuthorization | undefined;

package/dist/commands/lanes.js

@@ -35,7 +35,7 @@ import { withCliFeatureUsed } from "../utils/cli-telemetry.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "../lib/lanes/registry-flag.js";
-import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, } from "../lib/lanes/flag-keys.js";
+import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, } from "../lib/lanes/flag-keys.js";
 import { CODEX_ROLLOUT_RETENTION_FLAG, configuredCodexRolloutHomes, lowDiskGuardEnabledForLane, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
@@ -500,6 +500,15 @@ function hireGrantFinishedChildrenDoNotCount(ctx, lane) {
         env: ctx.env,
     }, readLanesRegistryFlag);
 }
+function reuseProfileRefreshEnabled(ctx, lane) {
+    const resolution = resolveLaneCompany(ctx.hqRoot(), lane);
+    const company = resolution.company ?? undefined;
+    return readLanesRegistryFlagFailOff(LANE_REUSE_REFRESHES_PROFILE_FLAG, {
+        company,
+        ...(company ? { companyUidSource: laneCompanyUidSource(resolution.source) } : {}),
+        env: ctx.env,
+    }, readLanesRegistryFlag);
+}
 function mergeOwnerLaneHierarchy(supplied, ownerLanes) {
     const byId = new Map();
     for (const lane of supplied)
@@ -3581,7 +3590,17 @@ async function runCreate(ctx, opts) {
             keep_alive: keepAlive,
             ...(keepAlive ? { keep_alive_opted_in_at: createdAt } : {}),
             provider,
+            provider_source: explicitProvider !== undefined
+                ? "cli"
+                : profile?.meta.provider !== undefined
+                    ? "profile"
+                    : "default",
             account: pinnedAccount,
+            account_source: accountWasExplicit
+                ? "cli"
+                : profileAccount !== undefined
+                    ? "profile"
+                    : "balanced",
             ...(accountSelection !== undefined ? { account_selection: accountSelection } : {}),
             ...(defaultPlacement !== undefined
                 ? { placement_default: defaultPlacement }
@@ -6238,14 +6257,14 @@ async function runAdmit(ctx, laneId, opts) {
         });
     }, ctx.sleep);
 }
-function resolveResumeProfile(ctx, lane, workerId) {
+function resolveResumeProfile(ctx, lane, workerId, allowProviderChange = false) {
     const worker = resolveLaneWorker(ctx.hqRoot(), workerId.trim(), lane.company?.slug ?? lane.mesh_company?.slug, undefined, lane.worker_profile === workerId.trim() && lane.registry_worker !== undefined
         ? { registryWorkerRecord: lane.registry_worker }
         : {});
     if (worker.profile === undefined) {
         throw new LanesError("worker_profile_required", `Worker ${JSON.stringify(workerId)} resolves to a registry worker, not a reusable provider profile; resume --worker requires personal/workers/<id>/meta.yaml`, { worker: workerId, path: worker.path });
     }
-    if (worker.profile.meta.provider !== lane.provider) {
+    if (!allowProviderChange && worker.profile.meta.provider !== lane.provider) {
         throw new LanesError("worker_profile_provider_mismatch", `Worker profile ${JSON.stringify(workerId)} uses provider ${worker.profile.meta.provider}, but lane ${lane.lane_id} uses ${lane.provider}; resume cannot change a lane's provider`, {
             worker: workerId,
             lane_id: lane.lane_id,
@@ -6299,7 +6318,7 @@ function applyResumeProfileAndEffort(current, next, input) {
             };
             next.worker_profile_repin_history = appendCappedHistory(current.worker_profile_repin_history ?? [], entry);
         }
-        next.worker_profile_ignored = ignoredWorkerProfileFields(current.provider);
+        next.worker_profile_ignored = ignoredWorkerProfileFields(next.provider);
         next.worker_policy_delivery = undefined;
         if (profile.meta.keep_alive !== undefined) {
             next.keep_alive = profile.meta.keep_alive;
@@ -6308,7 +6327,64 @@ function applyResumeProfileAndEffort(current, next, input) {
                 : undefined;
             next.keep_alive_blocked_reason = undefined;
         }
-        if (next.model_source !== "cli" && next.model_source !== "preserved") {
+        if (input.refreshProfileSettings === true) {
+            const providerPinned = current.provider_source === undefined || current.provider_source === "cli";
+            const accountPinned = next.account_source === undefined || next.account_source === "cli";
+            const targetProvider = providerPinned ? current.provider : profile.meta.provider;
+            if (targetProvider !== current.provider) {
+                throw new LanesError("profile_provider_changed", `Worker profile now selects ${targetProvider}; this lane runs ${current.provider}; create a new lane`, { lane_id: current.lane_id, lane_provider: current.provider, profile_provider: targetProvider });
+            }
+            const profileMatchesProvider = profile.meta.provider === targetProvider;
+            const nextModel = next.model_source === "cli" || next.model_source === "preserved"
+                ? next.model
+                : current.model_source === "cli" || current.model_source === "preserved" ||
+                    (providerPinned && !profileMatchesProvider)
+                    ? current.model
+                    : profileMatchesProvider ? profile.meta.model : undefined;
+            const nextEffort = current.effort_source === "cli" || (providerPinned && !profileMatchesProvider)
+                ? current.effort
+                : profileMatchesProvider ? profile.meta.effort : undefined;
+            const profileAccounts = profileMatchesProvider ? profile.meta.accounts : undefined;
+            const profileAccount = profileMatchesProvider && profileAccounts === undefined
+                ? profile.meta.account
+                : profileAccounts?.includes(next.account ?? "") ? next.account : profileAccounts?.[0];
+            next.provider = targetProvider;
+            next.provider_source = providerPinned ? current.provider_source : "profile";
+            if (!accountPinned && profileMatchesProvider) {
+                next.account = profileAccount;
+                next.account_source = profileAccount === undefined ? "balanced" : "profile";
+                next.account_selection = undefined;
+            }
+            if (profileAccounts !== undefined) {
+                if (accountPinned && current.account !== undefined && !profileAccounts.includes(current.account)) {
+                    throw new LanesError("profile_account_not_allowed", `Worker profile ${profile.id} no longer allows pinned lane account ${current.account}`, { lane_id: current.lane_id, worker: profile.id, account: current.account, allowed_accounts: profileAccounts });
+                }
+                next.admission_accounts = [...profileAccounts];
+            }
+            next.model = nextModel;
+            next.model_source = next.model_source === "cli" || next.model_source === "preserved"
+                ? next.model_source
+                : current.model_source === "cli" || current.model_source === "preserved"
+                    ? current.model_source
+                    : nextModel === undefined ? "none" : "profile";
+            next.effort = nextEffort;
+            next.effort_source = current.effort_source === "cli"
+                ? "cli"
+                : nextEffort === undefined ? "none" : "profile";
+            next.profile_settings_pinned = true;
+            if (current.provider !== next.provider || current.model !== next.model || current.effort !== next.effort) {
+                const entry = {
+                    at: input.at ?? new Date().toISOString(),
+                    actor: `profile:${profile.id}`,
+                    reason: "worker_profile_refresh",
+                    ...(current.provider !== next.provider ? { provider: { from: current.provider, to: next.provider } } : {}),
+                    ...(current.model !== next.model ? { model: { from: current.model ?? null, to: next.model ?? "(provider default)" } } : {}),
+                    ...(current.effort !== next.effort ? { effort: { from: current.effort ?? null, to: next.effort ?? "(provider default)" } } : {}),
+                };
+                next.settings_history = appendCappedHistory(current.settings_history ?? [], entry);
+            }
+        }
+        else if (next.model_source !== "cli" && next.model_source !== "preserved") {
             if (profile.meta.provider === current.provider && profile.meta.model !== undefined) {
                 next.model = profile.meta.model;
                 next.model_source = "profile";
@@ -6355,6 +6431,7 @@ function recordResumeSetup(ctx, lane, input) {
         input.cliModel === undefined &&
         input.meshCompany === undefined &&
         input.clearWorkerProfileChangedQueue !== true &&
+        input.refreshProfileSettings !== true &&
         lane.keep_alive_blocked_reason !== "terminal_state")
         return lane;
     return casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => {
@@ -6470,6 +6547,12 @@ async function prepareAccountMove(ctx, lane, input) {
     const profile = input.workerProfile?.profile ?? (lane.worker_profile !== undefined
         ? loadWorkerProfile(hqRoot, lane.worker_profile)
         : undefined);
+    if (input.refreshProfileSettings === true &&
+        profile?.meta.provider === lane.provider &&
+        profile.meta.accounts !== undefined &&
+        !profile.meta.accounts.includes(target)) {
+        throw new LanesError("profile_account_not_allowed", `Account ${target} is not in worker profile ${profile.id}'s allowed accounts`, { lane_id: laneId, worker: profile.id, account: target, allowed_accounts: profile.meta.accounts });
+    }
     const profileDefaultsApply = profile !== undefined && profile.meta.provider === lane.provider;
     const pinnedModel = input.preservedModel ?? (input.workerProfile !== undefined
         ? lane.model_source === "cli" || lane.model_source === "preserved" ? lane.model : undefined
@@ -6556,6 +6639,7 @@ async function prepareAccountMove(ctx, lane, input) {
             const next = {
                 ...current,
                 account: target,
+                ...(input.accountSource !== undefined ? { account_source: input.accountSource } : {}),
                 ...(input.accountSelection !== undefined ? { account_selection: input.accountSelection } : {}),
                 admission_accounts: undefined,
                 provider_session_id: sessionId,
@@ -6584,6 +6668,7 @@ async function prepareAccountMove(ctx, lane, input) {
                 ...(input.workerProfile !== undefined ? { profile: input.workerProfile } : {}),
                 ...(input.profileRepin !== undefined ? { profileRepin: input.profileRepin } : {}),
                 ...(input.effort !== undefined ? { effort: input.effort } : {}),
+                ...(input.refreshProfileSettings === true ? { refreshProfileSettings: true } : {}),
                 at,
             });
             if (input.deferTurnStart) {
@@ -6631,9 +6716,11 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
     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 allowedAccounts = options.refreshProfileSettings === true
+        ? profilePin ?? lane.admission_accounts
+        : profilePin !== undefined && lane.admission_accounts !== undefined
+            ? profilePin.filter((account) => lane.admission_accounts.includes(account))
+            : profilePin ?? lane.admission_accounts;
     const pinnedModel = workerProfile !== undefined
         ? lane.model_source === "cli" || lane.model_source === "preserved" ? lane.model : undefined
         : lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
@@ -8280,6 +8367,7 @@ export function registerLanesCommand(parent, deps = {}) {
         hasPendingQuestionForLane: questionHandlers.hasPendingQuestionForLane,
         cancelFallbackQuestionsForLane: questionHandlers.cancelFallbackQuestionsForLane,
         resolveResumeProfile,
+        reuseProfileRefreshEnabled,
         selectAutomaticClaudeResumeAccount,
         validateResumeProfileModel,
         withResumeHireAdmission,
@@ -8307,6 +8395,7 @@ export function registerLanesCommand(parent, deps = {}) {
         hasPendingQuestionForLane: questionHandlers.hasPendingQuestionForLane,
         cancelFallbackQuestionsForLane: questionHandlers.cancelFallbackQuestionsForLane,
         resolveResumeProfile,
+        reuseProfileRefreshEnabled,
         selectAutomaticClaudeResumeAccount,
         validateResumeProfileModel,
         withResumeHireAdmission,

package/dist/commands/mcp-status.js

@@ -24,6 +24,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { anywhereRuntimeEnabled } from './anywhere-runtime-flag.js';
+import { claudeTargets } from '../lib/install/claude-targets.js';
 import { HQ_PACK_PROVENANCE_KEY, SECRET_REDACTION, backupRoot, claudeConfigFormat, claudeConfigPath, codexConfigFormat, codexConfigPath, CODEX_MCP_SERVERS_KEY, ConfigParseError, isCodexInstalled, readConfigDoc, resolveEnv, } from './mcp-registration.js';
 // ---------------------------------------------------------------------------
 // Pure status computation.
@@ -84,6 +85,49 @@ function summarizeDef(def) {
 function summariesDiffer(a, b) {
     return JSON.stringify(a) !== JSON.stringify(b);
 }
+function findAnywherePluginMcp(home) {
+    const claude = path.join(home, '.claude');
+    try {
+        const targets = claudeTargets(home);
+        const state = JSON.parse(fs.readFileSync(targets.stateFile, 'utf8'));
+        const pluginId = state.plugin?.pluginId;
+        if (typeof pluginId !== 'string' || pluginId.length === 0)
+            return undefined;
+        const settings = JSON.parse(fs.readFileSync(targets.settingsJson, 'utf8'));
+        if (settings.enabledPlugins?.[pluginId] !== true)
+            return undefined;
+        const installedFile = path.join(claude, 'plugins', 'installed_plugins.json');
+        const installed = JSON.parse(fs.readFileSync(installedFile, 'utf8'));
+        const install = installed.plugins?.[pluginId]?.find((entry) => typeof entry.installPath === 'string');
+        if (!install || typeof install.installPath !== 'string' || !path.isAbsolute(install.installPath))
+            return undefined;
+        const installDir = path.resolve(install.installPath);
+        const cacheRoot = path.resolve(claude, 'plugins', 'cache');
+        const cacheRelative = path.relative(cacheRoot, installDir);
+        if (cacheRelative.startsWith('..') || path.isAbsolute(cacheRelative) || !cacheRelative.split(path.sep).includes('hq'))
+            return undefined;
+        const file = path.join(installDir, '.mcp.json');
+        const stat = fs.lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            return undefined;
+        const doc = JSON.parse(fs.readFileSync(file, 'utf8'));
+        const server = doc.mcpServers?.hq;
+        return server && typeof server === 'object' && !Array.isArray(server) ? server : undefined;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        console.warn(`Skipping unavailable hq-anywhere plugin MCP metadata: ${error.message}`);
+        return undefined;
+    }
+}
+function pluginAndCodexMcpEquivalent(plugin, codex) {
+    const pArgs = Array.isArray(plugin.args) ? plugin.args : [];
+    const cArgs = Array.isArray(codex.args) ? codex.args : [];
+    const pluginTarget = plugin.type === 'stdio' && plugin.command === '/bin/sh' && pArgs.length === 3 && pArgs[0] === '${CLAUDE_PLUGIN_ROOT}/scripts/hq-claude-plugin-launch.sh' && pArgs[1] === 'mcp' && pArgs[2] === 'serve';
+    const codexTarget = codex.type === 'stdio' && typeof codex.command === 'string' && /(^|\/)hq$/.test(codex.command) && cArgs.length === 2 && cArgs[0] === 'mcp' && cArgs[1] === 'serve';
+    return pluginTarget && codexTarget && JSON.stringify(headerKeysOf(plugin)) === JSON.stringify(headerKeysOf(codex)) && JSON.stringify(envKeysOf(plugin)) === JSON.stringify(envKeysOf(codex));
+}
 /** Scan the Claude runtime: read `~/.claude.json`, collect HQ-owned servers. */
 function scanClaude(env) {
     const configPath = claudeConfigPath(env);
@@ -201,6 +245,17 @@ export function computeMcpStatus(env) {
     const checkHealth = anywhereRuntimeEnabled();
     const claudeScan = scanClaude(env);
     const codexScan = scanCodex(env);
+    // Claude plugins keep their MCP manifest beside the installed plugin rather
+    // than in ~/.claude.json. Pair the HQ plugin with the HQ pack's Codex entry
+    // so equivalent launchers do not show as absent or drifted.
+    const pluginMcp = checkHealth ? findAnywherePluginMcp(env.home) : undefined;
+    if (pluginMcp) {
+        for (const [name, found] of codexScan.hqServers) {
+            if (found.pack === 'hq-anywhere' || found.pack.endsWith('/hq-anywhere')) {
+                claudeScan.hqServers.set(name, { def: pluginMcp, pack: found.pack });
+            }
+        }
+    }
     // Union of every HQ-owned server name across both runtimes.
     const names = new Set([...claudeScan.hqServers.keys(), ...codexScan.hqServers.keys()]);
     const servers = [];
@@ -232,7 +287,9 @@ export function computeMcpStatus(env) {
         // DRIFT = present in both but transport-relevant content differs (no header VALUES).
         let drifted = false;
         if (onClaude && onCodex && claudeFound && codexFound) {
-            drifted = summariesDiffer(summarizeDef(claudeFound.def), summarizeDef(codexFound.def));
+            drifted = pluginMcp && claudeFound.def === pluginMcp && pluginAndCodexMcpEquivalent(pluginMcp, codexFound.def)
+                ? false
+                : summariesDiffer(summarizeDef(claudeFound.def), summarizeDef(codexFound.def));
         }
         servers.push({
             server: name,

package/dist/commands/pack-install.d.ts

@@ -278,7 +278,9 @@ export declare function verifyArtifact(input: VerifyArtifactInput): void;
  * @param item       the bare server name declared under `contributes.mcp`
  */
 export declare function validateMcpManifest(payloadDir: string, item: string): void;
-export declare function validateManifest(payloadDir: string, hqVersion: string | null): PackManifest;
+export declare function validateManifest(payloadDir: string, hqVersion: string | null, options?: {
+    allowReservedName?: boolean;
+}): PackManifest;
 /**
  * Enforce a pack's `requires.packs`: every named dependency MUST already be
  * installed (and satisfy its optional semver RANGE) before we write anything.