@indigoai-us/hq-cli 5.313.0 → 5.314.0

package/dist/commands/lanes-questions.js

@@ -1,1005 +0,0 @@
-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