Add visual separator after startup info in ScrollList

Added a horizontal rule (────) with blank lines above and below to
visually separate the startup info from the conversation history.

The separator uses theme.Border color and spans 80 characters, providing
a clear visual break between startup messages and the chat content.

This makes it easier to distinguish where the conversation starts when
scrolling back through history.

.gitignore

@@ -3,6 +3,7 @@
 .env
 .kit/*
 !.kit/extensions/
+!.kit/prompts/
 aidocs/
 *.log
 /kit

.kit/prompts/acp-smoke-test.md

@@ -0,0 +1,37 @@
+---
+description: Run ACP smoke test against opencode/kimi-k2.5 to verify JSON-RPC stdio works
+---
+
+Run the ACP smoke test to verify the Kit ACP server works correctly over JSON-RPC stdio with streaming responses.
+
+## Steps
+
+1. Build the kit binary:
+   ```bash
+   go build -o output/kit ./cmd/kit
+   ```
+
+2. Run the smoke test Python script against opencode/kimi-k2.5:
+   ```bash
+   python3 scripts/acp_smoke_test.py
+   ```
+
+3. Verify the output shows:
+   - `session/new` returns a valid `sessionId`
+   - `session/prompt` streams `agent_thought_chunk` notifications (reasoning)
+   - `session/prompt` streams `agent_message_chunk` notifications (response)
+   - Final result has `stopReason: "end_turn"`
+   - `✓ SMOKE TEST PASSED` at the end
+
+4. If the test fails, check:
+   - `output/kit` binary exists and is executable
+   - `OPENCODE_API_KEY` or `OPENCODE_ZEN_API_KEY` environment variable is set
+   - `scripts/acp_smoke_test.py` exists
+   - The model `opencode/kimi-k2.5` is available (`kit models opencode | grep kimi-k2.5`)
+
+5. For testing with a different model, edit the script or set the `MODEL` variable:
+   ```bash
+   MODEL=anthropic/claude-sonnet-4-5 python3 scripts/acp_smoke_test.py
+   ```
+
+The smoke test exercises the full ACP protocol: session lifecycle, streaming notifications, and tool-free prompt completion.

.kit/prompts/commit-push.md

@@ -0,0 +1,30 @@
+---
+description: Stage, commit, and push changes with an auto-generated conventional commit message
+---
+
+Review the current git status and diff, then stage all changes, write a concise conventional commit message, commit, and push to the current branch.
+
+## Steps
+
+1. **Check status**: `git status` — understand what has changed
+2. **Review the diff**: `git diff` (and `git diff --cached` if anything is already staged) — read the actual changes
+3. **Stage everything**: `git add -A`
+4. **Craft the commit message** following Conventional Commits:
+   - Format: `<type>(<scope>): <short summary>`
+   - Types: `feat`, `fix`, `refactor`, `chore`, `docs`, `test`, `perf`, `build`
+   - Scope: optional, the subsystem affected (e.g. `ui`, `cmd`, `config`)
+   - Summary: imperative mood, lowercase, no trailing period, ≤72 chars
+   - Body: add a blank line then bullet points for non-trivial changes
+   - Do **not** include "Generated by" or similar noise
+5. **Commit**: `git commit -m "<message>"`
+6. **Push**: `git push`
+
+## Guidelines
+
+- Read the actual diff — do not guess from filenames alone
+- Prefer one well-scoped commit; do not split unless the changes are clearly unrelated
+- Keep the subject line under 72 characters
+- Use the body to explain *what* and *why*, not *how*
+- If there is nothing to commit, say so and stop
+
+$@

.kit/prompts/new-prompt.md

@@ -0,0 +1,47 @@
+---
+description: Scaffold a new prompt template in .kit/prompts/
+---
+
+Create a new kit prompt template. The user wants a prompt that does: $@
+
+## What a prompt template is
+
+A prompt template is a `.md` file in `.kit/prompts/` (project-local) or `~/.kit/prompts/` (global).
+It becomes a `/slug` slash command in the kit input box — typed as `/filename` with optional arguments.
+
+## File format
+
+```
+---
+description: One-line description shown in autocomplete
+---
+
+Body text of the prompt. Use $@ for all user-supplied arguments,
+$1 $2 etc. for positional arguments.
+```
+
+- **Filename** → slug: `commit-push.md` becomes `/commit-push`
+- **Frontmatter**: only `description` is recognised; keep it under ~80 chars
+- **Body**: plain markdown; the full text is submitted as the user's message when the template fires
+- **Arguments**: `$@` expands to everything the user typed after the slash command name;
+  `$1`, `$2` for individual positional args; omit entirely if no arguments are needed
+
+## Steps
+
+1. **Understand the workflow** the user described in `$@` — ask a clarifying question if the intent is ambiguous
+2. **Choose a filename**: short, lowercase, hyphen-separated, descriptive (e.g. `code-review.md`)
+3. **Write the description**: one sentence, imperative, fits in autocomplete
+4. **Draft the body**:
+   - Open with a single sentence stating the goal
+   - Use `## Steps` for multi-step workflows; use plain prose for simple prompts
+   - Be specific: name commands, flags, and file paths where relevant
+   - End with `$@` on its own line if the user might want to pass context or a hint; omit if the prompt is self-contained
+5. **Write the file** to `.kit/prompts/<slug>.md`
+6. **Confirm** by showing the final file content and the slash command that activates it
+
+## Guidelines
+
+- Keep prompts action-oriented — they should tell kit *what to do*, not just *what to think about*
+- Prefer concrete steps over vague instructions
+- A prompt that does one thing well beats one that tries to cover every edge case
+- If the workflow already exists as a prompt, suggest extending it instead of duplicating

.kit/prompts/release-tagger.md

@@ -0,0 +1,70 @@
+---
+description: Semantic version tagging workflow - analyzes commits and tags releases
+---
+
+# Release Tagging Workflow
+
+Tag a new version of this Go project following semantic versioning.
+
+## Steps
+
+1. **Fetch remote tags**: `git fetch --tags origin`
+
+2. **Find latest version**: `git tag -l | sort -V | tail -5` to see recent tags
+
+3. **Analyze changes since last tag**:
+   - `git log <latest-tag>..HEAD --oneline` - list commits
+   - `git diff <latest-tag>..HEAD --stat` - see file stats
+   - `git diff <latest-tag>..HEAD --name-only` - see changed files
+
+4. **Determine version bump** (Semantic Versioning):
+   - **MAJOR (X.0.0)**: Breaking API changes, incompatible modifications
+   - **MINOR (0.X.0)**: New features, backward-compatible additions
+   - **PATCH (0.0.X)**: Bug fixes, backward-compatible fixes
+   
+   Look for indicators:
+   - `feat:` or `feature:` commits → MINOR
+   - `fix:` or `bugfix:` commits → PATCH
+   - `breaking:` or `BREAKING CHANGE:` → MAJOR
+   - Breaking API changes in `pkg/` or public interfaces → MAJOR
+   - New commands, flags, or features → MINOR
+   - Documentation-only changes → PATCH (or skip)
+
+5. **Calculate new version**: Increment appropriate segment, reset lower segments to 0
+
+6. **Draft tag message**:
+   - Summarize key changes from commits
+   - Group by type (Features, Fixes, Breaking Changes)
+   - Keep concise but informative
+
+7. **Create annotated tag**: `git tag -a vX.Y.Z -m "vX.Y.Z - <summary>\n\n<detailed list>"`
+
+8. **Push tag**: `git push origin vX.Y.Z`
+
+## Guidelines
+
+- Always fetch remote tags first to avoid conflicts
+- Use annotated tags (`-a`) with descriptive messages
+- Follow semver strictly - when in doubt, prefer conservative bump (patch over minor)
+- For Go projects, changes to `pkg/` or exported APIs warrant careful version consideration
+- If no changes since last tag, suggest skipping the release
+- Include commit summaries in the tag message body
+
+## Example Tag Message Format
+
+```
+v0.30.1 - Bug fixes for model handling and UI improvements
+
+Fixes:
+- Properly handle think tags from Qwen/DeepSeek models
+- Handle custom provider model persistence and bare model names
+
+Improvements:
+- UI style refactoring and cleanup
+```
+
+Wait for the user to confirm the version and message before executing tag commands.
+
+---
+
+$@

AGENTS.md

@@ -1,22 +1,3 @@
-<!-- OPENSPEC:START -->
-# OpenSpec Instructions
-
-These instructions are for AI assistants working in this project.
-
-Always open `@/openspec/AGENTS.md` when the request:
-- Mentions planning or proposals (words like proposal, spec, change, plan)
-- Introduces new capabilities, breaking changes, architecture shifts, or big performance/security work
-- Sounds ambiguous and you need the authoritative spec before coding
-
-Use `@/openspec/AGENTS.md` to learn:
-- How to create and apply change proposals
-- Spec format and conventions
-- Project structure and guidelines
-
-Keep this managed block so 'openspec update' can refresh the instructions.
-
-<!-- OPENSPEC:END -->
-
 # KIT Agent Guidelines
 
 ## Build/Test Commands
@@ -42,6 +23,33 @@ Keep this managed block so 'openspec update' can refresh the instructions.
 - **Extension system** (`internal/extensions/`): Yaegi-interpreted Go, 13 lifecycle events, custom tools/commands/widgets/overlays/editor interceptors
 - **TUI** (`internal/ui/`): Bubble Tea v2 parent-child model (`AppModel` → `InputComponent`, `StreamComponent`, etc.)
 - **Decoupling pattern**: `cmd/root.go` has converter functions (e.g. `widgetProviderForUI()`) that bridge `internal/extensions/` types to `internal/ui/` types — the UI never imports extensions directly
+- **Public SDK** (`pkg/kit/`): The public-facing Go SDK for embedding Kit as a library. See rules below.
+
+## Public SDK (`pkg/kit/`) Rules
+
+`pkg/kit/` is the **public API surface** consumed by external Go developers. All exported symbols, types, function names, and godoc comments in this package are part of the SDK contract.
+
+### No Dependency Name Leakage
+Internal dependency names (e.g. `charm.land/fantasy`, library-specific jargon) **must not** appear in:
+- **Exported function/method names** — use generic terms (`LLM`, `Provider`, `Message`) instead of library names
+- **Exported type names** — type aliases should use domain names (e.g. `LLMMessage`, not `FantasyMessage`)
+- **Godoc comments** on exported symbols — these are visible in `go doc` output and pkg.go.dev
+- **Struct field names and tags** on exported types
+
+Using dependency types directly in **function bodies** (private implementation) is fine — that's invisible to SDK consumers.
+
+### Naming Conventions for SDK Symbols
+- Type aliases re-exporting dependency types: use `LLM*` prefix (e.g. `LLMMessage`, `LLMUsage`, `LLMResponse`)
+- Conversion helpers: use `ConvertToLLM*` / `ConvertFromLLM*` (not the dependency name)
+- Provider queries: use `GetLLMProviders` (not `GetFantasyProviders`)
+- When wrapping internal methods, the `pkg/kit/` name should be dependency-agnostic even if the `internal/` method still uses the old name
+
+### Deprecation Pattern
+When renaming a public SDK symbol, keep the old name as a deprecated wrapper for one release cycle:
+```go
+// Deprecated: Use NewName instead.
+func OldName() { return NewName() }
+```
 
 ## Key Patterns
 
@@ -92,3 +100,21 @@ Positional args are the prompt. `@file` args attach file content. Key flags: `--
 - Never guess or manually search the filesystem for external projects
 - Example: `btca ask -r https://github.com/user/repo -q "How does X work?"`
 - See `.agents/skills/btca-cli/SKILL.md` for full btca usage
+
+## BTCA Configured Resources
+The following external repositories are configured in `btca.config.jsonc` for research:
+
+- bubbletea
+- lipgloss
+- bubbles
+- glamour
+- fantasy
+- catwalk
+- crush
+- pi
+- iteratr
+- yaegi
+- acp-go-sdk
+- opencode
+- herald
+- herald-md

AUTOSCROLL_FIX_SUMMARY.md

@@ -0,0 +1,80 @@
+# Autoscroll Fix - Final Summary
+
+## Root Cause
+
+The autoscroll was failing for streaming assistant messages due to a bug in how `GotoBottom()` calculated item heights.
+
+### The Problem
+
+1. **Reasoning blocks** (`StreamingMessageItem` with `role="reasoning"`) are **never cached** because they have live duration counters that update every render
+2. The `Height()` method returns `0` when `cachedRender == ""`
+3. `GotoBottom()` was calling:
+   ```go
+   itemHeight := item.Height()  // Returns 0 for reasoning
+   if itemHeight == 0 {
+       item.Render(s.width)  // Renders but doesn't cache (reasoning)
+       itemHeight = item.Height()  // Still returns 0!
+   }
+   ```
+4. This caused incorrect scroll position calculations, especially during reasoning → assistant transitions
+
+## The Solution
+
+Changed `GotoBottom()` and `AtBottom()` to calculate height **directly from the rendered string** instead of relying on the cached height:
+
+```go
+// OLD: item.Height() which checks cached render
+itemHeight := item.Height()
+if itemHeight == 0 {
+    item.Render(s.width)
+    itemHeight = item.Height()  // Still might be 0!
+}
+
+// NEW: Calculate from rendered string directly
+rendered := item.Render(s.width)
+itemHeight := strings.Count(rendered, "\n") + 1
+```
+
+This works for **all** items regardless of whether they cache their render or not.
+
+## Files Changed
+
+### `internal/ui/scrolllist.go`
+- **`GotoBottom()`**: Calculate height from rendered string (2 loops)
+- **`AtBottom()`**: Calculate height from rendered string (1 loop)
+
+### `internal/ui/model.go`
+- **`appendStreamingChunk()`**: For existing messages, call `GotoBottom()` directly (iteratr pattern)
+- **`refreshContent()`**: Simplified to only call `SetItems()` (removed redundant `GotoBottom()`)
+- **Bash streaming handler**: Removed redundant `GotoBottom()` after `refreshContent()`
+
+## Testing Results
+
+✅ **Test prompt**: "explore this repo"
+
+**Before fix**:
+- Autoscroll stopped after reasoning block completed
+- Viewport stuck showing end of reasoning ("Thought for 203ms")
+- Assistant response streamed off-screen below
+
+**After fix**:
+- Autoscroll works throughout reasoning block
+- Autoscroll continues during reasoning → assistant transition  
+- Viewport stays at bottom showing latest assistant content
+- Final position shows end of response (build commands section)
+
+## Behavior Verified
+
+1. ✅ Streaming text auto-scrolls to bottom
+2. ✅ Works across reasoning → assistant transition
+3. ✅ Manual scroll up (PgUp) disables autoscroll
+4. ✅ Scroll to bottom (Alt+End) re-enables autoscroll
+5. ✅ Accurate positioning with no offset errors
+
+## Performance Note
+
+The fix calls `Render()` on all items during `GotoBottom()` calculations. This is acceptable because:
+- `Render()` is already optimized with caching for non-reasoning items
+- `GotoBottom()` is only called during content updates (not every frame)
+- Reasoning blocks need to render anyway for live duration updates
+- This matches iteratr's approach of ensuring items are rendered before height calculations

README.md

@@ -209,7 +209,7 @@ kit auth status              # Check authentication status
 
 # Model database
 kit models [provider]        # List available models (optionally filter by provider)
-kit models --all             # Show all providers (not just Fantasy-compatible)
+kit models --all             # Show all providers (not just LLM-compatible)
 kit update-models [source]   # Update model database (from models.dev, URL, file, or 'embedded')
 
 # Extension management
@@ -502,7 +502,7 @@ func main() {
     if err != nil {
         log.Fatal(err)
     }
-    defer host.Close()
+    defer func() { _ = host.Close() }()
     
     // Send a prompt
     response, err := host.Prompt(ctx, "What is 2+2?")
@@ -726,7 +726,7 @@ Use `custom/custom` when pointing Kit at any OpenAI-compatible endpoint with `--
 kit --provider-url "http://localhost:8080/v1" "Hello"
 ```
 
-This automatically defaults to `custom/custom` without needing to specify a model. The custom provider routes through fantasy's `openaicompat` provider and supports:
+This automatically defaults to `custom/custom` without needing to specify a model. The custom provider routes through the `openaicompat` provider and supports:
 
 - Zero cost tracking (input/output = 0)
 - 262K context window, 65K output limit

btca.config.jsonc

@@ -82,6 +82,12 @@
       "name": "herald",
       "url": "https://github.com/indaco/herald",
       "branch": "main"
+    },
+    {
+      "type": "git",
+      "name": "herald-md",
+      "url": "https://github.com/indaco/herald-md",
+      "branch": "main"
     }
   ],
   "model": "claude-haiku-4-5",

cmd/acp.go

@@ -11,6 +11,7 @@ import (
 	"os/signal"
 	"syscall"
 
+	"github.com/charmbracelet/log"
 	acp "github.com/coder/acp-go-sdk"
 
 	"github.com/mark3labs/kit/internal/acpserver"
@@ -54,6 +55,8 @@ func runACP(cmd *cobra.Command, _ []string) error {
 		conn.SetLogger(slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{
 			Level: slog.LevelDebug,
 		})))
+		// Also set charmbracelet/log level for acpserver package logging
+		log.SetLevel(log.DebugLevel)
 	}
 
 	// Wait for either the client to disconnect or a signal.

cmd/models.go

@@ -55,7 +55,7 @@ func printAllProviders(showAll bool) error {
 	if showAll {
 		providerIDs = kit.GetSupportedProviders()
 	} else {
-		providerIDs = kit.GetFantasyProviders()
+		providerIDs = kit.GetLLMProviders()
 	}
 	sort.Strings(providerIDs)
 

cmd/root.go

@@ -10,7 +10,6 @@ import (
 	"strings"
 
 	tea "charm.land/bubbletea/v2"
-	"charm.land/fantasy"
 	"charm.land/lipgloss/v2"
 	"github.com/mark3labs/kit/internal/app"
 	"github.com/mark3labs/kit/internal/auth"
@@ -38,7 +37,6 @@ var (
 	noExitFlag       bool
 	maxSteps         int
 	streamFlag       bool // Enable streaming output
-	compactMode      bool // Enable compact output mode
 	autoCompactFlag  bool // Enable auto-compaction near context limit
 
 	// Session management
@@ -280,8 +278,6 @@ func init() {
 		IntVar(&maxSteps, "max-steps", 0, "maximum number of agent steps (0 for unlimited)")
 	rootCmd.PersistentFlags().
 		BoolVar(&streamFlag, "stream", true, "enable streaming output for faster response display")
-	rootCmd.PersistentFlags().
-		BoolVar(&compactMode, "compact", false, "enable compact output mode without fancy styling")
 	rootCmd.PersistentFlags().
 		BoolVar(&autoCompactFlag, "auto-compact", false, "auto-compact conversation when near context limit")
 	rootCmd.PersistentFlags().
@@ -325,7 +321,6 @@ func init() {
 	_ = viper.BindPFlag("debug", rootCmd.PersistentFlags().Lookup("debug"))
 	_ = viper.BindPFlag("max-steps", rootCmd.PersistentFlags().Lookup("max-steps"))
 	_ = viper.BindPFlag("stream", rootCmd.PersistentFlags().Lookup("stream"))
-	_ = viper.BindPFlag("compact", rootCmd.PersistentFlags().Lookup("compact"))
 	_ = viper.BindPFlag("auto-compact", rootCmd.PersistentFlags().Lookup("auto-compact"))
 
 	_ = viper.BindPFlag("provider-url", rootCmd.PersistentFlags().Lookup("provider-url"))
@@ -415,7 +410,7 @@ func runKit(ctx context.Context) error {
 // normalised to start with "/" so they integrate with the slash-command
 // autocomplete and dispatch pipeline.
 func extensionCommandsForUI(k *kit.Kit) []ui.ExtensionCommand {
-	defs := k.ExtensionCommands()
+	defs := k.Extensions().Commands()
 	if len(defs) == 0 {
 		return nil
 	}
@@ -429,12 +424,12 @@ func extensionCommandsForUI(k *kit.Kit) []ui.ExtensionCommand {
 			Name:        name,
 			Description: d.Description,
 			Execute: func(args string) (string, error) {
-				return d.Execute(args, k.GetExtensionContext())
+				return d.Execute(args, k.Extensions().GetContext())
 			},
 		}
 		if d.Complete != nil {
 			ec.Complete = func(prefix string) []string {
-				return d.Complete(prefix, k.GetExtensionContext())
+				return d.Complete(prefix, k.Extensions().GetContext())
 			}
 		}
 		cmds = append(cmds, ec)
@@ -446,11 +441,11 @@ func extensionCommandsForUI(k *kit.Kit) []ui.ExtensionCommand {
 // ui.WidgetData for the given placement. Returns nil if extensions are
 // disabled, which is safe — the UI treats a nil GetWidgets as "no widgets".
 func widgetProviderForUI(k *kit.Kit) func(string) []ui.WidgetData {
-	if !k.HasExtensions() {
+	if !k.Extensions().HasExtensions() {
 		return nil
 	}
 	return func(placement string) []ui.WidgetData {
-		configs := k.GetExtensionWidgets(extensions.WidgetPlacement(placement))
+		configs := k.Extensions().GetWidgets(extensions.WidgetPlacement(placement))
 		if len(configs) == 0 {
 			return nil
 		}
@@ -467,25 +462,34 @@ func widgetProviderForUI(k *kit.Kit) func(string) []ui.WidgetData {
 	}
 }
 
+// headerFooterProviderForUI returns a provider func that maps an
+// extensions.HeaderFooterConfig getter into the ui.WidgetData shape
+// expected by AppModel. The getter argument selects header vs footer.
+func headerFooterProviderForUI(k *kit.Kit, getter func() *extensions.HeaderFooterConfig) func() *ui.WidgetData {
+	if !k.Extensions().HasExtensions() {
+		return nil
+	}
+	return func() *ui.WidgetData {
+		cfg := getter()
+		if cfg == nil {
+			return nil
+		}
+		return &ui.WidgetData{
+			Text:        cfg.Content.Text,
+			Markdown:    cfg.Content.Markdown,
+			BorderColor: cfg.Style.BorderColor,
+			NoBorder:    cfg.Style.NoBorder,
+		}
+	}
+}
+
 // headerProviderForUI returns a function that converts the extension header
 // to a *ui.WidgetData for the TUI. Returns nil if extensions are disabled,
 // which is safe — the UI treats a nil GetHeader as "no header".
 func headerProviderForUI(k *kit.Kit) func() *ui.WidgetData {
-	if !k.HasExtensions() {
-		return nil
-	}
-	return func() *ui.WidgetData {
-		config := k.GetExtensionHeader()
-		if config == nil {
-			return nil
-		}
-		return &ui.WidgetData{
-			Text:        config.Content.Text,
-			Markdown:    config.Content.Markdown,
-			BorderColor: config.Style.BorderColor,
-			NoBorder:    config.Style.NoBorder,
-		}
-	}
+	return headerFooterProviderForUI(k, func() *extensions.HeaderFooterConfig {
+		return k.Extensions().GetHeader()
+	})
 }
 
 // toolRendererProviderForUI returns a function that converts extension tool
@@ -493,11 +497,11 @@ func headerProviderForUI(k *kit.Kit) func() *ui.WidgetData {
 // disabled, which is safe — the UI treats a nil GetToolRenderer as "no
 // custom renderers".
 func toolRendererProviderForUI(k *kit.Kit) func(string) *ui.ToolRendererData {
-	if !k.HasExtensions() {
+	if !k.Extensions().HasExtensions() {
 		return nil
 	}
 	return func(toolName string) *ui.ToolRendererData {
-		config := k.GetExtensionToolRenderer(toolName)
+		config := k.Extensions().GetToolRenderer(toolName)
 		if config == nil {
 			return nil
 		}
@@ -517,11 +521,11 @@ func toolRendererProviderForUI(k *kit.Kit) func(string) *ui.ToolRendererData {
 // Returns nil if extensions are disabled, which is safe — the UI treats a
 // nil GetEditorInterceptor as "no interceptor".
 func editorInterceptorProviderForUI(k *kit.Kit) func() *ui.EditorInterceptor {
-	if !k.HasExtensions() {
+	if !k.Extensions().HasExtensions() {
 		return nil
 	}
 	return func() *ui.EditorInterceptor {
-		config := k.GetExtensionEditor()
+		config := k.Extensions().GetEditor()
 		if config == nil {
 			return nil
 		}
@@ -555,11 +559,11 @@ func editorInterceptorProviderForUI(k *kit.Kit) func() *ui.EditorInterceptor {
 // visibility overrides to a *ui.UIVisibility for the TUI. Returns nil if
 // extensions are disabled — the UI treats nil as "show everything".
 func uiVisibilityProviderForUI(k *kit.Kit) func() *ui.UIVisibility {
-	if !k.HasExtensions() {
+	if !k.Extensions().HasExtensions() {
 		return nil
 	}
 	return func() *ui.UIVisibility {
-		v := k.GetExtensionUIVisibility()
+		v := k.Extensions().GetUIVisibility()
 		if v == nil {
 			return nil
 		}
@@ -576,21 +580,9 @@ func uiVisibilityProviderForUI(k *kit.Kit) func() *ui.UIVisibility {
 // to a *ui.WidgetData for the TUI. Returns nil if extensions are disabled,
 // which is safe — the UI treats a nil GetFooter as "no footer".
 func footerProviderForUI(k *kit.Kit) func() *ui.WidgetData {
-	if !k.HasExtensions() {
-		return nil
-	}
-	return func() *ui.WidgetData {
-		config := k.GetExtensionFooter()
-		if config == nil {
-			return nil
-		}
-		return &ui.WidgetData{
-			Text:        config.Content.Text,
-			Markdown:    config.Content.Markdown,
-			BorderColor: config.Style.BorderColor,
-			NoBorder:    config.Style.NoBorder,
-		}
-	}
+	return headerFooterProviderForUI(k, func() *extensions.HeaderFooterConfig {
+		return k.Extensions().GetFooter()
+	})
 }
 
 // statusBarProviderForUI returns a function that fetches extension status bar
@@ -598,11 +590,11 @@ func footerProviderForUI(k *kit.Kit) func() *ui.WidgetData {
 // if extensions are disabled, which is safe — the TUI treats a nil
 // GetStatusBarEntries as "no extension entries".
 func statusBarProviderForUI(k *kit.Kit) func() []ui.StatusBarEntryData {
-	if !k.HasExtensions() {
+	if !k.Extensions().HasExtensions() {
 		return nil
 	}
 	return func() []ui.StatusBarEntryData {
-		entries := k.GetExtensionStatusEntries()
+		entries := k.Extensions().GetStatusEntries()
 		if len(entries) == 0 {
 			return nil
 		}
@@ -622,30 +614,36 @@ func statusBarProviderForUI(k *kit.Kit) func() []ui.StatusBarEntryData {
 // and returns (cancelled, reason). Returns nil if extensions are disabled —
 // the UI treats nil as "no hook".
 func beforeForkProviderForUI(k *kit.Kit) func(string, bool, string) (bool, string) {
-	if !k.HasExtensions() {
+	if !k.Extensions().HasExtensions() {
 		return nil
 	}
-	return k.EmitBeforeFork
+	return func(targetID string, isUserMsg bool, userText string) (bool, string) {
+		return k.Extensions().EmitBeforeFork(targetID, isUserMsg, userText)
+	}
 }
 
 // beforeSessionSwitchProviderForUI returns a callback that emits a
 // BeforeSessionSwitch event and returns (cancelled, reason). Returns nil
 // if extensions are disabled — the UI treats nil as "no hook".
 func beforeSessionSwitchProviderForUI(k *kit.Kit) func(string) (bool, string) {
-	if !k.HasExtensions() {
+	if !k.Extensions().HasExtensions() {
 		return nil
 	}
-	return k.EmitBeforeSessionSwitch
+	return func(switchReason string) (bool, string) {
+		return k.Extensions().EmitBeforeSessionSwitch(switchReason)
+	}
 }
 
 // globalShortcutsProviderForUI returns a callback that queries the extension
 // runner for registered keyboard shortcuts. Returns nil if extensions are
 // disabled — the UI treats nil as "no shortcuts".
 func globalShortcutsProviderForUI(k *kit.Kit) func() map[string]func() {
-	if !k.HasExtensions() {
+	if !k.Extensions().HasExtensions() {
 		return nil
 	}
-	return k.GetExtensionShortcuts
+	return func() map[string]func() {
+		return k.Extensions().GetShortcuts()
+	}
 }
 
 func runNormalMode(ctx context.Context) error {
@@ -677,9 +675,15 @@ func runNormalMode(ctx context.Context) error {
 	// Restore persisted model preference when no explicit --model flag or
 	// config file model is set. Precedence: CLI flag > config file > saved
 	// preference > built-in default. This mirrors how themes are persisted.
+	// Skip custom/* models unless --provider-url is also provided, since the
+	// custom provider requires a URL that was only valid for the previous session.
 	if !modelFlagChanged && !viper.InConfig("model") {
 		if pref := ui.LoadModelPreference(); pref != "" {
-			viper.Set("model", pref)
+			if strings.HasPrefix(pref, "custom/") && viper.GetString("provider-url") == "" {
+				// Don't restore custom models without a provider URL
+			} else {
+				viper.Set("model", pref)
+			}
 		}
 	}
 
@@ -700,6 +704,15 @@ func runNormalMode(ctx context.Context) error {
 		viper.Set("model", "custom/custom")
 	}
 
+	// When --provider-url is set with an explicit --model that lacks a provider
+	// prefix (no "/"), auto-prefix with "custom/" for OpenAI-compatible endpoints.
+	if viper.GetString("provider-url") != "" && modelFlagChanged {
+		model := viper.GetString("model")
+		if model != "" && !strings.Contains(model, "/") {
+			viper.Set("model", "custom/"+model)
+		}
+	}
+
 	// Load MCP configuration.
 	mcpConfig, err := config.LoadAndValidateConfig()
 	if err != nil {
@@ -710,7 +723,7 @@ func runNormalMode(ctx context.Context) error {
 	var spinnerFunc kit.SpinnerFunc
 	if !quietFlag {
 		spinnerFunc = func(fn func() error) error {
-			tempCli, tempErr := ui.NewCLI(viper.GetBool("debug"), viper.GetBool("compact"))
+			tempCli, tempErr := ui.NewCLI(viper.GetBool("debug"))
 			if tempErr == nil {
 				return tempCli.ShowSpinner(fn)
 			}
@@ -774,9 +787,9 @@ func runNormalMode(ctx context.Context) error {
 
 	// Load existing messages from resumed/continued sessions.
 	treeSession := kitInstance.GetTreeSession()
-	var messages []fantasy.Message
+	var messages []kit.LLMMessage
 	if treeSession != nil {
-		messages = treeSession.GetFantasyMessages()
+		messages = treeSession.GetLLMMessages()
 	}
 
 	// Create the app.App instance.
@@ -803,9 +816,9 @@ func runNormalMode(ctx context.Context) error {
 	var startupExtensionMessages []string
 
 	// Set up extension context and emit SessionStart.
-	if kitInstance.HasExtensions() {
+	if kitInstance.Extensions().HasExtensions() {
 		cwd, _ := os.Getwd()
-		kitInstance.SetExtensionContext(extensions.Context{
+		kitInstance.Extensions().SetContext(extensions.Context{
 			CWD:         cwd,
 			Model:       modelName,
 			Interactive: positionalPrompt == "",
@@ -824,28 +837,28 @@ func runNormalMode(ctx context.Context) error {
 			CancelAndSend: func(text string) { appInstance.InterruptAndSend(text) },
 			Exit:          func() { appInstance.QuitFromExtension() },
 			SetWidget: func(config extensions.WidgetConfig) {
-				kitInstance.SetExtensionWidget(config)
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().SetWidget(config)
+				go appInstance.NotifyWidgetUpdate()
 			},
 			RemoveWidget: func(id string) {
-				kitInstance.RemoveExtensionWidget(id)
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().RemoveWidget(id)
+				go appInstance.NotifyWidgetUpdate()
 			},
 			SetHeader: func(config extensions.HeaderFooterConfig) {
-				kitInstance.SetExtensionHeader(config)
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().SetHeader(config)
+				go appInstance.NotifyWidgetUpdate()
 			},
 			RemoveHeader: func() {
-				kitInstance.RemoveExtensionHeader()
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().RemoveHeader()
+				go appInstance.NotifyWidgetUpdate()
 			},
 			SetFooter: func(config extensions.HeaderFooterConfig) {
-				kitInstance.SetExtensionFooter(config)
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().SetFooter(config)
+				go appInstance.NotifyWidgetUpdate()
 			},
 			RemoveFooter: func() {
-				kitInstance.RemoveExtensionFooter()
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().RemoveFooter()
+				go appInstance.NotifyWidgetUpdate()
 			},
 			PromptSelect: func(config extensions.PromptSelectConfig) extensions.PromptSelectResult {
 				ch := make(chan app.PromptResponse, 1)
@@ -895,8 +908,8 @@ func runNormalMode(ctx context.Context) error {
 				return extensions.PromptInputResult{Value: resp.Value}
 			},
 			SetUIVisibility: func(v extensions.UIVisibility) {
-				kitInstance.SetExtensionUIVisibility(v)
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().SetUIVisibility(v)
+				go appInstance.NotifyWidgetUpdate()
 			},
 			GetContextStats: func() extensions.ContextStats {
 				s := kitInstance.GetContextStats()
@@ -908,53 +921,52 @@ func runNormalMode(ctx context.Context) error {
 				}
 			},
 			SetEditor: func(config extensions.EditorConfig) {
-				kitInstance.SetExtensionEditor(config)
-				// Use a goroutine for NotifyWidgetUpdate because this may be
-				// called from within an editor HandleKey callback, which runs
-				// synchronously inside BubbleTea's Update(). Calling prog.Send()
-				// directly from Update() deadlocks the event loop.
+				kitInstance.Extensions().SetEditor(config)
+				// Always use a goroutine for NotifyWidgetUpdate: prog.Send()
+				// deadlocks if called synchronously from inside BubbleTea's
+				// Update() handler. All call sites use go-routines uniformly.
 				go appInstance.NotifyWidgetUpdate()
 			},
 			ResetEditor: func() {
-				kitInstance.ResetExtensionEditor()
+				kitInstance.Extensions().ResetEditor()
 				go appInstance.NotifyWidgetUpdate()
 			},
 			GetMessages: func() []extensions.SessionMessage {
-				return kitInstance.GetSessionMessages()
+				return kitInstance.Extensions().GetSessionMessages()
 			},
 			GetSessionPath: func() string {
-				return kitInstance.GetSessionFilePath()
+				return kitInstance.GetSessionPath()
 			},
 			AppendEntry: func(entryType string, data string) (string, error) {
-				return kitInstance.AppendExtensionEntry(entryType, data)
+				return kitInstance.Extensions().AppendEntry(entryType, data)
 			},
 			GetEntries: func(entryType string) []extensions.ExtensionEntry {
-				return kitInstance.GetExtensionEntries(entryType)
+				return kitInstance.Extensions().GetEntries(entryType)
 			},
 			SetEditorText: func(text string) {
 				appInstance.SetEditorTextFromExtension(text)
 			},
 			SetStatus: func(key string, text string, priority int) {
-				kitInstance.SetExtensionStatus(extensions.StatusBarEntry{
+				kitInstance.Extensions().SetStatus(extensions.StatusBarEntry{
 					Key:      key,
 					Text:     text,
 					Priority: priority,
 				})
-				appInstance.NotifyWidgetUpdate()
+				go appInstance.NotifyWidgetUpdate()
 			},
 			RemoveStatus: func(key string) {
-				kitInstance.RemoveExtensionStatus(key)
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().RemoveStatus(key)
+				go appInstance.NotifyWidgetUpdate()
 			},
 			GetOption: func(name string) string {
-				return kitInstance.GetExtensionOption(name)
+				return kitInstance.Extensions().GetOption(name)
 			},
 			SetOption: func(name string, value string) {
-				kitInstance.SetExtensionOption(name, value)
+				kitInstance.Extensions().SetOption(name, value)
 			},
 			SetModel: func(modelString string) error {
 				// Capture previous model for the ModelChange event.
-				previousModel := kitInstance.GetExtensionContext().Model
+				previousModel := kitInstance.Extensions().GetContext().Model
 				err := kitInstance.SetModel(context.Background(), modelString)
 				if err != nil {
 					return err
@@ -963,9 +975,9 @@ func runNormalMode(ctx context.Context) error {
 				p, m, _ := models.ParseModelString(modelString)
 				appInstance.NotifyModelChanged(p, m)
 				// Update the context's Model field so handlers see it.
-				kitInstance.UpdateExtensionContextModel(modelString)
+				kitInstance.Extensions().UpdateContextModel(modelString)
 				// Fire OnModelChange event to extensions.
-				kitInstance.EmitModelChange(modelString, previousModel, "extension")
+				kitInstance.Extensions().EmitModelChange(modelString, previousModel, "extension")
 				// Update usage tracker with new model info for correct token counting.
 				if usageTracker != nil {
 					newProvider, newModel, _ := models.ParseModelString(modelString)
@@ -990,7 +1002,7 @@ func runNormalMode(ctx context.Context) error {
 				return kitInstance.GetAvailableModels()
 			},
 			EmitCustomEvent: func(name string, data string) {
-				kitInstance.EmitExtensionCustomEvent(name, data)
+				kitInstance.Extensions().EmitCustomEvent(name, data)
 			},
 			Complete: func(req extensions.CompleteRequest) (extensions.CompleteResponse, error) {
 				return kitInstance.ExecuteCompletion(context.Background(), req)
@@ -999,7 +1011,7 @@ func runNormalMode(ctx context.Context) error {
 				return appInstance.SuspendTUI(callback)
 			},
 			RenderMessage: func(rendererName, content string) {
-				renderer := kitInstance.GetExtensionMessageRenderer(rendererName)
+				renderer := kitInstance.Extensions().GetMessageRenderer(rendererName)
 				if renderer == nil || renderer.Render == nil {
 					appInstance.PrintFromExtension("", content)
 					return
@@ -1012,19 +1024,19 @@ func runNormalMode(ctx context.Context) error {
 				appInstance.PrintFromExtension("", rendered)
 			},
 			ReloadExtensions: func() error {
-				err := kitInstance.ReloadExtensions()
+				err := kitInstance.Extensions().Reload()
 				if err != nil {
 					return err
 				}
 				// Notify TUI that widgets/status/commands may have changed.
-				appInstance.NotifyWidgetUpdate()
+				go appInstance.NotifyWidgetUpdate()
 				return nil
 			},
 			GetAllTools: func() []extensions.ToolInfo {
-				return kitInstance.GetExtensionToolInfos()
+				return kitInstance.Extensions().GetToolInfos()
 			},
 			SetActiveTools: func(names []string) {
-				kitInstance.SetExtensionActiveTools(names)
+				kitInstance.Extensions().SetActiveTools(names)
 			},
 			RegisterTheme: func(name string, config extensions.ThemeColorConfig) {
 				tc := func(c extensions.ThemeColor) [2]string { return [2]string{c.Light, c.Dark} }
@@ -1095,7 +1107,7 @@ func runNormalMode(ctx context.Context) error {
 				}
 				extResult := &extensions.SubagentResult{
 					Response:  result.Response,
-					Error:     result.Error,
+					Error:     err,
 					SessionID: result.SessionID,
 					Elapsed:   result.Elapsed,
 				}
@@ -1149,16 +1161,19 @@ func runNormalMode(ctx context.Context) error {
 			GetChildren: kitInstance.GetChildren,
 			NavigateTo: func(entryID string) extensions.TreeNavigationResult {
 				err := kitInstance.NavigateTo(entryID)
-				if err != "" {
-					return extensions.TreeNavigationResult{Success: false, Error: err}
+				if err != nil {
+					return extensions.TreeNavigationResult{Success: false, Error: err.Error()}
 				}
 				return extensions.TreeNavigationResult{Success: true}
 			},
-			SummarizeBranch: kitInstance.SummarizeBranch,
+			SummarizeBranch: func(fromID, toID string) string {
+				summary, _ := kitInstance.SummarizeBranch(fromID, toID)
+				return summary
+			},
 			CollapseBranch: func(fromID, toID, summary string) extensions.TreeNavigationResult {
 				err := kitInstance.CollapseBranch(fromID, toID, summary)
-				if err != "" {
-					return extensions.TreeNavigationResult{Success: false, Error: err}
+				if err != nil {
+					return extensions.TreeNavigationResult{Success: false, Error: err.Error()}
 				}
 				return extensions.TreeNavigationResult{Success: true}
 			},
@@ -1207,10 +1222,10 @@ func runNormalMode(ctx context.Context) error {
 			ParseArguments:       kit.ParseArguments,
 			SimpleParseArguments: kit.SimpleParseArguments,
 			EvaluateModelConditional: func(condition string) bool {
-				return kit.EvaluateModelConditional(kitInstance.GetExtensionContext().Model, condition)
+				return kit.EvaluateModelConditional(kitInstance.Extensions().GetContext().Model, condition)
 			},
 			RenderWithModelConditionals: func(content string) string {
-				return kit.RenderWithModelConditionals(content, kitInstance.GetExtensionContext().Model)
+				return kit.RenderWithModelConditionals(content, kitInstance.Extensions().GetContext().Model)
 			},
 
 			// -------------------------------------------------------------------------
@@ -1222,16 +1237,16 @@ func runNormalMode(ctx context.Context) error {
 			},
 			CheckModelAvailable: kit.CheckModelAvailable,
 			GetCurrentProvider: func() string {
-				return kit.GetCurrentProvider(kitInstance.GetExtensionContext().Model)
+				return kit.GetCurrentProvider(kitInstance.Extensions().GetContext().Model)
 			},
 			GetCurrentModelID: func() string {
-				return kit.GetCurrentModelID(kitInstance.GetExtensionContext().Model)
+				return kit.GetCurrentModelID(kitInstance.Extensions().GetContext().Model)
 			},
 		})
-		kitInstance.EmitSessionStart()
+		kitInstance.Extensions().EmitSessionStart()
 
 		// Restore normal print functions for runtime use.
-		kitInstance.SetExtensionContext(extensions.Context{
+		kitInstance.Extensions().SetContext(extensions.Context{
 			CWD:           cwd,
 			Model:         modelName,
 			Interactive:   positionalPrompt == "",
@@ -1243,28 +1258,28 @@ func runNormalMode(ctx context.Context) error {
 			CancelAndSend: func(text string) { appInstance.InterruptAndSend(text) },
 			Exit:          func() { appInstance.QuitFromExtension() },
 			SetWidget: func(config extensions.WidgetConfig) {
-				kitInstance.SetExtensionWidget(config)
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().SetWidget(config)
+				go appInstance.NotifyWidgetUpdate()
 			},
 			RemoveWidget: func(id string) {
-				kitInstance.RemoveExtensionWidget(id)
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().RemoveWidget(id)
+				go appInstance.NotifyWidgetUpdate()
 			},
 			SetHeader: func(config extensions.HeaderFooterConfig) {
-				kitInstance.SetExtensionHeader(config)
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().SetHeader(config)
+				go appInstance.NotifyWidgetUpdate()
 			},
 			RemoveHeader: func() {
-				kitInstance.RemoveExtensionHeader()
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().RemoveHeader()
+				go appInstance.NotifyWidgetUpdate()
 			},
 			SetFooter: func(config extensions.HeaderFooterConfig) {
-				kitInstance.SetExtensionFooter(config)
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().SetFooter(config)
+				go appInstance.NotifyWidgetUpdate()
 			},
 			RemoveFooter: func() {
-				kitInstance.RemoveExtensionFooter()
-				appInstance.NotifyWidgetUpdate()
+				kitInstance.Extensions().RemoveFooter()
+				go appInstance.NotifyWidgetUpdate()
 			},
 			PromptSelect: func(config extensions.PromptSelectConfig) extensions.PromptSelectResult {
 				ch := make(chan app.PromptResponse, 1)
@@ -1360,7 +1375,7 @@ func runNormalMode(ctx context.Context) error {
 				}
 				extResult := &extensions.SubagentResult{
 					Response:  result.Response,
-					Error:     result.Error,
+					Error:     err,
 					SessionID: result.SessionID,
 					Elapsed:   result.Elapsed,
 				}
@@ -1414,16 +1429,19 @@ func runNormalMode(ctx context.Context) error {
 			GetChildren: kitInstance.GetChildren,
 			NavigateTo: func(entryID string) extensions.TreeNavigationResult {
 				err := kitInstance.NavigateTo(entryID)
-				if err != "" {
-					return extensions.TreeNavigationResult{Success: false, Error: err}
+				if err != nil {
+					return extensions.TreeNavigationResult{Success: false, Error: err.Error()}
 				}
 				return extensions.TreeNavigationResult{Success: true}
 			},
-			SummarizeBranch: kitInstance.SummarizeBranch,
+			SummarizeBranch: func(fromID, toID string) string {
+				summary, _ := kitInstance.SummarizeBranch(fromID, toID)
+				return summary
+			},
 			CollapseBranch: func(fromID, toID, summary string) extensions.TreeNavigationResult {
 				err := kitInstance.CollapseBranch(fromID, toID, summary)
-				if err != "" {
-					return extensions.TreeNavigationResult{Success: false, Error: err}
+				if err != nil {
+					return extensions.TreeNavigationResult{Success: false, Error: err.Error()}
 				}
 				return extensions.TreeNavigationResult{Success: true}
 			},
@@ -1472,10 +1490,10 @@ func runNormalMode(ctx context.Context) error {
 			ParseArguments:       kit.ParseArguments,
 			SimpleParseArguments: kit.SimpleParseArguments,
 			EvaluateModelConditional: func(condition string) bool {
-				return kit.EvaluateModelConditional(kitInstance.GetExtensionContext().Model, condition)
+				return kit.EvaluateModelConditional(kitInstance.Extensions().GetContext().Model, condition)
 			},
 			RenderWithModelConditionals: func(content string) string {
-				return kit.RenderWithModelConditionals(content, kitInstance.GetExtensionContext().Model)
+				return kit.RenderWithModelConditionals(content, kitInstance.Extensions().GetContext().Model)
 			},
 
 			// -------------------------------------------------------------------------
@@ -1487,10 +1505,10 @@ func runNormalMode(ctx context.Context) error {
 			},
 			CheckModelAvailable: kit.CheckModelAvailable,
 			GetCurrentProvider: func() string {
-				return kit.GetCurrentProvider(kitInstance.GetExtensionContext().Model)
+				return kit.GetCurrentProvider(kitInstance.Extensions().GetContext().Model)
 			},
 			GetCurrentModelID: func() string {
-				return kit.GetCurrentModelID(kitInstance.GetExtensionContext().Model)
+				return kit.GetCurrentModelID(kitInstance.Extensions().GetContext().Model)
 			},
 		})
 	}
@@ -1560,7 +1578,7 @@ func runNormalMode(ctx context.Context) error {
 			return err
 		}
 		// Update the extension context's Model field so handlers see it.
-		kitInstance.UpdateExtensionContextModel(modelString)
+		kitInstance.Extensions().UpdateContextModel(modelString)
 		// NOTE: We do NOT call appInstance.NotifyModelChanged() here because
 		// this callback runs synchronously inside BubbleTea's Update(), and
 		// NotifyModelChanged calls prog.Send() which deadlocks. The UI layer
@@ -1586,7 +1604,7 @@ func runNormalMode(ctx context.Context) error {
 		return nil
 	}
 	emitModelChangeForUI := func(newModel, previousModel, source string) {
-		kitInstance.EmitModelChange(newModel, previousModel, source)
+		kitInstance.Extensions().EmitModelChange(newModel, previousModel, source)
 	}
 
 	// Build thinking level callback.
@@ -1727,7 +1745,7 @@ func buildJSONOutput(result *kit.TurnResult, model string) ([]byte, error) {
 	}
 
 	for _, fmsg := range result.Messages {
-		converted := kit.ConvertFromFantasyMessage(fmsg)
+		converted := kit.ConvertFromLLMMessage(fmsg)
 		m := jsonMessage{Role: string(converted.Role)}
 		for _, p := range converted.Parts {
 			switch c := p.(type) {
@@ -1781,43 +1799,45 @@ func runInteractiveModeBubbleTea(_ context.Context, appInstance *app.App, modelN
 	cwd, _ := os.Getwd()
 
 	appModel := ui.NewAppModel(appInstance, ui.AppModelOptions{
-		CompactMode:             viper.GetBool("compact"),
-		ModelName:               modelName,
-		ProviderName:            providerName,
-		LoadingMessage:          loadingMessage,
-		Cwd:                     cwd,
-		Width:                   termWidth,
-		Height:                  termHeight,
-		ServerNames:             serverNames,
-		ToolNames:               toolNames,
-		MCPToolCount:            mcpToolCount,
-		ExtensionToolCount:      extensionToolCount,
-		UsageTracker:            usageTracker,
-		ExtensionCommands:       extCommands,
-		PromptTemplates:         promptTemplates,
-		ContextPaths:            contextPaths,
-		SkillItems:              skillItems,
-		GetWidgets:              getWidgets,
-		GetHeader:               getHeader,
-		GetFooter:               getFooter,
-		GetToolRenderer:         getToolRenderer,
-		GetEditorInterceptor:    getEditorInterceptor,
-		GetUIVisibility:         getUIVisibility,
-		GetStatusBarEntries:     getStatusBarEntries,
-		EmitBeforeFork:          emitBeforeFork,
-		EmitBeforeSessionSwitch: emitBeforeSessionSwitch,
-		GetGlobalShortcuts:      getGlobalShortcuts,
-		GetExtensionCommands:    getExtensionCommands,
-		SetModel:                setModel,
-		EmitModelChange:         emitModelChange,
-		ThinkingLevel:           thinkingLevel,
-		IsReasoningModel:        isReasoningModel,
-		SetThinkingLevel:        setThinkingLevel,
-		SwitchSession:           switchSession,
-		ShowSessionPicker:       resumeFlag,
+		ModelName:                modelName,
+		ProviderName:             providerName,
+		LoadingMessage:           loadingMessage,
+		Cwd:                      cwd,
+		Width:                    termWidth,
+		Height:                   termHeight,
+		ServerNames:              serverNames,
+		ToolNames:                toolNames,
+		MCPToolCount:             mcpToolCount,
+		ExtensionToolCount:       extensionToolCount,
+		UsageTracker:             usageTracker,
+		ExtensionCommands:        extCommands,
+		PromptTemplates:          promptTemplates,
+		ContextPaths:             contextPaths,
+		SkillItems:               skillItems,
+		StartupExtensionMessages: startupExtensionMessages,
+		GetWidgets:               getWidgets,
+		GetHeader:                getHeader,
+		GetFooter:                getFooter,
+		GetToolRenderer:          getToolRenderer,
+		GetEditorInterceptor:     getEditorInterceptor,
+		GetUIVisibility:          getUIVisibility,
+		GetStatusBarEntries:      getStatusBarEntries,
+		EmitBeforeFork:           emitBeforeFork,
+		EmitBeforeSessionSwitch:  emitBeforeSessionSwitch,
+		GetGlobalShortcuts:       getGlobalShortcuts,
+		GetExtensionCommands:     getExtensionCommands,
+		SetModel:                 setModel,
+		EmitModelChange:          emitModelChange,
+		ThinkingLevel:            thinkingLevel,
+		IsReasoningModel:         isReasoningModel,
+		SetThinkingLevel:         setThinkingLevel,
+		SwitchSession:            switchSession,
+		ShowSessionPicker:        resumeFlag,
 	})
 
-	// Print startup info to stdout before Bubble Tea takes over the screen.
+	// Print KIT banner and startup info to stdout before Bubble Tea takes over the screen.
+	fmt.Println(kitBanner())
+	fmt.Println()
 	appModel.PrintStartupInfo()
 
 	// Print any extension messages that were captured during startup.

cmd/setup.go

@@ -41,7 +41,6 @@ func BuildAppOptions(mcpConfig *config.Config, modelName string, serverNames, to
 		StreamingEnabled: viper.GetBool("stream"),
 		Quiet:            quietFlag,
 		Debug:            viper.GetBool("debug"),
-		CompactMode:      viper.GetBool("compact"),
 	}
 }
 
@@ -131,7 +130,6 @@ func SetupCLIForNonInteractive(k *kit.Kit) (*ui.CLI, error) {
 		Agent:          agentAdapter,
 		ModelString:    viper.GetString("model"),
 		Debug:          viper.GetBool("debug"),
-		Compact:        viper.GetBool("compact"),
 		Quiet:          quietFlag,
 		ShowDebug:      false,
 		ProviderAPIKey: viper.GetString("provider-api-key"),

examples/extensions/all_extensions_load_test.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/mark3labs/kit/pkg/extensions/test"
+)
+
+// TestAllExtensions_Load is a smoke test that verifies every single-file
+// example extension in this directory can be loaded by the Yaegi interpreter
+// without errors. This catches syntax errors, missing symbols, bad imports,
+// and Init signature mismatches.
+func TestAllExtensions_Load(t *testing.T) {
+	files := extensionFiles(t)
+
+	for _, file := range files {
+		t.Run(file, func(t *testing.T) {
+			harness := test.New(t)
+			ext := harness.LoadFile(file)
+			if ext == nil {
+				t.Fatalf("%s: extension should not be nil after loading", file)
+			}
+		})
+	}
+
+	t.Logf("successfully loaded %d extensions", len(files))
+}

examples/extensions/all_extensions_sanity_test.go

@@ -0,0 +1,253 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/mark3labs/kit/internal/extensions"
+	"github.com/mark3labs/kit/pkg/extensions/test"
+)
+
+// extensionFiles returns all single-file extensions in the current directory.
+// It skips test files, the test template, and files without an Init function.
+func extensionFiles(t *testing.T) []string {
+	t.Helper()
+
+	skip := map[string]bool{
+		"extension_test_template.go": true,
+	}
+
+	entries, err := os.ReadDir(".")
+	if err != nil {
+		t.Fatalf("failed to read directory: %v", err)
+	}
+
+	var files []string
+	for _, entry := range entries {
+		name := entry.Name()
+		if entry.IsDir() || filepath.Ext(name) != ".go" {
+			continue
+		}
+		if strings.HasSuffix(name, "_test.go") || skip[name] {
+			continue
+		}
+		src, err := os.ReadFile(name)
+		if err != nil {
+			t.Fatalf("failed to read %s: %v", name, err)
+		}
+		if !strings.Contains(string(src), "func Init(") {
+			continue
+		}
+		files = append(files, name)
+	}
+
+	if len(files) == 0 {
+		t.Fatal("no extensions found — check the directory")
+	}
+	return files
+}
+
+// TestAllExtensions_Lifecycle verifies that every extension survives a full
+// SessionStart → SessionShutdown round-trip without errors.
+func TestAllExtensions_Lifecycle(t *testing.T) {
+	for _, file := range extensionFiles(t) {
+		t.Run(file, func(t *testing.T) {
+			harness := test.New(t)
+			harness.LoadFile(file)
+
+			_, err := harness.Emit(extensions.SessionStartEvent{
+				SessionID: "smoke-test-session",
+			})
+			if err != nil {
+				t.Fatalf("SessionStart error: %v", err)
+			}
+
+			_, err = harness.Emit(extensions.SessionShutdownEvent{})
+			if err != nil {
+				t.Fatalf("SessionShutdown error: %v", err)
+			}
+		})
+	}
+}
+
+// TestAllExtensions_CommandSanity checks that every registered command has
+// a non-empty name, a non-empty description, no spaces in the name, no
+// leading slash, a non-nil Execute function, and no duplicate names.
+func TestAllExtensions_CommandSanity(t *testing.T) {
+	for _, file := range extensionFiles(t) {
+		t.Run(file, func(t *testing.T) {
+			harness := test.New(t)
+			harness.LoadFile(file)
+
+			cmds := harness.RegisteredCommands()
+			seen := make(map[string]bool)
+			for _, cmd := range cmds {
+				if cmd.Name == "" {
+					t.Error("command has empty name")
+				}
+				if strings.Contains(cmd.Name, " ") {
+					t.Errorf("command %q contains spaces", cmd.Name)
+				}
+				if strings.HasPrefix(cmd.Name, "/") {
+					t.Errorf("command %q has leading slash (framework adds it)", cmd.Name)
+				}
+				if cmd.Description == "" {
+					t.Errorf("command %q has empty description", cmd.Name)
+				}
+				if cmd.Execute == nil {
+					t.Errorf("command %q has nil Execute function", cmd.Name)
+				}
+				if seen[cmd.Name] {
+					t.Errorf("duplicate command name %q", cmd.Name)
+				}
+				seen[cmd.Name] = true
+			}
+		})
+	}
+}
+
+// TestAllExtensions_ToolSanity checks that every registered tool has a
+// non-empty name, a non-empty description, at least one executor, valid
+// JSON in its Parameters field, and no duplicate names.
+func TestAllExtensions_ToolSanity(t *testing.T) {
+	for _, file := range extensionFiles(t) {
+		t.Run(file, func(t *testing.T) {
+			harness := test.New(t)
+			harness.LoadFile(file)
+
+			tools := harness.RegisteredTools()
+			seen := make(map[string]bool)
+			for _, tool := range tools {
+				if tool.Name == "" {
+					t.Error("tool has empty name")
+				}
+				if tool.Description == "" {
+					t.Errorf("tool %q has empty description", tool.Name)
+				}
+				if tool.Execute == nil && tool.ExecuteWithContext == nil {
+					t.Errorf("tool %q has no executor (both Execute and ExecuteWithContext are nil)", tool.Name)
+				}
+				if tool.Parameters != "" && !json.Valid([]byte(tool.Parameters)) {
+					t.Errorf("tool %q has invalid JSON in Parameters: %s", tool.Name, tool.Parameters)
+				}
+				if seen[tool.Name] {
+					t.Errorf("duplicate tool name %q", tool.Name)
+				}
+				seen[tool.Name] = true
+			}
+		})
+	}
+}
+
+// TestAllExtensions_ZeroValueEvents fires every event type (as zero-value
+// structs) at each extension and verifies no errors are returned. Extensions
+// should be resilient to events they don't handle and to events with empty
+// fields.
+func TestAllExtensions_ZeroValueEvents(t *testing.T) {
+	// Build the set of zero-value events for every event type.
+	zeroEvents := []extensions.Event{
+		extensions.ToolCallEvent{},
+		extensions.ToolExecutionStartEvent{},
+		extensions.ToolExecutionEndEvent{},
+		extensions.ToolOutputEvent{},
+		extensions.ToolResultEvent{},
+		extensions.InputEvent{},
+		extensions.BeforeAgentStartEvent{},
+		extensions.AgentStartEvent{},
+		extensions.AgentEndEvent{},
+		extensions.MessageStartEvent{},
+		extensions.MessageUpdateEvent{},
+		extensions.MessageEndEvent{},
+		extensions.SessionStartEvent{},
+		extensions.SessionShutdownEvent{},
+		extensions.ModelChangeEvent{},
+		extensions.ContextPrepareEvent{},
+		extensions.BeforeForkEvent{},
+		extensions.BeforeSessionSwitchEvent{},
+		extensions.BeforeCompactEvent{},
+		extensions.SubagentStartEvent{},
+		extensions.SubagentChunkEvent{},
+		extensions.SubagentEndEvent{},
+	}
+
+	for _, file := range extensionFiles(t) {
+		t.Run(file, func(t *testing.T) {
+			harness := test.New(t)
+			harness.LoadFile(file)
+
+			for _, ev := range zeroEvents {
+				_, err := harness.Emit(ev)
+				if err != nil {
+					t.Errorf("event %T returned error: %v", ev, err)
+				}
+			}
+		})
+	}
+}
+
+// TestAllExtensions_WidgetSanity emits SessionStart and then checks that
+// any widgets set during initialization have non-empty IDs and valid
+// placements.
+func TestAllExtensions_WidgetSanity(t *testing.T) {
+	validPlacements := map[extensions.WidgetPlacement]bool{
+		"above": true,
+		"below": true,
+	}
+
+	for _, file := range extensionFiles(t) {
+		t.Run(file, func(t *testing.T) {
+			harness := test.New(t)
+			harness.LoadFile(file)
+
+			// Trigger SessionStart so extensions that set widgets on init do so.
+			_, _ = harness.Emit(extensions.SessionStartEvent{
+				SessionID: "widget-sanity-test",
+			})
+
+			// Widgets is an exported field on MockContext; reads are safe
+			// here because Emit returned synchronously.
+			for id, w := range harness.Context().Widgets {
+				if w.ID == "" {
+					t.Errorf("widget stored with key %q has empty ID", id)
+				}
+				if w.ID != id {
+					t.Errorf("widget key %q doesn't match widget ID %q", id, w.ID)
+				}
+				if !validPlacements[w.Placement] {
+					t.Errorf("widget %q has invalid placement %q (want \"above\" or \"below\")", id, w.Placement)
+				}
+			}
+		})
+	}
+}
+
+// TestAllExtensions_IdempotentLifecycle verifies that receiving SessionStart
+// twice and SessionShutdown twice doesn't cause errors — extensions should
+// be defensive about repeated lifecycle events.
+func TestAllExtensions_IdempotentLifecycle(t *testing.T) {
+	for _, file := range extensionFiles(t) {
+		t.Run(file, func(t *testing.T) {
+			harness := test.New(t)
+			harness.LoadFile(file)
+
+			for i := range 2 {
+				_, err := harness.Emit(extensions.SessionStartEvent{
+					SessionID: "idempotent-test",
+				})
+				if err != nil {
+					t.Fatalf("SessionStart #%d error: %v", i+1, err)
+				}
+			}
+
+			for i := range 2 {
+				_, err := harness.Emit(extensions.SessionShutdownEvent{})
+				if err != nil {
+					t.Fatalf("SessionShutdown #%d error: %v", i+1, err)
+				}
+			}
+		})
+	}
+}

examples/extensions/lsp-diagnostics.go

@@ -2,9 +2,7 @@
 
 // lsp-diagnostics.go — LSP-powered diagnostics for Kit's edit tool.
 //
-// Starts language servers on demand and surfaces diagnostics after file edits,
-// following the same pattern used by Charm's crush editor:
-//
+// Starts language servers on demand and surfaces diagnostics after file edits:
 //  1. After an edit, notify the LSP server of the file change
 //  2. Wait for the server to publish fresh diagnostics
 //  3. Append diagnostic output to the edit tool's result
@@ -412,7 +410,7 @@ func (c *lspClient) changeFile(absPath, content string) {
 }
 
 // waitForDiagnostics polls until the server publishes new diagnostics or
-// the timeout elapses. Mirrors crush's WaitForDiagnostics pattern.
+// the timeout elapses.
 func (c *lspClient) waitForDiagnostics(timeout time.Duration) {
 	c.diagMu.Lock()
 	startVersion := c.diagVersion

go.mod

@@ -3,7 +3,7 @@ module github.com/mark3labs/kit
 go 1.26.1
 
 require (
-	charm.land/bubbles/v2 v2.0.0
+	charm.land/bubbles/v2 v2.1.0
 	charm.land/bubbletea/v2 v2.0.2
 	charm.land/fantasy v0.17.1
 	charm.land/huh/v2 v2.0.3
@@ -13,6 +13,8 @@ require (
 	github.com/charmbracelet/fang v1.0.0
 	github.com/charmbracelet/log v1.0.0
 	github.com/coder/acp-go-sdk v0.6.3
+	github.com/indaco/herald v0.10.0
+	github.com/indaco/herald-md v0.1.0
 	github.com/mark3labs/mcp-go v0.46.0
 	github.com/spf13/cobra v1.10.2
 	github.com/spf13/viper v1.21.0
@@ -29,22 +31,21 @@ require (
 	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.21.0 // indirect
 	github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 // indirect
 	github.com/atotto/clipboard v0.1.4 // indirect
-	github.com/aws/aws-sdk-go-v2 v1.41.4 // indirect
+	github.com/aws/aws-sdk-go-v2 v1.41.5 // indirect
 	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.8 // indirect
-	github.com/aws/aws-sdk-go-v2/config v1.32.12 // indirect
-	github.com/aws/aws-sdk-go-v2/credentials v1.19.12 // indirect
-	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.20 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.20 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.20 // indirect
+	github.com/aws/aws-sdk-go-v2/config v1.32.13 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.19.13 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.21 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.21 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.6 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.20 // indirect
-	github.com/aws/aws-sdk-go-v2/service/signin v1.0.8 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sso v1.30.13 // indirect
-	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.17 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sts v1.41.9 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.21 // indirect
+	github.com/aws/aws-sdk-go-v2/service/signin v1.0.9 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.30.14 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.18 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.41.10 // indirect
 	github.com/aws/smithy-go v1.24.2 // indirect
-	github.com/aymerick/douceur v0.2.0 // indirect
 	github.com/catppuccin/go v0.3.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/charmbracelet/anthropic-sdk-go v0.0.0-20260223140439-63879b0b8dab // indirect
@@ -52,11 +53,11 @@ require (
 	github.com/charmbracelet/harmonica v0.2.0 // indirect
 	github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 // indirect
 	github.com/charmbracelet/openai-go v0.0.0-20260319145158-d0740cc34266 // indirect
-	github.com/charmbracelet/ultraviolet v0.0.0-20260316091819-b93f6a3b8502 // indirect
+	github.com/charmbracelet/ultraviolet v0.0.0-20260330092749-0f94982c930b // indirect
 	github.com/charmbracelet/x/cellbuf v0.0.15 // indirect
-	github.com/charmbracelet/x/exp/charmtone v0.0.0-20260323091123-df7b1bcffcca // indirect
+	github.com/charmbracelet/x/exp/charmtone v0.0.0-20260330094520-2dce04b6f8a4 // indirect
 	github.com/charmbracelet/x/exp/ordered v0.1.0 // indirect
-	github.com/charmbracelet/x/exp/slice v0.0.0-20260323091123-df7b1bcffcca // indirect
+	github.com/charmbracelet/x/exp/slice v0.0.0-20260330094520-2dce04b6f8a4 // indirect
 	github.com/charmbracelet/x/exp/strings v0.1.0 // indirect
 	github.com/charmbracelet/x/json v0.2.0 // indirect
 	github.com/charmbracelet/x/termios v0.1.1 // indirect
@@ -80,19 +81,15 @@ require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/googleapis/enterprise-certificate-proxy v0.3.14 // indirect
 	github.com/googleapis/gax-go/v2 v2.20.0 // indirect
-	github.com/gorilla/css v1.0.1 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
-	github.com/indaco/herald v0.9.0 // indirect
-	github.com/kaptinlin/go-i18n v0.2.12 // indirect
+	github.com/kaptinlin/go-i18n v0.3.0 // indirect
 	github.com/kaptinlin/jsonpointer v0.4.17 // indirect
-	github.com/kaptinlin/jsonschema v0.7.6 // indirect
-	github.com/kaptinlin/messageformat-go v0.4.18 // indirect
-	github.com/microcosm-cc/bluemonday v1.0.27 // indirect
+	github.com/kaptinlin/jsonschema v0.7.7 // indirect
+	github.com/kaptinlin/messageformat-go v0.4.19 // indirect
 	github.com/mitchellh/hashstructure/v2 v2.0.2 // indirect
 	github.com/muesli/mango v0.2.0 // indirect
 	github.com/muesli/mango-cobra v1.3.0 // indirect
 	github.com/muesli/mango-pflag v0.2.0 // indirect
-	github.com/muesli/reflow v0.3.0 // indirect
 	github.com/muesli/roff v0.1.0 // indirect
 	github.com/pelletier/go-toml/v2 v2.3.0 // indirect
 	github.com/sagikazarmark/locafero v0.12.0 // indirect
@@ -106,7 +103,6 @@ require (
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	github.com/yosida95/uritemplate/v3 v3.0.2 // indirect
 	github.com/yuin/goldmark v1.8.2 // indirect
-	github.com/yuin/goldmark-emoji v1.0.6 // indirect
 	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
 	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0 // indirect
 	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.67.0 // indirect
@@ -120,7 +116,7 @@ require (
 	golang.org/x/oauth2 v0.36.0 // indirect
 	golang.org/x/time v0.15.0 // indirect
 	google.golang.org/api v0.273.0 // indirect
-	google.golang.org/genai v1.51.0 // indirect
+	google.golang.org/genai v1.52.0 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20260319201613-d00831a3d3e7 // indirect
 	google.golang.org/grpc v1.79.3 // indirect
 	google.golang.org/protobuf v1.36.11 // indirect
@@ -129,11 +125,10 @@ require (
 
 require (
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/charmbracelet/glamour v1.0.0
 	github.com/charmbracelet/x/ansi v0.11.6
 	github.com/charmbracelet/x/term v0.2.2 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/lucasb-eyer/go-colorful v1.3.0 // indirect
+	github.com/lucasb-eyer/go-colorful v1.4.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.21 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect

go.sum

@@ -1,5 +1,5 @@
-charm.land/bubbles/v2 v2.0.0 h1:tE3eK/pHjmtrDiRdoC9uGNLgpopOd8fjhEe31B/ai5s=
-charm.land/bubbles/v2 v2.0.0/go.mod h1:rCHoleP2XhU8um45NTuOWBPNVHxnkXKTiZqcclL/qOI=
+charm.land/bubbles/v2 v2.1.0 h1:YSnNh5cPYlYjPxRrzs5VEn3vwhtEn3jVGRBT3M7/I0g=
+charm.land/bubbles/v2 v2.1.0/go.mod h1:l97h4hym2hvWBVfmJDtrEHHCtkIKeTEb3TTJ4ZOB3wY=
 charm.land/bubbletea/v2 v2.0.2 h1:4CRtRnuZOdFDTWSff9r8QFt/9+z6Emubz3aDMnf/dx0=
 charm.land/bubbletea/v2 v2.0.2/go.mod h1:3LRff2U4WIYXy7MTxfbAQ+AdfM3D8Xuvz2wbsOD9OHQ=
 charm.land/fantasy v0.17.1 h1:SQzfnyJPDuQWt6e//KKmQmEEXdqHMC0IZz10XwkLcEM=
@@ -34,42 +34,40 @@ github.com/alecthomas/repr v0.5.2 h1:SU73FTI9D1P5UNtvseffFSGmdNci/O6RsqzeXJtP0Qs
 github.com/alecthomas/repr v0.5.2/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
 github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
 github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
-github.com/aws/aws-sdk-go-v2 v1.41.4 h1:10f50G7WyU02T56ox1wWXq+zTX9I1zxG46HYuG1hH/k=
-github.com/aws/aws-sdk-go-v2 v1.41.4/go.mod h1:mwsPRE8ceUUpiTgF7QmQIJ7lgsKUPQOUl3o72QBrE1o=
+github.com/aws/aws-sdk-go-v2 v1.41.5 h1:dj5kopbwUsVUVFgO4Fi5BIT3t4WyqIDjGKCangnV/yY=
+github.com/aws/aws-sdk-go-v2 v1.41.5/go.mod h1:mwsPRE8ceUUpiTgF7QmQIJ7lgsKUPQOUl3o72QBrE1o=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.8 h1:eBMB84YGghSocM7PsjmmPffTa+1FBUeNvGvFou6V/4o=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.8/go.mod h1:lyw7GFp3qENLh7kwzf7iMzAxDn+NzjXEAGjKS2UOKqI=
-github.com/aws/aws-sdk-go-v2/config v1.32.12 h1:O3csC7HUGn2895eNrLytOJQdoL2xyJy0iYXhoZ1OmP0=
-github.com/aws/aws-sdk-go-v2/config v1.32.12/go.mod h1:96zTvoOFR4FURjI+/5wY1vc1ABceROO4lWgWJuxgy0g=
-github.com/aws/aws-sdk-go-v2/credentials v1.19.12 h1:oqtA6v+y5fZg//tcTWahyN9PEn5eDU/Wpvc2+kJ4aY8=
-github.com/aws/aws-sdk-go-v2/credentials v1.19.12/go.mod h1:U3R1RtSHx6NB0DvEQFGyf/0sbrpJrluENHdPy1j/3TE=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.20 h1:zOgq3uezl5nznfoK3ODuqbhVg1JzAGDUhXOsU0IDCAo=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.20/go.mod h1:z/MVwUARehy6GAg/yQ1GO2IMl0k++cu1ohP9zo887wE=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.20 h1:CNXO7mvgThFGqOFgbNAP2nol2qAWBOGfqR/7tQlvLmc=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.20/go.mod h1:oydPDJKcfMhgfcgBUZaG+toBbwy8yPWubJXBVERtI4o=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.20 h1:tN6W/hg+pkM+tf9XDkWUbDEjGLb+raoBMFsTodcoYKw=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.20/go.mod h1:YJ898MhD067hSHA6xYCx5ts/jEd8BSOLtQDL3iZsvbc=
+github.com/aws/aws-sdk-go-v2/config v1.32.13 h1:5KgbxMaS2coSWRrx9TX/QtWbqzgQkOdEa3sZPhBhCSg=
+github.com/aws/aws-sdk-go-v2/config v1.32.13/go.mod h1:8zz7wedqtCbw5e9Mi2doEwDyEgHcEE9YOJp6a8jdSMY=
+github.com/aws/aws-sdk-go-v2/credentials v1.19.13 h1:mA59E3fokBvyEGHKFdnpNNrvaR351cqiHgRg+JzOSRI=
+github.com/aws/aws-sdk-go-v2/credentials v1.19.13/go.mod h1:yoTXOQKea18nrM69wGF9jBdG4WocSZA1h38A+t/MAsk=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.21 h1:NUS3K4BTDArQqNu2ih7yeDLaS3bmHD0YndtA6UP884g=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.21/go.mod h1:YWNWJQNjKigKY1RHVJCuupeWDrrHjRqHm0N9rdrWzYI=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.21 h1:Rgg6wvjjtX8bNHcvi9OnXWwcE0a2vGpbwmtICOsvcf4=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.21/go.mod h1:A/kJFst/nm//cyqonihbdpQZwiUhhzpqTsdbhDdRF9c=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21 h1:PEgGVtPoB6NTpPrBgqSE5hE/o47Ij9qk/SEZFbUOe9A=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21/go.mod h1:p+hz+PRAYlY3zcpJhPwXlLC4C+kqn70WIHwnzAfs6ps=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.6 h1:qYQ4pzQ2Oz6WpQ8T3HvGHnZydA72MnLuFK9tJwmrbHw=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.6/go.mod h1:O3h0IK87yXci+kg6flUKzJnWeziQUKciKrLjcatSNcY=
 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7 h1:5EniKhLZe4xzL7a+fU3C2tfUN4nWIqlLesfrjkuPFTY=
 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7/go.mod h1:x0nZssQ3qZSnIcePWLvcoFisRXJzcTVvYpAAdYX8+GI=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.20 h1:2HvVAIq+YqgGotK6EkMf+KIEqTISmTYh5zLpYyeTo1Y=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.20/go.mod h1:V4X406Y666khGa8ghKmphma/7C0DAtEQYhkq9z4vpbk=
-github.com/aws/aws-sdk-go-v2/service/signin v1.0.8 h1:0GFOLzEbOyZABS3PhYfBIx2rNBACYcKty+XGkTgw1ow=
-github.com/aws/aws-sdk-go-v2/service/signin v1.0.8/go.mod h1:LXypKvk85AROkKhOG6/YEcHFPoX+prKTowKnVdcaIxE=
-github.com/aws/aws-sdk-go-v2/service/sso v1.30.13 h1:kiIDLZ005EcKomYYITtfsjn7dtOwHDOFy7IbPXKek2o=
-github.com/aws/aws-sdk-go-v2/service/sso v1.30.13/go.mod h1:2h/xGEowcW/g38g06g3KpRWDlT+OTfxxI0o1KqayAB8=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.17 h1:jzKAXIlhZhJbnYwHbvUQZEB8KfgAEuG0dc08Bkda7NU=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.17/go.mod h1:Al9fFsXjv4KfbzQHGe6V4NZSZQXecFcvaIF4e70FoRA=
-github.com/aws/aws-sdk-go-v2/service/sts v1.41.9 h1:Cng+OOwCHmFljXIxpEVXAGMnBia8MSU6Ch5i9PgBkcU=
-github.com/aws/aws-sdk-go-v2/service/sts v1.41.9/go.mod h1:LrlIndBDdjA/EeXeyNBle+gyCwTlizzW5ycgWnvIxkk=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.21 h1:c31//R3xgIJMSC8S6hEVq+38DcvUlgFY0FM6mSI5oto=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.21/go.mod h1:r6+pf23ouCB718FUxaqzZdbpYFyDtehyZcmP5KL9FkA=
+github.com/aws/aws-sdk-go-v2/service/signin v1.0.9 h1:QKZH0S178gCmFEgst8hN0mCX1KxLgHBKKY/CLqwP8lg=
+github.com/aws/aws-sdk-go-v2/service/signin v1.0.9/go.mod h1:7yuQJoT+OoH8aqIxw9vwF+8KpvLZ8AWmvmUWHsGQZvI=
+github.com/aws/aws-sdk-go-v2/service/sso v1.30.14 h1:GcLE9ba5ehAQma6wlopUesYg/hbcOhFNWTjELkiWkh4=
+github.com/aws/aws-sdk-go-v2/service/sso v1.30.14/go.mod h1:WSvS1NLr7JaPunCXqpJnWk1Bjo7IxzZXrZi1QQCkuqM=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.18 h1:mP49nTpfKtpXLt5SLn8Uv8z6W+03jYVoOSAl/c02nog=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.18/go.mod h1:YO8TrYtFdl5w/4vmjL8zaBSsiNp3w0L1FfKVKenZT7w=
+github.com/aws/aws-sdk-go-v2/service/sts v1.41.10 h1:p8ogvvLugcR/zLBXTXrTkj0RYBUdErbMnAFFp12Lm/U=
+github.com/aws/aws-sdk-go-v2/service/sts v1.41.10/go.mod h1:60dv0eZJfeVXfbT1tFJinbHrDfSJ2GZl4Q//OSSNAVw=
 github.com/aws/smithy-go v1.24.2 h1:FzA3bu/nt/vDvmnkg+R8Xl46gmzEDam6mZ1hzmwXFng=
 github.com/aws/smithy-go v1.24.2/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
 github.com/aymanbagabas/go-udiff v0.4.1 h1:OEIrQ8maEeDBXQDoGCbbTTXYJMYRCRO1fnodZ12Gv5o=
 github.com/aymanbagabas/go-udiff v0.4.1/go.mod h1:0L9PGwj20lrtmEMeyw4WKJ/TMyDtvAoK9bf2u/mNo3w=
-github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
-github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
 github.com/catppuccin/go v0.3.0 h1:d+0/YicIq+hSTo5oPuRi5kOpqkVA5tAsU6dNhvRu+aY=
 github.com/catppuccin/go v0.3.0/go.mod h1:8IHJuMGaUUjQM82qBrGNBv7LFq6JI3NnQCF6MOlZjpc=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
@@ -80,8 +78,6 @@ github.com/charmbracelet/colorprofile v0.4.3 h1:QPa1IWkYI+AOB+fE+mg/5/4HRMZcaXex
 github.com/charmbracelet/colorprofile v0.4.3/go.mod h1:/zT4BhpD5aGFpqQQqw7a+VtHCzu+zrQtt1zhMt9mR4Q=
 github.com/charmbracelet/fang v1.0.0 h1:jESBY40agJOlLYnnv9jE0mLqDGTxEk0hkOnx7YGyRlQ=
 github.com/charmbracelet/fang v1.0.0/go.mod h1:P5/DNb9DddQ0Z0dbc0P3ol4/ix5Po7Ofr2KMBfAqoCo=
-github.com/charmbracelet/glamour v1.0.0 h1:AWMLOVFHTsysl4WV8T8QgkQ0s/ZNZo7CiE4WKhk8l08=
-github.com/charmbracelet/glamour v1.0.0/go.mod h1:DSdohgOBkMr2ZQNhw4LZxSGpx3SvpeujNoXrQyH2hxo=
 github.com/charmbracelet/harmonica v0.2.0 h1:8NxJWRWg/bzKqqEaaeFNipOu77YR5t8aSwG4pgaUBiQ=
 github.com/charmbracelet/harmonica v0.2.0/go.mod h1:KSri/1RMQOZLbw7AHqgcBycp8pgJnQMYYT8QZRqZ1Ao=
 github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 h1:ZR7e0ro+SZZiIZD7msJyA+NjkCNNavuiPBLgerbOziE=
@@ -90,8 +86,8 @@ github.com/charmbracelet/log v1.0.0 h1:HVVVMmfOorfj3BA9i8X8UL69Hoz9lI0PYwXfJvOdR
 github.com/charmbracelet/log v1.0.0/go.mod h1:uYgY3SmLpwJWxmlrPwXvzVYujxis1vAKRV/0VQB7yWA=
 github.com/charmbracelet/openai-go v0.0.0-20260319145158-d0740cc34266 h1:BW/sZtyd1JyYy0h5adMm3tzpNyL857LWjuTRET6OhpY=
 github.com/charmbracelet/openai-go v0.0.0-20260319145158-d0740cc34266/go.mod h1:1DahUaExbUZx/jD+FNT2PKP4L9rLE5+ZBRuI8mZjd/E=
-github.com/charmbracelet/ultraviolet v0.0.0-20260316091819-b93f6a3b8502 h1:hzWNs3UQRSUTS6YCbLaQnwqKBFXT5Yh1OOw6+26apqg=
-github.com/charmbracelet/ultraviolet v0.0.0-20260316091819-b93f6a3b8502/go.mod h1:mkUCcxn9w9j89JJp3pOza5tmDQZPgIB75UfmQlFYvas=
+github.com/charmbracelet/ultraviolet v0.0.0-20260330092749-0f94982c930b h1:ASDO9RT6SNKTQN87jO2bRfxHFJq8cgeYdFzivY2gCeM=
+github.com/charmbracelet/ultraviolet v0.0.0-20260330092749-0f94982c930b/go.mod h1:Vo8TffMf0q7Uho/n8e6XpBZvOWtd3g39yX+9P5rRutA=
 github.com/charmbracelet/x/ansi v0.11.6 h1:GhV21SiDz/45W9AnV2R61xZMRri5NlLnl6CVF7ihZW8=
 github.com/charmbracelet/x/ansi v0.11.6/go.mod h1:2JNYLgQUsyqaiLovhU2Rv/pb8r6ydXKS3NIttu3VGZQ=
 github.com/charmbracelet/x/cellbuf v0.0.15 h1:ur3pZy0o6z/R7EylET877CBxaiE1Sp1GMxoFPAIztPI=
@@ -100,14 +96,14 @@ github.com/charmbracelet/x/conpty v0.1.1 h1:s1bUxjoi7EpqiXysVtC+a8RrvPPNcNvAjfi4
 github.com/charmbracelet/x/conpty v0.1.1/go.mod h1:OmtR77VODEFbiTzGE9G1XiRJAga6011PIm4u5fTNZpk=
 github.com/charmbracelet/x/errors v0.0.0-20240508181413-e8d8b6e2de86 h1:JSt3B+U9iqk37QUU2Rvb6DSBYRLtWqFqfxf8l5hOZUA=
 github.com/charmbracelet/x/errors v0.0.0-20240508181413-e8d8b6e2de86/go.mod h1:2P0UgXMEa6TsToMSuFqKFQR+fZTO9CNGUNokkPatT/0=
-github.com/charmbracelet/x/exp/charmtone v0.0.0-20260323091123-df7b1bcffcca h1:62yAoS1Ynbuzwcn1LkNBxi3IMF5p0E0cHCoaLOOmN9w=
-github.com/charmbracelet/x/exp/charmtone v0.0.0-20260323091123-df7b1bcffcca/go.mod h1:nsExn0DGyX0lh9LwLHTn2Gg+hafdzfSXnC+QmEJTZFY=
+github.com/charmbracelet/x/exp/charmtone v0.0.0-20260330094520-2dce04b6f8a4 h1:pIj18ZCZO4WOVj7jwjLoUb1lC7rS/I8oC3fZWXugNaY=
+github.com/charmbracelet/x/exp/charmtone v0.0.0-20260330094520-2dce04b6f8a4/go.mod h1:nsExn0DGyX0lh9LwLHTn2Gg+hafdzfSXnC+QmEJTZFY=
 github.com/charmbracelet/x/exp/golden v0.0.0-20250806222409-83e3a29d542f h1:pk6gmGpCE7F3FcjaOEKYriCvpmIN4+6OS/RD0vm4uIA=
 github.com/charmbracelet/x/exp/golden v0.0.0-20250806222409-83e3a29d542f/go.mod h1:IfZAMTHB6XkZSeXUqriemErjAWCCzT0LwjKFYCZyw0I=
 github.com/charmbracelet/x/exp/ordered v0.1.0 h1:55/qLwjIh0gL0Vni+QAWk7T/qRVP6sBf+2agPBgnOFE=
 github.com/charmbracelet/x/exp/ordered v0.1.0/go.mod h1:5UHwmG+is5THxMyCJHNPCn2/ecI07aKNrW+LcResjJ8=
-github.com/charmbracelet/x/exp/slice v0.0.0-20260323091123-df7b1bcffcca h1:QQoyQLgUzojMNWHVHToN6d9qTvT0KWtxUKIRPx/Ox5o=
-github.com/charmbracelet/x/exp/slice v0.0.0-20260323091123-df7b1bcffcca/go.mod h1:vqEfX6xzqW1pKKZUUiFOKg0OQ7bCh54Q2vR/tserrRA=
+github.com/charmbracelet/x/exp/slice v0.0.0-20260330094520-2dce04b6f8a4 h1:VSd4zShIAf/4FgEDFJpapEcAPrc7h3dyyN7V9JlJpQw=
+github.com/charmbracelet/x/exp/slice v0.0.0-20260330094520-2dce04b6f8a4/go.mod h1:vqEfX6xzqW1pKKZUUiFOKg0OQ7bCh54Q2vR/tserrRA=
 github.com/charmbracelet/x/exp/strings v0.1.0 h1:i69S2XI7uG1u4NLGeJPSYU++Nmjvpo9nwd6aoEm7gkA=
 github.com/charmbracelet/x/exp/strings v0.1.0/go.mod h1:/ehtMPNh9K4odGFkqYJKpIYyePhdp1hLBRvyY4bWkH8=
 github.com/charmbracelet/x/json v0.2.0 h1:DqB+ZGx2h+Z+1s98HOuOyli+i97wsFQIxP2ZQANTPrQ=
@@ -179,41 +175,38 @@ github.com/googleapis/enterprise-certificate-proxy v0.3.14 h1:yh8ncqsbUY4shRD5dA
 github.com/googleapis/enterprise-certificate-proxy v0.3.14/go.mod h1:vqVt9yG9480NtzREnTlmGSBmFrA+bzb0yl0TxoBQXOg=
 github.com/googleapis/gax-go/v2 v2.20.0 h1:NIKVuLhDlIV74muWlsMM4CcQZqN6JJ20Qcxd9YMuYcs=
 github.com/googleapis/gax-go/v2 v2.20.0/go.mod h1:But/NJU6TnZsrLai/xBAQLLz+Hc7fHZJt/hsCz3Fih4=
-github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8=
-github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
 github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/indaco/herald v0.9.0 h1:LrAfXEHkKz8WmctUKdndppIU/qFpylSbZ8galS0DVAc=
-github.com/indaco/herald v0.9.0/go.mod h1:T5g1+XLYvpjouhzAGHnAHDCKizhESkoV6+QPZ3DhgWA=
-github.com/kaptinlin/go-i18n v0.2.12 h1:ywDsvb4KDFddMC2dpI/rrIzGU2mWUSvHmWUm9BMsdl4=
-github.com/kaptinlin/go-i18n v0.2.12/go.mod h1:pVcu9qsW5pOIOoZFJXesRYmLos1vMQrby70JPAoWmJU=
+github.com/indaco/herald v0.10.0 h1:XzahEKX6cr50qZQrUdA3QrQBHg8uGm5jETD0UDi21BI=
+github.com/indaco/herald v0.10.0/go.mod h1:T5g1+XLYvpjouhzAGHnAHDCKizhESkoV6+QPZ3DhgWA=
+github.com/indaco/herald-md v0.1.0 h1:zmYudYo+uamzKTBcIffJVJYrqk9xDNnVrTh+de2zciw=
+github.com/indaco/herald-md v0.1.0/go.mod h1:Z1HxPCbSn+/+TFzOM/UbsmKeEk/28NNI6JOTileKXto=
+github.com/kaptinlin/go-i18n v0.3.0 h1:wP76dvYg04bvwTb+8NB+CmdZ2kL7lSSCQ9B/kFv7QHo=
+github.com/kaptinlin/go-i18n v0.3.0/go.mod h1:pVcu9qsW5pOIOoZFJXesRYmLos1vMQrby70JPAoWmJU=
 github.com/kaptinlin/jsonpointer v0.4.17 h1:mY9k8ciWncxbsECyaxKnR0MdmxamNdp2tLQkAKVrtSk=
 github.com/kaptinlin/jsonpointer v0.4.17/go.mod h1:SsfsjqnHG5zuKo1DTBzk1VknaHlL4osHw+X9kZKukpU=
-github.com/kaptinlin/jsonschema v0.7.6 h1:UUMqZGFAk7nOzQsYAxvgygm4wpDp/nwXxA4VP9mCPCs=
-github.com/kaptinlin/jsonschema v0.7.6/go.mod h1:GGk/oE+F1lWUfYrzKaCf4QWZmMdytt0LL4XdFEFB0LE=
-github.com/kaptinlin/messageformat-go v0.4.18 h1:RBlHVWgZyoxTcUgGWBsl2AcyScq/urqbLZvzgryTmSI=
-github.com/kaptinlin/messageformat-go v0.4.18/go.mod h1:ntI3154RnqJgr7GaC+vZBnIExl2V3sv9selvRNNEM24=
+github.com/kaptinlin/jsonschema v0.7.7 h1:41BlQJ9dskH0oE5DSzBUrl/w4JQYIr6N6L0B5GNyDoM=
+github.com/kaptinlin/jsonschema v0.7.7/go.mod h1:rKjWfyySHSxAD7Li2ctYkPlOu960igoKBvZ2ADRtd5Q=
+github.com/kaptinlin/messageformat-go v0.4.19 h1:A5kuuZ1ybXDQ7kD1aoEWGAOemX7hLsMY0yolgSbgpRI=
+github.com/kaptinlin/messageformat-go v0.4.19/go.mod h1:utSDTfiXTxl66OC5RIEuObLH7Ue3YjbA2X86SYMBYWg=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
-github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag=
-github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/lucasb-eyer/go-colorful v1.4.0 h1:UtrWVfLdarDgc44HcS7pYloGHJUjHV/4FwW4TvVgFr4=
+github.com/lucasb-eyer/go-colorful v1.4.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mark3labs/mcp-go v0.46.0 h1:8KRibF4wcKejbLsHxCA/QBVUr5fQ9nwz/n8lGqmaALo=
 github.com/mark3labs/mcp-go v0.46.0/go.mod h1:JKTC7R2LLVagkEWK7Kwu7DbmA6iIvnNAod6yrHiQMag=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
 github.com/mattn/go-runewidth v0.0.21 h1:jJKAZiQH+2mIinzCJIaIG9Be1+0NR+5sz/lYEEjdM8w=
 github.com/mattn/go-runewidth v0.0.21/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
-github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
-github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA=
 github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4NcD46KavDd4=
 github.com/mitchellh/hashstructure/v2 v2.0.2/go.mod h1:MG3aRVU/N29oo/V/IhBX8GR/zz4kQkprJgF2EVszyDE=
 github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
@@ -224,8 +217,6 @@ github.com/muesli/mango-cobra v1.3.0 h1:vQy5GvPg3ndOSpduxutqFoINhWk3vD5K2dXo5E8p
 github.com/muesli/mango-cobra v1.3.0/go.mod h1:Cj1ZrBu3806Qw7UjxnAUgE+7tllUBj1NCLQDwwGx19E=
 github.com/muesli/mango-pflag v0.2.0 h1:QViokgKDZQCzKhYe1zH8D+UlPJzBSGoP9yx0hBG0t5k=
 github.com/muesli/mango-pflag v0.2.0/go.mod h1:X9LT1p/pbGA1wjvEbtwnixujKErkP0jVmrxwrw3fL0Y=
-github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
-github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
 github.com/muesli/roff v0.1.0 h1:YD0lalCotmYuF5HhZliKWlIx7IEhiXeSfq7hNjFqGF8=
 github.com/muesli/roff v0.1.0/go.mod h1:pjAHQM9hdUUwm/krAfrLGgJkXJ+YuhtsfZ42kieB2Ig=
 github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
@@ -238,8 +229,6 @@ github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgm
 github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
@@ -281,8 +270,6 @@ github.com/yosida95/uritemplate/v3 v3.0.2 h1:Ed3Oyj9yrmi9087+NczuL5BwkIc4wvTb5zI
 github.com/yosida95/uritemplate/v3 v3.0.2/go.mod h1:ILOh0sOhIJR3+L/8afwt/kE++YT040gmv5BQTMR2HP4=
 github.com/yuin/goldmark v1.8.2 h1:kEGpgqJXdgbkhcOgBxkC0X0PmoPG1ZyoZ117rDVp4zE=
 github.com/yuin/goldmark v1.8.2/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
-github.com/yuin/goldmark-emoji v1.0.6 h1:QWfF2FYaXwL74tfGOW5izeiZepUDroDJfWubQI9HTHs=
-github.com/yuin/goldmark-emoji v1.0.6/go.mod h1:ukxJDKFpdFb5x0a5HqbdlcKtebh086iJpI31LTKmWuA=
 go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
 go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
 go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0 h1:yI1/OhfEPy7J9eoa6Sj051C7n5dvpj0QX8g4sRchg04=
@@ -324,8 +311,8 @@ gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
 gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
 google.golang.org/api v0.273.0 h1:r/Bcv36Xa/te1ugaN1kdJ5LoA5Wj/cL+a4gj6FiPBjQ=
 google.golang.org/api v0.273.0/go.mod h1:JbAt7mF+XVmWu6xNP8/+CTiGH30ofmCmk9nM8d8fHew=
-google.golang.org/genai v1.51.0 h1:IZGuUqgfx40INv3hLFGCbOSGp0qFqm7LVmDghzNIYqg=
-google.golang.org/genai v1.51.0/go.mod h1:A3kkl0nyBjyFlNjgxIwKq70julKbIxpSxqKO5gw/gmk=
+google.golang.org/genai v1.52.0 h1:ekVIxWHtLUNbt+v0WWi4j3JT4yrHDEbysMcHQcaCQoI=
+google.golang.org/genai v1.52.0/go.mod h1:A3kkl0nyBjyFlNjgxIwKq70julKbIxpSxqKO5gw/gmk=
 google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7 h1:XzmzkmB14QhVhgnawEVsOn6OFsnpyxNPRY9QV01dNB0=
 google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7/go.mod h1:L43LFes82YgSonw6iTXTxXUX1OlULt4AQtkik4ULL/I=
 google.golang.org/genproto/googleapis/api v0.0.0-20260319201613-d00831a3d3e7 h1:41r6JMbpzBMen0R/4TZeeAmGXSJC7DftGINUodzTkPI=

internal/acpserver/agent.go

@@ -7,8 +7,11 @@ package acpserver
 
 import (
 	"context"
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	"os"
+	"strings"
 	"sync/atomic"
 
 	"github.com/charmbracelet/log"
@@ -20,6 +23,17 @@ import (
 // Version is injected at build time; fallback to "dev".
 var Version = "dev"
 
+// thinkingTagOpen and thinkingTagClose are the XML-style tags that some models
+// (Qwen, DeepSeek) wrap reasoning content in. We parse these to extract
+// reasoning/thinking content and send it as ACP thought updates.
+// Also support <think> format used by some models.
+const (
+	thinkingTagOpen    = "<thinking>"
+	thinkingTagClose   = "</thinking>"
+	shortThinkTagOpen  = "<think>"
+	shortThinkTagClose = "</think>"
+)
+
 // Agent implements the acp.Agent interface, delegating to Kit for LLM
 // execution, tool calls, and session management.
 type Agent struct {
@@ -28,6 +42,10 @@ type Agent struct {
 
 	// toolCallCounter provides unique IDs for tool calls within a turn.
 	toolCallCounter atomic.Int64
+
+	// inThinkingTag tracks whether we're currently inside a <thinking> tag
+	// when parsing streaming content from models that wrap reasoning in XML tags.
+	inThinkingTag bool
 }
 
 // NewAgent creates a new ACP agent backed by Kit.
@@ -111,13 +129,23 @@ func (a *Agent) Prompt(ctx context.Context, params acp.PromptRequest) (acp.Promp
 		)
 	}
 
-	// Extract text from prompt content blocks.
-	promptText := extractPromptText(params.Prompt)
-	if promptText == "" {
+	// Extract text and file attachments from prompt content blocks.
+	promptText, files := extractPromptContent(params.Prompt)
+	if promptText == "" && len(files) == 0 {
 		return acp.PromptResponse{}, acp.NewInvalidParams("empty prompt")
 	}
 
-	log.Debug("acp: prompt", "session", sessionID, "prompt_len", len(promptText))
+	// If we have files but no text prompt, add a default prompt
+	// This is required because the underlying LLM library needs a non-empty prompt
+	// when there are no previous messages in the conversation.
+	if promptText == "" && len(files) > 0 {
+		promptText = "Please analyze the attached file."
+	}
+
+	log.Debug("acp: prompt", "session", sessionID, "prompt_len", len(promptText), "files", len(files))
+
+	// Reset thinking tag state for this new prompt turn
+	a.inThinkingTag = false
 
 	// Create a cancellable context for this prompt turn.
 	promptCtx, cancel := context.WithCancel(ctx)
@@ -129,7 +157,13 @@ func (a *Agent) Prompt(ctx context.Context, params acp.PromptRequest) (acp.Promp
 	defer unsub()
 
 	// Run the prompt through Kit's full turn lifecycle.
-	_, err := sess.kit.PromptResult(promptCtx, promptText)
+	// Use PromptResultWithFiles when file attachments are present.
+	var err error
+	if len(files) > 0 {
+		_, err = sess.kit.PromptResultWithFiles(promptCtx, promptText, files)
+	} else {
+		_, err = sess.kit.PromptResult(promptCtx, promptText)
+	}
 	if err != nil {
 		if promptCtx.Err() != nil {
 			return acp.PromptResponse{
@@ -162,6 +196,24 @@ func (a *Agent) SetSessionMode(_ context.Context, _ acp.SetSessionModeRequest) (
 	return acp.SetSessionModeResponse{}, nil
 }
 
+// SetSessionModel changes the active model for a session.
+func (a *Agent) SetSessionModel(ctx context.Context, params acp.SetSessionModelRequest) (acp.SetSessionModelResponse, error) {
+	sessionID := string(params.SessionId)
+	sess, ok := a.registry.get(sessionID)
+	if !ok {
+		return acp.SetSessionModelResponse{}, acp.NewInvalidParams(fmt.Sprintf("session not found: %s", sessionID))
+	}
+
+	modelID := string(params.ModelId)
+	log.Debug("acp: set_session_model", "session", sessionID, "model", modelID)
+
+	if err := sess.kit.SetModel(ctx, modelID); err != nil {
+		return acp.SetSessionModelResponse{}, fmt.Errorf("set model: %w", err)
+	}
+
+	return acp.SetSessionModelResponse{}, nil
+}
+
 // ---------------------------------------------------------------------------
 // Event streaming: Kit events → ACP SessionUpdate notifications
 // ---------------------------------------------------------------------------
@@ -178,8 +230,24 @@ func (a *Agent) subscribeEvents(ctx context.Context, k *kit.Kit, sessionID acp.S
 		var update *acp.SessionUpdate
 		switch ev := e.(type) {
 		case kit.MessageUpdateEvent:
-			u := acp.UpdateAgentMessageText(ev.Chunk)
-			update = &u
+			// Handle models that wrap reasoning in <thinking> tags (Qwen, DeepSeek)
+			// Parse the chunk and separate reasoning from regular text
+			reasoning, text := a.parseThinkingTags(ev.Chunk)
+
+			// Send reasoning update if we have reasoning content
+			if reasoning != "" {
+				u := acp.UpdateAgentThoughtText(reasoning)
+				_ = a.conn.SessionUpdate(ctx, acp.SessionNotification{
+					SessionId: sessionID,
+					Update:    u,
+				})
+			}
+
+			// Send text update if we have text content
+			if text != "" {
+				u := acp.UpdateAgentMessageText(text)
+				update = &u
+			}
 
 		case kit.ReasoningDeltaEvent:
 			u := acp.UpdateAgentThoughtText(ev.Delta)
@@ -231,19 +299,271 @@ func (a *Agent) subscribeEvents(ctx context.Context, k *kit.Kit, sessionID acp.S
 // Helpers
 // ---------------------------------------------------------------------------
 
-// extractPromptText extracts the concatenated text content from ACP content
-// blocks. Non-text blocks are ignored for now.
-func extractPromptText(blocks []acp.ContentBlock) string {
-	var text string
-	for _, block := range blocks {
-		if block.Text != nil {
-			if text != "" {
-				text += "\n"
+// extractPromptContent extracts text and file attachments from ACP content blocks.
+// It converts supported content blocks (image, audio, resource) to Kit's LLMFilePart.
+func extractPromptContent(blocks []acp.ContentBlock) (string, []kit.LLMFilePart) {
+	var textParts []string
+	var files []kit.LLMFilePart
+
+	log.Debug("acp: extracting content", "blocks", len(blocks))
+
+	for i, block := range blocks {
+		switch {
+		// Text content
+		case block.Text != nil:
+			log.Debug("acp: content block", "index", i, "type", "text", "len", len(block.Text.Text))
+			textParts = append(textParts, block.Text.Text)
+
+		// Image data (base64)
+		case block.Image != nil:
+			mimeType := block.Image.MimeType
+			if mimeType == "" {
+				mimeType = "image/png" // Default fallback
 			}
-			text += block.Text.Text
+			log.Debug("acp: content block", "index", i, "type", "image", "mime", mimeType, "data_len", len(block.Image.Data))
+			if data, err := base64.StdEncoding.DecodeString(block.Image.Data); err == nil {
+				files = append(files, kit.LLMFilePart{
+					Filename:  "image.png",
+					Data:      data,
+					MediaType: mimeType,
+				})
+			} else {
+				log.Debug("acp: failed to decode image", "error", err)
+			}
+
+		// Audio data (base64)
+		case block.Audio != nil:
+			mimeType := block.Audio.MimeType
+			if mimeType == "" {
+				mimeType = "audio/wav" // Default fallback
+			}
+			log.Debug("acp: content block", "index", i, "type", "audio", "mime", mimeType)
+			if data, err := base64.StdEncoding.DecodeString(block.Audio.Data); err == nil {
+				files = append(files, kit.LLMFilePart{
+					Filename:  "audio.wav",
+					Data:      data,
+					MediaType: mimeType,
+				})
+			} else {
+				log.Debug("acp: failed to decode audio", "error", err)
+			}
+
+		// Embedded resource (text or binary file content)
+		case block.Resource != nil:
+			log.Debug("acp: content block", "index", i, "type", "resource")
+			res := block.Resource.Resource
+			// Text resource - append as text content with file reference
+			if res.TextResourceContents != nil {
+				uri := res.TextResourceContents.Uri
+				content := res.TextResourceContents.Text
+				mimeType := "text/plain"
+				if res.TextResourceContents.MimeType != nil {
+					mimeType = *res.TextResourceContents.MimeType
+				}
+				log.Debug("acp: text resource", "uri", uri, "mime", mimeType, "len", len(content))
+				// Text files are included as formatted text, NOT as FilePart
+				// FilePart is for binary files (images, audio, PDFs) only
+				textParts = append(textParts, fmt.Sprintf("[File: %s]\n```\n%s\n```", uri, content))
+			}
+			// Binary resource (base64 blob) - these become FilePart
+			if res.BlobResourceContents != nil {
+				uri := res.BlobResourceContents.Uri
+				mimeType := "application/octet-stream"
+				if res.BlobResourceContents.MimeType != nil {
+					mimeType = *res.BlobResourceContents.MimeType
+				}
+				log.Debug("acp: binary resource", "uri", uri, "mime", mimeType, "blob_len", len(res.BlobResourceContents.Blob))
+				if data, err := base64.StdEncoding.DecodeString(res.BlobResourceContents.Blob); err == nil {
+					files = append(files, kit.LLMFilePart{
+						Filename:  extractFilenameFromURI(uri),
+						Data:      data,
+						MediaType: mimeType,
+					})
+				} else {
+					log.Debug("acp: failed to decode binary resource", "error", err)
+				}
+			}
+
+		// Resource link (file reference without embedded content)
+		case block.ResourceLink != nil:
+			uri := block.ResourceLink.Uri
+			name := block.ResourceLink.Name
+			log.Debug("acp: content block", "index", i, "type", "resource_link", "uri", uri, "name", name)
+			// For resource links, we'll try to read the file from disk
+			// This requires the file URI to be accessible (file:// scheme)
+			if content, err := readResourceFromURI(uri); err == nil {
+				// Detect if it's a text file or binary file
+				mimeType := "text/plain"
+				if block.ResourceLink.MimeType != nil {
+					mimeType = *block.ResourceLink.MimeType
+				}
+				log.Debug("acp: resource link loaded", "uri", uri, "mime", mimeType, "size", len(content))
+
+				// Only create FilePart for binary files (images, audio, PDFs, etc.)
+				// Text files are included as formatted text in the message
+				if isTextMimeType(mimeType) || looksLikeText(content) {
+					textParts = append(textParts, fmt.Sprintf("[File: %s]\n```\n%s\n```", uri, string(content)))
+				} else {
+					// Binary file - create FilePart for models that support it
+					files = append(files, kit.LLMFilePart{
+						Filename:  extractFilenameFromURI(uri),
+						Data:      content,
+						MediaType: mimeType,
+					})
+				}
+			} else {
+				// If we can't read it, include as a text reference
+				log.Debug("acp: resource link failed to load", "uri", uri, "error", err)
+				textParts = append(textParts, fmt.Sprintf("[Referenced file: %s]", uri))
+			}
+
+		default:
+			log.Debug("acp: content block", "index", i, "type", "unknown/unhandled")
 		}
 	}
-	return text
+
+	// Debug log the extracted content
+	for i, f := range files {
+		log.Debug("acp: extracted file", "index", i, "filename", f.Filename, "mime", f.MediaType, "size", len(f.Data))
+	}
+
+	return strings.Join(textParts, "\n"), files
+}
+
+// parseThinkingTags parses a text chunk for <thinking> or  tags and separates
+// reasoning content from regular text. This handles models (Qwen, DeepSeek)
+// that wrap reasoning in XML-style tags instead of using proper reasoning events.
+// Returns (reasoningContent, textContent).
+func (a *Agent) parseThinkingTags(chunk string) (reasoning string, text string) {
+	// Handle empty chunk
+	if chunk == "" {
+		return "", ""
+	}
+
+	// Determine which tag format to use (long or short)
+	openTag := thinkingTagOpen
+	closeTag := thinkingTagClose
+
+	if strings.Contains(chunk, shortThinkTagOpen) || strings.Contains(chunk, shortThinkTagClose) {
+		openTag = shortThinkTagOpen
+		closeTag = shortThinkTagClose
+	} else if !strings.Contains(chunk, thinkingTagOpen) && !strings.Contains(chunk, thinkingTagClose) && !a.inThinkingTag {
+		// No tags at all and not in thinking mode - return as text
+		return "", chunk
+	}
+
+	// Check for opening tag
+	if strings.Contains(chunk, openTag) {
+		parts := strings.SplitN(chunk, openTag, 2)
+
+		// Content before the opening tag is regular text
+		if !a.inThinkingTag && parts[0] != "" {
+			text = parts[0]
+		}
+
+		a.inThinkingTag = true
+
+		// Content after the opening tag is reasoning
+		if len(parts) > 1 {
+			// Check if the same chunk contains the closing tag
+			if strings.Contains(parts[1], closeTag) {
+				innerParts := strings.SplitN(parts[1], closeTag, 2)
+				reasoning = innerParts[0]
+				a.inThinkingTag = false
+
+				// Content after closing tag is regular text
+				if len(innerParts) > 1 && innerParts[1] != "" {
+					text += innerParts[1]
+				}
+			} else if parts[1] != "" {
+				// No closing tag yet, all remaining content is reasoning
+				reasoning = parts[1]
+			}
+		}
+		return reasoning, text
+	}
+
+	// Check for closing tag
+	if strings.Contains(chunk, closeTag) {
+		parts := strings.SplitN(chunk, closeTag, 2)
+		a.inThinkingTag = false
+
+		// Content before closing tag is reasoning
+		reasoning = parts[0]
+
+		// Content after closing tag is regular text
+		if len(parts) > 1 && parts[1] != "" {
+			text = parts[1]
+		}
+		return reasoning, text
+	}
+
+	// No tags found - content goes to current mode
+	if a.inThinkingTag {
+		return chunk, ""
+	}
+	return "", chunk
+}
+
+// isTextMimeType returns true if the MIME type indicates text content.
+func isTextMimeType(mimeType string) bool {
+	return strings.HasPrefix(mimeType, "text/") ||
+		mimeType == "application/json" ||
+		mimeType == "application/xml" ||
+		mimeType == "application/javascript" ||
+		mimeType == "application/typescript" ||
+		mimeType == "application/x-sh" ||
+		mimeType == "application/x-python" ||
+		mimeType == "application/x-yaml" ||
+		mimeType == "application/x-toml"
+}
+
+// looksLikeText checks if the content appears to be text (not binary).
+// It samples the first 512 bytes and checks for null bytes or high
+// concentration of non-printable characters.
+func looksLikeText(data []byte) bool {
+	if len(data) == 0 {
+		return true
+	}
+	// Check first 512 bytes (or less if file is smaller)
+	sampleSize := min(len(data), 512)
+	sample := data[:sampleSize]
+
+	// Count non-printable characters
+	nonPrintable := 0
+	for _, b := range sample {
+		// Null byte indicates binary
+		if b == 0 {
+			return false
+		}
+		// Count control characters (except common whitespace)
+		if b < 32 && b != '\n' && b != '\r' && b != '\t' {
+			nonPrintable++
+		}
+	}
+
+	// If more than 30% non-printable, consider it binary
+	return float64(nonPrintable)/float64(sampleSize) < 0.3
+}
+
+// extractFilenameFromURI extracts a filename from a file URI or path.
+func extractFilenameFromURI(uri string) string {
+	// Handle file:// URIs
+	uri = strings.TrimPrefix(uri, "file://")
+	// Extract basename
+	if idx := strings.LastIndex(uri, "/"); idx >= 0 {
+		return uri[idx+1:]
+	}
+	return uri
+}
+
+// readResourceFromURI attempts to read file content from a file:// URI.
+func readResourceFromURI(uri string) ([]byte, error) {
+	if !strings.HasPrefix(uri, "file://") {
+		return nil, fmt.Errorf("unsupported URI scheme: %s", uri)
+	}
+	path := uri[7:] // Remove file:// prefix
+	return os.ReadFile(path)
 }
 
 // parseToolArgs attempts to parse a JSON tool args string into a map for

internal/acpserver/session.go

@@ -62,8 +62,8 @@ func (r *sessionRegistry) create(ctx context.Context, cwd string) (*acpSession,
 	// work in ACP mode. TUI-dependent features (widgets, prompts, editor)
 	// become no-ops or return cancelled; all data/model/tool APIs work
 	// identically to interactive mode.
-	if kitInstance.HasExtensions() {
-		kitInstance.SetExtensionContext(extensions.Context{
+	if kitInstance.Extensions().HasExtensions() {
+		kitInstance.Extensions().SetContext(extensions.Context{
 			SessionID:   sessionID,
 			CWD:         cwd,
 			Model:       kitInstance.GetModelString(),
@@ -121,31 +121,31 @@ func (r *sessionRegistry) create(ctx context.Context, cwd string) (*acpSession,
 					MessageCount:    s.MessageCount,
 				}
 			},
-			GetMessages:    func() []extensions.SessionMessage { return kitInstance.GetSessionMessages() },
-			GetSessionPath: func() string { return kitInstance.GetSessionFilePath() },
+			GetMessages:    func() []extensions.SessionMessage { return kitInstance.Extensions().GetSessionMessages() },
+			GetSessionPath: func() string { return kitInstance.GetSessionPath() },
 			AppendEntry: func(entryType, data string) (string, error) {
-				return kitInstance.AppendExtensionEntry(entryType, data)
+				return kitInstance.Extensions().AppendEntry(entryType, data)
 			},
 			GetEntries: func(entryType string) []extensions.ExtensionEntry {
-				return kitInstance.GetExtensionEntries(entryType)
+				return kitInstance.Extensions().GetEntries(entryType)
 			},
 
 			// Options, model, and tool management.
-			GetOption: func(name string) string { return kitInstance.GetExtensionOption(name) },
-			SetOption: func(name, value string) { kitInstance.SetExtensionOption(name, value) },
+			GetOption: func(name string) string { return kitInstance.Extensions().GetOption(name) },
+			SetOption: func(name, value string) { kitInstance.Extensions().SetOption(name, value) },
 			SetModel: func(modelString string) error {
-				previousModel := kitInstance.GetExtensionContext().Model
+				previousModel := kitInstance.Extensions().GetContext().Model
 				if err := kitInstance.SetModel(context.Background(), modelString); err != nil {
 					return err
 				}
-				kitInstance.UpdateExtensionContextModel(modelString)
-				kitInstance.EmitModelChange(modelString, previousModel, "extension")
+				kitInstance.Extensions().UpdateContextModel(modelString)
+				kitInstance.Extensions().EmitModelChange(modelString, previousModel, "extension")
 				return nil
 			},
 			GetAvailableModels: func() []extensions.ModelInfoEntry { return kitInstance.GetAvailableModels() },
-			EmitCustomEvent:    func(name, data string) { kitInstance.EmitExtensionCustomEvent(name, data) },
-			GetAllTools:        func() []extensions.ToolInfo { return kitInstance.GetExtensionToolInfos() },
-			SetActiveTools:     func(names []string) { kitInstance.SetExtensionActiveTools(names) },
+			EmitCustomEvent:    func(name, data string) { kitInstance.Extensions().EmitCustomEvent(name, data) },
+			GetAllTools:        func() []extensions.ToolInfo { return kitInstance.Extensions().GetToolInfos() },
+			SetActiveTools:     func(names []string) { kitInstance.Extensions().SetActiveTools(names) },
 
 			// LLM completions and subagents.
 			Complete: func(req extensions.CompleteRequest) (extensions.CompleteResponse, error) {
@@ -173,7 +173,7 @@ func (r *sessionRegistry) create(ctx context.Context, cwd string) (*acpSession,
 				}
 				extResult := &extensions.SubagentResult{
 					Response:  result.Response,
-					Error:     result.Error,
+					Error:     err,
 					SessionID: result.SessionID,
 					Elapsed:   result.Elapsed,
 				}
@@ -188,15 +188,15 @@ func (r *sessionRegistry) create(ctx context.Context, cwd string) (*acpSession,
 
 			// Render — fall back to logging.
 			RenderMessage: func(name, content string) {
-				renderer := kitInstance.GetExtensionMessageRenderer(name)
+				renderer := kitInstance.Extensions().GetMessageRenderer(name)
 				if renderer != nil && renderer.Render != nil {
 					content = renderer.Render(content, 80)
 				}
 				log.Info("extension: message", "renderer", name, "content", content)
 			},
-			ReloadExtensions: func() error { return kitInstance.ReloadExtensions() },
+			ReloadExtensions: func() error { return kitInstance.Extensions().Reload() },
 		})
-		kitInstance.EmitSessionStart()
+		kitInstance.Extensions().EmitSessionStart()
 	}
 
 	sess := &acpSession{

internal/agent/agent.go

@@ -31,7 +31,7 @@ type AgentConfig struct {
 	CoreTools []fantasy.AgentTool
 
 	// ToolWrapper is an optional function that wraps the combined tool list
-	// before it is passed to the Fantasy agent. Used by the extensions system
+	// before it is passed to the LLM agent. Used by the extensions system
 	// to intercept tool calls/results.
 	ToolWrapper func([]fantasy.AgentTool) []fantasy.AgentTool
 
@@ -75,9 +75,9 @@ type ToolOutputHandler = core.ToolOutputCallback
 // tracking during long-running tool-calling conversations.
 type StepUsageHandler func(inputTokens, outputTokens, cacheReadTokens, cacheCreationTokens int64)
 
-// Agent represents an AI agent with core tool integration using the fantasy library.
+// Agent represents an AI agent with core tool integration using the LLM library.
 // Core tools (bash, read, write, edit, grep, find, ls) are registered as direct
-// fantasy.AgentTool implementations — no MCP layer, no serialization overhead.
+// AgentTool implementations — no MCP layer, no serialization overhead.
 // Additional tools from external MCP servers can be loaded alongside core tools.
 type Agent struct {
 	toolManager      *tools.MCPToolManager
@@ -100,7 +100,7 @@ type GenerateWithLoopResult struct {
 	FinalResponse *fantasy.Response
 	// ConversationMessages contains all messages in the conversation including tool calls and results
 	ConversationMessages []fantasy.Message
-	// Messages contains the conversation as custom content blocks (crush-style)
+	// Messages contains the conversation as custom content blocks
 	Messages []message.Message
 	// TotalUsage contains aggregate token usage across all steps
 	TotalUsage fantasy.Usage
@@ -112,13 +112,13 @@ type GenerateWithLoopResult struct {
 // Core tools (bash, read, write, edit, grep, find, ls) are always registered.
 // External MCP tools are loaded from the config if any MCP servers are configured.
 func NewAgent(ctx context.Context, agentConfig *AgentConfig) (*Agent, error) {
-	// Create the LLM provider via fantasy
+	// Create the LLM provider
 	providerResult, err := models.CreateProvider(ctx, agentConfig.ModelConfig)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create model provider: %v", err)
 	}
 
-	// Register core tools (direct fantasy implementations, no MCP overhead).
+	// Register core tools (direct AgentTool implementations, no MCP overhead).
 	// Use caller-provided tools if set, otherwise default to all core tools.
 	coreTools := agentConfig.CoreTools
 	if len(coreTools) == 0 {
@@ -158,7 +158,7 @@ func NewAgent(ctx context.Context, agentConfig *AgentConfig) (*Agent, error) {
 		allTools = agentConfig.ToolWrapper(allTools)
 	}
 
-	// Build fantasy agent options
+	// Build agent options
 	var agentOpts []fantasy.AgentOption
 
 	if agentConfig.SystemPrompt != "" {
@@ -198,7 +198,7 @@ func NewAgent(ctx context.Context, agentConfig *AgentConfig) (*Agent, error) {
 		}
 	}
 
-	// Create the fantasy agent
+	// Create the agent
 	fantasyAgent := fantasy.NewAgent(providerResult.Model, agentOpts...)
 
 	// Determine provider type from model string
@@ -234,8 +234,8 @@ func (a *Agent) GenerateWithLoop(ctx context.Context, messages []fantasy.Message
 		onResponse, onToolCallContent, nil, nil, nil, nil)
 }
 
-// GenerateWithLoopAndStreaming processes messages using the fantasy agent with streaming and callbacks.
-// Fantasy handles the tool call loop internally. We map fantasy's rich callback system
+// GenerateWithLoopAndStreaming processes messages using the agent with streaming and callbacks.
+// The agent handles the tool call loop internally. We map the rich callback system
 // to kit's existing callback interface for UI integration.
 func (a *Agent) GenerateWithLoopAndStreaming(ctx context.Context, messages []fantasy.Message,
 	onToolCall ToolCallHandler, onToolExecution ToolExecutionHandler, onToolResult ToolResultHandler,
@@ -251,17 +251,21 @@ func (a *Agent) GenerateWithLoopAndStreaming(ctx context.Context, messages []fan
 		ctx = core.ContextWithToolOutputCallback(ctx, onToolOutput)
 	}
 
-	// Fantasy requires the current user input as Prompt, with prior messages as history.
+	// The agent requires the current user input as Prompt, with prior messages as history.
 	// Extract the last user message text and files as the prompt, and pass everything
 	// before it as Messages. Files (e.g. clipboard images) are passed via the Files
-	// field so Fantasy includes them in the API request.
+	// field so the agent includes them in the API request.
 	prompt, files, history := splitPromptAndHistory(messages)
 
+	// Apply message-level cache control for Anthropic models.
+	// This avoids type conflicts with provider-level options.
+	history = applyCacheControlToMessages(history)
+
 	// Track current tool call args for callbacks
 	var currentToolArgs string
 
 	// Use the streaming path when streaming is enabled OR when any callbacks are
-	// provided. Fantasy only exposes tool/step callbacks on AgentStreamCall, so
+	// provided. The agent only exposes tool/step callbacks on AgentStreamCall, so
 	// Stream is required to observe tool execution in real time. The non-streaming
 	// Generate path is reserved for the simple case with no callbacks at all.
 	hasCallbacks := onToolCall != nil || onToolExecution != nil || onToolResult != nil ||
@@ -269,12 +273,12 @@ func (a *Agent) GenerateWithLoopAndStreaming(ctx context.Context, messages []fan
 
 	if a.streamingEnabled || hasCallbacks {
 		// Track completed step messages so we can return partial results
-		// on cancellation. Fantasy's Stream() discards accumulated steps
+		// on cancellation. The agent's Stream() discards accumulated steps
 		// when it returns an error, but the OnStepFinish callback fires
 		// for every step that completed before the error occurred.
 		var completedStepMessages []fantasy.Message
 
-		// Use fantasy's streaming agent
+		// Use the streaming agent
 		streamCall := fantasy.AgentStreamCall{
 			Prompt:   prompt,
 			Files:    files,
@@ -403,6 +407,11 @@ func (a *Agent) GenerateWithLoopAndStreaming(ctx context.Context, messages []fan
 						onConsumed(len(steered))
 					}
 				}
+
+				// Apply message-level cache control for Anthropic models.
+				// This avoids type conflicts with provider-level options.
+				result.Messages = applyCacheControlToMessages(result.Messages)
+
 				return stepCtx, result, nil
 			}
 		}
@@ -454,7 +463,7 @@ func (a *Agent) GenerateWithLoopAndStreaming(ctx context.Context, messages []fan
 }
 
 // splitPromptAndHistory extracts the last user message as the prompt string,
-// and returns everything before it as conversation history. Fantasy's agent
+// and returns everything before it as conversation history. The agent's
 // requires the current turn's input as Prompt (string), with prior messages
 // passed separately as Messages (history).
 func splitPromptAndHistory(messages []fantasy.Message) (string, []fantasy.FilePart, []fantasy.Message) {
@@ -497,8 +506,8 @@ func splitPromptAndHistory(messages []fantasy.Message) (string, []fantasy.FilePa
 	return "", nil, messages
 }
 
-// convertAgentResult converts a fantasy AgentResult to our GenerateWithLoopResult.
-// It builds both the legacy fantasy.Message slice and the new custom content blocks.
+// convertAgentResult converts an AgentResult to our GenerateWithLoopResult.
+// It builds both the message slice and the new custom content blocks.
 func convertAgentResult(result *fantasy.AgentResult, originalMessages []fantasy.Message) *GenerateWithLoopResult {
 	// Collect all conversation messages: original + all step messages
 	var allFantasyMessages []fantasy.Message
@@ -511,7 +520,7 @@ func convertAgentResult(result *fantasy.AgentResult, originalMessages []fantasy.
 	// Convert to custom content blocks
 	var allMessages []message.Message
 	for _, fm := range allFantasyMessages {
-		allMessages = append(allMessages, message.FromFantasyMessage(fm))
+		allMessages = append(allMessages, message.FromLLMMessage(fm))
 	}
 
 	return &GenerateWithLoopResult{
@@ -523,7 +532,7 @@ func convertAgentResult(result *fantasy.AgentResult, originalMessages []fantasy.
 	}
 }
 
-// extractToolResultText extracts the text and error status from a fantasy ToolResultContent.
+// extractToolResultText extracts the text and error status from a ToolResultContent.
 // For core tools, the result is already clean text (no MCP JSON wrapping).
 // For MCP tools, it unwraps the MCP content structure.
 func extractToolResultText(tr fantasy.ToolResultContent) (string, bool) {
@@ -536,7 +545,7 @@ func extractToolResultText(tr fantasy.ToolResultContent) (string, bool) {
 		return errResult.Error.Error(), true
 	}
 
-	// Get text directly from the Fantasy result type.
+	// Get text directly from the result type.
 	if textResult, ok := tr.Result.(fantasy.ToolResultOutputContentText); ok {
 		// Try to unwrap MCP JSON structure (for external MCP tools).
 		// Core tools return plain text, so this is a no-op for them.
@@ -649,7 +658,7 @@ func (a *Agent) SetModel(ctx context.Context, config *models.ProviderConfig) err
 		allTools = a.toolWrapper(allTools)
 	}
 
-	// Rebuild fantasy agent options.
+	// Rebuild agent options.
 	var agentOpts []fantasy.AgentOption
 	if a.systemPrompt != "" {
 		agentOpts = append(agentOpts, fantasy.WithSystemPrompt(a.systemPrompt))
@@ -710,7 +719,7 @@ func (a *Agent) SetModel(ctx context.Context, config *models.ProviderConfig) err
 	return nil
 }
 
-// GetModel returns the underlying fantasy LanguageModel.
+// GetModel returns the underlying LanguageModel.
 func (a *Agent) GetModel() fantasy.LanguageModel {
 	return a.model
 }

internal/agent/cache_control.go

@@ -0,0 +1,84 @@
+package agent
+
+import (
+	"charm.land/fantasy"
+	"charm.land/fantasy/providers/anthropic"
+)
+
+// cacheControlOptions returns provider options for Anthropic cache control.
+// This is used at the message level to avoid type conflicts with provider-level options.
+func cacheControlOptions() fantasy.ProviderOptions {
+	return anthropic.NewProviderCacheControlOptions(&anthropic.ProviderCacheControlOptions{
+		CacheControl: anthropic.CacheControl{
+			Type: "ephemeral",
+		},
+	})
+}
+
+// applyCacheControlToMessages adds cache control to specific messages.
+// Anthropic allows max 4 cache blocks per request.
+// Counts existing cache blocks and only adds new ones up to the limit.
+func applyCacheControlToMessages(messages []fantasy.Message) []fantasy.Message {
+	if len(messages) == 0 {
+		return messages
+	}
+
+	// Make a copy to avoid modifying the original slice
+	result := make([]fantasy.Message, len(messages))
+	copy(result, messages)
+
+	cacheOpts := cacheControlOptions()
+	maxCacheBlocks := 4
+
+	// Helper to check if message already has cache control
+	hasCache := func(msg fantasy.Message) bool {
+		if msg.ProviderOptions == nil {
+			return false
+		}
+		if _, ok := msg.ProviderOptions["anthropic"]; ok {
+			return true
+		}
+		return false
+	}
+
+	// Count existing cache blocks
+	existingCacheCount := 0
+	for _, msg := range result {
+		if hasCache(msg) {
+			existingCacheCount++
+		}
+	}
+
+	// If we're already at or over the limit, don't add more
+	if existingCacheCount >= maxCacheBlocks {
+		return result
+	}
+
+	// How many new cache blocks can we add?
+	remaining := maxCacheBlocks - existingCacheCount
+
+	// First: find and cache the last system message (most important)
+	lastSystemIdx := -1
+	for i, msg := range result {
+		if msg.Role == fantasy.MessageRoleSystem {
+			lastSystemIdx = i
+		}
+	}
+
+	if lastSystemIdx >= 0 && remaining > 0 && !hasCache(result[lastSystemIdx]) {
+		result[lastSystemIdx].ProviderOptions = cacheOpts
+		remaining--
+	}
+
+	// Second: cache the most recent messages (up to remaining limit)
+	// Work backwards from the end to prioritize recent context
+	for i := len(result) - 1; i >= 0 && remaining > 0; i-- {
+		if hasCache(result[i]) {
+			continue
+		}
+		result[i].ProviderOptions = cacheOpts
+		remaining--
+	}
+
+	return result
+}

internal/agent/factory.go

@@ -39,7 +39,7 @@ type AgentCreationOptions struct {
 	// CoreTools overrides the default core tool set. If empty, core.AllTools()
 	// is used.
 	CoreTools []fantasy.AgentTool
-	// ToolWrapper wraps the combined tool list before Fantasy agent creation.
+	// ToolWrapper wraps the combined tool list before agent creation.
 	ToolWrapper func([]fantasy.AgentTool) []fantasy.AgentTool
 	// ExtraTools are additional tools to include (e.g. from extensions).
 	ExtraTools []fantasy.AgentTool

internal/app/app.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"sync"
 	"sync/atomic"
+	"time"
 
 	tea "charm.land/bubbletea/v2"
 	"charm.land/fantasy"
@@ -19,7 +20,7 @@ import (
 // queueItem holds a prompt and optional image attachments for the execution queue.
 type queueItem struct {
 	Prompt string
-	Files  []fantasy.FilePart
+	Files  []kit.LLMFilePart
 }
 
 // App is the application-layer orchestrator. It owns the agentic loop,
@@ -68,11 +69,20 @@ type App struct {
 	// rootCtx/rootCancel are used to signal shutdown to all goroutines.
 	rootCtx    context.Context
 	rootCancel context.CancelFunc
+
+	// widgetUpdatePending is set to true when a WidgetUpdateEvent has been
+	// sent to the TUI but not yet consumed by its event loop. While the flag
+	// is set, subsequent NotifyWidgetUpdate calls are coalesced (dropped) to
+	// prevent fast extension tickers from flooding the BubbleTea mailbox with
+	// redundant re-render triggers. The flag is cleared after a short debounce
+	// (~1 frame) so new updates are always let through once the TUI has had a
+	// chance to process the pending event.
+	widgetUpdatePending atomic.Bool
 }
 
 // New creates a new App with the provided options and pre-loaded messages.
 // initialMessages may be nil or empty for a fresh session.
-func New(opts Options, initialMessages []fantasy.Message) *App {
+func New(opts Options, initialMessages []kit.LLMMessage) *App {
 	rootCtx, rootCancel := context.WithCancel(context.Background())
 	return &App{
 		opts:       opts,
@@ -116,9 +126,8 @@ func (a *App) Run(prompt string) int {
 // If the app is idle the prompt executes immediately; otherwise it is queued.
 // Returns the current queue depth (0 = started immediately, >0 = queued).
 //
-// Satisfies ui.AppController (via RunWithImages which converts ImageAttachment
-// to fantasy.FilePart).
-func (a *App) RunWithFiles(prompt string, files []fantasy.FilePart) int {
+// Satisfies ui.AppController.
+func (a *App) RunWithFiles(prompt string, files []kit.LLMFilePart) int {
 	a.mu.Lock()
 
 	if a.closed {
@@ -261,6 +270,17 @@ func (a *App) ClearMessages() {
 	}
 }
 
+// ReloadMessagesFromTree clears the in-memory message store and reloads it
+// from the tree session's current branch. Unlike ClearMessages, this does NOT
+// reset the tree session's leaf pointer. Used after Branch() to sync the
+// store with the new branch position.
+func (a *App) ReloadMessagesFromTree() {
+	a.store.Clear()
+	if a.opts.TreeSession != nil {
+		a.store.Replace(a.opts.TreeSession.GetLLMMessages())
+	}
+}
+
 // GetTreeSession returns the tree session manager, or nil if not configured.
 func (a *App) GetTreeSession() *session.TreeManager {
 	return a.opts.TreeSession
@@ -282,7 +302,7 @@ func (a *App) SwitchTreeSession(ts *session.TreeManager) {
 	// Reload messages from new session.
 	a.store.Clear()
 	if ts != nil {
-		a.store.Replace(ts.GetFantasyMessages())
+		a.store.Replace(ts.GetLLMMessages())
 	}
 }
 
@@ -293,12 +313,12 @@ func (a *App) SwitchTreeSession(ts *session.TreeManager) {
 //
 // Satisfies ui.AppController.
 func (a *App) AddContextMessage(text string) {
-	msg := fantasy.NewUserMessage(text)
-	a.store.Add(msg)
+	kitMsg := fantasy.NewUserMessage(text)
+	a.store.Add(kitMsg)
 
 	// Persist to tree session if active.
 	if ts := a.opts.TreeSession; ts != nil {
-		_, _ = ts.AppendFantasyMessage(msg)
+		_, _ = ts.AppendLLMMessage(fantasy.NewUserMessage(text))
 	}
 }
 
@@ -336,6 +356,15 @@ func (a *App) CompactConversation(customInstructions string) error {
 			a.mu.Unlock()
 		}()
 
+		// Subscribe to SDK events for streaming compaction summary to the TUI.
+		sendFn := func(msg tea.Msg) {
+			if a.program != nil {
+				a.program.Send(msg)
+			}
+		}
+		unsub := a.subscribeSDKEvents(sendFn, nil)
+		defer unsub()
+
 		result, err := a.opts.Kit.Compact(a.rootCtx, nil, customInstructions)
 		if err != nil {
 			a.sendEvent(CompactErrorEvent{Err: err})
@@ -348,7 +377,7 @@ func (a *App) CompactConversation(customInstructions string) error {
 
 		// Sync in-memory store with the compacted session.
 		if a.opts.TreeSession != nil {
-			a.store.Replace(a.opts.TreeSession.GetFantasyMessages())
+			a.store.Replace(a.opts.TreeSession.GetLLMMessages())
 		}
 
 		a.sendEvent(CompactCompleteEvent{
@@ -485,11 +514,10 @@ func (a *App) drainQueue(first queueItem) {
 		a.mu.Lock()
 		items = append(items, a.queue...)
 		a.queue = a.queue[:0] // Clear the queue
-		queueLen := len(a.queue)
 		a.mu.Unlock()
 
-		// Send queue updated event (queue is now empty)
-		a.sendEvent(QueueUpdatedEvent{Length: queueLen})
+		// Notify UI: all queued messages have been consumed into this batch.
+		a.sendEvent(QueueUpdatedEvent{Length: 0})
 
 		// Process all collected items as a single batch
 		a.runQueueBatch(items)
@@ -522,6 +550,11 @@ func (a *App) drainQueue(first queueItem) {
 		}
 		a.mu.Unlock()
 
+		if hasMore {
+			// Notify UI: these newly queued messages have been consumed into the next batch.
+			a.sendEvent(QueueUpdatedEvent{Length: 0})
+		}
+
 		if !hasMore {
 			// No more items, we're done
 			break
@@ -569,7 +602,7 @@ func (a *App) runQueueBatch(items []queueItem) {
 			// call/result pairs; only the in-progress message or tool
 			// call is discarded. Sync the in-memory store to match.
 			if ts := a.opts.TreeSession; ts != nil {
-				a.store.Replace(ts.GetFantasyMessages())
+				a.store.Replace(ts.GetLLMMessages())
 			}
 			a.sendEvent(StepCancelledEvent{})
 			return
@@ -588,7 +621,7 @@ func (a *App) runQueueBatch(items []queueItem) {
 // executeStep runs a single agentic step by delegating to the SDK's
 // PromptResult() (or PromptResultWithFiles for multimodal), which handles
 // session persistence, hooks, extension events, and the generation loop.
-func (a *App) executeStep(ctx context.Context, prompt string, eventFn func(tea.Msg), files []fantasy.FilePart) (*kit.TurnResult, error) {
+func (a *App) executeStep(ctx context.Context, prompt string, eventFn func(tea.Msg), files []kit.LLMFilePart) (*kit.TurnResult, error) {
 	// Test hook: bypass SDK entirely.
 	if a.opts.PromptFunc != nil {
 		return a.opts.PromptFunc(ctx, prompt)
@@ -834,12 +867,32 @@ func (a *App) NotifyModelChanged(provider, model string) {
 // NotifyWidgetUpdate sends a WidgetUpdateEvent to the TUI so it re-renders
 // extension widgets. Called from the extension context's SetWidget/RemoveWidget
 // closures. In non-interactive mode this is a no-op (widgets are TUI-only).
+//
+// Coalescing: if a WidgetUpdateEvent is already queued and not yet consumed
+// by the TUI event loop, additional calls within the same ~16 ms window are
+// dropped. This prevents fast extension tickers from flooding BubbleTea's
+// mailbox with redundant re-render triggers.
 func (a *App) NotifyWidgetUpdate() {
+	// Coalesce: only one pending update at a time.
+	if !a.widgetUpdatePending.CompareAndSwap(false, true) {
+		return
+	}
 	a.mu.Lock()
 	prog := a.program
 	a.mu.Unlock()
 	if prog != nil {
 		prog.Send(WidgetUpdateEvent{})
+		// Reset the pending flag after a short debounce so subsequent calls
+		// within the same render cycle are also coalesced, but new updates
+		// after the cycle are allowed through.
+		go func() {
+			time.Sleep(16 * time.Millisecond) // ~1 frame at 60 fps
+			a.widgetUpdatePending.Store(false)
+		}()
+	} else {
+		// No program registered (non-interactive mode); clear the flag so
+		// future calls are never permanently blocked.
+		a.widgetUpdatePending.Store(false)
 	}
 }
 

internal/app/app_test.go

@@ -7,8 +7,6 @@ import (
 	"testing"
 	"time"
 
-	"charm.land/fantasy"
-
 	kit "github.com/mark3labs/kit/pkg/kit"
 )
 
@@ -574,13 +572,13 @@ func TestUpdateUsageFromTurnResult_skipsTotalsWhenStepUsageSeen(t *testing.T) {
 
 	app.updateUsageFromTurnResult(&kit.TurnResult{
 		Response: "ok",
-		TotalUsage: &fantasy.Usage{
+		TotalUsage: &kit.LLMUsage{
 			InputTokens:         999,
 			OutputTokens:        111,
 			CacheReadTokens:     7,
 			CacheCreationTokens: 3,
 		},
-		FinalUsage: &fantasy.Usage{InputTokens: 456},
+		FinalUsage: &kit.LLMUsage{InputTokens: 456},
 	}, "prompt", true)
 
 	usage.mu.Lock()
@@ -608,13 +606,13 @@ func TestUpdateUsageFromTurnResult_recordsWhenInputTokensZero(t *testing.T) {
 	// Simulate OpenAI-compatible behavior: all prompt tokens cached, InputTokens=0
 	app.updateUsageFromTurnResult(&kit.TurnResult{
 		Response: "ok",
-		TotalUsage: &fantasy.Usage{
+		TotalUsage: &kit.LLMUsage{
 			InputTokens:         0,   // All cached - subtracted from prompt
 			OutputTokens:        150, // Actual generated tokens
 			CacheReadTokens:     500, // Cache hit
 			CacheCreationTokens: 0,
 		},
-		FinalUsage: &fantasy.Usage{InputTokens: 0, OutputTokens: 150},
+		FinalUsage: &kit.LLMUsage{InputTokens: 0, OutputTokens: 150},
 	}, "prompt", false)
 
 	usage.mu.Lock()
@@ -642,11 +640,11 @@ func TestUpdateUsageFromTurnResult_contextTokensUsesInputOnly(t *testing.T) {
 
 	app.updateUsageFromTurnResult(&kit.TurnResult{
 		Response: "ok",
-		TotalUsage: &fantasy.Usage{
+		TotalUsage: &kit.LLMUsage{
 			InputTokens:  1000,
 			OutputTokens: 200,
 		},
-		FinalUsage: &fantasy.Usage{
+		FinalUsage: &kit.LLMUsage{
 			InputTokens:  1000, // Full context including history
 			OutputTokens: 200,
 		},

internal/app/events.go

@@ -1,6 +1,6 @@
 package app
 
-import "charm.land/fantasy"
+import kit "github.com/mark3labs/kit/pkg/kit"
 
 // StreamChunkEvent is sent by the app layer when a streaming text delta arrives
 // from the LLM. Each chunk contains an incremental portion of the response.
@@ -118,8 +118,8 @@ type SpinnerEvent struct {
 // MessageCreatedEvent is sent when a new message is added to the message store.
 // This allows the TUI to stay in sync with the conversation history.
 type MessageCreatedEvent struct {
-	// Message is the fantasy message that was added to the store.
-	Message fantasy.Message
+	// Message is the message that was added to the store.
+	Message kit.LLMMessage
 }
 
 // CompactCompleteEvent is sent when a /compact operation finishes successfully.

internal/app/messages.go

@@ -3,14 +3,14 @@ package app
 import (
 	"sync"
 
-	"charm.land/fantasy"
+	kit "github.com/mark3labs/kit/pkg/kit"
 )
 
 // MessageStore is a thread-safe in-memory store for the conversation history.
 // On-disk persistence is handled by the TreeManager at the app/SDK layer.
 type MessageStore struct {
 	mu       sync.RWMutex
-	messages []fantasy.Message
+	messages []kit.LLMMessage
 }
 
 // NewMessageStore creates an empty MessageStore.
@@ -20,14 +20,14 @@ func NewMessageStore() *MessageStore {
 
 // NewMessageStoreWithMessages creates a MessageStore pre-populated with the
 // given messages. This is used when loading an existing session at startup.
-func NewMessageStoreWithMessages(msgs []fantasy.Message) *MessageStore {
-	cp := make([]fantasy.Message, len(msgs))
+func NewMessageStoreWithMessages(msgs []kit.LLMMessage) *MessageStore {
+	cp := make([]kit.LLMMessage, len(msgs))
 	copy(cp, msgs)
 	return &MessageStore{messages: cp}
 }
 
 // Add appends a single message to the store.
-func (s *MessageStore) Add(msg fantasy.Message) {
+func (s *MessageStore) Add(msg kit.LLMMessage) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.messages = append(s.messages, msg)
@@ -36,22 +36,22 @@ func (s *MessageStore) Add(msg fantasy.Message) {
 // Replace replaces the entire message history with the given slice. This is
 // used after an agent step returns the full updated conversation (including
 // tool calls and results).
-func (s *MessageStore) Replace(msgs []fantasy.Message) {
+func (s *MessageStore) Replace(msgs []kit.LLMMessage) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
-	cp := make([]fantasy.Message, len(msgs))
+	cp := make([]kit.LLMMessage, len(msgs))
 	copy(cp, msgs)
 	s.messages = cp
 }
 
 // GetAll returns a snapshot copy of the current message slice.
 // The returned slice is safe to modify without affecting the store.
-func (s *MessageStore) GetAll() []fantasy.Message {
+func (s *MessageStore) GetAll() []kit.LLMMessage {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
-	cp := make([]fantasy.Message, len(s.messages))
+	cp := make([]kit.LLMMessage, len(s.messages))
 	copy(cp, s.messages)
 	return cp
 }

internal/app/messages_test.go

@@ -4,16 +4,29 @@ import (
 	"testing"
 
 	"charm.land/fantasy"
+
+	kit "github.com/mark3labs/kit/pkg/kit"
 )
 
-// makeTextMsg builds a minimal fantasy.Message with a single TextPart.
-func makeTextMsg(role, text string) fantasy.Message {
-	return fantasy.Message{
-		Role:    fantasy.MessageRole(role),
+// makeTextMsg builds a minimal kit.LLMMessage using fantasy.NewUserMessage
+// or constructing with the given role.
+func makeTextMsg(role, text string) kit.LLMMessage {
+	return kit.LLMMessage{
+		Role:    kit.LLMMessageRole(role),
 		Content: []fantasy.MessagePart{fantasy.TextPart{Text: text}},
 	}
 }
 
+// textOf extracts the plain text from an LLMMessage for assertions.
+func textOf(msg kit.LLMMessage) string {
+	for _, part := range msg.Content {
+		if tp, ok := part.(fantasy.TextPart); ok {
+			return tp.Text
+		}
+	}
+	return ""
+}
+
 // --------------------------------------------------------------------------
 // NewMessageStore / NewMessageStoreWithMessages
 // --------------------------------------------------------------------------
@@ -29,7 +42,7 @@ func TestNewMessageStore_empty(t *testing.T) {
 }
 
 func TestNewMessageStoreWithMessages_preloaded(t *testing.T) {
-	msgs := []fantasy.Message{
+	msgs := []kit.LLMMessage{
 		makeTextMsg("user", "hello"),
 		makeTextMsg("assistant", "hi"),
 	}
@@ -42,7 +55,7 @@ func TestNewMessageStoreWithMessages_preloaded(t *testing.T) {
 // NewMessageStoreWithMessages must deep-copy the slice so that external
 // modifications don't affect the store.
 func TestNewMessageStoreWithMessages_isolatesInput(t *testing.T) {
-	msgs := []fantasy.Message{makeTextMsg("user", "hello")}
+	msgs := []kit.LLMMessage{makeTextMsg("user", "hello")}
 	s := NewMessageStoreWithMessages(msgs)
 
 	// Mutate the source slice.
@@ -52,9 +65,8 @@ func TestNewMessageStoreWithMessages_isolatesInput(t *testing.T) {
 	if len(got) != 1 {
 		t.Fatalf("expected 1 message, got %d", len(got))
 	}
-	tp, ok := got[0].Content[0].(fantasy.TextPart)
-	if !ok || tp.Text != "hello" {
-		t.Fatalf("store was mutated by external slice change; got %q", tp.Text)
+	if textOf(got[0]) != "hello" {
+		t.Fatalf("store was mutated by external slice change; got %q", textOf(got[0]))
 	}
 }
 
@@ -80,9 +92,8 @@ func TestAdd_preservesOrder(t *testing.T) {
 	}
 	got := s.GetAll()
 	for i, expected := range texts {
-		tp, ok := got[i].Content[0].(fantasy.TextPart)
-		if !ok || tp.Text != expected {
-			t.Fatalf("message[%d]: expected %q, got %q", i, expected, tp.Text)
+		if textOf(got[i]) != expected {
+			t.Fatalf("message[%d]: expected %q, got %q", i, expected, textOf(got[i]))
 		}
 	}
 }
@@ -95,7 +106,7 @@ func TestReplace_swapsHistory(t *testing.T) {
 	s := NewMessageStore()
 	s.Add(makeTextMsg("user", "old"))
 
-	replacement := []fantasy.Message{
+	replacement := []kit.LLMMessage{
 		makeTextMsg("user", "new1"),
 		makeTextMsg("assistant", "new2"),
 	}
@@ -105,25 +116,22 @@ func TestReplace_swapsHistory(t *testing.T) {
 		t.Fatalf("expected 2 messages after replace, got %d", s.Len())
 	}
 	got := s.GetAll()
-	tp0, _ := got[0].Content[0].(fantasy.TextPart)
-	tp1, _ := got[1].Content[0].(fantasy.TextPart)
-	if tp0.Text != "new1" || tp1.Text != "new2" {
-		t.Fatalf("unexpected messages after replace: %q %q", tp0.Text, tp1.Text)
+	if textOf(got[0]) != "new1" || textOf(got[1]) != "new2" {
+		t.Fatalf("unexpected messages after replace: %q %q", textOf(got[0]), textOf(got[1]))
 	}
 }
 
 // Replace must deep-copy the incoming slice.
 func TestReplace_isolatesInput(t *testing.T) {
 	s := NewMessageStore()
-	replacement := []fantasy.Message{makeTextMsg("user", "original")}
+	replacement := []kit.LLMMessage{makeTextMsg("user", "original")}
 	s.Replace(replacement)
 
 	replacement[0] = makeTextMsg("user", "mutated")
 
 	got := s.GetAll()
-	tp, _ := got[0].Content[0].(fantasy.TextPart)
-	if tp.Text != "original" {
-		t.Fatalf("store was mutated by external slice change after Replace; got %q", tp.Text)
+	if textOf(got[0]) != "original" {
+		t.Fatalf("store was mutated by external slice change after Replace; got %q", textOf(got[0]))
 	}
 }
 
@@ -140,9 +148,8 @@ func TestGetAll_returnsCopy(t *testing.T) {
 	got[0] = makeTextMsg("user", "mutated")
 
 	internal := s.GetAll()
-	tp, _ := internal[0].Content[0].(fantasy.TextPart)
-	if tp.Text != "hello" {
-		t.Fatalf("GetAll returned non-copy; store was mutated to %q", tp.Text)
+	if textOf(internal[0]) != "hello" {
+		t.Fatalf("GetAll returned non-copy; store was mutated to %q", textOf(internal[0]))
 	}
 }
 
@@ -179,9 +186,8 @@ func TestClear_allowsSubsequentAdds(t *testing.T) {
 		t.Fatalf("expected 1 message after Clear+Add, got %d", s.Len())
 	}
 	got := s.GetAll()
-	tp, _ := got[0].Content[0].(fantasy.TextPart)
-	if tp.Text != "after" {
-		t.Fatalf("expected %q, got %q", "after", tp.Text)
+	if textOf(got[0]) != "after" {
+		t.Fatalf("expected %q, got %q", "after", textOf(got[0]))
 	}
 }
 

internal/app/options.go

@@ -67,10 +67,6 @@ type Options struct {
 	// Debug enables verbose debug logging.
 	Debug bool
 
-	// CompactMode selects the compact renderer instead of the block renderer for
-	// message formatting.
-	CompactMode bool
-
 	// UsageTracker is an optional callback for recording token usage after each
 	// agent step. When non-nil, the app layer calls UpdateUsage (or
 	// EstimateAndUpdateUsage as a fallback) using the usage data returned by the

internal/compaction/compaction.go

@@ -428,6 +428,10 @@ type PreviousCompaction struct {
 	ModifiedFiles []string
 }
 
+// StreamCallback is called for each chunk of text during streaming compaction.
+// Return a non-nil error to cancel the stream.
+type StreamCallback func(delta string) error
+
 // Compact summarises older messages using the LLM, returning the compaction
 // result and a new message slice (summary message + preserved recent
 // messages).
@@ -442,6 +446,8 @@ type PreviousCompaction struct {
 //
 // prev carries file tracking from a previous compaction for cumulative
 // tracking. Pass nil if there is no prior compaction.
+// onChunk is an optional callback for streaming summary text. Pass nil for
+// non-streaming compaction.
 func Compact(
 	ctx context.Context,
 	model fantasy.LanguageModel,
@@ -449,6 +455,7 @@ func Compact(
 	opts CompactionOptions,
 	customInstructions string,
 	prev *PreviousCompaction,
+	onChunk StreamCallback,
 ) (*CompactionResult, []fantasy.Message, error) {
 	opts.defaults()
 
@@ -487,9 +494,9 @@ func Compact(
 	var err error
 
 	if IsSplitTurn(messages, cutPoint) {
-		summaryText, err = compactSplitTurn(ctx, model, oldMessages, messages, cutPoint, opts, customInstructions)
+		summaryText, err = compactSplitTurn(ctx, model, oldMessages, messages, cutPoint, opts, customInstructions, onChunk)
 	} else {
-		summaryText, err = compactNormal(ctx, model, oldMessages, opts, customInstructions)
+		summaryText, err = compactNormal(ctx, model, oldMessages, opts, customInstructions, onChunk)
 	}
 	if err != nil {
 		return nil, nil, err
@@ -527,15 +534,17 @@ func Compact(
 }
 
 // compactNormal generates a summary for a clean turn-boundary cut.
+// If onChunk is provided, text deltas are streamed to it.
 func compactNormal(
 	ctx context.Context,
 	model fantasy.LanguageModel,
 	oldMessages []fantasy.Message,
 	opts CompactionOptions,
 	customInstructions string,
+	onChunk StreamCallback,
 ) (string, error) {
 	conversationText := serializeMessages(oldMessages)
-	return generateSummary(ctx, model, conversationText, opts, customInstructions)
+	return generateSummary(ctx, model, conversationText, opts, customInstructions, onChunk)
 }
 
 // compactSplitTurn handles the case where the cut point lands mid-turn.
@@ -546,6 +555,7 @@ func compactNormal(
 //
 // The merged result preserves context from both the older history and the
 // beginning of the current long turn.
+// If onChunk is provided, both summaries and the separator are streamed.
 func compactSplitTurn(
 	ctx context.Context,
 	model fantasy.LanguageModel,
@@ -554,6 +564,7 @@ func compactSplitTurn(
 	cutPoint int,
 	opts CompactionOptions,
 	customInstructions string,
+	onChunk StreamCallback,
 ) (string, error) {
 	// Find where the split turn starts.
 	turnStart := findTurnStart(allMessages, cutPoint)
@@ -573,12 +584,19 @@ func compactSplitTurn(
 	// Generate history summary if there are complete turns before the split.
 	if len(historyMessages) >= 2 {
 		historySummary, err = generateSummary(ctx, model,
-			serializeMessages(historyMessages), opts, "")
+			serializeMessages(historyMessages), opts, "", onChunk)
 		if err != nil {
 			return "", fmt.Errorf("split turn history summary failed: %w", err)
 		}
 	}
 
+	// Stream the separator between history and turn prefix summaries.
+	if onChunk != nil && historySummary != "" {
+		if err := onChunk("\n\n---\n\n## Current Turn (in progress)\n\n"); err != nil {
+			return "", fmt.Errorf("streaming separator failed: %w", err)
+		}
+	}
+
 	// Generate turn prefix summary.
 	turnPrefixText := serializeMessages(turnPrefixMessages)
 	turnPrefixPrompt := "The messages above are the BEGINNING of a long turn that was split. " +
@@ -588,16 +606,10 @@ func compactSplitTurn(
 		turnPrefixPrompt += "\n\nAdditional instructions: " + customInstructions
 	}
 
-	summaryAgent := fantasy.NewAgent(model,
-		fantasy.WithSystemPrompt(defaultSystemPrompt),
-	)
-	result, err := summaryAgent.Generate(ctx, fantasy.AgentCall{
-		Prompt: turnPrefixText + "\n\n" + turnPrefixPrompt,
-	})
+	turnPrefixSummary, err := generateSummary(ctx, model, turnPrefixText, opts, turnPrefixPrompt, onChunk)
 	if err != nil {
 		return "", fmt.Errorf("split turn prefix summary failed: %w", err)
 	}
-	turnPrefixSummary := result.Response.Content.Text()
 
 	// Merge the two summaries.
 	if historySummary != "" && turnPrefixSummary != "" {
@@ -610,12 +622,14 @@ func compactSplitTurn(
 }
 
 // generateSummary calls the LLM to produce a structured summary.
+// If onChunk is provided, the summary is streamed using Agent.Stream().
 func generateSummary(
 	ctx context.Context,
 	model fantasy.LanguageModel,
 	conversationText string,
 	opts CompactionOptions,
 	customInstructions string,
+	onChunk StreamCallback,
 ) (string, error) {
 	userPrompt := opts.SummaryPrompt
 	if userPrompt == "" {
@@ -628,8 +642,31 @@ func generateSummary(
 	summaryAgent := fantasy.NewAgent(model,
 		fantasy.WithSystemPrompt(defaultSystemPrompt),
 	)
+
+	prompt := conversationText + "\n\n" + userPrompt
+
+	// Use streaming if onChunk is provided.
+	if onChunk != nil {
+		var fullText strings.Builder
+		_, err := summaryAgent.Stream(ctx, fantasy.AgentStreamCall{
+			Prompt: prompt,
+			OnTextDelta: func(_, delta string) error {
+				if delta != "" {
+					fullText.WriteString(delta)
+					return onChunk(delta)
+				}
+				return nil
+			},
+		})
+		if err != nil {
+			return "", fmt.Errorf("compaction summarisation (streaming) failed: %w", err)
+		}
+		return fullText.String(), nil
+	}
+
+	// Non-streaming path.
 	result, err := summaryAgent.Generate(ctx, fantasy.AgentCall{
-		Prompt: conversationText + "\n\n" + userPrompt,
+		Prompt: prompt,
 	})
 	if err != nil {
 		return "", fmt.Errorf("compaction summarisation failed: %w", err)

internal/compaction/compaction_test.go

@@ -243,7 +243,7 @@ func TestCompact_TooFewMessages(t *testing.T) {
 		makeTextMessageN(fantasy.MessageRoleUser, 400),
 	}
 
-	result, newMsgs, err := Compact(context.TODO(), nil, msgs, CompactionOptions{}, "", nil)
+	result, newMsgs, err := Compact(context.TODO(), nil, msgs, CompactionOptions{}, "", nil, nil)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -262,7 +262,7 @@ func TestCompact_WithinBudget(t *testing.T) {
 		makeTextMessageN(fantasy.MessageRoleAssistant, 400),
 	}
 
-	result, newMsgs, err := Compact(context.TODO(), nil, msgs, CompactionOptions{}, "", nil)
+	result, newMsgs, err := Compact(context.TODO(), nil, msgs, CompactionOptions{}, "", nil, nil)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}

internal/config/config.go

@@ -191,7 +191,6 @@ type Config struct {
 	Model          string                     `json:"model,omitempty" yaml:"model,omitempty"`
 	MaxSteps       int                        `json:"max-steps,omitempty" yaml:"max-steps,omitempty"`
 	Debug          bool                       `json:"debug,omitempty" yaml:"debug,omitempty"`
-	Compact        bool                       `json:"compact,omitempty" yaml:"compact,omitempty"`
 	SystemPrompt   string                     `json:"system-prompt,omitempty" yaml:"system-prompt,omitempty"`
 	ProviderAPIKey string                     `json:"provider-api-key,omitempty" yaml:"provider-api-key,omitempty"`
 	ProviderURL    string                     `json:"provider-url,omitempty" yaml:"provider-url,omitempty"`

internal/core/bash.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"os"
 	"os/exec"
+	"regexp"
 	"strings"
 	"sync"
 	"time"
@@ -39,20 +40,8 @@ func toolOutputCallbackFromContext(ctx context.Context) ToolOutputCallback {
 const defaultBashTimeout = 120 * time.Second
 const maxBashTimeout = 600 * time.Second
 
-var bannedCommands = []string{
-	"alias ", "bg ", "bind ", "builtin ",
-	"caller ", "command ", "compgen ",
-	"complete ", "compopt ", "coproc ",
-	"dirs ", "disown ", "enable ",
-	"fc ", "fg ", "hash ", "help ",
-	"history ", "jobs ", "kill ",
-	"logout ", "mapfile ", "popd ",
-	"pushd ", "readonly ", "select ",
-	"set ", "shopt ", "source ",
-	"suspend ", "times ", "trap ",
-	"type ", "typeset ", "ulimit ",
-	"umask ", "unalias ", "wait ",
-}
+// bannedCmdRe matches bash builtin commands that are not allowed for security reasons.
+var bannedCmdRe = regexp.MustCompile(`^(alias|bg|bind|builtin|caller|command|compgen|complete|compopt|coproc|dirs|disown|enable|fc|fg|hash|help|history|jobs|kill|logout|mapfile|popd|pushd|readonly|select|set|shopt|source|suspend|times|trap|type|typeset|ulimit|umask|unalias|wait)\s`)
 
 type bashArgs struct {
 	Command string  `json:"command"`
@@ -94,10 +83,8 @@ func executeBash(ctx context.Context, call fantasy.ToolCall, workDir string) (fa
 	}
 
 	// Check for banned commands
-	for _, banned := range bannedCommands {
-		if strings.HasPrefix(args.Command, banned) {
-			return fantasy.NewTextErrorResponse(fmt.Sprintf("command '%s' is not allowed", args.Command)), nil
-		}
+	if bannedCmdRe.MatchString(args.Command) {
+		return fantasy.NewTextErrorResponse(fmt.Sprintf("command '%s' is not allowed", args.Command)), nil
 	}
 
 	// Determine timeout

internal/extensions/loader.go

@@ -47,46 +47,56 @@ func LoadExtensions(extraPaths []string) ([]LoadedExtension, error) {
 	return loaded, nil
 }
 
+// pathSet is a thread-safe helper for deduplicating and ordering file paths.
+type pathSet struct {
+	m    map[string]bool
+	list []string
+}
+
+func newPathSet() *pathSet {
+	return &pathSet{m: make(map[string]bool)}
+}
+
+func (ps *pathSet) add(p string) bool {
+	abs, err := filepath.Abs(p)
+	if err != nil {
+		return false
+	}
+	if ps.m[abs] {
+		return false
+	}
+	ps.m[abs] = true
+	ps.list = append(ps.list, abs)
+	return true
+}
+
 // discoverExtensionPaths returns deduplicated paths to extension files in
 // load-order (global first, then project-local, then explicit).
 func discoverExtensionPaths(extraPaths []string) []string {
-	seen := make(map[string]bool)
-	var paths []string
-
-	add := func(p string) {
-		abs, err := filepath.Abs(p)
-		if err != nil {
-			return
-		}
-		if seen[abs] {
-			return
-		}
-		seen[abs] = true
-		paths = append(paths, abs)
-	}
+	ps := newPathSet()
 
 	// Global extensions: $XDG_CONFIG_HOME/kit/extensions/ (default ~/.config/kit/extensions/)
 	globalDir := globalExtensionsDir()
 	for _, p := range findExtensionsInDir(globalDir) {
-		add(p)
+		ps.add(p)
 	}
 
 	// Global installed git packages: $XDG_DATA_HOME/kit/git/
 	globalGitDir := globalGitInstallRoot()
 	for _, p := range findExtensionsInGitPackages(globalGitDir) {
-		add(p)
+		ps.add(p)
 	}
 
 	// Project-local extensions: .kit/extensions/
 	localDir := filepath.Join(".kit", "extensions")
 	for _, p := range findExtensionsInDir(localDir) {
-		add(p)
+		ps.add(p)
 	}
 
 	// Project-local installed git packages: .kit/git/
 	projectGitDir := filepath.Join(".kit", "git")
 	for _, p := range findExtensionsInGitPackages(projectGitDir) {
-		add(p)
+		ps.add(p)
 	}
 
 	// Explicit paths (highest precedence)
@@ -97,14 +107,14 @@ func discoverExtensionPaths(extraPaths []string) []string {
 		}
 		if info.IsDir() {
 			for _, found := range findExtensionsInDir(p) {
-				add(found)
+				ps.add(found)
 			}
 		} else if strings.HasSuffix(p, ".go") {
-			add(p)
+			ps.add(p)
 		}
 	}
 
-	return paths
+	return ps.list
 }
 
 // findExtensionsInDir returns .go files in dir and main.go in immediate subdirs.

internal/extensions/subagent.go

@@ -173,10 +173,10 @@ type subagentJSONOutput struct {
 	} `json:"usage,omitempty"`
 }
 
-var subagentCounter uint64
+var subagentCounter atomic.Uint64
 
 func generateSubagentID() string {
-	n := atomic.AddUint64(&subagentCounter, 1)
+	n := subagentCounter.Add(1)
 	return fmt.Sprintf("sub-%d-%d", time.Now().UnixNano(), n)
 }
 

internal/extensions/wrapper.go

@@ -42,13 +42,13 @@ func ExtensionToolsAsFantasy(defs []ToolDef, runner *Runner) []fantasy.AgentTool
 
 // coreToolKinds maps built-in tool names to their kind classification.
 var coreToolKinds = map[string]string{
-	"bash":           "execute",
-	"edit":           "edit",
-	"write":          "edit",
-	"read":           "read",
-	"ls":             "read",
-	"grep":           "search",
-	"find":           "search",
+	"bash":     "execute",
+	"edit":     "edit",
+	"write":    "edit",
+	"read":     "read",
+	"ls":       "read",
+	"grep":     "search",
+	"find":     "search",
 	"subagent": "agent",
 }
 

internal/message/content.go

@@ -4,12 +4,18 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"regexp"
 	"strings"
 	"time"
 
 	"charm.land/fantasy"
 )
 
+// thinkTagRegex matches  ...  tags that some models (Qwen, DeepSeek) wrap
+// reasoning content in. Used to strip these tags from text content.
+// The (?s) flag makes . match newlines.
+var thinkTagRegex = regexp.MustCompile(`(?s)` + `` + `think` + `` + `(.*?)` + `` + `/think` + ``)
+
 // sanitizeToolCallID ensures the ID matches Anthropic's required pattern:
 // ^[a-zA-Z0-9_-]+$ (alphanumeric, underscores, and hyphens only).
 // Invalid characters are replaced with underscores.
@@ -115,9 +121,9 @@ const (
 )
 
 // Message is a single conversation message containing a heterogeneous slice
-// of ContentPart blocks. This design (borrowed from crush) enables a single
-// assistant message to carry text, reasoning, and multiple tool calls as
-// discrete, typed blocks rather than flattening everything into strings.
+// of ContentPart blocks. This design enables a single assistant message to
+// carry text, reasoning, and multiple tool calls as discrete, typed blocks
+// rather than flattening everything into strings.
 type Message struct {
 	ID        string        `json:"id"`
 	Role      MessageRole   `json:"role"`
@@ -312,12 +318,18 @@ func UnmarshalParts(data []byte) ([]ContentPart, error) {
 	return parts, nil
 }
 
-// --- Fantasy bridge ---
+// --- LLM bridge ---
 
-// ToFantasyMessages converts a Message to one or more fantasy.Message values.
-// An assistant message with tool calls produces a single fantasy message with
+// ToLLMMessages converts a Message to one or more LLM message values.
+// An assistant message with tool calls produces a single message with
 // mixed TextPart and ToolCallPart content. Tool-role messages produce
 // ToolResultPart entries.
+func (m *Message) ToLLMMessages() []fantasy.Message {
+	return m.ToFantasyMessages()
+}
+
+// Deprecated: Use ToLLMMessages instead.
+// ToFantasyMessages converts a Message to one or more LLM message values.
 func (m *Message) ToFantasyMessages() []fantasy.Message {
 	switch m.Role {
 	case RoleAssistant:
@@ -416,7 +428,14 @@ func (m *Message) ToFantasyMessages() []fantasy.Message {
 	}
 }
 
-// FromFantasyMessage converts a fantasy.Message into our Message type,
+// FromLLMMessage converts an LLM message into our Message type,
+// extracting all content parts into the appropriate block types.
+func FromLLMMessage(msg fantasy.Message) Message {
+	return FromFantasyMessage(msg)
+}
+
+// Deprecated: Use FromLLMMessage instead.
+// FromFantasyMessage converts an LLM message into our Message type,
 // extracting all content parts into the appropriate block types.
 func FromFantasyMessage(msg fantasy.Message) Message {
 	m := Message{
@@ -430,7 +449,11 @@ func FromFantasyMessage(msg fantasy.Message) Message {
 		switch p := part.(type) {
 		case fantasy.TextPart:
 			if p.Text != "" {
-				m.Parts = append(m.Parts, TextContent{Text: p.Text})
+				// Strip  ...  tags that some models wrap reasoning in
+				cleanedText := thinkTagRegex.ReplaceAllString(p.Text, "")
+				if cleanedText != "" {
+					m.Parts = append(m.Parts, TextContent{Text: cleanedText})
+				}
 			}
 		case fantasy.ToolCallPart:
 			m.Parts = append(m.Parts, ToolCall{

internal/models/cache_options.go

@@ -0,0 +1,87 @@
+package models
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"maps"
+	"os"
+
+	"charm.land/fantasy"
+	"charm.land/fantasy/providers/openai"
+)
+
+// buildCacheProviderOptions returns caching options for supported models.
+// Caching is enabled by default for all supported models to reduce costs.
+// Set KIT_DISABLE_CACHE=1 or ProviderConfig.DisableCaching=true to opt out.
+func buildCacheProviderOptions(modelInfo *ModelInfo, config *ProviderConfig) fantasy.ProviderOptions {
+	// Check explicit opt-out via config
+	if config.DisableCaching {
+		return nil
+	}
+
+	// Check global opt-out via environment
+	if os.Getenv("KIT_DISABLE_CACHE") != "" {
+		return nil
+	}
+
+	// Check if model supports caching
+	if modelInfo == nil || !modelInfo.SupportsCaching() {
+		return nil
+	}
+
+	switch modelInfo.CacheType() {
+	case "anthropic-ephemeral":
+		// Provider-level Anthropic caching disabled - use message-level caching instead.
+		return nil
+	case "openai-prompt-cache":
+		return buildOpenAICacheOptions(config, modelInfo.ID)
+	case "google-cached-content":
+		// Google caching not yet implemented.
+		return nil
+	default:
+		return nil
+	}
+}
+
+// buildOpenAICacheOptions enables prompt caching for OpenAI models.
+// Uses a deterministic cache key based on system prompt and model ID.
+func buildOpenAICacheOptions(config *ProviderConfig, modelID string) fantasy.ProviderOptions {
+	cacheKey := generateCacheKey(config.SystemPrompt, modelID)
+
+	return fantasy.ProviderOptions{
+		openai.Name: &openai.ProviderOptions{
+			PromptCacheKey: &cacheKey,
+		},
+	}
+}
+
+// generateCacheKey creates a deterministic cache key from system prompt and model.
+// This ensures the same system prompt + model combination gets cache hits.
+func generateCacheKey(systemPrompt, modelID string) string {
+	if systemPrompt == "" {
+		systemPrompt = "default"
+	}
+
+	h := sha256.New()
+	h.Write([]byte(systemPrompt))
+	h.Write([]byte(modelID))
+
+	// Prefix with "kit-" to identify KIT-generated cache keys
+	return "kit-" + hex.EncodeToString(h.Sum(nil))[:24]
+}
+
+// mergeProviderOptions merges multiple ProviderOptions maps.
+// Later maps take precedence over earlier ones.
+func mergeProviderOptions(opts ...fantasy.ProviderOptions) fantasy.ProviderOptions {
+	result := make(fantasy.ProviderOptions)
+
+	for _, opt := range opts {
+		maps.Copy(result, opt)
+	}
+
+	if len(result) == 0 {
+		return nil
+	}
+
+	return result
+}

internal/models/cache_options_test.go

@@ -0,0 +1,248 @@
+package models
+
+import (
+	"os"
+	"testing"
+
+	"charm.land/fantasy"
+)
+
+func TestModelInfo_SupportsCaching(t *testing.T) {
+	tests := []struct {
+		name     string
+		family   string
+		expected bool
+	}{
+		{"Claude model", "claude-3-5-sonnet", true},
+		{"Claude 4 model", "claude-4-opus", true},
+		{"GPT model", "gpt-4", true},
+		{"GPT-5 model", "gpt-5", true},
+		{"O1 model", "o1", true},
+		{"O3 model", "o3", true},
+		{"O4 model", "o4-mini", true},
+		{"Codex model", "codex", true},
+		{"Gemini model", "gemini-2.5-pro", true},
+		{"Gemini 1.5 model", "gemini-1.5-flash", true},
+		{"Llama model", "llama-3", false},
+		{"Unknown model", "unknown", false},
+		{"Empty family", "", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := &ModelInfo{Family: tt.family}
+			if got := m.SupportsCaching(); got != tt.expected {
+				t.Errorf("ModelInfo.SupportsCaching() = %v, want %v", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestModelInfo_CacheType(t *testing.T) {
+	tests := []struct {
+		name     string
+		family   string
+		expected string
+	}{
+		{"Claude model", "claude-3-5-sonnet", "anthropic-ephemeral"},
+		{"GPT model", "gpt-4", "openai-prompt-cache"},
+		{"O1 model", "o1", "openai-prompt-cache"},
+		{"Gemini model", "gemini-2.5-pro", "google-cached-content"},
+		{"Unknown model", "llama-3", ""},
+		{"Empty family", "", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := &ModelInfo{Family: tt.family}
+			if got := m.CacheType(); got != tt.expected {
+				t.Errorf("ModelInfo.CacheType() = %v, want %v", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestGenerateCacheKey(t *testing.T) {
+	key1 := generateCacheKey("system prompt", "model-id")
+	key2 := generateCacheKey("system prompt", "model-id")
+	if key1 != key2 {
+		t.Errorf("generateCacheKey should be deterministic: got %q and %q", key1, key2)
+	}
+
+	key3 := generateCacheKey("different prompt", "model-id")
+	if key1 == key3 {
+		t.Errorf("generateCacheKey should produce different keys for different inputs")
+	}
+
+	key4 := generateCacheKey("", "model-id")
+	key5 := generateCacheKey("default", "model-id")
+	if key4 != key5 {
+		t.Errorf("generateCacheKey should treat empty prompt as 'default'")
+	}
+
+	if len(key1) < 4 || key1[:4] != "kit-" {
+		t.Errorf("generateCacheKey should produce keys with 'kit-' prefix, got %q", key1)
+	}
+}
+
+func TestBuildCacheProviderOptions_Disabled(t *testing.T) {
+	config := &ProviderConfig{DisableCaching: true}
+	modelInfo := &ModelInfo{Family: "claude-3", ID: "claude-3-opus"}
+
+	if opts := buildCacheProviderOptions(modelInfo, config); opts != nil {
+		t.Errorf("buildCacheProviderOptions should return nil when DisableCaching=true")
+	}
+}
+
+func TestBuildCacheProviderOptions_EnvironmentVariable(t *testing.T) {
+	_ = os.Setenv("KIT_DISABLE_CACHE", "1")
+	defer func() { _ = os.Unsetenv("KIT_DISABLE_CACHE") }()
+
+	config := &ProviderConfig{DisableCaching: false}
+	modelInfo := &ModelInfo{Family: "claude-3", ID: "claude-3-opus"}
+
+	if opts := buildCacheProviderOptions(modelInfo, config); opts != nil {
+		t.Errorf("buildCacheProviderOptions should return nil when KIT_DISABLE_CACHE is set")
+	}
+}
+
+func TestBuildCacheProviderOptions_UnsupportedModel(t *testing.T) {
+	config := &ProviderConfig{DisableCaching: false}
+	modelInfo := &ModelInfo{Family: "llama-3", ID: "llama-3-70b"}
+
+	if opts := buildCacheProviderOptions(modelInfo, config); opts != nil {
+		t.Errorf("buildCacheProviderOptions should return nil for unsupported model families")
+	}
+}
+
+func TestBuildCacheProviderOptions_NilModelInfo(t *testing.T) {
+	config := &ProviderConfig{DisableCaching: false}
+
+	if opts := buildCacheProviderOptions(nil, config); opts != nil {
+		t.Errorf("buildCacheProviderOptions should return nil when modelInfo is nil")
+	}
+}
+
+func TestBuildCacheProviderOptions_Anthropic(t *testing.T) {
+	_ = os.Unsetenv("KIT_DISABLE_CACHE")
+
+	config := &ProviderConfig{DisableCaching: false}
+	modelInfo := &ModelInfo{Family: "claude-3", ID: "claude-3-opus"}
+
+	opts := buildCacheProviderOptions(modelInfo, config)
+	// Provider-level Anthropic caching is disabled; message-level caching is used instead
+	if opts != nil {
+		t.Logf("Provider-level Anthropic caching disabled; using message-level caching")
+	}
+}
+
+func TestBuildCacheProviderOptions_OpenAI(t *testing.T) {
+	_ = os.Unsetenv("KIT_DISABLE_CACHE")
+
+	config := &ProviderConfig{
+		DisableCaching: false,
+		SystemPrompt:   "test system prompt",
+	}
+	modelInfo := &ModelInfo{Family: "gpt-4", ID: "gpt-4o"}
+
+	opts := buildCacheProviderOptions(modelInfo, config)
+	if opts == nil {
+		t.Fatalf("buildCacheProviderOptions should return options for OpenAI models")
+	}
+
+	if _, ok := opts["openai"]; !ok {
+		t.Errorf("buildCacheProviderOptions should include 'openai' key for GPT models")
+	}
+}
+
+func TestCachingPriorityOverThinking(t *testing.T) {
+	_ = os.Unsetenv("KIT_DISABLE_CACHE")
+
+	// Anthropic uses message-level caching; provider-level returns nil
+	config1 := &ProviderConfig{
+		DisableCaching: false,
+		ThinkingLevel:  ThinkingOff,
+	}
+	modelInfo1 := &ModelInfo{Family: "claude-3", ID: "claude-3-opus"}
+	opts1 := buildCacheProviderOptions(modelInfo1, config1)
+	if opts1 != nil {
+		t.Logf("Provider-level Anthropic caching disabled; using message-level caching")
+	}
+
+	// OpenAI provider-level caching works with thinking enabled
+	config2 := &ProviderConfig{
+		DisableCaching: false,
+		SystemPrompt:   "test prompt",
+		ThinkingLevel:  ThinkingMedium,
+	}
+	modelInfo2 := &ModelInfo{Family: "gpt-4", ID: "gpt-4o"}
+	opts2 := buildCacheProviderOptions(modelInfo2, config2)
+	if opts2 == nil {
+		t.Errorf("OpenAI caching should work with thinking enabled")
+	}
+
+	// OpenAI caching also works with thinking disabled
+	config3 := &ProviderConfig{
+		DisableCaching: false,
+		SystemPrompt:   "test prompt",
+		ThinkingLevel:  ThinkingOff,
+	}
+	opts3 := buildCacheProviderOptions(modelInfo2, config3)
+	if opts3 == nil {
+		t.Errorf("OpenAI caching should work when thinking is OFF")
+	}
+}
+
+func TestMergeProviderOptions(t *testing.T) {
+	opts1 := fantasy.ProviderOptions{
+		"provider1": &testProviderData{value: "value1"},
+	}
+	opts2 := fantasy.ProviderOptions{
+		"provider2": &testProviderData{value: "value2"},
+	}
+
+	merged := mergeProviderOptions(opts1, opts2)
+
+	if len(merged) != 2 {
+		t.Errorf("mergeProviderOptions should combine options from multiple maps, got %d items", len(merged))
+	}
+
+	if _, ok := merged["provider1"]; !ok {
+		t.Errorf("merged options should contain 'provider1' key")
+	}
+
+	if _, ok := merged["provider2"]; !ok {
+		t.Errorf("merged options should contain 'provider2' key")
+	}
+
+	// Later options should override earlier ones
+	opts3 := fantasy.ProviderOptions{
+		"provider1": &testProviderData{value: "overridden"},
+	}
+	merged2 := mergeProviderOptions(opts1, opts3)
+
+	if data, ok := merged2["provider1"].(*testProviderData); ok {
+		if data.value != "overridden" {
+			t.Errorf("later options should override earlier ones, got %q", data.value)
+		}
+	}
+
+	if mergeProviderOptions() != nil {
+		t.Errorf("mergeProviderOptions with no args should return nil")
+	}
+}
+
+// testProviderData is a simple implementation of ProviderOptionsData for testing
+type testProviderData struct {
+	value string
+}
+
+func (t *testProviderData) Options() {}
+
+func (t *testProviderData) MarshalJSON() ([]byte, error) {
+	return []byte(`"` + t.value + `"`), nil
+}
+
+func (t *testProviderData) UnmarshalJSON(data []byte) error {
+	return nil
+}

internal/models/modelsdb.go

@@ -48,10 +48,10 @@ type modelsDBLimit struct {
 	Output  int `json:"output"`
 }
 
-// npmToFantasyProvider maps npm package names from models.dev to fantasy
+// npmToLLMProvider maps npm package names from models.dev to LLM
 // provider identifiers. Providers not in this map but with an api URL
 // can be auto-routed through openaicompat.
-var npmToFantasyProvider = map[string]string{
+var npmToLLMProvider = map[string]string{
 	"@ai-sdk/anthropic":               "anthropic",
 	"@ai-sdk/openai":                  "openai",
 	"@ai-sdk/google":                  "google",

internal/models/providers.go

@@ -10,6 +10,7 @@ import (
 	"maps"
 	"net/http"
 	"os"
+	"regexp"
 	"strings"
 	"time"
 
@@ -22,6 +23,7 @@ import (
 	"charm.land/fantasy/providers/openaicompat"
 	"charm.land/fantasy/providers/openrouter"
 	"charm.land/fantasy/providers/vercel"
+	openaisdk "github.com/charmbracelet/openai-go"
 
 	"github.com/mark3labs/kit/internal/auth"
 	"github.com/mark3labs/kit/internal/ui/progress"
@@ -155,6 +157,7 @@ type ProviderConfig struct {
 	MainGPU        *int32
 	TLSSkipVerify  bool
 	ThinkingLevel  ThinkingLevel
+	DisableCaching bool // Opt-out: set to true to disable automatic prompt caching
 }
 
 // ProviderResult contains the result of provider creation.
@@ -237,30 +240,59 @@ func CreateProvider(ctx context.Context, config *ProviderConfig) (*ProviderResul
 		validateModelConfig(config, modelInfo)
 	}
 
+	// Create the base provider
+	var result *ProviderResult
+	var createErr error
+
 	switch provider {
 	case "anthropic":
-		return createAnthropicProvider(ctx, config, modelName)
+		result, createErr = createAnthropicProvider(ctx, config, modelName)
 	case "openai":
-		return createOpenAIProvider(ctx, config, modelName)
+		result, createErr = createOpenAIProvider(ctx, config, modelName)
 	case "google", "gemini":
-		return createGoogleProvider(ctx, config, modelName)
+		result, createErr = createGoogleProvider(ctx, config, modelName)
 	case "ollama":
-		return createOllamaProvider(ctx, config, modelName)
+		result, createErr = createOllamaProvider(ctx, config, modelName)
 	case "azure":
-		return createAzureProvider(ctx, config, modelName)
+		result, createErr = createAzureProvider(ctx, config, modelName)
 	case "google-vertex-anthropic":
-		return createVertexAnthropicProvider(ctx, config, modelName)
+		result, createErr = createVertexAnthropicProvider(ctx, config, modelName)
 	case "openrouter":
-		return createOpenRouterProvider(ctx, config, modelName)
+		result, createErr = createOpenRouterProvider(ctx, config, modelName)
 	case "bedrock":
-		return createBedrockProvider(ctx, config, modelName)
+		result, createErr = createBedrockProvider(ctx, config, modelName)
 	case "vercel":
-		return createVercelProvider(ctx, config, modelName)
+		result, createErr = createVercelProvider(ctx, config, modelName)
 	case "custom":
-		return createCustomProvider(ctx, config, modelName)
+		result, createErr = createCustomProvider(ctx, config, modelName)
 	default:
-		return autoRouteProvider(ctx, config, provider, modelName, registry)
+		result, createErr = autoRouteProvider(ctx, config, provider, modelName, registry)
 	}
+
+	if createErr != nil {
+		return nil, createErr
+	}
+
+	// AUTOMATICALLY ENABLE CACHING for supported models (unless disabled).
+	// This works for BOTH native and auto-routed providers by detecting
+	// the model family from the model metadata.
+	if cacheOpts := buildCacheProviderOptions(modelInfo, config); cacheOpts != nil {
+		if result.ProviderOptions == nil {
+			result.ProviderOptions = cacheOpts
+		} else {
+			// Merge cache options with existing provider options.
+			// Only add cache options for providers that don't already have
+			// options set, to avoid type conflicts (e.g., Anthropic has
+			// different types for regular options vs cache control options).
+			for k, v := range cacheOpts {
+				if _, exists := result.ProviderOptions[k]; !exists {
+					result.ProviderOptions[k] = v
+				}
+			}
+		}
+	}
+
+	return result, nil
 }
 
 // autoRouteProvider attempts to create a provider by looking up its npm package
@@ -280,14 +312,14 @@ func autoRouteProvider(ctx context.Context, config *ProviderConfig, provider, mo
 		npmPackage = modelInfo.ProviderNPM
 	}
 
-	// Determine the fantasy provider for this npm package
-	fantasyProvider := npmToFantasyProvider[npmPackage]
-	if fantasyProvider == "" && providerInfo.API != "" {
+	// Determine the LLM provider for this npm package
+	llmProvider := npmToLLMProvider[npmPackage]
+	if llmProvider == "" && providerInfo.API != "" {
 		// Unknown npm but has API URL → route through openaicompat
-		fantasyProvider = "openaicompat"
+		llmProvider = "openaicompat"
 	}
 
-	switch fantasyProvider {
+	switch llmProvider {
 	case "openaicompat":
 		return createAutoRoutedOpenAICompatProvider(ctx, config, modelName, providerInfo)
 	case "anthropic":
@@ -301,7 +333,7 @@ func autoRouteProvider(ctx context.Context, config *ProviderConfig, provider, mo
 		}
 		return createAutoRoutedOpenAIProvider(ctx, config, modelName, providerInfo)
 	default:
-		return nil, fmt.Errorf("unsupported provider: %s (npm: %s has no fantasy mapping)", provider, npmPackage)
+		return nil, fmt.Errorf("unsupported provider: %s (npm: %s has no LLM provider mapping)", provider, npmPackage)
 	}
 }
 
@@ -510,10 +542,15 @@ func thinkingLevelToReasoningEffort(level ThinkingLevel) *openai.ReasoningEffort
 // SendReasoning to true and configures the thinking budget. For thinking-off
 // or non-reasoning models the returned map is nil.
 //
+// NOTE: With message-level caching, thinking and caching can work together.
+// Message-level cache control (ProviderCacheControlOptions) doesn't conflict
+// with provider-level thinking options (ProviderOptions).
+//
 // Anthropic requires max_tokens > thinking.budget_tokens. If the configured
 // MaxTokens is too low, it is bumped to budget + 4096 to leave room for the
 // actual response.
 func buildAnthropicProviderOptions(config *ProviderConfig, modelName string) fantasy.ProviderOptions {
+	// Thinking is OFF by default. If user hasn't explicitly enabled it, return nil.
 	if config.ThinkingLevel == "" || config.ThinkingLevel == ThinkingOff {
 		return nil
 	}
@@ -963,6 +1000,133 @@ func createVercelProvider(ctx context.Context, config *ProviderConfig, modelName
 	return &ProviderResult{Model: model}, nil
 }
 
+// thinkTagRegex matches <think>...</think> tags for extracting reasoning content
+// from models that wrap thinking in XML-like tags (e.g., Qwen, DeepSeek).
+var thinkTagRegex = regexp.MustCompile(`(?s)<think>(.*?)</think>`)
+
+// customExtraContentFunc extracts reasoning from <think> tags in the content field.
+// This handles models like Qwen and DeepSeek that return reasoning wrapped in XML tags
+// rather than using a separate reasoning_content field.
+func customExtraContentFunc(choice openaisdk.ChatCompletionChoice) []fantasy.Content {
+	var content []fantasy.Content
+	if choice.Message.Content == "" {
+		return content
+	}
+
+	// Check for <think> tags in the content
+	matches := thinkTagRegex.FindStringSubmatch(choice.Message.Content)
+	if len(matches) > 1 {
+		// Found reasoning content in <think> tags
+		reasoning := strings.TrimSpace(matches[1])
+		if reasoning != "" {
+			content = append(content, fantasy.ReasoningContent{
+				Text: reasoning,
+			})
+		}
+	}
+
+	return content
+}
+
+// customStreamExtraFunc handles streaming responses with <think> tags.
+// It extracts reasoning content and emits proper reasoning events.
+func customStreamExtraFunc(
+	chunk openaisdk.ChatCompletionChunk,
+	yield func(fantasy.StreamPart) bool,
+	ctx map[string]any,
+) (map[string]any, bool) {
+	if len(chunk.Choices) == 0 {
+		return ctx, true
+	}
+
+	const reasoningStartedKey = "reasoning_started"
+	const reasoningBufferKey = "reasoning_buffer"
+	const inThinkTagKey = "in_think_tag"
+
+	reasoningStarted, _ := ctx[reasoningStartedKey].(bool)
+	inThinkTag, _ := ctx[inThinkTagKey].(bool)
+	reasoningBuffer, _ := ctx[reasoningBufferKey].(string)
+
+	for i, choice := range chunk.Choices {
+		content := choice.Delta.Content
+		if content == "" {
+			continue
+		}
+
+		// Check for <think> tag start
+		if strings.Contains(content, "<think>") {
+			inThinkTag = true
+			ctx[inThinkTagKey] = true
+
+			// Emit reasoning start event
+			if !reasoningStarted {
+				reasoningStarted = true
+				ctx[reasoningStartedKey] = true
+				if !yield(fantasy.StreamPart{
+					Type: fantasy.StreamPartTypeReasoningStart,
+					ID:   fmt.Sprintf("%d", i),
+				}) {
+					return ctx, false
+				}
+			}
+
+			// Extract content after <think>
+			parts := strings.SplitN(content, "<think>", 2)
+			if len(parts) > 1 && parts[1] != "" {
+				reasoningBuffer += parts[1]
+				ctx[reasoningBufferKey] = reasoningBuffer
+			}
+			continue
+		}
+
+		// Check for </think> tag end
+		if strings.Contains(content, "</think>") {
+			inThinkTag = false
+			ctx[inThinkTagKey] = false
+
+			// Extract content before </think>
+			parts := strings.SplitN(content, "</think>", 2)
+			if len(parts) > 0 {
+				reasoningBuffer += parts[0]
+			}
+
+			// Emit the accumulated reasoning
+			if reasoningBuffer != "" {
+				if !yield(fantasy.StreamPart{
+					Type:  fantasy.StreamPartTypeReasoningDelta,
+					ID:    fmt.Sprintf("%d", i),
+					Delta: reasoningBuffer,
+				}) {
+					return ctx, false
+				}
+				ctx[reasoningBufferKey] = ""
+			}
+
+			// Emit reasoning end
+			if !yield(fantasy.StreamPart{
+				Type: fantasy.StreamPartTypeReasoningEnd,
+				ID:   fmt.Sprintf("%d", i),
+			}) {
+				return ctx, false
+			}
+			continue
+		}
+
+		// Accumulate reasoning content while in think tag
+		if inThinkTag {
+			reasoningBuffer += content
+			ctx[reasoningBufferKey] = reasoningBuffer
+		}
+	}
+
+	return ctx, true
+}
+
+// customToPromptFunc converts prompts to OpenAI format using the default conversion.
+func customToPromptFunc(prompt fantasy.Prompt, systemPrompt, user string) ([]openaisdk.ChatCompletionMessageParamUnion, []fantasy.CallWarning) {
+	return openai.DefaultToPrompt(prompt, systemPrompt, user)
+}
+
 func createCustomProvider(ctx context.Context, config *ProviderConfig, modelName string) (*ProviderResult, error) {
 	if config.ProviderURL == "" {
 		return nil, fmt.Errorf("custom provider requires --provider-url")
@@ -977,16 +1141,23 @@ func createCustomProvider(ctx context.Context, config *ProviderConfig, modelName
 		apiKey = "custom"
 	}
 
-	var opts []openaicompat.Option
-	opts = append(opts, openaicompat.WithBaseURL(config.ProviderURL))
-	opts = append(opts, openaicompat.WithAPIKey(apiKey))
-	opts = append(opts, openaicompat.WithName("custom"))
+	// Use the openai provider directly with custom hooks to handle <think> tags
+	// from models like Qwen and DeepSeek that wrap reasoning in XML tags.
+	var opts []openai.Option
+	opts = append(opts, openai.WithBaseURL(config.ProviderURL))
+	opts = append(opts, openai.WithAPIKey(apiKey))
+	opts = append(opts, openai.WithName("custom"))
+	opts = append(opts, openai.WithLanguageModelOptions(
+		openai.WithLanguageModelExtraContentFunc(customExtraContentFunc),
+		openai.WithLanguageModelStreamExtraFunc(customStreamExtraFunc),
+		openai.WithLanguageModelToPromptFunc(customToPromptFunc),
+	))
 
 	if config.TLSSkipVerify {
-		opts = append(opts, openaicompat.WithHTTPClient(createHTTPClientWithTLSConfig(true)))
+		opts = append(opts, openai.WithHTTPClient(createHTTPClientWithTLSConfig(true)))
 	}
 
-	p, err := openaicompat.New(opts...)
+	p, err := openai.New(opts...)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create custom provider: %w", err)
 	}

internal/models/registry.go

@@ -17,6 +17,7 @@ var embeddedModelsJSON []byte
 type ModelInfo struct {
 	ID          string
 	Name        string
+	Family      string // Model family (e.g., "claude", "gpt", "gemini")
 	Attachment  bool
 	Reasoning   bool
 	Temperature bool
@@ -25,6 +26,44 @@ type ModelInfo struct {
 	ProviderNPM string // Model-specific provider npm override (e.g. "@ai-sdk/anthropic")
 }
 
+// SupportsCaching returns true if this model family supports prompt caching.
+// This enables automatic cost savings for supported models regardless of provider.
+func (m *ModelInfo) SupportsCaching() bool {
+	switch {
+	case strings.HasPrefix(m.Family, "claude"):
+		return true
+	case strings.HasPrefix(m.Family, "gpt"),
+		strings.HasPrefix(m.Family, "o1"),
+		strings.HasPrefix(m.Family, "o3"),
+		strings.HasPrefix(m.Family, "o4"),
+		strings.HasPrefix(m.Family, "codex"):
+		return true
+	case strings.HasPrefix(m.Family, "gemini"):
+		return true
+	default:
+		return false
+	}
+}
+
+// CacheType returns the appropriate cache mechanism for this model family.
+// Returns empty string if caching is not supported.
+func (m *ModelInfo) CacheType() string {
+	switch {
+	case strings.HasPrefix(m.Family, "claude"):
+		return "anthropic-ephemeral"
+	case strings.HasPrefix(m.Family, "gpt"),
+		strings.HasPrefix(m.Family, "o1"),
+		strings.HasPrefix(m.Family, "o3"),
+		strings.HasPrefix(m.Family, "o4"),
+		strings.HasPrefix(m.Family, "codex"):
+		return "openai-prompt-cache"
+	case strings.HasPrefix(m.Family, "gemini"):
+		return "google-cached-content"
+	default:
+		return ""
+	}
+}
+
 // Cost represents the pricing information for a model.
 type Cost struct {
 	Input      float64
@@ -86,6 +125,7 @@ func buildFromModelsDB() map[string]ProviderInfo {
 			modelsMap[modelID] = ModelInfo{
 				ID:          dm.ID,
 				Name:        dm.Name,
+				Family:      dm.Family,
 				Attachment:  dm.Attachment,
 				Reasoning:   dm.Reasoning,
 				Temperature: dm.Temperature,
@@ -308,27 +348,32 @@ func (r *ModelsRegistry) GetSupportedProviders() []string {
 	return providers
 }
 
-// GetFantasyProviders returns provider IDs that can be used with fantasy,
+// GetLLMProviders returns provider IDs that have LLM support,
 // either through a native provider or via openaicompat auto-routing.
-func (r *ModelsRegistry) GetFantasyProviders() []string {
+func (r *ModelsRegistry) GetLLMProviders() []string {
 	var providers []string
 	for providerID, info := range r.providers {
-		if isProviderFantasySupported(providerID, &info) {
+		if isProviderLLMSupported(providerID, &info) {
 			providers = append(providers, providerID)
 		}
 	}
 	return providers
 }
 
-// isProviderFantasySupported checks if a provider can be used with fantasy.
-func isProviderFantasySupported(providerID string, info *ProviderInfo) bool {
+// Deprecated: Use GetLLMProviders instead.
+func (r *ModelsRegistry) GetFantasyProviders() []string {
+	return r.GetLLMProviders()
+}
+
+// isProviderLLMSupported checks if a provider can be used with the LLM layer.
+func isProviderLLMSupported(providerID string, info *ProviderInfo) bool {
 	// Ollama is always supported (via openaicompat pointed at localhost)
 	if providerID == "ollama" {
 		return true
 	}
 
-	// Check if npm maps to a fantasy provider
-	if _, ok := npmToFantasyProvider[info.NPM]; ok {
+	// Check if npm maps to an LLM provider
+	if _, ok := npmToLLMProvider[info.NPM]; ok {
 		return true
 	}
 

internal/session/tree_manager.go

@@ -181,7 +181,7 @@ func OpenTreeSession(path string) (*TreeManager, error) {
 
 	// Set leaf to the last entry.
 	if len(tm.entries) > 0 {
-		tm.leafID = tm.entryID(tm.entries[len(tm.entries)-1])
+		tm.leafID = tm.EntryID(tm.entries[len(tm.entries)-1])
 	}
 
 	// Open file for appending.
@@ -242,9 +242,14 @@ func (tm *TreeManager) AppendMessage(msg message.Message) (string, error) {
 	return entry.ID, nil
 }
 
-// AppendFantasyMessage converts a fantasy.Message and appends it.
+// AppendLLMMessage converts an LLM message and appends it.
+func (tm *TreeManager) AppendLLMMessage(msg fantasy.Message) (string, error) {
+	return tm.AppendMessage(message.FromLLMMessage(msg))
+}
+
+// Deprecated: Use AppendLLMMessage instead.
 func (tm *TreeManager) AppendFantasyMessage(msg fantasy.Message) (string, error) {
-	return tm.AppendMessage(message.FromFantasyMessage(msg))
+	return tm.AppendLLMMessage(msg)
 }
 
 // AppendModelChange records a model/provider change.
@@ -521,7 +526,7 @@ func (tm *TreeManager) BuildContext() (messages []fantasy.Message, provider stri
 	for _, entry := range branch {
 		// Once we reach the first kept entry, stop skipping.
 		if skipping {
-			entryID := tm.entryID(entry)
+			entryID := tm.EntryID(entry)
 			if entryID == lastCompaction.FirstKeptEntryID {
 				skipping = false
 			} else {
@@ -535,7 +540,7 @@ func (tm *TreeManager) BuildContext() (messages []fantasy.Message, provider stri
 			if err != nil {
 				continue // skip malformed entries
 			}
-			msgs := msg.ToFantasyMessages()
+			msgs := msg.ToLLMMessages()
 			messages = append(messages, msgs...)
 
 		case *BranchSummaryEntry:
@@ -684,7 +689,7 @@ func (tm *TreeManager) GetContextEntryIDs() []string {
 	skipping := lastCompaction != nil
 	for _, entry := range branch {
 		if skipping {
-			entryID := tm.entryID(entry)
+			entryID := tm.EntryID(entry)
 			if entryID == lastCompaction.FirstKeptEntryID {
 				skipping = false
 			} else {
@@ -698,7 +703,7 @@ func (tm *TreeManager) GetContextEntryIDs() []string {
 			if err != nil {
 				continue
 			}
-			msgs := msg.ToFantasyMessages()
+			msgs := msg.ToLLMMessages()
 			for range msgs {
 				ids = append(ids, e.ID)
 			}
@@ -737,31 +742,41 @@ func (tm *TreeManager) GetLastCompaction() *CompactionEntry {
 
 // --- Legacy bridge ---
 
-// AddFantasyMessages appends multiple fantasy messages as entries. This is
+// AddLLMMessages appends multiple LLM messages as entries. This is
 // used when syncing from the agent's ConversationMessages after a step.
-func (tm *TreeManager) AddFantasyMessages(msgs []fantasy.Message) error {
+func (tm *TreeManager) AddLLMMessages(msgs []fantasy.Message) error {
 	for _, msg := range msgs {
-		if _, err := tm.AppendFantasyMessage(msg); err != nil {
+		if _, err := tm.AppendLLMMessage(msg); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-// GetFantasyMessages builds the context and returns just the messages.
+// Deprecated: Use AddLLMMessages instead.
+func (tm *TreeManager) AddFantasyMessages(msgs []fantasy.Message) error {
+	return tm.AddLLMMessages(msgs)
+}
+
+// GetLLMMessages builds the context and returns just the messages.
 // This satisfies the same conceptual role as the old Manager.GetMessages().
-func (tm *TreeManager) GetFantasyMessages() []fantasy.Message {
+func (tm *TreeManager) GetLLMMessages() []fantasy.Message {
 	msgs, _, _ := tm.BuildContext()
 	return msgs
 }
 
+// Deprecated: Use GetLLMMessages instead.
+func (tm *TreeManager) GetFantasyMessages() []fantasy.Message {
+	return tm.GetLLMMessages()
+}
+
 // --- Internal helpers ---
 
 // addEntryToIndex adds an entry to the in-memory indices.
 func (tm *TreeManager) addEntryToIndex(entry any) {
 	tm.entries = append(tm.entries, entry)
 
-	id := tm.entryID(entry)
+	id := tm.EntryID(entry)
 	parentID := tm.entryParentID(entry)
 
 	if id != "" {
@@ -798,8 +813,8 @@ func (tm *TreeManager) writeEntry(entry any) error {
 	return err
 }
 
-// entryID extracts the ID from any entry type.
-func (tm *TreeManager) entryID(entry any) string {
+// EntryID extracts the ID from any entry type.
+func (tm *TreeManager) EntryID(entry any) string {
 	switch e := entry.(type) {
 	case *MessageEntry:
 		return e.ID

internal/tools/mcp_test.go

@@ -460,5 +460,3 @@ func sliceEqual(a, b []any) bool {
 	}
 	return true
 }
-
-

internal/ui/children_test.go

@@ -149,11 +149,13 @@ func TestInputComponent_QuitReturnsTeaQuit(t *testing.T) {
 }
 
 // --------------------------------------------------------------------------
-// TestInputComponent_ClearCallsClearMessages verifies that /clear (and its
-// aliases) calls appCtrl.ClearMessages() and returns no submitMsg.
+// TestInputComponent_ClearForwardsAsSubmitMsg verifies that /clear (and its
+// aliases) are forwarded as submitMsg to the parent model so that the parent
+// can call ClearMessages(), update scrollback, and print the confirmation
+// message in one place. InputComponent must NOT call ClearMessages() directly.
 // --------------------------------------------------------------------------
 
-func TestInputComponent_ClearCallsClearMessages(t *testing.T) {
+func TestInputComponent_ClearForwardsAsSubmitMsg(t *testing.T) {
 	aliases := []string{"/clear", "/c", "/cls"}
 	for _, alias := range aliases {
 		t.Run(alias, func(t *testing.T) {
@@ -164,22 +166,29 @@ func TestInputComponent_ClearCallsClearMessages(t *testing.T) {
 
 			_, cmd := sendInputMsg(c, tea.KeyPressMsg{Code: tea.KeyEnter})
 
-			if ctrl.clearMsgCalled != 1 {
-				t.Fatalf("%s: expected ClearMessages() called once, got %d", alias, ctrl.clearMsgCalled)
+			// InputComponent must NOT call ClearMessages() directly.
+			if ctrl.clearMsgCalled != 0 {
+				t.Fatalf("%s: InputComponent must not call ClearMessages(), got %d", alias, ctrl.clearMsgCalled)
 			}
-			// No cmd should be returned (no submitMsg forwarded to parent).
-			if cmd != nil {
-				msg := runCmd(cmd)
-				if _, ok := msg.(submitMsg); ok {
-					t.Fatalf("%s: /clear should not emit submitMsg, got submitMsg", alias)
-				}
+			// A submitMsg must be emitted so the parent model handles /clear.
+			if cmd == nil {
+				t.Fatalf("%s: expected submitMsg cmd, got nil", alias)
+			}
+			msg := runCmd(cmd)
+			sm, ok := msg.(submitMsg)
+			if !ok {
+				t.Fatalf("%s: expected submitMsg, got %T", alias, msg)
+			}
+			if sm.Text != alias {
+				t.Fatalf("%s: expected submitMsg text %q, got %q", alias, alias, sm.Text)
 			}
 		})
 	}
 }
 
 // TestInputComponent_ClearNilCtrl_NoPanic verifies that /clear with a nil
-// appCtrl does not panic.
+// appCtrl does not panic. Since /clear is now forwarded to the parent via
+// submitMsg, no appCtrl interaction happens in InputComponent at all.
 func TestInputComponent_ClearNilCtrl_NoPanic(t *testing.T) {
 	c := newTestInput(nil)
 	c.textarea.SetValue("/clear")
@@ -266,10 +275,9 @@ func TestInputComponent_UnknownSlashCommand_ForwardsAsSubmit(t *testing.T) {
 // Helpers
 // --------------------------------------------------------------------------
 
-// newTestStream creates a StreamComponent with a fixed width and model name,
-// in non-compact mode.
+// newTestStream creates a StreamComponent with a fixed width and model name.
 func newTestStream() *StreamComponent {
-	return NewStreamComponent(false, 80, "test-model")
+	return NewStreamComponent(80, "test-model")
 }
 
 // sendStreamMsg calls component.Update and returns the updated component.
@@ -690,3 +698,170 @@ func TestStreamComponent_StaleFlushTick_Discarded(t *testing.T) {
 		t.Fatalf("expected streamContent='new' after current flush, got %q", got)
 	}
 }
+
+// TestStreamComponent_ConsumeOverflow_NoHeight verifies that when height is
+// unconstrained (0), ConsumeOverflow always returns "".
+func TestStreamComponent_ConsumeOverflow_NoHeight(t *testing.T) {
+	c := newTestStream()
+	// Commit some content directly.
+	c.streamContent.WriteString("line1\nline2\nline3")
+	c.phase = streamPhaseActive
+	c.renderDirty = true
+
+	if got := c.ConsumeOverflow(); got != "" {
+		t.Fatalf("expected empty with height=0, got %q", got)
+	}
+}
+
+// TestStreamComponent_ConsumeOverflow_NoOverflow verifies that when content fits
+// within the allocated height, ConsumeOverflow returns "".
+func TestStreamComponent_ConsumeOverflow_NoOverflow(t *testing.T) {
+	c := newTestStream()
+	c.streamContent.WriteString("line1\nline2")
+	c.phase = streamPhaseActive
+	c.renderDirty = true
+	c.height = 20 // plenty of room
+
+	if got := c.ConsumeOverflow(); got != "" {
+		t.Fatalf("expected empty when content fits, got %q", got)
+	}
+}
+
+// TestStreamComponent_ConsumeOverflow_EmitsTopLines verifies that when the
+// rendered content has more lines than the allocated height, ConsumeOverflow
+// returns the top overflow lines and advances the internal pointer.
+func TestStreamComponent_ConsumeOverflow_EmitsTopLines(t *testing.T) {
+	c := newTestStream()
+	c.height = 2
+
+	// Build raw content that when "rendered" (plain text for this test)
+	// is 5 lines — we bypass the markdown renderer by writing directly to
+	// streamContent and using a nil renderer.
+	c.renderer = nil
+	c.streamContent.WriteString("a\nb\nc\nd\ne")
+	c.phase = streamPhaseActive
+	c.renderDirty = true
+
+	// First call: should return lines a, b, c (5 lines - 2 visible = 3 overflow).
+	overflow1 := c.ConsumeOverflow()
+	if overflow1 == "" {
+		t.Fatal("expected overflow, got empty")
+	}
+	overflowLines := strings.Split(overflow1, "\n")
+	if len(overflowLines) != 3 {
+		t.Fatalf("expected 3 overflow lines, got %d: %q", len(overflowLines), overflow1)
+	}
+	if overflowLines[0] != "a" || overflowLines[1] != "b" || overflowLines[2] != "c" {
+		t.Fatalf("unexpected overflow lines: %v", overflowLines)
+	}
+
+	// Second call without new content should return "" (pointer already advanced).
+	overflow2 := c.ConsumeOverflow()
+	if overflow2 != "" {
+		t.Fatalf("expected empty on second call, got %q", overflow2)
+	}
+}
+
+// TestStreamComponent_ConsumeOverflow_IncrementalFlush verifies that as new
+// content arrives, ConsumeOverflow incrementally returns only newly overflowed
+// lines on each call.
+func TestStreamComponent_ConsumeOverflow_IncrementalFlush(t *testing.T) {
+	c := newTestStream()
+	c.height = 2
+	c.renderer = nil
+	c.phase = streamPhaseActive
+
+	// Start with 3 lines — 1 overflows.
+	c.streamContent.WriteString("a\nb\nc")
+	c.renderDirty = true
+
+	overflow1 := c.ConsumeOverflow()
+	if overflow1 != "a" {
+		t.Fatalf("expected 'a', got %q", overflow1)
+	}
+
+	// Add 2 more lines — 2 additional overflows.
+	c.streamContent.WriteString("\nd\ne")
+	c.renderDirty = true
+
+	overflow2 := c.ConsumeOverflow()
+	want := "b\nc"
+	if overflow2 != want {
+		t.Fatalf("expected %q, got %q", want, overflow2)
+	}
+}
+
+// TestStreamComponent_ConsumeOverflow_ResetClearsPointer verifies that Reset()
+// resets the scrollback pointer so the next response starts fresh.
+func TestStreamComponent_ConsumeOverflow_ResetClearsPointer(t *testing.T) {
+	c := newTestStream()
+	c.height = 1
+	c.renderer = nil
+	c.phase = streamPhaseActive
+
+	c.streamContent.WriteString("a\nb")
+	c.renderDirty = true
+	overflow := c.ConsumeOverflow()
+	if overflow != "a" {
+		t.Fatalf("expected 'a', got %q", overflow)
+	}
+
+	c.Reset()
+	if c.scrollbackFlushedLines != 0 {
+		t.Fatalf("expected scrollbackFlushedLines=0 after Reset, got %d", c.scrollbackFlushedLines)
+	}
+}
+
+// TestStreamComponent_GetRenderedContent_SkipsFlushedLines verifies that
+// GetRenderedContent skips lines already emitted via ConsumeOverflow so the
+// caller doesn't re-print content already in the terminal scrollback.
+func TestStreamComponent_GetRenderedContent_SkipsFlushedLines(t *testing.T) {
+	c := newTestStream()
+	c.height = 2
+	c.renderer = nil
+	c.phase = streamPhaseActive
+
+	// 5 lines → 3 overflow, 2 visible.
+	c.streamContent.WriteString("a\nb\nc\nd\ne")
+	c.renderDirty = true
+
+	// Consume the overflow: lines a, b, c.
+	overflow := c.ConsumeOverflow()
+	if overflow != "a\nb\nc" {
+		t.Fatalf("expected 'a\\nb\\nc', got %q", overflow)
+	}
+	if c.scrollbackFlushedLines != 3 {
+		t.Fatalf("expected flushedLines=3, got %d", c.scrollbackFlushedLines)
+	}
+
+	// GetRenderedContent should only return the non-flushed portion: d, e.
+	got := c.GetRenderedContent()
+	if got != "d\ne" {
+		t.Fatalf("expected 'd\\ne', got %q", got)
+	}
+}
+
+// TestStreamComponent_GetRenderedContent_AllFlushed verifies that when all
+// lines have been pushed via ConsumeOverflow, GetRenderedContent returns "".
+func TestStreamComponent_GetRenderedContent_AllFlushed(t *testing.T) {
+	c := newTestStream()
+	c.height = 1
+	c.renderer = nil
+	c.phase = streamPhaseActive
+
+	// 2 lines → height=1, so 1 overflow.
+	c.streamContent.WriteString("a\nb")
+	c.renderDirty = true
+
+	// Consume overflow (line a), leaving 1 visible line (b).
+	_ = c.ConsumeOverflow()
+
+	// Now bump height so everything overflows — simulate a resize that made
+	// the viewable area 0, forcing all content to be "flushed".
+	c.scrollbackFlushedLines = 2 // pretend both lines were flushed
+
+	got := c.GetRenderedContent()
+	if got != "" {
+		t.Fatalf("expected empty when all lines flushed, got %q", got)
+	}
+}

internal/ui/cli.go

@@ -11,33 +11,26 @@ import (
 )
 
 // CLI manages the command-line interface for KIT, providing message rendering,
-// user input handling, and display management. It supports both standard and compact
-// display modes, handles streaming responses, tracks token usage, and manages the
-// overall conversation flow between the user and AI assistants.
+// user input handling, and display management. It handles streaming responses,
+// tracks token usage, and manages the overall conversation flow between the
+// user and AI assistants.
 type CLI struct {
 	renderer     Renderer
 	usageTracker *UsageTracker
 	width        int
-	compactMode  bool
 	debug        bool
 	modelName    string
 }
 
-// NewCLI creates and initializes a new CLI instance with the specified display modes.
-// The debug parameter enables debug message rendering, while compact enables a more
-// condensed display format. Returns an initialized CLI ready for interaction or an
+// NewCLI creates and initializes a new CLI instance. The debug parameter enables
+// debug message rendering. Returns an initialized CLI ready for interaction or an
 // error if initialization fails.
-func NewCLI(debug bool, compact bool) (*CLI, error) {
+func NewCLI(debug bool) (*CLI, error) {
 	cli := &CLI{
-		compactMode: compact,
-		debug:       debug,
+		debug: debug,
 	}
 	cli.updateSize()
-	if compact {
-		cli.renderer = NewCompactRenderer(cli.width, debug)
-	} else {
-		cli.renderer = newMessageRenderer(cli.width, debug)
-	}
+	cli.renderer = newMessageRenderer(cli.width, debug)
 
 	return cli, nil
 }

internal/ui/clipboard.go

@@ -0,0 +1,96 @@
+package ui
+
+import (
+	"fmt"
+	"runtime"
+
+	tea "charm.land/bubbletea/v2"
+	"github.com/atotto/clipboard"
+)
+
+// CopyToClipboard writes text to both the system clipboard and via OSC 52.
+// Returns a tea.Cmd that can be used in Bubble Tea's Update flow.
+func CopyToClipboard(text string) tea.Cmd {
+	if text == "" {
+		return nil
+	}
+
+	return tea.Sequence(
+		// Method 1: OSC 52 escape sequence (works in modern terminals)
+		tea.SetClipboard(text),
+
+		// Method 2: Native system clipboard (atotto/clipboard)
+		func() tea.Msg {
+			// Best effort - ignore errors
+			_ = clipboard.WriteAll(text)
+			return nil
+		},
+	)
+}
+
+// CopyToClipboardWithMessage writes text to clipboard and returns a toast notification.
+func CopyToClipboardWithMessage(text string, message string) tea.Cmd {
+	if text == "" {
+		return nil
+	}
+
+	return tea.Sequence(
+		CopyToClipboard(text),
+		func() tea.Msg {
+			return ToastMsg{Message: message, Type: ToastInfo}
+		},
+	)
+}
+
+// ToastType represents the type of toast notification.
+type ToastType int
+
+const (
+	ToastInfo ToastType = iota
+	ToastSuccess
+	ToastWarning
+	ToastError
+)
+
+// ToastMsg is a message to display a toast notification.
+type ToastMsg struct {
+	Message string
+	Type    ToastType
+}
+
+// IsClipboardSupported returns true if the clipboard is supported on this platform.
+func IsClipboardSupported() bool {
+	// atotto/clipboard supports Linux (with xclip or xsel), macOS, Windows
+	switch runtime.GOOS {
+	case "darwin", "windows":
+		return true
+	case "linux":
+		// Check if xclip or xsel is available
+		// This is a best-effort check
+		return true
+	default:
+		return false
+	}
+}
+
+// CopySelection represents a text selection with start/end positions.
+type CopySelection struct {
+	StartItemIdx int  // Index of item where selection starts
+	StartLine    int  // Line within item where selection starts
+	StartCol     int  // Column where selection starts
+	EndItemIdx   int  // Index of item where selection ends
+	EndLine      int  // Line within item where selection ends
+	EndCol       int  // Column where selection ends
+	Active       bool // Whether selection is currently active
+}
+
+// IsEmpty returns true if the selection has no content.
+func (s CopySelection) IsEmpty() bool {
+	return !s.Active || (s.StartItemIdx == s.EndItemIdx && s.StartLine == s.EndLine && s.StartCol == s.EndCol)
+}
+
+// String returns a string representation for debugging.
+func (s CopySelection) String() string {
+	return fmt.Sprintf("Selection{item:%d-%d, line:%d-%d, col:%d-%d, active:%v}",
+		s.StartItemIdx, s.EndItemIdx, s.StartLine, s.EndLine, s.StartCol, s.EndCol, s.Active)
+}

internal/ui/compact_renderer.go

@@ -1,470 +0,0 @@
-package ui
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	"charm.land/lipgloss/v2"
-)
-
-// CompactRenderer handles rendering messages in a space-efficient compact format,
-// optimized for terminals with limited vertical space. It displays messages with
-// minimal decorations while maintaining readability and essential information.
-type CompactRenderer struct {
-	width int
-	debug bool
-
-	// getToolRenderer returns extension-provided rendering overrides for a
-	// specific tool. May be nil if no extensions are loaded. Used in
-	// RenderToolMessage to check for custom header/body formatting before
-	// falling back to builtin renderers.
-	getToolRenderer func(toolName string) *ToolRendererData
-}
-
-// NewCompactRenderer creates and initializes a new CompactRenderer with the specified
-// terminal width and debug mode setting. The width parameter determines line wrapping,
-// while debug enables additional diagnostic output in rendered messages.
-func NewCompactRenderer(width int, debug bool) *CompactRenderer {
-	return &CompactRenderer{
-		width: width,
-		debug: debug,
-	}
-}
-
-// SetWidth updates the terminal width for the renderer, affecting how content
-// is wrapped and formatted in subsequent render operations.
-func (r *CompactRenderer) SetWidth(width int) {
-	r.width = width
-}
-
-// RenderUserMessage renders a user's input message in compact format with a
-// distinctive symbol (>) and label. The content is formatted to preserve structure
-// while minimizing vertical space usage. Returns a UIMessage with formatted content
-// and metadata.
-func (r *CompactRenderer) RenderUserMessage(content string, timestamp time.Time) UIMessage {
-	theme := getTheme()
-	symbol := lipgloss.NewStyle().Foreground(theme.Info).Render(">")
-	label := lipgloss.NewStyle().Foreground(theme.Info).Bold(true).Render("User")
-
-	// Only run markdown rendering when the message contains code spans or
-	// fenced code blocks. Plain text is rendered directly so that newlines
-	// are preserved without the extra paragraph spacing glamour adds.
-	var compactContent string
-	if strings.Contains(content, "`") {
-		mdContent := strings.ReplaceAll(content, "\n", "\n\n")
-		compactContent = r.formatUserAssistantContent(mdContent)
-		compactContent = removeBlankLines(compactContent)
-	} else {
-		compactContent = content
-	}
-
-	// Handle multi-line content
-	lines := strings.Split(compactContent, "\n")
-	var formattedLines []string
-
-	for i, line := range lines {
-		if i == 0 {
-			// First line includes symbol and label
-			formattedLines = append(formattedLines, fmt.Sprintf("%s  %s %s", symbol, label, line))
-		} else {
-			// Subsequent lines without indentation for compact mode
-			formattedLines = append(formattedLines, line)
-		}
-	}
-
-	return UIMessage{
-		Type:      UserMessage,
-		Content:   strings.Join(formattedLines, "\n"),
-		Height:    len(formattedLines),
-		Timestamp: timestamp,
-	}
-}
-
-// RenderAssistantMessage renders an AI assistant's response in compact format with
-// a distinctive symbol (<) and the model name as label. Empty content is ignored
-// and returns an empty message. Returns a UIMessage with formatted content and metadata.
-func (r *CompactRenderer) RenderAssistantMessage(content string, timestamp time.Time, modelName string) UIMessage {
-	// Ignore empty responses - don't render anything
-	compactContent := r.formatUserAssistantContent(content)
-	if compactContent == "" {
-		return UIMessage{
-			Type:      AssistantMessage,
-			Content:   "",
-			Height:    0,
-			Timestamp: timestamp,
-		}
-	}
-
-	theme := getTheme()
-	symbol := lipgloss.NewStyle().Foreground(theme.Primary).Render("<")
-
-	// Use the full model name, fallback to "Assistant" if empty
-	if modelName == "" {
-		modelName = "Assistant"
-	}
-	label := lipgloss.NewStyle().Foreground(theme.Primary).Bold(true).Render(modelName)
-
-	// Handle multi-line content
-	lines := strings.Split(compactContent, "\n")
-	var formattedLines []string
-
-	for i, line := range lines {
-		if i == 0 {
-			// First line includes symbol and label
-			formattedLines = append(formattedLines, fmt.Sprintf("%s  %s %s", symbol, label, line))
-		} else {
-			// Subsequent lines without indentation for compact mode
-			formattedLines = append(formattedLines, line)
-		}
-	}
-
-	return UIMessage{
-		Type:      AssistantMessage,
-		Content:   strings.Join(formattedLines, "\n"),
-		Height:    len(formattedLines),
-		Timestamp: timestamp,
-	}
-}
-
-// RenderToolMessage renders a unified tool block in compact format, combining
-// the tool invocation header (icon + display name + params) with the execution
-// result body. Status is indicated by icon: checkmark for success, cross for error.
-func (r *CompactRenderer) RenderToolMessage(toolName, toolArgs, toolResult string, isError bool) UIMessage {
-	theme := getTheme()
-
-	// Resolve extension renderer once for all overrides.
-	var extRd *ToolRendererData
-	if r.getToolRenderer != nil {
-		extRd = r.getToolRenderer(toolName)
-	}
-
-	// Status icon
-	var icon string
-	iconColor := theme.Success
-	if isError {
-		icon = "×"
-		iconColor = theme.Error
-	} else {
-		icon = "✓"
-	}
-
-	iconStr := lipgloss.NewStyle().Foreground(iconColor).Bold(true).Render(icon)
-
-	// Extension can override display name.
-	displayName := toolDisplayName(toolName)
-	if extRd != nil && extRd.DisplayName != "" {
-		displayName = extRd.DisplayName
-	}
-	nameStr := lipgloss.NewStyle().Foreground(theme.Info).Bold(true).Render(displayName)
-
-	// Format params — check extension renderer first.
-	paramBudget := max(r.width-10-len(displayName), 20)
-	var params string
-	if extRd != nil && extRd.RenderHeader != nil {
-		params = extRd.RenderHeader(toolArgs, paramBudget)
-	}
-	if params == "" {
-		params = formatToolParams(toolArgs, paramBudget)
-	}
-
-	// Build header line
-	header := iconStr + " " + nameStr
-	if params != "" {
-		header += " " + lipgloss.NewStyle().Foreground(theme.Muted).Render(params)
-	}
-
-	// Format body: check extension renderer first, then compact builtin, then default.
-	var body string
-	if extRd != nil && extRd.RenderBody != nil {
-		body = extRd.RenderBody(toolResult, isError, r.width-4)
-		// Apply markdown rendering if requested and body is non-empty.
-		if body != "" && extRd.BodyMarkdown {
-			body = strings.TrimSuffix(toMarkdown(body, r.width-4), "\n")
-		}
-	}
-	if body == "" {
-		if isError {
-			body = lipgloss.NewStyle().Foreground(theme.Error).Render(r.formatToolResult(toolResult))
-		} else {
-			// Use compact summary renderers instead of full tool body renderers.
-			body = renderToolBodyCompact(toolName, toolArgs, toolResult, r.width-4)
-			if body == "" {
-				formatted := r.formatToolResult(toolResult)
-				if formatted == "" {
-					body = lipgloss.NewStyle().Foreground(theme.Muted).Italic(true).Render("(no output)")
-				} else {
-					body = lipgloss.NewStyle().Foreground(theme.Muted).Render(formatted)
-				}
-			}
-		}
-	}
-
-	// Combine header + indented body
-	var lines []string
-	lines = append(lines, header)
-	if body != "" {
-		for line := range strings.SplitSeq(body, "\n") {
-			lines = append(lines, "  "+line)
-		}
-	}
-
-	return UIMessage{
-		Type:    ToolMessage,
-		Content: strings.Join(lines, "\n"),
-		Height:  len(lines),
-	}
-}
-
-// RenderSystemMessage renders a system notification or informational message in
-// compact format with a distinctive symbol (*) and "System" label. Content is
-// formatted to fit on a single line for minimal space usage.
-func (r *CompactRenderer) RenderSystemMessage(content string, timestamp time.Time) UIMessage {
-	theme := getTheme()
-	symbol := lipgloss.NewStyle().Foreground(theme.Muted).Render("◇")
-	label := lipgloss.NewStyle().Foreground(theme.Muted).Bold(true).Render("System")
-
-	compactContent := r.formatCompactContent(content)
-
-	line := fmt.Sprintf("%s  %-8s %s", symbol, label, compactContent)
-
-	return UIMessage{
-		Type:      SystemMessage,
-		Content:   line,
-		Height:    1,
-		Timestamp: timestamp,
-	}
-}
-
-// RenderErrorMessage renders an error notification in compact format with a
-// distinctive error symbol (!) and styling to ensure visibility. The error
-// content is displayed in a single line with appropriate color highlighting.
-func (r *CompactRenderer) RenderErrorMessage(errorMsg string, timestamp time.Time) UIMessage {
-	theme := getTheme()
-	symbol := lipgloss.NewStyle().Foreground(theme.Error).Render("!")
-	label := lipgloss.NewStyle().Foreground(theme.Error).Bold(true).Render("Error")
-
-	compactContent := lipgloss.NewStyle().Foreground(theme.Error).Render(r.formatCompactContent(errorMsg))
-
-	line := fmt.Sprintf("%s  %-8s %s", symbol, label, compactContent)
-
-	return UIMessage{
-		Type:      ErrorMessage,
-		Content:   line,
-		Height:    1,
-		Timestamp: timestamp,
-	}
-}
-
-// RenderDebugMessage renders diagnostic information in compact format when debug
-// mode is enabled. Messages are truncated if they exceed the available width to
-// maintain single-line display.
-func (r *CompactRenderer) RenderDebugMessage(message string, timestamp time.Time) UIMessage {
-	theme := getTheme()
-	symbol := lipgloss.NewStyle().Foreground(theme.Tool).Render("*")
-	label := lipgloss.NewStyle().Foreground(theme.Tool).Bold(true).Render("Debug")
-
-	// Truncate message if too long
-	content := message
-	if len(content) > r.width-20 {
-		content = content[:r.width-23] + "..."
-	}
-
-	line := fmt.Sprintf("%s  %-8s %s", symbol, label, content)
-
-	return UIMessage{
-		Type:      SystemMessage,
-		Content:   line,
-		Height:    1,
-		Timestamp: timestamp,
-	}
-}
-
-// RenderDebugConfigMessage renders configuration settings in compact format for
-// debugging purposes. Config entries are displayed as key=value pairs separated
-// by commas, truncated if necessary to fit on a single line.
-func (r *CompactRenderer) RenderDebugConfigMessage(config map[string]any, timestamp time.Time) UIMessage {
-	theme := getTheme()
-	symbol := lipgloss.NewStyle().Foreground(theme.Tool).Render("*")
-	label := lipgloss.NewStyle().Foreground(theme.Tool).Bold(true).Render("Debug")
-
-	// Format config as compact key=value pairs
-	var configPairs []string
-	for key, value := range config {
-		if value != nil {
-			configPairs = append(configPairs, fmt.Sprintf("%s=%v", key, value))
-		}
-	}
-
-	content := strings.Join(configPairs, ", ")
-	if len(content) > r.width-20 {
-		content = content[:r.width-23] + "..."
-	}
-
-	line := fmt.Sprintf("%s  %-8s %s", symbol, label, content)
-
-	return UIMessage{
-		Type:      SystemMessage,
-		Content:   line,
-		Height:    1,
-		Timestamp: timestamp,
-	}
-}
-
-// formatCompactContent formats content for compact single-line display
-func (r *CompactRenderer) formatCompactContent(content string) string {
-	if content == "" {
-		return ""
-	}
-
-	// Remove markdown formatting for compact display
-	content = strings.ReplaceAll(content, "\n", " ")
-	content = strings.ReplaceAll(content, "\t", " ")
-
-	// Collapse multiple spaces
-	for strings.Contains(content, "  ") {
-		content = strings.ReplaceAll(content, "  ", " ")
-	}
-
-	content = strings.TrimSpace(content)
-
-	// Truncate if too long (unless in debug mode)
-	maxLen := max(
-		// Reserve space for symbol and label more conservatively
-		r.width-28,
-		// Minimum width for readability
-		40)
-	if !r.debug && len(content) > maxLen {
-		content = content[:maxLen-3] + "..."
-	}
-
-	return content
-}
-
-// formatUserAssistantContent formats user and assistant content using glamour markdown rendering
-func (r *CompactRenderer) formatUserAssistantContent(content string) string {
-	if content == "" {
-		return ""
-	}
-
-	// Calculate available width more conservatively
-	// Account for: symbol (1) + spaces (2) + label (up to 20 chars) + space (1) + margin (4)
-	availableWidth := max(r.width-28,
-		// Minimum width for readability
-		40)
-
-	// Use glamour to render markdown content with proper width
-	rendered := toMarkdown(content, availableWidth)
-	return strings.TrimSuffix(rendered, "\n")
-}
-
-// wrapText wraps text to the specified width, preserving existing line breaks
-func (r *CompactRenderer) wrapText(text string, width int) string {
-	if width <= 0 {
-		return text
-	}
-
-	lines := strings.Split(text, "\n")
-	var wrappedLines []string
-
-	for _, line := range lines {
-		if len(line) <= width {
-			wrappedLines = append(wrappedLines, line)
-			continue
-		}
-
-		// Wrap long lines
-		words := strings.Fields(line)
-		if len(words) == 0 {
-			wrappedLines = append(wrappedLines, line)
-			continue
-		}
-
-		currentLine := ""
-		for _, word := range words {
-			// If adding this word would exceed the width, start a new line
-			if len(currentLine)+len(word)+1 > width && currentLine != "" {
-				wrappedLines = append(wrappedLines, currentLine)
-				currentLine = word
-			} else {
-				if currentLine == "" {
-					currentLine = word
-				} else {
-					currentLine += " " + word
-				}
-			}
-		}
-		if currentLine != "" {
-			wrappedLines = append(wrappedLines, currentLine)
-		}
-	}
-
-	return strings.Join(wrappedLines, "\n")
-}
-
-// formatToolArgs formats tool arguments for compact display
-func (r *CompactRenderer) formatToolArgs(args string) string {
-	if args == "" || args == "{}" {
-		return ""
-	}
-
-	// Remove JSON braces and format compactly
-	args = strings.TrimSpace(args)
-	if strings.HasPrefix(args, "{") && strings.HasSuffix(args, "}") {
-		args = strings.TrimPrefix(args, "{")
-		args = strings.TrimSuffix(args, "}")
-		args = strings.TrimSpace(args)
-	}
-
-	// Remove quotes around simple values
-	args = strings.ReplaceAll(args, `"`, "")
-
-	// Remove parameter names (e.g., "command: ls" -> "ls", "path: /home" -> "/home")
-	// Look for pattern "key: value" and extract just the value
-	if colonIndex := strings.Index(args, ":"); colonIndex != -1 {
-		args = strings.TrimSpace(args[colonIndex+1:])
-	}
-
-	return r.formatCompactContent(args)
-}
-
-// formatToolResult formats tool results preserving formatting but limiting to 5 lines
-func (r *CompactRenderer) formatToolResult(result string) string {
-	if result == "" {
-		return ""
-	}
-
-	// Check if this is bash output with stdout/stderr tags
-	if strings.Contains(result, "<stdout>") || strings.Contains(result, "<stderr>") {
-		result = r.formatBashOutput(result)
-	}
-
-	// Calculate available width more conservatively
-	availableWidth := max(r.width-28,
-		// Minimum width for readability
-		40)
-
-	// First wrap the text to prevent long lines (tool results are usually plain text, not markdown)
-	wrappedResult := r.wrapText(result, availableWidth)
-
-	// Then limit to 5 lines
-	lines := strings.Split(wrappedResult, "\n")
-	if len(lines) > 5 {
-		lines = lines[:5]
-		// Add truncation indicator
-		if len(lines) == 5 && lines[4] != "" {
-			lines[4] = lines[4] + "..."
-		} else {
-			lines = append(lines, "...")
-		}
-	}
-
-	return strings.Join(lines, "\n")
-}
-
-// formatBashOutput formats bash command output by removing stdout/stderr tags
-// and styling appropriately. Delegates tag parsing to the shared parseBashOutput
-// helper.
-func (r *CompactRenderer) formatBashOutput(result string) string {
-	return parseBashOutput(result, getTheme())
-}

internal/ui/enhanced_styles.go

@@ -35,8 +35,11 @@ func GetTheme() Theme {
 
 // SetTheme updates the global UI theme, affecting all subsequent rendering
 // operations. This allows runtime theme switching for different visual preferences.
+// It also invalidates the markdownTypographyCache so the next call to
+// GetMarkdownTypography picks up the new theme.
 func SetTheme(theme Theme) {
 	currentTheme = theme
+	markdownTypographyCache = nil // invalidate cached renderer; colors may have changed
 }
 
 // MarkdownThemeColors defines colors for markdown rendering and syntax highlighting.
@@ -291,40 +294,3 @@ func ApplyGradient(text string, colorA, colorB color.Color) string {
 
 	return result.String()
 }
-
-// Compact styling utilities
-
-// StyleCompactSymbol creates a lipgloss style for message type indicators in
-// compact mode, using bold colored text to distinguish different message categories.
-func StyleCompactSymbol(symbol string, c color.Color) lipgloss.Style {
-	return lipgloss.NewStyle().
-		Foreground(c).
-		Bold(true)
-}
-
-// StyleCompactLabel creates a lipgloss style for message labels in compact mode
-// with fixed width for alignment and bold colored text for readability.
-func StyleCompactLabel(c color.Color) lipgloss.Style {
-	return lipgloss.NewStyle().
-		Foreground(c).
-		Bold(true).
-		Width(8)
-}
-
-// StyleCompactContent creates a simple lipgloss style for message content in
-// compact mode, applying only color without additional formatting.
-func StyleCompactContent(c color.Color) lipgloss.Style {
-	return lipgloss.NewStyle().
-		Foreground(c)
-}
-
-// FormatCompactLine assembles a complete compact mode message line with consistent
-// spacing and styling. Combines a symbol, fixed-width label, and content with their
-// respective colors to create a uniform appearance across all message types.
-func FormatCompactLine(symbol, label, content string, symbolColor, labelColor, contentColor color.Color) string {
-	styledSymbol := StyleCompactSymbol(symbol, symbolColor).Render(symbol)
-	styledLabel := StyleCompactLabel(labelColor).Render(label)
-	styledContent := StyleCompactContent(contentColor).Render(content)
-
-	return fmt.Sprintf("%s  %-8s %s", styledSymbol, styledLabel, styledContent)
-}

internal/ui/factory.go

@@ -25,7 +25,6 @@ type CLISetupOptions struct {
 	Agent          AgentInterface
 	ModelString    string
 	Debug          bool
-	Compact        bool
 	Quiet          bool
 	ShowDebug      bool   // Whether to show debug config
 	ProviderAPIKey string // For OAuth detection
@@ -76,7 +75,7 @@ func SetupCLI(opts *CLISetupOptions) (*CLI, error) {
 		return nil, nil // No CLI in quiet mode
 	}
 
-	cli, err := NewCLI(opts.Debug, opts.Compact)
+	cli, err := NewCLI(opts.Debug)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create CLI: %v", err)
 	}

internal/ui/file_suggestions.go

@@ -355,5 +355,3 @@ func scoreFilePath(query, path string) int {
 
 	return 0
 }
-
-

internal/ui/format.go

@@ -7,29 +7,29 @@ import (
 	"charm.land/lipgloss/v2"
 )
 
-// Renderer is the interface satisfied by both MessageRenderer and
-// CompactRenderer. It allows model.go and cli.go to call rendering methods
-// without branching on compact mode.
+// Renderer is the interface satisfied by MessageRenderer. It allows model.go
+// and cli.go to call rendering methods uniformly.
 type Renderer interface {
 	RenderUserMessage(content string, timestamp time.Time) UIMessage
 	RenderAssistantMessage(content string, timestamp time.Time, modelName string) UIMessage
+	RenderReasoningBlock(content string, timestamp time.Time) UIMessage
 	RenderToolMessage(toolName, toolArgs, toolResult string, isError bool) UIMessage
 	RenderSystemMessage(content string, timestamp time.Time) UIMessage
 	RenderErrorMessage(errorMsg string, timestamp time.Time) UIMessage
 	RenderDebugMessage(message string, timestamp time.Time) UIMessage
 	RenderDebugConfigMessage(config map[string]any, timestamp time.Time) UIMessage
 	SetWidth(width int)
+	UpdateTheme()
 }
 
-// Compile-time checks that both renderers satisfy the Renderer interface.
+// Compile-time check that MessageRenderer satisfies the Renderer interface.
 var _ Renderer = (*MessageRenderer)(nil)
-var _ Renderer = (*CompactRenderer)(nil)
 
 // parseBashOutput parses <stdout>/<stderr> tagged output from bash tool
 // results, styling stderr with the theme's error color. Returns the
 // combined, styled output string with tags stripped.
 //
-// Shared by both MessageRenderer and CompactRenderer.
+// Shared by MessageRenderer.
 func parseBashOutput(result string, theme Theme) string {
 	var formattedResult strings.Builder
 	remaining := result

internal/ui/input.go

@@ -409,21 +409,14 @@ func (s *InputComponent) handleSubmit(value string) tea.Cmd {
 	}
 
 	// Resolve via canonical command lookup so aliases are handled uniformly.
-	// Only /quit and /clear are handled locally — /clear-queue must go
-	// through the parent model so it can update queueCount directly
-	// (calling ClearQueue here would skip the UI state update since we
-	// can't send events from within Update without deadlocking).
+	// Only /quit is handled locally — all other slash commands (including
+	// /clear and /clear-queue) are forwarded to the parent model via
+	// submitMsg so the parent can update its own state (scrollback, queue
+	// counts, etc.) in one place.
 	if sc := GetCommandByName(trimmed); sc != nil {
 		switch sc.Name {
 		case "/quit":
 			return tea.Quit
-
-		case "/clear":
-			if s.appCtrl != nil {
-				s.appCtrl.ClearMessages()
-			}
-			// Don't forward to app.Run(); just clear silently.
-			return nil
 		}
 	}
 
@@ -493,10 +486,8 @@ func (s *InputComponent) View() tea.View {
 	view.WriteString("\n")
 	view.WriteString(inputBoxStyle.Render(s.textarea.View()))
 
-	if s.showPopup && len(s.filtered) > 0 {
-		view.WriteString("\n")
-		view.WriteString(s.renderPopup())
-	}
+	// Popup is now rendered as a centered overlay in AppModel.View()
+	// instead of inline here to prevent bottom overflow
 
 	// Show image attachment indicator when images are pending.
 	if len(s.pendingImages) > 0 {
@@ -540,11 +531,40 @@ func (s *InputComponent) View() tea.View {
 		view.WriteString(helpStyle.Render(hint))
 	}
 
-	return tea.NewView(containerStyle.Render(view.String()))
+	v := tea.NewView(containerStyle.Render(view.String()))
+	v.AltScreen = true
+	v.MouseMode = tea.MouseModeCellMotion
+	v.ReportFocus = true
+	v.KeyboardEnhancements = tea.KeyboardEnhancements{
+		ReportEventTypes: true,
+	}
+	return v
 }
 
 // renderPopup renders the autocomplete popup for slash command suggestions.
-func (s *InputComponent) renderPopup() string {
+// When rendered inline (not centered), returns the styled popup content.
+// RenderPopupCentered renders the popup as a centered overlay.
+func (s *InputComponent) RenderPopupCentered(termWidth, termHeight int) string {
+	if !s.showPopup || len(s.filtered) == 0 {
+		return ""
+	}
+
+	popupContent := s.renderPopupWithOptions(true)
+
+	// Center popup using lipgloss.Place
+	positioned := lipgloss.Place(
+		termWidth,
+		termHeight,
+		lipgloss.Center,
+		lipgloss.Center,
+		popupContent,
+	)
+
+	return positioned
+}
+
+// renderPopupWithOptions renders the popup content with optional center styling.
+func (s *InputComponent) renderPopupWithOptions(centered bool) string {
 	theme := GetTheme()
 	popupWidth := max(s.width-4, 20)
 	popupStyle := lipgloss.NewStyle().

internal/ui/message_items.go

@@ -0,0 +1,398 @@
+package ui
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"charm.land/lipgloss/v2"
+)
+
+// --------------------------------------------------------------------------
+// MessageItem implementations for ScrollList
+// --------------------------------------------------------------------------
+
+// TextMessageItem represents a completed text message (user or assistant)
+// in the scrollback. It uses pre-rendered styled content from MessageRenderer.
+type TextMessageItem struct {
+	id          string
+	role        string // "user" or "assistant"
+	content     string // Raw content (for re-rendering if needed)
+	preRendered string // Pre-rendered styled content from MessageRenderer
+	timestamp   time.Time
+}
+
+// NewTextMessageItem creates a new text message for the scrollback.
+// The content should be pre-rendered using MessageRenderer for proper styling.
+func NewTextMessageItem(id string, role string, content string) *TextMessageItem {
+	return &TextMessageItem{
+		id:        id,
+		role:      role,
+		content:   content,
+		timestamp: time.Now(),
+	}
+}
+
+// NewStyledMessageItem creates a message item with pre-rendered styled content.
+// This is the preferred way to create messages when you have styled content from MessageRenderer.
+func NewStyledMessageItem(id string, role string, rawContent string, preRendered string) *TextMessageItem {
+	return &TextMessageItem{
+		id:          id,
+		role:        role,
+		content:     rawContent,
+		preRendered: preRendered,
+		timestamp:   time.Now(),
+	}
+}
+
+func (m *TextMessageItem) ID() string {
+	return m.id
+}
+
+func (m *TextMessageItem) Render(width int) string {
+	// If we have pre-rendered styled content, return it
+	if m.preRendered != "" {
+		return m.preRendered
+	}
+
+	// Fallback to simple formatting if no pre-rendered content
+	return m.renderContent(width)
+}
+
+func (m *TextMessageItem) Height() int {
+	rendered := m.Render(0) // Width doesn't matter since we use pre-rendered
+	if rendered == "" {
+		return 0
+	}
+	return strings.Count(rendered, "\n") + 1
+}
+
+func (m *TextMessageItem) renderContent(width int) string {
+	var parts []string
+
+	// Role indicator
+	if m.role == "user" {
+		parts = append(parts, "│ ▸ You")
+	} else {
+		parts = append(parts, "") // Assistant messages start without role
+	}
+
+	// Content with simple wrapping
+	contentWidth := max(width-4, 20)
+
+	for line := range strings.SplitSeq(m.content, "\n") {
+		if len(line) <= contentWidth {
+			parts = append(parts, "│ "+line)
+		} else {
+			// Basic wrap
+			for len(line) > contentWidth {
+				parts = append(parts, "│ "+line[:contentWidth])
+				line = line[contentWidth:]
+			}
+			if len(line) > 0 {
+				parts = append(parts, "│ "+line)
+			}
+		}
+	}
+
+	return strings.Join(parts, "\n")
+}
+
+// --------------------------------------------------------------------------
+// StreamingMessageItem - Live streaming assistant/reasoning text
+// --------------------------------------------------------------------------
+
+// StreamingMessageItem represents actively streaming assistant or reasoning text.
+// It accumulates content chunks and re-renders on each update for live display.
+type StreamingMessageItem struct {
+	id            string
+	role          string // "assistant" or "reasoning"
+	content       string // Accumulated streaming content
+	timestamp     time.Time
+	startTime     time.Time // When streaming started (for live duration counter)
+	modelName     string
+	streaming     bool          // true while actively streaming
+	finalDuration time.Duration // Frozen duration when complete
+	cachedRender  string
+	cachedWidth   int
+}
+
+// NewStreamingMessageItem creates a new streaming message item.
+func NewStreamingMessageItem(id, role string, modelName string) *StreamingMessageItem {
+	now := time.Now()
+	return &StreamingMessageItem{
+		id:        id,
+		role:      role,
+		timestamp: now,
+		startTime: now,
+		modelName: modelName,
+		streaming: true,
+	}
+}
+
+// ID returns the unique identifier.
+func (s *StreamingMessageItem) ID() string {
+	return s.id
+}
+
+// Render renders the streaming message with live content.
+func (s *StreamingMessageItem) Render(width int) string {
+	// For reasoning, never cache - we need live duration updates
+	// For assistant, cache is OK
+	if s.role != "reasoning" && s.cachedWidth == width && s.cachedRender != "" {
+		return s.cachedRender
+	}
+
+	// Get renderer from context
+	renderer := newMessageRenderer(width, false)
+
+	var rendered string
+	if s.role == "reasoning" {
+		// Render as reasoning/thinking block with live duration counter
+		theme := GetTheme()
+		mutedStyle := lipgloss.NewStyle().Foreground(theme.Muted)
+		ty := createTypography(theme)
+		content := strings.TrimLeft(s.content, " \t\n")
+
+		var parts []string
+		parts = append(parts, mutedStyle.Render(ty.Italic(content)))
+
+		// Add live duration counter (updates on each render)
+		var duration time.Duration
+		if s.finalDuration > 0 {
+			// Streaming complete, show frozen duration
+			duration = s.finalDuration
+		} else if !s.startTime.IsZero() {
+			// Still streaming, show live duration
+			duration = time.Since(s.startTime)
+		}
+
+		if duration > 0 {
+			var durationStr string
+			if duration < time.Second {
+				durationStr = fmt.Sprintf("%dms", duration.Milliseconds())
+			} else {
+				durationStr = fmt.Sprintf("%.1fs", duration.Seconds())
+			}
+			label := lipgloss.NewStyle().Foreground(theme.VeryMuted).Render("Thought for ")
+			durationStyled := lipgloss.NewStyle().Foreground(theme.Accent).Render(durationStr)
+			parts = append(parts, label+durationStyled)
+		}
+
+		rendered = styleMarginBottom1.Render(strings.Join(parts, "\n"))
+	} else {
+		// Render as assistant message
+		msg := renderer.RenderAssistantMessage(s.content, s.timestamp, s.modelName)
+		rendered = msg.Content
+	}
+
+	// Cache and return (but reasoning is never cached due to live duration)
+	if s.role != "reasoning" {
+		s.cachedRender = rendered
+		s.cachedWidth = width
+	}
+	return rendered
+}
+
+// Height returns the number of lines.
+func (s *StreamingMessageItem) Height() int {
+	if s.cachedRender == "" {
+		return 0
+	}
+	return strings.Count(s.cachedRender, "\n") + 1
+}
+
+// AppendChunk adds a content chunk and invalidates the render cache.
+func (s *StreamingMessageItem) AppendChunk(chunk string) {
+	s.content += chunk
+	s.cachedWidth = 0 // Invalidate cache
+}
+
+// MarkComplete marks the streaming message as complete and freezes the duration.
+func (s *StreamingMessageItem) MarkComplete() {
+	s.streaming = false
+	// Freeze the duration for reasoning blocks
+	if s.role == "reasoning" && !s.startTime.IsZero() {
+		s.finalDuration = time.Since(s.startTime)
+	}
+}
+
+// --------------------------------------------------------------------------
+// StreamingBashOutputItem - Live bash command output
+// --------------------------------------------------------------------------
+
+// StreamingBashOutputItem represents live bash command output.
+type StreamingBashOutputItem struct {
+	id           string
+	command      string
+	stdoutLines  []string
+	stderrLines  []string
+	maxLines     int
+	complete     bool
+	cachedRender string
+	cachedWidth  int
+}
+
+// NewStreamingBashOutputItem creates a new streaming bash output item.
+func NewStreamingBashOutputItem(id string, command string) *StreamingBashOutputItem {
+	return &StreamingBashOutputItem{
+		id:          id,
+		command:     command,
+		stdoutLines: make([]string, 0),
+		stderrLines: make([]string, 0),
+		maxLines:    100, // Cap lines to prevent memory issues
+		complete:    false,
+	}
+}
+
+func (m *StreamingBashOutputItem) ID() string {
+	return m.id
+}
+
+func (m *StreamingBashOutputItem) Render(width int) string {
+	// Return cached if width matches and complete
+	if m.complete && m.cachedWidth == width && m.cachedRender != "" {
+		return m.cachedRender
+	}
+
+	theme := GetTheme()
+	var parts []string
+
+	// Header with command
+	if m.command != "" {
+		headerStyle := lipgloss.NewStyle().
+			Foreground(theme.Muted).
+			Italic(true)
+		parts = append(parts, headerStyle.Render(fmt.Sprintf("▸ %s", m.command)))
+	}
+
+	const lineIndent = "  "
+	lineWidth := width - len(lineIndent)
+
+	// Stdout lines
+	if len(m.stdoutLines) > 0 {
+		outputStyle := lipgloss.NewStyle().
+			Foreground(theme.Text).
+			Background(theme.CodeBg).
+			PaddingLeft(1).
+			Width(lineWidth)
+		for _, line := range m.stdoutLines {
+			parts = append(parts, lineIndent+outputStyle.Render(line))
+		}
+	}
+
+	// Stderr lines
+	if len(m.stderrLines) > 0 {
+		stderrStyle := lipgloss.NewStyle().
+			Foreground(theme.Error).
+			Background(theme.CodeBg).
+			PaddingLeft(1).
+			Width(lineWidth)
+		for _, line := range m.stderrLines {
+			parts = append(parts, lineIndent+stderrStyle.Render(line))
+		}
+	}
+
+	result := strings.Join(parts, "\n")
+	if m.complete {
+		m.cachedRender = result
+		m.cachedWidth = width
+	}
+	return result
+}
+
+func (m *StreamingBashOutputItem) Height() int {
+	if m.cachedRender != "" {
+		return strings.Count(m.cachedRender, "\n") + 1
+	}
+	// Estimate: command header + stdout + stderr
+	return 1 + len(m.stdoutLines) + len(m.stderrLines)
+}
+
+// AppendStdout adds a stdout line to the output.
+func (m *StreamingBashOutputItem) AppendStdout(line string) {
+	m.stdoutLines = append(m.stdoutLines, line)
+	// Cap lines
+	if len(m.stdoutLines) > m.maxLines {
+		m.stdoutLines = m.stdoutLines[len(m.stdoutLines)-m.maxLines:]
+	}
+	m.cachedWidth = 0 // Invalidate cache
+}
+
+// AppendStderr adds a stderr line to the output.
+func (m *StreamingBashOutputItem) AppendStderr(line string) {
+	m.stderrLines = append(m.stderrLines, line)
+	// Cap lines
+	if len(m.stderrLines) > m.maxLines {
+		m.stderrLines = m.stderrLines[len(m.stderrLines)-m.maxLines:]
+	}
+	m.cachedWidth = 0 // Invalidate cache
+}
+
+// MarkComplete marks the bash output as complete.
+func (m *StreamingBashOutputItem) MarkComplete() {
+	m.complete = true
+}
+
+// --------------------------------------------------------------------------
+// SystemMessageItem - System messages (commands, info, errors)
+// --------------------------------------------------------------------------
+
+// SystemMessageItem represents a system message (commands, info, errors).
+type SystemMessageItem struct {
+	id           string
+	content      string
+	timestamp    time.Time
+	cachedRender string
+	cachedWidth  int
+}
+
+// NewSystemMessageItem creates a new system message for the scrollback.
+func NewSystemMessageItem(id, content string) *SystemMessageItem {
+	return &SystemMessageItem{
+		id:        id,
+		content:   content,
+		timestamp: time.Now(),
+	}
+}
+
+func (m *SystemMessageItem) ID() string {
+	return m.id
+}
+
+func (m *SystemMessageItem) Render(width int) string {
+	// Return cached render if width matches
+	if m.cachedWidth == width && m.cachedRender != "" {
+		return m.cachedRender
+	}
+
+	// Simple system message formatting
+	rendered := "│ " + strings.ReplaceAll(m.content, "\n", "\n│ ")
+
+	// Cache and return
+	m.cachedRender = rendered
+	m.cachedWidth = width
+	return rendered
+}
+
+func (m *SystemMessageItem) Height() int {
+	if m.cachedRender != "" {
+		return strings.Count(m.cachedRender, "\n") + 1
+	}
+	// Estimate
+	if m.cachedWidth > 0 {
+		return (len(m.content) / max(m.cachedWidth-10, 40)) + 3
+	}
+	return 3
+}
+
+// --------------------------------------------------------------------------
+// Helper: generateMessageID
+// --------------------------------------------------------------------------
+
+var messageCounter = 0
+
+func generateMessageID() string {
+	messageCounter++
+	return fmt.Sprintf("msg-%d-%d", time.Now().UnixNano(), messageCounter)
+}

internal/ui/messages.go

@@ -3,7 +3,6 @@ package ui
 import (
 	"encoding/json"
 	"fmt"
-	"regexp"
 	"sort"
 	"strings"
 	"time"
@@ -12,9 +11,6 @@ import (
 	"github.com/indaco/herald"
 )
 
-// ansiEscapeRe matches ANSI escape sequences used for terminal styling.
-var ansiEscapeRe = regexp.MustCompile(`\x1b\[[0-9;]*m`)
-
 // MessageType represents different categories of messages displayed in the UI,
 // each with distinct visual styling and formatting rules.
 type MessageType int
@@ -41,11 +37,6 @@ type UIMessage struct {
 	Streaming bool
 }
 
-// getTheme returns the current theme (helper for compact_renderer.go)
-func getTheme() Theme {
-	return GetTheme()
-}
-
 // toolDisplayName returns a human-friendly display name for a tool,
 // title-casing the first letter of the raw name.
 func toolDisplayName(rawName string) string {
@@ -163,7 +154,7 @@ func (r *MessageRenderer) RenderUserMessage(content string, timestamp time.Time)
 	}
 
 	rendered := r.ty.Tip(content)
-	rendered = lipgloss.NewStyle().MarginBottom(1).Render(rendered)
+	rendered = styleMarginBottom1.Render(rendered)
 
 	return UIMessage{
 		Type:      UserMessage,
@@ -186,7 +177,37 @@ func (r *MessageRenderer) RenderAssistantMessage(content string, timestamp time.
 
 	// Use markdown rendering with Chroma syntax highlighting
 	rendered := toMarkdown(content, r.width-4)
-	rendered = lipgloss.NewStyle().MarginBottom(1).Render(rendered)
+	rendered = styleMarginBottom1.Render(rendered)
+
+	return UIMessage{
+		Type:      AssistantMessage,
+		Content:   rendered,
+		Height:    lipgloss.Height(rendered),
+		Timestamp: timestamp,
+	}
+}
+
+// RenderReasoningBlock renders a reasoning/thinking block with the same styling
+// as live streaming: muted italic text with margin. This is used when resuming
+// sessions to display saved reasoning content.
+func (r *MessageRenderer) RenderReasoningBlock(content string, timestamp time.Time) UIMessage {
+	if strings.TrimSpace(content) == "" {
+		return UIMessage{
+			Type:      AssistantMessage,
+			Content:   "",
+			Height:    0,
+			Timestamp: timestamp,
+		}
+	}
+
+	theme := GetTheme()
+	// Match live streaming styling: muted italic text
+	// Same as stream.go renderReasoningBlock()
+	lines := strings.Split(strings.TrimRight(content, "\n"), "\n")
+	contentStr := strings.TrimLeft(strings.Join(lines, "\n"), " \t\n")
+	mutedStyle := lipgloss.NewStyle().Foreground(theme.Muted)
+	rendered := mutedStyle.Render(r.ty.Italic(contentStr))
+	rendered = styleMarginBottom1.Render(rendered)
 
 	return UIMessage{
 		Type:      AssistantMessage,
@@ -203,7 +224,7 @@ func (r *MessageRenderer) RenderSystemMessage(content string, timestamp time.Tim
 	}
 
 	rendered := r.ty.Note(content)
-	rendered = lipgloss.NewStyle().MarginBottom(1).Render(rendered)
+	rendered = styleMarginBottom1.Render(rendered)
 
 	return UIMessage{
 		Type:      SystemMessage,
@@ -229,7 +250,7 @@ func (r *MessageRenderer) RenderDebugMessage(message string, timestamp time.Time
 		header,
 		r.ty.P(strings.Join(formattedLines, "\n")),
 	)
-	content = lipgloss.NewStyle().MarginBottom(1).Render(content)
+	content = styleMarginBottom1.Render(content)
 
 	return UIMessage{
 		Content: content,
@@ -257,7 +278,7 @@ func (r *MessageRenderer) RenderDebugConfigMessage(config map[string]any, timest
 	} else {
 		content = header
 	}
-	content = lipgloss.NewStyle().MarginBottom(1).Render(content)
+	content = styleMarginBottom1.Render(content)
 
 	return UIMessage{
 		Type:      SystemMessage,
@@ -270,7 +291,7 @@ func (r *MessageRenderer) RenderDebugConfigMessage(config map[string]any, timest
 // RenderErrorMessage renders error notifications
 func (r *MessageRenderer) RenderErrorMessage(errorMsg string, timestamp time.Time) UIMessage {
 	rendered := r.ty.Caution(errorMsg)
-	rendered = lipgloss.NewStyle().MarginBottom(1).Render(rendered)
+	rendered = styleMarginBottom1.Render(rendered)
 
 	return UIMessage{
 		Type:      ErrorMessage,
@@ -354,7 +375,7 @@ func (r *MessageRenderer) RenderToolMessage(toolName, toolArgs, toolResult strin
 		"",
 		body,
 	)
-	fullContent = lipgloss.NewStyle().MarginBottom(1).Render(fullContent)
+	fullContent = styleMarginBottom1.Render(fullContent)
 
 	return UIMessage{
 		Type:    ToolMessage,
@@ -363,29 +384,6 @@ func (r *MessageRenderer) RenderToolMessage(toolName, toolArgs, toolResult strin
 	}
 }
 
-// formatToolArgs formats tool arguments for display
-func (r *MessageRenderer) formatToolArgs(args string) string {
-	args = strings.TrimSpace(args)
-	if strings.HasPrefix(args, "{") && strings.HasSuffix(args, "}") {
-		args = strings.TrimPrefix(args, "{")
-		args = strings.TrimSuffix(args, "}")
-		args = strings.TrimSpace(args)
-	}
-
-	if args == "" {
-		return "(no arguments)"
-	}
-
-	if !r.debug {
-		maxLen := 100
-		if len(args) > maxLen {
-			return args[:maxLen] + "..."
-		}
-	}
-
-	return args
-}
-
 // formatToolResult formats tool results based on tool type
 func (r *MessageRenderer) formatToolResult(toolName, result string) string {
 	if !r.debug {
@@ -436,14 +434,8 @@ func createTypography(theme Theme) *herald.Typography {
 	)
 }
 
-// removeBlankLines removes lines that are visually blank from rendered output.
-func removeBlankLines(s string) string {
-	lines := strings.Split(s, "\n")
-	filtered := lines[:0]
-	for _, line := range lines {
-		if strings.TrimSpace(ansiEscapeRe.ReplaceAllString(line, "")) != "" {
-			filtered = append(filtered, line)
-		}
-	}
-	return strings.Join(filtered, "\n")
+// UpdateTheme refreshes the renderer's typography instance with colors from
+// the current theme. This is called when the user changes themes via /theme.
+func (r *MessageRenderer) UpdateTheme() {
+	r.ty = createTypography(GetTheme())
 }

internal/ui/model_selector.go

@@ -50,7 +50,7 @@ func NewModelSelector(currentModel string, width, height int) *ModelSelectorComp
 	registry := models.GetGlobalRegistry()
 	var allModels []ModelEntry
 
-	for _, providerID := range registry.GetFantasyProviders() {
+	for _, providerID := range registry.GetLLMProviders() {
 		// Only include providers with valid API keys configured.
 		if err := registry.ValidateEnvironment(providerID, ""); err != nil {
 			continue
@@ -281,7 +281,14 @@ func (ms *ModelSelectorComponent) View() tea.View {
 	footerStyle := lipgloss.NewStyle().Foreground(theme.Muted).PaddingLeft(2)
 	b.WriteString(footerStyle.Render(strings.Join(footerParts, "  ")))
 
-	return tea.NewView(b.String())
+	v := tea.NewView(b.String())
+	v.AltScreen = true
+	v.MouseMode = tea.MouseModeCellMotion
+	v.ReportFocus = true
+	v.KeyboardEnhancements = tea.KeyboardEnhancements{
+		ReportEventTypes: true,
+	}
+	return v
 }
 
 // IsActive returns whether the selector is still accepting input.

internal/ui/model_test.go

@@ -5,9 +5,9 @@ import (
 	"testing"
 
 	tea "charm.land/bubbletea/v2"
-	"charm.land/fantasy"
 	"github.com/mark3labs/kit/internal/app"
 	"github.com/mark3labs/kit/internal/session"
+	kit "github.com/mark3labs/kit/pkg/kit"
 )
 
 // --------------------------------------------------------------------------
@@ -46,6 +46,10 @@ func (s *stubAppController) ClearMessages() {
 	s.clearMsgCalled++
 }
 
+func (s *stubAppController) ReloadMessagesFromTree() {
+	// no-op in tests
+}
+
 func (s *stubAppController) CompactConversation(_ string) error {
 	return nil
 }
@@ -66,7 +70,7 @@ func (s *stubAppController) AddContextMessage(_ string) {
 	// no-op in tests
 }
 
-func (s *stubAppController) RunWithFiles(prompt string, _ []fantasy.FilePart) int {
+func (s *stubAppController) RunWithFiles(prompt string, _ []kit.LLMFilePart) int {
 	s.runCalls = append(s.runCalls, prompt)
 	return s.queueLen
 }
@@ -97,9 +101,11 @@ func (s *stubStreamComponent) View() tea.View             { return tea.NewView("
 func (s *stubStreamComponent) Reset()                     { s.resetCalled++; s.renderedContent = "" }
 func (s *stubStreamComponent) SetHeight(h int)            { s.height = h }
 func (s *stubStreamComponent) GetRenderedContent() string { return s.renderedContent }
+func (s *stubStreamComponent) ConsumeOverflow() string    { return "" }
 func (s *stubStreamComponent) SpinnerView() string        { return "" }
 func (s *stubStreamComponent) SetThinkingVisible(bool)    {}
 func (s *stubStreamComponent) HasReasoning() bool         { return false }
+func (s *stubStreamComponent) UpdateTheme()               {}
 
 // stubInputComponent satisfies inputComponentIface without rendering anything.
 type stubInputComponent struct {
@@ -126,7 +132,6 @@ func newTestAppModel(ctrl AppController) (*AppModel, *stubStreamComponent, *stub
 		stream:                stream,
 		input:                 input,
 		renderer:              newMessageRenderer(80, false),
-		compactMode:           false,
 		modelName:             "test-model",
 		width:                 80,
 		height:                24,
@@ -142,7 +147,11 @@ func newTestAppModel(ctrl AppController) (*AppModel, *stubStreamComponent, *stub
 // sendMsg calls m.Update once with the given message and returns the updated model.
 func sendMsg(m *AppModel, msg tea.Msg) *AppModel {
 	updated, _ := m.Update(msg)
-	return updated.(*AppModel)
+	result := updated.(*AppModel)
+	// Simulate BubbleTea's frame cycle: View() is called after every Update().
+	// This flushes any pending layoutDirty work (e.g. distributeHeight).
+	_ = result.View()
+	return result
 }
 
 // --------------------------------------------------------------------------

internal/ui/progress/ollama.go

@@ -118,22 +118,33 @@ func (m ProgressModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 // status information and help text. Displays error messages if present or
 // a completion message when the download finishes.
 func (m ProgressModel) View() tea.View {
+	var v tea.View
+	v.AltScreen = true
+	v.MouseMode = tea.MouseModeCellMotion
+	v.ReportFocus = true
+	v.KeyboardEnhancements = tea.KeyboardEnhancements{
+		ReportEventTypes: true,
+	}
+
 	if m.err != nil {
-		return tea.NewView(fmt.Sprintf("Error: %s\n", m.err.Error()))
+		v.Content = fmt.Sprintf("Error: %s\n", m.err.Error())
+		return v
 	}
 
 	if m.complete {
-		return tea.NewView(fmt.Sprintf("\n%s%s\n\n%sComplete!\n",
+		v.Content = fmt.Sprintf("\n%s%s\n\n%sComplete!\n",
 			strings.Repeat(" ", padding),
 			m.progress.View(),
-			strings.Repeat(" ", padding)))
+			strings.Repeat(" ", padding))
+		return v
 	}
 
 	pad := strings.Repeat(" ", padding)
-	return tea.NewView(fmt.Sprintf("\n%s%s\n%s%s\n\n%s",
+	v.Content = fmt.Sprintf("\n%s%s\n%s%s\n\n%s",
 		pad, m.progress.View(),
 		pad, m.status,
-		pad+helpStyle("Press 'q' or Ctrl+C to cancel")))
+		pad+helpStyle("Press 'q' or Ctrl+C to cancel"))
+	return v
 }
 
 // ProgressReader wraps an io.Reader to intercept and parse Ollama pull operation

internal/ui/scrolllist.go

@@ -0,0 +1,698 @@
+package ui
+
+import (
+	"strings"
+
+	"charm.land/lipgloss/v2"
+)
+
+// highlightStyle is lazily initialized to avoid creating it on every render
+var highlightStyle lipgloss.Style
+
+// initHighlightStyle creates the highlight style with proper colors
+func initHighlightStyle() lipgloss.Style {
+	if highlightStyle.String() == "" {
+		theme := GetTheme()
+		highlightStyle = lipgloss.NewStyle().
+			Background(theme.Secondary).
+			Foreground(theme.Background).
+			Bold(true)
+	}
+	return highlightStyle
+}
+
+// MessageItem is the interface all scrollback messages must implement.
+// This allows lazy rendering - messages are only rendered when visible.
+type MessageItem interface {
+	// Render returns the styled content for this message at the given width.
+	// Implementations should cache the result to avoid re-rendering.
+	Render(width int) string
+
+	// Height returns the number of lines this message occupies when rendered.
+	Height() int
+
+	// ID returns a unique identifier for this message (for tracking).
+	ID() string
+}
+
+// ScrollList manages a viewport over a list of MessageItems.
+// It handles offset-based scrolling and lazy rendering. Only visible
+// items are rendered on each View() call.
+type ScrollList struct {
+	items      []MessageItem
+	offsetIdx  int // Index of first visible item
+	offsetLine int // Lines to skip from first visible item
+	width      int
+	height     int  // Viewport height in lines
+	autoScroll bool // Whether to auto-scroll to bottom on new content
+	itemGap    int  // Number of blank lines between items (0 = no gap)
+	focusedIdx int  // Index of focused/selected item (-1 = none)
+	selectable bool // Whether items can be selected via mouse/keyboard
+
+	// Selection tracking for copy+paste (crush-style)
+	selection     CopySelection // Current text selection
+	mouseDown     bool          // Whether mouse button is currently down
+	mouseDownX    int           // X coordinate where mouse was pressed
+	mouseDownY    int           // Y coordinate where mouse was pressed
+	mouseDownItem int           // Item index where mouse was pressed
+}
+
+// NewScrollList creates a new ScrollList with the given dimensions.
+func NewScrollList(width, height int) *ScrollList {
+	return &ScrollList{
+		items:      []MessageItem{},
+		offsetIdx:  0,
+		offsetLine: 0,
+		width:      width,
+		height:     height,
+		autoScroll: true, // Start with auto-scroll enabled
+	}
+}
+
+// SetItems replaces the items in the scroll list. If auto-scroll is enabled,
+// the viewport will scroll to the bottom to show the latest content.
+func (s *ScrollList) SetItems(items []MessageItem) {
+	s.items = items
+	if s.autoScroll {
+		s.GotoBottom()
+	}
+}
+
+// SetHeight updates the viewport height. Called when the terminal is resized.
+func (s *ScrollList) SetHeight(height int) {
+	s.height = height
+	s.clampOffset()
+}
+
+// SetWidth updates the viewport width. Called when the terminal is resized.
+// This may invalidate cached renders in MessageItems.
+func (s *ScrollList) SetWidth(width int) {
+	s.width = width
+	s.clampOffset()
+}
+
+// SetItemGap sets the number of blank lines between items (0 = no gap).
+func (s *ScrollList) SetItemGap(gap int) {
+	s.itemGap = gap
+}
+
+// ItemGap returns the current gap between items.
+func (s *ScrollList) ItemGap() int {
+	return s.itemGap
+}
+
+// SetSelectable enables or disables item selection.
+func (s *ScrollList) SetSelectable(selectable bool) {
+	s.selectable = selectable
+}
+
+// FocusedIdx returns the currently focused item index (-1 if none).
+func (s *ScrollList) FocusedIdx() int {
+	return s.focusedIdx
+}
+
+// SetFocused sets the focused item by index.
+func (s *ScrollList) SetFocused(idx int) {
+	if idx < -1 {
+		s.focusedIdx = -1
+	} else if idx >= len(s.items) {
+		s.focusedIdx = len(s.items) - 1
+	} else {
+		s.focusedIdx = idx
+	}
+}
+
+// SelectItemAtY selects the item at the given Y coordinate (relative to viewport).
+// Returns the selected item index or -1 if no item at that position.
+func (s *ScrollList) SelectItemAtY(y int) int {
+	if !s.selectable || len(s.items) == 0 || y < 0 || y >= s.height {
+		return -1
+	}
+
+	// Calculate which item is at the given Y position
+	currentY := 0
+	for idx := s.offsetIdx; idx < len(s.items); idx++ {
+		item := s.items[idx]
+		itemHeight := item.Height()
+
+		// Check if y falls within this item
+		if y >= currentY && y < currentY+itemHeight {
+			s.focusedIdx = idx
+			return idx
+		}
+
+		currentY += itemHeight
+
+		// Add gap after item (except last)
+		if s.itemGap > 0 && idx < len(s.items)-1 {
+			currentY += s.itemGap
+		}
+
+		// Stop if we've passed the viewport
+		if currentY >= s.height {
+			break
+		}
+	}
+
+	return -1
+}
+
+// HandleMouseDown handles mouse button press for selection (crush-style).
+// Returns true if the click was handled.
+func (s *ScrollList) HandleMouseDown(x, y int) bool {
+	if !s.selectable || len(s.items) == 0 {
+		return false
+	}
+
+	s.mouseDown = true
+	s.mouseDownX = x
+	s.mouseDownY = y
+
+	// Find which item and line was clicked
+	itemIdx, lineIdx := s.getItemAndLineAtY(y)
+	s.mouseDownItem = itemIdx
+
+	// Start a new selection at click position
+	if itemIdx >= 0 {
+		s.selection = CopySelection{
+			StartItemIdx: itemIdx,
+			StartLine:    lineIdx,
+			StartCol:     x,
+			EndItemIdx:   itemIdx,
+			EndLine:      lineIdx,
+			EndCol:       x,
+			Active:       true,
+		}
+		return true
+	}
+
+	return false
+}
+
+// HandleMouseDrag handles mouse drag for selection (crush-style).
+// Updates the selection end point. Returns true if selection changed.
+func (s *ScrollList) HandleMouseDrag(x, y int) bool {
+	if !s.mouseDown || !s.selectable {
+		return false
+	}
+
+	// Find which item and line we're dragging over
+	itemIdx, lineIdx := s.getItemAndLineAtY(y)
+	if itemIdx < 0 {
+		return false
+	}
+
+	// Update selection end point
+	s.selection.EndItemIdx = itemIdx
+	s.selection.EndLine = lineIdx
+	s.selection.EndCol = x
+	s.selection.Active = true
+
+	return true
+}
+
+// getItemAndLineAtY converts a Y coordinate to item index and line index within that item.
+// Returns (-1, -1) if Y is outside the viewport or beyond all items.
+func (s *ScrollList) getItemAndLineAtY(y int) (itemIdx, lineIdx int) {
+	if y < 0 || y >= s.height || len(s.items) == 0 {
+		return -1, -1
+	}
+
+	currentY := 0
+	for idx := s.offsetIdx; idx < len(s.items); idx++ {
+		item := s.items[idx]
+		itemHeight := item.Height()
+
+		// Check if y falls within this item
+		if y >= currentY && y < currentY+itemHeight {
+			return idx, y - currentY
+		}
+
+		currentY += itemHeight
+
+		// Add gap after item (except last)
+		if s.itemGap > 0 && idx < len(s.items)-1 {
+			currentY += s.itemGap
+		}
+
+		// Stop if we've passed the viewport
+		if currentY >= s.height {
+			break
+		}
+	}
+
+	return -1, -1
+}
+
+// HandleMouseUp handles mouse button release (crush-style).
+// Finalizes selection and returns true if there was an active selection.
+func (s *ScrollList) HandleMouseUp(x, y int) bool {
+	if !s.mouseDown {
+		return false
+	}
+
+	s.mouseDown = false
+
+	// Check if we have a valid selection
+	if s.selection.Active && !s.selection.IsEmpty() {
+		return true
+	}
+
+	return false
+}
+
+// GetSelection returns the current text selection.
+func (s *ScrollList) GetSelection() CopySelection {
+	return s.selection
+}
+
+// ClearSelection clears the current text selection.
+func (s *ScrollList) ClearSelection() {
+	s.selection = CopySelection{}
+	s.mouseDown = false
+}
+
+// HasSelection returns true if there is an active non-empty selection.
+func (s *ScrollList) HasSelection() bool {
+	return s.selection.Active && !s.selection.IsEmpty()
+}
+
+// ScrollBy scrolls the viewport by the given number of lines.
+// Positive = scroll down, negative = scroll up.
+func (s *ScrollList) ScrollBy(lines int) {
+	if lines > 0 {
+		// Scroll down
+		for lines > 0 && s.offsetIdx < len(s.items) {
+			if s.offsetIdx >= len(s.items) {
+				break
+			}
+			currentItem := s.items[s.offsetIdx]
+			itemHeight := currentItem.Height()
+			remainingLines := itemHeight - s.offsetLine
+
+			if lines >= remainingLines {
+				// Move to next item
+				s.offsetIdx++
+				s.offsetLine = 0
+				lines -= remainingLines
+				// Consume gap lines between items
+				if s.itemGap > 0 && s.offsetIdx < len(s.items) {
+					if lines >= s.itemGap {
+						lines -= s.itemGap
+					} else {
+						lines = 0
+					}
+				}
+			} else {
+				// Stay on current item, skip more lines
+				s.offsetLine += lines
+				lines = 0
+			}
+		}
+	} else if lines < 0 {
+		// Scroll up
+		lines = -lines
+		for lines > 0 && (s.offsetIdx > 0 || s.offsetLine > 0) {
+			if s.offsetLine > 0 {
+				// Scroll within current item
+				if lines >= s.offsetLine {
+					lines -= s.offsetLine
+					s.offsetLine = 0
+				} else {
+					s.offsetLine -= lines
+					lines = 0
+				}
+			} else if s.offsetIdx > 0 {
+				// Consume gap lines between items
+				if s.itemGap > 0 {
+					if lines > s.itemGap {
+						lines -= s.itemGap
+					} else {
+						lines = 0
+						continue
+					}
+				}
+				// Move to previous item
+				s.offsetIdx--
+				if s.offsetIdx < len(s.items) {
+					currentItem := s.items[s.offsetIdx]
+					itemHeight := currentItem.Height()
+
+					if lines >= itemHeight {
+						lines -= itemHeight
+						s.offsetLine = 0
+					} else {
+						s.offsetLine = itemHeight - lines
+						lines = 0
+					}
+				}
+			}
+		}
+	}
+	s.clampOffset()
+}
+
+// GotoBottom scrolls to the end of the list.
+func (s *ScrollList) GotoBottom() {
+	if len(s.items) == 0 {
+		s.offsetIdx = 0
+		s.offsetLine = 0
+		return
+	}
+
+	// Calculate total height including gaps
+	// Ensure items are rendered before checking height (iteratr pattern)
+	totalHeight := 0
+	for i, item := range s.items {
+		// Render to get actual content (handles non-cached items like reasoning blocks)
+		rendered := item.Render(s.width)
+		itemHeight := strings.Count(rendered, "\n") + 1
+		totalHeight += itemHeight
+		// Add gap after each item except the last
+		if s.itemGap > 0 && i < len(s.items)-1 {
+			totalHeight += s.itemGap
+		}
+	}
+
+	// If content fits in viewport, start at top
+	if totalHeight <= s.height {
+		s.offsetIdx = 0
+		s.offsetLine = 0
+		return
+	}
+
+	// Otherwise, position viewport at bottom
+	remaining := totalHeight - s.height
+	for idx := 0; idx < len(s.items); idx++ {
+		// Render to get actual content
+		rendered := s.items[idx].Render(s.width)
+		itemHeight := strings.Count(rendered, "\n") + 1
+		if remaining < itemHeight {
+			s.offsetIdx = idx
+			s.offsetLine = remaining
+			return
+		}
+		remaining -= itemHeight
+		// Subtract gap after item (except last)
+		if s.itemGap > 0 && idx < len(s.items)-1 {
+			remaining -= s.itemGap
+		}
+	}
+
+	// Fallback: show last item
+	s.offsetIdx = max(0, len(s.items)-1)
+	s.offsetLine = 0
+}
+
+// GotoTop scrolls to the beginning of the list.
+func (s *ScrollList) GotoTop() {
+	s.offsetIdx = 0
+	s.offsetLine = 0
+}
+
+// AtBottom returns true if the viewport is at the bottom of the list.
+func (s *ScrollList) AtBottom() bool {
+	if len(s.items) == 0 {
+		return true
+	}
+
+	// Calculate visible height from current position including gaps
+	// Calculate height directly from rendered content (handles non-cached items)
+	visibleHeight := 0
+	for idx := s.offsetIdx; idx < len(s.items); idx++ {
+		item := s.items[idx]
+		// Render to get actual content
+		rendered := item.Render(s.width)
+		itemHeight := strings.Count(rendered, "\n") + 1
+
+		if idx == s.offsetIdx {
+			visibleHeight += itemHeight - s.offsetLine
+		} else {
+			visibleHeight += itemHeight
+		}
+
+		// Add gap after item (except last)
+		if s.itemGap > 0 && idx < len(s.items)-1 {
+			visibleHeight += s.itemGap
+		}
+
+		if visibleHeight >= s.height {
+			return false
+		}
+	}
+
+	return true
+}
+
+// AtTop returns true if the viewport is at the top of the list.
+func (s *ScrollList) AtTop() bool {
+	return s.offsetIdx == 0 && s.offsetLine == 0
+}
+
+// View renders the visible portion of the scrollback.
+// Only items that fit within the viewport height are rendered.
+// ALWAYS returns exactly s.height lines (padded with empty lines if needed)
+// to ensure the input/footer stay fixed at the bottom.
+func (s *ScrollList) View() string {
+	if s.height <= 0 {
+		return ""
+	}
+
+	var lines []string
+	remainingHeight := s.height
+
+	// Render visible items
+	if len(s.items) > 0 {
+		for idx := s.offsetIdx; idx < len(s.items) && remainingHeight > 0; idx++ {
+			item := s.items[idx]
+			content := item.Render(s.width)
+			contentLines := strings.Split(content, "\n")
+
+			startLine := 0
+			if idx == s.offsetIdx {
+				startLine = s.offsetLine
+			}
+
+			// Check if this item is focused (for visual indicator)
+			isFocused := idx == s.focusedIdx
+
+			for i := startLine; i < len(contentLines) && remainingHeight > 0; i++ {
+				line := contentLines[i]
+
+				// Apply selection highlighting if this line is within selection
+				if s.selection.Active && s.isLineInSelection(idx, i) {
+					line = s.applyHighlight(line)
+				} else if isFocused && s.selectable {
+					// Apply subtle focus indicator when item is focused but not in selection
+					line = s.applyFocusIndicator(line)
+				}
+
+				lines = append(lines, line)
+				remainingHeight--
+			}
+
+			// Add gap lines between items (but not after the last visible item)
+			if remainingHeight > 0 && idx < len(s.items)-1 && s.itemGap > 0 {
+				for g := 0; g < s.itemGap && remainingHeight > 0; g++ {
+					lines = append(lines, "")
+					remainingHeight--
+				}
+			}
+		}
+	}
+
+	// Pad with empty lines to ensure exactly s.height lines
+	// This keeps the input/footer fixed at the bottom of the screen
+	for remainingHeight > 0 {
+		lines = append(lines, "")
+		remainingHeight--
+	}
+
+	return strings.Join(lines, "\n")
+}
+
+// isLineInSelection checks if a specific line within an item is part of the current selection.
+func (s *ScrollList) isLineInSelection(itemIdx, lineIdx int) bool {
+	if !s.selection.Active {
+		return false
+	}
+
+	// Normalize selection (start <= end)
+	startItem := s.selection.StartItemIdx
+	startLine := s.selection.StartLine
+	endItem := s.selection.EndItemIdx
+	endLine := s.selection.EndLine
+
+	if startItem > endItem || (startItem == endItem && startLine > endLine) {
+		startItem, endItem = endItem, startItem
+		startLine, endLine = endLine, startLine
+	}
+
+	// Check if item is within selection range
+	if itemIdx < startItem || itemIdx > endItem {
+		return false
+	}
+
+	// For single item selection
+	if startItem == endItem {
+		return itemIdx == startItem && lineIdx >= startLine && lineIdx <= endLine
+	}
+
+	// For multi-item selection
+	if itemIdx == startItem {
+		return lineIdx >= startLine
+	}
+	if itemIdx == endItem {
+		return lineIdx <= endLine
+	}
+	// Middle items are fully selected
+	return itemIdx > startItem && itemIdx < endItem
+}
+
+// applyHighlight applies the highlight style to a line.
+// Uses the theme's Highlight color for the background.
+func (s *ScrollList) applyHighlight(line string) string {
+	if line == "" {
+		return line
+	}
+	// Apply background/foreground color change for selection
+	style := initHighlightStyle()
+	return style.Render(line)
+}
+
+// applyFocusIndicator applies a subtle visual indicator for focused items.
+func (s *ScrollList) applyFocusIndicator(line string) string {
+	if line == "" {
+		return line
+	}
+	// Just return the line as-is - no visual indicator for focus
+	// The selection highlighting is enough
+	return line
+}
+
+// ScrollPercent returns the current scroll position as a percentage (0.0-1.0).
+// 0.0 = at top, 1.0 = at bottom. Useful for scroll indicators.
+func (s *ScrollList) ScrollPercent() float64 {
+	if len(s.items) == 0 {
+		return 0.0
+	}
+
+	totalHeight := 0
+	for _, item := range s.items {
+		totalHeight += item.Height()
+	}
+
+	if totalHeight <= s.height {
+		return 1.0 // All content fits, consider it "at bottom"
+	}
+
+	// Calculate how many lines are above the viewport
+	linesAbove := 0
+	for i := 0; i < s.offsetIdx && i < len(s.items); i++ {
+		linesAbove += s.items[i].Height()
+	}
+	linesAbove += s.offsetLine
+
+	scrollableHeight := totalHeight - s.height
+	if scrollableHeight <= 0 {
+		return 1.0
+	}
+
+	percent := float64(linesAbove) / float64(scrollableHeight)
+	if percent > 1.0 {
+		percent = 1.0
+	}
+	if percent < 0.0 {
+		percent = 0.0
+	}
+	return percent
+}
+
+// clampOffset ensures the offset values are within valid bounds after
+// resizing or scrolling operations. Prevents scrolling past the bottom
+// of content (showing empty space when there's content above).
+func (s *ScrollList) clampOffset() {
+	if len(s.items) == 0 {
+		s.offsetIdx = 0
+		s.offsetLine = 0
+		return
+	}
+
+	// First, clamp offsetIdx to valid item range
+	if s.offsetIdx >= len(s.items) {
+		s.offsetIdx = len(s.items) - 1
+	}
+	if s.offsetIdx < 0 {
+		s.offsetIdx = 0
+	}
+
+	// Clamp offsetLine within current item
+	if s.offsetIdx < len(s.items) {
+		// Calculate height from rendered content (handles non-cached items)
+		rendered := s.items[s.offsetIdx].Render(s.width)
+		itemHeight := strings.Count(rendered, "\n") + 1
+		if s.offsetLine >= itemHeight {
+			s.offsetLine = max(0, itemHeight-1)
+		}
+	}
+	if s.offsetLine < 0 {
+		s.offsetLine = 0
+	}
+
+	// Prevent scrolling past the bottom (showing empty space at bottom when there's content above)
+	// Calculate total content height
+	totalHeight := 0
+	for i, item := range s.items {
+		rendered := item.Render(s.width)
+		totalHeight += strings.Count(rendered, "\n") + 1
+		if s.itemGap > 0 && i < len(s.items)-1 {
+			totalHeight += s.itemGap
+		}
+	}
+
+	// If content fits in viewport, force start at top
+	if totalHeight <= s.height {
+		s.offsetIdx = 0
+		s.offsetLine = 0
+		return
+	}
+
+	// Calculate how many lines are currently above the viewport
+	linesAbove := 0
+	for i := 0; i < s.offsetIdx; i++ {
+		rendered := s.items[i].Render(s.width)
+		linesAbove += strings.Count(rendered, "\n") + 1
+		if s.itemGap > 0 && i < len(s.items)-1 {
+			linesAbove += s.itemGap
+		}
+	}
+	linesAbove += s.offsetLine
+
+	// Calculate how many lines are visible from current position to end
+	linesFromCurrentToEnd := totalHeight - linesAbove
+
+	// If there's less content remaining than the viewport height,
+	// we've scrolled past the bottom - need to back up
+	if linesFromCurrentToEnd < s.height {
+		// Position viewport so the last line of content is at the bottom
+		targetLine := totalHeight - s.height
+		currentLine := 0
+
+		for idx := 0; idx < len(s.items); idx++ {
+			rendered := s.items[idx].Render(s.width)
+			itemHeight := strings.Count(rendered, "\n") + 1
+
+			if currentLine+itemHeight > targetLine {
+				// This item contains the target line
+				s.offsetIdx = idx
+				s.offsetLine = targetLine - currentLine
+				return
+			}
+
+			currentLine += itemHeight
+			if s.itemGap > 0 && idx < len(s.items)-1 {
+				currentLine += s.itemGap
+			}
+		}
+	}
+}

internal/ui/session_selector.go

@@ -325,7 +325,14 @@ func (ss *SessionSelectorComponent) View() tea.View {
 		}
 	}
 
-	return tea.NewView(b.String())
+	v := tea.NewView(b.String())
+	v.AltScreen = true
+	v.MouseMode = tea.MouseModeCellMotion
+	v.ReportFocus = true
+	v.KeyboardEnhancements = tea.KeyboardEnhancements{
+		ReportEventTypes: true,
+	}
+	return v
 }
 
 // IsActive returns whether the selector is still accepting input.

internal/ui/slash_command_input.go

@@ -1,352 +0,0 @@
-package ui
-
-import (
-	"strings"
-
-	"charm.land/bubbles/v2/key"
-	"charm.land/bubbles/v2/textarea"
-	tea "charm.land/bubbletea/v2"
-	"charm.land/lipgloss/v2"
-)
-
-// SlashCommandInput provides an interactive text input field with intelligent
-// slash command autocomplete functionality. It displays a popup menu of matching
-// commands as the user types, supporting fuzzy matching and keyboard navigation.
-type SlashCommandInput struct {
-	textarea      textarea.Model
-	commands      []SlashCommand
-	showPopup     bool
-	filtered      []FuzzyMatch
-	selected      int
-	width         int
-	lastValue     string
-	popupHeight   int
-	title         string
-	quitting      bool
-	value         string
-	submitNext    bool // Flag to submit on next update
-	renderedLines int  // Track how many lines were rendered
-	hideHint      bool // Suppress the "enter submit · ctrl+j..." hint
-}
-
-// NewSlashCommandInput creates and initializes a new slash command input field with
-// the specified width and title. The input supports multi-line text entry, command
-// autocomplete, and is styled to match the application's theme.
-func NewSlashCommandInput(width int, title string) *SlashCommandInput {
-	ta := textarea.New()
-	ta.Placeholder = "Type your message..."
-	ta.ShowLineNumbers = false
-	ta.Prompt = ""
-	ta.CharLimit = 5000
-	ta.SetWidth(width - 8) // Account for container padding, border and internal padding
-	ta.SetHeight(3)        // Default to 3 lines like huh
-	ta.Focus()
-
-	// Override InsertNewline so only ctrl+j and shift+enter insert newlines.
-	// Enter always submits the input.
-	ta.KeyMap.InsertNewline = key.NewBinding(
-		key.WithKeys("ctrl+j", "shift+enter"),
-		key.WithHelp("ctrl+j", "insert newline"),
-	)
-
-	// Style the textarea using theme colors.
-	theme := GetTheme()
-	styles := ta.Styles()
-	styles.Focused.Base = lipgloss.NewStyle()
-	styles.Focused.Placeholder = lipgloss.NewStyle().Foreground(theme.VeryMuted)
-	styles.Focused.Text = lipgloss.NewStyle().Foreground(theme.Text)
-	styles.Focused.Prompt = lipgloss.NewStyle()
-	styles.Focused.CursorLine = lipgloss.NewStyle()
-	ta.SetStyles(styles)
-
-	return &SlashCommandInput{
-		textarea:    ta,
-		commands:    SlashCommands,
-		width:       width,
-		popupHeight: 7,
-		title:       title,
-	}
-}
-
-// Init implements the tea.Model interface, returning the initial command to start
-// the cursor blinking animation for the text input field.
-func (s *SlashCommandInput) Init() tea.Cmd {
-	return textarea.Blink
-}
-
-// Update implements the tea.Model interface, handling keyboard input for text entry,
-// command selection, and navigation. Manages the autocomplete popup display and
-// processes submission or cancellation actions.
-func (s *SlashCommandInput) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	var cmd tea.Cmd
-
-	// Check if we need to submit after updating the view
-	if s.submitNext {
-		s.value = s.textarea.Value()
-		s.quitting = true
-		return s, tea.Quit
-	}
-
-	switch msg := msg.(type) {
-	case tea.KeyPressMsg: // Check for quit keys first (when popup is not shown)
-		if !s.showPopup {
-			switch msg.String() {
-			case "ctrl+c", "esc":
-				s.quitting = true
-				return s, tea.Quit
-			case "ctrl+d", "enter": // Enter always submits
-				s.value = s.textarea.Value()
-				s.quitting = true
-				return s, tea.Quit
-			}
-		}
-
-		// Handle popup navigation
-		if s.showPopup {
-			switch {
-			case key.Matches(msg, key.NewBinding(key.WithKeys("up"), key.WithHelp("↑", "up"))):
-				if s.selected > 0 {
-					s.selected--
-				}
-				return s, nil
-			case key.Matches(msg, key.NewBinding(key.WithKeys("down"), key.WithHelp("↓", "down"))):
-				if s.selected < len(s.filtered)-1 {
-					s.selected++
-				}
-				return s, nil
-			case key.Matches(msg, key.NewBinding(key.WithKeys("tab"))):
-				if s.selected < len(s.filtered) {
-					// Complete with selected command
-					s.textarea.SetValue(s.filtered[s.selected].Command.Name)
-					s.showPopup = false
-					s.selected = 0
-					// Move cursor to end
-					s.textarea.CursorEnd()
-				}
-				return s, nil
-			case key.Matches(msg, key.NewBinding(key.WithKeys("enter"))):
-				if s.selected < len(s.filtered) {
-					// Populate the field with the selected command
-					s.textarea.SetValue(s.filtered[s.selected].Command.Name)
-					s.textarea.CursorEnd()
-					// Hide the popup
-					s.showPopup = false
-					s.selected = 0
-					// Set flag to submit on next update (after view refresh)
-					s.submitNext = true
-					// Force a refresh
-					return s, nil
-				}
-				return s, nil
-			case key.Matches(msg, key.NewBinding(key.WithKeys("esc"))):
-				s.showPopup = false
-				s.selected = 0
-				return s, nil
-			}
-		}
-
-		// Update textarea
-		s.textarea, cmd = s.textarea.Update(msg)
-
-		// Check if we should show/update popup
-		value := s.textarea.Value()
-		if value != s.lastValue {
-			s.lastValue = value
-			// Only show popup if we're on the first line and it starts with /
-			lines := strings.Split(value, "\n")
-			if len(lines) > 0 && strings.HasPrefix(lines[0], "/") && !strings.Contains(lines[0], " ") && len(lines) == 1 {
-				// Show and update popup
-				s.showPopup = true
-				s.filtered = FuzzyMatchCommands(lines[0], s.commands)
-				s.selected = 0
-			} else {
-				// Hide popup
-				s.showPopup = false
-			}
-		}
-		return s, cmd
-
-	default:
-		// Pass through other messages
-		s.textarea, cmd = s.textarea.Update(msg)
-		return s, cmd
-	}
-}
-
-// View implements the tea.Model interface, rendering the complete input field
-// including the title, text area, autocomplete popup (when active), and help text.
-// The view adapts based on whether single or multi-line input is detected.
-func (s *SlashCommandInput) View() tea.View {
-	containerStyle := lipgloss.NewStyle()
-
-	theme := GetTheme()
-
-	// PaddingLeft(3) aligns with message content: border(1) + paddingLeft(2).
-	titleStyle := lipgloss.NewStyle().
-		Foreground(theme.Text).
-		MarginBottom(1).
-		PaddingLeft(3)
-
-	// Input box with huh-like styling
-	inputBoxStyle := lipgloss.NewStyle().
-		Border(lipgloss.ThickBorder()).
-		BorderLeft(true).
-		BorderRight(false).
-		BorderTop(false).
-		BorderBottom(false).
-		BorderForeground(theme.Primary).
-		PaddingLeft(2).    // match message block paddingLeft
-		Width(s.width - 1) // full width minus left border
-
-	// Build the view
-	var view strings.Builder
-	view.WriteString(titleStyle.Render(s.title))
-	view.WriteString("\n")
-	view.WriteString(inputBoxStyle.Render(s.textarea.View()))
-	// Count rendered lines
-	s.renderedLines = 2 + s.textarea.Height() // title + newline + textarea height
-
-	// Add popup if visible
-	if s.showPopup && len(s.filtered) > 0 {
-		view.WriteString("\n")
-		view.WriteString(s.renderPopup())
-		// Add popup lines
-		visibleItems := min(len(s.filtered), s.popupHeight)
-		scrollIndicators := 0
-		if s.selected >= s.popupHeight {
-			scrollIndicators++ // top indicator
-		}
-		if len(s.filtered) > s.popupHeight {
-			scrollIndicators++ // bottom indicator
-		}
-		popupLines := visibleItems + scrollIndicators + 5 // items + scroll + border + padding + footer
-		s.renderedLines += 1 + popupLines                 // newline + popup
-	}
-
-	// Add help text at bottom (unless hidden by extension).
-	if !s.hideHint {
-		helpStyle := lipgloss.NewStyle().
-			Foreground(theme.VeryMuted).
-			MarginTop(1).
-			PaddingLeft(3)
-
-		helpText := "enter submit • ctrl+j / shift+enter new line"
-
-		view.WriteString("\n")
-		view.WriteString(helpStyle.Render(helpText))
-		s.renderedLines += 2 // newline + help text
-	}
-
-	// Apply container padding to entire view
-	return tea.NewView(containerStyle.Render(view.String()))
-}
-
-// renderPopup renders the autocomplete popup
-func (s *SlashCommandInput) renderPopup() string {
-	theme := GetTheme()
-
-	// Popup styling
-	popupStyle := lipgloss.NewStyle().
-		Border(lipgloss.RoundedBorder()).
-		BorderForeground(theme.MutedBorder).
-		Padding(1, 2).
-		Width(s.width - 4). // Account for container padding
-		MarginLeft(0)       // No extra margin needed due to container padding
-
-	var items []string
-
-	// Calculate visible window
-	visibleItems := min(len(s.filtered), s.popupHeight)
-	startIdx := 0
-
-	// Adjust window to keep selected item visible
-	if s.selected >= s.popupHeight {
-		startIdx = s.selected - s.popupHeight + 1
-	}
-
-	endIdx := min(startIdx+visibleItems, len(s.filtered))
-
-	for i := startIdx; i < endIdx; i++ {
-		match := s.filtered[i]
-		cmd := match.Command
-		// Create the selection indicator
-		var indicator string
-		if i == s.selected {
-			indicator = lipgloss.NewStyle().
-				Foreground(theme.Primary).
-				Render("> ")
-		} else {
-			indicator = "  "
-		}
-
-		// Format item
-		nameStyle := lipgloss.NewStyle().
-			Foreground(theme.Secondary).
-			Bold(true)
-
-		descStyle := lipgloss.NewStyle().
-			Foreground(theme.Muted)
-
-		// Highlight selected item
-		if i == s.selected {
-			nameStyle = nameStyle.Foreground(theme.Primary)
-			descStyle = descStyle.Foreground(theme.Text)
-		}
-
-		// Format with proper spacing
-		nameWidth := 15
-		name := nameStyle.Width(nameWidth - 2).Render(cmd.Name)
-
-		// Truncate description if needed
-		desc := cmd.Description
-		maxDescLen := s.width - nameWidth - 14 // Account for padding and indicator
-		if len(desc) > maxDescLen && maxDescLen > 3 {
-			desc = desc[:maxDescLen-3] + "..."
-		}
-
-		line := indicator + name + descStyle.Render(desc)
-		items = append(items, line)
-	}
-
-	// Add scroll indicators if needed
-	if startIdx > 0 {
-		scrollUpStyle := lipgloss.NewStyle().Foreground(theme.VeryMuted)
-		items = append([]string{scrollUpStyle.Render("  ↑ more above")}, items...)
-	}
-	if endIdx < len(s.filtered) {
-		scrollDownStyle := lipgloss.NewStyle().Foreground(theme.VeryMuted)
-		items = append(items, scrollDownStyle.Render("  ↓ more below"))
-	}
-	// Join items
-	content := strings.Join(items, "\n")
-
-	// Add footer hint
-	footerStyle := lipgloss.NewStyle().
-		Foreground(theme.VeryMuted).
-		Italic(true)
-	footer := footerStyle.Render("↑↓ navigate • tab complete • ↵ select • esc dismiss")
-
-	// Combine content and footer
-	popupContent := content + "\n\n" + footer
-
-	return popupStyle.Render(popupContent)
-}
-
-// Value returns the final text value entered by the user after submission.
-// This will be empty if the input was cancelled.
-func (s *SlashCommandInput) Value() string {
-	return s.value
-}
-
-// Cancelled returns true if the user cancelled the input operation (e.g., by
-// pressing ESC or Ctrl+C) without submitting any text.
-func (s *SlashCommandInput) Cancelled() bool {
-	return s.quitting && s.value == ""
-}
-
-// RenderedLines returns the total number of terminal lines used by the last
-// rendered view, including the title, input area, popup, and help text. This
-// is used for proper screen clearing when the input is dismissed.
-func (s *SlashCommandInput) RenderedLines() int {
-	return s.renderedLines
-}

internal/ui/stream.go

@@ -2,6 +2,7 @@ package ui
 
 import (
 	"fmt"
+	"regexp"
 	"strings"
 	"time"
 
@@ -11,6 +12,17 @@ import (
 	"github.com/mark3labs/kit/internal/app"
 )
 
+// thinkTagRegex matches  ...  tags that some models (Qwen, DeepSeek) wrap
+// reasoning content in. Used to strip these tags from streaming text content.
+// The (?s) flag makes . match newlines.
+var thinkTagRegex = regexp.MustCompile(`(?s)` + `` + `think` + `` + `(.*?)` + `` + `/think` + ``)
+
+// thinkTagOpen and thinkTagClose are the opening and closing think tag strings.
+const (
+	thinkTagOpen  = "<think>"
+	thinkTagClose = "</think>"
+)
+
 // knightRiderFrames generates a KITT-style scanning animation where a bright
 // light bounces back and forth across a row of dots with a trailing glow.
 // Colors are derived from the active theme. Used by StreamComponent (TUI
@@ -193,6 +205,14 @@ type StreamComponent struct {
 	// the cache.
 	renderDirty bool
 
+	// scrollbackFlushedLines is the number of lines from the top of the
+	// rendered content that have already been emitted to the terminal
+	// scrollback buffer. On each flush, lines that overflow the allocated
+	// height and haven't been pushed yet are emitted via tea.Println so
+	// they appear in the terminal's real scrollback (scrollable with the
+	// terminal's own scroll mechanism).
+	scrollbackFlushedLines int
+
 	// thinkingVisible controls whether reasoning blocks are expanded or collapsed.
 	thinkingVisible bool
 
@@ -202,7 +222,11 @@ type StreamComponent struct {
 	// reasoningDuration holds the total reasoning time, frozen when streaming text begins.
 	reasoningDuration time.Duration
 
-	// renderer renders streaming assistant text in either compact or standard mode.
+	// inThinkTag tracks whether we're currently inside a  section
+	// from models that wrap reasoning in XML-like tags (Qwen, DeepSeek).
+	inThinkTag bool
+
+	// renderer renders streaming assistant text.
 	renderer Renderer
 
 	// modelName is displayed in the streaming text header.
@@ -223,17 +247,12 @@ type StreamComponent struct {
 }
 
 // NewStreamComponent creates a new StreamComponent ready to be embedded in AppModel.
-func NewStreamComponent(compactMode bool, width int, modelName string) *StreamComponent {
+func NewStreamComponent(width int, modelName string) *StreamComponent {
 	if width == 0 {
 		width = 80
 	}
 
-	var renderer Renderer
-	if compactMode {
-		renderer = NewCompactRenderer(width, false)
-	} else {
-		renderer = newMessageRenderer(width, false)
-	}
+	renderer := newMessageRenderer(width, false)
 
 	return &StreamComponent{
 		spinnerFrames: knightRiderFrames(),
@@ -279,6 +298,42 @@ func (s *StreamComponent) Reset() {
 	s.timestamp = time.Time{}
 	s.reasoningStartTime = time.Time{}
 	s.reasoningDuration = 0
+	s.scrollbackFlushedLines = 0
+}
+
+// ConsumeOverflow returns any lines from the rendered stream content that have
+// overflowed the allocated height and have not yet been pushed to the terminal
+// scrollback buffer. It advances the internal flushed-line pointer so
+// subsequent calls only return newly overflowed lines.
+//
+// Returns "" when there is no overflow or height is unconstrained (0).
+// The caller should emit the returned string via tea.Println so the content
+// appears in the terminal's real scrollback (not just discarded).
+func (s *StreamComponent) ConsumeOverflow() string {
+	if s.height <= 0 {
+		return ""
+	}
+	content := s.render()
+	if content == "" {
+		return ""
+	}
+	lines := strings.Split(content, "\n")
+	totalLines := len(lines)
+	// Number of lines that overflow the viewable height.
+	overflowLines := totalLines - s.height
+	if overflowLines <= 0 {
+		return ""
+	}
+	// How many overflow lines are new (not yet flushed to scrollback).
+	newOverflow := overflowLines - s.scrollbackFlushedLines
+	if newOverflow <= 0 {
+		return ""
+	}
+	// The new overflow is lines [s.scrollbackFlushedLines .. overflowLines).
+	start := s.scrollbackFlushedLines
+	end := overflowLines
+	s.scrollbackFlushedLines = overflowLines
+	return strings.Join(lines[start:end], "\n")
 }
 
 // GetRenderedContent returns the rendered assistant message from the accumulated
@@ -287,6 +342,10 @@ func (s *StreamComponent) Reset() {
 //
 // This commits any pending chunks first so the output includes all received
 // content, not just what has been flushed by the tick.
+//
+// Lines already pushed to the terminal scrollback buffer via ConsumeOverflow
+// are skipped so that callers do not re-emit content that is already visible
+// in the terminal's real scrollback.
 func (s *StreamComponent) GetRenderedContent() string {
 	// Commit any pending chunks so the final output is complete.
 	s.commitPending()
@@ -307,14 +366,28 @@ func (s *StreamComponent) GetRenderedContent() string {
 	if len(sections) == 0 {
 		return ""
 	}
-	return strings.Join(sections, "\n")
+	fullContent := strings.Join(sections, "\n")
+
+	// Skip lines already emitted to the terminal scrollback via ConsumeOverflow
+	// so the caller doesn't re-print content that is already there.
+	if s.scrollbackFlushedLines > 0 {
+		lines := strings.Split(fullContent, "\n")
+		if s.scrollbackFlushedLines >= len(lines) {
+			return "" // everything already in scrollback
+		}
+		return strings.Join(lines[s.scrollbackFlushedLines:], "\n")
+	}
+
+	return fullContent
 }
 
 // commitPending moves any pending chunks to the committed content builders.
 // Called before reading content for scrollback output or on flush tick.
 func (s *StreamComponent) commitPending() {
 	if s.pendingStream.Len() > 0 {
-		s.streamContent.WriteString(s.pendingStream.String())
+		// Strip  ...  tags that some models wrap reasoning in
+		cleanedText := thinkTagRegex.ReplaceAllString(s.pendingStream.String(), "")
+		s.streamContent.WriteString(cleanedText)
 		s.pendingStream.Reset()
 		s.renderDirty = true
 	}
@@ -408,8 +481,46 @@ func (s *StreamComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		if s.reasoningDuration == 0 && !s.reasoningStartTime.IsZero() {
 			s.reasoningDuration = time.Since(s.reasoningStartTime)
 		}
-		s.pendingStream.WriteString(msg.Content)
-		if !s.flushPending {
+
+		// Handle models that wrap reasoning in  tags (Qwen, DeepSeek)
+		// Filter out all content between  and  tags
+		content := msg.Content
+
+		// Check for opening tag
+		if strings.Contains(content, thinkTagOpen) {
+			parts := strings.SplitN(content, thinkTagOpen, 2)
+			// Content before the tag can be written
+			if !s.inThinkTag && parts[0] != "" {
+				s.pendingStream.WriteString(parts[0])
+			}
+			s.inThinkTag = true
+			// Content after the opening tag is reasoning - don't write it
+			if len(parts) > 1 && parts[1] != "" {
+				// Check if the same chunk contains the closing tag
+				if strings.Contains(parts[1], thinkTagClose) {
+					innerParts := strings.SplitN(parts[1], thinkTagClose, 2)
+					s.inThinkTag = false
+					// Content after closing tag can be written
+					if len(innerParts) > 1 && innerParts[1] != "" {
+						s.pendingStream.WriteString(innerParts[1])
+					}
+				}
+			}
+		} else if strings.Contains(content, thinkTagClose) {
+			// Closing tag found
+			parts := strings.SplitN(content, thinkTagClose, 2)
+			s.inThinkTag = false
+			// Content after closing tag can be written
+			if len(parts) > 1 && parts[1] != "" {
+				s.pendingStream.WriteString(parts[1])
+			}
+		} else if !s.inThinkTag {
+			// Normal content, not inside think tags
+			s.pendingStream.WriteString(content)
+		}
+		// else: inside think tag, don't write this content
+
+		if !s.flushPending && s.pendingStream.Len() > 0 {
 			s.flushPending = true
 			return s, streamFlushTickCmd(s.flushGeneration)
 		}
@@ -452,7 +563,14 @@ func (s *StreamComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 func (s *StreamComponent) View() tea.View {
 	fullContent := s.render()
 	visibleContent := s.viewContent(fullContent)
-	return tea.NewView(visibleContent)
+	v := tea.NewView(visibleContent)
+	v.AltScreen = true
+	v.MouseMode = tea.MouseModeCellMotion
+	v.ReportFocus = true
+	v.KeyboardEnhancements = tea.KeyboardEnhancements{
+		ReportEventTypes: true,
+	}
+	return v
 }
 
 // --------------------------------------------------------------------------
@@ -567,7 +685,7 @@ func (s *StreamComponent) renderReasoningBlock(reasoning string) string {
 	} else {
 		result = strings.Join(parts, "\n")
 	}
-	return lipgloss.NewStyle().MarginBottom(1).Render(result)
+	return styleMarginBottom1.Render(result)
 }
 
 // SetThinkingVisible sets whether reasoning blocks are shown or collapsed.
@@ -653,3 +771,9 @@ func removeToolID(ids []string, id string) []string {
 func formatToolExecutionMessage(toolName string) string {
 	return toolName
 }
+
+// UpdateTheme refreshes the component's typography instance with colors from
+// the current theme. This is called when the user changes themes via /theme.
+func (s *StreamComponent) UpdateTheme() {
+	s.ty = createTypography(GetTheme())
+}

internal/ui/styles.go

@@ -1,19 +1,11 @@
 package ui
 
 import (
-	"fmt"
-	"image/color"
-
 	"charm.land/lipgloss/v2"
-	"github.com/charmbracelet/glamour"
-	"github.com/charmbracelet/glamour/ansi"
+	"github.com/indaco/herald"
+	heraldmd "github.com/indaco/herald-md"
 )
 
-// uintPtr returns a pointer to u. Used by ansi.StyleConfig fields.
-//
-//go:fix inline
-func uintPtr(u uint) *uint { return new(u) }
-
 // BaseStyle returns a new, empty lipgloss style that can be customized with
 // additional styling methods. This serves as the foundation for building more
 // complex styled components.
@@ -21,248 +13,83 @@ func BaseStyle() lipgloss.Style {
 	return lipgloss.NewStyle()
 }
 
-// colorHex converts a color.Color to a hex string suitable for ansi.StyleConfig.
-func colorHex(c color.Color) string {
-	r, g, b, _ := c.RGBA()
-	return fmt.Sprintf("#%02x%02x%02x", r>>8, g>>8, b>>8)
-}
+// markdownTypographyCache holds the last-created Typography instance for
+// herald-md rendering. It is cached to avoid re-initialization on every
+// streaming flush tick. The cache is invalidated by SetTheme when the
+// active theme changes.
+// This is only accessed from BubbleTea's single-threaded Update/View cycle,
+// so no mutex is required.
+var markdownTypographyCache *herald.Typography
 
-// colorHexPtr returns a pointer to the hex string of a color.Color.
-func colorHexPtr(c color.Color) *string {
-	s := colorHex(c)
-	return &s
-}
-
-// GetMarkdownRenderer creates and returns a configured glamour.TermRenderer for
-// rendering markdown content with syntax highlighting and proper formatting. The
-// renderer is customized with our theme colors and adapted to the specified width.
-func GetMarkdownRenderer(width int) *glamour.TermRenderer {
-	r, _ := glamour.NewTermRenderer(
-		glamour.WithStyles(generateMarkdownStyleConfig()),
-		glamour.WithWordWrap(width),
-	)
-	return r
-}
-
-// generateMarkdownStyleConfig creates an ansi.StyleConfig from the active theme.
-func generateMarkdownStyleConfig() ansi.StyleConfig {
-	md := GetTheme().Markdown
-	text := colorHexPtr(md.Text)
-	muted := colorHexPtr(md.Muted)
-	heading := colorHexPtr(md.Heading)
-	emph := colorHexPtr(md.Emph)
-	strong := colorHexPtr(md.Strong)
-	link := colorHexPtr(md.Link)
-	code := colorHexPtr(md.Code)
-	errClr := colorHexPtr(md.Error)
-	keyword := colorHexPtr(md.Keyword)
-	str := colorHexPtr(md.String)
-	number := colorHexPtr(md.Number)
-	comment := colorHexPtr(md.Comment)
-
-	return ansi.StyleConfig{
-		Document: ansi.StyleBlock{
-			StylePrimitive: ansi.StylePrimitive{
-				BlockPrefix: "",
-				BlockSuffix: "",
-				Color:       text,
-			},
-			Margin: uintPtr(0),
-		},
-		BlockQuote: ansi.StyleBlock{
-			StylePrimitive: ansi.StylePrimitive{
-				Color:  muted,
-				Italic: new(true),
-				Prefix: "┃ ",
-			},
-			Indent: uintPtr(1),
-		},
-		List: ansi.StyleList{
-			LevelIndent: 0,
-			StyleBlock: ansi.StyleBlock{
-				StylePrimitive: ansi.StylePrimitive{
-					Color: text,
-				},
-			},
-		},
-		Heading: ansi.StyleBlock{
-			StylePrimitive: ansi.StylePrimitive{
-				BlockSuffix: "\n",
-				Color:       heading,
-				Bold:        new(true),
-			},
-		},
-		H1: ansi.StyleBlock{
-			StylePrimitive: ansi.StylePrimitive{
-				Prefix: "# ",
-				Color:  heading,
-				Bold:   new(true),
-			},
-		},
-		H2: ansi.StyleBlock{
-			StylePrimitive: ansi.StylePrimitive{
-				Prefix: "## ",
-				Color:  heading,
-				Bold:   new(true),
-			},
-		},
-		H3: ansi.StyleBlock{
-			StylePrimitive: ansi.StylePrimitive{
-				Prefix: "### ",
-				Color:  heading,
-				Bold:   new(true),
-			},
-		},
-		H4: ansi.StyleBlock{
-			StylePrimitive: ansi.StylePrimitive{
-				Prefix: "#### ",
-				Color:  heading,
-				Bold:   new(true),
-			},
-		},
-		H5: ansi.StyleBlock{
-			StylePrimitive: ansi.StylePrimitive{
-				Prefix: "##### ",
-				Color:  heading,
-				Bold:   new(true),
-			},
-		},
-		H6: ansi.StyleBlock{
-			StylePrimitive: ansi.StylePrimitive{
-				Prefix: "###### ",
-				Color:  heading,
-				Bold:   new(true),
-			},
-		},
-		Strikethrough: ansi.StylePrimitive{
-			CrossedOut: new(true),
-			Color:      muted,
-		},
-		Emph: ansi.StylePrimitive{
-			Color:  emph,
-			Italic: new(true),
-		},
-		Strong: ansi.StylePrimitive{
-			Bold:  new(true),
-			Color: strong,
-		},
-		HorizontalRule: ansi.StylePrimitive{
-			Color:  muted,
-			Format: "\n─────────────────────────────────────────\n",
-		},
-		Item: ansi.StylePrimitive{
-			BlockPrefix: "• ",
-			Color:       text,
-		},
-		Enumeration: ansi.StylePrimitive{
-			BlockPrefix: ". ",
-			Color:       text,
-		},
-		Task: ansi.StyleTask{
-			StylePrimitive: ansi.StylePrimitive{},
-			Ticked:         "[✓] ",
-			Unticked:       "[ ] ",
-		},
-		Link: ansi.StylePrimitive{
-			Color:     link,
-			Underline: new(true),
-		},
-		LinkText: ansi.StylePrimitive{
-			Color: link,
-			Bold:  new(true),
-		},
-		Image: ansi.StylePrimitive{
-			Color:     link,
-			Underline: new(true),
-			Format:    "🖼 {{.text}}",
-		},
-		ImageText: ansi.StylePrimitive{
-			Color:  link,
-			Format: "{{.text}}",
-		},
-		Code: ansi.StyleBlock{
-			StylePrimitive: ansi.StylePrimitive{
-				Color:  code,
-				Prefix: "",
-				Suffix: "",
-			},
-		},
-		CodeBlock: ansi.StyleCodeBlock{
-			StyleBlock: ansi.StyleBlock{
-				StylePrimitive: ansi.StylePrimitive{
-					Prefix: "",
-					Color:  code,
-				},
-				Margin: uintPtr(0),
-			},
-			Chroma: &ansi.Chroma{
-				Text:             ansi.StylePrimitive{Color: text},
-				Error:            ansi.StylePrimitive{Color: errClr},
-				Comment:          ansi.StylePrimitive{Color: comment},
-				CommentPreproc:   ansi.StylePrimitive{Color: keyword},
-				Keyword:          ansi.StylePrimitive{Color: keyword},
-				KeywordReserved:  ansi.StylePrimitive{Color: keyword},
-				KeywordNamespace: ansi.StylePrimitive{Color: keyword},
-				KeywordType:      ansi.StylePrimitive{Color: keyword},
-				Operator:         ansi.StylePrimitive{Color: text},
-				Punctuation:      ansi.StylePrimitive{Color: text},
-				Name:             ansi.StylePrimitive{Color: text},
-				NameBuiltin:      ansi.StylePrimitive{Color: text},
-				NameTag:          ansi.StylePrimitive{Color: keyword},
-				NameAttribute:    ansi.StylePrimitive{Color: text},
-				NameClass:        ansi.StylePrimitive{Color: keyword},
-				NameConstant:     ansi.StylePrimitive{Color: text},
-				NameDecorator:    ansi.StylePrimitive{Color: text},
-				NameFunction:     ansi.StylePrimitive{Color: text},
-				LiteralNumber:    ansi.StylePrimitive{Color: number},
-				LiteralString:    ansi.StylePrimitive{Color: str},
-				LiteralStringEscape: ansi.StylePrimitive{
-					Color: keyword,
-				},
-				GenericDeleted: ansi.StylePrimitive{Color: errClr},
-				GenericEmph: ansi.StylePrimitive{
-					Color:  emph,
-					Italic: new(true),
-				},
-				GenericInserted: ansi.StylePrimitive{Color: str},
-				GenericStrong: ansi.StylePrimitive{
-					Color: strong,
-					Bold:  new(true),
-				},
-				GenericSubheading: ansi.StylePrimitive{
-					Color: heading,
-				},
-			},
-		},
-		Table: ansi.StyleTable{
-			StyleBlock: ansi.StyleBlock{
-				StylePrimitive: ansi.StylePrimitive{
-					BlockPrefix: "\n",
-					BlockSuffix: "\n",
-				},
-			},
-			CenterSeparator: new("┼"),
-			ColumnSeparator: new("│"),
-			RowSeparator:    new("─"),
-		},
-		DefinitionDescription: ansi.StylePrimitive{
-			BlockPrefix: "\n ❯ ",
-			Color:       link,
-		},
-		Text: ansi.StylePrimitive{
-			Color: text,
-		},
-		Paragraph: ansi.StyleBlock{
-			StylePrimitive: ansi.StylePrimitive{
-				Color: text,
-			},
-		},
+// GetMarkdownTypography returns a herald.Typography configured with our
+// active theme colors. The typography is cached and only rebuilt when
+// the theme changes via SetTheme.
+func GetMarkdownTypography() *herald.Typography {
+	if markdownTypographyCache != nil {
+		return markdownTypographyCache
 	}
+
+	theme := GetTheme()
+	md := theme.Markdown
+
+	// Build herald theme from our theme colors
+	hty := herald.Theme{
+		// Headings - use heading color
+		H1: lipgloss.NewStyle().Foreground(md.Heading).Bold(true),
+		H2: lipgloss.NewStyle().Foreground(md.Heading).Bold(true),
+		H3: lipgloss.NewStyle().Foreground(md.Heading).Bold(true),
+		H4: lipgloss.NewStyle().Foreground(md.Heading).Bold(true),
+		H5: lipgloss.NewStyle().Foreground(md.Heading).Bold(true),
+		H6: lipgloss.NewStyle().Foreground(md.Muted).Bold(true),
+
+		// Text blocks
+		Paragraph:  lipgloss.NewStyle().Foreground(md.Text),
+		Blockquote: lipgloss.NewStyle().Foreground(md.Muted).Italic(true),
+		CodeInline: lipgloss.NewStyle().Foreground(md.Code),
+		CodeBlock:  lipgloss.NewStyle().Foreground(md.Code),
+		HR:         lipgloss.NewStyle().Foreground(md.Muted),
+
+		// Lists
+		ListBullet: lipgloss.NewStyle().Foreground(md.Text),
+		ListItem:   lipgloss.NewStyle().Foreground(md.Text),
+
+		// Inline styles
+		Bold:          lipgloss.NewStyle().Foreground(md.Strong).Bold(true),
+		Italic:        lipgloss.NewStyle().Foreground(md.Emph).Italic(true),
+		Strikethrough: lipgloss.NewStyle().Foreground(md.Muted).Strikethrough(true),
+		Link:          lipgloss.NewStyle().Foreground(md.Link).Underline(true),
+
+		// Definition lists
+		DT: lipgloss.NewStyle().Foreground(md.Text).Bold(true),
+		DD: lipgloss.NewStyle().Foreground(md.Muted),
+
+		// Key-value
+		KVKey:   lipgloss.NewStyle().Foreground(md.Text).Bold(true),
+		KVValue: lipgloss.NewStyle().Foreground(md.Text),
+
+		// Badges/Tags - use semantic colors
+		Badge:        lipgloss.NewStyle().Foreground(md.Text).Bold(true),
+		SuccessBadge: lipgloss.NewStyle().Foreground(theme.Success).Bold(true),
+		WarningBadge: lipgloss.NewStyle().Foreground(theme.Warning).Bold(true),
+		ErrorBadge:   lipgloss.NewStyle().Foreground(theme.Error).Bold(true),
+		InfoBadge:    lipgloss.NewStyle().Foreground(theme.Info).Bold(true),
+
+		// Heading decorations
+		H1UnderlineChar: "═",
+		H2UnderlineChar: "─",
+		H3UnderlineChar: "·",
+	}
+
+	ty := herald.New(herald.WithTheme(hty))
+	markdownTypographyCache = ty
+	return ty
 }
 
-// toMarkdown renders markdown content using glamour.
+// toMarkdown renders markdown content using herald-md.
+// The width parameter is currently unused as herald handles wrapping
+// based on terminal width internally.
 func toMarkdown(content string, width int) string {
-	r := GetMarkdownRenderer(width)
-	rendered, _ := r.Render(content)
+	ty := GetMarkdownTypography()
+	rendered := heraldmd.Render(ty, []byte(content))
 	return rendered
 }

internal/ui/themes.go

@@ -129,13 +129,20 @@ type presetColors struct {
 }
 
 func makeTheme(p presetColors) Theme {
-	ac := func(pair [2]string) color.Color { return AdaptiveColor(pair[0], pair[1]) }
 	def := DefaultTheme()
-	acOr := func(pair [2]string, fb color.Color) color.Color {
+	ac := func(pair [2]string) color.Color {
+		c := AdaptiveColor(pair[0], pair[1])
 		if pair[0] == "" && pair[1] == "" {
+			return nil
+		}
+		return c
+	}
+	acOr := func(pair [2]string, fb color.Color) color.Color {
+		c := ac(pair)
+		if c == nil {
 			return fb
 		}
-		return ac(pair)
+		return c
 	}
 	t := Theme{
 		Primary:     ac(p.primary),

internal/ui/tool_approval_input.go

@@ -83,9 +83,19 @@ func (t *ToolApprovalInput) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 }
 
 func (t *ToolApprovalInput) View() tea.View {
-	if t.done {
-		return tea.NewView("we are done")
+	v := tea.NewView("")
+	v.AltScreen = true
+	v.MouseMode = tea.MouseModeCellMotion
+	v.ReportFocus = true
+	v.KeyboardEnhancements = tea.KeyboardEnhancements{
+		ReportEventTypes: true,
 	}
+
+	if t.done {
+		v.Content = "we are done"
+		return v
+	}
+
 	containerStyle := lipgloss.NewStyle()
 
 	theme := GetTheme()
@@ -135,5 +145,6 @@ func (t *ToolApprovalInput) View() tea.View {
 	}
 	view.WriteString(yesText + "/" + noText + "\n")
 
-	return tea.NewView(containerStyle.Render(inputBoxStyle.Render(view.String())))
+	v.Content = containerStyle.Render(inputBoxStyle.Render(view.String()))
+	return v
 }

internal/ui/tool_renderers.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
@@ -15,6 +16,7 @@ import (
 	"github.com/alecthomas/chroma/v2/styles"
 	udiff "github.com/aymanbagabas/go-udiff"
 	xansi "github.com/charmbracelet/x/ansi"
+	"github.com/indaco/herald"
 )
 
 // Maximum visible lines per tool type before truncation.
@@ -26,6 +28,13 @@ const (
 	maxLsLines    = 20 // lines for Ls directory listings
 )
 
+// isShellTool reports if the tool name matches a shell-like tool (bash, grep, find, or
+// tools with "shell"/"command" in the name). Used by renderToolBody.
+func isShellTool(toolName string) bool {
+	return toolName == "bash" || toolName == "grep" || toolName == "find" ||
+		strings.Contains(toolName, "shell") || strings.Contains(toolName, "command")
+}
+
 // renderToolBody dispatches to tool-specific body renderers based on tool name.
 // Returns the styled body string, or empty string to fall back to default rendering.
 func renderToolBody(toolName, toolArgs, toolResult string, width int) string {
@@ -46,8 +55,7 @@ func renderToolBody(toolName, toolArgs, toolResult string, width int) string {
 		if body := renderWriteBody(toolArgs, toolResult, width); body != "" {
 			return body
 		}
-	case toolName == "bash" || toolName == "grep" || toolName == "find" ||
-		strings.Contains(toolName, "shell") || strings.Contains(toolName, "command"):
+	case isShellTool(toolName):
 		if body := renderBashBody(toolResult, width); body != "" {
 			return body
 		}
@@ -244,7 +252,7 @@ func renderDiffBlock(before, after string, startLine int, width int) string {
 	gutterWidth := max(len(fmt.Sprintf("%d", maxLineNum)), 3)
 	contentWidth := max(panelWidth-gutterWidth-4, 10) // gutter + " - " or " + "
 
-	theme := getTheme()
+	theme := GetTheme()
 
 	// Styles for each cell type
 	gutterInsert := lipgloss.NewStyle().Foreground(theme.Muted).Background(theme.DiffInsertBg)
@@ -349,7 +357,7 @@ func renderLsBody(toolResult string, width int) string {
 	const indent = "  "
 	codeWidth := max(width-len(indent), 20)
 
-	theme := getTheme()
+	theme := GetTheme()
 	codeStyle := lipgloss.NewStyle().Background(theme.CodeBg).PaddingLeft(1)
 
 	var result []string
@@ -374,137 +382,106 @@ func renderLsBody(toolResult string, width int) string {
 // Read tool — code block with line numbers + syntax highlighting
 // ---------------------------------------------------------------------------
 
-// renderReadBody renders Read tool output with styled line numbers and optional
-// syntax highlighting based on file extension.
+// renderReadBody renders Read tool output using herald.CodeBlock with line numbers
+// and syntax highlighting. Uses WithCodeLineNumberOffset to show correct offsets
+// based on the Read tool's offset parameter.
 func renderReadBody(toolArgs, toolResult string, width int) string {
 	if strings.TrimSpace(toolResult) == "" {
 		return ""
 	}
 
-	// Extract file path for syntax highlighting
+	// Extract file path and offset from tool args
 	var fileName string
+	var offset = 1
 	var args map[string]any
 	if err := json.Unmarshal([]byte(toolArgs), &args); err == nil {
 		if p, ok := args["path"].(string); ok {
 			fileName = p
 		}
+		if o, ok := args["offset"].(float64); ok {
+			offset = int(o)
+		}
 	}
 
-	return renderCodeBlock(toolResult, fileName, width)
-}
-
-// codeLine holds a parsed line with optional line number.
-type codeLine struct {
-	lineNum string
-	code    string
-}
-
-// renderCodeBlock renders content with a styled gutter (line numbers) and
-// optional syntax highlighting.
-func renderCodeBlock(content, fileName string, width int) string {
-	rawLines := strings.Split(content, "\n")
-
-	// Parse lines: detect "N: content" format from Read tool
-	var parsed []codeLine
-	maxNumWidth := 0
-	var codeOnly []string
+	// Parse lines to extract pure code content (removing "N: " prefixes)
+	rawLines := strings.Split(toolResult, "\n")
+	var codeLines []string
+	var footerLines []string
+	var codeHiddenCount int
 
 	for _, line := range rawLines {
+		// Detect "N: content" format from Read tool
 		if idx := strings.Index(line, ": "); idx > 0 && idx <= 7 {
 			numPart := line[:idx]
 			if _, err := strconv.Atoi(strings.TrimSpace(numPart)); err == nil {
-				parsed = append(parsed, codeLine{lineNum: numPart, code: line[idx+2:]})
-				if len(numPart) > maxNumWidth {
-					maxNumWidth = len(numPart)
-				}
-				codeOnly = append(codeOnly, line[idx+2:])
+				codeLines = append(codeLines, line[idx+2:])
 				continue
 			}
 		}
-		// No line number — treat as metadata/footer
-		parsed = append(parsed, codeLine{code: line})
-		codeOnly = append(codeOnly, line)
+		// No line number — treat as footer/metadata (e.g., truncation notice)
+		footerLines = append(footerLines, line)
 	}
 
-	if len(parsed) == 0 {
-		return ""
+	// Apply maxCodeLines truncation
+	totalCodeLines := len(codeLines)
+	if totalCodeLines > maxCodeLines {
+		codeHiddenCount = totalCodeLines - maxCodeLines
+		codeLines = codeLines[:maxCodeLines]
 	}
 
-	// Truncate to maxCodeLines visible lines (preserve footer/metadata lines)
-	var codeHiddenCount int
-	totalParsed := len(parsed)
-	if totalParsed > maxCodeLines {
-		// Check if last line is a footer (no line number) — keep it
-		var footerLines []codeLine
-		for totalParsed > 0 && parsed[totalParsed-1].lineNum == "" {
-			footerLines = append([]codeLine{parsed[totalParsed-1]}, footerLines...)
-			totalParsed--
-		}
-		if totalParsed > maxCodeLines {
-			codeHiddenCount = totalParsed - maxCodeLines
-			parsed = append(parsed[:maxCodeLines], footerLines...)
-			codeOnly = codeOnly[:maxCodeLines]
-			for _, fl := range footerLines {
-				codeOnly = append(codeOnly, fl.code)
-			}
-		} else {
-			// Restore — footer trimming was enough
-			parsed = parsed[:totalParsed]
-			parsed = append(parsed, footerLines...)
+	// Build language hint from file extension
+	lang := ""
+	if fileName != "" {
+		// Extract extension without the dot
+		if ext := strings.TrimPrefix(filepath.Ext(fileName), "."); ext != "" {
+			lang = ext
 		}
 	}
 
-	// Syntax highlight the code portion
-	highlighted := syntaxHighlight(strings.Join(codeOnly, "\n"), fileName)
-	highlightedLines := strings.Split(highlighted, "\n")
-
-	// Layout
-	const codeIndent = "  "
-	gutterWidth := max(maxNumWidth+2, 5)
-	codeWidth := max(width-gutterWidth-len(codeIndent), 20)
-
-	theme := getTheme()
-	gutterStyle := lipgloss.NewStyle().Foreground(theme.Muted).Background(theme.GutterBg).PaddingRight(1)
-	codeStyle := lipgloss.NewStyle().Background(theme.CodeBg).PaddingLeft(1)
-
-	var result []string
-	for i, p := range parsed {
-		// If this line has no line number, it's a metadata/footer line (e.g. truncation notice).
-		if p.lineNum == "" {
-			// Render footer lines with code background but no gutter
-			truncatedFooter := truncateLine(p.code, codeWidth-1) // account for PaddingLeft(1)
-			footer := codeStyle.Width(codeWidth).Render(truncatedFooter)
-			emptyGutter := gutterStyle.Width(gutterWidth).Render("")
-			result = append(result, codeIndent+lipgloss.JoinHorizontal(lipgloss.Top, emptyGutter, footer))
-			continue
-		}
-
-		gutter := gutterStyle.Width(gutterWidth).Render(p.lineNum)
-
-		var codePart string
-		if i < len(highlightedLines) {
-			codePart = highlightedLines[i]
-		} else {
-			codePart = p.code
-		}
-		// Truncate the (possibly ANSI-highlighted) line to fit within
-		// the code column, preventing lipgloss from wrapping it.
-		codePart = truncateLine(codePart, codeWidth-1) // account for PaddingLeft(1)
-		styledCode := codeStyle.Width(codeWidth).Render(codePart)
-
-		result = append(result, codeIndent+lipgloss.JoinHorizontal(lipgloss.Top, gutter, styledCode))
+	// Create typography with line number offset and custom formatter
+	// Match Write tool: GutterBg for line numbers, CodeBg for content
+	codeContent := strings.Join(codeLines, "\n")
+	theme := GetTheme()
+	hty := herald.Theme{
+		CodeBlock: lipgloss.NewStyle().
+			Background(theme.CodeBg).
+			PaddingLeft(1),
+		CodeLineNumber: lipgloss.NewStyle().
+			Foreground(theme.Muted).
+			Background(theme.GutterBg),
 	}
+	ty := herald.New(
+		herald.WithTheme(hty),
+		herald.WithCodeLineNumbers(true),
+		herald.WithCodeLineNumberOffset(offset),
+		herald.WithCodeFormatter(func(code, _ string) string {
+			// Use our syntax highlighter with the filename for lexer detection
+			return syntaxHighlight(code, fileName)
+		}),
+	)
 
-	// Truncation hint
+	// Render the code block
+	result := ty.CodeBlock(codeContent, lang)
+
+	// Add truncation hint if needed
 	if codeHiddenCount > 0 {
 		hint := fmt.Sprintf("...(%d more lines)", codeHiddenCount)
-		emptyGutter := gutterStyle.Width(gutterWidth).Render("")
-		hintContent := codeStyle.Width(codeWidth).
-			Foreground(theme.Muted).Italic(true).Render(hint)
-		result = append(result, codeIndent+lipgloss.JoinHorizontal(lipgloss.Top, emptyGutter, hintContent))
+		result += "\n" + lipgloss.NewStyle().Foreground(GetTheme().Muted).Italic(true).Render(hint)
 	}
 
-	return strings.Join(result, "\n")
+	// Add any footer lines
+	if len(footerLines) > 0 {
+		footer := strings.Join(footerLines, "\n")
+		result += "\n" + lipgloss.NewStyle().Foreground(GetTheme().Muted).Render(footer)
+	}
+
+	// Indent entire block to match Write/Edit tools (2 spaces)
+	const blockIndent = "  "
+	lines := strings.Split(result, "\n")
+	for i, line := range lines {
+		lines[i] = blockIndent + line
+	}
+	return strings.Join(lines, "\n")
 }
 
 // ---------------------------------------------------------------------------
@@ -558,7 +535,7 @@ func renderWriteBlock(content, fileName string, width int) string {
 	gutterWidth := numDigits + 2
 	codeWidth := max(width-gutterWidth-len(codeIndent), 20)
 
-	theme := getTheme()
+	theme := GetTheme()
 	gutterStyle := lipgloss.NewStyle().Foreground(theme.Muted).Background(theme.GutterBg).PaddingRight(1)
 	writeStyle := lipgloss.NewStyle().Background(theme.WriteBg).PaddingLeft(1)
 
@@ -610,7 +587,7 @@ func renderBashBody(toolResult string, width int) string {
 		return ""
 	}
 
-	theme := getTheme()
+	theme := GetTheme()
 	outputStyle := lipgloss.NewStyle().Background(theme.CodeBg).PaddingLeft(1)
 	stderrStyle := lipgloss.NewStyle().Foreground(theme.Error).Background(theme.CodeBg).PaddingLeft(1)
 
@@ -627,7 +604,6 @@ func renderBashBody(toolResult string, width int) string {
 
 	const lineIndent = "  "
 	// Truncate individual lines to the available width so they never wrap.
-	// This mirrors Crush's approach: truncate, don't wrap.
 	lineWidth := max(width-len(lineIndent), 20)
 	// Account for PaddingLeft(1) on the output/stderr styles
 	maxLineChars := lineWidth - 1
@@ -761,188 +737,10 @@ func truncateLine(s string, maxWidth int) string {
 	return xansi.Truncate(s, maxWidth, "…")
 }
 
-// ---------------------------------------------------------------------------
-// Compact tool body renderers — one-line summaries for compact mode
-// ---------------------------------------------------------------------------
-
-// renderToolBodyCompact returns a brief summary string for tool results in
-// compact display mode. Returns empty string to fall back to default.
-func renderToolBodyCompact(toolName, toolArgs, toolResult string, width int) string {
-	switch {
-	case toolName == "edit":
-		return renderEditCompact(toolArgs, toolResult)
-	case toolName == "ls":
-		return renderLsCompact(toolResult)
-	case toolName == "read":
-		return renderReadCompact(toolResult)
-	case toolName == "write":
-		return renderWriteCompact(toolArgs)
-	case toolName == "bash" || toolName == "grep" || toolName == "find" ||
-		strings.Contains(toolName, "shell") || strings.Contains(toolName, "command"):
-		return renderBashCompact(toolResult, width)
-	case toolName == "subagent":
-		return renderSubagentCompact(toolResult)
-	}
-	return ""
-}
-
-// renderReadCompact returns a line-count summary for Read tool output.
-func renderReadCompact(toolResult string) string {
-	content := strings.TrimSpace(toolResult)
-	if content == "" {
-		return ""
-	}
-
-	lines := strings.Split(content, "\n")
-
-	// Count actual code lines (those with "N: " line-number prefix)
-	codeLines := 0
-	for _, line := range lines {
-		if idx := strings.Index(line, ": "); idx > 0 && idx <= 7 {
-			numPart := line[:idx]
-			if _, err := strconv.Atoi(strings.TrimSpace(numPart)); err == nil {
-				codeLines++
-			}
-		}
-	}
-	if codeLines == 0 {
-		return ""
-	}
-
-	theme := getTheme()
-	summary := fmt.Sprintf("%d lines", codeLines)
-	return lipgloss.NewStyle().Foreground(theme.Muted).Italic(true).Render(summary)
-}
-
-// renderEditCompact returns a change-count summary for Edit tool output.
-func renderEditCompact(toolArgs, toolResult string) string {
-	var args map[string]any
-	if err := json.Unmarshal([]byte(toolArgs), &args); err != nil {
-		return ""
-	}
-
-	oldText, _ := args["old_text"].(string)
-	newText, _ := args["new_text"].(string)
-	if oldText == "" && newText == "" {
-		return ""
-	}
-
-	oldCount := len(strings.Split(oldText, "\n"))
-	newCount := len(strings.Split(newText, "\n"))
-
-	theme := getTheme()
-	var summary string
-	if oldCount == newCount {
-		summary = fmt.Sprintf("%d lines modified", oldCount)
-	} else {
-		summary = fmt.Sprintf("-%d/+%d lines", oldCount, newCount)
-	}
-	return lipgloss.NewStyle().Foreground(theme.Muted).Italic(true).Render(summary)
-}
-
-// renderWriteCompact returns a line-count summary for Write tool output.
-func renderWriteCompact(toolArgs string) string {
-	var args map[string]any
-	if err := json.Unmarshal([]byte(toolArgs), &args); err != nil {
-		return ""
-	}
-
-	content, _ := args["content"].(string)
-	if content == "" {
-		return ""
-	}
-
-	count := len(strings.Split(content, "\n"))
-	theme := getTheme()
-	summary := fmt.Sprintf("%d lines written", count)
-	return lipgloss.NewStyle().Foreground(theme.Muted).Italic(true).Render(summary)
-}
-
-// renderLsCompact returns an entry-count summary for Ls tool output.
-func renderLsCompact(toolResult string) string {
-	content := strings.TrimSpace(toolResult)
-	if content == "" {
-		return ""
-	}
-
-	entries := strings.Split(content, "\n")
-	theme := getTheme()
-	summary := fmt.Sprintf("%d entries", len(entries))
-	return lipgloss.NewStyle().Foreground(theme.Muted).Italic(true).Render(summary)
-}
-
-// renderBashCompact returns the first few lines of bash output as a compact
-// summary. Shows up to 3 meaningful output lines.
-func renderBashCompact(toolResult string, width int) string {
-	result := strings.TrimSpace(toolResult)
-	if result == "" {
-		return ""
-	}
-
-	lines := strings.Split(result, "\n")
-
-	// Filter to meaningful output lines (skip STDERR: label, keep exit codes separate)
-	var outputLines []string
-	var exitCode string
-	inStderr := false
-	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if trimmed == "STDERR:" {
-			inStderr = true
-			continue
-		}
-		if strings.HasPrefix(trimmed, "Exit code:") {
-			exitCode = trimmed
-			continue
-		}
-		if trimmed == "" {
-			continue
-		}
-		outputLines = append(outputLines, line)
-		_ = inStderr // stderr lines are included in output
-	}
-
-	if len(outputLines) == 0 {
-		if exitCode != "" {
-			theme := getTheme()
-			return lipgloss.NewStyle().Foreground(theme.Error).Render(exitCode)
-		}
-		return ""
-	}
-
-	const maxLines = 3
-	theme := getTheme()
-
-	display := outputLines
-	if len(display) > maxLines {
-		display = display[:maxLines]
-	}
-
-	// Truncate each line to available width (ANSI-aware)
-	lineMax := max(width-4, 20)
-	for i, line := range display {
-		display[i] = truncateLine(line, lineMax)
-	}
-
-	summary := strings.Join(display, "\n")
-	if len(outputLines) > maxLines {
-		summary += fmt.Sprintf("\n...(%d more lines)", len(outputLines)-maxLines)
-	}
-	if exitCode != "" {
-		summary += "\n" + lipgloss.NewStyle().Foreground(theme.Error).Render(exitCode)
-	}
-
-	return lipgloss.NewStyle().Foreground(theme.Muted).Render(summary)
-}
-
-// ---------------------------------------------------------------------------
-// Subagent tool renderers — show only summary, not full output
-// ---------------------------------------------------------------------------
-
 // renderSubagentBody renders a clean summary of subagent results with bash-style
 // background styling for consistency with other tools.
 func renderSubagentBody(toolResult string, width int) string {
-	theme := getTheme()
+	theme := GetTheme()
 	result := strings.TrimSpace(toolResult)
 	if result == "" {
 		return ""
@@ -1050,27 +848,3 @@ func extractSubagentPreviewLines(content string, maxLines, maxWidth int) []strin
 
 	return preview
 }
-
-// renderSubagentCompact returns a brief one-line summary for subagent results.
-func renderSubagentCompact(toolResult string) string {
-	result := strings.TrimSpace(toolResult)
-	if result == "" {
-		return ""
-	}
-
-	theme := getTheme()
-
-	// Extract just the first line which contains the status
-	lines := strings.Split(result, "\n")
-	if len(lines) == 0 {
-		return ""
-	}
-
-	statusLine := lines[0]
-
-	// Make it more compact by removing redundant words
-	statusLine = strings.Replace(statusLine, "Subagent completed successfully in ", "Completed in ", 1)
-	statusLine = strings.Replace(statusLine, "Subagent failed", "Failed", 1)
-
-	return lipgloss.NewStyle().Foreground(theme.Muted).Italic(true).Render(statusLine)
-}

internal/ui/tree_selector.go

@@ -265,7 +265,14 @@ func (ts *TreeSelectorComponent) View() tea.View {
 	footer := fmt.Sprintf("(%d/%d) [%s]", ts.cursor+1, len(ts.flatNodes), ts.filter)
 	b.WriteString(footerStyle.Render(footer))
 
-	return tea.NewView(b.String())
+	v := tea.NewView(b.String())
+	v.AltScreen = true
+	v.MouseMode = tea.MouseModeCellMotion
+	v.ReportFocus = true
+	v.KeyboardEnhancements = tea.KeyboardEnhancements{
+		ReportEventTypes: true,
+	}
+	return v
 }
 
 // IsActive returns whether the tree selector is still accepting input.

pkg/extensions/test/harness.go

@@ -52,7 +52,6 @@ type Harness struct {
 	t       *testing.T
 	runner  *extensions.Runner
 	context *MockContext
-	extPath string
 }
 
 // New creates a new test harness for the given test.
@@ -72,15 +71,9 @@ func New(t *testing.T) *Harness {
 func (h *Harness) LoadFile(path string) *extensions.LoadedExtension {
 	h.t.Helper()
 
-	// Verify file exists
-	if _, err := os.Stat(path); err != nil {
-		h.t.Fatalf("extension file not found: %s: %v", path, err)
-	}
-
-	// Read extension source
 	src, err := os.ReadFile(path)
 	if err != nil {
-		h.t.Fatalf("failed to read extension file: %v", err)
+		h.t.Fatalf("failed to read extension file %s: %v", path, err)
 	}
 
 	return h.loadSource(string(src), path)
@@ -144,7 +137,6 @@ func (h *Harness) loadSource(src string, path string) *extensions.LoadedExtensio
 
 	// Create runner with the loaded extension
 	h.runner = extensions.NewRunner([]extensions.LoadedExtension{*ext})
-	h.extPath = path
 
 	// Wire the mock context
 	h.runner.SetContext(h.context.ToContext())
@@ -222,11 +214,3 @@ func (h *Harness) RegisteredCommands() []extensions.CommandDef {
 	}
 	return h.runner.RegisteredCommands()
 }
-
-// MustLoad is like LoadFile but fails the test immediately on error.
-// It returns the harness for chaining.
-func (h *Harness) MustLoad(path string) *Harness {
-	h.t.Helper()
-	h.LoadFile(path)
-	return h
-}

pkg/extensions/test/mock.go

@@ -59,29 +59,12 @@ type MockContext struct {
 	Overlays []extensions.OverlayConfig
 }
 
-// StatusBarEntry represents a recorded status bar entry
-type StatusBarEntry struct {
-	Key      string
-	Text     string
-	Priority int
-}
-
 // NewMockContext creates a new mock context with default values.
 func NewMockContext() *MockContext {
 	return &MockContext{
-		Prints:        make([]string, 0),
-		PrintInfos:    make([]string, 0),
-		PrintErrors:   make([]string, 0),
-		PrintBlocks:   make([]extensions.PrintBlockOpts, 0),
-		Messages:      make([]string, 0),
-		CancelSends:   make([]string, 0),
 		Widgets:       make(map[string]extensions.WidgetConfig),
-		RemovedIDs:    make([]string, 0),
 		StatusEntries: make(map[string]extensions.StatusBarEntry),
-		RemovedStatus: make([]string, 0),
-		EditorTexts:   make([]string, 0),
 		Options:       make(map[string]string),
-		Overlays:      make([]extensions.OverlayConfig, 0),
 		Interactive:   true,
 		SessionID:     "test-session",
 		CWD:           "/test",

pkg/kit/README.md

@@ -1,6 +1,6 @@
 # KIT SDK
 
-The KIT SDK allows you to use KIT programmatically from Go applications without spawning OS processes.
+The KIT SDK (`pkg/kit`) lets you embed Kit's full agent capabilities — LLM interactions, tool execution, session management, streaming, hooks — into any Go application.
 
 ## Installation
 
@@ -17,26 +17,26 @@ import (
     "context"
     "fmt"
     "log"
-    
+
     kit "github.com/mark3labs/kit/pkg/kit"
 )
 
 func main() {
     ctx := context.Background()
-    
+
     // Create Kit instance with default configuration
     host, err := kit.New(ctx, nil)
     if err != nil {
         log.Fatal(err)
     }
-    defer host.Close()
-    
+    defer func() { _ = host.Close() }()
+
     // Send a prompt
     response, err := host.Prompt(ctx, "What is 2+2?")
     if err != nil {
         log.Fatal(err)
     }
-    
+
     fmt.Println(response)
 }
 ```
@@ -56,11 +56,23 @@ You can override specific settings:
 ```go
 host, err := kit.New(ctx, &kit.Options{
     Model:        "ollama/llama3",            // Override model
-    SystemPrompt: "You are a helpful bot",   // Override system prompt
-    ConfigFile:   "/path/to/config.yml",     // Use specific config file
-    MaxSteps:     10,                        // Override max steps
-    Streaming:    true,                      // Enable streaming
-    Quiet:        true,                      // Suppress debug output
+    SystemPrompt: "You are a helpful bot",    // Override system prompt
+    ConfigFile:   "/path/to/config.yml",      // Use specific config file
+    MaxSteps:     10,                         // Override max steps
+    Streaming:    true,                       // Enable streaming
+    Quiet:        true,                       // Suppress debug output
+
+    // Session options
+    SessionPath:  "./session.jsonl",          // Open specific session
+    Continue:     true,                       // Resume most recent session
+    NoSession:    true,                       // Ephemeral mode
+
+    // Tool options
+    Tools:        []kit.Tool{kit.NewBashTool()}, // Replace default tool set
+    ExtraTools:   []kit.Tool{myTool},            // Add alongside defaults
+
+    // Compaction
+    AutoCompact:  true,                       // Auto-compact near context limit
 })
 ```
 
@@ -108,34 +120,56 @@ host.Prompt(ctx, "My name is Alice")
 response, _ := host.Prompt(ctx, "What's my name?")
 // Response: "Your name is Alice"
 
-// Save session
-host.SaveSession("./session.json")
-
-// Load session later
-host.LoadSession("./session.json")
-
-// Clear session
+// Clear conversation history
 host.ClearSession()
 ```
 
+## Re-exported Types
+
+The SDK re-exports types so you don't need direct internal imports:
+
+```go
+// Message types
+kit.Message, kit.MessageRole, kit.ContentPart
+kit.TextContent, kit.ReasoningContent, kit.ToolCall, kit.ToolResult, kit.Finish
+kit.RoleUser, kit.RoleAssistant, kit.RoleTool, kit.RoleSystem
+
+// LLM types — concrete Kit-owned structs, no external library dependency
+kit.LLMMessage      // {Role LLMMessageRole, Content string}
+kit.LLMMessageRole  // "user" | "assistant" | "system" | "tool"
+kit.LLMUsage        // {InputTokens, OutputTokens, TotalTokens, ...}
+kit.LLMResponse     // {Content, FinishReason, Usage}
+kit.LLMFilePart     // {Filename, Data []byte, MediaType}
+
+// Conversion helpers
+msgs := kit.ConvertToLLMMessages(&msg)   // SDK Message → []LLMMessage
+msg  := kit.ConvertFromLLMMessage(lMsg)  // LLMMessage  → SDK Message
+```
+
 ## API Reference
 
 ### Types
 
 - `Kit` - Main SDK type
 - `Options` - Configuration options
-- `Message` - Conversation message
-- `ToolCall` - Tool invocation details
+- `Message` - Conversation message with typed content parts
+- `Tool` - Agent tool interface
+- `TurnResult` - Full result from a prompt including usage stats
 
-### Methods
+### Key Methods
 
 - `New(ctx, opts)` - Create new Kit instance
-- `Prompt(ctx, message)` - Send message and get response
-- `LoadSession(path)` - Load session from file
-- `SaveSession(path)` - Save session to file
-- `ClearSession()` - Clear conversation history
-- `GetSessionManager()` - Get session manager for advanced usage
+- `Prompt(ctx, message)` - Send message and get response string
+- `PromptResult(ctx, message)` - Send message and get full TurnResult
+- `PromptWithOptions(ctx, message, opts)` - Prompt with per-call options
+- `Steer(ctx, instruction)` - System-level steering
+- `FollowUp(ctx, text)` - Continue without new user input
+- `SetModel(ctx, model)` - Switch model at runtime
 - `GetModelString()` - Get current model string
+- `GetModelInfo()` - Get model capabilities and limits
+- `ClearSession()` - Clear conversation history
+- `GetSessionPath()` - Get session file path
+- `GetSessionID()` - Get session UUID
 - `Close()` - Clean up resources
 
 ## Environment Variables

pkg/kit/auth.go

@@ -1,6 +1,10 @@
 package kit
 
-import "github.com/mark3labs/kit/internal/auth"
+import (
+	"os"
+
+	"github.com/mark3labs/kit/internal/auth"
+)
 
 // CredentialManager manages API keys and OAuth credentials.
 type CredentialManager = auth.CredentialManager
@@ -66,14 +70,12 @@ func HasOpenAICredentials() bool {
 // Returns an empty string if no key is found.
 func GetOpenAIAPIKey() string {
 	cm, err := auth.NewCredentialManager()
-	if err != nil {
-		return ""
-	}
-	// Try to get valid access token (handles OAuth refresh)
-	token, err := cm.GetValidOpenAIAccessToken()
-	if err == nil && token != "" {
-		return token
+	if err == nil {
+		// Try to get valid access token (handles OAuth refresh)
+		if token, err := cm.GetValidOpenAIAccessToken(); err == nil && token != "" {
+			return token
+		}
 	}
 	// Fall back to environment variable
-	return ""
+	return os.Getenv("OPENAI_API_KEY")
 }

pkg/kit/compaction.go

@@ -2,10 +2,9 @@ package kit
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
-	"charm.land/fantasy"
-
 	"github.com/mark3labs/kit/internal/compaction"
 )
 
@@ -17,10 +16,14 @@ type ContextStats struct {
 	MessageCount    int     // Number of messages in the conversation
 }
 
+// defaultReserveTokens is the number of tokens to keep free in the context
+// window as a safety margin during compaction checks.
+const defaultReserveTokens = 16384
+
 // EstimateContextTokens returns the estimated token count of the current
 // conversation based on tree session messages.
 func (m *Kit) EstimateContextTokens() int {
-	messages := m.treeSession.GetFantasyMessages()
+	messages := m.treeSession.GetLLMMessages()
 	return compaction.EstimateMessageTokens(messages)
 }
 
@@ -34,12 +37,12 @@ func (m *Kit) ShouldCompact() bool {
 		return false
 	}
 
-	reserveTokens := 16384
+	reserveTokens := defaultReserveTokens
 	if m.compactionOpts != nil && m.compactionOpts.ReserveTokens > 0 {
 		reserveTokens = m.compactionOpts.ReserveTokens
 	}
 
-	messages := m.treeSession.GetFantasyMessages()
+	messages := m.treeSession.GetLLMMessages()
 	return compaction.ShouldCompact(messages, info.Limit.Context, reserveTokens)
 }
 
@@ -52,7 +55,7 @@ func (m *Kit) ShouldCompact() bool {
 // because it includes system prompts, tool definitions, and other overhead
 // that the heuristic cannot account for.
 func (m *Kit) GetContextStats() ContextStats {
-	messages := m.treeSession.GetFantasyMessages()
+	messages := m.treeSession.GetLLMMessages()
 
 	// Prefer the real API-reported input token count when available.
 	m.lastInputTokensMu.RLock()
@@ -111,7 +114,7 @@ func (m *Kit) compactInternal(ctx context.Context, opts *CompactionOptions, cust
 		}
 	}
 
-	messages := m.treeSession.GetFantasyMessages()
+	messages := m.treeSession.GetLLMMessages()
 	if len(messages) < 2 {
 		return nil, fmt.Errorf("cannot compact: need at least 2 messages")
 	}
@@ -131,7 +134,7 @@ func (m *Kit) compactInternal(ctx context.Context, opts *CompactionOptions, cust
 				if reason == "" {
 					reason = "compaction cancelled by extension"
 				}
-				return nil, fmt.Errorf("%s", reason)
+				return nil, errors.New(reason)
 			}
 			// Extension provided a custom summary — use it directly.
 			if hookResult.Summary != "" {
@@ -150,7 +153,15 @@ func (m *Kit) compactInternal(ctx context.Context, opts *CompactionOptions, cust
 	}
 
 	model := m.agent.GetModel()
-	result, _, err := compaction.Compact(ctx, model, messages, *opts, customInstructions, prev)
+
+	// Create a streaming callback to emit chunks as events.
+	streamCallback := func(delta string) error {
+		// Emit MessageUpdateEvent to the UI for streaming display.
+		m.events.emit(MessageUpdateEvent{Chunk: delta})
+		return nil
+	}
+
+	result, _, err := compaction.Compact(ctx, model, messages, *opts, customInstructions, prev, streamCallback)
 	if err != nil {
 		return nil, err
 	}
@@ -166,34 +177,17 @@ func (m *Kit) compactInternal(ctx context.Context, opts *CompactionOptions, cust
 		firstKeptEntryID = entryIDs[result.CutPoint]
 	}
 
-	if _, err := m.treeSession.AppendCompaction(
-		result.Summary,
-		firstKeptEntryID,
-		result.OriginalTokens,
-		result.CompactedTokens,
-		result.MessagesRemoved,
-		result.ReadFiles,
-		result.ModifiedFiles,
-	); err != nil {
-		return nil, fmt.Errorf("failed to persist compaction entry: %w", err)
+	if err := m.persistAndEmitCompaction(result.Summary, firstKeptEntryID, result.OriginalTokens, result.CompactedTokens, result.MessagesRemoved, result.ReadFiles, result.ModifiedFiles); err != nil {
+		return nil, err
 	}
 
-	m.events.emit(CompactionEvent{
-		Summary:         result.Summary,
-		OriginalTokens:  result.OriginalTokens,
-		CompactedTokens: result.CompactedTokens,
-		MessagesRemoved: result.MessagesRemoved,
-		ReadFiles:       result.ReadFiles,
-		ModifiedFiles:   result.ModifiedFiles,
-	})
-
 	return result, nil
 }
 
 // applyCustomCompaction handles compaction when an extension provides a
 // custom summary. It still determines the cut point and persists a
 // CompactionEntry.
-func (m *Kit) applyCustomCompaction(summary string, messages []fantasy.Message, opts *CompactionOptions) (*CompactionResult, error) {
+func (m *Kit) applyCustomCompaction(summary string, messages []LLMMessage, opts *CompactionOptions) (*CompactionResult, error) {
 	originalTokens := compaction.EstimateMessageTokens(messages)
 
 	cutPoint := compaction.FindCutPoint(messages, opts.KeepRecentTokens)
@@ -211,24 +205,13 @@ func (m *Kit) applyCustomCompaction(summary string, messages []fantasy.Message,
 	}
 
 	// Estimate new token count.
-	summaryTokens := compaction.EstimateMessageTokens([]fantasy.Message{{
-		Role:    "system",
-		Content: []fantasy.MessagePart{fantasy.TextPart{Text: summary}},
+	summaryTokens := compaction.EstimateMessageTokens([]LLMMessage{{
+		Role:    LLMRoleSystem,
+		Content: []LLMMessagePart{LLMTextPart{Text: summary}},
 	}})
 	recentTokens := compaction.EstimateMessageTokens(messages[cutPoint:])
 	compactedTokens := summaryTokens + recentTokens
 
-	if _, err := m.treeSession.AppendCompaction(
-		summary,
-		firstKeptEntryID,
-		originalTokens,
-		compactedTokens,
-		cutPoint,
-		nil, nil, // no file tracking for custom summaries
-	); err != nil {
-		return nil, fmt.Errorf("failed to persist compaction entry: %w", err)
-	}
-
 	result := &CompactionResult{
 		Summary:         summary,
 		OriginalTokens:  originalTokens,
@@ -236,12 +219,41 @@ func (m *Kit) applyCustomCompaction(summary string, messages []fantasy.Message,
 		MessagesRemoved: cutPoint,
 	}
 
-	m.events.emit(CompactionEvent{
-		Summary:         result.Summary,
-		OriginalTokens:  result.OriginalTokens,
-		CompactedTokens: result.CompactedTokens,
-		MessagesRemoved: result.MessagesRemoved,
-	})
+	if err := m.persistAndEmitCompaction(summary, firstKeptEntryID, originalTokens, compactedTokens, cutPoint, nil, nil); err != nil {
+		return nil, err
+	}
 
 	return result, nil
 }
+
+// persistAndEmitCompaction writes a CompactionEntry to the session tree and
+// emits a CompactionEvent. It is the single implementation shared by
+// compactInternal and applyCustomCompaction.
+func (m *Kit) persistAndEmitCompaction(
+	summary, firstKeptEntryID string,
+	originalTokens, compactedTokens, messagesRemoved int,
+	readFiles, modifiedFiles []string,
+) error {
+	if _, err := m.treeSession.AppendCompaction(
+		summary,
+		firstKeptEntryID,
+		originalTokens,
+		compactedTokens,
+		messagesRemoved,
+		readFiles,
+		modifiedFiles,
+	); err != nil {
+		return fmt.Errorf("failed to persist compaction entry: %w", err)
+	}
+	m.events.emit(CompactionEvent{
+		Summary:         summary,
+		OriginalTokens:  originalTokens,
+		CompactedTokens: compactedTokens,
+		MessagesRemoved: messagesRemoved,
+		ReadFiles:       readFiles,
+		ModifiedFiles:   modifiedFiles,
+	})
+	return nil
+}
+
+// Conversion helpers are in llm_convert.go.

pkg/kit/config.go

@@ -12,6 +12,10 @@ import (
 // defaultSystemPrompt is the built-in system prompt used when no custom
 // prompt is configured. It describes the available core tools and provides
 // usage guidelines.
+//
+// NOTE: Keep this in sync with the CLI default in cmd/root.go (search for
+// defaultSystemPrompt or system-prompt flag default). Changes here should
+// generally be reflected there, and vice versa.
 const defaultSystemPrompt = `You are an expert coding assistant operating inside kit, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
 
 Available tools:
@@ -78,20 +82,16 @@ func InitConfig(configFile string, debug bool) error {
 	viper.AddConfigPath(home)
 
 	configLoaded := false
-	configNames := []string{".kit"}
 
-	for _, name := range configNames {
-		viper.SetConfigName(name)
-		if err := viper.ReadInConfig(); err == nil {
-			configPath := viper.ConfigFileUsed()
-			if err := LoadConfigWithEnvSubstitution(configPath); err != nil {
-				if strings.Contains(err.Error(), "environment variable substitution failed") {
-					return fmt.Errorf("error reading config file '%s': %w", configPath, err)
-				}
-				continue
+	viper.SetConfigName(".kit")
+	if err := viper.ReadInConfig(); err == nil {
+		configPath := viper.ConfigFileUsed()
+		if err := LoadConfigWithEnvSubstitution(configPath); err != nil {
+			if strings.Contains(err.Error(), "environment variable substitution failed") {
+				return fmt.Errorf("error reading config file '%s': %w", configPath, err)
 			}
+		} else {
 			configLoaded = true
-			break
 		}
 	}
 

pkg/kit/events.go

@@ -76,13 +76,13 @@ const (
 // coreToolKinds maps built-in tool names to their kind. MCP and extension
 // tools without an entry default to ToolKindExecute.
 var coreToolKinds = map[string]string{
-	"bash":           ToolKindExecute,
-	"edit":           ToolKindEdit,
-	"write":          ToolKindEdit,
-	"read":           ToolKindRead,
-	"ls":             ToolKindRead,
-	"grep":           ToolKindSearch,
-	"find":           ToolKindSearch,
+	"bash":     ToolKindExecute,
+	"edit":     ToolKindEdit,
+	"write":    ToolKindEdit,
+	"read":     ToolKindRead,
+	"ls":       ToolKindRead,
+	"grep":     ToolKindSearch,
+	"find":     ToolKindSearch,
 	"subagent": ToolKindSubagent,
 }
 
@@ -416,42 +416,6 @@ func (m *Kit) OnTurnEnd(handler func(TurnEndEvent)) func() {
 // Subagent event subscriptions
 // ---------------------------------------------------------------------------
 
-// subagentListenerSet holds per-tool-call listeners for subagent events.
-type subagentListenerSet struct {
-	mu        sync.RWMutex
-	listeners map[int]EventListener
-	nextID    int
-}
-
-func newSubagentListenerSet() *subagentListenerSet {
-	return &subagentListenerSet{listeners: make(map[int]EventListener)}
-}
-
-func (s *subagentListenerSet) add(listener EventListener) func() {
-	s.mu.Lock()
-	id := s.nextID
-	s.nextID++
-	s.listeners[id] = listener
-	s.mu.Unlock()
-	return func() {
-		s.mu.Lock()
-		delete(s.listeners, id)
-		s.mu.Unlock()
-	}
-}
-
-func (s *subagentListenerSet) emit(event Event) {
-	s.mu.RLock()
-	snapshot := make([]EventListener, 0, len(s.listeners))
-	for _, l := range s.listeners {
-		snapshot = append(snapshot, l)
-	}
-	s.mu.RUnlock()
-	for _, l := range snapshot {
-		l(event)
-	}
-}
-
 // SubscribeSubagent registers a listener for real-time events from a subagent
 // identified by its tool call ID. Returns an unsubscribe function.
 //
@@ -470,14 +434,14 @@ func (s *subagentListenerSet) emit(event Event) {
 //	    }
 //	})
 func (m *Kit) SubscribeSubagent(toolCallID string, listener EventListener) func() {
-	actual, _ := m.subagentListeners.LoadOrStore(toolCallID, newSubagentListenerSet())
-	return actual.(*subagentListenerSet).add(listener)
+	actual, _ := m.subagentListeners.LoadOrStore(toolCallID, newEventBus())
+	return actual.(*eventBus).subscribe(listener)
 }
 
 // getSubagentListenerSet returns the listener set for a tool call, or nil.
-func (m *Kit) getSubagentListenerSet(toolCallID string) *subagentListenerSet {
+func (m *Kit) getSubagentListenerSet(toolCallID string) *eventBus {
 	if v, ok := m.subagentListeners.Load(toolCallID); ok {
-		return v.(*subagentListenerSet)
+		return v.(*eventBus)
 	}
 	return nil
 }

pkg/kit/events_test.go

@@ -140,8 +140,14 @@ func TestEventBusConcurrentSubscribeEmit(t *testing.T) {
 	wg.Wait()
 
 	// We can't assert an exact count because subscribe/emit ordering is
-	// non-deterministic, but it must not panic or deadlock.
-	t.Logf("total events received across subscribers: %d", total.Load())
+	// non-deterministic, but we can assert the count is non-negative and
+	// that no events were lost (each subscriber that registered before an
+	// emit must have received it at least partially).
+	got := total.Load()
+	if got < 0 {
+		t.Errorf("expected non-negative total event count, got %d", got)
+	}
+	t.Logf("total events received across subscribers: %d", got)
 }
 
 // TestEventBusEmitNoListeners verifies emit is a no-op with no subscribers.
@@ -169,6 +175,11 @@ func TestEventTypes(t *testing.T) {
 		{ToolResultEvent{}, EventToolResult},
 		{ToolCallContentEvent{}, EventToolCallContent},
 		{ResponseEvent{}, EventResponse},
+		{CompactionEvent{}, EventCompaction},
+		{ReasoningDeltaEvent{}, EventReasoningDelta},
+		{ToolOutputEvent{}, EventToolOutput},
+		{StepUsageEvent{}, EventStepUsage},
+		{SteerConsumedEvent{}, EventSteerConsumed},
 	}
 
 	for _, tt := range tests {
@@ -212,26 +223,36 @@ func TestEventOrdering(t *testing.T) {
 		EventTurnStart,
 		EventMessageStart,
 		EventMessageUpdate,
+		EventReasoningDelta,
+		EventToolOutput,
 		EventToolCall,
 		EventToolExecutionStart,
 		EventToolExecutionEnd,
 		EventToolResult,
 		EventToolCallContent,
 		EventMessageEnd,
+		EventStepUsage,
 		EventResponse,
+		EventCompaction,
+		EventSteerConsumed,
 		EventTurnEnd,
 	}
 
 	bus.emit(TurnStartEvent{})
 	bus.emit(MessageStartEvent{})
 	bus.emit(MessageUpdateEvent{Chunk: "hello"})
+	bus.emit(ReasoningDeltaEvent{Delta: "thinking..."})
+	bus.emit(ToolOutputEvent{ToolName: "bash", Chunk: "output"})
 	bus.emit(ToolCallEvent{ToolName: "bash"})
 	bus.emit(ToolExecutionStartEvent{ToolName: "bash"})
 	bus.emit(ToolExecutionEndEvent{ToolName: "bash"})
 	bus.emit(ToolResultEvent{ToolName: "bash", Result: "ok"})
 	bus.emit(ToolCallContentEvent{Content: "I'll run bash"})
 	bus.emit(MessageEndEvent{Content: "done"})
+	bus.emit(StepUsageEvent{InputTokens: 100})
 	bus.emit(ResponseEvent{Content: "done"})
+	bus.emit(CompactionEvent{Summary: "compacted"})
+	bus.emit(SteerConsumedEvent{Count: 1})
 	bus.emit(TurnEndEvent{Response: "done"})
 
 	if len(types) != len(expected) {

pkg/kit/extension_api.go

@@ -0,0 +1,435 @@
+package kit
+
+import (
+	"fmt"
+
+	"github.com/mark3labs/kit/internal/extensions"
+	"github.com/mark3labs/kit/internal/message"
+	"github.com/mark3labs/kit/internal/session"
+)
+
+// ExtensionAPI provides grouped access to all extension-related functionality.
+// This cleans up the main Kit API surface while keeping all extension capabilities available.
+type ExtensionAPI interface {
+	// Context management
+	SetContext(ctx extensions.Context)
+	GetContext() extensions.Context
+	UpdateContextModel(model string)
+
+	// Widgets
+	SetWidget(config extensions.WidgetConfig)
+	RemoveWidget(id string)
+	GetWidgets(placement extensions.WidgetPlacement) []extensions.WidgetConfig
+
+	// Header/Footer
+	SetHeader(config extensions.HeaderFooterConfig)
+	RemoveHeader()
+	GetHeader() *extensions.HeaderFooterConfig
+	SetFooter(config extensions.HeaderFooterConfig)
+	RemoveFooter()
+	GetFooter() *extensions.HeaderFooterConfig
+
+	// Editor
+	SetEditor(config extensions.EditorConfig)
+	ResetEditor()
+	GetEditor() *extensions.EditorConfig
+
+	// UI Visibility
+	SetUIVisibility(v extensions.UIVisibility)
+	GetUIVisibility() *extensions.UIVisibility
+
+	// Tool rendering
+	GetToolRenderer(toolName string) *extensions.ToolRenderConfig
+	GetMessageRenderer(name string) *extensions.MessageRendererConfig
+
+	// Session data
+	GetSessionMessages() []extensions.SessionMessage
+	AppendEntry(extType, data string) (string, error)
+	GetEntries(extType string) []extensions.ExtensionEntry
+
+	// Status bar
+	SetStatus(entry extensions.StatusBarEntry)
+	RemoveStatus(key string)
+	GetStatusEntries() []extensions.StatusBarEntry
+
+	// Shortcuts
+	GetShortcuts() map[string]func()
+
+	// Tools
+	GetToolInfos() []extensions.ToolInfo
+	SetActiveTools(names []string)
+
+	// Options
+	GetOption(name string) string
+	SetOption(name, value string)
+
+	// Events
+	EmitSessionStart()
+	EmitModelChange(newModel, previousModel, source string)
+	EmitCustomEvent(name, data string)
+	EmitBeforeFork(targetID string, isUserMsg bool, userText string) (cancelled bool, reason string)
+	EmitBeforeSessionSwitch(switchReason string) (cancelled bool, reason string)
+
+	// Commands
+	Commands() []extensions.CommandDef
+
+	// Lifecycle
+	Reload() error
+	HasExtensions() bool
+}
+
+// extensionAPI implements ExtensionAPI by wrapping a Kit instance.
+type extensionAPI struct {
+	kit *Kit
+}
+
+// Extensions returns the ExtensionAPI for accessing all extension-related functionality.
+func (m *Kit) Extensions() ExtensionAPI {
+	return &extensionAPI{kit: m}
+}
+
+// Context management
+
+func (e *extensionAPI) SetContext(ctx extensions.Context) {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.SetContext(ctx)
+	}
+}
+
+func (e *extensionAPI) GetContext() extensions.Context {
+	if e.kit.extRunner != nil {
+		return e.kit.extRunner.GetContext()
+	}
+	return extensions.Context{}
+}
+
+func (e *extensionAPI) UpdateContextModel(model string) {
+	if e.kit.extRunner != nil {
+		ctx := e.kit.extRunner.GetContext()
+		ctx.Model = model
+		e.kit.extRunner.SetContext(ctx)
+	}
+}
+
+// Widgets
+
+func (e *extensionAPI) SetWidget(config extensions.WidgetConfig) {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.SetWidget(config)
+	}
+}
+
+func (e *extensionAPI) RemoveWidget(id string) {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.RemoveWidget(id)
+	}
+}
+
+func (e *extensionAPI) GetWidgets(placement extensions.WidgetPlacement) []extensions.WidgetConfig {
+	if e.kit.extRunner == nil {
+		return nil
+	}
+	return e.kit.extRunner.GetWidgets(placement)
+}
+
+// Header/Footer
+
+func (e *extensionAPI) SetHeader(config extensions.HeaderFooterConfig) {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.SetHeader(config)
+	}
+}
+
+func (e *extensionAPI) RemoveHeader() {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.RemoveHeader()
+	}
+}
+
+func (e *extensionAPI) GetHeader() *extensions.HeaderFooterConfig {
+	if e.kit.extRunner == nil {
+		return nil
+	}
+	return e.kit.extRunner.GetHeader()
+}
+
+func (e *extensionAPI) SetFooter(config extensions.HeaderFooterConfig) {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.SetFooter(config)
+	}
+}
+
+func (e *extensionAPI) RemoveFooter() {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.RemoveFooter()
+	}
+}
+
+func (e *extensionAPI) GetFooter() *extensions.HeaderFooterConfig {
+	if e.kit.extRunner == nil {
+		return nil
+	}
+	return e.kit.extRunner.GetFooter()
+}
+
+// Editor
+
+func (e *extensionAPI) SetEditor(config extensions.EditorConfig) {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.SetEditor(config)
+	}
+}
+
+func (e *extensionAPI) ResetEditor() {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.ResetEditor()
+	}
+}
+
+func (e *extensionAPI) GetEditor() *extensions.EditorConfig {
+	if e.kit.extRunner == nil {
+		return nil
+	}
+	return e.kit.extRunner.GetEditor()
+}
+
+// UI Visibility
+
+func (e *extensionAPI) SetUIVisibility(v extensions.UIVisibility) {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.SetUIVisibility(v)
+	}
+}
+
+func (e *extensionAPI) GetUIVisibility() *extensions.UIVisibility {
+	if e.kit.extRunner == nil {
+		return nil
+	}
+	return e.kit.extRunner.GetUIVisibility()
+}
+
+// Tool rendering
+
+func (e *extensionAPI) GetToolRenderer(toolName string) *extensions.ToolRenderConfig {
+	if e.kit.extRunner == nil {
+		return nil
+	}
+	return e.kit.extRunner.GetToolRenderer(toolName)
+}
+
+func (e *extensionAPI) GetMessageRenderer(name string) *extensions.MessageRendererConfig {
+	if e.kit.extRunner == nil {
+		return nil
+	}
+	return e.kit.extRunner.GetMessageRenderer(name)
+}
+
+// Session data
+
+func (e *extensionAPI) GetSessionMessages() []extensions.SessionMessage {
+	return iterBranchMessages(e.kit.treeSession, func(me *session.MessageEntry, msg message.Message) extensions.SessionMessage {
+		return extensions.SessionMessage{
+			ID:        me.ID,
+			Role:      string(msg.Role),
+			Content:   msg.Content(),
+			Timestamp: me.Timestamp.Format("2006-01-02T15:04:05Z07:00"),
+		}
+	})
+}
+
+func (e *extensionAPI) AppendEntry(extType, data string) (string, error) {
+	if e.kit.treeSession == nil {
+		return "", fmt.Errorf("no session available")
+	}
+	return e.kit.treeSession.AppendExtensionData(extType, data)
+}
+
+func (e *extensionAPI) GetEntries(extType string) []extensions.ExtensionEntry {
+	if e.kit.treeSession == nil {
+		return nil
+	}
+	entries := e.kit.treeSession.GetExtensionData(extType)
+	result := make([]extensions.ExtensionEntry, 0, len(entries))
+	for _, e := range entries {
+		result = append(result, extensions.ExtensionEntry{
+			ID:        e.ID,
+			EntryType: e.ExtType,
+			Data:      e.Data,
+			Timestamp: e.Timestamp.Format("2006-01-02T15:04:05Z07:00"),
+		})
+	}
+	return result
+}
+
+// Status bar
+
+func (e *extensionAPI) SetStatus(entry extensions.StatusBarEntry) {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.SetStatusEntry(entry)
+	}
+}
+
+func (e *extensionAPI) RemoveStatus(key string) {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.RemoveStatusEntry(key)
+	}
+}
+
+func (e *extensionAPI) GetStatusEntries() []extensions.StatusBarEntry {
+	if e.kit.extRunner == nil {
+		return nil
+	}
+	return e.kit.extRunner.GetStatusEntries()
+}
+
+// Shortcuts
+
+func (e *extensionAPI) GetShortcuts() map[string]func() {
+	if e.kit.extRunner == nil {
+		return nil
+	}
+	entries := e.kit.extRunner.GetShortcuts()
+	if entries == nil {
+		return nil
+	}
+	result := make(map[string]func(), len(entries))
+	for key, entry := range entries {
+		h := entry.Handler
+		r := e.kit.extRunner
+		result[key] = func() {
+			ctx := r.GetContext()
+			h(ctx)
+		}
+	}
+	return result
+}
+
+// Tools
+
+func (e *extensionAPI) GetToolInfos() []extensions.ToolInfo {
+	agentTools := e.kit.agent.GetTools()
+	coreCount := e.kit.agent.GetCoreToolCount()
+	mcpCount := e.kit.agent.GetMCPToolCount()
+
+	result := make([]extensions.ToolInfo, 0, len(agentTools))
+	for i, t := range agentTools {
+		info := t.Info()
+		source := "core"
+		if i >= coreCount && i < coreCount+mcpCount {
+			source = "mcp"
+		} else if i >= coreCount+mcpCount {
+			source = "extension"
+		}
+		enabled := true
+		if e.kit.extRunner != nil && e.kit.extRunner.IsToolDisabled(info.Name) {
+			enabled = false
+		}
+		result = append(result, extensions.ToolInfo{
+			Name:        info.Name,
+			Description: info.Description,
+			Source:      source,
+			Enabled:     enabled,
+		})
+	}
+	return result
+}
+
+func (e *extensionAPI) SetActiveTools(names []string) {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.SetActiveTools(names)
+	}
+}
+
+// Options
+
+func (e *extensionAPI) GetOption(name string) string {
+	if e.kit.extRunner == nil {
+		return ""
+	}
+	return e.kit.extRunner.GetOption(name)
+}
+
+func (e *extensionAPI) SetOption(name, value string) {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.SetOption(name, value)
+	}
+}
+
+// Events
+
+func (e *extensionAPI) EmitSessionStart() {
+	if e.kit.extRunner != nil && e.kit.extRunner.HasHandlers(extensions.SessionStart) {
+		_, _ = e.kit.extRunner.Emit(extensions.SessionStartEvent{})
+	}
+}
+
+func (e *extensionAPI) EmitModelChange(newModel, previousModel, source string) {
+	if e.kit.extRunner != nil && e.kit.extRunner.HasHandlers(extensions.ModelChange) {
+		_, _ = e.kit.extRunner.Emit(extensions.ModelChangeEvent{
+			NewModel:      newModel,
+			PreviousModel: previousModel,
+			Source:        source,
+		})
+	}
+}
+
+func (e *extensionAPI) EmitCustomEvent(name, data string) {
+	if e.kit.extRunner != nil {
+		e.kit.extRunner.EmitCustomEvent(name, data)
+	}
+}
+
+func (e *extensionAPI) EmitBeforeFork(targetID string, isUserMsg bool, userText string) (cancelled bool, reason string) {
+	if e.kit.extRunner == nil || !e.kit.extRunner.HasHandlers(extensions.BeforeFork) {
+		return false, ""
+	}
+	result, _ := e.kit.extRunner.Emit(extensions.BeforeForkEvent{
+		TargetID:      targetID,
+		IsUserMessage: isUserMsg,
+		UserText:      userText,
+	})
+	if r, ok := result.(extensions.BeforeForkResult); ok && r.Cancel {
+		reason := r.Reason
+		if reason == "" {
+			reason = "Fork cancelled by extension."
+		}
+		return true, reason
+	}
+	return false, ""
+}
+
+func (e *extensionAPI) EmitBeforeSessionSwitch(switchReason string) (cancelled bool, reason string) {
+	if e.kit.extRunner == nil || !e.kit.extRunner.HasHandlers(extensions.BeforeSessionSwitch) {
+		return false, ""
+	}
+	result, _ := e.kit.extRunner.Emit(extensions.BeforeSessionSwitchEvent{
+		Reason: switchReason,
+	})
+	if r, ok := result.(extensions.BeforeSessionSwitchResult); ok && r.Cancel {
+		reason := r.Reason
+		if reason == "" {
+			reason = "Session switch cancelled by extension."
+		}
+		return true, reason
+	}
+	return false, ""
+}
+
+// Commands
+
+func (e *extensionAPI) Commands() []extensions.CommandDef {
+	if e.kit.extRunner == nil {
+		return nil
+	}
+	return e.kit.extRunner.RegisteredCommands()
+}
+
+// Lifecycle
+
+func (e *extensionAPI) Reload() error {
+	return e.kit.ReloadExtensions()
+}
+
+func (e *extensionAPI) HasExtensions() bool {
+	return e.kit.extRunner != nil
+}

pkg/kit/extensions_bridge.go

@@ -4,7 +4,6 @@ import (
 	"strings"
 	"sync"
 
-	"charm.land/fantasy"
 	"github.com/mark3labs/kit/internal/extensions"
 )
 
@@ -104,11 +103,9 @@ func (m *Kit) bridgeExtensions(runner *extensions.Runner) {
 	if runner.HasHandlers(extensions.AgentEnd) {
 		m.Subscribe(func(e Event) {
 			if ev, ok := e.(TurnEndEvent); ok {
-				stopReason := ev.StopReason
-				response := ev.Response
+				stopReason, response := ev.StopReason, ev.Response
 				if ev.Error != nil {
-					stopReason = "error"
-					response = ""
+					stopReason, response = "error", ""
 				} else if stopReason == "" {
 					stopReason = "completed"
 				}
@@ -141,7 +138,7 @@ func (m *Kit) bridgeExtensions(runner *extensions.Runner) {
 		// taskByCallID tracks the task description extracted from ToolCall input,
 		// keyed by toolCallID. Populated on ToolCall, consumed on ToolResult.
 		taskByCallID := make(map[string]string)
-		var taskMu = &taskMutex{}
+		var taskMu sync.Mutex
 
 		// Intercept ToolCall to capture the task and subscribe to child events.
 		m.Subscribe(func(e Event) {
@@ -157,7 +154,9 @@ func (m *Kit) bridgeExtensions(runner *extensions.Runner) {
 					task = t
 				}
 			}
-			taskMu.set(taskByCallID, ev.ToolCallID, task)
+			taskMu.Lock()
+			taskByCallID[ev.ToolCallID] = task
+			taskMu.Unlock()
 
 			// Subscribe to child events so we can forward them as SubagentChunkEvents.
 			if runner.HasHandlers(extensions.SubagentChunk) {
@@ -204,7 +203,9 @@ func (m *Kit) bridgeExtensions(runner *extensions.Runner) {
 				if !ok || ev.ToolName != "subagent" {
 					return
 				}
-				task := taskMu.get(taskByCallID, ev.ToolCallID)
+				taskMu.Lock()
+				task := taskByCallID[ev.ToolCallID]
+				taskMu.Unlock()
 				_, _ = runner.Emit(extensions.SubagentStartEvent{
 					ToolCallID: ev.ToolCallID,
 					Task:       task,
@@ -219,8 +220,10 @@ func (m *Kit) bridgeExtensions(runner *extensions.Runner) {
 				if !ok || ev.ToolName != "subagent" {
 					return
 				}
-				task := taskMu.get(taskByCallID, ev.ToolCallID)
-				taskMu.del(taskByCallID, ev.ToolCallID)
+				taskMu.Lock()
+				task := taskByCallID[ev.ToolCallID]
+				delete(taskByCallID, ev.ToolCallID)
+				taskMu.Unlock()
 				errMsg := ""
 				if ev.IsError {
 					errMsg = ev.Result
@@ -243,20 +246,20 @@ func (m *Kit) bridgeExtensions(runner *extensions.Runner) {
 	// Extension ContextPrepare → SDK ContextPrepare hook.
 	if runner.HasHandlers(extensions.ContextPrepare) {
 		m.OnContextPrepare(HookPriorityNormal, func(h ContextPrepareHook) *ContextPrepareResult {
-			// Convert fantasy.Message slice to extension ContextMessage slice.
+			// Convert LLM message slice to extension ContextMessage slice.
+			// Extract plain text from each message for the extension API.
 			extMsgs := make([]extensions.ContextMessage, len(h.Messages))
 			for i, msg := range h.Messages {
-				// Extract text from content parts.
-				var text strings.Builder
+				var sb strings.Builder
 				for _, part := range msg.Content {
-					if tp, ok := part.(fantasy.TextPart); ok {
-						text.WriteString(tp.Text)
+					if tp, ok := part.(LLMTextPart); ok {
+						sb.WriteString(tp.Text)
 					}
 				}
 				extMsgs[i] = extensions.ContextMessage{
 					Index:   i,
 					Role:    string(msg.Role),
-					Content: text.String(),
+					Content: sb.String(),
 				}
 			}
 
@@ -266,28 +269,26 @@ func (m *Kit) bridgeExtensions(runner *extensions.Runner) {
 				return nil
 			}
 
-			// Rebuild fantasy.Message slice from extension result.
-			rebuilt := make([]fantasy.Message, 0, len(r.Messages))
+			// Rebuild LLM message slice from extension result.
+			rebuilt := make([]LLMMessage, 0, len(r.Messages))
 			for _, cm := range r.Messages {
 				if cm.Index >= 0 && cm.Index < len(h.Messages) {
-					// Reuse original message (preserves tool calls, reasoning, etc.)
+					// Reuse original message (preserves original role and content).
 					rebuilt = append(rebuilt, h.Messages[cm.Index])
 				} else {
-					// New message injected by extension.
-					role := fantasy.MessageRoleUser
+					// New message injected by extension — construct from role + text.
+					role := LLMRoleUser
 					switch cm.Role {
 					case "assistant":
-						role = fantasy.MessageRoleAssistant
+						role = LLMRoleAssistant
 					case "system":
-						role = fantasy.MessageRoleSystem
+						role = LLMRoleSystem
 					case "tool":
-						role = fantasy.MessageRoleTool
+						role = LLMRoleTool
 					}
-					rebuilt = append(rebuilt, fantasy.Message{
-						Role: role,
-						Content: []fantasy.MessagePart{
-							fantasy.TextPart{Text: cm.Content},
-						},
+					rebuilt = append(rebuilt, LLMMessage{
+						Role:    role,
+						Content: []LLMMessagePart{LLMTextPart{Text: cm.Content}},
 					})
 				}
 			}
@@ -324,27 +325,3 @@ func (m *Kit) bridgeExtensions(runner *extensions.Runner) {
 		})
 	}
 }
-
-// taskMutex is a simple mutex-protected map helper used by bridgeExtensions.
-// It lives in this file to avoid polluting the kit package with unexported types.
-type taskMutex struct {
-	mu sync.Mutex
-}
-
-func (t *taskMutex) set(m map[string]string, key, val string) {
-	t.mu.Lock()
-	m[key] = val
-	t.mu.Unlock()
-}
-
-func (t *taskMutex) get(m map[string]string, key string) string {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	return m[key]
-}
-
-func (t *taskMutex) del(m map[string]string, key string) {
-	t.mu.Lock()
-	delete(m, key)
-	t.mu.Unlock()
-}

pkg/kit/hooks.go

@@ -82,15 +82,15 @@ type AfterTurnResult struct{}
 // is assembled from the session tree (including compaction) and before the
 // messages are sent to the LLM. Hooks can filter, reorder, or inject messages.
 type ContextPrepareHook struct {
-	// Messages is the current context as fantasy.Message objects.
-	Messages []fantasy.Message
+	// Messages is the current context as LLM message objects.
+	Messages []LLMMessage
 }
 
 // ContextPrepareResult can replace the context window.
 type ContextPrepareResult struct {
 	// Messages replaces the entire context window. If nil, the original
 	// messages are used.
-	Messages []fantasy.Message
+	Messages []LLMMessage
 }
 
 // BeforeCompactHook is the input for hooks that fire before compaction runs.
@@ -167,8 +167,13 @@ func (hr *hookRegistry[In, Out]) register(p HookPriority, h func(In) *Out) func(
 }
 
 // run executes all hooks in priority order. The first non-nil result wins.
+// Returns nil immediately if no hooks are registered.
 func (hr *hookRegistry[In, Out]) run(input In) *Out {
 	hr.mu.RLock()
+	if len(hr.hooks) == 0 {
+		hr.mu.RUnlock()
+		return nil
+	}
 	snapshot := make([]hookEntry[In, Out], len(hr.hooks))
 	copy(snapshot, hr.hooks)
 	hr.mu.RUnlock()
@@ -247,7 +252,7 @@ func (m *Kit) OnBeforeCompact(p HookPriority, h func(BeforeCompactHook) *BeforeC
 // Tool wrapping via hooks
 // ---------------------------------------------------------------------------
 
-// hookedTool wraps a fantasy.AgentTool to run BeforeToolCall and
+// hookedTool wraps an AgentTool to run BeforeToolCall and
 // AfterToolResult hooks around each execution. The registries are referenced
 // by pointer so hooks added after agent creation are still invoked.
 type hookedTool struct {

pkg/kit/hooks_test.go

@@ -107,6 +107,11 @@ func TestHookRegistry_SamePriorityPreservesOrder(t *testing.T) {
 func TestHookRegistry_Unregister(t *testing.T) {
 	hr := newHookRegistry[string, string]()
 
+	// Verify initial state (merged from TestHookRegistry_HasHooks).
+	if hr.hasHooks() {
+		t.Error("expected hasHooks to be false initially")
+	}
+
 	unregister := hr.register(HookPriorityNormal, func(input string) *string {
 		result := "should be gone"
 		return &result
@@ -137,24 +142,6 @@ func TestHookRegistry_NoHooksReturnsNil(t *testing.T) {
 	}
 }
 
-func TestHookRegistry_HasHooks(t *testing.T) {
-	hr := newHookRegistry[string, string]()
-
-	if hr.hasHooks() {
-		t.Error("expected hasHooks to be false initially")
-	}
-
-	unsub := hr.register(HookPriorityNormal, func(_ string) *string { return nil })
-	if !hr.hasHooks() {
-		t.Error("expected hasHooks to be true after registration")
-	}
-
-	unsub()
-	if hr.hasHooks() {
-		t.Error("expected hasHooks to be false after unregister")
-	}
-}
-
 func TestHookRegistry_ConcurrentAccess(t *testing.T) {
 	hr := newHookRegistry[int, int]()
 
@@ -187,7 +174,7 @@ func TestHookRegistry_ConcurrentAccess(t *testing.T) {
 // hookedTool tests
 // ---------------------------------------------------------------------------
 
-// mockAgentTool implements fantasy.AgentTool for testing.
+// mockAgentTool implements the AgentTool interface for testing.
 type mockAgentTool struct {
 	name  string
 	runFn func(ctx context.Context, call fantasy.ToolCall) (fantasy.ToolResponse, error)
@@ -206,10 +193,14 @@ func (m *mockAgentTool) Run(ctx context.Context, call fantasy.ToolCall) (fantasy
 	return fantasy.NewTextResponse("default output"), nil
 }
 
-func TestHookedTool_Passthrough(t *testing.T) {
+// newEmptyHookedTool creates a hookedTool with empty hook registries and the given mock tool.
+func newEmptyHookedTool(mock *mockAgentTool) *hookedTool {
 	before := newHookRegistry[BeforeToolCallHook, BeforeToolCallResult]()
 	after := newHookRegistry[AfterToolResultHook, AfterToolResultResult]()
+	return &hookedTool{inner: mock, beforeToolCall: before, afterToolResult: after}
+}
 
+func TestHookedTool_Passthrough(t *testing.T) {
 	mock := &mockAgentTool{
 		name: "test_tool",
 		runFn: func(_ context.Context, _ fantasy.ToolCall) (fantasy.ToolResponse, error) {
@@ -217,7 +208,7 @@ func TestHookedTool_Passthrough(t *testing.T) {
 		},
 	}
 
-	ht := &hookedTool{inner: mock, beforeToolCall: before, afterToolResult: after}
+	ht := newEmptyHookedTool(mock)
 
 	resp, err := ht.Run(context.Background(), fantasy.ToolCall{Input: "{}"})
 	if err != nil {
@@ -372,11 +363,7 @@ func TestHookedTool_HookReceivesToolInfo(t *testing.T) {
 
 func TestHookedTool_InfoDelegates(t *testing.T) {
 	mock := &mockAgentTool{name: "delegate_test"}
-	ht := &hookedTool{
-		inner:           mock,
-		beforeToolCall:  newHookRegistry[BeforeToolCallHook, BeforeToolCallResult](),
-		afterToolResult: newHookRegistry[AfterToolResultHook, AfterToolResultResult](),
-	}
+	ht := newEmptyHookedTool(mock)
 
 	if ht.Info().Name != "delegate_test" {
 		t.Errorf("expected Info() to delegate to inner tool")

pkg/kit/kit.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"log"
 	"os"
 	"path/filepath"
 	"strings"
@@ -12,6 +11,7 @@ import (
 	"time"
 
 	"charm.land/fantasy"
+	charmlog "github.com/charmbracelet/log"
 
 	"github.com/mark3labs/kit/internal/agent"
 	"github.com/mark3labs/kit/internal/config"
@@ -68,8 +68,16 @@ type Kit struct {
 	// SubscribeSubagent(). Keyed by toolCallID → *subagentListenerSet.
 	subagentListeners sync.Map
 
+	// skillCache holds skills discovered for this Kit instance.
+	// Using a per-instance cache avoids cross-contamination when multiple
+	// Kit instances exist in the same process.
+	skillCache struct {
+		skills []*skills.Skill
+		mu     sync.RWMutex
+	}
+
 	// steerCh is a buffered channel used to inject steering messages into
-	// the running agent turn via Fantasy's PrepareStep. Created fresh for
+	// the running agent turn via the LLM library's PrepareStep. Created fresh for
 	// each generate() call and set to nil when idle. Protected by steerMu.
 	steerMu       sync.Mutex
 	steerCh       chan string
@@ -128,222 +136,6 @@ func (m *Kit) GetBufferedDebugMessages() []string {
 	return m.bufferedLogger.GetMessages()
 }
 
-// SetExtensionContext configures the extension runner with the given context
-// functions. No-op if extensions are disabled.
-func (m *Kit) SetExtensionContext(ctx extensions.Context) {
-	if m.extRunner != nil {
-		m.extRunner.SetContext(ctx)
-	}
-}
-
-// GetExtensionContext returns the current extension runtime context.
-// Returns a zero Context if extensions are disabled.
-func (m *Kit) GetExtensionContext() extensions.Context {
-	if m.extRunner != nil {
-		return m.extRunner.GetContext()
-	}
-	return extensions.Context{}
-}
-
-// UpdateExtensionContextModel updates the Model field on the extension
-// context so subsequent event handlers see the new model. This is a
-// targeted update that avoids replacing the entire Context struct.
-func (m *Kit) UpdateExtensionContextModel(model string) {
-	if m.extRunner != nil {
-		ctx := m.extRunner.GetContext()
-		ctx.Model = model
-		m.extRunner.SetContext(ctx)
-	}
-}
-
-// EmitSessionStart fires the SessionStart event for extensions.
-// No-op if extensions are disabled or no handlers are registered.
-func (m *Kit) EmitSessionStart() {
-	if m.extRunner != nil && m.extRunner.HasHandlers(extensions.SessionStart) {
-		_, _ = m.extRunner.Emit(extensions.SessionStartEvent{})
-	}
-}
-
-// ExtensionCommands returns the slash commands registered by extensions.
-// Returns nil if extensions are disabled or no commands are registered.
-func (m *Kit) ExtensionCommands() []extensions.CommandDef {
-	if m.extRunner == nil {
-		return nil
-	}
-	return m.extRunner.RegisteredCommands()
-}
-
-// SetExtensionWidget places or updates a persistent extension widget.
-// Delegates to the extension runner. No-op if extensions are disabled.
-func (m *Kit) SetExtensionWidget(config extensions.WidgetConfig) {
-	if m.extRunner != nil {
-		m.extRunner.SetWidget(config)
-	}
-}
-
-// RemoveExtensionWidget removes a previously placed extension widget by ID.
-// Delegates to the extension runner. No-op if extensions are disabled.
-func (m *Kit) RemoveExtensionWidget(id string) {
-	if m.extRunner != nil {
-		m.extRunner.RemoveWidget(id)
-	}
-}
-
-// GetExtensionWidgets returns extension widgets matching the given placement.
-// Returns nil if extensions are disabled or no widgets match.
-func (m *Kit) GetExtensionWidgets(placement extensions.WidgetPlacement) []extensions.WidgetConfig {
-	if m.extRunner == nil {
-		return nil
-	}
-	return m.extRunner.GetWidgets(placement)
-}
-
-// SetExtensionHeader places or replaces the custom header from extensions.
-// Delegates to the extension runner. No-op if extensions are disabled.
-func (m *Kit) SetExtensionHeader(config extensions.HeaderFooterConfig) {
-	if m.extRunner != nil {
-		m.extRunner.SetHeader(config)
-	}
-}
-
-// RemoveExtensionHeader removes the custom extension header.
-// Delegates to the extension runner. No-op if extensions are disabled.
-func (m *Kit) RemoveExtensionHeader() {
-	if m.extRunner != nil {
-		m.extRunner.RemoveHeader()
-	}
-}
-
-// GetExtensionHeader returns the current custom header, or nil if none is set.
-// Returns nil if extensions are disabled.
-func (m *Kit) GetExtensionHeader() *extensions.HeaderFooterConfig {
-	if m.extRunner == nil {
-		return nil
-	}
-	return m.extRunner.GetHeader()
-}
-
-// SetExtensionFooter places or replaces the custom footer from extensions.
-// Delegates to the extension runner. No-op if extensions are disabled.
-func (m *Kit) SetExtensionFooter(config extensions.HeaderFooterConfig) {
-	if m.extRunner != nil {
-		m.extRunner.SetFooter(config)
-	}
-}
-
-// RemoveExtensionFooter removes the custom extension footer.
-// Delegates to the extension runner. No-op if extensions are disabled.
-func (m *Kit) RemoveExtensionFooter() {
-	if m.extRunner != nil {
-		m.extRunner.RemoveFooter()
-	}
-}
-
-// GetExtensionFooter returns the current custom footer, or nil if none is set.
-// Returns nil if extensions are disabled.
-func (m *Kit) GetExtensionFooter() *extensions.HeaderFooterConfig {
-	if m.extRunner == nil {
-		return nil
-	}
-	return m.extRunner.GetFooter()
-}
-
-// GetExtensionToolRenderer returns the custom renderer for the named tool, or
-// nil if no extension registered a renderer for it. Returns nil if extensions
-// are disabled.
-func (m *Kit) GetExtensionToolRenderer(toolName string) *extensions.ToolRenderConfig {
-	if m.extRunner == nil {
-		return nil
-	}
-	return m.extRunner.GetToolRenderer(toolName)
-}
-
-// SetExtensionEditor installs an editor interceptor from extensions.
-// Delegates to the extension runner. No-op if extensions are disabled.
-func (m *Kit) SetExtensionEditor(config extensions.EditorConfig) {
-	if m.extRunner != nil {
-		m.extRunner.SetEditor(config)
-	}
-}
-
-// ResetExtensionEditor removes the active editor interceptor from extensions.
-// Delegates to the extension runner. No-op if extensions are disabled.
-func (m *Kit) ResetExtensionEditor() {
-	if m.extRunner != nil {
-		m.extRunner.ResetEditor()
-	}
-}
-
-// GetExtensionEditor returns the current editor interceptor, or nil if none
-// is set. Returns nil if extensions are disabled.
-func (m *Kit) GetExtensionEditor() *extensions.EditorConfig {
-	if m.extRunner == nil {
-		return nil
-	}
-	return m.extRunner.GetEditor()
-}
-
-// SetExtensionUIVisibility stores extension-provided UI visibility overrides.
-// No-op if extensions are disabled.
-func (m *Kit) SetExtensionUIVisibility(v extensions.UIVisibility) {
-	if m.extRunner != nil {
-		m.extRunner.SetUIVisibility(v)
-	}
-}
-
-// GetExtensionUIVisibility returns extension-provided UI visibility overrides,
-// or nil if none have been set. Returns nil if extensions are disabled.
-func (m *Kit) GetExtensionUIVisibility() *extensions.UIVisibility {
-	if m.extRunner == nil {
-		return nil
-	}
-	return m.extRunner.GetUIVisibility()
-}
-
-// GetSessionMessages returns the conversation messages on the current branch
-// as extension-facing SessionMessage structs, ordered root to leaf.
-func (m *Kit) GetSessionMessages() []extensions.SessionMessage {
-	if m.treeSession == nil {
-		return nil
-	}
-	branch := m.treeSession.GetBranch("")
-	var msgs []extensions.SessionMessage
-	for _, entry := range branch {
-		me, ok := entry.(*session.MessageEntry)
-		if !ok {
-			continue
-		}
-		msg, err := me.ToMessage()
-		if err != nil {
-			continue
-		}
-		// Flatten content parts into a single text string.
-		var content strings.Builder
-		for _, p := range msg.Parts {
-			switch pt := p.(type) {
-			case message.TextContent:
-				content.WriteString(pt.Text)
-			case message.ReasoningContent:
-				content.WriteString(pt.Thinking)
-			case message.ToolCall:
-				fmt.Fprintf(&content, "[tool_call: %s(%s)]", pt.Name, pt.Input)
-			case message.ToolResult:
-				fmt.Fprintf(&content, "[tool_result: %s]", pt.Content)
-			}
-		}
-		msgs = append(msgs, extensions.SessionMessage{
-			ID:        me.ID,
-			ParentID:  me.ParentID,
-			Role:      string(msg.Role),
-			Content:   content.String(),
-			Model:     msg.Model,
-			Provider:  msg.Provider,
-			Timestamp: me.Timestamp.Format("2006-01-02T15:04:05Z07:00"),
-		})
-	}
-	return msgs
-}
-
 // StructuredMessage represents a conversation message with typed content parts
 // (tool calls, reasoning, finish markers, etc.) instead of flattened text.
 type StructuredMessage struct {
@@ -361,11 +153,29 @@ type StructuredMessage struct {
 // flattens all content to a single text string, this preserves tool calls,
 // tool results, reasoning blocks, and finish markers as distinct typed parts.
 func (m *Kit) GetStructuredMessages() []StructuredMessage {
-	if m.treeSession == nil {
+	return iterBranchMessages(m.treeSession, func(me *session.MessageEntry, msg message.Message) StructuredMessage {
+		return StructuredMessage{
+			ID:        me.ID,
+			ParentID:  me.ParentID,
+			Role:      msg.Role,
+			Parts:     msg.Parts,
+			Model:     msg.Model,
+			Provider:  msg.Provider,
+			Timestamp: me.Timestamp.Format("2006-01-02T15:04:05Z07:00"),
+		}
+	})
+}
+
+// iterBranchMessages iterates over the current branch's MessageEntry items,
+// converting each to a message.Message and calling fn to build the result.
+// Returns nil if there is no tree session. Skips entries that are not
+// MessageEntry or that fail conversion.
+func iterBranchMessages[T any](tm *session.TreeManager, fn func(*session.MessageEntry, message.Message) T) []T {
+	if tm == nil {
 		return nil
 	}
-	branch := m.treeSession.GetBranch("")
-	var msgs []StructuredMessage
+	branch := tm.GetBranch("")
+	var results []T
 	for _, entry := range branch {
 		me, ok := entry.(*session.MessageEntry)
 		if !ok {
@@ -375,137 +185,9 @@ func (m *Kit) GetStructuredMessages() []StructuredMessage {
 		if err != nil {
 			continue
 		}
-		msgs = append(msgs, StructuredMessage{
-			ID:        me.ID,
-			ParentID:  me.ParentID,
-			Role:      msg.Role,
-			Parts:     msg.Parts,
-			Model:     msg.Model,
-			Provider:  msg.Provider,
-			Timestamp: me.Timestamp.Format("2006-01-02T15:04:05Z07:00"),
-		})
-	}
-	return msgs
-}
-
-// GetSessionFilePath returns the JSONL file path of the current session.
-func (m *Kit) GetSessionFilePath() string {
-	if m.treeSession == nil {
-		return ""
-	}
-	return m.treeSession.GetFilePath()
-}
-
-// AppendExtensionEntry persists custom extension data in the session tree.
-func (m *Kit) AppendExtensionEntry(extType, data string) (string, error) {
-	if m.treeSession == nil {
-		return "", fmt.Errorf("no session available")
-	}
-	return m.treeSession.AppendExtensionData(extType, data)
-}
-
-// GetExtensionEntries retrieves persisted extension data entries for a type.
-func (m *Kit) GetExtensionEntries(extType string) []extensions.ExtensionEntry {
-	if m.treeSession == nil {
-		return nil
-	}
-	entries := m.treeSession.GetExtensionData(extType)
-	result := make([]extensions.ExtensionEntry, 0, len(entries))
-	for _, e := range entries {
-		result = append(result, extensions.ExtensionEntry{
-			ID:        e.ID,
-			EntryType: e.ExtType,
-			Data:      e.Data,
-			Timestamp: e.Timestamp.Format("2006-01-02T15:04:05Z07:00"),
-		})
-	}
-	return result
-}
-
-// SetExtensionStatus places or updates a keyed status bar entry.
-func (m *Kit) SetExtensionStatus(entry extensions.StatusBarEntry) {
-	if m.extRunner != nil {
-		m.extRunner.SetStatusEntry(entry)
-	}
-}
-
-// RemoveExtensionStatus removes a keyed status bar entry.
-func (m *Kit) RemoveExtensionStatus(key string) {
-	if m.extRunner != nil {
-		m.extRunner.RemoveStatusEntry(key)
-	}
-}
-
-// GetExtensionStatusEntries returns all extension status bar entries sorted by priority.
-func (m *Kit) GetExtensionStatusEntries() []extensions.StatusBarEntry {
-	if m.extRunner == nil {
-		return nil
-	}
-	return m.extRunner.GetStatusEntries()
-}
-
-// GetExtensionShortcuts returns a map of key bindings to handler functions
-// from all loaded extensions. Returns nil if no shortcuts are registered or
-// extensions are disabled. Handlers are closures that capture the runner's
-// current context, so they can call Print/SetStatus/etc.
-func (m *Kit) GetExtensionShortcuts() map[string]func() {
-	if m.extRunner == nil {
-		return nil
-	}
-	entries := m.extRunner.GetShortcuts()
-	if entries == nil {
-		return nil
-	}
-	result := make(map[string]func(), len(entries))
-	for key, entry := range entries {
-		h := entry.Handler
-		r := m.extRunner
-		result[key] = func() {
-			ctx := r.GetContext()
-			h(ctx)
-		}
-	}
-	return result
-}
-
-// GetExtensionToolInfos returns information about all tools available to the
-// agent, including enabled/disabled status from SetActiveTools. Each tool is
-// categorized by source: "core", "mcp", or "extension".
-func (m *Kit) GetExtensionToolInfos() []extensions.ToolInfo {
-	agentTools := m.agent.GetTools()
-	coreCount := m.agent.GetCoreToolCount()
-	mcpCount := m.agent.GetMCPToolCount()
-
-	result := make([]extensions.ToolInfo, 0, len(agentTools))
-	for i, t := range agentTools {
-		info := t.Info()
-		source := "core"
-		if i >= coreCount && i < coreCount+mcpCount {
-			source = "mcp"
-		} else if i >= coreCount+mcpCount {
-			source = "extension"
-		}
-		enabled := true
-		if m.extRunner != nil && m.extRunner.IsToolDisabled(info.Name) {
-			enabled = false
-		}
-		result = append(result, extensions.ToolInfo{
-			Name:        info.Name,
-			Description: info.Description,
-			Source:      source,
-			Enabled:     enabled,
-		})
-	}
-	return result
-}
-
-// SetExtensionActiveTools restricts the tool set to the named tools. All
-// other tools are blocked from execution. Pass nil to re-enable all tools.
-// No-op if extensions are disabled.
-func (m *Kit) SetExtensionActiveTools(names []string) {
-	if m.extRunner != nil {
-		m.extRunner.SetActiveTools(names)
+		results = append(results, fn(me, msg))
 	}
+	return results
 }
 
 // SetModel changes the active model at runtime. The existing tools, system
@@ -522,6 +204,10 @@ func (m *Kit) SetModel(ctx context.Context, modelString string) error {
 	// Build a provider config from current settings, overriding the model.
 	// Load system prompt properly (handles both file paths and inline content).
 	systemPrompt, _ := config.LoadSystemPrompt(viper.GetString("system-prompt"))
+	thinkingLevel := models.ParseThinkingLevel(viper.GetString("thinking-level"))
+
+	// With message-level caching, thinking and caching can work together.
+	// No need to disable caching when thinking is enabled.
 	config := &models.ProviderConfig{
 		ModelString:    modelString,
 		SystemPrompt:   systemPrompt,
@@ -529,7 +215,8 @@ func (m *Kit) SetModel(ctx context.Context, modelString string) error {
 		ProviderURL:    viper.GetString("provider-url"),
 		MaxTokens:      viper.GetInt("max-tokens"),
 		TLSSkipVerify:  viper.GetBool("tls-skip-verify"),
-		ThinkingLevel:  models.ParseThinkingLevel(viper.GetString("thinking-level")),
+		ThinkingLevel:  thinkingLevel,
+		DisableCaching: false, // Caching enabled by default, works with thinking
 	}
 	temperature := float32(viper.GetFloat64("temperature"))
 	config.Temperature = &temperature
@@ -561,7 +248,7 @@ func (m *Kit) SetModel(ctx context.Context, modelString string) error {
 func (m *Kit) GetAvailableModels() []extensions.ModelInfoEntry {
 	registry := models.GetGlobalRegistry()
 	var result []extensions.ModelInfoEntry
-	for _, providerID := range registry.GetFantasyProviders() {
+	for _, providerID := range registry.GetLLMProviders() {
 		modelsMap, err := registry.GetModelsForProvider(providerID)
 		if err != nil {
 			continue
@@ -580,50 +267,6 @@ func (m *Kit) GetAvailableModels() []extensions.ModelInfoEntry {
 	return result
 }
 
-// GetExtensionOption resolves a named extension option value.
-func (m *Kit) GetExtensionOption(name string) string {
-	if m.extRunner == nil {
-		return ""
-	}
-	return m.extRunner.GetOption(name)
-}
-
-// SetExtensionOption stores a runtime override for a named extension option.
-func (m *Kit) SetExtensionOption(name, value string) {
-	if m.extRunner != nil {
-		m.extRunner.SetOption(name, value)
-	}
-}
-
-// EmitModelChange fires the ModelChange event for extensions.
-// No-op if extensions are disabled or no handlers are registered.
-func (m *Kit) EmitModelChange(newModel, previousModel, source string) {
-	if m.extRunner != nil && m.extRunner.HasHandlers(extensions.ModelChange) {
-		_, _ = m.extRunner.Emit(extensions.ModelChangeEvent{
-			NewModel:      newModel,
-			PreviousModel: previousModel,
-			Source:        source,
-		})
-	}
-}
-
-// EmitExtensionCustomEvent dispatches a named event to all extension handlers.
-// No-op if extensions are disabled.
-func (m *Kit) EmitExtensionCustomEvent(name, data string) {
-	if m.extRunner != nil {
-		m.extRunner.EmitCustomEvent(name, data)
-	}
-}
-
-// GetExtensionMessageRenderer returns the named message renderer, or nil
-// if no extension registered a renderer with that name.
-func (m *Kit) GetExtensionMessageRenderer(name string) *extensions.MessageRendererConfig {
-	if m.extRunner == nil {
-		return nil
-	}
-	return m.extRunner.GetMessageRenderer(name)
-}
-
 // ReloadExtensions hot-reloads all extensions from disk. Event handlers,
 // commands, renderers, and shortcuts update immediately. Extension-defined
 // tools are NOT updated (they are baked into the agent at creation time).
@@ -698,7 +341,7 @@ func (m *Kit) ExecuteCompletion(ctx context.Context, req extensions.CompleteRequ
 	}
 	defer closer()
 
-	// Build fantasy agent options (no tools — just a simple completion).
+	// Build agent options (no tools — just a simple completion).
 	var agentOpts []fantasy.AgentOption
 	if req.System != "" {
 		agentOpts = append(agentOpts, fantasy.WithSystemPrompt(req.System))
@@ -712,7 +355,7 @@ func (m *Kit) ExecuteCompletion(ctx context.Context, req extensions.CompleteRequ
 
 	completionAgent := fantasy.NewAgent(llmModel, agentOpts...)
 
-	// Convert extension SessionMessage history to fantasy.Message slice.
+	// Convert extension SessionMessage history to LLM message slice.
 	var messages []fantasy.Message
 	for _, sm := range req.Messages {
 		messages = append(messages, fantasy.Message{
@@ -760,53 +403,6 @@ func (m *Kit) ExecuteCompletion(ctx context.Context, req extensions.CompleteRequ
 	}, nil
 }
 
-// EmitBeforeFork emits a BeforeFork event to extensions and returns
-// whether the fork was cancelled and the reason. No-op if extensions are
-// disabled (returns false, "").
-func (m *Kit) EmitBeforeFork(targetID string, isUserMsg bool, userText string) (cancelled bool, reason string) {
-	if m.extRunner == nil || !m.extRunner.HasHandlers(extensions.BeforeFork) {
-		return false, ""
-	}
-	result, _ := m.extRunner.Emit(extensions.BeforeForkEvent{
-		TargetID:      targetID,
-		IsUserMessage: isUserMsg,
-		UserText:      userText,
-	})
-	if r, ok := result.(extensions.BeforeForkResult); ok && r.Cancel {
-		reason := r.Reason
-		if reason == "" {
-			reason = "Fork cancelled by extension."
-		}
-		return true, reason
-	}
-	return false, ""
-}
-
-// EmitBeforeSessionSwitch emits a BeforeSessionSwitch event to extensions
-// and returns whether the switch was cancelled and the reason. No-op if
-// extensions are disabled (returns false, "").
-func (m *Kit) EmitBeforeSessionSwitch(switchReason string) (cancelled bool, reason string) {
-	if m.extRunner == nil || !m.extRunner.HasHandlers(extensions.BeforeSessionSwitch) {
-		return false, ""
-	}
-	result, _ := m.extRunner.Emit(extensions.BeforeSessionSwitchEvent{
-		Reason: switchReason,
-	})
-	if r, ok := result.(extensions.BeforeSessionSwitchResult); ok && r.Cancel {
-		reason := r.Reason
-		if reason == "" {
-			reason = "Session switch cancelled by extension."
-		}
-		return true, reason
-	}
-	return false, ""
-}
-
-// HasExtensions returns true if the extension runner is configured and active.
-func (m *Kit) HasExtensions() bool {
-	return m.extRunner != nil
-}
-
 // Options configures Kit creation with optional overrides for model,
 // prompts, configuration, and behavior settings. All fields are optional
 // and will use CLI defaults if not specified.
@@ -1049,9 +645,9 @@ func New(ctx context.Context, opts *Options) (*Kit, error) {
 		k.bridgeExtensions(agentResult.ExtRunner)
 
 		// Initialize extension context with minimal defaults. SDK users can call
-		// SetExtensionContext to override with richer implementations (TUI callbacks,
+		// Extensions().SetContext to override with richer implementations (TUI callbacks,
 		// prompts, etc.). This ensures extensions never crash on nil function fields.
-		k.SetExtensionContext(extensions.Context{
+		k.Extensions().SetContext(extensions.Context{
 			CWD:         cwd,
 			Model:       k.modelString,
 			Interactive: false, // SDK mode defaults to non-interactive
@@ -1226,16 +822,17 @@ type TurnResult struct {
 	// TotalUsage is the aggregate token usage across all steps in the turn
 	// (includes tool-calling loop iterations). Nil if the provider didn't
 	// report usage.
-	TotalUsage *FantasyUsage
+	TotalUsage *LLMUsage
 
 	// FinalUsage is the token usage from the last API call only. Use this
 	// for context window fill estimation (InputTokens + OutputTokens ≈
 	// current context size). Nil if unavailable.
-	FinalUsage *FantasyUsage
+	FinalUsage *LLMUsage
 
 	// Messages is the full updated conversation after the turn, including
 	// any tool call/result messages added during the agent loop.
-	Messages []FantasyMessage
+	// Each message carries role and plain-text content.
+	Messages []LLMMessage
 }
 
 // ---------------------------------------------------------------------------
@@ -1274,17 +871,16 @@ type SubagentConfig struct {
 }
 
 // SubagentResult contains the outcome of an in-process subagent execution.
+// Errors are returned as the error return value of Subagent(), not in this struct.
 type SubagentResult struct {
 	// Response is the subagent's final text response.
 	Response string
-	// Error is set if the subagent failed (nil on success).
-	Error error
 	// SessionID is the subagent's session identifier (for replay).
 	SessionID string
 	// StopReason is the LLM's finish reason for the subagent's final turn.
 	StopReason string
 	// Usage contains token usage from the subagent's run.
-	Usage *FantasyUsage
+	Usage *LLMUsage
 	// Elapsed is the total execution time.
 	Elapsed time.Duration
 }
@@ -1352,10 +948,7 @@ func (m *Kit) Subagent(ctx context.Context, cfg SubagentConfig) (*SubagentResult
 		childOpts.Model = m.modelString
 		child, err = New(ctx, childOpts)
 		if err != nil {
-			return &SubagentResult{
-				Error:   fmt.Errorf("failed to create subagent: %w", err),
-				Elapsed: time.Since(start),
-			}, err
+			return nil, fmt.Errorf("failed to create subagent: %w", err)
 		}
 		// Prepend a note so the agent knows which model is actually running.
 		cfg.Prompt = fmt.Sprintf(
@@ -1363,10 +956,7 @@ func (m *Kit) Subagent(ctx context.Context, cfg SubagentConfig) (*SubagentResult
 			model, m.modelString, cfg.Prompt,
 		)
 	} else if err != nil {
-		return &SubagentResult{
-			Error:   fmt.Errorf("failed to create subagent: %w", err),
-			Elapsed: time.Since(start),
-		}, err
+		return nil, fmt.Errorf("failed to create subagent: %w", err)
 	}
 	defer func() { _ = child.Close() }()
 
@@ -1380,11 +970,7 @@ func (m *Kit) Subagent(ctx context.Context, cfg SubagentConfig) (*SubagentResult
 	elapsed := time.Since(start)
 
 	if err != nil {
-		return &SubagentResult{
-			Error:     err,
-			SessionID: child.GetSessionID(),
-			Elapsed:   elapsed,
-		}, err
+		return nil, err
 	}
 
 	subResult := &SubagentResult{
@@ -1423,14 +1009,13 @@ func (m *Kit) generate(ctx context.Context, messages []fantasy.Message) (*agent.
 			case msg := <-steerCh:
 				leftover = append(leftover, msg)
 			default:
-				goto drained
+				m.steerMu.Lock()
+				m.steerCh = nil
+				m.leftoverSteer = leftover
+				m.steerMu.Unlock()
+				return
 			}
 		}
-	drained:
-		m.steerMu.Lock()
-		m.steerCh = nil
-		m.leftoverSteer = leftover
-		m.steerMu.Unlock()
 	}()
 	ctx = agent.ContextWithSteerCh(ctx, steerCh)
 	ctx = agent.ContextWithSteerConsumed(ctx, func(count int) {
@@ -1463,7 +1048,7 @@ func (m *Kit) generate(ctx context.Context, messages []fantasy.Message) (*agent.
 		}
 		sr := &core.SubagentSpawnResult{
 			Response:  result.Response,
-			Error:     result.Error,
+			Error:     err,
 			SessionID: result.SessionID,
 			Elapsed:   result.Elapsed,
 		}
@@ -1526,8 +1111,12 @@ func (m *Kit) generate(ctx context.Context, messages []fantasy.Message) (*agent.
 		func(inputTokens, outputTokens, cacheReadTokens, cacheCreationTokens int64) {
 			// Emit step usage event for real-time cost tracking
 			if viper.GetBool("debug") {
-				log.Printf("[DEBUG] Kit.generate emitting StepUsageEvent: input=%d output=%d cacheRead=%d cacheCreate=%d",
-					inputTokens, outputTokens, cacheReadTokens, cacheCreationTokens)
+				charmlog.Debug("Kit.generate emitting StepUsageEvent",
+					"input", inputTokens,
+					"output", outputTokens,
+					"cacheRead", cacheReadTokens,
+					"cacheCreate", cacheCreationTokens,
+				)
 			}
 			m.events.emit(StepUsageEvent{
 				InputTokens:      uint64(inputTokens),
@@ -1568,36 +1157,34 @@ func (m *Kit) runTurn(ctx context.Context, promptLabel string, prompt string, pr
 	}
 
 	// Run BeforeTurn hooks — can modify the prompt, inject system/context messages.
-	if m.beforeTurn.hasHooks() {
-		if hookResult := m.beforeTurn.run(BeforeTurnHook{Prompt: prompt}); hookResult != nil {
-			// Override prompt text in the last user message, preserving
-			// any file parts (e.g. clipboard images).
-			if hookResult.Prompt != nil {
-				for i := len(preMessages) - 1; i >= 0; i-- {
-					if preMessages[i].Role == fantasy.MessageRoleUser {
-						files := extractFileParts(preMessages[i])
-						preMessages[i] = fantasy.NewUserMessage(*hookResult.Prompt, files...)
-						break
-					}
+	if hookResult := m.beforeTurn.run(BeforeTurnHook{Prompt: prompt}); hookResult != nil {
+		// Override prompt text in the last user message, preserving
+		// any file parts (e.g. clipboard images).
+		if hookResult.Prompt != nil {
+			for i := len(preMessages) - 1; i >= 0; i-- {
+				if preMessages[i].Role == fantasy.MessageRoleUser {
+					files := extractFileParts(preMessages[i])
+					preMessages[i] = fantasy.NewUserMessage(*hookResult.Prompt, files...)
+					break
 				}
 			}
-			// Inject messages before the original preMessages.
-			var injected []fantasy.Message
-			if hookResult.SystemPrompt != nil {
-				injected = append(injected, fantasy.NewSystemMessage(*hookResult.SystemPrompt))
-			}
-			if hookResult.InjectText != nil {
-				injected = append(injected, fantasy.NewUserMessage(*hookResult.InjectText))
-			}
-			if len(injected) > 0 {
-				preMessages = append(injected, preMessages...)
-			}
+		}
+		// Inject messages before the original preMessages.
+		var injected []fantasy.Message
+		if hookResult.SystemPrompt != nil {
+			injected = append(injected, fantasy.NewSystemMessage(*hookResult.SystemPrompt))
+		}
+		if hookResult.InjectText != nil {
+			injected = append(injected, fantasy.NewUserMessage(*hookResult.InjectText))
+		}
+		if len(injected) > 0 {
+			preMessages = append(injected, preMessages...)
 		}
 	}
 
 	// Persist pre-generation messages to tree session.
 	for _, msg := range preMessages {
-		_, _ = m.treeSession.AppendFantasyMessage(msg)
+		_, _ = m.treeSession.AppendLLMMessage(msg)
 	}
 
 	// Auto-compact if enabled and conversation is near the context limit.
@@ -1606,13 +1193,11 @@ func (m *Kit) runTurn(ctx context.Context, promptLabel string, prompt string, pr
 	}
 
 	// Build context from the tree so only the current branch is sent.
-	messages := m.treeSession.GetFantasyMessages()
+	messages := m.treeSession.GetLLMMessages()
 
 	// Run ContextPrepare hooks — extensions can filter, reorder, or inject messages.
-	if m.contextPrepare.hasHooks() {
-		if hookResult := m.contextPrepare.run(ContextPrepareHook{Messages: messages}); hookResult != nil && hookResult.Messages != nil {
-			messages = hookResult.Messages
-		}
+	if hookResult := m.contextPrepare.run(ContextPrepareHook{Messages: messages}); hookResult != nil && hookResult.Messages != nil {
+		messages = hookResult.Messages
 	}
 
 	sentCount := len(messages)
@@ -1631,14 +1216,12 @@ func (m *Kit) runTurn(ctx context.Context, promptLabel string, prompt string, pr
 		// (pending) message or tool call is discarded.
 		if result != nil && len(result.ConversationMessages) > sentCount {
 			for _, msg := range result.ConversationMessages[sentCount:] {
-				_, _ = m.treeSession.AppendFantasyMessage(msg)
+				_, _ = m.treeSession.AppendLLMMessage(msg)
 			}
 		}
 		m.events.emit(TurnEndEvent{Error: err})
 		// Run AfterTurn hooks even on error.
-		if m.afterTurn.hasHooks() {
-			m.afterTurn.run(AfterTurnHook{Error: err})
-		}
+		m.afterTurn.run(AfterTurnHook{Error: err})
 		return nil, err
 	}
 
@@ -1649,7 +1232,7 @@ func (m *Kit) runTurn(ctx context.Context, promptLabel string, prompt string, pr
 	// GetContextStats() see up-to-date token counts.
 	if len(result.ConversationMessages) > sentCount {
 		for _, msg := range result.ConversationMessages[sentCount:] {
-			_, _ = m.treeSession.AppendFantasyMessage(msg)
+			_, _ = m.treeSession.AppendLLMMessage(msg)
 		}
 	}
 
@@ -1669,9 +1252,7 @@ func (m *Kit) runTurn(ctx context.Context, promptLabel string, prompt string, pr
 	m.events.emit(TurnEndEvent{Response: responseText, StopReason: stopReason})
 
 	// Run AfterTurn hooks.
-	if m.afterTurn.hasHooks() {
-		m.afterTurn.run(AfterTurnHook{Response: responseText})
-	}
+	m.afterTurn.run(AfterTurnHook{Response: responseText})
 
 	// Build TurnResult with usage stats.
 	turnResult := &TurnResult{
@@ -1733,7 +1314,7 @@ func (m *Kit) Steer(ctx context.Context, instruction string) (string, error) {
 // Returns an error if there are no previous messages in the session.
 func (m *Kit) FollowUp(ctx context.Context, text string) (string, error) {
 	// Verify there is conversation history to follow up on.
-	if len(m.treeSession.GetFantasyMessages()) == 0 {
+	if len(m.treeSession.GetLLMMessages()) == 0 {
 		return "", fmt.Errorf("cannot follow up: no previous messages")
 	}
 
@@ -1852,7 +1433,7 @@ func (m *Kit) PromptResult(ctx context.Context, message string) (*TurnResult, er
 // PromptResultWithFiles sends a multimodal message (text + images) and returns
 // the full turn result. The files parameter carries binary file data (e.g.
 // clipboard images) that are included alongside the text in the user message.
-func (m *Kit) PromptResultWithFiles(ctx context.Context, message string, files []fantasy.FilePart) (*TurnResult, error) {
+func (m *Kit) PromptResultWithFiles(ctx context.Context, message string, files []LLMFilePart) (*TurnResult, error) {
 	return m.runTurn(ctx, message, message, []fantasy.Message{
 		fantasy.NewUserMessage(message, files...),
 	})
@@ -1873,7 +1454,7 @@ func (m *Kit) PromptResultWithMessages(ctx context.Context, messages []string) (
 		promptLabel = promptLabel[:100] + "..."
 	}
 
-	// Build fantasy messages from all strings
+	// Build LLM messages from all strings
 	var preMessages []fantasy.Message
 	for _, msg := range messages {
 		preMessages = append(preMessages, fantasy.NewUserMessage(msg))
@@ -1918,6 +1499,9 @@ func (m *Kit) GetThinkingLevel() string {
 
 // SetThinkingLevel changes the thinking level and recreates the agent with
 // the new thinking budget. Returns an error if provider recreation fails.
+//
+// With message-level caching, both thinking and caching work together.
+// Caching reduces costs by 60-90% for repeated context.
 func (m *Kit) SetThinkingLevel(ctx context.Context, level string) error {
 	viper.Set("thinking-level", level)
 	// Recreate agent with new thinking config by re-running SetModel

pkg/kit/models.go

@@ -16,10 +16,15 @@ func GetSupportedProviders() []string {
 	return models.GetGlobalRegistry().GetSupportedProviders()
 }
 
-// GetFantasyProviders returns provider IDs that can be used with fantasy,
+// GetLLMProviders returns provider IDs that have LLM support,
 // either through a native provider or via openaicompat auto-routing.
+func GetLLMProviders() []string {
+	return models.GetGlobalRegistry().GetLLMProviders()
+}
+
+// Deprecated: Use GetLLMProviders instead.
 func GetFantasyProviders() []string {
-	return models.GetGlobalRegistry().GetFantasyProviders()
+	return GetLLMProviders()
 }
 
 // GetModelsForProvider returns all known models for a provider.

pkg/kit/sessions.go

@@ -134,29 +134,27 @@ func (m *Kit) GetChildren(parentID string) []string {
 }
 
 // NavigateTo branches/forks the session to the specified entry ID.
-// Returns error description or empty string for success.
-func (m *Kit) NavigateTo(entryID string) string {
+// Returns an error if the session is unavailable or the entry ID is not found.
+func (m *Kit) NavigateTo(entryID string) error {
 	if m.treeSession == nil {
-		return "no tree session available"
+		return fmt.Errorf("no tree session available")
 	}
-	if err := m.treeSession.Branch(entryID); err != nil {
-		return err.Error()
-	}
-	return ""
+	return m.treeSession.Branch(entryID)
 }
 
-// SummarizeBranch uses LLM to summarize a branch range.
-// Returns summary text or error string.
-func (m *Kit) SummarizeBranch(fromID, toID string) string {
+// SummarizeBranch uses the LLM to summarize the conversation between two
+// entry IDs. Returns the summary text, or an error if the range is invalid,
+// the session is unavailable, or the LLM call fails.
+func (m *Kit) SummarizeBranch(fromID, toID string) (string, error) {
 	if m.treeSession == nil {
-		return ""
+		return "", fmt.Errorf("no tree session available")
 	}
 
 	// Get the branch and find the range
 	branch := m.treeSession.GetBranch("")
 	var startIdx, endIdx = -1, -1
 	for i, entry := range branch {
-		id := m.getEntryID(entry)
+		id := m.treeSession.EntryID(entry)
 		if id == fromID {
 			startIdx = i
 		}
@@ -166,7 +164,7 @@ func (m *Kit) SummarizeBranch(fromID, toID string) string {
 	}
 
 	if startIdx < 0 || endIdx < 0 || startIdx > endIdx {
-		return ""
+		return "", fmt.Errorf("entry IDs not found or out of order in current branch")
 	}
 
 	// Build text to summarize
@@ -179,7 +177,7 @@ func (m *Kit) SummarizeBranch(fromID, toID string) string {
 	}
 
 	if content.Len() == 0 {
-		return ""
+		return "", fmt.Errorf("no content found in the specified range")
 	}
 
 	// Use LLM to summarize
@@ -189,22 +187,19 @@ func (m *Kit) SummarizeBranch(fromID, toID string) string {
 		Prompt: content.String(),
 	})
 	if err != nil {
-		return ""
+		return "", fmt.Errorf("summarization failed: %w", err)
 	}
-	return resp.Text
+	return resp.Text, nil
 }
 
 // CollapseBranch replaces a branch range with a summary entry.
-// Returns error description or empty string for success.
-func (m *Kit) CollapseBranch(fromID, toID, summary string) string {
+// Returns an error if the session is unavailable or the operation fails.
+func (m *Kit) CollapseBranch(fromID, toID, summary string) error {
 	if m.treeSession == nil {
-		return "no tree session available"
+		return fmt.Errorf("no tree session available")
 	}
 	_, err := m.treeSession.AppendBranchSummary(fromID, summary)
-	if err != nil {
-		return err.Error()
-	}
-	return ""
+	return err
 }
 
 // entryToTreeNode converts a session entry to a TreeNode.
@@ -273,22 +268,6 @@ func (m *Kit) entryToTreeNode(entry any) *TreeNode {
 	}
 }
 
-// getEntryID extracts the ID from a session entry.
-func (m *Kit) getEntryID(entry any) string {
-	switch e := entry.(type) {
-	case *session.MessageEntry:
-		return e.ID
-	case *session.BranchSummaryEntry:
-		return e.ID
-	case *session.ModelChangeEntry:
-		return e.ID
-	case *session.ExtensionDataEntry:
-		return e.ID
-	default:
-		return ""
-	}
-}
-
 // TreeNode represents a node in the session tree for SDK consumers.
 type TreeNode struct {
 	ID        string

pkg/kit/skills.go

@@ -2,7 +2,6 @@ package kit
 
 import (
 	"os"
-	"sync"
 
 	"github.com/mark3labs/kit/internal/extensions"
 	"github.com/mark3labs/kit/internal/skills"
@@ -78,35 +77,18 @@ func NewPromptBuilder(basePrompt string) *PromptBuilder {
 // Skill Bridge for Extensions (Phase 2)
 // ---------------------------------------------------------------------------
 
-// skillCache holds skills discovered for the current session.
-type skillCache struct {
-	skills []*Skill
-	mu     sync.RWMutex
-}
-
-var globalSkillCache skillCache
-
 // DiscoverSkillsForExtension finds skills in standard locations for extensions.
-// Returns skills in the extension-facing format.
+// Returns skills in the extension-facing format. Results are cached per-Kit
+// instance to avoid reloading on every call.
 func (m *Kit) DiscoverSkillsForExtension() []extensions.Skill {
 	cwd, _ := os.Getwd()
 
-	// Check cache first
-	globalSkillCache.mu.RLock()
-	if len(globalSkillCache.skills) > 0 {
-		globalSkillCache.mu.RUnlock()
-		return m.convertSkills(globalSkillCache.skills)
+	m.skillCache.mu.Lock()
+	defer m.skillCache.mu.Unlock()
+	if len(m.skillCache.skills) == 0 {
+		m.skillCache.skills, _ = skills.LoadSkills(cwd)
 	}
-	globalSkillCache.mu.RUnlock()
-
-	// Load fresh
-	skillList, _ := skills.LoadSkills(cwd)
-
-	globalSkillCache.mu.Lock()
-	globalSkillCache.skills = skillList
-	globalSkillCache.mu.Unlock()
-
-	return m.convertSkills(skillList)
+	return m.convertSkills(m.skillCache.skills)
 }
 
 // LoadSkillForExtension loads a single skill file for extensions.
@@ -140,19 +122,17 @@ func (m *Kit) convertSkill(s *skills.Skill) *extensions.Skill {
 }
 
 // convertSkills converts a slice of skills.
-func (m *Kit) convertSkills(skills []*skills.Skill) []extensions.Skill {
-	result := make([]extensions.Skill, 0, len(skills))
-	for _, s := range skills {
-		if converted := m.convertSkill(s); converted != nil {
-			result = append(result, *converted)
-		}
+func (m *Kit) convertSkills(skillList []*skills.Skill) []extensions.Skill {
+	result := make([]extensions.Skill, 0, len(skillList))
+	for _, s := range skillList {
+		result = append(result, *m.convertSkill(s))
 	}
 	return result
 }
 
-// ClearSkillCache clears the global skill cache (called on reload).
+// ClearSkillCache clears the skill cache for this Kit instance.
 func (m *Kit) ClearSkillCache() {
-	globalSkillCache.mu.Lock()
-	globalSkillCache.skills = nil
-	globalSkillCache.mu.Unlock()
+	m.skillCache.mu.Lock()
+	defer m.skillCache.mu.Unlock()
+	m.skillCache.skills = nil
 }

pkg/kit/template_bridge.go

@@ -3,6 +3,7 @@ package kit
 import (
 	"regexp"
 	"strings"
+	"sync"
 
 	"github.com/mark3labs/kit/internal/extensions"
 	"github.com/mark3labs/kit/internal/models"
@@ -34,16 +35,17 @@ func ParseTemplate(name, content string) extensions.PromptTemplate {
 }
 
 // RenderTemplate substitutes variables into template content.
+// Handles {{name}} and {{ name }} (any whitespace) placeholders.
 func RenderTemplate(tpl extensions.PromptTemplate, vars map[string]string) string {
-	result := tpl.Content
-	for name, value := range vars {
-		placeholder := "{{" + name + "}}"
-		result = strings.ReplaceAll(result, placeholder, value)
-		// Also handle with spaces
-		placeholderSpaced := "{{ " + name + " }}"
-		result = strings.ReplaceAll(result, placeholderSpaced, value)
-	}
-	return result
+	return varRegex.ReplaceAllStringFunc(tpl.Content, func(m string) string {
+		sub := varRegex.FindStringSubmatch(m)
+		if len(sub) > 1 {
+			if v, ok := vars[sub[1]]; ok {
+				return v
+			}
+		}
+		return m
+	})
 }
 
 // ParseArguments parses command-line style arguments.
@@ -58,13 +60,10 @@ func ParseArguments(input string, pattern extensions.ArgumentPattern) extensions
 		return result
 	}
 
-	// First field is the command itself (if present)
+	// First field is the command itself (if present); skip it.
 	startIdx := 0
 	if len(fields) > 0 && !strings.HasPrefix(fields[0], "-") {
-		// Check if it's a command name or positional arg
-		if len(pattern.Positional) == 0 || !isFlag(fields[0], pattern.Flags) {
-			startIdx = 1 // Skip command name
-		}
+		startIdx = 1
 	}
 
 	// Parse flags
@@ -166,7 +165,7 @@ func SimpleParseArguments(input string, count int) []string {
 	result = append(result, input) // [0] = full input
 
 	// [1]..[count] = positional args
-	for i := 0; i < count; i++ {
+	for i := range count {
 		if i < len(fields) {
 			result = append(result, fields[i])
 		} else {
@@ -224,22 +223,11 @@ func parseFields(input string) []string {
 	return fields
 }
 
-// isFlag checks if a field is a known flag.
-func isFlag(field string, flags map[string]string) bool {
-	if strings.HasPrefix(field, "--") {
-		return true
-	}
-	if strings.HasPrefix(field, "-") && len(field) > 1 {
-		return true
-	}
-	return false
-}
-
 // EvaluateModelConditional checks if condition matches current model.
 // Condition supports wildcards: * matches any, ? matches single char.
 func EvaluateModelConditional(currentModel, condition string) bool {
 	// Handle comma-separated conditions (OR logic)
-	for _, c := range strings.Split(condition, ",") {
+	for c := range strings.SplitSeq(condition, ",") {
 		c = strings.TrimSpace(c)
 		if matchModelPattern(currentModel, c) {
 			return true
@@ -248,17 +236,24 @@ func EvaluateModelConditional(currentModel, condition string) bool {
 	return false
 }
 
-// matchModelPattern matches a model against a pattern with wildcards.
-func matchModelPattern(model, pattern string) bool {
-	// Convert pattern to regexp
-	pattern = strings.ReplaceAll(pattern, "*", ".*")
-	pattern = strings.ReplaceAll(pattern, "?", ".")
-	pattern = "^" + pattern + "$"
+// modelPatternCache caches compiled regexps for model glob patterns.
+var modelPatternCache sync.Map
 
-	re, err := regexp.Compile(pattern)
-	if err != nil {
-		// Fallback: exact match
-		return model == pattern
+// matchModelPattern matches a model against a pattern with wildcards.
+// Compiled regexps are cached to avoid recompilation on hot paths.
+func matchModelPattern(model, pattern string) bool {
+	rePattern := "^" + strings.ReplaceAll(strings.ReplaceAll(pattern, "*", ".*"), "?", ".") + "$"
+	var re *regexp.Regexp
+	if v, ok := modelPatternCache.Load(rePattern); ok {
+		re = v.(*regexp.Regexp)
+	} else {
+		compiled, err := regexp.Compile(rePattern)
+		if err != nil {
+			// Fallback: exact match
+			return model == pattern
+		}
+		modelPatternCache.Store(rePattern, compiled)
+		re = compiled
 	}
 	return re.MatchString(model)
 }

pkg/kit/types.go

@@ -1,6 +1,8 @@
 package kit
 
 import (
+	"context"
+
 	"charm.land/fantasy"
 
 	"github.com/mark3labs/kit/internal/agent"
@@ -76,10 +78,6 @@ type MCPServerConfig = config.MCPServerConfig
 // AgentConfig holds configuration options for creating a new Agent.
 type AgentConfig = agent.AgentConfig
 
-// GenerateResult contains the result and conversation history from an agent
-// interaction.
-type GenerateResult = agent.GenerateWithLoopResult
-
 type (
 	// ToolCallHandler is a function type for handling tool calls as they happen.
 	ToolCallHandler = agent.ToolCallHandler
@@ -128,18 +126,75 @@ type ModelsRegistry = models.ModelsRegistry
 // Ollama model loading. Signature: func(fn func() error) error.
 type SpinnerFunc = agent.SpinnerFunc
 
-// ==== Fantasy Types (re-exported) ====
+// ==== LLM Types ====
+//
+// These are type aliases for the corresponding charm.land/fantasy types,
+// giving them clean LLM-prefixed names without leaking the dependency name.
+// SDK consumers can use these types without importing charm.land/fantasy directly.
 
-// FantasyMessage is the underlying message type used by the fantasy agent
-// library. Re-exported so SDK users can work with fantasy types without a
-// direct import of charm.land/fantasy.
-type FantasyMessage = fantasy.Message
+// LLMMessage represents a message in an LLM conversation, carrying a role
+// and a slice of typed content parts (text, tool calls, reasoning, etc.).
+type LLMMessage = fantasy.Message
 
-// FantasyUsage contains token usage information from an LLM response.
-type FantasyUsage = fantasy.Usage
+// LLMMessagePart is the interface implemented by all LLM message content parts.
+type LLMMessagePart = fantasy.MessagePart
 
-// FantasyResponse is the response type returned by the fantasy agent library.
-type FantasyResponse = fantasy.Response
+// LLMFilePart represents a file attachment (image, document, audio, etc.)
+// that can be included in a multimodal prompt via PromptResultWithFiles.
+type LLMFilePart = fantasy.FilePart
+
+// LLMUsage contains token usage information returned by the LLM provider.
+type LLMUsage = fantasy.Usage
+
+// LLMResponse represents a complete response from the LLM provider.
+type LLMResponse = fantasy.Response
+
+// LLMTextPart is a plain-text content part for constructing LLM messages.
+type LLMTextPart = fantasy.TextPart
+
+// LLMReasoningPart is a reasoning/chain-of-thought content part.
+type LLMReasoningPart = fantasy.ReasoningPart
+
+// LLMToolCallPart represents an LLM-initiated tool invocation within a message.
+type LLMToolCallPart = fantasy.ToolCallPart
+
+// LLMToolResultPart represents the result of a tool execution within a message.
+type LLMToolResultPart = fantasy.ToolResultPart
+
+// LLMToolResultOutputContent is the interface for tool result output content.
+type LLMToolResultOutputContent = fantasy.ToolResultOutputContent
+
+// LLMToolResultOutputContentText is a text-valued tool result output.
+type LLMToolResultOutputContentText = fantasy.ToolResultOutputContentText
+
+// LLMToolResultOutputContentError is an error-valued tool result output.
+type LLMToolResultOutputContentError = fantasy.ToolResultOutputContentError
+
+// LLMMessageRole identifies the participant role in an LLM conversation.
+type LLMMessageRole = fantasy.MessageRole
+
+// LLMFinishReason indicates why the LLM stopped generating.
+type LLMFinishReason = fantasy.FinishReason
+
+// LLM role constants mirror fantasy.MessageRole* values under clean LLM-prefixed names.
+const (
+	// LLMRoleUser identifies a user message.
+	LLMRoleUser = fantasy.MessageRoleUser
+	// LLMRoleAssistant identifies an assistant message.
+	LLMRoleAssistant = fantasy.MessageRoleAssistant
+	// LLMRoleSystem identifies a system message.
+	LLMRoleSystem = fantasy.MessageRoleSystem
+	// LLMRoleTool identifies a tool result message.
+	LLMRoleTool = fantasy.MessageRoleTool
+)
+
+// NewLLMUserMessage constructs a user-role LLMMessage with optional file
+// attachments. It is equivalent to fantasy.NewUserMessage.
+var NewLLMUserMessage = fantasy.NewUserMessage
+
+// NewLLMSystemMessage constructs a system-role LLMMessage from one or more
+// prompt strings. It is equivalent to fantasy.NewSystemMessage.
+var NewLLMSystemMessage = fantasy.NewSystemMessage
 
 // ==== Compaction Types (internal/compaction/) ====
 
@@ -151,27 +206,37 @@ type CompactionOptions = compaction.CompactionOptions
 
 // ==== Constructor & Helper Functions ====
 
-var (
-	// ParseModelString parses a model string in "provider/model" format.
-	ParseModelString = models.ParseModelString
-	// CreateProvider creates a fantasy LanguageModel based on provider config.
-	CreateProvider = models.CreateProvider
-	// GetGlobalRegistry returns the global models registry instance.
-	GetGlobalRegistry = models.GetGlobalRegistry
-	// LoadSystemPrompt loads system prompt from file or returns string directly.
-	LoadSystemPrompt = config.LoadSystemPrompt
-)
+// ParseModelString parses a model string in "provider/model" format.
+// Returns provider, modelID, and an error if the format is invalid.
+func ParseModelString(model string) (provider, modelID string, err error) {
+	return models.ParseModelString(model)
+}
+
+// CreateProvider creates a LanguageModel based on provider config.
+func CreateProvider(ctx context.Context, cfg *ProviderConfig) (*ProviderResult, error) {
+	return models.CreateProvider(ctx, cfg)
+}
+
+// GetGlobalRegistry returns the global models registry instance.
+func GetGlobalRegistry() *ModelsRegistry {
+	return models.GetGlobalRegistry()
+}
+
+// LoadSystemPrompt loads a system prompt from a file path, or returns the
+// string directly if it is not a valid file path.
+func LoadSystemPrompt(pathOrContent string) (string, error) {
+	return config.LoadSystemPrompt(pathOrContent)
+}
 
 // ==== Conversion Helpers ====
 
-// ConvertToFantasyMessages converts an SDK message to the underlying fantasy
-// messages used by the agent for LLM interactions.
-func ConvertToFantasyMessages(msg *Message) []fantasy.Message {
-	return msg.ToFantasyMessages()
+// ConvertToLLMMessages converts an SDK message to a slice of LLMMessages.
+// Each SDK message may expand to multiple LLM messages depending on its content.
+func ConvertToLLMMessages(msg *Message) []LLMMessage {
+	return msg.ToLLMMessages()
 }
 
-// ConvertFromFantasyMessage converts a fantasy message from the agent to an SDK
-// message format for use in the SDK API.
-func ConvertFromFantasyMessage(msg fantasy.Message) Message {
-	return message.FromFantasyMessage(msg)
+// ConvertFromLLMMessage converts an LLMMessage to an SDK message.
+func ConvertFromLLMMessage(msg LLMMessage) Message {
+	return message.FromLLMMessage(msg)
 }

pkg/kit/types_test.go

@@ -1,6 +1,7 @@
 package kit_test
 
 import (
+	"encoding/json"
 	"testing"
 
 	kit "github.com/mark3labs/kit/pkg/kit"
@@ -49,13 +50,228 @@ func TestTypeExports(t *testing.T) {
 		Role:  kit.RoleUser,
 		Parts: []kit.ContentPart{kit.TextContent{Text: "test"}},
 	}
-	fantasyMsgs := kit.ConvertToFantasyMessages(&userMsg)
-	if len(fantasyMsgs) == 0 {
-		t.Error("ConvertToFantasyMessages returned empty slice")
+	llmMsgs := kit.ConvertToLLMMessages(&userMsg)
+	if len(llmMsgs) == 0 {
+		t.Error("ConvertToLLMMessages returned empty slice")
 	}
 
-	roundTrip := kit.ConvertFromFantasyMessage(fantasyMsgs[0])
+	roundTrip := kit.ConvertFromLLMMessage(llmMsgs[0])
 	if roundTrip.Content() != "test" {
 		t.Errorf("round-trip Content() = %q, want %q", roundTrip.Content(), "test")
 	}
 }
+
+// TestLLMRoleConstants verifies the LLM role constants have the correct values.
+func TestLLMRoleConstants(t *testing.T) {
+	if kit.LLMRoleUser != "user" {
+		t.Errorf("LLMRoleUser = %q, want %q", kit.LLMRoleUser, "user")
+	}
+	if kit.LLMRoleAssistant != "assistant" {
+		t.Errorf("LLMRoleAssistant = %q, want %q", kit.LLMRoleAssistant, "assistant")
+	}
+	if kit.LLMRoleSystem != "system" {
+		t.Errorf("LLMRoleSystem = %q, want %q", kit.LLMRoleSystem, "system")
+	}
+	if kit.LLMRoleTool != "tool" {
+		t.Errorf("LLMRoleTool = %q, want %q", kit.LLMRoleTool, "tool")
+	}
+}
+
+// TestLLMMessageAlias verifies LLMMessage is a type alias for fantasy.Message
+// and can be used interchangeably.
+func TestLLMMessageAlias(t *testing.T) {
+	// Construct an LLMMessage using alias types.
+	msg := kit.LLMMessage{
+		Role: kit.LLMRoleUser,
+		Content: []kit.LLMMessagePart{
+			kit.LLMTextPart{Text: "hello world"},
+		},
+	}
+	if msg.Role != "user" {
+		t.Errorf("LLMMessage.Role = %q, want %q", msg.Role, "user")
+	}
+	// Verify we can extract text via the part types.
+	if len(msg.Content) != 1 {
+		t.Fatalf("expected 1 content part, got %d", len(msg.Content))
+	}
+	tp, ok := msg.Content[0].(kit.LLMTextPart)
+	if !ok {
+		t.Fatal("content part is not LLMTextPart")
+	}
+	if tp.Text != "hello world" {
+		t.Errorf("LLMTextPart.Text = %q, want %q", tp.Text, "hello world")
+	}
+}
+
+// TestNewLLMUserMessage verifies the NewLLMUserMessage constructor works.
+func TestNewLLMUserMessage(t *testing.T) {
+	msg := kit.NewLLMUserMessage("hello from user")
+	if msg.Role != kit.LLMRoleUser {
+		t.Errorf("NewLLMUserMessage role = %q, want %q", msg.Role, kit.LLMRoleUser)
+	}
+	if len(msg.Content) == 0 {
+		t.Fatal("NewLLMUserMessage content is empty")
+	}
+	tp, ok := msg.Content[0].(kit.LLMTextPart)
+	if !ok {
+		t.Fatal("content[0] is not LLMTextPart")
+	}
+	if tp.Text != "hello from user" {
+		t.Errorf("NewLLMUserMessage text = %q, want %q", tp.Text, "hello from user")
+	}
+}
+
+// TestNewLLMSystemMessage verifies the NewLLMSystemMessage constructor works.
+func TestNewLLMSystemMessage(t *testing.T) {
+	msg := kit.NewLLMSystemMessage("you are helpful")
+	if msg.Role != kit.LLMRoleSystem {
+		t.Errorf("NewLLMSystemMessage role = %q, want %q", msg.Role, kit.LLMRoleSystem)
+	}
+	if len(msg.Content) == 0 {
+		t.Fatal("NewLLMSystemMessage content is empty")
+	}
+}
+
+// TestLLMUsageAlias verifies LLMUsage is a type alias for fantasy.Usage
+// and carries the correct fields.
+func TestLLMUsageAlias(t *testing.T) {
+	u := kit.LLMUsage{
+		InputTokens:         100,
+		OutputTokens:        50,
+		TotalTokens:         150,
+		ReasoningTokens:     10,
+		CacheCreationTokens: 5,
+		CacheReadTokens:     20,
+	}
+	if u.InputTokens != 100 {
+		t.Errorf("LLMUsage.InputTokens = %d, want 100", u.InputTokens)
+	}
+	if u.TotalTokens != 150 {
+		t.Errorf("LLMUsage.TotalTokens = %d, want 150", u.TotalTokens)
+	}
+
+	// Verify JSON marshaling uses snake_case (inherited from fantasy.Usage tags).
+	data, err := json.Marshal(u)
+	if err != nil {
+		t.Fatalf("LLMUsage.MarshalJSON: %v", err)
+	}
+	jsonStr := string(data)
+	if jsonStr == "" {
+		t.Error("LLMUsage JSON is empty")
+	}
+	// Check that input_tokens key is present.
+	if !containsStr(jsonStr, `"input_tokens":100`) {
+		t.Errorf("LLMUsage JSON missing input_tokens: %s", jsonStr)
+	}
+}
+
+// TestLLMFilePartAlias verifies LLMFilePart is a type alias for fantasy.FilePart.
+func TestLLMFilePartAlias(t *testing.T) {
+	fp := kit.LLMFilePart{
+		Filename:  "screenshot.png",
+		Data:      []byte{0x89, 0x50, 0x4E, 0x47},
+		MediaType: "image/png",
+	}
+	if fp.Filename != "screenshot.png" {
+		t.Errorf("LLMFilePart.Filename = %q, want %q", fp.Filename, "screenshot.png")
+	}
+	if fp.MediaType != "image/png" {
+		t.Errorf("LLMFilePart.MediaType = %q, want %q", fp.MediaType, "image/png")
+	}
+	if len(fp.Data) != 4 {
+		t.Errorf("LLMFilePart.Data len = %d, want 4", len(fp.Data))
+	}
+
+	// Verify it can be used as a file part for constructing user messages.
+	msg := kit.NewLLMUserMessage("see this image", fp)
+	if msg.Role != kit.LLMRoleUser {
+		t.Errorf("message role = %q, want user", msg.Role)
+	}
+}
+
+// TestLLMPartTypesAlias verifies all the part type aliases compile and work.
+func TestLLMPartTypesAlias(t *testing.T) {
+	// LLMTextPart
+	tp := kit.LLMTextPart{Text: "plain text"}
+	if tp.Text != "plain text" {
+		t.Errorf("LLMTextPart.Text = %q", tp.Text)
+	}
+
+	// LLMReasoningPart
+	rp := kit.LLMReasoningPart{Text: "I think therefore"}
+	if rp.Text != "I think therefore" {
+		t.Errorf("LLMReasoningPart.Text = %q", rp.Text)
+	}
+
+	// LLMToolCallPart
+	tc := kit.LLMToolCallPart{
+		ToolCallID: "call-1",
+		ToolName:   "bash",
+		Input:      `{"cmd":"echo hi"}`,
+	}
+	if tc.ToolCallID != "call-1" {
+		t.Errorf("LLMToolCallPart.ToolCallID = %q", tc.ToolCallID)
+	}
+
+	// LLMToolResultPart
+	tro := kit.LLMToolResultOutputContentText{Text: "output text"}
+	tr := kit.LLMToolResultPart{
+		ToolCallID: "call-1",
+		Output:     tro,
+	}
+	if tr.ToolCallID != "call-1" {
+		t.Errorf("LLMToolResultPart.ToolCallID = %q", tr.ToolCallID)
+	}
+}
+
+// TestConvertToLLMMessages verifies round-trip conversion preserves content.
+func TestConvertToLLMMessages(t *testing.T) {
+	msg := kit.Message{
+		Role:  kit.RoleUser,
+		Parts: []kit.ContentPart{kit.TextContent{Text: "what is 2+2?"}},
+	}
+	llmMsgs := kit.ConvertToLLMMessages(&msg)
+	if len(llmMsgs) == 0 {
+		t.Fatal("ConvertToLLMMessages returned empty slice")
+	}
+	if llmMsgs[0].Role != kit.LLMRoleUser {
+		t.Errorf("converted Role = %q, want %q", llmMsgs[0].Role, kit.LLMRoleUser)
+	}
+	// Check text is preserved in content parts.
+	found := false
+	for _, part := range llmMsgs[0].Content {
+		if tp, ok := part.(kit.LLMTextPart); ok && tp.Text == "what is 2+2?" {
+			found = true
+		}
+	}
+	if !found {
+		t.Errorf("text content not found in converted LLMMessage")
+	}
+}
+
+// TestConvertFromLLMMessage verifies LLMMessage → Message conversion.
+func TestConvertFromLLMMessage(t *testing.T) {
+	llm := kit.NewLLMUserMessage("the answer is 4")
+	llm.Role = kit.LLMRoleAssistant
+	msg := kit.ConvertFromLLMMessage(llm)
+	if msg.Role != kit.RoleAssistant {
+		t.Errorf("converted Role = %q, want %q", msg.Role, kit.RoleAssistant)
+	}
+	if msg.Content() != "the answer is 4" {
+		t.Errorf("converted Content() = %q, want %q", msg.Content(), "the answer is 4")
+	}
+}
+
+// containsStr is a tiny helper to avoid importing strings in test.
+func containsStr(s, substr string) bool {
+	return len(s) >= len(substr) && (s == substr || len(s) > 0 && indexStr(s, substr) >= 0)
+}
+
+func indexStr(s, substr string) int {
+	for i := 0; i <= len(s)-len(substr); i++ {
+		if s[i:i+len(substr)] == substr {
+			return i
+		}
+	}
+	return -1
+}

scripts/acp_smoke_test.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+ACP smoke test — drives `kit acp` over JSON-RPC 2.0 stdio.
+
+Protocol flow:
+  1. session/new  → get sessionId
+  2. session/set_model → set opencode/kimi-k2.5
+  3. session/prompt → "What is 2+2? Answer in one sentence."
+  4. Collect session updates until done
+"""
+
+import json
+import subprocess
+import sys
+import threading
+import time
+import os
+
+KIT_BIN = os.path.join(os.path.dirname(__file__), "..", "output", "kit")
+MODEL   = "opencode/kimi-k2.5"
+CWD     = os.path.expanduser("~")
+TIMEOUT = 60  # seconds to wait for the prompt to complete
+
+
+def rpc(method, params, req_id):
+    return json.dumps({"jsonrpc": "2.0", "id": req_id, "method": method, "params": params}) + "\n"
+
+
+def send(proc, line):
+    print(f"\n→ SEND  {line.strip()}", flush=True)
+    proc.stdin.write(line)
+    proc.stdin.flush()
+
+
+def read_responses(proc, collected, done_event):
+    """Read newline-delimited JSON from stdout until process exits."""
+    for raw in proc.stdout:
+        raw = raw.strip()
+        if not raw:
+            continue
+        try:
+            msg = json.loads(raw)
+        except json.JSONDecodeError:
+            print(f"  [non-JSON stdout]: {raw}", flush=True)
+            continue
+
+        collected.append(msg)
+
+        # Pretty-print condensed
+        if "result" in msg:
+            result = msg["result"]
+            print(f"← RESP  id={msg.get('id')}  result={json.dumps(result)[:200]}", flush=True)
+            # Prompt complete when we get a stopReason on id=3
+            if msg.get("id") == 3 and "stopReason" in result:
+                done_event.set()
+        elif "error" in msg:
+            print(f"← ERROR id={msg.get('id')}  {json.dumps(msg['error'])}", flush=True)
+            # If it's the prompt call that errored, unblock
+            if msg.get("id") == 3:
+                done_event.set()
+        elif "method" in msg:
+            # Notification / session update
+            m = msg.get("method", "")
+            p = msg.get("params", {})
+            if m in ("session/update", "session/updated"):
+                update = p.get("update", {})
+                stype = update.get("sessionUpdate") or update.get("type", "?")
+                content = update.get("content", {})
+                if stype == "agent_thought_chunk":
+                    print(f"  [thinking] {content.get('text','')}", end="", flush=True)
+                elif stype == "agent_message_chunk":
+                    print(f"  [response] {content.get('text','')}", end="", flush=True)
+                else:
+                    print(f"\n  [update/{stype}] {json.dumps(update)[:200]}", flush=True)
+            else:
+                print(f"\n← NOTIF {m}  {json.dumps(p)[:200]}", flush=True)
+
+
+def main():
+    print(f"Starting: {KIT_BIN} acp -m {MODEL}", flush=True)
+
+    proc = subprocess.Popen(
+        [KIT_BIN, "acp", "-m", MODEL],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        bufsize=1,
+    )
+
+    collected = []
+    done_event = threading.Event()
+
+    reader = threading.Thread(target=read_responses, args=(proc, collected, done_event), daemon=True)
+    reader.start()
+
+    stderr_lines = []
+    def read_stderr():
+        for line in proc.stderr:
+            line = line.rstrip()
+            stderr_lines.append(line)
+            if line:
+                print(f"  [stderr] {line}", flush=True)
+    threading.Thread(target=read_stderr, daemon=True).start()
+
+    time.sleep(0.3)  # let the process initialise
+
+    # 1. session/new
+    send(proc, rpc("session/new", {"cwd": CWD, "mcpServers": []}, 1))
+    time.sleep(1.0)
+
+    session_id = None
+    for msg in collected:
+        if msg.get("id") == 1 and "result" in msg:
+            session_id = msg["result"].get("sessionId")
+            break
+
+    if not session_id:
+        print("\n✗ FAIL: did not get sessionId from session/new", flush=True)
+        proc.terminate()
+        sys.exit(1)
+
+    print(f"\n✓ Got sessionId: {session_id}", flush=True)
+
+    # 2. session/set_model (model already set via -m flag, but exercise the RPC)
+    send(proc, rpc("session/set_model", {"sessionId": session_id, "modelId": MODEL}, 2))
+    time.sleep(0.5)
+
+    # 3. session/prompt
+    prompt_params = {
+        "sessionId": session_id,
+        "prompt": [{"type": "text", "text": "What is 2+2? Answer in one sentence."}],
+    }
+    send(proc, rpc("session/prompt", prompt_params, 3))
+
+    # Wait for finished update or timeout
+    if not done_event.wait(timeout=TIMEOUT):
+        print(f"\n✗ FAIL: timed out after {TIMEOUT}s waiting for finished update", flush=True)
+        proc.terminate()
+        sys.exit(1)
+
+    # Check we got a successful prompt response
+    prompt_resp = next((m for m in collected if m.get("id") == 3), None)
+    if prompt_resp and "error" in prompt_resp:
+        print(f"\n✗ FAIL: prompt returned error: {prompt_resp['error']}", flush=True)
+        proc.terminate()
+        sys.exit(1)
+
+    print("\n✓ SMOKE TEST PASSED", flush=True)
+    proc.terminate()
+    proc.wait(timeout=5)
+
+
+if __name__ == "__main__":
+    main()

skills/kit-sdk/SKILL.md

@@ -119,18 +119,18 @@ result, err := host.PromptResult(ctx, "Analyze this file")
 // result.Response     — assistant's text
 // result.StopReason   — "stop", "length", "tool-calls", "error", etc.
 // result.SessionID    — session UUID
-// result.TotalUsage   — aggregate tokens across all steps (*kit.FantasyUsage)
-// result.FinalUsage   — tokens from last API call only
-// result.Messages     — full updated conversation ([]kit.FantasyMessage)
+// result.TotalUsage   — aggregate tokens across all steps (*kit.LLMUsage)
+//                        LLMUsage{InputTokens, OutputTokens, TotalTokens, ...}
+// result.FinalUsage   — tokens from last API call only (*kit.LLMUsage)
+// result.Messages     — full updated conversation ([]kit.LLMMessage)
+//                        LLMMessage{Role kit.LLMMessageRole, Content string}
 ```
 
 ### Multimodal with file attachments
 
 ```go
-import "charm.land/fantasy"
-
-files := []fantasy.FilePart{{
-    Name:      "screenshot.png",
+files := []kit.LLMFilePart{{
+    Filename:  "screenshot.png",
     MediaType: "image/png",
     Data:      imageBytes,
 }}
@@ -242,6 +242,8 @@ unsub := host.Subscribe(func(e kit.Event) {
 | `response` | `ResponseEvent` | `Content` |
 | `compaction` | `CompactionEvent` | `Summary`, `OriginalTokens`, `CompactedTokens`, `MessagesRemoved`, `ReadFiles`, `ModifiedFiles` |
 | `reasoning_delta` | `ReasoningDeltaEvent` | `Delta` |
+| `step_usage` | `StepUsageEvent` | `InputTokens`, `OutputTokens`, `CacheReadTokens`, `CacheWriteTokens` |
+| `steer_consumed` | `SteerConsumedEvent` | `Count` |
 
 ### Tool kind constants
 
@@ -308,7 +310,7 @@ host.OnAfterTurn(kit.HookPriorityNormal, func(h kit.AfterTurnHook) {
 
 ```go
 host.OnContextPrepare(kit.HookPriorityNormal, func(h kit.ContextPrepareHook) *kit.ContextPrepareResult {
-    // h.Messages — []fantasy.Message (the full context being sent to the LLM)
+    // h.Messages — []kit.LLMMessage (the full context being sent to the LLM)
     // Return nil to pass through, or replace entire context:
     return &kit.ContextPrepareResult{Messages: filteredMessages}
 })
@@ -457,7 +459,7 @@ err = host.SetThinkingLevel(ctx, "medium") // recreates agent with new thinking
 ```go
 models := host.GetAvailableModels()      // []extensions.ModelInfoEntry
 providers := kit.GetSupportedProviders() // []string
-providers := kit.GetFantasyProviders()   // providers usable with fantasy
+providers := kit.GetLLMProviders()       // providers with LLM support
 models, _ := kit.GetModelsForProvider("anthropic") // map[string]kit.ModelInfo
 info := kit.LookupModel("anthropic", "claude-sonnet-4-5-20250929") // *kit.ModelInfo
 info := kit.GetProviderInfo("openai")    // *kit.ProviderInfo (env vars, API URL)
@@ -525,7 +527,7 @@ result, err := host.Subagent(ctx, kit.SubagentConfig{
     },
 })
 // result.Response, result.Error, result.SessionID, result.StopReason
-// result.Usage (*kit.FantasyUsage), result.Elapsed (time.Duration)
+// result.Usage (*kit.LLMUsage), result.Elapsed (time.Duration)
 ```
 
 ### Subscribing to subagent events from parent
@@ -542,6 +544,53 @@ host.OnToolCall(func(e kit.ToolCallEvent) {
 
 ---
 
+## Extension API
+
+The `Extensions()` method returns an `ExtensionAPI` interface that groups all extension-related functionality. This is the primary way to interact with extension state from the SDK.
+
+```go
+extAPI := host.Extensions()
+
+// Check if extensions are loaded
+if extAPI.HasExtensions() {
+    // Context management
+    extAPI.SetContext(extensions.Context{...})
+    ctx := extAPI.GetContext()
+    extAPI.UpdateContextModel("anthropic/claude-sonnet-4-5-20250929")
+
+    // Widgets, headers, footers
+    extAPI.SetWidget(extensions.WidgetConfig{...})
+    extAPI.RemoveWidget("widget-id")
+    extAPI.SetHeader(extensions.HeaderFooterConfig{...})
+    extAPI.SetFooter(extensions.HeaderFooterConfig{...})
+
+    // Status bar
+    extAPI.SetStatus(extensions.StatusBarEntry{...})
+    extAPI.RemoveStatus("key")
+
+    // Options
+    extAPI.SetOption("name", "value")
+    val := extAPI.GetOption("name")
+
+    // Tools
+    tools := extAPI.GetToolInfos()
+    extAPI.SetActiveTools([]string{"bash", "read"})
+
+    // Events
+    extAPI.EmitSessionStart()
+    extAPI.EmitModelChange("new/model", "old/model", "extension")
+    extAPI.EmitCustomEvent("my-event", "data")
+
+    // Commands and lifecycle
+    cmds := extAPI.Commands()
+    err := extAPI.Reload()
+}
+```
+
+All methods are no-ops when extensions are disabled (nil runner), so callers don't need nil checks.
+
+---
+
 ## Authentication
 
 ```go
@@ -593,15 +642,19 @@ kit.Config, kit.MCPServerConfig
 // Provider types
 kit.ProviderConfig, kit.ProviderResult, kit.ModelInfo, kit.ModelCost, kit.ModelLimit
 
-// Fantasy types (from charm.land/fantasy)
-kit.FantasyMessage, kit.FantasyUsage, kit.FantasyResponse
+// LLM types — concrete Kit-owned structs (no external library dependency)
+kit.LLMMessage      // {Role LLMMessageRole, Content string}
+kit.LLMMessageRole  // "user" | "assistant" | "system" | "tool"
+kit.LLMUsage        // {InputTokens, OutputTokens, TotalTokens, ReasoningTokens, ...}
+kit.LLMResponse     // {Content, FinishReason, Usage}
+kit.LLMFilePart     // {Filename, Data []byte, MediaType}
 
 // Compaction types
 kit.CompactionResult, kit.CompactionOptions
 
 // Conversion helpers
-msgs := kit.ConvertToFantasyMessages(&msg)   // SDK message → fantasy messages
-msg := kit.ConvertFromFantasyMessage(fMsg)    // fantasy message → SDK message
+msgs := kit.ConvertToLLMMessages(&msg)   // SDK Message  → []LLMMessage
+msg  := kit.ConvertFromLLMMessage(lMsg)  // LLMMessage   → SDK Message
 ```
 
 ---
@@ -749,6 +802,7 @@ kit.LoadConfigWithEnvSubstitution("/path/to/config.yml")
 ## Key Files for Reference
 
 - [`pkg/kit/kit.go`](https://github.com/mark3labs/kit/blob/main/pkg/kit/kit.go) — Kit struct, New(), Prompt methods, Subagent, Close
+- [`pkg/kit/extension_api.go`](https://github.com/mark3labs/kit/blob/main/pkg/kit/extension_api.go) — ExtensionAPI interface, kit.Extensions() accessor
 - [`pkg/kit/types.go`](https://github.com/mark3labs/kit/blob/main/pkg/kit/types.go) — Re-exported types from internal packages
 - [`pkg/kit/tools.go`](https://github.com/mark3labs/kit/blob/main/pkg/kit/tools.go) — Tool constructors and bundles
 - [`pkg/kit/events.go`](https://github.com/mark3labs/kit/blob/main/pkg/kit/events.go) — Event types, EventBus, typed subscribers

specs/unified-bubbletea-architecture.md

@@ -1,450 +0,0 @@
-# Unified Bubble Tea Architecture
-
-## Overview
-
-Replace the micro-program pattern (3 interactive `tea.NewProgram` calls + 1 standalone progress) with a single persistent Bubble Tea program using child model composition. Extract a thick app layer from `cmd/root.go` to own agent orchestration, message storage, and event emission. TUI becomes purely reactive.
-
-New capabilities: message queueing during streaming, double-tap ESC cancellation, stacked layout (output above, input pinned below), queue badge with clear support.
-
-## User Story
-
-As a KIT user, I want the TUI to remain responsive during agent streaming so I can queue follow-up messages, cancel in-progress work, and see a persistent input area -- instead of waiting for each response to complete before typing.
-
-As a developer, I want the TUI architecture to follow Bubble Tea's idiomatic child-model pattern so components are composable, testable, and extensible without terminal ownership conflicts.
-
-## Requirements
-
-### Architecture
-- Single `tea.NewProgram()` call for the entire interactive session
-- Parent model manages state transitions and routes messages to child components
-- Child components: `InputComponent` (slash commands + autocomplete), `StreamComponent` (streaming display + spinner), `ApprovalComponent` (tool approval)
-- Ollama `ProgressModel` remains standalone (different lifecycle, runs during provider init)
-- Non-interactive mode bypasses `tea.Program` entirely, uses same app layer without TUI
-
-### App Layer
-- New `internal/app` package owns: agent orchestration loop, in-memory message store, message queue, tool approval callback, hook execution, session persistence, usage tracking
-- App layer exposes `Run(prompt)`, `RunOnce(ctx, prompt)`, `CancelCurrentStep()`, `ClearQueue()`, `QueueLength()`, `ClearMessages()`
-- Events sent to TUI via `program.Send()` -- no pubsub infra
-- Message store: mutable `[]fantasy.Message` with wrapper IDs, emits events on change. Bridges to `session.Manager` for persistence on each step completion.
-- `ToolApprovalFunc` provided at construction via `Options`. Interactive mode: channel handshake with TUI. Non-interactive: auto-approve. Channel must be `select`-able against app context to avoid goroutine leaks on shutdown.
-- All 7 agent callbacks from `GenerateWithLoopAndStreaming` (`agent.go:144-151`) mapped to events sent via `program.Send()`. See Events section.
-- Hook executor (`hooks.Executor`) owned by app layer. Fires `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `Stop` at same points as current `runAgenticStep`.
-
-### App Layer Options
-
-Full options mirroring current `AgenticLoopConfig` (`root.go:753-769`):
-
-```go
-type Options struct {
-    Agent            *agent.Agent
-    ToolApprovalFunc ToolApprovalFunc   // required, set at construction
-    HookExecutor     *hooks.Executor    // optional
-    SessionManager   *session.Manager   // optional, for persistence
-    MCPConfig        *config.Config     // for session continuation
-    ModelName        string
-    ServerNames      []string           // for slash commands
-    ToolNames        []string           // for slash commands
-    StreamingEnabled bool
-    Quiet            bool
-    Debug            bool
-    CompactMode      bool
-}
-```
-
-### Events
-
-Events emitted by app layer (defined in `internal/app/events.go`):
-
-| Event | Source callback | Purpose |
-|---|---|---|
-| `StreamChunkEvent` | `onStreamingResponse` | Streaming text delta |
-| `ToolCallStartedEvent` | `onToolCall` | Tool call initiated (name + args) |
-| `ToolExecutionEvent` | `onToolExecution` | Tool execution starting/stopping |
-| `ToolResultEvent` | `onToolResult` | Tool result (name, args, result, isError) |
-| `ToolCallContentEvent` | `onToolCallContent` | Tool call content display |
-| `ResponseCompleteEvent` | `onResponse` | Final response text |
-| `StepCompleteEvent` | (after generate returns) | Agent step finished, includes usage data |
-| `StepErrorEvent` | (on agent error) | Agent step failed with error |
-| `QueueUpdatedEvent` | (on queue change) | Queue length changed |
-| `ToolApprovalNeededEvent` | `onToolApproval` | Approval required, includes response channel |
-| `SpinnerEvent` | (before first chunk) | Show/hide spinner state |
-| `HookBlockedEvent` | (hook returns block) | Hook blocked the action |
-| `MessageCreatedEvent` | (on history add) | New message added to store |
-
-TUI-internal messages (defined in `internal/ui/events.go`, NOT in app layer):
-
-| Message | Purpose |
-|---|---|
-| `submitMsg` | Input component submitted text |
-| `approvalResultMsg` | Approval component returned decision |
-| `cancelTimerExpiredMsg` | 2s ESC timer expired |
-
-### TUI Behavior
-- Stacked layout: latest response output above, input textarea pinned below
-- Output area shows latest response only. Completed responses emitted above the BT-managed region via `tea.Println()` before the model resets for the next interaction. This works with BT v2 inline mode (no alt screen).
-- Input textarea keeps current sizing behavior from `SlashCommandInput`
-- Slash command autocomplete fully self-contained in input component. Component holds `*app.App` reference for executing commands that affect app state (`/clear` calls `app.ClearMessages()`, `/quit` returns `tea.Quit` to parent, `/clear-queue` calls `app.ClearQueue()`). Parent receives either a `submitMsg` (text prompt) or a `tea.Cmd` (slash command side effect).
-- Message queueing: user can submit while agent streams. Queue badge shows "N queued" near input. `/clear-queue` slash command flushes queue.
-- Double-tap ESC: first press shows "press again to cancel", second press calls `App.CancelCurrentStep()`. Timer expires after 2s, resets state.
-- Tool approval: agent blocks on `ToolApprovalFunc` callback. Callback sends `ToolApprovalNeededEvent` (containing a `chan<- bool` response channel) to program, then blocks on that channel via `select` with `ctx.Done()`. TUI transitions to approval state, user decides, parent sends result on channel. If ctx cancelled, callback returns `false, ctx.Err()`.
-- Keyboard during streaming: input textarea remains focused and editable. All keystrokes go to the input component normally. ESC is intercepted by parent for cancel flow. Enter/submit queues the message via `app.Run()`.
-- Spinner: `StreamComponent` renders a spinner animation (replacing the current standalone goroutine-based `ui.Spinner`) when the agent is processing but hasn't sent any chunks yet. First `StreamChunkEvent` transitions from spinner to streaming display. No more goroutine writing to stderr.
-
-### Compact Mode
-
-Current code uses two renderers (`MessageRenderer` and `CompactRenderer`) toggled by `cli.compactMode`. Both renderers retained. The `CompactMode` flag propagated through `App.Options` → parent model → child components. Each component checks the flag and delegates to the appropriate renderer for message formatting.
-
-### Usage Tracking
-
-`UsageTracker` moves to the app layer. Created during `App.New()` using model info from `Options`. App layer calls `UpdateUsageFromResponse()` after each step. Emits usage data in `StepCompleteEvent`. TUI renders usage via retained `UsageTracker.RenderUsageInfo()` method. Non-interactive mode reads usage from app layer directly.
-
-### Non-Interactive Mode
-- Same app layer, no TUI. `ToolApprovalFunc` auto-approves (provided at construction). Output prints directly to stdout.
-- Current `runNonInteractiveMode` refactored to use `app.RunOnce()`.
-- **Behavior change**: current non-interactive non-quiet mode creates a BT streaming display program. New behavior: `RunOnce()` accepts an optional `StreamingWriter io.Writer` for real-time output. Non-interactive passes `os.Stdout`. No BT program created.
-
-### Session Persistence
-
-`session.Manager` owned by app layer (passed via `Options.SessionManager`). App layer calls `session.Manager.AddMessages()` after each step completion and on queue drain. `--load-session` flag handled in `cmd/root.go` before app construction -- loaded messages passed to `App.New()` as initial history. `MessageStore.Clear()` also calls `session.Manager.ReplaceAllMessages()`.
-
-### Error Handling
-
-Agent errors (API failures, rate limits, MCP crashes) emitted as `StepErrorEvent`. Parent model receives the event, passes error to `StreamComponent` for inline display (matching current behavior), then transitions to `stateInput`. No automatic retry -- user can retry by submitting again.
-
-### Graceful Shutdown
-
-Shutdown sequence when user quits (Ctrl+C or `/quit`):
-
-1. Parent model returns `tea.Quit`
-2. `tea.Program.Run()` returns in `cmd/root.go`
-3. If agent goroutine running: `app.CancelCurrentStep()` called (deferred)
-4. `app.Close()` called (deferred) -- cancels app context, waits for agent goroutine to exit
-5. `mcpAgent.Close()` called (deferred, existing) -- closes MCP connections and provider
-
-`App` holds a top-level `context.Context` (created with `context.WithCancel` in `New()`). All agent goroutines use this context. `App.Close()` cancels it and calls `sync.WaitGroup.Wait()` to ensure clean exit.
-
-### Parent Model State Machine
-
-```
-stateInput ──submit──→ stateWorking ──StepComplete──→ stateInput
-                            │                              ↑
-                            ├──ToolApproval──→ stateApproval──approve/deny──┘
-                            │                              │
-                            ├──StepError────→ stateInput   │
-                            │                              │
-                            └──Cancel────────→ stateInput  │
-                                                           │
-                          (queue non-empty: auto-drain) ───┘
-```
-
-States:
-- `stateInput` -- input focused, waiting for user
-- `stateWorking` -- agent running (spinner → streaming → tool calls → streaming → ...)
-- `stateApproval` -- tool approval dialog active (sub-state of working)
-
-### Testing
-- Unit tests for each child component (send messages, assert state transitions)
-- Unit tests for parent model (state routing, child delegation, cancel flow, error handling)
-- Unit tests for app layer (message store, queue, cancel, session save ordering, ToolApprovalFunc channel + ctx cancellation)
-
-## Technical Implementation
-
-### Package Structure
-
-```
-internal/
-  app/
-    app.go              # App struct, New(), Run(), RunOnce(), CancelCurrentStep(), Close()
-    app_test.go         # App tests (queue, cancel, drain, session save)
-    messages.go         # MessageStore (in-memory, wraps []fantasy.Message, bridges session.Manager)
-    messages_test.go    # MessageStore tests
-    events.go           # All event types sent to TUI via program.Send()
-    options.go          # Options struct, ToolApprovalFunc type
-  ui/
-    model.go            # Parent tea.Model (AppModel), state machine, message routing
-    model_test.go       # Parent model tests
-    input.go            # InputComponent (refactored slash_command_input.go)
-    input_test.go       # Input tests
-    stream.go           # StreamComponent (refactored streaming_display.go + spinner)
-    stream_test.go      # Stream tests
-    approval.go         # ApprovalComponent (refactored tool_approval_input.go)
-    approval_test.go    # Approval tests
-    events.go           # TUI-internal message types (submitMsg, approvalResultMsg, cancelTimerExpiredMsg)
-    cli.go              # Retained: SetupCLI factory (creates App + AppModel), non-TUI helpers
-    messages.go         # Retained: message rendering (used by StreamComponent)
-    styles.go           # Retained
-    enhanced_styles.go  # Retained
-    compact_renderer.go # Retained
-    block_renderer.go   # Retained
-    commands.go         # Retained + /clear-queue added
-    fuzzy.go            # Retained
-    usage_tracker.go    # Retained (used by app layer)
-    debug_logger.go     # Retained (used by app layer)
-  ui/progress/
-    ollama.go           # Retained standalone (not part of refactor)
-```
-
-### Parent Model
-
-```go
-type appState int
-const (
-    stateInput    appState = iota  // Input focused, waiting for user
-    stateWorking                    // Agent running, streaming output
-    stateApproval                   // Tool approval dialog active
-)
-
-type AppModel struct {
-    state        appState
-    app          *app.App            // Thick app layer reference
-    input        InputComponent      // Child: user input + autocomplete
-    stream       StreamComponent     // Child: streaming display + spinner
-    approval     ApprovalComponent   // Child: tool approval
-    renderer     *MessageRenderer    // For tea.Println of completed responses
-    compactRdr   *CompactRenderer    // Compact mode renderer
-    compactMode  bool                // Which renderer to use
-    queueCount   int                 // Cached from QueueUpdatedEvent
-    canceling    bool                // Double-tap ESC state
-    approvalChan chan<- bool         // Response channel for current approval
-    width        int
-    height       int
-}
-```
-
-### Event Flow
-
-```
-User types → InputComponent.Update() → submit
-  ↓
-Parent receives submitMsg → calls app.Run(prompt) in tea.Cmd goroutine
-  ↓
-Parent transitions to stateWorking → StreamComponent active (spinner mode)
-  ↓
-App layer goroutine: agent processes
-  → program.Send(SpinnerEvent{Show: true})
-  → program.Send(ToolCallStartedEvent{...})
-  → program.Send(StreamChunkEvent{...})  (first chunk hides spinner)
-  → program.Send(ToolResultEvent{...})
-  → program.Send(ToolCallContentEvent{...})
-  ↓
-Parent routes events to StreamComponent.Update()
-  ↓
-Agent needs tool approval → ToolApprovalFunc called
-  → creates chan bool, sends ToolApprovalNeededEvent{ResponseChan: ch}
-  → blocks: select { case result := <-ch; case <-ctx.Done() }
-  ↓
-Parent stores channel in approvalChan, transitions to stateApproval
-  ↓
-User approves → Parent sends on approvalChan → Agent continues
-  ↓
-Agent completes → app sends StepCompleteEvent{Usage: ...}
-  ↓
-Parent: tea.Println() completed response, transitions to stateInput
-  ↓
-If queue non-empty: App auto-drains next message, stays in stateWorking
-```
-
-### Cancel Flow
-
-```
-User presses ESC during stateWorking
-  ↓
-Parent sets canceling=true, returns cancelTimerCmd (2s tea.Tick)
-  ↓
-User presses ESC again within 2s → Parent calls app.CancelCurrentStep()
-  ↓
-App cancels step context → agent goroutine exits
-  → ToolApprovalFunc unblocks via ctx.Done() if waiting
-  → StepErrorEvent or StepCompleteEvent emitted
-  ↓
-Parent transitions to stateInput
-  ↓
-cancelTimerExpiredMsg arrives (if no second ESC) → resets canceling=false
-```
-
-### cmd/root.go Changes
-
-```go
-// runNormalMode becomes:
-appInstance, err := app.New(app.Options{
-    Agent:            mcpAgent,
-    ToolApprovalFunc: toolApprovalFunc,  // set per mode, see below
-    HookExecutor:     hookExecutor,
-    SessionManager:   sessionManager,
-    MCPConfig:        mcpConfig,
-    ModelName:        modelString,
-    ServerNames:      serverNames,
-    ToolNames:        toolNames,
-    StreamingEnabled: viper.GetBool("stream"),
-    Quiet:            quietFlag,
-    Debug:            viper.GetBool("debug"),
-    CompactMode:      viper.GetBool("compact"),
-}, initialMessages)  // loaded from session if --load-session
-defer appInstance.Close()
-
-// Interactive mode:
-toolApprovalFunc = app.NewInteractiveApprovalFunc(appInstance)
-model := ui.NewAppModel(appInstance, uiOpts)
-program := tea.NewProgram(model)
-appInstance.SetProgram(program)  // Safe: app.Run() not called until Init()
-_, err := program.Run()
-
-// Non-interactive mode:
-toolApprovalFunc = app.AutoApproveFunc
-result, err := appInstance.RunOnce(ctx, prompt, os.Stdout) // stdout for streaming
-printResult(result)
-```
-
-**SetProgram timing**: Safe because `app.Run()` is only called from `tea.Cmd` functions after the program starts its event loop. `AppModel.Init()` returns no command that calls `app.Run()` -- the first `Run()` call happens when the user submits input or when `Init()` dispatches an initial prompt (non-interactive continuation via `--no-exit`).
-
-## Tasks
-
-### 1. Create app layer skeleton
-- [ ] [P0] Create `internal/app/events.go` with all event types: `StreamChunkEvent`, `ToolCallStartedEvent`, `ToolExecutionEvent`, `ToolResultEvent`, `ToolCallContentEvent`, `ResponseCompleteEvent`, `StepCompleteEvent` (with usage data), `StepErrorEvent`, `QueueUpdatedEvent`, `ToolApprovalNeededEvent` (with `ResponseChan chan<- bool`), `SpinnerEvent`, `HookBlockedEvent`, `MessageCreatedEvent`
-- [ ] [P0] Create `internal/app/options.go` with `Options` struct (all fields from App Layer Options section), `ToolApprovalFunc` type (`func(ctx context.Context, toolName, toolArgs string) (bool, error)`), `AutoApproveFunc` var, `NewInteractiveApprovalFunc` constructor
-- [ ] [P0] Create `internal/app/messages.go` with `MessageStore` wrapping `[]fantasy.Message`. Methods: `Add(fantasy.Message)`, `Replace([]fantasy.Message)`, `GetAll() []fantasy.Message`, `Clear()`. Bridges to `session.Manager` (if non-nil) on every mutation for persistence.
-- [ ] [P0] Create `internal/app/app.go` with `App` struct, `New(opts, initialMessages)`, `SetProgram(*tea.Program)`, `Run(prompt)`, `RunOnce(ctx, prompt, io.Writer)`, `CancelCurrentStep()`, `QueueLength()`, `ClearQueue()`, `ClearMessages()`, `Close()`. Internal: `context.WithCancel`, `sync.WaitGroup`, `sync.Mutex` for busy/queue state.
-
-### 2. Migrate agent orchestration into app layer
-- [ ] [P1] Move `runAgenticStep` logic from `cmd/root.go:873-1191` into `App.executeStep()`. Map all 7 agent callbacks to `program.Send()` events. Wire `ToolApprovalFunc` for `onToolApproval`. Emit `SpinnerEvent{Show:true}` before calling agent, `SpinnerEvent{Show:false}` on first stream chunk.
-- [ ] [P1] Move hook execution from `cmd/root.go:810-828,943-969,1002-1019,1186-1223` into `App.executeStep()`. Fire `UserPromptSubmit` in `Run()` before `executeStep()`. Fire `PreToolUse`/`PostToolUse`/`Stop` at same points. Emit `HookBlockedEvent` if hook blocks.
-- [ ] [P1] Move conversation history management into `MessageStore`. `App.executeStep()` calls `store.Add()` for user message before agent call, `store.Replace()` with updated history after agent returns. Store bridges to `session.Manager`.
-- [ ] [P1] Move usage tracking into app layer. Create `UsageTracker` in `App.New()` from model info. Call `UpdateUsageFromResponse()` after each step. Include usage data in `StepCompleteEvent`.
-- [ ] [P1] Implement queue drain: after step completes (success or error), if queue non-empty, dequeue next message and call `executeStep()` in same goroutine (no new goroutine spawn).
-
-### 3. Create parent TUI model
-- [ ] [P1] Create `internal/ui/model.go` with `AppModel` struct (see Parent Model section), `NewAppModel()`, `Init()`, `Update()`, `View()`. State machine routes events to children based on `appState`. Handle `tea.WindowSizeMsg` to distribute height. Store `approvalChan` for tool approval response.
-- [ ] [P1] Implement double-tap ESC cancel in parent `Update()`: intercept `tea.KeyPressMsg` for ESC during `stateWorking`. Track `canceling` bool, return `tea.Tick(2*time.Second, ...)` as timer cmd, call `app.CancelCurrentStep()` on second press within window.
-- [ ] [P1] Implement `tea.Println()` for completed responses: on `StepCompleteEvent`, render the completed response using message renderer (respecting compact mode), emit via `tea.Println()`, then reset `StreamComponent` state.
-- [ ] [P1] Implement `StepErrorEvent` handling: render error inline in stream area, transition to `stateInput`.
-- [ ] [P1] Implement graceful quit: Ctrl+C and `/quit` return `tea.Quit`. Deferred `app.Close()` in `cmd/root.go` handles cleanup.
-
-### 4. Refactor child components
-- [ ] [P1] Refactor `slash_command_input.go` → `internal/ui/input.go` as `InputComponent`. Remove `tea.Quit` on submit -- return `submitMsg` as a `tea.Cmd`. Keep autocomplete + popup self-contained. Hold `*app.App` reference for slash command execution: `/clear` → `app.ClearMessages()`, `/clear-queue` → `app.ClearQueue()`, `/quit` → return `tea.Quit` cmd. Remove `os.Exit(0)` from `/quit`.
-- [ ] [P1] Refactor `streaming_display.go` → `internal/ui/stream.go` as `StreamComponent`. Add spinner state: render KITT-style animation (from current `spinner.go`) when `SpinnerEvent{Show:true}` received, switch to streaming text on first `StreamChunkEvent`. Accept all display events (`ToolCallStartedEvent`, `ToolResultEvent`, etc.) and render via retained `MessageRenderer`/`CompactRenderer`. Remove `streamDoneMsg`/`tea.Quit` -- parent manages lifecycle. Add `Reset()` to clear state between steps.
-- [ ] [P1] Refactor `tool_approval_input.go` → `internal/ui/approval.go` as `ApprovalComponent`. Remove `tea.Quit` -- return `approvalResultMsg{approved: bool}` as a `tea.Cmd`. Parent handles sending result on `approvalChan`.
-
-### 5. Wire TUI to app layer in cmd/root.go
-- [ ] [P1] Refactor `runNormalMode()`: create `app.App` with full `Options` (all fields). Wire `ToolApprovalFunc` per mode. Load session messages before construction. Defer `appInstance.Close()`.
-- [ ] [P1] Interactive path: create `ui.NewAppModel()` + single `tea.NewProgram(model)` + `appInstance.SetProgram(program)` + `program.Run()`. Remove `SetupCLI()` flow for interactive mode.
-- [ ] [P1] Non-interactive path: call `appInstance.RunOnce(ctx, prompt, os.Stdout)`. Handle `--no-exit` by switching to interactive mode after. No `tea.Program` created. Remove old streaming display usage for non-interactive.
-- [ ] [P1] Retain `SetupCLI()` as alternative factory for non-interactive quiet mode (just prints final text, no renderers needed). Or inline the quiet-mode logic.
-
-### 6. Implement message queueing UX
-- [ ] [P2] Add queue badge rendering in parent `View()` -- show "N queued" right-aligned on separator line when `queueCount > 0`. Update count on `QueueUpdatedEvent`.
-- [ ] [P2] Register `/clear-queue` slash command in `internal/ui/commands.go`.
-- [ ] [P2] Handle `submitMsg` during `stateWorking`: parent calls `app.Run()` (which queues internally), does NOT transition state. Input component stays active and clears text.
-
-### 7. Stacked layout
-- [ ] [P2] Implement stacked `View()` in parent: stream output region (variable height) + separator line + input region (current textarea height). Use `lipgloss.JoinVertical`. Separator shows queue badge if applicable.
-- [ ] [P2] Handle `tea.WindowSizeMsg` propagation: calculate input height (fixed, from textarea), separator (1 line), remaining goes to stream. Propagate dimensions to children.
-
-### 8. Cleanup
-- [ ] [P2] Delete standalone `tea.NewProgram` calls from `cli.go` (`GetPrompt`, `StartStreamingMessage`, `GetToolApproval`). Remove `streamProgram`/`streamDone` fields.
-- [ ] [P2] Delete `runAgenticStep`, `runAgenticLoop`, `runInteractiveLoop`, `addMessagesToHistory`, `replaceMessagesHistory`, `AgenticLoopConfig` from `cmd/root.go`.
-- [ ] [P2] Delete old `spinner.go` (replaced by StreamComponent's inline spinner).
-- [ ] [P3] Trim `CLI` struct to only non-TUI helpers needed by non-interactive quiet mode. Remove `GetPrompt`, `StartStreamingMessage`, `UpdateStreamingMessage`, `GetToolApproval`, `finishStreaming`, `HandleSlashCommand`. Retain `DisplayError`, `DisplayInfo` for non-interactive error output if needed, or remove entirely if `RunOnce` handles its own output.
-
-### 9. Tests
-- [ ] [P2] Unit tests for `MessageStore`: add, replace, getAll, clear, session.Manager bridge (mock manager, verify calls)
-- [ ] [P2] Unit tests for `App`: run (single), run (queued), cancel during step, cancel during approval (verify ToolApprovalFunc unblocks via ctx), queue drain ordering, ClearQueue, Close (verify goroutine cleanup via WaitGroup)
-- [ ] [P2] Unit tests for `AppModel`: state transitions (input→working→approval→input), StepError→input, ESC cancel flow (single tap resets, double tap cancels), queue badge update, window resize, tea.Println on step complete
-- [ ] [P2] Unit tests for child components: `InputComponent` (submit emits submitMsg, slash commands execute, /quit returns tea.Quit), `StreamComponent` (spinner→streaming transition, chunk accumulation, tool call rendering, reset), `ApprovalComponent` (approve/deny emits approvalResultMsg)
-
-## UI Mockup
-
-### Processing (stateWorking, spinner)
-
-```
-  ◇◇◇◆◇◇◇ Thinking...
-
-
-───────────────────────────────────
-> █
-```
-
-### During Streaming (stateWorking)
-
-```
-  assistant (claude-sonnet-4-20250514)
-  Here is the implementation of the requested
-  feature. First, I'll create the new file...
-  █ (streaming cursor)
-
-─────────────────────────────────── 2 queued
-> write tests for that too█
-```
-
-### Tool Call in Stream (stateWorking)
-
-```
-  assistant (claude-sonnet-4-20250514)
-  Let me check the build first.
-
-  ⚙ bash: go build -o output/kit
-  ◇◇◇◆◇◇◇ Executing...
-
-─────────────────────────────────── 2 queued
-> write tests for that too█
-```
-
-### During Tool Approval (stateApproval)
-
-```
-  assistant (claude-sonnet-4-20250514)
-  I need to run a command to check the build.
-
-  ┌─ Tool Approval ──────────────────────┐
-  │ bash: go build -o output/kit          │
-  │                                      │
-  │  [Yes]   No                          │
-  └──────────────────────────────────────┘
-
-─────────────────────────────────── 2 queued
-> █
-```
-
-### Cancel in Progress (stateWorking, canceling)
-
-```
-  assistant (claude-sonnet-4-20250514)
-  Analyzing the codebase structure to find
-  relevant files...
-
-  ⚠ Press ESC again to cancel
-
-─────────────────────────────────── 1 queued
-> also check the tests█
-```
-
-### Error (stateWorking → stateInput)
-
-```
-  ✗ Error: API rate limit exceeded. Try again.
-
-───────────────────────────────────
-> █
-```
-
-## Out of Scope
-
-- Scrollable viewport / chat history browsing (latest response only for v1)
-- Ollama `ProgressModel` unification (stays standalone)
-- Persistent message storage / database (session JSON files retained as-is)
-- Multi-session support
-- Split-pane or tabbed layouts
-- Mouse interaction
-- Changing tool call display format (keep current rendering via retained renderers)
-- Prompt history persistence across sessions
-- Any visual/theme changes beyond new layout
-- Refactoring the `agent.Agent` or `fantasy` interfaces
-- Changing hook execution semantics
-
-## Open Questions
-
-- Should queue drain be immediate (next message starts as soon as current step completes) or should there be a brief pause to let the user read the response?
-- If the user cancels mid-stream and there are queued messages, should the queue also be flushed or should the next queued message execute?
-- Should the input component retain focus (cursor visible, editable) during `stateApproval`, or should focus fully transfer to the approval dialog?
-- Should `tea.Println()` of completed responses include tool call/result details, or just the final assistant text? Current behavior shows everything inline.
-- How should debug logging work during the TUI lifecycle? Currently `BufferedDebugLogger` accumulates messages shown after agent creation. In the new architecture, should debug messages be events rendered in the stream component?
-- For `--no-exit` (non-interactive then interactive): should `RunOnce` return and then `cmd/root.go` creates the TUI program for the interactive continuation, or should the TUI program be created upfront and the initial prompt dispatched via `Init()`?

test_messages.txt

@@ -0,0 +1,9 @@
+1. Hello, world!
+
+2. Testing one, two, three.
+
+3. This is a quick test message.
+
+4. Sample text for verification.
+
+5. All systems operational.

www/pages/cli/commands.md

@@ -21,7 +21,7 @@ Manage the local model database that maps provider names to API configurations.
 
 ```bash
 kit models [provider]        # List available models (optionally filter by provider)
-kit models --all             # Show all providers (not just Fantasy-compatible)
+kit models --all             # Show all providers (not just LLM-compatible)
 kit update-models [source]   # Update model database
 ```
 

www/pages/providers.md

@@ -139,7 +139,7 @@ When `--provider-url` is provided without `--model`, Kit automatically defaults
 kit --provider-url "http://localhost:8080/v1" "Hello"
 ```
 
-The `custom/custom` model has zero cost, 262K context window, and supports reasoning. It routes through fantasy's `openaicompat` provider and accepts any OpenAI-compatible API endpoint.
+The `custom/custom` model has zero cost, 262K context window, and supports reasoning. It routes through the `openaicompat` provider and accepts any OpenAI-compatible API endpoint.
 
 Optionally set `CUSTOM_API_KEY` environment variable or use `--provider-api-key` for endpoints requiring authentication.