feat: opencode zen adapter + first-run config generation, fix stats/stream bugs

- adapters/opencode.lua: opencode.ai zen free pool adapter — sends the
  opencode client User-Agent (zen fingerprints clients by UA; non-official
  clients hit FreeUsageLimitError); pairs with api_key: public
- config: no config file ships in the repo; first run generates a default
  config at the -config path with a random admin key, loopback listen and a
  keyless zen source (config.EnsureDefault); remove config.example.yaml
- lua: seed bundled adapters from the embedded FS instead of a hardcoded
  name list
- ui: widen model kind select (chat was clipped to 'cha')
- phase 5 bugfixes: stats ms/s bucket mixing, cleanScopes nil, ctx.Err
  guards, direct-path ModelAvailable, empty stream body failure,
  bestImageModel rewrite, transform failure recording, Core.mu, timer,
  effective model for tool-calls

internal/lua/adapters/opencode.lua

@@ -0,0 +1,95 @@
+local adapter = {}
+
+adapter.name = "opencode"
+adapter.version = "1.0.0"
+adapter.endpoint = "/chat/completions"
+
+-- opencode.ai zen 网关按 User-Agent 指纹识别官方客户端并把请求分到免费额度池；
+-- 非官方 UA（curl/Go 默认等）会被分到匿名池并触发 FreeUsageLimitError。
+-- 因此固定发送 opencode 客户端的 UA；配合源配置 api_key: "public"（官方无 key
+-- 客户端实际发送 Bearer public）即可走免费池。
+adapter.headers = {
+    ["User-Agent"] = "opencode/0.1.0",
+}
+
+-- OpenAI /chat/completions format (pass-through, strip provider-specific fields)
+function adapter.transform_request(raw_body)
+    local ok, req = pcall(json.decode, raw_body)
+    if not ok then return raw_body end
+    req.disable_thinking = nil
+    req.extra_body = nil
+    if req.messages then
+        for _, msg in ipairs(req.messages) do
+            msg.reasoning_content = nil
+        end
+    end
+    return json.encode(req)
+end
+
+function adapter.transform_response(raw_body)
+    local ok, resp = pcall(json.decode, raw_body)
+    if not ok or resp == nil then return raw_body end
+
+    local unified = {
+        content = "",
+        finish_reason = "",
+        token_usage = { prompt = 0, completion = 0, total = 0 }
+    }
+
+    if type(resp.usage) == "table" then
+        unified.token_usage.prompt = resp.usage.prompt_tokens or 0
+        unified.token_usage.completion = resp.usage.completion_tokens or 0
+        unified.token_usage.total = resp.usage.total_tokens or 0
+    end
+
+    if type(resp.choices) == "table" and #resp.choices > 0 then
+        local ch = resp.choices[1]
+        if type(ch.message) == "table" then
+            unified.content = ch.message.content or ""
+            if ch.message.reasoning_content then
+                unified.reasoning_content = ch.message.reasoning_content
+            end
+            if type(ch.message.tool_calls) == "table" then
+                local tcs = {}
+                for _, tc in ipairs(ch.message.tool_calls) do
+                    local args_ok, args = pcall(json.decode, tc["function"].arguments)
+                    if not args_ok then args = {} end
+                    table.insert(tcs, {
+                        id = tc.id,
+                        type = tc.type or "function",
+                        name = tc["function"].name,
+                        arguments = args
+                    })
+                end
+                unified.tool_calls = tcs
+            end
+        end
+        unified.finish_reason = ch.finish_reason or ""
+    end
+
+    return json.encode(unified)
+end
+
+function adapter.transform_stream_chunk(raw_chunk)
+    local ok, chunk = pcall(json.decode, raw_chunk)
+    if not ok then return "" end
+
+    if not chunk.choices or #chunk.choices == 0 then return "" end
+    local delta = chunk.choices[1].delta or {}
+    local fr = chunk.choices[1].finish_reason
+
+    local unified = {
+        content = delta.content or "",
+        done = (fr ~= nil)
+    }
+    if delta.reasoning_content then
+        unified.reasoning_content = delta.reasoning_content
+    end
+    if delta.tool_calls then
+        -- pass raw streaming fragments through; OpenAI clients accumulate index+id+name+arguments
+        unified.tool_calls = delta.tool_calls
+    end
+    return json.encode(unified)
+end
+
+return adapter

internal/lua/vm.go

@@ -302,13 +302,21 @@ func (v *VM) pool(name string) *adapterPool {
 }
 
 func (v *VM) writeBundledAdapters() error {
-	known := []string{"openai", "anthropic", "deepseek", "gemini", "github", "groq", "mistral", "ollama", "kimicode"}
-	for _, name := range known {
-		dst := filepath.Join(v.dir, name+".lua")
+	// Derive the set from the embedded FS instead of a hardcoded name list so
+	// adding an adapter never requires maintaining a second list.
+	entries, err := bundledAdapters.ReadDir("adapters")
+	if err != nil {
+		return err
+	}
+	for _, e := range entries {
+		if e.IsDir() || !strings.HasSuffix(e.Name(), ".lua") {
+			continue
+		}
+		dst := filepath.Join(v.dir, e.Name())
 		if _, err := os.Stat(dst); err == nil {
 			continue
 		}
-		data, err := bundledAdapters.ReadFile("adapters/" + name + ".lua")
+		data, err := bundledAdapters.ReadFile("adapters/" + e.Name())
 		if err != nil {
 			continue
 		}

internal/lua/vm_test.go

@@ -2,6 +2,7 @@ package lua
 
 import (
 	"encoding/json"
+	"os"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -28,13 +29,56 @@ func TestLoadBundledAdapters(t *testing.T) {
 	for _, a := range adapters {
 		names[a.Name] = true
 	}
-	for _, want := range []string{"openai", "deepseek", "anthropic", "gemini", "ollama", "kimicode"} {
+	for _, want := range []string{"openai", "deepseek", "anthropic", "gemini", "ollama", "kimicode", "opencode"} {
 		if !names[want] {
 			t.Errorf("missing adapter %s (got %v)", want, names)
 		}
 	}
 }
 
+func TestFirstRunSeedsEveryBundledAdapter(t *testing.T) {
+	dir := filepath.Join(t.TempDir(), "adapters")
+	vm := NewVM(dir)
+	if err := vm.Start(); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+	defer vm.Stop()
+	// every embedded .lua must have been copied out (and no extra, non-.lua files)
+	embedded, err := bundledAdapters.ReadDir("adapters")
+	if err != nil {
+		t.Fatal(err)
+	}
+	seeded := 0
+	for _, e := range embedded {
+		if e.IsDir() || !strings.HasSuffix(e.Name(), ".lua") {
+			continue
+		}
+		seeded++
+		if _, err := os.Stat(filepath.Join(dir, e.Name())); err != nil {
+			t.Errorf("embedded adapter %s not seeded", e.Name())
+		}
+	}
+	if seeded == 0 {
+		t.Fatal("no embedded adapters found")
+	}
+	written := 0
+	entries, _ := os.ReadDir(dir)
+	for _, e := range entries {
+		if !e.IsDir() && strings.HasSuffix(e.Name(), ".lua") {
+			written++
+		}
+	}
+	if written != seeded {
+		t.Fatalf("seeded %d files but %d embedded adapters exist", written, seeded)
+	}
+	// re-start with the existing dir: authoritative, never rewritten
+	vm2 := NewVM(dir)
+	if err := vm2.Start(); err != nil {
+		t.Fatalf("second start: %v", err)
+	}
+	defer vm2.Stop()
+}
+
 func TestTransformRequest(t *testing.T) {
 	vm := NewVM(freshAdapterDir(t))
 	if err := vm.Start(); err != nil {
@@ -65,6 +109,32 @@ func TestBuildHeadersFallbackStatic(t *testing.T) {
 	}
 }
 
+func TestOpenCodeAdapterFingerprint(t *testing.T) {
+	vm := NewVM(freshAdapterDir(t))
+	if err := vm.Start(); err != nil {
+		t.Fatal(err)
+	}
+	defer vm.Stop()
+	hdrs, err := vm.BuildHeaders("opencode", map[string]interface{}{"api_key": "public"})
+	if err != nil {
+		t.Fatalf("build headers: %v", err)
+	}
+	if ua := hdrs["User-Agent"]; ua != "opencode/0.1.0" {
+		t.Fatalf("opencode adapter must send the opencode client UA, got %q", ua)
+	}
+	if hdrs["Authorization"] != "" {
+		t.Fatalf("opencode adapter must not hardcode Authorization (config api_key supplies it), got %q", hdrs["Authorization"])
+	}
+	// passthrough behaves like the openai adapter
+	out, err := vm.Transform("opencode", "transform_request", `{"model":"x","disable_thinking":true,"extra_body":{},"messages":[{"role":"user","content":"hi"}]}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(out, "disable_thinking") || strings.Contains(out, "extra_body") {
+		t.Fatalf("opencode transform_request must strip provider fields: %s", out)
+	}
+}
+
 func TestBuildHeadersCustomHook(t *testing.T) {
 	vm := NewVM(freshAdapterDir(t))
 	if err := vm.Start(); err != nil {