@indigoai-us/hq-cli 5.234.1 → 5.235.0

package/dist/commands/lanes.js

@@ -17,13 +17,11 @@ import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
 import { registerLaneTrackerImportCommand } from "./lanes-import.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
-import { createTrackerMeshQuestionClient, deliverTrackerMeshQuestionOnce } from "../lib/lanes/tracker-mesh-questions.js";
-import { createWorkMeshTrackerStore } from "../lib/lanes/tracker-mesh.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { resolveProcessFlagGate } from "../lib/flag-registry.js";
-import { defaultTrackerActor, LANES_TRACKER_FLAG, LANES_TRACKER_MESH_FLAG, registerLaneTrackerCommands, } from "./lanes-tracker.js";
+import { defaultTrackerActor, LANES_TRACKER_FLAG, registerLaneTrackerCommands, } from "./lanes-tracker.js";
 import { createOutpostHireGrantContext, parseOutpostHireGrantContext, sameHireGrantSenior, } from "../lib/lanes/hire-grant-dispatch.js";
 import { createOutpostProfileRepinContext, parseOutpostProfileRepinContext, } from "../lib/lanes/outpost-profile-repin.js";
 import { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity, resolveAdmissionHost, } from "../lib/lanes/admission-host.js";
@@ -46,7 +44,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, LEAD_LANE_KEEP_ALIVE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
-import { questionBodyAbsPath, questionRecordRefusalCode, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
+import { questionBodyAbsPath, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
 import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { assertUniqueAccountHomes, providerCompactAfterMs } from "../lib/lanes/config.js";
@@ -81,9 +79,6 @@ function defaultLanePlacementEnabled() {
 function defaultLaneTrackerEnabled(company) {
     return readLanesRegistryFlag(LANES_TRACKER_FLAG, { company });
 }
-function defaultLaneTrackerMeshEnabled(company) {
-    return readLanesRegistryFlag(LANES_TRACKER_MESH_FLAG, { company });
-}
 function defaultLaneOutpostQuestionVisibilityEnabled(company, env) {
     return readLanesRegistryFlag(LANE_OUTPOST_QUESTION_VISIBILITY_FLAG, {
         company,
@@ -319,8 +314,6 @@ function resolveDeps(deps = {}) {
         laneOutpostQuestionVisibilityEnabled: deps.laneOutpostQuestionVisibilityEnabled ??
             ((company) => defaultLaneOutpostQuestionVisibilityEnabled(company, env)),
         laneTrackerEnabled: deps.laneTrackerEnabled ?? defaultLaneTrackerEnabled,
-        laneTrackerMeshEnabled: deps.laneTrackerMeshEnabled ?? defaultLaneTrackerMeshEnabled,
-        trackerMeshRequest: deps.trackerMeshRequest,
         laneHostScopedAccountHomesEnabled: deps.laneHostScopedAccountHomesEnabled ??
             ((company) => defaultLaneHostScopedAccountHomesEnabled(company, env)),
         trackerActor: deps.trackerActor ?? defaultTrackerActor,
@@ -510,167 +503,6 @@ function requireQuestionBody(hqRoot, question) {
     }
     return body;
 }
-function trackerMeshAudience(ref) {
-    if (ref.kind === "user")
-        return "owner";
-    if (ref.kind === "session")
-        return "operator";
-    return `lane:${ref.id ?? ""}`;
-}
-function trackerMeshAudienceKind(value) {
-    if (value === "owner" || value.startsWith("owner:"))
-        return "owner";
-    if (value === "operator" || value.startsWith("operator:"))
-        return "operator";
-    return "lane";
-}
-function trackerMeshQuestionInput(lane, question, body) {
-    if (!lane.project_id.trim())
-        throw new LanesError("tracker_mesh_question_invalid", "Question lane has no project id", { lane_id: lane.lane_id });
-    const route = question.routing_history;
-    const currentAudience = route.at(-1)?.audience ?? lane.senior;
-    return {
-        laneId: lane.lane_id,
-        ...(lane.thread_id ? { threadId: lane.thread_id } : {}),
-        projectId: lane.project_id,
-        audience: trackerMeshAudienceKind(trackerMeshAudience(currentAudience)),
-        audienceChain: route.length ? route.map((entry) => trackerMeshAudience(entry.audience)) : [trackerMeshAudience(currentAudience)],
-        routingHistory: route.map((entry) => ({ audience: trackerMeshAudience(entry.audience), at: entry.at, reason: entry.reason })),
-        question: body.question,
-        context: body.context,
-        options: body.options,
-        ...(body.recommended !== undefined ? { recommended: body.recommended } : {}),
-    };
-}
-function assertMeshQuestionMatchesLocal(row, question, company) {
-    if (row.companyUid !== company.uid || row.laneId !== question.lane_id || row.projectId !== question.project_id) {
-        throw new LanesError("tracker_question_company_mismatch", "Work Mesh question does not match the local lane company and project", {
-            question_id: question.question_id,
-            mesh_question_id: row.questionId,
-            lane_id: question.lane_id,
-        });
-    }
-}
-async function indexTrackerQuestion(ctx, hqRoot, lane, question, body, company, client = createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest })) {
-    if (question.mesh_question_id)
-        return question;
-    if (question.status !== "pending")
-        return question;
-    const input = trackerMeshQuestionInput(lane, question, body);
-    const candidates = (await client.list(["pending", "answered"])).filter((row) => row.laneId === input.laneId && row.projectId === input.projectId && row.threadId === (input.threadId ?? row.threadId) &&
-        row.audience === input.audience && row.question === input.question && row.context === input.context &&
-        JSON.stringify(row.options) === JSON.stringify(input.options) &&
-        row.routingHistory.at(-1)?.at === input.routingHistory.at(-1)?.at);
-    if (candidates.length > 1) {
-        throw new LanesError("tracker_mesh_question_ambiguous", "More than one pending Work Mesh question matches this local question", { question_id: question.question_id, lane_id: lane.lane_id });
-    }
-    const row = candidates[0] ?? await client.create(input);
-    assertMeshQuestionMatchesLocal(row, question, company);
-    return casUpdateQuestion(hqRoot, question.question_id, (current) => {
-        if (current.status !== "pending")
-            return current;
-        if (current.mesh_question_id && current.mesh_question_id !== row.questionId) {
-            throw new LanesError("tracker_mesh_question_conflict", "Local question was already linked to another Work Mesh question", { question_id: current.question_id });
-        }
-        return current.mesh_question_id === row.questionId ? current : { ...current, mesh_question_id: row.questionId };
-    });
-}
-async function syncTrackerMeshQuestions(ctx, hqRoot) {
-    if (!ctx.laneTrackerMeshEnabled)
-        return;
-    const lanes = new Map(loadAllLanes(hqRoot).map((lane) => [lane.lane_id, lane]));
-    const byCompany = new Map();
-    for (const lane of lanes.values()) {
-        let company;
-        try {
-            company = await resolveQuestionCompanyWithFallback(hqRoot, lane, () => resolveActiveQuestionCompany(ctx, "Cannot sync lane questions without an HQ company"));
-        }
-        catch (err) {
-            if (lane.company || lane.mesh_company ||
-                !isLanesError(err) || err.error !== "question_company_unavailable" ||
-                err.details.resolution !== "active_company_required")
-                throw err;
-            continue;
-        }
-        if (!await ctx.laneTrackerMeshEnabled(company))
-            continue;
-        const key = `${company.uid}\0${company.slug}`;
-        if (!byCompany.has(key))
-            byCompany.set(key, { company, client: createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest }) });
-    }
-    const localQuestions = loadAllQuestions(hqRoot);
-    for (const question of localQuestions) {
-        if (question.status !== "pending" || question.mesh_question_id)
-            continue;
-        const lane = lanes.get(question.lane_id);
-        if (!lane)
-            continue;
-        const company = question.company ?? lane.company ?? lane.mesh_company;
-        if (!company)
-            continue;
-        const client = byCompany.get(`${company.uid}\0${company.slug}`)?.client;
-        if (!client)
-            continue;
-        const body = requireQuestionBody(hqRoot, question);
-        await indexTrackerQuestion(ctx, hqRoot, lane, question, body, company, client);
-    }
-    for (const { company, client } of byCompany.values()) {
-        const remote = await client.list(["answered"]);
-        const remoteById = new Map(remote.map((row) => [row.questionId, row]));
-        for (const question of loadAllQuestions(hqRoot)) {
-            if (!question.mesh_question_id || question.company?.uid !== company.uid)
-                continue;
-            const row = remoteById.get(question.mesh_question_id);
-            if (!row)
-                continue;
-            assertMeshQuestionMatchesLocal(row, question, company);
-            const lane = lanes.get(question.lane_id);
-            if (!lane)
-                continue;
-            if (row.status === "answered" && question.status === "pending") {
-                if (typeof row.choice !== "string" || typeof row.answeredAt !== "string" || typeof row.answeredBy !== "string") {
-                    throw new LanesError("tracker_mesh_response_invalid", "Answered Work Mesh question is missing its answer fields", { mesh_question_id: row.questionId });
-                }
-                const currentBody = requireQuestionBody(hqRoot, question);
-                let notesRef;
-                let nextBody = question.body;
-                if (row.notes !== undefined) {
-                    const bodyQuestion = question.company || question.body.store === "personal" ? question : { ...question, company };
-                    const stored = writeQuestionBody(hqRoot, bodyQuestion, { ...currentBody, notes: row.notes });
-                    notesRef = stored.ref;
-                    nextBody = stored;
-                }
-                casUpdateQuestion(hqRoot, question.question_id, (current) => {
-                    if (current.status !== "pending")
-                        return current;
-                    if (current.mesh_question_id !== row.questionId)
-                        throw new LanesError("tracker_mesh_question_conflict", "Local question link changed during answer sync", { question_id: current.question_id });
-                    return {
-                        ...current,
-                        company: current.company ?? company,
-                        body: nextBody,
-                        status: "answered",
-                        answer: {
-                            choice: row.choice,
-                            answer_kind: currentBody.options.includes(row.choice) ? "option" : "freeform",
-                            notes_ref: notesRef,
-                            answered_by: row.answeredBy,
-                            answered_at: row.answeredAt,
-                            answered_level: current.hop,
-                        },
-                    };
-                });
-            }
-        }
-        for (const question of loadAllQuestions(hqRoot)) {
-            if (question.company?.uid !== company.uid || !question.mesh_question_id)
-                continue;
-            await deliverTrackerMeshQuestionOnce(question, company, client, (deliveredAt) => casUpdateQuestion(hqRoot, question.question_id, (current) => current.mesh_delivered_at
-                ? current
-                : { ...current, mesh_delivered_at: deliveredAt }));
-        }
-    }
-}
 function loadAllLanes(hqRoot) {
     return listLaneIds(hqRoot).map((id) => readLane(hqRoot, id));
 }
@@ -7996,7 +7828,7 @@ async function runAsk(ctx, opts) {
     const attempts = ASK_ATTEMPTS;
     for (let i = 0; i < attempts; i += 1) {
         try {
-            let withBody = raiseLaneQuestion({
+            const withBody = raiseLaneQuestion({
                 hqRoot,
                 lane,
                 body,
@@ -8006,9 +7838,6 @@ async function runAsk(ctx, opts) {
                 questionId,
             });
             questionId = withBody.question_id;
-            if (await ctx.laneTrackerMeshEnabled(questionCompany)) {
-                withBody = await indexTrackerQuestion(ctx, hqRoot, lane, withBody, body, questionCompany);
-            }
             await emitLaneMeshEvent(ctx, lane.mesh_company ?? lane.company, lane.thread_id, "lane_question", {
                 lane_id: lane.lane_id,
                 question_id: withBody.question_id,
@@ -8395,28 +8224,18 @@ async function runQuestionsList(ctx, opts) {
     const outpostLoad = opts.allHosts
         ? await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company)
         : { questions: [], errors: [] };
-    const meshRows = await ctx.laneTrackerMeshEnabled(company) && status !== "expired"
-        ? await createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest }).list(status ? [status] : undefined)
-        : [];
     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 localMeshQuestionIds = new Set(localQuestions.map((question) => question.mesh_question_id).filter((id) => Boolean(id)));
     const questions = [
         ...localQuestions
             .filter((q) => !remoteQuestionIds.has(q.question_id))
             .map((q) => {
-            const meshRow = q.mesh_question_id ? meshRows.find((row) => row.questionId === q.mesh_question_id) : undefined;
             const row = {
                 ...q,
                 audience: resolveAudience(hqRoot, q, ctx),
-                ...(meshRow ? {
-                    mesh_question_id: meshRow.questionId,
-                    body_preview: { question: meshRow.question, context: meshRow.context ?? "", options: meshRow.options, ...(meshRow.recommended ? { recommended: meshRow.recommended } : {}) },
-                    host: `${meshRow.host.kind}:${meshRow.host.id}`,
-                } : {}),
                 ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
             };
             if (!opts.allHosts)
@@ -8448,50 +8267,6 @@ async function runQuestionsList(ctx, opts) {
             audience,
             ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
         })),
-        ...meshRows
-            .filter((row) => {
-            if (localMeshQuestionIds.has(row.questionId))
-                return false;
-            if (status && row.status !== status)
-                return false;
-            if (opts.from && row.laneId !== opts.from)
-                return false;
-            if (opts.project && row.projectId !== opts.project)
-                return false;
-            if (opts.story) {
-                const lane = localLanes.get(row.laneId);
-                if (!lane || lane.story_id !== opts.story)
-                    return false;
-            }
-            const audience = row.audience === "owner"
-                ? { kind: "user" }
-                : row.audience === "operator"
-                    ? { kind: "session", id: "mesh" }
-                    : { kind: "lane", id: row.laneId };
-            if (forFilter && !audienceMatches(audience, forFilter))
-                return false;
-            return true;
-        })
-            .map((row) => ({
-            question_id: row.questionId,
-            mesh_question_id: row.questionId,
-            lane_id: row.laneId,
-            company,
-            project_id: row.projectId,
-            story_id: localLanes.get(row.laneId)?.story_id ?? "",
-            ...(row.threadId ? { thread_id: row.threadId } : {}),
-            asked_at: row.askedAt,
-            origin: { kind: "lane", id: row.laneId },
-            hop: row.routingHistory.length || 1,
-            status: row.status,
-            audience: row.audience,
-            host: `${row.host.kind}:${row.host.id}`,
-            question: row.question,
-            context: row.context ?? "",
-            options: row.options,
-            ...(row.recommended ? { recommended: row.recommended } : {}),
-            ...(row.choice !== undefined ? { answer: { choice: row.choice, answered_by: row.answeredBy, answered_at: row.answeredAt, notes: row.notes } } : {}),
-        })),
     ];
     printJson({
         ok: true,
@@ -8509,43 +8284,6 @@ async function runQuestionsShow(ctx, questionId) {
     catch (err) {
         if (!isLanesError(err) || err.error !== "question_not_found")
             throw err;
-        let meshCompany = null;
-        try {
-            meshCompany = await resolveActiveQuestionCompany(ctx, "Cannot look up Work Mesh question without an active company");
-        }
-        catch (companyError) {
-            if (questionRecordRefusalCode(companyError) !== "question_company_unavailable")
-                throw companyError;
-            // The Outpost lookup below remains available to unscoped primary hosts.
-        }
-        if (meshCompany && await ctx.laneTrackerMeshEnabled(meshCompany)) {
-            const rows = await createTrackerMeshQuestionClient({ company: meshCompany, request: ctx.trackerMeshRequest }).list();
-            const matches = rows.filter((row) => row.questionId === questionId);
-            if (matches.length > 1)
-                throw new LanesError("tracker_mesh_question_ambiguous", `Work Mesh question ${questionId} is duplicated in the company inbox`, { question_id: questionId });
-            const row = matches[0];
-            if (row) {
-                printJson({
-                    ok: true,
-                    action: "questions.show",
-                    question: {
-                        question_id: row.questionId,
-                        mesh_question_id: row.questionId,
-                        lane_id: row.laneId,
-                        company: meshCompany,
-                        project_id: row.projectId,
-                        thread_id: row.threadId,
-                        asked_at: row.askedAt,
-                        status: row.status,
-                        audience: row.audience,
-                        host: `${row.host.kind}:${row.host.id}`,
-                    },
-                    audience: row.audience,
-                    body: { question: row.question, context: row.context ?? "", options: row.options, ...(row.recommended ? { recommended: row.recommended } : {}), ...(row.notes ? { notes: row.notes } : {}) },
-                });
-                return;
-            }
-        }
         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}`, {
@@ -8601,42 +8339,6 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         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>");
-        if (await ctx.laneTrackerMeshEnabled(company)) {
-            const client = createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest });
-            const matches = (await client.list(["pending", "answered"])).filter((row) => row.questionId === questionId);
-            if (matches.length > 1)
-                throw new LanesError("tracker_mesh_question_ambiguous", `Work Mesh question ${questionId} is duplicated in the company inbox`, { question_id: questionId });
-            const row = matches[0];
-            if (row) {
-                if (row.status !== "pending")
-                    throw new LanesError("question_not_pending", `Question ${questionId} is ${row.status}`, { question_id: questionId, status: row.status });
-                const freeform = opts.freeform?.trim() || undefined;
-                if (freeform !== undefined && row.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, row.options, false);
-                const answer = await client.answer(questionId, choice, opts.notes);
-                printJson({
-                    ok: true,
-                    action: "questions.answer",
-                    lane_id: answer.laneId,
-                    question: {
-                        question_id: answer.questionId,
-                        mesh_question_id: answer.questionId,
-                        lane_id: answer.laneId,
-                        project_id: answer.projectId,
-                        status: answer.status,
-                        choice: answer.choice,
-                        answered_by: answer.answeredBy,
-                        answered_at: answer.answeredAt,
-                        delivered_at: answer.deliveredAt ?? null,
-                    },
-                    delivery: "awaiting_host_poll",
-                });
-                return;
-            }
-        }
         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}`, {
@@ -8712,22 +8414,6 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         throw new LanesError("missing_choice", "--choice or --freeform is required", {});
     }
     const choice = freeform ?? resolveAnswerChoice(opts.choice, body.options, false);
-    let remoteAnswer;
-    let meshQuestionId = question.mesh_question_id;
-    if (await ctx.laneTrackerMeshEnabled(questionCompany)) {
-        const client = createTrackerMeshQuestionClient({ company: questionCompany, request: ctx.trackerMeshRequest });
-        if (!meshQuestionId) {
-            const indexed = await indexTrackerQuestion(ctx, hqRoot, askingLane, question, body, questionCompany, client);
-            meshQuestionId = indexed.mesh_question_id;
-        }
-        if (!meshQuestionId)
-            throw new LanesError("tracker_mesh_question_link_missing", "Work Mesh question could not be linked before answering", { question_id: question.question_id });
-        remoteAnswer = await client.answer(meshQuestionId, choice, opts.notes);
-        assertMeshQuestionMatchesLocal(remoteAnswer, question, questionCompany);
-        if (remoteAnswer.status !== "answered" || remoteAnswer.choice !== choice) {
-            throw new LanesError("tracker_mesh_response_invalid", "Work Mesh did not record the requested question answer", { mesh_question_id: meshQuestionId });
-        }
-    }
     const at = ctx.now().toISOString();
     const answeredBy = sessionIdFromEnv(ctx.env)
         ? `session:${sessionIdFromEnv(ctx.env)}`
@@ -8762,7 +8448,6 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
                 answered_at: at,
                 answered_level: current.hop,
             },
-            ...(meshQuestionId ? { mesh_question_id: meshQuestionId } : {}),
         };
     });
     const latestAskingLane = readLane(hqRoot, askingLane.lane_id);
@@ -8797,8 +8482,6 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         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 });
         }
-        if (remoteAnswer)
-            await syncTrackerMeshQuestions(ctx, hqRoot);
         printJson({
             ok: true,
             action: "questions.answer",
@@ -9430,7 +9113,6 @@ async function runReconcile(ctx, opts) {
         livenessDeps: livenessDepsFromCtx(ctx),
         presenceConnected: ctx.presenceConnected,
         resolveQuestionActiveCompany: () => resolveActiveQuestionCompany(ctx),
-        syncTrackerQuestions: (root) => syncTrackerMeshQuestions(ctx, root),
         recoverQueuedMessages: async (lane) => {
             await recoverQueuedMessages(ctx, lane.lane_id);
         },
@@ -9510,8 +9192,6 @@ export function registerLanesCommand(parent, deps = {}) {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
-        trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
-        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
         actor: ctx.trackerActor,
     }, wrap);
@@ -9519,24 +9199,18 @@ export function registerLanesCommand(parent, deps = {}) {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
-        trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
-        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
     }, wrap);
     registerLaneChecksCommand(lanes, {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
-        trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
-        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
     }, wrap);
     registerLaneReportCommands(lanes, {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
-        trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
-        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
         readQuestionBody: (root, question) => {
             const body = requireQuestionBody(root, question);

package/dist/lib/flag-registry.js

@@ -12,9 +12,8 @@ import { readMachineCompanyBinding } from "./work-context/company.js";
 import { readSessionState } from "./work-context/state.js";
 import { workContextRoot } from "./work-context/paths.js";
 import { readCompaniesManifestMap } from "./work-context/repo-remote.js";
-import { loadCachedTokens, resolveDefaultHqRoot } from "../utils/cognito-session.js";
+import { resolveDefaultHqRoot } from "../utils/cognito-session.js";
 import { resolveFlagRegistryEndpoint, } from "./flag-registry-endpoint.js";
-import { FLAG_REGISTRY_SELF_CONTAINED_WORKER_FLAG, flagRegistryWorkerModeCacheFailureContext, flagRegistryStateDir, flagRegistryWorkerModeCachePath, readCachedFlagRegistryWorkerMode, writeCachedFlagRegistryWorkerMode, } from "./flag-registry-worker-mode-cache.js";
 import { FLAG_REGISTRY_WORKER_SOURCE } from "./flag-registry-worker-source.generated.js";
 export { FLAG_REGISTRY_ENDPOINT_ENV } from "./flag-registry-endpoint.js";
 const COMPANY_UID_RE = /^cmp_[A-Za-z0-9]{3,128}$/;
@@ -101,86 +100,6 @@ function processSnapshotReader(companyIdentifiers) {
         },
     };
 }
-function personSubjectForWorkerMode(idToken) {
-    if (typeof idToken !== "string")
-        return null;
-    const payload = idToken.split(".")[1];
-    if (!payload)
-        return null;
-    try {
-        const subject = JSON.parse(Buffer.from(payload, "base64url").toString("utf8")).sub;
-        return typeof subject === "string" && subject.trim() ? subject : null;
-    }
-    catch {
-        Sentry.captureMessage("Could not scope cached flag-registry worker mode because the cached ID token payload is invalid", { level: "warning", tags: { component: "flag-registry-worker-mode-cache" } });
-        return null;
-    }
-}
-/** Scope a persisted rollout value to the same identity that fetched it. */
-function workerModeCacheScopes(company) {
-    const tokens = loadCachedTokens();
-    const personSubject = tokens ? personSubjectForWorkerMode(tokens.idToken) : null;
-    if (tokens && !personSubject)
-        return null;
-    return [
-        ...(company.companyUid ? [`company:${company.companyUid}`] : []),
-        ...(company.companySlug ? [`company-slug:${company.companySlug}`] : []),
-        ...(personSubject ? [`person:${personSubject}`] : []),
-    ];
-}
-function selfContainedWorkerEnabled(company) {
-    const localOverride = readLocalOverride(FLAG_REGISTRY_SELF_CONTAINED_WORKER_FLAG, process.env);
-    if (localOverride !== null)
-        return localOverride;
-    const scopes = workerModeCacheScopes(company);
-    if (!scopes)
-        return false;
-    const filePath = flagRegistryWorkerModeCachePath(flagRegistryStateDir(), scopes);
-    try {
-        return readCachedFlagRegistryWorkerMode(filePath)?.value ?? false;
-    }
-    catch (error) {
-        const failure = flagRegistryWorkerModeCacheFailureContext(error, "read", filePath);
-        Sentry.captureException(failure.exception, {
-            tags: {
-                component: "flag-registry-worker-mode-cache",
-                worker: "flag-registry",
-                ...failure.tags,
-            },
-        });
-        return false;
-    }
-}
-function cacheWorkerModeFromSnapshot(snapshot, company) {
-    // A developer's local hq-flags override is process-local and must not become
-    // the value selected by a future process.
-    if (readLocalOverride(FLAG_REGISTRY_SELF_CONTAINED_WORKER_FLAG, process.env) !== null)
-        return;
-    const scopes = workerModeCacheScopes(company);
-    if (!scopes)
-        return;
-    const decision = resolveFlag({
-        flagKey: FLAG_REGISTRY_SELF_CONTAINED_WORKER_FLAG,
-        env: {},
-        snapshot,
-        companyIdentifiers: [company.companyUid, company.companySlug].filter((value) => Boolean(value)),
-        lookup: { fallback: false },
-    });
-    try {
-        writeCachedFlagRegistryWorkerMode(flagRegistryWorkerModeCachePath(flagRegistryStateDir(), scopes), { version: snapshot.version, value: decision.value });
-    }
-    catch (error) {
-        const filePath = flagRegistryWorkerModeCachePath(flagRegistryStateDir(), scopes);
-        const failure = flagRegistryWorkerModeCacheFailureContext(error, "write", filePath);
-        Sentry.captureException(failure.exception, {
-            tags: {
-                component: "flag-registry-worker-mode-cache",
-                worker: "flag-registry",
-                ...failure.tags,
-            },
-        });
-    }
-}
 /**
  * Begin one registry refresh without awaiting it or retaining the CLI process.
  *
@@ -199,42 +118,38 @@ export function kickFlagRegistryReadiness(dependencies = {}) {
     const companyIdentifiers = [companyUid, company.companySlug].filter((value) => Boolean(value));
     processReader = processSnapshotReader(companyIdentifiers);
     try {
-        let workerSource = new URL("./flag-registry-worker.js", import.meta.url);
-        let workerOptions = { workerData: {
+        const embeddedSource = dependencies.workerSource ?? FLAG_REGISTRY_WORKER_SOURCE;
+        if (embeddedSource.length === 0) {
+            (dependencies.captureWorkerFailure ?? ((error, tags) => {
+                Sentry.captureException(error, { tags });
+            }))(new Error("Self-contained flag-registry worker source is unavailable"), {
+                component: "flag-registry-worker-startup",
+                worker: "flag-registry",
+                flag_worker_failure: "embedded_source_unavailable",
+            });
+            return processReader;
+        }
+        // This source is embedded at build time, so it remains available while an
+        // updater replaces the installed package tree.
+        const workerOptions = {
+            workerData: {
                 endpoint,
                 ...(companyUid ? { companyUid } : {}),
                 ...(company.companySlug ? { companyIdentifiers: [company.companySlug] } : {}),
-            } };
-        if (selfContainedWorkerEnabled(company)) {
-            // The worker source is generated and embedded in this parent module at
-            // build time. It is already resident before company, identity, and cache
-            // reads can yield to an updater replacing this package tree.
-            const embeddedSource = dependencies.workerSource ?? FLAG_REGISTRY_WORKER_SOURCE;
-            if (embeddedSource.length === 0) {
-                (dependencies.captureWorkerFailure ?? ((error, tags) => {
-                    Sentry.captureException(error, { tags });
-                }))(new Error("Self-contained flag-registry worker source is unavailable"), {
-                    component: "flag-registry-worker-startup",
-                    worker: "flag-registry",
-                    flag_worker_failure: "embedded_source_unavailable",
-                });
-                return processReader;
-            }
-            workerSource = embeddedSource;
-            workerOptions = { ...workerOptions, eval: true };
-        }
+            },
+            eval: true,
+        };
         // The SDK's child-process integration captures every Worker error unless
         // its process-wide captureWorkerErrors option is disabled. Scope only this
         // worker so the reporting boundary can classify its startup errors without
         // changing capture for unrelated workers.
         const worker = Sentry.withScope((scope) => {
             scope.setTag("worker", "flag-registry");
-            return (dependencies.createWorker ?? ((filename, options) => new Worker(filename, options)))(workerSource, workerOptions);
+            return (dependencies.createWorker ?? ((filename, options) => new Worker(filename, options)))(embeddedSource, workerOptions);
         });
         worker.on("message", (value) => {
             if (isFlagSnapshot(value)) {
                 heldSnapshot = value;
-                cacheWorkerModeFromSnapshot(value, company);
             }
         });
         // A failed background refresh must stay invisible to an offline CLI.

package/dist/lib/lanes/reconcile.d.ts

@@ -81,8 +81,6 @@ export interface ReconcileDeps {
     readRegistryFlag?: typeof readLanesRegistryFlag;
     /** Active-company fallback for questions raised from an unscoped lane. */
     resolveQuestionActiveCompany?: () => Promise<LaneCompanyRef>;
-    /** Index local questions and poll remote answers before the normal answer-wake pass. */
-    syncTrackerQuestions?: (hqRoot: string) => Promise<void>;
     /** Resume queued messages after this pass wins a local dead-worker CAS. */
     recoverQueuedMessages?: (lane: LaneRecord) => Promise<void>;
     /** Detached mesh seam for dead-watcher recovery. */