@indigoai-us/hq-cli 5.294.0 → 5.296.0

package/dist/commands/lanes.js

@@ -31,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";
@@ -69,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";
@@ -85,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);
@@ -301,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,
@@ -514,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");
@@ -1053,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;
@@ -1089,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;
@@ -1280,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);
@@ -1288,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(),
@@ -1316,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();
@@ -1406,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;
             }
@@ -1424,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,
@@ -1445,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);
         }
     }
@@ -1524,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]
         : [
@@ -1537,6 +1526,7 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
                 hierarchy: [laneId],
                 snapshot: true,
             });
+            probedOutpostIds.push(outpostId);
         }
         catch (err) {
             if (requestedOutpostId !== undefined)
@@ -1555,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) });
@@ -3502,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,
@@ -4276,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;
     }
@@ -4306,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) {
@@ -4581,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,
@@ -4626,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 });
     }
@@ -4666,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));
@@ -4689,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,
@@ -4707,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;
@@ -4736,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, {
@@ -4772,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);
@@ -4846,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.
@@ -4878,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;
@@ -4890,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) {
@@ -5121,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(),
@@ -5146,10 +5062,12 @@ async function runShow(ctx, laneId) {
     })
         .slice(0, 20)
         .map(({ repo, pr, head_sha, recorded_at }) => ({ repo, pr, head_sha, recorded_at }));
+    const laneForShow = { ...lane };
+    delete laneForShow.resume_history;
     printJson({
         ok: true,
         action: "show",
-        lane,
+        lane: laneForShow,
         ...(laneIsSenior ? { reviews: recentReviews, reviews_skipped: reviewListing.skipped } : {}),
         ...hire,
         overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, ctx.now()),
@@ -5163,6 +5081,9 @@ 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,
+        // Public JSON key for the bounded start audit; `last_resume` remains unchanged.
+        resume_history: lane.resume_history ?? [],
+        keep_alive_history: lane.keep_alive_history ?? [],
         account: lane.account ?? null,
         account_history: lane.account_history ?? [],
         failed_resume_history: lane.failed_resume_history ?? [],
@@ -5186,15 +5107,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
                 ? {
@@ -5910,7 +5832,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,
@@ -6274,7 +6195,12 @@ async function prepareAccountMove(ctx, lane, input) {
                 }),
                 pending_resume: input.deferTurnStart
                     ? undefined
-                    : { session_id: sessionId, at, ...input.pending },
+                    : {
+                        session_id: sessionId,
+                        at,
+                        caller: ctx.env.HQ_LANE_ID?.trim() || "user",
+                        ...input.pending,
+                    },
             };
             applyResumeProfileAndEffort(current, next, {
                 ...(input.workerProfile !== undefined ? { profile: input.workerProfile } : {}),
@@ -6917,6 +6843,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 });
@@ -7591,6 +7600,7 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
                                 ? { model: automatic.preservedModel, model_source: "preserved" }
                                 : {}),
                     },
+                    accountSelection: selection,
                 };
             }
             let latest;
@@ -7608,7 +7618,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, {
@@ -7622,7 +7635,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;
@@ -7830,6 +7843,7 @@ export function registerLanesCommand(parent, deps = {}) {
         assessLaneAdmission,
         casUpdateLane,
         dispatchOutpostLaneCommand,
+        dispatchPrimaryLaneMessage,
         drainHookStatusFor,
         laneIsHostedHere,
         laneWithRecoveredProviderSession,
@@ -8166,6 +8180,15 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (laneId, storyId, opts) => {
         await storyHandlers.runStoryStart(ctx, laneId, storyId, opts);
     }));
+    stories
+        .command("review")
+        .description("Move a carried story to review")
+        .argument("<lane-id>", "Lane id")
+        .argument("<story-id>", "Story id")
+        .option("--project <slug>", "Project id; defaults to the lane's current project")
+        .action(wrap(async (laneId, storyId, opts) => {
+        await storyHandlers.runStoryReview(ctx, laneId, storyId, opts);
+    }));
     stories
         .command("block")
         .description("Mark one carried story blocked")