Fix: correct import path for preferences module

Refactor: standardize 'agent' -> 'agents' for params and prompts
Refactor: Restructure project into core, features, adapters, and config modules
2026-01-16 12:04:09 -05:00 · 2026-01-16 12:01:42 -05:00 · 2026-01-16 11:52:46 -05:00 · 2026-01-16 11:33:11 -05:00 · 2026-01-16 10:45:34 -05:00 · 2026-01-16 09:44:17 -05:00
157 changed files with 33046 additions and 4992 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,12 +7,114 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

+## [0.6.0] - 2026-01-16
+
+### Added
+
+- **Conflict Resolution System** - Git-style diff visualization for code review
+  - New `conflict.lua` module with full conflict management
+  - Git-style markers: `<<<<<<< CURRENT`, `=======`, `>>>>>>> INCOMING`
+  - Visual highlighting: green for original, blue for AI suggestions
+  - Buffer-local keymaps: `co` (ours), `ct` (theirs), `cb` (both), `cn` (none)
+  - Navigation keymaps: `]x` (next), `[x` (previous)
+  - Floating menu with `cm` or `<CR>` on conflict
+  - Number keys `1-4` for quick selection in menu
+  - Auto-show menu after code injection
+  - Auto-show menu for next conflict after resolution
+  - Commands: `:CoderConflictToggle`, `:CoderConflictMenu`, `:CoderConflictNext`, `:CoderConflictPrev`, `:CoderConflictStatus`, `:CoderConflictResolveAll`, `:CoderConflictAcceptCurrent`, `:CoderConflictAcceptIncoming`, `:CoderConflictAcceptBoth`, `:CoderConflictAcceptNone`, `:CoderConflictAutoMenu`
+
+- **Linter Validation System** - Auto-check and fix lint errors after code injection
+  - New `linter.lua` module for LSP diagnostics integration
+  - Auto-saves file after code injection
+  - Waits for LSP diagnostics to update
+  - Detects errors and warnings in injected code region
+  - Auto-queues AI fix prompts for lint errors
+  - Shows errors in quickfix list
+  - Commands: `:CoderLintCheck`, `:CoderLintFix`, `:CoderLintQuickfix`, `:CoderLintToggleAuto`
+
+- **SEARCH/REPLACE Block System** - Reliable code editing with fuzzy matching
+  - New `search_replace.lua` module for reliable code editing
+  - Parses SEARCH/REPLACE blocks from LLM responses
+  - Fuzzy matching with configurable thresholds
+  - Whitespace normalization for better matching
+  - Multiple matching strategies: exact, normalized, line-by-line
+  - Automatic fallback to line-based injection
+
+- **Process and Show Menu Function** - Streamlined conflict handling
+  - New `process_and_show_menu()` function combines processing and menu display
+  - Ensures highlights and keymaps are set up before showing menu
+
+### Changed
+
+- Unified automatic and manual tag processing to use same code path
+- `insert_conflict()` now only inserts markers, callers handle processing
+- Added `nowait = true` to conflict keymaps to prevent delay from built-in `c` command
+- Improved patch application flow with conflict mode integration
+
+### Fixed
+
+- Fixed `string.gsub` returning two values causing `table.insert` errors
+- Fixed keymaps not triggering due to Neovim's `c` command intercepting first character
+- Fixed menu not showing after code injection
+- Fixed diff highlighting not appearing
+
+---
+
+## [0.5.0] - 2026-01-15
+
+### Added
+
+- **Cost Tracking System** - Track LLM API costs across sessions
+  - New `:CoderCost` command opens cost estimation floating window
+  - Session costs tracked in real-time
+  - All-time costs persisted in `.coder/cost_history.json`
+  - Per-model breakdown with token counts
+  - Pricing database for 50+ models (GPT-4/5, Claude, O-series, Gemini)
+  - Window keymaps: `q` close, `r` refresh, `c` clear session, `C` clear all
+
+- **Automatic Ollama Fallback** - Graceful degradation when API limits hit
+  - Automatically switches to Ollama when Copilot rate limits exceeded
+  - Detects local Ollama availability before fallback
+  - Notifies user of provider switch
+
+- **Enhanced Error Handling** - Better error messages for API failures
+  - Shows actual API response on parse errors
+  - Improved rate limit detection and messaging
+  - Sanitized newlines in error notifications
+
+- **Agent Tools System Improvements**
+  - New `to_openai_format()` and `to_claude_format()` functions
+  - `get_definitions()` for generic tool access
+  - Fixed tool call argument serialization
+
+- **Credentials Management System** - Store API keys outside of config files
+  - New `:CoderAddApiKey` command for interactive credential setup
+  - `:CoderRemoveApiKey` to remove stored credentials
+  - `:CoderCredentials` to view credential status
+  - `:CoderSwitchProvider` to switch active LLM provider
+  - Credentials stored in `~/.local/share/nvim/codetyper/configuration.json`
+
+### Changed
+
+- Cost window now shows both session and all-time statistics
+- Improved agent prompt templates with correct tool names
+- Better error context in LLM provider responses
+
+### Fixed
+
+- Fixed "Failed to parse Copilot response" error showing instead of actual error
+- Fixed `nvim_buf_set_lines` crash from newlines in error messages
+- Fixed `tools.definitions` nil error in agent initialization
+- Fixed tool name mismatch in agent prompts
+
+---
+
 ## [0.4.0] - 2026-01-13

 ### Added

 - **Event-Driven Architecture** - Complete rewrite of prompt processing system
-  - Prompts are now treated as events with metadata (buffer state, priority, timestamps)
+  - Prompts are now treated as events with metadata
  - New modules: `queue.lua`, `patch.lua`, `confidence.lua`, `worker.lua`, `scheduler.lua`
  - Priority-based event queue with observer pattern
  - Buffer snapshots for staleness detection
@@ -23,42 +125,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  - Configurable escalation threshold (default: 0.7)

 - **Confidence Scoring** - Response quality heuristics
-  - 5 weighted heuristics: length, uncertainty phrases, syntax completeness, repetition, truncation
+  - 5 weighted heuristics: length, uncertainty, syntax, repetition, truncation
  - Scores range from 0.0-1.0
  - Determines whether to escalate to more capable LLM

 - **Staleness Detection** - Safe patch application
  - Track `vim.b.changedtick` and content hash at prompt time
  - Discard patches if buffer changed during generation
-  - Prevents stale code injection

 - **Completion-Aware Injection** - No fighting with autocomplete
  - Defer code injection while completion popup visible
  - Works with native popup, nvim-cmp, and coq_nvim
-  - Configurable delay after popup closes (default: 100ms)

 - **Tree-sitter Scope Resolution** - Smart context extraction
  - Automatically resolves prompts to enclosing function/method/class
  - Falls back to heuristics when Tree-sitter unavailable
-  - Scope types: function, method, class, block, file

 - **Intent Detection** - Understands what you want
  - Parses prompts to detect: complete, refactor, fix, add, document, test, optimize, explain
-  - Intent determines injection strategy (replace vs insert vs append)
-  - Priority adjustment based on intent type
-
- **Tag Precedence Rules** - Multiple tags handled cleanly
-  - First tag in scope wins (FIFO ordering)
-  - Later tags in same scope skipped with warning
-  - Different scopes process independently
+  - Intent determines injection strategy

 ### Configuration

 New `scheduler` configuration block:
 ```lua
 scheduler = {
-  enabled = true,           -- Enable event-driven mode
-  ollama_scout = true,      -- Use Ollama first
+  enabled = true,
+  ollama_scout = true,
  escalation_threshold = 0.7,
  max_concurrent = 2,
  completion_delay_ms = 100,
@@ -71,50 +164,32 @@ scheduler = {

 ### Added

- **Multiple LLM Providers** - Support for additional providers beyond Claude and Ollama
-  - OpenAI API with custom endpoint support (Azure, OpenRouter, etc.)
+- **Multiple LLM Providers** - Support for additional providers
+  - OpenAI API with custom endpoint support
  - Google Gemini API
-  - GitHub Copilot (uses existing copilot.lua/copilot.vim authentication)
+  - GitHub Copilot

 - **Agent Mode** - Autonomous coding assistant with tool use
-  - `read_file` - Read file contents
-  - `edit_file` - Edit files with find/replace
-  - `write_file` - Create or overwrite files
-  - `bash` - Execute shell commands
+  - `read_file`, `edit_file`, `write_file`, `bash` tools
  - Real-time logging of agent actions
  - `:CoderAgent`, `:CoderAgentToggle`, `:CoderAgentStop` commands

- **Transform Commands** - Transform /@ @/ tags inline without split view
-  - `:CoderTransform` - Transform all tags in file
-  - `:CoderTransformCursor` - Transform tag at cursor
-  - `:CoderTransformVisual` - Transform selected tags
-  - Default keymaps: `<leader>ctt` (cursor/visual), `<leader>ctT` (all)
+- **Transform Commands** - Transform /@ @/ tags inline
+  - `:CoderTransform`, `:CoderTransformCursor`, `:CoderTransformVisual`
+  - Default keymaps: `<leader>ctt`, `<leader>ctT`

 - **Auto-Index Feature** - Automatically create coder companion files
  - Creates `.coder.` companion files when opening source files
-  - Language-aware templates with correct comment syntax
-  - `:CoderIndex` command to manually open companion
-  - `<leader>ci` keymap
-  - Configurable via `auto_index` option (disabled by default)
+  - Language-aware templates

 - **Logs Panel** - Real-time visibility into LLM operations
-  - Token usage tracking (prompt and completion tokens)
-  - "Thinking" process visibility
-  - Request/response logging
-  - `:CoderLogs` command to toggle panel

 - **Mode Switcher** - Switch between Ask and Agent modes
-  - `:CoderType` command shows mode selection UI

 ### Changed

- Window width configuration now uses percentage as whole number (e.g., `25` for 25%)
+- Window width configuration now uses percentage as whole number
 - Improved code extraction from LLM responses
- Better prompt templates for code generation
-
-### Fixed
-
- Window width calculation consistency across modules

 ---

@@ -123,31 +198,23 @@ scheduler = {
 ### Added

 - **Ask Panel** - Chat interface for asking questions about code
-  - Fixed at 1/4 (25%) screen width for consistent layout
-  - File attachment with `@` key (uses Telescope if available)
-  - `Ctrl+n` to start a new chat (clears input and history)
+  - Fixed at 1/4 (25%) screen width
+  - File attachment with `@` key
+  - `Ctrl+n` to start a new chat
  - `Ctrl+Enter` to submit questions
  - `Ctrl+f` to add current file as context
-  - `Ctrl+h/j/k/l` for window navigation
-  - `K/J` to jump between output and input windows
-  - `Y` to copy last response to clipboard
-  - `q` to close panel (closes both windows together)
- Auto-open Ask panel on startup (configurable via `auto_open_ask`)
- File content is now sent to LLM when attaching files with `@`
+  - `Y` to copy last response

 ### Changed

- Ask panel width is now fixed at 25% (1/4 of screen)
- Improved close behavior - closing either Ask window closes both
- Proper focus management after closing Ask panel
- Compact UI elements to fit 1/4 width layout
- Changed "Assistant" label to "AI" in chat messages
+- Ask panel width is now fixed at 25%
+- Improved close behavior
+- Changed "Assistant" label to "AI"

 ### Fixed

 - Ask panel window state sync issues
- Window focus returning to code after closing Ask panel
- NerdTree/nvim-tree causing Ask panel to resize incorrectly
+- Window focus returning to code after closing

 ---

@@ -159,27 +226,13 @@ scheduler = {
 - Core plugin architecture with modular Lua structure
 - Split window view for coder and target files
 - Tag-based prompt system (`/@` to open, `@/` to close)
- Claude API integration for code generation
- Ollama API integration for local LLM support
- Automatic `.gitignore` management for coder files and `.coder/` folder
- Smart prompt type detection (refactor, add, document, explain)
- Code injection system with multiple strategies
- User commands: `Coder`, `CoderOpen`, `CoderClose`, `CoderToggle`, `CoderProcess`, `CoderTree`, `CoderTreeView`
- Health check module (`:checkhealth codetyper`)
- Comprehensive documentation and help files
- Telescope integration for file selection (optional)
- **Project tree logging**: Automatic `.coder/tree.log` maintenance
-  - Updates on file create, save, delete
-  - Debounced updates (1 second) for performance
-  - File type icons for visual clarity
-  - Ignores common build/dependency folders
-
-### Configuration Options
-
- LLM provider selection (Claude/Ollama)
- Window position and width customization
- Custom prompt tag patterns
- Auto gitignore toggle
+- Claude API integration
+- Ollama API integration
+- Automatic `.gitignore` management
+- Smart prompt type detection
+- Code injection system
+- Health check module
+- Project tree logging

 ---

@@ -194,7 +247,9 @@ scheduler = {
 - **Fixed** - Bug fixes
 - **Security** - Vulnerability fixes

-[Unreleased]: https://github.com/cargdev/codetyper.nvim/compare/v0.4.0...HEAD
+[Unreleased]: https://github.com/cargdev/codetyper.nvim/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/cargdev/codetyper.nvim/compare/v0.5.0...v0.6.0
+[0.5.0]: https://github.com/cargdev/codetyper.nvim/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/cargdev/codetyper.nvim/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/cargdev/codetyper.nvim/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/cargdev/codetyper.nvim/compare/v0.1.0...v0.2.0
--- a/README.md
+++ b/README.md
@@ -1,60 +1,86 @@
-# 🚀 Codetyper.nvim
+# Codetyper.nvim

 **AI-powered coding partner for Neovim** - Write code faster with LLM assistance while staying in control of your logic.

 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Neovim](https://img.shields.io/badge/Neovim-0.8%2B-green.svg)](https://neovim.io/)

-## ✨ Features
+## Features

- 📐 **Split View**: Work with your code and prompts side by side
- 💬 **Ask Panel**: Chat interface for questions and explanations
- 🤖 **Agent Mode**: Autonomous coding agent with tool use (read, edit, write, bash)
- 🏷️ **Tag-based Prompts**: Use `/@` and `@/` tags to write natural language prompts
- ⚡ **Transform Commands**: Transform prompts inline without leaving your file
- 🔌 **Multiple LLM Providers**: Claude, OpenAI, Gemini, Copilot, and Ollama (local)
- 📋 **Event-Driven Scheduler**: Queue-based processing with optimistic execution
- 🎯 **Tree-sitter Scope Resolution**: Smart context extraction for functions/methods
- 🧠 **Intent Detection**: Understands complete, refactor, fix, add, document intents
- 📊 **Confidence Scoring**: Automatic escalation from local to remote LLMs
- 🛡️ **Completion-Aware**: Safe injection that doesn't fight with autocomplete
- 📁 **Auto-Index**: Automatically create coder companion files on file open
- 📜 **Logs Panel**: Real-time visibility into LLM requests and token usage
- 🔒 **Git Integration**: Automatically adds `.coder.*` files to `.gitignore`
- 🌳 **Project Tree Logging**: Maintains a `tree.log` tracking your project structure
+- **Split View**: Work with your code and prompts side by side
+- **Ask Panel**: Chat interface for questions and explanations
+- **Agent Mode**: Autonomous coding agent with tool use (read, edit, write, bash)
+- **Tag-based Prompts**: Use `/@` and `@/` tags to write natural language prompts
+- **Transform Commands**: Transform prompts inline without leaving your file
+- **Multiple LLM Providers**: Claude, OpenAI, Gemini, Copilot, and Ollama (local)
+- **SEARCH/REPLACE Blocks**: Reliable code editing with fuzzy matching
+- **Conflict Resolution**: Git-style diff visualization with interactive resolution
+- **Linter Validation**: Auto-check and fix lint errors after code injection
+- **Event-Driven Scheduler**: Queue-based processing with optimistic execution
+- **Tree-sitter Scope Resolution**: Smart context extraction for functions/methods
+- **Intent Detection**: Understands complete, refactor, fix, add, document intents
+- **Confidence Scoring**: Automatic escalation from local to remote LLMs
+- **Completion-Aware**: Safe injection that doesn't fight with autocomplete
+- **Auto-Index**: Automatically create coder companion files on file open
+- **Logs Panel**: Real-time visibility into LLM requests and token usage
+- **Cost Tracking**: Persistent LLM cost estimation with session and all-time stats
+- **Git Integration**: Automatically adds `.coder.*` files to `.gitignore`
+- **Project Tree Logging**: Maintains a `tree.log` tracking your project structure
+- **Brain System**: Knowledge graph that learns from your coding patterns

 ---

-## 📚 Table of Contents
+## Table of Contents

- [Requirements](#-requirements)
- [Installation](#-installation)
- [Quick Start](#-quick-start)
- [Configuration](#-configuration)
- [LLM Providers](#-llm-providers)
- [Commands Reference](#-commands-reference)
- [Usage Guide](#-usage-guide)
- [Agent Mode](#-agent-mode)
- [Keymaps](#-keymaps)
- [Health Check](#-health-check)
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Configuration](#configuration)
+- [LLM Providers](#llm-providers)
+- [Commands Reference](#commands-reference)
+- [Keymaps Reference](#keymaps-reference)
+- [Usage Guide](#usage-guide)
+- [Conflict Resolution](#conflict-resolution)
+- [Linter Validation](#linter-validation)
+- [Logs Panel](#logs-panel)
+- [Cost Tracking](#cost-tracking)
+- [Agent Mode](#agent-mode)
+- [Health Check](#health-check)
+- [Reporting Issues](#reporting-issues)

 ---

-## 📋 Requirements
+## Requirements

 - Neovim >= 0.8.0
 - curl (for API calls)
 - One of: Claude API key, OpenAI API key, Gemini API key, GitHub Copilot, or Ollama running locally

+### Required Plugins
+
+- [plenary.nvim](https://github.com/nvim-lua/plenary.nvim) - Async utilities
+- [nvim-treesitter](https://github.com/nvim-treesitter/nvim-treesitter) - Scope detection for functions/methods
+
+### Optional Plugins
+
+- [nvim-treesitter-textobjects](https://github.com/nvim-treesitter/nvim-treesitter-textobjects) - Better text object support
+- [nui.nvim](https://github.com/MunifTanjim/nui.nvim) - UI components
+
 ---

-## 📦 Installation
+## Installation

 ### Using [lazy.nvim](https://github.com/folke/lazy.nvim)

 ```lua
 {
  "cargdev/codetyper.nvim",
+  dependencies = {
+    "nvim-lua/plenary.nvim",
+    "nvim-treesitter/nvim-treesitter",
+    "nvim-treesitter/nvim-treesitter-textobjects",
+    "MunifTanjim/nui.nvim",
+  },
  cmd = { "Coder", "CoderOpen", "CoderToggle", "CoderAgent" },
  keys = {
    { "<leader>co", "<cmd>Coder open<cr>", desc = "Coder: Open" },
@@ -84,7 +110,7 @@ use {

 ---

-## 🚀 Quick Start
+## Quick Start

 **1. Open a file and start Coder:**
 ```vim
@@ -98,11 +124,17 @@ use {
 using regex, return boolean @/
 ```

-**3. The LLM generates code and injects it into `utils.ts` (right panel)**
+**3. The LLM generates code and shows a diff for you to review**
+
+**4. Use conflict resolution keymaps to accept/reject changes:**
+- `ct` - Accept AI suggestion (theirs)
+- `co` - Keep original code (ours)
+- `cb` - Accept both versions
+- `cn` - Delete both (none)

 ---

-## ⚙️ Configuration
+## Configuration

 ```lua
 require("codetyper").setup({
@@ -110,31 +142,26 @@ require("codetyper").setup({
  llm = {
    provider = "claude", -- "claude", "openai", "gemini", "copilot", or "ollama"

-    -- Claude (Anthropic) settings
    claude = {
      api_key = nil, -- Uses ANTHROPIC_API_KEY env var if nil
      model = "claude-sonnet-4-20250514",
    },

-    -- OpenAI settings
    openai = {
      api_key = nil, -- Uses OPENAI_API_KEY env var if nil
      model = "gpt-4o",
      endpoint = nil, -- Custom endpoint (Azure, OpenRouter, etc.)
    },

-    -- Google Gemini settings
    gemini = {
      api_key = nil, -- Uses GEMINI_API_KEY env var if nil
      model = "gemini-2.0-flash",
    },

-    -- GitHub Copilot settings (uses copilot.lua/copilot.vim auth)
    copilot = {
      model = "gpt-4o",
    },

-    -- Ollama (local) settings
    ollama = {
      host = "http://localhost:11434",
      model = "deepseek-coder:6.7b",
@@ -143,7 +170,7 @@ require("codetyper").setup({

  -- Window Configuration
  window = {
-    width = 25, -- Percentage of screen width (25 = 25%)
+    width = 25, -- Percentage of screen width
    position = "left",
    border = "rounded",
  },
@@ -156,17 +183,18 @@ require("codetyper").setup({
  },

  -- Auto Features
-  auto_gitignore = true, -- Automatically add coder files to .gitignore
-  auto_open_ask = true, -- Auto-open Ask panel on startup
-  auto_index = false, -- Auto-create coder companion files on file open
+  auto_gitignore = true,
+  auto_open_ask = true,
+  auto_index = false,

  -- Event-Driven Scheduler
  scheduler = {
-    enabled = true, -- Enable event-driven prompt processing
-    ollama_scout = true, -- Use Ollama for first attempt (fast local)
-    escalation_threshold = 0.7, -- Below this confidence, escalate to remote
-    max_concurrent = 2, -- Max parallel workers
-    completion_delay_ms = 100, -- Delay injection after completion popup
+    enabled = true,
+    ollama_scout = true,
+    escalation_threshold = 0.7,
+    max_concurrent = 2,
+    completion_delay_ms = 100,
+    apply_delay_ms = 5000,
  },
 })
 ```
@@ -179,12 +207,26 @@ require("codetyper").setup({
 | `OPENAI_API_KEY` | OpenAI API key |
 | `GEMINI_API_KEY` | Google Gemini API key |

+### Credentials Management
+
+Store API keys securely outside of config files:
+
+```vim
+:CoderAddApiKey
+```
+
+Credentials are stored in `~/.local/share/nvim/codetyper/configuration.json`.
+
+**Priority order:**
+1. Stored credentials (via `:CoderAddApiKey`)
+2. Config file settings
+3. Environment variables
+
 ---

-## 🔌 LLM Providers
+## LLM Providers

-### Claude (Anthropic)
-Best for complex reasoning and code generation.
+### Claude
 ```lua
 llm = {
  provider = "claude",
@@ -193,19 +235,17 @@ llm = {
 ```

 ### OpenAI
-Supports custom endpoints for Azure, OpenRouter, etc.
 ```lua
 llm = {
  provider = "openai",
  openai = {
    model = "gpt-4o",
-    endpoint = "https://api.openai.com/v1/chat/completions", -- optional
+    endpoint = "https://api.openai.com/v1/chat/completions",
  },
 }
 ```

 ### Google Gemini
-Fast and capable.
 ```lua
 llm = {
  provider = "gemini",
@@ -214,7 +254,6 @@ llm = {
 ```

 ### GitHub Copilot
-Uses your existing Copilot subscription (requires copilot.lua or copilot.vim).
 ```lua
 llm = {
  provider = "copilot",
@@ -223,7 +262,6 @@ llm = {
 ```

 ### Ollama (Local)
-Run models locally with no API costs.
 ```lua
 llm = {
  provider = "ollama",
@@ -236,123 +274,120 @@ llm = {

 ---

-## 📝 Commands Reference
+## Commands Reference

-### Main Commands
+### Core Commands

-| Command | Description |
-|---------|-------------|
-| `:Coder {subcommand}` | Main command with subcommands |
-| `:CoderOpen` | Open the coder split view |
-| `:CoderClose` | Close the coder split view |
-| `:CoderToggle` | Toggle the coder split view |
-| `:CoderProcess` | Process the last prompt |
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `:Coder open` | `:CoderOpen` | Open the coder split view |
+| `:Coder close` | `:CoderClose` | Close the coder split view |
+| `:Coder toggle` | `:CoderToggle` | Toggle the coder split view |
+| `:Coder process` | `:CoderProcess` | Process the last prompt |
+| `:Coder status` | - | Show plugin status |
+| `:Coder focus` | - | Switch focus between windows |
+| `:Coder reset` | - | Reset processed prompts |

 ### Ask Panel

-| Command | Description |
-|---------|-------------|
-| `:CoderAsk` | Open the Ask panel |
-| `:CoderAskToggle` | Toggle the Ask panel |
-| `:CoderAskClear` | Clear chat history |
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `:Coder ask` | `:CoderAsk` | Open the Ask panel |
+| `:Coder ask-toggle` | `:CoderAskToggle` | Toggle the Ask panel |
+| `:Coder ask-clear` | `:CoderAskClear` | Clear chat history |

 ### Agent Mode

-| Command | Description |
-|---------|-------------|
-| `:CoderAgent` | Open the Agent panel |
-| `:CoderAgentToggle` | Toggle the Agent panel |
-| `:CoderAgentStop` | Stop the running agent |
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `:Coder agent` | `:CoderAgent` | Open the Agent panel |
+| `:Coder agent-toggle` | `:CoderAgentToggle` | Toggle the Agent panel |
+| `:Coder agent-stop` | `:CoderAgentStop` | Stop running agent |
+
+### Agentic Mode
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `:Coder agentic-run <task>` | `:CoderAgenticRun` | Run agentic task |
+| `:Coder agentic-list` | `:CoderAgenticList` | List available agents |
+| `:Coder agentic-init` | `:CoderAgenticInit` | Initialize .coder/agents/ |

 ### Transform Commands

-| Command | Description |
-|---------|-------------|
-| `:CoderTransform` | Transform all /@ @/ tags in file |
-| `:CoderTransformCursor` | Transform tag at cursor position |
-| `:CoderTransformVisual` | Transform selected tags (visual mode) |
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `:Coder transform` | `:CoderTransform` | Transform all tags in file |
+| `:Coder transform-cursor` | `:CoderTransformCursor` | Transform tag at cursor |
+| - | `:CoderTransformVisual` | Transform selected tags |

-### Utility Commands
+### Conflict Resolution
+
+| Command | Description |
+|---------|-------------|
+| `:CoderConflictToggle` | Toggle conflict mode |
+| `:CoderConflictMenu` | Show resolution menu |
+| `:CoderConflictNext` | Go to next conflict |
+| `:CoderConflictPrev` | Go to previous conflict |
+| `:CoderConflictStatus` | Show conflict status |
+| `:CoderConflictResolveAll [keep]` | Resolve all (ours/theirs/both/none) |
+| `:CoderConflictAcceptCurrent` | Accept original code |
+| `:CoderConflictAcceptIncoming` | Accept AI suggestion |
+| `:CoderConflictAcceptBoth` | Accept both versions |
+| `:CoderConflictAcceptNone` | Delete both |
+| `:CoderConflictAutoMenu` | Toggle auto-show menu |
+
+### Linter Validation
+
+| Command | Description |
+|---------|-------------|
+| `:CoderLintCheck` | Check buffer for lint errors |
+| `:CoderLintFix` | Request AI to fix lint errors |
+| `:CoderLintQuickfix` | Show errors in quickfix |
+| `:CoderLintToggleAuto` | Toggle auto lint checking |
+
+### Queue & Scheduler
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `:Coder queue-status` | `:CoderQueueStatus` | Show scheduler status |
+| `:Coder queue-process` | `:CoderQueueProcess` | Trigger queue processing |
+
+### Processing Mode
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `:Coder auto-toggle` | `:CoderAutoToggle` | Toggle auto/manual mode |
+| `:Coder auto-set <mode>` | `:CoderAutoSet` | Set mode (auto/manual) |
+
+### Brain & Memory
+
+| Command | Description |
+|---------|-------------|
+| `:CoderMemories` | Show learned memories |
+| `:CoderForget [pattern]` | Clear memories |
+| `:CoderBrain [action]` | Brain management (stats/commit/flush/prune) |
+| `:CoderFeedback <type>` | Give feedback (good/bad/stats) |
+
+### Cost & Credentials
+
+| Command | Description |
+|---------|-------------|
+| `:CoderCost` | Show cost estimation window |
+| `:CoderAddApiKey` | Add/update API key |
+| `:CoderRemoveApiKey` | Remove credentials |
+| `:CoderCredentials` | Show credentials status |
+| `:CoderSwitchProvider` | Switch LLM provider |
+
+### UI Commands

 | Command | Description |
 |---------|-------------|
-| `:CoderIndex` | Open coder companion for current file |
 | `:CoderLogs` | Toggle logs panel |
-| `:CoderType` | Switch between Ask/Agent modes |
-| `:CoderTree` | Refresh tree.log |
-| `:CoderTreeView` | View tree.log |
+| `:CoderType` | Show Ask/Agent switcher |

 ---

-## 📖 Usage Guide
-
-### Tag-Based Prompts
-
-Write prompts in your coder file using `/@` and `@/` tags:
-
-```typescript
-/@ Create a Button component with the following props:
- variant: 'primary' | 'secondary' | 'danger'
- size: 'sm' | 'md' | 'lg'
- disabled: boolean
-Use Tailwind CSS for styling @/
-```
-
-When you close the tag with `@/`, the prompt is automatically processed.
-
-### Transform Commands
-
-Transform prompts inline without the split view:
-
-```typescript
-// In your source file:
-/@ Add input validation for email and password @/
-
-// Run :CoderTransformCursor to transform the prompt at cursor
-```
-
-### Prompt Types
-
-The plugin auto-detects prompt type:
-
-| Keywords | Type | Behavior |
-|----------|------|----------|
-| `refactor`, `rewrite` | Refactor | Replaces code |
-| `add`, `create`, `implement` | Add | Inserts new code |
-| `document`, `comment` | Document | Adds documentation |
-| `explain`, `what`, `how` | Explain | Shows explanation only |
-
---
-
-## 🤖 Agent Mode
-
-The Agent mode provides an autonomous coding assistant with tool access:
-
-### Available Tools
-
- **read_file**: Read file contents
- **edit_file**: Edit files with find/replace
- **write_file**: Create or overwrite files
- **bash**: Execute shell commands
-
-### Using Agent Mode
-
-1. Open the agent panel: `:CoderAgent` or `<leader>ca`
-2. Describe what you want to accomplish
-3. The agent will use tools to complete the task
-4. Review changes before they're applied
-
-### Agent Keymaps
-
-| Key | Description |
-|-----|-------------|
-| `<CR>` | Submit message |
-| `Ctrl+c` | Stop agent execution |
-| `q` | Close agent panel |
-
---
-
-## ⌨️ Keymaps
+## Keymaps Reference

 ### Default Keymaps (auto-configured)

@@ -362,7 +397,36 @@ The Agent mode provides an autonomous coding assistant with tool access:
 | `<leader>ctt` | Visual | Transform selected tags |
 | `<leader>ctT` | Normal | Transform all tags in file |
 | `<leader>ca` | Normal | Toggle Agent panel |
-| `<leader>ci` | Normal | Open coder companion (index) |
+| `<leader>ci` | Normal | Open coder companion |
+
+### Conflict Resolution Keymaps (buffer-local when conflicts exist)
+
+| Key | Description |
+|-----|-------------|
+| `co` | Accept CURRENT (original) code |
+| `ct` | Accept INCOMING (AI suggestion) |
+| `cb` | Accept BOTH versions |
+| `cn` | Delete conflict (accept NONE) |
+| `cm` | Show conflict resolution menu |
+| `]x` | Go to next conflict |
+| `[x` | Go to previous conflict |
+| `<CR>` | Show menu when on conflict |
+
+### Conflict Menu Keymaps (in floating menu)
+
+| Key | Description |
+|-----|-------------|
+| `1` | Accept current (original) |
+| `2` | Accept incoming (AI) |
+| `3` | Accept both |
+| `4` | Accept none |
+| `co` | Accept current |
+| `ct` | Accept incoming |
+| `cb` | Accept both |
+| `cn` | Accept none |
+| `]x` | Go to next conflict |
+| `[x` | Go to previous conflict |
+| `q` / `<Esc>` | Close menu |

 ### Ask Panel Keymaps

@@ -375,6 +439,29 @@ The Agent mode provides an autonomous coding assistant with tool access:
 | `q` | Close panel |
 | `Y` | Copy last response |

+### Agent Panel Keymaps
+
+| Key | Description |
+|-----|-------------|
+| `<CR>` | Submit message |
+| `Ctrl+c` | Stop agent execution |
+| `q` | Close agent panel |
+
+### Logs Panel Keymaps
+
+| Key | Description |
+|-----|-------------|
+| `q` / `<Esc>` | Close logs panel |
+
+### Cost Window Keymaps
+
+| Key | Description |
+|-----|-------------|
+| `q` / `<Esc>` | Close window |
+| `r` | Refresh display |
+| `c` | Clear session costs |
+| `C` | Clear all history |
+
 ### Suggested Additional Keymaps

 ```lua
@@ -385,63 +472,288 @@ map("n", "<leader>cc", "<cmd>Coder close<cr>", { desc = "Coder: Close" })
 map("n", "<leader>ct", "<cmd>Coder toggle<cr>", { desc = "Coder: Toggle" })
 map("n", "<leader>cp", "<cmd>Coder process<cr>", { desc = "Coder: Process" })
 map("n", "<leader>cs", "<cmd>Coder status<cr>", { desc = "Coder: Status" })
+map("n", "<leader>cl", "<cmd>CoderLogs<cr>", { desc = "Coder: Logs" })
+map("n", "<leader>cm", "<cmd>CoderConflictMenu<cr>", { desc = "Coder: Conflict Menu" })
 ```

 ---

-## 🏥 Health Check
+## Usage Guide

-Verify your setup:
+### Tag-Based Prompts
+
+Write prompts using `/@` and `@/` tags:
+
+```typescript
+/@ Create a Button component with:
+- variant: 'primary' | 'secondary' | 'danger'
+- size: 'sm' | 'md' | 'lg'
+Use Tailwind CSS for styling @/
+```
+
+### Prompt Types
+
+| Keywords | Type | Behavior |
+|----------|------|----------|
+| `complete`, `finish`, `implement` | Complete | Replaces scope |
+| `refactor`, `rewrite`, `simplify` | Refactor | Replaces code |
+| `fix`, `debug`, `bug`, `error` | Fix | Fixes bugs |
+| `add`, `create`, `generate` | Add | Inserts new code |
+| `document`, `comment`, `jsdoc` | Document | Adds docs |
+| `explain`, `what`, `how` | Explain | Shows explanation |
+
+### Function Completion
+
+When you write a prompt inside a function, the plugin detects the enclosing scope:
+
+```typescript
+function getUserById(id: number): User | null {
+  /@ return the user from the database by id @/
+}
+```
+
+---
+
+## Conflict Resolution
+
+When code is generated, it's shown as a git-style conflict for you to review:
+
+```
+<<<<<<< CURRENT
+// Original code here
+=======
+// AI-generated code here
+>>>>>>> INCOMING
+```
+
+### Visual Indicators
+
+- **Green background**: Original (CURRENT) code
+- **Blue background**: AI-generated (INCOMING) code
+- **Virtual text hints**: Shows available keymaps
+
+### Resolution Options
+
+1. **Accept Current (`co`)**: Keep your original code
+2. **Accept Incoming (`ct`)**: Use the AI suggestion
+3. **Accept Both (`cb`)**: Keep both versions
+4. **Accept None (`cn`)**: Delete the entire conflict
+
+### Auto-Show Menu
+
+When code is injected, a floating menu automatically appears. After resolving a conflict, the menu shows again for the next conflict.
+
+Toggle auto-show: `:CoderConflictAutoMenu`
+
+---
+
+## Linter Validation
+
+After accepting AI suggestions (`ct` or `cb`), the plugin:
+
+1. **Saves the file** automatically
+2. **Checks LSP diagnostics** for errors/warnings
+3. **Offers to fix** lint errors with AI
+
+### Configuration
+
+```lua
+-- In conflict.lua config
+lint_after_accept = true,      -- Check linter after accepting
+auto_fix_lint_errors = true,   -- Auto-queue fix without prompting
+```
+
+### Manual Commands
+
+- `:CoderLintCheck` - Check current buffer
+- `:CoderLintFix` - Queue AI fix for errors
+- `:CoderLintQuickfix` - Show in quickfix list
+
+---
+
+## Logs Panel
+
+Real-time visibility into LLM operations:
+
+```vim
+:CoderLogs
+```
+
+Shows:
+- Generation requests and responses
+- Token usage
+- Queue status
+- Errors and warnings
+
+---
+
+## Cost Tracking
+
+Track LLM API costs across sessions:
+
+```vim
+:CoderCost
+```
+
+Features:
+- Session and all-time statistics
+- Per-model breakdown
+- Pricing for 50+ models
+- Persistent history in `.coder/cost_history.json`
+
+---
+
+## Agent Mode
+
+Autonomous coding assistant with tool access:
+
+### Available Tools
+
+- **read_file**: Read file contents
+- **edit_file**: Edit files with find/replace
+- **write_file**: Create or overwrite files
+- **bash**: Execute shell commands
+
+### Using Agent Mode
+
+1. Open: `:CoderAgent` or `<leader>ca`
+2. Describe your task
+3. Agent uses tools autonomously
+4. Review changes in conflict mode
+
+---
+
+## Health Check

 ```vim
 :checkhealth codetyper
 ```

-This checks:
- Neovim version
- curl availability
- LLM configuration
- API key status
- Telescope availability (optional)
-
 ---

-## 📁 File Structure
+## File Structure

 ```
 your-project/
-├── .coder/                    # Auto-created, gitignored
-│   └── tree.log              # Project structure log
+├── .coder/
+│   ├── tree.log
+│   ├── cost_history.json
+│   ├── brain/
+│   ├── agents/
+│   └── rules/
 ├── src/
-│   ├── index.ts              # Your source file
-│   ├── index.coder.ts        # Coder file (gitignored)
-└── .gitignore                # Auto-updated with coder patterns
+│   ├── index.ts
+│   └── index.coder.ts
+└── .gitignore
 ```

 ---

-## 🤝 Contributing
+## Reporting Issues

-Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+Found a bug or have a feature request? Please create an issue on GitHub.
+
+### Before Creating an Issue
+
+1. **Search existing issues** to avoid duplicates
+2. **Update to the latest version** and check if the issue persists
+3. **Run health check**: `:checkhealth codetyper`
+
+### Bug Reports
+
+When reporting a bug, please include:
+
+```markdown
+**Description**
+A clear description of what the bug is.
+
+**Steps to Reproduce**
+1. Open file '...'
+2. Run command '...'
+3. See error
+
+**Expected Behavior**
+What you expected to happen.
+
+**Actual Behavior**
+What actually happened.
+
+**Environment**
+- Neovim version: (output of `nvim --version`)
+- Plugin version: (commit hash or tag)
+- OS: (e.g., macOS 14.0, Ubuntu 22.04)
+- LLM Provider: (e.g., Claude, OpenAI, Ollama)
+
+**Error Messages**
+Paste any error messages from `:messages`
+
+**Minimal Config**
+If possible, provide a minimal config to reproduce:
+```lua
+-- minimal.lua
+require("codetyper").setup({
+  llm = { provider = "..." },
+})
+```
+```
+
+### Feature Requests
+
+For feature requests, please describe:
+
+- **Use case**: What problem does this solve?
+- **Proposed solution**: How should it work?
+- **Alternatives**: Other solutions you've considered
+
+### Debug Information
+
+To gather debug information:
+
+```vim
+" Check plugin status
+:Coder status
+
+" View logs
+:CoderLogs
+
+" Check health
+:checkhealth codetyper
+
+" View recent messages
+:messages
+```
+
+### Issue Labels
+
+- `bug` - Something isn't working
+- `enhancement` - New feature request
+- `documentation` - Documentation improvements
+- `question` - General questions
+- `help wanted` - Issues that need community help

 ---

-## 📄 License
+## Contributing

-MIT License - see [LICENSE](LICENSE) for details.
+Contributions welcome! See [CONTRIBUTING.md](CONTRIBUTING.md).

 ---

-## 👨‍💻 Author
+## License
+
+MIT License - see [LICENSE](LICENSE).
+
+---
+
+## Author

 **cargdev**

 - Website: [cargdev.io](https://cargdev.io)
- Blog: [blog.cargdev.io](https://blog.cargdev.io)
 - Email: carlos.gutierrez@carg.dev

 ---

 <p align="center">
-  Made with ❤️ for the Neovim community
+  Made with care for the Neovim community
 </p>
--- a/doc/codetyper.txt
+++ b/doc/codetyper.txt
@@ -120,7 +120,7 @@ Default configuration: >lua
 5. LLM PROVIDERS                                      *codetyper-providers*

                                                    *codetyper-claude*
-Claude (Anthropic)~
+Claude~
 Best for complex reasoning and code generation.
 >lua
  llm = {
--- a/llms.txt
+++ b/llms.txt
@@ -14,61 +14,72 @@ Instead of having an AI generate entire files, Codetyper lets developers maintai
 2. A companion "coder file" is created (`index.coder.ts`)
 3. Developer writes prompts using special tags: `/@ prompt @/`
 4. When the closing tag is typed, the LLM generates code
-5. Generated code is injected into the target file
+5. Generated code is shown as a conflict for review
+6. Developer accepts/rejects changes using keymaps

 ## Plugin Architecture

 ```
 lua/codetyper/
-├── init.lua          # Main entry, setup function, module initialization
-├── config.lua        # Configuration management, defaults, validation
-├── types.lua         # Lua type definitions for LSP/documentation
-├── utils.lua         # Utility functions (file ops, notifications)
-├── commands.lua      # Vim command definitions (:Coder, :CoderOpen, etc.)
-├── window.lua        # Split window management (open, close, toggle)
-├── parser.lua        # Parses /@ @/ tags from buffer content
-├── gitignore.lua     # Manages .gitignore entries for coder files
-├── autocmds.lua      # Autocommands for tag detection, filetype, auto-index
-├── inject.lua        # Code injection strategies
-├── health.lua        # Health check for :checkhealth
-├── tree.lua          # Project tree logging (.coder/tree.log)
-├── logs_panel.lua    # Standalone logs panel UI
+├── init.lua              # Main entry, setup function
+├── config.lua            # Configuration management
+├── types.lua             # Lua type definitions
+├── utils.lua             # Utility functions
+├── commands.lua          # Vim command definitions
+├── window.lua            # Split window management
+├── parser.lua            # Parses /@ @/ tags
+├── gitignore.lua         # Manages .gitignore entries
+├── autocmds.lua          # Autocommands for tag detection
+├── inject.lua            # Code injection strategies
+├── health.lua            # Health check for :checkhealth
+├── tree.lua              # Project tree logging
+├── logs_panel.lua        # Standalone logs panel UI
+├── cost.lua              # LLM cost tracking
+├── credentials.lua       # Secure credential storage
 ├── llm/
-│   ├── init.lua      # LLM interface, provider selection
-│   ├── claude.lua    # Claude API client (Anthropic)
-│   ├── openai.lua    # OpenAI API client (with custom endpoint support)
-│   ├── gemini.lua    # Google Gemini API client
-│   ├── copilot.lua   # GitHub Copilot client (uses OAuth from copilot.lua/vim)
-│   └── ollama.lua    # Ollama API client (local LLMs)
+│   ├── init.lua          # LLM interface, provider selection
+│   ├── claude.lua        # Claude API client
+│   ├── openai.lua        # OpenAI API client
+│   ├── gemini.lua        # Google Gemini API client
+│   ├── copilot.lua       # GitHub Copilot client
+│   └── ollama.lua        # Ollama API client (local)
 ├── agent/
-│   ├── init.lua      # Agent system entry point
-│   ├── ui.lua        # Agent panel UI
-│   ├── logs.lua      # Logging system with listeners
-│   ├── tools.lua     # Tool definitions (read_file, edit_file, write_file, bash)
-│   ├── executor.lua  # Tool execution logic
-│   ├── parser.lua    # Parse tool calls from LLM responses
-│   ├── queue.lua     # Event queue with priority heap
-│   ├── patch.lua     # Patch candidates with staleness detection
-│   ├── confidence.lua # Response confidence scoring heuristics
-│   ├── worker.lua    # Async LLM worker wrapper
-│   ├── scheduler.lua # Event scheduler with completion-awareness
-│   ├── scope.lua     # Tree-sitter scope resolution
-│   └── intent.lua    # Intent detection from prompts
+│   ├── init.lua          # Agent system entry point
+│   ├── ui.lua            # Agent panel UI
+│   ├── logs.lua          # Logging system
+│   ├── tools.lua         # Tool definitions (read, edit, write, bash)
+│   ├── executor.lua      # Tool execution logic
+│   ├── parser.lua        # Parse tool calls from responses
+│   ├── queue.lua         # Event queue with priority heap
+│   ├── patch.lua         # Patch candidates with staleness detection
+│   ├── confidence.lua    # Response confidence scoring
+│   ├── worker.lua        # Async LLM worker
+│   ├── scheduler.lua     # Event scheduler
+│   ├── scope.lua         # Tree-sitter scope resolution
+│   ├── intent.lua        # Intent detection from prompts
+│   ├── conflict.lua      # Git-style conflict resolution
+│   ├── linter.lua        # LSP diagnostics validation
+│   └── search_replace.lua # SEARCH/REPLACE block parsing
 ├── ask/
-│   ├── init.lua      # Ask panel entry point
-│   └── ui.lua        # Ask panel UI (chat interface)
+│   ├── init.lua          # Ask panel entry point
+│   └── ui.lua            # Ask panel UI (chat interface)
 └── prompts/
-    ├── init.lua      # System prompts for code generation
-    └── agent.lua     # Agent-specific prompts and tool instructions
+    ├── init.lua          # System prompts for code generation
+    └── agent.lua         # Agent-specific prompts
 ```

 ## .coder/ Folder

-The plugin automatically creates and maintains a `.coder/` folder in your project:
-
 ```
 .coder/
-└── tree.log    # Project structure, auto-updated on file changes
+├── tree.log           # Project structure, auto-updated
+├── cost_history.json  # LLM cost tracking history
+├── brain/             # Knowledge graph storage
+│   ├── nodes/
+│   ├── indices/
+│   └── deltas/
+├── agents/            # Custom agent definitions
+└── rules/             # Project-specific rules
 ```

 ## Key Features
@@ -86,66 +97,122 @@ llm = {
 }
 ```

-### 2. Agent Mode
+### 2. Conflict Resolution System
+
+Git-style diff visualization for code review:
+
+```
+<<<<<<< CURRENT
+// Original code
+=======
+// AI-generated code
+>>>>>>> INCOMING
+```
+
+**Keymaps (buffer-local when conflicts exist):**
+| Key | Description |
+|-----|-------------|
+| `co` | Accept CURRENT (original) code |
+| `ct` | Accept INCOMING (AI suggestion) |
+| `cb` | Accept BOTH versions |
+| `cn` | Delete conflict (accept NONE) |
+| `cm` | Show conflict resolution menu |
+| `]x` | Go to next conflict |
+| `[x` | Go to previous conflict |
+| `<CR>` | Show menu when on conflict |
+
+**Menu keymaps:**
+| Key | Description |
+|-----|-------------|
+| `1` | Accept current |
+| `2` | Accept incoming |
+| `3` | Accept both |
+| `4` | Accept none |
+| `q`/`<Esc>` | Close menu |
+
+**Configuration:**
+```lua
+-- In conflict.lua
+config = {
+  lint_after_accept = true,      -- Check linter after accepting
+  auto_fix_lint_errors = true,   -- Auto-queue fix
+  auto_show_menu = true,         -- Show menu after injection
+  auto_show_next_menu = true,    -- Show menu for next conflict
+}
+```
+
+### 3. Linter Validation
+
+Auto-check and fix lint errors after code injection:
+
+```lua
+-- In linter.lua
+config = {
+  auto_save = true,              -- Save file after injection
+  diagnostic_delay_ms = 500,     -- Wait for LSP
+  min_severity = vim.diagnostic.severity.WARN,
+  auto_offer_fix = true,         -- Offer to fix errors
+}
+```
+
+**Commands:**
+- `:CoderLintCheck` - Check buffer for lint errors
+- `:CoderLintFix` - Request AI to fix lint errors
+- `:CoderLintQuickfix` - Show errors in quickfix
+- `:CoderLintToggleAuto` - Toggle auto lint checking
+
+### 4. SEARCH/REPLACE Block System
+
+Reliable code editing with fuzzy matching:
+
+```
+<<<<<<< SEARCH
+function oldCode() {
+  // original
+}
+=======
+function newCode() {
+  // replacement
+}
+>>>>>>> REPLACE
+```
+
+**Configuration:**
+```lua
+-- In search_replace.lua
+config = {
+  fuzzy_threshold = 0.8,         -- Minimum similarity
+  normalize_whitespace = true,   -- Ignore whitespace differences
+  context_lines = 3,             -- Lines for context matching
+}
+```
+
+### 5. Agent Mode

 Autonomous coding assistant with tool access:

+**Available Tools:**
 - `read_file` - Read file contents
 - `edit_file` - Edit files with find/replace
 - `write_file` - Create or overwrite files
 - `bash` - Execute shell commands

-### 3. Transform Commands
-
-Transform `/@ @/` tags inline without split view:
-
- `:CoderTransform` - Transform all tags in file
- `:CoderTransformCursor` - Transform tag at cursor
- `:CoderTransformVisual` - Transform selected tags
-
-### 4. Auto-Index
-
-Automatically create coder companion files when opening source files:
-
-```lua
-auto_index = true  -- disabled by default
-```
-
-### 5. Logs Panel
-
-Real-time visibility into LLM operations with token usage tracking.
-
 ### 6. Event-Driven Scheduler

-Prompts are treated as events, not commands:
-
 ```
-User types /@...@/ → Event queued → Scheduler dispatches → Worker processes → Patch created → Safe injection
+User types /@...@/ → Event queued → Scheduler dispatches → Worker processes → Patch created → Conflict shown
 ```

 **Key concepts:**
-
- **PromptEvent**: Captures buffer state (changedtick, content hash) at prompt time
- **Optimistic Execution**: Ollama as fast scout, escalate to remote LLMs if confidence low
- **Confidence Scoring**: 5 heuristics (length, uncertainty, syntax, repetition, truncation)
- **Staleness Detection**: Discard patches if buffer changed during generation
- **Completion Safety**: Defer injection while autocomplete popup visible
-
-**Configuration:**
-
-```lua
-scheduler = {
-  enabled = true,           -- Enable event-driven mode
-  ollama_scout = true,      -- Use Ollama first
-  escalation_threshold = 0.7, -- Below this → escalate
-  max_concurrent = 2,       -- Parallel workers
-  completion_delay_ms = 100, -- Wait after popup closes
-}
-```
+- **PromptEvent**: Captures buffer state at prompt time
+- **Optimistic Execution**: Ollama as fast scout
+- **Confidence Scoring**: 5 heuristics
+- **Staleness Detection**: Discard if buffer changed
+- **Completion Safety**: Defer while autocomplete visible

 ### 7. Tree-sitter Scope Resolution

-Prompts automatically resolve to their enclosing function/method/class:
+Prompts automatically resolve to enclosing scope:

 ```lua
 function foo()
@@ -155,13 +222,8 @@ end

 **Scope types:** `function`, `method`, `class`, `block`, `file`

-For replacement intents (complete, refactor, fix), the entire scope is extracted
-and sent to the LLM, then replaced with the transformed version.
-
 ### 8. Intent Detection

-The system parses prompts to detect user intent:
-
 | Intent | Keywords | Action |
 |--------|----------|--------|
 | complete | complete, finish, implement | replace |
@@ -170,76 +232,174 @@ The system parses prompts to detect user intent:
 | add | add, create, insert, new | insert |
 | document | document, comment, jsdoc | replace |
 | test | test, spec, unit test | append |
-| optimize | optimize, performance, faster | replace |
-| explain | explain, what, how, why | none |
+| optimize | optimize, performance | replace |
+| explain | explain, what, how | none |

-### 9. Tag Precedence
+### 9. Cost Tracking

-Multiple tags in the same scope follow "first tag wins" rule:
- Earlier (by line number) unresolved tag processes first
- Later tags in same scope are skipped with warning
- Different scopes process independently
+Track LLM API costs:
+- Session costs tracked in real-time
+- All-time costs in `.coder/cost_history.json`
+- Pricing for 50+ models

-## Commands
+### 10. Credentials Management

-### Main Commands
- `:Coder open` - Opens split view with coder file
- `:Coder close` - Closes the split
- `:Coder toggle` - Toggles the view
- `:Coder process` - Manually triggers code generation
+```vim
+:CoderAddApiKey
+```
+
+Stored in `~/.local/share/nvim/codetyper/configuration.json`
+
+**Priority:** stored credentials > config > environment variables
+
+## Commands Reference
+
+### Core Commands
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `:Coder open` | `:CoderOpen` | Open coder split |
+| `:Coder close` | `:CoderClose` | Close coder split |
+| `:Coder toggle` | `:CoderToggle` | Toggle coder split |
+| `:Coder process` | `:CoderProcess` | Process last prompt |
+| `:Coder status` | - | Show status |
+| `:Coder focus` | - | Switch focus |
+| `:Coder reset` | - | Reset processed prompts |

 ### Ask Panel
- `:CoderAsk` - Open Ask panel
- `:CoderAskToggle` - Toggle Ask panel
- `:CoderAskClear` - Clear chat history
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `:Coder ask` | `:CoderAsk` | Open Ask panel |
+| `:Coder ask-toggle` | `:CoderAskToggle` | Toggle Ask panel |
+| `:Coder ask-clear` | `:CoderAskClear` | Clear chat |

 ### Agent Mode
- `:CoderAgent` - Open Agent panel
- `:CoderAgentToggle` - Toggle Agent panel
- `:CoderAgentStop` - Stop running agent
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `:Coder agent` | `:CoderAgent` | Open Agent panel |
+| `:Coder agent-toggle` | `:CoderAgentToggle` | Toggle Agent panel |
+| `:Coder agent-stop` | `:CoderAgentStop` | Stop agent |

-### Transform
- `:CoderTransform` - Transform all tags
- `:CoderTransformCursor` - Transform at cursor
- `:CoderTransformVisual` - Transform selection
+### Transform Commands
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `:Coder transform` | `:CoderTransform` | Transform all tags |
+| `:Coder transform-cursor` | `:CoderTransformCursor` | Transform at cursor |
+| - | `:CoderTransformVisual` | Transform selected |

-### Utility
- `:CoderIndex` - Open coder companion
- `:CoderLogs` - Toggle logs panel
- `:CoderType` - Switch Ask/Agent mode
- `:CoderTree` - Refresh tree.log
- `:CoderTreeView` - View tree.log
+### Conflict Resolution
+| Command | Description |
+|---------|-------------|
+| `:CoderConflictToggle` | Toggle conflict mode |
+| `:CoderConflictMenu` | Show resolution menu |
+| `:CoderConflictNext` | Go to next conflict |
+| `:CoderConflictPrev` | Go to previous conflict |
+| `:CoderConflictStatus` | Show conflict status |
+| `:CoderConflictResolveAll [keep]` | Resolve all |
+| `:CoderConflictAcceptCurrent` | Accept original |
+| `:CoderConflictAcceptIncoming` | Accept AI |
+| `:CoderConflictAcceptBoth` | Accept both |
+| `:CoderConflictAcceptNone` | Delete both |
+| `:CoderConflictAutoMenu` | Toggle auto-show menu |
+
+### Linter Validation
+| Command | Description |
+|---------|-------------|
+| `:CoderLintCheck` | Check buffer |
+| `:CoderLintFix` | AI fix errors |
+| `:CoderLintQuickfix` | Show in quickfix |
+| `:CoderLintToggleAuto` | Toggle auto lint |
+
+### Queue & Scheduler
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `:Coder queue-status` | `:CoderQueueStatus` | Show status |
+| `:Coder queue-process` | `:CoderQueueProcess` | Trigger processing |
+
+### Processing Mode
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `:Coder auto-toggle` | `:CoderAutoToggle` | Toggle auto/manual |
+| `:Coder auto-set <mode>` | `:CoderAutoSet` | Set mode |
+
+### Brain & Memory
+| Command | Description |
+|---------|-------------|
+| `:CoderMemories` | Show memories |
+| `:CoderForget [pattern]` | Clear memories |
+| `:CoderBrain [action]` | Brain management |
+| `:CoderFeedback <type>` | Give feedback |
+
+### Cost & Credentials
+| Command | Description |
+|---------|-------------|
+| `:CoderCost` | Show cost window |
+| `:CoderAddApiKey` | Add/update API key |
+| `:CoderRemoveApiKey` | Remove credentials |
+| `:CoderCredentials` | Show credentials |
+| `:CoderSwitchProvider` | Switch provider |
+
+### UI Commands
+| Command | Description |
+|---------|-------------|
+| `:CoderLogs` | Toggle logs panel |
+| `:CoderType` | Show mode switcher |
+
+## Keymaps Reference
+
+### Default Keymaps
+| Key | Mode | Description |
+|-----|------|-------------|
+| `<leader>ctt` | Normal | Transform tag at cursor |
+| `<leader>ctt` | Visual | Transform selected tags |
+| `<leader>ctT` | Normal | Transform all tags |
+| `<leader>ca` | Normal | Toggle Agent panel |
+| `<leader>ci` | Normal | Open coder companion |
+
+### Ask Panel Keymaps
+| Key | Description |
+|-----|-------------|
+| `@` | Attach file |
+| `Ctrl+Enter` | Submit |
+| `Ctrl+n` | New chat |
+| `Ctrl+f` | Add current file |
+| `q` | Close |
+| `Y` | Copy response |
+
+### Agent Panel Keymaps
+| Key | Description |
+|-----|-------------|
+| `<CR>` | Submit |
+| `Ctrl+c` | Stop agent |
+| `q` | Close |
+
+### Logs Panel Keymaps
+| Key | Description |
+|-----|-------------|
+| `q`/`<Esc>` | Close |
+
+### Cost Window Keymaps
+| Key | Description |
+|-----|-------------|
+| `q`/`<Esc>` | Close |
+| `r` | Refresh |
+| `c` | Clear session |
+| `C` | Clear all |

 ## Configuration Schema

 ```lua
 {
  llm = {
-    provider = "claude",  -- "claude" | "openai" | "gemini" | "copilot" | "ollama"
-    claude = {
-      api_key = nil,      -- string, uses ANTHROPIC_API_KEY env if nil
-      model = "claude-sonnet-4-20250514",
-    },
-    openai = {
-      api_key = nil,      -- string, uses OPENAI_API_KEY env if nil
-      model = "gpt-4o",
-      endpoint = nil,     -- custom endpoint for Azure, OpenRouter, etc.
-    },
-    gemini = {
-      api_key = nil,      -- string, uses GEMINI_API_KEY env if nil
-      model = "gemini-2.0-flash",
-    },
-    copilot = {
-      model = "gpt-4o",   -- uses OAuth from copilot.lua/copilot.vim
-    },
-    ollama = {
-      host = "http://localhost:11434",
-      model = "deepseek-coder:6.7b",
-    },
+    provider = "claude",
+    claude = { api_key = nil, model = "claude-sonnet-4-20250514" },
+    openai = { api_key = nil, model = "gpt-4o", endpoint = nil },
+    gemini = { api_key = nil, model = "gemini-2.0-flash" },
+    copilot = { model = "gpt-4o" },
+    ollama = { host = "http://localhost:11434", model = "deepseek-coder:6.7b" },
  },
  window = {
-    width = 25,           -- percentage (25 = 25% of screen)
-    position = "left",    -- "left" | "right"
+    width = 25,
+    position = "left",
    border = "rounded",
  },
  patterns = {
@@ -249,13 +409,14 @@ Multiple tags in the same scope follow "first tag wins" rule:
  },
  auto_gitignore = true,
  auto_open_ask = true,
-  auto_index = false,     -- auto-create coder companion files
+  auto_index = false,
  scheduler = {
-    enabled = true,           -- enable event-driven scheduler
-    ollama_scout = true,      -- use Ollama as fast scout
+    enabled = true,
+    ollama_scout = true,
    escalation_threshold = 0.7,
    max_concurrent = 2,
    completion_delay_ms = 100,
+    apply_delay_ms = 5000,
  },
 }
 ```
@@ -264,29 +425,26 @@ Multiple tags in the same scope follow "first tag wins" rule:

 ### Claude API
 - Endpoint: `https://api.anthropic.com/v1/messages`
- Uses `x-api-key` header for authentication
- Supports tool use for agent mode
+- Auth: `x-api-key` header
+- Supports tool use

 ### OpenAI API
 - Endpoint: `https://api.openai.com/v1/chat/completions` (configurable)
- Uses `Authorization: Bearer` header
- Supports tool use for agent mode
- Compatible with Azure, OpenRouter, and other OpenAI-compatible APIs
+- Auth: `Authorization: Bearer`
+- Compatible with Azure, OpenRouter

 ### Gemini API
 - Endpoint: `https://generativelanguage.googleapis.com/v1beta/models`
- Uses API key in URL parameter
- Supports function calling for agent mode
+- Auth: API key in URL
+- Supports function calling

 ### Copilot API
 - Uses GitHub OAuth token from copilot.lua/copilot.vim
- Endpoint from token response (typically `api.githubcopilot.com`)
 - OpenAI-compatible format

 ### Ollama API
 - Endpoint: `{host}/api/generate` or `{host}/api/chat`
- No authentication required for local instances
- Tool use via prompt-based approach
+- No auth required locally

 ## Agent Tool Definitions

@@ -299,13 +457,6 @@ tools = {
 }
 ```

-## Code Injection Strategies
-
-1. **Refactor**: Replace entire file content
-2. **Add**: Insert at cursor position in target file
-3. **Document**: Insert above current function/class
-4. **Generic**: Prompt user for action
-
 ## File Naming Convention

 | Target File | Coder File |
@@ -318,8 +469,8 @@ Pattern: `name.coder.extension`

 ## Dependencies

- **Required**: Neovim >= 0.8.0, curl
- **Optional**: telescope.nvim (enhanced file picker), copilot.lua or copilot.vim (for Copilot provider)
+- **Required**: Neovim >= 0.8.0, curl, plenary.nvim, nvim-treesitter
+- **Optional**: telescope.nvim, copilot.lua/copilot.vim, nui.nvim

 ## Contact

--- a/lua/codetyper/adapters/nvim/autocmds.lua
+++ b/lua/codetyper/adapters/nvim/autocmds.lua
--- a/lua/codetyper/adapters/nvim/cmp/init.lua
+++ b/lua/codetyper/adapters/nvim/cmp/init.lua
@@ -0,0 +1,357 @@
+---@mod codetyper.cmp_source Completion source for nvim-cmp
+---@brief [[
+--- Provides intelligent code completions using the brain, indexer, and LLM.
+--- Integrates with nvim-cmp as a custom source.
+---@brief ]]
+
+local M = {}
+
+local source = {}
+
+--- Check if cmp is available
+---@return boolean
+local function has_cmp()
+	return pcall(require, "cmp")
+end
+
+--- Get completion items from brain context
+---@param prefix string Current word prefix
+---@return table[] items
+local function get_brain_completions(prefix)
+	local items = {}
+
+	local ok_brain, brain = pcall(require, "codetyper.brain")
+	if not ok_brain then
+		return items
+	end
+
+	-- Check if brain is initialized safely
+	local is_init = false
+	if brain.is_initialized then
+		local ok, result = pcall(brain.is_initialized)
+		is_init = ok and result
+	end
+
+	if not is_init then
+		return items
+	end
+
+	-- Query brain for relevant patterns
+	local ok_query, result = pcall(brain.query, {
+		query = prefix,
+		max_results = 10,
+		types = { "pattern" },
+	})
+
+	if ok_query and result and result.nodes then
+		for _, node in ipairs(result.nodes) do
+			if node.c and node.c.s then
+				-- Extract function/class names from summary
+				local summary = node.c.s
+				for name in summary:gmatch("functions:%s*([^;]+)") do
+					for func in name:gmatch("([%w_]+)") do
+						if func:lower():find(prefix:lower(), 1, true) then
+							table.insert(items, {
+								label = func,
+								kind = 3, -- Function
+								detail = "[brain]",
+								documentation = summary,
+							})
+						end
+					end
+				end
+				for name in summary:gmatch("classes:%s*([^;]+)") do
+					for class in name:gmatch("([%w_]+)") do
+						if class:lower():find(prefix:lower(), 1, true) then
+							table.insert(items, {
+								label = class,
+								kind = 7, -- Class
+								detail = "[brain]",
+								documentation = summary,
+							})
+						end
+					end
+				end
+			end
+		end
+	end
+
+	return items
+end
+
+--- Get completion items from indexer symbols
+---@param prefix string Current word prefix
+---@return table[] items
+local function get_indexer_completions(prefix)
+	local items = {}
+
+	local ok_indexer, indexer = pcall(require, "codetyper.indexer")
+	if not ok_indexer then
+		return items
+	end
+
+	local ok_load, index = pcall(indexer.load_index)
+	if not ok_load or not index then
+		return items
+	end
+
+	-- Search symbols
+	if index.symbols then
+		for symbol, files in pairs(index.symbols) do
+			if symbol:lower():find(prefix:lower(), 1, true) then
+				local files_str = type(files) == "table" and table.concat(files, ", ") or tostring(files)
+				table.insert(items, {
+					label = symbol,
+					kind = 6, -- Variable (generic)
+					detail = "[index] " .. files_str:sub(1, 30),
+					documentation = "Symbol found in: " .. files_str,
+				})
+			end
+		end
+	end
+
+	-- Search functions in files
+	if index.files then
+		for filepath, file_index in pairs(index.files) do
+			if file_index and file_index.functions then
+				for _, func in ipairs(file_index.functions) do
+					if func.name and func.name:lower():find(prefix:lower(), 1, true) then
+						table.insert(items, {
+							label = func.name,
+							kind = 3, -- Function
+							detail = "[index] " .. vim.fn.fnamemodify(filepath, ":t"),
+							documentation = func.docstring or ("Function at line " .. (func.line or "?")),
+						})
+					end
+				end
+			end
+			if file_index and file_index.classes then
+				for _, class in ipairs(file_index.classes) do
+					if class.name and class.name:lower():find(prefix:lower(), 1, true) then
+						table.insert(items, {
+							label = class.name,
+							kind = 7, -- Class
+							detail = "[index] " .. vim.fn.fnamemodify(filepath, ":t"),
+							documentation = class.docstring or ("Class at line " .. (class.line or "?")),
+						})
+					end
+				end
+			end
+		end
+	end
+
+	return items
+end
+
+--- Get completion items from current buffer (fallback)
+---@param prefix string Current word prefix
+---@param bufnr number Buffer number
+---@return table[] items
+local function get_buffer_completions(prefix, bufnr)
+	local items = {}
+	local seen = {}
+
+	-- Get all lines in buffer
+	local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
+	local prefix_lower = prefix:lower()
+
+	for _, line in ipairs(lines) do
+		-- Extract words that could be identifiers
+		for word in line:gmatch("[%a_][%w_]*") do
+			if #word >= 3 and word:lower():find(prefix_lower, 1, true) and not seen[word] and word ~= prefix then
+				seen[word] = true
+				table.insert(items, {
+					label = word,
+					kind = 1, -- Text
+					detail = "[buffer]",
+				})
+			end
+		end
+	end
+
+	return items
+end
+
+--- Try to get Copilot suggestion if plugin is installed
+---@param prefix string
+---@return string|nil suggestion
+local function get_copilot_suggestion(prefix)
+	-- Try copilot.lua suggestion API first
+	local ok, copilot_suggestion = pcall(require, "copilot.suggestion")
+	if ok and copilot_suggestion and type(copilot_suggestion.get_suggestion) == "function" then
+		local ok2, suggestion = pcall(copilot_suggestion.get_suggestion)
+		if ok2 and suggestion and suggestion ~= "" then
+			-- Only return if suggestion seems to start with prefix (best-effort)
+			if prefix == "" or suggestion:lower():match(prefix:lower(), 1) then
+				return suggestion
+			else
+				return suggestion
+			end
+		end
+	end
+
+	-- Fallback: try older copilot module if present
+	local ok3, copilot = pcall(require, "copilot")
+	if ok3 and copilot and type(copilot.get_suggestion) == "function" then
+		local ok4, suggestion = pcall(copilot.get_suggestion)
+		if ok4 and suggestion and suggestion ~= "" then
+			return suggestion
+		end
+	end
+
+	return nil
+end
+
+--- Create new cmp source instance
+function source.new()
+	return setmetatable({}, { __index = source })
+end
+
+--- Get source name
+function source:get_keyword_pattern()
+	return [[\k\+]]
+end
+
+--- Check if source is available
+function source:is_available()
+	return true
+end
+
+--- Get debug name
+function source:get_debug_name()
+	return "codetyper"
+end
+
+--- Get trigger characters
+function source:get_trigger_characters()
+	return { ".", ":", "_" }
+end
+
+--- Complete
+---@param params table
+---@param callback fun(response: table|nil)
+function source:complete(params, callback)
+	local prefix = params.context.cursor_before_line:match("[%w_]+$") or ""
+
+	if #prefix < 2 then
+		callback({ items = {}, isIncomplete = true })
+		return
+	end
+
+	-- Collect completions from brain, indexer, and buffer
+	local items = {}
+	local seen = {}
+
+	-- Get brain completions (highest priority)
+	local ok1, brain_items = pcall(get_brain_completions, prefix)
+	if ok1 and brain_items then
+		for _, item in ipairs(brain_items) do
+			if not seen[item.label] then
+				seen[item.label] = true
+				item.sortText = "1" .. item.label
+				table.insert(items, item)
+			end
+		end
+	end
+
+	-- Get indexer completions
+	local ok2, indexer_items = pcall(get_indexer_completions, prefix)
+	if ok2 and indexer_items then
+		for _, item in ipairs(indexer_items) do
+			if not seen[item.label] then
+				seen[item.label] = true
+				item.sortText = "2" .. item.label
+				table.insert(items, item)
+			end
+		end
+	end
+
+	-- Get buffer completions as fallback (lower priority)
+	local bufnr = params.context.bufnr
+	if bufnr then
+		local ok3, buffer_items = pcall(get_buffer_completions, prefix, bufnr)
+		if ok3 and buffer_items then
+			for _, item in ipairs(buffer_items) do
+				if not seen[item.label] then
+					seen[item.label] = true
+					item.sortText = "3" .. item.label
+					table.insert(items, item)
+				end
+			end
+		end
+	end
+
+	-- If Copilot is installed, prefer its suggestion as a top-priority completion
+	local ok_cp, _ = pcall(require, "copilot")
+	if ok_cp then
+		local suggestion = nil
+		local ok_sug, res = pcall(get_copilot_suggestion, prefix)
+		if ok_sug then
+			suggestion = res
+		end
+		if suggestion and suggestion ~= "" then
+			-- Truncate suggestion to first line for label display
+			local first_line = suggestion:match("([^
+]+)") or suggestion
+			-- Avoid duplicates
+			if not seen[first_line] then
+				seen[first_line] = true
+				table.insert(items, 1, {
+					label = first_line,
+					kind = 1,
+					detail = "[copilot]",
+					documentation = suggestion,
+					sortText = "0" .. first_line,
+				})
+			end
+		end
+	end
+
+	callback({
+		items = items,
+		isIncomplete = #items >= 50,
+	})
+end
+
+--- Setup the completion source
+function M.setup()
+	if not has_cmp() then
+		return false
+	end
+
+	local cmp = require("cmp")
+	local new_source = source.new()
+
+	-- Register the source
+	cmp.register_source("codetyper", new_source)
+
+	return true
+end
+
+--- Check if source is registered
+---@return boolean
+function M.is_registered()
+	local ok, cmp = pcall(require, "cmp")
+	if not ok then
+		return false
+	end
+
+	-- Try to get registered sources
+	local config = cmp.get_config()
+	if config and config.sources then
+		for _, src in ipairs(config.sources) do
+			if src.name == "codetyper" then
+				return true
+			end
+		end
+	end
+
+	return false
+end
+
+--- Get source for manual registration
+function M.get_source()
+	return source
+end
+
+return M
--- a/lua/codetyper/adapters/nvim/commands.lua
+++ b/lua/codetyper/adapters/nvim/commands.lua
--- a/lua/codetyper/adapters/nvim/ui/chat.lua
+++ b/lua/codetyper/adapters/nvim/ui/chat.lua
@@ -4,9 +4,9 @@

 local M = {}

-local agent = require("codetyper.agent")
-local logs = require("codetyper.agent.logs")
-local utils = require("codetyper.utils")
+local agent = require("codetyper.features.agents")
+local logs = require("codetyper.adapters.nvim.ui.logs")
+local utils = require("codetyper.support.utils")

 ---@class AgentUIState
 ---@field chat_buf number|nil Chat buffer
@@ -29,20 +29,69 @@ local state = {
  is_open = false,
  log_listener_id = nil,
  referenced_files = {},
+  selection_context = nil, -- Visual selection passed when opening
 }

 --- Namespace for highlights
 local ns_chat = vim.api.nvim_create_namespace("codetyper_agent_chat")
 local ns_logs = vim.api.nvim_create_namespace("codetyper_agent_logs")

--- Fixed widths
-local CHAT_WIDTH = 300
-local LOGS_WIDTH = 50
+--- Fixed heights
 local INPUT_HEIGHT = 5
+local LOGS_WIDTH = 50
+
+--- Calculate dynamic width (1/4 of screen, minimum 30)
+---@return number
+local function get_panel_width()
+  return math.max(math.floor(vim.o.columns * 0.25), 30)
+end

 --- Autocmd group
 local agent_augroup = nil

+--- Autocmd group for width maintenance
+local width_augroup = nil
+
+--- Store target width
+local target_width = nil
+
+--- Setup autocmd to always maintain 1/4 window width
+local function setup_width_autocmd()
+  -- Clear previous autocmd group if exists
+  if width_augroup then
+    pcall(vim.api.nvim_del_augroup_by_id, width_augroup)
+  end
+
+  width_augroup = vim.api.nvim_create_augroup("CodetypeAgentWidth", { clear = true })
+
+  -- Always maintain 1/4 width on any window event
+  vim.api.nvim_create_autocmd({ "WinResized", "WinNew", "WinClosed", "VimResized" }, {
+    group = width_augroup,
+    callback = function()
+      if not state.is_open or not state.chat_win then
+        return
+      end
+      if not vim.api.nvim_win_is_valid(state.chat_win) then
+        return
+      end
+
+      vim.schedule(function()
+        if state.chat_win and vim.api.nvim_win_is_valid(state.chat_win) then
+          -- Always calculate 1/4 of current screen width
+          local new_target = math.max(math.floor(vim.o.columns * 0.25), 30)
+          target_width = new_target
+
+          local current_width = vim.api.nvim_win_get_width(state.chat_win)
+          if current_width ~= target_width then
+            pcall(vim.api.nvim_win_set_width, state.chat_win, target_width)
+          end
+        end
+      end)
+    end,
+    desc = "Maintain Agent panel at 1/4 window width",
+  })
+end
+
 --- Add a log entry to the logs buffer
 ---@param entry table Log entry
 local function add_log_entry(entry)
@@ -73,7 +122,9 @@ local function add_log_entry(entry)
    local lines = vim.api.nvim_buf_get_lines(state.logs_buf, 0, -1, false)
    local line_num = #lines

-    vim.api.nvim_buf_set_lines(state.logs_buf, -1, -1, false, { formatted })
+    -- Split formatted log into individual lines to avoid passing newline-containing items
+    local formatted_lines = vim.split(formatted, "\n")
+    vim.api.nvim_buf_set_lines(state.logs_buf, -1, -1, false, formatted_lines)

    -- Apply highlighting based on level
    local hl_map = {
@@ -186,8 +237,16 @@ local function create_callbacks()

    on_complete = function()
      vim.schedule(function()
-        add_message("system", "Done.", "DiagnosticHint")
-        logs.info("Agent loop completed")
+        local changes_count = agent.get_changes_count()
+        if changes_count > 0 then
+          add_message("system",
+            string.format("Done. %d file(s) changed. Press <leader>d to review changes.", changes_count),
+            "DiagnosticHint")
+          logs.info(string.format("Agent completed with %d change(s)", changes_count))
+        else
+          add_message("system", "Done.", "DiagnosticHint")
+          logs.info("Agent loop completed")
+        end
        M.focus_input()
      end)
    end,
@@ -255,12 +314,15 @@ local function submit_input()
        "╔═══════════════════════════════════════════════════════════════╗",
        "║  [AGENT MODE] Can read/write files                           ║",
        "╠═══════════════════════════════════════════════════════════════╣",
-        "║  @ attach file | C-f current file | :CoderType switch mode   ║",
+        "║  @ attach | C-f current file | <leader>d review changes      ║",
        "╚═══════════════════════════════════════════════════════════════╝",
        "",
      })
      vim.bo[state.chat_buf].modifiable = false
    end
+    -- Also clear collected diffs
+    local diff_review = require("codetyper.adapters.nvim.ui.diff_review")
+    diff_review.clear()
    return
  end

@@ -269,6 +331,30 @@ local function submit_input()
    return
  end

+  if input == "/continue" then
+    if agent.is_running() then
+      add_message("system", "Agent is already running. Use /stop first.")
+      return
+    end
+
+    if not agent.has_saved_session() then
+      add_message("system", "No saved session to continue.")
+      return
+    end
+
+    local info = agent.get_saved_session_info()
+    if info then
+      add_message("system", string.format("Resuming session from %s...", info.saved_at))
+      logs.info(string.format("Resuming: %d messages, iteration %d", info.messages, info.iteration))
+    end
+
+    local success = agent.continue_session(create_callbacks())
+    if not success then
+      add_message("system", "Failed to resume session.")
+    end
+    return
+  end
+
  -- Build file context
  local file_context = build_file_context()
  local file_count = vim.tbl_count(state.referenced_files)
@@ -301,7 +387,7 @@ local function submit_input()
    current_file = vim.fn.expand("%:p")
  end

-  local llm = require("codetyper.llm")
+  local llm = require("codetyper.core.llm")
  local context = {}

  if current_file ~= "" and vim.fn.filereadable(current_file) == 1 then
@@ -311,8 +397,15 @@ local function submit_input()

  -- Append file context to input
  local full_input = input
+
+  -- Add selection context if present
+  local selection_ctx = M.get_selection_context()
+  if selection_ctx then
+    full_input = full_input .. "\n\n" .. selection_ctx
+  end
+
  if file_context ~= "" then
-    full_input = input .. "\n\nATTACHED FILES:" .. file_context
+    full_input = full_input .. "\n\nATTACHED FILES:" .. file_context
  end

  logs.thinking("Starting...")
@@ -446,12 +539,20 @@ local function update_logs_title()
 end

 --- Open the agent UI
-function M.open()
+---@param selection table|nil Visual selection context {text, start_line, end_line, filepath, filename, language}
+function M.open(selection)
  if state.is_open then
+    -- If already open and new selection provided, add it as context
+    if selection and selection.text and selection.text ~= "" then
+      M.add_selection_context(selection)
+    end
    M.focus_input()
    return
  end

+  -- Store selection context
+  state.selection_context = selection
+
  -- Clear previous state
  logs.clear()
  state.referenced_files = {}
@@ -479,7 +580,7 @@ function M.open()
  vim.cmd("topleft vsplit")
  state.chat_win = vim.api.nvim_get_current_win()
  vim.api.nvim_win_set_buf(state.chat_win, state.chat_buf)
-  vim.api.nvim_win_set_width(state.chat_win, CHAT_WIDTH)
+  vim.api.nvim_win_set_width(state.chat_win, get_panel_width())

  -- Window options for chat
  vim.wo[state.chat_win].number = false
@@ -526,7 +627,7 @@ function M.open()
    "╔═══════════════════════════════════════════════════════════════╗",
    "║  [AGENT MODE] Can read/write files                           ║",
    "╠═══════════════════════════════════════════════════════════════╣",
-    "║  @ attach file | C-f current file | :CoderType switch mode   ║",
+    "║  @ attach | C-f current file | <leader>d review changes      ║",
    "╚═══════════════════════════════════════════════════════════════╝",
    "",
  })
@@ -559,6 +660,7 @@ function M.open()
  vim.keymap.set("n", "<Tab>", M.focus_chat, input_opts)
  vim.keymap.set("n", "q", M.close, input_opts)
  vim.keymap.set("n", "<Esc>", M.close, input_opts)
+  vim.keymap.set("n", "<leader>d", M.show_diff_review, input_opts)

  -- Set up keymaps for chat buffer
  local chat_opts = { buffer = state.chat_buf, noremap = true, silent = true }
@@ -569,6 +671,7 @@ function M.open()
  vim.keymap.set("n", "<C-f>", M.include_current_file, chat_opts)
  vim.keymap.set("n", "<Tab>", M.focus_logs, chat_opts)
  vim.keymap.set("n", "q", M.close, chat_opts)
+  vim.keymap.set("n", "<leader>d", M.show_diff_review, chat_opts)

  -- Set up keymaps for logs buffer
  local logs_opts = { buffer = state.logs_buf, noremap = true, silent = true }
@@ -592,18 +695,51 @@ function M.open()
    end,
  })

+  -- Setup autocmd to maintain 1/4 width
+  target_width = get_panel_width()
+  setup_width_autocmd()
+
  state.is_open = true

  -- Focus input and log startup
  M.focus_input()
  logs.info("Agent ready")

+  -- Check for saved session and notify user
+  if agent.has_saved_session() then
+    vim.schedule(function()
+      local info = agent.get_saved_session_info()
+      if info then
+        add_message("system",
+          string.format("Saved session available (%s). Type /continue to resume.", info.saved_at),
+          "DiagnosticHint")
+        logs.info("Saved session found: " .. (info.prompt or ""):sub(1, 30) .. "...")
+      end
+    end)
+  end
+
+  -- If we have a selection, show it as context
+  if selection and selection.text and selection.text ~= "" then
+    vim.schedule(function()
+      M.add_selection_context(selection)
+    end)
+  end
+
  -- Log provider info
  local ok, codetyper = pcall(require, "codetyper")
  if ok then
    local config = codetyper.get_config()
    local provider = config.llm.provider
-    local model = provider == "claude" and config.llm.claude.model or config.llm.ollama.model
+    local model = "unknown"
+    if provider == "ollama" then
+      model = config.llm.ollama.model
+    elseif provider == "openai" then
+      model = config.llm.openai.model
+    elseif provider == "gemini" then
+      model = config.llm.gemini.model
+    elseif provider == "copilot" then
+      model = config.llm.copilot.model
+    end
    logs.info(string.format("%s (%s)", provider, model))
  end
 end
@@ -671,4 +807,101 @@ function M.is_open()
  return state.is_open
 end

+--- Show the diff review for all changes made in this session
+function M.show_diff_review()
+  local changes_count = agent.get_changes_count()
+  if changes_count == 0 then
+    utils.notify("No changes to review", vim.log.levels.INFO)
+    return
+  end
+  agent.show_diff_review()
+end
+
+--- Add visual selection as context in the chat
+---@param selection table Selection info {text, start_line, end_line, filepath, filename, language}
+function M.add_selection_context(selection)
+  if not state.chat_buf or not vim.api.nvim_buf_is_valid(state.chat_buf) then
+    return
+  end
+
+  state.selection_context = selection
+
+  vim.bo[state.chat_buf].modifiable = true
+
+  local lines = vim.api.nvim_buf_get_lines(state.chat_buf, 0, -1, false)
+
+  -- Format the selection display
+  local location = ""
+  if selection.filename then
+    location = selection.filename
+    if selection.start_line then
+      location = location .. ":" .. selection.start_line
+      if selection.end_line and selection.end_line ~= selection.start_line then
+        location = location .. "-" .. selection.end_line
+      end
+    end
+  end
+
+  local new_lines = {
+    "",
+    "┌─ Selected Code ─────────────────────",
+    "│ " .. location,
+    "│",
+  }
+
+  -- Add the selected code
+  for _, line in ipairs(vim.split(selection.text, "\n")) do
+    table.insert(new_lines, "│ " .. line)
+  end
+
+  table.insert(new_lines, "│")
+  table.insert(new_lines, "└──────────────────────────────────────")
+  table.insert(new_lines, "")
+  table.insert(new_lines, "Describe what you'd like to do with this code.")
+
+  for _, line in ipairs(new_lines) do
+    table.insert(lines, line)
+  end
+
+  vim.api.nvim_buf_set_lines(state.chat_buf, 0, -1, false, lines)
+  vim.bo[state.chat_buf].modifiable = false
+
+  -- Scroll to bottom
+  if state.chat_win and vim.api.nvim_win_is_valid(state.chat_win) then
+    local line_count = vim.api.nvim_buf_line_count(state.chat_buf)
+    vim.api.nvim_win_set_cursor(state.chat_win, { line_count, 0 })
+  end
+
+  -- Also add the file to referenced_files for context
+  if selection.filepath and selection.filepath ~= "" then
+    state.referenced_files[selection.filename or "selection"] = selection.filepath
+  end
+
+  logs.info("Selection added: " .. location)
+end
+
+--- Get selection context for agent prompt
+---@return string|nil Selection context string
+function M.get_selection_context()
+  if not state.selection_context or not state.selection_context.text then
+    return nil
+  end
+
+  local sel = state.selection_context
+  local location = sel.filename or "unknown"
+  if sel.start_line then
+    location = location .. ":" .. sel.start_line
+    if sel.end_line and sel.end_line ~= sel.start_line then
+      location = location .. "-" .. sel.end_line
+    end
+  end
+
+  return string.format(
+    "SELECTED CODE (%s):\n```%s\n%s\n```",
+    location,
+    sel.language or "",
+    sel.text
+  )
+end
+
 return M
--- a/lua/codetyper/adapters/nvim/ui/context_modal.lua
+++ b/lua/codetyper/adapters/nvim/ui/context_modal.lua
@@ -0,0 +1,381 @@
+---@mod codetyper.agent.context_modal Modal for additional context input
+---@brief [[
+--- Opens a floating window for user to provide additional context
+--- when the LLM requests more information.
+---@brief ]]
+
+local M = {}
+
+---@class ContextModalState
+---@field buf number|nil Buffer number
+---@field win number|nil Window number
+---@field original_event table|nil Original prompt event
+---@field callback function|nil Callback with additional context
+---@field llm_response string|nil LLM's response asking for context
+
+local state = {
+	buf = nil,
+	win = nil,
+	original_event = nil,
+	callback = nil,
+	llm_response = nil,
+	attached_files = nil,
+}
+
+--- Close the context modal
+function M.close()
+	if state.win and vim.api.nvim_win_is_valid(state.win) then
+		vim.api.nvim_win_close(state.win, true)
+	end
+	if state.buf and vim.api.nvim_buf_is_valid(state.buf) then
+		vim.api.nvim_buf_delete(state.buf, { force = true })
+	end
+	state.win = nil
+	state.buf = nil
+	state.original_event = nil
+	state.callback = nil
+	state.llm_response = nil
+end
+
+--- Submit the additional context
+local function submit()
+	if not state.buf or not vim.api.nvim_buf_is_valid(state.buf) then
+		return
+	end
+
+	local lines = vim.api.nvim_buf_get_lines(state.buf, 0, -1, false)
+	local additional_context = table.concat(lines, "\n")
+
+	-- Trim whitespace
+	additional_context = additional_context:match("^%s*(.-)%s*$") or additional_context
+
+	if additional_context == "" then
+		M.close()
+		return
+	end
+
+	local original_event = state.original_event
+	local callback = state.callback
+
+	M.close()
+
+	if callback and original_event then
+		-- Pass attached_files as third optional parameter
+		callback(original_event, additional_context, state.attached_files)
+	end
+end
+
+
+--- Parse requested file paths from LLM response and resolve to full paths
+local function parse_requested_files(response)
+	if not response or response == "" then
+		return {}
+	end
+
+	local cwd = vim.fn.getcwd()
+	local candidates = {}
+	local seen = {}
+
+	for path in response:gmatch("`([%w%._%-%/]+%.[%w_]+)`") do
+		if not seen[path] then
+			table.insert(candidates, path)
+			seen[path] = true
+		end
+	end
+	for path in response:gmatch("([%w%._%-%/]+%.[%w_]+)") do
+		if not seen[path] then
+			table.insert(candidates, path)
+			seen[path] = true
+		end
+	end
+
+	-- Resolve to full paths using cwd and glob
+	local resolved = {}
+	for _, p in ipairs(candidates) do
+		local full = nil
+		if p:sub(1,1) == "/" and vim.fn.filereadable(p) == 1 then
+			full = p
+		else
+			local try1 = cwd .. "/" .. p
+			if vim.fn.filereadable(try1) == 1 then
+				full = try1
+			else
+				local tail = p:match("[^/]+$") or p
+				local matches = vim.fn.globpath(cwd, "**/" .. tail, false, true)
+				if matches and #matches > 0 then
+					full = matches[1]
+				end
+			end
+		end
+		if full and vim.fn.filereadable(full) == 1 then
+			table.insert(resolved, full)
+		end
+	end
+	return resolved
+end
+
+
+--- Attach parsed files into the modal buffer and remember them for submission
+local function attach_requested_files()
+	if not state.llm_response or state.llm_response == "" then
+		return
+	end
+	local files = parse_requested_files(state.llm_response)
+	if #files == 0 then
+		local ui_prompts = require("codetyper.prompts.agents.modal").ui
+		vim.api.nvim_buf_set_lines(state.buf, vim.api.nvim_buf_line_count(state.buf), -1, false, ui_prompts.files_header)
+		return
+	end
+
+	state.attached_files = state.attached_files or {}
+
+	for _, full in ipairs(files) do
+		local ok, lines = pcall(vim.fn.readfile, full)
+		if ok and lines and #lines > 0 then
+			table.insert(state.attached_files, { path = vim.fn.fnamemodify(full, ":~:." ) , full_path = full, content = table.concat(lines, "\n") })
+			local insert_at = vim.api.nvim_buf_line_count(state.buf)
+			vim.api.nvim_buf_set_lines(state.buf, insert_at, insert_at, false, { "", "-- Attached: " .. full .. " --" })
+			for i, l in ipairs(lines) do
+				vim.api.nvim_buf_set_lines(state.buf, insert_at + 1 + i, insert_at + 1 + i, false, { l })
+			end
+		else
+			local insert_at = vim.api.nvim_buf_line_count(state.buf)
+			vim.api.nvim_buf_set_lines(state.buf, insert_at, insert_at, false, { "", "-- Failed to read: " .. full .. " --" })
+		end
+	end
+	-- Move cursor to end and enter insert mode
+	vim.api.nvim_win_set_cursor(state.win, { vim.api.nvim_buf_line_count(state.buf), 0 })
+	vim.cmd("startinsert")
+end
+
+--- Open the context modal
+---@param original_event table Original prompt event
+---@param llm_response string LLM's response asking for context
+---@param callback function(event: table, additional_context: string, attached_files?: table)
+---@param suggested_commands table[]|nil Optional list of {label,cmd} suggested shell commands
+function M.open(original_event, llm_response, callback, suggested_commands)
+	-- Close any existing modal
+	M.close()
+
+	state.original_event = original_event
+	state.llm_response = llm_response
+	state.callback = callback
+
+	-- Calculate window size
+	local width = math.min(80, vim.o.columns - 10)
+	local height = 10
+
+	-- Create buffer
+	state.buf = vim.api.nvim_create_buf(false, true)
+	vim.bo[state.buf].buftype = "nofile"
+	vim.bo[state.buf].bufhidden = "wipe"
+	vim.bo[state.buf].filetype = "markdown"
+
+	-- Create window
+	local row = math.floor((vim.o.lines - height) / 2)
+	local col = math.floor((vim.o.columns - width) / 2)
+
+	state.win = vim.api.nvim_open_win(state.buf, true, {
+		relative = "editor",
+		row = row,
+		col = col,
+		width = width,
+		height = height,
+		style = "minimal",
+		border = "rounded",
+		title = " Additional Context Needed ",
+		title_pos = "center",
+	})
+
+	-- Set window options
+	vim.wo[state.win].wrap = true
+	vim.wo[state.win].cursorline = true
+
+	local ui_prompts = require("codetyper.prompts.agents.modal").ui
+
+	-- Add header showing what the LLM said
+	local header_lines = {
+		ui_prompts.llm_response_header,
+	}
+
+	-- Truncate LLM response for display
+	local response_preview = llm_response or ""
+	if #response_preview > 200 then
+		response_preview = response_preview:sub(1, 200) .. "..."
+	end
+	for line in response_preview:gmatch("[^\n]+") do
+		table.insert(header_lines, "-- " .. line)
+	end
+
+	-- If suggested commands were provided, show them in the header
+	if suggested_commands and #suggested_commands > 0 then
+		table.insert(header_lines, "")
+		table.insert(header_lines, ui_prompts.suggested_commands_header)
+		for i, s in ipairs(suggested_commands) do
+			local label = s.label or s.cmd
+			table.insert(header_lines, string.format("[%d] %s: %s", i, label, s.cmd))
+		end
+		table.insert(header_lines, ui_prompts.commands_hint)
+	end
+
+	table.insert(header_lines, "")
+	table.insert(header_lines, ui_prompts.input_header)
+	table.insert(header_lines, "")
+
+	vim.api.nvim_buf_set_lines(state.buf, 0, -1, false, header_lines)
+
+	-- Move cursor to the end
+	vim.api.nvim_win_set_cursor(state.win, { #header_lines, 0 })
+
+	-- Set up keymaps
+	local opts = { buffer = state.buf, noremap = true, silent = true }
+
+	-- Submit with Ctrl+Enter or <leader>s
+	vim.keymap.set("n", "<C-CR>", submit, opts)
+	vim.keymap.set("i", "<C-CR>", submit, opts)
+	vim.keymap.set("n", "<leader>s", submit, opts)
+	vim.keymap.set("n", "<CR><CR>", submit, opts)
+
+	-- Attach parsed files (from LLM response)
+	vim.keymap.set("n", "a", function()
+		attach_requested_files()
+	end, opts)
+
+	-- Confirm and submit with 'c' (convenient when doing question round)
+	vim.keymap.set("n", "c", submit, opts)
+
+	-- Quick run of project inspection from modal with <leader>r / <C-r> in insert mode
+	vim.keymap.set("n", "<leader>r", run_project_inspect, opts)
+	vim.keymap.set("i", "<C-r>", function()
+		vim.schedule(run_project_inspect)
+	end, { buffer = state.buf, noremap = true, silent = true })
+
+	-- If suggested commands provided, create per-command keymaps <leader>1..n to run them
+	state.suggested_commands = suggested_commands
+	if suggested_commands and #suggested_commands > 0 then
+		for i, s in ipairs(suggested_commands) do
+			local key = "<leader>" .. tostring(i)
+			vim.keymap.set("n", key, function()
+				-- run this single command and append output
+				if not s or not s.cmd then
+					return
+				end
+				local ok, out = pcall(vim.fn.systemlist, s.cmd)
+				local insert_at = vim.api.nvim_buf_line_count(state.buf)
+				vim.api.nvim_buf_set_lines(state.buf, insert_at, insert_at, false, { "", "-- Output: " .. s.cmd .. " --" })
+				if ok and out and #out > 0 then
+					for j, line in ipairs(out) do
+						vim.api.nvim_buf_set_lines(state.buf, insert_at + j, insert_at + j, false, { line })
+					end
+				else
+					vim.api.nvim_buf_set_lines(state.buf, insert_at + 1, insert_at + 1, false, { "(no output or command failed)" })
+				end
+				vim.api.nvim_win_set_cursor(state.win, { vim.api.nvim_buf_line_count(state.buf), 0 })
+				vim.cmd("startinsert")
+			end, opts)
+		end
+		-- Also map <leader>0 to run all suggested commands
+		vim.keymap.set("n", "<leader>0", function()
+			for _, s in ipairs(suggested_commands) do
+				pcall(function()
+					local ok, out = pcall(vim.fn.systemlist, s.cmd)
+					local insert_at = vim.api.nvim_buf_line_count(state.buf)
+					vim.api.nvim_buf_set_lines(state.buf, insert_at, insert_at, false, { "", "-- Output: " .. s.cmd .. " --" })
+					if ok and out and #out > 0 then
+						for j, line in ipairs(out) do
+							vim.api.nvim_buf_set_lines(state.buf, insert_at + j, insert_at + j, false, { line })
+						end
+					else
+						vim.api.nvim_buf_set_lines(state.buf, insert_at + 1, insert_at + 1, false, { "(no output or command failed)" })
+					end
+				end)
+			end
+			vim.api.nvim_win_set_cursor(state.win, { vim.api.nvim_buf_line_count(state.buf), 0 })
+			vim.cmd("startinsert")
+		end, opts)
+	end
+
+	-- Close with Esc or q
+	vim.keymap.set("n", "<Esc>", M.close, opts)
+	vim.keymap.set("n", "q", M.close, opts)
+
+	-- Start in insert mode
+	vim.cmd("startinsert")
+
+	-- Log
+	pcall(function()
+		local logs = require("codetyper.adapters.nvim.ui.logs")
+		logs.add({
+			type = "info",
+			message = "Context modal opened - waiting for user input",
+		})
+	end)
+end
+
+--- Run a small set of safe project inspection commands and insert outputs into the modal buffer
+local function run_project_inspect()
+	if not state.buf or not vim.api.nvim_buf_is_valid(state.buf) then
+		return
+	end
+
+	local cmds = {
+		{ label = "List files (ls -la)", cmd = "ls -la" },
+		{ label = "Git status (git status --porcelain)", cmd = "git status --porcelain" },
+		{ label = "Git top (git rev-parse --show-toplevel)", cmd = "git rev-parse --show-toplevel" },
+		{ label = "Show repo files (git ls-files)", cmd = "git ls-files" },
+	}
+
+	local ui_prompts = require("codetyper.prompts.agents.modal").ui
+	local insert_pos = vim.api.nvim_buf_line_count(state.buf)
+	vim.api.nvim_buf_set_lines(state.buf, insert_pos, insert_pos, false, ui_prompts.project_inspect_header)
+
+	for _, c in ipairs(cmds) do
+		local ok, out = pcall(vim.fn.systemlist, c.cmd)
+		if ok and out and #out > 0 then
+			vim.api.nvim_buf_set_lines(state.buf, insert_pos + 2, insert_pos + 2, false, { "-- " .. c.label .. " --" })
+			for i, line in ipairs(out) do
+				vim.api.nvim_buf_set_lines(state.buf, insert_pos + 2 + i, insert_pos + 2 + i, false, { line })
+			end
+			insert_pos = vim.api.nvim_buf_line_count(state.buf)
+		else
+			vim.api.nvim_buf_set_lines(state.buf, insert_pos + 2, insert_pos + 2, false, { "-- " .. c.label .. " --", "(no output or command failed)" })
+			insert_pos = vim.api.nvim_buf_line_count(state.buf)
+		end
+	end
+
+	-- Move cursor to end
+	vim.api.nvim_win_set_cursor(state.win, { vim.api.nvim_buf_line_count(state.buf), 0 })
+	vim.cmd("startinsert")
+end
+
+-- Provide a keybinding in the modal to run project inspection commands
+pcall(function()
+	if state.buf and vim.api.nvim_buf_is_valid(state.buf) then
+		vim.keymap.set("n", "<leader>r", run_project_inspect, { buffer = state.buf, noremap = true, silent = true })
+		vim.keymap.set("i", "<C-r>", function()
+			vim.schedule(run_project_inspect)
+		end, { buffer = state.buf, noremap = true, silent = true })
+	end
+end)
+
+--- Check if modal is open
+---@return boolean
+function M.is_open()
+	return state.win ~= nil and vim.api.nvim_win_is_valid(state.win)
+end
+
+--- Setup autocmds for the context modal
+function M.setup()
+	local group = vim.api.nvim_create_augroup("CodetypeContextModal", { clear = true })
+
+	-- Close context modal when exiting Neovim
+	vim.api.nvim_create_autocmd("VimLeavePre", {
+		group = group,
+		callback = function()
+			M.close()
+		end,
+		desc = "Close context modal before exiting Neovim",
+	})
+end
+
+return M
--- a/lua/codetyper/adapters/nvim/ui/diff_review.lua
+++ b/lua/codetyper/adapters/nvim/ui/diff_review.lua
@@ -0,0 +1,386 @@
+---@mod codetyper.agent.diff_review Diff review UI for agent changes
+---
+--- Provides a lazygit-style window interface for reviewing all changes
+--- made during an agent session.
+
+local M = {}
+
+local utils = require("codetyper.support.utils")
+local prompts = require("codetyper.prompts.agents.diff")
+
+
+---@class DiffEntry
+---@field path string File path
+---@field operation string "create"|"edit"|"delete"
+---@field original string|nil Original content (nil for new files)
+---@field modified string New/modified content
+---@field approved boolean Whether change was approved
+---@field applied boolean Whether change was applied
+
+---@class DiffReviewState
+---@field entries DiffEntry[] List of changes
+---@field current_index number Currently selected entry
+---@field list_buf number|nil File list buffer
+---@field list_win number|nil File list window
+---@field diff_buf number|nil Diff view buffer
+---@field diff_win number|nil Diff view window
+---@field is_open boolean Whether review UI is open
+
+local state = {
+  entries = {},
+  current_index = 1,
+  list_buf = nil,
+  list_win = nil,
+  diff_buf = nil,
+  diff_win = nil,
+  is_open = false,
+}
+
+--- Clear all collected diffs
+function M.clear()
+  state.entries = {}
+  state.current_index = 1
+end
+
+--- Add a diff entry
+---@param entry DiffEntry
+function M.add(entry)
+  table.insert(state.entries, entry)
+end
+
+--- Get all entries
+---@return DiffEntry[]
+function M.get_entries()
+  return state.entries
+end
+
+--- Get entry count
+---@return number
+function M.count()
+  return #state.entries
+end
+
+--- Generate unified diff between two strings
+---@param original string|nil
+---@param modified string
+---@param filepath string
+---@return string[]
+local function generate_diff_lines(original, modified, filepath)
+  local lines = {}
+  local filename = vim.fn.fnamemodify(filepath, ":t")
+
+  if not original then
+    -- New file
+    table.insert(lines, "--- /dev/null")
+    table.insert(lines, "+++ b/" .. filename)
+    table.insert(lines, "@@ -0,0 +1," .. #vim.split(modified, "\n") .. " @@")
+    for _, line in ipairs(vim.split(modified, "\n")) do
+      table.insert(lines, "+" .. line)
+    end
+  else
+    -- Modified file - use vim's diff
+    table.insert(lines, "--- a/" .. filename)
+    table.insert(lines, "+++ b/" .. filename)
+
+    local orig_lines = vim.split(original, "\n")
+    local mod_lines = vim.split(modified, "\n")
+
+    -- Simple diff: show removed and added lines
+    local max_lines = math.max(#orig_lines, #mod_lines)
+    local context_start = 1
+    local in_change = false
+
+    for i = 1, max_lines do
+      local orig = orig_lines[i] or ""
+      local mod = mod_lines[i] or ""
+
+      if orig ~= mod then
+        if not in_change then
+          table.insert(lines, string.format("@@ -%d,%d +%d,%d @@",
+            math.max(1, i - 2), math.min(5, #orig_lines - i + 3),
+            math.max(1, i - 2), math.min(5, #mod_lines - i + 3)))
+          in_change = true
+        end
+        if orig ~= "" then
+          table.insert(lines, "-" .. orig)
+        end
+        if mod ~= "" then
+          table.insert(lines, "+" .. mod)
+        end
+      else
+        if in_change then
+          table.insert(lines, " " .. orig)
+          in_change = false
+        end
+      end
+    end
+  end
+
+  return lines
+end
+
+--- Update the diff view for current entry
+local function update_diff_view()
+  if not state.diff_buf or not vim.api.nvim_buf_is_valid(state.diff_buf) then
+    return
+  end
+
+  local entry = state.entries[state.current_index]
+  local ui_prompts = prompts.review
+  if not entry then
+    vim.bo[state.diff_buf].modifiable = true
+    vim.api.nvim_buf_set_lines(state.diff_buf, 0, -1, false, { ui_prompts.messages.no_changes_short })
+    vim.bo[state.diff_buf].modifiable = false
+    return
+  end
+
+  local lines = {}
+
+  -- Header
+  local status_icon = entry.applied and " " or (entry.approved and " " or " ")
+  local op_icon = entry.operation == "create" and "+" or (entry.operation == "delete" and "-" or "~")
+  local current_status = entry.applied and ui_prompts.status.applied
+      or (entry.approved and ui_prompts.status.approved or ui_prompts.status.pending)
+
+  table.insert(lines, string.format(ui_prompts.diff_header.top,
+    status_icon, op_icon, vim.fn.fnamemodify(entry.path, ":t")))
+  table.insert(lines, string.format(ui_prompts.diff_header.path, entry.path))
+  table.insert(lines, string.format(ui_prompts.diff_header.op, entry.operation))
+  table.insert(lines, string.format(ui_prompts.diff_header.status, current_status))
+  table.insert(lines, ui_prompts.diff_header.bottom)
+  table.insert(lines, "")
+
+  -- Diff content
+  local diff_lines = generate_diff_lines(entry.original, entry.modified, entry.path)
+  for _, line in ipairs(diff_lines) do
+    table.insert(lines, line)
+  end
+
+  vim.bo[state.diff_buf].modifiable = true
+  vim.api.nvim_buf_set_lines(state.diff_buf, 0, -1, false, lines)
+  vim.bo[state.diff_buf].modifiable = false
+  vim.bo[state.diff_buf].filetype = "diff"
+end
+
+--- Update the file list
+local function update_file_list()
+  if not state.list_buf or not vim.api.nvim_buf_is_valid(state.list_buf) then
+    return
+  end
+
+  local ui_prompts = prompts.review
+  local lines = {}
+  table.insert(lines, string.format(ui_prompts.list_menu.top, #state.entries))
+  for _, item in ipairs(ui_prompts.list_menu.items) do
+    table.insert(lines, item)
+  end
+  table.insert(lines, ui_prompts.list_menu.bottom)
+  table.insert(lines, "")
+
+  for i, entry in ipairs(state.entries) do
+    local prefix = (i == state.current_index) and "▶ " or "  "
+    local status = entry.applied and "" or (entry.approved and "" or "○")
+    local op = entry.operation == "create" and "[+]" or (entry.operation == "delete" and "[-]" or "[~]")
+    local filename = vim.fn.fnamemodify(entry.path, ":t")
+
+    table.insert(lines, string.format("%s%s %s %s", prefix, status, op, filename))
+  end
+
+  if #state.entries == 0 then
+    table.insert(lines, ui_prompts.messages.no_changes)
+  end
+
+  vim.bo[state.list_buf].modifiable = true
+  vim.api.nvim_buf_set_lines(state.list_buf, 0, -1, false, lines)
+  vim.bo[state.list_buf].modifiable = false
+
+  -- Highlight current line
+  if state.list_win and vim.api.nvim_win_is_valid(state.list_win) then
+    local target_line = 9 + state.current_index - 1
+    if target_line <= vim.api.nvim_buf_line_count(state.list_buf) then
+      vim.api.nvim_win_set_cursor(state.list_win, { target_line, 0 })
+    end
+  end
+end
+
+--- Navigate to next entry
+function M.next()
+  if state.current_index < #state.entries then
+    state.current_index = state.current_index + 1
+    update_file_list()
+    update_diff_view()
+  end
+end
+
+--- Navigate to previous entry
+function M.prev()
+  if state.current_index > 1 then
+    state.current_index = state.current_index - 1
+    update_file_list()
+    update_diff_view()
+  end
+end
+
+--- Approve current entry
+function M.approve_current()
+  local entry = state.entries[state.current_index]
+  if entry and not entry.applied then
+    entry.approved = true
+    update_file_list()
+    update_diff_view()
+  end
+end
+
+--- Reject current entry
+function M.reject_current()
+  local entry = state.entries[state.current_index]
+  if entry and not entry.applied then
+    entry.approved = false
+    update_file_list()
+    update_diff_view()
+  end
+end
+
+--- Approve all entries
+function M.approve_all()
+  for _, entry in ipairs(state.entries) do
+    if not entry.applied then
+      entry.approved = true
+    end
+  end
+  update_file_list()
+  update_diff_view()
+end
+
+--- Apply approved changes
+function M.apply_approved()
+  local applied_count = 0
+
+  for _, entry in ipairs(state.entries) do
+    if entry.approved and not entry.applied then
+      if entry.operation == "create" or entry.operation == "edit" then
+        local ok = utils.write_file(entry.path, entry.modified)
+        if ok then
+          entry.applied = true
+          applied_count = applied_count + 1
+        end
+      elseif entry.operation == "delete" then
+        local ok = os.remove(entry.path)
+        if ok then
+          entry.applied = true
+          applied_count = applied_count + 1
+        end
+      end
+    end
+  end
+
+  update_file_list()
+  update_diff_view()
+
+  if applied_count > 0 then
+    utils.notify(string.format(prompts.review.messages.applied_count, applied_count))
+  end
+
+  return applied_count
+end
+
+--- Open the diff review UI
+function M.open()
+  if state.is_open then
+    return
+  end
+
+  if #state.entries == 0 then
+    utils.notify(prompts.review.messages.no_changes_short, vim.log.levels.INFO)
+    return
+  end
+
+  -- Create list buffer
+  state.list_buf = vim.api.nvim_create_buf(false, true)
+  vim.bo[state.list_buf].buftype = "nofile"
+  vim.bo[state.list_buf].bufhidden = "wipe"
+  vim.bo[state.list_buf].swapfile = false
+
+  -- Create diff buffer
+  state.diff_buf = vim.api.nvim_create_buf(false, true)
+  vim.bo[state.diff_buf].buftype = "nofile"
+  vim.bo[state.diff_buf].bufhidden = "wipe"
+  vim.bo[state.diff_buf].swapfile = false
+
+  -- Create layout: list on left (30 cols), diff on right
+  vim.cmd("tabnew")
+  state.diff_win = vim.api.nvim_get_current_win()
+  vim.api.nvim_win_set_buf(state.diff_win, state.diff_buf)
+
+  vim.cmd("topleft vsplit")
+  state.list_win = vim.api.nvim_get_current_win()
+  vim.api.nvim_win_set_buf(state.list_win, state.list_buf)
+  vim.api.nvim_win_set_width(state.list_win, 35)
+
+  -- Window options
+  for _, win in ipairs({ state.list_win, state.diff_win }) do
+    vim.wo[win].number = false
+    vim.wo[win].relativenumber = false
+    vim.wo[win].signcolumn = "no"
+    vim.wo[win].wrap = false
+    vim.wo[win].cursorline = true
+  end
+
+  -- Set up keymaps for list buffer
+  local list_opts = { buffer = state.list_buf, noremap = true, silent = true }
+  vim.keymap.set("n", "j", M.next, list_opts)
+  vim.keymap.set("n", "k", M.prev, list_opts)
+  vim.keymap.set("n", "<Down>", M.next, list_opts)
+  vim.keymap.set("n", "<Up>", M.prev, list_opts)
+  vim.keymap.set("n", "<CR>", function() vim.api.nvim_set_current_win(state.diff_win) end, list_opts)
+  vim.keymap.set("n", "a", M.approve_current, list_opts)
+  vim.keymap.set("n", "r", M.reject_current, list_opts)
+  vim.keymap.set("n", "A", M.approve_all, list_opts)
+  vim.keymap.set("n", "q", M.close, list_opts)
+  vim.keymap.set("n", "<Esc>", M.close, list_opts)
+
+  -- Set up keymaps for diff buffer
+  local diff_opts = { buffer = state.diff_buf, noremap = true, silent = true }
+  vim.keymap.set("n", "j", M.next, diff_opts)
+  vim.keymap.set("n", "k", M.prev, diff_opts)
+  vim.keymap.set("n", "<Tab>", function() vim.api.nvim_set_current_win(state.list_win) end, diff_opts)
+  vim.keymap.set("n", "a", M.approve_current, diff_opts)
+  vim.keymap.set("n", "r", M.reject_current, diff_opts)
+  vim.keymap.set("n", "A", M.approve_all, diff_opts)
+  vim.keymap.set("n", "q", M.close, diff_opts)
+  vim.keymap.set("n", "<Esc>", M.close, diff_opts)
+
+  state.is_open = true
+  state.current_index = 1
+
+  -- Initial render
+  update_file_list()
+  update_diff_view()
+
+  -- Focus list window
+  vim.api.nvim_set_current_win(state.list_win)
+end
+
+--- Close the diff review UI
+function M.close()
+  if not state.is_open then
+    return
+  end
+
+  -- Close the tab (which closes both windows)
+  pcall(vim.cmd, "tabclose")
+
+  state.list_buf = nil
+  state.list_win = nil
+  state.diff_buf = nil
+  state.diff_win = nil
+  state.is_open = false
+end
+
+--- Check if review UI is open
+---@return boolean
+function M.is_open()
+  return state.is_open
+end
+
+return M
--- a/lua/codetyper/adapters/nvim/ui/logs.lua
+++ b/lua/codetyper/adapters/nvim/ui/logs.lua
@@ -4,6 +4,9 @@

 local M = {}

+local params = require("codetyper.params.agents.logs")
+
+
 ---@class LogEntry
 ---@field timestamp string ISO timestamp
 ---@field level string "info" | "debug" | "request" | "response" | "tool" | "error"
@@ -119,14 +122,7 @@ end
 ---@param status string "start" | "success" | "error" | "approval"
 ---@param details? string Additional details
 function M.tool(tool_name, status, details)
-  local icons = {
-    start = "->",
-    success = "OK",
-    error = "ERR",
-    approval = "??",
-    approved = "YES",
-    rejected = "NO",
-  }
+  local icons = params.icons

  local msg = string.format("[%s] %s", icons[status] or status, tool_name)
  if details then
@@ -165,10 +161,83 @@ function M.add(entry)
  M.log(entry.type or "info", entry.message or "", entry.data)
 end

--- Log thinking/reasoning step
+--- Log thinking/reasoning step (Claude Code style)
 ---@param step string Description of what's happening
 function M.thinking(step)
-  M.log("debug", "> " .. step)
+  M.log("thinking", step)
+end
+
+--- Log a reasoning/explanation message (shown prominently)
+---@param message string The reasoning message
+function M.reason(message)
+  M.log("reason", message)
+end
+
+--- Log file read operation
+---@param filepath string Path of file being read
+---@param lines? number Number of lines read
+function M.read(filepath, lines)
+  local msg = string.format("Read(%s)", vim.fn.fnamemodify(filepath, ":~:."))
+  if lines then
+    msg = msg .. string.format("\n  ⎿  Read %d lines", lines)
+  end
+  M.log("action", msg)
+end
+
+--- Log explore/search operation
+---@param description string What we're exploring
+function M.explore(description)
+  M.log("action", string.format("Explore(%s)", description))
+end
+
+--- Log explore done
+---@param tool_uses number Number of tool uses
+---@param tokens number Tokens used
+---@param duration number Duration in seconds
+function M.explore_done(tool_uses, tokens, duration)
+  M.log("result", string.format("  ⎿  Done (%d tool uses · %.1fk tokens · %.1fs)", tool_uses, tokens / 1000, duration))
+end
+
+--- Log update/edit operation
+---@param filepath string Path of file being edited
+---@param added? number Lines added
+---@param removed? number Lines removed
+function M.update(filepath, added, removed)
+  local msg = string.format("Update(%s)", vim.fn.fnamemodify(filepath, ":~:."))
+  if added or removed then
+    local parts = {}
+    if added and added > 0 then
+      table.insert(parts, string.format("Added %d lines", added))
+    end
+    if removed and removed > 0 then
+      table.insert(parts, string.format("Removed %d lines", removed))
+    end
+    if #parts > 0 then
+      msg = msg .. "\n  ⎿  " .. table.concat(parts, ", ")
+    end
+  end
+  M.log("action", msg)
+end
+
+--- Log a task/step that's in progress
+---@param task string Task name
+---@param status string Status message (optional)
+function M.task(task, status)
+  local msg = task
+  if status then
+    msg = msg .. " " .. status
+  end
+  M.log("task", msg)
+end
+
+--- Log task completion
+---@param next_task? string Next task (optional)
+function M.task_done(next_task)
+  local msg = "  ⎿  Done"
+  if next_task then
+    msg = msg .. "\n✶ " .. next_task
+  end
+  M.log("result", msg)
 end

 --- Register a listener for new log entries
@@ -223,16 +292,81 @@ end
 ---@param entry LogEntry
 ---@return string
 function M.format_entry(entry)
-  local level_prefix = ({
-    info = "i",
-    debug = ".",
-    request = ">",
-    response = "<",
-    tool = "T",
-    error = "!",
-  })[entry.level] or "?"
+  -- Claude Code style formatting for thinking/action entries
+  local thinking_types = params.thinking_types
+  local is_thinking = vim.tbl_contains(thinking_types, entry.level)

-  return string.format("[%s] %s %s", entry.timestamp, level_prefix, entry.message)
+  if is_thinking then
+    local prefix = params.thinking_prefixes[entry.level] or "⏺"
+
+    if prefix ~= "" then
+      return prefix .. " " .. entry.message
+    else
+      return entry.message
+    end
+  end
+
+  -- Traditional log format for other types
+  local level_prefix = params.level_icons[entry.level] or "?"
+
+  local base = string.format("[%s] %s %s", entry.timestamp, level_prefix, entry.message)
+
+  -- If this is a response entry with raw_response, append the full response
+  if entry.data and entry.data.raw_response then
+    local response = entry.data.raw_response
+    -- Add separator and the full response
+    base = base .. "\n" .. string.rep("-", 40) .. "\n" .. response .. "\n" .. string.rep("-", 40)
+  end
+
+  return base
+end
+
+--- Format entry for display in chat (compact Claude Code style)
+---@param entry LogEntry
+---@return string|nil Formatted string or nil to skip
+function M.format_for_chat(entry)
+  -- Skip certain log types in chat view
+  local skip_types = { "debug", "queue", "patch" }
+  if vim.tbl_contains(skip_types, entry.level) then
+    return nil
+  end
+
+  -- Claude Code style formatting
+  local thinking_types = params.thinking_types
+  if vim.tbl_contains(thinking_types, entry.level) then
+    local prefix = params.thinking_prefixes[entry.level] or "⏺"
+
+    if prefix ~= "" then
+      return prefix .. " " .. entry.message
+    else
+      return entry.message
+    end
+  end
+
+  -- Tool logs
+  if entry.level == "tool" then
+    return "⏺ " .. entry.message:gsub("^%[.-%] ", "")
+  end
+
+  -- Info/success
+  if entry.level == "info" or entry.level == "success" then
+    return "⏺ " .. entry.message
+  end
+
+  -- Errors
+  if entry.level == "error" then
+    return "⚠ " .. entry.message
+  end
+
+  -- Request/response (compact)
+  if entry.level == "request" then
+    return "⏺ " .. entry.message
+  end
+  if entry.level == "response" then
+    return "  ⎿ " .. entry.message
+  end
+
+  return nil
 end

 --- Estimate token count for a string (rough approximation)
--- a/lua/codetyper/adapters/nvim/ui/logs_panel.lua
+++ b/lua/codetyper/adapters/nvim/ui/logs_panel.lua
@@ -0,0 +1,382 @@
+---@mod codetyper.logs_panel Standalone logs panel for code generation
+---
+--- Shows real-time logs when generating code via /@ @/ prompts.
+
+local M = {}
+
+local logs = require("codetyper.adapters.nvim.ui.logs")
+local queue = require("codetyper.core.events.queue")
+
+---@class LogsPanelState
+---@field buf number|nil Logs buffer
+---@field win number|nil Logs window
+---@field queue_buf number|nil Queue buffer
+---@field queue_win number|nil Queue window
+---@field is_open boolean Whether the panel is open
+---@field listener_id number|nil Listener ID for logs
+---@field queue_listener_id number|nil Listener ID for queue
+
+local state = {
+  buf = nil,
+  win = nil,
+  queue_buf = nil,
+  queue_win = nil,
+  is_open = false,
+  listener_id = nil,
+  queue_listener_id = nil,
+}
+
+--- Namespace for highlights
+local ns_logs = vim.api.nvim_create_namespace("codetyper_logs_panel")
+local ns_queue = vim.api.nvim_create_namespace("codetyper_queue_panel")
+
+--- Fixed dimensions
+local LOGS_WIDTH = 60
+local QUEUE_HEIGHT = 8
+
+--- Add a log entry to the buffer
+---@param entry table Log entry
+local function add_log_entry(entry)
+  if not state.buf or not vim.api.nvim_buf_is_valid(state.buf) then
+    return
+  end
+
+  vim.schedule(function()
+    if not state.buf or not vim.api.nvim_buf_is_valid(state.buf) then
+      return
+    end
+
+    -- Handle clear event
+    if entry.level == "clear" then
+      vim.bo[state.buf].modifiable = true
+      vim.api.nvim_buf_set_lines(state.buf, 0, -1, false, {
+        "Generation Logs",
+        string.rep("─", LOGS_WIDTH - 2),
+        "",
+      })
+      vim.bo[state.buf].modifiable = false
+      return
+    end
+
+    vim.bo[state.buf].modifiable = true
+
+    local formatted = logs.format_entry(entry)
+    local formatted_lines = vim.split(formatted, "\n", { plain = true })
+    local line_count = vim.api.nvim_buf_line_count(state.buf)
+
+    vim.api.nvim_buf_set_lines(state.buf, -1, -1, false, formatted_lines)
+
+    -- Apply highlighting based on level
+    local hl_map = {
+      info = "DiagnosticInfo",
+      debug = "Comment",
+      request = "DiagnosticWarn",
+      response = "DiagnosticOk",
+      tool = "DiagnosticHint",
+      error = "DiagnosticError",
+    }
+
+    local hl = hl_map[entry.level] or "Normal"
+    for i = 0, #formatted_lines - 1 do
+      vim.api.nvim_buf_add_highlight(state.buf, ns_logs, hl, line_count + i, 0, -1)
+    end
+
+    vim.bo[state.buf].modifiable = false
+
+    -- Auto-scroll logs
+    if state.win and vim.api.nvim_win_is_valid(state.win) then
+      local new_count = vim.api.nvim_buf_line_count(state.buf)
+      pcall(vim.api.nvim_win_set_cursor, state.win, { new_count, 0 })
+    end
+  end)
+end
+
+--- Update the title with token counts
+local function update_title()
+  if not state.win or not vim.api.nvim_win_is_valid(state.win) then
+    return
+  end
+
+  local prompt_tokens, response_tokens = logs.get_token_totals()
+  local provider, model = logs.get_provider_info()
+
+  if provider and state.buf and vim.api.nvim_buf_is_valid(state.buf) then
+    vim.bo[state.buf].modifiable = true
+    local title = string.format("%s | %d/%d tokens", (provider or ""):upper(), prompt_tokens, response_tokens)
+    vim.api.nvim_buf_set_lines(state.buf, 0, 1, false, { title })
+    vim.bo[state.buf].modifiable = false
+  end
+end
+
+--- Update the queue display
+local function update_queue_display()
+  if not state.queue_buf or not vim.api.nvim_buf_is_valid(state.queue_buf) then
+    return
+  end
+
+  vim.schedule(function()
+    if not state.queue_buf or not vim.api.nvim_buf_is_valid(state.queue_buf) then
+      return
+    end
+
+    vim.bo[state.queue_buf].modifiable = true
+
+    local lines = {
+      "Queue",
+      string.rep("─", LOGS_WIDTH - 2),
+    }
+
+    -- Get all events (pending and processing)
+    local pending = queue.get_pending()
+    local processing = queue.get_processing()
+
+    -- Add processing events first
+    for _, event in ipairs(processing) do
+      local filename = vim.fn.fnamemodify(event.target_path or "", ":t")
+      local line_num = event.range and event.range.start_line or 0
+      local prompt_preview = (event.prompt_content or ""):sub(1, 25):gsub("\n", " ")
+      if #(event.prompt_content or "") > 25 then
+        prompt_preview = prompt_preview .. "..."
+      end
+      table.insert(lines, string.format("▶ %s:%d %s", filename, line_num, prompt_preview))
+    end
+
+    -- Add pending events
+    for _, event in ipairs(pending) do
+      local filename = vim.fn.fnamemodify(event.target_path or "", ":t")
+      local line_num = event.range and event.range.start_line or 0
+      local prompt_preview = (event.prompt_content or ""):sub(1, 25):gsub("\n", " ")
+      if #(event.prompt_content or "") > 25 then
+        prompt_preview = prompt_preview .. "..."
+      end
+      table.insert(lines, string.format("○ %s:%d %s", filename, line_num, prompt_preview))
+    end
+
+    if #pending == 0 and #processing == 0 then
+      table.insert(lines, "  (empty)")
+    end
+
+    vim.api.nvim_buf_set_lines(state.queue_buf, 0, -1, false, lines)
+
+    -- Apply highlights
+    vim.api.nvim_buf_clear_namespace(state.queue_buf, ns_queue, 0, -1)
+    vim.api.nvim_buf_add_highlight(state.queue_buf, ns_queue, "Title", 0, 0, -1)
+    vim.api.nvim_buf_add_highlight(state.queue_buf, ns_queue, "Comment", 1, 0, -1)
+
+    local line_idx = 2
+    for _ = 1, #processing do
+      vim.api.nvim_buf_add_highlight(state.queue_buf, ns_queue, "DiagnosticWarn", line_idx, 0, 1)
+      vim.api.nvim_buf_add_highlight(state.queue_buf, ns_queue, "String", line_idx, 2, -1)
+      line_idx = line_idx + 1
+    end
+    for _ = 1, #pending do
+      vim.api.nvim_buf_add_highlight(state.queue_buf, ns_queue, "Comment", line_idx, 0, 1)
+      vim.api.nvim_buf_add_highlight(state.queue_buf, ns_queue, "Normal", line_idx, 2, -1)
+      line_idx = line_idx + 1
+    end
+
+    vim.bo[state.queue_buf].modifiable = false
+  end)
+end
+
+--- Open the logs panel
+function M.open()
+  if state.is_open then
+    return
+  end
+
+  -- Clear previous logs
+  logs.clear()
+
+  -- Create logs buffer
+  state.buf = vim.api.nvim_create_buf(false, true)
+  vim.bo[state.buf].buftype = "nofile"
+  vim.bo[state.buf].bufhidden = "hide"
+  vim.bo[state.buf].swapfile = false
+
+  -- Create window on the right
+  vim.cmd("botright vsplit")
+  state.win = vim.api.nvim_get_current_win()
+  vim.api.nvim_win_set_buf(state.win, state.buf)
+  vim.api.nvim_win_set_width(state.win, LOGS_WIDTH)
+
+  -- Window options for logs
+  vim.wo[state.win].number = false
+  vim.wo[state.win].relativenumber = false
+  vim.wo[state.win].signcolumn = "no"
+  vim.wo[state.win].wrap = true
+  vim.wo[state.win].linebreak = true
+  vim.wo[state.win].winfixwidth = true
+  vim.wo[state.win].cursorline = false
+
+  -- Set initial content for logs
+  vim.bo[state.buf].modifiable = true
+  vim.api.nvim_buf_set_lines(state.buf, 0, -1, false, {
+    "Generation Logs",
+    string.rep("─", LOGS_WIDTH - 2),
+    "",
+  })
+  vim.bo[state.buf].modifiable = false
+
+  -- Create queue buffer
+  state.queue_buf = vim.api.nvim_create_buf(false, true)
+  vim.bo[state.queue_buf].buftype = "nofile"
+  vim.bo[state.queue_buf].bufhidden = "hide"
+  vim.bo[state.queue_buf].swapfile = false
+
+  -- Create queue window as horizontal split at bottom of logs window
+  vim.cmd("belowright split")
+  state.queue_win = vim.api.nvim_get_current_win()
+  vim.api.nvim_win_set_buf(state.queue_win, state.queue_buf)
+  vim.api.nvim_win_set_height(state.queue_win, QUEUE_HEIGHT)
+
+  -- Window options for queue
+  vim.wo[state.queue_win].number = false
+  vim.wo[state.queue_win].relativenumber = false
+  vim.wo[state.queue_win].signcolumn = "no"
+  vim.wo[state.queue_win].wrap = true
+  vim.wo[state.queue_win].linebreak = true
+  vim.wo[state.queue_win].winfixheight = true
+  vim.wo[state.queue_win].cursorline = false
+
+  -- Setup keymaps for logs buffer
+  local opts = { buffer = state.buf, noremap = true, silent = true }
+  vim.keymap.set("n", "q", M.close, opts)
+  vim.keymap.set("n", "<Esc>", M.close, opts)
+
+  -- Setup keymaps for queue buffer
+  local queue_opts = { buffer = state.queue_buf, noremap = true, silent = true }
+  vim.keymap.set("n", "q", M.close, queue_opts)
+  vim.keymap.set("n", "<Esc>", M.close, queue_opts)
+
+  -- Register log listener
+  state.listener_id = logs.add_listener(function(entry)
+    add_log_entry(entry)
+    if entry.level == "response" then
+      vim.schedule(update_title)
+    end
+  end)
+
+  -- Register queue listener
+  state.queue_listener_id = queue.add_listener(function()
+    update_queue_display()
+  end)
+
+  -- Initial queue display
+  update_queue_display()
+
+  state.is_open = true
+
+  -- Return focus to previous window
+  vim.cmd("wincmd p")
+
+  logs.info("Logs panel opened")
+end
+
+--- Close the logs panel
+---@param force? boolean Force close even if not marked as open
+function M.close(force)
+  if not state.is_open and not force then
+    return
+  end
+
+  -- Remove log listener
+  if state.listener_id then
+    pcall(logs.remove_listener, state.listener_id)
+    state.listener_id = nil
+  end
+
+  -- Remove queue listener
+  if state.queue_listener_id then
+    pcall(queue.remove_listener, state.queue_listener_id)
+    state.queue_listener_id = nil
+  end
+
+  -- Close queue window first
+  if state.queue_win then
+    pcall(vim.api.nvim_win_close, state.queue_win, true)
+    state.queue_win = nil
+  end
+
+  -- Close logs window
+  if state.win then
+    pcall(vim.api.nvim_win_close, state.win, true)
+    state.win = nil
+  end
+
+  -- Delete queue buffer
+  if state.queue_buf then
+    pcall(vim.api.nvim_buf_delete, state.queue_buf, { force = true })
+    state.queue_buf = nil
+  end
+
+  -- Delete logs buffer
+  if state.buf then
+    pcall(vim.api.nvim_buf_delete, state.buf, { force = true })
+    state.buf = nil
+  end
+
+  state.is_open = false
+end
+
+--- Toggle the logs panel
+function M.toggle()
+  if state.is_open then
+    M.close()
+  else
+    M.open()
+  end
+end
+
+--- Check if panel is open
+---@return boolean
+function M.is_open()
+  return state.is_open
+end
+
+--- Ensure panel is open (call before starting generation)
+function M.ensure_open()
+  if not state.is_open then
+    M.open()
+  end
+end
+
+--- Setup autocmds for the logs panel
+function M.setup()
+  local group = vim.api.nvim_create_augroup("CodetypeLogsPanel", { clear = true })
+
+  -- Close logs panel when exiting Neovim
+  vim.api.nvim_create_autocmd("VimLeavePre", {
+    group = group,
+    callback = function()
+      -- Force close to ensure cleanup even in edge cases
+      M.close(true)
+    end,
+    desc = "Close logs panel before exiting Neovim",
+  })
+
+  -- Also clean up when QuitPre fires (handles :qa, :wqa, etc.)
+  vim.api.nvim_create_autocmd("QuitPre", {
+    group = group,
+    callback = function()
+      -- Check if this is the last window (about to quit Neovim)
+      local wins = vim.api.nvim_list_wins()
+      local real_wins = 0
+      for _, win in ipairs(wins) do
+        local buf = vim.api.nvim_win_get_buf(win)
+        local buftype = vim.bo[buf].buftype
+        -- Count non-special windows
+        if buftype == "" or buftype == "help" then
+          real_wins = real_wins + 1
+        end
+      end
+      -- If only logs/queue windows remain, close them
+      if real_wins <= 1 then
+        M.close(true)
+      end
+    end,
+    desc = "Close logs panel on quit",
+  })
+end
+
+return M
--- a/lua/codetyper/adapters/nvim/ui/switcher.lua
+++ b/lua/codetyper/adapters/nvim/ui/switcher.lua
@@ -20,8 +20,8 @@ function M.show()
    end

    -- Close current panel first
-    local ask = require("codetyper.ask")
-    local agent_ui = require("codetyper.agent.ui")
+    local ask = require("codetyper.features.ask.engine")
+    local agent_ui = require("codetyper.adapters.nvim.ui.chat")

    if ask.is_open() then
      ask.close()
--- a/lua/codetyper/adapters/nvim/windows.lua
+++ b/lua/codetyper/adapters/nvim/windows.lua
@@ -2,7 +2,7 @@

 local M = {}

-local utils = require("codetyper.utils")
+local utils = require("codetyper.support.utils")

 ---@type number|nil Current coder window ID
 M._coder_win = nil
@@ -18,14 +18,14 @@ M._target_buf = nil

 --- Calculate window width based on configuration
 ---@param config CoderConfig Plugin configuration
---@return number Width in columns
+---@return number Width in columns (minimum 30)
 local function calculate_width(config)
  local width = config.window.width
  if width <= 1 then
-    -- Percentage of total width
-    return math.floor(vim.o.columns * width)
+    -- Percentage of total width (1/4 of screen with minimum 30)
+    return math.max(math.floor(vim.o.columns * width), 30)
  end
-  return math.floor(width)
+  return math.max(math.floor(width), 30)
 end

 --- Open the coder split view
@@ -43,7 +43,7 @@ function M.open_split(target_path, coder_path)
    utils.write_file(coder_path, "")
    
    -- Ensure gitignore is updated when creating a new coder file
-    local gitignore = require("codetyper.gitignore")
+    local gitignore = require("codetyper.support.gitignore")
    gitignore.ensure_ignored()
  end

--- a/lua/codetyper/agent/executor.lua
+++ b/lua/codetyper/agent/executor.lua
@@ -1,294 +0,0 @@
---@mod codetyper.agent.executor Tool executor for agent system
---
--- Executes tools requested by the LLM and returns results.
-
-local M = {}
-local utils = require("codetyper.utils")
-
---@class ExecutionResult
---@field success boolean Whether the execution succeeded
---@field result string Result message or content
---@field requires_approval boolean Whether user approval is needed
---@field diff_data? DiffData Data for diff preview (if requires_approval)
-
---@class DiffData
---@field path string File path
---@field original string Original content
---@field modified string Modified content
---@field operation string Operation type: "edit", "create", "overwrite", "bash"
-
--- Execute a tool and return result via callback
---@param tool_name string Name of the tool to execute
---@param parameters table Tool parameters
---@param callback fun(result: ExecutionResult) Callback with result
-function M.execute(tool_name, parameters, callback)
-  local handlers = {
-    read_file = M.handle_read_file,
-    edit_file = M.handle_edit_file,
-    write_file = M.handle_write_file,
-    bash = M.handle_bash,
-  }
-
-  local handler = handlers[tool_name]
-  if not handler then
-    callback({
-      success = false,
-      result = "Unknown tool: " .. tool_name,
-      requires_approval = false,
-    })
-    return
-  end
-
-  handler(parameters, callback)
-end
-
--- Handle read_file tool
---@param params table { path: string }
---@param callback fun(result: ExecutionResult)
-function M.handle_read_file(params, callback)
-  local path = M.resolve_path(params.path)
-  local content = utils.read_file(path)
-
-  if content then
-    callback({
-      success = true,
-      result = content,
-      requires_approval = false,
-    })
-  else
-    callback({
-      success = false,
-      result = "Could not read file: " .. path,
-      requires_approval = false,
-    })
-  end
-end
-
--- Handle edit_file tool
---@param params table { path: string, find: string, replace: string }
---@param callback fun(result: ExecutionResult)
-function M.handle_edit_file(params, callback)
-  local path = M.resolve_path(params.path)
-  local original = utils.read_file(path)
-
-  if not original then
-    callback({
-      success = false,
-      result = "File not found: " .. path,
-      requires_approval = false,
-    })
-    return
-  end
-
-  -- Try to find and replace the content
-  local escaped_find = utils.escape_pattern(params.find)
-  local new_content, count = original:gsub(escaped_find, params.replace, 1)
-
-  if count == 0 then
-    callback({
-      success = false,
-      result = "Could not find content to replace in: " .. path,
-      requires_approval = false,
-    })
-    return
-  end
-
-  -- Requires user approval - show diff
-  callback({
-    success = true,
-    result = "Edit prepared for: " .. path,
-    requires_approval = true,
-    diff_data = {
-      path = path,
-      original = original,
-      modified = new_content,
-      operation = "edit",
-    },
-  })
-end
-
--- Handle write_file tool
---@param params table { path: string, content: string }
---@param callback fun(result: ExecutionResult)
-function M.handle_write_file(params, callback)
-  local path = M.resolve_path(params.path)
-  local original = utils.read_file(path) or ""
-  local operation = original == "" and "create" or "overwrite"
-
-  -- Ensure parent directory exists
-  local dir = vim.fn.fnamemodify(path, ":h")
-  if dir ~= "" and dir ~= "." then
-    utils.ensure_dir(dir)
-  end
-
-  callback({
-    success = true,
-    result = (operation == "create" and "Create" or "Overwrite") .. " prepared for: " .. path,
-    requires_approval = true,
-    diff_data = {
-      path = path,
-      original = original,
-      modified = params.content,
-      operation = operation,
-    },
-  })
-end
-
--- Handle bash tool
---@param params table { command: string, timeout?: number }
---@param callback fun(result: ExecutionResult)
-function M.handle_bash(params, callback)
-  local command = params.command
-
-  -- Requires user approval first
-  callback({
-    success = true,
-    result = "Command: " .. command,
-    requires_approval = true,
-    diff_data = {
-      path = "[bash]",
-      original = "",
-      modified = "$ " .. command,
-      operation = "bash",
-    },
-    bash_command = command,
-    bash_timeout = params.timeout or 30000,
-  })
-end
-
--- Actually apply an approved change
---@param diff_data DiffData The diff data to apply
---@param callback fun(result: ExecutionResult)
-function M.apply_change(diff_data, callback)
-  if diff_data.operation == "bash" then
-    -- Extract command from modified (remove "$ " prefix)
-    local command = diff_data.modified:gsub("^%$ ", "")
-    M.execute_bash_command(command, 30000, callback)
-  else
-    -- Write file
-    local success = utils.write_file(diff_data.path, diff_data.modified)
-    if success then
-      -- Reload buffer if it's open
-      M.reload_buffer_if_open(diff_data.path)
-      callback({
-        success = true,
-        result = "Changes applied to: " .. diff_data.path,
-        requires_approval = false,
-      })
-    else
-      callback({
-        success = false,
-        result = "Failed to write: " .. diff_data.path,
-        requires_approval = false,
-      })
-    end
-  end
-end
-
--- Execute a bash command
---@param command string Command to execute
---@param timeout number Timeout in milliseconds
---@param callback fun(result: ExecutionResult)
-function M.execute_bash_command(command, timeout, callback)
-  local stdout_data = {}
-  local stderr_data = {}
-  local job_id
-
-  job_id = vim.fn.jobstart(command, {
-    stdout_buffered = true,
-    stderr_buffered = true,
-    on_stdout = function(_, data)
-      if data then
-        for _, line in ipairs(data) do
-          if line ~= "" then
-            table.insert(stdout_data, line)
-          end
-        end
-      end
-    end,
-    on_stderr = function(_, data)
-      if data then
-        for _, line in ipairs(data) do
-          if line ~= "" then
-            table.insert(stderr_data, line)
-          end
-        end
-      end
-    end,
-    on_exit = function(_, exit_code)
-      vim.schedule(function()
-        local result = table.concat(stdout_data, "\n")
-        if #stderr_data > 0 then
-          if result ~= "" then
-            result = result .. "\n"
-          end
-          result = result .. "STDERR:\n" .. table.concat(stderr_data, "\n")
-        end
-        result = result .. "\n[Exit code: " .. exit_code .. "]"
-
-        callback({
-          success = exit_code == 0,
-          result = result,
-          requires_approval = false,
-        })
-      end)
-    end,
-  })
-
-  -- Set up timeout
-  if job_id > 0 then
-    vim.defer_fn(function()
-      if vim.fn.jobwait({ job_id }, 0)[1] == -1 then
-        vim.fn.jobstop(job_id)
-        vim.schedule(function()
-          callback({
-            success = false,
-            result = "Command timed out after " .. timeout .. "ms",
-            requires_approval = false,
-          })
-        end)
-      end
-    end, timeout)
-  else
-    callback({
-      success = false,
-      result = "Failed to start command",
-      requires_approval = false,
-    })
-  end
-end
-
--- Reload a buffer if it's currently open
---@param filepath string Path to the file
-function M.reload_buffer_if_open(filepath)
-  local full_path = vim.fn.fnamemodify(filepath, ":p")
-  for _, buf in ipairs(vim.api.nvim_list_bufs()) do
-    if vim.api.nvim_buf_is_loaded(buf) then
-      local buf_name = vim.api.nvim_buf_get_name(buf)
-      if buf_name == full_path then
-        vim.api.nvim_buf_call(buf, function()
-          vim.cmd("edit!")
-        end)
-        break
-      end
-    end
-  end
-end
-
--- Resolve a path (expand ~ and make absolute if needed)
---@param path string Path to resolve
---@return string Resolved path
-function M.resolve_path(path)
-  -- Expand ~ to home directory
-  local expanded = vim.fn.expand(path)
-
-  -- If relative, make it relative to project root or cwd
-  if not vim.startswith(expanded, "/") then
-    local root = utils.get_project_root() or vim.fn.getcwd()
-    expanded = root .. "/" .. expanded
-  end
-
-  return vim.fn.fnamemodify(expanded, ":p")
-end
-
-return M
--- a/lua/codetyper/agent/intent.lua
+++ b/lua/codetyper/agent/intent.lua
@@ -1,312 +0,0 @@
---@mod codetyper.agent.intent Intent detection from prompts
---@brief [[
--- Parses prompt content to determine user intent and target scope.
--- Intents determine how the generated code should be applied.
---@brief ]]
-
-local M = {}
-
---@class Intent
---@field type string "complete"|"refactor"|"add"|"fix"|"document"|"test"|"explain"|"optimize"
---@field scope_hint string|nil "function"|"class"|"block"|"file"|"selection"|nil
---@field confidence number 0.0-1.0 how confident we are about the intent
---@field action string "replace"|"insert"|"append"|"none"
---@field keywords string[] Keywords that triggered this intent
-
--- Intent patterns with associated metadata
-local intent_patterns = {
-	-- Complete: fill in missing implementation
-	complete = {
-		patterns = {
-			"complete",
-			"finish",
-			"implement",
-			"fill in",
-			"fill out",
-			"stub",
-			"todo",
-			"fixme",
-		},
-		scope_hint = "function",
-		action = "replace",
-		priority = 1,
-	},
-
-	-- Refactor: rewrite existing code
-	refactor = {
-		patterns = {
-			"refactor",
-			"rewrite",
-			"restructure",
-			"reorganize",
-			"clean up",
-			"cleanup",
-			"simplify",
-			"improve",
-		},
-		scope_hint = "function",
-		action = "replace",
-		priority = 2,
-	},
-
-	-- Fix: repair bugs or issues
-	fix = {
-		patterns = {
-			"fix",
-			"repair",
-			"correct",
-			"debug",
-			"solve",
-			"resolve",
-			"patch",
-			"bug",
-			"error",
-			"issue",
-		},
-		scope_hint = "function",
-		action = "replace",
-		priority = 1,
-	},
-
-	-- Add: insert new code
-	add = {
-		patterns = {
-			"add",
-			"create",
-			"insert",
-			"include",
-			"append",
-			"new",
-			"generate",
-			"write",
-		},
-		scope_hint = nil, -- Could be anywhere
-		action = "insert",
-		priority = 3,
-	},
-
-	-- Document: add documentation
-	document = {
-		patterns = {
-			"document",
-			"comment",
-			"jsdoc",
-			"docstring",
-			"describe",
-			"annotate",
-			"type hint",
-			"typehint",
-		},
-		scope_hint = "function",
-		action = "replace", -- Replace with documented version
-		priority = 2,
-	},
-
-	-- Test: generate tests
-	test = {
-		patterns = {
-			"test",
-			"spec",
-			"unit test",
-			"integration test",
-			"coverage",
-		},
-		scope_hint = "file",
-		action = "append",
-		priority = 3,
-	},
-
-	-- Optimize: improve performance
-	optimize = {
-		patterns = {
-			"optimize",
-			"performance",
-			"faster",
-			"efficient",
-			"speed up",
-			"reduce",
-			"minimize",
-		},
-		scope_hint = "function",
-		action = "replace",
-		priority = 2,
-	},
-
-	-- Explain: provide explanation (no code change)
-	explain = {
-		patterns = {
-			"explain",
-			"what does",
-			"how does",
-			"why",
-			"describe",
-			"walk through",
-			"understand",
-		},
-		scope_hint = "function",
-		action = "none",
-		priority = 4,
-	},
-}
-
--- Scope hint patterns
-local scope_patterns = {
-	["this function"] = "function",
-	["this method"] = "function",
-	["the function"] = "function",
-	["the method"] = "function",
-	["this class"] = "class",
-	["the class"] = "class",
-	["this file"] = "file",
-	["the file"] = "file",
-	["this block"] = "block",
-	["the block"] = "block",
-	["this"] = nil, -- Use Tree-sitter to determine
-	["here"] = nil,
-}
-
--- Detect intent from prompt content
---@param prompt string The prompt content
---@return Intent
-function M.detect(prompt)
-	local lower = prompt:lower()
-	local best_match = nil
-	local best_priority = 999
-	local matched_keywords = {}
-
-	-- Check each intent type
-	for intent_type, config in pairs(intent_patterns) do
-		for _, pattern in ipairs(config.patterns) do
-			if lower:find(pattern, 1, true) then
-				if config.priority < best_priority then
-					best_match = intent_type
-					best_priority = config.priority
-					matched_keywords = { pattern }
-				elseif config.priority == best_priority and best_match == intent_type then
-					table.insert(matched_keywords, pattern)
-				end
-			end
-		end
-	end
-
-	-- Default to "add" if no clear intent
-	if not best_match then
-		best_match = "add"
-		matched_keywords = {}
-	end
-
-	local config = intent_patterns[best_match]
-
-	-- Detect scope hint from prompt
-	local scope_hint = config.scope_hint
-	for pattern, hint in pairs(scope_patterns) do
-		if lower:find(pattern, 1, true) then
-			scope_hint = hint or scope_hint
-			break
-		end
-	end
-
-	-- Calculate confidence based on keyword matches
-	local confidence = 0.5 + (#matched_keywords * 0.15)
-	confidence = math.min(confidence, 1.0)
-
-	return {
-		type = best_match,
-		scope_hint = scope_hint,
-		confidence = confidence,
-		action = config.action,
-		keywords = matched_keywords,
-	}
-end
-
--- Check if intent requires code modification
---@param intent Intent
---@return boolean
-function M.modifies_code(intent)
-	return intent.action ~= "none"
-end
-
--- Check if intent should replace existing code
---@param intent Intent
---@return boolean
-function M.is_replacement(intent)
-	return intent.action == "replace"
-end
-
--- Check if intent adds new code
---@param intent Intent
---@return boolean
-function M.is_insertion(intent)
-	return intent.action == "insert" or intent.action == "append"
-end
-
--- Get system prompt modifier based on intent
---@param intent Intent
---@return string
-function M.get_prompt_modifier(intent)
-	local modifiers = {
-		complete = [[
-You are completing an incomplete function.
-Return the complete function with all missing parts filled in.
-Keep the existing signature unless changes are required.
-Output only the code, no explanations.]],
-
-		refactor = [[
-You are refactoring existing code.
-Improve the code structure while maintaining the same behavior.
-Keep the function signature unchanged.
-Output only the refactored code, no explanations.]],
-
-		fix = [[
-You are fixing a bug in the code.
-Identify and correct the issue while minimizing changes.
-Preserve the original intent of the code.
-Output only the fixed code, no explanations.]],
-
-		add = [[
-You are adding new code.
-Follow the existing code style and conventions.
-Output only the new code to be inserted, no explanations.]],
-
-		document = [[
-You are adding documentation to the code.
-Add appropriate comments/docstrings for the function.
-Include parameter types, return types, and description.
-Output the complete function with documentation.]],
-
-		test = [[
-You are generating tests for the code.
-Create comprehensive unit tests covering edge cases.
-Follow the testing conventions of the project.
-Output only the test code, no explanations.]],
-
-		optimize = [[
-You are optimizing code for performance.
-Improve efficiency while maintaining correctness.
-Document any significant algorithmic changes.
-Output only the optimized code, no explanations.]],
-
-		explain = [[
-You are explaining code to a developer.
-Provide a clear, concise explanation of what the code does.
-Include information about the algorithm and any edge cases.
-Do not output code, only explanation.]],
-	}
-
-	return modifiers[intent.type] or modifiers.add
-end
-
--- Format intent for logging
---@param intent Intent
---@return string
-function M.format(intent)
-	return string.format(
-		"%s (scope: %s, action: %s, confidence: %.2f)",
-		intent.type,
-		intent.scope_hint or "auto",
-		intent.action,
-		intent.confidence
-	)
-end
-
-return M
--- a/lua/codetyper/agent/patch.lua
+++ b/lua/codetyper/agent/patch.lua
@@ -1,478 +0,0 @@
---@mod codetyper.agent.patch Patch system with staleness detection
---@brief [[
--- Manages code patches with buffer snapshots for staleness detection.
--- Patches are queued for safe injection when completion popup is not visible.
---@brief ]]
-
-local M = {}
-
---@class BufferSnapshot
---@field bufnr number Buffer number
---@field changedtick number vim.b.changedtick at snapshot time
---@field content_hash string Hash of buffer content in range
---@field range {start_line: number, end_line: number}|nil Range snapshotted
-
---@class PatchCandidate
---@field id string Unique patch ID
---@field event_id string Related PromptEvent ID
---@field target_bufnr number Target buffer for injection
---@field target_path string Target file path
---@field original_snapshot BufferSnapshot Snapshot at event creation
---@field generated_code string Code to inject
---@field injection_range {start_line: number, end_line: number}|nil
---@field injection_strategy string "append"|"replace"|"insert"
---@field confidence number Confidence score (0.0-1.0)
---@field status string "pending"|"applied"|"stale"|"rejected"
---@field created_at number Timestamp
---@field applied_at number|nil When applied
-
--- Patch storage
---@type PatchCandidate[]
-local patches = {}
-
--- Patch ID counter
-local patch_counter = 0
-
--- Generate unique patch ID
---@return string
-function M.generate_id()
-	patch_counter = patch_counter + 1
-	return string.format("patch_%d_%d", os.time(), patch_counter)
-end
-
--- Hash buffer content in range
---@param bufnr number
---@param start_line number|nil 1-indexed, nil for whole buffer
---@param end_line number|nil 1-indexed, nil for whole buffer
---@return string
-local function hash_buffer_range(bufnr, start_line, end_line)
-	if not vim.api.nvim_buf_is_valid(bufnr) then
-		return ""
-	end
-
-	local lines
-	if start_line and end_line then
-		lines = vim.api.nvim_buf_get_lines(bufnr, start_line - 1, end_line, false)
-	else
-		lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
-	end
-
-	local content = table.concat(lines, "\n")
-	local hash = 0
-	for i = 1, #content do
-		hash = (hash * 31 + string.byte(content, i)) % 2147483647
-	end
-	return string.format("%x", hash)
-end
-
--- Take a snapshot of buffer state
---@param bufnr number Buffer number
---@param range {start_line: number, end_line: number}|nil Optional range
---@return BufferSnapshot
-function M.snapshot_buffer(bufnr, range)
-	local changedtick = 0
-	if vim.api.nvim_buf_is_valid(bufnr) then
-		changedtick = vim.api.nvim_buf_get_var(bufnr, "changedtick") or vim.b[bufnr].changedtick or 0
-	end
-
-	local content_hash
-	if range then
-		content_hash = hash_buffer_range(bufnr, range.start_line, range.end_line)
-	else
-		content_hash = hash_buffer_range(bufnr, nil, nil)
-	end
-
-	return {
-		bufnr = bufnr,
-		changedtick = changedtick,
-		content_hash = content_hash,
-		range = range,
-	}
-end
-
--- Check if buffer changed since snapshot
---@param snapshot BufferSnapshot
---@return boolean is_stale
---@return string|nil reason
-function M.is_snapshot_stale(snapshot)
-	if not vim.api.nvim_buf_is_valid(snapshot.bufnr) then
-		return true, "buffer_invalid"
-	end
-
-	-- Check changedtick first (fast path)
-	local current_tick = vim.api.nvim_buf_get_var(snapshot.bufnr, "changedtick")
-		or vim.b[snapshot.bufnr].changedtick or 0
-
-	if current_tick ~= snapshot.changedtick then
-		-- Changedtick differs, but might be just cursor movement
-		-- Verify with content hash
-		local current_hash
-		if snapshot.range then
-			current_hash = hash_buffer_range(
-				snapshot.bufnr,
-				snapshot.range.start_line,
-				snapshot.range.end_line
-			)
-		else
-			current_hash = hash_buffer_range(snapshot.bufnr, nil, nil)
-		end
-
-		if current_hash ~= snapshot.content_hash then
-			return true, "content_changed"
-		end
-	end
-
-	return false, nil
-end
-
--- Check if a patch is stale
---@param patch PatchCandidate
---@return boolean
---@return string|nil reason
-function M.is_stale(patch)
-	return M.is_snapshot_stale(patch.original_snapshot)
-end
-
--- Queue a patch for deferred application
---@param patch PatchCandidate
---@return PatchCandidate
-function M.queue_patch(patch)
-	patch.id = patch.id or M.generate_id()
-	patch.status = patch.status or "pending"
-	patch.created_at = patch.created_at or os.time()
-
-	table.insert(patches, patch)
-
-	-- Log patch creation
-	pcall(function()
-		local logs = require("codetyper.agent.logs")
-		logs.add({
-			type = "patch",
-			message = string.format(
-				"Patch queued: %s (confidence: %.2f)",
-				patch.id, patch.confidence or 0
-			),
-			data = {
-				patch_id = patch.id,
-				event_id = patch.event_id,
-				target_path = patch.target_path,
-				code_preview = patch.generated_code:sub(1, 50),
-			},
-		})
-	end)
-
-	return patch
-end
-
--- Create patch from event and response
---@param event table PromptEvent
---@param generated_code string
---@param confidence number
---@param strategy string|nil Injection strategy (overrides intent-based)
---@return PatchCandidate
-function M.create_from_event(event, generated_code, confidence, strategy)
-	-- Get target buffer
-	local target_bufnr = vim.fn.bufnr(event.target_path)
-	if target_bufnr == -1 then
-		-- Try to find by filename
-		for _, buf in ipairs(vim.api.nvim_list_bufs()) do
-			local name = vim.api.nvim_buf_get_name(buf)
-			if name == event.target_path then
-				target_bufnr = buf
-				break
-			end
-		end
-	end
-
-	-- Take snapshot of the scope range in target buffer (for staleness detection)
-	local snapshot_range = event.scope_range or event.range
-	local snapshot = M.snapshot_buffer(
-		target_bufnr ~= -1 and target_bufnr or event.bufnr,
-		snapshot_range
-	)
-
-	-- Determine injection strategy and range based on intent
-	local injection_strategy = strategy
-	local injection_range = nil
-
-	if not injection_strategy and event.intent then
-		local intent_mod = require("codetyper.agent.intent")
-		if intent_mod.is_replacement(event.intent) then
-			injection_strategy = "replace"
-			-- Use scope range for replacement
-			if event.scope_range then
-				injection_range = event.scope_range
-			end
-		elseif event.intent.action == "insert" then
-			injection_strategy = "insert"
-			-- Insert at prompt location
-			injection_range = { start_line = event.range.start_line, end_line = event.range.start_line }
-		elseif event.intent.action == "append" then
-			injection_strategy = "append"
-			-- Will append to end of file
-		else
-			injection_strategy = "append"
-		end
-	end
-
-	injection_strategy = injection_strategy or "append"
-
-	return {
-		id = M.generate_id(),
-		event_id = event.id,
-		target_bufnr = target_bufnr,
-		target_path = event.target_path,
-		original_snapshot = snapshot,
-		generated_code = generated_code,
-		injection_range = injection_range,
-		injection_strategy = injection_strategy,
-		confidence = confidence,
-		status = "pending",
-		created_at = os.time(),
-		intent = event.intent,
-		scope = event.scope,
-	}
-end
-
--- Get all pending patches
---@return PatchCandidate[]
-function M.get_pending()
-	local pending = {}
-	for _, patch in ipairs(patches) do
-		if patch.status == "pending" then
-			table.insert(pending, patch)
-		end
-	end
-	return pending
-end
-
--- Get patch by ID
---@param id string
---@return PatchCandidate|nil
-function M.get(id)
-	for _, patch in ipairs(patches) do
-		if patch.id == id then
-			return patch
-		end
-	end
-	return nil
-end
-
--- Get patches for event
---@param event_id string
---@return PatchCandidate[]
-function M.get_for_event(event_id)
-	local result = {}
-	for _, patch in ipairs(patches) do
-		if patch.event_id == event_id then
-			table.insert(result, patch)
-		end
-	end
-	return result
-end
-
--- Mark patch as applied
---@param id string
---@return boolean
-function M.mark_applied(id)
-	local patch = M.get(id)
-	if patch then
-		patch.status = "applied"
-		patch.applied_at = os.time()
-		return true
-	end
-	return false
-end
-
--- Mark patch as stale
---@param id string
---@param reason string|nil
---@return boolean
-function M.mark_stale(id, reason)
-	local patch = M.get(id)
-	if patch then
-		patch.status = "stale"
-		patch.stale_reason = reason
-		return true
-	end
-	return false
-end
-
--- Mark patch as rejected
---@param id string
---@param reason string|nil
---@return boolean
-function M.mark_rejected(id, reason)
-	local patch = M.get(id)
-	if patch then
-		patch.status = "rejected"
-		patch.reject_reason = reason
-		return true
-	end
-	return false
-end
-
--- Apply a patch to the target buffer
---@param patch PatchCandidate
---@return boolean success
---@return string|nil error
-function M.apply(patch)
-	-- Check staleness first
-	local is_stale, stale_reason = M.is_stale(patch)
-	if is_stale then
-		M.mark_stale(patch.id, stale_reason)
-
-		pcall(function()
-			local logs = require("codetyper.agent.logs")
-			logs.add({
-				type = "warning",
-				message = string.format("Patch %s is stale: %s", patch.id, stale_reason or "unknown"),
-			})
-		end)
-
-		return false, "patch_stale: " .. (stale_reason or "unknown")
-	end
-
-	-- Ensure target buffer is valid
-	local target_bufnr = patch.target_bufnr
-	if target_bufnr == -1 or not vim.api.nvim_buf_is_valid(target_bufnr) then
-		-- Try to load buffer from path
-		target_bufnr = vim.fn.bufadd(patch.target_path)
-		if target_bufnr == 0 then
-			M.mark_rejected(patch.id, "buffer_not_found")
-			return false, "target buffer not found"
-		end
-		vim.fn.bufload(target_bufnr)
-		patch.target_bufnr = target_bufnr
-	end
-
-	-- Prepare code lines
-	local code_lines = vim.split(patch.generated_code, "\n", { plain = true })
-
-	-- Apply based on strategy
-	local ok, err = pcall(function()
-		if patch.injection_strategy == "replace" and patch.injection_range then
-			-- Replace specific range
-			vim.api.nvim_buf_set_lines(
-				target_bufnr,
-				patch.injection_range.start_line - 1,
-				patch.injection_range.end_line,
-				false,
-				code_lines
-			)
-		elseif patch.injection_strategy == "insert" and patch.injection_range then
-			-- Insert at specific line
-			vim.api.nvim_buf_set_lines(
-				target_bufnr,
-				patch.injection_range.start_line - 1,
-				patch.injection_range.start_line - 1,
-				false,
-				code_lines
-			)
-		else
-			-- Default: append to end
-			local line_count = vim.api.nvim_buf_line_count(target_bufnr)
-			vim.api.nvim_buf_set_lines(target_bufnr, line_count, line_count, false, code_lines)
-		end
-	end)
-
-	if not ok then
-		M.mark_rejected(patch.id, err)
-		return false, err
-	end
-
-	M.mark_applied(patch.id)
-
-	pcall(function()
-		local logs = require("codetyper.agent.logs")
-		logs.add({
-			type = "success",
-			message = string.format("Patch %s applied successfully", patch.id),
-			data = {
-				target_path = patch.target_path,
-				lines_added = #code_lines,
-			},
-		})
-	end)
-
-	return true, nil
-end
-
--- Flush all pending patches that are safe to apply
---@return number applied_count
---@return number stale_count
-function M.flush_pending()
-	local applied = 0
-	local stale = 0
-
-	for _, patch in ipairs(patches) do
-		if patch.status == "pending" then
-			local success, _ = M.apply(patch)
-			if success then
-				applied = applied + 1
-			else
-				stale = stale + 1
-			end
-		end
-	end
-
-	return applied, stale
-end
-
--- Cancel all pending patches for a buffer
---@param bufnr number
---@return number cancelled_count
-function M.cancel_for_buffer(bufnr)
-	local cancelled = 0
-	for _, patch in ipairs(patches) do
-		if patch.status == "pending" and
-			(patch.target_bufnr == bufnr or patch.original_snapshot.bufnr == bufnr) then
-			patch.status = "cancelled"
-			cancelled = cancelled + 1
-		end
-	end
-	return cancelled
-end
-
--- Cleanup old patches
---@param max_age number Max age in seconds (default: 300)
-function M.cleanup(max_age)
-	max_age = max_age or 300
-	local now = os.time()
-	local i = 1
-	while i <= #patches do
-		local patch = patches[i]
-		if patch.status ~= "pending" and (now - patch.created_at) > max_age then
-			table.remove(patches, i)
-		else
-			i = i + 1
-		end
-	end
-end
-
--- Get statistics
---@return table
-function M.stats()
-	local stats = {
-		total = #patches,
-		pending = 0,
-		applied = 0,
-		stale = 0,
-		rejected = 0,
-		cancelled = 0,
-	}
-	for _, patch in ipairs(patches) do
-		local s = patch.status
-		if stats[s] then
-			stats[s] = stats[s] + 1
-		end
-	end
-	return stats
-end
-
--- Clear all patches
-function M.clear()
-	patches = {}
-end
-
-return M
--- a/lua/codetyper/agent/tools.lua
+++ b/lua/codetyper/agent/tools.lua
@@ -1,161 +0,0 @@
---@mod codetyper.agent.tools Tool definitions for the agent system
---
--- Defines available tools that the LLM can use to interact with files and system.
-
-local M = {}
-
--- Tool definitions in a provider-agnostic format
-M.definitions = {
-  read_file = {
-    name = "read_file",
-    description = "Read the contents of a file at the specified path",
-    parameters = {
-      type = "object",
-      properties = {
-        path = {
-          type = "string",
-          description = "Absolute or relative path to the file to read",
-        },
-      },
-      required = { "path" },
-    },
-  },
-
-  edit_file = {
-    name = "edit_file",
-    description = "Edit a file by replacing specific content. Provide the exact content to find and the replacement.",
-    parameters = {
-      type = "object",
-      properties = {
-        path = {
-          type = "string",
-          description = "Path to the file to edit",
-        },
-        find = {
-          type = "string",
-          description = "Exact content to find (must match exactly, including whitespace)",
-        },
-        replace = {
-          type = "string",
-          description = "Content to replace with",
-        },
-      },
-      required = { "path", "find", "replace" },
-    },
-  },
-
-  write_file = {
-    name = "write_file",
-    description = "Write content to a file, creating it if it doesn't exist or overwriting if it does",
-    parameters = {
-      type = "object",
-      properties = {
-        path = {
-          type = "string",
-          description = "Path to the file to write",
-        },
-        content = {
-          type = "string",
-          description = "Complete file content to write",
-        },
-      },
-      required = { "path", "content" },
-    },
-  },
-
-  bash = {
-    name = "bash",
-    description = "Execute a bash command and return the output. Use for git, npm, build tools, etc.",
-    parameters = {
-      type = "object",
-      properties = {
-        command = {
-          type = "string",
-          description = "The bash command to execute",
-        },
-        timeout = {
-          type = "number",
-          description = "Timeout in milliseconds (default: 30000)",
-        },
-      },
-      required = { "command" },
-    },
-  },
-}
-
--- Convert tool definitions to Claude API format
---@return table[] Tools in Claude's expected format
-function M.to_claude_format()
-  local tools = {}
-  for _, tool in pairs(M.definitions) do
-    table.insert(tools, {
-      name = tool.name,
-      description = tool.description,
-      input_schema = tool.parameters,
-    })
-  end
-  return tools
-end
-
--- Convert tool definitions to OpenAI API format
---@return table[] Tools in OpenAI's expected format
-function M.to_openai_format()
-  local tools = {}
-  for _, tool in pairs(M.definitions) do
-    table.insert(tools, {
-      type = "function",
-      ["function"] = {
-        name = tool.name,
-        description = tool.description,
-        parameters = tool.parameters,
-      },
-    })
-  end
-  return tools
-end
-
--- Convert tool definitions to prompt format for Ollama
---@return string Formatted tool descriptions for system prompt
-function M.to_prompt_format()
-  local lines = {
-    "You have access to the following tools. To use a tool, respond with a JSON block.",
-    "",
-  }
-
-  for _, tool in pairs(M.definitions) do
-    table.insert(lines, "## " .. tool.name)
-    table.insert(lines, tool.description)
-    table.insert(lines, "")
-    table.insert(lines, "Parameters:")
-    for prop_name, prop in pairs(tool.parameters.properties) do
-      local required = vim.tbl_contains(tool.parameters.required or {}, prop_name)
-      local req_str = required and " (required)" or " (optional)"
-      table.insert(lines, "  - " .. prop_name .. ": " .. prop.description .. req_str)
-    end
-    table.insert(lines, "")
-  end
-
-  table.insert(lines, "---")
-  table.insert(lines, "")
-  table.insert(lines, "To call a tool, output a JSON block like this:")
-  table.insert(lines, "```json")
-  table.insert(lines, '{"tool": "tool_name", "parameters": {"param1": "value1"}}')
-  table.insert(lines, "```")
-  table.insert(lines, "")
-  table.insert(lines, "After receiving tool results, continue your response or call another tool.")
-  table.insert(lines, "When you're done, just respond normally without any tool calls.")
-
-  return table.concat(lines, "\n")
-end
-
--- Get a list of tool names
---@return string[]
-function M.get_tool_names()
-  local names = {}
-  for name, _ in pairs(M.definitions) do
-    table.insert(names, name)
-  end
-  return names
-end
-
-return M
--- a/lua/codetyper/agent/worker.lua
+++ b/lua/codetyper/agent/worker.lua
@@ -1,419 +0,0 @@
---@mod codetyper.agent.worker Async LLM worker wrapper
---@brief [[
--- Wraps LLM clients with timeout handling and confidence scoring.
--- Provides unified interface for scheduler to dispatch work.
---@brief ]]
-
-local M = {}
-
-local confidence = require("codetyper.agent.confidence")
-
---@class WorkerResult
---@field success boolean Whether the request succeeded
---@field response string|nil The generated code
---@field error string|nil Error message if failed
---@field confidence number Confidence score (0.0-1.0)
---@field confidence_breakdown table Detailed confidence breakdown
---@field duration number Time taken in seconds
---@field worker_type string LLM provider used
---@field usage table|nil Token usage if available
-
---@class Worker
---@field id string Worker ID
---@field event table PromptEvent being processed
---@field worker_type string LLM provider type
---@field status string "pending"|"running"|"completed"|"failed"|"timeout"
---@field start_time number Start timestamp
---@field timeout_ms number Timeout in milliseconds
---@field timer any Timeout timer handle
---@field callback function Result callback
-
--- Worker ID counter
-local worker_counter = 0
-
--- Active workers
---@type table<string, Worker>
-local active_workers = {}
-
--- Default timeouts by provider type
-local default_timeouts = {
-	ollama = 30000,   -- 30s for local
-	claude = 60000,   -- 60s for remote
-	openai = 60000,
-	gemini = 60000,
-	copilot = 60000,
-}
-
--- Generate worker ID
---@return string
-local function generate_id()
-	worker_counter = worker_counter + 1
-	return string.format("worker_%d_%d", os.time(), worker_counter)
-end
-
--- Get LLM client by type
---@param worker_type string
---@return table|nil client
---@return string|nil error
-local function get_client(worker_type)
-	local ok, client = pcall(require, "codetyper.llm." .. worker_type)
-	if ok and client then
-		return client, nil
-	end
-	return nil, "Unknown provider: " .. worker_type
-end
-
--- Build prompt for code generation
---@param event table PromptEvent
---@return string prompt
---@return table context
-local function build_prompt(event)
-	local intent_mod = require("codetyper.agent.intent")
-
-	-- Get target file content for context
-	local target_content = ""
-	if event.target_path then
-		local ok, lines = pcall(function()
-			return vim.fn.readfile(event.target_path)
-		end)
-		if ok and lines then
-			target_content = table.concat(lines, "\n")
-		end
-	end
-
-	local filetype = vim.fn.fnamemodify(event.target_path or "", ":e")
-
-	-- Build context with scope information
-	local context = {
-		target_path = event.target_path,
-		target_content = target_content,
-		filetype = filetype,
-		scope = event.scope,
-		scope_text = event.scope_text,
-		scope_range = event.scope_range,
-		intent = event.intent,
-	}
-
-	-- Build the actual prompt based on intent and scope
-	local system_prompt = ""
-	local user_prompt = event.prompt_content
-
-	if event.intent then
-		system_prompt = intent_mod.get_prompt_modifier(event.intent)
-	end
-
-	-- If we have a scope (function/method), include it in the prompt
-	if event.scope_text and event.scope and event.scope.type ~= "file" then
-		local scope_type = event.scope.type
-		local scope_name = event.scope.name or "anonymous"
-
-		-- For replacement intents, provide the full scope to transform
-		if event.intent and intent_mod.is_replacement(event.intent) then
-			user_prompt = string.format(
-				[[Here is a %s named "%s" in a %s file:
-
-```%s
-%s
-```
-
-User request: %s
-
-Return the complete transformed %s. Output only code, no explanations.]],
-				scope_type,
-				scope_name,
-				filetype,
-				filetype,
-				event.scope_text,
-				event.prompt_content,
-				scope_type
-			)
-		else
-			-- For insertion intents, provide context
-			user_prompt = string.format(
-				[[Context - this code is inside a %s named "%s":
-
-```%s
-%s
-```
-
-User request: %s
-
-Output only the code to insert, no explanations.]],
-				scope_type,
-				scope_name,
-				filetype,
-				event.scope_text,
-				event.prompt_content
-			)
-		end
-	else
-		-- No scope resolved, use full file context
-		user_prompt = string.format(
-			[[File: %s (%s)
-
-```%s
-%s
-```
-
-User request: %s
-
-Output only code, no explanations.]],
-			vim.fn.fnamemodify(event.target_path or "", ":t"),
-			filetype,
-			filetype,
-			target_content:sub(1, 4000), -- Limit context size
-			event.prompt_content
-		)
-	end
-
-	context.system_prompt = system_prompt
-	context.formatted_prompt = user_prompt
-
-	return user_prompt, context
-end
-
--- Create and start a worker
---@param event table PromptEvent
---@param worker_type string LLM provider type
---@param callback function(result: WorkerResult)
---@return Worker
-function M.create(event, worker_type, callback)
-	local worker = {
-		id = generate_id(),
-		event = event,
-		worker_type = worker_type,
-		status = "pending",
-		start_time = os.clock(),
-		timeout_ms = default_timeouts[worker_type] or 60000,
-		callback = callback,
-	}
-
-	active_workers[worker.id] = worker
-
-	-- Log worker creation
-	pcall(function()
-		local logs = require("codetyper.agent.logs")
-		logs.add({
-			type = "worker",
-			message = string.format("Worker %s started (%s)", worker.id, worker_type),
-			data = {
-				worker_id = worker.id,
-				event_id = event.id,
-				provider = worker_type,
-			},
-		})
-	end)
-
-	-- Start the work
-	M.start(worker)
-
-	return worker
-end
-
--- Start worker execution
---@param worker Worker
-function M.start(worker)
-	worker.status = "running"
-
-	-- Set up timeout
-	worker.timer = vim.defer_fn(function()
-		if worker.status == "running" then
-			worker.status = "timeout"
-			active_workers[worker.id] = nil
-
-			pcall(function()
-				local logs = require("codetyper.agent.logs")
-				logs.add({
-					type = "warning",
-					message = string.format("Worker %s timed out after %dms", worker.id, worker.timeout_ms),
-				})
-			end)
-
-			worker.callback({
-				success = false,
-				response = nil,
-				error = "timeout",
-				confidence = 0,
-				confidence_breakdown = {},
-				duration = (os.clock() - worker.start_time),
-				worker_type = worker.worker_type,
-			})
-		end
-	end, worker.timeout_ms)
-
-	-- Get client and execute
-	local client, client_err = get_client(worker.worker_type)
-	if not client then
-		M.complete(worker, nil, client_err)
-		return
-	end
-
-	local prompt, context = build_prompt(worker.event)
-
-	-- Call the LLM
-	client.generate(prompt, context, function(response, err, usage)
-		-- Cancel timeout timer
-		if worker.timer then
-			pcall(function()
-				-- Timer might have already fired
-				if type(worker.timer) == "userdata" and worker.timer.stop then
-					worker.timer:stop()
-				end
-			end)
-		end
-
-		if worker.status ~= "running" then
-			return -- Already timed out or cancelled
-		end
-
-		M.complete(worker, response, err, usage)
-	end)
-end
-
--- Complete worker execution
---@param worker Worker
---@param response string|nil
---@param error string|nil
---@param usage table|nil
-function M.complete(worker, response, error, usage)
-	local duration = os.clock() - worker.start_time
-
-	if error then
-		worker.status = "failed"
-		active_workers[worker.id] = nil
-
-		pcall(function()
-			local logs = require("codetyper.agent.logs")
-			logs.add({
-				type = "error",
-				message = string.format("Worker %s failed: %s", worker.id, error),
-			})
-		end)
-
-		worker.callback({
-			success = false,
-			response = nil,
-			error = error,
-			confidence = 0,
-			confidence_breakdown = {},
-			duration = duration,
-			worker_type = worker.worker_type,
-			usage = usage,
-		})
-		return
-	end
-
-	-- Score confidence
-	local conf_score, breakdown = confidence.score(response, worker.event.prompt_content)
-
-	worker.status = "completed"
-	active_workers[worker.id] = nil
-
-	pcall(function()
-		local logs = require("codetyper.agent.logs")
-		logs.add({
-			type = "success",
-			message = string.format(
-				"Worker %s completed (%.2fs, confidence: %.2f - %s)",
-				worker.id, duration, conf_score, confidence.level_name(conf_score)
-			),
-			data = {
-				confidence_breakdown = confidence.format_breakdown(breakdown),
-				usage = usage,
-			},
-		})
-	end)
-
-	worker.callback({
-		success = true,
-		response = response,
-		error = nil,
-		confidence = conf_score,
-		confidence_breakdown = breakdown,
-		duration = duration,
-		worker_type = worker.worker_type,
-		usage = usage,
-	})
-end
-
--- Cancel a worker
---@param worker_id string
---@return boolean
-function M.cancel(worker_id)
-	local worker = active_workers[worker_id]
-	if not worker then
-		return false
-	end
-
-	if worker.timer then
-		pcall(function()
-			if type(worker.timer) == "userdata" and worker.timer.stop then
-				worker.timer:stop()
-			end
-		end)
-	end
-
-	worker.status = "cancelled"
-	active_workers[worker_id] = nil
-
-	pcall(function()
-		local logs = require("codetyper.agent.logs")
-		logs.add({
-			type = "info",
-			message = string.format("Worker %s cancelled", worker_id),
-		})
-	end)
-
-	return true
-end
-
--- Get active worker count
---@return number
-function M.active_count()
-	local count = 0
-	for _ in pairs(active_workers) do
-		count = count + 1
-	end
-	return count
-end
-
--- Get all active workers
---@return Worker[]
-function M.get_active()
-	local workers = {}
-	for _, worker in pairs(active_workers) do
-		table.insert(workers, worker)
-	end
-	return workers
-end
-
--- Check if worker exists and is running
---@param worker_id string
---@return boolean
-function M.is_running(worker_id)
-	local worker = active_workers[worker_id]
-	return worker ~= nil and worker.status == "running"
-end
-
--- Cancel all workers for an event
---@param event_id string
---@return number cancelled_count
-function M.cancel_for_event(event_id)
-	local cancelled = 0
-	for id, worker in pairs(active_workers) do
-		if worker.event.id == event_id then
-			M.cancel(id)
-			cancelled = cancelled + 1
-		end
-	end
-	return cancelled
-end
-
--- Set timeout for worker type
---@param worker_type string
---@param timeout_ms number
-function M.set_timeout(worker_type, timeout_ms)
-	default_timeouts[worker_type] = timeout_ms
-end
-
-return M
--- a/lua/codetyper/autocmds.lua
+++ b/lua/codetyper/autocmds.lua
@@ -1,635 +0,0 @@
---@mod codetyper.autocmds Autocommands for Codetyper.nvim
-
-local M = {}
-
-local utils = require("codetyper.utils")
-
--- Autocommand group name
-local AUGROUP = "Codetyper"
-
--- Debounce timer for tree updates
-local tree_update_timer = nil
-local TREE_UPDATE_DEBOUNCE_MS = 1000 -- 1 second debounce
-
--- Track processed prompts to avoid re-processing
---@type table<string, boolean>
-local processed_prompts = {}
-
--- Generate a unique key for a prompt
---@param bufnr number Buffer number
---@param prompt table Prompt object
---@return string Unique key
-local function get_prompt_key(bufnr, prompt)
-	return string.format("%d:%d:%d:%s", bufnr, prompt.start_line, prompt.end_line, prompt.content:sub(1, 50))
-end
-
--- Schedule tree update with debounce
-local function schedule_tree_update()
-	if tree_update_timer then
-		tree_update_timer:stop()
-	end
-
-	tree_update_timer = vim.defer_fn(function()
-		local tree = require("codetyper.tree")
-		tree.update_tree_log()
-		tree_update_timer = nil
-	end, TREE_UPDATE_DEBOUNCE_MS)
-end
-
--- Setup autocommands
-function M.setup()
-	local group = vim.api.nvim_create_augroup(AUGROUP, { clear = true })
-
-	-- Auto-save coder file when leaving insert mode
-	vim.api.nvim_create_autocmd("InsertLeave", {
-		group = group,
-		pattern = "*.coder.*",
-		callback = function()
-			-- Auto-save the coder file
-			if vim.bo.modified then
-				vim.cmd("silent! write")
-			end
-			-- Check for closed prompts and auto-process
-			M.check_for_closed_prompt()
-		end,
-		desc = "Auto-save and check for closed prompt tags",
-	})
-
-	-- Auto-set filetype for coder files based on extension
-	vim.api.nvim_create_autocmd({ "BufRead", "BufNewFile" }, {
-		group = group,
-		pattern = "*.coder.*",
-		callback = function()
-			M.set_coder_filetype()
-		end,
-		desc = "Set filetype for coder files",
-	})
-
-	-- Auto-open split view when opening a coder file directly (e.g., from nvim-tree)
-	vim.api.nvim_create_autocmd("BufEnter", {
-		group = group,
-		pattern = "*.coder.*",
-		callback = function()
-			-- Delay slightly to ensure buffer is fully loaded
-			vim.defer_fn(function()
-				M.auto_open_target_file()
-			end, 50)
-		end,
-		desc = "Auto-open target file when coder file is opened",
-	})
-
-	-- Cleanup on buffer close
-	vim.api.nvim_create_autocmd("BufWipeout", {
-		group = group,
-		pattern = "*.coder.*",
-		callback = function(ev)
-			local window = require("codetyper.window")
-			if window.is_open() then
-				window.close_split()
-			end
-			-- Clear processed prompts for this buffer
-			local bufnr = ev.buf
-			for key, _ in pairs(processed_prompts) do
-				if key:match("^" .. bufnr .. ":") then
-					processed_prompts[key] = nil
-				end
-			end
-			-- Clear auto-opened tracking
-			M.clear_auto_opened(bufnr)
-		end,
-		desc = "Cleanup on coder buffer close",
-	})
-
-	-- Update tree.log when files are created/written
-	vim.api.nvim_create_autocmd({ "BufWritePost", "BufNewFile" }, {
-		group = group,
-		pattern = "*",
-		callback = function(ev)
-			-- Skip coder files and tree.log itself
-			local filepath = ev.file or vim.fn.expand("%:p")
-			if filepath:match("%.coder%.") or filepath:match("tree%.log$") then
-				return
-			end
-			-- Schedule tree update with debounce
-			schedule_tree_update()
-		end,
-		desc = "Update tree.log on file creation/save",
-	})
-
-	-- Update tree.log when files are deleted (via netrw or file explorer)
-	vim.api.nvim_create_autocmd("BufDelete", {
-		group = group,
-		pattern = "*",
-		callback = function(ev)
-			local filepath = ev.file or ""
-			-- Skip special buffers and coder files
-			if filepath == "" or filepath:match("%.coder%.") or filepath:match("tree%.log$") then
-				return
-			end
-			schedule_tree_update()
-		end,
-		desc = "Update tree.log on file deletion",
-	})
-
-	-- Update tree on directory change
-	vim.api.nvim_create_autocmd("DirChanged", {
-		group = group,
-		pattern = "*",
-		callback = function()
-			schedule_tree_update()
-		end,
-		desc = "Update tree.log on directory change",
-	})
-
-	-- Auto-index: Create/open coder companion file when opening source files
-	vim.api.nvim_create_autocmd("BufEnter", {
-		group = group,
-		pattern = "*",
-		callback = function(ev)
-			-- Delay to ensure buffer is fully loaded
-			vim.defer_fn(function()
-				M.auto_index_file(ev.buf)
-			end, 100)
-		end,
-		desc = "Auto-index source files with coder companion",
-	})
-end
-
--- Get config with fallback defaults
-local function get_config_safe()
-	local codetyper = require("codetyper")
-	local config = codetyper.get_config()
-	-- Return defaults if not initialized
-	if not config or not config.patterns then
-		return {
-			patterns = {
-				open_tag = "/@",
-				close_tag = "@/",
-				file_pattern = "*.coder.*",
-			}
-		}
-	end
-	return config
-end
-
--- Check if the buffer has a newly closed prompt and auto-process
-function M.check_for_closed_prompt()
-	local config = get_config_safe()
-	local parser = require("codetyper.parser")
-
-	local bufnr = vim.api.nvim_get_current_buf()
-
-	-- Get current line
-	local cursor = vim.api.nvim_win_get_cursor(0)
-	local line = cursor[1]
-	local lines = vim.api.nvim_buf_get_lines(bufnr, line - 1, line, false)
-
-	if #lines == 0 then
-		return
-	end
-
-	local current_line = lines[1]
-
-	-- Check if line contains closing tag
-	if parser.has_closing_tag(current_line, config.patterns.close_tag) then
-		-- Find the complete prompt
-		local prompt = parser.get_last_prompt(bufnr)
-		if prompt and prompt.content and prompt.content ~= "" then
-			-- Generate unique key for this prompt
-			local prompt_key = get_prompt_key(bufnr, prompt)
-
-			-- Check if already processed
-			if processed_prompts[prompt_key] then
-				return
-			end
-
-			-- Mark as processed
-			processed_prompts[prompt_key] = true
-
-			-- Check if scheduler is enabled
-			local codetyper = require("codetyper")
-			local ct_config = codetyper.get_config()
-			local scheduler_enabled = ct_config and ct_config.scheduler and ct_config.scheduler.enabled
-
-			if scheduler_enabled then
-				-- Event-driven: emit to queue
-				vim.schedule(function()
-					local queue = require("codetyper.agent.queue")
-					local patch_mod = require("codetyper.agent.patch")
-					local intent_mod = require("codetyper.agent.intent")
-					local scope_mod = require("codetyper.agent.scope")
-
-					-- Take buffer snapshot
-					local snapshot = patch_mod.snapshot_buffer(bufnr, {
-						start_line = prompt.start_line,
-						end_line = prompt.end_line,
-					})
-
-					-- Get target path
-					local current_file = vim.fn.expand("%:p")
-					local target_path = utils.get_target_path(current_file)
-
-					-- Clean prompt content
-					local cleaned = parser.clean_prompt(prompt.content)
-
-					-- Detect intent from prompt
-					local intent = intent_mod.detect(cleaned)
-
-					-- Resolve scope in target file (use prompt position to find enclosing scope)
-					local target_bufnr = vim.fn.bufnr(target_path)
-					local scope = nil
-					local scope_text = nil
-					local scope_range = nil
-
-					if target_bufnr ~= -1 then
-						-- Find scope at the corresponding line in target
-						-- Use the prompt's line position as reference
-						scope = scope_mod.resolve_scope(target_bufnr, prompt.start_line, 1)
-						if scope and scope.type ~= "file" then
-							scope_text = scope.text
-							scope_range = {
-								start_line = scope.range.start_row,
-								end_line = scope.range.end_row,
-							}
-						end
-					end
-
-					-- Determine priority based on intent
-					local priority = 2 -- Normal
-					if intent.type == "fix" or intent.type == "complete" then
-						priority = 1 -- High priority for fixes and completions
-					elseif intent.type == "test" or intent.type == "document" then
-						priority = 3 -- Lower priority for tests and docs
-					end
-
-					-- Enqueue the event
-					queue.enqueue({
-						id = queue.generate_id(),
-						bufnr = bufnr,
-						range = { start_line = prompt.start_line, end_line = prompt.end_line },
-						timestamp = os.clock(),
-						changedtick = snapshot.changedtick,
-						content_hash = snapshot.content_hash,
-						prompt_content = cleaned,
-						target_path = target_path,
-						priority = priority,
-						status = "pending",
-						attempt_count = 0,
-						intent = intent,
-						scope = scope,
-						scope_text = scope_text,
-						scope_range = scope_range,
-					})
-
-					local scope_info = scope and scope.type ~= "file"
-						and string.format(" [%s: %s]", scope.type, scope.name or "anonymous")
-						or ""
-					utils.notify(
-						string.format("Prompt queued: %s%s", intent.type, scope_info),
-						vim.log.levels.INFO
-					)
-				end)
-			else
-				-- Legacy: direct processing
-				utils.notify("Processing prompt...", vim.log.levels.INFO)
-				vim.schedule(function()
-					vim.cmd("CoderProcess")
-				end)
-			end
-		end
-	end
-end
-
--- Reset processed prompts for a buffer (useful for re-processing)
---@param bufnr? number Buffer number (default: current)
-function M.reset_processed(bufnr)
-	bufnr = bufnr or vim.api.nvim_get_current_buf()
-	for key, _ in pairs(processed_prompts) do
-		if key:match("^" .. bufnr .. ":") then
-			processed_prompts[key] = nil
-		end
-	end
-	utils.notify("Prompt history cleared - prompts can be re-processed")
-end
-
--- Track if we already opened the split for this buffer
---@type table<number, boolean>
-local auto_opened_buffers = {}
-
--- Auto-open target file when a coder file is opened directly
-function M.auto_open_target_file()
-	local window = require("codetyper.window")
-
-	-- Skip if split is already open
-	if window.is_open() then
-		return
-	end
-
-	local bufnr = vim.api.nvim_get_current_buf()
-
-	-- Skip if we already handled this buffer
-	if auto_opened_buffers[bufnr] then
-		return
-	end
-
-	local current_file = vim.fn.expand("%:p")
-
-	-- Skip empty paths
-	if not current_file or current_file == "" then
-		return
-	end
-
-	-- Verify it's a coder file
-	if not utils.is_coder_file(current_file) then
-		return
-	end
-
-	-- Skip if we're in a special buffer (nvim-tree, etc.)
-	local buftype = vim.bo[bufnr].buftype
-	if buftype ~= "" then
-		return
-	end
-
-	-- Mark as handled
-	auto_opened_buffers[bufnr] = true
-
-	-- Get the target file path
-	local target_path = utils.get_target_path(current_file)
-
-	-- Check if target file exists
-	if not utils.file_exists(target_path) then
-		utils.notify("Target file not found: " .. vim.fn.fnamemodify(target_path, ":t"), vim.log.levels.WARN)
-		return
-	end
-
-	-- Get config with fallback defaults
-	local codetyper = require("codetyper")
-	local config = codetyper.get_config()
-
-	-- Fallback width if config not fully loaded (percentage, e.g., 25 = 25%)
-	local width_pct = (config and config.window and config.window.width) or 25
-	local width = math.ceil(vim.o.columns * (width_pct / 100))
-
-	-- Store current coder window
-	local coder_win = vim.api.nvim_get_current_win()
-	local coder_buf = bufnr
-
-	-- Open target file in a vertical split on the right
-	local ok, err = pcall(function()
-		vim.cmd("vsplit " .. vim.fn.fnameescape(target_path))
-	end)
-
-	if not ok then
-		utils.notify("Failed to open target file: " .. tostring(err), vim.log.levels.ERROR)
-		auto_opened_buffers[bufnr] = nil -- Allow retry
-		return
-	end
-
-	-- Now we're in the target window (right side)
-	local target_win = vim.api.nvim_get_current_win()
-	local target_buf = vim.api.nvim_get_current_buf()
-
-	-- Set the coder window width (left side)
-	pcall(vim.api.nvim_win_set_width, coder_win, width)
-
-	-- Update window module state
-	window._coder_win = coder_win
-	window._coder_buf = coder_buf
-	window._target_win = target_win
-	window._target_buf = target_buf
-
-	-- Set up window options for coder window
-	pcall(function()
-		vim.wo[coder_win].number = true
-		vim.wo[coder_win].relativenumber = true
-		vim.wo[coder_win].signcolumn = "yes"
-	end)
-
-	utils.notify("Opened target: " .. vim.fn.fnamemodify(target_path, ":t"))
-end
-
--- Clear auto-opened tracking for a buffer
---@param bufnr number Buffer number
-function M.clear_auto_opened(bufnr)
-	auto_opened_buffers[bufnr] = nil
-end
-
--- Set appropriate filetype for coder files
-function M.set_coder_filetype()
-	local filepath = vim.fn.expand("%:p")
-
-	-- Extract the actual extension (e.g., index.coder.ts -> ts)
-	local ext = filepath:match("%.coder%.(%w+)$")
-
-	if ext then
-		-- Map extension to filetype
-		local ft_map = {
-			ts = "typescript",
-			tsx = "typescriptreact",
-			js = "javascript",
-			jsx = "javascriptreact",
-			py = "python",
-			lua = "lua",
-			go = "go",
-			rs = "rust",
-			rb = "ruby",
-			java = "java",
-			c = "c",
-			cpp = "cpp",
-			cs = "cs",
-			json = "json",
-			yaml = "yaml",
-			yml = "yaml",
-			md = "markdown",
-			html = "html",
-			css = "css",
-			scss = "scss",
-			vue = "vue",
-			svelte = "svelte",
-		}
-
-		local filetype = ft_map[ext] or ext
-		vim.bo.filetype = filetype
-	end
-end
-
--- Clear all autocommands
-function M.clear()
-	vim.api.nvim_del_augroup_by_name(AUGROUP)
-end
-
--- Track buffers that have been auto-indexed
---@type table<number, boolean>
-local auto_indexed_buffers = {}
-
--- Supported file extensions for auto-indexing
-local supported_extensions = {
-	"ts", "tsx", "js", "jsx", "py", "lua", "go", "rs", "rb",
-	"java", "c", "cpp", "cs", "json", "yaml", "yml", "md",
-	"html", "css", "scss", "vue", "svelte", "php", "sh", "zsh",
-}
-
--- Check if extension is supported
---@param ext string File extension
---@return boolean
-local function is_supported_extension(ext)
-	for _, supported in ipairs(supported_extensions) do
-		if ext == supported then
-			return true
-		end
-	end
-	return false
-end
-
--- Auto-index a file by creating/opening its coder companion
---@param bufnr number Buffer number
-function M.auto_index_file(bufnr)
-	-- Skip if buffer is invalid
-	if not vim.api.nvim_buf_is_valid(bufnr) then
-		return
-	end
-
-	-- Skip if already indexed
-	if auto_indexed_buffers[bufnr] then
-		return
-	end
-
-	-- Get file path
-	local filepath = vim.api.nvim_buf_get_name(bufnr)
-	if not filepath or filepath == "" then
-		return
-	end
-
-	-- Skip coder files
-	if utils.is_coder_file(filepath) then
-		return
-	end
-
-	-- Skip special buffers
-	local buftype = vim.bo[bufnr].buftype
-	if buftype ~= "" then
-		return
-	end
-
-	-- Skip unsupported file types
-	local ext = vim.fn.fnamemodify(filepath, ":e")
-	if ext == "" or not is_supported_extension(ext) then
-		return
-	end
-
-	-- Skip if auto_index is disabled in config
-	local codetyper = require("codetyper")
-	local config = codetyper.get_config()
-	if config and config.auto_index == false then
-		return
-	end
-
-	-- Mark as indexed
-	auto_indexed_buffers[bufnr] = true
-
-	-- Get coder companion path
-	local coder_path = utils.get_coder_path(filepath)
-
-	-- Check if coder file already exists
-	local coder_exists = utils.file_exists(coder_path)
-
-	-- Create coder file with template if it doesn't exist
-	if not coder_exists then
-		local filename = vim.fn.fnamemodify(filepath, ":t")
-		local template = string.format(
-			[[-- Coder companion for %s
-- Use /@ @/ tags to write pseudo-code prompts
-- Example:
-- /@
-- Add a function that validates user input
-- - Check for empty strings
-- - Validate email format
-- @/
-
-]],
-			filename
-		)
-		utils.write_file(coder_path, template)
-	end
-
-	-- Notify user about the coder companion
-	local coder_filename = vim.fn.fnamemodify(coder_path, ":t")
-	if coder_exists then
-		utils.notify("Coder companion available: " .. coder_filename, vim.log.levels.DEBUG)
-	else
-		utils.notify("Created coder companion: " .. coder_filename, vim.log.levels.INFO)
-	end
-end
-
--- Open the coder companion for the current file
---@param open_split? boolean Whether to open in split view (default: true)
-function M.open_coder_companion(open_split)
-	open_split = open_split ~= false -- Default to true
-
-	local filepath = vim.fn.expand("%:p")
-	if not filepath or filepath == "" then
-		utils.notify("No file open", vim.log.levels.WARN)
-		return
-	end
-
-	if utils.is_coder_file(filepath) then
-		utils.notify("Already in coder file", vim.log.levels.INFO)
-		return
-	end
-
-	local coder_path = utils.get_coder_path(filepath)
-
-	-- Create if it doesn't exist
-	if not utils.file_exists(coder_path) then
-		local filename = vim.fn.fnamemodify(filepath, ":t")
-		local ext = vim.fn.fnamemodify(filepath, ":e")
-		local comment_prefix = "--"
-		if vim.tbl_contains({ "js", "jsx", "ts", "tsx", "java", "c", "cpp", "cs", "go", "rs", "php" }, ext) then
-			comment_prefix = "//"
-		elseif vim.tbl_contains({ "py", "sh", "zsh", "yaml", "yml" }, ext) then
-			comment_prefix = "#"
-		elseif vim.tbl_contains({ "html", "md" }, ext) then
-			comment_prefix = "<!--"
-		end
-
-		local close_comment = comment_prefix == "<!--" and " -->" or ""
-		local template = string.format(
-			[[%s Coder companion for %s%s
-%s Use /@ @/ tags to write pseudo-code prompts%s
-%s Example:%s
-%s /@%s
-%s Add a function that validates user input%s
-%s - Check for empty strings%s
-%s - Validate email format%s
-%s @/%s
-
-]],
-			comment_prefix, filename, close_comment,
-			comment_prefix, close_comment,
-			comment_prefix, close_comment,
-			comment_prefix, close_comment,
-			comment_prefix, close_comment,
-			comment_prefix, close_comment,
-			comment_prefix, close_comment,
-			comment_prefix, close_comment
-		)
-		utils.write_file(coder_path, template)
-	end
-
-	if open_split then
-		-- Use the window module to open split view
-		local window = require("codetyper.window")
-		window.open_split(coder_path, filepath)
-	else
-		-- Just open the coder file
-		vim.cmd("edit " .. vim.fn.fnameescape(coder_path))
-	end
-end
-
--- Clear auto-indexed tracking for a buffer
---@param bufnr number Buffer number
-function M.clear_auto_indexed(bufnr)
-	auto_indexed_buffers[bufnr] = nil
-end
-
-return M
--- a/lua/codetyper/commands.lua
+++ b/lua/codetyper/commands.lua
@@ -1,834 +0,0 @@
---@mod codetyper.commands Command definitions for Codetyper.nvim
-
-local M = {}
-
-local utils = require("codetyper.utils")
-local window = require("codetyper.window")
-
--- Open coder view for current file or select one
---@param opts? table Command options
-local function cmd_open(opts)
-  opts = opts or {}
-
-  local current_file = vim.fn.expand("%:p")
-
-  -- If no file is open, prompt user to select one
-  if current_file == "" or vim.bo.buftype ~= "" then
-    -- Use telescope or vim.ui.select to pick a file
-    if pcall(require, "telescope") then
-      require("telescope.builtin").find_files({
-        prompt_title = "Select file for Coder",
-        attach_mappings = function(prompt_bufnr, map)
-          local actions = require("telescope.actions")
-          local action_state = require("telescope.actions.state")
-
-          actions.select_default:replace(function()
-            actions.close(prompt_bufnr)
-            local selection = action_state.get_selected_entry()
-            if selection then
-              local target_path = selection.path or selection[1]
-              local coder_path = utils.get_coder_path(target_path)
-              window.open_split(target_path, coder_path)
-            end
-          end)
-          return true
-        end,
-      })
-    else
-      -- Fallback to input prompt
-      vim.ui.input({ prompt = "Enter file path: " }, function(input)
-        if input and input ~= "" then
-          local target_path = vim.fn.fnamemodify(input, ":p")
-          local coder_path = utils.get_coder_path(target_path)
-          window.open_split(target_path, coder_path)
-        end
-      end)
-    end
-    return
-  end
-
-  local target_path, coder_path
-
-  -- Check if current file is a coder file
-  if utils.is_coder_file(current_file) then
-    coder_path = current_file
-    target_path = utils.get_target_path(current_file)
-  else
-    target_path = current_file
-    coder_path = utils.get_coder_path(current_file)
-  end
-
-  window.open_split(target_path, coder_path)
-end
-
--- Close coder view
-local function cmd_close()
-  window.close_split()
-end
-
--- Toggle coder view
-local function cmd_toggle()
-  local current_file = vim.fn.expand("%:p")
-
-  if current_file == "" then
-    utils.notify("No file in current buffer", vim.log.levels.WARN)
-    return
-  end
-
-  local target_path, coder_path
-
-  if utils.is_coder_file(current_file) then
-    coder_path = current_file
-    target_path = utils.get_target_path(current_file)
-  else
-    target_path = current_file
-    coder_path = utils.get_coder_path(current_file)
-  end
-
-  window.toggle_split(target_path, coder_path)
-end
-
--- Build enhanced user prompt with context
---@param clean_prompt string The cleaned user prompt
---@param context table Context information
---@return string Enhanced prompt
-local function build_user_prompt(clean_prompt, context)
-  local enhanced = "TASK: " .. clean_prompt .. "\n\n"
-  
-  enhanced = enhanced .. "REQUIREMENTS:\n"
-  enhanced = enhanced .. "- Generate ONLY " .. (context.language or "code") .. " code\n"
-  enhanced = enhanced .. "- NO markdown code blocks (no ```)\n"
-  enhanced = enhanced .. "- NO explanations or comments about what you did\n"
-  enhanced = enhanced .. "- Match the coding style of the existing file exactly\n"
-  enhanced = enhanced .. "- Output must be ready to insert directly into the file\n"
-  
-  return enhanced
-end
-
--- Process prompt at cursor and generate code
-local function cmd_process()
-  local parser = require("codetyper.parser")
-  local llm = require("codetyper.llm")
-
-  local bufnr = vim.api.nvim_get_current_buf()
-  local current_file = vim.fn.expand("%:p")
-
-  if not utils.is_coder_file(current_file) then
-    utils.notify("Not a coder file. Use *.coder.* files", vim.log.levels.WARN)
-    return
-  end
-
-  local prompt = parser.get_last_prompt(bufnr)
-  if not prompt then
-    utils.notify("No prompt found. Use /@ your prompt @/", vim.log.levels.WARN)
-    return
-  end
-
-  local target_path = utils.get_target_path(current_file)
-  local prompt_type = parser.detect_prompt_type(prompt.content)
-  local context = llm.build_context(target_path, prompt_type)
-  local clean_prompt = parser.clean_prompt(prompt.content)
-  
-  -- Build enhanced prompt with explicit instructions
-  local enhanced_prompt = build_user_prompt(clean_prompt, context)
-
-  utils.notify("Processing: " .. clean_prompt:sub(1, 50) .. "...", vim.log.levels.INFO)
-
-  llm.generate(enhanced_prompt, context, function(response, err)
-    if err then
-      utils.notify("Generation failed: " .. err, vim.log.levels.ERROR)
-      return
-    end
-
-    if response then
-      -- Inject code into target file
-      local inject = require("codetyper.inject")
-      inject.inject_code(target_path, response, prompt_type)
-      utils.notify("Code generated and injected!", vim.log.levels.INFO)
-    end
-  end)
-end
-
--- Show plugin status
-local function cmd_status()
-  local codetyper = require("codetyper")
-  local config = codetyper.get_config()
-  local tree = require("codetyper.tree")
-
-  local stats = tree.get_stats()
-
-  local status = {
-    "Codetyper.nvim Status",
-    "====================",
-    "",
-    "Provider: " .. config.llm.provider,
-  }
-
-  if config.llm.provider == "claude" then
-    local has_key = (config.llm.claude.api_key or vim.env.ANTHROPIC_API_KEY) ~= nil
-    table.insert(status, "Claude API Key: " .. (has_key and "configured" or "NOT SET"))
-    table.insert(status, "Claude Model: " .. config.llm.claude.model)
-  else
-    table.insert(status, "Ollama Host: " .. config.llm.ollama.host)
-    table.insert(status, "Ollama Model: " .. config.llm.ollama.model)
-  end
-
-  table.insert(status, "")
-  table.insert(status, "Window Position: " .. config.window.position)
-  table.insert(status, "Window Width: " .. tostring(config.window.width * 100) .. "%")
-  table.insert(status, "")
-  table.insert(status, "View Open: " .. (window.is_open() and "yes" or "no"))
-  table.insert(status, "")
-  table.insert(status, "Project Stats:")
-  table.insert(status, "  Files: " .. stats.files)
-  table.insert(status, "  Directories: " .. stats.directories)
-  table.insert(status, "  Tree Log: " .. (tree.get_tree_log_path() or "N/A"))
-
-  utils.notify(table.concat(status, "\n"))
-end
-
--- Refresh tree.log manually
-local function cmd_tree()
-  local tree = require("codetyper.tree")
-  if tree.update_tree_log() then
-    utils.notify("Tree log updated: " .. tree.get_tree_log_path())
-  else
-    utils.notify("Failed to update tree log", vim.log.levels.ERROR)
-  end
-end
-
--- Open tree.log file
-local function cmd_tree_view()
-  local tree = require("codetyper.tree")
-  local tree_log_path = tree.get_tree_log_path()
-
-  if not tree_log_path then
-    utils.notify("Could not find tree.log", vim.log.levels.WARN)
-    return
-  end
-
-  -- Ensure tree is up to date
-  tree.update_tree_log()
-
-  -- Open in a new split
-  vim.cmd("vsplit " .. vim.fn.fnameescape(tree_log_path))
-  vim.bo.readonly = true
-  vim.bo.modifiable = false
-end
-
--- Reset processed prompts to allow re-processing
-local function cmd_reset()
-  local autocmds = require("codetyper.autocmds")
-  autocmds.reset_processed()
-end
-
--- Force update gitignore
-local function cmd_gitignore()
-  local gitignore = require("codetyper.gitignore")
-  gitignore.force_update()
-end
-
--- Open ask panel
-local function cmd_ask()
-  local ask = require("codetyper.ask")
-  ask.open()
-end
-
--- Close ask panel
-local function cmd_ask_close()
-  local ask = require("codetyper.ask")
-  ask.close()
-end
-
--- Toggle ask panel
-local function cmd_ask_toggle()
-  local ask = require("codetyper.ask")
-  ask.toggle()
-end
-
--- Clear ask history
-local function cmd_ask_clear()
-  local ask = require("codetyper.ask")
-  ask.clear_history()
-end
-
--- Open agent panel
-local function cmd_agent()
-  local agent_ui = require("codetyper.agent.ui")
-  agent_ui.open()
-end
-
--- Close agent panel
-local function cmd_agent_close()
-  local agent_ui = require("codetyper.agent.ui")
-  agent_ui.close()
-end
-
--- Toggle agent panel
-local function cmd_agent_toggle()
-  local agent_ui = require("codetyper.agent.ui")
-  agent_ui.toggle()
-end
-
--- Stop running agent
-local function cmd_agent_stop()
-  local agent = require("codetyper.agent")
-  if agent.is_running() then
-    agent.stop()
-    utils.notify("Agent stopped")
-  else
-    utils.notify("No agent running", vim.log.levels.INFO)
-  end
-end
-
--- Show chat type switcher modal (Ask/Agent)
-local function cmd_type_toggle()
-  local switcher = require("codetyper.chat_switcher")
-  switcher.show()
-end
-
--- Toggle logs panel
-local function cmd_logs_toggle()
-  local logs_panel = require("codetyper.logs_panel")
-  logs_panel.toggle()
-end
-
--- Switch focus between coder and target windows
-local function cmd_focus()
-  if not window.is_open() then
-    utils.notify("Coder view not open", vim.log.levels.WARN)
-    return
-  end
-
-  local current_win = vim.api.nvim_get_current_win()
-  if current_win == window.get_coder_win() then
-    window.focus_target()
-  else
-    window.focus_coder()
-  end
-end
-
--- Transform inline /@ @/ tags in current file
--- Works on ANY file, not just .coder.* files
-local function cmd_transform()
-  local parser = require("codetyper.parser")
-  local llm = require("codetyper.llm")
-  local logs_panel = require("codetyper.logs_panel")
-  local logs = require("codetyper.agent.logs")
-
-  local bufnr = vim.api.nvim_get_current_buf()
-  local filepath = vim.fn.expand("%:p")
-
-  if filepath == "" then
-    utils.notify("No file in current buffer", vim.log.levels.WARN)
-    return
-  end
-
-  -- Find all prompts in the current buffer
-  local prompts = parser.find_prompts_in_buffer(bufnr)
-
-  if #prompts == 0 then
-    utils.notify("No /@ @/ tags found in current file", vim.log.levels.INFO)
-    return
-  end
-
-  -- Open the logs panel to show generation progress
-  logs_panel.open()
-  logs.info("Transform started: " .. #prompts .. " prompt(s)")
-
-  utils.notify("Found " .. #prompts .. " prompt(s) to transform...", vim.log.levels.INFO)
-
-  -- Build context for this file
-  local ext = vim.fn.fnamemodify(filepath, ":e")
-  local context = llm.build_context(filepath, "code_generation")
-
-  -- Process prompts in reverse order (bottom to top) to maintain line numbers
-  local sorted_prompts = {}
-  for i = #prompts, 1, -1 do
-    table.insert(sorted_prompts, prompts[i])
-  end
-
-  -- Track how many are being processed
-  local pending = #sorted_prompts
-  local completed = 0
-  local errors = 0
-
-  -- Process each prompt
-  for _, prompt in ipairs(sorted_prompts) do
-    local clean_prompt = parser.clean_prompt(prompt.content)
-    local prompt_type = parser.detect_prompt_type(prompt.content)
-
-    -- Build enhanced user prompt
-    local enhanced_prompt = "TASK: " .. clean_prompt .. "\n\n"
-    enhanced_prompt = enhanced_prompt .. "REQUIREMENTS:\n"
-    enhanced_prompt = enhanced_prompt .. "- Generate ONLY " .. (context.language or "code") .. " code\n"
-    enhanced_prompt = enhanced_prompt .. "- NO markdown code blocks (no ```)\n"
-    enhanced_prompt = enhanced_prompt .. "- NO explanations or comments about what you did\n"
-    enhanced_prompt = enhanced_prompt .. "- Match the coding style of the existing file exactly\n"
-    enhanced_prompt = enhanced_prompt .. "- Output must be ready to insert directly into the file\n"
-
-    logs.info("Processing: " .. clean_prompt:sub(1, 40) .. "...")
-    utils.notify("Processing: " .. clean_prompt:sub(1, 40) .. "...", vim.log.levels.INFO)
-
-    -- Generate code for this prompt
-    llm.generate(enhanced_prompt, context, function(response, err)
-      if err then
-        logs.error("Failed: " .. err)
-        utils.notify("Failed: " .. err, vim.log.levels.ERROR)
-        errors = errors + 1
-      elseif response then
-        -- Replace the prompt tag with generated code
-        vim.schedule(function()
-          -- Get current buffer lines
-          local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
-
-          -- Calculate the exact range to replace
-          local start_line = prompt.start_line
-          local end_line = prompt.end_line
-
-          -- Find the full lines containing the tags
-          local start_line_content = lines[start_line] or ""
-          local end_line_content = lines[end_line] or ""
-
-          -- Check if there's content before the opening tag on the same line
-          local codetyper = require("codetyper")
-          local config = codetyper.get_config()
-          local before_tag = ""
-          local after_tag = ""
-
-          local open_pos = start_line_content:find(utils.escape_pattern(config.patterns.open_tag))
-          if open_pos and open_pos > 1 then
-            before_tag = start_line_content:sub(1, open_pos - 1)
-          end
-
-          local close_pos = end_line_content:find(utils.escape_pattern(config.patterns.close_tag))
-          if close_pos then
-            local after_close = close_pos + #config.patterns.close_tag
-            if after_close <= #end_line_content then
-              after_tag = end_line_content:sub(after_close)
-            end
-          end
-
-          -- Build the replacement lines
-          local replacement_lines = vim.split(response, "\n", { plain = true })
-
-          -- Add before/after content if any
-          if before_tag ~= "" and #replacement_lines > 0 then
-            replacement_lines[1] = before_tag .. replacement_lines[1]
-          end
-          if after_tag ~= "" and #replacement_lines > 0 then
-            replacement_lines[#replacement_lines] = replacement_lines[#replacement_lines] .. after_tag
-          end
-
-          -- Replace the lines in buffer
-          vim.api.nvim_buf_set_lines(bufnr, start_line - 1, end_line, false, replacement_lines)
-
-          completed = completed + 1
-          if completed + errors >= pending then
-            local msg = "Transform complete: " .. completed .. " succeeded, " .. errors .. " failed"
-            logs.info(msg)
-            utils.notify(msg, errors > 0 and vim.log.levels.WARN or vim.log.levels.INFO)
-          end
-        end)
-      end
-    end)
-  end
-end
-
--- Transform prompts within a line range (for visual selection)
---@param start_line number Start line (1-indexed)
---@param end_line number End line (1-indexed)
-local function cmd_transform_range(start_line, end_line)
-  local parser = require("codetyper.parser")
-  local llm = require("codetyper.llm")
-  local logs_panel = require("codetyper.logs_panel")
-  local logs = require("codetyper.agent.logs")
-
-  local bufnr = vim.api.nvim_get_current_buf()
-  local filepath = vim.fn.expand("%:p")
-
-  if filepath == "" then
-    utils.notify("No file in current buffer", vim.log.levels.WARN)
-    return
-  end
-
-  -- Find all prompts in the current buffer
-  local all_prompts = parser.find_prompts_in_buffer(bufnr)
-
-  -- Filter prompts that are within the selected range
-  local prompts = {}
-  for _, prompt in ipairs(all_prompts) do
-    if prompt.start_line >= start_line and prompt.end_line <= end_line then
-      table.insert(prompts, prompt)
-    end
-  end
-
-  if #prompts == 0 then
-    utils.notify("No /@ @/ tags found in selection (lines " .. start_line .. "-" .. end_line .. ")", vim.log.levels.INFO)
-    return
-  end
-
-  -- Open the logs panel to show generation progress
-  logs_panel.open()
-  logs.info("Transform selection: " .. #prompts .. " prompt(s)")
-
-  utils.notify("Found " .. #prompts .. " prompt(s) in selection to transform...", vim.log.levels.INFO)
-
-  -- Build context for this file
-  local context = llm.build_context(filepath, "code_generation")
-
-  -- Process prompts in reverse order (bottom to top) to maintain line numbers
-  local sorted_prompts = {}
-  for i = #prompts, 1, -1 do
-    table.insert(sorted_prompts, prompts[i])
-  end
-
-  local pending = #sorted_prompts
-  local completed = 0
-  local errors = 0
-
-  for _, prompt in ipairs(sorted_prompts) do
-    local clean_prompt = parser.clean_prompt(prompt.content)
-
-    local enhanced_prompt = "TASK: " .. clean_prompt .. "\n\n"
-    enhanced_prompt = enhanced_prompt .. "REQUIREMENTS:\n"
-    enhanced_prompt = enhanced_prompt .. "- Generate ONLY " .. (context.language or "code") .. " code\n"
-    enhanced_prompt = enhanced_prompt .. "- NO markdown code blocks (no ```)\n"
-    enhanced_prompt = enhanced_prompt .. "- NO explanations or comments about what you did\n"
-    enhanced_prompt = enhanced_prompt .. "- Match the coding style of the existing file exactly\n"
-    enhanced_prompt = enhanced_prompt .. "- Output must be ready to insert directly into the file\n"
-
-    logs.info("Processing: " .. clean_prompt:sub(1, 40) .. "...")
-    utils.notify("Processing: " .. clean_prompt:sub(1, 40) .. "...", vim.log.levels.INFO)
-
-    llm.generate(enhanced_prompt, context, function(response, err)
-      if err then
-        logs.error("Failed: " .. err)
-        utils.notify("Failed: " .. err, vim.log.levels.ERROR)
-        errors = errors + 1
-      elseif response then
-        vim.schedule(function()
-          local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
-          local p_start_line = prompt.start_line
-          local p_end_line = prompt.end_line
-
-          local start_line_content = lines[p_start_line] or ""
-          local end_line_content = lines[p_end_line] or ""
-
-          local codetyper = require("codetyper")
-          local config = codetyper.get_config()
-          local before_tag = ""
-          local after_tag = ""
-
-          local open_pos = start_line_content:find(utils.escape_pattern(config.patterns.open_tag))
-          if open_pos and open_pos > 1 then
-            before_tag = start_line_content:sub(1, open_pos - 1)
-          end
-
-          local close_pos = end_line_content:find(utils.escape_pattern(config.patterns.close_tag))
-          if close_pos then
-            local after_close = close_pos + #config.patterns.close_tag
-            if after_close <= #end_line_content then
-              after_tag = end_line_content:sub(after_close)
-            end
-          end
-
-          local replacement_lines = vim.split(response, "\n", { plain = true })
-
-          if before_tag ~= "" and #replacement_lines > 0 then
-            replacement_lines[1] = before_tag .. replacement_lines[1]
-          end
-          if after_tag ~= "" and #replacement_lines > 0 then
-            replacement_lines[#replacement_lines] = replacement_lines[#replacement_lines] .. after_tag
-          end
-
-          vim.api.nvim_buf_set_lines(bufnr, p_start_line - 1, p_end_line, false, replacement_lines)
-
-          completed = completed + 1
-          if completed + errors >= pending then
-            local msg = "Transform complete: " .. completed .. " succeeded, " .. errors .. " failed"
-            logs.info(msg)
-            utils.notify(msg, errors > 0 and vim.log.levels.WARN or vim.log.levels.INFO)
-          end
-        end)
-      end
-    end)
-  end
-end
-
--- Command wrapper for visual selection transform
-local function cmd_transform_visual()
-  -- Get visual selection marks
-  local start_line = vim.fn.line("'<")
-  local end_line = vim.fn.line("'>")
-  cmd_transform_range(start_line, end_line)
-end
-
--- Transform a single prompt at cursor position
-local function cmd_transform_at_cursor()
-  local parser = require("codetyper.parser")
-  local llm = require("codetyper.llm")
-  local logs_panel = require("codetyper.logs_panel")
-  local logs = require("codetyper.agent.logs")
-
-  local bufnr = vim.api.nvim_get_current_buf()
-  local filepath = vim.fn.expand("%:p")
-
-  if filepath == "" then
-    utils.notify("No file in current buffer", vim.log.levels.WARN)
-    return
-  end
-
-  -- Find prompt at cursor
-  local prompt = parser.get_prompt_at_cursor(bufnr)
-
-  if not prompt then
-    utils.notify("No /@ @/ tag at cursor position", vim.log.levels.WARN)
-    return
-  end
-
-  -- Open the logs panel to show generation progress
-  logs_panel.open()
-
-  local clean_prompt = parser.clean_prompt(prompt.content)
-  local context = llm.build_context(filepath, "code_generation")
-
-  logs.info("Transform cursor: " .. clean_prompt:sub(1, 40) .. "...")
-
-  -- Build enhanced user prompt
-  local enhanced_prompt = "TASK: " .. clean_prompt .. "\n\n"
-  enhanced_prompt = enhanced_prompt .. "REQUIREMENTS:\n"
-  enhanced_prompt = enhanced_prompt .. "- Generate ONLY " .. (context.language or "code") .. " code\n"
-  enhanced_prompt = enhanced_prompt .. "- NO markdown code blocks (no ```)\n"
-  enhanced_prompt = enhanced_prompt .. "- NO explanations or comments about what you did\n"
-  enhanced_prompt = enhanced_prompt .. "- Match the coding style of the existing file exactly\n"
-  enhanced_prompt = enhanced_prompt .. "- Output must be ready to insert directly into the file\n"
-
-  utils.notify("Transforming: " .. clean_prompt:sub(1, 40) .. "...", vim.log.levels.INFO)
-
-  llm.generate(enhanced_prompt, context, function(response, err)
-    if err then
-      logs.error("Transform failed: " .. err)
-      utils.notify("Transform failed: " .. err, vim.log.levels.ERROR)
-      return
-    end
-
-    if response then
-      vim.schedule(function()
-        local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
-        local start_line = prompt.start_line
-        local end_line = prompt.end_line
-
-        local start_line_content = lines[start_line] or ""
-        local end_line_content = lines[end_line] or ""
-
-        local codetyper = require("codetyper")
-        local config = codetyper.get_config()
-        local before_tag = ""
-        local after_tag = ""
-
-        local open_pos = start_line_content:find(utils.escape_pattern(config.patterns.open_tag))
-        if open_pos and open_pos > 1 then
-          before_tag = start_line_content:sub(1, open_pos - 1)
-        end
-
-        local close_pos = end_line_content:find(utils.escape_pattern(config.patterns.close_tag))
-        if close_pos then
-          local after_close = close_pos + #config.patterns.close_tag
-          if after_close <= #end_line_content then
-            after_tag = end_line_content:sub(after_close)
-          end
-        end
-
-        local replacement_lines = vim.split(response, "\n", { plain = true })
-
-        if before_tag ~= "" and #replacement_lines > 0 then
-          replacement_lines[1] = before_tag .. replacement_lines[1]
-        end
-        if after_tag ~= "" and #replacement_lines > 0 then
-          replacement_lines[#replacement_lines] = replacement_lines[#replacement_lines] .. after_tag
-        end
-
-        vim.api.nvim_buf_set_lines(bufnr, start_line - 1, end_line, false, replacement_lines)
-        logs.info("Transform complete!")
-        utils.notify("Transform complete!", vim.log.levels.INFO)
-      end)
-    end
-  end)
-end
-
--- Main command dispatcher
---@param args table Command arguments
-local function coder_cmd(args)
-  local subcommand = args.fargs[1] or "toggle"
-
-  local commands = {
-    open = cmd_open,
-    close = cmd_close,
-    toggle = cmd_toggle,
-    process = cmd_process,
-    status = cmd_status,
-    focus = cmd_focus,
-    tree = cmd_tree,
-    ["tree-view"] = cmd_tree_view,
-    reset = cmd_reset,
-    ask = cmd_ask,
-    ["ask-close"] = cmd_ask_close,
-    ["ask-toggle"] = cmd_ask_toggle,
-    ["ask-clear"] = cmd_ask_clear,
-    gitignore = cmd_gitignore,
-    transform = cmd_transform,
-    ["transform-cursor"] = cmd_transform_at_cursor,
-    agent = cmd_agent,
-    ["agent-close"] = cmd_agent_close,
-    ["agent-toggle"] = cmd_agent_toggle,
-    ["agent-stop"] = cmd_agent_stop,
-    ["type-toggle"] = cmd_type_toggle,
-    ["logs-toggle"] = cmd_logs_toggle,
-  }
-
-  local cmd_fn = commands[subcommand]
-  if cmd_fn then
-    cmd_fn(args)
-  else
-    utils.notify("Unknown subcommand: " .. subcommand, vim.log.levels.ERROR)
-  end
-end
-
--- Setup all commands
-function M.setup()
-  vim.api.nvim_create_user_command("Coder", coder_cmd, {
-    nargs = "?",
-    complete = function()
-      return {
-        "open", "close", "toggle", "process", "status", "focus",
-        "tree", "tree-view", "reset", "gitignore",
-        "ask", "ask-close", "ask-toggle", "ask-clear",
-        "transform", "transform-cursor",
-        "agent", "agent-close", "agent-toggle", "agent-stop",
-        "type-toggle", "logs-toggle",
-      }
-    end,
-    desc = "Codetyper.nvim commands",
-  })
-
-  -- Convenience aliases
-  vim.api.nvim_create_user_command("CoderOpen", function()
-    cmd_open()
-  end, { desc = "Open Coder view" })
-
-  vim.api.nvim_create_user_command("CoderClose", function()
-    cmd_close()
-  end, { desc = "Close Coder view" })
-
-  vim.api.nvim_create_user_command("CoderToggle", function()
-    cmd_toggle()
-  end, { desc = "Toggle Coder view" })
-
-  vim.api.nvim_create_user_command("CoderProcess", function()
-    cmd_process()
-  end, { desc = "Process prompt and generate code" })
-
-  vim.api.nvim_create_user_command("CoderTree", function()
-    cmd_tree()
-  end, { desc = "Refresh tree.log" })
-
-  vim.api.nvim_create_user_command("CoderTreeView", function()
-    cmd_tree_view()
-  end, { desc = "View tree.log" })
-
-  -- Ask panel commands
-  vim.api.nvim_create_user_command("CoderAsk", function()
-    cmd_ask()
-  end, { desc = "Open Ask panel" })
-
-  vim.api.nvim_create_user_command("CoderAskToggle", function()
-    cmd_ask_toggle()
-  end, { desc = "Toggle Ask panel" })
-
-  vim.api.nvim_create_user_command("CoderAskClear", function()
-    cmd_ask_clear()
-  end, { desc = "Clear Ask history" })
-
-  -- Transform commands (inline /@ @/ tag replacement)
-  vim.api.nvim_create_user_command("CoderTransform", function()
-    cmd_transform()
-  end, { desc = "Transform all /@ @/ tags in current file" })
-
-  vim.api.nvim_create_user_command("CoderTransformCursor", function()
-    cmd_transform_at_cursor()
-  end, { desc = "Transform /@ @/ tag at cursor" })
-
-  vim.api.nvim_create_user_command("CoderTransformVisual", function(opts)
-    local start_line = opts.line1
-    local end_line = opts.line2
-    cmd_transform_range(start_line, end_line)
-  end, { range = true, desc = "Transform /@ @/ tags in visual selection" })
-
-  -- Agent commands
-  vim.api.nvim_create_user_command("CoderAgent", function()
-    cmd_agent()
-  end, { desc = "Open Agent panel" })
-
-  vim.api.nvim_create_user_command("CoderAgentToggle", function()
-    cmd_agent_toggle()
-  end, { desc = "Toggle Agent panel" })
-
-  vim.api.nvim_create_user_command("CoderAgentStop", function()
-    cmd_agent_stop()
-  end, { desc = "Stop running agent" })
-
-  -- Chat type switcher command
-  vim.api.nvim_create_user_command("CoderType", function()
-    cmd_type_toggle()
-  end, { desc = "Show Ask/Agent mode switcher" })
-
-  -- Logs panel command
-  vim.api.nvim_create_user_command("CoderLogs", function()
-    cmd_logs_toggle()
-  end, { desc = "Toggle logs panel" })
-
-  -- Index command - open coder companion for current file
-  vim.api.nvim_create_user_command("CoderIndex", function()
-    local autocmds = require("codetyper.autocmds")
-    autocmds.open_coder_companion()
-  end, { desc = "Open coder companion for current file" })
-
-  -- Setup default keymaps
-  M.setup_keymaps()
-end
-
--- Setup default keymaps for transform commands
-function M.setup_keymaps()
-  -- Visual mode: transform selected /@ @/ tags
-  vim.keymap.set("v", "<leader>ctt", ":<C-u>CoderTransformVisual<CR>", { 
-    silent = true, 
-    desc = "Coder: Transform selected tags" 
-  })
-
-  -- Normal mode: transform tag at cursor
-  vim.keymap.set("n", "<leader>ctt", "<cmd>CoderTransformCursor<CR>", { 
-    silent = true, 
-    desc = "Coder: Transform tag at cursor" 
-  })
-
-  -- Normal mode: transform all tags in file
-  vim.keymap.set("n", "<leader>ctT", "<cmd>CoderTransform<CR>", {
-    silent = true,
-    desc = "Coder: Transform all tags in file"
-  })
-
-  -- Agent keymaps
-  vim.keymap.set("n", "<leader>ca", "<cmd>CoderAgentToggle<CR>", {
-    silent = true,
-    desc = "Coder: Toggle Agent panel"
-  })
-
-  -- Index keymap - open coder companion
-  vim.keymap.set("n", "<leader>ci", "<cmd>CoderIndex<CR>", {
-    silent = true,
-    desc = "Coder: Open coder companion for file"
-  })
-end
-
-return M
--- a/lua/codetyper/commands/agents/banned.lua
+++ b/lua/codetyper/commands/agents/banned.lua
@@ -0,0 +1,18 @@
+--- Banned commands for safety
+M.BANNED_COMMANDS = {
+	"rm -rf /",
+	"rm -rf /*",
+	"dd if=/dev/zero",
+	"mkfs",
+	":(){ :|:& };:",
+	"> /dev/sda",
+}
+
+--- Banned patterns
+M.BANNED_PATTERNS = {
+	"curl.*|.*sh",
+	"wget.*|.*sh",
+	"rm%s+%-rf%s+/",
+}
+
+return M
--- a/lua/codetyper/config/credentials.lua
+++ b/lua/codetyper/config/credentials.lua
@@ -0,0 +1,681 @@
+---@mod codetyper.credentials Secure credential storage for Codetyper.nvim
+---@brief [[
+--- Manages API keys and model preferences stored outside of config files.
+--- Credentials are stored in ~/.local/share/nvim/codetyper/configuration.json
+---@brief ]]
+
+local M = {}
+
+local utils = require("codetyper.support.utils")
+
+--- Get the credentials file path
+---@return string Path to credentials file
+local function get_credentials_path()
+	local data_dir = vim.fn.stdpath("data")
+	return data_dir .. "/codetyper/configuration.json"
+end
+
+--- Ensure the credentials directory exists
+---@return boolean Success
+local function ensure_dir()
+	local data_dir = vim.fn.stdpath("data")
+	local codetyper_dir = data_dir .. "/codetyper"
+	return utils.ensure_dir(codetyper_dir)
+end
+
+--- Load credentials from file
+---@return table Credentials data
+function M.load()
+	local path = get_credentials_path()
+	local content = utils.read_file(path)
+
+	if not content or content == "" then
+		return {
+			version = 1,
+			providers = {},
+		}
+	end
+
+	local ok, data = pcall(vim.json.decode, content)
+	if not ok or not data then
+		return {
+			version = 1,
+			providers = {},
+		}
+	end
+
+	return data
+end
+
+--- Save credentials to file
+---@param data table Credentials data
+---@return boolean Success
+function M.save(data)
+	if not ensure_dir() then
+		return false
+	end
+
+	local path = get_credentials_path()
+	local ok, json = pcall(vim.json.encode, data)
+	if not ok then
+		return false
+	end
+
+	return utils.write_file(path, json)
+end
+
+--- Get API key for a provider
+---@param provider string Provider name (claude, openai, gemini, copilot, ollama)
+---@return string|nil API key or nil if not found
+function M.get_api_key(provider)
+	local data = M.load()
+	local provider_data = data.providers and data.providers[provider]
+
+	if provider_data and provider_data.api_key then
+		return provider_data.api_key
+	end
+
+	return nil
+end
+
+--- Get model for a provider
+---@param provider string Provider name
+---@return string|nil Model name or nil if not found
+function M.get_model(provider)
+	local data = M.load()
+	local provider_data = data.providers and data.providers[provider]
+
+	if provider_data and provider_data.model then
+		return provider_data.model
+	end
+
+	return nil
+end
+
+--- Get endpoint for a provider (for custom OpenAI-compatible endpoints)
+---@param provider string Provider name
+---@return string|nil Endpoint URL or nil if not found
+function M.get_endpoint(provider)
+	local data = M.load()
+	local provider_data = data.providers and data.providers[provider]
+
+	if provider_data and provider_data.endpoint then
+		return provider_data.endpoint
+	end
+
+	return nil
+end
+
+--- Get host for Ollama
+---@return string|nil Host URL or nil if not found
+function M.get_ollama_host()
+	local data = M.load()
+	local provider_data = data.providers and data.providers.ollama
+
+	if provider_data and provider_data.host then
+		return provider_data.host
+	end
+
+	return nil
+end
+
+--- Set credentials for a provider
+---@param provider string Provider name
+---@param credentials table Credentials (api_key, model, endpoint, host)
+---@return boolean Success
+function M.set_credentials(provider, credentials)
+	local data = M.load()
+
+	if not data.providers then
+		data.providers = {}
+	end
+
+	if not data.providers[provider] then
+		data.providers[provider] = {}
+	end
+
+	-- Merge credentials
+	for key, value in pairs(credentials) do
+		if value and value ~= "" then
+			data.providers[provider][key] = value
+		end
+	end
+
+	data.updated = os.time()
+
+	return M.save(data)
+end
+
+--- Remove credentials for a provider
+---@param provider string Provider name
+---@return boolean Success
+function M.remove_credentials(provider)
+	local data = M.load()
+
+	if data.providers and data.providers[provider] then
+		data.providers[provider] = nil
+		data.updated = os.time()
+		return M.save(data)
+	end
+
+	return true
+end
+
+--- List all configured providers (checks both stored credentials AND config)
+---@return table List of provider names with their config status
+function M.list_providers()
+	local data = M.load()
+	local result = {}
+
+	local all_providers = { "claude", "openai", "gemini", "copilot", "ollama" }
+
+	for _, provider in ipairs(all_providers) do
+		local provider_data = data.providers and data.providers[provider]
+		local has_stored_key = provider_data and provider_data.api_key and provider_data.api_key ~= ""
+		local has_model = provider_data and provider_data.model and provider_data.model ~= ""
+
+		-- Check if configured from config or environment
+		local configured_from_config = false
+		local config_model = nil
+		local ok, codetyper = pcall(require, "codetyper")
+		if ok then
+			local config = codetyper.get_config()
+			if config and config.llm and config.llm[provider] then
+				local pc = config.llm[provider]
+				config_model = pc.model
+
+				if provider == "claude" then
+					configured_from_config = pc.api_key ~= nil or vim.env.ANTHROPIC_API_KEY ~= nil
+				elseif provider == "openai" then
+					configured_from_config = pc.api_key ~= nil or vim.env.OPENAI_API_KEY ~= nil
+				elseif provider == "gemini" then
+					configured_from_config = pc.api_key ~= nil or vim.env.GEMINI_API_KEY ~= nil
+				elseif provider == "copilot" then
+					configured_from_config = true -- Just needs copilot.lua
+				elseif provider == "ollama" then
+					configured_from_config = pc.host ~= nil
+				end
+			end
+		end
+
+		local is_configured = has_stored_key
+			or (provider == "ollama" and provider_data ~= nil)
+			or (provider == "copilot" and (provider_data ~= nil or configured_from_config))
+			or configured_from_config
+
+		table.insert(result, {
+			name = provider,
+			configured = is_configured,
+			has_api_key = has_stored_key,
+			has_model = has_model or config_model ~= nil,
+			model = (provider_data and provider_data.model) or config_model,
+			source = has_stored_key and "stored" or (configured_from_config and "config" or nil),
+		})
+	end
+
+	return result
+end
+
+--- Default models for each provider
+M.default_models = {
+	claude = "claude-sonnet-4-20250514",
+	openai = "gpt-4o",
+	gemini = "gemini-2.0-flash",
+	copilot = "claude-sonnet-4",
+	ollama = "deepseek-coder:6.7b",
+}
+
+--- Available models for Copilot (GitHub Copilot Chat API)
+--- Models with cost multipliers: 0x = free, 0.33x = discount, 1x = standard, 3x = premium
+M.copilot_models = {
+	-- Free tier (0x)
+	{ name = "gpt-4.1", cost = "0x" },
+	{ name = "gpt-4o", cost = "0x" },
+	{ name = "gpt-5-mini", cost = "0x" },
+	{ name = "grok-code-fast-1", cost = "0x" },
+	{ name = "raptor-mini", cost = "0x" },
+	-- Discount tier (0.33x)
+	{ name = "claude-haiku-4.5", cost = "0.33x" },
+	{ name = "gemini-3-flash", cost = "0.33x" },
+	{ name = "gpt-5.1-codex-mini", cost = "0.33x" },
+	-- Standard tier (1x)
+	{ name = "claude-sonnet-4", cost = "1x" },
+	{ name = "claude-sonnet-4.5", cost = "1x" },
+	{ name = "gemini-2.5-pro", cost = "1x" },
+	{ name = "gemini-3-pro", cost = "1x" },
+	{ name = "gpt-5", cost = "1x" },
+	{ name = "gpt-5-codex", cost = "1x" },
+	{ name = "gpt-5.1", cost = "1x" },
+	{ name = "gpt-5.1-codex", cost = "1x" },
+	{ name = "gpt-5.1-codex-max", cost = "1x" },
+	{ name = "gpt-5.2", cost = "1x" },
+	{ name = "gpt-5.2-codex", cost = "1x" },
+	-- Premium tier (3x)
+	{ name = "claude-opus-4.5", cost = "3x" },
+}
+
+--- Get list of copilot model names (for completion)
+---@return string[]
+function M.get_copilot_model_names()
+	local names = {}
+	for _, model in ipairs(M.copilot_models) do
+		table.insert(names, model.name)
+	end
+	return names
+end
+
+--- Get cost for a copilot model
+---@param model_name string
+---@return string|nil
+function M.get_copilot_model_cost(model_name)
+	for _, model in ipairs(M.copilot_models) do
+		if model.name == model_name then
+			return model.cost
+		end
+	end
+	return nil
+end
+
+--- Interactive command to add/update API key
+function M.interactive_add()
+	local providers = { "claude", "openai", "gemini", "copilot", "ollama" }
+
+	-- Step 1: Select provider
+	vim.ui.select(providers, {
+		prompt = "Select LLM provider:",
+		format_item = function(item)
+			local display = item:sub(1, 1):upper() .. item:sub(2)
+			local creds = M.load()
+			local configured = creds.providers and creds.providers[item]
+			if configured and (configured.api_key or item == "ollama") then
+				return display .. " [configured]"
+			end
+			return display
+		end,
+	}, function(provider)
+		if not provider then
+			return
+		end
+
+		-- Step 2: Get API key (skip for Ollama)
+		if provider == "ollama" then
+			M.interactive_ollama_config()
+		else
+			M.interactive_api_key(provider)
+		end
+	end)
+end
+
+--- Interactive API key input
+---@param provider string Provider name
+function M.interactive_api_key(provider)
+	-- Copilot uses OAuth from copilot.lua, no API key needed
+	if provider == "copilot" then
+		M.interactive_copilot_config()
+		return
+	end
+
+	local prompt = string.format("Enter %s API key (leave empty to skip): ", provider:upper())
+
+	vim.ui.input({ prompt = prompt }, function(api_key)
+		if api_key == nil then
+			return -- Cancelled
+		end
+
+		-- Step 3: Get model
+		M.interactive_model(provider, api_key)
+	end)
+end
+
+--- Interactive Copilot configuration (no API key, uses OAuth)
+---@param silent? boolean If true, don't show the OAuth info message
+function M.interactive_copilot_config(silent)
+	if not silent then
+		utils.notify("Copilot uses OAuth from copilot.lua/copilot.vim - no API key needed", vim.log.levels.INFO)
+	end
+
+	-- Get current model if configured
+	local current_model = M.get_model("copilot") or M.default_models.copilot
+	local current_cost = M.get_copilot_model_cost(current_model) or "?"
+
+	-- Build model options with "Custom..." option
+	local model_options = vim.deepcopy(M.copilot_models)
+	table.insert(model_options, { name = "Custom...", cost = "" })
+
+	vim.ui.select(model_options, {
+		prompt = "Select Copilot model (current: " .. current_model .. " — " .. current_cost .. "):",
+		format_item = function(item)
+			local display = item.name
+			if item.cost and item.cost ~= "" then
+				display = display .. " — " .. item.cost
+			end
+			if item.name == current_model then
+				display = display .. " [current]"
+			end
+			return display
+		end,
+	}, function(choice)
+		if choice == nil then
+			return -- Cancelled
+		end
+
+		if choice.name == "Custom..." then
+			-- Allow custom model input
+			vim.ui.input({
+				prompt = "Enter custom model name: ",
+				default = current_model,
+			}, function(custom_model)
+				if custom_model and custom_model ~= "" then
+					M.save_and_notify("copilot", {
+						model = custom_model,
+						configured = true,
+					})
+				end
+			end)
+		else
+			M.save_and_notify("copilot", {
+				model = choice.name,
+				configured = true,
+			})
+		end
+	end)
+end
+
+--- Interactive model selection
+---@param provider string Provider name
+---@param api_key string|nil API key
+function M.interactive_model(provider, api_key)
+	local default_model = M.default_models[provider] or ""
+	local prompt = string.format("Enter model (default: %s): ", default_model)
+
+	vim.ui.input({ prompt = prompt, default = default_model }, function(model)
+		if model == nil then
+			return -- Cancelled
+		end
+
+		-- Use default if empty
+		if model == "" then
+			model = default_model
+		end
+
+		-- Save credentials
+		local credentials = {
+			model = model,
+		}
+
+		if api_key and api_key ~= "" then
+			credentials.api_key = api_key
+		end
+
+		-- For OpenAI, also ask for custom endpoint
+		if provider == "openai" then
+			M.interactive_endpoint(provider, credentials)
+		else
+			M.save_and_notify(provider, credentials)
+		end
+	end)
+end
+
+--- Interactive endpoint input for OpenAI-compatible providers
+---@param provider string Provider name
+---@param credentials table Current credentials
+function M.interactive_endpoint(provider, credentials)
+	vim.ui.input({
+		prompt = "Custom endpoint (leave empty for default OpenAI): ",
+	}, function(endpoint)
+		if endpoint == nil then
+			return -- Cancelled
+		end
+
+		if endpoint ~= "" then
+			credentials.endpoint = endpoint
+		end
+
+		M.save_and_notify(provider, credentials)
+	end)
+end
+
+--- Interactive Ollama configuration
+function M.interactive_ollama_config()
+	vim.ui.input({
+		prompt = "Ollama host (default: http://localhost:11434): ",
+		default = "http://localhost:11434",
+	}, function(host)
+		if host == nil then
+			return -- Cancelled
+		end
+
+		if host == "" then
+			host = "http://localhost:11434"
+		end
+
+		-- Get model
+		local default_model = M.default_models.ollama
+		vim.ui.input({
+			prompt = string.format("Ollama model (default: %s): ", default_model),
+			default = default_model,
+		}, function(model)
+			if model == nil then
+				return -- Cancelled
+			end
+
+			if model == "" then
+				model = default_model
+			end
+
+			M.save_and_notify("ollama", {
+				host = host,
+				model = model,
+			})
+		end)
+	end)
+end
+
+--- Save credentials and notify user
+---@param provider string Provider name
+---@param credentials table Credentials to save
+function M.save_and_notify(provider, credentials)
+	if M.set_credentials(provider, credentials) then
+		local msg = string.format("Saved %s configuration", provider:upper())
+		if credentials.model then
+			msg = msg .. " (model: " .. credentials.model .. ")"
+		end
+		utils.notify(msg, vim.log.levels.INFO)
+	else
+		utils.notify("Failed to save credentials", vim.log.levels.ERROR)
+	end
+end
+
+--- Show current credentials status
+function M.show_status()
+	local providers = M.list_providers()
+
+	-- Get current active provider
+	local codetyper = require("codetyper")
+	local current = codetyper.get_config().llm.provider
+
+	local lines = {
+		"Codetyper Credentials Status",
+		"============================",
+		"",
+		"Storage: " .. get_credentials_path(),
+		"Active:  " .. current:upper(),
+		"",
+	}
+
+	for _, p in ipairs(providers) do
+		local status_icon = p.configured and "✓" or "✗"
+		local active_marker = p.name == current and " [ACTIVE]" or ""
+		local source_info = ""
+		if p.configured then
+			source_info = p.source == "stored" and " (stored)" or " (config)"
+		end
+		local model_info = p.model and (" - " .. p.model) or ""
+
+		table.insert(lines, string.format("  %s %s%s%s%s",
+			status_icon,
+			p.name:upper(),
+			active_marker,
+			source_info,
+			model_info))
+	end
+
+	table.insert(lines, "")
+	table.insert(lines, "Commands:")
+	table.insert(lines, "  :CoderAddApiKey      - Add/update credentials")
+	table.insert(lines, "  :CoderSwitchProvider - Switch active provider")
+	table.insert(lines, "  :CoderRemoveApiKey   - Remove stored credentials")
+
+	utils.notify(table.concat(lines, "\n"))
+end
+
+--- Interactive remove credentials
+function M.interactive_remove()
+	local data = M.load()
+	local configured = {}
+
+	for provider, _ in pairs(data.providers or {}) do
+		table.insert(configured, provider)
+	end
+
+	if #configured == 0 then
+		utils.notify("No credentials configured", vim.log.levels.INFO)
+		return
+	end
+
+	vim.ui.select(configured, {
+		prompt = "Select provider to remove:",
+	}, function(provider)
+		if not provider then
+			return
+		end
+
+		vim.ui.select({ "Yes", "No" }, {
+			prompt = "Remove " .. provider:upper() .. " credentials?",
+		}, function(choice)
+			if choice == "Yes" then
+				if M.remove_credentials(provider) then
+					utils.notify("Removed " .. provider:upper() .. " credentials", vim.log.levels.INFO)
+				else
+					utils.notify("Failed to remove credentials", vim.log.levels.ERROR)
+				end
+			end
+		end)
+	end)
+end
+
+--- Set the active provider
+---@param provider string Provider name
+function M.set_active_provider(provider)
+	local data = M.load()
+	data.active_provider = provider
+	data.updated = os.time()
+	M.save(data)
+
+	-- Also update the runtime config
+	local codetyper = require("codetyper")
+	local config = codetyper.get_config()
+	config.llm.provider = provider
+
+	utils.notify("Active provider set to: " .. provider:upper(), vim.log.levels.INFO)
+end
+
+--- Get the active provider from stored config
+---@return string|nil Active provider
+function M.get_active_provider()
+	local data = M.load()
+	return data.active_provider
+end
+
+--- Check if a provider is configured (from stored credentials OR config)
+---@param provider string Provider name
+---@return boolean configured, string|nil source
+local function is_provider_configured(provider)
+	-- Check stored credentials first
+	local data = M.load()
+	local stored = data.providers and data.providers[provider]
+	if stored then
+		if stored.configured or stored.api_key or provider == "ollama" or provider == "copilot" then
+			return true, "stored"
+		end
+	end
+
+	-- Check codetyper config
+	local ok, codetyper = pcall(require, "codetyper")
+	if not ok then
+		return false, nil
+	end
+
+	local config = codetyper.get_config()
+	if not config or not config.llm then
+		return false, nil
+	end
+
+	local provider_config = config.llm[provider]
+	if not provider_config then
+		return false, nil
+	end
+
+	-- Check for API key in config or environment
+	if provider == "claude" then
+		if provider_config.api_key or vim.env.ANTHROPIC_API_KEY then
+			return true, "config"
+		end
+	elseif provider == "openai" then
+		if provider_config.api_key or vim.env.OPENAI_API_KEY then
+			return true, "config"
+		end
+	elseif provider == "gemini" then
+		if provider_config.api_key or vim.env.GEMINI_API_KEY then
+			return true, "config"
+		end
+	elseif provider == "copilot" then
+		-- Copilot just needs copilot.lua installed
+		return true, "config"
+	elseif provider == "ollama" then
+		-- Ollama just needs host configured
+		if provider_config.host then
+			return true, "config"
+		end
+	end
+
+	return false, nil
+end
+
+--- Interactive switch provider
+function M.interactive_switch_provider()
+	local all_providers = { "claude", "openai", "gemini", "copilot", "ollama" }
+	local available = {}
+	local sources = {}
+
+	for _, provider in ipairs(all_providers) do
+		local configured, source = is_provider_configured(provider)
+		if configured then
+			table.insert(available, provider)
+			sources[provider] = source
+		end
+	end
+
+	if #available == 0 then
+		utils.notify("No providers configured. Use :CoderAddApiKey or add to your config.", vim.log.levels.WARN)
+		return
+	end
+
+	local codetyper = require("codetyper")
+	local current = codetyper.get_config().llm.provider
+
+	vim.ui.select(available, {
+		prompt = "Select provider (current: " .. current .. "):",
+		format_item = function(item)
+			local marker = item == current and " [active]" or ""
+			local source_marker = sources[item] == "stored" and " (stored)" or " (config)"
+			return item:upper() .. marker .. source_marker
+		end,
+	}, function(provider)
+		if provider then
+			M.set_active_provider(provider)
+		end
+	end)
+end
+
+return M
--- a/lua/codetyper/config/defaults.lua
+++ b/lua/codetyper/config/defaults.lua
@@ -5,11 +5,7 @@ local M = {}
 ---@type CoderConfig
 local defaults = {
  llm = {
-    provider = "ollama", -- Options: "claude", "ollama", "openai", "gemini", "copilot"
-    claude = {
-      api_key = nil, -- Will use ANTHROPIC_API_KEY env var if nil
-      model = "claude-sonnet-4-20250514",
-    },
+    provider = "ollama", -- Options: "ollama", "openai", "gemini", "copilot"
    ollama = {
      host = "http://localhost:11434",
      model = "deepseek-coder:6.7b",
@@ -24,7 +20,7 @@ local defaults = {
      model = "gemini-2.0-flash",
    },
    copilot = {
-      model = "gpt-4o", -- Uses GitHub Copilot authentication
+      model = "claude-sonnet-4", -- Uses GitHub Copilot authentication
    },
  },
  window = {
@@ -46,6 +42,49 @@ local defaults = {
    escalation_threshold = 0.7, -- Below this confidence, escalate to remote LLM
    max_concurrent = 2, -- Maximum concurrent workers
    completion_delay_ms = 100, -- Wait after completion popup closes
+    apply_delay_ms = 5000, -- Wait before removing tags and applying code (ms)
+  },
+  indexer = {
+    enabled = true, -- Enable project indexing
+    auto_index = true, -- Index files on save
+    index_on_open = false, -- Index project when opening
+    max_file_size = 100000, -- Skip files larger than 100KB
+    excluded_dirs = { "node_modules", "dist", "build", ".git", ".coder", "__pycache__", "vendor", "target" },
+    index_extensions = { "lua", "ts", "tsx", "js", "jsx", "py", "go", "rs", "rb", "java", "c", "cpp", "h", "hpp" },
+    memory = {
+      enabled = true, -- Enable memory persistence
+      max_memories = 1000, -- Maximum stored memories
+      prune_threshold = 0.1, -- Remove low-weight memories
+    },
+  },
+  brain = {
+    enabled = true, -- Enable brain learning system
+    auto_learn = true, -- Auto-learn from events
+    auto_commit = true, -- Auto-commit after threshold
+    commit_threshold = 10, -- Changes before auto-commit
+    max_nodes = 5000, -- Maximum nodes before pruning
+    max_deltas = 500, -- Maximum delta history
+    prune = {
+      enabled = true, -- Enable auto-pruning
+      threshold = 0.1, -- Remove nodes below this weight
+      unused_days = 90, -- Remove unused nodes after N days
+    },
+    output = {
+      max_tokens = 4000, -- Token budget for LLM context
+      format = "compact", -- "compact"|"json"|"natural"
+    },
+  },
+  suggestion = {
+    enabled = true, -- Enable ghost text suggestions (Copilot-style)
+    auto_trigger = true, -- Auto-trigger on typing
+    debounce = 150, -- Debounce in milliseconds
+    use_copilot = true, -- Use copilot.lua suggestions when available, fallback to codetyper
+    keymap = {
+      accept = "<Tab>", -- Accept suggestion
+      next = "<M-]>", -- Next suggestion (Alt+])
+      prev = "<M-[>", -- Previous suggestion (Alt+[)
+      dismiss = "<C-]>", -- Dismiss suggestion (Ctrl+])
+    },
  },
 }

@@ -87,7 +126,7 @@ function M.validate(config)
    return false, "Missing LLM configuration"
  end

-  local valid_providers = { "claude", "ollama", "openai", "gemini", "copilot" }
+  local valid_providers = { "ollama", "openai", "gemini", "copilot" }
  local is_valid_provider = false
  for _, p in ipairs(valid_providers) do
    if config.llm.provider == p then
@@ -101,12 +140,7 @@ function M.validate(config)
  end

  -- Validate provider-specific configuration
-  if config.llm.provider == "claude" then
-    local api_key = config.llm.claude.api_key or vim.env.ANTHROPIC_API_KEY
-    if not api_key or api_key == "" then
-      return false, "Claude API key not configured. Set llm.claude.api_key or ANTHROPIC_API_KEY env var"
-    end
-  elseif config.llm.provider == "openai" then
+  if config.llm.provider == "openai" then
    local api_key = config.llm.openai.api_key or vim.env.OPENAI_API_KEY
    if not api_key or api_key == "" then
      return false, "OpenAI API key not configured. Set llm.openai.api_key or OPENAI_API_KEY env var"
--- a/lua/codetyper/config/preferences.lua
+++ b/lua/codetyper/config/preferences.lua
@@ -0,0 +1,214 @@
+---@mod codetyper.preferences User preferences management
+---@brief [[
+--- Manages user preferences stored in .coder/preferences.json
+--- Allows per-project configuration of plugin behavior.
+---@brief ]]
+
+local M = {}
+
+local utils = require("codetyper.support.utils")
+
+---@class CoderPreferences
+---@field auto_process boolean Whether to auto-process /@ @/ tags (default: nil = ask)
+---@field asked_auto_process boolean Whether we've asked the user about auto_process
+
+--- Default preferences
+local defaults = {
+  auto_process = nil, -- nil means "not yet decided"
+  asked_auto_process = false,
+}
+
+--- Cached preferences per project
+---@type table<string, CoderPreferences>
+local cache = {}
+
+--- Get the preferences file path for current project
+---@return string
+local function get_preferences_path()
+  local cwd = vim.fn.getcwd()
+  return cwd .. "/.coder/preferences.json"
+end
+
+--- Ensure .coder directory exists
+local function ensure_coder_dir()
+  local cwd = vim.fn.getcwd()
+  local coder_dir = cwd .. "/.coder"
+  if vim.fn.isdirectory(coder_dir) == 0 then
+    vim.fn.mkdir(coder_dir, "p")
+  end
+end
+
+--- Load preferences from file
+---@return CoderPreferences
+function M.load()
+  local cwd = vim.fn.getcwd()
+
+  -- Check cache first
+  if cache[cwd] then
+    return cache[cwd]
+  end
+
+  local path = get_preferences_path()
+  local prefs = vim.deepcopy(defaults)
+
+  if utils.file_exists(path) then
+    local content = utils.read_file(path)
+    if content then
+      local ok, decoded = pcall(vim.json.decode, content)
+      if ok and decoded then
+        -- Merge with defaults
+        for k, v in pairs(decoded) do
+          prefs[k] = v
+        end
+      end
+    end
+  end
+
+  -- Cache it
+  cache[cwd] = prefs
+  return prefs
+end
+
+--- Save preferences to file
+---@param prefs CoderPreferences
+function M.save(prefs)
+  local cwd = vim.fn.getcwd()
+  ensure_coder_dir()
+
+  local path = get_preferences_path()
+  local ok, encoded = pcall(vim.json.encode, prefs)
+  if ok then
+    utils.write_file(path, encoded)
+    -- Update cache
+    cache[cwd] = prefs
+  end
+end
+
+--- Get a specific preference
+---@param key string
+---@return any
+function M.get(key)
+  local prefs = M.load()
+  return prefs[key]
+end
+
+--- Set a specific preference
+---@param key string
+---@param value any
+function M.set(key, value)
+  local prefs = M.load()
+  prefs[key] = value
+  M.save(prefs)
+end
+
+--- Check if auto-process is enabled
+---@return boolean|nil Returns true/false if set, nil if not yet decided
+function M.is_auto_process_enabled()
+  return M.get("auto_process")
+end
+
+--- Set auto-process preference
+---@param enabled boolean
+function M.set_auto_process(enabled)
+  M.set("auto_process", enabled)
+  M.set("asked_auto_process", true)
+end
+
+--- Check if we've already asked the user about auto-process
+---@return boolean
+function M.has_asked_auto_process()
+  return M.get("asked_auto_process") == true
+end
+
+--- Ask user about auto-process preference (shows floating window)
+---@param callback function(enabled: boolean) Called with user's choice
+function M.ask_auto_process_preference(callback)
+  -- Check if already asked
+  if M.has_asked_auto_process() then
+    local enabled = M.is_auto_process_enabled()
+    if enabled ~= nil then
+      callback(enabled)
+      return
+    end
+  end
+
+  -- Create floating window to ask
+  local width = 60
+  local height = 7
+  local row = math.floor((vim.o.lines - height) / 2)
+  local col = math.floor((vim.o.columns - width) / 2)
+
+  local buf = vim.api.nvim_create_buf(false, true)
+  vim.bo[buf].buftype = "nofile"
+  vim.bo[buf].bufhidden = "wipe"
+
+  local win = vim.api.nvim_open_win(buf, true, {
+    relative = "editor",
+    row = row,
+    col = col,
+    width = width,
+    height = height,
+    style = "minimal",
+    border = "rounded",
+    title = " Codetyper Preferences ",
+    title_pos = "center",
+  })
+
+  local lines = {
+    "",
+    "  How would you like to process /@ @/ prompt tags?",
+    "",
+    "  [a] Automatic - Process when you close the tag",
+    "  [m] Manual    - Only process with :CoderProcess",
+    "",
+    "  Press 'a' or 'm' to choose (Esc to cancel)",
+  }
+
+  vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
+  vim.bo[buf].modifiable = false
+
+  -- Highlight
+  local ns = vim.api.nvim_create_namespace("codetyper_prefs")
+  vim.api.nvim_buf_add_highlight(buf, ns, "Title", 1, 0, -1)
+  vim.api.nvim_buf_add_highlight(buf, ns, "String", 3, 2, 5)
+  vim.api.nvim_buf_add_highlight(buf, ns, "String", 4, 2, 5)
+
+  local function close_and_callback(enabled)
+    if vim.api.nvim_win_is_valid(win) then
+      vim.api.nvim_win_close(win, true)
+    end
+    if enabled ~= nil then
+      M.set_auto_process(enabled)
+      local mode = enabled and "automatic" or "manual"
+      vim.notify("Codetyper: Set to " .. mode .. " mode (saved to .coder/preferences.json)", vim.log.levels.INFO)
+    end
+    if callback then
+      callback(enabled)
+    end
+  end
+
+  -- Keymaps
+  local opts = { buffer = buf, noremap = true, silent = true }
+  vim.keymap.set("n", "a", function() close_and_callback(true) end, opts)
+  vim.keymap.set("n", "A", function() close_and_callback(true) end, opts)
+  vim.keymap.set("n", "m", function() close_and_callback(false) end, opts)
+  vim.keymap.set("n", "M", function() close_and_callback(false) end, opts)
+  vim.keymap.set("n", "<Esc>", function() close_and_callback(nil) end, opts)
+  vim.keymap.set("n", "q", function() close_and_callback(nil) end, opts)
+end
+
+--- Clear cached preferences (useful when changing projects)
+function M.clear_cache()
+  cache = {}
+end
+
+--- Toggle auto-process mode
+function M.toggle_auto_process()
+  local current = M.is_auto_process_enabled()
+  local new_value = not current
+  M.set_auto_process(new_value)
+  local mode = new_value and "automatic" or "manual"
+  vim.notify("Codetyper: Switched to " .. mode .. " mode", vim.log.levels.INFO)
+end
+
+return M
--- a/lua/codetyper/core/cost/init.lua
+++ b/lua/codetyper/core/cost/init.lua
@@ -0,0 +1,750 @@
+---@mod codetyper.cost Cost estimation for LLM usage
+---@brief [[
+--- Tracks token usage and estimates costs based on model pricing.
+--- Prices are per 1M tokens. Persists usage data in the brain.
+---@brief ]]
+
+local M = {}
+
+local utils = require("codetyper.support.utils")
+
+--- Cost history file name
+local COST_HISTORY_FILE = "cost_history.json"
+
+--- Get path to cost history file
+---@return string File path
+local function get_history_path()
+	local root = utils.get_project_root()
+	return root .. "/.coder/" .. COST_HISTORY_FILE
+end
+
+--- Default model for savings comparison (what you'd pay if not using Ollama)
+M.comparison_model = "gpt-4o"
+
+--- Models considered "free" (Ollama, local, Copilot subscription)
+M.free_models = {
+	["ollama"] = true,
+	["codellama"] = true,
+	["llama2"] = true,
+	["llama3"] = true,
+	["mistral"] = true,
+	["deepseek-coder"] = true,
+	["copilot"] = true,
+}
+
+--- Model pricing table (per 1M tokens in USD)
+---@type table<string, {input: number, cached_input: number|nil, output: number|nil}>
+M.pricing = {
+	-- GPT-5.x series
+	["gpt-5.2"] = { input = 1.75, cached_input = 0.175, output = 14.00 },
+	["gpt-5.1"] = { input = 1.25, cached_input = 0.125, output = 10.00 },
+	["gpt-5"] = { input = 1.25, cached_input = 0.125, output = 10.00 },
+	["gpt-5-mini"] = { input = 0.25, cached_input = 0.025, output = 2.00 },
+	["gpt-5-nano"] = { input = 0.05, cached_input = 0.005, output = 0.40 },
+	["gpt-5.2-chat-latest"] = { input = 1.75, cached_input = 0.175, output = 14.00 },
+	["gpt-5.1-chat-latest"] = { input = 1.25, cached_input = 0.125, output = 10.00 },
+	["gpt-5-chat-latest"] = { input = 1.25, cached_input = 0.125, output = 10.00 },
+	["gpt-5.2-codex"] = { input = 1.75, cached_input = 0.175, output = 14.00 },
+	["gpt-5.1-codex-max"] = { input = 1.25, cached_input = 0.125, output = 10.00 },
+	["gpt-5.1-codex"] = { input = 1.25, cached_input = 0.125, output = 10.00 },
+	["gpt-5-codex"] = { input = 1.25, cached_input = 0.125, output = 10.00 },
+	["gpt-5.2-pro"] = { input = 21.00, cached_input = nil, output = 168.00 },
+	["gpt-5-pro"] = { input = 15.00, cached_input = nil, output = 120.00 },
+	["gpt-5.1-codex-mini"] = { input = 0.25, cached_input = 0.025, output = 2.00 },
+	["gpt-5-search-api"] = { input = 1.25, cached_input = 0.125, output = 10.00 },
+
+	-- GPT-4.x series
+	["gpt-4.1"] = { input = 2.00, cached_input = 0.50, output = 8.00 },
+	["gpt-4.1-mini"] = { input = 0.40, cached_input = 0.10, output = 1.60 },
+	["gpt-4.1-nano"] = { input = 0.10, cached_input = 0.025, output = 0.40 },
+	["gpt-4o"] = { input = 2.50, cached_input = 1.25, output = 10.00 },
+	["gpt-4o-2024-05-13"] = { input = 5.00, cached_input = nil, output = 15.00 },
+	["gpt-4o-mini"] = { input = 0.15, cached_input = 0.075, output = 0.60 },
+
+	-- Realtime models
+	["gpt-realtime"] = { input = 4.00, cached_input = 0.40, output = 16.00 },
+	["gpt-realtime-mini"] = { input = 0.60, cached_input = 0.06, output = 2.40 },
+	["gpt-4o-realtime-preview"] = { input = 5.00, cached_input = 2.50, output = 20.00 },
+	["gpt-4o-mini-realtime-preview"] = { input = 0.60, cached_input = 0.30, output = 2.40 },
+
+	-- Audio models
+	["gpt-audio"] = { input = 2.50, cached_input = nil, output = 10.00 },
+	["gpt-audio-mini"] = { input = 0.60, cached_input = nil, output = 2.40 },
+	["gpt-4o-audio-preview"] = { input = 2.50, cached_input = nil, output = 10.00 },
+	["gpt-4o-mini-audio-preview"] = { input = 0.15, cached_input = nil, output = 0.60 },
+
+	-- O-series reasoning models
+	["o1"] = { input = 15.00, cached_input = 7.50, output = 60.00 },
+	["o1-pro"] = { input = 150.00, cached_input = nil, output = 600.00 },
+	["o3-pro"] = { input = 20.00, cached_input = nil, output = 80.00 },
+	["o3"] = { input = 2.00, cached_input = 0.50, output = 8.00 },
+	["o3-deep-research"] = { input = 10.00, cached_input = 2.50, output = 40.00 },
+	["o4-mini"] = { input = 1.10, cached_input = 0.275, output = 4.40 },
+	["o4-mini-deep-research"] = { input = 2.00, cached_input = 0.50, output = 8.00 },
+	["o3-mini"] = { input = 1.10, cached_input = 0.55, output = 4.40 },
+	["o1-mini"] = { input = 1.10, cached_input = 0.55, output = 4.40 },
+
+	-- Codex
+	["codex-mini-latest"] = { input = 1.50, cached_input = 0.375, output = 6.00 },
+
+	-- Search models
+	["gpt-4o-mini-search-preview"] = { input = 0.15, cached_input = nil, output = 0.60 },
+	["gpt-4o-search-preview"] = { input = 2.50, cached_input = nil, output = 10.00 },
+
+	-- Computer use
+	["computer-use-preview"] = { input = 3.00, cached_input = nil, output = 12.00 },
+
+	-- Image models
+	["gpt-image-1.5"] = { input = 5.00, cached_input = 1.25, output = 10.00 },
+	["chatgpt-image-latest"] = { input = 5.00, cached_input = 1.25, output = 10.00 },
+	["gpt-image-1"] = { input = 5.00, cached_input = 1.25, output = nil },
+	["gpt-image-1-mini"] = { input = 2.00, cached_input = 0.20, output = nil },
+
+	-- Claude models
+	["claude-3-opus"] = { input = 15.00, cached_input = 7.50, output = 75.00 },
+	["claude-3-sonnet"] = { input = 3.00, cached_input = 1.50, output = 15.00 },
+	["claude-3-haiku"] = { input = 0.25, cached_input = 0.125, output = 1.25 },
+	["claude-3.5-sonnet"] = { input = 3.00, cached_input = 1.50, output = 15.00 },
+	["claude-3.5-haiku"] = { input = 0.80, cached_input = 0.40, output = 4.00 },
+
+	-- Ollama/Local models (free)
+	["ollama"] = { input = 0, cached_input = 0, output = 0 },
+	["codellama"] = { input = 0, cached_input = 0, output = 0 },
+	["llama2"] = { input = 0, cached_input = 0, output = 0 },
+	["llama3"] = { input = 0, cached_input = 0, output = 0 },
+	["mistral"] = { input = 0, cached_input = 0, output = 0 },
+	["deepseek-coder"] = { input = 0, cached_input = 0, output = 0 },
+
+	-- Copilot (included in subscription, but tracking usage)
+	["copilot"] = { input = 0, cached_input = 0, output = 0 },
+}
+
+---@class CostUsage
+---@field model string Model name
+---@field input_tokens number Input tokens used
+---@field output_tokens number Output tokens used
+---@field cached_tokens number Cached input tokens
+---@field timestamp number Unix timestamp
+---@field cost number Calculated cost in USD
+
+---@class CostState
+---@field usage CostUsage[] Current session usage
+---@field all_usage CostUsage[] All historical usage from brain
+---@field session_start number Session start timestamp
+---@field win number|nil Window handle
+---@field buf number|nil Buffer handle
+---@field loaded boolean Whether historical data has been loaded
+local state = {
+	usage = {},
+	all_usage = {},
+	session_start = os.time(),
+	win = nil,
+	buf = nil,
+	loaded = false,
+}
+
+--- Load historical usage from disk
+function M.load_from_history()
+	if state.loaded then
+		return
+	end
+
+	local history_path = get_history_path()
+	local content = utils.read_file(history_path)
+
+	if content and content ~= "" then
+		local ok, data = pcall(vim.json.decode, content)
+		if ok and data and data.usage then
+			state.all_usage = data.usage
+		end
+	end
+
+	state.loaded = true
+end
+
+--- Save all usage to disk (debounced)
+local save_timer = nil
+local function save_to_disk()
+	-- Cancel existing timer
+	if save_timer then
+		save_timer:stop()
+		save_timer = nil
+	end
+
+	-- Debounce writes (500ms)
+	save_timer = vim.loop.new_timer()
+	save_timer:start(500, 0, vim.schedule_wrap(function()
+		local history_path = get_history_path()
+
+		-- Ensure directory exists
+		local dir = vim.fn.fnamemodify(history_path, ":h")
+		utils.ensure_dir(dir)
+
+		-- Merge session and historical usage
+		local all_data = vim.deepcopy(state.all_usage)
+		for _, usage in ipairs(state.usage) do
+			table.insert(all_data, usage)
+		end
+
+		-- Save to file
+		local data = {
+			version = 1,
+			updated = os.time(),
+			usage = all_data,
+		}
+
+		local ok, json = pcall(vim.json.encode, data)
+		if ok then
+			utils.write_file(history_path, json)
+		end
+
+		save_timer = nil
+	end))
+end
+
+--- Normalize model name for pricing lookup
+---@param model string Model name from API
+---@return string Normalized model name
+local function normalize_model(model)
+	if not model then
+		return "unknown"
+	end
+
+	-- Convert to lowercase
+	local normalized = model:lower()
+
+	-- Handle Copilot models
+	if normalized:match("copilot") then
+		return "copilot"
+	end
+
+	-- Handle common prefixes
+	normalized = normalized:gsub("^openai/", "")
+	normalized = normalized:gsub("^anthropic/", "")
+
+	-- Try exact match first
+	if M.pricing[normalized] then
+		return normalized
+	end
+
+	-- Try partial matches
+	for price_model, _ in pairs(M.pricing) do
+		if normalized:match(price_model) or price_model:match(normalized) then
+			return price_model
+		end
+	end
+
+	return normalized
+end
+
+--- Check if a model is considered "free" (local/Ollama/Copilot subscription)
+---@param model string Model name
+---@return boolean True if free
+function M.is_free_model(model)
+	local normalized = normalize_model(model)
+
+	-- Check direct match
+	if M.free_models[normalized] then
+		return true
+	end
+
+	-- Check if it's an Ollama model (any model with : in name like deepseek-coder:6.7b)
+	if model:match(":") then
+		return true
+	end
+
+	-- Check pricing - if cost is 0, it's free
+	local pricing = M.pricing[normalized]
+	if pricing and pricing.input == 0 and pricing.output == 0 then
+		return true
+	end
+
+	return false
+end
+
+--- Calculate cost for token usage
+---@param model string Model name
+---@param input_tokens number Input tokens
+---@param output_tokens number Output tokens
+---@param cached_tokens? number Cached input tokens
+---@return number Cost in USD
+function M.calculate_cost(model, input_tokens, output_tokens, cached_tokens)
+	local normalized = normalize_model(model)
+	local pricing = M.pricing[normalized]
+
+	if not pricing then
+		-- Unknown model, return 0
+		return 0
+	end
+
+	cached_tokens = cached_tokens or 0
+	local regular_input = input_tokens - cached_tokens
+
+	-- Calculate cost (prices are per 1M tokens)
+	local input_cost = (regular_input / 1000000) * (pricing.input or 0)
+	local cached_cost = (cached_tokens / 1000000) * (pricing.cached_input or pricing.input or 0)
+	local output_cost = (output_tokens / 1000000) * (pricing.output or 0)
+
+	return input_cost + cached_cost + output_cost
+end
+
+--- Calculate estimated savings (what would have been paid if using comparison model)
+---@param input_tokens number Input tokens
+---@param output_tokens number Output tokens
+---@param cached_tokens? number Cached input tokens
+---@return number Estimated savings in USD
+function M.calculate_savings(input_tokens, output_tokens, cached_tokens)
+	-- Calculate what it would have cost with the comparison model
+	return M.calculate_cost(M.comparison_model, input_tokens, output_tokens, cached_tokens)
+end
+
+--- Record token usage
+---@param model string Model name
+---@param input_tokens number Input tokens
+---@param output_tokens number Output tokens
+---@param cached_tokens? number Cached input tokens
+function M.record_usage(model, input_tokens, output_tokens, cached_tokens)
+	cached_tokens = cached_tokens or 0
+	local cost = M.calculate_cost(model, input_tokens, output_tokens, cached_tokens)
+
+	-- Calculate savings if using a free model
+	local savings = 0
+	if M.is_free_model(model) then
+		savings = M.calculate_savings(input_tokens, output_tokens, cached_tokens)
+	end
+
+	table.insert(state.usage, {
+		model = model,
+		input_tokens = input_tokens,
+		output_tokens = output_tokens,
+		cached_tokens = cached_tokens,
+		timestamp = os.time(),
+		cost = cost,
+		savings = savings,
+		is_free = M.is_free_model(model),
+	})
+
+	-- Save to disk (debounced)
+	save_to_disk()
+
+	-- Update window if open
+	if state.win and vim.api.nvim_win_is_valid(state.win) then
+		M.refresh_window()
+	end
+end
+
+--- Aggregate usage data into stats
+---@param usage_list CostUsage[] List of usage records
+---@return table Stats
+local function aggregate_usage(usage_list)
+	local stats = {
+		total_input = 0,
+		total_output = 0,
+		total_cached = 0,
+		total_cost = 0,
+		total_savings = 0,
+		free_requests = 0,
+		paid_requests = 0,
+		by_model = {},
+		request_count = #usage_list,
+	}
+
+	for _, usage in ipairs(usage_list) do
+		stats.total_input = stats.total_input + (usage.input_tokens or 0)
+		stats.total_output = stats.total_output + (usage.output_tokens or 0)
+		stats.total_cached = stats.total_cached + (usage.cached_tokens or 0)
+		stats.total_cost = stats.total_cost + (usage.cost or 0)
+
+		-- Track savings
+		local usage_savings = usage.savings or 0
+		-- For historical data without savings field, calculate it
+		if usage_savings == 0 and usage.is_free == nil then
+			local model = usage.model or "unknown"
+			if M.is_free_model(model) then
+				usage_savings = M.calculate_savings(
+					usage.input_tokens or 0,
+					usage.output_tokens or 0,
+					usage.cached_tokens or 0
+				)
+			end
+		end
+		stats.total_savings = stats.total_savings + usage_savings
+
+		-- Track free vs paid
+		local is_free = usage.is_free
+		if is_free == nil then
+			is_free = M.is_free_model(usage.model or "unknown")
+		end
+		if is_free then
+			stats.free_requests = stats.free_requests + 1
+		else
+			stats.paid_requests = stats.paid_requests + 1
+		end
+
+		local model = usage.model or "unknown"
+		if not stats.by_model[model] then
+			stats.by_model[model] = {
+				input_tokens = 0,
+				output_tokens = 0,
+				cached_tokens = 0,
+				cost = 0,
+				savings = 0,
+				requests = 0,
+				is_free = is_free,
+			}
+		end
+
+		stats.by_model[model].input_tokens = stats.by_model[model].input_tokens + (usage.input_tokens or 0)
+		stats.by_model[model].output_tokens = stats.by_model[model].output_tokens + (usage.output_tokens or 0)
+		stats.by_model[model].cached_tokens = stats.by_model[model].cached_tokens + (usage.cached_tokens or 0)
+		stats.by_model[model].cost = stats.by_model[model].cost + (usage.cost or 0)
+		stats.by_model[model].savings = stats.by_model[model].savings + usage_savings
+		stats.by_model[model].requests = stats.by_model[model].requests + 1
+	end
+
+	return stats
+end
+
+--- Get session statistics
+---@return table Statistics
+function M.get_stats()
+	local stats = aggregate_usage(state.usage)
+	stats.session_duration = os.time() - state.session_start
+	return stats
+end
+
+--- Get all-time statistics (session + historical)
+---@return table Statistics
+function M.get_all_time_stats()
+	-- Load history if not loaded
+	M.load_from_history()
+
+	-- Combine session and historical usage
+	local all_usage = vim.deepcopy(state.all_usage)
+	for _, usage in ipairs(state.usage) do
+		table.insert(all_usage, usage)
+	end
+
+	local stats = aggregate_usage(all_usage)
+
+	-- Calculate time span
+	if #all_usage > 0 then
+		local oldest = all_usage[1].timestamp or os.time()
+		for _, usage in ipairs(all_usage) do
+			if usage.timestamp and usage.timestamp < oldest then
+				oldest = usage.timestamp
+			end
+		end
+		stats.time_span = os.time() - oldest
+	else
+		stats.time_span = 0
+	end
+
+	return stats
+end
+
+--- Format cost as string
+---@param cost number Cost in USD
+---@return string Formatted cost
+local function format_cost(cost)
+	if cost < 0.01 then
+		return string.format("$%.4f", cost)
+	elseif cost < 1 then
+		return string.format("$%.3f", cost)
+	else
+		return string.format("$%.2f", cost)
+	end
+end
+
+--- Format token count
+---@param tokens number Token count
+---@return string Formatted count
+local function format_tokens(tokens)
+	if tokens >= 1000000 then
+		return string.format("%.2fM", tokens / 1000000)
+	elseif tokens >= 1000 then
+		return string.format("%.1fK", tokens / 1000)
+	else
+		return tostring(tokens)
+	end
+end
+
+--- Format duration
+---@param seconds number Duration in seconds
+---@return string Formatted duration
+local function format_duration(seconds)
+	if seconds < 60 then
+		return string.format("%ds", seconds)
+	elseif seconds < 3600 then
+		return string.format("%dm %ds", math.floor(seconds / 60), seconds % 60)
+	else
+		local hours = math.floor(seconds / 3600)
+		local mins = math.floor((seconds % 3600) / 60)
+		return string.format("%dh %dm", hours, mins)
+	end
+end
+
+--- Generate model breakdown section
+---@param stats table Stats with by_model
+---@return string[] Lines
+local function generate_model_breakdown(stats)
+	local lines = {}
+
+	if next(stats.by_model) then
+		-- Sort models by cost (descending)
+		local models = {}
+		for model, data in pairs(stats.by_model) do
+			table.insert(models, { name = model, data = data })
+		end
+		table.sort(models, function(a, b)
+			return a.data.cost > b.data.cost
+		end)
+
+		for _, item in ipairs(models) do
+			local model = item.name
+			local data = item.data
+			local pricing = M.pricing[normalize_model(model)]
+			local is_free = data.is_free or M.is_free_model(model)
+
+			table.insert(lines, "")
+			local model_icon = is_free and "🆓" or "💳"
+			table.insert(lines, string.format("  %s %s", model_icon, model))
+			table.insert(lines, string.format("     Requests: %d", data.requests))
+			table.insert(lines, string.format("     Input:    %s tokens", format_tokens(data.input_tokens)))
+			table.insert(lines, string.format("     Output:   %s tokens", format_tokens(data.output_tokens)))
+
+			if is_free then
+				-- Show savings for free models
+				if data.savings and data.savings > 0 then
+					table.insert(lines, string.format("     Saved:    %s", format_cost(data.savings)))
+				end
+			else
+				table.insert(lines, string.format("     Cost:     %s", format_cost(data.cost)))
+			end
+
+			-- Show pricing info for paid models
+			if pricing and not is_free then
+				local price_info = string.format(
+					"     Rate:     $%.2f/1M in, $%.2f/1M out",
+					pricing.input or 0,
+					pricing.output or 0
+				)
+				table.insert(lines, price_info)
+			end
+		end
+	else
+		table.insert(lines, "  No usage recorded.")
+	end
+
+	return lines
+end
+
+--- Generate window content
+---@return string[] Lines for the buffer
+local function generate_content()
+	local session_stats = M.get_stats()
+	local all_time_stats = M.get_all_time_stats()
+	local lines = {}
+
+	-- Header
+	table.insert(lines, "╔══════════════════════════════════════════════════════╗")
+	table.insert(lines, "║              💰 LLM Cost Estimation                  ║")
+	table.insert(lines, "╠══════════════════════════════════════════════════════╣")
+	table.insert(lines, "")
+
+	-- All-time summary (prominent)
+	table.insert(lines, "🌐 All-Time Summary (Project)")
+	table.insert(lines, "───────────────────────────────────────────────────────")
+	if all_time_stats.time_span > 0 then
+		table.insert(lines, string.format("  Time span:      %s", format_duration(all_time_stats.time_span)))
+	end
+	table.insert(lines, string.format("  Requests:       %d total", all_time_stats.request_count))
+	table.insert(lines, string.format("    Local/Free:   %d requests", all_time_stats.free_requests or 0))
+	table.insert(lines, string.format("    Paid API:     %d requests", all_time_stats.paid_requests or 0))
+	table.insert(lines, string.format("  Input tokens:   %s", format_tokens(all_time_stats.total_input)))
+	table.insert(lines, string.format("  Output tokens:  %s", format_tokens(all_time_stats.total_output)))
+	if all_time_stats.total_cached > 0 then
+		table.insert(lines, string.format("  Cached tokens:  %s", format_tokens(all_time_stats.total_cached)))
+	end
+	table.insert(lines, "")
+	table.insert(lines, string.format("  💵 Total Cost:  %s", format_cost(all_time_stats.total_cost)))
+
+	-- Show savings prominently if there are any
+	if all_time_stats.total_savings and all_time_stats.total_savings > 0 then
+		table.insert(lines, string.format("  💚 Saved:       %s (vs %s)", format_cost(all_time_stats.total_savings), M.comparison_model))
+	end
+	table.insert(lines, "")
+
+	-- Session summary
+	table.insert(lines, "📊 Current Session")
+	table.insert(lines, "───────────────────────────────────────────────────────")
+	table.insert(lines, string.format("  Duration:       %s", format_duration(session_stats.session_duration)))
+	table.insert(lines, string.format("  Requests:       %d (%d free, %d paid)",
+		session_stats.request_count,
+		session_stats.free_requests or 0,
+		session_stats.paid_requests or 0))
+	table.insert(lines, string.format("  Input tokens:   %s", format_tokens(session_stats.total_input)))
+	table.insert(lines, string.format("  Output tokens:  %s", format_tokens(session_stats.total_output)))
+	if session_stats.total_cached > 0 then
+		table.insert(lines, string.format("  Cached tokens:  %s", format_tokens(session_stats.total_cached)))
+	end
+	table.insert(lines, string.format("  Session Cost:   %s", format_cost(session_stats.total_cost)))
+	if session_stats.total_savings and session_stats.total_savings > 0 then
+		table.insert(lines, string.format("  Session Saved:  %s", format_cost(session_stats.total_savings)))
+	end
+	table.insert(lines, "")
+
+	-- Per-model breakdown (all-time)
+	table.insert(lines, "📈 Cost by Model (All-Time)")
+	table.insert(lines, "───────────────────────────────────────────────────────")
+	local model_lines = generate_model_breakdown(all_time_stats)
+	for _, line in ipairs(model_lines) do
+		table.insert(lines, line)
+	end
+
+	table.insert(lines, "")
+	table.insert(lines, "───────────────────────────────────────────────────────")
+	table.insert(lines, "  'q' close | 'r' refresh | 'c' clear session | 'C' all")
+	table.insert(lines, "╚══════════════════════════════════════════════════════╝")
+
+	return lines
+end
+
+--- Refresh the cost window content
+function M.refresh_window()
+	if not state.buf or not vim.api.nvim_buf_is_valid(state.buf) then
+		return
+	end
+
+	local lines = generate_content()
+
+	vim.bo[state.buf].modifiable = true
+	vim.api.nvim_buf_set_lines(state.buf, 0, -1, false, lines)
+	vim.bo[state.buf].modifiable = false
+end
+
+--- Open the cost estimation window
+function M.open()
+	-- Load historical data if not loaded
+	M.load_from_history()
+
+	-- Close existing window if open
+	if state.win and vim.api.nvim_win_is_valid(state.win) then
+		vim.api.nvim_win_close(state.win, true)
+	end
+
+	-- Create buffer
+	state.buf = vim.api.nvim_create_buf(false, true)
+	vim.bo[state.buf].buftype = "nofile"
+	vim.bo[state.buf].bufhidden = "wipe"
+	vim.bo[state.buf].swapfile = false
+	vim.bo[state.buf].filetype = "codetyper-cost"
+
+	-- Calculate window size
+	local width = 58
+	local height = 40
+	local row = math.floor((vim.o.lines - height) / 2)
+	local col = math.floor((vim.o.columns - width) / 2)
+
+	-- Create floating window
+	state.win = vim.api.nvim_open_win(state.buf, true, {
+		relative = "editor",
+		width = width,
+		height = height,
+		row = row,
+		col = col,
+		style = "minimal",
+		border = "rounded",
+		title = " Cost Estimation ",
+		title_pos = "center",
+	})
+
+	-- Set window options
+	vim.wo[state.win].wrap = false
+	vim.wo[state.win].cursorline = false
+
+	-- Populate content
+	M.refresh_window()
+
+	-- Set up keymaps
+	local opts = { buffer = state.buf, silent = true }
+	vim.keymap.set("n", "q", function()
+		M.close()
+	end, opts)
+	vim.keymap.set("n", "<Esc>", function()
+		M.close()
+	end, opts)
+	vim.keymap.set("n", "r", function()
+		M.refresh_window()
+	end, opts)
+	vim.keymap.set("n", "c", function()
+		M.clear_session()
+		M.refresh_window()
+	end, opts)
+	vim.keymap.set("n", "C", function()
+		M.clear_all()
+		M.refresh_window()
+	end, opts)
+
+	-- Set up highlights
+	vim.api.nvim_buf_call(state.buf, function()
+		vim.fn.matchadd("Title", "LLM Cost Estimation")
+		vim.fn.matchadd("Number", "\\$[0-9.]*")
+		vim.fn.matchadd("Keyword", "[0-9.]*[KM]\\? tokens")
+		vim.fn.matchadd("Special", "🤖\\|💰\\|📊\\|📈\\|💵")
+	end)
+end
+
+--- Close the cost window
+function M.close()
+	if state.win and vim.api.nvim_win_is_valid(state.win) then
+		vim.api.nvim_win_close(state.win, true)
+	end
+	state.win = nil
+	state.buf = nil
+end
+
+--- Toggle the cost window
+function M.toggle()
+	if state.win and vim.api.nvim_win_is_valid(state.win) then
+		M.close()
+	else
+		M.open()
+	end
+end
+
+--- Clear session usage (not history)
+function M.clear_session()
+	state.usage = {}
+	state.session_start = os.time()
+	utils.notify("Session cost tracking cleared", vim.log.levels.INFO)
+end
+
+--- Clear all history (session + saved)
+function M.clear_all()
+	state.usage = {}
+	state.all_usage = {}
+	state.session_start = os.time()
+	state.loaded = false
+
+	-- Delete history file
+	local history_path = get_history_path()
+	local ok, err = os.remove(history_path)
+	if not ok and err and not err:match("No such file") then
+		utils.notify("Failed to delete history: " .. err, vim.log.levels.WARN)
+	end
+
+	utils.notify("All cost history cleared", vim.log.levels.INFO)
+end
+
+--- Clear usage history (alias for clear_session)
+function M.clear()
+	M.clear_session()
+end
+
+--- Reset session
+function M.reset()
+	M.clear_session()
+end
+
+return M
--- a/lua/codetyper/core/diff/conflict.lua
+++ b/lua/codetyper/core/diff/conflict.lua
--- a/lua/codetyper/core/diff/diff.lua
+++ b/lua/codetyper/core/diff/diff.lua
@@ -9,7 +9,20 @@ local M = {}
 ---@param callback fun(approved: boolean) Called with user decision
 function M.show_diff(diff_data, callback)
  local original_lines = vim.split(diff_data.original, "\n", { plain = true })
-  local modified_lines = vim.split(diff_data.modified, "\n", { plain = true })
+  local modified_lines
+
+  -- For delete operations, show a clear message
+  if diff_data.operation == "delete" then
+    modified_lines = {
+      "",
+      "  FILE WILL BE DELETED",
+      "",
+      "  Reason: " .. (diff_data.reason or "No reason provided"),
+      "",
+    }
+  else
+    modified_lines = vim.split(diff_data.modified, "\n", { plain = true })
+  end

  -- Calculate window dimensions
  local width = math.floor(vim.o.columns * 0.8)
@@ -59,7 +72,7 @@ function M.show_diff(diff_data, callback)
    col = col + half_width + 1,
    style = "minimal",
    border = "rounded",
-    title = " MODIFIED [" .. diff_data.operation .. "] ",
+    title = diff_data.operation == "delete" and " ⚠️ DELETE " or (" MODIFIED [" .. diff_data.operation .. "] "),
    title_pos = "center",
  })

@@ -144,39 +157,67 @@ function M.show_diff(diff_data, callback)
  end

  -- Show help message
-  vim.api.nvim_echo({
-    { "Diff: ", "Normal" },
-    { diff_data.path, "Directory" },
-    { " | ", "Normal" },
-    { "y/<CR>", "Keyword" },
-    { " approve  ", "Normal" },
-    { "n/q/<Esc>", "Keyword" },
-    { " reject  ", "Normal" },
-    { "<Tab>", "Keyword" },
-    { " switch panes", "Normal" },
-  }, false, {})
+  local help_msg = require("codetyper.prompts.agents.diff").diff_help
+
+  -- Iterate to replace {path} variable
+  local final_help = {}
+  for _, item in ipairs(help_msg) do
+    if item[1] == "{path}" then
+       table.insert(final_help, { diff_data.path, item[2] })
+    else
+       table.insert(final_help, item)
+    end
+  end
+
+  vim.api.nvim_echo(final_help, false, {})
 end

--- Show approval dialog for bash commands
+---@alias BashApprovalResult {approved: boolean, permission_level: string|nil}
+
+--- Show approval dialog for bash commands with permission levels
 ---@param command string The bash command to approve
---@param callback fun(approved: boolean) Called with user decision
+---@param callback fun(result: BashApprovalResult) Called with user decision
 function M.show_bash_approval(command, callback)
-  -- Create a simple floating window for bash approval
+  local permissions = require("codetyper.features.agents.permissions")
+
+  -- Check if command is auto-approved
+  local perm_result = permissions.check_bash_permission(command)
+  if perm_result.auto and perm_result.allowed then
+    vim.schedule(function()
+      callback({ approved = true, permission_level = "auto" })
+    end)
+    return
+  end
+
+  -- Create approval dialog with options
+  local approval_prompts = require("codetyper.prompts.agents.diff").bash_approval
  local lines = {
    "",
-    "  BASH COMMAND APPROVAL",
-    "  " .. string.rep("-", 50),
+    approval_prompts.title,
+    approval_prompts.divider,
    "",
-    "  Command:",
+    approval_prompts.command_label,
    "  $ " .. command,
    "",
-    "  " .. string.rep("-", 50),
-    "  Press [y] or [Enter] to execute",
-    "  Press [n], [q], or [Esc] to cancel",
-    "",
  }

-  local width = math.max(60, #command + 10)
+  -- Add warning for dangerous commands
+  if not perm_result.allowed and perm_result.reason ~= "Requires approval" then
+    table.insert(lines, approval_prompts.warning_prefix .. perm_result.reason)
+    table.insert(lines, "")
+  end
+
+  table.insert(lines, approval_prompts.divider)
+  table.insert(lines, "")
+  for _, opt in ipairs(approval_prompts.options) do
+     table.insert(lines, opt)
+  end
+  table.insert(lines, "")
+  table.insert(lines, approval_prompts.divider)
+  table.insert(lines, approval_prompts.cancel_hint)
+  table.insert(lines, "")
+
+  local width = math.max(65, #command + 15)
  local height = #lines

  local buf = vim.api.nvim_create_buf(false, true)
@@ -196,45 +237,84 @@ function M.show_bash_approval(command, callback)
    title_pos = "center",
  })

-  -- Apply some highlighting
+  -- Apply highlighting
  vim.api.nvim_buf_add_highlight(buf, -1, "Title", 1, 0, -1)
  vim.api.nvim_buf_add_highlight(buf, -1, "String", 5, 0, -1)

+  -- Highlight options
+  for i, line in ipairs(lines) do
+    if line:match("^%s+%[y%]") then
+      vim.api.nvim_buf_add_highlight(buf, -1, "DiagnosticOk", i - 1, 0, -1)
+    elseif line:match("^%s+%[s%]") then
+      vim.api.nvim_buf_add_highlight(buf, -1, "DiagnosticInfo", i - 1, 0, -1)
+    elseif line:match("^%s+%[a%]") then
+      vim.api.nvim_buf_add_highlight(buf, -1, "DiagnosticHint", i - 1, 0, -1)
+    elseif line:match("^%s+%[n%]") then
+      vim.api.nvim_buf_add_highlight(buf, -1, "DiagnosticError", i - 1, 0, -1)
+    elseif line:match("⚠️") then
+      vim.api.nvim_buf_add_highlight(buf, -1, "DiagnosticWarn", i - 1, 0, -1)
+    end
+  end
+
  local callback_called = false

-  local function close_and_respond(approved)
+  local function close_and_respond(approved, permission_level)
    if callback_called then
      return
    end
    callback_called = true

+    -- Grant permission if approved with session or list level
+    if approved and permission_level then
+      permissions.grant_permission(command, permission_level)
+    end
+
    pcall(vim.api.nvim_win_close, win, true)

    vim.schedule(function()
-      callback(approved)
+      callback({ approved = approved, permission_level = permission_level })
    end)
  end

  local keymap_opts = { buffer = buf, noremap = true, silent = true, nowait = true }

-  -- Approve
+  -- Allow once
  vim.keymap.set("n", "y", function()
-    close_and_respond(true)
+    close_and_respond(true, "allow")
  end, keymap_opts)
  vim.keymap.set("n", "<CR>", function()
-    close_and_respond(true)
+    close_and_respond(true, "allow")
+  end, keymap_opts)
+
+  -- Allow this session
+  vim.keymap.set("n", "s", function()
+    close_and_respond(true, "allow_session")
+  end, keymap_opts)
+
+  -- Add to allow list
+  vim.keymap.set("n", "a", function()
+    close_and_respond(true, "allow_list")
  end, keymap_opts)

  -- Reject
  vim.keymap.set("n", "n", function()
-    close_and_respond(false)
+    close_and_respond(false, nil)
  end, keymap_opts)
  vim.keymap.set("n", "q", function()
-    close_and_respond(false)
+    close_and_respond(false, nil)
  end, keymap_opts)
  vim.keymap.set("n", "<Esc>", function()
-    close_and_respond(false)
+    close_and_respond(false, nil)
  end, keymap_opts)
 end

+--- Show approval dialog for bash commands (simple version for backward compatibility)
+---@param command string The bash command to approve
+---@param callback fun(approved: boolean) Called with user decision
+function M.show_bash_approval_simple(command, callback)
+  M.show_bash_approval(command, function(result)
+    callback(result.approved)
+  end)
+end
+
 return M
--- a/lua/codetyper/core/diff/patch.lua
+++ b/lua/codetyper/core/diff/patch.lua
--- a/lua/codetyper/core/diff/search_replace.lua
+++ b/lua/codetyper/core/diff/search_replace.lua
@@ -0,0 +1,572 @@
+---@mod codetyper.agent.search_replace Search/Replace editing system
+---@brief [[
+--- Implements SEARCH/REPLACE block parsing and fuzzy matching for reliable code edits.
+--- Parses and applies SEARCH/REPLACE blocks from LLM responses.
+---@brief ]]
+
+local M = {}
+
+local params = require("codetyper.params.agents.search_replace").patterns
+
+---@class SearchReplaceBlock
+---@field search string The text to search for
+---@field replace string The text to replace with
+---@field file_path string|nil Optional file path for multi-file edits
+
+---@class MatchResult
+---@field start_line number 1-indexed start line
+---@field end_line number 1-indexed end line
+---@field start_col number 1-indexed start column (for partial line matches)
+---@field end_col number 1-indexed end column
+---@field strategy string Which matching strategy succeeded
+---@field confidence number Match confidence (0.0-1.0)
+
+--- Parse SEARCH/REPLACE blocks from LLM response
+--- Supports multiple formats:
+--- Format 1 (dash style):
+---   ------- SEARCH
+---   old code
+---   =======
+---   new code
+---   +++++++ REPLACE
+---
+--- Format 2 (claude style):
+---   <<<<<<< SEARCH
+---   old code
+---   =======
+---   new code
+---   >>>>>>> REPLACE
+---
+--- Format 3 (simple):
+---   [SEARCH]
+---   old code
+---   [REPLACE]
+---   new code
+---   [END]
+---
+---@param response string LLM response text
+---@return SearchReplaceBlock[]
+function M.parse_blocks(response)
+	local blocks = {}
+
+	-- Try dash-style format: ------- SEARCH ... ======= ... +++++++ REPLACE
+	for search, replace in response:gmatch(params.dash_style) do
+		table.insert(blocks, { search = search, replace = replace })
+	end
+
+	if #blocks > 0 then
+		return blocks
+	end
+
+	-- Try claude-style format: <<<<<<< SEARCH ... ======= ... >>>>>>> REPLACE
+	for search, replace in response:gmatch(params.claude_style) do
+		table.insert(blocks, { search = search, replace = replace })
+	end
+
+	if #blocks > 0 then
+		return blocks
+	end
+
+	-- Try simple format: [SEARCH] ... [REPLACE] ... [END]
+	for search, replace in response:gmatch(params.simple_style) do
+		table.insert(blocks, { search = search, replace = replace })
+	end
+
+	if #blocks > 0 then
+		return blocks
+	end
+
+	-- Try markdown diff format: ```diff ... ```
+	local diff_block = response:match(params.diff_block)
+	if diff_block then
+		local old_lines = {}
+		local new_lines = {}
+		for line in diff_block:gmatch("[^\n]+") do
+			if line:match("^%-[^%-]") then
+				-- Removed line (starts with single -)
+				table.insert(old_lines, line:sub(2))
+			elseif line:match("^%+[^%+]") then
+				-- Added line (starts with single +)
+				table.insert(new_lines, line:sub(2))
+			elseif line:match("^%s") or line:match("^[^%-%+@]") then
+				-- Context line
+				table.insert(old_lines, line:match("^%s?(.*)"))
+				table.insert(new_lines, line:match("^%s?(.*)"))
+			end
+		end
+		if #old_lines > 0 or #new_lines > 0 then
+			table.insert(blocks, {
+				search = table.concat(old_lines, "\n"),
+				replace = table.concat(new_lines, "\n"),
+			})
+		end
+	end
+
+	return blocks
+end
+
+--- Get indentation of a line
+---@param line string
+---@return string
+local function get_indentation(line)
+	if not line then
+		return ""
+	end
+	return line:match("^(%s*)") or ""
+end
+
+--- Normalize whitespace in a string (collapse multiple spaces to one)
+---@param str string
+---@return string
+local function normalize_whitespace(str)
+	-- Wrap in parentheses to only return first value (gsub returns string + count)
+	return (str:gsub("%s+", " "):gsub("^%s*", ""):gsub("%s*$", ""))
+end
+
+--- Trim trailing whitespace from each line
+---@param str string
+---@return string
+local function trim_lines(str)
+	local lines = vim.split(str, "\n", { plain = true })
+	for i, line in ipairs(lines) do
+		-- Wrap in parentheses to only get string, not count
+		lines[i] = (line:gsub("%s+$", ""))
+	end
+	return table.concat(lines, "\n")
+end
+
+--- Calculate Levenshtein distance between two strings
+---@param s1 string
+---@param s2 string
+---@return number
+local function levenshtein(s1, s2)
+	local len1, len2 = #s1, #s2
+	if len1 == 0 then
+		return len2
+	end
+	if len2 == 0 then
+		return len1
+	end
+
+	local matrix = {}
+	for i = 0, len1 do
+		matrix[i] = { [0] = i }
+	end
+	for j = 0, len2 do
+		matrix[0][j] = j
+	end
+
+	for i = 1, len1 do
+		for j = 1, len2 do
+			local cost = (s1:sub(i, i) == s2:sub(j, j)) and 0 or 1
+			matrix[i][j] = math.min(
+				matrix[i - 1][j] + 1,
+				matrix[i][j - 1] + 1,
+				matrix[i - 1][j - 1] + cost
+			)
+		end
+	end
+
+	return matrix[len1][len2]
+end
+
+--- Calculate similarity ratio (0.0-1.0) between two strings
+---@param s1 string
+---@param s2 string
+---@return number
+local function similarity(s1, s2)
+	if s1 == s2 then
+		return 1.0
+	end
+	local max_len = math.max(#s1, #s2)
+	if max_len == 0 then
+		return 1.0
+	end
+	local distance = levenshtein(s1, s2)
+	return 1.0 - (distance / max_len)
+end
+
+--- Strategy 1: Exact match
+---@param content_lines string[]
+---@param search_lines string[]
+---@return MatchResult|nil
+local function exact_match(content_lines, search_lines)
+	if #search_lines == 0 then
+		return nil
+	end
+
+	for i = 1, #content_lines - #search_lines + 1 do
+		local match = true
+		for j = 1, #search_lines do
+			if content_lines[i + j - 1] ~= search_lines[j] then
+				match = false
+				break
+			end
+		end
+		if match then
+			return {
+				start_line = i,
+				end_line = i + #search_lines - 1,
+				start_col = 1,
+				end_col = #content_lines[i + #search_lines - 1],
+				strategy = "exact",
+				confidence = 1.0,
+			}
+		end
+	end
+
+	return nil
+end
+
+--- Strategy 2: Line-trimmed match (ignore trailing whitespace)
+---@param content_lines string[]
+---@param search_lines string[]
+---@return MatchResult|nil
+local function line_trimmed_match(content_lines, search_lines)
+	if #search_lines == 0 then
+		return nil
+	end
+
+	local trimmed_search = {}
+	for _, line in ipairs(search_lines) do
+		table.insert(trimmed_search, (line:gsub("%s+$", "")))
+	end
+
+	for i = 1, #content_lines - #search_lines + 1 do
+		local match = true
+		for j = 1, #search_lines do
+			local trimmed_content = content_lines[i + j - 1]:gsub("%s+$", "")
+			if trimmed_content ~= trimmed_search[j] then
+				match = false
+				break
+			end
+		end
+		if match then
+			return {
+				start_line = i,
+				end_line = i + #search_lines - 1,
+				start_col = 1,
+				end_col = #content_lines[i + #search_lines - 1],
+				strategy = "line_trimmed",
+				confidence = 0.95,
+			}
+		end
+	end
+
+	return nil
+end
+
+--- Strategy 3: Indentation-flexible match (normalize indentation)
+---@param content_lines string[]
+---@param search_lines string[]
+---@return MatchResult|nil
+local function indentation_flexible_match(content_lines, search_lines)
+	if #search_lines == 0 then
+		return nil
+	end
+
+	-- Get base indentation from search (first non-empty line)
+	local search_indent = ""
+	for _, line in ipairs(search_lines) do
+		if line:match("%S") then
+			search_indent = get_indentation(line)
+			break
+		end
+	end
+
+	-- Strip common indentation from search
+	local stripped_search = {}
+	for _, line in ipairs(search_lines) do
+		if line:match("^" .. vim.pesc(search_indent)) then
+			table.insert(stripped_search, line:sub(#search_indent + 1))
+		else
+			table.insert(stripped_search, line)
+		end
+	end
+
+	for i = 1, #content_lines - #search_lines + 1 do
+		-- Get content indentation at this position
+		local content_indent = ""
+		for j = 0, #search_lines - 1 do
+			local line = content_lines[i + j]
+			if line:match("%S") then
+				content_indent = get_indentation(line)
+				break
+			end
+		end
+
+		local match = true
+		for j = 1, #search_lines do
+			local content_line = content_lines[i + j - 1]
+			local expected = content_indent .. stripped_search[j]
+
+			-- Compare with normalized indentation
+			if content_line:gsub("%s+$", "") ~= expected:gsub("%s+$", "") then
+				match = false
+				break
+			end
+		end
+
+		if match then
+			return {
+				start_line = i,
+				end_line = i + #search_lines - 1,
+				start_col = 1,
+				end_col = #content_lines[i + #search_lines - 1],
+				strategy = "indentation_flexible",
+				confidence = 0.9,
+			}
+		end
+	end
+
+	return nil
+end
+
+--- Strategy 4: Block anchor match (match first/last lines, fuzzy middle)
+---@param content_lines string[]
+---@param search_lines string[]
+---@return MatchResult|nil
+local function block_anchor_match(content_lines, search_lines)
+	if #search_lines < 2 then
+		return nil
+	end
+
+	local first_search = search_lines[1]:gsub("%s+$", "")
+	local last_search = search_lines[#search_lines]:gsub("%s+$", "")
+
+	-- Find potential start positions
+	local candidates = {}
+	for i = 1, #content_lines - #search_lines + 1 do
+		local first_content = content_lines[i]:gsub("%s+$", "")
+		if similarity(first_content, first_search) > 0.8 then
+			-- Check if last line also matches
+			local last_idx = i + #search_lines - 1
+			if last_idx <= #content_lines then
+				local last_content = content_lines[last_idx]:gsub("%s+$", "")
+				if similarity(last_content, last_search) > 0.8 then
+					-- Calculate overall similarity
+					local total_sim = 0
+					for j = 1, #search_lines do
+						local c = content_lines[i + j - 1]:gsub("%s+$", "")
+						local s = search_lines[j]:gsub("%s+$", "")
+						total_sim = total_sim + similarity(c, s)
+					end
+					local avg_sim = total_sim / #search_lines
+					if avg_sim > 0.7 then
+						table.insert(candidates, { start = i, similarity = avg_sim })
+					end
+				end
+			end
+		end
+	end
+
+	-- Return best match
+	if #candidates > 0 then
+		table.sort(candidates, function(a, b)
+			return a.similarity > b.similarity
+		end)
+		local best = candidates[1]
+		return {
+			start_line = best.start,
+			end_line = best.start + #search_lines - 1,
+			start_col = 1,
+			end_col = #content_lines[best.start + #search_lines - 1],
+			strategy = "block_anchor",
+			confidence = best.similarity * 0.85,
+		}
+	end
+
+	return nil
+end
+
+--- Strategy 5: Whitespace-normalized match
+---@param content_lines string[]
+---@param search_lines string[]
+---@return MatchResult|nil
+local function whitespace_normalized_match(content_lines, search_lines)
+	if #search_lines == 0 then
+		return nil
+	end
+
+	-- Normalize search lines
+	local norm_search = {}
+	for _, line in ipairs(search_lines) do
+		table.insert(norm_search, normalize_whitespace(line))
+	end
+
+	for i = 1, #content_lines - #search_lines + 1 do
+		local match = true
+		for j = 1, #search_lines do
+			local norm_content = normalize_whitespace(content_lines[i + j - 1])
+			if norm_content ~= norm_search[j] then
+				match = false
+				break
+			end
+		end
+		if match then
+			return {
+				start_line = i,
+				end_line = i + #search_lines - 1,
+				start_col = 1,
+				end_col = #content_lines[i + #search_lines - 1],
+				strategy = "whitespace_normalized",
+				confidence = 0.8,
+			}
+		end
+	end
+
+	return nil
+end
+
+--- Find the best match for search text in content
+---@param content string File content
+---@param search string Text to search for
+---@return MatchResult|nil
+function M.find_match(content, search)
+	local content_lines = vim.split(content, "\n", { plain = true })
+	local search_lines = vim.split(search, "\n", { plain = true })
+
+	-- Remove trailing empty lines from search
+	while #search_lines > 0 and search_lines[#search_lines]:match("^%s*$") do
+		table.remove(search_lines)
+	end
+
+	if #search_lines == 0 then
+		return nil
+	end
+
+	-- Try strategies in order of strictness
+	local strategies = {
+		exact_match,
+		line_trimmed_match,
+		indentation_flexible_match,
+		block_anchor_match,
+		whitespace_normalized_match,
+	}
+
+	for _, strategy in ipairs(strategies) do
+		local result = strategy(content_lines, search_lines)
+		if result then
+			return result
+		end
+	end
+
+	return nil
+end
+
+--- Apply a single SEARCH/REPLACE block to content
+---@param content string Original file content
+---@param block SearchReplaceBlock
+---@return string|nil new_content
+---@return MatchResult|nil match_info
+---@return string|nil error
+function M.apply_block(content, block)
+	local match = M.find_match(content, block.search)
+	if not match then
+		return nil, nil, "Could not find search text in file"
+	end
+
+	local content_lines = vim.split(content, "\n", { plain = true })
+	local replace_lines = vim.split(block.replace, "\n", { plain = true })
+
+	-- Adjust indentation of replacement to match original
+	local original_indent = get_indentation(content_lines[match.start_line])
+	local replace_indent = ""
+	for _, line in ipairs(replace_lines) do
+		if line:match("%S") then
+			replace_indent = get_indentation(line)
+			break
+		end
+	end
+
+	-- Apply indentation adjustment
+	local adjusted_replace = {}
+	for _, line in ipairs(replace_lines) do
+		if line:match("^" .. vim.pesc(replace_indent)) then
+			table.insert(adjusted_replace, original_indent .. line:sub(#replace_indent + 1))
+		elseif line:match("^%s*$") then
+			table.insert(adjusted_replace, "")
+		else
+			table.insert(adjusted_replace, original_indent .. line)
+		end
+	end
+
+	-- Build new content
+	local new_lines = {}
+	for i = 1, match.start_line - 1 do
+		table.insert(new_lines, content_lines[i])
+	end
+	for _, line in ipairs(adjusted_replace) do
+		table.insert(new_lines, line)
+	end
+	for i = match.end_line + 1, #content_lines do
+		table.insert(new_lines, content_lines[i])
+	end
+
+	return table.concat(new_lines, "\n"), match, nil
+end
+
+--- Apply multiple SEARCH/REPLACE blocks to content
+---@param content string Original file content
+---@param blocks SearchReplaceBlock[]
+---@return string new_content
+---@return table results Array of {success: boolean, match: MatchResult|nil, error: string|nil}
+function M.apply_blocks(content, blocks)
+	local current_content = content
+	local results = {}
+
+	for _, block in ipairs(blocks) do
+		local new_content, match, err = M.apply_block(current_content, block)
+		if new_content then
+			current_content = new_content
+			table.insert(results, { success = true, match = match })
+		else
+			table.insert(results, { success = false, error = err })
+		end
+	end
+
+	return current_content, results
+end
+
+--- Apply SEARCH/REPLACE blocks to a buffer
+---@param bufnr number Buffer number
+---@param blocks SearchReplaceBlock[]
+---@return boolean success
+---@return string|nil error
+function M.apply_to_buffer(bufnr, blocks)
+	if not vim.api.nvim_buf_is_valid(bufnr) then
+		return false, "Invalid buffer"
+	end
+
+	local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
+	local content = table.concat(lines, "\n")
+
+	local new_content, results = M.apply_blocks(content, blocks)
+
+	-- Check for any failures
+	local failures = {}
+	for i, result in ipairs(results) do
+		if not result.success then
+			table.insert(failures, string.format("Block %d: %s", i, result.error or "unknown error"))
+		end
+	end
+
+	if #failures > 0 then
+		return false, table.concat(failures, "; ")
+	end
+
+	-- Apply to buffer
+	local new_lines = vim.split(new_content, "\n", { plain = true })
+	vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, new_lines)
+
+	return true, nil
+end
+
+--- Check if response contains SEARCH/REPLACE blocks
+---@param response string
+---@return boolean
+function M.has_blocks(response)
+	return #M.parse_blocks(response) > 0
+end
+
+return M
--- a/lua/codetyper/core/events/queue.lua
+++ b/lua/codetyper/core/events/queue.lua
@@ -6,6 +6,11 @@

 local M = {}

+---@class AttachedFile
+---@field path string Relative path as referenced in prompt
+---@field full_path string Absolute path to the file
+---@field content string File content
+
 ---@class PromptEvent
 ---@field id string Unique event ID
 ---@field bufnr number Source buffer number
@@ -16,14 +21,15 @@ local M = {}
 ---@field prompt_content string Cleaned prompt text
 ---@field target_path string Target file for injection
 ---@field priority number Priority (1=high, 2=normal, 3=low)
---@field status string "pending"|"processing"|"completed"|"escalated"|"cancelled"
+---@field status string "pending"|"processing"|"completed"|"escalated"|"cancelled"|"needs_context"|"failed"
 ---@field attempt_count number Number of processing attempts
---@field worker_type string|nil LLM provider used ("ollama"|"claude"|etc)
+---@field worker_type string|nil LLM provider used ("ollama"|"openai"|"gemini"|"copilot")
 ---@field created_at number System time when created
 ---@field intent Intent|nil Detected intent from prompt
 ---@field scope ScopeInfo|nil Resolved scope (function/class/file)
 ---@field scope_text string|nil Text of the resolved scope
 ---@field scope_range {start_line: number, end_line: number}|nil Range of scope in target
+---@field attached_files AttachedFile[]|nil Files attached via @filename syntax

 --- Internal state
 ---@type PromptEvent[]
@@ -188,7 +194,7 @@ function M.enqueue(event)

 	-- Log to agent logs if available
 	pcall(function()
-		local logs = require("codetyper.agent.logs")
+		local logs = require("codetyper.adapters.nvim.ui.logs")
 		logs.add({
 			type = "queue",
 			message = string.format("Event queued: %s (priority: %d)", event.id, event.priority),
@@ -383,16 +389,21 @@ function M.clear(status)
 	notify_listeners("update", nil)
 end

--- Cleanup completed/cancelled events older than max_age seconds
+--- Cleanup completed/cancelled/failed events older than max_age seconds
 ---@param max_age number Maximum age in seconds (default: 300)
 function M.cleanup(max_age)
 	max_age = max_age or 300
 	local now = os.time()
+	local terminal_statuses = {
+		completed = true,
+		cancelled = true,
+		failed = true,
+		needs_context = true,
+	}
 	local i = 1
 	while i <= #queue do
 		local event = queue[i]
-		if (event.status == "completed" or event.status == "cancelled")
-			and (now - event.created_at) > max_age then
+		if terminal_statuses[event.status] and (now - event.created_at) > max_age then
 			table.remove(queue, i)
 		else
 			i = i + 1
@@ -410,6 +421,8 @@ function M.stats()
 		completed = 0,
 		cancelled = 0,
 		escalated = 0,
+		failed = 0,
+		needs_context = 0,
 	}
 	for _, event in ipairs(queue) do
 		local s = event.status
--- a/lua/codetyper/core/intent/init.lua
+++ b/lua/codetyper/core/intent/init.lua
@@ -0,0 +1,117 @@
+---@mod codetyper.agent.intent Intent detection from prompts
+---@brief [[
+--- Parses prompt content to determine user intent and target scope.
+--- Intents determine how the generated code should be applied.
+---@brief ]]
+
+local M = {}
+
+---@class Intent
+---@field type string "complete"|"refactor"|"add"|"fix"|"document"|"test"|"explain"|"optimize"
+---@field scope_hint string|nil "function"|"class"|"block"|"file"|"selection"|nil
+---@field confidence number 0.0-1.0 how confident we are about the intent
+---@field action string "replace"|"insert"|"append"|"none"
+---@field keywords string[] Keywords that triggered this intent
+
+local params = require("codetyper.params.agents.intent")
+local intent_patterns = params.intent_patterns
+local scope_patterns = params.scope_patterns
+local prompts = require("codetyper.prompts.agents.intent")
+
+--- Detect intent from prompt content
+---@param prompt string The prompt content
+---@return Intent
+function M.detect(prompt)
+	local lower = prompt:lower()
+	local best_match = nil
+	local best_priority = 999
+	local matched_keywords = {}
+
+	-- Check each intent type
+	for intent_type, config in pairs(intent_patterns) do
+		for _, pattern in ipairs(config.patterns) do
+			if lower:find(pattern, 1, true) then
+				if config.priority < best_priority then
+					best_match = intent_type
+					best_priority = config.priority
+					matched_keywords = { pattern }
+				elseif config.priority == best_priority and best_match == intent_type then
+					table.insert(matched_keywords, pattern)
+				end
+			end
+		end
+	end
+
+	-- Default to "add" if no clear intent
+	if not best_match then
+		best_match = "add"
+		matched_keywords = {}
+	end
+
+	local config = intent_patterns[best_match]
+
+	-- Detect scope hint from prompt
+	local scope_hint = config.scope_hint
+	for pattern, hint in pairs(scope_patterns) do
+		if lower:find(pattern, 1, true) then
+			scope_hint = hint or scope_hint
+			break
+		end
+	end
+
+	-- Calculate confidence based on keyword matches
+	local confidence = 0.5 + (#matched_keywords * 0.15)
+	confidence = math.min(confidence, 1.0)
+
+	return {
+		type = best_match,
+		scope_hint = scope_hint,
+		confidence = confidence,
+		action = config.action,
+		keywords = matched_keywords,
+	}
+end
+
+--- Check if intent requires code modification
+---@param intent Intent
+---@return boolean
+function M.modifies_code(intent)
+	return intent.action ~= "none"
+end
+
+--- Check if intent should replace existing code
+---@param intent Intent
+---@return boolean
+function M.is_replacement(intent)
+	return intent.action == "replace"
+end
+
+--- Check if intent adds new code
+---@param intent Intent
+---@return boolean
+function M.is_insertion(intent)
+	return intent.action == "insert" or intent.action == "append"
+end
+
+--- Get system prompt modifier based on intent
+---@param intent Intent
+---@return string
+function M.get_prompt_modifier(intent)
+	local modifiers = prompts.modifiers
+	return modifiers[intent.type] or modifiers.add
+end
+
+--- Format intent for logging
+---@param intent Intent
+---@return string
+function M.format(intent)
+	return string.format(
+		"%s (scope: %s, action: %s, confidence: %.2f)",
+		intent.type,
+		intent.scope_hint or "auto",
+		intent.action,
+		intent.confidence
+	)
+end
+
+return M
--- a/lua/codetyper/core/llm/confidence.lua
+++ b/lua/codetyper/core/llm/confidence.lua
@@ -6,41 +6,14 @@

 local M = {}

+local params = require("codetyper.params.agents.confidence")
+
 --- Heuristic weights (must sum to 1.0)
-M.weights = {
-	length = 0.15,      -- Response length relative to prompt
-	uncertainty = 0.30, -- Uncertainty phrases
-	syntax = 0.25,      -- Syntax completeness
-	repetition = 0.15,  -- Duplicate lines
-	truncation = 0.15,  -- Incomplete ending
-}
+M.weights = params.weights

 --- Uncertainty phrases that indicate low confidence
-local uncertainty_phrases = {
-	-- English
-	"i'm not sure",
-	"i am not sure",
-	"maybe",
-	"perhaps",
-	"might work",
-	"could work",
-	"not certain",
-	"uncertain",
-	"i think",
-	"possibly",
-	"TODO",
-	"FIXME",
-	"XXX",
-	"placeholder",
-	"implement this",
-	"fill in",
-	"your code here",
-	"...", -- Ellipsis as placeholder
-	"# TODO",
-	"// TODO",
-	"-- TODO",
-	"/* TODO",
-}
+local uncertainty_phrases = params.uncertainty_phrases
+

 --- Score based on response length relative to prompt
 ---@param response string
@@ -94,32 +67,6 @@ local function score_uncertainty(response)
 	end
 end

--- Check bracket balance for common languages
---@param response string
---@return boolean balanced
-local function check_brackets(response)
-	local pairs = {
-		["{"] = "}",
-		["["] = "]",
-		["("] = ")",
-	}
-
-	local stack = {}
-
-	for char in response:gmatch(".") do
-		if pairs[char] then
-			table.insert(stack, pairs[char])
-		elseif char == "}" or char == "]" or char == ")" then
-			if #stack == 0 or stack[#stack] ~= char then
-				return false
-			end
-			table.remove(stack)
-		end
-	end
-
-	return #stack == 0
-end
-
 --- Score based on syntax completeness
 ---@param response string
 ---@return number 0.0-1.0
@@ -127,7 +74,7 @@ local function score_syntax(response)
 	local score = 1.0

 	-- Check bracket balance
-	if not check_brackets(response) then
+	if not require("codetyper.support.utils").check_brackets(response) then
 		score = score - 0.4
 	end

@@ -255,14 +202,15 @@ function M.score(response, prompt, context)
 	_ = context -- Reserved for future use

 	if not response or #response == 0 then
-		return 0, {
-			length = 0,
-			uncertainty = 0,
-			syntax = 0,
-			repetition = 0,
-			truncation = 0,
-			weighted_total = 0,
-		}
+		return 0,
+			{
+				length = 0,
+				uncertainty = 0,
+				syntax = 0,
+				repetition = 0,
+				truncation = 0,
+				weighted_total = 0,
+			}
 	end

 	local scores = {
--- a/lua/codetyper/core/llm/copilot.lua
+++ b/lua/codetyper/core/llm/copilot.lua
@@ -2,8 +2,8 @@

 local M = {}

-local utils = require("codetyper.utils")
-local llm = require("codetyper.llm")
+local utils = require("codetyper.support.utils")
+local llm = require("codetyper.core.llm")

 --- Copilot API endpoints
 local AUTH_URL = "https://api.github.com/copilot_internal/v2/token"
@@ -14,6 +14,51 @@ local AUTH_URL = "https://api.github.com/copilot_internal/v2/token"
 ---@field github_token table|nil
 M.state = nil

+--- Track if we've already suggested Ollama fallback this session
+local ollama_fallback_suggested = false
+
+--- Suggest switching to Ollama when rate limits are hit
+---@param error_msg string The error message that triggered this
+function M.suggest_ollama_fallback(error_msg)
+	if ollama_fallback_suggested then
+		return
+	end
+
+	-- Check if Ollama is available
+	local ollama_available = false
+	vim.fn.jobstart({ "curl", "-s", "http://localhost:11434/api/tags" }, {
+		on_exit = function(_, code)
+			if code == 0 then
+				ollama_available = true
+			end
+
+			vim.schedule(function()
+				if ollama_available then
+					-- Switch to Ollama automatically
+					local codetyper = require("codetyper")
+					local config = codetyper.get_config()
+					config.llm.provider = "ollama"
+
+					ollama_fallback_suggested = true
+					utils.notify(
+						"⚠️ Copilot rate limit reached. Switched to Ollama automatically.\n"
+							.. "Original error: "
+							.. error_msg:sub(1, 100),
+						vim.log.levels.WARN
+					)
+				else
+					utils.notify(
+						"⚠️ Copilot rate limit reached. Ollama not available.\n"
+							.. "Start Ollama with: ollama serve\n"
+							.. "Or wait for Copilot limits to reset.",
+						vim.log.levels.WARN
+					)
+				end
+			end)
+		end,
+	})
+end
+
 --- Get OAuth token from copilot.lua or copilot.vim config
 ---@return string|nil OAuth token
 local function get_oauth_token()
@@ -51,9 +96,16 @@ local function get_oauth_token()
 	return nil
 end

--- Get model from config
+--- Get model from stored credentials or config
 ---@return string Model name
 local function get_model()
+	-- Priority: stored credentials > config
+	local credentials = require("codetyper.credentials")
+	local stored_model = credentials.get_model("copilot")
+	if stored_model then
+		return stored_model
+	end
+
 	local codetyper = require("codetyper")
 	local config = codetyper.get_config()
 	return config.llm.copilot.model
@@ -204,15 +256,37 @@ local function make_request(token, body, callback)
 			local ok, response = pcall(vim.json.decode, response_text)

 			if not ok then
+				-- Show the actual response text as the error (truncated if too long)
+				local error_msg = response_text
+				if #error_msg > 200 then
+					error_msg = error_msg:sub(1, 200) .. "..."
+				end
+
+				-- Clean up common patterns
+				if response_text:match("<!DOCTYPE") or response_text:match("<html") then
+					error_msg = "Copilot API returned HTML error page. Service may be unavailable."
+				end
+
+				-- Check for rate limit and suggest Ollama fallback
+				if response_text:match("limit") or response_text:match("Upgrade") or response_text:match("quota") then
+					M.suggest_ollama_fallback(error_msg)
+				end
+
 				vim.schedule(function()
-					callback(nil, "Failed to parse Copilot response", nil)
+					callback(nil, error_msg, nil)
 				end)
 				return
 			end

 			if response.error then
+				local error_msg = response.error.message or "Copilot API error"
+				if response.error.code == "rate_limit_exceeded" or (error_msg:match("limit") and error_msg:match("plan")) then
+					error_msg = "Copilot rate limit: " .. error_msg
+					M.suggest_ollama_fallback(error_msg)
+				end
+
 				vim.schedule(function()
-					callback(nil, response.error.message or "Copilot API error", nil)
+					callback(nil, error_msg, nil)
 				end)
 				return
 			end
@@ -220,6 +294,17 @@ local function make_request(token, body, callback)
 			-- Extract usage info
 			local usage = response.usage or {}

+			-- Record usage for cost tracking
+			if usage.prompt_tokens or usage.completion_tokens then
+				local cost = require("codetyper.core.cost")
+				cost.record_usage(
+					get_model(),
+					usage.prompt_tokens or 0,
+					usage.completion_tokens or 0,
+					usage.prompt_tokens_details and usage.prompt_tokens_details.cached_tokens or 0
+				)
+			end
+
 			if response.choices and response.choices[1] and response.choices[1].message then
 				local code = llm.extract_code(response.choices[1].message.content)
 				vim.schedule(function()
@@ -263,7 +348,7 @@ end
 ---@param context table Context information
 ---@param callback fun(response: string|nil, error: string|nil)
 function M.generate(prompt, context, callback)
-	local logs = require("codetyper.agent.logs")
+	local logs = require("codetyper.adapters.nvim.ui.logs")

 	ensure_initialized()

@@ -329,7 +414,7 @@ end
 ---@param tool_definitions table Tool definitions
 ---@param callback fun(response: table|nil, error: string|nil)
 function M.generate_with_tools(messages, context, tool_definitions, callback)
-	local logs = require("codetyper.agent.logs")
+	local logs = require("codetyper.adapters.nvim.ui.logs")

 	ensure_initialized()

@@ -351,31 +436,68 @@ function M.generate_with_tools(messages, context, tool_definitions, callback)
 			return
 		end

-		local tools_module = require("codetyper.agent.tools")
-		local agent_prompts = require("codetyper.prompts.agent")
+		local tools_module = require("codetyper.core.tools")
+		local agent_prompts = require("codetyper.prompts.agents")

-		-- Build system prompt with agent instructions
+		-- Build system prompt with agent instructions and project context
 		local system_prompt = llm.build_system_prompt(context)
-		system_prompt = system_prompt .. "\n\n" .. agent_prompts.system
-		system_prompt = system_prompt .. "\n\n" .. agent_prompts.tool_instructions
+		system_prompt = system_prompt .. "\n\n" .. agent_prompts.build_system_prompt()

 		-- Format messages for Copilot (OpenAI-compatible format)
 		local copilot_messages = { { role = "system", content = system_prompt } }
 		for _, msg in ipairs(messages) do
-			if type(msg.content) == "string" then
-				table.insert(copilot_messages, { role = msg.role, content = msg.content })
-			elseif type(msg.content) == "table" then
-				local text_parts = {}
-				for _, part in ipairs(msg.content) do
-					if part.type == "tool_result" then
-						table.insert(text_parts, "[" .. (part.name or "tool") .. " result]: " .. (part.content or ""))
-					elseif part.type == "text" then
-						table.insert(text_parts, part.text or "")
+			if msg.role == "user" then
+				-- User messages - handle string or table content
+				if type(msg.content) == "string" then
+					table.insert(copilot_messages, { role = "user", content = msg.content })
+				elseif type(msg.content) == "table" then
+					-- Handle complex content (like tool results from user perspective)
+					local text_parts = {}
+					for _, part in ipairs(msg.content) do
+						if part.type == "tool_result" then
+							table.insert(text_parts, "[" .. (part.name or "tool") .. " result]: " .. (part.content or ""))
+						elseif part.type == "text" then
+							table.insert(text_parts, part.text or "")
+						end
+					end
+					if #text_parts > 0 then
+						table.insert(copilot_messages, { role = "user", content = table.concat(text_parts, "\n") })
 					end
 				end
-				if #text_parts > 0 then
-					table.insert(copilot_messages, { role = msg.role, content = table.concat(text_parts, "\n") })
+			elseif msg.role == "assistant" then
+				-- Assistant messages - must preserve tool_calls if present
+				local assistant_msg = {
+					role = "assistant",
+					content = type(msg.content) == "string" and msg.content or nil,
+				}
+				-- Convert tool_calls to OpenAI format for the API
+				if msg.tool_calls and #msg.tool_calls > 0 then
+					assistant_msg.tool_calls = {}
+					for _, tc in ipairs(msg.tool_calls) do
+						-- Convert from parsed format {id, name, parameters} to OpenAI format
+						local openai_tc = {
+							id = tc.id,
+							type = "function",
+							["function"] = {
+								name = tc.name,
+								arguments = vim.json.encode(tc.parameters or {}),
+							},
+						}
+						table.insert(assistant_msg.tool_calls, openai_tc)
+					end
+					-- Ensure content is not nil when tool_calls present
+					if assistant_msg.content == nil then
+						assistant_msg.content = ""
+					end
 				end
+				table.insert(copilot_messages, assistant_msg)
+			elseif msg.role == "tool" then
+				-- Tool result messages - must have tool_call_id
+				table.insert(copilot_messages, {
+					role = "tool",
+					tool_call_id = msg.tool_call_id,
+					content = type(msg.content) == "string" and msg.content or vim.json.encode(msg.content),
+				})
 			end
 		end

@@ -386,6 +508,7 @@ function M.generate_with_tools(messages, context, tool_definitions, callback)
 			temperature = 0.3,
 			stream = false,
 			tools = tools_module.to_openai_format(),
+			tool_choice = "auto", -- Encourage the model to use tools when appropriate
 		}

 		local endpoint = (token.endpoints and token.endpoints.api or "https://api.githubcopilot.com")
@@ -396,6 +519,20 @@ function M.generate_with_tools(messages, context, tool_definitions, callback)
 		logs.debug(string.format("Estimated prompt: ~%d tokens", prompt_estimate))
 		logs.thinking("Sending to Copilot API...")

+		-- Log request to debug file
+		local debug_log_path = vim.fn.expand("~/.local/codetyper-debug.log")
+		local debug_f = io.open(debug_log_path, "a")
+		if debug_f then
+			debug_f:write(os.date("[%Y-%m-%d %H:%M:%S] ") .. "COPILOT REQUEST\n")
+			debug_f:write("Messages count: " .. #copilot_messages .. "\n")
+			for i, m in ipairs(copilot_messages) do
+				debug_f:write(string.format("  [%d] role=%s, has_tool_calls=%s, has_tool_call_id=%s\n",
+					i, m.role, tostring(m.tool_calls ~= nil), tostring(m.tool_call_id ~= nil)))
+			end
+			debug_f:write("---\n")
+			debug_f:close()
+		end
+
 		local headers = build_headers(token)
 		local cmd = {
 			"curl",
@@ -413,35 +550,97 @@ function M.generate_with_tools(messages, context, tool_definitions, callback)
 		table.insert(cmd, "-d")
 		table.insert(cmd, json_body)

+		-- Debug logging helper
+		local function debug_log(msg, data)
+			local log_path = vim.fn.expand("~/.local/codetyper-debug.log")
+			local f = io.open(log_path, "a")
+			if f then
+				f:write(os.date("[%Y-%m-%d %H:%M:%S] ") .. msg .. "\n")
+				if data then
+					f:write("DATA: " .. tostring(data):sub(1, 2000) .. "\n")
+				end
+				f:write("---\n")
+				f:close()
+			end
+		end
+
+		-- Prevent double callback calls
+		local callback_called = false
+
 		vim.fn.jobstart(cmd, {
 			stdout_buffered = true,
 			on_stdout = function(_, data)
+				if callback_called then
+					debug_log("on_stdout: callback already called, skipping")
+					return
+				end
+
 				if not data or #data == 0 or (data[1] == "" and #data == 1) then
+					debug_log("on_stdout: empty data")
 					return
 				end

 				local response_text = table.concat(data, "\n")
+				debug_log("on_stdout: received response", response_text)
+
 				local ok, response = pcall(vim.json.decode, response_text)

 				if not ok then
+					debug_log("JSON parse failed", response_text)
+					callback_called = true
+
+					-- Show the actual response text as the error (truncated if too long)
+					local error_msg = response_text
+					if #error_msg > 200 then
+						error_msg = error_msg:sub(1, 200) .. "..."
+					end
+
+					-- Clean up common patterns
+					if response_text:match("<!DOCTYPE") or response_text:match("<html") then
+						error_msg = "Copilot API returned HTML error page. Service may be unavailable."
+					end
+
+					-- Check for rate limit and suggest Ollama fallback
+					if response_text:match("limit") or response_text:match("Upgrade") or response_text:match("quota") then
+						M.suggest_ollama_fallback(error_msg)
+					end
+
 					vim.schedule(function()
-						logs.error("Failed to parse Copilot response")
-						callback(nil, "Failed to parse Copilot response")
+						logs.error(error_msg)
+						callback(nil, error_msg)
 					end)
 					return
 				end

 				if response.error then
+					callback_called = true
+					local error_msg = response.error.message or "Copilot API error"
+
+					-- Check for rate limit in structured error
+					if response.error.code == "rate_limit_exceeded" or (error_msg:match("limit") and error_msg:match("plan")) then
+						error_msg = "Copilot rate limit: " .. error_msg
+						M.suggest_ollama_fallback(error_msg)
+					end
+
 					vim.schedule(function()
-						logs.error(response.error.message or "Copilot API error")
-						callback(nil, response.error.message or "Copilot API error")
+						logs.error(error_msg)
+						callback(nil, error_msg)
 					end)
 					return
 				end

-				-- Log token usage
+				-- Log token usage and record cost
 				if response.usage then
 					logs.response(response.usage.prompt_tokens or 0, response.usage.completion_tokens or 0, "stop")
+
+					-- Record usage for cost tracking
+					local cost_tracker = require("codetyper.core.cost")
+					cost_tracker.record_usage(
+						get_model(),
+						response.usage.prompt_tokens or 0,
+						response.usage.completion_tokens or 0,
+						response.usage.prompt_tokens_details and response.usage.prompt_tokens_details.cached_tokens or 0
+					)
 				end

 				-- Convert to Claude-like format for parser compatibility
@@ -474,12 +673,19 @@ function M.generate_with_tools(messages, context, tool_definitions, callback)
 					end
 				end

+				callback_called = true
+				debug_log("on_stdout: success, calling callback")
 				vim.schedule(function()
 					callback(converted, nil)
 				end)
 			end,
 			on_stderr = function(_, data)
+				if callback_called then
+					return
+				end
 				if data and #data > 0 and data[1] ~= "" then
+					debug_log("on_stderr", table.concat(data, "\n"))
+					callback_called = true
 					vim.schedule(function()
 						logs.error("Copilot API request failed: " .. table.concat(data, "\n"))
 						callback(nil, "Copilot API request failed: " .. table.concat(data, "\n"))
@@ -487,7 +693,12 @@ function M.generate_with_tools(messages, context, tool_definitions, callback)
 				end
 			end,
 			on_exit = function(_, code)
+				debug_log("on_exit: code=" .. code .. ", callback_called=" .. tostring(callback_called))
+				if callback_called then
+					return
+				end
 				if code ~= 0 then
+					callback_called = true
 					vim.schedule(function()
 						logs.error("Copilot API request failed with code: " .. code)
 						callback(nil, "Copilot API request failed with code: " .. code)
--- a/lua/codetyper/core/llm/gemini.lua
+++ b/lua/codetyper/core/llm/gemini.lua
@@ -2,23 +2,37 @@

 local M = {}

-local utils = require("codetyper.utils")
-local llm = require("codetyper.llm")
+local utils = require("codetyper.support.utils")
+local llm = require("codetyper.core.llm")

 --- Gemini API endpoint
 local API_URL = "https://generativelanguage.googleapis.com/v1beta/models"

--- Get API key from config or environment
+--- Get API key from stored credentials, config, or environment
 ---@return string|nil API key
 local function get_api_key()
+	-- Priority: stored credentials > config > environment
+	local credentials = require("codetyper.credentials")
+	local stored_key = credentials.get_api_key("gemini")
+	if stored_key then
+		return stored_key
+	end
+
 	local codetyper = require("codetyper")
 	local config = codetyper.get_config()
 	return config.llm.gemini.api_key or vim.env.GEMINI_API_KEY
 end

--- Get model from config
+--- Get model from stored credentials or config
 ---@return string Model name
 local function get_model()
+	-- Priority: stored credentials > config
+	local credentials = require("codetyper.credentials")
+	local stored_model = credentials.get_model("gemini")
+	if stored_model then
+		return stored_model
+	end
+
 	local codetyper = require("codetyper")
 	local config = codetyper.get_config()
 	return config.llm.gemini.model
@@ -153,7 +167,7 @@ end
 ---@param context table Context information
 ---@param callback fun(response: string|nil, error: string|nil) Callback function
 function M.generate(prompt, context, callback)
-	local logs = require("codetyper.agent.logs")
+	local logs = require("codetyper.adapters.nvim.ui.logs")
 	local model = get_model()

 	-- Log the request
@@ -203,7 +217,7 @@ end
 ---@param tool_definitions table Tool definitions
 ---@param callback fun(response: table|nil, error: string|nil) Callback with raw response
 function M.generate_with_tools(messages, context, tool_definitions, callback)
-	local logs = require("codetyper.agent.logs")
+	local logs = require("codetyper.adapters.nvim.ui.logs")
 	local model = get_model()

 	logs.request("gemini", model)
@@ -216,8 +230,8 @@ function M.generate_with_tools(messages, context, tool_definitions, callback)
 		return
 	end

-	local tools_module = require("codetyper.agent.tools")
-	local agent_prompts = require("codetyper.prompts.agent")
+	local tools_module = require("codetyper.core.tools")
+	local agent_prompts = require("codetyper.prompts.agents")

 	-- Build system prompt with agent instructions
 	local system_prompt = llm.build_system_prompt(context)
--- a/lua/codetyper/core/llm/init.lua
+++ b/lua/codetyper/core/llm/init.lua
@@ -1,8 +1,8 @@
 ---@mod codetyper.llm LLM interface for Codetyper.nvim

 local M = {}
-local lang_map = require("codetyper.utils.langmap")
-local utils = require("codetyper.utils")
+local lang_map = require("codetyper.support.langmap")
+local utils = require("codetyper.support.utils")

 --- Get the appropriate LLM client based on configuration
 ---@return table LLM client module
@@ -10,16 +10,14 @@ function M.get_client()
 	local codetyper = require("codetyper")
 	local config = codetyper.get_config()

-	if config.llm.provider == "claude" then
-		return require("codetyper.llm.claude")
-	elseif config.llm.provider == "ollama" then
-		return require("codetyper.llm.ollama")
+	if config.llm.provider == "ollama" then
+		return require("codetyper.core.llm.ollama")
 	elseif config.llm.provider == "openai" then
-		return require("codetyper.llm.openai")
+		return require("codetyper.core.llm.openai")
 	elseif config.llm.provider == "gemini" then
-		return require("codetyper.llm.gemini")
+		return require("codetyper.core.llm.gemini")
 	elseif config.llm.provider == "copilot" then
-		return require("codetyper.llm.copilot")
+		return require("codetyper.core.llm.copilot")
 	else
 		error("Unknown LLM provider: " .. config.llm.provider)
 	end
@@ -34,6 +32,32 @@ function M.generate(prompt, context, callback)
 	client.generate(prompt, context, callback)
 end

+--- Smart generate with automatic provider selection based on brain memories
+--- Prefers Ollama when context is rich, falls back to Copilot otherwise.
+--- Implements verification pondering to reinforce Ollama accuracy over time.
+---@param prompt string The user's prompt
+---@param context table Context information
+---@param callback fun(response: string|nil, error: string|nil, metadata: table|nil) Callback
+function M.smart_generate(prompt, context, callback)
+	local selector = require("codetyper.core.llm.selector")
+	selector.smart_generate(prompt, context, callback)
+end
+
+--- Get accuracy statistics for providers
+---@return table Statistics for each provider
+function M.get_accuracy_stats()
+	local selector = require("codetyper.core.llm.selector")
+	return selector.get_accuracy_stats()
+end
+
+--- Report user feedback on response quality (for reinforcement learning)
+---@param provider string Which provider generated the response
+---@param was_correct boolean Whether the response was good
+function M.report_feedback(provider, was_correct)
+	local selector = require("codetyper.core.llm.selector")
+	selector.report_feedback(provider, was_correct)
+end
+
 --- Build the system prompt for code generation
 ---@param context table Context information
 ---@return string System prompt
@@ -50,7 +74,49 @@ function M.build_system_prompt(context)
 	system = system:gsub("{{language}}", context.language or "unknown")
 	system = system:gsub("{{filepath}}", context.file_path or "unknown")

-	-- Add file content with analysis hints
+	-- For agent mode, include project context
+	if prompt_type == "agent" then
+		local project_info = "\n\n## PROJECT CONTEXT\n"
+
+		if context.project_root then
+			project_info = project_info .. "- Project root: " .. context.project_root .. "\n"
+		end
+		if context.cwd then
+			project_info = project_info .. "- Working directory: " .. context.cwd .. "\n"
+		end
+		if context.project_type then
+			project_info = project_info .. "- Project type: " .. context.project_type .. "\n"
+		end
+		if context.project_stats then
+			project_info = project_info
+				.. string.format(
+					"- Stats: %d files, %d functions, %d classes\n",
+					context.project_stats.files or 0,
+					context.project_stats.functions or 0,
+					context.project_stats.classes or 0
+				)
+		end
+		if context.file_path then
+			project_info = project_info .. "- Current file: " .. context.file_path .. "\n"
+		end
+
+		system = system .. project_info
+		return system
+	end
+
+	-- For "ask" or "explain" mode, don't add code generation instructions
+	if prompt_type == "ask" or prompt_type == "explain" then
+		-- Just add context about the file if available
+		if context.file_path then
+			system = system .. "\n\nContext: The user is working with " .. context.file_path
+			if context.language then
+				system = system .. " (" .. context.language .. ")"
+			end
+		end
+		return system
+	end
+
+	-- Add file content with analysis hints (for code generation modes)
 	if context.file_content and context.file_content ~= "" then
 		system = system .. "\n\n===== EXISTING FILE CONTENT (analyze and match this style) =====\n"
 		system = system .. context.file_content
@@ -74,13 +140,34 @@ function M.build_context(target_path, prompt_type)
 	local content = utils.read_file(target_path)
 	local ext = vim.fn.fnamemodify(target_path, ":e")

-	return {
+	local context = {
 		file_content = content,
 		language = lang_map[ext] or ext,
 		extension = ext,
 		prompt_type = prompt_type,
 		file_path = target_path,
 	}
+
+	-- For agent mode, include additional project context
+	if prompt_type == "agent" then
+		local project_root = utils.get_project_root()
+		context.project_root = project_root
+
+		-- Try to get project info from indexer
+		local ok_indexer, indexer = pcall(require, "codetyper.indexer")
+		if ok_indexer then
+			local status = indexer.get_status()
+			if status.indexed then
+				context.project_type = status.project_type
+				context.project_stats = status.stats
+			end
+		end
+
+		-- Include working directory
+		context.cwd = vim.fn.getcwd()
+	end
+
+	return context
 end

 --- Parse LLM response and extract code
--- a/lua/codetyper/core/llm/ollama.lua
+++ b/lua/codetyper/core/llm/ollama.lua
@@ -2,24 +2,36 @@

 local M = {}

-local utils = require("codetyper.utils")
-local llm = require("codetyper.llm")
+local utils = require("codetyper.support.utils")
+local llm = require("codetyper.core.llm")

--- Get Ollama host from config
+--- Get Ollama host from stored credentials or config
 ---@return string Host URL
 local function get_host()
+	-- Priority: stored credentials > config
+	local credentials = require("codetyper.credentials")
+	local stored_host = credentials.get_ollama_host()
+	if stored_host then
+		return stored_host
+	end
+
 	local codetyper = require("codetyper")
 	local config = codetyper.get_config()
-
 	return config.llm.ollama.host
 end

--- Get model from config
+--- Get model from stored credentials or config
 ---@return string Model name
 local function get_model()
+	-- Priority: stored credentials > config
+	local credentials = require("codetyper.credentials")
+	local stored_model = credentials.get_model("ollama")
+	if stored_model then
+		return stored_model
+	end
+
 	local codetyper = require("codetyper")
 	local config = codetyper.get_config()
-
 	return config.llm.ollama.model
 end

@@ -125,7 +137,7 @@ end
 ---@param context table Context information
 ---@param callback fun(response: string|nil, error: string|nil) Callback function
 function M.generate(prompt, context, callback)
-	local logs = require("codetyper.agent.logs")
+	local logs = require("codetyper.adapters.nvim.ui.logs")
 	local model = get_model()

 	-- Log the request
@@ -199,47 +211,41 @@ function M.validate()
 	return true
 end

--- Build system prompt for agent mode with tool instructions
+--- Generate with tool use support for agentic mode (text-based tool calling)
+---@param messages table[] Conversation history
 ---@param context table Context information
---@return string System prompt
-local function build_agent_system_prompt(context)
-	local agent_prompts = require("codetyper.prompts.agent")
-	local tools_module = require("codetyper.agent.tools")
+---@param tool_definitions table Tool definitions
+---@param callback fun(response: table|nil, error: string|nil) Callback with Claude-like response format
+function M.generate_with_tools(messages, context, tool_definitions, callback)
+	local logs = require("codetyper.adapters.nvim.ui.logs")
+	local agent_prompts = require("codetyper.prompts.agents")
+	local tools_module = require("codetyper.core.tools")

-	local system_prompt = agent_prompts.system .. "\n\n"
-	system_prompt = system_prompt .. tools_module.to_prompt_format() .. "\n\n"
-	system_prompt = system_prompt .. agent_prompts.tool_instructions
+	logs.request("ollama", get_model())
+	logs.thinking("Preparing agent request...")

-	-- Add context about current file if available
-	if context.file_path then
-		system_prompt = system_prompt .. "\n\nCurrent working context:\n"
-		system_prompt = system_prompt .. "- File: " .. context.file_path .. "\n"
-		if context.language then
-			system_prompt = system_prompt .. "- Language: " .. context.language .. "\n"
+	-- Build system prompt with tool instructions
+	local system_prompt = llm.build_system_prompt(context)
+	system_prompt = system_prompt .. "\n\n" .. agent_prompts.system
+	system_prompt = system_prompt .. "\n\n" .. agent_prompts.tool_instructions
+
+	-- Add tool descriptions
+	system_prompt = system_prompt .. "\n\n## Available Tools\n"
+	system_prompt = system_prompt .. "Call tools by outputting JSON in this exact format:\n"
+	system_prompt = system_prompt .. '```json\n{"tool": "tool_name", "arguments": {...}}\n```\n\n'
+
+	for _, tool in ipairs(tool_definitions) do
+		local name = tool.name or (tool["function"] and tool["function"].name)
+		local desc = tool.description or (tool["function"] and tool["function"].description)
+		if name then
+			system_prompt = system_prompt .. string.format("### %s\n%s\n\n", name, desc or "")
 		end
 	end

-	-- Add project root info
-	local root = utils.get_project_root()
-	if root then
-		system_prompt = system_prompt .. "- Project root: " .. root .. "\n"
-	end
-
-	return system_prompt
-end
-
--- Build request body for Ollama API with tools (chat format)
---@param messages table[] Conversation messages
---@param context table Context information
---@return table Request body
-local function build_tools_request_body(messages, context)
-	local system_prompt = build_agent_system_prompt(context)
-
 	-- Convert messages to Ollama chat format
 	local ollama_messages = {}
 	for _, msg in ipairs(messages) do
 		local content = msg.content
-		-- Handle complex content (like tool results)
 		if type(content) == "table" then
 			local text_parts = {}
 			for _, part in ipairs(content) do
@@ -251,14 +257,10 @@ local function build_tools_request_body(messages, context)
 			end
 			content = table.concat(text_parts, "\n")
 		end
-
-		table.insert(ollama_messages, {
-			role = msg.role,
-			content = content,
-		})
+		table.insert(ollama_messages, { role = msg.role, content = content })
 	end

-	return {
+	local body = {
 		model = get_model(),
 		messages = ollama_messages,
 		system = system_prompt,
@@ -268,16 +270,15 @@ local function build_tools_request_body(messages, context)
 			num_predict = 4096,
 		},
 	}
-end

--- Make HTTP request to Ollama chat API
---@param body table Request body
---@param callback fun(response: string|nil, error: string|nil, usage: table|nil) Callback function
-local function make_chat_request(body, callback)
 	local host = get_host()
 	local url = host .. "/api/chat"
 	local json_body = vim.json.encode(body)

+	local prompt_estimate = logs.estimate_tokens(json_body)
+	logs.debug(string.format("Estimated prompt: ~%d tokens", prompt_estimate))
+	logs.thinking("Sending to Ollama API...")
+
 	local cmd = {
 		"curl",
 		"-s",
@@ -302,196 +303,82 @@ local function make_chat_request(body, callback)

 			if not ok then
 				vim.schedule(function()
-					callback(nil, "Failed to parse Ollama response", nil)
+					logs.error("Failed to parse Ollama response")
+					callback(nil, "Failed to parse Ollama response")
 				end)
 				return
 			end

 			if response.error then
 				vim.schedule(function()
-					callback(nil, response.error or "Ollama API error", nil)
+					logs.error(response.error or "Ollama API error")
+					callback(nil, response.error or "Ollama API error")
 				end)
 				return
 			end

-			-- Extract usage info
-			local usage = {
-				prompt_tokens = response.prompt_eval_count or 0,
-				response_tokens = response.eval_count or 0,
-			}
+			-- Log token usage and record cost (Ollama is free but we track usage)
+			if response.prompt_eval_count or response.eval_count then
+				logs.response(response.prompt_eval_count or 0, response.eval_count or 0, "stop")

-			-- Return the message content for agent parsing
-			if response.message and response.message.content then
-				vim.schedule(function()
-					callback(response.message.content, nil, usage)
-				end)
-			else
-				vim.schedule(function()
-					callback(nil, "No response from Ollama", nil)
-				end)
+				-- Record usage for cost tracking (free for local models)
+				local cost = require("codetyper.core.cost")
+				cost.record_usage(
+					get_model(),
+					response.prompt_eval_count or 0,
+					response.eval_count or 0,
+					0 -- No cached tokens for Ollama
+				)
 			end
+
+			-- Parse the response text for tool calls
+			local content_text = response.message and response.message.content or ""
+			local converted = { content = {}, stop_reason = "end_turn" }
+
+			-- Try to extract JSON tool calls from response
+			local json_match = content_text:match("```json%s*(%b{})%s*```")
+			if json_match then
+				local ok_json, parsed = pcall(vim.json.decode, json_match)
+				if ok_json and parsed.tool then
+					table.insert(converted.content, {
+						type = "tool_use",
+						id = "call_" .. string.format("%x", os.time()) .. "_" .. string.format("%x", math.random(0, 0xFFFF)),
+						name = parsed.tool,
+						input = parsed.arguments or {},
+					})
+					logs.thinking("Tool call: " .. parsed.tool)
+					content_text = content_text:gsub("```json.-```", ""):gsub("^%s+", ""):gsub("%s+$", "")
+					converted.stop_reason = "tool_use"
+				end
+			end
+
+			-- Add text content
+			if content_text and content_text ~= "" then
+				table.insert(converted.content, 1, { type = "text", text = content_text })
+				logs.thinking("Response contains text")
+			end
+
+			vim.schedule(function()
+				callback(converted, nil)
+			end)
 		end,
 		on_stderr = function(_, data)
 			if data and #data > 0 and data[1] ~= "" then
 				vim.schedule(function()
-					callback(nil, "Ollama API request failed: " .. table.concat(data, "\n"), nil)
+					logs.error("Ollama API request failed: " .. table.concat(data, "\n"))
+					callback(nil, "Ollama API request failed: " .. table.concat(data, "\n"))
 				end)
 			end
 		end,
 		on_exit = function(_, code)
 			if code ~= 0 then
-				-- Don't double-report errors
+				vim.schedule(function()
+					logs.error("Ollama API request failed with code: " .. code)
+					callback(nil, "Ollama API request failed with code: " .. code)
+				end)
 			end
 		end,
 	})
 end

--- Generate response with tools using Ollama API
---@param messages table[] Conversation history
---@param context table Context information
---@param tools table Tool definitions (embedded in prompt for Ollama)
---@param callback fun(response: string|nil, error: string|nil) Callback function
-function M.generate_with_tools(messages, context, tools, callback)
-	local logs = require("codetyper.agent.logs")
-
-	-- Log the request
-	local model = get_model()
-	logs.request("ollama", model)
-	logs.thinking("Preparing API request...")
-
-	local body = build_tools_request_body(messages, context)
-
-	-- Estimate prompt tokens
-	local prompt_estimate = logs.estimate_tokens(vim.json.encode(body))
-	logs.debug(string.format("Estimated prompt: ~%d tokens", prompt_estimate))
-
-	make_chat_request(body, function(response, err, usage)
-		if err then
-			logs.error(err)
-			callback(nil, err)
-		else
-			-- Log token usage
-			if usage then
-				logs.response(usage.prompt_tokens or 0, usage.response_tokens or 0, "end_turn")
-			end
-
-			-- Log if response contains tool calls
-			if response then
-				local parser = require("codetyper.agent.parser")
-				local parsed = parser.parse_ollama_response(response)
-				if #parsed.tool_calls > 0 then
-					for _, tc in ipairs(parsed.tool_calls) do
-						logs.thinking("Tool call: " .. tc.name)
-					end
-				end
-				if parsed.text and parsed.text ~= "" then
-					logs.thinking("Response contains text")
-				end
-			end
-
-			callback(response, nil)
-		end
-	end)
-end
-
--- Generate with tool use support for agentic mode (simulated via prompts)
---@param messages table[] Conversation history
---@param context table Context information
---@param tool_definitions table Tool definitions
---@param callback fun(response: string|nil, error: string|nil) Callback with response text
-function M.generate_with_tools(messages, context, tool_definitions, callback)
-  local tools_module = require("codetyper.agent.tools")
-  local agent_prompts = require("codetyper.prompts.agent")
-
-  -- Build system prompt with agent instructions and tool definitions
-  local system_prompt = llm.build_system_prompt(context)
-  system_prompt = system_prompt .. "\n\n" .. agent_prompts.system
-  system_prompt = system_prompt .. "\n\n" .. tools_module.to_prompt_format()
-
-  -- Flatten messages to single prompt (Ollama's generate API)
-  local prompt_parts = {}
-  for _, msg in ipairs(messages) do
-    if type(msg.content) == "string" then
-      local role_prefix = msg.role == "user" and "User" or "Assistant"
-      table.insert(prompt_parts, role_prefix .. ": " .. msg.content)
-    elseif type(msg.content) == "table" then
-      -- Handle tool results
-      for _, item in ipairs(msg.content) do
-        if item.type == "tool_result" then
-          table.insert(prompt_parts, "Tool result: " .. item.content)
-        end
-      end
-    end
-  end
-
-  local body = {
-    model = get_model(),
-    system = system_prompt,
-    prompt = table.concat(prompt_parts, "\n\n"),
-    stream = false,
-    options = {
-      temperature = 0.2,
-      num_predict = 4096,
-    },
-  }
-
-  local host = get_host()
-  local url = host .. "/api/generate"
-  local json_body = vim.json.encode(body)
-
-  local cmd = {
-    "curl",
-    "-s",
-    "-X", "POST",
-    url,
-    "-H", "Content-Type: application/json",
-    "-d", json_body,
-  }
-
-  vim.fn.jobstart(cmd, {
-    stdout_buffered = true,
-    on_stdout = function(_, data)
-      if not data or #data == 0 or (data[1] == "" and #data == 1) then
-        return
-      end
-
-      local response_text = table.concat(data, "\n")
-      local ok, response = pcall(vim.json.decode, response_text)
-
-      if not ok then
-        vim.schedule(function()
-          callback(nil, "Failed to parse Ollama response")
-        end)
-        return
-      end
-
-      if response.error then
-        vim.schedule(function()
-          callback(nil, response.error or "Ollama API error")
-        end)
-        return
-      end
-
-      -- Return raw response text for parser to handle
-      vim.schedule(function()
-        callback(response.response or "", nil)
-      end)
-    end,
-    on_stderr = function(_, data)
-      if data and #data > 0 and data[1] ~= "" then
-        vim.schedule(function()
-          callback(nil, "Ollama API request failed: " .. table.concat(data, "\n"))
-        end)
-      end
-    end,
-    on_exit = function(_, code)
-      if code ~= 0 then
-        vim.schedule(function()
-          callback(nil, "Ollama API request failed with code: " .. code)
-        end)
-      end
-    end,
-  })
-end
-
 return M
--- a/lua/codetyper/core/llm/openai.lua
+++ b/lua/codetyper/core/llm/openai.lua
@@ -2,31 +2,52 @@

 local M = {}

-local utils = require("codetyper.utils")
-local llm = require("codetyper.llm")
+local utils = require("codetyper.support.utils")
+local llm = require("codetyper.core.llm")

 --- OpenAI API endpoint
 local API_URL = "https://api.openai.com/v1/chat/completions"

--- Get API key from config or environment
+--- Get API key from stored credentials, config, or environment
 ---@return string|nil API key
 local function get_api_key()
+	-- Priority: stored credentials > config > environment
+	local credentials = require("codetyper.credentials")
+	local stored_key = credentials.get_api_key("openai")
+	if stored_key then
+		return stored_key
+	end
+
 	local codetyper = require("codetyper")
 	local config = codetyper.get_config()
 	return config.llm.openai.api_key or vim.env.OPENAI_API_KEY
 end

--- Get model from config
+--- Get model from stored credentials or config
 ---@return string Model name
 local function get_model()
+	-- Priority: stored credentials > config
+	local credentials = require("codetyper.credentials")
+	local stored_model = credentials.get_model("openai")
+	if stored_model then
+		return stored_model
+	end
+
 	local codetyper = require("codetyper")
 	local config = codetyper.get_config()
 	return config.llm.openai.model
 end

--- Get endpoint from config (allows custom endpoints like Azure, OpenRouter)
+--- Get endpoint from stored credentials or config (allows custom endpoints like Azure, OpenRouter)
 ---@return string API endpoint
 local function get_endpoint()
+	-- Priority: stored credentials > config > default
+	local credentials = require("codetyper.credentials")
+	local stored_endpoint = credentials.get_endpoint("openai")
+	if stored_endpoint then
+		return stored_endpoint
+	end
+
 	local codetyper = require("codetyper")
 	local config = codetyper.get_config()
 	return config.llm.openai.endpoint or API_URL
@@ -137,7 +158,7 @@ end
 ---@param context table Context information
 ---@param callback fun(response: string|nil, error: string|nil) Callback function
 function M.generate(prompt, context, callback)
-	local logs = require("codetyper.agent.logs")
+	local logs = require("codetyper.adapters.nvim.ui.logs")
 	local model = get_model()

 	-- Log the request
@@ -187,7 +208,7 @@ end
 ---@param tool_definitions table Tool definitions
 ---@param callback fun(response: table|nil, error: string|nil) Callback with raw response
 function M.generate_with_tools(messages, context, tool_definitions, callback)
-	local logs = require("codetyper.agent.logs")
+	local logs = require("codetyper.adapters.nvim.ui.logs")
 	local model = get_model()

 	logs.request("openai", model)
@@ -200,8 +221,8 @@ function M.generate_with_tools(messages, context, tool_definitions, callback)
 		return
 	end

-	local tools_module = require("codetyper.agent.tools")
-	local agent_prompts = require("codetyper.prompts.agent")
+	local tools_module = require("codetyper.core.tools")
+	local agent_prompts = require("codetyper.prompts.agents")

 	-- Build system prompt with agent instructions
 	local system_prompt = llm.build_system_prompt(context)
@@ -284,9 +305,18 @@ function M.generate_with_tools(messages, context, tool_definitions, callback)
 				return
 			end

-			-- Log token usage
+			-- Log token usage and record cost
 			if response.usage then
 				logs.response(response.usage.prompt_tokens or 0, response.usage.completion_tokens or 0, "stop")
+
+				-- Record usage for cost tracking
+				local cost = require("codetyper.core.cost")
+				cost.record_usage(
+					model,
+					response.usage.prompt_tokens or 0,
+					response.usage.completion_tokens or 0,
+					response.usage.prompt_tokens_details and response.usage.prompt_tokens_details.cached_tokens or 0
+				)
 			end

 			-- Convert to Claude-like format for parser compatibility
--- a/lua/codetyper/core/llm/parser.lua
+++ b/lua/codetyper/core/llm/parser.lua
@@ -4,6 +4,9 @@

 local M = {}

+local params = require("codetyper.params.agents.parser")
+
+
 ---@class ParsedResponse
 ---@field text string Text content from the response
 ---@field tool_calls ToolCall[] List of tool calls
@@ -48,11 +51,11 @@ function M.parse_ollama_response(response_text)
  local result = {
    text = response_text,
    tool_calls = {},
-    stop_reason = "end_turn",
+    stop_reason = params.defaults.stop_reason,
  }

  -- Pattern to find JSON tool blocks in fenced code blocks
-  local fenced_pattern = "```json%s*(%b{})%s*```"
+  local fenced_pattern = params.patterns.fenced_json

  -- Find all fenced JSON blocks
  for json_str in response_text:gmatch(fenced_pattern) do
@@ -63,14 +66,14 @@ function M.parse_ollama_response(response_text)
        name = parsed.tool,
        parameters = parsed.parameters,
      })
-      result.stop_reason = "tool_use"
+      result.stop_reason = params.defaults.tool_stop_reason
    end
  end

  -- Also try to find inline JSON (not in code blocks)
  -- Pattern for {"tool": "...", "parameters": {...}}
  if #result.tool_calls == 0 then
-    local inline_pattern = '(%{"tool"%s*:%s*"[^"]+"%s*,%s*"parameters"%s*:%s*%b{}%})'
+    local inline_pattern = params.patterns.inline_json
    for json_str in response_text:gmatch(inline_pattern) do
      local ok, parsed = pcall(vim.json.decode, json_str)
      if ok and parsed.tool and parsed.parameters then
@@ -79,15 +82,15 @@ function M.parse_ollama_response(response_text)
          name = parsed.tool,
          parameters = parsed.parameters,
        })
-        result.stop_reason = "tool_use"
+        result.stop_reason = params.defaults.tool_stop_reason
      end
    end
  end

  -- Clean tool JSON from displayed text
  if #result.tool_calls > 0 then
-    result.text = result.text:gsub("```json%s*%b{}%s*```", "[Tool call]")
-    result.text = result.text:gsub('%{"tool"%s*:%s*"[^"]+"%s*,%s*"parameters"%s*:%s*%b{}%}', "[Tool call]")
+    result.text = result.text:gsub(params.patterns.fenced_json, params.defaults.replacement_text)
+    result.text = result.text:gsub(params.patterns.inline_json, params.defaults.replacement_text)
  end

  return result
--- a/lua/codetyper/core/llm/selector.lua
+++ b/lua/codetyper/core/llm/selector.lua
@@ -0,0 +1,514 @@
+---@mod codetyper.llm.selector Smart LLM selection with memory-based confidence
+---@brief [[
+--- Intelligent LLM provider selection based on brain memories.
+--- Prefers local Ollama when context is rich, falls back to Copilot otherwise.
+--- Implements verification pondering to reinforce Ollama accuracy over time.
+---@brief ]]
+
+local M = {}
+
+---@class SelectionResult
+---@field provider string Selected provider name
+---@field confidence number Confidence score (0-1)
+---@field memory_count number Number of relevant memories found
+---@field reason string Human-readable reason for selection
+
+---@class PonderResult
+---@field ollama_response string Ollama's response
+---@field verifier_response string Verifier's response
+---@field agreement_score number How much they agree (0-1)
+---@field ollama_correct boolean Whether Ollama was deemed correct
+---@field feedback string Feedback for learning
+
+--- Minimum memories required for high confidence
+local MIN_MEMORIES_FOR_LOCAL = 3
+
+--- Minimum memory relevance score for local provider
+local MIN_RELEVANCE_FOR_LOCAL = 0.6
+
+--- Agreement threshold for Ollama verification
+local AGREEMENT_THRESHOLD = 0.7
+
+--- Pondering sample rate (0-1) - how often to verify Ollama
+local PONDER_SAMPLE_RATE = 0.2
+
+--- Provider accuracy tracking (persisted in brain)
+local accuracy_cache = {
+	ollama = { correct = 0, total = 0 },
+	copilot = { correct = 0, total = 0 },
+}
+
+--- Get the brain module safely
+---@return table|nil
+local function get_brain()
+	local ok, brain = pcall(require, "codetyper.brain")
+	if ok and brain.is_initialized and brain.is_initialized() then
+		return brain
+	end
+	return nil
+end
+
+--- Load accuracy stats from brain
+local function load_accuracy_stats()
+	local brain = get_brain()
+	if not brain then
+		return
+	end
+
+	-- Query for accuracy tracking nodes
+	pcall(function()
+		local result = brain.query({
+			query = "provider_accuracy_stats",
+			types = { "metric" },
+			limit = 1,
+		})
+
+		if result and result.nodes and #result.nodes > 0 then
+			local node = result.nodes[1]
+			if node.c and node.c.d then
+				local ok, stats = pcall(vim.json.decode, node.c.d)
+				if ok and stats then
+					accuracy_cache = stats
+				end
+			end
+		end
+	end)
+end
+
+--- Save accuracy stats to brain
+local function save_accuracy_stats()
+	local brain = get_brain()
+	if not brain then
+		return
+	end
+
+	pcall(function()
+		brain.learn({
+			type = "metric",
+			summary = "provider_accuracy_stats",
+			detail = vim.json.encode(accuracy_cache),
+			weight = 1.0,
+		})
+	end)
+end
+
+--- Calculate Ollama confidence based on historical accuracy
+---@return number confidence (0-1)
+local function get_ollama_historical_confidence()
+	local stats = accuracy_cache.ollama
+	if stats.total < 5 then
+		-- Not enough data, return neutral confidence
+		return 0.5
+	end
+
+	local accuracy = stats.correct / stats.total
+	-- Boost confidence if accuracy is high
+	return math.min(1.0, accuracy * 1.2)
+end
+
+--- Query brain for relevant context
+---@param prompt string User prompt
+---@param file_path string|nil Current file path
+---@return table result {memories: table[], relevance: number, count: number}
+local function query_brain_context(prompt, file_path)
+	local result = {
+		memories = {},
+		relevance = 0,
+		count = 0,
+	}
+
+	local brain = get_brain()
+	if not brain then
+		return result
+	end
+
+	-- Query brain with multiple dimensions
+	local ok, query_result = pcall(function()
+		return brain.query({
+			query = prompt,
+			file = file_path,
+			limit = 10,
+			types = { "pattern", "correction", "convention", "fact" },
+		})
+	end)
+
+	if not ok or not query_result then
+		return result
+	end
+
+	result.memories = query_result.nodes or {}
+	result.count = #result.memories
+
+	-- Calculate average relevance
+	if result.count > 0 then
+		local total_relevance = 0
+		for _, node in ipairs(result.memories) do
+			-- Use node weight and success rate as relevance indicators
+			local node_relevance = (node.sc and node.sc.w or 0.5) * (node.sc and node.sc.sr or 0.5)
+			total_relevance = total_relevance + node_relevance
+		end
+		result.relevance = total_relevance / result.count
+	end
+
+	return result
+end
+
+--- Select the best LLM provider based on context
+---@param prompt string User prompt
+---@param context table LLM context
+---@return SelectionResult
+function M.select_provider(prompt, context)
+	-- Load accuracy stats on first call
+	if accuracy_cache.ollama.total == 0 then
+		load_accuracy_stats()
+	end
+
+	local file_path = context.file_path
+
+	-- Query brain for relevant memories
+	local brain_context = query_brain_context(prompt, file_path)
+
+	-- Calculate base confidence from memories
+	local memory_confidence = 0
+	if brain_context.count >= MIN_MEMORIES_FOR_LOCAL then
+		memory_confidence = math.min(1.0, brain_context.count / 10) * brain_context.relevance
+	end
+
+	-- Factor in historical Ollama accuracy
+	local historical_confidence = get_ollama_historical_confidence()
+
+	-- Combined confidence score
+	local combined_confidence = (memory_confidence * 0.6) + (historical_confidence * 0.4)
+
+	-- Decision logic
+	local provider = "copilot" -- Default to more capable
+	local reason = ""
+
+	if brain_context.count >= MIN_MEMORIES_FOR_LOCAL and combined_confidence >= MIN_RELEVANCE_FOR_LOCAL then
+		provider = "ollama"
+		reason = string.format(
+			"Rich context: %d memories (%.1f%% relevance), historical accuracy: %.1f%%",
+			brain_context.count,
+			brain_context.relevance * 100,
+			historical_confidence * 100
+		)
+	elseif brain_context.count > 0 and combined_confidence >= 0.4 then
+		-- Medium confidence - use Ollama but with pondering
+		provider = "ollama"
+		reason = string.format(
+			"Moderate context: %d memories, will verify with pondering",
+			brain_context.count
+		)
+	else
+		reason = string.format(
+			"Insufficient context: %d memories (need %d), using capable provider",
+			brain_context.count,
+			MIN_MEMORIES_FOR_LOCAL
+		)
+	end
+
+	return {
+		provider = provider,
+		confidence = combined_confidence,
+		memory_count = brain_context.count,
+		reason = reason,
+		memories = brain_context.memories,
+	}
+end
+
+--- Check if we should ponder (verify) this Ollama response
+---@param confidence number Current confidence level
+---@return boolean
+function M.should_ponder(confidence)
+	-- Always ponder when confidence is medium
+	if confidence >= 0.4 and confidence < 0.7 then
+		return true
+	end
+
+	-- Random sampling for high confidence to keep learning
+	if confidence >= 0.7 then
+		return math.random() < PONDER_SAMPLE_RATE
+	end
+
+	-- Low confidence shouldn't reach Ollama anyway
+	return false
+end
+
+--- Calculate agreement score between two responses
+---@param response1 string First response
+---@param response2 string Second response
+---@return number Agreement score (0-1)
+local function calculate_agreement(response1, response2)
+	-- Normalize responses
+	local norm1 = response1:lower():gsub("%s+", " "):gsub("[^%w%s]", "")
+	local norm2 = response2:lower():gsub("%s+", " "):gsub("[^%w%s]", "")
+
+	-- Extract words
+	local words1 = {}
+	for word in norm1:gmatch("%w+") do
+		words1[word] = (words1[word] or 0) + 1
+	end
+
+	local words2 = {}
+	for word in norm2:gmatch("%w+") do
+		words2[word] = (words2[word] or 0) + 1
+	end
+
+	-- Calculate Jaccard similarity
+	local intersection = 0
+	local union = 0
+
+	for word, count1 in pairs(words1) do
+		local count2 = words2[word] or 0
+		intersection = intersection + math.min(count1, count2)
+		union = union + math.max(count1, count2)
+	end
+
+	for word, count2 in pairs(words2) do
+		if not words1[word] then
+			union = union + count2
+		end
+	end
+
+	if union == 0 then
+		return 1.0 -- Both empty
+	end
+
+	-- Also check structural similarity (code structure)
+	local struct_score = 0
+	local function_count1 = select(2, response1:gsub("function", ""))
+	local function_count2 = select(2, response2:gsub("function", ""))
+	if function_count1 > 0 or function_count2 > 0 then
+		struct_score = 1 - math.abs(function_count1 - function_count2) / math.max(function_count1, function_count2, 1)
+	else
+		struct_score = 1.0
+	end
+
+	-- Combined score
+	local jaccard = intersection / union
+	return (jaccard * 0.7) + (struct_score * 0.3)
+end
+
+--- Ponder (verify) Ollama's response with another LLM
+---@param prompt string Original prompt
+---@param context table LLM context
+---@param ollama_response string Ollama's response
+---@param callback fun(result: PonderResult) Callback with pondering result
+function M.ponder(prompt, context, ollama_response, callback)
+	-- Use Copilot as verifier
+	local copilot = require("codetyper.core.llm.copilot")
+
+	-- Build verification prompt
+	local verify_prompt = prompt
+
+	copilot.generate(verify_prompt, context, function(verifier_response, error)
+		if error or not verifier_response then
+			-- Verification failed, assume Ollama is correct
+			callback({
+				ollama_response = ollama_response,
+				verifier_response = "",
+				agreement_score = 1.0,
+				ollama_correct = true,
+				feedback = "Verification unavailable, trusting Ollama",
+			})
+			return
+		end
+
+		-- Calculate agreement
+		local agreement = calculate_agreement(ollama_response, verifier_response)
+
+		-- Determine if Ollama was correct
+		local ollama_correct = agreement >= AGREEMENT_THRESHOLD
+
+		-- Generate feedback
+		local feedback
+		if ollama_correct then
+			feedback = string.format("Agreement: %.1f%% - Ollama response validated", agreement * 100)
+		else
+			feedback = string.format(
+				"Disagreement: %.1f%% - Ollama may need correction",
+				(1 - agreement) * 100
+			)
+		end
+
+		-- Update accuracy tracking
+		accuracy_cache.ollama.total = accuracy_cache.ollama.total + 1
+		if ollama_correct then
+			accuracy_cache.ollama.correct = accuracy_cache.ollama.correct + 1
+		end
+		save_accuracy_stats()
+
+		-- Learn from this verification
+		local brain = get_brain()
+		if brain then
+			pcall(function()
+				if ollama_correct then
+					-- Reinforce the pattern
+					brain.learn({
+						type = "correction",
+						summary = "Ollama verified correct",
+						detail = string.format(
+							"Prompt: %s\nAgreement: %.1f%%",
+							prompt:sub(1, 100),
+							agreement * 100
+						),
+						weight = 0.8,
+						file = context.file_path,
+					})
+				else
+					-- Learn the correction
+					brain.learn({
+						type = "correction",
+						summary = "Ollama needed correction",
+						detail = string.format(
+							"Prompt: %s\nOllama: %s\nCorrect: %s",
+							prompt:sub(1, 100),
+							ollama_response:sub(1, 200),
+							verifier_response:sub(1, 200)
+						),
+						weight = 0.9,
+						file = context.file_path,
+					})
+				end
+			end)
+		end
+
+		callback({
+			ollama_response = ollama_response,
+			verifier_response = verifier_response,
+			agreement_score = agreement,
+			ollama_correct = ollama_correct,
+			feedback = feedback,
+		})
+	end)
+end
+
+--- Smart generate with automatic provider selection and pondering
+---@param prompt string User prompt
+---@param context table LLM context
+---@param callback fun(response: string|nil, error: string|nil, metadata: table|nil) Callback
+function M.smart_generate(prompt, context, callback)
+	-- Select provider
+	local selection = M.select_provider(prompt, context)
+
+	-- Log selection
+	pcall(function()
+		local logs = require("codetyper.adapters.nvim.ui.logs")
+		logs.add({
+			type = "info",
+			message = string.format(
+				"LLM: %s (confidence: %.1f%%, %s)",
+				selection.provider,
+				selection.confidence * 100,
+				selection.reason
+			),
+		})
+	end)
+
+	-- Get the selected client
+	local client
+	if selection.provider == "ollama" then
+		client = require("codetyper.core.llm.ollama")
+	else
+		client = require("codetyper.core.llm.copilot")
+	end
+
+	-- Generate response
+	client.generate(prompt, context, function(response, error)
+		if error then
+			-- Fallback on error
+			if selection.provider == "ollama" then
+				-- Try Copilot as fallback
+				local copilot = require("codetyper.core.llm.copilot")
+				copilot.generate(prompt, context, function(fallback_response, fallback_error)
+					callback(fallback_response, fallback_error, {
+						provider = "copilot",
+						fallback = true,
+						original_provider = "ollama",
+						original_error = error,
+					})
+				end)
+				return
+			end
+			callback(nil, error, { provider = selection.provider })
+			return
+		end
+
+		-- Check if we should ponder
+		if selection.provider == "ollama" and M.should_ponder(selection.confidence) then
+			M.ponder(prompt, context, response, function(ponder_result)
+				if ponder_result.ollama_correct then
+					-- Ollama was correct, use its response
+					callback(response, nil, {
+						provider = "ollama",
+						pondered = true,
+						agreement = ponder_result.agreement_score,
+						confidence = selection.confidence,
+					})
+				else
+					-- Use verifier's response instead
+					callback(ponder_result.verifier_response, nil, {
+						provider = "copilot",
+						pondered = true,
+						agreement = ponder_result.agreement_score,
+						original_provider = "ollama",
+						corrected = true,
+					})
+				end
+			end)
+		else
+			-- No pondering needed
+			callback(response, nil, {
+				provider = selection.provider,
+				pondered = false,
+				confidence = selection.confidence,
+			})
+		end
+	end)
+end
+
+--- Get current accuracy statistics
+---@return table {ollama: {correct, total, accuracy}, copilot: {correct, total, accuracy}}
+function M.get_accuracy_stats()
+	local stats = {
+		ollama = {
+			correct = accuracy_cache.ollama.correct,
+			total = accuracy_cache.ollama.total,
+			accuracy = accuracy_cache.ollama.total > 0
+				and (accuracy_cache.ollama.correct / accuracy_cache.ollama.total)
+				or 0,
+		},
+		copilot = {
+			correct = accuracy_cache.copilot.correct,
+			total = accuracy_cache.copilot.total,
+			accuracy = accuracy_cache.copilot.total > 0
+				and (accuracy_cache.copilot.correct / accuracy_cache.copilot.total)
+				or 0,
+		},
+	}
+	return stats
+end
+
+--- Reset accuracy statistics
+function M.reset_accuracy_stats()
+	accuracy_cache = {
+		ollama = { correct = 0, total = 0 },
+		copilot = { correct = 0, total = 0 },
+	}
+	save_accuracy_stats()
+end
+
+--- Report user feedback on response quality
+---@param provider string Which provider generated the response
+---@param was_correct boolean Whether the response was good
+function M.report_feedback(provider, was_correct)
+	if accuracy_cache[provider] then
+		accuracy_cache[provider].total = accuracy_cache[provider].total + 1
+		if was_correct then
+			accuracy_cache[provider].correct = accuracy_cache[provider].correct + 1
+		end
+		save_accuracy_stats()
+	end
+end
+
+return M
--- a/lua/codetyper/core/memory/delta/commit.lua
+++ b/lua/codetyper/core/memory/delta/commit.lua
@@ -0,0 +1,291 @@
+--- Brain Delta Commit Operations
+--- Git-like commit creation and management
+
+local storage = require("codetyper.core.memory.storage")
+local hash_mod = require("codetyper.core.memory.hash")
+local diff_mod = require("codetyper.core.memory.delta.diff")
+local types = require("codetyper.core.memory.types")
+
+local M = {}
+
+--- Create a new delta commit
+---@param changes table[] Changes to commit
+---@param message string Commit message
+---@param trigger? string Trigger source
+---@return Delta|nil Created delta
+function M.create(changes, message, trigger)
+  if not changes or #changes == 0 then
+    return nil
+  end
+
+  local now = os.time()
+  local head = storage.get_head()
+
+  -- Create delta object
+  local delta = {
+    h = hash_mod.delta_hash(changes, head, now),
+    p = head,
+    ts = now,
+    ch = {},
+    m = {
+      msg = message or "Unnamed commit",
+      trig = trigger or "manual",
+    },
+  }
+
+  -- Process changes
+  for _, change in ipairs(changes) do
+    table.insert(delta.ch, {
+      op = change.op,
+      path = change.path,
+      bh = change.bh,
+      ah = change.ah,
+      diff = change.diff,
+    })
+  end
+
+  -- Save delta
+  storage.save_delta(delta)
+
+  -- Update HEAD
+  storage.set_head(delta.h)
+
+  -- Update meta
+  local meta = storage.get_meta()
+  storage.update_meta({ dc = meta.dc + 1 })
+
+  return delta
+end
+
+--- Get a delta by hash
+---@param delta_hash string Delta hash
+---@return Delta|nil
+function M.get(delta_hash)
+  return storage.get_delta(delta_hash)
+end
+
+--- Get the current HEAD delta
+---@return Delta|nil
+function M.get_head()
+  local head_hash = storage.get_head()
+  if not head_hash then
+    return nil
+  end
+  return M.get(head_hash)
+end
+
+--- Get delta history (ancestry chain)
+---@param limit? number Max entries
+---@param from_hash? string Starting hash (default: HEAD)
+---@return Delta[]
+function M.get_history(limit, from_hash)
+  limit = limit or 50
+  local history = {}
+  local current_hash = from_hash or storage.get_head()
+
+  while current_hash and #history < limit do
+    local delta = M.get(current_hash)
+    if not delta then
+      break
+    end
+
+    table.insert(history, delta)
+    current_hash = delta.p
+  end
+
+  return history
+end
+
+--- Check if a delta exists
+---@param delta_hash string Delta hash
+---@return boolean
+function M.exists(delta_hash)
+  return M.get(delta_hash) ~= nil
+end
+
+--- Get the path from one delta to another
+---@param from_hash string Start delta hash
+---@param to_hash string End delta hash
+---@return Delta[]|nil Path of deltas, or nil if no path
+function M.get_path(from_hash, to_hash)
+  -- Build ancestry from both sides
+  local from_ancestry = {}
+  local current = from_hash
+  while current do
+    from_ancestry[current] = true
+    local delta = M.get(current)
+    if not delta then
+      break
+    end
+    current = delta.p
+  end
+
+  -- Walk from to_hash back to find common ancestor
+  local path = {}
+  current = to_hash
+  while current do
+    local delta = M.get(current)
+    if not delta then
+      break
+    end
+
+    table.insert(path, 1, delta)
+
+    if from_ancestry[current] then
+      -- Found common ancestor
+      return path
+    end
+
+    current = delta.p
+  end
+
+  return nil
+end
+
+--- Get all changes between two deltas
+---@param from_hash string|nil Start delta hash (nil = beginning)
+---@param to_hash string End delta hash
+---@return table[] Combined changes
+function M.get_changes_between(from_hash, to_hash)
+  local path = {}
+  local current = to_hash
+
+  while current and current ~= from_hash do
+    local delta = M.get(current)
+    if not delta then
+      break
+    end
+    table.insert(path, 1, delta)
+    current = delta.p
+  end
+
+  -- Collect all changes
+  local changes = {}
+  for _, delta in ipairs(path) do
+    for _, change in ipairs(delta.ch) do
+      table.insert(changes, change)
+    end
+  end
+
+  return changes
+end
+
+--- Compute reverse changes for rollback
+---@param delta Delta Delta to reverse
+---@return table[] Reverse changes
+function M.compute_reverse(delta)
+  local reversed = {}
+
+  for i = #delta.ch, 1, -1 do
+    local change = delta.ch[i]
+    local rev = {
+      path = change.path,
+    }
+
+    if change.op == types.DELTA_OPS.ADD then
+      rev.op = types.DELTA_OPS.DELETE
+      rev.bh = change.ah
+    elseif change.op == types.DELTA_OPS.DELETE then
+      rev.op = types.DELTA_OPS.ADD
+      rev.ah = change.bh
+    elseif change.op == types.DELTA_OPS.MODIFY then
+      rev.op = types.DELTA_OPS.MODIFY
+      rev.bh = change.ah
+      rev.ah = change.bh
+      if change.diff then
+        rev.diff = diff_mod.reverse(change.diff)
+      end
+    end
+
+    table.insert(reversed, rev)
+  end
+
+  return reversed
+end
+
+--- Squash multiple deltas into one
+---@param delta_hashes string[] Delta hashes to squash
+---@param message string Squash commit message
+---@return Delta|nil Squashed delta
+function M.squash(delta_hashes, message)
+  if #delta_hashes == 0 then
+    return nil
+  end
+
+  -- Collect all changes in order
+  local all_changes = {}
+  for _, delta_hash in ipairs(delta_hashes) do
+    local delta = M.get(delta_hash)
+    if delta then
+      for _, change in ipairs(delta.ch) do
+        table.insert(all_changes, change)
+      end
+    end
+  end
+
+  -- Compact the changes
+  local compacted = diff_mod.compact(all_changes)
+
+  return M.create(compacted, message, "squash")
+end
+
+--- Get summary of a delta
+---@param delta Delta Delta to summarize
+---@return table Summary
+function M.summarize(delta)
+  local adds = 0
+  local mods = 0
+  local dels = 0
+  local paths = {}
+
+  for _, change in ipairs(delta.ch) do
+    if change.op == types.DELTA_OPS.ADD then
+      adds = adds + 1
+    elseif change.op == types.DELTA_OPS.MODIFY then
+      mods = mods + 1
+    elseif change.op == types.DELTA_OPS.DELETE then
+      dels = dels + 1
+    end
+
+    -- Extract category from path
+    local parts = vim.split(change.path, ".", { plain = true })
+    if parts[1] then
+      paths[parts[1]] = true
+    end
+  end
+
+  return {
+    hash = delta.h,
+    parent = delta.p,
+    timestamp = delta.ts,
+    message = delta.m.msg,
+    trigger = delta.m.trig,
+    stats = {
+      adds = adds,
+      modifies = mods,
+      deletes = dels,
+      total = adds + mods + dels,
+    },
+    categories = vim.tbl_keys(paths),
+  }
+end
+
+--- Format delta for display
+---@param delta Delta Delta to format
+---@return string[] Lines
+function M.format(delta)
+  local summary = M.summarize(delta)
+  local lines = {
+    string.format("commit %s", delta.h),
+    string.format("Date:   %s", os.date("%Y-%m-%d %H:%M:%S", delta.ts)),
+    string.format("Parent: %s", delta.p or "(none)"),
+    "",
+    "    " .. (delta.m.msg or "No message"),
+    "",
+    string.format(" %d additions, %d modifications, %d deletions", summary.stats.adds, summary.stats.modifies, summary.stats.deletes),
+  }
+
+  return lines
+end
+
+return M
--- a/lua/codetyper/core/memory/delta/diff.lua
+++ b/lua/codetyper/core/memory/delta/diff.lua
@@ -0,0 +1,261 @@
+--- Brain Delta Diff Computation
+--- Field-level diff algorithms for delta versioning
+
+local hash = require("codetyper.core.memory.hash")
+
+local M = {}
+
+--- Compute diff between two values
+---@param before any Before value
+---@param after any After value
+---@param path? string Current path
+---@return table[] Diff entries
+function M.compute(before, after, path)
+  path = path or ""
+  local diffs = {}
+
+  local before_type = type(before)
+  local after_type = type(after)
+
+  -- Handle nil cases
+  if before == nil and after == nil then
+    return diffs
+  end
+
+  if before == nil then
+    table.insert(diffs, {
+      path = path,
+      op = "add",
+      value = after,
+    })
+    return diffs
+  end
+
+  if after == nil then
+    table.insert(diffs, {
+      path = path,
+      op = "delete",
+      value = before,
+    })
+    return diffs
+  end
+
+  -- Type change
+  if before_type ~= after_type then
+    table.insert(diffs, {
+      path = path,
+      op = "replace",
+      from = before,
+      to = after,
+    })
+    return diffs
+  end
+
+  -- Tables (recursive)
+  if before_type == "table" then
+    -- Get all keys
+    local keys = {}
+    for k in pairs(before) do
+      keys[k] = true
+    end
+    for k in pairs(after) do
+      keys[k] = true
+    end
+
+    for k in pairs(keys) do
+      local sub_path = path == "" and tostring(k) or (path .. "." .. tostring(k))
+      local sub_diffs = M.compute(before[k], after[k], sub_path)
+      for _, d in ipairs(sub_diffs) do
+        table.insert(diffs, d)
+      end
+    end
+
+    return diffs
+  end
+
+  -- Primitive comparison
+  if before ~= after then
+    table.insert(diffs, {
+      path = path,
+      op = "replace",
+      from = before,
+      to = after,
+    })
+  end
+
+  return diffs
+end
+
+--- Apply a diff to a value
+---@param base any Base value
+---@param diffs table[] Diff entries
+---@return any Result value
+function M.apply(base, diffs)
+  local result = vim.deepcopy(base) or {}
+
+  for _, diff in ipairs(diffs) do
+    M.apply_single(result, diff)
+  end
+
+  return result
+end
+
+--- Apply a single diff entry
+---@param target table Target table
+---@param diff table Diff entry
+function M.apply_single(target, diff)
+  local path = diff.path
+  local parts = vim.split(path, ".", { plain = true })
+
+  if #parts == 0 or parts[1] == "" then
+    -- Root-level change
+    if diff.op == "add" or diff.op == "replace" then
+      for k, v in pairs(diff.value or diff.to or {}) do
+        target[k] = v
+      end
+    end
+    return
+  end
+
+  -- Navigate to parent
+  local current = target
+  for i = 1, #parts - 1 do
+    local key = parts[i]
+    -- Try numeric key
+    local num_key = tonumber(key)
+    key = num_key or key
+
+    if current[key] == nil then
+      current[key] = {}
+    end
+    current = current[key]
+  end
+
+  -- Apply to final key
+  local final_key = parts[#parts]
+  local num_key = tonumber(final_key)
+  final_key = num_key or final_key
+
+  if diff.op == "add" then
+    current[final_key] = diff.value
+  elseif diff.op == "delete" then
+    current[final_key] = nil
+  elseif diff.op == "replace" then
+    current[final_key] = diff.to
+  end
+end
+
+--- Reverse a diff (for rollback)
+---@param diffs table[] Diff entries
+---@return table[] Reversed diffs
+function M.reverse(diffs)
+  local reversed = {}
+
+  for i = #diffs, 1, -1 do
+    local diff = diffs[i]
+    local rev = {
+      path = diff.path,
+    }
+
+    if diff.op == "add" then
+      rev.op = "delete"
+      rev.value = diff.value
+    elseif diff.op == "delete" then
+      rev.op = "add"
+      rev.value = diff.value
+    elseif diff.op == "replace" then
+      rev.op = "replace"
+      rev.from = diff.to
+      rev.to = diff.from
+    end
+
+    table.insert(reversed, rev)
+  end
+
+  return reversed
+end
+
+--- Compact diffs (combine related changes)
+---@param diffs table[] Diff entries
+---@return table[] Compacted diffs
+function M.compact(diffs)
+  local by_path = {}
+
+  for _, diff in ipairs(diffs) do
+    local existing = by_path[diff.path]
+    if existing then
+      -- Combine: keep first "from", use last "to"
+      if diff.op == "replace" then
+        existing.to = diff.to
+      elseif diff.op == "delete" then
+        existing.op = "delete"
+        existing.to = nil
+      end
+    else
+      by_path[diff.path] = vim.deepcopy(diff)
+    end
+  end
+
+  -- Convert back to array, filter out no-ops
+  local result = {}
+  for _, diff in pairs(by_path) do
+    -- Skip if add then delete (net no change)
+    if not (diff.op == "delete" and diff.from == nil) then
+      table.insert(result, diff)
+    end
+  end
+
+  return result
+end
+
+--- Create a minimal diff summary for storage
+---@param diffs table[] Diff entries
+---@return table Summary
+function M.summarize(diffs)
+  local adds = 0
+  local deletes = 0
+  local replaces = 0
+  local paths = {}
+
+  for _, diff in ipairs(diffs) do
+    if diff.op == "add" then
+      adds = adds + 1
+    elseif diff.op == "delete" then
+      deletes = deletes + 1
+    elseif diff.op == "replace" then
+      replaces = replaces + 1
+    end
+
+    -- Extract top-level path
+    local parts = vim.split(diff.path, ".", { plain = true })
+    if parts[1] then
+      paths[parts[1]] = true
+    end
+  end
+
+  return {
+    adds = adds,
+    deletes = deletes,
+    replaces = replaces,
+    paths = vim.tbl_keys(paths),
+    total = adds + deletes + replaces,
+  }
+end
+
+--- Check if two states are equal (no diff)
+---@param state1 any First state
+---@param state2 any Second state
+---@return boolean
+function M.equals(state1, state2)
+  local diffs = M.compute(state1, state2)
+  return #diffs == 0
+end
+
+--- Get hash of diff for deduplication
+---@param diffs table[] Diff entries
+---@return string Hash
+function M.hash(diffs)
+  return hash.compute_table(diffs)
+end
+
+return M
--- a/lua/codetyper/core/memory/delta/init.lua
+++ b/lua/codetyper/core/memory/delta/init.lua
@@ -0,0 +1,278 @@
+--- Brain Delta Coordinator
+--- Git-like versioning system for brain state
+
+local storage = require("codetyper.core.memory.storage")
+local commit_mod = require("codetyper.core.memory.delta.commit")
+local diff_mod = require("codetyper.core.memory.delta.diff")
+local types = require("codetyper.core.memory.types")
+
+local M = {}
+
+-- Re-export submodules
+M.commit = commit_mod
+M.diff = diff_mod
+
+--- Create a commit from pending graph changes
+---@param message string Commit message
+---@param trigger? string Trigger source
+---@return string|nil Delta hash
+function M.commit(message, trigger)
+  local graph = require("codetyper.core.memory.graph")
+  local changes = graph.get_pending_changes()
+
+  if #changes == 0 then
+    return nil
+  end
+
+  local delta = commit_mod.create(changes, message, trigger or "auto")
+  if delta then
+    return delta.h
+  end
+
+  return nil
+end
+
+--- Rollback to a specific delta
+---@param target_hash string Target delta hash
+---@return boolean Success
+function M.rollback(target_hash)
+  local current_hash = storage.get_head()
+  if not current_hash then
+    return false
+  end
+
+  if current_hash == target_hash then
+    return true -- Already at target
+  end
+
+  -- Get path from target to current
+  local deltas_to_reverse = {}
+  local current = current_hash
+
+  while current and current ~= target_hash do
+    local delta = commit_mod.get(current)
+    if not delta then
+      return false -- Broken chain
+    end
+    table.insert(deltas_to_reverse, delta)
+    current = delta.p
+  end
+
+  if current ~= target_hash then
+    return false -- Target not in ancestry
+  end
+
+  -- Apply reverse changes
+  for _, delta in ipairs(deltas_to_reverse) do
+    local reverse_changes = commit_mod.compute_reverse(delta)
+    M.apply_changes(reverse_changes)
+  end
+
+  -- Update HEAD
+  storage.set_head(target_hash)
+
+  -- Create a rollback commit
+  commit_mod.create({
+    {
+      op = types.DELTA_OPS.MODIFY,
+      path = "meta.head",
+      bh = current_hash,
+      ah = target_hash,
+    },
+  }, "Rollback to " .. target_hash:sub(1, 8), "rollback")
+
+  return true
+end
+
+--- Apply changes to current state
+---@param changes table[] Changes to apply
+function M.apply_changes(changes)
+  local node_mod = require("codetyper.core.memory.graph.node")
+
+  for _, change in ipairs(changes) do
+    local parts = vim.split(change.path, ".", { plain = true })
+
+    if parts[1] == "nodes" and #parts >= 3 then
+      local node_type = parts[2]
+      local node_id = parts[3]
+
+      if change.op == types.DELTA_OPS.ADD then
+        -- Node was added, need to delete for reverse
+        node_mod.delete(node_id)
+      elseif change.op == types.DELTA_OPS.DELETE then
+        -- Node was deleted, would need original data to restore
+        -- This is a limitation - we'd need content storage
+      elseif change.op == types.DELTA_OPS.MODIFY then
+        -- Apply diff if available
+        if change.diff then
+          local node = node_mod.get(node_id)
+          if node then
+            local updated = diff_mod.apply(node, change.diff)
+            -- Direct update without tracking
+            local nodes = storage.get_nodes(node_type)
+            nodes[node_id] = updated
+            storage.save_nodes(node_type, nodes)
+          end
+        end
+      end
+    elseif parts[1] == "graph" then
+      -- Handle graph/edge changes
+      local edge_mod = require("codetyper.core.memory.graph.edge")
+      if parts[2] == "edges" and #parts >= 3 then
+        local edge_id = parts[3]
+        if change.op == types.DELTA_OPS.ADD then
+          -- Edge was added, delete for reverse
+          -- Parse edge_id to get source/target
+          local graph = storage.get_graph()
+          if graph.edges and graph.edges[edge_id] then
+            local edge = graph.edges[edge_id]
+            edge_mod.delete(edge.s, edge.t, edge.ty)
+          end
+        end
+      end
+    end
+  end
+end
+
+--- Get delta history
+---@param limit? number Max entries
+---@return Delta[]
+function M.get_history(limit)
+  return commit_mod.get_history(limit)
+end
+
+--- Get formatted log
+---@param limit? number Max entries
+---@return string[] Log lines
+function M.log(limit)
+  local history = M.get_history(limit or 20)
+  local lines = {}
+
+  for _, delta in ipairs(history) do
+    local formatted = commit_mod.format(delta)
+    for _, line in ipairs(formatted) do
+      table.insert(lines, line)
+    end
+    table.insert(lines, "")
+  end
+
+  return lines
+end
+
+--- Get current HEAD hash
+---@return string|nil
+function M.head()
+  return storage.get_head()
+end
+
+--- Check if there are uncommitted changes
+---@return boolean
+function M.has_pending()
+  local graph = require("codetyper.core.memory.graph")
+  local node_pending = require("codetyper.core.memory.graph.node").pending
+  local edge_pending = require("codetyper.core.memory.graph.edge").pending
+  return #node_pending > 0 or #edge_pending > 0
+end
+
+--- Get status (like git status)
+---@return table Status info
+function M.status()
+  local node_pending = require("codetyper.core.memory.graph.node").pending
+  local edge_pending = require("codetyper.core.memory.graph.edge").pending
+
+  local adds = 0
+  local mods = 0
+  local dels = 0
+
+  for _, change in ipairs(node_pending) do
+    if change.op == types.DELTA_OPS.ADD then
+      adds = adds + 1
+    elseif change.op == types.DELTA_OPS.MODIFY then
+      mods = mods + 1
+    elseif change.op == types.DELTA_OPS.DELETE then
+      dels = dels + 1
+    end
+  end
+
+  for _, change in ipairs(edge_pending) do
+    if change.op == types.DELTA_OPS.ADD then
+      adds = adds + 1
+    elseif change.op == types.DELTA_OPS.DELETE then
+      dels = dels + 1
+    end
+  end
+
+  return {
+    head = storage.get_head(),
+    pending = {
+      adds = adds,
+      modifies = mods,
+      deletes = dels,
+      total = adds + mods + dels,
+    },
+    clean = (adds + mods + dels) == 0,
+  }
+end
+
+--- Prune old deltas
+---@param keep number Number of recent deltas to keep
+---@return number Number of pruned deltas
+function M.prune_history(keep)
+  keep = keep or 100
+  local history = M.get_history(1000) -- Get all
+
+  if #history <= keep then
+    return 0
+  end
+
+  local pruned = 0
+  local brain_dir = storage.get_brain_dir()
+
+  for i = keep + 1, #history do
+    local delta = history[i]
+    local filepath = brain_dir .. "/deltas/objects/" .. delta.h .. ".json"
+    if os.remove(filepath) then
+      pruned = pruned + 1
+    end
+  end
+
+  -- Update meta
+  local meta = storage.get_meta()
+  storage.update_meta({ dc = math.max(0, meta.dc - pruned) })
+
+  return pruned
+end
+
+--- Reset to initial state (dangerous!)
+---@return boolean Success
+function M.reset()
+  -- Clear all nodes
+  for _, node_type in pairs(types.NODE_TYPES) do
+    storage.save_nodes(node_type .. "s", {})
+  end
+
+  -- Clear graph
+  storage.save_graph({ adj = {}, radj = {}, edges = {} })
+
+  -- Clear indices
+  storage.save_index("by_file", {})
+  storage.save_index("by_time", {})
+  storage.save_index("by_symbol", {})
+
+  -- Reset meta
+  storage.update_meta({
+    head = nil,
+    nc = 0,
+    ec = 0,
+    dc = 0,
+  })
+
+  -- Clear pending
+  require("codetyper.core.memory.graph.node").pending = {}
+  require("codetyper.core.memory.graph.edge").pending = {}
+
+  storage.flush_all()
+  return true
+end
+
+return M
--- a/lua/codetyper/core/memory/graph/edge.lua
+++ b/lua/codetyper/core/memory/graph/edge.lua
@@ -0,0 +1,367 @@
+--- Brain Graph Edge Operations
+--- CRUD operations for node connections
+
+local storage = require("codetyper.core.memory.storage")
+local hash = require("codetyper.core.memory.hash")
+local types = require("codetyper.core.memory.types")
+
+local M = {}
+
+--- Pending changes for delta tracking
+---@type table[]
+M.pending = {}
+
+--- Create a new edge between nodes
+---@param source_id string Source node ID
+---@param target_id string Target node ID
+---@param edge_type EdgeType Edge type
+---@param props? EdgeProps Edge properties
+---@return Edge|nil Created edge
+function M.create(source_id, target_id, edge_type, props)
+  props = props or {}
+
+  local edge = {
+    id = hash.edge_id(source_id, target_id),
+    s = source_id,
+    t = target_id,
+    ty = edge_type,
+    p = {
+      w = props.w or 0.5,
+      dir = props.dir or "bi",
+      r = props.r,
+    },
+    ts = os.time(),
+  }
+
+  -- Update adjacency lists
+  local graph = storage.get_graph()
+
+  -- Forward adjacency
+  graph.adj[source_id] = graph.adj[source_id] or {}
+  graph.adj[source_id][edge_type] = graph.adj[source_id][edge_type] or {}
+
+  -- Check for duplicate
+  if vim.tbl_contains(graph.adj[source_id][edge_type], target_id) then
+    -- Edge exists, strengthen it instead
+    return M.strengthen(source_id, target_id, edge_type)
+  end
+
+  table.insert(graph.adj[source_id][edge_type], target_id)
+
+  -- Reverse adjacency
+  graph.radj[target_id] = graph.radj[target_id] or {}
+  graph.radj[target_id][edge_type] = graph.radj[target_id][edge_type] or {}
+  table.insert(graph.radj[target_id][edge_type], source_id)
+
+  -- Store edge properties separately (for weight/metadata)
+  graph.edges = graph.edges or {}
+  graph.edges[edge.id] = edge
+
+  storage.save_graph(graph)
+
+  -- Update meta
+  local meta = storage.get_meta()
+  storage.update_meta({ ec = meta.ec + 1 })
+
+  -- Track pending change
+  table.insert(M.pending, {
+    op = types.DELTA_OPS.ADD,
+    path = "graph.edges." .. edge.id,
+    ah = hash.compute_table(edge),
+  })
+
+  return edge
+end
+
+--- Get edge by source and target
+---@param source_id string Source node ID
+---@param target_id string Target node ID
+---@param edge_type? EdgeType Optional edge type filter
+---@return Edge|nil
+function M.get(source_id, target_id, edge_type)
+  local graph = storage.get_graph()
+  local edge_id = hash.edge_id(source_id, target_id)
+
+  if not graph.edges or not graph.edges[edge_id] then
+    return nil
+  end
+
+  local edge = graph.edges[edge_id]
+
+  if edge_type and edge.ty ~= edge_type then
+    return nil
+  end
+
+  return edge
+end
+
+--- Get all edges for a node
+---@param node_id string Node ID
+---@param edge_types? EdgeType[] Edge types to include
+---@param direction? "out"|"in"|"both" Direction (default: "out")
+---@return Edge[]
+function M.get_edges(node_id, edge_types, direction)
+  direction = direction or "out"
+  local graph = storage.get_graph()
+  local results = {}
+
+  edge_types = edge_types or vim.tbl_values(types.EDGE_TYPES)
+
+  -- Outgoing edges
+  if direction == "out" or direction == "both" then
+    local adj = graph.adj[node_id]
+    if adj then
+      for _, edge_type in ipairs(edge_types) do
+        local targets = adj[edge_type] or {}
+        for _, target_id in ipairs(targets) do
+          local edge_id = hash.edge_id(node_id, target_id)
+          if graph.edges and graph.edges[edge_id] then
+            table.insert(results, graph.edges[edge_id])
+          end
+        end
+      end
+    end
+  end
+
+  -- Incoming edges
+  if direction == "in" or direction == "both" then
+    local radj = graph.radj[node_id]
+    if radj then
+      for _, edge_type in ipairs(edge_types) do
+        local sources = radj[edge_type] or {}
+        for _, source_id in ipairs(sources) do
+          local edge_id = hash.edge_id(source_id, node_id)
+          if graph.edges and graph.edges[edge_id] then
+            table.insert(results, graph.edges[edge_id])
+          end
+        end
+      end
+    end
+  end
+
+  return results
+end
+
+--- Get neighbor node IDs
+---@param node_id string Node ID
+---@param edge_types? EdgeType[] Edge types to follow
+---@param direction? "out"|"in"|"both" Direction
+---@return string[] Neighbor node IDs
+function M.get_neighbors(node_id, edge_types, direction)
+  direction = direction or "out"
+  local graph = storage.get_graph()
+  local neighbors = {}
+
+  edge_types = edge_types or vim.tbl_values(types.EDGE_TYPES)
+
+  -- Outgoing
+  if direction == "out" or direction == "both" then
+    local adj = graph.adj[node_id]
+    if adj then
+      for _, edge_type in ipairs(edge_types) do
+        for _, target in ipairs(adj[edge_type] or {}) do
+          if not vim.tbl_contains(neighbors, target) then
+            table.insert(neighbors, target)
+          end
+        end
+      end
+    end
+  end
+
+  -- Incoming
+  if direction == "in" or direction == "both" then
+    local radj = graph.radj[node_id]
+    if radj then
+      for _, edge_type in ipairs(edge_types) do
+        for _, source in ipairs(radj[edge_type] or {}) do
+          if not vim.tbl_contains(neighbors, source) then
+            table.insert(neighbors, source)
+          end
+        end
+      end
+    end
+  end
+
+  return neighbors
+end
+
+--- Delete an edge
+---@param source_id string Source node ID
+---@param target_id string Target node ID
+---@param edge_type? EdgeType Edge type (deletes all if nil)
+---@return boolean Success
+function M.delete(source_id, target_id, edge_type)
+  local graph = storage.get_graph()
+  local edge_id = hash.edge_id(source_id, target_id)
+
+  if not graph.edges or not graph.edges[edge_id] then
+    return false
+  end
+
+  local edge = graph.edges[edge_id]
+
+  if edge_type and edge.ty ~= edge_type then
+    return false
+  end
+
+  local before_hash = hash.compute_table(edge)
+
+  -- Remove from adjacency
+  if graph.adj[source_id] and graph.adj[source_id][edge.ty] then
+    graph.adj[source_id][edge.ty] = vim.tbl_filter(function(id)
+      return id ~= target_id
+    end, graph.adj[source_id][edge.ty])
+  end
+
+  -- Remove from reverse adjacency
+  if graph.radj[target_id] and graph.radj[target_id][edge.ty] then
+    graph.radj[target_id][edge.ty] = vim.tbl_filter(function(id)
+      return id ~= source_id
+    end, graph.radj[target_id][edge.ty])
+  end
+
+  -- Remove edge data
+  graph.edges[edge_id] = nil
+
+  storage.save_graph(graph)
+
+  -- Update meta
+  local meta = storage.get_meta()
+  storage.update_meta({ ec = math.max(0, meta.ec - 1) })
+
+  -- Track pending change
+  table.insert(M.pending, {
+    op = types.DELTA_OPS.DELETE,
+    path = "graph.edges." .. edge_id,
+    bh = before_hash,
+  })
+
+  return true
+end
+
+--- Delete all edges for a node
+---@param node_id string Node ID
+---@return number Number of deleted edges
+function M.delete_all(node_id)
+  local edges = M.get_edges(node_id, nil, "both")
+  local count = 0
+
+  for _, edge in ipairs(edges) do
+    if M.delete(edge.s, edge.t, edge.ty) then
+      count = count + 1
+    end
+  end
+
+  return count
+end
+
+--- Strengthen an existing edge
+---@param source_id string Source node ID
+---@param target_id string Target node ID
+---@param edge_type EdgeType Edge type
+---@return Edge|nil Updated edge
+function M.strengthen(source_id, target_id, edge_type)
+  local graph = storage.get_graph()
+  local edge_id = hash.edge_id(source_id, target_id)
+
+  if not graph.edges or not graph.edges[edge_id] then
+    return nil
+  end
+
+  local edge = graph.edges[edge_id]
+
+  if edge.ty ~= edge_type then
+    return nil
+  end
+
+  -- Increase weight (diminishing returns)
+  edge.p.w = math.min(1.0, edge.p.w + (1 - edge.p.w) * 0.1)
+  edge.ts = os.time()
+
+  graph.edges[edge_id] = edge
+  storage.save_graph(graph)
+
+  return edge
+end
+
+--- Find path between two nodes
+---@param from_id string Start node ID
+---@param to_id string End node ID
+---@param max_depth? number Maximum depth (default: 5)
+---@return table|nil Path info {nodes: string[], edges: Edge[], found: boolean}
+function M.find_path(from_id, to_id, max_depth)
+  max_depth = max_depth or 5
+
+  -- BFS
+  local queue = { { id = from_id, path = {}, edges = {} } }
+  local visited = { [from_id] = true }
+
+  while #queue > 0 do
+    local current = table.remove(queue, 1)
+
+    if current.id == to_id then
+      table.insert(current.path, to_id)
+      return {
+        nodes = current.path,
+        edges = current.edges,
+        found = true,
+      }
+    end
+
+    if #current.path >= max_depth then
+      goto continue
+    end
+
+    -- Get all neighbors
+    local edges = M.get_edges(current.id, nil, "both")
+
+    for _, edge in ipairs(edges) do
+      local neighbor = edge.s == current.id and edge.t or edge.s
+
+      if not visited[neighbor] then
+        visited[neighbor] = true
+
+        local new_path = vim.list_extend({}, current.path)
+        table.insert(new_path, current.id)
+
+        local new_edges = vim.list_extend({}, current.edges)
+        table.insert(new_edges, edge)
+
+        table.insert(queue, {
+          id = neighbor,
+          path = new_path,
+          edges = new_edges,
+        })
+      end
+    end
+
+    ::continue::
+  end
+
+  return { nodes = {}, edges = {}, found = false }
+end
+
+--- Get pending changes and clear
+---@return table[] Pending changes
+function M.get_and_clear_pending()
+  local changes = M.pending
+  M.pending = {}
+  return changes
+end
+
+--- Check if two nodes are connected
+---@param node_id_1 string First node ID
+---@param node_id_2 string Second node ID
+---@param edge_type? EdgeType Edge type filter
+---@return boolean
+function M.are_connected(node_id_1, node_id_2, edge_type)
+  local edge = M.get(node_id_1, node_id_2, edge_type)
+  if edge then
+    return true
+  end
+  -- Check reverse
+  edge = M.get(node_id_2, node_id_1, edge_type)
+  return edge ~= nil
+end
+
+return M
--- a/lua/codetyper/core/memory/graph/init.lua
+++ b/lua/codetyper/core/memory/graph/init.lua
@@ -0,0 +1,213 @@
+--- Brain Graph Coordinator
+--- High-level graph operations
+
+local node = require("codetyper.core.memory.graph.node")
+local edge = require("codetyper.core.memory.graph.edge")
+local query = require("codetyper.core.memory.graph.query")
+local storage = require("codetyper.core.memory.storage")
+local types = require("codetyper.core.memory.types")
+
+local M = {}
+
+-- Re-export submodules
+M.node = node
+M.edge = edge
+M.query = query
+
+--- Add a learning with automatic edge creation
+---@param node_type NodeType Node type
+---@param content NodeContent Content
+---@param context? NodeContext Context
+---@param related_ids? string[] Related node IDs
+---@return Node Created node
+function M.add_learning(node_type, content, context, related_ids)
+  -- Create the node
+  local new_node = node.create(node_type, content, context)
+
+  -- Create edges to related nodes
+  if related_ids then
+    for _, related_id in ipairs(related_ids) do
+      local related_node = node.get(related_id)
+      if related_node then
+        -- Determine edge type based on relationship
+        local edge_type = types.EDGE_TYPES.SEMANTIC
+
+        -- If same file, use file edge
+        if context and context.f and related_node.ctx and related_node.ctx.f == context.f then
+          edge_type = types.EDGE_TYPES.FILE
+        end
+
+        edge.create(new_node.id, related_id, edge_type, {
+          w = 0.5,
+          r = "Related learning",
+        })
+      end
+    end
+  end
+
+  -- Find and link to similar existing nodes
+  local similar = query.semantic_search(content.s, 5)
+  for _, sim_node in ipairs(similar) do
+    if sim_node.id ~= new_node.id then
+      -- Create semantic edge if similarity is high enough
+      local sim_score = query.compute_relevance(sim_node, { query = content.s })
+      if sim_score > 0.5 then
+        edge.create(new_node.id, sim_node.id, types.EDGE_TYPES.SEMANTIC, {
+          w = sim_score,
+          r = "Semantic similarity",
+        })
+      end
+    end
+  end
+
+  return new_node
+end
+
+--- Remove a learning and its edges
+---@param node_id string Node ID to remove
+---@return boolean Success
+function M.remove_learning(node_id)
+  -- Delete all edges first
+  edge.delete_all(node_id)
+
+  -- Delete the node
+  return node.delete(node_id)
+end
+
+--- Prune low-value nodes
+---@param opts? table Prune options
+---@return number Number of pruned nodes
+function M.prune(opts)
+  opts = opts or {}
+  local threshold = opts.threshold or 0.1
+  local unused_days = opts.unused_days or 90
+  local now = os.time()
+  local cutoff = now - (unused_days * 86400)
+
+  local pruned = 0
+
+  -- Find nodes to prune
+  for _, node_type in pairs(types.NODE_TYPES) do
+    local nodes_to_prune = node.find({
+      types = { node_type },
+      min_weight = 0, -- Get all
+    })
+
+    for _, n in ipairs(nodes_to_prune) do
+      local should_prune = false
+
+      -- Prune if weight below threshold and not used recently
+      if n.sc.w < threshold and (n.ts.lu or n.ts.up) < cutoff then
+        should_prune = true
+      end
+
+      -- Prune if never used and old
+      if n.sc.u == 0 and n.ts.cr < cutoff then
+        should_prune = true
+      end
+
+      if should_prune then
+        if M.remove_learning(n.id) then
+          pruned = pruned + 1
+        end
+      end
+    end
+  end
+
+  return pruned
+end
+
+--- Get all pending changes from nodes and edges
+---@return table[] Combined pending changes
+function M.get_pending_changes()
+  local changes = {}
+
+  -- Get node changes
+  local node_changes = node.get_and_clear_pending()
+  for _, change in ipairs(node_changes) do
+    table.insert(changes, change)
+  end
+
+  -- Get edge changes
+  local edge_changes = edge.get_and_clear_pending()
+  for _, change in ipairs(edge_changes) do
+    table.insert(changes, change)
+  end
+
+  return changes
+end
+
+--- Get graph statistics
+---@return table Stats
+function M.stats()
+  local meta = storage.get_meta()
+
+  -- Count nodes by type
+  local by_type = {}
+  for _, node_type in pairs(types.NODE_TYPES) do
+    local nodes = storage.get_nodes(node_type .. "s")
+    by_type[node_type] = vim.tbl_count(nodes)
+  end
+
+  -- Count edges by type
+  local graph = storage.get_graph()
+  local edges_by_type = {}
+  if graph.edges then
+    for _, e in pairs(graph.edges) do
+      edges_by_type[e.ty] = (edges_by_type[e.ty] or 0) + 1
+    end
+  end
+
+  return {
+    node_count = meta.nc,
+    edge_count = meta.ec,
+    delta_count = meta.dc,
+    nodes_by_type = by_type,
+    edges_by_type = edges_by_type,
+  }
+end
+
+--- Create temporal edge between nodes created in sequence
+---@param node_ids string[] Node IDs in temporal order
+function M.link_temporal(node_ids)
+  for i = 1, #node_ids - 1 do
+    edge.create(node_ids[i], node_ids[i + 1], types.EDGE_TYPES.TEMPORAL, {
+      w = 0.7,
+      dir = "fwd",
+      r = "Temporal sequence",
+    })
+  end
+end
+
+--- Create causal edge (this caused that)
+---@param cause_id string Cause node ID
+---@param effect_id string Effect node ID
+---@param reason? string Reason description
+function M.link_causal(cause_id, effect_id, reason)
+  edge.create(cause_id, effect_id, types.EDGE_TYPES.CAUSAL, {
+    w = 0.8,
+    dir = "fwd",
+    r = reason or "Caused by",
+  })
+end
+
+--- Mark a node as superseded by another
+---@param old_id string Old node ID
+---@param new_id string New node ID
+function M.supersede(old_id, new_id)
+  edge.create(old_id, new_id, types.EDGE_TYPES.SUPERSEDES, {
+    w = 1.0,
+    dir = "fwd",
+    r = "Superseded by newer learning",
+  })
+
+  -- Reduce weight of old node
+  local old_node = node.get(old_id)
+  if old_node then
+    node.update(old_id, {
+      sc = { w = old_node.sc.w * 0.5 },
+    })
+  end
+end
+
+return M
--- a/lua/codetyper/core/memory/graph/node.lua
+++ b/lua/codetyper/core/memory/graph/node.lua
@@ -0,0 +1,403 @@
+--- Brain Graph Node Operations
+--- CRUD operations for learning nodes
+
+local storage = require("codetyper.core.memory.storage")
+local hash = require("codetyper.core.memory.hash")
+local types = require("codetyper.core.memory.types")
+
+local M = {}
+
+--- Pending changes for delta tracking
+---@type table[]
+M.pending = {}
+
+--- Node type to file mapping
+local TYPE_MAP = {
+  [types.NODE_TYPES.PATTERN] = "patterns",
+  [types.NODE_TYPES.CORRECTION] = "corrections",
+  [types.NODE_TYPES.DECISION] = "decisions",
+  [types.NODE_TYPES.CONVENTION] = "conventions",
+  [types.NODE_TYPES.FEEDBACK] = "feedback",
+  [types.NODE_TYPES.SESSION] = "sessions",
+  -- Full names for convenience
+  patterns = "patterns",
+  corrections = "corrections",
+  decisions = "decisions",
+  conventions = "conventions",
+  feedback = "feedback",
+  sessions = "sessions",
+}
+
+--- Get storage key for node type
+---@param node_type string Node type
+---@return string Storage key
+local function get_storage_key(node_type)
+  return TYPE_MAP[node_type] or "patterns"
+end
+
+--- Create a new node
+---@param node_type NodeType Node type
+---@param content NodeContent Content
+---@param context? NodeContext Context
+---@param opts? table Additional options
+---@return Node Created node
+function M.create(node_type, content, context, opts)
+  opts = opts or {}
+  local now = os.time()
+
+  local node = {
+    id = hash.node_id(node_type, content.s),
+    t = node_type,
+    h = hash.compute(content.s .. (content.d or "")),
+    c = {
+      s = content.s or "",
+      d = content.d or content.s or "",
+      code = content.code,
+      lang = content.lang,
+    },
+    ctx = context or {},
+    sc = {
+      w = opts.weight or 0.5,
+      u = 0,
+      sr = 1.0,
+    },
+    ts = {
+      cr = now,
+      up = now,
+      lu = now,
+    },
+    m = {
+      src = opts.source or types.SOURCES.AUTO,
+      v = 1,
+    },
+  }
+
+  -- Store node
+  local storage_key = get_storage_key(node_type)
+  local nodes = storage.get_nodes(storage_key)
+  nodes[node.id] = node
+  storage.save_nodes(storage_key, nodes)
+
+  -- Update meta
+  local meta = storage.get_meta()
+  storage.update_meta({ nc = meta.nc + 1 })
+
+  -- Update indices
+  M.update_indices(node, "add")
+
+  -- Track pending change
+  table.insert(M.pending, {
+    op = types.DELTA_OPS.ADD,
+    path = "nodes." .. storage_key .. "." .. node.id,
+    ah = node.h,
+  })
+
+  return node
+end
+
+--- Get a node by ID
+---@param node_id string Node ID
+---@return Node|nil
+function M.get(node_id)
+  -- Parse node type from ID (n_<type>_<timestamp>_<hash>)
+  local parts = vim.split(node_id, "_")
+  if #parts < 3 then
+    return nil
+  end
+
+  local node_type = parts[2]
+  local storage_key = get_storage_key(node_type)
+  local nodes = storage.get_nodes(storage_key)
+
+  return nodes[node_id]
+end
+
+--- Update a node
+---@param node_id string Node ID
+---@param updates table Partial updates
+---@return Node|nil Updated node
+function M.update(node_id, updates)
+  local node = M.get(node_id)
+  if not node then
+    return nil
+  end
+
+  local before_hash = node.h
+
+  -- Apply updates
+  if updates.c then
+    node.c = vim.tbl_deep_extend("force", node.c, updates.c)
+  end
+  if updates.ctx then
+    node.ctx = vim.tbl_deep_extend("force", node.ctx, updates.ctx)
+  end
+  if updates.sc then
+    node.sc = vim.tbl_deep_extend("force", node.sc, updates.sc)
+  end
+
+  -- Update timestamps and hash
+  node.ts.up = os.time()
+  node.h = hash.compute((node.c.s or "") .. (node.c.d or ""))
+  node.m.v = (node.m.v or 0) + 1
+
+  -- Save
+  local storage_key = get_storage_key(node.t)
+  local nodes = storage.get_nodes(storage_key)
+  nodes[node_id] = node
+  storage.save_nodes(storage_key, nodes)
+
+  -- Update indices if context changed
+  if updates.ctx then
+    M.update_indices(node, "update")
+  end
+
+  -- Track pending change
+  table.insert(M.pending, {
+    op = types.DELTA_OPS.MODIFY,
+    path = "nodes." .. storage_key .. "." .. node_id,
+    bh = before_hash,
+    ah = node.h,
+  })
+
+  return node
+end
+
+--- Delete a node
+---@param node_id string Node ID
+---@return boolean Success
+function M.delete(node_id)
+  local node = M.get(node_id)
+  if not node then
+    return false
+  end
+
+  local storage_key = get_storage_key(node.t)
+  local nodes = storage.get_nodes(storage_key)
+
+  if not nodes[node_id] then
+    return false
+  end
+
+  local before_hash = node.h
+  nodes[node_id] = nil
+  storage.save_nodes(storage_key, nodes)
+
+  -- Update meta
+  local meta = storage.get_meta()
+  storage.update_meta({ nc = math.max(0, meta.nc - 1) })
+
+  -- Update indices
+  M.update_indices(node, "delete")
+
+  -- Track pending change
+  table.insert(M.pending, {
+    op = types.DELTA_OPS.DELETE,
+    path = "nodes." .. storage_key .. "." .. node_id,
+    bh = before_hash,
+  })
+
+  return true
+end
+
+--- Find nodes by criteria
+---@param criteria table Search criteria
+---@return Node[]
+function M.find(criteria)
+  local results = {}
+
+  local node_types = criteria.types or vim.tbl_values(types.NODE_TYPES)
+
+  for _, node_type in ipairs(node_types) do
+    local storage_key = get_storage_key(node_type)
+    local nodes = storage.get_nodes(storage_key)
+
+    for _, node in pairs(nodes) do
+      local matches = true
+
+      -- Filter by file
+      if criteria.file and node.ctx.f ~= criteria.file then
+        matches = false
+      end
+
+      -- Filter by min weight
+      if criteria.min_weight and node.sc.w < criteria.min_weight then
+        matches = false
+      end
+
+      -- Filter by since timestamp
+      if criteria.since and node.ts.cr < criteria.since then
+        matches = false
+      end
+
+      -- Filter by content match
+      if criteria.query then
+        local query_lower = criteria.query:lower()
+        local summary_lower = (node.c.s or ""):lower()
+        local detail_lower = (node.c.d or ""):lower()
+        if not summary_lower:find(query_lower, 1, true) and not detail_lower:find(query_lower, 1, true) then
+          matches = false
+        end
+      end
+
+      if matches then
+        table.insert(results, node)
+      end
+    end
+  end
+
+  -- Sort by relevance (weight * recency)
+  table.sort(results, function(a, b)
+    local score_a = a.sc.w * (1 / (1 + (os.time() - a.ts.lu) / 86400))
+    local score_b = b.sc.w * (1 / (1 + (os.time() - b.ts.lu) / 86400))
+    return score_a > score_b
+  end)
+
+  -- Apply limit
+  if criteria.limit and #results > criteria.limit then
+    local limited = {}
+    for i = 1, criteria.limit do
+      limited[i] = results[i]
+    end
+    return limited
+  end
+
+  return results
+end
+
+--- Record usage of a node
+---@param node_id string Node ID
+---@param success? boolean Was the usage successful
+function M.record_usage(node_id, success)
+  local node = M.get(node_id)
+  if not node then
+    return
+  end
+
+  -- Update usage stats
+  node.sc.u = node.sc.u + 1
+  node.ts.lu = os.time()
+
+  -- Update success rate
+  if success ~= nil then
+    local total = node.sc.u
+    local successes = node.sc.sr * (total - 1) + (success and 1 or 0)
+    node.sc.sr = successes / total
+  end
+
+  -- Increase weight slightly for frequently used nodes
+  if node.sc.u > 5 then
+    node.sc.w = math.min(1.0, node.sc.w + 0.01)
+  end
+
+  -- Save (direct save, no pending change tracking for usage)
+  local storage_key = get_storage_key(node.t)
+  local nodes = storage.get_nodes(storage_key)
+  nodes[node_id] = node
+  storage.save_nodes(storage_key, nodes)
+end
+
+--- Update indices for a node
+---@param node Node The node
+---@param op "add"|"update"|"delete" Operation type
+function M.update_indices(node, op)
+  -- File index
+  if node.ctx.f then
+    local by_file = storage.get_index("by_file")
+
+    if op == "delete" then
+      if by_file[node.ctx.f] then
+        by_file[node.ctx.f] = vim.tbl_filter(function(id)
+          return id ~= node.id
+        end, by_file[node.ctx.f])
+      end
+    else
+      by_file[node.ctx.f] = by_file[node.ctx.f] or {}
+      if not vim.tbl_contains(by_file[node.ctx.f], node.id) then
+        table.insert(by_file[node.ctx.f], node.id)
+      end
+    end
+
+    storage.save_index("by_file", by_file)
+  end
+
+  -- Symbol index
+  if node.ctx.sym then
+    local by_symbol = storage.get_index("by_symbol")
+
+    for _, sym in ipairs(node.ctx.sym) do
+      if op == "delete" then
+        if by_symbol[sym] then
+          by_symbol[sym] = vim.tbl_filter(function(id)
+            return id ~= node.id
+          end, by_symbol[sym])
+        end
+      else
+        by_symbol[sym] = by_symbol[sym] or {}
+        if not vim.tbl_contains(by_symbol[sym], node.id) then
+          table.insert(by_symbol[sym], node.id)
+        end
+      end
+    end
+
+    storage.save_index("by_symbol", by_symbol)
+  end
+
+  -- Time index (daily buckets)
+  local day = os.date("%Y-%m-%d", node.ts.cr)
+  local by_time = storage.get_index("by_time")
+
+  if op == "delete" then
+    if by_time[day] then
+      by_time[day] = vim.tbl_filter(function(id)
+        return id ~= node.id
+      end, by_time[day])
+    end
+  elseif op == "add" then
+    by_time[day] = by_time[day] or {}
+    if not vim.tbl_contains(by_time[day], node.id) then
+      table.insert(by_time[day], node.id)
+    end
+  end
+
+  storage.save_index("by_time", by_time)
+end
+
+--- Get pending changes and clear
+---@return table[] Pending changes
+function M.get_and_clear_pending()
+  local changes = M.pending
+  M.pending = {}
+  return changes
+end
+
+--- Merge two similar nodes
+---@param node_id_1 string First node ID
+---@param node_id_2 string Second node ID (will be deleted)
+---@return Node|nil Merged node
+function M.merge(node_id_1, node_id_2)
+  local node1 = M.get(node_id_1)
+  local node2 = M.get(node_id_2)
+
+  if not node1 or not node2 then
+    return nil
+  end
+
+  -- Merge content (keep longer detail)
+  local merged_detail = #node1.c.d > #node2.c.d and node1.c.d or node2.c.d
+
+  -- Merge scores (combine weights and usage)
+  local merged_weight = (node1.sc.w + node2.sc.w) / 2
+  local merged_usage = node1.sc.u + node2.sc.u
+
+  M.update(node_id_1, {
+    c = { d = merged_detail },
+    sc = { w = merged_weight, u = merged_usage },
+  })
+
+  -- Delete the second node
+  M.delete(node_id_2)
+
+  return M.get(node_id_1)
+end
+
+return M
--- a/lua/codetyper/core/memory/graph/query.lua
+++ b/lua/codetyper/core/memory/graph/query.lua
@@ -0,0 +1,488 @@
+--- Brain Graph Query Engine
+--- Multi-dimensional traversal and relevance scoring
+
+local storage = require("codetyper.core.memory.storage")
+local types = require("codetyper.core.memory.types")
+
+local M = {}
+
+--- Lazy load dependencies to avoid circular requires
+local function get_node_module()
+  return require("codetyper.core.memory.graph.node")
+end
+
+local function get_edge_module()
+  return require("codetyper.core.memory.graph.edge")
+end
+
+--- Compute text similarity (simple keyword matching)
+---@param text1 string First text
+---@param text2 string Second text
+---@return number Similarity score (0-1)
+local function text_similarity(text1, text2)
+  if not text1 or not text2 then
+    return 0
+  end
+
+  text1 = text1:lower()
+  text2 = text2:lower()
+
+  -- Extract words
+  local words1 = {}
+  for word in text1:gmatch("%w+") do
+    words1[word] = true
+  end
+
+  local words2 = {}
+  for word in text2:gmatch("%w+") do
+    words2[word] = true
+  end
+
+  -- Count matches
+  local matches = 0
+  local total = 0
+
+  for word in pairs(words1) do
+    total = total + 1
+    if words2[word] then
+      matches = matches + 1
+    end
+  end
+
+  for word in pairs(words2) do
+    if not words1[word] then
+      total = total + 1
+    end
+  end
+
+  if total == 0 then
+    return 0
+  end
+
+  return matches / total
+end
+
+--- Compute relevance score for a node
+---@param node Node Node to score
+---@param opts QueryOpts Query options
+---@return number Relevance score (0-1)
+function M.compute_relevance(node, opts)
+  local score = 0
+  local weights = {
+    content_match = 0.30,
+    recency = 0.20,
+    usage = 0.15,
+    weight = 0.15,
+    connection_density = 0.10,
+    success_rate = 0.10,
+  }
+
+  -- Content similarity
+  if opts.query then
+    local summary = node.c.s or ""
+    local detail = node.c.d or ""
+    local similarity = math.max(text_similarity(opts.query, summary), text_similarity(opts.query, detail) * 0.8)
+    score = score + (similarity * weights.content_match)
+  else
+    score = score + weights.content_match * 0.5 -- Base score if no query
+  end
+
+  -- Recency decay (exponential with 30-day half-life)
+  local age_days = (os.time() - (node.ts.lu or node.ts.up)) / 86400
+  local recency = math.exp(-age_days / 30)
+  score = score + (recency * weights.recency)
+
+  -- Usage frequency (normalized)
+  local usage = math.min(node.sc.u / 10, 1.0)
+  score = score + (usage * weights.usage)
+
+  -- Node weight
+  score = score + (node.sc.w * weights.weight)
+
+  -- Connection density
+  local edge_mod = get_edge_module()
+  local connections = #edge_mod.get_edges(node.id, nil, "both")
+  local density = math.min(connections / 5, 1.0)
+  score = score + (density * weights.connection_density)
+
+  -- Success rate
+  score = score + (node.sc.sr * weights.success_rate)
+
+  return score
+end
+
+--- Traverse graph from seed nodes (basic traversal)
+---@param seed_ids string[] Starting node IDs
+---@param depth number Traversal depth
+---@param edge_types? EdgeType[] Edge types to follow
+---@return table<string, Node> Discovered nodes indexed by ID
+local function traverse(seed_ids, depth, edge_types)
+  local node_mod = get_node_module()
+  local edge_mod = get_edge_module()
+  local discovered = {}
+  local frontier = seed_ids
+
+  for _ = 1, depth do
+    local next_frontier = {}
+
+    for _, node_id in ipairs(frontier) do
+      -- Skip if already discovered
+      if discovered[node_id] then
+        goto continue
+      end
+
+      -- Get and store node
+      local node = node_mod.get(node_id)
+      if node then
+        discovered[node_id] = node
+
+        -- Get neighbors
+        local neighbors = edge_mod.get_neighbors(node_id, edge_types, "both")
+        for _, neighbor_id in ipairs(neighbors) do
+          if not discovered[neighbor_id] then
+            table.insert(next_frontier, neighbor_id)
+          end
+        end
+      end
+
+      ::continue::
+    end
+
+    frontier = next_frontier
+    if #frontier == 0 then
+      break
+    end
+  end
+
+  return discovered
+end
+
+--- Spreading activation - mimics human associative memory
+--- Activation spreads from seed nodes along edges, decaying by weight
+--- Nodes accumulate activation from multiple paths (like neural pathways)
+---@param seed_activations table<string, number> Initial activations {node_id: activation}
+---@param max_iterations number Max spread iterations (default 3)
+---@param decay number Activation decay per hop (default 0.5)
+---@param threshold number Minimum activation to continue spreading (default 0.1)
+---@return table<string, number> Final activations {node_id: accumulated_activation}
+local function spreading_activation(seed_activations, max_iterations, decay, threshold)
+  local edge_mod = get_edge_module()
+  max_iterations = max_iterations or 3
+  decay = decay or 0.5
+  threshold = threshold or 0.1
+
+  -- Accumulated activation for each node
+  local activation = {}
+  for node_id, act in pairs(seed_activations) do
+    activation[node_id] = act
+  end
+
+  -- Current frontier with their activation levels
+  local frontier = {}
+  for node_id, act in pairs(seed_activations) do
+    frontier[node_id] = act
+  end
+
+  -- Spread activation iteratively
+  for _ = 1, max_iterations do
+    local next_frontier = {}
+
+    for source_id, source_activation in pairs(frontier) do
+      -- Get all outgoing edges
+      local edges = edge_mod.get_edges(source_id, nil, "both")
+
+      for _, edge in ipairs(edges) do
+        -- Determine target (could be source or target of edge)
+        local target_id = edge.s == source_id and edge.t or edge.s
+
+        -- Calculate spreading activation
+        -- Activation = source_activation * edge_weight * decay
+        local edge_weight = edge.p and edge.p.w or 0.5
+        local spread_amount = source_activation * edge_weight * decay
+
+        -- Only spread if above threshold
+        if spread_amount >= threshold then
+          -- Accumulate activation (multiple paths add up)
+          activation[target_id] = (activation[target_id] or 0) + spread_amount
+
+          -- Add to next frontier if not already processed with higher activation
+          if not next_frontier[target_id] or next_frontier[target_id] < spread_amount then
+            next_frontier[target_id] = spread_amount
+          end
+        end
+      end
+    end
+
+    -- Stop if no more spreading
+    if vim.tbl_count(next_frontier) == 0 then
+      break
+    end
+
+    frontier = next_frontier
+  end
+
+  return activation
+end
+
+--- Execute a query across all dimensions
+---@param opts QueryOpts Query options
+---@return QueryResult
+function M.execute(opts)
+  opts = opts or {}
+  local node_mod = get_node_module()
+  local results = {
+    semantic = {},
+    file = {},
+    temporal = {},
+  }
+
+  -- 1. Semantic traversal (content similarity)
+  if opts.query then
+    local seed_nodes = node_mod.find({
+      query = opts.query,
+      types = opts.types,
+      limit = 10,
+    })
+
+    local seed_ids = vim.tbl_map(function(n)
+      return n.id
+    end, seed_nodes)
+    local depth = opts.depth or 2
+
+    local discovered = traverse(seed_ids, depth, { types.EDGE_TYPES.SEMANTIC })
+    for id, node in pairs(discovered) do
+      results.semantic[id] = node
+    end
+  end
+
+  -- 2. File-based traversal
+  if opts.file then
+    local by_file = storage.get_index("by_file")
+    local file_node_ids = by_file[opts.file] or {}
+
+    for _, node_id in ipairs(file_node_ids) do
+      local node = node_mod.get(node_id)
+      if node then
+        results.file[node.id] = node
+      end
+    end
+
+    -- Also get nodes from related files via edges
+    local discovered = traverse(file_node_ids, 1, { types.EDGE_TYPES.FILE })
+    for id, node in pairs(discovered) do
+      results.file[id] = node
+    end
+  end
+
+  -- 3. Temporal traversal (recent context)
+  if opts.since then
+    local by_time = storage.get_index("by_time")
+    local now = os.time()
+
+    for day, node_ids in pairs(by_time) do
+      -- Parse day to timestamp
+      local year, month, day_num = day:match("(%d+)-(%d+)-(%d+)")
+      if year then
+        local day_ts = os.time({ year = tonumber(year), month = tonumber(month), day = tonumber(day_num) })
+        if day_ts >= opts.since then
+          for _, node_id in ipairs(node_ids) do
+            local node = node_mod.get(node_id)
+            if node then
+              results.temporal[node.id] = node
+            end
+          end
+        end
+      end
+    end
+
+    -- Follow temporal edges
+    local temporal_ids = vim.tbl_keys(results.temporal)
+    local discovered = traverse(temporal_ids, 1, { types.EDGE_TYPES.TEMPORAL })
+    for id, node in pairs(discovered) do
+      results.temporal[id] = node
+    end
+  end
+
+  -- 4. Combine all found nodes and compute seed activations
+  local all_nodes = {}
+  local seed_activations = {}
+
+  for _, category in pairs(results) do
+    for id, node in pairs(category) do
+      if not all_nodes[id] then
+        all_nodes[id] = node
+        -- Compute initial activation based on relevance
+        local relevance = M.compute_relevance(node, opts)
+        seed_activations[id] = relevance
+      end
+    end
+  end
+
+  -- 5. Apply spreading activation - like human associative memory
+  -- Activation spreads from seed nodes along edges, accumulating
+  -- Nodes connected to multiple relevant seeds get higher activation
+  local final_activations = spreading_activation(
+    seed_activations,
+    opts.spread_iterations or 3,  -- How far activation spreads
+    opts.spread_decay or 0.5,     -- How much activation decays per hop
+    opts.spread_threshold or 0.05 -- Minimum activation to continue spreading
+  )
+
+  -- 6. Score and rank by combined activation
+  local scored = {}
+  for id, activation in pairs(final_activations) do
+    local node = all_nodes[id] or node_mod.get(id)
+    if node then
+      all_nodes[id] = node
+      -- Final score = spreading activation + base relevance
+      local base_relevance = M.compute_relevance(node, opts)
+      local final_score = (activation * 0.6) + (base_relevance * 0.4)
+      table.insert(scored, { node = node, relevance = final_score, activation = activation })
+    end
+  end
+
+  table.sort(scored, function(a, b)
+    return a.relevance > b.relevance
+  end)
+
+  -- 7. Apply limit
+  local limit = opts.limit or 50
+  local result_nodes = {}
+  local truncated = #scored > limit
+
+  for i = 1, math.min(limit, #scored) do
+    table.insert(result_nodes, scored[i].node)
+  end
+
+  -- 8. Get edges between result nodes
+  local edge_mod = get_edge_module()
+  local result_edges = {}
+  local node_ids = {}
+  for _, node in ipairs(result_nodes) do
+    node_ids[node.id] = true
+  end
+
+  for _, node in ipairs(result_nodes) do
+    local edges = edge_mod.get_edges(node.id, nil, "out")
+    for _, edge in ipairs(edges) do
+      if node_ids[edge.t] then
+        table.insert(result_edges, edge)
+      end
+    end
+  end
+
+  return {
+    nodes = result_nodes,
+    edges = result_edges,
+    stats = {
+      semantic_count = vim.tbl_count(results.semantic),
+      file_count = vim.tbl_count(results.file),
+      temporal_count = vim.tbl_count(results.temporal),
+      total_scored = #scored,
+      seed_nodes = vim.tbl_count(seed_activations),
+      activated_nodes = vim.tbl_count(final_activations),
+    },
+    truncated = truncated,
+  }
+end
+
+--- Expose spreading activation for direct use
+--- Useful for custom activation patterns or debugging
+M.spreading_activation = spreading_activation
+
+--- Find nodes by file
+---@param filepath string File path
+---@param limit? number Max results
+---@return Node[]
+function M.by_file(filepath, limit)
+  local result = M.execute({
+    file = filepath,
+    limit = limit or 20,
+  })
+  return result.nodes
+end
+
+--- Find nodes by time range
+---@param since number Start timestamp
+---@param until_ts? number End timestamp
+---@param limit? number Max results
+---@return Node[]
+function M.by_time_range(since, until_ts, limit)
+  local node_mod = get_node_module()
+  local by_time = storage.get_index("by_time")
+  local results = {}
+
+  until_ts = until_ts or os.time()
+
+  for day, node_ids in pairs(by_time) do
+    local year, month, day_num = day:match("(%d+)-(%d+)-(%d+)")
+    if year then
+      local day_ts = os.time({ year = tonumber(year), month = tonumber(month), day = tonumber(day_num) })
+      if day_ts >= since and day_ts <= until_ts then
+        for _, node_id in ipairs(node_ids) do
+          local node = node_mod.get(node_id)
+          if node then
+            table.insert(results, node)
+          end
+        end
+      end
+    end
+  end
+
+  -- Sort by creation time
+  table.sort(results, function(a, b)
+    return a.ts.cr > b.ts.cr
+  end)
+
+  if limit and #results > limit then
+    local limited = {}
+    for i = 1, limit do
+      limited[i] = results[i]
+    end
+    return limited
+  end
+
+  return results
+end
+
+--- Find semantically similar nodes
+---@param query string Query text
+---@param limit? number Max results
+---@return Node[]
+function M.semantic_search(query, limit)
+  local result = M.execute({
+    query = query,
+    limit = limit or 10,
+    depth = 2,
+  })
+  return result.nodes
+end
+
+--- Get context chain (path) for explanation
+---@param node_ids string[] Node IDs to chain
+---@return string[] Chain descriptions
+function M.get_context_chain(node_ids)
+  local node_mod = get_node_module()
+  local edge_mod = get_edge_module()
+  local chain = {}
+
+  for i, node_id in ipairs(node_ids) do
+    local node = node_mod.get(node_id)
+    if node then
+      local entry = string.format("[%s] %s (w:%.2f)", node.t:upper(), node.c.s, node.sc.w)
+      table.insert(chain, entry)
+
+      -- Add edge to next node if exists
+      if node_ids[i + 1] then
+        local edge = edge_mod.get(node_id, node_ids[i + 1])
+        if edge then
+          table.insert(chain, string.format("  -> %s (w:%.2f)", edge.ty, edge.p.w))
+        end
+      end
+    end
+  end
+
+  return chain
+end
+
+return M
--- a/lua/codetyper/core/memory/hash.lua
+++ b/lua/codetyper/core/memory/hash.lua
@@ -0,0 +1,112 @@
+--- Brain Hashing Utilities
+--- Content-addressable storage with 8-character hashes
+
+local M = {}
+
+--- Simple DJB2 hash algorithm (fast, good distribution)
+---@param str string String to hash
+---@return number Hash value
+local function djb2(str)
+  local hash = 5381
+  for i = 1, #str do
+    hash = ((hash * 33) + string.byte(str, i)) % 0x100000000
+  end
+  return hash
+end
+
+--- Convert number to hex string
+---@param num number Number to convert
+---@param len number Desired length
+---@return string Hex string
+local function to_hex(num, len)
+  local hex = string.format("%x", num)
+  if #hex < len then
+    hex = string.rep("0", len - #hex) .. hex
+  end
+  return hex:sub(-len)
+end
+
+--- Compute 8-character hash from string
+---@param content string Content to hash
+---@return string 8-character hex hash
+function M.compute(content)
+  if not content or content == "" then
+    return "00000000"
+  end
+  local hash = djb2(content)
+  return to_hex(hash, 8)
+end
+
+--- Compute hash from table (JSON-serialized)
+---@param tbl table Table to hash
+---@return string 8-character hex hash
+function M.compute_table(tbl)
+  local ok, json = pcall(vim.json.encode, tbl)
+  if not ok then
+    return "00000000"
+  end
+  return M.compute(json)
+end
+
+--- Generate unique node ID
+---@param node_type string Node type prefix
+---@param content? string Optional content for hash
+---@return string Node ID (n_<timestamp>_<hash>)
+function M.node_id(node_type, content)
+  local ts = os.time()
+  local hash_input = (content or "") .. tostring(ts) .. tostring(math.random(100000))
+  local hash = M.compute(hash_input):sub(1, 6)
+  return string.format("n_%s_%d_%s", node_type, ts, hash)
+end
+
+--- Generate unique edge ID
+---@param source_id string Source node ID
+---@param target_id string Target node ID
+---@return string Edge ID (e_<source_hash>_<target_hash>)
+function M.edge_id(source_id, target_id)
+  local src_hash = M.compute(source_id):sub(1, 4)
+  local tgt_hash = M.compute(target_id):sub(1, 4)
+  return string.format("e_%s_%s", src_hash, tgt_hash)
+end
+
+--- Generate delta hash
+---@param changes table[] Delta changes
+---@param parent string|nil Parent delta hash
+---@param timestamp number Delta timestamp
+---@return string 8-character delta hash
+function M.delta_hash(changes, parent, timestamp)
+  local content = (parent or "root") .. tostring(timestamp)
+  for _, change in ipairs(changes or {}) do
+    content = content .. (change.op or "") .. (change.path or "")
+  end
+  return M.compute(content)
+end
+
+--- Hash file path for storage
+---@param filepath string File path
+---@return string 8-character hash
+function M.path_hash(filepath)
+  return M.compute(filepath)
+end
+
+--- Check if two hashes match
+---@param hash1 string First hash
+---@param hash2 string Second hash
+---@return boolean True if matching
+function M.matches(hash1, hash2)
+  return hash1 == hash2
+end
+
+--- Generate random hash (for testing/temporary IDs)
+---@return string 8-character random hash
+function M.random()
+  local chars = "0123456789abcdef"
+  local result = ""
+  for _ = 1, 8 do
+    local idx = math.random(1, #chars)
+    result = result .. chars:sub(idx, idx)
+  end
+  return result
+end
+
+return M
--- a/lua/codetyper/core/memory/init.lua
+++ b/lua/codetyper/core/memory/init.lua
@@ -0,0 +1,276 @@
+--- Brain Learning System
+--- Graph-based knowledge storage with delta versioning
+
+local storage = require("codetyper.core.memory.storage")
+local types = require("codetyper.core.memory.types")
+
+local M = {}
+
+---@type BrainConfig|nil
+local config = nil
+
+---@type boolean
+local initialized = false
+
+--- Pending changes counter for auto-commit
+local pending_changes = 0
+
+--- Default configuration
+local DEFAULT_CONFIG = {
+  enabled = true,
+  auto_learn = true,
+  auto_commit = true,
+  commit_threshold = 10,
+  max_nodes = 5000,
+  max_deltas = 500,
+  prune = {
+    enabled = true,
+    threshold = 0.1,
+    unused_days = 90,
+  },
+  output = {
+    max_tokens = 4000,
+    format = "compact",
+  },
+}
+
+--- Initialize brain system
+---@param opts? BrainConfig Configuration options
+function M.setup(opts)
+  config = vim.tbl_deep_extend("force", DEFAULT_CONFIG, opts or {})
+
+  if not config.enabled then
+    return
+  end
+
+  -- Ensure storage directories
+  storage.ensure_dirs()
+
+  -- Initialize meta if not exists
+  storage.get_meta()
+
+  initialized = true
+end
+
+--- Check if brain is initialized
+---@return boolean
+function M.is_initialized()
+  return initialized and config and config.enabled
+end
+
+--- Get current configuration
+---@return BrainConfig|nil
+function M.get_config()
+  return config
+end
+
+--- Learn from an event
+---@param event LearnEvent Learning event
+---@return string|nil Node ID if created
+function M.learn(event)
+  if not M.is_initialized() or not config.auto_learn then
+    return nil
+  end
+
+  local learners = require("codetyper.core.memory.learners")
+  local node_id = learners.process(event)
+
+  if node_id then
+    pending_changes = pending_changes + 1
+
+    -- Auto-commit if threshold reached
+    if config.auto_commit and pending_changes >= config.commit_threshold then
+      M.commit("Auto-commit: " .. pending_changes .. " changes")
+      pending_changes = 0
+    end
+  end
+
+  return node_id
+end
+
+--- Query relevant knowledge for context
+---@param opts QueryOpts Query options
+---@return QueryResult
+function M.query(opts)
+  if not M.is_initialized() then
+    return { nodes = {}, edges = {}, stats = {}, truncated = false }
+  end
+
+  local query_engine = require("codetyper.core.memory.graph.query")
+  return query_engine.execute(opts)
+end
+
+--- Get LLM-optimized context string
+---@param opts? QueryOpts Query options
+---@return string Formatted context
+function M.get_context_for_llm(opts)
+  if not M.is_initialized() then
+    return ""
+  end
+
+  opts = opts or {}
+  opts.max_tokens = opts.max_tokens or config.output.max_tokens
+
+  local result = M.query(opts)
+  local formatter = require("codetyper.core.memory.output.formatter")
+
+  if config.output.format == "json" then
+    return formatter.to_json(result, opts)
+  else
+    return formatter.to_compact(result, opts)
+  end
+end
+
+--- Create a delta commit
+---@param message string Commit message
+---@return string|nil Delta hash
+function M.commit(message)
+  if not M.is_initialized() then
+    return nil
+  end
+
+  local delta_mgr = require("codetyper.core.memory.delta")
+  return delta_mgr.commit(message)
+end
+
+--- Rollback to a previous delta
+---@param delta_hash string Target delta hash
+---@return boolean Success
+function M.rollback(delta_hash)
+  if not M.is_initialized() then
+    return false
+  end
+
+  local delta_mgr = require("codetyper.core.memory.delta")
+  return delta_mgr.rollback(delta_hash)
+end
+
+--- Get delta history
+---@param limit? number Max entries
+---@return Delta[]
+function M.get_history(limit)
+  if not M.is_initialized() then
+    return {}
+  end
+
+  local delta_mgr = require("codetyper.core.memory.delta")
+  return delta_mgr.get_history(limit or 50)
+end
+
+--- Prune low-value nodes
+---@param opts? table Prune options
+---@return number Number of pruned nodes
+function M.prune(opts)
+  if not M.is_initialized() or not config.prune.enabled then
+    return 0
+  end
+
+  opts = vim.tbl_extend("force", {
+    threshold = config.prune.threshold,
+    unused_days = config.prune.unused_days,
+  }, opts or {})
+
+  local graph = require("codetyper.core.memory.graph")
+  return graph.prune(opts)
+end
+
+--- Export brain state
+---@return table|nil Exported data
+function M.export()
+  if not M.is_initialized() then
+    return nil
+  end
+
+  return {
+    schema = types.SCHEMA_VERSION,
+    meta = storage.get_meta(),
+    graph = storage.get_graph(),
+    nodes = {
+      patterns = storage.get_nodes("patterns"),
+      corrections = storage.get_nodes("corrections"),
+      decisions = storage.get_nodes("decisions"),
+      conventions = storage.get_nodes("conventions"),
+      feedback = storage.get_nodes("feedback"),
+      sessions = storage.get_nodes("sessions"),
+    },
+    indices = {
+      by_file = storage.get_index("by_file"),
+      by_time = storage.get_index("by_time"),
+      by_symbol = storage.get_index("by_symbol"),
+    },
+  }
+end
+
+--- Import brain state
+---@param data table Exported data
+---@return boolean Success
+function M.import(data)
+  if not data or data.schema ~= types.SCHEMA_VERSION then
+    return false
+  end
+
+  storage.ensure_dirs()
+
+  -- Import nodes
+  if data.nodes then
+    for node_type, nodes in pairs(data.nodes) do
+      storage.save_nodes(node_type, nodes)
+    end
+  end
+
+  -- Import graph
+  if data.graph then
+    storage.save_graph(data.graph)
+  end
+
+  -- Import indices
+  if data.indices then
+    for index_type, index_data in pairs(data.indices) do
+      storage.save_index(index_type, index_data)
+    end
+  end
+
+  -- Import meta last
+  if data.meta then
+    for k, v in pairs(data.meta) do
+      storage.update_meta({ [k] = v })
+    end
+  end
+
+  storage.flush_all()
+  return true
+end
+
+--- Get stats about the brain
+---@return table Stats
+function M.stats()
+  if not M.is_initialized() then
+    return {}
+  end
+
+  local meta = storage.get_meta()
+  return {
+    initialized = true,
+    node_count = meta.nc,
+    edge_count = meta.ec,
+    delta_count = meta.dc,
+    head = meta.head,
+    pending_changes = pending_changes,
+  }
+end
+
+--- Flush all pending writes to disk
+function M.flush()
+  storage.flush_all()
+end
+
+--- Shutdown brain (call before exit)
+function M.shutdown()
+  if pending_changes > 0 then
+    M.commit("Session end: " .. pending_changes .. " changes")
+  end
+  storage.flush_all()
+  initialized = false
+end
+
+return M
--- a/lua/codetyper/core/memory/learners/convention.lua
+++ b/lua/codetyper/core/memory/learners/convention.lua
@@ -0,0 +1,233 @@
+--- Brain Convention Learner
+--- Learns project conventions and coding standards
+
+local types = require("codetyper.core.memory.types")
+
+local M = {}
+
+--- Detect if event contains convention info
+---@param event LearnEvent Learning event
+---@return boolean
+function M.detect(event)
+  local valid_types = {
+    "convention_detected",
+    "naming_pattern",
+    "style_pattern",
+    "project_structure",
+    "config_change",
+  }
+
+  for _, t in ipairs(valid_types) do
+    if event.type == t then
+      return true
+    end
+  end
+
+  return false
+end
+
+--- Extract convention data from event
+---@param event LearnEvent Learning event
+---@return table|nil Extracted data
+function M.extract(event)
+  local data = event.data or {}
+
+  if event.type == "convention_detected" then
+    return {
+      summary = "Convention: " .. (data.name or "unnamed"),
+      detail = data.description or data.name,
+      rule = data.rule,
+      examples = data.examples,
+      category = data.category or "general",
+      file = event.file,
+    }
+  end
+
+  if event.type == "naming_pattern" then
+    return {
+      summary = "Naming: " .. (data.pattern_name or data.pattern),
+      detail = "Naming convention: " .. (data.description or data.pattern),
+      rule = data.pattern,
+      examples = data.examples,
+      category = "naming",
+      scope = data.scope, -- function, variable, class, file
+    }
+  end
+
+  if event.type == "style_pattern" then
+    return {
+      summary = "Style: " .. (data.name or "unnamed"),
+      detail = data.description or "Code style pattern",
+      rule = data.rule,
+      examples = data.examples,
+      category = "style",
+      lang = data.language,
+    }
+  end
+
+  if event.type == "project_structure" then
+    return {
+      summary = "Structure: " .. (data.pattern or "project layout"),
+      detail = data.description or "Project structure convention",
+      rule = data.rule,
+      category = "structure",
+      paths = data.paths,
+    }
+  end
+
+  if event.type == "config_change" then
+    return {
+      summary = "Config: " .. (data.setting or "setting change"),
+      detail = "Configuration: " .. (data.description or data.setting),
+      before = data.before,
+      after = data.after,
+      category = "config",
+      file = event.file,
+    }
+  end
+
+  return nil
+end
+
+--- Check if convention should be learned
+---@param data table Extracted data
+---@return boolean
+function M.should_learn(data)
+  if not data.summary then
+    return false
+  end
+
+  -- Skip very vague conventions
+  if not data.detail or #data.detail < 5 then
+    return false
+  end
+
+  return true
+end
+
+--- Create node from convention data
+---@param data table Extracted data
+---@return table Node creation params
+function M.create_node_params(data)
+  local detail = data.detail or ""
+
+  -- Add examples if available
+  if data.examples and #data.examples > 0 then
+    detail = detail .. "\n\nExamples:"
+    for _, ex in ipairs(data.examples) do
+      detail = detail .. "\n- " .. tostring(ex)
+    end
+  end
+
+  -- Add rule if available
+  if data.rule then
+    detail = detail .. "\n\nRule: " .. tostring(data.rule)
+  end
+
+  return {
+    node_type = types.NODE_TYPES.CONVENTION,
+    content = {
+      s = data.summary:sub(1, 200),
+      d = detail,
+      lang = data.lang,
+    },
+    context = {
+      f = data.file,
+      sym = data.scope and { data.scope } or nil,
+    },
+    opts = {
+      weight = 0.6,
+      source = types.SOURCES.AUTO,
+    },
+  }
+end
+
+--- Find related conventions
+---@param data table Extracted data
+---@param query_fn function Query function
+---@return string[] Related node IDs
+function M.find_related(data, query_fn)
+  local related = {}
+
+  -- Find conventions in same category
+  if data.category then
+    local similar = query_fn({
+      query = data.category,
+      types = { types.NODE_TYPES.CONVENTION },
+      limit = 5,
+    })
+    for _, node in ipairs(similar) do
+      table.insert(related, node.id)
+    end
+  end
+
+  -- Find patterns that follow this convention
+  if data.rule then
+    local patterns = query_fn({
+      query = data.rule,
+      types = { types.NODE_TYPES.PATTERN },
+      limit = 3,
+    })
+    for _, node in ipairs(patterns) do
+      if not vim.tbl_contains(related, node.id) then
+        table.insert(related, node.id)
+      end
+    end
+  end
+
+  return related
+end
+
+--- Detect naming convention from symbol names
+---@param symbols string[] Symbol names to analyze
+---@return table|nil Detected convention
+function M.detect_naming(symbols)
+  if not symbols or #symbols < 3 then
+    return nil
+  end
+
+  local patterns = {
+    snake_case = 0,
+    camelCase = 0,
+    PascalCase = 0,
+    SCREAMING_SNAKE = 0,
+    kebab_case = 0,
+  }
+
+  for _, sym in ipairs(symbols) do
+    if sym:match("^[a-z][a-z0-9_]*$") then
+      patterns.snake_case = patterns.snake_case + 1
+    elseif sym:match("^[a-z][a-zA-Z0-9]*$") then
+      patterns.camelCase = patterns.camelCase + 1
+    elseif sym:match("^[A-Z][a-zA-Z0-9]*$") then
+      patterns.PascalCase = patterns.PascalCase + 1
+    elseif sym:match("^[A-Z][A-Z0-9_]*$") then
+      patterns.SCREAMING_SNAKE = patterns.SCREAMING_SNAKE + 1
+    elseif sym:match("^[a-z][a-z0-9%-]*$") then
+      patterns.kebab_case = patterns.kebab_case + 1
+    end
+  end
+
+  -- Find dominant pattern
+  local max_count = 0
+  local dominant = nil
+
+  for pattern, count in pairs(patterns) do
+    if count > max_count then
+      max_count = count
+      dominant = pattern
+    end
+  end
+
+  if dominant and max_count >= #symbols * 0.6 then
+    return {
+      pattern = dominant,
+      confidence = max_count / #symbols,
+      sample_size = #symbols,
+    }
+  end
+
+  return nil
+end
+
+return M
--- a/lua/codetyper/core/memory/learners/correction.lua
+++ b/lua/codetyper/core/memory/learners/correction.lua
@@ -0,0 +1,213 @@
+--- Brain Correction Learner
+--- Learns from user corrections and edits
+
+local types = require("codetyper.core.memory.types")
+
+local M = {}
+
+--- Detect if event is a correction
+---@param event LearnEvent Learning event
+---@return boolean
+function M.detect(event)
+  local valid_types = {
+    "user_correction",
+    "code_rejected",
+    "code_modified",
+    "suggestion_rejected",
+  }
+
+  for _, t in ipairs(valid_types) do
+    if event.type == t then
+      return true
+    end
+  end
+
+  return false
+end
+
+--- Extract correction data from event
+---@param event LearnEvent Learning event
+---@return table|nil Extracted data
+function M.extract(event)
+  local data = event.data or {}
+
+  if event.type == "user_correction" then
+    return {
+      summary = "Correction: " .. (data.error_type or "user edit"),
+      detail = data.description or "User corrected the generated code",
+      before = data.before,
+      after = data.after,
+      error_type = data.error_type,
+      file = event.file,
+      function_name = data.function_name,
+      lines = data.lines,
+    }
+  end
+
+  if event.type == "code_rejected" then
+    return {
+      summary = "Rejected: " .. (data.reason or "not accepted"),
+      detail = data.description or "User rejected generated code",
+      rejected_code = data.code,
+      reason = data.reason,
+      file = event.file,
+      intent = data.intent,
+    }
+  end
+
+  if event.type == "code_modified" then
+    local changes = M.analyze_changes(data.before, data.after)
+    return {
+      summary = "Modified: " .. changes.summary,
+      detail = changes.detail,
+      before = data.before,
+      after = data.after,
+      change_type = changes.type,
+      file = event.file,
+      lines = data.lines,
+    }
+  end
+
+  return nil
+end
+
+--- Analyze changes between before/after code
+---@param before string Before code
+---@param after string After code
+---@return table Change analysis
+function M.analyze_changes(before, after)
+  before = before or ""
+  after = after or ""
+
+  local before_lines = vim.split(before, "\n")
+  local after_lines = vim.split(after, "\n")
+
+  local added = 0
+  local removed = 0
+  local modified = 0
+
+  -- Simple line-based diff
+  local max_lines = math.max(#before_lines, #after_lines)
+  for i = 1, max_lines do
+    local b = before_lines[i]
+    local a = after_lines[i]
+
+    if b == nil and a ~= nil then
+      added = added + 1
+    elseif b ~= nil and a == nil then
+      removed = removed + 1
+    elseif b ~= a then
+      modified = modified + 1
+    end
+  end
+
+  local change_type = "mixed"
+  if added > 0 and removed == 0 and modified == 0 then
+    change_type = "addition"
+  elseif removed > 0 and added == 0 and modified == 0 then
+    change_type = "deletion"
+  elseif modified > 0 and added == 0 and removed == 0 then
+    change_type = "modification"
+  end
+
+  return {
+    type = change_type,
+    summary = string.format("+%d -%d ~%d lines", added, removed, modified),
+    detail = string.format("Added %d, removed %d, modified %d lines", added, removed, modified),
+    stats = {
+      added = added,
+      removed = removed,
+      modified = modified,
+    },
+  }
+end
+
+--- Check if correction should be learned
+---@param data table Extracted data
+---@return boolean
+function M.should_learn(data)
+  -- Always learn corrections - they're valuable
+  if not data.summary then
+    return false
+  end
+
+  -- Skip trivial changes
+  if data.before and data.after then
+    -- Skip if only whitespace changed
+    local before_trimmed = data.before:gsub("%s+", "")
+    local after_trimmed = data.after:gsub("%s+", "")
+    if before_trimmed == after_trimmed then
+      return false
+    end
+  end
+
+  return true
+end
+
+--- Create node from correction data
+---@param data table Extracted data
+---@return table Node creation params
+function M.create_node_params(data)
+  local detail = data.detail or ""
+
+  -- Include before/after in detail for learning
+  if data.before and data.after then
+    detail = detail .. "\n\nBefore:\n" .. data.before:sub(1, 500)
+    detail = detail .. "\n\nAfter:\n" .. data.after:sub(1, 500)
+  end
+
+  return {
+    node_type = types.NODE_TYPES.CORRECTION,
+    content = {
+      s = data.summary:sub(1, 200),
+      d = detail,
+      code = data.after or data.rejected_code,
+      lang = data.lang,
+    },
+    context = {
+      f = data.file,
+      fn = data.function_name,
+      ln = data.lines,
+    },
+    opts = {
+      weight = 0.7, -- Corrections are valuable
+      source = types.SOURCES.USER,
+    },
+  }
+end
+
+--- Find related nodes for corrections
+---@param data table Extracted data
+---@param query_fn function Query function
+---@return string[] Related node IDs
+function M.find_related(data, query_fn)
+  local related = {}
+
+  -- Find patterns that might be corrected
+  if data.before then
+    local similar = query_fn({
+      query = data.before:sub(1, 100),
+      types = { types.NODE_TYPES.PATTERN },
+      limit = 3,
+    })
+    for _, node in ipairs(similar) do
+      table.insert(related, node.id)
+    end
+  end
+
+  -- Find other corrections in same file
+  if data.file then
+    local file_corrections = query_fn({
+      file = data.file,
+      types = { types.NODE_TYPES.CORRECTION },
+      limit = 3,
+    })
+    for _, node in ipairs(file_corrections) do
+      table.insert(related, node.id)
+    end
+  end
+
+  return related
+end
+
+return M
--- a/lua/codetyper/core/memory/learners/init.lua
+++ b/lua/codetyper/core/memory/learners/init.lua
@@ -0,0 +1,232 @@
+--- Brain Learners Coordinator
+--- Routes learning events to appropriate learners
+
+local types = require("codetyper.core.memory.types")
+
+local M = {}
+
+-- Lazy load learners
+local function get_pattern_learner()
+  return require("codetyper.core.memory.learners.pattern")
+end
+
+local function get_correction_learner()
+  return require("codetyper.core.memory.learners.correction")
+end
+
+local function get_convention_learner()
+  return require("codetyper.core.memory.learners.convention")
+end
+
+--- All available learners
+local LEARNERS = {
+  { name = "pattern", loader = get_pattern_learner },
+  { name = "correction", loader = get_correction_learner },
+  { name = "convention", loader = get_convention_learner },
+}
+
+--- Process a learning event
+---@param event LearnEvent Learning event
+---@return string|nil Created node ID
+function M.process(event)
+  if not event or not event.type then
+    return nil
+  end
+
+  -- Add timestamp if missing
+  event.timestamp = event.timestamp or os.time()
+
+  -- Find matching learner
+  for _, learner_info in ipairs(LEARNERS) do
+    local learner = learner_info.loader()
+
+    if learner.detect(event) then
+      return M.learn_with(learner, event)
+    end
+  end
+
+  -- Handle generic feedback events
+  if event.type == "user_feedback" then
+    return M.process_feedback(event)
+  end
+
+  -- Handle session events
+  if event.type == "session_start" or event.type == "session_end" then
+    return M.process_session(event)
+  end
+
+  return nil
+end
+
+--- Learn using a specific learner
+---@param learner table Learner module
+---@param event LearnEvent Learning event
+---@return string|nil Created node ID
+function M.learn_with(learner, event)
+  -- Extract data
+  local extracted = learner.extract(event)
+  if not extracted then
+    return nil
+  end
+
+  -- Handle multiple extractions (e.g., from file indexing)
+  if vim.islist(extracted) then
+    local node_ids = {}
+    for _, data in ipairs(extracted) do
+      local node_id = M.create_learning(learner, data, event)
+      if node_id then
+        table.insert(node_ids, node_id)
+      end
+    end
+    return node_ids[1] -- Return first for now
+  end
+
+  return M.create_learning(learner, extracted, event)
+end
+
+--- Create a learning from extracted data
+---@param learner table Learner module
+---@param data table Extracted data
+---@param event LearnEvent Original event
+---@return string|nil Created node ID
+function M.create_learning(learner, data, event)
+  -- Check if should learn
+  if not learner.should_learn(data) then
+    return nil
+  end
+
+  -- Get node params
+  local params = learner.create_node_params(data)
+
+  -- Get graph module
+  local graph = require("codetyper.core.memory.graph")
+
+  -- Find related nodes
+  local related_ids = {}
+  if learner.find_related then
+    related_ids = learner.find_related(data, function(opts)
+      return graph.query.execute(opts).nodes
+    end)
+  end
+
+  -- Create the learning
+  local node = graph.add_learning(params.node_type, params.content, params.context, related_ids)
+
+  -- Update weight if specified
+  if params.opts and params.opts.weight then
+    graph.node.update(node.id, { sc = { w = params.opts.weight } })
+  end
+
+  return node.id
+end
+
+--- Process feedback event
+---@param event LearnEvent Feedback event
+---@return string|nil Created node ID
+function M.process_feedback(event)
+  local data = event.data or {}
+  local graph = require("codetyper.core.memory.graph")
+
+  local content = {
+    s = "Feedback: " .. (data.feedback or "unknown"),
+    d = data.description or ("User " .. (data.feedback or "gave feedback")),
+  }
+
+  local context = {
+    f = event.file,
+  }
+
+  -- If feedback references a node, update it
+  if data.node_id then
+    local node = graph.node.get(data.node_id)
+    if node then
+      local weight_delta = data.feedback == "accepted" and 0.1 or -0.1
+      local new_weight = math.max(0, math.min(1, node.sc.w + weight_delta))
+
+      graph.node.update(data.node_id, {
+        sc = { w = new_weight },
+      })
+
+      -- Record usage
+      graph.node.record_usage(data.node_id, data.feedback == "accepted")
+
+      -- Create feedback node linked to original
+      local fb_node = graph.add_learning(types.NODE_TYPES.FEEDBACK, content, context, { data.node_id })
+
+      return fb_node.id
+    end
+  end
+
+  -- Create standalone feedback node
+  local node = graph.add_learning(types.NODE_TYPES.FEEDBACK, content, context)
+  return node.id
+end
+
+--- Process session event
+---@param event LearnEvent Session event
+---@return string|nil Created node ID
+function M.process_session(event)
+  local data = event.data or {}
+  local graph = require("codetyper.core.memory.graph")
+
+  local content = {
+    s = event.type == "session_start" and "Session started" or "Session ended",
+    d = data.description or event.type,
+  }
+
+  if event.type == "session_end" and data.stats then
+    content.d = content.d .. "\n\nStats:"
+    content.d = content.d .. "\n- Completions: " .. (data.stats.completions or 0)
+    content.d = content.d .. "\n- Corrections: " .. (data.stats.corrections or 0)
+    content.d = content.d .. "\n- Files: " .. (data.stats.files or 0)
+  end
+
+  local node = graph.add_learning(types.NODE_TYPES.SESSION, content, {})
+
+  -- Link to recent session nodes
+  if event.type == "session_end" then
+    local recent = graph.query.by_time_range(os.time() - 3600, os.time(), 20) -- Last hour
+    local session_nodes = {}
+
+    for _, n in ipairs(recent) do
+      if n.id ~= node.id then
+        table.insert(session_nodes, n.id)
+      end
+    end
+
+    -- Create temporal links
+    if #session_nodes > 0 then
+      graph.link_temporal(session_nodes)
+    end
+  end
+
+  return node.id
+end
+
+--- Batch process multiple events
+---@param events LearnEvent[] Events to process
+---@return string[] Created node IDs
+function M.batch_process(events)
+  local node_ids = {}
+
+  for _, event in ipairs(events) do
+    local node_id = M.process(event)
+    if node_id then
+      table.insert(node_ids, node_id)
+    end
+  end
+
+  return node_ids
+end
+
+--- Get learner names
+---@return string[]
+function M.get_learner_names()
+  local names = {}
+  for _, learner in ipairs(LEARNERS) do
+    table.insert(names, learner.name)
+  end
+  return names
+end
+
+return M
--- a/lua/codetyper/core/memory/learners/pattern.lua
+++ b/lua/codetyper/core/memory/learners/pattern.lua
@@ -0,0 +1,176 @@
+--- Brain Pattern Learner
+--- Detects and learns code patterns
+
+local types = require("codetyper.core.memory.types")
+
+local M = {}
+
+--- Detect if event contains a learnable pattern
+---@param event LearnEvent Learning event
+---@return boolean
+function M.detect(event)
+  if not event or not event.type then
+    return false
+  end
+
+  local valid_types = {
+    "code_completion",
+    "file_indexed",
+    "code_analyzed",
+    "pattern_detected",
+  }
+
+  for _, t in ipairs(valid_types) do
+    if event.type == t then
+      return true
+    end
+  end
+
+  return false
+end
+
+--- Extract pattern data from event
+---@param event LearnEvent Learning event
+---@return table|nil Extracted data
+function M.extract(event)
+  local data = event.data or {}
+
+  -- Extract from code completion
+  if event.type == "code_completion" then
+    return {
+      summary = "Code pattern: " .. (data.intent or "unknown"),
+      detail = data.code or data.content or "",
+      code = data.code,
+      lang = data.language,
+      file = event.file,
+      function_name = data.function_name,
+      symbols = data.symbols,
+    }
+  end
+
+  -- Extract from file indexing
+  if event.type == "file_indexed" then
+    local patterns = {}
+
+    -- Extract function patterns
+    if data.functions then
+      for _, func in ipairs(data.functions) do
+        table.insert(patterns, {
+          summary = "Function: " .. func.name,
+          detail = func.signature or func.name,
+          code = func.body,
+          lang = data.language,
+          file = event.file,
+          function_name = func.name,
+          lines = func.lines,
+        })
+      end
+    end
+
+    -- Extract class patterns
+    if data.classes then
+      for _, class in ipairs(data.classes) do
+        table.insert(patterns, {
+          summary = "Class: " .. class.name,
+          detail = class.description or class.name,
+          lang = data.language,
+          file = event.file,
+          symbols = { class.name },
+        })
+      end
+    end
+
+    return #patterns > 0 and patterns or nil
+  end
+
+  -- Extract from explicit pattern detection
+  if event.type == "pattern_detected" then
+    return {
+      summary = data.name or "Unnamed pattern",
+      detail = data.description or data.name or "",
+      code = data.example,
+      lang = data.language,
+      file = event.file,
+      symbols = data.symbols,
+    }
+  end
+
+  return nil
+end
+
+--- Check if pattern should be learned
+---@param data table Extracted data
+---@return boolean
+function M.should_learn(data)
+  -- Skip if no meaningful content
+  if not data.summary or data.summary == "" then
+    return false
+  end
+
+  -- Skip very short patterns
+  if data.detail and #data.detail < 10 then
+    return false
+  end
+
+  -- Skip auto-generated patterns
+  if data.summary:match("^%s*$") then
+    return false
+  end
+
+  return true
+end
+
+--- Create node from pattern data
+---@param data table Extracted data
+---@return table Node creation params
+function M.create_node_params(data)
+  return {
+    node_type = types.NODE_TYPES.PATTERN,
+    content = {
+      s = data.summary:sub(1, 200), -- Limit summary
+      d = data.detail,
+      code = data.code,
+      lang = data.lang,
+    },
+    context = {
+      f = data.file,
+      fn = data.function_name,
+      ln = data.lines,
+      sym = data.symbols,
+    },
+    opts = {
+      weight = 0.5,
+      source = types.SOURCES.AUTO,
+    },
+  }
+end
+
+--- Find potentially related nodes
+---@param data table Extracted data
+---@param query_fn function Query function
+---@return string[] Related node IDs
+function M.find_related(data, query_fn)
+  local related = {}
+
+  -- Find nodes in same file
+  if data.file then
+    local file_nodes = query_fn({ file = data.file, limit = 5 })
+    for _, node in ipairs(file_nodes) do
+      table.insert(related, node.id)
+    end
+  end
+
+  -- Find semantically similar
+  if data.summary then
+    local similar = query_fn({ query = data.summary, limit = 3 })
+    for _, node in ipairs(similar) do
+      if not vim.tbl_contains(related, node.id) then
+        table.insert(related, node.id)
+      end
+    end
+  end
+
+  return related
+end
+
+return M
--- a/lua/codetyper/core/memory/output/formatter.lua
+++ b/lua/codetyper/core/memory/output/formatter.lua
@@ -0,0 +1,279 @@
+--- Brain Output Formatter
+--- LLM-optimized output formatting
+
+local types = require("codetyper.core.memory.types")
+
+local M = {}
+
+--- Estimate token count (rough approximation)
+---@param text string Text to estimate
+---@return number Estimated tokens
+function M.estimate_tokens(text)
+  if not text then
+    return 0
+  end
+  -- Rough estimate: 1 token ~= 4 characters
+  return math.ceil(#text / 4)
+end
+
+--- Format nodes to compact text format
+---@param result QueryResult Query result
+---@param opts? table Options
+---@return string Formatted output
+function M.to_compact(result, opts)
+  opts = opts or {}
+  local max_tokens = opts.max_tokens or 4000
+  local lines = {}
+  local current_tokens = 0
+
+  -- Header
+  table.insert(lines, "---BRAIN_CONTEXT---")
+  if opts.query then
+    table.insert(lines, "Q: " .. opts.query)
+  end
+  table.insert(lines, "")
+
+  -- Add nodes by relevance (already sorted)
+  table.insert(lines, "Learnings:")
+
+  for i, node in ipairs(result.nodes) do
+    -- Format: [idx] TYPE | w:0.85 u:5 | Summary
+    local line = string.format(
+      "[%d] %s | w:%.2f u:%d | %s",
+      i,
+      (node.t or "?"):upper(),
+      node.sc.w or 0,
+      node.sc.u or 0,
+      (node.c.s or ""):sub(1, 100)
+    )
+
+    local line_tokens = M.estimate_tokens(line)
+    if current_tokens + line_tokens > max_tokens - 100 then
+      table.insert(lines, "... (truncated)")
+      break
+    end
+
+    table.insert(lines, line)
+    current_tokens = current_tokens + line_tokens
+
+    -- Add context if file-related
+    if node.ctx and node.ctx.f then
+      local ctx_line = "   @ " .. node.ctx.f
+      if node.ctx.fn then
+        ctx_line = ctx_line .. ":" .. node.ctx.fn
+      end
+      if node.ctx.ln then
+        ctx_line = ctx_line .. " L" .. node.ctx.ln[1]
+      end
+      table.insert(lines, ctx_line)
+      current_tokens = current_tokens + M.estimate_tokens(ctx_line)
+    end
+  end
+
+  -- Add connections if space allows
+  if #result.edges > 0 and current_tokens < max_tokens - 200 then
+    table.insert(lines, "")
+    table.insert(lines, "Connections:")
+
+    for _, edge in ipairs(result.edges) do
+      if current_tokens >= max_tokens - 50 then
+        break
+      end
+
+      local conn_line = string.format(
+        "  %s --%s(%.2f)--> %s",
+        edge.s:sub(-8),
+        edge.ty,
+        edge.p.w or 0.5,
+        edge.t:sub(-8)
+      )
+      table.insert(lines, conn_line)
+      current_tokens = current_tokens + M.estimate_tokens(conn_line)
+    end
+  end
+
+  table.insert(lines, "---END_CONTEXT---")
+
+  return table.concat(lines, "\n")
+end
+
+--- Format nodes to JSON format
+---@param result QueryResult Query result
+---@param opts? table Options
+---@return string JSON output
+function M.to_json(result, opts)
+  opts = opts or {}
+  local max_tokens = opts.max_tokens or 4000
+
+  local output = {
+    _s = "brain-v1", -- Schema
+    q = opts.query,
+    l = {}, -- Learnings
+    c = {}, -- Connections
+  }
+
+  local current_tokens = 50 -- Base overhead
+
+  -- Add nodes
+  for _, node in ipairs(result.nodes) do
+    local entry = {
+      t = node.t,
+      s = (node.c.s or ""):sub(1, 150),
+      w = node.sc.w,
+      u = node.sc.u,
+    }
+
+    if node.ctx and node.ctx.f then
+      entry.f = node.ctx.f
+    end
+
+    local entry_tokens = M.estimate_tokens(vim.json.encode(entry))
+    if current_tokens + entry_tokens > max_tokens - 100 then
+      break
+    end
+
+    table.insert(output.l, entry)
+    current_tokens = current_tokens + entry_tokens
+  end
+
+  -- Add edges if space
+  if current_tokens < max_tokens - 200 then
+    for _, edge in ipairs(result.edges) do
+      if current_tokens >= max_tokens - 50 then
+        break
+      end
+
+      local e = {
+        s = edge.s:sub(-8),
+        t = edge.t:sub(-8),
+        r = edge.ty,
+        w = edge.p.w,
+      }
+
+      table.insert(output.c, e)
+      current_tokens = current_tokens + 30
+    end
+  end
+
+  return vim.json.encode(output)
+end
+
+--- Format as natural language
+---@param result QueryResult Query result
+---@param opts? table Options
+---@return string Natural language output
+function M.to_natural(result, opts)
+  opts = opts or {}
+  local max_tokens = opts.max_tokens or 4000
+  local lines = {}
+  local current_tokens = 0
+
+  if #result.nodes == 0 then
+    return "No relevant learnings found."
+  end
+
+  table.insert(lines, "Based on previous learnings:")
+  table.insert(lines, "")
+
+  -- Group by type
+  local by_type = {}
+  for _, node in ipairs(result.nodes) do
+    by_type[node.t] = by_type[node.t] or {}
+    table.insert(by_type[node.t], node)
+  end
+
+  local type_names = {
+    [types.NODE_TYPES.PATTERN] = "Code Patterns",
+    [types.NODE_TYPES.CORRECTION] = "Previous Corrections",
+    [types.NODE_TYPES.CONVENTION] = "Project Conventions",
+    [types.NODE_TYPES.DECISION] = "Architectural Decisions",
+    [types.NODE_TYPES.FEEDBACK] = "User Preferences",
+    [types.NODE_TYPES.SESSION] = "Session Context",
+  }
+
+  for node_type, nodes in pairs(by_type) do
+    local type_name = type_names[node_type] or node_type
+
+    table.insert(lines, "**" .. type_name .. "**")
+
+    for _, node in ipairs(nodes) do
+      if current_tokens >= max_tokens - 100 then
+        table.insert(lines, "...")
+        goto done
+      end
+
+      local bullet = string.format("- %s (confidence: %.0f%%)", node.c.s or "?", (node.sc.w or 0) * 100)
+
+      table.insert(lines, bullet)
+      current_tokens = current_tokens + M.estimate_tokens(bullet)
+
+      -- Add detail if high weight
+      if node.sc.w > 0.7 and node.c.d and #node.c.d > #(node.c.s or "") then
+        local detail = "  " .. node.c.d:sub(1, 150)
+        if #node.c.d > 150 then
+          detail = detail .. "..."
+        end
+        table.insert(lines, detail)
+        current_tokens = current_tokens + M.estimate_tokens(detail)
+      end
+    end
+
+    table.insert(lines, "")
+  end
+
+  ::done::
+
+  return table.concat(lines, "\n")
+end
+
+--- Format context chain for explanation
+---@param chain table[] Chain of nodes and edges
+---@return string Chain explanation
+function M.format_chain(chain)
+  local lines = {}
+
+  for i, item in ipairs(chain) do
+    if item.node then
+      local prefix = i == 1 and "" or "  -> "
+      table.insert(lines, string.format("%s[%s] %s (w:%.2f)", prefix, item.node.t:upper(), item.node.c.s:sub(1, 50), item.node.sc.w))
+    end
+    if item.edge then
+      table.insert(lines, string.format("     via %s (w:%.2f)", item.edge.ty, item.edge.p.w))
+    end
+  end
+
+  return table.concat(lines, "\n")
+end
+
+--- Compress output to fit token budget
+---@param text string Text to compress
+---@param max_tokens number Token budget
+---@return string Compressed text
+function M.compress(text, max_tokens)
+  local current = M.estimate_tokens(text)
+
+  if current <= max_tokens then
+    return text
+  end
+
+  -- Simple truncation with ellipsis
+  local ratio = max_tokens / current
+  local target_chars = math.floor(#text * ratio * 0.9) -- 10% buffer
+
+  return text:sub(1, target_chars) .. "\n...(truncated)"
+end
+
+--- Get minimal context for quick lookups
+---@param nodes Node[] Nodes to format
+---@return string Minimal context
+function M.minimal(nodes)
+  local items = {}
+
+  for _, node in ipairs(nodes) do
+    table.insert(items, string.format("%s:%s", node.t, (node.c.s or ""):sub(1, 40)))
+  end
+
+  return table.concat(items, " | ")
+end
+
+return M
--- a/lua/codetyper/core/memory/output/init.lua
+++ b/lua/codetyper/core/memory/output/init.lua
@@ -0,0 +1,166 @@
+--- Brain Output Coordinator
+--- Manages LLM context generation
+
+local formatter = require("codetyper.core.memory.output.formatter")
+
+local M = {}
+
+-- Re-export formatter
+M.formatter = formatter
+
+--- Default token budget
+local DEFAULT_MAX_TOKENS = 4000
+
+--- Generate context for LLM prompt
+---@param opts? table Options
+---@return string Context string
+function M.generate(opts)
+  opts = opts or {}
+
+  local brain = require("codetyper.core.memory")
+  if not brain.is_initialized() then
+    return ""
+  end
+
+  -- Build query opts
+  local query_opts = {
+    query = opts.query,
+    file = opts.file,
+    types = opts.types,
+    since = opts.since,
+    limit = opts.limit or 30,
+    depth = opts.depth or 2,
+    max_tokens = opts.max_tokens or DEFAULT_MAX_TOKENS,
+  }
+
+  -- Execute query
+  local result = brain.query(query_opts)
+
+  if #result.nodes == 0 then
+    return ""
+  end
+
+  -- Format based on style
+  local format = opts.format or "compact"
+
+  if format == "json" then
+    return formatter.to_json(result, query_opts)
+  elseif format == "natural" then
+    return formatter.to_natural(result, query_opts)
+  else
+    return formatter.to_compact(result, query_opts)
+  end
+end
+
+--- Generate context for a specific file
+---@param filepath string File path
+---@param opts? table Options
+---@return string Context string
+function M.for_file(filepath, opts)
+  opts = opts or {}
+  opts.file = filepath
+  return M.generate(opts)
+end
+
+--- Generate context for current buffer
+---@param opts? table Options
+---@return string Context string
+function M.for_current_buffer(opts)
+  local filepath = vim.fn.expand("%:p")
+  if filepath == "" then
+    return ""
+  end
+  return M.for_file(filepath, opts)
+end
+
+--- Generate context for a query/prompt
+---@param query string Query text
+---@param opts? table Options
+---@return string Context string
+function M.for_query(query, opts)
+  opts = opts or {}
+  opts.query = query
+  return M.generate(opts)
+end
+
+--- Get context for LLM system prompt
+---@param opts? table Options
+---@return string System context
+function M.system_context(opts)
+  opts = opts or {}
+  opts.limit = opts.limit or 20
+  opts.format = opts.format or "compact"
+
+  local context = M.generate(opts)
+
+  if context == "" then
+    return ""
+  end
+
+  return [[
+The following context contains learned patterns and conventions from this project:
+
+]] .. context .. [[
+
+
+Use this context to inform your responses, following established patterns and conventions.
+]]
+end
+
+--- Get relevant context for code completion
+---@param prefix string Code before cursor
+---@param suffix string Code after cursor
+---@param filepath string Current file
+---@return string Context
+function M.for_completion(prefix, suffix, filepath)
+  -- Extract relevant terms from code
+  local terms = {}
+
+  -- Get function/class names
+  for word in prefix:gmatch("[A-Z][a-zA-Z0-9]+") do
+    table.insert(terms, word)
+  end
+  for word in prefix:gmatch("function%s+([a-zA-Z_][a-zA-Z0-9_]*)") do
+    table.insert(terms, word)
+  end
+
+  local query = table.concat(terms, " ")
+
+  return M.generate({
+    query = query,
+    file = filepath,
+    limit = 15,
+    max_tokens = 2000,
+    format = "compact",
+  })
+end
+
+--- Check if context is available
+---@return boolean
+function M.has_context()
+  local brain = require("codetyper.core.memory")
+  if not brain.is_initialized() then
+    return false
+  end
+
+  local stats = brain.stats()
+  return stats.node_count > 0
+end
+
+--- Get context stats
+---@return table Stats
+function M.stats()
+  local brain = require("codetyper.core.memory")
+  if not brain.is_initialized() then
+    return { available = false }
+  end
+
+  local stats = brain.stats()
+  return {
+    available = true,
+    node_count = stats.node_count,
+    edge_count = stats.edge_count,
+  }
+end
+
+return M
--- a/lua/codetyper/core/memory/storage.lua
+++ b/lua/codetyper/core/memory/storage.lua
@@ -0,0 +1,338 @@
+--- Brain Storage Layer
+--- Cache + disk persistence with lazy loading
+
+local utils = require("codetyper.support.utils")
+local types = require("codetyper.core.memory.types")
+
+local M = {}
+
+--- In-memory cache keyed by project root
+---@type table<string, table>
+local cache = {}
+
+--- Dirty flags for pending writes
+---@type table<string, table<string, boolean>>
+local dirty = {}
+
+--- Debounce timers
+---@type table<string, userdata>
+local timers = {}
+
+local DEBOUNCE_MS = 500
+
+--- Get brain directory path for current project
+---@param root? string Project root (defaults to current)
+---@return string Brain directory path
+function M.get_brain_dir(root)
+  root = root or utils.get_project_root()
+  return root .. "/.coder/brain"
+end
+
+--- Ensure brain directory structure exists
+---@param root? string Project root
+---@return boolean Success
+function M.ensure_dirs(root)
+  local brain_dir = M.get_brain_dir(root)
+  local dirs = {
+    brain_dir,
+    brain_dir .. "/nodes",
+    brain_dir .. "/indices",
+    brain_dir .. "/deltas",
+    brain_dir .. "/deltas/objects",
+  }
+  for _, dir in ipairs(dirs) do
+    if not utils.ensure_dir(dir) then
+      return false
+    end
+  end
+  return true
+end
+
+--- Get file path for a storage key
+---@param key string Storage key (e.g., "meta", "nodes.patterns", "deltas.objects.abc123")
+---@param root? string Project root
+---@return string File path
+function M.get_path(key, root)
+  local brain_dir = M.get_brain_dir(root)
+  local parts = vim.split(key, ".", { plain = true })
+
+  if #parts == 1 then
+    return brain_dir .. "/" .. key .. ".json"
+  elseif #parts == 2 then
+    return brain_dir .. "/" .. parts[1] .. "/" .. parts[2] .. ".json"
+  else
+    return brain_dir .. "/" .. table.concat(parts, "/") .. ".json"
+  end
+end
+
+--- Get cache for project
+---@param root? string Project root
+---@return table Project cache
+local function get_cache(root)
+  root = root or utils.get_project_root()
+  if not cache[root] then
+    cache[root] = {}
+    dirty[root] = {}
+  end
+  return cache[root]
+end
+
+--- Read JSON from disk
+---@param filepath string File path
+---@return table|nil Data or nil on error
+local function read_json(filepath)
+  local content = utils.read_file(filepath)
+  if not content or content == "" then
+    return nil
+  end
+  local ok, data = pcall(vim.json.decode, content)
+  if not ok then
+    return nil
+  end
+  return data
+end
+
+--- Write JSON to disk
+---@param filepath string File path
+---@param data table Data to write
+---@return boolean Success
+local function write_json(filepath, data)
+  local ok, json = pcall(vim.json.encode, data)
+  if not ok then
+    return false
+  end
+  return utils.write_file(filepath, json)
+end
+
+--- Load data from disk into cache
+---@param key string Storage key
+---@param root? string Project root
+---@return table|nil Data or nil
+function M.load(key, root)
+  root = root or utils.get_project_root()
+  local project_cache = get_cache(root)
+
+  -- Return cached if available
+  if project_cache[key] ~= nil then
+    return project_cache[key]
+  end
+
+  -- Load from disk
+  local filepath = M.get_path(key, root)
+  local data = read_json(filepath)
+
+  -- Cache the result (even nil to avoid repeated reads)
+  project_cache[key] = data or {}
+
+  return project_cache[key]
+end
+
+--- Save data to cache and schedule disk write
+---@param key string Storage key
+---@param data table Data to save
+---@param root? string Project root
+---@param immediate? boolean Skip debounce
+function M.save(key, data, root, immediate)
+  root = root or utils.get_project_root()
+  local project_cache = get_cache(root)
+
+  -- Update cache
+  project_cache[key] = data
+  dirty[root][key] = true
+
+  if immediate then
+    M.flush(key, root)
+    return
+  end
+
+  -- Debounced write
+  local timer_key = root .. ":" .. key
+  if timers[timer_key] then
+    timers[timer_key]:stop()
+  end
+
+  timers[timer_key] = vim.defer_fn(function()
+    M.flush(key, root)
+    timers[timer_key] = nil
+  end, DEBOUNCE_MS)
+end
+
+--- Flush a key to disk immediately
+---@param key string Storage key
+---@param root? string Project root
+---@return boolean Success
+function M.flush(key, root)
+  root = root or utils.get_project_root()
+  local project_cache = get_cache(root)
+
+  if not dirty[root][key] then
+    return true
+  end
+
+  M.ensure_dirs(root)
+  local filepath = M.get_path(key, root)
+  local data = project_cache[key]
+
+  if data == nil then
+    -- Delete file if data is nil
+    os.remove(filepath)
+    dirty[root][key] = nil
+    return true
+  end
+
+  local success = write_json(filepath, data)
+  if success then
+    dirty[root][key] = nil
+  end
+  return success
+end
+
+--- Flush all dirty keys to disk
+---@param root? string Project root
+function M.flush_all(root)
+  root = root or utils.get_project_root()
+  if not dirty[root] then
+    return
+  end
+
+  for key, is_dirty in pairs(dirty[root]) do
+    if is_dirty then
+      M.flush(key, root)
+    end
+  end
+end
+
+--- Get meta.json data
+---@param root? string Project root
+---@return GraphMeta
+function M.get_meta(root)
+  local meta = M.load("meta", root)
+  if not meta or not meta.v then
+    meta = {
+      v = types.SCHEMA_VERSION,
+      head = nil,
+      nc = 0,
+      ec = 0,
+      dc = 0,
+    }
+    M.save("meta", meta, root)
+  end
+  return meta
+end
+
+--- Update meta.json
+---@param updates table Partial updates
+---@param root? string Project root
+function M.update_meta(updates, root)
+  local meta = M.get_meta(root)
+  for k, v in pairs(updates) do
+    meta[k] = v
+  end
+  M.save("meta", meta, root)
+end
+
+--- Get nodes by type
+---@param node_type string Node type (e.g., "patterns", "corrections")
+---@param root? string Project root
+---@return table<string, Node> Nodes indexed by ID
+function M.get_nodes(node_type, root)
+  return M.load("nodes." .. node_type, root) or {}
+end
+
+--- Save nodes by type
+---@param node_type string Node type
+---@param nodes table<string, Node> Nodes indexed by ID
+---@param root? string Project root
+function M.save_nodes(node_type, nodes, root)
+  M.save("nodes." .. node_type, nodes, root)
+end
+
+--- Get graph adjacency
+---@param root? string Project root
+---@return Graph Graph data
+function M.get_graph(root)
+  local graph = M.load("graph", root)
+  if not graph or not graph.adj then
+    graph = {
+      adj = {},
+      radj = {},
+    }
+    M.save("graph", graph, root)
+  end
+  return graph
+end
+
+--- Save graph
+---@param graph Graph Graph data
+---@param root? string Project root
+function M.save_graph(graph, root)
+  M.save("graph", graph, root)
+end
+
+--- Get index by type
+---@param index_type string Index type (e.g., "by_file", "by_time")
+---@param root? string Project root
+---@return table Index data
+function M.get_index(index_type, root)
+  return M.load("indices." .. index_type, root) or {}
+end
+
+--- Save index
+---@param index_type string Index type
+---@param data table Index data
+---@param root? string Project root
+function M.save_index(index_type, data, root)
+  M.save("indices." .. index_type, data, root)
+end
+
+--- Get delta by hash
+---@param hash string Delta hash
+---@param root? string Project root
+---@return Delta|nil Delta data
+function M.get_delta(hash, root)
+  return M.load("deltas.objects." .. hash, root)
+end
+
+--- Save delta
+---@param delta Delta Delta data
+---@param root? string Project root
+function M.save_delta(delta, root)
+  M.save("deltas.objects." .. delta.h, delta, root, true) -- Immediate write for deltas
+end
+
+--- Get HEAD delta hash
+---@param root? string Project root
+---@return string|nil HEAD hash
+function M.get_head(root)
+  local meta = M.get_meta(root)
+  return meta.head
+end
+
+--- Set HEAD delta hash
+---@param hash string|nil Delta hash
+---@param root? string Project root
+function M.set_head(hash, root)
+  M.update_meta({ head = hash }, root)
+end
+
+--- Clear all caches (for testing)
+function M.clear_cache()
+  cache = {}
+  dirty = {}
+  for _, timer in pairs(timers) do
+    if timer then
+      timer:stop()
+    end
+  end
+  timers = {}
+end
+
+--- Check if brain exists for project
+---@param root? string Project root
+---@return boolean
+function M.exists(root)
+  local brain_dir = M.get_brain_dir(root)
+  return vim.fn.isdirectory(brain_dir) == 1
+end
+
+return M
--- a/lua/codetyper/core/memory/types.lua
+++ b/lua/codetyper/core/memory/types.lua
@@ -0,0 +1,175 @@
+---@meta
+--- Brain Learning System Type Definitions
+--- Optimized for LLM consumption with compact field names
+
+local M = {}
+
+---@alias NodeType "pat"|"cor"|"dec"|"con"|"fbk"|"ses"
+-- pat = pattern, cor = correction, dec = decision
+-- con = convention, fbk = feedback, ses = session
+
+---@alias EdgeType "sem"|"file"|"temp"|"caus"|"sup"
+-- sem = semantic, file = file-based, temp = temporal
+-- caus = causal, sup = supersedes
+
+---@alias DeltaOp "add"|"mod"|"del"
+
+---@class NodeContent
+---@field s string Summary (max 200 chars)
+---@field d string Detail (full description)
+---@field code? string Optional code snippet
+---@field lang? string Language identifier
+
+---@class NodeContext
+---@field f? string File path (relative)
+---@field fn? string Function name
+---@field ln? number[] Line range [start, end]
+---@field sym? string[] Symbol references
+
+---@class NodeScores
+---@field w number Weight (0-1)
+---@field u number Usage count
+---@field sr number Success rate (0-1)
+
+---@class NodeTimestamps
+---@field cr number Created (unix timestamp)
+---@field up number Updated (unix timestamp)
+---@field lu? number Last used (unix timestamp)
+
+---@class NodeMeta
+---@field src "auto"|"user"|"llm" Source of learning
+---@field v number Version number
+---@field dr? string[] Delta references
+
+---@class Node
+---@field id string Unique identifier (n_<timestamp>_<hash>)
+---@field t NodeType Node type
+---@field h string Content hash (8 chars)
+---@field c NodeContent Content
+---@field ctx NodeContext Context
+---@field sc NodeScores Scores
+---@field ts NodeTimestamps Timestamps
+---@field m? NodeMeta Metadata
+
+---@class EdgeProps
+---@field w number Weight (0-1)
+---@field dir "bi"|"fwd"|"bwd" Direction
+---@field r? string Reason/description
+
+---@class Edge
+---@field id string Unique identifier (e_<source>_<target>)
+---@field s string Source node ID
+---@field t string Target node ID
+---@field ty EdgeType Edge type
+---@field p EdgeProps Properties
+---@field ts number Created timestamp
+
+---@class DeltaChange
+---@field op DeltaOp Operation type
+---@field path string JSON path (e.g., "nodes.pat.n_123")
+---@field bh? string Before hash
+---@field ah? string After hash
+---@field diff? table Field-level diff
+
+---@class DeltaMeta
+---@field msg string Commit message
+---@field trig string Trigger source
+---@field sid? string Session ID
+
+---@class Delta
+---@field h string Hash (8 chars)
+---@field p? string Parent hash
+---@field ts number Timestamp
+---@field ch DeltaChange[] Changes
+---@field m DeltaMeta Metadata
+
+---@class GraphMeta
+---@field v number Schema version
+---@field head? string Current HEAD delta hash
+---@field nc number Node count
+---@field ec number Edge count
+---@field dc number Delta count
+
+---@class AdjacencyEntry
+---@field sem? string[] Semantic edges
+---@field file? string[] File edges
+---@field temp? string[] Temporal edges
+---@field caus? string[] Causal edges
+---@field sup? string[] Supersedes edges
+
+---@class Graph
+---@field meta GraphMeta Metadata
+---@field adj table<string, AdjacencyEntry> Adjacency list
+---@field radj table<string, AdjacencyEntry> Reverse adjacency
+
+---@class QueryOpts
+---@field query? string Text query
+---@field file? string File path filter
+---@field types? NodeType[] Node types to include
+---@field since? number Timestamp filter
+---@field limit? number Max results
+---@field depth? number Traversal depth
+---@field max_tokens? number Token budget
+
+---@class QueryResult
+---@field nodes Node[] Matched nodes
+---@field edges Edge[] Related edges
+---@field stats table Query statistics
+---@field truncated boolean Whether results were truncated
+
+---@class LLMContext
+---@field schema string Schema version
+---@field query string Original query
+---@field learnings table[] Compact learning entries
+---@field connections table[] Connection summaries
+---@field tokens number Estimated token count
+
+---@class LearnEvent
+---@field type string Event type
+---@field data table Event data
+---@field file? string Related file
+---@field timestamp number Event timestamp
+
+---@class BrainConfig
+---@field enabled boolean Enable brain system
+---@field auto_learn boolean Auto-learn from events
+---@field auto_commit boolean Auto-commit after threshold
+---@field commit_threshold number Changes before auto-commit
+---@field max_nodes number Max nodes before pruning
+---@field max_deltas number Max delta history
+---@field prune table Pruning config
+---@field output table Output config
+
+-- Type constants for runtime use
+M.NODE_TYPES = {
+  PATTERN = "pat",
+  CORRECTION = "cor",
+  DECISION = "dec",
+  CONVENTION = "con",
+  FEEDBACK = "fbk",
+  SESSION = "ses",
+}
+
+M.EDGE_TYPES = {
+  SEMANTIC = "sem",
+  FILE = "file",
+  TEMPORAL = "temp",
+  CAUSAL = "caus",
+  SUPERSEDES = "sup",
+}
+
+M.DELTA_OPS = {
+  ADD = "add",
+  MODIFY = "mod",
+  DELETE = "del",
+}
+
+M.SOURCES = {
+  AUTO = "auto",
+  USER = "user",
+  LLM = "llm",
+}
+
+M.SCHEMA_VERSION = 1
+
+return M
--- a/lua/codetyper/core/scheduler/executor.lua
+++ b/lua/codetyper/core/scheduler/executor.lua
@@ -0,0 +1,616 @@
+---@mod codetyper.agent.executor Tool executor for agent system
+---
+--- Executes tools requested by the LLM and returns results.
+
+local M = {}
+local utils = require("codetyper.support.utils")
+local logs = require("codetyper.adapters.nvim.ui.logs")
+
+---@class ExecutionResult
+---@field success boolean Whether the execution succeeded
+---@field result string Result message or content
+---@field requires_approval boolean Whether user approval is needed
+---@field diff_data? DiffData Data for diff preview (if requires_approval)
+
+--- Open a file in a buffer (in a non-agent window)
+---@param path string File path to open
+---@param jump_to_line? number Optional line number to jump to
+local function open_file_in_buffer(path, jump_to_line)
+  if not path or path == "" then
+    return
+  end
+
+  -- Check if file exists
+  if vim.fn.filereadable(path) ~= 1 then
+    return
+  end
+
+  vim.schedule(function()
+    -- Find a suitable window (not the agent UI windows)
+    local target_win = nil
+    local agent_ui_ok, agent_ui = pcall(require, "codetyper.agent.ui")
+
+    for _, win in ipairs(vim.api.nvim_list_wins()) do
+      local buf = vim.api.nvim_win_get_buf(win)
+      local buftype = vim.bo[buf].buftype
+
+      -- Skip special buffers (agent UI, nofile, etc.)
+      if buftype == "" or buftype == "acwrite" then
+        -- Check if this is not an agent UI window
+        local is_agent_win = false
+        if agent_ui_ok and agent_ui.is_open() then
+          -- Skip agent windows by checking if it's one of our special buffers
+          local bufname = vim.api.nvim_buf_get_name(buf)
+          if bufname == "" then
+            -- Could be agent buffer, check by buffer option
+            is_agent_win = vim.bo[buf].buftype == "nofile"
+          end
+        end
+
+        if not is_agent_win then
+          target_win = win
+          break
+        end
+      end
+    end
+
+    -- If no suitable window found, create a new split
+    if not target_win then
+      -- Get the rightmost non-agent window or create one
+      vim.cmd("rightbelow vsplit")
+      target_win = vim.api.nvim_get_current_win()
+    end
+
+    -- Open the file in the target window
+    vim.api.nvim_set_current_win(target_win)
+    vim.cmd("edit " .. vim.fn.fnameescape(path))
+
+    -- Jump to line if specified
+    if jump_to_line and jump_to_line > 0 then
+      local line_count = vim.api.nvim_buf_line_count(0)
+      local target_line = math.min(jump_to_line, line_count)
+      vim.api.nvim_win_set_cursor(target_win, { target_line, 0 })
+      vim.cmd("normal! zz")
+    end
+  end)
+end
+
+--- Expose open_file_in_buffer for external use
+M.open_file_in_buffer = open_file_in_buffer
+
+---@class DiffData
+---@field path string File path
+---@field original string Original content
+---@field modified string Modified content
+---@field operation string Operation type: "edit", "create", "overwrite", "bash"
+
+--- Execute a tool and return result via callback
+---@param tool_name string Name of the tool to execute
+---@param parameters table Tool parameters
+---@param callback fun(result: ExecutionResult) Callback with result
+function M.execute(tool_name, parameters, callback)
+  local handlers = {
+    read_file = M.handle_read_file,
+    edit_file = M.handle_edit_file,
+    write_file = M.handle_write_file,
+    bash = M.handle_bash,
+    delete_file = M.handle_delete_file,
+    list_directory = M.handle_list_directory,
+    search_files = M.handle_search_files,
+  }
+
+  local handler = handlers[tool_name]
+  if not handler then
+    callback({
+      success = false,
+      result = "Unknown tool: " .. tool_name,
+      requires_approval = false,
+    })
+    return
+  end
+
+  handler(parameters, callback)
+end
+
+--- Handle read_file tool
+---@param params table { path: string }
+---@param callback fun(result: ExecutionResult)
+function M.handle_read_file(params, callback)
+  local path = M.resolve_path(params.path)
+
+  -- Log the read operation in Claude Code style
+  local relative_path = vim.fn.fnamemodify(path, ":~:.")
+  logs.read(relative_path)
+
+  local content = utils.read_file(path)
+
+  if content then
+    -- Log how many lines were read
+    local lines = vim.split(content, "\n", { plain = true })
+    logs.add({ type = "result", message = string.format("  ⎿  Read %d lines", #lines) })
+
+    -- Open the file in a buffer so user can see it
+    open_file_in_buffer(path)
+
+    callback({
+      success = true,
+      result = content,
+      requires_approval = false,
+    })
+  else
+    logs.add({ type = "error", message = "  ⎿  File not found" })
+    callback({
+      success = false,
+      result = "Could not read file: " .. path,
+      requires_approval = false,
+    })
+  end
+end
+
+--- Handle edit_file tool
+---@param params table { path: string, find: string, replace: string }
+---@param callback fun(result: ExecutionResult)
+function M.handle_edit_file(params, callback)
+  local path = M.resolve_path(params.path)
+  local relative_path = vim.fn.fnamemodify(path, ":~:.")
+
+  -- Log the edit operation
+  logs.add({ type = "action", message = string.format("Edit(%s)", relative_path) })
+
+  local original = utils.read_file(path)
+
+  if not original then
+    logs.add({ type = "error", message = "  ⎿  File not found" })
+    callback({
+      success = false,
+      result = "File not found: " .. path,
+      requires_approval = false,
+    })
+    return
+  end
+
+  -- Try to find and replace the content
+  local escaped_find = utils.escape_pattern(params.find)
+  local new_content, count = original:gsub(escaped_find, params.replace, 1)
+
+  if count == 0 then
+    logs.add({ type = "error", message = "  ⎿  Content not found" })
+    callback({
+      success = false,
+      result = "Could not find content to replace in: " .. path,
+      requires_approval = false,
+    })
+    return
+  end
+
+  -- Calculate lines changed
+  local original_lines = #vim.split(original, "\n", { plain = true })
+  local new_lines = #vim.split(new_content, "\n", { plain = true })
+  local diff = new_lines - original_lines
+  if diff > 0 then
+    logs.add({ type = "result", message = string.format("  ⎿  +%d lines (pending approval)", diff) })
+  elseif diff < 0 then
+    logs.add({ type = "result", message = string.format("  ⎿  %d lines (pending approval)", diff) })
+  else
+    logs.add({ type = "result", message = "  ⎿  Modified (pending approval)" })
+  end
+
+  -- Requires user approval - show diff
+  callback({
+    success = true,
+    result = "Edit prepared for: " .. path,
+    requires_approval = true,
+    diff_data = {
+      path = path,
+      original = original,
+      modified = new_content,
+      operation = "edit",
+    },
+  })
+end
+
+--- Handle write_file tool
+---@param params table { path: string, content: string }
+---@param callback fun(result: ExecutionResult)
+function M.handle_write_file(params, callback)
+  local path = M.resolve_path(params.path)
+  local relative_path = vim.fn.fnamemodify(path, ":~:.")
+  local original = utils.read_file(path) or ""
+  local operation = original == "" and "create" or "overwrite"
+
+  -- Log the write operation
+  if operation == "create" then
+    logs.add({ type = "action", message = string.format("Write(%s)", relative_path) })
+    local new_lines = #vim.split(params.content, "\n", { plain = true })
+    logs.add({ type = "result", message = string.format("  ⎿  New file (%d lines, pending approval)", new_lines) })
+  else
+    logs.add({ type = "action", message = string.format("Update(%s)", relative_path) })
+    local original_lines = #vim.split(original, "\n", { plain = true })
+    local new_lines = #vim.split(params.content, "\n", { plain = true })
+    local diff = new_lines - original_lines
+    if diff > 0 then
+      logs.add({ type = "result", message = string.format("  ⎿  +%d lines (pending approval)", diff) })
+    elseif diff < 0 then
+      logs.add({ type = "result", message = string.format("  ⎿  %d lines (pending approval)", diff) })
+    else
+      logs.add({ type = "result", message = "  ⎿  Modified (pending approval)" })
+    end
+  end
+
+  -- Ensure parent directory exists
+  local dir = vim.fn.fnamemodify(path, ":h")
+  if dir ~= "" and dir ~= "." then
+    utils.ensure_dir(dir)
+  end
+
+  callback({
+    success = true,
+    result = (operation == "create" and "Create" or "Overwrite") .. " prepared for: " .. path,
+    requires_approval = true,
+    diff_data = {
+      path = path,
+      original = original,
+      modified = params.content,
+      operation = operation,
+    },
+  })
+end
+
+--- Handle bash tool
+---@param params table { command: string, timeout?: number }
+---@param callback fun(result: ExecutionResult)
+function M.handle_bash(params, callback)
+  local command = params.command
+
+  -- Log the bash operation
+  logs.add({ type = "action", message = string.format("Bash(%s)", command:sub(1, 50) .. (#command > 50 and "..." or "")) })
+  logs.add({ type = "result", message = "  ⎿  Pending approval" })
+
+  -- Requires user approval first
+  callback({
+    success = true,
+    result = "Command: " .. command,
+    requires_approval = true,
+    diff_data = {
+      path = "[bash]",
+      original = "",
+      modified = "$ " .. command,
+      operation = "bash",
+    },
+    bash_command = command,
+    bash_timeout = params.timeout or 30000,
+  })
+end
+
+--- Handle delete_file tool
+---@param params table { path: string, reason: string }
+---@param callback fun(result: ExecutionResult)
+function M.handle_delete_file(params, callback)
+  local path = M.resolve_path(params.path)
+  local reason = params.reason or "No reason provided"
+
+  -- Check if file exists
+  if not utils.file_exists(path) then
+    callback({
+      success = false,
+      result = "File not found: " .. path,
+      requires_approval = false,
+    })
+    return
+  end
+
+  -- Read content for showing in diff (so user knows what they're deleting)
+  local content = utils.read_file(path) or "[Could not read file]"
+
+  callback({
+    success = true,
+    result = "Delete: " .. path .. " (" .. reason .. ")",
+    requires_approval = true,
+    diff_data = {
+      path = path,
+      original = content,
+      modified = "", -- Empty = deletion
+      operation = "delete",
+      reason = reason,
+    },
+  })
+end
+
+--- Handle list_directory tool
+---@param params table { path?: string, recursive?: boolean }
+---@param callback fun(result: ExecutionResult)
+function M.handle_list_directory(params, callback)
+  local path = params.path and M.resolve_path(params.path) or (utils.get_project_root() or vim.fn.getcwd())
+  local recursive = params.recursive or false
+
+  -- Use vim.fn.readdir or glob for directory listing
+  local entries = {}
+  local function list_dir(dir, depth)
+    if depth > 3 then
+      return
+    end
+
+    local ok, files = pcall(vim.fn.readdir, dir)
+    if not ok or not files then
+      return
+    end
+
+    for _, name in ipairs(files) do
+      if name ~= "." and name ~= ".." and not name:match("^%.git$") and not name:match("^node_modules$") then
+        local full_path = dir .. "/" .. name
+        local stat = vim.loop.fs_stat(full_path)
+        if stat then
+          local prefix = string.rep("  ", depth)
+          local type_indicator = stat.type == "directory" and "/" or ""
+          table.insert(entries, prefix .. name .. type_indicator)
+
+          if recursive and stat.type == "directory" then
+            list_dir(full_path, depth + 1)
+          end
+        end
+      end
+    end
+  end
+
+  list_dir(path, 0)
+
+  local result = "Directory: " .. path .. "\n\n" .. table.concat(entries, "\n")
+
+  callback({
+    success = true,
+    result = result,
+    requires_approval = false,
+  })
+end
+
+--- Handle search_files tool
+---@param params table { pattern?: string, content?: string, path?: string }
+---@param callback fun(result: ExecutionResult)
+function M.handle_search_files(params, callback)
+  local search_path = params.path and M.resolve_path(params.path) or (utils.get_project_root() or vim.fn.getcwd())
+  local pattern = params.pattern
+  local content_search = params.content
+
+  local results = {}
+
+  if pattern then
+    -- Search by file name pattern using glob
+    local glob_pattern = search_path .. "/**/" .. pattern
+    local files = vim.fn.glob(glob_pattern, false, true)
+
+    for _, file in ipairs(files) do
+      -- Skip common ignore patterns
+      if not file:match("node_modules") and not file:match("%.git/") then
+        local relative = file:gsub(search_path .. "/", "")
+        table.insert(results, relative)
+      end
+    end
+  end
+
+  if content_search then
+    -- Search by content using grep
+    local grep_results = {}
+    local grep_cmd = string.format("grep -rl '%s' '%s' 2>/dev/null | head -20", content_search:gsub("'", "\\'"), search_path)
+
+    local handle = io.popen(grep_cmd)
+    if handle then
+      for line in handle:lines() do
+        if not line:match("node_modules") and not line:match("%.git/") then
+          local relative = line:gsub(search_path .. "/", "")
+          table.insert(grep_results, relative)
+        end
+      end
+      handle:close()
+    end
+
+    -- Merge with pattern results or use as primary results
+    if #results == 0 then
+      results = grep_results
+    else
+      -- Intersection of pattern and content results
+      local pattern_set = {}
+      for _, f in ipairs(results) do
+        pattern_set[f] = true
+      end
+      results = {}
+      for _, f in ipairs(grep_results) do
+        if pattern_set[f] then
+          table.insert(results, f)
+        end
+      end
+    end
+  end
+
+  local result_text = "Search results"
+  if pattern then
+    result_text = result_text .. " (pattern: " .. pattern .. ")"
+  end
+  if content_search then
+    result_text = result_text .. " (content: " .. content_search .. ")"
+  end
+  result_text = result_text .. ":\n\n"
+
+  if #results == 0 then
+    result_text = result_text .. "No files found."
+  else
+    result_text = result_text .. table.concat(results, "\n")
+  end
+
+  callback({
+    success = true,
+    result = result_text,
+    requires_approval = false,
+  })
+end
+
+--- Actually apply an approved change
+---@param diff_data DiffData The diff data to apply
+---@param callback fun(result: ExecutionResult)
+function M.apply_change(diff_data, callback)
+  if diff_data.operation == "bash" then
+    -- Extract command from modified (remove "$ " prefix)
+    local command = diff_data.modified:gsub("^%$ ", "")
+    M.execute_bash_command(command, 30000, callback)
+  elseif diff_data.operation == "delete" then
+    -- Delete file
+    local ok, err = os.remove(diff_data.path)
+    if ok then
+      -- Close buffer if it's open
+      M.close_buffer_if_open(diff_data.path)
+      callback({
+        success = true,
+        result = "Deleted: " .. diff_data.path,
+        requires_approval = false,
+      })
+    else
+      callback({
+        success = false,
+        result = "Failed to delete: " .. diff_data.path .. " (" .. (err or "unknown error") .. ")",
+        requires_approval = false,
+      })
+    end
+  else
+    -- Write file
+    local success = utils.write_file(diff_data.path, diff_data.modified)
+    if success then
+      -- Open and/or reload buffer so user can see the changes
+      open_file_in_buffer(diff_data.path)
+      M.reload_buffer_if_open(diff_data.path)
+      callback({
+        success = true,
+        result = "Changes applied to: " .. diff_data.path,
+        requires_approval = false,
+      })
+    else
+      callback({
+        success = false,
+        result = "Failed to write: " .. diff_data.path,
+        requires_approval = false,
+      })
+    end
+  end
+end
+
+--- Execute a bash command
+---@param command string Command to execute
+---@param timeout number Timeout in milliseconds
+---@param callback fun(result: ExecutionResult)
+function M.execute_bash_command(command, timeout, callback)
+  local stdout_data = {}
+  local stderr_data = {}
+  local job_id
+
+  job_id = vim.fn.jobstart(command, {
+    stdout_buffered = true,
+    stderr_buffered = true,
+    on_stdout = function(_, data)
+      if data then
+        for _, line in ipairs(data) do
+          if line ~= "" then
+            table.insert(stdout_data, line)
+          end
+        end
+      end
+    end,
+    on_stderr = function(_, data)
+      if data then
+        for _, line in ipairs(data) do
+          if line ~= "" then
+            table.insert(stderr_data, line)
+          end
+        end
+      end
+    end,
+    on_exit = function(_, exit_code)
+      vim.schedule(function()
+        local result = table.concat(stdout_data, "\n")
+        if #stderr_data > 0 then
+          if result ~= "" then
+            result = result .. "\n"
+          end
+          result = result .. "STDERR:\n" .. table.concat(stderr_data, "\n")
+        end
+        result = result .. "\n[Exit code: " .. exit_code .. "]"
+
+        callback({
+          success = exit_code == 0,
+          result = result,
+          requires_approval = false,
+        })
+      end)
+    end,
+  })
+
+  -- Set up timeout
+  if job_id > 0 then
+    vim.defer_fn(function()
+      if vim.fn.jobwait({ job_id }, 0)[1] == -1 then
+        vim.fn.jobstop(job_id)
+        vim.schedule(function()
+          callback({
+            success = false,
+            result = "Command timed out after " .. timeout .. "ms",
+            requires_approval = false,
+          })
+        end)
+      end
+    end, timeout)
+  else
+    callback({
+      success = false,
+      result = "Failed to start command",
+      requires_approval = false,
+    })
+  end
+end
+
+--- Reload a buffer if it's currently open
+---@param filepath string Path to the file
+function M.reload_buffer_if_open(filepath)
+  local full_path = vim.fn.fnamemodify(filepath, ":p")
+  for _, buf in ipairs(vim.api.nvim_list_bufs()) do
+    if vim.api.nvim_buf_is_loaded(buf) then
+      local buf_name = vim.api.nvim_buf_get_name(buf)
+      if buf_name == full_path then
+        vim.api.nvim_buf_call(buf, function()
+          vim.cmd("edit!")
+        end)
+        break
+      end
+    end
+  end
+end
+
+--- Close a buffer if it's currently open (for deleted files)
+---@param filepath string Path to the file
+function M.close_buffer_if_open(filepath)
+  local full_path = vim.fn.fnamemodify(filepath, ":p")
+  for _, buf in ipairs(vim.api.nvim_list_bufs()) do
+    if vim.api.nvim_buf_is_loaded(buf) then
+      local buf_name = vim.api.nvim_buf_get_name(buf)
+      if buf_name == full_path then
+        -- Force close the buffer
+        pcall(vim.api.nvim_buf_delete, buf, { force = true })
+        break
+      end
+    end
+  end
+end
+
+--- Resolve a path (expand ~ and make absolute if needed)
+---@param path string Path to resolve
+---@return string Resolved path
+function M.resolve_path(path)
+  -- Expand ~ to home directory
+  local expanded = vim.fn.expand(path)
+
+  -- If relative, make it relative to project root or cwd
+  if not vim.startswith(expanded, "/") then
+    local root = utils.get_project_root() or vim.fn.getcwd()
+    expanded = root .. "/" .. expanded
+  end
+
+  return vim.fn.fnamemodify(expanded, ":p")
+end
+
+return M
--- a/lua/codetyper/core/scheduler/loop.lua
+++ b/lua/codetyper/core/scheduler/loop.lua
@@ -0,0 +1,381 @@
+---@mod codetyper.agent.loop Agent loop with tool orchestration
+---@brief [[
+--- Main agent loop that handles multi-turn conversations with tool use.
+--- Agent execution loop with tool calling support.
+---@brief ]]
+
+local M = {}
+
+local prompts = require("codetyper.prompts.agents.loop")
+
+---@class AgentMessage
+---@field role "system"|"user"|"assistant"|"tool"
+---@field content string|table
+---@field tool_call_id? string For tool responses
+---@field tool_calls? table[] For assistant tool calls
+---@field name? string Tool name for tool responses
+
+---@class AgentLoopOpts
+---@field system_prompt string System prompt
+---@field user_input string Initial user message
+---@field tools? CoderTool[] Available tools (default: all registered)
+---@field max_iterations? number Max tool call iterations (default: 10)
+---@field provider? string LLM provider to use
+---@field on_start? fun() Called when loop starts
+---@field on_chunk? fun(chunk: string) Called for each response chunk
+---@field on_tool_call? fun(name: string, input: table) Called before tool execution
+---@field on_tool_result? fun(name: string, result: any, error: string|nil) Called after tool execution
+---@field on_message? fun(message: AgentMessage) Called for each message added
+---@field on_complete? fun(result: string|nil, error: string|nil) Called when loop completes
+---@field session_ctx? table Session context shared across tools
+
+--- Format tool definitions for OpenAI-compatible API
+---@param tools CoderTool[]
+---@return table[]
+local function format_tools_for_api(tools)
+	local formatted = {}
+	for _, tool in ipairs(tools) do
+		local properties = {}
+		local required = {}
+
+		for _, param in ipairs(tool.params or {}) do
+			properties[param.name] = {
+				type = param.type == "integer" and "number" or param.type,
+				description = param.description,
+			}
+			if not param.optional then
+				table.insert(required, param.name)
+			end
+		end
+
+		table.insert(formatted, {
+			type = "function",
+			["function"] = {
+				name = tool.name,
+				description = type(tool.description) == "function" and tool.description() or tool.description,
+				parameters = {
+					type = "object",
+					properties = properties,
+					required = required,
+				},
+			},
+		})
+	end
+	return formatted
+end
+
+--- Parse tool calls from LLM response
+---@param response table LLM response
+---@return table[] tool_calls
+local function parse_tool_calls(response)
+	local tool_calls = {}
+
+	-- Handle different response formats
+	if response.tool_calls then
+		-- OpenAI format
+		for _, call in ipairs(response.tool_calls) do
+			local args = call["function"].arguments
+			if type(args) == "string" then
+				local ok, parsed = pcall(vim.json.decode, args)
+				if ok then
+					args = parsed
+				end
+			end
+			table.insert(tool_calls, {
+				id = call.id,
+				name = call["function"].name,
+				input = args,
+			})
+		end
+	elseif response.content and type(response.content) == "table" then
+		-- Claude format (content blocks)
+		for _, block in ipairs(response.content) do
+			if block.type == "tool_use" then
+				table.insert(tool_calls, {
+					id = block.id,
+					name = block.name,
+					input = block.input,
+				})
+			end
+		end
+	end
+
+	return tool_calls
+end
+
+--- Build messages for LLM request
+---@param history AgentMessage[]
+---@return table[]
+local function build_messages(history)
+	local messages = {}
+
+	for _, msg in ipairs(history) do
+		if msg.role == "system" then
+			table.insert(messages, {
+				role = "system",
+				content = msg.content,
+			})
+		elseif msg.role == "user" then
+			table.insert(messages, {
+				role = "user",
+				content = msg.content,
+			})
+		elseif msg.role == "assistant" then
+			local message = {
+				role = "assistant",
+				content = msg.content,
+			}
+			if msg.tool_calls then
+				message.tool_calls = msg.tool_calls
+			end
+			table.insert(messages, message)
+		elseif msg.role == "tool" then
+			table.insert(messages, {
+				role = "tool",
+				tool_call_id = msg.tool_call_id,
+				content = type(msg.content) == "string" and msg.content or vim.json.encode(msg.content),
+			})
+		end
+	end
+
+	return messages
+end
+
+--- Execute the agent loop
+---@param opts AgentLoopOpts
+function M.run(opts)
+	local tools_mod = require("codetyper.core.tools")
+	local llm = require("codetyper.core.llm")
+
+	-- Get tools
+	local tools = opts.tools or tools_mod.list()
+	local tool_map = {}
+	for _, tool in ipairs(tools) do
+		tool_map[tool.name] = tool
+	end
+
+	-- Initialize conversation history
+	---@type AgentMessage[]
+	local history = {
+		{ role = "system", content = opts.system_prompt },
+		{ role = "user", content = opts.user_input },
+	}
+
+	local session_ctx = opts.session_ctx or {}
+	local max_iterations = opts.max_iterations or 10
+	local iteration = 0
+
+	-- Callback wrappers
+	local function on_message(msg)
+		if opts.on_message then
+			opts.on_message(msg)
+		end
+	end
+
+	-- Notify of initial messages
+	for _, msg in ipairs(history) do
+		on_message(msg)
+	end
+
+	-- Start notification
+	if opts.on_start then
+		opts.on_start()
+	end
+
+	--- Process one iteration of the loop
+	local function process_iteration()
+		iteration = iteration + 1
+
+		if iteration > max_iterations then
+			if opts.on_complete then
+				opts.on_complete(nil, "Max iterations reached")
+			end
+			return
+		end
+
+		-- Build request
+		local messages = build_messages(history)
+		local formatted_tools = format_tools_for_api(tools)
+
+		-- Build context for LLM
+		local context = {
+			file_content = "",
+			language = "lua",
+			extension = "lua",
+			prompt_type = "agent",
+			tools = formatted_tools,
+		}
+
+		-- Get LLM response
+		local client = llm.get_client()
+		if not client then
+			if opts.on_complete then
+				opts.on_complete(nil, "No LLM client available")
+			end
+			return
+		end
+
+		-- Build prompt from messages
+		local prompt_parts = {}
+		for _, msg in ipairs(messages) do
+			if msg.role ~= "system" then
+				table.insert(prompt_parts, string.format("[%s]: %s", msg.role, msg.content or ""))
+			end
+		end
+		local prompt = table.concat(prompt_parts, "\n\n")
+
+		client.generate(prompt, context, function(response, error)
+			if error then
+				if opts.on_complete then
+					opts.on_complete(nil, error)
+				end
+				return
+			end
+
+			-- Chunk callback
+			if opts.on_chunk then
+				opts.on_chunk(response)
+			end
+
+			-- Parse response for tool calls
+			-- For now, we'll use a simple heuristic to detect tool calls in the response
+			-- In a full implementation, the LLM would return structured tool calls
+			local tool_calls = {}
+
+			-- Try to parse JSON tool calls from response
+			local json_match = response:match("```json%s*(%b{})%s*```")
+			if json_match then
+				local ok, parsed = pcall(vim.json.decode, json_match)
+				if ok and parsed.tool_calls then
+					tool_calls = parsed.tool_calls
+				end
+			end
+
+			-- Add assistant message
+			local assistant_msg = {
+				role = "assistant",
+				content = response,
+				tool_calls = #tool_calls > 0 and tool_calls or nil,
+			}
+			table.insert(history, assistant_msg)
+			on_message(assistant_msg)
+
+			-- Process tool calls
+			if #tool_calls > 0 then
+				local pending = #tool_calls
+				local results = {}
+
+				for i, call in ipairs(tool_calls) do
+					local tool = tool_map[call.name]
+					if not tool then
+						results[i] = { error = "Unknown tool: " .. call.name }
+						pending = pending - 1
+					else
+						-- Notify of tool call
+						if opts.on_tool_call then
+							opts.on_tool_call(call.name, call.input)
+						end
+
+						-- Execute tool
+						local tool_opts = {
+							on_log = function(msg)
+								pcall(function()
+									local logs = require("codetyper.adapters.nvim.ui.logs")
+									logs.add({ type = "tool", message = msg })
+								end)
+							end,
+							on_complete = function(result, err)
+								results[i] = { result = result, error = err }
+								pending = pending - 1
+
+								-- Notify of tool result
+								if opts.on_tool_result then
+									opts.on_tool_result(call.name, result, err)
+								end
+
+								-- Add tool response to history
+								local tool_msg = {
+									role = "tool",
+									tool_call_id = call.id or tostring(i),
+									name = call.name,
+									content = err or result,
+								}
+								table.insert(history, tool_msg)
+								on_message(tool_msg)
+
+								-- Continue loop when all tools complete
+								if pending == 0 then
+									vim.schedule(process_iteration)
+								end
+							end,
+							session_ctx = session_ctx,
+						}
+
+						-- Validate and execute
+						local valid, validation_err = true, nil
+						if tool.validate_input then
+							valid, validation_err = tool:validate_input(call.input)
+						end
+
+						if not valid then
+							tool_opts.on_complete(nil, validation_err)
+						else
+							local result, err = tool.func(call.input, tool_opts)
+							-- If sync result, call on_complete
+							if result ~= nil or err ~= nil then
+								tool_opts.on_complete(result, err)
+							end
+						end
+					end
+				end
+			else
+				-- No tool calls - loop complete
+				if opts.on_complete then
+					opts.on_complete(response, nil)
+				end
+			end
+		end)
+	end
+
+	-- Start the loop
+	process_iteration()
+end
+
+--- Create an agent with default settings
+---@param task string Task description
+---@param opts? AgentLoopOpts Additional options
+function M.create(task, opts)
+	opts = opts or {}
+
+	local system_prompt = opts.system_prompt or prompts.default_system_prompt
+
+	M.run(vim.tbl_extend("force", opts, {
+		system_prompt = system_prompt,
+		user_input = task,
+	}))
+end
+
+--- Simple dispatch agent for sub-tasks
+---@param prompt string Task for the sub-agent
+---@param on_complete fun(result: string|nil, error: string|nil) Completion callback
+---@param opts? table Additional options
+function M.dispatch(prompt, on_complete, opts)
+	opts = opts or {}
+
+	-- Sub-agents get limited tools by default
+	local tools_mod = require("codetyper.core.tools")
+	local safe_tools = tools_mod.list(function(tool)
+		return tool.name == "view" or tool.name == "grep" or tool.name == "glob"
+	end)
+
+	M.run({
+		system_prompt = prompts.dispatch_prompt,
+		user_input = prompt,
+		tools = opts.tools or safe_tools,
+		max_iterations = opts.max_iterations or 5,
+		on_complete = on_complete,
+		session_ctx = opts.session_ctx,
+	})
+end
+
+return M
--- a/lua/codetyper/core/scheduler/resume.lua
+++ b/lua/codetyper/core/scheduler/resume.lua
@@ -0,0 +1,155 @@
+---@mod codetyper.agent.resume Resume context for agent sessions
+---
+--- Saves and loads agent state to allow continuing long-running tasks.
+
+local M = {}
+
+local utils = require("codetyper.support.utils")
+
+--- Get the resume context directory
+---@return string|nil
+local function get_resume_dir()
+  local root = utils.get_project_root() or vim.fn.getcwd()
+  return root .. "/.coder/tmp"
+end
+
+--- Get the resume context file path
+---@return string|nil
+local function get_resume_path()
+  local dir = get_resume_dir()
+  if not dir then
+    return nil
+  end
+  return dir .. "/agent_resume.json"
+end
+
+--- Ensure the resume directory exists
+---@return boolean
+local function ensure_resume_dir()
+  local dir = get_resume_dir()
+  if not dir then
+    return false
+  end
+  return utils.ensure_dir(dir)
+end
+
+---@class ResumeContext
+---@field conversation table[] Message history
+---@field pending_tool_results table[] Pending results
+---@field iteration number Current iteration count
+---@field original_prompt string Original user prompt
+---@field timestamp number When saved
+---@field project_root string Project root path
+
+--- Save the current agent state for resuming later
+---@param conversation table[] Conversation history
+---@param pending_results table[] Pending tool results
+---@param iteration number Current iteration
+---@param original_prompt string Original prompt
+---@return boolean Success
+function M.save(conversation, pending_results, iteration, original_prompt)
+  if not ensure_resume_dir() then
+    return false
+  end
+
+  local path = get_resume_path()
+  if not path then
+    return false
+  end
+
+  local context = {
+    conversation = conversation,
+    pending_tool_results = pending_results,
+    iteration = iteration,
+    original_prompt = original_prompt,
+    timestamp = os.time(),
+    project_root = utils.get_project_root() or vim.fn.getcwd(),
+  }
+
+  local ok, json = pcall(vim.json.encode, context)
+  if not ok then
+    utils.notify("Failed to encode resume context", vim.log.levels.ERROR)
+    return false
+  end
+
+  local success = utils.write_file(path, json)
+  if success then
+    utils.notify("Agent state saved. Use /continue to resume.", vim.log.levels.INFO)
+  end
+  return success
+end
+
+--- Load saved agent state
+---@return ResumeContext|nil
+function M.load()
+  local path = get_resume_path()
+  if not path then
+    return nil
+  end
+
+  local content = utils.read_file(path)
+  if not content or content == "" then
+    return nil
+  end
+
+  local ok, context = pcall(vim.json.decode, content)
+  if not ok or not context then
+    return nil
+  end
+
+  return context
+end
+
+--- Check if there's a saved resume context
+---@return boolean
+function M.has_saved_state()
+  local path = get_resume_path()
+  if not path then
+    return false
+  end
+  return vim.fn.filereadable(path) == 1
+end
+
+--- Get info about saved state (for display)
+---@return table|nil
+function M.get_info()
+  local context = M.load()
+  if not context then
+    return nil
+  end
+
+  local age_seconds = os.time() - (context.timestamp or 0)
+  local age_str
+  if age_seconds < 60 then
+    age_str = age_seconds .. " seconds ago"
+  elseif age_seconds < 3600 then
+    age_str = math.floor(age_seconds / 60) .. " minutes ago"
+  else
+    age_str = math.floor(age_seconds / 3600) .. " hours ago"
+  end
+
+  return {
+    prompt = context.original_prompt,
+    iteration = context.iteration,
+    messages = #context.conversation,
+    saved_at = age_str,
+    project = context.project_root,
+  }
+end
+
+--- Clear saved resume context
+---@return boolean
+function M.clear()
+  local path = get_resume_path()
+  if not path then
+    return false
+  end
+
+  if vim.fn.filereadable(path) == 1 then
+    os.remove(path)
+    return true
+  end
+  return false
+end
+
+return M
--- a/lua/codetyper/core/scheduler/scheduler.lua
+++ b/lua/codetyper/core/scheduler/scheduler.lua
@@ -6,10 +6,15 @@

 local M = {}

-local queue = require("codetyper.agent.queue")
-local patch = require("codetyper.agent.patch")
-local worker = require("codetyper.agent.worker")
-local confidence_mod = require("codetyper.agent.confidence")
+local queue = require("codetyper.core.events.queue")
+local patch = require("codetyper.core.diff.patch")
+local worker = require("codetyper.core.scheduler.worker")
+local confidence_mod = require("codetyper.core.llm.confidence")
+local context_modal = require("codetyper.adapters.nvim.ui.context_modal")
+local params = require("codetyper.params.agents.scheduler")
+
+-- Setup context modal cleanup on exit
+context_modal.setup()

 --- Scheduler state
 local state = {
@@ -17,14 +22,7 @@ local state = {
 	timer = nil,
 	poll_interval = 100, -- ms
 	paused = false,
-	config = {
-		enabled = true,
-		ollama_scout = true,
-		escalation_threshold = 0.7,
-		max_concurrent = 2,
-		completion_delay_ms = 100,
-		remote_provider = "claude", -- Default fallback provider
-	},
+	config = params.config,
 }

 --- Autocommand group for injection timing
@@ -85,9 +83,7 @@ local function get_remote_provider()
 			-- If current provider is ollama, use configured remote
 			if config.llm.provider == "ollama" then
 				-- Check which remote provider is configured
-				if config.llm.claude and config.llm.claude.api_key then
-					return "claude"
-				elseif config.llm.openai and config.llm.openai.api_key then
+				if config.llm.openai and config.llm.openai.api_key then
 					return "openai"
 				elseif config.llm.gemini and config.llm.gemini.api_key then
 					return "gemini"
@@ -115,18 +111,224 @@ local function get_primary_provider()
 			return config.llm.provider
 		end
 	end
-	return "claude"
+	return "ollama"
+end
+
+--- Retry event with additional context
+---@param original_event table Original prompt event
+---@param additional_context string Additional context from user
+local function retry_with_context(original_event, additional_context, attached_files)
+	-- Create new prompt content combining original + additional
+	local combined_prompt = string.format(
+		"%s\n\nAdditional context:\n%s",
+		original_event.prompt_content,
+		additional_context
+	)
+
+	-- Create a new event with the combined prompt
+	local new_event = vim.deepcopy(original_event)
+	new_event.id = nil -- Will be assigned a new ID
+	new_event.prompt_content = combined_prompt
+	new_event.attempt_count = 0
+	new_event.status = nil
+	-- Preserve any attached files provided by the context modal
+	if attached_files and #attached_files > 0 then
+		new_event.attached_files = attached_files
+	end
+
+	-- Log the retry
+	pcall(function()
+		local logs = require("codetyper.adapters.nvim.ui.logs")
+		logs.add({
+			type = "info",
+			message = string.format("Retrying with additional context (original: %s)", original_event.id),
+		})
+	end)
+
+	-- Queue the new event
+	queue.enqueue(new_event)
+end
+
+--- Try to parse requested file paths from an LLM response asking for more context
+---@param response string
+---@return string[] list of resolved full paths
+local function parse_requested_files(response)
+	if not response or response == "" then
+		return {}
+	end
+
+	local cwd = vim.fn.getcwd()
+	local results = {}
+	local seen = {}
+
+	-- Heuristics: capture backticked paths, lines starting with - or *, or raw paths with slashes and extension
+	for path in response:gmatch("`([%w%._%-%/]+%.[%w_]+)`") do
+		if not seen[path] then
+			table.insert(results, path)
+			seen[path] = true
+		end
+	end
+
+	for path in response:gmatch("([%w%._%-%/]+%.[%w_]+)") do
+		if not seen[path] then
+			-- Filter out common English words that match the pattern
+			if not path:match("^[Ii]$") and not path:match("^[Tt]his$") then
+				table.insert(results, path)
+				seen[path] = true
+			end
+		end
+	end
+
+	-- Also capture list items like '- src/foo.lua'
+	for line in response:gmatch("[^\\n]+") do
+		local m = line:match("^%s*[-*]%s*([%w%._%-%/]+%.[%w_]+)%s*$")
+		if m and not seen[m] then
+			table.insert(results, m)
+			seen[m] = true
+		end
+	end
+
+	-- Resolve each candidate to a full path by checking cwd and globbing
+	local resolved = {}
+	for _, p in ipairs(results) do
+		local candidate = p
+		local full = nil
+
+		-- If absolute or already rooted
+		if candidate:sub(1,1) == "/" and vim.fn.filereadable(candidate) == 1 then
+			full = candidate
+		else
+			-- Try relative to cwd
+			local try1 = cwd .. "/" .. candidate
+			if vim.fn.filereadable(try1) == 1 then
+				full = try1
+			else
+				-- Try globbing for filename anywhere in project
+				local basename = candidate
+				-- If candidate contains slashes, try the tail
+				local tail = candidate:match("[^/]+$") or candidate
+				local matches = vim.fn.globpath(cwd, "**/" .. tail, false, true)
+				if matches and #matches > 0 then
+					full = matches[1]
+				end
+			end
+		end
+
+		if full and vim.fn.filereadable(full) == 1 then
+			table.insert(resolved, full)
+		end
+	end
+
+	return resolved
 end

 --- Process worker result and decide next action
 ---@param event table PromptEvent
 ---@param result table WorkerResult
 local function handle_worker_result(event, result)
+	-- Check if LLM needs more context
+	if result.needs_context then
+		pcall(function()
+			local logs = require("codetyper.adapters.nvim.ui.logs")
+			logs.add({
+				type = "info",
+				message = string.format("Event %s: LLM needs more context, opening modal", event.id),
+			})
+		end)
+
+		-- Try to auto-attach any files the LLM specifically requested in its response
+		local requested = parse_requested_files(result.response or "")
+
+		-- Detect suggested shell commands the LLM may want executed (e.g., "run ls -la", "please run git status")
+		local function detect_suggested_commands(response)
+			if not response then
+				return {}
+			end
+			local cmds = {}
+			-- capture backticked commands: `ls -la`
+			for c in response:gmatch("`([^`]+)`") do
+				if #c > 1 and not c:match("%-%-help") then
+					table.insert(cmds, { label = c, cmd = c })
+				end
+			end
+			-- capture phrases like: run ls -la or run `ls -la`
+			for m in response:gmatch("[Rr]un%s+([%w%p%s%-_/]+)") do
+				local cand = m:gsub("^%s+",""):gsub("%s+$","")
+				if cand and #cand > 1 then
+					-- ignore long sentences; keep first line or command-like substring
+					local line = cand:match("[^\n]+") or cand
+					line = line:gsub("and then.*","")
+					line = line:gsub("please.*","")
+					if not line:match("%a+%s+files") then
+						table.insert(cmds, { label = line, cmd = line })
+					end
+				end
+			end
+			-- dedupe
+			local seen = {}
+			local out = {}
+			for _, v in ipairs(cmds) do
+				if v.cmd and not seen[v.cmd] then
+					seen[v.cmd] = true
+					table.insert(out, v)
+				end
+			end
+			return out
+		end
+
+		local suggested_cmds = detect_suggested_commands(result.response or "")
+		if suggested_cmds and #suggested_cmds > 0 then
+			-- Open modal and show suggested commands for user approval
+			context_modal.open(result.original_event or event, result.response or "", retry_with_context, suggested_cmds)
+			queue.update_status(event.id, "needs_context", { response = result.response })
+			return
+		end
+		if requested and #requested > 0 then
+			pcall(function()
+				local logs = require("codetyper.adapters.nvim.ui.logs")
+				logs.add({ type = "info", message = string.format("Auto-attaching %d requested file(s)", #requested) })
+			end)
+
+			-- Build attached_files entries
+			local attached = event.attached_files or {}
+			for _, full in ipairs(requested) do
+				local ok, content = pcall(function()
+					return table.concat(vim.fn.readfile(full), "\n")
+				end)
+				if ok and content then
+					table.insert(attached, {
+						path = vim.fn.fnamemodify(full, ":~:."),
+						full_path = full,
+						content = content,
+					})
+				end
+			end
+
+			-- Retry automatically with same prompt but attached files
+			local new_event = vim.deepcopy(result.original_event or event)
+			new_event.id = nil
+			new_event.attached_files = attached
+			new_event.attempt_count = 0
+			new_event.status = nil
+			queue.enqueue(new_event)
+
+			queue.update_status(event.id, "needs_context", { response = result.response })
+			return
+		end
+
+		-- If no files parsed, open modal for manual context entry
+		context_modal.open(result.original_event or event, result.response or "", retry_with_context)
+
+		-- Mark original event as needing context (not failed)
+		queue.update_status(event.id, "needs_context", { response = result.response })
+		return
+	end
+
 	if not result.success then
 		-- Failed - try escalation if this was ollama
 		if result.worker_type == "ollama" and event.attempt_count < 2 then
 			pcall(function()
-				local logs = require("codetyper.agent.logs")
+				local logs = require("codetyper.adapters.nvim.ui.logs")
 				logs.add({
 					type = "info",
 					message = string.format(
@@ -156,7 +358,7 @@ local function handle_worker_result(event, result)
 	if needs_escalation and result.worker_type == "ollama" and event.attempt_count < 2 then
 		-- Low confidence from ollama - escalate to remote
 		pcall(function()
-			local logs = require("codetyper.agent.logs")
+			local logs = require("codetyper.adapters.nvim.ui.logs")
 			logs.add({
 				type = "info",
 				message = string.format(
@@ -178,8 +380,19 @@ local function handle_worker_result(event, result)

 	queue.complete(event.id)

-	-- Schedule patch application
-	M.schedule_patch_flush()
+	-- Schedule patch application after delay (gives user time to review/cancel)
+	local delay = state.config.apply_delay_ms or 5000
+	pcall(function()
+		local logs = require("codetyper.adapters.nvim.ui.logs")
+		logs.add({
+			type = "info",
+			message = string.format("Code ready. Applying in %.1f seconds...", delay / 1000),
+		})
+	end)
+
+	vim.defer_fn(function()
+		M.schedule_patch_flush()
+	end, delay)
 end

 --- Dispatch next event from queue
@@ -203,7 +416,7 @@ local function dispatch_next()
 	local should_skip, skip_reason = queue.check_precedence(event)
 	if should_skip then
 		pcall(function()
-			local logs = require("codetyper.agent.logs")
+			local logs = require("codetyper.adapters.nvim.ui.logs")
 			logs.add({
 				type = "warning",
 				message = string.format("Event %s skipped: %s", event.id, skip_reason or "conflict"),
@@ -219,7 +432,7 @@ local function dispatch_next()

 	-- Log dispatch with intent/scope info
 	pcall(function()
-		local logs = require("codetyper.agent.logs")
+		local logs = require("codetyper.adapters.nvim.ui.logs")
 		local intent_info = event.intent and event.intent.type or "unknown"
 		local scope_info = event.scope and event.scope.type ~= "file"
 			and string.format("%s:%s", event.scope.type, event.scope.name or "anon")
@@ -241,15 +454,27 @@ local function dispatch_next()
 	end)
 end

+--- Track if we're already waiting to flush (avoid spam logs)
+local waiting_to_flush = false
+
 --- Schedule patch flush after delay (completion safety)
+--- Will keep retrying until safe to inject or no pending patches
 function M.schedule_patch_flush()
 	vim.defer_fn(function()
+		-- Check if there are any pending patches
+		local pending = patch.get_pending()
+		if #pending == 0 then
+			waiting_to_flush = false
+			return -- Nothing to apply
+		end
+
 		local safe, reason = M.is_safe_to_inject()
 		if safe then
-			local applied, stale = patch.flush_pending()
+			waiting_to_flush = false
+			local applied, stale = patch.flush_pending_smart()
 			if applied > 0 or stale > 0 then
 				pcall(function()
-					local logs = require("codetyper.agent.logs")
+					local logs = require("codetyper.adapters.nvim.ui.logs")
 					logs.add({
 						type = "info",
 						message = string.format("Patches flushed: %d applied, %d stale", applied, stale),
@@ -257,15 +482,20 @@ function M.schedule_patch_flush()
 				end)
 			end
 		else
-			-- Not safe yet, reschedule
-			pcall(function()
-				local logs = require("codetyper.agent.logs")
-				logs.add({
-					type = "debug",
-					message = string.format("Patch flush deferred: %s", reason or "unknown"),
-				})
-			end)
-			-- Will be retried on next InsertLeave or CursorHold
+			-- Not safe yet (user is typing), reschedule to try again
+			-- Only log once when we start waiting
+			if not waiting_to_flush then
+				waiting_to_flush = true
+				pcall(function()
+					local logs = require("codetyper.adapters.nvim.ui.logs")
+					logs.add({
+						type = "info",
+						message = "Waiting for user to finish typing before applying code...",
+					})
+				end)
+			end
+			-- Retry after a delay - keep waiting for user to finish typing
+			M.schedule_patch_flush()
 		end
 	end, state.config.completion_delay_ms)
 end
@@ -302,7 +532,7 @@ local function setup_autocmds()
 		callback = function()
 			vim.defer_fn(function()
 				if not M.is_completion_visible() then
-					patch.flush_pending()
+					patch.flush_pending_smart()
 				end
 			end, state.config.completion_delay_ms)
 		end,
@@ -314,7 +544,7 @@ local function setup_autocmds()
 		group = augroup,
 		callback = function()
 			if not M.is_insert_mode() and not M.is_completion_visible() then
-				patch.flush_pending()
+				patch.flush_pending_smart()
 			end
 		end,
 		desc = "Flush pending patches on CursorHold",
@@ -340,6 +570,15 @@ local function setup_autocmds()
 		end,
 		desc = "Cleanup on buffer delete",
 	})
+
+	-- Stop scheduler when exiting Neovim
+	vim.api.nvim_create_autocmd("VimLeavePre", {
+		group = augroup,
+		callback = function()
+			M.stop()
+		end,
+		desc = "Stop scheduler before exiting Neovim",
+	})
 end

 --- Start the scheduler
@@ -389,7 +628,7 @@ function M.start(config)
 	scheduler_loop()

 	pcall(function()
-		local logs = require("codetyper.agent.logs")
+		local logs = require("codetyper.adapters.nvim.ui.logs")
 		logs.add({
 			type = "info",
 			message = "Scheduler started",
@@ -421,7 +660,7 @@ function M.stop()
 	end

 	pcall(function()
-		local logs = require("codetyper.agent.logs")
+		local logs = require("codetyper.adapters.nvim.ui.logs")
 		logs.add({
 			type = "info",
 			message = "Scheduler stopped",
@@ -474,7 +713,7 @@ end

 --- Force flush all pending patches (ignores completion check)
 function M.force_flush()
-	return patch.flush_pending()
+	return patch.flush_pending_smart()
 end

 --- Update configuration
@@ -485,4 +724,33 @@ function M.configure(config)
 	end
 end

+--- Queue a prompt for processing
+--- This is a convenience function that creates a proper PromptEvent and enqueues it
+---@param opts table Prompt options
+---   - bufnr: number Source buffer number
+---   - filepath: string Source file path
+---   - target_path: string Target file for injection (can be same as filepath)
+---   - prompt_content: string The cleaned prompt text
+---   - range: {start_line: number, end_line: number} Line range of prompt tag
+---   - source: string|nil Source identifier (e.g., "transform_command", "autocmd")
+---   - priority: number|nil Priority (1=high, 2=normal, 3=low) default 2
+---@return table The enqueued event
+function M.queue_prompt(opts)
+	-- Build the PromptEvent structure
+	local event = {
+		bufnr = opts.bufnr,
+		filepath = opts.filepath,
+		target_path = opts.target_path or opts.filepath,
+		prompt_content = opts.prompt_content,
+		range = opts.range,
+		priority = opts.priority or 2,
+		source = opts.source or "manual",
+		-- Capture buffer state for staleness detection
+		changedtick = vim.api.nvim_buf_get_changedtick(opts.bufnr),
+	}
+
+	-- Enqueue through the queue module
+	return queue.enqueue(event)
+end
+
 return M
--- a/lua/codetyper/core/scheduler/worker.lua
+++ b/lua/codetyper/core/scheduler/worker.lua
--- a/lua/codetyper/core/scope/init.lua
+++ b/lua/codetyper/core/scope/init.lua
@@ -14,78 +14,52 @@ local M = {}
 ---@field name string|nil Name of the function/class if available

 --- Node types that represent function-like scopes per language
-local function_nodes = {
-	-- Lua
-	["function_declaration"] = "function",
-	["function_definition"] = "function",
-	["local_function"] = "function",
-	["function"] = "function",
-
-	-- JavaScript/TypeScript
-	["function_declaration"] = "function",
-	["function_expression"] = "function",
-	["arrow_function"] = "function",
-	["method_definition"] = "method",
-	["function"] = "function",
-
-	-- Python
-	["function_definition"] = "function",
-	["async_function_definition"] = "function",
-
-	-- Go
-	["function_declaration"] = "function",
-	["method_declaration"] = "method",
-
-	-- Rust
-	["function_item"] = "function",
-	["impl_item"] = "method",
-
-	-- Ruby
-	["method"] = "method",
-	["singleton_method"] = "method",
-
-	-- Java/C#
-	["method_declaration"] = "method",
-	["constructor_declaration"] = "method",
-
-	-- C/C++
-	["function_definition"] = "function",
-}
-
--- Node types that represent class-like scopes
-local class_nodes = {
-	["class_declaration"] = "class",
-	["class_definition"] = "class",
-	["class"] = "class",
-	["struct_item"] = "class",
-	["impl_item"] = "class",
-	["interface_declaration"] = "class",
-	["module"] = "class",
-}
-
--- Node types that represent block scopes
-local block_nodes = {
-	["block"] = "block",
-	["statement_block"] = "block",
-	["compound_statement"] = "block",
-	["do_block"] = "block",
-}
+local params = require("codetyper.params.agents.scope")
+local function_nodes = params.function_nodes
+local class_nodes = params.class_nodes
+local block_nodes = params.block_nodes

 --- Check if Tree-sitter is available for buffer
 ---@param bufnr number
 ---@return boolean
 function M.has_treesitter(bufnr)
-	local ok, parsers = pcall(require, "nvim-treesitter.parsers")
-	if not ok then
-		return false
+	-- Try to get the language for this buffer
+	local lang = nil
+
+	-- Method 1: Use vim.treesitter (Neovim 0.9+)
+	if vim.treesitter and vim.treesitter.language then
+		local ft = vim.bo[bufnr].filetype
+		if vim.treesitter.language.get_lang then
+			lang = vim.treesitter.language.get_lang(ft)
+		else
+			lang = ft
+		end
 	end

-	local lang = parsers.get_buf_lang(bufnr)
+	-- Method 2: Try nvim-treesitter parsers module
 	if not lang then
+		local ok, parsers = pcall(require, "nvim-treesitter.parsers")
+		if ok and parsers then
+			if parsers.get_buf_lang then
+				lang = parsers.get_buf_lang(bufnr)
+			elseif parsers.ft_to_lang then
+				lang = parsers.ft_to_lang(vim.bo[bufnr].filetype)
+			end
+		end
+	end
+
+	-- Fallback to filetype
+	if not lang then
+		lang = vim.bo[bufnr].filetype
+	end
+
+	if not lang or lang == "" then
 		return false
 	end

-	return parsers.has_parser(lang)
+	-- Check if parser is available
+	local has_parser = pcall(vim.treesitter.get_parser, bufnr, lang)
+	return has_parser
 end

 --- Get Tree-sitter node at position
@@ -256,13 +230,21 @@ function M.resolve_scope_heuristic(bufnr, row, col)
 			ending = nil, -- Python uses indentation
 		},
 		javascript = {
-			start = "^%s*function%s+",
-			start_alt = "^%s*const%s+%w+%s*=%s*",
+			start = "^%s*export%s+function%s+",
+			start_alt = "^%s*function%s+",
+			start_alt2 = "^%s*export%s+const%s+%w+%s*=",
+			start_alt3 = "^%s*const%s+%w+%s*=%s*",
+			start_alt4 = "^%s*export%s+async%s+function%s+",
+			start_alt5 = "^%s*async%s+function%s+",
 			ending = "^%s*}%s*$",
 		},
 		typescript = {
-			start = "^%s*function%s+",
-			start_alt = "^%s*const%s+%w+%s*=%s*",
+			start = "^%s*export%s+function%s+",
+			start_alt = "^%s*function%s+",
+			start_alt2 = "^%s*export%s+const%s+%w+%s*=",
+			start_alt3 = "^%s*const%s+%w+%s*=%s*",
+			start_alt4 = "^%s*export%s+async%s+function%s+",
+			start_alt5 = "^%s*async%s+function%s+",
 			ending = "^%s*}%s*$",
 		},
 	}
@@ -276,8 +258,13 @@ function M.resolve_scope_heuristic(bufnr, row, col)
 	local start_line = nil
 	for i = row, 1, -1 do
 		local line = lines[i]
-		if line:match(lang_patterns.start) or
-			(lang_patterns.start_alt and line:match(lang_patterns.start_alt)) then
+		-- Check all start patterns
+		if line:match(lang_patterns.start)
+			or (lang_patterns.start_alt and line:match(lang_patterns.start_alt))
+			or (lang_patterns.start_alt2 and line:match(lang_patterns.start_alt2))
+			or (lang_patterns.start_alt3 and line:match(lang_patterns.start_alt3))
+			or (lang_patterns.start_alt4 and line:match(lang_patterns.start_alt4))
+			or (lang_patterns.start_alt5 and line:match(lang_patterns.start_alt5)) then
 			start_line = i
 			break
 		end
--- a/lua/codetyper/core/tools/base.lua
+++ b/lua/codetyper/core/tools/base.lua
@@ -0,0 +1,128 @@
+---@mod codetyper.agent.tools.base Base tool definition
+---@brief [[
+--- Base metatable for all LLM tools.
+--- Tools extend this base to provide structured AI capabilities.
+---@brief ]]
+
+---@class CoderToolParam
+---@field name string Parameter name
+---@field description string Parameter description
+---@field type string Parameter type ("string", "number", "boolean", "table")
+---@field optional? boolean Whether the parameter is optional
+---@field default? any Default value for optional parameters
+
+---@class CoderToolReturn
+---@field name string Return value name
+---@field description string Return value description
+---@field type string Return type
+---@field optional? boolean Whether the return is optional
+
+---@class CoderToolOpts
+---@field on_log? fun(message: string) Log callback
+---@field on_complete? fun(result: any, error: string|nil) Completion callback
+---@field session_ctx? table Session context
+---@field streaming? boolean Whether response is still streaming
+---@field confirm? fun(message: string, callback: fun(ok: boolean)) Confirmation callback
+
+---@class CoderTool
+---@field name string Tool identifier
+---@field description string|fun(): string Tool description
+---@field params CoderToolParam[] Input parameters
+---@field returns CoderToolReturn[] Return values
+---@field requires_confirmation? boolean Whether tool needs user confirmation
+---@field func fun(input: table, opts: CoderToolOpts): any, string|nil Tool implementation
+
+local M = {}
+M.__index = M
+
+--- Call the tool function
+---@param opts CoderToolOpts Options for the tool call
+---@return any result
+---@return string|nil error
+function M:__call(opts, on_log, on_complete)
+	return self.func(opts, on_log, on_complete)
+end
+
+--- Get the tool description
+---@return string
+function M:get_description()
+	if type(self.description) == "function" then
+		return self.description()
+	end
+	return self.description
+end
+
+--- Validate input against parameter schema
+---@param input table Input to validate
+---@return boolean valid
+---@return string|nil error
+function M:validate_input(input)
+	if not self.params then
+		return true
+	end
+
+	for _, param in ipairs(self.params) do
+		local value = input[param.name]
+
+		-- Check required parameters
+		if not param.optional and value == nil then
+			return false, string.format("Missing required parameter: %s", param.name)
+		end
+
+		-- Type checking
+		if value ~= nil then
+			local actual_type = type(value)
+			local expected_type = param.type
+
+			-- Handle special types
+			if expected_type == "integer" and actual_type == "number" then
+				if math.floor(value) ~= value then
+					return false, string.format("Parameter %s must be an integer", param.name)
+				end
+			elseif expected_type ~= actual_type and expected_type ~= "any" then
+				return false, string.format("Parameter %s must be %s, got %s", param.name, expected_type, actual_type)
+			end
+		end
+	end
+
+	return true
+end
+
+--- Generate JSON schema for the tool (for LLM function calling)
+---@return table schema
+function M:to_schema()
+	local properties = {}
+	local required = {}
+
+	for _, param in ipairs(self.params or {}) do
+		local prop = {
+			type = param.type == "integer" and "number" or param.type,
+			description = param.description,
+		}
+
+		if param.default ~= nil then
+			prop.default = param.default
+		end
+
+		properties[param.name] = prop
+
+		if not param.optional then
+			table.insert(required, param.name)
+		end
+	end
+
+	return {
+		type = "function",
+		function_def = {
+			name = self.name,
+			description = self:get_description(),
+			parameters = {
+				type = "object",
+				properties = properties,
+				required = required,
+			},
+		},
+	}
+end
+
+return M
--- a/lua/codetyper/core/tools/bash.lua
+++ b/lua/codetyper/core/tools/bash.lua
@@ -0,0 +1,139 @@
+---@mod codetyper.agent.tools.bash Shell command execution tool
+---@brief [[
+--- Tool for executing shell commands with safety checks.
+---@brief ]]
+
+local Base = require("codetyper.core.tools.base")
+local description = require("codetyper.prompts.agents.bash").description
+local params = require("codetyper.params.agents.bash").params
+local returns = require("codetyper.params.agents.bash").returns
+local BANNED_COMMANDS = require("codetyper.commands.agents.banned").BANNED_COMMANDS
+local BANNED_PATTERNS = require("codetyper.commands.agents.banned").BANNED_PATTERNS
+
+---@class CoderTool
+local M = setmetatable({}, Base)
+
+M.name = "bash"
+M.description = description
+M.params = params
+M.returns = returns
+M.requires_confirmation = true
+
+--- Check if command is safe
+---@param command string
+---@return boolean safe
+---@return string|nil reason
+local function is_safe_command(command)
+	-- Check exact matches
+	for _, banned in ipairs(BANNED_COMMANDS) do
+		if command == banned then
+			return false, "Command is banned for safety"
+		end
+	end
+
+	-- Check patterns
+	for _, pattern in ipairs(BANNED_PATTERNS) do
+		if command:match(pattern) then
+			return false, "Command matches banned pattern"
+		end
+	end
+
+	return true
+end
+
+---@param input {command: string, cwd?: string, timeout?: integer}
+---@param opts CoderToolOpts
+---@return string|nil result
+---@return string|nil error
+function M.func(input, opts)
+	if not input.command then
+		return nil, "command is required"
+	end
+
+	-- Safety check
+	local safe, reason = is_safe_command(input.command)
+	if not safe then
+		return nil, reason
+	end
+
+	-- Confirmation required
+	if M.requires_confirmation and opts.confirm then
+		local confirmed = false
+		local confirm_error = nil
+
+		opts.confirm("Execute command: " .. input.command, function(ok)
+			if not ok then
+				confirm_error = "User declined command execution"
+			end
+			confirmed = ok
+		end)
+
+		-- Wait for confirmation (in async context, this would be handled differently)
+		if confirm_error then
+			return nil, confirm_error
+		end
+	end
+
+	-- Log the operation
+	if opts.on_log then
+		opts.on_log("Executing: " .. input.command)
+	end
+
+	-- Prepare command
+	local cwd = input.cwd or vim.fn.getcwd()
+	local timeout = input.timeout or 120000
+
+	-- Execute command
+	local output = ""
+	local exit_code = 0
+
+	local job_opts = {
+		command = "bash",
+		args = { "-c", input.command },
+		cwd = cwd,
+		on_stdout = function(_, data)
+			if data then
+				output = output .. table.concat(data, "\n")
+			end
+		end,
+		on_stderr = function(_, data)
+			if data then
+				output = output .. table.concat(data, "\n")
+			end
+		end,
+		on_exit = function(_, code)
+			exit_code = code
+		end,
+	}
+
+	-- Run synchronously with timeout
+	local Job = require("plenary.job")
+	local job = Job:new(job_opts)
+
+	job:sync(timeout)
+	exit_code = job.code or 0
+	output = table.concat(job:result() or {}, "\n")
+
+	-- Also get stderr
+	local stderr = table.concat(job:stderr_result() or {}, "\n")
+	if stderr and stderr ~= "" then
+		output = output .. "\n" .. stderr
+	end
+
+	-- Check result
+	if exit_code ~= 0 then
+		local error_msg = string.format("Command failed with exit code %d: %s", exit_code, output)
+		if opts.on_complete then
+			opts.on_complete(nil, error_msg)
+		end
+		return nil, error_msg
+	end
+
+	if opts.on_complete then
+		opts.on_complete(output, nil)
+	end
+
+	return output, nil
+end
+
+return M
--- a/lua/codetyper/core/tools/edit.lua
+++ b/lua/codetyper/core/tools/edit.lua
@@ -0,0 +1,391 @@
+---@mod codetyper.agent.tools.edit File editing tool with fallback matching
+---@brief [[
+--- Tool for making targeted edits to files using search/replace.
+--- Implements multiple fallback strategies for robust matching.
+--- Multi-strategy approach for reliable editing.
+---@brief ]]
+
+local Base = require("codetyper.core.tools.base")
+local description = require("codetyper.prompts.agents.edit").description
+local params = require("codetyper.params.agents.edit").params
+local returns = require("codetyper.params.agents.edit").returns
+
+---@class CoderTool
+local M = setmetatable({}, Base)
+
+M.name = "edit"
+M.description = description
+M.params = params
+M.returns = returns
+M.requires_confirmation = false
+
+--- Normalize line endings to LF
+---@param str string
+---@return string
+local function normalize_line_endings(str)
+	return str:gsub("\r\n", "\n"):gsub("\r", "\n")
+end
+
+--- Strategy 1: Exact match
+---@param content string File content
+---@param old_str string String to find
+---@return number|nil start_pos
+---@return number|nil end_pos
+local function exact_match(content, old_str)
+	local pos = content:find(old_str, 1, true)
+	if pos then
+		return pos, pos + #old_str - 1
+	end
+	return nil, nil
+end
+
+--- Strategy 2: Whitespace-normalized match
+--- Collapses all whitespace to single spaces
+---@param content string
+---@param old_str string
+---@return number|nil start_pos
+---@return number|nil end_pos
+local function whitespace_normalized_match(content, old_str)
+	local function normalize_ws(s)
+		return s:gsub("%s+", " "):gsub("^%s+", ""):gsub("%s+$", "")
+	end
+
+	local norm_old = normalize_ws(old_str)
+	local lines = vim.split(content, "\n")
+
+	-- Try to find matching block
+	for i = 1, #lines do
+		local block = {}
+		local block_start = nil
+
+		for j = i, #lines do
+			table.insert(block, lines[j])
+			local block_text = table.concat(block, "\n")
+			local norm_block = normalize_ws(block_text)
+
+			if norm_block == norm_old then
+				-- Found match
+				local before = table.concat(vim.list_slice(lines, 1, i - 1), "\n")
+				local start_pos = #before + (i > 1 and 2 or 1)
+				local end_pos = start_pos + #block_text - 1
+				return start_pos, end_pos
+			end
+
+			-- If block is already longer than target, stop
+			if #norm_block > #norm_old then
+				break
+			end
+		end
+	end
+
+	return nil, nil
+end
+
+--- Strategy 3: Indentation-flexible match
+--- Ignores leading whitespace differences
+---@param content string
+---@param old_str string
+---@return number|nil start_pos
+---@return number|nil end_pos
+local function indentation_flexible_match(content, old_str)
+	local function strip_indent(s)
+		local lines = vim.split(s, "\n")
+		local result = {}
+		for _, line in ipairs(lines) do
+			table.insert(result, line:gsub("^%s+", ""))
+		end
+		return table.concat(result, "\n")
+	end
+
+	local stripped_old = strip_indent(old_str)
+	local lines = vim.split(content, "\n")
+	local old_lines = vim.split(old_str, "\n")
+	local num_old_lines = #old_lines
+
+	for i = 1, #lines - num_old_lines + 1 do
+		local block = vim.list_slice(lines, i, i + num_old_lines - 1)
+		local block_text = table.concat(block, "\n")
+
+		if strip_indent(block_text) == stripped_old then
+			local before = table.concat(vim.list_slice(lines, 1, i - 1), "\n")
+			local start_pos = #before + (i > 1 and 2 or 1)
+			local end_pos = start_pos + #block_text - 1
+			return start_pos, end_pos
+		end
+	end
+
+	return nil, nil
+end
+
+--- Strategy 4: Line-trimmed match
+--- Trims each line before comparing
+---@param content string
+---@param old_str string
+---@return number|nil start_pos
+---@return number|nil end_pos
+local function line_trimmed_match(content, old_str)
+	local function trim_lines(s)
+		local lines = vim.split(s, "\n")
+		local result = {}
+		for _, line in ipairs(lines) do
+			table.insert(result, line:match("^%s*(.-)%s*$"))
+		end
+		return table.concat(result, "\n")
+	end
+
+	local trimmed_old = trim_lines(old_str)
+	local lines = vim.split(content, "\n")
+	local old_lines = vim.split(old_str, "\n")
+	local num_old_lines = #old_lines
+
+	for i = 1, #lines - num_old_lines + 1 do
+		local block = vim.list_slice(lines, i, i + num_old_lines - 1)
+		local block_text = table.concat(block, "\n")
+
+		if trim_lines(block_text) == trimmed_old then
+			local before = table.concat(vim.list_slice(lines, 1, i - 1), "\n")
+			local start_pos = #before + (i > 1 and 2 or 1)
+			local end_pos = start_pos + #block_text - 1
+			return start_pos, end_pos
+		end
+	end
+
+	return nil, nil
+end
+
+--- Calculate Levenshtein distance between two strings
+---@param s1 string
+---@param s2 string
+---@return number
+local function levenshtein(s1, s2)
+	local len1, len2 = #s1, #s2
+	local matrix = {}
+
+	for i = 0, len1 do
+		matrix[i] = { [0] = i }
+	end
+	for j = 0, len2 do
+		matrix[0][j] = j
+	end
+
+	for i = 1, len1 do
+		for j = 1, len2 do
+			local cost = s1:sub(i, i) == s2:sub(j, j) and 0 or 1
+			matrix[i][j] = math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost)
+		end
+	end
+
+	return matrix[len1][len2]
+end
+
+--- Strategy 5: Fuzzy anchor-based match
+--- Uses first and last lines as anchors, allows fuzzy matching in between
+---@param content string
+---@param old_str string
+---@param threshold? number Similarity threshold (0-1), default 0.8
+---@return number|nil start_pos
+---@return number|nil end_pos
+local function fuzzy_anchor_match(content, old_str, threshold)
+	threshold = threshold or 0.8
+
+	local old_lines = vim.split(old_str, "\n")
+	if #old_lines < 2 then
+		return nil, nil
+	end
+
+	local first_line = old_lines[1]:match("^%s*(.-)%s*$")
+	local last_line = old_lines[#old_lines]:match("^%s*(.-)%s*$")
+	local content_lines = vim.split(content, "\n")
+
+	-- Find potential start positions
+	local candidates = {}
+	for i, line in ipairs(content_lines) do
+		local trimmed = line:match("^%s*(.-)%s*$")
+		if
+			trimmed == first_line
+			or (
+				#first_line > 0
+				and 1 - (levenshtein(trimmed, first_line) / math.max(#trimmed, #first_line)) >= threshold
+			)
+		then
+			table.insert(candidates, i)
+		end
+	end
+
+	-- For each candidate, look for matching end
+	for _, start_idx in ipairs(candidates) do
+		local expected_end = start_idx + #old_lines - 1
+		if expected_end <= #content_lines then
+			local end_line = content_lines[expected_end]:match("^%s*(.-)%s*$")
+			if
+				end_line == last_line
+				or (
+					#last_line > 0
+					and 1 - (levenshtein(end_line, last_line) / math.max(#end_line, #last_line)) >= threshold
+				)
+			then
+				-- Calculate positions
+				local before = table.concat(vim.list_slice(content_lines, 1, start_idx - 1), "\n")
+				local block = table.concat(vim.list_slice(content_lines, start_idx, expected_end), "\n")
+				local start_pos = #before + (start_idx > 1 and 2 or 1)
+				local end_pos = start_pos + #block - 1
+				return start_pos, end_pos
+			end
+		end
+	end
+
+	return nil, nil
+end
+
+--- Try all matching strategies in order
+---@param content string File content
+---@param old_str string String to find
+---@return number|nil start_pos
+---@return number|nil end_pos
+---@return string strategy_used
+local function find_match(content, old_str)
+	-- Strategy 1: Exact match
+	local start_pos, end_pos = exact_match(content, old_str)
+	if start_pos then
+		return start_pos, end_pos, "exact"
+	end
+
+	-- Strategy 2: Whitespace-normalized
+	start_pos, end_pos = whitespace_normalized_match(content, old_str)
+	if start_pos then
+		return start_pos, end_pos, "whitespace_normalized"
+	end
+
+	-- Strategy 3: Indentation-flexible
+	start_pos, end_pos = indentation_flexible_match(content, old_str)
+	if start_pos then
+		return start_pos, end_pos, "indentation_flexible"
+	end
+
+	-- Strategy 4: Line-trimmed
+	start_pos, end_pos = line_trimmed_match(content, old_str)
+	if start_pos then
+		return start_pos, end_pos, "line_trimmed"
+	end
+
+	-- Strategy 5: Fuzzy anchor
+	start_pos, end_pos = fuzzy_anchor_match(content, old_str)
+	if start_pos then
+		return start_pos, end_pos, "fuzzy_anchor"
+	end
+
+	return nil, nil, "none"
+end
+
+---@param input {path: string, old_string: string, new_string: string}
+---@param opts CoderToolOpts
+---@return boolean|nil result
+---@return string|nil error
+function M.func(input, opts)
+	if not input.path then
+		return nil, "path is required"
+	end
+	if input.old_string == nil then
+		return nil, "old_string is required"
+	end
+	if input.new_string == nil then
+		return nil, "new_string is required"
+	end
+
+	-- Log the operation
+	if opts.on_log then
+		opts.on_log("Editing file: " .. input.path)
+	end
+
+	-- Resolve path
+	local path = input.path
+	if not vim.startswith(path, "/") then
+		path = vim.fn.getcwd() .. "/" .. path
+	end
+
+	-- Normalize inputs
+	local old_str = normalize_line_endings(input.old_string)
+	local new_str = normalize_line_endings(input.new_string)
+
+	-- Handle new file creation (empty old_string)
+	if old_str == "" then
+		-- Create parent directories
+		local dir = vim.fn.fnamemodify(path, ":h")
+		if vim.fn.isdirectory(dir) == 0 then
+			vim.fn.mkdir(dir, "p")
+		end
+
+		-- Write new file
+		local lines = vim.split(new_str, "\n", { plain = true })
+		local ok = pcall(vim.fn.writefile, lines, path)
+
+		if not ok then
+			return nil, "Failed to create file: " .. input.path
+		end
+
+		-- Reload buffer if open
+		local bufnr = vim.fn.bufnr(path)
+		if bufnr ~= -1 and vim.api.nvim_buf_is_valid(bufnr) then
+			vim.api.nvim_buf_call(bufnr, function()
+				vim.cmd("edit!")
+			end)
+		end
+
+		if opts.on_complete then
+			opts.on_complete(true, nil)
+		end
+
+		return true, nil
+	end
+
+	-- Check if file exists
+	if vim.fn.filereadable(path) ~= 1 then
+		return nil, "File not found: " .. input.path
+	end
+
+	-- Read current content
+	local lines = vim.fn.readfile(path)
+	if not lines then
+		return nil, "Failed to read file: " .. input.path
+	end
+
+	local content = normalize_line_endings(table.concat(lines, "\n"))
+
+	-- Find match using fallback strategies
+	local start_pos, end_pos, strategy = find_match(content, old_str)
+
+	if not start_pos then
+		return nil, "old_string not found in file (tried 5 matching strategies)"
+	end
+
+	if opts.on_log then
+		opts.on_log("Match found using strategy: " .. strategy)
+	end
+
+	-- Perform replacement
+	local new_content = content:sub(1, start_pos - 1) .. new_str .. content:sub(end_pos + 1)
+
+	-- Write back
+	local new_lines = vim.split(new_content, "\n", { plain = true })
+	local ok = pcall(vim.fn.writefile, new_lines, path)
+
+	if not ok then
+		return nil, "Failed to write file: " .. input.path
+	end
+
+	-- Reload buffer if open
+	local bufnr = vim.fn.bufnr(path)
+	if bufnr ~= -1 and vim.api.nvim_buf_is_valid(bufnr) then
+		vim.api.nvim_buf_call(bufnr, function()
+			vim.cmd("edit!")
+		end)
+	end
+
+	if opts.on_complete then
+		opts.on_complete(true, nil)
+	end
+
+	return true, nil
+end
+
+return M
--- a/lua/codetyper/core/tools/glob.lua
+++ b/lua/codetyper/core/tools/glob.lua
@@ -0,0 +1,146 @@
+---@mod codetyper.agent.tools.glob File pattern matching tool
+---@brief [[
+--- Tool for finding files by glob pattern.
+---@brief ]]
+
+local Base = require("codetyper.core.tools.base")
+
+---@class CoderTool
+local M = setmetatable({}, Base)
+
+M.name = "glob"
+
+M.description = [[Finds files matching a glob pattern.
+
+Example patterns:
+- "**/*.lua" - All Lua files
+- "src/**/*.ts" - TypeScript files in src
+- "**/test_*.py" - Test files in Python]]
+
+M.params = {
+	{
+		name = "pattern",
+		description = "Glob pattern to match files",
+		type = "string",
+	},
+	{
+		name = "path",
+		description = "Base directory to search in (default: project root)",
+		type = "string",
+		optional = true,
+	},
+	{
+		name = "max_results",
+		description = "Maximum number of results (default: 100)",
+		type = "integer",
+		optional = true,
+	},
+}
+
+M.returns = {
+	{
+		name = "matches",
+		description = "JSON array of matching file paths",
+		type = "string",
+	},
+	{
+		name = "error",
+		description = "Error message if glob failed",
+		type = "string",
+		optional = true,
+	},
+}
+
+M.requires_confirmation = false
+
+---@param input {pattern: string, path?: string, max_results?: integer}
+---@param opts CoderToolOpts
+---@return string|nil result
+---@return string|nil error
+function M.func(input, opts)
+	if not input.pattern then
+		return nil, "pattern is required"
+	end
+
+	-- Log the operation
+	if opts.on_log then
+		opts.on_log("Finding files: " .. input.pattern)
+	end
+
+	-- Resolve base path
+	local base_path = input.path or vim.fn.getcwd()
+	if not vim.startswith(base_path, "/") then
+		base_path = vim.fn.getcwd() .. "/" .. base_path
+	end
+
+	local max_results = input.max_results or 100
+
+	-- Use vim.fn.glob or fd if available
+	local matches = {}
+
+	if vim.fn.executable("fd") == 1 then
+		-- Use fd for better performance
+		local Job = require("plenary.job")
+
+		-- Convert glob to fd pattern
+		local fd_pattern = input.pattern:gsub("%*%*/", ""):gsub("%*", ".*")
+
+		local job = Job:new({
+			command = "fd",
+			args = {
+				"--type",
+				"f",
+				"--max-results",
+				tostring(max_results),
+				"--glob",
+				input.pattern,
+				base_path,
+			},
+			cwd = base_path,
+		})
+
+		job:sync(30000)
+		matches = job:result() or {}
+	else
+		-- Fallback to vim.fn.globpath
+		local pattern = base_path .. "/" .. input.pattern
+		local files = vim.fn.glob(pattern, false, true)
+
+		for i, file in ipairs(files) do
+			if i > max_results then
+				break
+			end
+			-- Make paths relative to base_path
+			local relative = file:gsub("^" .. vim.pesc(base_path) .. "/", "")
+			table.insert(matches, relative)
+		end
+	end
+
+	-- Clean up matches
+	local cleaned = {}
+	for _, match in ipairs(matches) do
+		if match and match ~= "" then
+			-- Make relative if absolute
+			local relative = match
+			if vim.startswith(match, base_path) then
+				relative = match:sub(#base_path + 2)
+			end
+			table.insert(cleaned, relative)
+		end
+	end
+
+	-- Return as JSON
+	local result = vim.json.encode({
+		matches = cleaned,
+		total = #cleaned,
+		truncated = #cleaned >= max_results,
+	})
+
+	if opts.on_complete then
+		opts.on_complete(result, nil)
+	end
+
+	return result, nil
+end
+
+return M
--- a/lua/codetyper/core/tools/grep.lua
+++ b/lua/codetyper/core/tools/grep.lua
@@ -0,0 +1,107 @@
+---@mod codetyper.agent.tools.grep Search tool
+---@brief [[
+--- Tool for searching file contents using ripgrep.
+---@brief ]]
+
+local Base = require("codetyper.core.tools.base")
+local description = require("codetyper.params.agents.grep").description
+local params = require("codetyper.prompts.agents.grep").params
+local returns = require("codetyper.prompts.agents.grep").returns
+
+---@class CoderTool
+local M = setmetatable({}, Base)
+
+M.name = "grep"
+M.description = description
+M.params = params
+M.returns = returns
+
+M.requires_confirmation = false
+
+---@param input {pattern: string, path?: string, include?: string, max_results?: integer}
+---@param opts CoderToolOpts
+---@return string|nil result
+---@return string|nil error
+function M.func(input, opts)
+	if not input.pattern then
+		return nil, "pattern is required"
+	end
+
+	-- Log the operation
+	if opts.on_log then
+		opts.on_log("Searching for: " .. input.pattern)
+	end
+
+	-- Build ripgrep command
+	local path = input.path or vim.fn.getcwd()
+	local max_results = input.max_results or 50
+
+	-- Resolve path
+	if not vim.startswith(path, "/") then
+		path = vim.fn.getcwd() .. "/" .. path
+	end
+
+	-- Check if ripgrep is available
+	if vim.fn.executable("rg") ~= 1 then
+		return nil, "ripgrep (rg) is not installed"
+	end
+
+	-- Build command args
+	local args = {
+		"--json",
+		"--max-count",
+		tostring(max_results),
+		"--no-heading",
+	}
+
+	if input.include then
+		table.insert(args, "--glob")
+		table.insert(args, input.include)
+	end
+
+	table.insert(args, input.pattern)
+	table.insert(args, path)
+
+	-- Execute ripgrep
+	local Job = require("plenary.job")
+	local job = Job:new({
+		command = "rg",
+		args = args,
+		cwd = vim.fn.getcwd(),
+	})
+
+	job:sync(30000) -- 30 second timeout
+
+	local results = job:result() or {}
+	local matches = {}
+
+	-- Parse JSON output
+	for _, line in ipairs(results) do
+		if line and line ~= "" then
+			local ok, parsed = pcall(vim.json.decode, line)
+			if ok and parsed.type == "match" then
+				local data = parsed.data
+				table.insert(matches, {
+					file = data.path.text,
+					line_number = data.line_number,
+					content = data.lines.text:gsub("\n$", ""),
+				})
+			end
+		end
+	end
+
+	-- Return as JSON
+	local result = vim.json.encode({
+		matches = matches,
+		total = #matches,
+		truncated = #matches >= max_results,
+	})
+
+	if opts.on_complete then
+		opts.on_complete(result, nil)
+	end
+
+	return result, nil
+end
+
+return M
--- a/lua/codetyper/core/tools/init.lua
+++ b/lua/codetyper/core/tools/init.lua
@@ -0,0 +1,90 @@
+---@mod codetyper.agent.tools Tool definitions for the agent system
+---
+--- Defines available tools that the LLM can use to interact with files and system.
+
+local M = {}
+
+--- Tool definitions in a provider-agnostic format
+M.definitions = require("codetyper.params.agents.tools").definitions
+
+--- Convert tool definitions to Claude API format
+---@return table[] Tools in Claude's expected format
+function M.to_claude_format()
+  local tools = {}
+  for _, tool in pairs(M.definitions) do
+    table.insert(tools, {
+      name = tool.name,
+      description = tool.description,
+      input_schema = tool.parameters,
+    })
+  end
+  return tools
+end
+
+--- Convert tool definitions to OpenAI API format
+---@return table[] Tools in OpenAI's expected format
+function M.to_openai_format()
+  local tools = {}
+  for _, tool in pairs(M.definitions) do
+    table.insert(tools, {
+      type = "function",
+      ["function"] = {
+        name = tool.name,
+        description = tool.description,
+        parameters = tool.parameters,
+      },
+    })
+  end
+  return tools
+end
+
+--- Convert tool definitions to prompt format for Ollama
+---@return string Formatted tool descriptions for system prompt
+function M.to_prompt_format()
+  local prompts = require("codetyper.prompts.agents.tools").instructions
+  local lines = {
+    prompts.intro,
+    "",
+  }
+
+  for _, tool in pairs(M.definitions) do
+    table.insert(lines, "## " .. tool.name)
+    table.insert(lines, tool.description)
+    table.insert(lines, "")
+    table.insert(lines, "Parameters:")
+    for prop_name, prop in pairs(tool.parameters.properties) do
+      local required = vim.tbl_contains(tool.parameters.required or {}, prop_name)
+      local req_str = required and " (required)" or " (optional)"
+      table.insert(lines, "  - " .. prop_name .. ": " .. prop.description .. req_str)
+    end
+    table.insert(lines, "")
+  end
+
+  table.insert(lines, "---")
+  table.insert(lines, "")
+  table.insert(lines, prompts.header)
+  table.insert(lines, prompts.example)
+  table.insert(lines, "")
+  table.insert(lines, prompts.footer)
+
+  return table.concat(lines, "\n")
+end
+
+--- Get a list of tool names
+---@return string[]
+function M.get_tool_names()
+  local names = {}
+  for name, _ in pairs(M.definitions) do
+    table.insert(names, name)
+  end
+  return names
+end
+
+--- Optional setup function for future extensibility
+---@param opts table|nil Configuration options
+function M.setup(opts)
+  -- Currently a no-op. Plugins or tests may call setup(); keep for compatibility.
+end
+
+return M
+
--- a/lua/codetyper/core/tools/registry.lua
+++ b/lua/codetyper/core/tools/registry.lua
@@ -0,0 +1,308 @@
+---@mod codetyper.agent.tools Tool registry and orchestration
+---@brief [[
+--- Registry for LLM tools with execution and schema generation.
+--- Tool system for agent mode.
+---@brief ]]
+
+local M = {}
+
+--- Registered tools
+---@type table<string, CoderTool>
+local tools = {}
+
+--- Tool execution history for current session
+---@type table[]
+local execution_history = {}
+
+--- Register a tool
+---@param tool CoderTool Tool to register
+function M.register(tool)
+	if not tool.name then
+		error("Tool must have a name")
+	end
+	tools[tool.name] = tool
+end
+
+--- Unregister a tool
+---@param name string Tool name
+function M.unregister(name)
+	tools[name] = nil
+end
+
+--- Get a tool by name
+---@param name string Tool name
+---@return CoderTool|nil
+function M.get(name)
+	return tools[name]
+end
+
+--- Get all registered tools
+---@return table<string, CoderTool>
+function M.get_all()
+	return tools
+end
+
+--- Get tools as a list
+---@param filter? fun(tool: CoderTool): boolean Optional filter function
+---@return CoderTool[]
+function M.list(filter)
+	local result = {}
+	for _, tool in pairs(tools) do
+		if not filter or filter(tool) then
+			table.insert(result, tool)
+		end
+	end
+	return result
+end
+
+--- Generate schemas for all tools (for LLM function calling)
+---@param filter? fun(tool: CoderTool): boolean Optional filter function
+---@return table[] schemas
+function M.get_schemas(filter)
+	local schemas = {}
+	for _, tool in pairs(tools) do
+		if not filter or filter(tool) then
+			if tool.to_schema then
+				table.insert(schemas, tool:to_schema())
+			end
+		end
+	end
+	return schemas
+end
+
+--- Execute a tool by name
+---@param name string Tool name
+---@param input table Input parameters
+---@param opts CoderToolOpts Execution options
+---@return any result
+---@return string|nil error
+function M.execute(name, input, opts)
+	local tool = tools[name]
+	if not tool then
+		return nil, "Unknown tool: " .. name
+	end
+
+	-- Validate input
+	if tool.validate_input then
+		local valid, err = tool:validate_input(input)
+		if not valid then
+			return nil, err
+		end
+	end
+
+	-- Log execution
+	if opts.on_log then
+		opts.on_log(string.format("Executing tool: %s", name))
+	end
+
+	-- Track execution
+	local execution = {
+		tool = name,
+		input = input,
+		start_time = os.time(),
+		status = "running",
+	}
+	table.insert(execution_history, execution)
+
+	-- Execute the tool
+	local result, err = tool.func(input, opts)
+
+	-- Update execution record
+	execution.end_time = os.time()
+	execution.status = err and "error" or "completed"
+	execution.result = result
+	execution.error = err
+
+	return result, err
+end
+
+--- Process a tool call from LLM response
+---@param tool_call table Tool call from LLM (name + input)
+---@param opts CoderToolOpts Execution options
+---@return any result
+---@return string|nil error
+function M.process_tool_call(tool_call, opts)
+	local name = tool_call.name or tool_call.function_name
+	local input = tool_call.input or tool_call.arguments or {}
+
+	-- Parse JSON arguments if string
+	if type(input) == "string" then
+		local ok, parsed = pcall(vim.json.decode, input)
+		if ok then
+			input = parsed
+		else
+			return nil, "Failed to parse tool arguments: " .. input
+		end
+	end
+
+	return M.execute(name, input, opts)
+end
+
+--- Get execution history
+---@param limit? number Max entries to return
+---@return table[]
+function M.get_history(limit)
+	if not limit then
+		return execution_history
+	end
+
+	local result = {}
+	local start = math.max(1, #execution_history - limit + 1)
+	for i = start, #execution_history do
+		table.insert(result, execution_history[i])
+	end
+	return result
+end
+
+--- Clear execution history
+function M.clear_history()
+	execution_history = {}
+end
+
+--- Load built-in tools
+function M.load_builtins()
+	-- View file tool
+	local view = require("codetyper.core.tools.view")
+	M.register(view)
+
+	-- Bash tool
+	local bash = require("codetyper.core.tools.bash")
+	M.register(bash)
+
+	-- Grep tool
+	local grep = require("codetyper.core.tools.grep")
+	M.register(grep)
+
+	-- Glob tool
+	local glob = require("codetyper.core.tools.glob")
+	M.register(glob)
+
+	-- Write file tool
+	local write = require("codetyper.core.tools.write")
+	M.register(write)
+
+	-- Edit tool
+	local edit = require("codetyper.core.tools.edit")
+	M.register(edit)
+end
+
+--- Initialize tools system
+function M.setup()
+	M.load_builtins()
+end
+
+--- Get tool definitions for LLM (lazy-loaded, OpenAI format)
+--- This is accessed as M.definitions property
+M.definitions = setmetatable({}, {
+	__call = function()
+		-- Ensure tools are loaded
+		if vim.tbl_count(tools) == 0 then
+			M.load_builtins()
+		end
+		return M.to_openai_format()
+	end,
+	__index = function(_, key)
+		-- Make it work as both function and table
+		if key == "get" then
+			return function()
+				if vim.tbl_count(tools) == 0 then
+					M.load_builtins()
+				end
+				return M.to_openai_format()
+			end
+		end
+		return nil
+	end,
+})
+
+--- Get definitions as a function (for backwards compatibility)
+function M.get_definitions()
+	if vim.tbl_count(tools) == 0 then
+		M.load_builtins()
+	end
+	return M.to_openai_format()
+end
+
+--- Convert all tools to OpenAI function calling format
+---@param filter? fun(tool: CoderTool): boolean Optional filter function
+---@return table[] OpenAI-compatible tool definitions
+function M.to_openai_format(filter)
+	local openai_tools = {}
+
+	for _, tool in pairs(tools) do
+		if not filter or filter(tool) then
+			local properties = {}
+			local required = {}
+
+			for _, param in ipairs(tool.params or {}) do
+				properties[param.name] = {
+					type = param.type == "integer" and "number" or param.type,
+					description = param.description,
+				}
+				if param.default ~= nil then
+					properties[param.name].default = param.default
+				end
+				if not param.optional then
+					table.insert(required, param.name)
+				end
+			end
+
+			local description = type(tool.description) == "function" and tool.description() or tool.description
+
+			table.insert(openai_tools, {
+				type = "function",
+				["function"] = {
+					name = tool.name,
+					description = description,
+					parameters = {
+						type = "object",
+						properties = properties,
+						required = required,
+					},
+				},
+			})
+		end
+	end
+
+	return openai_tools
+end
+
+--- Convert all tools to Claude tool use format
+---@param filter? fun(tool: CoderTool): boolean Optional filter function
+---@return table[] Claude-compatible tool definitions
+function M.to_claude_format(filter)
+	local claude_tools = {}
+
+	for _, tool in pairs(tools) do
+		if not filter or filter(tool) then
+			local properties = {}
+			local required = {}
+
+			for _, param in ipairs(tool.params or {}) do
+				properties[param.name] = {
+					type = param.type == "integer" and "number" or param.type,
+					description = param.description,
+				}
+				if not param.optional then
+					table.insert(required, param.name)
+				end
+			end
+
+			local description = type(tool.description) == "function" and tool.description() or tool.description
+
+			table.insert(claude_tools, {
+				name = tool.name,
+				description = description,
+				input_schema = {
+					type = "object",
+					properties = properties,
+					required = required,
+				},
+			})
+		end
+	end
+
+	return claude_tools
+end
+
+return M
--- a/lua/codetyper/core/tools/view.lua
+++ b/lua/codetyper/core/tools/view.lua
@@ -0,0 +1,114 @@
+---@mod codetyper.agent.tools.view File viewing tool
+---@brief [[
+--- Tool for reading file contents with line range support.
+---@brief ]]
+
+local Base = require("codetyper.core.tools.base")
+
+---@class CoderTool
+local M = setmetatable({}, Base)
+
+M.name = "view"
+
+local params = require("codetyper.params.agents.view")
+local description = require("codetyper.prompts.agents.view").description
+
+M.description = description
+M.params = params.params
+M.returns = params.returns
+
+M.requires_confirmation = false
+
+--- Maximum content size before truncation
+local MAX_CONTENT_SIZE = 200 * 1024 -- 200KB
+
+---@param input {path: string, start_line?: integer, end_line?: integer}
+---@param opts CoderToolOpts
+---@return string|nil result
+---@return string|nil error
+function M.func(input, opts)
+	if not input.path then
+		return nil, "path is required"
+	end
+
+	-- Log the operation
+	if opts.on_log then
+		opts.on_log("Reading file: " .. input.path)
+	end
+
+	-- Resolve path
+	local path = input.path
+	if not vim.startswith(path, "/") then
+		-- Relative path - resolve from project root
+		local root = vim.fn.getcwd()
+		path = root .. "/" .. path
+	end
+
+	-- Check if file exists
+	local stat = vim.uv.fs_stat(path)
+	if not stat then
+		return nil, "File not found: " .. input.path
+	end
+
+	if stat.type == "directory" then
+		return nil, "Path is a directory: " .. input.path
+	end
+
+	-- Read file
+	local lines = vim.fn.readfile(path)
+	if not lines then
+		return nil, "Failed to read file: " .. input.path
+	end
+
+	-- Apply line range
+	local start_line = input.start_line or 1
+	local end_line = input.end_line or #lines
+
+	start_line = math.max(1, start_line)
+	end_line = math.min(#lines, end_line)
+
+	local total_lines = #lines
+	local selected_lines = {}
+
+	for i = start_line, end_line do
+		table.insert(selected_lines, lines[i])
+	end
+
+	-- Check for truncation
+	local content = table.concat(selected_lines, "\n")
+	local is_truncated = false
+
+	if #content > MAX_CONTENT_SIZE then
+		-- Truncate content
+		local truncated_lines = {}
+		local size = 0
+
+		for _, line in ipairs(selected_lines) do
+			size = size + #line + 1
+			if size > MAX_CONTENT_SIZE then
+				is_truncated = true
+				break
+			end
+			table.insert(truncated_lines, line)
+		end
+
+		content = table.concat(truncated_lines, "\n")
+	end
+
+	-- Return as JSON
+	local result = vim.json.encode({
+		content = content,
+		total_line_count = total_lines,
+		is_truncated = is_truncated,
+		start_line = start_line,
+		end_line = end_line,
+	})
+
+	if opts.on_complete then
+		opts.on_complete(result, nil)
+	end
+
+	return result, nil
+end
+
+return M
--- a/lua/codetyper/core/tools/write.lua
+++ b/lua/codetyper/core/tools/write.lua
@@ -0,0 +1,72 @@
+---@mod codetyper.agent.tools.write File writing tool
+---@brief [[
+--- Tool for creating or overwriting files.
+---@brief ]]
+
+local Base = require("codetyper.core.tools.base")
+local description = require("codetyper.prompts.agents.write").description
+local params = require("codetyper.params.agents.write")
+
+---@class CoderTool
+local M = setmetatable({}, Base)
+
+M.name = "write"
+M.description = description
+M.params = params.params
+M.returns = params.returns
+
+M.requires_confirmation = true
+
+---@param input {path: string, content: string}
+---@param opts CoderToolOpts
+---@return boolean|nil result
+---@return string|nil error
+function M.func(input, opts)
+	if not input.path then
+		return nil, "path is required"
+	end
+	if not input.content then
+		return nil, "content is required"
+	end
+
+	-- Log the operation
+	if opts.on_log then
+		opts.on_log("Writing file: " .. input.path)
+	end
+
+	-- Resolve path
+	local path = input.path
+	if not vim.startswith(path, "/") then
+		path = vim.fn.getcwd() .. "/" .. path
+	end
+
+	-- Create parent directories
+	local dir = vim.fn.fnamemodify(path, ":h")
+	if vim.fn.isdirectory(dir) == 0 then
+		vim.fn.mkdir(dir, "p")
+	end
+
+	-- Write the file
+	local lines = vim.split(input.content, "\n", { plain = true })
+	local ok = pcall(vim.fn.writefile, lines, path)
+
+	if not ok then
+		return nil, "Failed to write file: " .. path
+	end
+
+	-- Reload buffer if open
+	local bufnr = vim.fn.bufnr(path)
+	if bufnr ~= -1 and vim.api.nvim_buf_is_valid(bufnr) then
+		vim.api.nvim_buf_call(bufnr, function()
+			vim.cmd("edit!")
+		end)
+	end
+
+	if opts.on_complete then
+		opts.on_complete(true, nil)
+	end
+
+	return true, nil
+end
+
+return M
--- a/lua/codetyper/features/agents/context_builder.lua
+++ b/lua/codetyper/features/agents/context_builder.lua
@@ -0,0 +1,268 @@
+---@mod codetyper.agent.context_builder Context builder for agent prompts
+---
+--- Builds rich context including project structure, memories, and conventions
+--- to help the LLM understand the codebase.
+
+local M = {}
+
+local utils = require("codetyper.support.utils")
+local params = require("codetyper.params.agents.context")
+
+--- Get project structure as a tree string
+---@param max_depth? number Maximum depth to traverse (default: 3)
+---@param max_files? number Maximum files to show (default: 50)
+---@return string Project tree
+function M.get_project_structure(max_depth, max_files)
+  max_depth = max_depth or 3
+  max_files = max_files or 50
+
+  local root = utils.get_project_root() or vim.fn.getcwd()
+  local lines = { "PROJECT STRUCTURE:", root, "" }
+  local file_count = 0
+
+  -- Common ignore patterns
+  local ignore_patterns = params.ignore_patterns
+
+  local function should_ignore(name)
+    for _, pattern in ipairs(ignore_patterns) do
+      if name:match(pattern) then
+        return true
+      end
+    end
+    return false
+  end
+
+  local function traverse(path, depth, prefix)
+    if depth > max_depth or file_count >= max_files then
+      return
+    end
+
+    local entries = {}
+    local handle = vim.loop.fs_scandir(path)
+    if not handle then
+      return
+    end
+
+    while true do
+      local name, type = vim.loop.fs_scandir_next(handle)
+      if not name then
+        break
+      end
+      if not should_ignore(name) then
+        table.insert(entries, { name = name, type = type })
+      end
+    end
+
+    -- Sort: directories first, then alphabetically
+    table.sort(entries, function(a, b)
+      if a.type == "directory" and b.type ~= "directory" then
+        return true
+      elseif a.type ~= "directory" and b.type == "directory" then
+        return false
+      else
+        return a.name < b.name
+      end
+    end)
+
+    for i, entry in ipairs(entries) do
+      if file_count >= max_files then
+        table.insert(lines, prefix .. "... (truncated)")
+        return
+      end
+
+      local is_last = (i == #entries)
+      local branch = is_last and "└── " or "├── "
+      local new_prefix = prefix .. (is_last and "    " or "│   ")
+
+      local icon = entry.type == "directory" and "/" or ""
+      table.insert(lines, prefix .. branch .. entry.name .. icon)
+      file_count = file_count + 1
+
+      if entry.type == "directory" then
+        traverse(path .. "/" .. entry.name, depth + 1, new_prefix)
+      end
+    end
+  end
+
+  traverse(root, 1, "")
+
+  if file_count >= max_files then
+    table.insert(lines, "")
+    table.insert(lines, "(Structure truncated at " .. max_files .. " entries)")
+  end
+
+  return table.concat(lines, "\n")
+end
+
+--- Get key files that are important for understanding the project
+---@return table<string, string> Map of filename to description
+function M.get_key_files()
+  local root = utils.get_project_root() or vim.fn.getcwd()
+  local key_files = {}
+
+  local important_files = {
+    ["package.json"] = "Node.js project config",
+    ["Cargo.toml"] = "Rust project config",
+    ["go.mod"] = "Go module config",
+    ["pyproject.toml"] = "Python project config",
+    ["setup.py"] = "Python setup config",
+    ["Makefile"] = "Build configuration",
+    ["CMakeLists.txt"] = "CMake config",
+    [".gitignore"] = "Git ignore patterns",
+    ["README.md"] = "Project documentation",
+    ["init.lua"] = "Neovim plugin entry",
+    ["plugin.lua"] = "Neovim plugin config",
+  }
+
+  for filename, desc in paparams.important_filesnd
+
+  return key_files
+end
+
+--- Detect project type and language
+---@return table { type: string, language: string, framework?: string }
+function M.detect_project_type()
+  local root = utils.get_project_root() or vim.fn.getcwd()
+
+  local indicators = {
+    ["package.json"] = { type = "node", language = "javascript/typescript" },
+    ["Cargo.toml"] = { type = "rust", language = "rust" },
+    ["go.mod"] = { type = "go", language = "go" },
+    ["pyproject.toml"] = { type = "python", language = "python" },
+    ["setup.py"] = { type = "python", language = "python" },
+    ["Gemfile"] = { type = "ruby", language = "ruby" },
+    ["pom.xml"] = { type = "maven", language = "java" },
+    ["build.gradle"] = { type = "gradle", language = "java/kotlin" },
+  }
+
+  -- Check for Neovim plugin specifically
+  if vim.fn.isdirectoparams.indicators   return info
+    end
+  end
+
+  return { type = "unknown", language = "unknown" }
+end
+
+--- Get memories/patterns from the brain system
+---@return string Formatted memories context
+function M.get_memories_context()
+  local ok_memory, memory = pcall(require, "codetyper.indexer.memory")
+  if not ok_memory then
+    return ""
+  end
+
+  local all = memory.get_all()
+  if not all then
+    return ""
+  end
+
+  local lines = {}
+
+  -- Add patterns
+  if all.patterns and next(all.patterns) then
+    table.insert(lines, "LEARNED PATTERNS:")
+    local count = 0
+    for _, mem in pairs(all.patterns) do
+      if count >= 5 then
+        break
+      end
+      if mem.content then
+        table.insert(lines, "  - " .. mem.content:sub(1, 100))
+        count = count + 1
+      end
+    end
+    table.insert(lines, "")
+  end
+
+  -- Add conventions
+  if all.conventions and next(all.conventions) then
+    table.insert(lines, "CODING CONVENTIONS:")
+    local count = 0
+    for _, mem in pairs(all.conventions) do
+      if count >= 5 then
+        break
+      end
+      if mem.content then
+        table.insert(lines, "  - " .. mem.content:sub(1, 100))
+        count = count + 1
+      end
+    end
+    table.insert(lines, "")
+  end
+
+  return table.concat(lines, "\n")
+end
+
+--- Build the full context for agent prompts
+---@return string Full context string
+function M.build_full_context()
+  local sections = {}
+
+  -- Project info
+  local project_type = M.detect_project_type()
+  table.insert(sections, string.format(
+    "PROJECT INFO:\n  Type: %s\n  Language: %s%s\n",
+    project_type.type,
+    project_type.language,
+    project_type.framework and ("\n  Framework: " .. project_type.framework) or ""
+  ))
+
+  -- Project structure
+  local structure = M.get_project_structure(3, 40)
+  table.insert(sections, structure)
+
+  -- Key files
+  local key_files = M.get_key_files()
+  if next(key_files) then
+    local key_lines = { "", "KEY FILES:" }
+    for name, info in pairs(key_files) do
+      table.insert(key_lines, string.format("  %s - %s", name, info.description))
+    end
+    table.insert(sections, table.concat(key_lines, "\n"))
+  end
+
+  -- Memories
+  local memories = M.get_memories_context()
+  if memories ~= "" then
+    table.insert(sections, "\n" .. memories)
+  end
+
+  return table.concat(sections, "\n")
+end
+
+--- Get a compact context summary for token efficiency
+---@return string Compact context
+function M.build_compact_context()
+  local root = utils.get_project_root() or vim.fn.getcwd()
+  local project_type = M.detect_project_type()
+
+  local lines = {
+    "CONTEXT:",
+    "  Root: " .. root,
+    "  Type: " .. project_type.type .. " (" .. project_type.language .. ")",
+  }
+
+  -- Add main directories
+  local main_dirs = {}
+  local handle = vim.loop.fs_scandir(root)
+  if handle then
+    while true do
+      local name, type = vim.loop.fs_scandir_next(handle)
+      if not name then
+        break
+      end
+      if type == "directory" and not name:match("^%.") and not name:match("node_modules") then
+        table.insert(main_dirs, name .. "/")
+      end
+    end
+  end
+
+  if #main_dirs > 0 then
+    table.sort(main_dirs)
+    table.insert(lines, "  Main dirs: " .. table.concat(main_dirs, ", "))
+  end
+
+  return table.concat(lines, "\n")
+end
+
+return M
--- a/lua/codetyper/features/agents/engine.lua
+++ b/lua/codetyper/features/agents/engine.lua
@@ -0,0 +1,754 @@
+---@mod codetyper.agent.agentic Agentic loop with proper tool calling
+---@brief [[
+--- Full agentic system that handles multi-file changes via tool calling.
+--- Multi-file agent system with tool orchestration.
+---@brief ]]
+
+local M = {}
+
+---@class AgenticMessage
+---@field role "system"|"user"|"assistant"|"tool"
+---@field content string|table
+---@field tool_calls? table[] For assistant messages with tool calls
+---@field tool_call_id? string For tool result messages
+---@field name? string Tool name for tool results
+
+---@class AgenticToolCall
+---@field id string Unique tool call ID
+---@field type "function"
+---@field function {name: string, arguments: string|table}
+
+---@class AgenticOpts
+---@field task string The task to accomplish
+---@field files? string[] Initial files to include as context
+---@field agent? string Agent name to use (default: "coder")
+---@field model? string Model override
+---@field max_iterations? number Max tool call rounds (default: 20)
+---@field on_message? fun(msg: AgenticMessage) Called for each message
+---@field on_tool_start? fun(name: string, args: table) Called before tool execution
+---@field on_tool_end? fun(name: string, result: any, error: string|nil) Called after tool execution
+---@field on_file_change? fun(path: string, action: string) Called when file is modified
+---@field on_complete? fun(result: string|nil, error: string|nil) Called when done
+---@field on_status? fun(status: string) Status updates
+
+local utils = require("codetyper.support.utils")
+
+--- Load agent definition
+---@param name string Agent name
+---@return table|nil agent definition
+local function load_agent(name)
+	local agents_dir = vim.fn.getcwd() .. "/.coder/agents"
+	local agent_file = agents_dir .. "/" .. name .. ".md"
+
+	-- Check if custom agent exists
+	if vim.fn.filereadable(agent_file) == 1 then
+		local content = table.concat(vim.fn.readfile(agent_file), "\n")
+		-- Parse frontmatter and content
+		local frontmatter = {}
+		local body = content
+
+		local fm_match = content:match("^%-%-%-\n(.-)%-%-%-\n(.*)$")
+		if fm_match then
+			-- Parse YAML-like frontmatter
+			for line in content:match("^%-%-%-\n(.-)%-%-%-"):gmatch("[^\n]+") do
+				local key, value = line:match("^(%w+):%s*(.+)$")
+				if key and value then
+					frontmatter[key] = value
+				end
+			end
+			body = content:match("%-%-%-\n.-%-%-%-%s*\n(.*)$") or content
+		end
+
+		return {
+			name = name,
+			description = frontmatter.description or "Custom agent: " .. name,
+			system_prompt = body,
+			tools = frontmatter.tools and vim.split(frontmatter.tools, ",") or nil,
+			model = frontmatter.model,
+		}
+	end
+
+	-- Built-in agents
+	local builtin_agents = require("codetyper.prompts.agents.personas").builtin
+
+	return builtin_agents[name]
+end
+
+--- Load rules from .coder/rules/
+---@return string Combined rules content
+local function load_rules()
+	local rules_dir = vim.fn.getcwd() .. "/.coder/rules"
+	local rules = {}
+
+	if vim.fn.isdirectory(rules_dir) == 1 then
+		local files = vim.fn.glob(rules_dir .. "/*.md", false, true)
+		for _, file in ipairs(files) do
+			local content = table.concat(vim.fn.readfile(file), "\n")
+			local filename = vim.fn.fnamemodify(file, ":t:r")
+			table.insert(rules, string.format("## Rule: %s\n%s", filename, content))
+		end
+	end
+
+	if #rules > 0 then
+		return "\n\n# Project Rules\n" .. table.concat(rules, "\n\n")
+	end
+	return ""
+end
+
+--- Build messages array for API request
+---@param history AgenticMessage[]
+---@param provider string "openai"|"claude"
+---@return table[] Formatted messages
+local function build_messages(history, provider)
+	local messages = {}
+
+	for _, msg in ipairs(history) do
+		if msg.role == "system" then
+			if provider == "claude" then
+				-- Claude uses system parameter, not message
+				-- Skip system messages in array
+			else
+				table.insert(messages, {
+					role = "system",
+					content = msg.content,
+				})
+			end
+		elseif msg.role == "user" then
+			table.insert(messages, {
+				role = "user",
+				content = msg.content,
+			})
+		elseif msg.role == "assistant" then
+			local message = {
+				role = "assistant",
+				content = msg.content,
+			}
+			if msg.tool_calls then
+				message.tool_calls = msg.tool_calls
+				if provider == "claude" then
+					-- Claude format: content is array of blocks
+					message.content = {}
+					if msg.content and msg.content ~= "" then
+						table.insert(message.content, {
+							type = "text",
+							text = msg.content,
+						})
+					end
+					for _, tc in ipairs(msg.tool_calls) do
+						table.insert(message.content, {
+							type = "tool_use",
+							id = tc.id,
+							name = tc["function"].name,
+							input = type(tc["function"].arguments) == "string"
+									and vim.json.decode(tc["function"].arguments)
+								or tc["function"].arguments,
+						})
+					end
+				end
+			end
+			table.insert(messages, message)
+		elseif msg.role == "tool" then
+			if provider == "claude" then
+				table.insert(messages, {
+					role = "user",
+					content = {
+						{
+							type = "tool_result",
+							tool_use_id = msg.tool_call_id,
+							content = msg.content,
+						},
+					},
+				})
+			else
+				table.insert(messages, {
+					role = "tool",
+					tool_call_id = msg.tool_call_id,
+					content = type(msg.content) == "string" and msg.content or vim.json.encode(msg.content),
+				})
+			end
+		end
+	end
+
+	return messages
+end
+
+--- Build tools array for API request
+---@param tool_names string[] Tool names to include
+---@param provider string "openai"|"claude"
+---@return table[] Formatted tools
+local function build_tools(tool_names, provider)
+	local tools_mod = require("codetyper.core.tools")
+	local tools = {}
+
+	for _, name in ipairs(tool_names) do
+		local tool = tools_mod.get(name)
+		if tool then
+			local properties = {}
+			local required = {}
+
+			for _, param in ipairs(tool.params or {}) do
+				properties[param.name] = {
+					type = param.type == "integer" and "number" or param.type,
+					description = param.description,
+				}
+				if not param.optional then
+					table.insert(required, param.name)
+				end
+			end
+
+			local description = type(tool.description) == "function" and tool.description() or tool.description
+
+			if provider == "claude" then
+				table.insert(tools, {
+					name = tool.name,
+					description = description,
+					input_schema = {
+						type = "object",
+						properties = properties,
+						required = required,
+					},
+				})
+			else
+				table.insert(tools, {
+					type = "function",
+					["function"] = {
+						name = tool.name,
+						description = description,
+						parameters = {
+							type = "object",
+							properties = properties,
+							required = required,
+						},
+					},
+				})
+			end
+		end
+	end
+
+	return tools
+end
+
+--- Execute a tool call
+---@param tool_call AgenticToolCall
+---@param opts AgenticOpts
+---@return string result
+---@return string|nil error
+local function execute_tool(tool_call, opts)
+	local tools_mod = require("codetyper.core.tools")
+	local name = tool_call["function"].name
+	local args = tool_call["function"].arguments
+
+	-- Parse arguments if string
+	if type(args) == "string" then
+		local ok, parsed = pcall(vim.json.decode, args)
+		if ok then
+			args = parsed
+		else
+			return "", "Failed to parse tool arguments: " .. args
+		end
+	end
+
+	-- Notify tool start
+	if opts.on_tool_start then
+		opts.on_tool_start(name, args)
+	end
+
+	if opts.on_status then
+		opts.on_status("Executing: " .. name)
+	end
+
+	-- Execute the tool
+	local tool = tools_mod.get(name)
+	if not tool then
+		local err = "Unknown tool: " .. name
+		if opts.on_tool_end then
+			opts.on_tool_end(name, nil, err)
+		end
+		return "", err
+	end
+
+	local result, err = tool.func(args, {
+		on_log = function(msg)
+			if opts.on_status then
+				opts.on_status(msg)
+			end
+		end,
+	})
+
+	-- Notify tool end
+	if opts.on_tool_end then
+		opts.on_tool_end(name, result, err)
+	end
+
+	-- Track file changes
+	if opts.on_file_change and (name == "write" or name == "edit") and not err then
+		opts.on_file_change(args.path, name == "write" and "created" or "modified")
+	end
+
+	if err then
+		return "", err
+	end
+
+	return type(result) == "string" and result or vim.json.encode(result), nil
+end
+
+--- Parse tool calls from LLM response (unified Claude-like format)
+---@param response table Raw API response in unified format
+---@param provider string Provider name (unused, kept for signature compatibility)
+---@return AgenticToolCall[]
+local function parse_tool_calls(response, provider)
+	local tool_calls = {}
+
+	-- Unified format: content array with tool_use blocks
+	local content = response.content or {}
+	for _, block in ipairs(content) do
+		if block.type == "tool_use" then
+			-- OpenAI expects arguments as JSON string, not table
+			local args = block.input
+			if type(args) == "table" then
+				args = vim.json.encode(args)
+			end
+
+			table.insert(tool_calls, {
+				id = block.id or utils.generate_id("call"),
+				type = "function",
+				["function"] = {
+					name = block.name,
+					arguments = args,
+				},
+			})
+		end
+	end
+
+	return tool_calls
+end
+
+--- Extract text content from response (unified Claude-like format)
+---@param response table Raw API response in unified format
+---@param provider string Provider name (unused, kept for signature compatibility)
+---@return string
+local function extract_content(response, provider)
+	local parts = {}
+	for _, block in ipairs(response.content or {}) do
+		if block.type == "text" then
+			table.insert(parts, block.text)
+		end
+	end
+	return table.concat(parts, "\n")
+end
+
+--- Check if response indicates completion (unified Claude-like format)
+---@param response table Raw API response in unified format
+---@param provider string Provider name (unused, kept for signature compatibility)
+---@return boolean
+local function is_complete(response, provider)
+	return response.stop_reason == "end_turn"
+end
+
+--- Make API request to LLM with native tool calling support
+---@param messages table[] Formatted messages
+---@param tools table[] Formatted tools
+---@param system_prompt string System prompt
+---@param provider string "openai"|"claude"|"copilot"
+---@param model string Model name
+---@param callback fun(response: table|nil, error: string|nil)
+local function call_llm(messages, tools, system_prompt, provider, model, callback)
+	local context = {
+		language = "lua",
+		file_content = "",
+		prompt_type = "agent",
+		project_root = vim.fn.getcwd(),
+		cwd = vim.fn.getcwd(),
+	}
+
+	-- Use native tool calling APIs
+	if provider == "copilot" then
+		local client = require("codetyper.core.llm.copilot")
+
+		-- Copilot's generate_with_tools expects messages in a specific format
+		-- Convert to the format it expects
+		local converted_messages = {}
+		for _, msg in ipairs(messages) do
+			if msg.role ~= "system" then
+				table.insert(converted_messages, msg)
+			end
+		end
+
+		client.generate_with_tools(converted_messages, context, tools, function(response, err)
+			if err then
+				callback(nil, err)
+				return
+			end
+
+			-- Response is already in Claude-like format from the provider
+			-- Convert to our internal format
+			local result = {
+				content = {},
+				stop_reason = "end_turn",
+			}
+
+			if response and response.content then
+				for _, block in ipairs(response.content) do
+					if block.type == "text" then
+						table.insert(result.content, { type = "text", text = block.text })
+					elseif block.type == "tool_use" then
+						table.insert(result.content, {
+							type = "tool_use",
+							id = block.id or utils.generate_id("call"),
+							name = block.name,
+							input = block.input,
+						})
+						result.stop_reason = "tool_use"
+					end
+				end
+			end
+
+			callback(result, nil)
+		end)
+	elseif provider == "openai" then
+		local client = require("codetyper.core.llm.openai")
+
+		-- OpenAI's generate_with_tools
+		local converted_messages = {}
+		for _, msg in ipairs(messages) do
+			if msg.role ~= "system" then
+				table.insert(converted_messages, msg)
+			end
+		end
+
+		client.generate_with_tools(converted_messages, context, tools, function(response, err)
+			if err then
+				callback(nil, err)
+				return
+			end
+
+			-- Response is already in Claude-like format from the provider
+			local result = {
+				content = {},
+				stop_reason = "end_turn",
+			}
+
+			if response and response.content then
+				for _, block in ipairs(response.content) do
+					if block.type == "text" then
+						table.insert(result.content, { type = "text", text = block.text })
+					elseif block.type == "tool_use" then
+						table.insert(result.content, {
+							type = "tool_use",
+							id = block.id or utils.generate_id("call"),
+							name = block.name,
+							input = block.input,
+						})
+						result.stop_reason = "tool_use"
+					end
+				end
+			end
+
+			callback(result, nil)
+		end)
+	elseif provider == "ollama" then
+		local client = require("codetyper.core.llm.ollama")
+
+		-- Ollama's generate_with_tools (text-based tool calling)
+		local converted_messages = {}
+		for _, msg in ipairs(messages) do
+			if msg.role ~= "system" then
+				table.insert(converted_messages, msg)
+			end
+		end
+
+		client.generate_with_tools(converted_messages, context, tools, function(response, err)
+			if err then
+				callback(nil, err)
+				return
+			end
+
+			-- Response is already in Claude-like format from the provider
+			callback(response, nil)
+		end)
+	else
+		-- Fallback for other providers (ollama, etc.) - use text-based parsing
+		local client = require("codetyper.core.llm." .. provider)
+
+		-- Build prompt from messages
+		local prompts = require("codetyper.prompts.agents")
+		local prompt_parts = {}
+		for _, msg in ipairs(messages) do
+			if msg.role == "user" then
+				local content = type(msg.content) == "string" and msg.content or vim.json.encode(msg.content)
+				table.insert(prompt_parts, prompts.text_user_prefix .. content)
+			elseif msg.role == "assistant" then
+				local content = type(msg.content) == "string" and msg.content or vim.json.encode(msg.content)
+				table.insert(prompt_parts, prompts.text_assistant_prefix .. content)
+			end
+		end
+
+		-- Add tool descriptions to prompt for text-based providers
+		local tool_desc = require("codetyper.prompts.agents").tool_instructions_text
+		for _, tool in ipairs(tools) do
+			local name = tool.name or (tool["function"] and tool["function"].name)
+			local desc = tool.description or (tool["function"] and tool["function"].description)
+			if name then
+				tool_desc = tool_desc .. string.format("- **%s**: %s\n", name, desc or "")
+			end
+		end
+
+		context.file_content = system_prompt .. tool_desc
+
+		client.generate(table.concat(prompt_parts, "\n\n"), context, function(response, err)
+			if err then
+				callback(nil, err)
+				return
+			end
+
+			-- Parse response for tool calls (text-based fallback)
+			local result = {
+				content = {},
+				stop_reason = "end_turn",
+			}
+
+			-- Extract text content
+			local text_content = response
+
+			-- Try to extract JSON tool calls from response
+			local json_match = response:match("```json%s*(%b{})%s*```")
+			if json_match then
+				local ok, parsed = pcall(vim.json.decode, json_match)
+				if ok and parsed.tool then
+					table.insert(result.content, {
+						type = "tool_use",
+						id = utils.generate_id("call"),
+						name = parsed.tool,
+						input = parsed.arguments or {},
+					})
+					text_content = response:gsub("```json.-```", ""):gsub("^%s+", ""):gsub("%s+$", "")
+					result.stop_reason = "tool_use"
+				end
+			end
+
+			if text_content and text_content ~= "" then
+				table.insert(result.content, 1, { type = "text", text = text_content })
+			end
+
+			callback(result, nil)
+		end)
+	end
+end
+
+--- Run the agentic loop
+---@param opts AgenticOpts
+function M.run(opts)
+	-- Load agent
+	local agent = load_agent(opts.agent or "coder")
+	if not agent then
+		if opts.on_complete then
+			opts.on_complete(nil, "Unknown agent: " .. (opts.agent or "coder"))
+		end
+		return
+	end
+
+	-- Load rules
+	local rules = load_rules()
+
+	-- Build system prompt
+	local system_prompt = agent.system_prompt .. rules
+
+	-- Initialize message history
+	---@type AgenticMessage[]
+	local history = {
+		{ role = "system", content = system_prompt },
+	}
+
+	-- Add initial file context if provided
+	if opts.files and #opts.files > 0 then
+		local file_context = require("codetyper.prompts.agents").format_file_context(opts.files)
+		table.insert(history, { role = "user", content = file_context })
+		table.insert(history, { role = "assistant", content = "I've reviewed the provided files. What would you like me to do?" })
+	end
+
+	-- Add the task
+	table.insert(history, { role = "user", content = opts.task })
+
+	-- Determine provider
+	local config = require("codetyper").get_config()
+	local provider = config.llm.provider or "copilot"
+	-- Note: Ollama has its own handler in call_llm, don't change it
+
+	-- Get tools for this agent
+	local tool_names = agent.tools or { "view", "edit", "write", "grep", "glob", "bash" }
+
+	-- Ensure tools are loaded
+	local tools_mod = require("codetyper.core.tools")
+	tools_mod.setup()
+
+	-- Build tools for API
+	local tools = build_tools(tool_names, provider)
+
+	-- Iteration tracking
+	local iteration = 0
+	local max_iterations = opts.max_iterations or 20
+
+	--- Process one iteration
+	local function process_iteration()
+		iteration = iteration + 1
+
+		if iteration > max_iterations then
+			if opts.on_complete then
+				opts.on_complete(nil, "Max iterations reached")
+			end
+			return
+		end
+
+		if opts.on_status then
+			opts.on_status(string.format("Thinking... (iteration %d)", iteration))
+		end
+
+		-- Build messages for API
+		local messages = build_messages(history, provider)
+
+		-- Call LLM
+		call_llm(messages, tools, system_prompt, provider, opts.model, function(response, err)
+			if err then
+				if opts.on_complete then
+					opts.on_complete(nil, err)
+				end
+				return
+			end
+
+			-- Extract content and tool calls
+			local content = extract_content(response, provider)
+			local tool_calls = parse_tool_calls(response, provider)
+
+			-- Add assistant message to history
+			local assistant_msg = {
+				role = "assistant",
+				content = content,
+				tool_calls = #tool_calls > 0 and tool_calls or nil,
+			}
+			table.insert(history, assistant_msg)
+
+			if opts.on_message then
+				opts.on_message(assistant_msg)
+			end
+
+			-- Process tool calls if any
+			if #tool_calls > 0 then
+				for _, tc in ipairs(tool_calls) do
+					local result, tool_err = execute_tool(tc, opts)
+
+					-- Add tool result to history
+					local tool_msg = {
+						role = "tool",
+						tool_call_id = tc.id,
+						name = tc["function"].name,
+						content = tool_err or result,
+					}
+					table.insert(history, tool_msg)
+
+					if opts.on_message then
+						opts.on_message(tool_msg)
+					end
+				end
+
+				-- Continue the loop
+				vim.schedule(process_iteration)
+			else
+				-- No tool calls - check if complete
+				if is_complete(response, provider) or content ~= "" then
+					if opts.on_complete then
+						opts.on_complete(content, nil)
+					end
+				else
+					-- Continue if not explicitly complete
+					vim.schedule(process_iteration)
+				end
+			end
+		end)
+	end
+
+	-- Start the loop
+	process_iteration()
+end
+
+--- Create default agent files in .coder/agents/
+function M.init_agents_dir()
+	local agents_dir = vim.fn.getcwd() .. "/.coder/agents"
+	vim.fn.mkdir(agents_dir, "p")
+
+	-- Create example agent
+	local example_agent = require("codetyper.prompts.agents.templates").agent
+
+	local example_path = agents_dir .. "/example.md"
+	if vim.fn.filereadable(example_path) ~= 1 then
+		vim.fn.writefile(vim.split(example_agent, "\n"), example_path)
+	end
+
+	return agents_dir
+end
+
+--- Create default rules in .coder/rules/
+function M.init_rules_dir()
+	local rules_dir = vim.fn.getcwd() .. "/.coder/rules"
+	vim.fn.mkdir(rules_dir, "p")
+
+	-- Create example rule
+	local example_rule = require("codetyper.prompts.agents.templates").rule
+
+	local example_path = rules_dir .. "/code-style.md"
+	if vim.fn.filereadable(example_path) ~= 1 then
+		vim.fn.writefile(vim.split(example_rule, "\n"), example_path)
+	end
+
+	return rules_dir
+end
+
+--- Initialize both agents and rules directories
+function M.init()
+	M.init_agents_dir()
+	M.init_rules_dir()
+end
+
+--- List available agents
+---@return table[] List of {name, description, builtin}
+function M.list_agents()
+	local agents = {}
+
+	-- Built-in agents
+	local personas = require("codetyper.prompts.agents.personas").builtin
+	local builtins = vim.tbl_keys(personas)
+	table.sort(builtins)
+
+	for _, name in ipairs(builtins) do
+		local agent = load_agent(name)
+		if agent then
+			table.insert(agents, {
+				name = agent.name,
+				description = agent.description,
+				builtin = true,
+			})
+		end
+	end
+
+	-- Custom agents from .coder/agents/
+	local agents_dir = vim.fn.getcwd() .. "/.coder/agents"
+	if vim.fn.isdirectory(agents_dir) == 1 then
+		local files = vim.fn.glob(agents_dir .. "/*.md", false, true)
+		for _, file in ipairs(files) do
+			local name = vim.fn.fnamemodify(file, ":t:r")
+			if not vim.tbl_contains(builtins, name) then
+				local agent = load_agent(name)
+				if agent then
+					table.insert(agents, {
+						name = agent.name,
+						description = agent.description,
+						builtin = false,
+					})
+				end
+			end
+		end
+	end
+
+	return agents
+end
+
+return M
--- a/lua/codetyper/features/agents/init.lua
+++ b/lua/codetyper/features/agents/init.lua
@@ -4,12 +4,14 @@

 local M = {}

-local tools = require("codetyper.agent.tools")
-local executor = require("codetyper.agent.executor")
-local parser = require("codetyper.agent.parser")
-local diff = require("codetyper.agent.diff")
-local utils = require("codetyper.utils")
-local logs = require("codetyper.agent.logs")
+local tools = require("codetyper.core.tools")
+local executor = require("codetyper.core.scheduler.executor")
+local parser = require("codetyper.core.llm.parser")
+local diff = require("codetyper.core.diff.diff")
+local diff_review = require("codetyper.adapters.nvim.ui.diff_review")
+local resume = require("codetyper.core.scheduler.resume")
+local utils = require("codetyper.support.utils")
+local logs = require("codetyper.adapters.nvim.ui.logs")

 ---@class AgentState
 ---@field conversation table[] Message history for multi-turn
@@ -21,8 +23,11 @@ local state = {
  conversation = {},
  pending_tool_results = {},
  is_running = false,
-  max_iterations = 10,
+  max_iterations = 25, -- Increased for complex tasks (env setup, tests, fixes)
  current_iteration = 0,
+  original_prompt = "", -- Store for resume functionality
+  current_context = nil, -- Store context for resume
+  current_callbacks = nil, -- Store callbacks for continue
 }

 ---@class AgentCallbacks
@@ -38,6 +43,8 @@ function M.reset()
  state.pending_tool_results = {}
  state.is_running = false
  state.current_iteration = 0
+  -- Clear collected diffs
+  diff_review.clear()
 end

 --- Check if agent is currently running
@@ -67,6 +74,9 @@ function M.run(prompt, context, callbacks)

  state.is_running = true
  state.current_iteration = 0
+  state.original_prompt = prompt
+  state.current_context = context
+  state.current_callbacks = callbacks

  -- Add user message to conversation
  table.insert(state.conversation, {
@@ -91,13 +101,13 @@ function M.agent_loop(context, callbacks)
  logs.info(string.format("Agent loop iteration %d/%d", state.current_iteration, state.max_iterations))

  if state.current_iteration > state.max_iterations then
-    logs.error("Max iterations reached")
-    callbacks.on_error("Max iterations reached (" .. state.max_iterations .. ")")
-    state.is_running = false
+    logs.info("Max iterations reached, asking user to continue or stop")
+    -- Ask user if they want to continue
+    M.prompt_continue(context, callbacks)
    return
  end

-  local llm = require("codetyper.llm")
+  local llm = require("codetyper.core.llm")
  local client = llm.get_client()

  -- Check if client supports tools
@@ -111,7 +121,11 @@ function M.agent_loop(context, callbacks)
  logs.thinking("Calling LLM with " .. #state.conversation .. " messages...")

  -- Generate with tools enabled
-  client.generate_with_tools(state.conversation, context, tools.definitions, function(response, err)
+  -- Ensure tools are loaded and get definitions
+  tools.setup()
+  local tool_defs = tools.to_openai_format()
+
+  client.generate_with_tools(state.conversation, context, tool_defs, function(response, err)
    if err then
      state.is_running = false
      callbacks.on_error(err)
@@ -123,12 +137,14 @@ function M.agent_loop(context, callbacks)
    local config = codetyper.get_config()
    local parsed

-    if config.llm.provider == "claude" then
+    -- Copilot uses Claude-like response format
+    if config.llm.provider == "copilot" then
      parsed = parser.parse_claude_response(response)
-      -- For Claude, preserve the original content array for proper tool_use handling
      table.insert(state.conversation, {
        role = "assistant",
-        content = response.content, -- Keep original content blocks for Claude API
+        content = parsed.text or "",
+        tool_calls = parsed.tool_calls,
+        _raw_content = response.content,
      })
    else
      -- For Ollama, response is the text directly
@@ -200,11 +216,36 @@ function M.process_tool_calls(tool_calls, index, context, callbacks)
        show_fn = diff.show_diff
      end

-      show_fn(result.diff_data, function(approved)
+      show_fn(result.diff_data, function(approval_result)
+        -- Handle both old (boolean) and new (table) approval result formats
+        local approved = type(approval_result) == "table" and approval_result.approved or approval_result
+        local permission_level = type(approval_result) == "table" and approval_result.permission_level or nil
+
        if approved then
-          logs.tool(tool_call.name, "approved", "User approved")
-          -- Apply the change
+          local log_msg = "User approved"
+          if permission_level == "allow_session" then
+            log_msg = "Allowed for session"
+          elseif permission_level == "allow_list" then
+            log_msg = "Added to allow list"
+          elseif permission_level == "auto" then
+            log_msg = "Auto-approved"
+          end
+          logs.tool(tool_call.name, "approved", log_msg)
+
+          -- Apply the change and collect for review
          executor.apply_change(result.diff_data, function(apply_result)
+            -- Collect the diff for end-of-session review
+            if result.diff_data.operation ~= "bash" then
+              diff_review.add({
+                path = result.diff_data.path,
+                operation = result.diff_data.operation,
+                original = result.diff_data.original,
+                modified = result.diff_data.modified,
+                approved = true,
+                applied = true,
+              })
+            end
+
            -- Store result for sending back to LLM
            table.insert(state.pending_tool_results, {
              tool_use_id = tool_call.id,
@@ -261,20 +302,16 @@ function M.continue_with_results(context, callbacks)
  local codetyper = require("codetyper")
  local config = codetyper.get_config()

-  if config.llm.provider == "claude" then
-    -- Claude format: tool_result blocks
-    local content = {}
+  -- Copilot uses OpenAI format for tool results (role: "tool")
+  if config.llm.provider == "copilot" then
+    -- OpenAI-style tool messages - each result is a separate message
    for _, result in ipairs(state.pending_tool_results) do
-      table.insert(content, {
-        type = "tool_result",
-        tool_use_id = result.tool_use_id,
+      table.insert(state.conversation, {
+        role = "tool",
+        tool_call_id = result.tool_use_id,
        content = result.result,
      })
    end
-    table.insert(state.conversation, {
-      role = "user",
-      content = content,
-    })
  else
    -- Ollama format: plain text describing results
    local result_text = "Tool results:\n"
@@ -305,4 +342,114 @@ function M.set_max_iterations(max)
  state.max_iterations = max
 end

+--- Get the count of collected changes
+---@return number
+function M.get_changes_count()
+  return diff_review.count()
+end
+
+--- Show the diff review UI for all collected changes
+function M.show_diff_review()
+  diff_review.open()
+end
+
+--- Check if diff review is open
+---@return boolean
+function M.is_review_open()
+  return diff_review.is_open()
+end
+
+--- Prompt user to continue or stop at max iterations
+---@param context table File context
+---@param callbacks AgentCallbacks
+function M.prompt_continue(context, callbacks)
+  vim.schedule(function()
+    vim.ui.select({ "Continue (25 more iterations)", "Stop and save for later" }, {
+      prompt = string.format("Agent reached %d iterations. Continue?", state.max_iterations),
+    }, function(choice)
+      if choice and choice:match("^Continue") then
+        -- Reset iteration counter and continue
+        state.current_iteration = 0
+        logs.info("User chose to continue, resetting iteration counter")
+        M.agent_loop(context, callbacks)
+      else
+        -- Save state for later resume
+        logs.info("User chose to stop, saving state for resume")
+        resume.save(
+          state.conversation,
+          state.pending_tool_results,
+          state.current_iteration,
+          state.original_prompt
+        )
+        state.is_running = false
+        callbacks.on_text("Agent paused. Use /continue to resume later.")
+        callbacks.on_complete()
+      end
+    end)
+  end)
+end
+
+--- Continue a previously stopped agent session
+---@param callbacks AgentCallbacks
+---@return boolean Success
+function M.continue_session(callbacks)
+  if state.is_running then
+    utils.notify("Agent is already running", vim.log.levels.WARN)
+    return false
+  end
+
+  local saved = resume.load()
+  if not saved then
+    utils.notify("No saved agent session to continue", vim.log.levels.WARN)
+    return false
+  end
+
+  logs.info("Resuming agent session")
+  logs.info(string.format("Loaded %d messages, iteration %d", #saved.conversation, saved.iteration))
+
+  -- Restore state
+  state.conversation = saved.conversation
+  state.pending_tool_results = saved.pending_tool_results or {}
+  state.current_iteration = 0 -- Reset for fresh iterations
+  state.original_prompt = saved.original_prompt
+  state.is_running = true
+  state.current_callbacks = callbacks
+
+  -- Build context from current state
+  local llm = require("codetyper.core.llm")
+  local context = {}
+  local current_file = vim.fn.expand("%:p")
+  if current_file ~= "" and vim.fn.filereadable(current_file) == 1 then
+    context = llm.build_context(current_file, "agent")
+  end
+  state.current_context = context
+
+  -- Clear saved state
+  resume.clear()
+
+  -- Add continuation message
+  table.insert(state.conversation, {
+    role = "user",
+    content = "Continue where you left off. Complete the remaining tasks.",
+  })
+
+  -- Continue the loop
+  callbacks.on_text("Resuming agent session...")
+  M.agent_loop(context, callbacks)
+
+  return true
+end
+
+--- Check if there's a saved session to continue
+---@return boolean
+function M.has_saved_session()
+  return resume.has_saved_state()
+end
+
+--- Get info about saved session
+---@return table|nil
+function M.get_saved_session_info()
+  return resume.get_info()
+end
+
 return M
--- a/lua/codetyper/features/agents/linter.lua
+++ b/lua/codetyper/features/agents/linter.lua
@@ -0,0 +1,425 @@
+---@mod codetyper.agent.linter Linter validation for generated code
+---@brief [[
+--- Validates generated code by checking LSP diagnostics after injection.
+--- Automatically saves the file and waits for LSP to update before checking.
+---@brief ]]
+
+local M = {}
+
+local config_params = require("codetyper.params.agents.linter")
+local prompts = require("codetyper.prompts.agents.linter")
+
+--- Configuration
+local config = config_params.config
+
+--- Diagnostic results for tracking
+---@type table<number, table>
+local validation_results = {}
+
+--- Configure linter behavior
+---@param opts table Configuration options
+function M.configure(opts)
+	for k, v in pairs(opts) do
+		if config[k] ~= nil then
+			config[k] = v
+		end
+	end
+end
+
+--- Get current configuration
+---@return table
+function M.get_config()
+	return vim.deepcopy(config)
+end
+
+--- Save buffer if modified
+---@param bufnr number Buffer number
+---@return boolean success
+local function save_buffer(bufnr)
+	if not vim.api.nvim_buf_is_valid(bufnr) then
+		return false
+	end
+
+	-- Skip if buffer is not modified
+	if not vim.bo[bufnr].modified then
+		return true
+	end
+
+	-- Skip if buffer has no name (unsaved file)
+	local bufname = vim.api.nvim_buf_get_name(bufnr)
+	if bufname == "" then
+		return false
+	end
+
+	-- Save the buffer
+	local ok, err = pcall(function()
+		vim.api.nvim_buf_call(bufnr, function()
+			vim.cmd("silent! write")
+		end)
+	end)
+
+	if not ok then
+		pcall(function()
+			local logs = require("codetyper.adapters.nvim.ui.logs")
+			logs.add({
+				type = "warning",
+				message = "Failed to save buffer: " .. tostring(err),
+			})
+		end)
+		return false
+	end
+
+	return true
+end
+
+--- Get LSP diagnostics for a buffer
+---@param bufnr number Buffer number
+---@param start_line? number Start line (1-indexed)
+---@param end_line? number End line (1-indexed)
+---@return table[] diagnostics List of diagnostics
+function M.get_diagnostics(bufnr, start_line, end_line)
+	if not vim.api.nvim_buf_is_valid(bufnr) then
+		return {}
+	end
+
+	local all_diagnostics = vim.diagnostic.get(bufnr)
+	local filtered = {}
+
+	for _, diag in ipairs(all_diagnostics) do
+		-- Filter by severity
+		if diag.severity <= config.min_severity then
+			-- Filter by line range if specified
+			if start_line and end_line then
+				local diag_line = diag.lnum + 1 -- Convert to 1-indexed
+				if diag_line >= start_line and diag_line <= end_line then
+					table.insert(filtered, diag)
+				end
+			else
+				table.insert(filtered, diag)
+			end
+		end
+	end
+
+	return filtered
+end
+
+--- Format a diagnostic for display
+---@param diag table Diagnostic object
+---@return string
+local function format_diagnostic(diag)
+	local severity_names = {
+		[vim.diagnostic.severity.ERROR] = "ERROR",
+		[vim.diagnostic.severity.WARN] = "WARN",
+		[vim.diagnostic.severity.INFO] = "INFO",
+		[vim.diagnostic.severity.HINT] = "HINT",
+	}
+	local severity = severity_names[diag.severity] or "UNKNOWN"
+	local line = diag.lnum + 1
+	local source = diag.source or "lsp"
+	return string.format("[%s] Line %d (%s): %s", severity, line, source, diag.message)
+end
+
+--- Check if there are errors in generated code region
+---@param bufnr number Buffer number
+---@param start_line number Start line (1-indexed)
+---@param end_line number End line (1-indexed)
+---@return table result {has_errors, has_warnings, diagnostics, summary}
+function M.check_region(bufnr, start_line, end_line)
+	local diagnostics = M.get_diagnostics(bufnr, start_line, end_line)
+
+	local errors = 0
+	local warnings = 0
+
+	for _, diag in ipairs(diagnostics) do
+		if diag.severity == vim.diagnostic.severity.ERROR then
+			errors = errors + 1
+		elseif diag.severity == vim.diagnostic.severity.WARN then
+			warnings = warnings + 1
+		end
+	end
+
+	return {
+		has_errors = errors > 0,
+		has_warnings = warnings > 0,
+		error_count = errors,
+		warning_count = warnings,
+		diagnostics = diagnostics,
+		summary = string.format("%d error(s), %d warning(s)", errors, warnings),
+	}
+end
+
+--- Validate code after injection and report issues
+---@param bufnr number Buffer number
+---@param start_line? number Start line of injected code (1-indexed)
+---@param end_line? number End line of injected code (1-indexed)
+---@param callback? function Callback with (result) when validation completes
+function M.validate_after_injection(bufnr, start_line, end_line, callback)
+	-- Save the file first
+	if config.auto_save then
+		save_buffer(bufnr)
+	end
+
+	-- Wait for LSP to process changes
+	vim.defer_fn(function()
+		if not vim.api.nvim_buf_is_valid(bufnr) then
+			if callback then callback(nil) end
+			return
+		end
+
+		local result
+		if start_line and end_line then
+			result = M.check_region(bufnr, start_line, end_line)
+		else
+			-- Check entire buffer
+			local line_count = vim.api.nvim_buf_line_count(bufnr)
+			result = M.check_region(bufnr, 1, line_count)
+		end
+
+		-- Store result for this buffer
+		validation_results[bufnr] = {
+			timestamp = os.time(),
+			result = result,
+			start_line = start_line,
+			end_line = end_line,
+		}
+
+		-- Log results
+		pcall(function()
+			local logs = require("codetyper.adapters.nvim.ui.logs")
+			if result.has_errors then
+				logs.add({
+					type = "error",
+					message = string.format("Linter found issues: %s", result.summary),
+				})
+				-- Log individual errors
+				for _, diag in ipairs(result.diagnostics) do
+					if diag.severity == vim.diagnostic.severity.ERROR then
+						logs.add({
+							type = "error",
+							message = format_diagnostic(diag),
+						})
+					end
+				end
+			elseif result.has_warnings then
+				logs.add({
+					type = "warning",
+					message = string.format("Linter warnings: %s", result.summary),
+				})
+			else
+				logs.add({
+					type = "success",
+					message = "Linter check passed - no errors or warnings",
+				})
+			end
+		end)
+
+		-- Notify user
+		if result.has_errors then
+			vim.notify(
+				string.format("Generated code has lint errors: %s", result.summary),
+				vim.log.levels.ERROR
+			)
+
+			-- Offer to fix if configured
+			if config.auto_offer_fix and #result.diagnostics > 0 then
+				M.offer_fix(bufnr, result)
+			end
+		elseif result.has_warnings then
+			vim.notify(
+				string.format("Generated code has warnings: %s", result.summary),
+				vim.log.levels.WARN
+			)
+		end
+
+		if callback then
+			callback(result)
+		end
+	end, config.diagnostic_delay_ms)
+end
+
+--- Offer to fix lint errors using AI
+---@param bufnr number Buffer number
+---@param result table Validation result
+function M.offer_fix(bufnr, result)
+	if not result.has_errors and not result.has_warnings then
+		return
+	end
+
+	-- Build error summary for prompt
+	local error_messages = {}
+	for _, diag in ipairs(result.diagnostics) do
+		table.insert(error_messages, format_diagnostic(diag))
+	end
+
+	vim.ui.select(
+		{ "Yes - Auto-fix with AI", "No - I'll fix manually", "Show errors in quickfix" },
+		{
+			prompt = string.format("Found %d issue(s). Would you like AI to fix them?", #result.diagnostics),
+		},
+		function(choice)
+			if not choice then return end
+
+			if choice:match("^Yes") then
+				M.request_ai_fix(bufnr, result)
+			elseif choice:match("quickfix") then
+				M.show_in_quickfix(bufnr, result)
+			end
+		end
+	)
+end
+
+--- Show lint errors in quickfix list
+---@param bufnr number Buffer number
+---@param result table Validation result
+function M.show_in_quickfix(bufnr, result)
+	local qf_items = {}
+	local bufname = vim.api.nvim_buf_get_name(bufnr)
+
+	for _, diag in ipairs(result.diagnostics) do
+		table.insert(qf_items, {
+			bufnr = bufnr,
+			filename = bufname,
+			lnum = diag.lnum + 1,
+			col = diag.col + 1,
+			text = diag.message,
+			type = diag.severity == vim.diagnostic.severity.ERROR and "E" or "W",
+		})
+	end
+
+	vim.fn.setqflist(qf_items, "r")
+	vim.cmd("copen")
+end
+
+--- Request AI to fix lint errors
+---@param bufnr number Buffer number
+---@param result table Validation result
+function M.request_ai_fix(bufnr, result)
+	if not vim.api.nvim_buf_is_valid(bufnr) then
+		return
+	end
+
+	local filepath = vim.api.nvim_buf_get_name(bufnr)
+
+	-- Build fix prompt
+	local error_list = {}
+	for _, diag in ipairs(result.diagnostics) do
+		table.insert(error_list, format_diagnostic(diag))
+	end
+
+	-- Get the affected code region
+	local start_line = result.diagnostics[1] and (result.diagnostics[1].lnum + 1) or 1
+	local end_line = start_line
+	for _, diag in ipairs(result.diagnostics) do
+		local line = diag.lnum + 1
+		if line < start_line then start_line = line end
+		if line > end_line then end_line = line end
+	end
+
+	-- Expand range by a few lines for context
+	start_line = math.max(1, start_line - 5)
+	end_line = math.min(vim.api.nvim_buf_line_count(bufnr), end_line + 5)
+
+	local lines = vim.api.nvim_buf_get_lines(bufnr, start_line - 1, end_line, false)
+	local code_context = table.concat(lines, "\n")
+
+	-- Create fix prompt using inline tag
+	local fix_prompt = string.format(
+		prompts.fix_request,
+		table.concat(error_list, "\n"),
+		start_line,
+		end_line,
+		code_context
+	)
+
+	-- Queue the fix through the scheduler
+	local scheduler = require("codetyper.core.scheduler.scheduler")
+	local queue = require("codetyper.core.events.queue")
+	local patch_mod = require("codetyper.core.diff.patch")
+
+	-- Ensure scheduler is running
+	if not scheduler.status().running then
+		scheduler.start()
+	end
+
+	-- Take snapshot
+	local snapshot = patch_mod.snapshot_buffer(bufnr, {
+		start_line = start_line,
+		end_line = end_line,
+	})
+
+	-- Enqueue fix request
+	queue.enqueue({
+		id = queue.generate_id(),
+		bufnr = bufnr,
+		range = { start_line = start_line, end_line = end_line },
+		timestamp = os.clock(),
+		changedtick = snapshot.changedtick,
+		content_hash = snapshot.content_hash,
+		prompt_content = fix_prompt,
+		target_path = filepath,
+		priority = 1, -- High priority for fixes
+		status = "pending",
+		attempt_count = 0,
+		intent = {
+			type = "fix",
+			action = "replace",
+			confidence = 0.9,
+		},
+		scope_range = { start_line = start_line, end_line = end_line },
+		source = "linter_fix",
+	})
+
+	pcall(function()
+		local logs = require("codetyper.adapters.nvim.ui.logs")
+		logs.add({
+			type = "info",
+			message = "Queued AI fix request for lint errors",
+		})
+	end)
+
+	vim.notify("Queued AI fix request for lint errors", vim.log.levels.INFO)
+end
+
+--- Get last validation result for a buffer
+---@param bufnr number Buffer number
+---@return table|nil result
+function M.get_last_result(bufnr)
+	return validation_results[bufnr]
+end
+
+--- Clear validation results for a buffer
+---@param bufnr number Buffer number
+function M.clear_result(bufnr)
+	validation_results[bufnr] = nil
+end
+
+--- Check if buffer has any lint errors currently
+---@param bufnr number Buffer number
+---@return boolean has_errors
+function M.has_errors(bufnr)
+	local diagnostics = vim.diagnostic.get(bufnr, {
+		severity = vim.diagnostic.severity.ERROR,
+	})
+	return #diagnostics > 0
+end
+
+--- Check if buffer has any lint warnings currently
+---@param bufnr number Buffer number
+---@return boolean has_warnings
+function M.has_warnings(bufnr)
+	local diagnostics = vim.diagnostic.get(bufnr, {
+		severity = { min = vim.diagnostic.severity.WARN },
+	})
+	return #diagnostics > 0
+end
+
+--- Validate all buffers with recent changes
+function M.validate_all_changed()
+	for bufnr, data in pairs(validation_results) do
+		if vim.api.nvim_buf_is_valid(bufnr) then
+			M.validate_after_injection(bufnr, data.start_line, data.end_line)
+		end
+	end
+end
+
+return M
--- a/lua/codetyper/features/agents/permissions.lua
+++ b/lua/codetyper/features/agents/permissions.lua
@@ -0,0 +1,182 @@
+---@mod codetyper.agent.permissions Permission manager for agent actions
+---
+--- Manages permissions for bash commands and file operations with
+--- allow, allow-session, allow-list, and reject options.
+
+local M = {}
+
+---@class PermissionState
+---@field session_allowed table<string, boolean> Commands allowed for this session
+---@field allow_list table<string, boolean> Patterns always allowed
+---@field deny_list table<string, boolean> Patterns always denied
+
+local params = require("codetyper.params.agents.permissions")
+
+local state = {
+	session_allowed = {},
+	allow_list = {},
+	deny_list = {},
+}
+
+--- Dangerous command patterns that should never be auto-allowed
+local DANGEROUS_PATTERNS = params.dangerous_patterns
+
+--- Safe command patterns that can be auto-allowed
+local SAFE_PATTERNS = params.safe_patterns
+
+---@alias PermissionLevel "allow"|"allow_session"|"allow_list"|"reject"
+
+---@class PermissionResult
+---@field allowed boolean Whether action is allowed
+---@field reason string Reason for the decision
+---@field auto boolean Whether this was an automatic decision
+
+--- Check if a command matches a pattern
+---@param command string The command to check
+---@param pattern string The pattern to match
+---@return boolean
+local function matches_pattern(command, pattern)
+	return command:match(pattern) ~= nil
+end
+
+--- Check if command is dangerous
+---@param command string The command to check
+---@return boolean, string|nil dangerous, reason
+local function is_dangerous(command)
+	for _, pattern in ipairs(DANGEROUS_PATTERNS) do
+		if matches_pattern(command, pattern) then
+			return true, "Matches dangerous pattern: " .. pattern
+		end
+	end
+	return false, nil
+end
+
+--- Check if command is safe
+---@param command string The command to check
+---@return boolean
+local function is_safe(command)
+	for _, pattern in ipairs(SAFE_PATTERNS) do
+		if matches_pattern(command, pattern) then
+			return true
+		end
+	end
+	return false
+end
+
+--- Normalize command for comparison (trim, lowercase first word)
+---@param command string
+---@return string
+local function normalize_command(command)
+	return vim.trim(command)
+end
+
+--- Check permission for a bash command
+---@param command string The command to check
+---@return PermissionResult
+function M.check_bash_permission(command)
+	local normalized = normalize_command(command)
+
+	-- Check deny list first
+	for pattern, _ in pairs(state.deny_list) do
+		if matches_pattern(normalized, pattern) then
+			return {
+				allowed = false,
+				reason = "Command in deny list",
+				auto = true,
+			}
+		end
+	end
+
+	-- Check if command is dangerous
+	local dangerous, reason = is_dangerous(normalized)
+	if dangerous then
+		return {
+			allowed = false,
+			reason = reason,
+			auto = false, -- Require explicit approval for dangerous commands
+		}
+	end
+
+	-- Check session allowed
+	if state.session_allowed[normalized] then
+		return {
+			allowed = true,
+			reason = "Allowed for this session",
+			auto = true,
+		}
+	end
+
+	-- Check allow list patterns
+	for pattern, _ in pairs(state.allow_list) do
+		if matches_pattern(normalized, pattern) then
+			return {
+				allowed = true,
+				reason = "Matches allow list pattern",
+				auto = true,
+			}
+		end
+	end
+
+	-- Check if command is inherently safe
+	if is_safe(normalized) then
+		return {
+			allowed = true,
+			reason = "Safe read-only command",
+			auto = true,
+		}
+	end
+
+	-- Otherwise, require explicit permission
+	return {
+		allowed = false,
+		reason = "Requires approval",
+		auto = false,
+	}
+end
+
+--- Grant permission for a command
+---@param command string The command
+---@param level PermissionLevel The permission level
+function M.grant_permission(command, level)
+	local normalized = normalize_command(command)
+
+	if level == "allow_session" then
+		state.session_allowed[normalized] = true
+	elseif level == "allow_list" then
+		-- Add as pattern (escape special chars for exact match)
+		local pattern = "^" .. vim.pesc(normalized) .. "$"
+		state.allow_list[pattern] = true
+	end
+end
+
+--- Add a pattern to the allow list
+---@param pattern string Lua pattern to allow
+function M.add_to_allow_list(pattern)
+	state.allow_list[pattern] = true
+end
+
+--- Add a pattern to the deny list
+---@param pattern string Lua pattern to deny
+function M.add_to_deny_list(pattern)
+	state.deny_list[pattern] = true
+end
+
+--- Clear session permissions
+function M.clear_session()
+	state.session_allowed = {}
+end
+
+--- Reset all permissions
+function M.reset()
+	state.session_allowed = {}
+	state.allow_list = {}
+	state.deny_list = {}
+end
+
+--- Get current permission state (for debugging)
+---@return PermissionState
+function M.get_state()
+	return vim.deepcopy(state)
+end
+
+return M
--- a/lua/codetyper/features/ask/engine.lua
+++ b/lua/codetyper/features/ask/engine.lua
@@ -1,8 +1,8 @@
---@mod codetyper.ask Ask window for Codetyper.nvim (similar to avante.nvim)
+---@mod codetyper.ask Ask window for Codetyper.nvim

 local M = {}

-local utils = require("codetyper.utils")
+local utils = require("codetyper.support.utils")

 ---@class AskState
 ---@field input_buf number|nil Input buffer
@@ -26,6 +26,7 @@ local state = {
 	agent_mode = false, -- Whether agent mode is enabled (can make file changes)
 	log_listener_id = nil, -- Listener ID for LLM logs
 	show_logs = true, -- Whether to show LLM logs in chat
+	selection_context = nil, -- Visual selection passed when opening
 }

 --- Get the ask window configuration
@@ -312,7 +313,9 @@ local function append_log_to_output(entry)
 	}

 	local icon = icons[entry.level] or "•"
-	local formatted = string.format("[%s] %s %s", entry.timestamp, icon, entry.message)
+	-- Sanitize message - replace newlines with spaces to prevent nvim_buf_set_lines error
+	local sanitized_message = entry.message:gsub("\n", " "):gsub("\r", "")
+	local formatted = string.format("[%s] %s %s", entry.timestamp, icon, sanitized_message)

 	vim.schedule(function()
 		if not state.output_buf or not vim.api.nvim_buf_is_valid(state.output_buf) then
@@ -342,7 +345,7 @@ local function setup_log_listener()
 	-- Remove existing listener if any
 	if state.log_listener_id then
 		pcall(function()
-			local logs = require("codetyper.agent.logs")
+			local logs = require("codetyper.adapters.nvim.ui.logs")
 			logs.remove_listener(state.log_listener_id)
 		end)
 		state.log_listener_id = nil
@@ -359,7 +362,7 @@ end
 local function remove_log_listener()
 	if state.log_listener_id then
 		pcall(function()
-			local logs = require("codetyper.agent.logs")
+			local logs = require("codetyper.adapters.nvim.ui.logs")
 			logs.remove_listener(state.log_listener_id)
 		end)
 		state.log_listener_id = nil
@@ -367,13 +370,21 @@ local function remove_log_listener()
 end

 --- Open the ask panel
-function M.open()
+---@param selection table|nil Visual selection context {text, start_line, end_line, filepath, filename, language}
+function M.open(selection)
 	-- Use the is_open() function which validates window state
 	if M.is_open() then
+		-- If already open and new selection provided, add it as context
+		if selection and selection.text and selection.text ~= "" then
+			M.add_selection_context(selection)
+		end
 		M.focus_input()
 		return
 	end

+	-- Store selection context for use in questions
+	state.selection_context = selection
+
 	local dims = calculate_dimensions()

 	-- Store the target width
@@ -477,6 +488,70 @@ function M.open()
 	-- Focus the input window and start insert mode
 	vim.api.nvim_set_current_win(state.input_win)
 	vim.cmd("startinsert")
+
+	-- If we have a selection, show it as context
+	if selection and selection.text and selection.text ~= "" then
+		vim.schedule(function()
+			M.add_selection_context(selection)
+		end)
+	end
+end
+
+--- Add visual selection as context in the chat
+---@param selection table Selection info {text, start_line, end_line, filepath, filename, language}
+function M.add_selection_context(selection)
+	if not state.output_buf or not vim.api.nvim_buf_is_valid(state.output_buf) then
+		return
+	end
+
+	state.selection_context = selection
+
+	vim.bo[state.output_buf].modifiable = true
+
+	local lines = vim.api.nvim_buf_get_lines(state.output_buf, 0, -1, false)
+
+	-- Format the selection display
+	local location = ""
+	if selection.filename then
+		location = selection.filename
+		if selection.start_line then
+			location = location .. ":" .. selection.start_line
+			if selection.end_line and selection.end_line ~= selection.start_line then
+				location = location .. "-" .. selection.end_line
+			end
+		end
+	end
+
+	local new_lines = {
+		"",
+		"┌─ 📋 Selected Code ─────────────────",
+		"│ " .. location,
+		"│",
+	}
+
+	-- Add the selected code with syntax hints
+	local lang = selection.language or "text"
+	for _, line in ipairs(vim.split(selection.text, "\n")) do
+		table.insert(new_lines, "│ " .. line)
+	end
+
+	table.insert(new_lines, "│")
+	table.insert(new_lines, "└─────────────────────────────────────")
+	table.insert(new_lines, "")
+	table.insert(new_lines, "Ask about this code or describe what you'd like to do with it.")
+
+	for _, line in ipairs(new_lines) do
+		table.insert(lines, line)
+	end
+
+	vim.api.nvim_buf_set_lines(state.output_buf, 0, -1, false, lines)
+	vim.bo[state.output_buf].modifiable = false
+
+	-- Scroll to bottom
+	if state.output_win and vim.api.nvim_win_is_valid(state.output_win) then
+		local line_count = vim.api.nvim_buf_line_count(state.output_buf)
+		vim.api.nvim_win_set_cursor(state.output_win, { line_count, 0 })
+	end
 end

 --- Show file picker for @ mentions
@@ -728,14 +803,17 @@ local function build_file_context()
 end

 --- Build context for the question
+---@param intent? table Detected intent from intent module
 ---@return table Context object
-local function build_context()
+local function build_context(intent)
 	local context = {
 		project_root = utils.get_project_root(),
 		current_file = nil,
 		current_content = nil,
 		language = nil,
 		referenced_files = state.referenced_files,
+		brain_context = nil,
+		indexer_context = nil,
 	}

 	-- Try to get current file context from the non-ask window
@@ -754,49 +832,140 @@ local function build_context()
 		end
 	end

+	-- Add brain context if intent needs it
+	if intent and intent.needs_brain_context then
+		local ok_brain, brain = pcall(require, "codetyper.brain")
+		if ok_brain and brain.is_initialized() then
+			context.brain_context = brain.get_context_for_llm({
+				file = context.current_file,
+				max_tokens = 1000,
+			})
+		end
+	end
+
+	-- Add indexer context if intent needs project-wide context
+	if intent and intent.needs_project_context then
+		local ok_indexer, indexer = pcall(require, "codetyper.indexer")
+		if ok_indexer then
+			context.indexer_context = indexer.get_context_for({
+				file = context.current_file,
+				prompt = "", -- Will be filled later
+				intent = intent,
+			})
+		end
+	end
+
 	return context
 end

--- Submit the question to LLM
-function M.submit()
-	local question = get_input_text()
-
-	if not question or question:match("^%s*$") then
-		utils.notify("Please enter a question", vim.log.levels.WARN)
-		M.focus_input()
+--- Append exploration log to output buffer
+---@param msg string
+---@param level string
+local function append_exploration_log(msg, level)
+	if not state.output_buf or not vim.api.nvim_buf_is_valid(state.output_buf) then
 		return
 	end

-	-- Build context BEFORE clearing input (to preserve file references)
-	local context = build_context()
-	local file_context, file_count = build_file_context()
+	vim.schedule(function()
+		if not state.output_buf or not vim.api.nvim_buf_is_valid(state.output_buf) then
+			return
+		end

-	-- Build display message (without full file contents)
-	local display_question = question
-	if file_count > 0 then
-		display_question = question .. "\n📎 " .. file_count .. " file(s) attached"
+		vim.bo[state.output_buf].modifiable = true
+
+		local lines = vim.api.nvim_buf_get_lines(state.output_buf, 0, -1, false)
+
+		-- Format based on level
+		local formatted = msg
+		if level == "progress" then
+			formatted = msg
+		elseif level == "debug" then
+			formatted = msg
+		elseif level == "file" then
+			formatted = msg
+		end
+
+		table.insert(lines, formatted)
+
+		vim.api.nvim_buf_set_lines(state.output_buf, 0, -1, false, lines)
+		vim.bo[state.output_buf].modifiable = false
+
+		-- Scroll to bottom
+		if state.output_win and vim.api.nvim_win_is_valid(state.output_win) then
+			local line_count = vim.api.nvim_buf_line_count(state.output_buf)
+			pcall(vim.api.nvim_win_set_cursor, state.output_win, { line_count, 0 })
+		end
+	end)
+end
+
+--- Continue submission after exploration
+---@param question string
+---@param intent table
+---@param context table
+---@param file_context string
+---@param file_count number
+---@param exploration_result table|nil
+local function continue_submit(question, intent, context, file_context, file_count, exploration_result)
+	-- Get prompt type based on intent
+	local ok_intent, intent_module = pcall(require, "codetyper.ask.intent")
+	local prompt_type = "ask"
+	if ok_intent then
+		prompt_type = intent_module.get_prompt_type(intent)
 	end

-	-- Add user message to output
-	append_to_output(display_question, true)
-
-	-- Clear input and references AFTER building context
-	M.clear_input()
-
-	-- Build system prompt for ask mode using prompts module
+	-- Build system prompt using prompts module
 	local prompts = require("codetyper.prompts")
-	local system_prompt = prompts.system.ask
+	local system_prompt = prompts.system[prompt_type] or prompts.system.ask

 	if context.current_file then
 		system_prompt = system_prompt .. "\n\nCurrent open file: " .. context.current_file
 		system_prompt = system_prompt .. "\nLanguage: " .. (context.language or "unknown")
 	end

+	-- Add exploration context if available
+	if exploration_result then
+		local ok_explorer, explorer = pcall(require, "codetyper.ask.explorer")
+		if ok_explorer then
+			local explore_context = explorer.build_context(exploration_result)
+			system_prompt = system_prompt .. "\n\n=== PROJECT EXPLORATION RESULTS ===\n"
+			system_prompt = system_prompt .. explore_context
+			system_prompt = system_prompt .. "\n=== END EXPLORATION ===\n"
+		end
+	end
+
+	-- Add brain context (learned patterns, conventions)
+	if context.brain_context and context.brain_context ~= "" then
+		system_prompt = system_prompt .. "\n\n=== LEARNED PROJECT KNOWLEDGE ===\n"
+		system_prompt = system_prompt .. context.brain_context
+		system_prompt = system_prompt .. "\n=== END LEARNED KNOWLEDGE ===\n"
+	end
+
+	-- Add indexer context (project structure, symbols)
+	if context.indexer_context then
+		local idx_ctx = context.indexer_context
+		if idx_ctx.project_type and idx_ctx.project_type ~= "unknown" then
+			system_prompt = system_prompt .. "\n\nProject type: " .. idx_ctx.project_type
+		end
+		if idx_ctx.relevant_symbols and next(idx_ctx.relevant_symbols) then
+			system_prompt = system_prompt .. "\n\nRelevant symbols in project:"
+			for symbol, files in pairs(idx_ctx.relevant_symbols) do
+				system_prompt = system_prompt .. "\n  - " .. symbol .. " (in: " .. table.concat(files, ", ") .. ")"
+			end
+		end
+		if idx_ctx.patterns and #idx_ctx.patterns > 0 then
+			system_prompt = system_prompt .. "\n\nProject patterns/memories:"
+			for _, pattern in ipairs(idx_ctx.patterns) do
+				system_prompt = system_prompt .. "\n  - " .. (pattern.summary or pattern.content or "")
+			end
+		end
+	end
+
 	-- Add to history
 	table.insert(state.history, { role = "user", content = question })

 	-- Show loading indicator
-	append_to_output("⏳ Thinking...", false)
+	append_to_output("", false)
+	append_to_output("⏳ Generating response...", false)

 	-- Get LLM client and generate response
 	local ok, llm = pcall(require, "codetyper.llm")
@@ -807,18 +976,49 @@ function M.submit()

 	local client = llm.get_client()

-	-- Build full prompt WITH file contents
-	local full_prompt = question
-	if file_context ~= "" then
-		full_prompt = "USER QUESTION: "
-			.. question
-			.. "\n\n"
-			.. "ATTACHED FILE CONTENTS (please analyze these):"
-			.. file_context
+	-- Build recent conversation context (limit to last N entries)
+	local history_context = ""
+	do
+		local max_entries = 8
+		local total = #state.history
+		local start_i = 1
+		if total > max_entries then
+			start_i = total - max_entries + 1
+		end
+		if total > 0 then
+			history_context = "\n\n=== PREVIOUS CONVERSATION ===\n"
+			for i = start_i, total do
+				local m = state.history[i]
+				local role = (m.role == "assistant") and "ASSISTANT" or "USER"
+				history_context = history_context .. role .. ": " .. (m.content or "") .. "\n"
+			end
+			history_context = history_context .. "=== END PREVIOUS CONVERSATION ===\n\n"
+		end
 	end

-	-- Also add current file if no files were explicitly attached
-	if file_count == 0 and context.current_content and context.current_content ~= "" then
+	-- Build full prompt starting with recent conversation + user question
+	local full_prompt = history_context .. "USER QUESTION: " .. question
+
+	-- Add visual selection context if present
+	if state.selection_context and state.selection_context.text and state.selection_context.text ~= "" then
+		local sel = state.selection_context
+		local location = sel.filename or "unknown"
+		if sel.start_line then
+			location = location .. ":" .. sel.start_line
+			if sel.end_line and sel.end_line ~= sel.start_line then
+				location = location .. "-" .. sel.end_line
+			end
+		end
+		full_prompt = full_prompt .. "\n\nSELECTED CODE (" .. location .. "):\n```" .. (sel.language or "") .. "\n"
+		full_prompt = full_prompt .. sel.text .. "\n```"
+	end
+
+	if file_context ~= "" then
+		full_prompt = full_prompt .. "\n\nATTACHED FILE CONTENTS (please analyze these):" .. file_context
+	end
+
+	-- Also add current file if no files were explicitly attached and no selection
+	if file_count == 0 and not state.selection_context and context.current_content and context.current_content ~= "" then
 		full_prompt = "USER QUESTION: "
 			.. question
 			.. "\n\n"
@@ -829,10 +1029,23 @@ function M.submit()
 			.. "\n```"
 	end

+	-- Add exploration summary to prompt if available
+	if exploration_result then
+		full_prompt = full_prompt
+			.. "\n\nPROJECT EXPLORATION COMPLETE: "
+			.. exploration_result.total_files
+			.. " files analyzed. "
+			.. "Project type: "
+			.. exploration_result.project.language
+			.. " ("
+			.. (exploration_result.project.framework or exploration_result.project.type)
+			.. ")"
+	end
+
 	local request_context = {
 		file_content = file_context ~= "" and file_context or context.current_content,
 		language = context.language,
-		prompt_type = "explain",
+		prompt_type = prompt_type,
 		file_path = context.current_file,
 	}

@@ -844,9 +1057,9 @@ function M.submit()
 			-- Remove last few lines (the thinking message)
 			local to_remove = 0
 			for i = #lines, 1, -1 do
-				if lines[i]:match("Thinking") or lines[i]:match("^[│└┌─]") then
+				if lines[i]:match("Generating") or lines[i]:match("^[│└┌─]") or lines[i] == "" then
 					to_remove = to_remove + 1
-					if lines[i]:match("┌") then
+					if lines[i]:match("┌") or to_remove >= 5 then
 						break
 					end
 				else
@@ -879,6 +1092,77 @@ function M.submit()
 	end)
 end

+--- Submit the question to LLM
+function M.submit()
+	local question = get_input_text()
+
+	if not question or question:match("^%s*$") then
+		utils.notify("Please enter a question", vim.log.levels.WARN)
+		M.focus_input()
+		return
+	end
+
+	-- Detect intent from prompt
+	local ok_intent, intent_module = pcall(require, "codetyper.ask.intent")
+	local intent = nil
+	if ok_intent then
+		intent = intent_module.detect(question)
+	else
+		-- Fallback intent
+		intent = {
+			type = "ask",
+			confidence = 0.5,
+			needs_project_context = false,
+			needs_brain_context = true,
+			needs_exploration = false,
+		}
+	end
+
+	-- Build context BEFORE clearing input (to preserve file references)
+	local context = build_context(intent)
+	local file_context, file_count = build_file_context()
+
+	-- Build display message (without full file contents)
+	local display_question = question
+	if file_count > 0 then
+		display_question = question .. "\n📎 " .. file_count .. " file(s) attached"
+	end
+	-- Show detected intent if not standard ask
+	if intent.type ~= "ask" then
+		display_question = display_question .. "\n🎯 " .. intent.type:upper() .. " mode"
+	end
+	-- Show exploration indicator
+	if intent.needs_exploration then
+		display_question = display_question .. "\n🔍 Project exploration required"
+	end
+
+	-- Add user message to output
+	append_to_output(display_question, true)
+
+	-- Clear input and references AFTER building context
+	M.clear_input()
+
+	-- Check if exploration is needed
+	if intent.needs_exploration then
+		local ok_explorer, explorer = pcall(require, "codetyper.ask.explorer")
+		if ok_explorer then
+			local root = utils.get_project_root()
+			if root then
+				-- Start exploration with logging
+				append_to_output("", false)
+				explorer.explore(root, append_exploration_log, function(exploration_result)
+					-- After exploration completes, continue with LLM request
+					continue_submit(question, intent, context, file_context, file_count, exploration_result)
+				end)
+				return
+			end
+		end
+	end
+
+	-- No exploration needed, continue directly
+	continue_submit(question, intent, context, file_context, file_count, nil)
+end
+
 --- Clear chat history
 function M.clear_history()
 	state.history = {}
--- a/lua/codetyper/features/ask/explorer.lua
+++ b/lua/codetyper/features/ask/explorer.lua
@@ -0,0 +1,676 @@
+---@mod codetyper.ask.explorer Project exploration for Ask mode
+---@brief [[
+--- Performs comprehensive project exploration when explaining a project.
+--- Shows progress, indexes files, and builds brain context.
+---@brief ]]
+
+local M = {}
+
+local utils = require("codetyper.support.utils")
+
+---@class ExplorationState
+---@field is_exploring boolean
+---@field files_scanned number
+---@field total_files number
+---@field current_file string|nil
+---@field findings table
+---@field on_log fun(msg: string, level: string)|nil
+
+local state = {
+	is_exploring = false,
+	files_scanned = 0,
+	total_files = 0,
+	current_file = nil,
+	findings = {},
+	on_log = nil,
+}
+
+--- File extensions to analyze
+local ANALYZABLE_EXTENSIONS = {
+	lua = true,
+	ts = true,
+	tsx = true,
+	js = true,
+	jsx = true,
+	py = true,
+	go = true,
+	rs = true,
+	rb = true,
+	java = true,
+	c = true,
+	cpp = true,
+	h = true,
+	hpp = true,
+	json = true,
+	yaml = true,
+	yml = true,
+	toml = true,
+	md = true,
+	xml = true,
+}
+
+--- Directories to skip
+local SKIP_DIRS = {
+	-- Version control
+	[".git"] = true,
+	[".svn"] = true,
+	[".hg"] = true,
+
+	-- IDE/Editor
+	[".idea"] = true,
+	[".vscode"] = true,
+	[".cursor"] = true,
+	[".cursorignore"] = true,
+	[".claude"] = true,
+	[".zed"] = true,
+
+	-- Project tooling
+	[".coder"] = true,
+	[".github"] = true,
+	[".gitlab"] = true,
+	[".husky"] = true,
+
+	-- Build outputs
+	dist = true,
+	build = true,
+	out = true,
+	target = true,
+	bin = true,
+	obj = true,
+	[".build"] = true,
+	[".output"] = true,
+
+	-- Dependencies
+	node_modules = true,
+	vendor = true,
+	[".vendor"] = true,
+	packages = true,
+	bower_components = true,
+	jspm_packages = true,
+
+	-- Cache/temp
+	[".cache"] = true,
+	[".tmp"] = true,
+	[".temp"] = true,
+	__pycache__ = true,
+	[".pytest_cache"] = true,
+	[".mypy_cache"] = true,
+	[".ruff_cache"] = true,
+	[".tox"] = true,
+	[".nox"] = true,
+	[".eggs"] = true,
+	["*.egg-info"] = true,
+
+	-- Framework specific
+	[".next"] = true,
+	[".nuxt"] = true,
+	[".svelte-kit"] = true,
+	[".vercel"] = true,
+	[".netlify"] = true,
+	[".serverless"] = true,
+	[".turbo"] = true,
+
+	-- Testing/coverage
+	coverage = true,
+	[".nyc_output"] = true,
+	htmlcov = true,
+
+	-- Logs
+	logs = true,
+	log = true,
+
+	-- OS files
+	[".DS_Store"] = true,
+	Thumbs_db = true,
+}
+
+--- Files to skip (patterns)
+local SKIP_FILES = {
+	-- Lock files
+	"package%-lock%.json",
+	"yarn%.lock",
+	"pnpm%-lock%.yaml",
+	"Gemfile%.lock",
+	"Cargo%.lock",
+	"poetry%.lock",
+	"Pipfile%.lock",
+	"composer%.lock",
+	"go%.sum",
+	"flake%.lock",
+	"%.lock$",
+	"%-lock%.json$",
+	"%-lock%.yaml$",
+
+	-- Generated files
+	"%.min%.js$",
+	"%.min%.css$",
+	"%.bundle%.js$",
+	"%.chunk%.js$",
+	"%.map$",
+	"%.d%.ts$",
+
+	-- Binary/media (shouldn't match anyway but be safe)
+	"%.png$",
+	"%.jpg$",
+	"%.jpeg$",
+	"%.gif$",
+	"%.ico$",
+	"%.svg$",
+	"%.woff",
+	"%.ttf$",
+	"%.eot$",
+	"%.pdf$",
+	"%.zip$",
+	"%.tar",
+	"%.gz$",
+
+	-- Config that's not useful
+	"%.env",
+	"%.env%.",
+}
+
+--- Log a message during exploration
+---@param msg string
+---@param level? string "info"|"debug"|"file"|"progress"
+local function log(msg, level)
+	level = level or "info"
+	if state.on_log then
+		state.on_log(msg, level)
+	end
+end
+
+--- Check if file should be skipped
+---@param filename string
+---@return boolean
+local function should_skip_file(filename)
+	for _, pattern in ipairs(SKIP_FILES) do
+		if filename:match(pattern) then
+			return true
+		end
+	end
+	return false
+end
+
+--- Check if directory should be skipped
+---@param dirname string
+---@return boolean
+local function should_skip_dir(dirname)
+	-- Direct match
+	if SKIP_DIRS[dirname] then
+		return true
+	end
+	-- Pattern match for .cursor* etc
+	if dirname:match("^%.cursor") then
+		return true
+	end
+	return false
+end
+
+--- Get all files in project
+---@param root string Project root
+---@return string[] files
+local function get_project_files(root)
+	local files = {}
+
+	local function scan_dir(dir)
+		local handle = vim.loop.fs_scandir(dir)
+		if not handle then
+			return
+		end
+
+		while true do
+			local name, type = vim.loop.fs_scandir_next(handle)
+			if not name then
+				break
+			end
+
+			local full_path = dir .. "/" .. name
+
+			if type == "directory" then
+				if not should_skip_dir(name) then
+					scan_dir(full_path)
+				end
+			elseif type == "file" then
+				if not should_skip_file(name) then
+					local ext = name:match("%.([^%.]+)$")
+					if ext and ANALYZABLE_EXTENSIONS[ext:lower()] then
+						table.insert(files, full_path)
+					end
+				end
+			end
+		end
+	end
+
+	scan_dir(root)
+	return files
+end
+
+--- Analyze a single file
+---@param filepath string
+---@return table|nil analysis
+local function analyze_file(filepath)
+	local content = utils.read_file(filepath)
+	if not content or content == "" then
+		return nil
+	end
+
+	local ext = filepath:match("%.([^%.]+)$") or ""
+	local lines = vim.split(content, "\n")
+
+	local analysis = {
+		path = filepath,
+		extension = ext,
+		lines = #lines,
+		size = #content,
+		imports = {},
+		exports = {},
+		functions = {},
+		classes = {},
+		summary = "",
+	}
+
+	-- Extract key patterns based on file type
+	for i, line in ipairs(lines) do
+		-- Imports/requires
+		local import = line:match('import%s+.*%s+from%s+["\']([^"\']+)["\']')
+			or line:match('require%(["\']([^"\']+)["\']%)')
+			or line:match("from%s+([%w_.]+)%s+import")
+		if import then
+			table.insert(analysis.imports, { source = import, line = i })
+		end
+
+		-- Function definitions
+		local func = line:match("^%s*function%s+([%w_:%.]+)%s*%(")
+			or line:match("^%s*local%s+function%s+([%w_]+)%s*%(")
+			or line:match("^%s*def%s+([%w_]+)%s*%(")
+			or line:match("^%s*func%s+([%w_]+)%s*%(")
+			or line:match("^%s*async%s+function%s+([%w_]+)%s*%(")
+			or line:match("^%s*public%s+.*%s+([%w_]+)%s*%(")
+		if func then
+			table.insert(analysis.functions, { name = func, line = i })
+		end
+
+		-- Class definitions
+		local class = line:match("^%s*class%s+([%w_]+)")
+			or line:match("^%s*public%s+class%s+([%w_]+)")
+			or line:match("^%s*interface%s+([%w_]+)")
+		if class then
+			table.insert(analysis.classes, { name = class, line = i })
+		end
+
+		-- Exports
+		local exp = line:match("^%s*export%s+.*%s+([%w_]+)")
+			or line:match("^%s*module%.exports%s*=")
+			or line:match("^return%s+M")
+		if exp then
+			table.insert(analysis.exports, { name = exp, line = i })
+		end
+	end
+
+	-- Create summary
+	local parts = {}
+	if #analysis.functions > 0 then
+		table.insert(parts, #analysis.functions .. " functions")
+	end
+	if #analysis.classes > 0 then
+		table.insert(parts, #analysis.classes .. " classes")
+	end
+	if #analysis.imports > 0 then
+		table.insert(parts, #analysis.imports .. " imports")
+	end
+	analysis.summary = table.concat(parts, ", ")
+
+	return analysis
+end
+
+--- Detect project type from files
+---@param root string
+---@return string type, table info
+local function detect_project_type(root)
+	local info = {
+		name = vim.fn.fnamemodify(root, ":t"),
+		type = "unknown",
+		framework = nil,
+		language = nil,
+	}
+
+	-- Check for common project files
+	if utils.file_exists(root .. "/package.json") then
+		info.type = "node"
+		info.language = "JavaScript/TypeScript"
+		local content = utils.read_file(root .. "/package.json")
+		if content then
+			local ok, pkg = pcall(vim.json.decode, content)
+			if ok then
+				info.name = pkg.name or info.name
+				if pkg.dependencies then
+					if pkg.dependencies.react then
+						info.framework = "React"
+					elseif pkg.dependencies.vue then
+						info.framework = "Vue"
+					elseif pkg.dependencies.next then
+						info.framework = "Next.js"
+					elseif pkg.dependencies.express then
+						info.framework = "Express"
+					end
+				end
+			end
+		end
+	elseif utils.file_exists(root .. "/pom.xml") then
+		info.type = "maven"
+		info.language = "Java"
+		local content = utils.read_file(root .. "/pom.xml")
+		if content and content:match("spring%-boot") then
+			info.framework = "Spring Boot"
+		end
+	elseif utils.file_exists(root .. "/Cargo.toml") then
+		info.type = "rust"
+		info.language = "Rust"
+	elseif utils.file_exists(root .. "/go.mod") then
+		info.type = "go"
+		info.language = "Go"
+	elseif utils.file_exists(root .. "/requirements.txt") or utils.file_exists(root .. "/pyproject.toml") then
+		info.type = "python"
+		info.language = "Python"
+	elseif utils.file_exists(root .. "/init.lua") or utils.file_exists(root .. "/plugin/") then
+		info.type = "neovim-plugin"
+		info.language = "Lua"
+	end
+
+	return info.type, info
+end
+
+--- Build project structure summary
+---@param files string[]
+---@param root string
+---@return table structure
+local function build_structure(files, root)
+	local structure = {
+		directories = {},
+		by_extension = {},
+		total_files = #files,
+	}
+
+	for _, file in ipairs(files) do
+		local relative = file:gsub("^" .. vim.pesc(root) .. "/", "")
+		local dir = vim.fn.fnamemodify(relative, ":h")
+		local ext = file:match("%.([^%.]+)$") or "unknown"
+
+		structure.directories[dir] = (structure.directories[dir] or 0) + 1
+		structure.by_extension[ext] = (structure.by_extension[ext] or 0) + 1
+	end
+
+	return structure
+end
+
+--- Explore project and build context
+---@param root string Project root
+---@param on_log fun(msg: string, level: string) Log callback
+---@param on_complete fun(result: table) Completion callback
+function M.explore(root, on_log, on_complete)
+	if state.is_exploring then
+		on_log("⚠️  Already exploring...", "warning")
+		return
+	end
+
+	state.is_exploring = true
+	state.on_log = on_log
+	state.findings = {}
+
+	-- Start exploration
+	log("⏺ Exploring project structure...", "info")
+	log("", "info")
+
+	-- Detect project type
+	log("  Detect(Project type)", "progress")
+	local project_type, project_info = detect_project_type(root)
+	log("  ⎿  " .. project_info.language .. " (" .. (project_info.framework or project_type) .. ")", "debug")
+
+	state.findings.project = project_info
+
+	-- Get all files
+	log("", "info")
+	log("  Scan(Project files)", "progress")
+	local files = get_project_files(root)
+	state.total_files = #files
+	log("  ⎿  Found " .. #files .. " analyzable files", "debug")
+
+	-- Build structure
+	local structure = build_structure(files, root)
+	state.findings.structure = structure
+
+	-- Show directory breakdown
+	log("", "info")
+	log("  Structure(Directories)", "progress")
+	local sorted_dirs = {}
+	for dir, count in pairs(structure.directories) do
+		table.insert(sorted_dirs, { dir = dir, count = count })
+	end
+	table.sort(sorted_dirs, function(a, b)
+		return a.count > b.count
+	end)
+	for i, entry in ipairs(sorted_dirs) do
+		if i <= 5 then
+			log("  ⎿  " .. entry.dir .. " (" .. entry.count .. " files)", "debug")
+		end
+	end
+	if #sorted_dirs > 5 then
+		log("  ⎿  +" .. (#sorted_dirs - 5) .. " more directories", "debug")
+	end
+
+	-- Analyze files asynchronously
+	log("", "info")
+	log("  Analyze(Source files)", "progress")
+
+	state.files_scanned = 0
+	local analyses = {}
+	local key_files = {}
+
+	-- Process files in batches to avoid blocking
+	local batch_size = 10
+	local current_batch = 0
+
+	local function process_batch()
+		local start_idx = current_batch * batch_size + 1
+		local end_idx = math.min(start_idx + batch_size - 1, #files)
+
+		for i = start_idx, end_idx do
+			local file = files[i]
+			local relative = file:gsub("^" .. vim.pesc(root) .. "/", "")
+
+			state.files_scanned = state.files_scanned + 1
+			state.current_file = relative
+
+			local analysis = analyze_file(file)
+			if analysis then
+				analysis.relative_path = relative
+				table.insert(analyses, analysis)
+
+				-- Track key files (many functions/classes)
+				if #analysis.functions >= 3 or #analysis.classes >= 1 then
+					table.insert(key_files, {
+						path = relative,
+						functions = #analysis.functions,
+						classes = #analysis.classes,
+						summary = analysis.summary,
+					})
+				end
+			end
+
+			-- Log some files
+			if i <= 3 or (i % 20 == 0) then
+				log("  ⎿  " .. relative .. ": " .. (analysis and analysis.summary or "(empty)"), "file")
+			end
+		end
+
+		-- Progress update
+		local progress = math.floor((state.files_scanned / state.total_files) * 100)
+		if progress % 25 == 0 and progress > 0 then
+			log("  ⎿  " .. progress .. "% complete (" .. state.files_scanned .. "/" .. state.total_files .. ")", "debug")
+		end
+
+		current_batch = current_batch + 1
+
+		if end_idx < #files then
+			-- Schedule next batch
+			vim.defer_fn(process_batch, 10)
+		else
+			-- Complete
+			finish_exploration(root, analyses, key_files, on_complete)
+		end
+	end
+
+	-- Start processing
+	vim.defer_fn(process_batch, 10)
+end
+
+--- Finish exploration and store results
+---@param root string
+---@param analyses table
+---@param key_files table
+---@param on_complete fun(result: table)
+function finish_exploration(root, analyses, key_files, on_complete)
+	log("  ⎿  +" .. (#analyses - 3) .. " more files analyzed", "debug")
+
+	-- Show key files
+	if #key_files > 0 then
+		log("", "info")
+		log("  KeyFiles(Important components)", "progress")
+		table.sort(key_files, function(a, b)
+			return (a.functions + a.classes * 2) > (b.functions + b.classes * 2)
+		end)
+		for i, kf in ipairs(key_files) do
+			if i <= 5 then
+				log("  ⎿  " .. kf.path .. ": " .. kf.summary, "file")
+			end
+		end
+		if #key_files > 5 then
+			log("  ⎿  +" .. (#key_files - 5) .. " more key files", "debug")
+		end
+	end
+
+	state.findings.analyses = analyses
+	state.findings.key_files = key_files
+
+	-- Store in brain if available
+	local ok_brain, brain = pcall(require, "codetyper.brain")
+	if ok_brain and brain.is_initialized() then
+		log("", "info")
+		log("  Store(Brain context)", "progress")
+
+		-- Store project pattern
+		brain.learn({
+			type = "pattern",
+			file = root,
+			content = {
+				summary = "Project: " .. state.findings.project.name,
+				detail = state.findings.project.language
+					.. " "
+					.. (state.findings.project.framework or state.findings.project.type),
+				code = nil,
+			},
+			context = {
+				file = root,
+				language = state.findings.project.language,
+			},
+		})
+
+		-- Store key file patterns
+		for i, kf in ipairs(key_files) do
+			if i <= 10 then
+				brain.learn({
+					type = "pattern",
+					file = root .. "/" .. kf.path,
+					content = {
+						summary = kf.path .. " - " .. kf.summary,
+						detail = kf.summary,
+					},
+					context = {
+						file = kf.path,
+					},
+				})
+			end
+		end
+
+		log("  ⎿  Stored " .. math.min(#key_files, 10) + 1 .. " patterns in brain", "debug")
+	end
+
+	-- Store in indexer if available
+	local ok_indexer, indexer = pcall(require, "codetyper.indexer")
+	if ok_indexer then
+		log("  Index(Project index)", "progress")
+		indexer.index_project(function(index)
+			log("  ⎿  Indexed " .. (index.stats.files or 0) .. " files", "debug")
+		end)
+	end
+
+	log("", "info")
+	log("✓ Exploration complete!", "info")
+	log("", "info")
+
+	-- Build result
+	local result = {
+		project = state.findings.project,
+		structure = state.findings.structure,
+		key_files = key_files,
+		total_files = state.total_files,
+		analyses = analyses,
+	}
+
+	state.is_exploring = false
+	state.on_log = nil
+
+	on_complete(result)
+end
+
+--- Check if exploration is in progress
+---@return boolean
+function M.is_exploring()
+	return state.is_exploring
+end
+
+--- Get exploration progress
+---@return number scanned, number total
+function M.get_progress()
+	return state.files_scanned, state.total_files
+end
+
+--- Build context string from exploration result
+---@param result table Exploration result
+---@return string context
+function M.build_context(result)
+	local parts = {}
+
+	-- Project info
+	table.insert(parts, "## Project: " .. result.project.name)
+	table.insert(parts, "- Type: " .. result.project.type)
+	table.insert(parts, "- Language: " .. (result.project.language or "Unknown"))
+	if result.project.framework then
+		table.insert(parts, "- Framework: " .. result.project.framework)
+	end
+	table.insert(parts, "- Files: " .. result.total_files)
+	table.insert(parts, "")
+
+	-- Structure
+	table.insert(parts, "## Structure")
+	if result.structure and result.structure.by_extension then
+		for ext, count in pairs(result.structure.by_extension) do
+			table.insert(parts, "- ." .. ext .. ": " .. count .. " files")
+		end
+	end
+	table.insert(parts, "")
+
+	-- Key components
+	if result.key_files and #result.key_files > 0 then
+		table.insert(parts, "## Key Components")
+		for i, kf in ipairs(result.key_files) do
+			if i <= 10 then
+				table.insert(parts, "- " .. kf.path .. ": " .. kf.summary)
+			end
+		end
+	end
+
+	return table.concat(parts, "\n")
+end
+
+return M
--- a/lua/codetyper/features/ask/intent.lua
+++ b/lua/codetyper/features/ask/intent.lua
@@ -0,0 +1,302 @@
+---@mod codetyper.ask.intent Intent detection for Ask mode
+---@brief [[
+--- Analyzes user prompts to detect intent (ask/explain vs code generation).
+--- Routes to appropriate prompt type and context sources.
+---@brief ]]
+
+local M = {}
+
+---@alias IntentType "ask"|"explain"|"generate"|"refactor"|"document"|"test"
+
+---@class Intent
+---@field type IntentType Detected intent type
+---@field confidence number 0-1 confidence score
+---@field needs_project_context boolean Whether project-wide context is needed
+---@field needs_brain_context boolean Whether brain/learned context is helpful
+---@field needs_exploration boolean Whether full project exploration is needed
+---@field keywords string[] Keywords that influenced detection
+
+--- Patterns for detecting ask/explain intent (questions about code)
+local ASK_PATTERNS = {
+	-- Question words
+	{ pattern = "^what%s", weight = 0.9 },
+	{ pattern = "^why%s", weight = 0.95 },
+	{ pattern = "^how%s+does", weight = 0.9 },
+	{ pattern = "^how%s+do%s+i", weight = 0.7 }, -- Could be asking for code
+	{ pattern = "^where%s", weight = 0.85 },
+	{ pattern = "^when%s", weight = 0.85 },
+	{ pattern = "^which%s", weight = 0.8 },
+	{ pattern = "^who%s", weight = 0.85 },
+	{ pattern = "^can%s+you%s+explain", weight = 0.95 },
+	{ pattern = "^could%s+you%s+explain", weight = 0.95 },
+	{ pattern = "^please%s+explain", weight = 0.95 },
+
+	-- Explanation requests
+	{ pattern = "explain%s", weight = 0.9 },
+	{ pattern = "describe%s", weight = 0.85 },
+	{ pattern = "tell%s+me%s+about", weight = 0.85 },
+	{ pattern = "walk%s+me%s+through", weight = 0.9 },
+	{ pattern = "help%s+me%s+understand", weight = 0.95 },
+	{ pattern = "what%s+is%s+the%s+purpose", weight = 0.95 },
+	{ pattern = "what%s+does%s+this", weight = 0.9 },
+	{ pattern = "what%s+does%s+it", weight = 0.9 },
+	{ pattern = "how%s+does%s+this%s+work", weight = 0.95 },
+	{ pattern = "how%s+does%s+it%s+work", weight = 0.95 },
+
+	-- Understanding queries
+	{ pattern = "understand", weight = 0.7 },
+	{ pattern = "meaning%s+of", weight = 0.85 },
+	{ pattern = "difference%s+between", weight = 0.9 },
+	{ pattern = "compared%s+to", weight = 0.8 },
+	{ pattern = "vs%s", weight = 0.7 },
+	{ pattern = "versus", weight = 0.7 },
+	{ pattern = "pros%s+and%s+cons", weight = 0.9 },
+	{ pattern = "advantages", weight = 0.8 },
+	{ pattern = "disadvantages", weight = 0.8 },
+	{ pattern = "trade%-?offs?", weight = 0.85 },
+
+	-- Analysis requests
+	{ pattern = "analyze", weight = 0.85 },
+	{ pattern = "review", weight = 0.7 }, -- Could also be refactor
+	{ pattern = "overview", weight = 0.9 },
+	{ pattern = "summary", weight = 0.9 },
+	{ pattern = "summarize", weight = 0.9 },
+
+	-- Question marks (weaker signal)
+	{ pattern = "%?$", weight = 0.3 },
+	{ pattern = "%?%s*$", weight = 0.3 },
+}
+
+--- Patterns for detecting code generation intent
+local GENERATE_PATTERNS = {
+	-- Direct commands
+	{ pattern = "^create%s", weight = 0.9 },
+	{ pattern = "^make%s", weight = 0.85 },
+	{ pattern = "^build%s", weight = 0.85 },
+	{ pattern = "^write%s", weight = 0.9 },
+	{ pattern = "^add%s", weight = 0.85 },
+	{ pattern = "^implement%s", weight = 0.95 },
+	{ pattern = "^generate%s", weight = 0.95 },
+	{ pattern = "^code%s", weight = 0.8 },
+
+	-- Modification commands
+	{ pattern = "^fix%s", weight = 0.9 },
+	{ pattern = "^change%s", weight = 0.8 },
+	{ pattern = "^update%s", weight = 0.75 },
+	{ pattern = "^modify%s", weight = 0.8 },
+	{ pattern = "^replace%s", weight = 0.85 },
+	{ pattern = "^remove%s", weight = 0.85 },
+	{ pattern = "^delete%s", weight = 0.85 },
+
+	-- Feature requests
+	{ pattern = "i%s+need%s+a", weight = 0.8 },
+	{ pattern = "i%s+want%s+a", weight = 0.8 },
+	{ pattern = "give%s+me", weight = 0.7 },
+	{ pattern = "show%s+me%s+how%s+to%s+code", weight = 0.9 },
+	{ pattern = "how%s+do%s+i%s+implement", weight = 0.85 },
+	{ pattern = "can%s+you%s+write", weight = 0.9 },
+	{ pattern = "can%s+you%s+create", weight = 0.9 },
+	{ pattern = "can%s+you%s+add", weight = 0.85 },
+	{ pattern = "can%s+you%s+make", weight = 0.85 },
+
+	-- Code-specific terms
+	{ pattern = "function%s+that", weight = 0.85 },
+	{ pattern = "class%s+that", weight = 0.85 },
+	{ pattern = "method%s+that", weight = 0.85 },
+	{ pattern = "component%s+that", weight = 0.85 },
+	{ pattern = "module%s+that", weight = 0.85 },
+	{ pattern = "api%s+for", weight = 0.8 },
+	{ pattern = "endpoint%s+for", weight = 0.8 },
+}
+
+--- Patterns for detecting refactor intent
+local REFACTOR_PATTERNS = {
+	{ pattern = "^refactor%s", weight = 0.95 },
+	{ pattern = "refactor%s+this", weight = 0.95 },
+	{ pattern = "clean%s+up", weight = 0.85 },
+	{ pattern = "improve%s+this%s+code", weight = 0.85 },
+	{ pattern = "make%s+this%s+cleaner", weight = 0.85 },
+	{ pattern = "simplify", weight = 0.8 },
+	{ pattern = "optimize", weight = 0.75 }, -- Could be explain
+	{ pattern = "reorganize", weight = 0.9 },
+	{ pattern = "restructure", weight = 0.9 },
+	{ pattern = "extract%s+to", weight = 0.9 },
+	{ pattern = "split%s+into", weight = 0.85 },
+	{ pattern = "dry%s+this", weight = 0.9 }, -- Don't repeat yourself
+	{ pattern = "reduce%s+duplication", weight = 0.9 },
+}
+
+--- Patterns for detecting documentation intent
+local DOCUMENT_PATTERNS = {
+	{ pattern = "^document%s", weight = 0.95 },
+	{ pattern = "add%s+documentation", weight = 0.95 },
+	{ pattern = "add%s+docs", weight = 0.95 },
+	{ pattern = "add%s+comments", weight = 0.9 },
+	{ pattern = "add%s+docstring", weight = 0.95 },
+	{ pattern = "add%s+jsdoc", weight = 0.95 },
+	{ pattern = "write%s+documentation", weight = 0.95 },
+	{ pattern = "document%s+this", weight = 0.95 },
+}
+
+--- Patterns for detecting test generation intent
+local TEST_PATTERNS = {
+	{ pattern = "^test%s", weight = 0.9 },
+	{ pattern = "write%s+tests?%s+for", weight = 0.95 },
+	{ pattern = "add%s+tests?%s+for", weight = 0.95 },
+	{ pattern = "create%s+tests?%s+for", weight = 0.95 },
+	{ pattern = "generate%s+tests?", weight = 0.95 },
+	{ pattern = "unit%s+tests?", weight = 0.9 },
+	{ pattern = "test%s+cases?%s+for", weight = 0.95 },
+	{ pattern = "spec%s+for", weight = 0.85 },
+}
+
+--- Patterns indicating project-wide context is needed
+local PROJECT_CONTEXT_PATTERNS = {
+	{ pattern = "project", weight = 0.9 },
+	{ pattern = "codebase", weight = 0.95 },
+	{ pattern = "entire", weight = 0.7 },
+	{ pattern = "whole", weight = 0.7 },
+	{ pattern = "all%s+files", weight = 0.9 },
+	{ pattern = "architecture", weight = 0.95 },
+	{ pattern = "structure", weight = 0.85 },
+	{ pattern = "how%s+is%s+.*%s+organized", weight = 0.95 },
+	{ pattern = "where%s+is%s+.*%s+defined", weight = 0.9 },
+	{ pattern = "dependencies", weight = 0.85 },
+	{ pattern = "imports?%s+from", weight = 0.7 },
+	{ pattern = "modules?", weight = 0.6 },
+	{ pattern = "packages?", weight = 0.6 },
+}
+
+--- Patterns indicating project exploration is needed (full indexing)
+local EXPLORE_PATTERNS = {
+	{ pattern = "explain%s+.*%s*project", weight = 1.0 },
+	{ pattern = "explain%s+.*%s*codebase", weight = 1.0 },
+	{ pattern = "explain%s+me%s+the%s+project", weight = 1.0 },
+	{ pattern = "tell%s+me%s+about%s+.*%s*project", weight = 0.95 },
+	{ pattern = "what%s+is%s+this%s+project", weight = 0.95 },
+	{ pattern = "overview%s+of%s+.*%s*project", weight = 0.95 },
+	{ pattern = "understand%s+.*%s*project", weight = 0.9 },
+	{ pattern = "analyze%s+.*%s*project", weight = 0.9 },
+	{ pattern = "explore%s+.*%s*project", weight = 1.0 },
+	{ pattern = "explore%s+.*%s*codebase", weight = 1.0 },
+	{ pattern = "index%s+.*%s*project", weight = 1.0 },
+	{ pattern = "scan%s+.*%s*project", weight = 0.95 },
+}
+
+--- Match patterns against text
+---@param text string Lowercased text to match
+---@param patterns table Pattern list with weights
+---@return number Score, string[] Matched keywords
+local function match_patterns(text, patterns)
+	local score = 0
+	local matched = {}
+
+	for _, p in ipairs(patterns) do
+		if text:match(p.pattern) then
+			score = score + p.weight
+			table.insert(matched, p.pattern)
+		end
+	end
+
+	return score, matched
+end
+
+--- Detect intent from user prompt
+---@param prompt string User's question/request
+---@return Intent Detected intent
+function M.detect(prompt)
+	local text = prompt:lower()
+
+	-- Calculate raw scores for each intent type (sum of matched weights)
+	local ask_score, ask_kw = match_patterns(text, ASK_PATTERNS)
+	local gen_score, gen_kw = match_patterns(text, GENERATE_PATTERNS)
+	local ref_score, ref_kw = match_patterns(text, REFACTOR_PATTERNS)
+	local doc_score, doc_kw = match_patterns(text, DOCUMENT_PATTERNS)
+	local test_score, test_kw = match_patterns(text, TEST_PATTERNS)
+	local proj_score, _ = match_patterns(text, PROJECT_CONTEXT_PATTERNS)
+	local explore_score, _ = match_patterns(text, EXPLORE_PATTERNS)
+
+	-- Find the winner by raw score (highest accumulated weight)
+	local scores = {
+		{ type = "ask", score = ask_score, keywords = ask_kw },
+		{ type = "generate", score = gen_score, keywords = gen_kw },
+		{ type = "refactor", score = ref_score, keywords = ref_kw },
+		{ type = "document", score = doc_score, keywords = doc_kw },
+		{ type = "test", score = test_score, keywords = test_kw },
+	}
+
+	table.sort(scores, function(a, b)
+		return a.score > b.score
+	end)
+
+	local winner = scores[1]
+
+	-- If top score is very low, default to ask (safer for Q&A)
+	if winner.score < 0.3 then
+		winner = { type = "ask", score = 0.5, keywords = {} }
+	end
+
+	-- If ask and generate are close AND there's a question mark, prefer ask
+	if winner.type == "generate" and ask_score > 0 then
+		if text:match("%?%s*$") and ask_score >= gen_score * 0.5 then
+			winner = { type = "ask", score = ask_score, keywords = ask_kw }
+		end
+	end
+
+	-- Determine if "explain" vs "ask" (explain needs more context)
+	local intent_type = winner.type
+	if intent_type == "ask" then
+		-- "explain" if asking about how something works, otherwise "ask"
+		if text:match("explain") or text:match("how%s+does") or text:match("walk%s+me%s+through") then
+			intent_type = "explain"
+		end
+	end
+
+	-- Normalize confidence to 0-1 range (cap at reasonable max)
+	local confidence = math.min(winner.score / 2, 1.0)
+
+	-- Check if exploration is needed (full project indexing)
+	local needs_exploration = explore_score >= 0.9
+
+	---@type Intent
+	local intent = {
+		type = intent_type,
+		confidence = confidence,
+		needs_project_context = proj_score > 0.5 or needs_exploration,
+		needs_brain_context = intent_type == "ask" or intent_type == "explain",
+		needs_exploration = needs_exploration,
+		keywords = winner.keywords,
+	}
+
+	return intent
+end
+
+--- Get prompt type for system prompt selection
+---@param intent Intent Detected intent
+---@return string Prompt type for prompts.system
+function M.get_prompt_type(intent)
+	local mapping = {
+		ask = "ask",
+		explain = "ask", -- Uses same prompt as ask
+		generate = "code_generation",
+		refactor = "refactor",
+		document = "document",
+		test = "test",
+	}
+	return mapping[intent.type] or "ask"
+end
+
+--- Check if intent requires code output
+---@param intent Intent
+---@return boolean
+function M.produces_code(intent)
+	local code_intents = {
+		generate = true,
+		refactor = true,
+		document = true, -- Documentation is code (comments)
+		test = true,
+	}
+	return code_intents[intent.type] or false
+end
+
+return M
--- a/lua/codetyper/features/completion/inject.lua
+++ b/lua/codetyper/features/completion/inject.lua
@@ -0,0 +1,456 @@
+---@mod codetyper.agent.inject Smart code injection with import handling
+---@brief [[
+--- Intelligent code injection that properly handles imports, merging them
+--- into existing import sections instead of blindly appending.
+---@brief ]]
+
+local M = {}
+
+---@class ImportConfig
+---@field pattern string Lua pattern to match import statements
+---@field multi_line boolean Whether imports can span multiple lines
+---@field sort_key function|nil Function to extract sort key from import
+---@field group_by function|nil Function to group imports
+
+---@class ParsedCode
+---@field imports string[] Import statements
+---@field body string[] Non-import code lines
+---@field import_lines table<number, boolean> Map of line numbers that are imports
+
+local utils = require("codetyper.support.utils")
+local languages = require("codetyper.params.agents.languages")
+local import_patterns = languages.import_patterns
+
+--- Check if a line is an import statement for the given language
+---@param line string
+---@param patterns table[] Import patterns for the language
+---@return boolean is_import
+---@return boolean is_multi_line
+local function is_import_line(line, patterns)
+	for _, p in ipairs(patterns) do
+		if line:match(p.pattern) then
+			return true, p.multi_line or false
+		end
+	end
+	return false, false
+end
+
+
+--- Check if a line ends a multi-line import
+---@param line string
+---@param filetype string
+---@return boolean
+local function ends_multiline_import(line, filetype)
+	return utils.ends_multiline_import(line, filetype)
+end
+
+--- Parse code into imports and body
+---@param code string|string[] Code to parse
+---@param filetype string File type/extension
+---@return ParsedCode
+function M.parse_code(code, filetype)
+	local lines
+	if type(code) == "string" then
+		lines = vim.split(code, "\n", { plain = true })
+	else
+		lines = code
+	end
+
+	local patterns = import_patterns[filetype] or import_patterns.javascript
+
+	local result = {
+		imports = {},
+		body = {},
+		import_lines = {},
+	}
+
+	local in_multiline_import = false
+	local current_import_lines = {}
+
+	for i, line in ipairs(lines) do
+		if in_multiline_import then
+			-- Continue collecting multi-line import
+			table.insert(current_import_lines, line)
+
+			if ends_multiline_import(line, filetype) then
+				-- Complete the multi-line import
+				table.insert(result.imports, table.concat(current_import_lines, "\n"))
+				for j = i - #current_import_lines + 1, i do
+					result.import_lines[j] = true
+				end
+				current_import_lines = {}
+				in_multiline_import = false
+			end
+		else
+			local is_import, is_multi = is_import_line(line, patterns)
+
+			if is_import then
+				result.import_lines[i] = true
+
+				if is_multi and not ends_multiline_import(line, filetype) then
+					-- Start of multi-line import
+					in_multiline_import = true
+					current_import_lines = { line }
+				else
+					-- Single-line import
+					table.insert(result.imports, line)
+				end
+			else
+				-- Non-import line
+				table.insert(result.body, line)
+			end
+		end
+	end
+
+	-- Handle unclosed multi-line import (shouldn't happen with well-formed code)
+	if #current_import_lines > 0 then
+		table.insert(result.imports, table.concat(current_import_lines, "\n"))
+	end
+
+	return result
+end
+
+--- Find the import section range in a buffer
+---@param bufnr number Buffer number
+---@param filetype string
+---@return number|nil start_line First import line (1-indexed)
+---@return number|nil end_line Last import line (1-indexed)
+function M.find_import_section(bufnr, filetype)
+	if not vim.api.nvim_buf_is_valid(bufnr) then
+		return nil, nil
+	end
+
+	local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
+	local patterns = import_patterns[filetype] or import_patterns.javascript
+
+	local first_import = nil
+	local last_import = nil
+	local in_multiline = false
+	local consecutive_non_import = 0
+	local max_gap = 3 -- Allow up to 3 blank/comment lines between imports
+
+	for i, line in ipairs(lines) do
+		if in_multiline then
+			last_import = i
+			consecutive_non_import = 0
+
+			if ends_multiline_import(line, filetype) then
+				in_multiline = false
+			end
+		else
+			local is_import, is_multi = is_import_line(line, patterns)
+
+			if is_import then
+				if not first_import then
+					first_import = i
+				end
+				last_import = i
+				consecutive_non_import = 0
+
+				if is_multi and not ends_multiline_import(line, filetype) then
+					in_multiline = true
+				end
+			elseif utils.is_empty_or_comment(line, filetype) then
+				-- Allow gaps in import section
+				if first_import then
+					consecutive_non_import = consecutive_non_import + 1
+					if consecutive_non_import > max_gap then
+						-- Too many non-import lines, import section has ended
+						break
+					end
+				end
+			else
+				-- Non-import, non-empty line
+				if first_import then
+					-- Import section has ended
+					break
+				end
+			end
+		end
+	end
+
+	return first_import, last_import
+end
+
+--- Get existing imports from a buffer
+---@param bufnr number Buffer number
+---@param filetype string
+---@return string[] Existing import statements
+function M.get_existing_imports(bufnr, filetype)
+	local start_line, end_line = M.find_import_section(bufnr, filetype)
+	if not start_line then
+		return {}
+	end
+
+	local lines = vim.api.nvim_buf_get_lines(bufnr, start_line - 1, end_line, false)
+	local parsed = M.parse_code(lines, filetype)
+	return parsed.imports
+end
+
+--- Normalize an import for comparison (remove whitespace variations)
+---@param import_str string
+---@return string
+local function normalize_import(import_str)
+	-- Remove trailing semicolon for comparison
+	local normalized = import_str:gsub(";%s*$", "")
+	-- Remove all whitespace around braces, commas, colons
+	normalized = normalized:gsub("%s*{%s*", "{")
+	normalized = normalized:gsub("%s*}%s*", "}")
+	normalized = normalized:gsub("%s*,%s*", ",")
+	normalized = normalized:gsub("%s*:%s*", ":")
+	-- Collapse multiple whitespace to single space
+	normalized = normalized:gsub("%s+", " ")
+	-- Trim leading/trailing whitespace
+	normalized = normalized:match("^%s*(.-)%s*$")
+	return normalized
+end
+
+--- Check if two imports are duplicates
+---@param import1 string
+---@param import2 string
+---@return boolean
+local function are_duplicate_imports(import1, import2)
+	return normalize_import(import1) == normalize_import(import2)
+end
+
+--- Merge new imports with existing ones, avoiding duplicates
+---@param existing string[] Existing imports
+---@param new_imports string[] New imports to merge
+---@return string[] Merged imports
+function M.merge_imports(existing, new_imports)
+	local merged = {}
+	local seen = {}
+
+	-- Add existing imports
+	for _, imp in ipairs(existing) do
+		local normalized = normalize_import(imp)
+		if not seen[normalized] then
+			seen[normalized] = true
+			table.insert(merged, imp)
+		end
+	end
+
+	-- Add new imports that aren't duplicates
+	for _, imp in ipairs(new_imports) do
+		local normalized = normalize_import(imp)
+		if not seen[normalized] then
+			seen[normalized] = true
+			table.insert(merged, imp)
+		end
+	end
+
+	return merged
+end
+
+--- Sort imports by their source/module
+---@param imports string[]
+---@param filetype string
+---@return string[]
+function M.sort_imports(imports, filetype)
+	-- Group imports: stdlib/builtin first, then third-party, then local
+	local builtin = {}
+	local third_party = {}
+	local local_imports = {}
+
+	for _, imp in ipairs(imports) do
+		local category = utils.classify_import(imp, filetype)
+
+		if category == "builtin" then
+			table.insert(builtin, imp)
+		elseif category == "local" then
+			table.insert(local_imports, imp)
+		else
+			table.insert(third_party, imp)
+		end
+	end
+
+	-- Sort each group alphabetically
+	table.sort(builtin)
+	table.sort(third_party)
+	table.sort(local_imports)
+
+	-- Combine with proper spacing
+	local result = {}
+
+	for _, imp in ipairs(builtin) do
+		table.insert(result, imp)
+	end
+	if #builtin > 0 and (#third_party > 0 or #local_imports > 0) then
+		table.insert(result, "") -- Blank line between groups
+	end
+
+	for _, imp in ipairs(third_party) do
+		table.insert(result, imp)
+	end
+	if #third_party > 0 and #local_imports > 0 then
+		table.insert(result, "") -- Blank line between groups
+	end
+
+	for _, imp in ipairs(local_imports) do
+		table.insert(result, imp)
+	end
+
+	return result
+end
+
+---@class InjectResult
+---@field success boolean
+---@field imports_added number Number of new imports added
+---@field imports_merged boolean Whether imports were merged into existing section
+---@field body_lines number Number of body lines injected
+
+--- Smart inject code into a buffer, properly handling imports
+---@param bufnr number Target buffer
+---@param code string|string[] Code to inject
+---@param opts table Options: { strategy: "append"|"replace"|"insert", range: {start_line, end_line}|nil, filetype: string|nil, sort_imports: boolean|nil }
+---@return InjectResult
+function M.inject(bufnr, code, opts)
+	opts = opts or {}
+
+	if not vim.api.nvim_buf_is_valid(bufnr) then
+		return { success = false, imports_added = 0, imports_merged = false, body_lines = 0 }
+	end
+
+	-- Get filetype
+	local filetype = opts.filetype
+	if not filetype then
+		local bufname = vim.api.nvim_buf_get_name(bufnr)
+		filetype = vim.fn.fnamemodify(bufname, ":e")
+	end
+
+	-- Parse the code to separate imports from body
+	local parsed = M.parse_code(code, filetype)
+
+	local result = {
+		success = true,
+		imports_added = 0,
+		imports_merged = false,
+		body_lines = #parsed.body,
+	}
+
+	-- Handle imports first if there are any
+	if #parsed.imports > 0 then
+		local import_start, import_end = M.find_import_section(bufnr, filetype)
+
+		if import_start then
+			-- Merge with existing import section
+			local existing_imports = M.get_existing_imports(bufnr, filetype)
+			local merged = M.merge_imports(existing_imports, parsed.imports)
+
+			-- Count how many new imports were actually added
+			result.imports_added = #merged - #existing_imports
+			result.imports_merged = true
+
+			-- Optionally sort imports
+			if opts.sort_imports ~= false then
+				merged = M.sort_imports(merged, filetype)
+			end
+
+			-- Convert back to lines (handling multi-line imports)
+			local import_lines = {}
+			for _, imp in ipairs(merged) do
+				for _, line in ipairs(vim.split(imp, "\n", { plain = true })) do
+					table.insert(import_lines, line)
+				end
+			end
+
+			-- Replace the import section
+			vim.api.nvim_buf_set_lines(bufnr, import_start - 1, import_end, false, import_lines)
+
+			-- Adjust line numbers for body injection
+			local lines_diff = #import_lines - (import_end - import_start + 1)
+			if opts.range and opts.range.start_line and opts.range.start_line > import_end then
+				opts.range.start_line = opts.range.start_line + lines_diff
+				if opts.range.end_line then
+					opts.range.end_line = opts.range.end_line + lines_diff
+				end
+			end
+		else
+			-- No existing import section, add imports at the top
+			-- Find the first non-comment, non-empty line
+			local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
+			local insert_at = 0
+
+			for i, line in ipairs(lines) do
+				local trimmed = line:match("^%s*(.-)%s*$")
+				-- Skip shebang, docstrings, and initial comments
+				if trimmed ~= "" and not trimmed:match("^#!")
+					and not trimmed:match("^['\"]") and not utils.is_empty_or_comment(line, filetype) then
+					insert_at = i - 1
+					break
+				end
+				insert_at = i
+			end
+
+			-- Add imports with a trailing blank line
+			local import_lines = {}
+			for _, imp in ipairs(parsed.imports) do
+				for _, line in ipairs(vim.split(imp, "\n", { plain = true })) do
+					table.insert(import_lines, line)
+				end
+			end
+			table.insert(import_lines, "") -- Blank line after imports
+
+			vim.api.nvim_buf_set_lines(bufnr, insert_at, insert_at, false, import_lines)
+			result.imports_added = #parsed.imports
+			result.imports_merged = false
+
+			-- Adjust body injection range
+			if opts.range and opts.range.start_line then
+				opts.range.start_line = opts.range.start_line + #import_lines
+				if opts.range.end_line then
+					opts.range.end_line = opts.range.end_line + #import_lines
+				end
+			end
+		end
+	end
+
+	-- Handle body (non-import) code
+	if #parsed.body > 0 then
+		-- Filter out empty leading/trailing lines from body
+		local body_lines = parsed.body
+		while #body_lines > 0 and body_lines[1]:match("^%s*$") do
+			table.remove(body_lines, 1)
+		end
+		while #body_lines > 0 and body_lines[#body_lines]:match("^%s*$") do
+			table.remove(body_lines)
+		end
+
+		if #body_lines > 0 then
+			local line_count = vim.api.nvim_buf_line_count(bufnr)
+			local strategy = opts.strategy or "append"
+
+			if strategy == "replace" and opts.range then
+				local start_line = math.max(1, opts.range.start_line)
+				local end_line = math.min(line_count, opts.range.end_line)
+				vim.api.nvim_buf_set_lines(bufnr, start_line - 1, end_line, false, body_lines)
+			elseif strategy == "insert" and opts.range then
+				local insert_line = math.max(0, math.min(line_count, opts.range.start_line - 1))
+				vim.api.nvim_buf_set_lines(bufnr, insert_line, insert_line, false, body_lines)
+			else
+				-- Default: append
+				local last_line = vim.api.nvim_buf_get_lines(bufnr, line_count - 1, line_count, false)[1] or ""
+				if last_line:match("%S") then
+					-- Add blank line for spacing
+					table.insert(body_lines, 1, "")
+				end
+				vim.api.nvim_buf_set_lines(bufnr, line_count, line_count, false, body_lines)
+			end
+
+			result.body_lines = #body_lines
+		end
+	end
+
+	return result
+end
+
+--- Check if code contains imports
+---@param code string|string[]
+---@param filetype string
+---@return boolean
+function M.has_imports(code, filetype)
+	local parsed = M.parse_code(code, filetype)
+	return #parsed.imports > 0
+end
+
+return M
--- a/lua/codetyper/features/completion/inline.lua
+++ b/lua/codetyper/features/completion/inline.lua
@@ -0,0 +1,192 @@
+---@mod codetyper.completion Insert mode completion for file references
+---
+--- Provides completion for @filename inside /@ @/ tags.
+
+local M = {}
+
+local parser = require("codetyper.parser")
+local utils = require("codetyper.support.utils")
+
+--- Get list of files for completion
+---@param prefix string Prefix to filter files
+---@return table[] List of completion items
+local function get_file_completions(prefix)
+  local cwd = vim.fn.getcwd()
+  local current_file = vim.fn.expand("%:p")
+  local current_dir = vim.fn.fnamemodify(current_file, ":h")
+  local files = {}
+
+  -- Use vim.fn.glob to find files matching the prefix
+  local pattern = prefix .. "*"
+
+  -- Determine base directory - use current file's directory if outside cwd
+  local base_dir = cwd
+  if current_dir ~= "" and not current_dir:find(cwd, 1, true) then
+    -- File is outside project, use its directory as base
+    base_dir = current_dir
+  end
+
+  -- Search in base directory
+  local matches = vim.fn.glob(base_dir .. "/" .. pattern, false, true)
+
+  -- Search with ** for all subdirectories
+  local deep_matches = vim.fn.glob(base_dir .. "/**/" .. pattern, false, true)
+  for _, m in ipairs(deep_matches) do
+    table.insert(matches, m)
+  end
+
+  -- Also search in cwd if different from base_dir
+  if base_dir ~= cwd then
+    local cwd_matches = vim.fn.glob(cwd .. "/" .. pattern, false, true)
+    for _, m in ipairs(cwd_matches) do
+      table.insert(matches, m)
+    end
+    local cwd_deep = vim.fn.glob(cwd .. "/**/" .. pattern, false, true)
+    for _, m in ipairs(cwd_deep) do
+      table.insert(matches, m)
+    end
+  end
+
+  -- Also search specific directories if prefix doesn't have path
+  if not prefix:find("/") then
+    local search_dirs = { "src", "lib", "lua", "app", "components", "utils", "tests" }
+    for _, dir in ipairs(search_dirs) do
+      local dir_path = base_dir .. "/" .. dir
+      if vim.fn.isdirectory(dir_path) == 1 then
+        local dir_matches = vim.fn.glob(dir_path .. "/**/" .. pattern, false, true)
+        for _, m in ipairs(dir_matches) do
+          table.insert(matches, m)
+        end
+      end
+    end
+  end
+
+  -- Convert to relative paths and deduplicate
+  local seen = {}
+  for _, match in ipairs(matches) do
+    -- Convert to relative path based on which base it came from
+    local rel_path
+    if match:find(base_dir, 1, true) == 1 then
+      rel_path = match:sub(#base_dir + 2)
+    elseif match:find(cwd, 1, true) == 1 then
+      rel_path = match:sub(#cwd + 2)
+    else
+      rel_path = vim.fn.fnamemodify(match, ":t") -- Just filename if can't make relative
+    end
+
+    -- Skip directories, coder files, and hidden/generated files
+    if vim.fn.isdirectory(match) == 0
+      and not utils.is_coder_file(match)
+      and not rel_path:match("^%.")
+      and not rel_path:match("node_modules")
+      and not rel_path:match("%.git/")
+      and not rel_path:match("dist/")
+      and not rel_path:match("build/")
+      and not seen[rel_path]
+    then
+      seen[rel_path] = true
+      table.insert(files, {
+        word = rel_path,
+        abbr = rel_path,
+        kind = "File",
+        menu = "[ref]",
+      })
+    end
+  end
+
+  -- Sort by length (shorter paths first)
+  table.sort(files, function(a, b)
+    return #a.word < #b.word
+  end)
+
+  -- Limit results
+  local result = {}
+  for i = 1, math.min(#files, 15) do
+    result[i] = files[i]
+  end
+
+  return result
+end
+
+--- Show file completion popup
+function M.show_file_completion()
+  -- Check if we're in an open prompt tag
+  local is_inside = parser.is_cursor_in_open_tag()
+  if not is_inside then
+    return false
+  end
+
+  -- Get the prefix being typed
+  local prefix = parser.get_file_ref_prefix()
+  if prefix == nil then
+    return false
+  end
+
+  -- Get completions
+  local items = get_file_completions(prefix)
+
+  if #items == 0 then
+    -- Try with empty prefix to show all files
+    items = get_file_completions("")
+  end
+
+  if #items > 0 then
+    -- Calculate start column (position right after @)
+    local cursor = vim.api.nvim_win_get_cursor(0)
+    local col = cursor[2] - #prefix + 1  -- 1-indexed for complete()
+
+    -- Show completion popup
+    vim.fn.complete(col, items)
+    return true
+  end
+
+  return false
+end
+
+--- Setup completion for file references (works on ALL files)
+function M.setup()
+  local group = vim.api.nvim_create_augroup("CoderCompletion", { clear = true })
+
+  -- Trigger completion on @ in insert mode (works on ALL files)
+  vim.api.nvim_create_autocmd("InsertCharPre", {
+    group = group,
+    pattern = "*",
+    callback = function()
+      -- Skip special buffers
+      if vim.bo.buftype ~= "" then
+        return
+      end
+
+      if vim.v.char == "@" then
+        -- Schedule completion popup after the @ is inserted
+        vim.schedule(function()
+          -- Check we're in an open tag
+          local is_inside = parser.is_cursor_in_open_tag()
+          if not is_inside then
+            return
+          end
+
+          -- Check we're not typing @/ (closing tag)
+          local cursor = vim.api.nvim_win_get_cursor(0)
+          local line = vim.api.nvim_get_current_line()
+          local next_char = line:sub(cursor[2] + 2, cursor[2] + 2)
+
+          if next_char == "/" then
+            return
+          end
+
+          -- Show file completion
+          M.show_file_completion()
+        end)
+      end
+    end,
+    desc = "Trigger file completion on @ inside prompt tags",
+  })
+
+  -- Also allow manual trigger with <C-x><C-f> style keybinding in insert mode
+  vim.keymap.set("i", "<C-x>@", function()
+    M.show_file_completion()
+  end, { silent = true, desc = "Coder: Complete file reference" })
+end
+
+return M
--- a/lua/codetyper/features/completion/suggestion.lua
+++ b/lua/codetyper/features/completion/suggestion.lua
@@ -0,0 +1,491 @@
+---@mod codetyper.suggestion Inline ghost text suggestions
+---@brief [[
+--- Provides Copilot-style inline suggestions with ghost text.
+--- Uses Copilot when available, falls back to codetyper's own suggestions.
+--- Shows suggestions as grayed-out text that can be accepted with Tab.
+---@brief ]]
+
+local M = {}
+
+---@class SuggestionState
+---@field current_suggestion string|nil Current suggestion text
+---@field suggestions string[] List of available suggestions
+---@field current_index number Current suggestion index
+---@field extmark_id number|nil Virtual text extmark ID
+---@field bufnr number|nil Buffer where suggestion is shown
+---@field line number|nil Line where suggestion is shown
+---@field col number|nil Column where suggestion starts
+---@field timer any|nil Debounce timer
+---@field using_copilot boolean Whether currently using copilot
+
+local state = {
+	current_suggestion = nil,
+	suggestions = {},
+	current_index = 0,
+	extmark_id = nil,
+	bufnr = nil,
+	line = nil,
+	col = nil,
+	timer = nil,
+	using_copilot = false,
+}
+
+--- Namespace for virtual text
+local ns = vim.api.nvim_create_namespace("codetyper_suggestion")
+
+--- Highlight group for ghost text
+local hl_group = "CmpGhostText"
+
+--- Configuration
+local config = {
+	enabled = true,
+	auto_trigger = true,
+	debounce = 150,
+	use_copilot = true, -- Use copilot when available
+	keymap = {
+		accept = "<Tab>",
+		next = "<M-]>",
+		prev = "<M-[>",
+		dismiss = "<C-]>",
+	},
+}
+
+--- Check if copilot is available and enabled
+---@return boolean, table|nil available, copilot_suggestion module
+local function get_copilot()
+	if not config.use_copilot then
+		return false, nil
+	end
+
+	local ok, copilot_suggestion = pcall(require, "copilot.suggestion")
+	if not ok then
+		return false, nil
+	end
+
+	-- Check if copilot suggestion is enabled
+	local ok_client, copilot_client = pcall(require, "copilot.client")
+	if ok_client and copilot_client.is_disabled and copilot_client.is_disabled() then
+		return false, nil
+	end
+
+	return true, copilot_suggestion
+end
+
+--- Check if suggestion is visible (copilot or codetyper)
+---@return boolean
+function M.is_visible()
+	-- Check copilot first
+	local copilot_ok, copilot_suggestion = get_copilot()
+	if copilot_ok and copilot_suggestion.is_visible() then
+		state.using_copilot = true
+		return true
+	end
+
+	-- Check codetyper's own suggestion
+	state.using_copilot = false
+	return state.extmark_id ~= nil and state.current_suggestion ~= nil
+end
+
+--- Clear the current suggestion
+function M.dismiss()
+	-- Dismiss copilot if active
+	local copilot_ok, copilot_suggestion = get_copilot()
+	if copilot_ok and copilot_suggestion.is_visible() then
+		copilot_suggestion.dismiss()
+	end
+
+	-- Clear codetyper's suggestion
+	if state.extmark_id and state.bufnr then
+		pcall(vim.api.nvim_buf_del_extmark, state.bufnr, ns, state.extmark_id)
+	end
+
+	state.current_suggestion = nil
+	state.suggestions = {}
+	state.current_index = 0
+	state.extmark_id = nil
+	state.bufnr = nil
+	state.line = nil
+	state.col = nil
+	state.using_copilot = false
+end
+
+--- Display suggestion as ghost text
+---@param suggestion string The suggestion to display
+local function display_suggestion(suggestion)
+	if not suggestion or suggestion == "" then
+		return
+	end
+
+	M.dismiss()
+
+	local bufnr = vim.api.nvim_get_current_buf()
+	local cursor = vim.api.nvim_win_get_cursor(0)
+	local line = cursor[1] - 1
+	local col = cursor[2]
+
+	-- Split suggestion into lines
+	local lines = vim.split(suggestion, "\n", { plain = true })
+
+	-- Build virtual text
+	local virt_text = {}
+	local virt_lines = {}
+
+	-- First line goes inline
+	if #lines > 0 then
+		virt_text = { { lines[1], hl_group } }
+	end
+
+	-- Remaining lines go below
+	for i = 2, #lines do
+		table.insert(virt_lines, { { lines[i], hl_group } })
+	end
+
+	-- Create extmark with virtual text
+	local opts = {
+		virt_text = virt_text,
+		virt_text_pos = "overlay",
+		hl_mode = "combine",
+	}
+
+	if #virt_lines > 0 then
+		opts.virt_lines = virt_lines
+	end
+
+	state.extmark_id = vim.api.nvim_buf_set_extmark(bufnr, ns, line, col, opts)
+	state.bufnr = bufnr
+	state.line = line
+	state.col = col
+	state.current_suggestion = suggestion
+end
+
+--- Accept the current suggestion
+---@return boolean Whether a suggestion was accepted
+function M.accept()
+	-- Check copilot first
+	local copilot_ok, copilot_suggestion = get_copilot()
+	if copilot_ok and copilot_suggestion.is_visible() then
+		copilot_suggestion.accept()
+		state.using_copilot = false
+		return true
+	end
+
+	-- Accept codetyper's suggestion
+	if not M.is_visible() then
+		return false
+	end
+
+	local suggestion = state.current_suggestion
+	local bufnr = state.bufnr
+	local line = state.line
+	local col = state.col
+
+	M.dismiss()
+
+	if suggestion and bufnr and line ~= nil and col ~= nil then
+		-- Get current line content
+		local current_line = vim.api.nvim_buf_get_lines(bufnr, line, line + 1, false)[1] or ""
+
+		-- Split suggestion into lines
+		local suggestion_lines = vim.split(suggestion, "\n", { plain = true })
+
+		if #suggestion_lines == 1 then
+			-- Single line - insert at cursor
+			local new_line = current_line:sub(1, col) .. suggestion .. current_line:sub(col + 1)
+			vim.api.nvim_buf_set_lines(bufnr, line, line + 1, false, { new_line })
+			-- Move cursor to end of inserted text
+			vim.api.nvim_win_set_cursor(0, { line + 1, col + #suggestion })
+		else
+			-- Multi-line - insert at cursor
+			local first_line = current_line:sub(1, col) .. suggestion_lines[1]
+			local last_line = suggestion_lines[#suggestion_lines] .. current_line:sub(col + 1)
+
+			local new_lines = { first_line }
+			for i = 2, #suggestion_lines - 1 do
+				table.insert(new_lines, suggestion_lines[i])
+			end
+			table.insert(new_lines, last_line)
+
+			vim.api.nvim_buf_set_lines(bufnr, line, line + 1, false, new_lines)
+			-- Move cursor to end of last line
+			vim.api.nvim_win_set_cursor(0, { line + #new_lines, #suggestion_lines[#suggestion_lines] })
+		end
+
+		return true
+	end
+
+	return false
+end
+
+--- Show next suggestion
+function M.next()
+	-- Check copilot first
+	local copilot_ok, copilot_suggestion = get_copilot()
+	if copilot_ok and copilot_suggestion.is_visible() then
+		copilot_suggestion.next()
+		return
+	end
+
+	-- Codetyper's suggestions
+	if #state.suggestions <= 1 then
+		return
+	end
+
+	state.current_index = (state.current_index % #state.suggestions) + 1
+	display_suggestion(state.suggestions[state.current_index])
+end
+
+--- Show previous suggestion
+function M.prev()
+	-- Check copilot first
+	local copilot_ok, copilot_suggestion = get_copilot()
+	if copilot_ok and copilot_suggestion.is_visible() then
+		copilot_suggestion.prev()
+		return
+	end
+
+	-- Codetyper's suggestions
+	if #state.suggestions <= 1 then
+		return
+	end
+
+	state.current_index = state.current_index - 1
+	if state.current_index < 1 then
+		state.current_index = #state.suggestions
+	end
+	display_suggestion(state.suggestions[state.current_index])
+end
+
+--- Get suggestions from brain/indexer
+---@param prefix string Current word prefix
+---@param context table Context info
+---@return string[] suggestions
+local function get_suggestions(prefix, context)
+	local suggestions = {}
+
+	-- Get completions from brain
+	local ok_brain, brain = pcall(require, "codetyper.brain")
+	if ok_brain and brain.is_initialized and brain.is_initialized() then
+		local result = brain.query({
+			query = prefix,
+			max_results = 5,
+			types = { "pattern" },
+		})
+
+		if result and result.nodes then
+			for _, node in ipairs(result.nodes) do
+				if node.c and node.c.code then
+					table.insert(suggestions, node.c.code)
+				end
+			end
+		end
+	end
+
+	-- Get completions from indexer
+	local ok_indexer, indexer = pcall(require, "codetyper.indexer")
+	if ok_indexer then
+		local index = indexer.load_index()
+		if index and index.symbols then
+			for symbol, _ in pairs(index.symbols) do
+				if symbol:lower():find(prefix:lower(), 1, true) and symbol ~= prefix then
+					-- Just complete the symbol name
+					local completion = symbol:sub(#prefix + 1)
+					if completion ~= "" then
+						table.insert(suggestions, completion)
+					end
+				end
+			end
+		end
+	end
+
+	-- Buffer-based completions
+	local bufnr = vim.api.nvim_get_current_buf()
+	local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
+	local seen = {}
+
+	for _, line in ipairs(lines) do
+		for word in line:gmatch("[%a_][%w_]*") do
+			if
+				#word > #prefix
+				and word:lower():find(prefix:lower(), 1, true) == 1
+				and not seen[word]
+				and word ~= prefix
+			then
+				seen[word] = true
+				local completion = word:sub(#prefix + 1)
+				if completion ~= "" then
+					table.insert(suggestions, completion)
+				end
+			end
+		end
+	end
+
+	return suggestions
+end
+
+--- Trigger suggestion generation
+function M.trigger()
+	if not config.enabled then
+		return
+	end
+
+	-- If copilot is available and has a suggestion, don't show codetyper's
+	local copilot_ok, copilot_suggestion = get_copilot()
+	if copilot_ok and copilot_suggestion.is_visible() then
+		-- Copilot is handling suggestions
+		state.using_copilot = true
+		return
+	end
+
+	-- Cancel existing timer
+	if state.timer then
+		state.timer:stop()
+		state.timer = nil
+	end
+
+	-- Get current context
+	local cursor = vim.api.nvim_win_get_cursor(0)
+	local line = vim.api.nvim_get_current_line()
+	local col = cursor[2]
+	local before_cursor = line:sub(1, col)
+
+	-- Extract prefix (word being typed)
+	local prefix = before_cursor:match("[%a_][%w_]*$") or ""
+
+	if #prefix < 2 then
+		M.dismiss()
+		return
+	end
+
+	-- Debounce - wait a bit longer to let copilot try first
+	local debounce_time = copilot_ok and (config.debounce + 200) or config.debounce
+
+	state.timer = vim.defer_fn(function()
+		-- Check again if copilot has shown something
+		if copilot_ok and copilot_suggestion.is_visible() then
+			state.using_copilot = true
+			state.timer = nil
+			return
+		end
+
+		local suggestions = get_suggestions(prefix, {
+			line = line,
+			col = col,
+			bufnr = vim.api.nvim_get_current_buf(),
+		})
+
+		if #suggestions > 0 then
+			state.suggestions = suggestions
+			state.current_index = 1
+			display_suggestion(suggestions[1])
+		else
+			M.dismiss()
+		end
+
+		state.timer = nil
+	end, debounce_time)
+end
+
+--- Setup keymaps
+local function setup_keymaps()
+	-- Accept with Tab (only when suggestion visible)
+	vim.keymap.set("i", config.keymap.accept, function()
+		if M.is_visible() then
+			M.accept()
+			return ""
+		end
+		-- Fallback to normal Tab behavior
+		return vim.api.nvim_replace_termcodes("<Tab>", true, false, true)
+	end, { expr = true, silent = true, desc = "Accept codetyper suggestion" })
+
+	-- Next suggestion
+	vim.keymap.set("i", config.keymap.next, function()
+		M.next()
+	end, { silent = true, desc = "Next codetyper suggestion" })
+
+	-- Previous suggestion
+	vim.keymap.set("i", config.keymap.prev, function()
+		M.prev()
+	end, { silent = true, desc = "Previous codetyper suggestion" })
+
+	-- Dismiss
+	vim.keymap.set("i", config.keymap.dismiss, function()
+		M.dismiss()
+	end, { silent = true, desc = "Dismiss codetyper suggestion" })
+end
+
+--- Setup autocmds for auto-trigger
+local function setup_autocmds()
+	local group = vim.api.nvim_create_augroup("CodetypeSuggestion", { clear = true })
+
+	-- Trigger on text change in insert mode
+	if config.auto_trigger then
+		vim.api.nvim_create_autocmd("TextChangedI", {
+			group = group,
+			callback = function()
+				M.trigger()
+			end,
+		})
+	end
+
+	-- Dismiss on leaving insert mode
+	vim.api.nvim_create_autocmd("InsertLeave", {
+		group = group,
+		callback = function()
+			M.dismiss()
+		end,
+	})
+
+	-- Dismiss on cursor move (not from typing)
+	vim.api.nvim_create_autocmd("CursorMovedI", {
+		group = group,
+		callback = function()
+			-- Only dismiss if cursor moved significantly
+			if state.line ~= nil then
+				local cursor = vim.api.nvim_win_get_cursor(0)
+				if cursor[1] - 1 ~= state.line then
+					M.dismiss()
+				end
+			end
+		end,
+	})
+end
+
+--- Setup highlight group
+local function setup_highlights()
+	-- Use Comment highlight or define custom ghost text style
+	vim.api.nvim_set_hl(0, hl_group, { link = "Comment" })
+end
+
+--- Setup the suggestion system
+---@param opts? table Configuration options
+function M.setup(opts)
+	if opts then
+		config = vim.tbl_deep_extend("force", config, opts)
+	end
+
+	setup_highlights()
+	setup_keymaps()
+	setup_autocmds()
+end
+
+--- Enable suggestions
+function M.enable()
+	config.enabled = true
+end
+
+--- Disable suggestions
+function M.disable()
+	config.enabled = false
+	M.dismiss()
+end
+
+--- Toggle suggestions
+function M.toggle()
+	if config.enabled then
+		M.disable()
+	else
+		M.enable()
+	end
+end
+
+return M
--- a/lua/codetyper/features/indexer/analyzer.lua
+++ b/lua/codetyper/features/indexer/analyzer.lua
@@ -0,0 +1,585 @@
+---@mod codetyper.indexer.analyzer Code analyzer using Tree-sitter
+---@brief [[
+--- Analyzes source files to extract functions, classes, exports, and imports.
+--- Uses Tree-sitter when available, falls back to pattern matching.
+---@brief ]]
+
+local M = {}
+
+local utils = require("codetyper.support.utils")
+local scanner = require("codetyper.features.indexer.scanner")
+
+--- Language-specific query patterns for Tree-sitter
+local TS_QUERIES = {
+	lua = {
+		functions = [[
+			(function_declaration name: (identifier) @name) @func
+			(function_definition) @func
+			(local_function name: (identifier) @name) @func
+			(assignment_statement
+				(variable_list name: (identifier) @name)
+				(expression_list value: (function_definition) @func))
+		]],
+		exports = [[
+			(return_statement (expression_list (table_constructor))) @export
+		]],
+	},
+	typescript = {
+		functions = [[
+			(function_declaration name: (identifier) @name) @func
+			(method_definition name: (property_identifier) @name) @func
+			(arrow_function) @func
+			(lexical_declaration
+				(variable_declarator name: (identifier) @name value: (arrow_function) @func))
+		]],
+		exports = [[
+			(export_statement) @export
+		]],
+		imports = [[
+			(import_statement) @import
+		]],
+	},
+	javascript = {
+		functions = [[
+			(function_declaration name: (identifier) @name) @func
+			(method_definition name: (property_identifier) @name) @func
+			(arrow_function) @func
+		]],
+		exports = [[
+			(export_statement) @export
+		]],
+		imports = [[
+			(import_statement) @import
+		]],
+	},
+	python = {
+		functions = [[
+			(function_definition name: (identifier) @name) @func
+		]],
+		classes = [[
+			(class_definition name: (identifier) @name) @class
+		]],
+		imports = [[
+			(import_statement) @import
+			(import_from_statement) @import
+		]],
+	},
+	go = {
+		functions = [[
+			(function_declaration name: (identifier) @name) @func
+			(method_declaration name: (field_identifier) @name) @func
+		]],
+		imports = [[
+			(import_declaration) @import
+		]],
+	},
+	rust = {
+		functions = [[
+			(function_item name: (identifier) @name) @func
+		]],
+		imports = [[
+			(use_declaration) @import
+		]],
+	},
+}
+
+-- Forward declaration for analyze_tree_generic (defined below)
+local analyze_tree_generic
+
+--- Hash file content for change detection
+---@param content string
+---@return string
+local function hash_content(content)
+	local hash = 0
+	for i = 1, math.min(#content, 10000) do
+		hash = (hash * 31 + string.byte(content, i)) % 2147483647
+	end
+	return string.format("%08x", hash)
+end
+
+--- Try to get Tree-sitter parser for a language
+---@param lang string
+---@return boolean
+local function has_ts_parser(lang)
+	local ok = pcall(vim.treesitter.language.inspect, lang)
+	return ok
+end
+
+--- Analyze file using Tree-sitter
+---@param filepath string
+---@param lang string
+---@param content string
+---@return table|nil
+local function analyze_with_treesitter(filepath, lang, content)
+	if not has_ts_parser(lang) then
+		return nil
+	end
+
+	local result = {
+		functions = {},
+		classes = {},
+		exports = {},
+		imports = {},
+	}
+
+	-- Create a temporary buffer for parsing
+	local bufnr = vim.api.nvim_create_buf(false, true)
+	vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, vim.split(content, "\n"))
+
+	local ok, parser = pcall(vim.treesitter.get_parser, bufnr, lang)
+	if not ok or not parser then
+		vim.api.nvim_buf_delete(bufnr, { force = true })
+		return nil
+	end
+
+	local tree = parser:parse()[1]
+	if not tree then
+		vim.api.nvim_buf_delete(bufnr, { force = true })
+		return nil
+	end
+
+	local root = tree:root()
+	local queries = TS_QUERIES[lang]
+
+	if not queries then
+		-- Fallback: walk tree manually for common patterns
+		result = analyze_tree_generic(root, bufnr)
+	else
+		-- Use language-specific queries
+		if queries.functions then
+			local query_ok, query = pcall(vim.treesitter.query.parse, lang, queries.functions)
+			if query_ok then
+				for id, node in query:iter_captures(root, bufnr, 0, -1) do
+					local capture_name = query.captures[id]
+					if capture_name == "func" or capture_name == "name" then
+						local start_row, _, end_row, _ = node:range()
+						local name = nil
+
+						-- Try to get name from sibling capture or child
+						if capture_name == "func" then
+							local name_node = node:field("name")[1]
+							if name_node then
+								name = vim.treesitter.get_node_text(name_node, bufnr)
+							end
+						else
+							name = vim.treesitter.get_node_text(node, bufnr)
+						end
+
+						if name and not vim.tbl_contains(vim.tbl_map(function(f)
+							return f.name
+						end, result.functions), name) then
+							table.insert(result.functions, {
+								name = name,
+								line = start_row + 1,
+								end_line = end_row + 1,
+								params = {},
+							})
+						end
+					end
+				end
+			end
+		end
+
+		if queries.classes then
+			local query_ok, query = pcall(vim.treesitter.query.parse, lang, queries.classes)
+			if query_ok then
+				for id, node in query:iter_captures(root, bufnr, 0, -1) do
+					local capture_name = query.captures[id]
+					if capture_name == "class" then
+						local start_row, _, end_row, _ = node:range()
+						local name_node = node:field("name")[1]
+						local name = name_node and vim.treesitter.get_node_text(name_node, bufnr) or "anonymous"
+
+						table.insert(result.classes, {
+							name = name,
+							line = start_row + 1,
+							end_line = end_row + 1,
+							methods = {},
+						})
+					end
+				end
+			end
+		end
+
+		if queries.exports then
+			local query_ok, query = pcall(vim.treesitter.query.parse, lang, queries.exports)
+			if query_ok then
+				for _, node in query:iter_captures(root, bufnr, 0, -1) do
+					local text = vim.treesitter.get_node_text(node, bufnr)
+					local start_row, _, _, _ = node:range()
+
+					-- Extract export names (simplified)
+					local names = {}
+					for name in text:gmatch("export%s+[%w_]+%s+([%w_]+)") do
+						table.insert(names, name)
+					end
+					for name in text:gmatch("export%s*{([^}]+)}") do
+						for n in name:gmatch("([%w_]+)") do
+							table.insert(names, n)
+						end
+					end
+
+					for _, name in ipairs(names) do
+						table.insert(result.exports, {
+							name = name,
+							type = "unknown",
+							line = start_row + 1,
+						})
+					end
+				end
+			end
+		end
+
+		if queries.imports then
+			local query_ok, query = pcall(vim.treesitter.query.parse, lang, queries.imports)
+			if query_ok then
+				for _, node in query:iter_captures(root, bufnr, 0, -1) do
+					local text = vim.treesitter.get_node_text(node, bufnr)
+					local start_row, _, _, _ = node:range()
+
+					-- Extract import source
+					local source = text:match('["\']([^"\']+)["\']')
+					if source then
+						table.insert(result.imports, {
+							source = source,
+							names = {},
+							line = start_row + 1,
+						})
+					end
+				end
+			end
+		end
+	end
+
+	vim.api.nvim_buf_delete(bufnr, { force = true })
+	return result
+end
+
+--- Generic tree analysis for unsupported languages
+---@param root TSNode
+---@param bufnr number
+---@return table
+analyze_tree_generic = function(root, bufnr)
+	local result = {
+		functions = {},
+		classes = {},
+		exports = {},
+		imports = {},
+	}
+
+	local function visit(node)
+		local node_type = node:type()
+
+		-- Common function patterns
+		if
+			node_type:match("function")
+			or node_type:match("method")
+			or node_type == "arrow_function"
+			or node_type == "func_literal"
+		then
+			local start_row, _, end_row, _ = node:range()
+			local name_node = node:field("name")[1]
+			local name = name_node and vim.treesitter.get_node_text(name_node, bufnr) or "anonymous"
+
+			table.insert(result.functions, {
+				name = name,
+				line = start_row + 1,
+				end_line = end_row + 1,
+				params = {},
+			})
+		end
+
+		-- Common class patterns
+		if node_type:match("class") or node_type == "struct_item" or node_type == "impl_item" then
+			local start_row, _, end_row, _ = node:range()
+			local name_node = node:field("name")[1]
+			local name = name_node and vim.treesitter.get_node_text(name_node, bufnr) or "anonymous"
+
+			table.insert(result.classes, {
+				name = name,
+				line = start_row + 1,
+				end_line = end_row + 1,
+				methods = {},
+			})
+		end
+
+		-- Recurse into children
+		for child in node:iter_children() do
+			visit(child)
+		end
+	end
+
+	visit(root)
+	return result
+end
+
+--- Analyze file using pattern matching (fallback)
+---@param content string
+---@param lang string
+---@return table
+local function analyze_with_patterns(content, lang)
+	local result = {
+		functions = {},
+		classes = {},
+		exports = {},
+		imports = {},
+	}
+
+	local lines = vim.split(content, "\n")
+
+	-- Language-specific patterns
+	local patterns = {
+		lua = {
+			func_start = "^%s*local?%s*function%s+([%w_%.]+)",
+			func_assign = "^%s*([%w_%.]+)%s*=%s*function",
+			module_return = "^return%s+M",
+		},
+		javascript = {
+			func_start = "^%s*function%s+([%w_]+)",
+			func_arrow = "^%s*const%s+([%w_]+)%s*=%s*",
+			class_start = "^%s*class%s+([%w_]+)",
+			export_line = "^%s*export%s+",
+			import_line = "^%s*import%s+",
+		},
+		typescript = {
+			func_start = "^%s*function%s+([%w_]+)",
+			func_arrow = "^%s*const%s+([%w_]+)%s*=%s*",
+			class_start = "^%s*class%s+([%w_]+)",
+			export_line = "^%s*export%s+",
+			import_line = "^%s*import%s+",
+		},
+		python = {
+			func_start = "^%s*def%s+([%w_]+)",
+			class_start = "^%s*class%s+([%w_]+)",
+			import_line = "^%s*import%s+",
+			from_import = "^%s*from%s+",
+		},
+		go = {
+			func_start = "^func%s+([%w_]+)",
+			method_start = "^func%s+%([^%)]+%)%s+([%w_]+)",
+			import_line = "^import%s+",
+		},
+		rust = {
+			func_start = "^%s*pub?%s*fn%s+([%w_]+)",
+			struct_start = "^%s*pub?%s*struct%s+([%w_]+)",
+			impl_start = "^%s*impl%s+([%w_<>]+)",
+			use_line = "^%s*use%s+",
+		},
+	}
+
+	local lang_patterns = patterns[lang] or patterns.javascript
+
+	for i, line in ipairs(lines) do
+		-- Functions
+		if lang_patterns.func_start then
+			local name = line:match(lang_patterns.func_start)
+			if name then
+				table.insert(result.functions, {
+					name = name,
+					line = i,
+					end_line = i,
+					params = {},
+				})
+			end
+		end
+
+		if lang_patterns.func_arrow then
+			local name = line:match(lang_patterns.func_arrow)
+			if name and line:match("=>") then
+				table.insert(result.functions, {
+					name = name,
+					line = i,
+					end_line = i,
+					params = {},
+				})
+			end
+		end
+
+		if lang_patterns.func_assign then
+			local name = line:match(lang_patterns.func_assign)
+			if name then
+				table.insert(result.functions, {
+					name = name,
+					line = i,
+					end_line = i,
+					params = {},
+				})
+			end
+		end
+
+		if lang_patterns.method_start then
+			local name = line:match(lang_patterns.method_start)
+			if name then
+				table.insert(result.functions, {
+					name = name,
+					line = i,
+					end_line = i,
+					params = {},
+				})
+			end
+		end
+
+		-- Classes
+		if lang_patterns.class_start then
+			local name = line:match(lang_patterns.class_start)
+			if name then
+				table.insert(result.classes, {
+					name = name,
+					line = i,
+					end_line = i,
+					methods = {},
+				})
+			end
+		end
+
+		if lang_patterns.struct_start then
+			local name = line:match(lang_patterns.struct_start)
+			if name then
+				table.insert(result.classes, {
+					name = name,
+					line = i,
+					end_line = i,
+					methods = {},
+				})
+			end
+		end
+
+		-- Exports
+		if lang_patterns.export_line and line:match(lang_patterns.export_line) then
+			local name = line:match("export%s+[%w_]+%s+([%w_]+)")
+				or line:match("export%s+default%s+([%w_]+)")
+				or line:match("export%s+{%s*([%w_]+)")
+			if name then
+				table.insert(result.exports, {
+					name = name,
+					type = "unknown",
+					line = i,
+				})
+			end
+		end
+
+		-- Imports
+		if lang_patterns.import_line and line:match(lang_patterns.import_line) then
+			local source = line:match('["\']([^"\']+)["\']')
+			if source then
+				table.insert(result.imports, {
+					source = source,
+					names = {},
+					line = i,
+				})
+			end
+		end
+
+		if lang_patterns.from_import and line:match(lang_patterns.from_import) then
+			local source = line:match("from%s+([%w_%.]+)")
+			if source then
+				table.insert(result.imports, {
+					source = source,
+					names = {},
+					line = i,
+				})
+			end
+		end
+
+		if lang_patterns.use_line and line:match(lang_patterns.use_line) then
+			local source = line:match("use%s+([%w_:]+)")
+			if source then
+				table.insert(result.imports, {
+					source = source,
+					names = {},
+					line = i,
+				})
+			end
+		end
+	end
+
+	-- For Lua, infer exports from module table
+	if lang == "lua" then
+		for _, func in ipairs(result.functions) do
+			if func.name:match("^M%.") then
+				local name = func.name:gsub("^M%.", "")
+				table.insert(result.exports, {
+					name = name,
+					type = "function",
+					line = func.line,
+				})
+			end
+		end
+	end
+
+	return result
+end
+
+--- Analyze a single file
+---@param filepath string Full path to file
+---@return FileIndex|nil
+function M.analyze_file(filepath)
+	local content = utils.read_file(filepath)
+	if not content then
+		return nil
+	end
+
+	local lang = scanner.get_language(filepath)
+
+	-- Map to Tree-sitter language names
+	local ts_lang_map = {
+		typescript = "typescript",
+		typescriptreact = "tsx",
+		javascript = "javascript",
+		javascriptreact = "javascript",
+		python = "python",
+		go = "go",
+		rust = "rust",
+		lua = "lua",
+	}
+
+	local ts_lang = ts_lang_map[lang] or lang
+
+	-- Try Tree-sitter first
+	local analysis = analyze_with_treesitter(filepath, ts_lang, content)
+
+	-- Fallback to pattern matching
+	if not analysis then
+		analysis = analyze_with_patterns(content, lang)
+	end
+
+	return {
+		path = filepath,
+		language = lang,
+		hash = hash_content(content),
+		exports = analysis.exports,
+		imports = analysis.imports,
+		functions = analysis.functions,
+		classes = analysis.classes,
+		last_indexed = os.time(),
+	}
+end
+
+--- Extract exports from a buffer
+---@param bufnr number
+---@return Export[]
+function M.extract_exports(bufnr)
+	local filepath = vim.api.nvim_buf_get_name(bufnr)
+	local analysis = M.analyze_file(filepath)
+	return analysis and analysis.exports or {}
+end
+
+--- Extract functions from a buffer
+---@param bufnr number
+---@return FunctionInfo[]
+function M.extract_functions(bufnr)
+	local filepath = vim.api.nvim_buf_get_name(bufnr)
+	local analysis = M.analyze_file(filepath)
+	return analysis and analysis.functions or {}
+end
+
+--- Extract imports from a buffer
+---@param bufnr number
+---@return Import[]
+function M.extract_imports(bufnr)
+	local filepath = vim.api.nvim_buf_get_name(bufnr)
+	local analysis = M.analyze_file(filepath)
+	return analysis and analysis.imports or {}
+end
+
+return M
--- a/lua/codetyper/features/indexer/init.lua
+++ b/lua/codetyper/features/indexer/init.lua
@@ -0,0 +1,604 @@
+---@mod codetyper.indexer Project indexer for Codetyper.nvim
+---@brief [[
+--- Indexes project structure, dependencies, and code symbols.
+--- Stores knowledge in .coder/ directory for enriching LLM context.
+---@brief ]]
+
+local M = {}
+
+local utils = require("codetyper.support.utils")
+
+--- Index schema version for migrations
+local INDEX_VERSION = 1
+
+--- Index file name
+local INDEX_FILE = "index.json"
+
+--- Debounce timer for file indexing
+local index_timer = nil
+local INDEX_DEBOUNCE_MS = 500
+
+--- Default indexer configuration
+local default_config = {
+	enabled = true,
+	auto_index = true,
+	index_on_open = false,
+	max_file_size = 100000,
+	excluded_dirs = { "node_modules", "dist", "build", ".git", ".coder", "__pycache__", "vendor", "target" },
+	index_extensions = { "lua", "ts", "tsx", "js", "jsx", "py", "go", "rs", "rb", "java", "c", "cpp", "h", "hpp" },
+	memory = {
+		enabled = true,
+		max_memories = 1000,
+		prune_threshold = 0.1,
+	},
+}
+
+--- Current configuration
+---@type table
+local config = vim.deepcopy(default_config)
+
+--- Cached project index
+---@type table<string, ProjectIndex>
+local index_cache = {}
+
+---@class ProjectIndex
+---@field version number Index schema version
+---@field project_root string Absolute path to project
+---@field project_name string Project name
+---@field project_type string "node"|"rust"|"go"|"python"|"lua"|"unknown"
+---@field dependencies table<string, string> name -> version
+---@field dev_dependencies table<string, string> name -> version
+---@field files table<string, FileIndex> path -> FileIndex
+---@field symbols table<string, string[]> symbol -> [file paths]
+---@field last_indexed number Timestamp
+---@field stats {files: number, functions: number, classes: number, exports: number}
+
+---@class FileIndex
+---@field path string Relative path from project root
+---@field language string Detected language
+---@field hash string Content hash for change detection
+---@field exports Export[] Exported symbols
+---@field imports Import[] Dependencies
+---@field functions FunctionInfo[]
+---@field classes ClassInfo[]
+---@field last_indexed number Timestamp
+
+---@class Export
+---@field name string Symbol name
+---@field type string "function"|"class"|"constant"|"type"|"variable"
+---@field line number Line number
+
+---@class Import
+---@field source string Import source/module
+---@field names string[] Imported names
+---@field line number Line number
+
+---@class FunctionInfo
+---@field name string Function name
+---@field params string[] Parameter names
+---@field line number Start line
+---@field end_line number End line
+---@field docstring string|nil Documentation
+
+---@class ClassInfo
+---@field name string Class name
+---@field methods string[] Method names
+---@field line number Start line
+---@field end_line number End line
+---@field docstring string|nil Documentation
+
+--- Get the index file path
+---@return string|nil
+local function get_index_path()
+	local root = utils.get_project_root()
+	if not root then
+		return nil
+	end
+	return root .. "/.coder/" .. INDEX_FILE
+end
+
+--- Create empty index structure
+---@return ProjectIndex
+local function create_empty_index()
+	local root = utils.get_project_root()
+	return {
+		version = INDEX_VERSION,
+		project_root = root or "",
+		project_name = root and vim.fn.fnamemodify(root, ":t") or "",
+		project_type = "unknown",
+		dependencies = {},
+		dev_dependencies = {},
+		files = {},
+		symbols = {},
+		last_indexed = os.time(),
+		stats = {
+			files = 0,
+			functions = 0,
+			classes = 0,
+			exports = 0,
+		},
+	}
+end
+
+--- Load index from disk
+---@return ProjectIndex|nil
+function M.load_index()
+	local root = utils.get_project_root()
+	if not root then
+		return nil
+	end
+
+	-- Check cache first
+	if index_cache[root] then
+		return index_cache[root]
+	end
+
+	local path = get_index_path()
+	if not path then
+		return nil
+	end
+
+	local content = utils.read_file(path)
+	if not content then
+		return nil
+	end
+
+	local ok, index = pcall(vim.json.decode, content)
+	if not ok or not index then
+		return nil
+	end
+
+	-- Validate version
+	if index.version ~= INDEX_VERSION then
+		-- Index needs migration or rebuild
+		return nil
+	end
+
+	-- Cache it
+	index_cache[root] = index
+	return index
+end
+
+--- Save index to disk
+---@param index ProjectIndex
+---@return boolean
+function M.save_index(index)
+	local root = utils.get_project_root()
+	if not root then
+		return false
+	end
+
+	-- Ensure .coder directory exists
+	local coder_dir = root .. "/.coder"
+	utils.ensure_dir(coder_dir)
+
+	local path = get_index_path()
+	if not path then
+		return false
+	end
+
+	local ok, encoded = pcall(vim.json.encode, index)
+	if not ok then
+		return false
+	end
+
+	local success = utils.write_file(path, encoded)
+	if success then
+		-- Update cache
+		index_cache[root] = index
+	end
+	return success
+end
+
+--- Index the entire project
+---@param callback? fun(index: ProjectIndex)
+---@return ProjectIndex|nil
+function M.index_project(callback)
+	local scanner = require("codetyper.features.indexer.scanner")
+	local analyzer = require("codetyper.features.indexer.analyzer")
+
+	local index = create_empty_index()
+	local root = utils.get_project_root()
+
+	if not root then
+		if callback then
+			callback(index)
+		end
+		return index
+	end
+
+	-- Detect project type and parse dependencies
+	index.project_type = scanner.detect_project_type(root)
+	local deps = scanner.parse_dependencies(root, index.project_type)
+	index.dependencies = deps.dependencies or {}
+	index.dev_dependencies = deps.dev_dependencies or {}
+
+	-- Get all indexable files
+	local files = scanner.get_indexable_files(root, config)
+
+	-- Index each file
+	local total_functions = 0
+	local total_classes = 0
+	local total_exports = 0
+
+	for _, filepath in ipairs(files) do
+		local relative_path = filepath:gsub("^" .. vim.pesc(root) .. "/", "")
+		local file_index = analyzer.analyze_file(filepath)
+
+		if file_index then
+			file_index.path = relative_path
+			index.files[relative_path] = file_index
+
+			-- Update symbol index
+			for _, exp in ipairs(file_index.exports or {}) do
+				if not index.symbols[exp.name] then
+					index.symbols[exp.name] = {}
+				end
+				table.insert(index.symbols[exp.name], relative_path)
+				total_exports = total_exports + 1
+			end
+
+			total_functions = total_functions + #(file_index.functions or {})
+			total_classes = total_classes + #(file_index.classes or {})
+		end
+	end
+
+	-- Update stats
+	index.stats = {
+		files = #files,
+		functions = total_functions,
+		classes = total_classes,
+		exports = total_exports,
+	}
+	index.last_indexed = os.time()
+
+	-- Save to disk
+	M.save_index(index)
+
+	-- Store memories
+	local memory = require("codetyper.features.indexer.memory")
+	memory.store_index_summary(index)
+
+	-- Sync project summary to brain
+	M.sync_project_to_brain(index, files, root)
+
+	if callback then
+		callback(index)
+	end
+
+	return index
+end
+
+--- Sync project index to brain
+---@param index ProjectIndex
+---@param files string[] List of file paths
+---@param root string Project root
+function M.sync_project_to_brain(index, files, root)
+	local ok_brain, brain = pcall(require, "codetyper.brain")
+	if not ok_brain or not brain.is_initialized or not brain.is_initialized() then
+		return
+	end
+
+	-- Store project-level pattern
+	brain.learn({
+		type = "pattern",
+		file = root,
+		content = {
+			summary = "Project: "
+				.. index.project_name
+				.. " ("
+				.. index.project_type
+				.. ") - "
+				.. index.stats.files
+				.. " files",
+			detail = string.format(
+				"%d functions, %d classes, %d exports",
+				index.stats.functions,
+				index.stats.classes,
+				index.stats.exports
+			),
+		},
+		context = {
+			file = root,
+			project_type = index.project_type,
+			dependencies = index.dependencies,
+		},
+	})
+
+	-- Store key file patterns (files with most functions/classes)
+	local key_files = {}
+	for path, file_index in pairs(index.files) do
+		local score = #(file_index.functions or {}) + (#(file_index.classes or {}) * 2)
+		if score >= 3 then
+			table.insert(key_files, { path = path, index = file_index, score = score })
+		end
+	end
+
+	table.sort(key_files, function(a, b)
+		return a.score > b.score
+	end)
+
+	-- Store top 20 key files in brain
+	for i, kf in ipairs(key_files) do
+		if i > 20 then
+			break
+		end
+		M.sync_to_brain(root .. "/" .. kf.path, kf.index)
+	end
+end
+
+--- Index a single file (incremental update)
+---@param filepath string
+---@return FileIndex|nil
+function M.index_file(filepath)
+	local analyzer = require("codetyper.features.indexer.analyzer")
+	local memory = require("codetyper.features.indexer.memory")
+	local root = utils.get_project_root()
+
+	if not root then
+		return nil
+	end
+
+	-- Load existing index
+	local index = M.load_index() or create_empty_index()
+
+	-- Analyze file
+	local file_index = analyzer.analyze_file(filepath)
+	if not file_index then
+		return nil
+	end
+
+	local relative_path = filepath:gsub("^" .. vim.pesc(root) .. "/", "")
+	file_index.path = relative_path
+
+	-- Remove old symbol references for this file
+	for symbol, paths in pairs(index.symbols) do
+		for i = #paths, 1, -1 do
+			if paths[i] == relative_path then
+				table.remove(paths, i)
+			end
+		end
+		if #paths == 0 then
+			index.symbols[symbol] = nil
+		end
+	end
+
+	-- Add new file index
+	index.files[relative_path] = file_index
+
+	-- Update symbol index
+	for _, exp in ipairs(file_index.exports or {}) do
+		if not index.symbols[exp.name] then
+			index.symbols[exp.name] = {}
+		end
+		table.insert(index.symbols[exp.name], relative_path)
+	end
+
+	-- Recalculate stats
+	local total_functions = 0
+	local total_classes = 0
+	local total_exports = 0
+	local file_count = 0
+
+	for _, f in pairs(index.files) do
+		file_count = file_count + 1
+		total_functions = total_functions + #(f.functions or {})
+		total_classes = total_classes + #(f.classes or {})
+		total_exports = total_exports + #(f.exports or {})
+	end
+
+	index.stats = {
+		files = file_count,
+		functions = total_functions,
+		classes = total_classes,
+		exports = total_exports,
+	}
+	index.last_indexed = os.time()
+
+	-- Save to disk
+	M.save_index(index)
+
+	-- Store file memory
+	memory.store_file_memory(relative_path, file_index)
+
+	-- Sync to brain if available
+	M.sync_to_brain(filepath, file_index)
+
+	return file_index
+end
+
+--- Sync file analysis to brain system
+---@param filepath string Full file path
+---@param file_index FileIndex File analysis
+function M.sync_to_brain(filepath, file_index)
+	local ok_brain, brain = pcall(require, "codetyper.brain")
+	if not ok_brain or not brain.is_initialized or not brain.is_initialized() then
+		return
+	end
+
+	-- Only store if file has meaningful content
+	local funcs = file_index.functions or {}
+	local classes = file_index.classes or {}
+	if #funcs == 0 and #classes == 0 then
+		return
+	end
+
+	-- Build summary
+	local parts = {}
+	if #funcs > 0 then
+		local func_names = {}
+		for i, f in ipairs(funcs) do
+			if i <= 5 then
+				table.insert(func_names, f.name)
+			end
+		end
+		table.insert(parts, "functions: " .. table.concat(func_names, ", "))
+		if #funcs > 5 then
+			table.insert(parts, "(+" .. (#funcs - 5) .. " more)")
+		end
+	end
+	if #classes > 0 then
+		local class_names = {}
+		for _, c in ipairs(classes) do
+			table.insert(class_names, c.name)
+		end
+		table.insert(parts, "classes: " .. table.concat(class_names, ", "))
+	end
+
+	local filename = vim.fn.fnamemodify(filepath, ":t")
+	local summary = filename .. " - " .. table.concat(parts, "; ")
+
+	-- Learn this pattern in brain
+	brain.learn({
+		type = "pattern",
+		file = filepath,
+		content = {
+			summary = summary,
+			detail = #funcs .. " functions, " .. #classes .. " classes",
+		},
+		context = {
+			file = file_index.path or filepath,
+			language = file_index.language,
+			functions = funcs,
+			classes = classes,
+			exports = file_index.exports,
+			imports = file_index.imports,
+		},
+	})
+end
+
+--- Schedule file indexing with debounce
+---@param filepath string
+function M.schedule_index_file(filepath)
+	if not config.enabled or not config.auto_index then
+		return
+	end
+
+	-- Check if file should be indexed
+	local scanner = require("codetyper.features.indexer.scanner")
+	if not scanner.should_index(filepath, config) then
+		return
+	end
+
+	-- Cancel existing timer
+	if index_timer then
+		index_timer:stop()
+	end
+
+	-- Schedule new index
+	index_timer = vim.defer_fn(function()
+		M.index_file(filepath)
+		index_timer = nil
+	end, INDEX_DEBOUNCE_MS)
+end
+
+--- Get relevant context for a prompt
+---@param opts {file: string, intent: table|nil, prompt: string, scope: string|nil}
+---@return table Context information
+function M.get_context_for(opts)
+	local memory = require("codetyper.features.indexer.memory")
+	local index = M.load_index()
+
+	local context = {
+		project_type = "unknown",
+		dependencies = {},
+		relevant_files = {},
+		relevant_symbols = {},
+		patterns = {},
+	}
+
+	if not index then
+		return context
+	end
+
+	context.project_type = index.project_type
+	context.dependencies = index.dependencies
+
+	-- Find relevant symbols from prompt
+	local words = {}
+	for word in opts.prompt:gmatch("%w+") do
+		if #word > 2 then
+			words[word:lower()] = true
+		end
+	end
+
+	-- Match symbols
+	for symbol, files in pairs(index.symbols) do
+		if words[symbol:lower()] then
+			context.relevant_symbols[symbol] = files
+		end
+	end
+
+	-- Get file context if available
+	if opts.file then
+		local root = utils.get_project_root()
+		if root then
+			local relative_path = opts.file:gsub("^" .. vim.pesc(root) .. "/", "")
+			local file_index = index.files[relative_path]
+			if file_index then
+				context.current_file = file_index
+			end
+		end
+	end
+
+	-- Get relevant memories
+	context.patterns = memory.get_relevant(opts.prompt, 5)
+
+	return context
+end
+
+--- Get index status
+---@return table Status information
+function M.get_status()
+	local index = M.load_index()
+	if not index then
+		return {
+			indexed = false,
+			stats = nil,
+			last_indexed = nil,
+		}
+	end
+
+	return {
+		indexed = true,
+		stats = index.stats,
+		last_indexed = index.last_indexed,
+		project_type = index.project_type,
+	}
+end
+
+--- Clear the project index
+function M.clear()
+	local root = utils.get_project_root()
+	if root then
+		index_cache[root] = nil
+	end
+
+	local path = get_index_path()
+	if path and utils.file_exists(path) then
+		os.remove(path)
+	end
+end
+
+--- Setup the indexer with configuration
+---@param opts? table Configuration options
+function M.setup(opts)
+	if opts then
+		config = vim.tbl_deep_extend("force", config, opts)
+	end
+
+	-- Index on startup if configured
+	if config.index_on_open then
+		vim.defer_fn(function()
+			M.index_project()
+		end, 1000)
+	end
+end
+
+--- Get current configuration
+---@return table
+function M.get_config()
+	return vim.deepcopy(config)
+end
+
+return M
--- a/lua/codetyper/features/indexer/memory.lua
+++ b/lua/codetyper/features/indexer/memory.lua
@@ -0,0 +1,539 @@
+---@mod codetyper.indexer.memory Memory persistence manager
+---@brief [[
+--- Stores and retrieves learned patterns and memories in .coder/memories/.
+--- Supports session history for learning from interactions.
+---@brief ]]
+
+local M = {}
+
+local utils = require("codetyper.support.utils")
+
+--- Memory directories
+local MEMORIES_DIR = "memories"
+local SESSIONS_DIR = "sessions"
+local FILES_DIR = "files"
+
+--- Memory files
+local PATTERNS_FILE = "patterns.json"
+local CONVENTIONS_FILE = "conventions.json"
+local SYMBOLS_FILE = "symbols.json"
+
+--- In-memory cache
+local cache = {
+	patterns = nil,
+	conventions = nil,
+	symbols = nil,
+}
+
+---@class Memory
+---@field id string Unique identifier
+---@field type "pattern"|"convention"|"session"|"interaction"
+---@field content string The learned information
+---@field context table Where/when learned
+---@field weight number Importance score (0.0-1.0)
+---@field created_at number Timestamp
+---@field updated_at number Last update timestamp
+---@field used_count number Times referenced
+
+--- Get the memories base directory
+---@return string|nil
+local function get_memories_dir()
+	local root = utils.get_project_root()
+	if not root then
+		return nil
+	end
+	return root .. "/.coder/" .. MEMORIES_DIR
+end
+
+--- Get the sessions directory
+---@return string|nil
+local function get_sessions_dir()
+	local root = utils.get_project_root()
+	if not root then
+		return nil
+	end
+	return root .. "/.coder/" .. SESSIONS_DIR
+end
+
+--- Ensure memories directory exists
+---@return boolean
+local function ensure_memories_dir()
+	local dir = get_memories_dir()
+	if not dir then
+		return false
+	end
+	utils.ensure_dir(dir)
+	utils.ensure_dir(dir .. "/" .. FILES_DIR)
+	return true
+end
+
+--- Ensure sessions directory exists
+---@return boolean
+local function ensure_sessions_dir()
+	local dir = get_sessions_dir()
+	if not dir then
+		return false
+	end
+	return utils.ensure_dir(dir)
+end
+
+--- Generate a unique ID
+---@return string
+local function generate_id()
+	return string.format("mem_%d_%s", os.time(), string.sub(tostring(math.random()), 3, 8))
+end
+
+--- Load a memory file
+---@param filename string
+---@return table
+local function load_memory_file(filename)
+	local dir = get_memories_dir()
+	if not dir then
+		return {}
+	end
+
+	local path = dir .. "/" .. filename
+	local content = utils.read_file(path)
+	if not content then
+		return {}
+	end
+
+	local ok, data = pcall(vim.json.decode, content)
+	if not ok or not data then
+		return {}
+	end
+
+	return data
+end
+
+--- Save a memory file
+---@param filename string
+---@param data table
+---@return boolean
+local function save_memory_file(filename, data)
+	if not ensure_memories_dir() then
+		return false
+	end
+
+	local dir = get_memories_dir()
+	if not dir then
+		return false
+	end
+
+	local path = dir .. "/" .. filename
+	local ok, encoded = pcall(vim.json.encode, data)
+	if not ok then
+		return false
+	end
+
+	return utils.write_file(path, encoded)
+end
+
+--- Hash a file path for storage
+---@param filepath string
+---@return string
+local function hash_path(filepath)
+	local hash = 0
+	for i = 1, #filepath do
+		hash = (hash * 31 + string.byte(filepath, i)) % 2147483647
+	end
+	return string.format("%08x", hash)
+end
+
+--- Load patterns from cache or disk
+---@return table
+function M.load_patterns()
+	if cache.patterns then
+		return cache.patterns
+	end
+	cache.patterns = load_memory_file(PATTERNS_FILE)
+	return cache.patterns
+end
+
+--- Load conventions from cache or disk
+---@return table
+function M.load_conventions()
+	if cache.conventions then
+		return cache.conventions
+	end
+	cache.conventions = load_memory_file(CONVENTIONS_FILE)
+	return cache.conventions
+end
+
+--- Load symbols from cache or disk
+---@return table
+function M.load_symbols()
+	if cache.symbols then
+		return cache.symbols
+	end
+	cache.symbols = load_memory_file(SYMBOLS_FILE)
+	return cache.symbols
+end
+
+--- Store a new memory
+---@param memory Memory
+---@return boolean
+function M.store_memory(memory)
+	memory.id = memory.id or generate_id()
+	memory.created_at = memory.created_at or os.time()
+	memory.updated_at = os.time()
+	memory.used_count = memory.used_count or 0
+	memory.weight = memory.weight or 0.5
+
+	local filename
+	if memory.type == "pattern" then
+		filename = PATTERNS_FILE
+		cache.patterns = nil
+	elseif memory.type == "convention" then
+		filename = CONVENTIONS_FILE
+		cache.conventions = nil
+	else
+		filename = PATTERNS_FILE
+		cache.patterns = nil
+	end
+
+	local data = load_memory_file(filename)
+	data[memory.id] = memory
+
+	return save_memory_file(filename, data)
+end
+
+--- Store file-specific memory
+---@param relative_path string Relative file path
+---@param file_index table FileIndex data
+---@return boolean
+function M.store_file_memory(relative_path, file_index)
+	if not ensure_memories_dir() then
+		return false
+	end
+
+	local dir = get_memories_dir()
+	if not dir then
+		return false
+	end
+
+	local hash = hash_path(relative_path)
+	local path = dir .. "/" .. FILES_DIR .. "/" .. hash .. ".json"
+
+	local data = {
+		path = relative_path,
+		indexed_at = os.time(),
+		functions = file_index.functions or {},
+		classes = file_index.classes or {},
+		exports = file_index.exports or {},
+		imports = file_index.imports or {},
+	}
+
+	local ok, encoded = pcall(vim.json.encode, data)
+	if not ok then
+		return false
+	end
+
+	return utils.write_file(path, encoded)
+end
+
+--- Load file-specific memory
+---@param relative_path string
+---@return table|nil
+function M.load_file_memory(relative_path)
+	local dir = get_memories_dir()
+	if not dir then
+		return nil
+	end
+
+	local hash = hash_path(relative_path)
+	local path = dir .. "/" .. FILES_DIR .. "/" .. hash .. ".json"
+
+	local content = utils.read_file(path)
+	if not content then
+		return nil
+	end
+
+	local ok, data = pcall(vim.json.decode, content)
+	if not ok then
+		return nil
+	end
+
+	return data
+end
+
+--- Store index summary as memories
+---@param index ProjectIndex
+function M.store_index_summary(index)
+	-- Store project type convention
+	if index.project_type and index.project_type ~= "unknown" then
+		M.store_memory({
+			type = "convention",
+			content = "Project uses " .. index.project_type .. " ecosystem",
+			context = {
+				project_root = index.project_root,
+				detected_at = os.time(),
+			},
+			weight = 0.9,
+		})
+	end
+
+	-- Store dependency patterns
+	local dep_count = 0
+	for _ in pairs(index.dependencies or {}) do
+		dep_count = dep_count + 1
+	end
+
+	if dep_count > 0 then
+		local deps_list = {}
+		for name, _ in pairs(index.dependencies) do
+			table.insert(deps_list, name)
+		end
+
+		M.store_memory({
+			type = "pattern",
+			content = "Project dependencies: " .. table.concat(deps_list, ", "),
+			context = {
+				dependency_count = dep_count,
+			},
+			weight = 0.7,
+		})
+	end
+
+	-- Update symbol cache
+	cache.symbols = nil
+	save_memory_file(SYMBOLS_FILE, index.symbols or {})
+end
+
+--- Store session interaction
+---@param interaction {prompt: string, response: string, file: string|nil, success: boolean}
+function M.store_session(interaction)
+	if not ensure_sessions_dir() then
+		return
+	end
+
+	local dir = get_sessions_dir()
+	if not dir then
+		return
+	end
+
+	-- Use date-based session files
+	local date = os.date("%Y-%m-%d")
+	local path = dir .. "/" .. date .. ".json"
+
+	local sessions = {}
+	local content = utils.read_file(path)
+	if content then
+		local ok, data = pcall(vim.json.decode, content)
+		if ok and data then
+			sessions = data
+		end
+	end
+
+	table.insert(sessions, {
+		timestamp = os.time(),
+		prompt = interaction.prompt,
+		response = string.sub(interaction.response or "", 1, 500), -- Truncate
+		file = interaction.file,
+		success = interaction.success,
+	})
+
+	-- Limit session size
+	if #sessions > 100 then
+		sessions = { unpack(sessions, #sessions - 99) }
+	end
+
+	local ok, encoded = pcall(vim.json.encode, sessions)
+	if ok then
+		utils.write_file(path, encoded)
+	end
+end
+
+--- Get relevant memories for a query
+---@param query string Search query
+---@param limit number Maximum results
+---@return Memory[]
+function M.get_relevant(query, limit)
+	limit = limit or 10
+	local results = {}
+
+	-- Tokenize query
+	local query_words = {}
+	for word in query:lower():gmatch("%w+") do
+		if #word > 2 then
+			query_words[word] = true
+		end
+	end
+
+	-- Search patterns
+	local patterns = M.load_patterns()
+	for _, memory in pairs(patterns) do
+		local score = 0
+		local content_lower = (memory.content or ""):lower()
+
+		for word in pairs(query_words) do
+			if content_lower:find(word, 1, true) then
+				score = score + 1
+			end
+		end
+
+		if score > 0 then
+			memory.relevance_score = score * (memory.weight or 0.5)
+			table.insert(results, memory)
+		end
+	end
+
+	-- Search conventions
+	local conventions = M.load_conventions()
+	for _, memory in pairs(conventions) do
+		local score = 0
+		local content_lower = (memory.content or ""):lower()
+
+		for word in pairs(query_words) do
+			if content_lower:find(word, 1, true) then
+				score = score + 1
+			end
+		end
+
+		if score > 0 then
+			memory.relevance_score = score * (memory.weight or 0.5)
+			table.insert(results, memory)
+		end
+	end
+
+	-- Sort by relevance
+	table.sort(results, function(a, b)
+		return (a.relevance_score or 0) > (b.relevance_score or 0)
+	end)
+
+	-- Limit results
+	local limited = {}
+	for i = 1, math.min(limit, #results) do
+		limited[i] = results[i]
+	end
+
+	return limited
+end
+
+--- Update memory usage count
+---@param memory_id string
+function M.update_usage(memory_id)
+	local patterns = M.load_patterns()
+	if patterns[memory_id] then
+		patterns[memory_id].used_count = (patterns[memory_id].used_count or 0) + 1
+		patterns[memory_id].updated_at = os.time()
+		save_memory_file(PATTERNS_FILE, patterns)
+		cache.patterns = nil
+		return
+	end
+
+	local conventions = M.load_conventions()
+	if conventions[memory_id] then
+		conventions[memory_id].used_count = (conventions[memory_id].used_count or 0) + 1
+		conventions[memory_id].updated_at = os.time()
+		save_memory_file(CONVENTIONS_FILE, conventions)
+		cache.conventions = nil
+	end
+end
+
+--- Get all memories
+---@return {patterns: table, conventions: table, symbols: table}
+function M.get_all()
+	return {
+		patterns = M.load_patterns(),
+		conventions = M.load_conventions(),
+		symbols = M.load_symbols(),
+	}
+end
+
+--- Clear all memories
+---@param pattern? string Optional pattern to match memory IDs
+function M.clear(pattern)
+	if not pattern then
+		-- Clear all
+		cache = { patterns = nil, conventions = nil, symbols = nil }
+		save_memory_file(PATTERNS_FILE, {})
+		save_memory_file(CONVENTIONS_FILE, {})
+		save_memory_file(SYMBOLS_FILE, {})
+		return
+	end
+
+	-- Clear matching pattern
+	local patterns = M.load_patterns()
+	for id in pairs(patterns) do
+		if id:match(pattern) then
+			patterns[id] = nil
+		end
+	end
+	save_memory_file(PATTERNS_FILE, patterns)
+	cache.patterns = nil
+
+	local conventions = M.load_conventions()
+	for id in pairs(conventions) do
+		if id:match(pattern) then
+			conventions[id] = nil
+		end
+	end
+	save_memory_file(CONVENTIONS_FILE, conventions)
+	cache.conventions = nil
+end
+
+--- Prune low-weight memories
+---@param threshold number Weight threshold (default: 0.1)
+function M.prune(threshold)
+	threshold = threshold or 0.1
+
+	local patterns = M.load_patterns()
+	local pruned = 0
+	for id, memory in pairs(patterns) do
+		if (memory.weight or 0) < threshold and (memory.used_count or 0) == 0 then
+			patterns[id] = nil
+			pruned = pruned + 1
+		end
+	end
+	if pruned > 0 then
+		save_memory_file(PATTERNS_FILE, patterns)
+		cache.patterns = nil
+	end
+
+	local conventions = M.load_conventions()
+	for id, memory in pairs(conventions) do
+		if (memory.weight or 0) < threshold and (memory.used_count or 0) == 0 then
+			conventions[id] = nil
+			pruned = pruned + 1
+		end
+	end
+	if pruned > 0 then
+		save_memory_file(CONVENTIONS_FILE, conventions)
+		cache.conventions = nil
+	end
+
+	return pruned
+end
+
+--- Get memory statistics
+---@return table
+function M.get_stats()
+	local patterns = M.load_patterns()
+	local conventions = M.load_conventions()
+	local symbols = M.load_symbols()
+
+	local pattern_count = 0
+	for _ in pairs(patterns) do
+		pattern_count = pattern_count + 1
+	end
+
+	local convention_count = 0
+	for _ in pairs(conventions) do
+		convention_count = convention_count + 1
+	end
+
+	local symbol_count = 0
+	for _ in pairs(symbols) do
+		symbol_count = symbol_count + 1
+	end
+
+	return {
+		patterns = pattern_count,
+		conventions = convention_count,
+		symbols = symbol_count,
+		total = pattern_count + convention_count,
+	}
+end
+
+return M
--- a/lua/codetyper/features/indexer/scanner.lua
+++ b/lua/codetyper/features/indexer/scanner.lua
@@ -0,0 +1,409 @@
+---@mod codetyper.indexer.scanner File scanner for project indexing
+---@brief [[
+--- Discovers indexable files, detects project type, and parses dependencies.
+---@brief ]]
+
+local M = {}
+
+local utils = require("codetyper.support.utils")
+
+--- Project type markers
+local PROJECT_MARKERS = {
+	node = { "package.json" },
+	rust = { "Cargo.toml" },
+	go = { "go.mod" },
+	python = { "pyproject.toml", "setup.py", "requirements.txt" },
+	lua = { "init.lua", ".luarc.json" },
+	ruby = { "Gemfile" },
+	java = { "pom.xml", "build.gradle" },
+	csharp = { "*.csproj", "*.sln" },
+}
+
+--- File extension to language mapping
+local EXTENSION_LANGUAGE = {
+	lua = "lua",
+	ts = "typescript",
+	tsx = "typescriptreact",
+	js = "javascript",
+	jsx = "javascriptreact",
+	py = "python",
+	go = "go",
+	rs = "rust",
+	rb = "ruby",
+	java = "java",
+	c = "c",
+	cpp = "cpp",
+	h = "c",
+	hpp = "cpp",
+	cs = "csharp",
+}
+
+--- Default ignore patterns
+local DEFAULT_IGNORES = {
+	"^%.", -- Hidden files/folders
+	"^node_modules$",
+	"^__pycache__$",
+	"^%.git$",
+	"^%.coder$",
+	"^dist$",
+	"^build$",
+	"^target$",
+	"^vendor$",
+	"^%.next$",
+	"^%.nuxt$",
+	"^coverage$",
+	"%.min%.js$",
+	"%.min%.css$",
+	"%.map$",
+	"%.lock$",
+	"%-lock%.json$",
+}
+
+--- Detect project type from root markers
+---@param root string Project root path
+---@return string Project type
+function M.detect_project_type(root)
+	for project_type, markers in pairs(PROJECT_MARKERS) do
+		for _, marker in ipairs(markers) do
+			local path = root .. "/" .. marker
+			if marker:match("^%*") then
+				-- Glob pattern
+				local pattern = marker:gsub("^%*", "")
+				local entries = vim.fn.glob(root .. "/*" .. pattern, false, true)
+				if #entries > 0 then
+					return project_type
+				end
+			else
+				if utils.file_exists(path) then
+					return project_type
+				end
+			end
+		end
+	end
+	return "unknown"
+end
+
+--- Parse project dependencies
+---@param root string Project root path
+---@param project_type string Project type
+---@return {dependencies: table<string, string>, dev_dependencies: table<string, string>}
+function M.parse_dependencies(root, project_type)
+	local deps = {
+		dependencies = {},
+		dev_dependencies = {},
+	}
+
+	if project_type == "node" then
+		deps = M.parse_package_json(root)
+	elseif project_type == "rust" then
+		deps = M.parse_cargo_toml(root)
+	elseif project_type == "go" then
+		deps = M.parse_go_mod(root)
+	elseif project_type == "python" then
+		deps = M.parse_python_deps(root)
+	end
+
+	return deps
+end
+
+--- Parse package.json for Node.js projects
+---@param root string Project root path
+---@return {dependencies: table, dev_dependencies: table}
+function M.parse_package_json(root)
+	local path = root .. "/package.json"
+	local content = utils.read_file(path)
+	if not content then
+		return { dependencies = {}, dev_dependencies = {} }
+	end
+
+	local ok, pkg = pcall(vim.json.decode, content)
+	if not ok or not pkg then
+		return { dependencies = {}, dev_dependencies = {} }
+	end
+
+	return {
+		dependencies = pkg.dependencies or {},
+		dev_dependencies = pkg.devDependencies or {},
+	}
+end
+
+--- Parse Cargo.toml for Rust projects
+---@param root string Project root path
+---@return {dependencies: table, dev_dependencies: table}
+function M.parse_cargo_toml(root)
+	local path = root .. "/Cargo.toml"
+	local content = utils.read_file(path)
+	if not content then
+		return { dependencies = {}, dev_dependencies = {} }
+	end
+
+	local deps = {}
+	local dev_deps = {}
+	local in_deps = false
+	local in_dev_deps = false
+
+	for line in content:gmatch("[^\n]+") do
+		if line:match("^%[dependencies%]") then
+			in_deps = true
+			in_dev_deps = false
+		elseif line:match("^%[dev%-dependencies%]") then
+			in_deps = false
+			in_dev_deps = true
+		elseif line:match("^%[") then
+			in_deps = false
+			in_dev_deps = false
+		elseif in_deps or in_dev_deps then
+			local name, version = line:match('^([%w_%-]+)%s*=%s*"([^"]+)"')
+			if not name then
+				name = line:match("^([%w_%-]+)%s*=")
+				version = "workspace"
+			end
+			if name then
+				if in_deps then
+					deps[name] = version or "unknown"
+				else
+					dev_deps[name] = version or "unknown"
+				end
+			end
+		end
+	end
+
+	return { dependencies = deps, dev_dependencies = dev_deps }
+end
+
+--- Parse go.mod for Go projects
+---@param root string Project root path
+---@return {dependencies: table, dev_dependencies: table}
+function M.parse_go_mod(root)
+	local path = root .. "/go.mod"
+	local content = utils.read_file(path)
+	if not content then
+		return { dependencies = {}, dev_dependencies = {} }
+	end
+
+	local deps = {}
+	local in_require = false
+
+	for line in content:gmatch("[^\n]+") do
+		if line:match("^require%s*%(") then
+			in_require = true
+		elseif line:match("^%)") then
+			in_require = false
+		elseif in_require then
+			local module, version = line:match("^%s*([%w%.%-%_/]+)%s+([%w%.%-]+)")
+			if module then
+				deps[module] = version
+			end
+		else
+			local module, version = line:match("^require%s+([%w%.%-%_/]+)%s+([%w%.%-]+)")
+			if module then
+				deps[module] = version
+			end
+		end
+	end
+
+	return { dependencies = deps, dev_dependencies = {} }
+end
+
+--- Parse Python dependencies (pyproject.toml or requirements.txt)
+---@param root string Project root path
+---@return {dependencies: table, dev_dependencies: table}
+function M.parse_python_deps(root)
+	local deps = {}
+	local dev_deps = {}
+
+	-- Try pyproject.toml first
+	local pyproject = root .. "/pyproject.toml"
+	local content = utils.read_file(pyproject)
+
+	if content then
+		-- Simple parsing for dependencies
+		local in_deps = false
+		local in_dev = false
+
+		for line in content:gmatch("[^\n]+") do
+			if line:match("^%[project%.dependencies%]") or line:match("^dependencies%s*=") then
+				in_deps = true
+				in_dev = false
+			elseif line:match("dev") and line:match("dependencies") then
+				in_deps = false
+				in_dev = true
+			elseif line:match("^%[") then
+				in_deps = false
+				in_dev = false
+			elseif in_deps or in_dev then
+				local name = line:match('"([%w_%-]+)')
+				if name then
+					if in_deps then
+						deps[name] = "latest"
+					else
+						dev_deps[name] = "latest"
+					end
+				end
+			end
+		end
+	end
+
+	-- Fallback to requirements.txt
+	local req_file = root .. "/requirements.txt"
+	content = utils.read_file(req_file)
+
+	if content then
+		for line in content:gmatch("[^\n]+") do
+			if not line:match("^#") and not line:match("^%s*$") then
+				local name, version = line:match("^([%w_%-]+)==([%d%.]+)")
+				if not name then
+					name = line:match("^([%w_%-]+)")
+					version = "latest"
+				end
+				if name then
+					deps[name] = version or "latest"
+				end
+			end
+		end
+	end
+
+	return { dependencies = deps, dev_dependencies = dev_deps }
+end
+
+--- Check if a file/directory should be ignored
+---@param name string File or directory name
+---@param config table Indexer configuration
+---@return boolean
+function M.should_ignore(name, config)
+	-- Check default patterns
+	for _, pattern in ipairs(DEFAULT_IGNORES) do
+		if name:match(pattern) then
+			return true
+		end
+	end
+
+	-- Check config excluded dirs
+	if config and config.excluded_dirs then
+		for _, dir in ipairs(config.excluded_dirs) do
+			if name == dir then
+				return true
+			end
+		end
+	end
+
+	return false
+end
+
+--- Check if a file should be indexed
+---@param filepath string Full file path
+---@param config table Indexer configuration
+---@return boolean
+function M.should_index(filepath, config)
+	local name = vim.fn.fnamemodify(filepath, ":t")
+	local ext = vim.fn.fnamemodify(filepath, ":e")
+
+	-- Check if it's a coder file
+	if utils.is_coder_file(filepath) then
+		return false
+	end
+
+	-- Check file size
+	if config and config.max_file_size then
+		local stat = vim.loop.fs_stat(filepath)
+		if stat and stat.size > config.max_file_size then
+			return false
+		end
+	end
+
+	-- Check extension
+	if config and config.index_extensions then
+		local valid_ext = false
+		for _, allowed_ext in ipairs(config.index_extensions) do
+			if ext == allowed_ext then
+				valid_ext = true
+				break
+			end
+		end
+		if not valid_ext then
+			return false
+		end
+	end
+
+	-- Check ignore patterns
+	if M.should_ignore(name, config) then
+		return false
+	end
+
+	return true
+end
+
+--- Get all indexable files in the project
+---@param root string Project root path
+---@param config table Indexer configuration
+---@return string[] List of file paths
+function M.get_indexable_files(root, config)
+	local files = {}
+
+	local function scan_dir(path)
+		local handle = vim.loop.fs_scandir(path)
+		if not handle then
+			return
+		end
+
+		while true do
+			local name, type = vim.loop.fs_scandir_next(handle)
+			if not name then
+				break
+			end
+
+			local full_path = path .. "/" .. name
+
+			if M.should_ignore(name, config) then
+				goto continue
+			end
+
+			if type == "directory" then
+				scan_dir(full_path)
+			elseif type == "file" then
+				if M.should_index(full_path, config) then
+					table.insert(files, full_path)
+				end
+			end
+
+			::continue::
+		end
+	end
+
+	scan_dir(root)
+	return files
+end
+
+--- Get language from file extension
+---@param filepath string File path
+---@return string Language name
+function M.get_language(filepath)
+	local ext = vim.fn.fnamemodify(filepath, ":e")
+	return EXTENSION_LANGUAGE[ext] or ext
+end
+
+--- Read .gitignore patterns
+---@param root string Project root
+---@return string[] Patterns
+function M.read_gitignore(root)
+	local patterns = {}
+	local path = root .. "/.gitignore"
+	local content = utils.read_file(path)
+
+	if not content then
+		return patterns
+	end
+
+	for line in content:gmatch("[^\n]+") do
+		-- Skip comments and empty lines
+		if not line:match("^#") and not line:match("^%s*$") then
+			-- Convert gitignore pattern to Lua pattern (simplified)
+			local pattern = line:gsub("^/", "^"):gsub("%*%*", ".*"):gsub("%*", "[^/]*"):gsub("%?", ".")
+			table.insert(patterns, pattern)
+		end
+	end
+
+	return patterns
+end
+
+return M
--- a/lua/codetyper/init.lua
+++ b/lua/codetyper/init.lua
@@ -1,7 +1,7 @@
 ---@mod codetyper Codetyper.nvim - AI-powered coding partner
 ---@brief [[
 --- Codetyper.nvim is a Neovim plugin that acts as your coding partner.
--- It uses LLM APIs (Claude, OpenAI, Gemini, Copilot, Ollama) to help you
+--- It uses LLM APIs (OpenAI, Gemini, Copilot, Ollama) to help you
 --- write code faster using special `.coder.*` files and inline prompt tags.
 --- Features an event-driven scheduler with confidence scoring and
 --- completion-aware injection timing.
@@ -22,14 +22,16 @@ function M.setup(opts)
    return
  end

-  local config = require("codetyper.config")
+  local config = require("codetyper.config.defaults")
  M.config = config.setup(opts)

  -- Initialize modules
-  local commands = require("codetyper.commands")
-  local gitignore = require("codetyper.gitignore")
-  local autocmds = require("codetyper.autocmds")
-  local tree = require("codetyper.tree")
+  local commands = require("codetyper.adapters.nvim.commands")
+  local gitignore = require("codetyper.support.gitignore")
+  local autocmds = require("codetyper.adapters.nvim.autocmds")
+  local tree = require("codetyper.support.tree")
+  local completion = require("codetyper.features.completion.inline")
+  local logs_panel = require("codetyper.adapters.nvim.ui.logs_panel")

  -- Register commands
  commands.setup()
@@ -37,15 +39,39 @@ function M.setup(opts)
  -- Setup autocommands
  autocmds.setup()

+  -- Setup file reference completion
+  completion.setup()
+
+  -- Setup logs panel (handles VimLeavePre cleanup)
+  logs_panel.setup()
+
  -- Ensure .gitignore has coder files excluded
  gitignore.ensure_ignored()

  -- Initialize tree logging (creates .coder folder and initial tree.log)
  tree.setup()

+  -- Initialize project indexer if enabled
+  if M.config.indexer and M.config.indexer.enabled then
+    local indexer = require("codetyper.features.indexer")
+    indexer.setup(M.config.indexer)
+  end
+
+  -- Initialize brain learning system if enabled
+  if M.config.brain and M.config.brain.enabled then
+    local brain = require("codetyper.core.memory")
+    brain.setup(M.config.brain)
+  end
+
+  -- Setup inline ghost text suggestions (Copilot-style)
+  if M.config.suggestion and M.config.suggestion.enabled then
+    local suggestion = require("codetyper.features.completion.suggestion")
+    suggestion.setup(M.config.suggestion)
+  end
+
  -- Start the event-driven scheduler if enabled
  if M.config.scheduler and M.config.scheduler.enabled then
-    local scheduler = require("codetyper.agent.scheduler")
+    local scheduler = require("codetyper.core.scheduler.scheduler")
    scheduler.start(M.config.scheduler)
  end

@@ -54,7 +80,7 @@ function M.setup(opts)
  -- Auto-open Ask panel after a short delay (to let UI settle)
  if M.config.auto_open_ask then
    vim.defer_fn(function()
-      local ask = require("codetyper.ask")
+      local ask = require("codetyper.features.ask.engine")
      if not ask.is_open() then
        ask.open()
      end
--- a/lua/codetyper/inject.lua
+++ b/lua/codetyper/inject.lua
@@ -2,14 +2,14 @@

 local M = {}

-local utils = require("codetyper.utils")
+local utils = require("codetyper.support.utils")

 --- Inject generated code into target file
 ---@param target_path string Path to target file
 ---@param code string Generated code
 ---@param prompt_type string Type of prompt (refactor, add, document, etc.)
 function M.inject_code(target_path, code, prompt_type)
-  local window = require("codetyper.window")
+  local window = require("codetyper.adapters.nvim.windows")

  -- Normalize the target path
  target_path = vim.fn.fnamemodify(target_path, ":p")
@@ -109,7 +109,7 @@ function M.inject_add(bufnr, code)
  local lines = vim.split(code, "\n", { plain = true })

  -- Get cursor position in target window
-  local window = require("codetyper.window")
+  local window = require("codetyper.adapters.nvim.windows")
  local target_win = window.get_target_win()

  local insert_line
--- a/lua/codetyper/llm/claude.lua
+++ b/lua/codetyper/llm/claude.lua
@@ -1,364 +0,0 @@
---@mod codetyper.llm.claude Claude API client for Codetyper.nvim
-
-local M = {}
-
-local utils = require("codetyper.utils")
-local llm = require("codetyper.llm")
-
--- Claude API endpoint
-local API_URL = "https://api.anthropic.com/v1/messages"
-
--- Get API key from config or environment
---@return string|nil API key
-local function get_api_key()
-	local codetyper = require("codetyper")
-	local config = codetyper.get_config()
-
-	return config.llm.claude.api_key or vim.env.ANTHROPIC_API_KEY
-end
-
--- Get model from config
---@return string Model name
-local function get_model()
-	local codetyper = require("codetyper")
-	local config = codetyper.get_config()
-
-	return config.llm.claude.model
-end
-
--- Build request body for Claude API
---@param prompt string User prompt
---@param context table Context information
---@return table Request body
-local function build_request_body(prompt, context)
-	local system_prompt = llm.build_system_prompt(context)
-
-	return {
-		model = get_model(),
-		max_tokens = 4096,
-		system = system_prompt,
-		messages = {
-			{
-				role = "user",
-				content = prompt,
-			},
-		},
-	}
-end
-
--- Make HTTP request to Claude API
---@param body table Request body
---@param callback fun(response: string|nil, error: string|nil, usage: table|nil) Callback function
-local function make_request(body, callback)
-	local api_key = get_api_key()
-	if not api_key then
-		callback(nil, "Claude API key not configured", nil)
-		return
-	end
-
-	local json_body = vim.json.encode(body)
-
-	-- Use curl for HTTP request (plenary.curl alternative)
-	local cmd = {
-		"curl",
-		"-s",
-		"-X",
-		"POST",
-		API_URL,
-		"-H",
-		"Content-Type: application/json",
-		"-H",
-		"x-api-key: " .. api_key,
-		"-H",
-		"anthropic-version: 2023-06-01",
-		"-d",
-		json_body,
-	}
-
-	vim.fn.jobstart(cmd, {
-		stdout_buffered = true,
-		on_stdout = function(_, data)
-			if not data or #data == 0 or (data[1] == "" and #data == 1) then
-				return
-			end
-
-			local response_text = table.concat(data, "\n")
-			local ok, response = pcall(vim.json.decode, response_text)
-
-			if not ok then
-				vim.schedule(function()
-					callback(nil, "Failed to parse Claude response", nil)
-				end)
-				return
-			end
-
-			if response.error then
-				vim.schedule(function()
-					callback(nil, response.error.message or "Claude API error", nil)
-				end)
-				return
-			end
-
-			-- Extract usage info
-			local usage = response.usage or {}
-
-			if response.content and response.content[1] and response.content[1].text then
-				local code = llm.extract_code(response.content[1].text)
-				vim.schedule(function()
-					callback(code, nil, usage)
-				end)
-			else
-				vim.schedule(function()
-					callback(nil, "No content in Claude response", nil)
-				end)
-			end
-		end,
-		on_stderr = function(_, data)
-			if data and #data > 0 and data[1] ~= "" then
-				vim.schedule(function()
-					callback(nil, "Claude API request failed: " .. table.concat(data, "\n"), nil)
-				end)
-			end
-		end,
-		on_exit = function(_, code)
-			if code ~= 0 then
-				vim.schedule(function()
-					callback(nil, "Claude API request failed with code: " .. code, nil)
-				end)
-			end
-		end,
-	})
-end
-
--- Generate code using Claude API
---@param prompt string The user's prompt
---@param context table Context information
---@param callback fun(response: string|nil, error: string|nil) Callback function
-function M.generate(prompt, context, callback)
-	local logs = require("codetyper.agent.logs")
-	local model = get_model()
-
-	-- Log the request
-	logs.request("claude", model)
-	logs.thinking("Building request body...")
-
-	local body = build_request_body(prompt, context)
-
-	-- Estimate prompt tokens
-	local prompt_estimate = logs.estimate_tokens(vim.json.encode(body))
-	logs.debug(string.format("Estimated prompt: ~%d tokens", prompt_estimate))
-	logs.thinking("Sending to Claude API...")
-
-	utils.notify("Sending request to Claude...", vim.log.levels.INFO)
-
-	make_request(body, function(response, err, usage)
-		if err then
-			logs.error(err)
-			utils.notify(err, vim.log.levels.ERROR)
-			callback(nil, err)
-		else
-			-- Log token usage
-			if usage then
-				logs.response(usage.input_tokens or 0, usage.output_tokens or 0, "end_turn")
-			end
-			logs.thinking("Response received, extracting code...")
-			logs.info("Code generated successfully")
-			utils.notify("Code generated successfully", vim.log.levels.INFO)
-			callback(response, nil)
-		end
-	end)
-end
-
--- Check if Claude is properly configured
---@return boolean, string? Valid status and optional error message
-function M.validate()
-	local api_key = get_api_key()
-	if not api_key or api_key == "" then
-		return false, "Claude API key not configured"
-	end
-	return true
-end
-
--- Generate with tool use support for agentic mode
---@param messages table[] Conversation history
---@param context table Context information
---@param tool_definitions table Tool definitions
---@param callback fun(response: table|nil, error: string|nil) Callback with raw response
-function M.generate_with_tools(messages, context, tool_definitions, callback)
-	local logs = require("codetyper.agent.logs")
-	local model = get_model()
-
-	-- Log the request
-	logs.request("claude", model)
-	logs.thinking("Preparing agent request...")
-
-	local api_key = get_api_key()
-	if not api_key then
-		logs.error("Claude API key not configured")
-		callback(nil, "Claude API key not configured")
-		return
-	end
-
-	local tools_module = require("codetyper.agent.tools")
-	local agent_prompts = require("codetyper.prompts.agent")
-
-	-- Build system prompt with agent instructions
-	local system_prompt = llm.build_system_prompt(context)
-	system_prompt = system_prompt .. "\n\n" .. agent_prompts.system
-	system_prompt = system_prompt .. "\n\n" .. agent_prompts.tool_instructions
-
-	-- Build request body with tools
-	local body = {
-		model = get_model(),
-		max_tokens = 4096,
-		system = system_prompt,
-		messages = M.format_messages_for_claude(messages),
-		tools = tools_module.to_claude_format(),
-	}
-
-	local json_body = vim.json.encode(body)
-
-	-- Estimate prompt tokens
-	local prompt_estimate = logs.estimate_tokens(json_body)
-	logs.debug(string.format("Estimated prompt: ~%d tokens", prompt_estimate))
-	logs.thinking("Sending to Claude API...")
-
-	local cmd = {
-		"curl",
-		"-s",
-		"-X",
-		"POST",
-		API_URL,
-		"-H",
-		"Content-Type: application/json",
-		"-H",
-		"x-api-key: " .. api_key,
-		"-H",
-		"anthropic-version: 2023-06-01",
-		"-d",
-		json_body,
-	}
-
-	vim.fn.jobstart(cmd, {
-		stdout_buffered = true,
-		on_stdout = function(_, data)
-			if not data or #data == 0 or (data[1] == "" and #data == 1) then
-				return
-			end
-
-			local response_text = table.concat(data, "\n")
-			local ok, response = pcall(vim.json.decode, response_text)
-
-			if not ok then
-				vim.schedule(function()
-					logs.error("Failed to parse Claude response")
-					callback(nil, "Failed to parse Claude response")
-				end)
-				return
-			end
-
-			if response.error then
-				vim.schedule(function()
-					logs.error(response.error.message or "Claude API error")
-					callback(nil, response.error.message or "Claude API error")
-				end)
-				return
-			end
-
-			-- Log token usage from response
-			if response.usage then
-				logs.response(response.usage.input_tokens or 0, response.usage.output_tokens or 0, response.stop_reason)
-			end
-
-			-- Log what's in the response
-			if response.content then
-				for _, block in ipairs(response.content) do
-					if block.type == "text" then
-						logs.thinking("Response contains text")
-					elseif block.type == "tool_use" then
-						logs.thinking("Tool call: " .. block.name)
-					end
-				end
-			end
-
-			-- Return raw response for parser to handle
-			vim.schedule(function()
-				callback(response, nil)
-			end)
-		end,
-		on_stderr = function(_, data)
-			if data and #data > 0 and data[1] ~= "" then
-				vim.schedule(function()
-					logs.error("Claude API request failed: " .. table.concat(data, "\n"))
-					callback(nil, "Claude API request failed: " .. table.concat(data, "\n"))
-				end)
-			end
-		end,
-		on_exit = function(_, code)
-			if code ~= 0 then
-				vim.schedule(function()
-					logs.error("Claude API request failed with code: " .. code)
-					callback(nil, "Claude API request failed with code: " .. code)
-				end)
-			end
-		end,
-	})
-end
-
--- Format messages for Claude API
---@param messages table[] Internal message format
---@return table[] Claude API message format
-function M.format_messages_for_claude(messages)
-	local formatted = {}
-
-	for _, msg in ipairs(messages) do
-		if msg.role == "user" then
-			if type(msg.content) == "table" then
-				-- Tool results
-				table.insert(formatted, {
-					role = "user",
-					content = msg.content,
-				})
-			else
-				table.insert(formatted, {
-					role = "user",
-					content = msg.content,
-				})
-			end
-		elseif msg.role == "assistant" then
-			-- Build content array for assistant messages
-			local content = {}
-
-			-- Add text if present
-			if msg.content and msg.content ~= "" then
-				table.insert(content, {
-					type = "text",
-					text = msg.content,
-				})
-			end
-
-			-- Add tool uses if present
-			if msg.tool_calls then
-				for _, tool_call in ipairs(msg.tool_calls) do
-					table.insert(content, {
-						type = "tool_use",
-						id = tool_call.id,
-						name = tool_call.name,
-						input = tool_call.parameters,
-					})
-				end
-			end
-
-			if #content > 0 then
-				table.insert(formatted, {
-					role = "assistant",
-					content = content,
-				})
-			end
-		end
-	end
-
-	return formatted
-end
-
-return M
--- a/lua/codetyper/logs_panel.lua
+++ b/lua/codetyper/logs_panel.lua
@@ -1,205 +0,0 @@
---@mod codetyper.logs_panel Standalone logs panel for code generation
---
--- Shows real-time logs when generating code via /@ @/ prompts.
-
-local M = {}
-
-local logs = require("codetyper.agent.logs")
-
---@class LogsPanelState
---@field buf number|nil Buffer
---@field win number|nil Window
---@field is_open boolean Whether the panel is open
---@field listener_id number|nil Listener ID for logs
-
-local state = {
-  buf = nil,
-  win = nil,
-  is_open = false,
-  listener_id = nil,
-}
-
--- Namespace for highlights
-local ns_logs = vim.api.nvim_create_namespace("codetyper_logs_panel")
-
--- Fixed width
-local LOGS_WIDTH = 60
-
--- Add a log entry to the buffer
---@param entry table Log entry
-local function add_log_entry(entry)
-  if not state.buf or not vim.api.nvim_buf_is_valid(state.buf) then
-    return
-  end
-
-  vim.schedule(function()
-    if not state.buf or not vim.api.nvim_buf_is_valid(state.buf) then
-      return
-    end
-
-    -- Handle clear event
-    if entry.level == "clear" then
-      vim.bo[state.buf].modifiable = true
-      vim.api.nvim_buf_set_lines(state.buf, 0, -1, false, {
-        "Generation Logs",
-        string.rep("─", LOGS_WIDTH - 2),
-        "",
-      })
-      vim.bo[state.buf].modifiable = false
-      return
-    end
-
-    vim.bo[state.buf].modifiable = true
-
-    local formatted = logs.format_entry(entry)
-    local lines = vim.api.nvim_buf_get_lines(state.buf, 0, -1, false)
-    local line_num = #lines
-
-    vim.api.nvim_buf_set_lines(state.buf, -1, -1, false, { formatted })
-
-    -- Apply highlighting based on level
-    local hl_map = {
-      info = "DiagnosticInfo",
-      debug = "Comment",
-      request = "DiagnosticWarn",
-      response = "DiagnosticOk",
-      tool = "DiagnosticHint",
-      error = "DiagnosticError",
-    }
-
-    local hl = hl_map[entry.level] or "Normal"
-    vim.api.nvim_buf_add_highlight(state.buf, ns_logs, hl, line_num, 0, -1)
-
-    vim.bo[state.buf].modifiable = false
-
-    -- Auto-scroll logs
-    if state.win and vim.api.nvim_win_is_valid(state.win) then
-      local new_count = vim.api.nvim_buf_line_count(state.buf)
-      pcall(vim.api.nvim_win_set_cursor, state.win, { new_count, 0 })
-    end
-  end)
-end
-
--- Update the title with token counts
-local function update_title()
-  if not state.win or not vim.api.nvim_win_is_valid(state.win) then
-    return
-  end
-
-  local prompt_tokens, response_tokens = logs.get_token_totals()
-  local provider, model = logs.get_provider_info()
-
-  if provider and state.buf and vim.api.nvim_buf_is_valid(state.buf) then
-    vim.bo[state.buf].modifiable = true
-    local title = string.format("%s | %d/%d tokens", (provider or ""):upper(), prompt_tokens, response_tokens)
-    vim.api.nvim_buf_set_lines(state.buf, 0, 1, false, { title })
-    vim.bo[state.buf].modifiable = false
-  end
-end
-
--- Open the logs panel
-function M.open()
-  if state.is_open then
-    return
-  end
-
-  -- Clear previous logs
-  logs.clear()
-
-  -- Create buffer
-  state.buf = vim.api.nvim_create_buf(false, true)
-  vim.bo[state.buf].buftype = "nofile"
-  vim.bo[state.buf].bufhidden = "hide"
-  vim.bo[state.buf].swapfile = false
-
-  -- Create window on the right
-  vim.cmd("botright vsplit")
-  state.win = vim.api.nvim_get_current_win()
-  vim.api.nvim_win_set_buf(state.win, state.buf)
-  vim.api.nvim_win_set_width(state.win, LOGS_WIDTH)
-
-  -- Window options
-  vim.wo[state.win].number = false
-  vim.wo[state.win].relativenumber = false
-  vim.wo[state.win].signcolumn = "no"
-  vim.wo[state.win].wrap = true
-  vim.wo[state.win].linebreak = true
-  vim.wo[state.win].winfixwidth = true
-  vim.wo[state.win].cursorline = false
-
-  -- Set initial content
-  vim.bo[state.buf].modifiable = true
-  vim.api.nvim_buf_set_lines(state.buf, 0, -1, false, {
-    "Generation Logs",
-    string.rep("─", LOGS_WIDTH - 2),
-    "",
-  })
-  vim.bo[state.buf].modifiable = false
-
-  -- Setup keymaps
-  local opts = { buffer = state.buf, noremap = true, silent = true }
-  vim.keymap.set("n", "q", M.close, opts)
-  vim.keymap.set("n", "<Esc>", M.close, opts)
-
-  -- Register log listener
-  state.listener_id = logs.add_listener(function(entry)
-    add_log_entry(entry)
-    if entry.level == "response" then
-      vim.schedule(update_title)
-    end
-  end)
-
-  state.is_open = true
-
-  -- Return focus to previous window
-  vim.cmd("wincmd p")
-
-  logs.info("Logs panel opened")
-end
-
--- Close the logs panel
-function M.close()
-  if not state.is_open then
-    return
-  end
-
-  -- Remove log listener
-  if state.listener_id then
-    logs.remove_listener(state.listener_id)
-    state.listener_id = nil
-  end
-
-  -- Close window
-  if state.win and vim.api.nvim_win_is_valid(state.win) then
-    pcall(vim.api.nvim_win_close, state.win, true)
-  end
-
-  -- Reset state
-  state.buf = nil
-  state.win = nil
-  state.is_open = false
-end
-
--- Toggle the logs panel
-function M.toggle()
-  if state.is_open then
-    M.close()
-  else
-    M.open()
-  end
-end
-
--- Check if panel is open
---@return boolean
-function M.is_open()
-  return state.is_open
-end
-
--- Ensure panel is open (call before starting generation)
-function M.ensure_open()
-  if not state.is_open then
-    M.open()
-  end
-end
-
-return M
--- a/lua/codetyper/params/agents/bash.lua
+++ b/lua/codetyper/params/agents/bash.lua
@@ -0,0 +1,35 @@
+M.params = {
+	{
+		name = "command",
+		description = "The shell command to execute",
+		type = "string",
+	},
+	{
+		name = "cwd",
+		description = "Working directory for the command (optional)",
+		type = "string",
+		optional = true,
+	},
+	{
+		name = "timeout",
+		description = "Timeout in milliseconds (default: 120000)",
+		type = "integer",
+		optional = true,
+	},
+}
+
+M.returns = {
+	{
+		name = "stdout",
+		description = "Command output",
+		type = "string",
+	},
+	{
+		name = "error",
+		description = "Error message if command failed",
+		type = "string",
+		optional = true,
+	},
+}
+
+return M
--- a/lua/codetyper/params/agents/confidence.lua
+++ b/lua/codetyper/params/agents/confidence.lua
@@ -0,0 +1,40 @@
+---@mod codetyper.params.agents.confidence Parameters for confidence scoring
+local M = {}
+
+--- Heuristic weights (must sum to 1.0)
+M.weights = {
+	length = 0.15, -- Response length relative to prompt
+	uncertainty = 0.30, -- Uncertainty phrases
+	syntax = 0.25, -- Syntax completeness
+	repetition = 0.15, -- Duplicate lines
+	truncation = 0.15, -- Incomplete ending
+}
+
+--- Uncertainty phrases that indicate low confidence
+M.uncertainty_phrases = {
+	-- English
+	"i'm not sure",
+	"i am not sure",
+	"maybe",
+	"perhaps",
+	"might work",
+	"could work",
+	"not certain",
+	"uncertain",
+	"i think",
+	"possibly",
+	"TODO",
+	"FIXME",
+	"XXX",
+	"placeholder",
+	"implement this",
+	"fill in",
+	"your code here",
+	"...", -- Ellipsis as placeholder
+	"# TODO",
+	"// TODO",
+	"-- TODO",
+	"/* TODO",
+}
+
+return M
--- a/lua/codetyper/params/agents/conflict.lua
+++ b/lua/codetyper/params/agents/conflict.lua
@@ -0,0 +1,33 @@
+---@mod codetyper.params.agents.conflict Parameters for conflict resolution
+local M = {}
+
+--- Configuration defaults
+M.config = {
+	-- Run linter check after accepting AI suggestions
+	lint_after_accept = true,
+	-- Auto-fix lint errors without prompting
+	auto_fix_lint_errors = true,
+	-- Auto-show menu after injecting conflict
+	auto_show_menu = true,
+	-- Auto-show menu for next conflict after resolving one
+	auto_show_next_menu = true,
+}
+
+--- Highlight groups
+M.hl_groups = {
+	current = "CoderConflictCurrent",
+	current_label = "CoderConflictCurrentLabel",
+	incoming = "CoderConflictIncoming",
+	incoming_label = "CoderConflictIncomingLabel",
+	separator = "CoderConflictSeparator",
+	hint = "CoderConflictHint",
+}
+
+--- Conflict markers
+M.markers = {
+	current_start = "<<<<<<< CURRENT",
+	separator = "=======",
+	incoming_end = ">>>>>>> INCOMING",
+}
+
+return M
--- a/lua/codetyper/params/agents/context.lua
+++ b/lua/codetyper/params/agents/context.lua
@@ -0,0 +1,48 @@
+---@mod codetyper.params.agents.context Parameters for context building
+local M = {}
+
+--- Common ignore patterns
+M.ignore_patterns = {
+	"^%.", -- Hidden files/dirs
+	"node_modules",
+	"%.git$",
+	"__pycache__",
+	"%.pyc$",
+	"target", -- Rust
+	"build",
+	"dist",
+	"%.o$",
+	"%.a$",
+	"%.so$",
+	"%.min%.",
+	"%.map$",
+}
+
+--- Key files that are important for understanding the project
+M.important_files = {
+	["package.json"] = "Node.js project config",
+	["Cargo.toml"] = "Rust project config",
+	["go.mod"] = "Go module config",
+	["pyproject.toml"] = "Python project config",
+	["setup.py"] = "Python setup config",
+	["Makefile"] = "Build configuration",
+	["CMakeLists.txt"] = "CMake config",
+	[".gitignore"] = "Git ignore patterns",
+	["README.md"] = "Project documentation",
+	["init.lua"] = "Neovim plugin entry",
+	["plugin.lua"] = "Neovim plugin config",
+}
+
+--- Project type detection indicators
+M.indicators = {
+	["package.json"] = { type = "node", language = "javascript/typescript" },
+	["Cargo.toml"] = { type = "rust", language = "rust" },
+	["go.mod"] = { type = "go", language = "go" },
+	["pyproject.toml"] = { type = "python", language = "python" },
+	["setup.py"] = { type = "python", language = "python" },
+	["Gemfile"] = { type = "ruby", language = "ruby" },
+	["pom.xml"] = { type = "maven", language = "java" },
+	["build.gradle"] = { type = "gradle", language = "java/kotlin" },
+}
+
+return M
--- a/lua/codetyper/params/agents/edit.lua
+++ b/lua/codetyper/params/agents/edit.lua
@@ -0,0 +1,33 @@
+M.params = {
+	{
+		name = "path",
+		description = "Path to the file to edit",
+		type = "string",
+	},
+	{
+		name = "old_string",
+		description = "Text to find and replace (empty string to create new file or append)",
+		type = "string",
+	},
+	{
+		name = "new_string",
+		description = "Text to replace with",
+		type = "string",
+	},
+}
+
+M.returns = {
+	{
+		name = "success",
+		description = "Whether the edit was applied",
+		type = "boolean",
+	},
+	{
+		name = "error",
+		description = "Error message if edit failed",
+		type = "string",
+		optional = true,
+	},
+}
+
+return M
--- a/lua/codetyper/params/agents/grep.lua
+++ b/lua/codetyper/params/agents/grep.lua
@@ -0,0 +1,10 @@
+M.description = [[Searches for a pattern in files using ripgrep.
+
+Returns file paths and matching lines. Use this to find code by content.
+
+Example patterns:
+- "function foo" - Find function definitions
+- "import.*react" - Find React imports
+- "TODO|FIXME" - Find todo comments]]
+
+return M
--- a/lua/codetyper/params/agents/intent.lua
+++ b/lua/codetyper/params/agents/intent.lua
@@ -0,0 +1,161 @@
+---@mod codetyper.params.agents.intent Intent patterns and scope configuration
+local M = {}
+
+--- Intent patterns with associated metadata
+M.intent_patterns = {
+	-- Complete: fill in missing implementation
+	complete = {
+		patterns = {
+			"complete",
+			"finish",
+			"implement",
+			"fill in",
+			"fill out",
+			"stub",
+			"todo",
+			"fixme",
+		},
+		scope_hint = "function",
+		action = "replace",
+		priority = 1,
+	},
+
+	-- Refactor: rewrite existing code
+	refactor = {
+		patterns = {
+			"refactor",
+			"rewrite",
+			"restructure",
+			"reorganize",
+			"clean up",
+			"cleanup",
+			"simplify",
+			"improve",
+		},
+		scope_hint = "function",
+		action = "replace",
+		priority = 2,
+	},
+
+	-- Fix: repair bugs or issues
+	fix = {
+		patterns = {
+			"fix",
+			"repair",
+			"correct",
+			"debug",
+			"solve",
+			"resolve",
+			"patch",
+			"bug",
+			"error",
+			"issue",
+			"update",
+			"modify",
+			"change",
+			"adjust",
+			"tweak",
+		},
+		scope_hint = "function",
+		action = "replace",
+		priority = 1,
+	},
+
+	-- Add: insert new code
+	add = {
+		patterns = {
+			"add",
+			"create",
+			"insert",
+			"include",
+			"append",
+			"new",
+			"generate",
+			"write",
+		},
+		scope_hint = nil, -- Could be anywhere
+		action = "insert",
+		priority = 3,
+	},
+
+	-- Document: add documentation
+	document = {
+		patterns = {
+			"document",
+			"comment",
+			"jsdoc",
+			"docstring",
+			"describe",
+			"annotate",
+			"type hint",
+			"typehint",
+		},
+		scope_hint = "function",
+		action = "replace", -- Replace with documented version
+		priority = 2,
+	},
+
+	-- Test: generate tests
+	test = {
+		patterns = {
+			"test",
+			"spec",
+			"unit test",
+			"integration test",
+			"coverage",
+		},
+		scope_hint = "file",
+		action = "append",
+		priority = 3,
+	},
+
+	-- Optimize: improve performance
+	optimize = {
+		patterns = {
+			"optimize",
+			"performance",
+			"faster",
+			"efficient",
+			"speed up",
+			"reduce",
+			"minimize",
+		},
+		scope_hint = "function",
+		action = "replace",
+		priority = 2,
+	},
+
+	-- Explain: provide explanation (no code change)
+	explain = {
+		patterns = {
+			"explain",
+			"what does",
+			"how does",
+			"why",
+			"describe",
+			"walk through",
+			"understand",
+		},
+		scope_hint = "function",
+		action = "none",
+		priority = 4,
+	},
+}
+
+--- Scope hint patterns
+M.scope_patterns = {
+	["this function"] = "function",
+	["this method"] = "function",
+	["the function"] = "function",
+	["the method"] = "function",
+	["this class"] = "class",
+	["the class"] = "class",
+	["this file"] = "file",
+	["the file"] = "file",
+	["this block"] = "block",
+	["the block"] = "block",
+	["this"] = nil, -- Use Tree-sitter to determine
+	["here"] = nil,
+}
+
+return M
--- a/lua/codetyper/params/agents/languages.lua
+++ b/lua/codetyper/params/agents/languages.lua
@@ -0,0 +1,87 @@
+---@mod codetyper.params.agents.languages Language-specific patterns and configurations
+local M = {}
+
+--- Language-specific import patterns
+M.import_patterns = {
+	-- JavaScript/TypeScript
+	javascript = {
+		{ pattern = "^%s*import%s+.+%s+from%s+['\"]", multi_line = true },
+		{ pattern = "^%s*import%s+['\"]", multi_line = false },
+		{ pattern = "^%s*import%s*{", multi_line = true },
+		{ pattern = "^%s*import%s*%*", multi_line = true },
+		{ pattern = "^%s*export%s+{.+}%s+from%s+['\"]", multi_line = true },
+		{ pattern = "^%s*const%s+%w+%s*=%s*require%(['\"]", multi_line = false },
+		{ pattern = "^%s*let%s+%w+%s*=%s*require%(['\"]", multi_line = false },
+		{ pattern = "^%s*var%s+%w+%s*=%s*require%(['\"]", multi_line = false },
+	},
+	-- Python
+	python = {
+		{ pattern = "^%s*import%s+%w", multi_line = false },
+		{ pattern = "^%s*from%s+[%w%.]+%s+import%s+", multi_line = true },
+	},
+	-- Lua
+	lua = {
+		{ pattern = "^%s*local%s+%w+%s*=%s*require%s*%(?['\"]", multi_line = false },
+		{ pattern = "^%s*require%s*%(?['\"]", multi_line = false },
+	},
+	-- Go
+	go = {
+		{ pattern = "^%s*import%s+%(?", multi_line = true },
+	},
+	-- Rust
+	rust = {
+		{ pattern = "^%s*use%s+", multi_line = true },
+		{ pattern = "^%s*extern%s+crate%s+", multi_line = false },
+	},
+	-- C/C++
+	c = {
+		{ pattern = "^%s*#include%s*[<\"]", multi_line = false },
+	},
+	-- Java/Kotlin
+	java = {
+		{ pattern = "^%s*import%s+", multi_line = false },
+	},
+	-- Ruby
+	ruby = {
+		{ pattern = "^%s*require%s+['\"]", multi_line = false },
+		{ pattern = "^%s*require_relative%s+['\"]", multi_line = false },
+	},
+	-- PHP
+	php = {
+		{ pattern = "^%s*use%s+", multi_line = false },
+		{ pattern = "^%s*require%s+['\"]", multi_line = false },
+		{ pattern = "^%s*require_once%s+['\"]", multi_line = false },
+		{ pattern = "^%s*include%s+['\"]", multi_line = false },
+		{ pattern = "^%s*include_once%s+['\"]", multi_line = false },
+	},
+}
+
+-- Alias common extensions to language configs
+M.import_patterns.ts = M.import_patterns.javascript
+M.import_patterns.tsx = M.import_patterns.javascript
+M.import_patterns.jsx = M.import_patterns.javascript
+M.import_patterns.mjs = M.import_patterns.javascript
+M.import_patterns.cjs = M.import_patterns.javascript
+M.import_patterns.py = M.import_patterns.python
+M.import_patterns.cpp = M.import_patterns.c
+M.import_patterns.hpp = M.import_patterns.c
+M.import_patterns.h = M.import_patterns.c
+M.import_patterns.kt = M.import_patterns.java
+M.import_patterns.rs = M.import_patterns.rust
+M.import_patterns.rb = M.import_patterns.ruby
+
+--- Language-specific comment patterns
+M.comment_patterns = {
+	lua = { "^%-%-" },
+	python = { "^#" },
+	javascript = { "^//", "^/%*", "^%*" },
+	typescript = { "^//", "^/%*", "^%*" },
+	go = { "^//", "^/%*", "^%*" },
+	rust = { "^//", "^/%*", "^%*" },
+	c = { "^//", "^/%*", "^%*", "^#" },
+	java = { "^//", "^/%*", "^%*" },
+	ruby = { "^#" },
+	php = { "^//", "^/%*", "^%*", "^#" },
+}
+
+return M
--- a/lua/codetyper/params/agents/linter.lua
+++ b/lua/codetyper/params/agents/linter.lua
@@ -0,0 +1,15 @@
+---@mod codetyper.params.agents.linter Linter configuration
+local M = {}
+
+M.config = {
+	-- Auto-save file after code injection
+	auto_save = true,
+	-- Delay in ms to wait for LSP diagnostics to update
+	diagnostic_delay_ms = 500,
+	-- Severity levels to check (1=Error, 2=Warning, 3=Info, 4=Hint)
+	min_severity = vim.diagnostic.severity.WARN,
+	-- Auto-offer to fix lint errors
+	auto_offer_fix = true,
+}
+
+return M
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Carlos Gutierrez	258b29f5f0	Fix: correct import path for preferences module	2026-01-16 12:04:09 -05:00
Carlos Gutierrez	6a69a524ea	Refactor: standardize 'agent' -> 'agents' for params and prompts	2026-01-16 12:01:42 -05:00
Carlos Gutierrez	10c1de8843	Refactor: Restructure project into core, features, adapters, and config modules	2026-01-16 11:52:46 -05:00
Carlos Gutierrez	4fb52596e3	Refactoring code	2026-01-16 11:33:11 -05:00
Carlos Gutierrez	9dfb52ac8d	Refactoring code	2026-01-16 10:45:34 -05:00
Carlos Gutierrez	c9be0cf804	Fixing build	2026-01-16 09:44:17 -05:00
Carlos Gutierrez	60577f8951	feat: add conflict resolution, linter validation, and SEARCH/REPLACE system - Add git-style conflict resolution with visual diff highlighting - Add buffer-local keymaps: co/ct/cb/cn for conflict resolution - Add floating menu with auto-show after code injection - Add linter validation that auto-checks LSP diagnostics after accepting code - Add SEARCH/REPLACE block parsing with fuzzy matching - Add new commands: CoderConflictMenu, CoderLintCheck, CoderLintFix - Update README with complete keymaps reference and issue reporting guide - Update CHANGELOG and llms.txt with full documentation - Clean up code comments and documentation Co-Authored-By: Claude <noreply@anthropic.com>	2026-01-16 09:00:35 -05:00
Carlos Gutierrez	f5df1a9ac0	Adding more features	2026-01-15 20:58:56 -05:00
Carlos Gutierrez	84c8bcf92c	Adding autocomplete and copilot suggestions	2026-01-14 21:43:56 -05:00
Carlos Gutierrez	5493a5ec38	test: add unit tests for preferences module - Test default values and loading preferences - Test saving and persistence to .coder/preferences.json - Test get/set individual preference values - Test is_auto_process_enabled and has_asked_auto_process - Test toggle_auto_process behavior - Test cache management (clear_cache) - Handle invalid JSON gracefully Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-13 23:53:21 -05:00
Carlos Gutierrez	c3da2901c9	feat: add user preference system for auto/manual tag processing - Add preferences.lua module for managing per-project preferences - Stores preferences in .coder/preferences.json - Shows floating dialog to ask user on first /@ @/ tag - Supports toggle between auto/manual modes - Update autocmds.lua with preference-aware wrapper functions - check_for_closed_prompt_with_preference() - check_all_prompts_with_preference() - Only auto-process when user chose automatic mode - Add CoderAutoToggle and CoderAutoSet commands - Toggle between automatic and manual modes - Set mode directly with :CoderAutoSet auto\|manual - Fix completion.lua to work in directories outside project - Use current file's directory as base when editing files outside cwd (e.g., ~/.config/* files) - Search in both current dir and cwd for completions Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-13 23:51:17 -05:00
Carlos Gutierrez	46672f6f87	feat: add function completion, apply delay, and VimLeavePre cleanup Major improvements to the event-driven prompt processing system: Function Completion: - Override intent to "complete" when prompt is inside function/method scope - Use Tree-sitter to detect enclosing scope and replace entire function - Special LLM prompt instructs to complete function body without duplicating - Patch apply uses "replace" strategy for scope range instead of appending Apply Delay: - Add `apply_delay_ms` config option (default 5000ms) for code review time - Log "Code ready. Applying in X seconds..." before applying patches - Configurable wait time before removing tags and injecting code VimLeavePre Cleanup: - Logs panel and queue windows close automatically on Neovim exit - Context modal closes on VimLeavePre - Scheduler stops timer and cleans up augroup on exit - Handle QuitPre for :qa, :wqa commands - Force close with buffer deletion for robust cleanup Response Cleaning: - Remove LLM special tokens (deepseek, llama markers) - Add blank line spacing before appended code - Log full raw LLM response in logs panel for debugging Documentation: - Add required dependencies (plenary.nvim, nvim-treesitter) - Add optional dependencies (nvim-treesitter-textobjects, nui.nvim) - Document all intent types including "complete" - Add Logs Panel section with features and keymaps - Update lazy.nvim example with dependencies Tests: - Add tests for patch create_from_event with different strategies - Fix assert.is_true to assert.is_truthy for string.match Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-13 23:40:13 -05:00
Carlos Gutierrez	0600144768	fixing the issues on the tags	2026-01-13 23:16:27 -05:00