@indigoai-us/hq-cli 5.234.2 → 5.236.0

package/dist/commands/lanes-checks.js

@@ -5,7 +5,6 @@ import { LanesError, isLanesError } from "../lib/lanes/errors.js";
 import { evaluateTrackerChecks } from "../lib/lanes/tracker-checks.js";
 import { laneRecordPath, listLaneIds, listQuestionIds, questionRecordPath, readLane, readQuestion } from "../lib/lanes/store.js";
 import { createLocalTrackerStore } from "../lib/lanes/tracker-store.js";
-import { createWorkMeshTrackerStore } from "../lib/lanes/tracker-mesh.js";
 import { LANES_TRACKER_FLAG } from "./lanes-tracker.js";
 function fail(error, message, details = {}) {
     throw new LanesError(error, message, details);
@@ -435,17 +434,7 @@ function readTeamInputs(root, company, projects, lanes) {
 export function pathForTrackerRecord(projectDirectory, kind, id) {
     return path.join(projectDirectory, "tracker", kind, `${id}.json`);
 }
-function recordInvalid(kind, record, projectDirectory, field, source = "local") {
-    if (source === "Work Mesh") {
-        return fail("tracker_checks_record_invalid", `Work Mesh tracker ${kind} record ${record.id} has invalid ${field}`, {
-            source,
-            record_id: record.id,
-            kind,
-            company: record.company,
-            project_id: record.project_id,
-            field,
-        });
-    }
+function recordInvalid(kind, record, projectDirectory, field) {
     return fail("tracker_checks_record_invalid", `Tracker ${kind} record has invalid ${field}`, {
         kind,
         id: record.id,
@@ -453,18 +442,15 @@ function recordInvalid(kind, record, projectDirectory, field, source = "local")
         path: pathForTrackerRecord(projectDirectory, kind, record.id),
     });
 }
-function requiredRecordDate(kind, record, projectDirectory, field, source = "local") {
+function requiredRecordDate(kind, record, projectDirectory, field) {
     const value = record[field];
     if (typeof value !== "string" || !Number.isFinite(Date.parse(value)))
-        return recordInvalid(kind, record, projectDirectory, field, source);
+        return recordInvalid(kind, record, projectDirectory, field);
     return value;
 }
-function requiredRecordTimestamp(kind, record, projectDirectory, field, value, source) {
-    if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) {
-        if (source === "Work Mesh")
-            return recordInvalid(kind, record, projectDirectory, field, source);
+function requiredRecordTimestamp(kind, record, projectDirectory, field, value) {
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value)))
         return parseTimestamp(value, field, pathForTrackerRecord(projectDirectory, kind, record.id));
-    }
     return value;
 }
 export function listTrackerRecords(projectDirectory, kind) {
@@ -522,17 +508,13 @@ export function listTrackerRecordsTolerant(projectDirectory, kind) {
     records.sort((a, b) => b.updated_at.localeCompare(a.updated_at) || a.id.localeCompare(b.id));
     return { records, errors };
 }
-async function readTrackerCheckRecords(root, company, projects, deps) {
+async function readTrackerCheckRecords(root, company, projects) {
     const blockers = [];
     const kpis = [];
     const directives = [];
-    const useMesh = await deps.trackerMeshEnabled(company);
-    const source = useMesh ? "Work Mesh" : "local";
     for (const project of projects) {
         const absoluteDirectory = path.join(root, "companies", company.slug, "projects", project.projectId);
-        const store = useMesh
-            ? (deps.meshStore ?? ((resolvedCompany, projectId) => createWorkMeshTrackerStore({ company: resolvedCompany, projectId, now: deps.now })))(company, project.projectId)
-            : createLocalTrackerStore(absoluteDirectory);
+        const store = createLocalTrackerStore(absoluteDirectory);
         const records = {
             blocker: await store.list("blocker"),
             kpi: await store.list("kpi"),
@@ -541,40 +523,40 @@ async function readTrackerCheckRecords(root, company, projects, deps) {
         for (const record of records.blocker) {
             if (record.company !== company.slug || record.project_id !== project.projectId)
                 continue;
-            const openedAt = requiredRecordDate("blocker", record, absoluteDirectory, "opened_at", source);
+            const openedAt = requiredRecordDate("blocker", record, absoluteDirectory, "opened_at");
             const resolvedAt = record.resolved_at;
             if (resolvedAt !== null && (typeof resolvedAt !== "string" || !Number.isFinite(Date.parse(resolvedAt))))
-                recordInvalid("blocker", record, absoluteDirectory, "resolved_at", source);
+                recordInvalid("blocker", record, absoluteDirectory, "resolved_at");
             const nextStep = record.next_step;
             if (nextStep !== undefined && nextStep !== null && typeof nextStep !== "string")
-                recordInvalid("blocker", record, absoluteDirectory, "next_step", source);
+                recordInvalid("blocker", record, absoluteDirectory, "next_step");
             blockers.push({ id: record.id, opened_at: openedAt, resolved_at: resolvedAt, next_step: typeof nextStep === "string" ? nextStep : null });
         }
         for (const record of records.kpi) {
             if (record.company !== company.slug || record.project_id !== project.projectId)
                 continue;
-            const createdAt = requiredRecordDate("kpi", record, absoluteDirectory, "created_at", source);
+            const createdAt = requiredRecordDate("kpi", record, absoluteDirectory, "created_at");
             if (!Array.isArray(record.values))
-                recordInvalid("kpi", record, absoluteDirectory, "values", source);
+                recordInvalid("kpi", record, absoluteDirectory, "values");
             const values = record.values.map((value) => {
                 if (!isObject(value))
-                    recordInvalid("kpi", record, absoluteDirectory, "values", source);
-                return { at: requiredRecordTimestamp("kpi", record, absoluteDirectory, "values[].at", value.at, source) };
+                    recordInvalid("kpi", record, absoluteDirectory, "values");
+                return { at: requiredRecordTimestamp("kpi", record, absoluteDirectory, "values[].at", value.at) };
             });
             kpis.push({ id: record.id, created_at: createdAt, values });
         }
         for (const record of records.directive) {
             if (record.company !== company.slug || record.project_id !== project.projectId)
                 continue;
-            const createdAt = requiredRecordDate("directive", record, absoluteDirectory, "created_at", source);
+            const createdAt = requiredRecordDate("directive", record, absoluteDirectory, "created_at");
             if (!Array.isArray(record.teams) || record.teams.some((team) => typeof team !== "string"))
-                recordInvalid("directive", record, absoluteDirectory, "teams", source);
+                recordInvalid("directive", record, absoluteDirectory, "teams");
             if (!Array.isArray(record.acknowledgements))
-                recordInvalid("directive", record, absoluteDirectory, "acknowledgements", source);
+                recordInvalid("directive", record, absoluteDirectory, "acknowledgements");
             const acknowledgements = record.acknowledgements.map((ack) => {
                 if (!isObject(ack) || typeof ack.team !== "string" || typeof ack.lane_id !== "string")
-                    recordInvalid("directive", record, absoluteDirectory, "acknowledgements", source);
-                return { team: ack.team, lane_id: ack.lane_id, at: requiredRecordTimestamp("directive", record, absoluteDirectory, "acknowledgements[].at", ack.at, source) };
+                    recordInvalid("directive", record, absoluteDirectory, "acknowledgements");
+                return { team: ack.team, lane_id: ack.lane_id, at: requiredRecordTimestamp("directive", record, absoluteDirectory, "acknowledgements[].at", ack.at) };
             });
             directives.push({ id: record.id, created_at: createdAt, teams: record.teams, acknowledgements });
         }
@@ -590,12 +572,12 @@ export async function resolveTrackerCompany(deps, requested) {
     }
     return company;
 }
-async function checkReport(root, company, projects, directiveProjects, projectFilter, now, deps) {
+async function checkReport(root, company, projects, directiveProjects, projectFilter, now) {
     const selectedProjects = [...projects.values()];
     const laneRecords = readScopedLanes(root, company, selectedProjects);
     const teams = readTeamInputs(root, company, selectedProjects, laneRecords);
     const questionRecords = readCompanyQuestions(root, company, projectFilter);
-    const trackerRecords = await readTrackerCheckRecords(root, company, selectedProjects, deps);
+    const trackerRecords = await readTrackerCheckRecords(root, company, selectedProjects);
     const directiveTeams = [...directiveProjects.values()].map((project) => ({
         team: project.team,
         ...(project.leadLaneId === undefined ? {} : { lead_lane_id: project.leadLaneId }),
@@ -628,7 +610,7 @@ export function registerLaneChecksCommand(parent, deps, wrap) {
         const directiveProjects = projectFilter === undefined
             ? projects
             : loadProjectMappings(root, company.slug);
-        const report = await checkReport(root, company, projects, directiveProjects, projectFilter, deps.now(), deps);
+        const report = await checkReport(root, company, projects, directiveProjects, projectFilter, deps.now());
         console.log(JSON.stringify(report, null, 2));
         if (report.checks.some((item) => item.result === "failing"))
             process.exitCode = 2;

package/dist/commands/lanes-import.d.ts

@@ -6,10 +6,8 @@ export interface LaneTrackerImportDeps {
     hqRoot: () => string;
     resolveCompany: (company?: string) => Promise<LaneCompanyRef>;
     trackerEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
-    trackerMeshEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     now: () => Date;
     store?: (projectDirectory: string) => TrackerStore;
-    meshStore?: (company: LaneCompanyRef, projectId: string) => TrackerStore;
 }
 export declare function registerLaneTrackerImportCommand(parent: Command, deps: LaneTrackerImportDeps, wrap: WrapHandler): void;
 export {};

package/dist/commands/lanes-import.js

@@ -5,7 +5,6 @@ import { isDeepStrictEqual } from "node:util";
 import { LanesError } from "../lib/lanes/errors.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { createLocalTrackerStore, } from "../lib/lanes/tracker-store.js";
-import { createWorkMeshTrackerStore } from "../lib/lanes/tracker-mesh.js";
 import { LANES_TRACKER_FLAG } from "./lanes-tracker.js";
 const IMPORT_DATE = "2026-09-25";
 const IMPORT_KEY_PREFIX = "trk7";
@@ -1049,7 +1048,7 @@ function statusOkrCandidates(status, statusSource, result) {
 function makeEmptyTeamResult(team) {
     return { team, status: "error", sources: { prd: null, status: null, brief: null, directives: null }, actions: [], skipped: [], errors: [], unlinked_key_results: [] };
 }
-async function prepareTeam(root, company, companyRef, useMesh, row, index, globalMarkdown, globalDirectivePath, deps) {
+async function prepareTeam(root, company, row, index, globalMarkdown, globalDirectivePath, deps) {
     const team = typeof row.team === "string" && row.team.trim() ? row.team.trim() : `unknown-${index}`;
     const result = makeEmptyTeamResult(team);
     let prdPath = "";
@@ -1098,9 +1097,7 @@ async function prepareTeam(root, company, companyRef, useMesh, row, index, globa
             addSkip(result, { kind: "okr", source_path: statusSource, reason: "no_explicit_goal_or_okr_source" });
         }
         candidates.push(...okrCandidates([...statusOkrs, ...briefOkrs], kpis, result, team));
-        const store = useMesh
-            ? (deps.meshStore ?? ((resolvedCompany, projectId) => createWorkMeshTrackerStore({ company: resolvedCompany, projectId, now: deps.now })))(companyRef, resolved.projectId)
-            : deps.store?.(path.dirname(prdPath)) ?? createLocalTrackerStore(path.dirname(prdPath), deps.now);
+        const store = deps.store?.(path.dirname(prdPath)) ?? createLocalTrackerStore(path.dirname(prdPath), deps.now);
         const importCandidates = uniqueCandidates(candidates, result);
         result.status = result.errors.length ? "imported_with_errors" : "imported";
         return { result, company, projectId: resolved.projectId, store, candidates: importCandidates };
@@ -1132,7 +1129,6 @@ export function registerLaneTrackerImportCommand(parent, deps, wrap) {
         if (!await deps.trackerEnabled(company)) {
             fail("tracker_disabled", `hq lanes import requires the ${LANES_TRACKER_FLAG} flag`, { company: company.slug });
         }
-        const trackerMeshEnabled = await deps.trackerMeshEnabled(company);
         const root = deps.hqRoot();
         const registryPath = resolveSourcePath(root, "workspace/lane-briefs/juniors.json", "juniors registry");
         const registry = readJsonObject(registryPath, "juniors registry");
@@ -1152,7 +1148,7 @@ export function registerLaneTrackerImportCommand(parent, deps, wrap) {
         const globalMarkdown = readText(globalPath, "operator-session-directives.md");
         const works = [];
         for (const [index, row] of selectedRows.entries()) {
-            works.push(await prepareTeam(root, company.slug, company, trackerMeshEnabled, row, index, globalMarkdown, globalPath, deps));
+            works.push(await prepareTeam(root, company.slug, row, index, globalMarkdown, globalPath, deps));
         }
         const mode = options.apply ? "apply" : "dry-run";
         const kpiIds = new Map();

package/dist/commands/lanes-report.js

@@ -4,7 +4,6 @@ import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
 import { questionRecordPath } from "../lib/lanes/store.js";
 import { normalizeIsoTimestamp } from "../lib/lanes/timestamp.js";
 import { mapSourceStoryStatus } from "../lib/mesh/story-status.js";
-import { createWorkMeshTrackerStore } from "../lib/lanes/tracker-mesh.js";
 import { buildTrackerOwnerReport, buildTrackerTeamPage, renderTrackerOwnerReportText, renderTrackerTeamPageText, } from "../lib/lanes/tracker-report.js";
 import { FIRST_TRACKER_REPORT_SINCE, readTrackerReportState, writeTrackerReportState, } from "../lib/lanes/tracker-report-state.js";
 import { listTrackerRecordsTolerant, loadCompanyQuestionRecords, loadProjectMappings, pathForTrackerRecord, readProject, resolveTrackerCompany, } from "./lanes-checks.js";
@@ -143,14 +142,8 @@ function currentAudience(question, sourcePath) {
         default: return fail("tracker_report_question_route_invalid", "Question current audience is unsupported", { question_id: question.question_id, path: sourcePath });
     }
 }
-async function trackerRecords(root, company, project, kind, errors, deps) {
+async function trackerRecords(root, company, project, kind, errors) {
     const projectDirectory = path.join(root, "companies", company.slug, "projects", project.projectId);
-    if (await deps.trackerMeshEnabled(company)) {
-        const store = (deps.meshStore ?? ((resolvedCompany, projectId) => createWorkMeshTrackerStore({ company: resolvedCompany, projectId, now: deps.now })))(company, project.projectId);
-        return (await store.list(kind))
-            .filter((record) => record.company === company.slug && record.project_id === project.projectId)
-            .map((record) => ({ ...record, source_path: `work-mesh://${company.uid}/projects/${project.projectId}/tracker/${kind}/${record.id}` }));
-    }
     const loaded = listTrackerRecordsTolerant(projectDirectory, kind);
     for (const issue of loaded.errors) {
         errors.push({ path: issue.path, field: issue.field, message: issue.message, ...(issue.record_id ? { record_id: issue.record_id } : {}) });
@@ -242,10 +235,10 @@ async function teamInput(root, company, project, questions, deps, errors = []) {
         stories,
         pull_requests: pullRequests,
         releases,
-        blockers: await trackerRecords(root, company, project, "blocker", errors, deps),
-        kpis: await trackerRecords(root, company, project, "kpi", errors, deps),
-        okrs: await trackerRecords(root, company, project, "okr", errors, deps),
-        directives: await trackerRecords(root, company, project, "directive", errors, deps),
+        blockers: await trackerRecords(root, company, project, "blocker", errors),
+        kpis: await trackerRecords(root, company, project, "kpi", errors),
+        okrs: await trackerRecords(root, company, project, "okr", errors),
+        directives: await trackerRecords(root, company, project, "directive", errors),
         questions: teamQuestions,
         errors,
     };

package/dist/commands/lanes-tracker.d.ts

@@ -2,17 +2,14 @@ import type { Command } from "commander";
 import { type TrackerStore } from "../lib/lanes/tracker-store.js";
 import type { LaneCompanyRef } from "../lib/lanes/types.js";
 export declare const LANES_TRACKER_FLAG = "lanes.tracker";
-export declare const LANES_TRACKER_MESH_FLAG = "lanes.tracker-mesh";
 export interface LaneTrackerCommandDeps {
     hqRoot: () => string;
     resolveCompany: (company?: string) => Promise<LaneCompanyRef>;
     trackerEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
-    trackerMeshEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     now: () => Date;
     actor: () => string | null;
     /** Test seam; production uses the same local store used by the public commands. */
     store?: (projectDirectory: string) => TrackerStore;
-    meshStore?: (company: LaneCompanyRef, projectId: string) => TrackerStore;
 }
 type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
 export declare function registerLaneTrackerCommands(parent: Command, deps: LaneTrackerCommandDeps, wrap: WrapHandler): void;

package/dist/commands/lanes-tracker.js

@@ -4,12 +4,11 @@ import * as path from "node:path";
 import { loadCachedTokens } from "@indigoai-us/hq-cloud";
 import { LanesError } from "../lib/lanes/errors.js";
 import { resolveProjectStoryLedger } from "../lib/lanes/story-ledger.js";
+import { tryReadQuestion } from "../lib/lanes/store.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { createLocalTrackerStore } from "../lib/lanes/tracker-store.js";
-import { createWorkMeshTrackerStore } from "../lib/lanes/tracker-mesh.js";
 import { peekIdToken } from "../utils/id-token.js";
 export const LANES_TRACKER_FLAG = "lanes.tracker";
-export const LANES_TRACKER_MESH_FLAG = "lanes.tracker-mesh";
 const MAX_POLICY_PATH_BYTES = 4096;
 function fail(error, message, details = {}) {
     throw new LanesError(error, message, details);
@@ -73,7 +72,6 @@ async function target(deps, options) {
     if (!await deps.trackerEnabled(company)) {
         fail("tracker_disabled", "hq lanes tracker commands require the lanes.tracker flag", { company: company.slug });
     }
-    const useMesh = await deps.trackerMeshEnabled(company);
     const project = validSegment(options.project, "project");
     const ledger = resolveProjectStoryLedger(deps.hqRoot(), project, company.slug);
     const projectCompany = readProjectCompany(ledger.path);
@@ -105,10 +103,7 @@ async function target(deps, options) {
     return {
         company,
         project,
-        usesMesh: useMesh,
-        store: useMesh
-            ? (deps.meshStore ?? ((resolvedCompany, resolvedProject) => createWorkMeshTrackerStore({ company: resolvedCompany, projectId: resolvedProject, now: deps.now })))(company, project)
-            : deps.store?.(realDirectory) ?? createLocalTrackerStore(realDirectory, deps.now),
+        store: deps.store?.(realDirectory) ?? createLocalTrackerStore(realDirectory, deps.now),
     };
 }
 function requireActor(deps) {
@@ -117,6 +112,25 @@ function requireActor(deps) {
         fail("tracker_identity_unavailable", "Cannot record approval without a signed-in HQ identity", {});
     return actor;
 }
+function approvalQuestionId(deps, company, project, rawQuestionId) {
+    if (rawQuestionId === undefined)
+        return undefined;
+    const questionId = validSegment(rawQuestionId, "question-id");
+    const question = tryReadQuestion(deps.hqRoot(), questionId);
+    if (!question)
+        fail("tracker_question_not_found", `Answered owner question ${questionId} was not found`, { question_id: questionId });
+    if (question.status !== "answered" || !question.answer) {
+        fail("tracker_question_not_answered", `Owner question ${questionId} is not answered`, { question_id: questionId });
+    }
+    if (question.company?.slug !== company.slug || question.project_id !== project) {
+        fail("tracker_question_scope_mismatch", `Owner question ${questionId} does not belong to this company project`, {
+            question_id: questionId,
+            company: company.slug,
+            project_id: project,
+        });
+    }
+    return questionId;
+}
 function numberValue(raw, field) {
     const value = Number(raw);
     if (!Number.isFinite(value))
@@ -292,17 +306,22 @@ export function registerLaneTrackerCommands(parent, deps, wrap) {
     addProjectOptions(kpi.command("approve").description("Approve a KPI proposal").argument("<kpi-id>", "KPI id"))
         .option("--question <id>", "Answered owner question authorizing this approval")
         .action(wrap(async (id, options) => {
-        const { store, usesMesh } = await target(deps, options);
-        if (usesMesh && !options.question)
-            fail("tracker_approval_question_required", "Work Mesh KPI approval requires --question <answered-owner-question-id>", { id });
+        const { company, project, store } = await target(deps, options);
+        const questionId = approvalQuestionId(deps, company, project, options.question);
         const current = await store.read("kpi", id);
         if (!current)
             fail("tracker_record_not_found", `Tracker KPI record ${id} was not found`, { kind: "kpi", id });
         const record = await store.update("kpi", id, current.version, (value) => {
             if (value.status === "approved")
                 fail("tracker_already_approved", "KPI is already approved", { id });
-            return { ...value, status: "approved", approved_by: requireActor(deps), approved_at: deps.now().toISOString() };
-        }, options.question ? { approvalQuestionId: options.question } : undefined);
+            return {
+                ...value,
+                status: "approved",
+                approved_by: requireActor(deps),
+                approved_at: deps.now().toISOString(),
+                ...(questionId ? { approval_question_id: questionId } : {}),
+            };
+        });
         console.log(JSON.stringify({ ok: true, action: "kpi.approve", record }, null, 2));
     }));
     addProjectOptions(kpi.command("list").description("List KPIs")).action(wrap(async (options) => {
@@ -338,17 +357,22 @@ export function registerLaneTrackerCommands(parent, deps, wrap) {
     addProjectOptions(okr.command("approve").description("Approve an OKR proposal").argument("<okr-id>", "OKR id"))
         .option("--question <id>", "Answered owner question authorizing this approval")
         .action(wrap(async (id, options) => {
-        const { store, usesMesh } = await target(deps, options);
-        if (usesMesh && !options.question)
-            fail("tracker_approval_question_required", "Work Mesh OKR approval requires --question <answered-owner-question-id>", { id });
+        const { company, project, store } = await target(deps, options);
+        const questionId = approvalQuestionId(deps, company, project, options.question);
         const current = await store.read("okr", id);
         if (!current)
             fail("tracker_record_not_found", `Tracker OKR record ${id} was not found`, { kind: "okr", id });
         const record = await store.update("okr", id, current.version, (value) => {
             if (value.status === "approved")
                 fail("tracker_already_approved", "OKR is already approved", { id });
-            return { ...value, status: "approved", approved_by: requireActor(deps), approved_at: deps.now().toISOString() };
-        }, options.question ? { approvalQuestionId: options.question } : undefined);
+            return {
+                ...value,
+                status: "approved",
+                approved_by: requireActor(deps),
+                approved_at: deps.now().toISOString(),
+                ...(questionId ? { approval_question_id: questionId } : {}),
+            };
+        });
         console.log(JSON.stringify({ ok: true, action: "okr.approve", record }, null, 2));
     }));
     addProjectOptions(okr.command("list").description("List OKRs")).action(wrap(async (options) => {

package/dist/commands/lanes.d.ts

@@ -6,7 +6,6 @@
  * `watch` and the monitor reminder are the line-oriented text surfaces.
  */
 import { Command } from "commander";
-import { type TrackerMeshRequest } from "../lib/lanes/tracker-mesh.js";
 import type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
 export type { OutpostIdentity } from "../lib/lanes/admission-host.js";
@@ -96,10 +95,6 @@ export interface LanesCommandDeps {
     laneOutpostQuestionVisibilityEnabled?: (company?: LaneCompanyRef | null) => boolean | Promise<boolean>;
     /** Test seam for the hq-flags gated tracker commands. */
     laneTrackerEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
-    /** The local-only PR 2 implementation refuses if mesh storage is enabled. */
-    laneTrackerMeshEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
-    /** Fake transport seam used by the disposable-root Work Mesh contract check. */
-    trackerMeshRequest?: TrackerMeshRequest;
     /** Test seam for the default-off host-scoped account-home writer gate. */
     laneHostScopedAccountHomesEnabled?: (company?: LaneCompanyRef | null) => boolean | Promise<boolean>;
     /** Test seam for recording approvals against the active identity. */