feat(hooks): add before_compaction and after_compaction events

[dgageot]

What this PR does

Adds two new hook events that make session compaction first-class in
the hooks mechanism, plus a refactor that splits the compaction
strategy into its own package so future strategies can land alongside
the default one without bloating pkg/runtime.

New hook events

• before_compaction fires immediately before the runtime
  compacts a session. The Input carries input_tokens,
  output_tokens, context_limit, and a compaction_reason of
  \"threshold\" (proactive 90% trigger), \"overflow\"
  (post-overflow recovery) or \"manual\" (user-invoked
  /compact). Hooks can:

  • Veto the compaction (Decision: \"block\" or exit code 2)
  • Replace the LLM-generated summary by returning a non-empty
    hookSpecificOutput.summary — the runtime applies that string
    verbatim and skips the model call entirely

• after_compaction fires after a successful compaction. Receives
  the produced summary together with the pre-compaction
  input_tokens / output_tokens (what was summarized) so
  observability handlers can naturally express "compacted from X to
  Y". Purely observational; output is ignored.

Compactor extraction (pkg/runtime/compactor)

The LLM-summarization strategy and session-aware extraction helpers
move out of pkg/runtime into a new package, leaving
pkg/runtime/session_compaction.go as a thin orchestrator (~130 LoC,
down from ~200) that does only what's intrinsically runtime-private:
hook dispatch, session mutation, event emission, and persistence.

Pure-logic helpers (SplitIndexForKeep, FirstIndexInBudget) move
to pkg/compaction where they join ShouldCompact and
EstimateMessageTokens. The default LLM strategy
(compactor.RunLLM) becomes a public function that user-supplied
before_compaction hooks can call back into if they want to delegate
to the default with tweaks (different model, different prompt) instead
of copying the LLM-call boilerplate.

To avoid an import cycle (pkg/runtime/compactor doesn't import
pkg/runtime), RunLLM accepts a RunAgent callback that the
runtime supplies — the actual sub-runtime construction with
WithSessionCompaction(false) stays in the runtime.

Behavior preservation

The mission-critical "no hooks configured" path is bit-for-bit
unchanged. Three regression guards pin this:

• TestCompaction (origin/main, end-to-end LLM compaction with a
  fake stream provider) — passes
• TestCompactionOverflowDoesNotLoop — passes
• TestDoCompactNoHooksMatchesPriorBehavior (new) — asserts
  identical event sequence (SessionCompaction(\"started\") → SessionSummary → SessionCompaction(\"completed\")) when no
  compaction hooks are configured

Reviewer pass

A full review was performed before merging. The findings worth
calling out:

• session_start re-emit on compact — initially I added a
  Source=\"compact\" re-emit so hooks like add_environment_info
  could re-inject context. Then upstream
  #2536 ("don't
  persist session_start hook output as a session message") landed
  and made session_start output transient — threaded into every
  model call automatically. The re-emit became redundant and was
  dropped along with its test; session_start now fires exactly
  once per RunStream as before.
• after_compaction token counts — the reviewer pass moved this
  contract to pre-compaction values ("compacted from X to Y")
  before the API had any users. Asserted in
  TestDoCompactAfterHookFires by seeding
  sess.{Input,Output}Tokens=1234,567 and verifying those exact
  numbers reach the hook.

Files changed

Area	Files
Hook contract	pkg/hooks/types.go, pkg/hooks/executor.go, pkg/hooks/config.go
Hook tests	pkg/hooks/hooks_test.go, pkg/hooks/dispatch_test.go
Runtime hook helpers	pkg/runtime/hooks.go
Compaction orchestrator	pkg/runtime/session_compaction.go, pkg/runtime/loop.go, pkg/runtime/runtime.go
New compactor package	pkg/runtime/compactor/{compactor,compactor_test}.go
Pure-logic helpers	pkg/compaction/{compaction,compaction_test}.go
Config + schema	pkg/config/latest/types.go, agent-schema.json
Example	examples/hooks.yaml (with a commented-out custom-summary block)
Runtime tests	pkg/runtime/session_compaction_test.go

Caveats documented in the schema and example

Vetoing on compaction_reason=\"overflow\" means the next LLM call
hits the same overflow. The runtime allows at most one
retry-with-compaction
(maxOverflowCompactions),
so a second denial fails the turn and surfaces an Error event
(not an infinite loop). Hook authors should gate denials by reason.

Verification

• go build ./... — green
• go test ./pkg/... ./cmd/... — all green
• go test -race ./pkg/runtime/... ./pkg/compaction/... ./pkg/hooks/... ./pkg/config/... — green with -race
• golangci-lint run ./... — 0 issues