lampson 0.2.8 → 0.2.10

package/lib/loop.syn

@@ -27,6 +27,23 @@ use "./plugins.syn" as plugins
 use "./tools/todo.syn" as todo
 
 let MAX_ERRORS_PER_TURN be 8
+-- capturas de computer_use (lib/computer.syn): el driver las deja en el blackboard "computer:screenshot" y acá van al
+-- modelo como imagen adjunta a un mensaje de usuario (un tool result es texto en todos los proveedores). Solo la más
+-- reciente viaja con la imagen; las anteriores quedan como nota (≈1500 tokens cada una, en CADA request).
+let SHOT_PREFIX be "[harness] Screenshot from computer_use: "
+
+export task drop_old_screenshots(msgs)
+    let out be []
+    each m in msgs
+        let is_shot be false
+        when m["role"] == "user"
+            when contains(m, "images")
+                set is_shot to starts_with(text(m["content"]), SHOT_PREFIX)
+        when is_shot
+            set out to append(out, {"role": "user", "content": text(m["content"]) + " [image removed to save context]"})
+        otherwise
+            set out to append(out, m)
+    give out
 -- Conciencia de progreso (2026-08-28, la mejor idea de cada harness — ver notes/*.md):
 --   * SPILL (deepseek): un resultado > SPILL_CAP se guarda entero en .lampson/spill/<call>.txt y el modelo ve
 --     cabeza + cola + "Full result saved to …"; `read` queda exento (ya pagina con offset/limit).
@@ -107,7 +124,7 @@ export task spill(name, id, out)
     let path be SPILL_DIR + "/" + id + ".txt"
     write_file(path, out)
     let half be floor(SPILL_CAP / 2)
-    give slice(out, 0, half) + "\n\n[... " + text(length(out) - SPILL_CAP) + " chars omitted. Full result saved to " + path + " — grep it, or read it with offset/limit; do not re-run the command ...]\n\n" + slice(out, length(out) - half, length(out))
+    give slice(out, 0, half) + "\n\n[... " + text(length(out) - SPILL_CAP) + " chars omitted. Full result saved to " + path + " — use the grep or read TOOLS on that exact path (it lives in lampson, outside your workspace: bash cannot see it); do not re-run the command ...]\n\n" + slice(out, length(out) - half, length(out))
 
 -- recibo de una línea para un tool result viejo
 export task receipt(m)
@@ -116,13 +133,13 @@ export task receipt(m)
         give out
     let status be "ok"
     when starts_with(out, "ERROR") or starts_with(out, "DENIED")
-        set status to slice(replace_text(split(out, "\n")[0], "\r", ""), 0, 120)
+        set status to slice(replace(split(out, "\n")[0], "\r", ""), 0, 120)
     otherwise
-        let codes be find_all(out, "\\[exit code [0-9]+\\]")
+        let codes be regex_find_all(out, "\\[exit code [0-9]+\\]")
         when length(codes) > 0
             let last be codes[length(codes) - 1]
             set status to slice(last, 1, length(last) - 1)
-    let saved be find_all(out, "Full result saved to [^ ]+")
+    let saved be regex_find_all(out, "Full result saved to [^ ]+")
     let where_full be when length(saved) > 0 then " · " + saved[0] otherwise ""
     give "[" + text(m["name"]) + " result pruned: " + status + " · " + text(length(split(out, "\n"))) + " lines/" + text(length(out)) + " chars" + where_full + " — re-run the tool only if you really need the content again]"
 
@@ -324,6 +341,8 @@ export task run_turn(cfg, messages, opts, on_event)
     let max_steps be opts["max_steps"]
     let budget be opts["budget_tokens"]
     let tag be opts["tag"]
+    -- ¿este modelo acepta imágenes? lo leen las tools que producen capturas (computer_use) para avisar al modelo
+    share provider.supports_vision(cfg) as "lampson:vision"
     -- compaction preventiva
     when estimate_tokens(msgs) > opts["compact_at_tokens"]
         emit(on_event, "compact", {"before": estimate_tokens(msgs)}, tag)
@@ -376,6 +395,11 @@ export task run_turn(cfg, messages, opts, on_event)
         emit(on_event, "usage", {"step": steps, "usage": r["usage"], "total": usage}, tag)
         let clean_text be strip_raw_tool_calls(r["text"])
         let assistant be {"role": "assistant", "content": clean_text, "tool_calls": r["tool_calls"]}
+        -- razonamiento del paso (solo lo trae el wire para los presets glm): va en el mensaje para
+        -- devolvérselo al modelo en el paso siguiente (thinking conservado, ver provider.chat_openai)
+        when contains(r, "reasoning")
+            when r["reasoning"] != ""
+                set assistant["reasoning"] to r["reasoning"]
         set msgs to append(msgs, assistant)
         when clean_text != ""
             emit(on_event, "assistant", clean_text, tag)
@@ -422,6 +446,14 @@ export task run_turn(cfg, messages, opts, on_event)
                 set errors to errors + 1
             emit(on_event, "tool_result", {"call": tc, "output": out}, tag)
             set msgs to append(msgs, tool_result_msg(tc, out))
+            -- captura de pantalla pendiente (computer_use): adjunta como imagen si el proveedor tiene visión
+            observe "computer:screenshot" as shot
+            when shot != nothing
+                share nothing as "computer:screenshot"
+                when provider.supports_vision(cfg)
+                    set msgs to drop_old_screenshots(msgs)
+                    set msgs to append(msgs, {"role": "user", "content": SHOT_PREFIX + shot["label"] + ". Look at it, then continue the task.", "images": shot["images"]})
+                    emit(on_event, "inbox", "captura de pantalla adjunta al modelo (" + shot["label"] + ")", tag)
         when errors >= MAX_ERRORS_PER_TURN
             set msgs to append(msgs, {"role": "user", "content": "[harness] Too many tool errors this turn. Stop calling tools and report what happened."})
             emit(on_event, "busy", {"label": "pensando", "kind": "llm"}, tag)

package/lib/lsp.syn

@@ -92,13 +92,13 @@ export task servers()
 -- resuelven realpaths, así que el rootUri y los uri de los documentos tienen que ser los reales.
 export task root_path()
     require env("LAMPSON_*")
-    let r be replace_text(env("LAMPSON_WORKSPACE", "workspace"), "\\", "/")
+    let r be replace(env("LAMPSON_WORKSPACE", "workspace"), "\\", "/")
     when c.ends_with(r, "/")
         set r to slice(r, 0, length(r) - 1)
     give r
 
 export task to_uri(path)
-    let p be replace_text(replace_text(path, "\\", "/"), " ", "%20")
+    let p be replace(replace(path, "\\", "/"), " ", "%20")
     when matches(p, "[A-Za-z]:/.*")
         give "file:///" + p
     give "file://" + p
@@ -109,7 +109,7 @@ export task from_uri(uri)
         set u to slice(u, 8, length(u))
     otherwise when starts_with(u, "file://")
         set u to slice(u, 7, length(u))
-    give replace_text(replace_text(replace_text(u, "%3A", ":"), "%3a", ":"), "%20", " ")
+    give replace(replace(replace(u, "%3A", ":"), "%3a", ":"), "%20", " ")
 
 -- uri del server → ruta relativa al workspace (o absoluta si cae fuera)
 export task relativize(uri, root)
@@ -123,7 +123,7 @@ export task relativize(uri, root)
     give p
 
 task ext_of(path)
-    let parts be split(replace_text(path, "\\", "/"), "/")
+    let parts be split(replace(path, "\\", "/"), "/")
     let base be parts[length(parts) - 1]
     let segs be split(base, ".")
     when length(segs) < 2

package/lib/mcp.syn

@@ -109,6 +109,24 @@ agent McpSup
         let sub be bus_subscribe(["mcp.req." + name, "mcp.stop." + name, "mcp.stop_all"])
         -- request síncrona (handshake y tools/list): manda y espera la respuesta con ese id, saltando
         -- notificaciones y basura; devuelve {result} | {error} | nothing (timeout / proceso muerto)
+        -- MIGA runtime (2026-09-06): proc_spawn en line_mode parte las líneas de más de 1 MiB en trozos de 1 MiB; un
+        -- resultado grande (una captura base64) llegaba en trozos que no decodificaban y la respuesta se perdía.
+        -- `acc` junta los trozos hasta que el JSON cierra; un trozo suelto que decodifica solo reinicia el acumulador.
+        let acc be ""
+        task decode_line(data)
+            let joined be acc + data
+            try
+                let m be json_decode(joined)
+                set acc to ""
+                give m
+            recover e1
+                try
+                    let m2 be json_decode(data)
+                    set acc to ""
+                    give m2
+                recover e2
+                    set acc to when length(joined) > 40000000 then "" otherwise joined
+                    give nothing
         task rpc(method, params, timeout)
             set seq to seq + 1
             let id be seq
@@ -122,12 +140,10 @@ agent McpSup
                 otherwise when ev["type"] == "exit"
                     set answer to {"error": "server exited with code " + text(ev["data"]["exit_code"])}
                 otherwise when ev["type"] == "stdout"
-                    try
-                        let m be json_decode(ev["data"])
+                    let m be decode_line(ev["data"])
+                    when m != nothing
                         when contains(m, "id") and m["id"] == id
                             set answer to when contains(m, "error") then {"error": text(m["error"]["message"])} otherwise {"result": m["result"]}
-                    recover e2
-                        set answer to answer
             give answer
         task notify(method, params)
             proc_send(p, json_encode({"jsonrpc": "2.0", "method": method, "params": params}) + "\n")

package/lib/md.syn

@@ -21,9 +21,9 @@ task width_now()
 task paths(s, color)
     when not color
         give s
-    let out be replace_re(s, "(^|[\s(])([\w.-]*/[\w./-]{2,})", "\1" + ESC + "[34m\2" + ESC + "[0m")
-    set out to replace_re(out, "(^|[\s(])(\w+\.(syn|js|ts|tsx|jsx|json|md|py|rs|go|ps1|sh|html|css|toml|yml|yaml|env))(\b)", "\1" + ESC + "[34m\2" + ESC + "[0m")
-    set out to replace_re(out, "(^|[\s(])(\w+\(\))", "\1" + ESC + "[34m\2" + ESC + "[0m")
+    let out be regex_replace(s, "(^|[\s(])([\w.-]*/[\w./-]{2,})", "\1" + ESC + "[34m\2" + ESC + "[0m")
+    set out to regex_replace(out, "(^|[\s(])(\w+\.(syn|js|ts|tsx|jsx|json|md|py|rs|go|ps1|sh|html|css|toml|yml|yaml|env))(\b)", "\1" + ESC + "[34m\2" + ESC + "[0m")
+    set out to regex_replace(out, "(^|[\s(])(\w+\(\))", "\1" + ESC + "[34m\2" + ESC + "[0m")
     give out
 
 task sgr(color, code, s)
@@ -42,16 +42,16 @@ task rep(ch, n)
 task emphasis(s, color)
     let out be s
     -- links [texto](url) → texto url  (antes que la cursiva: la url puede traer _ o *)
-    set out to replace_re(out, "\[([^\]]+)\]\(([^)]+)\)", sgr(color, "4", "\1") + sgr(color, "2", " \2"))
-    set out to replace_re(out, "\*\*([^*]+)\*\*", sgr(color, "1", "\1"))
-    set out to replace_re(out, "__([^_]+)__", sgr(color, "1", "\1"))
-    set out to replace_re(out, "~~([^~]+)~~", sgr(color, "9", "\1"))
+    set out to regex_replace(out, "\[([^\]]+)\]\(([^)]+)\)", sgr(color, "4", "\1") + sgr(color, "2", " \2"))
+    set out to regex_replace(out, "\*\*([^*]+)\*\*", sgr(color, "1", "\1"))
+    set out to regex_replace(out, "__([^_]+)__", sgr(color, "1", "\1"))
+    set out to regex_replace(out, "~~([^~]+)~~", sgr(color, "9", "\1"))
     -- cursiva: *x* solo si no está pegada a texto/número (2*3 no es cursiva). Dos pasadas:
     -- el grupo \3 consume el separador, así que "*a* *b*" necesita la segunda.
     let pass be 0
     while pass < 2
-        set out to replace_re(out, "(^|[^\w*])\*([^*\s][^*]*?)\*($|[^\w*])", "\1" + sgr(color, "3", "\2") + "\3")
-        set out to replace_re(out, "(^|[^\w_])_([^_\s][^_]*?)_($|[^\w_])", "\1" + sgr(color, "3", "\2") + "\3")
+        set out to regex_replace(out, "(^|[^\w*])\*([^*\s][^*]*?)\*($|[^\w*])", "\1" + sgr(color, "3", "\2") + "\3")
+        set out to regex_replace(out, "(^|[^\w_])_([^_\s][^_]*?)_($|[^\w_])", "\1" + sgr(color, "3", "\2") + "\3")
         set pass to pass + 1
     give out
 
@@ -162,8 +162,8 @@ export task render(md, color)
     let table be []
     each line in split(md, "\n")
         let t be trim(line)
-        let heading be capture(t, "^(#{1,6}) (.+)$")
-        let item be capture(t, "^(\d{1,3})[.)] (.*)$")
+        let heading be regex_capture(t, "^(#{1,6}) (.+)$")
+        let item be regex_capture(t, "^(\d{1,3})[.)] (.*)$")
         let is_row be starts_with(t, "|") and ends_with(t, "|") and not in_code
         when length(table) > 0 and not is_row
             each l in table_lines(table, pre, color)

package/lib/origin.syn

@@ -0,0 +1,67 @@
+-- lib/origin.syn — de dónde viene una petición HTTP: la usan el hub (hub.tpl.syn, lib/auth.syn) y cada workspace (web.syn).
+--
+-- «Local» (esta PC, entra sin passkey) se PRUEBA con las tres cosas a la vez, nunca se deduce de lo que falta:
+--   1. el peer es loopback;
+--   2. no pasó por ningún proxy (sin X-Forwarded-*, Forwarded ni los headers de cloudflared);
+--   3. el Host CRUDO es un nombre de loopback. Un túnel (syn tunnel, cloudflared, ngrok) o el edge de --domain
+--      traen el Host público; una página con DNS rebinding trae el suyo.
+-- Desde el motor v0.6.42 los X-Forwarded-* de un peer que no está en `trust proxy` se borran antes del programa. El
+-- hub y los workspaces confían en loopback (`trust proxy` / `--trust-proxy`): ahí conectan los túneles, el edge y el
+-- proxy del hub, así que lo que dicen llega y `ip of request` es el cliente real. Sin eso, un syn tunnel entraba
+-- como «esta PC» (2026-10-05). Un túnel TCP crudo (ssh -R, ngrok tcp) no deja rastro y no se puede distinguir:
+-- nunca se apunta uno al hub.
+--
+-- Otra origin en el navegador — CSRF, un WebSocket abierto desde otra página, DNS rebinding — se rechaza siempre,
+-- local o remoto: un navegador manda Origin en todo POST, en todo WebSocket y en los fetch entre origins, y tiene
+-- que coincidir con la origin de la propia petición. Sin Origin (curl, scripts, navegación) no hay sitio ajeno.
+-- Módulo puro: sin require.
+
+let FORWARD_HEADERS be ["x-forwarded-for", "x-forwarded-host", "x-forwarded-proto", "forwarded", "x-real-ip", "cf-connecting-ip", "cf-ray"]
+let LOOPBACK_NAMES be ["localhost", "127.0.0.1", "::1"]
+
+export task is_loopback(ip)
+    give ip == "127.0.0.1" or ip == "::1" or ip == "::ffff:127.0.0.1"
+
+-- valor de Host (o X-Forwarded-Host) → nombre sin puerto ni corchetes, en minúsculas
+export task host_name(value)
+    let h be trim(split(lower(text(value)), ",")[0])
+    when starts_with(h, "[")
+        give split(slice(h, 1, length(h)), "]")[0]
+    give split(h, ":")[0]
+
+-- "host[:puerto]" como lo vio el navegador: el que puso el proxy de confianza, o el Host si no hubo proxy
+task authority(headers)
+    give trim(split(lower(text(get(headers, "x-forwarded-host", get(headers, "host", "")))), ",")[0])
+
+-- el Host que llegó a ESTE servidor (un proxy lo reescribe al suyo; el de afuera queda en X-Forwarded-Host)
+export task raw_host(headers)
+    give host_name(get(headers, "host", ""))
+
+-- el dominio que ve el usuario: rp_id de WebAuthn
+export task public_host(headers)
+    give host_name(authority(headers))
+
+-- la origin que ve el navegador. Lampson no termina TLS en el hub ni en los workspaces: sin un proxy de confianza
+-- que diga https (el edge, un túnel), es http
+export task origin_of(headers)
+    let proto be lower(trim(split(text(get(headers, "x-forwarded-proto", "")), ",")[0]))
+    when proto == ""
+        set proto to "http"
+    give proto + "://" + authority(headers)
+
+export task forwarded(headers)
+    each h in FORWARD_HEADERS
+        when contains(headers, h)
+            give true
+    give false
+
+export task loopback_host(headers)
+    give contains(LOOPBACK_NAMES, raw_host(headers))
+
+export task cross_site(headers)
+    when not contains(headers, "origin")
+        give false
+    give lower(trim(text(headers["origin"]))) != origin_of(headers)
+
+export task is_local(ip, headers)
+    give is_loopback(ip) and not forwarded(headers) and loopback_host(headers)

package/lib/permission.syn

@@ -10,6 +10,7 @@
 -- Modos (LAMPSON_PERMISSION): "ask" (default) | "yolo" (dangerous → allow) | "strict" (dangerous → deny)
 
 use "./tools/url.syn" as u
+use "./computer.syn" as computer
 
 -- Tier 1: nunca. Coincidencia por substring, case-insensitive.
 -- (el comando se evalúa con un espacio final añadido, así "rm -rf / " matchea la raíz pero NO "rm -rf /tmp/x")
@@ -94,7 +95,7 @@ export task evaluate(name, args, mode)
         give {"decision": "allow", "reason": "public URL"}
     when name == "write" or name == "edit"
         -- el scope file("./*") ya impide salir del workspace; aquí solo miramos secretos obvios
-        let p be when contains(args, "path") then lower(replace_text(text(args["path"]), "\\", "/")) otherwise ""
+        let p be when contains(args, "path") then lower(replace(text(args["path"]), "\\", "/")) otherwise ""
         let parts be split(p, "/")
         let base be parts[length(parts) - 1]
         when is_secret_env(base)
@@ -153,11 +154,27 @@ export task evaluate(name, args, mode)
         when mode == "strict"
             give {"decision": "deny", "reason": "strict mode (installs a third-party skill)"}
         give {"decision": "ask", "reason": "installs a third-party skill from " + (when contains(args, "source") then text(args["source"]) otherwise "?") + " (" + (when contains(args, "scope") then text(args["scope"]) otherwise "global") + ")"}
+    when name == "computer_use"
+        -- el escritorio del usuario (lib/computer.syn): leer (ventanas, árbol, capturas, texto) siempre; actuar pide UNA
+        -- sola vez por corrida — la primera acción — y cubre todo lo demás (teclas en foreground, abrir apps y
+        -- navegadores): pedir por cada cosa hacía inútil la tool (2026-09-06: cuatro pedidos para llenar un form).
+        -- La tool deja "computer:grant" en el blackboard al ejecutar la primera aprobada. strict deniega actuar.
+        let cact be when contains(args, "action") then lower(text(args["action"])) otherwise ""
+        when not contains(computer.ACTING, cact)
+            give {"decision": "allow", "reason": "read-only tool"}
+        when mode == "yolo"
+            give {"decision": "allow", "reason": "yolo mode (computer " + cact + ")"}
+        when mode == "strict"
+            give {"decision": "deny", "reason": "strict mode (computer " + cact + ")"}
+        observe "computer:grant" as granted
+        when granted == true
+            give {"decision": "allow", "reason": "desktop control granted this run"}
+        give {"decision": "ask", "reason": "takes control of your desktop for the rest of this run — clicks and keys in the background (briefly to the front when an app needs it), opening apps and browser windows; asked once"}
     give {"decision": "allow", "reason": "read-only tool"}
 
 -- Resumen legible de una tool call, para mostrar al humano antes de aprobar / en el log.
 task one_line(s, max)
-    let t be replace_text(replace_text(s, "\r", ""), "\n", " ⏎ ")
+    let t be replace(replace(s, "\r", ""), "\n", " ⏎ ")
     when length(t) > max
         give slice(t, 0, max) + "…"
     give t
@@ -165,6 +182,8 @@ task one_line(s, max)
 export task describe_call(name, args)
     when starts_with(name, "mcp_") or starts_with(name, "plugin_")
         give name + " " + one_line(json_encode(args), 160)
+    when name == "computer_use"
+        give computer.describe(args)
     when name == "lsp" and contains(args, "op") and text(args["op"]) == "add"
         give "lsp add " + (when contains(args, "server") then text(args["server"]) otherwise "?") + " (" + (when contains(args, "scope") then text(args["scope"]) otherwise "global") + ")"
     when name == "lsp"

package/lib/prompt.syn

@@ -6,6 +6,7 @@
 
 use "./skills.syn" as skills
 use "./tools/memo.syn" as memo
+use "./computer.syn" as computer
 
 let CONTEXT_FILES be ["AGENTS.md", "LAMPSON.md"]
 
@@ -22,13 +23,20 @@ task read_context_files()
     give out
 
 export task build(env_info, addendum)
+    require exec
+    require time
     require file.read("workspace")
     require file.read("workspace/*")
     require file.read("skills")
     require file.read("skills/*")
     require file.read("memory")
     require file.read("memory/*")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
     require env("LAMPSON_*")
+    require env("OS")
+    -- computer_use solo se menciona cuando está en el catálogo (encendida + driver): vacío si no
+    let cu be computer.prompt_line()
     let core be `You are Lampson, a coding agent that works inside the user's project through tools.
 Operate like a careful senior engineer: precise, honest, and economical with words.
 
@@ -60,7 +68,7 @@ Operate like a careful senior engineer: precise, honest, and economical with wor
 - memory: durable facts across sessions (user preferences, environment details, tool quirks, conventions). Check it before investigating. Write declarative facts, not instructions to yourself; do not store task progress or anything stale in a week. The notes live outside the project: only this tool reaches them (never ls/bash, never files inside the repo).
 - skill: before starting a kind of task, scan the skill list below; if one matches or is even partially relevant, load it and follow it. Err on the side of loading.
 - todo: your task list (whole-list replacement, one in_progress at a time; see Method step 1).
-- MCP tools are named mcp_<server>_<tool>; calling one may ask the user for approval. The mcp tool lists, connects (action=add, with the user's approval) and disconnects servers; a new server's tools enter your catalog on the next turn.
+- MCP tools are named mcp_<server>_<tool>; calling one may ask the user for approval. The mcp tool lists, connects (action=add, with the user's approval) and disconnects servers; a new server's tools enter your catalog on the next turn.{cu}
 - Call several independent tools in one turn (reads, searches, read-only commands); serialize only when a later call depends on an earlier result. Tool outputs are truncated at 30k chars — narrow your queries.
 
 # Tone

package/lib/provider.syn

@@ -37,15 +37,39 @@ export let PRESETS be {
     "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"},
-    -- 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"}
+    -- Z.ai (Zhipu), API compatible con OpenAI, dos presets con la MISMA key (es la misma cuenta):
+    -- `glm` = pago por uso (saldo prepago); `glm-coding` = GLM Coding Plan (suscripción), que solo vale
+    -- en el endpoint /coding/. La key de un Coding Plan contra `glm` da 429 código 1113 "Insufficient
+    -- balance or no resource package" (visto 2026-09-05): no es la key, es el endpoint.
+    -- Modelo por defecto glm-5.3-flash (2026-09-07): el primer GLM-5 multimodal nativo (imágenes por
+    -- image_url, verificado con un PNG en data URL), 1M de contexto, 128K de salida y más rápido que
+    -- glm-5.3; ambos endpoints lo listan en GET /models. Su thinking no se puede apagar (ver chat_openai).
+    "glm":        {"wire": "openai",    "base_url": "https://api.z.ai/api/paas/v4",        "model": "glm-5.3-flash"},
+    "glm-coding": {"wire": "openai",    "base_url": "https://api.z.ai/api/coding/paas/v4", "model": "glm-5.3-flash"}
 }
 
 -- Keys: una por proveedor en .env como LAMPSON_API_KEY_<PROVIDER> (LAMPSON_API_KEY_DEEPSEEK, _ANTHROPIC…);
 -- LAMPSON_API_KEY es la del proveedor por defecto (LAMPSON_PROVIDER). Así se cambia de proveedor en caliente
 -- (/provider en terminal, selector en la web) sin tocar .env. Solo se comprueba SI hay key, nunca se muestra.
-task key_var(name)
-    give "LAMPSON_API_KEY_" + upper(name)
+-- (`glm-coding` → LAMPSON_API_KEY_GLM_CODING: un guion no es válido en un nombre de variable)
+export task key_var(name)
+    give "LAMPSON_API_KEY_" + upper(join(split(name, "-"), "_"))
+
+-- Presets que comparten cuenta y key (z.ai): si uno no tiene key propia, usa la del otro.
+let KEY_ALIASES be {"glm-coding": "glm", "glm": "glm-coding"}
+
+-- Nombre bajo el que hay key para `n` (config.json o LAMPSON_API_KEY_<P>): él mismo, si no su alias, si no "".
+task key_owner(n)
+    require env("LAMPSON_*")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    when settings.raw_key(n) != "" or env(key_var(n), "") != ""
+        give n
+    when contains(KEY_ALIASES, n)
+        let a be KEY_ALIASES[n]
+        when settings.raw_key(a) != "" or env(key_var(a), "") != ""
+            give a
+    give ""
 
 -- proveedor por defecto: config.json (onboarding / UI) > LAMPSON_PROVIDER en .env > deepseek
 task env_default()
@@ -67,9 +91,7 @@ export task has_key(name)
     require file.read(".lampson/*")
     when name == "ollama"
         give true
-    when settings.raw_key(name) != ""
-        give true
-    when env(key_var(name), "") != ""
+    when key_owner(name) != ""
         give true
     give name == env_default() and env("LAMPSON_API_KEY", "") != ""
 
@@ -97,7 +119,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", "glm"]
+let LOWERCASE_MODELS be ["deepseek", "openai", "anthropic", "groq", "kimi", "grok", "openrouter", "glm", "glm-coding"]
 
 export task normalize_model(name, model)
     let m be trim(text(model))
@@ -163,12 +185,15 @@ export task config_for(name, model)
     when model != nothing and model != ""
         set m to model
     set m to normalize_model(n, m)
-    -- key: guardada en config.json > LAMPSON_API_KEY_<P> > LAMPSON_API_KEY (solo para el proveedor de .env)
+    -- key: guardada en config.json > LAMPSON_API_KEY_<P> > LAMPSON_API_KEY (solo para el proveedor de .env).
+    -- Si el preset no tiene key propia se usa la de su alias (KEY_ALIASES: glm ↔ glm-coding).
     let key be secret("LAMPSON_API_KEY", "ollama")
-    when env(key_var(n), "") != ""
-        set key to secret(key_var(n), "ollama")
-    when settings.raw_key(n) != ""
-        set key to as_secret(settings.raw_key(n), "api_key_" + n)
+    let ko be key_owner(n)
+    when ko != ""
+        when env(key_var(ko), "") != ""
+            set key to secret(key_var(ko), "ollama")
+        when settings.raw_key(ko) != ""
+            set key to as_secret(settings.raw_key(ko), "api_key_" + ko)
     give {
         "provider": n,
         "wire": wire,
@@ -200,7 +225,15 @@ task err_result(msg)
 
 -- ---------- OpenAI wire (chat/completions) ----------
 
-task to_openai_messages(messages)
+-- Presets de Z.ai: comparten cuenta y key, y son los únicos que reciben `thinking` y el eco del razonamiento.
+task is_glm(cfg)
+    when not contains(cfg, "provider")
+        give false
+    give cfg["provider"] == "glm" or cfg["provider"] == "glm-coding"
+
+-- keep_reasoning: devolver el `reasoning` guardado en cada assistant como `reasoning_content` (solo Z.ai;
+-- otros endpoints podrían rechazar el campo). Ver chat_openai.
+task to_openai_messages(messages, keep_reasoning)
     let out be []
     each m in messages
         when m["role"] == "assistant"
@@ -211,6 +244,10 @@ task to_openai_messages(messages)
                     each tc in m["tool_calls"]
                         set tcs to append(tcs, {"id": tc["id"], "type": "function", "function": {"name": tc["name"], "arguments": json_encode(tc["args"])}})
                     set entry to {"role": "assistant", "content": m["content"], "tool_calls": tcs}
+            when keep_reasoning and contains(m, "reasoning")
+                when m["reasoning"] != nothing
+                    when m["reasoning"] != ""
+                        set entry["reasoning_content"] to m["reasoning"]
             set out to append(out, entry)
         otherwise when m["role"] == "tool"
             set out to append(out, {"role": "tool", "tool_call_id": m["tool_call_id"], "content": m["content"]})
@@ -257,9 +294,10 @@ 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-")
+    -- GLM: los modelos con visión llevan sufijo v (glm-4.5v, glm-4.6v); glm-5.3-flash es el primer GLM-5
+    -- multimodal nativo (glm-5.3 a secas NO acepta imágenes). Verificado 2026-09-07 con un PNG por data URL.
+    when p == "glm" or p == "glm-coding"
+        give contains(m, "vision") or ends_with(m, "v") or contains(m, "v-") or starts_with(m, "glm-5.3-flash")
     give false
 
 -- Modelo sin visión: la imagen se reemplaza por una nota que el modelo puede explicarle al usuario
@@ -311,9 +349,16 @@ task parse_args(raw)
         give {"_raw": raw, "_parse_error": err}
 
 task chat_openai(cfg, messages, catalog)
-    let body be {"model": cfg["model"], "messages": to_openai_messages(messages), "max_tokens": cfg["max_tokens"]}
+    let glm be is_glm(cfg)
+    let body be {"model": cfg["model"], "messages": to_openai_messages(messages, glm), "max_tokens": cfg["max_tokens"]}
     when length(catalog) > 0
-        set body to {"model": cfg["model"], "messages": to_openai_messages(messages), "max_tokens": cfg["max_tokens"], "tools": to_openai_tools(catalog)}
+        set body["tools"] to to_openai_tools(catalog)
+    -- Z.ai: el thinking de glm-5.3-flash no se puede apagar y la doc recomienda clear_thinking=false, que
+    -- conserva el razonamiento entre pasos de un turno SI cada assistant vuelve con su reasoning_content
+    -- (por eso se guarda `reasoning` en el mensaje y to_openai_messages lo ecoa). Solo para los presets
+    -- glm: otros endpoints OpenAI rechazan parámetros desconocidos. Verificado 2026-09-07: 200 con y sin eco.
+    when glm
+        set body["thinking"] to {"type": "enabled", "clear_thinking": false}
     let headers be {"Authorization": bearer(cfg["key"]), "Content-Type": "application/json"}
     let r be http_post(strip_slash(cfg["base_url"]) + "/chat/completions", json_encode(body), headers, cfg["timeout"])
     when contains(r, "error")
@@ -331,6 +376,11 @@ task chat_openai(cfg, messages, catalog)
         when msg["tool_calls"] != nothing
             each tc in msg["tool_calls"]
                 set calls to append(calls, {"id": tc["id"], "name": tc["function"]["name"], "args": parse_args(tc["function"]["arguments"])})
+    -- razonamiento del paso (reasoning_content): se guarda solo para Z.ai, que es quien lo vuelve a pedir
+    let reasoning be ""
+    when glm and contains(msg, "reasoning_content")
+        when msg["reasoning_content"] != nothing
+            set reasoning to text(msg["reasoning_content"])
     let usage be {"input": 0, "output": 0, "cached": 0}
     when contains(j, "usage")
         when j["usage"] != nothing
@@ -348,7 +398,7 @@ task chat_openai(cfg, messages, catalog)
             give {"text": "", "tool_calls": [], "usage": usage, "stop": "end", "error": "empty response: the model used its whole output budget (max_tokens=" + text(cfg["max_tokens"]) + ") without emitting text or tool calls — a reasoning model can spend it all thinking. Raise LAMPSON_MAX_TOKENS (or simplify the request) and say «seguí»."}
         set txt to txt + "\n\n[respuesta cortada: se alcanzó max_tokens=" + text(cfg["max_tokens"]) + " — decí «seguí» para que continúe]"
     let finish be when length(calls) > 0 then "tool_calls" otherwise "end"
-    give {"text": txt, "tool_calls": calls, "usage": usage, "stop": finish, "error": nothing}
+    give {"text": txt, "tool_calls": calls, "usage": usage, "stop": finish, "error": nothing, "reasoning": reasoning}
 
 -- ---------- Anthropic wire (messages) ----------
 

package/lib/schedule.syn

@@ -70,7 +70,7 @@ export task tz_offset()
 
 -- "+0200" | "-03:00" | "-3" → segundos
 export task parse_offset(raw)
-    let s be replace_text(trim(raw), ":", "")
+    let s be replace(trim(raw), ":", "")
     when s == ""
         give 0
     let sign be when starts_with(s, "-") then -1 otherwise 1
@@ -126,8 +126,8 @@ task parse_span(tok)
     let t be lower(tok)
     when not matches(t, "[0-9]+(\.[0-9]+)?(s|m|h|d|min|h?ora?s?|d[ií]as?|seg(undos)?|minutos?)?")
         give nothing
-    let num be number(capture(t, "[0-9]+(?:\.[0-9]+)?"))
-    let unit be replace_re(t, "^[0-9.]+", "")
+    let num be number(regex_capture(t, "[0-9]+(?:\.[0-9]+)?")[0])
+    let unit be regex_replace(t, "^[0-9.]+", "")
     when unit == "s" or starts_with(unit, "seg")
         give floor(num)
     when unit == "m" or starts_with(unit, "min")
@@ -139,9 +139,9 @@ task parse_span(tok)
 -- → {ok, plan: {kind: every|daily|weekly, seconds?, hh?, mm?, days?}, error}
 export task parse_when(spec)
     let s be lower(trim(text(spec)))
-    set s to replace_text(replace_text(replace_text(s, " a las ", " "), " at ", " "), "todos los días", "daily")
-    set s to replace_text(replace_text(s, "todos los dias", "daily"), "every day", "daily")
-    let toks be where(split(replace_text(s, ",", " "), " "), (x) => x != "")
+    set s to replace(replace(replace(s, " a las ", " "), " at ", " "), "todos los días", "daily")
+    set s to replace(replace(s, "todos los dias", "daily"), "every day", "daily")
+    let toks be where(split(replace(s, ",", " "), " "), (x) => x != "")
     when length(toks) == 0
         give {"ok": false, "error": "empty schedule"}
     let head be toks[0]
@@ -335,7 +335,7 @@ export task mount_ok()
         give true
 
 task norm_path(p)
-    let s be lower(replace_text(trim(p), "\\", "/"))
+    let s be lower(replace(trim(p), "\\", "/"))
     -- Git Bash: /c/Users/x → c:/users/x
     when matches(s, "/[a-z]/.*")
         set s to slice(s, 1, 2) + ":" + slice(s, 2, length(s))
@@ -369,8 +369,8 @@ task put(t)
     give t
 
 task slug(name)
-    let s be lower(replace_re(text(name), "[^A-Za-z0-9]+", "-"))
-    set s to replace_re(replace_re(s, "^-+", ""), "-+$", "")
+    let s be lower(regex_replace(text(name), "[^A-Za-z0-9]+", "-"))
+    set s to regex_replace(regex_replace(s, "^-+", ""), "-+$", "")
     when s == ""
         give "task"
     when length(s) > 24
@@ -471,7 +471,7 @@ task default_name(action)
     when action["type"] == "bash"
         let cmd be action["command"]
         give when length(cmd) > 40 then slice(cmd, 0, 40) + "…" otherwise cmd
-    let p be replace_text(action["prompt"], "\n", " ")
+    let p be replace(action["prompt"], "\n", " ")
     give when length(p) > 40 then slice(p, 0, 40) + "…" otherwise p
 
 export task remove(id)
@@ -628,7 +628,7 @@ export task record(t, started, status, output, extra)
     give fresh
 
 task one_line(s, max)
-    let t be trim(replace_text(replace_text(text(s), "\r", ""), "\n", " ⏎ "))
+    let t be trim(replace(replace(text(s), "\r", ""), "\n", " ⏎ "))
     when length(t) > max
         give slice(t, 0, max) + "…"
     give t
@@ -646,7 +646,7 @@ export task log_tail(id, n)
     when not matches(text(id), "[a-z0-9-]{1,40}")
         give ""
     try
-        let lines be split(replace_text(read_file(LOG_DIR + "/" + id + ".log"), "\r", ""), "\n")
+        let lines be split(replace(read_file(LOG_DIR + "/" + id + ".log"), "\r", ""), "\n")
         when length(lines) > n
             set lines to slice(lines, length(lines) - n, length(lines))
         give join(lines, "\n")