Problem

LlmSessionActor has an implicit state machine implemented via Become() calls
with Command<> registrations that don't compose cleanly. The current states
(Ready, Processing, Compacting) work but adding new states is fragile:

• Command<> handlers registered in one Become() scope can conflict with handlers
  in shared methods like CommandSubscriptionMessages()
• Adding a Passivating state (needed for pre-shutdown memory distillation) requires
  either duplicating shared handler registration or using boolean flags — both are
  brittle
• The actor is 3000+ lines and its state transitions are scattered across methods
  rather than being explicitly defined

Motivation

This blocks two features:

• Passivation-triggered memory distillation (feat(memory): session-level memory observer actor (spike) #410): the session observer needs to
  distill before the session stops, requiring a Passivating behavior state
• Graceful session drain (bug: graceful daemon restart on config change — drain active sessions before restart #326): daemon restart needs to drain active sessions,
  which requires explicit lifecycle state management

Proposed approach

1. Define an explicit state enum: Ready, Processing, Compacting, Passivating
2. Extract shared command handlers into composable methods that can be mixed into any state
3. Make state transitions explicit and testable
4. Extract dependencies (memory observation, compaction, tool execution) into
   independently testable components where possible
5. Reduce the actor's line count by extracting concerns into child actors or services

Related

• feat(memory): session-level memory observer actor (spike) #410 — session-level memory observer (spike, known limitation: no passivation distill)
• bug: graceful daemon restart on config change — drain active sessions before restart #326 — graceful daemon restart / drain active sessions
• refactor: extract PipelineHostingActor base class from SlackThreadBindingActor and SignalRSessionActor #306 — extract PipelineHostingActor base class