lampson 0.1.1 → 0.1.2

package/README.md

@@ -132,6 +132,18 @@ In the REPL, `/` lists every command (`/agent`, `/ask` `/yolo` `/strict`, `/mode
 `/files`, `/procs`, `/logs <name>`, `/stop <name>`, `/kill <pid>`, `/skills`, `/sessions`,
 `/resume <id>`, `/tokens`, `/flags`). `!cmd` runs a command yourself.
 
+The prompt is a real line editor (Synsema ≥ 0.6.11, falls back to plain `read_line` without a TTY):
+typing `/` opens the command menu (recent ones first, filtered as you type), `Tab` completes the
+command and then its arguments (files for `/image`, sessions, providers, processes, lamps, MCP/LSP
+servers, flags), `↑↓` browse history or the menu, `Alt+Enter` inserts a newline, `Ctrl+O` shows the
+last tool result in full, `Ctrl+U`/`Ctrl+W` clear the line/word, `Esc` closes the menu. Approvals are
+an arrow-key menu (`permitir`/`denegar`, or `p`/`d`).
+
+The terminal renders the model's markdown (headings, lists, tables, code fences) and shows every tool
+result: `edit`/`write` print a line diff (`- red / + green`, line numbers, 2 lines of context); other
+tools are collapsed to 15 lines. `/out [n]` prints the n-th last result of the turn in full and
+`/verbose` toggles full output for every tool (saved in `.lampson/config.json`).
+
 The project is mounted as `lampson/workspace` (an NTFS junction on Windows, a symlink elsewhere)
 and every tool declares `file("workspace/*")` — that literal, named scope is what makes the
 confinement real. Config, sessions and process logs live in the `lampson` folder, never in your project.

package/chat.syn

@@ -43,6 +43,9 @@ use "./lib/tools/memo.syn" as memo
 use "./lib/update.syn" as update
 use "./lib/settings.syn" as settings
 use "./lib/trace.syn" as trace
+use "./lib/md.syn" as md
+use "./lib/diff.syn" as diff
+use "./lib/line.syn" as ed
 use "./lib/mcp.syn" as mcp
 use "./lib/lamps.syn" as lamps
 use "./lib/lsp.syn" as lsp
@@ -53,6 +56,12 @@ use "./lib/tools/todo.syn" as todo
 
 let ESC be decode(bytes("1b", "hex"))
 let COLOR be env("LAMPSON_NO_COLOR", "") == ""
+-- /verbose: mostrar el output completo de cada tool (persistido en .lampson/config.json); si no, se
+-- colapsa a OUT_LINES líneas y /out [n] muestra el resultado n-ésimo (desde el último) del turno completo
+let saved_cfg be settings.load()
+let VERBOSE be contains(saved_cfg, "verbose") and saved_cfg["verbose"] == true
+let OUT_LINES be 15
+let turn_outputs be []
 
 task c(code, s)
     when not COLOR
@@ -86,37 +95,83 @@ task summarize(name, out)
     let lines be split(out, "\n")
     when starts_with(out, "ERROR") or starts_with(out, "DENIED")
         give first_line(out, 140)
-    when name == "read"
+    when name == "read" and not VERBOSE
         give text(length(lines)) + " líneas"
-    when name == "ls" or name == "find" or name == "grep"
-        give text(length(lines)) + " resultados · " + first_line(out, 90)
-    when name == "bash"
-        -- hasta 5 líneas del output, el resto colapsado
+    when (name == "ls" or name == "find") and not VERBOSE
+        -- las primeras entradas en una línea (hasta ~100 chars), y cuántas más hay
+        let shown be []
+        let used be 0
+        each l in lines
+            when used < 100 and trim(l) != ""
+                set shown to append(shown, trim(l))
+                set used to used + length(l) + 2
+        let rest be length(lines) - length(shown)
+        give text(length(lines)) + (when name == "ls" then " entradas: " otherwise " archivos: ") + join(shown, "  ") + (when rest > 0 then dim("  +" + text(rest)) otherwise "")
+    when name == "grep" and not VERBOSE
+        let files be {}
+        each l in lines
+            let f be split(l, ":")[0]
+            when trim(l) != ""
+                set files[f] to true
+        give text(length(lines)) + " coincidencias en " + text(length(keys(files))) + " archivo" + (when length(keys(files)) == 1 then "" otherwise "s") + " · " + first_line(out, 90)
+    when name == "bash" or name == "process" or VERBOSE
+        -- hasta OUT_LINES líneas del output (todas con /verbose), el resto colapsado → /out
         let shown be []
         each e in enumerate(lines)
-            when e["index"] < 5
-                when trim(e["item"]) != ""
-                    set shown to append(shown, slice(e["item"], 0, 140))
-        let extra be when length(lines) > 5 then dim("  (+" + text(length(lines) - 5) + " líneas)") otherwise ""
+            when VERBOSE or e["index"] < OUT_LINES
+                set shown to append(shown, when VERBOSE then e["item"] otherwise slice(e["item"], 0, 160))
+        let extra be when not VERBOSE and length(lines) > OUT_LINES then "\n      " + dim("(+" + text(length(lines) - OUT_LINES) + " líneas · /out para ver todo)") otherwise ""
         give join(shown, "\n      ") + extra
     give first_line(out, 120)
 
+-- diff de un edit/write (antes/después publicado por la tool en el blackboard) — nothing si no hay
+task diff_of(name, out)
+    when name != "edit" and name != "write"
+        give nothing
+    when starts_with(out, "ERROR") or starts_with(out, "DENIED")
+        give nothing
+    observe "lampson:ui:diff" as d
+    when d == nothing
+        give nothing
+    give diff.diff(d["old"], d["new"], 2, COLOR)
+
+task print_diff(path, d)
+    let head be path + " · " + green("+" + text(d["added"])) + " " + red("−" + text(d["removed"]))
+    print("    " + green("✓") + " " + head)
+    each l in d["lines"]
+        print("      " + l)
+
+-- /out: resultado completo de una tool del turno
+task print_full(o)
+    when o["diff"] != nothing
+        print_diff(o["path"], o["diff"])
+    otherwise
+        each l in split(o["output"], "\n")
+            print("      " + l)
+
 -- tag = "" para el agente principal; los subagentes en background NO pasan por acá (escriben su log)
 task on_event(kind, data, tag)
     trace.event(sid, kind, data, tag)
     when kind == "assistant"
         print("")
-        print(data)
+        print(md.render(data, COLOR))
         print("")
     otherwise when kind == "inbox"
         print("  " + cyan("✉ " + first_line(data, 140)))
     otherwise when kind == "tool_call"
-        print("  " + yellow("⚙ " + permission.describe_call(data["name"], data["args"])))
+        print("  " + yellow("▸ " + permission.describe_call(data["name"], data["args"])))
     otherwise when kind == "tool_result"
         let out be data["output"]
+        let name be data["call"]["name"]
         let bad be starts_with(out, "ERROR") or starts_with(out, "DENIED")
-        let mark be when bad then red("✗") otherwise green("✓")
-        print("    " + mark + " " + (when bad then red(summarize(data["call"]["name"], out)) otherwise dim(summarize(data["call"]["name"], out))))
+        let d be diff_of(name, out)
+        let path be when d != nothing then text(data["call"]["args"]["path"]) otherwise ""
+        set turn_outputs to append(turn_outputs, {"name": name, "args": data["call"]["args"], "output": out, "diff": d, "path": path})
+        when d != nothing
+            print_diff(path, d)
+        otherwise
+            let mark be when bad then red("✗") otherwise green("✓")
+            print("    " + mark + " " + (when bad then red(summarize(name, out)) otherwise dim(summarize(name, out))))
     otherwise when kind == "tool_denied"
         set data to data
     otherwise when kind == "error"
@@ -134,8 +189,12 @@ task ask_user(name, args, why)
     print("  " + yellow("⚠ requiere tu aprobación · " + why))
     print("    " + permission.describe_call(name, args))
     flush()
-    let ok be approve "  ¿permitir?" within 10m
-    give ok
+    -- menú ↑↓/Enter (o p/d, 1/2, Esc = no) cuando hay TTY; sin TTY, el approve nativo (fail-closed)
+    let pick be ed.choose("  ¿permitir?", ["permitir", "denegar"], COLOR)
+    when pick == -1
+        let ok be approve "  ¿permitir?" within 10m
+        give ok
+    give pick == 0
 
 let LINE be "  ────────────────────────────────────────────────────────────────────────"
 
@@ -164,6 +223,8 @@ let COMMANDS be [
     ["/mcp", "[add <nombre> <comando…> [--project] | remove <nombre>]", "servers MCP: listar, conectar o quitar (global: lampson/.lampson/mcp.json · proyecto: .lampson/mcp.json)"],
     ["/lamps", "[on <nombre> | off <nombre> | run <lámpara> <tool> [json] | remove <nombre>]", "lámparas (plugins de tools): listar, encender o apagar (global: lampson/lamps/ · proyecto: .lampson/lamps/)"],
     ["/lsp", "[add <typescript|python|rust|go|css|html> [--project] | add <nombre> <comando…> --ext .x=lang | remove <nombre>]", "language servers (navegación semántica: symbols/definition/references/hover); arrancan en la primera consulta"],
+    ["/out", "[n]", "resultado completo de la última tool del turno (n = contar hacia atrás: /out 2 es la anteúltima)"],
+    ["/verbose", "", "alternar: mostrar SIEMPRE el output completo de cada tool (queda guardado en config.json)"],
     ["/trace", "[n]", "traza legible de esta sesión (pasos, tools, tiempos, tokens, errores): .lampson/trace/<sesión>.log"],
     ["/tokens", "", "tamaño del contexto y tokens gastados en esta sesión"],
     ["/new", "", "empezar una sesión nueva (historial vacío)"],
@@ -182,10 +243,138 @@ task pad(s, n)
         set out to out + " "
     give out
 
+-- entrada multilínea sin modo raw (read_key llegará a Synsema): una línea que termina en "\" continúa
+-- en la siguiente; una línea que EMPIEZA con """ abre un bloque que cierra con una línea """ sola
+-- (ideal para pegar código o logs). EOF corta el bloque con lo acumulado.
+-- candidatos para completar el argumento de un comando (Tab / menú del editor de línea).
+-- head = argumentos ya escritos antes del último token; last = lo que se está escribiendo
+task complete_args(cmd, head, last)
+    let first be trim(head) == ""
+    when cmd == "/image"
+        give workspace_paths(last)
+    when cmd == "/resume" or cmd == "/delete"
+        give apply((s) => s["id"], session.list())
+    when cmd == "/provider"
+        when first
+            give apply((p) => p["name"], provider.providers())
+        give []
+    when cmd == "/logs" or cmd == "/stop"
+        when first
+            give apply((p) => p["name"], proc.list())
+        give []
+    when cmd == "/memory"
+        give apply((m) => m["name"], memo.list())
+    when cmd == "/lamps"
+        when first
+            give ["on", "off", "run", "remove"]
+        give apply((l) => l["name"], lamps.summary())
+    when cmd == "/mcp"
+        when first
+            give ["add", "remove"]
+        when starts_with(trim(head), "remove")
+            give apply((m) => m["name"], mcp.summary())
+        give ["--project"]
+    when cmd == "/lsp"
+        when first
+            give ["add", "remove"]
+        when starts_with(trim(head), "remove")
+            give apply((s) => s["name"], lsp.summary())
+        when trim(head) == "add"
+            give sort_by(keys(lsp.PRESETS), (x) => x)
+        give ["--project", "--ext"]
+    when cmd == "/agent"
+        give ["build", "plan", "review", "explore", "worker"]
+    when cmd == "/model"
+        give []
+    give []
+
+-- rutas del workspace que empiezan con el prefijo escrito (directorios con "/" final para seguir completando)
+task workspace_paths(prefix)
+    let dir be ""
+    let base be prefix
+    let cut be -1
+    let i be length(prefix) - 1
+    while i >= 0 and cut == -1
+        when slice(prefix, i, i + 1) == "/" or slice(prefix, i, i + 1) == "\\"
+            set cut to i
+        set i to i - 1
+    when cut >= 0
+        set dir to slice(prefix, 0, cut + 1)
+        set base to slice(prefix, cut + 1, length(prefix))
+    let out be []
+    try
+        each e in list_dir(when dir == "" then "workspace" otherwise "workspace/" + dir)
+            when starts_with(e["name"], base) and e["name"] != ".git"
+                set out to append(out, dir + e["name"] + (when e["is_dir"] then "/" otherwise ""))
+    recover err
+        set out to []
+    give sort_by(out, (x) => x)
+
+-- mientras el humano no escribe: ¿hay avisos de subagentes en background? → cortar la lectura y
+-- dejar que el bucle principal los inyecte (turno automático)
+task idle()
+    let pending be false
+    try
+        each c in agents.list_children()
+            when c["status"] != "running" and not c["delivered"]
+                set pending to true
+    recover err
+        set pending to false
+    give pending
+
+let input_history be []
+
+task read_input(prompt)
+    let first be read_line(prompt)
+    when first == nothing
+        give nothing
+    let more be []
+    when trim(first) == "\"\"\"" or starts_with(first, "\"\"\"")
+        let body be slice(first, 3, length(first))
+        when trim(body) != ""
+            set more to append(more, body)
+        let open be true
+        while open
+            let l be read_line(dim("  … "))
+            when l == nothing or trim(l) == "\"\"\""
+                set open to false
+            otherwise
+                set more to append(more, l)
+        give join(more, "\n")
+    let cur be first
+    while ends_with(cur, "\\")
+        set more to append(more, slice(cur, 0, length(cur) - 1))
+        let l be read_line(dim("  … "))
+        set cur to when l == nothing then "" otherwise l
+    set more to append(more, cur)
+    give join(more, "\n")
+
+-- últimos comandos usados (config.json "recent"): "/" solo los muestra primero
+task remember_command(input)
+    let name be split(trim(input), " ")[0]
+    when name == "/" or name == "/help"
+        give nothing
+    let doc be settings.load()
+    let old be when contains(doc, "recent") then doc["recent"] otherwise []
+    let recent be [name]
+    each r in old
+        when r != name and length(recent) < 3
+            set recent to append(recent, r)
+    set doc["recent"] to recent
+    settings.save(doc)
+    give nothing
+
 task help()
+    let doc be settings.load()
+    let recent be when contains(doc, "recent") then doc["recent"] otherwise []
     print("")
+    when length(recent) > 0
+        print("  recientes   " + join(apply((r) => cyan(r), recent), "   "))
+        print("")
     print("  Escribí lo que querés hacer en el proyecto. El agente lee, busca, edita y corre comandos con tools")
     print("  acotadas al workspace; cada paso queda a la vista. Los comandos empiezan con /:")
+    print("  Teclas: Tab completa · ↑↓ historial/menú · Alt+Enter salto de línea · Ctrl+O último resultado completo · Esc cierra el menú")
+    print("  Sin TTY (pipe): terminá la línea con \\ para continuar, o un bloque entre líneas \"\"\".")
     print("")
     each c in COMMANDS
         print("  " + pad(c[0] + " " + c[1], 38) + c[2])
@@ -238,6 +427,21 @@ task banner(ws, cfg, profile, mode, sid)
     print("  workspace   " + ws)
     print("  agente      " + profile + "        permisos  " + mode + "        modelo  " + cfg["model"])
     print("  sesión      " + sid + "        " + git.summary())
+    -- extensiones en una línea (detalle con /lamps, /mcp, /lsp): encendidas/total
+    let ls be lamps.summary()
+    let lamps_on be length(where(ls, (l) => l["enabled"]))
+    let ms be mcp.summary()
+    let mcp_on be length(where(ms, (m) => m["status"] == "ready"))
+    let ss be lsp.summary()
+    let ext be []
+    when length(ls) > 0
+        set ext to append(ext, (when lamps_on > 0 then green("lamps " + text(lamps_on) + "/" + text(length(ls))) otherwise dim("lamps 0/" + text(length(ls)))))
+    when length(ms) > 0
+        set ext to append(ext, (when mcp_on == length(ms) then green("mcp " + text(mcp_on) + "/" + text(length(ms))) otherwise red("mcp " + text(mcp_on) + "/" + text(length(ms)))))
+    when length(ss) > 0
+        set ext to append(ext, dim("lsp " + text(length(ss))))
+    when length(ext) > 0
+        print("  extras      " + join(ext, dim("  ·  ")) + dim("   (/lamps /mcp /lsp)"))
     let upd be update.line()
     when upd != ""
         print("  " + yellow("⬆ " + upd) + dim("  (o /update acá)"))
@@ -402,14 +606,13 @@ let system_msg be system_for(profile)
 -- servers MCP (globales en .lampson/mcp.json, del proyecto en workspace/.lampson/mcp.json): arrancan antes
 -- de armar el catálogo de tools; hasta 8 s de espera a que estén listos
 let mcp_servers be mcp.start_all(8)
+-- mcp / lsp / lámparas van resumidos en el banner ("extras"); acá solo se avisa lo que está ROTO
 each ms in mcp.summary()
-    print("  " + (when ms["status"] == "ready" then green("● mcp " + ms["name"]) otherwise red("○ mcp " + ms["name"] + " " + ms["status"])) + dim(" (" + ms["scope"] + ") " + text(length(ms["tools"])) + " tools" + (when ms["error"] != nothing then " · " + text(ms["error"]) otherwise "")))
--- language servers (lib/lsp.syn): solo se anuncian; arrancan lazy en la primera consulta
-each s in lsp.summary()
-    print("  " + dim("○ lsp " + s["name"] + " (" + s["scope"] + ") " + join(s["extensions"], " ") + " · arranca en la primera consulta"))
--- lámparas (plugins de tools, lib/lamps.syn): solo se anuncian; apagadas no entran al catálogo
+    when ms["status"] != "ready"
+        print("  " + red("○ mcp " + ms["name"] + " " + ms["status"]) + dim(when ms["error"] != nothing then " · " + text(ms["error"]) otherwise ""))
 each l in lamps.summary()
-    print("  " + (when l["enabled"] then green("● lamp " + l["name"]) otherwise dim("○ lamp " + l["name"] + " off")) + dim(" (" + l["scope"] + ", " + l["kind"] + ") " + text(length(l["tools"])) + " tools" + (when l["error"] != nothing then " · " + text(l["error"]) otherwise "")))
+    when l["error"] != nothing
+        print("  " + red("○ lamp " + l["name"] + " rota") + dim(" · " + text(l["error"])))
 let opts be opts_for(profile, lower(env("LAMPSON_PERMISSION", "ask")))
 
 -- marca de corrida (blackboard): session.save la estampa en meta.run; reanudar una sesión guardada por
@@ -465,14 +668,24 @@ while running
         session.save(sid, messages, {"title": session.title_of(messages)})
         flush()
     otherwise
-        set line to read_line("\n" + (when length(pending_images) > 0 then dim("📎" + text(length(pending_images)) + " ") otherwise "") + cyan("❯ "))
+        let saved be settings.load()
+        let ctx be {"commands": COMMANDS, "recent": (when contains(saved, "recent") then saved["recent"] otherwise []), "history": input_history, "complete": complete_args, "idle": idle, "fallback": read_input}
+        set line to ed.read((when length(pending_images) > 0 then dim("📎" + text(length(pending_images)) + " ") otherwise "") + cyan("❯ "), COLOR, ctx)
+        when line != nothing and line != ed.INTERRUPT and trim(line) != ""
+            set input_history to append(input_history, line)
     when inbox != nothing
         set running to running
+    otherwise when line == ed.INTERRUPT
+        set running to running
     otherwise when line == nothing
         set running to false
     otherwise
         set followups to 0
+        when not starts_with(trim(line), "/")
+            set turn_outputs to []
         let input be trim(line)
+        when starts_with(input, "/") and length(input) > 1
+            remember_command(input)
         when input == ""
             set running to running
         otherwise when input == "/exit" or input == "/quit"
@@ -491,6 +704,23 @@ while running
                 print("  " + update.apply())
         otherwise when input == "/config"
             show_config(cfg, env_info["cwd"], profile, mode, opts)
+        otherwise when input == "/verbose"
+            set VERBOSE to not VERBOSE
+            let doc be settings.load()
+            set doc["verbose"] to VERBOSE
+            settings.save(doc)
+            print("  " + (when VERBOSE then green("verbose ON") + dim(" · cada tool muestra su output completo") otherwise dim("verbose OFF · outputs colapsados a " + text(OUT_LINES) + " líneas; /out para ver uno completo")))
+        otherwise when starts_with(input, "/out")
+            let n be trim(slice(input, 4, length(input)))
+            let back be when n == "" then 1 otherwise floor(number(n))
+            when length(turn_outputs) == 0
+                print(dim("  ninguna tool corrió en este turno"))
+            otherwise when back < 1 or back > length(turn_outputs)
+                print(dim("  hay " + text(length(turn_outputs)) + " resultados en este turno: /out 1 … /out " + text(length(turn_outputs))))
+            otherwise
+                let o be turn_outputs[length(turn_outputs) - back]
+                print("  " + yellow("▸ " + permission.describe_call(o["name"], o["args"])))
+                print_full(o)
         otherwise when starts_with(input, "/trace")
             let n be trim(slice(input, 6, length(input)))
             let lines be when n == "" then 40 otherwise floor(number(n))

package/lib/diff.syn

@@ -0,0 +1,142 @@
+-- lib/diff.syn — diff de líneas para mostrar en la terminal qué cambió edit/write
+--   diff(old, new, ctx, color) → {"added": n, "removed": m, "lines": [texto ya formateado…]}
+-- Algoritmo: se recorta el prefijo y sufijo comunes (una edición es local) y se hace LCS solo sobre el
+-- medio. Si el medio es enorme (> LIMIT² celdas) se muestra como bloque quitado + bloque agregado.
+
+let ESC be decode(bytes("1b", "hex"))
+let LIMIT be 600
+
+task sgr(color, code, s)
+    when not color
+        give s
+    give ESC + "[" + code + "m" + s + ESC + "[0m"
+
+task lpad(s, n)
+    let out be s
+    while length(out) < n
+        set out to " " + out
+    give out
+
+-- LCS clásico: devuelve la lista de ops {"op": " "|"-"|"+", "a": idx_old, "b": idx_new}
+task lcs_ops(a, b)
+    let n be length(a)
+    let m be length(b)
+    -- tabla (n+1)×(m+1) aplanada, fila por fila
+    let table be []
+    let size be (n + 1) * (m + 1)
+    while length(table) < size
+        set table to append(table, 0)
+    let i be n - 1
+    while i >= 0
+        let j be m - 1
+        while j >= 0
+            when a[i] == b[j]
+                set table[i * (m + 1) + j] to table[(i + 1) * (m + 1) + j + 1] + 1
+            otherwise
+                let down be table[(i + 1) * (m + 1) + j]
+                let right be table[i * (m + 1) + j + 1]
+                set table[i * (m + 1) + j] to (when down >= right then down otherwise right)
+            set j to j - 1
+        set i to i - 1
+    let ops be []
+    set i to 0
+    let j be 0
+    while i < n and j < m
+        when a[i] == b[j]
+            set ops to append(ops, {"op": " ", "a": i, "b": j})
+            set i to i + 1
+            set j to j + 1
+        otherwise when table[(i + 1) * (m + 1) + j] >= table[i * (m + 1) + j + 1]
+            set ops to append(ops, {"op": "-", "a": i, "b": j})
+            set i to i + 1
+        otherwise
+            set ops to append(ops, {"op": "+", "a": i, "b": j})
+            set j to j + 1
+    while i < n
+        set ops to append(ops, {"op": "-", "a": i, "b": j})
+        set i to i + 1
+    while j < m
+        set ops to append(ops, {"op": "+", "a": i, "b": j})
+        set j to j + 1
+    give ops
+
+export task diff(old, new, ctx, color)
+    let a be when old == "" then [] otherwise split(old, "\n")
+    let b be when new == "" then [] otherwise split(new, "\n")
+    -- prefijo común
+    let pre be 0
+    while pre < length(a) and pre < length(b) and a[pre] == b[pre]
+        set pre to pre + 1
+    -- sufijo común (sin pisar el prefijo)
+    let suf be 0
+    while suf < length(a) - pre and suf < length(b) - pre and a[length(a) - 1 - suf] == b[length(b) - 1 - suf]
+        set suf to suf + 1
+    let mid_a be slice(a, pre, length(a) - suf)
+    let mid_b be slice(b, pre, length(b) - suf)
+    let ops be []
+    when length(mid_a) * length(mid_b) > LIMIT * LIMIT
+        each e in enumerate(mid_a)
+            set ops to append(ops, {"op": "-", "a": e["index"], "b": 0})
+        each e in enumerate(mid_b)
+            set ops to append(ops, {"op": "+", "a": length(mid_a), "b": e["index"]})
+    otherwise
+        set ops to lcs_ops(mid_a, mid_b)
+    let added be 0
+    let removed be 0
+    each o in ops
+        when o["op"] == "+"
+            set added to added + 1
+        otherwise when o["op"] == "-"
+            set removed to removed + 1
+    -- render: ctx líneas de contexto antes y después del bloque cambiado (números de línea del archivo NUEVO
+    -- para "+"/" ", del viejo para "-"), con "⋯" entre hunks
+    let width be length(text(length(b)))
+    let lines be []
+    -- contexto previo (del prefijo común)
+    let start be when pre - ctx > 0 then pre - ctx otherwise 0
+    when start > 0
+        set lines to append(lines, sgr(color, "2", lpad("", width) + " ⋯"))
+    let k be start
+    while k < pre
+        set lines to append(lines, sgr(color, "2", lpad(text(k + 1), width) + " │   " + a[k]))
+        set k to k + 1
+    -- medio: contexto interno acotado (ctx a cada lado de un cambio)
+    let last_change be -1
+    let idx be 0
+    each o in ops
+        when o["op"] != " "
+            set last_change to idx
+        set idx to idx + 1
+    set idx to 0
+    let skipping be false
+    each o in ops
+        let near be false
+        let w be idx - ctx
+        while w <= idx + ctx and not near
+            when w >= 0 and w < length(ops) and ops[w]["op"] != " "
+                set near to true
+            set w to w + 1
+        when o["op"] == " "
+            when near
+                set lines to append(lines, sgr(color, "2", lpad(text(pre + o["b"] + 1), width) + " │   " + mid_b[o["b"]]))
+                set skipping to false
+            otherwise when not skipping
+                set lines to append(lines, sgr(color, "2", lpad("", width) + " ⋯"))
+                set skipping to true
+        otherwise when o["op"] == "-"
+            set lines to append(lines, sgr(color, "2", lpad(text(pre + o["a"] + 1), width) + " │ ") + sgr(color, "31", "- " + mid_a[o["a"]]))
+            set skipping to false
+        otherwise
+            set lines to append(lines, sgr(color, "2", lpad(text(pre + o["b"] + 1), width) + " │ ") + sgr(color, "32", "+ " + mid_b[o["b"]]))
+            set skipping to false
+        set idx to idx + 1
+    -- contexto posterior (del sufijo común)
+    let after_start be length(b) - suf
+    let upto be when after_start + ctx < length(b) then after_start + ctx otherwise length(b)
+    set k to after_start
+    while k < upto
+        set lines to append(lines, sgr(color, "2", lpad(text(k + 1), width) + " │   " + b[k]))
+        set k to k + 1
+    when upto < length(b)
+        set lines to append(lines, sgr(color, "2", lpad("", width) + " ⋯"))
+    give {"added": added, "removed": removed, "lines": lines}

package/lib/line.syn

@@ -0,0 +1,365 @@
+-- lib/line.syn — editor de línea para la terminal (Synsema v0.6.11+: term_open/term_recv)
+--   read(prompt, color, ctx)  → texto (puede tener "\n"), INTERRUPT si ctx["idle"]() pidió cortar,
+--                               nothing en EOF. Sin TTY (pipe/CI) delega en ctx["fallback"](prompt).
+--   choose(question, options, color) → índice elegido, -1 sin TTY (usar approve), nothing en EOF/Esc.
+-- Teclas: ←→ Home End · ↑↓ historial o menú · Tab completa · Alt+Enter salto de línea · Enter envía
+--         Ctrl+A/E inicio/fin · Ctrl+U borra la línea · Ctrl+W borra palabra · Ctrl+O = /out · Esc cierra el menú
+-- Menú: al escribir "/" aparecen los comandos (primero los recientes); con "/cmd " los argumentos que
+--       devuelva ctx["complete"](cmd, prefijo) (archivos, servers, flags…). Máx MENU_ROWS filas.
+-- MIGA: dibujar SIEMPRE con term_write (print queda buffereado). El runtime restaura la terminal al cerrar.
+
+let ESC be decode(bytes("1b", "hex"))
+let MENU_ROWS be 8
+export let INTERRUPT be ESC + "interrupt"
+
+task sgr(color, code, s)
+    when not color or s == ""
+        give s
+    give ESC + "[" + code + "m" + s + ESC + "[0m"
+
+task vis(s)
+    give length(strip_ansi(s))
+
+task rep(ch, n)
+    let out be ""
+    while length(out) < n
+        set out to out + ch
+    give out
+
+task starts(s, p)
+    give starts_with(s, p)
+
+-- ---------- candidatos ----------
+
+-- buf = texto del editor. give {"kind": "cmd"|"arg"|"", "items": [{"label","fill","desc"}], "token": prefijo}
+task candidates(buf, ctx)
+    when not starts(buf, "/") or contains(buf, "\n")
+        give {"kind": "", "items": [], "token": ""}
+    let sp be capture(buf, "^(/\S*)\s+(.*)$")
+    when sp == nothing
+        -- comando a medias: recientes primero cuando es "/" pelado
+        let items be []
+        let seen be {}
+        when buf == "/"
+            each r in ctx["recent"]
+                each c in ctx["commands"]
+                    when c[0] == r and not contains(seen, r)
+                        set seen[r] to true
+                        set items to append(items, {"label": c[0], "fill": c[0] + (when c[1] != "" then " " otherwise ""), "args": c[1], "desc": c[2], "recent": true})
+        each c in ctx["commands"]
+            when starts(c[0], buf) and not contains(seen, c[0])
+                set seen[c[0]] to true
+                set items to append(items, {"label": c[0], "fill": c[0] + (when c[1] != "" then " " otherwise ""), "args": c[1], "desc": c[2], "recent": false})
+        give {"kind": "cmd", "items": items, "token": buf}
+    let cmd be sp[0]
+    let rest be sp[1]
+    -- último token (lo que se completa); lo anterior queda fijo
+    let toks be split(rest, " ")
+    let last be toks[length(toks) - 1]
+    let head be slice(rest, 0, length(rest) - length(last))
+    let items be []
+    let cands be ctx["complete"](cmd, head, last)
+    each c in cands
+        when starts(c, last)
+            set items to append(items, {"label": c, "fill": cmd + " " + head + c + (when ends_with(c, "/") then "" otherwise " "), "args": "", "desc": "", "recent": false})
+    give {"kind": "arg", "items": items, "token": last}
+
+-- ---------- dibujo ----------
+
+-- filas físicas que ocupa un texto de ancho w en una terminal de cols columnas
+task rows_of(w, cols)
+    when cols <= 0
+        give 1
+    give floor(w / cols) + 1
+
+-- dibuja prompt + buffer (multilínea) + menú; deja el cursor en su lugar. give filas totales dibujadas
+-- (para poder volver al inicio en el próximo redraw)
+task draw(h, st, color, ctx)
+    let size be term_size(h)
+    let cols be size["cols"]
+    let lines be split(st["buf"], "\n")
+    -- posición del cursor: línea y columna dentro del buffer
+    let cl be 0
+    let cc be st["cur"]
+    let i be 0
+    let found be false
+    while i < length(lines) and not found
+        when cc <= length(lines[i])
+            set cl to i
+            set found to true
+        otherwise
+            set cc to cc - length(lines[i]) - 1
+            set i to i + 1
+    let out be ""
+    -- volver al inicio de lo dibujado la vez anterior y limpiar hacia abajo
+    when st["cursor_row"] > 0
+        set out to out + ESC + "[" + text(st["cursor_row"]) + "A"
+    set out to out + "\r" + ESC + "[J"
+    let cont be sgr(color, "2", "  … ")
+    let rows_before_cursor be 0
+    let total be 0
+    let cursor_col be 0
+    set i to 0
+    each l in lines
+        let pre be when i == 0 then st["prompt"] otherwise cont
+        set out to out + (when i > 0 then "\r\n" otherwise "") + pre + l
+        let r be rows_of(vis(pre) + length(l), cols)
+        when i < cl
+            set rows_before_cursor to rows_before_cursor + r
+        otherwise when i == cl
+            set rows_before_cursor to rows_before_cursor + floor((vis(pre) + cc) / cols)
+            set cursor_col to (vis(pre) + cc) % cols
+        set total to total + r
+        set i to i + 1
+    -- menú
+    let menu_rows be 0
+    when st["menu"] and length(st["items"]) > 0
+        let items be st["items"]
+        let from be 0
+        when st["sel"] >= MENU_ROWS
+            set from to st["sel"] - MENU_ROWS + 1
+        let k be from
+        while k < length(items) and k < from + MENU_ROWS
+            let it be items[k]
+            let row be ""
+            when st["kind"] == "cmd"
+                let full be it["label"] + (when it["args"] != "" then " " + it["args"] otherwise "")
+                let name be when length(full) > 34 then slice(full, 0, 33) + "…" otherwise full
+                let padn be name + rep(" ", 34 - length(name))
+                let desc be when length(it["desc"]) > cols - 40 then slice(it["desc"], 0, cols - 43) + "…" otherwise it["desc"]
+                set row to (when k == st["sel"] then sgr(color, "7", " " + padn + " ") otherwise " " + sgr(color, "1", it["label"]) + sgr(color, "2", slice(padn, length(it["label"]), length(padn)) + " ")) + (when it["recent"] then sgr(color, "36", "↺ ") otherwise "  ") + sgr(color, "2", desc)
+            otherwise
+                set row to when k == st["sel"] then sgr(color, "7", " " + it["label"] + " ") otherwise " " + it["label"]
+            set out to out + "\r\n" + "    " + row
+            set menu_rows to menu_rows + 1
+            set k to k + 1
+        when length(items) > MENU_ROWS
+            set out to out + "\r\n" + sgr(color, "2", "    (" + text(length(items)) + " opciones · ↑↓ elegir · Tab completa · Esc cierra)")
+            set menu_rows to menu_rows + 1
+    -- recolocar el cursor: subir (filas debajo de la línea del cursor + menú), ir a la columna
+    let below be total - rows_before_cursor - 1 + menu_rows
+    when below > 0
+        set out to out + ESC + "[" + text(below) + "A"
+    set out to out + "\r"
+    when cursor_col > 0
+        set out to out + ESC + "[" + text(cursor_col) + "C"
+    term_write(h, out)
+    set st["cursor_row"] to rows_before_cursor
+    give st
+
+-- ---------- edición ----------
+
+task insert(st, s)
+    set st["buf"] to slice(st["buf"], 0, st["cur"]) + s + slice(st["buf"], st["cur"], length(st["buf"]))
+    set st["cur"] to st["cur"] + length(s)
+    give st
+
+task refresh_menu(st, ctx)
+    let c be candidates(st["buf"], ctx)
+    set st["kind"] to c["kind"]
+    set st["items"] to c["items"]
+    set st["sel"] to 0
+    set st["nav"] to false
+    set st["menu"] to c["kind"] != "" and length(c["items"]) > 0 and not st["menu_off"]
+    give st
+
+task word_start(buf, cur)
+    let i be cur
+    while i > 0 and slice(buf, i - 1, i) == " "
+        set i to i - 1
+    while i > 0 and slice(buf, i - 1, i) != " " and slice(buf, i - 1, i) != "\n"
+        set i to i - 1
+    give i
+
+task accept(st)
+    let it be st["items"][st["sel"]]
+    set st["buf"] to it["fill"]
+    set st["cur"] to length(it["fill"])
+    set st["menu"] to false
+    give st
+
+export task read(prompt, color, ctx)
+    let h be term_open({"ctrl_c": "exit"})
+    when h == nothing
+        give ctx["fallback"](prompt)
+    let st be {"buf": "", "cur": 0, "prompt": prompt, "cursor_row": 0, "menu": false, "menu_off": false, "kind": "", "items": [], "sel": 0, "nav": false}
+    let hist be ctx["history"]
+    let hi be length(hist)
+    let draft be ""
+    let result be nothing
+    let done be false
+    term_write(h, "\r\n")
+    set st to draw(h, st, color, ctx)
+    while not done
+        let ev be term_recv(h, 1)
+        let dirty be true
+        when ev == nothing
+            set dirty to false
+            when ctx["idle"]()
+                set result to INTERRUPT
+                set done to true
+        otherwise when ev["type"] == "focus"
+            set dirty to false
+        otherwise when ev["type"] == "eof"
+            set result to nothing
+            set done to true
+        otherwise when ev["type"] == "paste"
+            set st to insert(st, replace_text(ev["text"], "\r", ""))
+            set st to refresh_menu(st, ctx)
+        otherwise when ev["type"] == "resize"
+            set st to st
+        otherwise when ev["type"] == "key"
+            let k be ev["key"]
+            let changed be true
+            when k == "enter" and ev["alt"]
+                set st to insert(st, "\n")
+            otherwise when k == "enter"
+                when st["menu"] and st["kind"] == "cmd" and st["buf"] != st["items"][st["sel"]]["label"] and st["buf"] != st["items"][st["sel"]]["fill"]
+                    set st to accept(st)
+                    when st["items"][st["sel"]]["args"] == ""
+                        set result to trim(st["buf"])
+                        set done to true
+                otherwise when st["menu"] and st["kind"] == "arg" and st["nav"]
+                    -- Enter solo completa el argumento si el humano navegó el menú; si no, envía tal cual
+                    set st to accept(st)
+                otherwise
+                    set result to st["buf"]
+                    set done to true
+            otherwise when k == "tab" and st["menu"]
+                set st to accept(st)
+            otherwise when k == "escape"
+                when st["menu"]
+                    set st["menu"] to false
+                    set st["menu_off"] to true
+                set changed to false
+            otherwise when k == "up" and st["menu"]
+                set st["sel"] to (when st["sel"] > 0 then st["sel"] - 1 otherwise length(st["items"]) - 1)
+                set st["nav"] to true
+                set changed to false
+            otherwise when k == "down" and st["menu"]
+                set st["sel"] to (when st["sel"] < length(st["items"]) - 1 then st["sel"] + 1 otherwise 0)
+                set st["nav"] to true
+                set changed to false
+            otherwise when k == "up"
+                when hi > 0
+                    when hi == length(hist)
+                        set draft to st["buf"]
+                    set hi to hi - 1
+                    set st["buf"] to hist[hi]
+                    set st["cur"] to length(st["buf"])
+                set changed to false
+            otherwise when k == "down"
+                when hi < length(hist)
+                    set hi to hi + 1
+                    set st["buf"] to (when hi == length(hist) then draft otherwise hist[hi])
+                    set st["cur"] to length(st["buf"])
+                set changed to false
+            otherwise when k == "left"
+                when st["cur"] > 0
+                    set st["cur"] to st["cur"] - 1
+                set changed to false
+            otherwise when k == "right"
+                when st["cur"] < length(st["buf"])
+                    set st["cur"] to st["cur"] + 1
+                set changed to false
+            otherwise when k == "home" or (k == "char" and ev["ctrl"] and ev["text"] == "a")
+                set st["cur"] to 0
+                set changed to false
+            otherwise when k == "end" or (k == "char" and ev["ctrl"] and ev["text"] == "e")
+                set st["cur"] to length(st["buf"])
+                set changed to false
+            otherwise when k == "backspace"
+                when st["cur"] > 0
+                    set st["buf"] to slice(st["buf"], 0, st["cur"] - 1) + slice(st["buf"], st["cur"], length(st["buf"]))
+                    set st["cur"] to st["cur"] - 1
+            otherwise when k == "delete"
+                when st["cur"] < length(st["buf"])
+                    set st["buf"] to slice(st["buf"], 0, st["cur"]) + slice(st["buf"], st["cur"] + 1, length(st["buf"]))
+            otherwise when k == "char" and ev["ctrl"] and ev["text"] == "u"
+                set st["buf"] to ""
+                set st["cur"] to 0
+            otherwise when k == "char" and ev["ctrl"] and ev["text"] == "w"
+                let ws be word_start(st["buf"], st["cur"])
+                set st["buf"] to slice(st["buf"], 0, ws) + slice(st["buf"], st["cur"], length(st["buf"]))
+                set st["cur"] to ws
+            otherwise when k == "char" and ev["ctrl"] and ev["text"] == "o"
+                set result to "/out"
+                set done to true
+            otherwise when k == "char" and ev["ctrl"] and ev["text"] == "l"
+                term_write(h, ESC + "[2J" + ESC + "[H")
+                set st["cursor_row"] to 0
+                set changed to false
+            otherwise when k == "char" and not ev["ctrl"]
+                set st to insert(st, ev["text"])
+            otherwise
+                set changed to false
+            when changed
+                set st["menu_off"] to false
+                set st to refresh_menu(st, ctx)
+        when not done and dirty
+            set st to draw(h, st, color, ctx)
+    -- dejar el prompt limpio (sin menú) en el scrollback y bajar a una línea nueva
+    set st["menu"] to false
+    set st to draw(h, st, color, ctx)
+    let lines be split(st["buf"], "\n")
+    let size be term_size(h)
+    let tail be 0
+    let i be 0
+    each l in lines
+        let pre be when i == 0 then vis(st["prompt"]) otherwise 4
+        when i > 0 or true
+            set tail to tail + rows_of(pre + length(l), size["cols"])
+        set i to i + 1
+    let down be tail - st["cursor_row"] - 1
+    term_write(h, (when down > 0 then ESC + "[" + text(down) + "B" otherwise "") + "\r\n")
+    term_close(h)
+    give result
+
+-- menú vertical de opciones (aprobaciones): ↑↓ + Enter, o la letra inicial / número; Esc = nothing
+export task choose(question, options, color)
+    let h be term_open({"ctrl_c": "exit"})
+    when h == nothing
+        give -1
+    let sel be 0
+    let done be false
+    let result be nothing
+    let drawn be 0
+    while not done
+        let out be ""
+        when drawn > 0
+            set out to out + ESC + "[" + text(drawn) + "A"
+        set out to out + "\r" + ESC + "[J" + question
+        let i be 0
+        each o in options
+            set out to out + "\r\n" + "    " + (when i == sel then sgr(color, "7", " " + o + " ") otherwise " " + sgr(color, "2", o))
+            set i to i + 1
+        term_write(h, out)
+        set drawn to length(options)
+        let ev be term_recv(h, 600)
+        when ev == nothing
+            set result to nothing
+            set done to true
+        otherwise when ev["type"] == "eof"
+            set done to true
+        otherwise when ev["type"] == "key"
+            let k be ev["key"]
+            when k == "up"
+                set sel to (when sel > 0 then sel - 1 otherwise length(options) - 1)
+            otherwise when k == "down" or k == "tab"
+                set sel to (when sel < length(options) - 1 then sel + 1 otherwise 0)
+            otherwise when k == "enter"
+                set result to sel
+                set done to true
+            otherwise when k == "escape"
+                set done to true
+            otherwise when k == "char" and not ev["ctrl"]
+                let t be lower(ev["text"])
+                let j be 0
+                each o in options
+                    when t == text(j + 1) or t == lower(slice(o, 0, 1))
+                        set result to j
+                        set done to true
+                    set j to j + 1
+    term_write(h, "\r\n")
+    term_close(h)
+    give result

package/lib/md.syn

@@ -0,0 +1,171 @@
+-- lib/md.syn — markdown → ANSI para la terminal (sin dependencias)
+--   render(md, color) → texto listo para print. color=false → texto plano legible (sin escapes).
+--   inline(s, color)  → solo formato inline (negrita, cursiva, `código`, links, ~~tachado~~).
+-- MIGA: `matches` es full-match; para buscar/reemplazar son `capture`/`find_all`/`replace_re`
+-- (backrefs \1). En strings "..." la barra va simple ("\*", "\d"): "\\d" NO es \d.
+-- Los bloques ``` se copian tal cual (sin parseo inline). La web ya renderiza markdown por su cuenta.
+
+let ESC be decode(bytes("1b", "hex"))
+let WIDTH be 72
+
+task sgr(color, code, s)
+    when not color or s == ""
+        give s
+    give ESC + "[" + code + "m" + s + ESC + "[0m"
+
+task rep(ch, n)
+    let out be ""
+    while length(out) < n
+        set out to out + ch
+    give out
+
+-- ---------- inline ----------
+
+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"))
+    -- 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 pass to pass + 1
+    give out
+
+export task inline(s, color)
+    -- `código` primero: lo de adentro no se toca
+    let parts be split(s, "`")
+    when length(parts) < 3
+        give emphasis(s, color)
+    let out be ""
+    let idx be 0
+    each p in parts
+        when idx == length(parts) - 1 and idx % 2 == 1
+            set out to out + "`" + emphasis(p, color)
+        otherwise when idx % 2 == 1
+            set out to out + sgr(color, "33", p)
+        otherwise
+            set out to out + emphasis(p, color)
+        set idx to idx + 1
+    give out
+
+-- ---------- bloques ----------
+
+task indent_of(line)
+    let n be 0
+    while n < length(line) and slice(line, n, n + 1) == " "
+        set n to n + 1
+    give n
+
+task table_cells(line)
+    let t be trim(line)
+    when starts_with(t, "|")
+        set t to slice(t, 1, length(t))
+    when ends_with(t, "|")
+        set t to slice(t, 0, length(t) - 1)
+    give apply(trim, split(t, "|"))
+
+-- rows: lista de listas de celdas (crudas); la primera es el header. Columnas alineadas al ancho
+-- máximo de cada una (ancho visible = length de inline(c, false), sin escapes ni marcas).
+task table_lines(rows, pre, color)
+    let widths be []
+    each r in rows
+        let i be 0
+        each c in r
+            when i >= length(widths)
+                set widths to append(widths, 0)
+            when length(inline(c, false)) > widths[i]
+                set widths[i] to length(inline(c, false))
+            set i to i + 1
+    let out be []
+    let ri be 0
+    each r in rows
+        let cells be []
+        let i be 0
+        each c in r
+            let fill be rep(" ", widths[i] - length(inline(c, false)))
+            set cells to append(cells, (when ri == 0 then sgr(color, "1", inline(c, color)) otherwise inline(c, color)) + fill)
+            set i to i + 1
+        set out to append(out, pre + join(cells, sgr(color, "2", " │ ")))
+        when ri == 0
+            let segs be []
+            each w in widths
+                set segs to append(segs, rep("─", w))
+            set out to append(out, pre + sgr(color, "2", join(segs, "─┼─")))
+        set ri to ri + 1
+    give out
+
+task fence_top(lang, color)
+    let label be when lang != "" then " " + lang + " " otherwise ""
+    give sgr(color, "2", "┌──" + label + rep("─", WIDTH - 3 - length(label)))
+
+export task render(md, color)
+    let pre be "  "
+    let out be []
+    let in_code be false
+    let fence be ""
+    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 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)
+                set out to append(out, l)
+            set table to []
+        when in_code
+            when starts_with(t, fence)
+                set in_code to false
+                set out to append(out, pre + sgr(color, "2", "└" + rep("─", WIDTH - 1)))
+            otherwise
+                set out to append(out, pre + sgr(color, "2", "│ ") + sgr(color, "36", line))
+        otherwise when starts_with(t, "```") or starts_with(t, "~~~")
+            set in_code to true
+            set fence to slice(t, 0, 3)
+            set out to append(out, pre + fence_top(trim(slice(t, 3, length(t))), color))
+        otherwise when heading != nothing
+            let lvl be length(heading[0])
+            let raw be trim(heading[1])
+            let title be inline(raw, color)
+            set out to append(out, "")
+            when lvl == 1
+                set out to append(out, pre + sgr(color, "1;36", upper(title)))
+                set out to append(out, pre + sgr(color, "36", rep("═", length(raw))))
+            otherwise when lvl == 2
+                set out to append(out, pre + sgr(color, "1;36", title))
+                set out to append(out, pre + sgr(color, "2;36", rep("─", length(raw))))
+            otherwise
+                set out to append(out, pre + sgr(color, "1", title))
+        otherwise when matches(t, "(-{3,}|\*{3,}|_{3,})")
+            set out to append(out, pre + sgr(color, "2", rep("─", WIDTH)))
+        otherwise when starts_with(t, ">")
+            set out to append(out, pre + sgr(color, "2", "▎ ") + sgr(color, "3", inline(trim(slice(t, 1, length(t))), color)))
+        otherwise when matches(t, "\|[\s:|-]+\|")
+            set table to table
+        otherwise when is_row
+            set table to append(table, table_cells(t))
+        otherwise when starts_with(t, "- ") or starts_with(t, "* ") or starts_with(t, "+ ") or item != nothing
+            let ind be rep(" ", indent_of(line))
+            let mark be when item != nothing then sgr(color, "36", item[0] + ".") otherwise sgr(color, "36", "•")
+            let rest be when item != nothing then item[1] otherwise slice(t, 2, length(t))
+            when starts_with(rest, "[ ] ")
+                set mark to sgr(color, "2", "☐")
+                set rest to slice(rest, 4, length(rest))
+            otherwise when starts_with(rest, "[x] ") or starts_with(rest, "[X] ")
+                set mark to sgr(color, "32", "☑")
+                set rest to slice(rest, 4, length(rest))
+            set out to append(out, pre + ind + mark + " " + inline(rest, color))
+        otherwise
+            set out to append(out, when t == "" then "" otherwise pre + inline(line, color))
+    when length(table) > 0
+        each l in table_lines(table, pre, color)
+            set out to append(out, l)
+    when in_code
+        set out to append(out, pre + sgr(color, "2", "└" + rep("─", WIDTH - 1)))
+    give join(out, "\n")

package/lib/permission.syn

@@ -149,6 +149,41 @@ export task describe_call(name, args)
         give "skill install " + text(args["source"]) + " --skill " + text(args["name"]) + " (" + (when contains(args, "scope") then text(args["scope"]) otherwise "global") + ")"
     when name == "bash"
         give "$ " + one_line(when contains(args, "command") then text(args["command"]) otherwise "", 160)
+    -- lectura/búsqueda: como lo escribiría un humano en la shell
+    when name == "read"
+        let rng be when contains(args, "offset") or contains(args, "limit") then "  (" + (when contains(args, "offset") then "desde " + text(floor(number(text(args["offset"])))) otherwise "") + (when contains(args, "limit") then " " + text(floor(number(text(args["limit"])))) + " líneas" otherwise "") + ")" otherwise ""
+        give "read " + arg(args, "path", ".") + rng
+    when name == "ls"
+        give "ls " + arg(args, "path", ".")
+    when name == "find"
+        give "find " + arg(args, "pattern", "*") + (when contains(args, "path") then "  en " + text(args["path"]) otherwise "")
+    when name == "grep"
+        let flags be (when contains(args, "regex") and args["regex"] == true then " -E" otherwise "") + (when contains(args, "glob") then " --glob " + text(args["glob"]) otherwise "")
+        give "grep" + flags + " \"" + one_line(arg(args, "pattern", ""), 80) + "\"" + (when contains(args, "path") then "  " + text(args["path"]) otherwise "")
+    when name == "edit"
+        give "edit " + arg(args, "path", "?")
+    when name == "write"
+        give "write " + arg(args, "path", "?") + (when contains(args, "content") then dim_len(text(args["content"])) otherwise "")
+    when name == "memory"
+        let mact be arg(args, "action", "list")
+        give "memory " + mact + (when contains(args, "name") then " " + text(args["name"]) otherwise "") + (when (mact == "write" or mact == "append") and contains(args, "content") then "  — " + one_line(text(args["content"]), 70) otherwise "")
+    when name == "process"
+        let pact be arg(args, "action", "list")
+        give "process " + pact + (when contains(args, "name") then " " + text(args["name"]) otherwise "") + (when contains(args, "command") then "  $ " + one_line(text(args["command"]), 100) otherwise "")
+    when name == "skill"
+        give "skill " + arg(args, "action", "load") + " " + arg(args, "name", "?")
+    when name == "todo"
+        let n be when contains(args, "items") then length(args["items"]) otherwise 0
+        let done be when contains(args, "items") then length(where(args["items"], (i) => contains(i, "status") and text(i["status"]) == "done")) otherwise 0
+        give "todo  " + text(done) + "/" + text(n) + " hechas"
     when contains(args, "path")
         give name + " " + text(args["path"])
-    give name + " " + json_encode(args)
+    give name + " " + one_line(json_encode(args), 160)
+
+task arg(args, key, default)
+    when contains(args, key)
+        give text(args[key])
+    give default
+
+task dim_len(s)
+    give "  (" + text(length(split(s, "\n"))) + " líneas)"

package/lib/tools/edit.syn

@@ -16,8 +16,11 @@ export task tool(path, old_string, new_string, replace_all)
     when n > 1
         when not all
             raise(`old_string appears {text(n)} times in {shown}; include more surrounding context to make it unique, or pass replace_all=true`)
-    write_file(real, join(parts, new_string))
+    let after be join(parts, new_string)
+    write_file(real, after)
     c.mark_observed(real)
+    -- antes/después para que la UI muestre el diff (chat.syn / web); el modelo solo recibe la línea de abajo
+    share {"path": shown, "old": content, "new": after} as "lampson:ui:diff"
     give `edited {shown}: {text(n)} replacement(s)`
 
 export let SPEC be {

package/lib/tools/write.syn

@@ -6,10 +6,14 @@ export task tool(path, content)
     require file("workspace/*")
     let real be c.ws(path)
     -- sobrescribir un archivo existente exige haberlo leído (y que no haya cambiado): igual que edit
+    let before be ""
     when file_exists(real)
         c.check_observed(real, "write")
+        set before to read_file(real)
     write_file(real, content)
     c.mark_observed(real)
+    -- antes/después para que la UI muestre el diff (archivo nuevo: before = "")
+    share {"path": c.unws(real), "old": before, "new": content} as "lampson:ui:diff"
     give `wrote {text(length(content))} chars to {c.unws(real)}`
 
 export let SPEC be {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lampson",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "A coding agent written in Synsema: terminal + web, tools confined to the mounted project, lamps (your own tool plugins), LSP, MCP, sub-agents.",
   "license": "MIT",
   "repository": {
@@ -32,7 +32,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "synsema": "^0.6.10"
+    "synsema": "^0.6.11"
   },
   "scripts": {
     "test": "pwsh -NoProfile -File tests/run.ps1"

package/skills/synsema/SKILL.md

@@ -3,7 +3,7 @@ name: synsema
 description: Writing, checking, running and testing Synsema (.syn) code — syntax reflexes, capabilities, live processes / pseudo-terminals, and the runtime traps that cost hours. Load before touching any .syn file.
 ---
 
-# Synsema quick reference (v0.6.10)
+# Synsema quick reference (v0.6.11)
 
 > Curated 10 KB summary for the agent (the full reference is ~450 KB and lives in the user's editor
 > skill). Kept in sync by hand with each `synsema update`; if `synsema --version` is newer than the
@@ -22,6 +22,11 @@ description: Writing, checking, running and testing Synsema (.syn) code — synt
 - `try` … `recover err` (recover SWALLOWS; `raise(err)` to re-throw) · `raise("msg")`
 - `contains(xs, x)` (on maps checks KEYS) · `append(xs, x)` returns a NEW list → `set xs to append(xs, x)`
 - `apply(f, xs)`, `where(xs, p)`, `sort_by(xs, f)`, `slice(xs, a, b)`, `split/join/trim/lower/upper`
+- Text/regex: `replace_text(t, old, new)` (literal), `replace_re(t, re, rep)` (`\1` backrefs), `capture(t, re)`
+  (first match; with groups → list), `find_all`, `matches` (**full match** only — not a search).
+  There is NO `replace`, `regex_replace`, `chars`, `repeat`. Rust regex: no lookahead/lookbehind.
+  In `"..."` strings backslashes are literal: write `"\d"`, `"\*"` (`"\\d"` is a literal `\d`).
+  Anonymous functions: `(x) => expr` only (no inline `task(x)`).
 - `json_encode / json_decode` · `length` · `text(x)` · `number(s)` (ALWAYS float → `floor()` for ints)
 - Modules: `use "./m.syn" as m` (local only, never `../`), `export task/let`. A module cannot have
   top-level `require` or `serve` — the ENTRY file grants capabilities.
@@ -50,6 +55,12 @@ description: Writing, checking, running and testing Synsema (.syn) code — synt
   `proc_spawn` in a handler is gone when the handler returns. A process that must outlive requests lives
   inside an `agent` spawned from the handler (own lifecycle; blackboard `share/observe` + `bus_*` are shared
   with handlers). That is how lampson's `process` tool works (`lib/tools/proc.syn`).
+- **Own terminal / raw keys (v0.6.11+)**: `let h be term_open({"ctrl_c": "exit"})` → `nothing` without a
+  TTY / under `test`/`serve` (fall back to `read_line`); `term_recv(h, secs)` → `{type: "key", key, text,
+  ctrl, alt, shift}` (`key` = `"char"|"enter"|"tab"|"backspace"|"up"|…`), `paste`, `resize`, `eof`;
+  draw with `term_write(h, ansi)` (**`print` stays buffered**); `term_size(h)`; `term_close(h)`. Alt+Enter
+  always arrives (Shift+Enter needs kitty protocol). `ask/approve` still work while open. Lampson's line
+  editor is `lib/line.syn`; drive a terminal UI in tests via `proc_spawn(…, {pty: true})` (`tty_test.syn`).
 - **File watch (v0.6.9+)**: `let w be watch("src", {"interval": 0.2, "ignore": ["*.tmp"]})` → events
   `{type: "create"|"modify"|"delete", path, is_dir}` via `watch_recv(w, secs)` or `select`; polling with a
   snapshot (latency = interval), `watch_close(w)`. Gate: `file("src")` + `file("src/*")`.
@@ -67,7 +78,9 @@ description: Writing, checking, running and testing Synsema (.syn) code — synt
 - `localhost` resolves to IPv6; use `127.0.0.1`.
 - `run("bash", ...)` hangs on Windows (WSL bash) → `C:\Program Files\Git\bin\bash.exe` or `cmd /c`.
 - A task named `run` shadows the builtin `run` (infinite recursion).
-- Reserved words that break variable/param names: `reason task ask stop decide analyze generate show approve confirm`.
+- Reserved words that break variable/param names: `reason task ask stop type run decide analyze generate show approve confirm`.
+- Reading a MISSING map key is a runtime error (`Map has no key 'x'`), not `nothing` → `contains(m, "x")` first.
+- Maps are passed by reference: `set m["k"] to v` inside a task IS visible to the caller (lists via `append` are not — it returns a new list).
 - `and`/`or` do NOT short-circuit → nest `when` before indexing.
 - No `merge`: add a key with `set m["k"] to v`. No `append_file`: read + write (atomic; parents created).
 - Runtime error messages are Capitalized (`Not a directory: …`) and `contains` is case-sensitive → compare `lower(text(err))`.