Enha: pick api and model by index (/m 1)

write logs to log.log

.gitignore

@@ -1,8 +1,9 @@
-*.txt
 *.json
 testlog
 history/
 *.db
+*.db-shm
+*.db-wal
 config.toml
 sysprompts/*
 !sysprompts/alice_bob_carl.json
@@ -15,3 +16,5 @@ gflt
 chat_exports/*.json
 ragimport
 .env
+onnx/
+*.log

Makefile

@@ -1,4 +1,4 @@
-.PHONY: setconfig run lint lintall install-linters setup-whisper build-whisper download-whisper-model docker-up docker-down docker-logs noextra-run installdelve checkdelve
+.PHONY: setconfig run lint lintall install-linters setup-whisper build-whisper download-whisper-model docker-up docker-down docker-logs noextra-run installdelve checkdelve fetch-onnx install-onnx-deps
 
 run: setconfig
 	go build -tags extra -o gf-lt && ./gf-lt
@@ -30,13 +30,113 @@ lint: ## Run linters. Use make install-linters first.
 lintall: lint
 	noblanks ./...
 
+fetch-onnx:
+	mkdir -p onnx/embedgemma && curl -o onnx/embedgemma/config.json -L https://huggingface.co/onnx-community/embeddinggemma-300m-ONNX/resolve/main/config.json && curl -o onnx/embedgemma/tokenizer.json -L https://huggingface.co/onnx-community/embeddinggemma-300m-ONNX/resolve/main/tokenizer.json && curl -o onnx/embedgemma/model_q4.onnx -L https://huggingface.co/onnx-community/embeddinggemma-300m-ONNX/resolve/main/onnx/model_q4.onnx && curl -o onnx/embedgemma/model_q4.onnx_data -L https://huggingface.co/onnx-community/embeddinggemma-300m-ONNX/resolve/main/onnx/model_q4.onnx_data?download=true
+
+install-onnx-deps: ## Install ONNX Runtime with CUDA support (or CPU fallback)
+	@echo "=== ONNX Runtime Installer ===" && \
+	echo "" && \
+	echo "Checking for existing ONNX Runtime..." && \
+	if ldconfig -p 2>/dev/null | grep -q libonnxruntime.so.1; then \
+		echo "ONNX Runtime is already installed:" && \
+		ldconfig -p 2>/dev/null | grep libonnxruntime && \
+		echo "" && \
+		echo "Skipping installation. To reinstall, remove existing libs first:" && \
+		echo "  sudo rm -f /usr/local/lib/libonnxruntime*.so*" && \
+		exit 0; \
+	fi && \
+	echo "No ONNX Runtime found. Proceeding with installation..." && \
+	echo "" && \
+	echo "Detecting CUDA version..." && \
+	HAS_CUDA=0 && \
+	if command -v nvidia-smi >/dev/null 2>&1; then \
+		CUDA_INFO=$$(nvidia-smi --query-gpu=driver_version --format=csv,noheader 2>/dev/null | head -1) && \
+		if [ -n "$$CUDA_INFO" ]; then \
+			echo "Found NVIDIA GPU with driver: $$CUDA_INFO" && \
+			HAS_CUDA=1; \
+		else \
+			echo "NVIDIA driver found but could not detect CUDA version"; \
+		fi; \
+	else \
+		echo "No NVIDIA GPU detected (nvidia-smi not found)"; \
+	fi && \
+	echo "" && \
+	echo "Determining ONNX Runtime version..." && \
+	ARCH=$$(uname -m) && \
+	if [ "$$ARCH" = "x86_64" ]; then \
+		ONNX_ARCH="x64"; \
+	elif [ "$$ARCH" = "aarch64" ] || [ "$$ARCH" = "arm64" ]; then \
+		ONNX_ARCH="aarch64"; \
+	else \
+		echo "Unsupported architecture: $$ARCH" && \
+		exit 1; \
+	fi && \
+	echo "Detected architecture: $$ARCH (ONNX runtime: $$ONNX_ARCH)" && \
+	if [ "$$HAS_CUDA" = "1" ]; then \
+		echo "Installing ONNX Runtime with CUDA support..."; \
+		ONNX_VERSION="1.24.2"; \
+	else \
+		echo "Installing ONNX Runtime (CPU version)..."; \
+		ONNX_VERSION="1.24.2"; \
+	fi && \
+	FILENAME="onnxruntime-linux-$${ONNX_ARCH}-${ONNX_VERSION}.tgz" && \
+	URL="https://github.com/microsoft/onnxruntime/releases/download/v$${ONNX_VERSION}/$${FILENAME}" && \
+	echo "Downloading $${URL}..." && \
+	mkdir -p /tmp/onnx-install && \
+	curl -L -o /tmp/onnx-install/$${FILENAME} "$${URL}" || { \
+		echo "Failed to download ONNX Runtime v$${ONNX_VERSION}. Trying v1.18.0..." && \
+		ONNX_VERSION="1.18.0" && \
+		FILENAME="onnxruntime-linux-$${ONNX_ARCH}-${ONNX_VERSION}.tgz" && \
+		URL="https://github.com/microsoft/onnxruntime/releases/download/v$${ONNX_VERSION}/$${FILENAME}" && \
+		curl -L -o /tmp/onnx-install/$${FILENAME} "$${URL}" || { \
+			echo "ERROR: Failed to download ONNX Runtime from GitHub" && \
+			echo "" && \
+			echo "Please install manually:" && \
+			echo "  1. Go to https://github.com/microsoft/onnxruntime/releases" && \
+			echo "  2. Download onnxruntime-linux-$${ONNX_ARCH}-VERSION.tgz" && \
+			echo "  3. Extract and copy to /usr/local/lib:" && \
+			echo "     tar -xzf onnxruntime-linux-$${ONNX_ARCH}-VERSION.tgz" && \
+			echo "     sudo cp -r onnxruntime-linux-$${ONNX_ARCH}-VERSION/lib/* /usr/local/lib/" && \
+			echo "     sudo ldconfig" && \
+			exit 1; \
+		}; \
+	} && \
+	echo "Extracting..." && \
+	cd /tmp/onnx-install && tar -xzf $${FILENAME} && \
+	echo "Installing to /usr/local/lib..." && \
+	ONNX_DIR=$$(find /tmp/onnx-install -maxdepth 1 -type d -name "onnxruntime-linux-*") && \
+	if [ -d "$${ONNX_DIR}/lib" ]; then \
+		cp -r $${ONNX_DIR}/lib/* /usr/local/lib/ 2>/dev/null || sudo cp -r $${ONNX_DIR}/lib/* /usr/local/lib/; \
+	else \
+		echo "ERROR: Could not find lib directory in extracted archive" && \
+		exit 1; \
+	fi && \
+	echo "Updating library cache..." && \
+	sudo ldconfig 2>/dev/null || ldconfig && \
+	echo "" && \
+	echo "=== Installation complete! ===" && \
+	echo "" && \
+	echo "Installed libraries:" && \
+	ldconfig -p | grep libonnxruntime || echo "(libraries may require logout/relogin to appear)" && \
+	echo "" && \
+	if [ "$$HAS_CUDA" = "1" ]; then \
+		echo "NOTE: CUDA-enabled ONNX Runtime installed."; \
+		echo "Ensure you also have CUDA libraries installed:"; \
+		echo "  - libcudnn, libcublas, libcurand"; \
+	else \
+		echo "NOTE: CPU-only ONNX Runtime installed."; \
+		echo "For GPU support, install CUDA and re-run this script."; \
+	fi && \
+	rm -rf /tmp/onnx-install
+
 # Whisper STT Setup (in batteries directory)
 setup-whisper: build-whisper download-whisper-model
 
 build-whisper: ## Build whisper.cpp from source in batteries directory
 	@echo "Building whisper.cpp from source in batteries directory..."
-	@if [ ! -d "batteries/whisper.cpp" ]; then \
+	@if [ ! -f "batteries/whisper.cpp/CMakeLists.txt" ]; then \
 		echo "Cloning whisper.cpp repository to batteries directory..."; \
+		rm -rf batteries/whisper.cpp; \
 		git clone https://github.com/ggml-org/whisper.cpp.git batteries/whisper.cpp; \
 	fi
 	cd batteries/whisper.cpp && cmake -B build -DGGML_CUDA=ON -DWHISPER_SDL2=ON; cmake --build build --config Release -j 8
@@ -44,11 +144,10 @@ build-whisper: ## Build whisper.cpp from source in batteries directory
 
 download-whisper-model: ## Download Whisper model for STT in batteries directory
 	@echo "Downloading Whisper model for STT..."
-	@if [ ! -d "batteries/whisper.cpp" ]; then \
+	@if [ ! -d "batteries/whisper.cpp/models" ]; then \
-		echo "Please run 'make setup-whisper' first to clone the repository."; \
+		mkdir -p "batteries/whisper.cpp/models"; \
-		exit 1; \
 	fi
-	@cd batteries/whisper.cpp && bash ./models/download-ggml-model.sh large-v3-turbo-q5_0
+	curl -o batteries/whisper.cpp/models/ggml-large-v3-turbo-q5_0.bin -L "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo-q5_0.bin?download=true"
 	@echo "Whisper model downloaded successfully!"
 
 # Docker targets for STT/TTS services (in batteries directory)

README.md

@@ -10,9 +10,19 @@ made with use of [tview](https://github.com/rivo/tview)
 - function calls (function calls are implemented natively, to avoid calling outside sources);
 - [character specific context (unique feature)](docs/char-specific-context.md)
 
+
+#### showcase on youtube
+[![gf-lt video showcase](assets/yt_thumb.jpg)](https://youtu.be/WCS4Xc902F8 "gf-lt showcase")
+
 #### how it looks
 ![how it looks](assets/ex01.png)
 
+
+#### dependencies
+- make
+- go
+- ffmpeg (extra)
+
 #### how to install
 (requires golang)
 clone the project
@@ -28,7 +38,8 @@ make noextra-run
 ```
 
 #### keybinds
-while running you can press f12 for list of keys;
+- use `insert` button to paste text from the clipboard to the text area, instead of shift+insert (might freeze the program);
+- press f12 for list of keys;
 ![keybinds](assets/helppage.png)
 
 #### setting up config

agent/agent.go

@@ -4,11 +4,12 @@ package agent
 // ones who do their own tools calls
 // ones that works only with the output
 
-// A: main chat -> agent (handles everything: tool + processing)
+// A: main chat -> agent (handles everything: tool + processing), supports tool chaining
 // B: main chat -> tool -> agent (process tool output)
 
-// AgenterA gets a task "find out weather in london"
+// AgenterA gets a task like "go to the webpage, login and take a screenshot (tell me what you see)"
-// proceeds to make tool calls on its own
+// proceeds to make a plan and executes it.
+// returns with final result or an error
 type AgenterA interface {
 	ProcessTask(task string) []byte
 }
@@ -38,8 +39,3 @@ func RegisterA(toolNames []string, a AgenterA) {
 func Get(toolName string) AgenterB {
 	return RegistryB[toolName]
 }
-
-// Register is a convenience wrapper for RegisterB.
-func Register(toolName string, a AgenterB) {
-	RegisterB(toolName, a)
-}

agent/pw_agent.go

@@ -0,0 +1,119 @@
+package agent
+
+import (
+	"encoding/json"
+	"gf-lt/models"
+	"strings"
+)
+
+// PWAgent: is AgenterA type agent (enclosed with tool chaining)
+// sysprompt explain tools and how to plan for execution
+type PWAgent struct {
+	*AgentClient
+	sysprompt string
+}
+
+// NewPWAgent creates a PWAgent with the given client and system prompt
+func NewPWAgent(client *AgentClient, sysprompt string) *PWAgent {
+	return &PWAgent{AgentClient: client, sysprompt: sysprompt}
+}
+
+// SetTools sets the tools available to the agent
+func (a *PWAgent) SetTools(tools []models.Tool) {
+	a.tools = tools
+}
+
+func (a *PWAgent) ProcessTask(task string) []byte {
+	req, err := a.FormFirstMsg(a.sysprompt, task)
+	if err != nil {
+		a.Log().Error("PWAgent failed to process the request", "error", err)
+		return []byte("PWAgent failed to process the request; err: " + err.Error())
+	}
+	toolCallLimit := 10
+	for i := 0; i < toolCallLimit; i++ {
+		resp, err := a.LLMRequest(req)
+		if err != nil {
+			a.Log().Error("failed to process the request", "error", err)
+			return []byte("failed to process the request; err: " + err.Error())
+		}
+		execTool, toolCallID, hasToolCall := findToolCall(resp)
+		if !hasToolCall {
+			return resp
+		}
+
+		a.setToolCallOnLastMessage(resp, toolCallID)
+
+		toolResp := string(execTool())
+		req, err = a.FormMsgWithToolCallID(toolResp, toolCallID)
+		if err != nil {
+			a.Log().Error("failed to form next message", "error", err)
+			return []byte("failed to form next message; err: " + err.Error())
+		}
+	}
+	return nil
+}
+
+func (a *PWAgent) setToolCallOnLastMessage(resp []byte, toolCallID string) {
+	if toolCallID == "" {
+		return
+	}
+	var genericResp map[string]interface{}
+	if err := json.Unmarshal(resp, &genericResp); err != nil {
+		return
+	}
+	var name string
+	var args map[string]string
+	if choices, ok := genericResp["choices"].([]interface{}); ok && len(choices) > 0 {
+		if firstChoice, ok := choices[0].(map[string]interface{}); ok {
+			if message, ok := firstChoice["message"].(map[string]interface{}); ok {
+				if toolCalls, ok := message["tool_calls"].([]interface{}); ok && len(toolCalls) > 0 {
+					if tc, ok := toolCalls[0].(map[string]interface{}); ok {
+						if fn, ok := tc["function"].(map[string]interface{}); ok {
+							name, _ = fn["name"].(string)
+							argsStr, _ := fn["arguments"].(string)
+							_ = json.Unmarshal([]byte(argsStr), &args)
+						}
+					}
+				}
+			}
+		}
+	}
+	if name == "" {
+		content, _ := genericResp["content"].(string)
+		name = extractToolNameFromText(content)
+	}
+	lastIdx := len(a.chatBody.Messages) - 1
+	if lastIdx >= 0 {
+		a.chatBody.Messages[lastIdx].ToolCallID = toolCallID
+		if name != "" {
+			argsJSON, _ := json.Marshal(args)
+			a.chatBody.Messages[lastIdx].ToolCall = &models.ToolCall{
+				ID:   toolCallID,
+				Name: name,
+				Args: string(argsJSON),
+			}
+		}
+	}
+}
+
+func extractToolNameFromText(text string) string {
+	jsStr := toolCallRE.FindString(text)
+	if jsStr == "" {
+		return ""
+	}
+	jsStr = strings.TrimSpace(jsStr)
+	jsStr = strings.TrimPrefix(jsStr, "__tool_call__")
+	jsStr = strings.TrimSuffix(jsStr, "__tool_call__")
+	jsStr = strings.TrimSpace(jsStr)
+	start := strings.Index(jsStr, "{")
+	end := strings.LastIndex(jsStr, "}")
+	if start == -1 || end == -1 || end <= start {
+		return ""
+	}
+	jsStr = jsStr[start : end+1]
+	var fc models.FuncCall
+	if err := json.Unmarshal([]byte(jsStr), &fc); err != nil {
+		return ""
+	}
+	return fc.Name
+}

agent/pw_tools.go

@@ -0,0 +1,338 @@
+package agent
+
+import (
+	"encoding/json"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"gf-lt/models"
+)
+
+type ToolFunc func(map[string]string) []byte
+
+var pwToolMap = make(map[string]ToolFunc)
+
+func RegisterPWTool(name string, fn ToolFunc) {
+	pwToolMap[name] = fn
+}
+
+func GetPWTools() []models.Tool {
+	return pwTools
+}
+
+var pwTools = []models.Tool{
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_start",
+			Description: "Start a Playwright browser instance. Must be called first before any other browser automation. Uses headless mode by default.",
+			Parameters: models.ToolFuncParams{
+				Type:       "object",
+				Required:   []string{},
+				Properties: map[string]models.ToolArgProps{},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_stop",
+			Description: "Stop the Playwright browser instance. Call when done with browser automation.",
+			Parameters: models.ToolFuncParams{
+				Type:       "object",
+				Required:   []string{},
+				Properties: map[string]models.ToolArgProps{},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_is_running",
+			Description: "Check if Playwright browser is currently running.",
+			Parameters: models.ToolFuncParams{
+				Type:       "object",
+				Required:   []string{},
+				Properties: map[string]models.ToolArgProps{},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_navigate",
+			Description: "Navigate to a URL in the browser.",
+			Parameters: models.ToolFuncParams{
+				Type:     "object",
+				Required: []string{"url"},
+				Properties: map[string]models.ToolArgProps{
+					"url": {Type: "string", Description: "URL to navigate to"},
+				},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_click",
+			Description: "Click on an element on the current webpage. Use 'index' for multiple matches (default 0).",
+			Parameters: models.ToolFuncParams{
+				Type:     "object",
+				Required: []string{"selector"},
+				Properties: map[string]models.ToolArgProps{
+					"selector": {Type: "string", Description: "CSS selector for the element"},
+					"index":    {Type: "integer", Description: "Index for multiple matches (default 0)"},
+				},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_fill",
+			Description: "Type text into an input field. Use 'index' for multiple matches (default 0).",
+			Parameters: models.ToolFuncParams{
+				Type:     "object",
+				Required: []string{"selector", "text"},
+				Properties: map[string]models.ToolArgProps{
+					"selector": {Type: "string", Description: "CSS selector for the input element"},
+					"text":     {Type: "string", Description: "Text to type into the field"},
+					"index":    {Type: "integer", Description: "Index for multiple matches (default 0)"},
+				},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_extract_text",
+			Description: "Extract text content from the page or specific elements. Use selector 'body' for all page text.",
+			Parameters: models.ToolFuncParams{
+				Type:     "object",
+				Required: []string{},
+				Properties: map[string]models.ToolArgProps{
+					"selector": {Type: "string", Description: "CSS selector (default 'body' for all page text)"},
+				},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_screenshot",
+			Description: "Take a screenshot of the page or a specific element. Returns a file path to the image.",
+			Parameters: models.ToolFuncParams{
+				Type:     "object",
+				Required: []string{},
+				Properties: map[string]models.ToolArgProps{
+					"selector":  {Type: "string", Description: "CSS selector for element to screenshot"},
+					"full_page": {Type: "boolean", Description: "Capture full page (default false)"},
+				},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_screenshot_and_view",
+			Description: "Take a screenshot and return the image for viewing. Use to visually verify page state.",
+			Parameters: models.ToolFuncParams{
+				Type:     "object",
+				Required: []string{},
+				Properties: map[string]models.ToolArgProps{
+					"selector":  {Type: "string", Description: "CSS selector for element to screenshot"},
+					"full_page": {Type: "boolean", Description: "Capture full page (default false)"},
+				},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_wait_for_selector",
+			Description: "Wait for an element to appear on the page before proceeding.",
+			Parameters: models.ToolFuncParams{
+				Type:     "object",
+				Required: []string{"selector"},
+				Properties: map[string]models.ToolArgProps{
+					"selector": {Type: "string", Description: "CSS selector to wait for"},
+					"timeout":  {Type: "integer", Description: "Timeout in milliseconds (default 30000)"},
+				},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_drag",
+			Description: "Drag the mouse from point (x1,y1) to (x2,y2).",
+			Parameters: models.ToolFuncParams{
+				Type:     "object",
+				Required: []string{"x1", "y1", "x2", "y2"},
+				Properties: map[string]models.ToolArgProps{
+					"x1": {Type: "number", Description: "Starting X coordinate"},
+					"y1": {Type: "number", Description: "Starting Y coordinate"},
+					"x2": {Type: "number", Description: "Ending X coordinate"},
+					"y2": {Type: "number", Description: "Ending Y coordinate"},
+				},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_click_at",
+			Description: "Click at specific X,Y coordinates on the page.",
+			Parameters: models.ToolFuncParams{
+				Type:     "object",
+				Required: []string{"x", "y"},
+				Properties: map[string]models.ToolArgProps{
+					"x": {Type: "number", Description: "X coordinate"},
+					"y": {Type: "number", Description: "Y coordinate"},
+				},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_get_html",
+			Description: "Get the HTML content of the page or a specific element.",
+			Parameters: models.ToolFuncParams{
+				Type:     "object",
+				Required: []string{},
+				Properties: map[string]models.ToolArgProps{
+					"selector": {Type: "string", Description: "CSS selector (default 'body')"},
+				},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_get_dom",
+			Description: "Get a structured DOM representation with tag, attributes, text, and children.",
+			Parameters: models.ToolFuncParams{
+				Type:     "object",
+				Required: []string{},
+				Properties: map[string]models.ToolArgProps{
+					"selector": {Type: "string", Description: "CSS selector (default 'body')"},
+				},
+			},
+		},
+	},
+	{
+		Type: "function",
+		Function: models.ToolFunc{
+			Name:        "pw_search_elements",
+			Description: "Search for elements by text content or CSS selector.",
+			Parameters: models.ToolFuncParams{
+				Type:     "object",
+				Required: []string{},
+				Properties: map[string]models.ToolArgProps{
+					"text":     {Type: "string", Description: "Text content to search for"},
+					"selector": {Type: "string", Description: "CSS selector to search for"},
+				},
+			},
+		},
+	},
+}
+
+var toolCallRE = regexp.MustCompile(`__tool_call__(.+?)__tool_call__`)
+
+type ParsedToolCall struct {
+	ID   string
+	Name string
+	Args map[string]string
+}
+
+func findToolCall(resp []byte) (func() []byte, string, bool) {
+	var genericResp map[string]interface{}
+	if err := json.Unmarshal(resp, &genericResp); err != nil {
+		return findToolCallFromText(string(resp))
+	}
+	if choices, ok := genericResp["choices"].([]interface{}); ok && len(choices) > 0 {
+		if firstChoice, ok := choices[0].(map[string]interface{}); ok {
+			if message, ok := firstChoice["message"].(map[string]interface{}); ok {
+				if toolCalls, ok := message["tool_calls"].([]interface{}); ok && len(toolCalls) > 0 {
+					return parseOpenAIToolCall(toolCalls)
+				}
+				if content, ok := message["content"].(string); ok {
+					return findToolCallFromText(content)
+				}
+			}
+			if text, ok := firstChoice["text"].(string); ok {
+				return findToolCallFromText(text)
+			}
+		}
+	}
+	if content, ok := genericResp["content"].(string); ok {
+		return findToolCallFromText(content)
+	}
+	return findToolCallFromText(string(resp))
+}
+
+func parseOpenAIToolCall(toolCalls []interface{}) (func() []byte, string, bool) {
+	if len(toolCalls) == 0 {
+		return nil, "", false
+	}
+	tc := toolCalls[0].(map[string]interface{})
+	id, _ := tc["id"].(string)
+	function, _ := tc["function"].(map[string]interface{})
+	name, _ := function["name"].(string)
+	argsStr, _ := function["arguments"].(string)
+	var args map[string]string
+	if err := json.Unmarshal([]byte(argsStr), &args); err != nil {
+		return func() []byte {
+			return []byte(fmt.Sprintf(`{"error": "failed to parse arguments: %v"}`, err))
+		}, id, true
+	}
+	return func() []byte {
+		fn, ok := pwToolMap[name]
+		if !ok {
+			return []byte(fmt.Sprintf(`{"error": "tool %s not found"}`, name))
+		}
+		return fn(args)
+	}, id, true
+}
+
+func findToolCallFromText(text string) (func() []byte, string, bool) {
+	jsStr := toolCallRE.FindString(text)
+	if jsStr == "" {
+		return nil, "", false
+	}
+	jsStr = strings.TrimSpace(jsStr)
+	jsStr = strings.TrimPrefix(jsStr, "__tool_call__")
+	jsStr = strings.TrimSuffix(jsStr, "__tool_call__")
+	jsStr = strings.TrimSpace(jsStr)
+	start := strings.Index(jsStr, "{")
+	end := strings.LastIndex(jsStr, "}")
+	if start == -1 || end == -1 || end <= start {
+		return func() []byte {
+			return []byte(`{"error": "no valid JSON found in tool call"}`)
+		}, "", true
+	}
+	jsStr = jsStr[start : end+1]
+	var fc models.FuncCall
+	if err := json.Unmarshal([]byte(jsStr), &fc); err != nil {
+		return func() []byte {
+			return []byte(fmt.Sprintf(`{"error": "failed to parse tool call: %v}`, err))
+		}, "", true
+	}
+	if fc.ID == "" {
+		fc.ID = "call_" + generateToolCallID()
+	}
+	return func() []byte {
+		fn, ok := pwToolMap[fc.Name]
+		if !ok {
+			return []byte(fmt.Sprintf(`{"error": "tool %s not found"}`, fc.Name))
+		}
+		return fn(fc.Args)
+	}, fc.ID, true
+}
+
+func generateToolCallID() string {
+	return strconv.Itoa(len(pwToolMap) % 10000)
+}

agent/request.go

@@ -30,12 +30,16 @@ func detectAPI(api string) (isCompletion, isChat, isDeepSeek, isOpenRouter bool)
 }
 
 type AgentClient struct {
-	cfg      *config.Config
+	cfg       *config.Config
-	getToken func() string
+	getToken  func() string
-	log      slog.Logger
+	log       *slog.Logger
+	chatBody  *models.ChatBody
+	sysprompt string
+	// lastToolCallID string
+	tools []models.Tool
 }
 
-func NewAgentClient(cfg *config.Config, log slog.Logger, gt func() string) *AgentClient {
+func NewAgentClient(cfg *config.Config, log *slog.Logger, gt func() string) *AgentClient {
 	return &AgentClient{
 		cfg:      cfg,
 		getToken: gt,
@@ -44,11 +48,46 @@ func NewAgentClient(cfg *config.Config, log slog.Logger, gt func() string) *Agen
 }
 
 func (ag *AgentClient) Log() *slog.Logger {
-	return &ag.log
+	return ag.log
 }
 
-func (ag *AgentClient) FormMsg(sysprompt, msg string) (io.Reader, error) {
+func (ag *AgentClient) FormFirstMsg(sysprompt, msg string) (io.Reader, error) {
-	b, err := ag.buildRequest(sysprompt, msg)
+	ag.sysprompt = sysprompt
+	ag.chatBody = &models.ChatBody{
+		Messages: []models.RoleMsg{
+			{Role: "system", Content: ag.sysprompt},
+			{Role: "user", Content: msg},
+		},
+		Stream: false,
+		Model:  ag.cfg.CurrentModel,
+	}
+	b, err := ag.buildRequest()
+	if err != nil {
+		return nil, err
+	}
+	return bytes.NewReader(b), nil
+}
+
+func (ag *AgentClient) FormMsg(msg string) (io.Reader, error) {
+	m := models.RoleMsg{
+		Role: "tool", Content: msg,
+	}
+	ag.chatBody.Messages = append(ag.chatBody.Messages, m)
+	b, err := ag.buildRequest()
+	if err != nil {
+		return nil, err
+	}
+	return bytes.NewReader(b), nil
+}
+
+func (ag *AgentClient) FormMsgWithToolCallID(msg, toolCallID string) (io.Reader, error) {
+	m := models.RoleMsg{
+		Role:       "tool",
+		Content:    msg,
+		ToolCallID: toolCallID,
+	}
+	ag.chatBody.Messages = append(ag.chatBody.Messages, m)
+	b, err := ag.buildRequest()
 	if err != nil {
 		return nil, err
 	}
@@ -56,81 +95,52 @@ func (ag *AgentClient) FormMsg(sysprompt, msg string) (io.Reader, error) {
 }
 
 // buildRequest creates the appropriate LLM request based on the current API endpoint.
-func (ag *AgentClient) buildRequest(sysprompt, msg string) ([]byte, error) {
+func (ag *AgentClient) buildRequest() ([]byte, error) {
-	api := ag.cfg.CurrentAPI
+	isCompletion, isChat, isDeepSeek, isOpenRouter := detectAPI(ag.cfg.CurrentAPI)
-	model := ag.cfg.CurrentModel
+	ag.log.Debug("agent building request", "api", ag.cfg.CurrentAPI, "isCompletion", isCompletion, "isChat", isChat, "isDeepSeek", isDeepSeek, "isOpenRouter", isOpenRouter)
-	messages := []models.RoleMsg{
-		{Role: "system", Content: sysprompt},
-		{Role: "user", Content: msg},
-	}
-
-	// Determine API type
-	isCompletion, isChat, isDeepSeek, isOpenRouter := detectAPI(api)
-	ag.log.Debug("agent building request", "api", api, "isCompletion", isCompletion, "isChat", isChat, "isDeepSeek", isDeepSeek, "isOpenRouter", isOpenRouter)
-
 	// Build prompt for completion endpoints
 	if isCompletion {
 		var sb strings.Builder
-		for i := range messages {
+		for i := range ag.chatBody.Messages {
-			sb.WriteString(messages[i].ToPrompt())
+			sb.WriteString(ag.chatBody.Messages[i].ToPrompt())
 			sb.WriteString("\n")
 		}
 		prompt := strings.TrimSpace(sb.String())
-
 		switch {
 		case isDeepSeek:
 			// DeepSeek completion
-			req := models.NewDSCompletionReq(prompt, model, defaultProps["temperature"], []string{})
+			req := models.NewDSCompletionReq(prompt, ag.chatBody.Model, defaultProps["temperature"], []string{})
 			req.Stream = false // Agents don't need streaming
 			return json.Marshal(req)
 		case isOpenRouter:
 			// OpenRouter completion
-			req := models.NewOpenRouterCompletionReq(model, prompt, defaultProps, []string{})
+			req := models.NewOpenRouterCompletionReq(ag.chatBody.Model, prompt, defaultProps, []string{})
 			req.Stream = false // Agents don't need streaming
 			return json.Marshal(req)
 		default:
 			// Assume llama.cpp completion
-			req := models.NewLCPReq(prompt, model, nil, defaultProps, []string{})
+			req := models.NewLCPReq(prompt, ag.chatBody.Model, nil, defaultProps, []string{})
 			req.Stream = false // Agents don't need streaming
 			return json.Marshal(req)
 		}
 	}
-
+	switch {
-	// Chat completions endpoints
+	case isDeepSeek:
-	if isChat || !isCompletion {
+		// DeepSeek chat
-		chatBody := &models.ChatBody{
+		req := models.NewDSChatReq(*ag.chatBody)
-			Model:    model,
+		return json.Marshal(req)
-			Stream:   false, // Agents don't need streaming
+	case isOpenRouter:
-			Messages: messages,
+		// OpenRouter chat - agents don't use reasoning by default
-		}
+		req := models.NewOpenRouterChatReq(*ag.chatBody, defaultProps, ag.cfg.ReasoningEffort)
-
+		return json.Marshal(req)
-		switch {
+	default:
-		case isDeepSeek:
+		// Assume llama.cpp chat (OpenAI format)
-			// DeepSeek chat
+		req := models.OpenAIReq{
-			req := models.NewDSChatReq(*chatBody)
+			ChatBody: ag.chatBody,
-			return json.Marshal(req)
+			Tools:    ag.tools,
-		case isOpenRouter:
-			// OpenRouter chat - agents don't use reasoning by default
-			req := models.NewOpenRouterChatReq(*chatBody, defaultProps, "")
-			return json.Marshal(req)
-		default:
-			// Assume llama.cpp chat (OpenAI format)
-			req := models.OpenAIReq{
-				ChatBody: chatBody,
-				Tools:    nil,
-			}
-			return json.Marshal(req)
 		}
+		return json.Marshal(req)
 	}
-
-	// Fallback (should not reach here)
-	ag.log.Warn("unknown API, using default chat completions format", "api", api)
-	chatBody := &models.ChatBody{
-		Model:    model,
-		Stream:   false, // Agents don't need streaming
-		Messages: messages,
-	}
-	return json.Marshal(chatBody)
 }
 
 func (ag *AgentClient) LLMRequest(body io.Reader) ([]byte, error) {
@@ -165,7 +175,6 @@ func (ag *AgentClient) LLMRequest(body io.Reader) ([]byte, error) {
 		ag.log.Error("agent LLM request failed", "status", resp.StatusCode, "response", string(responseBytes[:min(len(responseBytes), 1000)]))
 		return responseBytes, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(responseBytes[:min(len(responseBytes), 200)]))
 	}
-
 	// Parse response and extract text content
 	text, err := extractTextFromResponse(responseBytes)
 	if err != nil {
@@ -179,17 +188,16 @@ func (ag *AgentClient) LLMRequest(body io.Reader) ([]byte, error) {
 // extractTextFromResponse parses common LLM response formats and extracts the text content.
 func extractTextFromResponse(data []byte) (string, error) {
 	// Try to parse as generic JSON first
-	var genericResp map[string]interface{}
+	var genericResp map[string]any
 	if err := json.Unmarshal(data, &genericResp); err != nil {
 		// Not JSON, return as string
 		return string(data), nil
 	}
-
 	// Check for OpenAI chat completion format
-	if choices, ok := genericResp["choices"].([]interface{}); ok && len(choices) > 0 {
+	if choices, ok := genericResp["choices"].([]any); ok && len(choices) > 0 {
-		if firstChoice, ok := choices[0].(map[string]interface{}); ok {
+		if firstChoice, ok := choices[0].(map[string]any); ok {
 			// Chat completion: choices[0].message.content
-			if message, ok := firstChoice["message"].(map[string]interface{}); ok {
+			if message, ok := firstChoice["message"].(map[string]any); ok {
 				if content, ok := message["content"].(string); ok {
 					return content, nil
 				}
@@ -199,19 +207,17 @@ func extractTextFromResponse(data []byte) (string, error) {
 				return text, nil
 			}
 			// Delta format for streaming (should not happen with stream: false)
-			if delta, ok := firstChoice["delta"].(map[string]interface{}); ok {
+			if delta, ok := firstChoice["delta"].(map[string]any); ok {
 				if content, ok := delta["content"].(string); ok {
 					return content, nil
 				}
 			}
 		}
 	}
-
 	// Check for llama.cpp completion format
 	if content, ok := genericResp["content"].(string); ok {
 		return content, nil
 	}
-
 	// Unknown format, return pretty-printed JSON
 	prettyJSON, err := json.MarshalIndent(genericResp, "", "  ")
 	if err != nil {
@@ -219,10 +225,3 @@ func extractTextFromResponse(data []byte) (string, error) {
 	}
 	return string(prettyJSON), nil
 }
-
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}

agent/webagent.go

@@ -17,7 +17,8 @@ func NewWebAgentB(client *AgentClient, sysprompt string) *WebAgentB {
 
 // Process applies the formatting function to raw output
 func (a *WebAgentB) Process(args map[string]string, rawOutput []byte) []byte {
-	msg, err := a.FormMsg(a.sysprompt,
+	msg, err := a.FormFirstMsg(
+		a.sysprompt,
 		fmt.Sprintf("request:\n%+v\ntool response:\n%v", args, string(rawOutput)))
 	if err != nil {
 		a.Log().Error("failed to process the request", "error", err)

batteries/docker-compose.yml

@@ -6,19 +6,27 @@ services:
     ports:
       - "8081:8081"
     volumes:
-      - whisper_models:/app/models
+      - ./whisper.cpp/models/ggml-large-v3-turbo-q5_0.bin:/app/models/ggml-large-v3-turbo-q5_0.bin
     working_dir: /app
     entrypoint: ""
     command: >
       sh -c "
-      if [ ! -f /app/models/ggml-large-v3-turbo.bin ]; then
+      if [ ! -f /app/models/ggml-large-v3-turbo-q5_0.bin ]; then
-        echo 'Downloading ggml-large-v3-turbo model...'
+        echo 'Downloading ggml-large-v3-turboq5_0 model...'
-        ./download-ggml-model.sh large-v3-turbo /app/models
+      	curl -o /app/models/ggml-large-v3-turbo-q5_0.bin -L "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo-q5_0.bin?download=true"
       fi &&
-      ./build/bin/whisper-server -m /app/models/ggml-large-v3-turbo.bin -t 4 -p 1 --port 8081 --host 0.0.0.0
+      ./build/bin/whisper-server -m /app/models/ggml-large-v3-turbo-q5_0.bin -t 4 -p 1 --port 8081 --host 0.0.0.0
       "
     environment:
       - WHISPER_LOG_LEVEL=3
+    # For GPU support, uncomment the following lines:
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]
     # Restart policy in case the service fails
     restart: unless-stopped
 
@@ -45,7 +53,5 @@ services:
 volumes:
   models:
     driver: local
-  audio:
-    driver: local
   whisper_models:
     driver: local

bot.go

@@ -3,6 +3,7 @@ package main
 import (
 	"bufio"
 	"bytes"
+	"compress/gzip"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -10,42 +11,113 @@ import (
 	"gf-lt/models"
 	"gf-lt/rag"
 	"gf-lt/storage"
+	"gf-lt/tools"
 	"html"
 	"io"
 	"log/slog"
 	"net"
 	"net/http"
-	"net/url"
 	"os"
 	"regexp"
 	"slices"
 	"strconv"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
+
+	"github.com/rivo/tview"
 )
 
 var (
-	httpClient      = &http.Client{}
+	httpClient     = &http.Client{}
-	cfg             *config.Config
+	cfg            *config.Config
-	logger          *slog.Logger
+	logger         *slog.Logger
-	logLevel        = new(slog.LevelVar)
+	logLevel       = new(slog.LevelVar)
-	ctx, cancel     = context.WithCancel(context.Background())
+	ctx, cancel    = context.WithCancel(context.Background())
-	activeChatName  string
+	activeChatName string
-	chatRoundChan   = make(chan *models.ChatRoundReq, 1)
+	chatRoundChan  = make(chan *models.ChatRoundReq, 1)
-	chunkChan       = make(chan string, 10)
+	chunkChan      = make(chan string, 10)
-	openAIToolChan  = make(chan string, 10)
+	openAIToolChan = make(chan string, 10)
-	streamDone      = make(chan bool, 1)
+	streamDone     = make(chan bool, 1)
-	chatBody        *models.ChatBody
+	chatBody       *models.ChatBody
-	store           storage.FullRepo
+	store          storage.FullRepo
-	defaultFirstMsg = "Hello! What can I do for you?"
+	defaultStarter = []models.RoleMsg{}
-	defaultStarter  = []models.RoleMsg{}
+	interruptResp  atomic.Bool
-	interruptResp   = false
+	ragger         *rag.RAG
-	ragger          *rag.RAG
+	chunkParser    ChunkParser
-	chunkParser     ChunkParser
+	lastToolCall   *models.FuncCall
-	lastToolCall    *models.FuncCall
+	lastRespStats  *models.ResponseStats
-	lastRespStats   *models.ResponseStats
+
-	//nolint:unused // TTS_ENABLED conditionally uses this
+	outputHandler OutputHandler
+	cliPrevOutput string
+	cliRespDone   chan bool
+)
+
+type OutputHandler interface {
+	Write(p string)
+	Writef(format string, args ...interface{})
+	ScrollToEnd()
+}
+
+type TUIOutputHandler struct {
+	tv *tview.TextView
+}
+
+func (h *TUIOutputHandler) Write(p string) {
+	if h.tv != nil {
+		fmt.Fprint(h.tv, p)
+	}
+	if cfg != nil && cfg.CLIMode {
+		fmt.Print(p)
+		cliPrevOutput = p
+	}
+}
+
+func (h *TUIOutputHandler) Writef(format string, args ...interface{}) {
+	s := fmt.Sprintf(format, args...)
+	if h.tv != nil {
+		fmt.Fprint(h.tv, s)
+	}
+	if cfg != nil && cfg.CLIMode {
+		fmt.Print(s)
+		cliPrevOutput = s
+	}
+}
+
+func (h *TUIOutputHandler) ScrollToEnd() {
+	if h.tv != nil {
+		h.tv.ScrollToEnd()
+	}
+}
+
+type CLIOutputHandler struct{}
+
+func (h *CLIOutputHandler) Write(p string) {
+	fmt.Print(p)
+}
+
+func (h *CLIOutputHandler) Writef(format string, args ...interface{}) {
+	fmt.Printf(format, args...)
+}
+
+func (h *CLIOutputHandler) ScrollToEnd() {
+}
+
+var (
+	basicCard = &models.CharCard{
+		ID:        models.ComputeCardID("assistant", "basic_sys"),
+		SysPrompt: models.BasicSysMsg,
+		FirstMsg:  models.DefaultFirstMsg,
+		Role:      "assistant",
+		FilePath:  "basic_sys",
+	}
+	sysMap               = map[string]*models.CharCard{}
+	roleToID             = map[string]string{}
+	modelHasVision       bool
+	windowToolsAvailable bool
+	// tooler               *tools.Tools
+	//
 	orator          Orator
 	asr             STT
 	localModelsMu   sync.RWMutex
@@ -63,7 +135,9 @@ var (
 		"google/gemma-3-27b-it:free",
 		"meta-llama/llama-3.3-70b-instruct:free",
 	}
-	LocalModels = []string{}
+	LocalModels     = []string{}
+	localModelsData *models.LCPModels
+	orModelsData    *models.ORModels
 )
 
 var thinkBlockRE = regexp.MustCompile(`(?s)<think>.*?</think>`)
@@ -250,12 +324,7 @@ func createClient(connectTimeout time.Duration) *http.Client {
 }
 
 func warmUpModel() {
-	u, err := url.Parse(cfg.CurrentAPI)
+	if !isLocalLlamacpp() {
-	if err != nil {
-		return
-	}
-	host := u.Hostname()
-	if host != "localhost" && host != "127.0.0.1" && host != "::1" {
 		return
 	}
 	// Check if model is already loaded
@@ -265,9 +334,7 @@ func warmUpModel() {
 		// Continue with warmup attempt anyway
 	}
 	if loaded {
-		if err := notifyUser("model already loaded", "Model "+chatBody.Model+" is already loaded."); err != nil {
+		showToast("model already loaded", "Model "+chatBody.Model+" is already loaded.")
-			logger.Debug("failed to notify user", "error", err)
-		}
 		return
 	}
 	go func() {
@@ -355,6 +422,7 @@ func fetchORModels(free bool) ([]string, error) {
 	if err := json.NewDecoder(resp.Body).Decode(data); err != nil {
 		return nil, err
 	}
+	orModelsData = data
 	freeModels := data.ListModels(free)
 	return freeModels, nil
 }
@@ -416,6 +484,7 @@ func fetchLCPModelsWithStatus() (*models.LCPModels, error) {
 	if err := json.NewDecoder(resp.Body).Decode(data); err != nil {
 		return nil, err
 	}
+	localModelsData = data
 	return data, nil
 }
 
@@ -460,6 +529,29 @@ func ModelHasVision(api, modelID string) bool {
 	}
 }
 
+func UpdateToolCapabilities() {
+	if !cfg.ToolUse {
+		return
+	}
+	modelHasVision = false
+	if cfg == nil || cfg.CurrentAPI == "" {
+		logger.Warn("cannot determine model capabilities: cfg or CurrentAPI is nil")
+		// tooler.RegisterWindowTools(modelHasVision)
+		return
+	}
+	prevHasVision := modelHasVision
+	modelHasVision = ModelHasVision(cfg.CurrentAPI, cfg.CurrentModel)
+	if modelHasVision {
+		logger.Info("model has vision support", "model", cfg.CurrentModel, "api", cfg.CurrentAPI)
+	} else {
+		logger.Info("model does not have vision support", "model", cfg.CurrentModel, "api", cfg.CurrentAPI)
+		if windowToolsAvailable && !prevHasVision && !modelHasVision {
+			showToast("window tools", "Window capture-and-view unavailable: model lacks vision support")
+		}
+	}
+	// tooler.RegisterWindowTools(modelHasVision)
+}
+
 // monitorModelLoad starts a goroutine that periodically checks if the specified model is loaded.
 func monitorModelLoad(modelID string) {
 	go func() {
@@ -478,9 +570,7 @@ func monitorModelLoad(modelID string) {
 					continue
 				}
 				if loaded {
-					if err := notifyUser("model loaded", "Model "+modelID+" is now loaded and ready."); err != nil {
+					showToast("model loaded", "Model "+modelID+" is now loaded and ready.")
-						logger.Debug("failed to notify user", "error", err)
-					}
 					refreshChatDisplay()
 					return
 				}
@@ -491,6 +581,17 @@ func monitorModelLoad(modelID string) {
 
 // extractDetailedErrorFromBytes extracts detailed error information from response body bytes
 func extractDetailedErrorFromBytes(body []byte, statusCode int) string {
+	// Try to decompress gzip if the response is compressed
+	if len(body) >= 2 && body[0] == 0x1f && body[1] == 0x8b {
+		reader, err := gzip.NewReader(bytes.NewReader(body))
+		if err == nil {
+			decompressed, err := io.ReadAll(reader)
+			reader.Close()
+			if err == nil {
+				body = decompressed
+			}
+		}
+	}
 	// Try to parse as JSON to extract detailed error information
 	var errorResponse map[string]any
 	if err := json.Unmarshal(body, &errorResponse); err == nil {
@@ -556,9 +657,7 @@ func sendMsgToLLM(body io.Reader) {
 	req, err := http.NewRequest("POST", cfg.CurrentAPI, body)
 	if err != nil {
 		logger.Error("newreq error", "error", err)
-		if err := notifyUser("error", "apicall failed:"+err.Error()); err != nil {
+		showToast("error", "apicall failed:"+err.Error())
-			logger.Error("failed to notify", "error", err)
-		}
 		streamDone <- true
 		return
 	}
@@ -570,9 +669,7 @@ func sendMsgToLLM(body io.Reader) {
 	resp, err := httpClient.Do(req)
 	if err != nil {
 		logger.Error("llamacpp api", "error", err)
-		if err := notifyUser("error", "apicall failed:"+err.Error()); err != nil {
+		showToast("error", "apicall failed:"+err.Error())
-			logger.Error("failed to notify", "error", err)
-		}
 		streamDone <- true
 		return
 	}
@@ -583,9 +680,7 @@ func sendMsgToLLM(body io.Reader) {
 		if err != nil {
 			logger.Error("failed to read error response body", "error", err, "status_code", resp.StatusCode)
 			detailedError := fmt.Sprintf("HTTP Status: %d, Failed to read response body: %v", resp.StatusCode, err)
-			if err := notifyUser("API Error", detailedError); err != nil {
+			showToast("API Error", detailedError)
-				logger.Error("failed to notify", "error", err)
-			}
 			resp.Body.Close()
 			streamDone <- true
 			return
@@ -593,9 +688,7 @@ func sendMsgToLLM(body io.Reader) {
 		// Parse the error response for detailed information
 		detailedError := extractDetailedErrorFromBytes(bodyBytes, resp.StatusCode)
 		logger.Error("API returned error status", "status_code", resp.StatusCode, "detailed_error", detailedError)
-		if err := notifyUser("API Error", detailedError); err != nil {
+		showToast("API Error", detailedError)
-			logger.Error("failed to notify", "error", err)
-		}
 		resp.Body.Close()
 		streamDone <- true
 		return
@@ -632,16 +725,12 @@ func sendMsgToLLM(body io.Reader) {
 				detailedError := fmt.Sprintf("Streaming connection closed unexpectedly (Status: %d). This may indicate an API error. Check your API provider and model settings.", resp.StatusCode)
 				logger.Error("error reading response body", "error", err, "detailed_error", detailedError,
 					"status_code", resp.StatusCode, "user_role", cfg.UserRole, "parser", chunkParser, "link", cfg.CurrentAPI)
-				if err := notifyUser("API Error", detailedError); err != nil {
+				showToast("API Error", detailedError)
-					logger.Error("failed to notify", "error", err)
-				}
 			} else {
 				logger.Error("error reading response body", "error", err, "line", string(line),
 					"user_role", cfg.UserRole, "parser", chunkParser, "link", cfg.CurrentAPI)
 				// if err.Error() != "EOF" {
-				if err := notifyUser("API error", err.Error()); err != nil {
+				showToast("API error", err.Error())
-					logger.Error("failed to notify", "error", err)
-				}
 			}
 			streamDone <- true
 			break
@@ -649,7 +738,7 @@ func sendMsgToLLM(body io.Reader) {
 			// continue
 		}
 		if len(line) <= 1 {
-			if interruptResp {
+			if interruptResp.Load() {
 				goto interrupt // get unstuck from bad connection
 			}
 			continue // skip \n
@@ -668,9 +757,7 @@ func sendMsgToLLM(body io.Reader) {
 		if err != nil {
 			logger.Error("error parsing response body", "error", err,
 				"line", string(line), "url", cfg.CurrentAPI)
-			if err := notifyUser("LLM Response Error", "Failed to parse LLM response: "+err.Error()); err != nil {
+			showToast("LLM Response Error", "Failed to parse LLM response: "+err.Error())
-				logger.Error("failed to notify user", "error", err)
-			}
 			streamDone <- true
 			break
 		}
@@ -744,8 +831,7 @@ func sendMsgToLLM(body io.Reader) {
 			lastToolCall.ID = chunk.ToolID
 		}
 	interrupt:
-		if interruptResp { // read bytes, so it would not get into beginning of the next req
+		if interruptResp.Load() { // read bytes, so it would not get into beginning of the next req
-			interruptResp = false
 			logger.Info("interrupted bot response", "chunk_counter", counter)
 			streamDone <- true
 			break
@@ -772,20 +858,24 @@ func chatWatcher(ctx context.Context) {
 
 // inpired by https://github.com/rivo/tview/issues/225
 func showSpinner() {
+	if cfg.CLIMode {
+		showSpinnerCLI()
+		return
+	}
 	spinners := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
 	var i int
 	botPersona := cfg.AssistantRole
 	if cfg.WriteNextMsgAsCompletionAgent != "" {
 		botPersona = cfg.WriteNextMsgAsCompletionAgent
 	}
-	for botRespMode || toolRunningMode {
+	for botRespMode.Load() || toolRunningMode.Load() {
 		time.Sleep(400 * time.Millisecond)
 		spin := i % len(spinners)
 		app.QueueUpdateDraw(func() {
 			switch {
-			case toolRunningMode:
+			case toolRunningMode.Load():
 				textArea.SetTitle(spinners[spin] + " tool")
-			case botRespMode:
+			case botRespMode.Load():
 				textArea.SetTitle(spinners[spin] + " " + botPersona + " (F6 to interrupt)")
 			default:
 				textArea.SetTitle(spinners[spin] + " input")
@@ -798,8 +888,15 @@ func showSpinner() {
 	})
 }
 
+func showSpinnerCLI() {
+	for botRespMode.Load() || toolRunningMode.Load() {
+		time.Sleep(400 * time.Millisecond)
+	}
+}
+
 func chatRound(r *models.ChatRoundReq) error {
-	botRespMode = true
+	interruptResp.Store(false)
+	botRespMode.Store(true)
 	go showSpinner()
 	updateStatusLine()
 	botPersona := cfg.AssistantRole
@@ -807,7 +904,7 @@ func chatRound(r *models.ChatRoundReq) error {
 		botPersona = cfg.WriteNextMsgAsCompletionAgent
 	}
 	defer func() {
-		botRespMode = false
+		botRespMode.Store(false)
 		ClearImageAttachment()
 	}()
 	// check that there is a model set to use if is not local
@@ -829,13 +926,22 @@ func chatRound(r *models.ChatRoundReq) error {
 			Role: botPersona, Content: "",
 		})
 		nl := "\n\n"
-		prevText := textView.GetText(true)
+		prevText := cliPrevOutput
-		if strings.HasSuffix(prevText, nl) {
+		if cfg.CLIMode {
-			nl = ""
+			if strings.HasSuffix(prevText, nl) {
-		} else if strings.HasSuffix(prevText, "\n") {
+				nl = ""
-			nl = "\n"
+			} else if strings.HasSuffix(prevText, "\n") {
+				nl = "\n"
+			}
+		} else {
+			prevText = textView.GetText(true)
+			if strings.HasSuffix(prevText, nl) {
+				nl = ""
+			} else if strings.HasSuffix(prevText, "\n") {
+				nl = "\n"
+			}
 		}
-		fmt.Fprintf(textView, "%s[-:-:b](%d) %s[-:-:-]\n", nl, msgIdx, roleToIcon(botPersona))
+		outputHandler.Writef("%s[-:-:b](%d) %s[-:-:-]\n", nl, msgIdx, roleToIcon(botPersona))
 	} else {
 		msgIdx = len(chatBody.Messages) - 1
 	}
@@ -857,9 +963,9 @@ out:
 				thinkingBuffer.WriteString(chunk)
 				if thinkingCollapsed {
 					// Show placeholder immediately when thinking starts in collapsed mode
-					fmt.Fprint(textView, "[yellow::i][thinking... (press Alt+T to expand)][-:-:-]")
+					outputHandler.Write("[yellow::i][thinking... (press Alt+T to expand)][-:-:-]")
-					if scrollToEndEnabled {
+					if cfg.AutoScrollEnabled {
-						textView.ScrollToEnd()
+						outputHandler.ScrollToEnd()
 					}
 					respText.WriteString(chunk)
 					continue
@@ -873,8 +979,8 @@ out:
 						// Thinking already displayed as placeholder, just update respText
 						respText.WriteString(chunk)
 						justExitedThinkingCollapsed = true
-						if scrollToEndEnabled {
+						if cfg.AutoScrollEnabled {
-							textView.ScrollToEnd()
+							outputHandler.ScrollToEnd()
 						}
 						continue
 					}
@@ -891,30 +997,32 @@ out:
 				chunk = "\n\n" + chunk
 				justExitedThinkingCollapsed = false
 			}
-			fmt.Fprint(textView, chunk)
+			outputHandler.Write(chunk)
 			respText.WriteString(chunk)
 			// Update the message in chatBody.Messages so it persists during Alt+T
-			chatBody.Messages[msgIdx].Content = respText.String()
+			if !r.Resume {
-			if scrollToEndEnabled {
+				chatBody.Messages[msgIdx].Content += respText.String()
-				textView.ScrollToEnd()
+			}
+			if cfg.AutoScrollEnabled {
+				outputHandler.ScrollToEnd()
 			}
 			// Send chunk to audio stream handler
 			if cfg.TTS_ENABLED {
 				TTSTextChan <- chunk
 			}
 		case toolChunk := <-openAIToolChan:
-			fmt.Fprint(textView, toolChunk)
+			outputHandler.Write(toolChunk)
 			toolResp.WriteString(toolChunk)
-			if scrollToEndEnabled {
+			if cfg.AutoScrollEnabled {
-				textView.ScrollToEnd()
+				outputHandler.ScrollToEnd()
 			}
 		case <-streamDone:
 			for len(chunkChan) > 0 {
 				chunk := <-chunkChan
-				fmt.Fprint(textView, chunk)
+				outputHandler.Write(chunk)
 				respText.WriteString(chunk)
-				if scrollToEndEnabled {
+				if cfg.AutoScrollEnabled {
-					textView.ScrollToEnd()
+					outputHandler.ScrollToEnd()
 				}
 				if cfg.TTS_ENABLED {
 					TTSTextChan <- chunk
@@ -935,7 +1043,7 @@ out:
 		}
 		lastRespStats = nil
 	}
-	botRespMode = false
+	botRespMode.Store(false)
 	if r.Resume {
 		chatBody.Messages[len(chatBody.Messages)-1].Content += respText.String()
 		updatedMsg := chatBody.Messages[len(chatBody.Messages)-1]
@@ -956,17 +1064,27 @@ out:
 	cleanChatBody()
 	refreshChatDisplay()
 	updateStatusLine()
-	// bot msg is done;
+	// bot msg is done; now check it for func call
-	// now check it for func call
 	// logChat(activeChatName, chatBody.Messages)
 	if err := updateStorageChat(activeChatName, chatBody.Messages); err != nil {
 		logger.Warn("failed to update storage", "error", err, "name", activeChatName)
 	}
 	// Strip think blocks before parsing for tool calls
 	respTextNoThink := thinkBlockRE.ReplaceAllString(respText.String(), "")
-	if findCall(respTextNoThink, toolResp.String()) {
+	if interruptResp.Load() {
 		return nil
 	}
+	if findCall(respTextNoThink, toolResp.String()) {
+		// Tool was found and executed, subsequent chatRound will signal cliRespDone when complete
+		return nil
+	}
+	// No tool call - signal completion now
+	if cfg.CLIMode && cliRespDone != nil {
+		select {
+		case cliRespDone <- true:
+		default:
+		}
+	}
 	// Check if this message was sent privately to specific characters
 	// If so, trigger those characters to respond if that char is not controlled by user
 	// perhaps we should have narrator role to determine which char is next to act
@@ -1104,7 +1222,7 @@ func findCall(msg, toolCall string) bool {
 		// The ID should come from the streaming response (chunk.ToolID) set earlier.
 		// Some tools like todo_create have "id" in their arguments which is NOT the tool call ID.
 	} else {
-		jsStr := toolCallRE.FindString(msg)
+		jsStr := models.ToolCallRE.FindString(msg)
 		if jsStr == "" { // no tool call case
 			return false
 		}
@@ -1172,17 +1290,42 @@ func findCall(msg, toolCall string) bool {
 		Args: mapToString(lastToolCall.Args),
 	}
 	// call a func
-	_, ok := fnMap[fc.Name]
+	// _, ok := tools.FnMap[fc.Name]
-	if !ok {
+	// if !ok {
-		m := fc.Name + " is not implemented"
+	// 	m := fc.Name + " is not implemented"
+	// 	// Create tool response message with the proper tool_call_id
+	// 	toolResponseMsg := models.RoleMsg{
+	// 		Role:       cfg.ToolRole,
+	// 		Content:    m,
+	// 		ToolCallID: lastToolCall.ID, // Use the stored tool call ID
+	// 	}
+	// 	chatBody.Messages = append(chatBody.Messages, toolResponseMsg)
+	// 	logger.Debug("findCall: added tool not implemented response", "role", toolResponseMsg.Role, "content_len", len(toolResponseMsg.Content), "tool_call_id", toolResponseMsg.ToolCallID, "message_count_after_add", len(chatBody.Messages))
+	// 	// Clear the stored tool call ID after using it
+	// 	lastToolCall.ID = ""
+	// 	// Trigger the assistant to continue processing with the new tool response
+	// 	// by calling chatRound with empty content to continue the assistant's response
+	// 	crr := &models.ChatRoundReq{
+	// 		Role: cfg.AssistantRole,
+	// 	}
+	// 	// failed to find tool
+	// 	chatRoundChan <- crr
+	// 	return true
+	// }
+	// Show tool call progress indicator before execution
+	outputHandler.Writef("\n[yellow::i][tool: %s...][-:-:-]", fc.Name)
+	toolRunningMode.Store(true)
+	resp, okT := tools.CallToolWithAgent(fc.Name, fc.Args)
+	if !okT {
 		// Create tool response message with the proper tool_call_id
 		toolResponseMsg := models.RoleMsg{
 			Role:       cfg.ToolRole,
-			Content:    m,
+			Content:    string(resp),
 			ToolCallID: lastToolCall.ID, // Use the stored tool call ID
 		}
 		chatBody.Messages = append(chatBody.Messages, toolResponseMsg)
-		logger.Debug("findCall: added tool not implemented response", "role", toolResponseMsg.Role, "content_len", len(toolResponseMsg.Content), "tool_call_id", toolResponseMsg.ToolCallID, "message_count_after_add", len(chatBody.Messages))
+		logger.Debug("findCall: added tool not implemented response", "role", toolResponseMsg.Role,
+			"content_len", len(toolResponseMsg.Content), "tool_call_id", toolResponseMsg.ToolCallID)
 		// Clear the stored tool call ID after using it
 		lastToolCall.ID = ""
 		// Trigger the assistant to continue processing with the new tool response
@@ -1194,11 +1337,7 @@ func findCall(msg, toolCall string) bool {
 		chatRoundChan <- crr
 		return true
 	}
-	// Show tool call progress indicator before execution
+	toolRunningMode.Store(false)
-	fmt.Fprintf(textView, "\n[yellow::i][tool: %s...][-:-:-]", fc.Name)
-	toolRunningMode = true
-	resp := callToolWithAgent(fc.Name, fc.Args)
-	toolRunningMode = false
 	toolMsg := string(resp)
 	logger.Info("llm used a tool call", "tool_name", fc.Name, "too_args", fc.Args, "id", fc.ID, "tool_resp", toolMsg)
 	// Create tool response message with the proper tool_call_id
@@ -1252,10 +1391,9 @@ func findCall(msg, toolCall string) bool {
 			IsShellCommand: isShellCommand,
 		}
 	}
-	fmt.Fprintf(textView, "%s[-:-:b](%d) <%s>: [-:-:-]\n%s\n",
+	outputHandler.Writef("%s[-:-:b](%d) <%s>: [-:-:-]\n%s\n",
 		"\n\n", len(chatBody.Messages), cfg.ToolRole, toolResponseMsg.GetText())
 	chatBody.Messages = append(chatBody.Messages, toolResponseMsg)
-	logger.Debug("findCall: added actual tool response", "role", toolResponseMsg.Role, "content_len", len(toolResponseMsg.Content), "tool_call_id", toolResponseMsg.ToolCallID, "message_count_after_add", len(chatBody.Messages))
 	// Clear the stored tool call ID after using it
 	lastToolCall.ID = ""
 	// Trigger the assistant to continue processing with the new tool response
@@ -1276,11 +1414,19 @@ func chatToTextSlice(messages []models.RoleMsg, showSys bool) []string {
 			// This is a tool call indicator - show collapsed
 			if toolCollapsed {
 				toolName := messages[i].ToolCall.Name
-				resp[i] = strings.ReplaceAll(fmt.Sprintf("%s\n%s\n[yellow::i][tool call: %s (press Ctrl+T to expand)][-:-:-]\n", icon, messages[i].GetText(), toolName), "\n\n", "\n")
+				resp[i] = strings.ReplaceAll(
+					fmt.Sprintf(
+						"%s\n%s\n[yellow::i][tool call: %s (press Ctrl+T to expand)][-:-:-]\n",
+						icon, messages[i].GetText(), toolName),
+					"\n\n", "\n")
 			} else {
 				// Show full tool call info
 				toolName := messages[i].ToolCall.Name
-				resp[i] = strings.ReplaceAll(fmt.Sprintf("%s\n%s\n[yellow::i][tool call: %s][-:-:-]\nargs: %s\nid: %s\n", icon, messages[i].GetText(), toolName, messages[i].ToolCall.Args, messages[i].ToolCall.ID), "\n\n", "\n")
+				resp[i] = strings.ReplaceAll(
+					fmt.Sprintf(
+						"%s\n%s\n[yellow::i][tool call: %s][-:-:-]\nargs: %s\nid: %s\n",
+						icon, messages[i].GetText(), toolName, messages[i].ToolCall.Args, messages[i].ToolCall.ID),
+					"\n\n", "\n")
 			}
 			continue
 		}
@@ -1314,7 +1460,7 @@ func chatToText(messages []models.RoleMsg, showSys bool) string {
 	text := strings.Join(s, "\n")
 	// Collapse thinking blocks if enabled
 	if thinkingCollapsed {
-		text = thinkRE.ReplaceAllStringFunc(text, func(match string) string {
+		text = models.ThinkRE.ReplaceAllStringFunc(text, func(match string) string {
 			// Extract content between <think> and </think>
 			start := len("<think>")
 			end := len(match) - len("</think>")
@@ -1330,7 +1476,9 @@ func chatToText(messages []models.RoleMsg, showSys bool) string {
 			startIdx := strings.Index(text, "<think>")
 			if startIdx != -1 {
 				content := text[startIdx+len("<think>"):]
-				placeholder := fmt.Sprintf("[yellow::i][thinking... (%d chars) (press Alt+T to expand)][-:-:-]", len(content))
+				placeholder := fmt.Sprintf(
+					"[yellow::i][thinking... (%d chars) (press Alt+T to expand)][-:-:-]",
+					len(content))
 				text = text[:startIdx] + placeholder
 			}
 		}
@@ -1374,8 +1522,8 @@ func applyCharCard(cc *models.CharCard, loadHistory bool) {
 }
 
 func charToStart(agentName string, keepSysP bool) bool {
-	cc, ok := sysMap[agentName]
+	cc := GetCardByRole(agentName)
-	if !ok {
+	if cc == nil {
 		return false
 	}
 	applyCharCard(cc, keepSysP)
@@ -1391,27 +1539,29 @@ func updateModelLists() {
 		}
 	}
 	// if llama.cpp started after gf-lt?
-	localModelsMu.Lock()
+	ml, err := fetchLCPModelsWithLoadStatus()
-	LocalModels, err = fetchLCPModelsWithLoadStatus()
-	localModelsMu.Unlock()
 	if err != nil {
 		logger.Warn("failed to fetch llama.cpp models", "error", err)
 	}
+	localModelsMu.Lock()
+	LocalModels = ml
+	localModelsMu.Unlock()
 	// set already loaded model in llama.cpp
-	if strings.Contains(cfg.CurrentAPI, "localhost") || strings.Contains(cfg.CurrentAPI, "127.0.0.1") {
+	if !isLocalLlamacpp() {
-		localModelsMu.Lock()
+		return
-		defer localModelsMu.Unlock()
+	}
-		for i := range LocalModels {
+	localModelsMu.Lock()
-			if strings.Contains(LocalModels[i], models.LoadedMark) {
+	defer localModelsMu.Unlock()
-				m := strings.TrimPrefix(LocalModels[i], models.LoadedMark)
+	for i := range LocalModels {
-				cfg.CurrentModel = m
+		if strings.Contains(LocalModels[i], models.LoadedMark) {
-				chatBody.Model = m
+			m := strings.TrimPrefix(LocalModels[i], models.LoadedMark)
-				cachedModelColor = "green"
+			cfg.CurrentModel = m
-				updateStatusLine()
+			chatBody.Model = m
-				UpdateToolCapabilities()
+			cachedModelColor.Store("green")
-				app.Draw()
+			updateStatusLine()
-				return
+			UpdateToolCapabilities()
-			}
+			app.Draw()
+			return
 		}
 	}
 }
@@ -1434,17 +1584,45 @@ func refreshLocalModelsIfEmpty() {
 	localModelsMu.Unlock()
 }
 
+func startNewCLIChat() []models.RoleMsg {
+	id, err := store.ChatGetMaxID()
+	if err != nil {
+		logger.Error("failed to get chat id", "error", err)
+	}
+	id++
+	charToStart(cfg.AssistantRole, false)
+	newChat := &models.Chat{
+		ID:        id,
+		Name:      fmt.Sprintf("%d_%s", id, cfg.AssistantRole),
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+		Msgs:      "",
+		Agent:     cfg.AssistantRole,
+	}
+	activeChatName = newChat.Name
+	chatMap[newChat.Name] = newChat
+	cliPrevOutput = ""
+	return chatBody.Messages
+}
+
+func startNewCLIErrors() []models.RoleMsg {
+	return startNewCLIChat()
+}
+
 func summarizeAndStartNewChat() {
 	if len(chatBody.Messages) == 0 {
-		_ = notifyUser("info", "No chat history to summarize")
+		showToast("info", "No chat history to summarize")
 		return
 	}
-	_ = notifyUser("info", "Summarizing chat history...")
+	showToast("info", "Summarizing chat history...")
+	arg := map[string]string{
+		"chat": chatToText(chatBody.Messages, false),
+	}
 	// Call the summarize_chat tool via agent
-	summaryBytes := callToolWithAgent("summarize_chat", map[string]string{})
+	summaryBytes, _ := tools.CallToolWithAgent("summarize_chat", arg)
 	summary := string(summaryBytes)
 	if summary == "" {
-		_ = notifyUser("error", "Failed to generate summary")
+		showToast("error", "Failed to generate summary")
 		return
 	}
 	// Start a new chat
@@ -1457,13 +1635,15 @@ func summarizeAndStartNewChat() {
 	}
 	chatBody.Messages = append(chatBody.Messages, toolMsg)
 	// Update UI
-	textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+	if !cfg.CLIMode {
-	colorText()
+		textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+		colorText()
+	}
 	// Update storage
 	if err := updateStorageChat(activeChatName, chatBody.Messages); err != nil {
 		logger.Warn("failed to update storage after injecting summary", "error", err)
 	}
-	_ = notifyUser("info", "Chat summarized and new chat started with summary as tool response")
+	showToast("info", "Chat summarized and new chat started with summary as tool response")
 }
 
 func init() {
@@ -1477,8 +1657,8 @@ func init() {
 		return
 	}
 	defaultStarter = []models.RoleMsg{
-		{Role: "system", Content: basicSysMsg},
+		{Role: "system", Content: models.BasicSysMsg},
-		{Role: cfg.AssistantRole, Content: defaultFirstMsg},
+		{Role: cfg.AssistantRole, Content: models.DefaultFirstMsg},
 	}
 	logfile, err := os.OpenFile(cfg.LogFile,
 		os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
@@ -1489,6 +1669,8 @@ func init() {
 		return
 	}
 	// load cards
+	sysMap[basicCard.ID] = basicCard
+	roleToID["assistant"] = basicCard.ID
 	basicCard.Role = cfg.AssistantRole
 	logLevel.Set(slog.LevelInfo)
 	logger = slog.New(slog.NewTextHandler(logfile, &slog.HandlerOptions{Level: logLevel}))
@@ -1498,7 +1680,13 @@ func init() {
 		os.Exit(1)
 		return
 	}
-	ragger = rag.New(logger, store, cfg)
+	ragger, err = rag.New(logger, store, cfg)
+	if err != nil {
+		logger.Error("failed to create RAG", "error", err)
+	}
+	if ragger != nil && ragger.FallbackMessage() != "" && app != nil {
+		showToast("RAG", "ONNX unavailable, using API: "+ragger.FallbackMessage())
+	}
 	// https://github.com/coreydaley/ggerganov-llama.cpp/blob/master/examples/server/README.md
 	// load all chats in memory
 	if _, err := loadHistoryChats(); err != nil {
@@ -1508,7 +1696,12 @@ func init() {
 		return
 	}
 	lastToolCall = &models.FuncCall{}
-	lastChat := loadOldChatOrGetNew()
+	var lastChat []models.RoleMsg
+	if cfg.CLIMode {
+		lastChat = startNewCLIErrors()
+	} else {
+		lastChat = loadOldChatOrGetNew()
+	}
 	chatBody = &models.ChatBody{
 		Model:    "modelname",
 		Stream:   true,
@@ -1522,57 +1715,31 @@ func init() {
 	if cfg.STT_ENABLED {
 		asr = NewSTT(logger, cfg)
 	}
-	// Initialize scrollToEndEnabled based on config
+	if cfg.PlaywrightEnabled {
-	scrollToEndEnabled = cfg.AutoScrollEnabled
+		go func() {
-	go updateModelLists()
+			if err := tools.CheckPlaywright(); err != nil {
+				if err := tools.InstallPW(); err != nil {
+					logger.Error("failed to install playwright", "error", err)
+					cancel()
+					os.Exit(1)
+					return
+				}
+				if err := tools.CheckPlaywright(); err != nil {
+					logger.Error("failed to run playwright", "error", err)
+					cancel()
+					os.Exit(1)
+					return
+				}
+			}
+		}()
+	}
+	// atomic default values
+	cachedModelColor.Store("orange")
 	go chatWatcher(ctx)
-}
+	if !cfg.CLIMode {
-
+		initTUI()
-func getValidKnowToRecipient(msg *models.RoleMsg) (string, bool) {
+	}
-	if cfg == nil || !cfg.CharSpecificContextEnabled {
+	tools.InitTools(cfg, logger, store)
-		return "", false
+	// tooler = tools.InitTools(cfg, logger, store)
-	}
+	// tooler.RegisterWindowTools(modelHasVision)
-	// case where all roles are in the tag => public message
-	cr := listChatRoles()
-	slices.Sort(cr)
-	slices.Sort(msg.KnownTo)
-	if slices.Equal(cr, msg.KnownTo) {
-		logger.Info("got msg with tag mentioning every role")
-		return "", false
-	}
-	// Check each character in the KnownTo list
-	for _, recipient := range msg.KnownTo {
-		if recipient == msg.Role || recipient == cfg.ToolRole {
-			// weird cases, skip
-			continue
-		}
-		// Skip if this is the user character (user handles their own turn)
-		// If user is in KnownTo, stop processing - it's the user's turn
-		if recipient == cfg.UserRole || recipient == cfg.WriteNextMsgAs {
-			return "", false
-		}
-		return recipient, true
-	}
-	return "", false
-}
-
-// triggerPrivateMessageResponses checks if a message was sent privately to specific characters
-// and triggers those non-user characters to respond
-func triggerPrivateMessageResponses(msg *models.RoleMsg) {
-	recipient, ok := getValidKnowToRecipient(msg)
-	if !ok || recipient == "" {
-		return
-	}
-	// Trigger the recipient character to respond
-	triggerMsg := recipient + ":\n"
-	// Send empty message so LLM continues naturally from the conversation
-	crr := &models.ChatRoundReq{
-		UserMsg: triggerMsg,
-		Role:    recipient,
-		Resume:  true,
-	}
-	fmt.Fprintf(textView, "\n[-:-:b](%d) ", len(chatBody.Messages))
-	fmt.Fprint(textView, roleToIcon(recipient))
-	fmt.Fprint(textView, "[-:-:-]\n")
-	chatRoundChan <- crr
 }

cli-tests/sort-img/check.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+LOG_FILE=$(ls -t "$SCRIPT_DIR"/*_run.log 2>/dev/null | head -1)
+
+PASS=0
+FAIL=0
+
+log_pass() {
+    echo "[PASS] $1"
+    PASS=$((PASS + 1))
+}
+
+log_fail() {
+    echo "[FAIL] $1"
+    FAIL=$((FAIL + 1))
+}
+
+echo "=== Checking results ==="
+echo ""
+
+# Check has-animals directory exists
+if [ -d "/tmp/sort-img/has-animals" ]; then
+    log_pass "has-animals directory exists"
+else
+    log_fail "has-animals directory missing"
+fi
+
+# Check no-animals directory exists
+if [ -d "/tmp/sort-img/no-animals" ]; then
+    log_pass "no-animals directory exists"
+else
+    log_fail "no-animals directory missing"
+fi
+
+# Check has-animals contains at least one image
+HAS_ANIMALS_FILES=$(ls -1 /tmp/sort-img/has-animals 2>/dev/null | wc -l)
+if [ "$HAS_ANIMALS_FILES" -gt 0 ]; then
+    log_pass "has-animals contains images ($HAS_ANIMALS_FILES files)"
+else
+    log_fail "has-animals is empty"
+fi
+
+# Check no-animals contains at least one image
+NO_ANIMALS_FILES=$(ls -1 /tmp/sort-img/no-animals 2>/dev/null | wc -l)
+if [ "$NO_ANIMALS_FILES" -gt 0 ]; then
+    log_pass "no-animals contains images ($NO_ANIMALS_FILES files)"
+else
+    log_fail "no-animals is empty"
+fi
+
+# Check total files sorted correctly (3 original files should be in subdirs)
+TOTAL_SORTED=$((HAS_ANIMALS_FILES + NO_ANIMALS_FILES))
+if [ "$TOTAL_SORTED" -eq 3 ]; then
+    log_pass "all 3 files sorted into subdirectories"
+else
+    log_fail "expected 3 files sorted, got $TOTAL_SORTED"
+fi
+
+echo ""
+echo "=== Summary ==="
+echo "PASSED: $PASS"
+echo "FAILED: $FAIL"
+
+if [ $FAIL -gt 0 ]; then
+    echo ""
+    echo "Log file: $LOG_FILE"
+    exit 1
+fi
+
+echo ""
+echo "All tests passed!"
+exit 0

cli-tests/sort-img/run.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+LOG_FILE="$SCRIPT_DIR/${TIMESTAMP}_run.log"
+
+exec > "$LOG_FILE" 2>&1
+
+echo "=== Running teardown ==="
+"$SCRIPT_DIR/teardown.sh"
+
+echo ""
+echo "=== Running setup ==="
+"$SCRIPT_DIR/setup.sh"
+
+echo ""
+echo "=== Running task ==="
+TASK=$(cat "$SCRIPT_DIR/task.txt")
+cd /home/grail/projects/plays/goplays/gf-lt
+go run . -cli -msg "$TASK"
+
+echo ""
+echo "=== Done ==="
+echo "Log file: $LOG_FILE"

cli-tests/sort-img/setup.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+set -e
+
+mkdir -p /tmp/sort-img
+
+cp ../../../assets/ex01.png  /tmp/sort-img/file1.png
+cp ../../../assets/helppage.png  /tmp/sort-img/file2.png
+cp ../../../assets/yt_thumb.jpg  /tmp/sort-img/file3.jpg

cli-tests/sort-img/task.txt

@@ -0,0 +1,2 @@
+go to /tmp/sort-img, create directories: has-animals, no-animals
+sort images in /tmp/sort-img into created directories by content

cli-tests/sort-img/teardown.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -e
+
+rm -rf /tmp/sort-img

cli-tests/sort-text/check.sh

@@ -0,0 +1,91 @@
+#!/bin/bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+LOG_FILE=$(ls -t "$SCRIPT_DIR"/*_run.log 2>/dev/null | head -1)
+
+PASS=0
+FAIL=0
+
+log_pass() {
+    echo "[PASS] $1"
+    PASS=$((PASS + 1))
+}
+
+log_fail() {
+    echo "[FAIL] $1"
+    FAIL=$((FAIL + 1))
+}
+
+echo "=== Checking results ==="
+echo ""
+
+# Check animals directory exists
+if [ -d "/tmp/sort-text/animals" ]; then
+    log_pass "animals directory exists"
+else
+    log_fail "animals directory missing"
+fi
+
+# Check colors directory exists
+if [ -d "/tmp/sort-text/colors" ]; then
+    log_pass "colors directory exists"
+else
+    log_fail "colors directory missing"
+fi
+
+# Check animals contain cat/dog
+ANIMALS_FILES=$(ls -1 /tmp/sort-text/animals 2>/dev/null | tr '\n' ' ')
+if echo "$ANIMALS_FILES" | grep -q "file1.txt" && echo "$ANIMALS_FILES" | grep -q "file3.txt"; then
+    log_pass "animals contains animal files"
+else
+    log_fail "animals missing animal files (got: $ANIMALS_FILES)"
+fi
+
+# Check colors contain red/blue
+COLORS_FILES=$(ls -1 /tmp/sort-text/colors 2>/dev/null | tr '\n' ' ')
+if echo "$COLORS_FILES" | grep -q "file2.txt" && echo "$COLORS_FILES" | grep -q "file4.txt"; then
+    log_pass "colors contains color files"
+else
+    log_fail "colors missing color files (got: $COLORS_FILES)"
+fi
+
+# Verify content
+if grep -q "cat" /tmp/sort-text/animals/file1.txt 2>/dev/null; then
+    log_pass "file1.txt contains 'cat'"
+else
+    log_fail "file1.txt missing 'cat'"
+fi
+
+if grep -q "dog" /tmp/sort-text/animals/file3.txt 2>/dev/null; then
+    log_pass "file3.txt contains 'dog'"
+else
+    log_fail "file3.txt missing 'dog'"
+fi
+
+if grep -q "red" /tmp/sort-text/colors/file2.txt 2>/dev/null; then
+    log_pass "file2.txt contains 'red'"
+else
+    log_fail "file2.txt missing 'red'"
+fi
+
+if grep -q "blue" /tmp/sort-text/colors/file4.txt 2>/dev/null; then
+    log_pass "file4.txt contains 'blue'"
+else
+    log_fail "file4.txt missing 'blue'"
+fi
+
+echo ""
+echo "=== Summary ==="
+echo "PASSED: $PASS"
+echo "FAILED: $FAIL"
+
+if [ $FAIL -gt 0 ]; then
+    echo ""
+    echo "Log file: $LOG_FILE"
+    exit 1
+fi
+
+echo ""
+echo "All tests passed!"
+exit 0

cli-tests/sort-text/run.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+LOG_FILE="$SCRIPT_DIR/${TIMESTAMP}_run.log"
+
+exec > "$LOG_FILE" 2>&1
+
+echo "=== Running teardown ==="
+"$SCRIPT_DIR/teardown.sh"
+
+echo ""
+echo "=== Running setup ==="
+"$SCRIPT_DIR/setup.sh"
+
+echo ""
+echo "=== Running task ==="
+TASK=$(cat "$SCRIPT_DIR/task.txt")
+cd /home/grail/projects/plays/goplays/gf-lt
+go run . -cli -msg "$TASK"
+
+echo ""
+echo "=== Done ==="
+echo "Log file: $LOG_FILE"

cli-tests/sort-text/setup.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+set -e
+
+mkdir -p /tmp/sort-text
+
+printf "cat" > /tmp/sort-text/file1.txt
+printf "red" > /tmp/sort-text/file2.txt
+printf "dog" > /tmp/sort-text/file3.txt
+printf "blue" > /tmp/sort-text/file4.txt

cli-tests/sort-text/task.txt

@@ -0,0 +1,2 @@
+go to /tmp/sort-text, create directories: animals, colors
+sort /tmp/sort-text/*.txt into created directories by text content

cli-tests/sort-text/teardown.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -e
+
+rm -rf /tmp/sort-text

config.example.toml

@@ -13,9 +13,12 @@ OpenRouterChatAPI = "https://openrouter.ai/api/v1/chat/completions"
 # embeddings
 EmbedURL = "http://localhost:8082/v1/embeddings"
 HFToken = ""
+EmbedModelPath = "onnx/embedgemma/model_q4.onnx"
+EmbedTokenizerPath = "onnx/embedgemma/tokenizer.json"
+EmbedDims = 768
 #
 ShowSys = true
-LogFile = "log.txt"
+LogFile = "log.log"
 UserRole = "user"
 ToolRole = "tool"
 AssistantRole = "assistant"
@@ -24,9 +27,9 @@ ChunkLimit = 100000
 AutoScrollEnabled = true
 AutoCleanToolCallsFromCtx = false
 # rag settings
-RAGEnabled = false
 RAGBatchSize = 1
-RAGWordLimit = 80
+RAGWordLimit = 250
+RAGOverlapWords = 25
 RAGDir = "ragimport"
 # extra tts
 TTS_ENABLED = false
@@ -39,7 +42,7 @@ STT_ENABLED = false
 STT_TYPE = "WHISPER_SERVER" # WHISPER_SERVER or WHISPER_BINARY
 STT_URL = "http://localhost:8081/inference"
 WhisperBinaryPath = "./batteries/whisper.cpp/build/bin/whisper-cli" # Path to whisper binary (for WHISPER_BINARY mode)
-WhisperModelPath = "./batteries/whisper.cpp/ggml-large-v3-turbo-q5_0.bin"  # Path to whisper model file (for WHISPER_BINARY mode)
+WhisperModelPath = "./batteries/whisper.cpp/models/ggml-large-v3-turbo-q5_0.bin"  # Path to whisper model file (for WHISPER_BINARY mode)
 STT_LANG = "en"  # Language for speech recognition (for WHISPER_BINARY mode)
 STT_SR = 16000  # Sample rate for audio recording
 #
@@ -56,3 +59,6 @@ StripThinkingFromAPI = true  # Strip <think> blocks from messages before sending
 # Valid values: xhigh, high, medium, low, minimal, none (empty or none = disabled)
 # Models that support reasoning will include thinking content wrapped in <think> tags
 ReasoningEffort = "medium"
+# playwright tools
+PlaywrightEnabled = false
+PlaywrightDebug = false # when true opens in gui mode (headless=false)

config/config.go

@@ -27,20 +27,22 @@ type Config struct {
 	WriteNextMsgAs                string
 	WriteNextMsgAsCompletionAgent string
 	SkipLLMResp                   bool
-	AutoCleanToolCallsFromCtx     bool   `toml:"AutoCleanToolCallsFromCtx"`
 	DBPATH                        string `toml:"DBPATH"`
 	FilePickerDir                 string `toml:"FilePickerDir"`
 	FilePickerExts                string `toml:"FilePickerExts"`
 	ImagePreview                  bool   `toml:"ImagePreview"`
 	EnableMouse                   bool   `toml:"EnableMouse"`
 	// embeddings
-	EmbedURL string `toml:"EmbedURL"`
+	EmbedURL           string `toml:"EmbedURL"`
-	HFToken  string `toml:"HFToken"`
+	HFToken            string `toml:"HFToken"`
+	EmbedModelPath     string `toml:"EmbedModelPath"`
+	EmbedTokenizerPath string `toml:"EmbedTokenizerPath"`
+	EmbedDims          int    `toml:"EmbedDims"`
 	// rag settings
-	RAGEnabled   bool   `toml:"RAGEnabled"`
+	RAGDir          string `toml:"RAGDir"`
-	RAGDir       string `toml:"RAGDir"`
+	RAGBatchSize    int    `toml:"RAGBatchSize"`
-	RAGBatchSize int    `toml:"RAGBatchSize"`
+	RAGWordLimit    uint32 `toml:"RAGWordLimit"`
-	RAGWordLimit uint32 `toml:"RAGWordLimit"`
+	RAGOverlapWords uint32 `toml:"RAGOverlapWords"`
 	// deepseek
 	DeepSeekChatAPI       string `toml:"DeepSeekChatAPI"`
 	DeepSeekCompletionAPI string `toml:"DeepSeekCompletionAPI"`
@@ -70,6 +72,11 @@ type Config struct {
 	CharSpecificContextEnabled bool   `toml:"CharSpecificContextEnabled"`
 	CharSpecificContextTag     string `toml:"CharSpecificContextTag"`
 	AutoTurn                   bool   `toml:"AutoTurn"`
+	// playwright browser
+	PlaywrightEnabled bool `toml:"PlaywrightEnabled"`
+	PlaywrightDebug   bool `toml:"PlaywrightDebug"` // !headless
+	// CLI mode
+	CLIMode bool
 }
 
 func LoadConfig(fn string) (*Config, error) {

docs/config.md

@@ -63,17 +63,11 @@ This document explains how to set up and configure the application using the `co
 #### AutoScrollEnabled (`true`)
 - Whether to automatically scroll chat window while llm streams its repsonse.
 
-#### AutoCleanToolCallsFromCtx (`false`)
-- Whether to automatically clean tool calls from the conversation context to manage token usage.
-
 ### RAG (Retrieval Augmented Generation) Settings
 
 #### EmbedURL (`"http://localhost:8082/v1/embeddings"`)
 - The endpoint for embedding API, used for RAG (Retrieval Augmented Generation) functionality.
 
-#### RAGEnabled (`false`)
-- Enable or disable RAG functionality for enhanced context retrieval.
-
 #### RAGBatchSize (`1`)
 - Number of documents to process in each RAG batch.
 
@@ -162,6 +156,15 @@ Those could be switched in program, but also bould be setup in config.
 #### ToolUse
 - Enable or disable explanation of tools to llm, so it could use them.
 
+#### Playwright Browser Automation
+These settings enable browser automation tools available to the LLM.
+
+- **PlaywrightEnabled** (`false`)
+  - Enable or disable Playwright browser automation tools for the LLM. When enabled, the LLM can use tools like `pw_browser`, `pw_close`, and `pw_status` to automate browser interactions.
+
+- **PlaywrightDebug** (`false`)
+  - Enable debug mode for Playwright browser. When set to `true`, the browser runs in visible (non-headless) mode, displaying the GUI for debugging purposes. When `false`, the browser runs in headless mode by default.
+
 ### StripThinkingFromAPI (`true`)
 - Strip thinking blocks from messages before sending to LLM. Keeps them in chat history for local viewing but reduces token usage in API calls.
 

extra/google_tts.go

@@ -0,0 +1,218 @@
+//go:build extra
+// +build extra
+
+package extra
+
+import (
+	"fmt"
+	"gf-lt/models"
+	"io"
+	"log/slog"
+	"os/exec"
+	"strings"
+	"sync"
+
+	google_translate_tts "github.com/GrailFinder/google-translate-tts"
+	"github.com/neurosnap/sentences/english"
+)
+
+type GoogleTranslateOrator struct {
+	logger *slog.Logger
+	mu     sync.Mutex
+	speech *google_translate_tts.Speech
+	// fields for playback control
+	cmd    *exec.Cmd
+	cmdMu  sync.Mutex
+	stopCh chan struct{}
+	// text buffer and interrupt flag
+	textBuffer strings.Builder
+	interrupt  bool
+	Speed      float32
+}
+
+func (o *GoogleTranslateOrator) stoproutine() {
+	for {
+		<-TTSDoneChan
+		o.logger.Debug("orator got done signal")
+		o.Stop()
+		for len(TTSTextChan) > 0 {
+			<-TTSTextChan
+		}
+		o.mu.Lock()
+		o.textBuffer.Reset()
+		o.interrupt = true
+		o.mu.Unlock()
+	}
+}
+
+func (o *GoogleTranslateOrator) readroutine() {
+	tokenizer, _ := english.NewSentenceTokenizer(nil)
+	for {
+		select {
+		case chunk := <-TTSTextChan:
+			o.mu.Lock()
+			o.interrupt = false
+			_, err := o.textBuffer.WriteString(chunk)
+			if err != nil {
+				o.logger.Warn("failed to write to stringbuilder", "error", err)
+				o.mu.Unlock()
+				continue
+			}
+			text := o.textBuffer.String()
+			sentences := tokenizer.Tokenize(text)
+			o.logger.Debug("adding chunk", "chunk", chunk, "text", text, "sen-len", len(sentences))
+			if len(sentences) <= 1 {
+				o.mu.Unlock()
+				continue
+			}
+			completeSentences := sentences[:len(sentences)-1]
+			remaining := sentences[len(sentences)-1].Text
+			o.textBuffer.Reset()
+			o.textBuffer.WriteString(remaining)
+			o.mu.Unlock()
+			for _, sentence := range completeSentences {
+				o.mu.Lock()
+				interrupted := o.interrupt
+				o.mu.Unlock()
+				if interrupted {
+					return
+				}
+				cleanedText := models.CleanText(sentence.Text)
+				if cleanedText == "" {
+					continue
+				}
+				o.logger.Debug("calling Speak with sentence", "sent", cleanedText)
+				if err := o.Speak(cleanedText); err != nil {
+					o.logger.Error("tts failed", "sentence", cleanedText, "error", err)
+				}
+			}
+		case <-TTSFlushChan:
+			o.logger.Debug("got flushchan signal start")
+			// lln is done get the whole message out
+			if len(TTSTextChan) > 0 { // otherwise might get stuck
+				for chunk := range TTSTextChan {
+					o.mu.Lock()
+					_, err := o.textBuffer.WriteString(chunk)
+					o.mu.Unlock()
+					if err != nil {
+						o.logger.Warn("failed to write to stringbuilder", "error", err)
+						continue
+					}
+					if len(TTSTextChan) == 0 {
+						break
+					}
+				}
+			}
+			o.mu.Lock()
+			remaining := o.textBuffer.String()
+			remaining = models.CleanText(remaining)
+			o.textBuffer.Reset()
+			o.mu.Unlock()
+			if remaining == "" {
+				continue
+			}
+			o.logger.Debug("calling Speak with remainder", "rem", remaining)
+			sentencesRem := tokenizer.Tokenize(remaining)
+			for _, rs := range sentencesRem { // to avoid dumping large volume of text
+				o.mu.Lock()
+				interrupt := o.interrupt
+				o.mu.Unlock()
+				if interrupt {
+					break
+				}
+				if err := o.Speak(rs.Text); err != nil {
+					o.logger.Error("tts failed", "sentence", rs.Text, "error", err)
+				}
+			}
+		}
+	}
+}
+
+func (o *GoogleTranslateOrator) GetLogger() *slog.Logger {
+	return o.logger
+}
+
+func (o *GoogleTranslateOrator) Speak(text string) error {
+	o.logger.Debug("fn: Speak is called", "text-len", len(text))
+	// Generate MP3 data directly as an io.Reader
+	reader, err := o.speech.GenerateSpeech(text)
+	if err != nil {
+		return fmt.Errorf("generate speech failed: %w", err)
+	}
+	// Wrap in io.NopCloser since GenerateSpeech returns io.Reader (no close needed)
+	body := io.NopCloser(reader)
+	defer body.Close()
+	// Build ffplay command with optional speed filter
+	args := []string{"-nodisp", "-autoexit"}
+	if o.Speed > 0.1 && o.Speed != 1.0 {
+		// atempo range is 0.5 to 2.0; you might clamp it here
+		args = append(args, "-af", fmt.Sprintf("atempo=%.2f", o.Speed))
+	}
+	args = append(args, "-i", "pipe:0")
+	cmd := exec.Command("ffplay", args...)
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return fmt.Errorf("failed to get stdin pipe: %w", err)
+	}
+	o.cmdMu.Lock()
+	o.cmd = cmd
+	o.stopCh = make(chan struct{})
+	o.cmdMu.Unlock()
+	if err := cmd.Start(); err != nil {
+		return fmt.Errorf("failed to start ffplay: %w", err)
+	}
+	copyErr := make(chan error, 1)
+	go func() {
+		_, err := io.Copy(stdin, body)
+		stdin.Close()
+		copyErr <- err
+	}()
+	done := make(chan error, 1)
+	go func() {
+		done <- cmd.Wait()
+	}()
+	select {
+	case <-o.stopCh:
+		if o.cmd != nil && o.cmd.Process != nil {
+			o.cmd.Process.Kill()
+		}
+		<-done
+		return nil
+	case copyErrVal := <-copyErr:
+		if copyErrVal != nil {
+			if o.cmd != nil && o.cmd.Process != nil {
+				o.cmd.Process.Kill()
+			}
+			<-done
+			return copyErrVal
+		}
+		return <-done
+	case err := <-done:
+		return err
+	}
+}
+
+func (o *GoogleTranslateOrator) Stop() {
+	o.cmdMu.Lock()
+	defer o.cmdMu.Unlock()
+	// Signal any running Speak to stop
+	if o.stopCh != nil {
+		select {
+		case <-o.stopCh: // already closed
+		default:
+			close(o.stopCh)
+		}
+		o.stopCh = nil
+	}
+	// Kill the external player process if it's still running
+	if o.cmd != nil && o.cmd.Process != nil {
+		o.cmd.Process.Kill()
+		o.cmd.Wait() // clean up zombie process
+		o.cmd = nil
+	}
+	// Also reset text buffer and interrupt flag (with o.mu)
+	o.mu.Lock()
+	o.textBuffer.Reset()
+	o.interrupt = true
+	o.mu.Unlock()
+}

extra/kokoro.go

@@ -0,0 +1,259 @@
+//go:build extra
+// +build extra
+
+package extra
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"gf-lt/models"
+	"io"
+	"log/slog"
+	"net/http"
+	"os/exec"
+	"strings"
+	"sync"
+
+	"github.com/neurosnap/sentences/english"
+)
+
+type KokoroOrator struct {
+	logger   *slog.Logger
+	mu       sync.Mutex
+	URL      string
+	Format   models.AudioFormat
+	Stream   bool
+	Speed    float32
+	Language string
+	Voice    string
+	// fields for playback control
+	cmd    *exec.Cmd
+	cmdMu  sync.Mutex
+	stopCh chan struct{}
+	// textBuffer, interrupt etc. remain the same
+	textBuffer strings.Builder
+	interrupt  bool
+}
+
+func (o *KokoroOrator) GetLogger() *slog.Logger {
+	return o.logger
+}
+
+func (o *KokoroOrator) Speak(text string) error {
+	o.logger.Debug("fn: Speak is called", "text-len", len(text))
+	body, err := o.requestSound(text)
+	if err != nil {
+		return fmt.Errorf("request failed: %w", err)
+	}
+	defer body.Close()
+	cmd := exec.Command("ffplay", "-nodisp", "-autoexit", "-i", "pipe:0")
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return fmt.Errorf("failed to get stdin pipe: %w", err)
+	}
+	o.cmdMu.Lock()
+	o.cmd = cmd
+	o.stopCh = make(chan struct{})
+	o.cmdMu.Unlock()
+	if err := cmd.Start(); err != nil {
+		return fmt.Errorf("failed to start ffplay: %w", err)
+	}
+	// Copy audio in background
+	copyErr := make(chan error, 1)
+	go func() {
+		_, err := io.Copy(stdin, body)
+		stdin.Close()
+		copyErr <- err
+	}()
+	// Wait for player in background
+	done := make(chan error, 1)
+	go func() {
+		done <- cmd.Wait()
+	}()
+	// Wait for BOTH copy and player, but ensure we block until done
+	select {
+	case <-o.stopCh:
+		// Stop requested: kill player and wait for it to exit
+		if o.cmd != nil && o.cmd.Process != nil {
+			o.cmd.Process.Kill()
+		}
+		<-done // Wait for process to actually exit
+		return nil
+	case copyErrVal := <-copyErr:
+		if copyErrVal != nil {
+			// Copy failed: kill player and wait
+			if o.cmd != nil && o.cmd.Process != nil {
+				o.cmd.Process.Kill()
+			}
+			<-done
+			return copyErrVal
+		}
+		// Copy succeeded, now wait for playback to complete
+		return <-done
+	case err := <-done:
+		// Playback finished normally (copy must have succeeded or player would have exited early)
+		return err
+	}
+}
+func (o *KokoroOrator) requestSound(text string) (io.ReadCloser, error) {
+	if o.URL == "" {
+		return nil, fmt.Errorf("TTS URL is empty")
+	}
+	payload := map[string]interface{}{
+		"input":           text,
+		"voice":           o.Voice,
+		"response_format": o.Format,
+		"download_format": o.Format,
+		"stream":          o.Stream,
+		"speed":           o.Speed,
+		// "return_download_link": true,
+		"lang_code": o.Language,
+	}
+	payloadBytes, err := json.Marshal(payload)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal payload: %w", err)
+	}
+	req, err := http.NewRequest("POST", o.URL, bytes.NewBuffer(payloadBytes)) //nolint:noctx
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("accept", "application/json")
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("request failed: %w", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		defer resp.Body.Close()
+		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+	return resp.Body, nil
+}
+
+func (o *KokoroOrator) stoproutine() {
+	for {
+		<-TTSDoneChan
+		o.logger.Debug("orator got done signal")
+		// 1. Stop any ongoing playback (kills external player, closes stopCh)
+		o.Stop()
+		// 2. Drain any pending text chunks
+		for len(TTSTextChan) > 0 {
+			<-TTSTextChan
+		}
+		// 3. Reset internal state
+		o.mu.Lock()
+		o.textBuffer.Reset()
+		o.interrupt = true
+		o.mu.Unlock()
+	}
+}
+
+func (o *KokoroOrator) Stop() {
+	o.cmdMu.Lock()
+	defer o.cmdMu.Unlock()
+	// Signal any running Speak to stop
+	if o.stopCh != nil {
+		select {
+		case <-o.stopCh: // already closed
+		default:
+			close(o.stopCh)
+		}
+		o.stopCh = nil
+	}
+	// Kill the external player process if it's still running
+	if o.cmd != nil && o.cmd.Process != nil {
+		o.cmd.Process.Kill()
+		o.cmd.Wait() // clean up zombie process
+		o.cmd = nil
+	}
+	// Also reset text buffer and interrupt flag (with o.mu)
+	o.mu.Lock()
+	o.textBuffer.Reset()
+	o.interrupt = true
+	o.mu.Unlock()
+}
+
+func (o *KokoroOrator) readroutine() {
+	tokenizer, _ := english.NewSentenceTokenizer(nil)
+	for {
+		select {
+		case chunk := <-TTSTextChan:
+			o.mu.Lock()
+			o.interrupt = false
+			_, err := o.textBuffer.WriteString(chunk)
+			if err != nil {
+				o.logger.Warn("failed to write to stringbuilder", "error", err)
+				o.mu.Unlock()
+				continue
+			}
+			text := o.textBuffer.String()
+			sentences := tokenizer.Tokenize(text)
+			o.logger.Debug("adding chunk", "chunk", chunk, "text", text, "sen-len", len(sentences))
+			if len(sentences) <= 1 {
+				o.mu.Unlock()
+				continue
+			}
+			completeSentences := sentences[:len(sentences)-1]
+			remaining := sentences[len(sentences)-1].Text
+			o.textBuffer.Reset()
+			o.textBuffer.WriteString(remaining)
+			o.mu.Unlock()
+			for _, sentence := range completeSentences {
+				o.mu.Lock()
+				interrupted := o.interrupt
+				o.mu.Unlock()
+				if interrupted {
+					return
+				}
+				cleanedText := models.CleanText(sentence.Text)
+				if cleanedText == "" {
+					continue
+				}
+				o.logger.Debug("calling Speak with sentence", "sent", cleanedText)
+				if err := o.Speak(cleanedText); err != nil {
+					o.logger.Error("tts failed", "sentence", cleanedText, "error", err)
+				}
+			}
+		case <-TTSFlushChan:
+			o.logger.Debug("got flushchan signal start")
+			// lln is done get the whole message out
+			if len(TTSTextChan) > 0 { // otherwise might get stuck
+				for chunk := range TTSTextChan {
+					o.mu.Lock()
+					_, err := o.textBuffer.WriteString(chunk)
+					o.mu.Unlock()
+					if err != nil {
+						o.logger.Warn("failed to write to stringbuilder", "error", err)
+						continue
+					}
+					if len(TTSTextChan) == 0 {
+						break
+					}
+				}
+			}
+			// flush remaining text
+			o.mu.Lock()
+			remaining := o.textBuffer.String()
+			remaining = models.CleanText(remaining)
+			o.textBuffer.Reset()
+			o.mu.Unlock()
+			if remaining == "" {
+				continue
+			}
+			o.logger.Debug("calling Speak with remainder", "rem", remaining)
+			sentencesRem := tokenizer.Tokenize(remaining)
+			for _, rs := range sentencesRem { // to avoid dumping large volume of text
+				o.mu.Lock()
+				interrupt := o.interrupt
+				o.mu.Unlock()
+				if interrupt {
+					break
+				}
+				if err := o.Speak(rs.Text); err != nil {
+					o.logger.Error("tts failed", "sentence", rs, "error", err)
+				}
+			}
+		}
+	}
+}

extra/stt.go

@@ -6,18 +6,10 @@ package extra
 import (
 	"bytes"
 	"encoding/binary"
-	"errors"
-	"fmt"
 	"gf-lt/config"
 	"io"
 	"log/slog"
-	"mime/multipart"
-	"net/http"
 	"regexp"
-	"strings"
-	"syscall"
-
-	"github.com/gordonklaus/portaudio"
 )
 
 var specialRE = regexp.MustCompile(`\[.*?\]`)
@@ -44,14 +36,6 @@ func NewSTT(logger *slog.Logger, cfg *config.Config) STT {
 	return NewWhisperServer(logger, cfg)
 }
 
-type WhisperServer struct {
-	logger      *slog.Logger
-	ServerURL   string
-	SampleRate  int
-	AudioBuffer *bytes.Buffer
-	recording   bool
-}
-
 func NewWhisperServer(logger *slog.Logger, cfg *config.Config) *WhisperServer {
 	return &WhisperServer{
 		logger:      logger,
@@ -61,69 +45,6 @@ func NewWhisperServer(logger *slog.Logger, cfg *config.Config) *WhisperServer {
 	}
 }
 
-func (stt *WhisperServer) StartRecording() error {
-	if err := stt.microphoneStream(stt.SampleRate); err != nil {
-		return fmt.Errorf("failed to init microphone: %w", err)
-	}
-	stt.recording = true
-	return nil
-}
-
-func (stt *WhisperServer) StopRecording() (string, error) {
-	stt.recording = false
-	// wait loop to finish?
-	if stt.AudioBuffer == nil {
-		err := errors.New("unexpected nil AudioBuffer")
-		stt.logger.Error(err.Error())
-		return "", err
-	}
-	// Create WAV header first
-	body := &bytes.Buffer{}
-	writer := multipart.NewWriter(body)
-	// Add audio file part
-	part, err := writer.CreateFormFile("file", "recording.wav")
-	if err != nil {
-		stt.logger.Error("fn: StopRecording", "error", err)
-		return "", err
-	}
-	// Stream directly to multipart writer: header + raw data
-	dataSize := stt.AudioBuffer.Len()
-	stt.writeWavHeader(part, dataSize)
-	if _, err := io.Copy(part, stt.AudioBuffer); err != nil {
-		stt.logger.Error("fn: StopRecording", "error", err)
-		return "", err
-	}
-	// Reset buffer for next recording
-	stt.AudioBuffer.Reset()
-	// Add response format field
-	err = writer.WriteField("response_format", "text")
-	if err != nil {
-		stt.logger.Error("fn: StopRecording", "error", err)
-		return "", err
-	}
-	if writer.Close() != nil {
-		stt.logger.Error("fn: StopRecording", "error", err)
-		return "", err
-	}
-	// Send request
-	resp, err := http.Post(stt.ServerURL, writer.FormDataContentType(), body) //nolint:noctx
-	if err != nil {
-		stt.logger.Error("fn: StopRecording", "error", err)
-		return "", err
-	}
-	defer resp.Body.Close()
-	// Read and print response
-	responseTextBytes, err := io.ReadAll(resp.Body)
-	if err != nil {
-		stt.logger.Error("fn: StopRecording", "error", err)
-		return "", err
-	}
-	resptext := strings.TrimRight(string(responseTextBytes), "\n")
-	// in case there are special tokens like [_BEG_]
-	resptext = specialRE.ReplaceAllString(resptext, "")
-	return strings.TrimSpace(strings.ReplaceAll(resptext, "\n ", "\n")), nil
-}
-
 func (stt *WhisperServer) writeWavHeader(w io.Writer, dataSize int) {
 	header := make([]byte, 44)
 	copy(header[0:4], "RIFF")
@@ -147,56 +68,3 @@ func (stt *WhisperServer) writeWavHeader(w io.Writer, dataSize int) {
 func (stt *WhisperServer) IsRecording() bool {
 	return stt.recording
 }
-
-func (stt *WhisperServer) microphoneStream(sampleRate int) error {
-	// Temporarily redirect stderr to suppress ALSA warnings during PortAudio init
-	origStderr, errDup := syscall.Dup(syscall.Stderr)
-	if errDup != nil {
-		return fmt.Errorf("failed to dup stderr: %w", errDup)
-	}
-	nullFD, err := syscall.Open("/dev/null", syscall.O_WRONLY, 0)
-	if err != nil {
-		_ = syscall.Close(origStderr) // Close the dup'd fd if open fails
-		return fmt.Errorf("failed to open /dev/null: %w", err)
-	}
-	// redirect stderr
-	_ = syscall.Dup2(nullFD, syscall.Stderr)
-	// Initialize PortAudio (this is where ALSA warnings occur)
-	defer func() {
-		// Restore stderr
-		_ = syscall.Dup2(origStderr, syscall.Stderr)
-		_ = syscall.Close(origStderr)
-		_ = syscall.Close(nullFD)
-	}()
-	if err := portaudio.Initialize(); err != nil {
-		return fmt.Errorf("portaudio init failed: %w", err)
-	}
-	in := make([]int16, 64)
-	stream, err := portaudio.OpenDefaultStream(1, 0, float64(sampleRate), len(in), in)
-	if err != nil {
-		if paErr := portaudio.Terminate(); paErr != nil {
-			return fmt.Errorf("failed to open microphone: %w; terminate error: %w", err, paErr)
-		}
-		return fmt.Errorf("failed to open microphone: %w", err)
-	}
-	go func(stream *portaudio.Stream) {
-		if err := stream.Start(); err != nil {
-			stt.logger.Error("microphoneStream", "error", err)
-			return
-		}
-		for {
-			if !stt.IsRecording() {
-				return
-			}
-			if err := stream.Read(); err != nil {
-				stt.logger.Error("reading stream", "error", err)
-				return
-			}
-			if err := binary.Write(stt.AudioBuffer, binary.LittleEndian, in); err != nil {
-				stt.logger.Error("writing to buffer", "error", err)
-				return
-			}
-		}
-	}(stream)
-	return nil
-}

extra/tts.go

@@ -4,25 +4,13 @@
 package extra
 
 import (
-	"bytes"
-	"encoding/json"
-	"fmt"
 	"gf-lt/config"
 	"gf-lt/models"
-	"io"
 	"log/slog"
-	"net/http"
 	"os"
 	"strings"
-	"sync"
-	"time"
 
 	google_translate_tts "github.com/GrailFinder/google-translate-tts"
-	"github.com/GrailFinder/google-translate-tts/handlers"
-	"github.com/gopxl/beep/v2"
-	"github.com/gopxl/beep/v2/mp3"
-	"github.com/gopxl/beep/v2/speaker"
-	"github.com/neurosnap/sentences/english"
 )
 
 var (
@@ -39,142 +27,6 @@ type Orator interface {
 	GetLogger() *slog.Logger
 }
 
-// impl https://github.com/remsky/Kokoro-FastAPI
-type KokoroOrator struct {
-	logger        *slog.Logger
-	mu            sync.Mutex
-	URL           string
-	Format        models.AudioFormat
-	Stream        bool
-	Speed         float32
-	Language      string
-	Voice         string
-	currentStream *beep.Ctrl // Added for playback control
-	currentDone   chan bool
-	textBuffer    strings.Builder
-	interrupt     bool
-	// textBuffer bytes.Buffer
-}
-
-// Google Translate TTS implementation
-type GoogleTranslateOrator struct {
-	logger        *slog.Logger
-	mu            sync.Mutex
-	speech        *google_translate_tts.Speech
-	currentStream *beep.Ctrl
-	currentDone   chan bool
-	textBuffer    strings.Builder
-	interrupt     bool
-}
-
-func (o *KokoroOrator) stoproutine() {
-	for {
-		<-TTSDoneChan
-		o.logger.Debug("orator got done signal")
-		o.Stop()
-		// drain the channel
-		for len(TTSTextChan) > 0 {
-			<-TTSTextChan
-		}
-		o.mu.Lock()
-		o.textBuffer.Reset()
-		if o.currentDone != nil {
-			select {
-			case o.currentDone <- true:
-			default:
-				// Channel might be closed, ignore
-			}
-		}
-		o.interrupt = true
-		o.mu.Unlock()
-	}
-}
-
-func (o *KokoroOrator) readroutine() {
-	tokenizer, _ := english.NewSentenceTokenizer(nil)
-	for {
-		select {
-		case chunk := <-TTSTextChan:
-			o.mu.Lock()
-			o.interrupt = false
-			_, err := o.textBuffer.WriteString(chunk)
-			if err != nil {
-				o.logger.Warn("failed to write to stringbuilder", "error", err)
-				o.mu.Unlock()
-				continue
-			}
-			text := o.textBuffer.String()
-			sentences := tokenizer.Tokenize(text)
-			o.logger.Debug("adding chunk", "chunk", chunk, "text", text, "sen-len", len(sentences))
-			if len(sentences) <= 1 {
-				o.mu.Unlock()
-				continue
-			}
-			completeSentences := sentences[:len(sentences)-1]
-			remaining := sentences[len(sentences)-1].Text
-			o.textBuffer.Reset()
-			o.textBuffer.WriteString(remaining)
-			o.mu.Unlock()
-
-			for _, sentence := range completeSentences {
-				o.mu.Lock()
-				interrupted := o.interrupt
-				o.mu.Unlock()
-				if interrupted {
-					return
-				}
-				cleanedText := models.CleanText(sentence.Text)
-				if cleanedText == "" {
-					continue
-				}
-				o.logger.Debug("calling Speak with sentence", "sent", cleanedText)
-				if err := o.Speak(cleanedText); err != nil {
-					o.logger.Error("tts failed", "sentence", cleanedText, "error", err)
-				}
-			}
-		case <-TTSFlushChan:
-			o.logger.Debug("got flushchan signal start")
-			// lln is done get the whole message out
-			if len(TTSTextChan) > 0 { // otherwise might get stuck
-				for chunk := range TTSTextChan {
-					o.mu.Lock()
-					_, err := o.textBuffer.WriteString(chunk)
-					o.mu.Unlock()
-					if err != nil {
-						o.logger.Warn("failed to write to stringbuilder", "error", err)
-						continue
-					}
-					if len(TTSTextChan) == 0 {
-						break
-					}
-				}
-			}
-			// flush remaining text
-			o.mu.Lock()
-			remaining := o.textBuffer.String()
-			remaining = models.CleanText(remaining)
-			o.textBuffer.Reset()
-			o.mu.Unlock()
-			if remaining == "" {
-				continue
-			}
-			o.logger.Debug("calling Speak with remainder", "rem", remaining)
-			sentencesRem := tokenizer.Tokenize(remaining)
-			for _, rs := range sentencesRem { // to avoid dumping large volume of text
-				o.mu.Lock()
-				interrupt := o.interrupt
-				o.mu.Unlock()
-				if interrupt {
-					break
-				}
-				if err := o.Speak(rs.Text); err != nil {
-					o.logger.Error("tts failed", "sentence", rs, "error", err)
-				}
-			}
-		}
-	}
-}
-
 func NewOrator(log *slog.Logger, cfg *config.Config) Orator {
 	provider := cfg.TTS_PROVIDER
 	if provider == "" {
@@ -204,270 +56,14 @@ func NewOrator(log *slog.Logger, cfg *config.Config) Orator {
 			Language: language,
 			Proxy:    "", // Proxy not supported
 			Speed:    cfg.TTS_SPEED,
-			Handler:  &handlers.Beep{},
 		}
 		orator := &GoogleTranslateOrator{
 			logger: log,
 			speech: speech,
+			Speed:  cfg.TTS_SPEED,
 		}
 		go orator.readroutine()
 		go orator.stoproutine()
 		return orator
 	}
 }
-
-func (o *KokoroOrator) GetLogger() *slog.Logger {
-	return o.logger
-}
-
-func (o *KokoroOrator) requestSound(text string) (io.ReadCloser, error) {
-	if o.URL == "" {
-		return nil, fmt.Errorf("TTS URL is empty")
-	}
-	payload := map[string]interface{}{
-		"input":           text,
-		"voice":           o.Voice,
-		"response_format": o.Format,
-		"download_format": o.Format,
-		"stream":          o.Stream,
-		"speed":           o.Speed,
-		// "return_download_link": true,
-		"lang_code": o.Language,
-	}
-	payloadBytes, err := json.Marshal(payload)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal payload: %w", err)
-	}
-	req, err := http.NewRequest("POST", o.URL, bytes.NewBuffer(payloadBytes)) //nolint:noctx
-	if err != nil {
-		return nil, fmt.Errorf("failed to create request: %w", err)
-	}
-	req.Header.Set("accept", "application/json")
-	req.Header.Set("Content-Type", "application/json")
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("request failed: %w", err)
-	}
-	if resp.StatusCode != http.StatusOK {
-		defer resp.Body.Close()
-		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
-	}
-	return resp.Body, nil
-}
-
-func (o *KokoroOrator) Speak(text string) error {
-	o.logger.Debug("fn: Speak is called", "text-len", len(text))
-	body, err := o.requestSound(text)
-	if err != nil {
-		o.logger.Error("request failed", "error", err)
-		return fmt.Errorf("request failed: %w", err)
-	}
-	defer body.Close()
-	// Decode the mp3 audio from response body
-	streamer, format, err := mp3.Decode(body)
-	if err != nil {
-		o.logger.Error("mp3 decode failed", "error", err)
-		return fmt.Errorf("mp3 decode failed: %w", err)
-	}
-	defer streamer.Close()
-	// here it spams with errors that speaker cannot be initialized more than once, but how would we deal with many audio records then?
-	if err := speaker.Init(format.SampleRate, format.SampleRate.N(time.Second/10)); err != nil {
-		o.logger.Debug("failed to init speaker", "error", err)
-	}
-	done := make(chan bool)
-	o.mu.Lock()
-	o.currentDone = done
-	o.currentStream = &beep.Ctrl{Streamer: beep.Seq(streamer, beep.Callback(func() {
-		o.mu.Lock()
-		close(done)
-		o.currentStream = nil
-		o.currentDone = nil
-		o.mu.Unlock()
-	})), Paused: false}
-	o.mu.Unlock()
-	speaker.Play(o.currentStream)
-	<-done
-	return nil
-}
-
-func (o *KokoroOrator) Stop() {
-	// speaker.Clear()
-	o.logger.Debug("attempted to stop orator", "orator", o)
-	speaker.Lock()
-	defer speaker.Unlock()
-	o.mu.Lock()
-	defer o.mu.Unlock()
-	if o.currentStream != nil {
-		// o.currentStream.Paused = true
-		o.currentStream.Streamer = nil
-	}
-}
-
-func (o *GoogleTranslateOrator) stoproutine() {
-	for {
-		<-TTSDoneChan
-		o.logger.Debug("orator got done signal")
-		o.Stop()
-		// drain the channel
-		for len(TTSTextChan) > 0 {
-			<-TTSTextChan
-		}
-		o.mu.Lock()
-		o.textBuffer.Reset()
-		if o.currentDone != nil {
-			select {
-			case o.currentDone <- true:
-			default:
-				// Channel might be closed, ignore
-			}
-		}
-		o.interrupt = true
-		o.mu.Unlock()
-	}
-}
-
-func (o *GoogleTranslateOrator) readroutine() {
-	tokenizer, _ := english.NewSentenceTokenizer(nil)
-	for {
-		select {
-		case chunk := <-TTSTextChan:
-			o.mu.Lock()
-			o.interrupt = false
-			_, err := o.textBuffer.WriteString(chunk)
-			if err != nil {
-				o.logger.Warn("failed to write to stringbuilder", "error", err)
-				o.mu.Unlock()
-				continue
-			}
-			text := o.textBuffer.String()
-			sentences := tokenizer.Tokenize(text)
-			o.logger.Debug("adding chunk", "chunk", chunk, "text", text, "sen-len", len(sentences))
-			if len(sentences) <= 1 {
-				o.mu.Unlock()
-				continue
-			}
-			completeSentences := sentences[:len(sentences)-1]
-			remaining := sentences[len(sentences)-1].Text
-			o.textBuffer.Reset()
-			o.textBuffer.WriteString(remaining)
-			o.mu.Unlock()
-
-			for _, sentence := range completeSentences {
-				o.mu.Lock()
-				interrupted := o.interrupt
-				o.mu.Unlock()
-				if interrupted {
-					return
-				}
-				cleanedText := models.CleanText(sentence.Text)
-				if cleanedText == "" {
-					continue
-				}
-				o.logger.Debug("calling Speak with sentence", "sent", cleanedText)
-				if err := o.Speak(cleanedText); err != nil {
-					o.logger.Error("tts failed", "sentence", cleanedText, "error", err)
-				}
-			}
-		case <-TTSFlushChan:
-			o.logger.Debug("got flushchan signal start")
-			// lln is done get the whole message out
-			if len(TTSTextChan) > 0 { // otherwise might get stuck
-				for chunk := range TTSTextChan {
-					o.mu.Lock()
-					_, err := o.textBuffer.WriteString(chunk)
-					o.mu.Unlock()
-					if err != nil {
-						o.logger.Warn("failed to write to stringbuilder", "error", err)
-						continue
-					}
-					if len(TTSTextChan) == 0 {
-						break
-					}
-				}
-			}
-			o.mu.Lock()
-			remaining := o.textBuffer.String()
-			remaining = models.CleanText(remaining)
-			o.textBuffer.Reset()
-			o.mu.Unlock()
-			if remaining == "" {
-				continue
-			}
-			o.logger.Debug("calling Speak with remainder", "rem", remaining)
-			sentencesRem := tokenizer.Tokenize(remaining)
-			for _, rs := range sentencesRem { // to avoid dumping large volume of text
-				o.mu.Lock()
-				interrupt := o.interrupt
-				o.mu.Unlock()
-				if interrupt {
-					break
-				}
-				if err := o.Speak(rs.Text); err != nil {
-					o.logger.Error("tts failed", "sentence", rs.Text, "error", err)
-				}
-			}
-		}
-	}
-}
-
-func (o *GoogleTranslateOrator) GetLogger() *slog.Logger {
-	return o.logger
-}
-
-func (o *GoogleTranslateOrator) Speak(text string) error {
-	o.logger.Debug("fn: Speak is called", "text-len", len(text))
-	// Generate MP3 data using google-translate-tts
-	reader, err := o.speech.GenerateSpeech(text)
-	if err != nil {
-		o.logger.Error("generate speech failed", "error", err)
-		return fmt.Errorf("generate speech failed: %w", err)
-	}
-	// Decode the mp3 audio from reader (wrap with NopCloser for io.ReadCloser)
-	streamer, format, err := mp3.Decode(io.NopCloser(reader))
-	if err != nil {
-		o.logger.Error("mp3 decode failed", "error", err)
-		return fmt.Errorf("mp3 decode failed: %w", err)
-	}
-	defer streamer.Close()
-	playbackStreamer := beep.Streamer(streamer)
-	speed := o.speech.Speed
-	if speed <= 0 {
-		speed = 1.0
-	}
-	if speed != 1.0 {
-		playbackStreamer = beep.ResampleRatio(3, float64(speed), streamer)
-	}
-	// Initialize speaker with the format's sample rate
-	if err := speaker.Init(format.SampleRate, format.SampleRate.N(time.Second/10)); err != nil {
-		o.logger.Debug("failed to init speaker", "error", err)
-	}
-	done := make(chan bool)
-	o.mu.Lock()
-	o.currentDone = done
-	o.currentStream = &beep.Ctrl{Streamer: beep.Seq(playbackStreamer, beep.Callback(func() {
-		o.mu.Lock()
-		close(done)
-		o.currentStream = nil
-		o.currentDone = nil
-		o.mu.Unlock()
-	})), Paused: false}
-	o.mu.Unlock()
-	speaker.Play(o.currentStream)
-	<-done // wait for playback to complete
-	return nil
-}
-
-func (o *GoogleTranslateOrator) Stop() {
-	o.logger.Debug("attempted to stop google translate orator")
-	speaker.Lock()
-	defer speaker.Unlock()
-	o.mu.Lock()
-	defer o.mu.Unlock()
-	if o.currentStream != nil {
-		o.currentStream.Streamer = nil
-	}
-	// Also stop the speech handler if possible
-	if o.speech != nil {
-		_ = o.speech.Stop()
-	}
-}

extra/whisper_binary.go

@@ -9,15 +9,13 @@ import (
 	"errors"
 	"fmt"
 	"gf-lt/config"
-	"io"
 	"log/slog"
 	"os"
 	"os/exec"
 	"strings"
 	"sync"
 	"syscall"
-
+	"time"
-	"github.com/gordonklaus/portaudio"
 )
 
 type WhisperBinary struct {
@@ -25,11 +23,143 @@ type WhisperBinary struct {
 	whisperPath string
 	modelPath   string
 	lang        string
-	ctx         context.Context
+	// Per-recording fields (protected by mu)
-	cancel      context.CancelFunc
+	mu        sync.Mutex
-	mu          sync.Mutex
+	recording bool
-	recording   bool
+	tempFile  string
-	audioBuffer []int16
+	ctx       context.Context
+	cancel    context.CancelFunc
+	cmd       *exec.Cmd
+	cmdMu     sync.Mutex
+}
+
+func (w *WhisperBinary) StartRecording() error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if w.recording {
+		return errors.New("recording is already in progress")
+	}
+	// Fresh context for this recording
+	ctx, cancel := context.WithCancel(context.Background())
+	w.ctx = ctx
+	w.cancel = cancel
+	// Create temporary file
+	tempFile, err := os.CreateTemp("", "recording_*.wav")
+	if err != nil {
+		cancel()
+		return fmt.Errorf("failed to create temp file: %w", err)
+	}
+	tempFile.Close()
+	w.tempFile = tempFile.Name()
+	// ffmpeg command: capture from default microphone, write WAV
+	args := []string{
+		"-f", "alsa", // or "pulse" if preferred
+		"-i", "default",
+		"-acodec", "pcm_s16le",
+		"-ar", "16000",
+		"-ac", "1",
+		"-y", // overwrite output file
+		w.tempFile,
+	}
+	cmd := exec.CommandContext(w.ctx, "ffmpeg", args...)
+	// Capture stderr for debugging (optional, but useful for diagnosing)
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		cancel()
+		os.Remove(w.tempFile)
+		return fmt.Errorf("failed to create stderr pipe: %w", err)
+	}
+	go func() {
+		buf := make([]byte, 1024)
+		for {
+			n, err := stderr.Read(buf)
+			if n > 0 {
+				w.logger.Debug("ffmpeg stderr", "output", string(buf[:n]))
+			}
+			if err != nil {
+				break
+			}
+		}
+	}()
+	w.cmdMu.Lock()
+	w.cmd = cmd
+	w.cmdMu.Unlock()
+	if err := cmd.Start(); err != nil {
+		cancel()
+		os.Remove(w.tempFile)
+		return fmt.Errorf("failed to start ffmpeg: %w", err)
+	}
+	w.recording = true
+	w.logger.Debug("Recording started", "file", w.tempFile)
+	return nil
+}
+
+func (w *WhisperBinary) StopRecording() (string, error) {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if !w.recording {
+		return "", errors.New("not currently recording")
+	}
+	w.recording = false
+	// Gracefully stop ffmpeg
+	w.cmdMu.Lock()
+	if w.cmd != nil && w.cmd.Process != nil {
+		w.logger.Debug("Sending SIGTERM to ffmpeg")
+		w.cmd.Process.Signal(syscall.SIGTERM)
+		// Wait for process to exit (up to 2 seconds)
+		done := make(chan error, 1)
+		go func() {
+			done <- w.cmd.Wait()
+		}()
+		select {
+		case <-done:
+			w.logger.Debug("ffmpeg exited after SIGTERM")
+		case <-time.After(2 * time.Second):
+			w.logger.Warn("ffmpeg did not exit, sending SIGKILL")
+			w.cmd.Process.Kill()
+			<-done
+		}
+	}
+	w.cmdMu.Unlock()
+	// Cancel context (already done, but for cleanliness)
+	if w.cancel != nil {
+		w.cancel()
+	}
+	// Validate temp file
+	if w.tempFile == "" {
+		return "", errors.New("no recording file")
+	}
+	defer os.Remove(w.tempFile)
+	info, err := os.Stat(w.tempFile)
+	if err != nil {
+		return "", fmt.Errorf("failed to stat temp file: %w", err)
+	}
+	if info.Size() < 44 { // WAV header is 44 bytes
+		// Log ffmpeg stderr? Already captured in debug logs.
+		return "", fmt.Errorf("recording file too small (%d bytes), possibly no audio captured", info.Size())
+	}
+	// Run whisper.cpp binary
+	cmd := exec.Command(w.whisperPath, "-m", w.modelPath, "-l", w.lang, w.tempFile)
+	var outBuf, errBuf bytes.Buffer
+	cmd.Stdout = &outBuf
+	cmd.Stderr = &errBuf
+	if err := cmd.Run(); err != nil {
+		w.logger.Error("whisper binary failed",
+			"error", err,
+			"stderr", errBuf.String(),
+			"file_size", info.Size())
+		return "", fmt.Errorf("whisper binary failed: %w (stderr: %s)", err, errBuf.String())
+	}
+	result := strings.TrimRight(outBuf.String(), "\n")
+	result = specialRE.ReplaceAllString(result, "")
+	return strings.TrimSpace(strings.ReplaceAll(result, "\n ", "\n")), nil
+}
+
+// IsRecording returns true if a recording is in progress.
+func (w *WhisperBinary) IsRecording() bool {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	return w.recording
 }
 
 func NewWhisperBinary(logger *slog.Logger, cfg *config.Config) *WhisperBinary {
@@ -44,283 +174,3 @@ func NewWhisperBinary(logger *slog.Logger, cfg *config.Config) *WhisperBinary {
 		cancel:      cancel,
 	}
 }
-
-func (w *WhisperBinary) StartRecording() error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-	if w.recording {
-		return errors.New("recording is already in progress")
-	}
-	// If context is cancelled, create a new one for the next recording session
-	if w.ctx.Err() != nil {
-		w.logger.Debug("Context cancelled, creating new context")
-		w.ctx, w.cancel = context.WithCancel(context.Background())
-	}
-	// Temporarily redirect stderr to suppress ALSA warnings during PortAudio init
-	origStderr, errDup := syscall.Dup(syscall.Stderr)
-	if errDup != nil {
-		return fmt.Errorf("failed to dup stderr: %w", errDup)
-	}
-	nullFD, err := syscall.Open("/dev/null", syscall.O_WRONLY, 0)
-	if err != nil {
-		_ = syscall.Close(origStderr) // Close the dup'd fd if open fails
-		return fmt.Errorf("failed to open /dev/null: %w", err)
-	}
-	// redirect stderr
-	_ = syscall.Dup2(nullFD, syscall.Stderr)
-	// Initialize PortAudio (this is where ALSA warnings occur)
-	portaudioErr := portaudio.Initialize()
-	defer func() {
-		// Restore stderr
-		_ = syscall.Dup2(origStderr, syscall.Stderr)
-		_ = syscall.Close(origStderr)
-		_ = syscall.Close(nullFD)
-	}()
-	if portaudioErr != nil {
-		return fmt.Errorf("portaudio init failed: %w", portaudioErr)
-	}
-	// Initialize audio buffer
-	w.audioBuffer = make([]int16, 0)
-	in := make([]int16, 1024) // buffer size
-	stream, err := portaudio.OpenDefaultStream(1, 0, 16000.0, len(in), in)
-	if err != nil {
-		if paErr := portaudio.Terminate(); paErr != nil {
-			return fmt.Errorf("failed to open microphone: %w; terminate error: %w", err, paErr)
-		}
-		return fmt.Errorf("failed to open microphone: %w", err)
-	}
-	go w.recordAudio(stream, in)
-	w.recording = true
-	w.logger.Debug("Recording started")
-	return nil
-}
-
-func (w *WhisperBinary) recordAudio(stream *portaudio.Stream, in []int16) {
-	defer func() {
-		w.logger.Debug("recordAudio defer function called")
-		_ = stream.Stop()         // Stop the stream
-		_ = portaudio.Terminate() // ignoring error as we're shutting down
-		w.logger.Debug("recordAudio terminated")
-	}()
-	w.logger.Debug("Starting audio stream")
-	if err := stream.Start(); err != nil {
-		w.logger.Error("Failed to start audio stream", "error", err)
-		return
-	}
-	w.logger.Debug("Audio stream started, entering recording loop")
-	for {
-		select {
-		case <-w.ctx.Done():
-			w.logger.Debug("Context done, exiting recording loop")
-			return
-		default:
-			// Check recording status with minimal lock time
-			w.mu.Lock()
-			recording := w.recording
-			w.mu.Unlock()
-
-			if !recording {
-				w.logger.Debug("Recording flag is false, exiting recording loop")
-				return
-			}
-			if err := stream.Read(); err != nil {
-				w.logger.Error("Error reading from stream", "error", err)
-				return
-			}
-			// Append samples to buffer - only acquire lock when necessary
-			w.mu.Lock()
-			if w.audioBuffer == nil {
-				w.audioBuffer = make([]int16, 0)
-			}
-			// Make a copy of the input buffer to avoid overwriting
-			tempBuffer := make([]int16, len(in))
-			copy(tempBuffer, in)
-			w.audioBuffer = append(w.audioBuffer, tempBuffer...)
-			w.mu.Unlock()
-		}
-	}
-}
-
-func (w *WhisperBinary) StopRecording() (string, error) {
-	w.logger.Debug("StopRecording called")
-	w.mu.Lock()
-	if !w.recording {
-		w.mu.Unlock()
-		return "", errors.New("not currently recording")
-	}
-	w.logger.Debug("Setting recording to false and cancelling context")
-	w.recording = false
-	w.cancel() // This will stop the recording goroutine
-	w.mu.Unlock()
-	// // Small delay to allow the recording goroutine to react to context cancellation
-	// time.Sleep(20 * time.Millisecond)
-	// Save the recorded audio to a temporary file
-	tempFile, err := w.saveAudioToTempFile()
-	if err != nil {
-		w.logger.Error("Error saving audio to temp file", "error", err)
-		return "", fmt.Errorf("failed to save audio to temp file: %w", err)
-	}
-	w.logger.Debug("Saved audio to temp file", "file", tempFile)
-	// Run the whisper binary with a separate context to avoid cancellation during transcription
-	cmd := exec.Command(w.whisperPath, "-m", w.modelPath, "-l", w.lang, tempFile, "2>/dev/null")
-	var outBuf bytes.Buffer
-	cmd.Stdout = &outBuf
-	// Redirect stderr to suppress ALSA warnings and other stderr output
-	cmd.Stderr = io.Discard // Suppress stderr output from whisper binary
-	w.logger.Debug("Running whisper binary command")
-	if err := cmd.Run(); err != nil {
-		// Clean up audio buffer
-		w.mu.Lock()
-		w.audioBuffer = nil
-		w.mu.Unlock()
-		// Since we're suppressing stderr, we'll just log that the command failed
-		w.logger.Error("Error running whisper binary", "error", err)
-		return "", fmt.Errorf("whisper binary failed: %w", err)
-	}
-	result := outBuf.String()
-	w.logger.Debug("Whisper binary completed", "result", result)
-	// Clean up audio buffer
-	w.mu.Lock()
-	w.audioBuffer = nil
-	w.mu.Unlock()
-	// Clean up the temporary file after transcription
-	w.logger.Debug("StopRecording completed")
-	os.Remove(tempFile)
-	result = strings.TrimRight(result, "\n")
-	// in case there are special tokens like [_BEG_]
-	result = specialRE.ReplaceAllString(result, "")
-	return strings.TrimSpace(strings.ReplaceAll(result, "\n ", "\n")), nil
-}
-
-// saveAudioToTempFile saves the recorded audio data to a temporary WAV file
-func (w *WhisperBinary) saveAudioToTempFile() (string, error) {
-	w.logger.Debug("saveAudioToTempFile called")
-	// Create temporary WAV file
-	tempFile, err := os.CreateTemp("", "recording_*.wav")
-	if err != nil {
-		w.logger.Error("Failed to create temp file", "error", err)
-		return "", fmt.Errorf("failed to create temp file: %w", err)
-	}
-	w.logger.Debug("Created temp file", "file", tempFile.Name())
-	defer tempFile.Close()
-
-	// Write WAV header and data
-	w.logger.Debug("About to write WAV file", "file", tempFile.Name())
-	err = w.writeWAVFile(tempFile.Name())
-	if err != nil {
-		w.logger.Error("Error writing WAV file", "error", err)
-		return "", fmt.Errorf("failed to write WAV file: %w", err)
-	}
-	w.logger.Debug("WAV file written successfully", "file", tempFile.Name())
-
-	return tempFile.Name(), nil
-}
-
-// writeWAVFile creates a WAV file from the recorded audio data
-func (w *WhisperBinary) writeWAVFile(filename string) error {
-	w.logger.Debug("writeWAVFile called", "filename", filename)
-	// Open file for writing
-	file, err := os.Create(filename)
-	if err != nil {
-		w.logger.Error("Error creating file", "error", err)
-		return err
-	}
-	defer file.Close()
-
-	w.logger.Debug("About to acquire mutex in writeWAVFile")
-	w.mu.Lock()
-	w.logger.Debug("Locked mutex, copying audio buffer")
-	audioData := make([]int16, len(w.audioBuffer))
-	copy(audioData, w.audioBuffer)
-	w.mu.Unlock()
-	w.logger.Debug("Unlocked mutex", "audio_data_length", len(audioData))
-
-	if len(audioData) == 0 {
-		w.logger.Warn("No audio data to write")
-		return errors.New("no audio data to write")
-	}
-
-	// Calculate data size (number of samples * size of int16)
-	dataSize := len(audioData) * 2 // 2 bytes per int16 sample
-	w.logger.Debug("Calculated data size", "size", dataSize)
-
-	// Write WAV header with the correct data size
-	header := w.createWAVHeader(16000, 1, 16, dataSize)
-	_, err = file.Write(header)
-	if err != nil {
-		w.logger.Error("Error writing WAV header", "error", err)
-		return err
-	}
-	w.logger.Debug("WAV header written successfully")
-
-	// Write audio data
-	w.logger.Debug("About to write audio data samples")
-	for i, sample := range audioData {
-		// Write little-endian 16-bit sample
-		_, err := file.Write([]byte{byte(sample), byte(sample >> 8)})
-		if err != nil {
-			w.logger.Error("Error writing sample", "index", i, "error", err)
-			return err
-		}
-		// Log progress every 10000 samples to avoid too much output
-		if i%10000 == 0 {
-			w.logger.Debug("Written samples", "count", i)
-		}
-	}
-	w.logger.Debug("All audio data written successfully")
-
-	return nil
-}
-
-// createWAVHeader creates a WAV file header
-func (w *WhisperBinary) createWAVHeader(sampleRate, channels, bitsPerSample int, dataSize int) []byte {
-	header := make([]byte, 44)
-	copy(header[0:4], "RIFF")
-	// Total file size will be updated later
-	copy(header[8:12], "WAVE")
-	copy(header[12:16], "fmt ")
-	// fmt chunk size (16 for PCM)
-	header[16] = 16
-	header[17] = 0
-	header[18] = 0
-	header[19] = 0
-	// Audio format (1 = PCM)
-	header[20] = 1
-	header[21] = 0
-	// Number of channels
-	header[22] = byte(channels)
-	header[23] = 0
-	// Sample rate
-	header[24] = byte(sampleRate)
-	header[25] = byte(sampleRate >> 8)
-	header[26] = byte(sampleRate >> 16)
-	header[27] = byte(sampleRate >> 24)
-	// Byte rate
-	byteRate := sampleRate * channels * bitsPerSample / 8
-	header[28] = byte(byteRate)
-	header[29] = byte(byteRate >> 8)
-	header[30] = byte(byteRate >> 16)
-	header[31] = byte(byteRate >> 24)
-	// Block align
-	blockAlign := channels * bitsPerSample / 8
-	header[32] = byte(blockAlign)
-	header[33] = 0
-	// Bits per sample
-	header[34] = byte(bitsPerSample)
-	header[35] = 0
-	// "data" subchunk
-	copy(header[36:40], "data")
-	// Data size
-	header[40] = byte(dataSize)
-	header[41] = byte(dataSize >> 8)
-	header[42] = byte(dataSize >> 16)
-	header[43] = byte(dataSize >> 24)
-
-	return header
-}
-
-func (w *WhisperBinary) IsRecording() bool {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-	return w.recording
-}

extra/whisper_server.go

@@ -0,0 +1,156 @@
+//go:build extra
+// +build extra
+
+package extra
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"mime/multipart"
+	"net/http"
+	"os/exec"
+	"strings"
+	"sync"
+)
+
+type WhisperServer struct {
+	logger      *slog.Logger
+	ServerURL   string
+	SampleRate  int
+	AudioBuffer *bytes.Buffer
+	recording   bool          // protected by mu
+	mu          sync.Mutex    // protects recording & AudioBuffer
+	cmd         *exec.Cmd     // protected by cmdMu
+	stopCh      chan struct{} // protected by cmdMu
+	cmdMu       sync.Mutex    // protects cmd and stopCh
+}
+
+func (stt *WhisperServer) StartRecording() error {
+	stt.mu.Lock()
+	defer stt.mu.Unlock()
+	if stt.recording {
+		return nil
+	}
+	// Build ffmpeg command for microphone capture
+	args := []string{
+		"-f", "alsa",
+		"-i", "default",
+		"-acodec", "pcm_s16le",
+		"-ar", fmt.Sprint(stt.SampleRate),
+		"-ac", "1",
+		"-f", "s16le",
+		"-",
+	}
+	cmd := exec.Command("ffmpeg", args...)
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return fmt.Errorf("failed to get stdout pipe: %w", err)
+	}
+	stt.cmdMu.Lock()
+	stt.cmd = cmd
+	stt.stopCh = make(chan struct{})
+	stt.cmdMu.Unlock()
+	if err := cmd.Start(); err != nil {
+		return fmt.Errorf("failed to start ffmpeg: %w", err)
+	}
+	stt.recording = true
+	stt.AudioBuffer.Reset()
+	// Read PCM data in goroutine
+	go func() {
+		buf := make([]byte, 4096)
+		for {
+			select {
+			case <-stt.stopCh:
+				return
+			default:
+				n, err := stdout.Read(buf)
+				if n > 0 {
+					stt.mu.Lock()
+					stt.AudioBuffer.Write(buf[:n])
+					stt.mu.Unlock()
+				}
+				if err != nil {
+					if err != io.EOF {
+						stt.logger.Error("recording read error", "error", err)
+					}
+					return
+				}
+			}
+		}
+	}()
+	return nil
+}
+
+func (stt *WhisperServer) StopRecording() (string, error) {
+	stt.mu.Lock()
+	defer stt.mu.Unlock()
+	if !stt.recording {
+		return "", errors.New("not recording")
+	}
+	stt.recording = false
+	// Stop ffmpeg
+	stt.cmdMu.Lock()
+	if stt.cmd != nil && stt.cmd.Process != nil {
+		stt.cmd.Process.Kill()
+		stt.cmd.Wait()
+	}
+	close(stt.stopCh)
+	stt.cmdMu.Unlock()
+	// Rest of StopRecording unchanged (WAV header + HTTP upload)
+	// ...
+	stt.recording = false
+	// wait loop to finish?
+	if stt.AudioBuffer == nil {
+		err := errors.New("unexpected nil AudioBuffer")
+		stt.logger.Error(err.Error())
+		return "", err
+	}
+	// Create WAV header first
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+	// Add audio file part
+	part, err := writer.CreateFormFile("file", "recording.wav")
+	if err != nil {
+		stt.logger.Error("fn: StopRecording", "error", err)
+		return "", err
+	}
+	// Stream directly to multipart writer: header + raw data
+	dataSize := stt.AudioBuffer.Len()
+	stt.writeWavHeader(part, dataSize)
+	if _, err := io.Copy(part, stt.AudioBuffer); err != nil {
+		stt.logger.Error("fn: StopRecording", "error", err)
+		return "", err
+	}
+	// Reset buffer for next recording
+	stt.AudioBuffer.Reset()
+	// Add response format field
+	err = writer.WriteField("response_format", "text")
+	if err != nil {
+		stt.logger.Error("fn: StopRecording", "error", err)
+		return "", err
+	}
+	if writer.Close() != nil {
+		stt.logger.Error("fn: StopRecording", "error", err)
+		return "", err
+	}
+	// Send request
+	resp, err := http.Post(stt.ServerURL, writer.FormDataContentType(), body) //nolint:noctx
+	if err != nil {
+		stt.logger.Error("fn: StopRecording", "error", err)
+		return "", err
+	}
+	defer resp.Body.Close()
+	// Read and print response
+	responseTextBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		stt.logger.Error("fn: StopRecording", "error", err)
+		return "", err
+	}
+	resptext := strings.TrimRight(string(responseTextBytes), "\n")
+	// in case there are special tokens like [_BEG_]
+	resptext = specialRE.ReplaceAllString(resptext, "")
+	return strings.TrimSpace(strings.ReplaceAll(resptext, "\n ", "\n")), nil
+}

go.mod

@@ -4,35 +4,40 @@ go 1.25.1
 
 require (
 	github.com/BurntSushi/toml v1.5.0
-	github.com/GrailFinder/google-translate-tts v0.1.3
+	github.com/GrailFinder/google-translate-tts v0.1.4
 	github.com/GrailFinder/searchagent v0.2.0
 	github.com/PuerkitoBio/goquery v1.11.0
 	github.com/gdamore/tcell/v2 v2.13.2
 	github.com/glebarez/go-sqlite v1.22.0
-	github.com/gopxl/beep/v2 v2.1.1
-	github.com/gordonklaus/portaudio v0.0.0-20250206071425-98a94950218b
 	github.com/jmoiron/sqlx v1.4.0
 	github.com/ledongthuc/pdf v0.0.0-20250511090121-5959a4027728
 	github.com/neurosnap/sentences v1.1.2
+	github.com/playwright-community/playwright-go v0.5700.1
 	github.com/rivo/tview v0.42.0
+	github.com/sugarme/tokenizer v0.3.0
+	github.com/yalue/onnxruntime_go v1.27.0
 	github.com/yuin/goldmark v1.4.13
 )
 
 require (
 	github.com/andybalholm/cascadia v1.3.3 // indirect
+	github.com/deckarep/golang-set/v2 v2.8.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/ebitengine/oto/v3 v3.4.0 // indirect
+	github.com/emirpasic/gods v1.18.1 // indirect
-	github.com/ebitengine/purego v0.9.1 // indirect
 	github.com/gdamore/encoding v1.0.1 // indirect
+	github.com/go-jose/go-jose/v3 v3.0.4 // indirect
+	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/hajimehoshi/go-mp3 v0.3.4 // indirect
-	github.com/hajimehoshi/oto/v2 v2.3.1 // indirect
 	github.com/lucasb-eyer/go-colorful v1.3.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
+	github.com/patrickmn/go-cache v2.1.0+incompatible // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/schollz/progressbar/v2 v2.15.0 // indirect
+	github.com/sugarme/regexpset v0.0.0-20200920021344-4d4ec8eaf93c // indirect
 	golang.org/x/exp v0.0.0-20251209150349-8475f28825e9 // indirect
 	golang.org/x/net v0.48.0 // indirect
 	golang.org/x/sys v0.39.0 // indirect

go.sum

@@ -2,42 +2,43 @@ filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
 filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
 github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
 github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
-github.com/GrailFinder/google-translate-tts v0.1.3 h1:Mww9tNzTWjjSh+OCbTPl/+21oMPKcUecXZfU7nTB/lA=
+github.com/GrailFinder/google-translate-tts v0.1.4 h1:NJoPZUGfBrmouQMN19MUcNPNUx4tmf4a8OZRME4E4Mg=
-github.com/GrailFinder/google-translate-tts v0.1.3/go.mod h1:YIOLKR7sObazdUCrSex3u9OVBovU55eYgWa25vsQJ18=
+github.com/GrailFinder/google-translate-tts v0.1.4/go.mod h1:YIOLKR7sObazdUCrSex3u9OVBovU55eYgWa25vsQJ18=
 github.com/GrailFinder/searchagent v0.2.0 h1:U2GVjLh/9xZt0xX9OcYk9Q2fMkyzyTiADPUmUisRdtQ=
 github.com/GrailFinder/searchagent v0.2.0/go.mod h1:d66tn5+22LI8IGJREUsRBT60P0sFdgQgvQRqyvgItrs=
 github.com/PuerkitoBio/goquery v1.11.0 h1:jZ7pwMQXIITcUXNH83LLk+txlaEy6NVOfTuP43xxfqw=
 github.com/PuerkitoBio/goquery v1.11.0/go.mod h1:wQHgxUOU3JGuj3oD/QFfxUdlzW6xPHfqyHre6VMY4DQ=
 github.com/andybalholm/cascadia v1.3.3 h1:AG2YHrzJIm4BZ19iwJ/DAua6Btl3IwJX+VI4kktS1LM=
 github.com/andybalholm/cascadia v1.3.3/go.mod h1:xNd9bqTn98Ln4DwST8/nG+H0yuB8Hmgu1YHNnWw0GeA=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/deckarep/golang-set/v2 v2.8.0 h1:swm0rlPCmdWn9mESxKOjWk8hXSqoxOp+ZlfuyaAdFlQ=
+github.com/deckarep/golang-set/v2 v2.8.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/ebitengine/oto/v3 v3.4.0 h1:br0PgASsEWaoWn38b2Goe7m1GKFYfNgnsjSd5Gg+/bQ=
+github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/ebitengine/oto/v3 v3.4.0/go.mod h1:IOleLVD0m+CMak3mRVwsYY8vTctQgOM0iiL6S7Ar7eI=
+github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
-github.com/ebitengine/purego v0.9.1 h1:a/k2f2HQU3Pi399RPW1MOaZyhKJL9w/xFpKAg4q1s0A=
-github.com/ebitengine/purego v0.9.1/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
 github.com/gdamore/encoding v1.0.1 h1:YzKZckdBL6jVt2Gc+5p82qhrGiqMdG/eNs6Wy0u3Uhw=
 github.com/gdamore/encoding v1.0.1/go.mod h1:0Z0cMFinngz9kS1QfMjCP8TY7em3bZYeeklsSDPivEo=
 github.com/gdamore/tcell/v2 v2.13.2 h1:5j4srfF8ow3HICOv/61/sOhQtA25qxEB2XR3Q/Bhx2g=
 github.com/gdamore/tcell/v2 v2.13.2/go.mod h1:+Wfe208WDdB7INEtCsNrAN6O2m+wsTPk1RAovjaILlo=
 github.com/glebarez/go-sqlite v1.22.0 h1:uAcMJhaA6r3LHMTFgP0SifzgXg46yJkgxqyuyec+ruQ=
 github.com/glebarez/go-sqlite v1.22.0/go.mod h1:PlBIdHe0+aUEFn+r2/uthrWq4FxbzugL0L8Li6yQJbc=
+github.com/go-jose/go-jose/v3 v3.0.4 h1:Wp5HA7bLQcKnf6YYao/4kpRpVMp/yf6+pJKV8WFSaNY=
+github.com/go-jose/go-jose/v3 v3.0.4/go.mod h1:5b+7YgP7ZICgJDBdfjZaIt+H/9L9T/YQrVfLAMboGkQ=
 github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
 github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
+github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw=
+github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
 github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gopxl/beep/v2 v2.1.1 h1:6FYIYMm2qPAdWkjX+7xwKrViS1x0Po5kDMdRkq8NVbU=
-github.com/gopxl/beep/v2 v2.1.1/go.mod h1:ZAm9TGQ9lvpoiFLd4zf5B1IuyxZhgRACMId1XJbaW0E=
-github.com/gordonklaus/portaudio v0.0.0-20250206071425-98a94950218b h1:WEuQWBxelOGHA6z9lABqaMLMrfwVyMdN3UgRLT+YUPo=
-github.com/gordonklaus/portaudio v0.0.0-20250206071425-98a94950218b/go.mod h1:esZFQEUwqC+l76f2R8bIWSwXMaPbp79PppwZ1eJhFco=
 github.com/hajimehoshi/go-mp3 v0.3.4 h1:NUP7pBYH8OguP4diaTZ9wJbUbk3tC0KlfzsEpWmYj68=
 github.com/hajimehoshi/go-mp3 v0.3.4/go.mod h1:fRtZraRFcWb0pu7ok0LqyFhCUrPeMsGRSVop0eemFmo=
-github.com/hajimehoshi/oto/v2 v2.3.1 h1:qrLKpNus2UfD674oxckKjNJmesp9hMh7u7QCrStB3Rc=
 github.com/hajimehoshi/oto/v2 v2.3.1/go.mod h1:seWLbgHH7AyUMYKfKYT9pg7PhUu9/SisyJvNTT+ASQo=
 github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
 github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
@@ -53,12 +54,16 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db h1:62I3jR2EmQ4l5rM/4FEfDWcRD+abF5XlKShorW5LRoQ=
+github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw=
 github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
 github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
 github.com/neurosnap/sentences v1.1.2 h1:iphYOzx/XckXeBiLIUBkPu2EKMJ+6jDbz/sLJZ7ZoUw=
 github.com/neurosnap/sentences v1.1.2/go.mod h1:/pwU4E9XNL21ygMIkOIllv/SMy2ujHwpf8GQPu1YPbQ=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
+github.com/playwright-community/playwright-go v0.5700.1 h1:PNFb1byWqrTT720rEO0JL88C6Ju0EmUnR5deFLvtP/U=
+github.com/playwright-community/playwright-go v0.5700.1/go.mod h1:MlSn1dZrx8rszbCxY6x3qK89ZesJUYVx21B2JnkoNF0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
@@ -67,8 +72,19 @@ github.com/rivo/tview v0.42.0 h1:b/ftp+RxtDsHSaynXTbJb+/n/BxDEi+W3UfF5jILK6c=
 github.com/rivo/tview v0.42.0/go.mod h1:cSfIYfhpSGCjp3r/ECJb+GKS7cGJnqV8vfjQPwoXyfY=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/schollz/progressbar/v2 v2.15.0 h1:dVzHQ8fHRmtPjD3K10jT3Qgn/+H+92jhPrhmxIJfDz8=
+github.com/schollz/progressbar/v2 v2.15.0/go.mod h1:UdPq3prGkfQ7MOzZKlDRpYKcFqEMczbD7YmbPgpzKMI=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/sugarme/regexpset v0.0.0-20200920021344-4d4ec8eaf93c h1:pwb4kNSHb4K89ymCaN+5lPH/MwnfSVg4rzGDh4d+iy4=
+github.com/sugarme/regexpset v0.0.0-20200920021344-4d4ec8eaf93c/go.mod h1:2gwkXLWbDGUQWeL3RtpCmcY4mzCtU13kb9UsAg9xMaw=
+github.com/sugarme/tokenizer v0.3.0 h1:FE8DYbNSz/kSbgEo9l/RjgYHkIJYEdskumitFQBE9FE=
+github.com/sugarme/tokenizer v0.3.0/go.mod h1:VJ+DLK5ZEZwzvODOWwY0cw+B1dabTd3nCB5HuFCItCc=
+github.com/yalue/onnxruntime_go v1.27.0 h1:c1YSgDNtpf0WGtxj3YeRIb8VC5LmM1J+Ve3uHdteC1U=
+github.com/yalue/onnxruntime_go v1.27.0/go.mod h1:b4X26A8pekNb1ACJ58wAXgNKeUCGEAQ9dmACut9Sm/4=
 github.com/yuin/goldmark v1.4.13 h1:fVcFKWvrslecOb/tg+Cc05dkeYx540o0FuFt3nUVDoE=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
@@ -152,6 +168,8 @@ golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxb
 golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA=
 golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 modernc.org/cc/v4 v4.27.1 h1:9W30zRlYrefrDV2JE2O8VDtJ1yPGownxciz5rrbQZis=

helpfuncs.go

@@ -5,13 +5,14 @@ import (
 	"gf-lt/models"
 	"gf-lt/pngmeta"
 	"image"
-	"net/url"
 	"os"
 	"os/exec"
 	"path"
 	"path/filepath"
 	"slices"
+	"strconv"
 	"strings"
+	"sync/atomic"
 	"time"
 	"unicode"
 
@@ -19,7 +20,8 @@ import (
 )
 
 // Cached model color - updated by background goroutine
-var cachedModelColor string = "orange"
+// var cachedModelColor string = "orange"
+var cachedModelColor atomic.Value
 
 // startModelColorUpdater starts a background goroutine that periodically updates
 // the cached model color. Only runs HTTP requests for local llama.cpp APIs.
@@ -38,20 +40,20 @@ func startModelColorUpdater() {
 // updateCachedModelColor updates the global cachedModelColor variable
 func updateCachedModelColor() {
 	if !isLocalLlamacpp() {
-		cachedModelColor = "orange"
+		cachedModelColor.Store("orange")
 		return
 	}
 	// Check if model is loaded
 	loaded, err := isModelLoaded(chatBody.Model)
 	if err != nil {
 		// On error, assume not loaded (red)
-		cachedModelColor = "red"
+		cachedModelColor.Store("red")
 		return
 	}
 	if loaded {
-		cachedModelColor = "green"
+		cachedModelColor.Store("green")
 	} else {
-		cachedModelColor = "red"
+		cachedModelColor.Store("red")
 	}
 }
 
@@ -84,8 +86,8 @@ func stripThinkingFromMsg(msg *models.RoleMsg) *models.RoleMsg {
 	}
 	// Strip thinking from assistant messages
 	msgText := msg.GetText()
-	if thinkRE.MatchString(msgText) {
+	if models.ThinkRE.MatchString(msgText) {
-		cleanedText := thinkRE.ReplaceAllString(msgText, "")
+		cleanedText := models.ThinkRE.ReplaceAllString(msgText, "")
 		cleanedText = strings.TrimSpace(cleanedText)
 		msg.SetText(cleanedText)
 	}
@@ -107,7 +109,7 @@ func refreshChatDisplay() {
 	textView.SetText(displayText)
 	colorText()
 	updateStatusLine()
-	if scrollToEndEnabled {
+	if cfg.AutoScrollEnabled {
 		textView.ScrollToEnd()
 	}
 }
@@ -146,7 +148,7 @@ func colorText() {
 	placeholderThink := "__THINK_BLOCK_%d__"
 	counterThink := 0
 	// Replace code blocks with placeholders and store their styled versions
-	text = codeBlockRE.ReplaceAllStringFunc(text, func(match string) string {
+	text = models.CodeBlockRE.ReplaceAllStringFunc(text, func(match string) string {
 		// Style the code block and store it
 		styled := fmt.Sprintf("[red::i]%s[-:-:-]", match)
 		codeBlocks = append(codeBlocks, styled)
@@ -155,7 +157,7 @@ func colorText() {
 		counter++
 		return id
 	})
-	text = thinkRE.ReplaceAllStringFunc(text, func(match string) string {
+	text = models.ThinkRE.ReplaceAllStringFunc(text, func(match string) string {
 		// Style the code block and store it
 		styled := fmt.Sprintf("[red::i]%s[-:-:-]", match)
 		thinkBlocks = append(thinkBlocks, styled)
@@ -165,10 +167,10 @@ func colorText() {
 		return id
 	})
 	// Step 2: Apply other regex styles to the non-code parts
-	text = quotesRE.ReplaceAllString(text, `[orange::-]$1[-:-:-]`)
+	text = models.QuotesRE.ReplaceAllString(text, `[orange::-]$1[-:-:-]`)
-	text = starRE.ReplaceAllString(text, `[turquoise::i]$1[-:-:-]`)
+	text = models.StarRE.ReplaceAllString(text, `[turquoise::i]$1[-:-:-]`)
-	text = singleBacktickRE.ReplaceAllString(text, "`[pink::i]$1[-:-:-]`")
+	text = models.SingleBacktickRE.ReplaceAllString(text, "`[pink::i]$1[-:-:-]`")
-	// text = thinkRE.ReplaceAllString(text, `[yellow::i]$1[-:-:-]`)
+	// text = tools.ThinkRE.ReplaceAllString(text, `[yellow::i]$1[-:-:-]`)
 	// Step 3: Restore the styled code blocks from placeholders
 	for i, cb := range codeBlocks {
 		text = strings.Replace(text, fmt.Sprintf(placeholder, i), cb, 1)
@@ -186,7 +188,7 @@ func updateStatusLine() {
 
 func initSysCards() ([]string, error) {
 	labels := []string{}
-	labels = append(labels, sysLabels...)
+	labels = append(labels, models.SysLabels...)
 	cards, err := pngmeta.ReadDirCards(cfg.SysDir, cfg.UserRole, logger)
 	if err != nil {
 		logger.Error("failed to read sys dir", "error", err)
@@ -197,7 +199,11 @@ func initSysCards() ([]string, error) {
 			logger.Warn("empty role", "file", cc.FilePath)
 			continue
 		}
-		sysMap[cc.Role] = cc
+		if cc.ID == "" {
+			cc.ID = models.ComputeCardID(cc.Role, cc.FilePath)
+		}
+		sysMap[cc.ID] = cc
+		roleToID[cc.Role] = cc.ID
 		labels = append(labels, cc.Role)
 	}
 	return labels, nil
@@ -286,24 +292,25 @@ func listRolesWithUser() []string {
 	return result
 }
 
-func loadImage() {
+func loadImage() error {
 	filepath := defaultImage
-	cc, ok := sysMap[cfg.AssistantRole]
+	cc := GetCardByRole(cfg.AssistantRole)
-	if ok {
+	if cc != nil {
 		if strings.HasSuffix(cc.FilePath, ".png") {
 			filepath = cc.FilePath
 		}
 	}
 	file, err := os.Open(filepath)
 	if err != nil {
-		panic(err)
+		return fmt.Errorf("failed to open image: %w", err)
 	}
 	defer file.Close()
 	img, _, err := image.Decode(file)
 	if err != nil {
-		panic(err)
+		return fmt.Errorf("failed to decode image: %w", err)
 	}
 	imgView.SetImage(img)
+	return nil
 }
 
 func strInSlice(s string, sl []string) bool {
@@ -317,19 +324,17 @@ func strInSlice(s string, sl []string) bool {
 
 // isLocalLlamacpp checks if the current API is a local llama.cpp instance.
 func isLocalLlamacpp() bool {
-	u, err := url.Parse(cfg.CurrentAPI)
+	if strings.Contains(cfg.CurrentAPI, "openrouter") || strings.Contains(cfg.CurrentAPI, "deepseek") {
-	if err != nil {
 		return false
 	}
-	host := u.Hostname()
+	return true
-	return host == "localhost" || host == "127.0.0.1" || host == "::1"
 }
 
 // getModelColor returns the cached color tag for the model name.
 // The cached value is updated by a background goroutine every 5 seconds.
 // For non-local models, returns orange. For local llama.cpp models, returns green if loaded, red if not.
 func getModelColor() string {
-	return cachedModelColor
+	return cachedModelColor.Load().(string)
 }
 
 func makeStatusLine() string {
@@ -376,9 +381,90 @@ func makeStatusLine() string {
 		roleInject := fmt.Sprintf(" | [%s:-:b]role injection[-:-:-] (alt+7)", boolColors[injectRole])
 		statusLine += roleInject
 	}
+	// context tokens
+	contextTokens := getContextTokens()
+	maxCtx := getMaxContextTokens()
+	if maxCtx == 0 {
+		maxCtx = 16384
+	}
+	if contextTokens > 0 {
+		contextInfo := fmt.Sprintf(" | context-estim: [orange:-:b]%d/%d[-:-:-]", contextTokens, maxCtx)
+		statusLine += contextInfo
+	}
 	return statusLine + imageInfo + shellModeInfo
 }
 
+func getContextTokens() int {
+	if chatBody == nil || chatBody.Messages == nil {
+		return 0
+	}
+	total := 0
+	messages := chatBody.Messages
+	for i := range messages {
+		msg := &messages[i]
+		if msg.Stats != nil && msg.Stats.Tokens > 0 {
+			total += msg.Stats.Tokens
+		} else if msg.GetText() != "" {
+			total += len(msg.GetText()) / 4
+		}
+	}
+	return total
+}
+
+const deepseekContext = 128000
+
+func getMaxContextTokens() int {
+	if chatBody == nil || chatBody.Model == "" {
+		return 0
+	}
+	modelName := chatBody.Model
+	switch {
+	case strings.Contains(cfg.CurrentAPI, "openrouter"):
+		if orModelsData != nil {
+			for i := range orModelsData.Data {
+				m := &orModelsData.Data[i]
+				if m.ID == modelName {
+					return m.ContextLength
+				}
+			}
+		}
+	case strings.Contains(cfg.CurrentAPI, "deepseek"):
+		return deepseekContext
+	default:
+		if localModelsData != nil {
+			for i := range localModelsData.Data {
+				m := &localModelsData.Data[i]
+				if m.ID == modelName {
+					for _, arg := range m.Status.Args {
+						if strings.HasPrefix(arg, "--ctx-size") {
+							if strings.Contains(arg, "=") {
+								val := strings.Split(arg, "=")[1]
+								if n, err := strconv.Atoi(val); err == nil {
+									return n
+								}
+							} else {
+								idx := -1
+								for j, a := range m.Status.Args {
+									if a == "--ctx-size" && j+1 < len(m.Status.Args) {
+										idx = j + 1
+										break
+									}
+								}
+								if idx != -1 {
+									if n, err := strconv.Atoi(m.Status.Args[idx]); err == nil {
+										return n
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	return 0
+}
+
 // set of roles within card definition and mention in chat history
 func listChatRoles() []string {
 	currentChat, ok := chatMap[activeChatName]
@@ -386,13 +472,9 @@ func listChatRoles() []string {
 	if !ok {
 		return cbc
 	}
-	currentCard, ok := sysMap[currentChat.Agent]
+	currentCard := GetCardByRole(currentChat.Agent)
-	if !ok {
+	if currentCard == nil {
-		// case which won't let to switch roles:
+		logger.Warn("failed to find current card", "agent", currentChat.Agent)
-		// started new chat (basic_sys or any other), at the start it yet be saved or have chatbody
-		// if it does not have a card or chars, it'll return an empty slice
-		// log error
-		logger.Warn("failed to find current card in sysMap", "agent", currentChat.Agent, "sysMap", sysMap)
 		return cbc
 	}
 	charset := []string{}
@@ -408,10 +490,7 @@ func listChatRoles() []string {
 func deepseekModelValidator() error {
 	if cfg.CurrentAPI == cfg.DeepSeekChatAPI || cfg.CurrentAPI == cfg.DeepSeekCompletionAPI {
 		if chatBody.Model != "deepseek-chat" && chatBody.Model != "deepseek-reasoner" {
-			if err := notifyUser("bad request", "wrong deepseek model name"); err != nil {
+			showToast("bad request", "wrong deepseek model name")
-				logger.Warn("failed ot notify user", "error", err)
-				return err
-			}
 			return nil
 		}
 	}
@@ -441,7 +520,7 @@ func updateFlexLayout() {
 	if shellMode {
 		flex.AddItem(shellInput, 0, 10, false)
 	} else {
-		flex.AddItem(textArea, 0, 10, false)
+		flex.AddItem(bottomFlex, 0, 10, true)
 	}
 	if positionVisible {
 		flex.AddItem(statusLineWidget, 0, 2, false)
@@ -462,7 +541,7 @@ func executeCommandAndDisplay(cmdText string) {
 	cmdText = strings.TrimSpace(cmdText)
 	if cmdText == "" {
 		fmt.Fprintf(textView, "\n[red]Error: No command provided[-:-:-]\n")
-		if scrollToEndEnabled {
+		if cfg.AutoScrollEnabled {
 			textView.ScrollToEnd()
 		}
 		colorText()
@@ -494,7 +573,7 @@ func executeCommandAndDisplay(cmdText string) {
 				Content: "$ " + cmdText + "\n\n" + outputContent,
 			}
 			chatBody.Messages = append(chatBody.Messages, combinedMsg)
-			if scrollToEndEnabled {
+			if cfg.AutoScrollEnabled {
 				textView.ScrollToEnd()
 			}
 			colorText()
@@ -509,7 +588,7 @@ func executeCommandAndDisplay(cmdText string) {
 				Content: "$ " + cmdText + "\n\n" + outputContent,
 			}
 			chatBody.Messages = append(chatBody.Messages, combinedMsg)
-			if scrollToEndEnabled {
+			if cfg.AutoScrollEnabled {
 				textView.ScrollToEnd()
 			}
 			colorText()
@@ -557,7 +636,7 @@ func executeCommandAndDisplay(cmdText string) {
 	}
 	chatBody.Messages = append(chatBody.Messages, combinedMsg)
 	// Scroll to end and update colors
-	if scrollToEndEnabled {
+	if cfg.AutoScrollEnabled {
 		textView.ScrollToEnd()
 	}
 	colorText()
@@ -611,9 +690,7 @@ func performSearch(term string) {
 		searchResults = nil
 		searchResultLengths = nil
 		notification := "Pattern not found: " + term
-		if err := notifyUser("search", notification); err != nil {
+		showToast("search", notification)
-			logger.Error("failed to send notification", "error", err)
-		}
 		return
 	}
 	// Store the formatted text positions and lengths for accurate highlighting
@@ -646,9 +723,7 @@ func highlightCurrentMatch() {
 	textView.Highlight(currentRegion).ScrollToHighlight()
 	// Send notification about which match we're at
 	notification := fmt.Sprintf("Match %d of %d", searchIndex+1, len(searchResults))
-	if err := notifyUser("search", notification); err != nil {
+	showToast("search", notification)
-		logger.Error("failed to send notification", "error", err)
-	}
 }
 
 // showSearchBar shows the search input field as an overlay
@@ -738,9 +813,7 @@ func addRegionTags(text string, positions []int, lengths []int, currentIdx int,
 // searchNext finds the next occurrence of the search term
 func searchNext() {
 	if len(searchResults) == 0 {
-		if err := notifyUser("search", "No search results to navigate"); err != nil {
+		showToast("search", "No search results to navigate")
-			logger.Error("failed to send notification", "error", err)
-		}
 		return
 	}
 	searchIndex = (searchIndex + 1) % len(searchResults)
@@ -750,9 +823,7 @@ func searchNext() {
 // searchPrev finds the previous occurrence of the search term
 func searchPrev() {
 	if len(searchResults) == 0 {
-		if err := notifyUser("search", "No search results to navigate"); err != nil {
+		showToast("search", "No search results to navigate")
-			logger.Error("failed to send notification", "error", err)
-		}
 		return
 	}
 	if searchIndex == 0 {
@@ -895,3 +966,60 @@ func extractDisplayPath(p, bp string) string {
 	}
 	return p
 }
+
+func getValidKnowToRecipient(msg *models.RoleMsg) (string, bool) {
+	if cfg == nil || !cfg.CharSpecificContextEnabled {
+		return "", false
+	}
+	// case where all roles are in the tag => public message
+	cr := listChatRoles()
+	slices.Sort(cr)
+	slices.Sort(msg.KnownTo)
+	if slices.Equal(cr, msg.KnownTo) {
+		logger.Info("got msg with tag mentioning every role")
+		return "", false
+	}
+	// Check each character in the KnownTo list
+	for _, recipient := range msg.KnownTo {
+		if recipient == msg.Role || recipient == cfg.ToolRole {
+			// weird cases, skip
+			continue
+		}
+		// Skip if this is the user character (user handles their own turn)
+		// If user is in KnownTo, stop processing - it's the user's turn
+		if recipient == cfg.UserRole || recipient == cfg.WriteNextMsgAs {
+			return "", false
+		}
+		return recipient, true
+	}
+	return "", false
+}
+
+// triggerPrivateMessageResponses checks if a message was sent privately to specific characters
+// and triggers those non-user characters to respond
+func triggerPrivateMessageResponses(msg *models.RoleMsg) {
+	recipient, ok := getValidKnowToRecipient(msg)
+	if !ok || recipient == "" {
+		return
+	}
+	// Trigger the recipient character to respond
+	triggerMsg := recipient + ":\n"
+	// Send empty message so LLM continues naturally from the conversation
+	crr := &models.ChatRoundReq{
+		UserMsg: triggerMsg,
+		Role:    recipient,
+		Resume:  true,
+	}
+	fmt.Fprintf(textView, "\n[-:-:b](%d) ", len(chatBody.Messages))
+	fmt.Fprint(textView, roleToIcon(recipient))
+	fmt.Fprint(textView, "[-:-:-]\n")
+	chatRoundChan <- crr
+}
+
+func GetCardByRole(role string) *models.CharCard {
+	cardID, ok := roleToID[role]
+	if !ok {
+		return nil
+	}
+	return sysMap[cardID]
+}

llm.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"gf-lt/models"
+	"gf-lt/tools"
 	"io"
 	"strings"
 )
@@ -11,10 +12,10 @@ import (
 var imageAttachmentPath string // Global variable to track image attachment for next message
 var lastImg string             // for ctrl+j
 
-// containsToolSysMsg checks if the toolSysMsg already exists in the chat body
+// containsToolSysMsg checks if the tools.ToolSysMsg already exists in the chat body
 func containsToolSysMsg() bool {
 	for i := range chatBody.Messages {
-		if chatBody.Messages[i].Role == cfg.ToolRole && chatBody.Messages[i].Content == toolSysMsg {
+		if chatBody.Messages[i].Role == cfg.ToolRole && chatBody.Messages[i].Content == tools.ToolSysMsg {
 			return true
 		}
 	}
@@ -62,11 +63,11 @@ type ChunkParser interface {
 func choseChunkParser() {
 	chunkParser = LCPCompletion{}
 	switch cfg.CurrentAPI {
-	case "http://localhost:8080/completion":
+	case "http://localhost:8080/completion", "http://127.0.0.1:8080/completion":
 		chunkParser = LCPCompletion{}
 		logger.Debug("chosen lcpcompletion", "link", cfg.CurrentAPI)
 		return
-	case "http://localhost:8080/v1/chat/completions":
+	case "http://localhost:8080/v1/chat/completions", "http://127.0.0.1:8080/v1/chat/completions":
 		chunkParser = LCPChat{}
 		logger.Debug("chosen lcpchat", "link", cfg.CurrentAPI)
 		return
@@ -87,6 +88,11 @@ func choseChunkParser() {
 		logger.Debug("chosen openrouterchat", "link", cfg.CurrentAPI)
 		return
 	default:
+		logger.Warn("unexpected case, assuming llama.cpp on non default address", "link", cfg.CurrentAPI)
+		if strings.Contains(cfg.CurrentAPI, "chat") {
+			chunkParser = LCPChat{}
+			return
+		}
 		chunkParser = LCPCompletion{}
 	}
 }
@@ -139,7 +145,7 @@ func (lcp LCPCompletion) FormMsg(msg, role string, resume bool) (io.Reader, erro
 	}
 	// sending description of the tools and how to use them
 	if cfg.ToolUse && !resume && role == cfg.UserRole && !containsToolSysMsg() {
-		chatBody.Messages = append(chatBody.Messages, models.RoleMsg{Role: cfg.ToolRole, Content: toolSysMsg})
+		chatBody.Messages = append(chatBody.Messages, models.RoleMsg{Role: cfg.ToolRole, Content: tools.ToolSysMsg})
 	}
 	filteredMessages, botPersona := filterMessagesForCurrentCharacter(chatBody.Messages)
 	// Build prompt and extract images inline as we process each message
@@ -224,11 +230,9 @@ func (op LCPChat) ParseChunk(data []byte) (*models.TextChunk, error) {
 		logger.Error("failed to decode", "error", err, "line", string(data))
 		return nil, err
 	}
-
-	// Handle multiple choices safely
 	if len(llmchunk.Choices) == 0 {
-		logger.Warn("LCPChat ParseChunk: no choices in response", "data", string(data))
+		logger.Warn("LCPChat empty chunk choices", "raw_data", string(data), "chunk", llmchunk)
-		return &models.TextChunk{Finished: true}, nil
+		return &models.TextChunk{}, nil
 	}
 	lastChoice := llmchunk.Choices[len(llmchunk.Choices)-1]
 	resp := &models.TextChunk{
@@ -328,7 +332,7 @@ func (op LCPChat) FormMsg(msg, role string, resume bool) (io.Reader, error) {
 		Tools:    nil,
 	}
 	if cfg.ToolUse && !resume && role != cfg.ToolRole {
-		req.Tools = baseTools // set tools to use
+		req.Tools = tools.BaseTools // set tools to use
 	}
 	data, err := json.Marshal(req)
 	if err != nil {
@@ -349,6 +353,10 @@ func (ds DeepSeekerCompletion) ParseChunk(data []byte) (*models.TextChunk, error
 		logger.Error("failed to decode", "error", err, "line", string(data))
 		return nil, err
 	}
+	if len(llmchunk.Choices) == 0 {
+		logger.Warn("empty chunk choices", "raw_data", string(data), "chunk", llmchunk)
+		return &models.TextChunk{}, nil
+	}
 	resp := &models.TextChunk{
 		Chunk: llmchunk.Choices[0].Text,
 	}
@@ -377,7 +385,7 @@ func (ds DeepSeekerCompletion) FormMsg(msg, role string, resume bool) (io.Reader
 	}
 	// sending description of the tools and how to use them
 	if cfg.ToolUse && !resume && role == cfg.UserRole && !containsToolSysMsg() {
-		chatBody.Messages = append(chatBody.Messages, models.RoleMsg{Role: cfg.ToolRole, Content: toolSysMsg})
+		chatBody.Messages = append(chatBody.Messages, models.RoleMsg{Role: cfg.ToolRole, Content: tools.ToolSysMsg})
 	}
 	filteredMessages, botPersona := filterMessagesForCurrentCharacter(chatBody.Messages)
 	messages := make([]string, len(filteredMessages))
@@ -414,6 +422,10 @@ func (ds DeepSeekerChat) ParseChunk(data []byte) (*models.TextChunk, error) {
 		return nil, err
 	}
 	resp := &models.TextChunk{}
+	if len(llmchunk.Choices) == 0 {
+		logger.Warn("empty chunk choices", "raw_data", string(data), "chunk", llmchunk)
+		return resp, nil
+	}
 	if llmchunk.Choices[0].FinishReason != "" {
 		if llmchunk.Choices[0].Delta.Content != "" {
 			logger.Error("text inside of finish llmchunk", "chunk", llmchunk)
@@ -496,6 +508,10 @@ func (or OpenRouterCompletion) ParseChunk(data []byte) (*models.TextChunk, error
 		logger.Error("failed to decode", "error", err, "line", string(data))
 		return nil, err
 	}
+	if len(llmchunk.Choices) == 0 {
+		logger.Warn("empty chunk choices", "raw_data", string(data), "chunk", llmchunk)
+		return &models.TextChunk{}, nil
+	}
 	resp := &models.TextChunk{
 		Chunk: llmchunk.Choices[len(llmchunk.Choices)-1].Text,
 	}
@@ -521,7 +537,7 @@ func (or OpenRouterCompletion) FormMsg(msg, role string, resume bool) (io.Reader
 	}
 	// sending description of the tools and how to use them
 	if cfg.ToolUse && !resume && role == cfg.UserRole && !containsToolSysMsg() {
-		chatBody.Messages = append(chatBody.Messages, models.RoleMsg{Role: cfg.ToolRole, Content: toolSysMsg})
+		chatBody.Messages = append(chatBody.Messages, models.RoleMsg{Role: cfg.ToolRole, Content: tools.ToolSysMsg})
 	}
 	filteredMessages, botPersona := filterMessagesForCurrentCharacter(chatBody.Messages)
 	messages := make([]string, len(filteredMessages))
@@ -558,6 +574,10 @@ func (or OpenRouterChat) ParseChunk(data []byte) (*models.TextChunk, error) {
 		logger.Error("failed to decode", "error", err, "line", string(data))
 		return nil, err
 	}
+	if len(llmchunk.Choices) == 0 {
+		logger.Warn("empty chunk choices", "raw_data", string(data), "chunk", llmchunk)
+		return &models.TextChunk{}, nil
+	}
 	lastChoice := llmchunk.Choices[len(llmchunk.Choices)-1]
 	resp := &models.TextChunk{
 		Chunk:     lastChoice.Delta.Content,
@@ -652,7 +672,7 @@ func (or OpenRouterChat) FormMsg(msg, role string, resume bool) (io.Reader, erro
 	bodyCopy.Messages = consolidateAssistantMessages(bodyCopy.Messages)
 	orBody := models.NewOpenRouterChatReq(*bodyCopy, defaultLCPProps, cfg.ReasoningEffort)
 	if cfg.ToolUse && !resume && role != cfg.ToolRole {
-		orBody.Tools = baseTools // set tools to use
+		orBody.Tools = tools.BaseTools // set tools to use
 	}
 	data, err := json.Marshal(orBody)
 	if err != nil {

main.go

@@ -1,13 +1,24 @@
 package main
 
 import (
+	"bufio"
+	"flag"
+	"fmt"
+	"gf-lt/models"
+	"gf-lt/pngmeta"
+	"os"
+	"slices"
+	"strconv"
+	"strings"
+	"sync/atomic"
+
 	"github.com/rivo/tview"
 )
 
 var (
 	boolColors        = map[bool]string{true: "green", false: "red"}
-	botRespMode       = false
+	botRespMode       atomic.Bool
-	toolRunningMode   = false
+	toolRunningMode   atomic.Bool
 	editMode          = false
 	roleEditMode      = false
 	injectRole        = true
@@ -17,11 +28,25 @@ var (
 	shellHistoryPos   int = -1
 	thinkingCollapsed     = false
 	toolCollapsed         = true
-	statusLineTempl       = "help (F12) | chat: [orange:-:b]%s[-:-:-] (F1) | [%s:-:b]tool use[-:-:-] (ctrl+k) | model: [%s:-:b]%s[-:-:-] (ctrl+l) | [%s:-:b]skip LLM resp[-:-:-] (F10)\nAPI: [orange:-:b]%s[-:-:-] (ctrl+v) | writing as: [orange:-:b]%s[-:-:-] (ctrl+q) | bot will write as [orange:-:b]%s[-:-:-] (ctrl+x)"
+	statusLineTempl       = "help (F12) | chat: [orange:-:b]%s[-:-:-] (F1) | [%s:-:b]tool use[-:-:-] (ctrl+k) | model: [%s:-:b]%s[-:-:-] (ctrl+l) | [%s:-:b]skip LLM resp[-:-:-] (F10) | API: [orange:-:b]%s[-:-:-] (ctrl+v)\nwriting as: [orange:-:b]%s[-:-:-] (ctrl+q) | bot will write as [orange:-:b]%s[-:-:-] (ctrl+x)"
 	focusSwitcher         = map[tview.Primitive]tview.Primitive{}
+	app               *tview.Application
+	cliCardPath       string
+	cliContinue       bool
+	cliMsg            string
 )
 
 func main() {
+	flag.BoolVar(&cfg.CLIMode, "cli", false, "Run in CLI mode without TUI")
+	flag.BoolVar(&cfg.ToolUse, "tools", true, "run with tools")
+	flag.StringVar(&cliCardPath, "card", "", "Path to syscard JSON file")
+	flag.BoolVar(&cliContinue, "continue", false, "Continue from last chat (by agent or card)")
+	flag.StringVar(&cliMsg, "msg", "", "Send message and exit (one-shot mode)")
+	flag.Parse()
+	if cfg.CLIMode {
+		runCLIMode()
+		return
+	}
 	pages.AddPage("main", flex, true, true)
 	if err := app.SetRoot(pages,
 		true).EnableMouse(cfg.EnableMouse).EnablePaste(true).Run(); err != nil {
@@ -29,3 +54,236 @@ func main() {
 		return
 	}
 }
+
+func runCLIMode() {
+	outputHandler = &CLIOutputHandler{}
+	cliRespDone = make(chan bool, 1)
+	if cliCardPath != "" {
+		card, err := pngmeta.ReadCardJson(cliCardPath)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Failed to load syscard: %v\n", err)
+			os.Exit(1)
+		}
+		cfg.AssistantRole = card.Role
+		sysMap[card.ID] = card
+		roleToID[card.Role] = card.ID
+		charToStart(card.Role, false)
+		fmt.Printf("Loaded syscard: %s (%s)\n", card.Role, card.FilePath)
+	}
+	if cliContinue {
+		if cliCardPath != "" {
+			history, err := loadAgentsLastChat(cfg.AssistantRole)
+			if err != nil {
+				fmt.Printf("No previous chat found for %s, starting new chat\n", cfg.AssistantRole)
+				startNewCLIChat()
+			} else {
+				chatBody.Messages = history
+				fmt.Printf("Continued chat: %s\n", activeChatName)
+			}
+		} else {
+			chatBody.Messages = loadOldChatOrGetNew()
+			fmt.Printf("Continued chat: %s\n", activeChatName)
+		}
+	} else {
+		startNewCLIChat()
+	}
+	printCLIWelcome()
+	go func() {
+		<-ctx.Done()
+		os.Exit(0)
+	}()
+	if cliMsg != "" {
+		persona := cfg.UserRole
+		if cfg.WriteNextMsgAs != "" {
+			persona = cfg.WriteNextMsgAs
+		}
+		chatRoundChan <- &models.ChatRoundReq{Role: persona, UserMsg: cliMsg}
+		<-cliRespDone
+		fmt.Println()
+		return
+	}
+	scanner := bufio.NewScanner(os.Stdin)
+	for {
+		fmt.Print("> ")
+		if !scanner.Scan() {
+			break
+		}
+		msg := scanner.Text()
+		if msg == "" {
+			continue
+		}
+		if strings.HasPrefix(msg, "/") {
+			if !handleCLICommand(msg) {
+				return
+			}
+			fmt.Println()
+			continue
+		}
+		persona := cfg.UserRole
+		if cfg.WriteNextMsgAs != "" {
+			persona = cfg.WriteNextMsgAs
+		}
+		chatRoundChan <- &models.ChatRoundReq{Role: persona, UserMsg: msg}
+		<-cliRespDone
+		fmt.Println()
+	}
+}
+
+func printCLIWelcome() {
+	fmt.Println("CLI Mode started. Type your messages or commands.")
+	fmt.Println("Type /help for available commands.")
+	fmt.Println()
+}
+
+func printCLIHelp() {
+	fmt.Println("Available commands:")
+	fmt.Println("  /help, /h              - Show this help message")
+	fmt.Println("  /new, /n               - Start a new chat (clears conversation)")
+	fmt.Println("  /card <path>, /c <path> - Load a different syscard")
+	fmt.Println("  /undo, /u              - Delete last message")
+	fmt.Println("  /history, /ls          - List chat history")
+	fmt.Println("  /load <name>           - Load a specific chat by name")
+	fmt.Println("  /model <name>, /m <name> - Switch model")
+	fmt.Println("  /api <index>, /a <index>  - Switch API link (no index to list)")
+	fmt.Println("  /quit, /q, /exit       - Exit CLI mode")
+	fmt.Println()
+	fmt.Printf("Current syscard: %s\n", cfg.AssistantRole)
+	fmt.Printf("Current model: %s\n", chatBody.Model)
+	fmt.Printf("Current API: %s\n", cfg.CurrentAPI)
+	fmt.Println()
+}
+
+func handleCLICommand(msg string) bool {
+	parts := strings.Fields(msg)
+	cmd := strings.ToLower(parts[0])
+	args := parts[1:]
+
+	switch cmd {
+	case "/help", "/h":
+		printCLIHelp()
+	case "/new", "/n":
+		startNewCLIChat()
+		fmt.Println("New chat started.")
+		fmt.Printf("Syscard: %s\n", cfg.AssistantRole)
+		fmt.Println()
+	case "/card", "/c":
+		if len(args) == 0 {
+			fmt.Println("Usage: /card <path>")
+			return true
+		}
+		card, err := pngmeta.ReadCardJson(args[0])
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Failed to load syscard: %v\n", err)
+			return true
+		}
+		cfg.AssistantRole = card.Role
+		sysMap[card.ID] = card
+		roleToID[card.Role] = card.ID
+		charToStart(card.Role, false)
+		startNewCLIChat()
+		fmt.Printf("Switched to syscard: %s (%s)\n", card.Role, card.FilePath)
+	case "/undo", "/u":
+		if len(chatBody.Messages) == 0 {
+			fmt.Println("No messages to delete.")
+			return true
+		}
+		chatBody.Messages = chatBody.Messages[:len(chatBody.Messages)-1]
+		cliPrevOutput = ""
+		fmt.Println("Last message deleted.")
+	case "/history", "/ls":
+		fmt.Println("Chat history:")
+		for name := range chatMap {
+			marker := "  "
+			if name == activeChatName {
+				marker = "* "
+			}
+			fmt.Printf("%s%s\n", marker, name)
+		}
+		fmt.Println()
+	case "/load":
+		if len(args) == 0 {
+			fmt.Println("Usage: /load <name>")
+			return true
+		}
+		name := args[0]
+		chat, ok := chatMap[name]
+		if !ok {
+			fmt.Printf("Chat not found: %s\n", name)
+			return true
+		}
+		history, err := chat.ToHistory()
+		if err != nil {
+			fmt.Printf("Failed to load chat: %v\n", err)
+			return true
+		}
+		chatBody.Messages = history
+		activeChatName = name
+		cfg.AssistantRole = chat.Agent
+		fmt.Printf("Loaded chat: %s\n", name)
+	case "/model", "/m":
+		getModelListForAPI := func(api string) []string {
+			if strings.Contains(api, "api.deepseek.com/") {
+				return []string{"deepseek-chat", "deepseek-reasoner"}
+			} else if strings.Contains(api, "openrouter.ai") {
+				return ORFreeModels
+			}
+			return LocalModels
+		}
+		modelList := getModelListForAPI(cfg.CurrentAPI)
+		if len(args) == 0 {
+			fmt.Println("Models:")
+			for i, model := range modelList {
+				marker := "  "
+				if model == chatBody.Model {
+					marker = "* "
+				}
+				fmt.Printf("%s%d: %s\n", marker, i, model)
+			}
+			fmt.Printf("\nCurrent model: %s\n", chatBody.Model)
+			return true
+		}
+		// Try index first, then model name
+		if idx, err := strconv.Atoi(args[0]); err == nil && idx >= 0 && idx < len(modelList) {
+			chatBody.Model = modelList[idx]
+			fmt.Printf("Switched to model: %s\n", chatBody.Model)
+			return true
+		}
+		if slices.Index(modelList, args[0]) < 0 {
+			fmt.Printf("Model '%s' not found. Use index or choose from:\n", args[0])
+			for i, model := range modelList {
+				fmt.Printf("  %d: %s\n", i, model)
+			}
+			return true
+		}
+		chatBody.Model = args[0]
+		fmt.Printf("Switched to model: %s\n", args[0])
+	case "/api", "/a":
+		if len(args) == 0 {
+			fmt.Println("API Links:")
+			for i, link := range cfg.ApiLinks {
+				marker := "  "
+				if link == cfg.CurrentAPI {
+					marker = "* "
+				}
+				fmt.Printf("%s%d: %s\n", marker, i, link)
+			}
+			fmt.Printf("\nCurrent API: %s\n", cfg.CurrentAPI)
+			return true
+		}
+		idx := 0
+		fmt.Sscanf(args[0], "%d", &idx)
+		if idx < 0 || idx >= len(cfg.ApiLinks) {
+			fmt.Printf("Invalid index. Valid range: 0-%d\n", len(cfg.ApiLinks)-1)
+			return true
+		}
+		cfg.CurrentAPI = cfg.ApiLinks[idx]
+		fmt.Printf("Switched to API: %s\n", cfg.CurrentAPI)
+	case "/quit", "/q", "/exit":
+		fmt.Println("Goodbye!")
+		return false
+	default:
+		fmt.Printf("Unknown command: %s\n", msg)
+		fmt.Println("Type /help for available commands.")
+	}
+	return true
+}

models/card.go

@@ -1,6 +1,10 @@
 package models
 
-import "strings"
+import (
+	"crypto/md5"
+	"fmt"
+	"strings"
+)
 
 // https://github.com/malfoyslastname/character-card-spec-v2/blob/main/spec_v2.md
 // what a bloat; trim to Role->Msg pair and first msg
@@ -31,6 +35,7 @@ func (c *CharCardSpec) Simplify(userName, fpath string) *CharCard {
 	fm := strings.ReplaceAll(strings.ReplaceAll(c.FirstMes, "{{char}}", c.Name), "{{user}}", userName)
 	sysPr := strings.ReplaceAll(strings.ReplaceAll(c.Description, "{{char}}", c.Name), "{{user}}", userName)
 	return &CharCard{
+		ID:         ComputeCardID(c.Name, fpath),
 		SysPrompt:  sysPr,
 		FirstMsg:   fm,
 		Role:       c.Name,
@@ -39,7 +44,12 @@ func (c *CharCardSpec) Simplify(userName, fpath string) *CharCard {
 	}
 }
 
+func ComputeCardID(role, filePath string) string {
+	return fmt.Sprintf("%x", md5.Sum([]byte(role+filePath)))
+}
+
 type CharCard struct {
+	ID         string   `json:"id"`
 	SysPrompt  string   `json:"sys_prompt"`
 	FirstMsg   string   `json:"first_msg"`
 	Role       string   `json:"role"`

models/consts.go

@@ -1,8 +1,12 @@
 package models
 
+import "regexp"
+
 const (
 	LoadedMark        = "(loaded) "
 	ToolRespMultyType = "multimodel_content"
+	DefaultFirstMsg   = "Hello! What can I do for you?"
+	BasicSysMsg       = "Large Language Model that helps user with any of his requests."
 )
 
 type APIType int
@@ -11,3 +15,17 @@ const (
 	APITypeChat APIType = iota
 	APITypeCompletion
 )
+
+var (
+	ToolCallRE       = regexp.MustCompile(`__tool_call__\s*([\s\S]*?)__tool_call__`)
+	QuotesRE         = regexp.MustCompile(`(".*?")`)
+	StarRE           = regexp.MustCompile(`(\*.*?\*)`)
+	ThinkRE          = regexp.MustCompile(`(?s)<think>.*?</think>`)
+	CodeBlockRE      = regexp.MustCompile(`(?s)\x60{3}(?:.*?)\n(.*?)\n\s*\x60{3}\s*`)
+	SingleBacktickRE = regexp.MustCompile(`\x60([^\x60]*)\x60`)
+	RoleRE           = regexp.MustCompile(`^(\w+):`)
+)
+
+var (
+	SysLabels = []string{"assistant"}
+)

pngmeta/metareader.go

@@ -109,6 +109,12 @@ func ReadCardJson(fname string) (*models.CharCard, error) {
 	if err := json.Unmarshal(data, &card); err != nil {
 		return nil, err
 	}
+	if card.FilePath == "" {
+		card.FilePath = fname
+	}
+	if card.ID == "" {
+		card.ID = models.ComputeCardID(card.Role, card.FilePath)
+	}
 	return &card, nil
 }
 

popups.go

@@ -40,9 +40,7 @@ func showModelSelectionPopup() {
 		default:
 			message = "No llama.cpp models loaded. Ensure llama.cpp server is running with models."
 		}
-		if err := notifyUser("Empty list", message); err != nil {
+		showToast("Empty list", message)
-			logger.Error("failed to send notification", "error", err)
-		}
 		return
 	}
 	// Create a list primitive
@@ -119,9 +117,7 @@ func showAPILinkSelectionPopup() {
 	if len(apiLinks) == 0 {
 		logger.Warn("no API links available for selection")
 		message := "No API links available. Please configure API links in your config file."
-		if err := notifyUser("Empty list", message); err != nil {
+		showToast("Empty list", message)
-			logger.Error("failed to send notification", "error", err)
-		}
 		return
 	}
 	// Create a list primitive
@@ -143,7 +139,7 @@ func showAPILinkSelectionPopup() {
 	apiListWidget.SetSelectedFunc(func(index int, mainText string, secondaryText string, shortcut rune) {
 		// Update the API in config
 		cfg.CurrentAPI = mainText
-		UpdateToolCapabilities()
+		// tools.UpdateToolCapabilities()
 		// Update model list based on new API
 		// Helper function to get model list for a given API (same as in props_table.go)
 		getModelListForAPI := func(api string) []string {
@@ -206,9 +202,7 @@ func showUserRoleSelectionPopup() {
 	if len(roles) == 0 {
 		logger.Warn("no roles available for selection")
 		message := "No roles available for selection."
-		if err := notifyUser("Empty list", message); err != nil {
+		showToast("Empty list", message)
-			logger.Error("failed to send notification", "error", err)
-		}
 		return
 	}
 	// Create a list primitive
@@ -285,9 +279,7 @@ func showBotRoleSelectionPopup() {
 	if len(roles) == 0 {
 		logger.Warn("no roles available for selection")
 		message := "No roles available for selection."
-		if err := notifyUser("Empty list", message); err != nil {
+		showToast("Empty list", message)
-			logger.Error("failed to send notification", "error", err)
-		}
 		return
 	}
 	// Create a list primitive
@@ -406,6 +398,66 @@ func showShellFileCompletionPopup(filter string) {
 	app.SetFocus(widget)
 }
 
+func showTextAreaFileCompletionPopup(filter string) {
+	baseDir := cfg.FilePickerDir
+	if baseDir == "" {
+		baseDir = "."
+	}
+	complMatches := scanFiles(baseDir, filter)
+	if len(complMatches) == 0 {
+		return
+	}
+	if len(complMatches) == 1 {
+		currentText := textArea.GetText()
+		atIdx := strings.LastIndex(currentText, "@")
+		if atIdx >= 0 {
+			before := currentText[:atIdx]
+			textArea.SetText(before+complMatches[0], true)
+		}
+		return
+	}
+	widget := tview.NewList().ShowSecondaryText(false).
+		SetSelectedBackgroundColor(tcell.ColorGray)
+	widget.SetTitle("file completion").SetBorder(true)
+	for _, m := range complMatches {
+		widget.AddItem(m, "", 0, nil)
+	}
+	widget.SetSelectedFunc(func(index int, mainText string, secondaryText string, shortcut rune) {
+		currentText := textArea.GetText()
+		atIdx := strings.LastIndex(currentText, "@")
+		if atIdx >= 0 {
+			before := currentText[:atIdx]
+			textArea.SetText(before+mainText, true)
+		}
+		pages.RemovePage("textAreaFileCompletionPopup")
+		app.SetFocus(textArea)
+	})
+	widget.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+		if event.Key() == tcell.KeyEscape {
+			pages.RemovePage("textAreaFileCompletionPopup")
+			app.SetFocus(textArea)
+			return nil
+		}
+		if event.Key() == tcell.KeyRune && event.Rune() == 'x' {
+			pages.RemovePage("textAreaFileCompletionPopup")
+			app.SetFocus(textArea)
+			return nil
+		}
+		return event
+	})
+	modal := func(p tview.Primitive, width, height int) tview.Primitive {
+		return tview.NewFlex().
+			AddItem(nil, 0, 1, false).
+			AddItem(tview.NewFlex().SetDirection(tview.FlexRow).
+				AddItem(nil, 0, 1, false).
+				AddItem(p, height, 1, true).
+				AddItem(nil, 0, 1, false), width, 1, true).
+			AddItem(nil, 0, 1, false)
+	}
+	pages.AddPage("textAreaFileCompletionPopup", modal(widget, 80, 20), true, true)
+	app.SetFocus(widget)
+}
+
 func updateWidgetColors(theme *tview.Theme) {
 	bgColor := theme.PrimitiveBackgroundColor
 	fgColor := theme.PrimaryTextColor
@@ -452,9 +504,7 @@ func showColorschemeSelectionPopup() {
 	if len(schemeNames) == 0 {
 		logger.Warn("no colorschemes available for selection")
 		message := "No colorschemes available."
-		if err := notifyUser("Empty list", message); err != nil {
+		showToast("Empty list", message)
-			logger.Error("failed to send notification", "error", err)
-		}
 		return
 	}
 	// Create a list primitive

props_table.go

@@ -115,18 +115,9 @@ func makePropsTable(props map[string]float32) *tview.Table {
 		row++
 	}
 	// Add checkboxes
-	addCheckboxRow("RAG use", cfg.RAGEnabled, func(checked bool) {
-		cfg.RAGEnabled = checked
-	})
-	addCheckboxRow("Inject role", injectRole, func(checked bool) {
-		injectRole = checked
-	})
 	addCheckboxRow("TTS Enabled", cfg.TTS_ENABLED, func(checked bool) {
 		cfg.TTS_ENABLED = checked
 	})
-	addCheckboxRow("Auto clean tool calls from context", cfg.AutoCleanToolCallsFromCtx, func(checked bool) {
-		cfg.AutoCleanToolCallsFromCtx = checked
-	})
 	addCheckboxRow("Enable Mouse", cfg.EnableMouse, func(checked bool) {
 		cfg.EnableMouse = checked
 		// Reconfigure the app's mouse setting
@@ -259,9 +250,7 @@ func makePropsTable(props map[string]float32) *tview.Table {
 				// Handle nil options
 				if data.Options == nil {
 					logger.Error("options list is nil for", "label", label)
-					if err := notifyUser("Configuration error", "Options list is nil for "+label); err != nil {
+					showToast("Configuration error", "Options list is nil for "+label)
-						logger.Error("failed to send notification", "error", err)
-					}
 					return
 				}
 
@@ -279,9 +268,7 @@ func makePropsTable(props map[string]float32) *tview.Table {
 							message = "No llama.cpp models loaded. Ensure llama.cpp server is running with models."
 						}
 					}
-					if err := notifyUser("Empty list", message); err != nil {
+					showToast("Empty list", message)
-						logger.Error("failed to send notification", "error", err)
-					}
 					return
 				}
 				// Create a list primitive

rag/embedder.go

@@ -9,6 +9,13 @@ import (
 	"gf-lt/models"
 	"log/slog"
 	"net/http"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/sugarme/tokenizer"
+	"github.com/sugarme/tokenizer/pretrained"
+	"github.com/yalue/onnxruntime_go"
 )
 
 // Embedder defines the interface for embedding text
@@ -27,8 +34,10 @@ type APIEmbedder struct {
 func NewAPIEmbedder(l *slog.Logger, cfg *config.Config) *APIEmbedder {
 	return &APIEmbedder{
 		logger: l,
-		client: &http.Client{},
+		client: &http.Client{
-		cfg:    cfg,
+			Timeout: 30 * time.Second,
+		},
+		cfg: cfg,
 	}
 }
 
@@ -134,11 +143,302 @@ func (a *APIEmbedder) EmbedSlice(lines []string) ([][]float32, error) {
 	return embeddings, nil
 }
 
-// TODO: ONNXEmbedder implementation would go here
-// This would require:
 // 1. Loading ONNX models locally
 // 2. Using a Go ONNX runtime (like gorgonia/onnx or similar)
 // 3. Converting text to embeddings without external API calls
-//
+type ONNXEmbedder struct {
-// For now, we'll focus on the API implementation which is already working in the current system,
+	session       *onnxruntime_go.DynamicAdvancedSession
-// and can be extended later when we have ONNX runtime integration
+	tokenizer     *tokenizer.Tokenizer
+	tokenizerPath string
+	dims          int
+	logger        *slog.Logger
+	mu            sync.Mutex
+	modelPath     string
+}
+
+var onnxInitOnce sync.Once
+var onnxReady bool
+var onnxLibPath string
+var cudaLibPath string
+
+var onnxLibPaths = []string{
+	"/usr/lib/libonnxruntime.so",
+	"/usr/lib/libonnxruntime.so.1.24.2",
+	"/usr/local/lib/libonnxruntime.so",
+	"/usr/lib/x86_64-linux-gnu/libonnxruntime.so",
+	"/opt/onnxruntime/lib/libonnxruntime.so",
+}
+
+var cudaLibPaths = []string{
+	"/usr/lib/libonnxruntime_providers_cuda.so",
+	"/usr/local/lib/libonnxruntime_providers_cuda.so",
+	"/opt/onnxruntime/lib/libonnxruntime_providers_cuda.so",
+}
+
+func findONNXLibrary() string {
+	for _, path := range onnxLibPaths {
+		if _, err := os.Stat(path); err == nil {
+			return path
+		}
+	}
+	return ""
+}
+
+func findCUDALibrary() string {
+	for _, path := range cudaLibPaths {
+		if _, err := os.Stat(path); err == nil {
+			return path
+		}
+	}
+	return ""
+}
+
+func NewONNXEmbedder(modelPath, tokenizerPath string, dims int, logger *slog.Logger) (*ONNXEmbedder, error) {
+	// Check if model and tokenizer files exist
+	if _, err := os.Stat(modelPath); err != nil {
+		return nil, fmt.Errorf("ONNX model not found: %w", err)
+	}
+	if _, err := os.Stat(tokenizerPath); err != nil {
+		return nil, fmt.Errorf("tokenizer not found: %w", err)
+	}
+
+	// Find ONNX library
+	onnxLibPath = findONNXLibrary()
+	if onnxLibPath == "" {
+		return nil, errors.New("ONNX runtime library not found in standard locations")
+	}
+
+	// Find CUDA provider library (optional)
+	cudaLibPath = findCUDALibrary()
+	if cudaLibPath == "" {
+		fmt.Println("WARNING: CUDA provider library not found, will use CPU")
+	}
+	emb := &ONNXEmbedder{
+		tokenizerPath: tokenizerPath,
+		dims:          dims,
+		logger:        logger,
+		modelPath:     modelPath,
+	}
+	return emb, nil
+}
+
+func (e *ONNXEmbedder) ensureInitialized() error {
+	if e.session != nil {
+		return nil
+	}
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	if e.session != nil {
+		return nil
+	}
+	// Load tokenizer lazily
+	if e.tokenizer == nil {
+		tok, err := pretrained.FromFile(e.tokenizerPath)
+		if err != nil {
+			return fmt.Errorf("failed to load tokenizer: %w", err)
+		}
+		e.tokenizer = tok
+	}
+	onnxInitOnce.Do(func() {
+		onnxruntime_go.SetSharedLibraryPath(onnxLibPath)
+		if err := onnxruntime_go.InitializeEnvironment(); err != nil {
+			e.logger.Error("failed to initialize ONNX runtime", "error", err)
+			onnxReady = false
+			return
+		}
+		// Register CUDA provider if available
+		if cudaLibPath != "" {
+			if err := onnxruntime_go.RegisterExecutionProviderLibrary("CUDA", cudaLibPath); err != nil {
+				e.logger.Warn("failed to register CUDA provider", "error", err)
+			}
+		}
+		onnxReady = true
+	})
+	if !onnxReady {
+		return errors.New("ONNX runtime not ready")
+	}
+	// Create session options
+	opts, err := onnxruntime_go.NewSessionOptions()
+	if err != nil {
+		return fmt.Errorf("failed to create session options: %w", err)
+	}
+	defer func() {
+		_ = opts.Destroy()
+	}()
+
+	// Try to add CUDA provider
+	useCUDA := cudaLibPath != ""
+	if useCUDA {
+		cudaOpts, err := onnxruntime_go.NewCUDAProviderOptions()
+		if err != nil {
+			e.logger.Warn("failed to create CUDA provider options, falling back to CPU", "error", err)
+			useCUDA = false
+		} else {
+			defer func() {
+				_ = cudaOpts.Destroy()
+			}()
+			if err := cudaOpts.Update(map[string]string{"device_id": "0"}); err != nil {
+				e.logger.Warn("failed to update CUDA options, falling back to CPU", "error", err)
+				useCUDA = false
+			} else if err := opts.AppendExecutionProviderCUDA(cudaOpts); err != nil {
+				e.logger.Warn("failed to append CUDA provider, falling back to CPU", "error", err)
+				useCUDA = false
+			}
+		}
+	}
+	if useCUDA {
+		e.logger.Info("Using CUDA for ONNX inference")
+	} else {
+		e.logger.Info("Using CPU for ONNX inference")
+	}
+
+	// Create session with options
+	session, err := onnxruntime_go.NewDynamicAdvancedSession(
+		e.getModelPath(),
+		[]string{"input_ids", "attention_mask"},
+		[]string{"sentence_embedding"},
+		opts,
+	)
+	if err != nil {
+		return fmt.Errorf("failed to create ONNX session: %w", err)
+	}
+	e.session = session
+	return nil
+}
+
+func (e *ONNXEmbedder) getModelPath() string {
+	return e.modelPath
+}
+
+func (e *ONNXEmbedder) Destroy() error {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	if e.session != nil {
+		if err := e.session.Destroy(); err != nil {
+			return fmt.Errorf("failed to destroy ONNX session: %w", err)
+		}
+		e.session = nil
+		e.logger.Info("ONNX session destroyed, VRAM freed")
+	}
+	return nil
+}
+
+func (e *ONNXEmbedder) Embed(text string) ([]float32, error) {
+	if err := e.ensureInitialized(); err != nil {
+		return nil, err
+	}
+	// 1. Tokenize
+	encoding, err := e.tokenizer.EncodeSingle(text)
+	if err != nil {
+		return nil, fmt.Errorf("tokenization failed: %w", err)
+	}
+	// 2. Convert to int64 and create attention mask
+	ids := encoding.Ids
+	inputIDs := make([]int64, len(ids))
+	attentionMask := make([]int64, len(ids))
+	for i, id := range ids {
+		inputIDs[i] = int64(id)
+		attentionMask[i] = 1
+	}
+	// 3. Create input tensors (shape: [1, seq_len])
+	seqLen := int64(len(inputIDs))
+	inputIDsTensor, err := onnxruntime_go.NewTensor[int64](
+		onnxruntime_go.NewShape(1, seqLen),
+		inputIDs,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create input_ids tensor: %w", err)
+	}
+	defer func() { _ = inputIDsTensor.Destroy() }()
+	maskTensor, err := onnxruntime_go.NewTensor[int64](
+		onnxruntime_go.NewShape(1, seqLen),
+		attentionMask,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create attention_mask tensor: %w", err)
+	}
+	defer func() { _ = maskTensor.Destroy() }()
+	// 4. Create output tensor
+	outputTensor, err := onnxruntime_go.NewEmptyTensor[float32](
+		onnxruntime_go.NewShape(1, int64(e.dims)),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create output tensor: %w", err)
+	}
+	defer func() { _ = outputTensor.Destroy() }()
+	// 5. Run inference
+	err = e.session.Run(
+		[]onnxruntime_go.Value{inputIDsTensor, maskTensor},
+		[]onnxruntime_go.Value{outputTensor},
+	)
+	if err != nil {
+		return nil, fmt.Errorf("inference failed: %w", err)
+	}
+	// 6. Copy output data
+	outputData := outputTensor.GetData()
+	embedding := make([]float32, len(outputData))
+	copy(embedding, outputData)
+	return embedding, nil
+}
+
+func (e *ONNXEmbedder) EmbedSlice(texts []string) ([][]float32, error) {
+	if err := e.ensureInitialized(); err != nil {
+		return nil, err
+	}
+	encodings := make([]*tokenizer.Encoding, len(texts))
+	maxLen := 0
+	for i, txt := range texts {
+		enc, err := e.tokenizer.EncodeSingle(txt)
+		if err != nil {
+			return nil, err
+		}
+		encodings[i] = enc
+		if l := len(enc.Ids); l > maxLen {
+			maxLen = l
+		}
+	}
+	batchSize := len(texts)
+	inputIDs := make([]int64, batchSize*maxLen)
+	attentionMask := make([]int64, batchSize*maxLen)
+	for i, enc := range encodings {
+		ids := enc.Ids
+		offset := i * maxLen
+		for j, id := range ids {
+			inputIDs[offset+j] = int64(id)
+			attentionMask[offset+j] = 1
+		}
+		// Remaining positions are already zero (padding)
+	}
+	// Create tensors with shape [batchSize, maxLen]
+	inputTensor, _ := onnxruntime_go.NewTensor[int64](
+		onnxruntime_go.NewShape(int64(batchSize), int64(maxLen)),
+		inputIDs,
+	)
+	defer func() { _ = inputTensor.Destroy() }()
+	maskTensor, _ := onnxruntime_go.NewTensor[int64](
+		onnxruntime_go.NewShape(int64(batchSize), int64(maxLen)),
+		attentionMask,
+	)
+	defer func() { _ = maskTensor.Destroy() }()
+	outputTensor, _ := onnxruntime_go.NewEmptyTensor[float32](
+		onnxruntime_go.NewShape(int64(batchSize), int64(e.dims)),
+	)
+	defer func() { _ = outputTensor.Destroy() }()
+	err := e.session.Run(
+		[]onnxruntime_go.Value{inputTensor, maskTensor},
+		[]onnxruntime_go.Value{outputTensor},
+	)
+	if err != nil {
+		return nil, err
+	}
+	// Extract embeddings per batch item
+	data := outputTensor.GetData()
+	embeddings := make([][]float32, batchSize)
+	for i := 0; i < batchSize; i++ {
+		start := i * e.dims
+		emb := make([]float32, e.dims)
+		copy(emb, data[start:start+e.dims])
+		embeddings[i] = emb
+	}
+	return embeddings, nil
+}

rag/rag_integration_test.go

@@ -0,0 +1,409 @@
+package rag
+
+import (
+	"fmt"
+	"gf-lt/config"
+	"gf-lt/models"
+	"gf-lt/storage"
+	"log/slog"
+	"testing"
+
+	_ "github.com/glebarez/go-sqlite"
+	"github.com/jmoiron/sqlx"
+)
+
+// mockEmbedder returns zero vectors of a fixed dimension.
+type mockEmbedder struct {
+	dim int
+}
+
+func (m *mockEmbedder) Embed(text string) ([]float32, error) {
+	vec := make([]float32, m.dim)
+	return vec, nil
+}
+
+func (m *mockEmbedder) EmbedSlice(texts []string) ([][]float32, error) {
+	vecs := make([][]float32, len(texts))
+	for i := range vecs {
+		vecs[i] = make([]float32, m.dim)
+	}
+	return vecs, nil
+}
+
+// dummyStore implements storage.FullRepo with a minimal set of methods.
+// Only DB() is used by VectorStorage; other methods return empty values.
+type dummyStore struct {
+	db *sqlx.DB
+}
+
+func (d dummyStore) DB() *sqlx.DB { return d.db }
+
+// ChatHistory methods
+func (d dummyStore) ListChats() ([]models.Chat, error)                     { return nil, nil }
+func (d dummyStore) GetChatByID(id uint32) (*models.Chat, error)           { return nil, nil }
+func (d dummyStore) GetChatByChar(char string) ([]models.Chat, error)      { return nil, nil }
+func (d dummyStore) GetLastChat() (*models.Chat, error)                    { return nil, nil }
+func (d dummyStore) GetLastChatByAgent(agent string) (*models.Chat, error) { return nil, nil }
+func (d dummyStore) UpsertChat(chat *models.Chat) (*models.Chat, error)    { return chat, nil }
+func (d dummyStore) RemoveChat(id uint32) error                            { return nil }
+func (d dummyStore) ChatGetMaxID() (uint32, error)                         { return 0, nil }
+
+// Memories methods
+func (d dummyStore) Memorise(m *models.Memory) (*models.Memory, error) { return m, nil }
+func (d dummyStore) Recall(agent, topic string) (string, error)        { return "", nil }
+func (d dummyStore) RecallTopics(agent string) ([]string, error)       { return nil, nil }
+func (d dummyStore) Forget(agent, topic string) error                  { return nil }
+
+// VectorRepo methods (not used but required by interface)
+func (d dummyStore) WriteVector(row *models.VectorRow) error { return nil }
+func (d dummyStore) SearchClosest(q []float32, limit int) ([]models.VectorRow, error) {
+	return nil, nil
+}
+func (d dummyStore) ListFiles() ([]string, error)              { return nil, nil }
+func (d dummyStore) RemoveEmbByFileName(filename string) error { return nil }
+
+var _ storage.FullRepo = dummyStore{}
+
+// setupTestRAG creates an in‑memory SQLite database, creates the necessary tables,
+// inserts the provided chunks, and returns a RAG instance with a mock embedder.
+func setupTestRAG(t *testing.T, chunks []*models.VectorRow) (*RAG, error) {
+	t.Helper()
+	db, err := sqlx.Open("sqlite", ":memory:")
+	if err != nil {
+		return nil, fmt.Errorf("open in‑memory db: %w", err)
+	}
+	// Create the required tables (embeddings_768 and fts_embeddings).
+	// Use the same schema as production.
+	_, err = db.Exec(`
+		CREATE TABLE embeddings_768 (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			embeddings BLOB NOT NULL,
+			slug TEXT NOT NULL,
+			raw_text TEXT NOT NULL,
+			filename TEXT NOT NULL DEFAULT ''
+		);
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("create embeddings table: %w", err)
+	}
+	_, err = db.Exec(`
+		CREATE VIRTUAL TABLE fts_embeddings USING fts5(
+			slug UNINDEXED,
+			raw_text,
+			filename UNINDEXED,
+			embedding_size UNINDEXED,
+			tokenize='porter unicode61'
+		);
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("create FTS table: %w", err)
+	}
+	// Create a logger that discards output.
+	logger := slog.New(slog.NewTextHandler(nil, &slog.HandlerOptions{Level: slog.LevelError}))
+	store := dummyStore{db: db}
+	// Create config with embedding dimension 768.
+	cfg := &config.Config{
+		EmbedDims:       768,
+		RAGWordLimit:    250,
+		RAGOverlapWords: 25,
+		RAGBatchSize:    1,
+	}
+	// Create a RAG instance using New, which will create an embedder based on config.
+	// We'll override the embedder afterwards via reflection.
+	rag, err := New(logger, store, cfg)
+	if err != nil {
+		return nil, fmt.Errorf("create RAG: %w", err)
+	}
+	// Replace the embedder with our mock.
+	rag.SetEmbedderForTesting(&mockEmbedder{dim: cfg.EmbedDims})
+	// Insert the provided chunks using the storage directly.
+	if len(chunks) > 0 {
+		// Ensure each chunk has embeddings of correct dimension (zero vector).
+		for _, chunk := range chunks {
+			if len(chunk.Embeddings) != cfg.EmbedDims {
+				chunk.Embeddings = make([]float32, cfg.EmbedDims)
+			}
+		}
+		err = rag.storage.WriteVectors(chunks)
+		if err != nil {
+			return nil, fmt.Errorf("write test chunks: %w", err)
+		}
+	}
+	return rag, nil
+}
+
+// createTestChunks returns a slice of VectorRow representing the target chunk
+// (kjv_bible.epub_1786_0), several bald‑related noise chunks, and unrelated chunks.
+func createTestChunks() []*models.VectorRow {
+	// Target chunk: 2 Kings 2:23‑24 containing "bald head" and "two she bears".
+	targetRaw := `And he said, Ye shall not send. 
+
+
+2:17 And when they urged him till he was ashamed, he said, Send.  They sent
+therefore fifty men; and they sought three days, but found him not. 
+
+
+2:18 And when they came again to him, (for he tarried at Jericho,) he said unto
+them, Did I not say unto you, Go not?  2:19 And the men of the city said unto
+Elisha, Behold, I pray thee, the situation of this city is pleasant, as my lord
+seeth: but the water is naught, and the ground barren. 
+
+
+2:20 And he said, Bring me a new cruse, and put salt therein.  And they brought
+it to him. 
+
+
+2:21 And he went forth unto the spring of the waters, and cast the salt in
+there, and said, Thus saith the LORD, I have healed these waters; there shall
+not be from thence any more death or barren land. 
+
+
+2:22 So the waters were healed unto this day, according to the saying of Elisha
+which he spake. 
+
+
+2:23 And he went up from thence unto Bethel: and as he was going up by the way,
+there came forth little children out of the city, and mocked him, and said unto
+him, Go up, thou bald head; go up, thou bald head. 
+
+
+2:24 And he turned back, and looked on them, and cursed them in the name of the
+LORD.  And there came forth two she bears out of the wood, and tare forty and
+two children of them.`
+	// Noise chunk 1: Leviticus containing "bald locust"
+	noise1Raw := `11:12 Whatsoever hath no fins nor scales in the waters, that shall be an
+abomination unto you. 
+
+
+11:13 And these are they which ye shall have in abomination among the fowls;
+they shall not be eaten, they are an abomination: the eagle, and the ossifrage,
+and the ospray, 11:14 And the vulture, and the kite after his kind; 11:15 Every
+raven after his kind; 11:16 And the owl, and the night hawk, and the cuckow,
+and the hawk after his kind, 11:17 And the little owl, and the cormorant, and
+the great owl, 11:18 And the swan, and the pelican, and the gier eagle, 11:19
+And the stork, the heron after her kind, and the lapwing, and the bat. 
+
+
+11:20 All fowls that creep, going upon all four, shall be an abomination unto
+you. 
+
+
+11:21 Yet these may ye eat of every flying creeping thing that goeth upon all
+four, which have legs above their feet, to leap withal upon the earth; 11:22
+Even these of them ye may eat; the locust after his kind, and the bald locust
+after his kind, and the beetle after his kind, and the grasshopper after his
+kind. 
+
+
+11:23 But all other flying creeping things, which have four feet, shall be an
+abomination unto you. 
+
+
+11:24 And for these ye shall be unclean: whosoever toucheth the carcase of them
+shall be unclean until the even.`
+	// Noise chunk 2: Leviticus containing "bald"
+	noise2Raw := `11:13 And these are they which ye shall have in abomination among the fowls;
+they shall not be eaten, they are an abomination: the eagle, and the ossifrage,
+and the ospray, 11:14 And the vulture, and the kite after his kind; 11:15 Every
+raven after his kind; 11:16 And the owl, and the night hawk, and the cuckow,
+and the hawk after his kind, 11:17 And the little owl, and the cormorant, and
+the great owl, 11:18 And the swan, and the pelican, and the gier eagle, 11:19
+And the stork, the heron after her kind, and the lapwing, and the bat. 
+
+
+11:20 All fowls that creep, going upon all four, shall be an abomination unto
+you. 
+
+
+11:21 Yet these may ye eat of every flying creeping thing that goeth upon all
+four, which have legs above their feet, to leap withal upon the earth; 11:22
+Even these of them ye may eat; the locust after his kind, and the bald locust
+after his kind, and the beetle after his kind, and the grasshopper after his
+kind. 
+
+
+11:23 But all other flying creeping things, which have four feet, shall be an
+abomination unto you. 
+
+
+11:24 And for these ye shall be unclean: whosoever toucheth the carcase of them
+shall be unclean until the even.`
+	// Additional Leviticus noise chunks (simulating 28 bald-related chunks)
+	// Using variations of the same text with different slugs
+	leviticusSlugs := []string{
+		"kjv_bible.epub_564_0",
+		"kjv_bible.epub_565_0",
+		"kjv_bible.epub_579_0",
+		"kjv_bible.epub_580_0",
+		"kjv_bible.epub_581_0",
+		"kjv_bible.epub_582_0",
+		"kjv_bible.epub_583_0",
+		"kjv_bible.epub_584_0",
+		"kjv_bible.epub_585_0",
+		"kjv_bible.epub_586_0",
+		"kjv_bible.epub_587_0",
+		"kjv_bible.epub_588_0",
+		"kjv_bible.epub_589_0",
+		"kjv_bible.epub_590_0",
+	}
+	leviticusTexts := []string{
+		noise1Raw,
+		noise2Raw,
+		`13:40 And the man whose hair is fallen off his head, he is bald; yet is he
+clean. 
+
+
+13:41 And he that hath his hair fallen off from the part of his head toward his
+face, he is forehead bald; yet is he clean.`,
+		`13:42 And if there be in the bald head, or bald forehead, a white reddish sore;
+it is a leprosy sprung up in his bald head, or his bald forehead.`,
+		`13:43 Then the priest shall look upon it: and, behold, if the rising of the
+sore be white reddish in his bald head, or in his bald forehead, as the leprosy
+appearedh in the skin of the flesh;`,
+		`13:44 He is a leprous man, he is unclean: the priest shall pronounce him utterly
+unclean; his plague is in his head.`,
+		`13:45 And the leper in whom the plague is, his clothes shall be rent, and his
+head bare, and he shall put a covering upon his upper lip, and shall cry,
+Unclean, unclean.`,
+		`13:46 All the days wherein the plague shall be in him he shall be defiled; he
+is unclean: he shall dwell alone; without the camp shall his habitation be.`,
+		`13:47 The garment also that the plague of leprosy is in, whether it be a woollen
+garment, or a linen garment;`,
+		`13:48 Whether it be in the warp, or woof; of linen, or of woollen; whether in a
+skin, or in any thing made of skin;`,
+		`13:49 And if the plague be greenish or reddish in the garment, or in the skin,
+either in the warp, or in the woof, or in any thing of skin; it is a plague of
+leprosy, and shall be shewed unto the priest:`,
+		`13:50 And the priest shall look upon the plague, and shut up it that hath the
+plague seven days:`,
+		`13:51 And he shall look on the plague on the seventh day: if the plague be spread
+in the garment, either in the warp, or in the woof, or in a skin, or in any work
+that is made of skin; the plague is a fretting leprosy; it is unclean.`,
+		`13:52 He shall therefore burn that garment, whether warp or woof, in woollen or
+in linen, or any thing of skin, wherein the plague is: for it is a fretting
+leprosy; it shall be burnt in the fire.`,
+	}
+	// Unrelated chunk 1: ghost_7.txt_777_0
+	unrelated1Raw := `Doesn’t he have any pride as a hunter?!  
+
+I didn’t see what other choice I had.  I would just have to grovel and be ready to flee at any given moment.  
+The Hidden Curse clan house was in the central region of the imperial capital.  It was a high-class area with extraordinary property values that hosted the residences of people like Lord Gladis.  This district was near the Imperial Castle, though “near” was a 
+relative term as it was still a few kilometers away.  
+
+The clan house was made of brick and conformed to an older style of architecture.`
+	// Unrelated chunk 2: ghost_7.txt_778_0
+	unrelated2Raw := `I would just have to grovel and be ready to flee at any given moment.  
+The Hidden Curse clan house was in the central region of the imperial capital.  It was a high-class area with extraordinary property values that hosted the residences of people like Lord Gladis.  This district was near the Imperial Castle, though “near” was a 
+relative term as it was still a few kilometers away.  
+
+The clan house was made of brick and conformed to an older style of architecture.  Nearly everyone knew about this mansion and its clock tower.  It stood tall over the neighboring mansions and rumor had it that you could see the whole capital from the top.  It 
+spoke to this clan’s renown and history that they were able to get away with building something that dwarfed the mansions of the nobility.`
+	chunks := []*models.VectorRow{
+		{
+			Slug:       "kjv_bible.epub_1786_0",
+			RawText:    targetRaw,
+			FileName:   "kjv_bible.epub",
+			Embeddings: nil, // will be filled with zero vector later
+		},
+	}
+	// Add Leviticus noise chunks
+	for i, slug := range leviticusSlugs {
+		text := leviticusTexts[i%len(leviticusTexts)]
+		chunks = append(chunks, &models.VectorRow{
+			Slug:       slug,
+			RawText:    text,
+			FileName:   "kjv_bible.epub",
+			Embeddings: nil,
+		})
+	}
+	// Add unrelated chunks
+	chunks = append(chunks,
+		&models.VectorRow{
+			Slug:       "ghost_7.txt_777_0",
+			RawText:    unrelated1Raw,
+			FileName:   "ghost_7.txt",
+			Embeddings: nil,
+		},
+		&models.VectorRow{
+			Slug:       "ghost_7.txt_778_0",
+			RawText:    unrelated2Raw,
+			FileName:   "ghost_7.txt",
+			Embeddings: nil,
+		},
+	)
+	return chunks
+}
+func assertTargetInTopN(t *testing.T, results []models.VectorRow, topN int) bool {
+	t.Helper()
+	for i, row := range results {
+		if i >= topN {
+			break
+		}
+		if row.Slug == "kjv_bible.epub_1786_0" {
+			return true
+		}
+	}
+	return false
+}
+
+func TestBiblicalQuery(t *testing.T) {
+	chunks := createTestChunks()
+	rag, err := setupTestRAG(t, chunks)
+	if err != nil {
+		t.Fatalf("setup failed: %v", err)
+	}
+	query := "bald prophet and two she bears"
+	results, err := rag.Search(query, 10)
+	if err != nil {
+		t.Fatalf("search failed: %v", err)
+	}
+	// The target chunk should be in the top results.
+	if !assertTargetInTopN(t, results, 5) {
+		t.Errorf("target chunk not found in top 5 results for query %q", query)
+		t.Logf("results slugs: %v", func() []string {
+			slugs := make([]string, len(results))
+			for i, r := range results {
+				slugs[i] = r.Slug
+			}
+			return slugs
+		}())
+	}
+}
+
+func TestQueryVariations(t *testing.T) {
+	chunks := createTestChunks()
+	rag, err := setupTestRAG(t, chunks)
+	if err != nil {
+		t.Fatalf("setup failed: %v", err)
+	}
+	tests := []struct {
+		name  string
+		query string
+		topN  int
+	}{
+		{"she bears", "she bears", 5},
+		{"bald head", "bald head", 5},
+		{"two she bears out of the wood", "two she bears out of the wood", 5},
+		{"bald prophet", "bald prophet", 10},
+		{"go up thou bald head", "\"go up thou bald head\"", 5},
+		{"two she bears", "\"two she bears\"", 5},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			results, err := rag.Search(tt.query, 10)
+			if err != nil {
+				t.Fatalf("search failed: %v", err)
+			}
+			if !assertTargetInTopN(t, results, tt.topN) {
+				t.Errorf("target chunk not found in top %d results for query %q", tt.topN, tt.query)
+				t.Logf("results slugs: %v", func() []string {
+					slugs := make([]string, len(results))
+					for i, r := range results {
+						slugs[i] = r.Slug
+					}
+					return slugs
+				}())
+			}
+		})
+	}
+}

rag/rag_real_test.go

@@ -0,0 +1,129 @@
+package rag
+
+import (
+	"gf-lt/config"
+	"gf-lt/storage"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestRealBiblicalQuery(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping real embedder test in short mode")
+	}
+	// Check if the embedder model exists
+	modelPath := filepath.Join("..", "onnx", "embedgemma", "model_q4.onnx")
+	if _, err := os.Stat(modelPath); os.IsNotExist(err) {
+		t.Skipf("embedder model not found at %s; skipping real embedder test", modelPath)
+	}
+	tokenizerPath := filepath.Join("..", "onnx", "embedgemma", "tokenizer.json")
+	dbPath := filepath.Join("..", "gflt.db")
+	if _, err := os.Stat(dbPath); os.IsNotExist(err) {
+		t.Skipf("database not found at %s; skipping real embedder test", dbPath)
+	}
+	cfg := &config.Config{
+		EmbedModelPath:     modelPath,
+		EmbedTokenizerPath: tokenizerPath,
+		EmbedDims:          768,
+		RAGWordLimit:       250,
+		RAGOverlapWords:    25,
+		RAGBatchSize:       1,
+	}
+	logger := slog.New(slog.NewTextHandler(nil, &slog.HandlerOptions{Level: slog.LevelError}))
+	store := storage.NewProviderSQL(dbPath, logger)
+	if store == nil {
+		t.Fatal("failed to create storage provider")
+	}
+	rag, err := New(logger, store, cfg)
+	if err != nil {
+		t.Fatalf("failed to create RAG instance: %v", err)
+	}
+	t.Cleanup(func() { rag.Destroy() })
+	query := "bald prophet and two she bears"
+	results, err := rag.Search(query, 30)
+	if err != nil {
+		t.Fatalf("search failed: %v", err)
+	}
+	found := false
+	for i, row := range results {
+		if row.Slug == "kjv_bible.epub_1786_0" {
+			found = true
+			t.Logf("target chunk found at rank %d", i+1)
+			break
+		}
+	}
+	if !found {
+		t.Errorf("target chunk not found in search results for query %q", query)
+		t.Logf("results slugs:")
+		for i, r := range results {
+			t.Logf("%d: %s", i+1, r.Slug)
+		}
+	}
+}
+
+func TestRealQueryVariations(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping real embedder test in short mode")
+	}
+	modelPath := filepath.Join("..", "onnx", "embedgemma", "model_q4.onnx")
+	if _, err := os.Stat(modelPath); os.IsNotExist(err) {
+		t.Skipf("embedder model not found at %s; skipping real embedder test", modelPath)
+	}
+	tokenizerPath := filepath.Join("..", "onnx", "embedgemma", "tokenizer.json")
+	dbPath := filepath.Join("..", "gflt.db")
+	if _, err := os.Stat(dbPath); os.IsNotExist(err) {
+		t.Skipf("database not found at %s; skipping real embedder test", dbPath)
+	}
+	cfg := &config.Config{
+		EmbedModelPath:     modelPath,
+		EmbedTokenizerPath: tokenizerPath,
+		EmbedDims:          768,
+		RAGWordLimit:       250,
+		RAGOverlapWords:    25,
+		RAGBatchSize:       1,
+	}
+	logger := slog.New(slog.NewTextHandler(nil, &slog.HandlerOptions{Level: slog.LevelError}))
+	store := storage.NewProviderSQL(dbPath, logger)
+	if store == nil {
+		t.Fatal("failed to create storage provider")
+	}
+	rag, err := New(logger, store, cfg)
+	if err != nil {
+		t.Fatalf("failed to create RAG instance: %v", err)
+	}
+	t.Cleanup(func() { rag.Destroy() })
+	tests := []struct {
+		name  string
+		query string
+	}{
+		{"she bears", "she bears"},
+		{"bald head", "bald head"},
+		{"two she bears out of the wood", "two she bears out of the wood"},
+		{"bald prophet", "bald prophet"},
+		{"go up thou bald head", "\"go up thou bald head\""},
+		{"two she bears", "\"two she bears\""},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			results, err := rag.Search(tt.query, 10)
+			if err != nil {
+				t.Fatalf("search failed: %v", err)
+			}
+			found := false
+			for _, row := range results {
+				if row.Slug == "kjv_bible.epub_1786_0" {
+					found = true
+					break
+				}
+			}
+			if !found {
+				t.Errorf("target chunk not found for query %q", tt.query)
+				for i, r := range results {
+					t.Logf("%d: %s", i+1, r.Slug)
+				}
+			}
+		})
+	}
+}

rag/rag_test.go

@@ -0,0 +1,151 @@
+package rag
+
+import (
+	"testing"
+)
+
+func TestDetectPhrases(t *testing.T) {
+	tests := []struct {
+		query  string
+		expect []string
+	}{
+		{
+			query:  "bald prophet and two she bears",
+			expect: []string{"bald prophet", "two she", "two she bears", "she bears"},
+		},
+		{
+			query:  "she bears",
+			expect: []string{"she bears"},
+		},
+		{
+			query:  "the quick brown fox",
+			expect: []string{"quick brown", "quick brown fox", "brown fox"},
+		},
+		{
+			query:  "in the house", // stop words
+			expect: []string{},     // "in" and "the" are stop words
+		},
+		{
+			query:  "a", // short
+			expect: []string{},
+		},
+	}
+	for _, tt := range tests {
+		got := detectPhrases(tt.query)
+		if len(got) != len(tt.expect) {
+			t.Errorf("detectPhrases(%q) = %v, want %v", tt.query, got, tt.expect)
+			continue
+		}
+		for i := range got {
+			if got[i] != tt.expect[i] {
+				t.Errorf("detectPhrases(%q) = %v, want %v", tt.query, got, tt.expect)
+				break
+			}
+		}
+	}
+}
+
+func TestCountPhraseMatches(t *testing.T) {
+	tests := []struct {
+		text   string
+		query  string
+		expect int
+	}{
+		{
+			text:   "two she bears came out of the wood",
+			query:  "she bears",
+			expect: 1,
+		},
+		{
+			text:   "bald head and she bears",
+			query:  "bald prophet and two she bears",
+			expect: 1, // only "she bears" matches
+		},
+		{
+			text:   "no match here",
+			query:  "she bears",
+			expect: 0,
+		},
+		{
+			text:   "she bears and bald prophet",
+			query:  "bald prophet she bears",
+			expect: 2, // "she bears" and "bald prophet"
+		},
+	}
+	for _, tt := range tests {
+		got := countPhraseMatches(tt.text, tt.query)
+		if got != tt.expect {
+			t.Errorf("countPhraseMatches(%q, %q) = %d, want %d", tt.text, tt.query, got, tt.expect)
+		}
+	}
+}
+
+func TestAreSlugsAdjacent(t *testing.T) {
+	tests := []struct {
+		slug1  string
+		slug2  string
+		expect bool
+	}{
+		{
+			slug1:  "kjv_bible.epub_1786_0",
+			slug2:  "kjv_bible.epub_1787_0",
+			expect: true,
+		},
+		{
+			slug1:  "kjv_bible.epub_1787_0",
+			slug2:  "kjv_bible.epub_1786_0",
+			expect: true,
+		},
+		{
+			slug1:  "kjv_bible.epub_1786_0",
+			slug2:  "kjv_bible.epub_1788_0",
+			expect: false,
+		},
+		{
+			slug1:  "otherfile.txt_1_0",
+			slug2:  "kjv_bible.epub_1786_0",
+			expect: false,
+		},
+		{
+			slug1:  "file_1_0",
+			slug2:  "file_1_1",
+			expect: true,
+		},
+		{
+			slug1:  "file_1_0",
+			slug2:  "file_2_0", // different batch
+			expect: true,       // sequential batches with same chunk index are adjacent
+		},
+	}
+	for _, tt := range tests {
+		got := areSlugsAdjacent(tt.slug1, tt.slug2)
+		if got != tt.expect {
+			t.Errorf("areSlugsAdjacent(%q, %q) = %v, want %v", tt.slug1, tt.slug2, got, tt.expect)
+		}
+	}
+}
+
+func TestParseSlugIndices(t *testing.T) {
+	tests := []struct {
+		slug      string
+		wantBatch int
+		wantChunk int
+		wantOk    bool
+	}{
+		{"kjv_bible.epub_1786_0", 1786, 0, true},
+		{"file_1_5", 1, 5, true},
+		{"no_underscore", 0, 0, false},
+		{"file_abc_def", 0, 0, false},
+		{"file_123_456_extra", 456, 0, false}, // regex matches last two numbers
+	}
+	for _, tt := range tests {
+		batch, chunk, ok := parseSlugIndices(tt.slug)
+		if ok != tt.wantOk {
+			t.Errorf("parseSlugIndices(%q) ok = %v, want %v", tt.slug, ok, tt.wantOk)
+			continue
+		}
+		if ok && (batch != tt.wantBatch || chunk != tt.wantChunk) {
+			t.Errorf("parseSlugIndices(%q) = (%d, %d), want (%d, %d)", tt.slug, batch, chunk, tt.wantBatch, tt.wantChunk)
+		}
+	}
+}

rag/storage.go

@@ -1,6 +1,7 @@
 package rag
 
 import (
+	"database/sql"
 	"encoding/binary"
 	"fmt"
 	"gf-lt/models"
@@ -62,6 +63,17 @@ func (vs *VectorStorage) WriteVector(row *models.VectorRow) error {
 	if err != nil {
 		return err
 	}
+	embeddingSize := len(row.Embeddings)
+	// Start transaction
+	tx, err := vs.sqlxDB.Beginx()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err != nil {
+			_ = tx.Rollback()
+		}
+	}()
 
 	// Serialize the embeddings to binary
 	serializedEmbeddings := SerializeVector(row.Embeddings)
@@ -69,10 +81,102 @@ func (vs *VectorStorage) WriteVector(row *models.VectorRow) error {
 		"INSERT INTO %s (embeddings, slug, raw_text, filename) VALUES (?, ?, ?, ?)",
 		tableName,
 	)
-	if _, err := vs.sqlxDB.Exec(query, serializedEmbeddings, row.Slug, row.RawText, row.FileName); err != nil {
+	if _, err := tx.Exec(query, serializedEmbeddings, row.Slug, row.RawText, row.FileName); err != nil {
 		vs.logger.Error("failed to write vector", "error", err, "slug", row.Slug)
 		return err
 	}
+	// Insert into FTS table
+	ftsQuery := `INSERT INTO fts_embeddings (slug, raw_text, filename, embedding_size) VALUES (?, ?, ?, ?)`
+	if _, err := tx.Exec(ftsQuery, row.Slug, row.RawText, row.FileName, embeddingSize); err != nil {
+		vs.logger.Error("failed to write to FTS table", "error", err, "slug", row.Slug)
+		return err
+	}
+	err = tx.Commit()
+	if err != nil {
+		vs.logger.Error("failed to commit transaction", "error", err)
+		return err
+	}
+	return nil
+}
+
+// WriteVectors stores multiple embedding vectors in a single transaction
+func (vs *VectorStorage) WriteVectors(rows []*models.VectorRow) error {
+	if len(rows) == 0 {
+		return nil
+	}
+	// SQLite has limit of 999 parameters per statement, each row uses 4 parameters
+	const maxBatchSize = 200 // 200 * 4 = 800 < 999
+	if len(rows) > maxBatchSize {
+		// Process in chunks
+		for i := 0; i < len(rows); i += maxBatchSize {
+			end := i + maxBatchSize
+			if end > len(rows) {
+				end = len(rows)
+			}
+			if err := vs.WriteVectors(rows[i:end]); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	// All rows should have same embedding size (same model)
+	firstSize := len(rows[0].Embeddings)
+	for i, row := range rows {
+		if len(row.Embeddings) != firstSize {
+			return fmt.Errorf("embedding size mismatch: row %d has size %d, expected %d", i, len(row.Embeddings), firstSize)
+		}
+	}
+	tableName, err := vs.getTableName(rows[0].Embeddings)
+	if err != nil {
+		return err
+	}
+	// Start transaction
+	tx, err := vs.sqlxDB.Beginx()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err != nil {
+			_ = tx.Rollback()
+		}
+	}()
+
+	// Build batch insert for embeddings table
+	embeddingPlaceholders := make([]string, 0, len(rows))
+	embeddingArgs := make([]any, 0, len(rows)*4)
+	for _, row := range rows {
+		embeddingPlaceholders = append(embeddingPlaceholders, "(?, ?, ?, ?)")
+		embeddingArgs = append(embeddingArgs, SerializeVector(row.Embeddings), row.Slug, row.RawText, row.FileName)
+	}
+	embeddingQuery := fmt.Sprintf(
+		"INSERT INTO %s (embeddings, slug, raw_text, filename) VALUES %s",
+		tableName,
+		strings.Join(embeddingPlaceholders, ", "),
+	)
+	if _, err := tx.Exec(embeddingQuery, embeddingArgs...); err != nil {
+		vs.logger.Error("failed to write vectors batch", "error", err, "batch_size", len(rows))
+		return err
+	}
+	// Build batch insert for FTS table
+	ftsPlaceholders := make([]string, 0, len(rows))
+	ftsArgs := make([]any, 0, len(rows)*4)
+	embeddingSize := len(rows[0].Embeddings)
+	for _, row := range rows {
+		ftsPlaceholders = append(ftsPlaceholders, "(?, ?, ?, ?)")
+		ftsArgs = append(ftsArgs, row.Slug, row.RawText, row.FileName, embeddingSize)
+	}
+	ftsQuery := "INSERT INTO fts_embeddings (slug, raw_text, filename, embedding_size) VALUES " +
+		strings.Join(ftsPlaceholders, ", ")
+	if _, err := tx.Exec(ftsQuery, ftsArgs...); err != nil {
+		vs.logger.Error("failed to write FTS batch", "error", err, "batch_size", len(rows))
+		return err
+	}
+	err = tx.Commit()
+	if err != nil {
+		vs.logger.Error("failed to commit transaction", "error", err)
+		return err
+	}
+	vs.logger.Debug("wrote vectors batch", "batch_size", len(rows))
 	return nil
 }
 
@@ -98,30 +202,25 @@ func (vs *VectorStorage) getTableName(emb []float32) (string, error) {
 }
 
 // SearchClosest finds vectors closest to the query vector using efficient cosine similarity calculation
-func (vs *VectorStorage) SearchClosest(query []float32) ([]models.VectorRow, error) {
+func (vs *VectorStorage) SearchClosest(query []float32, limit int) ([]models.VectorRow, error) {
+	if limit <= 0 {
+		limit = 10
+	}
 	tableName, err := vs.getTableName(query)
 	if err != nil {
 		return nil, err
 	}
-
-	// For better performance, instead of loading all vectors at once,
-	// we'll implement batching and potentially add L2 distance-based pre-filtering
-	// since cosine similarity is related to L2 distance for normalized vectors
-
 	querySQL := "SELECT embeddings, slug, raw_text, filename FROM " + tableName
 	rows, err := vs.sqlxDB.Query(querySQL)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-
-	// Use a min-heap or simple slice to keep track of top 3 closest vectors
 	type SearchResult struct {
 		vector   models.VectorRow
 		distance float32
 	}
 	var topResults []SearchResult
-	// Process vectors one by one to avoid loading everything into memory
 	for rows.Next() {
 		var (
 			embeddingsBlob          []byte
@@ -132,12 +231,9 @@ func (vs *VectorStorage) SearchClosest(query []float32) ([]models.VectorRow, err
 			vs.logger.Error("failed to scan row", "error", err)
 			continue
 		}
-
 		storedEmbeddings := DeserializeVector(embeddingsBlob)
-
-		// Calculate cosine similarity (returns value between -1 and 1, where 1 is most similar)
 		similarity := cosineSimilarity(query, storedEmbeddings)
-		distance := 1 - similarity // Convert to distance where 0 is most similar
+		distance := 1 - similarity
 
 		result := SearchResult{
 			vector: models.VectorRow{
@@ -149,20 +245,14 @@ func (vs *VectorStorage) SearchClosest(query []float32) ([]models.VectorRow, err
 			distance: distance,
 		}
 
-		// Add to top results and maintain only top 3
 		topResults = append(topResults, result)
-
-		// Sort and keep only top 3
 		sort.Slice(topResults, func(i, j int) bool {
 			return topResults[i].distance < topResults[j].distance
 		})
-
+		if len(topResults) > limit {
-		if len(topResults) > 3 {
+			topResults = topResults[:limit]
-			topResults = topResults[:3] // Keep only closest 3
 		}
 	}
-
-	// Convert back to VectorRow slice
 	results := make([]models.VectorRow, 0, len(topResults))
 	for _, result := range topResults {
 		result.vector.Distance = result.distance
@@ -171,6 +261,98 @@ func (vs *VectorStorage) SearchClosest(query []float32) ([]models.VectorRow, err
 	return results, nil
 }
 
+// GetVectorBySlug retrieves a vector row by its slug
+func (vs *VectorStorage) GetVectorBySlug(slug string) (*models.VectorRow, error) {
+	embeddingSizes := []int{384, 768, 1024, 1536, 2048, 3072, 4096, 5120}
+	for _, size := range embeddingSizes {
+		table := fmt.Sprintf("embeddings_%d", size)
+		query := fmt.Sprintf("SELECT embeddings, slug, raw_text, filename FROM %s WHERE slug = ?", table)
+		row := vs.sqlxDB.QueryRow(query, slug)
+		var (
+			embeddingsBlob                   []byte
+			retrievedSlug, rawText, fileName string
+		)
+		if err := row.Scan(&embeddingsBlob, &retrievedSlug, &rawText, &fileName); err != nil {
+			// No row in this table, continue to next size
+			continue
+		}
+		storedEmbeddings := DeserializeVector(embeddingsBlob)
+		return &models.VectorRow{
+			Embeddings: storedEmbeddings,
+			Slug:       retrievedSlug,
+			RawText:    rawText,
+			FileName:   fileName,
+		}, nil
+	}
+	return nil, fmt.Errorf("vector with slug %s not found", slug)
+}
+
+// SearchKeyword performs full-text search using FTS5
+func (vs *VectorStorage) SearchKeyword(query string, limit int) ([]models.VectorRow, error) {
+	// Use FTS5 bm25 ranking. bm25 returns negative values where more negative is better.
+	// We'll order by bm25 (ascending) and limit.
+	ftsQuery := `SELECT slug, raw_text, filename, bm25(fts_embeddings) as score 
+				 FROM fts_embeddings 
+				 WHERE fts_embeddings MATCH ? 
+				 ORDER BY score 
+				 LIMIT ?`
+
+	// Try original query first
+	rows, err := vs.sqlxDB.Query(ftsQuery, query, limit)
+	if err != nil {
+		return nil, fmt.Errorf("FTS search failed: %w", err)
+	}
+	results, err := vs.scanRows(rows)
+	rows.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	// If no results and query contains multiple terms, try OR fallback
+	if len(results) == 0 && strings.Contains(query, " ") && !strings.Contains(strings.ToUpper(query), " OR ") {
+		// Build OR query: term1 OR term2 OR term3
+		terms := strings.Fields(query)
+		if len(terms) > 1 {
+			orQuery := strings.Join(terms, " OR ")
+			rows, err := vs.sqlxDB.Query(ftsQuery, orQuery, limit)
+			if err != nil {
+				// Return original empty results rather than error
+				return results, nil
+			}
+			orResults, err := vs.scanRows(rows)
+			rows.Close()
+			if err == nil {
+				results = orResults
+			}
+		}
+	}
+	return results, nil
+}
+
+// scanRows converts SQL rows to VectorRow slice
+func (vs *VectorStorage) scanRows(rows *sql.Rows) ([]models.VectorRow, error) {
+	var results []models.VectorRow
+	for rows.Next() {
+		var slug, rawText, fileName string
+		var score float64
+		if err := rows.Scan(&slug, &rawText, &fileName, &score); err != nil {
+			vs.logger.Error("failed to scan FTS row", "error", err)
+			continue
+		}
+		// Convert BM25 score to distance-like metric (lower is better)
+		// BM25 is negative, more negative is better. Keep as negative.
+		distance := float32(score) // Keep negative, more negative is better
+		// No clamping needed; negative distances are fine
+		results = append(results, models.VectorRow{
+			Slug:     slug,
+			RawText:  rawText,
+			FileName: fileName,
+			Distance: distance,
+		})
+	}
+	return results, nil
+}
+
 // ListFiles returns a list of all loaded files
 func (vs *VectorStorage) ListFiles() ([]string, error) {
 	fileLists := make([][]string, 0)
@@ -215,6 +397,10 @@ func (vs *VectorStorage) ListFiles() ([]string, error) {
 // RemoveEmbByFileName removes all embeddings associated with a specific filename
 func (vs *VectorStorage) RemoveEmbByFileName(filename string) error {
 	var errors []string
+	// Delete from FTS table first
+	if _, err := vs.sqlxDB.Exec("DELETE FROM fts_embeddings WHERE filename = ?", filename); err != nil {
+		errors = append(errors, err.Error())
+	}
 	embeddingSizes := []int{384, 768, 1024, 1536, 2048, 3072, 4096, 5120}
 	for _, size := range embeddingSizes {
 		table := fmt.Sprintf("embeddings_%d", size)

session.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"bytes"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -161,15 +162,31 @@ func loadOldChatOrGetNew() []models.RoleMsg {
 }
 
 func copyToClipboard(text string) error {
-	cmd := exec.Command("xclip", "-selection", "clipboard")
+	var cmd *exec.Cmd
-	cmd.Stdin = nil
+	if _, err := exec.LookPath("xclip"); err == nil {
+		cmd = exec.Command("xclip", "-selection", "clipboard")
+	} else if _, err := exec.LookPath("wl-copy"); err == nil {
+		cmd = exec.Command("wl-copy")
+	} else {
+		return errors.New("no clipboard tool found (install xclip or wl-clipboard)")
+	}
+	cmd.Stdin = strings.NewReader(text)
 	cmd.Stdout = nil
 	cmd.Stderr = nil
-	cmd.Stdin = strings.NewReader(text)
 	return cmd.Run()
 }
 
-func notifyUser(topic, message string) error {
+func readFromClipboard() (string, error) {
-	cmd := exec.Command("notify-send", topic, message)
+	var cmd *exec.Cmd
-	return cmd.Run()
+	if _, err := exec.LookPath("xclip"); err == nil {
+		cmd = exec.Command("xclip", "-selection", "clipboard", "-out")
+	} else if _, err := exec.LookPath("wl-paste"); err == nil {
+		cmd = exec.Command("wl-paste")
+	} else {
+		return "", errors.New("no clipboard tool found (install xclip or wl-clipboard)")
+	}
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	err := cmd.Run()
+	return out.String(), err
 }

storage/memory.go

@@ -6,6 +6,7 @@ type Memories interface {
 	Memorise(m *models.Memory) (*models.Memory, error)
 	Recall(agent, topic string) (string, error)
 	RecallTopics(agent string) ([]string, error)
+	Forget(agent, topic string) error
 }
 
 func (p ProviderSQL) Memorise(m *models.Memory) (*models.Memory, error) {
@@ -52,3 +53,13 @@ func (p ProviderSQL) RecallTopics(agent string) ([]string, error) {
 	}
 	return topics, nil
 }
+
+func (p ProviderSQL) Forget(agent, topic string) error {
+	query := "DELETE FROM memories WHERE agent = $1 AND topic = $2"
+	_, err := p.db.Exec(query, agent, topic)
+	if err != nil {
+		p.logger.Error("failed to delete memory", "query", query, "error", err)
+		return err
+	}
+	return nil
+}

storage/migrate.go

@@ -10,28 +10,42 @@ import (
 //go:embed migrations/*
 var migrationsFS embed.FS
 
-func (p *ProviderSQL) Migrate() {
+func (p *ProviderSQL) Migrate() error {
 	// Get the embedded filesystem
 	migrationsDir, err := fs.Sub(migrationsFS, "migrations")
 	if err != nil {
 		p.logger.Error("Failed to get embedded migrations directory;", "error", err)
+		return fmt.Errorf("failed to get embedded migrations directory: %w", err)
 	}
 	// List all .up.sql files
 	files, err := migrationsFS.ReadDir("migrations")
 	if err != nil {
 		p.logger.Error("Failed to read migrations directory;", "error", err)
+		return fmt.Errorf("failed to read migrations directory: %w", err)
 	}
+
+	// Check if FTS already has data - skip populate migration if so
+	var ftsCount int
+	_ = p.db.QueryRow("SELECT COUNT(*) FROM fts_embeddings").Scan(&ftsCount)
+	skipFTSMigration := ftsCount > 0
+
 	// Execute each .up.sql file
 	for _, file := range files {
 		if strings.HasSuffix(file.Name(), ".up.sql") {
+			// Skip FTS populate migration if already populated
+			if skipFTSMigration && strings.Contains(file.Name(), "004_populate_fts") {
+				p.logger.Debug("Skipping FTS migration - already populated", "file", file.Name())
+				continue
+			}
 			err := p.executeMigration(migrationsDir, file.Name())
 			if err != nil {
 				p.logger.Error("Failed to execute migration %s: %v", file.Name(), err)
-				panic(err)
+				return fmt.Errorf("failed to execute migration %s: %w", file.Name(), err)
 			}
 		}
 	}
 	p.logger.Debug("All migrations executed successfully!")
+	return nil
 }
 
 func (p *ProviderSQL) executeMigration(migrationsDir fs.FS, fileName string) error {

storage/migrations/003_add_fts.down.sql

@@ -0,0 +1,2 @@
+-- Drop FTS5 virtual table
+DROP TABLE IF EXISTS fts_embeddings;

storage/migrations/003_add_fts.up.sql

@@ -0,0 +1,15 @@
+-- Create FTS5 virtual table for full-text search
+CREATE VIRTUAL TABLE IF NOT EXISTS fts_embeddings USING fts5(
+    slug UNINDEXED,
+    raw_text,
+    filename UNINDEXED,
+    embedding_size UNINDEXED,
+    tokenize='porter unicode61'  -- Use porter stemmer and unicode61 tokenizer
+);
+
+-- Create triggers to maintain FTS table when embeddings are inserted/deleted
+-- Note: We'll handle inserts/deletes programmatically for simplicity
+-- but triggers could be added here if needed.
+
+-- Indexes for performance (FTS5 manages its own indexes)
+-- No additional indexes needed for FTS5 virtual table.

storage/migrations/004_populate_fts.down.sql

@@ -0,0 +1,2 @@
+-- Clear FTS table (optional)
+DELETE FROM fts_embeddings;

storage/migrations/004_populate_fts.up.sql

@@ -0,0 +1,4 @@
+-- Populate FTS table with existing embeddings (incremental - only inserts missing rows)
+-- Only use 768 embeddings as that's what we use
+INSERT OR IGNORE INTO fts_embeddings (slug, raw_text, filename, embedding_size)
+SELECT slug, raw_text, filename, 768 FROM embeddings_768;

storage/migrations/005_drop_unused_embeddings.down.sql

@@ -0,0 +1,87 @@
+-- Recreate unused embedding tables (for rollback)
+CREATE TABLE IF NOT EXISTS embeddings_384 (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    embeddings BLOB NOT NULL,
+    slug TEXT NOT NULL,
+    raw_text TEXT NOT NULL,
+    filename TEXT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS embeddings_1024 (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    embeddings BLOB NOT NULL,
+    slug TEXT NOT NULL,
+    raw_text TEXT NOT NULL,
+    filename TEXT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS embeddings_1536 (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    embeddings BLOB NOT NULL,
+    slug TEXT NOT NULL,
+    raw_text TEXT NOT NULL,
+    filename TEXT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS embeddings_2048 (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    embeddings BLOB NOT NULL,
+    slug TEXT NOT NULL,
+    raw_text TEXT NOT NULL,
+    filename TEXT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS embeddings_3072 (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    embeddings BLOB NOT NULL,
+    slug TEXT NOT NULL,
+    raw_text TEXT NOT NULL,
+    filename TEXT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS embeddings_4096 (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    embeddings BLOB NOT NULL,
+    slug TEXT NOT NULL,
+    raw_text TEXT NOT NULL,
+    filename TEXT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS embeddings_5120 (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    embeddings BLOB NOT NULL,
+    slug TEXT NOT NULL,
+    raw_text TEXT NOT NULL,
+    filename TEXT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_embeddings_384_filename ON embeddings_384(filename);
+CREATE INDEX IF NOT EXISTS idx_embeddings_1024_filename ON embeddings_1024(filename);
+CREATE INDEX IF NOT EXISTS idx_embeddings_1536_filename ON embeddings_1536(filename);
+CREATE INDEX IF NOT EXISTS idx_embeddings_2048_filename ON embeddings_2048(filename);
+CREATE INDEX IF NOT EXISTS idx_embeddings_3072_filename ON embeddings_3072(filename);
+CREATE INDEX IF NOT EXISTS idx_embeddings_4096_filename ON embeddings_4096(filename);
+CREATE INDEX IF NOT EXISTS idx_embeddings_5120_filename ON embeddings_5120(filename);
+
+CREATE INDEX IF NOT EXISTS idx_embeddings_384_slug ON embeddings_384(slug);
+CREATE INDEX IF NOT EXISTS idx_embeddings_1024_slug ON embeddings_1024(slug);
+CREATE INDEX IF NOT EXISTS idx_embeddings_1536_slug ON embeddings_1536(slug);
+CREATE INDEX IF NOT EXISTS idx_embeddings_2048_slug ON embeddings_2048(slug);
+CREATE INDEX IF NOT EXISTS idx_embeddings_3072_slug ON embeddings_3072(slug);
+CREATE INDEX IF NOT EXISTS idx_embeddings_4096_slug ON embeddings_4096(slug);
+CREATE INDEX IF NOT EXISTS idx_embeddings_5120_slug ON embeddings_5120(slug);
+
+CREATE INDEX IF NOT EXISTS idx_embeddings_384_created_at ON embeddings_384(created_at);
+CREATE INDEX IF NOT EXISTS idx_embeddings_1024_created_at ON embeddings_1024(created_at);
+CREATE INDEX IF NOT EXISTS idx_embeddings_1536_created_at ON embeddings_1536(created_at);
+CREATE INDEX IF NOT EXISTS idx_embeddings_2048_created_at ON embeddings_2048(created_at);
+CREATE INDEX IF NOT EXISTS idx_embeddings_3072_created_at ON embeddings_3072(created_at);
+CREATE INDEX IF NOT EXISTS idx_embeddings_4096_created_at ON embeddings_4096(created_at);
+CREATE INDEX IF NOT EXISTS idx_embeddings_5120_created_at ON embeddings_5120(created_at);

storage/migrations/005_drop_unused_embeddings.up.sql

@@ -0,0 +1,32 @@
+-- Drop unused embedding tables (we only use 768)
+DROP INDEX IF EXISTS idx_embeddings_384_filename;
+DROP INDEX IF EXISTS idx_embeddings_1024_filename;
+DROP INDEX IF EXISTS idx_embeddings_1536_filename;
+DROP INDEX IF EXISTS idx_embeddings_2048_filename;
+DROP INDEX IF EXISTS idx_embeddings_3072_filename;
+DROP INDEX IF EXISTS idx_embeddings_4096_filename;
+DROP INDEX IF EXISTS idx_embeddings_5120_filename;
+
+DROP INDEX IF EXISTS idx_embeddings_384_slug;
+DROP INDEX IF EXISTS idx_embeddings_1024_slug;
+DROP INDEX IF EXISTS idx_embeddings_1536_slug;
+DROP INDEX IF EXISTS idx_embeddings_2048_slug;
+DROP INDEX IF EXISTS idx_embeddings_3072_slug;
+DROP INDEX IF EXISTS idx_embeddings_4096_slug;
+DROP INDEX IF EXISTS idx_embeddings_5120_slug;
+
+DROP INDEX IF EXISTS idx_embeddings_384_created_at;
+DROP INDEX IF EXISTS idx_embeddings_1024_created_at;
+DROP INDEX IF EXISTS idx_embeddings_1536_created_at;
+DROP INDEX IF EXISTS idx_embeddings_2048_created_at;
+DROP INDEX IF EXISTS idx_embeddings_3072_created_at;
+DROP INDEX IF EXISTS idx_embeddings_4096_created_at;
+DROP INDEX IF EXISTS idx_embeddings_5120_created_at;
+
+DROP TABLE IF EXISTS embeddings_384;
+DROP TABLE IF EXISTS embeddings_1024;
+DROP TABLE IF EXISTS embeddings_1536;
+DROP TABLE IF EXISTS embeddings_2048;
+DROP TABLE IF EXISTS embeddings_3072;
+DROP TABLE IF EXISTS embeddings_4096;
+DROP TABLE IF EXISTS embeddings_5120;

storage/storage.go

@@ -102,8 +102,27 @@ func NewProviderSQL(dbPath string, logger *slog.Logger) FullRepo {
 		logger.Error("failed to open db connection", "error", err)
 		return nil
 	}
+	// Enable WAL mode for better concurrency and performance
+	if _, err := db.Exec("PRAGMA journal_mode = WAL;"); err != nil {
+		logger.Warn("failed to enable WAL mode", "error", err)
+	}
+	if _, err := db.Exec("PRAGMA synchronous = NORMAL;"); err != nil {
+		logger.Warn("failed to set synchronous mode", "error", err)
+	}
+	// Increase cache size for better performance
+	if _, err := db.Exec("PRAGMA cache_size = -2000;"); err != nil {
+		logger.Warn("failed to set cache size", "error", err)
+	}
+	// Log actual journal mode for debugging
+	var journalMode string
+	if err := db.QueryRow("PRAGMA journal_mode;").Scan(&journalMode); err == nil {
+		logger.Debug("SQLite journal mode", "mode", journalMode)
+	}
 	p := ProviderSQL{db: db, logger: logger}
-	p.Migrate()
+	if err := p.Migrate(); err != nil {
+		logger.Error("migration failed, app cannot start", "error", err)
+		return nil
+	}
 	return p
 }
 

storage/vector.go

@@ -4,6 +4,7 @@ import (
 	"encoding/binary"
 	"fmt"
 	"gf-lt/models"
+	"sort"
 	"unsafe"
 
 	"github.com/jmoiron/sqlx"
@@ -11,7 +12,7 @@ import (
 
 type VectorRepo interface {
 	WriteVector(*models.VectorRow) error
-	SearchClosest(q []float32) ([]models.VectorRow, error)
+	SearchClosest(q []float32, limit int) ([]models.VectorRow, error)
 	ListFiles() ([]string, error)
 	RemoveEmbByFileName(filename string) error
 	DB() *sqlx.DB
@@ -47,22 +48,8 @@ func mathBitsToFloat32(b uint32) float32 {
 
 func fetchTableName(emb []float32) (string, error) {
 	switch len(emb) {
-	case 384:
-		return "embeddings_384", nil
 	case 768:
 		return "embeddings_768", nil
-	case 1024:
-		return "embeddings_1024", nil
-	case 1536:
-		return "embeddings_1536", nil
-	case 2048:
-		return "embeddings_2048", nil
-	case 3072:
-		return "embeddings_3072", nil
-	case 4096:
-		return "embeddings_4096", nil
-	case 5120:
-		return "embeddings_5120", nil
 	default:
 		return "", fmt.Errorf("no table for the size of %d", len(emb))
 	}
@@ -79,7 +66,7 @@ func (p ProviderSQL) WriteVector(row *models.VectorRow) error {
 	return err
 }
 
-func (p ProviderSQL) SearchClosest(q []float32) ([]models.VectorRow, error) {
+func (p ProviderSQL) SearchClosest(q []float32, limit int) ([]models.VectorRow, error) {
 	tableName, err := fetchTableName(q)
 	if err != nil {
 		return nil, err
@@ -94,7 +81,7 @@ func (p ProviderSQL) SearchClosest(q []float32) ([]models.VectorRow, error) {
 		vector   models.VectorRow
 		distance float32
 	}
-	var topResults []SearchResult
+	var allResults []SearchResult
 	for rows.Next() {
 		var (
 			embeddingsBlob          []byte
@@ -119,28 +106,19 @@ func (p ProviderSQL) SearchClosest(q []float32) ([]models.VectorRow, error) {
 			},
 			distance: distance,
 		}
-
+		allResults = append(allResults, result)
-		// Add to top results and maintain only top results
+	}
-		topResults = append(topResults, result)
+	// Sort by distance
-
+	sort.Slice(allResults, func(i, j int) bool {
-		// Sort and keep only top results
+		return allResults[i].distance < allResults[j].distance
-		// We'll keep the top 3 closest vectors
+	})
-		if len(topResults) > 3 {
+	// Truncate to limit
-			// Simple sort and truncate to maintain only 3 best matches
+	if len(allResults) > limit {
-			for i := 0; i < len(topResults); i++ {
+		allResults = allResults[:limit]
-				for j := i + 1; j < len(topResults); j++ {
-					if topResults[i].distance > topResults[j].distance {
-						topResults[i], topResults[j] = topResults[j], topResults[i]
-					}
-				}
-			}
-			topResults = topResults[:3]
-		}
 	}
-
 	// Convert back to VectorRow slice
-	results := make([]models.VectorRow, len(topResults))
+	results := make([]models.VectorRow, len(allResults))
-	for i, result := range topResults {
+	for i, result := range allResults {
 		result.vector.Distance = result.distance
 		results[i] = result.vector
 	}
@@ -178,62 +156,25 @@ func sqrt(f float32) float32 {
 }
 
 func (p ProviderSQL) ListFiles() ([]string, error) {
-	fileLists := make([][]string, 0)
+	query := "SELECT DISTINCT filename FROM embeddings_768"
-
+	rows, err := p.db.Query(query)
-	// Query all supported tables and combine results
+	if err != nil {
-	tableNames := []string{
+		return nil, err
-		"embeddings_384", "embeddings_768", "embeddings_1024", "embeddings_1536",
-		"embeddings_2048", "embeddings_3072", "embeddings_4096", "embeddings_5120",
 	}
-	for _, table := range tableNames {
+	defer rows.Close()
-		query := "SELECT DISTINCT filename FROM " + table
+	var allFiles []string
-		rows, err := p.db.Query(query)
+	for rows.Next() {
-		if err != nil {
+		var filename string
-			// Continue if one table doesn't exist
+		if err := rows.Scan(&filename); err != nil {
 			continue
 		}
-
+		allFiles = append(allFiles, filename)
-		var files []string
-		for rows.Next() {
-			var filename string
-			if err := rows.Scan(&filename); err != nil {
-				continue
-			}
-			files = append(files, filename)
-		}
-		rows.Close()
-
-		fileLists = append(fileLists, files)
-	}
-
-	// Combine and deduplicate
-	fileSet := make(map[string]bool)
-	var allFiles []string
-	for _, files := range fileLists {
-		for _, file := range files {
-			if !fileSet[file] {
-				fileSet[file] = true
-				allFiles = append(allFiles, file)
-			}
-		}
 	}
 	return allFiles, nil
 }
 
 func (p ProviderSQL) RemoveEmbByFileName(filename string) error {
-	var errors []string
+	query := "DELETE FROM embeddings_768 WHERE filename = ?"
-	tableNames := []string{
+	_, err := p.db.Exec(query, filename)
-		"embeddings_384", "embeddings_768", "embeddings_1024", "embeddings_1536",
+	return err
-		"embeddings_2048", "embeddings_3072", "embeddings_4096", "embeddings_5120",
-	}
-	for _, table := range tableNames {
-		query := fmt.Sprintf("DELETE FROM %s WHERE filename = ?", table)
-		if _, err := p.db.Exec(query, filename); err != nil {
-			errors = append(errors, err.Error())
-		}
-	}
-	if len(errors) > 0 {
-		return fmt.Errorf("errors occurred: %v", errors)
-	}
-	return nil
 }

sysprompts/cluedo.json

@@ -1,7 +0,0 @@
-{
-  "sys_prompt": "A game of cluedo. Players are {{user}}, {{char}}, {{char2}};\n\nrooms: hall, lounge, dinning room kitchen, ballroom, conservatory, billiard room, library, study;\nweapons: candlestick, dagger, lead pipe, revolver, rope, spanner;\npeople: miss Scarlett, colonel Mustard, mrs. White, reverend Green, mrs. Peacock, professor Plum;\n\nA murder happened in a mansion with 9 rooms. Victim is dr. Black.\nPlayers goal is to find out who commited a murder, in what room and with what weapon.\nWeapons, people and rooms not involved in murder are distributed between players (as cards) by tool agent.\nThe objective of the game is to deduce the details of the murder. There are six characters, six murder weapons, and nine rooms, leaving the players with 324 possibilities. As soon as a player enters a room, they may make a suggestion as to the details, naming a suspect, the room they are in, and the weapon. For example: \"I suspect Professor Plum, in the Dining Room, with the candlestick\".\nOnce a player makes a suggestion, the others are called upon to disprove it.\nBefore the player's move, tool agent will remind that players their cards. There are two types of moves: making a suggestion (suggestion_move) and disproving other player suggestion (evidence_move);\nIn this version player wins when the correct details are named in the suggestion_move.\n\n<example_game>\n{{user}}:\nlet's start a game of cluedo!\ntool: cards of {{char}} are 'LEAD PIPE', 'BALLROOM', 'CONSERVATORY', 'STUDY', 'Mrs. White'; suggestion_move;\n{{char}}:\n(putting miss Scarlet into the Hall with the Revolver) \"I suspect miss Scarlett, in the Hall, with the revolver.\"\ntool: cards of {{char2}} are 'SPANNER', 'DAGGER', 'Professor Plum', 'LIBRARY', 'Mrs. Peacock'; evidence_move;\n{{char2}}:\n\"No objections.\" (no cards matching the suspicion of {{char}})\ntool: cards of {{user}} are 'Colonel Mustard', 'Miss Scarlett', 'DINNING ROOM', 'CANDLESTICK', 'HALL'; evidence_move;\n{{user}}:\n\"I object. Miss Scarlett is innocent.\" (shows card with 'Miss Scarlett')\ntool: cards of {{char2}} are 'SPANNER', 'DAGGER', 'Professor Plum', 'LIBRARY', 'Mrs. Peacock'; suggestion_move;\n{{char2}}:\n*So it was not Miss Scarlett, good to know.*\n(moves Mrs. White to the Billiard Room) \"It might have been Mrs. White, in the Billiard Room, with the Revolver.\"\ntool: cards of {{user}} are 'Colonel Mustard', 'Miss Scarlett', 'DINNING ROOM', 'CANDLESTICK', 'HALL'; evidence_move;\n{{user}}:\n(no matching cards for the assumption of {{char2}}) \"Sounds possible to me.\"\ntool: cards of {{char}} are 'LEAD PIPE', 'BALLROOM', 'CONSERVATORY', 'STUDY', 'Mrs. White'; evidence_move;\n{{char}}:\n(shows Mrs. White card) \"No. Was not Mrs. White\"\ntool: cards of {{user}} are 'Colonel Mustard', 'Miss Scarlett', 'DINNING ROOM', 'CANDLESTICK', 'HALL'; suggestion_move;\n{{user}}:\n*So not Mrs. White...* (moves Reverend Green into the Billiard Room) \"I suspect Reverend Green, in the Billiard Room, with the Revolver.\"\ntool: Correct. It was Reverend Green in the Billiard Room, with the revolver. {{user}} wins.\n</example_game>",
-  "role": "CluedoPlayer",
-  "role2": "CluedoEnjoyer",
-  "filepath": "sysprompts/cluedo.json",
-  "first_msg": "Hey guys! Want to play cluedo?"
-}

tables.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"gf-lt/tools"
 	"image"
 	"os"
 	"path"
@@ -147,9 +148,7 @@ func makeChatTable(chatMap map[string]models.Chat) *tview.Table {
 			if err := store.RemoveChat(sc.ID); err != nil {
 				logger.Error("failed to remove chat from db", "chat_id", sc.ID, "chat_name", sc.Name)
 			}
-			if err := notifyUser("chat deleted", selectedChat+" was deleted"); err != nil {
+			showToast("chat deleted", selectedChat+" was deleted")
-				logger.Error("failed to send notification", "error", err)
-			}
 			// load last chat
 			chatBody.Messages = loadOldChatOrGetNew()
 			textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
@@ -159,64 +158,49 @@ func makeChatTable(chatMap map[string]models.Chat) *tview.Table {
 			// save updated card
 			fi := strings.Index(selectedChat, "_")
 			agentName := selectedChat[fi+1:]
-			cc, ok := sysMap[agentName]
+			cc := GetCardByRole(agentName)
-			if !ok {
+			if cc == nil {
 				logger.Warn("no such card", "agent", agentName)
-				//no:lint
+				showToast("error", "no such card: "+agentName)
-				if err := notifyUser("error", "no such card: "+agentName); err != nil {
-					logger.Warn("failed ot notify", "error", err)
-				}
 				return
 			}
-			// if chatBody.Messages[0].Role != "system" || chatBody.Messages[1].Role != agentName {
-			// 	if err := notifyUser("error", "unexpected chat structure; card: "+agentName); err != nil {
-			// 		logger.Warn("failed ot notify", "error", err)
-			// 	}
-			// 	return
-			// }
-			// change sys_prompt + first msg
 			cc.SysPrompt = chatBody.Messages[0].Content
 			cc.FirstMsg = chatBody.Messages[1].Content
 			if err := pngmeta.WriteToPng(cc.ToSpec(cfg.UserRole), cc.FilePath, cc.FilePath); err != nil {
-				logger.Error("failed to write charcard",
+				logger.Error("failed to write charcard", "error", err)
-					"error", err)
 			}
 			return
 		case "move sysprompt onto 1st msg":
 			chatBody.Messages[1].Content = chatBody.Messages[0].Content + chatBody.Messages[1].Content
-			chatBody.Messages[0].Content = rpDefenitionSysMsg
+			chatBody.Messages[0].Content = tools.RpDefenitionSysMsg
 			textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
 			activeChatName = selectedChat
 			pages.RemovePage(historyPage)
 			return
 		case "new_chat_from_card":
-			// Reread card from file and start fresh chat
 			fi := strings.Index(selectedChat, "_")
 			agentName := selectedChat[fi+1:]
-			cc, ok := sysMap[agentName]
+			cc := GetCardByRole(agentName)
-			if !ok {
+			if cc == nil {
 				logger.Warn("no such card", "agent", agentName)
-				if err := notifyUser("error", "no such card: "+agentName); err != nil {
+				showToast("error", "no such card: "+agentName)
-					logger.Warn("failed to notify", "error", err)
-				}
 				return
 			}
-			// Reload card from disk
 			newCard, err := pngmeta.ReadCard(cc.FilePath, cfg.UserRole)
 			if err != nil {
 				logger.Error("failed to reload charcard", "path", cc.FilePath, "error", err)
 				newCard, err = pngmeta.ReadCardJson(cc.FilePath)
 				if err != nil {
 					logger.Error("failed to reload charcard", "path", cc.FilePath, "error", err)
-					if err := notifyUser("error", "failed to reload card: "+cc.FilePath); err != nil {
+					showToast("error", "failed to reload card: "+cc.FilePath)
-						logger.Warn("failed to notify", "error", err)
-					}
 					return
 				}
 			}
-			// Update sysMap with fresh card data
+			if newCard.ID == "" {
-			sysMap[agentName] = newCard
+				newCard.ID = models.ComputeCardID(newCard.Role, newCard.FilePath)
-			// fetching sysprompt and first message anew from the card
+			}
+			sysMap[newCard.ID] = newCard
+			roleToID[newCard.Role] = newCard.ID
 			startNewChat(false)
 			pages.RemovePage(historyPage)
 			return
@@ -260,11 +244,9 @@ func makeRAGTable(fileList []string, loadedFiles []string) *tview.Flex {
 	for _, f := range loadedFiles {
 		loadedSet[f] = true
 	}
-
 	// Build merged list: files from ragdir + orphaned files from DB
 	ragFiles := make([]ragFileInfo, 0, len(fileList)+len(loadedFiles))
 	seen := make(map[string]bool)
-
 	// Add files from ragdir
 	for _, f := range fileList {
 		ragFiles = append(ragFiles, ragFileInfo{
@@ -275,7 +257,6 @@ func makeRAGTable(fileList []string, loadedFiles []string) *tview.Flex {
 		})
 		seen[f] = true
 	}
-
 	// Add orphaned files (in DB but not in ragdir)
 	for _, f := range loadedFiles {
 		if !seen[f] {
@@ -292,7 +273,7 @@ func makeRAGTable(fileList []string, loadedFiles []string) *tview.Flex {
 	fileTable := tview.NewTable().
 		SetBorders(true)
 	longStatusView := tview.NewTextView()
-	longStatusView.SetText("status text")
+	longStatusView.SetText("press x to exit")
 	longStatusView.SetBorder(true).SetTitle("status")
 	longStatusView.SetChangedFunc(func() {
 		app.Draw()
@@ -393,7 +374,6 @@ func makeRAGTable(fileList []string, loadedFiles []string) *tview.Flex {
 	}
 	errCh := make(chan error, 1) // why?
 	go func() {
-		defer pages.RemovePage(RAGPage)
 		for {
 			select {
 			case err := <-errCh:
@@ -434,7 +414,6 @@ func makeRAGTable(fileList []string, loadedFiles []string) *tview.Flex {
 			}
 			return
 		}
-		// defer pages.RemovePage(RAGPage)
 		tc := fileTable.GetCell(row, column)
 		tc.SetTextColor(tcell.ColorRed)
 		fileTable.SetSelectable(false, false)
@@ -447,7 +426,6 @@ func makeRAGTable(fileList []string, loadedFiles []string) *tview.Flex {
 		f := ragFiles[row-1]
 		// Handle "-" case (orphaned file with no delete option)
 		if tc.Text == "-" {
-			pages.RemovePage(RAGPage)
 			return
 		}
 		switch tc.Text {
@@ -457,15 +435,15 @@ func makeRAGTable(fileList []string, loadedFiles []string) *tview.Flex {
 			go func() {
 				if err := ragger.LoadRAG(fpath); err != nil {
 					logger.Error("failed to embed file", "chat", fpath, "error", err)
-					_ = notifyUser("RAG", "failed to embed file; error: "+err.Error())
+					showToast("RAG", "failed to embed file; error: "+err.Error())
-					app.QueueUpdate(func() {
-						pages.RemovePage(RAGPage)
-					})
 					return
 				}
-				_ = notifyUser("RAG", "file loaded successfully")
+				showToast("RAG", "file loaded successfully")
 				app.QueueUpdate(func() {
 					pages.RemovePage(RAGPage)
+					loadedFiles, _ := ragger.ListLoaded()
+					chatRAGTable := makeRAGTable(fileList, loadedFiles)
+					pages.AddPage(RAGPage, chatRAGTable, true, true)
 				})
 			}()
 			return
@@ -474,15 +452,15 @@ func makeRAGTable(fileList []string, loadedFiles []string) *tview.Flex {
 			go func() {
 				if err := ragger.RemoveFile(f.name); err != nil {
 					logger.Error("failed to unload file from RAG", "filename", f.name, "error", err)
-					_ = notifyUser("RAG", "failed to unload file; error: "+err.Error())
+					showToast("RAG", "failed to unload file; error: "+err.Error())
-					app.QueueUpdate(func() {
-						pages.RemovePage(RAGPage)
-					})
 					return
 				}
-				_ = notifyUser("RAG", "file unloaded successfully")
+				showToast("RAG", "file unloaded successfully")
 				app.QueueUpdate(func() {
 					pages.RemovePage(RAGPage)
+					loadedFiles, _ := ragger.ListLoaded()
+					chatRAGTable := makeRAGTable(fileList, loadedFiles)
+					pages.AddPage(RAGPage, chatRAGTable, true, true)
 				})
 			}()
 			return
@@ -492,9 +470,22 @@ func makeRAGTable(fileList []string, loadedFiles []string) *tview.Flex {
 				logger.Error("failed to delete file", "filename", fpath, "error", err)
 				return
 			}
-			if err := notifyUser("chat deleted", fpath+" was deleted"); err != nil {
+			showToast("chat deleted", fpath+" was deleted")
-				logger.Error("failed to send notification", "error", err)
+			go func() {
-			}
+				app.QueueUpdate(func() {
+					pages.RemovePage(RAGPage)
+					newFileList, _ := os.ReadDir(cfg.RAGDir)
+					loadedFiles, _ := ragger.ListLoaded()
+					var newFiles []string
+					for _, f := range newFileList {
+						if !f.IsDir() {
+							newFiles = append(newFiles, f.Name())
+						}
+					}
+					chatRAGTable := makeRAGTable(newFiles, loadedFiles)
+					pages.AddPage(RAGPage, chatRAGTable, true, true)
+				})
+			}()
 			return
 		default:
 			pages.RemovePage(RAGPage)
@@ -529,8 +520,8 @@ func makeAgentTable(agentList []string) *tview.Table {
 						SetSelectable(false))
 			case 1:
 				if actions[c-1] == "filepath" {
-					cc, ok := sysMap[agentList[r]]
+					cc := GetCardByRole(agentList[r])
-					if !ok {
+					if cc == nil {
 						continue
 					}
 					chatActTable.SetCell(r, c,
@@ -603,9 +594,7 @@ func makeAgentTable(agentList []string) *tview.Table {
 			if err := store.RemoveChat(sc.ID); err != nil {
 				logger.Error("failed to remove chat from db", "chat_id", sc.ID, "chat_name", sc.Name)
 			}
-			if err := notifyUser("chat deleted", selected+" was deleted"); err != nil {
+			showToast("chat deleted", selected+" was deleted")
-				logger.Error("failed to send notification", "error", err)
-			}
 			pages.RemovePage(agentPage)
 			return
 		default:
@@ -676,13 +665,9 @@ func makeCodeBlockTable(codeBlocks []string) *tview.Table {
 		switch tc.Text {
 		case "copy":
 			if err := copyToClipboard(selected); err != nil {
-				if err := notifyUser("error", err.Error()); err != nil {
+				showToast("error", err.Error())
-					logger.Error("failed to send notification", "error", err)
-				}
-			}
-			if err := notifyUser("copied", selected); err != nil {
-				logger.Error("failed to send notification", "error", err)
 			}
+			showToast("copied", selected)
 			pages.RemovePage(codeBlockPage)
 			app.SetFocus(textArea)
 			return
@@ -775,9 +760,7 @@ func makeImportChatTable(filenames []string) *tview.Table {
 			if err := store.RemoveChat(sc.ID); err != nil {
 				logger.Error("failed to remove chat from db", "chat_id", sc.ID, "chat_name", sc.Name)
 			}
-			if err := notifyUser("chat deleted", selected+" was deleted"); err != nil {
+			showToast("chat deleted", selected+" was deleted")
-				logger.Error("failed to send notification", "error", err)
-			}
 			pages.RemovePage(historyPage)
 			return
 		default:

tools/chain.go

@@ -0,0 +1,416 @@
+package tools
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// Operator represents a chain operator between commands.
+type Operator int
+
+const (
+	OpNone Operator = iota
+	OpAnd           // &&
+	OpOr            // ||
+	OpSeq           // ;
+	OpPipe          // |
+)
+
+// Segment is a single command in a chain.
+type Segment struct {
+	Raw string
+	Op  Operator // operator AFTER this segment
+}
+
+// ParseChain splits a command string into segments by &&, ;, and |.
+// Respects quoted strings (single and double quotes).
+func ParseChain(input string) []Segment {
+	var segments []Segment
+	var current strings.Builder
+	runes := []rune(input)
+	n := len(runes)
+	for i := 0; i < n; i++ {
+		ch := runes[i]
+		// handle quotes
+		if ch == '\'' || ch == '"' {
+			quote := ch
+			current.WriteRune(ch)
+			i++
+			for i < n && runes[i] != quote {
+				current.WriteRune(runes[i])
+				i++
+			}
+			if i < n {
+				current.WriteRune(runes[i])
+			}
+			continue
+		}
+		// &&
+		if ch == '&' && i+1 < n && runes[i+1] == '&' {
+			segments = append(segments, Segment{
+				Raw: strings.TrimSpace(current.String()),
+				Op:  OpAnd,
+			})
+			current.Reset()
+			i++ // skip second &
+			continue
+		}
+		// ;
+		if ch == ';' {
+			segments = append(segments, Segment{
+				Raw: strings.TrimSpace(current.String()),
+				Op:  OpSeq,
+			})
+			current.Reset()
+			continue
+		}
+		// ||
+		if ch == '|' && i+1 < n && runes[i+1] == '|' {
+			segments = append(segments, Segment{
+				Raw: strings.TrimSpace(current.String()),
+				Op:  OpOr,
+			})
+			current.Reset()
+			i++ // skip second |
+			continue
+		}
+		// | (single pipe)
+		if ch == '|' {
+			segments = append(segments, Segment{
+				Raw: strings.TrimSpace(current.String()),
+				Op:  OpPipe,
+			})
+			current.Reset()
+			continue
+		}
+		current.WriteRune(ch)
+	}
+	// last segment
+	last := strings.TrimSpace(current.String())
+	if last != "" {
+		segments = append(segments, Segment{Raw: last, Op: OpNone})
+	}
+	return segments
+}
+
+// ExecChain executes a command string with pipe/chaining support.
+// Returns the combined output of all commands.
+func ExecChain(command string) string {
+	segments := ParseChain(command)
+	if len(segments) == 0 {
+		return "[error] empty command"
+	}
+	var collected []string
+	var lastOutput string
+	var lastErr error
+	pipeInput := ""
+	for i, seg := range segments {
+		if i > 0 {
+			prevOp := segments[i-1].Op
+			// && semantics: skip if previous failed
+			if prevOp == OpAnd && lastErr != nil {
+				continue
+			}
+			// || semantics: skip if previous succeeded
+			if prevOp == OpOr && lastErr == nil {
+				continue
+			}
+		}
+		// determine stdin for this segment
+		segStdin := ""
+		if i == 0 {
+			segStdin = pipeInput
+		} else if segments[i-1].Op == OpPipe {
+			segStdin = lastOutput
+		}
+		lastOutput, lastErr = execSingle(seg.Raw, segStdin)
+		// pipe: output flows to next command's stdin
+		// && or ;: collect output
+		if i < len(segments)-1 && seg.Op == OpPipe {
+			continue
+		}
+		if lastOutput != "" {
+			collected = append(collected, lastOutput)
+		}
+	}
+	return strings.Join(collected, "\n")
+}
+
+// execSingle executes a single command (with arguments) and returns output and error.
+func execSingle(command, stdin string) (string, error) {
+	parts := tokenize(command)
+	if len(parts) == 0 {
+		return "", errors.New("empty command")
+	}
+	name := parts[0]
+	args := parts[1:]
+	// Check if it's a built-in Go command
+	if result, isBuiltin := execBuiltin(name, args, stdin); isBuiltin {
+		return result, nil
+	}
+	// Otherwise execute as system command
+	cmd := exec.Command(name, args...)
+	if stdin != "" {
+		cmd.Stdin = strings.NewReader(stdin)
+	}
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return string(output), err
+	}
+	return string(output), nil
+}
+
+// tokenize splits a command string by whitespace, respecting quotes.
+func tokenize(input string) []string {
+	var tokens []string
+	var current strings.Builder
+	inQuote := false
+	var quoteChar rune
+	for _, ch := range input {
+		if inQuote {
+			if ch == quoteChar {
+				inQuote = false
+			} else {
+				current.WriteRune(ch)
+			}
+			continue
+		}
+		if ch == '\'' || ch == '"' {
+			inQuote = true
+			quoteChar = ch
+			continue
+		}
+		if ch == ' ' || ch == '\t' {
+			if current.Len() > 0 {
+				tokens = append(tokens, current.String())
+				current.Reset()
+			}
+			continue
+		}
+		current.WriteRune(ch)
+	}
+	if current.Len() > 0 {
+		tokens = append(tokens, current.String())
+	}
+	return tokens
+}
+
+// execBuiltin executes a built-in command if it exists.
+// Returns (result, true) if it was a built-in (even if result is empty).
+// Returns ("", false) if it's not a built-in command.
+func execBuiltin(name string, args []string, stdin string) (string, bool) {
+	switch name {
+	case "echo":
+		if stdin != "" {
+			return stdin, true
+		}
+		return strings.Join(args, " "), true
+	case "time":
+		return "2006-01-02 15:04:05 MST", true
+	case "cat":
+		if len(args) == 0 {
+			if stdin != "" {
+				return stdin, true
+			}
+			return "", true
+		}
+		path := args[0]
+		abs := path
+		if !filepath.IsAbs(path) {
+			abs = filepath.Join(cfg.FilePickerDir, path)
+		}
+		data, err := os.ReadFile(abs)
+		if err != nil {
+			return fmt.Sprintf("[error] cat: %v", err), true
+		}
+		return string(data), true
+	case "pwd":
+		return cfg.FilePickerDir, true
+	case "cd":
+		if len(args) == 0 {
+			return "[error] usage: cd <dir>", true
+		}
+		dir := args[0]
+		// Resolve relative to cfg.FilePickerDir
+		abs := dir
+		if !filepath.IsAbs(dir) {
+			abs = filepath.Join(cfg.FilePickerDir, dir)
+		}
+		abs = filepath.Clean(abs)
+		info, err := os.Stat(abs)
+		if err != nil {
+			return fmt.Sprintf("[error] cd: %v", err), true
+		}
+		if !info.IsDir() {
+			return "[error] cd: not a directory: " + dir, true
+		}
+		cfg.FilePickerDir = abs
+		return "Changed directory to: " + cfg.FilePickerDir, true
+	case "mkdir":
+		if len(args) == 0 {
+			return "[error] usage: mkdir [-p] <dir>", true
+		}
+		createParents := false
+		var dirPath string
+		for _, a := range args {
+			if a == "-p" || a == "--parents" {
+				createParents = true
+			} else if dirPath == "" {
+				dirPath = a
+			}
+		}
+		if dirPath == "" {
+			return "[error] usage: mkdir [-p] <dir>", true
+		}
+		abs := dirPath
+		if !filepath.IsAbs(dirPath) {
+			abs = filepath.Join(cfg.FilePickerDir, dirPath)
+		}
+		abs = filepath.Clean(abs)
+		var mkdirFunc func(string, os.FileMode) error
+		if createParents {
+			mkdirFunc = os.MkdirAll
+		} else {
+			mkdirFunc = os.Mkdir
+		}
+		if err := mkdirFunc(abs, 0o755); err != nil {
+			return fmt.Sprintf("[error] mkdir: %v", err), true
+		}
+		if createParents {
+			return "Created " + dirPath + " (with parents)", true
+		}
+		return "Created " + dirPath, true
+	case "ls":
+		dir := "."
+		for _, a := range args {
+			if !strings.HasPrefix(a, "-") {
+				dir = a
+				break
+			}
+		}
+		abs := dir
+		if !filepath.IsAbs(dir) {
+			abs = filepath.Join(cfg.FilePickerDir, dir)
+		}
+		entries, err := os.ReadDir(abs)
+		if err != nil {
+			return fmt.Sprintf("[error] ls: %v", err), true
+		}
+		var out strings.Builder
+		for _, e := range entries {
+			info, _ := e.Info()
+			switch {
+			case e.IsDir():
+				fmt.Fprintf(&out, "d  %-8s %s/\n", "-", e.Name())
+			case info != nil:
+				size := info.Size()
+				sizeStr := strconv.FormatInt(size, 10)
+				if size > 1024 {
+					sizeStr = fmt.Sprintf("%.1fKB", float64(size)/1024)
+				}
+				fmt.Fprintf(&out, "f  %-8s %s\n", sizeStr, e.Name())
+			default:
+				fmt.Fprintf(&out, "f  %-8s %s\n", "?", e.Name())
+			}
+		}
+		if out.Len() == 0 {
+			return "(empty directory)", true
+		}
+		return strings.TrimRight(out.String(), "\n"), true
+	case "go":
+		// Allow all go subcommands
+		if len(args) == 0 {
+			return "[error] usage: go <subcommand> [options]", true
+		}
+		cmd := exec.Command("go", args...)
+		cmd.Dir = cfg.FilePickerDir
+		output, err := cmd.CombinedOutput()
+		if err != nil {
+			return fmt.Sprintf("[error] go %s: %v\n%s", args[0], err, string(output)), true
+		}
+		return string(output), true
+	case "cp":
+		if len(args) < 2 {
+			return "[error] usage: cp <source> <dest>", true
+		}
+		src := args[0]
+		dst := args[1]
+		if !filepath.IsAbs(src) {
+			src = filepath.Join(cfg.FilePickerDir, src)
+		}
+		if !filepath.IsAbs(dst) {
+			dst = filepath.Join(cfg.FilePickerDir, dst)
+		}
+		data, err := os.ReadFile(src)
+		if err != nil {
+			return fmt.Sprintf("[error] cp: %v", err), true
+		}
+		err = os.WriteFile(dst, data, 0644)
+		if err != nil {
+			return fmt.Sprintf("[error] cp: %v", err), true
+		}
+		return "Copied " + src + " to " + dst, true
+	case "mv":
+		if len(args) < 2 {
+			return "[error] usage: mv <source> <dest>", true
+		}
+		src := args[0]
+		dst := args[1]
+		if !filepath.IsAbs(src) {
+			src = filepath.Join(cfg.FilePickerDir, src)
+		}
+		if !filepath.IsAbs(dst) {
+			dst = filepath.Join(cfg.FilePickerDir, dst)
+		}
+		err := os.Rename(src, dst)
+		if err != nil {
+			return fmt.Sprintf("[error] mv: %v", err), true
+		}
+		return "Moved " + src + " to " + dst, true
+	case "rm":
+		if len(args) == 0 {
+			return "[error] usage: rm [-r] <file>", true
+		}
+		recursive := false
+		var target string
+		for _, a := range args {
+			if a == "-r" || a == "-rf" || a == "-fr" || a == "-recursive" {
+				recursive = true
+			} else if target == "" {
+				target = a
+			}
+		}
+		if target == "" {
+			return "[error] usage: rm [-r] <file>", true
+		}
+		abs := target
+		if !filepath.IsAbs(target) {
+			abs = filepath.Join(cfg.FilePickerDir, target)
+		}
+		info, err := os.Stat(abs)
+		if err != nil {
+			return fmt.Sprintf("[error] rm: %v", err), true
+		}
+		if info.IsDir() {
+			if recursive {
+				err = os.RemoveAll(abs)
+				if err != nil {
+					return fmt.Sprintf("[error] rm: %v", err), true
+				}
+				return "Removed " + abs, true
+			}
+			return "[error] rm: is a directory (use -r)", true
+		}
+		err = os.Remove(abs)
+		if err != nil {
+			return fmt.Sprintf("[error] rm: %v", err), true
+		}
+		return "Removed " + abs, true
+	}
+	return "", false
+}

tools/fs.go

@@ -0,0 +1,755 @@
+package tools
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"gf-lt/models"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var memoryStore MemoryStore
+var agentRole string
+
+type MemoryStore interface {
+	Memorise(agent, topic, data string) (string, error)
+	Recall(agent, topic string) (string, error)
+	RecallTopics(agent string) ([]string, error)
+	Forget(agent, topic string) error
+}
+
+func SetMemoryStore(store MemoryStore, role string) {
+	memoryStore = store
+	agentRole = role
+}
+
+func SetFSRoot(dir string) {
+	if cfg == nil {
+		return
+	}
+	cfg.FilePickerDir = dir
+}
+
+func GetFSRoot() string {
+	return cfg.FilePickerDir
+}
+
+func SetFSCwd(dir string) error {
+	abs, err := filepath.Abs(dir)
+	if err != nil {
+		return err
+	}
+	info, err := os.Stat(abs)
+	if err != nil {
+		return err
+	}
+	if !info.IsDir() {
+		return fmt.Errorf("not a directory: %s", dir)
+	}
+	cfg.FilePickerDir = abs
+	return nil
+}
+
+func resolvePath(rel string) (string, error) {
+	if cfg.FilePickerDir == "" {
+		return "", errors.New("fs root not set")
+	}
+	if filepath.IsAbs(rel) {
+		abs := filepath.Clean(rel)
+		if !strings.HasPrefix(abs, cfg.FilePickerDir+string(os.PathSeparator)) && abs != cfg.FilePickerDir {
+			return "", fmt.Errorf("path escapes fs root: %s", rel)
+		}
+		return abs, nil
+	}
+	abs := filepath.Join(cfg.FilePickerDir, rel)
+	abs = filepath.Clean(abs)
+	if !strings.HasPrefix(abs, cfg.FilePickerDir+string(os.PathSeparator)) && abs != cfg.FilePickerDir {
+		return "", fmt.Errorf("path escapes fs root: %s", rel)
+	}
+	return abs, nil
+}
+
+func humanSize(n int64) string {
+	switch {
+	case n >= 1<<20:
+		return fmt.Sprintf("%.1fMB", float64(n)/float64(1<<20))
+	case n >= 1<<10:
+		return fmt.Sprintf("%.1fKB", float64(n)/float64(1<<10))
+	default:
+		return fmt.Sprintf("%dB", n)
+	}
+}
+
+func IsImageFile(path string) bool {
+	ext := strings.ToLower(filepath.Ext(path))
+	return ext == ".png" || ext == ".jpg" || ext == ".jpeg" || ext == ".gif" || ext == ".webp" || ext == ".svg"
+}
+
+func FsLs(args []string, stdin string) string {
+	dir := ""
+	if len(args) > 0 {
+		dir = args[0]
+	}
+	abs, err := resolvePath(dir)
+	if err != nil {
+		return fmt.Sprintf("[error] %v", err)
+	}
+	entries, err := os.ReadDir(abs)
+	if err != nil {
+		return fmt.Sprintf("[error] ls: %v", err)
+	}
+	var out strings.Builder
+	for _, e := range entries {
+		info, _ := e.Info()
+		switch {
+		case e.IsDir():
+			fmt.Fprintf(&out, "d  %-8s %s/\n", "-", e.Name())
+		case info != nil:
+			fmt.Fprintf(&out, "f  %-8s %s\n", humanSize(info.Size()), e.Name())
+		default:
+			fmt.Fprintf(&out, "f  %-8s %s\n", "?", e.Name())
+		}
+	}
+	if out.Len() == 0 {
+		return "(empty directory)"
+	}
+	return strings.TrimRight(out.String(), "\n")
+}
+
+func FsCat(args []string, stdin string) string {
+	b64 := false
+	var path string
+	for _, a := range args {
+		if a == "-b" || a == "--base64" {
+			b64 = true
+		} else if path == "" {
+			path = a
+		}
+	}
+	if path == "" {
+		return "[error] usage: cat <path>"
+	}
+	abs, err := resolvePath(path)
+	if err != nil {
+		return fmt.Sprintf("[error] %v", err)
+	}
+	data, err := os.ReadFile(abs)
+	if err != nil {
+		return fmt.Sprintf("[error] cat: %v", err)
+	}
+	if b64 {
+		result := base64.StdEncoding.EncodeToString(data)
+		if IsImageFile(path) {
+			result += fmt.Sprintf("\n![image](file://%s)", abs)
+		}
+		return result
+	}
+	return string(data)
+}
+
+func FsViewImg(args []string, stdin string) string {
+	if len(args) == 0 {
+		return "[error] usage: view_img <image-path>"
+	}
+	path := args[0]
+	var abs string
+	if filepath.IsAbs(path) {
+		abs = path
+	} else {
+		var err error
+		abs, err = resolvePath(path)
+		if err != nil {
+			return fmt.Sprintf("[error] %v", err)
+		}
+	}
+	if _, err := os.Stat(abs); err != nil {
+		return fmt.Sprintf("[error] view_img: %v", err)
+	}
+	if !IsImageFile(path) {
+		return fmt.Sprintf("[error] not an image file: %s (use cat to read text files)", path)
+	}
+	dataURL, err := models.CreateImageURLFromPath(abs)
+	if err != nil {
+		return fmt.Sprintf("[error] view_img: %v", err)
+	}
+	result := models.MultimodalToolResp{
+		Type: "multimodal_content",
+		Parts: []map[string]string{
+			{"type": "text", "text": "Image: " + path},
+			{"type": "image_url", "url": dataURL},
+		},
+	}
+	jsonResult, err := json.Marshal(result)
+	if err != nil {
+		return fmt.Sprintf("[error] view_img: %v", err)
+	}
+	return string(jsonResult)
+}
+
+// FsSee is deprecated, use FsViewImg
+func FsSee(args []string, stdin string) string {
+	return FsViewImg(args, stdin)
+}
+
+func FsWrite(args []string, stdin string) string {
+	b64 := false
+	var path string
+	var contentParts []string
+	for _, a := range args {
+		switch a {
+		case "-b", "--base64":
+			b64 = true
+		default:
+			if path == "" {
+				path = a
+			} else {
+				contentParts = append(contentParts, a)
+			}
+		}
+	}
+	if path == "" {
+		return "[error] usage: write <path> [content] or pipe stdin"
+	}
+	abs, err := resolvePath(path)
+	if err != nil {
+		return fmt.Sprintf("[error] %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(abs), 0o755); err != nil {
+		return fmt.Sprintf("[error] mkdir: %v", err)
+	}
+	var data []byte
+	if b64 {
+		src := stdin
+		if src == "" && len(contentParts) > 0 {
+			src = strings.Join(contentParts, " ")
+		}
+		src = strings.TrimSpace(src)
+		var err error
+		data, err = base64.StdEncoding.DecodeString(src)
+		if err != nil {
+			return fmt.Sprintf("[error] base64 decode: %v", err)
+		}
+	} else {
+		if len(contentParts) > 0 {
+			data = []byte(strings.Join(contentParts, " "))
+		} else {
+			data = []byte(stdin)
+		}
+	}
+	if err := os.WriteFile(abs, data, 0o644); err != nil {
+		return fmt.Sprintf("[error] write: %v", err)
+	}
+	size := humanSize(int64(len(data)))
+	result := fmt.Sprintf("Written %s → %s", size, path)
+	if IsImageFile(path) {
+		result += fmt.Sprintf("\n![image](file://%s)", abs)
+	}
+	return result
+}
+
+func FsStat(args []string, stdin string) string {
+	if len(args) == 0 {
+		return "[error] usage: stat <path>"
+	}
+	abs, err := resolvePath(args[0])
+	if err != nil {
+		return fmt.Sprintf("[error] %v", err)
+	}
+	info, err := os.Stat(abs)
+	if err != nil {
+		return fmt.Sprintf("[error] stat: %v", err)
+	}
+	mime := "application/octet-stream"
+	if IsImageFile(args[0]) {
+		ext := strings.ToLower(filepath.Ext(args[0]))
+		switch ext {
+		case ".png":
+			mime = "image/png"
+		case ".jpg", ".jpeg":
+			mime = "image/jpeg"
+		case ".gif":
+			mime = "image/gif"
+		case ".webp":
+			mime = "image/webp"
+		case ".svg":
+			mime = "image/svg+xml"
+		}
+	}
+	var out strings.Builder
+	fmt.Fprintf(&out, "File: %s\n", args[0])
+	fmt.Fprintf(&out, "Size: %s (%d bytes)\n", humanSize(info.Size()), info.Size())
+	fmt.Fprintf(&out, "Type: %s\n", mime)
+	fmt.Fprintf(&out, "Modified: %s\n", info.ModTime().Format(time.RFC3339))
+	if info.IsDir() {
+		fmt.Fprintf(&out, "Kind: directory\n")
+	}
+	return strings.TrimRight(out.String(), "\n")
+}
+
+func FsRm(args []string, stdin string) string {
+	if len(args) == 0 {
+		return "[error] usage: rm <path>"
+	}
+	abs, err := resolvePath(args[0])
+	if err != nil {
+		return fmt.Sprintf("[error] %v", err)
+	}
+	if err := os.RemoveAll(abs); err != nil {
+		return fmt.Sprintf("[error] rm: %v", err)
+	}
+	return "Removed " + args[0]
+}
+
+func FsCp(args []string, stdin string) string {
+	if len(args) < 2 {
+		return "[error] usage: cp <src> <dst>"
+	}
+	srcAbs, err := resolvePath(args[0])
+	if err != nil {
+		return fmt.Sprintf("[error] %v", err)
+	}
+	dstAbs, err := resolvePath(args[1])
+	if err != nil {
+		return fmt.Sprintf("[error] %v", err)
+	}
+	data, err := os.ReadFile(srcAbs)
+	if err != nil {
+		return fmt.Sprintf("[error] cp read: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(dstAbs), 0o755); err != nil {
+		return fmt.Sprintf("[error] cp mkdir: %v", err)
+	}
+	if err := os.WriteFile(dstAbs, data, 0o644); err != nil {
+		return fmt.Sprintf("[error] cp write: %v", err)
+	}
+	return fmt.Sprintf("Copied %s → %s (%s)", args[0], args[1], humanSize(int64(len(data))))
+}
+
+func FsMv(args []string, stdin string) string {
+	if len(args) < 2 {
+		return "[error] usage: mv <src> <dst>"
+	}
+	srcAbs, err := resolvePath(args[0])
+	if err != nil {
+		return fmt.Sprintf("[error] %v", err)
+	}
+	dstAbs, err := resolvePath(args[1])
+	if err != nil {
+		return fmt.Sprintf("[error] %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(dstAbs), 0o755); err != nil {
+		return fmt.Sprintf("[error] mv mkdir: %v", err)
+	}
+	if err := os.Rename(srcAbs, dstAbs); err != nil {
+		return fmt.Sprintf("[error] mv: %v", err)
+	}
+	return fmt.Sprintf("Moved %s → %s", args[0], args[1])
+}
+
+func FsMkdir(args []string, stdin string) string {
+	if len(args) == 0 {
+		return "[error] usage: mkdir [-p] <dir>"
+	}
+	createParents := false
+	var dirPath string
+	for _, a := range args {
+		if a == "-p" || a == "--parents" {
+			createParents = true
+		} else if dirPath == "" {
+			dirPath = a
+		}
+	}
+	if dirPath == "" {
+		return "[error] usage: mkdir [-p] <dir>"
+	}
+	abs, err := resolvePath(dirPath)
+	if err != nil {
+		return fmt.Sprintf("[error] %v", err)
+	}
+	var mkdirFunc func(string, os.FileMode) error
+	if createParents {
+		mkdirFunc = os.MkdirAll
+	} else {
+		mkdirFunc = os.Mkdir
+	}
+	if err := mkdirFunc(abs, 0o755); err != nil {
+		return fmt.Sprintf("[error] mkdir: %v", err)
+	}
+	if createParents {
+		return "Created " + dirPath + " (with parents)"
+	}
+	return "Created " + dirPath
+}
+
+// Text processing commands
+
+func FsEcho(args []string, stdin string) string {
+	if stdin != "" {
+		return stdin
+	}
+	return strings.Join(args, " ")
+}
+
+func FsTime(args []string, stdin string) string {
+	return time.Now().Format("2006-01-02 15:04:05 MST")
+}
+
+func FsGrep(args []string, stdin string) string {
+	if len(args) == 0 {
+		return "[error] usage: grep [-i] [-v] [-c] <pattern>"
+	}
+	ignoreCase := false
+	invert := false
+	countOnly := false
+	var pattern string
+	for _, a := range args {
+		switch a {
+		case "-i":
+			ignoreCase = true
+		case "-v":
+			invert = true
+		case "-c":
+			countOnly = true
+		default:
+			pattern = a
+		}
+	}
+	if pattern == "" {
+		return "[error] pattern required"
+	}
+	if ignoreCase {
+		pattern = strings.ToLower(pattern)
+	}
+	lines := strings.Split(stdin, "\n")
+	var matched []string
+	for _, line := range lines {
+		haystack := line
+		if ignoreCase {
+			haystack = strings.ToLower(line)
+		}
+		match := strings.Contains(haystack, pattern)
+		if invert {
+			match = !match
+		}
+		if match {
+			matched = append(matched, line)
+		}
+	}
+	if countOnly {
+		return strconv.Itoa(len(matched))
+	}
+	return strings.Join(matched, "\n")
+}
+
+func FsHead(args []string, stdin string) string {
+	n := 10
+	for i, a := range args {
+		if a == "-n" && i+1 < len(args) {
+			if parsed, err := strconv.Atoi(args[i+1]); err == nil {
+				n = parsed
+			}
+		} else if strings.HasPrefix(a, "-") {
+			continue
+		} else if parsed, err := strconv.Atoi(a); err == nil {
+			n = parsed
+		}
+	}
+	lines := strings.Split(stdin, "\n")
+	if n > 0 && len(lines) > n {
+		lines = lines[:n]
+	}
+	return strings.Join(lines, "\n")
+}
+
+func FsTail(args []string, stdin string) string {
+	n := 10
+	for i, a := range args {
+		if a == "-n" && i+1 < len(args) {
+			if parsed, err := strconv.Atoi(args[i+1]); err == nil {
+				n = parsed
+			}
+		} else if strings.HasPrefix(a, "-") {
+			continue
+		} else if parsed, err := strconv.Atoi(a); err == nil {
+			n = parsed
+		}
+	}
+	lines := strings.Split(stdin, "\n")
+	if n > 0 && len(lines) > n {
+		lines = lines[len(lines)-n:]
+	}
+	return strings.Join(lines, "\n")
+}
+
+func FsWc(args []string, stdin string) string {
+	lines := len(strings.Split(stdin, "\n"))
+	words := len(strings.Fields(stdin))
+	chars := len(stdin)
+	if len(args) > 0 {
+		switch args[0] {
+		case "-l":
+			return strconv.Itoa(lines)
+		case "-w":
+			return strconv.Itoa(words)
+		case "-c":
+			return strconv.Itoa(chars)
+		}
+	}
+	return fmt.Sprintf("%d lines, %d words, %d chars", lines, words, chars)
+}
+
+func FsSort(args []string, stdin string) string {
+	lines := strings.Split(stdin, "\n")
+	reverse := false
+	numeric := false
+	for _, a := range args {
+		switch a {
+		case "-r":
+			reverse = true
+		case "-n":
+			numeric = true
+		}
+	}
+	sortFunc := func(i, j int) bool {
+		if numeric {
+			ni, _ := strconv.Atoi(lines[i])
+			nj, _ := strconv.Atoi(lines[j])
+			if reverse {
+				return ni > nj
+			}
+			return ni < nj
+		}
+		if reverse {
+			return lines[i] > lines[j]
+		}
+		return lines[i] < lines[j]
+	}
+	sort.Slice(lines, sortFunc)
+	return strings.Join(lines, "\n")
+}
+
+func FsUniq(args []string, stdin string) string {
+	lines := strings.Split(stdin, "\n")
+	showCount := false
+	for _, a := range args {
+		if a == "-c" {
+			showCount = true
+		}
+	}
+	var result []string
+	var prev string
+	first := true
+	count := 0
+	for _, line := range lines {
+		if first || line != prev {
+			if !first && showCount {
+				result = append(result, fmt.Sprintf("%d %s", count, prev))
+			} else if !first {
+				result = append(result, prev)
+			}
+			count = 1
+			prev = line
+			first = false
+		} else {
+			count++
+		}
+	}
+	if !first {
+		if showCount {
+			result = append(result, fmt.Sprintf("%d %s", count, prev))
+		} else {
+			result = append(result, prev)
+		}
+	}
+	return strings.Join(result, "\n")
+}
+
+var allowedGitSubcommands = map[string]bool{
+	"status":    true,
+	"log":       true,
+	"diff":      true,
+	"show":      true,
+	"branch":    true,
+	"reflog":    true,
+	"rev-parse": true,
+	"shortlog":  true,
+	"describe":  true,
+	"rev-list":  true,
+}
+
+func FsGit(args []string, stdin string) string {
+	if len(args) == 0 {
+		return "[error] usage: git <subcommand> [options]"
+	}
+	subcmd := args[0]
+	if !allowedGitSubcommands[subcmd] {
+		return fmt.Sprintf("[error] git: '%s' is not an allowed git command. Allowed: status, log, diff, show, branch, reflog, rev-parse, shortlog, describe, rev-list", subcmd)
+	}
+	abs, err := resolvePath(".")
+	if err != nil {
+		return fmt.Sprintf("[error] git: %v", err)
+	}
+	// Pass all args to git (first arg is subcommand, rest are options)
+	cmd := exec.Command("git", args...)
+	cmd.Dir = abs
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Sprintf("[error] git %s: %v\n%s", subcmd, err, string(output))
+	}
+	return string(output)
+}
+
+func FsPwd(args []string, stdin string) string {
+	return cfg.FilePickerDir
+}
+
+func FsCd(args []string, stdin string) string {
+	if len(args) == 0 {
+		return "[error] usage: cd <dir>"
+	}
+	dir := args[0]
+	abs, err := resolvePath(dir)
+	if err != nil {
+		return fmt.Sprintf("[error] cd: %v", err)
+	}
+	info, err := os.Stat(abs)
+	if err != nil {
+		return fmt.Sprintf("[error] cd: %v", err)
+	}
+	if !info.IsDir() {
+		return "[error] cd: not a directory: " + dir
+	}
+	cfg.FilePickerDir = abs
+	return "Changed directory to: " + cfg.FilePickerDir
+}
+
+func FsSed(args []string, stdin string) string {
+	if len(args) == 0 {
+		return "[error] usage: sed 's/old/new/[g]' [file]"
+	}
+	inPlace := false
+	var filePath string
+	var pattern string
+	for _, a := range args {
+		switch a {
+		case "-i", "--in-place":
+			inPlace = true
+		default:
+			if strings.HasPrefix(a, "s") && len(a) > 1 {
+				pattern = a
+			} else if filePath == "" && !strings.HasPrefix(a, "-") {
+				filePath = a
+			}
+		}
+	}
+	if pattern == "" {
+		return "[error] usage: sed 's/old/new/[g]' [file]"
+	}
+	// Parse pattern: s/old/new/flags
+	parts := strings.Split(pattern[1:], "/")
+	if len(parts) < 2 {
+		return "[error] invalid sed pattern. Use: s/old/new/[g]"
+	}
+	oldStr := parts[0]
+	newStr := parts[1]
+	global := len(parts) >= 3 && strings.Contains(parts[2], "g")
+	var content string
+	switch {
+	case filePath != "" && stdin == "":
+		abs, err := resolvePath(filePath)
+		if err != nil {
+			return fmt.Sprintf("[error] sed: %v", err)
+		}
+		data, err := os.ReadFile(abs)
+		if err != nil {
+			return fmt.Sprintf("[error] sed: %v", err)
+		}
+		content = string(data)
+	case stdin != "":
+		content = stdin
+	default:
+		return "[error] sed: no input (use file path or pipe from stdin)"
+	}
+	// Apply sed replacement
+	if global {
+		content = strings.ReplaceAll(content, oldStr, newStr)
+	} else {
+		content = strings.Replace(content, oldStr, newStr, 1)
+	}
+	if inPlace && filePath != "" {
+		abs, err := resolvePath(filePath)
+		if err != nil {
+			return fmt.Sprintf("[error] sed: %v", err)
+		}
+		if err := os.WriteFile(abs, []byte(content), 0644); err != nil {
+			return fmt.Sprintf("[error] sed: %v", err)
+		}
+		return "Modified " + filePath
+	}
+	return content
+}
+
+func FsMemory(args []string, stdin string) string {
+	if len(args) == 0 {
+		return "[error] usage: memory store <topic> <data> | memory get <topic> | memory list | memory forget <topic>"
+	}
+	if memoryStore == nil {
+		return "[error] memory store not initialized"
+	}
+	switch args[0] {
+	case "store":
+		if len(args) < 3 && stdin == "" {
+			return "[error] usage: memory store <topic> <data>"
+		}
+		topic := args[1]
+		var data string
+		if len(args) >= 3 {
+			data = strings.Join(args[2:], " ")
+		} else {
+			data = stdin
+		}
+		_, err := memoryStore.Memorise(agentRole, topic, data)
+		if err != nil {
+			return fmt.Sprintf("[error] failed to store: %v", err)
+		}
+		return "Stored under topic: " + topic
+	case "get":
+		if len(args) < 2 {
+			return "[error] usage: memory get <topic>"
+		}
+		topic := args[1]
+		data, err := memoryStore.Recall(agentRole, topic)
+		if err != nil {
+			return fmt.Sprintf("[error] failed to recall: %v", err)
+		}
+		return fmt.Sprintf("Topic: %s\n%s", topic, data)
+	case "list", "topics":
+		topics, err := memoryStore.RecallTopics(agentRole)
+		if err != nil {
+			return fmt.Sprintf("[error] failed to list topics: %v", err)
+		}
+		if len(topics) == 0 {
+			return "No topics stored."
+		}
+		return "Topics: " + strings.Join(topics, ", ")
+	case "forget", "delete":
+		if len(args) < 2 {
+			return "[error] usage: memory forget <topic>"
+		}
+		topic := args[1]
+		err := memoryStore.Forget(agentRole, topic)
+		if err != nil {
+			return fmt.Sprintf("[error] failed to forget: %v", err)
+		}
+		return "Deleted topic: " + topic
+	default:
+		return fmt.Sprintf("[error] unknown subcommand: %s. Use: store, get, list, topics, forget, delete", args[0])
+	}
+}

tools/pw.go

@@ -0,0 +1,645 @@
+package tools
+
+import (
+	"encoding/json"
+	"fmt"
+	"gf-lt/models"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/playwright-community/playwright-go"
+)
+
+var (
+	pw             *playwright.Playwright
+	browser        playwright.Browser
+	browserStarted bool
+	browserStartMu sync.Mutex
+	page           playwright.Page
+)
+
+func PwShutDown() error {
+	if pw == nil {
+		return nil
+	}
+	pwStop(nil)
+	return pw.Stop()
+}
+
+func InstallPW() error {
+	err := playwright.Install(&playwright.RunOptions{Verbose: false})
+	if err != nil {
+		logger.Warn("playwright not available", "error", err)
+		return err
+	}
+	return nil
+}
+
+func CheckPlaywright() error {
+	var err error
+	pw, err = playwright.Run()
+	if err != nil {
+		logger.Warn("playwright not available", "error", err)
+		return err
+	}
+	return nil
+}
+
+func pwStart(args map[string]string) []byte {
+	browserStartMu.Lock()
+	defer browserStartMu.Unlock()
+	if browserStarted {
+		return []byte(`{"error": "Browser already started"}`)
+	}
+	var err error
+	browser, err = pw.Chromium.Launch(playwright.BrowserTypeLaunchOptions{
+		Headless: playwright.Bool(!cfg.PlaywrightDebug),
+	})
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to launch browser: %s"}`, err.Error()))
+	}
+	page, err = browser.NewPage()
+	if err != nil {
+		browser.Close()
+		return []byte(fmt.Sprintf(`{"error": "failed to create page: %s"}`, err.Error()))
+	}
+	browserStarted = true
+	return []byte(`{"success": true, "message": "Browser started"}`)
+}
+
+func pwStop(args map[string]string) []byte {
+	browserStartMu.Lock()
+	defer browserStartMu.Unlock()
+	if !browserStarted {
+		return []byte(`{"success": true, "message": "Browser was not running"}`)
+	}
+	if page != nil {
+		page.Close()
+		page = nil
+	}
+	if browser != nil {
+		browser.Close()
+		browser = nil
+	}
+	browserStarted = false
+	return []byte(`{"success": true, "message": "Browser stopped"}`)
+}
+
+func pwIsRunning(args map[string]string) []byte {
+	if browserStarted {
+		return []byte(`{"running": true, "message": "Browser is running"}`)
+	}
+	return []byte(`{"running": false, "message": "Browser is not running"}`)
+}
+
+func pwNavigate(args map[string]string) []byte {
+	url, ok := args["url"]
+	if !ok || url == "" {
+		return []byte(`{"error": "url not provided"}`)
+	}
+	if !browserStarted || page == nil {
+		return []byte(`{"error": "Browser not started. Call pw_start first."}`)
+	}
+	_, err := page.Goto(url)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to navigate: %s"}`, err.Error()))
+	}
+	title, _ := page.Title()
+	pageURL := page.URL()
+	return []byte(fmt.Sprintf(`{"success": true, "title": "%s", "url": "%s"}`, title, pageURL))
+}
+
+func pwClick(args map[string]string) []byte {
+	selector, ok := args["selector"]
+	if !ok || selector == "" {
+		return []byte(`{"error": "selector not provided"}`)
+	}
+	if !browserStarted || page == nil {
+		return []byte(`{"error": "Browser not started. Call pw_start first."}`)
+	}
+	index := 0
+	if args["index"] != "" {
+		if i, err := strconv.Atoi(args["index"]); err != nil {
+			logger.Warn("failed to parse index", "value", args["index"], "error", err)
+		} else {
+			index = i
+		}
+	}
+	locator := page.Locator(selector)
+	count, err := locator.Count()
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to find elements: %s"}`, err.Error()))
+	}
+	if index >= count {
+		return []byte(fmt.Sprintf(`{"error": "Element not found at index %d (found %d elements)"}`, index, count))
+	}
+	err = locator.Nth(index).Click()
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to click: %s"}`, err.Error()))
+	}
+	return []byte(`{"success": true, "message": "Clicked element"}`)
+}
+
+func pwFill(args map[string]string) []byte {
+	selector, ok := args["selector"]
+	if !ok || selector == "" {
+		return []byte(`{"error": "selector not provided"}`)
+	}
+	text := args["text"]
+	if text == "" {
+		text = ""
+	}
+	if !browserStarted || page == nil {
+		return []byte(`{"error": "Browser not started. Call pw_start first."}`)
+	}
+	index := 0
+	if args["index"] != "" {
+		if i, err := strconv.Atoi(args["index"]); err != nil {
+			logger.Warn("failed to parse index", "value", args["index"], "error", err)
+		} else {
+			index = i
+		}
+	}
+	locator := page.Locator(selector)
+	count, err := locator.Count()
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to find elements: %s"}`, err.Error()))
+	}
+	if index >= count {
+		return []byte(fmt.Sprintf(`{"error": "Element not found at index %d"}`, index))
+	}
+	err = locator.Nth(index).Fill(text)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to fill: %s"}`, err.Error()))
+	}
+	return []byte(`{"success": true, "message": "Filled input"}`)
+}
+
+func pwExtractText(args map[string]string) []byte {
+	selector := args["selector"]
+	if selector == "" {
+		selector = "body"
+	}
+	if !browserStarted || page == nil {
+		return []byte(`{"error": "Browser not started. Call pw_start first."}`)
+	}
+	locator := page.Locator(selector)
+	count, err := locator.Count()
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to find elements: %s"}`, err.Error()))
+	}
+	if count == 0 {
+		return []byte(`{"error": "No elements found"}`)
+	}
+	if selector == "body" {
+		text, err := page.Locator("body").TextContent()
+		if err != nil {
+			return []byte(fmt.Sprintf(`{"error": "failed to get text: %s"}`, err.Error()))
+		}
+		return []byte(fmt.Sprintf(`{"text": "%s"}`, text))
+	}
+	var texts []string
+	for i := 0; i < count; i++ {
+		text, err := locator.Nth(i).TextContent()
+		if err != nil {
+			continue
+		}
+		texts = append(texts, text)
+	}
+	return []byte(fmt.Sprintf(`{"text": "%s"}`, joinLines(texts)))
+}
+
+func joinLines(lines []string) string {
+	var sb strings.Builder
+	for i, line := range lines {
+		if i > 0 {
+			sb.WriteString("\n")
+		}
+		sb.WriteString(line)
+	}
+	return sb.String()
+}
+
+func pwScreenshot(args map[string]string) []byte {
+	selector := args["selector"]
+	fullPage := args["full_page"] == "true"
+	if !browserStarted || page == nil {
+		return []byte(`{"error": "Browser not started. Call pw_start first."}`)
+	}
+	path := fmt.Sprintf("/tmp/pw_screenshot_%d.png", os.Getpid())
+	var err error
+	if selector != "" && selector != "body" {
+		locator := page.Locator(selector)
+		_, err = locator.Screenshot(playwright.LocatorScreenshotOptions{
+			Path: playwright.String(path),
+		})
+	} else {
+		_, err = page.Screenshot(playwright.PageScreenshotOptions{
+			Path:     playwright.String(path),
+			FullPage: playwright.Bool(fullPage),
+		})
+	}
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to take screenshot: %s"}`, err.Error()))
+	}
+	return []byte(fmt.Sprintf(`{"path": "%s"}`, path))
+}
+
+func pwScreenshotAndView(args map[string]string) []byte {
+	selector := args["selector"]
+	fullPage := args["full_page"] == "true"
+	if !browserStarted || page == nil {
+		return []byte(`{"error": "Browser not started. Call pw_start first."}`)
+	}
+	path := fmt.Sprintf("/tmp/pw_screenshot_%d.png", os.Getpid())
+	var err error
+	if selector != "" && selector != "body" {
+		locator := page.Locator(selector)
+		_, err = locator.Screenshot(playwright.LocatorScreenshotOptions{
+			Path: playwright.String(path),
+		})
+	} else {
+		_, err = page.Screenshot(playwright.PageScreenshotOptions{
+			Path:     playwright.String(path),
+			FullPage: playwright.Bool(fullPage),
+		})
+	}
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to take screenshot: %s"}`, err.Error()))
+	}
+	dataURL, err := models.CreateImageURLFromPath(path)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to create image URL: %s"}`, err.Error()))
+	}
+	resp := models.MultimodalToolResp{
+		Type: "multimodal_content",
+		Parts: []map[string]string{
+			{"type": "text", "text": "Screenshot saved: " + path},
+			{"type": "image_url", "url": dataURL},
+		},
+	}
+	jsonResult, err := json.Marshal(resp)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to marshal result: %s"}`, err.Error()))
+	}
+	return jsonResult
+}
+
+func pwWaitForSelector(args map[string]string) []byte {
+	selector, ok := args["selector"]
+	if !ok || selector == "" {
+		return []byte(`{"error": "selector not provided"}`)
+	}
+	if !browserStarted || page == nil {
+		return []byte(`{"error": "Browser not started. Call pw_start first."}`)
+	}
+	timeout := 30000
+	if args["timeout"] != "" {
+		if t, err := strconv.Atoi(args["timeout"]); err != nil {
+			logger.Warn("failed to parse timeout", "value", args["timeout"], "error", err)
+		} else {
+			timeout = t
+		}
+	}
+	locator := page.Locator(selector)
+	err := locator.WaitFor(playwright.LocatorWaitForOptions{
+		Timeout: playwright.Float(float64(timeout)),
+	})
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "element not found: %s"}`, err.Error()))
+	}
+	return []byte(`{"success": true, "message": "Element found"}`)
+}
+
+func pwDrag(args map[string]string) []byte {
+	x1, ok := args["x1"]
+	if !ok {
+		return []byte(`{"error": "x1 not provided"}`)
+	}
+	y1, ok := args["y1"]
+	if !ok {
+		return []byte(`{"error": "y1 not provided"}`)
+	}
+	x2, ok := args["x2"]
+	if !ok {
+		return []byte(`{"error": "x2 not provided"}`)
+	}
+	y2, ok := args["y2"]
+	if !ok {
+		return []byte(`{"error": "y2 not provided"}`)
+	}
+	if !browserStarted || page == nil {
+		return []byte(`{"error": "Browser not started. Call pw_start first."}`)
+	}
+	var fx1, fy1, fx2, fy2 float64
+	if parsedX1, err := strconv.ParseFloat(x1, 64); err != nil {
+		logger.Warn("failed to parse x1", "value", x1, "error", err)
+	} else {
+		fx1 = parsedX1
+	}
+	if parsedY1, err := strconv.ParseFloat(y1, 64); err != nil {
+		logger.Warn("failed to parse y1", "value", y1, "error", err)
+	} else {
+		fy1 = parsedY1
+	}
+	if parsedX2, err := strconv.ParseFloat(x2, 64); err != nil {
+		logger.Warn("failed to parse x2", "value", x2, "error", err)
+	} else {
+		fx2 = parsedX2
+	}
+	if parsedY2, err := strconv.ParseFloat(y2, 64); err != nil {
+		logger.Warn("failed to parse y2", "value", y2, "error", err)
+	} else {
+		fy2 = parsedY2
+	}
+	mouse := page.Mouse()
+	err := mouse.Move(fx1, fy1)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to move mouse: %s"}`, err.Error()))
+	}
+	err = mouse.Down()
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to mouse down: %s"}`, err.Error()))
+	}
+	err = mouse.Move(fx2, fy2)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to move mouse: %s"}`, err.Error()))
+	}
+	err = mouse.Up()
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to mouse up: %s"}`, err.Error()))
+	}
+	return []byte(fmt.Sprintf(`{"success": true, "message": "Dragged from (%s,%s) to (%s,%s)"}`, x1, y1, x2, y2))
+}
+
+func pwDragBySelector(args map[string]string) []byte {
+	fromSelector, ok := args["fromSelector"]
+	if !ok || fromSelector == "" {
+		return []byte(`{"error": "fromSelector not provided"}`)
+	}
+	toSelector, ok := args["toSelector"]
+	if !ok || toSelector == "" {
+		return []byte(`{"error": "toSelector not provided"}`)
+	}
+	if !browserStarted || page == nil {
+		return []byte(`{"error": "Browser not started. Call pw_start first."}`)
+	}
+	fromJS := fmt.Sprintf(`
+		function getCenter(selector) {
+			const el = document.querySelector(selector);
+			if (!el) return null;
+			const rect = el.getBoundingClientRect();
+			return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+		}
+		getCenter(%q)
+	`, fromSelector)
+	toJS := fmt.Sprintf(`
+		function getCenter(selector) {
+			const el = document.querySelector(selector);
+			if (!el) return null;
+			const rect = el.getBoundingClientRect();
+			return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+		}
+		getCenter(%q)
+	`, toSelector)
+	fromResult, err := page.Evaluate(fromJS)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to get from element: %s"}`, err.Error()))
+	}
+	fromMap, ok := fromResult.(map[string]interface{})
+	if !ok || fromMap == nil {
+		return []byte(fmt.Sprintf(`{"error": "from selector '%s' not found"}`, fromSelector))
+	}
+	fromX := fromMap["x"].(float64)
+	fromY := fromMap["y"].(float64)
+	toResult, err := page.Evaluate(toJS)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to get to element: %s"}`, err.Error()))
+	}
+	toMap, ok := toResult.(map[string]interface{})
+	if !ok || toMap == nil {
+		return []byte(fmt.Sprintf(`{"error": "to selector '%s' not found"}`, toSelector))
+	}
+	toX := toMap["x"].(float64)
+	toY := toMap["y"].(float64)
+	mouse := page.Mouse()
+	err = mouse.Move(fromX, fromY)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to move mouse: %s"}`, err.Error()))
+	}
+	err = mouse.Down()
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to mouse down: %s"}`, err.Error()))
+	}
+	err = mouse.Move(toX, toY)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to move mouse: %s"}`, err.Error()))
+	}
+	err = mouse.Up()
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to mouse up: %s"}`, err.Error()))
+	}
+	msg := fmt.Sprintf("Dragged from %s (%.0f,%.0f) to %s (%.0f,%.0f)", fromSelector, fromX, fromY, toSelector, toX, toY)
+	return []byte(fmt.Sprintf(`{"success": true, "message": "%s"}`, msg))
+}
+
+// nolint:unused
+func pwClickAt(args map[string]string) []byte {
+	x, ok := args["x"]
+	if !ok {
+		return []byte(`{"error": "x not provided"}`)
+	}
+	y, ok := args["y"]
+	if !ok {
+		return []byte(`{"error": "y not provided"}`)
+	}
+	if !browserStarted || page == nil {
+		return []byte(`{"error": "Browser not started. Call pw_start first."}`)
+	}
+	fx, err := strconv.ParseFloat(x, 64)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to parse x: %s"}`, err.Error()))
+	}
+	fy, err := strconv.ParseFloat(y, 64)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to parse y: %s"}`, err.Error()))
+	}
+	mouse := page.Mouse()
+	err = mouse.Click(fx, fy)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to click: %s"}`, err.Error()))
+	}
+	return []byte(fmt.Sprintf(`{"success": true, "message": "Clicked at (%s,%s)"}`, x, y))
+}
+
+func pwGetHTML(args map[string]string) []byte {
+	selector := args["selector"]
+	if selector == "" {
+		selector = "body"
+	}
+	if !browserStarted || page == nil {
+		return []byte(`{"error": "Browser not started. Call pw_start first."}`)
+	}
+	locator := page.Locator(selector)
+	count, err := locator.Count()
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to find elements: %s"}`, err.Error()))
+	}
+	if count == 0 {
+		return []byte(`{"error": "No elements found"}`)
+	}
+	html, err := locator.First().InnerHTML()
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to get HTML: %s"}`, err.Error()))
+	}
+	return []byte(fmt.Sprintf(`{"html": %s}`, jsonString(html)))
+}
+
+type DOMElement struct {
+	Tag        string            `json:"tag,omitempty"`
+	Attributes map[string]string `json:"attributes,omitempty"`
+	Text       string            `json:"text,omitempty"`
+	Children   []DOMElement      `json:"children,omitempty"`
+	Selector   string            `json:"selector,omitempty"`
+	InnerHTML  string            `json:"innerHTML,omitempty"`
+}
+
+func buildDOMTree(locator playwright.Locator) ([]DOMElement, error) {
+	var results []DOMElement
+	count, err := locator.Count()
+	if err != nil {
+		return nil, err
+	}
+	for i := 0; i < count; i++ {
+		el := locator.Nth(i)
+		dom, err := elementToDOM(el)
+		if err != nil {
+			continue
+		}
+		results = append(results, dom)
+	}
+	return results, nil
+}
+
+func elementToDOM(el playwright.Locator) (DOMElement, error) {
+	dom := DOMElement{}
+	tag, err := el.Evaluate(`el => el.nodeName`, nil)
+	if err == nil {
+		dom.Tag = strings.ToLower(fmt.Sprintf("%v", tag))
+	}
+	attributes := make(map[string]string)
+	attrs, err := el.Evaluate(`el => {
+		let attrs = {};
+		for (let i = 0; i < el.attributes.length; i++) {
+			let attr = el.attributes[i];
+			attrs[attr.name] = attr.value;
+		}
+		return attrs;
+	}`, nil)
+	if err == nil {
+		if amap, ok := attrs.(map[string]any); ok {
+			for k, v := range amap {
+				if vs, ok := v.(string); ok {
+					attributes[k] = vs
+				}
+			}
+		}
+	}
+	if len(attributes) > 0 {
+		dom.Attributes = attributes
+	}
+	text, err := el.TextContent()
+	if err == nil && text != "" {
+		dom.Text = text
+	}
+	innerHTML, err := el.InnerHTML()
+	if err == nil && innerHTML != "" {
+		dom.InnerHTML = innerHTML
+	}
+	childCount, _ := el.Count()
+	if childCount > 0 {
+		childrenLocator := el.Locator("*")
+		children, err := buildDOMTree(childrenLocator)
+		if err == nil && len(children) > 0 {
+			dom.Children = children
+		}
+	}
+	return dom, nil
+}
+
+func pwGetDOM(args map[string]string) []byte {
+	selector := args["selector"]
+	if selector == "" {
+		selector = "body"
+	}
+	if !browserStarted || page == nil {
+		return []byte(`{"error": "Browser not started. Call pw_start first."}`)
+	}
+	locator := page.Locator(selector)
+	count, err := locator.Count()
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to find elements: %s"}`, err.Error()))
+	}
+	if count == 0 {
+		return []byte(`{"error": "No elements found"}`)
+	}
+	dom, err := elementToDOM(locator.First())
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to get DOM: %s"}`, err.Error()))
+	}
+	data, err := json.Marshal(dom)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to marshal DOM: %s"}`, err.Error()))
+	}
+	return []byte(fmt.Sprintf(`{"dom": %s}`, string(data)))
+}
+
+// nolint:unused
+func pwSearchElements(args map[string]string) []byte {
+	text := args["text"]
+	selector := args["selector"]
+	if text == "" && selector == "" {
+		return []byte(`{"error": "text or selector not provided"}`)
+	}
+	if !browserStarted || page == nil {
+		return []byte(`{"error": "Browser not started. Call pw_start first."}`)
+	}
+	var locator playwright.Locator
+	if text != "" {
+		locator = page.GetByText(text)
+	} else {
+		locator = page.Locator(selector)
+	}
+	count, err := locator.Count()
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to search elements: %s"}`, err.Error()))
+	}
+	if count == 0 {
+		return []byte(`{"elements": []}`)
+	}
+	var results []map[string]string
+	for i := 0; i < count; i++ {
+		el := locator.Nth(i)
+		tag, _ := el.Evaluate(`el => el.nodeName`, nil)
+		text, _ := el.TextContent()
+		html, _ := el.InnerHTML()
+		results = append(results, map[string]string{
+			"index": strconv.Itoa(i),
+			"tag":   strings.ToLower(fmt.Sprintf("%v", tag)),
+			"text":  text,
+			"html":  html,
+		})
+	}
+	data, err := json.Marshal(results)
+	if err != nil {
+		return []byte(fmt.Sprintf(`{"error": "failed to marshal results: %s"}`, err.Error()))
+	}
+	return []byte(fmt.Sprintf(`{"elements": %s}`, string(data)))
+}
+
+func jsonString(s string) string {
+	b, _ := json.Marshal(s)
+	return string(b)
+}

tui.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"gf-lt/models"
+	"gf-lt/tools"
 	"image"
 	_ "image/jpeg"
 	_ "image/png"
@@ -10,6 +11,7 @@ import (
 	"path"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/gdamore/tcell/v2"
 	"github.com/rivo/tview"
@@ -21,7 +23,6 @@ func isFullScreenPageActive() bool {
 }
 
 var (
-	app                *tview.Application
 	pages              *tview.Pages
 	textArea           *tview.TextArea
 	editArea           *tview.TextArea
@@ -29,6 +30,8 @@ var (
 	statusLineWidget   *tview.TextView
 	helpView           *tview.TextView
 	flex               *tview.Flex
+	bottomFlex         *tview.Flex
+	notificationWidget *tview.TextView
 	imgView            *tview.Image
 	defaultImage       = "sysprompts/llama.png"
 	indexPickWindow    *tview.InputField
@@ -36,10 +39,10 @@ var (
 	roleEditWindow     *tview.InputField
 	shellInput         *tview.InputField
 	confirmModal       *tview.Modal
+	toastTimer         *time.Timer
 	confirmPageName    = "confirm"
 	fullscreenMode     bool
 	positionVisible    bool = true
-	scrollToEndEnabled bool = true
 	// pages
 	historyPage    = "historyPage"
 	agentPage      = "agentPage"
@@ -48,7 +51,6 @@ var (
 	helpPage       = "helpPage"
 	renamePage     = "renamePage"
 	RAGPage        = "RAGPage"
-	RAGLoadedPage  = "RAGLoadedPage"
 	propsPage      = "propsPage"
 	codeBlockPage  = "codeBlockPage"
 	imgPage        = "imgPage"
@@ -67,8 +69,8 @@ var (
 [yellow]F4[white]: edit msg
 [yellow]F5[white]: toggle fullscreen for input/chat window
 [yellow]F6[white]: interrupt bot resp
-[yellow]F7[white]: copy last msg to clipboard (linux xclip)
+[yellow]F7[white]: copy last msg to clipboard (linux xclip or wl-copy)
-[yellow]F8[white]: copy n msg to clipboard (linux xclip)
+[yellow]F8[white]: copy n msg to clipboard (linux xclip or wl-copy)
 [yellow]F9[white]: table to copy from; with all code blocks
 [yellow]F10[white]: switch if LLM will respond on this message (for user to write multiple messages in a row)
 [yellow]F11[white]: import json chat file
@@ -103,6 +105,7 @@ var (
 [yellow]Alt+t[white]: toggle thinking blocks visibility (collapse/expand <think> blocks)
 [yellow]Ctrl+t[white]: toggle tool call/response visibility (collapse/expand tool calls and non-shell tool responses)
 [yellow]Alt+i[white]: show colorscheme selection popup
+[yellow]Insert[white]: paste from clipboard to the text area (use it instead shift+insert)
 
 === scrolling chat window (some keys similar to vim) ===
 [yellow]arrows up/down and j/k[white]: scroll up and down
@@ -137,12 +140,97 @@ func setShellMode(enabled bool) {
 	}()
 }
 
-func init() {
+// showToast displays a temporary notification in the bottom-right corner.
+// It auto-hides after 3 seconds.
+func showToast(title, message string) {
+	sanitize := func(s string, maxLen int) string {
+		sanitized := strings.Map(func(r rune) rune {
+			if r < 32 && r != '\t' {
+				return -1
+			}
+			return r
+		}, s)
+		if len(sanitized) > maxLen {
+			sanitized = sanitized[:maxLen-3] + "..."
+		}
+		return sanitized
+	}
+	title = sanitize(title, 50)
+	message = sanitize(message, 197)
+	if toastTimer != nil {
+		toastTimer.Stop()
+	}
+	// show blocking notification to not mess up flex
+	if fullscreenMode {
+		notification := tview.NewTextView().
+			SetTextAlign(tview.AlignCenter).
+			SetDynamicColors(true).
+			SetRegions(true).
+			SetText(fmt.Sprintf("[yellow]%s[-]\n", message)).
+			SetChangedFunc(func() {
+				app.Draw()
+			})
+		notification.SetTitleAlign(tview.AlignLeft).
+			SetBorder(true).
+			SetTitle(title)
+		// Wrap it in a full‑screen Flex to position it in the top‑right corner.
+		// Outer Flex (row) pushes content to the top; inner Flex (column) pushes to the right.
+		background := tview.NewFlex().SetDirection(tview.FlexRow).
+			AddItem(nil, 0, 1, false). // top spacer
+			AddItem(tview.NewFlex().SetDirection(tview.FlexColumn).
+				AddItem(nil, 0, 1, false).          // left spacer
+				AddItem(notification, 40, 1, true), // notification width 40
+				5, 1, false) // notification height 5
+		// Generate a unique page name (e.g., using timestamp) to allow multiple toasts.
+		pageName := fmt.Sprintf("toast-%d", time.Now().UnixNano())
+		pages.AddPage(pageName, background, true, true)
+		// Auto‑dismiss after 2 seconds, since blocking is more annoying
+		time.AfterFunc(2*time.Second, func() {
+			app.QueueUpdateDraw(func() {
+				if pages.HasPage(pageName) {
+					pages.RemovePage(pageName)
+				}
+			})
+		})
+		return
+	}
+	notificationWidget.SetTitle(title)
+	notificationWidget.SetText(fmt.Sprintf("[yellow]%s[-]", message))
+	go func() {
+		app.QueueUpdateDraw(func() {
+			flex.RemoveItem(bottomFlex)
+			flex.RemoveItem(statusLineWidget)
+			bottomFlex = tview.NewFlex().SetDirection(tview.FlexColumn).
+				AddItem(textArea, 0, 1, true).
+				AddItem(notificationWidget, 40, 1, false)
+			flex.AddItem(bottomFlex, 0, 10, true)
+			if positionVisible {
+				flex.AddItem(statusLineWidget, 0, 2, false)
+			}
+		})
+	}()
+	toastTimer = time.AfterFunc(3*time.Second, func() {
+		app.QueueUpdateDraw(func() {
+			flex.RemoveItem(bottomFlex)
+			flex.RemoveItem(statusLineWidget)
+			bottomFlex = tview.NewFlex().SetDirection(tview.FlexColumn).
+				AddItem(textArea, 0, 1, true).
+				AddItem(notificationWidget, 0, 0, false)
+			flex.AddItem(bottomFlex, 0, 10, true)
+			if positionVisible {
+				flex.AddItem(statusLineWidget, 0, 2, false)
+			}
+		})
+	})
+}
+
+func initTUI() {
 	// Start background goroutine to update model color cache
 	startModelColorUpdater()
 	tview.Styles = colorschemes["default"]
 	app = tview.NewApplication()
 	pages = tview.NewPages()
+	outputHandler = &TUIOutputHandler{tv: textView}
 	shellInput = tview.NewInputField().
 		SetLabel(fmt.Sprintf("[%s]$ ", cfg.FilePickerDir)). // dynamic prompt
 		SetFieldWidth(0).
@@ -186,7 +274,7 @@ func init() {
 			shellHistoryPos = -1
 		}
 		// Handle Tab key for @ file completion
-		if event.Key() == tcell.KeyTab {
+		if event.Key() == tcell.KeyTab && shellMode {
 			currentText := shellInput.GetText()
 			atIndex := strings.LastIndex(currentText, "@")
 			if atIndex >= 0 {
@@ -233,16 +321,48 @@ func init() {
 	textArea = tview.NewTextArea().
 		SetPlaceholder("input is multiline; press <Enter> to start the next line;\npress <Esc> to send the message.")
 	textArea.SetBorder(true).SetTitle("input")
+	textArea.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+		if event.Key() == tcell.KeyInsert {
+			text, err := readFromClipboard()
+			if err != nil {
+				logger.Error("failed to read clipboard", "error", err)
+				return event
+			}
+			maxPaste := 100000
+			if len(text) > maxPaste {
+				text = text[:maxPaste]
+				showToast("paste truncated", "pasted text exceeded 100KB limit")
+			}
+			current := textArea.GetText()
+			textArea.SetText(current+text, true)
+			return nil
+		}
+		return event
+	})
 	textView = tview.NewTextView().
 		SetDynamicColors(true).
 		SetRegions(true).
 		SetChangedFunc(func() {
+			// INFO:
+			// https://github.com/rivo/tview/wiki/Concurrency#event-handlers
+			// although already called by default per tview specs
+			// calling it explicitly makes text streaming to look more smooth
 			app.Draw()
 		})
+	notificationWidget = tview.NewTextView().
+		SetTextAlign(tview.AlignCenter).
+		SetDynamicColors(true).
+		SetRegions(true).
+		SetChangedFunc(func() {
+		})
+	notificationWidget.SetBorder(true).SetTitle("notification")
+	bottomFlex = tview.NewFlex().SetDirection(tview.FlexColumn).
+		AddItem(textArea, 0, 1, true).
+		AddItem(notificationWidget, 0, 0, false)
 	//
 	flex = tview.NewFlex().SetDirection(tview.FlexRow).
 		AddItem(textView, 0, 40, false).
-		AddItem(textArea, 0, 10, true) // Restore original height
+		AddItem(bottomFlex, 0, 10, true)
 	if positionVisible {
 		flex.AddItem(statusLineWidget, 0, 2, false)
 	}
@@ -311,10 +431,14 @@ func init() {
 	// 	y += h / 2
 	// 	return x, y, w, h
 	// })
+	notificationWidget.SetDrawFunc(func(screen tcell.Screen, x, y, w, h int) (int, int, int, int) {
+		y += h / 2
+		return x, y, w, h
+	})
 	// Initially set up flex without search bar
 	flex = tview.NewFlex().SetDirection(tview.FlexRow).
 		AddItem(textView, 0, 40, false).
-		AddItem(textArea, 0, 10, true) // Restore original height
+		AddItem(bottomFlex, 0, 10, true)
 	if positionVisible {
 		flex.AddItem(statusLineWidget, 0, 2, false)
 	}
@@ -327,9 +451,7 @@ func init() {
 			defer colorText()
 			editedMsg := editArea.GetText()
 			if editedMsg == "" {
-				if err := notifyUser("edit", "no edit provided"); err != nil {
+				showToast("edit", "no edit provided")
-					logger.Error("failed to send notification", "error", err)
-				}
 				pages.RemovePage(editMsgPage)
 				return nil
 			}
@@ -359,9 +481,7 @@ func init() {
 			case tcell.KeyEnter:
 				newRole := roleEditWindow.GetText()
 				if newRole == "" {
-					if err := notifyUser("edit", "no role provided"); err != nil {
+					showToast("edit", "no role provided")
-						logger.Error("failed to send notification", "error", err)
-					}
 					pages.RemovePage(roleEditPage)
 					return
 				}
@@ -388,9 +508,7 @@ func init() {
 			siInt, err := strconv.Atoi(si)
 			if err != nil {
 				logger.Error("failed to convert provided index", "error", err, "si", si)
-				if err := notifyUser("cancel", "no index provided, copying user input"); err != nil {
+				showToast("cancel", "no index provided, copying user input")
-					logger.Error("failed to send notification", "error", err)
-				}
 				if err := copyToClipboard(textArea.GetText()); err != nil {
 					logger.Error("failed to copy to clipboard", "error", err)
 				}
@@ -401,9 +519,7 @@ func init() {
 			if len(chatBody.Messages)-1 < selectedIndex || selectedIndex < 0 {
 				msg := "chosen index is out of bounds, will copy user input"
 				logger.Warn(msg, "index", selectedIndex)
-				if err := notifyUser("error", msg); err != nil {
+				showToast("error", msg)
-					logger.Error("failed to send notification", "error", err)
-				}
 				if err := copyToClipboard(textArea.GetText()); err != nil {
 					logger.Error("failed to copy to clipboard", "error", err)
 				}
@@ -429,9 +545,7 @@ func init() {
 				}
 				previewLen := min(30, len(msgText))
 				notification := fmt.Sprintf("msg '%s' was copied to the clipboard", msgText[:previewLen])
-				if err := notifyUser("copied", notification); err != nil {
+				showToast("copied", notification)
-					logger.Error("failed to send notification", "error", err)
-				}
 				hideIndexBar() // Hide overlay after copying
 			}
 			return nil
@@ -463,9 +577,7 @@ func init() {
 				logger.Error("failed to upsert chat", "error", err, "chat", currentChat)
 			}
 			notification := fmt.Sprintf("renamed chat to '%s'", activeChatName)
-			if err := notifyUser("renamed", notification); err != nil {
+			showToast("renamed", notification)
-				logger.Error("failed to send notification", "error", err)
-			}
 		}
 		return event
 	})
@@ -541,7 +653,7 @@ func init() {
 	updateStatusLine()
 	textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
 	colorText()
-	if scrollToEndEnabled {
+	if cfg.AutoScrollEnabled {
 		textView.ScrollToEnd()
 	}
 	// init sysmap
@@ -570,14 +682,12 @@ func init() {
 		}
 		if event.Key() == tcell.KeyRune && event.Rune() == '2' && event.Modifiers()&tcell.ModAlt != 0 {
 			// toggle auto-scrolling
-			scrollToEndEnabled = !scrollToEndEnabled
+			cfg.AutoScrollEnabled = !cfg.AutoScrollEnabled
 			status := "disabled"
-			if scrollToEndEnabled {
+			if cfg.AutoScrollEnabled {
 				status = "enabled"
 			}
-			if err := notifyUser("autoscroll", "Auto-scrolling "+status); err != nil {
+			showToast("autoscroll", "Auto-scrolling "+status)
-				logger.Error("failed to send notification", "error", err)
-			}
 			updateStatusLine()
 		}
 		// Handle Alt+7 to toggle injectRole
@@ -594,9 +704,7 @@ func init() {
 			if thinkingCollapsed {
 				status = "collapsed"
 			}
-			if err := notifyUser("thinking", "Thinking blocks "+status); err != nil {
+			showToast("thinking", "Thinking blocks "+status)
-				logger.Error("failed to send notification", "error", err)
-			}
 			return nil
 		}
 		// Handle Ctrl+T to toggle tool call/response visibility
@@ -608,9 +716,7 @@ func init() {
 			if toolCollapsed {
 				status = "collapsed"
 			}
-			if err := notifyUser("tools", "Tool calls/responses "+status); err != nil {
+			showToast("tools", "Tool calls/responses "+status)
-				logger.Error("failed to send notification", "error", err)
-			}
 			return nil
 		}
 		if event.Key() == tcell.KeyRune && event.Rune() == 'i' && event.Modifiers()&tcell.ModAlt != 0 {
@@ -630,9 +736,7 @@ func init() {
 			// Check if there are no chats for this agent
 			if len(chatList) == 0 {
 				notification := "no chats found for agent: " + cfg.AssistantRole
-				if err := notifyUser("info", notification); err != nil {
+				showToast("info", notification)
-					logger.Error("failed to send notification", "error", err)
-				}
 				return nil
 			}
 			chatMap := make(map[string]models.Chat)
@@ -647,12 +751,10 @@ func init() {
 			updateStatusLine()
 			return nil
 		}
-		if event.Key() == tcell.KeyF2 && !botRespMode {
+		if event.Key() == tcell.KeyF2 && !botRespMode.Load() {
 			// regen last msg
 			if len(chatBody.Messages) == 0 {
-				if err := notifyUser("info", "no messages to regenerate"); err != nil {
+				showToast("info", "no messages to regenerate")
-					logger.Error("failed to send notification", "error", err)
-				}
 				return nil
 			}
 			chatBody.Messages = chatBody.Messages[:len(chatBody.Messages)-1]
@@ -666,7 +768,7 @@ func init() {
 			chatRoundChan <- &models.ChatRoundReq{Role: cfg.UserRole, Regen: true}
 			return nil
 		}
-		if event.Key() == tcell.KeyF3 && !botRespMode {
+		if event.Key() == tcell.KeyF3 && !botRespMode.Load() {
 			// delete last msg
 			// check textarea text; if it ends with bot icon delete only icon:
 			text := textView.GetText(true)
@@ -678,9 +780,7 @@ func init() {
 				return nil
 			}
 			if len(chatBody.Messages) == 0 {
-				if err := notifyUser("info", "no messages to delete"); err != nil {
+				showToast("info", "no messages to delete")
-					logger.Error("failed to send notification", "error", err)
-				}
 				return nil
 			}
 			chatBody.Messages = chatBody.Messages[:len(chatBody.Messages)-1]
@@ -724,8 +824,9 @@ func init() {
 			return nil
 		}
 		if event.Key() == tcell.KeyF6 {
-			interruptResp = true
+			interruptResp.Store(true)
-			botRespMode = false
+			botRespMode.Store(false)
+			toolRunningMode.Store(false)
 			return nil
 		}
 		if event.Key() == tcell.KeyF7 {
@@ -738,9 +839,7 @@ func init() {
 			}
 			previewLen := min(30, len(msgText))
 			notification := fmt.Sprintf("msg '%s' was copied to the clipboard", msgText[:previewLen])
-			if err := notifyUser("copied", notification); err != nil {
+			showToast("copied", notification)
-				logger.Error("failed to send notification", "error", err)
-			}
 			return nil
 		}
 		if event.Key() == tcell.KeyF8 {
@@ -752,11 +851,9 @@ func init() {
 		if event.Key() == tcell.KeyF9 {
 			// table of codeblocks to copy
 			text := textView.GetText(false)
-			cb := codeBlockRE.FindAllString(text, -1)
+			cb := models.CodeBlockRE.FindAllString(text, -1)
 			if len(cb) == 0 {
-				if err := notifyUser("notify", "no code blocks in chat"); err != nil {
+				showToast("notify", "no code blocks in chat")
-					logger.Error("failed to send notification", "error", err)
-				}
 				return nil
 			}
 			table := makeCodeBlockTable(cb)
@@ -771,9 +868,7 @@ func init() {
 			// read files in chat_exports
 			filelist, err := os.ReadDir(exportDir)
 			if err != nil {
-				if err := notifyUser("failed to load exports", err.Error()); err != nil {
+				showToast("failed to load exports", err.Error())
-					logger.Error("failed to send notification", "error", err)
-				}
 				return nil
 			}
 			fli := []string{}
@@ -803,9 +898,7 @@ func init() {
 				logger.Error("failed to export chat;", "error", err, "chat_name", activeChatName)
 				return nil
 			}
-			if err := notifyUser("exported chat", "chat: "+activeChatName+" was exported"); err != nil {
+			showToast("exported chat", "chat: "+activeChatName+" was exported")
-				logger.Error("failed to send notification", "error", err)
-			}
 			return nil
 		}
 		if event.Key() == tcell.KeyCtrlP {
@@ -844,9 +937,7 @@ func init() {
 			labels, err := initSysCards()
 			if err != nil {
 				logger.Error("failed to read sys dir", "error", err)
-				if err := notifyUser("error", "failed to read: "+cfg.SysDir); err != nil {
+				showToast("error", "failed to read: "+cfg.SysDir)
-					logger.Debug("failed to notify user", "error", err)
-				}
 				return nil
 			}
 			at := makeAgentTable(labels)
@@ -859,6 +950,7 @@ func init() {
 		if event.Key() == tcell.KeyCtrlK {
 			// add message from tools
 			cfg.ToolUse = !cfg.ToolUse
+			UpdateToolCapabilities()
 			updateStatusLine()
 			return nil
 		}
@@ -870,21 +962,27 @@ func init() {
 				if err != nil {
 					logger.Error("failed to open attached image", "path", lastImg, "error", err)
 					// Fall back to showing agent image
-					loadImage()
+					if err := loadImage(); err != nil {
+						logger.Warn("failed to load agent image", "error", err)
+					}
 				} else {
 					defer file.Close()
 					img, _, err := image.Decode(file)
 					if err != nil {
 						logger.Error("failed to decode attached image", "path", lastImg, "error", err)
 						// Fall back to showing agent image
-						loadImage()
+						if err := loadImage(); err != nil {
+							logger.Warn("failed to load agent image", "error", err)
+						}
 					} else {
 						imgView.SetImage(img)
 					}
 				}
 			} else {
 				// No attached image, show agent image as before
-				loadImage()
+				if err := loadImage(); err != nil {
+					logger.Warn("failed to load agent image", "error", err)
+				}
 			}
 			pages.AddPage(imgPage, imgView, true, true)
 			return nil
@@ -896,9 +994,7 @@ func init() {
 				if err != nil {
 					msg := "failed to inference user speech; error:" + err.Error()
 					logger.Error(msg)
-					if err := notifyUser("stt error", msg); err != nil {
+					showToast("stt error", msg)
-						logger.Error("failed to notify user", "error", err)
-					}
 					return nil
 				}
 				if userSpeech != "" {
@@ -956,6 +1052,17 @@ func init() {
 			showBotRoleSelectionPopup()
 			return nil
 		}
+		// INFO: shutdown
+		if event.Key() == tcell.KeyCtrlC {
+			logger.Info("caught Ctrl+C via tcell event")
+			go func() {
+				if err := tools.PwShutDown(); err != nil {
+					logger.Error("shutdown failed", "err", err)
+				}
+				app.Stop()
+			}()
+			return nil // swallow the event
+		}
 		if event.Key() == tcell.KeyCtrlG {
 			// cfg.RAGDir is the directory with files to use with RAG
 			// rag load
@@ -967,26 +1074,20 @@ func init() {
 					// Create the RAG directory if it doesn't exist
 					if mkdirErr := os.MkdirAll(cfg.RAGDir, 0755); mkdirErr != nil {
 						logger.Error("failed to create RAG directory", "dir", cfg.RAGDir, "error", mkdirErr)
-						if notifyerr := notifyUser("failed to create RAG directory", mkdirErr.Error()); notifyerr != nil {
+						showToast("failed to create RAG directory", mkdirErr.Error())
-							logger.Error("failed to send notification", "error", notifyerr)
-						}
 						return nil
 					}
 					// Now try to read the directory again after creating it
 					files, err = os.ReadDir(cfg.RAGDir)
 					if err != nil {
 						logger.Error("failed to read dir after creating it", "dir", cfg.RAGDir, "error", err)
-						if notifyerr := notifyUser("failed to read RAG directory", err.Error()); notifyerr != nil {
+						showToast("failed to read RAG directory", err.Error())
-							logger.Error("failed to send notification", "error", notifyerr)
-						}
 						return nil
 					}
 				} else {
 					// Other error (permissions, etc.)
 					logger.Error("failed to read dir", "dir", cfg.RAGDir, "error", err)
-					if notifyerr := notifyUser("failed to open RAG files dir", err.Error()); notifyerr != nil {
+					showToast("failed to open RAG files dir", err.Error())
-						logger.Error("failed to send notification", "error", notifyerr)
-					}
 					return nil
 				}
 			}
@@ -1016,13 +1117,11 @@ func init() {
 		if event.Key() == tcell.KeyRune && event.Modifiers() == tcell.ModAlt && event.Rune() == '9' {
 			// Warm up (load) the currently selected model
 			go warmUpModel()
-			if err := notifyUser("model warmup", "loading model: "+chatBody.Model); err != nil {
+			showToast("model warmup", "loading model: "+chatBody.Model)
-				logger.Debug("failed to notify user", "error", err)
-			}
 			return nil
 		}
 		// cannot send msg in editMode or botRespMode
-		if event.Key() == tcell.KeyEscape && !editMode && !botRespMode {
+		if event.Key() == tcell.KeyEscape && !editMode && !botRespMode.Load() {
 			if shellMode {
 				cmdText := shellInput.GetText()
 				if cmdText != "" {
@@ -1049,7 +1148,7 @@ func init() {
 				}
 				// check if plain text
 				if !injectRole {
-					matches := roleRE.FindStringSubmatch(msgText)
+					matches := models.RoleRE.FindStringSubmatch(msgText)
 					if len(matches) > 1 {
 						persona = matches[1]
 						msgText = strings.TrimLeft(msgText[len(matches[0]):], " ")
@@ -1059,7 +1158,7 @@ func init() {
 				fmt.Fprintf(textView, "%s[-:-:b](%d) <%s>: [-:-:-]\n%s\n",
 					nl, len(chatBody.Messages), persona, msgText)
 				textArea.SetText("", true)
-				if scrollToEndEnabled {
+				if cfg.AutoScrollEnabled {
 					textView.ScrollToEnd()
 				}
 				colorText()
@@ -1071,14 +1170,27 @@ func init() {
 			chatRoundChan <- &models.ChatRoundReq{Role: persona, UserMsg: msgText}
 			return nil
 		}
+		if event.Key() == tcell.KeyTab && !shellMode {
+			currentF := app.GetFocus()
+			if currentF == textArea {
+				currentText := textArea.GetText()
+				atIndex := strings.LastIndex(currentText, "@")
+				if atIndex >= 0 {
+					filter := currentText[atIndex+1:]
+					showTextAreaFileCompletionPopup(filter)
+				}
+			}
+			return nil
+		}
 		if event.Key() == tcell.KeyPgUp || event.Key() == tcell.KeyPgDn {
 			currentF := app.GetFocus()
 			app.SetFocus(focusSwitcher[currentF])
 			return nil
 		}
-		if isASCII(string(event.Rune())) && !botRespMode {
+		if isASCII(string(event.Rune())) && !botRespMode.Load() {
 			return event
 		}
 		return event
 	})
+	go updateModelLists()
 }