@indigoai-us/hq-cli 5.293.0 → 5.295.0

package/dist/commands/lanes.js

@@ -17,11 +17,13 @@ import { createLaneMoveHandlers } from "./lanes-move.js";
 import { createLaneQuestionsHandlers } from "./lanes-questions.js";
 import { createLaneResumeHandlers } from "./lanes-resume.js";
 import { createLaneWatchHandlers } from "./lanes-watch.js";
+import { createLaneStoryHandlers } from "./lanes-stories.js";
 import { callerMatchesSessionSenior, assertPlacementEnabled, defaultLanePlacementEnabled, parsePlacementPolicy, processLanePlacementCompany, readClaudeAccountBalanceSignalsEnabled, readLanePlacementEnabled, } from "./lanes-shared.js";
 export { CLAUDE_ACCOUNT_BALANCE_SIGNALS_FLAG, LANE_OUTPOST_LOAD_BALANCING_FLAG } from "./lanes-shared.js";
 export { resolveAnswerChoice } from "./lanes-questions.js";
 import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
 import { registerLaneKpisCommand } from "./lanes-kpis.js";
+import { registerLaneAutopilotReportCommand } from "./lanes-autopilot.js";
 import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
 import { registerLaneRepoMergeHoldCommand } from "./lanes-hold.js";
@@ -29,18 +31,17 @@ import { registerLaneReviewCommand } from "./lanes-review.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { withCliFeatureUsed } from "../utils/cli-telemetry.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
-import { startOutpostLaneSnapshotRefresh } from "../lib/lanes/outpost-snapshot-refresh.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
-import { getOrFetchOutpostSnapshot, OUTPOST_SNAPSHOT_CACHE_TTL_MS, outpostLaneListSnapshotKey, OutpostSnapshotInvocationMemo, } from "../lib/lanes/outpost-snapshot-cache.js";
+import { OutpostSnapshotInvocationMemo } from "../lib/lanes/outpost-snapshot-memo.js";
 import { createOutpostHireGrantContext, parseOutpostHireGrantContext, selectOutpostHireGrantHierarchy, sameHireGrantSenior, } from "../lib/lanes/hire-grant-dispatch.js";
 import { createOutpostProfileRepinContext, parseOutpostProfileRepinContext, } from "../lib/lanes/outpost-profile-repin.js";
 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, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostQuestionListCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, REMOTE_LANE_READ_ENV, outpostRejectedEffortOption, parseOutpostPickupPayload, PICKUP_WAIT_MS, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
-import { outpostHireSummaryCacheKey, LANE_OUTPOST_SNAPSHOT_CACHE_FLAG, OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS, readOutpostHireSummaryCache, readOutpostHireSummaryCacheIncludingStale, writeOutpostHireSummaryCache, } from "../lib/lanes/outpost-hire-cache.js";
+import { outpostHireSummaryCacheKey, OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS, readOutpostHireSummaryCache, readOutpostHireSummaryCacheIncludingStale, writeOutpostHireSummaryCache, } from "../lib/lanes/outpost-hire-cache.js";
 import { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "../lib/lanes/host-capacity.js";
 import { BALANCE_MOVABLE_STATES, selectClaudeAccount, } from "../lib/lanes/claude-balance.js";
 import { parseUserYaml } from "../utils/user-yaml-error.js";
@@ -55,7 +56,7 @@ import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { listLaneReviews } from "../lib/lanes/reviews.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
 import { AccountResolutionError, compareLaneQueueOrder, 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, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseQuestionRecord, parseSeniorKind, readAllLanes, readLane, sanitizeHostComponent, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, dropboxDir, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, readWorkerRunResult, resumeCommandRefusal, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
-import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
+import { laneStories, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
 import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
 import { doneKeepAliveVerdict, hasPendingKeepAliveWork, keepAliveExclusion, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
@@ -67,7 +68,7 @@ import { LanesError } from "../lib/lanes/errors.js";
 import { readLatestEnvelopeRecord } from "../lib/lanes/watcher.js";
 import { loadQuotaState, quotaBlockFor } from "../lib/lanes/quota.js";
 import { SESSION_MOVE_REASON } from "../lib/lanes/move-account.js";
-import { managerStatusGateEnabledForLane, resolveManagerStatusGateForLane, } from "../lib/lanes/manager-status-gate.js";
+import { resolveManagerStatusTarget, } from "../lib/lanes/manager-status-gate.js";
 import { blockerFreshnessFingerprint, resolveBlockerFreshnessForLane, } from "../lib/lanes/blocker-freshness.js";
 import { resolveKrFreshnessForShow } from "../lib/lanes/kr-freshness.js";
 import { ensureSessionHome } from "../lib/lanes/session-relink.js";
@@ -83,7 +84,6 @@ const REMOTE_MIRROR_REFRESH_BATCH_SIZE = 100;
 const REMOTE_LANE_NOT_FOUND_GRACE_MS = 15 * 60_000;
 /** The lane → mesh seam. Defined in lib/lanes/mesh-events.ts; the watcher shares it. */
 export { emitLaneDecisionEvents };
-export { LANE_OUTPOST_SNAPSHOT_CACHE_FLAG };
 function withoutProviderHome(value) {
     if (Array.isArray(value))
         return value.map(withoutProviderHome);
@@ -299,8 +299,6 @@ function resolveDeps(deps = {}) {
         })),
         fetchText: deps.fetchText ?? defaultFetchText,
         lanePlacementEnabled: deps.lanePlacementEnabled ?? defaultLanePlacementEnabled,
-        outpostSnapshotCacheEnabled: deps.outpostSnapshotCacheEnabled ?? (() => readLanesRegistryFlag(LANE_OUTPOST_SNAPSHOT_CACHE_FLAG, { env })),
-        startOutpostLaneSnapshotRefresh: deps.startOutpostLaneSnapshotRefresh ?? ((root) => startOutpostLaneSnapshotRefresh(root, env)),
         storyLedgerEnabled: deps.storyLedgerEnabled ?? laneStoryLedgerEnabled,
         isSsmOwnerDispatch: deps.isSsmOwnerDispatch ?? (() => isSsmRunCommandProcess()),
         withGrantHireLocks: deps.withGrantHireLocks ?? withLaneHireLocks,
@@ -512,7 +510,7 @@ async function readRemoteHireGrantSenior(ctx, hqRoot, seniorLaneId) {
             laneIds: [seniorLaneId],
             snapshot: true,
             strictSnapshot: true,
-        }, {}, { bypassCache: true });
+        }, {}, { bypassMemo: true });
     }
     catch (error) {
         throw unavailable(isLanesError(error) ? error.error : "outpost_lane_list_unavailable");
@@ -1051,7 +1049,7 @@ function laneHostFromCtx(ctx, expectedId) {
     return { kind: "local", id: hostname };
 }
 async function readOutpostCapacity(ctx, outpostId) {
-    return readOutpostSnapshotWithCache(ctx, JSON.stringify(["capacity", outpostId]), (value) => isOutpostCapacitySnapshot(value, outpostId), () => readOutpostCapacityUncached(ctx, outpostId));
+    return readOutpostCapacityUncached(ctx, outpostId);
 }
 async function readOutpostCapacityUncached(ctx, outpostId) {
     let result;
@@ -1087,39 +1085,6 @@ async function readOutpostCapacityUncached(ctx, outpostId) {
     }
     return snapshot;
 }
-async function readOutpostSnapshotWithCache(ctx, key, isValue, fetch) {
-    let enabled = false;
-    try {
-        enabled = await ctx.outpostSnapshotCacheEnabled();
-    }
-    catch (err) {
-        process.stderr.write(`lanes snapshot cache flag read failed; using uncached Outpost read: ${dispatchErrorMessage(err)}\n`);
-    }
-    if (!enabled)
-        return fetch();
-    return getOrFetchOutpostSnapshot({ hqRoot: ctx.hqRoot(), key, isValue, fetch });
-}
-function isLaneRecordArray(value) {
-    if (!Array.isArray(value))
-        return false;
-    try {
-        for (const lane of value)
-            parseLaneRecord(lane);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function isOutpostCapacitySnapshot(value, outpostId) {
-    try {
-        const snapshot = parseHostCapacitySnapshot(value);
-        return snapshot.host.kind === "outpost" && snapshot.host.id === outpostId;
-    }
-    catch {
-        return false;
-    }
-}
 async function loadHostCapacitySnapshots(ctx, hqRoot, config = loadLanesConfig(hqRoot), localLanes = loadAllLanes(hqRoot)) {
     const localHost = laneHostFromCtx(ctx);
     let outpostIds;
@@ -1278,7 +1243,7 @@ async function readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOpt
 }
 async function readOutpostLaneRecords(ctx, outpostId, requestedQuery = {}, dispatchOptions = {}, options = {}) {
     const query = normalizedLaneListQuery(requestedQuery);
-    if (options.bypassCache === true) {
+    if (options.bypassMemo === true) {
         return readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOptions);
     }
     let invocationMemo = outpostLaneListMemo.get(ctx);
@@ -1286,10 +1251,10 @@ async function readOutpostLaneRecords(ctx, outpostId, requestedQuery = {}, dispa
         invocationMemo = new OutpostSnapshotInvocationMemo();
         outpostLaneListMemo.set(ctx, invocationMemo);
     }
-    return invocationMemo.getOrCreate(outpostId, query, () => readOutpostSnapshotWithCache(ctx, outpostLaneListSnapshotKey(outpostId, query), isLaneRecordArray, () => readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOptions)));
+    return invocationMemo.getOrCreate(outpostId, query, () => readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOptions));
 }
-/** Refresh only this host's non-terminal Outpost mirrors in one bounded owner query per Outpost. */
-async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
+/** Refresh this host's selected Outpost mirrors in one bounded owner query per Outpost. */
+async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds, options = {}) {
     const result = {
         updated: new Map(),
         unverifiedRemote: new Map(),
@@ -1314,11 +1279,21 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
         .filter((lane) => lane.host.kind === "outpost" &&
         (host.outpostId === null || lane.host.id !== host.outpostId) &&
         originMatchesThisHost(lane) &&
-        (parentLaneIds === undefined || (lane.senior.kind === "lane" &&
+        ((parentLaneIds === undefined || (lane.senior.kind === "lane" &&
             lane.senior.id !== undefined &&
-            parentLaneIds.has(lane.senior.id))) &&
-        !isTerminalLaneState(lane.state))
-        .sort((a, b) => a.lane_id.localeCompare(b.lane_id));
+            parentLaneIds.has(lane.senior.id))) || options.laneIds?.has(lane.lane_id) === true) &&
+        (options.includeTerminalMirrors === true || !isTerminalLaneState(lane.state)))
+        .sort((a, b) => {
+        const terminalOrder = Number(isTerminalLaneState(a.state)) - Number(isTerminalLaneState(b.state));
+        if (terminalOrder !== 0)
+            return terminalOrder;
+        if (isTerminalLaneState(a.state)) {
+            const updatedAtOrder = Date.parse(b.updated_at) - Date.parse(a.updated_at);
+            if (updatedAtOrder !== 0)
+                return updatedAtOrder;
+        }
+        return a.lane_id.localeCompare(b.lane_id);
+    });
     if (candidates.length === 0)
         return result;
     const enabledByCompany = new Map();
@@ -1404,7 +1379,13 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
                 : undefined;
             const before = readLane(hqRoot, mirror.lane_id);
             if (before.host.kind !== "outpost" || before.host.id !== outpostId ||
-                !originMatchesThisHost(before) || isTerminalLaneState(before.state)) {
+                !originMatchesThisHost(before) ||
+                (!options.includeTerminalMirrors && isTerminalLaneState(before.state))) {
+                result.updated.set(mirror.lane_id, before);
+                continue;
+            }
+            if (owner.version < before.version) {
+                result.unverifiedRemote.set(mirror.lane_id, "owner_snapshot_behind_mirror");
                 result.updated.set(mirror.lane_id, before);
                 continue;
             }
@@ -1422,10 +1403,16 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
                 result.updated.set(mirror.lane_id, before);
                 continue;
             }
+            let ownerSnapshotLostVersionRace = false;
             const updated = retryUpdateLane(hqRoot, mirror.lane_id, "reconcile", (current) => {
                 if (current.host.kind !== "outpost" || current.host.id !== outpostId ||
-                    !originMatchesThisHost(current) || isTerminalLaneState(current.state))
+                    !originMatchesThisHost(current) ||
+                    (!options.includeTerminalMirrors && isTerminalLaneState(current.state)))
+                    return current;
+                if (owner.version < current.version) {
+                    ownerSnapshotLostVersionRace = true;
                     return current;
+                }
                 return {
                     ...current,
                     state: owner.state,
@@ -1443,6 +1430,9 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
                     } : {}),
                 };
             });
+            if (ownerSnapshotLostVersionRace) {
+                result.unverifiedRemote.set(mirror.lane_id, "owner_snapshot_behind_mirror");
+            }
             result.updated.set(mirror.lane_id, updated);
         }
     }
@@ -1522,6 +1512,7 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
     const hostOutpostIdSet = new Set(hostOutpostIds);
     const matches = [];
     const failedOutpostIds = [];
+    const probedOutpostIds = [];
     const lookupOutpostIds = requestedOutpostId !== undefined
         ? [requestedOutpostId]
         : [
@@ -1535,6 +1526,7 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
                 hierarchy: [laneId],
                 snapshot: true,
             });
+            probedOutpostIds.push(outpostId);
         }
         catch (err) {
             if (requestedOutpostId !== undefined)
@@ -1553,7 +1545,10 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
         }
     }
     if (matches.length === 0) {
-        throw commandLaneNotFound(laneId, options.outpostHint === true, failedOutpostIds.length > 0 ? { failed_outpost_ids: failedOutpostIds } : undefined);
+        throw commandLaneNotFound(laneId, options.outpostHint === true, {
+            ...(failedOutpostIds.length > 0 ? { failed_outpost_ids: failedOutpostIds } : {}),
+            ...(probedOutpostIds.length > 0 ? { probed_outpost_ids: probedOutpostIds } : {}),
+        });
     }
     if (matches.length !== 1) {
         throw new LanesError("lane_outpost_ambiguous", `More than one registered Outpost reported lane ${laneId} with the same recorded host identity`, { lane_id: laneId, outpost_ids: matches.map((match) => match.outpostId) });
@@ -3500,7 +3495,6 @@ async function runCreate(ctx, opts) {
     if (admission.action === "start") {
         started = spawnLaneWorker(hqRoot, lane, {
             env: ctx.env,
-            managerStatusGateEnabled: await managerStatusGateEnabledForLane(hqRoot, lane, { env: ctx.env }),
             modelDeps: {
                 readFileSync: ctx.readFileSync,
                 probe: ctx.probeProvider,
@@ -4274,6 +4268,7 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
             outpost_id: outpostId,
             outpost_command_id: dispatched.commandId,
             outpost_transport: "outposts_exec",
+            delivered_to: { host: outpostId, lane_id: ownerLane.lane_id, mechanism: "outposts_exec" },
         });
         return;
     }
@@ -4304,6 +4299,9 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
         outpost_id: outpostId,
         outpost_command_id: dispatched.commandId,
         outpost_transport: "outposts_exec",
+        ...(action === "message"
+            ? { delivered_to: { host: outpostId, lane_id: lane.lane_id, mechanism: "outposts_exec" } }
+            : {}),
     });
 }
 function dispatchedOwnerLane(ctx, laneId, outpostId, rawLane, behavior) {
@@ -4579,7 +4577,6 @@ async function runPickup(ctx, opts) {
         try {
             return spawnLaneWorker(hqRoot, current, {
                 env: ctx.env,
-                managerStatusGateEnabled: await managerStatusGateEnabledForLane(hqRoot, current, { env: ctx.env }),
                 modelDeps: {
                     readFileSync: ctx.readFileSync,
                     probe: ctx.probeProvider,
@@ -4624,7 +4621,7 @@ async function runPickup(ctx, opts) {
         lane: started,
     });
 }
-async function runList(ctx, opts, fastRouteFlags) {
+async function runList(ctx, opts) {
     if (opts.json && opts.human) {
         throw new LanesError("conflicting_output_format", "Use either --json or --human for hq lanes list", { json: true, human: true });
     }
@@ -4664,15 +4661,14 @@ async function runList(ctx, opts, fastRouteFlags) {
     const hierarchyIds = opts.hierarchy === undefined
         ? undefined
         : new Set(opts.hierarchy.flatMap((laneId) => selectOutpostHireGrantHierarchy(laneId, laneSource).map((lane) => lane.lane_id)));
-    let selectedLanes = laneSource
-        .filter((lane) => {
+    const matchesLaneFilters = (lane, includeState) => {
         if (requestedLaneIds.length > 0 && !requestedIds.has(lane.lane_id))
             return false;
-        if (opts.active && isTerminalLaneState(lane.state))
+        if (includeState && opts.active && isTerminalLaneState(lane.state))
             return false;
         if (hierarchyIds && !hierarchyIds.has(lane.lane_id))
             return false;
-        if (state && lane.state !== state)
+        if (includeState && state && lane.state !== state)
             return false;
         const carriesFilter = laneStories(lane).some((story) => (!opts.project || story.project_id === opts.project) &&
             (!opts.story || story.story_id === opts.story));
@@ -4687,8 +4683,11 @@ async function runList(ctx, opts, fastRouteFlags) {
         if (senior && seniorKey(lane.senior) !== seniorKey(senior))
             return false;
         return true;
-    })
+    };
+    const selectLanes = () => laneSource
+        .filter((lane) => matchesLaneFilters(lane, true))
         .sort(compareLaneQueueOrder);
+    let selectedLanes = selectLanes();
     if (opts.snapshot) {
         printJson({
             ok: true,
@@ -4705,15 +4704,20 @@ async function runList(ctx, opts, fastRouteFlags) {
     const remoteRead = ctx.env[REMOTE_LANE_READ_ENV] === "1";
     const remoteRefresh = remoteRead
         ? { updated: new Map(), unverifiedRemote: new Map(), missingOnOwner: new Map() }
-        : await refreshRemoteLaneMirrors(ctx, hqRoot, laneSource, new Set(selectedLanes
-            .filter((lane) => !isTerminalLaneState(lane.state))
-            .map((lane) => lane.lane_id)));
+        : await refreshRemoteLaneMirrors(ctx, hqRoot, laneSource, new Set(laneSource
+            .filter((lane) => matchesLaneFilters(lane, false))
+            .map((lane) => lane.lane_id)), {
+            includeTerminalMirrors: true,
+            laneIds: new Set(laneSource
+                .filter((lane) => matchesLaneFilters(lane, false))
+                .map((lane) => lane.lane_id)),
+        });
     for (const [laneId, updated] of remoteRefresh.updated) {
         const index = laneSource.findIndex((lane) => lane.lane_id === laneId);
         if (index >= 0)
             laneSource[index] = updated;
     }
-    selectedLanes = selectedLanes.map((lane) => remoteRefresh.updated.get(lane.lane_id) ?? lane);
+    selectedLanes = selectLanes();
     const now = ctx.now();
     const host = reconcileHostFromCtx(ctx);
     const allLanes = laneSource;
@@ -4734,33 +4738,7 @@ async function runList(ctx, opts, fastRouteFlags) {
         ownerEligibleLaneIds.add(lane.lane_id);
     }
     const ownerLanes = selectedLanes.filter((lane) => ownerEligibleLaneIds.has(lane.lane_id));
-    const refreshRemote = ctx.env.HQ_INTERNAL_LANES_REFRESH_REMOTE_SNAPSHOT === "1";
-    let snapshotCacheEnabled = fastRouteFlags?.snapshotCacheEnabled ?? false;
-    if (fastRouteFlags === undefined &&
-        (refreshRemote || (!opts.fresh && ownerLanes.length > 0))) {
-        try {
-            snapshotCacheEnabled = await ctx.outpostSnapshotCacheEnabled();
-        }
-        catch (err) {
-            process.stderr.write(`lanes snapshot cache flag read failed; using wait-for-remote list: ${dispatchErrorMessage(err)}\n`);
-        }
-    }
-    if (refreshRemote) {
-        if (snapshotCacheEnabled && ownerLanes.length > 0) {
-            const outcomes = await batchOwnerLaneHireFields(ctx, ownerLanes, allLanes, { forceRefresh: true });
-            const failures = [...outcomes.entries()].filter(([, outcome]) => "error" in outcome);
-            if (failures.length > 0) {
-                const firstOutcome = failures[0][1];
-                const firstError = "error" in firstOutcome ? firstOutcome.error : undefined;
-                process.stderr.write(`lanes snapshot refresh failed for ${failures.length} lane(s): ${firstError?.error ?? "outpost_lane_hire_summary_missing"}: ${firstError?.message ?? "owner summary outcome was missing"}\n`);
-                throw firstError ?? new LanesError("outpost_lane_hire_summary_missing", "Background Outpost lane summary refresh returned a missing outcome", { lane_ids: failures.map(([laneId]) => laneId) });
-            }
-        }
-        return;
-    }
     const hireByLane = new Map();
-    const remoteSnapshotMetadata = new Map();
-    let remoteLanesLoading = false;
     for (const lane of selectedLanes) {
         if (!ownerEligibleLaneIds.has(lane.lane_id)) {
             hireByLane.set(lane.lane_id, {
@@ -4770,47 +4748,7 @@ async function runList(ctx, opts, fastRouteFlags) {
             continue;
         }
     }
-    if (snapshotCacheEnabled && !opts.fresh && ownerLanes.length > 0) {
-        const nowMs = ctx.now().getTime();
-        const cached = readOutpostHireSummaryCacheIncludingStale(hqRoot, nowMs);
-        let refreshNeeded = false;
-        for (const lane of ownerLanes) {
-            if (lane.host.kind !== "outpost")
-                continue;
-            const summary = cached.get(outpostHireSummaryCacheKey(lane.host.id, lane.lane_id));
-            if (!summary) {
-                hireByLane.set(lane.lane_id, {
-                    ...laneHireFields(lane, allLanes, aliveChildrenByParent),
-                    hire_source: "local",
-                });
-                remoteSnapshotMetadata.set(lane.lane_id, { ageSeconds: null, stale: true, loading: true });
-                refreshNeeded = true;
-                remoteLanesLoading = true;
-                continue;
-            }
-            const ageMs = Math.max(0, nowMs - Date.parse(summary.cached_at));
-            const stale = ageMs >= OUTPOST_SNAPSHOT_CACHE_TTL_MS;
-            hireByLane.set(lane.lane_id, {
-                hire_grant: summary.hire_grant,
-                hire_alive_children: summary.hire_alive_children,
-                hire: summary.hire,
-                hire_summary: summary.hire_summary,
-                hire_source: "owner",
-            });
-            remoteSnapshotMetadata.set(lane.lane_id, {
-                ageSeconds: Math.floor(ageMs / 1_000),
-                stale,
-                loading: stale,
-            });
-            if (stale) {
-                refreshNeeded = true;
-                remoteLanesLoading = true;
-            }
-        }
-        if (refreshNeeded)
-            ctx.startOutpostLaneSnapshotRefresh(hqRoot);
-    }
-    else if (ownerLanes.length > 0) {
+    if (ownerLanes.length > 0) {
         const ownerSummaries = await batchOwnerLaneHireFields(ctx, ownerLanes, allLanes);
         for (const lane of ownerLanes) {
             const outcome = ownerSummaries.get(lane.lane_id);
@@ -4844,15 +4782,6 @@ async function runList(ctx, opts, fastRouteFlags) {
             ...(remoteQueued
                 ? { state: "remote", remote_state: lane.state, queued_reason: undefined, queued_details: undefined }
                 : {}),
-            ...(remoteSnapshotMetadata.has(lane.lane_id)
-                ? {
-                    remote_snapshot_age_s: remoteSnapshotMetadata.get(lane.lane_id).ageSeconds,
-                    remote_snapshot_stale: remoteSnapshotMetadata.get(lane.lane_id).stale,
-                    ...(remoteSnapshotMetadata.get(lane.lane_id).loading
-                        ? { remote_snapshot_loading: true }
-                        : {}),
-                }
-                : {}),
             overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, now),
             stalled: Boolean(lane.stalled),
             // Listing is observational. Reconcile owns durable liveness transitions.
@@ -4876,8 +4805,7 @@ async function runList(ctx, opts, fastRouteFlags) {
         };
     });
     const placementCompany = company ?? processLanePlacementCompany(ctx);
-    const placementEnabled = !remoteRead && (fastRouteFlags?.lanePlacementEnabled ??
-        await readLanePlacementEnabled(ctx, placementCompany));
+    const placementEnabled = !remoteRead && await readLanePlacementEnabled(ctx, placementCompany);
     const host_capacity = placementEnabled
         ? (await loadHostCapacitySnapshots(ctx, hqRoot, undefined, allLanes)).entries
         : undefined;
@@ -4888,43 +4816,24 @@ async function runList(ctx, opts, fastRouteFlags) {
         ...(remoteRefresh.unverifiedRemote.size > 0
             ? { unverified_remote_lanes: [...remoteRefresh.unverifiedRemote.keys()] }
             : {}),
-        ...(remoteLanesLoading ? { remote_lanes_loading: true } : {}),
         ...(host_capacity !== undefined ? { host_capacity } : {}),
     };
     if (opts.human)
-        console.log(formatLaneListHuman(lanes, remoteLanesLoading));
+        console.log(formatLaneListHuman(lanes));
     else
         printJson(result);
 }
-/** Keeps the placement-enabled cache-first path on the full lane command graph. */
-export async function runFastCachedLanesListFromEntrypoint() {
-    try {
-        await runList(resolveDeps(), { json: true }, {
-            snapshotCacheEnabled: true,
-            lanePlacementEnabled: true,
-        });
-    }
-    catch (err) {
-        failJson(err);
-    }
-}
-function formatLaneListHuman(lanes, remoteLanesLoading = false) {
+function formatLaneListHuman(lanes) {
     const rows = lanes.map((lane) => {
         const ids = lane.story_ids;
         const storyLabel = ids.length > 0
             ? "stories: " + ids.join(", ")
             : "no story: " + (lane.no_story_reason ?? "reason not recorded");
-        const snapshotNote = lane.remote_snapshot_stale && lane.remote_snapshot_age_s !== null &&
-            lane.remote_snapshot_age_s !== undefined
-            ? `  remote snapshot stale (${lane.remote_snapshot_age_s}s)`
-            : "";
         return lane.lane_id + "  " + lane.state + "  " + lane.provider + "  " + lane.project_id +
-            "  " + storyLabel + snapshotNote;
+            "  " + storyLabel;
     });
     if (rows.length === 0)
         rows.push("No lanes.");
-    if (remoteLanesLoading)
-        rows.push("Remote lanes loading.");
     return rows.join("\n");
 }
 async function runStatus(ctx, opts) {
@@ -5119,8 +5028,17 @@ async function runShow(ctx, laneId) {
     const doneStateVerdict = storedLane.state === "done" && storedLane.keep_alive === true
         ? doneKeepAliveVerdict(storedLane, { decision: storedLane.last_envelope?.decision, story_complete: storedLane.story_complete }, storedLane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, storedLane))
         : null;
-    const managerStatusGate = await resolveManagerStatusGateForLane(hqRoot, storedLane, { env: ctx.env });
-    const managerStatusTarget = managerStatusGate.target;
+    let managerStatusTarget;
+    let managerStatusGateError;
+    try {
+        resolveLaneCompany(hqRoot, storedLane);
+        managerStatusTarget = resolveManagerStatusTarget(hqRoot, storedLane);
+    }
+    catch (err) {
+        managerStatusGateError = err instanceof LanesError ? err.error : "manager_status_gate_unavailable";
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`hq lanes: manager status gate disabled for ${storedLane.lane_id}: ${managerStatusGateError}: ${message}\n`);
+    }
     const blockerFreshness = await resolveBlockerFreshnessForLane(hqRoot, storedLane, {
         env: ctx.env,
         now: ctx.now().getTime(),
@@ -5161,6 +5079,7 @@ async function runShow(ctx, laneId) {
         envelope_repair_mode: lane.envelope_repair?.mode ?? null,
         envelope_validation_errors: lane.envelope_validation_errors ?? [],
         last_resume: lane.last_resume ?? null,
+        keep_alive_history: lane.keep_alive_history ?? [],
         account: lane.account ?? null,
         account_history: lane.account_history ?? [],
         failed_resume_history: lane.failed_resume_history ?? [],
@@ -5184,15 +5103,16 @@ async function runShow(ctx, laneId) {
                 (storedLane.keep_alive === true ? null : "not_opted_in"),
             consecutive_auto_resumes: lane.keep_alive_resume_count ?? 0,
             last_auto_resume_at: lane.keep_alive_last_resume_at ?? null,
+            keep_alive_history: lane.keep_alive_history ?? [],
             next_eligible_at: lane.keep_alive_next_eligible_at ?? null,
             exhausted_at: lane.keep_alive_exhausted_at ?? null,
         },
-        manager_status_gate: managerStatusGate.error !== undefined
+        manager_status_gate: managerStatusGateError !== undefined
             ? {
                 status_path: null,
                 skipped: null,
                 consecutive_misses: storedLane.status_gate?.consecutive_misses ?? 0,
-                error: managerStatusGate.error,
+                error: managerStatusGateError,
             }
             : managerStatusTarget?.manager
                 ? {
@@ -5295,6 +5215,13 @@ function appendCallerSeniorReason(message, authorization) {
         ? message
         : `${message}; authorization refused: ${callerSeniorReason(authorization)}`;
 }
+function assertQuestionAnswerAuthorized(ctx, lane) {
+    const authorization = callerSeniorAuthorization(ctx, lane.senior);
+    if (authorization.authorized)
+        return;
+    const reason = callerSeniorReason(authorization);
+    throw new LanesError("question_answer_unauthorized", appendCallerSeniorReason(`Only senior ${seniorKey(lane.senior)} may answer lane ${lane.lane_id}'s Outpost question`, authorization), { lane_id: lane.lane_id, senior: lane.senior, reason });
+}
 function laneGrantTargetHostedHere(ctx, lane) {
     if (lane.host.kind === "local") {
         return laneRunsHere(lane, reconcileHostFromCtx(ctx));
@@ -5901,7 +5828,6 @@ async function runAdmit(ctx, laneId, opts) {
         }
         const started = spawnLaneWorker(hqRoot, lane, {
             env: ctx.env,
-            managerStatusGateEnabled: await managerStatusGateEnabledForLane(hqRoot, lane, { env: ctx.env }),
             modelDeps: {
                 readFileSync: ctx.readFileSync,
                 probe: ctx.probeProvider,
@@ -6447,84 +6373,6 @@ function laneWithRecoveredProviderSession(hqRoot, lane) {
             : {}),
     };
 }
-function storyCommandTarget(lane, storyId, project) {
-    const projectId = project?.trim() || lane.project_id;
-    const normalizedStoryId = storyId.trim();
-    if (!projectId) {
-        throw new LanesError("missing_project", "--project is required", {});
-    }
-    if (!normalizedStoryId) {
-        throw new LanesError("missing_story", "<story-id> is required", {});
-    }
-    const story = laneStory(lane, projectId, normalizedStoryId);
-    if (!story) {
-        throw new LanesError("story_not_on_lane", `Story ${projectId}/${normalizedStoryId} is not carried by lane ${lane.lane_id}`, { lane_id: lane.lane_id, project_id: projectId, story_id: normalizedStoryId });
-    }
-    return { projectId, storyId: normalizedStoryId, story };
-}
-function updateCarriedStory(lane, projectId, storyId, status, at, extras = {}) {
-    const stories = laneStories(lane).map((story) => story.project_id === projectId && story.story_id === storyId
-        ? {
-            ...story,
-            status,
-            updated_at: at,
-            blocked_reason: extras.blocked_reason,
-            verified_at: extras.verified_at,
-            verified_by: extras.verified_by,
-        }
-        : story);
-    return {
-        ...lane,
-        project_id: projectId,
-        story_id: storyId,
-        stories,
-    };
-}
-function addCarriedStory(lane, projectId, storyId, at) {
-    if (laneStory(lane, projectId, storyId)) {
-        throw new LanesError("story_already_on_lane", `Story ${projectId}/${storyId} is already carried by lane ${lane.lane_id}`, {
-            lane_id: lane.lane_id,
-            project_id: projectId,
-            story_id: storyId,
-        });
-    }
-    return {
-        ...lane,
-        ...(lane.story_id.trim() ? {} : { project_id: projectId, story_id: storyId }),
-        stories: [
-            ...laneStories(lane),
-            { project_id: projectId, story_id: storyId, status: "in_progress", added_at: at, updated_at: at },
-        ],
-    };
-}
-function callerMayVerifyStory(ctx, lane) {
-    const callerLaneId = ctx.env.HQ_LANE_ID?.trim();
-    if (callerLaneId) {
-        return lane.senior.kind === "lane" && lane.senior.id === callerLaneId;
-    }
-    if (lane.senior.kind === "user")
-        return true;
-    if (lane.senior.kind === "lane")
-        return false;
-    return sessionIdFromEnv(ctx.env) === lane.senior.id;
-}
-async function ensureStoryThread(ctx, lane, projectId, storyId = lane.story_id) {
-    const company = lane.mesh_company ?? lane.company;
-    if (!company)
-        return lane;
-    return ensureLaneThreadRecord(ctx, lane, projectId, storyId);
-}
-async function ensureStoryThreadForTransition(ctx, lane, projectId, storyId) {
-    try {
-        return { lane: await ensureStoryThread(ctx, lane, projectId, storyId) };
-    }
-    catch (err) {
-        const warning = storyNotOnBoardWarning(err);
-        if (warning === undefined)
-            throw err;
-        return { lane, warning };
-    }
-}
 async function ensureLaneThreadRecord(ctx, lane, projectId = lane.project_id, storyId = lane.story_id, laneStatus = lane.state) {
     const company = lane.mesh_company ?? lane.company;
     if (!company)
@@ -6546,228 +6394,6 @@ async function ensureLaneThreadRecord(ctx, lane, projectId = lane.project_id, st
     }
     return updated;
 }
-async function emitStoryTransition(ctx, lane, projectId, storyId, event, status, payload = {}, skipStoryStatusPatch = false) {
-    const company = lane.mesh_company ?? lane.company;
-    if (!company)
-        return;
-    const ready = await ensureStoryThread(ctx, lane, projectId, storyId);
-    if (!ready.thread_id)
-        return;
-    await emitLaneMeshEvent(ctx, company, ready.thread_id, event, {
-        lane_id: ready.lane_id,
-        project_id: projectId,
-        story_id: storyId,
-        ...payload,
-        lane_status: lane.state,
-    });
-    if (!skipStoryStatusPatch && projectId?.trim() && storyId?.trim()) {
-        await ctx.mesh.patchStoryStatus(company, projectId, storyId, status === "blocked" ? "in_progress" : status);
-    }
-}
-function sameCommittedStory(current, expected, projectId, storyId) {
-    const currentStory = laneStory(current, projectId, storyId);
-    const expectedStory = laneStory(expected, projectId, storyId);
-    return (current.project_id === expected.project_id &&
-        current.story_id === expected.story_id &&
-        JSON.stringify(currentStory) === JSON.stringify(expectedStory));
-}
-async function commitStoryTransition(ctx, before, next, projectId, storyId, event, status, payload = {}, skipStoryStatusPatch = false) {
-    try {
-        await emitStoryTransition(ctx, next, projectId, storyId, event, status, payload, skipStoryStatusPatch);
-        return undefined;
-    }
-    catch (err) {
-        const warning = storyNotOnBoardWarning(err);
-        if (warning !== undefined)
-            return warning;
-        try {
-            const current = readLane(ctx.hqRoot(), next.lane_id);
-            if (!sameCommittedStory(current, next, projectId, storyId)) {
-                throw new LanesError("story_transition_rollback_conflict", `Story ${projectId}/${storyId} changed while mesh publication failed`, { lane_id: next.lane_id, project_id: projectId, story_id: storyId });
-            }
-            updateLane(ctx.hqRoot(), next.lane_id, current.version, "command", (latest) => {
-                if (!sameCommittedStory(latest, next, projectId, storyId)) {
-                    throw new LanesError("story_transition_rollback_conflict", `Story ${projectId}/${storyId} changed before rollback`, { lane_id: next.lane_id, project_id: projectId, story_id: storyId });
-                }
-                return {
-                    ...latest,
-                    project_id: before.project_id,
-                    story_id: before.story_id,
-                    stories: before.stories,
-                };
-            });
-        }
-        catch (rollbackErr) {
-            process.stderr.write(`hq lanes: story transition rollback failed for ${next.lane_id}/${projectId}/${storyId}: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}\n`);
-        }
-        throw err;
-    }
-}
-async function runStoryList(ctx, laneId) {
-    const lane = readLane(ctx.hqRoot(), laneId);
-    printJson({
-        ok: true,
-        action: "story.list",
-        lane_id: laneId,
-        stories: laneStories(lane),
-        active_stories: activeLaneStories(lane),
-        story_warning: storyWarning(lane) ?? null,
-    });
-}
-async function runStoryAdd(ctx, laneId, storyId, opts) {
-    const hqRoot = ctx.hqRoot();
-    let lane = readLane(hqRoot, laneId);
-    assertLaneRunsHereForOperatorMutation(ctx, lane, "update story status for");
-    const projectId = opts.project?.trim() || lane.project_id;
-    if (!projectId)
-        throw new LanesError("missing_project", "--project is required", {});
-    const normalizedStoryId = storyId.trim();
-    if (!normalizedStoryId)
-        throw new LanesError("missing_story", "<story-id> is required", {});
-    if (ctx.storyLedgerEnabled()) {
-        validateProjectStories(hqRoot, projectId, [normalizedStoryId], lane.company?.slug);
-    }
-    const company = lane.mesh_company ?? lane.company;
-    const warnings = [];
-    let storyKnownAbsent = false;
-    if (company) {
-        const boardCheck = await storyBoardCheck(ctx, company, projectId, [normalizedStoryId]);
-        if (boardCheck.warning !== undefined)
-            warnings.push(boardCheck.warning);
-        storyKnownAbsent = boardCheck.absentStoryIds.has(normalizedStoryId);
-    }
-    const at = ctx.now().toISOString();
-    const thread = await ensureStoryThreadForTransition(ctx, lane, projectId, normalizedStoryId);
-    lane = thread.lane;
-    if (thread.warning !== undefined)
-        warnings.push(thread.warning);
-    const before = lane;
-    const next = casUpdateLane(hqRoot, laneId, (current) => {
-        assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
-        const added = addCarriedStory(current, projectId, normalizedStoryId, at);
-        return {
-            ...added,
-            no_story_reason: undefined,
-        };
-    });
-    const transitionWarning = await commitStoryTransition(ctx, before, next, projectId, normalizedStoryId, "lane_started", "in_progress", {}, storyKnownAbsent);
-    if (transitionWarning !== undefined)
-        warnings.push(transitionWarning);
-    const finalLane = readLane(hqRoot, laneId);
-    printJson({
-        ok: true,
-        action: "story.add",
-        lane_id: laneId,
-        project_id: projectId,
-        story_id: normalizedStoryId,
-        status: "in_progress",
-        story_warning: combinedStoryWarning(finalLane, warnings),
-        lane: finalLane,
-    });
-}
-async function runStoryStart(ctx, laneId, storyId, opts) {
-    const hqRoot = ctx.hqRoot();
-    let lane = readLane(hqRoot, laneId);
-    assertLaneRunsHereForOperatorMutation(ctx, lane, "update story status for");
-    const target = storyCommandTarget(lane, storyId, opts.project);
-    if (target.story.status === "done") {
-        throw new LanesError("story_already_done", `Story ${target.projectId}/${target.storyId} is done and cannot be started again`, {
-            lane_id: laneId,
-            project_id: target.projectId,
-            story_id: target.storyId,
-        });
-    }
-    const at = ctx.now().toISOString();
-    const warnings = [];
-    const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
-    lane = thread.lane;
-    if (thread.warning !== undefined)
-        warnings.push(thread.warning);
-    const before = lane;
-    const next = casUpdateLane(hqRoot, laneId, (current) => {
-        assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
-        return updateCarriedStory(current, target.projectId, target.storyId, "in_progress", at);
-    });
-    const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_started", "in_progress");
-    if (transitionWarning !== undefined)
-        warnings.push(transitionWarning);
-    const finalLane = readLane(hqRoot, laneId);
-    printJson({ ok: true, action: "story.start", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "in_progress", story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
-}
-async function runStoryBlock(ctx, laneId, storyId, opts) {
-    const hqRoot = ctx.hqRoot();
-    let lane = readLane(hqRoot, laneId);
-    assertLaneRunsHereForOperatorMutation(ctx, lane, "update story status for");
-    const target = storyCommandTarget(lane, storyId, opts.project);
-    if (target.story.status === "done") {
-        throw new LanesError("story_already_done", `Story ${target.projectId}/${target.storyId} is done and cannot be blocked again`, {
-            lane_id: laneId,
-            project_id: target.projectId,
-            story_id: target.storyId,
-        });
-    }
-    const reason = opts.reason?.trim();
-    if (!reason)
-        throw new LanesError("missing_block_reason", "--reason is required", {});
-    const at = ctx.now().toISOString();
-    const warnings = [];
-    const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
-    lane = thread.lane;
-    if (thread.warning !== undefined)
-        warnings.push(thread.warning);
-    const before = lane;
-    const next = casUpdateLane(hqRoot, laneId, (current) => {
-        assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
-        return updateCarriedStory(current, target.projectId, target.storyId, "blocked", at, { blocked_reason: reason });
-    });
-    const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_blocked", "blocked", { blocked_reason: reason });
-    if (transitionWarning !== undefined)
-        warnings.push(transitionWarning);
-    const finalLane = readLane(hqRoot, laneId);
-    printJson({ ok: true, action: "story.block", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "blocked", blocked_reason: reason, story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
-}
-async function runStoryDone(ctx, laneId, storyId, opts) {
-    const hqRoot = ctx.hqRoot();
-    let lane = readLane(hqRoot, laneId);
-    assertLaneRunsHereForOperatorMutation(ctx, lane, "update story status for");
-    if (!opts.verified) {
-        throw new LanesError("senior_verification_required", "Only a senior may mark a story done; pass --verified after reviewing or merging it", { lane_id: laneId });
-    }
-    if (!callerMayVerifyStory(ctx, lane)) {
-        throw new LanesError("senior_verification_required", `Caller is not the senior for lane ${laneId}`, {
-            lane_id: laneId,
-            senior: lane.senior,
-        });
-    }
-    const target = storyCommandTarget(lane, storyId, opts.project);
-    if (target.story.status !== "review") {
-        throw new LanesError("story_not_ready_for_verification", `Story ${target.projectId}/${target.storyId} must be in review before senior verification`, {
-            lane_id: laneId,
-            project_id: target.projectId,
-            story_id: target.storyId,
-            status: target.story.status,
-        });
-    }
-    const at = ctx.now().toISOString();
-    const warnings = [];
-    const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
-    lane = thread.lane;
-    if (thread.warning !== undefined)
-        warnings.push(thread.warning);
-    const before = lane;
-    const next = casUpdateLane(hqRoot, laneId, (current) => {
-        assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
-        return updateCarriedStory(current, target.projectId, target.storyId, "done", at, {
-            verified_at: at,
-            verified_by: current.senior,
-        });
-    });
-    const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_done", "done", { summary: "Senior verification complete" });
-    if (transitionWarning !== undefined)
-        warnings.push(transitionWarning);
-    const finalLane = readLane(hqRoot, laneId);
-    printJson({ ok: true, action: "story.done", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "done", verified: true, story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
-}
 /**
  * Registration state of the drain hook in the lane's account home, read the
  * way the provider reads it. Null when the lane has no bound account yet
@@ -7208,6 +6834,89 @@ function isDefiniteOutpostLaneNotFound(dispatched, laneId, ownerError) {
         ownerError?.error === "lane_not_found" &&
         ownerError.details.lane_id === laneId;
 }
+async function dispatchPrimaryLaneMessage(ctx, laneId, options) {
+    const outpostId = "primary";
+    const waitMs = outpostSingleLaneWaitMs(ctx.env);
+    let dispatched;
+    try {
+        dispatched = await ctx.dispatchOutpostExec({
+            outpostId,
+            command: buildOutpostLaneCommand({
+                action: "message",
+                laneId,
+                text: options.text,
+                project: options.project,
+                story: options.story,
+                account: options.account,
+                model: options.model,
+                effort: options.effort,
+                worker: options.worker,
+                compact: options.compact,
+                callerLaneId: ctx.env.HQ_LANE_ID?.trim() || undefined,
+                callerSessionId: sessionIdFromEnv(ctx.env),
+            }),
+            timeoutSeconds: Math.ceil(waitMs / 1000),
+            waitMs,
+        });
+    }
+    catch (err) {
+        const message = dispatchErrorMessage(err);
+        throw new LanesError("outpost_dispatch_failed", `Could not dispatch message for lane ${laneId} to primary: ${message}`, { lane_id: laneId, outpost_id: outpostId, wait_ms: waitMs, wait_env: OUTPOST_SINGLE_LANE_WAIT_ENV });
+    }
+    const confirmedCommandId = dispatched.commandId?.trim();
+    const ownerError = ownerErrorFromOutput(dispatched.stdout);
+    if (isDefiniteOutpostLaneNotFound(dispatched, laneId, ownerError)) {
+        throw new LanesError("lane_not_found", ownerError.message, {
+            ...ownerError.details,
+            lane_id: laneId,
+            outpost_id: outpostId,
+            command_id: confirmedCommandId,
+        });
+    }
+    if (dispatched.done === true &&
+        Boolean(confirmedCommandId) &&
+        dispatched.status === "Failed" &&
+        dispatched.exitCode !== null &&
+        dispatched.exitCode !== 0 &&
+        ownerError) {
+        throw new LanesError(ownerError.error, ownerError.message, {
+            ...ownerError.details,
+            lane_id: laneId,
+            outpost_id: outpostId,
+            command_id: confirmedCommandId,
+        });
+    }
+    if (dispatched.done !== true ||
+        dispatched.status !== "Success" ||
+        dispatched.exitCode !== 0 ||
+        !confirmedCommandId) {
+        throw new LanesError("outpost_delivery_unconfirmed", `Primary did not confirm message delivery for lane ${laneId}`, {
+            lane_id: laneId,
+            outpost_id: outpostId,
+            command_id: confirmedCommandId ?? null,
+            status: dispatched.status,
+            done: dispatched.done ?? false,
+            exit_code: dispatched.exitCode,
+        });
+    }
+    const remote = parseRemoteJson(dispatched.stdout, "Primary lane message");
+    if (remote === null ||
+        remote.ok !== true ||
+        remote.action !== "message" ||
+        remote.lane_id !== laneId ||
+        remote.accepted !== true) {
+        throw new LanesError("outpost_delivery_unconfirmed", `Primary completed exec without a confirmed message result for lane ${laneId}`, { lane_id: laneId, outpost_id: outpostId, command_id: confirmedCommandId });
+    }
+    if (!options.silent) {
+        printJson({
+            ...remote,
+            outpost_id: outpostId,
+            outpost_command_id: confirmedCommandId,
+            outpost_transport: "outposts_exec",
+            delivered_to: { host: outpostId, lane_id: laneId, mechanism: "outposts_exec" },
+        });
+    }
+}
 async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false) {
     if (lane.host.kind !== "outpost") {
         throw new LanesError("outpost_dispatch_failed", `Lane ${lane.lane_id} has no Outpost host to dispatch stop to`, { lane_id: lane.lane_id });
@@ -7882,6 +7591,7 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
                                 ? { model: automatic.preservedModel, model_source: "preserved" }
                                 : {}),
                     },
+                    accountSelection: selection,
                 };
             }
             let latest;
@@ -7899,7 +7609,10 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
                 latest.last_resume?.session_id !== lane.last_resume?.session_id)
                 return { lane: latest };
             if (selection.account === lane.account) {
-                return { lane: persistClaudeAccountSelection(hqRoot, recoveredLane, selection) };
+                return {
+                    lane: persistClaudeAccountSelection(hqRoot, recoveredLane, selection),
+                    accountSelection: selection,
+                };
             }
             try {
                 const moved = await prepareAccountMove(ctx, recoveredLane, {
@@ -7913,7 +7626,7 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
                     admissionLocksHeld: true,
                     accountSelection: selection,
                 });
-                return { lane: moved.lane };
+                return { lane: moved.lane, accountSelection: selection };
             }
             catch (err) {
                 let latest;
@@ -8052,6 +7765,19 @@ function attachJsonNoop(cmd) {
 }
 export function registerLanesCommand(parent, deps = {}) {
     const ctx = resolveDeps(deps);
+    const storyHandlers = createLaneStoryHandlers({
+        assertLaneRunsHereForOperatorMutation,
+        casUpdateLane,
+        combinedStoryWarning,
+        emitLaneMeshEvent,
+        ensureLaneThreadRecord,
+        printJson,
+        readLane,
+        storyBoardCheck,
+        storyNotOnBoardWarning,
+        updateLane,
+        validateProjectStories,
+    });
     const accountHandlers = createLaneAccountsHandlers({
         automaticBalanceMoveHistoryReason,
         ensureDir,
@@ -8069,6 +7795,7 @@ export function registerLanesCommand(parent, deps = {}) {
         MAX_PLACEMENT_OUTPOSTS,
         OUTPOST_QUESTION_LOOKUP_CONCURRENCY,
         assertLaneRunsHereForOperatorMutation,
+        assertQuestionAnswerAuthorized,
         assertQuestionCompanyMatchesLane,
         casUpdateQuestion,
         effectiveLaneQuestionCompany,
@@ -8107,6 +7834,7 @@ export function registerLanesCommand(parent, deps = {}) {
         assessLaneAdmission,
         casUpdateLane,
         dispatchOutpostLaneCommand,
+        dispatchPrimaryLaneMessage,
         drainHookStatusFor,
         laneIsHostedHere,
         laneWithRecoveredProviderSession,
@@ -8207,6 +7935,11 @@ export function registerLanesCommand(parent, deps = {}) {
     }, wrap);
     registerOutpostPrunerCommand(lanes);
     registerLaneKpisCommand(lanes, { hqRoot: ctx.hqRoot, now: ctx.now, wrap });
+    registerLaneAutopilotReportCommand(lanes, {
+        hqRoot: ctx.hqRoot,
+        now: ctx.now,
+        currentHost: () => resolveAdmissionHost({ hostname: ctx.hostname, readOutpostIdentity: ctx.readOutpostIdentity }),
+    }, wrap);
     const noStoryOption = new Option("--no-story <reason>", "Create a lane without a story and record why");
     noStoryOption.attributeName = () => "noStory";
     lanes
@@ -8418,7 +8151,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .description("List the stories carried by a lane")
         .argument("<lane-id>", "Lane id")
         .action(wrap(async (laneId) => {
-        await runStoryList(ctx, laneId);
+        await storyHandlers.runStoryList(ctx, laneId);
     }));
     stories
         .command("add")
@@ -8427,7 +8160,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .argument("<story-id>", "Story id")
         .option("--project <slug>", "Project id; defaults to the lane's current project")
         .action(wrap(async (laneId, storyId, opts) => {
-        await runStoryAdd(ctx, laneId, storyId, opts);
+        await storyHandlers.runStoryAdd(ctx, laneId, storyId, opts);
     }));
     stories
         .command("start")
@@ -8436,7 +8169,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .argument("<story-id>", "Story id")
         .option("--project <slug>", "Project id; defaults to the lane's current project")
         .action(wrap(async (laneId, storyId, opts) => {
-        await runStoryStart(ctx, laneId, storyId, opts);
+        await storyHandlers.runStoryStart(ctx, laneId, storyId, opts);
     }));
     stories
         .command("block")
@@ -8446,7 +8179,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .requiredOption("--reason <text>", "Why the story is blocked")
         .option("--project <slug>", "Project id; defaults to the lane's current project")
         .action(wrap(async (laneId, storyId, opts) => {
-        await runStoryBlock(ctx, laneId, storyId, opts);
+        await storyHandlers.runStoryBlock(ctx, laneId, storyId, opts);
     }));
     stories
         .command("done")
@@ -8456,7 +8189,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .requiredOption("--verified", "Confirm senior review or merge")
         .option("--project <slug>", "Project id; defaults to the lane's current project")
         .action(wrap(async (laneId, storyId, opts) => {
-        await runStoryDone(ctx, laneId, storyId, opts);
+        await storyHandlers.runStoryDone(ctx, laneId, storyId, opts);
     }));
     lanes
         .command("message")
@@ -8745,9 +8478,11 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (opts) => {
         await runPickup(ctx, opts);
     }));
-    lanes
-        .command("autopilot")
-        .description("Check registered team leads and wake them for ready work")
+    const autopilot = lanes.commands.find((command) => command.name() === "autopilot");
+    if (!autopilot)
+        throw new Error("Lanes autopilot command group was not registered");
+    autopilot
+        .description("Run lead autopilot checks and report follow-through metrics")
         .command("run")
         .description("Run one lead autopilot check pass")
         .option("--dry-run", "Report proposed wakes without writing them")