internal/
├── app/          # Orchestrator (builder, queue, signals, message_processor)
├── agent/        # Multi-agent system (delegation, reflection, tree planning)
├── tools/        # AI tool registry (54 tools, 10 tool sets)
├── ui/           # TUI on Bubble Tea (themes, progress, command palette)
├── client/       # API clients (Gemini, Gemini OAuth, Anthropic, Ollama)
├── config/       # Configuration (YAML, 22+ sections, provider registry)
├── chat/         # Session and history management
├── permission/   # Permission system (RiskLow/Medium/High)
├── plan/         # Task planning and execution
├── context/      # Context management and summarization
├── memory/       # Memory, learning, persistence
├── security/     # Security (sandbox, command/SSH validation)
├── semantic/     # Semantic search with embeddings
├── mcp/          # Model Context Protocol (external servers)
├── router/       # Smart request routing
├── format/       # Formatting utilities (Duration, Bytes)
├── fileutil/     # Atomic file transactions
├── hooks/        # Pre/post-tool hooks
├── auth/         # OAuth authorization (Gemini)
├── update/       # Self-update system with rollback
├── audit/        # Audit logging
├── cache/        # Result caching
├── ratelimit/    # API rate limiting
├── watcher/      # File change monitoring
├── tasks/        # Background tasks (bash shells)
├── commands/     # Slash commands
├── logging/      # Structured logging (slog)
├── git/          # Git integration
├── highlight/    # Syntax highlighting
├── ssh/          # SSH validation
├── robustness/   # Error recovery, circuit breaker
└── undo/         # Undo stack

// internal/tools/registry.go
type Registry struct {
    tools map[string]Tool
}

// internal/app/builder.go — selectToolSets, client creation, wiring

// internal/client/factory.go
func NewClient(ctx, cfg, modelID) (Client, error)

// internal/agent/delegation.go
type DelegationStrategy struct { ... }

dm.mu.Lock()
snapshot, _ := dm.save()   // Serialize under lock
dm.mu.Unlock()
go dm.writeSnapshot(snapshot)  // Async write without lock

// Setters — under Lock()
func (c *Client) SetModel(m string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.model = m
}

// Getters — under RLock()
func (c *Client) GetModel() string {
    c.mu.RLock()
    defer c.mu.RUnlock()
    return c.model
}

// internal/tools/my_tool.go
package tools

type MyTool struct {
    workDir string
}

func (t *MyTool) Name() string {
    return "my_tool"
}

func (t *MyTool) Description() string {
    return "Description of my tool"
}

func (t *MyTool) Declaration() *genai.FunctionDeclaration {
    return &genai.FunctionDeclaration{
        Name:        "my_tool",
        Description: "Description of my tool",
        Parameters: &genai.Schema{
            Type: genai.TypeObject,
            Properties: map[string]*genai.Schema{
                "input": {
                    Type:        genai.TypeString,
                    Description: "Input parameter",
                },
            },
            Required: []string{"input"},
        },
    }
}

func (t *MyTool) Execute(ctx context.Context, args map[string]any) (ToolResult, error) {
    input, _ := args["input"].(string)
    // ... logic ...
    return ToolResult{Output: "result"}, nil
}

func (t *MyTool) Validate(args map[string]any) error {
    if _, ok := args["input"].(string); !ok {
        return fmt.Errorf("input is required")
    }
    return nil
}

// internal/tools/registry.go — add to DefaultRegistry or DefaultLazyRegistry

// internal/tools/registry.go — add to the appropriate toolSetDefinitions

// internal/tools/declarations.go — add FunctionDeclaration

// internal/tools/safety.go — add to the appropriate level

# Compile all packages
go build ./...

# Static analysis
go vet ./...

# Tests with race detection
go test -race -coverprofile=coverage.out ./...

# Dependencies
go mod download && go mod tidy

# Build binary
go build -o gokin ./cmd/gokin

# Build with version
go build -ldflags "-X main.version=1.0.0" -o gokin ./cmd/gokin