internal/
├── domain/           # Pure business logic, no external deps
│   ├── order/       # Aggregate package
│   │   ├── order.go        # Aggregate root
│   │   ├── values.go       # Value objects
│   │   ├── events.go       # Domain events
│   │   ├── repository.go   # Repository interface
│   │   └── errors.go       # Sentinel errors
│   └── shared/      # Shared domain types
├── application/     # Use cases, orchestrates domain
│   └── order/
│       ├── application.go  # Commands/queries
│       └── adapter.go      # Legacy compatibility (if needed)
├── infra/           # External adapters
│   ├── mysqlrepo/   # Repository implementations
│   └── telebot/     # Telegram adapter
cmd/                 # Entry points with dependency wiring

// Constructor with validation - emits creation event
func NewOrder(id ID, userID user.ID, ...) (*Order, error) {
    if id < 0 {
        return nil, ErrInvalidOrderID
    }
    order := &Order{...}
    order.recordEvent(NewOrderCreated(...))
    return order, nil
}

// Reconstitute for DB loading - no validation, no events (DB is trusted)
func Reconstitute(id ID, userID user.ID, ...) *Order {
    return &Order{...}
}

type Order struct {
    // ... fields
    events []DomainEvent  // Uncommitted events
}

func (o *Order) recordEvent(e DomainEvent) { o.events = append(o.events, e) }
func (o *Order) DomainEvents() []DomainEvent { return o.events }
func (o *Order) ClearEvents() { o.events = nil }

func (o *Order) MarkAsShipped() error {
    if o.status == StatusShipped {
        return nil  // Already in desired state - no-op
    }
    o.status = StatusShipped
    o.recordEvent(NewOrderShipped(o.id))  // Only on actual change
    return nil
}

type Tasks []*Task
func (t Tasks) UserIDs() []UserID           // Extract unique IDs
func (t Tasks) FilterByUserIDs(ids []UserID) Tasks  // Domain filtering

type LegacyAdapter struct {
    app *Application
}

var _ ports.OldInterface = (*LegacyAdapter)(nil)  // Compile-time check

func (a *LegacyAdapter) OldMethod(ctx context.Context, params OldParams) error {
    return a.app.NewUseCase(ctx, NewRequest{...})
}

cmd/ → infra/ → application/ → domain/
       ↓
    (external libs)

- What is the goal?
- Who are the stakeholders?
- What are the success criteria?
- What constraints exist (time, tech, compatibility)?
- What assumptions are being made?

# Understand current structure
tree -d -L 3 internal/

# Find related code
rg "type.*interface" --type go

# Check existing patterns
rg "func New" --type go | head -20

### Phase 1: Domain Layer
1. **Create OrderID value object** (File: internal/domain/order/values.go)
   - Action: Add OrderID type with validation
   - Dependencies: None
   - Tests: internal/domain/order/values_test.go

2. **Create Order aggregate** (File: internal/domain/order/order.go)
   - Action: Define Order struct with NewOrder and Reconstitute
   - Dependencies: Step 1
   - Tests: internal/domain/order/order_test.go

# Implementation Plan: [Feature Name]

## Overview
[2-3 sentence summary of what we're building]

## Requirements
- [ ] Functional requirement 1
- [ ] Functional requirement 2
- [ ] Non-functional: performance, security, etc.

## Architecture Changes

### New Files
- `internal/domain/order/order.go` - Order aggregate
- `internal/domain/order/repository.go` - Repository interface

### Modified Files
- `internal/application/order/application.go` - Add CreateOrder use case
- `cmd/api/main.go` - Wire new dependencies

## Implementation Phases

### Phase 1: Domain Layer (Estimated: 2 hours)
| Step | File | Action | Dependencies |
|------|------|--------|--------------|
| 1.1 | values.go | Create OrderID | None |
| 1.2 | order.go | Create Order aggregate | 1.1 |
| 1.3 | repository.go | Define Repository interface | 1.2 |

### Phase 2: Application Layer (Estimated: 1 hour)
...

### Phase 3: Infrastructure Layer (Estimated: 2 hours)
...

### Phase 4: API Layer (Estimated: 1 hour)
...

## Testing Strategy
- Unit tests: All domain and application logic
- Integration tests: Repository implementations
- E2E tests: API endpoints

## Risks & Mitigations
| Risk | Impact | Mitigation |
|------|--------|------------|
| Database migration | High | Run in staging first |
| Breaking API | Medium | Version endpoint |

## Success Criteria
- [ ] All tests passing
- [ ] Coverage > 80% on new code
- [ ] No lint errors
- [ ] Security scan clean
- [ ] Documentation updated

# Find existing patterns
rg "type.*Repository interface" --type go
rg "func New.*Application" --type go

# Check package dependencies
go mod graph | grep "your/module"

# Visualize architecture (if go-cleanarch installed)
go-cleanarch -o arch.png ./...

# List all domain packages
find internal/domain -type d

# Check test coverage
go test -cover ./internal/domain/...