lampson 0.2.4 → 0.2.6

package/chat.syn

@@ -79,6 +79,10 @@ task dim(s)
     give c("2", s)
 task yellow(s)
     give c("33", s)
+-- actividad de tools (▸, $): amarillo atenuado, para que el 33 pleno quede solo como "atención
+-- requerida" (⚠ aprobaciones, avisos) — semáforo: actividad ≠ advertencia (2026-08-31)
+task act(s)
+    give c("2;33", s)
 task green(s)
     give c("32", s)
 task red(s)
@@ -276,7 +280,7 @@ task on_event(kind, data, tag)
             set pending_call to desc
         otherwise
             set pending_call to ""
-            print("  " + yellow("▸ " + desc))
+            print("  " + act("▸ " + desc))
     otherwise when kind == "tool_result"
         let out be data["output"]
         let name be data["call"]["name"]
@@ -284,7 +288,7 @@ task on_event(kind, data, tag)
         let d be diff_of(name, out)
         let path be when d != nothing then text(data["call"]["args"]["path"]) otherwise ""
         set turn_outputs to append(turn_outputs, {"name": name, "args": data["call"]["args"], "output": out, "diff": d, "path": path})
-        let lead be when pending_call != "" then "  " + yellow("▸ " + pending_call) + "  " otherwise "    "
+        let lead be when pending_call != "" then "  " + act("▸ " + pending_call) + "  " otherwise "    "
         set pending_call to ""
         when d != nothing
             print_diff_with(lead, path, d)
@@ -329,9 +333,7 @@ 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, con confirmación (ver /sessions)"],
@@ -381,7 +383,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 +422,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,51 +600,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("")
-    let list be provider.providers()
-    -- menú ↑↓/Enter (o inicial / número) cuando hay TTY; sin TTY, la lista numerada + read_line de siempre.
-    -- Las etiquetas van en texto plano: las pinta el menú (ver lib/line.syn).
-    let labels be []
-    each p in list
-        set labels to append(labels, pad(p["name"], 12) + pad(p["model"], 26) + (when p["name"] == "ollama" then "(local, sin key)" otherwise (when p["has_key"] then "● key guardada" otherwise "")))
+-- ---------- /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("  " + cyan("Configuremos el modelo.") + " Elegí un proveedor:", labels, COLOR)
-    let name be ""
+    let pick be ed.choose("  " + question, labels, COLOR)
     when pick == nothing
-        print("  (sin cambios)")
+        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) == ""
+        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
-    otherwise when pick == -1
-        print("  " + cyan("Configuremos el modelo.") + " Elegí un proveedor (número o nombre):")
-        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) == ""
+    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
-        set name to 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))
+    when not contains(provider.PRESETS, 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
-    otherwise
-        set name to list[pick]["name"]
-    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))
+    -- 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
+    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
@@ -685,10 +775,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)
@@ -925,41 +1019,17 @@ while running
                 print(dim("  hay " + text(length(turn_outputs)) + " resultados en este turno: /out 1 … /out " + text(length(turn_outputs))))
             otherwise
                 let o be turn_outputs[length(turn_outputs) - back]
-                print("  " + yellow("▸ " + permission.describe_call(o["name"], o["args"])))
+                print("  " + act("▸ " + permission.describe_call(o["name"], o["args"])))
                 print_full(o)
         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()
+        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", "")
@@ -1271,7 +1341,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)
@@ -1288,7 +1358,7 @@ while running
             when cmd == ""
                 print("  uso: !<comando>   p.ej. !git status · !npm test · !cat .env")
             otherwise
-                print("  " + yellow("$ " + cmd))
+                print("  " + act("$ " + 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)})

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/diff.syn

@@ -8,6 +8,10 @@ use "./ui.syn" as ui
 
 let ESC be decode(bytes("1b", "hex"))
 let LIMIT be 80
+-- corridas largas de +/- se colapsan: HEAD líneas, "⋮ ±N líneas más", TAIL líneas (un rewrite de 200
+-- líneas pintaba 200 rojas + 200 verdes; el diff completo sigue en la UI web, que recibe old/new crudos)
+let HEAD be 4
+let TAIL be 2
 
 -- línea de diff con fondo (verde/rojo) rellenada hasta el ancho útil, cortada si se pasa
 task row(color, kind, num, body, width)
@@ -40,6 +44,26 @@ task lpad(s, n)
         set out to " " + out
     give out
 
+-- vuelca una corrida de líneas +/- ya formateadas: entera si es corta, colapsada si supera HEAD+TAIL+1
+task flush_run(lines, rows, op, color, width)
+    when length(rows) <= HEAD + TAIL + 1
+        each r in rows
+            set lines to append(lines, r)
+        give lines
+    let i be 0
+    while i < HEAD
+        set lines to append(lines, rows[i])
+        set i to i + 1
+    let hidden be length(rows) - HEAD - TAIL
+    let sign be when op == "+" then "+" otherwise "−"
+    let code be when op == "+" then "32;2" otherwise "31;2"
+    set lines to append(lines, sgr(color, code, lpad("", width) + " ⋮ " + sign + text(hidden) + " líneas más"))
+    set i to length(rows) - TAIL
+    while i < length(rows)
+        set lines to append(lines, rows[i])
+        set i to i + 1
+    give lines
+
 -- LCS clásico: devuelve la lista de ops {"op": " "|"-"|"+", "a": idx_old, "b": idx_new}
 task lcs_ops(a, b)
     let n be length(a)
@@ -135,6 +159,9 @@ export task diff(old, new, ctx, color)
         set idx to idx + 1
     set idx to 0
     let skipping be false
+    -- corrida de +/- consecutivos: se junta y se vuelca colapsada (flush_run) al cambiar de tipo
+    let run_op be ""
+    let run_rows be []
     each o in ops
         let near be false
         let w be idx - ctx
@@ -142,6 +169,10 @@ export task diff(old, new, ctx, color)
             when w >= 0 and w < length(ops) and ops[w]["op"] != " "
                 set near to true
             set w to w + 1
+        when o["op"] != run_op and run_op != ""
+            set lines to flush_run(lines, run_rows, run_op, color, width)
+            set run_op to ""
+            set run_rows to []
         when o["op"] == " "
             when near
                 set lines to append(lines, row(color, " ", text(pre + o["b"] + 1), mid_b[o["b"]], width))
@@ -150,12 +181,16 @@ export task diff(old, new, ctx, color)
                 set lines to append(lines, sgr(color, "2", lpad("", width) + " ⋯"))
                 set skipping to true
         otherwise when o["op"] == "-"
-            set lines to append(lines, row(color, "-", text(pre + o["a"] + 1), mid_a[o["a"]], width))
+            set run_op to "-"
+            set run_rows to append(run_rows, row(color, "-", text(pre + o["a"] + 1), mid_a[o["a"]], width))
             set skipping to false
         otherwise
-            set lines to append(lines, row(color, "+", text(pre + o["b"] + 1), mid_b[o["b"]], width))
+            set run_op to "+"
+            set run_rows to append(run_rows, row(color, "+", text(pre + o["b"] + 1), mid_b[o["b"]], width))
             set skipping to false
         set idx to idx + 1
+    when run_op != ""
+        set lines to flush_run(lines, run_rows, run_op, color, width)
     -- contexto posterior (del sufijo común)
     let after_start be length(b) - suf
     let upto be when after_start + ctx < length(b) then after_start + ctx otherwise length(b)

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

package/lib/tools/common.syn

@@ -11,6 +11,13 @@ export let ROOT be "workspace"
 export let MAX_OUTPUT be 30000
 export let IGNORED_DIRS be [".git", "node_modules", ".synsema", ".lampson", "workspace", "target", "dist", "build", "coverage", "__pycache__", ".venv", ".next", ".netlify", ".cache", ".turbo"]
 
+-- true si algún segmento del path es ".." (no cuenta "foo..bar")
+task has_dotdot(p)
+    each part in split(p, "/")
+        when part == ".."
+            give true
+    give false
+
 -- path del modelo → path real bajo workspace/
 export task ws(path)
     let p be when path == nothing then "." otherwise replace_text(text(path), "\\", "/")
@@ -22,6 +29,12 @@ export task ws(path)
             set p to slice(p, 1, length(p))
         otherwise
             set stripping to false
+    -- escape del workspace (C:\… o ..): mensaje instructivo ANTES del runtime. Sin esto el modelo
+    -- recibía "Capability not granted: file_write(…)" (con ..) u "os error 123" (con C:\…, que parece
+    -- un error de sintaxis de la ruta) y quemaba reintentos probando variantes (visto 2026-08-31:
+    -- quiso guardar una "memoria global" fuera del workspace, como el install global de skills).
+    when contains(split(p, "/")[0], ":") or has_dotdot(p)
+        raise("path escapes the workspace: \"" + text(path) + "\" — file tools only reach the mounted workspace; use paths relative to its root (e.g. \"src/app.ts\"). Do not retry with other path variants. To keep notes across sessions use the memory tool (the harness stores them per project, outside the repo); for anything else outside the workspace, explain what you need and ask the user.")
     when p == "." or p == "" or p == ROOT
         give ROOT
     when starts_with(p, ROOT + "/")