@indigoai-us/hq-cli 5.278.0 → 5.280.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [5.280.0] — 2026-09-29
+
+### Fixed
+
+- Single-lane commands for Outpost-hosted lanes use a configurable pickup wait,
+  defaulting to 120 seconds. `hq lanes list` capacity probes use a separate
+  15-second timeout. A lane ID with a registered host suffix routes to that
+  Outpost first.
+
+## [5.279.0] — 2026-09-29
+
+### Fixed
+
+- Claude keep-alive resumes use the same account selection as manual resumes,
+  including profile pins and the optional recent-use tiebreak. If no eligible
+  account can be selected, the lane resumes on its current account and records
+  the failure.
+
 ## [5.278.0] — 2026-09-29
 
 ### Changed

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

@@ -195,6 +195,7 @@ export interface Ctx {
     resolveCompany: (company?: string) => Promise<LaneCompanyRef>;
     resolveActiveCompany: (company: string) => Promise<LaneCompanyRef | null>;
     listOutpostIds: () => Promise<string[]>;
+    listOutpostRoutes: () => Promise<OutpostRouteIdentity[]>;
     readOutpostIdentity: () => OutpostIdentity;
     spawnLogin: (opts: {
         command: string;
@@ -244,6 +245,10 @@ export interface Ctx {
     mergeHoldEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     mergeReviewEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
 }
+export interface OutpostRouteIdentity {
+    outpostId: string;
+    instanceName?: string;
+}
 export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
 export declare const CLAUDE_ACCOUNT_BALANCE_SIGNALS_FLAG = "lanes.claude-account-balance-signals";
 export declare function defaultLanePlacementEnabled(company: LaneCompanyRef | undefined): Promise<boolean>;

package/dist/commands/lanes.d.ts

@@ -6,7 +6,7 @@
  * `watch` and the monitor reminder are the line-oriented text surfaces.
  */
 import { Command } from "commander";
-import { type LanesMesh, type SpawnLoginResult } from "./lanes-shared.js";
+import { type LanesMesh, type OutpostRouteIdentity, type SpawnLoginResult } from "./lanes-shared.js";
 export type { LanesMesh, SpawnLoginResult } from "./lanes-shared.js";
 export { CLAUDE_ACCOUNT_BALANCE_SIGNALS_FLAG, LANE_OUTPOST_LOAD_BALANCING_FLAG } from "./lanes-shared.js";
 export { resolveAnswerChoice } from "./lanes-questions.js";
@@ -38,6 +38,7 @@ export interface LanesCommandDeps {
     /** Membership-backed explicit company selection for account-home writers. */
     resolveActiveCompany?: (company: string) => Promise<LaneCompanyRef | null>;
     listOutpostIds?: () => Promise<string[]>;
+    listOutpostRoutes?: () => Promise<OutpostRouteIdentity[]>;
     readOutpostIdentity?: () => OutpostIdentity;
     spawnLogin?: (opts: {
         command: string;

package/dist/commands/lanes.js

@@ -36,7 +36,7 @@ import { createOutpostProfileRepinContext, parseOutpostProfileRepinContext, } fr
 import { createOutpostRegistryWorkerApprovalContext, parseOutpostRegistryWorkerApprovalContext, } from "../lib/lanes/outpost-registry-worker-approval.js";
 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";
-import { buildOutpostCapacityCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostQuestionListCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, outpostRejectedEffortOption, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
+import { buildOutpostCapacityCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostQuestionListCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, outpostRejectedEffortOption, parseOutpostPickupPayload, PICKUP_WAIT_MS, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
 import { outpostHireSummaryCacheKey, readOutpostHireSummaryCache, writeOutpostHireSummaryCache, } from "../lib/lanes/outpost-hire-cache.js";
 import { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "../lib/lanes/host-capacity.js";
 import { BALANCE_MOVABLE_STATES, selectClaudeAccount, } from "../lib/lanes/claude-balance.js";
@@ -159,6 +159,10 @@ async function defaultListOutpostIds() {
     const rows = await defaultOutpostsClient().list();
     return rows.map((row) => row.outpostId);
 }
+async function defaultListOutpostRoutes() {
+    const rows = await defaultOutpostsClient().list();
+    return rows.map(({ outpostId, instanceName }) => ({ outpostId, instanceName }));
+}
 async function defaultStageOutpostPayload(outpostId, bytes) {
     return stageOutpostPayload(defaultOutpostsClient(), outpostId, bytes);
 }
@@ -218,6 +222,9 @@ function resolveDeps(deps = {}) {
     };
     const bindProcessCwd = deps.hqRoot === undefined;
     const resolveRoot = deps.hqRoot ?? (() => resolveLanesHqRoot({ env, cwd: cwd() }));
+    const listOutpostRoutes = deps.listOutpostRoutes ?? (deps.listOutpostIds
+        ? async () => (await deps.listOutpostIds()).map((outpostId) => ({ outpostId }))
+        : defaultListOutpostRoutes);
     const hqRoot = () => {
         callerCwd();
         const root = resolveRoot();
@@ -236,6 +243,7 @@ function resolveDeps(deps = {}) {
         resolveCompany: deps.resolveCompany ?? defaultResolveCompany,
         resolveActiveCompany: deps.resolveActiveCompany ?? defaultResolveActiveCompany,
         listOutpostIds: deps.listOutpostIds ?? defaultListOutpostIds,
+        listOutpostRoutes,
         readOutpostIdentity: deps.readOutpostIdentity ?? (() => readOutpostIdentity()),
         spawnLogin: deps.spawnLogin ?? defaultSpawnLogin,
         throttleDeps: deps.throttleDeps ?? defaultThrottleDeps(env),
@@ -611,6 +619,7 @@ async function fetchOwnerLaneHireFields(ctx, lane) {
     }
     const outpostId = lane.host.id;
     const hqBinary = outpostCliOverride(ctx, outpostId);
+    const waitMs = outpostSingleLaneWaitMs(ctx.env);
     let dispatched;
     try {
         dispatched = await ctx.dispatchOutpostExec({
@@ -620,12 +629,15 @@ async function fetchOwnerLaneHireFields(ctx, lane) {
                 laneId: lane.lane_id,
                 hqBinary,
             }),
-            timeoutSeconds: OUTPOST_HIRE_SUMMARY_TIMEOUT_SECONDS,
-            waitMs: OUTPOST_HIRE_SUMMARY_WAIT_MS,
+            timeoutSeconds: Math.ceil(waitMs / 1000),
+            waitMs,
         });
     }
     catch (err) {
-        throw new LanesError("outpost_lane_hire_summary_unavailable", `Could not read hire summary for lane ${lane.lane_id} from Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { lane_id: lane.lane_id, outpost_id: outpostId });
+        const message = dispatchErrorMessage(err);
+        throw new LanesError("outpost_lane_hire_summary_unavailable", /timed out waiting for outpost pickup/i.test(message)
+            ? outpostPickupTimeoutMessage(outpostId, waitMs, `reading hire summary for lane ${lane.lane_id}`)
+            : `Could not read hire summary for lane ${lane.lane_id} from Outpost ${outpostId}: ${message}`, { lane_id: lane.lane_id, outpost_id: outpostId });
     }
     if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
         throw new LanesError("outpost_lane_hire_summary_unavailable", `Outpost ${outpostId} did not confirm the hire summary for lane ${lane.lane_id}`, { lane_id: lane.lane_id, outpost_id: outpostId, command_id: dispatched.commandId });
@@ -808,8 +820,6 @@ async function batchOwnerLaneHireFields(ctx, lanes) {
     writeOutpostHireSummaryCache(ctx.hqRoot(), cacheUpdates, ctx.now().getTime(), cached);
     return outcomes;
 }
-const OUTPOST_HIRE_SUMMARY_TIMEOUT_SECONDS = 20;
-const OUTPOST_HIRE_SUMMARY_WAIT_MS = 15_000;
 const OUTPOST_HIRE_SUMMARY_CONCURRENCY = 4;
 async function laneHirePresentation(ctx, lane, lanes) {
     const local = laneHireFields(lane, lanes);
@@ -886,6 +896,28 @@ async function withResumeHireAdmission(ctx, lane, fn, grantContext) {
 }
 const CAPACITY_PROBE_TIMEOUT_MS = 15_000;
 const MAX_PLACEMENT_OUTPOSTS = 16;
+const OUTPOST_HIRE_SUMMARY_TIMEOUT_SECONDS = 20;
+const OUTPOST_HIRE_SUMMARY_WAIT_MS = 15_000;
+const OUTPOST_SINGLE_LANE_WAIT_ENV = "HQ_LANES_OUTPOST_SINGLE_LANE_WAIT_MS";
+const OUTPOST_SINGLE_LANE_WAIT_MAX_MS = 600_000;
+function outpostSingleLaneWaitMs(env) {
+    const raw = env[OUTPOST_SINGLE_LANE_WAIT_ENV]?.trim() || String(PICKUP_WAIT_MS);
+    const value = /^\d+$/.test(raw) ? Number(raw) : Number.NaN;
+    if (!Number.isSafeInteger(value) ||
+        value < CAPACITY_PROBE_TIMEOUT_MS ||
+        value > OUTPOST_SINGLE_LANE_WAIT_MAX_MS) {
+        throw new LanesError("outpost_wait_invalid", `${OUTPOST_SINGLE_LANE_WAIT_ENV} must be an integer from ${CAPACITY_PROBE_TIMEOUT_MS} to ${OUTPOST_SINGLE_LANE_WAIT_MAX_MS} milliseconds`, { env: OUTPOST_SINGLE_LANE_WAIT_ENV });
+    }
+    return value;
+}
+function outpostRouteMatchesHost(route, host) {
+    return typeof route.instanceName === "string" &&
+        route.instanceName.trim() !== "" &&
+        sanitizeHostComponent(route.instanceName.trim()) === sanitizeHostComponent(host.trim());
+}
+function outpostPickupTimeoutMessage(outpostId, waitMs, operation) {
+    return `Outpost ${outpostId} pickup timed out after ${waitMs}ms while ${operation}. Raise ${OUTPOST_SINGLE_LANE_WAIT_ENV} (milliseconds) and retry.`;
+}
 function outpostIdentityUnknownError(message, expectedId, details = {}) {
     const expected = expectedId ?? "<expected-outpost-id>";
     const command = `hq lanes outpost-identity backfill --id ${expected}`;
@@ -1025,14 +1057,20 @@ function normalizedLaneListQuery(query) {
     };
 }
 async function readOutpostLaneRecordsUncached(ctx, outpostId, query) {
+    const targetedLookup = query.hierarchy !== undefined || query.laneIds !== undefined;
+    const waitMs = targetedLookup ? outpostSingleLaneWaitMs(ctx.env) : CAPACITY_PROBE_TIMEOUT_MS;
     let result;
     try {
-        result = await dispatchOutpostLaneList(ctx, outpostId, query, CAPACITY_PROBE_TIMEOUT_MS / 1000, CAPACITY_PROBE_TIMEOUT_MS);
+        result = await dispatchOutpostLaneList(ctx, outpostId, query, Math.ceil(waitMs / 1000), waitMs);
     }
     catch (err) {
+        const message = dispatchErrorMessage(err);
+        if (/timed out waiting for outpost pickup/i.test(message)) {
+            throw new LanesError("outpost_lane_list_unavailable", outpostPickupTimeoutMessage(outpostId, waitMs, "reading the requested lane"), { outpost_id: outpostId, wait_ms: waitMs, wait_env: OUTPOST_SINGLE_LANE_WAIT_ENV });
+        }
         if (isLanesError(err))
             throw err;
-        throw new LanesError("outpost_lane_list_unavailable", `Could not read lanes from Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { outpost_id: outpostId });
+        throw new LanesError("outpost_lane_list_unavailable", `Could not read lanes from Outpost ${outpostId}: ${message}`, { outpost_id: outpostId });
     }
     if (result.done !== true || result.status !== "Success" || result.exitCode !== 0) {
         throw new LanesError("outpost_lane_list_unavailable", `Outpost ${outpostId} did not return a successful lane list`, { outpost_id: outpostId, status: result.status, done: result.done ?? false, exit_code: result.exitCode });
@@ -1119,17 +1157,34 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
     if (!hostSuffix || sanitizeHostComponent(hostSuffix) !== hostSuffix) {
         throw commandLaneNotFound(laneId, options.outpostHint === true);
     }
-    let rawOutpostIds;
+    let rawOutpostRoutes;
     try {
-        rawOutpostIds = await ctx.listOutpostIds();
+        rawOutpostRoutes = await ctx.listOutpostRoutes();
     }
     catch (err) {
         throw new LanesError("outpost_list_unavailable", `Could not resolve registered Outposts for lane ${laneId}: ${dispatchErrorMessage(err)}`, { lane_id: laneId });
     }
-    if (!Array.isArray(rawOutpostIds)) {
+    if (!Array.isArray(rawOutpostRoutes)) {
         throw new LanesError("outpost_list_invalid", "Registered Outpost list is not an array", { lane_id: laneId });
     }
-    const outpostIds = rawOutpostIds.map((id) => typeof id === "string" ? id.trim() : "");
+    const outpostRoutes = rawOutpostRoutes.map((raw, index) => {
+        if (raw === null || typeof raw !== "object" || Array.isArray(raw) ||
+            typeof raw.outpostId !== "string" ||
+            !raw.outpostId ||
+            (raw.instanceName !== undefined &&
+                typeof raw.instanceName !== "string")) {
+            throw new LanesError("outpost_list_invalid", `Registered Outpost row ${index} is malformed`, {
+                lane_id: laneId,
+                index,
+            });
+        }
+        const row = raw;
+        return {
+            outpostId: row.outpostId.trim(),
+            ...(typeof row.instanceName === "string" ? { instanceName: row.instanceName.trim() } : {}),
+        };
+    });
+    const outpostIds = outpostRoutes.map(({ outpostId }) => outpostId);
     if (outpostIds.length > MAX_PLACEMENT_OUTPOSTS ||
         outpostIds.some((id) => id === "") ||
         new Set(outpostIds).size !== outpostIds.length) {
@@ -1142,9 +1197,23 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
     if (requestedOutpostId !== undefined && !outpostIds.includes(requestedOutpostId)) {
         throw new LanesError("outpost_not_registered", `Outpost ${requestedOutpostId} is not registered`, { lane_id: laneId, outpost_id: requestedOutpostId });
     }
+    const hostRoutes = outpostRoutes.filter((route) => outpostRouteMatchesHost(route, hostSuffix));
+    const identity = ctx.readOutpostIdentity();
+    const localHostRoutes = outpostRoutes.filter((route) => outpostRouteMatchesHost(route, ctx.hostname()));
+    if (localHostRoutes.length > 1 || (identity.kind === "id" && localHostRoutes.some((route) => route.outpostId !== identity.id))) {
+        throw new LanesError("outpost_host_ambiguous", "Registered Outpost host identity conflicts with this host's identity", { lane_id: laneId, local_outpost_id: identity.kind === "id" ? identity.id : undefined });
+    }
+    const localOutpostId = identity.kind === "id" ? identity.id : localHostRoutes[0]?.outpostId;
+    const hostOutpostIds = hostRoutes.map(({ outpostId }) => outpostId);
+    const hostOutpostIdSet = new Set(hostOutpostIds);
     const matches = [];
     const failedOutpostIds = [];
-    const lookupOutpostIds = requestedOutpostId === undefined ? outpostIds : [requestedOutpostId];
+    const lookupOutpostIds = requestedOutpostId !== undefined
+        ? [requestedOutpostId]
+        : [
+            ...hostOutpostIds.filter((id) => id !== localOutpostId),
+            ...outpostIds.filter((id) => id !== localOutpostId && !hostOutpostIdSet.has(id)),
+        ];
     for (const outpostId of lookupOutpostIds) {
         let ownerLanes;
         try {
@@ -1156,6 +1225,8 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
         catch (err) {
             if (requestedOutpostId !== undefined)
                 throw err;
+            if (isLanesError(err) && err.error === "outpost_wait_invalid")
+                throw err;
             failedOutpostIds.push(outpostId);
             continue;
         }
@@ -3547,6 +3618,7 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
         throw new LanesError("outpost_dispatch_failed", `Lane ${lane.lane_id} has no Outpost host to dispatch to`, { lane_id: lane.lane_id });
     }
     const outpostId = lane.host.id;
+    const waitMs = outpostSingleLaneWaitMs(ctx.env);
     const profileRepinContext = action === "resume" &&
         options.worker !== undefined &&
         callerMatchesSenior(ctx, lane.senior)
@@ -3583,6 +3655,8 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
     try {
         const dispatchCommand = (contexts) => ctx.dispatchOutpostExec({
             outpostId,
+            timeoutSeconds: Math.ceil(waitMs / 1000),
+            waitMs,
             command: buildOutpostLaneCommand({
                 action: action === "grant"
                     ? "grant-target"
@@ -3636,7 +3710,10 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
         }
     }
     catch (err) {
-        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 message = dispatchErrorMessage(err);
+        throw new LanesError("outpost_dispatch_failed", /timed out waiting for outpost pickup/i.test(message)
+            ? outpostPickupTimeoutMessage(outpostId, waitMs, `dispatching ${action} for lane ${lane.lane_id}`)
+            : `Could not dispatch ${action} for lane ${lane.lane_id} to Outpost ${outpostId}: ${message}`, { lane_id: lane.lane_id, outpost_id: outpostId, wait_ms: waitMs, wait_env: OUTPOST_SINGLE_LANE_WAIT_ENV });
     }
     if (grantContextRejected) {
         throw new LanesError("outpost_cli_upgrade_required", `Outpost ${outpostId} needs an hq-cli release containing this fix before it can resume lane ${lane.lane_id} under its primary-hosted senior`, {
@@ -3834,6 +3911,7 @@ function parseReparentDescendantIds(value, laneId, outpostId) {
     return ids;
 }
 async function readOutpostLaneSnapshot(ctx, outpostId, laneId) {
+    const waitMs = outpostSingleLaneWaitMs(ctx.env);
     let dispatched;
     try {
         dispatched = await ctx.dispatchOutpostExec({
@@ -3843,12 +3921,15 @@ async function readOutpostLaneSnapshot(ctx, outpostId, laneId) {
                 laneId,
                 hqBinary: outpostCliOverride(ctx, outpostId),
             }),
-            timeoutSeconds: OUTPOST_HIRE_SUMMARY_TIMEOUT_SECONDS,
-            waitMs: OUTPOST_HIRE_SUMMARY_WAIT_MS,
+            timeoutSeconds: Math.ceil(waitMs / 1000),
+            waitMs,
         });
     }
     catch (err) {
-        throw new LanesError("outpost_lane_sync_unavailable", `Could not refresh descendant lane ${laneId} from Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { lane_id: laneId, outpost_id: outpostId });
+        const message = dispatchErrorMessage(err);
+        throw new LanesError("outpost_lane_sync_unavailable", /timed out waiting for outpost pickup/i.test(message)
+            ? outpostPickupTimeoutMessage(outpostId, waitMs, `reading lane ${laneId}`)
+            : `Could not refresh descendant lane ${laneId} from Outpost ${outpostId}: ${message}`, { lane_id: laneId, outpost_id: outpostId });
     }
     if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
         throw new LanesError("outpost_lane_sync_unavailable", `Outpost ${outpostId} did not confirm the snapshot for descendant lane ${laneId}`, { lane_id: laneId, outpost_id: outpostId, command_id: dispatched.commandId });
@@ -5534,12 +5615,12 @@ async function prepareAccountMove(ctx, lane, input) {
     const at = now.toISOString();
     const from = lane.account ?? null;
     // The capacity decision and the record write run under the target
-    // account's admission lock, the same serialization lane creation uses. A
-    // slot is taken by a running lane or by a lane another move has already
-    // pointed at the account whose spawn has not claimed it yet
-    // (`pending_resume` set by this write, cleared by the claim), so two moves
-    // into one free slot cannot both start.
-    return withLaneAdmissionLock(hqRoot, lane.provider, async () => {
+    // account's admission lock, or while reconcile holds all provider
+    // admission locks. A slot is taken by a running lane or a lane another move
+    // has pointed at its target account but whose spawn has not claimed it yet
+    // (`pending_resume` is set by this write and cleared by the claim), so two
+    // moves into one free slot cannot both start.
+    const writeMove = async () => {
         const admission = input.deferTurnStart
             ? undefined
             : await assessLaneAdmission(ctx, lane, {
@@ -5602,7 +5683,10 @@ async function prepareAccountMove(ctx, lane, input) {
             return next;
         }), input.grantContext);
         return { lane: moved, from, to: target, copy, queued };
-    }, ctx.sleep);
+    };
+    return input.admissionLocksHeld
+        ? writeMove()
+        : withLaneAdmissionLock(hqRoot, lane.provider, writeMove, ctx.sleep);
 }
 async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, options = {}) {
     if (lane.provider !== "claude")
@@ -6370,22 +6454,27 @@ function parseRemoteCancelledQuestionIds(value, laneId, outpostId, commandId) {
     }
     return value;
 }
-async function readOutpostTerminalLane(ctx, laneId, outpostId, stopCommandId) {
+async function readOutpostTerminalLane(ctx, laneId, outpostId, stopCommandId, waitMs) {
     let dispatched;
     try {
         dispatched = await ctx.dispatchOutpostExec({
             outpostId,
             command: buildOutpostLaneCommand({ action: "show", laneId }),
-            timeoutSeconds: 120,
-            waitMs: 120_000,
+            timeoutSeconds: Math.ceil(waitMs / 1000),
+            waitMs,
         });
     }
     catch (err) {
-        throw new LanesError("outpost_delivery_unconfirmed", `Could not read terminal lane ${laneId} from Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, {
+        const message = dispatchErrorMessage(err);
+        throw new LanesError("outpost_delivery_unconfirmed", /timed out waiting for outpost pickup/i.test(message)
+            ? outpostPickupTimeoutMessage(outpostId, waitMs, `confirming terminal lane ${laneId}`)
+            : `Could not read terminal lane ${laneId} from Outpost ${outpostId}: ${message}`, {
             lane_id: laneId,
             outpost_id: outpostId,
             command_id: stopCommandId,
             sync_command_id: null,
+            wait_ms: waitMs,
+            wait_env: OUTPOST_SINGLE_LANE_WAIT_ENV,
         });
     }
     const commandId = dispatched.commandId?.trim();
@@ -6454,17 +6543,21 @@ async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false) {
         throw new LanesError("outpost_dispatch_failed", `Lane ${lane.lane_id} has no Outpost host to dispatch stop to`, { lane_id: lane.lane_id });
     }
     const outpostId = lane.host.id;
+    const waitMs = outpostSingleLaneWaitMs(ctx.env);
     let dispatched;
     try {
         dispatched = await ctx.dispatchOutpostExec({
             outpostId,
             command: buildOutpostLaneCommand({ action: "stop", laneId: lane.lane_id, reason }),
-            timeoutSeconds: 120,
-            waitMs: 120_000,
+            timeoutSeconds: Math.ceil(waitMs / 1000),
+            waitMs,
         });
     }
     catch (err) {
-        throw new LanesError("outpost_dispatch_failed", `Could not dispatch stop for lane ${lane.lane_id} to Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { lane_id: lane.lane_id, outpost_id: outpostId });
+        const message = dispatchErrorMessage(err);
+        throw new LanesError("outpost_dispatch_failed", /timed out waiting for outpost pickup/i.test(message)
+            ? outpostPickupTimeoutMessage(outpostId, waitMs, `stopping lane ${lane.lane_id}`)
+            : `Could not dispatch stop for lane ${lane.lane_id} to Outpost ${outpostId}: ${message}`, { lane_id: lane.lane_id, outpost_id: outpostId, wait_ms: waitMs, wait_env: OUTPOST_SINGLE_LANE_WAIT_ENV });
     }
     if (reason !== undefined && outpostRejectedStopReasonOption(dispatched)) {
         throw new LanesError("outpost_cli_upgrade_required", `Outpost ${outpostId} needs an hq-cli release containing stop reason support before it can stop lane ${lane.lane_id}`, {
@@ -6512,7 +6605,7 @@ async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false) {
         }
         state = remote.state;
         alreadyTerminal = true;
-        const owner = await readOutpostTerminalLane(ctx, lane.lane_id, outpostId, commandId);
+        const owner = await readOutpostTerminalLane(ctx, lane.lane_id, outpostId, commandId, waitMs);
         if (owner.lane.state !== state) {
             throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} returned a different terminal state for lane ${lane.lane_id}`, {
                 lane_id: lane.lane_id,
@@ -6993,6 +7086,93 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
         recoverQueuedMessages,
         mesh: ctx.mesh,
         env: ctx.env,
+        prepareKeepAliveClaudeResume: async (lane) => {
+            const recoveredLane = laneWithRecoveredProviderSession(hqRoot, lane);
+            const pendingModel = recoveredLane.pending_settings?.model;
+            const selectionLane = pendingModel === undefined
+                ? recoveredLane
+                : { ...recoveredLane, model: pendingModel, model_source: undefined };
+            let automatic;
+            try {
+                automatic = await selectAutomaticClaudeResumeAccount(ctx, selectionLane, undefined, {
+                    repairUnavailableAccount: true,
+                });
+            }
+            catch (err) {
+                return {
+                    lane: recoveredLane,
+                    selectionFailure: err instanceof LanesError
+                        ? `${err.error}: ${err.message}`
+                        : err instanceof Error
+                            ? err.message
+                            : String(err),
+                };
+            }
+            if (automatic === undefined)
+                return { lane: recoveredLane };
+            const { selection } = automatic;
+            if (opts.dryRun) {
+                return {
+                    lane: {
+                        ...selectionLane,
+                        account: selection.account,
+                        account_selection: selection,
+                        ...(pendingModel !== undefined
+                            ? { model: pendingModel, model_source: "cli" }
+                            : automatic.preservedModel !== undefined
+                                ? { model: automatic.preservedModel, model_source: "preserved" }
+                                : {}),
+                    },
+                };
+            }
+            let latest;
+            try {
+                latest = readLane(hqRoot, lane.lane_id);
+            }
+            catch (err) {
+                throw new LanesError("keep_alive_account_selection_lane_unreadable", `Cannot re-read lane ${lane.lane_id} before applying Claude account selection: ${err instanceof Error ? err.message : String(err)}`, { lane_id: lane.lane_id });
+            }
+            if (latest.version !== lane.version ||
+                latest.state !== lane.state ||
+                latest.keep_alive !== true ||
+                latest.keep_alive_opted_in_at !== lane.keep_alive_opted_in_at ||
+                latest.provider_session_id !== lane.provider_session_id ||
+                latest.last_resume?.session_id !== lane.last_resume?.session_id)
+                return { lane: latest };
+            if (selection.account === lane.account) {
+                return { lane: persistClaudeAccountSelection(hqRoot, recoveredLane, selection) };
+            }
+            try {
+                const moved = await prepareAccountMove(ctx, recoveredLane, {
+                    account: selection.account,
+                    cliModel: pendingModel,
+                    accountHistoryReason: "keep_alive_resume",
+                    ...(pendingModel === undefined && automatic.preservedModel !== undefined
+                        ? { preservedModel: automatic.preservedModel }
+                        : {}),
+                    deferTurnStart: true,
+                    admissionLocksHeld: true,
+                    accountSelection: selection,
+                });
+                return { lane: moved.lane };
+            }
+            catch (err) {
+                let latest;
+                try {
+                    latest = readLane(hqRoot, lane.lane_id);
+                }
+                catch (readErr) {
+                    return {
+                        lane,
+                        selectionFailure: `account move failed: ${err instanceof Error ? err.message : String(err)}; lane re-read failed: ${readErr instanceof Error ? readErr.message : String(readErr)}`,
+                    };
+                }
+                return {
+                    lane: latest,
+                    selectionFailure: `account move failed: ${err instanceof LanesError ? `${err.error}: ${err.message}` : err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        },
     });
     printJson(summary);
     if (!summary.ok) {

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

@@ -92,6 +92,11 @@ export interface ReconcileDeps {
     meshEmitTimeoutMs?: number;
     /** Fresh keep-alive eligibility read; injected to exercise opt-in changes before queueing. */
     readKeepAliveRecheckLane?: (hqRoot: string, laneId: string) => LaneRecord;
+    /** Reuse the command's Claude resume selection and session-move path for keep-alive. */
+    prepareKeepAliveClaudeResume?: (lane: LaneRecord) => Promise<{
+        lane: LaneRecord;
+        selectionFailure?: string;
+    }>;
     /** Process-table snapshot seam for the opt-in runaway-search guard. */
     runawayToolProcessLister?: () => readonly RunawayProcessInfo[];
     /** Test seam: prevent real process signals while exercising the guard. */

package/dist/lib/lanes/reconcile.js

@@ -1001,7 +1001,7 @@ export async function runPassBody(hqRoot, deps) {
     await withAllLaneAdmissionLocks(hqRoot, async () => {
         const freshLanes = loadLaneRecords(hqRoot, summary);
         const freshQuestions = loadQuestionRecords(hqRoot, summary);
-        resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, startDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany);
+        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, startDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany);
         const drainLanes = loadLaneRecords(hqRoot, summary);
         await admitQueued(hqRoot, drainLanes, summary, startDeps, now);
         await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, startDeps);
@@ -1723,7 +1723,7 @@ function latestEnvelopeMtimeMs(hqRoot, lane, ref) {
         throw new LanesError("keep_alive_envelope_timestamp_unavailable", `Cannot stat latest envelope for lane ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}`, { lane_id: lane.lane_id, path: filePath });
     }
 }
-function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCompany, supersessionLineageAwareByCompany) {
+async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCompany, supersessionLineageAwareByCompany) {
     const nowMs = now.getTime();
     const nowIso = now.toISOString();
     const config = loadLanesConfig(hqRoot);
@@ -2108,6 +2108,44 @@ function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCom
             });
             continue;
         }
+        const seniorId = current.senior.kind === "lane" ? current.senior.id : undefined;
+        if (seniorId !== undefined) {
+            let grantPreflight;
+            try {
+                grantPreflight = withHireGrantAdmission(hqRoot, seniorId, (snapshot) => {
+                    const latestLane = readLane(hqRoot, current.lane_id);
+                    if (latestLane.version !== current.version ||
+                        latestLane.state !== current.state ||
+                        latestLane.keep_alive !== true ||
+                        latestLane.keep_alive_opted_in_at !== current.keep_alive_opted_in_at ||
+                        latestLane.senior.kind !== "lane" ||
+                        latestLane.senior.id !== seniorId)
+                        return { kind: "stale" };
+                    const refusal = terminalChildResumeHireGrantError(latestLane, snapshot);
+                    return refusal === null
+                        ? { kind: "eligible" }
+                        : { kind: "refused", error: refusal.error, message: refusal.message };
+                });
+            }
+            catch (err) {
+                markDirty(summary, {
+                    kind: "lane",
+                    id: current.lane_id,
+                    why: `keep-alive hire admission preflight failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+            if (grantPreflight.kind === "stale")
+                continue;
+            if (grantPreflight.kind === "refused") {
+                summary.skipped.push({
+                    kind: "lane",
+                    id: current.lane_id,
+                    why: `keep_alive_hire_admission: ${grantPreflight.error}: ${grantPreflight.message}`,
+                });
+                continue;
+            }
+        }
         const resumedFrom = current.state === "done" ? "done" : "interrupted";
         const resumeText = resumedFrom === "interrupted"
             ? LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT
@@ -2118,6 +2156,114 @@ function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCom
         if (carriesAnsweredQuestions && !deps.dryRun) {
             writeAnsweredQuestions(hqRoot, current, questions);
         }
+        let accountSelectionFailure;
+        if (current.provider === "claude" && deps.prepareKeepAliveClaudeResume !== undefined) {
+            const optInBeforePreparation = current.keep_alive_opted_in_at;
+            let preparedLane;
+            try {
+                const prepared = await deps.prepareKeepAliveClaudeResume(current);
+                preparedLane = prepared.lane;
+                accountSelectionFailure = prepared.selectionFailure;
+            }
+            catch (err) {
+                // Account balancing is best-effort for keep-alive. A failure to read
+                // balance inputs must not prevent the existing session from resuming.
+                try {
+                    preparedLane = readLane(hqRoot, current.lane_id);
+                }
+                catch (readErr) {
+                    markDirty(summary, {
+                        kind: "lane",
+                        id: current.lane_id,
+                        why: `keep-alive account selection failed and lane could not be re-read: ${readErr instanceof Error ? readErr.message : String(readErr)}`,
+                    });
+                    continue;
+                }
+                accountSelectionFailure = err instanceof Error ? err.message : String(err);
+            }
+            const preparedSessionId = preparedLane.provider_session_id ?? preparedLane.last_resume?.session_id;
+            if (preparedLane.state !== initialState ||
+                preparedLane.keep_alive !== true ||
+                !laneRunsHere(preparedLane, deps.host) ||
+                preparedSessionId !== currentSessionId)
+                continue;
+            let latest;
+            try {
+                latest = deps.dryRun
+                    ? (deps.readKeepAliveRecheckLane?.(hqRoot, current.lane_id) ?? readLane(hqRoot, current.lane_id))
+                    : readLane(hqRoot, current.lane_id);
+            }
+            catch (err) {
+                markDirty(summary, {
+                    kind: "lane",
+                    id: current.lane_id,
+                    why: `keep-alive eligibility recheck failed after account selection: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+            if (latest.state !== initialState || !laneRunsHere(latest, deps.host))
+                continue;
+            if (latest.keep_alive !== true) {
+                recordKeepAliveSkip(hqRoot, latest, "not_opted_in", summary, deps);
+                continue;
+            }
+            if (latest.keep_alive_opted_in_at !== optInBeforePreparation) {
+                summary.skipped.push({
+                    kind: "lane",
+                    id: latest.lane_id,
+                    why: "keep_alive_eligibility_changed_during_account_selection",
+                });
+                continue;
+            }
+            const latestSessionId = latest.provider_session_id ?? latest.last_resume?.session_id;
+            if (latestSessionId !== currentSessionId)
+                continue;
+            let latestEligibilityAtMs;
+            if (initialState === "done") {
+                const envelope = readLatestEnvelopeRecord(hqRoot, latest.lane_id);
+                if (!envelope || envelope.envelope.decision !== "done")
+                    continue;
+                if (doneKeepAliveVerdict(latest, envelope.envelope, latest.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, latest, questions)) !== "eligible")
+                    continue;
+                try {
+                    latestEligibilityAtMs = latestEnvelopeMtimeMs(hqRoot, latest, envelope.ref);
+                }
+                catch (err) {
+                    markDirty(summary, {
+                        kind: "lane",
+                        id: latest.lane_id,
+                        why: `keep-alive envelope timestamp unavailable after account selection: ${err instanceof Error ? err.message : String(err)}`,
+                    });
+                    continue;
+                }
+            }
+            else {
+                latestEligibilityAtMs = Date.parse(latest.interrupted_at ?? "");
+            }
+            const latestOptedInAtMs = Date.parse(latest.keep_alive_opted_in_at ?? "");
+            if (!Number.isFinite(latestEligibilityAtMs) || !Number.isFinite(latestOptedInAtMs))
+                continue;
+            if (latestEligibilityAtMs <= latestOptedInAtMs) {
+                recordKeepAliveSkip(hqRoot, latest, initialState === "done" ? "envelope_before_opt_in" : "interruption_before_opt_in", summary, deps);
+                continue;
+            }
+            current = deps.dryRun ? preparedLane : latest;
+        }
+        if (accountSelectionFailure !== undefined) {
+            summary.skipped.push({
+                kind: "lane",
+                id: current.lane_id,
+                why: `keep_alive_account_selection_failed: ${accountSelectionFailure}`,
+            });
+            if (!deps.dryRun) {
+                recordKeepAliveEvent(hqRoot, current.lane_id, summary, {
+                    event: "keep_alive_account_selection_failed",
+                    at: nowIso,
+                    account: current.account ?? null,
+                    reason: accountSelectionFailure,
+                });
+            }
+        }
         const queue = (expectedSeniorId) => casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
             latestLane.state === current.state &&
             latestLane.keep_alive === true &&
@@ -2145,7 +2291,6 @@ function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCom
             keep_alive_exhausted_at: undefined,
             keep_alive_blocked_reason: undefined,
         }), deps.dryRun);
-        const seniorId = current.senior.kind === "lane" ? current.senior.id : undefined;
         let queued;
         if (seniorId) {
             try {

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

@@ -500,9 +500,8 @@ export interface LaneRecord {
     /** Eligible accounts for a queue entry created without an explicit account. */
     admission_accounts?: string[];
     /**
-     * Every operator move of the lane's session to another account of the
-     * same provider (`hq lanes resume|message --account`), newest last, capped
-     * like the other histories.
+     * Moves of the lane's session to another account of the same provider,
+     * newest last and capped like the other histories.
      */
     account_history?: AccountHistoryEntry[];
     /** Bounded audit history for explicitly authorized resumes from failed. */
@@ -665,7 +664,7 @@ export interface AccountHistoryEntry {
     from: string | null;
     to: string;
     at: string;
-    reason: "first_assignment" | "model_change" | "usage_limit" | "account_unavailable" | "recorded_account_logged_out" | "load_balance" | "operator_move";
+    reason: "first_assignment" | "model_change" | "usage_limit" | "account_unavailable" | "recorded_account_logged_out" | "load_balance" | "keep_alive_resume" | "operator_move";
 }
 export interface FailedResumeHistoryEntry {
     at: string;

package/package.json

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