@indigoai-us/hq-cli 5.225.0 → 5.227.0

package/dist/commands/lanes.js

@@ -17,6 +17,8 @@ import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
 import { registerLaneTrackerImportCommand } from "./lanes-import.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { createTrackerMeshQuestionClient, deliverTrackerMeshQuestionOnce } from "../lib/lanes/tracker-mesh-questions.js";
+import { createWorkMeshTrackerStore } from "../lib/lanes/tracker-mesh.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
@@ -44,19 +46,20 @@ import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_
 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 { questionBodyAbsPath, questionRecordRefusalCode, 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 { dispatchLaneDelivery } from "../lib/lanes/delivery-core.js";
-import { formatMonitorEvent } from "../lib/lanes/dropbox.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 { 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, stopLaneProcesses, } from "../lib/lanes/spawn.js";
+import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, spawnLaneWorker, laneRunDir, readSpawnManifest, readPidRecord, probePidRecord, readProcStarttime, stopLaneProcesses, } from "../lib/lanes/spawn.js";
 import { handOffInstallHere } from "../lib/daemon/handoff.js";
 export { spawnLaneWorker };
 export { questionBodyAbsPath };
@@ -283,6 +286,8 @@ function resolveDeps(deps = {}) {
         proveDetached: deps.proveDetached,
         killProcess: deps.killProcess,
         isAlive: deps.isAlive,
+        readStarttime: deps.readStarttime,
+        watcherLoopDeps: deps.watcherLoopDeps,
         stopSleepMs: deps.stopSleepMs,
         livenessDeps: deps.livenessDeps,
         presenceConnected: deps.presenceConnected,
@@ -324,6 +329,7 @@ function resolveDeps(deps = {}) {
             ((company) => defaultLaneOutpostQuestionVisibilityEnabled(company, env)),
         laneTrackerEnabled: deps.laneTrackerEnabled ?? defaultLaneTrackerEnabled,
         laneTrackerMeshEnabled: deps.laneTrackerMeshEnabled ?? defaultLaneTrackerMeshEnabled,
+        trackerMeshRequest: deps.trackerMeshRequest,
         laneHostScopedAccountHomesEnabled: deps.laneHostScopedAccountHomesEnabled ??
             ((company) => defaultLaneHostScopedAccountHomesEnabled(company, env)),
         trackerActor: deps.trackerActor ?? defaultTrackerActor,
@@ -513,6 +519,167 @@ function requireQuestionBody(hqRoot, question) {
     }
     return body;
 }
+function trackerMeshAudience(ref) {
+    if (ref.kind === "user")
+        return "owner";
+    if (ref.kind === "session")
+        return "operator";
+    return `lane:${ref.id ?? ""}`;
+}
+function trackerMeshAudienceKind(value) {
+    if (value === "owner" || value.startsWith("owner:"))
+        return "owner";
+    if (value === "operator" || value.startsWith("operator:"))
+        return "operator";
+    return "lane";
+}
+function trackerMeshQuestionInput(lane, question, body) {
+    if (!lane.project_id.trim())
+        throw new LanesError("tracker_mesh_question_invalid", "Question lane has no project id", { lane_id: lane.lane_id });
+    const route = question.routing_history;
+    const currentAudience = route.at(-1)?.audience ?? lane.senior;
+    return {
+        laneId: lane.lane_id,
+        ...(lane.thread_id ? { threadId: lane.thread_id } : {}),
+        projectId: lane.project_id,
+        audience: trackerMeshAudienceKind(trackerMeshAudience(currentAudience)),
+        audienceChain: route.length ? route.map((entry) => trackerMeshAudience(entry.audience)) : [trackerMeshAudience(currentAudience)],
+        routingHistory: route.map((entry) => ({ audience: trackerMeshAudience(entry.audience), at: entry.at, reason: entry.reason })),
+        question: body.question,
+        context: body.context,
+        options: body.options,
+        ...(body.recommended !== undefined ? { recommended: body.recommended } : {}),
+    };
+}
+function assertMeshQuestionMatchesLocal(row, question, company) {
+    if (row.companyUid !== company.uid || row.laneId !== question.lane_id || row.projectId !== question.project_id) {
+        throw new LanesError("tracker_question_company_mismatch", "Work Mesh question does not match the local lane company and project", {
+            question_id: question.question_id,
+            mesh_question_id: row.questionId,
+            lane_id: question.lane_id,
+        });
+    }
+}
+async function indexTrackerQuestion(ctx, hqRoot, lane, question, body, company, client = createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest })) {
+    if (question.mesh_question_id)
+        return question;
+    if (question.status !== "pending")
+        return question;
+    const input = trackerMeshQuestionInput(lane, question, body);
+    const candidates = (await client.list(["pending", "answered"])).filter((row) => row.laneId === input.laneId && row.projectId === input.projectId && row.threadId === (input.threadId ?? row.threadId) &&
+        row.audience === input.audience && row.question === input.question && row.context === input.context &&
+        JSON.stringify(row.options) === JSON.stringify(input.options) &&
+        row.routingHistory.at(-1)?.at === input.routingHistory.at(-1)?.at);
+    if (candidates.length > 1) {
+        throw new LanesError("tracker_mesh_question_ambiguous", "More than one pending Work Mesh question matches this local question", { question_id: question.question_id, lane_id: lane.lane_id });
+    }
+    const row = candidates[0] ?? await client.create(input);
+    assertMeshQuestionMatchesLocal(row, question, company);
+    return casUpdateQuestion(hqRoot, question.question_id, (current) => {
+        if (current.status !== "pending")
+            return current;
+        if (current.mesh_question_id && current.mesh_question_id !== row.questionId) {
+            throw new LanesError("tracker_mesh_question_conflict", "Local question was already linked to another Work Mesh question", { question_id: current.question_id });
+        }
+        return current.mesh_question_id === row.questionId ? current : { ...current, mesh_question_id: row.questionId };
+    });
+}
+async function syncTrackerMeshQuestions(ctx, hqRoot) {
+    if (!ctx.laneTrackerMeshEnabled)
+        return;
+    const lanes = new Map(loadAllLanes(hqRoot).map((lane) => [lane.lane_id, lane]));
+    const byCompany = new Map();
+    for (const lane of lanes.values()) {
+        let company;
+        try {
+            company = await resolveQuestionCompanyWithFallback(hqRoot, lane, () => resolveActiveQuestionCompany(ctx, "Cannot sync lane questions without an HQ company"));
+        }
+        catch (err) {
+            if (lane.company || lane.mesh_company ||
+                !isLanesError(err) || err.error !== "question_company_unavailable" ||
+                err.details.resolution !== "active_company_required")
+                throw err;
+            continue;
+        }
+        if (!await ctx.laneTrackerMeshEnabled(company))
+            continue;
+        const key = `${company.uid}\0${company.slug}`;
+        if (!byCompany.has(key))
+            byCompany.set(key, { company, client: createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest }) });
+    }
+    const localQuestions = loadAllQuestions(hqRoot);
+    for (const question of localQuestions) {
+        if (question.status !== "pending" || question.mesh_question_id)
+            continue;
+        const lane = lanes.get(question.lane_id);
+        if (!lane)
+            continue;
+        const company = question.company ?? lane.company ?? lane.mesh_company;
+        if (!company)
+            continue;
+        const client = byCompany.get(`${company.uid}\0${company.slug}`)?.client;
+        if (!client)
+            continue;
+        const body = requireQuestionBody(hqRoot, question);
+        await indexTrackerQuestion(ctx, hqRoot, lane, question, body, company, client);
+    }
+    for (const { company, client } of byCompany.values()) {
+        const remote = await client.list(["answered"]);
+        const remoteById = new Map(remote.map((row) => [row.questionId, row]));
+        for (const question of loadAllQuestions(hqRoot)) {
+            if (!question.mesh_question_id || question.company?.uid !== company.uid)
+                continue;
+            const row = remoteById.get(question.mesh_question_id);
+            if (!row)
+                continue;
+            assertMeshQuestionMatchesLocal(row, question, company);
+            const lane = lanes.get(question.lane_id);
+            if (!lane)
+                continue;
+            if (row.status === "answered" && question.status === "pending") {
+                if (typeof row.choice !== "string" || typeof row.answeredAt !== "string" || typeof row.answeredBy !== "string") {
+                    throw new LanesError("tracker_mesh_response_invalid", "Answered Work Mesh question is missing its answer fields", { mesh_question_id: row.questionId });
+                }
+                const currentBody = requireQuestionBody(hqRoot, question);
+                let notesRef;
+                let nextBody = question.body;
+                if (row.notes !== undefined) {
+                    const bodyQuestion = question.company || question.body.store === "personal" ? question : { ...question, company };
+                    const stored = writeQuestionBody(hqRoot, bodyQuestion, { ...currentBody, notes: row.notes });
+                    notesRef = stored.ref;
+                    nextBody = stored;
+                }
+                casUpdateQuestion(hqRoot, question.question_id, (current) => {
+                    if (current.status !== "pending")
+                        return current;
+                    if (current.mesh_question_id !== row.questionId)
+                        throw new LanesError("tracker_mesh_question_conflict", "Local question link changed during answer sync", { question_id: current.question_id });
+                    return {
+                        ...current,
+                        company: current.company ?? company,
+                        body: nextBody,
+                        status: "answered",
+                        answer: {
+                            choice: row.choice,
+                            answer_kind: currentBody.options.includes(row.choice) ? "option" : "freeform",
+                            notes_ref: notesRef,
+                            answered_by: row.answeredBy,
+                            answered_at: row.answeredAt,
+                            answered_level: current.hop,
+                        },
+                    };
+                });
+            }
+        }
+        for (const question of loadAllQuestions(hqRoot)) {
+            if (question.company?.uid !== company.uid || !question.mesh_question_id)
+                continue;
+            await deliverTrackerMeshQuestionOnce(question, company, client, (deliveredAt) => casUpdateQuestion(hqRoot, question.question_id, (current) => current.mesh_delivered_at
+                ? current
+                : { ...current, mesh_delivered_at: deliveredAt }));
+        }
+    }
+}
 function loadAllLanes(hqRoot) {
     return listLaneIds(hqRoot).map((id) => readLane(hqRoot, id));
 }
@@ -5552,7 +5719,13 @@ function assertCurrentResumeAccountAvailable(ctx, lane) {
 }
 async function runMessage(ctx, laneId, opts) {
     const hqRoot = ctx.hqRoot();
-    const text = opts.text;
+    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", {});
     }
@@ -5562,330 +5735,498 @@ async function runMessage(ctx, laneId, opts) {
         return;
     }
     assertLaneRunsHereForOperatorMutation(ctx, lane, "message");
-    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);
-    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);
+    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}`;
+                }
+            }
+        }
     }
-    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 } : {}),
-            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 } : {}),
-                    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);
+    try {
+        const exclusion = messageLaneExclusion(ctx, lane);
+        if (exclusion !== undefined) {
+            let messageCount;
+            if (dropboxInboxHasMessages(hqRoot, laneId)) {
+                messageCount = drainDropbox(hqRoot, laneId, { archiveDirectory: "undeliverable" }).length;
             }
-            else {
-                lane = persistClaudeAccountSelection(hqRoot, lane, selection);
+            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);
             }
         }
-    }
-    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 } : {}),
+        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);
+        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,
         });
-    }
-    if (move?.queued) {
-        // Parked at the target's cap: reconcile resumes the session there.
-    }
-    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 });
+        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 } : {}),
+                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 } : {}),
+                        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);
                 }
-                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`, {
+                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,
-                                        prepared_version: lane.version,
-                                        version: current.version,
-                                        state: current.state,
+                                        provider: lane.provider,
                                     });
                                 }
-                                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,
+                                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,
-                            },
-                            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),
+                                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;
                         });
-                        archiveResumeMessage(hqRoot, laneId, dropboxMessage);
-                        return started;
-                    });
-                }, ctx.sleep);
-            },
-        }, mechanism);
-        if (dispatched.mechanism === "resume")
-            resumed = dispatched.value;
-    }
-    // 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, {
+                    }, 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,
-                    message_id: messageId,
-                    at,
-                }),
-            };
+                    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;
+    }
+}
+function messageLaneExclusion(ctx, lane) {
+    if (lane.state === "killed" || lane.state === "cancelled")
+        return lane.state;
+    return keepAliveExclusion(lane, loadAllLanes(ctx.hqRoot()), loadRetiredLaneIds(ctx.hqRoot()));
+}
+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();
+    const lane = readLane(hqRoot, laneId);
+    if (!dropboxInboxHasMessages(hqRoot, laneId))
+        return { action: "none", message_count: 0 };
+    const exclusion = messageLaneExclusion(ctx, lane);
+    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;
     }
-    // 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;
-    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,
-    });
 }
 function accountMoveSummary(move) {
     return {
@@ -7219,7 +7560,7 @@ async function runAsk(ctx, opts) {
     const attempts = ASK_ATTEMPTS;
     for (let i = 0; i < attempts; i += 1) {
         try {
-            const withBody = raiseLaneQuestion({
+            let withBody = raiseLaneQuestion({
                 hqRoot,
                 lane,
                 body,
@@ -7229,6 +7570,9 @@ async function runAsk(ctx, opts) {
                 questionId,
             });
             questionId = withBody.question_id;
+            if (await ctx.laneTrackerMeshEnabled(questionCompany)) {
+                withBody = await indexTrackerQuestion(ctx, hqRoot, lane, withBody, body, questionCompany);
+            }
             await emitLaneMeshEvent(ctx, lane.mesh_company ?? lane.company, lane.thread_id, "lane_question", {
                 lane_id: lane.lane_id,
                 question_id: withBody.question_id,
@@ -7615,18 +7959,28 @@ async function runQuestionsList(ctx, opts) {
     const outpostLoad = opts.allHosts
         ? await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company)
         : { questions: [], errors: [] };
+    const meshRows = await ctx.laneTrackerMeshEnabled(company) && status !== "expired"
+        ? await createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest }).list(status ? [status] : undefined)
+        : [];
     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 localMeshQuestionIds = new Set(localQuestions.map((question) => question.mesh_question_id).filter((id) => Boolean(id)));
     const questions = [
         ...localQuestions
             .filter((q) => !remoteQuestionIds.has(q.question_id))
             .map((q) => {
+            const meshRow = q.mesh_question_id ? meshRows.find((row) => row.questionId === q.mesh_question_id) : undefined;
             const row = {
                 ...q,
                 audience: resolveAudience(hqRoot, q, ctx),
+                ...(meshRow ? {
+                    mesh_question_id: meshRow.questionId,
+                    body_preview: { question: meshRow.question, context: meshRow.context ?? "", options: meshRow.options, ...(meshRow.recommended ? { recommended: meshRow.recommended } : {}) },
+                    host: `${meshRow.host.kind}:${meshRow.host.id}`,
+                } : {}),
                 ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
             };
             if (!opts.allHosts)
@@ -7658,6 +8012,50 @@ async function runQuestionsList(ctx, opts) {
             audience,
             ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
         })),
+        ...meshRows
+            .filter((row) => {
+            if (localMeshQuestionIds.has(row.questionId))
+                return false;
+            if (status && row.status !== status)
+                return false;
+            if (opts.from && row.laneId !== opts.from)
+                return false;
+            if (opts.project && row.projectId !== opts.project)
+                return false;
+            if (opts.story) {
+                const lane = localLanes.get(row.laneId);
+                if (!lane || lane.story_id !== opts.story)
+                    return false;
+            }
+            const audience = row.audience === "owner"
+                ? { kind: "user" }
+                : row.audience === "operator"
+                    ? { kind: "session", id: "mesh" }
+                    : { kind: "lane", id: row.laneId };
+            if (forFilter && !audienceMatches(audience, forFilter))
+                return false;
+            return true;
+        })
+            .map((row) => ({
+            question_id: row.questionId,
+            mesh_question_id: row.questionId,
+            lane_id: row.laneId,
+            company,
+            project_id: row.projectId,
+            story_id: localLanes.get(row.laneId)?.story_id ?? "",
+            ...(row.threadId ? { thread_id: row.threadId } : {}),
+            asked_at: row.askedAt,
+            origin: { kind: "lane", id: row.laneId },
+            hop: row.routingHistory.length || 1,
+            status: row.status,
+            audience: row.audience,
+            host: `${row.host.kind}:${row.host.id}`,
+            question: row.question,
+            context: row.context ?? "",
+            options: row.options,
+            ...(row.recommended ? { recommended: row.recommended } : {}),
+            ...(row.choice !== undefined ? { answer: { choice: row.choice, answered_by: row.answeredBy, answered_at: row.answeredAt, notes: row.notes } } : {}),
+        })),
     ];
     printJson({
         ok: true,
@@ -7675,6 +8073,43 @@ async function runQuestionsShow(ctx, questionId) {
     catch (err) {
         if (!isLanesError(err) || err.error !== "question_not_found")
             throw err;
+        let meshCompany = null;
+        try {
+            meshCompany = await resolveActiveQuestionCompany(ctx, "Cannot look up Work Mesh question without an active company");
+        }
+        catch (companyError) {
+            if (questionRecordRefusalCode(companyError) !== "question_company_unavailable")
+                throw companyError;
+            // The Outpost lookup below remains available to unscoped primary hosts.
+        }
+        if (meshCompany && await ctx.laneTrackerMeshEnabled(meshCompany)) {
+            const rows = await createTrackerMeshQuestionClient({ company: meshCompany, request: ctx.trackerMeshRequest }).list();
+            const matches = rows.filter((row) => row.questionId === questionId);
+            if (matches.length > 1)
+                throw new LanesError("tracker_mesh_question_ambiguous", `Work Mesh question ${questionId} is duplicated in the company inbox`, { question_id: questionId });
+            const row = matches[0];
+            if (row) {
+                printJson({
+                    ok: true,
+                    action: "questions.show",
+                    question: {
+                        question_id: row.questionId,
+                        mesh_question_id: row.questionId,
+                        lane_id: row.laneId,
+                        company: meshCompany,
+                        project_id: row.projectId,
+                        thread_id: row.threadId,
+                        asked_at: row.askedAt,
+                        status: row.status,
+                        audience: row.audience,
+                        host: `${row.host.kind}:${row.host.id}`,
+                    },
+                    audience: row.audience,
+                    body: { question: row.question, context: row.context ?? "", options: row.options, ...(row.recommended ? { recommended: row.recommended } : {}), ...(row.notes ? { notes: row.notes } : {}) },
+                });
+                return;
+            }
+        }
         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}`, {
@@ -7730,6 +8165,42 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         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>");
+        if (await ctx.laneTrackerMeshEnabled(company)) {
+            const client = createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest });
+            const matches = (await client.list(["pending", "answered"])).filter((row) => row.questionId === questionId);
+            if (matches.length > 1)
+                throw new LanesError("tracker_mesh_question_ambiguous", `Work Mesh question ${questionId} is duplicated in the company inbox`, { question_id: questionId });
+            const row = matches[0];
+            if (row) {
+                if (row.status !== "pending")
+                    throw new LanesError("question_not_pending", `Question ${questionId} is ${row.status}`, { question_id: questionId, status: row.status });
+                const freeform = opts.freeform?.trim() || undefined;
+                if (freeform !== undefined && row.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, row.options, false);
+                const answer = await client.answer(questionId, choice, opts.notes);
+                printJson({
+                    ok: true,
+                    action: "questions.answer",
+                    lane_id: answer.laneId,
+                    question: {
+                        question_id: answer.questionId,
+                        mesh_question_id: answer.questionId,
+                        lane_id: answer.laneId,
+                        project_id: answer.projectId,
+                        status: answer.status,
+                        choice: answer.choice,
+                        answered_by: answer.answeredBy,
+                        answered_at: answer.answeredAt,
+                        delivered_at: answer.deliveredAt ?? null,
+                    },
+                    delivery: "awaiting_host_poll",
+                });
+                return;
+            }
+        }
         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}`, {
@@ -7805,6 +8276,22 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         throw new LanesError("missing_choice", "--choice or --freeform is required", {});
     }
     const choice = freeform ?? resolveAnswerChoice(opts.choice, body.options, false);
+    let remoteAnswer;
+    let meshQuestionId = question.mesh_question_id;
+    if (await ctx.laneTrackerMeshEnabled(questionCompany)) {
+        const client = createTrackerMeshQuestionClient({ company: questionCompany, request: ctx.trackerMeshRequest });
+        if (!meshQuestionId) {
+            const indexed = await indexTrackerQuestion(ctx, hqRoot, askingLane, question, body, questionCompany, client);
+            meshQuestionId = indexed.mesh_question_id;
+        }
+        if (!meshQuestionId)
+            throw new LanesError("tracker_mesh_question_link_missing", "Work Mesh question could not be linked before answering", { question_id: question.question_id });
+        remoteAnswer = await client.answer(meshQuestionId, choice, opts.notes);
+        assertMeshQuestionMatchesLocal(remoteAnswer, question, questionCompany);
+        if (remoteAnswer.status !== "answered" || remoteAnswer.choice !== choice) {
+            throw new LanesError("tracker_mesh_response_invalid", "Work Mesh did not record the requested question answer", { mesh_question_id: meshQuestionId });
+        }
+    }
     const at = ctx.now().toISOString();
     const answeredBy = sessionIdFromEnv(ctx.env)
         ? `session:${sessionIdFromEnv(ctx.env)}`
@@ -7839,6 +8326,7 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
                 answered_at: at,
                 answered_level: current.hop,
             },
+            ...(meshQuestionId ? { mesh_question_id: meshQuestionId } : {}),
         };
     });
     const latestAskingLane = readLane(hqRoot, askingLane.lane_id);
@@ -7873,6 +8361,8 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         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 });
         }
+        if (remoteAnswer)
+            await syncTrackerMeshQuestions(ctx, hqRoot);
         printJson({
             ok: true,
             action: "questions.answer",
@@ -8532,6 +9022,10 @@ async function runReconcile(ctx, opts) {
         livenessDeps: livenessDepsFromCtx(ctx),
         presenceConnected: ctx.presenceConnected,
         resolveQuestionActiveCompany: () => resolveActiveQuestionCompany(ctx),
+        syncTrackerQuestions: (root) => syncTrackerMeshQuestions(ctx, root),
+        recoverQueuedMessages: async (lane) => {
+            await recoverQueuedMessages(ctx, lane.lane_id);
+        },
         mesh: ctx.mesh,
         env: ctx.env,
     });
@@ -8609,6 +9103,7 @@ export function registerLanesCommand(parent, deps = {}) {
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
         trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
+        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
         actor: ctx.trackerActor,
     }, wrap);
@@ -8617,6 +9112,7 @@ export function registerLanesCommand(parent, deps = {}) {
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
         trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
+        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
     }, wrap);
     registerLaneChecksCommand(lanes, {
@@ -8624,6 +9120,7 @@ export function registerLanesCommand(parent, deps = {}) {
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
         trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
+        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
     }, wrap);
     registerLaneReportCommands(lanes, {
@@ -8631,6 +9128,7 @@ export function registerLanesCommand(parent, deps = {}) {
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
         trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
+        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
         readQuestionBody: (root, question) => {
             const body = requireQuestionBody(root, question);
@@ -8863,6 +9361,12 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (laneId, opts) => {
         await 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));
+    }));
     lanes
         .command("_monitor-message", { hidden: true })
         .argument("<lane-id>", "Lane id")