lampson 0.1.0

package/chat.syn

@@ -0,0 +1,799 @@
+-- chat.syn — Lampson por terminal (REPL)
+--
+--   synsema run chat.syn                 -- sesión nueva
+--   LAMPSON_SESSION=<id> synsema run chat.syn   -- reanudar
+--
+-- Comandos: /help /new /sessions /resume <id> /tokens /yolo /ask /strict /agent <build|plan|review|explore> /exit
+--
+-- El ENTRY otorga el superset de capacidades; cada tool declara las suyas y call_tool intersecta.
+-- El proyecto objetivo se monta como ./workspace (ver lampson.ps1 / lampson.sh y lib/tools/common.syn).
+
+intent: "Coding agent REPL: the model picks tools from an allow-list, each runs least-privilege in the workspace"
+
+require net
+require time
+require stdin
+require exec
+require env("LAMPSON_*")
+require env("OS")
+require secret("LAMPSON_*")
+require file("workspace")
+require file("workspace/*")
+require file.read("skills")
+require file.read("skills/*")
+require file.read("lamps")
+require file.read("lamps/*")
+require file("memory")
+require file("memory/*")
+require file(".lampson")
+require file(".lampson/*")
+
+use "./lib/provider.syn" as provider
+use "./lib/tools.syn" as tools
+use "./lib/prompt.syn" as prompt
+use "./lib/loop.syn" as loop
+use "./lib/session.syn" as session
+use "./lib/permission.syn" as permission
+use "./lib/agents.syn" as agents
+use "./lib/tree.syn" as tree
+use "./lib/skills.syn" as skills
+use "./lib/git.syn" as git
+use "./lib/tools/proc.syn" as proc
+use "./lib/tools/memo.syn" as memo
+use "./lib/update.syn" as update
+use "./lib/settings.syn" as settings
+use "./lib/trace.syn" as trace
+use "./lib/mcp.syn" as mcp
+use "./lib/lamps.syn" as lamps
+use "./lib/lsp.syn" as lsp
+use "./lib/tools/todo.syn" as todo
+
+-- ---------- UI de terminal ----------
+-- Colores ANSI (Windows Terminal, PowerShell 7, cualquier terminal moderna). LAMPSON_NO_COLOR=1 los apaga.
+
+let ESC be decode(bytes("1b", "hex"))
+let COLOR be env("LAMPSON_NO_COLOR", "") == ""
+
+task c(code, s)
+    when not COLOR
+        give s
+    give ESC + "[" + code + "m" + s + ESC + "[0m"
+
+task cyan(s)
+    give c("36;1", s)
+task dim(s)
+    give c("2", s)
+task yellow(s)
+    give c("33", s)
+task green(s)
+    give c("32", s)
+task red(s)
+    give c("31", s)
+
+task first_line(s, max)
+    let f be split(s, "\n")[0]
+    when length(f) > max
+        give slice(f, 0, max) + "…"
+    give f
+
+task fmt_tokens(n)
+    when n >= 1000
+        give text(floor(n / 100) / 10) + "k"
+    give text(n)
+
+-- resumen de UNA línea del resultado de una tool, según la tool
+task summarize(name, out)
+    let lines be split(out, "\n")
+    when starts_with(out, "ERROR") or starts_with(out, "DENIED")
+        give first_line(out, 140)
+    when name == "read"
+        give text(length(lines)) + " líneas"
+    when name == "ls" or name == "find" or name == "grep"
+        give text(length(lines)) + " resultados · " + first_line(out, 90)
+    when name == "bash"
+        -- hasta 5 líneas del output, el resto colapsado
+        let shown be []
+        each e in enumerate(lines)
+            when e["index"] < 5
+                when trim(e["item"]) != ""
+                    set shown to append(shown, slice(e["item"], 0, 140))
+        let extra be when length(lines) > 5 then dim("  (+" + text(length(lines) - 5) + " líneas)") otherwise ""
+        give join(shown, "\n      ") + extra
+    give first_line(out, 120)
+
+-- tag = "" para el agente principal; los subagentes en background NO pasan por acá (escriben su log)
+task on_event(kind, data, tag)
+    trace.event(sid, kind, data, tag)
+    when kind == "assistant"
+        print("")
+        print(data)
+        print("")
+    otherwise when kind == "inbox"
+        print("  " + cyan("✉ " + first_line(data, 140)))
+    otherwise when kind == "tool_call"
+        print("  " + yellow("⚙ " + permission.describe_call(data["name"], data["args"])))
+    otherwise when kind == "tool_result"
+        let out be data["output"]
+        let bad be starts_with(out, "ERROR") or starts_with(out, "DENIED")
+        let mark be when bad then red("✗") otherwise green("✓")
+        print("    " + mark + " " + (when bad then red(summarize(data["call"]["name"], out)) otherwise dim(summarize(data["call"]["name"], out))))
+    otherwise when kind == "tool_denied"
+        set data to data
+    otherwise when kind == "error"
+        print("  " + red("‼ " + text(data)))
+        when contains(lower(text(data)), "model")
+            print("  " + yellow("el proveedor rechazó el nombre del modelo (" + cfg["model"] + "): /model sin argumentos lista los válidos, /model <nombre> lo cambia"))
+    otherwise when kind == "compact"
+        print("  " + dim("⧗ compactando contexto (~" + text(data["before"]) + " tokens)"))
+    flush()
+
+-- Human in the loop con el `approve` nativo de Synsema: prompt [approve] … (y/n) en TTY; sin TTY deniega
+-- (fail-closed, un agente no puede auto-aprobarse); `within` acota la espera.
+task ask_user(name, args, why)
+    print("")
+    print("  " + yellow("⚠ requiere tu aprobación · " + why))
+    print("    " + permission.describe_call(name, args))
+    flush()
+    let ok be approve "  ¿permitir?" within 10m
+    give ok
+
+let LINE be "  ────────────────────────────────────────────────────────────────────────"
+
+-- catálogo de comandos del REPL: [comando, argumentos, descripción]. Es la fuente de /help, de `/` y de las sugerencias.
+let COMMANDS be [
+    ["/agent", "<build|plan|review|explore>", "cambiar de agente (qué tools ve): build edita · plan solo lee y propone · review revisa y corre tests · explore busca"],
+    ["/ask", "", "permisos: PREGUNTAR antes de un comando peligroso (rm -rf, git push --force, sudo…)"],
+    ["/yolo", "", "permisos: PERMITIR comandos peligrosos sin preguntar (los destructivos del sistema siguen bloqueados)"],
+    ["/strict", "", "permisos: DENEGAR comandos peligrosos"],
+    ["/model", "<nombre>", "cambiar el modelo para esta sesión (mismo proveedor y key)"],
+    ["/provider", "[nombre] [modelo]", "cambiar de proveedor (deepseek, anthropic, openai, minimax…); sin args lista cuáles tienen key"],
+    ["/setup", "", "elegir proveedor, modelo y pegar la API key (queda en lampson/.lampson/config.json, local)"],
+    ["/paste", "", "adjuntar la imagen del portapapeles al próximo mensaje (copiá una captura y escribí /paste)"],
+    ["/image", "<ruta>", "adjuntar una imagen (png/jpg/gif/webp) al próximo mensaje; /image sin ruta muestra o quita las pendientes"],
+    ["/delete", "<id>", "borrar una sesión guardada (ver /sessions)"],
+    ["/config", "", "ver la configuración vigente (proveedor, modelo, límites, workspace)"],
+    ["/files", "", "árbol completo del workspace"],
+    ["/procs", "", "procesos que el agente dejó corriendo (servidores) y su estado"],
+    ["/logs", "<nombre> [n]", "últimas n líneas del log de un proceso gestionado"],
+    ["/stop", "<nombre>", "parar un proceso gestionado"],
+    ["/kill", "<pid>", "matar un proceso NO gestionado (p.ej. un servidor huérfano que ves en /procs)"],
+    ["/memory", "[nombre]", "notas que el agente guardó sobre ESTE proyecto (memory/<proyecto>/*.md); con nombre, la muestra"],
+    ["/skills", "", "skills disponibles (instrucciones que el agente puede cargar)"],
+    ["/agents", "", "subagentes lanzados con delegate: estado, pasos y log de cada uno"],
+    ["/todo", "", "lista de tareas del agente en esta sesión (la mantiene con la tool todo)"],
+    ["/mcp", "[add <nombre> <comando…> [--project] | remove <nombre>]", "servers MCP: listar, conectar o quitar (global: lampson/.lampson/mcp.json · proyecto: .lampson/mcp.json)"],
+    ["/lamps", "[on <nombre> | off <nombre> | run <lámpara> <tool> [json] | remove <nombre>]", "lámparas (plugins de tools): listar, encender o apagar (global: lampson/lamps/ · proyecto: .lampson/lamps/)"],
+    ["/lsp", "[add <typescript|python|rust|go|css|html> [--project] | add <nombre> <comando…> --ext .x=lang | remove <nombre>]", "language servers (navegación semántica: symbols/definition/references/hover); arrancan en la primera consulta"],
+    ["/trace", "[n]", "traza legible de esta sesión (pasos, tools, tiempos, tokens, errores): .lampson/trace/<sesión>.log"],
+    ["/tokens", "", "tamaño del contexto y tokens gastados en esta sesión"],
+    ["/new", "", "empezar una sesión nueva (historial vacío)"],
+    ["/sessions", "", "listar sesiones guardadas"],
+    ["/resume", "<id>", "reanudar una sesión guardada"],
+    ["/flags", "", "flags de arranque: lampson --web --agent --yolo --workspace …"],
+    ["/update", "", "actualizar Lampson a la última versión (git pull); también: lampson --update"],
+    ["!<comando>", "", "correr un comando VOS en un terminal real (prompts y REPLs funcionan; ^C corta); la salida queda en el contexto del agente"],
+    ["/help", "", "esta ayuda"],
+    ["/exit", "", "salir (la sesión queda guardada)"]
+]
+
+task pad(s, n)
+    let out be s
+    while length(out) < n
+        set out to out + " "
+    give out
+
+task help()
+    print("")
+    print("  Escribí lo que querés hacer en el proyecto. El agente lee, busca, edita y corre comandos con tools")
+    print("  acotadas al workspace; cada paso queda a la vista. Los comandos empiezan con /:")
+    print("")
+    each c in COMMANDS
+        print("  " + pad(c[0] + " " + c[1], 38) + c[2])
+    print("")
+
+task flags()
+    print("")
+    print("  Flags de arranque (desde cualquier carpeta; el directorio actual es el workspace):")
+    print("")
+    print("  lampson                          REPL por terminal sobre el proyecto actual")
+    print("  lampson --web                    interfaz web en http://127.0.0.1:8080")
+    print("  lampson --workspace C:\\ruta      elegir el proyecto sin hacer cd")
+    print("  lampson --agent plan             perfil inicial: build | plan | review | explore")
+    print("  lampson --yolo | --strict | --ask   permisos (--dangerously-skip-permissions = --yolo)")
+    print("  lampson --help                   ayuda del launcher")
+    print("")
+    print("  Configuración persistente (opcional): lampson\\.env → LAMPSON_PROVIDER, LAMPSON_API_KEY, LAMPSON_MODEL…")
+    print("")
+
+task show_config(cfg, ws, profile, mode, opts)
+    print("")
+    print("  proveedor   " + cfg["provider"] + " (" + cfg["wire"] + " → " + cfg["base_url"] + ")")
+    print("  modelo      " + cfg["model"] + "   max_tokens " + text(cfg["max_tokens"]) + "   timeout " + text(floor(cfg["timeout"])) + "s")
+    print("  agente      " + profile + "   tools: " + join(agents.profile(profile)["tools"], ", "))
+    print("  permisos    " + mode)
+    print("  límites     " + text(opts["max_steps"]) + " pasos/turno · " + text(floor(opts["budget_tokens"])) + " tokens/turno · compacta a " + text(floor(opts["compact_at_tokens"])))
+    print("  workspace   " + ws)
+    print("")
+
+-- sugerencias para un comando desconocido: por prefijo
+task suggest(input)
+    let word be split(input, " ")[0]
+    let hits be []
+    each c in COMMANDS
+        when starts_with(c[0], word)
+            set hits to append(hits, c[0])
+    when length(hits) == 0
+        give "comando desconocido: " + word + " · escribí / para ver la lista"
+    give "¿quisiste decir " + join(hits, " · ") + "?"
+
+task banner(ws, cfg, profile, mode, sid)
+    print("")
+    print("  ██   █████  ███  ███ ██████  ███████  ██████  ███   ██")
+    print("  ██  ██   ██ ████████ ██   ██ ██      ██    ██ ████  ██")
+    print("  ██  ███████ ██ ██ ██ ██████  ███████ ██    ██ ██ ██ ██")
+    print("  ██  ██   ██ ██    ██ ██           ██ ██    ██ ██  ████")
+    print("  ██████   ██ ██    ██ ██      ███████  ██████  ██   ███")
+    print("  harness de agente en Synsema")
+    print(LINE)
+    print("  workspace   " + ws)
+    print("  agente      " + profile + "        permisos  " + mode + "        modelo  " + cfg["model"])
+    print("  sesión      " + sid + "        " + git.summary())
+    let upd be update.line()
+    when upd != ""
+        print("  " + yellow("⬆ " + upd) + dim("  (o /update acá)"))
+    print(LINE)
+    print(tree.render(0, 22))
+    print(LINE)
+    print("  Escribí un pedido, " + cyan("/") + " para los comandos, " + cyan("!") + "comando para correr algo vos.")
+
+task skills_list()
+    let idx be skills.index()
+    let out be []
+    each n in sort_by(keys(idx), (x) => x)
+        set out to append(out, "  " + n + " (" + idx[n]["source"] + "): " + idx[n]["description"])
+    when length(out) == 0
+        give "  (sin skills)"
+    give join(out, "\n")
+
+-- ---------- onboarding ----------
+-- Primera vez (ningún proveedor con key) o /setup: elegir proveedor, modelo y pegar la key. Va a
+-- lampson/.lampson/config.json (local, gitignored) y vale para terminal y web. Sin TTY no pregunta.
+task setup_wizard()
+    print("")
+    print("  " + cyan("Configuremos el modelo.") + " Elegí un proveedor (número o nombre):")
+    let list be provider.providers()
+    each e in enumerate(list)
+        let p be e["item"]
+        print("  " + pad(text(e["index"] + 1) + ".", 4) + pad(p["name"], 12) + dim(p["model"]) + (when p["name"] == "ollama" then dim("  (local, sin key)") otherwise (when p["has_key"] then green("  ● key guardada") otherwise "")))
+    let choice be read_line("  proveedor: ")
+    when choice == nothing or trim(choice) == ""
+        print("  (sin cambios)")
+        give false
+    let name be lower(trim(choice))
+    when matches(name, "[0-9]+")
+        let i be floor(number(name)) - 1
+        when i >= 0 and i < length(list)
+            set name to list[i]["name"]
+    when not contains(provider.PRESETS, name)
+        print("  " + red("no conozco el proveedor " + name))
+        give false
+    let preset be provider.PRESETS[name]
+    let model be read_line("  modelo [" + preset["model"] + "]: ")
+    set model to when model == nothing then "" otherwise trim(model)
+    when name != "ollama"
+        print("  " + dim("la key se guarda en lampson/.lampson/config.json (solo en esta máquina); Enter para dejar la actual"))
+        let key be read_line("  API key de " + name + ": ")
+        when key != nothing and trim(key) != ""
+            settings.set_key(name, trim(key))
+    settings.set_default(name, model)
+    print("  " + green("listo") + " · " + name + " · " + (when model == "" then preset["model"] otherwise model) + dim("   (cambialo cuando quieras con /setup o /provider)"))
+    give true
+
+-- ---------- imágenes en el REPL ----------
+-- Una terminal no puede pegar una imagen, así que se lee del portapapeles (/paste) o de un archivo
+-- (/image ruta) con un script del sistema que devuelve "media_type|w|h|base64". Quedan pendientes
+-- hasta el próximo mensaje al agente (mismo formato canónico que la web: m["images"]).
+let pending_images be []
+
+task grab_image(mode, path)
+    let r be nothing
+    when env("OS", "") == "Windows_NT"
+        set r to run("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", "lib/tools/img.ps1", mode, path], 60)
+    otherwise
+        set r to run("bash", ["lib/tools/img.sh", mode, path], 60)
+    let line be trim(replace_text(r["stdout"], "\r", ""))
+    when line == "" or starts_with(line, "ERROR|")
+        give {"error": when line == "" then trim(r["stderr"]) otherwise slice(line, 6, length(line))}
+    let parts be split(line, "|")
+    when length(parts) < 4
+        give {"error": "salida inesperada del lector de imágenes"}
+    give {"media_type": parts[0], "w": floor(number(parts[1])), "h": floor(number(parts[2])), "data": parts[3]}
+
+task attach_image(mode, path)
+    when length(pending_images) >= 4
+        print("  " + yellow("máximo 4 imágenes por mensaje (/image para quitarlas)"))
+        give false
+    let im be grab_image(mode, path)
+    when contains(im, "error")
+        print("  " + red("✗ " + im["error"]))
+        give false
+    set pending_images to append(pending_images, im)
+    let vis be provider.supports_vision(cfg)
+    print("  " + green("📎 imagen " + text(length(pending_images)) + " adjunta") + dim(" · " + text(im["w"]) + "x" + text(im["h"]) + " · " + text(floor(length(im["data"]) * 3 / 4 / 1024)) + " KB · se manda con tu próximo mensaje"))
+    when not vis
+        print("  " + yellow("ojo: " + cfg["provider"] + " · " + cfg["model"] + " no acepta imágenes; el modelo recibirá solo una nota. Cambiá con /provider a uno con visión (anthropic, gpt-4o…)"))
+    give true
+
+-- ---------- boot ----------
+
+let cfg be provider.config()
+when not provider.configured() and cfg["provider"] != "ollama"
+    print("")
+    print("  Bienvenido a Lampson. Todavía no hay ninguna API key configurada.")
+    when setup_wizard()
+        set cfg to provider.config()
+let env_info be agents.env_info(cfg)
+let profile be lower(env("LAMPSON_AGENT", "build"))
+task system_for(p)
+    give {"role": "system", "content": prompt.build(env_info, agents.addendum_for(p))}
+task opts_for(p, mode)
+    let o be loop.default_opts(agents.registry_for(p), agents.catalog_for(p), ask_user)
+    set o to loop.with_steps(o, agents.steps_for(p))
+    set o to loop.with_inbox(o, agents.parent_inbox, "")
+    give loop.with_mode(o, mode)
+
+-- Subagente en background: `agent Child` (lib/agents.syn) corre en un hilo con intérprete propio y solo
+-- puede llamar tasks TOP-LEVEL de este programa — esta es su única puerta de entrada al harness.
+task lampson_subagent(spec_json)
+    give agents.run_child_json(spec_json)
+
+-- !comando del usuario en un pseudo-terminal: la salida se ve EN VIVO y, si el proceso se queda esperando
+-- (prompt y/N, contraseña, REPL, `npm init`…), lo que escribas se le manda como teclas + Enter.
+-- Enter vacío = seguir esperando · ^C = cortar. Devuelve la salida (sin ANSI) para el contexto del agente.
+task shell_argv(cmd)
+    when env("OS", "") == "Windows_NT"
+        give ["powershell", ["-NoLogo", "-NoProfile", "-Command", cmd]]
+    give ["bash", ["-lc", cmd]]
+
+task run_interactive(cmd)
+    let sh be shell_argv(cmd)
+    let p be proc_spawn(sh[0], sh[1], {"cwd": env("LAMPSON_WORKSPACE", "workspace"), "pty": true, "cols": 120, "rows": 40})
+    let captured be []
+    let partial be ""
+    let alive be true
+    while alive
+        let ev be proc_recv(p, 5)
+        when ev == nothing
+            when proc_status(p) != "running"
+                set alive to false
+            otherwise
+                -- silencio: si quedó una línea a medias es casi seguro un prompt; dejar escribir
+                let hint be when trim(partial) == "" then "(sin salida hace 5 s · Enter: seguir esperando · texto: mandárselo · ^C: cortar) " otherwise partial + " "
+                let line be read_line(dim(hint))
+                set partial to ""
+                when line == nothing or trim(line) == "^C"
+                    proc_kill(p)
+                    set captured to append(captured, "[cortado por el usuario]")
+                otherwise when trim(line) != ""
+                    proc_send(p, line + "\r")
+        otherwise when ev["type"] == "exit"
+            when partial != ""
+                print("    " + partial)
+                set captured to append(captured, partial)
+            set captured to append(captured, "[exit " + text(ev["data"]["exit_code"]) + "]")
+            set alive to false
+        otherwise
+            let raw be ev["data"]
+            when is_bytes(raw)
+                set raw to decode(raw, "utf8_lossy")
+            let chunk be strip_ansi(raw)
+            let lines be split(partial + chunk, "\n")
+            let n be length(lines)
+            each e in enumerate(lines)
+                when e["index"] < n - 1
+                    print("    " + e["item"])
+                    set captured to append(captured, e["item"])
+            set partial to lines[n - 1]
+            flush()
+    proc_close(p)
+    give join(captured, "\n")
+
+let system_msg be system_for(profile)
+-- servers MCP (globales en .lampson/mcp.json, del proyecto en workspace/.lampson/mcp.json): arrancan antes
+-- de armar el catálogo de tools; hasta 8 s de espera a que estén listos
+let mcp_servers be mcp.start_all(8)
+each ms in mcp.summary()
+    print("  " + (when ms["status"] == "ready" then green("● mcp " + ms["name"]) otherwise red("○ mcp " + ms["name"] + " " + ms["status"])) + dim(" (" + ms["scope"] + ") " + text(length(ms["tools"])) + " tools" + (when ms["error"] != nothing then " · " + text(ms["error"]) otherwise "")))
+-- language servers (lib/lsp.syn): solo se anuncian; arrancan lazy en la primera consulta
+each s in lsp.summary()
+    print("  " + dim("○ lsp " + s["name"] + " (" + s["scope"] + ") " + join(s["extensions"], " ") + " · arranca en la primera consulta"))
+-- lámparas (plugins de tools, lib/lamps.syn): solo se anuncian; apagadas no entran al catálogo
+each l in lamps.summary()
+    print("  " + (when l["enabled"] then green("● lamp " + l["name"]) otherwise dim("○ lamp " + l["name"] + " off")) + dim(" (" + l["scope"] + ", " + l["kind"] + ") " + text(length(l["tools"])) + " tools" + (when l["error"] != nothing then " · " + text(l["error"]) otherwise "")))
+let opts be opts_for(profile, lower(env("LAMPSON_PERMISSION", "ask")))
+
+-- marca de corrida (blackboard): session.save la estampa en meta.run; reanudar una sesión guardada por
+-- OTRA corrida dispara la nota de procesos muertos (proc.resume_note) para que el modelo no los crea vivos
+share {"id": text(now())} as "lampson:run"
+share {"kind": "terminal"} as "lampson:ui"
+
+let sid be env("LAMPSON_SESSION", "")
+let messages be [system_msg]
+when sid != ""
+    when session.exists(sid)
+        let doc be session.load(sid)
+        set messages to doc["messages"]
+        print("reanudando sesión " + sid + " (" + text(length(messages)) + " mensajes)")
+        when session.from_other_run(doc)
+            let note be proc.resume_note(sid)
+            when note != ""
+                set messages to append(messages, {"role": "user", "content": note})
+                print("  " + cyan("✉ " + first_line(note, 140)))
+    otherwise
+        print("sesión " + sid + " no existe; creando una nueva")
+        set sid to ""
+when sid == ""
+    set sid to session.new_id()
+-- sesión actual (blackboard): la tool todo guarda su lista por sesión y no recibe contexto (lib/tools/todo.syn)
+share {"id": sid} as "lampson:session"
+
+banner(env_info["cwd"], cfg, profile, opts["permission_mode"], sid)
+flush()
+
+let total_usage be {"input": 0, "output": 0}
+let mode be opts["permission_mode"]
+let running be true
+-- turnos automáticos por avisos de subagentes en background (padre idle): tope 3 seguidos, se
+-- reinicia con input humano real (anti bucle auto-excitado, deepseek-harness)
+let followups be 0
+while running
+    let inbox be when followups < 3 then agents.parent_inbox(0, "") otherwise nothing
+    let line be nothing
+    when inbox != nothing
+        set followups to followups + 1
+        each m in inbox["messages"]
+            print("")
+            print("  " + cyan("✉ " + first_line(m, 140)))
+            set messages to append(messages, {"role": "user", "content": m})
+        trace.user(sid, "(turno automático por aviso de subagente)", profile, mode, cfg["model"])
+        set opts to opts_for(profile, mode)
+        let result be loop.run_turn(cfg, messages, opts, on_event)
+        trace.turn_end(sid, result)
+        set messages to result["messages"]
+        set total_usage to {"input": total_usage["input"] + result["usage"]["input"], "output": total_usage["output"] + result["usage"]["output"]}
+        print(dim("  ─── " + text(result["steps"]) + " pasos · " + fmt_tokens(result["usage"]["input"] + result["usage"]["output"]) + " tokens · turno automático por subagente"))
+        session.save(sid, messages, {"title": session.title_of(messages)})
+        flush()
+    otherwise
+        set line to read_line("\n" + (when length(pending_images) > 0 then dim("📎" + text(length(pending_images)) + " ") otherwise "") + cyan("❯ "))
+    when inbox != nothing
+        set running to running
+    otherwise when line == nothing
+        set running to false
+    otherwise
+        set followups to 0
+        let input be trim(line)
+        when input == ""
+            set running to running
+        otherwise when input == "/exit" or input == "/quit"
+            set running to false
+        otherwise when input == "/help" or input == "/"
+            help()
+        otherwise when input == "/flags"
+            flags()
+        otherwise when input == "/update"
+            let u be update.check()
+            when not u["available"]
+                print("  ya estás en la última versión (" + u["current"] + ")")
+            otherwise
+                each n in u["notes"]
+                    print("  " + dim("· " + n))
+                print("  " + update.apply())
+        otherwise when input == "/config"
+            show_config(cfg, env_info["cwd"], profile, mode, opts)
+        otherwise when starts_with(input, "/trace")
+            let n be trim(slice(input, 6, length(input)))
+            let lines be when n == "" then 40 otherwise floor(number(n))
+            print(dim("  " + trace.file_of(sid)))
+            print(trace.tail(sid, lines))
+        otherwise when starts_with(input, "/model")
+            let want be trim(slice(input, 6, length(input)))
+            when want == ""
+                print("modelo actual: " + cfg["model"] + " · uso: /model <nombre>")
+                let lm be provider.list_models(cfg)
+                when lm["error"] != nothing
+                    print("  " + dim("no pude listar los modelos de " + cfg["provider"] + ": " + lm["error"]))
+                otherwise
+                    print("  disponibles en " + cfg["provider"] + ": " + join(lm["models"], ", "))
+            otherwise
+                set cfg["model"] to provider.normalize_model(cfg["provider"], want)
+                print("modelo=" + want + " (solo esta sesión; para fijarlo: LAMPSON_MODEL en lampson\\.env)")
+        otherwise when starts_with(input, "/provider")
+            let args be where(split(trim(slice(input, 9, length(input))), " "), (x) => x != "")
+            when length(args) == 0
+                print("  proveedor actual: " + cfg["provider"] + " · modelo " + cfg["model"])
+                each p in provider.providers()
+                    print("  " + (when p["has_key"] then green("● ") otherwise dim("○ ")) + pad(p["name"], 12) + dim(p["model"] + (when p["has_key"] then "" otherwise "   (sin key: LAMPSON_API_KEY_" + upper(p["name"]) + " en lampson\\.env)")))
+                print("  uso: /provider <nombre> [modelo]")
+            otherwise when not contains(provider.PRESETS, lower(args[0]))
+                print("  no conozco el proveedor " + args[0] + " · disponibles: " + join(sort_by(keys(provider.PRESETS), (x) => x), ", "))
+            otherwise
+                set cfg to provider.config_for(args[0], when length(args) > 1 then args[1] otherwise "")
+                when not cfg["has_key"]
+                    print("  " + yellow("ojo: no hay key para " + cfg["provider"] + " — agregá LAMPSON_API_KEY_" + upper(cfg["provider"]) + "=… en lampson\\.env (se usará LAMPSON_API_KEY, que probablemente falle)"))
+                print("  proveedor=" + cfg["provider"] + " · modelo=" + cfg["model"] + " · " + cfg["wire"] + " → " + cfg["base_url"] + dim("   (solo esta sesión; para fijarlo: LAMPSON_PROVIDER en .env)"))
+        otherwise when input == "/setup"
+            when setup_wizard()
+                set cfg to provider.config()
+        otherwise when input == "/paste"
+            attach_image("clip", "")
+        otherwise when starts_with(input, "/image")
+            let p be trim(slice(input, 6, length(input)))
+            when p == ""
+                when length(pending_images) == 0
+                    print("  sin imágenes pendientes · uso: /image <ruta>  o  /paste")
+                otherwise
+                    print("  " + text(length(pending_images)) + " imagen(es) pendiente(s) — se mandan con tu próximo mensaje. ¿Quitarlas? (s/N)")
+                    let a be read_line("  ")
+                    when a != nothing and lower(trim(a)) == "s"
+                        set pending_images to []
+                        print("  quitadas")
+            otherwise
+                attach_image("file", p)
+        otherwise when starts_with(input, "/delete")
+            let id be trim(slice(input, 7, length(input)))
+            when id == ""
+                print("  uso: /delete <id>   (ver /sessions)")
+            otherwise when id == sid
+                print("  esa es la sesión actual; hacé /new primero")
+            otherwise
+                print("  " + session.delete(id))
+        otherwise when input == "/new"
+            set sid to session.new_id()
+            set messages to [system_msg]
+            share {"id": sid} as "lampson:session"
+            print("nueva sesión " + sid)
+        otherwise when input == "/sessions"
+            each s in session.list()
+                print("  " + s["id"] + "  " + s["title"])
+        otherwise when starts_with(input, "/resume ")
+            let id be trim(slice(input, 8, length(input)))
+            when session.exists(id)
+                set sid to id
+                let rdoc be session.load(id)
+                set messages to rdoc["messages"]
+                share {"id": sid} as "lampson:session"
+                print("reanudada " + id + " (" + text(length(messages)) + " mensajes)")
+                when session.from_other_run(rdoc)
+                    let note be proc.resume_note(sid)
+                    when note != ""
+                        set messages to append(messages, {"role": "user", "content": note})
+                        print("  " + cyan("✉ " + first_line(note, 140)))
+            otherwise
+                print("no existe " + id)
+        otherwise when input == "/files"
+            print(tree.render(2, 200))
+        otherwise when input == "/procs"
+            let items be proc.list()
+            when length(items) == 0
+                print("  (ningún proceso gestionado)")
+            each p in items
+                print("  " + (when p["running"] then green("● running") otherwise red("○ exited ")) + "  " + p["name"] + "  $ " + p["command"])
+            let ports be proc.listeners()
+            when length(ports) > 0
+                print("")
+                print("  " + dim("puertos en escucha en esta máquina (de cualquier programa, no solo de lampson; /kill <pid> para matar uno):"))
+                each l in ports
+                    print("  " + yellow(":" + text(l["port"])) + "  pid " + text(l["pid"]) + "  " + l["name"] + "  " + dim(first_line(l["command"], 110)))
+        otherwise when starts_with(input, "/logs")
+            let args be split(trim(slice(input, 5, length(input))), " ")
+            when args[0] == ""
+                print("  uso: /logs <nombre> [líneas]")
+            otherwise
+                let n be when length(args) > 1 then number(args[1]) otherwise 60
+                print(proc.logs(args[0], n))
+        otherwise when starts_with(input, "/kill")
+            let pid be trim(slice(input, 5, length(input)))
+            print("  " + (when pid == "" then "uso: /kill <pid>  (ver /procs)" otherwise proc.kill_pid(number(pid))))
+        otherwise when starts_with(input, "/stop")
+            let nm be trim(slice(input, 5, length(input)))
+            print("  " + (when nm == "" then "uso: /stop <nombre>" otherwise proc.halt(nm)))
+        otherwise when starts_with(input, "/memory")
+            let nm be trim(slice(input, 7, length(input)))
+            when nm == ""
+                let items be memo.list()
+                print("  " + dim("memory/" + memo.slug() + "/"))
+                when length(items) == 0
+                    print("  (sin notas todavía — el agente las crea con la tool memory)")
+                each it in items
+                    print("  " + yellow(it["name"]) + "  " + it["title"])
+            otherwise
+                print(memo.note_read(nm))
+        otherwise when input == "/todo"
+            let items be todo.load(sid)
+            print(when length(items) == 0 then "  sin tareas (el agente las crea con la tool todo)" otherwise "  " + replace_text(todo.format(items), "\n", "\n  "))
+        otherwise when input == "/lsp" or starts_with(input, "/lsp ")
+            let srest be trim(slice(input, 4, length(input)))
+            when starts_with(srest, "add ")
+                -- /lsp add typescript [--project]   ·   /lsp add mylang cmd args… --ext .x=lang [--ext .y=lang2]
+                let sscope be when contains(srest, "--project") then "project" otherwise "global"
+                let sline be trim(replace_text(srest, "--project", ""))
+                let stoks be where(split(slice(sline, 4, length(sline)), " "), (x) => x != "")
+                when length(stoks) == 0
+                    print("  uso: /lsp add <" + join(keys(lsp.PRESETS), "|") + "> [--project]   ·   /lsp add <nombre> <comando…> --ext .ext=languageId")
+                otherwise
+                    let langs be {}
+                    let cmdtoks be []
+                    let ti be 1
+                    while ti < length(stoks)
+                        when stoks[ti] == "--ext" and ti + 1 < length(stoks)
+                            let kv be split(stoks[ti + 1], "=")
+                            when length(kv) == 2
+                                set langs[kv[0]] to kv[1]
+                            set ti to ti + 2
+                        otherwise
+                            set cmdtoks to append(cmdtoks, stoks[ti])
+                            set ti to ti + 1
+                    try
+                        print("  " + lsp.add_server(stoks[0], when length(cmdtoks) == 0 then nothing otherwise join(cmdtoks, " "), when length(keys(langs)) == 0 then nothing otherwise langs, sscope))
+                    recover err
+                        print("  " + red(text(err)))
+            otherwise when starts_with(srest, "remove ")
+                try
+                    print("  " + lsp.remove_server(trim(slice(srest, 7, length(srest)))))
+                recover err
+                    print("  " + red(text(err)))
+            otherwise
+                let ss be lsp.summary()
+                when length(ss) == 0
+                    print("  sin language servers configurados. Agregá uno: " + cyan("/lsp add typescript") + dim("  (presets: " + join(keys(lsp.PRESETS), ", ") + ")"))
+                    print("  " + dim("el agente los usa con la tool lsp: symbols (estructura de un archivo sin leerlo), definition, references, hover"))
+                each s in ss
+                    print("  " + (when s["status"] == "ready" then green("● ") otherwise (when s["status"] == "error" or s["status"] == "exited" then red("○ ") otherwise dim("○ "))) + pad(s["name"], 12) + dim(pad(s["scope"], 8) + pad(s["status"], 8) + join(s["extensions"], " ") + "  $ " + s["command"]) + (when s["error"] != nothing then red("  " + text(s["error"])) otherwise ""))
+                print("  " + dim("idle = arranca en la primera consulta del agente"))
+        otherwise when input == "/lamps" or starts_with(input, "/lamps ")
+            let lrest be trim(slice(input, 6, length(input)))
+            when starts_with(lrest, "run ")
+                -- /lamps run <lámpara> <tool> [json de args]  → la corre el usuario, sin el modelo
+                let rt be where(split(trim(slice(lrest, 4, length(lrest))), " "), (x) => x != "")
+                when length(rt) < 2
+                    print("  uso: /lamps run <lámpara> <tool> [{\"arg\": \"valor\"}]")
+                otherwise
+                    let rargs be {}
+                    when length(rt) > 2
+                        try
+                            set rargs to json_decode(join(slice(rt, 2, length(rt)), " "))
+                        recover err
+                            print("  " + red("args: JSON inválido"))
+                    try
+                        print(lamps.call(lamps.tool_name(rt[0], rt[1]), rargs))
+                    recover err
+                        print("  " + red(text(err)))
+            otherwise when starts_with(lrest, "remove ")
+                try
+                    print("  " + lamps.remove(trim(slice(lrest, 7, length(lrest)))))
+                recover err
+                    print("  " + red(text(err)))
+                set opts to opts_for(profile, mode)
+            otherwise when starts_with(lrest, "on ") or starts_with(lrest, "off ")
+                let lon be starts_with(lrest, "on ")
+                try
+                    print("  " + lamps.set_enabled(trim(slice(lrest, when lon then 3 otherwise 4, length(lrest))), lon))
+                recover err
+                    print("  " + red(text(err)))
+                set opts to opts_for(profile, mode)
+            otherwise
+                let ls be lamps.summary()
+                when length(ls) == 0
+                    print("  sin lámparas. Una lámpara es una carpeta con lamp.json: " + dim("lampson\\lamps\\<nombre>\\ (global) · .lampson\\lamps\\<nombre>\\ del repo (proyecto)"))
+                    print("  " + dim("el agente también puede crearlas (write en .lampson/lamps/) y pedirte encenderlas"))
+                each l in ls
+                    print("  " + (when l["enabled"] then green("● ") otherwise dim("○ ")) + pad(l["name"], 14) + dim(pad(l["scope"], 8) + pad(l["kind"], 5)) + (when l["error"] != nothing then red("rota: " + text(l["error"])) otherwise dim(text(length(l["tools"])) + " tools [" + join(l["tools"], ", ") + "]" + (when l["kind"] == "syn" then "  techo: " + l["caps"] otherwise "  $ " + l["command"]))))
+                print("  " + dim("encender/apagar: /lamps on <nombre> · /lamps off <nombre> · correr una vos: /lamps run <lámpara> <tool> [json]"))
+        otherwise when input == "/mcp" or starts_with(input, "/mcp ")
+            let mrest be trim(slice(input, 4, length(input)))
+            when starts_with(mrest, "add ")
+                -- /mcp add <nombre> <comando…> [--project]  (env/keys: editá el mcp.json a mano, no van por terminal)
+                let mscope be when contains(mrest, "--project") then "project" otherwise "global"
+                let mline be trim(replace_text(mrest, "--project", ""))
+                let mtoks be where(split(slice(mline, 4, length(mline)), " "), (x) => x != "")
+                when length(mtoks) < 2
+                    print("  uso: /mcp add <nombre> <comando…> [--project]   p.ej.: /mcp add github npx -y @modelcontextprotocol/server-github")
+                otherwise
+                    try
+                        print("  " + mcp.add_server(mtoks[0], join(slice(mtoks, 1, length(mtoks)), " "), {}, mscope))
+                    recover err
+                        print("  " + red(text(err)))
+                    set opts to opts_for(profile, mode)
+            otherwise when starts_with(mrest, "remove ")
+                try
+                    print("  " + mcp.remove_server(trim(slice(mrest, 7, length(mrest)))))
+                recover err
+                    print("  " + red(text(err)))
+                set opts to opts_for(profile, mode)
+            otherwise
+                let sm be mcp.summary()
+                when length(sm) == 0
+                    print("  sin servers MCP conectados (no hay ninguno configurado).")
+                    print("  conectá uno: " + cyan("/mcp add <nombre> <comando…> [--project]") + dim("   · o editá lampson\\.lampson\\mcp.json (global) / .lampson\\mcp.json del repo (proyecto)"))
+                    print("  " + dim("el agente también puede: pedile \"conectá el MCP de github\" y te va a pedir aprobación"))
+                each ms in sm
+                    print("  " + (when ms["status"] == "ready" then green("● ") otherwise red("○ ")) + pad(ms["name"], 14) + dim(pad(ms["scope"], 8) + ms["status"] + "  $ " + ms["command"]) + (when ms["error"] != nothing then red("  " + text(ms["error"])) otherwise ""))
+                    when length(ms["tools"]) > 0
+                        print("      " + dim(join(ms["tools"], ", ")))
+                -- servers que se pusieron listos después del arranque: recomponer el catálogo
+                set opts to opts_for(profile, mode)
+        otherwise when input == "/agents"
+            agents.prune(10, 1800)
+            let kids be agents.list_children()
+            when length(kids) == 0
+                print("  sin subagentes todavía (el agente los lanza con la tool delegate)")
+            each c in kids
+                print("  " + (when c["status"] == "running" then green("● running") otherwise dim("○ " + c["status"] + "  ")) + "  " + c["id"] + "  " + text(c["steps"]) + " pasos  " + dim(first_line(c["brief"], 80)) + dim("  log: " + agents.DIR + "/" + c["id"] + ".log"))
+        otherwise when input == "/skills"
+            print(skills_list())
+            print(dim("  instalar una de skills.sh: pedile al agente «instalá la skill X de owner/repo» (global, pide aprobación) · o !npx skills add owner/repo --skill X -g"))
+        otherwise when input == "/tokens"
+            print("contexto≈" + text(loop.estimate_tokens(messages)) + " tokens · gastado in=" + text(total_usage["input"]) + " out=" + text(total_usage["output"]))
+        otherwise when input == "/yolo" or input == "/ask" or input == "/strict"
+            set mode to slice(input, 1, length(input))
+            set opts to opts_for(profile, mode)
+            print("permisos=" + opts["permission_mode"])
+        otherwise when starts_with(input, "/agent")
+            let want be trim(slice(input, 6, length(input)))
+            when want == ""
+                print("agente=" + profile + " · disponibles: " + join(agents.names(), ", "))
+            otherwise when contains(agents.PROFILES, want)
+                set profile to want
+                set system_msg to system_for(profile)
+                set opts to opts_for(profile, mode)
+                -- el system prompt cambia con el perfil; el historial se conserva (cambiar de agente no borra la conversación)
+                set messages to [system_msg] + slice(messages, 1, length(messages))
+                print("agente=" + profile + " · tools: " + join(agents.profile(profile)["tools"], ", "))
+            otherwise
+                print("no existe el agente " + want + " · disponibles: " + join(agents.names(), ", "))
+        otherwise when starts_with(input, "/")
+            print("  " + suggest(input))
+        otherwise when starts_with(input, "!")
+            -- comando del USUARIO: corre sin política de permisos (lo escribiste vos), salida al contexto
+            let cmd be trim(slice(input, 1, length(input)))
+            when cmd == ""
+                print("  uso: !<comando>   p.ej. !git status · !npm test · !cat .env")
+            otherwise
+                print("  " + yellow("$ " + cmd))
+                flush()
+                let out be run_interactive(cmd)
+                set messages to append(messages, {"role": "user", "content": "[The user ran this command in the shell themselves]\n$ " + cmd + "\n" + tools.truncate(out, 6000)})
+                session.save(sid, messages, {"title": session.title_of(messages)})
+        otherwise
+            when length(pending_images) > 0
+                set messages to append(messages, {"role": "user", "content": input, "images": pending_images})
+                set pending_images to []
+            otherwise
+                set messages to append(messages, {"role": "user", "content": input})
+            trace.user(sid, input, profile, mode, cfg["model"])
+            -- catálogo fresco por turno: si el turno anterior conectó/quitó un server MCP, sus tools
+            -- entran/salen acá (con los mismos servers el catálogo es idéntico → el prompt cache no se corta)
+            set opts to opts_for(profile, mode)
+            let result be loop.run_turn(cfg, messages, opts, on_event)
+            trace.turn_end(sid, result)
+            set messages to result["messages"]
+            set total_usage to {"input": total_usage["input"] + result["usage"]["input"], "output": total_usage["output"] + result["usage"]["output"]}
+            let summary be text(result["steps"]) + (when result["steps"] == 1 then " paso" otherwise " pasos") + " · " + fmt_tokens(result["usage"]["input"] + result["usage"]["output"]) + " tokens"
+            when result["stopped"] == "max_steps"
+                set summary to summary + " · " + red("límite de " + text(opts["max_steps"]) + " pasos por turno")
+                print(dim("  ─── " + summary))
+                print("  " + yellow("El agente paró por el límite de pasos, no porque terminó. Escribí «seguí» para que continúe donde quedó, o subí LAMPSON_MAX_STEPS."))
+            otherwise when result["stopped"] != "done"
+                set summary to summary + " · " + red("detenido: " + result["stopped"])
+                print(dim("  ─── " + summary))
+            otherwise
+                print(dim("  ─── " + summary))
+            session.save(sid, messages, {"title": session.title_of(messages)})
+    flush()
+-- los procesos gestionados (servidores) y los subagentes en background mueren con lampson
+agents.stop_all()
+mcp.stop_all()
+lsp.stop_all()
+proc.halt_all()
+print("bye · sesión " + sid)