lampson 0.2.7 → 0.2.9

package/lib/tools/proc.syn

@@ -38,7 +38,7 @@ task path(name, ext)
     give DIR + "/" + name + "." + ext
 
 task tail_lines(content, n)
-    let lines be split(replace_text(content, "\r", ""), "\n")
+    let lines be split(replace(content, "\r", ""), "\n")
     when length(lines) > n
         set lines to slice(lines, length(lines) - n, length(lines))
     give join(lines, "\n")
@@ -211,7 +211,7 @@ export task resume_note(sid)
     give "[harness] This session was resumed after a lampson restart. Managed processes do NOT survive a restart — anything this conversation started earlier is gone unless listed as running below. Current real state:\n" + join(lines, "\n") + "\nOld logs remain in " + DIR + "/<name>.log. Start a process again with the `process` tool only if it is needed now; do not assume any server is up."
 
 task first_line_of(s)
-    let t be replace_text(text(s), "\r", "")
+    let t be replace(text(s), "\r", "")
     give split(t, "\n")[0]
 
 -- {run, session} actuales (blackboard "lampson:run" / "lampson:session"; vacíos fuera de un entry)
@@ -246,43 +246,61 @@ export task list()
         give []
     give out
 
--- Puertos TCP en escucha (cualquier proceso, gestionado o no): [{port, pid, name, command}] — via proc.sh ports
--- (Windows: netstat+tasklist · Linux: ss · macOS: lsof). Un servidor huérfano no aparece en list(); acá sí.
-export task listeners()
+-- Todos los puertos TCP en escucha con su dueño, en crudo: [{port, pid, name}] — UNA llamada a proc.sh ports
+-- (Windows: netstat+tasklist · Linux: ss · macOS: lsof), sin filtrar y sin la línea de comando. Para encontrar y
+-- parar los procesos de Lampson por su puerto (lib/workspaces.syn): el edge de --domain escucha en :443.
+export task port_owners()
     require exec
     require env("LAMPSON_*")
     require env("OS")
-    require file(".lampson")
-    require file(".lampson/*")
     let out be []
     try
         let r be run(shell(), ["lib/tools/proc.sh", "ports"], 20, {"cwd": "."})
-        let seen be {}
-        each line in split(replace_text(r["stdout"], "\r", ""), "\n")
+        each line in split(replace(r["stdout"], "\r", ""), "\n")
             let parts be where(split(trim(line), " "), (x) => x != "")
-            when length(parts) >= 2
-                let port be floor(number(parts[0]))
-                let nm be when length(parts) >= 3 then parts[2] otherwise "?"
-                when port >= 1024 and port < 49152 and not contains(SYSTEM_PROCS, lower(nm)) and not contains(seen, text(port))
-                    set seen[text(port)] to true
-                    set out to append(out, {"port": port, "pid": floor(number(parts[1])), "name": nm, "command": ""})
+            when length(parts) >= 2 and matches(parts[0], "[0-9]+") and matches(parts[1], "[0-9]+")
+                set out to append(out, {"port": floor(number(parts[0])), "pid": floor(number(parts[1])), "name": when length(parts) >= 3 then parts[2] otherwise "?"})
     recover err
         give out
+    give out
+
+-- Puertos TCP en escucha que le interesan al usuario y al agente (panel «Puertos», tool process): sin los del
+-- sistema ni los efímeros, uno por puerto, con la línea de comando: [{port, pid, name, command}]. Un servidor
+-- huérfano no aparece en list(); acá sí.
+export task listeners()
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file(".lampson")
+    require file(".lampson/*")
+    let out be []
+    let seen be {}
+    each l in port_owners()
+        when l["port"] >= 1024 and l["port"] < 49152 and not contains(SYSTEM_PROCS, lower(l["name"])) and not contains(seen, text(l["port"]))
+            set seen[text(l["port"])] to true
+            set out to append(out, {"port": l["port"], "pid": l["pid"], "name": l["name"], "command": ""})
     -- la línea de comando dice QUÉ es (next dev, un MCP server de otra herramienta, synsema serve…); un run por pid
     let cmds be {}
     let enriched be []
     each l in out
         let key be text(l["pid"])
         when not contains(cmds, key)
-            try
-                let r be run(shell(), ["lib/tools/proc.sh", "info", key], 15, {"cwd": "."})
-                set cmds[key] to trim(replace_text(r["stdout"], "\n", " "))
-            recover err
-                set cmds[key] to ""
+            set cmds[key] to command_of(l["pid"])
         set l["command"] to when length(cmds[key]) > 300 then slice(cmds[key], 0, 300) + "…" otherwise cmds[key]
         set enriched to append(enriched, l)
     give sort_by(enriched, (x) => x["port"])
 
+-- la línea de comando de un pid ("" si no se puede saber) — via proc.sh info
+export task command_of(pid)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    try
+        let r be run(shell(), ["lib/tools/proc.sh", "info", text(floor(pid))], 15, {"cwd": "."})
+        give trim(replace(r["stdout"], "\n", " "))
+    recover err
+        give ""
+
 -- matar un pid ajeno (huérfano de otra herramienta): taskkill /T o kill_tree, via proc.sh
 export task kill_pid(pid)
     require exec

package/lib/tools/qr.js

@@ -0,0 +1,26 @@
+// qr.js <texto> — dibuja un QR en la terminal (lampson --pair): medio bloque por fila de módulos (▀ ▄ █), con
+// colores FORZADOS (negro sobre blanco) para que la cámara lo lea igual con tema claro u oscuro. Usa la misma
+// librería que el QR de la web (public/vendor/qrcode.js).
+const path = require('path');
+const qrcode = require(path.join(__dirname, '..', '..', 'public', 'vendor', 'qrcode.js'));
+
+const text = process.argv[2];
+if (!text) { console.error('uso: node qr.js <texto>'); process.exit(2); }
+const qr = qrcode(0, 'M');
+qr.addData(text);
+qr.make();
+
+const n = qr.getModuleCount();
+const quiet = 3; // margen claro alrededor (la cámara lo necesita para encontrar el código)
+const dark = (r, c) => r >= 0 && c >= 0 && r < n && c < n && qr.isDark(r, c);
+const ON = '\x1b[30;107m', OFF = '\x1b[0m'; // texto negro, fondo blanco brillante
+const lines = [];
+for (let r = -quiet; r < n + quiet; r += 2) {
+  let line = '  ' + ON;
+  for (let c = -quiet; c < n + quiet; c++) {
+    const top = dark(r, c), bottom = dark(r + 1, c);
+    line += top && bottom ? '█' : top ? '▀' : bottom ? '▄' : ' ';
+  }
+  lines.push(line + OFF);
+}
+process.stdout.write(lines.join('\n') + '\n');

package/lib/tools/url.syn

@@ -0,0 +1,220 @@
+-- lib/tools/url.syn — URLs para la tool fetch y para permission.syn (puro, sin capacidades)
+--
+--   parse(url)        → {ok, error?, url, scheme, host, port, path, query, origin, dir}
+--   host_class(host)  → "public" | "private" | "blocked"
+--   sensitive(url)    → motivo (texto) si la URL lleva una credencial, o nothing
+--   resolve(base, href) → URL absoluta de un href (relativo o no), o nothing si no es navegable (#, javascript:)
+--
+-- Política de hosts (tomada de hermes url_safety.py, sin resolver DNS: el runtime no expone un resolver):
+--   * "blocked": endpoints de metadata de la nube (169.254.169.254 y familia, metadata.google.internal).
+--     Nunca son un destino legítimo: se deniegan SIEMPRE, incluso en yolo.
+--   * "private": loopback, redes privadas (10/8, 172.16/12, 192.168/16, CGNAT 100.64/10), link-local,
+--     localhost y sufijos internos. Legítimo para mirar el propio dev server → PIDE aprobación (yolo permite,
+--     strict deniega). Un host numérico ambiguo (entero, hex, octal) cae aquí también.
+--   * "public": el resto. Límite conocido: sin DNS no se detecta un nombre público que resuelve a una IP
+--     privada (DNS rebinding); hermes lo cubre con un resolver, aquí queda documentado.
+
+let SENSITIVE_PARAMS be ["access_token", "api_key", "apikey", "auth_token", "authorization", "awsaccesskeyid", "client_secret", "credential", "credentials", "jwt", "password", "passwd", "secret", "session_id", "signature", "token", "private_key", "x_amz_security_token", "x_amz_signature", "x-amz-security-token", "x-amz-signature"]
+let SECRET_RE be "(?i)(\\bsk-(ant-|proj-)?[a-z0-9_-]{24,}|\\bghp_[a-z0-9]{20,}|\\bgithub_pat_[a-z0-9_]{20,}|\\bgho_[a-z0-9]{20,}|\\bglpat-[a-z0-9_-]{16,}|\\bxox[abprs]-[a-z0-9-]{10,}|\\bakia[0-9a-z]{16}\\b|\\baiza[0-9a-z_-]{30,}|-----begin [a-z ]*private key|\\beyj[a-z0-9_-]{20,}\\.eyj[a-z0-9_-]{20,})"
+
+task fail(msg)
+    give {"ok": false, "error": msg}
+
+export task parse(raw)
+    when raw == nothing
+        give fail("missing URL")
+    let u be trim(text(raw))
+    -- "https:// host" — el modelo a veces mete un espacio tras el esquema (hermes normalize_url_for_request)
+    set u to regex_replace(u, "^([A-Za-z][A-Za-z0-9+.-]*://)\\s+", "\\1")
+    when u == ""
+        give fail("missing URL")
+    when length(u) > 2048
+        give fail("URL longer than 2048 chars")
+    when contains(u, " ") or contains(u, "\n") or contains(u, "\t")
+        give fail("URL contains whitespace: " + u)
+    let sp be split(u, "://")
+    when length(sp) < 2
+        give fail("not an absolute http(s) URL: " + u)
+    let scheme be lower(sp[0])
+    when scheme != "http" and scheme != "https"
+        give fail("unsupported scheme '" + scheme + "' (only http and https)")
+    let rest be join(slice(sp, 1, length(sp)), "://")
+    -- fragmento y query
+    let frag_sp be split(rest, "#")
+    set rest to frag_sp[0]
+    let q_sp be split(rest, "?")
+    let query be when length(q_sp) > 1 then join(slice(q_sp, 1, length(q_sp)), "?") otherwise ""
+    set rest to q_sp[0]
+    -- autoridad y path
+    let slash_sp be split(rest, "/")
+    let authority be slash_sp[0]
+    let path be when length(slash_sp) > 1 then "/" + join(slice(slash_sp, 1, length(slash_sp)), "/") otherwise "/"
+    when contains(authority, "@")
+        give fail("credentials in the URL are not allowed")
+    when authority == ""
+        give fail("missing host: " + u)
+    let host be lower(authority)
+    let port be ""
+    when starts_with(host, "[")
+        -- IPv6 literal: [::1]:8080
+        let close be split(host, "]")
+        set host to slice(close[0], 1, length(close[0]))
+        when length(close) > 1 and starts_with(close[1], ":")
+            set port to slice(close[1], 1, length(close[1]))
+    otherwise
+        let hp be split(host, ":")
+        when length(hp) > 2
+            give fail("malformed host: " + authority)
+        set host to hp[0]
+        when length(hp) == 2
+            set port to hp[1]
+    when port != "" and not matches(port, "[0-9]{1,5}")
+        give fail("malformed port: " + port)
+    -- "example.com." (FQDN con punto final) ≡ "example.com"
+    while ends_with(host, ".")
+        set host to slice(host, 0, length(host) - 1)
+    when host == ""
+        give fail("missing host: " + u)
+    let origin be scheme + "://" + host + (when port != "" then ":" + port otherwise "")
+    let dir_parts be split(path, "/")
+    let dir be join(slice(dir_parts, 0, length(dir_parts) - 1), "/") + "/"
+    give {"ok": true, "url": origin + path + (when query != "" then "?" + query otherwise ""), "scheme": scheme, "host": host, "port": port, "path": path, "query": query, "origin": origin, "dir": dir}
+
+-- octetos de una IPv4 en notación decimal con puntos, o nothing
+task ipv4_octets(host)
+    when not matches(host, "[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}")
+        give nothing
+    let out be []
+    each p in split(host, ".")
+        let n be floor(number(p))
+        when n > 255
+            give nothing
+        set out to append(out, n)
+    give out
+
+task ipv4_class(o)
+    let a be o[0]
+    let b be o[1]
+    when a == 169 and b == 254
+        give "blocked"
+    when a == 100 and b == 100 and o[2] == 100 and o[3] == 200
+        give "blocked"
+    when a == 127 or a == 10 or a == 0
+        give "private"
+    when a == 192 and b == 168
+        give "private"
+    when a == 172 and b >= 16 and b <= 31
+        give "private"
+    when a == 100 and b >= 64 and b <= 127
+        give "private"
+    when a >= 224
+        give "private"
+    give "public"
+
+export task host_class(host)
+    let h be lower(text(host))
+    when h == "metadata.google.internal" or h == "metadata.goog" or h == "fd00:ec2::254"
+        give "blocked"
+    let o be ipv4_octets(h)
+    when o != nothing
+        give ipv4_class(o)
+    -- IPv6: loopback, unspecified, ULA fc00::/7, link-local fe80::/10, IPv4 mapeadas ::ffff:a.b.c.d
+    when contains(h, ":")
+        when h == "::1" or h == "::"
+            give "private"
+        when starts_with(h, "::ffff:")
+            let inner be ipv4_octets(slice(h, 7, length(h)))
+            give when inner != nothing then ipv4_class(inner) otherwise "private"
+        when starts_with(h, "fc") or starts_with(h, "fd") or starts_with(h, "fe8") or starts_with(h, "fe9") or starts_with(h, "fea") or starts_with(h, "feb")
+            give "private"
+        give "public"
+    when h == "localhost" or ends_with(h, ".localhost") or ends_with(h, ".internal") or ends_with(h, ".local") or ends_with(h, ".home.arpa") or ends_with(h, ".lan")
+        give "private"
+    -- formas numéricas ambiguas (2130706433, 0x7f000001, 0177.0.0.1): clásicos de bypass → tratar como privado
+    when matches(h, "[0-9]+") or matches(h, "0x[0-9a-f]+") or matches(h, "[0-9x.]+")
+        give "private"
+    give "public"
+
+-- %XX → carácter (para inspeccionar una URL con secretos codificados)
+task percent_decode(s)
+    let out be s
+    each m in regex_find_all(s, "%[0-9A-Fa-f]{2}")
+        let ch be nothing
+        try
+            set ch to json_decode("\"\\u00" + slice(m, 1, 3) + "\"")
+        recover e
+            set ch to nothing
+        when ch != nothing
+            set out to replace(out, m, ch)
+    give out
+
+export task sensitive(raw)
+    when raw == nothing
+        give nothing
+    let u be text(raw)
+    let decoded be percent_decode(u)
+    when length(regex_find_all(u, SECRET_RE)) > 0 or length(regex_find_all(decoded, SECRET_RE)) > 0
+        give "an API key or token"
+    let p be parse(u)
+    when not p["ok"]
+        give nothing
+    when p["query"] == ""
+        give nothing
+    each pair in split(p["query"], "&")
+        let kv be split(pair, "=")
+        let k be lower(trim(percent_decode(kv[0])))
+        let v be when length(kv) > 1 then join(slice(kv, 1, length(kv)), "=") otherwise ""
+        when v != "" and contains(SENSITIVE_PARAMS, k)
+            give "a credential-like query parameter (" + kv[0] + ")"
+    give nothing
+
+-- "/a/b/../c/./d" → "/a/c/d"
+task normalize_path(path)
+    let out be []
+    each seg in split(path, "/")
+        when seg == ".."
+            when length(out) > 0
+                set out to slice(out, 0, length(out) - 1)
+        otherwise when seg != "." and seg != ""
+            set out to append(out, seg)
+    give "/" + join(out, "/") + (when ends_with(path, "/") and length(out) > 0 then "/" otherwise "")
+
+export task resolve(base, href)
+    when href == nothing
+        give nothing
+    let h be trim(text(href))
+    let lh be lower(h)
+    when h == "" or starts_with(h, "#") or starts_with(lh, "javascript:") or starts_with(lh, "data:") or starts_with(lh, "mailto:") or starts_with(lh, "tel:")
+        give nothing
+    when matches(h, "[A-Za-z][A-Za-z0-9+.-]*:.*")
+        give h
+    let b be parse(base)
+    when not b["ok"]
+        give h
+    when starts_with(h, "//")
+        give b["scheme"] + ":" + h
+    -- separar query/fragmento del path relativo para normalizar solo el path
+    let tail be ""
+    let core be h
+    let qi be split(h, "?")
+    let fi be split(h, "#")
+    when length(qi) > 1
+        set core to qi[0]
+        set tail to "?" + join(slice(qi, 1, length(qi)), "?")
+    otherwise when length(fi) > 1
+        set core to fi[0]
+        set tail to "#" + join(slice(fi, 1, length(fi)), "#")
+    when core == ""
+        give b["origin"] + b["path"] + tail
+    when starts_with(core, "/")
+        give b["origin"] + normalize_path(core) + tail
+    give b["origin"] + normalize_path(b["dir"] + core) + tail
+
+-- nombre de archivo estable para la caché/spill de una URL: fetch-<host>-<digest>
+export task slug(host)
+    let s be regex_replace(lower(text(host)), "[^a-z0-9._-]", "-")
+    when length(s) > 60
+        set s to slice(s, 0, 60)
+    when s == ""
+        give "page"
+    give s

package/lib/tools.syn

@@ -19,6 +19,7 @@ use "./tools/ls.syn" as t_ls
 use "./tools/find.syn" as t_find
 use "./tools/grep.syn" as t_grep
 use "./tools/bash.syn" as t_bash
+use "./tools/fetch.syn" as t_fetch
 use "./tools/skill.syn" as t_skill
 use "./tools/process.syn" as t_process
 use "./tools/memo.syn" as t_memo
@@ -28,6 +29,26 @@ use "./mcp.syn" as mcp
 use "./plugins.syn" as plugins
 use "./lsp.syn" as lsp
 use "./schedule.syn" as schedule
+use "./computer.syn" as computer
+
+-- la tool computer_use (lib/computer.syn): el escritorio y el navegador del usuario en segundo plano, sobre un
+-- driver externo. Está en el registry siempre, pero al catálogo del modelo solo entra cuando está encendida y el
+-- driver existe (agents.tool_names). Los args llegan planos del JSON del modelo y van a computer.call como map.
+-- OJO: cada propiedad del SPEC tiene que ser un parámetro acá — un arg que no está da "unknown parameter" antes de
+-- llegar a computer.call (2026-09-06: delivery_mode faltaba y el modelo no pudo apretar Enter en Chrome). Lo cubre
+-- un test de unit.test.syn que recorre las propiedades del SPEC.
+task computer_tool(action, pid, window_id, element, x, y, text, key, keys, modifiers, direction, amount, from_x, from_y, to_x, to_y, x1, y1, x2, y2, value, name, path, url, target_id, tab_id, ref, query, screenshot, max_elements, replace, delta_y, delta_x, profile, seconds, button, delivery_mode, option, app, capture_after, fields, goal, steps, enter)
+    require exec
+    require time
+    require env("LAMPSON_*")
+    require env("OS")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    let a be {}
+    each e in [["pid", pid], ["window_id", window_id], ["element", element], ["x", x], ["y", y], ["text", text], ["key", key], ["keys", keys], ["modifiers", modifiers], ["direction", direction], ["amount", amount], ["from_x", from_x], ["from_y", from_y], ["to_x", to_x], ["to_y", to_y], ["x1", x1], ["y1", y1], ["x2", x2], ["y2", y2], ["value", value], ["name", name], ["path", path], ["url", url], ["target_id", target_id], ["tab_id", tab_id], ["ref", ref], ["query", query], ["screenshot", screenshot], ["max_elements", max_elements], ["replace", replace], ["delta_y", delta_y], ["delta_x", delta_x], ["profile", profile], ["seconds", seconds], ["button", button], ["delivery_mode", delivery_mode], ["option", option], ["app", app], ["capture_after", capture_after], ["fields", fields], ["goal", goal], ["steps", steps], ["enter", enter]]
+        when e[1] != nothing
+            set a[e[0]] to e[1]
+    give computer.call(action, a)
 
 -- la task de la tool skill (su SPEC está en tools/skill.syn)
 task skill_tool(name, action, source, scope)
@@ -256,6 +277,7 @@ export task registry()
         "find": t_find.tool,
         "grep": t_grep.tool,
         "bash": t_bash.tool,
+        "fetch": t_fetch.tool,
         "process": t_process.tool,
         "memory": t_memo.tool,
         "todo": t_todo.tool,
@@ -263,10 +285,11 @@ export task registry()
         "mcp": mcp_tool,
         "plugin": plugin_tool,
         "lsp": lsp_tool,
-        "schedule": schedule_tool
+        "schedule": schedule_tool,
+        "computer_use": computer_tool
     }
 
-export let CATALOG be [t_read.SPEC, t_write.SPEC, t_edit.SPEC, t_ls.SPEC, t_find.SPEC, t_grep.SPEC, LSP_SPEC, t_bash.SPEC, t_process.SPEC, t_memo.SPEC, t_todo.SPEC, t_skill.SPEC, MCP_SPEC, PLUGIN_SPEC, SCHEDULE_SPEC]
+export let CATALOG be [t_read.SPEC, t_write.SPEC, t_edit.SPEC, t_ls.SPEC, t_find.SPEC, t_grep.SPEC, LSP_SPEC, t_fetch.SPEC, t_bash.SPEC, t_process.SPEC, t_memo.SPEC, t_todo.SPEC, t_skill.SPEC, MCP_SPEC, PLUGIN_SPEC, SCHEDULE_SPEC, computer.SPEC]
 
 -- Subconjuntos (para perfiles de agente): registry/catálogo filtrados por nombre.
 export task registry_subset(names)

package/lib/trace.syn

@@ -16,7 +16,7 @@ task path(sid)
     give DIR + "/" + sid + ".log"
 
 task one_line(s, max)
-    let t be replace_text(replace_text(text(s), "\r", ""), "\n", " ⏎ ")
+    let t be replace(replace(text(s), "\r", ""), "\n", " ⏎ ")
     when length(t) > max
         give slice(t, 0, max) + "…"
     give t
@@ -105,7 +105,7 @@ export task tail(sid, n)
     require file(".lampson")
     require file(".lampson/*")
     try
-        let lines be split(replace_text(read_file(path(sid)), "\r", ""), "\n")
+        let lines be split(replace(read_file(path(sid)), "\r", ""), "\n")
         when length(lines) > n
             set lines to slice(lines, length(lines) - n, length(lines))
         give join(lines, "\n")

package/lib/tree.syn

@@ -3,35 +3,38 @@ use "./tools/common.syn" as c
 
 let MAX_ENTRIES be 2000
 
-task walk(dir, depth, max_depth, state)
+-- n = entradas contadas hasta ahora en todo el árbol; da {items, n} (listas y mapas son valores: el contador vuelve con give)
+task walk(dir, depth, max_depth, n)
     let out be []
     when depth > max_depth
-        give out
+        give {"items": out, "n": n}
     let entries be []
     try
         set entries to list_dir(dir)
     recover err
-        give out
+        give {"items": out, "n": n}
     each e in entries
-        when state["n"] >= MAX_ENTRIES
-            give out
+        when n >= MAX_ENTRIES
+            give {"items": out, "n": n}
         let rel be c.unws(dir + "/" + e["name"])
         when e["is_dir"]
             when not contains(c.IGNORED_DIRS, e["name"])
-                set state["n"] to state["n"] + 1
-                set out to append(out, {"name": e["name"], "path": rel, "is_dir": true, "children": walk(dir + "/" + e["name"], depth + 1, max_depth, state)})
+                set n to n + 1
+                let sub be walk(dir + "/" + e["name"], depth + 1, max_depth, n)
+                set n to sub["n"]
+                set out to append(out, {"name": e["name"], "path": rel, "is_dir": true, "children": sub["items"]})
         otherwise
-            set state["n"] to state["n"] + 1
+            set n to n + 1
             set out to append(out, {"name": e["name"], "path": rel, "is_dir": false, "size": e["size"]})
     -- carpetas primero
-    give where(out, (x) => x["is_dir"]) + where(out, (x) => not x["is_dir"])
+    give {"items": where(out, (x) => x["is_dir"]) + where(out, (x) => not x["is_dir"]), "n": n}
 
 -- árbol anidado: [{name, path, is_dir, size?, children?}]
 export task tree(max_depth)
     require file.read("workspace")
     require file.read("workspace/*")
-    let state be {"n": 0}
-    give {"entries": walk(c.ROOT, 0, max_depth, state), "count": state["n"], "truncated": state["n"] >= MAX_ENTRIES}
+    let w be walk(c.ROOT, 0, max_depth, 0)
+    give {"entries": w["items"], "count": w["n"], "truncated": w["n"] >= MAX_ENTRIES}
 
 -- render de texto para la terminal (2 niveles, compacto)
 export task render(max_depth, max_lines)
@@ -55,5 +58,18 @@ export task file_content(path)
     require file.read("workspace")
     require file.read("workspace/*")
     let real be c.ws(path)
-    let content be read_file(real)
-    give {"path": c.unws(real), "content": c.truncate(content, 200000), "lines": length(split(content, "\n"))}
+    let rel be c.unws(real)
+    let info be file_info(real)
+    when not info["exists"]
+        raise("\"" + rel + "\" does not exist")
+    when info["is_dir"]
+        raise("\"" + rel + "\" is a folder")
+    -- binarios (sqlite, imágenes, fuentes…): read_file no puede decodificarlos como UTF-8 y el runtime lo reporta
+    -- como "File not found" (engañoso; visto 2026-09-05 con un dev.db de Prisma). En vez de un error, {binary: true}
+    -- y el visor muestra su aviso, sin ensuciar el chat.
+    try
+        let content be read_file(real)
+        -- truncated: el editor de la web lo abre en solo lectura (guardar el recorte destruiría el archivo)
+        give {"path": rel, "content": c.truncate(content, 200000), "lines": length(split(content, "\n")), "truncated": length(content) > 200000, "binary": false, "size": info["size"]}
+    recover err
+        give {"path": rel, "content": "", "lines": 0, "truncated": false, "binary": true, "size": info["size"], "error": text(err)}

package/lib/update.syn

@@ -12,7 +12,7 @@ task run_git(args, secs)
         let r be run("git", args, secs)
         when r["exit_code"] != 0
             give nothing
-        give trim(replace_text(r["stdout"], "\r", ""))
+        give trim(replace(r["stdout"], "\r", ""))
     recover err
         give nothing