@indigoai-us/hq-cli 5.198.0 → 5.199.0

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);
@@ -6771,7 +7223,7 @@ function deliverAnswerToAskingLane(ctx, question, choice, at) {
         }
         assertLaneRunsHereForOperatorMutation(ctx, lane, "deliver an answer to");
         appendDropboxMessage(hqRoot, laneId, answerDropboxMessage(question, choice, at, mintMessageId()));
-        return { status: "dropped" };
+        return { status: "awaiting_next_tool_call" };
     }
     catch (err) {
         writeAnswerDeliveryFailed(hqRoot, laneId, question.question_id, err, at);
@@ -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() || "";