subagent, bash: run each subagent run and bash task in its own cgroup

hive-subagent-daemon and hive-bash-daemon are now delegated their cgroup
(Delegate=memory pids, DelegateSubgroup=daemon). At start each daemon
enables memory+pids below its unit and creates runs/ (subagent) or
tasks/ (bash). Each subagent run gets runs/<name>-<n>/ and each bash
task tasks/<id>/, both with memory.oom.group=1, and the daemon removes
the directory when the run ends. An OOM kill now takes one whole run
instead of one process out of the daemon's shared cgroup, and never the
daemon itself.

Subagent runs get oom_score_adj +1000; bash tasks and both daemons stay
at 0; the harness stays at -500. The unit-level OOMScoreAdjust=500 on
the subagent daemon goes: it was both the daemon's own score and a floor
no run below it could be lowered past.

Bash tasks enter their cgroup from the existing pre_exec hook, writing
to a cgroup.procs fd opened by the parent. hive-claude builds its
Command itself and exposes neither a pre_exec hook nor the child's pid,
so a subagent's claude (and an ACP agent's process) is started as the
daemon's own binary with the run's cgroup in its environment; main()
enters the cgroup, raises oom_score_adj and execs the real program, the
trampoline swarm-review-classifier already uses. Both enter before the
program executes, so nothing it forks starts outside the run's cgroup.

Without a delegated `daemon` leaf (tests, a dev shell) each daemon logs
one warning and runs everything in its own cgroup, as before.

The shared helper is hive-agent-sock's run_cgroup module, the crate
both daemons already use for what in-container plugins share.

Closes #5007

nix/module-eval/agent-memory.nix

@@ -55,34 +55,45 @@ let
         && lib.elem "multi-user.target" agentDefault.systemd.services.hyperhive-memory-cap-check.wantedBy;
     }
     {
-      # The sign is the whole property, and it is easy to write backwards:
-      # a HIGHER OOMScoreAdjust is a MORE likely victim. So the subagent
-      # daemon must be strictly above zero and the harness strictly below
-      # it — swap the two and the kernel takes the agent's own turn first,
-      # which is worse than setting nothing at all. Both nested `claude`
-      # processes inherit their unit's value, so ordering the units orders
-      # the sessions. Held as an inequality rather than two constants: what
-      # must not drift is the order, not the magnitudes.
-      name = "the OOM killer prefers a subagent over the agent's own session";
+      # A HIGHER OOMScoreAdjust is a MORE likely victim. The subagent daemon
+      # puts each run at +1000 itself and bash tasks stay at 0, so the harness
+      # must sit below 0 for the agent's own session to go last. Neither
+      # daemon unit carries a value: it would make the idle daemon a likelier
+      # victim than a bash task, and a floor no run under it could go below.
+      name = "the OOM killer takes the agent's own session last";
       ok =
-        let
-          sub = (agentSubagentDaemon agentDefault).serviceConfig.OOMScoreAdjust;
-          own = (agentHarness agentDefault).serviceConfig.OOMScoreAdjust;
-        in
-        sub > 0 && own < 0 && sub > own;
+        (agentHarness agentDefault).serviceConfig.OOMScoreAdjust < 0
+        && !((agentSubagentDaemon agentDefault).serviceConfig ? OOMScoreAdjust)
+        && !((agentBashDaemon agentDefault).serviceConfig ? OOMScoreAdjust);
     }
     {
-      # The pair the case above only makes sense with: preferring this unit
-      # as the victim is an improvement only if losing one subagent isn't
-      # losing all of them. systemd's default `stop` would take the daemon
-      # and every sibling session down with whichever process the kernel
-      # chose, which is the blast radius that made the preference a bad
-      # trade in the first place.
+      # Both daemons create a cgroup per run under their own; without the
+      # delegation they cannot, and without the `daemon` leaf (the name
+      # hive-agent-sock's `run_cgroup` looks for) they refuse to, so runs
+      # would share the daemon's cgroup again.
+      name = "the subagent and bash daemons are delegated their cgroup";
+      ok =
+        lib.all
+          (
+            unit:
+            unit.serviceConfig.Delegate or null == "memory pids"
+            && unit.serviceConfig.DelegateSubgroup or null == "daemon"
+          )
+          [
+            (agentSubagentDaemon agentDefault)
+            (agentBashDaemon agentDefault)
+          ];
+    }
+    {
+      # Preferring a subagent run as the victim is an improvement only if
+      # losing one run isn't losing all of them. systemd's default `stop`
+      # would take the daemon and every sibling session down with whichever
+      # process the kernel chose.
       name = "one subagent losing the OOM draw does not stop the daemon";
       ok = (agentSubagentDaemon agentDefault).serviceConfig.OOMPolicy == "continue";
     }
     {
-      # Each bash task is a process in the daemon's cgroup; under `stop` one
+      # Every bash task runs under the daemon's unit; under `stop` one
       # OOM-killed task would end every running sibling task.
       name = "one bash task losing the OOM draw does not stop the daemon";
       ok = (agentBashDaemon agentDefault).serviceConfig.OOMPolicy or null == "continue";