@indigoai-us/hq-cli 5.314.0 → 5.315.0

package/dist/commands/lanes-questions.js

@@ -0,0 +1,1005 @@
+import { buildOutpostQuestionAnswerCommand, buildOutpostQuestionCancelCommand, buildOutpostQuestionShowCommand, dispatchErrorMessage } from "../lib/lanes/outpost-dispatch.js";
+import { assertNoSecretText } from "../lib/lanes/text-scan.js";
+import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
+import { appendCappedHistory, createQuestion, isLanesError, listSessionLiveness, parseLivenessState, parseQuestionRecord, parseQuestionStatus, readDaemonPresenceConnected, readLane, readQuestion, wakeAnsweredLaneNow, sessionLiveness, appendDropboxMessage, answerDropboxMessage, laneAcceptsDropboxDelivery, laneIdForAnswerDelivery, writeQuestionBody } from "../lib/lanes/index.js";
+import { resolveQuestionCompanyWithFallback } from "../lib/lanes/questions.js";
+import { LanesError } from "../lib/lanes/errors.js";
+export function resolveAnswerChoice(choice, options, freeform) {
+    const trimmed = choice.trim();
+    if (/^[0-9]+$/.test(trimmed)) {
+        const index = Number(trimmed);
+        if (Number.isInteger(index) && index >= 1 && index <= options.length) {
+            return options[index - 1];
+        }
+    }
+    if (options.includes(trimmed) || options.includes(choice)) {
+        return options.includes(trimmed) ? trimmed : choice;
+    }
+    if (freeform)
+        return choice;
+    throw new LanesError("off_menu_choice", `Choice ${JSON.stringify(choice)} is not on the menu. Pass --freeform to allow it.`, { choice, options });
+}
+export function createLaneQuestionsHandlers(deps) {
+    const { CAPACITY_PROBE_TIMEOUT_MS, MAX_PLACEMENT_OUTPOSTS, OUTPOST_QUESTION_LOOKUP_CONCURRENCY, assertLaneRunsHereForOperatorMutation, assertQuestionAnswerAuthorized, assertQuestionCompanyMatchesLane, casUpdateQuestion, casUpdateLane, effectiveLaneQuestionCompany, emitLaneMeshEvent, groupQuestionLanesByCompany, isQuestionAnswer, laneIsHostedHere, livenessDepsFromCtx, loadAllLanes, loadAllQuestions, mapWithConcurrency, mintMessageId, parseOutpostQuestionAudience, parseOutpostQuestionBody, parseRemoteJson, parseSeniorRef, questionCompanyForLane, questionCompanyRefMatches, questionListCompanyArg, readOutpostQuestionRecords, readQuestionBody, printJson, readSessionMeta, reconcileHostFromCtx, resolveActiveQuestionCompany, resolveAudience, sameQuestionAnswer, sameQuestionCompany, seniorOfSession, writeAnswerDeliveryFailed } = deps;
+    function requireQuestionBody(hqRoot, question) {
+        const body = readQuestionBody(hqRoot, question);
+        if (!body) {
+            throw new LanesError("question_body_unavailable", `Question body is not available on this host for ${question.question_id}`, {
+                question_id: question.question_id,
+                store: question.body.store,
+                ref: question.body.ref,
+            });
+        }
+        return body;
+    }
+    function assertQuestionCompanyAccess(question, lane, requestedCompany, hqRoot) {
+        assertQuestionCompanyMatchesLane(question, lane, "question_company_mismatch", hqRoot);
+        const questionCompany = questionCompanyForLane(question, lane, hqRoot);
+        if (questionCompany !== null && !sameQuestionCompany(questionCompany, requestedCompany)) {
+            throw new LanesError("question_company_mismatch", `Question ${question.question_id} does not belong to the requested or active company`, { question_id: question.question_id, lane_id: lane.lane_id });
+        }
+    }
+    function assertQuestionCompanyResolvedForAnswer(question, lane, hqRoot, resolvedCompany) {
+        if (questionCompanyForLane(question, lane, hqRoot) !== null || resolvedCompany)
+            return;
+        throw new LanesError("question_company_unavailable", `Cannot answer legacy question ${question.question_id}: its company cannot be resolved from the question or lane; re-run with --company <slug>`, { question_id: question.question_id, lane_id: lane.lane_id });
+    }
+    function audienceMatches(audience, filter) {
+        if (filter.kind === "me") {
+            return audience.kind === "session" && audience.id === filter.id;
+        }
+        if (filter.kind === "user")
+            return audience.kind === "user";
+        return audience.kind === filter.kind && audience.id === filter.id;
+    }
+    function questionAudienceMatchesSenior(audience, lane, ctx) {
+        if (audienceMatches(audience, lane.senior))
+            return true;
+        const sessionId = sessionIdFromEnv(ctx.env);
+        if (sessionId && audienceMatches(audience, { kind: "session", id: sessionId }))
+            return true;
+        const callerLaneId = ctx.env.HQ_LANE_ID?.trim();
+        return callerLaneId !== undefined && callerLaneId.length > 0 &&
+            audienceMatches(audience, { kind: "lane", id: callerLaneId });
+    }
+    function parseForFilter(raw, ctx) {
+        const trimmed = raw.trim();
+        if (trimmed === "me") {
+            const sessionId = sessionIdFromEnv(ctx.env);
+            if (!sessionId) {
+                throw new LanesError("missing_session_id", "--for me requires a current session id (HQ_SESSION_ID)", {});
+            }
+            return { kind: "me", id: sessionId };
+        }
+        return parseSeniorRef(trimmed);
+    }
+    function yieldEventLoop() {
+        return new Promise((resolve) => {
+            setImmediate(resolve);
+        });
+    }
+    function throwIfQuestionNotPending(current) {
+        if (current.status === "pending")
+            return;
+        throw new LanesError("question_not_pending", `Question ${current.question_id} is ${current.status}`, { question_id: current.question_id, status: current.status });
+    }
+    async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options, lookupErrors = []) {
+        if (lane.host.kind !== "outpost") {
+            throw new LanesError("outpost_dispatch_failed", `Lane ${lane.lane_id} has no Outpost host to answer its question`, { lane_id: lane.lane_id, question_id: questionId });
+        }
+        assertQuestionAnswerAuthorized(ctx, lane);
+        const outpostId = lane.host.id;
+        let dispatched;
+        try {
+            dispatched = await ctx.dispatchOutpostExec({
+                outpostId,
+                command: buildOutpostQuestionAnswerCommand({
+                    questionId,
+                    choice: options.choice,
+                    freeform: options.freeform,
+                    notes: options.notes,
+                    company: options.company,
+                }),
+            });
+        }
+        catch (err) {
+            throw new LanesError("outpost_dispatch_failed", `Could not dispatch question ${questionId} to Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
+        }
+        if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
+            throw new LanesError("outpost_dispatch_failed", `Outpost ${outpostId} did not confirm the answer for question ${questionId}`, {
+                lane_id: lane.lane_id,
+                question_id: questionId,
+                outpost_id: outpostId,
+                command_id: dispatched.commandId,
+                status: dispatched.status,
+                done: dispatched.done ?? false,
+                exit_code: dispatched.exitCode,
+            });
+        }
+        const remote = parseRemoteJson(dispatched.stdout, "Outpost question answer");
+        if (remote?.error !== undefined) {
+            throw new LanesError("outpost_remote_command_failed", typeof remote.message === "string"
+                ? remote.message
+                : `Outpost ${outpostId} rejected the answer for question ${questionId}`, {
+                lane_id: lane.lane_id,
+                question_id: questionId,
+                outpost_id: outpostId,
+                command_id: dispatched.commandId,
+                remote_error: remote.error,
+            });
+        }
+        const remoteQuestion = remote?.question !== null && typeof remote?.question === "object"
+            ? remote.question
+            : null;
+        const awaitingWakeConfirmed = lane.state !== "awaiting_input" ||
+            (remote?.wake_status === "resumed" && remote.lane_state === "running") ||
+            (remote?.wake_status === "queued" && remote.lane_state === "queued") ||
+            ((remote?.wake_status === "awaiting_answers" || remote?.wake_status === "deferred") &&
+                remote.lane_state === "awaiting_input");
+        if (remote?.ok !== true ||
+            remote.action !== "questions.answer" ||
+            remoteQuestion?.question_id !== questionId ||
+            remoteQuestion.lane_id !== lane.lane_id ||
+            remoteQuestion.status !== "answered" ||
+            typeof remote.delivery !== "string" ||
+            !awaitingWakeConfirmed) {
+            throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} completed exec without confirming the answer and wake status for question ${questionId}`, {
+                lane_id: lane.lane_id,
+                question_id: questionId,
+                outpost_id: outpostId,
+                command_id: dispatched.commandId,
+            });
+        }
+        let ownerQuestion;
+        try {
+            ownerQuestion = parseQuestionRecord(remoteQuestion);
+        }
+        catch (err) {
+            throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} did not return a valid answered question record for ${questionId}: ${dispatchErrorMessage(err)}`, {
+                lane_id: lane.lane_id,
+                question_id: questionId,
+                outpost_id: outpostId,
+                command_id: dispatched.commandId,
+            });
+        }
+        const ownerAnswer = ownerQuestion.answer;
+        const ownerLaneCompany = effectiveLaneQuestionCompany(lane, ctx.hqRoot());
+        if (!isQuestionAnswer(ownerAnswer) ||
+            ownerQuestion.lane_id !== lane.lane_id ||
+            (ownerQuestion.company !== null && ownerLaneCompany !== null &&
+                !sameQuestionCompany(ownerQuestion.company, ownerLaneCompany))) {
+            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,
+                outpost_id: outpostId,
+                command_id: dispatched.commandId,
+            });
+        }
+        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 (current.company !== null &&
+                effectiveLaneQuestionCompany(lane, ctx.hqRoot()) !== null &&
+                !sameQuestionCompany(current.company, effectiveLaneQuestionCompany(lane, ctx.hqRoot()))) {
+                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.company !== null &&
+                ownerQuestion.company !== null &&
+                !sameQuestionCompany(current.company, ownerQuestion.company)) {
+                throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} has a different company than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
+            }
+            if (current.status === "pending") {
+                return {
+                    ...current,
+                    company: current.company ?? ownerQuestion.company,
+                    status: "answered",
+                    answer: ownerAnswer,
+                    delivered_at: ownerQuestion.delivered_at ?? current.delivered_at ?? null,
+                };
+            }
+            if (current.status === "answered" && sameQuestionAnswer(current.answer, ownerAnswer)) {
+                const deliveredAt = ownerQuestion.delivered_at ?? current.delivered_at ?? null;
+                const company = current.company ?? ownerQuestion.company;
+                return deliveredAt === current.delivered_at && company === current.company
+                    ? current
+                    : { ...current, company, delivered_at: deliveredAt };
+            }
+            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);
+            const primaryCompany = effectiveLaneQuestionCompany(primaryLane, ctx.hqRoot());
+            const ownerCompany = effectiveLaneQuestionCompany(lane, ctx.hqRoot());
+            if (primaryCompany !== null && ownerCompany !== null && !sameQuestionCompany(primaryCompany, ownerCompany)) {
+                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,
+            question: syncedQuestion,
+            outpost_id: outpostId,
+            outpost_command_id: dispatched.commandId,
+            outpost_transport: "outposts_exec",
+            ...(lookupErrors.length > 0 ? { lookup_errors: lookupErrors } : {}),
+        });
+    }
+    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) {
+            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 });
+        }
+        assertQuestionCompanyMatchesLane(question, owner.lane, "outpost_question_company_mismatch", ctx.hqRoot());
+        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" &&
+            !laneIsHostedHere(ctx, lane) &&
+            (!companyFilter ||
+                effectiveLaneQuestionCompany(lane, hqRoot) === null ||
+                questionCompanyRefMatches(effectiveLaneQuestionCompany(lane, hqRoot), 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(hqRoot, lanes, companyFilter)) {
+                if (group.company === null) {
+                    errors.push({
+                        host: `outpost:${outpostId}`,
+                        error: "outpost_question_company_unavailable",
+                    });
+                    continue;
+                }
+                if (companyFilter && !questionCompanyRefMatches(group.company, companyFilter))
+                    continue;
+                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;
+                    assertQuestionCompanyMatchesLane(question, lane, "outpost_question_company_mismatch", hqRoot);
+                    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 cancelFallbackQuestionsForLane(ctx, lane, trigger, at) {
+        const hqRoot = ctx.hqRoot();
+        const caller = ctx.env.HQ_LANE_ID?.trim() || sessionIdFromEnv(ctx.env) || "user";
+        const reason = `Fallback ${trigger} by ${caller} at ${at}`;
+        const failures = [];
+        const cancelledQuestionIds = [];
+        const remoteOwner = lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane);
+        let pending;
+        try {
+            pending = remoteOwner
+                ? (await readOutpostQuestionRecords(ctx, lane.host.id, effectiveLaneQuestionCompany(lane, hqRoot)))
+                    .map(({ question }) => question)
+                    .filter((question) => question.origin.id === lane.lane_id && question.status === "pending")
+                : loadAllQuestions(hqRoot).filter((question) => question.origin.id === lane.lane_id && question.status === "pending");
+        }
+        catch (err) {
+            failures.push({ error: dispatchErrorMessage(err) });
+            pending = [];
+        }
+        for (const question of pending) {
+            try {
+                if (remoteOwner) {
+                    const outpostId = lane.host.id;
+                    const dispatched = await ctx.dispatchOutpostExec({
+                        outpostId,
+                        command: buildOutpostQuestionCancelCommand({ questionId: question.question_id, reason }),
+                        timeoutSeconds: Math.ceil(CAPACITY_PROBE_TIMEOUT_MS / 1000),
+                        waitMs: CAPACITY_PROBE_TIMEOUT_MS,
+                    });
+                    const remote = parseRemoteJson(dispatched.stdout, "Outpost question cancel");
+                    const remoteQuestion = remote?.question !== null && typeof remote?.question === "object"
+                        ? remote.question
+                        : null;
+                    if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0 ||
+                        remote?.ok !== true || remote.action !== "questions.cancel" ||
+                        remoteQuestion?.question_id !== question.question_id || remoteQuestion.status !== "cancelled") {
+                        throw new LanesError("outpost_question_cancel_unconfirmed", `Outpost ${outpostId} did not confirm cancellation of question ${question.question_id}`, { lane_id: lane.lane_id, question_id: question.question_id, outpost_id: outpostId });
+                    }
+                }
+                else {
+                    const cancellationEntry = {
+                        hop: question.hop,
+                        audience: resolveAudience(hqRoot, question, ctx),
+                        at,
+                        reason: "cancelled",
+                        detail: reason,
+                    };
+                    const updated = casUpdateQuestion(hqRoot, question.question_id, (current) => {
+                        if (current.status !== "pending")
+                            return current;
+                        return {
+                            ...current,
+                            status: "cancelled",
+                            routing_history: appendCappedHistory(current.routing_history, cancellationEntry),
+                        };
+                    });
+                    if (updated.status !== "cancelled")
+                        continue;
+                }
+                cancelledQuestionIds.push(question.question_id);
+            }
+            catch (err) {
+                failures.push({ question_id: question.question_id, error: dispatchErrorMessage(err) });
+            }
+        }
+        if (failures.length > 0) {
+            const failure = {
+                at,
+                caller,
+                trigger,
+                question_ids: failures.flatMap((entry) => entry.question_id ? [entry.question_id] : []),
+                error: failures.map((entry) => entry.error).join("; "),
+            };
+            try {
+                casUpdateLane(hqRoot, lane.lane_id, (current) => {
+                    const history = current.fallback_question_cancellation_failures ?? [];
+                    const duplicate = history.some((entry) => entry.at === failure.at && entry.caller === caller && entry.trigger === trigger);
+                    return duplicate
+                        ? current
+                        : {
+                            ...current,
+                            fallback_question_cancellation_failures: [...history, failure].slice(-20),
+                        };
+                });
+            }
+            catch (err) {
+                const message = `Could not record fallback question cancellation failure for lane ${lane.lane_id}: ${dispatchErrorMessage(err)}\n`;
+                process.stderr.write(message);
+                failures.push({ error: `Failure record could not be persisted: ${dispatchErrorMessage(err)}` });
+            }
+        }
+        return { cancelled_question_ids: cancelledQuestionIds, failures };
+    }
+    async function hasPendingQuestionForLane(ctx, lane) {
+        const hqRoot = ctx.hqRoot();
+        const local = loadAllQuestions(hqRoot).some((question) => question.lane_id === lane.lane_id &&
+            question.status === "pending" &&
+            questionAudienceMatchesSenior(resolveAudience(hqRoot, question, ctx), lane, ctx));
+        if (local)
+            return true;
+        if (lane.host.kind !== "outpost" || laneIsHostedHere(ctx, lane))
+            return false;
+        // Reuse the owner lookup used by questions list/answer. An unreachable
+        // owner leaves no answerable question, so the message/resume path can recover.
+        const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot);
+        return lookup.questions.some(({ question, lane: ownerLane, audience }) => ownerLane.lane_id === lane.lane_id &&
+            question.status === "pending" &&
+            questionAudienceMatchesSenior(audience, ownerLane, ctx));
+    }
+    function syncPrimaryQuestionDelivery(hqRoot, owner) {
+        const deliveredAt = owner.question.delivered_at;
+        if (!deliveredAt)
+            return;
+        try {
+            casUpdateQuestion(hqRoot, owner.question.question_id, (current) => {
+                if (current.lane_id !== owner.lane.lane_id) {
+                    throw new LanesError("outpost_question_sync_conflict", `Primary question ${current.question_id} belongs to a different lane than its Outpost owner`, { lane_id: owner.lane.lane_id, question_id: current.question_id });
+                }
+                if (current.company !== null &&
+                    owner.question.company !== null &&
+                    !sameQuestionCompany(current.company, owner.question.company)) {
+                    throw new LanesError("outpost_question_sync_conflict", `Primary question ${current.question_id} belongs to a different company than its Outpost owner`, { lane_id: owner.lane.lane_id, question_id: current.question_id });
+                }
+                const company = current.company ?? owner.question.company;
+                const nextDeliveredAt = current.delivered_at ?? deliveredAt;
+                return company === current.company && nextDeliveredAt === current.delivered_at
+                    ? current
+                    : { ...current, company, delivered_at: nextDeliveredAt };
+            });
+        }
+        catch (err) {
+            if (isLanesError(err) && err.error === "question_not_found")
+                return;
+            throw err;
+        }
+    }
+    function deliverAnswerToAskingLane(ctx, question, choice, at) {
+        const hqRoot = ctx.hqRoot();
+        const laneId = laneIdForAnswerDelivery(question);
+        try {
+            const lane = readLane(hqRoot, laneId);
+            if (!laneAcceptsDropboxDelivery(lane)) {
+                return { status: "recorded_only" };
+            }
+            assertLaneRunsHereForOperatorMutation(ctx, lane, "deliver an answer to");
+            appendDropboxMessage(hqRoot, laneId, answerDropboxMessage(question, choice, at, mintMessageId()));
+            return { status: "awaiting_next_tool_call" };
+        }
+        catch (err) {
+            writeAnswerDeliveryFailed(hqRoot, laneId, question.question_id, err, at);
+            return { status: "failed" };
+        }
+    }
+    async function runQuestionsList(ctx, opts) {
+        const hqRoot = ctx.hqRoot();
+        const status = opts.status ? parseQuestionStatus(opts.status) : undefined;
+        const forFilter = opts.for ? parseForFilter(opts.for, ctx) : undefined;
+        const company = opts.company
+            ? await ctx.resolveCompany(opts.company)
+            : await resolveActiveQuestionCompany(ctx, "Cannot access lane questions because the active HQ company could not be resolved; re-run with --company <slug>");
+        const localLanes = new Map(loadAllLanes(hqRoot).map((lane) => [lane.lane_id, lane]));
+        const targeted = opts.from !== undefined || opts.project !== undefined || opts.story !== undefined;
+        const localQuestions = loadAllQuestions(hqRoot)
+            .filter((q) => {
+            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;
+            const lane = localLanes.get(q.lane_id);
+            if (lane)
+                assertQuestionCompanyMatchesLane(q, lane, "question_company_mismatch", hqRoot);
+            const questionCompany = lane ? questionCompanyForLane(q, lane, hqRoot) : q.company;
+            if (questionCompany !== null && !sameQuestionCompany(questionCompany, company)) {
+                if (targeted) {
+                    throw new LanesError("question_company_mismatch", `Question ${q.question_id} does not belong to the requested or active company`, { question_id: q.question_id, lane_id: q.lane_id });
+                }
+                return false;
+            }
+            if (forFilter) {
+                const audience = resolveAudience(hqRoot, q, ctx);
+                if (!audienceMatches(audience, forFilter))
+                    return false;
+            }
+            return true;
+        });
+        const outpostLoad = opts.allHosts
+            ? await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company)
+            : { questions: [], errors: [] };
+        for (const owner of outpostLoad.questions) {
+            assertQuestionCompanyAccess(owner.question, owner.lane, company, hqRoot);
+            syncPrimaryQuestionDelivery(hqRoot, owner);
+        }
+        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,
+                    priority: q.priority ?? null,
+                    priority_display: q.priority ?? "-",
+                    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;
+                assertQuestionCompanyAccess(q, lane, company, hqRoot);
+                if (forFilter) {
+                    if (!audienceMatches(audience, forFilter))
+                        return false;
+                }
+                return true;
+            })
+                .map(({ question: q, host, audience }) => ({
+                ...q,
+                priority: q.priority ?? null,
+                priority_display: q.priority ?? "-",
+                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();
+        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,
+            action: "questions.show",
+            question,
+            audience: resolveAudience(hqRoot, question, ctx),
+            body,
+        });
+    }
+    async function runQuestionsAnswer(ctx, questionId, opts) {
+        const hqRoot = ctx.hqRoot();
+        if (opts.choice !== undefined)
+            assertNoSecretText("answer choice", opts.choice);
+        if (opts.freeform !== undefined)
+            assertNoSecretText("freeform answer", opts.freeform);
+        if (opts.notes !== undefined)
+            assertNoSecretText("answer notes", opts.notes);
+        const explicitCompany = 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 company = explicitCompany ?? await resolveActiveQuestionCompany(ctx, "Cannot look up this lane question because the active HQ company could not be resolved; re-run with --company <slug>");
+            const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company);
+            const matches = lookup.questions.filter((entry) => entry.question.question_id === questionId);
+            if (matches.length === 0 && 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 })),
+                });
+            }
+            if (matches.length === 0) {
+                const allCompanyLookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot);
+                const otherCompanyMatch = allCompanyLookup.questions.find((entry) => entry.question.question_id === questionId);
+                if (otherCompanyMatch) {
+                    assertQuestionCompanyAccess(otherCompanyMatch.question, otherCompanyMatch.lane, company, hqRoot);
+                }
+                if (allCompanyLookup.errors.length > 0) {
+                    throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
+                        question_id: questionId,
+                        hosts: allCompanyLookup.errors.map(({ host, error }) => ({ host, error })),
+                    });
+                }
+                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 });
+            }
+            assertQuestionCompanyAccess(owner.question, owner.lane, company, hqRoot);
+            const ownerCompany = await resolveQuestionCompanyWithFallback(hqRoot, owner.lane, async () => explicitCompany ?? company);
+            assertQuestionCompanyResolvedForAnswer(owner.question, owner.lane, hqRoot, ownerCompany);
+            throwIfQuestionNotPending(owner.question);
+            await yieldEventLoop();
+            await dispatchOutpostQuestionAnswer(ctx, owner.lane, questionId, {
+                ...opts,
+                company: questionListCompanyArg(ownerCompany),
+            }, lookup.errors);
+            return;
+        }
+        await yieldEventLoop();
+        const askingLane = readLane(hqRoot, laneIdForAnswerDelivery(question));
+        const resolvedCompany = await resolveQuestionCompanyWithFallback(hqRoot, askingLane, async () => explicitCompany ?? question.company ?? await resolveActiveQuestionCompany(ctx, `Cannot answer legacy question ${questionId}: its company cannot be resolved from the question or lane; re-run with --company <slug>`));
+        const requestedCompany = explicitCompany ?? resolvedCompany;
+        assertQuestionCompanyAccess(question, askingLane, requestedCompany, hqRoot);
+        assertQuestionCompanyResolvedForAnswer(question, askingLane, hqRoot, resolvedCompany);
+        const questionCompany = question.company ?? effectiveLaneQuestionCompany(askingLane, hqRoot) ?? resolvedCompany;
+        const questionForBody = question.company === null
+            ? { ...question, company: questionCompany }
+            : question;
+        if (askingLane.host.kind === "outpost" && !laneIsHostedHere(ctx, askingLane)) {
+            await dispatchOutpostQuestionAnswer(ctx, askingLane, questionId, {
+                ...opts,
+                company: questionListCompanyArg(questionCompany),
+            });
+            return;
+        }
+        throwIfQuestionNotPending(question);
+        if (askingLane.state === "awaiting_input") {
+            assertLaneRunsHereForOperatorMutation(ctx, askingLane, "wake after answering");
+        }
+        if (laneAcceptsDropboxDelivery(askingLane)) {
+            assertLaneRunsHereForOperatorMutation(ctx, askingLane, "deliver an answer to");
+        }
+        const body = requireQuestionBody(hqRoot, questionForBody);
+        // A trimmed-empty --freeform is absent: it must not win over --choice and
+        // must not become a freeform answer of "".
+        const freeform = opts.freeform?.trim() || undefined;
+        if (freeform !== undefined && body.options.length === 0) {
+            throw new LanesError("freeform_not_allowed", "--freeform is only allowed for a question with options", { question_id: questionId });
+        }
+        if (!freeform && !opts.choice) {
+            throw new LanesError("missing_choice", "--choice or --freeform is required", {});
+        }
+        const choice = freeform ?? resolveAnswerChoice(opts.choice, body.options, false);
+        const at = ctx.now().toISOString();
+        const answeredBy = sessionIdFromEnv(ctx.env)
+            ? `session:${sessionIdFromEnv(ctx.env)}`
+            : "user";
+        const updated = casUpdateQuestion(hqRoot, questionId, (current) => {
+            throwIfQuestionNotPending(current);
+            assertQuestionCompanyAccess(current, askingLane, requestedCompany, hqRoot);
+            const recordedCompany = current.company ?? questionCompany;
+            const currentForBody = current.company === null
+                ? { ...current, company: recordedCompany }
+                : current;
+            let notesRef;
+            let nextBody = current.body;
+            if (opts.notes) {
+                const stored = writeQuestionBody(hqRoot, currentForBody, {
+                    ...body,
+                    notes: opts.notes,
+                });
+                notesRef = stored.ref;
+                nextBody = stored;
+            }
+            return {
+                ...current,
+                company: recordedCompany,
+                body: nextBody,
+                status: "answered",
+                answer: {
+                    choice,
+                    answer_kind: freeform ? "freeform" : "option",
+                    notes_ref: notesRef,
+                    answered_by: answeredBy,
+                    answered_at: at,
+                    answered_level: current.hop,
+                },
+            };
+        });
+        const latestAskingLane = readLane(hqRoot, askingLane.lane_id);
+        if (latestAskingLane.state === "awaiting_input") {
+            let wake;
+            try {
+                wake = await wakeAnsweredLaneNow(hqRoot, askingLane.lane_id, {
+                    now: ctx.now,
+                    host: reconcileHostFromCtx(ctx),
+                    dryRun: false,
+                    spawnLaneDeps: {
+                        env: ctx.env,
+                        existsSync: ctx.existsSync,
+                        spawnProcess: ctx.spawnProcess,
+                        proveDetached: ctx.proveDetached,
+                        killProcess: ctx.killProcess,
+                        now: ctx.now,
+                        resolveMachineIdentity: ctx.resolveMachineIdentity,
+                        runCompaction: ctx.runCompaction,
+                        locateTranscript: ctx.locateTranscript,
+                    },
+                    throttleDeps: ctx.throttleDeps,
+                    livenessDeps: livenessDepsFromCtx(ctx),
+                    presenceConnected: ctx.presenceConnected,
+                    mesh: ctx.mesh,
+                    env: ctx.env,
+                });
+            }
+            catch (err) {
+                throw new LanesError("question_wake_failed", `Question ${questionId} was recorded, but lane ${askingLane.lane_id} could not be woken: ${dispatchErrorMessage(err)}`, { lane_id: askingLane.lane_id, question_id: questionId });
+            }
+            if (wake.status === "failed") {
+                throw new LanesError("question_wake_failed", `Question ${questionId} was recorded, but lane ${askingLane.lane_id} could not be woken: ${wake.error}`, { lane_id: askingLane.lane_id, question_id: questionId, wake_error: wake.error });
+            }
+            printJson({
+                ok: true,
+                action: "questions.answer",
+                lane_id: askingLane.lane_id,
+                question: updated,
+                delivery: wake.status === "awaiting_answers" ? "awaiting_other_answers" : wake.status,
+                wake_status: wake.status,
+                lane_state: wake.lane_state,
+                ...(wake.queued_reason !== undefined ? { queued_reason: wake.queued_reason } : {}),
+                ...(wake.remaining_question_ids !== undefined
+                    ? { remaining_question_ids: wake.remaining_question_ids }
+                    : {}),
+            });
+            return;
+        }
+        const delivery = deliverAnswerToAskingLane(ctx, updated, choice, at);
+        printJson({
+            ok: true,
+            action: "questions.answer",
+            question: updated,
+            delivery: delivery.status,
+        });
+    }
+    async function runQuestionsEscalate(ctx, questionId, opts) {
+        const hqRoot = ctx.hqRoot();
+        const question = readQuestion(hqRoot, questionId);
+        throwIfQuestionNotPending(question);
+        await yieldEventLoop();
+        const originalHop = question.hop;
+        const audience = resolveAudience(hqRoot, question, ctx);
+        if (audience.kind === "user") {
+            throw new LanesError("already_at_top_authority", "Cannot escalate past the user", { question_id: questionId });
+        }
+        const at = ctx.now().toISOString();
+        if (opts.note) {
+            requireQuestionBody(hqRoot, question);
+        }
+        const updated = casUpdateQuestion(hqRoot, questionId, (current) => {
+            throwIfQuestionNotPending(current);
+            if (current.hop !== originalHop) {
+                throw new LanesError("question_already_escalated", `Question ${questionId} hop already advanced`, {
+                    question_id: questionId,
+                    hop: current.hop,
+                    expected_hop: originalHop,
+                });
+            }
+            let nextBody = current.body;
+            if (opts.note) {
+                const body = requireQuestionBody(hqRoot, current);
+                nextBody = writeQuestionBody(hqRoot, current, {
+                    ...body,
+                    notes: [body.notes, opts.note].filter(Boolean).join("\n"),
+                });
+            }
+            const nextHop = current.hop + 1;
+            return {
+                ...current,
+                body: nextBody,
+                hop: nextHop,
+                routing_history: appendCappedHistory(current.routing_history, {
+                    hop: nextHop,
+                    audience: resolveAudience(hqRoot, { ...current, hop: nextHop }, ctx),
+                    at,
+                    reason: "escalated",
+                }),
+            };
+        });
+        const nextAudience = resolveAudience(hqRoot, updated, ctx);
+        if (nextAudience.kind === "user") {
+            const lane = readLane(hqRoot, updated.lane_id);
+            await emitLaneMeshEvent(ctx, lane.mesh_company ?? lane.company, lane.thread_id, "lane_question_at_user", { lane_id: lane.lane_id, question_id: updated.question_id });
+        }
+        printJson({ ok: true, action: "questions.escalate", question: updated });
+    }
+    async function runQuestionsCancel(ctx, questionId, opts) {
+        const hqRoot = ctx.hqRoot();
+        const question = readQuestion(hqRoot, questionId);
+        throwIfQuestionNotPending(question);
+        await yieldEventLoop();
+        const at = ctx.now().toISOString();
+        const updated = casUpdateQuestion(hqRoot, questionId, (current) => {
+            throwIfQuestionNotPending(current);
+            const entry = {
+                hop: current.hop,
+                audience: resolveAudience(hqRoot, current, ctx),
+                at,
+                reason: "cancelled",
+                ...(opts.reason ? { detail: opts.reason } : {}),
+            };
+            return {
+                ...current,
+                status: "cancelled",
+                routing_history: appendCappedHistory(current.routing_history, entry),
+            };
+        });
+        printJson({ ok: true, action: "questions.cancel", question: updated });
+    }
+    async function runSessionsList(ctx, opts) {
+        const hqRoot = ctx.hqRoot();
+        const state = opts.state ? parseLivenessState(opts.state) : undefined;
+        const livenessDeps = livenessDepsFromCtx(ctx);
+        const presenceConnected = ctx.presenceConnected ?? readDaemonPresenceConnected(livenessDeps);
+        const rows = listSessionLiveness(hqRoot, {
+            nowMs: ctx.now().getTime(),
+            presenceConnected,
+            deps: livenessDeps,
+        }).filter((row) => {
+            if (state && row.state !== state)
+                return false;
+            if (!opts.company)
+                return true;
+            const meta = readSessionMeta(hqRoot, row.sessionId, ctx);
+            const slug = typeof meta?.company_slug === "string" ? meta.company_slug : "";
+            const uid = typeof meta?.company_uid === "string" ? meta.company_uid : "";
+            return slug === opts.company || uid === opts.company;
+        });
+        printJson({ ok: true, action: "sessions.list", sessions: rows });
+    }
+    async function runSessionsShow(ctx, sessionId) {
+        const hqRoot = ctx.hqRoot();
+        const livenessDeps = livenessDepsFromCtx(ctx);
+        const presenceConnected = ctx.presenceConnected ?? readDaemonPresenceConnected(livenessDeps);
+        const state = sessionLiveness(hqRoot, sessionId, {
+            nowMs: ctx.now().getTime(),
+            presenceConnected,
+            deps: livenessDeps,
+        });
+        if (state === null) {
+            throw new LanesError("session_not_found", `Session ${sessionId} is not in the liveness index`, { session_id: sessionId });
+        }
+        const meta = readSessionMeta(hqRoot, sessionId, ctx);
+        printJson({
+            ok: true,
+            action: "sessions.show",
+            session_id: sessionId,
+            state,
+            senior: meta ? seniorOfSession(hqRoot, sessionId, ctx) : { kind: "user" },
+            company_slug: typeof meta?.company_slug === "string" ? meta.company_slug : null,
+        });
+    }
+    return {
+        hasPendingQuestionForLane,
+        cancelFallbackQuestionsForLane,
+        runQuestionsList,
+        runQuestionsShow,
+        runQuestionsAnswer,
+        runQuestionsEscalate,
+        runQuestionsCancel,
+        runSessionsList,
+        runSessionsShow,
+        requireQuestionBody
+    };
+}
+//# sourceMappingURL=lanes-questions.js.map