@indigoai-us/hq-cli 5.203.0 → 5.205.0

package/dist/commands/lanes.js

@@ -10,6 +10,7 @@ import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { readLocalOverride } from "@indigoai-us/hq-flags-client";
 import { Option } from "commander";
 import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
@@ -32,11 +33,12 @@ import { vaultApiFetch } from "../utils/vault-api.js";
 import { openMeshTransport } from "../lib/mesh/client.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
-import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
+import { effectiveAccountHome } from "../lib/lanes/account-home.js";
+import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
-import { providerCompactAfterMs } from "../lib/lanes/config.js";
+import { assertUniqueAccountHomes, providerCompactAfterMs } from "../lib/lanes/config.js";
 import { parseCliEffort, resolveLaneEffort, } from "../lib/lanes/effort.js";
 import { LanesError } from "../lib/lanes/errors.js";
 import { dispatchLaneDelivery } from "../lib/lanes/delivery-core.js";
@@ -59,6 +61,7 @@ const VENDOR_LOGIN = {
 export { emitLaneDecisionEvents };
 export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
 export const LANE_OUTPOST_QUESTION_VISIBILITY_FLAG = "lanes.outpost-question-visibility";
+export const LANE_HOST_SCOPED_ACCOUNT_HOMES_FLAG = "lanes.host-scoped-account-homes";
 function defaultLanePlacementEnabled() {
     return resolveProcessFlagGate(LANE_OUTPOST_LOAD_BALANCING_FLAG, { fallback: false }, () => false);
 }
@@ -82,6 +85,15 @@ function defaultLaneOutpostQuestionVisibilityEnabled(company, env) {
         env,
     });
 }
+function defaultLaneHostScopedAccountHomesEnabled(company, env) {
+    return readLanesRegistryFlag(LANE_HOST_SCOPED_ACCOUNT_HOMES_FLAG, { company, env });
+}
+async function hostScopedAccountHomesEnabled(ctx) {
+    const localOverride = readLocalOverride(LANE_HOST_SCOPED_ACCOUNT_HOMES_FLAG, ctx.env);
+    if (localOverride !== null)
+        return localOverride;
+    return ctx.laneHostScopedAccountHomesEnabled(await ctx.resolveCompany());
+}
 function withoutProviderHome(value) {
     if (Array.isArray(value))
         return value.map(withoutProviderHome);
@@ -286,6 +298,8 @@ function resolveDeps(deps = {}) {
             ((company) => defaultLaneOutpostQuestionVisibilityEnabled(company, env)),
         laneTrackerEnabled: deps.laneTrackerEnabled ?? defaultLaneTrackerEnabled,
         laneTrackerMeshEnabled: deps.laneTrackerMeshEnabled ?? defaultLaneTrackerMeshEnabled,
+        laneHostScopedAccountHomesEnabled: deps.laneHostScopedAccountHomesEnabled ??
+            ((company) => defaultLaneHostScopedAccountHomesEnabled(company, env)),
         trackerActor: deps.trackerActor ?? defaultTrackerActor,
     };
 }
@@ -298,6 +312,7 @@ function livenessDepsFromCtx(ctx) {
         env: ctx.env,
         existsSync: ctx.existsSync,
         readFileSync: ctx.readFileSync,
+        hostname: ctx.hostname,
     };
 }
 function reconcileHostFromCtx(ctx) {
@@ -849,33 +864,15 @@ async function withResumeHireAdmission(ctx, lane, fn) {
     }
     if (!await ctx.laneHireGrantsEnabled(lane.company))
         return fn();
-    return withHireGrantAdmission(hqRoot, lane.senior.id, ({ parent, children, parentGrant, availableChildGrant }) => {
+    return withHireGrantAdmission(hqRoot, lane.senior.id, (snapshot) => {
         const current = readLane(hqRoot, lane.lane_id);
         // A different resume already reactivated this lane; it occupies the slot
         // in the shared snapshot and is not a second hire.
         if (!isTerminalLaneState(current.state))
             return fn();
-        if (isTerminalLaneState(parent.state)) {
-            throw new LanesError("hire_grant_senior_inactive", `Senior lane ${parent.lane_id} is ${parent.state} and cannot resume child lanes`, { senior_lane_id: parent.lane_id, state: parent.state });
-        }
-        if (children.length >= (parent.hire_grant ?? 0)) {
-            throw hireGrantCapacityError(parent, children);
-        }
-        const requestedGrant = current.hire_grant ?? 0;
-        if (requestedGrant > availableChildGrant) {
-            throw new LanesError("hire_grant_carve_exceeded", `Senior lane ${parent.lane_id} has ${availableChildGrant} unassigned hire grant remaining, but terminal child ${current.lane_id} needs ${requestedGrant} to resume. Ask its senior for more: write an ask envelope with the desired total grant and why; the senior runs hq lanes grant ${parent.lane_id} --hire <n>.`, {
-                senior_lane_id: parent.lane_id,
-                parent_grant: parentGrant,
-                alive_children: children.map((child) => child.lane_id),
-                assigned_child_grants: assignedChildHireGrants(children),
-                requested_hire_grant: requestedGrant,
-                available_hire_grant: availableChildGrant,
-                ask_guidance: {
-                    envelope: "decision=ask; include the desired total grant and the reason",
-                    senior_command: `hq lanes grant ${parent.lane_id} --hire <n>`,
-                },
-            });
-        }
+        const refusal = terminalChildResumeHireGrantError(current, snapshot);
+        if (refusal !== null)
+            throw refusal;
         return fn();
     });
 }
@@ -1004,6 +1001,7 @@ async function loadHostCapacitySnapshots(ctx, hqRoot, config = loadLanesConfig(h
         lanes: loadAllLanes(hqRoot),
         config,
         existsSync: ctx.existsSync,
+        hostname: ctx.hostname(),
         now: ctx.now(),
     });
     const remote = await Promise.all(remoteIds.map(async (id) => {
@@ -1118,6 +1116,7 @@ async function loadClaudeBalanceHostSnapshots(ctx, hqRoot, config) {
         existsSync: ctx.existsSync,
         probe: ctx.probeProvider,
         env: ctx.env,
+        hostname: ctx.hostname(),
         now: ctx.now(),
     });
     const snapshots = [{
@@ -1140,6 +1139,7 @@ async function loadClaudeBalanceHostSnapshots(ctx, hqRoot, config) {
                     existsSync: ctx.existsSync,
                     probe: ctx.probeProvider,
                     env: ctx.env,
+                    hostname: ctx.hostname(),
                     now: ctx.now(),
                 }),
                 lanes: actualLocalLanes,
@@ -2196,6 +2196,7 @@ export function applyOutpostAccountPickup(hqRoot, laneId, modelDeps = {}) {
     try {
         const resolved = resolveAccount(lane.provider, lane.account, config, {
             hqRoot,
+            hostname: os.hostname(),
             accountDeps: {
                 probe: modelDeps.probe,
                 env: modelDeps.env,
@@ -2203,6 +2204,7 @@ export function applyOutpostAccountPickup(hqRoot, laneId, modelDeps = {}) {
         });
         const status = accountStatus(lane.provider, resolved.id, config, {
             existsSync: (p) => fs.existsSync(p),
+            hostname: os.hostname(),
             probe: modelDeps.probe,
             env: modelDeps.env,
         });
@@ -2449,6 +2451,11 @@ async function runCreate(ctx, opts) {
     const profileEffort = profileDefaultsApply ? profile?.meta.effort : undefined;
     const profileAccount = profileDefaultsApply ? profile?.meta.account : undefined;
     const profileAccounts = profileDefaultsApply ? profile?.meta.accounts : undefined;
+    const keepAlive = opts.keepAlive === true ||
+        (profileDefaultsApply && profile?.meta.keep_alive === true);
+    if (keepAlive && !providerSupportsSessionResume(provider)) {
+        throw new LanesError("keep_alive_provider_unsupported", `Provider ${provider} cannot resume recorded sessions, so keep-alive is unavailable`, { provider });
+    }
     const briefAbs = resolveCallerPath(ctx.callerCwd(), briefFile);
     if (!ctx.existsSync(briefAbs)) {
         throw new LanesError("brief_not_found", `Brief file not found: ${briefAbs}`, {
@@ -2589,6 +2596,7 @@ async function runCreate(ctx, opts) {
         }
         const resolved = resolveAccount(provider, requested, config, {
             hqRoot,
+            hostname: ctx.hostname(),
             cliModel,
             model: cliModel ?? profileModel,
         });
@@ -2597,6 +2605,7 @@ async function runCreate(ctx, opts) {
     else if (profileAccount !== undefined && profileAccounts === undefined) {
         const resolved = resolveAccount(provider, profileAccount, config, {
             hqRoot,
+            hostname: ctx.hostname(),
             cliModel,
             model: cliModel ?? profileModel,
         });
@@ -2650,6 +2659,7 @@ async function runCreate(ctx, opts) {
         const candidate = pinnedAccount ??
             resolveAccount(provider, undefined, config, {
                 hqRoot,
+                hostname: ctx.hostname(),
                 existsSync: ctx.existsSync,
                 accountDeps: { probe: ctx.probeProvider, env: ctx.env },
                 cliModel,
@@ -2669,6 +2679,7 @@ async function runCreate(ctx, opts) {
                     (profileAccounts === undefined || profileAccounts.includes(id)) &&
                     accountStatus(provider, id, config, {
                         existsSync: ctx.existsSync,
+                        hostname: ctx.hostname(),
                         probe: ctx.probeProvider,
                         env: ctx.env,
                     }).logged_in === true)
@@ -2679,7 +2690,10 @@ async function runCreate(ctx, opts) {
         const quotaBlocked = [];
         const quota = loadQuotaState(hqRoot);
         for (const id of toValidate) {
-            const home = accounts[id]?.home;
+            const account = accounts[id];
+            const home = account === undefined
+                ? undefined
+                : effectiveAccountHome(account, ctx.hostname()).home;
             if (home === undefined)
                 continue;
             checkedAccounts.push(id);
@@ -2782,6 +2796,7 @@ async function runCreate(ctx, opts) {
                         existsSync: ctx.existsSync,
                         probe: ctx.probeProvider,
                         env: ctx.env,
+                        hostname: ctx.hostname(),
                         now: ctx.now(),
                     }),
                     lanes: localLanes,
@@ -2805,6 +2820,7 @@ async function runCreate(ctx, opts) {
             pinnedAccount = resolveAccount(provider, undefined, config, {
                 hqRoot,
                 existsSync: ctx.existsSync,
+                hostname: ctx.hostname(),
                 accountDeps: { probe: ctx.probeProvider, env: ctx.env },
                 cliModel,
                 model: cliModel ?? profileModel,
@@ -2898,6 +2914,7 @@ async function runCreate(ctx, opts) {
                     worker_profile_ignored: ignoredWorkerProfileFields(provider),
                 }
                 : {}),
+            keep_alive: keepAlive,
             provider,
             account: pinnedAccount,
             ...(accountSelection !== undefined ? { account_selection: accountSelection } : {}),
@@ -3353,6 +3370,7 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
                 model: options.model,
                 effort: options.effort,
                 worker: options.worker,
+                keepAlive: options.keepAlive,
                 hire: options.hire,
                 grantContext,
                 compact: options.compact,
@@ -4029,6 +4047,7 @@ async function runCapacity(ctx) {
         existsSync: ctx.existsSync,
         probe: ctx.probeProvider,
         env: ctx.env,
+        hostname: ctx.hostname(),
         now: ctx.now(),
     });
     printJson(snapshot);
@@ -4478,6 +4497,13 @@ async function runShow(ctx, laneId) {
         effort_source: lane.effort_source ?? null,
         terminal_reason: lane.terminal_reason ?? null,
         terminal_details: lane.terminal_details ?? null,
+        keep_alive_state: {
+            enabled: lane.keep_alive === true,
+            consecutive_auto_resumes: lane.keep_alive_resume_count ?? 0,
+            last_auto_resume_at: lane.keep_alive_last_resume_at ?? null,
+            next_eligible_at: lane.keep_alive_next_eligible_at ?? null,
+            exhausted_at: lane.keep_alive_exhausted_at ?? null,
+        },
         last_message_at: lane.last_message_at ?? null,
         last_compaction: lane.last_compaction
             ? { ...lane.last_compaction, after: compactionAfterUsage(storedLane) }
@@ -4873,6 +4899,7 @@ function validateResumeProfileModel(ctx, lane, profile) {
     const account = resolveAccount(lane.provider, lane.account, config, {
         hqRoot,
         existsSync: ctx.existsSync,
+        hostname: ctx.hostname(),
         model: profile.meta.model,
     });
     validateProfileLaneModel(lane.provider, profile.meta.model, account.home, profile.id, {
@@ -4891,6 +4918,9 @@ function applyResumeProfileAndEffort(current, next, input) {
         next.worker_profile_hash = profile.contentHash;
         next.worker_profile_ignored = ignoredWorkerProfileFields(current.provider);
         next.worker_policy_delivery = undefined;
+        if (profile.meta.keep_alive !== undefined) {
+            next.keep_alive = profile.meta.keep_alive;
+        }
         if (next.model_source !== "cli") {
             if (profile.meta.provider === current.provider && profile.meta.model !== undefined) {
                 next.model = profile.meta.model;
@@ -4906,6 +4936,8 @@ function applyResumeProfileAndEffort(current, next, input) {
         next.effort = input.effort.effort;
         next.effort_source = input.effort.source;
     }
+    if (input.keepAlive !== undefined)
+        next.keep_alive = input.keepAlive;
 }
 function recordResumeSetup(ctx, lane, input) {
     if (input.cliModel !== undefined) {
@@ -4919,7 +4951,7 @@ function recordResumeSetup(ctx, lane, input) {
         if (account === undefined) {
             throw new AccountResolutionError("unknown_account", `Lane ${lane.lane_id} records account ${JSON.stringify(lane.account)} which is not configured for ${lane.provider}`, { provider: lane.provider, account: lane.account ?? "", enabled: [] });
         }
-        validateLaneModel(lane.provider, model, account.home, {
+        validateLaneModel(lane.provider, model, effectiveAccountHome(account, ctx.hostname()).home, {
             readFileSync: ctx.readFileSync,
             probe: ctx.probeProvider,
             env: ctx.env,
@@ -4927,6 +4959,7 @@ function recordResumeSetup(ctx, lane, input) {
     }
     if (input.profile === undefined &&
         input.effort === undefined &&
+        input.keepAlive === undefined &&
         input.cliModel === undefined &&
         input.meshCompany === undefined)
         return lane;
@@ -4949,6 +4982,23 @@ function recordResumeSetup(ctx, lane, input) {
         return next;
     });
 }
+function hasKeepAliveProgress(lane) {
+    return (lane.keep_alive_resume_count ?? 0) !== 0 ||
+        lane.keep_alive_last_resume_at !== undefined ||
+        lane.keep_alive_next_eligible_at !== undefined ||
+        lane.keep_alive_exhausted_at !== undefined;
+}
+function resetKeepAliveProgress(lane) {
+    if (!hasKeepAliveProgress(lane))
+        return lane;
+    return {
+        ...lane,
+        keep_alive_resume_count: 0,
+        keep_alive_last_resume_at: undefined,
+        keep_alive_next_eligible_at: undefined,
+        keep_alive_exhausted_at: undefined,
+    };
+}
 /** Resolve an explicit resume override or newly attached profile like create does. */
 function resolveResumeEffort(ctx, lane, input) {
     if (input.cliEffort === undefined && input.profile === undefined)
@@ -5039,11 +5089,13 @@ async function prepareAccountMove(ctx, lane, input) {
     if (targetCfg === undefined) {
         throw new AccountResolutionError("unknown_account", `Unknown account ${JSON.stringify(target)} for ${lane.provider}. Configured: ${Object.keys(providerCfg.accounts).join(", ") || "(none)"}`, { provider: lane.provider, account: target, enabled: Object.keys(providerCfg.accounts).filter((id) => providerCfg.accounts[id]?.enabled) });
     }
+    const targetHome = effectiveAccountHome(targetCfg, ctx.hostname()).home;
     if (!targetCfg.enabled) {
         throw new AccountResolutionError("account_disabled", `Account ${JSON.stringify(target)} is disabled${targetCfg.disabled_reason ? `: ${targetCfg.disabled_reason}` : ""}`, { provider: lane.provider, account: target, reason: targetCfg.disabled_reason ?? "" });
     }
     if (accountStatus(lane.provider, target, config, {
         existsSync: ctx.existsSync,
+        hostname: ctx.hostname(),
         probe: ctx.probeProvider,
         env: ctx.env,
     }).logged_in !== true) {
@@ -5060,7 +5112,7 @@ async function prepareAccountMove(ctx, lane, input) {
             : undefined;
     const profileModel = profileDefaultsApply ? profile?.meta.model : undefined;
     if (input.cliModel === undefined && profileDefaultsApply && profileModel !== undefined && pinnedModel === undefined) {
-        validateProfileLaneModel(lane.provider, profileModel, targetCfg.home, profile.id, {
+        validateProfileLaneModel(lane.provider, profileModel, targetHome, profile.id, {
             readFileSync: ctx.readFileSync,
             probe: ctx.probeProvider,
             env: ctx.env,
@@ -5086,7 +5138,7 @@ async function prepareAccountMove(ctx, lane, input) {
         throw new LanesError("account_quota_held", `Account ${target} for ${lane.provider} is held${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""}${block.marker ? ` (${block.marker})` : ""}`, { provider: lane.provider, account: target, quota_reset_at: block.quota_reset_at ?? null, marker: block.marker ?? null, model: model ?? null });
     }
     if (model !== undefined) {
-        validateLaneModel(lane.provider, model, targetCfg.home, {
+        validateLaneModel(lane.provider, model, targetHome, {
             readFileSync: ctx.readFileSync,
             probe: ctx.probeProvider,
             env: ctx.env,
@@ -5096,14 +5148,15 @@ async function prepareAccountMove(ctx, lane, input) {
     if (sourceCfg === undefined) {
         throw new AccountResolutionError("unknown_account", `Lane ${laneId} records account ${JSON.stringify(lane.account)} which is not configured for ${lane.provider}`, { provider: lane.provider, account: lane.account ?? "", enabled: [] });
     }
+    const sourceHome = effectiveAccountHome(sourceCfg, ctx.hostname()).home;
     // Checks done. Copy the session files, then write the record.
     const copy = ensureSessionHome({
         provider: lane.provider,
         sessionId,
         cwd: hqRoot,
-        targetHome: targetCfg.home,
-        registeredHomes: Object.values(providerCfg.accounts).map((account) => account.home),
-        providerHomeAtSpawn: lane.provider_home_at_spawn ?? sourceCfg.home,
+        targetHome,
+        registeredHomes: Object.values(providerCfg.accounts).map((account) => effectiveAccountHome(account, ctx.hostname()).home),
+        providerHomeAtSpawn: lane.provider_home_at_spawn ?? sourceHome,
     });
     const at = now.toISOString();
     const from = lane.account ?? null;
@@ -5186,6 +5239,7 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile) {
         }
         if (accountStatus("claude", lane.account, config, {
             existsSync: ctx.existsSync,
+            hostname: ctx.hostname(),
             probe: ctx.probeProvider,
             env: ctx.env,
         }).logged_in === false) {
@@ -5212,6 +5266,7 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile) {
         ? false
         : accountStatus("claude", lane.account, config, {
             existsSync: ctx.existsSync,
+            hostname: ctx.hostname(),
             probe: ctx.probeProvider,
             env: ctx.env,
         }).logged_in;
@@ -5274,6 +5329,7 @@ function assertCurrentResumeAccountAvailable(ctx, lane) {
     }
     if (accountStatus(lane.provider, lane.account, config, {
         existsSync: ctx.existsSync,
+        hostname: ctx.hostname(),
         probe: ctx.probeProvider,
         env: ctx.env,
     }).logged_in !== true) {
@@ -5538,7 +5594,7 @@ async function runMessage(ctx, laneId, opts) {
     }
     // Every accepted message moves the compaction reference forward.
     let next = casUpdateLane(hqRoot, laneId, (current) => ({
-        ...current,
+        ...resetKeepAliveProgress(current),
         last_message_at: at,
     }));
     if (projectId !== lane.project_id || storyId !== lane.story_id) {
@@ -5876,6 +5932,9 @@ async function runResume(ctx, laneId, opts) {
     const resumeProfile = opts.worker !== undefined
         ? resolveResumeProfile(ctx, lane, opts.worker)
         : undefined;
+    const keepAlive = opts.keepAlive === true
+        ? true
+        : resumeProfile?.profile.meta.keep_alive;
     const keepCurrentAccount = opts.account !== undefined && accountRequestKeepsCurrentLane(lane, opts.account);
     if (keepCurrentAccount)
         assertCurrentResumeAccountAvailable(ctx, lane);
@@ -5933,6 +5992,7 @@ async function runResume(ctx, laneId, opts) {
     lane = recordResumeSetup(ctx, lane, {
         ...(move === null && resumeProfile !== undefined ? { profile: resumeProfile } : {}),
         ...(move === null && resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+        ...(keepAlive !== undefined ? { keepAlive } : {}),
         ...(move === null && keepCurrentAccount && opts.model !== undefined ? { cliModel: opts.model } : {}),
         ...(requestedMeshCompany !== undefined
             ? { meshCompany: requestedMeshCompany, threadId: meshThreadId }
@@ -6028,7 +6088,7 @@ async function runResume(ctx, laneId, opts) {
     if (text !== undefined) {
         // An operator text moves the compaction reference forward, as a message does.
         next = casUpdateLane(hqRoot, laneId, (current) => ({
-            ...current,
+            ...resetKeepAliveProgress(current),
             last_message_at: at,
         }));
     }
@@ -6063,6 +6123,9 @@ async function runResume(ctx, laneId, opts) {
             };
         });
     }
+    if (text === undefined && hasKeepAliveProgress(next)) {
+        next = casUpdateLane(hqRoot, laneId, (current) => resetKeepAliveProgress(current));
+    }
     printJson({
         ok: true,
         action: "resume",
@@ -6419,7 +6482,7 @@ function drainHookStatusFor(ctx, lane) {
     const account = config.providers[lane.provider].accounts[lane.account];
     if (account === undefined)
         return null;
-    const home = canonicalizeHome(account.home, {
+    const home = canonicalizeHome(effectiveAccountHome(account, ctx.hostname()).home, {
         homedir: ctx.homedir,
         realpathSync: (p) => fs.realpathSync(p),
         existsSync: (p) => fs.existsSync(p),
@@ -7671,6 +7734,7 @@ async function runAccountsList(ctx, opts) {
     const quota = loadQuotaState(hqRoot);
     const accounts = providers.flatMap((provider) => listAccountStatuses(provider, config, {
         existsSync: ctx.existsSync,
+        hostname: ctx.hostname(),
         probe: ctx.probeProvider,
         env: ctx.env,
     }).map((status) => {
@@ -7686,6 +7750,7 @@ async function runAccountsList(ctx, opts) {
         });
         return {
             ...status,
+            effective_home: status.home,
             model: accountCfg?.model ?? null,
             effort: accountCfg?.effort ?? null,
             effective_model: model ?? null,
@@ -7849,9 +7914,23 @@ async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
         throw new LanesError("device_auth_unsupported", "--device-auth is supported only for codex account login", { provider });
     }
     const registeredAccount = config.providers[provider].accounts[id];
-    const homeRaw = opts.home?.trim() ||
-        registeredAccount?.home ||
-        (id === "a" ? DEFAULT_ACCOUNT_HOMES[provider] : `~/.${provider}-${id}`);
+    const hostname = ctx.hostname().trim();
+    if (!hostname) {
+        throw new LanesError("host_identity_unknown", "Cannot resolve this host's hostname for account login", {});
+    }
+    const requestedHome = opts.home?.trim();
+    if (opts.home !== undefined && !requestedHome) {
+        throw new LanesError("invalid_account_home", "--home must be a non-empty path", { provider, account: id });
+    }
+    const hostScopedWriterEnabled = registeredAccount !== undefined && requestedHome !== undefined
+        ? await hostScopedAccountHomesEnabled(ctx)
+        : false;
+    const homeRaw = requestedHome ??
+        (registeredAccount !== undefined
+            ? effectiveAccountHome(registeredAccount, hostname).home
+            : id === "a"
+                ? DEFAULT_ACCOUNT_HOMES[provider]
+                : `~/.${provider}-${id}`);
     const homeResolved = homeRaw.startsWith("~") || path.isAbsolute(homeRaw)
         ? homeRaw
         : resolveCallerPath(callerCwd, homeRaw);
@@ -7860,20 +7939,43 @@ async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
         realpathSync: (p) => fs.realpathSync(p),
         existsSync: (p) => fs.existsSync(p),
     });
-    for (const [existingId, account] of Object.entries(config.providers[provider].accounts)) {
-        if (existingId === id)
-            continue;
-        if (account.home === home) {
-            throw new LanesError("duplicate_account_home", `Home ${home} is already registered as ${provider} account ${existingId}`, { provider, accounts: [existingId, id], home });
+    const nextAccount = registeredAccount === undefined
+        ? { home, enabled: true }
+        : { ...registeredAccount, enabled: true };
+    if (registeredAccount !== undefined) {
+        if (hostScopedWriterEnabled && requestedHome !== undefined) {
+            if (home === registeredAccount.home) {
+                if (nextAccount.hosts !== undefined) {
+                    delete nextAccount.hosts[hostname];
+                    if (Object.keys(nextAccount.hosts).length === 0)
+                        delete nextAccount.hosts;
+                }
+            }
+            else {
+                nextAccount.hosts = {
+                    ...(registeredAccount.hosts ?? {}),
+                    [hostname]: { home },
+                };
+            }
+        }
+        else if (requestedHome !== undefined) {
+            // With the rollout off, retain the legacy shared-home write shape.
+            nextAccount.home = home;
         }
     }
+    delete nextAccount.disabled_reason;
+    assertUniqueAccountHomes(provider, {
+        ...config.providers[provider].accounts,
+        [id]: nextAccount,
+    });
     ensureDir(home);
     const defaultId = config.providers[provider].default_account;
-    const defaultHome = (defaultId !== undefined
-        ? config.providers[provider].accounts[defaultId]?.home
+    const defaultAccount = defaultId !== undefined
+        ? config.providers[provider].accounts[defaultId]
+        : Object.values(config.providers[provider].accounts).find((account) => account.enabled);
+    const defaultHome = (defaultAccount !== undefined
+        ? effectiveAccountHome(defaultAccount, hostname).home
         : undefined) ??
-        Object.values(config.providers[provider].accounts).find((account) => account.enabled)
-            ?.home ??
         canonicalizeHome(DEFAULT_ACCOUNT_HOMES[provider], {
             homedir: ctx.homedir,
             realpathSync: (p) => fs.realpathSync(p),
@@ -7899,12 +8001,10 @@ async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
     if ((grokNeedsRails || copied) && !railsPresent(home)) {
         throw new LanesError("rails_missing", `Hook rails are missing under ${home}; account not enabled`, { provider, account: id, home });
     }
-    config.providers[provider].accounts[id] = {
-        home,
-        enabled: true,
-    };
+    config.providers[provider].accounts[id] = nextAccount;
     const status = accountStatus(provider, id, config, {
         existsSync: ctx.existsSync,
+        hostname,
         probe: ctx.probeProvider,
         env: ctx.env,
     });
@@ -7916,6 +8016,93 @@ async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
     writeLanesConfig(hqRoot, config);
     printJson({ ok: true, action: "accounts.login", account: status });
 }
+async function runAccountsSetHome(ctx, providerRaw, accountIdRaw, homeRaw, opts) {
+    if (!(await hostScopedAccountHomesEnabled(ctx))) {
+        throw new LanesError("host_scoped_account_homes_disabled", "Setting a host-specific account home requires the lanes.host-scoped-account-homes flag", { flag: LANE_HOST_SCOPED_ACCOUNT_HOMES_FLAG });
+    }
+    const callerCwd = ctx.callerCwd();
+    const hqRoot = ctx.hqRoot();
+    const provider = parseLaneProvider(providerRaw);
+    const id = accountIdRaw.trim();
+    if (!id) {
+        throw new AccountResolutionError("unknown_account", "account-id must be non-empty", {
+            provider,
+            account: accountIdRaw,
+            enabled: [],
+        });
+    }
+    const hostname = opts.host === undefined ? ctx.hostname().trim() : opts.host.trim();
+    if (!hostname || (opts.host !== undefined && hostname !== opts.host)) {
+        throw new LanesError("invalid_host", "--host must be a non-empty hostname without surrounding whitespace", {
+            host: opts.host ?? "",
+        });
+    }
+    if (!homeRaw.trim()) {
+        throw new LanesError("invalid_account_home", "home path must be a non-empty path", {
+            provider,
+            account: id,
+        });
+    }
+    const config = loadLanesConfig(hqRoot);
+    const account = config.providers[provider].accounts[id];
+    if (account === undefined) {
+        throw new AccountResolutionError("unknown_account", `Unknown account ${JSON.stringify(id)} for ${provider}`, {
+            provider,
+            account: id,
+            enabled: Object.keys(config.providers[provider].accounts).filter((key) => config.providers[provider].accounts[key]?.enabled),
+        });
+    }
+    const homePath = homeRaw.trim();
+    const isCurrentHost = hostname === ctx.hostname().trim();
+    let home;
+    if (isCurrentHost) {
+        const homeResolved = homePath.startsWith("~") || path.isAbsolute(homePath)
+            ? homePath
+            : resolveCallerPath(callerCwd, homePath);
+        home = canonicalizeHome(homeResolved, {
+            homedir: ctx.homedir,
+            realpathSync: (p) => fs.realpathSync(p),
+            existsSync: (p) => fs.existsSync(p),
+        });
+    }
+    else if (homePath === "~" || homePath.startsWith("~/")) {
+        home = homePath;
+    }
+    else if (path.isAbsolute(homePath)) {
+        home = path.normalize(homePath);
+    }
+    else {
+        throw new LanesError("invalid_remote_account_home", "A home for another host must be an absolute path or start with ~/", { provider, account: id, hostname, home: homePath });
+    }
+    for (const [otherId, other] of Object.entries(config.providers[provider].accounts)) {
+        if (otherId !== id && effectiveAccountHome(other, hostname).home === home) {
+            throw new LanesError("duplicate_account_home", `Home ${home} is already registered as ${provider} account ${otherId} on host ${hostname}`, { provider, accounts: [otherId, id], home, hostname });
+        }
+    }
+    if (home === account.home) {
+        if (account.hosts !== undefined) {
+            delete account.hosts[hostname];
+            if (Object.keys(account.hosts).length === 0)
+                delete account.hosts;
+        }
+    }
+    else {
+        const hosts = Object.assign(Object.create(null), account.hosts ?? {});
+        hosts[hostname] = { home };
+        account.hosts = hosts;
+    }
+    assertUniqueAccountHomes(provider, config.providers[provider].accounts);
+    writeLanesConfig(hqRoot, config);
+    printJson({
+        ok: true,
+        action: "accounts.set-home",
+        provider,
+        account: id,
+        hostname,
+        home,
+        home_source: home === account.home ? "default" : "host",
+    });
+}
 async function runAccountsEnable(ctx, providerRaw, accountId) {
     const hqRoot = ctx.hqRoot();
     const provider = parseLaneProvider(providerRaw);
@@ -7932,6 +8119,7 @@ async function runAccountsEnable(ctx, providerRaw, accountId) {
     }
     const status = accountStatus(provider, accountId, config, {
         existsSync: ctx.existsSync,
+        hostname: ctx.hostname(),
         probe: ctx.probeProvider,
         env: ctx.env,
     });
@@ -7948,6 +8136,7 @@ async function runAccountsEnable(ctx, providerRaw, accountId) {
         action: "accounts.enable",
         account: accountStatus(provider, accountId, loadLanesConfig(hqRoot), {
             existsSync: ctx.existsSync,
+            hostname: ctx.hostname(),
             probe: ctx.probeProvider,
             env: ctx.env,
         }),
@@ -7976,6 +8165,7 @@ async function runAccountsDisable(ctx, providerRaw, accountId, opts) {
         action: "accounts.disable",
         account: accountStatus(provider, accountId, loadLanesConfig(hqRoot), {
             existsSync: ctx.existsSync,
+            hostname: ctx.hostname(),
             probe: ctx.probeProvider,
             env: ctx.env,
         }),
@@ -8145,6 +8335,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--effort <level>", "Effort level; claude: low|medium|high|xhigh|max, codex: minimal|low|medium|high|xhigh|max|ultra, grok: low|medium|high|xhigh")
         .option("--senior <ref>", "session:<id> | lane:<id> | user")
         .option("--hire-grant <n>", "Maximum alive direct child lanes assigned to this lane; set by its senior")
+        .option("--keep-alive", "Automatically resume done lead lanes while their story remains open")
         .option("--timeout <secs>", "Deadline in seconds (warns, does not kill)")
         .option("--priority <n>", "Queue priority; higher runs first", "1")
         .option("--outpost <id>", "Run on this Outpost instead of the local host")
@@ -8382,6 +8573,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .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("--keep-alive", "Automatically resume done lead lanes while their story remains open")
         .option("--mesh-company <slug>", "Attach Work Mesh attribution after verifying company membership")
         .option("--no-compact", "Skip the resume-time compaction check for this resume")
         .action(wrap(async (laneId, opts) => {
@@ -8490,6 +8682,17 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (opts) => {
         await runAccountsBalance(ctx, opts);
     }));
+    accounts
+        .command("set-home")
+        .description("Set the host-specific home for an existing provider account")
+        .argument("<provider>", "claude | codex | grok")
+        .argument("<account-id>", "Existing account id")
+        .argument("<path>", "Home directory for this host")
+        .option("--host <hostname>", "Host key (defaults to this host's hostname)")
+        .option("--json", "JSON on stdout (always)")
+        .action(wrap(async (provider, accountId, home, opts) => {
+        await runAccountsSetHome(ctx, provider, accountId, home, opts);
+    }));
     accounts
         .command("login")
         .description("Create a home, run the vendor login, and register the account")