agents: read the memory cap at boot, not from the build

An agent's memory cap was rendered into its flake (`memoryMaxBytes` →
`services.hyperhive.agent.claudeMemoryMaxBytes`), so the closure depended
on it and a changed cap reached the JSC heap ceiling and the subagent
`MemoryHigh=` only after a rebuild.

hive-c0re now writes the effective `MemoryMax=` in bytes to the agent's
runtime dir (`/run/hive/memory-max-bytes` inside) in `write_dropins`,
from the same value the drop-in gets. The file is removed for
`infinity` or a RAM percentage, and left alone when the drop-in is kept.

Inside the container, `nix/agent-modules/memory-cap.nix` reads it at
boot: an environment generator sets `BUN_JSC_forceRAMSize` (75%) for
every unit and `machinectl shell`, `/etc/set-environment` exports it in
login shells, and a unit generator writes `MemoryHigh=` (2/3) as a
drop-in for `hive-subagent-daemon`.

The render drops `memoryMaxBytes`, the agent option is removed (both
spellings fail eval with a removal message), and
`effective_memory_bytes_from` goes with its only caller.

Part of #5081 (slice S0-2).

nix/agent-modules/claude-settings.nix

@@ -19,11 +19,6 @@ let
   # meta.rs `otel_config`). Options declared in `otel.nix`, which also
   # exports the generic OTLP environment this container's producers read.
   otelCfg = config.services.hyperhive.agent.otel;
-  # Effective per-agent MemoryMax=, in bytes, injected by meta.rs's
-  # per-agent flake render (`services.hyperhive.agent.claudeMemoryMaxBytes`). `null`
-  # when the effective cap is unbounded ("infinity") or a RAM
-  # percentage — see `resource_limits::effective_memory_bytes`.
-  memoryMaxBytes = config.services.hyperhive.agent.claudeMemoryMaxBytes;
   # Base claude-code environment applied to every agent regardless of OTEL.
   # Shipped via the managed settings `env` block so claude and `hivectl
   # choom` both inherit them without a launch wrapper.
@@ -47,19 +42,6 @@ let
     CLAUDE_CODE_RESUME_INTERRUPTED_TURN = "1";
     # Use the simpler system prompt variant suited to headless operation.
     CLAUDE_CODE_SIMPLE_SYSTEM_PROMPT = "1";
-  }
-  # Bun/JavaScriptCore (the runtime under claude-code's `.claude-wrapped`
-  # binary) sizes its default heap ceiling off the container's visible
-  # `/proc/meminfo`, which under nspawn is the *host's* physical RAM, not
-  # the systemd `MemoryMax=` cgroup cap actually enforced on this
-  # container — the cap lives on the host's outer cgroup and is invisible
-  # from inside (confirmed: `/sys/fs/cgroup/memory.max` reads `max` at
-  # every level from in here). That mismatch lets JSC's heap grow well
-  # past the real wall before GC kicks in hard, causing choom sessions to
-  # hang. Pin JSC's ceiling to 75% of the *actual* effective cap instead,
-  # once it's known at build time.
-  // lib.optionalAttrs (memoryMaxBytes != null) {
-    BUN_JSC_forceRAMSize = toString (memoryMaxBytes * 75 / 100);
   };
   # Claude Code's own telemetry switches — what it emits, and whether it
   # emits at all. Everything an OTEL SDK reads generically (endpoint,
@@ -99,31 +81,6 @@ in
     '';
   };
 
-  # Build-time implementation surface for the JSC-heap-ceiling fix:
-  # meta.rs's per-agent flake render injects this from the effective
-  # `MemoryMax=` (per-agent `resource-limits.json` override, else the
-  # hive-wide `services.hyperhive.agentMemoryMax`) — see
-  # `resource_limits::effective_memory_bytes_from`. Not meant to be set
-  # directly in an agent.nix, same convention as `services.hyperhive.agent.otel.*`
-  # above; the host option (or `hivectl agent <name> set-limits`) is
-  # the real operator knob, and this only reflects the value baked in at
-  # the agent's *last rebuild* — `set-limits` still applies the
-  # cgroup cap live via a drop-in reload, but this derived heap ceiling
-  # needs a rebuild to pick up a new value.
-  options.services.hyperhive.agent.claudeMemoryMaxBytes = lib.mkOption {
-    type = lib.types.nullOr lib.types.ints.positive;
-    default = null;
-    internal = true;
-    description = ''
-      Effective per-agent memory cap in bytes, when it's a plain
-      byte-size value (null for an unbounded or percentage-based cap).
-      This is the whole container's cap, not claude's share of it —
-      the name records its first consumer, `BUN_JSC_forceRAMSize` in
-      `baseClaudeEnv`. `mcp.nix` reads it too, to size the subagent
-      daemon's `MemoryHigh=` against the container it runs in.
-    '';
-  };
-
   options.services.hyperhive.agent.claudeMarketplaces = lib.mkOption {
     type = lib.types.listOf lib.types.str;
     default = [
@@ -257,9 +214,7 @@ in
     environment.etc."claude-code/managed-settings.json".source =
       let
         baseSettings = "${config.services.hyperhive.agent.packages.assets}/share/hyperhive/prompts/claude-settings.json";
-        # Merge base env (always) with OTEL env (when enabled). jq is always
-        # run — `baseClaudeEnv` can carry per-agent values (e.g.
-        # BUN_JSC_forceRAMSize) that can't live in the static store asset.
+        # Merge base env (always) with OTEL env (when enabled).
         allEnv =
           baseClaudeEnv
           // lib.optionalAttrs otelCfg.enable otelSettingsEnv