@indigoai-us/hq-cli 5.218.0 → 5.220.0

package/dist/commands/lanes.js

@@ -13,6 +13,7 @@ import * as path from "node:path";
 import { readLocalOverride } from "@indigoai-us/hq-flags-client";
 import { Option } from "commander";
 import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
+import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
@@ -33,6 +34,7 @@ import { vaultApiFetch } from "../utils/vault-api.js";
 import { resolveActiveMembershipCompany } from "../lib/mesh/api.js";
 import { openMeshTransport, requireToken } from "../lib/mesh/client.js";
 import { CompanySelectionError } from "../utils/company-selection-error.js";
+import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
@@ -40,7 +42,7 @@ import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
 import { keepAliveExclusion, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
-import { questionBodyAbsPath } from "../lib/lanes/questions.js";
+import { questionBodyAbsPath, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { assertUniqueAccountHomes, providerCompactAfterMs } from "../lib/lanes/config.js";
 import { parseCliEffort, resolveLaneEffort, } from "../lib/lanes/effort.js";
@@ -1579,6 +1581,40 @@ function sameQuestionCompany(a, b) {
     const bSlug = b.slug.trim();
     return aSlug !== "" && aSlug === bSlug;
 }
+function effectiveLaneQuestionCompany(lane, hqRoot) {
+    return lane.company ?? lane.mesh_company ?? (hqRoot ? resolveProjectQuestionCompany(hqRoot, lane) : null);
+}
+function questionCompanyForLane(question, lane, hqRoot) {
+    return question.company ?? effectiveLaneQuestionCompany(lane, hqRoot);
+}
+async function resolveActiveQuestionCompany(ctx, message = "Cannot access lane questions because the active HQ company could not be resolved") {
+    try {
+        return await ctx.resolveCompany();
+    }
+    catch (err) {
+        if (!(err instanceof CompanySelectionError))
+            throw err;
+        throw new LanesError("question_company_unavailable", message, {});
+    }
+}
+function assertQuestionCompanyMatchesLane(question, lane, code, hqRoot) {
+    const laneCompany = effectiveLaneQuestionCompany(lane, hqRoot);
+    if (question.company != null && laneCompany !== null && !sameQuestionCompany(question.company, laneCompany)) {
+        throw new LanesError(code, `Question ${question.question_id} does not match lane ${lane.lane_id}'s company`, { question_id: question.question_id, lane_id: lane.lane_id });
+    }
+}
+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 questionCompanyRefMatches(recordCompany, filter) {
     return recordCompany !== null &&
         recordCompany !== undefined &&
@@ -3543,9 +3579,11 @@ async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
         });
     }
     const ownerAnswer = ownerQuestion.answer;
+    const ownerLaneCompany = effectiveLaneQuestionCompany(lane, ctx.hqRoot());
     if (!isQuestionAnswer(ownerAnswer) ||
         ownerQuestion.lane_id !== lane.lane_id ||
-        !sameQuestionCompany(ownerQuestion.company, lane.company)) {
+        (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,
@@ -3557,14 +3595,31 @@ async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
         if (current.lane_id !== lane.lane_id) {
             throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} belongs to a different lane than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
         }
-        if (!sameQuestionCompany(current.company, lane.company)) {
+        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, status: "answered", answer: ownerAnswer };
+            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)) {
-            return current;
+            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 });
     });
@@ -3576,7 +3631,9 @@ async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
         if (!isLanesError(err) || err.error !== "question_not_found")
             throw err;
         const primaryLane = readLane(ctx.hqRoot(), lane.lane_id);
-        if (!sameQuestionCompany(primaryLane.company, lane.company)) {
+        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 {
@@ -7035,6 +7092,7 @@ async function runAsk(ctx, opts) {
     }
     const lane = readLane(hqRoot, laneId);
     assertLaneRunsHereForOperatorMutation(ctx, lane, "ask");
+    const questionCompany = await resolveQuestionCompanyWithFallback(hqRoot, lane, () => resolveActiveQuestionCompany(ctx, "Cannot raise a lane question because the active HQ company could not be resolved"));
     const optionList = Array.isArray(opts.option)
         ? opts.option
         : opts.option
@@ -7059,6 +7117,7 @@ async function runAsk(ctx, opts) {
                 body,
                 raisedVia: "cli",
                 at,
+                activeCompany: questionCompany,
                 questionId,
             });
             questionId = withBody.question_id;
@@ -7084,6 +7143,8 @@ async function runAsk(ctx, opts) {
             return;
         }
         catch (err) {
+            if (isLanesError(err) && err.error === "secret_text_refused")
+                throw err;
             lastErr = err;
             process.stderr.write(`hq lanes ask: attempt ${i + 1}/${attempts} failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
             if (i === attempts - 1)
@@ -7113,14 +7174,15 @@ async function runAsk(ctx, opts) {
     });
 }
 const OUTPOST_QUESTION_LOOKUP_CONCURRENCY = 4;
-function groupQuestionLanesByCompany(lanes) {
+function groupQuestionLanesByCompany(hqRoot, lanes, fallbackCompany) {
     const groups = [];
     for (const lane of lanes) {
-        const existing = groups.find((group) => sameQuestionCompany(group.company, lane.company));
+        const company = effectiveLaneQuestionCompany(lane, hqRoot) ?? fallbackCompany ?? null;
+        const existing = groups.find((group) => sameQuestionCompany(group.company, company));
         if (existing)
             existing.lanes.push(lane);
         else
-            groups.push({ company: lane.company, lanes: [lane] });
+            groups.push({ company, lanes: [lane] });
     }
     return groups;
 }
@@ -7264,17 +7326,19 @@ async function readOutpostQuestionDetail(ctx, owner) {
         throw new LanesError("outpost_question_show_invalid", `Outpost ${outpostId} returned an invalid question record`, { outpost_id: outpostId, question_id: owner.question.question_id });
     }
     if (question.question_id !== owner.question.question_id ||
-        question.lane_id !== owner.lane.lane_id ||
-        !sameQuestionCompany(question.company, owner.lane.company)) {
+        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" &&
-        (!companyFilter || questionCompanyRefMatches(lane.company, companyFilter)));
+        (!companyFilter ||
+            effectiveLaneQuestionCompany(lane, hqRoot) === null ||
+            questionCompanyRefMatches(effectiveLaneQuestionCompany(lane, hqRoot), companyFilter)));
     const lanesByOutpost = new Map();
     for (const lane of hostedLanes) {
         if (lane.host.kind !== "outpost")
@@ -7287,7 +7351,7 @@ async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
     const errors = [];
     const eligibleGroups = [];
     for (const [outpostId, lanes] of [...lanesByOutpost.entries()].sort(([a], [b]) => a.localeCompare(b))) {
-        for (const group of groupQuestionLanesByCompany(lanes)) {
+        for (const group of groupQuestionLanesByCompany(hqRoot, lanes, companyFilter)) {
             if (group.company === null) {
                 if (await ctx.laneOutpostQuestionVisibilityEnabled(null)) {
                     errors.push({
@@ -7346,9 +7410,7 @@ async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
                 const lane = localLanesById.get(question.lane_id);
                 if (!lane)
                     continue;
-                if (!sameQuestionCompany(question.company, lane.company)) {
-                    throw new LanesError("outpost_question_company_mismatch", `Outpost ${outpostId} question ${question.question_id} does not match its primary lane company`, { outpost_id: outpostId, question_id: question.question_id });
-                }
+                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 });
                 }
@@ -7379,14 +7441,42 @@ async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
         errors: [...new Map(errors.map((entry) => [entry.host, entry])).values()],
     };
 }
+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;
+    }
+}
 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;
-    let company;
-    if (opts.company)
-        company = await ctx.resolveCompany(opts.company);
-    const localLanes = opts.allHosts ? new Map(loadAllLanes(hqRoot).map((lane) => [lane.lane_id, lane])) : 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)
@@ -7397,16 +7487,15 @@ async function runQuestionsList(ctx, opts) {
             return false;
         if (opts.story && q.story_id !== opts.story)
             return false;
-        if (company && !(opts.allHosts
-            ? questionCompanyRefMatches(q.company, company)
-            : companyRefMatches(q.company, company))) {
-            return false;
-        }
-        if (company && localLanes) {
-            const lane = localLanes.get(q.lane_id);
-            if (!lane || !questionCompanyRefMatches(lane.company, company) || !sameQuestionCompany(q.company, lane.company)) {
-                return false;
+        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);
@@ -7418,6 +7507,10 @@ async function runQuestionsList(ctx, opts) {
     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
@@ -7430,7 +7523,7 @@ async function runQuestionsList(ctx, opts) {
             };
             if (!opts.allHosts)
                 return row;
-            const lane = localLanes?.get(q.lane_id);
+            const lane = localLanes.get(q.lane_id);
             const host = lane?.host.kind === "outpost" ? `outpost:${lane.host.id}` : "local";
             return { ...row, host };
         }),
@@ -7444,11 +7537,7 @@ async function runQuestionsList(ctx, opts) {
                 return false;
             if (opts.story && q.story_id !== opts.story)
                 return false;
-            if (company && (!questionCompanyRefMatches(q.company, company) ||
-                !questionCompanyRefMatches(lane.company, company) ||
-                !sameQuestionCompany(q.company, lane.company))) {
-                return false;
-            }
+            assertQuestionCompanyAccess(q, lane, company, hqRoot);
             if (forFilter) {
                 if (!audienceMatches(audience, forFilter))
                     return false;
@@ -7518,7 +7607,13 @@ async function runQuestionsShow(ctx, questionId) {
 }
 async function runQuestionsAnswer(ctx, questionId, opts) {
     const hqRoot = ctx.hqRoot();
-    const company = opts.company ? await ctx.resolveCompany(opts.company) : undefined;
+    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);
@@ -7526,6 +7621,7 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
     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);
         if (lookup.errors.length > 0) {
             throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
@@ -7535,6 +7631,17 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         }
         const matches = lookup.questions.filter((entry) => entry.question.question_id === questionId);
         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) {
@@ -7544,29 +7651,31 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         if (!owner) {
             throw new LanesError("question_not_found", `Question ${questionId} not found on this primary or its Outposts`, { question_id: questionId });
         }
-        if (!sameQuestionCompany(owner.question.company, owner.lane.company)) {
-            throw new LanesError("outpost_question_company_mismatch", `Question ${questionId} does not match its primary lane company`, { question_id: questionId, lane_id: owner.lane.lane_id });
-        }
+        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(owner.lane.company),
+            company: questionListCompanyArg(ownerCompany),
         });
         return;
     }
     await yieldEventLoop();
     const askingLane = readLane(hqRoot, laneIdForAnswerDelivery(question));
-    if (company &&
-        (!questionCompanyRefMatches(question.company, company) ||
-            !questionCompanyRefMatches(askingLane.company, company) ||
-            !sameQuestionCompany(question.company, askingLane.company))) {
-        throw new LanesError("question_company_mismatch", `Question ${questionId} does not belong to the requested company`, { question_id: questionId, lane_id: askingLane.lane_id });
-    }
+    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,
-            ...(askingLane.company ? { company: questionListCompanyArg(askingLane.company) } : {}),
+            company: questionListCompanyArg(questionCompany),
         });
         return;
     }
@@ -7577,7 +7686,7 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
     if (laneAcceptsDropboxDelivery(askingLane)) {
         assertLaneRunsHereForOperatorMutation(ctx, askingLane, "deliver an answer to");
     }
-    const body = requireQuestionBody(hqRoot, question);
+    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;
@@ -7594,10 +7703,15 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         : "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, current, {
+            const stored = writeQuestionBody(hqRoot, currentForBody, {
                 ...body,
                 notes: opts.notes,
             });
@@ -7606,6 +7720,7 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         }
         return {
             ...current,
+            company: recordedCompany,
             body: nextBody,
             status: "answered",
             answer: {
@@ -8303,6 +8418,7 @@ async function runReconcile(ctx, opts) {
         throttleDeps: ctx.throttleDeps,
         livenessDeps: livenessDepsFromCtx(ctx),
         presenceConnected: ctx.presenceConnected,
+        resolveQuestionActiveCompany: () => resolveActiveQuestionCompany(ctx),
         mesh: ctx.mesh,
         env: ctx.env,
     });
@@ -8383,6 +8499,13 @@ export function registerLanesCommand(parent, deps = {}) {
         now: ctx.now,
         actor: ctx.trackerActor,
     }, wrap);
+    registerLaneChecksCommand(lanes, {
+        hqRoot: ctx.hqRoot,
+        resolveCompany: ctx.resolveCompany,
+        trackerEnabled: ctx.laneTrackerEnabled,
+        trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
+        now: ctx.now,
+    }, wrap);
     registerOutpostPrunerCommand(lanes);
     const noStoryOption = new Option("--no-story <reason>", "Create a lane without a story and record why");
     noStoryOption.attributeName = () => "noStory";

package/dist/lib/flag-registry-worker-mode-cache.d.ts

@@ -0,0 +1,13 @@
+export declare const FLAG_REGISTRY_SELF_CONTAINED_WORKER_FLAG = "cli.flag-worker-self-contained";
+interface CachedWorkerMode {
+    version: number;
+    value: boolean;
+}
+/** Keep the last server snapshot decision for this one startup-mode flag. */
+export declare function flagRegistryWorkerModeCachePath(stateDir: string, scopeIdentifiers: readonly string[]): string;
+/** A missing, invalid, or inaccessible cache never enables the rollout. */
+export declare function readCachedFlagRegistryWorkerMode(filePath: string): CachedWorkerMode | null;
+export declare function writeCachedFlagRegistryWorkerMode(filePath: string, snapshot: CachedWorkerMode): void;
+export declare function flagRegistryStateDir(env?: NodeJS.ProcessEnv): string;
+export {};
+//# sourceMappingURL=flag-registry-worker-mode-cache.d.ts.map

package/dist/lib/flag-registry-worker-mode-cache.js

@@ -0,0 +1,146 @@
+import { createHash, randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export const FLAG_REGISTRY_SELF_CONTAINED_WORKER_FLAG = "cli.flag-worker-self-contained";
+/** Keep the last server snapshot decision for this one startup-mode flag. */
+export function flagRegistryWorkerModeCachePath(stateDir, scopeIdentifiers) {
+    const basename = scopeIdentifiers.length === 0
+        ? "worker-mode-default.json"
+        : `worker-mode-${createHash("sha256")
+            .update([...scopeIdentifiers].sort().join("\0"))
+            .digest("hex")
+            .slice(0, 24)}.json`;
+    return path.join(stateDir, "flags", basename);
+}
+/** A missing, invalid, or inaccessible cache never enables the rollout. */
+export function readCachedFlagRegistryWorkerMode(filePath) {
+    let latest = readCacheRecordIfPresent(filePath);
+    const directory = path.dirname(filePath);
+    if (!fs.existsSync(directory))
+        return latest;
+    const basename = path.basename(filePath);
+    const versionedPrefix = `${basename}.v`;
+    for (const entry of fs.readdirSync(directory)) {
+        if (!entry.startsWith(versionedPrefix) || !entry.endsWith(".json"))
+            continue;
+        const versionedPath = path.join(directory, entry);
+        const record = readCacheRecordIfPresent(versionedPath);
+        if (record)
+            latest = newerCacheRecord(latest, record);
+    }
+    return latest;
+}
+export function writeCachedFlagRegistryWorkerMode(filePath, snapshot) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const existing = readCachedFlagRegistryWorkerMode(filePath);
+    if (existing && snapshot.version < existing.version)
+        return;
+    // Each registry version gets its own immutable destination. Concurrent
+    // processes can publish v7 and v8 in either order without an older value
+    // replacing the newer record.
+    const versionedPath = `${filePath}.v${snapshot.version}.json`;
+    const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        fs.writeFileSync(tempPath, `${JSON.stringify(snapshot)}\n`, {
+            encoding: "utf8",
+            mode: 0o600,
+            flag: "wx",
+        });
+        try {
+            fs.linkSync(tempPath, versionedPath);
+        }
+        catch (error) {
+            if (!isAlreadyExistsError(error))
+                throw error;
+            const existingVersion = readCacheRecord(versionedPath);
+            if (existingVersion.value !== snapshot.value) {
+                throw new Error("Conflicting flag-registry worker cache values share a version");
+            }
+        }
+    }
+    finally {
+        if (fs.existsSync(tempPath))
+            fs.unlinkSync(tempPath);
+    }
+    pruneOlderCacheRecords(filePath);
+}
+export function flagRegistryStateDir(env = process.env) {
+    const override = env.HQ_STATE_DIR?.trim();
+    return override ? override : path.join(os.homedir(), ".hq");
+}
+function isCachedWorkerMode(value) {
+    return typeof value === "object" && value !== null &&
+        "version" in value && typeof value.version === "number" &&
+        Number.isSafeInteger(value.version) && value.version >= 0 &&
+        "value" in value && typeof value.value === "boolean";
+}
+function readCacheRecord(filePath) {
+    const value = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (!isCachedWorkerMode(value)) {
+        throw new Error("Cached flag-registry worker mode has an invalid shape");
+    }
+    return value;
+}
+function newerCacheRecord(current, candidate) {
+    if (!current || candidate.version > current.version)
+        return candidate;
+    if (candidate.version === current.version && candidate.value !== current.value) {
+        throw new Error("Conflicting flag-registry worker cache values share a version");
+    }
+    return current;
+}
+function pruneOlderCacheRecords(filePath) {
+    const latest = readCachedFlagRegistryWorkerMode(filePath);
+    if (!latest)
+        return;
+    const directory = path.dirname(filePath);
+    const basename = path.basename(filePath);
+    const versionedPrefix = `${basename}.v`;
+    for (const entry of fs.readdirSync(directory)) {
+        if (!entry.startsWith(versionedPrefix) || !entry.endsWith(".json"))
+            continue;
+        const recordPath = path.join(directory, entry);
+        const record = readCacheRecordIfPresent(recordPath);
+        if (record && record.version < latest.version) {
+            try {
+                fs.unlinkSync(recordPath);
+            }
+            catch (error) {
+                if (!isNotFoundError(error))
+                    throw error;
+            }
+        }
+    }
+    if (fs.existsSync(filePath)) {
+        const legacyRecord = readCacheRecordIfPresent(filePath);
+        if (legacyRecord && legacyRecord.version < latest.version) {
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch (error) {
+                if (!isNotFoundError(error))
+                    throw error;
+            }
+        }
+    }
+}
+function readCacheRecordIfPresent(filePath) {
+    try {
+        return readCacheRecord(filePath);
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return null;
+        throw error;
+    }
+}
+function isAlreadyExistsError(error) {
+    return typeof error === "object" && error !== null &&
+        "code" in error && error.code === "EEXIST";
+}
+function isNotFoundError(error) {
+    return typeof error === "object" && error !== null &&
+        "code" in error && error.code === "ENOENT";
+}
+//# sourceMappingURL=flag-registry-worker-mode-cache.js.map