@indigoai-us/hq-cli 5.329.0 → 5.330.0

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## [5.330.0] — 2026-10-02
+- `hq lanes message` and `hq lanes resume` can refresh model, effort, and account settings from the current worker profile when a done lane starts a new story, behind the default-off `lanes.reuse-refreshes-profile` flag. Reused settings are recorded in lane history; provider-changing reuse is refused without changing the lane.
+
+- The default-off `sync.warn-invalid-ontology-entities` hq-flag warns before push with each invalid local entity path and its frontmatter field names. Sync continues and leaves the files unchanged; omitted `aliases` is accepted because hq-pro supplies an empty-list default, while a malformed aliases value is still reported.
+
 ## [5.329.0] — 2026-10-02
 - `hq lanes keep-alive-audit` no longer reports a keep-alive lead as not restarted when the matching launch has rolled out of capped resume histories; if only queue-time evidence remains, it reports a confirmed untimed restart instead of assigning an on-time or late launch time.
 

package/dist/commands/cloud.d.ts

@@ -239,6 +239,11 @@ export interface ShareCallResult {
 export interface PushAllDeps {
     vaultClient: PullAllVaultClient;
     share: (options: ShareCallOptions) => Promise<ShareCallResult>;
+    beforeShare?: (input: {
+        slug: string;
+        companyUid: string;
+        companyRoot: string;
+    }) => Promise<void>;
     /** DEV-1768: resolve membership push scope (same as pull). */
     resolveScope?: (companyUid: string, slug: string) => Promise<PullScope>;
 }

package/dist/commands/cloud.js

@@ -17,10 +17,11 @@ import chalk from "chalk";
 import * as fs from "fs";
 import * as path from "path";
 import { share, sync, getStateDir, listJournals, VaultClient, computePersonalVaultPaths, PERSONAL_VAULT_JOURNAL_SLUG, resolvePullScope, syncDoctor, } from "@indigoai-us/hq-cloud";
-import { DEFAULT_HQ_ROOT, ensureCognitoToken, buildVaultConfig, } from "../utils/cognito-session.js";
+import { DEFAULT_HQ_ROOT, ensureCognitoToken, buildVaultConfig, loadCachedTokens, } from "../utils/cognito-session.js";
 import { resolveUploadAuthor } from "../utils/upload-author.js";
 import { companyFolderExceedsThreshold, emitNarrowHint, isStrictRefusal, resolveBannerLevel, resolveNarrowHintPresentationLevel, resolveNarrowHintMinBytes, } from "../lib/narrow-hint-banner.js";
 import { beginSyncHealthReport, } from "../utils/client-health.js";
+import { companySlugFromSyncPaths, warnAboutInvalidOntologyEntities, } from "../lib/sync-invalid-entity-warning.js";
 import { isWorkBearingSyncResult, recordFirstWorkBearingSync, } from "../lib/first-sync-next-step.js";
 import { maybeShowCliInviteNudge } from "../lib/cli-invite-nudge.js";
 import { createPlanLimitRefusalTracker, describeRefusedCount, describeRefusedFiles, mergePlanLimitRefusals, renderPlanLimitRefusalLines, trackingProgressRecorder, } from "../lib/billing/plan-limit-refusals.js";
@@ -504,6 +505,22 @@ export async function pushAll(options, deps) {
             }
         }
         try {
+            if (entry.slug !== "personal") {
+                try {
+                    await deps.beforeShare?.({
+                        slug: entry.slug,
+                        companyUid: entry.companyUid,
+                        companyRoot: path.join(options.hqRoot, "companies", entry.slug),
+                    });
+                }
+                catch (error) {
+                    const name = error instanceof Error ? error.name : "UnknownError";
+                    const errorClass = /^[A-Za-z][A-Za-z0-9]{0,63}$/.test(name)
+                        ? name
+                        : "UnknownError";
+                    process.stderr.write(`HQ Sync entity diagnostic failed (${errorClass}); continuing upload.\n`);
+                }
+            }
             const r = await deps.share(entry.shareOptions);
             result.filesUploaded += r.filesUploaded;
             result.bytesUploaded += r.bytesUploaded;
@@ -926,6 +943,20 @@ export function registerCloudCommands(program) {
             });
             const planLimitTracker = createPlanLimitRefusalTracker(companySlugForBilling(progressCompany));
             syncHealth = beginSyncHealthReport();
+            if (!personalMode) {
+                const companyUid = entityContext?.uid ??
+                    (targetCompany?.startsWith("cmp_") ? targetCompany : "");
+                const companySlug = companySlugFromSyncPaths(options.hqRoot, targetPaths);
+                if (companySlug) {
+                    await warnAboutInvalidOntologyEntities({
+                        hqRoot: options.hqRoot,
+                        companyRoot: path.join(options.hqRoot, "companies", companySlug),
+                        companyUid,
+                        companySlug,
+                        idToken: loadCachedTokens()?.idToken ?? "",
+                    });
+                }
+            }
             const result = await share({
                 paths: targetPaths,
                 company: targetCompany,
@@ -1541,6 +1572,13 @@ async function runPushAll(hqRoot, message, onConflict, skipPersonal) {
         }, {
             vaultClient: adapter,
             resolveScope: (companyUid, slug) => resolvePullScope(realClient, companyUid, slug, hqRoot),
+            beforeShare: async ({ slug, companyUid, companyRoot }) => warnAboutInvalidOntologyEntities({
+                hqRoot,
+                companyRoot,
+                companyUid,
+                companySlug: slug,
+                idToken: loadCachedTokens()?.idToken ?? "",
+            }),
             share: async (opts) => {
                 const progressCompany = opts.personalMode
                     ? null
@@ -1692,6 +1730,18 @@ async function runNowSingle(hqRoot, company, personal, message, onConflict, mode
             const pushScope = await resolveCliPullScope(scopeClient, targetCompany ?? pushSlug, hqRoot, (companyUid) => { nudgeResolvedCompanyUid = companyUid; });
             nowPushPrefixSet = pushScope?.prefixSet;
         }
+        if (!personalMode) {
+            const companySlug = companySlugFromSyncPaths(hqRoot, pushPaths);
+            if (companySlug) {
+                await warnAboutInvalidOntologyEntities({
+                    hqRoot,
+                    companyRoot: path.join(hqRoot, "companies", companySlug),
+                    companyUid: targetCompany?.startsWith("cmp_") ? targetCompany : "",
+                    companySlug,
+                    idToken: loadCachedTokens()?.idToken ?? "",
+                });
+            }
+        }
         const pushProgressCompany = personalMode ? null : (pushSlug ?? null);
         const planLimitTracker = createPlanLimitRefusalTracker(companySlugForBilling(pushProgressCompany));
         const pushResult = await share({

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/lib/lanes/flag-keys.d.ts

@@ -1,5 +1,7 @@
 /** hq-flags keys used by lane command behavior. */
 export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+/** Refresh provider/model/effort from a worker profile when a done lane takes a new story. */
+export declare const LANE_REUSE_REFRESHES_PROFILE_FLAG = "lanes.reuse-refreshes-profile";
 /** Enables one automatic continuation after a missing-envelope repair. */
 export declare const LANE_ENVELOPE_REPAIR_CONTINUE_FLAG = "lanes.envelope-repair-continue";
 /** Count only children with live work against their senior's hire grant. */

package/dist/lib/lanes/flag-keys.js

@@ -1,5 +1,7 @@
 /** hq-flags keys used by lane command behavior. */
 export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+/** Refresh provider/model/effort from a worker profile when a done lane takes a new story. */
+export const LANE_REUSE_REFRESHES_PROFILE_FLAG = "lanes.reuse-refreshes-profile";
 /** Enables one automatic continuation after a missing-envelope repair. */
 export const LANE_ENVELOPE_REPAIR_CONTINUE_FLAG = "lanes.envelope-repair-continue";
 /** Count only children with live work against their senior's hire grant. */

package/dist/lib/lanes/spawn.js

@@ -1733,8 +1733,8 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         });
     }
     const profileDefaultsApply = profile !== undefined && profile.meta.provider === existing.provider;
-    const profileModel = profileDefaultsApply ? profile.meta.model : undefined;
-    const profileEffort = profileDefaultsApply ? profile.meta.effort : undefined;
+    const profileModel = profileDefaultsApply && existing.profile_settings_pinned !== true ? profile.meta.model : undefined;
+    const profileEffort = profileDefaultsApply && existing.profile_settings_pinned !== true ? profile.meta.effort : undefined;
     const ignoredProfileFields = profile
         ? ignoredWorkerProfileFields(existing.provider)
         : [];
@@ -1765,7 +1765,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         : undefined;
     // `hq lanes set` on a running lane leaves the change pending until this spawn.
     const pendingSettings = existing.pending_settings;
-    let pinnedModel = pendingSettings?.model ?? (existing.model_source === undefined || existing.model_source === "cli" || existing.model_source === "preserved"
+    let pinnedModel = pendingSettings?.model ?? (existing.profile_settings_pinned === true || existing.model_source === undefined || existing.model_source === "cli" || existing.model_source === "preserved"
         ? existing.model
         : undefined);
     const accountDeps = {
@@ -1929,7 +1929,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         : undefined;
     const effort = launch.effort ?? pendingResumeEffort ?? resolveLaneEffort({
         cliEffort: pendingSettings?.effort ?? (existing.effort_source === "cli" ? existing.effort : undefined),
-        profileEffort,
+        profileEffort: existing.profile_settings_pinned === true ? existing.effort : profileEffort,
         accountEffort: accountCfg?.effort,
         providerEffort: config.providers[lane.provider].effort,
         model,
@@ -2138,7 +2138,11 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                             ? "cli"
                             : preservedAccountModel !== undefined || existing.model_source === "preserved"
                                 ? "preserved"
-                                : "cli"
+                                : existing.model_source === "cli"
+                                    ? "cli"
+                                    : existing.profile_settings_pinned === true
+                                        ? "profile"
+                                        : "cli"
                         : profileModel !== undefined
                             ? "profile"
                             : accountCfg?.model !== undefined
@@ -2483,8 +2487,8 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
         })
         : undefined;
     const profileDefaultsApply = profile !== undefined && profile.meta.provider === lane.provider;
-    const profileModel = profileDefaultsApply ? profile.meta.model : undefined;
-    const profileEffort = profileDefaultsApply ? profile.meta.effort : undefined;
+    const profileModel = profileDefaultsApply && lane.profile_settings_pinned !== true ? profile.meta.model : undefined;
+    const profileEffort = profileDefaultsApply && lane.profile_settings_pinned !== true ? profile.meta.effort : undefined;
     const ignoredProfileFields = profile
         ? ignoredWorkerProfileFields(lane.provider)
         : [];
@@ -2506,7 +2510,7 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
             ignoredFields: ignoredProfileFields,
         }
         : undefined;
-    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
+    const pinnedModel = lane.profile_settings_pinned === true || lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
         ? lane.model
         : undefined;
     const resolved = resolveAccount(lane.provider, lane.account, config, {
@@ -2534,7 +2538,7 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
     });
     const effort = resolveLaneEffort({
         cliEffort: lane.effort_source === "cli" ? lane.effort : undefined,
-        profileEffort,
+        profileEffort: lane.profile_settings_pinned === true ? lane.effort : profileEffort,
         accountEffort: accountCfg?.effort,
         providerEffort: config.providers[lane.provider].effort,
         model,
@@ -2618,7 +2622,7 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
                 if (model !== undefined) {
                     next.model = model;
                     next.model_source = pinnedModel !== undefined
-                        ? lane.model_source === "preserved" ? "preserved" : "cli"
+                        ? lane.model_source === "preserved" ? "preserved" : lane.model_source === "profile" || lane.profile_settings_pinned === true ? "profile" : "cli"
                         : profileModel !== undefined
                             ? "profile"
                             : accountCfg?.model !== undefined

package/dist/lib/lanes/store.js

@@ -652,6 +652,27 @@ export function parseLaneRecord(raw, filePath) {
     if (!isLaneProvider(raw.provider)) {
         throw new LaneSchemaError(`Unknown provider ${JSON.stringify(raw.provider)}`, { path: filePath, value: raw.provider });
     }
+    if (raw.provider_source !== undefined && !["cli", "profile", "default"].includes(String(raw.provider_source))) {
+        throw new LaneSchemaError("provider_source must be cli, profile, or default", {
+            path: filePath,
+            field: "provider_source",
+            value: raw.provider_source,
+        });
+    }
+    if (raw.account_source !== undefined && !["cli", "profile", "balanced"].includes(String(raw.account_source))) {
+        throw new LaneSchemaError("account_source must be cli, profile, or balanced", {
+            path: filePath,
+            field: "account_source",
+            value: raw.account_source,
+        });
+    }
+    if (raw.profile_settings_pinned !== undefined && typeof raw.profile_settings_pinned !== "boolean") {
+        throw new LaneSchemaError("profile_settings_pinned must be a boolean", {
+            path: filePath,
+            field: "profile_settings_pinned",
+            value: raw.profile_settings_pinned,
+        });
+    }
     if (raw.worker_policy_delivery !== undefined &&
         raw.worker_policy_delivery !== "hook" &&
         raw.worker_policy_delivery !== "prompt") {
@@ -867,8 +888,8 @@ export function parseLaneRecord(raw, filePath) {
         for (const [index, entry] of raw.settings_history.entries()) {
             const field = `settings_history[${index}]`;
             if (!isPlainObject(entry) ||
-                Object.keys(entry).some((key) => !["at", "actor", "model", "effort", "reason"].includes(key)) ||
-                (entry.model === undefined && entry.effort === undefined)) {
+                Object.keys(entry).some((key) => !["at", "actor", "provider", "model", "effort", "reason"].includes(key)) ||
+                (entry.provider === undefined && entry.model === undefined && entry.effort === undefined)) {
                 throw new LaneSchemaError(`${field} must be a settings history entry`, { path: filePath, field });
             }
             requireTimestamp(entry.at, `${field}.at`, filePath);
@@ -878,6 +899,12 @@ export function parseLaneRecord(raw, filePath) {
             if (entry.reason !== undefined && (typeof entry.reason !== "string" || entry.reason.trim() === "")) {
                 throw new LaneSchemaError(`${field}.reason must be a non-empty string when present`, { path: filePath, field });
             }
+            if (entry.provider !== undefined && (!isPlainObject(entry.provider) ||
+                Object.keys(entry.provider).some((key) => key !== "from" && key !== "to") ||
+                !isLaneProvider(entry.provider.from) ||
+                !isLaneProvider(entry.provider.to))) {
+                throw new LaneSchemaError(`${field}.provider must be a {from, to} change`, { path: filePath, field });
+            }
             for (const key of ["model", "effort"]) {
                 const change = entry[key];
                 if (change === undefined)

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

@@ -312,6 +312,10 @@ export interface LaneStopHistoryEntry {
 export interface LaneSettingsHistoryEntry {
     at: string;
     actor: string;
+    provider?: {
+        from: LaneProvider;
+        to: LaneProvider;
+    };
     model?: {
         from: string | null;
         to: string;
@@ -578,7 +582,13 @@ export interface LaneRecord {
     /** How policy files were delivered on the most recent profile spawn. */
     worker_policy_delivery?: "hook" | "prompt";
     provider: LaneProvider;
+    /** Whether provider came from an explicit create override or the worker profile/default. */
+    provider_source?: "cli" | "profile" | "default";
     account?: string;
+    /** Explicit create account choices remain pinned during profile refreshes. */
+    account_source?: "cli" | "profile" | "balanced";
+    /** Reuse snapshots the worker profile's resolved settings for the new story. */
+    profile_settings_pinned?: boolean;
     /** Recent Claude account-selection evidence for a create or automatic resume move. */
     account_selection?: LaneAccountSelection;
     /** Eligible accounts for a queue entry created without an explicit account. */

package/dist/lib/lanes/types.js

@@ -231,7 +231,7 @@ export const LANE_FIELD_WRITERS = {
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
     priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], registry_worker: ["creator", "command", "spawn"], registry_worker_approval_history: ["command", "watcher", "reconcile"], worker_profile_repin_history: ["command"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
     keep_alive: ["creator", "command"], keep_alive_standing: ["command"], keep_alive_opted_in_at: ["creator", "command"], keep_alive_blocked_reason: ["command", "reconcile"], keep_alive_resume_count: ["command", "reconcile"], keep_alive_history: ["reconcile"], keep_alive_blocked_resume_streak: ["reconcile", "spawn", "watcher"], keep_alive_last_resume_at: ["command", "reconcile"], keep_alive_next_eligible_at: ["command", "reconcile"], keep_alive_exhausted_at: ["command", "reconcile"],
-    provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], failed_resume_history: ["command"], fallback_question_cancellation_failures: ["command"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
+    provider: ["creator", "command"], provider_source: ["creator", "command"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_source: ["creator", "command"], profile_settings_pinned: ["command"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], failed_resume_history: ["command"], fallback_question_cancellation_failures: ["command"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], ended_at: ["reconcile"], envelope_summary: ["reconcile"], attribution_history: ["command", "watcher", "reconcile"], story_switch_pending: ["command", "watcher", "reconcile"], story_switch_unacknowledged: ["watcher", "reconcile"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn", "command"], effort_source: ["creator", "spawn", "command"], fast_mode: ["spawn"],
     last_message_at: ["command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher", "reconcile"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],

package/dist/lib/sync-invalid-entity-warning.d.ts

@@ -0,0 +1,32 @@
+import type { FlagClient, FlagClientOptions } from "@indigoai-us/hq-flags-client";
+export declare const SYNC_INVALID_ENTITY_WARNING_FLAG = "sync.warn-invalid-ontology-entities";
+export declare const SYNC_INVALID_ENTITY_WARNING_FALLBACK = false;
+export declare const SYNC_INVALID_ENTITY_WARNING_TIMEOUT_MS = 1500;
+type FlagClientLike = Pick<FlagClient, "ready" | "isEnabled" | "close">;
+export interface InvalidEntityFrontmatter {
+    path: string;
+    fields: string[];
+}
+export interface SyncInvalidEntityWarningDependencies {
+    env?: NodeJS.ProcessEnv;
+    createClient?: (options: FlagClientOptions) => FlagClientLike;
+    idToken?: string;
+    writeLine?: (line: string) => void;
+}
+/** Check only the entity directory that this sync push will upload. */
+export declare function findInvalidOntologyEntities(args: {
+    companyRoot: string;
+    hqRoot: string;
+}): InvalidEntityFrontmatter[];
+export declare function companySlugFromSyncPaths(hqRoot: string, syncPaths: string[]): string | undefined;
+/** Warns by path and field names only. Any diagnostic failure leaves sync running. */
+export declare function warnAboutInvalidOntologyEntities(args: {
+    hqRoot: string;
+    companyRoot: string;
+    companyUid: string;
+    companySlug: string;
+    idToken?: string;
+    dependencies?: Omit<SyncInvalidEntityWarningDependencies, "idToken">;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=sync-invalid-entity-warning.d.ts.map

package/dist/lib/sync-invalid-entity-warning.js

@@ -0,0 +1,205 @@
+import { createFlagClient, readLocalOverride } from "@indigoai-us/hq-flags-client";
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as yaml from "js-yaml";
+import { resolveFlagRegistryEndpoint } from "./flag-registry-endpoint.js";
+export const SYNC_INVALID_ENTITY_WARNING_FLAG = "sync.warn-invalid-ontology-entities";
+export const SYNC_INVALID_ENTITY_WARNING_FALLBACK = false;
+export const SYNC_INVALID_ENTITY_WARNING_TIMEOUT_MS = 1500;
+const ENTITY_TYPES = new Set([
+    "person", "project", "company", "concept", "product", "tool",
+    "tool/technology", "model", "platform", "contact", "deal", "contract",
+    "invoice", "account", "journal-entry", "ar-invoice", "ap-bill",
+]);
+const REQUIRED_FIELDS = [
+    "id", "type", "canonical_name", "confidence", "status",
+    "domain", "first_seen", "last_updated", "signal_count",
+];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validRequiredFields(frontmatter) {
+    const invalid = new Set();
+    for (const field of REQUIRED_FIELDS) {
+        if (!(field in frontmatter))
+            invalid.add(field);
+    }
+    if (typeof frontmatter.id !== "string" || frontmatter.id.length === 0) {
+        invalid.add("id");
+    }
+    if (typeof frontmatter.type !== "string" || !ENTITY_TYPES.has(frontmatter.type)) {
+        invalid.add("type");
+    }
+    if (typeof frontmatter.canonical_name !== "string" ||
+        frontmatter.canonical_name.length === 0) {
+        invalid.add("canonical_name");
+    }
+    if ("aliases" in frontmatter &&
+        (!Array.isArray(frontmatter.aliases) ||
+            !frontmatter.aliases.every((value) => typeof value === "string"))) {
+        invalid.add("aliases");
+    }
+    if (typeof frontmatter.confidence !== "number" ||
+        !Number.isFinite(frontmatter.confidence) ||
+        frontmatter.confidence < 0 ||
+        frontmatter.confidence > 1) {
+        invalid.add("confidence");
+    }
+    if (frontmatter.status !== "draft" && frontmatter.status !== "confirmed") {
+        invalid.add("status");
+    }
+    if (!Array.isArray(frontmatter.domain) ||
+        !frontmatter.domain.every((value) => typeof value === "string")) {
+        invalid.add("domain");
+    }
+    if (typeof frontmatter.first_seen !== "string" || frontmatter.first_seen.length === 0) {
+        invalid.add("first_seen");
+    }
+    if (typeof frontmatter.last_updated !== "string" ||
+        frontmatter.last_updated.length === 0) {
+        invalid.add("last_updated");
+    }
+    if (typeof frontmatter.signal_count !== "number" ||
+        !Number.isInteger(frontmatter.signal_count) ||
+        frontmatter.signal_count < 0) {
+        invalid.add("signal_count");
+    }
+    if (invalid.size === 0 &&
+        frontmatter.identity_version !== 2 &&
+        frontmatter.id !== createHash("sha256")
+            .update(`${frontmatter.type}:${frontmatter.canonical_name}`)
+            .digest("hex")) {
+        invalid.add("id");
+    }
+    return [...invalid].sort();
+}
+function parseInvalidEntityFile(filePath, displayPath) {
+    try {
+        const content = fs.readFileSync(filePath, "utf8");
+        const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+        if (!match)
+            return { path: displayPath, fields: ["_frontmatter"] };
+        // Match the ontology reader's YAML parser semantics: ISO date scalars stay
+        // strings so Zod's `z.string()` fields are checked as the server checks them.
+        const parsed = yaml.load(match[1], { schema: yaml.CORE_SCHEMA });
+        if (!isRecord(parsed))
+            return { path: displayPath, fields: ["_root"] };
+        const fields = validRequiredFields(parsed);
+        return fields.length ? { path: displayPath, fields } : null;
+    }
+    catch {
+        // YAML parser errors can embed user content; report the location only.
+        return { path: displayPath, fields: ["_frontmatter"] };
+    }
+}
+/** Check only the entity directory that this sync push will upload. */
+export function findInvalidOntologyEntities(args) {
+    const entityRoot = path.join(args.companyRoot, "ontology", "entities");
+    if (!fs.existsSync(entityRoot))
+        return [];
+    const found = [];
+    const typeEntries = fs.readdirSync(entityRoot, { withFileTypes: true });
+    for (const typeEntry of typeEntries) {
+        if (!typeEntry.isDirectory())
+            continue;
+        const typeRoot = path.join(entityRoot, typeEntry.name);
+        for (const entityEntry of fs.readdirSync(typeRoot, { withFileTypes: true })) {
+            if (!entityEntry.isFile() || !entityEntry.name.endsWith(".md"))
+                continue;
+            const filePath = path.join(typeRoot, entityEntry.name);
+            const relativePath = path.relative(args.hqRoot, filePath).split(path.sep).join("/");
+            const invalid = parseInvalidEntityFile(filePath, relativePath);
+            if (invalid)
+                found.push(invalid);
+        }
+    }
+    return found.sort((a, b) => a.path.localeCompare(b.path));
+}
+export function companySlugFromSyncPaths(hqRoot, syncPaths) {
+    const companiesRoot = path.resolve(hqRoot, "companies");
+    for (const syncPath of syncPaths) {
+        const relative = path.relative(companiesRoot, path.resolve(syncPath));
+        if (!relative || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+            continue;
+        const slug = relative.split(path.sep)[0];
+        if (slug && slug !== ".")
+            return slug;
+    }
+    return undefined;
+}
+function safeErrorClass(error) {
+    const name = error instanceof Error ? error.name : "UnknownError";
+    return /^[A-Za-z][A-Za-z0-9]{0,63}$/.test(name) ? name : "UnknownError";
+}
+async function warningEnabled(args) {
+    const env = args.dependencies.env ?? process.env;
+    const override = readLocalOverride(SYNC_INVALID_ENTITY_WARNING_FLAG, env);
+    if (override !== null)
+        return override;
+    const companyUid = args.companyUid || env.HQ_COMPANY_UID?.trim() || "";
+    const companySlug = args.companySlug || env.HQ_COMPANY_SLUG?.trim() || "";
+    if (!/^cmp_[A-Za-z0-9]{3,128}$/.test(companyUid)) {
+        return SYNC_INVALID_ENTITY_WARNING_FALLBACK;
+    }
+    const token = args.dependencies.idToken ?? "";
+    if (!token)
+        return SYNC_INVALID_ENTITY_WARNING_FALLBACK;
+    let client;
+    let failed = false;
+    try {
+        client = (args.dependencies.createClient ?? createFlagClient)({
+            endpoint: resolveFlagRegistryEndpoint(undefined, env),
+            companyUid,
+            ...(/^[A-Za-z0-9][A-Za-z0-9-]{0,63}$/.test(companySlug)
+                ? { companyIdentifiers: [companySlug] }
+                : {}),
+            env: {},
+            getToken: () => token,
+            refreshIntervalMs: 0,
+            requestTimeoutMs: SYNC_INVALID_ENTITY_WARNING_TIMEOUT_MS,
+            onError: (error) => {
+                failed = true;
+                (args.dependencies.writeLine ?? ((line) => process.stderr.write(line)))(`HQ Sync entity-warning flag lookup failed (${safeErrorClass(error)}); defaulting off.\n`);
+            },
+        });
+        await client.ready();
+        return !failed && client.isEnabled(SYNC_INVALID_ENTITY_WARNING_FLAG, {
+            fallback: SYNC_INVALID_ENTITY_WARNING_FALLBACK,
+        });
+    }
+    catch (error) {
+        (args.dependencies.writeLine ?? ((line) => process.stderr.write(line)))(`HQ Sync entity-warning flag lookup failed (${safeErrorClass(error)}); defaulting off.\n`);
+        return SYNC_INVALID_ENTITY_WARNING_FALLBACK;
+    }
+    finally {
+        client?.close();
+    }
+}
+/** Warns by path and field names only. Any diagnostic failure leaves sync running. */
+export async function warnAboutInvalidOntologyEntities(args) {
+    try {
+        const enabled = await warningEnabled({
+            companyUid: args.companyUid,
+            companySlug: args.companySlug,
+            dependencies: { ...args.dependencies, idToken: args.idToken },
+        });
+        if (!enabled)
+            return;
+        const invalid = findInvalidOntologyEntities(args);
+        const writeLine = args.dependencies?.writeLine ?? ((line) => process.stderr.write(line));
+        for (const item of invalid) {
+            writeLine(`HQ Sync warning: ${item.path} has frontmatter rejected by ontology matching: ${item.fields.join(", ")}. Sync will continue and leave the file unchanged. Fix the entity if you want it included in ontology results.\n`);
+        }
+    }
+    catch (error) {
+        const writeLine = args.dependencies?.writeLine ?? ((line) => process.stderr.write(line));
+        try {
+            writeLine(`HQ Sync entity diagnostic failed (${safeErrorClass(error)}); sync will continue.\n`);
+        }
+        catch {
+            // A closed stderr must not prevent the upload from preserving user data.
+        }
+    }
+}
+//# sourceMappingURL=sync-invalid-entity-warning.js.map

package/package.json

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