@indigoai-us/hq-cli 5.242.0 → 5.244.0

package/dist/commands/lanes.js

@@ -11,6 +11,9 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { Option } from "commander";
+import { createLaneAccountsHandlers } from "./lanes-accounts.js";
+import { createLaneQuestionsHandlers } from "./lanes-questions.js";
+export { resolveAnswerChoice } from "./lanes-questions.js";
 import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
 import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
@@ -26,10 +29,10 @@ import { createOutpostProfileRepinContext, parseOutpostProfileRepinContext, } fr
 import { createOutpostRegistryWorkerApprovalContext, parseOutpostRegistryWorkerApprovalContext, } from "../lib/lanes/outpost-registry-worker-approval.js";
 import { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity, resolveAdmissionHost, } from "../lib/lanes/admission-host.js";
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
-import { buildOutpostCapacityCommand, buildOutpostBalanceMoveCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostMoveTargetCommand, buildOutpostQuestionAnswerCommand, buildOutpostQuestionListCommand, buildOutpostQuestionShowCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, outpostRejectedEffortOption, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
+import { buildOutpostCapacityCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostMoveTargetCommand, buildOutpostQuestionListCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, outpostRejectedEffortOption, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
 import { outpostHireSummaryCacheKey, readOutpostHireSummaryCache, writeOutpostHireSummaryCache, } from "../lib/lanes/outpost-hire-cache.js";
 import { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "../lib/lanes/host-capacity.js";
-import { BALANCE_MOVABLE_STATES, accountLoadsForReport, planClaudeBalanceMoves, selectClaudeAccount, } from "../lib/lanes/claude-balance.js";
+import { BALANCE_MOVABLE_STATES, selectClaudeAccount, } from "../lib/lanes/claude-balance.js";
 import { parseUserYaml } from "../utils/user-yaml-error.js";
 import { backfillOutpostIdentityMarker as backfillOutpostIdentityMarkerImpl, createOutpostIdentityMarkerIfMissing, validateOutpostIdentityId, } from "../lib/lanes/outpost-identity.js";
 import { vaultApiFetch } from "../utils/vault-api.js";
@@ -40,21 +43,20 @@ 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, 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, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, 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, withAllLaneAdmissionLocks, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } 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, 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 { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
 import { keepAliveExclusion, LEAD_LANE_KEEP_ALIVE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
 import { questionBodyAbsPath, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
 import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.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 { 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 { accountQuotaView, loadQuotaState, quotaBlockFor } from "../lib/lanes/quota.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";
@@ -64,11 +66,7 @@ export { spawnLaneWorker };
 export { questionBodyAbsPath };
 export { MAX_LANE_DEPTH };
 export const LANES_RUNS_REL = path.join("workspace", "lanes-runs");
-const VENDOR_LOGIN = {
-    claude: { command: "claude", args: ["auth", "login"] },
-    codex: { command: "codex", args: ["login"] },
-    grok: { command: "grok", args: ["login"] },
-};
+/** The lane → mesh seam. Defined in lib/lanes/mesh-events.ts; the watcher shares it. */
 export { emitLaneDecisionEvents };
 export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
 function defaultLanePlacementEnabled() {
@@ -77,13 +75,6 @@ function defaultLanePlacementEnabled() {
 function defaultLaneTrackerEnabled(company) {
     return readLanesRegistryFlag(LANES_TRACKER_FLAG, { company });
 }
-async function resolveSelectedAccountHomeCompany(ctx, selector) {
-    const company = await ctx.resolveActiveCompany(selector);
-    if (!company) {
-        throw new CompanySelectionError(`No unique active company membership for ${selector}. Pass an active company UID with --company.`);
-    }
-    return company;
-}
 function withoutProviderHome(value) {
     if (Array.isArray(value))
         return value.map(withoutProviderHome);
@@ -354,21 +345,6 @@ function parseHireGrant(raw) {
 function seniorKey(ref) {
     return ref.kind === "user" ? "user" : `${ref.kind}:${ref.id ?? ""}`;
 }
-export function resolveAnswerChoice(choice, options, freeform) {
-    const trimmed = choice.trim();
-    if (/^[0-9]+$/.test(trimmed)) {
-        const index = Number(trimmed);
-        if (Number.isInteger(index) && index >= 1 && index <= options.length) {
-            return options[index - 1];
-        }
-    }
-    if (options.includes(trimmed) || options.includes(choice)) {
-        return options.includes(trimmed) ? trimmed : choice;
-    }
-    if (freeform)
-        return choice;
-    throw new LanesError("off_menu_choice", `Choice ${JSON.stringify(choice)} is not on the menu. Pass --freeform to allow it.`, { choice, options });
-}
 function parsePriority(raw) {
     if (raw === undefined || raw === null || raw === "")
         return 1;
@@ -471,17 +447,6 @@ function readQuestionBody(hqRoot, question) {
     }
     return stored.body;
 }
-function requireQuestionBody(hqRoot, question) {
-    const body = readQuestionBody(hqRoot, question);
-    if (!body) {
-        throw new LanesError("question_body_unavailable", `Question body is not available on this host for ${question.question_id}`, {
-            question_id: question.question_id,
-            store: question.body.store,
-            ref: question.body.ref,
-        });
-    }
-    return body;
-}
 function loadAllLanes(hqRoot) {
     return listLaneIds(hqRoot).map((id) => readLane(hqRoot, id));
 }
@@ -1664,18 +1629,6 @@ function assertQuestionCompanyMatchesLane(question, lane, code, hqRoot) {
         throw new LanesError(code, `Question ${question.question_id} does not match lane ${lane.lane_id}'s company`, { question_id: question.question_id, lane_id: lane.lane_id });
     }
 }
-function assertQuestionCompanyAccess(question, lane, requestedCompany, hqRoot) {
-    assertQuestionCompanyMatchesLane(question, lane, "question_company_mismatch", hqRoot);
-    const questionCompany = questionCompanyForLane(question, lane, hqRoot);
-    if (questionCompany !== null && !sameQuestionCompany(questionCompany, requestedCompany)) {
-        throw new LanesError("question_company_mismatch", `Question ${question.question_id} does not belong to the requested or active company`, { question_id: question.question_id, lane_id: lane.lane_id });
-    }
-}
-function assertQuestionCompanyResolvedForAnswer(question, lane, hqRoot, resolvedCompany) {
-    if (questionCompanyForLane(question, lane, hqRoot) !== null || resolvedCompany)
-        return;
-    throw new LanesError("question_company_unavailable", `Cannot answer legacy question ${question.question_id}: its company cannot be resolved from the question or lane; re-run with --company <slug>`, { question_id: question.question_id, lane_id: lane.lane_id });
-}
 function questionCompanyRefMatches(recordCompany, filter) {
     return recordCompany !== null &&
         recordCompany !== undefined &&
@@ -1734,25 +1687,6 @@ function resolveAudience(hqRoot, question, ctx) {
     }
     return current;
 }
-function audienceMatches(audience, filter) {
-    if (filter.kind === "me") {
-        return audience.kind === "session" && audience.id === filter.id;
-    }
-    if (filter.kind === "user")
-        return audience.kind === "user";
-    return audience.kind === filter.kind && audience.id === filter.id;
-}
-function parseForFilter(raw, ctx) {
-    const trimmed = raw.trim();
-    if (trimmed === "me") {
-        const sessionId = sessionIdFromEnv(ctx.env);
-        if (!sessionId) {
-            throw new LanesError("missing_session_id", "--for me requires a current session id (HQ_SESSION_ID)", {});
-        }
-        return { kind: "me", id: sessionId };
-    }
-    return parseSeniorRef(trimmed);
-}
 function timeoutPath(hqRoot, laneId) {
     return path.join(runDir(hqRoot, laneId), "timeout.json");
 }
@@ -1916,16 +1850,6 @@ function assertKnownOutpost(requested, known) {
         throw new LanesError("unknown_outpost", `Unknown Outpost ${JSON.stringify(requested)}. Accepted: ${known.join(", ") || "(none)"}`, { accepted: known, value: requested });
     }
 }
-function copyHookRails(fromHome, toHome) {
-    const src = path.join(fromHome, "hooks");
-    if (!fs.existsSync(src))
-        return false;
-    fs.cpSync(src, path.join(toHome, "hooks"), { recursive: true });
-    return true;
-}
-function railsPresent(home) {
-    return fs.existsSync(path.join(home, "hooks"));
-}
 /**
  * Spec §5.1: `hq lanes ask` from inside a lane can hit a binary or dist
  * being replaced mid-call (ENOENT / ETXTBSY / a module that no longer
@@ -1934,11 +1858,6 @@ function railsPresent(home) {
  */
 export const ASK_BACKOFF_MS = [5_000, 15_000];
 export const ASK_ATTEMPTS = ASK_BACKOFF_MS.length + 1;
-function yieldEventLoop() {
-    return new Promise((resolve) => {
-        setImmediate(resolve);
-    });
-}
 function laneWaitHumanLine(result) {
     const details = Object.entries(result.change)
         .filter(([key]) => key !== "type")
@@ -1996,11 +1915,6 @@ export function casUpdateLane(hqRoot, laneId, updater) {
         return updateLane(hqRoot, laneId, current.version, "command", updater);
     });
 }
-function throwIfQuestionNotPending(current) {
-    if (current.status === "pending")
-        return;
-    throw new LanesError("question_not_pending", `Question ${current.question_id} is ${current.status}`, { question_id: current.question_id, status: current.status });
-}
 function formatUnknownValue(value) {
     if (typeof value === "string")
         return value;
@@ -3924,159 +3838,6 @@ async function readOutpostLaneSnapshot(ctx, outpostId, laneId) {
     }
     return remote.lane;
 }
-async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
-    if (lane.host.kind !== "outpost") {
-        throw new LanesError("outpost_dispatch_failed", `Lane ${lane.lane_id} has no Outpost host to answer its question`, { lane_id: lane.lane_id, question_id: questionId });
-    }
-    const outpostId = lane.host.id;
-    let dispatched;
-    try {
-        dispatched = await ctx.dispatchOutpostExec({
-            outpostId,
-            command: buildOutpostQuestionAnswerCommand({
-                questionId,
-                choice: options.choice,
-                freeform: options.freeform,
-                notes: options.notes,
-                company: options.company,
-            }),
-        });
-    }
-    catch (err) {
-        throw new LanesError("outpost_dispatch_failed", `Could not dispatch question ${questionId} to Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
-    }
-    if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
-        throw new LanesError("outpost_dispatch_failed", `Outpost ${outpostId} did not confirm the answer for question ${questionId}`, {
-            lane_id: lane.lane_id,
-            question_id: questionId,
-            outpost_id: outpostId,
-            command_id: dispatched.commandId,
-            status: dispatched.status,
-            done: dispatched.done ?? false,
-            exit_code: dispatched.exitCode,
-        });
-    }
-    const remote = parseRemoteJson(dispatched.stdout, "Outpost question answer");
-    if (remote?.error !== undefined) {
-        throw new LanesError("outpost_remote_command_failed", typeof remote.message === "string"
-            ? remote.message
-            : `Outpost ${outpostId} rejected the answer for question ${questionId}`, {
-            lane_id: lane.lane_id,
-            question_id: questionId,
-            outpost_id: outpostId,
-            command_id: dispatched.commandId,
-            remote_error: remote.error,
-        });
-    }
-    const remoteQuestion = remote?.question !== null && typeof remote?.question === "object"
-        ? remote.question
-        : null;
-    const awaitingWakeConfirmed = lane.state !== "awaiting_input" ||
-        (remote?.wake_status === "resumed" && remote.lane_state === "running") ||
-        (remote?.wake_status === "queued" && remote.lane_state === "queued") ||
-        (remote?.wake_status === "awaiting_answers" && remote.lane_state === "awaiting_input");
-    if (remote?.ok !== true ||
-        remote.action !== "questions.answer" ||
-        remoteQuestion?.question_id !== questionId ||
-        remoteQuestion.lane_id !== lane.lane_id ||
-        remoteQuestion.status !== "answered" ||
-        typeof remote.delivery !== "string" ||
-        !awaitingWakeConfirmed) {
-        throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} completed exec without confirming the answer and wake status for question ${questionId}`, {
-            lane_id: lane.lane_id,
-            question_id: questionId,
-            outpost_id: outpostId,
-            command_id: dispatched.commandId,
-        });
-    }
-    let ownerQuestion;
-    try {
-        ownerQuestion = parseQuestionRecord(remoteQuestion);
-    }
-    catch (err) {
-        throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} did not return a valid answered question record for ${questionId}: ${dispatchErrorMessage(err)}`, {
-            lane_id: lane.lane_id,
-            question_id: questionId,
-            outpost_id: outpostId,
-            command_id: dispatched.commandId,
-        });
-    }
-    const ownerAnswer = ownerQuestion.answer;
-    const ownerLaneCompany = effectiveLaneQuestionCompany(lane, ctx.hqRoot());
-    if (!isQuestionAnswer(ownerAnswer) ||
-        ownerQuestion.lane_id !== lane.lane_id ||
-        (ownerQuestion.company !== null && ownerLaneCompany !== null &&
-            !sameQuestionCompany(ownerQuestion.company, ownerLaneCompany))) {
-        throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} did not return the confirmed answer for question ${questionId}`, {
-            lane_id: lane.lane_id,
-            question_id: questionId,
-            outpost_id: outpostId,
-            command_id: dispatched.commandId,
-        });
-    }
-    const updatePrimaryCopy = () => casUpdateQuestion(ctx.hqRoot(), questionId, (current) => {
-        if (current.lane_id !== lane.lane_id) {
-            throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} belongs to a different lane than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
-        }
-        if (current.company !== null &&
-            effectiveLaneQuestionCompany(lane, ctx.hqRoot()) !== null &&
-            !sameQuestionCompany(current.company, effectiveLaneQuestionCompany(lane, ctx.hqRoot()))) {
-            throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} belongs to a different company than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
-        }
-        if (current.company !== null &&
-            ownerQuestion.company !== null &&
-            !sameQuestionCompany(current.company, ownerQuestion.company)) {
-            throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} has a different company than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
-        }
-        if (current.status === "pending") {
-            return {
-                ...current,
-                company: current.company ?? ownerQuestion.company,
-                status: "answered",
-                answer: ownerAnswer,
-                delivered_at: ownerQuestion.delivered_at ?? current.delivered_at ?? null,
-            };
-        }
-        if (current.status === "answered" && sameQuestionAnswer(current.answer, ownerAnswer)) {
-            const deliveredAt = ownerQuestion.delivered_at ?? current.delivered_at ?? null;
-            const company = current.company ?? ownerQuestion.company;
-            return deliveredAt === current.delivered_at && company === current.company
-                ? current
-                : { ...current, company, delivered_at: deliveredAt };
-        }
-        throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} is ${current.status} or has a different answer than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
-    });
-    let syncedQuestion;
-    try {
-        syncedQuestion = updatePrimaryCopy();
-    }
-    catch (err) {
-        if (!isLanesError(err) || err.error !== "question_not_found")
-            throw err;
-        const primaryLane = readLane(ctx.hqRoot(), lane.lane_id);
-        const primaryCompany = effectiveLaneQuestionCompany(primaryLane, ctx.hqRoot());
-        const ownerCompany = effectiveLaneQuestionCompany(lane, ctx.hqRoot());
-        if (primaryCompany !== null && ownerCompany !== null && !sameQuestionCompany(primaryCompany, ownerCompany)) {
-            throw new LanesError("outpost_question_sync_conflict", `Primary lane ${lane.lane_id} belongs to a different company than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
-        }
-        try {
-            syncedQuestion = createQuestion(ctx.hqRoot(), ownerQuestion);
-        }
-        catch (createErr) {
-            if (!isLanesError(createErr) || createErr.error !== "question_exists")
-                throw createErr;
-            syncedQuestion = updatePrimaryCopy();
-        }
-    }
-    printJson({
-        ...remote,
-        lane_id: lane.lane_id,
-        question: syncedQuestion,
-        outpost_id: outpostId,
-        outpost_command_id: dispatched.commandId,
-        outpost_transport: "outposts_exec",
-    });
-}
 function isQuestionAnswer(value) {
     if (value === null || typeof value !== "object")
         return false;
@@ -6530,74 +6291,6 @@ function persistClaudeAccountSelection(hqRoot, lane, selection) {
         return { ...current, account_selection: selection };
     });
 }
-async function applyClaudeBalanceMove(ctx, suggestion) {
-    const currentHost = reconcileHostFromCtx(ctx);
-    const suggestionRunsHere = suggestion.host.kind === "outpost"
-        ? currentHost.outpostId === suggestion.host.id
-        : currentHost.outpostId === null && currentHost.hostname === suggestion.host.id;
-    if (suggestion.host.kind === "outpost" && !suggestionRunsHere) {
-        let result;
-        try {
-            result = await ctx.dispatchOutpostExec({
-                outpostId: suggestion.host.id,
-                command: buildOutpostBalanceMoveCommand({
-                    laneId: suggestion.lane_id,
-                    account: suggestion.to,
-                    fromAccount: suggestion.from,
-                    expectedState: suggestion.state,
-                }),
-                timeoutSeconds: 120,
-                waitMs: 120_000,
-            });
-        }
-        catch (err) {
-            throw new LanesError("claude_account_balance_move_failed", `Could not move lane ${suggestion.lane_id} on Outpost ${suggestion.host.id}: ${dispatchErrorMessage(err)}`, { lane_id: suggestion.lane_id, host: suggestion.host, account: suggestion.to });
-        }
-        if (result.done !== true || result.status !== "Success" || result.exitCode !== 0) {
-            throw new LanesError("claude_account_balance_move_failed", `Outpost ${suggestion.host.id} did not confirm the account move for lane ${suggestion.lane_id}`, { lane_id: suggestion.lane_id, host: suggestion.host, account: suggestion.to, status: result.status, exit_code: result.exitCode });
-        }
-        const remote = parseRemoteJson(result.stdout, "Claude account balance move");
-        if (remote?.ok !== true || remote.action !== "balance-move-target" ||
-            remote.lane_id !== suggestion.lane_id || remote.from !== suggestion.from ||
-            remote.account !== suggestion.to ||
-            remote.state !== suggestion.state) {
-            throw new LanesError("claude_account_balance_move_unconfirmed", `Outpost ${suggestion.host.id} returned an invalid account-move result`, {
-                lane_id: suggestion.lane_id,
-                host: suggestion.host,
-                account: suggestion.to,
-            });
-        }
-        return { lane_id: suggestion.lane_id, host: suggestion.host, from: suggestion.from, to: suggestion.to, state: suggestion.state };
-    }
-    const lane = laneWithRecoveredProviderSession(ctx.hqRoot(), readLane(ctx.hqRoot(), suggestion.lane_id));
-    if (lane.state === "running") {
-        throw new LanesError("lane_running", `Lane ${lane.lane_id} is running; balance never moves a running turn`, {
-            lane_id: lane.lane_id,
-            state: lane.state,
-        });
-    }
-    if (lane.host.kind !== suggestion.host.kind || lane.host.id !== suggestion.host.id ||
-        lane.account !== suggestion.from || lane.state !== suggestion.state) {
-        throw new LanesError("claude_account_balance_lane_changed", `Lane ${lane.lane_id} changed after balance was calculated`, {
-            lane_id: lane.lane_id,
-            host: lane.host,
-            account: lane.account ?? null,
-        });
-    }
-    if (!BALANCE_MOVABLE_STATES.includes(lane.state)) {
-        throw new LanesError("claude_account_balance_state_not_movable", `Lane ${lane.lane_id} is no longer between turns`, {
-            lane_id: lane.lane_id,
-            state: lane.state,
-        });
-    }
-    const moved = await prepareAccountMove(ctx, lane, {
-        account: suggestion.to,
-        cliModel: undefined,
-        accountHistoryReason: automaticBalanceMoveHistoryReason(ctx, lane),
-        deferTurnStart: true,
-    });
-    return { lane_id: moved.lane.lane_id, host: moved.lane.host, from: moved.from ?? suggestion.from, to: moved.to, state: moved.lane.state };
-}
 async function runClaudeBalanceMoveTarget(ctx, laneId, opts) {
     const lane = laneWithRecoveredProviderSession(ctx.hqRoot(), readLane(ctx.hqRoot(), laneId));
     assertLaneRunsHereForOperatorMutation(ctx, lane, "balance-move-target");
@@ -8167,1119 +7860,70 @@ function parseOutpostQuestionBody(raw, outpostId, questionId) {
     }
     return parseQuestionBody(raw);
 }
-async function readOutpostQuestionDetail(ctx, owner) {
-    if (owner.lane.host.kind !== "outpost") {
-        throw new LanesError("outpost_question_owner_invalid", `Question ${owner.question.question_id} does not have an Outpost owner`, { question_id: owner.question.question_id, lane_id: owner.lane.lane_id });
-    }
-    const outpostId = owner.lane.host.id;
-    let result;
-    try {
-        result = await ctx.dispatchOutpostExec({
-            outpostId,
-            command: buildOutpostQuestionShowCommand(owner.question.question_id),
-            timeoutSeconds: CAPACITY_PROBE_TIMEOUT_MS / 1000,
-            waitMs: CAPACITY_PROBE_TIMEOUT_MS,
-        });
-    }
-    catch {
-        throw new LanesError("outpost_question_show_unavailable", `Could not read question ${owner.question.question_id} from Outpost ${outpostId}`, { outpost_id: outpostId, question_id: owner.question.question_id });
-    }
-    if (result.done !== true || result.status !== "Success" || result.exitCode !== 0) {
-        throw new LanesError("outpost_question_show_unavailable", `Outpost ${outpostId} did not return question ${owner.question.question_id}`, { outpost_id: outpostId, question_id: owner.question.question_id });
-    }
-    let raw;
-    try {
-        raw = JSON.parse(result.stdout);
-    }
-    catch {
-        throw new LanesError("outpost_question_show_invalid", `Outpost ${outpostId} returned invalid question-show JSON`, { outpost_id: outpostId, question_id: owner.question.question_id });
-    }
-    if (raw === null ||
-        typeof raw !== "object" ||
-        Array.isArray(raw) ||
-        raw.ok !== true ||
-        raw.action !== "questions.show" ||
-        !Object.prototype.hasOwnProperty.call(raw, "body")) {
-        throw new LanesError("outpost_question_show_invalid", `Outpost ${outpostId} returned a malformed question-show response`, { outpost_id: outpostId, question_id: owner.question.question_id });
-    }
-    const response = raw;
-    let question;
-    try {
-        question = parseQuestionRecord(response.question);
-    }
-    catch {
-        throw new LanesError("outpost_question_show_invalid", `Outpost ${outpostId} returned an invalid question record`, { outpost_id: outpostId, question_id: owner.question.question_id });
-    }
-    if (question.question_id !== owner.question.question_id ||
-        question.lane_id !== owner.lane.lane_id) {
-        throw new LanesError("outpost_question_company_mismatch", `Outpost ${outpostId} returned question ${owner.question.question_id} for a different lane or company`, { outpost_id: outpostId, question_id: owner.question.question_id });
-    }
-    assertQuestionCompanyMatchesLane(question, owner.lane, "outpost_question_company_mismatch", ctx.hqRoot());
-    const audience = parseOutpostQuestionAudience(response.audience, outpostId, 0);
-    const body = parseOutpostQuestionBody(response.body, outpostId, question.question_id);
-    return { question, audience, body };
-}
-async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
-    const hostedLanes = loadAllLanes(hqRoot).filter((lane) => lane.host.kind === "outpost" &&
-        (!companyFilter ||
-            effectiveLaneQuestionCompany(lane, hqRoot) === null ||
-            questionCompanyRefMatches(effectiveLaneQuestionCompany(lane, hqRoot), companyFilter)));
-    const lanesByOutpost = new Map();
-    for (const lane of hostedLanes) {
-        if (lane.host.kind !== "outpost")
-            continue;
-        const lanes = lanesByOutpost.get(lane.host.id) ?? [];
-        lanes.push(lane);
-        lanesByOutpost.set(lane.host.id, lanes);
-    }
-    const questions = [];
-    const errors = [];
-    const eligibleGroups = [];
-    for (const [outpostId, lanes] of [...lanesByOutpost.entries()].sort(([a], [b]) => a.localeCompare(b))) {
-        for (const group of groupQuestionLanesByCompany(hqRoot, lanes, companyFilter)) {
-            if (group.company === null) {
-                errors.push({
-                    host: `outpost:${outpostId}`,
-                    error: "outpost_question_company_unavailable",
-                });
-                continue;
-            }
-            if (companyFilter && !questionCompanyRefMatches(group.company, companyFilter))
-                continue;
-            eligibleGroups.push({ outpostId, group });
-        }
-    }
-    if (eligibleGroups.length === 0) {
-        return { questions, errors: [...new Map(errors.map((entry) => [entry.host, entry])).values()] };
-    }
-    let knownOutpostIds;
+function writeAnswerDeliveryFailed(hqRoot, laneId, questionId, err, at) {
+    const failure = {
+        schema_version: "hq-lane-ask-delivery-failed.v1",
+        at,
+        lane_id: laneId,
+        question_id: questionId,
+        error: err instanceof Error
+            ? { name: err.name, message: err.message }
+            : { name: "Error", message: String(err) },
+    };
     try {
-        knownOutpostIds = await ctx.listOutpostIds();
-    }
-    catch {
-        return {
-            questions,
-            errors: [...new Map([
-                    ...errors,
-                    ...[...new Set(eligibleGroups.map(({ outpostId }) => outpostId))].map((outpostId) => ({
-                        host: `outpost:${outpostId}`,
-                        error: "outpost_list_unavailable",
-                    })),
-                ].map((entry) => [entry.host, entry])).values()],
-        };
+        writeJsonFile(askDeliveryFailedPath(hqRoot, laneId), failure);
     }
-    const normalizedOutpostIds = knownOutpostIds.map((id) => typeof id === "string" ? id.trim() : "");
-    if (knownOutpostIds.length > MAX_PLACEMENT_OUTPOSTS ||
-        normalizedOutpostIds.some((id) => id === "") ||
-        new Set(normalizedOutpostIds).size !== normalizedOutpostIds.length) {
-        throw new LanesError("outpost_list_invalid", "Outpost list is malformed or exceeds the placement limit", { count: knownOutpostIds.length, maximum: MAX_PLACEMENT_OUTPOSTS });
+    catch (writeErr) {
+        process.stderr.write(`hq lanes: failed to write ask_delivery_failed for ${laneId}: ${writeErr instanceof Error ? writeErr.message : String(writeErr)}\n`);
     }
-    const knownOutpostIdSet = new Set(normalizedOutpostIds);
-    const loadedGroups = await mapWithConcurrency(eligibleGroups, OUTPOST_QUESTION_LOOKUP_CONCURRENCY, async ({ outpostId, group }) => {
-        if (!knownOutpostIdSet.has(outpostId)) {
-            return {
-                questions: [],
-                errors: [{ host: `outpost:${outpostId}`, error: "unknown_outpost" }],
-            };
-        }
-        try {
-            const remoteQuestions = await readOutpostQuestionRecords(ctx, outpostId, group.company);
-            const localLanesById = new Map(group.lanes.map((lane) => [lane.lane_id, lane]));
-            const groupQuestions = [];
-            const seenQuestionIds = new Set();
-            for (const { question, audience } of remoteQuestions) {
-                const lane = localLanesById.get(question.lane_id);
-                if (!lane)
-                    continue;
-                assertQuestionCompanyMatchesLane(question, lane, "outpost_question_company_mismatch", hqRoot);
-                if (seenQuestionIds.has(question.question_id)) {
-                    throw new LanesError("outpost_question_list_invalid", `Outpost ${outpostId} returned a duplicate question id`, { outpost_id: outpostId, question_id: question.question_id });
-                }
-                seenQuestionIds.add(question.question_id);
-                groupQuestions.push({
-                    question,
-                    lane,
-                    host: `outpost:${outpostId}`,
-                    audience,
-                });
-            }
-            return { questions: groupQuestions, errors: [] };
-        }
-        catch (err) {
-            return {
-                questions: [],
-                errors: [{
-                        host: `outpost:${outpostId}`,
-                        error: isLanesError(err) ? err.error : "outpost_question_list_unavailable",
-                    }],
-            };
-        }
+}
+/**
+ * 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) {
+    const fromEnv = ctx.env.HQ_ROOT?.trim();
+    const hqRoot = fromEnv && ctx.existsSync(fromEnv) ? fromEnv : ctx.hqRoot();
+    const summary = await runReconcilePass(hqRoot, {
+        now: ctx.now,
+        host: reconcileHostFromCtx(ctx),
+        dryRun: Boolean(opts.dryRun),
+        spawnLaneDeps: {
+            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,
+        },
+        throttleDeps: ctx.throttleDeps,
+        livenessDeps: livenessDepsFromCtx(ctx),
+        presenceConnected: ctx.presenceConnected,
+        resolveQuestionActiveCompany: () => resolveActiveQuestionCompany(ctx),
+        recoverQueuedMessages: async (lane) => {
+            await recoverQueuedMessages(ctx, lane.lane_id);
+        },
+        mesh: ctx.mesh,
+        env: ctx.env,
     });
-    questions.push(...loadedGroups.flatMap(({ questions: groupQuestions }) => groupQuestions));
-    errors.push(...loadedGroups.flatMap(({ errors: groupErrors }) => groupErrors));
-    return {
-        questions,
-        errors: [...new Map(errors.map((entry) => [entry.host, entry])).values()],
-    };
+    printJson(summary);
+    if (!summary.ok) {
+        process.exit(1);
+    }
 }
-function syncPrimaryQuestionDelivery(hqRoot, owner) {
-    const deliveredAt = owner.question.delivered_at;
-    if (!deliveredAt)
-        return;
-    try {
-        casUpdateQuestion(hqRoot, owner.question.question_id, (current) => {
-            if (current.lane_id !== owner.lane.lane_id) {
-                throw new LanesError("outpost_question_sync_conflict", `Primary question ${current.question_id} belongs to a different lane than its Outpost owner`, { lane_id: owner.lane.lane_id, question_id: current.question_id });
-            }
-            if (current.company !== null &&
-                owner.question.company !== null &&
-                !sameQuestionCompany(current.company, owner.question.company)) {
-                throw new LanesError("outpost_question_sync_conflict", `Primary question ${current.question_id} belongs to a different company than its Outpost owner`, { lane_id: owner.lane.lane_id, question_id: current.question_id });
-            }
-            const company = current.company ?? owner.question.company;
-            const nextDeliveredAt = current.delivered_at ?? deliveredAt;
-            return company === current.company && nextDeliveredAt === current.delivered_at
-                ? current
-                : { ...current, company, delivered_at: nextDeliveredAt };
-        });
-    }
-    catch (err) {
-        if (isLanesError(err) && err.error === "question_not_found")
-            return;
-        throw err;
-    }
-}
-async function runQuestionsList(ctx, opts) {
-    const hqRoot = ctx.hqRoot();
-    const status = opts.status ? parseQuestionStatus(opts.status) : undefined;
-    const forFilter = opts.for ? parseForFilter(opts.for, ctx) : undefined;
-    const company = opts.company
-        ? await ctx.resolveCompany(opts.company)
-        : await resolveActiveQuestionCompany(ctx, "Cannot access lane questions because the active HQ company could not be resolved; re-run with --company <slug>");
-    const localLanes = new Map(loadAllLanes(hqRoot).map((lane) => [lane.lane_id, lane]));
-    const targeted = opts.from !== undefined || opts.project !== undefined || opts.story !== undefined;
-    const localQuestions = loadAllQuestions(hqRoot)
-        .filter((q) => {
-        if (status && q.status !== status)
-            return false;
-        if (opts.from && q.lane_id !== opts.from && q.origin.id !== opts.from)
-            return false;
-        if (opts.project && q.project_id !== opts.project)
-            return false;
-        if (opts.story && q.story_id !== opts.story)
-            return false;
-        const lane = localLanes.get(q.lane_id);
-        if (lane)
-            assertQuestionCompanyMatchesLane(q, lane, "question_company_mismatch", hqRoot);
-        const questionCompany = lane ? questionCompanyForLane(q, lane, hqRoot) : q.company;
-        if (questionCompany !== null && !sameQuestionCompany(questionCompany, company)) {
-            if (targeted) {
-                throw new LanesError("question_company_mismatch", `Question ${q.question_id} does not belong to the requested or active company`, { question_id: q.question_id, lane_id: q.lane_id });
-            }
-            return false;
-        }
-        if (forFilter) {
-            const audience = resolveAudience(hqRoot, q, ctx);
-            if (!audienceMatches(audience, forFilter))
-                return false;
-        }
-        return true;
-    });
-    const outpostLoad = opts.allHosts
-        ? await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company)
-        : { questions: [], errors: [] };
-    for (const owner of outpostLoad.questions) {
-        assertQuestionCompanyAccess(owner.question, owner.lane, company, hqRoot);
-        syncPrimaryQuestionDelivery(hqRoot, owner);
-    }
-    const remoteQuestionIds = new Set(outpostLoad.questions.map(({ question }) => question.question_id));
-    const questions = [
-        ...localQuestions
-            .filter((q) => !remoteQuestionIds.has(q.question_id))
-            .map((q) => {
-            const row = {
-                ...q,
-                audience: resolveAudience(hqRoot, q, ctx),
-                ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
-            };
-            if (!opts.allHosts)
-                return row;
-            const lane = localLanes.get(q.lane_id);
-            const host = lane?.host.kind === "outpost" ? `outpost:${lane.host.id}` : "local";
-            return { ...row, host };
-        }),
-        ...outpostLoad.questions
-            .filter(({ question: q, lane, audience }) => {
-            if (status && q.status !== status)
-                return false;
-            if (opts.from && q.lane_id !== opts.from && q.origin.id !== opts.from)
-                return false;
-            if (opts.project && q.project_id !== opts.project)
-                return false;
-            if (opts.story && q.story_id !== opts.story)
-                return false;
-            assertQuestionCompanyAccess(q, lane, company, hqRoot);
-            if (forFilter) {
-                if (!audienceMatches(audience, forFilter))
-                    return false;
-            }
-            return true;
-        })
-            .map(({ question: q, host, audience }) => ({
-            ...q,
-            host,
-            audience,
-            ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
-        })),
-    ];
-    printJson({
-        ok: true,
-        action: "questions.list",
-        questions,
-        ...(outpostLoad.errors.length > 0 ? { errors: outpostLoad.errors } : {}),
-    });
-}
-async function runQuestionsShow(ctx, questionId) {
-    const hqRoot = ctx.hqRoot();
-    let question;
-    try {
-        question = readQuestion(hqRoot, questionId);
-    }
-    catch (err) {
-        if (!isLanesError(err) || err.error !== "question_not_found")
-            throw err;
-        const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot);
-        if (lookup.errors.length > 0) {
-            throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
-                question_id: questionId,
-                hosts: lookup.errors.map(({ host, error }) => ({ host, error })),
-            });
-        }
-        const matches = lookup.questions.filter((entry) => entry.question.question_id === questionId);
-        if (matches.length === 0) {
-            throw new LanesError("question_not_found", `Question ${questionId} not found on this primary or its Outposts`, { question_id: questionId });
-        }
-        if (matches.length > 1) {
-            throw new LanesError("outpost_question_ambiguous", `Question ${questionId} is present on more than one Outpost`, { question_id: questionId, owner_count: matches.length });
-        }
-        const owner = matches[0];
-        if (!owner) {
-            throw new LanesError("outpost_question_ambiguous", `Question ${questionId} has no unique Outpost owner`, { question_id: questionId });
-        }
-        const detail = await readOutpostQuestionDetail(ctx, owner);
-        printJson({
-            ok: true,
-            action: "questions.show",
-            question: detail.question,
-            audience: detail.audience,
-            body: detail.body,
-            host: owner.host,
-        });
-        return;
-    }
-    const body = readQuestionBody(hqRoot, question);
-    printJson({
-        ok: true,
-        action: "questions.show",
-        question,
-        audience: resolveAudience(hqRoot, question, ctx),
-        body,
-    });
-}
-async function runQuestionsAnswer(ctx, questionId, opts) {
-    const hqRoot = ctx.hqRoot();
-    if (opts.choice !== undefined)
-        assertNoSecretText("answer choice", opts.choice);
-    if (opts.freeform !== undefined)
-        assertNoSecretText("freeform answer", opts.freeform);
-    if (opts.notes !== undefined)
-        assertNoSecretText("answer notes", opts.notes);
-    const explicitCompany = opts.company ? await ctx.resolveCompany(opts.company) : undefined;
-    let question;
-    try {
-        question = readQuestion(hqRoot, questionId);
-    }
-    catch (err) {
-        if (!isLanesError(err) || err.error !== "question_not_found")
-            throw err;
-        const company = explicitCompany ?? await resolveActiveQuestionCompany(ctx, "Cannot look up this lane question because the active HQ company could not be resolved; re-run with --company <slug>");
-        const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company);
-        if (lookup.errors.length > 0) {
-            throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
-                question_id: questionId,
-                hosts: lookup.errors.map(({ host, error }) => ({ host, error })),
-            });
-        }
-        const matches = lookup.questions.filter((entry) => entry.question.question_id === questionId);
-        if (matches.length === 0) {
-            const allCompanyLookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot);
-            const otherCompanyMatch = allCompanyLookup.questions.find((entry) => entry.question.question_id === questionId);
-            if (otherCompanyMatch) {
-                assertQuestionCompanyAccess(otherCompanyMatch.question, otherCompanyMatch.lane, company, hqRoot);
-            }
-            if (allCompanyLookup.errors.length > 0) {
-                throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
-                    question_id: questionId,
-                    hosts: allCompanyLookup.errors.map(({ host, error }) => ({ host, error })),
-                });
-            }
-            throw new LanesError("question_not_found", `Question ${questionId} not found on this primary or its Outposts`, { question_id: questionId });
-        }
-        if (matches.length > 1) {
-            throw new LanesError("outpost_question_ambiguous", `Question ${questionId} is present on more than one Outpost`, { question_id: questionId, owner_count: matches.length });
-        }
-        const owner = matches[0];
-        if (!owner) {
-            throw new LanesError("question_not_found", `Question ${questionId} not found on this primary or its Outposts`, { question_id: questionId });
-        }
-        assertQuestionCompanyAccess(owner.question, owner.lane, company, hqRoot);
-        const ownerCompany = await resolveQuestionCompanyWithFallback(hqRoot, owner.lane, async () => explicitCompany ?? company);
-        assertQuestionCompanyResolvedForAnswer(owner.question, owner.lane, hqRoot, ownerCompany);
-        throwIfQuestionNotPending(owner.question);
-        await yieldEventLoop();
-        await dispatchOutpostQuestionAnswer(ctx, owner.lane, questionId, {
-            ...opts,
-            company: questionListCompanyArg(ownerCompany),
-        });
-        return;
-    }
-    await yieldEventLoop();
-    const askingLane = readLane(hqRoot, laneIdForAnswerDelivery(question));
-    const resolvedCompany = await resolveQuestionCompanyWithFallback(hqRoot, askingLane, async () => explicitCompany ?? question.company ?? await resolveActiveQuestionCompany(ctx, `Cannot answer legacy question ${questionId}: its company cannot be resolved from the question or lane; re-run with --company <slug>`));
-    const requestedCompany = explicitCompany ?? resolvedCompany;
-    assertQuestionCompanyAccess(question, askingLane, requestedCompany, hqRoot);
-    assertQuestionCompanyResolvedForAnswer(question, askingLane, hqRoot, resolvedCompany);
-    const questionCompany = question.company ?? effectiveLaneQuestionCompany(askingLane, hqRoot) ?? resolvedCompany;
-    const questionForBody = question.company === null
-        ? { ...question, company: questionCompany }
-        : question;
-    if (askingLane.host.kind === "outpost" && !laneIsHostedHere(ctx, askingLane)) {
-        await dispatchOutpostQuestionAnswer(ctx, askingLane, questionId, {
-            ...opts,
-            company: questionListCompanyArg(questionCompany),
-        });
-        return;
-    }
-    throwIfQuestionNotPending(question);
-    if (askingLane.state === "awaiting_input") {
-        assertLaneRunsHereForOperatorMutation(ctx, askingLane, "wake after answering");
-    }
-    if (laneAcceptsDropboxDelivery(askingLane)) {
-        assertLaneRunsHereForOperatorMutation(ctx, askingLane, "deliver an answer to");
-    }
-    const body = requireQuestionBody(hqRoot, questionForBody);
-    // A trimmed-empty --freeform is absent: it must not win over --choice and
-    // must not become a freeform answer of "".
-    const freeform = opts.freeform?.trim() || undefined;
-    if (freeform !== undefined && body.options.length === 0) {
-        throw new LanesError("freeform_not_allowed", "--freeform is only allowed for a question with options", { question_id: questionId });
-    }
-    if (!freeform && !opts.choice) {
-        throw new LanesError("missing_choice", "--choice or --freeform is required", {});
-    }
-    const choice = freeform ?? resolveAnswerChoice(opts.choice, body.options, false);
-    const at = ctx.now().toISOString();
-    const answeredBy = sessionIdFromEnv(ctx.env)
-        ? `session:${sessionIdFromEnv(ctx.env)}`
-        : "user";
-    const updated = casUpdateQuestion(hqRoot, questionId, (current) => {
-        throwIfQuestionNotPending(current);
-        assertQuestionCompanyAccess(current, askingLane, requestedCompany, hqRoot);
-        const recordedCompany = current.company ?? questionCompany;
-        const currentForBody = current.company === null
-            ? { ...current, company: recordedCompany }
-            : current;
-        let notesRef;
-        let nextBody = current.body;
-        if (opts.notes) {
-            const stored = writeQuestionBody(hqRoot, currentForBody, {
-                ...body,
-                notes: opts.notes,
-            });
-            notesRef = stored.ref;
-            nextBody = stored;
-        }
-        return {
-            ...current,
-            company: recordedCompany,
-            body: nextBody,
-            status: "answered",
-            answer: {
-                choice,
-                answer_kind: freeform ? "freeform" : "option",
-                notes_ref: notesRef,
-                answered_by: answeredBy,
-                answered_at: at,
-                answered_level: current.hop,
-            },
-        };
-    });
-    const latestAskingLane = readLane(hqRoot, askingLane.lane_id);
-    if (latestAskingLane.state === "awaiting_input") {
-        let wake;
-        try {
-            wake = await wakeAnsweredLaneNow(hqRoot, askingLane.lane_id, {
-                now: ctx.now,
-                host: reconcileHostFromCtx(ctx),
-                dryRun: false,
-                spawnLaneDeps: {
-                    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,
-                },
-                throttleDeps: ctx.throttleDeps,
-                livenessDeps: livenessDepsFromCtx(ctx),
-                presenceConnected: ctx.presenceConnected,
-                mesh: ctx.mesh,
-                env: ctx.env,
-            });
-        }
-        catch (err) {
-            throw new LanesError("question_wake_failed", `Question ${questionId} was recorded, but lane ${askingLane.lane_id} could not be woken: ${dispatchErrorMessage(err)}`, { lane_id: askingLane.lane_id, question_id: questionId });
-        }
-        if (wake.status === "failed") {
-            throw new LanesError("question_wake_failed", `Question ${questionId} was recorded, but lane ${askingLane.lane_id} could not be woken: ${wake.error}`, { lane_id: askingLane.lane_id, question_id: questionId, wake_error: wake.error });
-        }
-        printJson({
-            ok: true,
-            action: "questions.answer",
-            lane_id: askingLane.lane_id,
-            question: updated,
-            delivery: wake.status === "awaiting_answers" ? "awaiting_other_answers" : wake.status,
-            wake_status: wake.status,
-            lane_state: wake.lane_state,
-            ...(wake.queued_reason !== undefined ? { queued_reason: wake.queued_reason } : {}),
-            ...(wake.remaining_question_ids !== undefined
-                ? { remaining_question_ids: wake.remaining_question_ids }
-                : {}),
-        });
-        return;
-    }
-    const delivery = deliverAnswerToAskingLane(ctx, updated, choice, at);
-    printJson({
-        ok: true,
-        action: "questions.answer",
-        question: updated,
-        delivery: delivery.status,
-    });
-}
-function writeAnswerDeliveryFailed(hqRoot, laneId, questionId, err, at) {
-    const failure = {
-        schema_version: "hq-lane-ask-delivery-failed.v1",
-        at,
-        lane_id: laneId,
-        question_id: questionId,
-        error: err instanceof Error
-            ? { name: err.name, message: err.message }
-            : { name: "Error", message: String(err) },
-    };
-    try {
-        writeJsonFile(askDeliveryFailedPath(hqRoot, laneId), failure);
-    }
-    catch (writeErr) {
-        process.stderr.write(`hq lanes: failed to write ask_delivery_failed for ${laneId}: ${writeErr instanceof Error ? writeErr.message : String(writeErr)}\n`);
-    }
-}
-/**
- * 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.
- */
-function deliverAnswerToAskingLane(ctx, question, choice, at) {
-    const hqRoot = ctx.hqRoot();
-    const laneId = laneIdForAnswerDelivery(question);
-    try {
-        const lane = readLane(hqRoot, laneId);
-        if (!laneAcceptsDropboxDelivery(lane)) {
-            return { status: "recorded_only" };
-        }
-        assertLaneRunsHereForOperatorMutation(ctx, lane, "deliver an answer to");
-        appendDropboxMessage(hqRoot, laneId, answerDropboxMessage(question, choice, at, mintMessageId()));
-        return { status: "awaiting_next_tool_call" };
-    }
-    catch (err) {
-        writeAnswerDeliveryFailed(hqRoot, laneId, question.question_id, err, at);
-        return { status: "failed" };
-    }
-}
-async function runQuestionsEscalate(ctx, questionId, opts) {
-    const hqRoot = ctx.hqRoot();
-    const question = readQuestion(hqRoot, questionId);
-    throwIfQuestionNotPending(question);
-    await yieldEventLoop();
-    const originalHop = question.hop;
-    const audience = resolveAudience(hqRoot, question, ctx);
-    if (audience.kind === "user") {
-        throw new LanesError("already_at_top_authority", "Cannot escalate past the user", { question_id: questionId });
-    }
-    const at = ctx.now().toISOString();
-    if (opts.note) {
-        requireQuestionBody(hqRoot, question);
-    }
-    const updated = casUpdateQuestion(hqRoot, questionId, (current) => {
-        throwIfQuestionNotPending(current);
-        if (current.hop !== originalHop) {
-            throw new LanesError("question_already_escalated", `Question ${questionId} hop already advanced`, {
-                question_id: questionId,
-                hop: current.hop,
-                expected_hop: originalHop,
-            });
-        }
-        let nextBody = current.body;
-        if (opts.note) {
-            const body = requireQuestionBody(hqRoot, current);
-            nextBody = writeQuestionBody(hqRoot, current, {
-                ...body,
-                notes: [body.notes, opts.note].filter(Boolean).join("\n"),
-            });
-        }
-        const nextHop = current.hop + 1;
-        return {
-            ...current,
-            body: nextBody,
-            hop: nextHop,
-            routing_history: appendCappedHistory(current.routing_history, {
-                hop: nextHop,
-                audience: resolveAudience(hqRoot, { ...current, hop: nextHop }, ctx),
-                at,
-                reason: "escalated",
-            }),
-        };
-    });
-    const nextAudience = resolveAudience(hqRoot, updated, ctx);
-    if (nextAudience.kind === "user") {
-        const lane = readLane(hqRoot, updated.lane_id);
-        await emitLaneMeshEvent(ctx, lane.mesh_company ?? lane.company, lane.thread_id, "lane_question_at_user", { lane_id: lane.lane_id, question_id: updated.question_id });
-    }
-    printJson({ ok: true, action: "questions.escalate", question: updated });
-}
-async function runQuestionsCancel(ctx, questionId, opts) {
-    const hqRoot = ctx.hqRoot();
-    const question = readQuestion(hqRoot, questionId);
-    throwIfQuestionNotPending(question);
-    await yieldEventLoop();
-    const at = ctx.now().toISOString();
-    const updated = casUpdateQuestion(hqRoot, questionId, (current) => {
-        throwIfQuestionNotPending(current);
-        const entry = {
-            hop: current.hop,
-            audience: resolveAudience(hqRoot, current, ctx),
-            at,
-            reason: "cancelled",
-            ...(opts.reason ? { detail: opts.reason } : {}),
-        };
-        return {
-            ...current,
-            status: "cancelled",
-            routing_history: appendCappedHistory(current.routing_history, entry),
-        };
-    });
-    printJson({ ok: true, action: "questions.cancel", question: updated });
-}
-async function runAccountsList(ctx, opts) {
-    const hqRoot = ctx.hqRoot();
-    const config = loadLanesConfig(hqRoot);
-    const providers = opts.provider
-        ? [parseLaneProvider(opts.provider)]
-        : [...LANE_PROVIDERS];
-    // model and effort are what a spawn on each account would start from
-    // (spec: --model/--effort, then the account, then the provider).
-    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) => {
-        const accountCfg = config.providers[provider].accounts[status.id];
-        const model = resolveLaneModel({
-            accountModel: accountCfg?.model,
-            providerModel: config.providers[provider].model,
-        });
-        const effort = resolveLaneEffort({
-            accountEffort: accountCfg?.effort,
-            providerEffort: config.providers[provider].effort,
-            model,
-        });
-        return {
-            ...status,
-            effective_home: status.home,
-            model: accountCfg?.model ?? null,
-            effort: accountCfg?.effort ?? null,
-            effective_model: model ?? null,
-            effective_effort: effort.effort ?? null,
-            effective_effort_source: effort.source,
-            ...accountQuotaView(quota, provider, status.id),
-        };
-    }));
-    const providerDefaults = providers.map((provider) => ({
-        provider,
-        model: config.providers[provider].model ?? null,
-        effort: config.providers[provider].effort ?? null,
-        compact_after_ms: providerCompactAfterMs(config.providers[provider]),
-    }));
-    printJson({
-        ok: true,
-        action: "accounts.list",
-        providers: providerDefaults,
-        accounts,
-    });
-}
-async function runAccountsBalance(ctx, opts) {
-    const provider = parseLaneProvider(opts.provider ?? "");
-    if (provider !== "claude") {
-        throw new LanesError("claude_account_balance_provider_unsupported", "Account balance is available only for --provider claude", {
-            provider,
-            accepted: ["claude"],
-        });
-    }
-    const hqRoot = ctx.hqRoot();
-    const config = loadLanesConfig(hqRoot);
-    const loaded = await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config);
-    // Retain the established response field for clients; balancing is now
-    // unconditional, so this compatibility value is always true.
-    const balanceGateEnabled = true;
-    const loads = accountLoadsForReport({ hosts: loaded.snapshots, config });
-    const suggestions = planClaudeBalanceMoves({ hosts: loaded.snapshots, config });
-    const selections = loaded.snapshots.map((host) => {
-        try {
-            const selection = selectClaudeAccount({
-                hosts: loaded.snapshots,
-                targetHost: host.capacity.host,
-                config,
-                unavailableHosts: loaded.unavailableHosts,
-            });
-            return {
-                target_host: host.capacity.host,
-                account: selection.account,
-                signal: selection.signal,
-                skipped_accounts: selection.skipped_accounts,
-            };
-        }
-        catch (err) {
-            return {
-                target_host: host.capacity.host,
-                error: isLanesError(err) ? err.error : "claude_account_balance_selection_failed",
-                message: dispatchErrorMessage(err),
-            };
-        }
-    });
-    const accounts = Object.keys(config.providers.claude.accounts).sort().map((account) => {
-        const load = loads.find((row) => row.account === account);
-        return {
-            account,
-            enabled: config.providers.claude.accounts[account]?.enabled === true,
-            live_lanes: load?.live_lanes ?? 0,
-            counts_complete: load?.counts_complete ?? false,
-            hosts: loaded.snapshots.map((host) => {
-                const accountStatus = host.capacity.providers.claude.accounts[account];
-                const accountLoad = load?.hosts.find((row) => row.host.kind === host.capacity.host.kind && row.host.id === host.capacity.host.id);
-                return {
-                    host: host.capacity.host,
-                    enabled: accountStatus?.enabled ?? false,
-                    logged_in: accountStatus?.logged_in ?? null,
-                    live_lanes: accountLoad?.live_lanes ?? null,
-                    lane_counts: accountLoad?.lane_counts ?? { running: null, queued: null, awaiting_input: null },
-                    count_source: accountLoad?.count_source ?? "unavailable",
-                    usage: accountStatus?.usage ?? null,
-                };
-            }),
-        };
-    });
-    const moved = [];
-    const skipped = [];
-    if (opts.apply) {
-        for (const suggestion of suggestions) {
-            if (!suggestion.apply) {
-                skipped.push({
-                    lane_id: suggestion.lane_id,
-                    host: suggestion.host,
-                    from: suggestion.from,
-                    to: suggestion.to,
-                    reason: suggestion.skip_reason ?? "not_movable",
-                });
-                continue;
-            }
-            try {
-                moved.push(await applyClaudeBalanceMove(ctx, suggestion));
-            }
-            catch (err) {
-                skipped.push({
-                    lane_id: suggestion.lane_id,
-                    host: suggestion.host,
-                    from: suggestion.from,
-                    to: suggestion.to,
-                    reason: isLanesError(err) ? `${err.error}: ${err.message}` : dispatchErrorMessage(err),
-                });
-            }
-        }
-    }
-    printJson({
-        ok: true,
-        action: "accounts.balance",
-        provider: "claude",
-        balance_gate_enabled: balanceGateEnabled,
-        accounts,
-        selections,
-        unavailable_hosts: loaded.unavailableHosts,
-        suggestions,
-        ...(opts.apply ? { moved, skipped } : {}),
-    });
-}
-async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
-    const callerCwd = ctx.callerCwd();
-    const hqRoot = ctx.hqRoot();
-    const provider = parseLaneProvider(providerRaw);
-    const config = loadLanesConfig(hqRoot);
-    const id = accountId.trim();
-    if (!id) {
-        throw new LanesError("invalid_account", "account-id must be non-empty", {});
-    }
-    if (opts.deviceAuth && provider !== "codex") {
-        throw new LanesError("device_auth_unsupported", "--device-auth is supported only for codex account login", { provider });
-    }
-    const registeredAccount = config.providers[provider].accounts[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 });
-    }
-    if (opts.company !== undefined) {
-        await resolveSelectedAccountHomeCompany(ctx, opts.company);
-    }
-    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);
-    const home = canonicalizeHome(homeResolved, {
-        homedir: ctx.homedir,
-        realpathSync: (p) => fs.realpathSync(p),
-        existsSync: (p) => fs.existsSync(p),
-    });
-    const nextAccount = registeredAccount === undefined
-        ? { home, enabled: true }
-        : { ...registeredAccount, enabled: true };
-    if (registeredAccount !== undefined && 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 },
-            };
-        }
-    }
-    delete nextAccount.disabled_reason;
-    assertUniqueAccountHomes(provider, {
-        ...config.providers[provider].accounts,
-        [id]: nextAccount,
-    });
-    ensureDir(home);
-    const defaultId = config.providers[provider].default_account;
-    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) ??
-        canonicalizeHome(DEFAULT_ACCOUNT_HOMES[provider], {
-            homedir: ctx.homedir,
-            realpathSync: (p) => fs.realpathSync(p),
-            existsSync: (p) => fs.existsSync(p),
-        });
-    const copied = defaultHome !== home ? copyHookRails(defaultHome, home) : railsPresent(home);
-    installDrainHook(provider, home);
-    const envVar = PROVIDER_HOME_ENV[provider];
-    const login = VENDOR_LOGIN[provider];
-    const loginArgs = provider === "codex" && opts.deviceAuth
-        ? [...login.args, "--device-auth"]
-        : login.args;
-    const result = await ctx.spawnLogin({
-        command: login.command,
-        args: loginArgs,
-        env: { ...ctx.env, [envVar]: home },
-        cwd: home,
-    });
-    if (result.status !== 0) {
-        throw new LanesError("login_failed", `${login.command} ${loginArgs.join(" ")} exited ${result.status}`, { provider, account: id, status: result.status });
-    }
-    const grokNeedsRails = provider === "grok";
-    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] = nextAccount;
-    const status = accountStatus(provider, id, config, {
-        existsSync: ctx.existsSync,
-        hostname,
-        probe: ctx.probeProvider,
-        env: ctx.env,
-    });
-    if (status.logged_in !== true) {
-        throw new LanesError(status.logged_in === false ? "account_not_logged_in" : "account_login_status_unknown", status.logged_in === false
-            ? `Account ${id} for ${provider} is not logged in`
-            : `Could not verify that account ${id} for ${provider} is logged in`, { provider, account: id, home });
-    }
-    writeLanesConfig(hqRoot, config);
-    printJson({ ok: true, action: "accounts.login", account: status });
-}
-async function runAccountsSetHome(ctx, providerRaw, accountIdRaw, homeRaw, opts) {
-    if (opts.company !== undefined)
-        await resolveSelectedAccountHomeCompany(ctx, opts.company);
-    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);
-    const config = loadLanesConfig(hqRoot);
-    const account = config.providers[provider].accounts[accountId];
-    if (!account) {
-        throw new AccountResolutionError("unknown_account", `Unknown account ${JSON.stringify(accountId)} for ${provider}`, {
-            provider,
-            account: accountId,
-            enabled: Object.entries(config.providers[provider].accounts)
-                .filter(([, a]) => a.enabled)
-                .map(([id]) => id),
-        });
-    }
-    const status = accountStatus(provider, accountId, config, {
-        existsSync: ctx.existsSync,
-        hostname: ctx.hostname(),
-        probe: ctx.probeProvider,
-        env: ctx.env,
-    });
-    if (status.logged_in !== true) {
-        throw new LanesError(status.logged_in === false ? "account_not_logged_in" : "account_login_status_unknown", status.logged_in === false
-            ? `Account ${accountId} for ${provider} is not logged in`
-            : `Could not verify that account ${accountId} for ${provider} is logged in`, { provider, account: accountId });
-    }
-    account.enabled = true;
-    delete account.disabled_reason;
-    writeLanesConfig(hqRoot, config);
-    printJson({
-        ok: true,
-        action: "accounts.enable",
-        account: accountStatus(provider, accountId, loadLanesConfig(hqRoot), {
-            existsSync: ctx.existsSync,
-            hostname: ctx.hostname(),
-            probe: ctx.probeProvider,
-            env: ctx.env,
-        }),
-    });
-}
-async function runAccountsDisable(ctx, providerRaw, accountId, opts) {
-    const hqRoot = ctx.hqRoot();
-    const provider = parseLaneProvider(providerRaw);
-    const config = loadLanesConfig(hqRoot);
-    const account = config.providers[provider].accounts[accountId];
-    if (!account) {
-        throw new AccountResolutionError("unknown_account", `Unknown account ${JSON.stringify(accountId)} for ${provider}`, {
-            provider,
-            account: accountId,
-            enabled: Object.entries(config.providers[provider].accounts)
-                .filter(([, a]) => a.enabled)
-                .map(([id]) => id),
-        });
-    }
-    account.enabled = false;
-    if (opts.reason)
-        account.disabled_reason = opts.reason;
-    writeLanesConfig(hqRoot, config);
-    printJson({
-        ok: true,
-        action: "accounts.disable",
-        account: accountStatus(provider, accountId, loadLanesConfig(hqRoot), {
-            existsSync: ctx.existsSync,
-            hostname: ctx.hostname(),
-            probe: ctx.probeProvider,
-            env: ctx.env,
-        }),
-    });
-}
-async function runSessionsList(ctx, opts) {
-    const hqRoot = ctx.hqRoot();
-    const state = opts.state ? parseLivenessState(opts.state) : undefined;
-    const livenessDeps = livenessDepsFromCtx(ctx);
-    const presenceConnected = ctx.presenceConnected ?? readDaemonPresenceConnected(livenessDeps);
-    const rows = listSessionLiveness(hqRoot, {
-        nowMs: ctx.now().getTime(),
-        presenceConnected,
-        deps: livenessDeps,
-    }).filter((row) => {
-        if (state && row.state !== state)
-            return false;
-        if (!opts.company)
-            return true;
-        const meta = readSessionMeta(hqRoot, row.sessionId, ctx);
-        const slug = typeof meta?.company_slug === "string" ? meta.company_slug : "";
-        const uid = typeof meta?.company_uid === "string" ? meta.company_uid : "";
-        return slug === opts.company || uid === opts.company;
-    });
-    printJson({ ok: true, action: "sessions.list", sessions: rows });
-}
-async function runSessionsShow(ctx, sessionId) {
-    const hqRoot = ctx.hqRoot();
-    const livenessDeps = livenessDepsFromCtx(ctx);
-    const presenceConnected = ctx.presenceConnected ?? readDaemonPresenceConnected(livenessDeps);
-    const state = sessionLiveness(hqRoot, sessionId, {
-        nowMs: ctx.now().getTime(),
-        presenceConnected,
-        deps: livenessDeps,
-    });
-    if (state === null) {
-        throw new LanesError("session_not_found", `Session ${sessionId} is not in the liveness index`, { session_id: sessionId });
-    }
-    const meta = readSessionMeta(hqRoot, sessionId, ctx);
-    printJson({
-        ok: true,
-        action: "sessions.show",
-        session_id: sessionId,
-        state,
-        senior: meta ? seniorOfSession(hqRoot, sessionId, ctx) : { kind: "user" },
-        company_slug: typeof meta?.company_slug === "string" ? meta.company_slug : null,
-    });
-}
-async function runReconcile(ctx, opts) {
-    const fromEnv = ctx.env.HQ_ROOT?.trim();
-    const hqRoot = fromEnv && ctx.existsSync(fromEnv) ? fromEnv : ctx.hqRoot();
-    const summary = await runReconcilePass(hqRoot, {
-        now: ctx.now,
-        host: reconcileHostFromCtx(ctx),
-        dryRun: Boolean(opts.dryRun),
-        spawnLaneDeps: {
-            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,
-        },
-        throttleDeps: ctx.throttleDeps,
-        livenessDeps: livenessDepsFromCtx(ctx),
-        presenceConnected: ctx.presenceConnected,
-        resolveQuestionActiveCompany: () => resolveActiveQuestionCompany(ctx),
-        recoverQueuedMessages: async (lane) => {
-            await recoverQueuedMessages(ctx, lane.lane_id);
-        },
-        mesh: ctx.mesh,
-        env: ctx.env,
-    });
-    printJson(summary);
-    if (!summary.ok) {
-        process.exit(1);
-    }
-}
-async function runReconcileInstall(ctx, opts) {
-    // `hq daemon` runs lanes-reconcile on this machine; a separate timer would run it twice.
-    const handedOff = opts.systemdRoot ? null : handOffInstallHere(["lanes-reconcile"]);
-    if (handedOff) {
-        printJson({ ok: true, action: "hq-daemon", message: handedOff });
+async function runReconcileInstall(ctx, opts) {
+    // `hq daemon` runs lanes-reconcile on this machine; a separate timer would run it twice.
+    const handedOff = opts.systemdRoot ? null : handOffInstallHere(["lanes-reconcile"]);
+    if (handedOff) {
+        printJson({ ok: true, action: "hq-daemon", message: handedOff });
         return;
     }
     const callerCwd = ctx.callerCwd();
@@ -9336,6 +7980,53 @@ function attachJsonNoop(cmd) {
 }
 export function registerLanesCommand(parent, deps = {}) {
     const ctx = resolveDeps(deps);
+    const accountHandlers = createLaneAccountsHandlers({
+        automaticBalanceMoveHistoryReason,
+        ensureDir,
+        laneWithRecoveredProviderSession,
+        loadClaudeBalanceHostSnapshots,
+        parseRemoteJson,
+        prepareAccountMove,
+        printJson,
+        reconcileHostFromCtx,
+        resolveCallerPath,
+    });
+    const questionHandlers = createLaneQuestionsHandlers({
+        CAPACITY_PROBE_TIMEOUT_MS,
+        MAX_PLACEMENT_OUTPOSTS,
+        OUTPOST_QUESTION_LOOKUP_CONCURRENCY,
+        assertLaneRunsHereForOperatorMutation,
+        assertQuestionCompanyMatchesLane,
+        casUpdateQuestion,
+        effectiveLaneQuestionCompany,
+        emitLaneMeshEvent,
+        groupQuestionLanesByCompany,
+        isQuestionAnswer,
+        laneIsHostedHere,
+        livenessDepsFromCtx,
+        loadAllLanes,
+        loadAllQuestions,
+        mapWithConcurrency,
+        mintMessageId,
+        parseOutpostQuestionAudience,
+        parseOutpostQuestionBody,
+        parseRemoteJson,
+        parseSeniorRef,
+        questionCompanyForLane,
+        questionCompanyRefMatches,
+        questionListCompanyArg,
+        readOutpostQuestionRecords,
+        readQuestionBody,
+        printJson,
+        readSessionMeta,
+        reconcileHostFromCtx,
+        resolveActiveQuestionCompany,
+        resolveAudience,
+        sameQuestionAnswer,
+        sameQuestionCompany,
+        seniorOfSession,
+        writeAnswerDeliveryFailed,
+    });
     const lanes = parent
         .command("lanes", { hidden: true })
         .description("Create, supervise, and steer worker lanes; routed decision queue");
@@ -9370,7 +8061,7 @@ export function registerLanesCommand(parent, deps = {}) {
         trackerEnabled: ctx.laneTrackerEnabled,
         now: ctx.now,
         readQuestionBody: (root, question) => {
-            const body = requireQuestionBody(root, question);
+            const body = questionHandlers.requireQuestionBody(root, question);
             assertQuestionBodySecretSafe(body);
             return body;
         },
@@ -9743,14 +8434,14 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--story <id>", "Filter by story")
         .option("--status <status>", `Filter by status (${QUESTION_STATUSES.join("|")})`)
         .action(wrap(async (opts) => {
-        await runQuestionsList(ctx, opts);
+        await questionHandlers.runQuestionsList(ctx, opts);
     }));
     questions
         .command("show")
         .description("Show one question")
         .argument("<question-id>", "Question id")
         .action(wrap(async (questionId) => {
-        await runQuestionsShow(ctx, questionId);
+        await questionHandlers.runQuestionsShow(ctx, questionId);
     }));
     questions
         .command("answer")
@@ -9761,7 +8452,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--freeform <text>", "Supply a free-form answer for a question with options")
         .option("--company <slug|uid>", "Require the question lane to match this company")
         .action(wrap(async (questionId, opts) => {
-        await runQuestionsAnswer(ctx, questionId, opts);
+        await questionHandlers.runQuestionsAnswer(ctx, questionId, opts);
     }));
     questions
         .command("escalate")
@@ -9769,7 +8460,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .argument("<question-id>", "Question id")
         .option("--note <text>", "Note recorded with the escalation")
         .action(wrap(async (questionId, opts) => {
-        await runQuestionsEscalate(ctx, questionId, opts);
+        await questionHandlers.runQuestionsEscalate(ctx, questionId, opts);
     }));
     questions
         .command("cancel")
@@ -9777,7 +8468,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .argument("<question-id>", "Question id")
         .option("--reason <text>", "Why it was cancelled")
         .action(wrap(async (questionId, opts) => {
-        await runQuestionsCancel(ctx, questionId, opts);
+        await questionHandlers.runQuestionsCancel(ctx, questionId, opts);
     }));
     const accounts = lanes
         .command("accounts")
@@ -9787,7 +8478,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .description("List accounts")
         .option("--provider <name>", "claude | codex | grok")
         .action(wrap(async (opts) => {
-        await runAccountsList(ctx, opts);
+        await accountHandlers.runAccountsList(ctx, opts);
     }));
     accounts
         .command("balance")
@@ -9796,7 +8487,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--apply", "Move eligible between-turn sessions to balance Claude accounts")
         .option("--json", "JSON on stdout (always)")
         .action(wrap(async (opts) => {
-        await runAccountsBalance(ctx, opts);
+        await accountHandlers.runAccountsBalance(ctx, opts);
     }));
     accounts
         .command("set-home")
@@ -9808,7 +8499,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--company <slug|uid>", "Company scope for account-home validation")
         .option("--json", "JSON on stdout (always)")
         .action(wrap(async (provider, accountId, home, opts) => {
-        await runAccountsSetHome(ctx, provider, accountId, home, opts);
+        await accountHandlers.runAccountsSetHome(ctx, provider, accountId, home, opts);
     }));
     accounts
         .command("login")
@@ -9819,7 +8510,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--company <slug|uid>", "Company scope for account-home validation")
         .option("--device-auth", "Use Codex device authentication instead of localhost callback")
         .action(wrap(async (provider, accountId, opts) => {
-        await runAccountsLogin(ctx, provider, accountId, opts);
+        await accountHandlers.runAccountsLogin(ctx, provider, accountId, opts);
     }));
     accounts
         .command("enable")
@@ -9827,7 +8518,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .argument("<provider>", "claude | codex | grok")
         .argument("<account-id>", "Account id")
         .action(wrap(async (provider, accountId) => {
-        await runAccountsEnable(ctx, provider, accountId);
+        await accountHandlers.runAccountsEnable(ctx, provider, accountId);
     }));
     accounts
         .command("disable")
@@ -9836,7 +8527,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .argument("<account-id>", "Account id")
         .option("--reason <text>", "Why the account is disabled")
         .action(wrap(async (provider, accountId, opts) => {
-        await runAccountsDisable(ctx, provider, accountId, opts);
+        await accountHandlers.runAccountsDisable(ctx, provider, accountId, opts);
     }));
     const sessions = lanes
         .command("sessions")
@@ -9847,14 +8538,14 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--state <state>", `live | idle | ended | lost`)
         .option("--company <slug>", "Filter by session meta company_slug")
         .action(wrap(async (opts) => {
-        await runSessionsList(ctx, opts);
+        await questionHandlers.runSessionsList(ctx, opts);
     }));
     sessions
         .command("show")
         .description("Show one session's liveness")
         .argument("<session-id>", "Session id")
         .action(wrap(async (sessionId) => {
-        await runSessionsShow(ctx, sessionId);
+        await questionHandlers.runSessionsShow(ctx, sessionId);
     }));
     lanes
         .command("pickup", { hidden: true })