This problem won't strictly be a linear program, but is better suited to Integer Programming.
First question: What sort of sets are working with?
We seem to have a set of jobs that must be completed. Additionally, we have a set of people who can do these jobs. Let's denote these sets $J$ and $P$, respectively. I'll assume those are the only sets you're dealing with, unless you'd like to clarify further.
Next question: What sort of decision variables will I need to formulate the problem?
Well, we probably need to assign people to jobs, in some fashion. Let $j\in J$ and $p\in P$ and let \begin{equation*}x_{ij}=\begin{cases}1& \text{job } j \text{ is completed by person }p\\
0& \text{otherwise}\end{cases}.\end{equation*}
Alternatively, you might want to assign a person to a group, the A and B you spoke of, or a group and a job, etc. You'll have to go back and make more sets, if that's the case.
What sort of parameters do you need? Maybe something that measures your utility of finishing one job before another? Then, you would need a parameter $v$ which encodes a value for each job.
What's your goal? Receive the most utility from completing these jobs? Complete as many as possible? etc. Encode whatever your objective is into a function using whatever sets, variables, and parameters you've defined above.
What constraints do you need? A common constraint in such a resource allocation problem might be that a person can only work on a finite number of jobs throughout the week, say $c$. We might write this constraint as
\begin{equation*}
\sum_{j\in J} x_{jp}\leq c \hspace{10pt}\forall p\in P.
\end{equation*}
The above info is a great general approach to formulating math programming problems.
As for your question regarding forbidding specific tasks from people who are in particular roles, let's suppose we have a set of roles $R$, jobs $J$, and people $P$. Consider $y_{rp}$, a decision variable equal to 1 if person $p$ is assigned to role $r$, and $x_{jp}$ from above. Further, let $J_r\subseteq J$ be a portion of the jobs only a member of role $r$ can perform. Then, we might write the constraint
\begin{equation*}
\sum_{j\in J'} x_{jp}\leq cy_{rp} \hspace{10pt}\forall p\in P.
\end{equation*}
Note that if person $p$ is not assigned to role $r$, he cannot perform any of these tasks, as
\begin{equation*}
\sum_{j\in J_r} x_{jp}\leq 0.
\end{equation*}
However, if he is assigned to role $r$, he may perform as many as $c$ tasks from subset $J_r$.
Does that help get you started? Feel free to ask other questions...
Your problem seems to be a
knapsack problem:
it is NP-hard.
As you noticed, it can be formulated as a linear program with binary constraints;
most linear programming software packages also allow integral constraints,
but those constraints can make them significantly slower.
The bipartite matching problem
can also be formulated as a linear program with binary constraints,
but it turns out that its relaxation, i.e., the same problem with
the binary constraints $x_i \in \{0,1\}$
replaced by $0 \leqslant x_i \leqslant 1$,
has integral solutions: the two problems are actually equivalent.
But this is the exception, rather than the rule:
in general, binary or integral constraints do make the problem harder,
and relaxing them only gives an upper (or lower) bound on the objective.
Best Answer
Here's the bad news: you can't do this with a straight-up linear program.
Here's the good news: you can do this with an integer linear program.
Introduce an additional binary decision variable $z$. Let $z=0$ whenever $x=0$ and $z=1$ whenever $x\ge 4$. Furthermore, pick an arbitrarily large number, call it $M$, such that $M$ can not bound your $x$ variable too soon(e.g. if your problem data is on the order of $10^2$, pick $M=10^5$ or something). Now add the following constraints to your problem:
$$ x \ge 4z \\ x \le Mz $$
If $z=0$, the constraints force $x=0$. If $z=1$ the constraints force $x \ge 4$ (since $M$ is large enough by definition).
In general, the modeling issue is capturing a situation like this: $$x = 0 \lor x\in[a,b], \quad0<a<b<\infty$$ $x$ is called a semicontinuous variable, and the trick that I've shown you above extends naturally to the following pair of constraints: $$ x \ge az \\ x \le bz $$
Unless you are coding the algorithm yourself, be aware that most commercial solver packages can handle semicontinuous variables internally (by doing the constraint modeling internally and branching on $z$). Read the appropriate documentation for the syntax.