lampson 0.2.8 → 0.2.9

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, "./")

package/lib/tools/fetch.syn

@@ -1,10 +1,10 @@
 -- lib/tools/fetch.syn — traer una página web o una respuesta HTTP como Markdown/texto, sin ruido
 --
 -- Antes (2026-09-02) el modelo hacía `bash curl <url>` y recibía HTML crudo: head, CSS, nav, scripts —
--- hasta 10k chars por llamada de puro ruido (synsema.com: 26,8 KB de HTML vs 2,5 KB de Markdown).
+-- hasta 10k chars por llamada de puro ruido (synsema.org: 26,8 KB de HTML vs 2,5 KB de Markdown).
 -- Esta tool combina lo mejor de los tres harnesses de referencia:
 --   * opencode webfetch.ts — negociación `Accept` con q-values por formato (markdown/text/html): un sitio
---     que sirve Markdown (synsema.com) lo entrega directo, sin convertir.
+--     que sirve Markdown (synsema.org) lo entrega directo, sin convertir.
 --   * deepseek web-fetch-http — transporte: redirects MANUALES (http_get no los sigue) hasta 5 saltos,
 --     revalidando cada salto con la política de hosts; tope de bytes; Content-Type clasificado (html /
 --     texto / binario); cabecera "url · HTTP status · tipo · tamaño" y pie explícito al truncar.
@@ -126,27 +126,27 @@ let NAMED be {"nbsp": " ", "lt": "<", "gt": ">", "quot": "\"", "apos": "'", "cop
 export task decode_entities(s)
     let out be s
     -- numéricas: &#233; &#xE9;
-    each m in find_all(out, "&#[0-9]{1,7};|&#[xX][0-9A-Fa-f]{1,6};")
+    each m in regex_find_all(out, "&#[0-9]{1,7};|&#[xX][0-9A-Fa-f]{1,6};")
         let inner be slice(m, 2, length(m) - 1)
         let cp be when starts_with(lower(inner), "x") then hex_to_int(slice(inner, 1, length(inner))) otherwise floor(number(inner))
-        set out to replace_text(out, m, cp_text(cp))
+        set out to replace(out, m, cp_text(cp))
     -- con nombre (las comunes; el resto se deja tal cual)
-    each m in find_all(out, "&[A-Za-z][A-Za-z0-9]{1,8};")
+    each m in regex_find_all(out, "&[A-Za-z][A-Za-z0-9]{1,8};")
         let name be slice(m, 1, length(m) - 1)
         when contains(NAMED, name)
-            set out to replace_text(out, m, NAMED[name])
-    give replace_text(out, "&amp;", "&")
+            set out to replace(out, m, NAMED[name])
+    give replace(out, "&amp;", "&")
 
 task strip_tags(s)
-    give replace_re(s, "(?s)<[^>]*>", "")
+    give regex_replace(s, "(?s)<[^>]*>", "")
 
 -- texto de un fragmento inline (título, texto de un link, celda): sin tags, entidades, espacios colapsados
 task inline_text(s)
-    give trim(replace_re(decode_entities(strip_tags(s)), "\\s+", " "))
+    give trim(regex_replace(decode_entities(strip_tags(s)), "\\s+", " "))
 
 export task title_of(html)
     -- capture con grupos devuelve una LISTA de grupos (verificado): [0] es el título
-    let t be capture(html, "(?is)<title[^>]*>(.*?)</title>")
+    let t be regex_capture(html, "(?is)<title[^>]*>(.*?)</title>")
     when t == nothing
         give ""
     give inline_text(t[0])
@@ -157,14 +157,14 @@ export task title_of(html)
 task pull_pre(h, plain)
     let blocks be []
     let out be h
-    each e in enumerate(find_all(h, "(?is)<pre\\b.*?</pre>"))
+    each e in enumerate(regex_find_all(h, "(?is)<pre\\b.*?</pre>"))
         let blk be e["item"]
-        let langm be capture(blk, "(?i)language-([A-Za-z0-9_+#-]+)")
+        let langm be regex_capture(blk, "(?i)language-([A-Za-z0-9_+#-]+)")
         let lang be when langm == nothing then nothing otherwise langm[0]
-        let innerm be capture(blk, "(?is)<pre\\b[^>]*>(.*?)</pre>")
+        let innerm be regex_capture(blk, "(?is)<pre\\b[^>]*>(.*?)</pre>")
         let inner be when innerm == nothing then "" otherwise innerm[0]
         let code be decode_entities(strip_tags(inner))
-        set code to replace_text(code, "\r\n", "\n")
+        set code to replace(code, "\r\n", "\n")
         -- quitar un salto inicial/final (el HTML suele meterlos), no la indentación
         when starts_with(code, "\n")
             set code to slice(code, 1, length(code))
@@ -172,47 +172,47 @@ task pull_pre(h, plain)
             set code to slice(code, 0, length(code) - 1)
         let fenced be when plain then "\n\n" + code + "\n\n" otherwise "\n\n```" + (when lang != nothing then text(lang) otherwise "") + "\n" + code + "\n```\n\n"
         set blocks to append(blocks, fenced)
-        set out to replace_text(out, blk, "%%LPRE" + text(e["index"]) + "%%")
+        set out to replace(out, blk, "%%LPRE" + text(e["index"]) + "%%")
     give {"html": out, "blocks": blocks}
 
 task push_pre(s, blocks)
     let out be s
     each e in enumerate(blocks)
-        set out to replace_text(out, "%%LPRE" + text(e["index"]) + "%%", e["item"])
+        set out to replace(out, "%%LPRE" + text(e["index"]) + "%%", e["item"])
     give out
 
 -- <ol> → "1. …" (find_all + reemplazo literal: replace_re no puede contar)
 task number_lists(h)
     let out be h
-    each blk in find_all(h, "(?is)<ol\\b[^>]*>.*?</ol>")
+    each blk in regex_find_all(h, "(?is)<ol\\b[^>]*>.*?</ol>")
         let parts be split(blk, "<li")
         let items be []
         each e in enumerate(parts)
             when e["index"] > 0
                 -- "<li" + [atributos]> contenido </li>
-                let body be replace_re(e["item"], "(?s)^[^>]*>", "")
-                set body to replace_re(body, "(?is)</li>.*$", "")
+                let body be regex_replace(e["item"], "(?s)^[^>]*>", "")
+                set body to regex_replace(body, "(?is)</li>.*$", "")
                 set items to append(items, text(length(items) + 1) + ". " + trim(body))
-        set out to replace_text(out, blk, "\n\n" + join(items, "\n") + "\n\n")
+        set out to replace(out, blk, "\n\n" + join(items, "\n") + "\n\n")
     give out
 
 -- <table> → tabla GFM (sin colspan; hermes/deepseek también los ignoran)
 task tables(h)
     let out be h
-    each blk in find_all(h, "(?is)<table\\b.*?</table>")
+    each blk in regex_find_all(h, "(?is)<table\\b.*?</table>")
         let rows be []
         let first_is_head be false
         each e in enumerate(split(blk, "<tr"))
             when e["index"] > 0
-                let row be replace_re(e["item"], "(?s)^[^>]*>", "")
-                set row to replace_re(row, "(?is)</tr>.*$", "")
+                let row be regex_replace(e["item"], "(?s)^[^>]*>", "")
+                set row to regex_replace(row, "(?is)</tr>.*$", "")
                 let cells be []
-                let row_td be replace_re(row, "(?i)<th\\b", "<td")
+                let row_td be regex_replace(row, "(?i)<th\\b", "<td")
                 each ce in enumerate(split(row_td, "<td"))
                     when ce["index"] > 0
-                        let cell be replace_re(ce["item"], "(?s)^[^>]*>", "")
-                        set cell to replace_re(cell, "(?is)</t[dh]>.*$", "")
-                        set cells to append(cells, replace_text(inline_text(cell), "|", "\\|"))
+                        let cell be regex_replace(ce["item"], "(?s)^[^>]*>", "")
+                        set cell to regex_replace(cell, "(?is)</t[dh]>.*$", "")
+                        set cells to append(cells, replace(inline_text(cell), "|", "\\|"))
                 when length(cells) > 0
                     when length(rows) == 0 and contains(lower(row), "<th")
                         set first_is_head to true
@@ -230,17 +230,17 @@ task tables(h)
                 when e["index"] > 0
                     set with_sep to append(with_sep, e["item"])
             set rows to with_sep
-        set out to replace_text(out, blk, "\n\n" + join(rows, "\n") + "\n\n")
+        set out to replace(out, blk, "\n\n" + join(rows, "\n") + "\n\n")
     give out
 
 -- <a href> → [texto](url absoluta); en plain, solo el texto
 task links(h, base, plain)
     let out be h
-    each a in find_all(h, "(?is)<a\\b[^>]*>.*?</a>")
-        let inner be capture(a, "(?is)<a\\b[^>]*>(.*?)</a>")
+    each a in regex_find_all(h, "(?is)<a\\b[^>]*>.*?</a>")
+        let inner be regex_capture(a, "(?is)<a\\b[^>]*>(.*?)</a>")
         let txt be when inner == nothing then "" otherwise inline_text(inner[0])
-        let href be capture(a, "(?is)<a\\b[^>]*\\shref\\s*=\\s*[\"']([^\"']*)[\"']")
-        let abs be when href == nothing then nothing otherwise u.resolve(base, href[0])
+        let href be regex_capture(a, "(?is)<a\\b[^>]*\\shref\\s*=\\s*[\"']([^\"']*)[\"']")
+        let abs be when href == nothing then nothing otherwise unwrap_ddg(u.resolve(base, href[0]))
         let repl be txt
         -- anclas internas (#x) sin destino real: "Skip to content", el "§"/"#" de cada heading → fuera
         when abs == nothing
@@ -248,9 +248,36 @@ task links(h, base, plain)
                 set repl to ""
         when not plain and abs != nothing and txt != ""
             set repl to when abs == txt then "<" + abs + ">" otherwise "[" + txt + "](" + abs + ")"
-        set out to replace_text(out, a, repl)
+        set out to replace(out, a, repl)
     give out
 
+-- DuckDuckGo (html.duckduckgo.com — buscar en la web SIN API key ni navegador) envuelve cada resultado en
+-- //duckduckgo.com/l/?uddg=<destino codificado>&rut=…: el modelo necesita el destino real (para traerlo con fetch
+-- o abrirlo con computer_use), no el redirect. Sin builtin de percent-decoding: se decodifica a bytes y luego UTF-8.
+task unwrap_ddg(url)
+    when url == nothing
+        give nothing
+    when not contains(url, "duckduckgo.com/l/?")
+        give url
+    let m be regex_capture(url, "[?&]uddg=([^&]*)")
+    when m == nothing
+        give url
+    give pct_decode(m[0])
+
+task pct_decode(s)
+    let out be bytes("")
+    let i be 0
+    let n be length(s)
+    while i < n
+        let ch be slice(s, i, i + 1)
+        when ch == "%" and i + 3 <= n and matches(slice(s, i + 1, i + 3), "[0-9A-Fa-f]{2}")
+            set out to out + bytes(slice(s, i + 1, i + 3), "hex")
+            set i to i + 3
+        otherwise
+            set out to out + bytes(when ch == "+" then " " otherwise ch)
+            set i to i + 1
+    give decode(out, "utf8_lossy")
+
 -- blockquote: marcadores y luego prefijo "> " línea por línea
 task quote_lines(s)
     when not contains(s, "%%LBQ%%")
@@ -261,7 +288,7 @@ task quote_lines(s)
         let line be l
         let opens be length(split(line, "%%LBQ%%")) - 1
         let closes be length(split(line, "%%/LBQ%%")) - 1
-        set line to replace_text(replace_text(line, "%%LBQ%%", ""), "%%/LBQ%%", "")
+        set line to replace(replace(line, "%%LBQ%%", ""), "%%/LBQ%%", "")
         when inq or opens > 0
             when trim(line) != ""
                 set line to "> " + trim(line)
@@ -273,12 +300,12 @@ task quote_lines(s)
     give join(out, "\n")
 
 export task to_markdown(html, base, plain)
-    let h be replace_text(text(html), "\r\n", "\n")
-    set h to replace_re(h, "(?s)<!--.*?-->", "")
+    let h be replace(text(html), "\r\n", "\n")
+    set h to regex_replace(h, "(?s)<!--.*?-->", "")
     -- ruido: sin contenido para el modelo (un patrón por tag: el motor Rust no tiene backreferences)
     -- (header también: en docs/GitHub es el menú del sitio; el título de la página va aparte en `title:`)
     each tg in ["script", "style", "noscript", "svg", "iframe", "template", "head", "nav", "header", "aside", "footer", "dialog", "select", "button", "canvas", "video", "audio", "object", "embed"]
-        set h to replace_re(h, "(?is)<" + tg + "\\b.*?</" + tg + "\\s*>", "")
+        set h to regex_replace(h, "(?is)<" + tg + "\\b.*?</" + tg + "\\s*>", "")
     let pre be pull_pre(h, plain)
     set h to pre["html"]
     -- links primero (una celda o un ítem con <a> conserva el link); listas numeradas y tablas antes de
@@ -287,58 +314,58 @@ export task to_markdown(html, base, plain)
     set h to number_lists(h)
     set h to tables(h)
     -- imágenes: alt como marca; sin alt, nada (base64 jamás llega al modelo)
-    set h to replace_re(h, "(?is)<img\\b[^>]*\\salt\\s*=\\s*[\"']([^\"']+)[\"'][^>]*>", "[image: \\1]")
-    set h to replace_re(h, "(?is)<img\\b[^>]*>", "")
+    set h to regex_replace(h, "(?is)<img\\b[^>]*\\salt\\s*=\\s*[\"']([^\"']+)[\"'][^>]*>", "[image: \\1]")
+    set h to regex_replace(h, "(?is)<img\\b[^>]*>", "")
     each lvl in ["1", "2", "3", "4", "5", "6"]
         let hashes be when plain then "" otherwise slice("######", 0, floor(number(lvl))) + " "
-        set h to replace_re(h, "(?is)<h" + lvl + "\\b[^>]*>(.*?)</h" + lvl + ">", "\n\n" + hashes + "\\1\n\n")
-    set h to replace_re(h, "(?i)<br\\s*/?>", "\n")
-    set h to replace_re(h, "(?i)<hr\\b[^>]*>", when plain then "\n\n" otherwise "\n\n---\n\n")
-    set h to replace_re(h, "(?is)<blockquote\\b[^>]*>", "\n\n%%LBQ%%")
-    set h to replace_re(h, "(?i)</blockquote>", "%%/LBQ%%\n\n")
-    set h to replace_re(h, "(?i)<li\\b[^>]*>", "\n- ")
-    set h to replace_re(h, "(?i)</li>", "")
-    set h to replace_re(h, "(?i)</(ul|ol|dl)>", "\n")
-    set h to replace_re(h, "(?i)<(ul|ol|dl)\\b[^>]*>", "\n")
-    set h to replace_re(h, "(?i)<dt\\b[^>]*>", "\n**")
-    set h to replace_re(h, "(?i)</dt>", "**\n")
-    set h to replace_re(h, "(?i)<dd\\b[^>]*>", "\n  ")
+        set h to regex_replace(h, "(?is)<h" + lvl + "\\b[^>]*>(.*?)</h" + lvl + ">", "\n\n" + hashes + "\\1\n\n")
+    set h to regex_replace(h, "(?i)<br\\s*/?>", "\n")
+    set h to regex_replace(h, "(?i)<hr\\b[^>]*>", when plain then "\n\n" otherwise "\n\n---\n\n")
+    set h to regex_replace(h, "(?is)<blockquote\\b[^>]*>", "\n\n%%LBQ%%")
+    set h to regex_replace(h, "(?i)</blockquote>", "%%/LBQ%%\n\n")
+    set h to regex_replace(h, "(?i)<li\\b[^>]*>", "\n- ")
+    set h to regex_replace(h, "(?i)</li>", "")
+    set h to regex_replace(h, "(?i)</(ul|ol|dl)>", "\n")
+    set h to regex_replace(h, "(?i)<(ul|ol|dl)\\b[^>]*>", "\n")
+    set h to regex_replace(h, "(?i)<dt\\b[^>]*>", "\n**")
+    set h to regex_replace(h, "(?i)</dt>", "**\n")
+    set h to regex_replace(h, "(?i)<dd\\b[^>]*>", "\n  ")
     -- énfasis vacíos decorativos (<i></i> como puntos de una barra) serían asteriscos sueltos
-    set h to replace_re(h, "(?is)<(i|em|b|strong)\\b[^>]*>\\s*</(i|em|b|strong)>", "")
+    set h to regex_replace(h, "(?is)<(i|em|b|strong)\\b[^>]*>\\s*</(i|em|b|strong)>", "")
     when not plain
-        set h to replace_re(h, "(?is)<(b|strong)\\b[^>]*>(.*?)</(b|strong)>", "**\\2**")
-        set h to replace_re(h, "(?is)<(i|em)\\b[^>]*>(.*?)</(i|em)>", "*\\2*")
-        set h to replace_re(h, "(?is)<code\\b[^>]*>(.*?)</code>", "`\\1`")
-    set h to replace_re(h, "(?i)</(p|div|section|article|main|header|figure|figcaption|details|summary|form|fieldset|address|tr|dd)>", "\n\n")
-    set h to replace_re(h, "(?i)<(p|div|section|article|main|header|figure|figcaption|details|summary|form|fieldset|address)\\b[^>]*>", "\n")
+        set h to regex_replace(h, "(?is)<(b|strong)\\b[^>]*>(.*?)</(b|strong)>", "**\\2**")
+        set h to regex_replace(h, "(?is)<(i|em)\\b[^>]*>(.*?)</(i|em)>", "*\\2*")
+        set h to regex_replace(h, "(?is)<code\\b[^>]*>(.*?)</code>", "`\\1`")
+    set h to regex_replace(h, "(?i)</(p|div|section|article|main|header|figure|figcaption|details|summary|form|fieldset|address|tr|dd)>", "\n\n")
+    set h to regex_replace(h, "(?i)<(p|div|section|article|main|header|figure|figcaption|details|summary|form|fieldset|address)\\b[^>]*>", "\n")
     set h to strip_tags(h)
     set h to decode_entities(h)
     -- énfasis vacío que quedó de tags sin texto
-    set h to replace_re(h, "\\*\\*\\s*\\*\\*", "")
-    set h to replace_re(h, "``", "")
+    set h to regex_replace(h, "\\*\\*\\s*\\*\\*", "")
+    set h to regex_replace(h, "``", "")
     -- espacios: colapsar (los <pre> están a salvo en sus marcadores)
-    set h to replace_text(h, cp_text(160), " ")
-    set h to replace_re(h, "[ \\t\\f\\v]+", " ")
-    set h to replace_re(h, "(?m)^ +", "")
-    set h to replace_re(h, "(?m) +$", "")
-    set h to replace_re(h, "\\n{3,}", "\n\n")
+    set h to replace(h, cp_text(160), " ")
+    set h to regex_replace(h, "[ \\t\\f\\v]+", " ")
+    set h to regex_replace(h, "(?m)^ +", "")
+    set h to regex_replace(h, "(?m) +$", "")
+    set h to regex_replace(h, "\\n{3,}", "\n\n")
     set h to quote_lines(h)
     set h to push_pre(h, pre["blocks"])
-    set h to replace_re(h, "\\n{3,}", "\n\n")
+    set h to regex_replace(h, "\\n{3,}", "\n\n")
     give trim(h)
 
 -- Markdown servido por el sitio: solo sacar imágenes base64 (hermes convert_base64_images_to_links)
 export task clean_markdown(md)
-    let out be replace_re(text(md), "!\\[([^\\]]*)\\]\\(\\s*data:image/[^)]*\\)", "[image: \\1]")
-    set out to replace_re(out, "data:image/[a-z+]+;base64,[A-Za-z0-9+/=]{40,}", "[image]")
-    give trim(replace_text(out, "\r\n", "\n"))
+    let out be regex_replace(text(md), "!\\[([^\\]]*)\\]\\(\\s*data:image/[^)]*\\)", "[image: \\1]")
+    set out to regex_replace(out, "data:image/[a-z+]+;base64,[A-Za-z0-9+/=]{40,}", "[image]")
+    give trim(replace(out, "\r\n", "\n"))
 
 -- href del <link rel="alternate" type="text/markdown">, resuelto; nothing si no hay
 export task markdown_alternate(html, base)
-    each l in find_all(text(html), "(?is)<link\\b[^>]*>")
+    each l in regex_find_all(text(html), "(?is)<link\\b[^>]*>")
         let ll be lower(l)
         when contains(ll, "alternate") and (contains(ll, "type=\"text/markdown\"") or contains(ll, "type='text/markdown'") or contains(ll, "type=\"text/x-markdown\""))
-            let href be capture(l, "(?is)\\shref\\s*=\\s*[\"']([^\"']*)[\"']")
+            let href be regex_capture(l, "(?is)\\shref\\s*=\\s*[\"']([^\"']*)[\"']")
             when href != nothing
                 give u.resolve(base, href[0])
     give nothing
@@ -563,7 +590,7 @@ export task tool(url, format, max_chars, timeout)
 
 export let SPEC be {
     "name": "fetch",
-    "description": "Fetch a web page or HTTP API response and return it as Markdown (default), plain text or raw HTML — scripts, styles, navigation and footers stripped, entities decoded, links made absolute, code blocks and tables kept. Use it instead of bash+curl whenever you will READ the result (docs, READMEs, issues, changelogs, API JSON): it asks the server for Markdown first and returns about a tenth of the characters of raw HTML. Follows up to 5 redirects. Pages longer than max_chars come back as head+tail with the full text saved to a file you can page with read (offset/limit) or grep — never fetch the same URL twice in a turn; repeats within 20 minutes are served from that file anyway. Binary content (images, PDF, archives) is reported, not returned. Private/loopback hosts (localhost, 10.x, 192.168.x, *.internal) ask the user first — fine for checking your own dev server; cloud metadata endpoints are always refused. Cite the URL when you use its content.",
+    "description": "Fetch a web page or HTTP API response and return it as Markdown (default), plain text or raw HTML — scripts, styles, navigation and footers stripped, entities decoded, links made absolute, code blocks and tables kept. Use it instead of bash+curl whenever you will READ the result (docs, READMEs, issues, changelogs, API JSON): it asks the server for Markdown first and returns about a tenth of the characters of raw HTML. Follows up to 5 redirects. Pages longer than max_chars come back as head+tail with the full text saved to a file you can page with read (offset/limit) or grep — never fetch the same URL twice in a turn; repeats within 20 minutes are served from that file anyway. Binary content (images, PDF, archives) is reported, not returned. Private/loopback hosts (localhost, 10.x, 192.168.x, *.internal) ask the user first — fine for checking your own dev server; cloud metadata endpoints are always refused. Cite the URL when you use its content. To SEARCH the web (no API key, no browser): fetch https://html.duckduckgo.com/html/?q=<url-encoded query> — the results come back as Markdown with the real target links; refine the query as needed, then fetch the page you chose.",
     "parameters": {"type": "object", "properties": {
         "url": {"type": "string", "description": "Absolute http(s) URL"},
         "format": {"type": "string", "enum": ["markdown", "text", "html"], "description": "markdown (default): HTML converted to Markdown, or the site's own Markdown when it offers one; text: plain text, no links or markup; html: the raw HTML (to see structure, selectors, meta tags)"},

package/lib/tools/grep.syn

@@ -11,7 +11,7 @@ export task tool(pattern, path, glob, regex)
     let r be grep(c.ws(path), pattern, opts)
     let lines be []
     each m in r["matches"]
-        set lines to append(lines, c.unws(replace_text(m["file"], "\\", "/")) + ":" + text(m["line"]) + ": " + trim(m["text"]))
+        set lines to append(lines, c.unws(replace(m["file"], "\\", "/")) + ":" + text(m["line"]) + ": " + trim(m["text"]))
     when length(lines) == 0
         give "no matches"
     let out be join(lines, "\n")

package/lib/tools/memo.syn

@@ -33,10 +33,10 @@ task valid_name(name)
 export task slug()
     require env("LAMPSON_*")
     let ws be env("LAMPSON_WORKSPACE", "workspace")
-    let norm be replace_text(lower(ws), "\\", "/")
+    let norm be replace(lower(ws), "\\", "/")
     let parts be where(split(norm, "/"), (x) => x != "")
     let base be when length(parts) > 0 then parts[length(parts) - 1] otherwise "workspace"
-    let runs be find_all(base, "[a-z0-9]+")
+    let runs be regex_find_all(base, "[a-z0-9]+")
     let clean be when length(runs) == 0 then "project" otherwise join(runs, "-")
     let h be slice(decode(sha256(norm), "hex"), 0, 8)
     give clean + "-" + h
@@ -61,7 +61,7 @@ export task list()
                 let title be ""
                 each line in split(read_file(path(name)), "\n")
                     when title == "" and trim(line) != ""
-                        set title to trim(replace_text(line, "#", ""))
+                        set title to trim(replace(line, "#", ""))
                 set out to append(out, {"name": name, "title": when length(title) > 120 then slice(title, 0, 120) otherwise title})
     recover err
         -- el runtime lanza "Not a directory: …" (mayúscula) cuando memory/<slug> aún no existe