@indigoai-us/hq-cli 5.198.1 → 5.199.0

package/CHANGELOG.md

@@ -2,8 +2,28 @@
 
 ## [Unreleased]
 
+## [5.199.0] — 2026-09-25
+
+### Added
+
+- `hq lanes questions list --all-hosts` reads questions from Outposts that own
+  this primary's lanes. Rows include the host, and an unavailable Outpost is
+  named in `errors` while local questions remain available. Remote rows use the
+  audience computed by the owner, and eligible Outpost reads run with bounded
+  concurrency. The primary can show and answer an Outpost-only question, then
+  save the owner's confirmed answer locally. Cross-host lookup requires the
+  company-scoped `lanes.outpost-question-visibility` hq-flags gate. Use
+  `--company` to limit a list or answer to one company.
+
 ## [5.198.1] — 2026-09-25
 
+### Fixed
+
+- Registry-backed hq-flags readers now use the central registry endpoint when
+  `HQ_FLAGS_API_URL` is unset or blank. Explicit endpoints and local overrides
+  keep precedence, and process-wide gates retain their legacy fallback until a
+  registry snapshot is ready.
+
 ## [5.198.0] — 2026-09-25
 
 ### Added

package/dist/command-catalog.generated.d.ts

@@ -7970,6 +7970,9 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly usage: "[options]";
             readonly arguments: readonly [];
             readonly options: readonly [{
+                readonly flags: "--all-hosts";
+                readonly description: "Include questions from Outposts that own this primary's lanes";
+            }, {
                 readonly flags: "--for <ref>";
                 readonly description: "Who must decide (ref | me | user)";
             }, {
@@ -8028,6 +8031,9 @@ export declare const COMMAND_CATALOG: readonly [{
             }, {
                 readonly flags: "--freeform <text>";
                 readonly description: "Supply a free-form answer for a question with options";
+            }, {
+                readonly flags: "--company <slug|uid>";
+                readonly description: "Require the question lane to match this company";
             }, {
                 readonly flags: "--json";
                 readonly description: "JSON on stdout (always)";

package/dist/command-catalog.generated.js

@@ -10306,6 +10306,10 @@ export const COMMAND_CATALOG = [
                         "usage": "[options]",
                         "arguments": [],
                         "options": [
+                            {
+                                "flags": "--all-hosts",
+                                "description": "Include questions from Outposts that own this primary's lanes"
+                            },
                             {
                                 "flags": "--for <ref>",
                                 "description": "Who must decide (ref | me | user)"
@@ -10384,6 +10388,10 @@ export const COMMAND_CATALOG = [
                                 "flags": "--freeform <text>",
                                 "description": "Supply a free-form answer for a question with options"
                             },
+                            {
+                                "flags": "--company <slug|uid>",
+                                "description": "Require the question lane to match this company"
+                            },
                             {
                                 "flags": "--json",
                                 "description": "JSON on stdout (always)"

package/dist/commands/lanes.d.ts

@@ -88,6 +88,8 @@ export interface LanesCommandDeps {
     withGrantHireLocks?: typeof withLaneHireLocks;
     /** Test seam for the Claude account-balancing gate. */
     laneClaudeAccountBalanceEnabled?: (company?: LaneCompanyRef | null) => boolean | Promise<boolean>;
+    /** Test seam for the default-off Outpost question visibility gate. */
+    laneOutpostQuestionVisibilityEnabled?: (company?: LaneCompanyRef | null) => boolean | Promise<boolean>;
     /** Test seam for the hq-flags gated tracker commands. */
     laneTrackerEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     /** The local-only PR 2 implementation refuses if mesh storage is enabled. */
@@ -96,6 +98,7 @@ export interface LanesCommandDeps {
     trackerActor?: () => string | null;
 }
 export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+export declare const LANE_OUTPOST_QUESTION_VISIBILITY_FLAG = "lanes.outpost-question-visibility";
 export declare function parseSeniorRef(raw: string): SeniorRef;
 export declare function resolveAnswerChoice(choice: string, options: string[], freeform: boolean): string;
 /**

package/dist/commands/lanes.js

@@ -22,7 +22,7 @@ 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 { 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 +31,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 +55,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 +73,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 +278,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,
@@ -1407,6 +1416,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 +3280,7 @@ async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
                 choice: options.choice,
                 freeform: options.freeform,
                 notes: options.notes,
+                company: options.company,
             }),
         });
     }
@@ -3318,7 +3344,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 +3354,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 +3369,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,
@@ -6582,6 +6633,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 +6905,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 +6916,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 +7037,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 +8039,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 +8063,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);
     }));

package/dist/lib/core-utils/hook-timeout-debug-context-flag.js

@@ -1,5 +1,7 @@
 import { loadCachedTokens } from "@indigoai-us/hq-cloud";
 import { createFlagClient, } from "@indigoai-us/hq-flags-client";
+import { resolveProcessFlagCompanyContext } from "../flag-registry.js";
+import { resolveFlagRegistryEndpoint } from "../flag-registry-endpoint.js";
 export const HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG = "hook-timeout-debug-context";
 export const HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_FALLBACK = false;
 export const HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_TIMEOUT_MS = 150;
@@ -20,12 +22,11 @@ function combineSignals(first, second) {
  */
 export async function hookTimeoutDebugContextEnabled(dependencies = {}, callerSignal) {
     const env = dependencies.env ?? process.env;
-    const endpoint = env.HQ_FLAGS_API_URL?.trim() || "";
-    const companyUid = env.HQ_COMPANY_UID?.trim() || "";
-    if (!endpoint || !/^cmp_[A-Za-z0-9]{3,128}$/.test(companyUid)) {
+    const endpoint = resolveFlagRegistryEndpoint(undefined, env);
+    const { companyUid, companySlug } = resolveProcessFlagCompanyContext(env);
+    if (!companyUid) {
         return HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_FALLBACK;
     }
-    const companySlug = env.HQ_COMPANY_SLUG?.trim() || "";
     const deadline = AbortSignal.timeout(HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_TIMEOUT_MS);
     const signal = callerSignal ? AbortSignal.any([callerSignal, deadline]) : deadline;
     const doFetch = dependencies.fetch ?? globalThis.fetch;

package/dist/lib/doctor/client-health-reason-codes-flag.js

@@ -1,5 +1,6 @@
 import { loadCachedTokens } from "@indigoai-us/hq-cloud";
 import { createFlagClient, } from "@indigoai-us/hq-flags-client";
+import { resolveFlagRegistryEndpoint } from "../flag-registry-endpoint.js";
 export const CLIENT_HEALTH_REASON_CODES_FLAG = "client-health-sync-reason-codes";
 export const CLIENT_HEALTH_REASON_CODES_FLAG_FALLBACK = false;
 export const CLIENT_HEALTH_REASON_CODES_FLAG_TIMEOUT_MS = 150;
@@ -32,9 +33,9 @@ export async function clientHealthReasonCodesEnabled(dependencies = {}, callerSi
 /** Resolve the same default-off gate for one explicitly identified company. */
 export async function clientHealthReasonCodesEnabledForCompany(company, dependencies = {}, callerSignal) {
     const env = dependencies.env ?? process.env;
-    const endpoint = env.HQ_FLAGS_API_URL?.trim() || "";
+    const endpoint = resolveFlagRegistryEndpoint(undefined, env);
     const companyUid = company.companyUid.trim();
-    if (!endpoint || !/^cmp_[A-Za-z0-9]{3,128}$/.test(companyUid)) {
+    if (!/^cmp_[A-Za-z0-9]{3,128}$/.test(companyUid)) {
         return CLIENT_HEALTH_REASON_CODES_FLAG_FALLBACK;
     }
     const companySlug = company.companySlug?.trim() || "";

package/dist/lib/flag-registry-endpoint.d.ts

@@ -0,0 +1,5 @@
+export declare const FLAG_REGISTRY_ENDPOINT_ENV = "HQ_FLAGS_API_URL";
+export declare const FLAG_REGISTRY_DEFAULT_ENDPOINT = "https://hqapi.hq.computer";
+/** Resolve one shared endpoint from an explicit option, environment, or service default. */
+export declare function resolveFlagRegistryEndpoint(explicitEndpoint?: string, env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=flag-registry-endpoint.d.ts.map

package/dist/lib/flag-registry-endpoint.js

@@ -0,0 +1,9 @@
+export const FLAG_REGISTRY_ENDPOINT_ENV = "HQ_FLAGS_API_URL";
+export const FLAG_REGISTRY_DEFAULT_ENDPOINT = "https://hqapi.hq.computer";
+/** Resolve one shared endpoint from an explicit option, environment, or service default. */
+export function resolveFlagRegistryEndpoint(explicitEndpoint, env = process.env) {
+    return explicitEndpoint?.trim()
+        || env[FLAG_REGISTRY_ENDPOINT_ENV]?.trim()
+        || FLAG_REGISTRY_DEFAULT_ENDPOINT;
+}
+//# sourceMappingURL=flag-registry-endpoint.js.map

package/dist/lib/flag-registry.d.ts

@@ -7,8 +7,7 @@
  */
 import { type WorkerOptions } from "node:worker_threads";
 import { type FlagClient, type FlagLookupOptions, type FlagSnapshot } from "@indigoai-us/hq-flags-client";
-/** Dedicated endpoint configuration; this is intentionally not HQ_PRO_API_URL. */
-export declare const FLAG_REGISTRY_ENDPOINT_ENV = "HQ_FLAGS_API_URL";
+export { FLAG_REGISTRY_ENDPOINT_ENV } from "./flag-registry-endpoint.js";
 /** The synchronous capability that command gate call sites need. */
 export type FlagReader = Pick<FlagClient, "isEnabled">;
 interface WorkerLike {
@@ -20,6 +19,12 @@ export interface FlagRegistryDependencies {
     endpoint?: string;
     createWorker?: (filename: URL, options: WorkerOptions) => WorkerLike;
 }
+export interface ProcessFlagCompanyContext {
+    companyUid?: string;
+    companySlug?: string;
+}
+/** Resolve the same company identity used by the process-wide flag reader. */
+export declare function resolveProcessFlagCompanyContext(env?: NodeJS.ProcessEnv): ProcessFlagCompanyContext;
 /**
  * Begin one registry refresh without awaiting it or retaining the CLI process.
  *
@@ -46,5 +51,4 @@ export declare function resolveProcessFlagGate(flagKey: string, lookup: FlagLook
 export declare function currentFlagSnapshot(): FlagSnapshot | null;
 /** Test-only reset for process-global readiness state. */
 export declare function _resetFlagRegistryForTests(): void;
-export {};
 //# sourceMappingURL=flag-registry.d.ts.map

package/dist/lib/flag-registry.js

@@ -12,8 +12,8 @@ import { readSessionState } from "./work-context/state.js";
 import { workContextRoot } from "./work-context/paths.js";
 import { readCompaniesManifestMap } from "./work-context/repo-remote.js";
 import { resolveDefaultHqRoot } from "../utils/cognito-session.js";
-/** Dedicated endpoint configuration; this is intentionally not HQ_PRO_API_URL. */
-export const FLAG_REGISTRY_ENDPOINT_ENV = "HQ_FLAGS_API_URL";
+import { resolveFlagRegistryEndpoint, } from "./flag-registry-endpoint.js";
+export { FLAG_REGISTRY_ENDPOINT_ENV } from "./flag-registry-endpoint.js";
 const COMPANY_UID_RE = /^cmp_[A-Za-z0-9]{3,128}$/;
 const COMPANY_SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 let heldSnapshot = null;
@@ -76,6 +76,15 @@ function companyUidForContext(context, env = process.env) {
     const manifestUid = readCompaniesManifestMap(hqRoot)?.[context.companySlug]?.cloud_uid;
     return typeof manifestUid === "string" ? normalizedCompanyUid(manifestUid) : undefined;
 }
+/** Resolve the same company identity used by the process-wide flag reader. */
+export function resolveProcessFlagCompanyContext(env = process.env) {
+    const context = processCompanyContext(env);
+    const companyUid = companyUidForContext(context, env);
+    return {
+        ...(companyUid ? { companyUid } : {}),
+        ...(context.companySlug ? { companySlug: context.companySlug } : {}),
+    };
+}
 function processSnapshotReader(companyIdentifiers) {
     return {
         isEnabled(flagKey, lookup = {}) {
@@ -101,11 +110,9 @@ function processSnapshotReader(companyIdentifiers) {
 export function kickFlagRegistryReadiness(dependencies = {}) {
     if (processReader)
         return processReader;
-    const endpoint = (dependencies.endpoint ?? process.env[FLAG_REGISTRY_ENDPOINT_ENV] ?? "").trim();
-    if (!endpoint)
-        return null;
-    const company = processCompanyContext();
-    const companyUid = companyUidForContext(company);
+    const endpoint = resolveFlagRegistryEndpoint(dependencies.endpoint, process.env);
+    const company = resolveProcessFlagCompanyContext();
+    const companyUid = company.companyUid;
     const companyIdentifiers = [companyUid, company.companySlug].filter((value) => Boolean(value));
     processReader = processSnapshotReader(companyIdentifiers);
     try {
@@ -149,6 +156,11 @@ export function resolveFlagGate(reader, flagKey, lookup, legacyFallback) {
 }
 /** Resolve a process gate against the shared snapshot reader, when configured. */
 export function resolveProcessFlagGate(flagKey, lookup, legacyFallback) {
+    // The endpoint refresh is deliberately asynchronous. Until a validated
+    // snapshot arrives, preserve each caller's exact legacy fallback.
+    if (!processReader || !heldSnapshot) {
+        return localOverrideOrFallback(flagKey, legacyFallback);
+    }
     return resolveFlagGate(processReader, flagKey, lookup, legacyFallback);
 }
 /**

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -46,6 +46,7 @@ export declare function buildOutpostQuestionAnswerCommand(input: {
     choice?: string;
     freeform?: string;
     notes?: string;
+    company?: string;
     hqBinary?: string;
 }): string;
 export interface OutpostExecPort {
@@ -73,6 +74,12 @@ export declare function buildOutpostPickupCommand(payloadUrl: string): string;
 export declare function buildOutpostCapacityCommand(): string;
 /** Read the lane records owned by an Outpost for exact per-account state counts. */
 export declare function buildOutpostLaneListCommand(): string;
+/** Read questions on one Outpost, scoped to a company when supplied. */
+export declare function buildOutpostQuestionListCommand(input?: {
+    company?: string;
+}): string;
+/** Read one question's body and owner-computed audience from its Outpost. */
+export declare function buildOutpostQuestionShowCommand(questionId: string): string;
 /** Commit a queued lane move on the host that currently owns its state. */
 export declare function buildOutpostMoveTargetCommand(input: {
     laneId: string;

package/dist/lib/lanes/outpost-dispatch.js

@@ -22,6 +22,7 @@ export function buildOutpostQuestionAnswerCommand(input) {
         ["--choice", input.choice],
         ["--freeform", input.freeform],
         ["--notes", input.notes],
+        ["--company", input.company],
     ]) {
         if (value !== undefined)
             args.push(flag, value);
@@ -68,6 +69,24 @@ export function buildOutpostCapacityCommand() {
 export function buildOutpostLaneListCommand() {
     return withRemoteHqDir(joinCommandParts(["hq", "lanes", "list", "--json"]));
 }
+/** Read questions on one Outpost, scoped to a company when supplied. */
+export function buildOutpostQuestionListCommand(input = {}) {
+    const args = ["hq", "lanes", "questions", "list"];
+    const company = input.company?.trim();
+    if (company)
+        args.push("--company", company);
+    return withRemoteHqDir(joinCommandParts(args));
+}
+/** Read one question's body and owner-computed audience from its Outpost. */
+export function buildOutpostQuestionShowCommand(questionId) {
+    return withRemoteHqDir(joinCommandParts([
+        "hq",
+        "lanes",
+        "questions",
+        "show",
+        questionId,
+    ]));
+}
 /** Commit a queued lane move on the host that currently owns its state. */
 export function buildOutpostMoveTargetCommand(input) {
     return withRemoteHqDir(joinCommandParts([

package/dist/lib/lanes/outpost-pruner-install.js

@@ -3,6 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { resolveHqBinary, resolveNodeBinary } from "../mesh/live/daemon/install.js";
 import { SYSTEMD_PATH_ENV } from "../service-manager/systemd.js";
+import { resolveFlagRegistryEndpoint } from "../flag-registry-endpoint.js";
 export const OUTPOST_PRUNER_PRESSURE_SERVICE = "hq-outpost-worktree-pruner-pressure.service";
 export const OUTPOST_PRUNER_PRESSURE_TIMER = "hq-outpost-worktree-pruner-pressure.timer";
 export const OUTPOST_PRUNER_DAILY_SERVICE = "hq-outpost-worktree-pruner-daily.service";
@@ -160,10 +161,10 @@ export function installOutpostPrunerTimers(options) {
     const nodeBinary = options.nodeBinary ?? resolveNodeBinary();
     const hqBinary = options.hqBinary ?? resolveHqBinary();
     const home = options.home ?? os.homedir();
-    const flagApiUrl = (options.flagApiUrl ?? process.env.HQ_FLAGS_API_URL ?? "").trim();
+    const flagApiUrl = resolveFlagRegistryEndpoint(options.flagApiUrl);
     const companyUid = (options.companyUid ?? process.env.HQ_COMPANY_UID ?? "").trim();
-    if (!flagApiUrl || !companyUid) {
-        throw new TypeError("install requires HQ_FLAGS_API_URL and HQ_COMPANY_UID for the timer services");
+    if (!companyUid) {
+        throw new TypeError("install requires HQ_COMPANY_UID for the timer services");
     }
     const flagEnvironment = [
         systemdEnvironment("HQ_FLAGS_API_URL", flagApiUrl),

package/dist/lib/lanes/outpost-worktree-pruner-flag.js

@@ -1,5 +1,6 @@
 import { loadCachedTokens } from "@indigoai-us/hq-cloud";
 import { createFlagClient } from "@indigoai-us/hq-flags-client";
+import { resolveFlagRegistryEndpoint } from "../flag-registry-endpoint.js";
 export const OUTPOST_WORKTREE_PRUNER_FLAG = "outpost.worktree-pruner";
 export const OUTPOST_WORKTREE_PRUNER_FLAG_FALLBACK = false;
 export const OUTPOST_WORKTREE_PRUNER_FLAG_TIMEOUT_MS = 5_000;
@@ -21,14 +22,13 @@ function reportFlagFailure(error) {
 }
 export async function outpostWorktreePrunerEnabled(dependencies = {}) {
     const env = dependencies.env ?? process.env;
-    const endpoint = env.HQ_FLAGS_API_URL?.trim() || "";
+    const endpoint = resolveFlagRegistryEndpoint(undefined, env);
     const companyUid = env.HQ_COMPANY_UID?.trim() || "";
-    if (!endpoint || !companyUid) {
+    if (!companyUid) {
         process.stderr.write(`${JSON.stringify({
             event: "outpost.worktree_pruner.flag_config_missing",
             flag: OUTPOST_WORKTREE_PRUNER_FLAG,
             missing: [
-                ...(!endpoint ? ["HQ_FLAGS_API_URL"] : []),
                 ...(!companyUid ? ["HQ_COMPANY_UID"] : []),
             ],
             fallback: OUTPOST_WORKTREE_PRUNER_FLAG_FALLBACK,

package/dist/lib/lanes/registry-flag.js

@@ -1,6 +1,7 @@
 import { createFlagClient, readLocalOverride, } from "@indigoai-us/hq-flags-client";
 import { ensureCognitoIdToken } from "../../utils/cognito-session.js";
-export const LANES_FLAG_API_DEFAULT_ENDPOINT = "https://hqapi.hq.computer";
+import { FLAG_REGISTRY_DEFAULT_ENDPOINT, resolveFlagRegistryEndpoint, } from "../flag-registry-endpoint.js";
+export const LANES_FLAG_API_DEFAULT_ENDPOINT = FLAG_REGISTRY_DEFAULT_ENDPOINT;
 export const LANES_FLAG_READ_TIMEOUT_MS = 5_000;
 const registryReads = new Map();
 class MissingFlagTokenError extends Error {
@@ -45,7 +46,7 @@ export async function readLanesRegistryFlag(flagKey, options = {}) {
     const localOverride = readLocalOverride(flagKey, env);
     if (localOverride !== null)
         return localOverride;
-    const endpoint = env.HQ_FLAGS_API_URL?.trim() || LANES_FLAG_API_DEFAULT_ENDPOINT;
+    const endpoint = resolveFlagRegistryEndpoint(undefined, env);
     const key = cacheKey(flagKey, options.company, endpoint);
     const cached = registryReads.get(key);
     if (cached)

package/dist/node-network-compat-flag.js

@@ -1,4 +1,5 @@
 import { createFlagClient, readLocalOverride } from "@indigoai-us/hq-flags-client";
+import { resolveFlagRegistryEndpoint } from "./lib/flag-registry-endpoint.js";
 export const NODE_NETWORK_FORCE_IPV4_FLAG = "cli.network.force-ipv4";
 export const NODE_NETWORK_FORCE_IPV4_FLAG_FALLBACK = false;
 // Node waits up to 1s before trying the next address family. Keep this request
@@ -29,10 +30,9 @@ export async function nodeNetworkForceIpv4Enabled(dependencies = {}) {
     const localOverride = readLocalOverride(NODE_NETWORK_FORCE_IPV4_FLAG, env);
     if (localOverride !== null)
         return localOverride;
-    const endpoint = env.HQ_FLAGS_API_URL?.trim() || "";
+    const endpoint = resolveFlagRegistryEndpoint(undefined, env);
     const companyUid = env.HQ_COMPANY_UID?.trim() || "";
-    if (!endpoint ||
-        !/^cmp_[A-Za-z0-9]{3,128}$/.test(companyUid)) {
+    if (!/^cmp_[A-Za-z0-9]{3,128}$/.test(companyUid)) {
         return NODE_NETWORK_FORCE_IPV4_FLAG_FALLBACK;
     }
     const companySlug = env.HQ_COMPANY_SLUG?.trim() || "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.198.1",
+  "version": "5.199.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {