@indigoai-us/hq-cli 5.247.1 → 5.249.0

package/dist/commands/lanes.js

@@ -12,7 +12,9 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { Option } from "commander";
 import { createLaneAccountsHandlers } from "./lanes-accounts.js";
+import { createLaneMessageHandlers } from "./lanes-message.js";
 import { createLaneQuestionsHandlers } from "./lanes-questions.js";
+import { createLaneResumeHandlers } from "./lanes-resume.js";
 export { resolveAnswerChoice } from "./lanes-questions.js";
 import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
 import { registerLaneChecksCommand } from "./lanes-checks.js";
@@ -43,7 +45,7 @@ import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
-import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, LANE_PROVIDERS, LANE_STATES, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, 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, parseQuestionRecord, parseSeniorKind, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, appendDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, withLaneHireLocks, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, LANE_PROVIDERS, LANE_STATES, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, 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, parseQuestionRecord, parseSeniorKind, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, dropboxDir, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
 import { keepAliveExclusion, LEAD_LANE_KEEP_ALIVE_FLAG, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
@@ -53,14 +55,11 @@ import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { parseCliEffort, resolveLaneEffort, } from "../lib/lanes/effort.js";
 import { LanesError } from "../lib/lanes/errors.js";
 import { LANE_WAIT_INVALID_INPUT_EXIT_CODE, LANE_WAIT_TIMEOUT_EXIT_CODE, runLaneWait, } from "../lib/lanes/wait.js";
-import { dispatchLaneDelivery } from "../lib/lanes/delivery-core.js";
-import { dropboxInboxHasMessages, drainDropbox, formatDropboxMessages, formatMonitorEvent, requeueDropboxMessages, } from "../lib/lanes/dropbox.js";
-import { isPidAlive, runWatcherLoop, WATCHER_OUT_MAX_BYTES, watcherOutLogPath, writeWatcherDecision, } from "../lib/lanes/watcher.js";
 import { 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";
 import { defaultProbe, validateProfileLaneModel, validateLaneModel, } from "../lib/lanes/models.js";
-import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, spawnLaneWorker, laneRunDir, readSpawnManifest, readPidRecord, probePidRecord, readProcStarttime, stopLaneProcesses, } from "../lib/lanes/spawn.js";
+import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, spawnLaneWorker, laneRunDir, readSpawnManifest, stopLaneProcesses, } from "../lib/lanes/spawn.js";
 import { handOffInstallHere } from "../lib/daemon/handoff.js";
 export { spawnLaneWorker };
 export { questionBodyAbsPath };
@@ -5389,57 +5388,6 @@ 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)
-        return undefined;
-    const config = loadLanesConfig(ctx.hqRoot());
-    const providerConfig = config.providers[lane.provider];
-    const accountId = input.account?.trim() || lane.account;
-    const accountConfig = accountId === undefined
-        ? undefined
-        : providerConfig.accounts[accountId];
-    const profileDefaultsApply = input.profile?.profile.meta.provider === lane.provider;
-    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
-        ? lane.model
-        : undefined;
-    const model = resolveLaneModel({
-        cliModel: input.model?.trim() || pinnedModel,
-        profileModel: profileDefaultsApply ? input.profile?.profile.meta.model : undefined,
-        accountModel: accountConfig?.model,
-        providerModel: providerConfig.model,
-    });
-    return resolveLaneEffort({
-        cliEffort: input.cliEffort,
-        profileEffort: profileDefaultsApply ? input.profile?.profile.meta.effort : undefined,
-        accountEffort: accountConfig?.effort,
-        providerEffort: providerConfig.effort,
-        model,
-    });
-}
-function recordedResumeEffort(lane) {
-    return {
-        ...(lane.effort !== undefined ? { effort: lane.effort } : {}),
-        source: lane.effort_source ?? "none",
-    };
-}
 /**
  * US-023: move the lane's provider session to `--account` (same provider)
  * before a resume or a message resume. Every check runs before anything is
@@ -5728,585 +5676,6 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
         ...(preservedModel !== undefined ? { preservedModel } : {}),
     };
 }
-function accountRequestKeepsCurrentLane(lane, rawAccount) {
-    const raw = rawAccount.trim();
-    const colon = raw.indexOf(":");
-    const requestedProvider = colon > 0 ? raw.slice(0, colon) : undefined;
-    const requestedAccount = colon > 0 ? raw.slice(colon + 1) : raw;
-    return requestedAccount.length > 0 &&
-        requestedAccount === lane.account &&
-        (requestedProvider === undefined || requestedProvider === lane.provider);
-}
-function assertCurrentResumeAccountAvailable(ctx, lane) {
-    const config = loadLanesConfig(ctx.hqRoot());
-    const account = lane.account === undefined
-        ? undefined
-        : config.providers[lane.provider].accounts[lane.account];
-    if (account === undefined || !account.enabled) {
-        throw new AccountResolutionError(account === undefined ? "unknown_account" : "account_disabled", account === undefined
-            ? `Lane ${lane.lane_id} records account ${JSON.stringify(lane.account)} which is not configured for ${lane.provider}`
-            : `Account ${JSON.stringify(lane.account)} is disabled${account.disabled_reason ? `: ${account.disabled_reason}` : ""}`, { provider: lane.provider, account: lane.account ?? "", ...(account?.disabled_reason !== undefined ? { reason: account.disabled_reason } : {}) });
-    }
-    if (accountStatus(lane.provider, lane.account, config, {
-        existsSync: ctx.existsSync,
-        hostname: ctx.hostname(),
-        probe: ctx.probeProvider,
-        env: ctx.env,
-    }).logged_in !== true) {
-        throw new LanesError("account_not_logged_in", `Account ${lane.account} for ${lane.provider} is not logged in (no credential file)`, { provider: lane.provider, account: lane.account, lane_id: lane.lane_id });
-    }
-}
-async function runMessage(ctx, laneId, opts) {
-    const hqRoot = ctx.hqRoot();
-    const hireGrantContext = opts.grantContext === undefined
-        ? undefined
-        : (() => {
-            if (!ctx.isSsmOwnerDispatch()) {
-                throw new LanesError("hire_grant_dispatch_unauthorized", "Message grant context is only valid on an Outpost owner dispatch", { lane_id: laneId });
-            }
-            return parseOutpostHireGrantContext(opts.grantContext, laneId);
-        })();
-    let accepted = false;
-    let claimedMessages = [];
-    const markAccepted = () => {
-        accepted = true;
-        opts.onAccepted?.();
-    };
-    let text = opts.text;
-    if (!text) {
-        throw new LanesError("missing_text", "--text is required", {});
-    }
-    let lane = readLane(hqRoot, laneId);
-    if (lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane)) {
-        await dispatchOutpostLaneCommand(ctx, lane, "message", opts);
-        return;
-    }
-    assertLaneRunsHereForOperatorMutation(ctx, lane, "message");
-    if (lane.state === "running") {
-        const workerPidPath = path.join(laneRunDir(hqRoot, laneId), "worker.pid");
-        const workerRecordExists = fs.existsSync(workerPidPath);
-        const worker = readPidRecord(workerPidPath);
-        if (workerRecordExists && worker === null) {
-            throw new LanesError("worker_pid_invalid", `Lane ${laneId} has a malformed worker PID record; message delivery cannot be classified safely`, { lane_id: laneId, worker_pid_path: workerPidPath });
-        }
-        // A fresh spawn may have committed running before publishing worker.pid;
-        // absence is not proof of exit. Reclassify only a recorded process that
-        // fails the PID plus start-time identity probe.
-        const processAlive = worker === null
-            ? true
-            : probePidRecord(worker, ctx.isAlive ?? isPidAlive, ctx.readStarttime ?? readProcStarttime).alive;
-        if (worker !== null && !processAlive) {
-            // The watcher may not have reached its next poll yet. Run the same
-            // classifier synchronously, then make the queue/resume choice again.
-            await runWatcherLoop(hqRoot, laneId, {
-                ...ctx.watcherLoopDeps,
-                now: () => ctx.now().getTime(),
-                isAlive: ctx.isAlive ?? isPidAlive,
-                readStarttime: ctx.readStarttime ?? readProcStarttime,
-                mesh: null,
-                resolveQuestionActiveCompany: () => resolveActiveQuestionCompany(ctx),
-            });
-            lane = readLane(hqRoot, laneId);
-            // This invocation won the race to classify the dead worker, so the
-            // watcher callback did not own recovery. Fold any earlier queued
-            // messages into this resume to keep one provider turn and one delivery.
-            if (laneDeliveryMechanism(lane) === "resume" && dropboxInboxHasMessages(hqRoot, laneId)) {
-                const queuedMessages = drainDropbox(hqRoot, laneId);
-                if (queuedMessages.length > 0) {
-                    claimedMessages = queuedMessages;
-                    text = `${formatDropboxMessages(queuedMessages)}\n\n${text}`;
-                }
-            }
-        }
-    }
-    try {
-        const eligibility = await messageLaneExclusion(ctx, lane);
-        lane = eligibility.lane;
-        const exclusion = eligibility.exclusion;
-        if (exclusion !== undefined) {
-            let messageCount;
-            if (dropboxInboxHasMessages(hqRoot, laneId)) {
-                messageCount = drainDropbox(hqRoot, laneId, { archiveDirectory: "undeliverable" }).length;
-            }
-            recordMessageUndeliverable(ctx, lane, exclusion, messageCount);
-            const refusalMessage = deliveryRefusalReason(lane);
-            throw new LanesError("lane_not_accepting_messages", refusalMessage || `Lane ${laneId} cannot receive messages: ${exclusion}`, { lane_id: laneId, state: lane.state, reason: exclusion });
-        }
-        if (lane.state === "done" && dropboxInboxHasMessages(hqRoot, laneId)) {
-            const staleMessages = drainDropbox(hqRoot, laneId, { archiveDirectory: "undeliverable" });
-            if (staleMessages.length > 0) {
-                recordMessageUndeliverable(ctx, lane, "done_before_queued_message", staleMessages.length);
-            }
-        }
-        const cliEffort = parseCliEffort(lane.provider, opts.effort);
-        if (cliEffort !== undefined && !providerSupportsSessionResume(lane.provider)) {
-            throw new LanesError("effort_resume_unsupported", `Provider ${lane.provider} cannot change effort on a resumed session`, { lane_id: laneId, provider: lane.provider });
-        }
-        // Check before transcript recovery, account probing, or message writes.
-        // The final state transition repeats this check under the senior lock.
-        await withResumeHireAdmission(ctx, lane, () => undefined, hireGrantContext);
-        lane = laneWithRecoveredProviderSession(hqRoot, lane);
-        const keepCurrentAccount = opts.account !== undefined && accountRequestKeepsCurrentLane(lane, opts.account);
-        if (keepCurrentAccount)
-            assertCurrentResumeAccountAvailable(ctx, lane);
-        // A real account move is refused on its own terms first: a running lane and
-        // a provider without session resume get the move's named errors, not the
-        // generic delivery refusal below. Naming the current account is a keep.
-        if (opts.account !== undefined && !keepCurrentAccount && lane.state === "running") {
-            throw new LanesError("lane_running", `Lane ${laneId} is running; stop it or wait for it to exit before moving its session`, {
-                lane_id: laneId,
-                state: lane.state,
-            });
-        }
-        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.
-        const mechanism = laneDeliveryMechanism(lane);
-        if (mechanism === "none") {
-            const message = deliveryRefusalReason(lane);
-            throw new LanesError("lane_not_accepting_messages", message, {
-                lane_id: laneId,
-                state: lane.state,
-                provider: lane.provider,
-                message,
-            });
-        }
-        if (keepCurrentAccount && opts.model !== undefined && mechanism !== "resume") {
-            throw new LanesError("model_requires_resume", "--model with --account requires a message that resumes the lane", { lane_id: laneId, state: lane.state });
-        }
-        if (opts.worker !== undefined && mechanism === "dropbox") {
-            throw new LanesError("worker_profile_requires_resume", `Lane ${laneId} is still running; --worker can only be applied when message starts a resumed provider turn`, { lane_id: laneId, state: lane.state });
-        }
-        if (cliEffort !== undefined && mechanism === "dropbox") {
-            throw new LanesError("lane_effort_requires_resume", `Lane ${laneId} is still running; --effort can only be applied when message starts a resumed provider turn`, { lane_id: laneId, state: lane.state });
-        }
-        const resumeProfile = opts.worker !== undefined
-            ? resolveResumeProfile(ctx, lane, opts.worker)
-            : undefined;
-        if (opts.model !== undefined && opts.account === undefined) {
-            throw new LanesError("model_requires_account", "--model on hq lanes message is only accepted together with --account", {});
-        }
-        const automaticAccountSelection = opts.account === undefined && mechanism === "resume"
-            ? await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile)
-            : undefined;
-        const resumeEffort = resolveResumeEffort(ctx, lane, {
-            cliEffort,
-            profile: resumeProfile,
-            account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.selection.account,
-            model: opts.model,
-        });
-        const messageId = mintMessageId();
-        const at = ctx.now().toISOString();
-        const projectId = opts.project?.trim() || lane.project_id;
-        const storyId = opts.story?.trim() || lane.story_id;
-        if (opts.story !== undefined && !opts.story.trim()) {
-            throw new LanesError("missing_story", "--story must be non-empty", {});
-        }
-        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;
-        let queuedOnAdmission = false;
-        if (opts.account !== undefined && !keepCurrentAccount) {
-            // A moved message is always a resume on the target account: a running
-            // lane (the dropbox mechanism) is refused inside prepareAccountMove.
-            move = await prepareAccountMove(ctx, lane, {
-                account: opts.account,
-                cliModel: opts.model?.trim() || undefined,
-                ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
-                ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
-                ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
-                pending: {
-                    trigger: "message",
-                    text: deliveryText,
-                    ...(opts.monitorEvent === undefined ? {} : { monitor_event: true }),
-                    message_id: messageId,
-                    compact: opts.compact !== false,
-                },
-            });
-            lane = move.lane;
-            if (move.queued) {
-                archiveResumeMessage(hqRoot, laneId, dropboxMessage);
-            }
-        }
-        else if (mechanism === "resume") {
-            const automatic = automaticAccountSelection;
-            if (automatic !== undefined) {
-                const selection = automatic.selection;
-                if (selection.account !== lane.account) {
-                    move = await prepareAccountMove(ctx, lane, {
-                        account: selection.account,
-                        cliModel: undefined,
-                        ...(automatic.historyReason !== undefined ? { accountHistoryReason: automatic.historyReason } : {}),
-                        ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
-                        ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
-                        ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
-                        pending: {
-                            trigger: "message",
-                            text: deliveryText,
-                            ...(opts.monitorEvent === undefined ? {} : { monitor_event: true }),
-                            message_id: messageId,
-                            compact: opts.compact !== false,
-                        },
-                        accountSelection: selection,
-                    });
-                    lane = move.lane;
-                    if (move.queued)
-                        archiveResumeMessage(hqRoot, laneId, dropboxMessage);
-                }
-                else {
-                    lane = persistClaudeAccountSelection(hqRoot, lane, selection);
-                }
-            }
-        }
-        if (resumeProfile !== undefined && (opts.account === undefined || keepCurrentAccount)) {
-            validateResumeProfileModel(ctx, lane, resumeProfile.profile);
-        }
-        if (move === null && (resumeProfile !== undefined || resumeEffort !== undefined || (keepCurrentAccount && opts.model !== undefined))) {
-            lane = recordResumeSetup(ctx, lane, {
-                ...(resumeProfile !== undefined ? { profile: resumeProfile } : {}),
-                ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
-                ...(keepCurrentAccount && opts.model !== undefined ? { cliModel: opts.model } : {}),
-            });
-        }
-        if (move?.queued) {
-            // Parked at the target's cap: reconcile resumes the session there.
-            markAccepted();
-        }
-        else {
-            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,
-                                        },
-                                    };
-                                });
-                            }
-                            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,
-                                    ...(opts.monitorEvent === undefined ? {} : { monitor_event: true }),
-                                },
-                                compact: opts.compact !== false,
-                                effort: resumeEffort ?? recordedResumeEffort(lane),
-                            });
-                            archiveResumeMessage(hqRoot, laneId, dropboxMessage);
-                            return started;
-                        }, hireGrantContext);
-                    }, ctx.sleep);
-                },
-            }, mechanism);
-            if (dispatched.mechanism === "resume")
-                resumed = dispatched.value;
-            markAccepted();
-        }
-        // Every accepted message moves the compaction reference forward.
-        let next = casUpdateLane(hqRoot, laneId, (current) => ({
-            ...resetKeepAliveProgress(current),
-            last_message_at: at,
-        }));
-        if (projectId !== lane.project_id || storyId !== lane.story_id) {
-            next = casUpdateLane(hqRoot, laneId, (current) => {
-                const already = current.attribution_history.some((entry) => entry.message_id === messageId);
-                if (already)
-                    return current;
-                return {
-                    ...current,
-                    project_id: projectId,
-                    story_id: storyId,
-                    no_story_reason: storyId ? undefined : current.no_story_reason,
-                    stories: laneStory(current, projectId, storyId)
-                        ? laneStories(current)
-                        : [
-                            ...laneStories(current),
-                            {
-                                project_id: projectId,
-                                story_id: storyId,
-                                status: "in_progress",
-                                added_at: at,
-                                updated_at: at,
-                            },
-                        ],
-                    attribution_history: appendCappedHistory(current.attribution_history, {
-                        project_id: projectId,
-                        story_id: storyId,
-                        message_id: messageId,
-                        at,
-                    }),
-                };
-            });
-        }
-        // What this command can claim when it returns: the message is durably
-        // written (accepted). Delivery to the model is asynchronous in both
-        // mechanisms. `dropbox` delivers on the worker's next tool call, and only
-        // if the drain hook is registered in the account home the worker was
-        // started from; `resume` has started a new worker with the message as its
-        // prompt. Neither is "delivered", so the response never says so.
-        const drainHook = drainHookStatusFor(ctx, next);
-        const deliveryStatus = move?.queued
-            ? "queued_on_target_account"
-            : queuedOnAdmission
-                ? "queued_on_admission"
-                : mechanism === "dropbox"
-                    ? "awaiting_next_tool_call"
-                    : "worker_spawned";
-        const warning = mechanism === "dropbox" && drainHook !== null && !drainHook.registered
-            ? `The drain hook is not registered in ${drainHook.path}; the running worker will not receive this message. It stays in the inbox and is delivered on the lane's next start.`
-            : mechanism === "dropbox" && next.stalled === true
-                ? `The worker has made no tool call since ${next.stalled_at ?? "an unknown time"} (${next.stalled_reason ?? "stalled"}); delivery waits on its next tool call.`
-                : null;
-        if (!opts.silent)
-            printJson({
-                ok: true,
-                action: "message",
-                lane_id: laneId,
-                message_id: messageId,
-                accepted: true,
-                delivered: false,
-                delivery: mechanism,
-                delivery_status: deliveryStatus,
-                inbox_path: mechanism === "dropbox" ? dropboxInboxPath(hqRoot, laneId) : null,
-                drain_hook: drainHook,
-                warning,
-                resumed_session_id: resumed?.last_resume?.session_id ?? null,
-                compaction: resumed?.last_compaction && resumed.last_compaction.resume_at === resumed.last_resume?.at
-                    ? resumed.last_compaction
-                    : null,
-                account_move: move ? accountMoveSummary(move) : null,
-                project_id: next.project_id,
-                story_id: next.story_id,
-                stories: laneStories(next),
-                story_warning: storyWarning(next) ?? null,
-                lane: next,
-            });
-    }
-    catch (err) {
-        if (claimedMessages.length > 0 && !accepted) {
-            const error = err instanceof Error ? err.message : String(err);
-            writeWatcherDecision(watcherOutLogPath(hqRoot, laneId), {
-                event: "message_recovery_failed",
-                at: ctx.now().toISOString(),
-                state: lane.state,
-                error,
-                message_count: claimedMessages.length,
-            }, WATCHER_OUT_MAX_BYTES);
-            try {
-                requeueDropboxMessages(hqRoot, laneId, claimedMessages);
-            }
-            catch (requeueErr) {
-                const requeueMessage = requeueErr instanceof Error ? requeueErr.message : String(requeueErr);
-                writeWatcherDecision(watcherOutLogPath(hqRoot, laneId), {
-                    event: "message_requeue_failed",
-                    at: ctx.now().toISOString(),
-                    state: lane.state,
-                    recovery_error: error,
-                    requeue_error: requeueMessage,
-                    message_count: claimedMessages.length,
-                }, WATCHER_OUT_MAX_BYTES);
-                throw new LanesError("message_requeue_failed", `Could not return ${claimedMessages.length} queued lane message(s) to the inbox after recovery failed: ${requeueMessage}`, { lane_id: laneId, message_count: claimedMessages.length, recovery_error: error });
-            }
-        }
-        throw err;
-    }
-}
-async function messageLaneExclusion(ctx, lane) {
-    if (lane.state === "killed" || lane.state === "cancelled") {
-        return { lane, exclusion: lane.state };
-    }
-    const lineageAware = await readLanesRegistryFlag(LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, {
-        company: lane.company,
-        env: ctx.env,
-    });
-    const currentLane = readLane(ctx.hqRoot(), lane.lane_id);
-    if (currentLane.state === "killed" || currentLane.state === "cancelled") {
-        return { lane: currentLane, exclusion: currentLane.state };
-    }
-    const lanes = loadAllLanes(ctx.hqRoot());
-    const retiredLaneIds = loadRetiredLaneIds(ctx.hqRoot());
-    return {
-        lane: currentLane,
-        exclusion: keepAliveExclusion(currentLane, lanes, retiredLaneIds, lineageAware),
-    };
-}
-function recordMessageUndeliverable(ctx, lane, reason, messageCount) {
-    writeWatcherDecision(watcherOutLogPath(ctx.hqRoot(), lane.lane_id), {
-        event: "message_undeliverable",
-        at: ctx.now().toISOString(),
-        state: lane.state,
-        reason,
-        ...(messageCount === undefined ? {} : { message_count: messageCount }),
-    }, WATCHER_OUT_MAX_BYTES);
-}
-/**
- * Watcher and reconcile call the hidden command below after they win the
- * terminal transition. The inbox is claimed once with the normal atomic
- * dropbox drain, and an accepted message is routed through runMessage so the
- * existing provider, admission, account, worker-profile and senior checks
- * remain authoritative.
- */
-async function recoverQueuedMessages(ctx, laneId) {
-    const hqRoot = ctx.hqRoot();
-    let lane = readLane(hqRoot, laneId);
-    if (!dropboxInboxHasMessages(hqRoot, laneId))
-        return { action: "none", message_count: 0 };
-    const eligibility = await messageLaneExclusion(ctx, lane);
-    lane = eligibility.lane;
-    const exclusion = eligibility.exclusion;
-    const refusal = exclusion ?? (lane.state === "done"
-        ? "done_before_envelope"
-        : lane.state === "awaiting_input"
-            ? "awaiting_input_requires_question_answer"
-            : laneDeliveryMechanism(lane) !== "resume"
-                ? `no_resume_path_for_${lane.state}`
-                : undefined);
-    if (refusal !== undefined) {
-        const messages = drainDropbox(hqRoot, laneId, { archiveDirectory: "undeliverable" });
-        if (messages.length > 0)
-            recordMessageUndeliverable(ctx, lane, refusal, messages.length);
-        return { action: messages.length > 0 ? "undeliverable" : "none", message_count: messages.length };
-    }
-    const messages = drainDropbox(hqRoot, laneId);
-    if (messages.length === 0)
-        return { action: "none", message_count: 0 };
-    let accepted = false;
-    try {
-        await runMessage(ctx, laneId, {
-            text: formatDropboxMessages(messages),
-            compact: false,
-            silent: true,
-            onAccepted: () => { accepted = true; },
-        });
-        return { action: "resumed", message_count: messages.length };
-    }
-    catch (err) {
-        const error = err instanceof Error ? err.message : String(err);
-        writeWatcherDecision(watcherOutLogPath(hqRoot, laneId), {
-            event: "message_recovery_failed",
-            at: ctx.now().toISOString(),
-            state: lane.state,
-            error,
-            message_count: messages.length,
-        }, WATCHER_OUT_MAX_BYTES);
-        if (!accepted) {
-            try {
-                requeueDropboxMessages(hqRoot, laneId, messages);
-            }
-            catch (requeueErr) {
-                const requeueMessage = requeueErr instanceof Error ? requeueErr.message : String(requeueErr);
-                writeWatcherDecision(watcherOutLogPath(hqRoot, laneId), {
-                    event: "message_requeue_failed",
-                    at: ctx.now().toISOString(),
-                    state: lane.state,
-                    recovery_error: error,
-                    requeue_error: requeueMessage,
-                    message_count: messages.length,
-                }, WATCHER_OUT_MAX_BYTES);
-                throw new LanesError("message_requeue_failed", `Could not return ${messages.length} queued lane message(s) to the inbox after recovery failed: ${requeueMessage}`, { lane_id: laneId, message_count: messages.length, recovery_error: error });
-            }
-        }
-        throw err;
-    }
-}
-function accountMoveSummary(move) {
-    return {
-        from: move.from,
-        to: move.to,
-        queued: move.queued,
-        copied: move.copy.copied,
-        sources: move.copy.sources,
-        targets: move.copy.targets,
-        source_dir: move.copy.source_dir,
-        target_dir: move.copy.target_dir,
-    };
-}
 function persistClaudeAccountSelection(hqRoot, lane, selection) {
     return casUpdateLane(hqRoot, lane.lane_id, (current) => {
         if (current.version !== lane.version || current.state !== lane.state || current.account !== lane.account) {
@@ -6321,69 +5690,6 @@ function persistClaudeAccountSelection(hqRoot, lane, selection) {
         return { ...current, account_selection: selection };
     });
 }
-async function runClaudeBalanceMoveTarget(ctx, laneId, opts) {
-    const lane = laneWithRecoveredProviderSession(ctx.hqRoot(), readLane(ctx.hqRoot(), laneId));
-    assertLaneRunsHereForOperatorMutation(ctx, lane, "balance-move-target");
-    if (lane.provider !== "claude") {
-        throw new LanesError("claude_account_balance_provider_mismatch", `Lane ${laneId} does not use Claude`, {
-            lane_id: laneId,
-            provider: lane.provider,
-        });
-    }
-    const expectedFrom = opts.fromAccount?.trim();
-    if (!expectedFrom) {
-        throw new LanesError("claude_account_balance_source_invalid", "Balance move requires --from-account <id>", {
-            lane_id: laneId,
-        });
-    }
-    if (lane.account !== expectedFrom) {
-        throw new LanesError("claude_account_balance_source_changed", `Lane ${laneId} no longer uses the planned source account`, {
-            lane_id: laneId,
-            expected_account: expectedFrom,
-            actual_account: lane.account ?? null,
-        });
-    }
-    const expectedState = opts.expectedState?.trim();
-    if (!expectedState) {
-        throw new LanesError("claude_account_balance_state_invalid", "Balance move requires --expected-state <state>", {
-            lane_id: laneId,
-        });
-    }
-    if (lane.state !== expectedState) {
-        throw new LanesError("claude_account_balance_state_changed", `Lane ${laneId} changed state after balance was calculated`, {
-            lane_id: laneId,
-            expected_state: expectedState,
-            actual_state: lane.state,
-        });
-    }
-    if (!BALANCE_MOVABLE_STATES.includes(lane.state) || lane.pending_resume !== undefined) {
-        throw new LanesError("claude_account_balance_state_not_movable", `Lane ${laneId} is not between turns`, {
-            lane_id: laneId,
-            state: lane.state,
-            pending_resume: lane.pending_resume !== undefined,
-        });
-    }
-    const account = opts.account?.trim();
-    if (!account) {
-        throw new LanesError("claude_account_balance_account_invalid", "Balance move requires --account <id>", {
-            lane_id: laneId,
-        });
-    }
-    const moved = await prepareAccountMove(ctx, lane, {
-        account,
-        cliModel: undefined,
-        accountHistoryReason: automaticBalanceMoveHistoryReason(ctx, lane),
-        deferTurnStart: true,
-    });
-    printJson({
-        ok: true,
-        action: "balance-move-target",
-        lane_id: laneId,
-        from: moved.from,
-        state: moved.lane.state,
-        account: moved.lane.account,
-    });
-}
 function automaticBalanceMoveHistoryReason(ctx, lane) {
     const hqRoot = ctx.hqRoot();
     const config = loadLanesConfig(hqRoot);
@@ -6432,384 +5738,6 @@ function laneWithRecoveredProviderSession(hqRoot, lane) {
             : {}),
     };
 }
-/**
- * `hq lanes resume <lane-id> [--text <msg>]`: the explicit opt-in that
- * continues a lane in `interrupted`, `done` or `blocked`, or a failed lane
- * whose only terminal reason is an invalid envelope after its repair turn,
- * on its recorded
- * provider session. `hq lanes message` keeps refusing `interrupted`; this
- * command is the path its refusal names. The launch is the same
- * `spawnLaneWorker` a message resume uses, so the resume-time compaction
- * rule and the watcher's mesh events are the same. The record gains
- * `last_resume` with `trigger: "resume"`, `resumed_from` and the text.
- */
-async function runResume(ctx, laneId, opts) {
-    const hqRoot = ctx.hqRoot();
-    let lane = readLane(hqRoot, laneId);
-    const failedResumeReason = opts.reason?.trim();
-    if (opts.reason !== undefined && opts.fromFailed !== true) {
-        throw new LanesError("failed_resume_reason_requires_flag", "--reason on hq lanes resume requires --from-failed", { lane_id: laneId });
-    }
-    if (opts.fromFailed === true && !failedResumeReason) {
-        throw new LanesError("failed_resume_reason_required", "--from-failed requires a non-empty --reason", { lane_id: laneId });
-    }
-    if (opts.reason !== undefined)
-        assertNoSecretText("resume reason", opts.reason);
-    if (opts.failedResumeContext !== undefined && opts.fromFailed !== true) {
-        throw new LanesError("failed_resume_authorization_invalid", "Failed-resume authorization context requires --from-failed", { lane_id: laneId });
-    }
-    const failedResumeActor = opts.fromFailed === true
-        ? authorizeFailedResume(ctx, lane, opts.failedResumeContext)
-        : undefined;
-    if (opts.fromFailed === true && lane.state !== "failed") {
-        throw new LanesError("lane_not_failed", `Lane ${laneId} is ${lane.state}; --from-failed only applies to a failed lane`, { lane_id: laneId, state: lane.state });
-    }
-    const failedResumeExpectedSenior = opts.fromFailed === true
-        ? { ...lane.senior }
-        : undefined;
-    const recoveredFailure = opts.fromFailed === true
-        ? lane.terminal_reason ?? "failure_reason_unavailable"
-        : undefined;
-    const hireGrantContext = opts.grantContext === undefined
-        ? undefined
-        : (() => {
-            if (!ctx.isSsmOwnerDispatch()) {
-                throw new LanesError("hire_grant_dispatch_unauthorized", "Resume grant context is only valid on an Outpost owner dispatch", { lane_id: laneId });
-            }
-            return parseOutpostHireGrantContext(opts.grantContext, laneId);
-        })();
-    if (opts.profileRepinContext !== undefined && !ctx.isSsmOwnerDispatch()) {
-        throw new LanesError("worker_profile_hash_mismatch", "Profile re-pin context is only valid on an Outpost owner dispatch", { lane_id: laneId });
-    }
-    if (lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane)) {
-        await withResumeHireAdmission(ctx, lane, () => undefined);
-        await dispatchOutpostLaneCommand(ctx, lane, "resume", opts);
-        return;
-    }
-    // Fail before provider/session work if a terminal child would consume a
-    // slot that its senior has already assigned elsewhere.
-    await withResumeHireAdmission(ctx, lane, () => undefined, hireGrantContext);
-    assertLaneRunsHereForOperatorMutation(ctx, lane, "resume");
-    const cliEffort = parseCliEffort(lane.provider, opts.effort);
-    if (cliEffort !== undefined && !providerSupportsSessionResume(lane.provider)) {
-        throw new LanesError("effort_resume_unsupported", `Provider ${lane.provider} cannot change effort on a resumed session`, { lane_id: laneId, provider: lane.provider });
-    }
-    lane = laneWithRecoveredProviderSession(hqRoot, lane);
-    if (opts.model !== undefined && opts.account === undefined) {
-        throw new LanesError("model_requires_account", "--model on hq lanes resume is only accepted together with --account", {});
-    }
-    if (opts.account !== undefined && lane.state === "running") {
-        throw new LanesError("lane_running", `Lane ${laneId} is running; stop it or wait for it to exit before moving its session`, {
-            lane_id: laneId,
-            state: lane.state,
-        });
-    }
-    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}` });
-    }
-    const refusal = resumeCommandRefusal(lane, { allowFailed: opts.fromFailed === true });
-    if (refusal !== null) {
-        throw new LanesError(refusal.error, refusal.message, {
-            lane_id: laneId,
-            state: lane.state,
-            provider: lane.provider,
-            message: refusal.message,
-        });
-    }
-    assertLaneRunsHereForAdmission(ctx, lane);
-    const resumedFrom = lane.state;
-    const text = opts.text?.trim() ? opts.text : undefined;
-    const at = ctx.now().toISOString();
-    const projectId = opts.project?.trim() || lane.project_id;
-    const storyId = opts.story?.trim() || lane.story_id;
-    if (opts.story !== undefined && !opts.story.trim()) {
-        throw new LanesError("missing_story", "--story must be non-empty", {});
-    }
-    if ((opts.project !== undefined || opts.story !== undefined) && ctx.storyLedgerEnabled()) {
-        validateProjectStories(hqRoot, projectId, [storyId], lane.company?.slug);
-    }
-    const attributionChanged = projectId !== lane.project_id || storyId !== lane.story_id;
-    const messageId = text !== undefined || attributionChanged ? mintMessageId() : undefined;
-    let requestedMeshCompany;
-    let meshThreadId;
-    if (opts.meshCompany !== undefined) {
-        const meshCompanySlug = opts.meshCompany.trim();
-        if (!meshCompanySlug) {
-            throw new LanesError("missing_mesh_company", "--mesh-company must be a non-empty company slug", {});
-        }
-        requestedMeshCompany = await ctx.resolveCompany(meshCompanySlug);
-        if (lane.company !== null &&
-            (lane.company.uid !== requestedMeshCompany.uid || lane.company.slug !== requestedMeshCompany.slug)) {
-            throw new LanesError("mesh_company_mismatch", "--mesh-company must match the lane's company when the lane is company-owned", { company: lane.company.slug, mesh_company: requestedMeshCompany.slug });
-        }
-        meshThreadId = await ctx.mesh.ensureProjectThread(requestedMeshCompany, projectId);
-    }
-    const resumeProfile = opts.worker !== undefined
-        ? resolveResumeProfile(ctx, lane, opts.worker)
-        : undefined;
-    const profileRepin = authorizeResumeProfileRepin(ctx, lane, resumeProfile, opts.profileRepinContext);
-    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);
-    if (resumeProfile !== undefined && (opts.account === undefined || keepCurrentAccount)) {
-        validateResumeProfileModel(ctx, lane, resumeProfile.profile);
-    }
-    const automaticAccountSelection = opts.account === undefined
-        ? await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile, { repairUnavailableAccount: true })
-        : undefined;
-    const resumeEffort = resolveResumeEffort(ctx, lane, {
-        cliEffort,
-        profile: resumeProfile,
-        account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.selection.account,
-        model: opts.model,
-    });
-    let move = null;
-    if (opts.account !== undefined && !keepCurrentAccount) {
-        move = await prepareAccountMove(ctx, lane, {
-            account: opts.account,
-            cliModel: opts.model?.trim() || undefined,
-            ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
-            ...(profileRepin !== undefined ? { profileRepin } : {}),
-            ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
-            pending: {
-                trigger: "resume",
-                resumed_from: resumedFrom,
-                ...(opts.fromFailed === true ? { from_failed: true } : {}),
-                ...(failedResumeExpectedSenior !== undefined
-                    ? { expected_senior: failedResumeExpectedSenior }
-                    : {}),
-                ...(text !== undefined ? { text } : {}),
-                ...(messageId !== undefined ? { message_id: messageId } : {}),
-                compact: opts.compact !== false,
-            },
-        });
-        lane = move.lane;
-    }
-    else if (automaticAccountSelection !== undefined) {
-        const selection = automaticAccountSelection.selection;
-        if (selection.account !== lane.account) {
-            move = await prepareAccountMove(ctx, lane, {
-                account: selection.account,
-                cliModel: undefined,
-                ...(automaticAccountSelection.historyReason !== undefined
-                    ? { accountHistoryReason: automaticAccountSelection.historyReason }
-                    : {}),
-                ...(automaticAccountSelection.preservedModel !== undefined
-                    ? { preservedModel: automaticAccountSelection.preservedModel }
-                    : {}),
-                ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
-                ...(profileRepin !== undefined ? { profileRepin } : {}),
-                ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
-                pending: {
-                    trigger: "resume",
-                    resumed_from: resumedFrom,
-                    ...(opts.fromFailed === true ? { from_failed: true } : {}),
-                    ...(failedResumeExpectedSenior !== undefined
-                        ? { expected_senior: failedResumeExpectedSenior }
-                        : {}),
-                    ...(text !== undefined ? { text } : {}),
-                    ...(messageId !== undefined ? { message_id: messageId } : {}),
-                    compact: opts.compact !== false,
-                },
-                accountSelection: selection,
-            });
-            lane = move.lane;
-        }
-        else {
-            lane = persistClaudeAccountSelection(hqRoot, lane, selection);
-        }
-    }
-    lane = recordResumeSetup(ctx, lane, {
-        ...(move === null && resumeProfile !== undefined ? { profile: resumeProfile } : {}),
-        ...(move === null && profileRepin !== undefined ? { profileRepin } : {}),
-        ...(move === null && resumeEffort !== undefined ? { effort: resumeEffort } : {}),
-        ...(keepAlive !== undefined ? { keepAlive } : {}),
-        ...(move === null && keepCurrentAccount && opts.model !== undefined ? { cliModel: opts.model } : {}),
-        ...(requestedMeshCompany !== undefined
-            ? { meshCompany: requestedMeshCompany, threadId: meshThreadId }
-            : {}),
-    });
-    let queuedOnAdmission = false;
-    let resumed;
-    if (move?.queued) {
-        resumed = lane;
-    }
-    else {
-        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 resume`, {
-                            lane_id: laneId,
-                            provider: lane.provider,
-                        });
-                    }
-                    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 resume 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: "resume",
-                                resumed_from: resumedFrom,
-                                ...(opts.fromFailed === true ? { from_failed: true } : {}),
-                                ...(failedResumeExpectedSenior !== undefined
-                                    ? { expected_senior: failedResumeExpectedSenior }
-                                    : {}),
-                                ...(text !== undefined ? { text } : {}),
-                                ...(messageId !== undefined ? { message_id: messageId } : {}),
-                                compact: opts.compact !== false,
-                                at,
-                            },
-                        };
-                    });
-                }
-                return 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: "resume",
-                        from: resumedFrom,
-                        ...(opts.fromFailed === true ? { fromFailed: true } : {}),
-                        ...(failedResumeExpectedSenior !== undefined
-                            ? { expectedSenior: failedResumeExpectedSenior }
-                            : {}),
-                        ...(text !== undefined ? { text } : {}),
-                        ...(messageId !== undefined ? { message_id: messageId } : {}),
-                    },
-                    compact: opts.compact !== false,
-                    effort: resumeEffort ?? recordedResumeEffort(lane),
-                });
-            }, hireGrantContext);
-        }, ctx.sleep);
-    }
-    if (text !== undefined && messageId !== undefined) {
-        // Same audit copy a message resume leaves; nothing drains it. Archive only
-        // after a successful spawn so a concurrent resume cannot leave a phantom.
-        archiveResumeMessage(hqRoot, laneId, {
-            at,
-            message_id: messageId,
-            text,
-            project_id: projectId,
-            story_id: storyId,
-            resumed_from: resumedFrom,
-        });
-    }
-    let next = resumed;
-    if (failedResumeActor !== undefined &&
-        failedResumeReason !== undefined &&
-        recoveredFailure !== undefined) {
-        next = casUpdateLane(hqRoot, laneId, (current) => ({
-            ...current,
-            failed_resume_history: appendCappedHistory(current.failed_resume_history ?? [], {
-                at,
-                actor: failedResumeActor,
-                reason: failedResumeReason,
-                failure: recoveredFailure,
-            }),
-        }));
-    }
-    if (text !== undefined) {
-        // An operator text moves the compaction reference forward, as a message does.
-        next = casUpdateLane(hqRoot, laneId, (current) => ({
-            ...resetKeepAliveProgress(current),
-            last_message_at: at,
-        }));
-    }
-    if (messageId !== undefined && attributionChanged) {
-        next = casUpdateLane(hqRoot, laneId, (current) => {
-            const already = current.attribution_history.some((entry) => entry.message_id === messageId);
-            if (already)
-                return current;
-            return {
-                ...current,
-                project_id: projectId,
-                story_id: storyId,
-                no_story_reason: storyId ? undefined : current.no_story_reason,
-                stories: laneStory(current, projectId, storyId)
-                    ? laneStories(current)
-                    : [
-                        ...laneStories(current),
-                        {
-                            project_id: projectId,
-                            story_id: storyId,
-                            status: "in_progress",
-                            added_at: at,
-                            updated_at: at,
-                        },
-                    ],
-                attribution_history: appendCappedHistory(current.attribution_history, {
-                    project_id: projectId,
-                    story_id: storyId,
-                    message_id: messageId,
-                    at,
-                }),
-            };
-        });
-    }
-    if (text === undefined && hasKeepAliveProgress(next)) {
-        next = casUpdateLane(hqRoot, laneId, (current) => resetKeepAliveProgress(current));
-    }
-    printJson({
-        ok: true,
-        action: "resume",
-        lane_id: laneId,
-        resumed_from: resumedFrom,
-        message_id: messageId ?? null,
-        text: text ?? null,
-        delivery: "resume",
-        delivery_status: move?.queued
-            ? "queued_on_target_account"
-            : queuedOnAdmission
-                ? "queued_on_admission"
-                : "worker_spawned",
-        account_move: move ? accountMoveSummary(move) : null,
-        resumed_session_id: resumed.last_resume?.session_id ?? null,
-        last_resume: next.last_resume ?? null,
-        compaction: resumed.last_compaction && resumed.last_compaction.resume_at === resumed.last_resume?.at
-            ? resumed.last_compaction
-            : null,
-        project_id: next.project_id,
-        story_id: next.story_id,
-        stories: laneStories(next),
-        story_warning: storyWarning(next) ?? null,
-        lane: next,
-    });
-}
 function storyCommandTarget(lane, storyId, project) {
     const projectId = project?.trim() || lane.project_id;
     const normalizedStoryId = storyId.trim();
@@ -7911,7 +6839,7 @@ function writeAnswerDeliveryFailed(hqRoot, laneId, questionId, err, at) {
  * Record is already durable. Delivery is best-effort onto the asking lane's
  * drop box (spec §6.5). Target is question.lane_id, never a project/story lookup.
  */
-async function runReconcile(ctx, opts) {
+async function runReconcile(ctx, opts, recoverQueuedMessages) {
     const fromEnv = ctx.env.HQ_ROOT?.trim();
     const hqRoot = fromEnv && ctx.existsSync(fromEnv) ? fromEnv : ctx.hqRoot();
     const summary = await runReconcilePass(hqRoot, {
@@ -7938,9 +6866,7 @@ async function runReconcile(ctx, opts) {
         livenessDeps: livenessDepsFromCtx(ctx),
         presenceConnected: ctx.presenceConnected,
         resolveQuestionActiveCompany: () => resolveActiveQuestionCompany(ctx),
-        recoverQueuedMessages: async (lane) => {
-            await recoverQueuedMessages(ctx, lane.lane_id);
-        },
+        recoverQueuedMessages,
         mesh: ctx.mesh,
         env: ctx.env,
     });
@@ -8057,6 +6983,51 @@ export function registerLanesCommand(parent, deps = {}) {
         seniorOfSession,
         writeAnswerDeliveryFailed,
     });
+    const messageHandlerDeps = {
+        archiveResumeMessage,
+        assertLaneRunsHereForAdmission,
+        assertLaneRunsHereForOperatorMutation,
+        assessLaneAdmission,
+        casUpdateLane,
+        dispatchOutpostLaneCommand,
+        drainHookStatusFor,
+        laneIsHostedHere,
+        laneWithRecoveredProviderSession,
+        loadAllLanes,
+        mintMessageId,
+        prepareAccountMove,
+        persistClaudeAccountSelection,
+        printJson,
+        recordResumeSetup,
+        resolveActiveQuestionCompany,
+        resolveResumeProfile,
+        selectAutomaticClaudeResumeAccount,
+        validateResumeProfileModel,
+        withResumeHireAdmission,
+    };
+    const messageHandlers = createLaneMessageHandlers(messageHandlerDeps);
+    const resumeHandlers = createLaneResumeHandlers({
+        archiveResumeMessage,
+        assertLaneRunsHereForAdmission,
+        assertLaneRunsHereForOperatorMutation,
+        assessLaneAdmission,
+        automaticBalanceMoveHistoryReason,
+        authorizeFailedResume,
+        authorizeResumeProfileRepin,
+        casUpdateLane,
+        dispatchOutpostLaneCommand,
+        laneIsHostedHere,
+        laneWithRecoveredProviderSession,
+        mintMessageId,
+        prepareAccountMove,
+        persistClaudeAccountSelection,
+        printJson,
+        recordResumeSetup,
+        resolveResumeProfile,
+        selectAutomaticClaudeResumeAccount,
+        validateResumeProfileModel,
+        withResumeHireAdmission,
+    });
     const lanes = parent
         .command("lanes", { hidden: true })
         .description("Create, supervise, and steer worker lanes; routed decision queue");
@@ -8243,7 +7214,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .requiredOption("--from-account <id>", "Expected source Claude account id")
         .requiredOption("--expected-state <state>", "Expected lane state from the balance plan")
         .action(wrap(async (laneId, opts) => {
-        await runClaudeBalanceMoveTarget(ctx, laneId, opts);
+        await resumeHandlers.runClaudeBalanceMoveTarget(ctx, laneId, opts);
     }));
     lanes
         .command("admit")
@@ -8344,13 +7315,13 @@ export function registerLanesCommand(parent, deps = {}) {
         .addOption(new Option("--grant-context <base64url>").hideHelp())
         .option("--no-compact", "Skip the resume-time compaction check for this message")
         .action(wrap(async (laneId, opts) => {
-        await runMessage(ctx, laneId, opts);
+        await messageHandlers.runMessage(ctx, laneId, opts);
     }));
     lanes
         .command("_recover-queued-messages", { hidden: true })
         .argument("<lane-id>", "Lane id")
         .action(wrap(async (laneId) => {
-        printJson(await recoverQueuedMessages(ctx, laneId));
+        printJson(await messageHandlers.recoverQueuedMessages(ctx, laneId));
     }));
     lanes
         .command("_monitor-message", { hidden: true })
@@ -8375,7 +7346,7 @@ export function registerLanesCommand(parent, deps = {}) {
             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, {
+        await messageHandlers.runMessage(ctx, laneId, {
             text: value.text,
             monitorEvent: {
                 monitor_id: value.monitor_id,
@@ -8404,7 +7375,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .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) => {
-        await runResume(ctx, laneId, opts);
+        await resumeHandlers.runResume(ctx, laneId, opts);
     }));
     lanes
         .command("reparent")
@@ -8590,7 +7561,9 @@ export function registerLanesCommand(parent, deps = {}) {
         .description("Run one machine-owned reconcile pass and exit")
         .option("--dry-run", "Report what would change and write nothing")
         .action(wrap(async (opts) => {
-        await runReconcile(ctx, opts);
+        await runReconcile(ctx, opts, async (lane) => {
+            await messageHandlers.recoverQueuedMessages(ctx, lane.lane_id);
+        });
     }));
     reconcile
         .command("install")