@indigoai-us/hq-cli 5.234.2 → 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/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. */

package/dist/lib/lanes/reconcile.js

@@ -632,14 +632,6 @@ export async function runPassBody(hqRoot, deps) {
     const livenessDeps = deps.livenessDeps ?? defaultLivenessDeps();
     let lanes;
     let questions;
-    if (!deps.dryRun) {
-        try {
-            await deps.syncTrackerQuestions?.(hqRoot);
-        }
-        catch (err) {
-            markError(summary, err);
-        }
-    }
     try {
         lanes = loadLaneRecords(hqRoot, summary);
         questions = loadQuestionRecords(hqRoot, summary);
@@ -843,14 +835,6 @@ export async function runPassBody(hqRoot, deps) {
         await admitQueued(hqRoot, drainLanes, summary, deps, now);
         await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, deps);
     });
-    if (!deps.dryRun && deps.syncTrackerQuestions) {
-        try {
-            await deps.syncTrackerQuestions(hqRoot);
-        }
-        catch (err) {
-            markError(summary, err);
-        }
-    }
     if (!deps.dryRun && summary.errors.length === 0) {
         try {
             writeHeartbeatFile(hqRoot, summary, nowIso);

package/dist/lib/lanes/store.js

@@ -738,15 +738,7 @@ export function parseQuestionRecord(raw, filePath) {
             value: delivered_at,
         });
     }
-    const mesh_question_id = raw.mesh_question_id;
-    if (mesh_question_id !== undefined && (typeof mesh_question_id !== "string" || !mesh_question_id.trim())) {
-        throw new LaneSchemaError("mesh_question_id must be a non-empty string when present", { path: filePath, value: mesh_question_id });
-    }
-    const mesh_delivered_at = raw.mesh_delivered_at === undefined ? null : raw.mesh_delivered_at;
-    if (mesh_delivered_at !== null && (typeof mesh_delivered_at !== "string" || !Number.isFinite(Date.parse(mesh_delivered_at)))) {
-        throw new LaneSchemaError("mesh_delivered_at must be a valid timestamp or null", { path: filePath, value: mesh_delivered_at });
-    }
-    return { ...raw, delivered_at, mesh_delivered_at };
+    return { ...raw, delivered_at };
 }
 /**
  * HQ Sync sibling-twin grammar from `@indigoai-us/hq-cloud` `buildConflictPath`:

package/dist/lib/lanes/tracker-store.d.ts

@@ -22,17 +22,13 @@ export interface TrackerStore {
     read(kind: TrackerKind, id: string): StoreValue<TrackerRecord | null>;
     list(kind: TrackerKind): StoreValue<TrackerRecord[]>;
     create(record: TrackerRecordInput): StoreValue<TrackerRecord>;
-    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord, metadata?: {
-        approvalQuestionId?: string;
-    }): StoreValue<TrackerRecord>;
+    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord): StoreValue<TrackerRecord>;
 }
 export interface LocalTrackerStore extends TrackerStore {
     read(kind: TrackerKind, id: string): TrackerRecord | null;
     list(kind: TrackerKind): TrackerRecord[];
     create(record: TrackerRecordInput): TrackerRecord;
-    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord, metadata?: {
-        approvalQuestionId?: string;
-    }): TrackerRecord;
+    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord): TrackerRecord;
 }
 export declare function createLocalTrackerStore(projectDirectory: string, now?: () => Date): LocalTrackerStore;
 //# sourceMappingURL=tracker-store.d.ts.map

package/dist/lib/lanes/tracker-store.js

@@ -238,7 +238,7 @@ export function createLocalTrackerStore(projectDirectory, now = () => new Date()
             writeExclusive(path.join(directory, `${id}.json`), `${JSON.stringify(record, null, 2)}\n`);
             return record;
         },
-        update(kind, id, expectedVersion, change, _metadata) {
+        update(kind, id, expectedVersion, change) {
             const file = recordPath(root, kind, id);
             const directory = ensureKindDirectory(root, kind);
             return withRecordLock(file, () => {

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

@@ -662,10 +662,6 @@ export interface QuestionRecord {
     version: number;
     /** Null until the owner starts a resume carrying this answer; absent on old records. */
     delivered_at?: string | null;
-    /** Work Mesh's server-issued id; absent for pre-TRK-9 local questions. */
-    mesh_question_id?: string;
-    /** Local checkpoint that the server accepted this question's delivery stamp. */
-    mesh_delivered_at?: string | null;
     body: QuestionBodyRef;
     routing_history: RoutingHistoryEntry[];
     answer?: QuestionAnswer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.234.2",
+  "version": "5.235.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {

package/dist/lib/lanes/tracker-mesh-questions.d.ts

@@ -1,54 +0,0 @@
-import type { LaneCompanyRef, QuestionRecord } from "./types.js";
-import { type TrackerMeshRequest } from "./tracker-mesh.js";
-export type TrackerMeshQuestionAudience = "owner" | "operator" | "lane";
-export type TrackerMeshQuestionStatus = "pending" | "answered" | "cancelled";
-export interface TrackerMeshQuestionRow {
-    questionId: string;
-    threadId: string;
-    companyUid: string;
-    projectId: string;
-    laneId: string;
-    host: {
-        kind: string;
-        id: string;
-    };
-    audience: TrackerMeshQuestionAudience;
-    audienceChain: string[];
-    routingHistory: Array<Record<string, string>>;
-    question: string;
-    context?: string;
-    options: string[];
-    recommended?: string;
-    askedAt: string;
-    status: TrackerMeshQuestionStatus;
-    choice?: string;
-    notes?: string;
-    answeredBy?: string;
-    answeredAt?: string;
-    deliveredAt?: string;
-}
-export interface TrackerMeshQuestionInput {
-    laneId: string;
-    threadId?: string;
-    projectId: string;
-    audience: TrackerMeshQuestionAudience;
-    audienceChain: string[];
-    routingHistory: Array<Record<string, string>>;
-    question: string;
-    context: string;
-    options: string[];
-    recommended?: string;
-}
-export interface TrackerMeshQuestionClient {
-    create(input: TrackerMeshQuestionInput): Promise<TrackerMeshQuestionRow>;
-    list(statuses?: readonly TrackerMeshQuestionStatus[]): Promise<TrackerMeshQuestionRow[]>;
-    answer(questionId: string, choice: string, notes?: string): Promise<TrackerMeshQuestionRow>;
-    delivered(questionId: string): Promise<TrackerMeshQuestionRow>;
-}
-/** Persist a local delivery checkpoint only after the Work Mesh stamp succeeds. */
-export declare function deliverTrackerMeshQuestionOnce(question: QuestionRecord, company: LaneCompanyRef, client: Pick<TrackerMeshQuestionClient, "delivered">, persist: (deliveredAt: string) => QuestionRecord): Promise<QuestionRecord>;
-export declare function createTrackerMeshQuestionClient(options: {
-    company: LaneCompanyRef;
-    request?: TrackerMeshRequest;
-}): TrackerMeshQuestionClient;
-//# sourceMappingURL=tracker-mesh-questions.d.ts.map