// Bantam agent: tiny, powerful, DIY
// Created by Luxferre in 2026, released into the public domain

package main

import (
  "bufio"
  "bytes"
  "context"
  "crypto/md5"
  "crypto/rand"
  "encoding/hex"
  "encoding/json"
  "errors"
  "fmt"
  "io"
  "net"
  "net/http"
  "net/url"
  "os"
  "os/exec"
  "os/signal"
  "path/filepath"
  "regexp"
  "sort"
  "strconv"
  "strings"
  "sync"
  "time"
  "unicode"
  "unicode/utf8"
)

var (
  COL   bool          // ANSI color enabled
  hist  []string      // line history (mirrors ~/.bantam_history)
  histF string        // history file path
  stdin *bufio.Reader // stdin reader for the REPL
)

type Cfg struct {
  Endpoint        string
  Model           string
  APIKey          string
  Temperature     float64
  Timeout         int
  ShellTimeout    int
  MaxALIterations int
  Stream          bool
  Color           string
  ContextWindow   int
  MaxToolRes      int
  Raw             map[string]string
}

// internalKey reports whether a model.cfg key is an agent-internal parameter
// that must never be forwarded to the chat completions API.
func internalKey(k string) bool {
  switch k {
  case "endpoint", "model", "temperature", "stream", "api_key", "timeout",
    "shell_timeout", "max_al_iterations", "color", "context_window", "max_tool_res",
    "bantam_tools_dir", "bantam_skills_dir":
    return true
  }
  return false
}

func proxyFromEnv(req *http.Request) (*url.URL, error) {
  socks := strings.TrimSpace(os.Getenv("SOCKS_PROXY"))
  if socks == "" {
    socks = strings.TrimSpace(os.Getenv("socks_proxy"))
  }
  if socks != "" {
    if !strings.Contains(socks, "://") {
      socks = "socks5://" + socks
    }
    return url.Parse(socks)
  }
  return http.ProxyFromEnvironment(req)
}

// llmTransport is a shared HTTP transport reused across all LLM calls so that
// connections are pooled instead of recreated per request.
var llmTransport = &http.Transport{
  Proxy:       proxyFromEnv,
  DialContext: (&net.Dialer{Timeout: 300 * time.Second}).DialContext,
}

var defCfg = Cfg{"https://api.kilo.ai/api/openrouter", "openrouter/free", "-", 0.7, 300, 120, 1000, true, "auto", 262144, 65536, map[string]string{"reasoning_effort": "high"}}

const opencodeAgentVersion = "opencode/1.18.31"
const opencodeProviderUA = "ai-sdk/provider-utils/4.0.23 runtime/bun/1.3.14"
const opencodeProjectID = "global"

// opencodeTailAlphabet is the character set used for the 14-character random
// tail of OpenCode IDs.
const opencodeTailAlphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

var (
  ocMu   sync.Mutex
  ocLast int64
  ocSeq  uint64
)

func atoiD(s string, d int) int {
  if v, e := strconv.Atoi(strings.TrimSpace(s)); e == nil {
    return v
  }
  return d
}

func toInt(v any, def int) int {
  switch n := v.(type) {
  case int:
    return n
  case float64:
    return int(n)
  case string:
    return atoiD(n, def)
  }
  return def
}

func fetchModels(cfg *Cfg, timeoutSec int) ([]map[string]any, error) {
  client := &http.Client{
    Transport: &http.Transport{
      Proxy:       proxyFromEnv,
      DialContext: (&net.Dialer{Timeout: time.Duration(timeoutSec) * time.Second}).DialContext,
    },
    Timeout: time.Duration(timeoutSec) * time.Second,
  }
  req, err := http.NewRequest("GET", strings.TrimRight(cfg.Endpoint, "/")+"/models", nil)
  if err != nil {
    return nil, err
  }
  applyLLMHeaders(req, cfg, ocRequestID())
  resp, err := client.Do(req)
  if err != nil {
    return nil, err
  }
  defer resp.Body.Close()
  if resp.StatusCode >= 400 {
    return nil, fmt.Errorf("HTTP %d from /models", resp.StatusCode)
  }
  var res struct {
    Data   []map[string]any `json:"data"`
    Models []map[string]any `json:"models"`
  }
  if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
    return nil, err
  }
  if len(res.Data) > 0 {
    return res.Data, nil
  }
  return res.Models, nil
}

func queryModelsContextWindow(cfg *Cfg) int {
  list, err := fetchModels(cfg, 3)
  if err != nil {
    return 0
  }
  for _, item := range list {
    id, _ := item["id"].(string)
    if id == cfg.Model || strings.EqualFold(id, cfg.Model) {
      for _, key := range []string{"context_window", "context_length", "max_context_length", "max_model_len", "context_size", "max_tokens", "max_input_tokens"} {
        if n := toInt(item[key], 0); n > 0 {
          return n
        }
      }
    }
  }
  return 0
}

var cwCacheMu sync.Mutex
var cwCache = map[string]int{}

func fetchContextWindow(cfg *Cfg) int {
  // Only values discovered from the /models endpoint are cached, keyed by
  // endpoint+model. The context_window-override and 262144 default are derived
  // per call from cfg so they never shadow each other across configs.
  key := cfg.Endpoint + "\x00" + cfg.Model
  cwCacheMu.Lock()
  if cw, ok := cwCache[key]; ok {
    cwCacheMu.Unlock()
    return cw
  }
  cwCacheMu.Unlock()
  if cw := queryModelsContextWindow(cfg); cw > 0 {
    cwCacheMu.Lock()
    cwCache[key] = cw
    cwCacheMu.Unlock()
    return cw
  }
  if v, ok := cfg.Raw["context_window"]; ok {
    return atoiD(v, 262144)
  }
  return 262144
}

// listModels queries the /models path on the configured inference endpoint and
// returns a plain newline-separated list of supported model IDs. The currently
// configured model is marked with a leading "* ". On transport or HTTP errors a
// non-nil error is returned so the caller can surface it.
func listModels(cfg *Cfg) (string, error) {
  t := cfg.Timeout
  if t < 10 {
    t = 10
  }
  list, err := fetchModels(cfg, t)
  if err != nil {
    return "", err
  }
  if len(list) == 0 {
    return "No models returned by the endpoint.", nil
  }
  var b strings.Builder
  for _, item := range list {
    id, _ := item["id"].(string)
    if id == "" {
      continue
    }
    if id == cfg.Model || strings.EqualFold(id, cfg.Model) {
      b.WriteString("* " + id + "\n")
    } else {
      b.WriteString("  " + id + "\n")
    }
  }
  return b.String(), nil
}

func parseCfgFile(path string, cfg *Cfg) {
  if d, err := os.ReadFile(path); err == nil {
    for _, ln := range strings.Split(string(d), "\n") {
      ln = strings.TrimSpace(ln)
      if ln == "" || ln[0] == '#' || !strings.Contains(ln, "=") {
        continue
      }
      k, v, _ := strings.Cut(ln, "=")
      k, v = strings.TrimSpace(k), strings.TrimSpace(v)
      cfg.Raw[k] = v
      switch k {
      case "endpoint":
        cfg.Endpoint = v
      case "model":
        cfg.Model = v
      case "api_key":
        cfg.APIKey = v
      case "temperature":
        if f, e := strconv.ParseFloat(v, 64); e == nil {
          cfg.Temperature = f
        }
      case "timeout":
        cfg.Timeout = atoiD(v, cfg.Timeout)
      case "shell_timeout":
        cfg.ShellTimeout = atoiD(v, cfg.ShellTimeout)
      case "max_al_iterations":
        cfg.MaxALIterations = atoiD(v, cfg.MaxALIterations)
      case "stream":
        cfg.Stream = v == "true" || v == "1" || v == "yes"
      case "color":
        cfg.Color = v
      case "context_window":
        cfg.ContextWindow = atoiD(v, cfg.ContextWindow)
      case "max_tool_res":
        cfg.MaxToolRes = atoiD(v, cfg.MaxToolRes)
      }
    }
  }
}

func applyEnvCfg(cfg *Cfg) {
  set := func(k, env string, dst *string) {
    if v := strings.TrimSpace(os.Getenv(env)); v != "" {
      *dst = v
      cfg.Raw[k] = v
    }
  }
  setNum := func(k, env string, dst *int) {
    if v := strings.TrimSpace(os.Getenv(env)); v != "" {
      *dst = atoiD(v, *dst)
      cfg.Raw[k] = strconv.Itoa(*dst)
    }
  }
  set("endpoint", "BANTAM_ENDPOINT", &cfg.Endpoint)
  set("model", "BANTAM_MODEL", &cfg.Model)
  if v := strings.TrimSpace(os.Getenv("BANTAM_TEMP")); v != "" {
    if f, e := strconv.ParseFloat(v, 64); e == nil {
      cfg.Temperature = f
      cfg.Raw["temperature"] = v
    }
  } else if v := strings.TrimSpace(os.Getenv("BANTAM_TEMPERATURE")); v != "" {
    if f, e := strconv.ParseFloat(v, 64); e == nil {
      cfg.Temperature = f
      cfg.Raw["temperature"] = v
    }
  }
  if v := strings.TrimSpace(os.Getenv("BANTAM_STREAM")); v != "" {
    cfg.Stream = v == "true" || v == "1" || v == "yes"
    cfg.Raw["stream"] = strconv.FormatBool(cfg.Stream)
  }
  set("color", "BANTAM_COLOR", &cfg.Color)
  setNum("timeout", "BANTAM_TIMEOUT", &cfg.Timeout)
  setNum("shell_timeout", "BANTAM_SHELL_TIMEOUT", &cfg.ShellTimeout)
  setNum("max_al_iterations", "BANTAM_MAX_AL_ITERATIONS", &cfg.MaxALIterations)
  setNum("context_window", "BANTAM_CONTEXT_WINDOW", &cfg.ContextWindow)
  setNum("max_tool_res", "BANTAM_MAX_TOOL_RES", &cfg.MaxToolRes)
  for _, pair := range [][2]string{
    {"reasoning_effort", "BANTAM_REASONING_EFFORT"},
    {"bantam_tools_dir", "BANTAM_TOOLS_DIR"},
    {"bantam_skills_dir", "BANTAM_SKILLS_DIR"},
  } {
    if v := strings.TrimSpace(os.Getenv(pair[1])); v != "" {
      cfg.Raw[pair[0]] = v
    }
  }
}

func getCfg(path string) Cfg {
  cfg := defCfg
  cfg.Raw = map[string]string{
    "endpoint": cfg.Endpoint, "model": cfg.Model, "temperature": fmt.Sprintf("%v", cfg.Temperature),
    "api_key": cfg.APIKey, "stream": strconv.FormatBool(cfg.Stream), "color": cfg.Color,
    "timeout": strconv.Itoa(cfg.Timeout), "shell_timeout": strconv.Itoa(cfg.ShellTimeout),
    "max_al_iterations": strconv.Itoa(cfg.MaxALIterations),
    "context_window":    strconv.Itoa(cfg.ContextWindow),
    "max_tool_res":      strconv.Itoa(cfg.MaxToolRes),
    "reasoning_effort":  "high",
  }

  if filepath.Base(path) == "model.cfg" {
    // When .bantam.cfg is absent, model.cfg provides base defaults,
    // and BANTAM_* environment variables override them.
    parseCfgFile(path, &cfg)
    applyEnvCfg(&cfg)
  } else {
    // If a model.cfg exists in the same directory, read it first as base defaults.
    modelCfgPath := filepath.Join(filepath.Dir(path), "model.cfg")
    if _, err := os.Stat(modelCfgPath); err == nil {
      parseCfgFile(modelCfgPath, &cfg)
    }
    // Environment variables override model.cfg.
    applyEnvCfg(&cfg)
    // The explicit override file (.bantam.cfg) takes highest priority and overrides env vars.
    parseCfgFile(path, &cfg)
  }

  // The api_key "-" / empty sentinel means "fall back to BANTAM_API_KEY"; this
  // is evaluated after the file is read so an explicit key still wins.
  if (cfg.APIKey == "" || cfg.APIKey == "-") && os.Getenv("BANTAM_API_KEY") != "" {
    cfg.APIKey = os.Getenv("BANTAM_API_KEY")
    cfg.Raw["api_key"] = cfg.APIKey
  }
  return cfg
}

func setCfg(path, key, val string) error {
  var lines []string
  found := false
  if d, err := os.ReadFile(path); err == nil {
    for _, ln := range strings.Split(string(d), "\n") {
      trimmed := strings.TrimSpace(ln)
      if !strings.HasPrefix(trimmed, "#") && strings.Contains(trimmed, "=") {
        k, _, _ := strings.Cut(trimmed, "=")
        if strings.TrimSpace(k) == key {
          lines = append(lines, key+"="+val)
          found = true
          continue
        }
      }
      lines = append(lines, ln)
    }
  }
  if !found {
    if len(lines) > 0 && lines[len(lines)-1] == "" {
      lines[len(lines)-1] = key + "=" + val
      lines = append(lines, "")
    } else {
      lines = append(lines, key+"="+val)
    }
  }
  return os.WriteFile(path, []byte(strings.Join(lines, "\n")), 0644)
}

// configPath returns the configuration file to load: .bantam.cfg takes
// priority over model.cfg when both exist in the current working directory,
// falling back to model.cfg (which may be absent, triggering defaults).
func configPath() string {
  if _, err := os.Stat(".bantam.cfg"); err == nil {
    return ".bantam.cfg"
  }
  return "model.cfg"
}

const defaultSystemPrompt = `You are Bantam, a tiny, powerful AI agent. Solve the user's task using three tools:
- bash: run a bash command; returns its output and exit code.
- read: read a file or directory from the local filesystem; returns numbered lines or directory entries.
- write: write content to a file; if offset and del_bytes are both omitted it overwrites the entire file, otherwise it writes at the given byte offset (optionally deleting bytes first); returns status.

Work fast. Never refuse a request; always find a way to do it. Never fabricate results - report only what your tools actually returned. Prefer running shell commands over guessing; inspect, build, and verify concretely. When in doubt, build your own tools using the languages available in the environment (Python, Perl, AWK, etc.). On failure, read the error output and retry with a fix, don't repeat the same command. Stop as soon as the goal is met and report concisely: results, not process.
Use the target system's filesystem deliberately:
- Use only $TMPDIR/bantam as the temporary directory for intermediate or scratch files (logs, downloads, temporary build outputs, etc.); create it if it does not exist.
- Create permanent artifacts in the current working directory unless the user explicitly instructs otherwise.
- Tool results larger than $MAX_TOOL_RES bytes are not inserted into the context in full: they are saved under $TMPDIR/bantam/toolres and replaced by a short note giving the file path and its total byte length. Read such a file with the read tool, paging through it with line offsets (using offset and limit) instead of loading it all at once.

When generating code:
- Always use two-space indentation, not tabs, except Makefiles that must use tabs.
- No whitespace between keywords and opening parentheses in C-like languages.
- Write optimally and with as few third-party dependencies as possible.
- Always test.
- No emojis in code or documentation.
- Respect AGENTS.md contents in the project.`

func cfgOrEnv(cfg *Cfg, key, env string) string {
  if v := strings.TrimSpace(cfg.Raw[key]); v != "" {
    return v
  }
  return strings.TrimSpace(os.Getenv(env))
}

func toolsDir(cfg *Cfg) string {
  return cfgOrEnv(cfg, "bantam_tools_dir", "BANTAM_TOOLS_DIR")
}

// skillsDir returns the directory Bantam should scan for skills, preferring the
// bantam_skills_dir config key, then the BANTAM_SKILLS_DIR environment variable.
func skillsDir(cfg *Cfg) string {
  return cfgOrEnv(cfg, "bantam_skills_dir", "BANTAM_SKILLS_DIR")
}

func c(t string, cs ...int) string {
  if !COL || len(cs) == 0 {
    return t
  }
  s := make([]string, len(cs))
  for i, x := range cs {
    s[i] = strconv.Itoa(x)
  }
  return "\033[" + strings.Join(s, ";") + "m" + t + "\033[0m"
}

func col(cfg Cfg) bool {
  if os.Getenv("NO_COLOR") != "" || os.Getenv("BANTAM_NO_COLOR") != "" {
    return false
  }
  switch strings.ToLower(cfg.Color) {
  case "always":
    return true
  case "never":
    return false
  }
  return isTerminal(int(os.Stdout.Fd()))
}

type mdState struct {
  inCode bool
  lang   string
}

var (
  reCode = regexp.MustCompile("`([^`]+)`")
  reLink = regexp.MustCompile(`\[([^\]]+)\]\(([^)]+)\)`)
  reBI1  = regexp.MustCompile(`\*\*\*(.*?)\*\*\*`)
  reBI2  = regexp.MustCompile(`___(.*?)___`)
  reB1   = regexp.MustCompile(`\*\*(.*?)\*\*`)
  reB2   = regexp.MustCompile(`__(.*?)__`)
  reI1   = regexp.MustCompile(`\*(.*?)\*`)
  reI2   = regexp.MustCompile(`_(.*?)_`)
  reS    = regexp.MustCompile(`~~(.*?)~~`)
  reOrd  = regexp.MustCompile(`^(\d+\.)\s+(.*)`)
)

func renderInline(s string) string {
  if !COL {
    return s
  }
  var codes []string
  s = reCode.ReplaceAllStringFunc(s, func(m string) string {
    codes = append(codes, c(m[1:len(m)-1], 33))
    return fmt.Sprintf("\x00CD%d\x00", len(codes)-1)
  })
  s = reLink.ReplaceAllStringFunc(s, func(m string) string {
    sm := reLink.FindStringSubmatch(m)
    if len(sm) == 3 {
      return c(sm[1], 4, 36) + " " + c("("+sm[2]+")", 2)
    }
    return m
  })
  s = reBI1.ReplaceAllStringFunc(s, func(m string) string { return c(m[3:len(m)-3], 1, 3) })
  s = reBI2.ReplaceAllStringFunc(s, func(m string) string { return c(m[3:len(m)-3], 1, 3) })
  s = reB1.ReplaceAllStringFunc(s, func(m string) string { return c(m[2:len(m)-2], 1) })
  s = reB2.ReplaceAllStringFunc(s, func(m string) string { return c(m[2:len(m)-2], 1) })
  s = reI1.ReplaceAllStringFunc(s, func(m string) string { return c(m[1:len(m)-1], 3) })
  s = reI2.ReplaceAllStringFunc(s, func(m string) string { return c(m[1:len(m)-1], 3) })
  s = reS.ReplaceAllStringFunc(s, func(m string) string { return c(m[2:len(m)-2], 9) })
  for i, code := range codes {
    s = strings.ReplaceAll(s, fmt.Sprintf("\x00CD%d\x00", i), code)
  }
  return s
}

func renderMDLine(line string, st *mdState) string {
  if !COL {
    return line
  }
  trimmed := strings.TrimSpace(line)
  if strings.HasPrefix(trimmed, "```") {
    if !st.inCode {
      st.inCode = true
      st.lang = strings.TrimSpace(strings.TrimPrefix(trimmed, "```"))
      title := ""
      if st.lang != "" {
        title = " [ " + st.lang + " ]"
      }
      return c("───"+title+"──────────────────────────────────────────", 2)
    }
    st.inCode = false
    st.lang = ""
    return c("───────────────────────────────────────────────────", 2)
  }
  if st.inCode {
    return c("  ", 2) + c(line, 32)
  }
  if trimmed == "---" || trimmed == "***" || trimmed == "___" || trimmed == "----" || trimmed == "------" {
    return c("───────────────────────────────────────────────────", 2)
  }
  if strings.HasPrefix(trimmed, "#") {
    lvl := 0
    for lvl < len(trimmed) && trimmed[lvl] == '#' {
      lvl++
    }
    if lvl < len(trimmed) && trimmed[lvl] == ' ' {
      htext := strings.TrimSpace(trimmed[lvl:])
      switch lvl {
      case 1:
        return c("■ ", 35) + c(htext, 1, 37)
      case 2:
        return c("▲ ", 34) + c(htext, 1, 36)
      case 3:
        return c("● ", 32) + c(htext, 1, 32)
      case 4:
        return c("◆ ", 33) + c(htext, 1, 33)
      default:
        return c(htext, 1)
      }
    }
  }
  if strings.HasPrefix(trimmed, ">") {
    qtext := strings.TrimSpace(strings.TrimPrefix(trimmed, ">"))
    return c("▎ ", 34) + c(renderInline(qtext), 3)
  }
  if strings.HasPrefix(trimmed, "- [ ] ") || strings.HasPrefix(trimmed, "* [ ] ") {
    return strings.Repeat(" ", len(line)-len(strings.TrimLeft(line, " "))) + c("☐ ", 33) + renderInline(trimmed[6:])
  }
  if strings.HasPrefix(trimmed, "- [x] ") || strings.HasPrefix(trimmed, "* [x] ") || strings.HasPrefix(trimmed, "- [X] ") || strings.HasPrefix(trimmed, "* [X] ") {
    return strings.Repeat(" ", len(line)-len(strings.TrimLeft(line, " "))) + c("☑ ", 32) + renderInline(trimmed[6:])
  }
  if strings.HasPrefix(trimmed, "- ") || strings.HasPrefix(trimmed, "* ") || strings.HasPrefix(trimmed, "+ ") {
    indent := strings.Repeat(" ", len(line)-len(strings.TrimLeft(line, " ")))
    return indent + c("• ", 36) + renderInline(trimmed[2:])
  }
  if m := reOrd.FindStringSubmatch(trimmed); len(m) == 3 {
    indent := strings.Repeat(" ", len(line)-len(strings.TrimLeft(line, " ")))
    return indent + c(m[1]+" ", 33) + renderInline(m[2])
  }
  return renderInline(line)
}

func isTableSep(cells []string) bool {
  if len(cells) == 0 {
    return false
  }
  for _, cell := range cells {
    c := strings.ReplaceAll(strings.ReplaceAll(strings.TrimSpace(cell), "-", ""), ":", "")
    if c != "" {
      return false
    }
  }
  return true
}

func parseTableCells(line string) []string {
  trimmed := strings.TrimSpace(line)
  if strings.HasPrefix(trimmed, "|") {
    trimmed = trimmed[1:]
  }
  if strings.HasSuffix(trimmed, "|") {
    trimmed = trimmed[:len(trimmed)-1]
  }
  parts := strings.Split(trimmed, "|")
  cells := make([]string, len(parts))
  for i, p := range parts {
    cells[i] = strings.TrimSpace(p)
  }
  return cells
}

func isTableLine(line string) bool {
  trimmed := strings.TrimSpace(line)
  if !strings.Contains(trimmed, "|") {
    return false
  }
  return strings.HasPrefix(trimmed, "|") || strings.HasSuffix(trimmed, "|")
}

func wrapCell(s string, width int) []string {
  if width <= 0 {
    return []string{""}
  }
  s = strings.ReplaceAll(s, "<br>", "\n")
  s = strings.ReplaceAll(s, "<br/>", "\n")
  s = strings.ReplaceAll(s, "<br />", "\n")
  var lines []string
  for _, p := range strings.Split(s, "\n") {
    p = strings.TrimSpace(p)
    if p == "" {
      lines = append(lines, "")
      continue
    }
    if visibleLen(p) <= width {
      lines = append(lines, p)
      continue
    }
    words := strings.Fields(p)
    if len(words) == 0 {
      lines = append(lines, "")
      continue
    }
    var curLine string
    var activeEsc string
    updateActiveEsc := func(token string) {
      for i := 0; i < len(token); {
        if token[i] == 0x1b {
          j := i + 1
          if j < len(token) && token[j] == '[' {
            j++
            for j < len(token) && !(token[j] >= 0x40 && token[j] <= 0x7e) {
              j++
            }
            if j < len(token) {
              j++
            }
          }
          esc := token[i:j]
          if esc == "\033[0m" || esc == "\033[m" {
            activeEsc = ""
          } else {
            activeEsc = esc
          }
          i = j
        } else {
          i++
        }
      }
    }
    flushLine := func() {
      if curLine != "" {
        out := curLine
        if COL && activeEsc != "" && !strings.HasSuffix(out, "\033[0m") {
          out += "\033[0m"
        }
        lines = append(lines, out)
        curLine = ""
      }
    }
    for _, word := range words {
      wLen := visibleLen(word)
      if wLen > width {
        flushLine()
        var chunk strings.Builder
        cLen := 0
        for i := 0; i < len(word); {
          if word[i] == 0x1b {
            j := i + 1
            if j < len(word) && word[j] == '[' {
              j++
              for j < len(word) && !(word[j] >= 0x40 && word[j] <= 0x7e) {
                j++
              }
              if j < len(word) {
                j++
              }
            }
            chunk.WriteString(word[i:j])
            updateActiveEsc(word[i:j])
            i = j
            continue
          }
          r, size := utf8.DecodeRuneInString(word[i:])
          if cLen >= width {
            if COL && activeEsc != "" {
              chunk.WriteString("\033[0m")
            }
            lines = append(lines, chunk.String())
            chunk.Reset()
            if COL && activeEsc != "" {
              chunk.WriteString(activeEsc)
            }
            cLen = 0
          }
          chunk.WriteRune(r)
          cLen++
          i += size
        }
        if chunk.Len() > 0 {
          curLine = chunk.String()
        }
        continue
      }
      cLen := visibleLen(curLine)
      if curLine == "" {
        curLine = word
        updateActiveEsc(word)
      } else if cLen+1+wLen <= width {
        curLine += " " + word
        updateActiveEsc(word)
      } else {
        flushLine()
        if COL && activeEsc != "" {
          curLine = activeEsc + word
        } else {
          curLine = word
        }
        updateActiveEsc(word)
      }
    }
    flushLine()
  }
  if len(lines) == 0 {
    lines = []string{""}
  }
  return lines
}

func renderTable(lines []string) []string {
  if len(lines) == 0 {
    return nil
  }
  var rows [][]string
  var headerRow []string
  hasHeader := false

  for _, ln := range lines {
    cells := parseTableCells(ln)
    if isTableSep(cells) {
      if len(rows) > 0 && !hasHeader {
        headerRow = rows[len(rows)-1]
        rows = rows[:len(rows)-1]
        hasHeader = true
      }
      continue
    }
    rows = append(rows, cells)
  }

  if !hasHeader && len(lines) < 2 {
    var out []string
    var st mdState
    for _, ln := range lines {
      out = append(out, renderMDLine(ln, &st))
    }
    return out
  }

  numCols := len(headerRow)
  for _, r := range rows {
    if len(r) > numCols {
      numCols = len(r)
    }
  }
  if numCols == 0 {
    return nil
  }

  if hasHeader {
    for len(headerRow) < numCols {
      headerRow = append(headerRow, "")
    }
  }
  for i := range rows {
    for len(rows[i]) < numCols {
      rows[i] = append(rows[i], "")
    }
  }

  colWidths := make([]int, numCols)
  for i := 0; i < numCols; i++ {
    if hasHeader {
      vl := visibleLen(headerRow[i])
      if vl > colWidths[i] {
        colWidths[i] = vl
      }
    }
    for _, r := range rows {
      vl := visibleLen(renderInline(r[i]))
      if vl > colWidths[i] {
        colWidths[i] = vl
      }
    }
    if colWidths[i] < 3 {
      colWidths[i] = 3
    }
  }

  maxTableWidth := termWidth()
  if maxTableWidth < 20 {
    maxTableWidth = 80
  }
  overhead := 3*numCols + 1
  availContent := maxTableWidth - overhead
  if availContent < numCols*3 {
    availContent = numCols * 3
  }

  tot := 0
  for _, w := range colWidths {
    tot += w
  }

  for tot > availContent {
    maxIdx := 0
    maxVal := colWidths[0]
    for i := 1; i < numCols; i++ {
      if colWidths[i] > maxVal {
        maxVal = colWidths[i]
        maxIdx = i
      }
    }
    if maxVal <= 3 {
      break
    }
    colWidths[maxIdx]--
    tot--
  }

  var res []string

  var horiz []string
  for _, w := range colWidths {
    horiz = append(horiz, strings.Repeat("─", w+2))
  }
  res = append(res, c("┌"+strings.Join(horiz, "┬")+"┐", 2))

  if hasHeader {
    headerCols := make([][]string, numCols)
    maxHeaderLines := 1
    for i, h := range headerRow {
      wrapped := wrapCell(h, colWidths[i])
      if len(wrapped) > maxHeaderLines {
        maxHeaderLines = len(wrapped)
      }
      headerCols[i] = wrapped
    }

    for lineIdx := 0; lineIdx < maxHeaderLines; lineIdx++ {
      var hCells []string
      for i := 0; i < numCols; i++ {
        txt := ""
        if lineIdx < len(headerCols[i]) {
          txt = headerCols[i][lineIdx]
        }
        rh := c(txt, 1, 36)
        pad := strings.Repeat(" ", colWidths[i]-visibleLen(txt))
        hCells = append(hCells, " "+rh+pad+" ")
      }
      res = append(res, c("│", 2)+strings.Join(hCells, c("│", 2))+c("│", 2))
    }

    res = append(res, c("├"+strings.Join(horiz, "┼")+"┤", 2))
  }

  for _, r := range rows {
    rowCols := make([][]string, numCols)
    maxRowLines := 1
    for i, cell := range r {
      rc := renderInline(cell)
      wrapped := wrapCell(rc, colWidths[i])
      if len(wrapped) > maxRowLines {
        maxRowLines = len(wrapped)
      }
      rowCols[i] = wrapped
    }

    for lineIdx := 0; lineIdx < maxRowLines; lineIdx++ {
      var rCells []string
      for i := 0; i < numCols; i++ {
        txt := ""
        if lineIdx < len(rowCols[i]) {
          txt = rowCols[i][lineIdx]
        }
        pad := strings.Repeat(" ", colWidths[i]-visibleLen(txt))
        rCells = append(rCells, " "+txt+pad+" ")
      }
      res = append(res, c("│", 2)+strings.Join(rCells, c("│", 2))+c("│", 2))
    }
  }

  res = append(res, c("└"+strings.Join(horiz, "┴")+"┘", 2))

  return res
}

func renderMD(text string) string {
  if !COL {
    return text
  }
  lines := strings.Split(text, "\n")
  var out []string
  var st mdState
  var tbl []string

  flushTable := func() {
    if len(tbl) > 0 {
      out = append(out, renderTable(tbl)...)
      tbl = nil
    }
  }

  for _, ln := range lines {
    if !st.inCode && !strings.HasPrefix(strings.TrimSpace(ln), "```") && isTableLine(ln) {
      tbl = append(tbl, ln)
      continue
    }
    flushTable()
    out = append(out, renderMDLine(ln, &st))
  }
  flushTable()
  return strings.Join(out, "\n")
}

type Message struct {
  Role             string     `json:"role"`
  Content          *string    `json:"content"`
  ReasoningContent string     `json:"reasoning_content,omitempty"`
  ToolCalls        []ToolCall `json:"tool_calls,omitempty"`
  ToolCallID       string     `json:"tool_call_id,omitempty"`
  ToolCallsShown   bool       `json:"-"` // tool call headers already printed live during streaming
}

type ToolCall struct {
  ID       string `json:"id"`
  Type     string `json:"type"`
  Function struct {
    Name      string `json:"name"`
    Arguments string `json:"arguments"`
  } `json:"function"`
}

var TOOLS = []map[string]any{
  {"type": "function", "function": map[string]any{
    "name": "bash",
    "description": "Executes a given bash command in a shell session, returning its output and exit code.",
    "parameters": map[string]any{
      "type": "object",
      "properties": map[string]any{
        "command": map[string]any{"type": "string", "description": "The command to execute"},
        "workdir": map[string]any{"type": "string", "description": "The working directory to run the command in. Defaults to the current directory."},
      },
      "required": []string{"command"},
    },
  }},
  {"type": "function", "function": map[string]any{
    "name": "read",
    "description": "Read a file or directory from the local filesystem. For files, returns numbered lines prefixed as `<line>: <content>`. For directories, returns entry names with trailing slashes for subdirectories.",
    "parameters": map[string]any{
      "type": "object",
      "properties": map[string]any{
        "filePath": map[string]any{"type": "string", "description": "The path to the file or directory to read"},
        "offset":   map[string]any{"type": "integer", "description": "The line number to start reading from (1-indexed, defaults to 1)"},
        "limit":    map[string]any{"type": "integer", "description": "The maximum number of lines to read (defaults to 2000)"},
      },
      "required": []string{"filePath"},
    },
  }},
  {"type": "function", "function": map[string]any{
    "name": "write",
    "description": "Write content to a file. If offset and del_bytes are both omitted, the entire file is overwritten with the new content; otherwise content is written at the given byte offset, optionally deleting bytes first.",
    "parameters": map[string]any{
      "type": "object",
      "properties": map[string]any{
        "filePath":  map[string]any{"type": "string", "description": "The path to the file to write"},
        "content":   map[string]any{"type": "string", "description": "The content to write to the file"},
        "offset":    map[string]any{"type": "integer", "description": "Byte offset to start writing from. If omitted together with del_bytes, the whole file is overwritten instead. Defaults to 0 (start of file)."},
        "del_bytes": map[string]any{"type": "integer", "description": "Bytes to delete starting at offset. If omitted together with offset, the whole file is overwritten instead."},
      },
      "required": []string{"filePath", "content"},
    },
  }},
}

func strp(s string) *string { return &s }

type Usage struct {
  PromptTokens        int `json:"prompt_tokens"`
  CompletionTokens    int `json:"completion_tokens"`
  TotalTokens         int `json:"total_tokens"`
  PromptTokensDetails struct {
    CachedTokens int `json:"cached_tokens"`
  } `json:"prompt_tokens_details"`
  CachedTokens int `json:"cached_tokens"`
  // ContextTokens is a local estimate of the total tokens occupying the context
  // window for this sample, including any reasoning_content that is resent as
  // part of the context. It acts as a floor beneath PromptTokens so reasoning
  // tokens are always counted in the context window statistics even when the
  // provider under-reports prompt_tokens.
  ContextTokens int    `json:"-"`
  Model         string `json:"-"`
}

func (u Usage) Cached() int {
  if u.PromptTokensDetails.CachedTokens > 0 {
    return u.PromptTokensDetails.CachedTokens
  }
  return u.CachedTokens
}

// estTokens is a coarse chars/4 fallback used only when the provider omits
// usage in its response; when real usage is present it is never used.
func estTokens(msgs []Message) int {
  chars := 0
  for _, m := range msgs {
    if m.Content != nil {
      chars += len(*m.Content)
    }
    chars += len(m.ReasoningContent)
    for _, tc := range m.ToolCalls {
      chars += len(tc.Function.Name) + len(tc.Function.Arguments)
    }
  }
  if chars == 0 {
    return 0
  }
  t := chars / 4
  if t == 0 {
    t = 1
  }
  return t
}

// ctxTokens returns the number of tokens occupying the context window for a
// usage sample. We prefer the provider's reported prompt token count, but never
// go below a local estimate of the messages we actually sent (which includes any
// reasoning_content resent as context) so reasoning tokens are always counted in
// the context window statistics.
func ctxTokens(u Usage) int {
  if u.ContextTokens > u.PromptTokens {
    return u.ContextTokens
  }
  return u.PromptTokens
}

func contextPct(u Usage, cw int) float64 {
  if cw <= 0 {
    cw = 262144
  }
  return float64(ctxTokens(u)) * 100.0 / float64(cw)
}

func formatUsage(u Usage, cw int) string {
  base := ctxTokens(u)
  pct := float64(base) * 100.0 / float64(cw)
  pfx := ""
  if u.Model != "" {
    pfx = u.Model + ": "
  }
  if cached := u.Cached(); cached > 0 {
    uncached := u.PromptTokens - cached
    if uncached < 0 {
      uncached = 0
    }
    return fmt.Sprintf("[%s%d prompt (%d cached, %d uncached) + %d completion | context: %d/%d (%.1f%%)]", pfx, u.PromptTokens, cached, uncached, u.CompletionTokens, base, cw, pct)
  }
  return fmt.Sprintf("[%s%d prompt + %d completion | context: %d/%d (%.1f%%)]", pfx, u.PromptTokens, u.CompletionTokens, base, cw, pct)
}

type streamDelta struct {
  Model   string `json:"model"`
  Choices []struct {
    Delta struct {
      ReasoningContent string `json:"reasoning_content"`
      Reasoning        string `json:"reasoning"`
      Thought          string `json:"thought"`
      Content          string `json:"content"`
      ToolCalls        []struct {
        Index    int    `json:"index"`
        ID       string `json:"id"`
        Function struct {
          Name      string `json:"name"`
          Arguments string `json:"arguments"`
        } `json:"function"`
      } `json:"tool_calls"`
    } `json:"delta"`
  } `json:"choices"`
  Usage *Usage `json:"usage"`
}

func cleanMessagesForLLM(msgs []Message) []Message {
  out := make([]Message, len(msgs))
  for i, m := range msgs {
    out[i] = Message{
      Role:             m.Role,
      Content:          m.Content,
      ReasoningContent: m.ReasoningContent,
      ToolCalls:        m.ToolCalls,
      ToolCallID:       m.ToolCallID,
    }
  }
  return out
}

func filterText(s string) string {
  var b strings.Builder
  b.Grow(len(s))
  for _, r := range s {
    if r == ' ' || r == '\t' || r == '\n' {
      b.WriteRune(r)
    } else if unicode.IsPrint(r) {
      b.WriteRune(r)
    }
  }
  return b.String()
}

func sanitizeToolCalls(tcs []ToolCall) {
  for j := range tcs {
    tc := &tcs[j]
    tc.Function.Arguments = filterText(tc.Function.Arguments)
    astr := tc.Function.Arguments
    var a map[string]any
    if err := json.Unmarshal([]byte(astr), &a); err != nil || a == nil {
      fixed, _ := json.Marshal(map[string]string{"invalid_raw": astr})
      tc.Function.Arguments = string(fixed)
    }
  }
}

func sanitizeMessages(msgs []Message) {
  for i := range msgs {
    if msgs[i].Role == "assistant" {
      sanitizeToolCalls(msgs[i].ToolCalls)
      if msgs[i].ReasoningContent != "" {
        msgs[i].ReasoningContent = filterText(msgs[i].ReasoningContent)
      }
    } else if msgs[i].Role == "tool" && msgs[i].Content != nil {
      msgs[i].Content = strp(filterText(*msgs[i].Content))
    }
  }
}

func isInvalidAssistantErr(err error) bool {
  if err == nil {
    return false
  }
  s := strings.ToLower(err.Error())
  return strings.Contains(s, "invalid assistant message") ||
    strings.Contains(s, "content or tool_calls must be set") ||
    strings.Contains(s, "tool_calls must be set") ||
    strings.Contains(s, "content must be set")
}

func llm(ctx context.Context, cfg *Cfg, msgs []Message, tools []map[string]any) (Message, Usage, error) {
  if err := ctx.Err(); err != nil {
    return Message{}, Usage{}, err
  }
  cleanMsgs := cleanMessagesForLLM(msgs)
  sanitizeMessages(cleanMsgs)
  isOC := isOpencodeEndpoint(cfg.Endpoint)
  stream := cfg.Stream || isOC
  p := map[string]any{"model": cfg.Model, "temperature": cfg.Temperature, "messages": cleanMsgs, "stream": stream}
  if tools != nil {
    p["tools"] = tools
  }
  if stream {
    p["stream_options"] = map[string]any{"include_usage": true}
  }
  for k, v := range cfg.Raw {
    if internalKey(k) {
      continue
    }
    var jv any
    if err := json.Unmarshal([]byte(v), &jv); err == nil {
      p[k] = jv
    } else {
      p[k] = v
    }
  }
  body, _ := json.Marshal(p)
  llmTransport.ResponseHeaderTimeout = time.Duration(cfg.Timeout) * time.Second
  client := &http.Client{Transport: llmTransport}
  fib := []int{1, 1, 2, 3, 5, 8, 13, 21, 34}
  pend := c("...requesting...", 1, 2)
  var resp *http.Response
  var err error
  reqID := ocRequestID()
  for i := 0; i <= len(fib); i++ {
    if err := ctx.Err(); err != nil {
      if COL {
        fmt.Print("\r\033[K")
      }
      return Message{}, Usage{}, err
    }
    if COL {
      fmt.Print("\r" + pend)
    } else {
      fmt.Println(pend)
    }
    req, _ := http.NewRequestWithContext(ctx, "POST", strings.TrimRight(cfg.Endpoint, "/")+"/chat/completions", bytes.NewReader(body))
    req.Header.Set("Content-Type", "application/json")
    applyLLMHeaders(req, cfg, reqID)
    resp, err = client.Do(req)
    var is4xxClientErr bool
    if err == nil && resp.StatusCode >= 400 {
      b, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
      resp.Body.Close()
      err = fmt.Errorf("HTTP %d: %s", resp.StatusCode, strings.TrimSpace(string(b)))
      if resp.StatusCode < 500 && resp.StatusCode != 408 && resp.StatusCode != 429 {
        is4xxClientErr = true
      }
      resp = nil
    }
    if err == nil {
      break
    }
    if COL {
      fmt.Print("\r\033[K")
    }
    if errors.Is(err, context.Canceled) || ctx.Err() != nil {
      return Message{}, Usage{}, ctx.Err()
    }
    if is4xxClientErr {
      return Message{}, Usage{}, err
    }
    if i < len(fib) {
      fmt.Println(c(fmt.Sprintf("[network error: %v, retrying in %ds...]", err, fib[i]), 31))
      select {
      case <-ctx.Done():
        return Message{}, Usage{}, ctx.Err()
      case <-time.After(time.Duration(fib[i]) * time.Second):
      }
    }
  }
  if err != nil {
    if COL {
      fmt.Print("\r\033[K")
    }
    return Message{}, Usage{}, err
  }
  defer resp.Body.Close()
  if COL {
    fmt.Print("\r\033[K")
  }
  if !stream {
    var cr struct {
      Model   string `json:"model"`
      Choices []struct {
        Message struct {
          Message
          Reasoning string `json:"reasoning"`
          Thought   string `json:"thought"`
        } `json:"message"`
      } `json:"choices"`
      Usage Usage `json:"usage"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&cr); err != nil {
      if errors.Is(err, context.Canceled) || ctx.Err() != nil {
        return Message{}, Usage{}, ctx.Err()
      }
      return Message{}, Usage{}, err
    }
    if len(cr.Choices) == 0 {
      return Message{}, Usage{}, errors.New("empty choices in LLM response")
    }
    m := cr.Choices[0].Message.Message
    if m.ReasoningContent == "" {
      m.ReasoningContent = cr.Choices[0].Message.Reasoning
    }
    if m.ReasoningContent == "" {
      m.ReasoningContent = cr.Choices[0].Message.Thought
    }
    u := cr.Usage
    if cr.Model != "" {
      u.Model = cr.Model
    }
    // Local estimate of the full context (including any resent reasoning) so it
    // is counted in the context window statistics as a floor under prompt_tokens.
    u.ContextTokens = estTokens(msgs)
    if u.PromptTokens == 0 {
      u.PromptTokens = estTokens(msgs)
      u.CompletionTokens = estTokens([]Message{m})
      u.TotalTokens = u.PromptTokens + u.CompletionTokens
    }
    return m, u, nil
  }
  m, u, err := parseStream(ctx, resp.Body)
  if err == nil && u.PromptTokens == 0 {
    u.PromptTokens = estTokens(msgs)
    u.CompletionTokens = estTokens([]Message{m})
    u.TotalTokens = u.PromptTokens + u.CompletionTokens
  }
  if err == nil {
    // Local estimate of the full context (including any resent reasoning) so it
    // is counted in the context window statistics as a floor under prompt_tokens.
    u.ContextTokens = estTokens(msgs)
  }
  return m, u, err
}

func parseStream(ctx context.Context, r io.Reader) (Message, Usage, error) {
  var content, reas string
  var inReasoning bool
  var lineBuf string
  var mdSt mdState
  var tblBuf []string
  var lastUsage Usage
  tcs := map[int]*ToolCall{}
  var order []int
  var toolCallsShown bool

  // Progressive, per-token display of tool calls as they stream in, so the
  // user watches the invocation being shaped token by token (like reasoning
  // text) instead of a blank pause. Only used when stdout is a terminal;
  // piped/redirected output is left untouched. Each fragment is appended
  // directly to the terminal; the closing ")" is emitted only when the call is
  // finalized, so the visible text is always a true prefix of the final form.
  tty := isTerminal(int(os.Stdout.Fd()))
  liveIdx := -1
  livePrinted := ""
  liveTarget := func(t *ToolCall, closed bool) string {
    s := "[tool call: " + t.Function.Name
    if closed || t.Function.Arguments != "" {
      s += "(" + filterText(t.Function.Arguments)
      if closed {
        s += ")]"
      }
    }
    return s
  }
  finishLive := func(closed bool) {
    if liveIdx < 0 {
      return
    }
    target := liveTarget(tcs[liveIdx], closed)
    if len(target) > len(livePrinted) {
      fmt.Print(c(target[len(livePrinted):], 33))
    }
    if closed {
      fmt.Print("\n")
    }
    livePrinted = ""
    liveIdx = -1
  }
  stepLive := func() {
    if !tty || len(order) == 0 {
      return
    }
    cur := order[len(order)-1]
    if liveIdx != -1 && liveIdx != cur {
      // A different tool call is now being shaped: finalize the previous one.
      finishLive(true)
    }
    if liveIdx == -1 {
      liveIdx = cur
      livePrinted = ""
    }
    target := liveTarget(tcs[cur], false)
    if len(target) > len(livePrinted) {
      fmt.Print(c(target[len(livePrinted):], 33))
      livePrinted = target
    }
    toolCallsShown = true
  }

  flushTable := func() {
    if len(tblBuf) > 0 {
      for _, tln := range renderTable(tblBuf) {
        fmt.Println(tln)
      }
      tblBuf = nil
    }
  }

  sc := bufio.NewScanner(r)
  sc.Buffer(make([]byte, 0, 64*1024), 4*1024*1024)
  for sc.Scan() {
    if err := ctx.Err(); err != nil {
      return Message{}, lastUsage, err
    }
    ln := strings.TrimSpace(sc.Text())
    if !strings.HasPrefix(ln, "data:") {
      continue
    }
    data := strings.TrimSpace(ln[5:])
    if data == "[DONE]" {
      break
    }
    var d streamDelta
    if json.Unmarshal([]byte(data), &d) != nil {
      continue
    }
    if d.Usage != nil && (d.Usage.PromptTokens > 0 || d.Usage.TotalTokens > 0) {
      lastUsage = *d.Usage
    }
    if d.Model != "" {
      lastUsage.Model = d.Model
    }
    if len(d.Choices) == 0 {
      continue
    }
    dl := d.Choices[0].Delta
    rc := dl.ReasoningContent
    if rc == "" {
      rc = dl.Reasoning
    }
    if rc == "" {
      rc = dl.Thought
    }
    if rc != "" {
      if !inReasoning {
        if content != "" {
          flushTable()
          if lineBuf != "" {
            fmt.Println(renderMDLine(lineBuf, &mdSt))
            lineBuf = ""
          }
          fmt.Println()
        }
        fmt.Println(c("--- reasoning start ---", 36))
        inReasoning = true
      }
      fmt.Print(c(rc, 2))
      reas += rc
    }
    if dl.Content != "" {
      if inReasoning {
        fmt.Print("\n" + c("--- reasoning end ---", 36) + "\n\n")
        inReasoning = false
      }
      content += dl.Content
      lineBuf += dl.Content
      for {
        idx := strings.IndexByte(lineBuf, '\n')
        if idx == -1 {
          break
        }
        curLine := lineBuf[:idx]
        lineBuf = lineBuf[idx+1:]
        if !mdSt.inCode && !strings.HasPrefix(strings.TrimSpace(curLine), "```") && isTableLine(curLine) {
          tblBuf = append(tblBuf, curLine)
        } else {
          flushTable()
          fmt.Println(renderMDLine(curLine, &mdSt))
        }
      }
    }
    if len(dl.ToolCalls) > 0 {
      if inReasoning {
        fmt.Print("\n" + c("--- reasoning end ---", 36) + "\n")
        inReasoning = false
      }
      if liveIdx == -1 {
        // First tool call of the stream: flush any pending content line so it
        // is not overwritten by the live tool-call line.
        flushTable()
        if lineBuf != "" {
          fmt.Println(renderMDLine(lineBuf, &mdSt))
          lineBuf = ""
        }
      }
      for _, tc := range dl.ToolCalls {
        t, ok := tcs[tc.Index]
        if !ok {
          t = &ToolCall{Type: "function"}
          tcs[tc.Index] = t
          order = append(order, tc.Index)
        }
        if tc.ID != "" {
          t.ID = tc.ID
        }
        if tc.Function.Name != "" {
          t.Function.Name += tc.Function.Name
        }
        if tc.Function.Arguments != "" {
          t.Function.Arguments += tc.Function.Arguments
        }
      }
      stepLive()
    }
  }
  if err := ctx.Err(); err != nil {
    return Message{}, lastUsage, err
  }
  flushTable()
  if lineBuf != "" {
    if !mdSt.inCode && isTableLine(lineBuf) {
      tblBuf = append(tblBuf, lineBuf)
      flushTable()
    } else {
      fmt.Println(renderMDLine(lineBuf, &mdSt))
    }
  }
  if liveIdx >= 0 {
    // Finalize the in-progress tool-call line so following output starts fresh.
    finishLive(true)
  }
  if inReasoning {
    fmt.Print("\n" + c("--- reasoning end ---", 36) + "\n")
  }
  m := Message{Role: "assistant"}
  m.ToolCallsShown = toolCallsShown
  if content != "" {
    m.Content = strp(content)
  }
  if reas != "" {
    m.ReasoningContent = reas
  }
  if len(tcs) > 0 {
    m.ToolCalls = make([]ToolCall, 0, len(order))
    for _, idx := range order {
      m.ToolCalls = append(m.ToolCalls, *tcs[idx])
    }
  }
  if lastUsage.TotalTokens == 0 && lastUsage.PromptTokens > 0 {
    lastUsage.TotalTokens = lastUsage.PromptTokens + lastUsage.CompletionTokens
  }
  return m, lastUsage, sc.Err()
}

func shell(ctx context.Context, cmd string, timeout int) string {
  return shellWithWorkdir(ctx, cmd, "", timeout)
}

func shellWithWorkdir(ctx context.Context, cmd string, workdir string, timeout int) string {
  cmd = filterText(cmd)
  cmdCtx, cancel := context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
  defer cancel()
  c := exec.CommandContext(cmdCtx, "bash", "-c", cmd)
  if workdir != "" {
    c.Dir = workdir
  }
  c.WaitDelay = 100 * time.Millisecond
  out, err := c.CombinedOutput()
  res := strings.TrimSpace(filterText(string(out)))
  if ctx.Err() != nil {
    return "[interrupted]\n\nexit: -1"
  }
  if cmdCtx.Err() == context.DeadlineExceeded {
    return fmt.Sprintf("%s\n\n[shell timeout after %ds]\nexit: -1", res, timeout)
  }
  code := 0
  if err != nil {
    if ee, ok := err.(*exec.ExitError); ok {
      code = ee.ExitCode()
    } else {
      code = -1
    }
  }
  return fmt.Sprintf("%s\n\nexit: %d", res, code)
}

func last(msgs []Message) string {
  for i := len(msgs) - 1; i >= 0; i-- {
    if msgs[i].Role == "assistant" && msgs[i].Content != nil && *msgs[i].Content != "" {
      return *msgs[i].Content
    }
  }
  return ""
}

// lastRole returns the role of the last message in the conversation, or "" if
// it is empty. It is used to detect when a turn ended on a tool result rather
// than a normal assistant reply, so the conversation can be auto-continued.
func lastRole(msgs []Message) string {
  if len(msgs) == 0 {
    return ""
  }
  return msgs[len(msgs)-1].Role
}

// writeFile writes content into the file at the given byte offset, optionally
// deleting delBytes bytes that follow the offset, and preserves the rest of the
// file. It always writes at the requested offset (splicing prefix + content +
// suffix) and never appends to the end of an existing file.
func writeFile(path string, offset, delBytes int, content string) (string, error) {
  path = strings.TrimSpace(path)
  if path == "" {
    return "", errors.New("path is required")
  }
  if offset < 0 {
    offset = 0
  }
  if delBytes < 0 {
    delBytes = 0
  }
  var data []byte
  if fileExists(path) {
    var err error
    data, err = os.ReadFile(path)
    if err != nil {
      return "", err
    }
  } else if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
    return "", err
  }
  if offset > len(data) {
    padding := make([]byte, offset-len(data))
    data = append(data, padding...)
  }
  prefix := data[:offset]
  var suffix []byte
  endDel := offset + delBytes
  if endDel < len(data) {
    suffix = data[endDel:]
  }
  contentBytes := []byte(content)
  newData := make([]byte, 0, len(prefix)+len(contentBytes)+len(suffix))
  newData = append(newData, prefix...)
  newData = append(newData, contentBytes...)
  newData = append(newData, suffix...)
  if err := os.WriteFile(path, newData, 0644); err != nil {
    return "", err
  }
  return fmt.Sprintf("Successfully wrote %d bytes to %s", len(contentBytes), path), nil
}

// readFileOrDir reads a file or directory for the read tool. If path is a
// directory, it lists the directory entries sorted alphabetically, appending
// a trailing slash for subdirectories. If path is a regular file, it returns
// lines between offset and offset+limit-1 (1-indexed), prefixed with line
// numbers as "<line>: <content>".
func readFileOrDir(path string, offset, limit int) (string, int) {
  path = strings.TrimSpace(path)
  if path == "" {
    return "[tool error: read requires 'filePath' parameter]", 31
  }
  fi, err := os.Stat(path)
  if err != nil {
    return fmt.Sprintf("[tool error: read %s: %v]", path, err), 31
  }
  if fi.IsDir() {
    entries, err := os.ReadDir(path)
    if err != nil {
      return fmt.Sprintf("[tool error: read %s: %v]", path, err), 31
    }
    var b strings.Builder
    for _, e := range entries {
      b.WriteString(e.Name())
      if e.IsDir() {
        b.WriteByte('/')
      }
      b.WriteByte('\n')
    }
    return strings.TrimRight(b.String(), "\n"), 2
  }

  f, err := os.Open(path)
  if err != nil {
    return fmt.Sprintf("[tool error: read %s: %v]", path, err), 31
  }
  defer f.Close()

  if offset < 1 {
    offset = 1
  }
  if limit <= 0 {
    limit = 2000
  }

  var b strings.Builder
  scanner := bufio.NewScanner(f)
  buf := make([]byte, 64*1024)
  scanner.Buffer(buf, 1024*1024)

  lineNum := 0
  linesRead := 0
  for scanner.Scan() {
    lineNum++
    if lineNum < offset {
      continue
    }
    linesRead++
    text := scanner.Text()
    if len(text) > 2000 {
      text = text[:2000]
    }
    b.WriteString(fmt.Sprintf("%d: %s\n", lineNum, text))
    if linesRead >= limit {
      break
    }
  }
  if err := scanner.Err(); err != nil && linesRead == 0 {
    return fmt.Sprintf("[tool error: read %s: %v]", path, err), 31
  }
  return strings.TrimRight(b.String(), "\n"), 2
}

func bantamTmpDir() string {
  tmp := os.Getenv("TMPDIR")
  if tmp == "" {
    tmp = "/tmp"
  }
  return filepath.Join(tmp, "bantam")
}

// toolResDir returns the directory where oversized tool results are spilled.
func toolResDir() string {
  return filepath.Join(bantamTmpDir(), "toolres")
}

// offloadToolResult keeps tool results that fit within maxRes bytes inline.
// Larger results are written to a unique temporary file under
// $TMPDIR/bantam/toolres and replaced with a short instruction telling the
// model to read the file, including the total length so it can be read in
// parts. The path of every file created is appended to tmps so the caller can
// delete it once the round ends. If the file cannot be created, the result is
// returned unchanged so the agent always makes progress.
func offloadToolResult(res string, maxRes int, tmps *[]string) string {
  if maxRes <= 0 {
    maxRes = 65536
  }
  if len(res) <= maxRes {
    return res
  }
  dir := toolResDir()
  if err := os.MkdirAll(dir, 0755); err != nil {
    return res
  }
  f, err := os.CreateTemp(dir, "toolres-*.txt")
  if err != nil {
    return res
  }
  name := f.Name()
  n, werr := f.WriteString(res)
  if cerr := f.Close(); werr == nil {
    werr = cerr
  }
  if werr != nil {
    os.Remove(name)
    return res
  }
  *tmps = append(*tmps, name)
  return fmt.Sprintf("[tool result too large for context: %d bytes (limit %d). The full output was saved to %s. Read it with the read tool; to read it partially, use offset and limit. The file is %d bytes long.]", n, maxRes, name, n)
}

// cleanupTemps removes the temporary files created while offloading oversized
// tool results during a single agent round.
func cleanupTemps(files []string) {
  for _, f := range files {
    os.Remove(f)
  }
}

func toolPath(a map[string]any) string {
  p, _ := a["filePath"].(string)
  if p == "" {
    p, _ = a["path"].(string)
  }
  return filterText(p)
}

func AL(ctx context.Context, cfg *Cfg, msgs []Message) ([]Message, Usage, error) {
  done := false
  var turnUsage Usage
  var tmps []string
  defer func() { cleanupTemps(tmps) }()
  for i := 0; i < cfg.MaxALIterations && !done; i++ {
    if err := ctx.Err(); err != nil {
      return msgs, turnUsage, err
    }
    m, u, err := llm(ctx, cfg, msgs, TOOLS)
    if err != nil {
      if errors.Is(err, context.Canceled) || ctx.Err() != nil {
        return msgs, turnUsage, err
      }
      if isInvalidAssistantErr(err) {
        stripped := false
        for j := len(msgs) - 1; j >= 0; j-- {
          if msgs[j].Role == "assistant" {
            fmt.Println(c("[stripped malformed assistant message]", 33))
            msgs = append(msgs[:j], msgs[j+1:]...)
            stripped = true
            break
          }
        }
        if stripped {
          continue
        }
      }
      return msgs, turnUsage, err
    }
    turnUsage.PromptTokens = u.PromptTokens
    turnUsage.CompletionTokens += u.CompletionTokens
    turnUsage.TotalTokens += u.TotalTokens
    // The last call sends the full conversation, so its context estimate is the
    // authoritative one for the turn's context window statistics.
    turnUsage.ContextTokens = u.ContextTokens
    if u.Cached() > 0 {
      turnUsage.CachedTokens = u.Cached()
    }
    if u.Model != "" {
      turnUsage.Model = u.Model
    }
    sanitizeToolCalls(m.ToolCalls)
    msgs = append(msgs, m)
    if !cfg.Stream {
      if m.ReasoningContent != "" {
        fmt.Println(c("--- reasoning start ---", 36) + "\n" + c(m.ReasoningContent, 2) + "\n" + c("--- reasoning end ---", 36))
      }
      if m.Content != nil {
        fmt.Println(renderMD(*m.Content))
      }
    }
    if len(m.ToolCalls) == 0 {
      // If the model returned only a reasoning block with no non-reasoning
      // tokens or tool calls, nudge it to continue rather than ending the turn.
      if m.ReasoningContent != "" && (m.Content == nil || strings.TrimSpace(*m.Content) == "") {
        fmt.Println(c("[auto continue: response was reasoning-only]", 33))
        msgs = append(msgs, Message{Role: "user", Content: strp("continue")})
        continue
      }
      done = true
      break
    }
    for _, tc := range m.ToolCalls {
      if err := ctx.Err(); err != nil {
        return msgs, turnUsage, err
      }
      fn, astr := tc.Function.Name, filterText(tc.Function.Arguments)
      if !m.ToolCallsShown {
        fmt.Println(c(fmt.Sprintf("[tool call: %s(%s)]", fn, astr), 33))
      }
      res, sty := "", 2
      var a map[string]any
      if err := json.Unmarshal([]byte(astr), &a); err != nil || a == nil {
        res, sty = fmt.Sprintf("[tool error: invalid JSON args for %s: %v. Raw: %q]", fn, err, astr), 31
      } else {
        switch fn {
        case "bash", "shell_exec":
          cmd, _ := a["command"].(string)
          cmd = filterText(cmd)
          workdir, _ := a["workdir"].(string)
          workdir = filterText(workdir)
          to := cfg.ShellTimeout
          if n := toInt(a["timeout"], 0); n > 0 {
            if n > 1000 {
              to = n / 1000
            } else {
              to = n
            }
          }
          res = shellWithWorkdir(ctx, cmd, workdir, to)
          if err := ctx.Err(); err != nil {
            return msgs, turnUsage, err
          }
        case "read":
          res, sty = readFileOrDir(toolPath(a), toInt(a["offset"], 1), toInt(a["limit"], 2000))
        case "write", "write_file":
          path := toolPath(a)
          contentVal, hasContent := a["content"]
          var content string
          if hasContent && contentVal != nil {
            if s, ok := contentVal.(string); ok {
              content = s
            }
          }
          hasOffset := a["offset"] != nil
          offset := toInt(a["offset"], 0)
          if offset < 0 {
            offset = 0
          }
          hasDel := a["del_bytes"] != nil
          delBytes := toInt(a["del_bytes"], 0)
          if strings.TrimSpace(path) == "" {
            res, sty = fmt.Sprintf("[tool error: %s requires 'filePath' parameter]", fn), 31
          } else if !hasContent {
            res, sty = fmt.Sprintf("[tool error: %s requires 'content' parameter]", fn), 31
          } else if !hasOffset && !hasDel {
            p := strings.TrimSpace(path)
            if err := os.MkdirAll(filepath.Dir(p), 0755); err != nil {
              res, sty = fmt.Sprintf("[tool error: %s %s: %v]", fn, p, err), 31
            } else if err := os.WriteFile(p, []byte(content), 0644); err != nil {
              res, sty = fmt.Sprintf("[tool error: %s %s: %v]", fn, p, err), 31
            } else {
              res = fmt.Sprintf("Successfully wrote %d bytes to %s", len(content), p)
            }
          } else {
            out, err := writeFile(path, offset, delBytes, content)
            if err != nil {
              res, sty = fmt.Sprintf("[tool error: %s %s: %v]", fn, path, err), 31
            } else {
              res = out
            }
          }
        default:
          res, sty = "Unknown tool: "+fn, 31
        }
      }
      res = filterText(res)
      ctxRes := offloadToolResult(res, cfg.MaxToolRes, &tmps)
      fmt.Println(c("[tool result: "+fn+"]", 32) + "\n" + c(ctxRes, sty) + "\n")
      msgs = append(msgs, Message{Role: "tool", ToolCallID: tc.ID, Content: strp(ctxRes)})
    }
  }
  if !done {
    msgs = append(msgs, Message{Role: "assistant", Content: strp(fmt.Sprintf("[max AL iterations (%d) reached]", cfg.MaxALIterations))})
  }
  return msgs, turnUsage, nil
}

func homeDir() string {
  if h, err := os.UserHomeDir(); err == nil && h != "" {
    return h
  }
  return "."
}

func sdir() string {
  d := filepath.Join(homeDir(), ".bantam", "sessions")
  os.MkdirAll(d, 0755)
  return d
}

type Session struct {
  ID       string    `json:"id"`
  Created  string    `json:"created"`
  Summary  string    `json:"summary"`
  Messages []Message `json:"messages"`
}

func summary(msgs []Message) string {
  for _, m := range msgs {
    if m.Role == "user" && m.Content != nil && strings.TrimSpace(*m.Content) != "" {
      t := strings.Join(strings.Fields(*m.Content), " ")
      if len(t) > 80 {
        t = t[:80] + "..."
      }
      return t
    }
  }
  return "(empty session)"
}

func fileExists(p string) bool {
  _, err := os.Stat(p)
  return err == nil
}

func projectID() string {
  dir, err := os.Getwd()
  if err != nil {
    dir = "."
  }
  if abs, err := filepath.Abs(dir); err == nil {
    dir = abs
  }
  h := md5.Sum([]byte(dir))
  return hex.EncodeToString(h[:])
}

// genOpencodeID generates an OpenCode-style identifier with a 12-hex-character
// timestamp prefix (6 bytes, big endian) and a 14-character random Base62 tail.
// When descending is true (session IDs), the timestamp value is bitwise inverted (~$),
// ensuring session IDs and request IDs form bitwise inverse hex prefixes.
func ocRandomTail() string {
  buf := make([]byte, 14)
  if _, err := rand.Read(buf); err != nil {
    h := md5.Sum([]byte(fmt.Sprintf("%d-%d", time.Now().UnixNano(), os.Getpid())))
    for i := range buf {
      buf[i] = h[i%len(h)]
    }
  }
  var tail strings.Builder
  for _, b := range buf {
    tail.WriteByte(opencodeTailAlphabet[int(b)%len(opencodeTailAlphabet)])
  }
  return tail.String()
}

func genOpencodeID(prefix string, descending bool) string {
  now := time.Now().UnixMilli()
  ocMu.Lock()
  if now != ocLast {
    ocLast = now
    ocSeq = 0
  }
  ocSeq++
  seq := ocSeq
  ocMu.Unlock()

  val := uint64(now)*0x1000 + (seq & 0xfff)
  if descending {
    val = ^val
  }
  hexPart := fmt.Sprintf("%012x", val&0xffffffffffff)
  return prefix + hexPart + ocRandomTail()
}

func opencodeSessionID() string {
  return genOpencodeID("ses_", true)
}

// opencodeSessionIDFromRequest returns a session ID whose 12-hex timestamp prefix
// is the exact bitwise inverse of the given msg_ request ID.
func opencodeSessionIDFromRequest(msgID string) string {
  if strings.HasPrefix(msgID, "msg_") && len(msgID) >= 16 {
    if val, err := strconv.ParseUint(msgID[4:16], 16, 64); err == nil {
      return fmt.Sprintf("ses_%012x", (^val)&0xffffffffffff) + ocRandomTail()
    }
  }
  return genOpencodeID("ses_", true)
}

// isOpencodeEndpoint reports whether the endpoint belongs to OpenCode Zen and
// therefore expects the x-opencode-* request headers.
func isOpencodeEndpoint(endpoint string) bool {
  u, err := url.Parse(strings.TrimSpace(endpoint))
  if err != nil || u.Hostname() == "" {
    return strings.Contains(strings.ToLower(endpoint), "opencode.ai")
  }
  h := strings.ToLower(u.Hostname())
  return h == "opencode.ai" || strings.HasSuffix(h, ".opencode.ai")
}

// ocRequestID returns a fresh OpenCode-style message id (msg_ followed by 12
// hex characters and 14 Base62 characters) matching the ids sent in the
// x-opencode-request header.
func ocRequestID() string {
  return genOpencodeID("msg_", false)
}

// applyLLMHeaders sets request headers mimicking OpenCode for all endpoints:
// the x-opencode-* family, the full provider User-Agent, and Authorization.
// msgID is used for the x-opencode-request header, and x-opencode-session is its
// bitwise inverse.
func applyLLMHeaders(req *http.Request, cfg *Cfg, msgID string) {
  sid := opencodeSessionIDFromRequest(msgID)
  req.Header.Set("User-Agent", opencodeAgentVersion+" "+opencodeProviderUA)
  req.Header.Set("x-opencode-client", "cli")
  req.Header.Set("x-opencode-project", opencodeProjectID)
  req.Header.Set("x-opencode-session", sid)
  req.Header.Set("x-opencode-request", msgID)
  if cfg.APIKey != "" && cfg.APIKey != "-" {
    req.Header.Set("Authorization", "Bearer "+cfg.APIKey)
  }
}

func saveSession(msgs []Message, sid string) (string, string) {
  sid = strings.TrimSpace(sid)
  if sid == "" {
    sid = projectID()
  }
  d := sdir()
  path := filepath.Join(d, sid+".json")
  s := Session{sid, time.Now().Format("2006-01-02 15:04:05"), summary(msgs), msgs}
  b, err := json.MarshalIndent(s, "", "  ")
  if err != nil {
    fmt.Fprintf(os.Stderr, "saveSession: marshal error: %v\n", err)
    return sid, s.Summary
  }
  if err := os.WriteFile(path, b, 0644); err != nil {
    fmt.Fprintf(os.Stderr, "saveSession: write error: %v\n", err)
  }
  return sid, s.Summary
}

func sessions() []Session {
  out := []Session{}
  d := filepath.Join(homeDir(), ".bantam", "sessions")
  entries, err := os.ReadDir(d)
  if err != nil {
    return out
  }
  for _, e := range entries {
    if e.IsDir() || !strings.HasSuffix(e.Name(), ".json") {
      continue
    }
    b, err := os.ReadFile(filepath.Join(d, e.Name()))
    if err != nil {
      continue
    }
    var s Session
    if json.Unmarshal(b, &s) != nil {
      continue
    }
    if s.ID == "" {
      s.ID = strings.TrimSuffix(e.Name(), ".json")
    }
    out = append(out, s)
  }
  sort.Slice(out, func(i, j int) bool { return out[i].ID > out[j].ID })
  return out
}

func loadSession(sid string) ([]Message, error) {
  ss := sessions()
  for i := range ss {
    if ss[i].ID == sid {
      return ss[i].Messages, nil
    }
  }
  var pref []*Session
  for i := range ss {
    if strings.HasPrefix(ss[i].ID, sid) {
      pref = append(pref, &ss[i])
    }
  }
  if len(pref) == 1 {
    return pref[0].Messages, nil
  }
  if len(pref) > 1 {
    names := make([]string, len(pref))
    for i, s := range pref {
      names[i] = s.ID
    }
    return nil, fmt.Errorf("ambiguous prefix: %s", strings.Join(names, ", "))
  }
  return nil, fmt.Errorf("session not found: %s", sid)
}

// findProjectSession returns the saved session for the current working
// directory (if any), or nil when none exists yet.
func findProjectSession() *Session {
  pid := projectID()
  ss := sessions()
  for i := range ss {
    if ss[i].ID == pid {
      return &ss[i]
    }
  }
  return nil
}

func autosave(msgs []Message) {
  saveSession(msgs, projectID())
}

const compactionPrompt = "You are now acting as a compaction engine. Summarize the preceding conversation concisely but completely, preserving all important facts, decisions, code snippets, tool outputs, errors, and current task state so work can seamlessly continue. Output only the summary."

func compact(ctx context.Context, cfg *Cfg, msgs []Message) ([]Message, string, error) {
  if len(msgs) == 0 || msgs[0].Role != "system" {
    return msgs, "", errors.New("session has no system message")
  }
  if len(msgs) <= 1 {
    return msgs, "", errors.New("nothing to compact")
  }
  cMsgs := append(append([]Message{}, msgs...), Message{
    Role:    "user",
    Content: strp(compactionPrompt),
  })
  cc := *cfg
  cc.Stream = false
  m, _, err := llm(ctx, &cc, cMsgs, nil)
  if err != nil {
    return msgs, "", err
  }
  s := ""
  if m.Content != nil {
    s = *m.Content
  }
  if s == "" {
    s = m.ReasoningContent
  }
  s = strings.TrimSpace(s)
  if s == "" {
    return msgs, "", errors.New("LLM returned an empty summary")
  }
  newMsgs := []Message{
    {Role: "system", Content: msgs[0].Content},
    {Role: "user", Content: strp("Summary of the previous conversation:\n" + s + "\n\nPlease continue from here.")},
  }
  return newMsgs, s, nil
}

func summarize(ctx context.Context, cfg *Cfg, msgs []Message) (string, error) {
  _, s, err := compact(ctx, cfg, msgs)
  return s, err
}

func loadHistory() {
  histF = filepath.Join(homeDir(), ".bantam_history")
  b, err := os.ReadFile(histF)
  if err != nil {
    return
  }
  for _, ln := range strings.Split(string(b), "\n") {
    if ln = strings.TrimRight(ln, "\r"); ln != "" {
      hist = append(hist, ln)
    }
  }
}

func addHistory(s string) {
  if s == "" || (len(hist) > 0 && hist[len(hist)-1] == s) {
    return
  }
  hist = append(hist, s)
}

func saveHistory() {
  os.WriteFile(histF, []byte(strings.Join(hist, "\n")+"\n"), 0644)
}

func visibleLen(s string) int {
  n := 0
  for i := 0; i < len(s); {
    switch s[i] {
    case 0x1b:
      j := i + 1
      if j < len(s) && s[j] == '[' {
        j++
        for j < len(s) && !(s[j] >= 0x40 && s[j] <= 0x7e) {
          j++
        }
        if j < len(s) {
          j++
        }
        i = j
      } else {
        i++
      }
    case 0x01, 0x02:
      i++
    default:
      _, size := utf8.DecodeRuneInString(s[i:])
      n++
      i += size
    }
  }
  return n
}

type editor struct {
  prompt string
  buf    []rune
  pos    int
  hist   []string
  hpos   int
  draft  string
  crow   int
}

func textPos(promptLen, W int, s string, pos int) (row, col int) {
  row, col = 0, promptLen
  if W < 1 {
    W = 1
  }
  runes := []rune(s)
  n := len(runes)
  for i := 0; i < n; i++ {
    r := runes[i]
    if i == pos {
      return row, col
    }
    if r == '\n' {
      row++
      col = 0
      continue
    }
    // The rune at index i is displayed at (row, col). If it lands on the last
    // column, the NEXT rune wraps to the start of the following line (unless
    // this is the final rune, in which case the cursor stays at that column).
    if col >= W-1 {
      if i < n-1 {
        row++
        col = 0
      }
    } else {
      col++
    }
  }
  return row, col
}

func (e *editor) draw() {
  W := termWidth()
  s := string(e.buf)
  P := visibleLen(e.prompt)
  er, _ := textPos(P, W, s, len([]rune(s)))
  pr, pc := textPos(P, W, s, e.pos)
  if e.crow > 0 {
    fmt.Printf("\033[%dA", e.crow)
  }
  // In raw mode OPOST is off, so a bare \n only moves down without
  // returning to column 0. Emit \r\n so each logical line starts at
  // column 0, matching the column-reset assumption in textPos().
  fmt.Print("\r\033[J" + e.prompt + strings.ReplaceAll(s, "\n", "\r\n"))
  if up := er - pr; up > 0 {
    fmt.Printf("\033[%dA", up)
  }
  fmt.Print("\r")
  if pc > 0 {
    fmt.Printf("\033[%dC", pc)
  }
  e.crow = pr
}

func (e *editor) histNav(up bool) {
  if up {
    if len(e.hist) == 0 {
      return
    }
    if e.hpos < 0 {
      e.draft = string(e.buf)
      e.hpos = len(e.hist) - 1
    } else if e.hpos > 0 {
      e.hpos--
    }
    e.buf = []rune(e.hist[e.hpos])
  } else {
    if e.hpos < 0 {
      return
    }
    e.hpos++
    if e.hpos >= len(e.hist) {
      e.hpos = -1
      e.buf = []rune(e.draft)
    } else {
      e.buf = []rune(e.hist[e.hpos])
    }
  }
  e.pos = len(e.buf)
}

// wordBack moves the cursor back to the start of the current/previous word.
func (e *editor) wordBack() {
  for e.pos > 0 && unicode.IsSpace(e.buf[e.pos-1]) {
    e.pos--
  }
  for e.pos > 0 && !unicode.IsSpace(e.buf[e.pos-1]) {
    e.pos--
  }
}

// wordFwd moves the cursor forward to the end of the current/next word.
func (e *editor) wordFwd() {
  n := len(e.buf)
  for e.pos < n && unicode.IsSpace(e.buf[e.pos]) {
    e.pos++
  }
  for e.pos < n && !unicode.IsSpace(e.buf[e.pos]) {
    e.pos++
  }
}

// delWordBack deletes the word preceding the cursor (Emacs Ctrl+W).
func (e *editor) delWordBack() {
  if e.pos == 0 {
    return
  }
  start := e.pos
  for start > 0 && unicode.IsSpace(e.buf[start-1]) {
    start--
  }
  for start > 0 && !unicode.IsSpace(e.buf[start-1]) {
    start--
  }
  e.buf = append(e.buf[:start], e.buf[e.pos:]...)
  e.pos = start
}

func readPlain(prompt string) (string, bool) {
  fmt.Print(prompt)
  line, err := stdin.ReadString('\n')
  if err != nil && line == "" {
    return "", false
  }
  return strings.TrimRight(line, "\r\n"), true
}

func readLine(prompt string) (string, bool) {
  if !isTerminal(int(os.Stdin.Fd())) {
    return readPlain(prompt)
  }
  restore, err := makeRaw(int(os.Stdin.Fd()))
  if err != nil {
    return readPlain(prompt)
  }
  defer restore()
  e := &editor{prompt: prompt, hpos: -1, hist: hist}
  for {
    e.draw()
    rn, _, err := stdin.ReadRune()
    if err != nil {
      fmt.Print("\r\n")
      return "", false
    }
    switch rn {
    case '\r':
      if stdin.Buffered() > 0 {
        if b, _ := stdin.Peek(1); len(b) > 0 && b[0] == '\n' {
          stdin.ReadByte()
        }
      }
      W := termWidth()
      s := string(e.buf)
      P := visibleLen(e.prompt)
      er, _ := textPos(P, W, s, len([]rune(s)))
      pr, _ := textPos(P, W, s, e.pos)
      if down := er - pr; down > 0 {
        fmt.Printf("\033[%dB", down)
      }
      fmt.Print("\r\n")
      return string(e.buf), true
    case '\n':
      e.buf = append(e.buf, 0)
      copy(e.buf[e.pos+1:], e.buf[e.pos:])
      e.buf[e.pos] = '\n'
      e.pos++
    case 0x03:
      fmt.Print("^C\r\n")
      return "", true
    case 0x04:
      if len(e.buf) == 0 {
        fmt.Print("\r\n")
        return "", false
      }
      // Ctrl+D with non-empty buffer: delete character under cursor
      if e.pos < len(e.buf) {
        e.buf = append(e.buf[:e.pos], e.buf[e.pos+1:]...)
      }
    case 0x01:
      e.pos = 0 // Ctrl+A: beginning of line
    case 0x05:
      e.pos = len(e.buf) // Ctrl+E: end of line
    case 0x02:
      if e.pos > 0 {
        e.pos--
      } // Ctrl+B: backward char
    case 0x06:
      if e.pos < len(e.buf) {
        e.pos++
      } // Ctrl+F: forward char
    case 0x17:
      e.delWordBack() // Ctrl+W: delete previous word
    case 0x0b:
      e.buf = e.buf[:e.pos] // Ctrl+K: kill to end of line
    case 0x15:
      e.buf = e.buf[e.pos:] // Ctrl+U: kill to start of line
      e.pos = 0
    case 0x7f, 0x08:
      if e.pos > 0 {
        e.buf = append(e.buf[:e.pos-1], e.buf[e.pos:]...)
        e.pos--
      }
    case 0x1b:
      b1, err1 := stdin.ReadByte()
      if err1 != nil {
        continue
      }
      if b1 == '[' {
        // Read the full CSI sequence (terminated by a byte in 0x40-0x7e).
        var seq []byte
        for {
          b, err := stdin.ReadByte()
          if err != nil {
            break
          }
          seq = append(seq, b)
          if b >= 0x40 && b <= 0x7e {
            break
          }
        }
        if len(seq) == 0 {
          continue
        }
        last := seq[len(seq)-1]
        switch last {
        case 'A':
          e.histNav(true)
        case 'B':
          e.histNav(false)
        case 'C':
          if strings.Contains(string(seq), "5") {
            e.wordFwd() // Ctrl+Right
          } else if e.pos < len(e.buf) {
            e.pos++
          }
        case 'D':
          if strings.Contains(string(seq), "5") {
            e.wordBack() // Ctrl+Left
          } else if e.pos > 0 {
            e.pos--
          }
        case 'H':
          e.pos = 0 // Home (ESC[H)
        case 'F':
          e.pos = len(e.buf) // End (ESC[F)
        case '~':
          // Home/End on some terminals: ESC[1~ / ESC[4~
          if len(seq) >= 1 && seq[0] == '1' {
            e.pos = 0
          } else if len(seq) >= 1 && seq[0] == '4' {
            e.pos = len(e.buf)
          }
        }
      } else if b1 == 'O' {
        // xterm application cursor keys: ESC O H/F (Home/End), A-D (arrows)
        b2, err2 := stdin.ReadByte()
        if err2 != nil {
          continue
        }
        switch b2 {
        case 'H':
          e.pos = 0
        case 'F':
          e.pos = len(e.buf)
        case 'A':
          e.histNav(true)
        case 'B':
          e.histNav(false)
        case 'C':
          if e.pos < len(e.buf) {
            e.pos++
          }
        case 'D':
          if e.pos > 0 {
            e.pos--
          }
        }
      }
    default:
      if rn >= 32 {
        e.buf = append(e.buf, 0)
        copy(e.buf[e.pos+1:], e.buf[e.pos:])
        e.buf[e.pos] = rn
        e.pos++
      }
    }
  }
}

// skillPrompt resolves and composes the prompt for the /skill command: it reads
// <dir>/<name>/SKILL.md (or an absolute path when no skills directory is set) and
// prefixes its contents to the optional user prompt.
func skillPrompt(u string, cfg *Cfg) (string, error) {
  rest := strings.TrimSpace(strings.TrimPrefix(u, "/skill"))
  if rest == "" {
    return "", fmt.Errorf("usage: /skill <skill_name|absolute_path> [prompt]")
  }
  name, prompt, _ := strings.Cut(rest, " ")
  prompt = strings.TrimSpace(prompt)
  sd := skillsDir(cfg)
  var path string
  if sd != "" {
    path = filepath.Join(sd, name, "SKILL.md")
  } else if strings.HasSuffix(name, "SKILL.md") {
    path = name // absolute path to the SKILL.md file itself
  } else {
    path = filepath.Join(name, "SKILL.md") // absolute path to the skill directory
  }
  data, err := os.ReadFile(path)
  if err != nil {
    return "", fmt.Errorf("cannot read skill %q: %v", name, err)
  }
  content := strings.TrimRight(string(data), "\r\n")
  if prompt != "" {
    return content + "\n\n" + prompt, nil
  }
  return content, nil
}

// listSkills prints every skill found under the configured skills directory, or a
// clear notice when none is configured / none are present.
func listSkills(cfg *Cfg) {
  sd := skillsDir(cfg)
  if sd == "" {
    fmt.Println(c("No skills directory configured (set BANTAM_SKILLS_DIR or bantam_skills_dir).", 33))
    return
  }
  entries, err := os.ReadDir(sd)
  if err != nil {
    fmt.Println(c("[skill error: cannot read skills dir: "+err.Error()+"]", 31))
    return
  }
  var names []string
  for _, e := range entries {
    if e.IsDir() {
      if _, err := os.Stat(filepath.Join(sd, e.Name(), "SKILL.md")); err == nil {
        names = append(names, e.Name())
      }
    }
  }
  if len(names) == 0 {
    fmt.Println(c("No skills found in "+sd, 33))
    return
  }
  fmt.Println(c("Available skills in "+sd+":", 1, 36))
  for _, n := range names {
    fmt.Println(c("  "+n, 32))
  }
}

func runDirectShell(cmd string, timeout int) {
  cmd = filterText(strings.TrimSpace(cmd))
  if cmd == "" {
    return
  }
  astr, _ := json.Marshal(map[string]string{"command": cmd})
  fmt.Println(c(fmt.Sprintf("[tool call: bash(%s)]", string(astr)), 33))
  sigCtx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
  res := shell(sigCtx, cmd, timeout)
  cancel()
  fmt.Println(c("[tool result: bash]", 32) + "\n" + c(res, 2))
}

func doCompact(cfg *Cfg, msgs []Message) []Message {
  if len(msgs) <= 1 {
    fmt.Println(c("Nothing to compact yet.", 33))
    return msgs
  }
  fmt.Println(c("[compacting conversation...]", 33))
  sigCtx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
  nm, sm, err := compact(sigCtx, cfg, msgs)
  interrupted := sigCtx.Err() != nil
  cancel()
  if err != nil {
    if interrupted || errors.Is(err, context.Canceled) {
      fmt.Println(c("\n[interrupted]", 33))
    } else {
      fmt.Println(c("[compact failed: "+err.Error()+"]", 31))
    }
    return msgs
  }
  msgs = nm
  autosave(msgs)
  fmt.Println(c(fmt.Sprintf("[compacted to %d messages]", len(msgs)), 32))
  fmt.Println(c("--- summary ---", 33) + "\n" + c(sm, 2))
  return msgs
}

// buildSystemPrompt renders the built-in system prompt for cfg: it expands the
// $TMPDIR/bantam placeholder to a concrete temporary directory, substitutes the
// configured max_tool_res value, and appends the optional extra-tools and
// skills hints.
func runTurn(cfg *Cfg, msgs []Message) ([]Message, Usage, error) {
  sigCtx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
  defer cancel()
  resMsgs, usg, err := AL(sigCtx, cfg, msgs)
  if lastRole(resMsgs) == "tool" {
    resMsgs = append(resMsgs, Message{Role: "user", Content: strp("continue")})
    fmt.Println(c("[auto continue: last message was a tool result]", 33))
    resMsgs, usg, err = AL(sigCtx, cfg, resMsgs)
  }
  if err != nil {
    if sigCtx.Err() != nil || errors.Is(err, context.Canceled) {
      fmt.Println(c("\n[interrupted]", 33))
    } else {
      fmt.Println(c("[error: "+err.Error()+"]", 31))
    }
  }
  return resMsgs, usg, err
}

// buildSystemPrompt renders the built-in system prompt for cfg: it expands the
// $TMPDIR/bantam placeholder to a concrete temporary directory, substitutes the
// configured max_tool_res value, and appends the optional extra-tools and
// skills hints.
func buildSystemPrompt(cfg *Cfg) string {
  sp := strings.ReplaceAll(defaultSystemPrompt, "$TMPDIR/bantam", bantamTmpDir())
  sp = strings.ReplaceAll(sp, "$MAX_TOOL_RES", strconv.Itoa(cfg.MaxToolRes))
  if td := toolsDir(cfg); td != "" {
    sp += "\n\nExtra shell tools can be found at " + td
  }
  if sd := skillsDir(cfg); sd != "" {
    sp += "\n\nSkills may be discovered and invoked from " + sd
  }
  return sp
}

func main() {
  cfg := getCfg(configPath())
  cfg.ContextWindow = fetchContextWindow(&cfg)
  sp := buildSystemPrompt(&cfg)
  COL = col(cfg)
  stdin = bufio.NewReader(os.Stdin)
  msgs := []Message{{Role: "system", Content: strp(sp)}}
  if len(os.Args) > 1 && os.Args[1] != "" {
    p := os.Args[1]
    data, err := os.ReadFile(p)
    if err != nil {
      fmt.Println(c("Error: file '"+p+"' not found.", 31))
      os.Exit(1)
    }
    u := strings.TrimSpace(string(data))
    if strings.HasPrefix(u, "!") {
      runDirectShell(strings.TrimPrefix(u, "!"), cfg.ShellTimeout)
      return
    }
    msgs = append(msgs, Message{Role: "user", Content: strp(u)})
    var usg Usage
    msgs, usg, err = runTurn(&cfg, msgs)
    if err != nil {
      os.Exit(1)
    }
    fmt.Println(c(formatUsage(usg, cfg.ContextWindow), 2))
    autosave(msgs)
    return
  }
  loadHistory()
  // Interactive startup: if a session already exists for this directory, offer
  // to autoload it so the user can seamlessly resume prior work.
  if sess := findProjectSession(); sess != nil && len(sess.Messages) > 1 {
    fmt.Println(c("[session found for this directory]", 33) + "  " + c(sess.ID, 32))
    fmt.Println("  " + c(sess.Summary, 2))
    fmt.Println(c(fmt.Sprintf("  created %s  [%d messages]", sess.Created, len(sess.Messages)), 2))
    fmt.Print(c("Resume this session? [Y/n]: ", 33))
    if ans, ok := readPlain(""); ok {
      ans = strings.TrimSpace(strings.ToLower(ans))
      if ans == "" || ans == "y" || ans == "yes" {
        msgs = sess.Messages
        autosave(msgs)
        fmt.Println(c("[session resumed: "+sess.ID+"]", 32) + "  " + c(summary(msgs), 2))
      }
    }
  }
  re := cfg.Raw["reasoning_effort"]
  if re == "" {
    re = "high"
  }
  fmt.Println(c("Bantam Agent ready", 1, 32) + c("  (Ctrl+J = new line)", 2))
  fmt.Println(c(fmt.Sprintf("endpoint: %s  model: %s  temp: %v  reasoning: %s  context: %d", cfg.Endpoint, cfg.Model, cfg.Temperature, re, cfg.ContextWindow), 2))
  for {
    u, ok := readLine(c("> ", 1, 36))
    if !ok {
      fmt.Println()
      break
    }
    u = strings.TrimSpace(u)
    if u == "" {
      continue
    }
    addHistory(u)
    // Command aliases: /model -> /cfg model, /endpoint -> /cfg endpoint.
    // (Note: /models is a distinct command and is intentionally not matched.)
    for _, cmd := range []string{"model", "endpoint"} {
      if u == "/"+cmd {
        u = "/cfg " + cmd
      } else if strings.HasPrefix(u, "/"+cmd+" ") {
        u = "/cfg " + cmd + " " + strings.TrimSpace(u[len(cmd)+2:])
      }
    }
    switch {
    case u == "/quit":
      goto done
    case u == "/clear":
      msgs = []Message{{Role: "system", Content: strp(sp)}}
      autosave(msgs)
      continue
    case u == "/save" || strings.HasPrefix(u, "/save "):
      name := strings.TrimSpace(strings.TrimPrefix(u, "/save"))
      sid, sm := saveSession(msgs, name)
      fmt.Println(c("[session saved: "+sid+"]", 32) + "  " + c(sm, 2))
      continue
    case u == "/continue" || u == "/cont":
      pid := projectID()
      lm, err := loadSession(pid)
      if err != nil {
        fmt.Println(c("No session found for current project: "+err.Error(), 31))
        continue
      }
      msgs = lm
      autosave(msgs)
      fmt.Println(c("[session continued: "+pid+"]", 32) + "  " + c(summary(msgs), 2))
      continue
    case u == "/list":
      ss := sessions()
      if len(ss) == 0 {
        fmt.Println(c("No sessions saved yet.", 33))
        continue
      }
      pid := projectID()
      for _, s := range ss {
        mk := ""
        if s.ID == pid {
          mk = c("  (current project)", 33)
        }
        fmt.Println(c(s.ID, 32) + mk + c(fmt.Sprintf("  %s  [%d msgs]", s.Created, len(s.Messages)), 2))
        fmt.Println("  " + c(s.Summary, 2))
      }
      continue
    case strings.HasPrefix(u, "/load"):
      parts := strings.Fields(u)
      if len(parts) < 2 {
        fmt.Println(c("Usage: /load <session-id>", 31))
        continue
      }
      lm, err := loadSession(parts[1])
      if err != nil {
        fmt.Println(c("Session not found: "+err.Error(), 31))
        continue
      }
      msgs = lm
      autosave(msgs)
      fmt.Println(c("[session loaded: "+parts[1]+"]", 32) + "  " + c(summary(msgs), 2))
      continue
    case u == "/compact":
      msgs = doCompact(&cfg, msgs)
      continue
    case strings.HasPrefix(u, "/cfg"):
      parts := strings.SplitN(u, " ", 3)
      if len(parts) == 2 {
        k := strings.TrimSpace(parts[1])
        if v, ok := cfg.Raw[k]; ok {
          fmt.Println(c(k+"="+v, 32))
        } else {
          fmt.Println(c(k+" not set", 31))
        }
      } else if len(parts) >= 3 {
        k, v := strings.TrimSpace(parts[1]), strings.TrimSpace(parts[2])
        if err := setCfg(".bantam.cfg", k, v); err != nil {
          fmt.Println(c("[cfg error: "+err.Error()+"]", 31))
          continue
        }
        cfg = getCfg(configPath())
        if k == "model" || k == "endpoint" || k == "api_key" {
          cfg.ContextWindow = fetchContextWindow(&cfg)
        }
        COL = col(cfg)
        fmt.Println(c(fmt.Sprintf("[config updated: %s=%s]", k, v), 32))
      } else {
        fmt.Println(c("Usage: /cfg <param> [val]", 31))
      }
      continue
    case strings.HasPrefix(u, "/skill"):
      if strings.TrimSpace(strings.TrimPrefix(u, "/skill")) == "" {
        listSkills(&cfg) // bare /skill lists available skills
        continue
      }
      composed, err := skillPrompt(u, &cfg)
      if err != nil {
        fmt.Println(c("[skill error: "+err.Error()+"]", 31))
        continue
      }
      u = composed // fall through to a normal LLM turn with the composed prompt
    case u == "/models":
      ml, err := listModels(&cfg)
      if err != nil {
        fmt.Println(c("[error querying /models: "+err.Error()+"]", 31))
        continue
      }
      fmt.Println(c("Supported models at "+cfg.Endpoint+":", 1, 36))
      fmt.Print(renderMD(ml))
      continue
    case strings.HasPrefix(u, "!"):
      runDirectShell(strings.TrimPrefix(u, "!"), cfg.ShellTimeout)
      continue
    case u == "/help":
      fmt.Println(c("Bantam commands:", 1, 36))
      for _, kv := range [][2]string{
        {"/quit", "exit"},
        {"/clear", "reset to system prompt"},
        {"/save [name]", "save session (default: project MD5)"},
        {"/continue", "continue project session (alias: /cont)"},
        {"/list", "list sessions"},
        {"/load <id>", "load session"},
        {"/compact", "compact context"},
        {"/cfg <k> [v]", "get/set config"},
        {"/model [m]", "alias for /cfg model"},
        {"/endpoint [e]", "alias for /cfg endpoint"},
        {"!<cmd>", "run shell command directly"},
        {"/models", "list models at endpoint"},
        {"/skill <n> [p]", "load SKILL.md and run as prompt"},
        {"/help", "show help"},
      } {
        fmt.Println(c(fmt.Sprintf("  %-18s", kv[0]), 1, 32) + kv[1])
      }
      continue
    }
    turnMsgs := append(append([]Message{}, msgs...), Message{Role: "user", Content: strp(u)})
    resMsgs, usg, err := runTurn(&cfg, turnMsgs)
    if err != nil {
      continue
    }
    msgs = resMsgs
    autosave(msgs)
    fmt.Println(c(formatUsage(usg, cfg.ContextWindow), 2))
    pct := contextPct(usg, cfg.ContextWindow)
    if pct >= 60.0 && len(msgs) > 1 {
      fmt.Print(c(fmt.Sprintf("Context usage is at %.1f%% (%d / %d tokens). Compact conversation? [Y/n]: ", pct, ctxTokens(usg), cfg.ContextWindow), 33))
      if ans, ok := readPlain(""); ok {
        ans = strings.TrimSpace(strings.ToLower(ans))
        if ans == "" || ans == "y" || ans == "yes" {
          msgs = doCompact(&cfg, msgs)
        }
      }
    }
  }
done:
  autosave(msgs)
  saveHistory()
}