lampson 0.1.1 → 0.1.3

package/lib/md.syn

@@ -0,0 +1,229 @@
+-- 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.
+
+use "./ui.syn" as ui
+
+let ESC be decode(bytes("1b", "hex"))
+-- ancho útil: columnas de la terminal menos la sangría (mín. 40, máx. 100 para que la prosa se lea)
+task width_now()
+    let c be ui.cols() - 4
+    when c < 40
+        give 40
+    when c > 100
+        give 100
+    give c
+
+-- rutas y símbolos de código dentro de la prosa → azul (lib/x.syn, src/a/b.ts, describe_call(), foo.bar)
+task paths(s, color)
+    when not color
+        give s
+    let out be replace_re(s, "(^|[\s(])([\w.-]*/[\w./-]{2,})", "\1" + ESC + "[34m\2" + ESC + "[0m")
+    set out to replace_re(out, "(^|[\s(])(\w+\.(syn|js|ts|tsx|jsx|json|md|py|rs|go|ps1|sh|html|css|toml|yml|yaml|env))(\b)", "\1" + ESC + "[34m\2" + ESC + "[0m")
+    set out to replace_re(out, "(^|[\s(])(\w+\(\))", "\1" + ESC + "[34m\2" + ESC + "[0m")
+    give out
+
+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 paths(emphasis(s, color), 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 + "`" + paths(emphasis(p, color), color)
+        otherwise when idx % 2 == 1
+            set out to out + sgr(color, "36", p)
+        otherwise
+            set out to out + paths(emphasis(p, color), 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 ui.width(inline(c, false)) > widths[i]
+                set widths[i] to ui.width(inline(c, false))
+            set i to i + 1
+    -- si no entra en la terminal, achicar la columna más ancha hasta que entre (mínimo 10) y envolver
+    let avail be width_now() - 3 * (length(widths) - 1)
+    let total be 0
+    each w in widths
+        set total to total + w
+    while total > avail
+        let widest be 0
+        let wi be 0
+        each w in widths
+            when w > widths[widest]
+                set widest to wi
+            set wi to wi + 1
+        when widths[widest] <= 10
+            set total to avail
+        otherwise
+            set widths[widest] to widths[widest] - 1
+            set total to total - 1
+    let out be []
+    let ri be 0
+    each r in rows
+        -- cada celda → lista de líneas envueltas a su ancho
+        let wrapped be []
+        let height be 1
+        let i be 0
+        each c in r
+            let ls be ui.wrap(c, widths[i], "")
+            set wrapped to append(wrapped, ls)
+            when length(ls) > height
+                set height to length(ls)
+            set i to i + 1
+        let li be 0
+        while li < height
+            let cells be []
+            set i to 0
+            each ls in wrapped
+                let piece be when li < length(ls) then ls[li] otherwise ""
+                let vis be ui.width(inline(piece, false))
+                let fill be rep(" ", (when widths[i] > vis then widths[i] - vis otherwise 0))
+                set cells to append(cells, (when ri == 0 then sgr(color, "1", inline(piece, color)) otherwise inline(piece, color)) + fill)
+                set i to i + 1
+            set out to append(out, pre + join(cells, sgr(color, "2", " │ ")))
+            set li to li + 1
+        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_now() - 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_now() - 1)))
+            otherwise
+                set out to append(out, pre + sgr(color, "2", "│ ") + ui.cut(sgr(color, "36", line), width_now() - 2))
+        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_now())))
+        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))
+            let wrapped be ui.wrap(rest, width_now() - length(ind) - 2, "")
+            let wi be 0
+            each wl in wrapped
+                set out to append(out, pre + ind + (when wi == 0 then mark + " " otherwise "  ") + inline(wl, color))
+                set wi to wi + 1
+        otherwise
+            when t == ""
+                set out to append(out, "")
+            otherwise
+                each wl in ui.wrap(trim(line), width_now(), "")
+                    set out to append(out, pre + inline(wl, 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_now() - 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/prompt.syn

@@ -35,7 +35,7 @@ Operate like a careful senior engineer: precise, honest, and economical with wor
 # Method — follow these five steps on every non-trivial request
 1. PLAN. If the task needs 3+ distinct steps (not 3 tool calls for one conceptual step), call todo FIRST and keep it current: one item in_progress at a time, marked completed the moment its work is verified — never batched, never on intent. The todo list survives context compaction; your narration does not. Skip it for a single straightforward change; when in doubt, use it.
 2. LOCATE. Find code with grep and find, never by reading directories at random. For a broad, open-ended question about how the codebase works, delegate ONE focused question to an explore sub-agent instead of reading everything yourself — the search stays out of your context. Batch independent lookups into a single turn.
-3. READ ONLY WHAT YOU NEED. Read the files you will change plus the ones you must understand to change them — not the whole project. Every file you read is re-sent on every later call. Use offset/limit for long files, but avoid tiny repeated slices. Trace a symbol to its definition and usages rather than guessing its shape. Never invent files, symbols, APIs or imports — if you have not seen it in this repo, go look. HARD LIMITS enforced by the harness: after 8 read-only calls in a row without acting you get a warning, after 16 read/ls/find/grep are refused until you act; a file read twice unchanged comes back as a one-line receipt.
+3. READ ONLY WHAT YOU NEED. Read the files you will change plus the ones you must understand to change them — not the whole project. Every file you read is re-sent on every later call. Use offset/limit for long files, but avoid tiny repeated slices. Trace a symbol to its definition and usages rather than guessing its shape. Never invent files, symbols, APIs or imports — if you have not seen it in this repo, go look. HARD LIMITS enforced by the harness: after 12 read-only calls in a row without acting you get a warning, after 24 read/ls/find/grep are refused until you act; a file read twice unchanged comes back as a one-line receipt.
 4. CHANGE. Act as soon as you know enough — usually within the first 6-10 reads. Prefer edit (exact-string replacement; old_string must be unique, include surrounding context) over write; write only for new files or full rewrites. edit/write on an existing file are rejected unless you read that file in this session and it has not changed since. Minimal, targeted changes: no drive-by refactors, renames or reformatting; add every import or dependency your code needs. Do NOT print code blocks to the user as a substitute for editing — apply the change, then summarise it. If an edit fails to apply, re-read the file and retry with the exact current text; if the same region fails twice, rewrite the enclosing function with write.
 5. VERIFY AND REPORT. Run the relevant tests, linter or build with bash and confirm they pass before claiming the work is done — AFTER your edits, not before as reconnaissance. Never assume a test command: check the README, the package manifest or the project instructions. Finish with a short summary: what changed (files, path:line for specific code) and how you verified it. Do not narrate every step.
 

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/lib/ui.syn

@@ -0,0 +1,161 @@
+-- lib/ui.syn — una sola paleta y medidas de texto para la terminal (md.syn, diff.syn, line.syn, chat.syn)
+--   Colores: dim/blue/green/red/yellow/cyan/bold/inv (+ fondos bg_add/bg_del para diffs). color=false → texto plano.
+--   width(s)      ancho visible (sin escapes; emoji/CJK cuentan 2)
+--   cut(s, max)   corta a `max` columnas respetando escapes (y cierra el color)
+--   wrap(s, max, indent)  envuelve texto PLANO por palabras; las líneas siguientes llevan `indent`
+--   cols()        columnas de la terminal (el editor las publica en el blackboard "lampson:ui:cols"; 100 si no hay)
+--   fmt_duration(secs) → "12s" · "2m 27s" · "1h 03m"
+
+let ESC be decode(bytes("1b", "hex"))
+
+export task sgr(color, code, s)
+    when not color or s == ""
+        give s
+    give ESC + "[" + code + "m" + s + ESC + "[0m"
+
+export task dim(color, s)
+    give sgr(color, "2", s)
+export task bold(color, s)
+    give sgr(color, "1", s)
+export task inv(color, s)
+    give sgr(color, "7", s)
+export task blue(color, s)
+    give sgr(color, "34", s)
+export task cyan(color, s)
+    give sgr(color, "36", s)
+export task green(color, s)
+    give sgr(color, "32", s)
+export task red(color, s)
+    give sgr(color, "31", s)
+export task yellow(color, s)
+    give sgr(color, "33", s)
+-- fondos para diffs (256 colores: verde y rojo oscuros, legibles en tema claro y oscuro)
+export task bg_add(color, s)
+    give sgr(color, "48;5;22", s)
+export task bg_del(color, s)
+    give sgr(color, "48;5;52", s)
+
+-- ---------- medidas ----------
+
+-- punto de código de UN carácter a partir de sus bytes UTF-8
+task codepoint(ch)
+    let b be bytes(ch)
+    let n be length(b)
+    when n == 1
+        give b[0]
+    when n == 2
+        give (b[0] - 192) * 64 + (b[1] - 128)
+    when n == 3
+        give (b[0] - 224) * 4096 + (b[1] - 128) * 64 + (b[2] - 128)
+    give (b[0] - 240) * 262144 + (b[1] - 128) * 4096 + (b[2] - 128) * 64 + (b[3] - 128)
+
+-- ancho de un carácter en celdas: emoji, CJK y símbolos "wide" ocupan 2
+task char_width(ch)
+    let cp be codepoint(ch)
+    when cp < 4352
+        give 1
+    when cp >= 127744 and cp <= 129791
+        give 2
+    when cp >= 4352 and cp <= 4447
+        give 2
+    when cp >= 11904 and cp <= 42191
+        give 2
+    when cp >= 44032 and cp <= 55203
+        give 2
+    when cp >= 63744 and cp <= 64255
+        give 2
+    when cp >= 65040 and cp <= 65135
+        give 2
+    when cp >= 65280 and cp <= 65376
+        give 2
+    when cp >= 9800 and cp <= 9811
+        give 2
+    when cp == 9888 or cp == 9889 or cp == 9989 or cp == 10060 or cp == 11093
+        give 2
+    give 1
+
+export task width(s)
+    let t be strip_ansi(s)
+    let w be 0
+    let i be 0
+    let n be length(t)
+    while i < n
+        set w to w + char_width(slice(t, i, i + 1))
+        set i to i + 1
+    give w
+
+-- corta a `max` celdas visibles, saltando secuencias ANSI enteras; añade "…" si cortó y cierra el color
+export task cut(s, max)
+    when width(s) <= max
+        give s
+    let out be ""
+    let w be 0
+    let i be 0
+    let n be length(s)
+    let limit be max - 1
+    while i < n and w < limit
+        let ch be slice(s, i, i + 1)
+        when ch == ESC
+            -- copiar la secuencia CSI completa: ESC [ … letra
+            let j be i + 1
+            while j < n and not matches(slice(s, j, j + 1), "[A-Za-z]")
+                set j to j + 1
+            set out to out + slice(s, i, j + 1)
+            set i to j + 1
+        otherwise
+            let cw be char_width(ch)
+            when w + cw <= limit
+                set out to out + ch
+                set w to w + cw
+                set i to i + 1
+            otherwise
+                set i to n
+    give out + ESC + "[0m" + "…"
+
+-- envuelve texto plano (sin escapes) por palabras; give lista de líneas (sin indent en la primera)
+export task wrap(s, max, indent)
+    when max <= 10 or length(s) <= max
+        give [s]
+    let words be split(s, " ")
+    let lines be []
+    let cur be ""
+    let curw be 0
+    each w in words
+        let ww be width(w)
+        let room be when length(lines) == 0 then max otherwise max - length(indent)
+        when curw == 0
+            set cur to w
+            set curw to ww
+        otherwise when curw + 1 + ww <= room
+            set cur to cur + " " + w
+            set curw to curw + 1 + ww
+        otherwise
+            set lines to append(lines, (when length(lines) == 0 then "" otherwise indent) + cur)
+            set cur to w
+            set curw to ww
+    set lines to append(lines, (when length(lines) == 0 then "" otherwise indent) + cur)
+    give lines
+
+-- ---------- terminal ----------
+
+export task cols()
+    observe "lampson:ui:cols" as c
+    when c == nothing
+        give 100
+    give c
+
+export task set_cols(n)
+    share n as "lampson:ui:cols"
+    give n
+
+export task fmt_duration(secs)
+    let s be floor(secs)
+    when s < 60
+        give text(s) + "s"
+    when s < 3600
+        let m be floor(s / 60)
+        let r be s - m * 60
+        give text(m) + "m " + (when r < 10 then "0" otherwise "") + text(r) + "s"
+    let h be floor(s / 3600)
+    let m2 be floor((s - h * 3600) / 60)
+    give text(h) + "h " + (when m2 < 10 then "0" otherwise "") + text(m2) + "m"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lampson",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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/public/index.html

@@ -145,6 +145,10 @@
   .sec h2 { font:400 10.5px/1.35 var(--mono); text-transform:uppercase; letter-spacing:.1em; color:var(--ink-3); margin:0; padding:12px 16px 8px; display:flex; align-items:center; gap:8px; cursor:pointer; user-select:none; flex:none; }
   .sec h2:hover { color:var(--ink); }
   .sec .caret { width:9px; font-size:9px; color:var(--ink-3); }
+  .sec h2 .h2act { margin-left:auto; border:0; background:none; color:var(--ink-3); font:inherit; font-size:12px; cursor:pointer; padding:0 2px; line-height:1; opacity:.6; }
+  .sec h2 .h2act:hover { opacity:1; color:var(--accent); }
+  .sec h2 .h2act.spin { animation: h2spin .6s linear; }
+  @keyframes h2spin { to { transform: rotate(360deg); } }
   .sec .cnt { margin-left:auto; letter-spacing:0; text-transform:none; }
   .sec .body { display:none; overflow:auto; min-height:0; padding:0 10px 10px 16px; }
   .sec.open .body { display:block; }
@@ -370,7 +374,7 @@
 </header>
 <aside>
   <section class="sec grow open" data-sec="tree">
-    <h2><span class="caret">▾</span>Archivos</h2>
+    <h2><span class="caret">▾</span>Archivos<button class="h2act" id="tree-reload" title="recargar el árbol">↻</button></h2>
     <div class="body" id="tree"></div>
   </section>
   <section class="sec" data-sec="procs">
@@ -700,6 +704,11 @@ function autoSec(name, hasContent) {
   const pref = localStorage.getItem('lampson.sec.' + name);
   setSec(name, pref === null ? hasContent : pref === '1');
 }
+// el árbol se refresca solo cuando una tool pudo crear/borrar archivos (write/edit/bash/process/delegate/lamp),
+// con un pequeño debounce para no repintar 20 veces en un turno con 20 writes; ↻ lo fuerza a mano
+let treeTimer = null;
+function treeChanged() { clearTimeout(treeTimer); treeTimer = setTimeout(loadTree, 400); }
+$('#tree-reload').onclick = e => { e.stopPropagation(); const b = e.currentTarget; b.classList.remove('spin'); void b.offsetWidth; b.classList.add('spin'); loadTree(); };
 document.querySelectorAll('.sec h2').forEach(h => h.onclick = () => {
   const s = h.closest('.sec'); const open = !s.classList.contains('open');
   localStorage.setItem('lampson.sec.' + s.dataset.sec, open ? '1' : '0');
@@ -1244,6 +1253,7 @@ function handle(chunk, thinking) {
   else if (k === 'tool_call') { thinking.querySelector('span:last-child').textContent = 'ejecutando ' + esc(d.name) + '…'; pending = add('step', `<span class="ic">⚙</span>${cmdHtml(describe(d))}`); wireMore(pending); if (d.name === 'process') setTimeout(loadProcs, 2500); if (d.name === 'delegate') { setTimeout(loadAgents, 800); setTimeout(loadAgents, 4000); } if (d.name === 'todo') setTimeout(loadTodo, 300); if (d.name === 'lamp') setTimeout(loadLamps, 300); if (d.name === 'lsp') setTimeout(loadLsp, 1500); }
   else if (k === 'inbox') { add('meta', '✉ ' + esc(String(d).split('\n')[0].slice(0, 160))); loadAgents(); }
   else if (k === 'tool_result') { const out = String(d.output); const bad = /^(ERROR|DENIED)/.test(out);
+    if (!bad && d.call && /^(write|edit|bash|process|delegate|lamp|skill)$/.test(d.call.name)) treeChanged();
     // lámpara recién creada: avisar en el chat con un acceso directo al switch (el modelo no sabe cómo se enciende en esta UI)
     if (d.call && d.call.name === 'lamp' && /^lamp '([^']+)' created/.test(out)) { const nm = out.match(/^lamp '([^']+)' created/)[1]; const m = add('meta', `☼ lámpara <b>${esc(nm)}</b> creada — está apagada: <a href="#" class="lampgo">encenderla en «lámparas»</a>`); m.querySelector('.lampgo').onclick = (ev) => { ev.preventDefault(); $('#lamps').click(); }; $('#lamps').classList.add('new'); setTimeout(() => $('#lamps').classList.remove('new'), 4000); } const el = pending || add('step', '<span class="ic">→</span>'); pending = null; thinking.querySelector('span:last-child').textContent = 'pensando…'; const ic = el.querySelector('.ic'); if (ic) { ic.textContent = bad ? '✗' : '✓'; ic.className = 'ic ' + (bad ? 'bad' : 'ok'); } el.insertAdjacentHTML('beforeend', `<details><summary class="${bad ? 'bad' : ''}">${esc(out.split('\n')[0].slice(0, 140))} <span style="color:var(--ink-3)">(${out.length} chars)</span></summary><pre>${esc(out)}</pre></details>`); }
   else if (k === 'approval_request') { const el = add('approval', `<div class="card"><div class="why">⚠ ${esc(d.why)}</div><code>${esc(describe({name: d.name, args: d.args}))}</code><div class="btns"><button class="primary" data-ok="1">Permitir</button><button data-ok="0">Denegar</button></div></div>`); el.querySelectorAll('button').forEach(b => b.onclick = async () => { el.querySelectorAll('button').forEach(x => x.disabled = true); await fetch('/api/approve', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ id: d.id, decision: b.dataset.ok === '1' }) }); }); el.dataset.id = d.id; }

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))`.