/* main.cpp — entry point, agentic loop, REPL, command dispatch. */
#include "bantam.hpp"
#include <array>
#include <cctype>
#include <cerrno>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <curl/curl.h>
#include <dirent.h>
#include <span>
#include <sys/stat.h>
#include <unistd.h>
#include <vector>

/* ----------------------------- usage / pct ---------------------------- */
static int ctx_tokens(Usage &u) {
  if (u.context_tokens > u.prompt_tokens) return u.context_tokens;
  return u.prompt_tokens;
}
static std::string format_usage(Usage &u, int cw) {
  int base = ctx_tokens(u);
  if (cw <= 0) cw = 262144;
  double pct = (double)base * 100.0 / (double)cw;
  std::string s;
  if (!u.model.empty()) str_appendf(s, "[%s: ", u.model.c_str());
  else s += "[";
  if (u.cached_tokens > 0) {
    int uncached = u.prompt_tokens - u.cached_tokens;
    if (uncached < 0) uncached = 0;
    str_appendf(s, "%d prompt (%d cached, %d uncached) + %d completion | context: %d/%d (%.1f%%)]",
                u.prompt_tokens, u.cached_tokens, uncached, u.completion_tokens, base, cw, pct);
  } else {
    str_appendf(s, "%d prompt + %d completion | context: %d/%d (%.1f%%)]",
                u.prompt_tokens, u.completion_tokens, base, cw, pct);
  }
  return s;
}
static double context_pct(Usage &u, int cw) {
  if (cw <= 0) cw = 262144;
  return (double)ctx_tokens(u) * 100.0 / (double)cw;
}

/* ----------------------------- invalid-assistant detection ------------- */
static bool is_invalid_assistant_err(const char *err) {
  if (!err) return false;
  std::string low = err;
  for (char &c : low) c = (char)std::tolower((unsigned char)c);
  return low.find("invalid assistant message") != std::string::npos
      || low.find("content or tool_calls must be set") != std::string::npos
      || low.find("tool_calls must be set") != std::string::npos
      || low.find("content must be set") != std::string::npos;
}

/* ----------------------------- sanitize args -------------------------- */
static std::string sanitize_arguments(std::string_view args) {
  std::string f = filter_text(args);
  Json o;
  if (Json::parse(f, o) && o.is_object()) return f;
  Json w = Json::object();
  w["invalid_raw"] = f;
  return w.dump();
}

/* ----------------------------- system prompt -------------------------- */
static const char *default_system_prompt =
"You are Bantam, a tiny, powerful AI agent. Solve the user's task using three tools:\n"
"- bash: run a bash command; returns its output and exit code.\n"
"- read: read a file or directory from the local filesystem; returns numbered lines or directory entries.\n"
"- write: write content to a file; if lineOffset/byteOffset and delLines/delBytes are all omitted it overwrites the entire file, otherwise it writes at the given line or byte offset (optionally deleting lines or bytes first); line-based edits are preferred; returns status.\n\n"
"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.\n"
"Use the target system's filesystem deliberately:\n"
"- 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.\n"
"- Create permanent artifacts in the current working directory unless the user explicitly instructs otherwise.\n"
"- 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.\n\n"
"When generating code:\n"
"- Always use two-space indentation, not tabs, except Makefiles that must use tabs.\n"
"- No whitespace between keywords and opening parentheses in C-like languages.\n"
"- Write optimally and with as few third-party dependencies as possible.\n"
"- Always test.\n"
"- No emojis in code or documentation.\n"
"- Respect AGENTS.md contents in the project.";

static std::string build_system_prompt(Cfg &cfg) {
  std::string tmp = bantam_tmp_dir();
  std::string sp = default_system_prompt;
  size_t found = 0;
  while ((found = sp.find("$TMPDIR/bantam", found)) != std::string::npos) {
    sp.replace(found, std::strlen("$TMPDIR/bantam"), tmp);
    found += tmp.size();
  }
  char mtr[32]; std::snprintf(mtr, sizeof mtr, "%d", cfg.max_tool_res);
  auto fm = sp.find("$MAX_TOOL_RES");
  if (fm != std::string::npos) sp.replace(fm, std::strlen("$MAX_TOOL_RES"), mtr);
  std::string out = sp;
  std::string td = tools_dir(cfg);
  if (!td.empty()) { out += "\n\nExtra shell tools can be found at "; out += td; }
  std::string sd = skills_dir(cfg);
  if (!sd.empty()) { out += "\n\nSkills may be discovered and invoked from "; out += sd; }
  return out;
}

/* ----------------------------- json arg helpers ----------------------- */
static std::string get_str(const Json &j, const char *k) {
  return j[k].str();
}
static int get_int(const Json &j, const char *k, int def = 0) {
  return j[k].as_int(def);
}
static std::string tool_path_arg(const Json &a) {
  std::string v = get_str(a, "filePath");
  if (v.empty()) v = get_str(a, "path");
  return v;
}
static bool trim_is_empty(std::string_view s) {
  size_t i = 0;
  while (i < s.size() && (s[i] == ' ' || s[i] == '\n' || s[i] == '\r' || s[i] == '\t')) i++;
  return i == s.size();
}

/* ----------------------------- AL loop -------------------------------- */
static int AL(Cfg &cfg, Messages &msgs, Usage &out, volatile int *interrupted, std::string *err) {
  int done = 0;
  std::vector<std::string> tmps;
  int rc = 0;
  for (int i = 0; i < cfg.max_al_iterations && !done; i++) {
    if (*interrupted) { rc = -1; break; }
    Message m; Usage u;
    std::string lerr;
    int lrc = llm(cfg, msgs, true, m, u, lerr, interrupted);
    if (lrc != 0) {
      if (*interrupted) { rc = -1; break; }
      if (is_invalid_assistant_err(lerr.c_str())) {
        int stripped = 0;
        for (int j = (int)msgs.items.size() - 1; j >= 0; j--) {
          if (msgs.items[j].role == "assistant") {
            cprint("[stripped malformed assistant message]\n", std::array{33});
            msgs.items.erase(msgs.items.begin() + j);
            stripped = 1;
            break;
          }
        }
        if (stripped) continue;
      }
      if (err) *err = std::move(lerr);
      rc = -1; break;
    }
    out.prompt_tokens = u.prompt_tokens;
    out.completion_tokens += u.completion_tokens;
    out.total_tokens += u.total_tokens;
    out.context_tokens = u.context_tokens;
    if (u.cached_tokens > 0) out.cached_tokens = u.cached_tokens;
    if (!u.model.empty()) out.model = u.model;
    for (auto &tc : m.calls) {
      tc.arguments = sanitize_arguments(tc.arguments);
    }
    msgs.items.push_back(m);
    if (!cfg.stream) {
      if (!m.reasoning.empty()) {
        cprint("--- reasoning start ---\n", std::array{36});
        cprint(m.reasoning, std::array{2});
        cprint("\n--- reasoning end ---\n", std::array{36});
      }
      if (!m.content.empty()) { render_md_print(m.content); printf("\n"); }
    }
    if (m.calls.empty()) {
      if (!m.reasoning.empty() && trim_is_empty(m.content)) {
        cprint("[auto continue: response was reasoning-only]\n", std::array{33});
        Message cont; cont.role = "user"; cont.content = "continue";
        msgs.items.push_back(cont);
        continue;
      }
      done = 1; break;
    }
    for (size_t tci = 0; tci < m.calls.size(); tci++) {
      if (*interrupted) { rc = -1; break; }
      ToolCall &tc = m.calls[tci];
      const std::string &astr = tc.arguments; /* already filtered by sanitize_arguments */
      if (!m.calls_shown) {
        cprint(sfmt("[tool call: %s(%s)]", tc.name.c_str(), astr.c_str()), std::array{33});
        printf("\n");
      }
      std::string res; int sty = 2;
      bool res_already_filtered = false;
      Json a_mut;
      if (!Json::parse(astr, a_mut) || !a_mut.is_object()) {
        res = sfmt("[tool error: invalid JSON args for %s: parse error. Raw: %s]", tc.name.c_str(), astr.c_str());
        sty = 31;
      } else {
        const Json &a = a_mut;
        std::string fn = tc.name;
        if (fn == "bash" || fn == "shell_exec") {
          std::string cmd = get_str(a, "command");
          std::string workdir = get_str(a, "workdir");
          std::string fwd = filter_text(workdir);
          int to = cfg.shell_timeout;
          if (a.contains("timeout")) { int n = get_int(a, "timeout"); if (n > 0) to = (n > 1000) ? n / 1000 : n; }
          res = shell_with_workdir(cmd, fwd, to, interrupted);
          res_already_filtered = true;
        } else if (fn == "read") {
          std::string p = tool_path_arg(a);
          std::string fp = filter_text(p);
          int off = get_int(a, "offset", 1); if (off < 1) off = 1;
          int lim = get_int(a, "limit", 2000); if (lim <= 0) lim = 2000;
          res = read_file_or_dir(fp, off, lim, &sty);
        } else if (fn == "write" || fn == "write_file") {
          std::string p = tool_path_arg(a);
          std::string fp = filter_text(p);
          std::string cv = get_str(a, "content");
          bool has_content = a.contains("content") && a["content"].is_string();
          bool has_line = a.contains("lineOffset") && !a["lineOffset"].is_null();
          bool has_byte = a.contains("byteOffset") && !a["byteOffset"].is_null();
          bool has_del_lines = a.contains("delLines") && !a["delLines"].is_null();
          bool has_del_bytes = a.contains("delBytes") && !a["delBytes"].is_null();
          long line_off = has_line ? (long)get_int(a, "lineOffset") : -1L;
          long byte_off = has_byte ? (long)get_int(a, "byteOffset") : -1L;
          long del_lines = has_del_lines ? (long)get_int(a, "delLines") : -1L;
          long del_bytes = has_del_bytes ? (long)get_int(a, "delBytes") : -1L;
          if (line_off < 1) line_off = -1L;
          if (byte_off < 0) byte_off = -1L;
          if (del_lines < 0) del_lines = -1L;
          if (del_bytes < 0) del_bytes = -1L;
          if (fp.empty()) { res = "[tool error: write requires 'filePath' parameter]"; sty = 31; }
          else if (!has_content) { res = "[tool error: write requires 'content' parameter]"; sty = 31; }
          else if (!has_line && !has_byte && !has_del_lines && !has_del_bytes) {
            /* No offset/deletion parameters: overwrite the whole file. */
            std::string c = filter_text(cv);
            /* Ensure the written file ends with a single trailing newline. */
            if (!c.empty() && c.back() != '\n') c.push_back('\n');
            auto sl = fp.find_last_of('/');
            if (sl != std::string::npos) mkdir_p(std::string_view(fp).substr(0, sl));
            else mkdir_p(".");
            if (!write_file_str(fp, c)) { res = sfmt("[tool error: write %s: %s]", fp.c_str(), strerror(errno)); sty = 31; }
            else { res = sfmt("Successfully wrote %zu bytes to %s", c.size(), fp.c_str()); }
          } else {
            int werr = 0; std::string c = filter_text(cv);
            /* Line-based edits keep the text-file trailing-newline convention;
             * byte-based edits are exact byte operations and must not have a
             * newline injected. */
            if (!(has_byte || has_del_bytes) && !c.empty() && c.back() != '\n') c.push_back('\n');
            res = write_file(fp, line_off, byte_off, del_lines, del_bytes, c, &werr);
            if (werr) sty = 31;
          }
        } else {
          res = sfmt("Unknown tool: %s", fn.c_str());
          sty = 31;
        }
      }
      if (!res_already_filtered) res = filter_text(res);
      res = offload_tool_result(res, cfg.max_tool_res, tmps);
      {
        std::string hdr = cstr("[tool result: ", std::array{32});
        std::string fn2 = cstr(tc.name, std::array{32});
        printf("%s%s]\n", hdr.c_str(), fn2.c_str());
        cprint(res, std::array{sty});
        printf("\n\n");
      }
      Message tm; tm.role = "tool"; tm.tool_call_id = tc.id; tm.content = std::move(res);
      msgs.items.push_back(std::move(tm));
      if (*interrupted) { rc = -1; break; }
    }
    if (rc != 0) break;
  }
  if (!done && rc == 0) {
    Message maxm; maxm.role = "assistant";
    maxm.content = sfmt("[max AL iterations (%d) reached]", cfg.max_al_iterations);
    msgs.items.push_back(maxm);
  }
  cleanup_temps(tmps);
  return rc;
}

/* ----------------------------- run_turn ------------------------------- */
static int run_turn(Cfg &cfg, Messages &msgs, Usage &usage, std::string *err, volatile int *interrupted) {
  *interrupted = 0;
  usage = Usage{};
  int rc = AL(cfg, msgs, usage, interrupted, err);
  if (rc != 0) {
    if (*interrupted) { cprint("\n[interrupted]\n", std::array{33}); }
    else { cprint("\n[error: ", std::array{31}); cprint((!err || err->empty()) ? "error" : *err, std::array{31}); cprint("]\n", std::array{31}); }
  }
  return rc;
}

/* ----------------------------- direct shell --------------------------- */
static void run_direct_shell(std::string_view cmd, int timeout) {
  std::string fcmd = filter_text(cmd);
  cprint(sfmt("[tool call: bash({\"command\":\"%s\"})]", fcmd.c_str()), std::array{33});
  printf("\n");
  std::string res = shell_with_workdir(fcmd, "", timeout, &g_interrupted);
  printf("%s\n", cstr("[tool result: bash]", std::array{32}).c_str());
  printf("%s\n", cstr(res, std::array{2}).c_str());
}

/* ----------------------------- skills --------------------------------- */
static std::string skill_prompt(std::string_view u, Cfg &cfg) {
  std::string_view rest = u.substr(6);
  while (!rest.empty() && rest.front() == ' ') rest = rest.substr(1);
  if (rest.empty()) return "";
  std::string name(rest);
  std::string prompt;
  auto sp = name.find(' ');
  if (sp != std::string::npos) { prompt = name.substr(sp + 1); name = name.substr(0, sp); }
  std::string sd = skills_dir(cfg);
  std::string path;
  if (!sd.empty()) {
    path = sfmt("%s/%s/SKILL.md", sd.c_str(), name.c_str());
  } else if (name.find("SKILL.md") != std::string::npos) {
    path = name;
  } else {
    path = name + "/SKILL.md";
  }
  struct stat st;
  if (stat(path.c_str(), &st) != 0)
    return sfmt("[cannot read skill \"%s\": %s]", name.c_str(), strerror(errno));
  if (S_ISDIR(st.st_mode))
    return sfmt("[cannot read skill \"%s\": Is a directory]", name.c_str());
  std::string data;
  if (!read_file_str(path, data))
    return sfmt("[cannot read skill \"%s\": %s]", name.c_str(), strerror(errno));
  while (!data.empty() && (data.back() == '\n' || data.back() == '\r')) data.pop_back();
  std::string out = data;
  if (!prompt.empty()) { out += "\n\n"; out += prompt; }
  return out;
}
static void list_skills(Cfg &cfg) {
  std::string sd = skills_dir(cfg);
  if (sd.empty()) { cprint("No skills directory configured (set BANTAM_SKILLS_DIR or bantam_skills_dir).\n", std::array{33}); return; }
  DIR *d = opendir(sd.c_str());
  if (!d) { cprint(sfmt("[skill error: cannot read skills dir: %s]", strerror(errno)), std::array{31}); return; }
  std::string names; int cnt = 0; struct dirent *de;
  while ((de = readdir(d))) {
    if (std::strcmp(de->d_name, ".") == 0 || std::strcmp(de->d_name, "..") == 0) continue;
    std::string full = sfmt("%s/%s", sd.c_str(), de->d_name);
    struct stat st; if (stat(full.c_str(), &st) != 0 || !S_ISDIR(st.st_mode)) continue;
    std::string sk = sfmt("%s/%s/SKILL.md", sd.c_str(), de->d_name);
    if (access(sk.c_str(), F_OK) == 0) { str_appendf(names, "  %s\n", de->d_name); cnt++; }
  }
  closedir(d);
  if (cnt == 0) { cprint("No skills found in ", std::array{33}); cprint(sd, std::array{33}); cprint("\n", std::array{33}); return; }
  cprint("Available skills in ", std::array{1, 36}); cprint(sd, std::array{1, 36}); cprint(":\n", std::array{1, 36});
  fputs(names.c_str(), stdout);
}

/* ----------------------------- compact -------------------------------- */
static void do_compact(Cfg &cfg, Messages &msgs) {
  if (msgs.items.size() <= 1) { cprint("Nothing to compact yet.\n", std::array{33}); return; }
  cprint("[compacting conversation...]\n", std::array{33});
  std::string sum, e;
  auto nm = compact(cfg, msgs, &sum, &e, &g_interrupted);
  int interrupted = g_interrupted;
  if (!nm) {
    if (interrupted) cprint("\n[interrupted]\n", std::array{33});
    else { cprint(sfmt("\n[compact failed: %s]", e.empty() ? "compact failed" : e.c_str()), std::array{31}); printf("\n"); }
    return;
  }
  msgs = std::move(*nm);
  autosave(msgs);
  printf("%s%d messages]\n", cstr("[compacted to ", std::array{32}).c_str(), (int)msgs.items.size());
  printf("%s", cstr("--- summary ---\n", std::array{33}).c_str());
  printf("%s\n", cstr(sum, std::array{2}).c_str());
}

/* ----------------------------- main ----------------------------------- */
struct CurlGlobalGuard {
  CurlGlobalGuard() { curl_global_init(CURL_GLOBAL_DEFAULT); }
  ~CurlGlobalGuard() { http_cleanup(); curl_global_cleanup(); }
};

int main(int argc, char **argv) {
  CurlGlobalGuard curl_guard;
  setup_signal_handler();
  Cfg cfg = get_cfg(config_path());
  g_col = color_enabled(cfg);
  std::string sp = build_system_prompt(cfg);
  Messages msgs;
  {
    Message sys; sys.role = "system"; sys.content = sp;
    msgs.items.push_back(sys);
  }

  if (argc > 1 && argv[1] && argv[1][0] != '\0') {
    std::string p = argv[1];
    struct stat st;
    if (stat(p.c_str(), &st) != 0 || S_ISDIR(st.st_mode)) {
      cprint("Error: file '", std::array{31}); cprint(p, std::array{31}); cprint("' not found.\n", std::array{31});
      return 1;
    }
    std::string u;
    if (!read_file_str(p, u)) {
      cprint("Error: file '", std::array{31}); cprint(p, std::array{31}); cprint("' not found.\n", std::array{31});
      return 1;
    }
    size_t a = 0; while (a < u.size() && (u[a] == ' ' || u[a] == '\n' || u[a] == '\r' || u[a] == '\t')) a++;
    u = u.substr(a);
    if (!u.empty() && u[0] == '!') { run_direct_shell(u.substr(1), cfg.shell_timeout); return 0; }
    cfg.context_window = fetch_context_window(cfg);
    Message um; um.role = "user"; um.content = u;
    msgs.items.push_back(um);
    Usage usg; std::string err;
    run_turn(cfg, msgs, usg, &err, &g_interrupted);
    if (!err.empty()) return 1;
    cprint(format_usage(usg, cfg.context_window), std::array{2}); printf("\n");
    autosave(msgs);
    return 0;
  }

  load_history();
  auto sess = find_project_session();
  if (sess && sess->messages.items.size() > 1) {
    cprint("[session found for this directory]\n", std::array{33});
    cprint("  ", std::array{33}); cprint(sess->id, std::array{32}); printf("\n");
    cprint("  ", std::array{33}); cprint(sess->summary, std::array{2}); printf("\n");
    std::string created = sfmt("  created %s  [%d messages]\n", sess->created.c_str(), (int)sess->messages.items.size());
    cprint(created, std::array{2});
    printf("  Resume this session? [Y/n]: "); fflush(stdout);
    bool ok; std::string ans = read_plain("", ok);
    if (ok) {
      std::string a2 = ans;
      size_t ai = 0; while (ai < a2.size() && (a2[ai] == ' ' || a2[ai] == '\n' || a2[ai] == '\r' || a2[ai] == '\t')) ai++;
      a2 = a2.substr(ai);
      while (!a2.empty() && (a2.back() == '\n' || a2.back() == '\r' || a2.back() == ' ')) a2.pop_back();
      if (a2.empty() || a2[0] == 'y' || a2[0] == 'Y') {
        msgs = std::move(sess->messages);
        autosave(msgs);
        printf("%s%s]\n", cstr("[session resumed: ", std::array{32}).c_str(), sess->id.c_str());
      }
    }
  }

  const std::string *re_ptr = cfg_raw_get(cfg, "reasoning_effort");
  std::string re = (re_ptr && !re_ptr->empty()) ? *re_ptr : "high";
  {
    cprint("Bantam Agent ready", std::array{1, 32}); printf("  ");
    cprint(" (Enter submits; Ctrl+J or paste = new line)\n", std::array{2});
    fflush(stdout);
    cfg.context_window = fetch_context_window(cfg);
    std::string info = sfmt("endpoint: %s  model: %s  temp: %g  reasoning: %s  context: %d\n",
                             cfg.endpoint.c_str(), cfg.model.c_str(), cfg.temperature, re.c_str(), cfg.context_window);
    cprint(info, std::array{2});
  }

  for (;;) {
    g_interrupted = 0;
    bool ok;
    std::string u = read_line("> ", ok);
    if (!ok) { printf("\n"); break; }
    std::string ut = u;
    size_t a = 0; while (a < ut.size() && (ut[a] == ' ' || ut[a] == '\n' || ut[a] == '\r' || ut[a] == '\t')) a++;
    ut = ut.substr(a);
    if (ut.empty()) continue;
    add_history(u);
    /* command aliases */
    for (int ci = 0; ci < 2; ci++) {
      const char *cmd = (ci == 0) ? "model" : "endpoint";
      std::string slash = sfmt("/%s", cmd);
      if (u == slash) {
        u = sfmt("/cfg %s", cmd);
      } else if (u.size() > slash.size() && u.rfind(slash, 0) == 0 && u[slash.size()] == ' ') {
        u = sfmt("/cfg %s %s", cmd, u.c_str() + slash.size() + 1);
      }
    }
    if (u == "/quit") break;
    if (u == "/clear") {
      msgs = Messages{};
      Message s2; s2.role = "system"; s2.content = build_system_prompt(cfg);
      msgs.items.push_back(s2);
      autosave(msgs); continue;
    }
    if (u == "/save" || u.starts_with("/save ")) {
      std::string name = u.substr(5);
      size_t ni = 0; while (ni < name.size() && name[ni] == ' ') ni++;
      name = name.substr(ni);
      std::string sid, sm;
      save_session(msgs, name, &sid, &sm);
      printf("%s%s]\n", cstr("[session saved: ", std::array{32}).c_str(), sid.c_str());
      cprint("  ", std::array{32}); cprint(sm, std::array{2}); printf("\n");
      continue;
    }
    if (u == "/continue" || u == "/cont") {
      std::string pid = project_id();
      std::string lerr;
      auto lm = load_session(pid, &lerr);
      if (!lm) { cprint("No session found for current project: ", std::array{31}); cprint(lerr, std::array{31}); printf("\n"); continue; }
      msgs = std::move(*lm);
      autosave(msgs);
      printf("%s%s]\n", cstr("[session continued: ", std::array{32}).c_str(), pid.c_str());
      std::string sm = summary_of(msgs);
      cprint("  ", std::array{32}); cprint(sm, std::array{32}); printf("\n");
      continue;
    }
    if (u == "/list") {
      auto ss = sessions_load();
      if (ss.empty()) { cprint("No sessions saved yet.\n", std::array{33}); continue; }
      std::string pid = project_id();
      for (auto &s : ss) {
        printf("%s", cstr(s.id, std::array{32}).c_str());
        if (s.id == pid) cprint("  (current project)", std::array{33});
        std::string meta = sfmt("  %s  [%d msgs]\n", s.created.c_str(), (int)s.messages.items.size());
        cprint(meta, std::array{2});
        cprint("  ", std::array{32}); cprint(s.summary, std::array{2}); printf("\n");
      }
      continue;
    }
    if (u == "/load" || u.starts_with("/load ")) {
      std::vector<std::string> parts;
      {
        std::string_view sv(u);
        size_t i = 0;
        while (i < sv.size()) {
          while (i < sv.size() && sv[i] == ' ') i++;
          if (i >= sv.size()) break;
          size_t j = i;
          while (j < sv.size() && sv[j] != ' ') j++;
          parts.push_back(std::string(sv.substr(i, j - i)));
          i = j;
        }
      }
      if (parts.size() < 2) { cprint("Usage: /load <session-id>\n", std::array{31}); continue; }
      std::string lerr;
      auto lm = load_session(parts[1], &lerr);
      if (!lm) { cprint("Session not found: ", std::array{31}); cprint(lerr, std::array{31}); printf("\n"); continue; }
      msgs = std::move(*lm);
      autosave(msgs);
      printf("%s%s]\n", cstr("[session loaded: ", std::array{32}).c_str(), parts[1].c_str());
      std::string sm = summary_of(msgs);
      cprint("  ", std::array{32}); cprint(sm, std::array{32}); printf("\n");
      continue;
    }
    if (u == "/compact") { do_compact(cfg, msgs); continue; }
    if (u == "/cfg" || u.starts_with("/cfg ")) {
      /* tokens after "/cfg " */
      std::string rest = u.substr(4);
      while (!rest.empty() && rest.front() == ' ') rest = rest.substr(1);
      std::string sub, key, val;
      {
        size_t i = 0;
        while (i < rest.size() && rest[i] != ' ') i++;
        sub = rest.substr(0, i);
        size_t j = i;
        while (j < rest.size() && rest[j] == ' ') j++;
        size_t ks = j;
        while (j < rest.size() && rest[j] != ' ') j++;
        key = rest.substr(ks, j - ks);
        size_t vs = j;
        while (vs < rest.size() && rest[vs] == ' ') vs++;
        val = rest.substr(vs);
      }
      if (sub.empty()) { cprint("Usage: /cfg <key> [value]\n", std::array{31}); continue; }
      if (sub == "get") {
        if (key.empty()) { cprint("Usage: /cfg get <key>\n", std::array{31}); continue; }
        const std::string *v = cfg_raw_get(cfg, key);
        if (v && !v->empty()) printf("%s=%s\n", cstr(key, std::array{32}).c_str(), v->c_str());
        else printf("%s not set\n", cstr(key, std::array{31}).c_str());
      } else if (sub == "set") {
        if (key.empty()) { cprint("Usage: /cfg set <key> <value>\n", std::array{31}); continue; }
        if (set_cfg(config_path(), key, val) != 0) { cprint("[cfg error]\n", std::array{31}); continue; }
        cfg = get_cfg(config_path());
        if (key == "model" || key == "endpoint" || key == "api_key")
          cfg.context_window = fetch_context_window(cfg);
        g_col = color_enabled(cfg);
        printf("%s%s=%s]\n", cstr("[config updated: ", std::array{32}).c_str(), key.c_str(), val.c_str());
      } else if (key.empty()) {
        /* single token: treat as get */
        const std::string *v = cfg_raw_get(cfg, sub);
        if (v && !v->empty()) printf("%s=%s\n", cstr(sub, std::array{32}).c_str(), v->c_str());
        else printf("%s not set\n", cstr(sub, std::array{31}).c_str());
      } else {
        /* legacy "/cfg key value": treat as set */
        if (set_cfg(config_path(), sub, key) != 0) { cprint("[cfg error]\n", std::array{31}); continue; }
        cfg = get_cfg(config_path());
        if (sub == "model" || sub == "endpoint" || sub == "api_key")
          cfg.context_window = fetch_context_window(cfg);
        g_col = color_enabled(cfg);
        printf("%s%s=%s]\n", cstr("[config updated: ", std::array{32}).c_str(), sub.c_str(), key.c_str());
      }
      continue;
    }
    if (u == "/skill" || u.starts_with("/skill ")) {
      std::string rest = u.substr(6);
      while (!rest.empty() && rest.front() == ' ') rest = rest.substr(1);
      if (rest.empty()) { list_skills(cfg); continue; }
      std::string composed = skill_prompt(u, cfg);
      if (composed.empty()) { cprint("/skill usage: /skill <name> [prompt]\n", std::array{31}); continue; }
      if (composed.starts_with("[cannot read skill")) {
        cprint(composed, std::array{31}); printf("\n"); continue;
      }
      u = composed;
      /* fall through to a normal LLM turn */
    } else if (u == "/models") {
      int e2; std::string ml = list_models(cfg, &e2);
      if (e2 != 0) { cprint("[error querying /models: ", std::array{31}); cprint(ml, std::array{31}); printf("]\n"); continue; }
      cprint("Supported models at ", std::array{1, 36}); cprint(cfg.endpoint, std::array{1, 36}); cprint(":\n", std::array{1, 36});
      render_md_print(ml);
      continue;
    } else if (!u.empty() && u[0] == '!') {
      run_direct_shell(u.substr(1), cfg.shell_timeout); continue;
    } else if (u == "/help") {
      cprint("Bantam commands:\n", std::array{1, 36});
      const char *cmds[][2] = {
        {"/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"}};
      for (int i = 0; i < 14; i++) {
        std::string label = sfmt("  %-18s", cmds[i][0]);
        cprint(label, std::array{1, 32});
        cprint(cmds[i][1], std::array{1, 32});
        printf("\n");
      }
      continue;
    }
    /* normal LLM turn */
    {
      Message um; um.role = "user"; um.content = u;
      msgs.items.push_back(um);
      Usage usg; std::string err;
      run_turn(cfg, msgs, usg, &err, &g_interrupted);
      if (!err.empty()) continue;
      cprint(format_usage(usg, cfg.context_window), std::array{2}); printf("\n");
      double pct = context_pct(usg, cfg.context_window);
      if (pct >= 60.0 && msgs.items.size() > 1) {
        std::string q = sfmt("Context usage is at %.1f%% (%d / %d tokens). Compact conversation? [Y/n]: ",
                              pct, ctx_tokens(usg), cfg.context_window);
        cprint(q, std::array{33});
        bool ok2; std::string ans = read_plain("", ok2);
        if (ok2) {
          std::string a2 = ans;
          size_t ai = 0; while (ai < a2.size() && (a2[ai] == ' ' || a2[ai] == '\n' || a2[ai] == '\r' || a2[ai] == '\t')) ai++;
          a2 = a2.substr(ai);
          while (!a2.empty() && (a2.back() == '\n' || a2.back() == '\r' || a2.back() == ' ')) a2.pop_back();
          if (a2.empty() || a2[0] == 'y' || a2[0] == 'Y') do_compact(cfg, msgs);
        }
      }
      autosave(msgs);
    }
  }
  autosave(msgs);
  save_history();
  return 0;
}