feat(core): agent-runtime types — Phase 1 of architecture unification

[claudiusthebot]

What

First step of the architecture unification plan
(docs/talon-architecture-unification-plan.md). Adds the canonical
shapes — AgentEvent, RunPolicy, ModelRef, ToolDescriptor,
and the split capability interfaces — under
src/core/agent-runtime/, plus an adapter that wraps the existing
QueryBackend as a Backend composed object so Phase 3+ work can
begin without churning every concrete backend in this same PR.

No production caller imports any of this yet. Phase 1 contract:
types-first, no behaviour change. The full test suite (2900 cases)
stays green and the only code added under src/ is the new
agent-runtime/ directory.

Why

Talon has accreted five backends under time pressure. Behaviour
drifts per backend — event parsing, usage extraction, MCP setup,
abort handling, and logging are all re-implemented in slightly
different shapes. The plan replaces that with single sources of
truth (events, policies, model identity, tool registry, store
abstraction). This PR is the smallest reviewable opener:

1. Define the new shapes.
2. Provide an adapter from the legacy interface to the new one.
3. Add tests for every type-level helper and adapter translation rule.
4. Touch zero backend implementations.

The second PR will plumb resolveActiveModel() → ModelRef through
/status, /model, chat query, heartbeat, and dream (Phase 2 in
the plan).

What lands

src/core/agent-runtime/
  events.ts           AgentEvent, AgentError, AgentResult, UsageSnapshot
                      + emptyUsage / addUsage / isAgentEventOf /
                        isAgentRunTerminator
  model-ref.ts        BackendId, ModelRef, CacheSupport, ModelSource
                      + BACKEND_IDS literal, isBackendId, sameModelRef,
                        makeBareModelRef
  run-policy.ts       RunKind, RunPolicy + sub-policies (ToolPolicy,
                      DeliveryPolicy, TimeoutPolicy, LoggingPolicy,
                      SessionPolicy, PermissionPolicy)
                      + defaultRunPolicyFor / allowsDelivery /
                        requiresAmbientChat
  tool-descriptor.ts  ToolDescriptor, ToolFilter, applyToolFilter
  capabilities.ts     ChatBackend, BackgroundRunner, ModelCatalog,
                      SessionBackend, ToolRuntime, UsageTelemetry
                      + composed Backend object with explicit
                        capability flags (deriveCapabilities)
  adapter.ts          adaptQueryBackend(legacy, id, label, opts)
                      — synthesises minimal AgentEvent streams around
                        query() and runOneShotAgent()
                      — translates UnifiedModelInfo → ModelRef
                      — proxies session / tools / usage methods
                      — optional logSink receives appendLog so callers
                        can keep the legacy markdown stream alive
                        during migration
  index.ts            Barrel

Design notes (lifted from the plan)

• AgentEvent is structurally typed — switch on event.type;
  no instanceof, no class hierarchy.
• ModelRef.{backend, id} is the identity pair; everything else
  is metadata for UIs and telemetry.
• RunPolicy lifts the loose contextLabel string into a real
  policy object. defaultRunPolicyFor(kind) returns the right shape
  for chat / heartbeat / dream / trigger / test.
• BACKEND_IDS is the single literal source for the BackendId
  union. The config.ts zod enums stay duplicated for now and get
  reconciled in a later phase (noted in model-ref.ts).
• The adapter is deliberately less rich than native Phase 3
  backends will be — no per-token streaming, no tool-call events.
  It can't lie about events it cannot observe; Phase 3 backends emit
  the full event surface natively.

Testing

• 50 new cases across two files:

  • agent-runtime-types.test.ts (32) — pure helpers across events,
    model-ref, run-policy, tool-descriptor, capabilities.
  • agent-runtime-adapter.test.ts (18) — every adapter translation
    rule pinned: chat happy path / empty text / thrown query / abort
    classification; background appendLog → logSink routing and error
    classification; ModelCatalog kinds (exact / ambiguous / missing);
    selectableOnly + query filter; getDefaultModel with and
    without getModelInfo; cacheSupport propagation;
    sessions / tools / usage proxies; capability-flag
    derivation.

• Tests pass (npm test) — 2900 / 2912 (12 pre-existing skips on
  the live-integration tier).

• Type check passes (npm run typecheck)

• No new lint warnings (npm run lint — 18 pre-existing warnings,
  none in new code).

• Prettier clean on the new files.

Out of scope

• No backend rewrites.
• No dispatcher / heartbeat / dream / /status / /model changes.
• The config.ts backend zod enums stay duplicated until Phase 2 or
  later. Note in model-ref.ts flags the link.
• The richer core/errors.ts classifier is not yet wired through the
  adapter — Phase 3 native backends will use it directly. The adapter
  ships a small inline classifier that maps the common cases.

Refs docs/talon-architecture-unification-plan.md