rename spawn_subagent tool to subagent; remove redundant toolDisplayNames map

Tool rename (breaking change for ToolName string comparisons in event handlers):
- internal/core/subagent.go: Name field 'spawn_subagent' → 'subagent'
- internal/extensions/wrapper.go: update coreToolKinds map key
- pkg/kit/events.go: update coreToolKinds map key and ToolKindSubagent comment
- pkg/kit/extensions_bridge.go: update three ToolName == ... guards
- internal/ui/tool_renderers.go: update two toolName == ... case guards
- internal/ui/stream.go: remove special-case branch (toolName is now already
  'subagent', so the title-case fallback produces 'Subagent' naturally)

Comments/docs updated everywhere (no logic changes):
- internal/core/tools.go, internal/extensions/api.go, events.go
- pkg/kit/kit.go, tools.go
- examples/extensions/subagent-test.go, kit-telegram/main.go
- README.md, skills/kit-sdk/SKILL.md
- www/pages/advanced/subagents.md, extensions/capabilities.md
- www/pages/index.md, sdk/callbacks.md
- www/public/session/index.html (tracked UI asset)

Redundant toolDisplayNames map removed (item #14):
- internal/ui/messages.go: delete the 7-entry map whose every value was
  identical to what the title-case fallback already produced; simplify
  toolDisplayName() to just the fallback

.agents/skills/btca-cli/SKILL.md

@@ -1,64 +0,0 @@
----
-name: btca-cli
-description: Operate the btca CLI for local resources and source-first answers. Use when setting up btca in a project, connecting a provider, adding or managing resources, and asking questions via btca commands. Invoke this skill when the user says "use btca" or needs to do more detailed research on a specific library or framework.
----
-
-# btca CLI
-
-`btca` is a source-first research CLI. It hydrates resources (git, local, npm) into searchable context, then answers questions grounded in those sources. Use configured resources for ongoing work, or one-off anonymous resources directly in `btca ask`.
-
-Full CLI reference: https://docs.btca.dev/guides/cli-reference
-
-Add resources:
-
-```bash
-# Git resource
-btca add -n svelte-dev https://github.com/sveltejs/svelte.dev
-
-# Local directory
-btca add -n my-docs -t local /absolute/path/to/docs
-
-# npm package
-btca add npm:@types/node@22.10.1 -n node-types -t npm
-```
-
-Verify resources:
-
-```bash
-btca resources
-```
-
-Ask a question:
-
-```bash
-btca ask -r svelte-dev -q "How do I define remote functions?"
-```
-
-## Common Tasks
-
-- Ask with multiple resources:
-
-```bash
-btca ask -r react -r typescript -q "How do I type useState?"
-```
-
-- Ask with anonymous one-off resources (not saved to config):
-
-```bash
-# One-off git repo
-btca ask -r https://github.com/sveltejs/svelte -q "Where is the implementation of writable stores?"
-
-# One-off npm package
-btca ask -r npm:react@19.0.0 -q "How is useTransition exported?"
-```
-
-## Config Overview
-
-- Config lives in `btca.config.jsonc` (project) and `~/.config/btca/btca.config.jsonc` (global).
-- Project config overrides global and controls provider/model and resources.
-
-## Troubleshooting
-
-- "No resources configured": add resources with `btca add ...` and re-run `btca resources`.
-- "Provider not connected": run `btca connect` and follow the prompts.
-- "Unknown resource": use `btca resources` for configured names, or pass a valid HTTPS git URL / `npm:<package>` as an anonymous one-off in `btca ask`.

.agents/skills/btca-cli/agents/openai.yaml

@@ -1,3 +0,0 @@
-interface:
-  display_name: "BTCA CLI"
-  short_description: "Help with BTCA CLI setup and usage workflows"

.agents/skills/kit-extensions/SKILL.md

@@ -1,853 +0,0 @@
----
-name: kit-extensions
-description: Guide for creating Kit extensions. Use when the user asks to build, create, or modify a Kit extension, add a custom tool, slash command, widget, keyboard shortcut, editor interceptor, tool renderer, or hook into any Kit lifecycle event.
----
-
-# Kit Extensions Development Guide
-
-Kit extensions are single-file Go programs interpreted at runtime by Yaegi. They hook into Kit's lifecycle, register custom tools and slash commands, display widgets, intercept editor input, render tool output, and more.
-
-## Extension Structure
-
-Every extension must export a `package main` with an `Init(api ext.API)` function:
-
-```go
-//go:build ignore
-
-package main
-
-import "kit/ext"
-
-func Init(api ext.API) {
-    // Register event handlers, tools, commands, etc.
-}
-```
-
-The `//go:build ignore` tag prevents `go build` from compiling the file directly.
-
-## Extension Locations
-
-Extensions are auto-loaded from these directories:
-
-- `~/.config/kit/extensions/*.go` (global, single files)
-- `~/.config/kit/extensions/*/main.go` (global, subdirectories)
-- `.kit/extensions/*.go` (project-local, single files)
-- `.kit/extensions/*/main.go` (project-local, subdirectories)
-
-Or loaded explicitly:
-
-```bash
-kit -e path/to/extension.go
-kit --extension path/to/extension.go
-```
-
-## Import Path
-
-Extensions import the Kit API as `"kit/ext"`. The full standard library is available plus `os/exec` for subprocess spawning.
-
-## API Overview
-
-The `Init` function receives an `ext.API` object for registering handlers, and event handlers receive an `ext.Context` with runtime capabilities.
-
----
-
-## Lifecycle Events
-
-Kit provides 18 lifecycle events. Each handler receives an event struct and a `Context`.
-
-### Session Events
-
-```go
-// Fired when session is loaded/created.
-api.OnSessionStart(func(e ext.SessionStartEvent, ctx ext.Context) {
-    // e.SessionID string
-})
-
-// Fired when Kit is shutting down. Use for cleanup.
-api.OnSessionShutdown(func(e ext.SessionShutdownEvent, ctx ext.Context) {
-    // No fields.
-})
-```
-
-### Agent Turn Events
-
-```go
-// Before agent starts processing. Can inject system prompt or text.
-api.OnBeforeAgentStart(func(e ext.BeforeAgentStartEvent, ctx ext.Context) *ext.BeforeAgentStartResult {
-    // e.Prompt string
-    // Return nil to pass through.
-    // Return &ext.BeforeAgentStartResult{SystemPrompt: &s} to augment system prompt.
-    // Return &ext.BeforeAgentStartResult{InjectText: &s} to inject text before prompt.
-    return nil
-})
-
-// Agent loop has started.
-api.OnAgentStart(func(e ext.AgentStartEvent, ctx ext.Context) {
-    // e.Prompt string
-})
-
-// Agent finished responding.
-api.OnAgentEnd(func(e ext.AgentEndEvent, ctx ext.Context) {
-    // e.Response string
-    // e.StopReason string — "completed", "cancelled", "error"
-})
-```
-
-### Tool Events
-
-```go
-// Before a tool executes. Can block the call.
-api.OnToolCall(func(e ext.ToolCallEvent, ctx ext.Context) *ext.ToolCallResult {
-    // e.ToolName string
-    // e.ToolCallID string
-    // e.Input string — JSON-encoded parameters
-    // e.Source string — "llm" or "user"
-    // Return nil to allow.
-    // Return &ext.ToolCallResult{Block: true, Reason: "..."} to block.
-    return nil
-})
-
-// Tool execution started (informational only).
-api.OnToolExecutionStart(func(e ext.ToolExecutionStartEvent, ctx ext.Context) {
-    // e.ToolName string
-})
-
-// Tool execution ended (informational only).
-api.OnToolExecutionEnd(func(e ext.ToolExecutionEndEvent, ctx ext.Context) {
-    // e.ToolName string
-})
-
-// After a tool returns. Can modify the result.
-api.OnToolResult(func(e ext.ToolResultEvent, ctx ext.Context) *ext.ToolResultResult {
-    // e.ToolName string
-    // e.Input string
-    // e.Content string
-    // e.IsError bool
-    // Return nil to pass through.
-    // Return &ext.ToolResultResult{Content: &s} to replace content.
-    // Return &ext.ToolResultResult{IsError: &b} to change error status.
-    return nil
-})
-```
-
-### Input Events
-
-```go
-// User submitted input. Can handle or transform it.
-api.OnInput(func(e ext.InputEvent, ctx ext.Context) *ext.InputResult {
-    // e.Text string
-    // e.Source string — "interactive", "cli", "script", "queue"
-    // Return nil to pass through to agent.
-    // Return &ext.InputResult{Action: "handled"} to consume without sending to agent.
-    // Return &ext.InputResult{Action: "transform", Text: "new text"} to rewrite.
-    return nil
-})
-```
-
-### Streaming Events
-
-```go
-api.OnMessageStart(func(e ext.MessageStartEvent, ctx ext.Context) {})
-api.OnMessageUpdate(func(e ext.MessageUpdateEvent, ctx ext.Context) {
-    // e.Chunk string — streaming text chunk
-})
-api.OnMessageEnd(func(e ext.MessageEndEvent, ctx ext.Context) {
-    // e.Content string — full message content
-})
-```
-
-### Model Events
-
-```go
-api.OnModelChange(func(e ext.ModelChangeEvent, ctx ext.Context) {
-    // e.NewModel string
-    // e.PreviousModel string
-    // e.Source string — "extension" or "user"
-})
-```
-
-### Context Filtering
-
-```go
-// Before messages are sent to the LLM. Can filter, reorder, or inject messages.
-api.OnContextPrepare(func(e ext.ContextPrepareEvent, ctx ext.Context) *ext.ContextPrepareResult {
-    // e.Messages []ext.ContextMessage
-    // Each ContextMessage has: Index int, Role string, Content string
-    // Index -1 means a new injected message (not from session).
-    // Return nil to pass through.
-    // Return &ext.ContextPrepareResult{Messages: msgs} to replace the context window.
-    return nil
-})
-```
-
-### Session Control Events
-
-```go
-// Before forking the session tree. Can cancel.
-api.OnBeforeFork(func(e ext.BeforeForkEvent, ctx ext.Context) *ext.BeforeForkResult {
-    // e.TargetID string, e.IsUserMessage bool, e.UserText string
-    return nil // or &ext.BeforeForkResult{Cancel: true, Reason: "..."}
-})
-
-// Before switching/clearing session. Can cancel.
-api.OnBeforeSessionSwitch(func(e ext.BeforeSessionSwitchEvent, ctx ext.Context) *ext.BeforeSessionSwitchResult {
-    // e.Reason string — "new" or "clear"
-    return nil // or &ext.BeforeSessionSwitchResult{Cancel: true, Reason: "..."}
-})
-
-// Before context compaction. Can cancel.
-api.OnBeforeCompact(func(e ext.BeforeCompactEvent, ctx ext.Context) *ext.BeforeCompactResult {
-    // e.EstimatedTokens, e.ContextLimit int
-    // e.UsagePercent float64, e.MessageCount int, e.IsAutomatic bool
-    return nil // or &ext.BeforeCompactResult{Cancel: true, Reason: "..."}
-})
-```
-
-### Custom Events
-
-```go
-// Subscribe to custom events emitted by other extensions.
-api.OnCustomEvent("event-name", func(data string) {
-    // data is arbitrary string payload
-})
-
-// Emit from Context:
-ctx.EmitCustomEvent("event-name", "payload")
-```
-
----
-
-## Registering Tools
-
-Tools are functions the LLM can invoke:
-
-```go
-api.RegisterTool(ext.ToolDef{
-    Name:        "current_time",
-    Description: "Get the current date and time",
-    Parameters:  `{"type":"object","properties":{}}`,
-    Execute: func(input string) (string, error) {
-        return time.Now().Format(time.RFC3339), nil
-    },
-})
-```
-
-For long-running tools with cancellation and progress:
-
-```go
-api.RegisterTool(ext.ToolDef{
-    Name:        "slow_task",
-    Description: "A long-running task with progress reporting",
-    Parameters:  `{"type":"object","properties":{"query":{"type":"string"}}}`,
-    ExecuteWithContext: func(input string, tc ext.ToolContext) (string, error) {
-        for i := 0; i < 10; i++ {
-            if tc.IsCancelled() {
-                return "cancelled", nil
-            }
-            tc.OnProgress(fmt.Sprintf("Step %d/10...", i+1))
-            time.Sleep(time.Second)
-        }
-        return "done", nil
-    },
-})
-```
-
-Parameters must be a JSON Schema string. The `input` argument is the JSON-encoded parameters from the LLM.
-
----
-
-## Registering Slash Commands
-
-Commands are user-facing actions invoked with `/name` in the input:
-
-```go
-api.RegisterCommand(ext.CommandDef{
-    Name:        "echo",
-    Description: "Echo back the provided text",
-    Execute: func(args string, ctx ext.Context) (string, error) {
-        ctx.PrintInfo("You said: " + args)
-        return "", nil
-    },
-    // Optional tab-completion:
-    Complete: func(prefix string, ctx ext.Context) []string {
-        return []string{"hello", "world"}
-    },
-})
-```
-
-Slash commands run in a dedicated goroutine (not a `tea.Cmd`), so they can safely block on prompts, I/O, etc.
-
----
-
-## Registering Keyboard Shortcuts
-
-```go
-api.RegisterShortcut(ext.ShortcutDef{
-    Key:         "ctrl+alt+p",
-    Description: "Toggle plan mode",
-}, func(ctx ext.Context) {
-    // handler runs when shortcut is pressed
-})
-```
-
----
-
-## Registering Options
-
-Options are configurable values resolved from env vars, config, or defaults:
-
-```go
-api.RegisterOption(ext.OptionDef{
-    Name:        "my-setting",
-    Description: "Controls something",
-    Default:     "false",
-})
-
-// Read at runtime (resolution: env KIT_OPT_MY_SETTING > config options.my-setting > default):
-val := ctx.GetOption("my-setting")
-
-// Set at runtime:
-ctx.SetOption("my-setting", "true")
-```
-
----
-
-## Context API Reference
-
-The `ext.Context` struct provides runtime capabilities via function fields.
-
-### Output
-
-```go
-ctx.Print("plain text")                    // plain output
-ctx.PrintInfo("styled info block")         // bordered info block
-ctx.PrintError("styled error block")       // red error block
-ctx.PrintBlock(ext.PrintBlockOpts{         // custom styled block
-    Text:        "content",
-    BorderColor: "#a6e3a1",
-    Subtitle:    "my-ext",
-})
-ctx.RenderMessage("renderer-name", "content")  // use a registered message renderer
-```
-
-### Message Injection
-
-```go
-ctx.SendMessage("prompt text")     // inject message and trigger agent turn (queued)
-ctx.CancelAndSend("new prompt")   // cancel current turn, clear queue, send new message
-```
-
-### Widgets
-
-Persistent UI elements displayed above or below the input area:
-
-```go
-ctx.SetWidget(ext.WidgetConfig{
-    ID:        "my-widget",
-    Placement: ext.WidgetAbove,  // or ext.WidgetBelow
-    Content:   ext.WidgetContent{
-        Text:     "Status: Active",
-        Markdown: false,  // set true for markdown rendering
-    },
-    Style: ext.WidgetStyle{
-        BorderColor: "#a6e3a1",  // hex color
-        NoBorder:    false,
-    },
-    Priority: 0,  // lower values render first
-})
-
-ctx.RemoveWidget("my-widget")
-```
-
-### Header and Footer
-
-```go
-ctx.SetHeader(ext.HeaderFooterConfig{
-    Content: ext.WidgetContent{Text: "My Header"},
-    Style:   ext.WidgetStyle{BorderColor: "#89b4fa"},
-})
-ctx.RemoveHeader()
-
-ctx.SetFooter(ext.HeaderFooterConfig{
-    Content: ext.WidgetContent{Text: "My Footer"},
-    Style:   ext.WidgetStyle{BorderColor: "#585b70"},
-})
-ctx.RemoveFooter()
-```
-
-### Status Bar
-
-```go
-ctx.SetStatus("key", "PLAN MODE", 10)  // key, text, priority (lower = further left)
-ctx.RemoveStatus("key")
-```
-
-### Interactive Prompts
-
-These block until the user responds (safe in slash commands and goroutines):
-
-```go
-// Selection list
-result := ctx.PromptSelect(ext.PromptSelectConfig{
-    Message: "Pick one:",
-    Options: []string{"Option A", "Option B", "Option C"},
-})
-if !result.Cancelled {
-    // result.Value string, result.Index int
-}
-
-// Yes/No confirmation
-result := ctx.PromptConfirm(ext.PromptConfirmConfig{
-    Message:      "Are you sure?",
-    DefaultValue: false,
-})
-if !result.Cancelled {
-    // result.Value bool
-}
-
-// Text input
-result := ctx.PromptInput(ext.PromptInputConfig{
-    Message:     "Enter name:",
-    Placeholder: "my-project",
-    Default:     "",
-})
-if !result.Cancelled {
-    // result.Value string
-}
-```
-
-### Overlay Dialogs
-
-Modal dialogs with optional action buttons:
-
-```go
-result := ctx.ShowOverlay(ext.OverlayConfig{
-    Title:   "Confirmation",
-    Content: ext.WidgetContent{Text: "Are you sure you want to proceed?", Markdown: true},
-    Style:   ext.OverlayStyle{BorderColor: "#f38ba8"},
-    Width:   60,          // 0 = 60% of terminal width
-    MaxHeight: 20,        // 0 = 80% of terminal height
-    Anchor:  ext.OverlayCenter,  // or ext.OverlayTopCenter, ext.OverlayBottomCenter
-    Actions: []string{"Confirm", "Cancel"},
-})
-if !result.Cancelled {
-    // result.Action string, result.Index int
-}
-```
-
-### Editor Interceptor
-
-Wrap the built-in text input with custom key handling and rendering:
-
-```go
-ctx.SetEditor(ext.EditorConfig{
-    HandleKey: func(key string, currentText string) ext.EditorKeyAction {
-        if key == "ctrl+s" {
-            return ext.EditorKeyAction{Type: ext.EditorKeySubmit, SubmitText: currentText}
-        }
-        return ext.EditorKeyAction{Type: ext.EditorKeyPassthrough}
-    },
-    Render: func(width int, defaultContent string) string {
-        return "[custom] " + defaultContent
-    },
-})
-
-ctx.ResetEditor()                  // remove interceptor
-ctx.SetEditorText("prefilled")     // set editor text content
-```
-
-**EditorKeyAction types:**
-- `ext.EditorKeyPassthrough` — let the default editor handle the key
-- `ext.EditorKeyConsumed` — swallow the key, do nothing
-- `ext.EditorKeyRemap` — remap to a different key: `EditorKeyAction{Type: ext.EditorKeyRemap, RemappedKey: "up"}`
-- `ext.EditorKeySubmit` — submit text: `EditorKeyAction{Type: ext.EditorKeySubmit, SubmitText: "text"}`
-
-### UI Visibility
-
-```go
-ctx.SetUIVisibility(ext.UIVisibility{
-    HideStartupMessage: true,
-    HideStatusBar:      true,
-    HideSeparator:      true,
-    HideInputHint:      true,
-})
-```
-
-### Session Data
-
-```go
-stats := ctx.GetContextStats()     // .EstimatedTokens, .ContextLimit, .UsagePercent, .MessageCount
-msgs := ctx.GetMessages()          // []ext.SessionMessage on current branch
-path := ctx.GetSessionPath()       // file path of session JSONL
-
-// Persist custom data in the session tree:
-id, err := ctx.AppendEntry("my-type", "data string")
-entries := ctx.GetEntries("my-type")  // []ext.ExtensionEntry{ID, EntryType, Data, Timestamp}
-```
-
-### Model Management
-
-```go
-err := ctx.SetModel("anthropic/claude-sonnet-4-20250514")
-models := ctx.GetAvailableModels()  // []ext.ModelInfoEntry
-```
-
-### Tool Management
-
-```go
-tools := ctx.GetAllTools()              // []ext.ToolInfo{Name, Description, Source, Enabled}
-ctx.SetActiveTools([]string{"read", "grep"})  // restrict to these tools only
-ctx.SetActiveTools(nil)                 // re-enable all tools
-```
-
-### LLM Completions
-
-Make standalone LLM calls (bypasses the agent tool loop):
-
-```go
-resp, err := ctx.Complete(ext.CompleteRequest{
-    Model:    "",             // empty = current model
-    System:   "You are ...",  // optional system prompt
-    Prompt:   "Summarize...", // the prompt
-    MaxTokens: 1000,          // 0 = provider default
-    OnChunk:  func(chunk string) { /* streaming */ },
-})
-// resp.Text, resp.InputTokens, resp.OutputTokens, resp.Model
-```
-
-### TUI Suspension
-
-Temporarily release the terminal for interactive subprocesses:
-
-```go
-ctx.SuspendTUI(func() {
-    cmd := exec.Command("vim", "file.go")
-    cmd.Stdin = os.Stdin
-    cmd.Stdout = os.Stdout
-    cmd.Stderr = os.Stderr
-    cmd.Run()
-})
-```
-
-### Application Control
-
-```go
-ctx.Exit()                        // graceful shutdown
-err := ctx.ReloadExtensions()     // hot-reload all extensions from disk
-```
-
-### Context Fields
-
-```go
-ctx.SessionID    // string
-ctx.CWD          // string — current working directory
-ctx.Model        // string — active model name
-ctx.Interactive  // bool — true if running in TUI mode
-```
-
----
-
-## Tool Renderers
-
-Customize how tool calls are displayed in the TUI:
-
-```go
-api.RegisterToolRenderer(ext.ToolRenderConfig{
-    ToolName:     "bash",
-    DisplayName:  "Shell",           // replaces auto-capitalized name
-    BorderColor:  "#89b4fa",
-    Background:   "",
-    BodyMarkdown: true,              // render body through markdown
-    RenderHeader: func(toolArgs string, width int) string {
-        var args struct{ Command string `json:"command"` }
-        json.Unmarshal([]byte(toolArgs), &args)
-        return "$ " + args.Command
-    },
-    RenderBody: func(toolResult string, isError bool, width int) string {
-        if isError {
-            return "ERROR: " + toolResult
-        }
-        return toolResult
-    },
-})
-```
-
-## Message Renderers
-
-Define named output styles for `ctx.RenderMessage()`:
-
-```go
-api.RegisterMessageRenderer(ext.MessageRendererConfig{
-    Name: "success",
-    Render: func(content string, width int) string {
-        return "  " + content  // green checkmark prefix
-    },
-})
-
-// Usage in handlers:
-ctx.RenderMessage("success", "All tests passed")
-```
-
----
-
-## Critical Yaegi Constraints
-
-### No Named Function References in Struct Fields
-
-Yaegi has a bug where named function references assigned to struct fields return zero values across the interpreter boundary. Always use anonymous closure literals:
-
-```go
-// WRONG - will silently return zero values:
-func myHandler(key, text string) ext.EditorKeyAction {
-    return ext.EditorKeyAction{Type: ext.EditorKeyPassthrough}
-}
-ctx.SetEditor(ext.EditorConfig{HandleKey: myHandler})
-
-// CORRECT - use anonymous closure:
-ctx.SetEditor(ext.EditorConfig{
-    HandleKey: func(key, text string) ext.EditorKeyAction {
-        return ext.EditorKeyAction{Type: ext.EditorKeyPassthrough}
-    },
-})
-```
-
-This applies to ALL struct fields that take function values: `ToolDef.Execute`, `CommandDef.Execute`, `EditorConfig.HandleKey`, `EditorConfig.Render`, `ToolRenderConfig.RenderHeader`, `ToolRenderConfig.RenderBody`, etc.
-
-### No Interfaces Across the Boundary
-
-All extension-facing API types are concrete structs, never interfaces. Yaegi crashes on interface wrapper generation.
-
-### Package-Level Variables for State
-
-Yaegi supports package-level variables captured in closures. This is the standard way to maintain state across event callbacks:
-
-```go
-package main
-
-import "kit/ext"
-
-var callCount int
-var lastTool string
-
-func Init(api ext.API) {
-    api.OnToolResult(func(e ext.ToolResultEvent, ctx ext.Context) *ext.ToolResultResult {
-        callCount++
-        lastTool = e.ToolName
-        return nil
-    })
-}
-```
-
----
-
-## Common Patterns
-
-### Pattern: Tool Call Blocking
-
-Block dangerous operations by intercepting tool calls:
-
-```go
-api.OnToolCall(func(tc ext.ToolCallEvent, ctx ext.Context) *ext.ToolCallResult {
-    if tc.ToolName == "bash" {
-        var input struct{ Command string `json:"command"` }
-        json.Unmarshal([]byte(tc.Input), &input)
-        if strings.Contains(input.Command, "rm -rf") {
-            return &ext.ToolCallResult{
-                Block:  true,
-                Reason: "Dangerous command blocked",
-            }
-        }
-    }
-    return nil
-})
-```
-
-### Pattern: System Prompt Injection
-
-Augment the agent's behavior by injecting instructions:
-
-```go
-api.OnBeforeAgentStart(func(_ ext.BeforeAgentStartEvent, ctx ext.Context) *ext.BeforeAgentStartResult {
-    prompt := "Always respond with bullet points."
-    return &ext.BeforeAgentStartResult{SystemPrompt: &prompt}
-})
-```
-
-### Pattern: Background Processing with SendMessage
-
-Run work in a goroutine and inject results back:
-
-```go
-api.RegisterCommand(ext.CommandDef{
-    Name: "run",
-    Description: "Run a command in the background",
-    Execute: func(args string, ctx ext.Context) (string, error) {
-        go func() {
-            out, err := exec.Command("sh", "-c", args).CombinedOutput()
-            if err != nil {
-                ctx.SendMessage(fmt.Sprintf("Command failed: %s\n%s", err, out))
-                return
-            }
-            ctx.SendMessage(fmt.Sprintf("Command output:\n```\n%s\n```", out))
-        }()
-        return "Running in background...", nil
-    },
-})
-```
-
-### Pattern: Ephemeral Context Injection
-
-Inject information into every LLM turn without persisting in session history:
-
-```go
-api.OnContextPrepare(func(e ext.ContextPrepareEvent, ctx ext.Context) *ext.ContextPrepareResult {
-    data, err := os.ReadFile(".kit/context.md")
-    if err != nil {
-        return nil
-    }
-    injected := ext.ContextMessage{
-        Index:   -1,  // -1 = new message, not from session
-        Role:    "system",
-        Content: string(data),
-    }
-    msgs := append([]ext.ContextMessage{injected}, e.Messages...)
-    return &ext.ContextPrepareResult{Messages: msgs}
-})
-```
-
-### Pattern: Live Widget Updates
-
-Update a widget periodically from a goroutine:
-
-```go
-api.OnSessionStart(func(_ ext.SessionStartEvent, ctx ext.Context) {
-    go func() {
-        ticker := time.NewTicker(time.Second)
-        defer ticker.Stop()
-        for range ticker.C {
-            ctx.SetWidget(ext.WidgetConfig{
-                ID:        "clock",
-                Placement: ext.WidgetAbove,
-                Content:   ext.WidgetContent{Text: time.Now().Format("15:04:05")},
-                Style:     ext.WidgetStyle{BorderColor: "#89b4fa"},
-            })
-        }
-    }()
-})
-```
-
-### Pattern: Spawning Kit as a Sub-Agent
-
-Extensions can spawn Kit as a subprocess for delegation:
-
-```bash
-kit --quiet --no-session --no-extensions --system-prompt "You are a reviewer" --model anthropic/claude-sonnet-4-20250514 "Review this code"
-```
-
-Key flags: `--quiet` (stdout only, no TUI), `--no-session` (ephemeral), `--no-extensions` (prevent recursion), `--system-prompt` (string or file path).
-
----
-
-## Testing Extensions
-
-```bash
-# Validate syntax of all discovered extensions
-kit extensions validate
-
-# List loaded extensions
-kit extensions list
-
-# Run with a specific extension
-kit -e path/to/extension.go
-
-# Run with multiple extensions
-kit -e ext1.go -e ext2.go
-
-# Disable all extensions
-kit --no-extensions
-
-# Generate an example extension scaffold
-kit extensions init
-```
-
----
-
-## Complete Example: Plan Mode
-
-A full extension that restricts the agent to read-only tools, with a slash command, keyboard shortcut, option, status bar indicator, and system prompt injection:
-
-```go
-//go:build ignore
-
-package main
-
-import (
-    "strings"
-    "kit/ext"
-)
-
-func Init(api ext.API) {
-    readOnlyTools := []string{"read", "grep", "find", "ls"}
-    var planActive bool
-
-    api.RegisterOption(ext.OptionDef{
-        Name:        "plan",
-        Description: "Start in plan mode (read-only tools)",
-        Default:     "false",
-    })
-
-    api.RegisterShortcut(ext.ShortcutDef{
-        Key:         "ctrl+alt+p",
-        Description: "Toggle plan/explore mode",
-    }, func(ctx ext.Context) {
-        planActive = !planActive
-        applyMode(ctx, planActive, readOnlyTools)
-    })
-
-    api.RegisterCommand(ext.CommandDef{
-        Name:        "plan",
-        Description: "Toggle plan/explore mode",
-        Execute: func(args string, ctx ext.Context) (string, error) {
-            planActive = !planActive
-            applyMode(ctx, planActive, readOnlyTools)
-            return "", nil
-        },
-    })
-
-    api.OnSessionStart(func(_ ext.SessionStartEvent, ctx ext.Context) {
-        if strings.ToLower(ctx.GetOption("plan")) == "true" {
-            planActive = true
-            applyMode(ctx, true, readOnlyTools)
-        }
-    })
-
-    api.OnBeforeAgentStart(func(_ ext.BeforeAgentStartEvent, ctx ext.Context) *ext.BeforeAgentStartResult {
-        if !planActive {
-            return nil
-        }
-        prompt := `You are in PLAN MODE (read-only). You can ONLY read and search.
-Focus on understanding, analysis, and generating plans.`
-        return &ext.BeforeAgentStartResult{SystemPrompt: &prompt}
-    })
-}
-
-func applyMode(ctx ext.Context, active bool, tools []string) {
-    if active {
-        ctx.SetActiveTools(tools)
-        ctx.SetStatus("plan-mode", "PLAN MODE (read-only)", 10)
-        ctx.PrintInfo("Plan mode ON")
-    } else {
-        ctx.SetActiveTools(nil)
-        ctx.RemoveStatus("plan-mode")
-        ctx.PrintInfo("Plan mode OFF")
-    }
-}
-```
-
-## Key Files for Reference
-
-- [`internal/extensions/api.go`](https://github.com/mark3labs/kit/blob/main/internal/extensions/api.go) — Complete API type definitions
-- [`internal/extensions/runner.go`](https://github.com/mark3labs/kit/blob/main/internal/extensions/runner.go) — Event dispatch and state management
-- [`internal/extensions/loader.go`](https://github.com/mark3labs/kit/blob/main/internal/extensions/loader.go) — Yaegi interpreter setup
-- [`internal/extensions/symbols.go`](https://github.com/mark3labs/kit/blob/main/internal/extensions/symbols.go) — All types exported to extensions
-- [`examples/extensions/`](https://github.com/mark3labs/kit/tree/main/examples/extensions) — 25+ working example extensions

.github/workflows/pages.yml

@@ -0,0 +1,32 @@
+name: Build and Deploy Docs to GitHub Pages
+
+on:
+  push:
+    branches: [master]
+  workflow_dispatch:
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Install Dependencies
+        working-directory: ./www
+        run: bun install
+
+      - name: Build
+        working-directory: ./www
+        run: bun run build
+
+      - name: Deploy to GitHub Pages
+        uses: JamesIves/github-pages-deploy-action@v4
+        with:
+          folder: www/out
+          branch: gh-pages

.gitignore

@@ -1,14 +1,16 @@
 .aider*
 .task/
 .env
-.kit/
+.kit/*
+!.kit/extensions/
 aidocs/
 *.log
 /kit
 .idea
-test/
 build/
 dist/
 contribute/output/
 CONTEXT.md
 output/
+.agents/
+skills-lock.json

.kit/extensions/go-edit-lint.go

@@ -0,0 +1,228 @@
+//go:build ignore
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"kit/ext"
+)
+
+const (
+	diagnosticsTimeout = 20 * time.Second
+	maxOutputBytes     = 12_000
+)
+
+type toolPathInput struct {
+	Path string `json:"path"`
+}
+
+type lintResult struct {
+	Output string
+	Err    error
+}
+
+func Init(api ext.API) {
+	api.OnSessionStart(func(_ ext.SessionStartEvent, ctx ext.Context) {
+		ctx.Print("go-edit-lint extension loaded - will run gopls and golangci-lint on Go file edits")
+	})
+
+	api.OnToolResult(func(e ext.ToolResultEvent, ctx ext.Context) *ext.ToolResultResult {
+		if e.IsError || !isEditOrWrite(e.ToolName) {
+			return nil
+		}
+
+		absPath, ok := resolveGoFilePath(e.Input, ctx.CWD)
+		if !ok {
+			return nil
+		}
+
+		report := runGoDiagnostics(ctx.CWD, absPath)
+		
+		// Check if there are issues and add explicit prompt for the LLM to react
+		goplsIssues, lintIssues := countIssues(report)
+		hasIssues := goplsIssues > 0 || lintIssues > 0
+		
+		var enhanced string
+		if hasIssues {
+			enhanced = e.Content + "\n\n" + report + "\n\n⚠️ DIAGNOSTICS FOUND: Please review the issues above and fix them before proceeding."
+		} else {
+			enhanced = e.Content + "\n\n" + report
+		}
+
+		// Show TUI message block for diagnostics visibility (only if there are issues)
+		if hasIssues {
+			var msgLines []string
+			msgLines = append(msgLines, fmt.Sprintf("File: %s", filepath.Base(absPath)))
+			if goplsIssues > 0 {
+				msgLines = append(msgLines, fmt.Sprintf("gopls: %d issue(s)", goplsIssues))
+			}
+			if lintIssues > 0 {
+				msgLines = append(msgLines, fmt.Sprintf("golangci-lint: %d issue(s)", lintIssues))
+			}
+			msgLines = append(msgLines, "", "⚠️ Please fix these issues before proceeding.")
+
+			borderColor := "#f9e2af" // yellow
+			if goplsIssues > 0 && lintIssues > 0 {
+				borderColor = "#f38ba8" // red
+			}
+
+			ctx.PrintBlock(ext.PrintBlockOpts{
+				Text:        strings.Join(msgLines, "\n"),
+				BorderColor: borderColor,
+				Subtitle:    "go-edit-lint",
+			})
+		}
+
+		return &ext.ToolResultResult{Content: &enhanced}
+	})
+}
+
+func isEditOrWrite(toolName string) bool {
+	return strings.EqualFold(toolName, "edit") || strings.EqualFold(toolName, "write")
+}
+
+func resolveGoFilePath(inputJSON, cwd string) (string, bool) {
+	var args toolPathInput
+	if err := json.Unmarshal([]byte(inputJSON), &args); err != nil || args.Path == "" {
+		return "", false
+	}
+
+	absPath := args.Path
+	if !filepath.IsAbs(absPath) {
+		absPath = filepath.Join(cwd, absPath)
+	}
+
+	if strings.ToLower(filepath.Ext(absPath)) != ".go" {
+		return "", false
+	}
+
+	return absPath, true
+}
+
+func runGoDiagnostics(cwd, absPath string) string {
+	gopls := runGopls(cwd, absPath)
+	lint := runGolangCILint(cwd, "./...")
+
+	return fmt.Sprintf(
+		"<go_diagnostics file=%q>\n[gopls]\n%s\n\n[golangci-lint]\n%s\n</go_diagnostics>",
+		filepath.Base(absPath),
+		formatToolResult(gopls, "No diagnostics."),
+		formatToolResult(lint, "No lint issues."),
+	)
+}
+
+func runGopls(cwd, absPath string) lintResult {
+	ctx, cancel := context.WithTimeout(context.Background(), diagnosticsTimeout)
+	defer cancel()
+
+	cmd := exec.CommandContext(ctx, "gopls", "check", absPath)
+	cmd.Dir = cwd
+	out, err := cmd.CombinedOutput()
+
+	if ctx.Err() == context.DeadlineExceeded {
+		return lintResult{Err: fmt.Errorf("timed out after %s", diagnosticsTimeout)}
+	}
+
+	if err != nil {
+		return lintResult{Output: truncate(string(out), maxOutputBytes), Err: fmt.Errorf("failed to run gopls check: %w", err)}
+	}
+
+	return lintResult{Output: truncate(string(out), maxOutputBytes)}
+}
+
+func runGolangCILint(cwd, target string) lintResult {
+	ctx, cancel := context.WithTimeout(context.Background(), diagnosticsTimeout)
+	defer cancel()
+
+	args := []string{
+		"run",
+		target,
+		"--show-stats=false",
+		"--output.text.path", "stdout",
+		"--output.text.colors=false",
+		"--output.text.print-issued-lines=false",
+	}
+	cmd := exec.CommandContext(ctx, "golangci-lint", args...)
+	cmd.Dir = cwd
+	out, err := cmd.CombinedOutput()
+
+	if ctx.Err() == context.DeadlineExceeded {
+		return lintResult{Err: fmt.Errorf("timed out after %s", diagnosticsTimeout)}
+	}
+
+	trimmed := truncate(string(out), maxOutputBytes)
+	if err == nil {
+		return lintResult{Output: trimmed}
+	}
+
+	exitErr, ok := err.(*exec.ExitError)
+	if ok && exitErr.ExitCode() == 1 {
+		return lintResult{Output: trimmed}
+	}
+
+	return lintResult{Output: trimmed, Err: fmt.Errorf("failed to run golangci-lint: %w", err)}
+}
+
+func formatToolResult(res lintResult, emptyFallback string) string {
+	var lines []string
+	if res.Err != nil {
+		lines = append(lines, "ERROR: "+res.Err.Error())
+	}
+	out := strings.TrimSpace(res.Output)
+	if out == "" {
+		if res.Err == nil {
+			lines = append(lines, emptyFallback)
+		}
+	} else {
+		lines = append(lines, out)
+	}
+	if len(lines) == 0 {
+		return emptyFallback
+	}
+	return strings.Join(lines, "\n")
+}
+
+func truncate(s string, max int) string {
+	if len(s) <= max {
+		return s
+	}
+	return s[:max] + "\n... output truncated ..."
+}
+
+func countIssues(report string) (goplsCount, lintCount int) {
+	// Extract gopls section
+	goplsStart := strings.Index(report, "[gopls]")
+	lintStart := strings.Index(report, "[golangci-lint]")
+	endTag := strings.Index(report, "</go_diagnostics>")
+
+	if goplsStart != -1 && lintStart != -1 {
+		goplsSection := report[goplsStart:lintStart]
+		// Count non-empty lines excluding the header and "No diagnostics." message
+		for _, line := range strings.Split(goplsSection, "\n") {
+			line = strings.TrimSpace(line)
+			if line != "" && line != "[gopls]" && line != "No diagnostics." {
+				goplsCount++
+			}
+		}
+	}
+
+	if lintStart != -1 && endTag != -1 {
+		lintSection := report[lintStart:endTag]
+		// Count non-empty lines excluding the header and "No lint issues." message
+		for _, line := range strings.Split(lintSection, "\n") {
+			line = strings.TrimSpace(line)
+			if line != "" && line != "[golangci-lint]" && line != "No lint issues." {
+				lintCount++
+			}
+		}
+	}
+
+	return goplsCount, lintCount
+}

.kit/extensions/subagent-monitor.go

@@ -0,0 +1,304 @@
+//go:build ignore
+
+// subagent-monitor — live horizontal widget strip for spawned subagents
+//
+// Subscribes to subagents spawned by the main Kit agent and displays a
+// single widget just above the input box. Each subagent occupies one column
+// in a side-by-side horizontal layout. Columns show scrolling real-time
+// output as the subagent works. When a subagent finishes its column is
+// removed automatically.
+//
+// Yaegi-safe design notes:
+// - No sync.Mutex (Yaegi has reflection issues with sync primitives)
+// - No channels in maps (Yaegi panics on range over map[string]chan)
+// - All ctx.* calls guarded with nil checks
+// - Simple data structures only
+package main
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"kit/ext"
+)
+
+// ---------------------------------------------------------------------------
+// Per-subagent state
+// ---------------------------------------------------------------------------
+
+type submonEntry struct {
+	id      int
+	callID  string
+	task    string
+	lines   []string
+	started time.Time
+	elapsed time.Duration
+}
+
+const (
+	submonColWidth = 34 // visible character width per column
+	submonMaxLines = 5  // scrolling output lines per column
+	submonColGap   = 2  // spaces between columns
+)
+
+// ---------------------------------------------------------------------------
+// Package-level state - all simple types
+// ---------------------------------------------------------------------------
+
+var (
+	submonCtx     ext.Context
+	submonHasCtx  bool
+	submonEntries []*submonEntry
+	submonNextID  int
+)
+
+func submonInit() {
+	submonEntries = nil
+	submonNextID = 1
+}
+
+// ---------------------------------------------------------------------------
+// String helpers
+// ---------------------------------------------------------------------------
+
+func submonPad(s string, w int) string {
+	r := []rune(s)
+	if len(r) >= w {
+		return string(r[:w])
+	}
+	return s + strings.Repeat(" ", w-len(r))
+}
+
+func submonTrunc(s string, w int) string {
+	r := []rune(s)
+	if len(r) <= w {
+		return s
+	}
+	if w <= 1 {
+		return "…"
+	}
+	return string(r[:w-1]) + "…"
+}
+
+// ---------------------------------------------------------------------------
+// Widget rendering
+// ---------------------------------------------------------------------------
+
+func submonRenderColumn(e *submonEntry) []string {
+	var rows []string
+
+	// Calculate elapsed time on-demand to avoid race conditions with ticker
+	elapsed := e.elapsed
+	if elapsed == 0 && !e.started.IsZero() {
+		elapsed = time.Since(e.started)
+	}
+	secs := int(elapsed.Seconds())
+	timeStr := fmt.Sprintf("%ds", secs)
+	taskMax := submonColWidth - len(timeStr) - 3
+	taskPart := submonTrunc(e.task, taskMax)
+	header := fmt.Sprintf("#%d %s  %s", e.id, taskPart, timeStr)
+	rows = append(rows, submonPad(header, submonColWidth))
+
+	display := e.lines
+	if len(display) > submonMaxLines {
+		display = display[len(display)-submonMaxLines:]
+	}
+	for _, l := range display {
+		rows = append(rows, submonPad("  "+submonTrunc(l, submonColWidth-2), submonColWidth))
+	}
+	for len(rows) < submonMaxLines+1 {
+		if len(rows) == 1 && len(e.lines) == 0 {
+			rows = append(rows, submonPad("  waiting…", submonColWidth))
+		} else {
+			rows = append(rows, strings.Repeat(" ", submonColWidth))
+		}
+	}
+	return rows
+}
+
+func submonBuildWidget() string {
+	if len(submonEntries) == 0 {
+		return ""
+	}
+
+	numCols := len(submonEntries)
+	numRows := submonMaxLines + 1
+	cols := make([][]string, numCols)
+	for i, e := range submonEntries {
+		rows := submonRenderColumn(e)
+		col := make([]string, numRows)
+		for j := 0; j < numRows; j++ {
+			if j < len(rows) {
+				col[j] = rows[j]
+			} else {
+				col[j] = strings.Repeat(" ", submonColWidth)
+			}
+		}
+		cols[i] = col
+	}
+
+	gap := strings.Repeat(" ", submonColGap)
+	var sb strings.Builder
+	for row := 0; row < numRows; row++ {
+		for ci := range cols {
+			if ci > 0 {
+				sb.WriteString(gap)
+			}
+			sb.WriteString(cols[ci][row])
+		}
+		if row < numRows-1 {
+			sb.WriteString("\n")
+		}
+	}
+	return sb.String()
+}
+
+func submonPushWidget() {
+	if !submonHasCtx {
+		return
+	}
+	if submonCtx.SetWidget == nil {
+		return
+	}
+
+	text := submonBuildWidget()
+	if len(submonEntries) == 0 {
+		if submonCtx.RemoveWidget != nil {
+			submonCtx.RemoveWidget("submon")
+		}
+		return
+	}
+	submonCtx.SetWidget(ext.WidgetConfig{
+		ID:        "submon",
+		Placement: ext.WidgetAbove,
+		Content:   ext.WidgetContent{Text: text},
+		Style:     ext.WidgetStyle{BorderColor: "#89b4fa"},
+		Priority:  0,
+	})
+}
+
+func submonAppendLine(e *submonEntry, line string) {
+	line = strings.TrimRight(line, "\r\n")
+	if strings.TrimSpace(line) == "" {
+		return
+	}
+	e.lines = append(e.lines, line)
+}
+
+// ---------------------------------------------------------------------------
+// Init
+// ---------------------------------------------------------------------------
+
+func Init(api ext.API) {
+	submonInit()
+
+	api.OnSessionStart(func(_ ext.SessionStartEvent, ctx ext.Context) {
+		submonCtx = ctx
+		submonHasCtx = true
+		submonInit()
+		if ctx.RemoveWidget != nil {
+			ctx.RemoveWidget("submon")
+		}
+	})
+
+	api.OnAgentEnd(func(_ ext.AgentEndEvent, ctx ext.Context) {
+		submonCtx = ctx
+		submonHasCtx = true
+	})
+
+	// ── SubagentStart ────────────────────────────────────────────────────────
+	api.OnSubagentStart(func(e ext.SubagentStartEvent, ctx ext.Context) {
+		submonCtx = ctx
+		submonHasCtx = true
+
+		id := submonNextID
+		submonNextID++
+		entry := &submonEntry{
+			id:      id,
+			callID:  e.ToolCallID,
+			task:    e.Task,
+			started: time.Now(),
+		}
+		submonEntries = append(submonEntries, entry)
+
+		submonPushWidget()
+	})
+
+	// ── SubagentChunk ────────────────────────────────────────────────────────
+	api.OnSubagentChunk(func(e ext.SubagentChunkEvent, ctx ext.Context) {
+		submonCtx = ctx
+		submonHasCtx = true
+
+		var entry *submonEntry
+		for _, en := range submonEntries {
+			if en.callID == e.ToolCallID {
+				entry = en
+				break
+			}
+		}
+		if entry == nil {
+			return
+		}
+
+		switch e.ChunkType {
+		case "text":
+			for _, line := range strings.Split(e.Content, "\n") {
+				submonAppendLine(entry, line)
+			}
+		case "tool_call":
+			submonAppendLine(entry, "→ "+e.ToolName)
+		case "tool_execution_start":
+			submonAppendLine(entry, "⚙ "+e.ToolName)
+		case "tool_result":
+			if e.IsError {
+				submonAppendLine(entry, "✗ "+e.ToolName)
+			} else {
+				submonAppendLine(entry, "✓ "+e.ToolName)
+			}
+		}
+
+		submonPushWidget()
+	})
+
+	// ── SubagentEnd ──────────────────────────────────────────────────────────
+	api.OnSubagentEnd(func(e ext.SubagentEndEvent, ctx ext.Context) {
+		submonCtx = ctx
+		submonHasCtx = true
+
+		var entry *submonEntry
+		for _, en := range submonEntries {
+			if en.callID == e.ToolCallID {
+				entry = en
+				break
+			}
+		}
+		if entry != nil {
+			entry.elapsed = time.Since(entry.started)
+			if e.ErrorMsg != "" {
+				submonAppendLine(entry, "✗ "+submonTrunc(e.ErrorMsg, submonColWidth-2))
+			}
+		}
+
+		submonPushWidget()
+
+		// Remove the entry immediately (no goroutine to avoid races)
+		newEntries := submonEntries[:0]
+		for _, en := range submonEntries {
+			if en.callID != e.ToolCallID {
+				newEntries = append(newEntries, en)
+			}
+		}
+		submonEntries = newEntries
+		submonPushWidget()
+	})
+
+	// ── SessionShutdown ──────────────────────────────────────────────────────
+	api.OnSessionShutdown(func(_ ext.SessionShutdownEvent, ctx ext.Context) {
+		submonInit()
+		// Guard ctx access - may be nil during shutdown
+		if ctx.RemoveWidget != nil {
+			ctx.RemoveWidget("submon")
+		}
+	})
+}

README.md

@@ -18,9 +18,12 @@ A powerful, extensible AI coding agent CLI with multi-provider support, built-in
 ## Features
 
 - **Multi-Provider LLM Support**: Anthropic, OpenAI, Google Gemini, Ollama, Azure OpenAI, AWS Bedrock, OpenRouter, and more
-- **Built-in Core Tools**: bash, read, write, edit, grep, find, ls - no MCP overhead
+- **Built-in Core Tools**: bash, read, write, edit, grep, find, ls, subagent - no MCP overhead
 - **MCP Integration**: Connect external MCP servers for expanded capabilities
 - **Extension System**: Write custom tools, commands, widgets, and UI modifications in Go
+- **Theming**: 22 built-in color themes (KITT, Catppuccin, Dracula, Nord, etc.) with runtime switching, persistence, and custom theme files
+- **Model Persistence**: Model and thinking level selections are automatically saved and restored across sessions
+- **Prompt Templates**: Create reusable prompt templates with shell-style argument substitution
 - **Interactive TUI**: Rich terminal interface powered by Bubble Tea with streaming, syntax highlighting, and custom rendering
 - **Session Management**: Tree-based conversation history with branching support
 - **Non-Interactive Mode**: Script-friendly positional args with JSON output
@@ -29,10 +32,14 @@ A powerful, extensible AI coding agent CLI with multi-provider support, built-in
 
 ## Installation
 
-### Using npm (recommended)
+### Using npm / bun / pnpm
 
 ```bash
 npm install -g @mark3labs/kit
+# or
+bun install -g @mark3labs/kit
+# or
+pnpm install -g @mark3labs/kit
 ```
 
 ### Using Go
@@ -66,8 +73,11 @@ kit @main.go @test.go "Review these files"
 # Continue the most recent session
 kit --continue
 
+# Model and thinking level selections are automatically persisted
+# across sessions and restored on next launch
+
 # Use specific model
-kit --model anthropic/claude-sonnet-4-5-20250929
+kit --model anthropic/claude-sonnet-latest
 ```
 
 ### Non-Interactive Mode
@@ -103,15 +113,15 @@ Kit looks for configuration in the following locations (in order of priority):
 
 1. CLI flags
 2. Environment variables (with `KIT_` prefix)
-3. `./.kit.yml` (project-local)
-4. `~/.kit.yml` (global)
+3. `./.kit.yml` / `./.kit.yaml` / `./.kit.json` (project-local)
+4. `~/.kit.yml` / `~/.kit.yaml` / `~/.kit.json` (global)
 
 ### Basic Configuration
 
 Create `~/.kit.yml`:
 
 ```yaml
-model: anthropic/claude-sonnet-4-5-20250929
+model: anthropic/claude-sonnet-latest
 max-tokens: 4096
 temperature: 0.7
 stream: true
@@ -172,6 +182,8 @@ mcpServers:
 # Extensions
 --extension, -e          Load additional extension file(s) (repeatable)
 --no-extensions          Disable all extensions
+--prompt-template        Load a specific prompt template by name
+--no-prompt-templates    Disable prompt template loading
 
 # Generation parameters
 --max-tokens             Maximum tokens in response (default: 4096)
@@ -179,6 +191,7 @@ mcpServers:
 --top-p                  Nucleus sampling 0.0-1.0 (default: 0.95)
 --top-k                  Limit top K tokens (default: 40)
 --stop-sequences         Custom stop sequences (comma-separated)
+--thinking-level         Extended thinking level: off, minimal, low, medium, high (default: off)
 
 # System
 --config                 Config file path (default: ~/.kit.yml)
@@ -190,28 +203,63 @@ mcpServers:
 
 ```bash
 # Authentication (for OAuth-enabled providers)
-kit auth login           # Start OAuth flow
-kit auth logout          # Remove credentials
-kit auth status          # Check authentication status
+kit auth login [provider]    # Start OAuth flow (e.g., anthropic)
+kit auth logout [provider]   # Remove credentials for provider
+kit auth status              # Check authentication status
 
 # Model database
-kit models               # List available models
-kit models --all         # Show all providers (not just Fantasy-compatible)
-kit update-models        # Update local model database from models.dev
+kit models [provider]        # List available models (optionally filter by provider)
+kit models --all             # Show all providers (not just Fantasy-compatible)
+kit update-models [source]   # Update model database (from models.dev, URL, file, or 'embedded')
 
 # Extension management
-kit extensions list      # List discovered extensions
-kit extensions validate  # Validate extension files
-kit extensions init      # Generate example extension template
+kit extensions list          # List discovered extensions
+kit extensions validate      # Validate extension files
+kit extensions init          # Generate example extension template
+kit install <git-url>        # Install extensions from git repositories
+kit install -l <git-url>     # Install to project-local .kit/git/ directory
+kit install -u <git-url>     # Update an already-installed package
+kit install --uninstall <pkg> # Remove an installed package
+
+# Skills
+kit skill                    # Install the Kit extensions skill via skills.sh
 
 # ACP server
-kit acp                  # Start as ACP agent (stdio JSON-RPC)
-kit acp --debug          # With debug logging to stderr
+kit acp                      # Start as ACP agent (stdio JSON-RPC)
+kit acp --debug              # With debug logging to stderr
 ```
 
+## Themes
+
+Kit ships with 22 built-in color themes that control all UI elements. Switch at runtime:
+
+```
+/theme dracula
+/theme catppuccin
+/theme tokyonight
+```
+
+Theme selections are automatically saved and restored on next launch (stored in `~/.config/kit/preferences.yml`). This persistence also applies to **model** and **thinking level** selections — all are saved together and restored on startup.
+
+### Custom themes
+
+Drop a `.yml` file in `~/.config/kit/themes/` (user) or `.kit/themes/` (project):
+
+```yaml
+# ~/.config/kit/themes/my-theme.yml
+primary:
+  light: "#8839ef"
+  dark: "#cba6f7"
+success:
+  light: "#40a02b"
+  dark: "#a6e3a1"
+```
+
+Built-in themes: `kitt`, `catppuccin`, `dracula`, `tokyonight`, `nord`, `gruvbox`, `monokai`, `solarized`, `github`, `one-dark`, `rose-pine`, `ayu`, `material`, `everforest`, `kanagawa`, `amoled`, `synthwave`, `vesper`, `flexoki`, `matrix`, `vercel`, `zenburn`
+
 ## Extension System
 
-Extensions are Go source files that run via Yaegi interpreter. They can add custom tools, slash commands, widgets, keyboard shortcuts, and intercept lifecycle events.
+Extensions are Go source files that run via Yaegi interpreter. They can add custom tools, slash commands, widgets, keyboard shortcuts, themes, and intercept lifecycle events.
 
 ### Minimal Extension
 
@@ -239,37 +287,79 @@ kit -e examples/extensions/minimal.go
 
 ### Extension Capabilities
 
-**Lifecycle Events**: OnSessionStart, OnSessionShutdown, OnAgentStart, OnAgentEnd, OnToolCall, OnToolResult, OnInput, OnMessageStart, OnMessageUpdate, OnMessageEnd, OnModelChange, OnContextPrepare, OnBeforeFork, OnBeforeSessionSwitch, OnBeforeCompact
+**Lifecycle Events**: OnSessionStart, OnSessionShutdown, OnBeforeAgentStart, OnAgentStart, OnAgentEnd, OnToolCall, OnToolExecutionStart, OnToolOutput, OnToolExecutionEnd, OnToolResult, OnInput, OnMessageStart, OnMessageUpdate, OnMessageEnd, OnModelChange, OnContextPrepare, OnBeforeFork, OnBeforeSessionSwitch, OnBeforeCompact, OnCustomEvent, OnSubagentStart, OnSubagentChunk, OnSubagentEnd
 
 **Custom Components**:
 - **Tools**: Add new tools the LLM can invoke
 - **Commands**: Register slash commands (e.g., `/mycommand`)
+- **Options**: Register configurable extension options
 - **Widgets**: Persistent status displays above/below input
+- **Headers/Footers**: Persistent content above/below the conversation
+- **Status Bar**: Custom status bar entries
 - **Shortcuts**: Global keyboard shortcuts
 - **Overlays**: Modal dialogs with markdown content
 - **Tool Renderers**: Customize how tool calls display
+- **Message Renderers**: Custom rendering for assistant messages
 - **Editor Interceptors**: Handle key events and wrap rendering
+- **Interactive Prompts**: Select, confirm, input, and multi-select dialogs
+- **Subagents**: Spawn in-process child Kit instances
+- **LLM Completion**: Direct model calls via `Complete()`
+- **Themes**: Register and switch color themes via `RegisterTheme`, `SetTheme`, `ListThemes`
+- **Custom Events**: Inter-extension communication via `EmitCustomEvent`
+
+**Bridged SDK APIs** (NEW): Extensions can now access internal SDK capabilities:
+- **Tree Navigation**: Navigate conversation history (`GetTreeNode`, `GetCurrentBranch`, `NavigateTo`), summarize branches (`SummarizeBranch`), and implement fresh context loops (`CollapseBranch`)
+- **Skill Loading**: Dynamically load and inject skills at runtime (`LoadSkill`, `DiscoverSkills`, `InjectSkillAsContext`)
+- **Template Parsing**: Parse and render templates with `{{variables}}` (`ParseTemplate`, `RenderTemplate`), parse CLI-style arguments (`ParseArguments`, `SimpleParseArguments`), and evaluate model conditionals (`EvaluateModelConditional`, `RenderWithModelConditionals`)
+- **Model Resolution**: Resolve model fallback chains (`ResolveModelChain`), query model capabilities (`GetModelCapabilities`, `CheckModelAvailable`), and extract provider/model ID (`GetCurrentProvider`, `GetCurrentModelID`)
 
 ### Extension Examples
 
 See the `examples/extensions/` directory:
 
 - `minimal.go` - Clean UI with custom footer
-- `notify.go` - Desktop notifications
-- `widget-status.go` - Persistent status widgets
-- `custom-editor-demo.go` - Vim-like modal editor
-- `prompt-demo.go` - Interactive prompts (select/confirm/input)
-- `tool-logger.go` - Log all tool calls
-- `overlay-demo.go` - Modal dialogs
-- `plan-mode.go` - Read-only planning mode
-- `subagent-widget.go` - Multi-agent orchestration
 - `auto-commit.go` - Auto-commit on shutdown
+- `bookmark.go` - Bookmark conversations
+- `branded-output.go` - Branded output rendering
+- `compact-notify.go` - Notification on compaction
+- `confirm-destructive.go` - Confirm destructive operations
+- `context-inject.go` - Inject context into conversations
+- `conversation-manager.go` - **NEW** Tree navigation, branch summarization, and fresh context loops
+- `custom-editor-demo.go` - Vim-like modal editor
+- `dev-reload.go` - Development live-reload
+- `header-footer-demo.go` - Custom headers and footers
+- `inline-bash.go` - Inline bash execution
+- `interactive-shell.go` - Interactive shell integration
+- `kit-kit.go` - Kit-in-Kit (sub-agent spawning)
+- `lsp-diagnostics.go` - LSP diagnostic integration
+- `notify.go` - Desktop notifications
+- `overlay-demo.go` - Modal dialogs
+- `permission-gate.go` - Permission gating for tools
+- `pirate.go` - Pirate-themed personality
+- `plan-mode.go` - Read-only planning mode
+- `project-rules.go` - Project-specific rules
+- `prompt-demo.go` - Interactive prompts (select/confirm/input)
+- `prompt-templates.go` - **NEW** Frontmatter-driven templates with model switching and skill injection
+- `protected-paths.go` - Path protection for sensitive files
+- `subagent-widget.go` - Multi-agent orchestration with status widget
+- `subagent-test.go` - Subagent testing utilities
+- `summarize.go` - Conversation summarization
+- `tool-logger.go` - Log all tool calls
+- `neon-theme.go` - Custom theme registration and switching
+- `tool-renderer-demo.go` - Custom tool call rendering
+- `widget-status.go` - Persistent status widgets
+
+Also see `.kit/extensions/go-edit-lint.go` (in this repo) for a project-local extension example that runs gopls and golangci-lint on Go file edits.
 
 ### Loading Extensions
 
 **Auto-discovery** (loads automatically):
-- `./.kit/extensions/*.go` (project-local)
-- `~/.config/kit/extensions/*.go` (global)
+- `~/.config/kit/extensions/*.go` (global single files)
+- `~/.config/kit/extensions/*/main.go` (global subdirectory extensions)
+- `.kit/extensions/*.go` (project-local single files)
+- `.kit/extensions/*/main.go` (project-local subdirectory extensions)
+- `~/.local/share/kit/git/` (global git-installed packages)
+- `.kit/git/` (project-local git-installed packages)
 
 **Explicit loading**:
 ```bash
@@ -282,13 +372,76 @@ kit -e ext1.go -e ext2.go  # Multiple extensions
 kit --no-extensions
 ```
 
+### Testing Extensions
+
+Kit provides a testing package to help you write unit tests for your extensions:
+
+```go
+package main
+
+import (
+    "testing"
+    "github.com/mark3labs/kit/pkg/extensions/test"
+    "github.com/mark3labs/kit/internal/extensions"
+)
+
+func TestMyExtension(t *testing.T) {
+    harness := test.New(t)
+    harness.LoadFile("my-ext.go")
+    
+    // Emit events and verify behavior
+    _, err := harness.Emit(extensions.SessionStartEvent{SessionID: "test"})
+    if err != nil {
+        t.Fatalf("unexpected error: %v", err)
+    }
+    
+    // Verify the extension printed something
+    test.AssertPrinted(t, harness, "session started")
+}
+```
+
+**Available assertions:**
+- `AssertBlocked()`, `AssertNotBlocked()` — Verify tool blocking
+- `AssertWidgetSet()`, `AssertWidgetText()` — Verify widget content
+- `AssertPrinted()`, `AssertPrintedContains()` — Verify output
+- `AssertToolRegistered()`, `AssertCommandRegistered()` — Verify registration
+
+See `examples/extensions/tool-logger_test.go` for a complete example with 14 test cases covering tool calls, input handling, and session lifecycle.
+
+### Prompt Templates
+
+Create reusable prompt templates with shell-style argument substitution. Templates are loaded from `~/.kit/prompts/*.md` and `.kit/prompts/*.md`.
+
+**Example template** (`~/.kit/prompts/review.md`):
+```markdown
+---
+description: Review code for issues
+---
+Review the following code for bugs and security issues.
+Focus on $1 specifically.
+```
+
+**Usage:**
+```
+/review error handling
+```
+
+**Argument placeholders:**
+- `$1`, `$2`, etc. — Individual arguments
+- `$@` or `$ARGUMENTS` — All arguments
+- `${@:2}` — Arguments from position 2 onwards
+- `${@:1:3}` — 3 arguments starting at position 1
+
+Disable templates with `--no-prompt-templates` or load a specific template with `--prompt-template <name>`.
+
 ## Session Management
 
 Kit uses a tree-based session model that supports branching and forking conversations.
 
 ### Session Locations
 
-- Default: `~/.local/share/kit/sessions/<cwd-hash>/<uuid>.jsonl`
+- Default: `~/.kit/sessions/<cwd-path>/<timestamp>_<id>.jsonl`
+- Path separators in the working directory are replaced with `--` (e.g., `/home/user/project` becomes `home--user--project`)
 - Each line is a session entry (messages, tool calls, extension data)
 - Supports branching from any message to explore alternate paths
 
@@ -311,6 +464,22 @@ kit -s path/to/session.jsonl
 kit --no-session
 ```
 
+### Interactive Session Commands
+
+During an interactive session, use these slash commands:
+
+| Command | Description |
+|---------|-------------|
+| `/name [name]` | Set or display the session's display name |
+| `/session` | Show session info (path, ID, message count) |
+| `/resume` | Open the session picker to switch sessions |
+| `/export [path]` | Export session as JSONL (auto-generates path if omitted) |
+| `/import <path>` | Import and switch to a session from a JSONL file |
+| `/share` | Upload session to GitHub Gist and get a shareable viewer URL |
+| `/tree` | Navigate the session tree |
+| `/fork` | Branch from an earlier message |
+| `/new` | Start a fresh session |
+
 ## Go SDK
 
 Embed Kit in your Go applications:
@@ -355,43 +524,74 @@ host, err := kit.New(ctx, &kit.Options{
     MaxSteps:     10,
     Streaming:    true,
     Quiet:        true,
+
+    // Session options
+    SessionPath:  "./session.jsonl",  // Open specific session
+    Continue:     true,                // Resume most recent session
+    NoSession:    true,                // Ephemeral mode
+
+    // Tool options
+    ExtraTools:   []kit.Tool{...},     // Additional tools alongside defaults
+
+    // Compaction
+    AutoCompact:  true,                // Auto-compact near context limit
+
+    Debug:        true,                // Debug logging
 })
 ```
 
 ### With Callbacks
 
 ```go
-response, err := host.PromptWithCallbacks(
+unsub := host.OnToolCall(func(e kit.ToolCallEvent) {
+    println("Calling tool:", e.ToolName)
+})
+defer unsub()
+
+unsub2 := host.OnToolResult(func(e kit.ToolResultEvent) {
+    if e.IsError {
+        println("Tool failed:", e.ToolName)
+    }
+})
+defer unsub2()
+
+unsub3 := host.OnStreaming(func(e kit.MessageUpdateEvent) {
+    print(e.Chunk)
+})
+defer unsub3()
+
+response, err := host.Prompt(
     ctx,
     "List files in current directory",
-    func(name, args string) {
-        // Tool call started
-        println("Calling tool:", name)
-    },
-    func(name, args, result string, isError bool) {
-        // Tool call completed
-        if isError {
-            println("Tool failed:", name)
-        }
-    },
-    func(chunk string) {
-        // Streaming text chunk
-        print(chunk)
-    },
 )
 ```
 
 ### Session Management
 
 ```go
+// Multi-turn conversations retain context automatically
 host.Prompt(ctx, "My name is Alice")
 response, _ := host.Prompt(ctx, "What's my name?")
 
-host.SaveSession("./session.json")
-host.LoadSession("./session.json")
+// Sessions are persisted automatically to JSONL files.
+// Access session info:
+path := host.GetSessionPath()
+id := host.GetSessionID()
+
+// Clear conversation history
 host.ClearSession()
 ```
 
+Session persistence is configured via `Options`:
+
+```go
+host, _ := kit.New(ctx, &kit.Options{
+    SessionPath: "./my-session.jsonl",  // Open specific session
+    Continue:    true,                   // Resume most recent session
+    NoSession:   true,                   // Ephemeral mode
+})
+```
+
 ## Advanced Usage
 
 ### Subagent Pattern
@@ -413,12 +613,25 @@ Parse the JSON output:
 {
   "response": "Final assistant response text",
   "model": "anthropic/claude-haiku-3-5-20241022",
+  "stop_reason": "end_turn",
+  "session_id": "a1b2c3d4e5f6",
   "usage": {
     "input_tokens": 1024,
     "output_tokens": 512,
-    "total_tokens": 1536
+    "total_tokens": 1536,
+    "cache_read_tokens": 0,
+    "cache_creation_tokens": 0
   },
-  "messages": [...]
+  "messages": [
+    {
+      "role": "assistant",
+      "parts": [
+        {"type": "text", "data": "..."},
+        {"type": "tool_call", "data": {"name": "...", "args": "..."}},
+        {"type": "tool_result", "data": {"name": "...", "result": "..."}}
+      ]
+    }
+  ]
 }
 ```
 
@@ -468,19 +681,27 @@ go fmt ./...
 ### Project Structure
 
 ```
-cmd/kit/           - CLI entry point
-cmd/               - CLI command implementations
-pkg/kit/           - Go SDK
-internal/agent/    - Agent loop and tool execution
-internal/ui/       - Bubble Tea TUI components
+cmd/kit/             - CLI entry point (main.go)
+cmd/                 - CLI command implementations (root, auth, models, etc.)
+pkg/kit/             - Go SDK for embedding Kit
+internal/app/        - Application orchestrator (agent loop, message store, queue)
+internal/agent/      - Agent execution and tool dispatch
+internal/auth/       - OAuth authentication and credential storage
+internal/acpserver/  - ACP (Agent Client Protocol) server
+internal/clipboard/  - Cross-platform clipboard operations
+internal/compaction/ - Conversation compaction and summarization
+internal/config/     - Configuration management
+internal/core/       - Built-in tools (bash, read, write, edit, grep, find, ls)
 internal/extensions/ - Yaegi extension system
-internal/core/     - Built-in tools
-internal/tools/    - MCP tool integration
-internal/config/   - Configuration management
-internal/acpserver/ - ACP (Agent Client Protocol) server
-internal/session/  - Session persistence
-internal/models/   - Provider and model management
+internal/kitsetup/   - Initial setup wizard
+internal/message/    - Message content types and structured content blocks
+internal/models/     - Provider and model management
+internal/session/    - Session persistence (tree-based JSONL)
+internal/skills/     - Skill loading and system prompt composition
+internal/tools/      - MCP tool integration
+internal/ui/         - Bubble Tea TUI components
 examples/extensions/ - Example extension files
+npm/                 - NPM package wrapper for distribution
 ```
 
 ## Supported Providers
@@ -494,13 +715,29 @@ examples/extensions/ - Example extension files
 - **Google Vertex** - Claude on Vertex AI
 - **OpenRouter** - Multi-provider router
 - **Vercel AI** - Vercel AI SDK models
+- **Custom** - Any OpenAI-compatible endpoint via `--provider-url`
 - **Auto-routed** - Any provider from models.dev database
 
+### Custom Provider
+
+Use `custom/custom` when pointing Kit at any OpenAI-compatible endpoint with `--provider-url`:
+
+```bash
+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:
+
+- Zero cost tracking (input/output = 0)
+- 262K context window, 65K output limit
+- Reasoning and temperature support
+- Optional `CUSTOM_API_KEY` environment variable or `--provider-api-key` flag
+
 ### Model String Format
 
 ```bash
 provider/model            # Standard format
-anthropic/claude-sonnet-4-5-20250929
+anthropic/claude-sonnet-latest
 openai/gpt-4o
 ollama/llama3
 google/gemini-2.0-flash-exp
@@ -509,18 +746,44 @@ google/gemini-2.0-flash-exp
 ### Model Aliases
 
 ```bash
-claude-opus-latest      → claude-opus-4-20250514
-claude-sonnet-latest    → claude-sonnet-4-5-20250929
-claude-3-5-haiku-latest → claude-3-5-haiku-20241022
+# Anthropic Claude
+claude-opus-latest        → claude-opus-4-6
+claude-sonnet-latest      → claude-sonnet-4-6
+claude-haiku-latest       → claude-haiku-4-5
+claude-4-opus-latest      → claude-opus-4-6
+claude-4-sonnet-latest    → claude-sonnet-4-6
+claude-4-haiku-latest     → claude-haiku-4-5
+claude-3-7-sonnet-latest  → claude-3-7-sonnet-20250219
+claude-3-5-sonnet-latest   → claude-3-5-sonnet-20241022
+claude-3-5-haiku-latest   → claude-3-5-haiku-20241022
+claude-3-opus-latest      → claude-3-opus-20240229
+
+# OpenAI GPT
+o1-latest                 → o1
+o3-latest                 → o3
+o4-latest                 → o4-mini
+gpt-5-latest              → gpt-5.4
+gpt-5-chat-latest         → gpt-5.4
+gpt-4-latest              → gpt-4o
+gpt-4                     → gpt-4o
+gpt-3.5-latest            → gpt-3.5-turbo
+gpt-3.5                   → gpt-3.5-turbo
+codex-latest              → codex-mini-latest
+
+# Google Gemini
+gemini-pro-latest         → gemini-2.5-pro
+gemini-flash-latest       → gemini-2.5-flash
+gemini-flash              → gemini-2.5-flash
+gemini-pro                → gemini-2.5-pro
 ```
 
 ## Contributing
 
-Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+Contributions are welcome! Please see the [contribution guide](contribute/contribute.md) for guidelines.
 
 ## License
 
-[Apache 2.0](LICENSE)
+[MIT](LICENSE)
 
 ## Community
 

btca.config.jsonc

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

cmd/auth.go

@@ -1,11 +1,15 @@
 package cmd
 
 import (
-	"bufio"
+	"context"
 	"fmt"
+	"net"
+	"net/http"
 	"os"
 	"strings"
+	"time"
 
+	"charm.land/huh/v2"
 	"github.com/mark3labs/kit/internal/auth"
 	kit "github.com/mark3labs/kit/pkg/kit"
 	"github.com/spf13/cobra"
@@ -14,7 +18,7 @@ import (
 // authCmd represents the auth command for managing AI provider authentication.
 // This command provides subcommands for login, logout, and status checking
 // of authentication credentials for various AI providers, with OAuth support
-// for providers like Anthropic.
+// for providers like Anthropic and OpenAI.
 var authCmd = &cobra.Command{
 	Use:   "auth",
 	Short: "Manage authentication credentials for AI providers",
@@ -25,9 +29,11 @@ using OAuth flows. Stored credentials take precedence over environment variables
 
 Available providers:
   - anthropic: Anthropic Claude API (OAuth)
+  - openai:    OpenAI API (OAuth and API key)
 
 Examples:
   kit auth login anthropic
+  kit auth login openai
   kit auth logout anthropic
   kit auth status`,
 }
@@ -46,9 +52,11 @@ environment variables when making API calls.
 
 Available providers:
   - anthropic: Anthropic Claude API (OAuth)
+  - openai:    OpenAI ChatGPT Plus/Pro (Codex OAuth)
 
 Example:
-  kit auth login anthropic`,
+  kit auth login anthropic
+  kit auth login openai`,
 	Args: cobra.ExactArgs(1),
 	RunE: runAuthLogin,
 }
@@ -61,14 +69,16 @@ var authLogoutCmd = &cobra.Command{
 	Short: "Remove stored authentication credentials for a provider",
 	Long: `Remove stored authentication credentials for an AI provider.
 
-This will delete the stored API key for the specified provider. You will need
-to use environment variables or command-line flags for authentication after logout.
+This will delete the stored API key or OAuth credentials for the specified provider. 
+You will need to use environment variables or command-line flags for authentication after logout.
 
 Available providers:
   - anthropic: Anthropic Claude API
+  - openai:    OpenAI API
 
 Example:
-  kit auth logout anthropic`,
+  kit auth logout anthropic
+  kit auth logout openai`,
 	Args: cobra.ExactArgs(1),
 	RunE: runAuthLogout,
 }
@@ -101,8 +111,10 @@ func runAuthLogin(cmd *cobra.Command, args []string) error {
 	switch provider {
 	case "anthropic":
 		return loginAnthropic()
+	case "openai":
+		return loginOpenAI()
 	default:
-		return fmt.Errorf("unsupported provider: %s. Available providers: anthropic", provider)
+		return fmt.Errorf("unsupported provider: %s. Available providers: anthropic, openai", provider)
 	}
 }
 
@@ -112,8 +124,10 @@ func runAuthLogout(cmd *cobra.Command, args []string) error {
 	switch provider {
 	case "anthropic":
 		return logoutAnthropic()
+	case "openai":
+		return logoutOpenAI()
 	default:
-		return fmt.Errorf("unsupported provider: %s. Available providers: anthropic", provider)
+		return fmt.Errorf("unsupported provider: %s. Available providers: anthropic, openai", provider)
 	}
 }
 
@@ -157,8 +171,44 @@ func runAuthStatus(cmd *cobra.Command, args []string) error {
 		}
 	}
 
+	// Check OpenAI credentials
+	fmt.Print("\nOpenAI: ")
+	if hasOpenAICreds, err := cm.HasOpenAICredentials(); err != nil {
+		fmt.Printf("Error checking credentials: %v\n", err)
+	} else if hasOpenAICreds {
+		if creds, err := cm.GetOpenAICredentials(); err != nil {
+			fmt.Printf("Error reading credentials: %v\n", err)
+		} else {
+			authType := "API Key"
+			status := "✓ Authenticated"
+
+			if creds.Type == "oauth" {
+				authType = "OAuth (ChatGPT/Codex)"
+				if creds.IsExpired() {
+					status = "⚠️  Token expired (will refresh automatically)"
+				} else if creds.NeedsRefresh() {
+					status = "⚠️  Token expires soon (will refresh automatically)"
+				}
+			}
+
+			accountInfo := ""
+			if creds.Type == "oauth" && creds.AccountID != "" {
+				accountInfo = fmt.Sprintf(" [%s]", creds.AccountID)
+			}
+
+			fmt.Printf("%s (%s%s, stored %s)\n", status, authType, accountInfo, creds.CreatedAt.Format("2006-01-02 15:04:05"))
+		}
+	} else {
+		fmt.Println("✗ Not authenticated")
+		// Check if environment variable is set
+		if os.Getenv("OPENAI_API_KEY") != "" {
+			fmt.Println("  (OPENAI_API_KEY environment variable is set)")
+		}
+	}
+
 	fmt.Println("\nTo authenticate with a provider:")
 	fmt.Println("  kit auth login anthropic")
+	fmt.Println("  kit auth login openai")
 
 	return nil
 }
@@ -171,14 +221,15 @@ func loginAnthropic() error {
 
 	// Check if already authenticated
 	if hasAuth, err := cm.HasAnthropicCredentials(); err == nil && hasAuth {
-		fmt.Print("You are already authenticated with Anthropic. Do you want to re-authenticate? (y/N): ")
-		reader := bufio.NewReader(os.Stdin)
-		response, err := reader.ReadString('\n')
-		if err != nil {
-			return fmt.Errorf("failed to read response: %w", err)
-		}
-		response = strings.TrimSpace(strings.ToLower(response))
-		if response != "y" && response != "yes" {
+		var reauth bool
+		err := huh.NewConfirm().
+			Title("You are already authenticated with Anthropic").
+			Description("Do you want to re-authenticate?").
+			Affirmative("Yes").
+			Negative("No").
+			Value(&reauth).
+			Run()
+		if err != nil || !reauth {
 			fmt.Println("Authentication cancelled.")
 			return nil
 		}
@@ -204,10 +255,13 @@ func loginAnthropic() error {
 
 	// Wait for user to complete OAuth flow
 	fmt.Println("After authorizing the application, you'll receive an authorization code.")
-	fmt.Print("Please enter the authorization code: ")
 
-	reader := bufio.NewReader(os.Stdin)
-	code, err := reader.ReadString('\n')
+	var code string
+	err = huh.NewInput().
+		Title("Authorization code").
+		Description("Paste the code from your browser").
+		Value(&code).
+		Run()
 	if err != nil {
 		return fmt.Errorf("failed to read authorization code: %w", err)
 	}
@@ -255,15 +309,15 @@ func logoutAnthropic() error {
 	}
 
 	// Confirm logout
-	fmt.Print("Are you sure you want to remove your Anthropic credentials? (y/N): ")
-	reader := bufio.NewReader(os.Stdin)
-	response, err := reader.ReadString('\n')
-	if err != nil {
-		return fmt.Errorf("failed to read response: %w", err)
-	}
-
-	response = strings.TrimSpace(strings.ToLower(response))
-	if response != "y" && response != "yes" {
+	var confirm bool
+	err = huh.NewConfirm().
+		Title("Remove Anthropic credentials").
+		Description("Are you sure you want to remove your stored credentials?").
+		Affirmative("Yes").
+		Negative("No").
+		Value(&confirm).
+		Run()
+	if err != nil || !confirm {
 		fmt.Println("Logout cancelled.")
 		return nil
 	}
@@ -278,3 +332,246 @@ func logoutAnthropic() error {
 
 	return nil
 }
+
+func loginOpenAI() error {
+	cm, err := kit.NewCredentialManager()
+	if err != nil {
+		return fmt.Errorf("failed to initialize credential manager: %w", err)
+	}
+
+	// Check if already authenticated
+	if hasAuth, err := cm.HasOpenAICredentials(); err == nil && hasAuth {
+		var reauth bool
+		err := huh.NewConfirm().
+			Title("You are already authenticated with OpenAI (ChatGPT/Codex)").
+			Description("Do you want to re-authenticate?").
+			Affirmative("Yes").
+			Negative("No").
+			Value(&reauth).
+			Run()
+		if err != nil || !reauth {
+			fmt.Println("Authentication cancelled.")
+			return nil
+		}
+	}
+
+	// Create OAuth client
+	client := auth.NewOpenAIOAuthClient()
+
+	// Generate authorization URL
+	fmt.Println("🔐 Starting OAuth authentication with OpenAI (ChatGPT/Codex)...")
+	fmt.Println("This will open your browser to authenticate with your ChatGPT account.")
+	fmt.Println()
+
+	authData, err := client.GetAuthorizationURL()
+	if err != nil {
+		return fmt.Errorf("failed to generate authorization URL: %w", err)
+	}
+
+	// Start local callback server
+	callbackServer, err := startOpenAICallbackServer(authData.State)
+	if err != nil {
+		fmt.Printf("⚠️  Could not start local callback server: %v\n", err)
+		fmt.Println("Falling back to manual code entry.")
+	}
+	if callbackServer != nil {
+		defer callbackServer.Close()
+	}
+
+	// Display URL and try to open browser
+	fmt.Println("📱 Opening your browser for authentication...")
+	fmt.Println("If the browser doesn't open automatically, please visit this URL:")
+	fmt.Printf("\n%s\n\n", authData.URL)
+
+	// Try to open browser
+	auth.TryOpenBrowser(authData.URL)
+
+	// Wait for callback or manual input
+	var code string
+	if callbackServer != nil {
+		fmt.Println("Waiting for browser authentication...")
+		select {
+		case callbackCode := <-callbackServer.CodeChan:
+			if callbackCode != "" {
+				code = callbackCode
+				fmt.Println("✓ Received authorization code from browser callback.")
+			}
+		case <-time.After(2 * time.Minute):
+			fmt.Println("\n⏱️  Timeout waiting for browser callback.")
+			callbackServer.Close()
+		}
+	}
+
+	// If no code from callback, prompt for manual entry
+	if code == "" {
+		fmt.Println("\nAfter authorizing, paste the callback URL or authorization code below.")
+		fmt.Println("(The callback URL will look like: http://localhost:1455/auth/callback?code=...&state=...)")
+		fmt.Println()
+
+		var input string
+		err = huh.NewInput().
+			Title("Callback URL or Code").
+			Description("Paste the full callback URL or just the authorization code").
+			Value(&input).
+			Run()
+		if err != nil {
+			return fmt.Errorf("failed to read input: %w", err)
+		}
+		input = strings.TrimSpace(input)
+
+		if input == "" {
+			return fmt.Errorf("authorization code cannot be empty")
+		}
+
+		// Parse the input (could be full URL or just code)
+		parsedCode, parsedState := auth.ParseOpenAIAuthorizationInput(input)
+		if parsedCode == "" {
+			return fmt.Errorf("could not extract authorization code from input")
+		}
+
+		// Validate state if provided
+		if parsedState != "" && parsedState != authData.State {
+			return fmt.Errorf("state mismatch - possible security issue")
+		}
+		code = parsedCode
+	}
+
+	// Exchange code for tokens
+	fmt.Println("\n🔄 Exchanging authorization code for access token...")
+	creds, err := client.ExchangeCode(code, authData.Verifier)
+	if err != nil {
+		return fmt.Errorf("failed to exchange authorization code: %w", err)
+	}
+
+	// Store the credentials
+	if err := cm.SetOpenAIOAuthCredentials(creds); err != nil {
+		return fmt.Errorf("failed to store credentials: %w", err)
+	}
+
+	fmt.Println("✅ Successfully authenticated with OpenAI (ChatGPT/Codex)!")
+	fmt.Printf("📁 Credentials stored in: %s\n", cm.GetCredentialsPath())
+	fmt.Printf("👤 Account ID: %s\n", creds.AccountID)
+	fmt.Println("\n🎉 Your OAuth credentials will now be used for OpenAI API calls.")
+	fmt.Println("💡 You can check your authentication status with: kit auth status")
+
+	return nil
+}
+
+// callbackServer holds the HTTP server and channel for receiving the OAuth callback
+type callbackServer struct {
+	Server   *http.Server
+	CodeChan chan string
+	State    string
+}
+
+// Close shuts down the callback server
+func (cs *callbackServer) Close() {
+	if cs.Server != nil {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		_ = cs.Server.Shutdown(ctx)
+	}
+}
+
+// startOpenAICallbackServer starts a local HTTP server to receive the OAuth callback
+func startOpenAICallbackServer(expectedState string) (*callbackServer, error) {
+	codeChan := make(chan string, 1)
+
+	mux := http.NewServeMux()
+	server := &http.Server{
+		Addr:    "127.0.0.1:1455",
+		Handler: mux,
+	}
+
+	mux.HandleFunc("/auth/callback", func(w http.ResponseWriter, r *http.Request) {
+		// Check state
+		state := r.URL.Query().Get("state")
+		if state != expectedState {
+			http.Error(w, "State mismatch", http.StatusBadRequest)
+			return
+		}
+
+		code := r.URL.Query().Get("code")
+		if code == "" {
+			http.Error(w, "Missing authorization code", http.StatusBadRequest)
+			return
+		}
+
+		// Send code to channel
+		select {
+		case codeChan <- code:
+		default:
+		}
+
+		// Return success page
+		w.Header().Set("Content-Type", "text/html")
+		w.WriteHeader(http.StatusOK)
+		_, _ = fmt.Fprintf(w, `<!DOCTYPE html>
+<html>
+<head><title>Authentication Successful</title></head>
+<body style="font-family: sans-serif; text-align: center; padding: 50px;">
+<h1>✓ Authentication Successful</h1>
+<p>You can close this window and return to the terminal.</p>
+</body>
+</html>`)
+	})
+
+	// Try to start server
+	listener, err := net.Listen("tcp", "127.0.0.1:1455")
+	if err != nil {
+		return nil, fmt.Errorf("port 1455 not available: %w", err)
+	}
+	_ = listener.Close()
+
+	go func() {
+		_ = server.ListenAndServe()
+	}()
+
+	return &callbackServer{
+		Server:   server,
+		CodeChan: codeChan,
+		State:    expectedState,
+	}, nil
+}
+
+func logoutOpenAI() error {
+	cm, err := kit.NewCredentialManager()
+	if err != nil {
+		return fmt.Errorf("failed to initialize credential manager: %w", err)
+	}
+
+	// Check if authenticated
+	hasAuth, err := cm.HasOpenAICredentials()
+	if err != nil {
+		return fmt.Errorf("failed to check authentication status: %w", err)
+	}
+
+	if !hasAuth {
+		fmt.Println("You are not currently authenticated with OpenAI.")
+		return nil
+	}
+
+	// Confirm logout
+	var confirm bool
+	err = huh.NewConfirm().
+		Title("Remove OpenAI credentials").
+		Description("Are you sure you want to remove your stored credentials?").
+		Affirmative("Yes").
+		Negative("No").
+		Value(&confirm).
+		Run()
+	if err != nil || !confirm {
+		fmt.Println("Logout cancelled.")
+		return nil
+	}
+
+	// Remove credentials
+	if err := cm.RemoveOpenAICredentials(); err != nil {
+		return fmt.Errorf("failed to remove credentials: %w", err)
+	}
+
+	fmt.Println("✓ Successfully logged out from OpenAI!")
+	fmt.Println("You will need to use environment variables or command-line flags for authentication.")
+
+	return nil
+}

cmd/install.go

@@ -0,0 +1,225 @@
+package cmd
+
+import (
+	"fmt"
+	"os/exec"
+
+	"github.com/charmbracelet/log"
+	"github.com/mark3labs/kit/internal/extensions"
+	"github.com/spf13/cobra"
+)
+
+var (
+	installLocalFlag     bool
+	installUpdateFlag    bool
+	installUninstallFlag bool
+	installAllFlag       bool
+)
+
+var installCmd = &cobra.Command{
+	Use:   "install <git-url>",
+	Short: "Install extensions from git repositories",
+	Long: `Install extensions from git repositories.
+
+The install command downloads and installs Kit extensions from git repositories.
+Extensions are stored in the global extensions directory by default, or in the
+project's .kit/git/ directory when using the --local flag.
+
+When a repo contains multiple extensions, an interactive multi-select is shown
+so you can choose which to install. Use --all to skip selection and install everything.
+
+Supported URL formats:
+  - github.com/user/repo (shorthand, defaults to HTTPS)
+  - git:github.com/user/repo
+  - https://github.com/user/repo
+  - ssh://git@github.com/user/repo
+  - git@github.com:user/repo
+
+You can pin to a specific version, tag, or commit using @:
+  - github.com/user/repo@v1.0.0
+  - github.com/user/repo@main
+  - github.com/user/repo@abc1234
+
+Examples:
+  kit install github.com/user/my-extension
+  kit install github.com/user/my-extension@v1.0.0
+  kit install github.com/user/my-extension --local
+  kit install github.com/user/collection --all`,
+	Args: cobra.ExactArgs(1),
+	RunE: runInstall,
+}
+
+func init() {
+	installCmd.Flags().BoolVarP(&installLocalFlag, "local", "l", false, "Install to project-local .kit/git/ directory")
+	installCmd.Flags().BoolVarP(&installUpdateFlag, "update", "u", false, "Update an already-installed package")
+	installCmd.Flags().BoolVar(&installUninstallFlag, "uninstall", false, "Remove an installed package")
+	installCmd.Flags().BoolVar(&installAllFlag, "all", false, "Install all extensions without prompting")
+
+	rootCmd.AddCommand(installCmd)
+}
+
+func runInstall(cmd *cobra.Command, args []string) error {
+	sourceStr := args[0]
+
+	// Check that git is available
+	if _, err := exec.LookPath("git"); err != nil {
+		return fmt.Errorf("git is not installed or not in PATH")
+	}
+
+	// Parse the source
+	source, err := extensions.ParseGitSource(sourceStr)
+	if err != nil {
+		return fmt.Errorf("invalid source: %w", err)
+	}
+
+	// Determine scope
+	scope := extensions.ScopeGlobal
+	if installLocalFlag {
+		scope = extensions.ScopeProject
+	}
+
+	installer := extensions.NewInstaller(".")
+
+	// Handle uninstall
+	if installUninstallFlag {
+		return runUninstall(installer, source, scope)
+	}
+
+	// Handle update
+	if installUpdateFlag {
+		return runUpdate(installer, source, scope)
+	}
+
+	// Handle install
+	return runInstallPackage(installer, source, scope)
+}
+
+func runInstallPackage(installer *extensions.Installer, source *extensions.GitSource, scope extensions.InstallScope) error {
+	// Check if already installed
+	existingScope, installed := installer.IsInstalled(source)
+	if installed {
+		return fmt.Errorf("extension already installed (scope: %s). Use --update to update or --uninstall to remove", existingScope)
+	}
+
+	// Preview extensions to decide if we need multi-select
+	previews, tempDir, err := installer.PreviewExtensions(source)
+	if err != nil {
+		return fmt.Errorf("previewing extensions: %w", err)
+	}
+	defer extensions.CleanupTempDir(tempDir)
+
+	if len(previews) == 0 {
+		return fmt.Errorf("no extensions found in %s", source.String())
+	}
+
+	scopeStr := "globally"
+	if scope == extensions.ScopeProject {
+		scopeStr = "locally in .kit/git/"
+	}
+
+	// Single extension or --all flag: install everything directly
+	if len(previews) == 1 || installAllFlag {
+		if err := installer.Install(source, scope); err != nil {
+			return fmt.Errorf("install failed: %w", err)
+		}
+
+		if source.Pinned {
+			fmt.Printf("Installed %s at %s %s\n", source.String(), source.Ref, scopeStr)
+		} else {
+			fmt.Printf("Installed %d extension(s) from %s %s\n", len(previews), source.String(), scopeStr)
+		}
+
+		log.Info("extension installed", "source", source.String(), "scope", scope)
+		return nil
+	}
+
+	// Multiple extensions: show interactive selection
+	includePaths, err := multiSelectForInstall(previews)
+	if err != nil {
+		if err.Error() == "selection cancelled" || err.Error() == "no extensions selected" {
+			fmt.Println("Install cancelled.")
+			return nil
+		}
+		return fmt.Errorf("selection failed: %w", err)
+	}
+
+	if err := installer.InstallWithInclude(source, scope, includePaths); err != nil {
+		return fmt.Errorf("install failed: %w", err)
+	}
+
+	fmt.Printf("Installed %d extension(s) from %s %s\n", len(includePaths), source.String(), scopeStr)
+	for _, path := range includePaths {
+		fmt.Printf("  - %s\n", path)
+	}
+
+	log.Info("extension installed", "source", source.String(), "scope", scope, "selected", len(includePaths))
+	return nil
+}
+
+func runUpdate(installer *extensions.Installer, source *extensions.GitSource, scope extensions.InstallScope) error {
+	// Find the installed package
+	existingScope, installed := installer.IsInstalled(source)
+	if !installed {
+		// Try to find with wildcard (no version)
+		entry, foundScope, err := extensions.FindInManifest(source.Identity())
+		if err != nil || entry == nil {
+			return fmt.Errorf("extension not installed: %s", source.Identity())
+		}
+		// Parse the found entry's source
+		foundSource, err := extensions.ParseGitSource(entry.Source)
+		if err != nil {
+			return fmt.Errorf("failed to parse installed source: %w", err)
+		}
+		existingScope = foundScope
+		source = foundSource
+	}
+
+	// Override scope if specified
+	if installLocalFlag && scope != existingScope {
+		return fmt.Errorf("extension installed in %s scope, cannot update with --local flag", existingScope)
+	}
+	scope = existingScope
+
+	// Check if pinned
+	if source.Pinned {
+		fmt.Printf("Skipping %s (pinned at %s)\n", source.Identity(), source.Ref)
+		return nil
+	}
+
+	// Update
+	if err := installer.Update(source, scope); err != nil {
+		return fmt.Errorf("update failed: %w", err)
+	}
+
+	fmt.Printf("Updated %s\n", source.Identity())
+	log.Info("extension updated", "source", source.Identity(), "scope", scope)
+	return nil
+}
+
+func runUninstall(installer *extensions.Installer, source *extensions.GitSource, scope extensions.InstallScope) error {
+	// Find where it's installed (ignore scope flag for uninstall - remove from wherever it exists)
+	existingScope, installed := installer.IsInstalled(source)
+	if !installed {
+		// Try to find in manifests
+		entry, foundScope, err := extensions.FindInManifest(source.Identity())
+		if err != nil || entry == nil {
+			return fmt.Errorf("extension not installed: %s", source.Identity())
+		}
+		existingScope = foundScope
+		// Parse the found entry's source
+		foundSource, err := extensions.ParseGitSource(entry.Source)
+		if err != nil {
+			return fmt.Errorf("failed to parse installed source: %w", err)
+		}
+		source = foundSource
+	}
+
+	// Uninstall from the scope where it's installed
+	if err := installer.Uninstall(source, existingScope); err != nil {
+		return fmt.Errorf("uninstall failed: %w", err)
+	}
+
+	fmt.Printf("Uninstalled %s from %s scope\n", source.Identity(), existingScope)
+	log.Info("extension uninstalled", "source", source.Identity(), "scope", existingScope)
+	return nil
+}

cmd/install_multiselect.go

@@ -0,0 +1,70 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"charm.land/huh/v2"
+	"github.com/charmbracelet/log"
+	"github.com/mark3labs/kit/internal/extensions"
+)
+
+// multiSelectForInstall runs a multi-select prompt for extension selection.
+// Returns the selected extension paths, or an error if cancelled.
+func multiSelectForInstall(previews []extensions.ExtensionPreview) ([]string, error) {
+	if len(previews) == 0 {
+		return nil, fmt.Errorf("no extensions to select")
+	}
+
+	// Non-interactive: select all
+	if !isInteractive() {
+		log.Info("Non-interactive mode, selecting all extensions")
+		paths := make([]string, len(previews))
+		for i, p := range previews {
+			paths[i] = p.Path
+		}
+		return paths, nil
+	}
+
+	// Single extension: just return it
+	if len(previews) == 1 {
+		return []string{previews[0].Path}, nil
+	}
+
+	// Build options for huh MultiSelect
+	options := make([]huh.Option[string], len(previews))
+	for i, p := range previews {
+		label := fmt.Sprintf("%s  %s", p.Name, p.Path)
+		options[i] = huh.NewOption(label, p.Path).Selected(true)
+	}
+
+	var selected []string
+
+	form := huh.NewForm(
+		huh.NewGroup(
+			huh.NewMultiSelect[string]().
+				Title("Select extensions to install").
+				Options(options...).
+				Value(&selected),
+		),
+	)
+
+	if err := form.Run(); err != nil {
+		return nil, fmt.Errorf("selection cancelled")
+	}
+
+	if len(selected) == 0 {
+		return nil, fmt.Errorf("no extensions selected")
+	}
+
+	return selected, nil
+}
+
+// isInteractive checks if the terminal is interactive.
+func isInteractive() bool {
+	fi, err := os.Stdout.Stat()
+	if err != nil {
+		return false
+	}
+	return (fi.Mode() & os.ModeCharDevice) != 0
+}

cmd/models.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"sort"
 
+	"github.com/mark3labs/kit/internal/models"
 	kit "github.com/mark3labs/kit/pkg/kit"
 	"github.com/spf13/cobra"
 )
@@ -47,6 +48,9 @@ func runModels(_ *cobra.Command, args []string) error {
 }
 
 func printAllProviders(showAll bool) error {
+	// Reload the registry to pick up any custom models from config
+	models.ReloadGlobalRegistry()
+
 	var providerIDs []string
 	if showAll {
 		providerIDs = kit.GetSupportedProviders()
@@ -98,6 +102,9 @@ func printAllProviders(showAll bool) error {
 }
 
 func printProvider(provider string) error {
+	// Reload the registry to pick up any custom models from config
+	models.ReloadGlobalRegistry()
+
 	m, err := kit.GetModelsForProvider(provider)
 	if err != nil {
 		return fmt.Errorf("unknown provider %q. Run 'kit models' to see all providers", provider)

cmd/root.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"image/color"
 	"log"
 	"os"
 	"strings"
@@ -12,9 +13,11 @@ import (
 	"charm.land/fantasy"
 	"charm.land/lipgloss/v2"
 	"github.com/mark3labs/kit/internal/app"
+	"github.com/mark3labs/kit/internal/auth"
 	"github.com/mark3labs/kit/internal/config"
 	"github.com/mark3labs/kit/internal/extensions"
 	"github.com/mark3labs/kit/internal/models"
+	"github.com/mark3labs/kit/internal/prompts"
 	"github.com/mark3labs/kit/internal/ui"
 	kit "github.com/mark3labs/kit/pkg/kit"
 	"github.com/spf13/cobra"
@@ -64,6 +67,15 @@ var (
 
 	// TLS configuration
 	tlsSkipVerify bool
+
+	// Prompt templates
+	promptTemplatePaths []string
+	noPromptTemplates   bool
+
+	// Preference restoration flags — set in RunE after cobra parses, used
+	// in runNormalMode to decide whether to apply saved preferences.
+	modelFlagChanged    bool
+	thinkingFlagChanged bool
 )
 
 // kitUIAdapter adapts *kit.Kit to ui.AgentInterface so the CLI setup layer
@@ -112,6 +124,17 @@ var rootCmd = &cobra.Command{
 		if len(args) > 0 {
 			processPositionalArgs(args)
 		}
+		// Record whether --model / --thinking-level were explicitly set by the
+		// user so that runNormalMode can fall back to saved preferences when
+		// they weren't. Must be captured here (after cobra parses) and before
+		// runKit because rootCmd can't be referenced inside runNormalMode
+		// without creating an initialization cycle.
+		if f := cmd.PersistentFlags().Lookup("model"); f != nil {
+			modelFlagChanged = f.Changed
+		}
+		if f := cmd.PersistentFlags().Lookup("thinking-level"); f != nil {
+			thinkingFlagChanged = f.Changed
+		}
 		return runKit(context.Background())
 	},
 }
@@ -141,24 +164,58 @@ func LoadConfigWithEnvSubstitution(configPath string) error {
 	return kit.LoadConfigWithEnvSubstitution(configPath)
 }
 
-func configToUiTheme(theme config.Theme) ui.Theme {
+// adaptiveOrDefault converts a config.AdaptiveColor to a resolved color.Color,
+// falling back to fallback when both Light and Dark are empty.
+func adaptiveOrDefault(ac config.AdaptiveColor, fallback color.Color) color.Color {
+	if ac.Light == "" && ac.Dark == "" {
+		return fallback
+	}
+	return ui.AdaptiveColor(ac.Light, ac.Dark)
+}
+
+func configToUiTheme(cfg config.Theme) ui.Theme {
+	def := ui.DefaultTheme()
 	return ui.Theme{
-		Primary:     ui.AdaptiveColor(theme.Primary.Light, theme.Primary.Dark),
-		Secondary:   ui.AdaptiveColor(theme.Secondary.Light, theme.Secondary.Dark),
-		Success:     ui.AdaptiveColor(theme.Success.Light, theme.Success.Dark),
-		Warning:     ui.AdaptiveColor(theme.Warning.Light, theme.Warning.Dark),
-		Error:       ui.AdaptiveColor(theme.Error.Light, theme.Error.Dark),
-		Info:        ui.AdaptiveColor(theme.Info.Light, theme.Info.Dark),
-		Text:        ui.AdaptiveColor(theme.Text.Light, theme.Text.Dark),
-		Muted:       ui.AdaptiveColor(theme.Muted.Light, theme.Muted.Dark),
-		VeryMuted:   ui.AdaptiveColor(theme.VeryMuted.Light, theme.VeryMuted.Dark),
-		Background:  ui.AdaptiveColor(theme.Background.Light, theme.Background.Dark),
-		Border:      ui.AdaptiveColor(theme.Border.Light, theme.Border.Dark),
-		MutedBorder: ui.AdaptiveColor(theme.MutedBorder.Light, theme.MutedBorder.Dark),
-		System:      ui.AdaptiveColor(theme.System.Light, theme.System.Dark),
-		Tool:        ui.AdaptiveColor(theme.Tool.Light, theme.Tool.Dark),
-		Accent:      ui.AdaptiveColor(theme.Accent.Light, theme.Accent.Dark),
-		Highlight:   ui.AdaptiveColor(theme.Highlight.Light, theme.Highlight.Dark),
+		Primary:     adaptiveOrDefault(cfg.Primary, def.Primary),
+		Secondary:   adaptiveOrDefault(cfg.Secondary, def.Secondary),
+		Success:     adaptiveOrDefault(cfg.Success, def.Success),
+		Warning:     adaptiveOrDefault(cfg.Warning, def.Warning),
+		Error:       adaptiveOrDefault(cfg.Error, def.Error),
+		Info:        adaptiveOrDefault(cfg.Info, def.Info),
+		Text:        adaptiveOrDefault(cfg.Text, def.Text),
+		Muted:       adaptiveOrDefault(cfg.Muted, def.Muted),
+		VeryMuted:   adaptiveOrDefault(cfg.VeryMuted, def.VeryMuted),
+		Background:  adaptiveOrDefault(cfg.Background, def.Background),
+		Border:      adaptiveOrDefault(cfg.Border, def.Border),
+		MutedBorder: adaptiveOrDefault(cfg.MutedBorder, def.MutedBorder),
+		System:      adaptiveOrDefault(cfg.System, def.System),
+		Tool:        adaptiveOrDefault(cfg.Tool, def.Tool),
+		Accent:      adaptiveOrDefault(cfg.Accent, def.Accent),
+		Highlight:   adaptiveOrDefault(cfg.Highlight, def.Highlight),
+
+		DiffInsertBg:  adaptiveOrDefault(cfg.DiffInsertBg, def.DiffInsertBg),
+		DiffDeleteBg:  adaptiveOrDefault(cfg.DiffDeleteBg, def.DiffDeleteBg),
+		DiffEqualBg:   adaptiveOrDefault(cfg.DiffEqualBg, def.DiffEqualBg),
+		DiffMissingBg: adaptiveOrDefault(cfg.DiffMissingBg, def.DiffMissingBg),
+
+		CodeBg:   adaptiveOrDefault(cfg.CodeBg, def.CodeBg),
+		GutterBg: adaptiveOrDefault(cfg.GutterBg, def.GutterBg),
+		WriteBg:  adaptiveOrDefault(cfg.WriteBg, def.WriteBg),
+
+		Markdown: ui.MarkdownThemeColors{
+			Text:    adaptiveOrDefault(cfg.Markdown.Text, def.Markdown.Text),
+			Muted:   adaptiveOrDefault(cfg.Markdown.Muted, def.Markdown.Muted),
+			Heading: adaptiveOrDefault(cfg.Markdown.Heading, def.Markdown.Heading),
+			Emph:    adaptiveOrDefault(cfg.Markdown.Emph, def.Markdown.Emph),
+			Strong:  adaptiveOrDefault(cfg.Markdown.Strong, def.Markdown.Strong),
+			Link:    adaptiveOrDefault(cfg.Markdown.Link, def.Markdown.Link),
+			Code:    adaptiveOrDefault(cfg.Markdown.Code, def.Markdown.Code),
+			Error:   adaptiveOrDefault(cfg.Markdown.Error, def.Markdown.Error),
+			Keyword: adaptiveOrDefault(cfg.Markdown.Keyword, def.Markdown.Keyword),
+			String:  adaptiveOrDefault(cfg.Markdown.String, def.Markdown.String),
+			Number:  adaptiveOrDefault(cfg.Markdown.Number, def.Markdown.Number),
+			Comment: adaptiveOrDefault(cfg.Markdown.Comment, def.Markdown.Comment),
+		},
 	}
 }
 
@@ -197,6 +254,9 @@ func init() {
 	if err == nil && viper.InConfig("theme") {
 		uiTheme := configToUiTheme(theme)
 		ui.SetTheme(uiTheme)
+	} else if pref := ui.LoadThemePreference(); pref != "" {
+		// No explicit theme in config — fall back to persisted preference.
+		_ = ui.ApplyThemeWithoutSave(pref)
 	}
 
 	rootCmd.PersistentFlags().
@@ -242,6 +302,10 @@ func init() {
 	flags.StringVar(&providerAPIKey, "provider-api-key", "", "API key for the provider (applies to OpenAI, Anthropic, and Google)")
 	flags.BoolVar(&tlsSkipVerify, "tls-skip-verify", false, "skip TLS certificate verification (WARNING: insecure, use only for self-signed certificates)")
 
+	// Prompt template flags
+	flags.StringArrayVar(&promptTemplatePaths, "prompt-template", nil, "load prompt template file or directory (repeatable)")
+	flags.BoolVar(&noPromptTemplates, "no-prompt-templates", false, "disable prompt template discovery")
+
 	// Model generation parameters
 	flags.IntVar(&maxTokens, "max-tokens", 4096, "maximum number of tokens in the response")
 	flags.Float32Var(&temperature, "temperature", 0.7, "controls randomness in responses (0.0-1.0)")
@@ -277,6 +341,8 @@ func init() {
 	_ = viper.BindPFlag("tls-skip-verify", rootCmd.PersistentFlags().Lookup("tls-skip-verify"))
 	_ = viper.BindPFlag("no-extensions", rootCmd.PersistentFlags().Lookup("no-extensions"))
 	_ = viper.BindPFlag("extension", rootCmd.PersistentFlags().Lookup("extension"))
+	_ = viper.BindPFlag("prompt-template", rootCmd.PersistentFlags().Lookup("prompt-template"))
+	_ = viper.BindPFlag("no-prompt-templates", rootCmd.PersistentFlags().Lookup("no-prompt-templates"))
 
 	// Defaults are already set in flag definitions, no need to duplicate in viper
 
@@ -608,6 +674,32 @@ func runNormalMode(ctx context.Context) error {
 		log.SetFlags(log.LstdFlags | log.Lshortfile)
 	}
 
+	// 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.
+	if !modelFlagChanged && !viper.InConfig("model") {
+		if pref := ui.LoadModelPreference(); pref != "" {
+			viper.Set("model", pref)
+		}
+	}
+
+	// Restore persisted thinking level preference (same precedence chain).
+	if !thinkingFlagChanged && !viper.InConfig("thinking-level") {
+		if pref := ui.LoadThinkingLevelPreference(); pref != "" {
+			viper.Set("thinking-level", pref)
+		}
+	}
+
+	// When --provider-url is set but no explicit --model was provided,
+	// default to "custom/custom" so the user doesn't need to remember a
+	// provider/model pair for custom OpenAI-compatible endpoints.
+	// This intentionally overrides saved preferences but respects config-file
+	// models — if you specify a model in ~/.kit.yml, it will be used with
+	// custom/custom's provider routing.
+	if viper.GetString("provider-url") != "" && !modelFlagChanged && !viper.InConfig("model") {
+		viper.Set("model", "custom/custom")
+	}
+
 	// Load MCP configuration.
 	mcpConfig, err := config.LoadAndValidateConfig()
 	if err != nil {
@@ -643,11 +735,16 @@ func runNormalMode(ctx context.Context) error {
 		},
 	}
 	if resumeFlag {
-		// TODO: TUI session picker.
-		sessions, _ := kit.ListSessions("")
-		if len(sessions) > 0 {
-			kitOpts.SessionPath = sessions[0].Path
+		// When --resume is combined with interactive mode, the TUI session
+		// picker will be shown at startup. For non-interactive mode, fall
+		// back to auto-selecting the most recent session.
+		if positionalPrompt != "" {
+			sessions, _ := kit.ListSessions("")
+			if len(sessions) > 0 {
+				kitOpts.SessionPath = sessions[0].Path
+			}
 		}
+		// Interactive mode: ShowSessionPicker is set below on AppModelOptions.
 	}
 
 	kitInstance, err := kit.New(ctx, kitOpts)
@@ -702,19 +799,29 @@ func runNormalMode(ctx context.Context) error {
 	appInstance := app.New(appOpts, messages)
 	defer appInstance.Close()
 
+	// Buffer for extension messages during startup (printed after startup banner).
+	var startupExtensionMessages []string
+
 	// Set up extension context and emit SessionStart.
 	if kitInstance.HasExtensions() {
 		cwd, _ := os.Getwd()
 		kitInstance.SetExtensionContext(extensions.Context{
-			CWD:           cwd,
-			Model:         modelName,
-			Interactive:   positionalPrompt == "",
-			Print:         func(text string) { appInstance.PrintFromExtension("", text) },
-			PrintInfo:     func(text string) { appInstance.PrintFromExtension("info", text) },
-			PrintError:    func(text string) { appInstance.PrintFromExtension("error", text) },
+			CWD:         cwd,
+			Model:       modelName,
+			Interactive: positionalPrompt == "",
+			Print: func(text string) {
+				// Capture messages during startup, print after startup banner.
+				startupExtensionMessages = append(startupExtensionMessages, text)
+			},
+			PrintInfo: func(text string) {
+				startupExtensionMessages = append(startupExtensionMessages, text)
+			},
+			PrintError: func(text string) {
+				startupExtensionMessages = append(startupExtensionMessages, text)
+			},
 			PrintBlock:    appInstance.PrintBlockFromExtension,
 			SendMessage:   func(text string) { appInstance.Run(text) },
-			CancelAndSend: func(text string) { appInstance.Steer(text) },
+			CancelAndSend: func(text string) { appInstance.InterruptAndSend(text) },
 			Exit:          func() { appInstance.QuitFromExtension() },
 			SetWidget: func(config extensions.WidgetConfig) {
 				kitInstance.SetExtensionWidget(config)
@@ -859,6 +966,24 @@ func runNormalMode(ctx context.Context) error {
 				kitInstance.UpdateExtensionContextModel(modelString)
 				// Fire OnModelChange event to extensions.
 				kitInstance.EmitModelChange(modelString, previousModel, "extension")
+				// Update usage tracker with new model info for correct token counting.
+				if usageTracker != nil {
+					newProvider, newModel, _ := models.ParseModelString(modelString)
+					if newProvider != "unknown" && newModel != "unknown" && newProvider != "ollama" {
+						registry := models.GetGlobalRegistry()
+						if modelInfo := registry.LookupModel(newProvider, newModel); modelInfo != nil {
+							// Check OAuth status for Anthropic models
+							isOAuth := false
+							if newProvider == "anthropic" {
+								_, source, err := auth.GetAnthropicAPIKey(viper.GetString("provider-api-key"))
+								if err == nil && strings.HasPrefix(source, "stored OAuth") {
+									isOAuth = true
+								}
+							}
+							usageTracker.UpdateModelInfo(modelInfo, newProvider, isOAuth)
+						}
+					}
+				}
 				return nil
 			},
 			GetAvailableModels: func() []extensions.ModelInfoEntry {
@@ -901,6 +1026,28 @@ func runNormalMode(ctx context.Context) error {
 			SetActiveTools: func(names []string) {
 				kitInstance.SetExtensionActiveTools(names)
 			},
+			RegisterTheme: func(name string, config extensions.ThemeColorConfig) {
+				tc := func(c extensions.ThemeColor) [2]string { return [2]string{c.Light, c.Dark} }
+				ui.RegisterThemeFromConfig(name,
+					tc(config.Primary), tc(config.Secondary),
+					tc(config.Success), tc(config.Warning),
+					tc(config.Error), tc(config.Info),
+					tc(config.Text), tc(config.Muted),
+					tc(config.VeryMuted), tc(config.Background),
+					tc(config.Border), tc(config.MutedBorder),
+					tc(config.System), tc(config.Tool),
+					tc(config.Accent), tc(config.Highlight),
+					tc(config.MdHeading), tc(config.MdLink),
+					tc(config.MdKeyword), tc(config.MdString),
+					tc(config.MdNumber), tc(config.MdComment),
+				)
+			},
+			SetTheme: func(name string) error {
+				return ui.ApplyTheme(name)
+			},
+			ListThemes: func() []string {
+				return ui.ListThemes()
+			},
 			ShowOverlay: func(config extensions.OverlayConfig) extensions.OverlayResult {
 				ch := make(chan app.OverlayResponse, 1)
 				appInstance.SendOverlayRequest(app.OverlayRequestEvent{
@@ -960,13 +1107,418 @@ func runNormalMode(ctx context.Context) error {
 				}
 				return nil, extResult, err
 			},
+
+			// -------------------------------------------------------------------------
+			// Tree Navigation API (Phase 1 Bridge)
+			// -------------------------------------------------------------------------
+			GetTreeNode: func(entryID string) *extensions.TreeNode {
+				node := kitInstance.GetTreeNode(entryID)
+				if node == nil {
+					return nil
+				}
+				return &extensions.TreeNode{
+					ID:        node.ID,
+					ParentID:  node.ParentID,
+					Type:      node.Type,
+					Role:      node.Role,
+					Content:   node.Content,
+					Model:     node.Model,
+					Provider:  node.Provider,
+					Timestamp: node.Timestamp,
+					Children:  node.Children,
+				}
+			},
+			GetCurrentBranch: func() []extensions.TreeNode {
+				nodes := kitInstance.GetCurrentBranch()
+				result := make([]extensions.TreeNode, len(nodes))
+				for i, n := range nodes {
+					result[i] = extensions.TreeNode{
+						ID:        n.ID,
+						ParentID:  n.ParentID,
+						Type:      n.Type,
+						Role:      n.Role,
+						Content:   n.Content,
+						Model:     n.Model,
+						Provider:  n.Provider,
+						Timestamp: n.Timestamp,
+						Children:  n.Children,
+					}
+				}
+				return result
+			},
+			GetChildren: kitInstance.GetChildren,
+			NavigateTo: func(entryID string) extensions.TreeNavigationResult {
+				err := kitInstance.NavigateTo(entryID)
+				if err != "" {
+					return extensions.TreeNavigationResult{Success: false, Error: err}
+				}
+				return extensions.TreeNavigationResult{Success: true}
+			},
+			SummarizeBranch: kitInstance.SummarizeBranch,
+			CollapseBranch: func(fromID, toID, summary string) extensions.TreeNavigationResult {
+				err := kitInstance.CollapseBranch(fromID, toID, summary)
+				if err != "" {
+					return extensions.TreeNavigationResult{Success: false, Error: err}
+				}
+				return extensions.TreeNavigationResult{Success: true}
+			},
+
+			// -------------------------------------------------------------------------
+			// Skill Loading API (Phase 2 Bridge)
+			// -------------------------------------------------------------------------
+			LoadSkill: func(path string) (*extensions.Skill, string) {
+				s, err := kitInstance.LoadSkillForExtension(path)
+				return s, err
+			},
+			LoadSkillsFromDir: func(dir string) extensions.SkillLoadResult {
+				return kitInstance.LoadSkillsFromDirForExtension(dir)
+			},
+			DiscoverSkills: func() extensions.SkillLoadResult {
+				skills := kitInstance.DiscoverSkillsForExtension()
+				return extensions.SkillLoadResult{Skills: skills}
+			},
+			InjectSkillAsContext: func(skillName string) string {
+				// Find skill by name
+				skills := kitInstance.DiscoverSkillsForExtension()
+				for _, s := range skills {
+					if s.Name == skillName {
+						// Inject via SendMessage as a system context message
+						appInstance.Run(fmt.Sprintf("<skill name=%q>\n%s\n</skill>", s.Name, s.Content))
+						return ""
+					}
+				}
+				return fmt.Sprintf("skill not found: %s", skillName)
+			},
+			InjectRawSkillAsContext: func(path string) string {
+				s, err := kitInstance.LoadSkillForExtension(path)
+				if err != "" {
+					return err
+				}
+				appInstance.Run(fmt.Sprintf("<skill name=%q>\n%s\n</skill>", s.Name, s.Content))
+				return ""
+			},
+			GetAvailableSkills: kitInstance.DiscoverSkillsForExtension,
+
+			// -------------------------------------------------------------------------
+			// Template Parsing API (Phase 3 Bridge)
+			// -------------------------------------------------------------------------
+			ParseTemplate:        kit.ParseTemplate,
+			RenderTemplate:       kit.RenderTemplate,
+			ParseArguments:       kit.ParseArguments,
+			SimpleParseArguments: kit.SimpleParseArguments,
+			EvaluateModelConditional: func(condition string) bool {
+				return kit.EvaluateModelConditional(kitInstance.GetExtensionContext().Model, condition)
+			},
+			RenderWithModelConditionals: func(content string) string {
+				return kit.RenderWithModelConditionals(content, kitInstance.GetExtensionContext().Model)
+			},
+
+			// -------------------------------------------------------------------------
+			// Model Resolution API (Phase 4 Bridge)
+			// -------------------------------------------------------------------------
+			ResolveModelChain: kit.ResolveModelChain,
+			GetModelCapabilities: func(model string) (extensions.ModelCapabilities, string) {
+				return kit.GetModelCapabilities(model)
+			},
+			CheckModelAvailable: kit.CheckModelAvailable,
+			GetCurrentProvider: func() string {
+				return kit.GetCurrentProvider(kitInstance.GetExtensionContext().Model)
+			},
+			GetCurrentModelID: func() string {
+				return kit.GetCurrentModelID(kitInstance.GetExtensionContext().Model)
+			},
 		})
 		kitInstance.EmitSessionStart()
+
+		// Restore normal print functions for runtime use.
+		kitInstance.SetExtensionContext(extensions.Context{
+			CWD:           cwd,
+			Model:         modelName,
+			Interactive:   positionalPrompt == "",
+			Print:         func(text string) { appInstance.PrintFromExtension("", text) },
+			PrintInfo:     func(text string) { appInstance.PrintFromExtension("info", text) },
+			PrintError:    func(text string) { appInstance.PrintFromExtension("error", text) },
+			PrintBlock:    appInstance.PrintBlockFromExtension,
+			SendMessage:   func(text string) { appInstance.Run(text) },
+			CancelAndSend: func(text string) { appInstance.InterruptAndSend(text) },
+			Exit:          func() { appInstance.QuitFromExtension() },
+			SetWidget: func(config extensions.WidgetConfig) {
+				kitInstance.SetExtensionWidget(config)
+				appInstance.NotifyWidgetUpdate()
+			},
+			RemoveWidget: func(id string) {
+				kitInstance.RemoveExtensionWidget(id)
+				appInstance.NotifyWidgetUpdate()
+			},
+			SetHeader: func(config extensions.HeaderFooterConfig) {
+				kitInstance.SetExtensionHeader(config)
+				appInstance.NotifyWidgetUpdate()
+			},
+			RemoveHeader: func() {
+				kitInstance.RemoveExtensionHeader()
+				appInstance.NotifyWidgetUpdate()
+			},
+			SetFooter: func(config extensions.HeaderFooterConfig) {
+				kitInstance.SetExtensionFooter(config)
+				appInstance.NotifyWidgetUpdate()
+			},
+			RemoveFooter: func() {
+				kitInstance.RemoveExtensionFooter()
+				appInstance.NotifyWidgetUpdate()
+			},
+			PromptSelect: func(config extensions.PromptSelectConfig) extensions.PromptSelectResult {
+				ch := make(chan app.PromptResponse, 1)
+				appInstance.SendPromptRequest(app.PromptRequestEvent{
+					PromptType: "select",
+					Message:    config.Message,
+					Options:    config.Options,
+					ResponseCh: ch,
+				})
+				resp := <-ch
+				if resp.Cancelled {
+					return extensions.PromptSelectResult{Cancelled: true}
+				}
+				return extensions.PromptSelectResult{Value: resp.Value, Index: resp.Index}
+			},
+			PromptConfirm: func(config extensions.PromptConfirmConfig) extensions.PromptConfirmResult {
+				ch := make(chan app.PromptResponse, 1)
+				def := "false"
+				if config.DefaultValue {
+					def = "true"
+				}
+				appInstance.SendPromptRequest(app.PromptRequestEvent{
+					PromptType: "confirm",
+					Message:    config.Message,
+					Default:    def,
+					ResponseCh: ch,
+				})
+				resp := <-ch
+				if resp.Cancelled {
+					return extensions.PromptConfirmResult{Cancelled: true}
+				}
+				return extensions.PromptConfirmResult{Value: resp.Confirmed}
+			},
+			PromptInput: func(config extensions.PromptInputConfig) extensions.PromptInputResult {
+				ch := make(chan app.PromptResponse, 1)
+				appInstance.SendPromptRequest(app.PromptRequestEvent{
+					PromptType:  "input",
+					Message:     config.Message,
+					Placeholder: config.Placeholder,
+					Default:     config.Default,
+					ResponseCh:  ch,
+				})
+				resp := <-ch
+				if resp.Cancelled {
+					return extensions.PromptInputResult{Cancelled: true}
+				}
+				return extensions.PromptInputResult{Value: resp.Value}
+			},
+			ShowOverlay: func(config extensions.OverlayConfig) extensions.OverlayResult {
+				ch := make(chan app.OverlayResponse, 1)
+				appInstance.SendOverlayRequest(app.OverlayRequestEvent{
+					Title:       config.Title,
+					Content:     config.Content.Text,
+					Markdown:    config.Content.Markdown,
+					BorderColor: config.Style.BorderColor,
+					Background:  config.Style.Background,
+					Width:       config.Width,
+					MaxHeight:   config.MaxHeight,
+					Anchor:      string(config.Anchor),
+					Actions:     config.Actions,
+					ResponseCh:  ch,
+				})
+				resp := <-ch
+				if resp.Cancelled {
+					return extensions.OverlayResult{Cancelled: true, Index: -1}
+				}
+				return extensions.OverlayResult{
+					Action: resp.Action,
+					Index:  resp.Index,
+				}
+			},
+			SpawnSubagent: func(config extensions.SubagentConfig) (*extensions.SubagentHandle, *extensions.SubagentResult, error) {
+				// In-process subagent via SDK.
+				sdkCfg := kit.SubagentConfig{
+					Prompt:       config.Prompt,
+					Model:        config.Model,
+					SystemPrompt: config.SystemPrompt,
+					Timeout:      config.Timeout,
+					NoSession:    config.NoSession,
+				}
+				// Bridge SDK events to extension SubagentEvents.
+				if config.OnEvent != nil {
+					sdkCfg.OnEvent = func(e kit.Event) {
+						se := sdkEventToSubagentEvent(e)
+						if se.Type != "" {
+							config.OnEvent(se)
+						}
+					}
+				}
+				result, err := kitInstance.Subagent(ctx, sdkCfg)
+				if result == nil {
+					return nil, &extensions.SubagentResult{Error: err}, err
+				}
+				extResult := &extensions.SubagentResult{
+					Response:  result.Response,
+					Error:     result.Error,
+					SessionID: result.SessionID,
+					Elapsed:   result.Elapsed,
+				}
+				if result.Usage != nil {
+					extResult.Usage = &extensions.SubagentUsage{
+						InputTokens:  result.Usage.InputTokens,
+						OutputTokens: result.Usage.OutputTokens,
+					}
+				}
+				return nil, extResult, err
+			},
+
+			// -------------------------------------------------------------------------
+			// Tree Navigation API (Phase 1 Bridge) - Second Context
+			// -------------------------------------------------------------------------
+			GetTreeNode: func(entryID string) *extensions.TreeNode {
+				node := kitInstance.GetTreeNode(entryID)
+				if node == nil {
+					return nil
+				}
+				return &extensions.TreeNode{
+					ID:        node.ID,
+					ParentID:  node.ParentID,
+					Type:      node.Type,
+					Role:      node.Role,
+					Content:   node.Content,
+					Model:     node.Model,
+					Provider:  node.Provider,
+					Timestamp: node.Timestamp,
+					Children:  node.Children,
+				}
+			},
+			GetCurrentBranch: func() []extensions.TreeNode {
+				nodes := kitInstance.GetCurrentBranch()
+				result := make([]extensions.TreeNode, len(nodes))
+				for i, n := range nodes {
+					result[i] = extensions.TreeNode{
+						ID:        n.ID,
+						ParentID:  n.ParentID,
+						Type:      n.Type,
+						Role:      n.Role,
+						Content:   n.Content,
+						Model:     n.Model,
+						Provider:  n.Provider,
+						Timestamp: n.Timestamp,
+						Children:  n.Children,
+					}
+				}
+				return result
+			},
+			GetChildren: kitInstance.GetChildren,
+			NavigateTo: func(entryID string) extensions.TreeNavigationResult {
+				err := kitInstance.NavigateTo(entryID)
+				if err != "" {
+					return extensions.TreeNavigationResult{Success: false, Error: err}
+				}
+				return extensions.TreeNavigationResult{Success: true}
+			},
+			SummarizeBranch: kitInstance.SummarizeBranch,
+			CollapseBranch: func(fromID, toID, summary string) extensions.TreeNavigationResult {
+				err := kitInstance.CollapseBranch(fromID, toID, summary)
+				if err != "" {
+					return extensions.TreeNavigationResult{Success: false, Error: err}
+				}
+				return extensions.TreeNavigationResult{Success: true}
+			},
+
+			// -------------------------------------------------------------------------
+			// Skill Loading API (Phase 2 Bridge) - Second Context
+			// -------------------------------------------------------------------------
+			LoadSkill: func(path string) (*extensions.Skill, string) {
+				s, err := kitInstance.LoadSkillForExtension(path)
+				return s, err
+			},
+			LoadSkillsFromDir: func(dir string) extensions.SkillLoadResult {
+				return kitInstance.LoadSkillsFromDirForExtension(dir)
+			},
+			DiscoverSkills: func() extensions.SkillLoadResult {
+				skills := kitInstance.DiscoverSkillsForExtension()
+				return extensions.SkillLoadResult{Skills: skills}
+			},
+			InjectSkillAsContext: func(skillName string) string {
+				skills := kitInstance.DiscoverSkillsForExtension()
+				for _, s := range skills {
+					if s.Name == skillName {
+						appInstance.Run(fmt.Sprintf("<skill name=%q>\n%s\n</skill>", s.Name, s.Content))
+						return ""
+					}
+				}
+				return fmt.Sprintf("skill not found: %s", skillName)
+			},
+			InjectRawSkillAsContext: func(path string) string {
+				s, err := kitInstance.LoadSkillForExtension(path)
+				if err != "" {
+					return err
+				}
+				appInstance.Run(fmt.Sprintf("<skill name=%q>\n%s\n</skill>", s.Name, s.Content))
+				return ""
+			},
+			GetAvailableSkills: func() []extensions.Skill {
+				return kitInstance.DiscoverSkillsForExtension()
+			},
+
+			// -------------------------------------------------------------------------
+			// Template Parsing API (Phase 3 Bridge) - Second Context
+			// -------------------------------------------------------------------------
+			ParseTemplate:        kit.ParseTemplate,
+			RenderTemplate:       kit.RenderTemplate,
+			ParseArguments:       kit.ParseArguments,
+			SimpleParseArguments: kit.SimpleParseArguments,
+			EvaluateModelConditional: func(condition string) bool {
+				return kit.EvaluateModelConditional(kitInstance.GetExtensionContext().Model, condition)
+			},
+			RenderWithModelConditionals: func(content string) string {
+				return kit.RenderWithModelConditionals(content, kitInstance.GetExtensionContext().Model)
+			},
+
+			// -------------------------------------------------------------------------
+			// Model Resolution API (Phase 4 Bridge) - Second Context
+			// -------------------------------------------------------------------------
+			ResolveModelChain: kit.ResolveModelChain,
+			GetModelCapabilities: func(model string) (extensions.ModelCapabilities, string) {
+				return kit.GetModelCapabilities(model)
+			},
+			CheckModelAvailable: kit.CheckModelAvailable,
+			GetCurrentProvider: func() string {
+				return kit.GetCurrentProvider(kitInstance.GetExtensionContext().Model)
+			},
+			GetCurrentModelID: func() string {
+				return kit.GetCurrentModelID(kitInstance.GetExtensionContext().Model)
+			},
+		})
 	}
 
 	// Convert extension commands to UI-layer type for the interactive TUI.
 	extCommands := extensionCommandsForUI(kitInstance)
 
+	// Load prompt templates from standard locations and explicit paths.
+	var promptTemplates []*prompts.PromptTemplate
+	if !noPromptTemplates {
+		homeDir, _ := os.UserHomeDir()
+		cwd, _ := os.Getwd()
+		tpls, diags, err := prompts.LoadAll(prompts.LoadOptions{
+			Cwd:             cwd,
+			HomeDir:         homeDir,
+			ExtraPaths:      promptTemplatePaths,
+			ConfigPaths:     viper.GetStringSlice("prompts"),
+			IncludeDefaults: true,
+		})
+		if err != nil {
+			log.Printf("Warning: failed to load some prompt templates: %v", err)
+		}
+		promptTemplates = tpls
+		for _, d := range diags {
+			log.Printf("Prompt template collision: /%s kept from %s, dropped from %s", d.Name, d.KeptPath, d.DroppedPath)
+		}
+	}
+
 	// Build context/skills display metadata for the startup banner.
 	var contextPaths []string
 	for _, cf := range kitInstance.GetContextFiles() {
@@ -1013,6 +1565,24 @@ func runNormalMode(ctx context.Context) error {
 		// this callback runs synchronously inside BubbleTea's Update(), and
 		// NotifyModelChanged calls prog.Send() which deadlocks. The UI layer
 		// updates m.providerName and m.modelName directly after setModel returns.
+		// Update usage tracker with new model info for correct token counting.
+		if usageTracker != nil {
+			newProvider, newModel, _ := models.ParseModelString(modelString)
+			if newProvider != "unknown" && newModel != "unknown" && newProvider != "ollama" {
+				registry := models.GetGlobalRegistry()
+				if modelInfo := registry.LookupModel(newProvider, newModel); modelInfo != nil {
+					// Check OAuth status for Anthropic models
+					isOAuth := false
+					if newProvider == "anthropic" {
+						_, source, err := auth.GetAnthropicAPIKey(viper.GetString("provider-api-key"))
+						if err == nil && strings.HasPrefix(source, "stored OAuth") {
+							isOAuth = true
+						}
+					}
+					usageTracker.UpdateModelInfo(modelInfo, newProvider, isOAuth)
+				}
+			}
+		}
 		return nil
 	}
 	emitModelChangeForUI := func(newModel, previousModel, source string) {
@@ -1024,9 +1594,21 @@ func runNormalMode(ctx context.Context) error {
 		return kitInstance.SetThinkingLevel(context.Background(), level)
 	}
 
+	// Build session-switching callback. Opens a JSONL session file and
+	// replaces the active tree session on both the Kit SDK and App layer.
+	switchSessionForUI := func(path string) error {
+		ts, err := kit.OpenTreeSession(path)
+		if err != nil {
+			return fmt.Errorf("failed to open session: %w", err)
+		}
+		kitInstance.SetTreeSession(ts)
+		appInstance.SwitchTreeSession(ts)
+		return nil
+	}
+
 	// Check if running in non-interactive mode
 	if positionalPrompt != "" {
-		return runNonInteractiveModeApp(ctx, appInstance, cli, positionalPrompt, quietFlag, jsonFlag, noExitFlag, modelName, parsedProvider, kitInstance.GetLoadingMessage(), serverNames, toolNames, mcpToolCount, extensionToolCount, usageTracker, extCommands, contextPaths, skillItems, getWidgets, getHeader, getFooter, getToolRenderer, getEditorInterceptor, getUIVisibility, getStatusBarEntries, emitBeforeFork, emitBeforeSessionSwitch, getGlobalShortcuts, getExtensionCommands, setModelForUI, emitModelChangeForUI, kitInstance.IsReasoningModel(), kitInstance.GetThinkingLevel(), setThinkingLevelForUI)
+		return runNonInteractiveModeApp(ctx, appInstance, cli, positionalPrompt, quietFlag, jsonFlag, noExitFlag, modelName, parsedProvider, kitInstance.GetLoadingMessage(), serverNames, toolNames, mcpToolCount, extensionToolCount, usageTracker, extCommands, promptTemplates, contextPaths, skillItems, getWidgets, getHeader, getFooter, getToolRenderer, getEditorInterceptor, getUIVisibility, getStatusBarEntries, emitBeforeFork, emitBeforeSessionSwitch, getGlobalShortcuts, getExtensionCommands, setModelForUI, emitModelChangeForUI, kitInstance.IsReasoningModel(), kitInstance.GetThinkingLevel(), setThinkingLevelForUI, switchSessionForUI)
 	}
 
 	// Quiet mode is not allowed in interactive mode
@@ -1034,7 +1616,7 @@ func runNormalMode(ctx context.Context) error {
 		return fmt.Errorf("--quiet requires a prompt")
 	}
 
-	return runInteractiveModeBubbleTea(ctx, appInstance, modelName, parsedProvider, kitInstance.GetLoadingMessage(), serverNames, toolNames, mcpToolCount, extensionToolCount, usageTracker, extCommands, contextPaths, skillItems, getWidgets, getHeader, getFooter, getToolRenderer, getEditorInterceptor, getUIVisibility, getStatusBarEntries, emitBeforeFork, emitBeforeSessionSwitch, getGlobalShortcuts, getExtensionCommands, setModelForUI, emitModelChangeForUI, kitInstance.IsReasoningModel(), kitInstance.GetThinkingLevel(), setThinkingLevelForUI)
+	return runInteractiveModeBubbleTea(ctx, appInstance, modelName, parsedProvider, kitInstance.GetLoadingMessage(), serverNames, toolNames, mcpToolCount, extensionToolCount, usageTracker, extCommands, promptTemplates, contextPaths, skillItems, getWidgets, getHeader, getFooter, getToolRenderer, getEditorInterceptor, getUIVisibility, getStatusBarEntries, emitBeforeFork, emitBeforeSessionSwitch, getGlobalShortcuts, getExtensionCommands, setModelForUI, emitModelChangeForUI, kitInstance.IsReasoningModel(), kitInstance.GetThinkingLevel(), setThinkingLevelForUI, switchSessionForUI, startupExtensionMessages)
 }
 
 // runNonInteractiveModeApp executes a single prompt via the app layer and exits,
@@ -1047,7 +1629,7 @@ func runNormalMode(ctx context.Context) error {
 //
 // When --no-exit is set, after the prompt completes the interactive BubbleTea
 // TUI is started so the user can continue the conversation.
-func runNonInteractiveModeApp(ctx context.Context, appInstance *app.App, cli *ui.CLI, prompt string, quiet, jsonOutput, noExit bool, modelName, providerName, loadingMessage string, serverNames, toolNames []string, mcpToolCount, extensionToolCount int, usageTracker *ui.UsageTracker, extCommands []ui.ExtensionCommand, contextPaths []string, skillItems []ui.SkillItem, getWidgets func(string) []ui.WidgetData, getHeader, getFooter func() *ui.WidgetData, getToolRenderer func(string) *ui.ToolRendererData, getEditorInterceptor func() *ui.EditorInterceptor, getUIVisibility func() *ui.UIVisibility, getStatusBarEntries func() []ui.StatusBarEntryData, emitBeforeFork func(string, bool, string) (bool, string), emitBeforeSessionSwitch func(string) (bool, string), getGlobalShortcuts func() map[string]func(), getExtensionCommands func() []ui.ExtensionCommand, setModel func(string) error, emitModelChange func(string, string, string), isReasoningModel bool, thinkingLevel string, setThinkingLevel func(string) error) error {
+func runNonInteractiveModeApp(ctx context.Context, appInstance *app.App, cli *ui.CLI, prompt string, quiet, jsonOutput, noExit bool, modelName, providerName, loadingMessage string, serverNames, toolNames []string, mcpToolCount, extensionToolCount int, usageTracker *ui.UsageTracker, extCommands []ui.ExtensionCommand, promptTemplates []*prompts.PromptTemplate, contextPaths []string, skillItems []ui.SkillItem, getWidgets func(string) []ui.WidgetData, getHeader, getFooter func() *ui.WidgetData, getToolRenderer func(string) *ui.ToolRendererData, getEditorInterceptor func() *ui.EditorInterceptor, getUIVisibility func() *ui.UIVisibility, getStatusBarEntries func() []ui.StatusBarEntryData, emitBeforeFork func(string, bool, string) (bool, string), emitBeforeSessionSwitch func(string) (bool, string), getGlobalShortcuts func() map[string]func(), getExtensionCommands func() []ui.ExtensionCommand, setModel func(string) error, emitModelChange func(string, string, string), isReasoningModel bool, thinkingLevel string, setThinkingLevel func(string) error, switchSession func(string) error) error {
 	// Expand @file references in the prompt before sending to the agent.
 	if cwd, err := os.Getwd(); err == nil {
 		prompt = ui.ProcessFileAttachments(prompt, cwd)
@@ -1090,7 +1672,7 @@ func runNonInteractiveModeApp(ctx context.Context, appInstance *app.App, cli *ui
 
 	// If --no-exit was requested, hand off to the interactive TUI.
 	if noExit {
-		return runInteractiveModeBubbleTea(ctx, appInstance, modelName, providerName, loadingMessage, serverNames, toolNames, mcpToolCount, extensionToolCount, usageTracker, extCommands, contextPaths, skillItems, getWidgets, getHeader, getFooter, getToolRenderer, getEditorInterceptor, getUIVisibility, getStatusBarEntries, emitBeforeFork, emitBeforeSessionSwitch, getGlobalShortcuts, getExtensionCommands, setModel, emitModelChange, isReasoningModel, thinkingLevel, setThinkingLevel)
+		return runInteractiveModeBubbleTea(ctx, appInstance, modelName, providerName, loadingMessage, serverNames, toolNames, mcpToolCount, extensionToolCount, usageTracker, extCommands, promptTemplates, contextPaths, skillItems, getWidgets, getHeader, getFooter, getToolRenderer, getEditorInterceptor, getUIVisibility, getStatusBarEntries, emitBeforeFork, emitBeforeSessionSwitch, getGlobalShortcuts, getExtensionCommands, setModel, emitModelChange, isReasoningModel, thinkingLevel, setThinkingLevel, switchSession, nil)
 	}
 
 	return nil
@@ -1188,7 +1770,7 @@ func writeJSONError(err error) {
 //  4. Calls program.Run() which blocks until the user quits (Ctrl+C or /quit).
 //
 // SetupCLI is not used for interactive mode; the TUI (AppModel) handles its own rendering.
-func runInteractiveModeBubbleTea(_ context.Context, appInstance *app.App, modelName, providerName, loadingMessage string, serverNames, toolNames []string, mcpToolCount, extensionToolCount int, usageTracker *ui.UsageTracker, extCommands []ui.ExtensionCommand, contextPaths []string, skillItems []ui.SkillItem, getWidgets func(string) []ui.WidgetData, getHeader, getFooter func() *ui.WidgetData, getToolRenderer func(string) *ui.ToolRendererData, getEditorInterceptor func() *ui.EditorInterceptor, getUIVisibility func() *ui.UIVisibility, getStatusBarEntries func() []ui.StatusBarEntryData, emitBeforeFork func(string, bool, string) (bool, string), emitBeforeSessionSwitch func(string) (bool, string), getGlobalShortcuts func() map[string]func(), getExtensionCommands func() []ui.ExtensionCommand, setModel func(string) error, emitModelChange func(string, string, string), isReasoningModel bool, thinkingLevel string, setThinkingLevel func(string) error) error {
+func runInteractiveModeBubbleTea(_ context.Context, appInstance *app.App, modelName, providerName, loadingMessage string, serverNames, toolNames []string, mcpToolCount, extensionToolCount int, usageTracker *ui.UsageTracker, extCommands []ui.ExtensionCommand, promptTemplates []*prompts.PromptTemplate, contextPaths []string, skillItems []ui.SkillItem, getWidgets func(string) []ui.WidgetData, getHeader, getFooter func() *ui.WidgetData, getToolRenderer func(string) *ui.ToolRendererData, getEditorInterceptor func() *ui.EditorInterceptor, getUIVisibility func() *ui.UIVisibility, getStatusBarEntries func() []ui.StatusBarEntryData, emitBeforeFork func(string, bool, string) (bool, string), emitBeforeSessionSwitch func(string) (bool, string), getGlobalShortcuts func() map[string]func(), getExtensionCommands func() []ui.ExtensionCommand, setModel func(string) error, emitModelChange func(string, string, string), isReasoningModel bool, thinkingLevel string, setThinkingLevel func(string) error, switchSession func(string) error, startupExtensionMessages []string) error {
 	// Determine terminal size; fall back gracefully.
 	termWidth, termHeight, err := term.GetSize(int(os.Stdout.Fd()))
 	if err != nil || termWidth == 0 {
@@ -1197,6 +1779,7 @@ func runInteractiveModeBubbleTea(_ context.Context, appInstance *app.App, modelN
 	}
 
 	cwd, _ := os.Getwd()
+
 	appModel := ui.NewAppModel(appInstance, ui.AppModelOptions{
 		CompactMode:             viper.GetBool("compact"),
 		ModelName:               modelName,
@@ -1211,6 +1794,7 @@ func runInteractiveModeBubbleTea(_ context.Context, appInstance *app.App, modelN
 		ExtensionToolCount:      extensionToolCount,
 		UsageTracker:            usageTracker,
 		ExtensionCommands:       extCommands,
+		PromptTemplates:         promptTemplates,
 		ContextPaths:            contextPaths,
 		SkillItems:              skillItems,
 		GetWidgets:              getWidgets,
@@ -1229,11 +1813,22 @@ func runInteractiveModeBubbleTea(_ context.Context, appInstance *app.App, modelN
 		ThinkingLevel:           thinkingLevel,
 		IsReasoningModel:        isReasoningModel,
 		SetThinkingLevel:        setThinkingLevel,
+		SwitchSession:           switchSession,
+		ShowSessionPicker:       resumeFlag,
 	})
 
 	// Print startup info to stdout before Bubble Tea takes over the screen.
 	appModel.PrintStartupInfo()
 
+	// Print any extension messages that were captured during startup.
+	if len(startupExtensionMessages) > 0 {
+		fmt.Println()
+		for _, msg := range startupExtensionMessages {
+			fmt.Println(msg)
+		}
+		fmt.Println()
+	}
+
 	program := tea.NewProgram(appModel)
 
 	// Register the program with the app layer so agent events are sent to the TUI.

cmd/skill.go

@@ -8,19 +8,21 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// skillCmd installs the kit-extensions skill via the skills.sh CLI (npx skills).
-// This teaches AI agents how to create Kit extensions with full knowledge of
-// the extension API, lifecycle events, widgets, tools, commands, and Yaegi constraints.
+// skillCmd installs Kit skills via the skills.sh CLI (npx skills).
 var skillCmd = &cobra.Command{
 	Use:   "skill",
-	Short: "Install the Kit extensions skill via skills.sh",
-	Long: `Install the kit-extensions skill that teaches AI agents how to create
-Kit extensions. Uses the skills.sh CLI (npx skills) to install the skill
-from the Kit repository.
+	Short: "Install Kit skills via skills.sh",
+	Long: `Install Kit skills that teach AI agents how to build with Kit.
+Uses the skills.sh CLI (npx skills) to install all skills from the Kit repository.
 
-The skill provides comprehensive documentation of Kit's extension API including
-lifecycle events, custom tools, slash commands, widgets, editor interceptors,
-tool renderers, and critical Yaegi interpreter constraints.
+Two skills are provided:
+
+  1. Extensions — creating Kit extensions with full knowledge of the extension
+     API, lifecycle events, widgets, tools, commands, editor interceptors,
+     tool renderers, and Yaegi interpreter constraints.
+
+  2. SDK — building AI-powered applications with the Kit Go SDK, including
+     providers, agents, tools, and MCP integration.
 
 Example:
   kit skill`,
@@ -41,8 +43,6 @@ func runSkill(_ *cobra.Command, _ []string) error {
 		"skills",
 		"add",
 		"mark3labs/kit",
-		"--skill",
-		"kit-extensions",
 	}
 
 	cmd := exec.Command(npx, args...)

examples/extensions/README.md

@@ -0,0 +1,197 @@
+# Kit Extension Examples
+
+A collection of example extensions demonstrating various Kit capabilities. These can be installed individually or as a complete collection.
+
+## Installation
+
+### Install all examples
+```bash
+kit install github.com/mark3labs/kit/examples/extensions
+```
+
+### Install with interactive selection
+```bash
+kit install github.com/mark3labs/kit/examples/extensions --select
+```
+
+### Install locally in your project
+```bash
+kit install github.com/mark3labs/kit/examples/extensions --local
+```
+
+## Extension Index
+
+### Core Concepts
+
+| Extension | Description | Key API |
+|-----------|-------------|---------|
+| `minimal.go` | Minimal viable extension | Basic `Init()` function |
+| `plan-mode.go` | Restrict agent to read-only tools | `OnBeforeAgentStart`, `SetActiveTools` |
+| `tool-logger.go` | Log all tool calls to file | `OnToolCall`, `OnToolResult` |
+| `notify.go` | Display notifications | `PrintInfo`, `PrintBlock` |
+
+### UI & Widgets
+
+| Extension | Description | Key API |
+|-----------|-------------|---------|
+| `widget-status.go` | Persistent status widget | `SetWidget`, `RemoveWidget` |
+| `header-footer-demo.go` | Custom header/footer | `SetHeader`, `SetFooter` |
+| `overlay-demo.go` | Modal overlay dialogs | `ShowOverlay` |
+| `compact-notify.go` | Compact mode notifications | `PrintBlock` |
+| `branded-output.go` | Custom styled output | `PrintBlock` with colors |
+
+### Input & Editor
+
+| Extension | Description | Key API |
+|-----------|-------------|---------|
+| `custom-editor-demo.go` | Custom key handling | `SetEditor`, `EditorKeyAction` |
+| `pirate.go` | Transform user input | `OnInput`, `InputResult` |
+| `interactive-shell.go` | Custom command input | Slash commands with prompts |
+| `inline-bash.go` | Execute bash inline | Input handling, `exec` |
+
+### Session & Context
+
+| Extension | Description | Key API |
+|-----------|-------------|---------|
+| `context-inject.go` | Inject context into prompts | `OnContextPrepare` |
+| `bookmark.go` | Bookmark messages | `AppendEntry`, `GetEntries` |
+| `project-rules.go` | Project-specific rules | Session data, file reading |
+| `protected-paths.go` | Block dangerous operations | `OnToolCall` with blocking |
+| `permission-gate.go` | Confirm destructive actions | `OnToolCall` with confirmation |
+
+### Tools & Commands
+
+| Extension | Description | Key API |
+|-----------|-------------|---------|
+| `auto-commit.go` | Auto-commit changes | Custom tool, git operations |
+| `summarize.go` | Summarize conversation | Custom tool with parameters |
+| `confirm-destructive.go` | Confirm destructive commands | `OnToolCall` blocking |
+| `lsp-diagnostics.go` | LSP integration | Complex extension, external process |
+
+### Subagents & Background Tasks
+
+| Extension | Description | Key API |
+|-----------|-------------|---------|
+| `kit-kit.go` | Spawn Kit as subagent | Subagent spawning |
+| `subagent-test.go` | Test subagent functionality | `SpawnSubagent` |
+| `subagent-widget.go` | Widget with subagent updates | Goroutines + widgets |
+| `dev-reload.go` | Hot reload extensions | `ReloadExtensions` |
+
+### Integrations
+
+| Extension | Description | Key API |
+|-----------|-------------|---------|
+| `kit-telegram/` | Telegram relay for remote monitoring & control | `RegisterCommand`, `OnAgentStart/End`, `SetStatus`, `SendMessage` |
+
+### Themes
+
+| Extension | Description | Key API |
+|-----------|-------------|---------|
+| `neon-theme.go` | Register and switch custom themes | `RegisterTheme`, `SetTheme` |
+
+### Rendering
+
+| Extension | Description | Key API |
+|-----------|-------------|---------|
+| `tool-renderer-demo.go` | Custom tool output styling | `RegisterToolRenderer` |
+| `prompt-demo.go` | Interactive prompts | `PromptSelect`, `PromptConfirm` |
+
+## Extension Details
+
+### minimal.go
+The bare minimum extension showing the required structure:
+- Package `main`
+- Import `kit/ext`
+- Export `Init(api ext.API)` function
+
+### plan-mode.go
+A complete example demonstrating:
+- Slash command (`/plan`)
+- Keyboard shortcut (`ctrl+alt+p`)
+- Option registration
+- Status bar indicators
+- System prompt injection
+- Tool filtering
+
+### widget-status.go
+Shows how to create persistent UI elements:
+- Create widgets with `SetWidget`
+- Update content dynamically
+- Remove when done
+- Handle session lifecycle
+
+### context-inject.go
+Advanced context manipulation:
+- Read project files
+- Inject into LLM context
+- Filter messages
+- Use negative indices for ephemeral content
+
+### lsp-diagnostics.go
+Complex real-world example:
+- Multi-file extension
+- External process management (LSP server)
+- File watching
+- Diagnostics aggregation
+
+### kit-telegram/
+Full-featured Telegram integration:
+- Slash command with subcommands and tab completion
+- Interactive guided setup flow with prompts
+- Background long-polling goroutine
+- Progress message rendering edited in place
+- Message queue with edit-before-dispatch
+- Remote command handling from Telegram
+- Status bar and widget updates
+- Config persistence with atomic writes
+
+## Multi-File Extension Example
+
+The `kit-kit-agents/` directory demonstrates the multi-file pattern:
+
+```
+kit-kit-agents/
+├── main.go          # Entry point with Init()
+├── agent.go         # Agent configuration
+├── manager.go       # Agent lifecycle management
+└── README.md        # Documentation
+```
+
+When the repo is installed, all files in subdirectories with `main.go` are loaded as separate extensions.
+
+## Testing & Validation
+
+After installing, test the extensions:
+
+```bash
+# List all loaded extensions
+kit extensions list
+
+# Validate all extensions
+kit extensions validate
+
+# Run with a specific extension
+kit -e ~/.local/share/kit/git/github.com/mark3labs/kit/examples/extensions/plan-mode.go
+```
+
+## Creating Your Own
+
+1. Copy `minimal.go` as a starting point
+2. Modify the `Init()` function to register your handlers
+3. Use the other examples for reference on specific APIs
+4. Test with `kit -e your-extension.go`
+5. Share by pushing to a git repository!
+
+## Update
+
+To get the latest examples:
+
+```bash
+kit install github.com/mark3labs/kit/examples/extensions --update
+```
+
+## See Also
+
+- [Kit Extensions Guide](https://github.com/mark3labs/kit/blob/main/.agents/skills/kit-extensions/SKILL.md)
+- [API Reference](https://github.com/mark3labs/kit/blob/main/internal/extensions/api.go)
+- [Example Extensions Source](https://github.com/mark3labs/kit/tree/main/examples/extensions)

examples/extensions/auto-commit.go

@@ -23,8 +23,7 @@ import (
 func Init(api ext.API) {
 	api.OnSessionShutdown(func(_ ext.SessionShutdownEvent, ctx ext.Context) {
 		// Check for staged changes.
-		diff, err := exec.Command("git", "diff", "--cached", "--quiet").CombinedOutput()
-		_ = diff
+		err := exec.Command("git", "diff", "--cached", "--quiet").Run()
 		if err == nil {
 			return // exit code 0 means no staged changes
 		}

examples/extensions/bridge_demo.go

@@ -0,0 +1,170 @@
+//go:build ignore
+
+// bridge_demo.go - Demonstrates the new bridged SDK APIs for extensions.
+// This extension showcases tree navigation, skill loading, template parsing,
+// and model resolution capabilities.
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"kit/ext"
+)
+
+var (
+	discoveredSkills []ext.Skill
+	currentBranch    []ext.TreeNode
+)
+
+func Init(api ext.API) {
+	// Register /tree-info command to demonstrate tree navigation
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "tree-info",
+		Description: "Show current conversation tree information",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			branch := ctx.GetCurrentBranch()
+			info := fmt.Sprintf("Current branch has %d nodes:\n", len(branch))
+			for i, node := range branch {
+				info += fmt.Sprintf("  [%d] %s (%s): %s...\n", i, node.Type, node.ID[:8], truncate(node.Content, 40))
+			}
+			ctx.PrintInfo(info)
+			return "", nil
+		},
+	})
+
+	// Register /discover-skills command
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "discover-skills",
+		Description: "Discover and list available skills",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			result := ctx.DiscoverSkills()
+			if result.Error != "" {
+				return "", fmt.Errorf("discovery failed: %s", result.Error)
+			}
+			discoveredSkills = result.Skills
+
+			info := fmt.Sprintf("Discovered %d skills:\n", len(result.Skills))
+			for _, s := range result.Skills {
+				info += fmt.Sprintf("  - %s: %s\n", s.Name, s.Description)
+			}
+			ctx.PrintInfo(info)
+			return "", nil
+		},
+	})
+
+	// Register /parse-template command
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "parse-template",
+		Description: "Parse a template and show extracted variables",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			if args == "" {
+				args = "Hello {{name}}, welcome to {{place}}!"
+			}
+			tpl := ctx.ParseTemplate("demo", args)
+			info := fmt.Sprintf("Template: %s\nVariables: %v", tpl.Content, tpl.Variables)
+			ctx.PrintInfo(info)
+			return "", nil
+		},
+	})
+
+	// Register /render-template command
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "render-template",
+		Description: "Render a template with variables (usage: /render-template name=John place=Kit)",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			tpl := ctx.ParseTemplate("demo", "Hello {{name}}, welcome to {{place}}!")
+			vars := ctx.ParseArguments(args, ext.ArgumentPattern{
+				Flags: map[string]string{"name": "name", "place": "place"},
+			})
+			rendered := ctx.RenderTemplate(tpl, vars.Vars)
+			ctx.PrintInfo("Rendered: " + rendered)
+			return "", nil
+		},
+	})
+
+	// Register /check-model command
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "check-model",
+		Description: "Check model capabilities and availability",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			model := args
+			if model == "" {
+				model = ctx.Model
+			}
+
+			available := ctx.CheckModelAvailable(model)
+			caps, err := ctx.GetModelCapabilities(model)
+
+			info := fmt.Sprintf("Model: %s\n", model)
+			info += fmt.Sprintf("Available: %v\n", available)
+			if err == "" {
+				info += fmt.Sprintf("Provider: %s\n", caps.Provider)
+				info += fmt.Sprintf("Context Limit: %d\n", caps.ContextLimit)
+				info += fmt.Sprintf("Reasoning: %v\n", caps.Reasoning)
+			} else {
+				info += fmt.Sprintf("Error: %s\n", err)
+			}
+			ctx.PrintInfo(info)
+			return "", nil
+		},
+	})
+
+	// Register /resolve-chain command
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "resolve-chain",
+		Description: "Resolve a model chain (usage: /resolve-chain claude-opus,gpt-4o,claude-sonnet)",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			if args == "" {
+				args = "anthropic/claude-opus-4,anthropic/claude-sonnet-4,openai/gpt-4o"
+			}
+			prefs := ctx.SimpleParseArguments(args, 1)
+			chain := []string{}
+			if len(prefs) > 1 {
+				// Split the first arg by comma
+				for _, p := range strings.Split(prefs[1], ",") {
+					p = strings.TrimSpace(p)
+					if p != "" {
+						chain = append(chain, p)
+					}
+				}
+			}
+
+			result := ctx.ResolveModelChain(chain)
+			info, _ := json.MarshalIndent(result, "", "  ")
+			ctx.PrintInfo("Resolution Result:\n" + string(info))
+			return "", nil
+		},
+	})
+
+	// Register /test-conditional command
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "test-conditional",
+		Description: "Test model conditional rendering",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			content := `<if-model is="claude-*">This is for Claude models<else>This is for other models</if-model>`
+			rendered := ctx.RenderWithModelConditionals(content)
+			ctx.PrintInfo("Input: " + content)
+			ctx.PrintInfo("Output: " + rendered)
+			ctx.PrintInfo(fmt.Sprintf("Current model matches 'claude-*': %v", ctx.EvaluateModelConditional("claude-*")))
+			return "", nil
+		},
+	})
+
+	// OnSessionStart: discover skills automatically
+	api.OnSessionStart(func(e ext.SessionStartEvent, ctx ext.Context) {
+		result := ctx.DiscoverSkills()
+		if result.Error == "" && len(result.Skills) > 0 {
+			discoveredSkills = result.Skills
+			ctx.SetStatus("bridge-demo", fmt.Sprintf("%d skills", len(result.Skills)), 50)
+		}
+	})
+}
+
+func truncate(s string, max int) string {
+	if len(s) <= max {
+		return s
+	}
+	return s[:max-3] + "..."
+}

examples/extensions/conversation-manager.go

@@ -0,0 +1,406 @@
+//go:build ignore
+
+// conversation-manager.go - Advanced conversation tree navigation and management.
+// This extension demonstrates:
+// - Tree navigation (GetTreeNode, GetCurrentBranch, NavigateTo)
+// - Branch summarization and collapsing
+// - Interactive tree exploration
+//
+// Commands:
+//   /tree              - Show conversation tree structure
+//   /branch            - Show current branch path
+//   /goto <entry-id>   - Navigate to a specific entry
+//   /summarize <n>     - Summarize last N messages
+//   /fresh-context     - Collapse branch and start fresh
+//   /loop <n> <prompt> - Execute prompt N times with fresh context each iteration
+
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"kit/ext"
+)
+
+var (
+	loopActive    bool
+	loopCount     int
+	loopCurrent   int
+	loopPrompt    string
+	loopStartNode string
+)
+
+func Init(api ext.API) {
+	// /tree - Show tree structure
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "tree",
+		Description: "Show conversation tree structure",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			showTree(ctx)
+			return "", nil
+		},
+	})
+
+	// /branch - Show current branch
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "branch",
+		Description: "Show current conversation branch",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			showBranch(ctx)
+			return "", nil
+		},
+	})
+
+	// /goto - Navigate to entry
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "goto",
+		Description: "Navigate to a specific entry ID (usage: /goto <entry-id>)",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			if args == "" {
+				ctx.PrintError("Usage: /goto <entry-id>")
+				return "", nil
+			}
+			result := ctx.NavigateTo(args)
+			if !result.Success {
+				ctx.PrintError(fmt.Sprintf("Navigation failed: %s", result.Error))
+				return "", nil
+			}
+			ctx.PrintInfo(fmt.Sprintf("Navigated to entry: %s", args))
+
+			// Show the node we navigated to
+			node := ctx.GetTreeNode(args)
+			if node != nil {
+				ctx.PrintInfo(fmt.Sprintf("Entry type: %s, Role: %s", node.Type, node.Role))
+			}
+			return "", nil
+		},
+	})
+
+	// /summarize - Summarize recent messages
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "summarize",
+		Description: "Summarize last N messages (usage: /summarize [n=5])",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			n := 5
+			if args != "" {
+				if parsed, err := strconv.Atoi(args); err == nil && parsed > 0 {
+					n = parsed
+				}
+			}
+
+			branch := ctx.GetCurrentBranch()
+			if len(branch) < 2 {
+				ctx.PrintError("Not enough messages to summarize")
+				return "", nil
+			}
+
+			// Find range to summarize
+			startIdx := len(branch) - n - 1
+			if startIdx < 0 {
+				startIdx = 0
+			}
+			endIdx := len(branch) - 1
+
+			fromID := branch[startIdx].ID
+			toID := branch[endIdx].ID
+
+			ctx.PrintInfo(fmt.Sprintf("Summarizing messages %d to %d...", startIdx, endIdx))
+			summary := ctx.SummarizeBranch(fromID, toID)
+
+			if summary == "" {
+				ctx.PrintError("Failed to generate summary")
+				return "", nil
+			}
+
+			ctx.PrintBlock(ext.PrintBlockOpts{
+				Text:        summary,
+				BorderColor: "#89b4fa",
+				Subtitle:    "conversation-manager · Summary",
+			})
+			return "", nil
+		},
+	})
+
+	// /fresh-context - Collapse and restart
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "fresh-context",
+		Description: "Collapse conversation to summary and start fresh",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			branch := ctx.GetCurrentBranch()
+			if len(branch) < 3 {
+				ctx.PrintError("Not enough context to collapse")
+				return "", nil
+			}
+
+			// Keep first message (system), summarize rest
+			fromID := branch[1].ID
+			toID := branch[len(branch)-1].ID
+
+			ctx.PrintInfo("Generating summary for context collapse...")
+			summary := ctx.SummarizeBranch(fromID, toID)
+
+			if summary == "" {
+				ctx.PrintError("Failed to generate summary")
+				return "", nil
+			}
+
+			// Collapse the branch
+			result := ctx.CollapseBranch(fromID, toID, summary)
+			if !result.Success {
+				ctx.PrintError(fmt.Sprintf("Collapse failed: %s", result.Error))
+				return "", nil
+			}
+
+			ctx.PrintInfo("Context collapsed. Starting fresh with summary.")
+			ctx.PrintBlock(ext.PrintBlockOpts{
+				Text:        summary,
+				BorderColor: "#a6e3a1",
+				Subtitle:    "conversation-manager · Collapsed Context",
+			})
+
+			// Set a widget showing we're in fresh mode
+			ctx.SetWidget(ext.WidgetConfig{
+				ID:        "fresh-context",
+				Placement: ext.WidgetAbove,
+				Content:   ext.WidgetContent{Text: "🌱 Fresh Context Mode - Previous conversation collapsed"},
+				Style:     ext.WidgetStyle{BorderColor: "#a6e3a1"},
+			})
+
+			return "", nil
+		},
+	})
+
+	// /loop - Execute with fresh context each iteration
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "loop",
+		Description: "Execute prompt N times with fresh context (usage: /loop 5 analyze this code)",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			if loopActive {
+				ctx.PrintError("Loop already in progress. Wait for completion.")
+				return "", nil
+			}
+
+			// Parse arguments
+			parts := strings.SplitN(args, " ", 2)
+			if len(parts) < 2 {
+				ctx.PrintError("Usage: /loop <count> <prompt>")
+				return "", nil
+			}
+
+			count, err := strconv.Atoi(parts[0])
+			if err != nil || count <= 0 || count > 10 {
+				ctx.PrintError("Invalid count (must be 1-10)")
+				return "", nil
+			}
+
+			loopCount = count
+			loopCurrent = 0
+			loopPrompt = parts[1]
+			loopActive = true
+
+			// Store current branch position
+			branch := ctx.GetCurrentBranch()
+			if len(branch) > 0 {
+				loopStartNode = branch[len(branch)-1].ID
+			}
+
+			ctx.PrintInfo(fmt.Sprintf("Starting loop: %d iterations", loopCount))
+			ctx.SetWidget(ext.WidgetConfig{
+				ID:        "loop-progress",
+				Placement: ext.WidgetAbove,
+				Content:   ext.WidgetContent{Text: fmt.Sprintf("🔄 Loop: 0/%d - %s", loopCount, loopPrompt)},
+				Style:     ext.WidgetStyle{BorderColor: "#fab387"},
+			})
+
+			// Start first iteration
+			executeLoopIteration(ctx)
+			return "", nil
+		},
+	})
+
+	// OnAgentEnd handles loop continuation
+	api.OnAgentEnd(func(e ext.AgentEndEvent, ctx ext.Context) {
+		if !loopActive {
+			return
+		}
+
+		loopCurrent++
+
+		if loopCurrent >= loopCount {
+			// Loop complete
+			loopActive = false
+			ctx.RemoveWidget("loop-progress")
+			ctx.PrintInfo(fmt.Sprintf("✅ Loop complete: %d/%d iterations", loopCurrent, loopCount))
+
+			// Show final summary
+			branch := ctx.GetCurrentBranch()
+			if len(branch) > 0 && loopStartNode != "" {
+				summary := ctx.SummarizeBranch(loopStartNode, branch[len(branch)-1].ID)
+				if summary != "" {
+					ctx.PrintBlock(ext.PrintBlockOpts{
+						Text:        summary,
+						BorderColor: "#a6e3a1",
+						Subtitle:    "conversation-manager · Loop Summary",
+					})
+				}
+			}
+			return
+		}
+
+		// Update progress
+		ctx.SetWidget(ext.WidgetConfig{
+			ID:        "loop-progress",
+			Placement: ext.WidgetAbove,
+			Content:   ext.WidgetContent{Text: fmt.Sprintf("🔄 Loop: %d/%d - %s", loopCurrent, loopCount, loopPrompt)},
+			Style:     ext.WidgetStyle{BorderColor: "#fab387"},
+		})
+
+		// Collapse previous iteration for fresh context
+		branch := ctx.GetCurrentBranch()
+		if len(branch) >= 2 {
+			// Find the user messages (look for the one before the last assistant message)
+			// We want to collapse from the user message that started this iteration
+			// to the last assistant response
+			var collapseStartIdx = -1
+			for i := len(branch) - 1; i >= 0; i-- {
+				if branch[i].Role == "assistant" {
+					// Found the last assistant message, now find the user message before it
+					for j := i - 1; j >= 0; j-- {
+						if branch[j].Role == "user" {
+							collapseStartIdx = j
+							break
+						}
+					}
+					break
+				}
+			}
+
+			if collapseStartIdx >= 0 {
+				fromID := branch[collapseStartIdx].ID
+				toID := branch[len(branch)-1].ID
+
+				ctx.PrintInfo(fmt.Sprintf("Collapsing iteration %d for fresh context...", loopCurrent))
+				summary := ctx.SummarizeBranch(fromID, toID)
+				if summary != "" {
+					result := ctx.CollapseBranch(fromID, toID, summary)
+					if result.Success {
+						ctx.PrintInfo("Context collapsed successfully")
+					} else {
+						ctx.PrintError(fmt.Sprintf("Collapse failed: %s", result.Error))
+					}
+				}
+			}
+		}
+
+		// Small delay to let UI update
+		time.Sleep(500 * time.Millisecond)
+
+		// Trigger next iteration
+		executeLoopIteration(ctx)
+	})
+}
+
+// showTree displays the conversation tree structure
+func showTree(ctx ext.Context) {
+	branch := ctx.GetCurrentBranch()
+	if len(branch) == 0 {
+		ctx.PrintInfo("Tree is empty")
+		return
+	}
+
+	var output strings.Builder
+	output.WriteString(fmt.Sprintf("Conversation Tree (%d nodes):\n\n", len(branch)))
+
+	for i, node := range branch {
+		prefix := "  "
+		if i == len(branch)-1 {
+			prefix = "▶ " // Current node
+		} else {
+			prefix = "  "
+		}
+
+		roleIcon := "💬"
+		switch node.Role {
+		case "user":
+			roleIcon = "👤"
+		case "assistant":
+			roleIcon = "🤖"
+		case "system":
+			roleIcon = "⚙️"
+		}
+
+		content := truncate(node.Content, 50)
+		if node.Type == "branch_summary" {
+			roleIcon = "📋"
+			content = "[Summary] " + truncate(node.Content, 40)
+		}
+
+		output.WriteString(fmt.Sprintf("%s%s %s: %s (%s...)\n", prefix, roleIcon, node.Role, node.ID[:8], content))
+
+		// Show children count if any
+		children := ctx.GetChildren(node.ID)
+		if len(children) > 0 {
+			output.WriteString(fmt.Sprintf("    └─ %d branch(es)\n", len(children)))
+		}
+	}
+
+	ctx.PrintBlock(ext.PrintBlockOpts{
+		Text:        output.String(),
+		BorderColor: "#89b4fa",
+		Subtitle:    "conversation-manager · Tree View",
+	})
+}
+
+// showBranch displays the current branch path
+func showBranch(ctx ext.Context) {
+	branch := ctx.GetCurrentBranch()
+	if len(branch) == 0 {
+		ctx.PrintInfo("No active branch")
+		return
+	}
+
+	var output strings.Builder
+	output.WriteString(fmt.Sprintf("Current Branch (%d nodes from root to leaf):\n\n", len(branch)))
+
+	for i, node := range branch {
+		marker := "  "
+		if i == len(branch)-1 {
+			marker = "▶ " // Current leaf
+		}
+
+		output.WriteString(fmt.Sprintf("%s[%d] %s (%s): %s\n",
+			marker, i, node.Type, node.ID[:8], truncate(node.Content, 40)))
+	}
+
+	// Show current node details
+	leaf := branch[len(branch)-1]
+	output.WriteString(fmt.Sprintf("\nCurrent Leaf:\n"))
+	output.WriteString(fmt.Sprintf("  ID: %s\n", leaf.ID))
+	output.WriteString(fmt.Sprintf("  Type: %s\n", leaf.Type))
+	output.WriteString(fmt.Sprintf("  Role: %s\n", leaf.Role))
+	output.WriteString(fmt.Sprintf("  Model: %s\n", leaf.Model))
+	output.WriteString(fmt.Sprintf("  Children: %d\n", len(leaf.Children)))
+
+	ctx.PrintBlock(ext.PrintBlockOpts{
+		Text:        output.String(),
+		BorderColor: "#cba6f7",
+		Subtitle:    "conversation-manager · Branch View",
+	})
+}
+
+// executeLoopIteration triggers the next loop iteration
+func executeLoopIteration(ctx ext.Context) {
+	iterationPrompt := fmt.Sprintf("[%d/%d] %s", loopCurrent+1, loopCount, loopPrompt)
+	ctx.SendMessage(iterationPrompt)
+}
+
+// truncate helper
+func truncate(s string, max int) string {
+	if len(s) <= max {
+		return s
+	}
+	return s[:max-3] + "..."
+}

examples/extensions/extension_test_template.go

@@ -0,0 +1,170 @@
+// Extension Test Template
+//
+// This is a template for writing tests for your Kit extension.
+// Copy this file to your extension directory, rename it to something like
+// "my-ext_test.go", and customize it for your extension.
+//
+// Run tests with: go test -v
+//
+// IMPORTANT: This file should be in the same directory as your extension
+// and use package main, NOT package test.
+
+package main
+
+import (
+	"testing"
+
+	"github.com/mark3labs/kit/internal/extensions"
+	"github.com/mark3labs/kit/pkg/extensions/test"
+)
+
+// Test that your extension loads without errors
+func TestExtension_Loads(t *testing.T) {
+	harness := test.New(t)
+	ext := harness.LoadFile("my-ext.go") // Change to your extension filename
+
+	// Verify the extension was loaded
+	if ext == nil {
+		t.Fatal("extension should not be nil")
+	}
+}
+
+// Test your event handlers are registered
+func TestExtension_EventHandlers(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("my-ext.go")
+
+	// Uncomment the handlers your extension uses:
+	// test.AssertHasHandlers(t, harness, extensions.ToolCall)
+	// test.AssertHasHandlers(t, harness, extensions.Input)
+	// test.AssertHasHandlers(t, harness, extensions.SessionStart)
+	// test.AssertHasHandlers(t, harness, extensions.AgentEnd)
+}
+
+// Test tool registration
+func TestExtension_Tools(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("my-ext.go")
+
+	// Test that your tools are registered
+	// test.AssertToolRegistered(t, harness, "my_tool")
+
+	// Or test all registered tools
+	tools := harness.RegisteredTools()
+	t.Logf("Registered %d tools", len(tools))
+	for _, tool := range tools {
+		t.Logf("  - %s: %s", tool.Name, tool.Description)
+	}
+}
+
+// Test command registration
+func TestExtension_Commands(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("my-ext.go")
+
+	// Test that your commands are registered
+	// test.AssertCommandRegistered(t, harness, "mycommand")
+
+	// Or test all registered commands
+	cmds := harness.RegisteredCommands()
+	t.Logf("Registered %d commands", len(cmds))
+	for _, cmd := range cmds {
+		t.Logf("  - %s: %s", cmd.Name, cmd.Description)
+	}
+}
+
+// Test session start behavior
+func TestExtension_SessionStart(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("my-ext.go")
+
+	// Emit session start event
+	_, err := harness.Emit(extensions.SessionStartEvent{
+		SessionID: "test-session",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Verify expected behavior:
+	// - Did it print something?
+	// test.AssertPrinted(t, harness, "expected output")
+
+	// - Did it set a widget?
+	// test.AssertWidgetSet(t, harness, "my-widget")
+	// test.AssertWidgetText(t, harness, "my-widget", "expected text")
+
+	// - Did it set the header/footer?
+	// test.AssertHeaderSet(t, harness)
+	// test.AssertFooterSet(t, harness)
+
+	// - Did it set a status?
+	// test.AssertStatusSet(t, harness, "myext:status")
+}
+
+// Test tool call handling
+func TestExtension_ToolCall(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("my-ext.go")
+
+	// Test a specific tool call
+	result, err := harness.Emit(extensions.ToolCallEvent{
+		ToolName: "some_tool",
+		Input:    `{"key": "value"}`,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// If your extension blocks certain tools:
+	// test.AssertNotBlocked(t, result)
+	// OR
+	// test.AssertBlocked(t, result, "expected reason")
+
+	// Suppress unused variable warning (remove this when using result)
+	_ = result
+
+	// Check for print output
+	// test.AssertPrinted(t, harness, "expected message")
+}
+
+// Test input handling
+func TestExtension_InputHandling(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("my-ext.go")
+
+	// Test input that should be handled
+	result, err := harness.Emit(extensions.InputEvent{
+		Text:   "test input",
+		Source: "cli",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// If your extension handles/transforms input:
+	// test.AssertInputHandled(t, result, "handled")
+	// OR
+	// test.AssertInputTransformed(t, result, "transformed text")
+
+	// Suppress unused variable warning (remove this when using result)
+	_ = result
+}
+
+// Test with configured prompt results
+func TestExtension_WithPrompts(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("my-ext.go")
+
+	// Configure what prompts should return
+	harness.Context().SetPromptSelectResult(extensions.PromptSelectResult{
+		Value:     "option1",
+		Index:     0,
+		Cancelled: false,
+	})
+
+	// Now when your extension calls ctx.PromptSelect(), it gets the configured result
+	_, _ = harness.Emit(extensions.SessionStartEvent{SessionID: "test"})
+
+	// Verify behavior based on the selected options
+}

examples/extensions/kit-telegram/README.md

@@ -0,0 +1,111 @@
+# kit-telegram
+
+A Kit extension that relays all Kit agent runs to Telegram and lets approved Telegram users reply back into Kit.
+
+## What it does
+
+- Relays **all Kit runs** to one Telegram chat while connected
+- Edits one Telegram progress message in place during a run
+- Lets approved Telegram users send normal text replies back into Kit
+- Shows `Telegram Connected` or `Telegram Disconnected` in the status bar
+- Shows a small spinner animation as `⠋ Telegram Connecting` only while the relay is still connecting
+- On startup with an already validated enabled config, sends a short Telegram connection message to confirm the relay is up
+
+## Requirements
+
+- `kit` installed and working
+- A Telegram bot token from `@BotFather`
+- Either:
+  - A Telegram chat where you can message the bot, or
+  - A numeric Telegram chat id you want to enter manually
+- For group chats, one or more allowed Telegram user ids
+
+## Quickstart
+
+### 1. Install the extension
+
+```bash
+kit install github.com/mark3labs/kit/examples/extensions/kit-telegram
+```
+
+Or run directly:
+```bash
+kit -e path/to/kit-telegram/main.go
+```
+
+### 2. Start Kit and connect Telegram
+
+```bash
+kit
+```
+
+Inside Kit, run:
+
+```
+/telegram connect
+```
+
+You will be prompted for:
+
+- Bot token from `@BotFather`
+- Whether to auto-detect the chat by messaging the bot or enter the chat id manually
+- Allowed user ids when needed
+
+### 3. Verify the relay
+
+```
+/telegram test
+```
+
+Reply in Telegram with the code from the test message.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/telegram` | Human-friendly overview and subcommand list |
+| `/telegram status` | Raw deterministic relay state |
+| `/telegram test` | Verify outbound and inbound relay |
+| `/telegram toggle` | Enable or disable relay without deleting credentials |
+| `/telegram logout` | Remove saved credentials and disconnect relay |
+| `/telegram connect` | Run the setup flow again |
+| `/telegram clear` | Clear Telegram status and working messages from the TUI |
+
+## Remote commands (from Telegram)
+
+| Command | Description |
+|---------|-------------|
+| `/telegram` | Sends the overview back to Telegram |
+| `/telegram status` | Sends the deterministic state report to Telegram |
+| `/telegram test` | Sends a reply-code test message from Telegram |
+| `/telegram toggle` | Flips the enabled flag |
+| `/telegram logout yes` | Logs out (requires `yes` confirmation) |
+| `/telegram clear` | Clears the TUI footer and working messages |
+
+## Key APIs Used
+
+- `RegisterCommand` — Slash command with subcommands and tab completion
+- `OnSessionStart` / `OnSessionShutdown` — Lifecycle management
+- `OnAgentStart` / `OnAgentEnd` — Run tracking and progress rendering
+- `OnToolCall` / `OnToolResult` — Action tracking
+- `OnMessageEnd` — Capture assistant responses
+- `OnInput` — Mirror local messages to Telegram
+- `SetStatus` / `RemoveStatus` — Status bar indicators
+- `SetWidget` / `RemoveWidget` — Working message display
+- `PromptInput` / `PromptSelect` / `PromptConfirm` — Interactive setup flow
+- `SendMessage` — Inject Telegram replies as Kit prompts
+
+## Architecture
+
+Single Go file interpreted by Yaegi at runtime. Core components:
+
+- **Telegram Bot API client** — HTTP calls via `net/http` for getMe, getChat, getChatMember, getUpdates (long-polling), sendMessage, editMessageText
+- **Config persistence** — JSON file at `.kit/kit-telegram.json` with atomic writes
+- **Long-polling goroutine** — Background polling for Telegram updates with warmup poll, retry, and client-side timeouts
+- **Message queue** — In-memory FIFO queue for Telegram prompt input with edit-before-dispatch support
+- **Progress rendering** — `⏳ elapsed · step N` with action lines, edited in place
+- **Final rendering** — `✅/❌ elapsed` with response text, split into chunks for long output
+
+## Debug mode
+
+Set environment variable `KIT_TELEGRAM_DEBUG=1` to enable verbose debug logging.

examples/extensions/neon-theme.go

@@ -0,0 +1,42 @@
+//go:build ignore
+
+package main
+
+import "kit/ext"
+
+// Init registers a "neon" theme and a /neon slash command to apply it.
+// Demonstrates how extensions can create and set themes programmatically.
+//
+// Usage: kit -e examples/extensions/neon-theme.go
+func Init(api ext.API) {
+	api.OnSessionStart(func(_ ext.SessionStartEvent, ctx ext.Context) {
+		// Register a cyberpunk neon theme at startup.
+		ctx.RegisterTheme("neon", ext.ThemeColorConfig{
+			Primary:    ext.ThemeColor{Light: "#CC00FF", Dark: "#FF00FF"},
+			Secondary:  ext.ThemeColor{Light: "#0088CC", Dark: "#00FFFF"},
+			Success:    ext.ThemeColor{Light: "#00CC44", Dark: "#00FF66"},
+			Warning:    ext.ThemeColor{Light: "#CCAA00", Dark: "#FFFF00"},
+			Error:      ext.ThemeColor{Light: "#CC0033", Dark: "#FF0055"},
+			Info:       ext.ThemeColor{Light: "#0088CC", Dark: "#00CCFF"},
+			Text:       ext.ThemeColor{Light: "#111111", Dark: "#F0F0F0"},
+			Background: ext.ThemeColor{Light: "#F0F0F0", Dark: "#0A0A14"},
+			MdKeyword:  ext.ThemeColor{Light: "#CC00FF", Dark: "#FF00FF"},
+			MdString:   ext.ThemeColor{Light: "#00CC44", Dark: "#00FF66"},
+			MdComment:  ext.ThemeColor{Light: "#888888", Dark: "#555555"},
+		})
+
+		ctx.PrintInfo("Neon theme registered! Use /theme neon to activate.")
+	})
+
+	// Also register a /neon slash command as a shortcut.
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "neon",
+		Description: "Switch to the neon cyberpunk theme",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			if err := ctx.SetTheme("neon"); err != nil {
+				return "", err
+			}
+			return "Neon theme activated!", nil
+		},
+	})
+}

examples/extensions/prompt-templates.go

@@ -0,0 +1,269 @@
+//go:build ignore
+
+// prompt-templates.go - Frontmatter-driven prompt templates with model switching.
+// This extension demonstrates the new bridged SDK APIs:
+// - Tree navigation for conversation management
+// - Template parsing with {{variable}} substitution
+// - Model resolution with fallback chains
+// - Skill injection
+//
+// Usage:
+//   1. Create ~/.config/kit/prompts/debug.md with frontmatter:
+//      ---
+//      description: Debug Python code
+//      model: claude-sonnet-4-20250514
+//      skill: python
+//      ---
+//      Help me debug this Python code: {{input}}
+//
+//   2. In Kit: /debug my_script.py
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"kit/ext"
+)
+
+// PromptTemplate represents a loaded template with frontmatter
+type PromptTemplate struct {
+	Name        string
+	Description string
+	Model       string
+	Skill       string
+	Content     string
+	Variables   []string
+	Path        string
+}
+
+var (
+	templates   = make(map[string]PromptTemplate)
+	templateDir string
+)
+
+func Init(api ext.API) {
+	// Determine template directory
+	home, _ := os.UserHomeDir()
+	templateDir = filepath.Join(home, ".config", "kit", "prompts")
+
+	// Ensure directory exists
+	os.MkdirAll(templateDir, 0755)
+
+	// Register commands
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "reload-templates",
+		Description: "Reload prompt templates from disk",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			loadTemplates(ctx)
+			ctx.PrintInfo(fmt.Sprintf("Loaded %d templates from %s", len(templates), templateDir))
+			return "", nil
+		},
+	})
+
+	// Dynamic template commands are registered after loading
+	api.OnSessionStart(func(e ext.SessionStartEvent, ctx ext.Context) {
+		loadTemplates(ctx)
+		registerTemplateCommands(api, ctx)
+	})
+}
+
+// loadTemplates discovers and loads all template files
+func loadTemplates(ctx ext.Context) {
+	templates = make(map[string]PromptTemplate)
+
+	entries, err := os.ReadDir(templateDir)
+	if err != nil {
+		return
+	}
+
+	for _, entry := range entries {
+		if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".md") {
+			continue
+		}
+
+		path := filepath.Join(templateDir, entry.Name())
+		tpl, err := loadTemplateFile(path)
+		if err != nil {
+			continue
+		}
+
+		name := strings.TrimSuffix(entry.Name(), ".md")
+		templates[name] = tpl
+	}
+}
+
+// loadTemplateFile parses a template with YAML frontmatter
+func loadTemplateFile(path string) (PromptTemplate, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return PromptTemplate{}, err
+	}
+
+	content := string(data)
+	tpl := PromptTemplate{Path: path}
+
+	// Parse frontmatter
+	if strings.HasPrefix(content, "---") {
+		parts := strings.SplitN(content[3:], "---", 2)
+		if len(parts) == 2 {
+			frontmatter := strings.TrimSpace(parts[0])
+			body := strings.TrimSpace(parts[1])
+
+			// Simple line-by-line frontmatter parsing
+			for _, line := range strings.Split(frontmatter, "\n") {
+				line = strings.TrimSpace(line)
+				if line == "" || strings.HasPrefix(line, "#") {
+					continue
+				}
+
+				key, value, found := strings.Cut(line, ":")
+				if found {
+					key = strings.TrimSpace(key)
+					value = strings.TrimSpace(value)
+					switch key {
+					case "description":
+						tpl.Description = value
+					case "model":
+						tpl.Model = value
+					case "skill":
+						tpl.Skill = value
+					}
+				}
+			}
+			tpl.Content = body
+		} else {
+			tpl.Content = content
+		}
+	} else {
+		tpl.Content = content
+	}
+
+	// Parse {{variables}} using simple string parsing
+	// (Can't use ctx.ParseTemplate here since we're in Init, not a handler)
+	var vars []string
+	for {
+		start := strings.Index(tpl.Content, "{{")
+		if start == -1 {
+			break
+		}
+		end := strings.Index(tpl.Content[start:], "}}")
+		if end == -1 {
+			break
+		}
+		varName := strings.TrimSpace(tpl.Content[start+2 : start+end])
+		vars = append(vars, varName)
+		tpl.Content = tpl.Content[:start] + "{{" + varName + "}}" + tpl.Content[start+end+2:]
+	}
+	tpl.Variables = vars
+
+	return tpl, nil
+}
+
+// registerTemplateCommands dynamically registers commands for each template
+func registerTemplateCommands(api ext.API, ctx ext.Context) {
+	for name, tpl := range templates {
+		// Skip if already registered (we'd need to track this)
+		tplCopy := tpl // Capture for closure
+		nameCopy := name
+
+		// Build description with metadata
+		desc := tplCopy.Description
+		if desc == "" {
+			desc = fmt.Sprintf("Run %s template", nameCopy)
+		}
+		if tplCopy.Model != "" {
+			desc += fmt.Sprintf(" [%s", tplCopy.Model)
+			if tplCopy.Skill != "" {
+				desc += fmt.Sprintf(" +%s", tplCopy.Skill)
+			}
+			desc += "]"
+		}
+
+		api.RegisterCommand(ext.CommandDef{
+			Name:        nameCopy,
+			Description: desc,
+			Execute: func(args string, ctx ext.Context) (string, error) {
+				return executeTemplate(ctx, tplCopy, args)
+			},
+		})
+	}
+}
+
+// executeTemplate runs a template with the given arguments
+func executeTemplate(ctx ext.Context, tpl PromptTemplate, args string) (string, error) {
+	// Store original model for restoration
+	originalModel := ctx.Model
+
+	// 1. Resolve and switch model if specified
+	if tpl.Model != "" {
+		// Parse model chain (comma-separated)
+		preferences := strings.Split(tpl.Model, ",")
+		for i := range preferences {
+			preferences[i] = strings.TrimSpace(preferences[i])
+		}
+
+		result := ctx.ResolveModelChain(preferences)
+		if result.Error != "" {
+			ctx.PrintError(fmt.Sprintf("Model resolution failed: %s", result.Error))
+			// Continue with current model
+		} else {
+			ctx.PrintInfo(fmt.Sprintf("Switching to model: %s", result.Model))
+			if err := ctx.SetModel(result.Model); err != nil {
+				ctx.PrintError(fmt.Sprintf("Failed to switch model: %s", err.Error()))
+			}
+		}
+	}
+
+	// 2. Inject skill if specified
+	if tpl.Skill != "" {
+		err := ctx.InjectSkillAsContext(tpl.Skill)
+		if err != "" {
+			ctx.PrintError(fmt.Sprintf("Skill injection failed: %s", err))
+		} else {
+			ctx.PrintInfo(fmt.Sprintf("Injected skill: %s", tpl.Skill))
+		}
+	}
+
+	// 3. Parse and render template
+	parsed := ctx.ParseTemplate(tpl.Name, tpl.Content)
+
+	// Build variable map
+	vars := make(map[string]string)
+
+	// Simple argument parsing: first arg is $1 (input), rest is $@
+	if len(parsed.Variables) > 0 {
+		argsList := ctx.SimpleParseArguments(args, len(parsed.Variables))
+		for i, varName := range parsed.Variables {
+			if i < len(parsed.Variables) && i+1 < len(argsList) {
+				vars[varName] = argsList[i+1]
+			}
+		}
+		// If single variable, use full args
+		if len(parsed.Variables) == 1 && vars[parsed.Variables[0]] == "" {
+			vars[parsed.Variables[0]] = args
+		}
+	}
+
+	// Render with model conditionals
+	content := ctx.RenderWithModelConditionals(tpl.Content)
+	rendered := ctx.RenderTemplate(ext.PromptTemplate{Name: tpl.Name, Content: content, Variables: parsed.Variables}, vars)
+
+	// 4. Send the rendered prompt
+	ctx.SendMessage(rendered)
+
+	// 5. Schedule model restoration after turn completes
+	// We use a goroutine to wait and restore
+	if tpl.Model != "" && originalModel != "" {
+		go func() {
+			// Note: In a real implementation, we'd use OnAgentEnd event
+			// For now, the user can manually switch back
+			ctx.SetStatus("template-mode", fmt.Sprintf("Template: %s (model will restore)", tpl.Name), 20)
+		}()
+	}
+
+	return fmt.Sprintf("Executing template: %s", tpl.Name), nil
+}

examples/extensions/status-tools/helpers.go

@@ -0,0 +1,43 @@
+//go:build ignore
+
+package main
+
+import (
+	"fmt"
+	"kit/ext"
+)
+
+// Helper functions for the status-tools extension
+// These are used by main.go but kept in a separate file
+// to demonstrate the multi-file extension pattern.
+
+// formatMemory converts bytes to human-readable format
+func formatMemory(bytes int64) string {
+	const (
+		KB = 1024
+		MB = 1024 * KB
+		GB = 1024 * MB
+	)
+
+	switch {
+	case bytes >= GB:
+		return fmt.Sprintf("%.2f GB", float64(bytes)/float64(GB))
+	case bytes >= MB:
+		return fmt.Sprintf("%.2f MB", float64(bytes)/float64(MB))
+	case bytes >= KB:
+		return fmt.Sprintf("%.2f KB", float64(bytes)/float64(KB))
+	default:
+		return fmt.Sprintf("%d B", bytes)
+	}
+}
+
+// showMemoryStatus displays memory usage (placeholder)
+func showMemoryStatus(ctx ext.Context) {
+	// This is a placeholder that would show memory stats
+	// In a real extension, you'd integrate with system metrics
+	ctx.PrintBlock(ext.PrintBlockOpts{
+		Text:        "Memory status monitoring not yet implemented",
+		BorderColor: "#f9e2af",
+		Subtitle:    "Memory",
+	})
+}

examples/extensions/status-tools/main.go

@@ -0,0 +1,49 @@
+//go:build ignore
+
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"kit/ext"
+)
+
+// Init registers the status tools extension.
+// This extension provides multiple status-related utilities as a
+// multi-file extension example.
+func Init(api ext.API) {
+	// Register a status bar widget that shows time
+	api.OnSessionStart(func(_ ext.SessionStartEvent, ctx ext.Context) {
+		go func() {
+			ticker := time.NewTicker(time.Second)
+			defer ticker.Stop()
+			for range ticker.C {
+				ctx.SetStatus("clock", time.Now().Format("15:04:05"), 5)
+			}
+		}()
+	})
+
+	// Register a /status command
+	api.RegisterCommand(ext.CommandDef{
+		Name:        "status",
+		Description: "Show system status information",
+		Execute: func(args string, ctx ext.Context) (string, error) {
+			stats := ctx.GetContextStats()
+			info := fmt.Sprintf(
+				"Model: %s\nTokens: %d/%d (%.1f%%)\nMessages: %d",
+				ctx.Model,
+				stats.EstimatedTokens,
+				stats.ContextLimit,
+				stats.UsagePercent*100,
+				stats.MessageCount,
+			)
+			ctx.PrintBlock(ext.PrintBlockOpts{
+				Text:        info,
+				BorderColor: "#89b4fa",
+				Subtitle:    "System Status",
+			})
+			return "", nil
+		},
+	})
+}

examples/extensions/subagent-monitor_test.go

@@ -0,0 +1,159 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/mark3labs/kit/internal/extensions"
+	"github.com/mark3labs/kit/pkg/extensions/test"
+)
+
+// TestSubagentMonitor_SessionStart verifies OnSessionStart initializes state
+// without panicking and properly guards nil ctx calls.
+func TestSubagentMonitor_SessionStart(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("../../.kit/extensions/subagent-monitor.go")
+
+	// Emit SessionStart - should not panic even with nil ctx functions
+	_, err := harness.Emit(extensions.SessionStartEvent{SessionID: "test-session"})
+	if err != nil {
+		t.Fatalf("SessionStart should not error: %v", err)
+	}
+}
+
+// TestSubagentMonitor_SubagentLifecycle verifies the full subagent lifecycle
+// creates entries and emits widget updates.
+func TestSubagentMonitor_SubagentLifecycle(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("../../.kit/extensions/subagent-monitor.go")
+
+	// Start session
+	_, err := harness.Emit(extensions.SessionStartEvent{SessionID: "test-session"})
+	if err != nil {
+		t.Fatalf("SessionStart should not error: %v", err)
+	}
+
+	// Emit SubagentStart
+	_, err = harness.Emit(extensions.SubagentStartEvent{
+		ToolCallID: "call-1",
+		Task:       "test task",
+	})
+	if err != nil {
+		t.Fatalf("SubagentStart should not error: %v", err)
+	}
+
+	// Emit a few chunks
+	for i := range 3 {
+		_, err = harness.Emit(extensions.SubagentChunkEvent{
+			ToolCallID: "call-1",
+			Task:       "test task",
+			ChunkType:  "text",
+			Content:    fmt.Sprintf("line %d", i),
+		})
+		if err != nil {
+			t.Fatalf("SubagentChunk %d should not error: %v", i, err)
+		}
+	}
+
+	// Emit tool call chunk
+	_, err = harness.Emit(extensions.SubagentChunkEvent{
+		ToolCallID: "call-1",
+		Task:       "test task",
+		ChunkType:  "tool_call",
+		ToolName:   "bash",
+	})
+	if err != nil {
+		t.Fatalf("SubagentChunk tool_call should not error: %v", err)
+	}
+
+	// Emit SubagentEnd
+	_, err = harness.Emit(extensions.SubagentEndEvent{
+		ToolCallID: "call-1",
+		Task:       "test task",
+		Response:   "done",
+	})
+	if err != nil {
+		t.Fatalf("SubagentEnd should not error: %v", err)
+	}
+
+	// Give time for cleanup goroutine
+	time.Sleep(100 * time.Millisecond)
+}
+
+// TestSubagentMonitor_MultipleSubagents verifies multiple parallel subagents.
+func TestSubagentMonitor_MultipleSubagents(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("../../.kit/extensions/subagent-monitor.go")
+
+	_, err := harness.Emit(extensions.SessionStartEvent{SessionID: "test-session"})
+	if err != nil {
+		t.Fatalf("SessionStart should not error: %v", err)
+	}
+
+	// Start 3 subagents
+	for i := 1; i <= 3; i++ {
+		_, err := harness.Emit(extensions.SubagentStartEvent{
+			ToolCallID: fmt.Sprintf("call-%d", i),
+			Task:       fmt.Sprintf("task %d", i),
+		})
+		if err != nil {
+			t.Fatalf("SubagentStart %d should not error: %v", i, err)
+		}
+	}
+
+	// Emit chunks for each
+	for i := 1; i <= 3; i++ {
+		_, err := harness.Emit(extensions.SubagentChunkEvent{
+			ToolCallID: fmt.Sprintf("call-%d", i),
+			Task:       fmt.Sprintf("task %d", i),
+			ChunkType:  "text",
+			Content:    fmt.Sprintf("output from agent %d", i),
+		})
+		if err != nil {
+			t.Fatalf("SubagentChunk %d should not error: %v", i, err)
+		}
+	}
+
+	// End all subagents
+	for i := 1; i <= 3; i++ {
+		_, err := harness.Emit(extensions.SubagentEndEvent{
+			ToolCallID: fmt.Sprintf("call-%d", i),
+			Task:       fmt.Sprintf("task %d", i),
+			Response:   "completed",
+		})
+		if err != nil {
+			t.Fatalf("SubagentEnd %d should not error: %v", i, err)
+		}
+	}
+
+	time.Sleep(100 * time.Millisecond)
+}
+
+// TestSubagentMonitor_SessionShutdown verifies shutdown doesn't panic
+// even with nil ctx functions.
+func TestSubagentMonitor_SessionShutdown(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("../../.kit/extensions/subagent-monitor.go")
+
+	// Start then shutdown
+	_, err := harness.Emit(extensions.SessionStartEvent{SessionID: "test-session"})
+	if err != nil {
+		t.Fatalf("SessionStart should not error: %v", err)
+	}
+
+	// Start a subagent
+	_, err = harness.Emit(extensions.SubagentStartEvent{
+		ToolCallID: "call-1",
+		Task:       "test task",
+	})
+	if err != nil {
+		t.Fatalf("SubagentStart should not error: %v", err)
+	}
+
+	// Shutdown - should not panic even with active subagent
+	_, err = harness.Emit(extensions.SessionShutdownEvent{})
+	if err != nil {
+		t.Fatalf("SessionShutdown should not error: %v", err)
+	}
+}

examples/extensions/subagent-test.go

@@ -37,7 +37,7 @@ func Init(api ext.API) {
 			"Subagent Test Extension loaded\n\n" +
 				"/subtest <task>    Spawn blocking subagent\n" +
 				"/subbg <task>      Spawn background subagent\n\n" +
-				"The LLM can also use the spawn_subagent tool.")
+				"The LLM can also use the subagent tool.")
 	})
 
 	api.OnAgentEnd(func(_ ext.AgentEndEvent, ctx ext.Context) {

examples/extensions/tool-logger_test.go

@@ -0,0 +1,358 @@
+package main
+
+import (
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/mark3labs/kit/internal/extensions"
+	"github.com/mark3labs/kit/pkg/extensions/test"
+)
+
+// Test that the tool-logger extension loads and registers handlers
+func TestToolLogger_Loads(t *testing.T) {
+	harness := test.New(t)
+	ext := harness.LoadFile("tool-logger.go")
+
+	if ext == nil {
+		t.Fatal("extension should not be nil")
+	}
+
+	// Verify all expected handlers are registered
+	test.AssertHasHandlers(t, harness, extensions.ToolCall)
+	test.AssertHasHandlers(t, harness, extensions.ToolResult)
+	test.AssertHasHandlers(t, harness, extensions.SessionStart)
+	test.AssertHasHandlers(t, harness, extensions.SessionShutdown)
+	test.AssertHasHandlers(t, harness, extensions.Input)
+}
+
+// Test that tool calls are logged (handlers run without errors)
+func TestToolLogger_ToolCall(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("tool-logger.go")
+
+	// Emit a tool call event
+	result, err := harness.Emit(extensions.ToolCallEvent{
+		ToolName:   "Read",
+		ToolCallID: "call-123",
+		Input:      `{"file": "test.txt"}`,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Tool logger should not block any tools
+	test.AssertNotBlocked(t, result)
+}
+
+// Test that tool results are processed
+func TestToolLogger_ToolResult(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("tool-logger.go")
+
+	content := "Hello, World!"
+	result, err := harness.Emit(extensions.ToolResultEvent{
+		ToolName: "Read",
+		Content:  content,
+		IsError:  false,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Tool logger should not modify results
+	if result != nil {
+		t.Error("expected nil result (no modification)")
+	}
+}
+
+// Test that error tool results are handled
+func TestToolLogger_ToolResultError(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("tool-logger.go")
+
+	result, err := harness.Emit(extensions.ToolResultEvent{
+		ToolName: "Bash",
+		Content:  "command not found",
+		IsError:  true,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if result != nil {
+		t.Error("expected nil result (no modification)")
+	}
+}
+
+// Test session start handler
+func TestToolLogger_SessionStart(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("tool-logger.go")
+
+	_, err := harness.Emit(extensions.SessionStartEvent{
+		SessionID: "test-session-123",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Handler should run without errors (logs to file)
+	// Since file logging happens outside our mock, we just verify no errors
+}
+
+// Test session shutdown handler
+func TestToolLogger_SessionShutdown(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("tool-logger.go")
+
+	_, err := harness.Emit(extensions.SessionShutdownEvent{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+// Test the !time command
+func TestToolLogger_TimeCommand(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("tool-logger.go")
+
+	result, err := harness.Emit(extensions.InputEvent{
+		Text:   "!time",
+		Source: "cli",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	test.AssertInputHandled(t, result, "handled")
+
+	// Verify PrintInfo was called with a time message
+	infos := harness.Context().GetPrintInfos()
+	found := false
+	for _, info := range infos {
+		if strings.Contains(info, "Current time:") {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Errorf("expected PrintInfo with 'Current time:', got: %v", infos)
+	}
+}
+
+// Test the !status command
+func TestToolLogger_StatusCommand(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("tool-logger.go")
+
+	result, err := harness.Emit(extensions.InputEvent{
+		Text:   "!status",
+		Source: "cli",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	test.AssertInputHandled(t, result, "handled")
+
+	// Verify PrintBlock was called
+	blocks := harness.Context().PrintBlocks
+	if len(blocks) != 1 {
+		t.Fatalf("expected 1 PrintBlock call, got %d", len(blocks))
+	}
+
+	block := blocks[0]
+	if block.Subtitle != "tool-logger extension" {
+		t.Errorf("expected subtitle 'tool-logger extension', got %q", block.Subtitle)
+	}
+	if block.BorderColor != "#a6e3a1" {
+		t.Errorf("expected border color '#a6e3a1', got %q", block.BorderColor)
+	}
+	if !strings.Contains(block.Text, "Session active") {
+		t.Errorf("expected text to contain 'Session active', got %q", block.Text)
+	}
+}
+
+// Test that unknown commands are not handled
+func TestToolLogger_UnknownCommand(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("tool-logger.go")
+
+	result, err := harness.Emit(extensions.InputEvent{
+		Text:   "!unknown",
+		Source: "cli",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if result != nil {
+		t.Errorf("expected nil result for unknown command, got %v", result)
+	}
+
+	// Verify no info/block prints for unknown commands
+	if len(harness.Context().GetPrintInfos()) != 0 {
+		t.Error("expected no PrintInfo calls for unknown command")
+	}
+	if len(harness.Context().PrintBlocks) != 0 {
+		t.Error("expected no PrintBlock calls for unknown command")
+	}
+}
+
+// Test regular text input (not a command)
+func TestToolLogger_RegularInput(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("tool-logger.go")
+
+	result, err := harness.Emit(extensions.InputEvent{
+		Text:   "This is a normal message",
+		Source: "cli",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if result != nil {
+		t.Errorf("expected nil result for regular input, got %v", result)
+	}
+}
+
+// Test complete session flow
+func TestToolLogger_FullSession(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("tool-logger.go")
+
+	// Simulate a full session
+	_, err := harness.Emit(extensions.SessionStartEvent{SessionID: "test"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Several tool calls
+	tools := []string{"Read", "Glob", "Grep", "Bash"}
+	for _, tool := range tools {
+		_, err := harness.Emit(extensions.ToolCallEvent{
+			ToolName: tool,
+			Input:    "{}",
+		})
+		if err != nil {
+			t.Fatalf("error for tool %s: %v", tool, err)
+		}
+
+		_, err = harness.Emit(extensions.ToolResultEvent{
+			ToolName: tool,
+			Content:  "result",
+			IsError:  false,
+		})
+		if err != nil {
+			t.Fatalf("error for tool result %s: %v", tool, err)
+		}
+	}
+
+	// User issues a command
+	_, err = harness.Emit(extensions.InputEvent{Text: "!time", Source: "cli"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	_, err = harness.Emit(extensions.SessionShutdownEvent{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Verify the !time command was handled
+	if len(harness.Context().GetPrintInfos()) != 1 {
+		t.Errorf("expected 1 PrintInfo call, got %d", len(harness.Context().GetPrintInfos()))
+	}
+}
+
+// Test that the extension handles file write errors gracefully
+func TestToolLogger_FileError(t *testing.T) {
+	// This test verifies the extension doesn't panic when file operations fail
+	// Since we can't easily mock os.OpenFile, we rely on the extension code
+	// properly checking for errors (which it does)
+
+	harness := test.New(t)
+	harness.LoadFile("tool-logger.go")
+
+	// Just verify the handlers run without panicking
+	_, err := harness.Emit(extensions.ToolCallEvent{ToolName: "Read", Input: "{}"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	_, err = harness.Emit(extensions.SessionStartEvent{SessionID: "test"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+// Test concurrent tool calls (race condition check)
+func TestToolLogger_ConcurrentToolCalls(t *testing.T) {
+	harness := test.New(t)
+	harness.LoadFile("tool-logger.go")
+
+	// Run multiple tool calls concurrently
+	done := make(chan bool, 10)
+	for i := range 10 {
+		go func(index int) {
+			defer func() { done <- true }()
+
+			toolName := "Tool" + string(rune('0'+index))
+			_, err := harness.Emit(extensions.ToolCallEvent{
+				ToolName: toolName,
+				Input:    "{}",
+			})
+			if err != nil {
+				t.Errorf("error in goroutine %d: %v", index, err)
+			}
+		}(i)
+	}
+
+	// Wait for all goroutines
+	for range 10 {
+		<-done
+	}
+}
+
+// Test the actual log file is created and written to
+func TestToolLogger_LogFile(t *testing.T) {
+	logFile := "/tmp/kit-tool-log.txt"
+
+	// Clean up before test
+	_ = os.Remove(logFile)
+
+	harness := test.New(t)
+	harness.LoadFile("tool-logger.go")
+
+	// Emit events
+	_, _ = harness.Emit(extensions.SessionStartEvent{SessionID: "test"})
+	_, _ = harness.Emit(extensions.ToolCallEvent{ToolName: "Read", Input: "{}"})
+	_, _ = harness.Emit(extensions.ToolResultEvent{ToolName: "Read", Content: "data", IsError: false})
+
+	// Note: Since the extension writes to a real file and the test harness
+	// mocks the context, the file writes actually happen. Let's verify.
+
+	// Give it a moment for file operations
+	if _, err := os.Stat(logFile); err == nil {
+		// File exists - read and verify content
+		content, err := os.ReadFile(logFile)
+		if err != nil {
+			t.Logf("Could not read log file: %v", err)
+		} else {
+			contentStr := string(content)
+			if !strings.Contains(contentStr, "SESSION_START") {
+				t.Error("log file should contain SESSION_START")
+			}
+			if !strings.Contains(contentStr, "CALL tool=Read") {
+				t.Error("log file should contain CALL tool=Read")
+			}
+			if !strings.Contains(contentStr, "RESULT tool=Read") {
+				t.Error("log file should contain RESULT tool=Read")
+			}
+		}
+	} else {
+		t.Log("Note: Log file not created - this is expected since the extension writes directly to disk")
+	}
+}

examples/extensions/tool-renderer-demo.go

@@ -28,7 +28,7 @@ func Init(api ext.API) {
 		DisplayName: "File",
 		BorderColor: "#89b4fa", // Catppuccin blue
 		RenderHeader: func(toolArgs string, width int) string {
-			var args map[string]interface{}
+			var args map[string]any
 			if err := json.Unmarshal([]byte(toolArgs), &args); err != nil {
 				return ""
 			}
@@ -72,7 +72,7 @@ func Init(api ext.API) {
 		Background:  "#1e1e2e", // Dark background
 		BorderColor: "#a6e3a1", // Catppuccin green
 		RenderHeader: func(toolArgs string, width int) string {
-			var args map[string]interface{}
+			var args map[string]any
 			if err := json.Unmarshal([]byte(toolArgs), &args); err != nil {
 				return ""
 			}

examples/sdk/README.md

@@ -0,0 +1,45 @@
+# SDK Examples
+
+These examples demonstrate how to use the Kit SDK (`pkg/kit`) to build agents programmatically in Go.
+
+## Examples
+
+### [basic](basic/)
+
+Shows core SDK usage: creating a Kit instance, sending prompts, overriding the model, subscribing to events (tool calls, streaming), and session management.
+
+```bash
+go run ./examples/sdk/basic
+```
+
+### [scripting](scripting/)
+
+A minimal script-friendly wrapper that takes a prompt from the command line and prints the response — useful for piping and automation.
+
+```bash
+go run ./examples/sdk/scripting "Explain what this repo does"
+```
+
+### [crypto-monitor](crypto-monitor/)
+
+A background agent that checks Bitcoin and Ethereum prices every 30 minutes and sends desktop notifications via `notify-send` (dbus). Demonstrates using the SDK for a long-running autonomous task with a single tool.
+
+```bash
+go run ./examples/sdk/crypto-monitor
+
+# Override the check interval:
+CRYPTO_INTERVAL=5m go run ./examples/sdk/crypto-monitor
+```
+
+## Getting Started
+
+```go
+import kit "github.com/mark3labs/kit/pkg/kit"
+
+host, err := kit.New(ctx, nil)        // uses ~/.kit.yml defaults
+defer host.Close()
+
+response, err := host.Prompt(ctx, "Hello!")
+```
+
+See the [SDK README](../../pkg/kit/README.md) for the full API reference.

examples/sdk/crypto-monitor/main.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"os/signal"
+	"time"
+
+	kit "github.com/mark3labs/kit/pkg/kit"
+)
+
+const systemPrompt = `You are a cryptocurrency price monitor. Your job is to:
+
+1. Fetch the current prices of Bitcoin and Ethereum using bash with curl
+2. Send a desktop notification with the results using notify-send
+
+To fetch prices, use this CoinGecko API endpoint (no API key needed):
+  curl -s 'https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum&vs_currencies=usd&include_24hr_change=true'
+
+To send a desktop notification:
+  notify-send -i dialog-information "Crypto Prices" "BTC: $XX,XXX (+X.X%)\nETH: $X,XXX (+X.X%)"
+
+Include the 24h percentage change in the notification. Use a green arrow (▲) for
+positive changes and a red arrow (▼) for negative. Format prices with commas.
+
+If the API call fails, send a notification about the failure instead.
+
+Always complete both steps: fetch then notify. Be concise — no commentary needed.`
+
+func main() {
+	interval := 30 * time.Minute
+	if os.Getenv("CRYPTO_INTERVAL") != "" {
+		d, err := time.ParseDuration(os.Getenv("CRYPTO_INTERVAL"))
+		if err == nil {
+			interval = d
+		}
+	}
+
+	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer cancel()
+
+	host, err := kit.New(ctx, &kit.Options{
+		SystemPrompt: systemPrompt,
+		Tools:        []kit.Tool{kit.NewBashTool()},
+		NoSession:    true,
+		Quiet:        true,
+	})
+	if err != nil {
+		log.Fatalf("Failed to create kit instance: %v", err)
+	}
+	defer func() { _ = host.Close() }()
+
+	fmt.Printf("Crypto price monitor started (every %s)\n", interval)
+	fmt.Println("Press Ctrl+C to stop")
+
+	// Run immediately on startup, then on each tick.
+	check(ctx, host)
+
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			check(ctx, host)
+		case <-ctx.Done():
+			fmt.Println("\nStopping price monitor")
+			return
+		}
+	}
+}
+
+func check(ctx context.Context, host *kit.Kit) {
+	fmt.Printf("[%s] Checking prices...\n", time.Now().Format("15:04:05"))
+
+	// Clear session so each check is independent.
+	host.ClearSession()
+
+	_, err := host.Prompt(ctx, "Fetch current Bitcoin and Ethereum prices and send a desktop notification.")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+	}
+}

go.mod

@@ -1,66 +1,70 @@
 module github.com/mark3labs/kit
 
-go 1.26.0
+go 1.26.1
 
 require (
 	charm.land/bubbles/v2 v2.0.0
-	charm.land/bubbletea/v2 v2.0.1
-	charm.land/fantasy v0.11.1
-	charm.land/lipgloss/v2 v2.0.0
+	charm.land/bubbletea/v2 v2.0.2
+	charm.land/fantasy v0.17.1
+	charm.land/huh/v2 v2.0.3
+	charm.land/lipgloss/v2 v2.0.2
 	github.com/alecthomas/chroma/v2 v2.23.1
-	github.com/aymanbagabas/go-udiff v0.4.0
-	github.com/charmbracelet/fang v0.4.4
-	github.com/charmbracelet/log v0.4.2
-	github.com/mark3labs/mcp-go v0.44.1
+	github.com/aymanbagabas/go-udiff v0.4.1
+	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/mark3labs/mcp-go v0.46.0
 	github.com/spf13/cobra v1.10.2
 	github.com/spf13/viper v1.21.0
 	github.com/traefik/yaegi v0.16.1
-	golang.org/x/term v0.40.0
+	golang.org/x/term v0.41.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
 	cloud.google.com/go v0.123.0 // indirect
-	cloud.google.com/go/auth v0.18.2 // indirect
+	cloud.google.com/go/auth v0.19.0 // indirect
 	cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect
 	cloud.google.com/go/compute/metadata v0.9.0 // indirect
 	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.3 // indirect
-	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.6 // indirect
-	github.com/aws/aws-sdk-go-v2/config v1.32.11 // indirect
-	github.com/aws/aws-sdk-go-v2/credentials v1.19.11 // indirect
-	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.19 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.19 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.19 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.5 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.6 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.19 // indirect
-	github.com/aws/aws-sdk-go-v2/service/signin v1.0.7 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sso v1.30.12 // indirect
-	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.16 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sts v1.41.8 // indirect
+	github.com/aws/aws-sdk-go-v2 v1.41.4 // 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/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/smithy-go v1.24.2 // indirect
 	github.com/aymerick/douceur v0.2.0 // indirect
-	github.com/bahlo/generic-list-go v0.2.0 // indirect
-	github.com/buger/jsonparser v1.1.1 // 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
-	github.com/charmbracelet/colorprofile v0.4.2 // indirect
+	github.com/charmbracelet/colorprofile v0.4.3 // indirect
 	github.com/charmbracelet/harmonica v0.2.0 // indirect
 	github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 // indirect
-	github.com/charmbracelet/ultraviolet v0.0.0-20260303162955-0b88c25f3fff // 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/x/cellbuf v0.0.15 // indirect
-	github.com/charmbracelet/x/exp/charmtone v0.0.0-20260305213658-fe36e8c10185 // indirect
-	github.com/charmbracelet/x/exp/slice v0.0.0-20260305213658-fe36e8c10185 // indirect
+	github.com/charmbracelet/x/exp/charmtone v0.0.0-20260323091123-df7b1bcffcca // 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/strings v0.1.0 // indirect
 	github.com/charmbracelet/x/json v0.2.0 // indirect
 	github.com/charmbracelet/x/termios v0.1.1 // indirect
 	github.com/charmbracelet/x/windows v0.2.2 // indirect
 	github.com/clipperhouse/displaywidth v0.11.0 // indirect
 	github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
-	github.com/coder/acp-go-sdk v0.6.3 // indirect
 	github.com/dlclark/regexp2 v1.11.5 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
@@ -71,26 +75,26 @@ require (
 	github.com/goccy/go-yaml v1.19.2 // indirect
 	github.com/golang-jwt/jwt/v5 v5.3.0 // indirect
 	github.com/google/go-cmp v0.7.0 // indirect
+	github.com/google/jsonschema-go v0.4.2 // indirect
 	github.com/google/s2a-go v0.1.9 // indirect
 	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.17.0 // 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/invopop/jsonschema v0.13.0 // indirect
+	github.com/indaco/herald v0.9.0 // indirect
 	github.com/kaptinlin/go-i18n v0.2.12 // indirect
 	github.com/kaptinlin/jsonpointer v0.4.17 // indirect
-	github.com/kaptinlin/jsonschema v0.7.5 // indirect
+	github.com/kaptinlin/jsonschema v0.7.6 // indirect
 	github.com/kaptinlin/messageformat-go v0.4.18 // indirect
-	github.com/mailru/easyjson v0.9.1 // indirect
 	github.com/microcosm-cc/bluemonday v1.0.27 // 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/openai/openai-go/v2 v2.7.1 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/pelletier/go-toml/v2 v2.3.0 // indirect
 	github.com/sagikazarmark/locafero v0.12.0 // indirect
 	github.com/spf13/afero v1.15.0 // indirect
 	github.com/spf13/cast v1.10.0 // indirect
@@ -99,45 +103,44 @@ require (
 	github.com/tidwall/match v1.2.0 // indirect
 	github.com/tidwall/pretty v1.2.1 // indirect
 	github.com/tidwall/sjson v1.2.5 // indirect
-	github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	github.com/yosida95/uritemplate/v3 v3.0.2 // indirect
-	github.com/yuin/goldmark v1.7.16 // 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.66.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.66.0 // indirect
-	go.opentelemetry.io/otel v1.41.0 // indirect
-	go.opentelemetry.io/otel/metric v1.41.0 // indirect
-	go.opentelemetry.io/otel/trace v1.41.0 // 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
+	go.opentelemetry.io/otel v1.42.0 // indirect
+	go.opentelemetry.io/otel/metric v1.42.0 // indirect
+	go.opentelemetry.io/otel/trace v1.42.0 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/crypto v0.48.0 // indirect
-	golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa // indirect
-	golang.org/x/net v0.51.0 // indirect
-	golang.org/x/oauth2 v0.35.0 // indirect
-	golang.org/x/time v0.14.0 // indirect
-	google.golang.org/api v0.269.0 // indirect
-	google.golang.org/genai v1.49.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171 // indirect
-	google.golang.org/grpc v1.79.2 // indirect
+	golang.org/x/crypto v0.49.0 // indirect
+	golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90 // indirect
+	golang.org/x/net v0.52.0 // indirect
+	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/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
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
 
 require (
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/charmbracelet/glamour v0.10.0
-	github.com/charmbracelet/x/ansi v0.11.6 // 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/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-runewidth v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.21 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
 	github.com/muesli/termenv v0.16.0 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/spf13/pflag v1.0.10 // indirect
-	golang.org/x/sync v0.19.0 // indirect
-	golang.org/x/sys v0.41.0 // indirect
-	golang.org/x/text v0.34.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
+	golang.org/x/sys v0.42.0 // indirect
+	golang.org/x/text v0.35.0
 )

go.sum

@@ -1,15 +1,17 @@
 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/bubbletea/v2 v2.0.1 h1:B8e9zzK7x9JJ+XvHGF4xnYu9Xa0E0y0MyggY6dbaCfQ=
-charm.land/bubbletea/v2 v2.0.1/go.mod h1:3LRff2U4WIYXy7MTxfbAQ+AdfM3D8Xuvz2wbsOD9OHQ=
-charm.land/fantasy v0.11.1 h1:G1dRqkzEQ0RJN1Ls5mte8HOi0wFKxYd5bfnRAmeYvDk=
-charm.land/fantasy v0.11.1/go.mod h1:C8wNxWlw+b2z54zsTor9r1tG2GE2C4QotvAlgXh9KF8=
-charm.land/lipgloss/v2 v2.0.0 h1:sd8N/B3x892oiOjFfBQdXBQp3cAkvjGaU5TvVZC3ivo=
-charm.land/lipgloss/v2 v2.0.0/go.mod h1:w6SnmsBFBmEFBodiEDurGS/sdUY/u1+v72DqUzc6J14=
+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=
+charm.land/fantasy v0.17.1/go.mod h1:FF5ALCCHETacHJPBqU42CtwMInYQ0ul52fdzIHQMbQk=
+charm.land/huh/v2 v2.0.3 h1:2cJsMqEPwSywGHvdlKsJyQKPtSJLVnFKyFbsYZTlLkU=
+charm.land/huh/v2 v2.0.3/go.mod h1:93eEveeeqn47MwiC3tf+2atZ2l7Is88rAtmZNZ8x9Wc=
+charm.land/lipgloss/v2 v2.0.2 h1:xFolbF8JdpNkM2cEPTfXEcW1p6NRzOWTSamRfYEw8cs=
+charm.land/lipgloss/v2 v2.0.2/go.mod h1:KjPle2Qd3YmvP1KL5OMHiHysGcNwq6u83MUjYkFvEkM=
 cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE=
 cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU=
-cloud.google.com/go/auth v0.18.2 h1:+Nbt5Ev0xEqxlNjd6c+yYUeosQ5TtEUaNcN/3FozlaM=
-cloud.google.com/go/auth v0.18.2/go.mod h1:xD+oY7gcahcu7G2SG2DsBerfFxgPAJz17zz2joOFF3M=
+cloud.google.com/go/auth v0.19.0 h1:DGYwtbcsGsT1ywuxsIoWi1u/vlks0moIblQHgSDgQkQ=
+cloud.google.com/go/auth v0.19.0/go.mod h1:2Aph7BT2KnaSFOM0JDPyiYgNh6PL9vGMiP8CUIXZ+IY=
 cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc=
 cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c=
 cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs=
@@ -32,74 +34,82 @@ 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.3 h1:4kQ/fa22KjDt13QCy1+bYADvdgcxpfH18f0zP542kZA=
-github.com/aws/aws-sdk-go-v2 v1.41.3/go.mod h1:mwsPRE8ceUUpiTgF7QmQIJ7lgsKUPQOUl3o72QBrE1o=
-github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.6 h1:N4lRUXZpZ1KVEUn6hxtco/1d2lgYhNn1fHkkl8WhlyQ=
-github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.6/go.mod h1:lyw7GFp3qENLh7kwzf7iMzAxDn+NzjXEAGjKS2UOKqI=
-github.com/aws/aws-sdk-go-v2/config v1.32.11 h1:ftxI5sgz8jZkckuUHXfC/wMUc8u3fG1vQS0plr2F2Zs=
-github.com/aws/aws-sdk-go-v2/config v1.32.11/go.mod h1:twF11+6ps9aNRKEDimksp923o44w/Thk9+8YIlzWMmo=
-github.com/aws/aws-sdk-go-v2/credentials v1.19.11 h1:NdV8cwCcAXrCWyxArt58BrvZJ9pZ9Fhf9w6Uh5W3Uyc=
-github.com/aws/aws-sdk-go-v2/credentials v1.19.11/go.mod h1:30yY2zqkMPdrvxBqzI9xQCM+WrlrZKSOpSJEsylVU+8=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.19 h1:INUvJxmhdEbVulJYHI061k4TVuS3jzzthNvjqvVvTKM=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.19/go.mod h1:FpZN2QISLdEBWkayloda+sZjVJL+e9Gl0k1SyTgcswU=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.19 h1:/sECfyq2JTifMI2JPyZ4bdRN77zJmr6SrS1eL3augIA=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.19/go.mod h1:dMf8A5oAqr9/oxOfLkC/c2LU/uMcALP0Rgn2BD5LWn0=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.19 h1:AWeJMk33GTBf6J20XJe6qZoRSJo0WfUhsMdUKhoODXE=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.19/go.mod h1:+GWrYoaAsV7/4pNHpwh1kiNLXkKaSoppxQq9lbH8Ejw=
-github.com/aws/aws-sdk-go-v2/internal/ini v1.8.5 h1:clHU5fm//kWS1C2HgtgWxfQbFbx4b6rx+5jzhgX9HrI=
-github.com/aws/aws-sdk-go-v2/internal/ini v1.8.5/go.mod h1:O3h0IK87yXci+kg6flUKzJnWeziQUKciKrLjcatSNcY=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.6 h1:XAq62tBTJP/85lFD5oqOOe7YYgWxY9LvWq8plyDvDVg=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.6/go.mod h1:x0nZssQ3qZSnIcePWLvcoFisRXJzcTVvYpAAdYX8+GI=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.19 h1:X1Tow7suZk9UCJHE1Iw9GMZJJl0dAnKXXP1NaSDHwmw=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.19/go.mod h1:/rARO8psX+4sfjUQXp5LLifjUt8DuATZ31WptNJTyQA=
-github.com/aws/aws-sdk-go-v2/service/signin v1.0.7 h1:Y2cAXlClHsXkkOvWZFXATr34b0hxxloeQu/pAZz2row=
-github.com/aws/aws-sdk-go-v2/service/signin v1.0.7/go.mod h1:idzZ7gmDeqeNrSPkdbtMp9qWMgcBwykA7P7Rzh5DXVU=
-github.com/aws/aws-sdk-go-v2/service/sso v1.30.12 h1:iSsvB9EtQ09YrsmIc44Heqlx5ByGErqhPK1ZQLppias=
-github.com/aws/aws-sdk-go-v2/service/sso v1.30.12/go.mod h1:fEWYKTRGoZNl8tZ77i61/ccwOMJdGxwOhWCkp6TXAr0=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.16 h1:EnUdUqRP1CNzt2DkV67tJx6XDN4xlfBFm+bzeNOQVb0=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.16/go.mod h1:Jic/xv0Rq/pFNCh3WwpH4BEqdbSAl+IyHro8LbibHD8=
-github.com/aws/aws-sdk-go-v2/service/sts v1.41.8 h1:XQTQTF75vnug2TXS8m7CVJfC2nniYPZnO1D4Np761Oo=
-github.com/aws/aws-sdk-go-v2/service/sts v1.41.8/go.mod h1:Xgx+PR1NUOjNmQY+tRMnouRp83JRM8pRMw/vCaVhPkI=
+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/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/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/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.0 h1:TKnLPh7IbnizJIBKFWa9mKayRUBQ9Kh1BPCk6w2PnYM=
-github.com/aymanbagabas/go-udiff v0.4.0/go.mod h1:0L9PGwj20lrtmEMeyw4WKJ/TMyDtvAoK9bf2u/mNo3w=
+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/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk=
-github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg=
-github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
-github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
+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=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/charmbracelet/anthropic-sdk-go v0.0.0-20260223140439-63879b0b8dab h1:J7XQLgl9sefgTnTGrmX3xqvp5o6MCiBzEjGv5igAlc4=
 github.com/charmbracelet/anthropic-sdk-go v0.0.0-20260223140439-63879b0b8dab/go.mod h1:hqlYqR7uPKOKfnNeicUbZp0Ps0GeYFlKYtwh5HGDCx8=
-github.com/charmbracelet/colorprofile v0.4.2 h1:BdSNuMjRbotnxHSfxy+PCSa4xAmz7szw70ktAtWRYrY=
-github.com/charmbracelet/colorprofile v0.4.2/go.mod h1:0rTi81QpwDElInthtrQ6Ni7cG0sDtwAd4C4le060fT8=
-github.com/charmbracelet/fang v0.4.4 h1:G4qKxF6or/eTPgmAolwPuRNyuci3hTUGGX1rj1YkHJY=
-github.com/charmbracelet/fang v0.4.4/go.mod h1:P5/DNb9DddQ0Z0dbc0P3ol4/ix5Po7Ofr2KMBfAqoCo=
-github.com/charmbracelet/glamour v0.10.0 h1:MtZvfwsYCx8jEPFJm3rIBFIMZUfUJ765oX8V6kXldcY=
-github.com/charmbracelet/glamour v0.10.0/go.mod h1:f+uf+I/ChNmqo087elLnVdCiVgjSKWuXa/l6NU2ndYk=
+github.com/charmbracelet/colorprofile v0.4.3 h1:QPa1IWkYI+AOB+fE+mg/5/4HRMZcaXex9t5KX76i20Q=
+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=
 github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834/go.mod h1:aKC/t2arECF6rNOnaKaVU6y4t4ZeHQzqfxedE/VkVhA=
-github.com/charmbracelet/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig=
-github.com/charmbracelet/log v0.4.2/go.mod h1:qifHGX/tc7eluv2R6pWIpyHDDrrb/AG71Pf2ysQu5nw=
-github.com/charmbracelet/ultraviolet v0.0.0-20260303162955-0b88c25f3fff h1:uY7A6hTokHPJBHfq7rj9Y/wm+IAjOghZTxKfVW6QLvw=
-github.com/charmbracelet/ultraviolet v0.0.0-20260303162955-0b88c25f3fff/go.mod h1:E6/0abq9uG2SnM8IbLB9Y5SW09uIgfaFETk8aRzgXUQ=
+github.com/charmbracelet/log v1.0.0 h1:HVVVMmfOorfj3BA9i8X8UL69Hoz9lI0PYwXfJvOdRc4=
+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/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=
 github.com/charmbracelet/x/cellbuf v0.0.15/go.mod h1:J1YVbR7MUuEGIFPCaaZ96KDl5NoS0DAWkskup+mOY+Q=
-github.com/charmbracelet/x/exp/charmtone v0.0.0-20260305213658-fe36e8c10185 h1:/192monmpmRICpSPrFRzkIO+xfhioV6/nwrQdkDTj10=
-github.com/charmbracelet/x/exp/charmtone v0.0.0-20260305213658-fe36e8c10185/go.mod h1:nsExn0DGyX0lh9LwLHTn2Gg+hafdzfSXnC+QmEJTZFY=
+github.com/charmbracelet/x/conpty v0.1.1 h1:s1bUxjoi7EpqiXysVtC+a8RrvPPNcNvAjfi4jxsAuEs=
+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/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/slice v0.0.0-20260305213658-fe36e8c10185 h1:bloHJLweYZeIkBVgi8AF94DrTdx3eoEB57VOpFuFi3U=
-github.com/charmbracelet/x/exp/slice v0.0.0-20260305213658-fe36e8c10185/go.mod h1:vqEfX6xzqW1pKKZUUiFOKg0OQ7bCh54Q2vR/tserrRA=
+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/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=
 github.com/charmbracelet/x/json v0.2.0/go.mod h1:opFIflx2YgXgi49xVUu8gEQ21teFAxyMwvOiZhIvWNM=
 github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk=
@@ -108,6 +118,8 @@ github.com/charmbracelet/x/termios v0.1.1 h1:o3Q2bT8eqzGnGPOYheoYS8eEleT5ZVNYNy8
 github.com/charmbracelet/x/termios v0.1.1/go.mod h1:rB7fnv1TgOPOyyKRJ9o+AsTU/vK5WHJ2ivHeut/Pcwo=
 github.com/charmbracelet/x/windows v0.2.2 h1:IofanmuvaxnKHuV04sC0eBy/smG6kIKrWG2/jYn2GuM=
 github.com/charmbracelet/x/windows v0.2.2/go.mod h1:/8XtdKZzedat74NQFn0NGlGL4soHB0YQZrETF96h75k=
+github.com/charmbracelet/x/xpty v0.1.3 h1:eGSitii4suhzrISYH50ZfufV3v085BXQwIytcOdFSsw=
+github.com/charmbracelet/x/xpty v0.1.3/go.mod h1:poPYpWuLDBFCKmKLDnhBp51ATa0ooD8FhypRwEFtH3Y=
 github.com/clipperhouse/displaywidth v0.11.0 h1:lBc6kY44VFw+TDx4I8opi/EtL9m20WSEFgwIwO+UVM8=
 github.com/clipperhouse/displaywidth v0.11.0/go.mod h1:bkrFNkf81G8HyVqmKGxsPufD3JhNl3dSqnGhOoSD/o0=
 github.com/clipperhouse/uax29/v2 v2.7.0 h1:+gs4oBZ2gPfVrKPthwbMzWZDaAFPGYK72F0NJv2v7Vk=
@@ -117,12 +129,16 @@ github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2/go.mod h1:qwXFYgsP6T7X
 github.com/coder/acp-go-sdk v0.6.3 h1:LsXQytehdjKIYJnoVWON/nf7mqbiarnyuyE3rrjBsXQ=
 github.com/coder/acp-go-sdk v0.6.3/go.mod h1:yKzM/3R9uELp4+nBAwwtkS0aN1FOFjo11CNPy37yFko=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
+github.com/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s=
+github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ=
 github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/dnaeon/go-vcr v1.2.0 h1:zHCHvJYTMh1N7xnV7zf1m1GPBF9Ad0Jk/whtQ1663qI=
 github.com/dnaeon/go-vcr v1.2.0/go.mod h1:R4UdLID7HZT3taECzJs4YgbbH6PIGXB6W/sc5OLb6RQ=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/envoyproxy/go-control-plane v0.14.0 h1:hbG2kr4RuFj222B6+7T83thSPqLjwBIfQawTkC++2HA=
 github.com/envoyproxy/go-control-plane/envoy v1.37.0 h1:u3riX6BoYRfF4Dr7dwSOroNfdSbEPe9Yyl09/B6wBrQ=
 github.com/envoyproxy/go-control-plane/envoy v1.37.0/go.mod h1:DReE9MMrmecPy+YvQOAOHNYMALuowAnbjjEMkkWOi6A=
@@ -153,14 +169,16 @@ github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/jsonschema-go v0.4.2 h1:tmrUohrwoLZZS/P3x7ex0WAVknEkBZM46iALbcqoRA8=
+github.com/google/jsonschema-go v0.4.2/go.mod h1:r5quNTdLOYEz95Ru18zA0ydNbBuYoo9tgaYcxEYhJVE=
 github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0=
 github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/enterprise-certificate-proxy v0.3.14 h1:yh8ncqsbUY4shRD5dA6RlzjJaT4hi3kII+zYw8wmLb8=
 github.com/googleapis/enterprise-certificate-proxy v0.3.14/go.mod h1:vqVt9yG9480NtzREnTlmGSBmFrA+bzb0yl0TxoBQXOg=
-github.com/googleapis/gax-go/v2 v2.17.0 h1:RksgfBpxqff0EZkDWYuz9q/uWsTVz+kf43LsZ1J6SMc=
-github.com/googleapis/gax-go/v2 v2.17.0/go.mod h1:mzaqghpQp4JDh3HvADwrat+6M3MOIDp5YKHhb9PAgDY=
+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=
@@ -169,14 +187,14 @@ github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUq
 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/invopop/jsonschema v0.13.0 h1:KvpoAJWEjR3uD9Kbm2HWJmqsEaHt8lBUpd0qHcIi21E=
-github.com/invopop/jsonschema v0.13.0/go.mod h1:ffZ5Km5SWWRAIN6wbDXItl95euhFz2uON45H2qjYt+0=
+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/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.5 h1:jkK4a3NyzNoGlvu12CsL3IcqNMVa5sL51HPVa0nWcPY=
-github.com/kaptinlin/jsonschema v0.7.5/go.mod h1:3gIWnptl+SWMyfMR2r4TXXd0xsQZ1m50AKrwmcUONSg=
+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/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
@@ -187,17 +205,17 @@ github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0
 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/mailru/easyjson v0.9.1 h1:LbtsOm5WAswyWbvTEOqhypdPeZzHavpZx96/n553mR8=
-github.com/mailru/easyjson v0.9.1/go.mod h1:1+xMtQp2MRNVL/V1bOzuP3aP8VNwRW55fQUto+XFtTU=
-github.com/mark3labs/mcp-go v0.44.1 h1:2PKppYlT9X2fXnE8SNYQLAX4hNjfPB0oNLqQVcN6mE8=
-github.com/mark3labs/mcp-go v0.44.1/go.mod h1:YnJfOL382MIWDx1kMY+2zsRHU/q78dBg9aFb8W6Thdw=
+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.20 h1:WcT52H91ZUAwy8+HUkdM3THM6gXqXuLJi9O3rjcQQaQ=
-github.com/mattn/go-runewidth v0.0.20/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
+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=
 github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
 github.com/muesli/mango v0.2.0 h1:iNNc0c5VLQ6fsMgAqGQofByNUBH2Q2nEbD6TaI+5yyQ=
@@ -212,10 +230,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=
 github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
-github.com/openai/openai-go/v2 v2.7.1 h1:/tfvTJhfv7hTSL8mWwc5VL4WLLSDL5yn9VqVykdu9r8=
-github.com/openai/openai-go/v2 v2.7.1/go.mod h1:jrJs23apqJKKbT+pqtFgNKpRju/KP9zpUTZhz3GElQE=
-github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
-github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
+github.com/pelletier/go-toml/v2 v2.3.0 h1:k59bC/lIZREW0/iVaQR8nDHxVq8OVlIzYCOJf421CaM=
+github.com/pelletier/go-toml/v2 v2.3.0/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo=
@@ -259,63 +275,65 @@ github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
 github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
 github.com/traefik/yaegi v0.16.1 h1:f1De3DVJqIDKmnasUF6MwmWv1dSEEat0wcpXhD2On3E=
 github.com/traefik/yaegi v0.16.1/go.mod h1:4eVhbPb3LnD2VigQjhYbEJ69vDRFdT2HQNrXx8eEwUY=
-github.com/wk8/go-ordered-map/v2 v2.1.8 h1:5h/BUHu93oj4gIdvHHHGsScSTMijfx5PeYkE/fJgbpc=
-github.com/wk8/go-ordered-map/v2 v2.1.8/go.mod h1:5nJHM5DyteebpVlHnWMV0rPz6Zp7+xBAnxjb1X5vnTw=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
 github.com/yosida95/uritemplate/v3 v3.0.2 h1:Ed3Oyj9yrmi9087+NczuL5BwkIc4wvTb5zIM+UJPGz4=
 github.com/yosida95/uritemplate/v3 v3.0.2/go.mod h1:ILOh0sOhIJR3+L/8afwt/kE++YT040gmv5BQTMR2HP4=
-github.com/yuin/goldmark v1.7.16 h1:n+CJdUxaFMiDUNnWC3dMWCIQJSkxH4uz3ZwQBkAlVNE=
-github.com/yuin/goldmark v1.7.16/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
+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.66.0 h1:w/o339tDd6Qtu3+ytwt+/jon2yjAs3Ot8Xq8pelfhSo=
-go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.66.0/go.mod h1:pdhNtM9C4H5fRdrnwO7NjxzQWhKSSxCHk/KluVqDVC0=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.66.0 h1:PnV4kVnw0zOmwwFkAzCN5O07fw1YOIQor120zrh0AVo=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.66.0/go.mod h1:ofAwF4uinaf8SXdVzzbL4OsxJ3VfeEg3f/F6CeF49/Y=
-go.opentelemetry.io/otel v1.41.0 h1:YlEwVsGAlCvczDILpUXpIpPSL/VPugt7zHThEMLce1c=
-go.opentelemetry.io/otel v1.41.0/go.mod h1:Yt4UwgEKeT05QbLwbyHXEwhnjxNO6D8L5PQP51/46dE=
-go.opentelemetry.io/otel/metric v1.41.0 h1:rFnDcs4gRzBcsO9tS8LCpgR0dxg4aaxWlJxCno7JlTQ=
-go.opentelemetry.io/otel/metric v1.41.0/go.mod h1:xPvCwd9pU0VN8tPZYzDZV/BMj9CM9vs00GuBjeKhJps=
-go.opentelemetry.io/otel/sdk v1.41.0 h1:YPIEXKmiAwkGl3Gu1huk1aYWwtpRLeskpV+wPisxBp8=
-go.opentelemetry.io/otel/sdk v1.41.0/go.mod h1:ahFdU0G5y8IxglBf0QBJXgSe7agzjE4GiTJ6HT9ud90=
-go.opentelemetry.io/otel/sdk/metric v1.41.0 h1:siZQIYBAUd1rlIWQT2uCxWJxcCO7q3TriaMlf08rXw8=
-go.opentelemetry.io/otel/sdk/metric v1.41.0/go.mod h1:HNBuSvT7ROaGtGI50ArdRLUnvRTRGniSUZbxiWxSO8Y=
-go.opentelemetry.io/otel/trace v1.41.0 h1:Vbk2co6bhj8L59ZJ6/xFTskY+tGAbOnCtQGVVa9TIN0=
-go.opentelemetry.io/otel/trace v1.41.0/go.mod h1:U1NU4ULCoxeDKc09yCWdWe+3QoyweJcISEVa1RBzOis=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0 h1:yI1/OhfEPy7J9eoa6Sj051C7n5dvpj0QX8g4sRchg04=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0/go.mod h1:NoUCKYWK+3ecatC4HjkRktREheMeEtrXoQxrqYFeHSc=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.67.0 h1:OyrsyzuttWTSur2qN/Lm0m2a8yqyIjUVBZcxFPuXq2o=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.67.0/go.mod h1:C2NGBr+kAB4bk3xtMXfZ94gqFDtg/GkI7e9zqGh5Beg=
+go.opentelemetry.io/otel v1.42.0 h1:lSQGzTgVR3+sgJDAU/7/ZMjN9Z+vUip7leaqBKy4sho=
+go.opentelemetry.io/otel v1.42.0/go.mod h1:lJNsdRMxCUIWuMlVJWzecSMuNjE7dOYyWlqOXWkdqCc=
+go.opentelemetry.io/otel/metric v1.42.0 h1:2jXG+3oZLNXEPfNmnpxKDeZsFI5o4J+nz6xUlaFdF/4=
+go.opentelemetry.io/otel/metric v1.42.0/go.mod h1:RlUN/7vTU7Ao/diDkEpQpnz3/92J9ko05BIwxYa2SSI=
+go.opentelemetry.io/otel/sdk v1.42.0 h1:LyC8+jqk6UJwdrI/8VydAq/hvkFKNHZVIWuslJXYsDo=
+go.opentelemetry.io/otel/sdk v1.42.0/go.mod h1:rGHCAxd9DAph0joO4W6OPwxjNTYWghRWmkHuGbayMts=
+go.opentelemetry.io/otel/sdk/metric v1.42.0 h1:D/1QR46Clz6ajyZ3G8SgNlTJKBdGp84q9RKCAZ3YGuA=
+go.opentelemetry.io/otel/sdk/metric v1.42.0/go.mod h1:Ua6AAlDKdZ7tdvaQKfSmnFTdHx37+J4ba8MwVCYM5hc=
+go.opentelemetry.io/otel/trace v1.42.0 h1:OUCgIPt+mzOnaUTpOQcBiM/PLQ/Op7oq6g4LenLmOYY=
+go.opentelemetry.io/otel/trace v1.42.0/go.mod h1:f3K9S+IFqnumBkKhRJMeaZeNk9epyhnCmQh/EysQCdc=
 go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
-golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=
-golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa h1:Zt3DZoOFFYkKhDT3v7Lm9FDMEV06GpzjG2jrqW+QTE0=
-golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa/go.mod h1:K79w1Vqn7PoiZn+TkNpx3BUWUQksGO3JcVX6qIjytmA=
-golang.org/x/net v0.51.0 h1:94R/GTO7mt3/4wIKpcR5gkGmRLOuE/2hNGeWq/GBIFo=
-golang.org/x/net v0.51.0/go.mod h1:aamm+2QF5ogm02fjy5Bb7CQ0WMt1/WVM7FtyaTLlA9Y=
-golang.org/x/oauth2 v0.35.0 h1:Mv2mzuHuZuY2+bkyWXIHMfhNdJAdwW3FuWeCPYN5GVQ=
-golang.org/x/oauth2 v0.35.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
-golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
-golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
+golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
+golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90 h1:jiDhWWeC7jfWqR9c/uplMOqJ0sbNlNWv0UkzE0vX1MA=
+golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90/go.mod h1:xE1HEv6b+1SCZ5/uscMRjUBKtIxworgEcEi+/n9NQDQ=
+golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0=
+golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=
+golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
+golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
-golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/term v0.40.0 h1:36e4zGLqU4yhjlmxEaagx2KuYbJq3EwY8K943ZsHcvg=
-golang.org/x/term v0.40.0/go.mod h1:w2P8uVp06p2iyKKuvXIm7N/y0UCRt3UfJTfZ7oOpglM=
-golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=
-golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA=
-golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
-golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
+golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
+golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/term v0.41.0 h1:QCgPso/Q3RTJx2Th4bDLqML4W6iJiaXFq2/ftQF13YU=
+golang.org/x/term v0.41.0/go.mod h1:3pfBgksrReYfZ5lvYM0kSO0LIkAl4Yl2bXOkKP7Ec2A=
+golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
+golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
+golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
+golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
 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.269.0 h1:qDrTOxKUQ/P0MveH6a7vZ+DNHxJQjtGm/uvdbdGXCQg=
-google.golang.org/api v0.269.0/go.mod h1:N8Wpcu23Tlccl0zSHEkcAZQKDLdquxK+l9r2LkwAauE=
-google.golang.org/genai v1.49.0 h1:Se+QJaH2GYK1aaR1o5S38mlU2GD5FnVvP76nfkV7LH0=
-google.golang.org/genai v1.49.0/go.mod h1:A3kkl0nyBjyFlNjgxIwKq70julKbIxpSxqKO5gw/gmk=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171 h1:ggcbiqK8WWh6l1dnltU4BgWGIGo+EVYxCaAPih/zQXQ=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
-google.golang.org/grpc v1.79.2 h1:fRMD94s2tITpyJGtBBn7MkMseNpOZU8ZxgC3MMBaXRU=
-google.golang.org/grpc v1.79.2/go.mod h1:KmT0Kjez+0dde/v2j9vzwoAScgEPx/Bw1CYChhHLrHQ=
+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/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=
+google.golang.org/genproto/googleapis/api v0.0.0-20260319201613-d00831a3d3e7/go.mod h1:EIQZ5bFCfRQDV4MhRle7+OgjNtZ6P1PiZBgAKuxXu/Y=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260319201613-d00831a3d3e7 h1:ndE4FoJqsIceKP2oYSnUZqhTdYufCYYkqwtFzfrhI7w=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260319201613-d00831a3d3e7/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
+google.golang.org/grpc v1.79.3 h1:sybAEdRIEtvcD68Gx7dmnwjZKlyfuc61Dyo9pGXXkKE=
+google.golang.org/grpc v1.79.3/go.mod h1:KmT0Kjez+0dde/v2j9vzwoAScgEPx/Bw1CYChhHLrHQ=
 google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
 google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

internal/agent/agent.go

@@ -63,6 +63,18 @@ type ToolCallContentHandler func(content string)
 // ReasoningDeltaHandler is a function type for handling streaming reasoning/thinking deltas.
 type ReasoningDeltaHandler func(delta string)
 
+// ToolOutputHandler is a function type for handling streaming tool output chunks.
+// Used by tools like bash to stream output as it arrives rather than waiting
+// for the command to complete. The isStderr flag indicates if the chunk
+// contains stderr output.
+// Note: This is an alias for core.ToolOutputCallback to avoid import cycles.
+type ToolOutputHandler = core.ToolOutputCallback
+
+// StepUsageHandler is a function type for handling token usage after each
+// complete step in a multi-step agent turn. This enables real-time cost
+// 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.
 // Core tools (bash, read, write, edit, grep, find, ls) are registered as direct
 // fantasy.AgentTool implementations — no MCP layer, no serialization overhead.
@@ -171,7 +183,8 @@ func NewAgent(ctx context.Context, agentConfig *AgentConfig) (*Agent, error) {
 
 	// Pass generation parameters when available.
 	if agentConfig.ModelConfig != nil {
-		if agentConfig.ModelConfig.MaxTokens > 0 {
+		// Skip max_output_tokens for providers that don't support it (e.g., Codex OAuth)
+		if agentConfig.ModelConfig.MaxTokens > 0 && !providerResult.SkipMaxOutputTokens {
 			agentOpts = append(agentOpts, fantasy.WithMaxOutputTokens(int64(agentConfig.ModelConfig.MaxTokens)))
 		}
 		if agentConfig.ModelConfig.Temperature != nil {
@@ -218,7 +231,7 @@ func (a *Agent) GenerateWithLoop(ctx context.Context, messages []fantasy.Message
 	onResponse ResponseHandler, onToolCallContent ToolCallContentHandler,
 ) (*GenerateWithLoopResult, error) {
 	return a.GenerateWithLoopAndStreaming(ctx, messages, onToolCall, onToolExecution, onToolResult,
-		onResponse, onToolCallContent, nil, nil)
+		onResponse, onToolCallContent, nil, nil, nil, nil)
 }
 
 // GenerateWithLoopAndStreaming processes messages using the fantasy agent with streaming and callbacks.
@@ -229,16 +242,22 @@ func (a *Agent) GenerateWithLoopAndStreaming(ctx context.Context, messages []fan
 	onResponse ResponseHandler, onToolCallContent ToolCallContentHandler,
 	onStreamingResponse StreamingResponseHandler,
 	onReasoningDelta ReasoningDeltaHandler,
+	onToolOutput ToolOutputHandler,
+	onStepUsage StepUsageHandler,
 ) (*GenerateWithLoopResult, error) {
 
+	// Inject tool output handler into context for use by core tools (e.g., bash).
+	if onToolOutput != nil {
+		ctx = core.ContextWithToolOutputCallback(ctx, onToolOutput)
+	}
+
 	// Fantasy 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.
 	prompt, files, history := splitPromptAndHistory(messages)
 
-	// Track current tool call info for callbacks
-	var currentToolName string
+	// Track current tool call args for callbacks
 	var currentToolArgs string
 
 	// Use the streaming path when streaming is enabled OR when any callbacks are
@@ -249,8 +268,14 @@ func (a *Agent) GenerateWithLoopAndStreaming(ctx context.Context, messages []fan
 		onToolCallContent != nil || onStreamingResponse != nil || onReasoningDelta != nil
 
 	if a.streamingEnabled || hasCallbacks {
+		// Track completed step messages so we can return partial results
+		// on cancellation. Fantasy'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
-		result, err := a.fantasyAgent.Stream(ctx, fantasy.AgentStreamCall{
+		streamCall := fantasy.AgentStreamCall{
 			Prompt:   prompt,
 			Files:    files,
 			Messages: history,
@@ -282,7 +307,6 @@ func (a *Agent) GenerateWithLoopAndStreaming(ctx context.Context, messages []fan
 				if ctx.Err() != nil {
 					return ctx.Err()
 				}
-				currentToolName = tc.ToolName
 				currentToolArgs = tc.Input
 
 				// Notify about the tool call
@@ -319,6 +343,10 @@ func (a *Agent) GenerateWithLoopAndStreaming(ctx context.Context, messages []fan
 
 			// Step callbacks for content that accompanies tool calls
 			OnStepFinish: func(step fantasy.StepResult) error {
+				// Accumulate messages from completed steps so they can be
+				// persisted even if a later step is cancelled.
+				completedStepMessages = append(completedStepMessages, step.Messages...)
+
 				if ctx.Err() != nil {
 					return ctx.Err()
 				}
@@ -328,10 +356,73 @@ func (a *Agent) GenerateWithLoopAndStreaming(ctx context.Context, messages []fan
 				if text != "" && len(toolCalls) > 0 && onToolCallContent != nil {
 					onToolCallContent(text)
 				}
+				// Emit step usage for real-time cost tracking
+				if onStepUsage != nil {
+					onStepUsage(step.Usage.InputTokens, step.Usage.OutputTokens,
+						step.Usage.CacheReadTokens, step.Usage.CacheCreationTokens)
+				}
 				return nil
 			},
-		})
+		}
+
+		// If a steer channel is attached to the context, wire up a
+		// PrepareStep function that drains the channel between steps
+		// and injects pending steer messages as user messages before
+		// the next LLM call. This enables graceful mid-turn steering
+		// without cancelling in-progress tool execution.
+		if steerCh := steerChFromContext(ctx); steerCh != nil {
+			onConsumed := steerConsumedFromContext(ctx)
+			streamCall.PrepareStep = func(
+				stepCtx context.Context,
+				opts fantasy.PrepareStepFunctionOptions,
+			) (context.Context, fantasy.PrepareStepResult, error) {
+				// Drain all pending steer messages (non-blocking).
+				var steered []string
+				for {
+					select {
+					case msg := <-steerCh:
+						steered = append(steered, msg)
+					default:
+						goto done
+					}
+				}
+			done:
+				result := fantasy.PrepareStepResult{
+					Model:    opts.Model,
+					Messages: opts.Messages,
+				}
+				if len(steered) > 0 {
+					// Inject each steer message as a user message so the
+					// LLM sees the redirection on the next step.
+					for _, text := range steered {
+						result.Messages = append(result.Messages,
+							fantasy.NewUserMessage(text))
+					}
+					// Notify that steer messages were consumed.
+					if onConsumed != nil {
+						onConsumed(len(steered))
+					}
+				}
+				return stepCtx, result, nil
+			}
+		}
+
+		result, err := a.fantasyAgent.Stream(ctx, streamCall)
 		if err != nil {
+			// On cancellation (or any error), return a partial result
+			// containing messages from completed steps so the caller can
+			// persist tool calls and results that finished before the
+			// cancellation. The original input messages are included so
+			// the caller sees the full conversation up to the point of
+			// cancellation.
+			if len(completedStepMessages) > 0 {
+				partialMessages := make([]fantasy.Message, 0, len(messages)+len(completedStepMessages))
+				partialMessages = append(partialMessages, messages...)
+				partialMessages = append(partialMessages, completedStepMessages...)
+				return &GenerateWithLoopResult{
+					ConversationMessages: partialMessages,
+				}, err
+			}
 			return nil, err
 		}
 
@@ -359,8 +450,6 @@ func (a *Agent) GenerateWithLoopAndStreaming(ctx context.Context, messages []fan
 		onResponse(result.Response.Content.Text())
 	}
 
-	_ = currentToolName // satisfy compiler for non-streaming path
-
 	return convertAgentResult(result, messages), nil
 }
 
@@ -580,7 +669,8 @@ func (a *Agent) SetModel(ctx context.Context, config *models.ProviderConfig) err
 	}
 
 	// Pass generation parameters when available.
-	if config.MaxTokens > 0 {
+	// Skip max_output_tokens for providers that don't support it (e.g., Codex OAuth)
+	if config.MaxTokens > 0 && !providerResult.SkipMaxOutputTokens {
 		agentOpts = append(agentOpts, fantasy.WithMaxOutputTokens(int64(config.MaxTokens)))
 	}
 	if config.Temperature != nil {

internal/agent/steer.go

@@ -0,0 +1,35 @@
+package agent
+
+import "context"
+
+// steerChKey is the context key for the steer channel.
+type steerChKey struct{}
+
+// steerConsumedKey is the context key for the steer-consumed callback.
+type steerConsumedKey struct{}
+
+// ContextWithSteerCh returns a new context with the steer channel attached.
+// The agent's PrepareStep function checks this channel between steps and
+// injects any pending steer messages as user messages before the next LLM call.
+func ContextWithSteerCh(ctx context.Context, ch <-chan string) context.Context {
+	return context.WithValue(ctx, steerChKey{}, ch)
+}
+
+// ContextWithSteerConsumed returns a new context with a callback that fires
+// when steer messages are consumed by PrepareStep. The count argument is the
+// number of messages injected in this batch.
+func ContextWithSteerConsumed(ctx context.Context, fn func(count int)) context.Context {
+	return context.WithValue(ctx, steerConsumedKey{}, fn)
+}
+
+// steerChFromContext extracts the steer channel from the context, or nil.
+func steerChFromContext(ctx context.Context) <-chan string {
+	ch, _ := ctx.Value(steerChKey{}).(<-chan string)
+	return ch
+}
+
+// steerConsumedFromContext extracts the steer-consumed callback, or nil.
+func steerConsumedFromContext(ctx context.Context) func(int) {
+	fn, _ := ctx.Value(steerConsumedKey{}).(func(int))
+	return fn
+}

internal/app/app.go

@@ -3,7 +3,10 @@ package app
 import (
 	"context"
 	"fmt"
+	"log"
+	"os"
 	"sync"
+	"sync/atomic"
 
 	tea "charm.land/bubbletea/v2"
 	"charm.land/fantasy"
@@ -159,11 +162,57 @@ func (a *App) QueueLength() int {
 	return len(a.queue)
 }
 
-// Steer cancels the current agent step (if running), clears the queue, and
-// sends a new message that will execute as soon as the current step finishes
-// cancelling. If the agent is idle, the message executes immediately.
-// This is the "steer" delivery mode for SendMessage.
-func (a *App) Steer(prompt string) {
+// Steer injects a steering message into the currently running agent turn.
+// If the agent is in a multi-step tool loop, the message is delivered after
+// the current tool execution finishes but before the next LLM call (graceful
+// mid-turn injection via Fantasy's PrepareStep). If the agent is streaming
+// a text-only response (no pending tool calls), the message waits until the
+// response completes and then executes as the next turn.
+//
+// If the agent is idle, the message starts executing immediately (same as Run).
+//
+// Returns the number of pending steer/queue items (0 = started immediately,
+// >0 = injected/queued). The caller must update UI state based on the return
+// value — Steer does NOT send events to the program to avoid deadlocking
+// when called from within Update().
+//
+// Satisfies ui.AppController.
+func (a *App) Steer(prompt string) int {
+	a.mu.Lock()
+
+	if a.closed {
+		a.mu.Unlock()
+		return 0
+	}
+
+	if !a.busy {
+		// Not busy — start immediately, same as Run().
+		item := queueItem{Prompt: prompt}
+		a.busy = true
+		a.wg.Add(1)
+		a.mu.Unlock()
+		go a.drainQueue(item)
+		return 0
+	}
+
+	a.mu.Unlock()
+
+	// Agent is busy — inject via the SDK's steer channel. The message
+	// will be picked up by PrepareStep between agent steps (after tool
+	// execution, before next LLM call). If PrepareStep doesn't fire
+	// (text-only response), drainQueue will pick it up after the turn.
+	if a.opts.Kit != nil {
+		a.opts.Kit.InjectSteer(prompt)
+	}
+	return 1
+}
+
+// InterruptAndSend cancels the current agent step (if running), clears the
+// queue, and sends a new message that will execute as soon as the current
+// step finishes cancelling. If the agent is idle, the message executes
+// immediately. This is the hard-cancel delivery mode used by extensions'
+// CancelAndSend.
+func (a *App) InterruptAndSend(prompt string) {
 	a.mu.Lock()
 
 	if a.closed {
@@ -217,6 +266,26 @@ func (a *App) GetTreeSession() *session.TreeManager {
 	return a.opts.TreeSession
 }
 
+// SwitchTreeSession replaces the active tree session with a new one and
+// reloads the in-memory message store from the new session's messages.
+// The old tree session is closed. Used by /resume to switch sessions.
+func (a *App) SwitchTreeSession(ts *session.TreeManager) {
+	// Close old session.
+	if old := a.opts.TreeSession; old != nil {
+		_ = old.Close()
+	}
+	a.opts.TreeSession = ts
+	// Also update the kit SDK's tree session so messages are persisted correctly.
+	if a.opts.Kit != nil {
+		a.opts.Kit.SetTreeSession(ts)
+	}
+	// Reload messages from new session.
+	a.store.Clear()
+	if ts != nil {
+		a.store.Replace(ts.GetFantasyMessages())
+	}
+}
+
 // AddContextMessage adds a user-role message to the conversation history
 // without triggering an LLM response. Used by the ! shell command prefix
 // to inject command output into context so the LLM can reference it in
@@ -385,47 +454,94 @@ func (a *App) Close() {
 
 	// Wait for background goroutines.
 	a.wg.Wait()
+
+	// Clean up empty session file on shutdown.
+	if ts := a.opts.TreeSession; ts != nil && ts.IsEmpty() {
+		if path := ts.GetFilePath(); path != "" {
+			_ = os.Remove(path)
+		}
+	}
 }
 
 // --------------------------------------------------------------------------
 // Internal: queue drain loop
 // --------------------------------------------------------------------------
 
-// drainQueue runs in a goroutine. It executes the given item and then
-// continues draining the queue until it is empty.
+// drainQueue runs in a goroutine. It collects all queued items (including the
+// first one) and submits them together as a single batch. This ensures that
+// when multiple messages are queued while the agent is working, they are all
+// submitted together in one turn rather than sequentially.
 // Must be called with a.busy == true and a.wg incremented.
 func (a *App) drainQueue(first queueItem) {
 	defer a.wg.Done()
 
-	item := first
-	for {
-		a.runQueueItem(item)
+	// Collect all items to process in this batch
+	var items []queueItem
+	items = append(items, first)
 
+	// Process batches until no more items are queued
+	for {
+		// Drain the queue to collect any pending items
 		a.mu.Lock()
-		// Stop draining if the app is shutting down.
-		if a.closed || a.rootCtx.Err() != nil {
-			a.busy = false
-			a.queue = a.queue[:0]
-			a.mu.Unlock()
-			return
-		}
-		if len(a.queue) == 0 {
-			a.busy = false
-			a.mu.Unlock()
-			return
-		}
-		item = a.queue[0]
-		a.queue = a.queue[1:]
-		qLen := len(a.queue)
+		items = append(items, a.queue...)
+		a.queue = a.queue[:0] // Clear the queue
+		queueLen := len(a.queue)
 		a.mu.Unlock()
-		// sendEvent must be called without a.mu held (see sendEvent comment).
-		a.sendEvent(QueueUpdatedEvent{Length: qLen})
+
+		// Send queue updated event (queue is now empty)
+		a.sendEvent(QueueUpdatedEvent{Length: queueLen})
+
+		// Process all collected items as a single batch
+		a.runQueueBatch(items)
+
+		// Drain any unconsumed steer messages from the SDK channel.
+		// These arrive when the user steered during a text-only response
+		// (no tool calls, so PrepareStep didn't fire for a second step).
+		// They go to the front of the queue so they run next.
+		if a.opts.Kit != nil {
+			if leftover := a.opts.Kit.DrainSteer(); len(leftover) > 0 {
+				a.mu.Lock()
+				steerItems := make([]queueItem, len(leftover))
+				for i, text := range leftover {
+					steerItems[i] = queueItem{Prompt: text}
+				}
+				a.queue = append(steerItems, a.queue...)
+				a.mu.Unlock()
+				// Notify UI about the consumed steer messages.
+				a.sendEvent(SteerConsumedEvent{})
+			}
+		}
+
+		// Check if more items were queued while we were processing
+		a.mu.Lock()
+		hasMore := len(a.queue) > 0
+		if hasMore {
+			// Start a new batch with the newly queued items
+			items = a.queue
+			a.queue = a.queue[:0]
+		}
+		a.mu.Unlock()
+
+		if !hasMore {
+			// No more items, we're done
+			break
+		}
+		// Process the new batch
 	}
+
+	// Mark as no longer busy
+	a.mu.Lock()
+	a.busy = false
+	a.mu.Unlock()
 }
 
-// runQueueItem executes a single queue item: adds the user message to the store,
-// runs the agent step, and sends the appropriate event to the program.
-func (a *App) runQueueItem(item queueItem) {
+// runQueueBatch executes multiple queue items as a single agent turn.
+// All items are submitted together, and the agent responds once to the combined context.
+func (a *App) runQueueBatch(items []queueItem) {
+	if len(items) == 0 {
+		return
+	}
+
 	// Create a per-step cancellable context.
 	stepCtx, cancel := context.WithCancel(a.rootCtx)
 	a.mu.Lock()
@@ -444,12 +560,17 @@ func (a *App) runQueueItem(item queueItem) {
 		}
 	}
 
-	result, err := a.executeStep(stepCtx, item.Prompt, eventFn, item.Files)
+	// Execute the batch
+	result, err := a.executeBatch(stepCtx, items, eventFn)
 	if err != nil {
 		if stepCtx.Err() != nil {
-			// Step was cancelled by the user (e.g. double-ESC). Send a
-			// cancellation event so the TUI can cut off the response
-			// cleanly without printing an error.
+			// Step was cancelled by the user (double-ESC). The SDK
+			// preserves the user message and any completed tool
+			// 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.sendEvent(StepCancelledEvent{})
 			return
 		}
@@ -479,9 +600,10 @@ func (a *App) executeStep(ctx context.Context, prompt string, eventFn func(tea.M
 		}
 	}
 
-	// Subscribe to SDK events for TUI rendering. The subscription is
-	// temporary — it lives only for the duration of this step.
-	unsub := a.subscribeSDKEvents(sendFn)
+	// Subscribe to SDK events for TUI rendering and per-step usage updates.
+	// The subscription is temporary — it lives only for the duration of this step.
+	var sawStepUsage atomic.Bool
+	unsub := a.subscribeSDKEvents(sendFn, &sawStepUsage)
 	defer unsub()
 
 	// Show spinner while the agent works.
@@ -501,15 +623,97 @@ func (a *App) executeStep(ctx context.Context, prompt string, eventFn func(tea.M
 	// Sync in-memory store with the SDK's authoritative conversation.
 	a.store.Replace(result.Messages)
 
-	// Update usage tracker.
-	a.updateUsageFromTurnResult(result, prompt)
+	// Update usage tracker. If per-step usage was already recorded from
+	// StepUsageEvent callbacks, avoid double-counting totals.
+	a.updateUsageFromTurnResult(result, prompt, sawStepUsage.Load())
 
 	return result, nil
 }
 
-// --------------------------------------------------------------------------
-// Internal: event helpers
-// --------------------------------------------------------------------------
+// executeBatch runs a batch of queue items as a single agent step by delegating
+// to the SDK's PromptResultWithMessages(), which handles session persistence,
+// hooks, extension events, and the generation loop.
+func (a *App) executeBatch(ctx context.Context, items []queueItem, eventFn func(tea.Msg)) (*kit.TurnResult, error) {
+	// Test hook: bypass SDK entirely (single item only for test compatibility).
+	if a.opts.PromptFunc != nil {
+		if len(items) == 1 {
+			return a.opts.PromptFunc(ctx, items[0].Prompt)
+		}
+		// For batch mode with PromptFunc, just use the first item
+		return a.opts.PromptFunc(ctx, items[0].Prompt)
+	}
+
+	sendFn := func(msg tea.Msg) {
+		if eventFn != nil {
+			eventFn(msg)
+		}
+	}
+
+	// Subscribe to SDK events for TUI rendering and per-step usage updates.
+	// The subscription is temporary — it lives only for the duration of this step.
+	var sawStepUsage atomic.Bool
+	unsub := a.subscribeSDKEvents(sendFn, &sawStepUsage)
+	defer unsub()
+
+	// Show spinner while the agent works.
+	sendFn(SpinnerEvent{Show: true})
+
+	// Check if any items have file attachments
+	hasFiles := false
+	for _, item := range items {
+		if len(item.Files) > 0 {
+			hasFiles = true
+			break
+		}
+	}
+
+	var result *kit.TurnResult
+	var err error
+
+	if len(items) == 1 {
+		// Single item: use the original path for compatibility
+		item := items[0]
+		if len(item.Files) > 0 || hasFiles {
+			result, err = a.opts.Kit.PromptResultWithFiles(ctx, item.Prompt, item.Files)
+		} else {
+			result, err = a.opts.Kit.PromptResult(ctx, item.Prompt)
+		}
+	} else {
+		// Multiple items: batch them together
+		var messages []string
+		for _, item := range items {
+			messages = append(messages, item.Prompt)
+		}
+
+		// File attachments are not supported in batch mode; fall back to
+		// processing only the first item that carries files.
+		if hasFiles {
+			// If files exist, fall back to processing just the first item with files
+			for _, item := range items {
+				if len(item.Files) > 0 {
+					result, err = a.opts.Kit.PromptResultWithFiles(ctx, item.Prompt, item.Files)
+					break
+				}
+			}
+		} else {
+			result, err = a.opts.Kit.PromptResultWithMessages(ctx, messages)
+		}
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	// Sync in-memory store with the SDK's authoritative conversation.
+	a.store.Replace(result.Messages)
+
+	// Update usage tracker (using last item's prompt for fallback estimation).
+	// If per-step usage was already recorded from StepUsageEvent callbacks,
+	// avoid double-counting totals.
+	a.updateUsageFromTurnResult(result, items[len(items)-1].Prompt, sawStepUsage.Load())
+
+	return result, nil
+}
 
 // sendEvent sends a tea.Msg to the registered program if one is set.
 // Must NOT be called with a.mu held (to avoid deadlock with the program).
@@ -523,9 +727,10 @@ func (a *App) sendEvent(msg tea.Msg) {
 }
 
 // subscribeSDKEvents registers temporary SDK event subscribers that convert
-// SDK events to tea.Msg events and dispatch them via sendFn. Returns an
-// unsubscribe function that removes all listeners.
-func (a *App) subscribeSDKEvents(sendFn func(tea.Msg)) func() {
+// SDK events to tea.Msg events and dispatch them via sendFn. When stepUsageSeen
+// is provided, it is set to true after any non-zero StepUsageEvent is observed.
+// Returns an unsubscribe function that removes all listeners.
+func (a *App) subscribeSDKEvents(sendFn func(tea.Msg), stepUsageSeen *atomic.Bool) func() {
 	k := a.opts.Kit
 	var unsubs []func()
 
@@ -550,6 +755,17 @@ func (a *App) subscribeSDKEvents(sendFn func(tea.Msg)) func() {
 			sendFn(StreamChunkEvent{Content: ev.Chunk})
 		case kit.ReasoningDeltaEvent:
 			sendFn(ReasoningChunkEvent{Delta: ev.Delta})
+		case kit.ToolOutputEvent:
+			sendFn(ToolOutputEvent{
+				ToolCallID: ev.ToolCallID,
+				ToolName:   ev.ToolName,
+				Chunk:      ev.Chunk,
+				IsStderr:   ev.IsStderr,
+			})
+		case kit.SteerConsumedEvent:
+			sendFn(SteerConsumedEvent{})
+		case kit.StepUsageEvent:
+			a.recordStepUsage(ev, stepUsageSeen)
 		}
 	}))
 
@@ -719,29 +935,106 @@ func (a *App) PrintBlockFromExtension(opts extensions.PrintBlockOpts) {
 	}
 }
 
+// recordStepUsage applies token/cost usage reported for a completed step.
+// Step usage events arrive even when a turn is later cancelled, so this keeps
+// the usage widget accurate on all stop paths.
+func (a *App) recordStepUsage(ev kit.StepUsageEvent, stepUsageSeen *atomic.Bool) {
+	hasUsage := ev.InputTokens > 0 || ev.OutputTokens > 0 || ev.CacheReadTokens > 0 || ev.CacheWriteTokens > 0
+	if a.opts.Debug {
+		log.Printf("[DEBUG] recordStepUsage: hasUsage=%v input=%d output=%d cacheRead=%d cacheWrite=%d",
+			hasUsage, ev.InputTokens, ev.OutputTokens, ev.CacheReadTokens, ev.CacheWriteTokens)
+	}
+	if !hasUsage {
+		return
+	}
+	if stepUsageSeen != nil {
+		stepUsageSeen.Store(true)
+	}
+	if a.opts.UsageTracker == nil {
+		return
+	}
+	a.opts.UsageTracker.UpdateUsage(
+		int(ev.InputTokens),
+		int(ev.OutputTokens),
+		int(ev.CacheReadTokens),
+		int(ev.CacheWriteTokens),
+	)
+	// NOTE: We do NOT call SetContextTokens here. Context fill is set once
+	// at turn completion via updateUsageFromTurnResult using FinalUsage.InputTokens,
+	// which reflects the full accumulated context. Per-step context tokens would
+	// cause the display to jump around during multi-step tool calls.
+}
+
 // updateUsageFromTurnResult records token usage from an SDK TurnResult into the
-// configured UsageTracker. This is the SDK-path equivalent of updateUsage.
-func (a *App) updateUsageFromTurnResult(result *kit.TurnResult, userPrompt string) {
+// configured UsageTracker. Called once per turn after the turn completes.
+//
+// When sawStepUsage is true, totals were already accumulated incrementally via
+// StepUsageEvent callbacks; in that case this method only updates context fill.
+// Otherwise it falls back to TotalUsage from the API response.
+//
+// NOTE: We only use ACTUAL token counts from API responses for cost tracking.
+// Estimation is never used for costs - only API-reported tokens are accurate.
+func (a *App) updateUsageFromTurnResult(result *kit.TurnResult, userPrompt string, sawStepUsage bool) {
 	if a.opts.UsageTracker == nil || result == nil {
 		return
 	}
 
-	if result.TotalUsage != nil {
-		inputTokens := int(result.TotalUsage.InputTokens)
-		outputTokens := int(result.TotalUsage.OutputTokens)
-		if inputTokens > 0 && outputTokens > 0 {
-			cacheReadTokens := int(result.TotalUsage.CacheReadTokens)
-			cacheWriteTokens := int(result.TotalUsage.CacheCreationTokens)
-			a.opts.UsageTracker.UpdateUsage(inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens)
+	// Debug logging for token tracking
+	if a.opts.Debug {
+		if result.TotalUsage != nil {
+			log.Printf("[DEBUG] updateUsageFromTurnResult TotalUsage: input=%d output=%d cacheRead=%d cacheCreate=%d",
+				result.TotalUsage.InputTokens, result.TotalUsage.OutputTokens,
+				result.TotalUsage.CacheReadTokens, result.TotalUsage.CacheCreationTokens)
 		} else {
-			a.opts.UsageTracker.EstimateAndUpdateUsage(userPrompt, result.Response)
-			return
+			log.Printf("[DEBUG] updateUsageFromTurnResult: TotalUsage=nil")
 		}
+		if result.FinalUsage != nil {
+			log.Printf("[DEBUG] updateUsageFromTurnResult FinalUsage: input=%d output=%d cacheRead=%d cacheCreate=%d",
+				result.FinalUsage.InputTokens, result.FinalUsage.OutputTokens,
+				result.FinalUsage.CacheReadTokens, result.FinalUsage.CacheCreationTokens)
+		} else {
+			log.Printf("[DEBUG] updateUsageFromTurnResult: FinalUsage=nil")
+		}
+		log.Printf("[DEBUG] updateUsageFromTurnResult: sawStepUsage=%v", sawStepUsage)
 	}
 
-	if result.FinalUsage != nil {
-		if ct := int(result.FinalUsage.InputTokens) + int(result.FinalUsage.OutputTokens); ct > 0 {
-			a.opts.UsageTracker.SetContextTokens(ct)
+	// --- Accumulate cost/token totals for the session ---
+	// Only use actual API-reported tokens for cost tracking.
+	// If sawStepUsage is true, totals were already updated via StepUsageEvent.
+	// Check any token field > 0 (not just InputTokens) because cached prompts
+	// can result in InputTokens=0 while OutputTokens>0 (OpenAI-compatible behavior).
+	hasTotalUsage := result.TotalUsage != nil &&
+		(result.TotalUsage.InputTokens > 0 ||
+			result.TotalUsage.OutputTokens > 0 ||
+			result.TotalUsage.CacheReadTokens > 0 ||
+			result.TotalUsage.CacheCreationTokens > 0)
+	if a.opts.Debug {
+		log.Printf("[DEBUG] updateUsageFromTurnResult: hasTotalUsage=%v", hasTotalUsage)
+	}
+	if !sawStepUsage && hasTotalUsage {
+		if a.opts.Debug {
+			log.Printf("[DEBUG] updateUsageFromTurnResult: calling UpdateUsage input=%d output=%d cacheRead=%d cacheCreate=%d",
+				result.TotalUsage.InputTokens, result.TotalUsage.OutputTokens,
+				result.TotalUsage.CacheReadTokens, result.TotalUsage.CacheCreationTokens)
 		}
+		a.opts.UsageTracker.UpdateUsage(
+			int(result.TotalUsage.InputTokens),
+			int(result.TotalUsage.OutputTokens),
+			int(result.TotalUsage.CacheReadTokens),
+			int(result.TotalUsage.CacheCreationTokens),
+		)
+	}
+
+	// --- Context window fill (drives the % bar) ---
+	// Use FinalUsage.InputTokens as the context window fill. The API's InputTokens
+	// already includes the full conversation history (system prompt + all previous
+	// messages + current user message). Adding OutputTokens would double-count since
+	// the output becomes part of the input for the next turn.
+	if result.FinalUsage != nil && result.FinalUsage.InputTokens > 0 {
+		if a.opts.Debug {
+			log.Printf("[DEBUG] updateUsageFromTurnResult: calling SetContextTokens=%d (FinalUsage.InputTokens)",
+				result.FinalUsage.InputTokens)
+		}
+		a.opts.UsageTracker.SetContextTokens(int(result.FinalUsage.InputTokens))
 	}
 }

internal/app/app_test.go

@@ -7,6 +7,8 @@ import (
 	"testing"
 	"time"
 
+	"charm.land/fantasy"
+
 	kit "github.com/mark3labs/kit/pkg/kit"
 )
 
@@ -14,6 +16,47 @@ import (
 // Helpers
 // --------------------------------------------------------------------------
 
+type usageUpdaterStub struct {
+	mu sync.Mutex
+
+	updateCalls   int
+	estimateCalls int
+	contextCalls  int
+
+	lastUpdateInput      int
+	lastUpdateOutput     int
+	lastUpdateCacheRead  int
+	lastUpdateCacheWrite int
+	lastContextTokens    int
+	lastEstimateInput    string
+	lastEstimateOutput   string
+}
+
+func (s *usageUpdaterStub) UpdateUsage(inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens int) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.updateCalls++
+	s.lastUpdateInput = inputTokens
+	s.lastUpdateOutput = outputTokens
+	s.lastUpdateCacheRead = cacheReadTokens
+	s.lastUpdateCacheWrite = cacheWriteTokens
+}
+
+func (s *usageUpdaterStub) EstimateAndUpdateUsage(inputText, outputText string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.estimateCalls++
+	s.lastEstimateInput = inputText
+	s.lastEstimateOutput = outputText
+}
+
+func (s *usageUpdaterStub) SetContextTokens(tokens int) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.contextCalls++
+	s.lastContextTokens = tokens
+}
+
 // turnResult builds a minimal TurnResult with response text t.
 func turnResult(t string) *kit.TurnResult {
 	return &kit.TurnResult{Response: t}
@@ -120,9 +163,8 @@ func TestRun_single(t *testing.T) {
 // Run (queued prompts)
 // --------------------------------------------------------------------------
 
-// TestRun_queued verifies that a second Run() call while the first is in-flight
-// enqueues the prompt rather than spawning a second goroutine, and that the
-// queue is drained after the first step completes.
+// TestRun_queued verifies that queued prompts are batched together and submitted
+// as a single agent turn rather than individually.
 func TestRun_queued(t *testing.T) {
 	gate := make(chan struct{})
 	callCount := 0
@@ -134,13 +176,7 @@ func TestRun_queued(t *testing.T) {
 			callCount++
 			mu.Unlock()
 			<-gate
-			return turnResult("first"), nil
-		},
-		func(_ context.Context) (*kit.TurnResult, error) {
-			mu.Lock()
-			callCount++
-			mu.Unlock()
-			return turnResult("second"), nil
+			return turnResult("batch result"), nil
 		},
 	)
 	app := newTestApp(stub)
@@ -165,11 +201,15 @@ func TestRun_queued(t *testing.T) {
 		t.Fatal("app did not become idle within 3s after queued runs")
 	}
 
+	// Wait for the goroutine to fully finish (avoid race with queue check)
+	app.wg.Wait()
+
 	mu.Lock()
 	total := callCount
 	mu.Unlock()
-	if total != 2 {
-		t.Fatalf("expected 2 calls, got %d", total)
+	// With batching, both prompts should be processed in a single call
+	if total != 1 {
+		t.Fatalf("expected 1 batched call, got %d", total)
 	}
 	if got := app.QueueLength(); got != 0 {
 		t.Fatalf("expected empty queue after drain, got %d", got)
@@ -180,31 +220,22 @@ func TestRun_queued(t *testing.T) {
 // Queue drain ordering
 // --------------------------------------------------------------------------
 
-// TestQueueDrainOrdering verifies that queued prompts are consumed in FIFO order.
+// TestQueueDrainOrdering verifies that queued prompts are batched together and
+// processed in a single agent turn.
 func TestQueueDrainOrdering(t *testing.T) {
 	gate := make(chan struct{})
-	var order []string
+	var receivedPrompt string
 	var mu sync.Mutex
 
 	stub := newStubWithFuncs(
 		func(ctx context.Context) (*kit.TurnResult, error) {
 			mu.Lock()
-			order = append(order, "first")
+			// In test mode with PromptFunc, we receive the first prompt
+			// but all messages are batched together
+			receivedPrompt = "batched"
 			mu.Unlock()
 			<-gate
-			return turnResult("first"), nil
-		},
-		func(_ context.Context) (*kit.TurnResult, error) {
-			mu.Lock()
-			order = append(order, "second")
-			mu.Unlock()
-			return turnResult("second"), nil
-		},
-		func(_ context.Context) (*kit.TurnResult, error) {
-			mu.Lock()
-			order = append(order, "third")
-			mu.Unlock()
-			return turnResult("third"), nil
+			return turnResult("batch result"), nil
 		},
 	)
 
@@ -228,16 +259,12 @@ func TestQueueDrainOrdering(t *testing.T) {
 	}
 
 	mu.Lock()
-	got := order
+	got := receivedPrompt
 	mu.Unlock()
 
-	if len(got) != 3 {
-		t.Fatalf("expected 3 calls, got %d: %v", len(got), got)
-	}
-	for i, want := range []string{"first", "second", "third"} {
-		if got[i] != want {
-			t.Fatalf("call[%d]: expected %q, got %q", i, want, got[i])
-		}
+	// With batching, all 3 prompts should be processed in a single call
+	if got != "batched" {
+		t.Fatalf("expected batched processing, got %q", got)
 	}
 }
 
@@ -505,3 +532,133 @@ func TestQueueLength_reflects(t *testing.T) {
 		t.Fatalf("expected 3, got %d", got)
 	}
 }
+
+// TestRecordStepUsage_updatesTracker verifies that per-step usage updates are
+// recorded immediately for cost tracking. Context tokens are NOT updated here
+// (only via updateUsageFromTurnResult) to avoid display jumps during multi-step
+// tool calls.
+func TestRecordStepUsage_updatesTracker(t *testing.T) {
+	usage := &usageUpdaterStub{}
+	app := New(Options{UsageTracker: usage}, nil)
+	defer app.Close()
+
+	app.recordStepUsage(kit.StepUsageEvent{
+		InputTokens:      120,
+		OutputTokens:     45,
+		CacheReadTokens:  5,
+		CacheWriteTokens: 2,
+	}, nil)
+
+	usage.mu.Lock()
+	defer usage.mu.Unlock()
+
+	if usage.updateCalls != 1 {
+		t.Fatalf("expected 1 update call, got %d", usage.updateCalls)
+	}
+	if usage.lastUpdateInput != 120 || usage.lastUpdateOutput != 45 || usage.lastUpdateCacheRead != 5 || usage.lastUpdateCacheWrite != 2 {
+		t.Fatalf("unexpected usage update payload: in=%d out=%d cache_read=%d cache_write=%d",
+			usage.lastUpdateInput, usage.lastUpdateOutput, usage.lastUpdateCacheRead, usage.lastUpdateCacheWrite)
+	}
+	// Context tokens should NOT be updated by recordStepUsage (only by updateUsageFromTurnResult)
+	if usage.contextCalls != 0 {
+		t.Fatalf("expected 0 context token updates from recordStepUsage, got %d", usage.contextCalls)
+	}
+}
+
+// TestUpdateUsageFromTurnResult_skipsTotalsWhenStepUsageSeen ensures we avoid
+// double-counting totals once StepUsageEvent-based updates were already applied.
+func TestUpdateUsageFromTurnResult_skipsTotalsWhenStepUsageSeen(t *testing.T) {
+	usage := &usageUpdaterStub{}
+	app := New(Options{UsageTracker: usage}, nil)
+	defer app.Close()
+
+	app.updateUsageFromTurnResult(&kit.TurnResult{
+		Response: "ok",
+		TotalUsage: &fantasy.Usage{
+			InputTokens:         999,
+			OutputTokens:        111,
+			CacheReadTokens:     7,
+			CacheCreationTokens: 3,
+		},
+		FinalUsage: &fantasy.Usage{InputTokens: 456},
+	}, "prompt", true)
+
+	usage.mu.Lock()
+	defer usage.mu.Unlock()
+
+	if usage.updateCalls != 0 {
+		t.Fatalf("expected no total usage update when sawStepUsage=true, got %d", usage.updateCalls)
+	}
+	if usage.estimateCalls != 0 {
+		t.Fatalf("expected no estimate update when sawStepUsage=true, got %d", usage.estimateCalls)
+	}
+	// Context tokens should be InputTokens only (456)
+	if usage.contextCalls != 1 || usage.lastContextTokens != 456 {
+		t.Fatalf("expected final context tokens=456 (InputTokens only), got calls=%d tokens=%d", usage.contextCalls, usage.lastContextTokens)
+	}
+}
+
+// TestUpdateUsageFromTurnResult_recordsWhenInputTokensZero verifies that usage
+// is recorded when InputTokens=0 but OutputTokens>0 (OpenAI-compatible cache behavior).
+func TestUpdateUsageFromTurnResult_recordsWhenInputTokensZero(t *testing.T) {
+	usage := &usageUpdaterStub{}
+	app := New(Options{UsageTracker: usage}, nil)
+	defer app.Close()
+
+	// Simulate OpenAI-compatible behavior: all prompt tokens cached, InputTokens=0
+	app.updateUsageFromTurnResult(&kit.TurnResult{
+		Response: "ok",
+		TotalUsage: &fantasy.Usage{
+			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},
+	}, "prompt", false)
+
+	usage.mu.Lock()
+	defer usage.mu.Unlock()
+
+	if usage.updateCalls != 1 {
+		t.Fatalf("expected 1 update call when InputTokens=0 but OutputTokens>0, got %d", usage.updateCalls)
+	}
+	if usage.lastUpdateInput != 0 || usage.lastUpdateOutput != 150 {
+		t.Fatalf("expected input=0 output=150, got input=%d output=%d",
+			usage.lastUpdateInput, usage.lastUpdateOutput)
+	}
+	if usage.lastUpdateCacheRead != 500 {
+		t.Fatalf("expected cache_read=500, got %d", usage.lastUpdateCacheRead)
+	}
+}
+
+// TestUpdateUsageFromTurnResult_contextTokensUsesInputOnly verifies that context
+// window fill uses InputTokens only (not input+output). The API's InputTokens
+// already includes the full conversation history; adding output would double-count.
+func TestUpdateUsageFromTurnResult_contextTokensUsesInputOnly(t *testing.T) {
+	usage := &usageUpdaterStub{}
+	app := New(Options{UsageTracker: usage}, nil)
+	defer app.Close()
+
+	app.updateUsageFromTurnResult(&kit.TurnResult{
+		Response: "ok",
+		TotalUsage: &fantasy.Usage{
+			InputTokens:  1000,
+			OutputTokens: 200,
+		},
+		FinalUsage: &fantasy.Usage{
+			InputTokens:  1000, // Full context including history
+			OutputTokens: 200,
+		},
+	}, "prompt", false)
+
+	usage.mu.Lock()
+	defer usage.mu.Unlock()
+
+	// Context tokens should be InputTokens only (1000), not input+output (1200)
+	// because InputTokens already includes the full conversation history
+	if usage.contextCalls != 1 || usage.lastContextTokens != 1000 {
+		t.Fatalf("expected context tokens=1000 (InputTokens only), got calls=%d tokens=%d",
+			usage.contextCalls, usage.lastContextTokens)
+	}
+}

internal/app/events.go

@@ -54,6 +54,19 @@ type ToolResultEvent struct {
 	IsError bool
 }
 
+// ToolOutputEvent is sent when a tool produces streaming output chunks (e.g., bash output).
+// This allows the TUI to display tool output as it arrives, before the tool completes.
+type ToolOutputEvent struct {
+	// ToolCallID is the stable identifier for the tool call producing output.
+	ToolCallID string
+	// ToolName is the name of the tool producing output.
+	ToolName string
+	// Chunk is a piece of the tool's output text.
+	Chunk string
+	// IsStderr indicates whether this chunk came from stderr.
+	IsStderr bool
+}
+
 // ToolCallContentEvent is sent when a step includes text content alongside tool calls.
 // This allows the TUI to display assistant commentary that accompanies tool usage.
 type ToolCallContentEvent struct {
@@ -128,6 +141,12 @@ type CompactErrorEvent struct {
 	Err error
 }
 
+// SteerConsumedEvent is sent when one or more steering messages have been
+// consumed — either injected mid-turn via PrepareStep, or drained into the
+// queue after a turn completes. The TUI uses this to clear the steering
+// badge from the display.
+type SteerConsumedEvent struct{}
+
 // ModelChangedEvent is sent when an extension changes the active model via
 // ctx.SetModel. The TUI updates the model name shown in the status bar and
 // message attribution.

internal/auth/credentials.go

@@ -10,9 +10,10 @@ import (
 )
 
 // CredentialStore holds all stored credentials for various providers.
-// Currently supports Anthropic credentials with both OAuth and API key authentication methods.
+// Currently supports Anthropic and OpenAI credentials with both OAuth and API key authentication methods.
 type CredentialStore struct {
 	Anthropic *AnthropicCredentials `json:"anthropic,omitempty"`
+	OpenAI    *OpenAICredentials    `json:"openai,omitempty"`
 }
 
 // AnthropicCredentials holds Anthropic API credentials supporting both OAuth
@@ -28,13 +29,44 @@ type AnthropicCredentials struct {
 	CreatedAt    time.Time `json:"created_at"`
 }
 
+// OpenAICredentials holds OpenAI API credentials supporting both OAuth
+// and API key authentication methods. The Type field indicates which authentication
+// method is being used. For OAuth, tokens are stored with expiration timestamps
+// for automatic refresh. For API keys, only the key itself is stored.
+type OpenAICredentials struct {
+	Type         string    `json:"type"`                    // "oauth" or "api_key"
+	APIKey       string    `json:"api_key,omitempty"`       // For API key auth
+	AccessToken  string    `json:"access_token,omitempty"`  // For OAuth
+	RefreshToken string    `json:"refresh_token,omitempty"` // For OAuth
+	ExpiresAt    int64     `json:"expires_at,omitempty"`    // For OAuth
+	AccountID    string    `json:"account_id,omitempty"`    // For OAuth (ChatGPT account ID)
+	CreatedAt    time.Time `json:"created_at"`
+}
+
+// oauthTokenExpired reports whether an OAuth token with the given type and
+// expiry unix timestamp is past its expiry. Returns false for API key
+// credentials or when no expiry is set.
+func oauthTokenExpired(credType string, expiresAt int64) bool {
+	if credType != "oauth" || expiresAt == 0 {
+		return false
+	}
+	return time.Now().Unix() >= expiresAt
+}
+
+// oauthTokenNeedsRefresh reports whether an OAuth token will expire within the
+// next 5 minutes, allowing proactive refresh before it becomes invalid.
+// Returns false for API key credentials or when no expiry is set.
+func oauthTokenNeedsRefresh(credType string, expiresAt int64) bool {
+	if credType != "oauth" || expiresAt == 0 {
+		return false
+	}
+	return time.Now().Unix() >= (expiresAt - 300) // 5 minutes buffer
+}
+
 // IsExpired checks if the OAuth token is expired based on the ExpiresAt timestamp.
 // Returns false for API key authentication or if no expiration is set.
 func (c *AnthropicCredentials) IsExpired() bool {
-	if c.Type != "oauth" || c.ExpiresAt == 0 {
-		return false
-	}
-	return time.Now().Unix() >= c.ExpiresAt
+	return oauthTokenExpired(c.Type, c.ExpiresAt)
 }
 
 // NeedsRefresh checks if the OAuth token needs refresh, returning true if the token
@@ -42,10 +74,21 @@ func (c *AnthropicCredentials) IsExpired() bool {
 // to avoid authentication failures during operations. Returns false for API key
 // authentication or if no expiration is set.
 func (c *AnthropicCredentials) NeedsRefresh() bool {
-	if c.Type != "oauth" || c.ExpiresAt == 0 {
-		return false
-	}
-	return time.Now().Unix() >= (c.ExpiresAt - 300) // 5 minutes buffer
+	return oauthTokenNeedsRefresh(c.Type, c.ExpiresAt)
+}
+
+// IsExpired checks if the OAuth token is expired based on the ExpiresAt timestamp.
+// Returns false for API key authentication or if no expiration is set.
+func (c *OpenAICredentials) IsExpired() bool {
+	return oauthTokenExpired(c.Type, c.ExpiresAt)
+}
+
+// NeedsRefresh checks if the OAuth token needs refresh, returning true if the token
+// will expire within the next 5 minutes. This allows for proactive token refresh
+// to avoid authentication failures during operations. Returns false for API key
+// authentication or if no expiration is set.
+func (c *OpenAICredentials) NeedsRefresh() bool {
+	return oauthTokenNeedsRefresh(c.Type, c.ExpiresAt)
 }
 
 // CredentialManager handles secure storage and retrieval of authentication credentials.
@@ -212,6 +255,142 @@ func (cm *CredentialManager) HasAnthropicCredentials() (bool, error) {
 	}
 }
 
+// SetOpenAICredentials stores OpenAI API key credentials. It validates the
+// API key format before storing. The API key must start with "sk-" and be
+// at least 20 characters long. Returns an error if the API key is invalid or
+// if storage fails.
+func (cm *CredentialManager) SetOpenAICredentials(apiKey string) error {
+	if err := validateOpenAIAPIKey(apiKey); err != nil {
+		return err
+	}
+
+	store, err := cm.LoadCredentials()
+	if err != nil {
+		return err
+	}
+
+	store.OpenAI = &OpenAICredentials{
+		Type:      "api_key",
+		APIKey:    apiKey,
+		CreatedAt: time.Now(),
+	}
+
+	return cm.SaveCredentials(store)
+}
+
+// GetOpenAICredentials retrieves stored OpenAI credentials. Returns nil if
+// no credentials are stored. The returned credentials may be either OAuth or API
+// key type, check the Type field to determine which.
+func (cm *CredentialManager) GetOpenAICredentials() (*OpenAICredentials, error) {
+	store, err := cm.LoadCredentials()
+	if err != nil {
+		return nil, err
+	}
+
+	return store.OpenAI, nil
+}
+
+// RemoveOpenAICredentials removes stored OpenAI credentials from storage.
+// If this was the only credential stored, the entire credentials file is removed.
+// Returns an error if the removal fails.
+func (cm *CredentialManager) RemoveOpenAICredentials() error {
+	store, err := cm.LoadCredentials()
+	if err != nil {
+		return err
+	}
+
+	store.OpenAI = nil
+
+	// If store is empty, remove the file entirely
+	if store.Anthropic == nil && store.OpenAI == nil {
+		if err := os.Remove(cm.credentialsPath); err != nil && !os.IsNotExist(err) {
+			return fmt.Errorf("failed to remove credentials file: %w", err)
+		}
+		return nil
+	}
+
+	return cm.SaveCredentials(store)
+}
+
+// HasOpenAICredentials checks if valid OpenAI credentials are stored.
+// Returns true if either a non-empty OAuth access token or API key is present,
+// false otherwise. Returns an error if credentials cannot be loaded.
+func (cm *CredentialManager) HasOpenAICredentials() (bool, error) {
+	creds, err := cm.GetOpenAICredentials()
+	if err != nil {
+		return false, err
+	}
+	if creds == nil {
+		return false, nil
+	}
+
+	// Check based on credential type
+	switch creds.Type {
+	case "oauth":
+		return creds.AccessToken != "", nil
+	case "api_key":
+		return creds.APIKey != "", nil
+	default:
+		return false, nil
+	}
+}
+
+// SetOpenAIOAuthCredentials stores OpenAI OAuth credentials in the credential manager's secure storage.
+// The credentials should include access token, refresh token, and expiration information.
+// Returns an error if the credentials cannot be saved.
+func (cm *CredentialManager) SetOpenAIOAuthCredentials(creds *OpenAICredentials) error {
+	store, err := cm.LoadCredentials()
+	if err != nil {
+		return err
+	}
+
+	store.OpenAI = creds
+	return cm.SaveCredentials(store)
+}
+
+// GetValidOpenAIAccessToken returns a valid access token for API requests. For OAuth credentials,
+// it automatically refreshes the token if it's expired or about to expire. For API key
+// credentials, it simply returns the API key. Returns an error if no credentials are found,
+// if token refresh fails, or if the credential type is unknown.
+func (cm *CredentialManager) GetValidOpenAIAccessToken() (string, error) {
+	creds, err := cm.GetOpenAICredentials()
+	if err != nil {
+		return "", err
+	}
+
+	if creds == nil {
+		return "", fmt.Errorf("no credentials found")
+	}
+
+	// For API key auth, return the API key
+	if creds.Type == "api_key" {
+		return creds.APIKey, nil
+	}
+
+	// For OAuth, check if token needs refresh
+	if creds.Type == "oauth" {
+		if creds.NeedsRefresh() {
+			// Refresh the token
+			client := NewOpenAIOAuthClient()
+			newCreds, err := client.RefreshToken(creds.RefreshToken)
+			if err != nil {
+				return "", fmt.Errorf("failed to refresh token: %w", err)
+			}
+
+			// Update stored credentials
+			if err := cm.SetOpenAIOAuthCredentials(newCreds); err != nil {
+				return "", fmt.Errorf("failed to save refreshed token: %w", err)
+			}
+
+			return newCreds.AccessToken, nil
+		}
+
+		return creds.AccessToken, nil
+	}
+
+	return "", fmt.Errorf("unknown credential type: %s", creds.Type)
+}
+
 // GetCredentialsPath returns the absolute path to the credentials JSON file.
 // This is useful for debugging or displaying the storage location to users.
 func (cm *CredentialManager) GetCredentialsPath() string {
@@ -238,6 +417,26 @@ func validateAnthropicAPIKey(apiKey string) error {
 	return nil
 }
 
+// validateOpenAIAPIKey validates the format of an OpenAI API key
+func validateOpenAIAPIKey(apiKey string) error {
+	apiKey = strings.TrimSpace(apiKey)
+
+	if apiKey == "" {
+		return fmt.Errorf("API key cannot be empty")
+	}
+
+	// OpenAI API keys typically start with "sk-" and are quite long
+	if !strings.HasPrefix(apiKey, "sk-") {
+		return fmt.Errorf("invalid OpenAI API key format (should start with 'sk-')")
+	}
+
+	if len(apiKey) < 20 {
+		return fmt.Errorf("API key appears to be too short")
+	}
+
+	return nil
+}
+
 // GetAnthropicAPIKey retrieves an Anthropic API key from multiple sources in priority order:
 // 1. Command-line flag value (highest priority)
 // 2. Stored credentials (OAuth or API key)

internal/auth/oauth.go

@@ -7,6 +7,7 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"net/url"
 	"strings"
@@ -30,6 +31,7 @@ type OAuthClient struct {
 type AuthData struct {
 	URL      string
 	Verifier string
+	State    string // Optional state parameter for CSRF protection
 }
 
 // NewOAuthClient creates a new OAuth client configured for Anthropic's OAuth service.
@@ -49,12 +51,12 @@ func NewOAuthClient() *OAuthClient {
 	}
 }
 
-// GeneratePKCE generates a cryptographically secure PKCE verifier and challenge pair
+// generatePKCE generates a cryptographically secure PKCE verifier and challenge pair
 // for the OAuth 2.0 PKCE flow. The verifier is a random 32-byte string encoded as
 // base64url, and the challenge is the SHA256 hash of the verifier, also base64url encoded.
 // Returns the verifier (to be stored securely), challenge (to be sent with auth request),
 // and any error encountered during generation.
-func GeneratePKCE() (verifier, challenge string, err error) {
+func generatePKCE() (verifier, challenge string, err error) {
 	// Generate 32 bytes of random data
 	verifierBytes := make([]byte, 32)
 	if _, err := rand.Read(verifierBytes); err != nil {
@@ -76,7 +78,7 @@ func GeneratePKCE() (verifier, challenge string, err error) {
 // and PKCE challenge. Returns an AuthData structure containing the URL for user
 // authentication and the PKCE verifier for the subsequent code exchange.
 func (c *OAuthClient) GetAuthorizationURL() (*AuthData, error) {
-	verifier, challenge, err := GeneratePKCE()
+	verifier, challenge, err := generatePKCE()
 	if err != nil {
 		return nil, fmt.Errorf("failed to generate PKCE: %w", err)
 	}
@@ -199,6 +201,270 @@ func (c *OAuthClient) parseCodeAndState(code string) (parsedCode, parsedState st
 	return
 }
 
+// OpenAIOAuthClient handles OAuth 2.0 authentication flow with OpenAI Codex (ChatGPT Plus/Pro).
+// This uses OpenAI's auth0-based OAuth service for ChatGPT account authentication.
+type OpenAIOAuthClient struct {
+	ClientID     string
+	AuthorizeURL string
+	TokenURL     string
+	RedirectURI  string
+	Scopes       string
+}
+
+// NewOpenAIOAuthClient creates a new OAuth client configured for OpenAI Codex OAuth.
+// This uses the public client ID for CLI applications with PKCE for security.
+func NewOpenAIOAuthClient() *OpenAIOAuthClient {
+	return &OpenAIOAuthClient{
+		// Public client ID for OpenAI Codex CLI OAuth
+		ClientID:     "app_EMoamEEZ73f0CkXaXp7hrann",
+		AuthorizeURL: "https://auth.openai.com/oauth/authorize",
+		TokenURL:     "https://auth.openai.com/oauth/token",
+		RedirectURI:  "http://localhost:1455/auth/callback",
+		Scopes:       "openid profile email offline_access",
+	}
+}
+
+// GetAuthorizationURL generates a complete authorization URL for the OAuth flow with
+// PKCE parameters. Returns an AuthData structure containing the URL for user
+// authentication and the PKCE verifier for the subsequent code exchange.
+func (c *OpenAIOAuthClient) GetAuthorizationURL() (*AuthData, error) {
+	verifier, challenge, err := generatePKCE()
+	if err != nil {
+		return nil, fmt.Errorf("failed to generate PKCE: %w", err)
+	}
+
+	// Generate random state
+	stateBytes := make([]byte, 16)
+	if _, err := rand.Read(stateBytes); err != nil {
+		return nil, fmt.Errorf("failed to generate state: %w", err)
+	}
+	state := fmt.Sprintf("%x", stateBytes)
+
+	params := url.Values{
+		"response_type":              {"code"},
+		"client_id":                  {c.ClientID},
+		"redirect_uri":               {c.RedirectURI},
+		"scope":                      {c.Scopes},
+		"code_challenge":             {challenge},
+		"code_challenge_method":      {"S256"},
+		"state":                      {state},
+		"id_token_add_organizations": {"true"},
+		"codex_cli_simplified_flow":  {"true"},
+		"originator":                 {"kit"},
+	}
+
+	authURL := fmt.Sprintf("%s?%s", c.AuthorizeURL, params.Encode())
+
+	return &AuthData{
+		URL:      authURL,
+		Verifier: verifier,
+		State:    state,
+	}, nil
+}
+
+// ExchangeCode exchanges an authorization code for access and refresh tokens.
+// The code parameter should be the authorization code received from the OAuth callback.
+// The verifier parameter must be the same PKCE verifier generated during GetAuthorizationURL.
+// Returns OpenAICredentials containing the tokens, expiration, and account ID.
+func (c *OpenAIOAuthClient) ExchangeCode(code, verifier string) (*OpenAICredentials, error) {
+	return c.exchangeAuthorizationCode(code, verifier, c.RedirectURI)
+}
+
+// exchangeAuthorizationCode performs the token exchange with the OAuth server
+func (c *OpenAIOAuthClient) exchangeAuthorizationCode(code, verifier, redirectUri string) (*OpenAICredentials, error) {
+	data := url.Values{
+		"grant_type":    {"authorization_code"},
+		"client_id":     {c.ClientID},
+		"code":          {code},
+		"code_verifier": {verifier},
+		"redirect_uri":  {redirectUri},
+	}
+
+	req, err := http.NewRequestWithContext(context.Background(), "POST", c.TokenURL, strings.NewReader(data.Encode()))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to make token request: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("token exchange failed: %s", string(body))
+	}
+
+	var tokenResp struct {
+		AccessToken  string `json:"access_token"`
+		RefreshToken string `json:"refresh_token"`
+		ExpiresIn    int    `json:"expires_in"`
+		IDToken      string `json:"id_token"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {
+		return nil, fmt.Errorf("failed to decode token response: %w", err)
+	}
+
+	if tokenResp.AccessToken == "" || tokenResp.RefreshToken == "" {
+		return nil, fmt.Errorf("token response missing required fields")
+	}
+
+	// Extract account ID from JWT token
+	accountID := extractOpenAIAccountID(tokenResp.AccessToken)
+	if accountID == "" {
+		return nil, fmt.Errorf("failed to extract account ID from token")
+	}
+
+	return &OpenAICredentials{
+		Type:         "oauth",
+		AccessToken:  tokenResp.AccessToken,
+		RefreshToken: tokenResp.RefreshToken,
+		ExpiresAt:    time.Now().Unix() + int64(tokenResp.ExpiresIn),
+		CreatedAt:    time.Now(),
+		AccountID:    accountID,
+	}, nil
+}
+
+// RefreshToken refreshes an expired or expiring access token using a refresh token.
+// Returns new OpenAICredentials with updated access token, refresh token (may be
+// rotated), and new expiration timestamp. Returns an error if the refresh fails or
+// the refresh token is invalid.
+func (c *OpenAIOAuthClient) RefreshToken(refreshToken string) (*OpenAICredentials, error) {
+	data := url.Values{
+		"grant_type":    {"refresh_token"},
+		"refresh_token": {refreshToken},
+		"client_id":     {c.ClientID},
+	}
+
+	req, err := http.NewRequestWithContext(context.Background(), "POST", c.TokenURL, strings.NewReader(data.Encode()))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to make refresh request: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("token refresh failed: %s", string(body))
+	}
+
+	var tokenResp struct {
+		AccessToken  string `json:"access_token"`
+		RefreshToken string `json:"refresh_token"`
+		ExpiresIn    int    `json:"expires_in"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {
+		return nil, fmt.Errorf("failed to decode refresh response: %w", err)
+	}
+
+	if tokenResp.AccessToken == "" || tokenResp.RefreshToken == "" {
+		return nil, fmt.Errorf("refresh response missing required fields")
+	}
+
+	// Extract account ID from JWT token
+	accountID := extractOpenAIAccountID(tokenResp.AccessToken)
+	if accountID == "" {
+		return nil, fmt.Errorf("failed to extract account ID from refreshed token")
+	}
+
+	return &OpenAICredentials{
+		Type:         "oauth",
+		AccessToken:  tokenResp.AccessToken,
+		RefreshToken: tokenResp.RefreshToken,
+		ExpiresAt:    time.Now().Unix() + int64(tokenResp.ExpiresIn),
+		CreatedAt:    time.Now(),
+		AccountID:    accountID,
+	}, nil
+}
+
+// extractOpenAIAccountID extracts the ChatGPT account ID from a JWT access token.
+// The account ID is stored in the claim path https://api.openai.com/auth.chatgpt_account_id
+func extractOpenAIAccountID(token string) string {
+	// JWT tokens are base64-encoded JSON payloads
+	parts := strings.Split(token, ".")
+	if len(parts) != 3 {
+		return ""
+	}
+
+	// Decode payload (second part)
+	payload := parts[1]
+	// Add padding if needed
+	if len(payload)%4 != 0 {
+		payload += strings.Repeat("=", 4-len(payload)%4)
+	}
+
+	decoded, err := base64.URLEncoding.DecodeString(payload)
+	if err != nil {
+		return ""
+	}
+
+	var claims map[string]any
+	if err := json.Unmarshal(decoded, &claims); err != nil {
+		return ""
+	}
+
+	// Navigate to the claim path: https://api.openai.com/auth.chatgpt_account_id
+	authPath, ok := claims["https://api.openai.com/auth"].(map[string]any)
+	if !ok {
+		return ""
+	}
+
+	accountID, ok := authPath["chatgpt_account_id"].(string)
+	if !ok {
+		return ""
+	}
+
+	return accountID
+}
+
+// ParseOpenAIAuthorizationInput parses various forms of authorization input:
+// - Full callback URL: http://localhost:1455/auth/callback?code=xxx&state=yyy
+// - Code#State format: abc123#state456
+// - Query string: code=abc123&state=state456
+// - Just the code: abc123
+func ParseOpenAIAuthorizationInput(input string) (code, state string) {
+	input = strings.TrimSpace(input)
+	if input == "" {
+		return "", ""
+	}
+
+	// Try parsing as URL
+	if strings.HasPrefix(input, "http") {
+		if u, err := url.Parse(input); err == nil {
+			return u.Query().Get("code"), u.Query().Get("state")
+		}
+	}
+
+	// Try code#state format
+	if strings.Contains(input, "#") {
+		parts := strings.SplitN(input, "#", 2)
+		return parts[0], parts[1]
+	}
+
+	// Try query string format
+	if strings.Contains(input, "code=") {
+		if values, err := url.ParseQuery(input); err == nil {
+			return values.Get("code"), values.Get("state")
+		}
+	}
+
+	// Assume it's just the code
+	return input, ""
+}
+
 // SetOAuthCredentials stores OAuth credentials in the credential manager's secure storage.
 // The credentials should include access token, refresh token, and expiration information.
 // Returns an error if the credentials cannot be saved.

internal/clipboard/clipboard.go

@@ -71,5 +71,5 @@ func DetectMediaType(data []byte) string {
 // ErrNoImage is returned when the clipboard does not contain image data.
 var ErrNoImage = fmt.Errorf("no image data on clipboard")
 
-// ErrNoClipboardTool is returned when no suitable clipboard tool is found.
-var ErrNoClipboardTool = fmt.Errorf("no clipboard tool available (install xclip, wl-paste, or use macOS)")
+// errNoClipboardTool is returned when no suitable clipboard tool is found.
+var errNoClipboardTool = fmt.Errorf("no clipboard tool available (install xclip, wl-paste, or use macOS)")

internal/clipboard/clipboard_darwin.go

@@ -7,9 +7,8 @@ import (
 )
 
 // ReadImage reads image data from the system clipboard on macOS.
-// It uses osascript to check if the clipboard contains an image and then
-// reads the data using a temporary approach. If the clipboard contains
-// an image, it writes it to stdout as PNG data.
+// It uses osascript to check if the clipboard contains an image via
+// NSPasteboard and writes it to stdout as PNG data.
 func ReadImage() (*ImageData, error) {
 	// Use osascript to write clipboard image to stdout via a pipe.
 	// The script checks if the clipboard has a «class PNGf» item.

internal/clipboard/clipboard_linux.go

@@ -41,7 +41,7 @@ func ReadImage() (*ImageData, error) {
 		return nil, ErrNoImage
 	}
 
-	return nil, ErrNoClipboardTool
+	return nil, errNoClipboardTool
 }
 
 // readWithXclip reads image data using xclip.

internal/clipboard/clipboard_windows.go

@@ -5,5 +5,5 @@ package clipboard
 // ReadImage reads image data from the system clipboard on Windows.
 // Windows clipboard image support is not yet implemented.
 func ReadImage() (*ImageData, error) {
-	return nil, ErrNoClipboardTool
+	return nil, errNoClipboardTool
 }

internal/compaction/compaction.go

@@ -5,10 +5,18 @@
 // messages (KeepRecentTokens, default 20 000) rather than a fixed message
 // count. Auto-compaction fires when estimated context usage exceeds
 // contextWindow − ReserveTokens.
+//
+// Features modelled after pi's compaction system:
+//   - Tool result truncation (2000 char max) during serialisation
+//   - Split turn handling: when a single turn exceeds the keep budget,
+//     the turn prefix is summarised separately and merged
+//   - Cumulative file tracking: read and modified files extracted from
+//     tool calls and carried forward across compactions
 package compaction
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"strings"
 
@@ -19,8 +27,8 @@ import (
 // Token estimation
 // ---------------------------------------------------------------------------
 
-// EstimateTokens provides a rough token count (~4 chars per token).
-func EstimateTokens(text string) int {
+// estimateTokens provides a rough token count (~4 chars per token).
+func estimateTokens(text string) int {
 	return len(text) / 4
 }
 
@@ -40,7 +48,7 @@ func estimateSingleMessageTokens(msg fantasy.Message) int {
 	total := 0
 	for _, part := range msg.Content {
 		if tp, ok := part.(fantasy.TextPart); ok {
-			total += EstimateTokens(tp.Text)
+			total += estimateTokens(tp.Text)
 		}
 	}
 	return total
@@ -66,10 +74,13 @@ func ShouldCompact(messages []fantasy.Message, contextWindow int, reserveTokens
 
 // CompactionResult contains statistics from a compaction operation.
 type CompactionResult struct {
-	Summary         string // LLM-generated summary of compacted messages
-	OriginalTokens  int    // Estimated token count before compaction
-	CompactedTokens int    // Estimated token count after compaction
-	MessagesRemoved int    // Number of messages replaced by the summary
+	Summary         string   // LLM-generated summary of compacted messages
+	OriginalTokens  int      // Estimated token count before compaction
+	CompactedTokens int      // Estimated token count after compaction
+	MessagesRemoved int      // Number of messages replaced by the summary
+	CutPoint        int      // Index in the original messages where the cut was made
+	ReadFiles       []string // Files read during the compacted conversation
+	ModifiedFiles   []string // Files modified during the compacted conversation
 }
 
 // CompactionOptions configures compaction behaviour. Token-based defaults
@@ -130,8 +141,34 @@ Use this EXACT format:
 - [Any data, examples, or references needed to continue]
 - [Or "(none)" if not applicable]
 
+<read-files>
+[One file path per line for files that were read during the conversation]
+</read-files>
+
+<modified-files>
+[One file path per line for files that were created, edited, or written during the conversation]
+</modified-files>
+
 Keep each section concise. Preserve exact file paths, function names, and error messages.`
 
+// ---------------------------------------------------------------------------
+// Tool result truncation
+// ---------------------------------------------------------------------------
+
+// maxToolResultChars is the maximum length of tool result text preserved
+// during serialisation. Longer results are truncated with a marker.
+const maxToolResultChars = 2000
+
+// truncateToolResult truncates text to maxToolResultChars, appending a
+// marker indicating how many characters were removed.
+func truncateToolResult(text string) string {
+	if len(text) <= maxToolResultChars {
+		return text
+	}
+	truncated := len(text) - maxToolResultChars
+	return text[:maxToolResultChars] + fmt.Sprintf("\n[...%d chars truncated]", truncated)
+}
+
 // ---------------------------------------------------------------------------
 // Cut point (token-based)
 // ---------------------------------------------------------------------------
@@ -143,11 +180,26 @@ func isValidCutPoint(msg fantasy.Message) bool {
 	return msg.Role != fantasy.MessageRoleTool
 }
 
+// findTurnStart returns the index of the user message that starts the turn
+// containing messages[idx]. A "turn" starts with a user message and includes
+// all subsequent assistant/tool messages until the next user message.
+func findTurnStart(messages []fantasy.Message, idx int) int {
+	for i := idx; i >= 0; i-- {
+		if messages[i].Role == fantasy.MessageRoleUser {
+			return i
+		}
+	}
+	return 0
+}
+
 // FindCutPoint walks backward from the end of messages, accumulating tokens
 // until the keepRecentTokens budget is filled. Returns the index that
 // separates "old" messages (0..cutPoint-1, to be summarised) from "recent"
 // messages (cutPoint..end, to be preserved).
 //
+// The cut point prefers turn boundaries (user messages). When a single turn
+// exceeds the budget, the cut lands mid-turn (IsSplitTurn returns true).
+//
 // Returns 0 if there are fewer than 2 messages or all messages fit within
 // the keep budget.
 func FindCutPoint(messages []fantasy.Message, keepRecentTokens int) int {
@@ -193,6 +245,23 @@ func FindCutPoint(messages []fantasy.Message, keepRecentTokens int) int {
 	return 0
 }
 
+// IsSplitTurn returns true if the cut point lands in the middle of a turn
+// (i.e. the message at cutPoint is not a user message, meaning we're
+// splitting a single turn's assistant/tool messages).
+func IsSplitTurn(messages []fantasy.Message, cutPoint int) bool {
+	if cutPoint <= 0 || cutPoint >= len(messages) {
+		return false
+	}
+	// If the cut point is at a user message, it's a clean turn boundary.
+	if messages[cutPoint].Role == fantasy.MessageRoleUser {
+		return false
+	}
+	// Otherwise we're cutting mid-turn — check if the turn started before
+	// the cut point.
+	turnStart := findTurnStart(messages, cutPoint)
+	return turnStart < cutPoint
+}
+
 // forceCutPoint returns a cut point that keeps only the last non-tool
 // message, summarising everything before it. Used when the budget-based
 // FindCutPoint returns 0 but the caller wants to compact anyway (manual
@@ -207,12 +276,104 @@ func forceCutPoint(messages []fantasy.Message) int {
 	return 0
 }
 
+// ---------------------------------------------------------------------------
+// File tracking
+// ---------------------------------------------------------------------------
+
+// fileOps contains cumulative file operation tracking.
+type fileOps struct {
+	ReadFiles     map[string]bool
+	ModifiedFiles map[string]bool
+}
+
+func newFileOps() *fileOps {
+	return &fileOps{
+		ReadFiles:     make(map[string]bool),
+		ModifiedFiles: make(map[string]bool),
+	}
+}
+
+// extractFileOps scans messages for tool calls and extracts file paths.
+// It recognises the built-in Kit tools: read, write, edit, bash, grep, find, ls.
+func extractFileOps(messages []fantasy.Message) *fileOps {
+	ops := newFileOps()
+	for _, msg := range messages {
+		for _, part := range msg.Content {
+			tc, ok := part.(fantasy.ToolCallPart)
+			if !ok {
+				continue
+			}
+
+			// Parse the JSON input to extract path arguments.
+			var args map[string]any
+			if err := json.Unmarshal([]byte(tc.Input), &args); err != nil {
+				continue
+			}
+
+			path, _ := args["path"].(string)
+			if path == "" {
+				continue
+			}
+
+			switch tc.ToolName {
+			case "read", "grep", "find", "ls":
+				ops.ReadFiles[path] = true
+			case "write", "edit":
+				ops.ModifiedFiles[path] = true
+			}
+		}
+	}
+	return ops
+}
+
+// merge combines another fileOps into this one (for cumulative tracking).
+func (f *fileOps) merge(other *fileOps) {
+	if other == nil {
+		return
+	}
+	for k := range other.ReadFiles {
+		f.ReadFiles[k] = true
+	}
+	for k := range other.ModifiedFiles {
+		f.ModifiedFiles[k] = true
+	}
+}
+
+// mergeSlices adds previously tracked file lists (from a prior compaction).
+func (f *fileOps) mergeSlices(readFiles, modifiedFiles []string) {
+	for _, p := range readFiles {
+		f.ReadFiles[p] = true
+	}
+	for _, p := range modifiedFiles {
+		f.ModifiedFiles[p] = true
+	}
+}
+
+// sortedKeys returns the keys of a bool map sorted alphabetically.
+func sortedKeys(m map[string]bool) []string {
+	if len(m) == 0 {
+		return nil
+	}
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	// Simple sort — no need for sort package for small lists.
+	for i := 0; i < len(keys); i++ {
+		for j := i + 1; j < len(keys); j++ {
+			if keys[j] < keys[i] {
+				keys[i], keys[j] = keys[j], keys[i]
+			}
+		}
+	}
+	return keys
+}
+
 // ---------------------------------------------------------------------------
 // Message serialisation
 // ---------------------------------------------------------------------------
 
-// roleLabel returns a human-readable label for a fantasy message role,
-
+// roleLabel returns a human-readable label for a fantasy message role.
 func roleLabel(role fantasy.MessageRole) string {
 	switch role {
 	case fantasy.MessageRoleUser:
@@ -229,16 +390,26 @@ func roleLabel(role fantasy.MessageRole) string {
 }
 
 // serializeMessages converts a slice of fantasy messages into a plain-text
-// representation suitable for sending to the summarisation LLM. The format
-
+// representation suitable for sending to the summarisation LLM. Tool result
+// text is truncated to maxToolResultChars to keep the summarisation request
+// within reasonable token budgets.
 func serializeMessages(messages []fantasy.Message) string {
 	var sb strings.Builder
 	for _, msg := range messages {
 		sb.WriteString(roleLabel(msg.Role))
 		sb.WriteString(":\n")
 		for _, part := range msg.Content {
-			if tp, ok := part.(fantasy.TextPart); ok {
-				sb.WriteString(tp.Text)
+			switch p := part.(type) {
+			case fantasy.TextPart:
+				if msg.Role == fantasy.MessageRoleTool {
+					sb.WriteString(truncateToolResult(p.Text))
+				} else {
+					sb.WriteString(p.Text)
+				}
+			case fantasy.ToolCallPart:
+				fmt.Fprintf(&sb, "[Tool call: %s(%s)]", p.ToolName, truncateToolResult(p.Input))
+			case fantasy.ReasoningPart:
+				fmt.Fprintf(&sb, "[Thinking]: %s", truncateToolResult(p.Text))
 			}
 		}
 		sb.WriteString("\n\n")
@@ -250,6 +421,13 @@ func serializeMessages(messages []fantasy.Message) string {
 // Compact
 // ---------------------------------------------------------------------------
 
+// PreviousCompaction carries file tracking state from a prior compaction so
+// that file operations accumulate across multiple compactions.
+type PreviousCompaction struct {
+	ReadFiles     []string
+	ModifiedFiles []string
+}
+
 // Compact summarises older messages using the LLM, returning the compaction
 // result and a new message slice (summary message + preserved recent
 // messages).
@@ -261,12 +439,16 @@ func serializeMessages(messages []fantasy.Message) string {
 // customInstructions is optional text appended to the summary prompt (e.g.
 // "Focus on the API design decisions"). Pass "" to use the default prompt
 // only.
+//
+// prev carries file tracking from a previous compaction for cumulative
+// tracking. Pass nil if there is no prior compaction.
 func Compact(
 	ctx context.Context,
 	model fantasy.LanguageModel,
 	messages []fantasy.Message,
 	opts CompactionOptions,
 	customInstructions string,
+	prev *PreviousCompaction,
 ) (*CompactionResult, []fantasy.Message, error) {
 	opts.defaults()
 
@@ -289,30 +471,30 @@ func Compact(
 	recentMessages := messages[cutPoint:]
 	originalTokens := EstimateMessageTokens(messages)
 
-	// Serialise old messages to text.
-	conversationText := serializeMessages(oldMessages)
-
-	// Build the user-facing prompt: conversation text + summary instructions.
-	userPrompt := opts.SummaryPrompt
-	if userPrompt == "" {
-		userPrompt = defaultSummaryPrompt
-	}
-	if customInstructions != "" {
-		userPrompt += "\n\nAdditional instructions: " + customInstructions
+	// Extract file operations from old messages.
+	ops := extractFileOps(oldMessages)
+	// Accumulate from previous compaction if present.
+	if prev != nil {
+		ops.mergeSlices(prev.ReadFiles, prev.ModifiedFiles)
 	}
+	// Also scan recent messages for file ops (they'll be carried forward).
+	recentOps := extractFileOps(recentMessages)
+	ops.merge(recentOps)
 
-	// Create a lightweight agent (no tools) just for summarisation.
-	summaryAgent := fantasy.NewAgent(model,
-		fantasy.WithSystemPrompt(defaultSystemPrompt),
-	)
-	result, err := summaryAgent.Generate(ctx, fantasy.AgentCall{
-		Prompt: conversationText + "\n\n" + userPrompt,
-	})
+	// Handle split turns: when the cut lands mid-turn, summarise the turn
+	// prefix separately and merge with the history summary.
+	var summaryText string
+	var err error
+
+	if IsSplitTurn(messages, cutPoint) {
+		summaryText, err = compactSplitTurn(ctx, model, oldMessages, messages, cutPoint, opts, customInstructions)
+	} else {
+		summaryText, err = compactNormal(ctx, model, oldMessages, opts, customInstructions)
+	}
 	if err != nil {
-		return nil, nil, fmt.Errorf("compaction summarisation failed: %w", err)
+		return nil, nil, err
 	}
 
-	summaryText := result.Response.Content.Text()
 	if summaryText == "" {
 		return nil, nil, fmt.Errorf("compaction produced an empty summary")
 	}
@@ -338,5 +520,120 @@ func Compact(
 		OriginalTokens:  originalTokens,
 		CompactedTokens: compactedTokens,
 		MessagesRemoved: len(oldMessages),
+		CutPoint:        cutPoint,
+		ReadFiles:       sortedKeys(ops.ReadFiles),
+		ModifiedFiles:   sortedKeys(ops.ModifiedFiles),
 	}, newMessages, nil
 }
+
+// compactNormal generates a summary for a clean turn-boundary cut.
+func compactNormal(
+	ctx context.Context,
+	model fantasy.LanguageModel,
+	oldMessages []fantasy.Message,
+	opts CompactionOptions,
+	customInstructions string,
+) (string, error) {
+	conversationText := serializeMessages(oldMessages)
+	return generateSummary(ctx, model, conversationText, opts, customInstructions)
+}
+
+// compactSplitTurn handles the case where the cut point lands mid-turn.
+// It generates two summaries and merges them:
+//  1. History summary: all complete turns before the split turn
+//  2. Turn prefix summary: the early part of the split turn (from the turn's
+//     user message up to the cut point)
+//
+// The merged result preserves context from both the older history and the
+// beginning of the current long turn.
+func compactSplitTurn(
+	ctx context.Context,
+	model fantasy.LanguageModel,
+	oldMessages []fantasy.Message,
+	allMessages []fantasy.Message,
+	cutPoint int,
+	opts CompactionOptions,
+	customInstructions string,
+) (string, error) {
+	// Find where the split turn starts.
+	turnStart := findTurnStart(allMessages, cutPoint)
+
+	// Messages before the turn are the "history" portion.
+	historyMessages := oldMessages
+	if turnStart > 0 && turnStart < len(oldMessages) {
+		historyMessages = oldMessages[:turnStart]
+	}
+
+	// The turn prefix: from turnStart to cutPoint.
+	turnPrefixMessages := allMessages[turnStart:cutPoint]
+
+	var historySummary string
+	var err error
+
+	// Generate history summary if there are complete turns before the split.
+	if len(historyMessages) >= 2 {
+		historySummary, err = generateSummary(ctx, model,
+			serializeMessages(historyMessages), opts, "")
+		if err != nil {
+			return "", fmt.Errorf("split turn history summary failed: %w", err)
+		}
+	}
+
+	// Generate turn prefix summary.
+	turnPrefixText := serializeMessages(turnPrefixMessages)
+	turnPrefixPrompt := "The messages above are the BEGINNING of a long turn that was split. " +
+		"Summarize the work done so far in this turn, preserving tool call results, " +
+		"file changes, and progress. Another LLM will continue this turn."
+	if customInstructions != "" {
+		turnPrefixPrompt += "\n\nAdditional instructions: " + customInstructions
+	}
+
+	summaryAgent := fantasy.NewAgent(model,
+		fantasy.WithSystemPrompt(defaultSystemPrompt),
+	)
+	result, err := summaryAgent.Generate(ctx, fantasy.AgentCall{
+		Prompt: turnPrefixText + "\n\n" + turnPrefixPrompt,
+	})
+	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 != "" {
+		return historySummary + "\n\n---\n\n## Current Turn (in progress)\n\n" + turnPrefixSummary, nil
+	}
+	if turnPrefixSummary != "" {
+		return turnPrefixSummary, nil
+	}
+	return historySummary, nil
+}
+
+// generateSummary calls the LLM to produce a structured summary.
+func generateSummary(
+	ctx context.Context,
+	model fantasy.LanguageModel,
+	conversationText string,
+	opts CompactionOptions,
+	customInstructions string,
+) (string, error) {
+	userPrompt := opts.SummaryPrompt
+	if userPrompt == "" {
+		userPrompt = defaultSummaryPrompt
+	}
+	if customInstructions != "" {
+		userPrompt += "\n\nAdditional instructions: " + customInstructions
+	}
+
+	summaryAgent := fantasy.NewAgent(model,
+		fantasy.WithSystemPrompt(defaultSystemPrompt),
+	)
+	result, err := summaryAgent.Generate(ctx, fantasy.AgentCall{
+		Prompt: conversationText + "\n\n" + userPrompt,
+	})
+	if err != nil {
+		return "", fmt.Errorf("compaction summarisation failed: %w", err)
+	}
+
+	return result.Response.Content.Text(), nil
+}

internal/compaction/compaction_test.go

@@ -36,9 +36,9 @@ func TestEstimateTokens(t *testing.T) {
 		{"hello world", 2}, // 11 / 4 = 2
 	}
 	for _, tt := range tests {
-		got := EstimateTokens(tt.text)
+		got := estimateTokens(tt.text)
 		if got != tt.want {
-			t.Errorf("EstimateTokens(%q) = %d, want %d", tt.text, got, tt.want)
+			t.Errorf("estimateTokens(%q) = %d, want %d", tt.text, got, tt.want)
 		}
 	}
 }
@@ -243,7 +243,7 @@ func TestCompact_TooFewMessages(t *testing.T) {
 		makeTextMessageN(fantasy.MessageRoleUser, 400),
 	}
 
-	result, newMsgs, err := Compact(context.TODO(), nil, msgs, CompactionOptions{}, "")
+	result, newMsgs, err := Compact(context.TODO(), nil, msgs, CompactionOptions{}, "", 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{}, "")
+	result, newMsgs, err := Compact(context.TODO(), nil, msgs, CompactionOptions{}, "", nil)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -273,3 +273,169 @@ func TestCompact_WithinBudget(t *testing.T) {
 		t.Errorf("messages changed: got %d, want %d", len(newMsgs), len(msgs))
 	}
 }
+
+// ---------------------------------------------------------------------------
+// Tool result truncation
+// ---------------------------------------------------------------------------
+
+func TestTruncateToolResult(t *testing.T) {
+	// Short text — no truncation.
+	short := strings.Repeat("x", 100)
+	if got := truncateToolResult(short); got != short {
+		t.Errorf("truncated short text unexpectedly")
+	}
+
+	// Exactly at limit.
+	exact := strings.Repeat("x", maxToolResultChars)
+	if got := truncateToolResult(exact); got != exact {
+		t.Errorf("truncated text at exact limit")
+	}
+
+	// Over limit.
+	over := strings.Repeat("x", maxToolResultChars+500)
+	got := truncateToolResult(over)
+	if len(got) > maxToolResultChars+50 { // allow room for marker
+		t.Errorf("truncated text too long: %d chars", len(got))
+	}
+	if !strings.Contains(got, "500 chars truncated") {
+		t.Errorf("truncation marker missing, got: %s", got[maxToolResultChars:])
+	}
+}
+
+func TestSerializeMessages_TruncatesToolResults(t *testing.T) {
+	longResult := strings.Repeat("R", maxToolResultChars+1000)
+	msgs := []fantasy.Message{
+		makeTextMessage(fantasy.MessageRoleUser, "question"),
+		{
+			Role:    fantasy.MessageRoleTool,
+			Content: []fantasy.MessagePart{fantasy.TextPart{Text: longResult}},
+		},
+	}
+
+	serialized := serializeMessages(msgs)
+	if strings.Contains(serialized, longResult) {
+		t.Error("tool result was not truncated during serialisation")
+	}
+	if !strings.Contains(serialized, "chars truncated") {
+		t.Error("truncation marker missing in serialised output")
+	}
+}
+
+func TestSerializeMessages_PreservesNonToolText(t *testing.T) {
+	longText := strings.Repeat("T", maxToolResultChars+1000)
+	msgs := []fantasy.Message{
+		makeTextMessage(fantasy.MessageRoleUser, longText),
+	}
+
+	serialized := serializeMessages(msgs)
+	if !strings.Contains(serialized, longText) {
+		t.Error("non-tool text was unexpectedly truncated")
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Split turn detection
+// ---------------------------------------------------------------------------
+
+func TestIsSplitTurn(t *testing.T) {
+	msgs := []fantasy.Message{
+		makeTextMessageN(fantasy.MessageRoleUser, 400),      // 0: turn 1 user
+		makeTextMessageN(fantasy.MessageRoleAssistant, 400), // 1: turn 1 assistant
+		makeTextMessageN(fantasy.MessageRoleUser, 400),      // 2: turn 2 user
+		makeTextMessageN(fantasy.MessageRoleAssistant, 400), // 3: turn 2 assistant
+		makeTextMessageN(fantasy.MessageRoleTool, 400),      // 4: turn 2 tool result
+		makeTextMessageN(fantasy.MessageRoleAssistant, 400), // 5: turn 2 assistant
+	}
+
+	tests := []struct {
+		name     string
+		cutPoint int
+		want     bool
+	}{
+		{"at user message (turn boundary)", 2, false},
+		{"at assistant mid-turn", 3, true},
+		{"at assistant after tool (mid-turn)", 5, true},
+		{"at 0 (no cut)", 0, false},
+		{"beyond range", 10, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := IsSplitTurn(msgs, tt.cutPoint)
+			if got != tt.want {
+				t.Errorf("IsSplitTurn(msgs, %d) = %v, want %v", tt.cutPoint, got, tt.want)
+			}
+		})
+	}
+}
+
+// ---------------------------------------------------------------------------
+// File operations extraction
+// ---------------------------------------------------------------------------
+
+func TestExtractFileOps(t *testing.T) {
+	// Create messages with tool calls.
+	msgs := []fantasy.Message{
+		{
+			Role: fantasy.MessageRoleAssistant,
+			Content: []fantasy.MessagePart{
+				fantasy.ToolCallPart{ToolCallID: "1", ToolName: "read", Input: `{"path":"src/main.go"}`},
+				fantasy.ToolCallPart{ToolCallID: "2", ToolName: "write", Input: `{"path":"src/out.go"}`},
+				fantasy.ToolCallPart{ToolCallID: "3", ToolName: "edit", Input: `{"path":"src/edit.go"}`},
+				fantasy.ToolCallPart{ToolCallID: "4", ToolName: "grep", Input: `{"path":"src/search"}`},
+			},
+		},
+	}
+
+	ops := extractFileOps(msgs)
+	if !ops.ReadFiles["src/main.go"] {
+		t.Error("read file not tracked: src/main.go")
+	}
+	if !ops.ReadFiles["src/search"] {
+		t.Error("grep path not tracked as read: src/search")
+	}
+	if !ops.ModifiedFiles["src/out.go"] {
+		t.Error("write file not tracked: src/out.go")
+	}
+	if !ops.ModifiedFiles["src/edit.go"] {
+		t.Error("edit file not tracked: src/edit.go")
+	}
+}
+
+func TestFileOps_MergeSlices(t *testing.T) {
+	ops := newFileOps()
+	ops.ReadFiles["a.go"] = true
+	ops.ModifiedFiles["b.go"] = true
+
+	ops.mergeSlices(
+		[]string{"c.go", "a.go"},
+		[]string{"d.go"},
+	)
+
+	if len(ops.ReadFiles) != 2 { // a.go, c.go
+		t.Errorf("ReadFiles len = %d, want 2", len(ops.ReadFiles))
+	}
+	if len(ops.ModifiedFiles) != 2 { // b.go, d.go
+		t.Errorf("ModifiedFiles len = %d, want 2", len(ops.ModifiedFiles))
+	}
+}
+
+func TestSortedKeys(t *testing.T) {
+	m := map[string]bool{"c": true, "a": true, "b": true}
+	got := sortedKeys(m)
+	want := []string{"a", "b", "c"}
+	if len(got) != len(want) {
+		t.Fatalf("sortedKeys len = %d, want %d", len(got), len(want))
+	}
+	for i, v := range got {
+		if v != want[i] {
+			t.Errorf("sortedKeys[%d] = %q, want %q", i, v, want[i])
+		}
+	}
+}
+
+func TestSortedKeys_Empty(t *testing.T) {
+	got := sortedKeys(nil)
+	if got != nil {
+		t.Errorf("sortedKeys(nil) = %v, want nil", got)
+	}
+}

internal/config/config.go

@@ -105,42 +105,82 @@ type AdaptiveColor struct {
 	Dark  string `json:"dark,omitempty" yaml:"dark,omitempty"`
 }
 
+// MarkdownThemeConfig defines color overrides for markdown rendering and
+// syntax highlighting.
+type MarkdownThemeConfig struct {
+	Text    AdaptiveColor `json:"text,omitzero" yaml:"text,omitempty"`
+	Muted   AdaptiveColor `json:"muted,omitzero" yaml:"muted,omitempty"`
+	Heading AdaptiveColor `json:"heading,omitzero" yaml:"heading,omitempty"`
+	Emph    AdaptiveColor `json:"emph,omitzero" yaml:"emph,omitempty"`
+	Strong  AdaptiveColor `json:"strong,omitzero" yaml:"strong,omitempty"`
+	Link    AdaptiveColor `json:"link,omitzero" yaml:"link,omitempty"`
+	Code    AdaptiveColor `json:"code,omitzero" yaml:"code,omitempty"`
+	Error   AdaptiveColor `json:"error,omitzero" yaml:"error,omitempty"`
+	Keyword AdaptiveColor `json:"keyword,omitzero" yaml:"keyword,omitempty"`
+	String  AdaptiveColor `json:"string,omitzero" yaml:"string,omitempty"`
+	Number  AdaptiveColor `json:"number,omitzero" yaml:"number,omitempty"`
+	Comment AdaptiveColor `json:"comment,omitzero" yaml:"comment,omitempty"`
+}
+
 // Theme defines the color scheme for the application UI with adaptive colors
 // that support both light and dark modes.
 type Theme struct {
-	Primary     AdaptiveColor `json:"primary" yaml:"primary"`
-	Secondary   AdaptiveColor `json:"secondary" yaml:"secondary"`
-	Success     AdaptiveColor `json:"success" yaml:"success"`
-	Warning     AdaptiveColor `json:"warning" yaml:"warning"`
-	Error       AdaptiveColor `json:"error" yaml:"error"`
-	Info        AdaptiveColor `json:"info" yaml:"info"`
-	Text        AdaptiveColor `json:"text" yaml:"text"`
-	Muted       AdaptiveColor `json:"muted" yaml:"muted"`
-	VeryMuted   AdaptiveColor `json:"very-muted" yaml:"very-muted"`
-	Background  AdaptiveColor `json:"background" yaml:"background"`
-	Border      AdaptiveColor `json:"border" yaml:"border"`
-	MutedBorder AdaptiveColor `json:"muted-border" yaml:"muted-border"`
-	System      AdaptiveColor `json:"system" yaml:"system"`
-	Tool        AdaptiveColor `json:"tool" yaml:"tool"`
-	Accent      AdaptiveColor `json:"accent" yaml:"accent"`
-	Highlight   AdaptiveColor `json:"highlight" yaml:"highlight"`
+	Primary     AdaptiveColor `json:"primary,omitzero" yaml:"primary,omitempty"`
+	Secondary   AdaptiveColor `json:"secondary,omitzero" yaml:"secondary,omitempty"`
+	Success     AdaptiveColor `json:"success,omitzero" yaml:"success,omitempty"`
+	Warning     AdaptiveColor `json:"warning,omitzero" yaml:"warning,omitempty"`
+	Error       AdaptiveColor `json:"error,omitzero" yaml:"error,omitempty"`
+	Info        AdaptiveColor `json:"info,omitzero" yaml:"info,omitempty"`
+	Text        AdaptiveColor `json:"text,omitzero" yaml:"text,omitempty"`
+	Muted       AdaptiveColor `json:"muted,omitzero" yaml:"muted,omitempty"`
+	VeryMuted   AdaptiveColor `json:"very-muted,omitzero" yaml:"very-muted,omitempty"`
+	Background  AdaptiveColor `json:"background,omitzero" yaml:"background,omitempty"`
+	Border      AdaptiveColor `json:"border,omitzero" yaml:"border,omitempty"`
+	MutedBorder AdaptiveColor `json:"muted-border,omitzero" yaml:"muted-border,omitempty"`
+	System      AdaptiveColor `json:"system,omitzero" yaml:"system,omitempty"`
+	Tool        AdaptiveColor `json:"tool,omitzero" yaml:"tool,omitempty"`
+	Accent      AdaptiveColor `json:"accent,omitzero" yaml:"accent,omitempty"`
+	Highlight   AdaptiveColor `json:"highlight,omitzero" yaml:"highlight,omitempty"`
+
+	// Diff block backgrounds
+	DiffInsertBg  AdaptiveColor `json:"diff-insert-bg,omitzero" yaml:"diff-insert-bg,omitempty"`
+	DiffDeleteBg  AdaptiveColor `json:"diff-delete-bg,omitzero" yaml:"diff-delete-bg,omitempty"`
+	DiffEqualBg   AdaptiveColor `json:"diff-equal-bg,omitzero" yaml:"diff-equal-bg,omitempty"`
+	DiffMissingBg AdaptiveColor `json:"diff-missing-bg,omitzero" yaml:"diff-missing-bg,omitempty"`
+
+	// Code/output block backgrounds
+	CodeBg   AdaptiveColor `json:"code-bg,omitzero" yaml:"code-bg,omitempty"`
+	GutterBg AdaptiveColor `json:"gutter-bg,omitzero" yaml:"gutter-bg,omitempty"`
+	WriteBg  AdaptiveColor `json:"write-bg,omitzero" yaml:"write-bg,omitempty"`
+
+	// Markdown rendering and syntax highlighting
+	Markdown MarkdownThemeConfig `json:"markdown,omitzero" yaml:"markdown,omitempty"`
 }
 
-// MarkdownTheme defines the color scheme for markdown rendering with syntax
-// highlighting support and adaptive colors for light and dark modes.
-type MarkdownTheme struct {
-	Text    AdaptiveColor `json:"text" yaml:"text"`
-	Muted   AdaptiveColor `json:"muted" yaml:"muted"`
-	Heading AdaptiveColor `json:"heading" yaml:"heading"`
-	Emph    AdaptiveColor `json:"emph" yaml:"emph"`
-	Strong  AdaptiveColor `json:"strong" yaml:"strong"`
-	Link    AdaptiveColor `json:"link" yaml:"link"`
-	Code    AdaptiveColor `json:"code" yaml:"code"`
-	Error   AdaptiveColor `json:"error" yaml:"error"`
-	Keyword AdaptiveColor `json:"keyword" yaml:"keyword"`
-	String  AdaptiveColor `json:"string" yaml:"string"`
-	Number  AdaptiveColor `json:"number" yaml:"number"`
-	Comment AdaptiveColor `json:"comment" yaml:"comment"`
+// CustomModelConfig defines a custom model that can be used with custom/custom
+// or other custom/ prefixed models. These models are loaded from the config file
+// and merged into the custom provider in the model registry.
+type CustomModelConfig struct {
+	Name        string      `json:"name" yaml:"name"`
+	Family      string      `json:"family,omitempty" yaml:"family,omitempty"`
+	Attachment  bool        `json:"attachment,omitempty" yaml:"attachment,omitempty"`
+	Reasoning   bool        `json:"reasoning,omitempty" yaml:"reasoning,omitempty"`
+	Temperature bool        `json:"temperature,omitempty" yaml:"temperature,omitempty"`
+	Knowledge   string      `json:"knowledge,omitempty" yaml:"knowledge,omitempty"`
+	Cost        CostConfig  `json:"cost" yaml:"cost"`
+	Limit       LimitConfig `json:"limit" yaml:"limit"`
+}
+
+// CostConfig defines the pricing for a custom model.
+type CostConfig struct {
+	Input  float64 `json:"input" yaml:"input"`
+	Output float64 `json:"output" yaml:"output"`
+}
+
+// LimitConfig defines context and output limits for a custom model.
+type LimitConfig struct {
+	Context int `json:"context" yaml:"context"`
+	Output  int `json:"output" yaml:"output"`
 }
 
 // Config represents the complete application configuration including MCP servers,
@@ -157,7 +197,6 @@ type Config struct {
 	ProviderURL    string                     `json:"provider-url,omitempty" yaml:"provider-url,omitempty"`
 	Stream         *bool                      `json:"stream,omitempty" yaml:"stream,omitempty"`
 	Theme          any                        `json:"theme" yaml:"theme"`
-	MarkdownTheme  any                        `json:"markdown-theme" yaml:"markdown-theme"`
 	// Model generation parameters
 	MaxTokens     int      `json:"max-tokens,omitempty" yaml:"max-tokens,omitempty"`
 	Temperature   *float32 `json:"temperature,omitempty" yaml:"temperature,omitempty"`
@@ -170,6 +209,13 @@ type Config struct {
 
 	// TLS configuration
 	TLSSkipVerify bool `json:"tls-skip-verify,omitempty" yaml:"tls-skip-verify,omitempty"`
+
+	// Prompt templates configuration
+	Prompts           []string `json:"prompts,omitempty" yaml:"prompts,omitempty"`
+	NoPromptTemplates bool     `json:"no-prompt-templates,omitempty" yaml:"no-prompt-templates,omitempty"`
+
+	// Custom model definitions (under custom/ provider)
+	CustomModels map[string]CustomModelConfig `json:"customModels,omitempty" yaml:"customModels,omitempty"`
 }
 
 // GetTransportType returns the transport type for the server config, mapping
@@ -357,10 +403,9 @@ func FilepathOr[T any](key string, value *T) error {
 				if err != nil {
 					return err
 				}
-				filepath.Join(home, absPath[2:])
+				absPath = filepath.Join(home, absPath[2:])
 			}
 			if !filepath.IsAbs(absPath) {
-				// base := GetConfigPath()
 				base := configPath
 				if base == "" {
 					fmt.Fprintf(os.Stderr, "unable to build relative path to config.")
@@ -373,11 +418,10 @@ func FilepathOr[T any](key string, value *T) error {
 				fmt.Fprintf(os.Stderr, "%q", err)
 				os.Exit(1)
 			}
-			if filepath.Ext(absPath) == ".json" {
+			switch filepath.Ext(absPath) {
+			case ".json":
 				return json.Unmarshal(b, value)
-			}
-
-			if filepath.Ext(absPath) == ".yaml" {
+			case ".yaml", ".yml":
 				return yaml.Unmarshal(b, value)
 			}
 		}

internal/core/bash.go

@@ -1,16 +1,41 @@
 package core
 
 import (
-	"bytes"
+	"bufio"
 	"context"
 	"fmt"
+	"io"
+	"os"
 	"os/exec"
 	"strings"
+	"sync"
 	"time"
 
 	"charm.land/fantasy"
 )
 
+// ToolOutputCallback is the signature for streaming tool output.
+// It receives tool call ID, tool name, output chunk, and whether it's stderr.
+type ToolOutputCallback func(toolCallID, toolName, chunk string, isStderr bool)
+
+// contextKey is a custom type for context keys to avoid collisions.
+type contextKey string
+
+const toolOutputCallbackKey contextKey = "toolOutputCallback"
+
+// ContextWithToolOutputCallback returns a new context with the tool output callback set.
+func ContextWithToolOutputCallback(ctx context.Context, callback ToolOutputCallback) context.Context {
+	return context.WithValue(ctx, toolOutputCallbackKey, callback)
+}
+
+// toolOutputCallbackFromContext retrieves the tool output callback from context.
+func toolOutputCallbackFromContext(ctx context.Context) ToolOutputCallback {
+	if cb, ok := ctx.Value(toolOutputCallbackKey).(ToolOutputCallback); ok {
+		return cb
+	}
+	return nil
+}
+
 const defaultBashTimeout = 120 * time.Second
 const maxBashTimeout = 600 * time.Second
 
@@ -90,32 +115,165 @@ func executeBash(ctx context.Context, call fantasy.ToolCall, workDir string) (fa
 		cmd.Dir = workDir
 	}
 
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
+	// Ensure SHELL is set to bash so child processes (e.g. tmux) use bash
+	// rather than the user's login shell (which may be nushell, fish, etc.).
+	bashPath, err := exec.LookPath("bash")
+	if err != nil {
+		bashPath = "/bin/bash"
+	}
+	cmd.Env = append(os.Environ(), "SHELL="+bashPath)
 
-	err := cmd.Run()
+	// Get the output callback if present (for streaming support)
+	outputCallback := toolOutputCallbackFromContext(ctx)
+
+	if outputCallback != nil {
+		// Streaming mode: use pipes to capture output as it arrives
+		return executeBashStreaming(cmdCtx, call, cmd, outputCallback)
+	}
+
+	// Non-streaming mode: collect all output at once (original behavior)
+	return executeBashBuffered(cmdCtx, call, cmd)
+}
+
+// executeBashBuffered collects all output before returning (original behavior).
+// It uses explicit pipes (not cmd.Stdout) so that cmd.WaitDelay can forcibly
+// close them when grandchild processes hold pipe handles open after the
+// direct child exits.
+func executeBashBuffered(cmdCtx context.Context, call fantasy.ToolCall, cmd *exec.Cmd) (fantasy.ToolResponse, error) {
+	stdoutPipe, err := cmd.StdoutPipe()
+	if err != nil {
+		return fantasy.NewTextErrorResponse("failed to create stdout pipe"), nil
+	}
+	stderrPipe, err := cmd.StderrPipe()
+	if err != nil {
+		return fantasy.NewTextErrorResponse("failed to create stderr pipe"), nil
+	}
+
+	if err := cmd.Start(); err != nil {
+		return fantasy.NewTextErrorResponse(fmt.Sprintf("failed to start command: %v", err)), nil
+	}
+
+	// Read pipes concurrently
+	var wg sync.WaitGroup
+	var stdout, stderr strings.Builder
+	var stdoutErr, stderrErr error
+
+	wg.Add(2)
+	go func() {
+		defer wg.Done()
+		_, stdoutErr = io.Copy(&stdout, stdoutPipe)
+	}()
+	go func() {
+		defer wg.Done()
+		_, stderrErr = io.Copy(&stderr, stderrPipe)
+	}()
+
+	// Wait for the process to exit first. cmd.WaitDelay ensures that if
+	// pipes remain open (held by grandchild processes), they'll be forcibly
+	// closed after the grace period, which unblocks the io.Copy goroutines.
+	waitErr := cmd.Wait()
+
+	// Wait for pipe readers to finish draining.
+	wg.Wait()
+
+	// Ignore pipe read errors caused by WaitDelay force-closing —
+	// we still have whatever was read before the close.
+	_ = stdoutErr
+	_ = stderrErr
+
+	exitCode := 0
+	if waitErr != nil {
+		if exitErr, ok := waitErr.(*exec.ExitError); ok {
+			exitCode = exitErr.ExitCode()
+		} else if cmdCtx.Err() == context.DeadlineExceeded {
+			return fantasy.NewTextErrorResponse("command timed out"), nil
+		}
+	}
+
+	return buildBashResponse(stdout.String(), stderr.String(), exitCode)
+}
+
+// executeBashStreaming streams output as it arrives via the callback.
+func executeBashStreaming(cmdCtx context.Context, call fantasy.ToolCall, cmd *exec.Cmd, outputCallback ToolOutputCallback) (fantasy.ToolResponse, error) {
+	stdoutPipe, err := cmd.StdoutPipe()
+	if err != nil {
+		return fantasy.NewTextErrorResponse("failed to create stdout pipe"), nil
+	}
+	stderrPipe, err := cmd.StderrPipe()
+	if err != nil {
+		return fantasy.NewTextErrorResponse("failed to create stderr pipe"), nil
+	}
+
+	// Start command execution
+	if err := cmd.Start(); err != nil {
+		return fantasy.NewTextErrorResponse(fmt.Sprintf("failed to start command: %v", err)), nil
+	}
+
+	// Stream stdout and stderr concurrently
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+	var stdoutChunks, stderrChunks []string
+
+	streamOutput := func(reader io.Reader, isStderr bool) {
+		defer wg.Done()
+		scanner := bufio.NewScanner(reader)
+		// Use larger buffer for long lines
+		buf := make([]byte, 0, 64*1024)
+		scanner.Buffer(buf, 1024*1024)
+
+		for scanner.Scan() {
+			chunk := scanner.Text()
+			// Send chunk to UI
+			outputCallback(call.ID, "bash", chunk, isStderr)
+			// Collect for final result
+			mu.Lock()
+			if isStderr {
+				stderrChunks = append(stderrChunks, chunk)
+			} else {
+				stdoutChunks = append(stdoutChunks, chunk)
+			}
+			mu.Unlock()
+		}
+	}
+
+	wg.Add(2)
+	go streamOutput(stdoutPipe, false)
+	go streamOutput(stderrPipe, true)
+
+	// Wait for the process to exit. cmd.WaitDelay ensures that if pipes
+	// remain open (held by grandchild processes), they'll be forcibly closed
+	// after the grace period, which unblocks the scanners above.
+	err = cmd.Wait()
+
+	// Wait for the pipe readers to finish draining. This will complete
+	// quickly since cmd.Wait() (with WaitDelay) has already ensured
+	// the pipes are closed.
+	wg.Wait()
 
 	exitCode := 0
 	if err != nil {
 		if exitErr, ok := err.(*exec.ExitError); ok {
 			exitCode = exitErr.ExitCode()
 		} else if cmdCtx.Err() == context.DeadlineExceeded {
-			return fantasy.NewTextErrorResponse(fmt.Sprintf("command timed out after %v", timeout)), nil
+			return fantasy.NewTextErrorResponse("command timed out"), nil
 		}
 	}
 
-	// Build result
+	return buildBashResponse(strings.Join(stdoutChunks, "\n"), strings.Join(stderrChunks, "\n"), exitCode)
+}
+
+// buildBashResponse constructs the final tool response from stdout/stderr.
+func buildBashResponse(stdout, stderr string, exitCode int) (fantasy.ToolResponse, error) {
 	var result strings.Builder
-	if stdout.Len() > 0 {
-		result.WriteString(stdout.String())
+	if stdout != "" {
+		result.WriteString(stdout)
 	}
-	if stderr.Len() > 0 {
+	if stderr != "" {
 		if result.Len() > 0 {
 			result.WriteString("\n")
 		}
 		result.WriteString("STDERR:\n")
-		result.WriteString(stderr.String())
+		result.WriteString(stderr)
 	}
 	if exitCode != 0 {
 		if result.Len() > 0 {

internal/core/bash_test.go

@@ -0,0 +1,129 @@
+package core
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+	"time"
+
+	"charm.land/fantasy"
+)
+
+// helper to create a bash tool call with the given command and optional timeout.
+func bashCall(command string, timeout float64) fantasy.ToolCall {
+	args := map[string]any{"command": command}
+	if timeout > 0 {
+		args["timeout"] = timeout
+	}
+	input, _ := json.Marshal(args)
+	return fantasy.ToolCall{
+		ID:    "test-call",
+		Name:  "bash",
+		Input: string(input),
+	}
+}
+
+func TestBash_SimpleCommand(t *testing.T) {
+	resp, err := executeBash(context.Background(), bashCall("echo hello", 0), "")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if resp.IsError {
+		t.Fatalf("expected success, got error: %s", resp.Content)
+	}
+	if resp.Content != "hello\n" {
+		t.Errorf("expected 'hello\\n', got %q", resp.Content)
+	}
+}
+
+func TestBash_TimeoutKillsProcess(t *testing.T) {
+	start := time.Now()
+	resp, err := executeBash(context.Background(), bashCall("sleep 60", 2), "")
+	elapsed := time.Since(start)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !resp.IsError {
+		t.Fatal("expected error response for timed-out command")
+	}
+	if elapsed > 10*time.Second {
+		t.Errorf("command took %v, expected ~2s timeout", elapsed)
+	}
+}
+
+func TestBash_BackgroundProcessDoesNotHang(t *testing.T) {
+	// This command spawns a background sleep that would hold pipes open
+	// forever if we didn't have process group killing + WaitDelay.
+	start := time.Now()
+	resp, err := executeBash(context.Background(), bashCall("echo done; sleep 3600 &", 5), "")
+	elapsed := time.Since(start)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	// The foreground command (echo) should complete quickly
+	if elapsed > 5*time.Second {
+		t.Errorf("command took %v, should complete in <5s (background process should not block)", elapsed)
+	}
+	if resp.IsError {
+		t.Fatalf("expected success, got error: %s", resp.Content)
+	}
+}
+
+func TestBash_BackgroundProcessDoesNotHang_Streaming(t *testing.T) {
+	// Same test but in streaming mode (with output callback).
+	ctx := ContextWithToolOutputCallback(context.Background(), func(_, _, _ string, _ bool) {})
+	start := time.Now()
+	resp, err := executeBash(ctx, bashCall("echo streaming; sleep 3600 &", 5), "")
+	elapsed := time.Since(start)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if elapsed > 5*time.Second {
+		t.Errorf("streaming command took %v, should complete in <5s", elapsed)
+	}
+	if resp.IsError {
+		t.Fatalf("expected success, got error: %s", resp.Content)
+	}
+}
+
+func TestBash_ContextCancellation(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		_, _ = executeBash(ctx, bashCall("sleep 60", 0), "")
+	}()
+
+	// Cancel after a short delay
+	time.Sleep(500 * time.Millisecond)
+	cancel()
+
+	// Should return promptly after cancellation
+	select {
+	case <-done:
+		// success
+	case <-time.After(5 * time.Second):
+		t.Fatal("executeBash did not return after context cancellation")
+	}
+}
+
+func TestBash_BannedCommand(t *testing.T) {
+	resp, err := executeBash(context.Background(), bashCall("alias foo=bar", 0), "")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !resp.IsError {
+		t.Fatal("expected error for banned command")
+	}
+}
+
+func TestBash_EmptyCommand(t *testing.T) {
+	resp, err := executeBash(context.Background(), bashCall("", 0), "")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !resp.IsError {
+		t.Fatal("expected error for empty command")
+	}
+}

internal/core/edit.go

@@ -4,25 +4,55 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"sort"
 	"strings"
 	"unicode"
+	"unicode/utf8"
 
 	"charm.land/fantasy"
+
+	udiff "github.com/aymanbagabas/go-udiff"
 )
 
-type editArgs struct {
-	Path    string `json:"path"`
+// Edit represents a single replacement in a multi-edit operation.
+type Edit struct {
 	OldText string `json:"old_text"`
 	NewText string `json:"new_text"`
 }
 
+// editArgs holds the arguments for the edit tool.
+// Supports both single-edit mode (old_text/new_text) and multi-edit mode (edits array).
+type editArgs struct {
+	Path    string `json:"path"`
+	OldText string `json:"old_text"` // Single-edit mode
+	NewText string `json:"new_text"` // Single-edit mode
+	Edits   []Edit `json:"edits"`    // Multi-edit mode
+}
+
+// replacement represents a normalized edit ready for processing.
+type replacement struct {
+	oldText     string // normalized old text for matching
+	newText     string // normalized new text
+	originalOld string // original old text for metadata
+	originalNew string // original new text for metadata
+	index       int    // index in the original edits array (for error messages)
+}
+
+// matchedReplacement represents a replacement with its match location.
+type matchedReplacement struct {
+	replacement
+	start          int  // start index in normalized content
+	end            int  // end index in normalized content
+	usedFuzzyMatch bool // true if fuzzy matching was used
+}
+
 // NewEditTool creates the edit core tool.
 func NewEditTool(opts ...ToolOption) fantasy.AgentTool {
 	cfg := ApplyOptions(opts)
 	return &coreTool{
 		info: fantasy.ToolInfo{
 			Name:        "edit",
-			Description: "Edit a file by replacing exact text. The old_text must match exactly (including whitespace). Use this for precise, surgical edits. Fails if old_text is not found or matches multiple locations.",
+			Description: "Edit a file by replacing exact text. Supports single edit via old_text/new_text, or multiple edits via the edits array. All edits in the array are matched against the original file content (non-incremental) and must be non-overlapping.",
 			Parameters: map[string]any{
 				"path": map[string]any{
 					"type":        "string",
@@ -30,14 +60,32 @@ func NewEditTool(opts ...ToolOption) fantasy.AgentTool {
 				},
 				"old_text": map[string]any{
 					"type":        "string",
-					"description": "Exact text to find and replace (must match exactly)",
+					"description": "Exact text to find and replace (single-edit mode). Must not be used with 'edits' array.",
 				},
 				"new_text": map[string]any{
 					"type":        "string",
-					"description": "New text to replace the old text with",
+					"description": "New text to replace the old text with (single-edit mode). Must not be used with 'edits' array.",
+				},
+				"edits": map[string]any{
+					"type":        "array",
+					"description": "Array of edits for multi-region replacement. Each edit must have unique, non-overlapping old_text. All matches are against the original file content.",
+					"items": map[string]any{
+						"type": "object",
+						"properties": map[string]any{
+							"old_text": map[string]any{
+								"type":        "string",
+								"description": "Exact text to find and replace for this edit",
+							},
+							"new_text": map[string]any{
+								"type":        "string",
+								"description": "New text for this edit",
+							},
+						},
+						"required": []string{"old_text", "new_text"},
+					},
 				},
 			},
-			Required: []string{"path", "old_text", "new_text"},
+			Required: []string{"path"},
 		},
 		handler: func(ctx context.Context, call fantasy.ToolCall) (fantasy.ToolResponse, error) {
 			return executeEdit(ctx, call, cfg.WorkDir)
@@ -48,7 +96,7 @@ func NewEditTool(opts ...ToolOption) fantasy.AgentTool {
 func executeEdit(ctx context.Context, call fantasy.ToolCall, workDir string) (fantasy.ToolResponse, error) {
 	var args editArgs
 	if err := parseArgs(call.Input, &args); err != nil {
-		return fantasy.NewTextErrorResponse("path, old_text, and new_text parameters are required"), nil
+		return fantasy.NewTextErrorResponse("failed to parse arguments: " + err.Error()), nil
 	}
 	if args.Path == "" {
 		return fantasy.NewTextErrorResponse("path parameter is required"), nil
@@ -66,158 +114,308 @@ func executeEdit(ctx context.Context, call fantasy.ToolCall, workDir string) (fa
 
 	content := string(contentBytes)
 
-	// Normalize line endings for matching
-	normalized := strings.ReplaceAll(content, "\r\n", "\n")
-	normalizedOld := strings.ReplaceAll(args.OldText, "\r\n", "\n")
-
-	// Try exact match first
-	count := strings.Count(normalized, normalizedOld)
-
-	// If no exact match, try fuzzy matching
-	if count == 0 {
-		if idx, matchLen := fuzzyMatch(normalized, normalizedOld); idx >= 0 {
-			// Apply fuzzy match — the matched text is the original content slice
-			matchedText := normalized[idx : idx+matchLen]
-			newContent := normalized[:idx] + args.NewText + normalized[idx+matchLen:]
-			if err := os.WriteFile(absPath, []byte(newContent), 0644); err != nil {
-				return fantasy.NewTextErrorResponse(fmt.Sprintf("failed to write file: %v", err)), nil
-			}
-			diff := generateDiff(absPath, normalized, newContent, idx)
-			resp := fantasy.NewTextResponse(fmt.Sprintf("Applied edit (fuzzy match) to %s\n%s", args.Path, diff))
-			return fantasy.WithResponseMetadata(resp, editDiffMeta(absPath, matchedText, args.NewText)), nil
-		}
-		return fantasy.NewTextErrorResponse(fmt.Sprintf("old_text not found in %s", args.Path)), nil
+	// Normalize and validate input
+	replacements, err := normalizeEditInput(args)
+	if err != nil {
+		return fantasy.NewTextErrorResponse(err.Error()), nil
 	}
 
-	if count > 1 {
-		return fantasy.NewTextErrorResponse(fmt.Sprintf("found %d matches for old_text in %s. Provide more context to identify the correct match.", count, args.Path)), nil
+	// Apply all edits
+	newContent, applied, err := applyEdits(content, replacements)
+	if err != nil {
+		return fantasy.NewTextErrorResponse(err.Error()), nil
 	}
 
-	// Apply the edit
-	newContent := strings.Replace(normalized, normalizedOld, args.NewText, 1)
-
+	// Write the file
 	if err := os.WriteFile(absPath, []byte(newContent), 0644); err != nil {
 		return fantasy.NewTextErrorResponse(fmt.Sprintf("failed to write file: %v", err)), nil
 	}
 
-	idx := strings.Index(normalized, normalizedOld)
-	diff := generateDiff(absPath, normalized, newContent, idx)
-	resp := fantasy.NewTextResponse(fmt.Sprintf("Applied edit to %s\n%s", args.Path, diff))
-	return fantasy.WithResponseMetadata(resp, editDiffMeta(absPath, normalizedOld, args.NewText)), nil
+	// Generate diff
+	normalizedContent := strings.ReplaceAll(content, "\r\n", "\n")
+	diff := generateDiff(absPath, normalizedContent, newContent)
+
+	// Build response with fuzzy match indication
+	fuzzyCount := 0
+	for _, m := range applied {
+		if m.usedFuzzyMatch {
+			fuzzyCount++
+		}
+	}
+
+	var msg string
+	if len(applied) == 1 {
+		if fuzzyCount > 0 {
+			msg = fmt.Sprintf("Applied edit (fuzzy match) to %s\n%s", args.Path, diff)
+		} else {
+			msg = fmt.Sprintf("Applied edit to %s\n%s", args.Path, diff)
+		}
+	} else {
+		if fuzzyCount > 0 {
+			msg = fmt.Sprintf("Applied %d edits (%d fuzzy) to %s\n%s", len(applied), fuzzyCount, args.Path, diff)
+		} else {
+			msg = fmt.Sprintf("Applied %d edits to %s\n%s", len(applied), args.Path, diff)
+		}
+	}
+
+	resp := fantasy.NewTextResponse(msg)
+	return fantasy.WithResponseMetadata(resp, editDiffMeta(absPath, applied)), nil
+}
+
+// normalizeEditInput validates and normalizes the edit input.
+// Returns error if both single-edit and multi-edit modes are used.
+func normalizeEditInput(args editArgs) ([]replacement, error) {
+	singleMode := args.OldText != "" || args.NewText != ""
+	multiMode := len(args.Edits) > 0
+
+	if singleMode && multiMode {
+		return nil, fmt.Errorf("cannot use old_text/new_text together with edits array")
+	}
+
+	if !singleMode && !multiMode {
+		return nil, fmt.Errorf("must provide either old_text/new_text or edits array")
+	}
+
+	if singleMode {
+		if args.OldText == "" {
+			return nil, fmt.Errorf("old_text is required when using single-edit mode")
+		}
+		if args.NewText == "" {
+			return nil, fmt.Errorf("new_text is required when using single-edit mode")
+		}
+		return []replacement{{
+			oldText:     strings.ReplaceAll(args.OldText, "\r\n", "\n"),
+			newText:     strings.ReplaceAll(args.NewText, "\r\n", "\n"),
+			originalOld: args.OldText,
+			originalNew: args.NewText,
+			index:       0,
+		}}, nil
+	}
+
+	// Multi-edit mode
+	var reps []replacement
+	for i, edit := range args.Edits {
+		if edit.OldText == "" {
+			return nil, fmt.Errorf("edits[%d].old_text is required", i)
+		}
+		reps = append(reps, replacement{
+			oldText:     strings.ReplaceAll(edit.OldText, "\r\n", "\n"),
+			newText:     strings.ReplaceAll(edit.NewText, "\r\n", "\n"),
+			originalOld: edit.OldText,
+			originalNew: edit.NewText,
+			index:       i,
+		})
+	}
+	return reps, nil
+}
+
+// applyEdits applies multiple replacements to the content.
+// All matches are against the original content (non-incremental).
+// Returns the new content, the applied matches, and any error.
+func applyEdits(content string, edits []replacement) (string, []matchedReplacement, error) {
+	normalizedContent := strings.ReplaceAll(content, "\r\n", "\n")
+
+	// Find all matches
+	var matched []matchedReplacement
+	for _, edit := range edits {
+		m, err := findMatch(normalizedContent, edit)
+		if err != nil {
+			return "", nil, err
+		}
+		matched = append(matched, *m)
+	}
+
+	// Sort by position
+	sort.Slice(matched, func(i, j int) bool {
+		return matched[i].start < matched[j].start
+	})
+
+	// Check for overlaps
+	for i := 1; i < len(matched); i++ {
+		if matched[i-1].end > matched[i].start {
+			return "", nil, fmt.Errorf("edits[%d] and edits[%d] overlap; merge them into a single edit",
+				matched[i-1].index, matched[i].index)
+		}
+	}
+
+	// Apply edits in reverse order (end to start) to maintain stable offsets
+	result := normalizedContent
+	for i := len(matched) - 1; i >= 0; i-- {
+		m := matched[i]
+		result = result[:m.start] + m.newText + result[m.end:]
+	}
+
+	return result, matched, nil
+}
+
+// findMatch finds a unique match for the edit in the content.
+// Returns error if not found or ambiguous.
+func findMatch(content string, edit replacement) (*matchedReplacement, error) {
+	// Try exact match first
+	count := strings.Count(content, edit.oldText)
+
+	if count == 0 {
+		// Try fuzzy match
+		idx, matchLen := fuzzyMatch(content, edit.oldText)
+		if idx < 0 {
+			return nil, fmt.Errorf("edits[%d]: could not find old_text in file. The text must match exactly (including whitespace)", edit.index)
+		}
+		// Use the matched text from content for the replacement
+		matchedText := content[idx : idx+matchLen]
+		return &matchedReplacement{
+			replacement: replacement{
+				oldText:     matchedText,
+				newText:     edit.newText,
+				originalOld: edit.originalOld,
+				originalNew: edit.originalNew,
+				index:       edit.index,
+			},
+			start:          idx,
+			end:            idx + matchLen,
+			usedFuzzyMatch: true,
+		}, nil
+	}
+
+	if count > 1 {
+		return nil, fmt.Errorf("found %d matches for edits[%d].old_text; each old_text must be unique, provide more context to identify the correct match", count, edit.index)
+	}
+
+	// Single exact match
+	idx := strings.Index(content, edit.oldText)
+	return &matchedReplacement{
+		replacement: edit,
+		start:       idx,
+		end:         idx + len(edit.oldText),
+	}, nil
 }
 
 // editDiffMeta builds the structured metadata attached to edit tool responses.
-func editDiffMeta(path, oldText, newText string) map[string]any {
+func editDiffMeta(path string, applied []matchedReplacement) map[string]any {
+	var diffBlocks []map[string]any
+	totalAdditions, totalDeletions := 0, 0
+
+	for _, m := range applied {
+		diffBlocks = append(diffBlocks, map[string]any{
+			"old_text": m.originalOld,
+			"new_text": m.originalNew,
+		})
+		totalAdditions += strings.Count(m.originalNew, "\n") + 1
+		totalDeletions += strings.Count(m.originalOld, "\n") + 1
+	}
+
 	return map[string]any{
 		"file_diffs": []map[string]any{{
-			"path":      path,
-			"additions": strings.Count(newText, "\n") + 1,
-			"deletions": strings.Count(oldText, "\n") + 1,
-			"diff_blocks": []map[string]any{{
-				"old_text": oldText,
-				"new_text": newText,
-			}},
+			"path":        path,
+			"additions":   totalAdditions,
+			"deletions":   totalDeletions,
+			"diff_blocks": diffBlocks,
 		}},
 	}
 }
 
 // fuzzyMatch tries to find old_text with relaxed matching:
-// - Strips trailing whitespace per line
-// - Normalizes unicode quotes to ASCII
-// - Normalizes unicode dashes/spaces
-// Returns (index, matchLength) or (-1, 0) if not found.
+//   - Strips trailing whitespace per line
+//   - Normalizes unicode quotes to ASCII
+//   - Normalizes unicode dashes/spaces
+//
+// Returns (index, matchLength) in the original content, or (-1, 0) if not
+// found or ambiguous (multiple matches).
 func fuzzyMatch(content, search string) (int, int) {
-	normalizedContent := normalizeForFuzzy(content)
-	normalizedSearch := normalizeForFuzzy(search)
+	normContent, contentMap := normalizeWithMap(content)
+	normSearch := normalizeForFuzzy(search)
 
-	idx := strings.Index(normalizedContent, normalizedSearch)
+	if normSearch == "" {
+		return -1, 0
+	}
+
+	idx := strings.Index(normContent, normSearch)
 	if idx < 0 {
 		return -1, 0
 	}
 
-	// Map back to original content position
-	// Since normalization can change lengths, we need to find the
-	// corresponding region in the original content
-	origIdx := mapFuzzyIndex(content, normalizedContent, idx)
-	origEnd := mapFuzzyIndex(content, normalizedContent, idx+len(normalizedSearch))
+	// Reject ambiguous matches — if there are multiple fuzzy matches
+	// we can't safely pick one.
+	if strings.Count(normContent, normSearch) > 1 {
+		return -1, 0
+	}
 
-	return origIdx, origEnd - origIdx
+	// Map normalized byte positions back to original byte positions.
+	origStart := contentMap[idx]
+	endNorm := idx + len(normSearch)
+	var origEnd int
+	if endNorm >= len(normContent) {
+		origEnd = len(content)
+	} else {
+		origEnd = contentMap[endNorm]
+	}
+
+	return origStart, origEnd - origStart
 }
 
-func normalizeForFuzzy(s string) string {
-	// Strip trailing whitespace per line
+// normalizeWithMap normalizes s for fuzzy matching and returns both the
+// normalized string and a byte-position mapping where mapping[i] is the
+// original byte position corresponding to normalized byte position i.
+//
+// Normalization: trim trailing whitespace per line, replace unicode
+// quotes/dashes/spaces with their ASCII equivalents.
+func normalizeWithMap(s string) (string, []int) {
+	var result []byte
+	var mapping []int // mapping[i] = original byte position for result byte i
+
 	lines := strings.Split(s, "\n")
-	for i, line := range lines {
-		lines[i] = strings.TrimRightFunc(line, unicode.IsSpace)
-	}
-	result := strings.Join(lines, "\n")
-
-	// Normalize smart quotes
-	replacer := strings.NewReplacer(
-		"\u201c", "\"", // left double quote
-		"\u201d", "\"", // right double quote
-		"\u2018", "'", // left single quote
-		"\u2019", "'", // right single quote
-		"\u2013", "-", // en dash
-		"\u2014", "-", // em dash
-		"\u00a0", " ", // non-breaking space
-	)
-	return replacer.Replace(result)
-}
-
-func mapFuzzyIndex(original, normalized string, normIdx int) int {
-	// Simple approach: count runes up to normIdx in normalized,
-	// then advance that many runes in original.
-	// This works because our normalization only replaces runes 1:1.
-	origRunes := []rune(original)
-	normRunes := []rune(normalized)
-
-	if normIdx >= len(normRunes) {
-		return len(original)
-	}
-
-	// Count bytes for the first normIdx runes in original
-	byteCount := 0
-	for i := 0; i < normIdx && i < len(origRunes); i++ {
-		byteCount += len(string(origRunes[i]))
-	}
-	return byteCount
-}
-
-// generateDiff creates a simple unified diff showing the change.
-func generateDiff(path, old, new string, changeIdx int) string {
-	oldLines := strings.Split(old, "\n")
-	newLines := strings.Split(new, "\n")
-
-	// Find the line number where the change starts
-	lineNum := strings.Count(old[:changeIdx], "\n") + 1
-
-	// Show context around the change
-	contextLines := 3
-	start := max(lineNum-contextLines-1, 0)
-
-	var diff strings.Builder
-	fmt.Fprintf(&diff, "--- %s\n+++ %s\n", path, path)
-
-	// Find changed region
-	endOld := min(lineNum+contextLines+countNewlines(old[changeIdx:])+1, len(oldLines))
-	endNew := min(lineNum+contextLines+countNewlines(new[changeIdx:])+1, len(newLines))
-
-	fmt.Fprintf(&diff, "@@ -%d,%d +%d,%d @@\n", start+1, endOld-start, start+1, endNew-start)
-
-	// Very simplified diff: show old lines as removed, new lines as added
-	// around the change region
-	for i := start; i < endOld && i < len(oldLines); i++ {
-		prefix := " "
-		if i >= lineNum-1 && i < lineNum-1+countNewlines(old[changeIdx:])+1 {
-			prefix = "-"
+	origPos := 0
+	for li, line := range lines {
+		if li > 0 {
+			result = append(result, '\n')
+			mapping = append(mapping, origPos)
+			origPos++ // skip \n in original
 		}
-		fmt.Fprintf(&diff, "%s %s\n", prefix, oldLines[i])
+
+		trimmed := strings.TrimRightFunc(line, unicode.IsSpace)
+
+		for j := 0; j < len(trimmed); {
+			r, size := utf8.DecodeRuneInString(trimmed[j:])
+			repl := normalizeRune(r)
+			for k := 0; k < len(repl); k++ {
+				mapping = append(mapping, origPos+j)
+			}
+			result = append(result, repl...)
+			j += size
+		}
+
+		origPos += len(line) // advance past full original line including trailing ws
 	}
 
-	return diff.String()
+	return string(result), mapping
 }
 
-func countNewlines(s string) int {
-	return strings.Count(s, "\n")
+// normalizeRune maps unicode quotes, dashes, and non-breaking spaces to
+// their ASCII equivalents. Returns the original rune as a string for all
+// other characters.
+func normalizeRune(r rune) string {
+	switch r {
+	case '\u201c', '\u201d': // left/right double quote
+		return "\""
+	case '\u2018', '\u2019': // left/right single quote
+		return "'"
+	case '\u2013', '\u2014': // en dash, em dash
+		return "-"
+	case '\u00a0': // non-breaking space
+		return " "
+	default:
+		return string(r)
+	}
+}
+
+// normalizeForFuzzy normalizes s for fuzzy matching (without position mapping).
+// Used for the search string where position mapping is not needed.
+func normalizeForFuzzy(s string) string {
+	norm, _ := normalizeWithMap(s)
+	return norm
+}
+
+// generateDiff creates a unified diff showing the change between old and new
+// file contents. Uses the go-udiff library for correct diff computation.
+func generateDiff(path, old, new string) string {
+	return udiff.Unified(path, path, old, new)
 }

internal/core/subagent.go

@@ -28,12 +28,14 @@ type SubagentSpawnResult struct {
 // SubagentSpawnFunc is a callback that spawns an in-process subagent. The
 // parent Kit instance injects this into the context so the core tool can
 // call back without importing pkg/kit (which would create a cycle).
-type SubagentSpawnFunc func(ctx context.Context, prompt, model, systemPrompt string, timeout time.Duration) (*SubagentSpawnResult, error)
+// The toolCallID parameter is the LLM-assigned ID of the subagent
+// tool call, enabling the parent to correlate subagent events.
+type SubagentSpawnFunc func(ctx context.Context, toolCallID, prompt, model, systemPrompt string, timeout time.Duration) (*SubagentSpawnResult, error)
 
 type subagentCtxKey struct{}
 
 // WithSubagentSpawner stores a spawn function in the context so that the
-// spawn_subagent core tool can create in-process subagents.
+// subagent core tool can create in-process subagents.
 func WithSubagentSpawner(ctx context.Context, fn SubagentSpawnFunc) context.Context {
 	return context.WithValue(ctx, subagentCtxKey{}, fn)
 }
@@ -47,7 +49,7 @@ func getSubagentSpawner(ctx context.Context) SubagentSpawnFunc {
 }
 
 // ---------------------------------------------------------------------------
-// spawn_subagent tool
+// subagent tool
 // ---------------------------------------------------------------------------
 
 type subagentArgs struct {
@@ -57,11 +59,11 @@ type subagentArgs struct {
 	TimeoutSeconds int    `json:"timeout_seconds,omitempty"`
 }
 
-// NewSubagentTool creates the spawn_subagent core tool.
+// NewSubagentTool creates the subagent core tool.
 func NewSubagentTool(opts ...ToolOption) fantasy.AgentTool {
 	return &coreTool{
 		info: fantasy.ToolInfo{
-			Name: "spawn_subagent",
+			Name: "subagent",
 			Description: `Spawn a subagent to perform a task autonomously.
 
 The subagent runs as a separate in-process Kit instance with full tool access
@@ -128,8 +130,16 @@ func executeSubagent(ctx context.Context, call fantasy.ToolCall) (fantasy.ToolRe
 		), fmt.Errorf("no subagent spawner in context")
 	}
 
+	// Detach from the parent's deadline so the subagent gets its own
+	// independent timeout (applied downstream in Kit.Subagent). The parent
+	// context may carry a tight deadline from the LLM generation loop or
+	// other tool timeouts that would prematurely kill the subagent.
+	// We preserve context values (spawner, etc.) and propagate parent
+	// cancellation (e.g. user hits Ctrl-C) without inheriting the deadline.
+	spawnCtx := detachedWithCancel(ctx)
+
 	// Spawn in-process subagent.
-	result, err := spawner(ctx, args.Task, args.Model, args.SystemPrompt, timeout)
+	result, err := spawner(spawnCtx, call.ID, args.Task, args.Model, args.SystemPrompt, timeout)
 	if err != nil || result.Error != nil {
 		spawnErr := err
 		if spawnErr == nil {
@@ -162,6 +172,39 @@ func executeSubagent(ctx context.Context, call fantasy.ToolCall) (fantasy.ToolRe
 	return resp, nil
 }
 
+// ---------------------------------------------------------------------------
+// Context detachment
+// ---------------------------------------------------------------------------
+
+// detachedContext wraps a parent context, preserving its values but removing
+// its deadline and cancellation. This allows the subagent to have its own
+// independent timeout while still accessing context-stored values (e.g. the
+// subagent spawner function).
+type detachedContext struct {
+	parent context.Context
+}
+
+func (d detachedContext) Deadline() (time.Time, bool) { return time.Time{}, false }
+func (d detachedContext) Done() <-chan struct{}       { return nil }
+func (d detachedContext) Err() error                  { return nil }
+func (d detachedContext) Value(key any) any           { return d.parent.Value(key) }
+
+// detachedWithCancel creates a new context that inherits values from the
+// parent but has no deadline. Cancellation of the parent is propagated: when
+// the parent is cancelled the returned context is also cancelled, but the
+// parent's deadline does not apply to the child.
+func detachedWithCancel(parent context.Context) context.Context {
+	child, cancel := context.WithCancel(detachedContext{parent: parent})
+	go func() {
+		select {
+		case <-parent.Done():
+			cancel()
+		case <-child.Done():
+		}
+	}()
+	return child
+}
+
 // truncateResponse limits the response length to avoid overwhelming context windows.
 func truncateResponse(s string, maxLen int) string {
 	if len(s) <= maxLen {

internal/core/tools.go

@@ -86,7 +86,7 @@ func ReadOnlyTools(opts ...ToolOption) []fantasy.AgentTool {
 	}
 }
 
-// SubagentTools returns all core tools except spawn_subagent. This prevents
+// SubagentTools returns all core tools except subagent. This prevents
 // infinite recursion when a subagent is itself a Kit instance.
 func SubagentTools(opts ...ToolOption) []fantasy.AgentTool {
 	return []fantasy.AgentTool{

internal/core/truncate.go

@@ -6,14 +6,17 @@ import (
 )
 
 const (
-	defaultMaxLines = 2000
-	defaultMaxBytes = 50 * 1024 // 50KB
-	grepMaxLineLen  = 500
+	defaultMaxLines   = 2000
+	defaultMaxBytes   = 50 * 1024 // 50KB
+	defaultMaxLineLen = 2000      // max characters per line before truncation
+	grepMaxLineLen    = 500
 
 	// DefaultMaxLines is the exported default line limit for truncation.
 	DefaultMaxLines = defaultMaxLines
 	// DefaultMaxBytes is the exported default byte limit for truncation.
 	DefaultMaxBytes = defaultMaxBytes
+	// DefaultMaxLineLen is the exported default per-line character limit.
+	DefaultMaxLineLen = defaultMaxLineLen
 )
 
 // TruncationResult describes how output was truncated.
@@ -26,6 +29,8 @@ type TruncationResult struct {
 }
 
 // TruncateTail keeps the last maxLines lines and at most maxBytes bytes.
+// Individual lines longer than defaultMaxLineLen are truncated to prevent
+// extremely long single lines from blowing up the TUI when wrapped.
 // Used for bash output where the tail is most relevant.
 func TruncateTail(content string, maxLines, maxBytes int) TruncationResult {
 	if maxLines <= 0 {
@@ -38,11 +43,11 @@ func TruncateTail(content string, maxLines, maxBytes int) TruncationResult {
 	lines := strings.Split(content, "\n")
 	total := len(lines)
 
-	if len(content) <= maxBytes && total <= maxLines {
-		return TruncationResult{Content: content, Total: total, Kept: total}
-	}
+	// Truncate individual long lines first to prevent single lines from
+	// wrapping into hundreds of visual lines in the TUI.
+	lines = truncateLongLines(lines, defaultMaxLineLen)
 
-	// Truncate by lines first (keep tail)
+	// Truncate by lines (keep tail)
 	truncBy := ""
 	if total > maxLines {
 		lines = lines[total-maxLines:]
@@ -78,6 +83,7 @@ func TruncateTail(content string, maxLines, maxBytes int) TruncationResult {
 }
 
 // truncateHead keeps the first maxLines lines and at most maxBytes bytes.
+// Individual lines longer than defaultMaxLineLen are truncated.
 // Used for read, grep, find, ls output where the head is most relevant.
 func truncateHead(content string, maxLines, maxBytes int) TruncationResult {
 	if maxLines <= 0 {
@@ -90,9 +96,8 @@ func truncateHead(content string, maxLines, maxBytes int) TruncationResult {
 	lines := strings.Split(content, "\n")
 	total := len(lines)
 
-	if len(content) <= maxBytes && total <= maxLines {
-		return TruncationResult{Content: content, Total: total, Kept: total}
-	}
+	// Truncate individual long lines first.
+	lines = truncateLongLines(lines, defaultMaxLineLen)
 
 	truncBy := ""
 	if total > maxLines {
@@ -125,6 +130,19 @@ func truncateHead(content string, maxLines, maxBytes int) TruncationResult {
 	}
 }
 
+// truncateLongLines caps each line to maxLen characters, appending a
+// "[...N chars truncated]" marker to any line that exceeds the limit.
+// This prevents a single very long line (e.g. minified JSON/JS) from
+// wrapping into hundreds of visual rows and blowing up the TUI.
+func truncateLongLines(lines []string, maxLen int) []string {
+	for i, line := range lines {
+		if len(line) > maxLen {
+			lines[i] = line[:maxLen] + fmt.Sprintf("... [%d chars truncated]", len(line)-maxLen)
+		}
+	}
+	return lines
+}
+
 // truncateLine truncates a single line to maxChars, appending "..." if cut.
 func truncateLine(line string, maxChars int) string {
 	if maxChars <= 0 {

internal/core/truncate_test.go

@@ -0,0 +1,163 @@
+package core
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTruncateTail_LongLines(t *testing.T) {
+	// A single line of 5000 chars should be truncated to defaultMaxLineLen.
+	longLine := strings.Repeat("x", 5000)
+	tr := TruncateTail(longLine, 2000, 50*1024)
+
+	if len(tr.Content) > defaultMaxLineLen+100 { // +100 for the "[...N chars truncated]" suffix
+		t.Errorf("single long line not truncated: got %d chars, want <= %d", len(tr.Content), defaultMaxLineLen+100)
+	}
+	if !strings.Contains(tr.Content, "chars truncated]") {
+		t.Error("truncated line should contain truncation marker")
+	}
+}
+
+func TestTruncateTail_NormalLines(t *testing.T) {
+	// Lines within the limit should pass through unchanged.
+	content := "line1\nline2\nline3"
+	tr := TruncateTail(content, 2000, 50*1024)
+	if tr.Content != content {
+		t.Errorf("got %q, want %q", tr.Content, content)
+	}
+	if tr.Truncated {
+		t.Error("should not be marked as truncated")
+	}
+}
+
+func TestTruncateTail_LineCount(t *testing.T) {
+	lines := make([]string, 100)
+	for i := range lines {
+		lines[i] = "line"
+	}
+	content := strings.Join(lines, "\n")
+	tr := TruncateTail(content, 10, 50*1024)
+
+	if !tr.Truncated {
+		t.Error("should be marked as truncated")
+	}
+	if tr.Total != 100 {
+		t.Errorf("total = %d, want 100", tr.Total)
+	}
+	if tr.Kept != 10 {
+		t.Errorf("kept = %d, want 10", tr.Kept)
+	}
+}
+
+func TestTruncateHead_LongLines(t *testing.T) {
+	longLine := strings.Repeat("y", 5000)
+	tr := truncateHead(longLine, 2000, 50*1024)
+
+	if len(tr.Content) > defaultMaxLineLen+100 {
+		t.Errorf("single long line not truncated: got %d chars, want <= %d", len(tr.Content), defaultMaxLineLen+100)
+	}
+	if !strings.Contains(tr.Content, "chars truncated]") {
+		t.Error("truncated line should contain truncation marker")
+	}
+}
+
+func TestTruncateHead_NormalLines(t *testing.T) {
+	content := "line1\nline2\nline3"
+	tr := truncateHead(content, 2000, 50*1024)
+	if tr.Content != content {
+		t.Errorf("got %q, want %q", tr.Content, content)
+	}
+	if tr.Truncated {
+		t.Error("should not be marked as truncated")
+	}
+}
+
+func TestTruncateHead_LineCount(t *testing.T) {
+	lines := make([]string, 100)
+	for i := range lines {
+		lines[i] = "line"
+	}
+	content := strings.Join(lines, "\n")
+	tr := truncateHead(content, 10, 50*1024)
+
+	if !tr.Truncated {
+		t.Error("should be marked as truncated")
+	}
+	if tr.Total != 100 {
+		t.Errorf("total = %d, want 100", tr.Total)
+	}
+	if tr.Kept != 10 {
+		t.Errorf("kept = %d, want 10", tr.Kept)
+	}
+}
+
+func TestTruncateLongLines(t *testing.T) {
+	lines := []string{
+		"short",
+		strings.Repeat("a", 3000),
+		"also short",
+	}
+	result := truncateLongLines(lines, 100)
+
+	if result[0] != "short" {
+		t.Error("short line should be unchanged")
+	}
+	if len(result[1]) > 200 { // 100 chars + marker
+		t.Errorf("long line not truncated: len=%d", len(result[1]))
+	}
+	if !strings.Contains(result[1], "chars truncated]") {
+		t.Error("should contain truncation marker")
+	}
+	if result[2] != "also short" {
+		t.Error("short line should be unchanged")
+	}
+}
+
+func TestTruncateTail_MixedLongAndManyLines(t *testing.T) {
+	// 50 lines, each 3000 chars — tests both per-line and total truncation.
+	lines := make([]string, 50)
+	for i := range lines {
+		lines[i] = strings.Repeat("z", 3000)
+	}
+	content := strings.Join(lines, "\n")
+
+	tr := TruncateTail(content, 10, 50*1024)
+
+	// Should keep 10 lines.
+	if tr.Kept != 10 {
+		t.Errorf("kept = %d, want 10", tr.Kept)
+	}
+	// Each line should be capped at ~defaultMaxLineLen.
+	resultLines := strings.Split(tr.Content, "\n")
+	for i, line := range resultLines {
+		if len(line) > defaultMaxLineLen+100 {
+			t.Errorf("line %d too long: %d chars", i, len(line))
+		}
+	}
+}
+
+func TestTruncateLine(t *testing.T) {
+	short := "hello"
+	if truncateLine(short, 10) != short {
+		t.Error("short line should be unchanged")
+	}
+
+	long := strings.Repeat("x", 100)
+	result := truncateLine(long, 10)
+	if len(result) != 13 { // 10 + "..."
+		t.Errorf("got len %d, want 13", len(result))
+	}
+
+	// Default max for 0 — input shorter than default, so unchanged
+	result2 := truncateLine(long, 0)
+	if result2 != long {
+		t.Errorf("100-char line should be unchanged when maxChars defaults to %d", grepMaxLineLen)
+	}
+
+	// Longer input with default
+	veryLong := strings.Repeat("x", 1000)
+	result3 := truncateLine(veryLong, 0)
+	if len(result3) != grepMaxLineLen+3 {
+		t.Errorf("got len %d, want %d", len(result3), grepMaxLineLen+3)
+	}
+}

internal/extensions/api.go

@@ -174,6 +174,22 @@ type Context struct {
 	//   }
 	PromptInput func(PromptInputConfig) PromptInputResult
 
+	// PromptMultiSelect shows a multi-selection list to the user, allowing
+	// them to toggle options with spacebar and confirm with enter. In
+	// non-interactive mode, returns all options as selected.
+	//
+	// Example:
+	//
+	//   result := ctx.PromptMultiSelect(ext.PromptMultiSelectConfig{
+	//       Message: "Select extensions to install:",
+	//       Options: []string{"git", "todo", "weather"},
+	//       DefaultSelected: []int{0, 1, 2},  // All selected by default
+	//   })
+	//   if !result.Cancelled {
+	//       fmt.Println("Selected:", result.Values)
+	//   }
+	PromptMultiSelect func(PromptMultiSelectConfig) PromptMultiSelectResult
+
 	// ShowOverlay displays a modal overlay dialog that blocks until the
 	// user dismisses it or selects an action. The overlay renders as a
 	// centered (or anchored) bordered box over the TUI. Returns a
@@ -469,6 +485,36 @@ type Context struct {
 	//   ctx.RenderMessage("build-status", "All 42 tests passed.")
 	RenderMessage func(rendererName string, content string)
 
+	// RegisterTheme adds a named theme to the runtime theme registry.
+	// If a theme with the same name already exists it is replaced.
+	// The theme becomes available via /theme and ctx.SetTheme().
+	//
+	// Example:
+	//
+	//   ctx.RegisterTheme("neon", ext.ThemeColorConfig{
+	//       Primary:   ext.ThemeColor{Dark: "#FF00FF"},
+	//       Secondary: ext.ThemeColor{Dark: "#00FFFF"},
+	//       Success:   ext.ThemeColor{Dark: "#00FF00"},
+	//       Warning:   ext.ThemeColor{Dark: "#FFFF00"},
+	//       Error:     ext.ThemeColor{Dark: "#FF0000"},
+	//       Info:      ext.ThemeColor{Dark: "#00FFFF"},
+	//       Text:      ext.ThemeColor{Dark: "#FFFFFF"},
+	//       Background: ext.ThemeColor{Dark: "#000000"},
+	//   })
+	RegisterTheme func(name string, config ThemeColorConfig)
+
+	// SetTheme switches the active color theme by name. The name must
+	// match a built-in theme, a user/project theme file, or a theme
+	// registered via RegisterTheme. Returns an error if not found.
+	//
+	// Example:
+	//
+	//   err := ctx.SetTheme("neon")
+	SetTheme func(name string) error
+
+	// ListThemes returns the names of all available themes.
+	ListThemes func() []string
+
 	// ReloadExtensions hot-reloads all extensions from disk. Existing
 	// extensions receive a SessionShutdown event, then new code is loaded
 	// and receives a SessionStart event. Event handlers, commands,
@@ -526,6 +572,102 @@ type Context struct {
 	//   })
 	//   // handle.Kill() to cancel, handle.Wait() to block
 	SpawnSubagent func(SubagentConfig) (*SubagentHandle, *SubagentResult, error)
+
+	// -------------------------------------------------------------------------
+	// Tree Navigation API (Phase 1 Bridge)
+	// -------------------------------------------------------------------------
+
+	// GetTreeNode returns a node by ID with full metadata and children.
+	// Returns nil if entry not found.
+	GetTreeNode func(entryID string) *TreeNode
+
+	// GetCurrentBranch returns the path from root to current leaf.
+	// Each node contains full metadata (unlike GetMessages which flattens).
+	GetCurrentBranch func() []TreeNode
+
+	// GetChildren returns direct child IDs of an entry.
+	GetChildren func(entryID string) []string
+
+	// NavigateTo branches/forks the session to the specified entry ID.
+	// Equivalent to SDK's Branch() but for extensions.
+	NavigateTo func(entryID string) TreeNavigationResult
+
+	// SummarizeBranch uses LLM to summarize a branch range.
+	// Returns summary text or error string (empty if success).
+	SummarizeBranch func(fromID, toID string) string
+
+	// CollapseBranch replaces a branch range with a summary entry.
+	// This is the "fresh context" primitive for context window management.
+	CollapseBranch func(fromID, toID, summary string) TreeNavigationResult
+
+	// -------------------------------------------------------------------------
+	// Skill Loading API (Phase 2 Bridge)
+	// -------------------------------------------------------------------------
+
+	// LoadSkill loads a single skill file from path.
+	// Parses YAML frontmatter, returns skill with content ready for injection.
+	LoadSkill func(path string) (*Skill, string)
+
+	// LoadSkillsFromDir discovers and loads all skills from a directory.
+	LoadSkillsFromDir func(dir string) SkillLoadResult
+
+	// DiscoverSkills finds skills in standard locations.
+	// Checks ~/.config/kit/skills/, .kit/skills/, .agents/skills/
+	DiscoverSkills func() SkillLoadResult
+
+	// InjectSkillAsContext sends a skill's content as a system message.
+	// Looks up skill by name from discovered skills.
+	InjectSkillAsContext func(skillName string) string
+
+	// InjectRawSkillAsContext loads and immediately injects a skill file.
+	InjectRawSkillAsContext func(path string) string
+
+	// GetAvailableSkills returns all currently loaded/discovered skills.
+	GetAvailableSkills func() []Skill
+
+	// -------------------------------------------------------------------------
+	// Template Parsing API (Phase 3 Bridge)
+	// -------------------------------------------------------------------------
+
+	// ParseTemplate extracts {{variables}} from template content.
+	ParseTemplate func(name, content string) PromptTemplate
+
+	// RenderTemplate substitutes variables into template content.
+	RenderTemplate func(tpl PromptTemplate, vars map[string]string) string
+
+	// ParseArguments parses command-line style arguments.
+	ParseArguments func(input string, pattern ArgumentPattern) ParseResult
+
+	// SimpleParseArguments parses $1, $2, $@ style arguments.
+	// Returns slice where [0]=full input, [1]=$1, [2]=$2, ... [n]=$@
+	SimpleParseArguments func(input string, count int) []string
+
+	// EvaluateModelConditional checks if condition matches current model.
+	// Condition supports wildcards: * matches any, ? matches single char.
+	EvaluateModelConditional func(condition string) bool
+
+	// RenderWithModelConditionals processes <if-model> blocks in content.
+	RenderWithModelConditionals func(content string) string
+
+	// -------------------------------------------------------------------------
+	// Model Resolution API (Phase 4 Bridge)
+	// -------------------------------------------------------------------------
+
+	// ResolveModelChain attempts each model in order until one is available.
+	ResolveModelChain func(preferences []string) ModelResolutionResult
+
+	// GetModelCapabilities returns capabilities for a specific model.
+	// If model is empty, uses current model.
+	GetModelCapabilities func(model string) (ModelCapabilities, string)
+
+	// CheckModelAvailable verifies if a model string is valid.
+	CheckModelAvailable func(model string) bool
+
+	// GetCurrentProvider returns just the provider part of current model.
+	GetCurrentProvider func() string
+
+	// GetCurrentModelID returns just the model ID part of current model.
+	GetCurrentModelID func() string
 }
 
 // ---------------------------------------------------------------------------
@@ -552,6 +694,148 @@ type SessionMessage struct {
 	Timestamp string
 }
 
+// ---------------------------------------------------------------------------
+// Tree navigation types (exposed to Yaegi — concrete structs)
+// ---------------------------------------------------------------------------
+
+// TreeNode represents a node in the session tree for navigation.
+// Extensions use this to traverse conversation history and implement
+// features like "fresh context" loops and branch summarization.
+type TreeNode struct {
+	// ID is the unique entry identifier.
+	ID string
+	// ParentID links this entry to its parent (empty if root).
+	ParentID string
+	// Type is the entry type: "message", "branch_summary", "model_change", "extension_data", "tool_execution".
+	Type string
+	// Role is the message role for message entries: "user", "assistant", "system", "tool".
+	Role string
+	// Content is the text content or summary.
+	Content string
+	// Model is the model that generated this (for assistant messages).
+	Model string
+	// Provider is the provider used.
+	Provider string
+	// Timestamp is the RFC3339-formatted creation time.
+	Timestamp string
+	// Children is the list of child entry IDs for tree traversal.
+	Children []string
+}
+
+// TreeNavigationResult reports success or failure of tree operations.
+type TreeNavigationResult struct {
+	// Success is true if the operation completed.
+	Success bool
+	// Error describes what went wrong (empty if success).
+	Error string
+}
+
+// ---------------------------------------------------------------------------
+// Skill types (exposed to Yaegi — concrete structs)
+// ---------------------------------------------------------------------------
+
+// Skill represents a loaded skill file with parsed YAML frontmatter.
+type Skill struct {
+	// Name is the human-readable identifier.
+	Name string
+	// Description summarizes what this skill provides.
+	Description string
+	// Content is the markdown body (frontmatter stripped).
+	Content string
+	// Path is the absolute filesystem path.
+	Path string
+	// Tags are optional labels for categorization.
+	Tags []string
+	// When controls automatic inclusion: "always", "on-demand", or file-glob.
+	When string
+}
+
+// SkillLoadResult reports skills loaded from a directory.
+type SkillLoadResult struct {
+	// Skills is the list of loaded skills.
+	Skills []Skill
+	// Error describes loading failures (empty if success).
+	Error string
+}
+
+// ---------------------------------------------------------------------------
+// Template parsing types (exposed to Yaegi — concrete structs)
+// ---------------------------------------------------------------------------
+
+// PromptTemplate represents a parsed template with variable placeholders.
+type PromptTemplate struct {
+	// Name is the template identifier.
+	Name string
+	// Content is the original template content.
+	Content string
+	// Variables are the extracted {{variable}} names.
+	Variables []string
+}
+
+// ArgumentPattern defines how to parse command arguments.
+type ArgumentPattern struct {
+	// Positional names for $1, $2, etc.
+	Positional []string
+	// Rest is the variable name for $@ (all remaining).
+	Rest string
+	// Flags maps flag names to variable names (e.g., "--loop" -> "loop").
+	Flags map[string]string
+}
+
+// ParseResult reports argument parsing outcome.
+type ParseResult struct {
+	// Vars maps variable names to values for positional args.
+	Vars map[string]string
+	// Flags maps flag names to values.
+	Flags map[string]string
+	// Rest is remaining unparsed text.
+	Rest string
+	// Error describes parsing failures (empty if success).
+	Error string
+}
+
+// ModelConditional represents an <if-model> block for evaluation.
+type ModelConditional struct {
+	// Condition is the model pattern (e.g., "claude-*", "anthropic/*").
+	Condition string
+	// Content is rendered if condition matches.
+	Content string
+	// Else is rendered if condition doesn't match.
+	Else string
+}
+
+// ---------------------------------------------------------------------------
+// Model resolution types (exposed to Yaegi — concrete structs)
+// ---------------------------------------------------------------------------
+
+// ModelCapabilities describes what a model supports.
+type ModelCapabilities struct {
+	// Provider is the provider ID (e.g., "anthropic").
+	Provider string
+	// ModelID is the model identifier (e.g., "claude-sonnet-4-20250929").
+	ModelID string
+	// ContextLimit is the maximum context window in tokens.
+	ContextLimit int
+	// OutputLimit is the maximum output tokens.
+	OutputLimit int
+	// Reasoning indicates if the model supports reasoning/thinking.
+	Reasoning bool
+	// Streaming indicates if the model supports streaming.
+	Streaming bool
+}
+
+// ModelResolutionResult reports model chain resolution outcome.
+type ModelResolutionResult struct {
+	// Model is the selected model in "provider/model" format.
+	Model string
+	// Capabilities describes the selected model.
+	Capabilities ModelCapabilities
+	// Attempted lists models tried before success.
+	Attempted []string
+	// Error describes resolution failures (empty if success).
+	Error string
+}
+
 // ExtensionEntry represents persisted extension data stored in the session.
 // Extensions use AppendEntry to save custom state and GetEntries to retrieve
 // it on session resume.
@@ -681,6 +965,7 @@ type API struct {
 	onToolCall                func(func(ToolCallEvent, Context) *ToolCallResult)
 	onToolExecStart           func(func(ToolExecutionStartEvent, Context))
 	onToolExecEnd             func(func(ToolExecutionEndEvent, Context))
+	onToolOutput              func(func(ToolOutputEvent, Context))
 	onToolResult              func(func(ToolResultEvent, Context) *ToolResultResult)
 	onInput                   func(func(InputEvent, Context) *InputResult)
 	onBeforeAgentStart        func(func(BeforeAgentStartEvent, Context) *BeforeAgentStartResult)
@@ -703,6 +988,9 @@ type API struct {
 	registerOption            func(OptionDef)
 	registerShortcutFn        func(ShortcutDef, func(Context))
 	registerMessageRendererFn func(MessageRendererConfig)
+	onSubagentStart           func(func(SubagentStartEvent, Context))
+	onSubagentChunk           func(func(SubagentChunkEvent, Context))
+	onSubagentEnd             func(func(SubagentEndEvent, Context))
 }
 
 // OnToolCall registers a handler that fires before a tool executes.
@@ -721,12 +1009,40 @@ func (a *API) OnToolExecutionEnd(handler func(ToolExecutionEndEvent, Context)) {
 	a.onToolExecEnd(handler)
 }
 
+// OnToolOutput registers a handler for streaming tool output chunks.
+// This fires for each output line as it arrives from tools like bash,
+// allowing extensions to observe or process output in real-time.
+func (a *API) OnToolOutput(handler func(ToolOutputEvent, Context)) {
+	a.onToolOutput(handler)
+}
+
 // OnToolResult registers a handler that fires after tool execution.
 // Return a non-nil ToolResultResult to modify the output.
 func (a *API) OnToolResult(handler func(ToolResultEvent, Context) *ToolResultResult) {
 	a.onToolResult(handler)
 }
 
+// OnSubagentStart registers a handler that fires when a subagent tool
+// call begins executing. Use the ToolCallID to correlate with subsequent
+// OnSubagentChunk and OnSubagentEnd events for the same subagent.
+func (a *API) OnSubagentStart(handler func(SubagentStartEvent, Context)) {
+	a.onSubagentStart(handler)
+}
+
+// OnSubagentChunk registers a handler for real-time events from a running
+// subagent. ChunkType identifies the kind of event ("text", "tool_call",
+// "tool_result", "tool_execution_start", "tool_execution_end", etc.).
+// Correlate with OnSubagentStart via the ToolCallID field.
+func (a *API) OnSubagentChunk(handler func(SubagentChunkEvent, Context)) {
+	a.onSubagentChunk(handler)
+}
+
+// OnSubagentEnd registers a handler that fires when a subagent call
+// completes. ErrorMsg is non-empty when the subagent failed.
+func (a *API) OnSubagentEnd(handler func(SubagentEndEvent, Context)) {
+	a.onSubagentEnd(handler)
+}
+
 // OnInput registers a handler that fires when user input is received.
 // Return a non-nil InputResult to transform or handle the input.
 func (a *API) OnInput(handler func(InputEvent, Context) *InputResult) {
@@ -1000,6 +1316,29 @@ type PromptInputResult struct {
 	Cancelled bool
 }
 
+// PromptMultiSelectConfig configures a multi-selection prompt that allows
+// the user to toggle multiple options and confirm their selection.
+type PromptMultiSelectConfig struct {
+	// Message is the question or instruction displayed to the user.
+	Message string
+	// Options is the list of choices the user can select from.
+	Options []string
+	// DefaultSelected contains indices of options that should be
+	// pre-selected when the prompt appears. If nil, all options are selected.
+	DefaultSelected []int
+}
+
+// PromptMultiSelectResult is the response from a multi-selection prompt.
+type PromptMultiSelectResult struct {
+	// Values contains the text of selected options.
+	Values []string
+	// Indices contains the zero-based indices of selected options.
+	Indices []int
+	// Cancelled is true if the user dismissed the prompt (ESC) or
+	// the prompt was unavailable (non-interactive mode).
+	Cancelled bool
+}
+
 // ---------------------------------------------------------------------------
 // Header/Footer types (exposed to Yaegi — concrete structs)
 // ---------------------------------------------------------------------------
@@ -1469,6 +1808,19 @@ type ToolExecutionEndEvent struct {
 
 func (e ToolExecutionEndEvent) Type() EventType { return ToolExecutionEnd }
 
+// ToolOutputEvent fires when a tool produces streaming output chunks.
+// This is primarily used for long-running tools like bash to show output
+// in real-time as it arrives, before the tool completes.
+type ToolOutputEvent struct {
+	ToolCallID string
+	ToolName   string
+	ToolKind   string
+	Chunk      string // Output text chunk
+	IsStderr   bool   // Whether this chunk came from stderr
+}
+
+func (e ToolOutputEvent) Type() EventType { return ToolOutput }
+
 // ToolResultEvent fires after tool execution with the output.
 type ToolResultEvent struct {
 	ToolCallID string
@@ -1674,13 +2026,115 @@ type BeforeCompactEvent struct {
 func (e BeforeCompactEvent) Type() EventType { return BeforeCompact }
 
 // BeforeCompactResult controls whether compaction proceeds. Return
-// Cancel=true with an optional Reason to block compaction.
+// Cancel=true with an optional Reason to block compaction, or provide
+// a custom Summary to replace the default LLM-generated one.
 type BeforeCompactResult struct {
 	// Cancel, when true, prevents compaction from proceeding.
 	Cancel bool
 	// Reason is a human-readable explanation shown to the user when
 	// Cancel is true. Empty string uses a default message.
 	Reason string
+	// Summary, when non-empty, replaces the default LLM-generated summary.
+	// The extension is responsible for generating a useful summary.
+	// Ignored when Cancel is true.
+	Summary string
 }
 
 func (BeforeCompactResult) isResult() {}
+
+// ---------------------------------------------------------------------------
+// Subagent lifecycle events (exposed to Yaegi — concrete structs)
+// ---------------------------------------------------------------------------
+
+// SubagentStartEvent fires when a subagent tool call begins executing.
+type SubagentStartEvent struct {
+	// ToolCallID is the LLM-assigned ID of the subagent tool call.
+	// Use this to correlate SubagentChunkEvent and SubagentEndEvent.
+	ToolCallID string
+	// Task is the task description passed to the subagent.
+	Task string
+}
+
+func (e SubagentStartEvent) Type() EventType { return SubagentStart }
+
+// SubagentChunkEvent fires for each real-time event from a running subagent.
+// Type field indicates the kind of event; read the relevant fields accordingly.
+type SubagentChunkEvent struct {
+	// ToolCallID matches the SubagentStartEvent.ToolCallID for this subagent.
+	ToolCallID string
+	// Task is the task description (repeated for convenience).
+	Task string
+	// ChunkType identifies the event kind:
+	//   "text"                 — LLM text chunk (read Content)
+	//   "reasoning"            — reasoning/thinking delta (read Content)
+	//   "tool_call"            — subagent called a tool (read ToolName, ToolArgs)
+	//   "tool_result"          — tool returned a result (read ToolName, ToolResult, IsError)
+	//   "tool_execution_start" — tool began executing (read ToolName)
+	//   "tool_execution_end"   — tool finished executing (read ToolName)
+	//   "turn_start"           — subagent turn began
+	//   "turn_end"             — subagent turn ended
+	ChunkType string
+	// Content carries text for "text" and "reasoning" chunk types.
+	Content string
+	// ToolName is set on tool-related chunk types.
+	ToolName string
+	// ToolArgs is the JSON-encoded tool arguments for "tool_call" chunks.
+	ToolArgs string
+	// ToolResult is the tool output for "tool_result" chunks.
+	ToolResult string
+	// IsError is true when a "tool_result" chunk represents an error.
+	IsError bool
+}
+
+func (e SubagentChunkEvent) Type() EventType { return SubagentChunk }
+
+// SubagentEndEvent fires when a subagent tool call completes.
+type SubagentEndEvent struct {
+	// ToolCallID matches the SubagentStartEvent.ToolCallID for this subagent.
+	ToolCallID string
+	// Task is the task description.
+	Task string
+	// Response is the subagent's final text response (empty on error).
+	Response string
+	// ErrorMsg is non-empty when the subagent failed.
+	ErrorMsg string
+}
+
+func (e SubagentEndEvent) Type() EventType { return SubagentEnd }
+
+// ThemeColor is an adaptive color pair with light and dark hex values.
+// Either field may be empty to inherit from the default theme.
+type ThemeColor struct {
+	Light string
+	Dark  string
+}
+
+// ThemeColorConfig defines a complete color theme that extensions can register
+// programmatically via ctx.RegisterTheme(). Uses plain hex strings (not
+// color.Color) so the type is safe to pass across the Yaegi boundary.
+type ThemeColorConfig struct {
+	Primary     ThemeColor
+	Secondary   ThemeColor
+	Success     ThemeColor
+	Warning     ThemeColor
+	Error       ThemeColor
+	Info        ThemeColor
+	Text        ThemeColor
+	Muted       ThemeColor
+	VeryMuted   ThemeColor
+	Background  ThemeColor
+	Border      ThemeColor
+	MutedBorder ThemeColor
+	System      ThemeColor
+	Tool        ThemeColor
+	Accent      ThemeColor
+	Highlight   ThemeColor
+
+	// Markdown/syntax highlighting overrides.
+	MdHeading ThemeColor
+	MdLink    ThemeColor
+	MdKeyword ThemeColor
+	MdString  ThemeColor
+	MdNumber  ThemeColor
+	MdComment ThemeColor
+}

internal/extensions/events.go

@@ -19,6 +19,9 @@ const (
 	// ToolExecutionEnd fires when a tool finishes executing.
 	ToolExecutionEnd EventType = "tool_execution_end"
 
+	// ToolOutput fires when a tool produces streaming output chunks.
+	ToolOutput EventType = "tool_output"
+
 	// ToolResult fires after a tool executes. Handlers can modify the result.
 	ToolResult EventType = "tool_result"
 
@@ -68,6 +71,18 @@ const (
 	// BeforeCompact fires before context compaction runs. Handlers can
 	// cancel compaction by returning Cancel=true.
 	BeforeCompact EventType = "before_compact"
+
+	// SubagentStart fires when a subagent tool call begins executing.
+	// Carries the tool call ID and the task description.
+	SubagentStart EventType = "subagent_start"
+
+	// SubagentChunk fires for each real-time event emitted by a running
+	// subagent: text chunks, tool calls, tool results, etc.
+	SubagentChunk EventType = "subagent_chunk"
+
+	// SubagentEnd fires when a subagent tool call completes (success
+	// or error). Carries the final response and any error message.
+	SubagentEnd EventType = "subagent_end"
 )
 
 // AllEventTypes returns every supported event type.
@@ -79,6 +94,7 @@ func AllEventTypes() []EventType {
 		SessionStart, SessionShutdown,
 		ModelChange, ContextPrepare,
 		BeforeFork, BeforeSessionSwitch, BeforeCompact,
+		SubagentStart, SubagentChunk, SubagentEnd,
 	}
 }
 

internal/extensions/events_test.go

@@ -4,8 +4,8 @@ import "testing"
 
 func TestAllEventTypes_Count(t *testing.T) {
 	all := AllEventTypes()
-	if len(all) != 18 {
-		t.Fatalf("expected 18 event types, got %d", len(all))
+	if len(all) != 21 {
+		t.Fatalf("expected 21 event types, got %d", len(all))
 	}
 }
 
@@ -55,6 +55,9 @@ func TestEventType_TypeMethod(t *testing.T) {
 		{BeforeForkEvent{TargetID: "abc"}, BeforeFork},
 		{BeforeSessionSwitchEvent{Reason: "new"}, BeforeSessionSwitch},
 		{BeforeCompactEvent{EstimatedTokens: 1000}, BeforeCompact},
+		{SubagentStartEvent{ToolCallID: "x", Task: "t"}, SubagentStart},
+		{SubagentChunkEvent{ToolCallID: "x", ChunkType: "text"}, SubagentChunk},
+		{SubagentEndEvent{ToolCallID: "x"}, SubagentEnd},
 	}
 
 	for _, tt := range tests {

internal/extensions/installer.go

@@ -0,0 +1,537 @@
+package extensions
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// InstallScope defines where a package should be installed.
+type InstallScope string
+
+const (
+	ScopeGlobal  InstallScope = "global"
+	ScopeProject InstallScope = "project"
+)
+
+// GitSource represents a parsed git repository URL.
+type GitSource struct {
+	Repo   string // Clone URL (e.g., https://github.com/user/repo.git)
+	Host   string // Host (e.g., github.com)
+	Path   string // Path (e.g., user/repo)
+	Ref    string // Optional ref (tag, branch, commit)
+	Pinned bool   // Whether a specific ref is pinned
+}
+
+// String returns the canonical string representation.
+func (g GitSource) String() string {
+	if g.Pinned {
+		return fmt.Sprintf("git:%s/%s@%s", g.Host, g.Path, g.Ref)
+	}
+	return fmt.Sprintf("git:%s/%s", g.Host, g.Path)
+}
+
+// Identity returns a normalized identity string for deduplication.
+func (g GitSource) Identity() string {
+	return fmt.Sprintf("%s/%s", g.Host, g.Path)
+}
+
+// ParseGitSource parses a git source string into a GitSource.
+// Supports formats like:
+//   - git:github.com/user/repo
+//   - git:github.com/user/repo@v1.0.0
+//   - https://github.com/user/repo
+//   - https://github.com/user/repo@v1.0.0
+//   - ssh://git@github.com/user/repo
+//   - git@github.com:user/repo
+//   - github.com/user/repo (shorthand, defaults to https)
+func ParseGitSource(source string) (*GitSource, error) {
+	source = strings.TrimSpace(source)
+
+	// Check for @ref suffix
+	ref := ""
+	pinned := false
+	if atIdx := strings.LastIndex(source, "@"); atIdx > 0 {
+		// Make sure it's not part of the protocol (e.g., @ in ssh://git@)
+		after := source[atIdx+1:]
+		if !strings.Contains(after, "/") && !strings.Contains(after, ":") {
+			ref = after
+			pinned = true
+			source = source[:atIdx]
+		}
+	}
+
+	// Handle git: prefix
+	source, _ = strings.CutPrefix(source, "git:")
+
+	var repo, host, path string
+
+	// Handle explicit URLs
+	if strings.HasPrefix(source, "http://") || strings.HasPrefix(source, "https://") {
+		u, err := url.Parse(source)
+		if err != nil {
+			return nil, fmt.Errorf("invalid URL: %w", err)
+		}
+		host = u.Host
+		path = strings.TrimPrefix(u.Path, "/")
+		path, _ = strings.CutSuffix(path, ".git")
+		repo = source
+		if !strings.HasSuffix(repo, ".git") {
+			repo += ".git"
+		}
+	} else if strings.HasPrefix(source, "ssh://") {
+		u, err := url.Parse(source)
+		if err != nil {
+			return nil, fmt.Errorf("invalid SSH URL: %w", err)
+		}
+		host = u.Host
+		path = strings.TrimPrefix(u.Path, "/")
+		path, _ = strings.CutSuffix(path, ".git")
+		repo = source
+	} else if strings.HasPrefix(source, "git@") {
+		// SSH shorthand: git@github.com:user/repo
+		parts := strings.SplitN(source, ":", 2)
+		if len(parts) != 2 {
+			return nil, fmt.Errorf("invalid SSH shorthand format")
+		}
+		host = strings.TrimPrefix(parts[0], "git@")
+		path = parts[1]
+		path, _ = strings.CutSuffix(path, ".git")
+		repo = source
+	} else if strings.HasPrefix(source, "github.com/") || strings.HasPrefix(source, "gitlab.com/") || strings.HasPrefix(source, "bitbucket.org/") {
+		// Shorthand for known hosts: host/path
+		parts := strings.SplitN(source, "/", 2)
+		if len(parts) != 2 {
+			return nil, fmt.Errorf("invalid shorthand format, expected host/path")
+		}
+		host = parts[0]
+		path = parts[1]
+		repo = fmt.Sprintf("https://%s/%s.git", host, path)
+	} else if strings.HasPrefix(source, ".") || strings.HasPrefix(source, "/") || strings.HasPrefix(source, "~") {
+		// Local paths are not supported
+		return nil, fmt.Errorf("local paths not supported, use explicit extension path with -e flag")
+	} else {
+		// Generic shorthand: host/user/repo (3+ path segments)
+		parts := strings.Split(source, "/")
+		if len(parts) >= 3 {
+			host = parts[0]
+			path = strings.Join(parts[1:], "/")
+			repo = fmt.Sprintf("https://%s/%s.git", host, path)
+		} else {
+			return nil, fmt.Errorf("unrecognized source format: %s", source)
+		}
+	}
+
+	return &GitSource{
+		Repo:   repo,
+		Host:   host,
+		Path:   path,
+		Ref:    ref,
+		Pinned: pinned,
+	}, nil
+}
+
+// Installer handles installing, updating, and removing git-based extensions.
+type Installer struct {
+	// Global packages root: $XDG_DATA_HOME/kit/git/ (default ~/.local/share/kit/git/)
+	globalGitRoot string
+	// Project packages root: .kit/git/
+	projectGitRoot string
+}
+
+// NewInstaller creates a new Installer.
+func NewInstaller(projectDir string) *Installer {
+	return &Installer{
+		globalGitRoot:  globalGitInstallRoot(),
+		projectGitRoot: filepath.Join(projectDir, ".kit", "git"),
+	}
+}
+
+// Install clones a git repository to the appropriate scope.
+func (i *Installer) Install(source *GitSource, scope InstallScope) error {
+	targetDir := i.getInstallPath(source, scope)
+
+	// Check if already installed
+	if _, err := os.Stat(targetDir); err == nil {
+		return fmt.Errorf("extension already installed at %s", targetDir)
+	}
+
+	// Ensure parent directory exists
+	if err := os.MkdirAll(filepath.Dir(targetDir), 0755); err != nil {
+		return fmt.Errorf("creating parent directory: %w", err)
+	}
+
+	// Clone the repository
+	cmd := exec.Command("git", "clone", "--depth=1", source.Repo, targetDir)
+	if output, err := cmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("git clone failed: %w\n%s", err, string(output))
+	}
+
+	// Checkout specific ref if pinned
+	if source.Pinned && source.Ref != "" {
+		checkoutCmd := exec.Command("git", "checkout", source.Ref)
+		checkoutCmd.Dir = targetDir
+		if output, err := checkoutCmd.CombinedOutput(); err != nil {
+			// Clean up on failed checkout
+			_ = os.RemoveAll(targetDir)
+			return fmt.Errorf("git checkout failed: %w\n%s", err, string(output))
+		}
+	}
+
+	// Validate that the package contains valid extensions
+	if err := i.validatePackage(targetDir); err != nil {
+		_ = os.RemoveAll(targetDir)
+		return fmt.Errorf("validation failed: %w", err)
+	}
+
+	// Add to manifest
+	entry := ManifestEntry{
+		Source:    source.String(),
+		Repo:      source.Repo,
+		Host:      source.Host,
+		Path:      source.Path,
+		Ref:       source.Ref,
+		Pinned:    source.Pinned,
+		Scope:     scope,
+		Installed: time.Now(),
+	}
+	if err := i.addToManifest(entry, scope); err != nil {
+		// Don't fail the install, just log the error
+		// The package is installed, manifest update failed
+		return fmt.Errorf("installed but failed to update manifest: %w", err)
+	}
+
+	return nil
+}
+
+// Uninstall removes an installed package.
+func (i *Installer) Uninstall(source *GitSource, scope InstallScope) error {
+	targetDir := i.getInstallPath(source, scope)
+
+	if _, err := os.Stat(targetDir); err != nil {
+		return fmt.Errorf("extension not found at %s", targetDir)
+	}
+
+	// Remove the directory
+	if err := os.RemoveAll(targetDir); err != nil {
+		return fmt.Errorf("removing extension directory: %w", err)
+	}
+
+	// Remove from manifest
+	if err := i.removeFromManifest(source.Identity(), scope); err != nil {
+		return fmt.Errorf("removed but failed to update manifest: %w", err)
+	}
+
+	return nil
+}
+
+// Update fetches and resets a git package to the latest.
+// For pinned packages, this does nothing.
+func (i *Installer) Update(source *GitSource, scope InstallScope) error {
+	if source.Pinned {
+		return nil // Don't update pinned packages
+	}
+
+	targetDir := i.getInstallPath(source, scope)
+
+	if _, err := os.Stat(targetDir); err != nil {
+		return i.Install(source, scope)
+	}
+
+	// Fetch latest
+	fetchCmd := exec.Command("git", "fetch", "--prune", "origin")
+	fetchCmd.Dir = targetDir
+	if output, err := fetchCmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("git fetch failed: %w\n%s", err, string(output))
+	}
+
+	// Reset to tracking branch or origin/HEAD
+	resetCmd := exec.Command("git", "reset", "--hard", "@{upstream}")
+	resetCmd.Dir = targetDir
+	if _, err := resetCmd.CombinedOutput(); err != nil {
+		// Try alternative: set HEAD and reset to origin/HEAD
+		_ = exec.Command("git", "remote", "set-head", "origin", "-a").Run()
+		resetCmd = exec.Command("git", "reset", "--hard", "origin/HEAD")
+		resetCmd.Dir = targetDir
+		if output, err := resetCmd.CombinedOutput(); err != nil {
+			return fmt.Errorf("git reset failed: %w\n%s", err, string(output))
+		}
+	}
+
+	// Clean untracked files
+	cleanCmd := exec.Command("git", "clean", "-fdx")
+	cleanCmd.Dir = targetDir
+	_ = cleanCmd.Run() // Ignore errors - clean is best effort
+
+	// Update manifest timestamp
+	entry := ManifestEntry{
+		Source:    source.String(),
+		Repo:      source.Repo,
+		Host:      source.Host,
+		Path:      source.Path,
+		Ref:       "",
+		Pinned:    false,
+		Scope:     scope,
+		Installed: time.Now(),
+		Updated:   time.Now(),
+	}
+	_ = i.addToManifest(entry, scope) // Best effort - don't fail update if manifest fails
+
+	return nil
+}
+
+// getInstallPath returns the target directory for a source.
+func (i *Installer) getInstallPath(source *GitSource, scope InstallScope) string {
+	root := i.globalGitRoot
+	if scope == ScopeProject {
+		root = i.projectGitRoot
+	}
+	return filepath.Join(root, source.Host, source.Path)
+}
+
+// validatePackage checks that the cloned repo contains valid .go extension files.
+func (i *Installer) validatePackage(dir string) error {
+	// Find all .go files in the directory
+	var goFiles []string
+	err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() && strings.HasSuffix(info.Name(), ".go") {
+			goFiles = append(goFiles, path)
+		}
+		return nil
+	})
+	if err != nil {
+		return fmt.Errorf("walking directory: %w", err)
+	}
+
+	if len(goFiles) == 0 {
+		return fmt.Errorf("no .go files found in package")
+	}
+
+	// Try to load the first .go file to validate it's a valid extension
+	// We don't fail if validation fails - the extension might be fine but
+	// have dependencies that aren't available during install time
+	_, err = loadSingleExtension(goFiles[0])
+	if err != nil {
+		// Log but don't fail - the extension might need runtime deps
+		// User can use `kit extensions validate` to check later
+		return nil
+	}
+
+	return nil
+}
+
+// addToManifest adds an entry to the manifest.
+func (i *Installer) addToManifest(entry ManifestEntry, scope InstallScope) error {
+	manifest, err := i.loadManifest(scope)
+	if err != nil {
+		return err
+	}
+
+	// Remove any existing entry with same identity
+	identity := entry.Host + "/" + entry.Path
+	filtered := make([]ManifestEntry, 0, len(manifest.Packages))
+	for _, p := range manifest.Packages {
+		if p.Host+"/"+p.Path != identity {
+			filtered = append(filtered, p)
+		}
+	}
+	filtered = append(filtered, entry)
+	manifest.Packages = filtered
+
+	return i.saveManifest(manifest, scope)
+}
+
+// removeFromManifest removes an entry from the manifest by identity.
+func (i *Installer) removeFromManifest(identity string, scope InstallScope) error {
+	manifest, err := i.loadManifest(scope)
+	if err != nil {
+		return err
+	}
+
+	filtered := make([]ManifestEntry, 0, len(manifest.Packages))
+	for _, p := range manifest.Packages {
+		if p.Host+"/"+p.Path != identity {
+			filtered = append(filtered, p)
+		}
+	}
+	manifest.Packages = filtered
+
+	return i.saveManifest(manifest, scope)
+}
+
+// loadManifest loads the manifest for the given scope.
+func (i *Installer) loadManifest(scope InstallScope) (*Manifest, error) {
+	path := i.manifestPath(scope)
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return &Manifest{Packages: []ManifestEntry{}}, nil
+		}
+		return nil, err
+	}
+
+	var manifest Manifest
+	if err := json.Unmarshal(data, &manifest); err != nil {
+		return nil, fmt.Errorf("parsing manifest: %w", err)
+	}
+
+	return &manifest, nil
+}
+
+// saveManifest saves the manifest for the given scope.
+func (i *Installer) saveManifest(manifest *Manifest, scope InstallScope) error {
+	path := i.manifestPath(scope)
+
+	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+		return fmt.Errorf("creating manifest directory: %w", err)
+	}
+
+	data, err := json.MarshalIndent(manifest, "", "  ")
+	if err != nil {
+		return fmt.Errorf("encoding manifest: %w", err)
+	}
+
+	if err := os.WriteFile(path, data, 0644); err != nil {
+		return fmt.Errorf("writing manifest: %w", err)
+	}
+
+	return nil
+}
+
+// manifestPath returns the path to the manifest file.
+func (i *Installer) manifestPath(scope InstallScope) string {
+	if scope == ScopeProject {
+		return filepath.Join(i.projectGitRoot, "packages.json")
+	}
+	return filepath.Join(i.globalGitRoot, "packages.json")
+}
+
+// globalGitInstallRoot returns the global git install root.
+func globalGitInstallRoot() string {
+	base := os.Getenv("XDG_DATA_HOME")
+	if base == "" {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return ""
+		}
+		base = filepath.Join(home, ".local", "share")
+	}
+	return filepath.Join(base, "kit", "git")
+}
+
+// GetInstalledPackages returns all installed packages from both scopes.
+func (i *Installer) GetInstalledPackages() ([]ManifestEntry, error) {
+	var all []ManifestEntry
+
+	global, err := i.loadManifest(ScopeGlobal)
+	if err != nil {
+		return nil, fmt.Errorf("loading global manifest: %w", err)
+	}
+	all = append(all, global.Packages...)
+
+	project, err := i.loadManifest(ScopeProject)
+	if err != nil {
+		return nil, fmt.Errorf("loading project manifest: %w", err)
+	}
+	all = append(all, project.Packages...)
+
+	return all, nil
+}
+
+// IsInstalled checks if a package is installed in either scope.
+// Returns (scope, true) if installed, ("", false) otherwise.
+func (i *Installer) IsInstalled(source *GitSource) (InstallScope, bool) {
+	globalPath := i.getInstallPath(source, ScopeGlobal)
+	if _, err := os.Stat(globalPath); err == nil {
+		return ScopeGlobal, true
+	}
+
+	projectPath := i.getInstallPath(source, ScopeProject)
+	if _, err := os.Stat(projectPath); err == nil {
+		return ScopeProject, true
+	}
+
+	return "", false
+}
+
+// PreviewExtensions clones a repo to a temporary directory and scans for extensions.
+// Returns the preview list and the temp directory path (caller should clean up).
+func (i *Installer) PreviewExtensions(source *GitSource) ([]ExtensionPreview, string, error) {
+	// Create temp directory
+	tempDir, err := os.MkdirTemp("", "kit-install-preview-*")
+	if err != nil {
+		return nil, "", fmt.Errorf("creating temp directory: %w", err)
+	}
+
+	// Clone to temp
+	cloneDir := filepath.Join(tempDir, "repo")
+	cmd := exec.Command("git", "clone", "--depth=1", source.Repo, cloneDir)
+	if output, err := cmd.CombinedOutput(); err != nil {
+		_ = os.RemoveAll(tempDir)
+		return nil, "", fmt.Errorf("git clone failed: %w\n%s", err, string(output))
+	}
+
+	// Checkout specific ref if pinned
+	if source.Pinned && source.Ref != "" {
+		checkoutCmd := exec.Command("git", "checkout", source.Ref)
+		checkoutCmd.Dir = cloneDir
+		if output, err := checkoutCmd.CombinedOutput(); err != nil {
+			_ = os.RemoveAll(tempDir)
+			return nil, "", fmt.Errorf("git checkout failed: %w\n%s", err, string(output))
+		}
+	}
+
+	// Scan for extensions
+	previews, err := ScanForExtensions(cloneDir)
+	if err != nil {
+		_ = os.RemoveAll(tempDir)
+		return nil, "", fmt.Errorf("scanning extensions: %w", err)
+	}
+
+	return previews, tempDir, nil
+}
+
+// InstallWithInclude clones a repo and installs only the specified extensions.
+// includePaths are relative paths like "./git/main.go" - if empty, installs all.
+func (i *Installer) InstallWithInclude(source *GitSource, scope InstallScope, includePaths []string) error {
+	// First, do a regular install
+	if err := i.Install(source, scope); err != nil {
+		return err
+	}
+
+	// If specific includes were requested, update the manifest
+	if len(includePaths) > 0 {
+		entry := ManifestEntry{
+			Source:  source.String(),
+			Repo:    source.Repo,
+			Host:    source.Host,
+			Path:    source.Path,
+			Ref:     source.Ref,
+			Pinned:  source.Pinned,
+			Scope:   scope,
+			Include: includePaths,
+		}
+
+		if err := addEntryToManifest(entry, scope); err != nil {
+			return fmt.Errorf("updating manifest with includes: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// CleanupTempDir removes a temporary directory used for preview.
+func CleanupTempDir(tempDir string) {
+	if tempDir != "" {
+		_ = os.RemoveAll(tempDir)
+	}
+}

internal/extensions/installer_test.go

@@ -0,0 +1,392 @@
+package extensions
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestParseGitSource(t *testing.T) {
+	tests := []struct {
+		name       string
+		source     string
+		wantRepo   string
+		wantHost   string
+		wantPath   string
+		wantRef    string
+		wantPinned bool
+		wantErr    bool
+	}{
+		{
+			name:       "github shorthand",
+			source:     "github.com/user/repo",
+			wantRepo:   "https://github.com/user/repo.git",
+			wantHost:   "github.com",
+			wantPath:   "user/repo",
+			wantRef:    "",
+			wantPinned: false,
+		},
+		{
+			name:       "github shorthand with version",
+			source:     "github.com/user/repo@v1.0.0",
+			wantRepo:   "https://github.com/user/repo.git",
+			wantHost:   "github.com",
+			wantPath:   "user/repo",
+			wantRef:    "v1.0.0",
+			wantPinned: true,
+		},
+		{
+			name:       "git prefix shorthand",
+			source:     "git:github.com/user/repo",
+			wantRepo:   "https://github.com/user/repo.git",
+			wantHost:   "github.com",
+			wantPath:   "user/repo",
+			wantRef:    "",
+			wantPinned: false,
+		},
+		{
+			name:       "https URL",
+			source:     "https://github.com/user/repo",
+			wantRepo:   "https://github.com/user/repo.git",
+			wantHost:   "github.com",
+			wantPath:   "user/repo",
+			wantRef:    "",
+			wantPinned: false,
+		},
+		{
+			name:       "https URL with .git suffix",
+			source:     "https://github.com/user/repo.git",
+			wantRepo:   "https://github.com/user/repo.git",
+			wantHost:   "github.com",
+			wantPath:   "user/repo",
+			wantRef:    "",
+			wantPinned: false,
+		},
+		{
+			name:       "ssh shorthand",
+			source:     "git@github.com:user/repo",
+			wantRepo:   "git@github.com:user/repo",
+			wantHost:   "github.com",
+			wantPath:   "user/repo",
+			wantRef:    "",
+			wantPinned: false,
+		},
+		{
+			name:       "ssh URL",
+			source:     "ssh://git@github.com/user/repo",
+			wantRepo:   "ssh://git@github.com/user/repo",
+			wantHost:   "github.com",
+			wantPath:   "user/repo",
+			wantRef:    "",
+			wantPinned: false,
+		},
+		{
+			name:       "gitlab shorthand",
+			source:     "gitlab.com/user/repo",
+			wantRepo:   "https://gitlab.com/user/repo.git",
+			wantHost:   "gitlab.com",
+			wantPath:   "user/repo",
+			wantRef:    "",
+			wantPinned: false,
+		},
+		{
+			name:       "bitbucket shorthand",
+			source:     "bitbucket.org/user/repo",
+			wantRepo:   "https://bitbucket.org/user/repo.git",
+			wantHost:   "bitbucket.org",
+			wantPath:   "user/repo",
+			wantRef:    "",
+			wantPinned: false,
+		},
+		{
+			name:       "generic host",
+			source:     "gitea.example.com/user/repo",
+			wantRepo:   "https://gitea.example.com/user/repo.git",
+			wantHost:   "gitea.example.com",
+			wantPath:   "user/repo",
+			wantRef:    "",
+			wantPinned: false,
+		},
+		{
+			name:       "with branch ref",
+			source:     "github.com/user/repo@main",
+			wantRepo:   "https://github.com/user/repo.git",
+			wantHost:   "github.com",
+			wantPath:   "user/repo",
+			wantRef:    "main",
+			wantPinned: true,
+		},
+		{
+			name:       "with commit ref",
+			source:     "github.com/user/repo@abc1234",
+			wantRepo:   "https://github.com/user/repo.git",
+			wantHost:   "github.com",
+			wantPath:   "user/repo",
+			wantRef:    "abc1234",
+			wantPinned: true,
+		},
+		{
+			name:    "local path should error",
+			source:  "./local/path",
+			wantErr: true,
+		},
+		{
+			name:    "absolute path should error",
+			source:  "/absolute/path",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ParseGitSource(tt.source)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ParseGitSource() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if err != nil {
+				return
+			}
+			if got.Repo != tt.wantRepo {
+				t.Errorf("ParseGitSource() Repo = %v, want %v", got.Repo, tt.wantRepo)
+			}
+			if got.Host != tt.wantHost {
+				t.Errorf("ParseGitSource() Host = %v, want %v", got.Host, tt.wantHost)
+			}
+			if got.Path != tt.wantPath {
+				t.Errorf("ParseGitSource() Path = %v, want %v", got.Path, tt.wantPath)
+			}
+			if got.Ref != tt.wantRef {
+				t.Errorf("ParseGitSource() Ref = %v, want %v", got.Ref, tt.wantRef)
+			}
+			if got.Pinned != tt.wantPinned {
+				t.Errorf("ParseGitSource() Pinned = %v, want %v", got.Pinned, tt.wantPinned)
+			}
+		})
+	}
+}
+
+func TestGitSourceIdentity(t *testing.T) {
+	source := &GitSource{
+		Host: "github.com",
+		Path: "user/repo",
+	}
+	if got := source.Identity(); got != "github.com/user/repo" {
+		t.Errorf("Identity() = %v, want %v", got, "github.com/user/repo")
+	}
+}
+
+func TestGitSourceString(t *testing.T) {
+	tests := []struct {
+		name   string
+		source GitSource
+		want   string
+	}{
+		{
+			name: "unpinned",
+			source: GitSource{
+				Host:   "github.com",
+				Path:   "user/repo",
+				Pinned: false,
+			},
+			want: "git:github.com/user/repo",
+		},
+		{
+			name: "pinned",
+			source: GitSource{
+				Host:   "github.com",
+				Path:   "user/repo",
+				Ref:    "v1.0.0",
+				Pinned: true,
+			},
+			want: "git:github.com/user/repo@v1.0.0",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.source.String(); got != tt.want {
+				t.Errorf("String() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestInstallerGetInstallPath(t *testing.T) {
+	tempDir := t.TempDir()
+	installer := NewInstaller(tempDir)
+
+	source := &GitSource{
+		Host: "github.com",
+		Path: "user/repo",
+	}
+
+	// Test global scope
+	globalPath := installer.getInstallPath(source, ScopeGlobal)
+	if !filepath.IsAbs(globalPath) {
+		t.Error("Global install path should be absolute")
+	}
+
+	// Test project scope
+	projectPath := installer.getInstallPath(source, ScopeProject)
+	expectedProjectPath := filepath.Join(tempDir, ".kit", "git", "github.com", "user", "repo")
+	if projectPath != expectedProjectPath {
+		t.Errorf("Project path = %v, want %v", projectPath, expectedProjectPath)
+	}
+}
+
+func TestManifestEntryIdentity(t *testing.T) {
+	entry := ManifestEntry{
+		Host: "github.com",
+		Path: "user/repo",
+	}
+	if got := entry.Identity(); got != "github.com/user/repo" {
+		t.Errorf("Identity() = %v, want %v", got, "github.com/user/repo")
+	}
+}
+
+func TestLoadAndSaveManifest(t *testing.T) {
+	tempDir := t.TempDir()
+	manifestPath := filepath.Join(tempDir, "packages.json")
+
+	// Test loading non-existent manifest
+	manifest, err := loadManifestFromPath(manifestPath)
+	if err != nil {
+		t.Fatalf("loadManifestFromPath() error = %v", err)
+	}
+	if len(manifest.Packages) != 0 {
+		t.Errorf("Expected empty packages, got %d", len(manifest.Packages))
+	}
+
+	// Create a manifest
+	manifest = &Manifest{
+		Packages: []ManifestEntry{
+			{
+				Source: "git:github.com/user/repo",
+				Repo:   "https://github.com/user/repo.git",
+				Host:   "github.com",
+				Path:   "user/repo",
+				Pinned: false,
+				Scope:  ScopeGlobal,
+			},
+		},
+	}
+
+	// Save it
+	err = saveManifestToPath(manifest, manifestPath)
+	if err != nil {
+		t.Fatalf("saveManifestToPath() error = %v", err)
+	}
+
+	// Load it back
+	loaded, err := loadManifestFromPath(manifestPath)
+	if err != nil {
+		t.Fatalf("loadManifestFromPath() error = %v", err)
+	}
+	if len(loaded.Packages) != 1 {
+		t.Errorf("Expected 1 package, got %d", len(loaded.Packages))
+	}
+	if loaded.Packages[0].Host != "github.com" {
+		t.Errorf("Expected host github.com, got %s", loaded.Packages[0].Host)
+	}
+}
+
+func TestAddAndRemoveFromManifest(t *testing.T) {
+	tempDir := t.TempDir()
+
+	// Set up environment for manifest path
+	if err := os.Setenv("XDG_DATA_HOME", tempDir); err != nil {
+		t.Fatalf("Setenv() error = %v", err)
+	}
+	defer func() {
+		if err := os.Unsetenv("XDG_DATA_HOME"); err != nil {
+			t.Logf("Unsetenv() error = %v", err)
+		}
+	}()
+
+	// The manifest path when XDG_DATA_HOME is set
+	manifestPath := filepath.Join(tempDir, "kit", "git", "packages.json")
+
+	// Add an entry
+	entry := ManifestEntry{
+		Source: "git:github.com/user/repo",
+		Host:   "github.com",
+		Path:   "user/repo",
+		Scope:  ScopeGlobal,
+	}
+
+	err := addEntryToManifest(entry, ScopeGlobal)
+	if err != nil {
+		t.Fatalf("addEntryToManifest() error = %v", err)
+	}
+
+	// Verify it was added
+	manifest, err := loadManifestFromPath(manifestPath)
+	if err != nil {
+		t.Fatalf("loadManifestFromPath() error = %v", err)
+	}
+	if len(manifest.Packages) != 1 {
+		t.Errorf("Expected 1 package, got %d", len(manifest.Packages))
+	}
+
+	// Remove it
+	err = removeEntryFromManifest("github.com/user/repo", ScopeGlobal)
+	if err != nil {
+		t.Fatalf("removeEntryFromManifest() error = %v", err)
+	}
+
+	// Verify it was removed
+	manifest, err = loadManifestFromPath(manifestPath)
+	if err != nil {
+		t.Fatalf("loadManifestFromPath() error = %v", err)
+	}
+	if len(manifest.Packages) != 0 {
+		t.Errorf("Expected 0 packages, got %d", len(manifest.Packages))
+	}
+}
+
+func TestFindInManifest(t *testing.T) {
+	tempDir := t.TempDir()
+	if err := os.Setenv("XDG_DATA_HOME", tempDir); err != nil {
+		t.Fatalf("Setenv() error = %v", err)
+	}
+	defer func() {
+		if err := os.Unsetenv("XDG_DATA_HOME"); err != nil {
+			t.Logf("Unsetenv() error = %v", err)
+		}
+	}()
+
+	// Add an entry to global manifest
+	entry := ManifestEntry{
+		Source: "git:github.com/user/repo",
+		Host:   "github.com",
+		Path:   "user/repo",
+		Scope:  ScopeGlobal,
+	}
+
+	err := addEntryToManifest(entry, ScopeGlobal)
+	if err != nil {
+		t.Fatalf("addEntryToManifest() error = %v", err)
+	}
+
+	// Find it
+	found, scope, err := FindInManifest("github.com/user/repo")
+	if err != nil {
+		t.Fatalf("FindInManifest() error = %v", err)
+	}
+	if found == nil {
+		t.Fatal("Expected to find entry, got nil")
+	}
+	if scope != ScopeGlobal {
+		t.Errorf("Expected scope global, got %s", scope)
+	}
+
+	// Try to find non-existent
+	notFound, _, err := FindInManifest("github.com/other/repo")
+	if err != nil {
+		t.Fatalf("FindInManifest() error = %v", err)
+	}
+	if notFound != nil {
+		t.Error("Expected nil for non-existent entry")
+	}
+}

internal/extensions/loader.go

@@ -71,12 +71,24 @@ func discoverExtensionPaths(extraPaths []string) []string {
 		add(p)
 	}
 
+	// Global installed git packages: $XDG_DATA_HOME/kit/git/
+	globalGitDir := globalGitInstallRoot()
+	for _, p := range findExtensionsInGitPackages(globalGitDir) {
+		add(p)
+	}
+
 	// Project-local extensions: .kit/extensions/
 	localDir := filepath.Join(".kit", "extensions")
 	for _, p := range findExtensionsInDir(localDir) {
 		add(p)
 	}
 
+	// Project-local installed git packages: .kit/git/
+	projectGitDir := filepath.Join(".kit", "git")
+	for _, p := range findExtensionsInGitPackages(projectGitDir) {
+		add(p)
+	}
+
 	// Explicit paths (highest precedence)
 	for _, p := range extraPaths {
 		info, err := os.Stat(p)
@@ -123,6 +135,219 @@ func findExtensionsInDir(dir string) []string {
 	return results
 }
 
+// findExtensionsInRepo scans a git repository for extensions using opinionated conventions.
+// Extensions are ONLY recognized in:
+//  1. Root-level *.go files
+//  2. Files in examples/extensions/ or examples/ext/ subdirectories
+//  3. Files in any top-level ext/ directory
+//  4. Files in any subdirectory that ends in -ext/ or -extensions/
+//
+// Everything else (cmd/, internal/, pkg/, etc.) is ignored.
+func findExtensionsInRepo(repoPath string) []string {
+	var results []string
+	multiFileDirs := make(map[string]bool)
+
+	_ = filepath.Walk(repoPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		relPath, _ := filepath.Rel(repoPath, path)
+		relPath = filepath.ToSlash(relPath)
+
+		// Skip directories we know don't contain extensions
+		if info.IsDir() {
+			switch info.Name() {
+			case ".git", ".github", "node_modules", "vendor", "dist", "build":
+				return filepath.SkipDir
+			}
+
+			// Skip internal code directories
+			if strings.HasPrefix(relPath, "internal/") ||
+				strings.HasPrefix(relPath, "cmd/") ||
+				strings.HasPrefix(relPath, "pkg/") ||
+				strings.HasPrefix(relPath, "test/") ||
+				strings.HasPrefix(relPath, "tests/") {
+				return filepath.SkipDir
+			}
+
+			// Root directory - scan it
+			if relPath == "." {
+				return nil
+			}
+
+			base := info.Name()
+			isExtDir := base == "extensions" || base == "ext" ||
+				strings.HasSuffix(base, "-extensions") || strings.HasSuffix(base, "-ext")
+
+			isExamplesSubdir := relPath == "examples" || strings.HasPrefix(relPath, "examples/")
+
+			if !isExtDir && !isExamplesSubdir {
+				mainPath := filepath.Join(path, "main.go")
+				if _, err := os.Stat(mainPath); err == nil {
+					if relPath == base { // Top-level directory
+						if !multiFileDirs[relPath] {
+							multiFileDirs[relPath] = true
+							results = append(results, mainPath)
+						}
+						return filepath.SkipDir
+					}
+					if isExamplesSubdir || isExtDir {
+						if !multiFileDirs[relPath] {
+							multiFileDirs[relPath] = true
+							results = append(results, mainPath)
+						}
+						return filepath.SkipDir
+					}
+				}
+				return filepath.SkipDir
+			}
+
+			// Check for main.go
+			mainPath := filepath.Join(path, "main.go")
+			if _, err := os.Stat(mainPath); err == nil {
+				if !multiFileDirs[relPath] {
+					multiFileDirs[relPath] = true
+					results = append(results, mainPath)
+				}
+				return filepath.SkipDir
+			}
+
+			return nil
+		}
+
+		// It's a file
+		if !strings.HasSuffix(info.Name(), ".go") {
+			return nil
+		}
+
+		if info.Name() == "main.go" {
+			return nil
+		}
+
+		parentDir := filepath.Dir(relPath)
+		if parentDir == "." {
+			// Root-level .go file - valid extension
+			results = append(results, path)
+			return nil
+		}
+
+		// Must be in valid extension directory
+		isValidExtDir := false
+		if strings.HasPrefix(parentDir, "examples/extensions/") ||
+			parentDir == "examples/extensions" {
+			isValidExtDir = true
+		} else if strings.HasPrefix(parentDir, "examples/ext/") ||
+			parentDir == "examples/ext" {
+			isValidExtDir = true
+		} else if strings.HasPrefix(parentDir, "ext/") ||
+			parentDir == "ext" {
+			isValidExtDir = true
+		} else if strings.Contains(parentDir, "-extensions/") ||
+			strings.HasSuffix(parentDir, "-extensions") {
+			isValidExtDir = true
+		} else if strings.Contains(parentDir, "-ext/") ||
+			strings.HasSuffix(parentDir, "-ext") {
+			isValidExtDir = true
+		}
+
+		if !isValidExtDir {
+			return nil
+		}
+
+		results = append(results, path)
+		return nil
+	})
+
+	return results
+}
+
+// Each git package is stored at <gitRoot>/<host>/<owner>/<repo>/ and can contain
+// .go files or a main.go in subdirectories.
+// If a package has a manifest with Include field, only those paths are loaded.
+func findExtensionsInGitPackages(gitRoot string) []string {
+	info, err := os.Stat(gitRoot)
+	if err != nil || !info.IsDir() {
+		return nil
+	}
+
+	var results []string
+
+	// Load the manifest if it exists
+	manifestPath := filepath.Join(gitRoot, "packages.json")
+	manifest, _ := loadManifestFromPath(manifestPath)
+	// Build a map of package identity -> include list
+	includeMap := make(map[string][]string)
+	if manifest != nil {
+		for _, entry := range manifest.Packages {
+			if len(entry.Include) > 0 {
+				identity := fmt.Sprintf("%s/%s", entry.Host, entry.Path)
+				includeMap[identity] = entry.Include
+			}
+		}
+	}
+
+	// Walk through host directories (e.g., github.com/)
+	hosts, err := os.ReadDir(gitRoot)
+	if err != nil {
+		return nil
+	}
+
+	for _, host := range hosts {
+		if !host.IsDir() {
+			continue
+		}
+		hostPath := filepath.Join(gitRoot, host.Name())
+
+		// Walk through owner directories (e.g., github.com/user/)
+		owners, err := os.ReadDir(hostPath)
+		if err != nil {
+			continue
+		}
+
+		for _, owner := range owners {
+			if !owner.IsDir() {
+				continue
+			}
+			ownerPath := filepath.Join(hostPath, owner.Name())
+
+			// Walk through repo directories (e.g., github.com/user/repo/)
+			repos, err := os.ReadDir(ownerPath)
+			if err != nil {
+				continue
+			}
+
+			for _, repo := range repos {
+				if !repo.IsDir() {
+					continue
+				}
+				repoPath := filepath.Join(ownerPath, repo.Name())
+
+				// Check if there's an include filter for this package
+				identity := fmt.Sprintf("%s/%s/%s", host.Name(), owner.Name(), repo.Name())
+				includes, hasFilter := includeMap[identity]
+
+				if hasFilter {
+					// Only include specific paths
+					for _, include := range includes {
+						// Convert relative path to absolute
+						include = strings.TrimPrefix(include, "./")
+						fullPath := filepath.Join(repoPath, filepath.FromSlash(include))
+						if _, err := os.Stat(fullPath); err == nil {
+							results = append(results, fullPath)
+						}
+					}
+				} else {
+					// Find all extensions within this repo using convention-based scanning
+					results = append(results, findExtensionsInRepo(repoPath)...)
+				}
+			}
+		}
+	}
+
+	return results
+}
+
 // globalExtensionsDir returns the global extensions directory, respecting
 // $XDG_CONFIG_HOME. Defaults to ~/.config/kit/extensions.
 func globalExtensionsDir() string {
@@ -214,6 +439,12 @@ func loadSingleExtension(path string) (*LoadedExtension, error) {
 				return nil
 			})
 		},
+		onToolOutput: func(h func(ToolOutputEvent, Context)) {
+			reg(ToolOutput, func(e Event, c Context) Result {
+				h(e.(ToolOutputEvent), c)
+				return nil
+			})
+		},
 		onToolResult: func(h func(ToolResultEvent, Context) *ToolResultResult) {
 			reg(ToolResult, func(e Event, c Context) Result {
 				r := h(e.(ToolResultEvent), c)
@@ -349,6 +580,24 @@ func loadSingleExtension(path string) (*LoadedExtension, error) {
 		registerShortcutFn: func(def ShortcutDef, handler func(Context)) {
 			ext.Shortcuts = append(ext.Shortcuts, ShortcutEntry{Def: def, Handler: handler})
 		},
+		onSubagentStart: func(h func(SubagentStartEvent, Context)) {
+			reg(SubagentStart, func(e Event, c Context) Result {
+				h(e.(SubagentStartEvent), c)
+				return nil
+			})
+		},
+		onSubagentChunk: func(h func(SubagentChunkEvent, Context)) {
+			reg(SubagentChunk, func(e Event, c Context) Result {
+				h(e.(SubagentChunkEvent), c)
+				return nil
+			})
+		},
+		onSubagentEnd: func(h func(SubagentEndEvent, Context)) {
+			reg(SubagentEnd, func(e Event, c Context) Result {
+				h(e.(SubagentEndEvent), c)
+				return nil
+			})
+		},
 	}
 
 	// Call Init — the extension registers its handlers, tools, commands.

internal/extensions/loader_test.go

@@ -304,6 +304,15 @@ func Init(api ext.API) {
 func TestLoadExtensions_SkipsBadFiles(t *testing.T) {
 	dir := t.TempDir()
 
+	// Isolate from host environment so globally-installed extensions
+	// are not discovered alongside the test fixtures.
+	isolated := t.TempDir()
+	t.Setenv("XDG_CONFIG_HOME", filepath.Join(isolated, "config"))
+	t.Setenv("XDG_DATA_HOME", filepath.Join(isolated, "data"))
+	origWd, _ := os.Getwd()
+	_ = os.Chdir(isolated)
+	t.Cleanup(func() { _ = os.Chdir(origWd) })
+
 	// Good extension
 	good := `package main
 import "kit/ext"

internal/extensions/manifest.go

@@ -0,0 +1,398 @@
+package extensions
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
+)
+
+// Manifest tracks installed git packages.
+type Manifest struct {
+	Packages []ManifestEntry `json:"packages"`
+}
+
+// ManifestEntry represents a single installed package.
+type ManifestEntry struct {
+	// Source is the canonical string representation (e.g., "git:github.com/user/repo@v1.0.0")
+	Source string `json:"source"`
+	// Repo is the clone URL
+	Repo string `json:"repo"`
+	// Host is the git host (e.g., github.com)
+	Host string `json:"host"`
+	// Path is the path on the host (e.g., user/repo)
+	Path string `json:"path"`
+	// Ref is the optional pinned ref (tag/branch/commit)
+	Ref string `json:"ref,omitempty"`
+	// Pinned indicates if the ref is pinned
+	Pinned bool `json:"pinned"`
+	// Scope is where the package is installed (global or project)
+	Scope InstallScope `json:"scope"`
+	// Installed is when the package was first installed
+	Installed time.Time `json:"installed"`
+	// Updated is when the package was last updated (only for unpinned, zero time means never updated)
+	Updated time.Time `json:"updated,omitzero"`
+	// Include is a list of relative paths to extensions that should be loaded.
+	// If empty, all extensions in the package are loaded.
+	// Paths are relative to the package root (e.g., "./git/main.go", "./weather.go")
+	Include []string `json:"include,omitempty"`
+}
+
+// Identity returns the normalized identity for deduplication.
+func (e ManifestEntry) Identity() string {
+	return fmt.Sprintf("%s/%s", e.Host, e.Path)
+}
+
+// loadManifest loads the manifest from the given scope.
+func loadManifestFromScope(scope InstallScope) (*Manifest, error) {
+	path := manifestPathForScope(scope)
+	return loadManifestFromPath(path)
+}
+
+// loadManifestFromPath loads a manifest from a specific file path.
+func loadManifestFromPath(path string) (*Manifest, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return &Manifest{Packages: []ManifestEntry{}}, nil
+		}
+		return nil, fmt.Errorf("reading manifest: %w", err)
+	}
+
+	var manifest Manifest
+	if err := json.Unmarshal(data, &manifest); err != nil {
+		return nil, fmt.Errorf("parsing manifest: %w", err)
+	}
+
+	return &manifest, nil
+}
+
+// saveManifestToScope saves the manifest to the given scope.
+func saveManifestToScope(manifest *Manifest, scope InstallScope) error {
+	path := manifestPathForScope(scope)
+	return saveManifestToPath(manifest, path)
+}
+
+// saveManifestToPath saves a manifest to a specific file path.
+func saveManifestToPath(manifest *Manifest, path string) error {
+	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+		return fmt.Errorf("creating manifest directory: %w", err)
+	}
+
+	data, err := json.MarshalIndent(manifest, "", "  ")
+	if err != nil {
+		return fmt.Errorf("encoding manifest: %w", err)
+	}
+
+	if err := os.WriteFile(path, data, 0644); err != nil {
+		return fmt.Errorf("writing manifest: %w", err)
+	}
+
+	return nil
+}
+
+// manifestPathForScope returns the manifest file path for a scope.
+func manifestPathForScope(scope InstallScope) string {
+	if scope == ScopeProject {
+		return filepath.Join(".kit", "git", "packages.json")
+	}
+
+	base := os.Getenv("XDG_DATA_HOME")
+	if base == "" {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return ""
+		}
+		base = filepath.Join(home, ".local", "share")
+	}
+	return filepath.Join(base, "kit", "git", "packages.json")
+}
+
+// GetGlobalManifest returns the global manifest.
+func GetGlobalManifest() (*Manifest, error) {
+	return loadManifestFromScope(ScopeGlobal)
+}
+
+// GetProjectManifest returns the project manifest.
+func GetProjectManifest() (*Manifest, error) {
+	return loadManifestFromScope(ScopeProject)
+}
+
+// addEntryToManifest adds or replaces an entry in the manifest for a scope.
+func addEntryToManifest(entry ManifestEntry, scope InstallScope) error {
+	manifest, err := loadManifestFromScope(scope)
+	if err != nil {
+		return err
+	}
+
+	// Remove any existing entry with same identity
+	identity := entry.Identity()
+	filtered := make([]ManifestEntry, 0, len(manifest.Packages))
+	for _, p := range manifest.Packages {
+		if p.Identity() != identity {
+			filtered = append(filtered, p)
+		}
+	}
+	filtered = append(filtered, entry)
+	manifest.Packages = filtered
+
+	return saveManifestToScope(manifest, scope)
+}
+
+// removeEntryFromManifest removes an entry by identity from the manifest for a scope.
+func removeEntryFromManifest(identity string, scope InstallScope) error {
+	manifest, err := loadManifestFromScope(scope)
+	if err != nil {
+		return err
+	}
+
+	filtered := make([]ManifestEntry, 0, len(manifest.Packages))
+	for _, p := range manifest.Packages {
+		if p.Identity() != identity {
+			filtered = append(filtered, p)
+		}
+	}
+	manifest.Packages = filtered
+
+	return saveManifestToScope(manifest, scope)
+}
+
+// FindInManifest finds an entry by identity in either global or project manifest.
+// Returns the entry and its scope, or nil if not found.
+func FindInManifest(identity string) (*ManifestEntry, InstallScope, error) {
+	global, err := loadManifestFromScope(ScopeGlobal)
+	if err != nil {
+		return nil, "", fmt.Errorf("loading global manifest: %w", err)
+	}
+	for _, p := range global.Packages {
+		if p.Identity() == identity {
+			return &p, ScopeGlobal, nil
+		}
+	}
+
+	project, err := loadManifestFromScope(ScopeProject)
+	if err != nil {
+		return nil, "", fmt.Errorf("loading project manifest: %w", err)
+	}
+	for _, p := range project.Packages {
+		if p.Identity() == identity {
+			return &p, ScopeProject, nil
+		}
+	}
+
+	return nil, "", nil
+}
+
+// ExtensionPreview represents a discovered extension in a package before installation.
+type ExtensionPreview struct {
+	// Path is the relative path from the package root (e.g., "./git/main.go")
+	Path string `json:"path"`
+	// Name is a display name for the extension (derived from path or metadata)
+	Name string `json:"name"`
+	// Description is an optional description (could be extracted from comments)
+	Description string `json:"description,omitempty"`
+	// IsMain indicates if this is a main.go in a subdirectory
+	IsMain bool `json:"is_main"`
+}
+
+// ScanForExtensions discovers all extensions in a directory using opinionated conventions.
+// Extensions are ONLY recognized in these specific locations:
+//  1. Root-level *.go files
+//  2. Files in examples/extensions/ or examples/ext/ subdirectories
+//  3. Files in any top-level ext/ directory
+//  4. Files in any subdirectory that ends in -ext/ or -extensions/
+//
+// Everything else (cmd/, internal/, pkg/, etc.) is ignored.
+func ScanForExtensions(dir string) ([]ExtensionPreview, error) {
+	info, err := os.Stat(dir)
+	if err != nil || !info.IsDir() {
+		return nil, fmt.Errorf("not a directory: %s", dir)
+	}
+
+	var previews []ExtensionPreview
+	multiFileDirs := make(map[string]bool)
+
+	err = filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		relPath, _ := filepath.Rel(dir, path)
+		relPath = filepath.ToSlash(relPath)
+
+		// Skip directories we know don't contain extensions
+		if info.IsDir() {
+			// Never scan these directories
+			switch info.Name() {
+			case ".git", ".github", "node_modules", "vendor", "dist", "build":
+				return filepath.SkipDir
+			}
+
+			// Skip internal code directories
+			if strings.HasPrefix(relPath, "internal/") ||
+				strings.HasPrefix(relPath, "cmd/") ||
+				strings.HasPrefix(relPath, "pkg/") ||
+				strings.HasPrefix(relPath, "test/") ||
+				strings.HasPrefix(relPath, "tests/") {
+				return filepath.SkipDir
+			}
+
+			// Root directory - scan it
+			if relPath == "." {
+				return nil
+			}
+
+			// Check if this directory is an extension location by name
+			// Pattern: must be named "extensions", "ext", or end with those
+			base := info.Name()
+			isExtDir := base == "extensions" || base == "ext" ||
+				strings.HasSuffix(base, "-extensions") || strings.HasSuffix(base, "-ext")
+
+			// Or check if it's a subdirectory of examples/ that might contain extensions
+			isExamplesSubdir := relPath == "examples" || strings.HasPrefix(relPath, "examples/")
+
+			if !isExtDir && !isExamplesSubdir {
+				// Check for main.go before skipping
+				mainPath := filepath.Join(path, "main.go")
+				if _, err := os.Stat(mainPath); err == nil {
+					// This is a package with main.go at root level
+					if relPath == base { // Top-level directory
+						if !multiFileDirs[relPath] {
+							multiFileDirs[relPath] = true
+							previews = append(previews, ExtensionPreview{
+								Path:   "./" + relPath + "/main.go",
+								Name:   deriveExtensionName(relPath+"/main.go", true),
+								IsMain: true,
+							})
+						}
+						return filepath.SkipDir
+					}
+					// Inside a valid extensions directory
+					if isExamplesSubdir || isExtDir {
+						if !multiFileDirs[relPath] {
+							multiFileDirs[relPath] = true
+							previews = append(previews, ExtensionPreview{
+								Path:   "./" + relPath + "/main.go",
+								Name:   deriveExtensionName(relPath+"/main.go", true),
+								IsMain: true,
+							})
+						}
+						return filepath.SkipDir
+					}
+				}
+
+				// Not an extension location
+				return filepath.SkipDir
+			}
+
+			// Check for main.go in this directory
+			mainPath := filepath.Join(path, "main.go")
+			if _, err := os.Stat(mainPath); err == nil {
+				if !multiFileDirs[relPath] {
+					multiFileDirs[relPath] = true
+					previews = append(previews, ExtensionPreview{
+						Path:   "./" + relPath + "/main.go",
+						Name:   deriveExtensionName(relPath+"/main.go", true),
+						IsMain: true,
+					})
+				}
+				return filepath.SkipDir
+			}
+
+			// Scan this extensions directory
+			return nil
+		}
+
+		// It's a file - check if it's a valid extension
+		if !strings.HasSuffix(info.Name(), ".go") {
+			return nil
+		}
+
+		if info.Name() == "main.go" {
+			return nil // Already handled above
+		}
+
+		// Check if parent is a valid extension location
+		parentDir := filepath.Dir(relPath)
+		if parentDir == "." {
+			// Root-level .go file - valid extension
+			previews = append(previews, ExtensionPreview{
+				Path:   "./" + relPath,
+				Name:   deriveExtensionName(relPath, false),
+				IsMain: false,
+			})
+			return nil
+		}
+
+		// Check if we're in a valid extension directory
+		// Valid locations are:
+		// - examples/extensions/*
+		// - examples/ext/*
+		// - ext/* (top-level)
+		// - Any *-extensions/* or *-ext/* directory
+		isValidExtDir := false
+		if strings.HasPrefix(parentDir, "examples/extensions/") ||
+			parentDir == "examples/extensions" {
+			isValidExtDir = true
+		} else if strings.HasPrefix(parentDir, "examples/ext/") ||
+			parentDir == "examples/ext" {
+			isValidExtDir = true
+		} else if strings.HasPrefix(parentDir, "ext/") ||
+			parentDir == "ext" {
+			isValidExtDir = true
+		} else if strings.Contains(parentDir, "-extensions/") ||
+			strings.HasSuffix(parentDir, "-extensions") {
+			isValidExtDir = true
+		} else if strings.Contains(parentDir, "-ext/") ||
+			strings.HasSuffix(parentDir, "-ext") {
+			isValidExtDir = true
+		}
+
+		if !isValidExtDir {
+			return nil
+		}
+
+		previews = append(previews, ExtensionPreview{
+			Path:   "./" + relPath,
+			Name:   deriveExtensionName(relPath, false),
+			IsMain: false,
+		})
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return previews, nil
+}
+
+// deriveExtensionName creates a display name from a file path.
+func deriveExtensionName(relPath string, isMain bool) string {
+	// Convert path to a readable name
+	// e.g., "git/main.go" -> "Git Extension"
+	// e.g., "weather.go" -> "Weather"
+
+	dir := filepath.Dir(relPath)
+	base := filepath.Base(relPath)
+
+	if isMain && dir != "." {
+		// Use immediate parent directory name for main.go files
+		name := filepath.Base(dir)
+		name = strings.ReplaceAll(name, "_", " ")
+		name = strings.ReplaceAll(name, "-", " ")
+		return cases.Title(language.English).String(name) + " Extension"
+	}
+
+	// Use filename without extension
+	name := strings.TrimSuffix(base, ".go")
+	name = strings.ReplaceAll(name, "_", " ")
+	name = strings.ReplaceAll(name, "-", " ")
+	return cases.Title(language.English).String(name)
+}

internal/extensions/runner.go

@@ -56,11 +56,261 @@ func NewRunner(exts []LoadedExtension) *Runner {
 }
 
 // SetContext updates the runtime context (session ID, model, etc.) that is
-// passed to every handler invocation. Thread-safe.
+// passed to every handler invocation. Nil function fields are replaced with
+// safe no-ops so extension handlers never panic on a missing callback.
+// Thread-safe.
 func (r *Runner) SetContext(ctx Context) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
-	r.ctx = ctx
+	r.ctx = normalizeContext(ctx)
+}
+
+// normalizeContext replaces nil function fields in ctx with no-op stubs so
+// that extension handlers can call any ctx method without a nil-function panic.
+func normalizeContext(ctx Context) Context {
+	if ctx.Print == nil {
+		ctx.Print = func(string) {}
+	}
+	if ctx.PrintInfo == nil {
+		ctx.PrintInfo = func(string) {}
+	}
+	if ctx.PrintError == nil {
+		ctx.PrintError = func(string) {}
+	}
+	if ctx.PrintBlock == nil {
+		ctx.PrintBlock = func(PrintBlockOpts) {}
+	}
+	if ctx.SendMessage == nil {
+		ctx.SendMessage = func(string) {}
+	}
+	if ctx.CancelAndSend == nil {
+		ctx.CancelAndSend = func(string) {}
+	}
+	if ctx.SetWidget == nil {
+		ctx.SetWidget = func(WidgetConfig) {}
+	}
+	if ctx.RemoveWidget == nil {
+		ctx.RemoveWidget = func(string) {}
+	}
+	if ctx.SetHeader == nil {
+		ctx.SetHeader = func(HeaderFooterConfig) {}
+	}
+	if ctx.RemoveHeader == nil {
+		ctx.RemoveHeader = func() {}
+	}
+	if ctx.SetFooter == nil {
+		ctx.SetFooter = func(HeaderFooterConfig) {}
+	}
+	if ctx.RemoveFooter == nil {
+		ctx.RemoveFooter = func() {}
+	}
+	if ctx.PromptSelect == nil {
+		ctx.PromptSelect = func(PromptSelectConfig) PromptSelectResult {
+			return PromptSelectResult{Cancelled: true}
+		}
+	}
+	if ctx.PromptConfirm == nil {
+		ctx.PromptConfirm = func(PromptConfirmConfig) PromptConfirmResult {
+			return PromptConfirmResult{Cancelled: true}
+		}
+	}
+	if ctx.PromptInput == nil {
+		ctx.PromptInput = func(PromptInputConfig) PromptInputResult {
+			return PromptInputResult{Cancelled: true}
+		}
+	}
+	if ctx.PromptMultiSelect == nil {
+		ctx.PromptMultiSelect = func(PromptMultiSelectConfig) PromptMultiSelectResult {
+			return PromptMultiSelectResult{Cancelled: true}
+		}
+	}
+	if ctx.ShowOverlay == nil {
+		ctx.ShowOverlay = func(OverlayConfig) OverlayResult {
+			return OverlayResult{Cancelled: true, Index: -1}
+		}
+	}
+	if ctx.SetEditor == nil {
+		ctx.SetEditor = func(EditorConfig) {}
+	}
+	if ctx.ResetEditor == nil {
+		ctx.ResetEditor = func() {}
+	}
+	if ctx.SetEditorText == nil {
+		ctx.SetEditorText = func(string) {}
+	}
+	if ctx.SetUIVisibility == nil {
+		ctx.SetUIVisibility = func(UIVisibility) {}
+	}
+	if ctx.SetStatus == nil {
+		ctx.SetStatus = func(string, string, int) {}
+	}
+	if ctx.RemoveStatus == nil {
+		ctx.RemoveStatus = func(string) {}
+	}
+	if ctx.GetContextStats == nil {
+		ctx.GetContextStats = func() ContextStats { return ContextStats{} }
+	}
+	if ctx.GetMessages == nil {
+		ctx.GetMessages = func() []SessionMessage { return nil }
+	}
+	if ctx.GetSessionPath == nil {
+		ctx.GetSessionPath = func() string { return "" }
+	}
+	if ctx.AppendEntry == nil {
+		ctx.AppendEntry = func(string, string) (string, error) { return "", nil }
+	}
+	if ctx.GetEntries == nil {
+		ctx.GetEntries = func(string) []ExtensionEntry { return nil }
+	}
+	if ctx.GetOption == nil {
+		ctx.GetOption = func(string) string { return "" }
+	}
+	if ctx.SetOption == nil {
+		ctx.SetOption = func(string, string) {}
+	}
+	if ctx.SetModel == nil {
+		ctx.SetModel = func(string) error { return nil }
+	}
+	if ctx.GetAvailableModels == nil {
+		ctx.GetAvailableModels = func() []ModelInfoEntry { return nil }
+	}
+	if ctx.EmitCustomEvent == nil {
+		ctx.EmitCustomEvent = func(string, string) {}
+	}
+	if ctx.GetAllTools == nil {
+		ctx.GetAllTools = func() []ToolInfo { return nil }
+	}
+	if ctx.SetActiveTools == nil {
+		ctx.SetActiveTools = func([]string) {}
+	}
+	if ctx.Exit == nil {
+		ctx.Exit = func() {}
+	}
+	if ctx.Complete == nil {
+		ctx.Complete = func(CompleteRequest) (CompleteResponse, error) {
+			return CompleteResponse{}, nil
+		}
+	}
+	if ctx.SuspendTUI == nil {
+		ctx.SuspendTUI = func(callback func()) error { callback(); return nil }
+	}
+	if ctx.RenderMessage == nil {
+		ctx.RenderMessage = func(string, string) {}
+	}
+	if ctx.RegisterTheme == nil {
+		ctx.RegisterTheme = func(string, ThemeColorConfig) {}
+	}
+	if ctx.SetTheme == nil {
+		ctx.SetTheme = func(string) error { return nil }
+	}
+	if ctx.ListThemes == nil {
+		ctx.ListThemes = func() []string { return nil }
+	}
+	if ctx.ReloadExtensions == nil {
+		ctx.ReloadExtensions = func() error { return nil }
+	}
+	if ctx.SpawnSubagent == nil {
+		ctx.SpawnSubagent = func(SubagentConfig) (*SubagentHandle, *SubagentResult, error) {
+			return nil, nil, nil
+		}
+	}
+
+	// -------------------------------------------------------------------------
+	// Tree Navigation API no-ops
+	// -------------------------------------------------------------------------
+	if ctx.GetTreeNode == nil {
+		ctx.GetTreeNode = func(string) *TreeNode { return nil }
+	}
+	if ctx.GetCurrentBranch == nil {
+		ctx.GetCurrentBranch = func() []TreeNode { return nil }
+	}
+	if ctx.GetChildren == nil {
+		ctx.GetChildren = func(string) []string { return nil }
+	}
+	if ctx.NavigateTo == nil {
+		ctx.NavigateTo = func(string) TreeNavigationResult {
+			return TreeNavigationResult{Success: false, Error: "not implemented"}
+		}
+	}
+	if ctx.SummarizeBranch == nil {
+		ctx.SummarizeBranch = func(string, string) string {
+			return ""
+		}
+	}
+	if ctx.CollapseBranch == nil {
+		ctx.CollapseBranch = func(string, string, string) TreeNavigationResult {
+			return TreeNavigationResult{Success: false, Error: "not implemented"}
+		}
+	}
+
+	// -------------------------------------------------------------------------
+	// Skill Loading API no-ops
+	// -------------------------------------------------------------------------
+	if ctx.LoadSkill == nil {
+		ctx.LoadSkill = func(string) (*Skill, string) { return nil, "" }
+	}
+	if ctx.LoadSkillsFromDir == nil {
+		ctx.LoadSkillsFromDir = func(string) SkillLoadResult { return SkillLoadResult{} }
+	}
+	if ctx.DiscoverSkills == nil {
+		ctx.DiscoverSkills = func() SkillLoadResult { return SkillLoadResult{} }
+	}
+	if ctx.InjectSkillAsContext == nil {
+		ctx.InjectSkillAsContext = func(string) string { return "" }
+	}
+	if ctx.InjectRawSkillAsContext == nil {
+		ctx.InjectRawSkillAsContext = func(string) string { return "" }
+	}
+	if ctx.GetAvailableSkills == nil {
+		ctx.GetAvailableSkills = func() []Skill { return nil }
+	}
+
+	// -------------------------------------------------------------------------
+	// Template Parsing API no-ops
+	// -------------------------------------------------------------------------
+	if ctx.ParseTemplate == nil {
+		ctx.ParseTemplate = func(string, string) PromptTemplate { return PromptTemplate{} }
+	}
+	if ctx.RenderTemplate == nil {
+		ctx.RenderTemplate = func(PromptTemplate, map[string]string) string { return "" }
+	}
+	if ctx.ParseArguments == nil {
+		ctx.ParseArguments = func(string, ArgumentPattern) ParseResult { return ParseResult{} }
+	}
+	if ctx.SimpleParseArguments == nil {
+		ctx.SimpleParseArguments = func(string, int) []string { return nil }
+	}
+	if ctx.EvaluateModelConditional == nil {
+		ctx.EvaluateModelConditional = func(string) bool { return false }
+	}
+	if ctx.RenderWithModelConditionals == nil {
+		ctx.RenderWithModelConditionals = func(string) string { return "" }
+	}
+
+	// -------------------------------------------------------------------------
+	// Model Resolution API no-ops
+	// -------------------------------------------------------------------------
+	if ctx.ResolveModelChain == nil {
+		ctx.ResolveModelChain = func([]string) ModelResolutionResult {
+			return ModelResolutionResult{Error: "not implemented"}
+		}
+	}
+	if ctx.GetModelCapabilities == nil {
+		ctx.GetModelCapabilities = func(string) (ModelCapabilities, string) {
+			return ModelCapabilities{}, "not implemented"
+		}
+	}
+	if ctx.CheckModelAvailable == nil {
+		ctx.CheckModelAvailable = func(string) bool { return false }
+	}
+	if ctx.GetCurrentProvider == nil {
+		ctx.GetCurrentProvider = func() string { return "" }
+	}
+	if ctx.GetCurrentModelID == nil {
+		ctx.GetCurrentModelID = func() string { return "" }
+	}
+
+	return ctx
 }
 
 // GetContext returns a snapshot of the current runtime context. Thread-safe.

internal/extensions/symbols.go

@@ -90,12 +90,14 @@ func Symbols() interp.Exports {
 			"EditorConfig":         reflect.ValueOf((*EditorConfig)(nil)),
 
 			// Prompt types
-			"PromptSelectConfig":  reflect.ValueOf((*PromptSelectConfig)(nil)),
-			"PromptSelectResult":  reflect.ValueOf((*PromptSelectResult)(nil)),
-			"PromptConfirmConfig": reflect.ValueOf((*PromptConfirmConfig)(nil)),
-			"PromptConfirmResult": reflect.ValueOf((*PromptConfirmResult)(nil)),
-			"PromptInputConfig":   reflect.ValueOf((*PromptInputConfig)(nil)),
-			"PromptInputResult":   reflect.ValueOf((*PromptInputResult)(nil)),
+			"PromptSelectConfig":      reflect.ValueOf((*PromptSelectConfig)(nil)),
+			"PromptSelectResult":      reflect.ValueOf((*PromptSelectResult)(nil)),
+			"PromptConfirmConfig":     reflect.ValueOf((*PromptConfirmConfig)(nil)),
+			"PromptConfirmResult":     reflect.ValueOf((*PromptConfirmResult)(nil)),
+			"PromptInputConfig":       reflect.ValueOf((*PromptInputConfig)(nil)),
+			"PromptInputResult":       reflect.ValueOf((*PromptInputResult)(nil)),
+			"PromptMultiSelectConfig": reflect.ValueOf((*PromptMultiSelectConfig)(nil)),
+			"PromptMultiSelectResult": reflect.ValueOf((*PromptMultiSelectResult)(nil)),
 
 			// Context filtering types
 			"ContextMessage":       reflect.ValueOf((*ContextMessage)(nil)),
@@ -117,11 +119,39 @@ func Symbols() interp.Exports {
 			"SubagentHandle": reflect.ValueOf((*SubagentHandle)(nil)),
 			"SubagentEvent":  reflect.ValueOf((*SubagentEvent)(nil)),
 
+			// Subagent lifecycle events
+			"SubagentStartEvent": reflect.ValueOf((*SubagentStartEvent)(nil)),
+			"SubagentChunkEvent": reflect.ValueOf((*SubagentChunkEvent)(nil)),
+			"SubagentEndEvent":   reflect.ValueOf((*SubagentEndEvent)(nil)),
+
+			// Theme types
+			"ThemeColor":       reflect.ValueOf((*ThemeColor)(nil)),
+			"ThemeColorConfig": reflect.ValueOf((*ThemeColorConfig)(nil)),
+
+			// Tree navigation types
+			"TreeNode":             reflect.ValueOf((*TreeNode)(nil)),
+			"TreeNavigationResult": reflect.ValueOf((*TreeNavigationResult)(nil)),
+
+			// Skill types
+			"Skill":           reflect.ValueOf((*Skill)(nil)),
+			"SkillLoadResult": reflect.ValueOf((*SkillLoadResult)(nil)),
+
+			// Template parsing types
+			"PromptTemplate":   reflect.ValueOf((*PromptTemplate)(nil)),
+			"ArgumentPattern":  reflect.ValueOf((*ArgumentPattern)(nil)),
+			"ParseResult":      reflect.ValueOf((*ParseResult)(nil)),
+			"ModelConditional": reflect.ValueOf((*ModelConditional)(nil)),
+
+			// Model resolution types
+			"ModelCapabilities":     reflect.ValueOf((*ModelCapabilities)(nil)),
+			"ModelResolutionResult": reflect.ValueOf((*ModelResolutionResult)(nil)),
+
 			// Event structs
 			"ToolCallEvent":           reflect.ValueOf((*ToolCallEvent)(nil)),
 			"ToolCallResult":          reflect.ValueOf((*ToolCallResult)(nil)),
 			"ToolExecutionStartEvent": reflect.ValueOf((*ToolExecutionStartEvent)(nil)),
 			"ToolExecutionEndEvent":   reflect.ValueOf((*ToolExecutionEndEvent)(nil)),
+			"ToolOutputEvent":         reflect.ValueOf((*ToolOutputEvent)(nil)),
 			"ToolResultEvent":         reflect.ValueOf((*ToolResultEvent)(nil)),
 			"ToolResultResult":        reflect.ValueOf((*ToolResultResult)(nil)),
 			"InputEvent":              reflect.ValueOf((*InputEvent)(nil)),

internal/extensions/test_api.go

@@ -0,0 +1,193 @@
+package extensions
+
+// NewTestAPI creates an API object wired for testing.
+// This is used by the test harness to load extensions and verify behavior.
+// The registration functions wire handlers directly to the provided extension.
+func NewTestAPI(ext *LoadedExtension) API {
+	reg := func(event EventType, fn HandlerFunc) {
+		ext.Handlers[event] = append(ext.Handlers[event], fn)
+	}
+
+	return API{
+		onToolCall: func(h func(ToolCallEvent, Context) *ToolCallResult) {
+			reg(ToolCall, func(e Event, c Context) Result {
+				r := h(e.(ToolCallEvent), c)
+				if r == nil {
+					return nil
+				}
+				return *r
+			})
+		},
+		onToolExecStart: func(h func(ToolExecutionStartEvent, Context)) {
+			reg(ToolExecutionStart, func(e Event, c Context) Result {
+				h(e.(ToolExecutionStartEvent), c)
+				return nil
+			})
+		},
+		onToolExecEnd: func(h func(ToolExecutionEndEvent, Context)) {
+			reg(ToolExecutionEnd, func(e Event, c Context) Result {
+				h(e.(ToolExecutionEndEvent), c)
+				return nil
+			})
+		},
+		onToolOutput: func(h func(ToolOutputEvent, Context)) {
+			reg(ToolOutput, func(e Event, c Context) Result {
+				h(e.(ToolOutputEvent), c)
+				return nil
+			})
+		},
+		onToolResult: func(h func(ToolResultEvent, Context) *ToolResultResult) {
+			reg(ToolResult, func(e Event, c Context) Result {
+				r := h(e.(ToolResultEvent), c)
+				if r == nil {
+					return nil
+				}
+				return *r
+			})
+		},
+		onInput: func(h func(InputEvent, Context) *InputResult) {
+			reg(Input, func(e Event, c Context) Result {
+				r := h(e.(InputEvent), c)
+				if r == nil {
+					return nil
+				}
+				return *r
+			})
+		},
+		onBeforeAgentStart: func(h func(BeforeAgentStartEvent, Context) *BeforeAgentStartResult) {
+			reg(BeforeAgentStart, func(e Event, c Context) Result {
+				r := h(e.(BeforeAgentStartEvent), c)
+				if r == nil {
+					return nil
+				}
+				return *r
+			})
+		},
+		onAgentStart: func(h func(AgentStartEvent, Context)) {
+			reg(AgentStart, func(e Event, c Context) Result {
+				h(e.(AgentStartEvent), c)
+				return nil
+			})
+		},
+		onAgentEnd: func(h func(AgentEndEvent, Context)) {
+			reg(AgentEnd, func(e Event, c Context) Result {
+				h(e.(AgentEndEvent), c)
+				return nil
+			})
+		},
+		onMessageStart: func(h func(MessageStartEvent, Context)) {
+			reg(MessageStart, func(e Event, c Context) Result {
+				h(e.(MessageStartEvent), c)
+				return nil
+			})
+		},
+		onMessageUpdate: func(h func(MessageUpdateEvent, Context)) {
+			reg(MessageUpdate, func(e Event, c Context) Result {
+				h(e.(MessageUpdateEvent), c)
+				return nil
+			})
+		},
+		onMessageEnd: func(h func(MessageEndEvent, Context)) {
+			reg(MessageEnd, func(e Event, c Context) Result {
+				h(e.(MessageEndEvent), c)
+				return nil
+			})
+		},
+		onSessionStart: func(h func(SessionStartEvent, Context)) {
+			reg(SessionStart, func(e Event, c Context) Result {
+				h(e.(SessionStartEvent), c)
+				return nil
+			})
+		},
+		onSessionShutdown: func(h func(SessionShutdownEvent, Context)) {
+			reg(SessionShutdown, func(e Event, c Context) Result {
+				h(e.(SessionShutdownEvent), c)
+				return nil
+			})
+		},
+		onModelChange: func(h func(ModelChangeEvent, Context)) {
+			reg(ModelChange, func(e Event, c Context) Result {
+				h(e.(ModelChangeEvent), c)
+				return nil
+			})
+		},
+		onContextPrepare: func(h func(ContextPrepareEvent, Context) *ContextPrepareResult) {
+			reg(ContextPrepare, func(e Event, c Context) Result {
+				r := h(e.(ContextPrepareEvent), c)
+				if r == nil {
+					return nil
+				}
+				return *r
+			})
+		},
+		onBeforeFork: func(h func(BeforeForkEvent, Context) *BeforeForkResult) {
+			reg(BeforeFork, func(e Event, c Context) Result {
+				r := h(e.(BeforeForkEvent), c)
+				if r == nil {
+					return nil
+				}
+				return *r
+			})
+		},
+		onBeforeSessionSwitch: func(h func(BeforeSessionSwitchEvent, Context) *BeforeSessionSwitchResult) {
+			reg(BeforeSessionSwitch, func(e Event, c Context) Result {
+				r := h(e.(BeforeSessionSwitchEvent), c)
+				if r == nil {
+					return nil
+				}
+				return *r
+			})
+		},
+		onBeforeCompact: func(h func(BeforeCompactEvent, Context) *BeforeCompactResult) {
+			reg(BeforeCompact, func(e Event, c Context) Result {
+				r := h(e.(BeforeCompactEvent), c)
+				if r == nil {
+					return nil
+				}
+				return *r
+			})
+		},
+		registerToolFn: func(tool ToolDef) {
+			ext.Tools = append(ext.Tools, tool)
+		},
+		registerCmdFn: func(cmd CommandDef) {
+			ext.Commands = append(ext.Commands, cmd)
+		},
+		registerToolRendererFn: func(config ToolRenderConfig) {
+			ext.ToolRenderers = append(ext.ToolRenderers, config)
+		},
+		onCustomEvent: func(name string, handler func(string)) {
+			if ext.CustomEventHandlers == nil {
+				ext.CustomEventHandlers = make(map[string][]func(string))
+			}
+			ext.CustomEventHandlers[name] = append(ext.CustomEventHandlers[name], handler)
+		},
+		registerOption: func(opt OptionDef) {
+			ext.Options = append(ext.Options, opt)
+		},
+		registerShortcutFn: func(def ShortcutDef, handler func(Context)) {
+			ext.Shortcuts = append(ext.Shortcuts, ShortcutEntry{Def: def, Handler: handler})
+		},
+		registerMessageRendererFn: func(config MessageRendererConfig) {
+			ext.MessageRenderers = append(ext.MessageRenderers, config)
+		},
+		onSubagentStart: func(h func(SubagentStartEvent, Context)) {
+			reg(SubagentStart, func(e Event, c Context) Result {
+				h(e.(SubagentStartEvent), c)
+				return nil
+			})
+		},
+		onSubagentChunk: func(h func(SubagentChunkEvent, Context)) {
+			reg(SubagentChunk, func(e Event, c Context) Result {
+				h(e.(SubagentChunkEvent), c)
+				return nil
+			})
+		},
+		onSubagentEnd: func(h func(SubagentEndEvent, Context)) {
+			reg(SubagentEnd, func(e Event, c Context) Result {
+				h(e.(SubagentEndEvent), c)
+				return nil
+			})
+		},
+	}
+}

internal/extensions/wrapper.go

@@ -49,7 +49,7 @@ var coreToolKinds = map[string]string{
 	"ls":             "read",
 	"grep":           "search",
 	"find":           "search",
-	"spawn_subagent": "agent",
+	"subagent": "agent",
 }
 
 // toolKindFor returns the ToolKind for a given tool name, defaulting to

internal/message/content.go

@@ -4,11 +4,38 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"strings"
 	"time"
 
 	"charm.land/fantasy"
 )
 
+// sanitizeToolCallID ensures the ID matches Anthropic's required pattern:
+// ^[a-zA-Z0-9_-]+$ (alphanumeric, underscores, and hyphens only).
+// Invalid characters are replaced with underscores.
+func sanitizeToolCallID(id string) string {
+	var sb strings.Builder
+	for _, r := range id {
+		switch {
+		case (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z'):
+			sb.WriteRune(r)
+		case r >= '0' && r <= '9':
+			sb.WriteRune(r)
+		case r == '_' || r == '-':
+			sb.WriteRune(r)
+		default:
+			// Replace invalid characters with underscore
+			sb.WriteByte('_')
+		}
+	}
+	result := sb.String()
+	// Ensure non-empty (Anthropic requires at least one character)
+	if result == "" {
+		return "tool_0"
+	}
+	return result
+}
+
 // ContentPart is the marker interface for all message content block types.
 // A message contains a heterogeneous slice of ContentPart values, enabling
 // rich structured messages that carry text, reasoning, tool calls, tool
@@ -312,7 +339,7 @@ func (m *Message) ToFantasyMessages() []fantasy.Message {
 		// Add tool calls
 		for _, tc := range m.ToolCalls() {
 			parts = append(parts, fantasy.ToolCallPart{
-				ToolCallID: tc.ID,
+				ToolCallID: sanitizeToolCallID(tc.ID),
 				ToolName:   tc.Name,
 				Input:      tc.Input,
 			})
@@ -340,7 +367,7 @@ func (m *Message) ToFantasyMessages() []fantasy.Message {
 				}
 			}
 			parts = append(parts, fantasy.ToolResultPart{
-				ToolCallID: result.ToolCallID,
+				ToolCallID: sanitizeToolCallID(result.ToolCallID),
 				Output:     output,
 			})
 		}

internal/message/content_test.go

@@ -0,0 +1,113 @@
+package message
+
+import (
+	"testing"
+)
+
+func TestSanitizeToolCallID(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "valid alphanumeric ID",
+			input:    "call_123abc",
+			expected: "call_123abc",
+		},
+		{
+			name:     "ID with dots (OpenCode/Kimi style)",
+			input:    "call.123.abc",
+			expected: "call_123_abc",
+		},
+		{
+			name:     "ID with colons",
+			input:    "tool:123:abc",
+			expected: "tool_123_abc",
+		},
+		{
+			name:     "ID with special characters",
+			input:    "tool@#$%^&*()",
+			expected: "tool_________",
+		},
+		{
+			name:     "Anthropic style ID (already valid)",
+			input:    "toolu_0123456789ABCDEF",
+			expected: "toolu_0123456789ABCDEF",
+		},
+		{
+			name:     "OpenAI style ID (already valid)",
+			input:    "call_O17Uplv4lJvD6DVdIvFFeRMw",
+			expected: "call_O17Uplv4lJvD6DVdIvFFeRMw",
+		},
+		{
+			name:     "ID with hyphens",
+			input:    "my-tool-call-123",
+			expected: "my-tool-call-123",
+		},
+		{
+			name:     "empty string",
+			input:    "",
+			expected: "tool_0",
+		},
+		{
+			name:     "only special characters",
+			input:    "@#$%",
+			expected: "____",
+		},
+		{
+			name:     "mixed valid and invalid",
+			input:    "call_123.abc-def@ghi",
+			expected: "call_123_abc-def_ghi",
+		},
+		{
+			name:     "Unicode characters",
+			input:    "tool_日本語",
+			expected: "tool____",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := sanitizeToolCallID(tt.input)
+			if result != tt.expected {
+				t.Errorf("sanitizeToolCallID(%q) = %q, want %q", tt.input, result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestSanitizeToolCallID_MatchesAnthropicPattern(t *testing.T) {
+	// Test that sanitized IDs match Anthropic's required pattern: ^[a-zA-Z0-9_-]+$
+	// This is a simplified check - in reality the pattern allows alphanumeric, underscore, hyphen
+	testIDs := []string{
+		"call.123.abc",
+		"tool:123:def",
+		"id@#$%^&*()",
+		"mixed.valid-id_test",
+		"",
+	}
+
+	for _, id := range testIDs {
+		sanitized := sanitizeToolCallID(id)
+
+		// Verify each character is valid
+		for i, r := range sanitized {
+			valid := (r >= 'a' && r <= 'z') ||
+				(r >= 'A' && r <= 'Z') ||
+				(r >= '0' && r <= '9') ||
+				r == '_' ||
+				r == '-'
+
+			if !valid {
+				t.Errorf("sanitizeToolCallID(%q) = %q, contains invalid character at position %d: %q",
+					id, sanitized, i, string(r))
+			}
+		}
+
+		// Verify non-empty
+		if sanitized == "" {
+			t.Errorf("sanitizeToolCallID(%q) returned empty string", id)
+		}
+	}
+}

internal/models/custom.go

@@ -0,0 +1,74 @@
+package models
+
+import (
+	"log"
+
+	"github.com/spf13/viper"
+)
+
+// loadCustomModelsFromConfig loads custom model definitions from the config file
+// and returns them as a map of model ID -> ModelInfo. Returns nil if no custom
+// models are configured.
+func loadCustomModelsFromConfig() map[string]ModelInfo {
+	if !viper.IsSet("customModels") {
+		return nil
+	}
+
+	var customModels map[string]CustomModelConfig
+	if err := viper.UnmarshalKey("customModels", &customModels); err != nil {
+		log.Printf("Warning: Failed to parse customModels: %v", err)
+		return nil
+	}
+
+	result := make(map[string]ModelInfo, len(customModels))
+	for modelID, cfg := range customModels {
+		info := modelConfigToModelInfo(modelID, cfg)
+		result[modelID] = info
+	}
+
+	return result
+}
+
+// modelConfigToModelInfo converts a CustomModelConfig to a ModelInfo.
+func modelConfigToModelInfo(modelID string, cfg CustomModelConfig) ModelInfo {
+	return ModelInfo{
+		ID:          modelID,
+		Name:        cfg.Name,
+		Attachment:  cfg.Attachment,
+		Reasoning:   cfg.Reasoning,
+		Temperature: cfg.Temperature,
+		Cost: Cost{
+			Input:  cfg.Cost.Input,
+			Output: cfg.Cost.Output,
+		},
+		Limit: Limit{
+			Context: cfg.Limit.Context,
+			Output:  cfg.Limit.Output,
+		},
+	}
+}
+
+// CustomModelConfig defines a custom model configuration loaded from the config file.
+// This is a duplicate here to avoid circular dependencies with internal/config.
+type CustomModelConfig struct {
+	Name        string      `json:"name" yaml:"name"`
+	Family      string      `json:"family,omitempty" yaml:"family,omitempty"`
+	Attachment  bool        `json:"attachment,omitempty" yaml:"attachment,omitempty"`
+	Reasoning   bool        `json:"reasoning,omitempty" yaml:"reasoning,omitempty"`
+	Temperature bool        `json:"temperature,omitempty" yaml:"temperature,omitempty"`
+	Knowledge   string      `json:"knowledge,omitempty" yaml:"knowledge,omitempty"`
+	Cost        CostConfig  `json:"cost" yaml:"cost"`
+	Limit       LimitConfig `json:"limit" yaml:"limit"`
+}
+
+// CostConfig defines the pricing for a custom model.
+type CostConfig struct {
+	Input  float64 `json:"input" yaml:"input"`
+	Output float64 `json:"output" yaml:"output"`
+}
+
+// LimitConfig defines context and output limits for a custom model.
+type LimitConfig struct {
+	Context int `json:"context" yaml:"context"`
+	Output  int `json:"output" yaml:"output"`
+}

internal/models/modelsdb.go

@@ -17,15 +17,21 @@ type modelsDBProvider struct {
 
 // modelsDBModel represents a model entry from models.dev/api.json.
 type modelsDBModel struct {
-	ID          string        `json:"id"`
-	Name        string        `json:"name"`
-	Family      string        `json:"family,omitempty"`
-	Attachment  bool          `json:"attachment"`
-	Reasoning   bool          `json:"reasoning"`
-	ToolCall    bool          `json:"tool_call"`
-	Temperature bool          `json:"temperature"`
-	Cost        modelsDBCost  `json:"cost"`
-	Limit       modelsDBLimit `json:"limit"`
+	ID          string                 `json:"id"`
+	Name        string                 `json:"name"`
+	Family      string                 `json:"family,omitempty"`
+	Attachment  bool                   `json:"attachment"`
+	Reasoning   bool                   `json:"reasoning"`
+	ToolCall    bool                   `json:"tool_call"`
+	Temperature bool                   `json:"temperature"`
+	Cost        modelsDBCost           `json:"cost"`
+	Limit       modelsDBLimit          `json:"limit"`
+	Provider    *modelsDBModelProvider `json:"provider,omitempty"` // Model-specific provider override
+}
+
+// modelsDBModelProvider represents a provider reference within a model.
+type modelsDBModelProvider struct {
+	NPM string `json:"npm"`
 }
 
 // modelsDBCost represents model pricing from models.dev.

internal/models/pool.go

@@ -166,28 +166,3 @@ func (p *ProviderPool) Close() {
 	}
 	p.mu.Unlock()
 }
-
-// Stats returns current pool statistics.
-func (p *ProviderPool) Stats() PoolStats {
-	p.mu.RLock()
-	defer p.mu.RUnlock()
-
-	stats := PoolStats{
-		TotalProviders: len(p.providers),
-	}
-	for _, pp := range p.providers {
-		if pp.refs > 0 {
-			stats.ActiveProviders++
-		} else {
-			stats.IdleProviders++
-		}
-	}
-	return stats
-}
-
-// PoolStats contains provider pool statistics.
-type PoolStats struct {
-	TotalProviders  int
-	ActiveProviders int
-	IdleProviders   int
-}

internal/models/providers.go

@@ -37,19 +37,42 @@ func resolveModelAlias(provider, modelName string) string {
 	registry := GetGlobalRegistry()
 
 	aliasMap := map[string]string{
-		"claude-opus-latest":     "claude-opus-4-20250514",
-		"claude-sonnet-latest":   "claude-sonnet-4-5-20250929",
-		"claude-4-opus-latest":   "claude-opus-4-20250514",
-		"claude-4-sonnet-latest": "claude-sonnet-4-5-20250929",
-
+		// Anthropic aliases
+		"claude-opus-latest":       "claude-opus-4-6",
+		"claude-sonnet-latest":     "claude-sonnet-4-6",
+		"claude-haiku-latest":      "claude-haiku-4-5",
+		"claude-4-opus-latest":     "claude-opus-4-6",
+		"claude-4-sonnet-latest":   "claude-sonnet-4-6",
+		"claude-4-haiku-latest":    "claude-haiku-4-5",
 		"claude-3-5-haiku-latest":  "claude-3-5-haiku-20241022",
 		"claude-3-5-sonnet-latest": "claude-3-5-sonnet-20241022",
 		"claude-3-7-sonnet-latest": "claude-3-7-sonnet-20250219",
 		"claude-3-opus-latest":     "claude-3-opus-20240229",
+
+		// OpenAI aliases
+		"gpt-5-latest":      "gpt-5.4",
+		"gpt-5-chat-latest": "gpt-5.4",
+		"gpt-4-latest":      "gpt-4o",
+		"gpt-4":             "gpt-4o",
+		"gpt-3.5":           "gpt-3.5-turbo",
+		"gpt-3.5-latest":    "gpt-3.5-turbo",
+		"o1-latest":         "o1",
+		"o3-latest":         "o3",
+		"o4-latest":         "o4-mini",
+		"codex-latest":      "codex-mini-latest",
+
+		// Google Gemini aliases
+		"gemini-pro-latest": "gemini-2.5-pro",
+		"gemini-flash":      "gemini-2.5-flash",
+		"gemini-pro":        "gemini-2.5-pro",
+		"gemini-2-flash":    "gemini-2.0-flash",
+		"gemini-2-pro":      "gemini-2.5-pro",
+		"gemini-1.5-flash":  "gemini-1.5-flash",
+		"gemini-1.5-pro":    "gemini-1.5-pro",
 	}
 
 	if resolved, exists := aliasMap[modelName]; exists {
-		if _, err := registry.ValidateModel(provider, resolved); err == nil {
+		if registry.LookupModel(provider, resolved) != nil {
 			return resolved
 		}
 	}
@@ -73,8 +96,8 @@ func ThinkingLevels() []ThinkingLevel {
 	return []ThinkingLevel{ThinkingOff, ThinkingMinimal, ThinkingLow, ThinkingMedium, ThinkingHigh}
 }
 
-// ThinkingBudgetTokens returns the token budget for a thinking level, or 0 for "off".
-func ThinkingBudgetTokens(level ThinkingLevel) int64 {
+// thinkingBudgetTokens returns the token budget for a thinking level, or 0 for "off".
+func thinkingBudgetTokens(level ThinkingLevel) int64 {
 	switch level {
 	case ThinkingMinimal:
 		return 1024
@@ -146,6 +169,9 @@ type ProviderResult struct {
 	// ProviderOptions contains provider-specific options to be passed to the
 	// fantasy agent (e.g. OpenAI Responses API reasoning options).
 	ProviderOptions fantasy.ProviderOptions
+	// SkipMaxOutputTokens indicates that this provider doesn't support the
+	// max_output_tokens parameter (e.g., OpenAI Codex OAuth API).
+	SkipMaxOutputTokens bool
 }
 
 // ParseModelString parses a model string in "provider/model" format (e.g. "anthropic/claude-sonnet-4-5").
@@ -162,16 +188,6 @@ func ParseModelString(modelString string) (provider, model string, err error) {
 		return "", "", fmt.Errorf("invalid model format %q: expected provider/model (e.g. anthropic/claude-sonnet-4-5)", modelString)
 	}
 
-	// Legacy colon-separated format
-	if strings.Contains(modelString, ":") {
-		parts := strings.SplitN(modelString, ":", 2)
-		if len(parts) == 2 && parts[0] != "" && parts[1] != "" {
-			fmt.Fprintf(os.Stderr, "Warning: model format %q uses deprecated colon separator. Use %s/%s instead.\n",
-				modelString, parts[0], parts[1])
-			return parts[0], parts[1], nil
-		}
-	}
-
 	return "", "", fmt.Errorf("invalid model format %q: expected provider/model (e.g. anthropic/claude-sonnet-4-5)", modelString)
 }
 
@@ -190,8 +206,8 @@ func CreateProvider(ctx context.Context, config *ProviderConfig) (*ProviderResul
 		return nil, err
 	}
 
-	// Resolve model aliases (for OAuth compatibility)
-	if provider == "anthropic" || provider == "google-vertex-anthropic" {
+	// Resolve model aliases to full model names
+	if provider == "anthropic" || provider == "google-vertex-anthropic" || provider == "openai" || provider == "google" {
 		modelName = resolveModelAlias(provider, modelName)
 	}
 
@@ -240,6 +256,8 @@ func CreateProvider(ctx context.Context, config *ProviderConfig) (*ProviderResul
 		return createBedrockProvider(ctx, config, modelName)
 	case "vercel":
 		return createVercelProvider(ctx, config, modelName)
+	case "custom":
+		return createCustomProvider(ctx, config, modelName)
 	default:
 		return autoRouteProvider(ctx, config, provider, modelName, registry)
 	}
@@ -248,14 +266,22 @@ func CreateProvider(ctx context.Context, config *ProviderConfig) (*ProviderResul
 // autoRouteProvider attempts to create a provider by looking up its npm package
 // in the models.dev database and routing through the appropriate fantasy provider.
 // For openai-compatible providers, it uses the api URL from models.dev.
+// Models may have a provider override that specifies a different npm package than
+// the provider's default (e.g., opencode's claude-opus-4-6 uses @ai-sdk/anthropic).
 func autoRouteProvider(ctx context.Context, config *ProviderConfig, provider, modelName string, registry *ModelsRegistry) (*ProviderResult, error) {
 	providerInfo := registry.GetProviderInfo(provider)
 	if providerInfo == nil {
 		return nil, fmt.Errorf("unsupported provider: %s (not found in model database)", provider)
 	}
 
+	// Check for model-specific provider override
+	npmPackage := providerInfo.NPM
+	if modelInfo := registry.LookupModel(provider, modelName); modelInfo != nil && modelInfo.ProviderNPM != "" {
+		npmPackage = modelInfo.ProviderNPM
+	}
+
 	// Determine the fantasy provider for this npm package
-	fantasyProvider := npmToFantasyProvider[providerInfo.NPM]
+	fantasyProvider := npmToFantasyProvider[npmPackage]
 	if fantasyProvider == "" && providerInfo.API != "" {
 		// Unknown npm but has API URL → route through openaicompat
 		fantasyProvider = "openaicompat"
@@ -275,7 +301,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, providerInfo.NPM)
+		return nil, fmt.Errorf("unsupported provider: %s (npm: %s has no fantasy mapping)", provider, npmPackage)
 	}
 }
 
@@ -333,7 +359,10 @@ func createAutoRoutedAnthropicProvider(ctx context.Context, config *ProviderConf
 	opts = append(opts, anthropic.WithAPIKey(apiKey))
 
 	if config.ProviderURL != "" {
-		opts = append(opts, anthropic.WithBaseURL(config.ProviderURL))
+		// The anthropic client appends "/v1/messages" to the base URL.
+		// If the provider URL ends with "/v1", strip it to avoid double "/v1/v1" paths.
+		baseURL := strings.TrimSuffix(config.ProviderURL, "/v1")
+		opts = append(opts, anthropic.WithBaseURL(baseURL))
 	}
 
 	if config.TLSSkipVerify {
@@ -489,7 +518,7 @@ func buildAnthropicProviderOptions(config *ProviderConfig, modelName string) fan
 		return nil
 	}
 
-	budget := ThinkingBudgetTokens(config.ThinkingLevel)
+	budget := thinkingBudgetTokens(config.ThinkingLevel)
 	if budget == 0 {
 		return nil
 	}
@@ -595,13 +624,52 @@ func createVertexAnthropicProvider(ctx context.Context, config *ProviderConfig,
 
 func createOpenAIProvider(ctx context.Context, config *ProviderConfig, modelName string) (*ProviderResult, error) {
 	apiKey := config.ProviderAPIKey
+	source := "command-line flag"
+	var accountID string
+	var isCodexOAuth bool
+
 	if apiKey == "" {
-		apiKey = os.Getenv("OPENAI_API_KEY")
-	}
-	if apiKey == "" {
-		return nil, fmt.Errorf("OpenAI API key not provided. Use --provider-api-key flag or OPENAI_API_KEY environment variable")
+		// Check stored credentials first
+		cm, err := auth.NewCredentialManager()
+		if err == nil {
+			if creds, err := cm.GetOpenAICredentials(); err == nil && creds != nil {
+				if creds.Type == "oauth" && creds.AccessToken != "" {
+					// For OAuth, get a valid access token (may refresh if needed)
+					token, err := cm.GetValidOpenAIAccessToken()
+					if err == nil && token != "" {
+						apiKey = token
+						accountID = creds.AccountID
+						isCodexOAuth = true
+						source = "stored Codex OAuth credentials"
+					}
+				} else if creds.Type == "api_key" && creds.APIKey != "" {
+					apiKey = creds.APIKey
+					source = "stored API key"
+				}
+			}
+		}
 	}
 
+	// Fall back to environment variable
+	if apiKey == "" {
+		apiKey = os.Getenv("OPENAI_API_KEY")
+		source = "OPENAI_API_KEY environment variable"
+	}
+
+	if apiKey == "" {
+		return nil, fmt.Errorf("OpenAI API key not provided. Use 'kit auth login openai', --provider-api-key flag, or OPENAI_API_KEY environment variable")
+	}
+
+	if os.Getenv("DEBUG") != "" || os.Getenv("KIT_DEBUG") != "" {
+		fmt.Fprintf(os.Stderr, "Using OpenAI API key from: %s\n", source)
+	}
+
+	// For Codex OAuth, use the ChatGPT backend API with custom headers
+	if isCodexOAuth {
+		return createOpenAICodexProvider(ctx, config, modelName, apiKey, accountID)
+	}
+
+	// Regular OpenAI API key flow
 	var opts []openai.Option
 	opts = append(opts, openai.WithAPIKey(apiKey))
 	opts = append(opts, openai.WithUseResponsesAPI())
@@ -630,6 +698,135 @@ func createOpenAIProvider(ctx context.Context, config *ProviderConfig, modelName
 	return &ProviderResult{Model: model, ProviderOptions: providerOpts}, nil
 }
 
+// createOpenAICodexProvider creates a provider for ChatGPT/Codex OAuth tokens.
+// Uses the chatgpt.com/backend-api/codex endpoint with special headers.
+func createOpenAICodexProvider(ctx context.Context, config *ProviderConfig, modelName, token, accountID string) (*ProviderResult, error) {
+	// Check for spark models which are not accessible via OAuth
+	if detectCodexModelFamily(modelName) == "gpt-codex-spark" {
+		return nil, fmt.Errorf("gpt-codex-spark models are not accessible via ChatGPT OAuth. " +
+			"These models require special access or a different authentication method. " +
+			"Please use regular Codex models like 'openai/gpt-5.3-codex' instead")
+	}
+
+	// Use the ChatGPT backend API with /codex path
+	baseURL := "https://chatgpt.com/backend-api/codex"
+	if config.ProviderURL != "" {
+		baseURL = config.ProviderURL
+	}
+
+	// Build custom HTTP client with required headers
+	httpClient := createCodexHTTPClient(token, accountID, config.TLSSkipVerify)
+
+	var opts []openai.Option
+	opts = append(opts, openai.WithAPIKey(token))
+	opts = append(opts, openai.WithBaseURL(baseURL))
+	opts = append(opts, openai.WithUseResponsesAPI())
+	opts = append(opts, openai.WithHTTPClient(httpClient))
+
+	provider, err := openai.New(opts...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create OpenAI Codex provider: %w", err)
+	}
+
+	model, err := provider.LanguageModel(ctx, modelName)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create OpenAI Codex model: %w", err)
+	}
+
+	providerOpts := buildCodexProviderOptions(config, modelName)
+
+	return &ProviderResult{
+		Model:               model,
+		ProviderOptions:     providerOpts,
+		SkipMaxOutputTokens: true,
+	}, nil
+}
+
+// buildCodexProviderOptions returns fantasy.ProviderOptions configured for
+// OpenAI Codex API. The Codex API requires the system prompt to be passed
+// as 'instructions' rather than as a system message.
+func buildCodexProviderOptions(config *ProviderConfig, modelName string) fantasy.ProviderOptions {
+	store := false
+	opts := &openai.ResponsesProviderOptions{
+		Store: &store,
+	}
+
+	if config.SystemPrompt != "" {
+		opts.Instructions = &config.SystemPrompt
+	}
+
+	if openai.IsResponsesReasoningModel(modelName) {
+		opts.ReasoningEffort = thinkingLevelToReasoningEffort(config.ThinkingLevel)
+	}
+
+	return fantasy.ProviderOptions{openai.Name: opts}
+}
+
+// detectCodexModelFamily determines the model family from the model name
+func detectCodexModelFamily(modelName string) string {
+	modelName = strings.ToLower(modelName)
+	if strings.Contains(modelName, "spark") {
+		return "gpt-codex-spark"
+	}
+	if strings.Contains(modelName, "codex-mini") || strings.Contains(modelName, "mini-latest") {
+		return "gpt-codex-mini"
+	}
+	if strings.Contains(modelName, "codex") {
+		return "gpt-codex"
+	}
+	return ""
+}
+
+// createCodexHTTPClient creates an HTTP client with headers required for ChatGPT/Codex API
+func createCodexHTTPClient(token, accountID string, skipVerify bool) *http.Client {
+	var base http.RoundTripper
+	if skipVerify {
+		base = &http.Transport{
+			TLSClientConfig: &tls.Config{
+				InsecureSkipVerify: true,
+			},
+		}
+	} else {
+		base = http.DefaultTransport
+	}
+
+	return &http.Client{
+		Transport: &codexTransport{
+			base:      base,
+			token:     token,
+			accountID: accountID,
+		},
+		Timeout: 120 * time.Second,
+	}
+}
+
+// codexTransport is a custom RoundTripper that adds ChatGPT/Codex specific headers
+type codexTransport struct {
+	base      http.RoundTripper
+	token     string
+	accountID string
+}
+
+func (t *codexTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	newReq := req.Clone(req.Context())
+
+	// Add required headers for ChatGPT/Codex API
+	// These headers mimic the official pi client to avoid Cloudflare blocking
+	newReq.Header.Set("Authorization", "Bearer "+t.token)
+	if t.accountID != "" {
+		newReq.Header.Set("chatgpt-account-id", t.accountID)
+	}
+	newReq.Header.Set("originator", "kit")
+	newReq.Header.Set("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
+	newReq.Header.Set("OpenAI-Beta", "responses=experimental")
+	newReq.Header.Set("Accept", "text/event-stream")
+	newReq.Header.Set("Accept-Language", "en-US,en;q=0.9")
+	newReq.Header.Set("Cache-Control", "no-cache")
+	newReq.Header.Set("Pragma", "no-cache")
+
+	return t.base.RoundTrip(newReq)
+}
+
 func createGoogleProvider(ctx context.Context, config *ProviderConfig, modelName string) (*ProviderResult, error) {
 	apiKey := firstNonEmpty(
 		config.ProviderAPIKey,
@@ -766,6 +963,42 @@ func createVercelProvider(ctx context.Context, config *ProviderConfig, modelName
 	return &ProviderResult{Model: model}, nil
 }
 
+func createCustomProvider(ctx context.Context, config *ProviderConfig, modelName string) (*ProviderResult, error) {
+	if config.ProviderURL == "" {
+		return nil, fmt.Errorf("custom provider requires --provider-url")
+	}
+
+	apiKey := config.ProviderAPIKey
+	if apiKey == "" {
+		apiKey = os.Getenv("CUSTOM_API_KEY")
+	}
+	if apiKey == "" {
+		// Many local/custom endpoints don't require a key; use a placeholder.
+		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"))
+
+	if config.TLSSkipVerify {
+		opts = append(opts, openaicompat.WithHTTPClient(createHTTPClientWithTLSConfig(true)))
+	}
+
+	p, err := openaicompat.New(opts...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create custom provider: %w", err)
+	}
+
+	model, err := p.LanguageModel(ctx, modelName)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create custom model: %w", err)
+	}
+
+	return &ProviderResult{Model: model}, nil
+}
+
 func createOllamaProvider(ctx context.Context, config *ProviderConfig, modelName string) (*ProviderResult, error) {
 	baseURL := "http://localhost:11434"
 	if host := os.Getenv("OLLAMA_HOST"); host != "" {

internal/models/registry.go

@@ -22,6 +22,7 @@ type ModelInfo struct {
 	Temperature bool
 	Cost        Cost
 	Limit       Limit
+	ProviderNPM string // Model-specific provider npm override (e.g. "@ai-sdk/anthropic")
 }
 
 // Cost represents the pricing information for a model.
@@ -78,6 +79,10 @@ func buildFromModelsDB() map[string]ProviderInfo {
 	for providerID, dp := range dbProviders {
 		modelsMap := make(map[string]ModelInfo, len(dp.Models))
 		for modelID, dm := range dp.Models {
+			providerNPM := ""
+			if dm.Provider != nil {
+				providerNPM = dm.Provider.NPM
+			}
 			modelsMap[modelID] = ModelInfo{
 				ID:          dm.ID,
 				Name:        dm.Name,
@@ -94,6 +99,7 @@ func buildFromModelsDB() map[string]ProviderInfo {
 					Context: dm.Limit.Context,
 					Output:  dm.Limit.Output,
 				},
+				ProviderNPM: providerNPM,
 			}
 		}
 
@@ -116,6 +122,47 @@ func buildFromModelsDB() map[string]ProviderInfo {
 		}
 	}
 
+	// Register the "custom" provider stub for --provider-url without --model.
+	// This allows users to point kit at any OpenAI-compatible endpoint without
+	// needing to specify a model from the database.
+	providers["custom"] = ProviderInfo{
+		ID:   "custom",
+		Name: "Custom",
+		Models: map[string]ModelInfo{
+			"custom": {
+				ID:          "custom",
+				Name:        "Custom",
+				Attachment:  false,
+				Reasoning:   true,
+				Temperature: true,
+				Cost: Cost{
+					Input:  0,
+					Output: 0,
+				},
+				Limit: Limit{
+					Context: 262_144,
+					Output:  65_536,
+				},
+			},
+		},
+	}
+
+	// Load custom models from config file and merge into custom provider.
+	// Config file models take precedence - if a model ID exists in both
+	// models.dev and config, the config version wins.
+	if customModels := loadCustomModelsFromConfig(); customModels != nil {
+		for modelID, info := range customModels {
+			// Validate custom model config
+			if info.Limit.Context <= 0 {
+				fmt.Fprintf(os.Stderr, "Warning: custom model %q has invalid context limit: %d\n", modelID, info.Limit.Context)
+			}
+			if info.Limit.Output <= 0 {
+				fmt.Fprintf(os.Stderr, "Warning: custom model %q has invalid output limit: %d\n", modelID, info.Limit.Output)
+			}
+			providers["custom"].Models[modelID] = info
+		}
+	}
+
 	return providers
 }
 
@@ -147,24 +194,8 @@ func (r *ModelsRegistry) LookupModel(provider, modelID string) *ModelInfo {
 	return &modelInfo
 }
 
-// ValidateModel validates if a model exists and returns detailed information.
-// Deprecated: Use LookupModel instead — it returns nil for unknown models
-// rather than an error, letting the provider API be the authority.
-func (r *ModelsRegistry) ValidateModel(provider, modelID string) (*ModelInfo, error) {
-	if info := r.LookupModel(provider, modelID); info != nil {
-		return info, nil
-	}
-
-	providerInfo, exists := r.providers[provider]
-	if !exists {
-		return nil, fmt.Errorf("unsupported provider: %s", provider)
-	}
-
-	return nil, fmt.Errorf("model %s not found for provider %s", modelID, providerInfo.ID)
-}
-
-// GetRequiredEnvVars returns the required environment variables for a provider.
-func (r *ModelsRegistry) GetRequiredEnvVars(provider string) ([]string, error) {
+// getRequiredEnvVars returns the required environment variables for a provider.
+func (r *ModelsRegistry) getRequiredEnvVars(provider string) ([]string, error) {
 	providerInfo, exists := r.providers[provider]
 	if !exists {
 		return nil, fmt.Errorf("unsupported provider: %s", provider)
@@ -194,7 +225,16 @@ func (r *ModelsRegistry) ValidateEnvironment(provider string, apiKey string) err
 		}
 	}
 
-	envVars, err := r.GetRequiredEnvVars(provider)
+	// For openai, check stored credentials (OAuth / API key)
+	if provider == "openai" {
+		if cm, err := auth.NewCredentialManager(); err == nil {
+			if has, _ := cm.HasOpenAICredentials(); has {
+				return nil
+			}
+		}
+	}
+
+	envVars, err := r.getRequiredEnvVars(provider)
 	if err != nil {
 		// Unknown provider — nothing to validate
 		return nil

internal/prompts/frontmatter.go

@@ -0,0 +1,25 @@
+package prompts
+
+import (
+	"fmt"
+
+	"gopkg.in/yaml.v3"
+)
+
+// frontmatterSep is the YAML frontmatter delimiter.
+const frontmatterSep = "---"
+
+// Frontmatter represents the YAML frontmatter in a prompt template file.
+type Frontmatter struct {
+	// Description summarises what this template provides.
+	Description string `yaml:"description"`
+}
+
+// ParseFrontmatter parses YAML frontmatter content into a Frontmatter struct.
+func ParseFrontmatter(content string) (*Frontmatter, error) {
+	var fm Frontmatter
+	if err := yaml.Unmarshal([]byte(content), &fm); err != nil {
+		return nil, fmt.Errorf("parsing frontmatter: %w", err)
+	}
+	return &fm, nil
+}

internal/prompts/loader.go

@@ -0,0 +1,217 @@
+package prompts
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/charmbracelet/log"
+)
+
+// LoadOptions configures how templates are discovered and loaded.
+type LoadOptions struct {
+	// Cwd is the current working directory for project-local discovery.
+	// If empty, the current working directory is used.
+	Cwd string
+	// HomeDir is the user's home directory. If empty, os.UserHomeDir() is used.
+	HomeDir string
+	// ExtraPaths are additional explicit paths to search for templates.
+	ExtraPaths []string
+	// ConfigPaths are paths from configuration files to search.
+	ConfigPaths []string
+	// IncludeDefaults determines whether to include built-in default templates.
+	IncludeDefaults bool
+}
+
+// Diagnostic reports a template collision or loading issue.
+type Diagnostic struct {
+	// Name is the template name that had a collision.
+	Name string
+	// KeptPath is the path of the template that was kept (higher precedence).
+	KeptPath string
+	// DroppedPath is the path of the template that was dropped.
+	DroppedPath string
+	// Reason explains why the collision occurred.
+	Reason string
+}
+
+// LoadAll discovers and loads all prompt templates from standard locations
+// and any extra paths. Templates are loaded in order of precedence (lowest
+// to highest), with later templates overriding earlier ones of the same name.
+//
+// Discovery paths searched in order:
+//  1. Default templates (if IncludeDefaults)
+//  2. ~/.kit/prompts/ (global user templates)
+//  3. .kit/prompts/ (project-local templates)
+//  4. ConfigPaths (from configuration)
+//  5. ExtraPaths (explicit paths, highest precedence)
+func LoadAll(opts LoadOptions) ([]*PromptTemplate, []Diagnostic, error) {
+	if opts.Cwd == "" {
+		opts.Cwd, _ = os.Getwd()
+	}
+
+	if opts.HomeDir == "" {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return nil, nil, fmt.Errorf("getting home directory: %w", err)
+		}
+		opts.HomeDir = home
+	}
+
+	var all []*PromptTemplate
+	var diagnostics []Diagnostic
+	seen := make(map[string]*PromptTemplate) // name -> template
+
+	// Helper to add templates with deduplication tracking
+	addTemplates := func(templates []*PromptTemplate, source string) {
+		for _, tpl := range templates {
+			if existing, ok := seen[tpl.Name]; ok {
+				// Collision: report diagnostic, keep existing (lower precedence wins)
+				diagnostics = append(diagnostics, Diagnostic{
+					Name:        tpl.Name,
+					KeptPath:    existing.FilePath,
+					DroppedPath: tpl.FilePath,
+					Reason:      fmt.Sprintf("template from %s overridden by %s", source, existing.Source),
+				})
+				log.Debug("template collision",
+					"name", tpl.Name,
+					"dropped", tpl.FilePath,
+					"kept", existing.FilePath)
+			} else {
+				tpl.Source = source
+				seen[tpl.Name] = tpl
+				all = append(all, tpl)
+			}
+		}
+	}
+
+	// 1. Default templates (lowest precedence)
+	if opts.IncludeDefaults {
+		defaults := loadDefaultTemplates()
+		addTemplates(defaults, "default")
+	}
+
+	// 2. Global user templates: ~/.kit/prompts/
+	globalDir := filepath.Join(opts.HomeDir, ".kit", "prompts")
+	if templates, err := LoadFromDir(globalDir); err == nil {
+		addTemplates(templates, "global")
+	}
+
+	// 3. Project-local templates: .kit/prompts/
+	localDir := filepath.Join(opts.Cwd, ".kit", "prompts")
+	if templates, err := LoadFromDir(localDir); err == nil {
+		addTemplates(templates, "local")
+	}
+
+	// 4. Config paths
+	for _, path := range opts.ConfigPaths {
+		info, err := os.Stat(path)
+		if err != nil {
+			continue
+		}
+		if info.IsDir() {
+			if templates, err := LoadFromDir(path); err == nil {
+				addTemplates(templates, "config")
+			}
+		} else if strings.HasSuffix(path, ".md") {
+			if tpl, err := ParseTemplate(path); err == nil {
+				addTemplates([]*PromptTemplate{tpl}, "config")
+			}
+		}
+	}
+
+	// 5. Extra paths (highest precedence)
+	for _, path := range opts.ExtraPaths {
+		info, err := os.Stat(path)
+		if err != nil {
+			continue
+		}
+		if info.IsDir() {
+			if templates, err := LoadFromDir(path); err == nil {
+				addTemplates(templates, "explicit")
+			}
+		} else if strings.HasSuffix(path, ".md") {
+			if tpl, err := ParseTemplate(path); err == nil {
+				addTemplates([]*PromptTemplate{tpl}, "explicit")
+			}
+		}
+	}
+
+	return all, diagnostics, nil
+}
+
+// LoadFromDir scans a directory for .md files and loads them as templates.
+// It looks for *.md files directly in the directory.
+// Files that fail to parse are logged and skipped.
+func LoadFromDir(dir string) ([]*PromptTemplate, error) {
+	info, err := os.Stat(dir)
+	if err != nil || !info.IsDir() {
+		return nil, nil // directory doesn't exist — not an error
+	}
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return nil, fmt.Errorf("reading prompts directory %s: %w", dir, err)
+	}
+
+	var templates []*PromptTemplate
+	var errs []string
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+
+		name := entry.Name()
+		if !strings.HasSuffix(name, ".md") {
+			continue
+		}
+
+		full := filepath.Join(dir, name)
+		tpl, err := ParseTemplate(full)
+		if err != nil {
+			errs = append(errs, err.Error())
+			continue
+		}
+		templates = append(templates, tpl)
+	}
+
+	if len(errs) > 0 {
+		return templates, fmt.Errorf("some templates failed to load: %s", strings.Join(errs, "; "))
+	}
+	return templates, nil
+}
+
+// Deduplicate removes duplicate templates by name, keeping the first occurrence.
+// It returns the deduplicated list and diagnostics for any collisions.
+// This is a standalone function for when you need to deduplicate an existing list.
+func Deduplicate(templates []*PromptTemplate) ([]*PromptTemplate, []Diagnostic) {
+	seen := make(map[string]*PromptTemplate)
+	var result []*PromptTemplate
+	var diagnostics []Diagnostic
+
+	for _, tpl := range templates {
+		if existing, ok := seen[tpl.Name]; ok {
+			diagnostics = append(diagnostics, Diagnostic{
+				Name:        tpl.Name,
+				KeptPath:    existing.FilePath,
+				DroppedPath: tpl.FilePath,
+				Reason:      "duplicate template name (first-match-wins)",
+			})
+		} else {
+			seen[tpl.Name] = tpl
+			result = append(result, tpl)
+		}
+	}
+
+	return result, diagnostics
+}
+
+// loadDefaultTemplates returns the built-in default templates.
+// These are embedded templates that ship with Kit.
+func loadDefaultTemplates() []*PromptTemplate {
+	// Default templates can be added here as needed
+	// For now, return an empty slice - users can define their own templates
+	return nil
+}

internal/prompts/loader_test.go

@@ -0,0 +1,126 @@
+package prompts
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestLoadAll_Integration(t *testing.T) {
+	// Create a temp directory for testing
+	tempDir := t.TempDir()
+
+	// Create the .kit/prompts subdirectory structure
+	promptsDir := filepath.Join(tempDir, ".kit", "prompts")
+	if err := os.MkdirAll(promptsDir, 0755); err != nil {
+		t.Fatalf("Failed to create prompts dir: %v", err)
+	}
+
+	// Create a test template file
+	templateContent := `---
+description: Test template for integration
+---
+Review $1 with focus on $2`
+
+	testFile := filepath.Join(promptsDir, "test.md")
+	if err := os.WriteFile(testFile, []byte(templateContent), 0644); err != nil {
+		t.Fatalf("Failed to create test file: %v", err)
+	}
+
+	// Test loading from the temp directory
+	tpls, diags, err := LoadAll(LoadOptions{
+		HomeDir:         tempDir,
+		IncludeDefaults: false, // Skip default locations for this test
+	})
+
+	if err != nil {
+		t.Fatalf("LoadAll failed: %v", err)
+	}
+
+	if len(diags) > 0 {
+		t.Logf("Got %d diagnostics", len(diags))
+	}
+
+	if len(tpls) != 1 {
+		t.Fatalf("Expected 1 template, got %d", len(tpls))
+	}
+
+	tpl := tpls[0]
+	if tpl.Name != "test" {
+		t.Errorf("Expected name 'test', got '%s'", tpl.Name)
+	}
+
+	if tpl.Description != "Test template for integration" {
+		t.Errorf("Expected description 'Test template for integration', got '%s'", tpl.Description)
+	}
+
+	// Test expansion
+	expanded := tpl.Expand("code security")
+	expected := "Review code with focus on security"
+	if expanded != expected {
+		t.Errorf("Expected '%s', got '%s'", expected, expanded)
+	}
+}
+
+func TestParseTemplate_WithFrontmatter(t *testing.T) {
+	// Create a temp file with frontmatter
+	tempDir := t.TempDir()
+	templateContent := `---
+description: A test template
+---
+Create a $1 component with $2 features`
+
+	testFile := filepath.Join(tempDir, "component.md")
+	if err := os.WriteFile(testFile, []byte(templateContent), 0644); err != nil {
+		t.Fatalf("Failed to create test file: %v", err)
+	}
+
+	tpl, err := ParseTemplate(testFile)
+	if err != nil {
+		t.Fatalf("ParseTemplate failed: %v", err)
+	}
+
+	if tpl.Name != "component" {
+		t.Errorf("Expected name 'component', got '%s'", tpl.Name)
+	}
+
+	if tpl.Description != "A test template" {
+		t.Errorf("Expected description 'A test template', got '%s'", tpl.Description)
+	}
+
+	expectedContent := "Create a $1 component with $2 features"
+	if tpl.Content != expectedContent {
+		t.Errorf("Expected content '%s', got '%s'", expectedContent, tpl.Content)
+	}
+}
+
+func TestParseTemplate_WithoutFrontmatter(t *testing.T) {
+	// Create a temp file without frontmatter
+	tempDir := t.TempDir()
+	templateContent := `Simple template without frontmatter
+Supports $1 and $2 placeholders`
+
+	testFile := filepath.Join(tempDir, "simple.md")
+	if err := os.WriteFile(testFile, []byte(templateContent), 0644); err != nil {
+		t.Fatalf("Failed to create test file: %v", err)
+	}
+
+	tpl, err := ParseTemplate(testFile)
+	if err != nil {
+		t.Fatalf("ParseTemplate failed: %v", err)
+	}
+
+	if tpl.Name != "simple" {
+		t.Errorf("Expected name 'simple', got '%s'", tpl.Name)
+	}
+
+	// Description should be empty since there's no frontmatter
+	if tpl.Description != "" {
+		t.Errorf("Expected empty description, got '%s'", tpl.Description)
+	}
+
+	// Content should include everything
+	if tpl.Content != templateContent {
+		t.Errorf("Content mismatch\nExpected:\n%s\nGot:\n%s", templateContent, tpl.Content)
+	}
+}

internal/prompts/template.go

@@ -0,0 +1,279 @@
+package prompts
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// PromptTemplate is a named prompt template with shell-style argument placeholders.
+// It supports Pi-style $1, $2, $@, $ARGUMENTS, ${@:N}, ${@:N:L} syntax.
+type PromptTemplate struct {
+	// Name is the human-readable identifier for this template.
+	Name string
+	// Description summarises what this template provides.
+	Description string
+	// Content is the raw template text with placeholders.
+	Content string
+	// Source indicates where the template was loaded from (e.g., "default", "user").
+	Source string
+	// FilePath is the absolute filesystem path the template was loaded from.
+	FilePath string
+}
+
+// ParseTemplate reads a template from a file. The template name is derived
+// from the filename (without extension). If the file contains YAML frontmatter,
+// the description is extracted from it.
+func ParseTemplate(path string) (*PromptTemplate, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("reading template %s: %w", path, err)
+	}
+
+	abs, err := filepath.Abs(path)
+	if err != nil {
+		abs = path
+	}
+
+	content := string(data)
+	tpl := &PromptTemplate{
+		FilePath: abs,
+		Content:  content,
+	}
+
+	// Parse frontmatter if present
+	if strings.HasPrefix(strings.TrimSpace(content), frontmatterSep) {
+		trimmed := strings.TrimSpace(content)
+		rest := trimmed[len(frontmatterSep):]
+		frontmatter, body, found := strings.Cut(rest, "\n"+frontmatterSep)
+		if found {
+			body = strings.TrimPrefix(body, "\n")
+			fm, err := ParseFrontmatter(frontmatter)
+			if err == nil {
+				tpl.Description = fm.Description
+			}
+			tpl.Content = strings.TrimSpace(body)
+		}
+	}
+
+	// Derive name from filename
+	base := filepath.Base(path)
+	ext := filepath.Ext(base)
+	tpl.Name = strings.TrimSuffix(base, ext)
+
+	return tpl, nil
+}
+
+// ParseCommandArgs splits a command line into arguments respecting quotes.
+// It handles single quotes, double quotes, and backslash escaping.
+func ParseCommandArgs(input string) []string {
+	var args []string
+	var current strings.Builder
+	inSingleQuote := false
+	inDoubleQuote := false
+	escaped := false
+
+	for i, r := range input {
+		if escaped {
+			current.WriteRune(r)
+			escaped = false
+			continue
+		}
+
+		if r == '\\' && !inSingleQuote {
+			// Backslash escapes next char, but not in single quotes
+			escaped = true
+			continue
+		}
+
+		if r == '\'' && !inDoubleQuote {
+			inSingleQuote = !inSingleQuote
+			continue
+		}
+
+		if r == '"' && !inSingleQuote {
+			inDoubleQuote = !inDoubleQuote
+			continue
+		}
+
+		if r == ' ' && !inSingleQuote && !inDoubleQuote {
+			if current.Len() > 0 {
+				args = append(args, current.String())
+				current.Reset()
+			}
+			continue
+		}
+
+		current.WriteRune(r)
+		_ = i // silence unused warning when we need position later
+	}
+
+	if current.Len() > 0 {
+		args = append(args, current.String())
+	}
+
+	return args
+}
+
+// argPlaceholder matches shell-style argument placeholders:
+//   - $1, $2, etc. - positional arguments
+//   - $@ - all arguments
+//   - $ARGUMENTS - all arguments (alias for $@)
+//   - ${@:N} - arguments from N onwards
+//   - ${@:N:L} - L arguments starting from N
+var argPlaceholder = regexp.MustCompile(`\$\{(\d+)\}|\$\{(\d+):(\d+)\}|\$\{ARGUMENTS\}|\$\{@(:\d+)?(:\d+)?\}|\$(\d+)|\$@|\$ARGUMENTS`)
+
+// SubstituteArgs replaces argument placeholders in content with values from args.
+// Supported placeholders:
+//   - $N, ${N} - the Nth argument (1-indexed)
+//   - $@, $ARGUMENTS, ${ARGUMENTS} - all arguments joined with spaces
+//   - ${@:N} - arguments from index N onwards (0-indexed)
+//   - ${@:N:L} - L arguments starting from index N (0-indexed)
+func SubstituteArgs(content string, args []string) string {
+	return argPlaceholder.ReplaceAllStringFunc(content, func(match string) string {
+		// Check for ${N} or ${N:M} format
+		if strings.HasPrefix(match, "${") && strings.Contains(match, "}") {
+			inner := match[2 : len(match)-1] // Remove ${ and }
+
+			// Check for ${ARGUMENTS}
+			if inner == "ARGUMENTS" {
+				return strings.Join(args, " ")
+			}
+
+			// Check for ${@...} format
+			if strings.HasPrefix(inner, "@") {
+				return expandAtArgs(inner, args)
+			}
+
+			// Check for ${N:M} format (positional with length)
+			if colonIdx := strings.Index(inner, ":"); colonIdx > 0 {
+				startStr := inner[:colonIdx]
+				rest := inner[colonIdx+1:]
+
+				start, err := strconv.Atoi(startStr)
+				if err != nil || start < 1 {
+					return match
+				}
+
+				// Check if there's a second colon for length ${N:M:L}
+				lengthStr, _, ok := strings.Cut(rest, ":")
+				if ok {
+					length, err := strconv.Atoi(lengthStr)
+					if err != nil || length < 0 {
+						return match
+					}
+					return joinArgsRange(args, start-1, length)
+				}
+
+				// Single colon ${N:M} - M is length
+				length, err := strconv.Atoi(rest)
+				if err != nil || length < 0 {
+					return match
+				}
+				return joinArgsRange(args, start-1, length)
+			}
+
+			// Simple ${N} format
+			n, err := strconv.Atoi(inner)
+			if err != nil || n < 1 {
+				return match
+			}
+			if n <= len(args) {
+				return args[n-1]
+			}
+			return ""
+		}
+
+		// Check for $N format (without braces)
+		if strings.HasPrefix(match, "$") && !strings.HasPrefix(match, "${") {
+			suffix := match[1:]
+
+			// $@ or $ARGUMENTS
+			if suffix == "@" || suffix == "ARGUMENTS" {
+				return strings.Join(args, " ")
+			}
+
+			// $N
+			n, err := strconv.Atoi(suffix)
+			if err != nil || n < 1 {
+				return match
+			}
+			if n <= len(args) {
+				return args[n-1]
+			}
+			return ""
+		}
+
+		return match
+	})
+}
+
+// expandAtArgs handles ${@...} patterns (1-indexed like bash)
+func expandAtArgs(inner string, args []string) string {
+	// Remove the @ prefix
+	rest := inner[1:]
+
+	if rest == "" {
+		// ${@} - all arguments
+		return strings.Join(args, " ")
+	}
+
+	// Must start with :
+	if !strings.HasPrefix(rest, ":") {
+		return "${" + inner + "}"
+	}
+	rest = rest[1:]
+
+	// Parse start index
+	startStr, lengthStr, hasLength := strings.Cut(rest, ":")
+
+	start, err := strconv.Atoi(startStr)
+	if err != nil || start < 0 {
+		return "${" + inner + "}"
+	}
+
+	// Convert from 1-indexed to 0-indexed (bash convention)
+	// Treat 0 as 1 (bash convention: args start at 1)
+	if start > 0 {
+		start--
+	}
+
+	if hasLength {
+		length, err := strconv.Atoi(lengthStr)
+		if err != nil || length < 0 {
+			return "${" + inner + "}"
+		}
+		return joinArgsRange(args, start, length)
+	}
+
+	// ${@:N} - from N to end
+	if start >= len(args) {
+		return ""
+	}
+	return strings.Join(args[start:], " ")
+}
+
+// joinArgsRange joins args from start index, taking up to length elements
+func joinArgsRange(args []string, start, length int) string {
+	if start >= len(args) || length <= 0 {
+		return ""
+	}
+	end := start + length
+	end = min(end, len(args))
+	return strings.Join(args[start:end], " ")
+}
+
+// Expand substitutes arguments into the template content and returns the result.
+// It first parses args from the input string, then substitutes them into the template.
+func (t *PromptTemplate) Expand(argsInput string) string {
+	args := ParseCommandArgs(argsInput)
+	return SubstituteArgs(t.Content, args)
+}
+
+// ExpandWithArgs substitutes the provided arguments into the template content.
+func (t *PromptTemplate) ExpandWithArgs(args []string) string {
+	return SubstituteArgs(t.Content, args)
+}

internal/prompts/template_test.go

@@ -0,0 +1,215 @@
+package prompts
+
+import (
+	"testing"
+)
+
+func TestParseCommandArgs(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected []string
+	}{
+		{"", []string{}},
+		{"hello", []string{"hello"}},
+		{"hello world", []string{"hello", "world"}},
+		{`"hello world"`, []string{"hello world"}},
+		{`'hello world'`, []string{"hello world"}},
+		{`hello "world foo" bar`, []string{"hello", "world foo", "bar"}},
+		{`hello 'world foo' bar`, []string{"hello", "world foo", "bar"}},
+		{`hello \"world\"`, []string{"hello", `"world"`}},
+		{`hello \\world`, []string{"hello", `\world`}},
+		{`  hello   world  `, []string{"hello", "world"}},
+		{`Button "onClick handler" "disabled support"`, []string{"Button", "onClick handler", "disabled support"}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			got := ParseCommandArgs(tt.input)
+			if len(got) != len(tt.expected) {
+				t.Errorf("ParseCommandArgs(%q) = %v, want %v", tt.input, got, tt.expected)
+				return
+			}
+			for i := range got {
+				if got[i] != tt.expected[i] {
+					t.Errorf("ParseCommandArgs(%q)[%d] = %q, want %q", tt.input, i, got[i], tt.expected[i])
+				}
+			}
+		})
+	}
+}
+
+func TestSubstituteArgs(t *testing.T) {
+	tests := []struct {
+		name     string
+		content  string
+		args     []string
+		expected string
+	}{
+		{
+			name:     "no placeholders",
+			content:  "Hello world",
+			args:     []string{},
+			expected: "Hello world",
+		},
+		{
+			name:     "positional $1",
+			content:  "Hello $1",
+			args:     []string{"world"},
+			expected: "Hello world",
+		},
+		{
+			name:     "positional $1 $2",
+			content:  "$1 and $2",
+			args:     []string{"first", "second"},
+			expected: "first and second",
+		},
+		{
+			name:     "missing arg",
+			content:  "Hello $1 and $2",
+			args:     []string{"world"},
+			expected: "Hello world and ",
+		},
+		{
+			name:     "$@ wildcard",
+			content:  "Args: $@",
+			args:     []string{"a", "b", "c"},
+			expected: "Args: a b c",
+		},
+		{
+			name:     "$ARGUMENTS wildcard",
+			content:  "Args: $ARGUMENTS",
+			args:     []string{"a", "b", "c"},
+			expected: "Args: a b c",
+		},
+		{
+			name:     "${@} all args",
+			content:  "Args: ${@}",
+			args:     []string{"a", "b", "c"},
+			expected: "Args: a b c",
+		},
+		{
+			name:     "${@:2} slice from index 2",
+			content:  "Rest: ${@:2}",
+			args:     []string{"a", "b", "c", "d"},
+			expected: "Rest: b c d",
+		},
+		{
+			name:     "${@:1:2} slice with length",
+			content:  "First two: ${@:1:2}",
+			args:     []string{"a", "b", "c", "d"},
+			expected: "First two: a b",
+		},
+		{
+			name:     "${@:0} from start",
+			content:  "All: ${@:0}",
+			args:     []string{"a", "b", "c"},
+			expected: "All: a b c",
+		},
+		{
+			name:     "${@:3:1} single arg",
+			content:  "Third: ${@:3:1}",
+			args:     []string{"a", "b", "c", "d"},
+			expected: "Third: c",
+		},
+		{
+			name:     "combined placeholders",
+			content:  "Create $1 with features: $ARGUMENTS",
+			args:     []string{"Button", "onClick", "disabled"},
+			expected: "Create Button with features: Button onClick disabled",
+		},
+		{
+			name:     "slice beyond bounds",
+			content:  "${@:10}",
+			args:     []string{"a", "b"},
+			expected: "",
+		},
+		{
+			name:     "empty args with wildcard",
+			content:  "Args: $@",
+			args:     []string{},
+			expected: "Args: ",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := SubstituteArgs(tt.content, tt.args)
+			if got != tt.expected {
+				t.Errorf("SubstituteArgs(%q, %v) = %q, want %q", tt.content, tt.args, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestParseFrontmatter(t *testing.T) {
+	tests := []struct {
+		name     string
+		content  string
+		wantDesc string
+		wantErr  bool
+	}{
+		{
+			name:     "simple description",
+			content:  "description: Review code\n",
+			wantDesc: "Review code",
+		},
+		{
+			name:     "empty",
+			content:  "",
+			wantDesc: "",
+		},
+		{
+			name:     "invalid yaml",
+			content:  "description: [unclosed",
+			wantDesc: "",
+			wantErr:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			fm, err := ParseFrontmatter(tt.content)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ParseFrontmatter() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if err != nil {
+				return
+			}
+			if fm.Description != tt.wantDesc {
+				t.Errorf("ParseFrontmatter() Description = %q, want %q", fm.Description, tt.wantDesc)
+			}
+		})
+	}
+}
+
+func TestPromptTemplateExpand(t *testing.T) {
+	tpl := &PromptTemplate{
+		Name:        "component",
+		Description: "Create a component",
+		Content:     "Create a React component named $1 with features: $ARGUMENTS",
+	}
+
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{
+			input:    "Button",
+			expected: "Create a React component named Button with features: Button",
+		},
+		{
+			input:    `Button "onClick handler"`,
+			expected: "Create a React component named Button with features: Button onClick handler",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			got := tpl.Expand(tt.input)
+			if got != tt.expected {
+				t.Errorf("Expand(%q) = %q, want %q", tt.input, got, tt.expected)
+			}
+		})
+	}
+}

internal/session/entry.go

@@ -23,6 +23,7 @@ const (
 	EntryTypeLabel         EntryType = "label"
 	EntryTypeSessionInfo   EntryType = "session_info"
 	EntryTypeExtensionData EntryType = "extension_data"
+	EntryTypeCompaction    EntryType = "compaction"
 )
 
 // CurrentVersion is the session format version for JSONL tree sessions.
@@ -102,6 +103,20 @@ type ExtensionDataEntry struct {
 	Data    string `json:"data"`     // Extension-defined data (JSON or plain text)
 }
 
+// CompactionEntry records an LLM-generated summary of older messages.
+// Instead of deleting old messages, the tree manager skips entries before
+// FirstKeptEntryID when building the LLM context, preserving full history.
+type CompactionEntry struct {
+	Entry
+	Summary          string   `json:"summary"`
+	FirstKeptEntryID string   `json:"first_kept_entry_id"`
+	TokensBefore     int      `json:"tokens_before"`
+	TokensAfter      int      `json:"tokens_after"`
+	MessagesRemoved  int      `json:"messages_removed"`
+	ReadFiles        []string `json:"read_files,omitempty"`
+	ModifiedFiles    []string `json:"modified_files,omitempty"`
+}
+
 // GenerateEntryID creates a unique entry identifier (16 hex chars).
 func GenerateEntryID() string {
 	bytes := make([]byte, 8)
@@ -144,17 +159,6 @@ func NewMessageEntry(parentID string, msg message.Message) (*MessageEntry, error
 	}, nil
 }
 
-// NewMessageEntryFromRaw creates a MessageEntry with pre-marshaled parts.
-func NewMessageEntryFromRaw(parentID, role string, parts json.RawMessage, model, provider string) *MessageEntry {
-	return &MessageEntry{
-		Entry:    NewEntry(EntryTypeMessage, parentID),
-		Role:     role,
-		Parts:    parts,
-		Model:    model,
-		Provider: provider,
-	}
-}
-
 // NewModelChangeEntry creates a ModelChangeEntry.
 func NewModelChangeEntry(parentID, provider, modelID string) *ModelChangeEntry {
 	return &ModelChangeEntry{
@@ -199,6 +203,20 @@ func NewExtensionDataEntry(parentID, extType, data string) *ExtensionDataEntry {
 	}
 }
 
+// NewCompactionEntry creates a CompactionEntry.
+func NewCompactionEntry(parentID, summary, firstKeptEntryID string, tokensBefore, tokensAfter, messagesRemoved int, readFiles, modifiedFiles []string) *CompactionEntry {
+	return &CompactionEntry{
+		Entry:            NewEntry(EntryTypeCompaction, parentID),
+		Summary:          summary,
+		FirstKeptEntryID: firstKeptEntryID,
+		TokensBefore:     tokensBefore,
+		TokensAfter:      tokensAfter,
+		MessagesRemoved:  messagesRemoved,
+		ReadFiles:        readFiles,
+		ModifiedFiles:    modifiedFiles,
+	}
+}
+
 // --- JSONL marshaling helpers ---
 
 // MarshalEntry serializes any entry to a JSON line (no trailing newline).
@@ -270,6 +288,13 @@ func UnmarshalEntry(data []byte) (any, error) {
 		}
 		return &e, nil
 
+	case EntryTypeCompaction:
+		var e CompactionEntry
+		if err := json.Unmarshal(data, &e); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal compaction entry: %w", err)
+		}
+		return &e, nil
+
 	default:
 		return nil, fmt.Errorf("unknown entry type: %q", env.Type)
 	}

internal/session/store.go

@@ -96,6 +96,7 @@ func ListAllSessions() ([]SessionInfo, error) {
 }
 
 // listSessionsInDir reads all .jsonl files in a directory and extracts session info.
+// Empty sessions (no messages) are automatically cleaned up and not returned.
 func listSessionsInDir(dir string) ([]SessionInfo, error) {
 	if _, err := os.Stat(dir); os.IsNotExist(err) {
 		return nil, nil
@@ -117,6 +118,11 @@ func listSessionsInDir(dir string) ([]SessionInfo, error) {
 		if err != nil {
 			continue // skip malformed session files
 		}
+		// Clean up and skip empty sessions (no messages)
+		if info.MessageCount == 0 {
+			_ = os.Remove(path)
+			continue
+		}
 		sessions = append(sessions, *info)
 	}
 
@@ -253,27 +259,3 @@ func extractTextPreview(partsJSON json.RawMessage) string {
 func DeleteSession(path string) error {
 	return os.Remove(path)
 }
-
-// ListChildSessions returns all sessions that have the given session ID as
-// their parent. This is useful for finding subagent sessions spawned from
-// a parent session. Results are sorted by creation time (newest first).
-func ListChildSessions(parentID string) ([]SessionInfo, error) {
-	if parentID == "" {
-		return nil, nil
-	}
-
-	allSessions, err := ListAllSessions()
-	if err != nil {
-		return nil, err
-	}
-
-	var children []SessionInfo
-	for _, s := range allSessions {
-		if s.ParentSessionID == parentID {
-			children = append(children, s)
-		}
-	}
-
-	// Already sorted by modification time from ListAllSessions
-	return children, nil
-}

internal/session/tree_manager.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"encoding/json"
 	"fmt"
+	"io"
 	"os"
 	"path/filepath"
 	"strings"
@@ -128,10 +129,34 @@ func OpenTreeSession(path string) (*TreeManager, error) {
 		filePath:   path,
 	}
 
-	scanner := bufio.NewScanner(strings.NewReader(string(data)))
+	reader := bufio.NewReader(strings.NewReader(string(data)))
 	lineNum := 0
-	for scanner.Scan() {
-		line := scanner.Text()
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				// Process the last line if it's not empty
+				if strings.TrimSpace(line) != "" {
+					lineNum++
+					entry, err := UnmarshalEntry([]byte(line))
+					if err != nil {
+						return nil, fmt.Errorf("line %d: %w", lineNum, err)
+					}
+					if lineNum == 1 {
+						h, ok := entry.(*SessionHeader)
+						if !ok {
+							return nil, fmt.Errorf("first line must be a session header, got %T", entry)
+						}
+						tm.header = *h
+					} else {
+						tm.addEntryToIndex(entry)
+					}
+				}
+				break
+			}
+			return nil, fmt.Errorf("failed to read session file: %w", err)
+		}
+
 		if strings.TrimSpace(line) == "" {
 			continue
 		}
@@ -153,9 +178,6 @@ func OpenTreeSession(path string) (*TreeManager, error) {
 
 		tm.addEntryToIndex(entry)
 	}
-	if err := scanner.Err(); err != nil {
-		return nil, fmt.Errorf("failed to scan session file: %w", err)
-	}
 
 	// Set leaf to the last entry.
 	if len(tm.entries) > 0 {
@@ -298,6 +320,22 @@ func (tm *TreeManager) AppendExtensionData(extType, data string) (string, error)
 	return entry.ID, nil
 }
 
+// AppendCompaction adds a compaction entry to the tree. The entry records
+// the summary and the ID of the first entry that should be preserved in the
+// LLM context. Messages before that entry are replaced by the summary.
+func (tm *TreeManager) AppendCompaction(summary, firstKeptEntryID string, tokensBefore, tokensAfter, messagesRemoved int, readFiles, modifiedFiles []string) (string, error) {
+	tm.mu.Lock()
+	defer tm.mu.Unlock()
+
+	entry := NewCompactionEntry(tm.leafID, summary, firstKeptEntryID, tokensBefore, tokensAfter, messagesRemoved, readFiles, modifiedFiles)
+	if err := tm.appendAndPersist(entry); err != nil {
+		return "", err
+	}
+
+	tm.leafID = entry.ID
+	return entry.ID, nil
+}
+
 // GetExtensionData returns all extension data entries matching the given type,
 // walking the current branch from root to leaf. If extType is empty, all
 // extension data entries on the branch are returned.
@@ -441,8 +479,9 @@ func (tm *TreeManager) GetTree() []*TreeNode {
 // --- Context building ---
 
 // BuildContext walks from the current leaf to the root and returns the
-// conversation messages suitable for sending to the LLM. Branch summaries
-// are converted to user messages to provide context from abandoned branches.
+// conversation messages suitable for sending to the LLM. Compaction entries
+// cause older messages to be replaced by the summary. Branch summaries are
+// converted to user messages to provide context from abandoned branches.
 // Also returns the latest model/provider settings encountered on the path.
 func (tm *TreeManager) BuildContext() (messages []fantasy.Message, provider string, modelID string) {
 	tm.mu.RLock()
@@ -455,7 +494,41 @@ func (tm *TreeManager) BuildContext() (messages []fantasy.Message, provider stri
 	// Walk from leaf to root collecting entries.
 	branch := tm.getBranchLocked(tm.leafID)
 
+	// Find the last compaction entry on this branch — it determines
+	// which older messages are replaced by the summary.
+	var lastCompaction *CompactionEntry
+	for i := len(branch) - 1; i >= 0; i-- {
+		if c, ok := branch[i].(*CompactionEntry); ok {
+			lastCompaction = c
+			break
+		}
+	}
+
+	// If there is a compaction, inject the summary first.
+	if lastCompaction != nil {
+		messages = append(messages, fantasy.Message{
+			Role: fantasy.MessageRoleSystem,
+			Content: []fantasy.MessagePart{
+				fantasy.TextPart{
+					Text: fmt.Sprintf("[Conversation summary — earlier messages were compacted]\n\n%s", lastCompaction.Summary),
+				},
+			},
+		})
+	}
+
+	// Determine whether to skip entries (everything before firstKeptEntryID).
+	skipping := lastCompaction != nil
 	for _, entry := range branch {
+		// Once we reach the first kept entry, stop skipping.
+		if skipping {
+			entryID := tm.entryID(entry)
+			if entryID == lastCompaction.FirstKeptEntryID {
+				skipping = false
+			} else {
+				continue
+			}
+		}
+
 		switch e := entry.(type) {
 		case *MessageEntry:
 			msg, err := e.ToMessage()
@@ -481,6 +554,10 @@ func (tm *TreeManager) BuildContext() (messages []fantasy.Message, provider stri
 		case *ModelChangeEntry:
 			provider = e.Provider
 			modelID = e.ModelID
+
+		case *CompactionEntry:
+			// Already handled above (the last one on the branch).
+			continue
 		}
 	}
 
@@ -551,6 +628,11 @@ func (tm *TreeManager) MessageCount() int {
 	return count
 }
 
+// IsEmpty returns true if the session has no messages (only header).
+func (tm *TreeManager) IsEmpty() bool {
+	return tm.MessageCount() == 0
+}
+
 // Close closes the underlying file handle.
 func (tm *TreeManager) Close() error {
 	tm.mu.Lock()
@@ -563,6 +645,96 @@ func (tm *TreeManager) Close() error {
 	return nil
 }
 
+// GetContextEntryIDs returns the entry IDs corresponding to the fantasy
+// messages returned by BuildContext, in the same order. Each entry ID maps
+// to the session entry that produced the fantasy message at the same index.
+// This is used by compaction to map a cut point index back to an entry ID.
+//
+// Note: A single MessageEntry produces at most one fantasy message. Branch
+// summary entries also produce one message each. The returned slice has the
+// same length as the messages slice from BuildContext (excluding the
+// compaction summary system message, which has no entry ID — it gets the
+// empty string "").
+func (tm *TreeManager) GetContextEntryIDs() []string {
+	tm.mu.RLock()
+	defer tm.mu.RUnlock()
+
+	if tm.leafID == "" {
+		return nil
+	}
+
+	branch := tm.getBranchLocked(tm.leafID)
+
+	// Find the last compaction entry for skip logic.
+	var lastCompaction *CompactionEntry
+	for i := len(branch) - 1; i >= 0; i-- {
+		if c, ok := branch[i].(*CompactionEntry); ok {
+			lastCompaction = c
+			break
+		}
+	}
+
+	var ids []string
+
+	// If there's a compaction summary injected, it has no entry ID.
+	if lastCompaction != nil {
+		ids = append(ids, "") // placeholder for the summary system message
+	}
+
+	skipping := lastCompaction != nil
+	for _, entry := range branch {
+		if skipping {
+			entryID := tm.entryID(entry)
+			if entryID == lastCompaction.FirstKeptEntryID {
+				skipping = false
+			} else {
+				continue
+			}
+		}
+
+		switch e := entry.(type) {
+		case *MessageEntry:
+			msg, err := e.ToMessage()
+			if err != nil {
+				continue
+			}
+			msgs := msg.ToFantasyMessages()
+			for range msgs {
+				ids = append(ids, e.ID)
+			}
+
+		case *BranchSummaryEntry:
+			if e.Summary != "" {
+				ids = append(ids, e.ID)
+			}
+
+		case *CompactionEntry:
+			continue
+		}
+	}
+
+	return ids
+}
+
+// GetLastCompaction returns the most recent CompactionEntry on the current
+// branch, or nil if none exists. Used to carry forward file tracking.
+func (tm *TreeManager) GetLastCompaction() *CompactionEntry {
+	tm.mu.RLock()
+	defer tm.mu.RUnlock()
+
+	if tm.leafID == "" {
+		return nil
+	}
+
+	branch := tm.getBranchLocked(tm.leafID)
+	for i := len(branch) - 1; i >= 0; i-- {
+		if c, ok := branch[i].(*CompactionEntry); ok {
+			return c
+		}
+	}
+	return nil
+}
+
 // --- Legacy bridge ---
 
 // AddFantasyMessages appends multiple fantasy messages as entries. This is
@@ -641,6 +813,8 @@ func (tm *TreeManager) entryID(entry any) string {
 		return e.ID
 	case *ExtensionDataEntry:
 		return e.ID
+	case *CompactionEntry:
+		return e.ID
 	default:
 		return ""
 	}
@@ -661,6 +835,8 @@ func (tm *TreeManager) entryParentID(entry any) string {
 		return e.ParentID
 	case *ExtensionDataEntry:
 		return e.ParentID
+	case *CompactionEntry:
+		return e.ParentID
 	default:
 		return ""
 	}

internal/tools/connection_pool.go

@@ -127,9 +127,7 @@ func (p *MCPConnectionPool) GetConnection(ctx context.Context, serverName string
 			return conn, nil
 		} else {
 			if p.debugLogger != nil && p.debugLogger.IsDebugEnabled() {
-				if p.debugLogger != nil && p.debugLogger.IsDebugEnabled() {
-					p.debugLogger.LogDebug(fmt.Sprintf("[POOL] Connection %s unhealthy, removing", serverName))
-				}
+				p.debugLogger.LogDebug(fmt.Sprintf("[POOL] Connection %s unhealthy, removing", serverName))
 			}
 			_ = conn.client.Close()
 			delete(p.connections, serverName)

internal/tools/mcp_test.go

@@ -3,6 +3,7 @@ package tools
 import (
 	"context"
 	"encoding/json"
+	"strings"
 	"testing"
 	"time"
 
@@ -70,7 +71,7 @@ func TestMCPToolManager_LoadTools_GracefulFailure(t *testing.T) {
 	}
 
 	// The error should mention that all servers failed
-	if err != nil && !contains(err.Error(), "all MCP servers failed") {
+	if err != nil && !strings.Contains(err.Error(), "all MCP servers failed") {
 		t.Errorf("Expected error message to mention all servers failed, got: %v", err)
 	}
 
@@ -460,12 +461,4 @@ func sliceEqual(a, b []any) bool {
 	return true
 }
 
-// Helper function to check if a string contains a substring
-func contains(s, substr string) bool {
-	for i := 0; i <= len(s)-len(substr); i++ {
-		if s[i:i+len(substr)] == substr {
-			return true
-		}
-	}
-	return false
-}
+

internal/ui/children_test.go

@@ -349,7 +349,7 @@ func TestStreamComponent_SpinnerKeepsRunningDuringStreaming(t *testing.T) {
 	c = sendStreamMsg(c, app.StreamChunkEvent{Content: "hello"})
 
 	// Flush pending chunks (simulates the 16ms tick firing).
-	c = sendStreamMsg(c, streamFlushTickMsg{})
+	c = sendStreamMsg(c, streamFlushTickMsg{generation: c.flushGeneration})
 
 	if !c.spinning {
 		t.Fatal("expected spinning=true after first chunk")
@@ -376,7 +376,7 @@ func TestStreamComponent_ChunkAccumulation(t *testing.T) {
 	}
 
 	// Flush pending chunks (simulates the 16ms tick firing).
-	c = sendStreamMsg(c, streamFlushTickMsg{})
+	c = sendStreamMsg(c, streamFlushTickMsg{generation: c.flushGeneration})
 
 	got := c.streamContent.String()
 	want := "Hello, world!"
@@ -396,6 +396,7 @@ func TestStreamComponent_ToolExecution_IsStarting_ShowsSpinner(t *testing.T) {
 	c := newTestStream()
 
 	_, cmd := c.Update(app.ToolExecutionEvent{
+		ToolCallID: "call-exec-1",
 		ToolName:   "exec_tool",
 		IsStarting: true,
 	})
@@ -403,8 +404,9 @@ func TestStreamComponent_ToolExecution_IsStarting_ShowsSpinner(t *testing.T) {
 	if !c.spinning {
 		t.Fatal("expected spinning=true during tool execution")
 	}
-	if len(c.activeTools) != 1 || !strings.Contains(c.activeTools[0], "exec_tool") {
-		t.Fatalf("expected activeTools to contain tool name, got %v", c.activeTools)
+	tools := c.activeToolDisplays()
+	if len(tools) != 1 || !strings.Contains(tools[0], "exec_tool") {
+		t.Fatalf("expected activeTools to contain tool name, got %v", tools)
 	}
 	if cmd == nil {
 		t.Fatal("expected tick cmd from ToolExecutionEvent{IsStarting:true}")
@@ -418,11 +420,13 @@ func TestStreamComponent_ToolExecution_NotStarting_KeepsSpinning(t *testing.T) {
 	c = sendStreamMsg(c, app.SpinnerEvent{Show: true})
 	// Simulate a tool starting
 	c = sendStreamMsg(c, app.ToolExecutionEvent{
+		ToolCallID: "call-some-1",
 		ToolName:   "some_tool",
 		IsStarting: true,
 	})
 
 	c = sendStreamMsg(c, app.ToolExecutionEvent{
+		ToolCallID: "call-some-1",
 		ToolName:   "some_tool",
 		IsStarting: false,
 	})
@@ -440,9 +444,9 @@ func TestStreamComponent_ParallelToolExecution(t *testing.T) {
 	c := newTestStream()
 
 	// Start three tools in parallel
-	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolName: "read", IsStarting: true})
-	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolName: "grep", IsStarting: true})
-	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolName: "find", IsStarting: true})
+	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolCallID: "call-read", ToolName: "read", IsStarting: true})
+	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolCallID: "call-grep", ToolName: "grep", IsStarting: true})
+	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolCallID: "call-find", ToolName: "find", IsStarting: true})
 
 	if len(c.activeTools) != 3 {
 		t.Fatalf("expected 3 active tools, got %d: %v", len(c.activeTools), c.activeTools)
@@ -455,19 +459,44 @@ func TestStreamComponent_ParallelToolExecution(t *testing.T) {
 	}
 
 	// Finish one tool
-	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolName: "grep", IsStarting: false})
+	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolCallID: "call-grep", ToolName: "grep", IsStarting: false})
 	if len(c.activeTools) != 2 {
 		t.Fatalf("expected 2 active tools after one finished, got %d: %v", len(c.activeTools), c.activeTools)
 	}
 
 	// Finish remaining tools
-	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolName: "read", IsStarting: false})
-	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolName: "find", IsStarting: false})
+	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolCallID: "call-read", ToolName: "read", IsStarting: false})
+	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolCallID: "call-find", ToolName: "find", IsStarting: false})
 	if len(c.activeTools) != 0 {
 		t.Fatalf("expected 0 active tools after all finished, got %d: %v", len(c.activeTools), c.activeTools)
 	}
 }
 
+// TestStreamComponent_ParallelSameToolName_UsesToolCallID verifies finishing one
+// tool call does not remove another concurrent call with the same tool name.
+func TestStreamComponent_ParallelSameToolName_UsesToolCallID(t *testing.T) {
+	c := newTestStream()
+
+	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolCallID: "call-read-1", ToolName: "read", IsStarting: true})
+	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolCallID: "call-read-2", ToolName: "read", IsStarting: true})
+
+	tools := c.activeToolDisplays()
+	if len(tools) != 2 {
+		t.Fatalf("expected 2 active read calls, got %d (%v)", len(tools), tools)
+	}
+
+	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolCallID: "call-read-1", ToolName: "read", IsStarting: false})
+	tools = c.activeToolDisplays()
+	if len(tools) != 1 {
+		t.Fatalf("expected 1 active read call after finishing one ID, got %d (%v)", len(tools), tools)
+	}
+
+	c = sendStreamMsg(c, app.ToolExecutionEvent{ToolCallID: "call-read-2", ToolName: "read", IsStarting: false})
+	if len(c.activeToolDisplays()) != 0 {
+		t.Fatalf("expected no active tools after finishing both IDs, got %v", c.activeToolDisplays())
+	}
+}
+
 // --------------------------------------------------------------------------
 // TestStreamComponent_GetRenderedContent verifies the method returns rendered
 // text when content is accumulated, and empty string when not.
@@ -560,9 +589,10 @@ func TestStreamComponent_SpinnerTick_AdvancesFrame(t *testing.T) {
 	// Start spinning first.
 	c = sendStreamMsg(c, app.SpinnerEvent{Show: true})
 	initialFrame := c.spinnerFrame
+	gen := c.spinnerGeneration
 
-	// Send a tick.
-	_, cmd := c.Update(streamSpinnerTickMsg{})
+	// Send a tick with the current generation.
+	_, cmd := c.Update(streamSpinnerTickMsg{generation: gen})
 
 	if c.spinnerFrame != initialFrame+1 {
 		t.Fatalf("expected spinnerFrame=%d, got %d", initialFrame+1, c.spinnerFrame)
@@ -583,3 +613,80 @@ func TestStreamComponent_SpinnerTick_NoReschedule_WhenNotSpinning(t *testing.T)
 		t.Fatal("expected no tick reschedule when not spinning")
 	}
 }
+
+// TestStreamComponent_StaleTick_Discarded verifies that a tick from a previous
+// spinner generation is silently discarded, preventing duplicate concurrent
+// tick loops that would double the animation speed.
+func TestStreamComponent_StaleTick_Discarded(t *testing.T) {
+	c := newTestStream()
+
+	// Start spinner → generation 1.
+	c = sendStreamMsg(c, app.SpinnerEvent{Show: true})
+	staleGen := c.spinnerGeneration
+
+	// Stop spinner → generation bumped to 2.
+	c = sendStreamMsg(c, app.SpinnerEvent{Show: false})
+
+	// Restart spinner → generation bumped to 3.
+	c = sendStreamMsg(c, app.SpinnerEvent{Show: true})
+	currentGen := c.spinnerGeneration
+	frameBefore := c.spinnerFrame
+
+	// Simulate a stale tick from the first spinner session arriving.
+	_, cmd := c.Update(streamSpinnerTickMsg{generation: staleGen})
+	if c.spinnerFrame != frameBefore {
+		t.Fatalf("stale tick should not advance frame: expected %d, got %d", frameBefore, c.spinnerFrame)
+	}
+	if cmd != nil {
+		t.Fatal("stale tick should not reschedule")
+	}
+
+	// A tick from the current generation should still work.
+	_, cmd = c.Update(streamSpinnerTickMsg{generation: currentGen})
+	if c.spinnerFrame != frameBefore+1 {
+		t.Fatalf("current-gen tick should advance frame: expected %d, got %d", frameBefore+1, c.spinnerFrame)
+	}
+	if cmd == nil {
+		t.Fatal("current-gen tick should reschedule")
+	}
+}
+
+// TestStreamComponent_StaleFlushTick_Discarded verifies that flush ticks from a
+// previous generation (e.g. pre-Reset) are ignored.
+func TestStreamComponent_StaleFlushTick_Discarded(t *testing.T) {
+	c := newTestStream()
+
+	// Start a pending flush and capture its generation.
+	c = sendStreamMsg(c, app.StreamChunkEvent{Content: "old"})
+	staleGen := c.flushGeneration
+	if !c.flushPending {
+		t.Fatal("precondition: expected flushPending=true after first chunk")
+	}
+
+	// Reset should invalidate in-flight flush ticks.
+	c.Reset()
+	if c.flushGeneration == staleGen {
+		t.Fatal("expected flushGeneration to change after Reset")
+	}
+
+	// New content in a new generation.
+	c = sendStreamMsg(c, app.StreamChunkEvent{Content: "new"})
+	if got := c.pendingStream.String(); got != "new" {
+		t.Fatalf("expected pendingStream='new', got %q", got)
+	}
+
+	// Stale flush tick should be ignored.
+	c = sendStreamMsg(c, streamFlushTickMsg{generation: staleGen})
+	if got := c.pendingStream.String(); got != "new" {
+		t.Fatalf("stale flush tick should not commit pending stream, got %q", got)
+	}
+
+	// Current generation flush should commit.
+	c = sendStreamMsg(c, streamFlushTickMsg{generation: c.flushGeneration})
+	if got := c.pendingStream.String(); got != "" {
+		t.Fatalf("expected pendingStream empty after current flush, got %q", got)
+	}
+	if got := c.streamContent.String(); got != "new" {
+		t.Fatalf("expected streamContent='new' after current flush, got %q", got)
+	}
+}

internal/ui/cli.go

@@ -36,7 +36,7 @@ func NewCLI(debug bool, compact bool) (*CLI, error) {
 	if compact {
 		cli.renderer = NewCompactRenderer(cli.width, debug)
 	} else {
-		cli.renderer = NewMessageRenderer(cli.width, debug)
+		cli.renderer = newMessageRenderer(cli.width, debug)
 	}
 
 	return cli, nil
@@ -108,13 +108,6 @@ func (c *CLI) DisplayAssistantMessageWithModel(message, modelName string) error
 	return nil
 }
 
-// DisplayToolCallMessage is a no-op retained for backward compatibility. Tool
-// calls are now rendered as part of the unified tool block in DisplayToolMessage,
-// which combines the invocation header with the execution result.
-func (c *CLI) DisplayToolCallMessage(toolName, toolArgs string) {
-	// No-op: unified tool blocks are rendered in DisplayToolMessage.
-}
-
 // DisplayToolMessage renders and displays the complete result of a tool execution,
 // including the tool name, arguments, and result. The isError parameter determines
 // whether the result should be displayed as an error or success message.
@@ -141,7 +134,7 @@ func (c *CLI) DisplayInfo(message string) {
 func (c *CLI) DisplayExtensionBlock(text, borderColor, subtitle string) {
 	theme := GetTheme()
 
-	var borderClr = lipgloss.Color("#89b4fa")
+	borderClr := theme.Info
 	if borderColor != "" {
 		borderClr = lipgloss.Color(borderColor)
 	}
@@ -186,9 +179,8 @@ func (c *CLI) DisplayDebugConfig(config map[string]any) {
 }
 
 // UpdateUsageFromResponse records token usage using metadata from the fantasy
-// response when available. Falls back to text-based estimation if the metadata is
-// missing or appears unreliable. This provides more accurate usage tracking when
-// providers supply token count information.
+// response. Only actual API-reported tokens are used for cost tracking.
+// If the provider doesn't report token counts, no usage is recorded.
 func (c *CLI) UpdateUsageFromResponse(response *fantasy.Response, inputText string) {
 	if c.usageTracker == nil {
 		return
@@ -198,19 +190,19 @@ func (c *CLI) UpdateUsageFromResponse(response *fantasy.Response, inputText stri
 	inputTokens := int(usage.InputTokens)
 	outputTokens := int(usage.OutputTokens)
 
-	// Validate that the metadata seems reasonable
-	if inputTokens > 0 && outputTokens > 0 {
+	// Only use actual API-reported tokens for cost tracking.
+	// We intentionally do NOT estimate tokens - estimation is inaccurate
+	// and should never be used for cost calculations.
+	if inputTokens > 0 {
 		cacheReadTokens := int(usage.CacheReadTokens)
 		cacheWriteTokens := int(usage.CacheCreationTokens)
 		c.usageTracker.UpdateUsage(inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens)
 		// Per-response usage is a single API call, so it represents the
 		// actual context window fill level.
 		c.usageTracker.SetContextTokens(inputTokens + outputTokens)
-	} else {
-		// Fallback to estimation if no metadata is available.
-		// EstimateAndUpdateUsage sets context tokens internally.
-		c.usageTracker.EstimateAndUpdateUsage(inputText, response.Content.Text())
 	}
+	// If inputTokens is 0, the provider didn't report usage - we skip recording
+	// rather than estimating, to ensure cost accuracy.
 }
 
 // DisplayUsageAfterResponse renders and displays token usage information immediately

internal/ui/commands.go

@@ -94,6 +94,24 @@ var SlashCommands = []SlashCommand{
 			return matches
 		},
 	},
+	{
+		Name:        "/theme",
+		Description: "Switch color theme (e.g. /theme catppuccin)",
+		Category:    "System",
+		Complete: func(prefix string) []string {
+			names := ListThemes()
+			if prefix == "" {
+				return names
+			}
+			var matches []string
+			for _, n := range names {
+				if strings.HasPrefix(n, strings.ToLower(prefix)) {
+					matches = append(matches, n)
+				}
+			}
+			return matches
+		},
+	},
 	{
 		Name:        "/quit",
 		Description: "Exit the application",
@@ -123,6 +141,27 @@ var SlashCommands = []SlashCommand{
 		Description: "Set a display name for this session",
 		Category:    "Navigation",
 	},
+	{
+		Name:        "/resume",
+		Description: "Open session picker to switch sessions",
+		Category:    "Navigation",
+		Aliases:     []string{"/r"},
+	},
+	{
+		Name:        "/export",
+		Description: "Export session (JSONL by default, or /export path.jsonl)",
+		Category:    "System",
+	},
+	{
+		Name:        "/share",
+		Description: "Share session via GitHub Gist (requires gh CLI)",
+		Category:    "System",
+	},
+	{
+		Name:        "/import",
+		Description: "Import a session from a JSONL file (/import path.jsonl)",
+		Category:    "System",
+	},
 	{
 		Name:        "/session",
 		Description: "Show session info and statistics",

internal/ui/compact_renderer.go

@@ -82,9 +82,20 @@ func (r *CompactRenderer) RenderUserMessage(content string, timestamp time.Time)
 }
 
 // RenderAssistantMessage renders an AI assistant's response in compact format with
-// a distinctive symbol (<) and the model name as label. Empty content is displayed
-// as "(no output)". Returns a UIMessage with formatted content and metadata.
+// 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("<")
 
@@ -94,12 +105,6 @@ func (r *CompactRenderer) RenderAssistantMessage(content string, timestamp time.
 	}
 	label := lipgloss.NewStyle().Foreground(theme.Primary).Bold(true).Render(modelName)
 
-	// Format content for assistant messages (preserve formatting, no truncation)
-	compactContent := r.formatUserAssistantContent(content)
-	if compactContent == "" {
-		compactContent = lipgloss.NewStyle().Foreground(theme.Muted).Italic(true).Render("(no output)")
-	}
-
 	// Handle multi-line content
 	lines := strings.Split(compactContent, "\n")
 	var formattedLines []string
@@ -122,30 +127,6 @@ func (r *CompactRenderer) RenderAssistantMessage(content string, timestamp time.
 	}
 }
 
-// RenderToolCallMessage renders a tool call notification in compact format, showing
-// the tool being executed with its arguments in a single line. The tool name is
-// highlighted and arguments are displayed in a muted color for visual distinction.
-func (r *CompactRenderer) RenderToolCallMessage(toolName, toolArgs string, timestamp time.Time) UIMessage {
-	theme := getTheme()
-	symbol := lipgloss.NewStyle().Foreground(theme.Tool).Render("[")
-	label := lipgloss.NewStyle().Foreground(theme.Tool).Bold(true).Render(toolName)
-
-	// Format args for compact display
-	argsDisplay := r.formatToolArgs(toolArgs)
-	if argsDisplay != "" {
-		argsDisplay = lipgloss.NewStyle().Foreground(theme.Muted).Render(argsDisplay)
-	}
-
-	line := fmt.Sprintf("%s  %s %s", symbol, label, argsDisplay)
-
-	return UIMessage{
-		Type:      ToolCallMessage,
-		Content:   line,
-		Height:    1,
-		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.

internal/ui/enhanced_styles.go

@@ -39,9 +39,26 @@ func SetTheme(theme Theme) {
 	currentTheme = theme
 }
 
+// MarkdownThemeColors defines colors for markdown rendering and syntax highlighting.
+type MarkdownThemeColors struct {
+	Text    color.Color
+	Muted   color.Color
+	Heading color.Color
+	Emph    color.Color
+	Strong  color.Color
+	Link    color.Color
+	Code    color.Color
+	Error   color.Color
+	Keyword color.Color
+	String  color.Color
+	Number  color.Color
+	Comment color.Color
+}
+
 // Theme defines a comprehensive color scheme for the application's UI, supporting
-// both light and dark terminal modes through adaptive colors. It includes semantic
-// colors for different message types and UI elements, based on the Catppuccin color palette.
+// both light and dark terminal modes through adaptive colors. Inspired by the
+// Knight Rider KITT aesthetic — scanner reds, amber dashboard glows, and dark
+// cockpit tones.
 type Theme struct {
 	Primary     color.Color
 	Secondary   color.Color
@@ -70,40 +87,60 @@ type Theme struct {
 	CodeBg   color.Color // Background for code blocks (Read tool)
 	GutterBg color.Color // Line-number gutter background
 	WriteBg  color.Color // Green-tinted bg for Write tool content
+
+	// Markdown rendering and syntax highlighting colors
+	Markdown MarkdownThemeColors
 }
 
-// DefaultTheme creates and returns the default KIT theme based on the Catppuccin
-// Mocha (dark) and Latte (light) color palettes. This theme provides a cohesive,
-// pleasant visual experience with carefully selected colors for different UI elements.
+// DefaultTheme creates and returns the default KIT theme inspired by the
+// Knight Rider KITT aesthetic — scanner reds, amber dashboard glows, and a
+// dark cockpit. No blues or bright greens; everything stays in the warm
+// red/amber/gray family of KITT's instrument panel.
 func DefaultTheme() Theme {
 	return Theme{
-		Primary:     AdaptiveColor("#8839ef", "#cba6f7"), // Latte/Mocha Mauve
-		Secondary:   AdaptiveColor("#04a5e5", "#89dceb"), // Latte/Mocha Sky
-		Success:     AdaptiveColor("#40a02b", "#a6e3a1"), // Latte/Mocha Green
-		Warning:     AdaptiveColor("#df8e1d", "#f9e2af"), // Latte/Mocha Yellow
-		Error:       AdaptiveColor("#d20f39", "#f38ba8"), // Latte/Mocha Red
-		Info:        AdaptiveColor("#1e66f5", "#89b4fa"), // Latte/Mocha Blue
-		Text:        AdaptiveColor("#4c4f69", "#cdd6f4"), // Latte/Mocha Text
-		Muted:       AdaptiveColor("#6c6f85", "#a6adc8"), // Latte/Mocha Subtext 0
-		VeryMuted:   AdaptiveColor("#9ca0b0", "#6c7086"), // Latte/Mocha Overlay 0
-		Background:  AdaptiveColor("#eff1f5", "#1e1e2e"), // Latte/Mocha Base
-		Border:      AdaptiveColor("#acb0be", "#585b70"), // Latte/Mocha Surface 2
-		MutedBorder: AdaptiveColor("#ccd0da", "#313244"), // Latte/Mocha Surface 0
-		System:      AdaptiveColor("#179299", "#94e2d5"), // Latte/Mocha Teal
-		Tool:        AdaptiveColor("#fe640b", "#fab387"), // Latte/Mocha Peach
-		Accent:      AdaptiveColor("#ea76cb", "#f5c2e7"), // Latte/Mocha Pink
-		Highlight:   AdaptiveColor("#e6e9ef", "#181825"), // Latte Mantle / Mocha Mantle
+		Primary:     AdaptiveColor("#CC1100", "#FF2200"), // KITT scanner red
+		Secondary:   AdaptiveColor("#CC6600", "#FF8800"), // Amber dashboard glow
+		Success:     AdaptiveColor("#998800", "#CCAA00"), // Warm gold — system OK
+		Warning:     AdaptiveColor("#CC8800", "#FFB800"), // Amber caution light
+		Error:       AdaptiveColor("#CC0000", "#FF3333"), // Alert red
+		Info:        AdaptiveColor("#BB6600", "#DD8833"), // Warm amber readout
+		Text:        AdaptiveColor("#1A1A1A", "#E0E0E0"), // Console text
+		Muted:       AdaptiveColor("#707070", "#808080"), // Dimmed readout
+		VeryMuted:   AdaptiveColor("#A0A0A0", "#505050"), // Inactive element
+		Background:  AdaptiveColor("#F0F0F0", "#0D0D0D"), // Cockpit interior
+		Border:      AdaptiveColor("#B0B0B0", "#3A3A3A"), // Panel edge
+		MutedBorder: AdaptiveColor("#D0D0D0", "#222222"), // Subtle divider
+		System:      AdaptiveColor("#CC6600", "#FF8800"), // Amber system status
+		Tool:        AdaptiveColor("#CC6600", "#FF8800"), // Amber instrument
+		Accent:      AdaptiveColor("#DD2222", "#FF4444"), // Secondary scanner glow
+		Highlight:   AdaptiveColor("#FFF0F0", "#1A1010"), // Red-tinted mantle
 
-		// Diff backgrounds — subtle tinted variants of the base palette
-		DiffInsertBg:  AdaptiveColor("#d5f0d5", "#1a3a2a"), // Green tint
-		DiffDeleteBg:  AdaptiveColor("#f5d5d5", "#3a1a2a"), // Red tint
-		DiffEqualBg:   AdaptiveColor("#eceef3", "#232336"), // Neutral
-		DiffMissingBg: AdaptiveColor("#e4e6eb", "#1a1a2e"), // Darker neutral
+		// Diff backgrounds
+		DiffInsertBg:  AdaptiveColor("#F0E8D0", "#2A2410"), // Warm amber tint (added)
+		DiffDeleteBg:  AdaptiveColor("#F5D5D5", "#2E1A1A"), // Red tint (removed)
+		DiffEqualBg:   AdaptiveColor("#E8E8E8", "#161616"), // Neutral
+		DiffMissingBg: AdaptiveColor("#E0E0E0", "#111111"), // Darker neutral
 
 		// Code & output backgrounds
-		CodeBg:   AdaptiveColor("#eceef3", "#232336"), // Matches DiffEqualBg
-		GutterBg: AdaptiveColor("#e4e6eb", "#1a1a2e"), // Slightly darker
-		WriteBg:  AdaptiveColor("#d5f0d5", "#1a3a2a"), // Matches DiffInsertBg (green tint)
+		CodeBg:   AdaptiveColor("#E8E8E8", "#161616"), // Matches DiffEqualBg
+		GutterBg: AdaptiveColor("#E0E0E0", "#111111"), // Slightly darker
+		WriteBg:  AdaptiveColor("#F0E8D0", "#2A2410"), // Warm amber tint
+
+		// Markdown & syntax highlighting — all warm tones
+		Markdown: MarkdownThemeColors{
+			Text:    AdaptiveColor("#1A1A1A", "#E0E0E0"), // Console text
+			Muted:   AdaptiveColor("#707070", "#808080"), // Dimmed readout
+			Heading: AdaptiveColor("#CC1100", "#FF4444"), // Scanner red accent
+			Emph:    AdaptiveColor("#CC8800", "#FFB800"), // Amber emphasis
+			Strong:  AdaptiveColor("#1A1A1A", "#E0E0E0"), // Bright text
+			Link:    AdaptiveColor("#CC4400", "#FF7744"), // Warm orange link
+			Code:    AdaptiveColor("#333333", "#CCCCCC"), // Inline code
+			Error:   AdaptiveColor("#CC0000", "#FF3333"), // Alert red
+			Keyword: AdaptiveColor("#CC3300", "#FF6644"), // Orange-red keyword
+			String:  AdaptiveColor("#BB7700", "#DDAA33"), // Amber string
+			Number:  AdaptiveColor("#CC8800", "#FFB800"), // Amber number
+			Comment: AdaptiveColor("#909090", "#606060"), // Dark gray comment
+		},
 	}
 }
 
@@ -255,11 +292,6 @@ func ApplyGradient(text string, colorA, colorB color.Color) string {
 	return result.String()
 }
 
-// CreateGradientText creates styled text with a gradient effect between two colors.
-func CreateGradientText(text string, startColor, endColor color.Color) string {
-	return ApplyGradient(text, startColor, endColor)
-}
-
 // Compact styling utilities
 
 // StyleCompactSymbol creates a lipgloss style for message type indicators in

internal/ui/factory.go

@@ -51,8 +51,8 @@ func CreateUsageTracker(modelString, providerAPIKey string) *UsageTracker {
 	}
 
 	registry := models.GetGlobalRegistry()
-	modelInfo, err := registry.ValidateModel(provider, model)
-	if err != nil {
+	modelInfo := registry.LookupModel(provider, model)
+	if modelInfo == nil {
 		return nil
 	}
 
@@ -94,7 +94,7 @@ func SetupCLI(opts *CLISetupOptions) (*CLI, error) {
 		// Skip usage tracking for ollama as it's not in models.dev
 		if provider != "ollama" {
 			registry := models.GetGlobalRegistry()
-			if modelInfo, err := registry.ValidateModel(provider, model); err == nil {
+			if modelInfo := registry.LookupModel(provider, model); modelInfo != nil {
 				// Check if OAuth credentials are being used for Anthropic models
 				isOAuth := false
 				if provider == "anthropic" {

internal/ui/file_suggestions.go

@@ -6,7 +6,6 @@ import (
 	"path/filepath"
 	"sort"
 	"strings"
-	"unicode/utf8"
 )
 
 // FileSuggestion represents a single file or directory suggestion for the @
@@ -345,44 +344,16 @@ func scoreFilePath(query, path string) int {
 	}
 
 	// Fuzzy character match on basename.
-	if score := fuzzyCharMatch(query, baseNameLower); score > 0 {
+	if score := fuzzyCharacterMatch(query, baseNameLower); score > 0 {
 		return score
 	}
 
 	// Fuzzy character match on full path.
-	if score := fuzzyCharMatch(query, pathLower); score > 0 {
+	if score := fuzzyCharacterMatch(query, pathLower); score > 0 {
 		return score - 50
 	}
 
 	return 0
 }
 
-// fuzzyCharMatch performs character-by-character fuzzy matching. Returns a
-// positive score if all query characters appear in order in the target.
-func fuzzyCharMatch(query, target string) int {
-	if utf8.RuneCountInString(query) > utf8.RuneCountInString(target) {
-		return 0
-	}
 
-	qRunes := []rune(query)
-	tRunes := []rune(target)
-	qi := 0
-	score := 100
-	consecutive := 0
-
-	for ti := 0; ti < len(tRunes) && qi < len(qRunes); ti++ {
-		if tRunes[ti] == qRunes[qi] {
-			qi++
-			consecutive++
-			score += consecutive * 5
-		} else {
-			consecutive = 0
-			score -= 2
-		}
-	}
-
-	if qi < len(qRunes) {
-		return 0
-	}
-	return score
-}

internal/ui/fuzzy.go

@@ -113,19 +113,23 @@ func fuzzyScore(query string, cmd *SlashCommand) int {
 	return 0
 }
 
-// fuzzyCharacterMatch performs character-by-character fuzzy matching
+// fuzzyCharacterMatch performs character-by-character fuzzy matching using
+// rune-safe iteration so multi-byte Unicode characters are handled correctly.
+// Returns a positive score if all query runes appear in order within target.
 func fuzzyCharacterMatch(query, target string) int {
-	if len(query) > len(target) {
+	qRunes := []rune(query)
+	tRunes := []rune(target)
+	if len(qRunes) > len(tRunes) {
 		return 0
 	}
 
-	queryIdx := 0
+	qi := 0
 	score := 100
 	consecutiveMatches := 0
 
-	for i := 0; i < len(target) && queryIdx < len(query); i++ {
-		if target[i] == query[queryIdx] {
-			queryIdx++
+	for ti := 0; ti < len(tRunes) && qi < len(qRunes); ti++ {
+		if tRunes[ti] == qRunes[qi] {
+			qi++
 			consecutiveMatches++
 			score += consecutiveMatches * 10
 		} else {
@@ -135,7 +139,7 @@ func fuzzyCharacterMatch(query, target string) int {
 	}
 
 	// Must match all characters in query
-	if queryIdx < len(query) {
+	if qi < len(qRunes) {
 		return 0
 	}
 

internal/ui/input.go

@@ -65,11 +65,33 @@ type InputComponent struct {
 	// hideHint suppresses the "enter submit · ctrl+j..." hint text.
 	hideHint bool
 
+	// agentBusy indicates the agent is currently working. When true, the
+	// hint text shows steering shortcut (Ctrl+S) instead of submit.
+	agentBusy bool
+
 	// pendingImages holds clipboard images attached to the next submission.
 	// Images are added via Ctrl+V and cleared on submit or Ctrl+U.
 	pendingImages []ImageAttachment
+
+	// history stores previously submitted prompts (most recent last).
+	// Limited to maxHistory entries; duplicates of the previous entry are
+	// skipped. Empty strings are never stored.
+	history []string
+	// historyIndex is the current position when browsing history.
+	// When not browsing, historyIndex == len(history).
+	historyIndex int
+	// savedInput holds the user's in-progress text before they started
+	// browsing history, so it can be restored when they press down past
+	// the end of history.
+	savedInput string
+	// browsingHistory is true when the user is navigating history with
+	// up/down arrows. Set to false when they type a character or submit.
+	browsingHistory bool
 }
 
+// maxHistory is the maximum number of prompt entries kept in history.
+const maxHistory = 100
+
 // clipboardImageMsg is the result of an async clipboard image read.
 type clipboardImageMsg struct {
 	image *ImageAttachment
@@ -96,11 +118,12 @@ func NewInputComponent(width int, title string, appCtrl AppController) *InputCom
 		key.WithHelp("ctrl+j", "insert newline"),
 	)
 
-	// Style the textarea to match huh theme
+	// Style the textarea using theme colors.
+	theme := GetTheme()
 	styles := ta.Styles()
 	styles.Focused.Base = lipgloss.NewStyle()
-	styles.Focused.Placeholder = lipgloss.NewStyle().Foreground(lipgloss.Color("240"))
-	styles.Focused.Text = lipgloss.NewStyle().Foreground(lipgloss.Color("252"))
+	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)
@@ -137,6 +160,7 @@ func (s *InputComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	if s.submitNext {
 		s.submitNext = false
 		value := s.textarea.Value()
+		s.pushHistory(value)
 		s.textarea.SetValue("")
 		s.textarea.CursorEnd()
 		s.showPopup = false
@@ -165,10 +189,47 @@ func (s *InputComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			switch msg.String() {
 			case "ctrl+d", "enter":
 				value := s.textarea.Value()
+				s.pushHistory(value)
 				s.textarea.SetValue("")
 				s.textarea.CursorEnd()
 				s.lastValue = ""
 				return s, s.handleSubmit(value)
+			case "up":
+				// Navigate prompt history backward (older entries).
+				if len(s.history) > 0 {
+					if !s.browsingHistory {
+						// Start browsing — save current input.
+						s.savedInput = s.textarea.Value()
+						s.browsingHistory = true
+						s.historyIndex = len(s.history)
+					}
+					if s.historyIndex > 0 {
+						s.historyIndex--
+						s.textarea.SetValue(s.history[s.historyIndex])
+						s.textarea.CursorEnd()
+						s.lastValue = s.textarea.Value()
+					}
+					return s, nil
+				}
+			case "down":
+				// Navigate prompt history forward (newer entries).
+				if s.browsingHistory {
+					if s.historyIndex < len(s.history)-1 {
+						s.historyIndex++
+						s.textarea.SetValue(s.history[s.historyIndex])
+						s.textarea.CursorEnd()
+						s.lastValue = s.textarea.Value()
+					} else {
+						// Past the end — restore saved input.
+						s.historyIndex = len(s.history)
+						s.browsingHistory = false
+						s.textarea.SetValue(s.savedInput)
+						s.textarea.CursorEnd()
+						s.lastValue = s.textarea.Value()
+						s.savedInput = ""
+					}
+					return s, nil
+				}
 			case "ctrl+v":
 				// Try to read an image from the clipboard asynchronously.
 				return s, readClipboardImageCmd()
@@ -249,6 +310,11 @@ func (s *InputComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		value := s.textarea.Value()
 		if value != s.lastValue {
 			s.lastValue = value
+			// User typed something — exit history browsing mode.
+			if s.browsingHistory {
+				s.browsingHistory = false
+				s.savedInput = ""
+			}
 			lines := strings.Split(value, "\n")
 			line := lines[len(lines)-1] // current line (last line for multi-line)
 
@@ -371,14 +437,44 @@ func (s *InputComponent) handleSubmit(value string) tea.Cmd {
 	}
 }
 
+// pushHistory adds a prompt to the history ring buffer. Empty strings and
+// consecutive duplicates of the last entry are skipped. When the buffer
+// exceeds maxHistory, the oldest entry is dropped.
+func (s *InputComponent) pushHistory(value string) {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return
+	}
+	// Skip consecutive duplicates.
+	if len(s.history) > 0 && s.history[len(s.history)-1] == trimmed {
+		s.resetHistoryBrowsing()
+		return
+	}
+	s.history = append(s.history, trimmed)
+	if len(s.history) > maxHistory {
+		s.history = s.history[len(s.history)-maxHistory:]
+	}
+	s.resetHistoryBrowsing()
+}
+
+// resetHistoryBrowsing resets the history browsing state so the index
+// points past the end (ready for new input).
+func (s *InputComponent) resetHistoryBrowsing() {
+	s.historyIndex = len(s.history)
+	s.browsingHistory = false
+	s.savedInput = ""
+}
+
 // View implements tea.Model. Renders the title, textarea, autocomplete popup
 // (if visible), and help text.
 func (s *InputComponent) View() tea.View {
 	containerStyle := lipgloss.NewStyle()
 
+	theme := GetTheme()
+
 	// PaddingLeft(3) aligns with message content: border(1) + paddingLeft(2).
 	titleStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("252")).
+		Foreground(theme.Text).
 		MarginBottom(1).
 		PaddingLeft(3)
 
@@ -388,7 +484,7 @@ func (s *InputComponent) View() tea.View {
 		BorderRight(false).
 		BorderTop(false).
 		BorderBottom(false).
-		BorderForeground(lipgloss.Color("39")).
+		BorderForeground(theme.Primary).
 		PaddingLeft(2).    // match message block paddingLeft
 		Width(s.width - 1) // full width minus left border
 
@@ -405,7 +501,7 @@ func (s *InputComponent) View() tea.View {
 	// Show image attachment indicator when images are pending.
 	if len(s.pendingImages) > 0 {
 		imgStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("39")).
+			Foreground(theme.Secondary).
 			PaddingLeft(3)
 
 		label := fmt.Sprintf("[%d image(s) attached] ctrl+u to clear", len(s.pendingImages))
@@ -415,11 +511,31 @@ func (s *InputComponent) View() tea.View {
 
 	if !s.hideHint {
 		helpStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("240")).
+			Foreground(theme.VeryMuted).
 			MarginTop(1).
 			PaddingLeft(3)
 
-		hint := "enter submit • ctrl+j / shift+enter new line • ctrl+v paste image"
+		// Adapt hint text to available width (accounting for left padding of 3).
+		var hint string
+		availableHintWidth := s.width - 3
+		if s.agentBusy {
+			// When the agent is working, show steering shortcut.
+			if availableHintWidth >= 55 {
+				hint = "enter queue • ctrl+s steer • esc esc cancel"
+			} else if availableHintWidth >= 35 {
+				hint = "↵ queue • ^S steer • esc×2 cancel"
+			} else {
+				hint = "^S steer"
+			}
+		} else if availableHintWidth >= 67 {
+			hint = "enter submit • ctrl+j / shift+enter new line • ctrl+v paste image"
+		} else if availableHintWidth >= 40 {
+			hint = "↵ submit • ctrl+j newline • ctrl+v image"
+		} else if availableHintWidth >= 20 {
+			hint = "↵ submit • ctrl+j"
+		} else {
+			hint = "↵ submit"
+		}
 		view.WriteString("\n")
 		view.WriteString(helpStyle.Render(hint))
 	}
@@ -429,13 +545,18 @@ func (s *InputComponent) View() tea.View {
 
 // renderPopup renders the autocomplete popup for slash command suggestions.
 func (s *InputComponent) renderPopup() string {
+	theme := GetTheme()
+	popupWidth := max(s.width-4, 20)
 	popupStyle := lipgloss.NewStyle().
 		Border(lipgloss.RoundedBorder()).
-		BorderForeground(lipgloss.Color("236")).
+		BorderForeground(theme.MutedBorder).
 		Padding(1, 2).
-		Width(s.width - 4).
+		Width(popupWidth).
 		MarginLeft(0)
 
+	// Inner content width: popup minus border (2) and horizontal padding (4).
+	innerWidth := max(popupWidth-6, 10)
+
 	var items []string
 
 	visibleItems := min(len(s.filtered), s.popupHeight)
@@ -451,56 +572,89 @@ func (s *InputComponent) renderPopup() string {
 
 		var indicator string
 		if i == s.selected {
-			indicator = lipgloss.NewStyle().Foreground(lipgloss.Color("39")).Render("> ")
+			indicator = lipgloss.NewStyle().Foreground(theme.Primary).Render("> ")
 		} else {
 			indicator = "  "
 		}
 
-		nameStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("39")).Bold(true)
-		descStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("243"))
+		nameStyle := lipgloss.NewStyle().Foreground(theme.Secondary).Bold(true)
+		descStyle := lipgloss.NewStyle().Foreground(theme.Muted)
 		if i == s.selected {
-			nameStyle = nameStyle.Foreground(lipgloss.Color("87"))
-			descStyle = descStyle.Foreground(lipgloss.Color("250"))
+			nameStyle = nameStyle.Foreground(theme.Primary)
+			descStyle = descStyle.Foreground(theme.Text)
 		}
 
 		if s.fileMode {
 			// File mode: use full width for the path, show description
 			// (e.g. "directory") inline after a gap.
-			maxNameLen := s.width - 24
+			maxNameLen := max(innerWidth-16, 8)
 			displayName := sc.Name
 			if len(displayName) > maxNameLen && maxNameLen > 3 {
 				displayName = displayName[:maxNameLen-3] + "..."
 			}
 			name := nameStyle.Render(displayName)
-			if sc.Description != "" {
+			if sc.Description != "" && innerWidth > 30 {
 				items = append(items, indicator+name+"  "+descStyle.Render(sc.Description))
 			} else {
 				items = append(items, indicator+name)
 			}
 		} else {
-			nameWidth := 15
-			name := nameStyle.Width(nameWidth - 2).Render(sc.Name)
+			// Line layout: indicator(2) + name(nameWidth-2 visual) + desc.
+			if innerWidth < 20 {
+				// Very narrow: show truncated name only, no fixed column.
+				displayName := sc.Name
+				maxName := max(innerWidth-2, 3)
+				if len(displayName) > maxName {
+					displayName = displayName[:maxName-1] + "…"
+				}
+				items = append(items, indicator+nameStyle.Render(displayName))
+			} else {
+				nameWidth := 15
+				if innerWidth < 25 {
+					nameWidth = max(innerWidth*2/5+1, 8)
+				}
+				maxNameChars := nameWidth - 2
+				displayName := sc.Name
+				if len(displayName) > maxNameChars {
+					displayName = displayName[:maxNameChars-1] + "…"
+				}
+				name := nameStyle.Width(maxNameChars).Render(displayName)
 
-			desc := sc.Description
-			maxDescLen := s.width - nameWidth - 14
-			if len(desc) > maxDescLen && maxDescLen > 3 {
-				desc = desc[:maxDescLen-3] + "..."
+				// Description gets remaining space.
+				maxDescLen := max(innerWidth-nameWidth, 0)
+				desc := sc.Description
+				if maxDescLen < 4 {
+					items = append(items, indicator+name)
+				} else {
+					if len(desc) > maxDescLen {
+						desc = desc[:maxDescLen-3] + "..."
+					}
+					items = append(items, indicator+name+descStyle.Render(desc))
+				}
 			}
-
-			items = append(items, indicator+name+descStyle.Render(desc))
 		}
 	}
 
 	if startIdx > 0 {
-		items = append([]string{lipgloss.NewStyle().Foreground(lipgloss.Color("238")).Render("  ↑ more above")}, items...)
+		items = append([]string{lipgloss.NewStyle().Foreground(theme.VeryMuted).Render("  ↑ more above")}, items...)
 	}
 	if endIdx < len(s.filtered) {
-		items = append(items, lipgloss.NewStyle().Foreground(lipgloss.Color("238")).Render("  ↓ more below"))
+		items = append(items, lipgloss.NewStyle().Foreground(theme.VeryMuted).Render("  ↓ more below"))
 	}
 
 	content := strings.Join(items, "\n")
-	footer := lipgloss.NewStyle().Foreground(lipgloss.Color("238")).Italic(true).
-		Render("↑↓ navigate • tab complete • ↵ select • esc dismiss")
+
+	// Adapt footer text to available width.
+	var footerText string
+	if innerWidth >= 50 {
+		footerText = "↑↓ navigate • tab complete • ↵ select • esc dismiss"
+	} else if innerWidth >= 30 {
+		footerText = "↑↓ nav • tab • ↵ select • esc"
+	} else {
+		footerText = "↑↓ tab ↵ esc"
+	}
+	footer := lipgloss.NewStyle().Foreground(theme.VeryMuted).Italic(true).
+		Render(footerText)
 
 	return popupStyle.Render(content + "\n\n" + footer)
 }

internal/ui/messages.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"charm.land/lipgloss/v2"
+	"github.com/indaco/herald"
 )
 
 // ansiEscapeRe matches ANSI escape sequences used for terminal styling.
@@ -22,9 +23,9 @@ const (
 	UserMessage MessageType = iota
 	AssistantMessage
 	ToolMessage
-	ToolCallMessage // New type for showing tool calls in progress
-	SystemMessage   // New type for KIT system messages (help, tools, etc.)
-	ErrorMessage    // New type for error messages
+	ToolCallMessage
+	SystemMessage
+	ErrorMessage
 )
 
 // UIMessage encapsulates a fully rendered message ready for display in the UI,
@@ -40,29 +41,14 @@ type UIMessage struct {
 	Streaming bool
 }
 
-// Helper functions to get theme colors
+// getTheme returns the current theme (helper for compact_renderer.go)
 func getTheme() Theme {
 	return GetTheme()
 }
 
-// toolDisplayNames maps raw tool names to human-friendly display names.
-var toolDisplayNames = map[string]string{
-	"bash":          "Bash",
-	"read":          "Read",
-	"write":         "Write",
-	"edit":          "Edit",
-	"grep":          "Grep",
-	"find":          "Find",
-	"ls":            "Ls",
-	"run_shell_cmd": "Bash",
-}
-
-// toolDisplayName returns a human-friendly display name for a tool.
-// Falls back to capitalizing the first letter of the raw name.
+// toolDisplayName returns a human-friendly display name for a tool,
+// title-casing the first letter of the raw name.
 func toolDisplayName(rawName string) string {
-	if display, ok := toolDisplayNames[rawName]; ok {
-		return display
-	}
 	if rawName != "" {
 		return strings.ToUpper(rawName[:1]) + rawName[1:]
 	}
@@ -70,8 +56,6 @@ func toolDisplayName(rawName string) string {
 }
 
 // formatToolParams formats tool input parameters for inline header display.
-// Extracts the primary parameter (command/filePath) first, then shows
-// remaining params as (key=val, ...). Truncates to maxWidth.
 func formatToolParams(toolArgs string, maxWidth int) string {
 	args := strings.TrimSpace(toolArgs)
 	if args == "" || args == "{}" {
@@ -80,7 +64,6 @@ func formatToolParams(toolArgs string, maxWidth int) string {
 
 	var params map[string]any
 	if err := json.Unmarshal([]byte(args), &params); err != nil {
-		// Fallback: strip braces and return raw content
 		args = strings.TrimPrefix(args, "{")
 		args = strings.TrimSuffix(args, "}")
 		args = strings.TrimSpace(args)
@@ -94,7 +77,6 @@ func formatToolParams(toolArgs string, maxWidth int) string {
 		return ""
 	}
 
-	// Identify primary parameter by checking known keys in priority order
 	primaryKeys := []string{"command", "filePath", "path", "pattern", "query", "url"}
 	var primaryKey string
 	var primaryVal string
@@ -111,14 +93,24 @@ func formatToolParams(toolArgs string, maxWidth int) string {
 		result.WriteString(primaryVal)
 	}
 
-	// Collect remaining parameters (skip large values like file content)
+	bodyKeys := map[string]bool{
+		"content":  true,
+		"old_text": true,
+		"new_text": true,
+		"oldText":  true,
+		"newText":  true,
+		"edits":    true,
+		"todos":    true,
+	}
 	var remaining []string
 	for key, val := range params {
 		if key == primaryKey {
 			continue
 		}
+		if bodyKeys[key] {
+			continue
+		}
 		valStr := fmt.Sprintf("%v", val)
-		// Skip very large values (e.g., oldString, newString, content, todos)
 		if len(valStr) > 100 {
 			continue
 		}
@@ -143,65 +135,35 @@ func formatToolParams(toolArgs string, maxWidth int) string {
 }
 
 // MessageRenderer handles the formatting and rendering of different message types
-// with consistent styling, markdown support, and appropriate visual hierarchies
-// for the standard (non-compact) display mode.
 type MessageRenderer 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.
+	width           int
+	debug           bool
+	ty              *herald.Typography
 	getToolRenderer func(toolName string) *ToolRendererData
 }
 
-// NewMessageRenderer creates and initializes a new MessageRenderer with the specified
-// terminal width and debug mode setting. The width parameter determines line wrapping
-// and layout calculations.
-func NewMessageRenderer(width int, debug bool) *MessageRenderer {
+// newMessageRenderer creates and initializes a new MessageRenderer
+func newMessageRenderer(width int, debug bool) *MessageRenderer {
 	return &MessageRenderer{
 		width: width,
 		debug: debug,
+		ty:    createTypography(GetTheme()),
 	}
 }
 
-// SetWidth updates the terminal width for the renderer, affecting how content
-// is wrapped and formatted in subsequent render operations.
+// SetWidth updates the terminal width for the renderer
 func (r *MessageRenderer) SetWidth(width int) {
 	r.width = width
 }
 
-// RenderUserMessage renders a user's input message with distinctive right-aligned
-// formatting, including the system username, timestamp, and markdown-rendered content.
-// The message is displayed with a colored right border for visual distinction.
+// RenderUserMessage renders a user's input message using herald Tip alert
 func (r *MessageRenderer) RenderUserMessage(content string, timestamp time.Time) UIMessage {
-	theme := getTheme()
-
-	// 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 messageContent string
-	if strings.Contains(content, "`") {
-		// Glamour treats single \n as a soft break, so convert to paragraph
-		// breaks and collapse the resulting blank lines after rendering.
-		mdContent := strings.ReplaceAll(content, "\n", "\n\n")
-		messageContent = r.renderMarkdown(mdContent, r.width-8)
-		messageContent = removeBlankLines(messageContent)
-	} else {
-		messageContent = content
+	if strings.TrimSpace(content) == "" {
+		content = "(empty message)"
 	}
 
-	fullContent := strings.TrimSuffix(messageContent, "\n")
-
-	// Left border with Blue color for user messages.
-	rendered := renderContentBlock(
-		fullContent,
-		r.width,
-		WithAlign(lipgloss.Left),
-		WithBorderColor(theme.Info),
-		WithMarginBottom(1),
-	)
+	rendered := r.ty.Tip(content)
+	rendered = lipgloss.NewStyle().MarginBottom(1).Render(rendered)
 
 	return UIMessage{
 		Type:      UserMessage,
@@ -211,33 +173,20 @@ func (r *MessageRenderer) RenderUserMessage(content string, timestamp time.Time)
 	}
 }
 
-// RenderAssistantMessage renders an AI assistant's response with left-aligned formatting,
-// including the model name, timestamp, and markdown-rendered content. Empty responses
-// are displayed with a special "Finished without output" message. The message features
-// a colored left border for visual distinction.
+// RenderAssistantMessage renders an AI assistant's response
 func (r *MessageRenderer) RenderAssistantMessage(content string, timestamp time.Time, modelName string) UIMessage {
-	theme := getTheme()
-
-	var messageContent string
 	if strings.TrimSpace(content) == "" {
-		messageContent = lipgloss.NewStyle().
-			Italic(true).
-			Foreground(theme.Muted).
-			Align(lipgloss.Center).
-			Render("Finished without output")
-	} else {
-		messageContent = r.renderMarkdown(content, r.width-8)
+		return UIMessage{
+			Type:      AssistantMessage,
+			Content:   "",
+			Height:    0,
+			Timestamp: timestamp,
+		}
 	}
 
-	fullContent := strings.TrimSuffix(messageContent, "\n")
-
-	// Left border with Primary (Mauve) color for assistant messages.
-	rendered := renderContentBlock(
-		fullContent,
-		r.width,
-		WithBorderColor(theme.Primary),
-		WithMarginBottom(1),
-	)
+	// Use markdown rendering with Chroma syntax highlighting
+	rendered := toMarkdown(content, r.width-4)
+	rendered = lipgloss.NewStyle().MarginBottom(1).Render(rendered)
 
 	return UIMessage{
 		Type:      AssistantMessage,
@@ -247,30 +196,14 @@ func (r *MessageRenderer) RenderAssistantMessage(content string, timestamp time.
 	}
 }
 
-// RenderSystemMessage renders KIT system messages such as help text, command outputs,
-// and informational notifications. These messages are displayed with a distinctive system
-// color border and "KIT System" label to differentiate them from user and AI content.
+// RenderSystemMessage renders KIT system messages using herald Note alert
 func (r *MessageRenderer) RenderSystemMessage(content string, timestamp time.Time) UIMessage {
-	theme := getTheme()
-
-	var messageContent string
 	if strings.TrimSpace(content) == "" {
-		messageContent = "No content available"
-	} else if strings.Contains(content, "`") {
-		messageContent = r.renderMarkdown(content, r.width-8)
-	} else {
-		messageContent = content
+		content = "No content available"
 	}
 
-	fullContent := "◇ " + strings.TrimSuffix(messageContent, "\n")
-
-	rendered := renderContentBlock(
-		fullContent,
-		r.width,
-		WithNoBorder(),
-		WithForeground(theme.Muted),
-		WithMarginBottom(1),
-	)
+	rendered := r.ty.Note(content)
+	rendered = lipgloss.NewStyle().MarginBottom(1).Render(rendered)
 
 	return UIMessage{
 		Type:      SystemMessage,
@@ -280,27 +213,9 @@ func (r *MessageRenderer) RenderSystemMessage(content string, timestamp time.Tim
 	}
 }
 
-// RenderDebugMessage renders diagnostic and debugging information with special formatting
-// including a debug icon, colored border, and structured layout. Debug messages are only
-// displayed when debug mode is enabled and help developers troubleshoot issues.
+// RenderDebugMessage renders diagnostic and debugging information
 func (r *MessageRenderer) RenderDebugMessage(message string, timestamp time.Time) UIMessage {
-	baseStyle := lipgloss.NewStyle()
-
-	theme := getTheme()
-	style := baseStyle.
-		Width(r.width - 3).
-		BorderLeft(true).
-		Foreground(theme.Muted).
-		BorderForeground(theme.Tool).
-		BorderStyle(lipgloss.ThickBorder()).
-		PaddingLeft(1).
-		MarginLeft(2).
-		MarginBottom(1)
-
-	header := baseStyle.
-		Foreground(theme.Tool).
-		Bold(true).
-		Render("🔍 Debug Output")
+	header := r.ty.H6("🔍 Debug Output")
 
 	lines := strings.Split(message, "\n")
 	var formattedLines []string
@@ -310,87 +225,52 @@ func (r *MessageRenderer) RenderDebugMessage(message string, timestamp time.Time
 		}
 	}
 
-	content := baseStyle.
-		Foreground(theme.Muted).
-		Render(strings.Join(formattedLines, "\n"))
-
-	fullContent := lipgloss.JoinVertical(lipgloss.Left,
+	content := r.ty.Compose(
 		header,
-		content,
+		r.ty.P(strings.Join(formattedLines, "\n")),
 	)
+	content = lipgloss.NewStyle().MarginBottom(1).Render(content)
 
 	return UIMessage{
-		Content: style.Render(fullContent),
-		Height:  lipgloss.Height(style.Render(fullContent)),
+		Content: content,
+		Height:  lipgloss.Height(content),
 	}
 }
 
-// RenderDebugConfigMessage renders configuration settings in a formatted debug display
-// with key-value pairs shown in a structured layout. Used to display runtime configuration
-// for debugging purposes with a distinctive icon and border styling.
+// RenderDebugConfigMessage renders configuration settings
 func (r *MessageRenderer) RenderDebugConfigMessage(config map[string]any, timestamp time.Time) UIMessage {
-	baseStyle := lipgloss.NewStyle()
-
-	theme := getTheme()
-	style := baseStyle.
-		Width(r.width - 1).
-		BorderLeft(true).
-		Foreground(theme.Muted).
-		BorderForeground(theme.Tool).
-		BorderStyle(lipgloss.ThickBorder()).
-		PaddingLeft(1)
-
-	header := baseStyle.
-		Foreground(theme.Tool).
-		Bold(true).
-		Render("🔧 Debug Configuration")
+	header := r.ty.H6("🔧 Debug Configuration")
 
 	var configLines []string
 	for key, value := range config {
 		if value != nil {
-			configLines = append(configLines, fmt.Sprintf("  %s: %v", key, value))
+			configLines = append(configLines, fmt.Sprintf("%s: %v", key, value))
 		}
 	}
 
-	configContent := baseStyle.
-		Foreground(theme.Muted).
-		Render(strings.Join(configLines, "\n"))
-
-	parts := []string{header}
+	var content string
 	if len(configLines) > 0 {
-		parts = append(parts, configContent)
+		content = r.ty.Compose(
+			header,
+			r.ty.P(strings.Join(configLines, "\n")),
+		)
+	} else {
+		content = header
 	}
-
-	rendered := style.Render(
-		lipgloss.JoinVertical(lipgloss.Left, parts...),
-	)
+	content = lipgloss.NewStyle().MarginBottom(1).Render(content)
 
 	return UIMessage{
 		Type:      SystemMessage,
-		Content:   rendered,
-		Height:    lipgloss.Height(rendered),
+		Content:   content,
+		Height:    lipgloss.Height(content),
 		Timestamp: timestamp,
 	}
 }
 
-// RenderErrorMessage renders error notifications with distinctive red coloring and
-// bold text to ensure visibility. Error messages include timestamp information and
-// are displayed with an error-colored border for immediate recognition.
+// RenderErrorMessage renders error notifications
 func (r *MessageRenderer) RenderErrorMessage(errorMsg string, timestamp time.Time) UIMessage {
-	theme := getTheme()
-
-	errorContent := lipgloss.NewStyle().
-		Foreground(theme.Error).
-		Bold(true).
-		Render(errorMsg)
-
-	rendered := renderContentBlock(
-		errorContent,
-		r.width,
-		WithAlign(lipgloss.Left),
-		WithBorderColor(theme.Error),
-		WithMarginBottom(1),
-	)
+	rendered := r.ty.Caution(errorMsg)
+	rendered = lipgloss.NewStyle().MarginBottom(1).Render(rendered)
 
 	return UIMessage{
 		Type:      ErrorMessage,
@@ -400,93 +280,18 @@ func (r *MessageRenderer) RenderErrorMessage(errorMsg string, timestamp time.Tim
 	}
 }
 
-// RenderToolCallMessage renders a notification that a tool is being executed, showing
-// the tool name, formatted arguments (if any), and execution timestamp. The message
-// uses tool-specific coloring to distinguish it from regular conversation messages.
-func (r *MessageRenderer) RenderToolCallMessage(toolName, toolArgs string, timestamp time.Time) UIMessage {
-	// Format timestamp
-	timeStr := timestamp.Local().Format("15:04")
-
-	// Format arguments with better presentation
-	theme := getTheme()
-	var argsContent string
-	if toolArgs != "" && toolArgs != "{}" {
-		argsContent = lipgloss.NewStyle().
-			Foreground(theme.Muted).
-			Italic(true).
-			Render(fmt.Sprintf("Arguments: %s", r.formatToolArgs(toolArgs)))
-	}
-
-	// Create info line
-	info := fmt.Sprintf(" Executing %s (%s)", toolName, timeStr)
-
-	// Combine parts
-	var fullContent string
-	if argsContent != "" {
-		fullContent = argsContent + "\n" +
-			lipgloss.NewStyle().Foreground(theme.VeryMuted).Render(info)
-	} else {
-		fullContent = lipgloss.NewStyle().Foreground(theme.VeryMuted).Render(info)
-	}
-
-	// Use the new block renderer
-	rendered := renderContentBlock(
-		fullContent,
-		r.width,
-		WithAlign(lipgloss.Left),
-		WithBorderColor(theme.Tool),
-		WithMarginBottom(1),
-	)
-
-	return UIMessage{
-		Type:      ToolCallMessage,
-		Content:   rendered,
-		Height:    lipgloss.Height(rendered),
-		Timestamp: timestamp,
-	}
-}
-
-// RenderToolMessage renders a unified tool block combining the tool invocation
-// header (icon + display name + params) with the execution result body. The
-// border color indicates status: green for success, red for error. This replaces
-// the previous two-block approach (separate call + result blocks).
+// RenderToolMessage renders a unified tool block
 func (r *MessageRenderer) 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)
 	}
 
-	// --- Header: [icon] [name] [params] ---
-	var icon string
-	borderColor := theme.Success
-	iconColor := theme.Success
-	if isError {
-		icon = "×"
-		borderColor = theme.Error
-		iconColor = theme.Error
-	} else {
-		icon = "✓"
-	}
-
-	// Extension can override border color (applies to both success and error).
-	if extRd != nil && extRd.BorderColor != "" {
-		borderColor = lipgloss.Color(extRd.BorderColor)
-	}
-
-	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 with width budget for the header line.
-	// Check extension renderer for custom header params first.
 	paramBudget := max(r.width-10-len(displayName), 20)
 	var params string
 	if extRd != nil && extRd.RenderHeader != nil {
@@ -496,69 +301,70 @@ func (r *MessageRenderer) RenderToolMessage(toolName, toolArgs, toolResult strin
 		params = formatToolParams(toolArgs, paramBudget)
 	}
 
-	header := iconStr + " " + nameStr
-	if params != "" {
-		header += " " + lipgloss.NewStyle().Foreground(theme.Muted).Render(params)
+	var icon string
+	iconColor := GetTheme().Success
+	if isError {
+		icon = "×"
+		iconColor = GetTheme().Error
+	} else {
+		icon = "✓"
 	}
 
-	// --- Body: check extension renderer first, then builtin, then default ---
+	// Style the tool name with color
+	theme := GetTheme()
+	nameColor := theme.Info
+	if isError {
+		nameColor = theme.Error
+	}
+	styledName := lipgloss.NewStyle().Foreground(nameColor).Bold(true).Render(displayName)
+	styledIcon := lipgloss.NewStyle().Foreground(iconColor).Render(icon)
+
+	// Build the content: icon + name + params on first line, then body
+	headerLine := styledIcon + " " + styledName
+	if params != "" {
+		headerLine += " " + lipgloss.NewStyle().Foreground(theme.Muted).Render(params)
+	}
+
+	// Get body content
 	var body string
 	if extRd != nil && extRd.RenderBody != nil {
 		body = extRd.RenderBody(toolResult, isError, r.width-8)
-		// Apply markdown rendering if requested and body is non-empty.
 		if body != "" && extRd.BodyMarkdown {
 			body = strings.TrimSuffix(toMarkdown(body, r.width-8), "\n")
 		}
 	}
 	if body == "" {
 		if isError {
-			body = lipgloss.NewStyle().
-				Foreground(theme.Error).
-				Render(toolResult)
+			body = r.formatToolResult(toolName, toolResult)
 		} else {
 			body = renderToolBody(toolName, toolArgs, toolResult, r.width-8)
 			if body == "" {
-				body = r.formatToolResult(toolName, toolResult, r.width-8)
+				body = r.formatToolResult(toolName, toolResult)
 			}
 		}
 	}
 
 	if strings.TrimSpace(body) == "" {
-		body = lipgloss.NewStyle().
-			Italic(true).
-			Foreground(theme.Muted).
-			Render("(no output)")
+		body = r.ty.Italic("(no output)")
 	}
 
-	// Combine header + body into a single block.
-	fullContent := header + "\n\n" + strings.TrimSuffix(body, "\n")
-
-	// Build rendering options; extension can override background.
-	blockOpts := []renderingOption{
-		WithAlign(lipgloss.Left),
-		WithBorderColor(borderColor),
-		WithMarginBottom(1),
-	}
-	if extRd != nil && extRd.Background != "" {
-		blockOpts = append(blockOpts, WithBackground(lipgloss.Color(extRd.Background)))
-	}
-
-	rendered := renderContentBlock(
-		fullContent,
-		r.width,
-		blockOpts...,
+	// Compose: icon + name + params, then body
+	fullContent := r.ty.Compose(
+		headerLine,
+		"",
+		body,
 	)
+	fullContent = lipgloss.NewStyle().MarginBottom(1).Render(fullContent)
 
 	return UIMessage{
 		Type:    ToolMessage,
-		Content: rendered,
-		Height:  lipgloss.Height(rendered),
+		Content: fullContent,
+		Height:  lipgloss.Height(fullContent),
 	}
 }
 
 // formatToolArgs formats tool arguments for display
 func (r *MessageRenderer) formatToolArgs(args string) string {
-	// Remove outer braces and clean up JSON formatting
 	args = strings.TrimSpace(args)
 	if strings.HasPrefix(args, "{") && strings.HasSuffix(args, "}") {
 		args = strings.TrimPrefix(args, "{")
@@ -566,12 +372,10 @@ func (r *MessageRenderer) formatToolArgs(args string) string {
 		args = strings.TrimSpace(args)
 	}
 
-	// If it's empty after cleanup, return a placeholder
 	if args == "" {
 		return "(no arguments)"
 	}
 
-	// Truncate if too long, but skip truncation in debug mode
 	if !r.debug {
 		maxLen := 100
 		if len(args) > maxLen {
@@ -583,10 +387,7 @@ func (r *MessageRenderer) formatToolArgs(args string) string {
 }
 
 // formatToolResult formats tool results based on tool type
-func (r *MessageRenderer) formatToolResult(toolName, result string, width int) string {
-	baseStyle := lipgloss.NewStyle()
-
-	// Truncate very long results only if not in debug mode
+func (r *MessageRenderer) formatToolResult(toolName, result string) string {
 	if !r.debug {
 		maxLines := 10
 		lines := strings.Split(result, "\n")
@@ -595,51 +396,47 @@ func (r *MessageRenderer) formatToolResult(toolName, result string, width int) s
 		}
 	}
 
-	// Format bash/command output with better formatting
-	if strings.Contains(toolName, "bash") || strings.Contains(toolName, "command") || strings.Contains(toolName, "shell") || toolName == "run_shell_cmd" {
-		theme := getTheme()
-
-		// Split result into sections if it contains both stdout and stderr
+	if strings.Contains(toolName, "bash") || strings.Contains(toolName, "command") ||
+		strings.Contains(toolName, "shell") {
 		if strings.Contains(result, "<stdout>") || strings.Contains(result, "<stderr>") {
-			return r.formatBashOutput(result, width, theme)
+			return parseBashOutput(result, GetTheme())
 		}
-
-		// For simple output, just render as monospace text with proper line breaks
-		return baseStyle.
-			Width(width).
-			Foreground(theme.Muted).
-			Render(result)
 	}
 
-	// For other tools, render as muted text
-	theme := getTheme()
-	return baseStyle.
-		Width(width).
-		Foreground(theme.Muted).
-		Render(result)
+	return result
 }
 
-// formatBashOutput formats bash command output with proper section handling.
-// Delegates tag parsing to the shared parseBashOutput helper.
-func (r *MessageRenderer) formatBashOutput(result string, width int, theme Theme) string {
-	parsed := parseBashOutput(result, theme)
-	return lipgloss.NewStyle().
-		Width(width).
-		Foreground(theme.Muted).
-		Render(parsed)
-}
-
-// renderMarkdown renders markdown content using glamour
-func (r *MessageRenderer) renderMarkdown(content string, width int) string {
-	rendered := toMarkdown(content, width)
-	return strings.TrimSuffix(rendered, "\n")
+// createTypography creates a typography instance from theme
+func createTypography(theme Theme) *herald.Typography {
+	return herald.New(
+		herald.WithPalette(herald.ColorPalette{
+			Primary:   theme.Primary,
+			Secondary: theme.Secondary,
+			Tertiary:  theme.Info,
+			Accent:    theme.Accent,
+			Highlight: theme.Highlight,
+			Muted:     theme.Muted,
+			Text:      theme.Text,
+			Surface:   theme.Background,
+			Base:      theme.CodeBg,
+		}),
+		herald.WithAlertPalette(herald.AlertPalette{
+			Note:      theme.Info,
+			Tip:       theme.Success,
+			Important: theme.Accent,
+			Warning:   theme.Warning,
+			Caution:   theme.Error,
+		}),
+		herald.WithCodeLineNumbers(true),
+		// Customize alert labels
+		herald.WithAlertLabel(herald.AlertNote, "Info"),
+		herald.WithAlertLabel(herald.AlertTip, "You"),
+		herald.WithAlertLabel(herald.AlertWarning, "Working"),
+		herald.WithAlertLabel(herald.AlertCaution, "Error"),
+	)
 }
 
 // removeBlankLines removes lines that are visually blank from rendered output.
-// Glamour wraps every character (including padding spaces) with ANSI color
-// codes, so we must strip escape sequences before checking whether a line is
-// empty. This collapses paragraph spacing so user messages render without
-// extra vertical gaps.
 func removeBlankLines(s string) string {
 	lines := strings.Split(s, "\n")
 	filtered := lines[:0]

internal/ui/model_selector.go

@@ -208,9 +208,20 @@ func (ms *ModelSelectorComponent) View() tea.View {
 	// Header.
 	b.WriteString(headerStyle.Render("Model Selector"))
 	b.WriteString("\n")
-	b.WriteString(helpStyle.Render("↑/↓: move  enter: select  esc: cancel  type to filter"))
+	// Adapt help text to terminal width.
+	if ms.width >= 56 {
+		b.WriteString(helpStyle.Render("↑/↓: move  enter: select  esc: cancel  type to filter"))
+	} else if ms.width >= 35 {
+		b.WriteString(helpStyle.Render("↑↓ move  ↵ select  esc  type"))
+	} else {
+		b.WriteString(helpStyle.Render("↑↓ ↵ esc"))
+	}
 	b.WriteString("\n")
-	b.WriteString(infoStyle.Render("Only showing models with configured API keys"))
+	if ms.width >= 48 {
+		b.WriteString(infoStyle.Render("Only showing models with configured API keys"))
+	} else {
+		b.WriteString(infoStyle.Render("Models with API keys"))
+	}
 	b.WriteString("\n")
 
 	// Search input.
@@ -281,9 +292,9 @@ func (ms *ModelSelectorComponent) IsActive() bool {
 // --- Internal helpers ---
 
 func (ms *ModelSelectorComponent) visibleHeight() int {
-	// Reserve: header(1) + help(1) + info(1) + search(1) + separator(1) + footer(2) = 7
-	h := max(ms.height-7, 5)
-	return h
+	// Reserve: header(1) + help(1) + info(1) + search(1) + separator(1) + footer(2) = 7.
+	// Minimum 3 entries so the selector is still usable on short terminals.
+	return max(ms.height-7, 3)
 }
 
 func (ms *ModelSelectorComponent) rebuildFiltered() {
@@ -396,8 +407,37 @@ func (ms *ModelSelectorComponent) renderEntry(entry ModelEntry, isCursor bool) s
 
 	// Active model checkmark.
 	var active string
+	activeWidth := 0
 	if entry.Provider+"/"+entry.ModelID == ms.currentModel {
 		active = lipgloss.NewStyle().Foreground(theme.Success).Render(" \u2713")
+		activeWidth = 2 // " ✓"
+	}
+
+	// Truncate model ID and provider tag to fit terminal width.
+	// Layout: cursor(3) + model + " " + provider + active.
+	// Use rune length for display-width accuracy (the "…" suffix is 1 rune / 1 column).
+	const cursorWidth = 3
+	available := max(ms.width-cursorWidth-activeWidth-1, 10) // 1 for space between model and provider
+	provDisplayLen := len([]rune(providerStr))
+	modelDisplayLen := len([]rune(modelStr))
+
+	if modelDisplayLen+1+provDisplayLen > available {
+		// Prioritize model name — truncate it, but keep provider visible.
+		maxModel := max(available-provDisplayLen-1, 6)
+		if maxModel < modelDisplayLen {
+			if maxModel > 3 {
+				runes := []rune(modelStr)
+				modelStr = string(runes[:maxModel-1]) + "…"
+			} else {
+				runes := []rune(modelStr)
+				modelStr = string(runes[:maxModel])
+			}
+		}
+		// If provider itself is too long, drop it.
+		modelDisplayLen = len([]rune(modelStr))
+		if modelDisplayLen+1+provDisplayLen > available {
+			providerStr = ""
+		}
 	}
 
 	// Style the model ID.
@@ -409,5 +449,9 @@ func (ms *ModelSelectorComponent) renderEntry(entry ModelEntry, isCursor bool) s
 	// Style the provider tag.
 	providerStyle := lipgloss.NewStyle().Foreground(theme.Muted)
 
-	return cursor + modelStyle.Render(modelStr) + " " + providerStyle.Render(providerStr) + active
+	result := cursor + modelStyle.Render(modelStr)
+	if providerStr != "" {
+		result += " " + providerStyle.Render(providerStr)
+	}
+	return result + active
 }

internal/ui/model_test.go

@@ -54,6 +54,10 @@ func (s *stubAppController) GetTreeSession() *session.TreeManager {
 	return nil
 }
 
+func (s *stubAppController) SwitchTreeSession(_ *session.TreeManager) {
+	// no-op in tests
+}
+
 func (s *stubAppController) SendEvent(_ tea.Msg) {
 	// no-op in tests
 }
@@ -67,6 +71,11 @@ func (s *stubAppController) RunWithFiles(prompt string, _ []fantasy.FilePart) in
 	return s.queueLen
 }
 
+func (s *stubAppController) Steer(prompt string) int {
+	s.runCalls = append(s.runCalls, prompt)
+	return s.queueLen
+}
+
 // --------------------------------------------------------------------------
 // Stub child components
 // --------------------------------------------------------------------------
@@ -112,15 +121,16 @@ func newTestAppModel(ctrl AppController) (*AppModel, *stubStreamComponent, *stub
 	stream := &stubStreamComponent{}
 	input := &stubInputComponent{}
 	m := &AppModel{
-		state:       stateInput,
-		appCtrl:     ctrl,
-		stream:      stream,
-		input:       input,
-		renderer:    NewMessageRenderer(80, false),
-		compactMode: false,
-		modelName:   "test-model",
-		width:       80,
-		height:      24,
+		state:                 stateInput,
+		appCtrl:               ctrl,
+		stream:                stream,
+		input:                 input,
+		renderer:              newMessageRenderer(80, false),
+		compactMode:           false,
+		modelName:             "test-model",
+		width:                 80,
+		height:                24,
+		streamingBashMaxLines: 50, // Initialize buffer cap like NewAppModel does
 	}
 	return m, stream, input
 }
@@ -602,6 +612,133 @@ func TestToolResult_printsAndStartsSpinner(t *testing.T) {
 	}
 }
 
+// TestToolOutputEvent_accumulatesBashOutput verifies that ToolOutputEvent
+// accumulates stdout and stderr lines into the streaming bash output buffers.
+func TestToolOutputEvent_accumulatesBashOutput(t *testing.T) {
+	ctrl := &stubAppController{}
+	m, _, _ := newTestAppModel(ctrl)
+	m.state = stateWorking
+
+	// Send stdout chunk.
+	m = sendMsg(m, app.ToolOutputEvent{
+		ToolCallID: "call-1",
+		ToolName:   "bash",
+		Chunk:      "line one\n",
+		IsStderr:   false,
+	})
+
+	if len(m.streamingBashOutput) != 1 || m.streamingBashOutput[0] != "line one\n" {
+		t.Fatalf("expected streamingBashOutput=['line one\\n'], got %v", m.streamingBashOutput)
+	}
+	if len(m.streamingBashStderr) != 0 {
+		t.Fatalf("expected empty streamingBashStderr, got %v", m.streamingBashStderr)
+	}
+
+	// Send another stdout chunk.
+	m = sendMsg(m, app.ToolOutputEvent{
+		ToolCallID: "call-1",
+		ToolName:   "bash",
+		Chunk:      "line two\n",
+		IsStderr:   false,
+	})
+
+	if len(m.streamingBashOutput) != 2 {
+		t.Fatalf("expected 2 stdout lines, got %d", len(m.streamingBashOutput))
+	}
+
+	// Send stderr chunk.
+	m = sendMsg(m, app.ToolOutputEvent{
+		ToolCallID: "call-1",
+		ToolName:   "bash",
+		Chunk:      "error: something failed\n",
+		IsStderr:   true,
+	})
+
+	if len(m.streamingBashStderr) != 1 {
+		t.Fatalf("expected 1 stderr line, got %d", len(m.streamingBashStderr))
+	}
+	if m.streamingBashStderr[0] != "error: something failed\n" {
+		t.Fatalf("expected stderr 'error: something failed\\n', got %q", m.streamingBashStderr[0])
+	}
+}
+
+// TestToolResult_clearsStreamingBashOutput verifies that ToolResultEvent clears
+// the streaming bash output buffers since the final result will be printed.
+func TestToolResult_clearsStreamingBashOutput(t *testing.T) {
+	ctrl := &stubAppController{}
+	m, _, _ := newTestAppModel(ctrl)
+	m.state = stateWorking
+
+	// Accumulate some bash output.
+	m.streamingBashOutput = []string{"output line"}
+	m.streamingBashStderr = []string{"error line"}
+
+	_, _ = m.Update(app.ToolResultEvent{
+		ToolName: "bash",
+		ToolArgs: `{"cmd":"ls"}`,
+		Result:   "output line\nerror line\n",
+		IsError:  false,
+	})
+
+	if len(m.streamingBashOutput) != 0 {
+		t.Fatalf("expected streamingBashOutput cleared, got %v", m.streamingBashOutput)
+	}
+	if len(m.streamingBashStderr) != 0 {
+		t.Fatalf("expected streamingBashStderr cleared, got %v", m.streamingBashStderr)
+	}
+}
+
+// TestToolCallStarted_extractsBashCommand verifies that ToolCallStartedEvent
+// extracts the bash command from ToolArgs and stores it for the streaming output header.
+func TestToolCallStarted_extractsBashCommand(t *testing.T) {
+	ctrl := &stubAppController{}
+	m, _, _ := newTestAppModel(ctrl)
+	m.state = stateWorking
+
+	// Send ToolCallStartedEvent with bash command.
+	m = sendMsg(m, app.ToolCallStartedEvent{
+		ToolCallID: "call-1",
+		ToolName:   "bash",
+		ToolArgs:   `{"command":"ls -la /home"}`,
+	})
+
+	if m.streamingBashCommand != "ls -la /home" {
+		t.Fatalf("expected streamingBashCommand='ls -la /home', got %q", m.streamingBashCommand)
+	}
+
+	// ToolResultEvent should clear the command.
+	m = sendMsg(m, app.ToolResultEvent{
+		ToolCallID: "call-1",
+		ToolName:   "bash",
+		ToolArgs:   `{"command":"ls -la /home"}`,
+		Result:     "output",
+		IsError:    false,
+	})
+
+	if m.streamingBashCommand != "" {
+		t.Fatalf("expected streamingBashCommand cleared, got %q", m.streamingBashCommand)
+	}
+}
+
+// TestToolCallStarted_nonBashTool_doesNotSetCommand verifies that non-bash tools
+// do not set the streamingBashCommand field.
+func TestToolCallStarted_nonBashTool_doesNotSetCommand(t *testing.T) {
+	ctrl := &stubAppController{}
+	m, _, _ := newTestAppModel(ctrl)
+	m.state = stateWorking
+
+	// Send ToolCallStartedEvent with a non-bash tool.
+	m = sendMsg(m, app.ToolCallStartedEvent{
+		ToolCallID: "call-1",
+		ToolName:   "read",
+		ToolArgs:   `{"file":"/etc/passwd"}`,
+	})
+
+	if m.streamingBashCommand != "" {
+		t.Fatalf("expected streamingBashCommand to remain empty for non-bash tools, got %q", m.streamingBashCommand)
+	}
+}
+
 // TestStepError_printCmd verifies that StepErrorEvent with a non-nil error
 // produces a non-nil cmd (the tea.Println call for the error message).
 func TestStepError_printCmd(t *testing.T) {