@indigoai-us/hq-cli 5.280.0 → 5.282.0

package/dist/commands/core-ontology.js

@@ -20,6 +20,7 @@ import { buildEntityIndex } from "../lib/checkpoint-ontology/tree.js";
 import { MERGE_COPIES_FLAG, mergeCopies, } from "../lib/checkpoint-ontology/merge-copies.js";
 import { callDeleteEndpoint } from "./files.js";
 import { resolveVaultCredential } from "../utils/resolve-vault-credential.js";
+import { registerCoreOntologyNativeCommands } from "./core-ontology-native.js";
 export const ONTOLOGY_PAYLOAD_FILE = "payload.json";
 class OntologyUsageError extends Error {
 }
@@ -267,5 +268,15 @@ export function registerCoreOntologyCommand(core) {
         }
     });
     describeCoreCommand(apply, { execution: "native", root: "live" });
+    registerCoreOntologyNativeCommands(ontology, () => {
+        const argv = process.argv.slice(2);
+        const coreIndex = argv.indexOf("core");
+        const ontologyIndex = argv.indexOf("ontology", coreIndex + 1);
+        const rootOptionIndex = argv.indexOf("--hq-root", coreIndex + 1);
+        const groupRoot = rootOptionIndex >= 0 && (ontologyIndex < 0 || rootOptionIndex < ontologyIndex)
+            ? argv[rootOptionIndex + 1]
+            : undefined;
+        return groupRoot ? rootFor({ hqRoot: groupRoot }) : process.env.HQ_ROOT || rootFor({});
+    });
 }
 //# sourceMappingURL=core-ontology.js.map

package/dist/commands/core.js

@@ -222,6 +222,15 @@ export const SCAFFOLD_ONLY_ASSETS = [
     { asset: "core/scripts/hq-delegate-secrets.sh", root: "live", summary: "Rollback shell for native delegate secrets" },
     { asset: "core/scripts/hq-delegate-transfer.sh", root: "live", summary: "Rollback shell for native delegate transfer" },
     { asset: "core/scripts/lib/secret-patterns.sh", root: "live", summary: "Secret-pattern library sourced by the delegate rollback shells" },
+    // Retained rollback companions for the gated native ontology commands. These
+    // are loose HQ-tree assets, but `hq core ontology` dispatches natively.
+    { asset: "core/scripts/ontology-audience-grant.sh", root: "live", summary: "Rollback companion for native ontology audience grant" },
+    { asset: "core/scripts/ontology-brief.mjs", root: "live", summary: "Rollback companion for native ontology brief" },
+    { asset: "core/scripts/ontology-candidate.sh", root: "live", summary: "Rollback companion for native ontology candidate" },
+    { asset: "core/scripts/ontology-garden.mjs", root: "live", summary: "Rollback companion for native ontology garden" },
+    { asset: "core/scripts/ontology-source-worklist.sh", root: "live", summary: "Rollback companion for native ontology source worklist" },
+    { asset: "core/scripts/source-yaml-validate.sh", root: "cwd", summary: "Rollback companion for native source YAML validation" },
+    { asset: "core/scripts/knowledge-prefs.sh", root: "live", summary: "Sibling dependency for ontology candidate rollback companion" },
     ...NATIVE_UTILITY_COMMANDS.map(({ asset, root, summary }) => ({
         asset,
         root,

package/dist/commands/group-grants.js

@@ -242,8 +242,9 @@ export function registerGroupGrantsCommand(program) {
     });
     grants
         .command("outbound")
-        .description("List grants a source-company group holds on other companies")
-        .requiredOption("--group <groupId>", "Group id to inspect")
+        .description("List grants a source-company group holds on other companies; " +
+        "requires --group <groupId>.")
+        .requiredOption("--group <groupId>", "Group id to inspect (required)")
         .action(async (opts) => {
         try {
             const token = await ensureCognitoToken();

package/dist/commands/lanes-message.js

@@ -507,6 +507,7 @@ export function createLaneMessageHandlers(deps) {
                                             ...current,
                                             state: "queued",
                                             queued_reason: admission.reason ?? "throttle",
+                                            queued_details: undefined,
                                             queued_at: at,
                                             pending_resume: {
                                                 session_id: sessionId,

package/dist/commands/lanes-move.js

@@ -156,6 +156,7 @@ export function createLaneMoveHandlers(deps) {
                 host: target,
                 account,
                 queued_reason: undefined,
+                queued_details: undefined,
                 admission_reserved_at: undefined,
             }));
         }, ctx.sleep);
@@ -218,6 +219,7 @@ export function createLaneMoveHandlers(deps) {
                         host: before.host,
                         account: before.account,
                         queued_reason: before.queued_reason,
+                        queued_details: before.queued_details,
                         admission_reserved_at: before.admission_reserved_at,
                     }));
                     return true;

package/dist/commands/lanes-resume.js

@@ -317,6 +317,7 @@ export function createLaneResumeHandlers(deps) {
                                 ...current,
                                 state: "queued",
                                 queued_reason: admission.reason ?? "throttle",
+                                queued_details: undefined,
                                 queued_at: at,
                                 pending_resume: {
                                     session_id: sessionId,

package/dist/commands/lanes-shared.d.ts

@@ -1,6 +1,7 @@
 import type { LaneCompanyRef, LanePlacementPolicy, LaneRecord, LanesConfig, QuestionAnswer, QuestionBody, QuestionRecord, SeniorRef, AccountHistoryEntry, LaneAccountSelection, PendingResume, QueuedReason, ResolvedLaneWorker, LivenessDeps, MachineIdentity, MonitorEvidenceReader, ReconcileHost, RunCommand, ThrottleDeps, withLaneHireLocks } from "../lib/lanes/index.js";
 import type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 import type { OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
+import type { CpuBusySource } from "../lib/lanes/throttle.js";
 import type { ProbeCommand } from "../lib/lanes/models.js";
 import type { KillProcessFn, ProveDetachedFn, SpawnProcessFn } from "../lib/lanes/spawn.js";
 import type { WatcherLoopDeps } from "../lib/lanes/watcher.js";
@@ -81,6 +82,11 @@ export interface AdmissionResult {
     action: "start" | "queue" | "refuse";
     reason?: QueuedReason;
     error?: LanesError;
+    throttle?: {
+        last_busy: number | null;
+        busy_source: CpuBusySource | undefined;
+        sampled_at: string | undefined;
+    };
 }
 export interface PrepareAccountMoveInput {
     account: string;

package/dist/commands/lanes.d.ts

@@ -25,6 +25,7 @@ export { spawnLaneWorker };
 export { questionBodyAbsPath };
 export { MAX_LANE_DEPTH };
 export declare const LANES_RUNS_REL: string;
+export declare const LANE_REMOTE_MIRROR_SYNC_FLAG = "lanes.remote-done-mirror";
 /** The lane → mesh seam. Defined in lib/lanes/mesh-events.ts; the watcher shares it. */
 export { emitLaneDecisionEvents };
 export interface LanesCommandDeps {

package/dist/commands/lanes.js

@@ -61,6 +61,7 @@ import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { parseCliEffort, resolveLaneEffort, } from "../lib/lanes/effort.js";
 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";
@@ -74,6 +75,8 @@ export { spawnLaneWorker };
 export { questionBodyAbsPath };
 export { MAX_LANE_DEPTH };
 export const LANES_RUNS_REL = path.join("workspace", "lanes-runs");
+export const LANE_REMOTE_MIRROR_SYNC_FLAG = "lanes.remote-done-mirror";
+const REMOTE_MIRROR_REFRESH_BATCH_SIZE = 100;
 /** The lane → mesh seam. Defined in lib/lanes/mesh-events.ts; the watcher shares it. */
 export { emitLaneDecisionEvents };
 function withoutProviderHome(value) {
@@ -714,7 +717,7 @@ async function dispatchOutpostLaneList(ctx, outpostId, query, timeoutSeconds, wa
         timeoutSeconds,
         waitMs,
     });
-    if (!rejectedLaneListFlag(filtered, query))
+    if (query.strictSnapshot || !rejectedLaneListFlag(filtered, query))
         return filtered;
     return ctx.dispatchOutpostExec({
         outpostId,
@@ -874,6 +877,7 @@ async function withResumeHireAdmission(ctx, lane, fn, grantContext) {
         !listLaneIds(hqRoot).includes(lane.senior.id)) {
         throw new LanesError("hire_grant_context_required", `Resume of Outpost lane ${lane.lane_id} requires the primary senior's hire-grant context`, { lane_id: lane.lane_id, senior_lane_id: lane.senior.id });
     }
+    await refreshRemoteLaneMirrors(ctx, hqRoot, loadAllLanes(hqRoot), new Set([lane.senior.id]));
     return withHireGrantAdmission(hqRoot, lane.senior.id, (snapshot) => {
         const current = readLane(hqRoot, lane.lane_id);
         if (grantContext !== undefined &&
@@ -1054,6 +1058,7 @@ function normalizedLaneListQuery(query) {
         ...(query.active ? { active: true } : {}),
         ...(query.hierarchy === undefined ? {} : { hierarchy: query.hierarchy }),
         ...(query.snapshot ? { snapshot: true } : {}),
+        ...(query.strictSnapshot ? { strictSnapshot: true } : {}),
     };
 }
 async function readOutpostLaneRecordsUncached(ctx, outpostId, query) {
@@ -1144,6 +1149,156 @@ async function readOutpostLaneRecords(ctx, outpostId, requestedQuery = {}) {
     byOutpost.set(outpostId, { queryKey, promise });
     return promise;
 }
+/** Refresh only primary-created, non-terminal Outpost mirrors in one bounded owner query per Outpost. */
+async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
+    const result = {
+        updated: new Map(),
+        unverifiedRemote: new Map(),
+    };
+    const host = reconcileHostFromCtx(ctx);
+    if (host.outpostId !== null || parentLaneIds?.size === 0)
+        return result;
+    let primaryIdentity;
+    const originMatchesThisPrimary = (lane) => {
+        if (lane.origin_host_source !== "imds") {
+            return lane.origin_host === host.hostname;
+        }
+        primaryIdentity ??= ctx.resolveMachineIdentity();
+        if (primaryIdentity.status !== "ok")
+            return false;
+        const primaryImdsId = primaryIdentity.imds ??
+            (primaryIdentity.source === "imds" ? primaryIdentity.id : null);
+        return primaryImdsId !== null && primaryImdsId === lane.origin_host;
+    };
+    const candidates = records
+        .filter((lane) => lane.host.kind === "outpost" &&
+        originMatchesThisPrimary(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));
+    if (candidates.length === 0)
+        return result;
+    const enabledByCompany = new Map();
+    const enabledCandidates = [];
+    for (const lane of candidates) {
+        const companyKey = JSON.stringify([lane.company?.uid ?? null, lane.company?.slug ?? null]);
+        let enabled = enabledByCompany.get(companyKey);
+        if (enabled === undefined) {
+            enabled = await readLanesRegistryFlag(LANE_REMOTE_MIRROR_SYNC_FLAG, {
+                company: lane.company,
+                env: ctx.env,
+            });
+            enabledByCompany.set(companyKey, enabled);
+        }
+        if (enabled)
+            enabledCandidates.push(lane);
+    }
+    if (enabledCandidates.length === 0)
+        return result;
+    const byOutpost = new Map();
+    for (const lane of enabledCandidates) {
+        const group = byOutpost.get(lane.host.id) ?? [];
+        group.push(lane);
+        byOutpost.set(lane.host.id, group);
+    }
+    for (const [outpostId, group] of byOutpost) {
+        const batch = group.slice(0, REMOTE_MIRROR_REFRESH_BATCH_SIZE);
+        const overflow = group.slice(REMOTE_MIRROR_REFRESH_BATCH_SIZE);
+        if (overflow.length > 0) {
+            const ids = overflow.map((lane) => lane.lane_id);
+            for (const lane of overflow) {
+                result.unverifiedRemote.set(lane.lane_id, "refresh_batch_limit");
+            }
+            process.stderr.write(`hq lanes: unverified remote mirrors from Outpost ${outpostId} remain counted; refresh batch limit left lanes ${ids.join(", ")} unread\n`);
+        }
+        let ownerRecords;
+        try {
+            ownerRecords = await readOutpostLaneRecords(ctx, outpostId, {
+                laneIds: batch.map((lane) => lane.lane_id),
+                snapshot: true,
+                strictSnapshot: true,
+            });
+        }
+        catch (error) {
+            const detail = isLanesError(error)
+                ? `${error.error}: ${error.message}`
+                : dispatchErrorMessage(error);
+            for (const lane of batch)
+                result.unverifiedRemote.set(lane.lane_id, detail);
+            process.stderr.write(`hq lanes: unverified remote mirrors from Outpost ${outpostId} remain counted: ${detail}; lanes ${batch.map((lane) => lane.lane_id).join(", ")}\n`);
+            continue;
+        }
+        for (const mirror of batch) {
+            const matches = ownerRecords.filter((lane) => lane.lane_id === mirror.lane_id);
+            const owner = matches[0];
+            const ownerIsHostedByOutpost = owner !== undefined && ((owner.host.kind === "outpost" && owner.host.id === outpostId) ||
+                (owner.host.kind === "local" && owner.host.id.trim() !== ""));
+            if (matches.length !== 1 ||
+                owner === undefined ||
+                !ownerIsHostedByOutpost ||
+                (owner.company?.uid ?? null) !== (mirror.company?.uid ?? null) ||
+                (owner.company?.slug ?? null) !== (mirror.company?.slug ?? null)) {
+                const detail = matches.length === 0
+                    ? "owner did not return the requested lane"
+                    : matches.length > 1
+                        ? "owner returned duplicate lane rows"
+                        : "owner lane identity did not match its mirror";
+                result.unverifiedRemote.set(mirror.lane_id, detail);
+                process.stderr.write(`hq lanes: unverified remote mirror ${mirror.lane_id} from Outpost ${outpostId} remains counted: ${detail}\n`);
+                continue;
+            }
+            const endedAt = isTerminalLaneState(owner.state)
+                ? owner.last_envelope?.at ?? owner.updated_at
+                : undefined;
+            const envelopeSummary = isTerminalLaneState(owner.state)
+                ? owner.envelope_summary
+                : undefined;
+            const before = readLane(hqRoot, mirror.lane_id);
+            if (before.host.kind !== "outpost" || before.host.id !== outpostId ||
+                !originMatchesThisPrimary(before) || isTerminalLaneState(before.state)) {
+                result.updated.set(mirror.lane_id, before);
+                continue;
+            }
+            const needsUpdate = before.state !== owner.state ||
+                before.queued_reason !== (owner.state === "queued" ? owner.queued_reason : undefined) ||
+                before.ended_at !== endedAt ||
+                before.envelope_summary !== envelopeSummary ||
+                (isTerminalLaneState(owner.state) && (JSON.stringify(before.last_envelope) !== JSON.stringify(owner.last_envelope) ||
+                    before.story_complete !== owner.story_complete ||
+                    before.story_complete_reason !== owner.story_complete_reason ||
+                    before.story_status !== owner.story_status ||
+                    before.terminal_reason !== owner.terminal_reason));
+            if (!needsUpdate) {
+                result.updated.set(mirror.lane_id, before);
+                continue;
+            }
+            const updated = retryUpdateLane(hqRoot, mirror.lane_id, "reconcile", (current) => {
+                if (current.host.kind !== "outpost" || current.host.id !== outpostId ||
+                    !originMatchesThisPrimary(current) || isTerminalLaneState(current.state))
+                    return current;
+                return {
+                    ...current,
+                    state: owner.state,
+                    queued_reason: owner.state === "queued" ? owner.queued_reason : undefined,
+                    ended_at: endedAt,
+                    envelope_summary: envelopeSummary,
+                    ...(isTerminalLaneState(owner.state) ? {
+                        last_envelope: owner.last_envelope,
+                        story_complete: owner.story_complete,
+                        story_complete_reason: owner.story_complete_reason,
+                        story_status: owner.story_status,
+                        terminal_reason: owner.terminal_reason,
+                        terminal_details: owner.terminal_details,
+                    } : {}),
+                };
+            });
+            result.updated.set(mirror.lane_id, updated);
+        }
+    }
+    return result;
+}
 async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
     try {
         return { lane: readLane(ctx.hqRoot(), laneId), remoteOnly: false };
@@ -1802,11 +1957,16 @@ async function applyThrottle(hqRoot, config, ctx, current, provider, pinnedAccou
     if (current.action !== "start" &&
         !(current.action === "queue" && current.reason === "queue_position"))
         return current;
-    const { decision } = await decideAdmission(hqRoot, config.throttle, ctx.throttleDeps);
+    const { decision, state } = await decideAdmission(hqRoot, config.throttle, ctx.throttleDeps);
     if (decision.admit)
         return current;
+    const throttle = {
+        last_busy: state.last_busy ?? null,
+        busy_source: state.busy_source,
+        sampled_at: state.sampled_at,
+    };
     if (current.action === "queue")
-        return { action: "queue", reason: "throttle" };
+        return { action: "queue", reason: "throttle", throttle };
     const providerCfg = config.providers[provider];
     const host = options.host ?? reconcileHostFromCtx(ctx);
     const nowMs = options.nowMs ?? ctx.now().getTime();
@@ -1838,7 +1998,7 @@ async function applyThrottle(hqRoot, config, ctx, current, provider, pinnedAccou
             }),
         };
     }
-    return { action: "queue", reason: "throttle" };
+    return { action: "queue", reason: "throttle", throttle };
 }
 async function assessLaneAdmission(ctx, lane, options) {
     const hqRoot = ctx.hqRoot();
@@ -2196,6 +2356,7 @@ function markDispatchFailure(hqRoot, laneId, details) {
             ...current,
             state: "failed",
             queued_reason: undefined,
+            queued_details: undefined,
             terminal_reason: DISPATCH_TERMINAL_REASON,
             terminal_details: details,
         };
@@ -2219,6 +2380,7 @@ export function pickupFailureUpdater(reasonRaw, details) {
             ...current,
             state: "failed",
             queued_reason: undefined,
+            queued_details: undefined,
             pickup_validation_pending: undefined,
             pickup_validation_pending_since: undefined,
             terminal_reason: reason,
@@ -3035,6 +3197,9 @@ async function runCreate(ctx, opts) {
                 : {}),
             attribution_history: [],
         };
+        if (senior.kind === "lane" && senior.id) {
+            await refreshRemoteLaneMirrors(ctx, hqRoot, loadAllLanes(hqRoot), new Set([senior.id]));
+        }
         const lane = senior.kind === "lane"
             ? withHireGrantAdmission(hqRoot, senior.id, ({ parent, children, parentGrant, availableChildGrant }) => {
                 if (isTerminalLaneState(parent.state)) {
@@ -3083,6 +3248,7 @@ async function runCreate(ctx, opts) {
                         ...current,
                         state: "failed",
                         queued_reason: undefined,
+                        queued_details: undefined,
                         terminal_reason: "mesh_thread_registration_failed",
                     }));
                 }
@@ -3227,6 +3393,7 @@ async function dispatchCreatedOutpostLane(ctx, input) {
                 ...current,
                 state: "cancelled",
                 queued_reason: undefined,
+                queued_details: undefined,
                 terminal_reason: "outpost_self_target",
                 outpost_command_id: dispatched.commandId,
             }));
@@ -4139,6 +4306,7 @@ async function runPickup(ctx, opts) {
                     ...live,
                     state: "queued",
                     queued_reason: admission.reason ?? "throttle",
+                    queued_details: undefined,
                     queued_at: live.queued_at ?? ctx.now().toISOString(),
                 };
             });
@@ -4228,7 +4396,7 @@ async function runList(ctx, opts) {
     const hierarchyIds = opts.hierarchy === undefined
         ? undefined
         : new Set(selectOutpostHireGrantHierarchy(opts.hierarchy, laneSource).map((lane) => lane.lane_id));
-    const selectedLanes = laneSource
+    let selectedLanes = laneSource
         .filter((lane) => {
         if (requestedLaneIds.length > 0 && !requestedIds.has(lane.lane_id))
             return false;
@@ -4254,9 +4422,27 @@ async function runList(ctx, opts) {
     })
         .sort(compareLaneQueueOrder);
     if (opts.snapshot) {
-        printJson({ ok: true, action: "list", lanes: selectedLanes });
+        printJson({
+            ok: true,
+            action: "list",
+            lanes: selectedLanes.map((lane) => {
+                if (!isTerminalLaneState(lane.state))
+                    return lane;
+                const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
+                return envelope?.summary ? { ...lane, envelope_summary: envelope.summary } : lane;
+            }),
+        });
         return;
     }
+    const remoteRefresh = await refreshRemoteLaneMirrors(ctx, hqRoot, laneSource, new Set(selectedLanes
+        .filter((lane) => !isTerminalLaneState(lane.state))
+        .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);
     const now = ctx.now();
     const host = reconcileHostFromCtx(ctx);
     const allLanes = laneSource;
@@ -4313,11 +4499,12 @@ async function runList(ctx, opts) {
         return {
             ...lane,
             ...hireByLane.get(lane.lane_id),
+            ...(remoteRefresh.unverifiedRemote.has(lane.lane_id) ? { unverified_remote: true } : {}),
             stories: laneStories(lane),
             story_ids: laneStories(lane).map((story) => story.story_id),
             no_story_reason: lane.no_story_reason ?? null,
             ...(remoteQueued
-                ? { state: "remote", remote_state: lane.state, queued_reason: undefined }
+                ? { state: "remote", remote_state: lane.state, queued_reason: undefined, queued_details: undefined }
                 : {}),
             overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, now),
             stalled: Boolean(lane.stalled),
@@ -4349,6 +4536,9 @@ async function runList(ctx, opts) {
         ok: true,
         action: "list",
         lanes,
+        ...(remoteRefresh.unverifiedRemote.size > 0
+            ? { unverified_remote_lanes: [...remoteRefresh.unverifiedRemote.keys()] }
+            : {}),
         ...(host_capacity !== undefined ? { host_capacity } : {}),
     };
     if (opts.human)
@@ -4552,7 +4742,7 @@ async function runShow(ctx, laneId) {
         storedLane.host.kind === "outpost" &&
         !laneRunsHere(storedLane, reconcileHostFromCtx(ctx));
     const lane = remoteQueued
-        ? { ...storedLane, state: "remote", remote_state: storedLane.state, queued_reason: undefined }
+        ? { ...storedLane, state: "remote", remote_state: storedLane.state, queued_reason: undefined, queued_details: undefined }
         : storedLane;
     const askDeliveryFailed = readJsonFile(askDeliveryFailedPath(hqRoot, laneId));
     const keepAliveState = resolveLaneKeepAlive(hqRoot, storedLane);
@@ -4768,6 +4958,13 @@ async function applyHireGrant(ctx, laneId, hireGrant, authorization, grantContex
             ? [initial.senior.id]
             : []),
     ];
+    if (authorization === "senior") {
+        const parentLaneIds = new Set([initial.lane_id]);
+        if (initial.senior.kind === "lane" && initial.senior.id) {
+            parentLaneIds.add(initial.senior.id);
+        }
+        await refreshRemoteLaneMirrors(ctx, hqRoot, loadAllLanes(hqRoot), parentLaneIds);
+    }
     const updated = ctx.withGrantHireLocks(hqRoot, lockedLaneIds, () => {
         const current = readLane(hqRoot, laneId);
         const currentCallerAuthorization = authorization === "senior"
@@ -5262,6 +5459,7 @@ async function runAdmit(ctx, laneId, opts) {
             });
         }
         let blockedBy;
+        let throttleTelemetry;
         if (opts.force) {
             const callerAuthorization = forceAdmissionAuthorization(ctx, lane);
             if (!callerAuthorization.authorized) {
@@ -5269,9 +5467,14 @@ async function runAdmit(ctx, laneId, opts) {
             }
             const config = loadLanesConfig(hqRoot);
             const lanes = loadAllLanes(hqRoot).filter((row) => row.lane_id !== laneId && laneRunsHere(row, host));
-            const { decision } = await decideAdmission(hqRoot, config.throttle, ctx.throttleDeps);
+            const { decision, state } = await decideAdmission(hqRoot, config.throttle, ctx.throttleDeps);
             if (!decision.admit) {
                 blockedBy = "throttle";
+                throttleTelemetry = {
+                    last_busy: state.last_busy ?? null,
+                    busy_source: state.busy_source,
+                    sampled_at: state.sampled_at,
+                };
             }
             else if (hasEarlierEligibleQueuedLane(lanes, lane, config, host, (row) => row.worker_profile === undefined
                 ? undefined
@@ -5284,6 +5487,7 @@ async function runAdmit(ctx, laneId, opts) {
                 queueAt: lane.queued_at ?? lane.created_at,
                 alreadyQueued: true,
             });
+            throttleTelemetry = admission.throttle;
             if (admission.action === "refuse" && admission.error) {
                 throw admission.error;
             }
@@ -5300,7 +5504,7 @@ async function runAdmit(ctx, laneId, opts) {
                         state: current.state,
                     });
                 }
-                return { ...current, queued_reason: blockedBy };
+                return { ...current, queued_reason: blockedBy, queued_details: undefined };
             });
             printJson({
                 ok: true,
@@ -5308,6 +5512,9 @@ async function runAdmit(ctx, laneId, opts) {
                 lane_id: laneId,
                 admitted: false,
                 blocked_by: blockedBy,
+                ...(blockedBy === "throttle" && throttleTelemetry !== undefined
+                    ? throttleTelemetry
+                    : {}),
                 lane: updated,
             });
             return;
@@ -5675,6 +5882,7 @@ async function prepareAccountMove(ctx, lane, input) {
             else if (queued) {
                 next.state = "queued";
                 next.queued_reason = admission?.reason ?? "throttle";
+                next.queued_details = undefined;
                 next.queued_at = at;
             }
             else {
@@ -6221,6 +6429,12 @@ async function reparentOnOwner(ctx, laneId, opts) {
     const nextSenior = parseSeniorRef(opts.senior);
     assertSeniorExists(hqRoot, nextSenior, ctx);
     const initial = readLane(hqRoot, laneId);
+    const refreshParents = new Set();
+    if (initial.senior.kind === "lane" && initial.senior.id)
+        refreshParents.add(initial.senior.id);
+    if (nextSenior.kind === "lane" && nextSenior.id)
+        refreshParents.add(nextSenior.id);
+    await refreshRemoteLaneMirrors(ctx, hqRoot, loadAllLanes(hqRoot), refreshParents);
     const lockIds = [
         laneId,
         ...(initial.senior.kind === "lane" && initial.senior.id ? [initial.senior.id] : []),
@@ -6380,12 +6594,58 @@ const CANONICAL_LOG_STREAMS = [
 ];
 async function runLogs(ctx, laneId, opts) {
     const hqRoot = ctx.hqRoot();
-    readLane(hqRoot, laneId);
-    const logsDir = path.join(runDir(hqRoot, laneId), "logs");
+    const lane = readLane(hqRoot, laneId);
     const tail = parseOptionalInt(opts.tail, "--tail");
     if (tail === 0) {
         throw new LanesError("invalid_integer", "--tail must be a positive integer", { flag: "--tail", value: opts.tail });
     }
+    if (lane.host.kind === "outpost" &&
+        !laneRunsHere(lane, reconcileHostFromCtx(ctx)) &&
+        await readLanesRegistryFlag(LANE_REMOTE_MIRROR_SYNC_FLAG, {
+            company: lane.company,
+            env: ctx.env,
+        })) {
+        const outpostId = lane.host.id;
+        const waitMs = outpostSingleLaneWaitMs(ctx.env);
+        let dispatched;
+        try {
+            dispatched = await ctx.dispatchOutpostExec({
+                outpostId,
+                command: buildOutpostLaneCommand({
+                    action: "logs",
+                    laneId,
+                    hqBinary: outpostCliOverride(ctx, outpostId),
+                    ...(tail === undefined ? {} : { tail: String(tail) }),
+                    json: true,
+                }),
+                timeoutSeconds: Math.ceil(waitMs / 1000),
+                waitMs,
+            });
+        }
+        catch (error) {
+            throw new LanesError("outpost_lane_logs_unavailable", `Could not read logs for lane ${laneId} from Outpost ${outpostId}: ${dispatchErrorMessage(error)}`, { lane_id: laneId, outpost_id: outpostId, wait_ms: waitMs, wait_env: OUTPOST_SINGLE_LANE_WAIT_ENV });
+        }
+        if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
+            throw new LanesError("outpost_lane_logs_unavailable", `Outpost ${outpostId} did not return logs for lane ${laneId}`, { lane_id: laneId, outpost_id: outpostId, status: dispatched.status, exit_code: dispatched.exitCode });
+        }
+        let body;
+        try {
+            body = JSON.parse(dispatched.stdout);
+        }
+        catch (error) {
+            throw new LanesError("outpost_lane_logs_invalid", `Outpost ${outpostId} returned invalid logs JSON for lane ${laneId}: ${dispatchErrorMessage(error)}`, { lane_id: laneId, outpost_id: outpostId });
+        }
+        if (body === null || typeof body !== "object" || Array.isArray(body) ||
+            body.ok !== true ||
+            body.action !== "logs" ||
+            body.lane_id !== laneId ||
+            !Array.isArray(body.streams)) {
+            throw new LanesError("outpost_lane_logs_invalid", `Outpost ${outpostId} returned a malformed logs payload for lane ${laneId}`, { lane_id: laneId, outpost_id: outpostId });
+        }
+        printJson(body);
+        return;
+    }
+    const logsDir = path.join(runDir(hqRoot, laneId), "logs");
     const names = new Set(CANONICAL_LOG_STREAMS);
     if (fs.existsSync(logsDir)) {
         for (const name of fs.readdirSync(logsDir)) {
@@ -6705,6 +6965,7 @@ async function runStop(ctx, laneId, reason, quiet = false) {
             ...current,
             state: stopCommittedState(current.state),
             queued_reason: undefined,
+            queued_details: undefined,
             ...(operatorReason === undefined ? {} : {
                 stop_history: [
                     ...(current.stop_history ?? []),
@@ -6779,6 +7040,7 @@ async function runInterrupt(ctx, laneId, reason) {
                 ...current,
                 state: "interrupted",
                 queued_reason: undefined,
+                queued_details: undefined,
                 interrupted_at: at,
                 terminal_reason: "operator_interrupt",
                 ...(operatorReason === undefined ? {} : {
@@ -7059,6 +7321,9 @@ function writeAnswerDeliveryFailed(hqRoot, laneId, questionId, err, at) {
 async function runReconcile(ctx, opts, recoverQueuedMessages) {
     const fromEnv = ctx.env.HQ_ROOT?.trim();
     const hqRoot = fromEnv && ctx.existsSync(fromEnv) ? fromEnv : ctx.hqRoot();
+    const mirrorRefresh = opts.dryRun
+        ? { updated: new Map(), unverifiedRemote: new Map() }
+        : await refreshRemoteLaneMirrors(ctx, hqRoot, loadAllLanes(hqRoot));
     const summary = await runReconcilePass(hqRoot, {
         now: ctx.now,
         host: reconcileHostFromCtx(ctx),
@@ -7174,7 +7439,12 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
             }
         },
     });
-    printJson(summary);
+    printJson({
+        ...summary,
+        ...(mirrorRefresh.unverifiedRemote.size > 0
+            ? { unverified_remote_lanes: [...mirrorRefresh.unverifiedRemote.keys()] }
+            : {}),
+    });
     if (!summary.ok) {
         process.exit(1);
     }

package/dist/lib/lanes/keep-alive.js

@@ -45,6 +45,7 @@ export function queueLaneTerminalResume(current, at, resumeText, options = {}) {
             ...current,
             state: "queued",
             queued_reason: undefined,
+            queued_details: undefined,
             queued_at: at,
             admission_reserved_at: undefined,
             terminal_reason: undefined,