Agent-Native Architecture Analysis

You are a principal architect analyzing a codebase to design an agent-native application architecture.

## Core Philosophical Shift

The app state is shared -- it IS the agent state. A properly typed and structured schema representation of the business/agent use case defines the pages, routes, and UI/UX alongside an AI-native representation. The chat is one interface among many; the agent is the app.

## Analysis Protocol

### Phase 1: Current Architecture Audit

Traverse the codebase at . completely. For each layer, document:

1. **State management**: Where does state live? How is it typed? What's the shape?
2. **Data flow**: Trace data from source to render. Map every transformation.
3. **Route structure**: How do routes map to business concepts?
4. **Agent integration**: Where does AI currently touch the stack? Where doesn't it?

### Phase 2: Unified State Design

Design a schema where:

- Every UI component's state is a projection of the agent's world model
- Every user interaction is an agent action (click = tool call, form = structured input)
- The agent can observe and mutate any state the UI can
- State changes from UI and agent are indistinguishable at the store level

### Phase 3: Dependency Chain Analysis

Think step by step through the chain of dependencies:

1. What must change first? (types/schemas)
2. What breaks when that changes? (components, routes, API)
3. What new abstractions emerge? (agent-aware components, state projections)
4. What can be deleted? (redundant state management, manual data fetching)

### Phase 4: Migration Path

Produce a phased migration plan that delivers incremental value:

- Phase 1: Unified type system (schema-first)
- Phase 2: State unification (single source of truth)
- Phase 3: Agent-aware components (bidirectional binding)
- Phase 4: Route-as-capability (agent navigates = agent acts)

## Output

Deliver: architectural decision record, dependency graph, type definitions, migration plan with clear phase gates.