@indigoai-us/hq-cli 5.198.1 → 5.200.0

package/dist/commands/lanes.js

@@ -22,7 +22,8 @@ import { createOutpostHireGrantContext, parseOutpostHireGrantContext, sameHireGr
 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";
 export { LANE_HIRE_GRANTS_FLAG };
-import { buildOutpostCapacityCommand, buildOutpostBalanceMoveCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostMoveTargetCommand, buildOutpostQuestionAnswerCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, outpostRejectedEffortOption, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
+import { buildOutpostCapacityCommand, buildOutpostBalanceMoveCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostMoveTargetCommand, buildOutpostQuestionAnswerCommand, buildOutpostQuestionListCommand, buildOutpostQuestionShowCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, outpostRejectedEffortOption, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
+import { outpostHireSummaryCacheKey, readOutpostHireSummaryCache, writeOutpostHireSummaryCache, } from "../lib/lanes/outpost-hire-cache.js";
 import { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "../lib/lanes/host-capacity.js";
 import { BALANCE_MOVABLE_STATES, CLAUDE_ACCOUNT_BALANCE_FLAG, accountLoadsForReport, assertBalanceApplyEnabled, planClaudeBalanceMoves, selectClaudeAccount, } from "../lib/lanes/claude-account-balance.js";
 import { parseUserYaml } from "../utils/user-yaml-error.js";
@@ -31,7 +32,7 @@ import { vaultApiFetch } from "../utils/vault-api.js";
 import { openMeshTransport } from "../lib/mesh/client.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
-import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, withLaneAdmissionLock, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, withLaneAdmissionLock, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
@@ -55,6 +56,7 @@ const VENDOR_LOGIN = {
 };
 export { emitLaneDecisionEvents };
 export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+export const LANE_OUTPOST_QUESTION_VISIBILITY_FLAG = "lanes.outpost-question-visibility";
 function defaultLanePlacementEnabled() {
     return resolveProcessFlagGate(LANE_OUTPOST_LOAD_BALANCING_FLAG, { fallback: false }, () => false);
 }
@@ -72,6 +74,12 @@ function defaultLaneTrackerMeshEnabled(company) {
 function defaultLaneHireGrantsEnabled(company) {
     return readLanesRegistryFlag(LANE_HIRE_GRANTS_FLAG, { company });
 }
+function defaultLaneOutpostQuestionVisibilityEnabled(company, env) {
+    return readLanesRegistryFlag(LANE_OUTPOST_QUESTION_VISIBILITY_FLAG, {
+        company,
+        env,
+    });
+}
 function withoutProviderHome(value) {
     if (Array.isArray(value))
         return value.map(withoutProviderHome);
@@ -271,6 +279,8 @@ function resolveDeps(deps = {}) {
         isSsmOwnerDispatch: deps.isSsmOwnerDispatch ?? (() => isSsmRunCommandProcess()),
         withGrantHireLocks: deps.withGrantHireLocks ?? withLaneHireLocks,
         laneClaudeAccountBalanceEnabled: deps.laneClaudeAccountBalanceEnabled ?? defaultLaneClaudeAccountBalanceEnabled,
+        laneOutpostQuestionVisibilityEnabled: deps.laneOutpostQuestionVisibilityEnabled ??
+            ((company) => defaultLaneOutpostQuestionVisibilityEnabled(company, env)),
         laneTrackerEnabled: deps.laneTrackerEnabled ?? defaultLaneTrackerEnabled,
         laneTrackerMeshEnabled: deps.laneTrackerMeshEnabled ?? defaultLaneTrackerMeshEnabled,
         trackerActor: deps.trackerActor ?? defaultTrackerActor,
@@ -569,6 +579,32 @@ function normalizeLaneRecordView(raw) {
     return normalized;
 }
 async function ownerLaneHireFields(ctx, lane) {
+    if (lane.host.kind !== "outpost") {
+        throw new LanesError("outpost_lane_hire_summary_invalid", "Owner summary requires an Outpost-hosted lane", {
+            lane_id: lane.lane_id,
+        });
+    }
+    const nowMs = ctx.now().getTime();
+    const cachedEntries = readOutpostHireSummaryCache(ctx.hqRoot(), nowMs);
+    const cached = cachedEntries.get(outpostHireSummaryCacheKey(lane.host.id, lane.lane_id));
+    if (cached) {
+        return {
+            hire_grant: cached.hire_grant,
+            hire_alive_children: cached.hire_alive_children,
+            hire: cached.hire,
+            hire_summary: cached.hire_summary,
+        };
+    }
+    const fields = await fetchOwnerLaneHireFields(ctx, lane);
+    const cachedAtMs = ctx.now().getTime();
+    writeOutpostHireSummaryCache(ctx.hqRoot(), [{
+            outpost_id: lane.host.id,
+            lane_id: lane.lane_id,
+            ...fields,
+        }], cachedAtMs, cachedEntries);
+    return fields;
+}
+async function fetchOwnerLaneHireFields(ctx, lane) {
     if (lane.host.kind !== "outpost") {
         throw new LanesError("outpost_lane_hire_summary_invalid", "Owner summary requires an Outpost-hosted lane", {
             lane_id: lane.lane_id,
@@ -599,25 +635,42 @@ async function ownerLaneHireFields(ctx, lane) {
     if (!remote || remote.ok !== true || remote.action !== "show") {
         throw new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned an invalid hire summary for lane ${lane.lane_id}`, { lane_id: lane.lane_id, outpost_id: outpostId, command_id: dispatched.commandId });
     }
+    return validateOwnerLaneHireSummary({
+        outpostId,
+        laneId: lane.lane_id,
+        rawLane: remote.lane,
+        hireGrant: remote.hire_grant,
+        hireAliveChildren: remote.hire_alive_children,
+        hire: remote.hire,
+        hireSummary: remote.hire_summary,
+        commandId: dispatched.commandId,
+    });
+}
+function validateOwnerLaneHireSummary(input) {
     let ownerLane;
     try {
-        ownerLane = parseLaneRecord(normalizeLaneRecordView(remote.lane));
+        ownerLane = parseLaneRecord(normalizeLaneRecordView(input.rawLane));
     }
     catch (err) {
-        throw new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned an invalid lane snapshot for ${lane.lane_id}`, { lane_id: lane.lane_id, outpost_id: outpostId, cause: dispatchErrorMessage(err) });
+        throw new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${input.outpostId} returned an invalid lane snapshot for ${input.laneId}`, {
+            lane_id: input.laneId,
+            outpost_id: input.outpostId,
+            command_id: input.commandId,
+            cause: dispatchErrorMessage(err),
+        });
     }
-    const grant = remote.hire_grant;
-    const alive = remote.hire_alive_children;
-    if (ownerLane.lane_id !== lane.lane_id ||
+    const grant = input.hireGrant;
+    const alive = input.hireAliveChildren;
+    if (ownerLane.lane_id !== input.laneId ||
         ownerLane.host.kind !== "outpost" ||
-        ownerLane.host.id !== outpostId ||
+        ownerLane.host.id !== input.outpostId ||
         !Number.isSafeInteger(grant) ||
         grant < 0 ||
         !Number.isSafeInteger(alive) ||
         alive < 0 ||
-        remote.hire !== `${String(alive)}/${String(grant)}` ||
-        remote.hire_summary !== `hire ${String(alive)}/${String(grant)}`) {
-        throw new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned an inconsistent hire summary for lane ${lane.lane_id}`, { lane_id: lane.lane_id, outpost_id: outpostId, command_id: dispatched.commandId });
+        input.hire !== `${String(alive)}/${String(grant)}` ||
+        input.hireSummary !== `hire ${String(alive)}/${String(grant)}`) {
+        throw new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${input.outpostId} returned an inconsistent hire summary for lane ${input.laneId}`, { lane_id: input.laneId, outpost_id: input.outpostId, command_id: input.commandId });
     }
     return {
         hire_grant: grant,
@@ -626,6 +679,116 @@ async function ownerLaneHireFields(ctx, lane) {
         hire_summary: `hire ${alive}/${grant}`,
     };
 }
+async function fetchOutpostListHireSummaries(ctx, outpostId, lanes) {
+    const fallback = (error) => new Map(lanes.map((lane) => [lane.lane_id, {
+            error: new LanesError(error.error, error.message, {
+                ...error.details,
+                outpost_id: outpostId,
+                lane_id: lane.lane_id,
+            }),
+        }]));
+    let hqBinary;
+    try {
+        hqBinary = outpostCliOverride(ctx, outpostId);
+    }
+    catch (err) {
+        if (isLanesError(err))
+            return fallback(err);
+        return fallback(new LanesError("outpost_lane_hire_summary_unavailable", `Could not read hire summaries from Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { outpost_id: outpostId }));
+    }
+    let dispatched;
+    try {
+        // No filters: the owner list must return every lane requested by this host group.
+        dispatched = await ctx.dispatchOutpostExec({
+            outpostId,
+            command: buildOutpostLaneListCommand({ hqBinary }),
+            timeoutSeconds: OUTPOST_HIRE_SUMMARY_TIMEOUT_SECONDS,
+            waitMs: OUTPOST_HIRE_SUMMARY_WAIT_MS,
+        });
+    }
+    catch (err) {
+        return fallback(new LanesError("outpost_lane_hire_summary_unavailable", `Could not read hire summaries from Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { outpost_id: outpostId }));
+    }
+    if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
+        return fallback(new LanesError("outpost_lane_hire_summary_unavailable", `Outpost ${outpostId} did not confirm its lane list for hire summaries`, { outpost_id: outpostId, command_id: dispatched.commandId }));
+    }
+    const remote = parseRemoteJson(dispatched.stdout, "Outpost lane hire summary list");
+    if (!remote || remote.ok !== true || remote.action !== "list" || !Array.isArray(remote.lanes)) {
+        return fallback(new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned an invalid lane list for hire summaries`, { outpost_id: outpostId, command_id: dispatched.commandId }));
+    }
+    const outcomes = new Map();
+    for (const lane of lanes) {
+        const matchingRows = remote.lanes.filter((row) => row !== null && typeof row === "object" && !Array.isArray(row) &&
+            row.lane_id === lane.lane_id);
+        if (matchingRows.length === 0) {
+            outcomes.set(lane.lane_id, { error: new LanesError("outpost_lane_hire_summary_missing", `Outpost ${outpostId} did not return lane ${lane.lane_id} in its lane list`, { outpost_id: outpostId, lane_id: lane.lane_id, command_id: dispatched.commandId }) });
+            continue;
+        }
+        if (matchingRows.length !== 1) {
+            outcomes.set(lane.lane_id, { error: new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned duplicate lane rows for ${lane.lane_id}`, { outpost_id: outpostId, lane_id: lane.lane_id, command_id: dispatched.commandId }) });
+            continue;
+        }
+        const row = matchingRows[0];
+        try {
+            outcomes.set(lane.lane_id, { fields: validateOwnerLaneHireSummary({
+                    outpostId,
+                    laneId: lane.lane_id,
+                    rawLane: row,
+                    hireGrant: row.hire_grant,
+                    hireAliveChildren: row.hire_alive_children,
+                    hire: row.hire,
+                    hireSummary: row.hire_summary,
+                    commandId: dispatched.commandId,
+                }) });
+        }
+        catch (err) {
+            outcomes.set(lane.lane_id, { error: isLanesError(err)
+                    ? err
+                    : new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned an invalid hire summary for lane ${lane.lane_id}`, { outpost_id: outpostId, lane_id: lane.lane_id, command_id: dispatched.commandId }) });
+        }
+    }
+    return outcomes;
+}
+async function batchOwnerLaneHireFields(ctx, lanes) {
+    const outcomes = new Map();
+    const groups = new Map();
+    const nowMs = ctx.now().getTime();
+    const cached = readOutpostHireSummaryCache(ctx.hqRoot(), nowMs);
+    for (const lane of lanes) {
+        if (lane.host.kind !== "outpost")
+            continue;
+        const cachedSummary = cached.get(outpostHireSummaryCacheKey(lane.host.id, lane.lane_id));
+        if (cachedSummary) {
+            outcomes.set(lane.lane_id, {
+                fields: {
+                    hire_grant: cachedSummary.hire_grant,
+                    hire_alive_children: cachedSummary.hire_alive_children,
+                    hire: cachedSummary.hire,
+                    hire_summary: cachedSummary.hire_summary,
+                },
+            });
+            continue;
+        }
+        const group = groups.get(lane.host.id) ?? [];
+        group.push(lane);
+        groups.set(lane.host.id, group);
+    }
+    const fetchedGroups = await mapWithConcurrency([...groups.entries()], OUTPOST_HIRE_SUMMARY_CONCURRENCY, ([outpostId, group]) => fetchOutpostListHireSummaries(ctx, outpostId, group));
+    const cacheUpdates = [];
+    for (const groupOutcomes of fetchedGroups) {
+        for (const [laneId, outcome] of groupOutcomes) {
+            outcomes.set(laneId, outcome);
+            if ("fields" in outcome) {
+                const lane = lanes.find((candidate) => candidate.lane_id === laneId);
+                if (lane?.host.kind === "outpost") {
+                    cacheUpdates.push({ outpost_id: lane.host.id, lane_id: laneId, ...outcome.fields });
+                }
+            }
+        }
+    }
+    writeOutpostHireSummaryCache(ctx.hqRoot(), cacheUpdates, ctx.now().getTime(), cached);
+    return outcomes;
+}
 const OUTPOST_HIRE_SUMMARY_TIMEOUT_SECONDS = 20;
 const OUTPOST_HIRE_SUMMARY_WAIT_MS = 15_000;
 const OUTPOST_HIRE_SUMMARY_CONCURRENCY = 4;
@@ -1407,6 +1570,22 @@ function sameLaneCompany(a, b) {
         return a === b;
     return (a.uid !== "" && a.uid === b.uid) || (a.slug !== "" && a.slug === b.slug);
 }
+function sameQuestionCompany(a, b) {
+    if (a === null || b === null)
+        return a === b;
+    const aUid = a.uid.trim();
+    const bUid = b.uid.trim();
+    if (aUid || bUid)
+        return aUid !== "" && aUid === bUid;
+    const aSlug = a.slug.trim();
+    const bSlug = b.slug.trim();
+    return aSlug !== "" && aSlug === bSlug;
+}
+function questionCompanyRefMatches(recordCompany, filter) {
+    return recordCompany !== null &&
+        recordCompany !== undefined &&
+        sameQuestionCompany(recordCompany, filter);
+}
 function companyRefMatches(recordCompany, filter) {
     return (recordCompany !== null &&
         recordCompany !== undefined &&
@@ -3255,6 +3434,7 @@ async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
                 choice: options.choice,
                 freeform: options.freeform,
                 notes: options.notes,
+                company: options.company,
             }),
         });
     }
@@ -3318,7 +3498,9 @@ async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
         });
     }
     const ownerAnswer = ownerQuestion.answer;
-    if (!isQuestionAnswer(ownerAnswer)) {
+    if (!isQuestionAnswer(ownerAnswer) ||
+        ownerQuestion.lane_id !== lane.lane_id ||
+        !sameQuestionCompany(ownerQuestion.company, lane.company)) {
         throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} did not return the confirmed answer for question ${questionId}`, {
             lane_id: lane.lane_id,
             question_id: questionId,
@@ -3326,10 +3508,13 @@ async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
             command_id: dispatched.commandId,
         });
     }
-    const syncedQuestion = casUpdateQuestion(ctx.hqRoot(), questionId, (current) => {
+    const updatePrimaryCopy = () => casUpdateQuestion(ctx.hqRoot(), questionId, (current) => {
         if (current.lane_id !== lane.lane_id) {
             throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} belongs to a different lane than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
         }
+        if (!sameQuestionCompany(current.company, lane.company)) {
+            throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} belongs to a different company than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
+        }
         if (current.status === "pending") {
             return { ...current, status: "answered", answer: ownerAnswer };
         }
@@ -3338,6 +3523,26 @@ async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
         }
         throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} is ${current.status} or has a different answer than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
     });
+    let syncedQuestion;
+    try {
+        syncedQuestion = updatePrimaryCopy();
+    }
+    catch (err) {
+        if (!isLanesError(err) || err.error !== "question_not_found")
+            throw err;
+        const primaryLane = readLane(ctx.hqRoot(), lane.lane_id);
+        if (!sameQuestionCompany(primaryLane.company, lane.company)) {
+            throw new LanesError("outpost_question_sync_conflict", `Primary lane ${lane.lane_id} belongs to a different company than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
+        }
+        try {
+            syncedQuestion = createQuestion(ctx.hqRoot(), ownerQuestion);
+        }
+        catch (createErr) {
+            if (!isLanesError(createErr) || createErr.error !== "question_exists")
+                throw createErr;
+            syncedQuestion = updatePrimaryCopy();
+        }
+    }
     printJson({
         ...remote,
         lane_id: lane.lane_id,
@@ -3630,6 +3835,7 @@ async function runList(ctx, opts) {
         return true;
     })
         .sort(compareLaneQueueOrder);
+    const ownerEligibleLaneIds = new Set();
     const companyContexts = new Map();
     for (const lane of selectedLanes) {
         if (lane.host.kind !== "outpost" ||
@@ -3637,14 +3843,58 @@ async function runList(ctx, opts) {
             laneRunsHere(lane, host)) {
             continue;
         }
-        const company = lane.company;
-        companyContexts.set(JSON.stringify([company?.uid ?? null, company?.slug ?? null]), company);
+        const companyKey = JSON.stringify([
+            lane.company?.uid ?? null,
+            lane.company?.slug ?? null,
+        ]);
+        ownerEligibleLaneIds.add(lane.lane_id);
+        companyContexts.set(companyKey, lane.company);
+    }
+    const enabledByCompany = new Map(await Promise.all([...companyContexts.entries()].map(async ([companyKey, company]) => [
+        companyKey,
+        await ctx.laneHireGrantsEnabled(company),
+    ])));
+    const ownerLanes = [];
+    const hireByLane = new Map();
+    for (const lane of selectedLanes) {
+        if (!ownerEligibleLaneIds.has(lane.lane_id)) {
+            hireByLane.set(lane.lane_id, {
+                ...laneHireFields(lane, allLanes),
+                hire_source: "local",
+            });
+            continue;
+        }
+        const companyKey = JSON.stringify([
+            lane.company?.uid ?? null,
+            lane.company?.slug ?? null,
+        ]);
+        if (enabledByCompany.get(companyKey))
+            ownerLanes.push(lane);
+        else {
+            hireByLane.set(lane.lane_id, {
+                ...laneHireFields(lane, allLanes),
+                hire_source: "local",
+            });
+        }
+    }
+    if (ownerLanes.length > 0) {
+        const ownerSummaries = await batchOwnerLaneHireFields(ctx, ownerLanes);
+        for (const lane of ownerLanes) {
+            const outcome = ownerSummaries.get(lane.lane_id);
+            if (outcome && "fields" in outcome) {
+                hireByLane.set(lane.lane_id, { ...outcome.fields, hire_source: "owner" });
+                continue;
+            }
+            const error = outcome && "error" in outcome
+                ? outcome.error
+                : new LanesError("outpost_lane_hire_summary_missing", `No owner hire summary was returned for lane ${lane.lane_id}`, { lane_id: lane.lane_id, outpost_id: lane.host.id });
+            hireByLane.set(lane.lane_id, {
+                ...laneHireFields(lane, allLanes),
+                hire_source: "local",
+                hire_warning: `${error.error}: ${error.message}`,
+            });
+        }
     }
-    await Promise.all([...companyContexts.values()].map((company) => ctx.laneHireGrantsEnabled(company)));
-    const hireByLane = new Map(await mapWithConcurrency(selectedLanes, OUTPOST_HIRE_SUMMARY_CONCURRENCY, async (lane) => [
-        lane.lane_id,
-        await laneHirePresentation(ctx, lane, allLanes),
-    ]));
     const lanes = selectedLanes.map((lane) => {
         const remoteQueued = lane.state === "queued" &&
             lane.host.kind === "outpost" &&
@@ -6582,6 +6832,271 @@ async function runAsk(ctx, opts) {
         ask_delivery_failed: failure,
     });
 }
+const OUTPOST_QUESTION_LOOKUP_CONCURRENCY = 4;
+function groupQuestionLanesByCompany(lanes) {
+    const groups = [];
+    for (const lane of lanes) {
+        const existing = groups.find((group) => sameQuestionCompany(group.company, lane.company));
+        if (existing)
+            existing.lanes.push(lane);
+        else
+            groups.push({ company: lane.company, lanes: [lane] });
+    }
+    return groups;
+}
+function questionListCompanyArg(company) {
+    if (company === null) {
+        throw new LanesError("outpost_question_company_unavailable", "An Outpost question lookup requires a recorded company identity", {});
+    }
+    const value = company.uid.trim() || company.slug.trim();
+    if (!value) {
+        throw new LanesError("outpost_question_company_invalid", "An Outpost question lookup needs a company slug or uid", {});
+    }
+    return value;
+}
+async function readOutpostQuestionRecords(ctx, outpostId, company) {
+    const companyArg = questionListCompanyArg(company);
+    let result;
+    try {
+        result = await ctx.dispatchOutpostExec({
+            outpostId,
+            command: buildOutpostQuestionListCommand({ company: companyArg }),
+            timeoutSeconds: CAPACITY_PROBE_TIMEOUT_MS / 1000,
+            waitMs: CAPACITY_PROBE_TIMEOUT_MS,
+        });
+    }
+    catch {
+        throw new LanesError("outpost_question_list_unavailable", `Could not read questions from Outpost ${outpostId}`, { outpost_id: outpostId });
+    }
+    if (result.done !== true || result.status !== "Success" || result.exitCode !== 0) {
+        throw new LanesError("outpost_question_list_unavailable", `Outpost ${outpostId} did not return a successful question list`, { outpost_id: outpostId });
+    }
+    let body;
+    try {
+        body = JSON.parse(result.stdout);
+    }
+    catch {
+        throw new LanesError("outpost_question_list_invalid", `Outpost ${outpostId} returned invalid question-list JSON`, { outpost_id: outpostId });
+    }
+    if (body === null ||
+        typeof body !== "object" ||
+        Array.isArray(body) ||
+        body.ok !== true ||
+        body.action !== "questions.list" ||
+        !Array.isArray(body.questions)) {
+        throw new LanesError("outpost_question_list_invalid", `Outpost ${outpostId} returned a malformed question list`, { outpost_id: outpostId });
+    }
+    const rows = body.questions;
+    const questions = [];
+    for (const [index, row] of rows.entries()) {
+        if (row === null || typeof row !== "object" || Array.isArray(row)) {
+            throw new LanesError("outpost_question_list_invalid", `Outpost ${outpostId} returned an invalid question record`, { outpost_id: outpostId, index });
+        }
+        const rowObject = row;
+        let question;
+        try {
+            question = parseQuestionRecord(row);
+        }
+        catch {
+            throw new LanesError("outpost_question_list_invalid", `Outpost ${outpostId} returned an invalid question record`, { outpost_id: outpostId, index });
+        }
+        const audience = parseOutpostQuestionAudience(rowObject.audience, outpostId, index);
+        questions.push({ question, audience });
+    }
+    return questions;
+}
+function parseOutpostQuestionAudience(raw, outpostId, index) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new LanesError("outpost_question_audience_invalid", `Outpost ${outpostId} returned a question without a valid owner-computed audience`, { outpost_id: outpostId, index });
+    }
+    const audience = raw;
+    try {
+        if (audience.kind === "user" && audience.id === undefined) {
+            return parseSeniorRef("user");
+        }
+        if (typeof audience.kind !== "string" || typeof audience.id !== "string") {
+            throw new Error("audience kind and id are invalid");
+        }
+        return parseSeniorRef(`${audience.kind}:${audience.id}`);
+    }
+    catch {
+        throw new LanesError("outpost_question_audience_invalid", `Outpost ${outpostId} returned an invalid owner-computed question audience`, { outpost_id: outpostId, index });
+    }
+}
+function parseOutpostQuestionBody(raw, outpostId, questionId) {
+    if (raw === null)
+        return null;
+    if (typeof raw !== "object" || Array.isArray(raw)) {
+        throw new LanesError("outpost_question_show_invalid", `Outpost ${outpostId} returned a malformed body for question ${questionId}`, { outpost_id: outpostId, question_id: questionId });
+    }
+    const body = raw;
+    if (typeof body.question !== "string" ||
+        typeof body.context !== "string" ||
+        !Array.isArray(body.options) ||
+        body.options.some((option) => typeof option !== "string") ||
+        (body.recommended !== undefined && typeof body.recommended !== "string") ||
+        (body.notes !== undefined && typeof body.notes !== "string")) {
+        throw new LanesError("outpost_question_show_invalid", `Outpost ${outpostId} returned a malformed body for question ${questionId}`, { outpost_id: outpostId, question_id: questionId });
+    }
+    return parseQuestionBody(raw);
+}
+async function readOutpostQuestionDetail(ctx, owner) {
+    if (owner.lane.host.kind !== "outpost") {
+        throw new LanesError("outpost_question_owner_invalid", `Question ${owner.question.question_id} does not have an Outpost owner`, { question_id: owner.question.question_id, lane_id: owner.lane.lane_id });
+    }
+    const outpostId = owner.lane.host.id;
+    let result;
+    try {
+        result = await ctx.dispatchOutpostExec({
+            outpostId,
+            command: buildOutpostQuestionShowCommand(owner.question.question_id),
+            timeoutSeconds: CAPACITY_PROBE_TIMEOUT_MS / 1000,
+            waitMs: CAPACITY_PROBE_TIMEOUT_MS,
+        });
+    }
+    catch {
+        throw new LanesError("outpost_question_show_unavailable", `Could not read question ${owner.question.question_id} from Outpost ${outpostId}`, { outpost_id: outpostId, question_id: owner.question.question_id });
+    }
+    if (result.done !== true || result.status !== "Success" || result.exitCode !== 0) {
+        throw new LanesError("outpost_question_show_unavailable", `Outpost ${outpostId} did not return question ${owner.question.question_id}`, { outpost_id: outpostId, question_id: owner.question.question_id });
+    }
+    let raw;
+    try {
+        raw = JSON.parse(result.stdout);
+    }
+    catch {
+        throw new LanesError("outpost_question_show_invalid", `Outpost ${outpostId} returned invalid question-show JSON`, { outpost_id: outpostId, question_id: owner.question.question_id });
+    }
+    if (raw === null ||
+        typeof raw !== "object" ||
+        Array.isArray(raw) ||
+        raw.ok !== true ||
+        raw.action !== "questions.show" ||
+        !Object.prototype.hasOwnProperty.call(raw, "body")) {
+        throw new LanesError("outpost_question_show_invalid", `Outpost ${outpostId} returned a malformed question-show response`, { outpost_id: outpostId, question_id: owner.question.question_id });
+    }
+    const response = raw;
+    let question;
+    try {
+        question = parseQuestionRecord(response.question);
+    }
+    catch {
+        throw new LanesError("outpost_question_show_invalid", `Outpost ${outpostId} returned an invalid question record`, { outpost_id: outpostId, question_id: owner.question.question_id });
+    }
+    if (question.question_id !== owner.question.question_id ||
+        question.lane_id !== owner.lane.lane_id ||
+        !sameQuestionCompany(question.company, owner.lane.company)) {
+        throw new LanesError("outpost_question_company_mismatch", `Outpost ${outpostId} returned question ${owner.question.question_id} for a different lane or company`, { outpost_id: outpostId, question_id: owner.question.question_id });
+    }
+    const audience = parseOutpostQuestionAudience(response.audience, outpostId, 0);
+    const body = parseOutpostQuestionBody(response.body, outpostId, question.question_id);
+    return { question, audience, body };
+}
+async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
+    const hostedLanes = loadAllLanes(hqRoot).filter((lane) => lane.host.kind === "outpost" &&
+        (!companyFilter || questionCompanyRefMatches(lane.company, companyFilter)));
+    const lanesByOutpost = new Map();
+    for (const lane of hostedLanes) {
+        if (lane.host.kind !== "outpost")
+            continue;
+        const lanes = lanesByOutpost.get(lane.host.id) ?? [];
+        lanes.push(lane);
+        lanesByOutpost.set(lane.host.id, lanes);
+    }
+    const questions = [];
+    const errors = [];
+    const eligibleGroups = [];
+    for (const [outpostId, lanes] of [...lanesByOutpost.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+        for (const group of groupQuestionLanesByCompany(lanes)) {
+            if (companyFilter && !questionCompanyRefMatches(group.company, companyFilter))
+                continue;
+            if (group.company === null) {
+                errors.push({
+                    host: `outpost:${outpostId}`,
+                    error: "outpost_question_company_unavailable",
+                });
+                continue;
+            }
+            if (await ctx.laneOutpostQuestionVisibilityEnabled(group.company)) {
+                eligibleGroups.push({ outpostId, group });
+            }
+        }
+    }
+    if (eligibleGroups.length === 0) {
+        return { questions, errors: [...new Map(errors.map((entry) => [entry.host, entry])).values()] };
+    }
+    let knownOutpostIds;
+    try {
+        knownOutpostIds = await ctx.listOutpostIds();
+    }
+    catch {
+        return {
+            questions,
+            errors: [...new Map([
+                    ...errors,
+                    ...[...new Set(eligibleGroups.map(({ outpostId }) => outpostId))].map((outpostId) => ({
+                        host: `outpost:${outpostId}`,
+                        error: "outpost_list_unavailable",
+                    })),
+                ].map((entry) => [entry.host, entry])).values()],
+        };
+    }
+    const normalizedOutpostIds = knownOutpostIds.map((id) => typeof id === "string" ? id.trim() : "");
+    if (knownOutpostIds.length > MAX_PLACEMENT_OUTPOSTS ||
+        normalizedOutpostIds.some((id) => id === "") ||
+        new Set(normalizedOutpostIds).size !== normalizedOutpostIds.length) {
+        throw new LanesError("outpost_list_invalid", "Outpost list is malformed or exceeds the placement limit", { count: knownOutpostIds.length, maximum: MAX_PLACEMENT_OUTPOSTS });
+    }
+    const knownOutpostIdSet = new Set(normalizedOutpostIds);
+    const loadedGroups = await mapWithConcurrency(eligibleGroups, OUTPOST_QUESTION_LOOKUP_CONCURRENCY, async ({ outpostId, group }) => {
+        if (!knownOutpostIdSet.has(outpostId)) {
+            return {
+                questions: [],
+                errors: [{ host: `outpost:${outpostId}`, error: "unknown_outpost" }],
+            };
+        }
+        try {
+            const remoteQuestions = await readOutpostQuestionRecords(ctx, outpostId, group.company);
+            const localLanesById = new Map(group.lanes.map((lane) => [lane.lane_id, lane]));
+            const groupQuestions = [];
+            const seenQuestionIds = new Set();
+            for (const { question, audience } of remoteQuestions) {
+                const lane = localLanesById.get(question.lane_id);
+                if (!lane)
+                    continue;
+                if (!sameQuestionCompany(question.company, lane.company)) {
+                    throw new LanesError("outpost_question_company_mismatch", `Outpost ${outpostId} question ${question.question_id} does not match its primary lane company`, { outpost_id: outpostId, question_id: question.question_id });
+                }
+                if (seenQuestionIds.has(question.question_id)) {
+                    throw new LanesError("outpost_question_list_invalid", `Outpost ${outpostId} returned a duplicate question id`, { outpost_id: outpostId, question_id: question.question_id });
+                }
+                seenQuestionIds.add(question.question_id);
+                groupQuestions.push({
+                    question,
+                    lane,
+                    host: `outpost:${outpostId}`,
+                    audience,
+                });
+            }
+            return { questions: groupQuestions, errors: [] };
+        }
+        catch (err) {
+            return {
+                questions: [],
+                errors: [{
+                        host: `outpost:${outpostId}`,
+                        error: isLanesError(err) ? err.error : "outpost_question_list_unavailable",
+                    }],
+            };
+        }
+    });
+    questions.push(...loadedGroups.flatMap(({ questions: groupQuestions }) => groupQuestions));
+    errors.push(...loadedGroups.flatMap(({ errors: groupErrors }) => groupErrors));
+    return {
+        questions,
+        errors: [...new Map(errors.map((entry) => [entry.host, entry])).values()],
+    };
+}
 async function runQuestionsList(ctx, opts) {
     const hqRoot = ctx.hqRoot();
     const status = opts.status ? parseQuestionStatus(opts.status) : undefined;
@@ -6589,7 +7104,8 @@ async function runQuestionsList(ctx, opts) {
     let company;
     if (opts.company)
         company = await ctx.resolveCompany(opts.company);
-    const questions = loadAllQuestions(hqRoot)
+    const localLanes = opts.allHosts ? new Map(loadAllLanes(hqRoot).map((lane) => [lane.lane_id, lane])) : undefined;
+    const localQuestions = loadAllQuestions(hqRoot)
         .filter((q) => {
         if (status && q.status !== status)
             return false;
@@ -6599,26 +7115,116 @@ async function runQuestionsList(ctx, opts) {
             return false;
         if (opts.story && q.story_id !== opts.story)
             return false;
-        if (company && !companyRefMatches(q.company, company)) {
+        if (company && !(opts.allHosts
+            ? questionCompanyRefMatches(q.company, company)
+            : companyRefMatches(q.company, company))) {
             return false;
         }
+        if (company && localLanes) {
+            const lane = localLanes.get(q.lane_id);
+            if (!lane || !questionCompanyRefMatches(lane.company, company) || !sameQuestionCompany(q.company, lane.company)) {
+                return false;
+            }
+        }
         if (forFilter) {
             const audience = resolveAudience(hqRoot, q, ctx);
             if (!audienceMatches(audience, forFilter))
                 return false;
         }
         return true;
-    })
-        .map((q) => ({
-        ...q,
-        audience: resolveAudience(hqRoot, q, ctx),
-        ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
-    }));
-    printJson({ ok: true, action: "questions.list", questions });
+    });
+    const outpostLoad = opts.allHosts
+        ? await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company)
+        : { questions: [], errors: [] };
+    const remoteQuestionIds = new Set(outpostLoad.questions.map(({ question }) => question.question_id));
+    const questions = [
+        ...localQuestions
+            .filter((q) => !remoteQuestionIds.has(q.question_id))
+            .map((q) => {
+            const row = {
+                ...q,
+                audience: resolveAudience(hqRoot, q, ctx),
+                ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
+            };
+            if (!opts.allHosts)
+                return row;
+            const lane = localLanes?.get(q.lane_id);
+            const host = lane?.host.kind === "outpost" ? `outpost:${lane.host.id}` : "local";
+            return { ...row, host };
+        }),
+        ...outpostLoad.questions
+            .filter(({ question: q, lane, audience }) => {
+            if (status && q.status !== status)
+                return false;
+            if (opts.from && q.lane_id !== opts.from && q.origin.id !== opts.from)
+                return false;
+            if (opts.project && q.project_id !== opts.project)
+                return false;
+            if (opts.story && q.story_id !== opts.story)
+                return false;
+            if (company && (!questionCompanyRefMatches(q.company, company) ||
+                !questionCompanyRefMatches(lane.company, company) ||
+                !sameQuestionCompany(q.company, lane.company))) {
+                return false;
+            }
+            if (forFilter) {
+                if (!audienceMatches(audience, forFilter))
+                    return false;
+            }
+            return true;
+        })
+            .map(({ question: q, host, audience }) => ({
+            ...q,
+            host,
+            audience,
+            ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
+        })),
+    ];
+    printJson({
+        ok: true,
+        action: "questions.list",
+        questions,
+        ...(outpostLoad.errors.length > 0 ? { errors: outpostLoad.errors } : {}),
+    });
 }
 async function runQuestionsShow(ctx, questionId) {
     const hqRoot = ctx.hqRoot();
-    const question = readQuestion(hqRoot, questionId);
+    let question;
+    try {
+        question = readQuestion(hqRoot, questionId);
+    }
+    catch (err) {
+        if (!isLanesError(err) || err.error !== "question_not_found")
+            throw err;
+        const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot);
+        if (lookup.errors.length > 0) {
+            throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
+                question_id: questionId,
+                hosts: lookup.errors.map(({ host, error }) => ({ host, error })),
+            });
+        }
+        const matches = lookup.questions.filter((entry) => entry.question.question_id === questionId);
+        if (matches.length === 0) {
+            throw new LanesError("question_not_found", `Question ${questionId} not found on this primary or its Outposts`, { question_id: questionId });
+        }
+        if (matches.length > 1) {
+            throw new LanesError("outpost_question_ambiguous", `Question ${questionId} is present on more than one Outpost`, { question_id: questionId, owner_count: matches.length });
+        }
+        const owner = matches[0];
+        if (!owner) {
+            throw new LanesError("outpost_question_ambiguous", `Question ${questionId} has no unique Outpost owner`, { question_id: questionId });
+        }
+        const detail = await readOutpostQuestionDetail(ctx, owner);
+        printJson({
+            ok: true,
+            action: "questions.show",
+            question: detail.question,
+            audience: detail.audience,
+            body: detail.body,
+            host: owner.host,
+        });
+        return;
+    }
     const body = readQuestionBody(hqRoot, question);
     printJson({
         ok: true,
@@ -6630,11 +7236,56 @@ async function runQuestionsShow(ctx, questionId) {
 }
 async function runQuestionsAnswer(ctx, questionId, opts) {
     const hqRoot = ctx.hqRoot();
-    const question = readQuestion(hqRoot, questionId);
+    const company = opts.company ? await ctx.resolveCompany(opts.company) : undefined;
+    let question;
+    try {
+        question = readQuestion(hqRoot, questionId);
+    }
+    catch (err) {
+        if (!isLanesError(err) || err.error !== "question_not_found")
+            throw err;
+        const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company);
+        if (lookup.errors.length > 0) {
+            throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
+                question_id: questionId,
+                hosts: lookup.errors.map(({ host, error }) => ({ host, error })),
+            });
+        }
+        const matches = lookup.questions.filter((entry) => entry.question.question_id === questionId);
+        if (matches.length === 0) {
+            throw new LanesError("question_not_found", `Question ${questionId} not found on this primary or its Outposts`, { question_id: questionId });
+        }
+        if (matches.length > 1) {
+            throw new LanesError("outpost_question_ambiguous", `Question ${questionId} is present on more than one Outpost`, { question_id: questionId, owner_count: matches.length });
+        }
+        const owner = matches[0];
+        if (!owner) {
+            throw new LanesError("question_not_found", `Question ${questionId} not found on this primary or its Outposts`, { question_id: questionId });
+        }
+        if (!sameQuestionCompany(owner.question.company, owner.lane.company)) {
+            throw new LanesError("outpost_question_company_mismatch", `Question ${questionId} does not match its primary lane company`, { question_id: questionId, lane_id: owner.lane.lane_id });
+        }
+        throwIfQuestionNotPending(owner.question);
+        await yieldEventLoop();
+        await dispatchOutpostQuestionAnswer(ctx, owner.lane, questionId, {
+            ...opts,
+            company: questionListCompanyArg(owner.lane.company),
+        });
+        return;
+    }
     await yieldEventLoop();
     const askingLane = readLane(hqRoot, laneIdForAnswerDelivery(question));
+    if (company &&
+        (!questionCompanyRefMatches(question.company, company) ||
+            !questionCompanyRefMatches(askingLane.company, company) ||
+            !sameQuestionCompany(question.company, askingLane.company))) {
+        throw new LanesError("question_company_mismatch", `Question ${questionId} does not belong to the requested company`, { question_id: questionId, lane_id: askingLane.lane_id });
+    }
     if (askingLane.host.kind === "outpost" && !laneIsHostedHere(ctx, askingLane)) {
-        await dispatchOutpostQuestionAnswer(ctx, askingLane, questionId, opts);
+        await dispatchOutpostQuestionAnswer(ctx, askingLane, questionId, {
+            ...opts,
+            ...(askingLane.company ? { company: questionListCompanyArg(askingLane.company) } : {}),
+        });
         return;
     }
     throwIfQuestionNotPending(question);
@@ -7587,6 +8238,7 @@ export function registerLanesCommand(parent, deps = {}) {
     questions
         .command("list")
         .description("List questions")
+        .option("--all-hosts", "Include questions from Outposts that own this primary's lanes")
         .option("--for <ref>", "Who must decide (ref | me | user)")
         .option("--from <lane-id>", "Which lane asked")
         .option("--company <slug|uid>", "Filter by company")
@@ -7610,6 +8262,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--choice <label|N>", "1-based index or option label")
         .option("--notes <text>", "Free-text notes stored with the body")
         .option("--freeform <text>", "Supply a free-form answer for a question with options")
+        .option("--company <slug|uid>", "Require the question lane to match this company")
         .action(wrap(async (questionId, opts) => {
         await runQuestionsAnswer(ctx, questionId, opts);
     }));