@indigoai-us/hq-cli 5.188.1 → 5.189.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [5.189.0] — 2026-09-25
+
+### Added
+
+- `hq lanes resume` and `hq lanes message` accept `--effort <level>` for the next resumed provider turn. Attaching a worker profile applies its configured effort when the command has no effort flag. With neither option, the lane keeps its recorded effort. Outpost commands forward the flag and report `outpost_effort_unsupported` when the remote CLI rejects it.
+
 ## [5.188.1] — 2026-09-25
 
 ### Fixed

package/dist/command-catalog.generated.d.ts

@@ -7345,6 +7345,9 @@ export declare const COMMAND_CATALOG: readonly [{
         }, {
             readonly flags: "--model <id>";
             readonly description: "Model for the moved lane (with --account only)";
+        }, {
+            readonly flags: "--effort <level>";
+            readonly description: "Reasoning effort for the resumed provider turn";
         }, {
             readonly flags: "--worker <profile>";
             readonly description: "Attach a personal worker profile when this message resumes the lane";
@@ -7382,6 +7385,9 @@ export declare const COMMAND_CATALOG: readonly [{
         }, {
             readonly flags: "--model <id>";
             readonly description: "Model for the moved lane (with --account only)";
+        }, {
+            readonly flags: "--effort <level>";
+            readonly description: "Reasoning effort for the resumed provider turn";
         }, {
             readonly flags: "--worker <profile>";
             readonly description: "Attach a personal worker profile for the resumed turn";

package/dist/command-catalog.generated.js

@@ -9496,6 +9496,10 @@ export const COMMAND_CATALOG = [
                         "flags": "--model <id>",
                         "description": "Model for the moved lane (with --account only)"
                     },
+                    {
+                        "flags": "--effort <level>",
+                        "description": "Reasoning effort for the resumed provider turn"
+                    },
                     {
                         "flags": "--worker <profile>",
                         "description": "Attach a personal worker profile when this message resumes the lane"
@@ -9545,6 +9549,10 @@ export const COMMAND_CATALOG = [
                         "flags": "--model <id>",
                         "description": "Model for the moved lane (with --account only)"
                     },
+                    {
+                        "flags": "--effort <level>",
+                        "description": "Reasoning effort for the resumed provider turn"
+                    },
                     {
                         "flags": "--worker <profile>",
                         "description": "Attach a personal worker profile for the resumed turn"

package/dist/commands/lanes.js

@@ -20,7 +20,7 @@ import { createOutpostHireGrantContext, parseOutpostHireGrantContext, sameHireGr
 import { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity, resolveAdmissionHost, } from "../lib/lanes/admission-host.js";
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
 export { LANE_HIRE_GRANTS_FLAG };
-import { buildOutpostCapacityCommand, buildOutpostBalanceMoveCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostMoveTargetCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
+import { buildOutpostCapacityCommand, buildOutpostBalanceMoveCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostMoveTargetCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, outpostRejectedEffortOption, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
 import { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "../lib/lanes/host-capacity.js";
 import { BALANCE_MOVABLE_STATES, CLAUDE_ACCOUNT_BALANCE_FLAG, accountLoadsForReport, assertBalanceApplyEnabled, planClaudeBalanceMoves, selectClaudeAccount, } from "../lib/lanes/claude-account-balance.js";
 import { parseUserYaml } from "../utils/user-yaml-error.js";
@@ -34,7 +34,7 @@ import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { providerCompactAfterMs } from "../lib/lanes/config.js";
-import { parseCliEffort, resolveLaneEffort } from "../lib/lanes/effort.js";
+import { parseCliEffort, resolveLaneEffort, } from "../lib/lanes/effort.js";
 import { LanesError } from "../lib/lanes/errors.js";
 import { accountQuotaView, loadQuotaState, quotaBlockFor } from "../lib/lanes/quota.js";
 import { SESSION_MOVE_REASON } from "../lib/lanes/move-account.js";
@@ -3100,6 +3100,8 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
                 story: options.story,
                 account: options.account,
                 model: options.model,
+                effort: options.effort,
+                worker: options.worker,
                 hire: options.hire,
                 grantContext,
                 compact: options.compact,
@@ -3110,6 +3112,18 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
         throw new LanesError("outpost_dispatch_failed", `Could not dispatch ${action} for lane ${lane.lane_id} to Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { lane_id: lane.lane_id, outpost_id: outpostId });
     }
     const ownerError = ownerErrorFromOutput(dispatched.stdout);
+    if (options.effort !== undefined && outpostRejectedEffortOption(dispatched)) {
+        throw new LanesError("outpost_effort_unsupported", `Outpost ${outpostId} rejected --effort; update hq-cli on that Outpost before changing a lane's effort remotely`, {
+            lane_id: lane.lane_id,
+            outpost_id: outpostId,
+            command_id: dispatched.commandId,
+            effort: options.effort,
+            status: dispatched.status,
+            done: dispatched.done ?? false,
+            exit_code: dispatched.exitCode,
+            owner_error: ownerError,
+        });
+    }
     if (ownerError) {
         throw new LanesError("outpost_dispatch_failed", `Outpost ${outpostId} rejected the ${action} command: ${ownerError.message}`, {
             lane_id: lane.lane_id,
@@ -4336,34 +4350,43 @@ function validateResumeProfileModel(ctx, lane, profile) {
         env: ctx.env,
     });
 }
+function applyResumeProfileAndEffort(current, next, input) {
+    if (input.profile !== undefined) {
+        const profile = input.profile.profile;
+        next.worker = input.profile.id;
+        next.worker_path = input.profile.path;
+        next.worker_pack = input.profile.pack;
+        next.worker_profile = profile.id;
+        next.worker_profile_hash = profile.contentHash;
+        next.worker_profile_ignored = ignoredWorkerProfileFields(current.provider);
+        next.worker_policy_delivery = undefined;
+        if (next.model_source !== "cli") {
+            if (profile.meta.provider === current.provider && profile.meta.model !== undefined) {
+                next.model = profile.meta.model;
+                next.model_source = "profile";
+            }
+            else if (profile.meta.provider === current.provider) {
+                next.model = undefined;
+                next.model_source = "none";
+            }
+        }
+    }
+    if (input.effort !== undefined) {
+        next.effort = input.effort.effort;
+        next.effort_source = input.effort.source;
+    }
+}
 function recordResumeSetup(ctx, lane, input) {
-    if (input.profile === undefined && input.meshCompany === undefined)
+    if (input.profile === undefined &&
+        input.effort === undefined &&
+        input.meshCompany === undefined)
         return lane;
     return casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => {
         if (current.version !== lane.version) {
             throw new LanesError("lane_resume_setup_conflict", `Lane ${lane.lane_id} changed while resume settings were prepared; run the resume again`, { lane_id: lane.lane_id, prepared_version: lane.version, version: current.version });
         }
         const next = { ...current };
-        if (input.profile !== undefined) {
-            const profile = input.profile.profile;
-            next.worker = input.profile.id;
-            next.worker_path = input.profile.path;
-            next.worker_pack = input.profile.pack;
-            next.worker_profile = profile.id;
-            next.worker_profile_hash = profile.contentHash;
-            next.worker_profile_ignored = ignoredWorkerProfileFields(current.provider);
-            next.worker_policy_delivery = undefined;
-            if (current.model_source !== "cli") {
-                if (profile.meta.provider === current.provider && profile.meta.model !== undefined) {
-                    next.model = profile.meta.model;
-                    next.model_source = "profile";
-                }
-                else if (profile.meta.provider === current.provider) {
-                    next.model = undefined;
-                    next.model_source = "none";
-                }
-            }
-        }
+        applyResumeProfileAndEffort(current, next, input);
         if (input.meshCompany !== undefined) {
             if (current.company === null)
                 next.mesh_company = input.meshCompany;
@@ -4373,6 +4396,40 @@ function recordResumeSetup(ctx, lane, input) {
         return next;
     });
 }
+/** Resolve an explicit resume override or newly attached profile like create does. */
+function resolveResumeEffort(ctx, lane, input) {
+    if (input.cliEffort === undefined && input.profile === undefined)
+        return undefined;
+    const config = loadLanesConfig(ctx.hqRoot());
+    const providerConfig = config.providers[lane.provider];
+    const accountId = input.account?.trim() || lane.account;
+    const accountConfig = accountId === undefined
+        ? undefined
+        : providerConfig.accounts[accountId];
+    const profileDefaultsApply = input.profile?.profile.meta.provider === lane.provider;
+    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli"
+        ? lane.model
+        : undefined;
+    const model = resolveLaneModel({
+        cliModel: input.model?.trim() || pinnedModel,
+        profileModel: profileDefaultsApply ? input.profile?.profile.meta.model : undefined,
+        accountModel: accountConfig?.model,
+        providerModel: providerConfig.model,
+    });
+    return resolveLaneEffort({
+        cliEffort: input.cliEffort,
+        profileEffort: profileDefaultsApply ? input.profile?.profile.meta.effort : undefined,
+        accountEffort: accountConfig?.effort,
+        providerEffort: providerConfig.effort,
+        model,
+    });
+}
+function recordedResumeEffort(lane) {
+    return {
+        ...(lane.effort !== undefined ? { effort: lane.effort } : {}),
+        source: lane.effort_source ?? "none",
+    };
+}
 /**
  * US-023: move the lane's provider session to `--account` (same provider)
  * before a resume or a message resume. Every check runs before anything is
@@ -4440,7 +4497,7 @@ async function prepareAccountMove(ctx, lane, input) {
     }).logged_in !== true) {
         throw new LanesError("account_not_logged_in", `Account ${target} for ${lane.provider} is not logged in (no credential file)`, { provider: lane.provider, account: target, lane_id: laneId });
     }
-    const profile = input.workerProfile ?? (lane.worker_profile !== undefined
+    const profile = input.workerProfile?.profile ?? (lane.worker_profile !== undefined
         ? loadWorkerProfile(hqRoot, lane.worker_profile)
         : undefined);
     const profileDefaultsApply = profile !== undefined && profile.meta.provider === lane.provider;
@@ -4542,6 +4599,10 @@ async function prepareAccountMove(ctx, lane, input) {
                     ? undefined
                     : { session_id: sessionId, at, ...input.pending },
             };
+            applyResumeProfileAndEffort(current, next, {
+                ...(input.workerProfile !== undefined ? { profile: input.workerProfile } : {}),
+                ...(input.effort !== undefined ? { effort: input.effort } : {}),
+            });
             if (input.deferTurnStart) {
                 next.state = current.state;
             }
@@ -4618,6 +4679,10 @@ async function runMessage(ctx, laneId, opts) {
         return;
     }
     assertLaneRunsHereForOperatorMutation(ctx, lane, "message");
+    const cliEffort = parseCliEffort(lane.provider, opts.effort);
+    if (cliEffort !== undefined && !providerSupportsSessionResume(lane.provider)) {
+        throw new LanesError("effort_resume_unsupported", `Provider ${lane.provider} cannot change effort on a resumed session`, { lane_id: laneId, provider: lane.provider });
+    }
     // Check before transcript recovery, account probing, or message writes.
     // The final state transition repeats this check under the senior lock.
     await withResumeHireAdmission(ctx, lane, () => undefined);
@@ -4649,12 +4714,24 @@ async function runMessage(ctx, laneId, opts) {
     if (opts.worker !== undefined && mechanism === "dropbox") {
         throw new LanesError("worker_profile_requires_resume", `Lane ${laneId} is still running; --worker can only be applied when message starts a resumed provider turn`, { lane_id: laneId, state: lane.state });
     }
+    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)
         : 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", {});
     }
+    const automaticAccountSelection = opts.account === undefined && mechanism === "resume"
+        ? await selectAutomaticClaudeResumeAccount(ctx, lane)
+        : undefined;
+    const resumeEffort = resolveResumeEffort(ctx, lane, {
+        cliEffort,
+        profile: resumeProfile,
+        account: opts.account ?? automaticAccountSelection?.account,
+        model: opts.model,
+    });
     const messageId = mintMessageId();
     const at = ctx.now().toISOString();
     const projectId = opts.project?.trim() || lane.project_id;
@@ -4675,7 +4752,8 @@ async function runMessage(ctx, laneId, opts) {
         move = await prepareAccountMove(ctx, lane, {
             account: opts.account,
             cliModel: opts.model?.trim() || undefined,
-            ...(resumeProfile !== undefined ? { workerProfile: resumeProfile.profile } : {}),
+            ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
+            ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
             pending: { trigger: "message", text, message_id: messageId, compact: opts.compact !== false },
         });
         lane = move.lane;
@@ -4684,13 +4762,14 @@ async function runMessage(ctx, laneId, opts) {
         }
     }
     else if (mechanism === "resume") {
-        const selection = await selectAutomaticClaudeResumeAccount(ctx, lane);
+        const selection = automaticAccountSelection;
         if (selection !== undefined) {
             if (selection.account !== lane.account) {
                 move = await prepareAccountMove(ctx, lane, {
                     account: selection.account,
                     cliModel: undefined,
-                    ...(resumeProfile !== undefined ? { workerProfile: resumeProfile.profile } : {}),
+                    ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
+                    ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     pending: {
                         trigger: "message",
                         text,
@@ -4708,10 +4787,14 @@ async function runMessage(ctx, laneId, opts) {
             }
         }
     }
-    if (resumeProfile !== undefined) {
-        if (opts.account === undefined)
-            validateResumeProfileModel(ctx, lane, resumeProfile.profile);
-        lane = recordResumeSetup(ctx, lane, { profile: resumeProfile });
+    if (resumeProfile !== undefined && opts.account === undefined) {
+        validateResumeProfileModel(ctx, lane, resumeProfile.profile);
+    }
+    if (move === null && (resumeProfile !== undefined || resumeEffort !== undefined)) {
+        lane = recordResumeSetup(ctx, lane, {
+            ...(resumeProfile !== undefined ? { profile: resumeProfile } : {}),
+            ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+        });
     }
     if (move?.queued) {
         // Parked at the target's cap: reconcile resumes the session there.
@@ -4785,6 +4868,7 @@ async function runMessage(ctx, laneId, opts) {
                 }, {
                     trigger: { kind: "message", text, message_id: messageId },
                     compact: opts.compact !== false,
+                    effort: resumeEffort ?? recordedResumeEffort(lane),
                 });
                 archiveResumeMessage(hqRoot, laneId, dropboxMessage);
                 return started;
@@ -5071,6 +5155,10 @@ async function runResume(ctx, laneId, opts) {
     // slot that its senior has already assigned elsewhere.
     await withResumeHireAdmission(ctx, lane, () => undefined);
     assertLaneRunsHereForOperatorMutation(ctx, lane, "resume");
+    const cliEffort = parseCliEffort(lane.provider, opts.effort);
+    if (cliEffort !== undefined && !providerSupportsSessionResume(lane.provider)) {
+        throw new LanesError("effort_resume_unsupported", `Provider ${lane.provider} cannot change effort on a resumed session`, { lane_id: laneId, provider: lane.provider });
+    }
     lane = laneWithRecoveredProviderSession(hqRoot, lane);
     if (opts.model !== undefined && opts.account === undefined) {
         throw new LanesError("model_requires_account", "--model on hq lanes resume is only accepted together with --account", {});
@@ -5127,12 +5215,19 @@ async function runResume(ctx, laneId, opts) {
     const automaticAccountSelection = opts.account === undefined
         ? await selectAutomaticClaudeResumeAccount(ctx, lane)
         : undefined;
+    const resumeEffort = resolveResumeEffort(ctx, lane, {
+        cliEffort,
+        profile: resumeProfile,
+        account: opts.account ?? automaticAccountSelection?.account,
+        model: opts.model,
+    });
     let move = null;
     if (opts.account !== undefined) {
         move = await prepareAccountMove(ctx, lane, {
             account: opts.account,
             cliModel: opts.model?.trim() || undefined,
-            ...(resumeProfile !== undefined ? { workerProfile: resumeProfile.profile } : {}),
+            ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
+            ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
             pending: {
                 trigger: "resume",
                 resumed_from: resumedFrom,
@@ -5148,7 +5243,8 @@ async function runResume(ctx, laneId, opts) {
             move = await prepareAccountMove(ctx, lane, {
                 account: automaticAccountSelection.account,
                 cliModel: undefined,
-                ...(resumeProfile !== undefined ? { workerProfile: resumeProfile.profile } : {}),
+                ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
+                ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                 pending: {
                     trigger: "resume",
                     resumed_from: resumedFrom,
@@ -5165,7 +5261,8 @@ async function runResume(ctx, laneId, opts) {
         }
     }
     lane = recordResumeSetup(ctx, lane, {
-        ...(resumeProfile !== undefined ? { profile: resumeProfile } : {}),
+        ...(move === null && resumeProfile !== undefined ? { profile: resumeProfile } : {}),
+        ...(move === null && resumeEffort !== undefined ? { effort: resumeEffort } : {}),
         ...(requestedMeshCompany !== undefined
             ? { meshCompany: requestedMeshCompany, threadId: meshThreadId }
             : {}),
@@ -5239,6 +5336,7 @@ async function runResume(ctx, laneId, opts) {
                         ...(messageId !== undefined ? { message_id: messageId } : {}),
                     },
                     compact: opts.compact !== false,
+                    effort: resumeEffort ?? recordedResumeEffort(lane),
                 });
             });
         }, ctx.sleep);
@@ -7049,6 +7147,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--story <id>", "Re-point story attribution from this message")
         .option("--account <id>", "Move the lane's session to this account of its provider before the message resumes it")
         .option("--model <id>", "Model for the moved lane (with --account only)")
+        .option("--effort <level>", "Reasoning effort for the resumed provider turn")
         .option("--worker <profile>", "Attach a personal worker profile when this message resumes the lane")
         .option("--no-compact", "Skip the resume-time compaction check for this message")
         .action(wrap(async (laneId, opts) => {
@@ -7063,6 +7162,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--story <id>", "Re-point story attribution from this resume")
         .option("--account <id>", "Move the lane's session to this account of its provider before resuming")
         .option("--model <id>", "Model for the moved lane (with --account only)")
+        .option("--effort <level>", "Reasoning effort for the resumed provider turn")
         .option("--worker <profile>", "Attach a personal worker profile for the resumed turn")
         .option("--mesh-company <slug>", "Attach Work Mesh attribution after verifying company membership")
         .option("--no-compact", "Skip the resume-time compaction check for this resume")

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

@@ -35,6 +35,8 @@ export interface OutpostLaneCommand {
     story?: string;
     account?: string;
     model?: string;
+    effort?: string;
+    worker?: string;
     hire?: string;
     grantContext?: string;
     compact?: boolean;
@@ -81,6 +83,8 @@ export declare function buildOutpostBalanceMoveCommand(input: {
 export declare function buildOutpostIdentityBackfillCommand(expectedId: string): string;
 /** Build the same `hq outposts exec` remote command used by lane pickup. */
 export declare function buildOutpostLaneCommand(input: OutpostLaneCommand): string;
+/** True when a remote CLI exited after rejecting the forwarded effort flag. */
+export declare function outpostRejectedEffortOption(result: Pick<OutpostDispatchResult, "exitCode" | "stdout" | "stderr">): boolean;
 export declare function stageOutpostPayload(port: Pick<OutpostExecPort, "stageExecInput">, outpostId: string, bytes: Uint8Array, put?: typeof fetch): Promise<{
     getUrl: string;
 }>;

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

@@ -104,6 +104,8 @@ export function buildOutpostLaneCommand(input) {
         ["--story", input.story],
         ["--account", input.account],
         ["--model", input.model],
+        ["--effort", input.effort],
+        ["--worker", input.worker],
         ["--hire", input.hire],
         ["--grant-context", input.grantContext],
     ]) {
@@ -114,6 +116,12 @@ export function buildOutpostLaneCommand(input) {
         args.push("--no-compact");
     return withRemoteHqDir(joinCommandParts(args));
 }
+/** True when a remote CLI exited after rejecting the forwarded effort flag. */
+export function outpostRejectedEffortOption(result) {
+    if (result.exitCode === 0)
+        return false;
+    return /(?:unknown|unrecognized) option[^\n]{0,120}--effort/i.test(`${result.stderr}\n${result.stdout}`);
+}
 export async function stageOutpostPayload(port, outpostId, bytes, put = fetch) {
     const staged = await port.stageExecInput(outpostId);
     const upload = await put(staged.putUrl, {

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

@@ -9,6 +9,7 @@
  */
 import { PROVIDER_HOME_ENV } from "./accounts.js";
 import { type RunCompactionFn } from "./compaction.js";
+import { type ResolvedEffort } from "./effort.js";
 import { type KnownModelsDeps } from "./models.js";
 import { type LaunchTrigger } from "./delivery.js";
 import { type MachineIdentity } from "./machine-identity.js";
@@ -283,6 +284,8 @@ export interface SpawnLaunchOptions {
      * (`hq lanes message --no-compact`). Default true.
      */
     compact?: boolean;
+    /** Effort resolved by an explicit resume/message request, or pinned from its record. */
+    effort?: ResolvedEffort;
 }
 /**
  * Bind the account, spawn the worker and its watcher outside the caller's

package/dist/lib/lanes/spawn.js

@@ -15,7 +15,7 @@ import { PROVIDER_HOME_ENV, accountStatus, isLoggedOut, resolveAccount, selectBa
 import { COMPACTION_PROMPT, compactionAfterUsage, compactionDue, compactLaneSession, } from "./compaction.js";
 import { installDrainHook } from "./hooks-install.js";
 import { loadLanesConfig, providerAutoCompactTokens, providerCompactAfterMs, } from "./config.js";
-import { appendEffortFlag, resolveLaneEffort } from "./effort.js";
+import { appendEffortFlag, resolveLaneEffort, } from "./effort.js";
 import { defaultProbe, validateLaneModel, validateProfileLaneModel, } from "./models.js";
 import { claimableStatesFor, planLaneLaunch, providerSupportsSessionResume, } from "./delivery.js";
 import { AccountResolutionError, LanesError } from "./errors.js";
@@ -1719,7 +1719,13 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         accountModel: accountCfg?.model,
         providerModel: config.providers[lane.provider].model,
     });
-    const effort = resolveLaneEffort({
+    const pendingResumeEffort = pendingResume !== undefined
+        ? {
+            ...(existing.effort !== undefined ? { effort: existing.effort } : {}),
+            source: existing.effort_source ?? "none",
+        }
+        : undefined;
+    const effort = launch.effort ?? pendingResumeEffort ?? resolveLaneEffort({
         cliEffort: existing.effort_source === "cli" ? existing.effort : undefined,
         profileEffort,
         accountEffort: accountCfg?.effort,

package/dist/lib/lanes/types.js

@@ -226,7 +226,7 @@ export const LANE_FIELD_WRITERS = {
     priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
     provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], 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"], attribution_history: ["command"],
-    last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn"], effort_source: ["creator", "spawn"], fast_mode: ["spawn"],
+    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"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["command", "reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], terminal_details: ["command", "spawn", "watcher", "reconcile"],

package/package.json

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