lampson 0.2.3 → 0.2.5

package/chat.syn

@@ -329,12 +329,10 @@ let COMMANDS be [
     ["/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)"],
+    ["/model", "[proveedor] [modelo]", "elegir proveedor y modelo con flechas (la lista de modelos la da la API); pide la key solo si falta; queda guardado"],
     ["/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)"],
+    ["/delete", "<id>", "borrar una sesión guardada, con confirmación (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"],
@@ -349,7 +347,7 @@ let COMMANDS be [
     ["/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"],
     ["/schedule", "[add <json> | run <id> | on <id> | off <id> | remove <id> | log <id>]", "tareas programadas (cada 6h, todos los días a las 9…): lámpara, comando o corrida del agente; corren mientras lampson esté abierto (o con lampson --daemon start, sin nada abierto)"],
-    ["/approve", "<id> yes|no", "responder una aprobación pendiente de una tarea programada que corre en background"],
+    ["/approve", "<id> [yes|no]", "responder una aprobación pendiente de una tarea programada que corre en background (sin yes|no la pregunta con el menú ↑↓)"],
     ["/out", "[n]", "resultado completo de la última tool del turno (n = contar hacia atrás: /out 2 es la anteúltima)"],
     ["/verbose", "", "alternar: mostrar SIEMPRE el output completo de cada tool (queda guardado en config.json)"],
     ["/trace", "[n]", "traza legible de esta sesión (pasos, tools, tiempos, tokens, errores): .lampson/trace/<sesión>.log"],
@@ -381,7 +379,7 @@ task complete_args(cmd, head, last)
         give workspace_paths(last)
     when cmd == "/resume" or cmd == "/delete"
         give apply((s) => s["id"], session.list())
-    when cmd == "/provider"
+    when cmd == "/provider" or cmd == "/model" or cmd == "/setup"
         when first
             give apply((p) => p["name"], provider.providers())
         give []
@@ -420,9 +418,8 @@ task complete_args(cmd, head, last)
             give []
         give apply((s) => s["id"], schedule.summary())
     when cmd == "/agent"
-        give ["build", "plan", "review", "explore", "worker"]
-    when cmd == "/model"
-        give []
+        -- solo los perfiles elegibles por el usuario: `worker` es interno de delegate (agents.names lo filtra)
+        give agents.names()
     give []
 
 -- rutas del workspace que empiezan con el prefijo escrito (directorios con "/" final para seguir completando)
@@ -599,37 +596,140 @@ task skills_list()
 -- ---------- 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: ")
+-- ---------- /model · /provider · /setup: UN solo flujo ----------
+-- Proveedor → modelo (lista viva de la API del proveedor) → key solo si falta. Todo con menús ↑↓ cuando hay
+-- TTY; sin TTY, listas numeradas + read_line. Siempre se GUARDA en lampson/.lampson/config.json (igual que
+-- la web): ya no hay "solo esta sesión". Con args (`/model glm glm-5.3-flash`) aplica directo lo que vino y
+-- pregunta solo lo que falte. cur_name/cur_model = lo activo, para marcarlo y ponerlo primero.
+let MENU_MAX be 18
+
+-- menú o lista numerada según haya TTY. Devuelve el índice elegido, o nothing si el usuario canceló.
+task pick_from(question, labels)
+    flush()
+    let pick be ed.choose("  " + question, labels, COLOR)
+    when pick == nothing
+        give nothing
+    when pick != -1
+        give pick
+    print("  " + question + " (número)")
+    each e in enumerate(labels)
+        print("  " + pad(text(e["index"] + 1) + ".", 4) + e["item"])
+    let choice be read_line("  > ")
     when choice == nothing or trim(choice) == ""
-        print("  (sin cambios)")
+        give nothing
+    let c be trim(choice)
+    when matches(c, "^[0-9]+$")
+        let i be floor(number(c)) - 1
+        when i >= 0 and i < length(labels)
+            give i
+        give nothing
+    -- también vale escribir el nombre (primera palabra de la etiqueta)
+    each e in enumerate(labels)
+        when lower(split(trim(e["item"]), " ")[0]) == lower(c)
+            give e["index"]
+    give nothing
+
+task ask_provider(cur_name)
+    let list be provider.providers()
+    -- el actual primero, después el resto en orden
+    let ordered be where(list, (p) => p["name"] == cur_name) + where(list, (p) => p["name"] != cur_name)
+    let labels be []
+    each p in ordered
+        let flag be when p["name"] == "ollama" then "local, sin key" otherwise (when p["has_key"] then "● key" otherwise "")
+        set labels to append(labels, pad(p["name"], 12) + pad(p["model"], 26) + pad(flag, 16) + (when p["name"] == cur_name then "◀ actual" otherwise ""))
+    let i be pick_from(cyan("Proveedor:"), labels)
+    when i == nothing
+        give ""
+    give ordered[i]["name"]
+
+-- modelos del proveedor según su API; si son muchos, un filtro antes del menú; siempre "otro…" para tipear
+task ask_model(name, cur_name, cur_model)
+    let pcfg be provider.config_for(name, "")
+    let default be when name == cur_name and cur_model != "" then cur_model otherwise pcfg["model"]
+    let lm be provider.list_models(pcfg)
+    when lm["error"] != nothing
+        print("  " + dim("no pude listar los modelos de " + name + " (" + lm["error"] + ")"))
+        let typed be read_line("  modelo [" + default + "]: ")
+        give when typed == nothing or trim(typed) == "" then default otherwise trim(typed)
+    let ids be lm["models"]
+    when length(ids) > MENU_MAX
+        print("  " + dim(text(length(ids)) + " modelos en " + name + " · escribí parte del nombre para filtrar (Enter = los primeros " + text(MENU_MAX) + ")"))
+        let f be read_line("  filtro: ")
+        let ff be when f == nothing then "" otherwise lower(trim(f))
+        when ff != ""
+            set ids to where(ids, (m) => contains(lower(m), ff))
+        when length(ids) == 0
+            print("  " + dim("ningún modelo contiene «" + ff + "»"))
+            set ids to lm["models"]
+        when length(ids) > MENU_MAX
+            set ids to slice(ids, 0, MENU_MAX)
+    -- el default primero (si la API lo lista), después el resto; al final la opción de escribir
+    let ordered be where(ids, (m) => m == default) + where(ids, (m) => m != default)
+    let labels be apply((m) => m + (when m == default then "   ◀ actual" otherwise ""), ordered)
+    set labels to append(labels, "otro… (escribir)")
+    let i be pick_from(cyan("Modelo de " + name + ":") + dim("  (según su API)"), labels)
+    when i == nothing
+        give ""
+    when i == length(labels) - 1
+        let typed be read_line("  modelo [" + default + "]: ")
+        give when typed == nothing or trim(typed) == "" then default otherwise trim(typed)
+    give ordered[i]
+
+-- pide la key si el proveedor no tiene una guardada. Devuelve false si el usuario canceló.
+task ensure_key(name)
+    when name == "ollama" or provider.has_key(name)
+        give true
+    print("  " + dim("la key se guarda en lampson/.lampson/config.json (solo en esta máquina)"))
+    let key be read_line("  API key de " + name + ": ")
+    when key == nothing
         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 trim(key) == ""
+        print("  " + yellow("sin key: podés agregarla después con /model"))
+        give true
+    settings.set_key(name, trim(key))
+    give true
+
+-- pre_name / pre_model: lo que vino por args ("" = preguntar). Devuelve true si guardó algo.
+task setup_wizard(pre_name, pre_model, cur_name, cur_model)
+    print("")
+    let name be lower(trim(pre_name))
+    when name == ""
+        set name to ask_provider(cur_name)
+        when name == ""
+            print("  (sin cambios)")
+            give false
     when not contains(provider.PRESETS, name)
-        print("  " + red("no conozco el proveedor " + name))
+        print("  " + red("no conozco el proveedor " + name) + " · disponibles: " + join(sort_by(keys(provider.PRESETS), (x) => x), ", "))
+        give false
+    -- la key va antes que el modelo: sin key la API no lista los modelos
+    when not ensure_key(name)
+        print("  (sin cambios)")
+        give false
+    let model be trim(pre_model)
+    when model == ""
+        set model to ask_model(name, cur_name, cur_model)
+        when model == ""
+            print("  (sin cambios)")
+            give false
+    -- un "modelo" que empieza con / es un comando tipeado por error (o un stdin que se acabó): no se guarda
+    when starts_with(model, "/")
+        print("  (sin cambios)")
         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))
+    set model to provider.normalize_model(name, model)
     settings.set_default(name, model)
-    print("  " + green("listo") + " · " + name + " · " + (when model == "" then preset["model"] otherwise model) + dim("   (cambialo cuando quieras con /setup o /provider)"))
+    print("  " + green("✓ " + name + " · " + model + " · guardado") + dim("   (/model para cambiarlo; /model <proveedor> [modelo] va directo)"))
     give true
 
+-- `/model x y` · `/provider x y` · `/setup`: args → (proveedor, modelo). Un solo arg que no es proveedor =
+-- modelo del proveedor actual.
+task setup_from_args(rest, cur_name, cur_model)
+    let args be where(split(trim(rest), " "), (x) => x != "")
+    when length(args) == 0
+        give setup_wizard("", "", cur_name, cur_model)
+    when length(args) == 1 and not contains(provider.PRESETS, lower(args[0]))
+        give setup_wizard(cur_name, args[0], cur_name, cur_model)
+    give setup_wizard(args[0], when length(args) > 1 then args[1] otherwise "", cur_name, cur_model)
+
 -- ---------- 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
@@ -671,10 +771,14 @@ 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()
+    when setup_wizard("", "", cfg["provider"], cfg["model"])
         set cfg to provider.config()
 let env_info be agents.env_info(cfg)
 let profile be lower(env("LAMPSON_AGENT", "build"))
+-- `--agent worker` (o cualquier nombre desconocido): worker es interno de delegate, no un perfil de sesión
+when not contains(agents.names(), profile)
+    print("agente '" + profile + "' no disponible · disponibles: " + join(agents.names(), ", ") + " · uso build")
+    set profile to "build"
 task system_for(p)
     give {"role": "system", "content": prompt.build(env_info, agents.addendum_for(p))}
 task opts_for(p, mode)
@@ -918,34 +1022,10 @@ while running
             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()
+        otherwise when starts_with(input, "/model") or starts_with(input, "/provider") or starts_with(input, "/setup")
+            -- un solo flujo (ver setup_wizard): proveedor → modelo (lista de la API) → key si falta; se guarda en config.json
+            let rest be trim(replace_re(input, "^/(model|provider|setup)", ""))
+            when setup_from_args(rest, cfg["provider"], cfg["model"])
                 set cfg to provider.config()
         otherwise when input == "/paste"
             attach_image("clip", "")
@@ -955,9 +1035,16 @@ while running
                 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"
+                    print("  " + text(length(pending_images)) + " imagen(es) pendiente(s) — se mandan con tu próximo mensaje.")
+                    flush()
+                    let ipick be ed.choose("  ¿qué hago con ellas?", ["dejarlas", "quitarlas"], COLOR)
+                    when ipick == -1
+                        print("  ¿Quitarlas? (s/N)")
+                        let a be read_line("  ")
+                        when a != nothing and lower(trim(a)) == "s"
+                            set pending_images to []
+                            print("  quitadas")
+                    otherwise when ipick == 1
                         set pending_images to []
                         print("  quitadas")
             otherwise
@@ -969,7 +1056,12 @@ while running
             otherwise when id == sid
                 print("  esa es la sesión actual; hacé /new primero")
             otherwise
-                print("  " + session.delete(id))
+                flush()
+                let dpick be ed.choose("  ¿borrar la sesión " + id + "?", ["cancelar", "borrar"], COLOR)
+                when dpick == 1 or dpick == -1   -- sin TTY el comando ya es explícito: borra
+                    print("  " + session.delete(id))
+                otherwise
+                    print("  (no se borró)")
         otherwise when input == "/new"
             set sid to session.new_id()
             set messages to [system_msg]
@@ -1126,14 +1218,29 @@ while running
                     print("      " + dim("permisos " + s["permission"] + " · próxima " + s["next_local"] + (when s["last_run"] != nothing then " · última " + s["last_status"] + ": " + first_line(s["last_summary"], 80) otherwise "")))
                 let pend be approvals.pending()
                 each ap in pend
-                    print("  " + yellow("⚠ aprobación pendiente " + ap["id"] + ": " + first_line(ap["message"], 100)) + dim("  → /approve " + ap["id"] + " yes|no"))
+                    print("  " + yellow("⚠ aprobación pendiente " + ap["id"] + ": " + first_line(ap["message"], 100)) + dim("  → /approve " + ap["id"]))
                 print("  " + dim("corren solas mientras lampson esté abierto (tick cada " + text(schedule.TICK_SECONDS) + " s) · con todo cerrado: lampson --daemon start · run/on/off/remove/log <id>"))
         otherwise when starts_with(input, "/approve ")
             let atoks be where(split(trim(slice(input, 9, length(input))), " "), (x) => x != "")
-            when length(atoks) < 2 or not contains(["yes", "no", "si", "sí", "y", "n"], lower(atoks[1]))
+            let yes be false
+            let answered be false
+            when length(atoks) == 1
+                -- «/approve <id>» a secas: menú ↑↓ (sin TTY, el uso de siempre)
+                flush()
+                let apick be ed.choose("  aprobación " + atoks[0], ["permitir", "denegar"], COLOR)
+                when apick == -1
+                    print("  uso: /approve <id> yes|no   (pendientes: /schedule)")
+                otherwise when apick == nothing
+                    print("  (sin responder)")
+                otherwise
+                    set yes to apick == 0
+                    set answered to true
+            otherwise when length(atoks) < 2 or not contains(["yes", "no", "si", "sí", "y", "n"], lower(atoks[1]))
                 print("  uso: /approve <id> yes|no   (pendientes: /schedule)")
             otherwise
-                let yes be contains(["yes", "si", "sí", "y"], lower(atoks[1]))
+                set yes to contains(["yes", "si", "sí", "y"], lower(atoks[1]))
+                set answered to true
+            when answered
                 when approvals.answer(atoks[0], yes)
                     print("  " + (when yes then green("✓ permitido ") otherwise red("✗ denegado ")) + atoks[0])
                 otherwise
@@ -1230,7 +1337,7 @@ while running
             let want be trim(slice(input, 6, length(input)))
             when want == ""
                 print("agente=" + profile + " · disponibles: " + join(agents.names(), ", "))
-            otherwise when contains(agents.PROFILES, want)
+            otherwise when contains(agents.names(), want)
                 set profile to want
                 set system_msg to system_for(profile)
                 set opts to opts_for(profile, mode)

package/hub.tpl.syn

@@ -57,13 +57,21 @@ serve on 8080
     -- la UI de un workspace: el mismo index.html; el frontend deduce /w/<slug> de la URL (BASE en js/core.js).
     -- Sin barra final: el runtime normaliza "/w/x/" → "/w/x" (301), así que la ruta canónica es esta
     route "GET /w/:slug"
+        -- entrar a un workspace apagado lo enciende (y levanta la pausa manual): si alguien abre la URL es para usarlo
+        let w be ws.get(params.slug)
+        when w != nothing and ws.health(w) == nothing
+            ws.start_ws(w)
+            ws.wait_ready(w, 8)
+            ws.summary()
         give html(read_file("public/index.html"))
 
     route "GET /api/hub" requires auth
         give {"ok": true, "port": ws.HUB_PORT, "idle_hours": ws.idle_hours(), "home": ws.home()}
 
     route "GET /api/workspaces" requires auth
-        give {"workspaces": ws.summary(), "idle_hours": ws.idle_hours()}
+        -- la caché del blackboard (tick + acciones) salvo ?fresh=1: la UI lo pide tras encender/apagar
+        let fresh be contains(query, "fresh")
+        give {"workspaces": when fresh then ws.summary() otherwise ws.summary_cached(20), "idle_hours": ws.idle_hours()}
 
     -- registrar una carpeta como workspace (y arrancarla)
     route "POST /api/workspaces" requires auth
@@ -73,6 +81,7 @@ serve on 8080
             let w be ws.ensure(text(b["path"]))
             ws.start_ws(w)
             ws.wait_ready(w, 8)
+            ws.summary()
             give {"ok": true, "workspace": w, "url": "/w/" + w["slug"] + "/"}
         recover err
             give fail(400, text(err))
@@ -84,7 +93,9 @@ serve on 8080
         when w == nothing
             give not_found("no such workspace")
         ws.start_ws(w)
-        give {"ok": ws.wait_ready(w, 8)}
+        let ok be ws.wait_ready(w, 8)
+        ws.summary()
+        give {"ok": ok}
 
     route "POST /api/workspaces/stop" requires auth
         expect body {slug: text}
@@ -92,13 +103,15 @@ serve on 8080
         let w be ws.get(text(b["slug"]))
         when w == nothing
             give not_found("no such workspace")
-        give {"ok": ws.stop_ws(w)}
+        give {"ok": ws.pause_ws(w)}
 
     route "POST /api/workspaces/remove" requires auth
         expect body {slug: text}
         let b be json of request
         try
-            give {"ok": true, "result": ws.remove(text(b["slug"]))}
+            let res be ws.remove(text(b["slug"]))
+            ws.summary()
+            give {"ok": true, "result": res}
         recover err
             give fail(400, text(err))
 
@@ -113,6 +126,7 @@ serve on 8080
             give fail(400, "policy must be auto | always | off")
         set w["policy"] to text(b["policy"])
         ws.put(w)
+        ws.summary()
         give {"ok": true}
 
     -- diálogo nativo del SO (PC); nothing → la UI usa el explorador propio

package/lib/line.syn

@@ -320,7 +320,10 @@ export task read(prompt, color, ctx)
     term_close(h)
     give result
 
--- menú vertical de opciones (aprobaciones): ↑↓ + Enter, o la letra inicial / número; Esc = nothing
+-- menú vertical de opciones (aprobaciones, /setup, confirmaciones): ↑↓ + Enter, o la letra inicial /
+-- número; Esc = nothing. La activa lleva ❯ y color; debajo, la línea de ayuda. Las opciones llegan en
+-- TEXTO PLANO (sin ANSI): el menú es el que pinta, y un reset de color adentro le cortaría la línea.
+let CHOOSE_HELP be "Enter confirma · Esc cancela"
 export task choose(question, options, color)
     let h be term_open({"ctrl_c": "exit"})
     when h == nothing
@@ -329,6 +332,11 @@ export task choose(question, options, color)
     let done be false
     let result be nothing
     let drawn be 0
+    -- Reservar el alto del bloque ANTES de dibujarlo: al pie de la pantalla esto scrollea una sola vez y
+    -- deja el menú entero a la vista. Sin esto, el ESC[nA del redibujo apunta a una línea que el scroll
+    -- movió y el menú aparece duplicado más abajo en cada tecla (visto con los 9 proveedores de /setup).
+    let need be length(options) + 2
+    term_write(h, rep("\n", need) + ESC + "[" + text(need) + "A")
     while not done
         let out be ""
         when drawn > 0
@@ -336,10 +344,11 @@ export task choose(question, options, color)
         set out to out + "\r" + ESC + "[J" + question
         let i be 0
         each o in options
-            set out to out + "\r\n" + "    " + (when i == sel then sgr(color, "7", " " + o + " ") otherwise " " + sgr(color, "2", o))
+            set out to out + "\r\n" + (when i == sel then "  " + sgr(color, "1;36", "❯ " + o) otherwise "    " + sgr(color, "2", o))
             set i to i + 1
+        set out to out + "\r\n\r\n  " + sgr(color, "2", CHOOSE_HELP)
         term_write(h, out)
-        set drawn to length(options)
+        set drawn to length(options) + 2   -- una línea por opción + la vacía + la de ayuda
         let ev be term_recv(h, 600)
         when ev == nothing
             set result to nothing
@@ -361,9 +370,11 @@ export task choose(question, options, color)
                 let t be lower(ev["text"])
                 let j be 0
                 each o in options
-                    when t == text(j + 1) or t == lower(slice(o, 0, 1))
-                        set result to j
-                        set done to true
+                    -- la PRIMERA que coincide gana: con 9 proveedores hay iniciales repetidas (o, g…)
+                    when not done
+                        when t == text(j + 1) or t == lower(slice(o, 0, 1))
+                            set result to j
+                            set done to true
                     set j to j + 1
     term_write(h, "\r\n")
     term_close(h)

package/lib/provider.syn

@@ -36,7 +36,9 @@ export let PRESETS be {
     "openrouter": {"wire": "openai",    "base_url": "https://openrouter.ai/api/v1",      "model": "deepseek/deepseek-chat"},
     "ollama":     {"wire": "openai",    "base_url": "http://127.0.0.1:11434/v1",         "model": "qwen2.5-coder"},
     "anthropic":  {"wire": "anthropic", "base_url": "https://api.anthropic.com/v1",      "model": "claude-sonnet-4-6"},
-    "minimax":    {"wire": "anthropic", "base_url": "https://api.minimax.io/anthropic/v1", "model": "MiniMax-M3"}
+    "minimax":    {"wire": "anthropic", "base_url": "https://api.minimax.io/anthropic/v1", "model": "MiniMax-M3"},
+    -- Z.ai (Zhipu): API compatible con OpenAI. Coding Plan: LAMPSON_BASE_URL=https://api.z.ai/api/coding/paas/v4
+    "glm":        {"wire": "openai",    "base_url": "https://api.z.ai/api/paas/v4",       "model": "glm-5.3"}
 }
 
 -- Keys: una por proveedor en .env como LAMPSON_API_KEY_<PROVIDER> (LAMPSON_API_KEY_DEEPSEEK, _ANTHROPIC…);
@@ -95,7 +97,7 @@ export task providers()
 -- Nombres de modelo: DeepSeek, OpenAI, Anthropic, Groq, Kimi, Grok y OpenRouter publican ids en minúsculas
 -- y la API rechaza otra capitalización ("deepseek-v4-pro" sí, "DeepSeek-V4-Pro" → 400 invalid_request_error,
 -- visto 2026-08-27 con un nombre tipeado en /setup). MiniMax ("MiniMax-M3") y Ollama (tags) se dejan tal cual.
-let LOWERCASE_MODELS be ["deepseek", "openai", "anthropic", "groq", "kimi", "grok", "openrouter"]
+let LOWERCASE_MODELS be ["deepseek", "openai", "anthropic", "groq", "kimi", "grok", "openrouter", "glm"]
 
 export task normalize_model(name, model)
     let m be trim(text(model))
@@ -255,6 +257,9 @@ export task supports_vision(cfg)
         give contains(m, "vision") or starts_with(m, "grok-4")
     when p == "kimi"
         give contains(m, "vision") or contains(m, "vl")
+    -- GLM: los modelos con visión llevan sufijo v (glm-4.5v, glm-4.6v)
+    when p == "glm"
+        give contains(m, "vision") or ends_with(m, "v") or contains(m, "v-")
     give false
 
 -- Modelo sin visión: la imagen se reemplaza por una nota que el modelo puede explicarle al usuario