@indigoai-us/hq-cli 5.202.1 → 5.204.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,13 +33,16 @@ 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, 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, 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";
+import { formatMonitorEvent } from "../lib/lanes/dropbox.js";
 import { accountQuotaView, loadQuotaState, quotaBlockFor } from "../lib/lanes/quota.js";
 import { SESSION_MOVE_REASON } from "../lib/lanes/move-account.js";
 import { ensureSessionHome } from "../lib/lanes/session-relink.js";
@@ -57,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);
 }
@@ -80,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);
@@ -235,6 +249,7 @@ function resolveDeps(deps = {}) {
         throttleDeps: deps.throttleDeps ?? defaultThrottleDeps(env),
         existsSync: deps.existsSync ?? ((p) => fs.existsSync(p)),
         readFileSync: deps.readFileSync ?? ((p, encoding) => fs.readFileSync(p, encoding)),
+        readStdin: deps.readStdin ?? (() => fs.readFileSync(0, "utf8")),
         homedir: deps.homedir ?? (() => os.homedir()),
         mesh: deps.mesh ?? createDefaultMesh(),
         sleep: deps.sleep ?? defaultSleep,
@@ -283,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,
     };
 }
@@ -295,6 +312,7 @@ function livenessDepsFromCtx(ctx) {
         env: ctx.env,
         existsSync: ctx.existsSync,
         readFileSync: ctx.readFileSync,
+        hostname: ctx.hostname,
     };
 }
 function reconcileHostFromCtx(ctx) {
@@ -1001,6 +1019,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) => {
@@ -1115,6 +1134,7 @@ async function loadClaudeBalanceHostSnapshots(ctx, hqRoot, config) {
         existsSync: ctx.existsSync,
         probe: ctx.probeProvider,
         env: ctx.env,
+        hostname: ctx.hostname(),
         now: ctx.now(),
     });
     const snapshots = [{
@@ -1137,6 +1157,7 @@ async function loadClaudeBalanceHostSnapshots(ctx, hqRoot, config) {
                     existsSync: ctx.existsSync,
                     probe: ctx.probeProvider,
                     env: ctx.env,
+                    hostname: ctx.hostname(),
                     now: ctx.now(),
                 }),
                 lanes: actualLocalLanes,
@@ -2193,6 +2214,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,
@@ -2200,6 +2222,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,
         });
@@ -2586,6 +2609,7 @@ async function runCreate(ctx, opts) {
         }
         const resolved = resolveAccount(provider, requested, config, {
             hqRoot,
+            hostname: ctx.hostname(),
             cliModel,
             model: cliModel ?? profileModel,
         });
@@ -2594,6 +2618,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,
         });
@@ -2647,6 +2672,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,
@@ -2666,6 +2692,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)
@@ -2676,7 +2703,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);
@@ -2779,6 +2809,7 @@ async function runCreate(ctx, opts) {
                         existsSync: ctx.existsSync,
                         probe: ctx.probeProvider,
                         env: ctx.env,
+                        hostname: ctx.hostname(),
                         now: ctx.now(),
                     }),
                     lanes: localLanes,
@@ -2802,6 +2833,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,
@@ -4026,6 +4058,7 @@ async function runCapacity(ctx) {
         existsSync: ctx.existsSync,
         probe: ctx.probeProvider,
         env: ctx.env,
+        hostname: ctx.hostname(),
         now: ctx.now(),
     });
     printJson(snapshot);
@@ -4870,6 +4903,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, {
@@ -4916,7 +4950,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,
@@ -5021,11 +5055,10 @@ async function prepareAccountMove(ctx, lane, input) {
             account: target,
         });
     }
-    if (!providerSupportsSessionResume(lane.provider)) {
-        throw new LanesError("provider_session_not_portable", `Provider ${lane.provider} has no session resume, so a lane cannot move between its accounts`, { lane_id: laneId, provider: lane.provider });
-    }
-    if (lane.provider === "grok") {
-        throw new LanesError("provider_session_not_portable", `Provider ${lane.provider} has no session resume, so a lane cannot move between its accounts`, { lane_id: laneId, provider: lane.provider });
+    // The grok comparison repeats PROVIDER_SESSION_PORTABLE so TypeScript narrows
+    // the provider for ensureSessionHome below.
+    if (!providerSessionPortable(lane.provider) || lane.provider === "grok") {
+        throw new LanesError("provider_session_not_portable", sessionNotPortableMessage(lane.provider), { lane_id: laneId, provider: lane.provider });
     }
     if (!hasRecordedSessionId(lane)) {
         throw new LanesError("no_provider_session", `Lane ${laneId} has no recorded provider session id, so there is no session to move`, { lane_id: laneId, provider: lane.provider });
@@ -5037,11 +5070,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) {
@@ -5058,7 +5093,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,
@@ -5084,7 +5119,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,
@@ -5094,14 +5129,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;
@@ -5184,6 +5220,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) {
@@ -5210,6 +5247,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;
@@ -5272,6 +5310,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) {
@@ -5310,8 +5349,8 @@ async function runMessage(ctx, laneId, opts) {
             state: lane.state,
         });
     }
-    if (opts.account !== undefined && !keepCurrentAccount && !providerSupportsSessionResume(lane.provider)) {
-        throw new LanesError("provider_session_not_portable", `Provider ${lane.provider} has no session resume, so a lane cannot move between its accounts`, { lane_id: laneId, provider: lane.provider });
+    if (opts.account !== undefined && !keepCurrentAccount && !providerSessionPortable(lane.provider)) {
+        throw new LanesError("provider_session_not_portable", sessionNotPortableMessage(lane.provider), { lane_id: laneId, provider: lane.provider });
     }
     // One decision point for how a follow-up reaches this lane (delivery.ts).
     // `none` refuses before anything is written: no inbox append, no spawn.
@@ -5359,12 +5398,27 @@ async function runMessage(ctx, laneId, opts) {
     if ((opts.project !== undefined || opts.story !== undefined) && ctx.storyLedgerEnabled()) {
         validateProjectStories(hqRoot, projectId, [storyId], lane.company?.slug);
     }
+    const framedMonitorEvent = opts.monitorEvent === undefined
+        ? undefined
+        : formatMonitorEvent({
+            monitorId: opts.monitorEvent.monitor_id,
+            description: opts.monitorEvent.description,
+            sequence: opts.monitorEvent.sequence,
+            text,
+        });
+    const deliveryText = framedMonitorEvent ?? text;
     const dropboxMessage = {
         at,
         message_id: messageId,
         text,
         project_id: projectId,
         story_id: storyId,
+        ...(opts.monitorEvent === undefined ? {} : {
+            kind: "monitor_event",
+            monitor_id: opts.monitorEvent.monitor_id,
+            description: opts.monitorEvent.description,
+            sequence: opts.monitorEvent.sequence,
+        }),
     };
     let resumed = null;
     let move = null;
@@ -5377,7 +5431,13 @@ async function runMessage(ctx, laneId, opts) {
             cliModel: opts.model?.trim() || undefined,
             ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
             ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
-            pending: { trigger: "message", text, message_id: messageId, compact: opts.compact !== false },
+            pending: {
+                trigger: "message",
+                text: deliveryText,
+                ...(opts.monitorEvent === undefined ? {} : { monitor_event: true }),
+                message_id: messageId,
+                compact: opts.compact !== false,
+            },
         });
         lane = move.lane;
         if (move.queued) {
@@ -5395,7 +5455,8 @@ async function runMessage(ctx, laneId, opts) {
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     pending: {
                         trigger: "message",
-                        text,
+                        text: deliveryText,
+                        ...(opts.monitorEvent === undefined ? {} : { monitor_event: true }),
                         message_id: messageId,
                         compact: opts.compact !== false,
                     },
@@ -5423,81 +5484,94 @@ async function runMessage(ctx, laneId, opts) {
     if (move?.queued) {
         // Parked at the target's cap: reconcile resumes the session there.
     }
-    else if (mechanism === "dropbox") {
-        // Live (or about-to-be-live) process: the PreToolUse drain delivers it.
-        if (!laneAcceptsOperatorMessage(lane)) {
-            throw new LanesError("lane_not_accepting_messages", operatorMessageRefusalReason(lane.state), { lane_id: laneId, state: lane.state });
-        }
-        appendDropboxMessage(hqRoot, laneId, dropboxMessage);
-    }
     else {
-        // Exited worker with a recorded session: queue the message when capacity
-        // is occupied, otherwise start its next turn under the shared admission lock.
-        assertLaneRunsHereForAdmission(ctx, lane);
-        resumed = await withLaneAdmissionLock(hqRoot, lane.provider, async () => {
-            const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
-            if (admission.action === "refuse" && admission.error)
-                throw admission.error;
-            return withResumeHireAdmission(ctx, lane, () => {
-                if (admission.action === "queue") {
-                    const sessionId = lane.provider_session_id;
-                    if (!sessionId) {
-                        throw new LanesError("no_provider_session", `Lane ${laneId} has no provider session id to queue this message resume`, {
-                            lane_id: laneId,
-                            provider: lane.provider,
-                        });
-                    }
-                    archiveResumeMessage(hqRoot, laneId, dropboxMessage);
-                    queuedOnAdmission = true;
-                    return casUpdateLane(hqRoot, laneId, (current) => {
-                        if (current.version !== lane.version || current.state !== lane.state) {
-                            throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while message admission was checked`, {
-                                lane_id: laneId,
-                                prepared_version: lane.version,
-                                version: current.version,
-                                state: current.state,
+        const dispatched = await dispatchLaneDelivery(lane, {
+            dropbox: () => {
+                // Live (or about-to-be-live) process: the PreToolUse drain delivers it.
+                if (!laneAcceptsOperatorMessage(lane)) {
+                    throw new LanesError("lane_not_accepting_messages", operatorMessageRefusalReason(lane.state), { lane_id: laneId, state: lane.state });
+                }
+                appendDropboxMessage(hqRoot, laneId, dropboxMessage);
+                return null;
+            },
+            resume: async () => {
+                // Exited worker with a recorded session: queue the message when capacity
+                // is occupied, otherwise start its next turn under the shared admission lock.
+                assertLaneRunsHereForAdmission(ctx, lane);
+                return withLaneAdmissionLock(hqRoot, lane.provider, async () => {
+                    const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
+                    if (admission.action === "refuse" && admission.error)
+                        throw admission.error;
+                    return withResumeHireAdmission(ctx, lane, () => {
+                        if (admission.action === "queue") {
+                            const sessionId = lane.provider_session_id;
+                            if (!sessionId) {
+                                throw new LanesError("no_provider_session", `Lane ${laneId} has no provider session id to queue this message resume`, {
+                                    lane_id: laneId,
+                                    provider: lane.provider,
+                                });
+                            }
+                            archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+                            queuedOnAdmission = true;
+                            return casUpdateLane(hqRoot, laneId, (current) => {
+                                if (current.version !== lane.version || current.state !== lane.state) {
+                                    throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while message admission was checked`, {
+                                        lane_id: laneId,
+                                        prepared_version: lane.version,
+                                        version: current.version,
+                                        state: current.state,
+                                    });
+                                }
+                                return {
+                                    ...current,
+                                    state: "queued",
+                                    queued_reason: admission.reason ?? "throttle",
+                                    queued_at: at,
+                                    pending_resume: {
+                                        session_id: sessionId,
+                                        trigger: "message",
+                                        text: deliveryText,
+                                        ...(opts.monitorEvent === undefined ? {} : { monitor_event: true }),
+                                        message_id: messageId,
+                                        compact: opts.compact !== false,
+                                        at,
+                                    },
+                                };
                             });
                         }
-                        return {
-                            ...current,
-                            state: "queued",
-                            queued_reason: admission.reason ?? "throttle",
-                            queued_at: at,
-                            pending_resume: {
-                                session_id: sessionId,
-                                trigger: "message",
-                                text,
+                        const started = spawnLaneWorker(hqRoot, lane, {
+                            env: ctx.env,
+                            modelDeps: {
+                                readFileSync: ctx.readFileSync,
+                                probe: ctx.probeProvider,
+                                env: ctx.env,
+                            },
+                            existsSync: ctx.existsSync,
+                            spawnProcess: ctx.spawnProcess,
+                            proveDetached: ctx.proveDetached,
+                            killProcess: ctx.killProcess,
+                            now: ctx.now,
+                            resolveMachineIdentity: ctx.resolveMachineIdentity,
+                            runCompaction: ctx.runCompaction,
+                            locateTranscript: ctx.locateTranscript,
+                        }, {
+                            trigger: {
+                                kind: "message",
+                                text: deliveryText,
                                 message_id: messageId,
-                                compact: opts.compact !== false,
-                                at,
+                                ...(opts.monitorEvent === undefined ? {} : { monitor_event: true }),
                             },
-                        };
+                            compact: opts.compact !== false,
+                            effort: resumeEffort ?? recordedResumeEffort(lane),
+                        });
+                        archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+                        return started;
                     });
-                }
-                const started = spawnLaneWorker(hqRoot, lane, {
-                    env: ctx.env,
-                    modelDeps: {
-                        readFileSync: ctx.readFileSync,
-                        probe: ctx.probeProvider,
-                        env: ctx.env,
-                    },
-                    existsSync: ctx.existsSync,
-                    spawnProcess: ctx.spawnProcess,
-                    proveDetached: ctx.proveDetached,
-                    killProcess: ctx.killProcess,
-                    now: ctx.now,
-                    resolveMachineIdentity: ctx.resolveMachineIdentity,
-                    runCompaction: ctx.runCompaction,
-                    locateTranscript: ctx.locateTranscript,
-                }, {
-                    trigger: { kind: "message", text, message_id: messageId },
-                    compact: opts.compact !== false,
-                    effort: resumeEffort ?? recordedResumeEffort(lane),
-                });
-                archiveResumeMessage(hqRoot, laneId, dropboxMessage);
-                return started;
-            });
-        }, ctx.sleep);
+                }, ctx.sleep);
+            },
+        }, mechanism);
+        if (dispatched.mechanism === "resume")
+            resumed = dispatched.value;
     }
     // Every accepted message moves the compaction reference forward.
     let next = casUpdateLane(hqRoot, laneId, (current) => ({
@@ -5736,8 +5810,6 @@ async function runClaudeBalanceMoveTarget(ctx, laneId, opts) {
     });
 }
 function laneWithRecoveredProviderSession(hqRoot, lane) {
-    if (lane.provider === "grok")
-        return lane;
     const manifest = readSpawnManifest(laneRunDir(hqRoot, lane.lane_id));
     const sessionId = (typeof lane.provider_session_id === "string" && lane.provider_session_id.trim()
         ? lane.provider_session_id
@@ -5795,8 +5867,8 @@ async function runResume(ctx, laneId, opts) {
             state: lane.state,
         });
     }
-    if (opts.account !== undefined && !providerSupportsSessionResume(lane.provider)) {
-        throw new LanesError("provider_session_not_portable", `Provider ${lane.provider} has no session resume, so a lane cannot move between its accounts`, { lane_id: laneId, provider: lane.provider });
+    if (opts.account !== undefined && !providerSessionPortable(lane.provider)) {
+        throw new LanesError("provider_session_not_portable", sessionNotPortableMessage(lane.provider), { lane_id: laneId, provider: lane.provider });
     }
     if (lane.state === "queued") {
         throw new LanesError("lane_not_resumable", `Lane ${laneId} is queued; use hq lanes admit ${laneId} to request admission`, { lane_id: laneId, state: lane.state, admission_command: `hq lanes admit ${laneId}` });
@@ -6384,7 +6456,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),
@@ -7636,6 +7708,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) => {
@@ -7651,6 +7724,7 @@ async function runAccountsList(ctx, opts) {
         });
         return {
             ...status,
+            effective_home: status.home,
             model: accountCfg?.model ?? null,
             effort: accountCfg?.effort ?? null,
             effective_model: model ?? null,
@@ -7814,9 +7888,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);
@@ -7825,20 +7913,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),
@@ -7864,12 +7975,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,
     });
@@ -7881,6 +7990,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);
@@ -7897,6 +8093,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,
     });
@@ -7913,6 +8110,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,
         }),
@@ -7941,6 +8139,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,
         }),
@@ -8304,6 +8503,38 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (laneId, opts) => {
         await runMessage(ctx, laneId, opts);
     }));
+    lanes
+        .command("_monitor-message", { hidden: true })
+        .argument("<lane-id>", "Lane id")
+        .action(wrap(async (laneId) => {
+        const input = ctx.readStdin();
+        let payload;
+        try {
+            payload = JSON.parse(input);
+        }
+        catch (err) {
+            throw new LanesError("monitor_lane_payload_invalid", `Monitor lane delivery payload is invalid JSON: ${err instanceof Error ? err.message : String(err)}.`, {});
+        }
+        if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+            throw new LanesError("monitor_lane_payload_invalid", "Monitor lane delivery payload must be an object.", {});
+        }
+        const value = payload;
+        if (typeof value.text !== "string" ||
+            typeof value.monitor_id !== "string" ||
+            typeof value.description !== "string" ||
+            !Number.isInteger(value.sequence) ||
+            Number(value.sequence) < 1) {
+            throw new LanesError("monitor_lane_payload_invalid", "Monitor lane delivery payload is missing text, monitor metadata, or sequence.", {});
+        }
+        await runMessage(ctx, laneId, {
+            text: value.text,
+            monitorEvent: {
+                monitor_id: value.monitor_id,
+                description: value.description,
+                sequence: Number(value.sequence),
+            },
+        });
+    }));
     lanes
         .command("resume")
         .description("Resume an interrupted, done or blocked lane on its recorded provider session")
@@ -8423,6 +8654,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")