lsp: refactor dispatch to handler map; split handlers into feature files (completion, codeaction, init, document); decompose completion logic into small helpers; update review checklist

16 files changed, 1472 insertions, 1247 deletions

diff --git a/internal/lsp/chat_trigger_suppression_test.go b/internal/lsp/chat_trigger_suppression_test.go
index 197fbfb..55a5245 100644
--- a/internal/lsp/chat_trigger_suppression_test.go
+++ b/internal/lsp/chat_trigger_suppression_test.go
@@ -4,14 +4,17 @@ import "testing"
 
 // Ensure completion is suppressed when a chat trigger is at EOL (?>,!>,:>,;>)
 func TestCompletionSuppressedOnChatTriggerEOL(t *testing.T) {
-    s := &Server{ maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string) }
-    s.llmClient = &countingLLM{}
-    tests := []string{"What now?>", "Explain!>", "Refactor:>", "note ;>"}
-    for i, line := range tests {
-        p := CompletionParams{ Position: Position{ Line: 0, Character: len(line) }, TextDocument: TextDocumentIdentifier{URI: "file://chat-suppr.go"} }
-        items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
-        if !ok { t.Fatalf("case %d: expected ok=true", i) }
-        if len(items) != 0 { t.Fatalf("case %d: expected no completion items for EOL chat trigger", i) }
-    }
+	s := &Server{maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string)}
+	s.llmClient = &countingLLM{}
+	tests := []string{"What now?>", "Explain!>", "Refactor:>", "note ;>"}
+	for i, line := range tests {
+		p := CompletionParams{Position: Position{Line: 0, Character: len(line)}, TextDocument: TextDocumentIdentifier{URI: "file://chat-suppr.go"}}
+		items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
+		if !ok {
+			t.Fatalf("case %d: expected ok=true", i)
+		}
+		if len(items) != 0 {
+			t.Fatalf("case %d: expected no completion items for EOL chat trigger", i)
+		}
+	}
 }
-
diff --git a/internal/lsp/codeaction_test.go b/internal/lsp/codeaction_test.go
index 59b16d8..f5abbbf 100644
--- a/internal/lsp/codeaction_test.go
+++ b/internal/lsp/codeaction_test.go
@@ -1,71 +1,100 @@
 package lsp
 
 import (
-    "context"
-    "encoding/json"
-    "testing"
-    "hexai/internal/llm"
+	"context"
+	"encoding/json"
+	"hexai/internal/llm"
+	"testing"
 )
 
-type fakeLLM struct{ resp string; err error }
+type fakeLLM struct {
+	resp string
+	err  error
+}
 
 func (f fakeLLM) Chat(_ context.Context, _ []llm.Message, _ ...llm.RequestOption) (string, error) {
-    return f.resp, f.err
+	return f.resp, f.err
 }
-func (f fakeLLM) Name() string { return "fake" }
+func (f fakeLLM) Name() string         { return "fake" }
 func (f fakeLLM) DefaultModel() string { return "fake-model" }
 
 func TestBuildRewriteCodeAction_LazyAndResolves(t *testing.T) {
-    s := newTestServer()
-    s.llmClient = fakeLLM{resp: "REWRITTEN"}
-    p := CodeActionParams{TextDocument: TextDocumentIdentifier{URI: "file:///t.go"}, Range: Range{Start: Position{Line: 1, Character: 2}, End: Position{Line: 3, Character: 4}}}
-    sel := ";rewrite;\nold code"
-    ca := s.buildRewriteCodeAction(p, sel)
-    if ca == nil { t.Fatalf("expected code action") }
-    // Should be lazy (no edit yet)
-    if ca.Edit != nil { t.Fatalf("expected nil Edit before resolve") }
-    if len(ca.Data) == 0 { t.Fatalf("expected data payload for lazy resolve") }
-    // Resolve now
-    resolved, ok := s.resolveCodeAction(*ca)
-    if !ok || resolved.Edit == nil { t.Fatalf("expected resolve to produce edit") }
-    edits := resolved.Edit.Changes[p.TextDocument.URI]
-    if len(edits) != 1 { t.Fatalf("expected 1 edit, got %d", len(edits)) }
-    if edits[0].Range != p.Range { t.Fatalf("edit range mismatch: got %+v want %+v", edits[0].Range, p.Range) }
-    if edits[0].NewText == "" { t.Fatalf("expected non-empty replacement text") }
+	s := newTestServer()
+	s.llmClient = fakeLLM{resp: "REWRITTEN"}
+	p := CodeActionParams{TextDocument: TextDocumentIdentifier{URI: "file:///t.go"}, Range: Range{Start: Position{Line: 1, Character: 2}, End: Position{Line: 3, Character: 4}}}
+	sel := ";rewrite;\nold code"
+	ca := s.buildRewriteCodeAction(p, sel)
+	if ca == nil {
+		t.Fatalf("expected code action")
+	}
+	// Should be lazy (no edit yet)
+	if ca.Edit != nil {
+		t.Fatalf("expected nil Edit before resolve")
+	}
+	if len(ca.Data) == 0 {
+		t.Fatalf("expected data payload for lazy resolve")
+	}
+	// Resolve now
+	resolved, ok := s.resolveCodeAction(*ca)
+	if !ok || resolved.Edit == nil {
+		t.Fatalf("expected resolve to produce edit")
+	}
+	edits := resolved.Edit.Changes[p.TextDocument.URI]
+	if len(edits) != 1 {
+		t.Fatalf("expected 1 edit, got %d", len(edits))
+	}
+	if edits[0].Range != p.Range {
+		t.Fatalf("edit range mismatch: got %+v want %+v", edits[0].Range, p.Range)
+	}
+	if edits[0].NewText == "" {
+		t.Fatalf("expected non-empty replacement text")
+	}
 }
 
 func TestBuildRewriteCodeAction_NoInstruction(t *testing.T) {
-    s := newTestServer()
-    s.llmClient = fakeLLM{resp: "IGNORED"}
-    p := CodeActionParams{TextDocument: TextDocumentIdentifier{URI: "file:///t.go"}, Range: Range{}}
-    sel := "no instruction here"
-    if ca := s.buildRewriteCodeAction(p, sel); ca != nil { t.Fatalf("expected nil action when no instruction present") }
+	s := newTestServer()
+	s.llmClient = fakeLLM{resp: "IGNORED"}
+	p := CodeActionParams{TextDocument: TextDocumentIdentifier{URI: "file:///t.go"}, Range: Range{}}
+	sel := "no instruction here"
+	if ca := s.buildRewriteCodeAction(p, sel); ca != nil {
+		t.Fatalf("expected nil action when no instruction present")
+	}
 }
 
 func TestBuildDiagnosticsCodeAction_LazyAndResolves(t *testing.T) {
-    s := newTestServer()
-    s.llmClient = fakeLLM{resp: "FIXED"}
-    p := CodeActionParams{TextDocument: TextDocumentIdentifier{URI: "file:///t.go"}, Range: Range{Start: Position{Line: 10}, End: Position{Line: 12, Character: 5}}}
-    ctx := CodeActionContext{Diagnostics: []Diagnostic{
-        {Range: Range{Start: Position{Line: 11}, End: Position{Line: 11, Character: 10}}, Message: "inside"},
-        {Range: Range{Start: Position{Line: 2}, End: Position{Line: 3}}, Message: "outside"},
-    }}
-    raw, _ := json.Marshal(ctx)
-    p.Context = json.RawMessage(raw)
-    sel := "some selected code"
-    ca := s.buildDiagnosticsCodeAction(p, sel)
-    if ca == nil { t.Fatalf("expected diagnostics code action") }
-    if ca.Edit != nil { t.Fatalf("expected lazy action without edit") }
-    if len(ca.Data) == 0 { t.Fatalf("expected data payload for lazy diagnostics action") }
-    resolved, ok := s.resolveCodeAction(*ca)
-    if !ok || resolved.Edit == nil { t.Fatalf("expected resolve to produce edit") }
+	s := newTestServer()
+	s.llmClient = fakeLLM{resp: "FIXED"}
+	p := CodeActionParams{TextDocument: TextDocumentIdentifier{URI: "file:///t.go"}, Range: Range{Start: Position{Line: 10}, End: Position{Line: 12, Character: 5}}}
+	ctx := CodeActionContext{Diagnostics: []Diagnostic{
+		{Range: Range{Start: Position{Line: 11}, End: Position{Line: 11, Character: 10}}, Message: "inside"},
+		{Range: Range{Start: Position{Line: 2}, End: Position{Line: 3}}, Message: "outside"},
+	}}
+	raw, _ := json.Marshal(ctx)
+	p.Context = json.RawMessage(raw)
+	sel := "some selected code"
+	ca := s.buildDiagnosticsCodeAction(p, sel)
+	if ca == nil {
+		t.Fatalf("expected diagnostics code action")
+	}
+	if ca.Edit != nil {
+		t.Fatalf("expected lazy action without edit")
+	}
+	if len(ca.Data) == 0 {
+		t.Fatalf("expected data payload for lazy diagnostics action")
+	}
+	resolved, ok := s.resolveCodeAction(*ca)
+	if !ok || resolved.Edit == nil {
+		t.Fatalf("expected resolve to produce edit")
+	}
 }
 
 func TestBuildDiagnosticsCodeAction_NoDiagnostics(t *testing.T) {
-    s := newTestServer()
-    s.llmClient = fakeLLM{resp: "FIXED"}
-    p := CodeActionParams{TextDocument: TextDocumentIdentifier{URI: "file:///t.go"}, Range: Range{}}
-    // empty context
-    p.Context = json.RawMessage(nil)
-    if ca := s.buildDiagnosticsCodeAction(p, "sel"); ca != nil { t.Fatalf("expected nil action when no diagnostics") }
+	s := newTestServer()
+	s.llmClient = fakeLLM{resp: "FIXED"}
+	p := CodeActionParams{TextDocument: TextDocumentIdentifier{URI: "file:///t.go"}, Range: Range{}}
+	// empty context
+	p.Context = json.RawMessage(nil)
+	if ca := s.buildDiagnosticsCodeAction(p, "sel"); ca != nil {
+		t.Fatalf("expected nil action when no diagnostics")
+	}
 }
diff --git a/internal/lsp/completion_cache_test.go b/internal/lsp/completion_cache_test.go
index a350281..779f89d 100644
--- a/internal/lsp/completion_cache_test.go
+++ b/internal/lsp/completion_cache_test.go
@@ -1,42 +1,42 @@
 package lsp
 
 import (
-    "bytes"
-    "log"
-    "strings"
-    "testing"
+	"bytes"
+	"log"
+	"strings"
+	"testing"
 
-    "hexai/internal/logging"
+	"hexai/internal/logging"
 )
 
 func TestCompletionCache_IgnoresWhitespaceBeforeCursor(t *testing.T) {
-    var buf bytes.Buffer
-    logger := log.New(&buf, "", 0)
-    s := NewServer(bytes.NewBuffer(nil), &buf, logger, ServerOptions{})
-    logging.Bind(logger)
-    s.triggerChars = []string{" ", "."}
-    fake := &countingLLM{}
-    s.llmClient = fake
+	var buf bytes.Buffer
+	logger := log.New(&buf, "", 0)
+	s := NewServer(bytes.NewBuffer(nil), &buf, logger, ServerOptions{})
+	logging.Bind(logger)
+	s.triggerChars = []string{" ", "."}
+	fake := &countingLLM{}
+	s.llmClient = fake
 
-    // First request with trailing spaces before cursor
-    line := "foo   "
-    p := CompletionParams{ Position: Position{ Line: 0, Character: len(line) }, TextDocument: TextDocumentIdentifier{URI: "file://x.go"} }
-    items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
-    if !ok || len(items) == 0 || fake.calls != 1 {
-        t.Fatalf("expected first call to invoke LLM; ok=%v len=%d calls=%d", ok, len(items), fake.calls)
-    }
+	// First request with trailing spaces before cursor
+	line := "foo   "
+	p := CompletionParams{Position: Position{Line: 0, Character: len(line)}, TextDocument: TextDocumentIdentifier{URI: "file://x.go"}}
+	items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
+	if !ok || len(items) == 0 || fake.calls != 1 {
+		t.Fatalf("expected first call to invoke LLM; ok=%v len=%d calls=%d", ok, len(items), fake.calls)
+	}
 
-    // Same logical context but with a different amount of trailing whitespace
-    line2 := "foo             "
-    p2 := CompletionParams{ Position: Position{ Line: 0, Character: len(line2) }, TextDocument: TextDocumentIdentifier{URI: "file://x.go"} }
-    items2, ok2 := s.tryLLMCompletion(p2, "", line2, "", "", "", false, "")
-    if !ok2 || len(items2) == 0 {
-        t.Fatalf("expected cache hit to still return items")
-    }
-    if fake.calls != 1 {
-        t.Fatalf("expected cache hit to avoid LLM call; calls=%d", fake.calls)
-    }
-    if !strings.Contains(buf.String(), "completion cache hit") {
-        t.Fatalf("expected log to contain cache hit message, got: %s", buf.String())
-    }
+	// Same logical context but with a different amount of trailing whitespace
+	line2 := "foo             "
+	p2 := CompletionParams{Position: Position{Line: 0, Character: len(line2)}, TextDocument: TextDocumentIdentifier{URI: "file://x.go"}}
+	items2, ok2 := s.tryLLMCompletion(p2, "", line2, "", "", "", false, "")
+	if !ok2 || len(items2) == 0 {
+		t.Fatalf("expected cache hit to still return items")
+	}
+	if fake.calls != 1 {
+		t.Fatalf("expected cache hit to avoid LLM call; calls=%d", fake.calls)
+	}
+	if !strings.Contains(buf.String(), "completion cache hit") {
+		t.Fatalf("expected log to contain cache hit message, got: %s", buf.String())
+	}
 }
diff --git a/internal/lsp/completion_codex_path_test.go b/internal/lsp/completion_codex_path_test.go
index 65ab75a..c8ce912 100644
--- a/internal/lsp/completion_codex_path_test.go
+++ b/internal/lsp/completion_codex_path_test.go
@@ -1,58 +1,78 @@
 package lsp
 
 import (
-    "context"
-    "errors"
-    "testing"
+	"context"
+	"errors"
+	"testing"
 
-    "hexai/internal/llm"
+	"hexai/internal/llm"
 )
 
 // fakeCodeLLM implements both llm.Client and llm.CodeCompleter.
-type fakeCodeLLM struct{
-    codeCalls int
-    chatCalls int
-    result    string
-    codeErr   error
+type fakeCodeLLM struct {
+	codeCalls int
+	chatCalls int
+	result    string
+	codeErr   error
 }
 
 func (f *fakeCodeLLM) CodeCompletion(_ context.Context, _ string, _ string, n int, _ string, _ float64) ([]string, error) {
-    f.codeCalls++
-    if f.codeErr != nil { return nil, f.codeErr }
-    if n <= 0 { n = 1 }
-    out := make([]string, n)
-    for i := 0; i < n; i++ { out[i] = f.result }
-    return out, nil
+	f.codeCalls++
+	if f.codeErr != nil {
+		return nil, f.codeErr
+	}
+	if n <= 0 {
+		n = 1
+	}
+	out := make([]string, n)
+	for i := 0; i < n; i++ {
+		out[i] = f.result
+	}
+	return out, nil
 }
 
 func (f *fakeCodeLLM) Chat(_ context.Context, _ []llm.Message, _ ...llm.RequestOption) (string, error) {
-    f.chatCalls++
-    return "chat", nil
+	f.chatCalls++
+	return "chat", nil
 }
 func (f *fakeCodeLLM) Name() string         { return "fake" }
 func (f *fakeCodeLLM) DefaultModel() string { return "m" }
 
 func TestTryLLMCompletion_PrefersCodeCompleterOverChat(t *testing.T) {
-    s := &Server{ maxTokens: 32, triggerChars: []string{"."}, compCache: make(map[string]string) }
-    fake := &fakeCodeLLM{ result: "DoThing()" }
-    s.llmClient = fake
-    line := "obj."
-    p := CompletionParams{ Position: Position{ Line: 0, Character: len(line) }, TextDocument: TextDocumentIdentifier{URI: "file://x.go"} }
-    items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
-    if !ok || len(items) == 0 { t.Fatalf("expected completion items via CodeCompleter path") }
-    if fake.codeCalls == 0 { t.Fatalf("expected CodeCompletion to be called") }
-    if fake.chatCalls != 0 { t.Fatalf("did not expect Chat fallback when CodeCompletion succeeds") }
+	s := &Server{maxTokens: 32, triggerChars: []string{"."}, compCache: make(map[string]string)}
+	fake := &fakeCodeLLM{result: "DoThing()"}
+	s.llmClient = fake
+	line := "obj."
+	p := CompletionParams{Position: Position{Line: 0, Character: len(line)}, TextDocument: TextDocumentIdentifier{URI: "file://x.go"}}
+	items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
+	if !ok || len(items) == 0 {
+		t.Fatalf("expected completion items via CodeCompleter path")
+	}
+	if fake.codeCalls == 0 {
+		t.Fatalf("expected CodeCompletion to be called")
+	}
+	if fake.chatCalls != 0 {
+		t.Fatalf("did not expect Chat fallback when CodeCompletion succeeds")
+	}
 }
 
 func TestTryLLMCompletion_FallsBackToChatOnCodeCompleterError(t *testing.T) {
-    s := &Server{ maxTokens: 32, triggerChars: []string{"."}, compCache: make(map[string]string) }
-    fake := &fakeCodeLLM{ result: "DoThing()", codeErr: errors.New("boom") }
-    s.llmClient = fake
-    line := "obj."
-    p := CompletionParams{ Position: Position{ Line: 0, Character: len(line) }, TextDocument: TextDocumentIdentifier{URI: "file://y.go"} }
-    items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
-    if !ok { t.Fatalf("expected ok=true even on fallback path") }
-    if len(items) == 0 { t.Fatalf("expected some items from Chat fallback") }
-    if fake.codeCalls == 0 { t.Fatalf("expected CodeCompletion to be attempted first") }
-    if fake.chatCalls == 0 { t.Fatalf("expected Chat fallback to be called when CodeCompletion errors") }
+	s := &Server{maxTokens: 32, triggerChars: []string{"."}, compCache: make(map[string]string)}
+	fake := &fakeCodeLLM{result: "DoThing()", codeErr: errors.New("boom")}
+	s.llmClient = fake
+	line := "obj."
+	p := CompletionParams{Position: Position{Line: 0, Character: len(line)}, TextDocument: TextDocumentIdentifier{URI: "file://y.go"}}
+	items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
+	if !ok {
+		t.Fatalf("expected ok=true even on fallback path")
+	}
+	if len(items) == 0 {
+		t.Fatalf("expected some items from Chat fallback")
+	}
+	if fake.codeCalls == 0 {
+		t.Fatalf("expected CodeCompletion to be attempted first")
+	}
+	if fake.chatCalls == 0 {
+		t.Fatalf("expected Chat fallback to be called when CodeCompletion errors")
+	}
 }
diff --git a/internal/lsp/completion_prefix_strip_test.go b/internal/lsp/completion_prefix_strip_test.go
index 9953714..64cca49 100644
--- a/internal/lsp/completion_prefix_strip_test.go
+++ b/internal/lsp/completion_prefix_strip_test.go
@@ -1,120 +1,158 @@
 package lsp
 
 import (
-    "encoding/json"
-    "testing"
+	"encoding/json"
+	"testing"
 )
 
 func TestStripDuplicateGeneralPrefix_ExactOverlap(t *testing.T) {
-    prefix := "func New "
-    sugg := "func New() *CustData"
-    got := stripDuplicateGeneralPrefix(prefix, sugg)
-    // We expect the already typed prefix to be removed from the suggestion.
-    if got == sugg {
-        t.Fatalf("expected duplicate prefix to be stripped; got unchanged: %q", got)
-    }
-    if got != "() *CustData" {
-        t.Fatalf("got %q want %q", got, "() *CustData")
-    }
+	prefix := "func New "
+	sugg := "func New() *CustData"
+	got := stripDuplicateGeneralPrefix(prefix, sugg)
+	// We expect the already typed prefix to be removed from the suggestion.
+	if got == sugg {
+		t.Fatalf("expected duplicate prefix to be stripped; got unchanged: %q", got)
+	}
+	if got != "() *CustData" {
+		t.Fatalf("got %q want %q", got, "() *CustData")
+	}
 }
 
 func TestStripDuplicateGeneralPrefix_TokenBoundarySuffix(t *testing.T) {
-    prefix := "db."
-    sugg := "db.Query()"
-    got := stripDuplicateGeneralPrefix(prefix, sugg)
-    if got != "Query()" {
-        t.Fatalf("got %q want %q", got, "Query()")
-    }
+	prefix := "db."
+	sugg := "db.Query()"
+	got := stripDuplicateGeneralPrefix(prefix, sugg)
+	if got != "Query()" {
+		t.Fatalf("got %q want %q", got, "Query()")
+	}
 }
 
 func TestStripDuplicateAssignmentPrefix_AssignAndWalrus(t *testing.T) {
-    // walrus
-    if out := stripDuplicateAssignmentPrefix("name := ", "name := compute()" ); out != "compute()" {
-        t.Fatalf(":= expected compute(), got %q", out)
-    }
-    // equals
-    if out := stripDuplicateAssignmentPrefix("x = ", "x = y+1" ); out != "y+1" {
-        t.Fatalf("= expected y+1, got %q", out)
-    }
+	// walrus
+	if out := stripDuplicateAssignmentPrefix("name := ", "name := compute()"); out != "compute()" {
+		t.Fatalf(":= expected compute(), got %q", out)
+	}
+	// equals
+	if out := stripDuplicateAssignmentPrefix("x = ", "x = y+1"); out != "y+1" {
+		t.Fatalf("= expected y+1, got %q", out)
+	}
 }
 
 func TestTryLLMCompletion_ManualInvokeAfterWhitespace_Allows(t *testing.T) {
-    s := &Server{ maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string) }
-    s.llmClient = fakeLLM{resp: "() *CustData"}
-    line := "func fib(i int) " // cursor after space
-    p := CompletionParams{ Position: Position{ Line: 0, Character: len(line) }, TextDocument: TextDocumentIdentifier{URI: "file://x.go"} }
-    // Simulate manual user invocation (TriggerKind=1)
-    p.Context = json.RawMessage([]byte(`{"triggerKind":1}`))
-    items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
-    if !ok { t.Fatalf("expected ok=true for manual invoke after whitespace") }
-    if len(items) == 0 { t.Fatalf("expected at least one completion item") }
+	s := &Server{maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string)}
+	s.llmClient = fakeLLM{resp: "() *CustData"}
+	line := "func fib(i int) " // cursor after space
+	p := CompletionParams{Position: Position{Line: 0, Character: len(line)}, TextDocument: TextDocumentIdentifier{URI: "file://x.go"}}
+	// Simulate manual user invocation (TriggerKind=1)
+	p.Context = json.RawMessage([]byte(`{"triggerKind":1}`))
+	items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
+	if !ok {
+		t.Fatalf("expected ok=true for manual invoke after whitespace")
+	}
+	if len(items) == 0 {
+		t.Fatalf("expected at least one completion item")
+	}
 }
 
 func TestTryLLMCompletion_InlineSemicolonPromptAlwaysTriggers(t *testing.T) {
-    s := &Server{ maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string) }
-    s.llmClient = fakeLLM{resp: "replacement"}
-    line := "prefix ;do something; suffix"
-    // No trigger char immediately before cursor; place cursor at end
-    p := CompletionParams{ Position: Position{ Line: 0, Character: len(line) }, TextDocument: TextDocumentIdentifier{URI: "file://inline.go"} }
-    items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
-    if !ok || len(items) == 0 { t.Fatalf("expected completion to trigger on inline ;text; prompt") }
+	s := &Server{maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string)}
+	s.llmClient = fakeLLM{resp: "replacement"}
+	line := "prefix ;do something; suffix"
+	// No trigger char immediately before cursor; place cursor at end
+	p := CompletionParams{Position: Position{Line: 0, Character: len(line)}, TextDocument: TextDocumentIdentifier{URI: "file://inline.go"}}
+	items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
+	if !ok || len(items) == 0 {
+		t.Fatalf("expected completion to trigger on inline ;text; prompt")
+	}
 }
 
 func TestTryLLMCompletion_DoubleSemicolonEmpty_DoesNotAutoTrigger(t *testing.T) {
-    s := &Server{ maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string) }
-    fake := &countingLLM{}
-    s.llmClient = fake
-    line := ";;   " // empty content after ';;' should not force-trigger
-    p := CompletionParams{ Position: Position{ Line: 0, Character: len(line) }, TextDocument: TextDocumentIdentifier{URI: "file://empty-inline.go"} }
-    items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
-    if !ok { t.Fatalf("expected ok=true for non-trigger path") }
-    if len(items) != 0 { t.Fatalf("expected no items when inline ';;' is empty") }
-    if fake.calls != 0 { t.Fatalf("LLM should not be called; calls=%d", fake.calls) }
+	s := &Server{maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string)}
+	fake := &countingLLM{}
+	s.llmClient = fake
+	line := ";;   " // empty content after ';;' should not force-trigger
+	p := CompletionParams{Position: Position{Line: 0, Character: len(line)}, TextDocument: TextDocumentIdentifier{URI: "file://empty-inline.go"}}
+	items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
+	if !ok {
+		t.Fatalf("expected ok=true for non-trigger path")
+	}
+	if len(items) != 0 {
+		t.Fatalf("expected no items when inline ';;' is empty")
+	}
+	if fake.calls != 0 {
+		t.Fatalf("LLM should not be called; calls=%d", fake.calls)
+	}
 }
 
 func TestHasDoubleSemicolonTrigger_Variants(t *testing.T) {
-    if hasDoubleSemicolonTrigger(";;") { t.Fatalf("bare ';;' should not trigger") }
-    if hasDoubleSemicolonTrigger(";; ;") { t.Fatalf("';;' followed by space should not trigger") }
-    if hasDoubleSemicolonTrigger(";;;") { t.Fatalf("';;;' should not trigger (no content)") }
-    if !hasDoubleSemicolonTrigger(";;x;") { t.Fatalf("expected trigger for ';;x;' pattern") }
+	if hasDoubleSemicolonTrigger(";;") {
+		t.Fatalf("bare ';;' should not trigger")
+	}
+	if hasDoubleSemicolonTrigger(";; ;") {
+		t.Fatalf("';;' followed by space should not trigger")
+	}
+	if hasDoubleSemicolonTrigger(";;;") {
+		t.Fatalf("';;;' should not trigger (no content)")
+	}
+	if !hasDoubleSemicolonTrigger(";;x;") {
+		t.Fatalf("expected trigger for ';;x;' pattern")
+	}
 }
 
 func TestBareDoubleSemicolonPreventsAutoTriggerEvenWithOtherTriggers(t *testing.T) {
-    s := &Server{ maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string) }
-    fake := &countingLLM{}
-    s.llmClient = fake
-    // Place a '.' earlier but also include bare ';;' at end; should not auto-trigger
-    line := "obj. call ;;"
-    p := CompletionParams{ Position: Position{ Line: 0, Character: len(line) }, TextDocument: TextDocumentIdentifier{URI: "file://bare-ds.go"} }
-    items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
-    if !ok { t.Fatalf("expected ok=true (handled), but not auto-triggering") }
-    if len(items) != 0 { t.Fatalf("expected no items due to bare ';;'") }
-    if fake.calls != 0 { t.Fatalf("LLM should not be called; calls=%d", fake.calls) }
+	s := &Server{maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string)}
+	fake := &countingLLM{}
+	s.llmClient = fake
+	// Place a '.' earlier but also include bare ';;' at end; should not auto-trigger
+	line := "obj. call ;;"
+	p := CompletionParams{Position: Position{Line: 0, Character: len(line)}, TextDocument: TextDocumentIdentifier{URI: "file://bare-ds.go"}}
+	items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
+	if !ok {
+		t.Fatalf("expected ok=true (handled), but not auto-triggering")
+	}
+	if len(items) != 0 {
+		t.Fatalf("expected no items due to bare ';;'")
+	}
+	if fake.calls != 0 {
+		t.Fatalf("LLM should not be called; calls=%d", fake.calls)
+	}
 }
 
 func TestBareDoubleSemicolonOnNextLine_PreventsAutoTrigger(t *testing.T) {
-    s := &Server{ maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string) }
-    fake := &countingLLM{}
-    s.llmClient = fake
-    current := "expression := flag.String(\"expression\", \"\", \"Expression to evaluate\")"
-    below := ";;"
-    p := CompletionParams{ Position: Position{ Line: 0, Character: len(current) }, TextDocument: TextDocumentIdentifier{URI: "file://nextline.go"} }
-    items, ok := s.tryLLMCompletion(p, "", current, below, "", "", false, "")
-    if !ok { t.Fatalf("expected ok=true handled") }
-    if len(items) != 0 { t.Fatalf("expected no items due to bare ';;' on next line") }
-    if fake.calls != 0 { t.Fatalf("LLM should not be called; calls=%d", fake.calls) }
+	s := &Server{maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string)}
+	fake := &countingLLM{}
+	s.llmClient = fake
+	current := "expression := flag.String(\"expression\", \"\", \"Expression to evaluate\")"
+	below := ";;"
+	p := CompletionParams{Position: Position{Line: 0, Character: len(current)}, TextDocument: TextDocumentIdentifier{URI: "file://nextline.go"}}
+	items, ok := s.tryLLMCompletion(p, "", current, below, "", "", false, "")
+	if !ok {
+		t.Fatalf("expected ok=true handled")
+	}
+	if len(items) != 0 {
+		t.Fatalf("expected no items due to bare ';;' on next line")
+	}
+	if fake.calls != 0 {
+		t.Fatalf("LLM should not be called; calls=%d", fake.calls)
+	}
 }
 
 func TestBareDoubleSemicolonPreventsManualInvoke(t *testing.T) {
-    s := &Server{ maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string) }
-    fake := &countingLLM{}
-    s.llmClient = fake
-    line := ";;"
-    p := CompletionParams{ Position: Position{ Line: 0, Character: len(line) }, TextDocument: TextDocumentIdentifier{URI: "file://bare-ds-manual.go"} }
-    // Simulate manual invoke
-    p.Context = json.RawMessage([]byte(`{"triggerKind":1}`))
-    items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
-    if !ok { t.Fatalf("expected ok=true (handled)") }
-    if len(items) != 0 { t.Fatalf("expected no items for bare ';;' even with manual invoke") }
-    if fake.calls != 0 { t.Fatalf("LLM should not be called; calls=%d", fake.calls) }
+	s := &Server{maxTokens: 32, triggerChars: []string{".", ":", "/", "_"}, compCache: make(map[string]string)}
+	fake := &countingLLM{}
+	s.llmClient = fake
+	line := ";;"
+	p := CompletionParams{Position: Position{Line: 0, Character: len(line)}, TextDocument: TextDocumentIdentifier{URI: "file://bare-ds-manual.go"}}
+	// Simulate manual invoke
+	p.Context = json.RawMessage([]byte(`{"triggerKind":1}`))
+	items, ok := s.tryLLMCompletion(p, "", line, "", "", "", false, "")
+	if !ok {
+		t.Fatalf("expected ok=true (handled)")
+	}
+	if len(items) != 0 {
+		t.Fatalf("expected no items for bare ';;' even with manual invoke")
+	}
+	if fake.calls != 0 {
+		t.Fatalf("LLM should not be called; calls=%d", fake.calls)
+	}
 }
diff --git a/internal/lsp/handlers.go b/internal/lsp/handlers.go
index 332344a..774a94a 100644
--- a/internal/lsp/handlers.go
+++ b/internal/lsp/handlers.go
@@ -3,209 +3,25 @@
 package lsp
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
-	"hexai/internal"
 	"hexai/internal/llm"
 	"hexai/internal/logging"
-	"os"
 	"strings"
 	"time"
 )
 
 func (s *Server) handle(req Request) {
-	switch req.Method {
-	case "initialize":
-		s.handleInitialize(req)
-	case "initialized":
-		s.handleInitialized()
-	case "shutdown":
-		s.handleShutdown(req)
-	case "exit":
-		s.handleExit()
-	case "textDocument/didOpen":
-		s.handleDidOpen(req)
-	case "textDocument/didChange":
-		s.handleDidChange(req)
-	case "textDocument/didClose":
-		s.handleDidClose(req)
-	case "textDocument/completion":
-		s.handleCompletion(req)
-	case "textDocument/codeAction":
-		s.handleCodeAction(req)
-	case "codeAction/resolve":
-		s.handleCodeActionResolve(req)
-	default:
-		if len(req.ID) != 0 {
-			s.reply(req.ID, nil, &RespError{Code: -32601, Message: fmt.Sprintf("method not found: %s", req.Method)})
-		}
-	}
-}
-
-func (s *Server) handleInitialize(req Request) {
-	version := internal.Version
-	if s.llmClient != nil {
-		version = version + " [" + s.llmClient.Name() + ":" + s.llmClient.DefaultModel() + "]"
-	}
-	res := InitializeResult{
-		Capabilities: ServerCapabilities{
-			TextDocumentSync: 1, // 1 = TextDocumentSyncKindFull
-			CompletionProvider: &CompletionOptions{
-				ResolveProvider:   false,
-				TriggerCharacters: s.triggerChars,
-			},
-			CodeActionProvider: CodeActionOptions{ResolveProvider: true},
-		},
-		ServerInfo: &ServerInfo{Name: "hexai", Version: version},
-	}
-	s.reply(req.ID, res, nil)
-}
-
-func (s *Server) handleCodeAction(req Request) {
-	var p CodeActionParams
-	if err := json.Unmarshal(req.Params, &p); err != nil {
-		if len(req.ID) != 0 {
-			s.reply(req.ID, []CodeAction{}, nil)
-		}
-		return
-	}
-	d := s.getDocument(p.TextDocument.URI)
-	if d == nil || len(d.lines) == 0 || s.llmClient == nil {
-		if len(req.ID) != 0 {
-			s.reply(req.ID, []CodeAction{}, nil)
-		}
+	if h, ok := s.handlers[req.Method]; ok {
+		h(req)
 		return
 	}
-	sel := extractRangeText(d, p.Range)
-	if strings.TrimSpace(sel) == "" {
-		if len(req.ID) != 0 {
-			s.reply(req.ID, []CodeAction{}, nil)
-		}
-		return
-	}
-
-	actions := make([]CodeAction, 0, 2)
-	if a := s.buildRewriteCodeAction(p, sel); a != nil {
-		actions = append(actions, *a)
-	}
-	if a := s.buildDiagnosticsCodeAction(p, sel); a != nil {
-		actions = append(actions, *a)
-	}
 	if len(req.ID) != 0 {
-		s.reply(req.ID, actions, nil)
-	}
-}
-
-func (s *Server) buildRewriteCodeAction(p CodeActionParams, sel string) *CodeAction {
-	if instr, cleaned := instructionFromSelection(sel); strings.TrimSpace(instr) != "" {
-		payload := struct {
-			Type        string `json:"type"`
-			URI         string `json:"uri"`
-			Range       Range  `json:"range"`
-			Instruction string `json:"instruction"`
-			Selection   string `json:"selection"`
-		}{Type: "rewrite", URI: p.TextDocument.URI, Range: p.Range, Instruction: instr, Selection: cleaned}
-		raw, _ := json.Marshal(payload)
-		ca := CodeAction{Title: "Hexai: rewrite selection", Kind: "refactor.rewrite", Data: raw}
-		return &ca
-	}
-	return nil
-}
-
-func (s *Server) buildDiagnosticsCodeAction(p CodeActionParams, sel string) *CodeAction {
-	diags := s.diagnosticsInRange(p.Context, p.Range)
-	if len(diags) == 0 {
-		return nil
+		s.reply(req.ID, nil, &RespError{Code: -32601, Message: fmt.Sprintf("method not found: %s", req.Method)})
 	}
-	payload := struct {
-		Type        string       `json:"type"`
-		URI         string       `json:"uri"`
-		Range       Range        `json:"range"`
-		Selection   string       `json:"selection"`
-		Diagnostics []Diagnostic `json:"diagnostics"`
-	}{Type: "diagnostics", URI: p.TextDocument.URI, Range: p.Range, Selection: sel, Diagnostics: diags}
-	raw, _ := json.Marshal(payload)
-	ca := CodeAction{Title: "Hexai: resolve diagnostics", Kind: "quickfix", Data: raw}
-	return &ca
 }
 
-func (s *Server) resolveCodeAction(ca CodeAction) (CodeAction, bool) {
-	if s.llmClient == nil || len(ca.Data) == 0 {
-		return ca, false
-	}
-	var payload struct {
-		Type        string       `json:"type"`
-		URI         string       `json:"uri"`
-		Range       Range        `json:"range"`
-		Instruction string       `json:"instruction,omitempty"`
-		Selection   string       `json:"selection"`
-		Diagnostics []Diagnostic `json:"diagnostics,omitempty"`
-	}
-	if err := json.Unmarshal(ca.Data, &payload); err != nil {
-		return ca, false
-	}
-	switch payload.Type {
-	case "rewrite":
-		sys := "You are a precise code refactoring engine. Rewrite the given code strictly according to the instruction. Return only the updated code with no prose or backticks. Preserve formatting where reasonable."
-		user := fmt.Sprintf("Instruction: %s\n\nSelected code to transform:\n%s", payload.Instruction, payload.Selection)
-		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-		defer cancel()
-		messages := []llm.Message{{Role: "system", Content: sys}, {Role: "user", Content: user}}
-		opts := s.llmRequestOpts()
-		if text, err := s.llmClient.Chat(ctx, messages, opts...); err == nil {
-			if out := stripCodeFences(strings.TrimSpace(text)); out != "" {
-				edit := WorkspaceEdit{Changes: map[string][]TextEdit{payload.URI: {{Range: payload.Range, NewText: out}}}}
-				ca.Edit = &edit
-				return ca, true
-			}
-		} else {
-			logging.Logf("lsp ", "codeAction rewrite llm err