lampson 0.2.7 → 0.2.9

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")

package/lib/session.syn

@@ -68,7 +68,7 @@ export task list()
         let entries be list_dir(DIR)
         each e in entries
             when not e["is_dir"]
-                let id be replace_text(e["name"], ".json", "")
+                let id be replace(e["name"], ".json", "")
                 try
                     let d be load(id)
                     let title be when contains(d["meta"], "title") then d["meta"]["title"] otherwise ""
@@ -80,7 +80,7 @@ export task list()
                     set out to out
     recover err
         give []
-    give sort_by(out, (s) => 0 - number(replace_text(replace_text(s["id"], "-", ""), "test", "")))
+    give sort_by(out, (s) => 0 - number(replace(replace(s["id"], "-", ""), "test", "")))
 
 -- Búsqueda de texto en las sesiones de ESTE proyecto (título y contenido de los mensajes user/assistant):
 -- [{id, updated, title, snippet}] — snippet = el primer trozo donde aparece `q`. Vacío = todas (sin snippet).
@@ -111,7 +111,7 @@ export task search(q, limit)
                                 let pos be length(split(lc, needle)[0])
                                 let a be when pos > 60 then pos - 60 otherwise 0
                                 let b be when pos + length(needle) + 90 < length(c) then pos + length(needle) + 90 otherwise length(c)
-                                set hit to (when a > 0 then "…" otherwise "") + replace_text(replace_text(slice(c, a, b), "\r", ""), "\n", " ") + (when b < length(c) then "…" otherwise "")
+                                set hit to (when a > 0 then "…" otherwise "") + replace(replace(slice(c, a, b), "\r", ""), "\n", " ") + (when b < length(c) then "…" otherwise "")
                 recover err
                     set hit to nothing
             when hit != nothing
@@ -132,7 +132,7 @@ export task delete(id)
     let files be [path_of(id), ".lampson/trace/" + id + ".log", ".lampson/trace/" + id + ".last"]
     each f in files
         when env("OS", "") == "Windows_NT"
-            run("cmd", ["/c", "del", "/q", replace_text(f, "/", "\\")], 10)
+            run("cmd", ["/c", "del", "/q", replace(f, "/", "\\")], 10)
         otherwise
             run("rm", ["-f", f], 10)
     give "borrada " + id
@@ -141,7 +141,7 @@ export task delete(id)
 export task title_of(messages)
     each m in messages
         when m["role"] == "user"
-            let t be replace_text(m["content"], "\n", " ")
+            let t be replace(m["content"], "\n", " ")
             when length(t) > 60
                 give slice(t, 0, 60) + "…"
             give t

package/lib/settings.syn

@@ -41,6 +41,12 @@ export task load()
 export task save(doc)
     require file(".lampson")
     require file(".lampson/*")
+    require env("LAMPSON_*")
+    -- LAMPSON_NO_CONFIG=1 (tests): NUNCA escribir el archivo real. Como load() devuelve un doc en blanco,
+    -- cualquier save() (remember_command al tipear /exit en tty_test, /verbose, set_key, set_default…)
+    -- pisaba provider y keys del usuario (pasó el 2026-09-05: tty_test dejó config.json vacío).
+    when env("LAMPSON_NO_CONFIG", "") == "1"
+        give false
     write_file(cfg_path(), json_encode(doc))
     give true
 
@@ -79,7 +85,11 @@ export task set_default(name, model)
 
 -- valores de configuración generales (rueda de la UI): tz, public_url, webhook_url, webhook_secret…
 -- Vacío = borrar la clave. Nunca se devuelven secretos al navegador: `values()` marca webhook_secret como has_*.
-export let KEYS be ["tz", "public_url", "webhook_url", "webhook_secret", "idle_hours"]
+-- computer_*: la tool computer_use (lib/computer.syn) — "1" enciende; max_tabs y grant_profile son sus knobs.
+-- judge = off | jev | laya: el juez de decisión de Lampson (lib/judge.syn), una credencial propia que usa computer
+-- use y puede usar cualquier otra parte; judge_model = con laya, la carpeta del checkpoint; con jev, un id para
+-- pinear (opcional). computer_judge / computer_judge_model: los nombres del primer día (2026-09-28), solo se leen.
+export let KEYS be ["tz", "public_url", "webhook_url", "webhook_secret", "idle_hours", "computer_use", "computer_max_tabs", "computer_grant_profile", "judge", "judge_model", "computer_judge", "computer_judge_model"]
 
 -- el archivo REAL, ignorando LAMPSON_NO_CONFIG: escribir con el doc en blanco de los tests pisaría provider/keys
 -- (pasó el 2026-08-29 probando la rueda con un web de test)
@@ -131,3 +141,57 @@ export task values()
                 set out[k] to e
                 set out[k + "_from_env"] to true
     give out
+
+-- el juez de computer use como ENTORNO para el runtime: Synsema lee SYNSEMA_JUDGE_* y TYPESAFE_API_KEY del proceso
+-- (o del .env) al arrancar, y un programa no puede cambiarlos en caliente. Lo usan quienes lanzan procesos: el
+-- workspace web (workspaces.start_ws) y la terminal (cli.syn ensure → lampson.ps1|sh). {} = no tocar nada.
+-- La key de TypeSafe se guarda con set_key("typesafe", …) como las de los proveedores.
+export task judge_env()
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    require env("LAMPSON_*")
+    let js be judge_setting()
+    let mode be lower(trim(text(js["mode"])))
+    let model be trim(text(js["model"]))
+    when mode == "jev" or mode == "typesafe"
+        let out be {"SYNSEMA_JUDGE_PROVIDER": "typesafe"}
+        let k be raw_key("typesafe")
+        when k != ""
+            set out["TYPESAFE_API_KEY"] to k
+        when model != ""
+            set out["SYNSEMA_JUDGE_MODEL"] to model
+        give out
+    when mode == "laya" or mode == "local"
+        let out be {"SYNSEMA_JUDGE_PROVIDER": "laya"}
+        when model != ""
+            set out["SYNSEMA_JUDGE_MODEL"] to model
+        give out
+    give {}
+
+-- el juez configurado → {mode, model, from_env}: `judge` / `judge_model` (LAMPSON_JUDGE en .env gana), y si no, los
+-- nombres viejos computer_judge / computer_judge_model
+export task judge_setting()
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    require env("LAMPSON_*")
+    let v be values()
+    let m be trim(text(v["judge"]))
+    let mo be trim(text(v["judge_model"]))
+    when m == ""
+        set m to trim(text(v["computer_judge"]))
+    when mo == ""
+        set mo to trim(text(v["computer_judge_model"]))
+    give {"mode": m, "model": mo, "from_env": contains(v, "judge_from_env")}
+
+-- guardar el juez con los nombres nuevos y borrar los viejos (una sola fuente de verdad)
+export task set_judge(mode, model)
+    require file(".lampson")
+    require file(".lampson/*")
+    require env("LAMPSON_*")
+    set_value("judge", when mode == "off" then "" otherwise mode)
+    when model != nothing
+        set_value("judge_model", text(model))
+    set_value("computer_judge", "")
+    when model != nothing
+        set_value("computer_judge_model", "")
+    give true

package/lib/skills.syn

@@ -37,9 +37,12 @@ let ROOTS be [
     {"dir": "workspace/.lampson/skills", "source": "local"}
 ]
 
+use "./computer.syn" as computer
+
 task frontmatter(md)
-    -- devuelve {name, description, body}; sin frontmatter → name vacío
-    let out be {"name": "", "description": "", "body": md}
+    -- devuelve {name, description, requires, body}; sin frontmatter → name vacío.
+    -- `requires: computer_use` (skills del harness): la skill solo entra al índice si esa tool está disponible
+    let out be {"name": "", "description": "", "requires": "", "body": md}
     when not starts_with(md, "---")
         give out
     let rest be slice(md, 3, length(md))
@@ -54,10 +57,13 @@ task frontmatter(md)
             set out["name"] to trim(slice(l, 5, length(l)))
         otherwise when starts_with(l, "description:")
             set out["description"] to trim(slice(l, 12, length(l)))
+        otherwise when starts_with(l, "requires:")
+            set out["requires"] to trim(slice(l, 9, length(l)))
     set out["body"] to trim(body)
     give out
 
-task scan_root(root, acc)
+-- hidden = tools que NO están disponibles: una skill con `requires:` de una de ellas no se lista
+task scan_root(root, acc, hidden)
     let out be acc
     try
         each e in list_dir(root["dir"])
@@ -66,7 +72,8 @@ task scan_root(root, acc)
                 try
                     let fm be frontmatter(read_file(path))
                     let name be when fm["name"] == "" then e["name"] otherwise fm["name"]
-                    set out[name] to {"name": name, "description": fm["description"], "path": path, "source": root["source"]}
+                    when not contains(hidden, fm["requires"])
+                        set out[name] to {"name": name, "description": fm["description"], "path": path, "source": root["source"]}
                 recover err
                     set out to out
     recover err
@@ -75,15 +82,20 @@ task scan_root(root, acc)
 
 -- índice: map name → {name, description, path, source}
 export task index()
+    require exec
+    require time
+    require env("LAMPSON_*")
+    require env("OS")
     require file.read("skills")
     require file.read("skills/*")
     require file.read("workspace")
     require file.read("workspace/*")
     require file.read(".lampson")
     require file.read(".lampson/*")
+    let hidden be when computer.available() then [] otherwise ["computer_use"]
     let acc be {}
     each r in ROOTS
-        set acc to scan_root(r, acc)
+        set acc to scan_root(r, acc, hidden)
     give acc
 
 -- sección del system prompt
@@ -98,6 +110,10 @@ export task prompt_section(idx)
     give join(lines, "\n")
 
 export task load(name)
+    require exec
+    require time
+    require env("LAMPSON_*")
+    require env("OS")
     require file.read("skills")
     require file.read("skills/*")
     require file.read("workspace")
@@ -149,7 +165,7 @@ task ensure_global_mount()
     run(shell_exe(), ["-c", when is_win then win otherwise unix], 30, {"cwd": "."})
 
 task tail_out(s)
-    let t be strip_ansi(replace_text(s, "\r", ""))
+    let t be strip_ansi(replace(s, "\r", ""))
     when length(t) > 3000
         give slice(t, length(t) - 3000, length(t))
     give t

package/lib/tools/bash.syn

@@ -27,7 +27,7 @@ export task shell_config()
 let SERVER_RE be ".*((npm|pnpm|yarn|bun)( run)? (dev|start|serve|watch|preview)|npx (next|vite|nodemon|serve|http-server)|next (dev|start)|vite( |$)|nodemon|synsema serve|uvicorn|gunicorn|flask run|manage\\.py runserver|python3? -m http\\.server|rails s(erver)?|php -S|ng serve|cargo (run|watch)|go run|dotnet (run|watch)|tail -f).*"
 
 export task looks_like_server(command)
-    let cmd be trim(lower(replace_text(command, "\n", " ")))
+    let cmd be trim(lower(replace(command, "\n", " ")))
     when matches(cmd, "timeout [0-9]+.*")
         give false
     give matches(cmd, SERVER_RE)

package/lib/tools/common.syn

@@ -20,7 +20,7 @@ task has_dotdot(p)
 
 -- path del modelo → path real bajo workspace/
 export task ws(path)
-    let p be when path == nothing then "." otherwise replace_text(text(path), "\\", "/")
+    let p be when path == nothing then "." otherwise replace(text(path), "\\", "/")
     let stripping be true
     while stripping
         when starts_with(p, "./")