Backend-only cleanup bundle for GitHub issue #108 (items 1+2 are
architectural/frontend and out of scope). TDD throughout; behaviour is
preserved at every call site — these are cost/observability improvements,
not policy changes.

Item 3 — tool_aliases collision policy (WARN, never reject):
canonicalize_tool_name folds dotted→wire lossily, so two distinct
spellings can collide with no detection. Add detect_alias_collisions()
(canonical → the >=2 distinct source spellings) + warn_alias_collisions()
to corlinman_agent.tool_aliases, and call it where the two security gates
build their allow-sets: the skill allowed-tools gate
(agent_servicer._skill_allowed_tools_block) and the subagent allowlist
escalation gate (subagent/runner._filter_tools_for_child). Each distinct
collision logs ONE structured warning (log key tool_aliases.collision,
deduped per gate for the process lifetime) — a hard reject could silently
break a working dotted allowlist on a security path, so first-registered
still wins and allow/deny outcomes are unchanged.

Item 4 — /admin/subagents overview SSE idle backoff: the live-overview
stream ran store.list_all()+merge per client on a fixed 2s tick forever.
Extract the pure _next_poll_interval(changed, current) helper (base 2.0s,
×1.5 backoff, 10.0s cap) and drive the loop with it: an unchanged tick
backs the interval off toward the cap; any change snaps straight back to
2s so liveness is never traded away. Keepalive now rides wall-clock
elapsed time so idle proxies keep the same ~10s byte rhythm.

Item 5 — public-URL disk-read caching: _resolve_public_base_url runs once
per media-bearing tool result and, with CORLINMAN_PUBLIC_URL unset,
re-read BOTH backing files every call. Add a module-level cache keyed on a
cheap stat() signature (mtime_ns, size) of the py-config drop and the
learned public_origin file: a hit skips the two reads; a mtime/size change
or either file appearing/disappearing invalidates; a transient stat()
error yields a never-equal signature so we re-read. The env short-circuit
is unchanged and never touches the cache.

Tests (all TDD, red→green):
- test_tool_aliases.py: detector finds {a.b, a_b}, dedupes identical
  spellings, no false positive on the shipped tool set; warn logs one
  structured event, deduped; runner gate warns without changing outcome.
- test_fix_LANE_A_servicer.py: skill gate logs the collision warning
  without changing allow/deny.
- test_subagents.py: _next_poll_interval grows to the cap when unchanged,
  resets to base on change.
- test_public_url_cache.py: cache hit avoids re-read (counters), mtime
  bump invalidates, appear/disappear invalidate, env still wins and
  short-circuits before any disk read.

… (Codex #113)

The idle backoff let since_keepalive accumulate a full backed-off
interval before the heartbeat check ran — the first idle keepalive after
a growth sequence (2→3→4.5→6.75) landed at ~16.25s, past the documented
~10s SSE rhythm proxies rely on. The poll sleep is now split into
heartbeat-bounded slices via a pure _sleep_slices helper: keepalives fire
exactly at rhythm crossings mid-sleep while the scan cadence still
honours the full poll interval (idle cost unchanged).

5 new unit tests (no-crossing, boundary cut, multi-crossing, entry-at-
rhythm, cadence-preservation sweep). 23 passed; ruff+mypy clean.

…dex #113 round 2)

Address 2 confirmed Codex #113 round-2 findings on the subagents overview
SSE loop (stream_subagents_overview), replacing the _sleep_slices machinery
with one cohesive three-clock redesign:

(a) 3520699516 — the keepalive clock accumulated only REQUESTED sleep, so
    time in _combined()/serialization/blocked yields went uncounted and the
    first idle keepalive could land past the 10s rhythm under load. The loop
    now measures real elapsed time: last_byte = time.monotonic() is updated
    after every yield (data frames AND keepalives) and a keepalive fires
    whenever now - last_byte >= HEARTBEAT.

(b) 3520699518 — after backing off toward 10s, the first change following an
    idle period was not observed until the whole backed-off sleep elapsed
    (detection regressed ~2s → up to 10s). A new cheap O(1) probe,
    _overview_change_signature(store, registry) = (registry.revision,
    store _persist_path st_mtime_ns), is sampled at the base cadence; a diff
    from the last full scan's signature forces an immediate scan (+ backoff
    reset via _next_poll_interval), so a change surfaces within ~2s again.

LiveSubagentRegistry gains a monotonically increasing `revision` int bumped
on every genuine row create/update/remove (_apply_spawned/_apply_child_event/
_apply_completed/_prune_terminal); the expensive list_all()+merge full scan
now runs only on the backed-off next_full_scan deadline or a detected change.

Tests: revision increments per mutation + is stable on no-op observes;
_overview_change_signature tracks store mtime + registry revision and
tolerates a missing/absent path (None component). _next_poll_interval backoff
tests kept; the 5 _sleep_slices tests deleted with the helper.

The monotonic-clock loop checks the heartbeat only before a full scan, so
a _combined()+merge that outruns the remaining heartbeat budget could
still silence /admin/subagents/events/live past the 10s rhythm and a
strict proxy would drop it. Now, once silence passes halfway to the
deadline, a keepalive is emitted BEFORE the scan (last_byte resets), so
post-scan silence is bounded by the scan duration alone. Decision
extracted as the pure _prescan_keepalive_due helper + 2 unit tests. 23
passed; ruff+mypy clean.