@indigoai-us/hq-cli 5.219.0 → 5.220.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [5.220.0] — 2026-09-26
+
+### Fixed
+
+- Lane questions now resolve their company from the lane's project before using
+  the active HQ company. Project ownership is used only when unique; otherwise
+  active-company selection applies without choosing a project owner. Legacy
+  questions can be answered with `--company <slug>` when lane or project
+  ownership cannot be resolved.
+
+- CLI updates no longer interrupt background flag refreshes when the
+  self-contained worker rollout is enabled.
+
 ## [5.219.0] — 2026-09-26
 
 ### Added

package/dist/commands/lanes.js

@@ -42,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, resolveQuestionCompany, } 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";
@@ -1581,39 +1581,39 @@ function sameQuestionCompany(a, b) {
     const bSlug = b.slug.trim();
     return aSlug !== "" && aSlug === bSlug;
 }
-function effectiveLaneQuestionCompany(lane) {
-    return lane.company ?? lane.mesh_company ?? null;
+function effectiveLaneQuestionCompany(lane, hqRoot) {
+    return lane.company ?? lane.mesh_company ?? (hqRoot ? resolveProjectQuestionCompany(hqRoot, lane) : null);
 }
-function questionCompanyForLane(question, lane) {
-    return question.company ?? effectiveLaneQuestionCompany(lane);
+function questionCompanyForLane(question, lane, hqRoot) {
+    return question.company ?? effectiveLaneQuestionCompany(lane, hqRoot);
 }
-async function resolveActiveQuestionCompany(ctx) {
+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", "Cannot access lane questions because the active HQ company could not be resolved", {});
+        throw new LanesError("question_company_unavailable", message, {});
     }
 }
-function assertQuestionCompanyMatchesLane(question, lane, code) {
-    const laneCompany = effectiveLaneQuestionCompany(lane);
+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) {
-    assertQuestionCompanyMatchesLane(question, lane, "question_company_mismatch");
-    const questionCompany = questionCompanyForLane(question, lane);
+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) {
-    if (questionCompanyForLane(question, lane) !== null)
+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`, { question_id: question.question_id, lane_id: lane.lane_id });
+    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 &&
@@ -3579,7 +3579,7 @@ async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
         });
     }
     const ownerAnswer = ownerQuestion.answer;
-    const ownerLaneCompany = effectiveLaneQuestionCompany(lane);
+    const ownerLaneCompany = effectiveLaneQuestionCompany(lane, ctx.hqRoot());
     if (!isQuestionAnswer(ownerAnswer) ||
         ownerQuestion.lane_id !== lane.lane_id ||
         (ownerQuestion.company !== null && ownerLaneCompany !== null &&
@@ -3596,8 +3596,8 @@ async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
             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) !== null &&
-            !sameQuestionCompany(current.company, effectiveLaneQuestionCompany(lane))) {
+            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 &&
@@ -3631,8 +3631,8 @@ 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);
-        const primaryCompany = effectiveLaneQuestionCompany(primaryLane);
-        const ownerCompany = effectiveLaneQuestionCompany(lane);
+        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 });
         }
@@ -7092,10 +7092,7 @@ async function runAsk(ctx, opts) {
     }
     const lane = readLane(hqRoot, laneId);
     assertLaneRunsHereForOperatorMutation(ctx, lane, "ask");
-    const activeCompany = lane.company || lane.mesh_company
-        ? undefined
-        : await resolveActiveQuestionCompany(ctx);
-    const questionCompany = resolveQuestionCompany(lane, activeCompany);
+    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
@@ -7177,10 +7174,10 @@ async function runAsk(ctx, opts) {
     });
 }
 const OUTPOST_QUESTION_LOOKUP_CONCURRENCY = 4;
-function groupQuestionLanesByCompany(lanes, fallbackCompany) {
+function groupQuestionLanesByCompany(hqRoot, lanes, fallbackCompany) {
     const groups = [];
     for (const lane of lanes) {
-        const company = effectiveLaneQuestionCompany(lane) ?? fallbackCompany ?? null;
+        const company = effectiveLaneQuestionCompany(lane, hqRoot) ?? fallbackCompany ?? null;
         const existing = groups.find((group) => sameQuestionCompany(group.company, company));
         if (existing)
             existing.lanes.push(lane);
@@ -7329,10 +7326,10 @@ 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, effectiveLaneQuestionCompany(owner.lane))) {
+        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 };
@@ -7340,8 +7337,8 @@ async function readOutpostQuestionDetail(ctx, owner) {
 async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
     const hostedLanes = loadAllLanes(hqRoot).filter((lane) => lane.host.kind === "outpost" &&
         (!companyFilter ||
-            effectiveLaneQuestionCompany(lane) === null ||
-            questionCompanyRefMatches(effectiveLaneQuestionCompany(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")
@@ -7354,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, companyFilter)) {
+        for (const group of groupQuestionLanesByCompany(hqRoot, lanes, companyFilter)) {
             if (group.company === null) {
                 if (await ctx.laneOutpostQuestionVisibilityEnabled(null)) {
                     errors.push({
@@ -7413,9 +7410,7 @@ async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
                 const lane = localLanesById.get(question.lane_id);
                 if (!lane)
                     continue;
-                if (!sameQuestionCompany(question.company, effectiveLaneQuestionCompany(lane))) {
-                    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 });
                 }
@@ -7479,7 +7474,7 @@ async function runQuestionsList(ctx, opts) {
     const forFilter = opts.for ? parseForFilter(opts.for, ctx) : undefined;
     const company = opts.company
         ? await ctx.resolveCompany(opts.company)
-        : await resolveActiveQuestionCompany(ctx);
+        : 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)
@@ -7494,8 +7489,8 @@ async function runQuestionsList(ctx, opts) {
             return false;
         const lane = localLanes.get(q.lane_id);
         if (lane)
-            assertQuestionCompanyMatchesLane(q, lane, "question_company_mismatch");
-        const questionCompany = lane ? questionCompanyForLane(q, lane) : q.company;
+            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 });
@@ -7513,7 +7508,7 @@ async function runQuestionsList(ctx, opts) {
         ? await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company)
         : { questions: [], errors: [] };
     for (const owner of outpostLoad.questions) {
-        assertQuestionCompanyAccess(owner.question, owner.lane, company);
+        assertQuestionCompanyAccess(owner.question, owner.lane, company, hqRoot);
         syncPrimaryQuestionDelivery(hqRoot, owner);
     }
     const remoteQuestionIds = new Set(outpostLoad.questions.map(({ question }) => question.question_id));
@@ -7542,7 +7537,7 @@ async function runQuestionsList(ctx, opts) {
                 return false;
             if (opts.story && q.story_id !== opts.story)
                 return false;
-            assertQuestionCompanyAccess(q, lane, company);
+            assertQuestionCompanyAccess(q, lane, company, hqRoot);
             if (forFilter) {
                 if (!audienceMatches(audience, forFilter))
                     return false;
@@ -7618,9 +7613,7 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         assertNoSecretText("freeform answer", opts.freeform);
     if (opts.notes !== undefined)
         assertNoSecretText("answer notes", opts.notes);
-    const company = opts.company
-        ? await ctx.resolveCompany(opts.company)
-        : await resolveActiveQuestionCompany(ctx);
+    const explicitCompany = opts.company ? await ctx.resolveCompany(opts.company) : undefined;
     let question;
     try {
         question = readQuestion(hqRoot, questionId);
@@ -7628,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}`, {
@@ -7640,7 +7634,7 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
             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);
+                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}`, {
@@ -7657,24 +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 });
         }
-        assertQuestionCompanyAccess(owner.question, owner.lane, company);
-        assertQuestionCompanyResolvedForAnswer(owner.question, owner.lane);
+        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(effectiveLaneQuestionCompany(owner.lane)),
+            company: questionListCompanyArg(ownerCompany),
         });
         return;
     }
     await yieldEventLoop();
     const askingLane = readLane(hqRoot, laneIdForAnswerDelivery(question));
-    assertQuestionCompanyAccess(question, askingLane, company);
-    assertQuestionCompanyResolvedForAnswer(question, askingLane);
+    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(effectiveLaneQuestionCompany(askingLane)),
+            company: questionListCompanyArg(questionCompany),
         });
         return;
     }
@@ -7685,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;
@@ -7702,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,
             });
@@ -7714,6 +7720,7 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         }
         return {
             ...current,
+            company: recordedCompany,
             body: nextBody,
             status: "answered",
             answer: {

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