lampson 0.1.2 → 0.1.3

package/README.md

@@ -139,6 +139,10 @@ servers, flags), `↑↓` browse history or the menu, `Alt+Enter` inserts a newl
 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`).
 
+While the model thinks or a slow tool runs (a long `bash`, a sub-agent), a status line shows what is
+running, the elapsed time and a bar that fills as you wait (`⠋ pensando  ▰▰▱▱▱▱▱▱▱▱ 12s`); it appears
+after 0.4 s so instant tools do not flicker, and anything you type meanwhile lands in the prompt.
+
 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
@@ -299,7 +303,7 @@ Borrowed from the harness that does each part best (see `notes/*.md`):
 | Budget runs out silently | 80 %: a notice appended to the latest tool result (no new user message, cache stays warm); 95 %: last step without tools, summary required | hermes / opencode |
 | Edits a file it never read, or one that changed | **Observation gate in code**: `read` records the file hash; `edit`/`write` on an existing file are rejected without it, or if the file changed since | deepseek |
 | Loses the plan | `todo` tool (whole-list replacement, one `in_progress` at a time, scoped to the session like the three references); re-injected only after context compaction, active items only | hermes, opencode |
-| Reads the whole project before touching anything | **Exploration cap** (ours): after 8 read-only calls in a row (read/ls/find/grep) without an edit/write/command the result carries a warning; after 16 they are refused until it acts (`LAMPSON_EXPLORE_CAP`) | — |
+| Reads the whole project before touching anything | **Exploration cap** (ours): after 12 read-only calls in a row (read/ls/find/grep) without an edit/write/command the result carries a warning; after 24 they are refused until it acts (`LAMPSON_EXPLORE_CAP`) | — |
 
 ### Sub-agents
 

package/chat.syn

@@ -46,6 +46,7 @@ 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/ui.syn" as ui
 use "./lib/mcp.syn" as mcp
 use "./lib/lamps.syn" as lamps
 use "./lib/lsp.syn" as lsp
@@ -107,6 +108,15 @@ task summarize(name, out)
                 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 == "delegate" and not VERBOSE
+        -- una línea por subagente: el encabezado [id · agente · estado · pasos · tokens · log]
+        let heads be []
+        each l in lines
+            when starts_with(trim(l), "[") and contains(l, " steps") or (starts_with(trim(l), "[") and contains(l, " · log:"))
+                set heads to append(heads, trim(l))
+        when length(heads) == 0
+            give first_line(out, 120)
+        give join(heads, "\n      ")
     when name == "grep" and not VERBOSE
         let files be {}
         each l in lines
@@ -136,11 +146,21 @@ task diff_of(name, out)
     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)
+    print_diff_with("    ", path, d)
+
+-- lead = lo que va antes del ✓ (la llamada, si se fusionó en la misma línea)
+task print_diff_with(lead, path, d)
+    let head be green("✓") + " " + c("34", path) + "  " + green("+" + text(d["added"])) + " " + red("−" + text(d["removed"]))
+    print(lead + head)
     each l in d["lines"]
         print("      " + l)
 
+-- tools "instantáneas": la llamada se imprime junto con su resultado, en una sola línea
+task is_instant(name)
+    give name == "read" or name == "ls" or name == "find" or name == "grep" or name == "memory" or name == "edit" or name == "write" or name == "todo" or name == "lsp"
+
+let pending_call be ""
+
 -- /out: resultado completo de una tool del turno
 task print_full(o)
     when o["diff"] != nothing
@@ -149,17 +169,110 @@ task print_full(o)
         each l in split(o["output"], "\n")
             print("      " + l)
 
+-- ---------- indicador de espera ----------
+-- El intérprete principal se bloquea en la llamada al modelo y en cada tool; el que dibuja es un agente
+-- (hilo real) que mira el blackboard: `lampson:busy` = {label, kind, since} mientras hay algo en curso.
+-- Arranca a dibujar recién a los 0,4 s (las tools instantáneas no parpadean) y suelta la terminal
+-- (`lampson:spinner:holding` = false) antes de que el principal vuelva a imprimir.
+agent Spinner
+    require time
+    let frames be ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    let i be 0
+    let drawn be false
+    let run be true
+    -- MIGA: un agente NO puede abrir la terminal (term_open → nothing) pero sí print+flush. Cada print de un
+    -- agente sale con el prefijo "[Spinner_0] " en la línea de abajo: cada frame limpia esa línea (\r ESC[K),
+    -- sube una (ESC[1A) y redibuja la suya. Al terminar deja el cursor en la línea del spinner, vacía.
+    let clear_here be "\r" + esc + "[K"
+    let up be esc + "[1A"
+    while run
+        observe "lampson:spinner:stop" as st
+        observe "lampson:busy" as b
+        when st == true
+            set run to false
+        otherwise when b == nothing
+            when drawn
+                print(clear_here + up + clear_here + up)
+                flush()
+                set drawn to false
+            share false as "lampson:spinner:holding"
+            sleep(0.05)
+        otherwise
+            let el be now() - b["since"]
+            when el >= 0.4
+                -- barra de "costo hundido": se llena rápido al principio y cada vez más despacio
+                let fill be floor(10 * (1 - exp(0 - el / 40)))
+                let bar be ""
+                let k be 0
+                while k < 10
+                    set bar to bar + (when k < fill then "▰" otherwise "▱")
+                    set k to k + 1
+                let hint be when el > 90 then "  esto está tardando (Ctrl+C corta)" otherwise (when el > 30 then "  ya casi" otherwise (when el > 8 then "  sigue trabajando" otherwise ""))
+                let secs be text(floor(el)) + "s"
+                let label be b["label"]
+                when length(label) > 60
+                    set label to slice(label, 0, 59) + "…"
+                let frame be frames[i % 10]
+                let body be when color then esc + "[36m" + frame + esc + "[0m " + label + "  " + esc + "[2m" + bar + " " + secs + hint + esc + "[0m" otherwise frame + " " + label + "  " + bar + " " + secs + hint
+                when drawn
+                    print(clear_here + up + clear_here + "  " + body)
+                otherwise
+                    share true as "lampson:spinner:holding"
+                    print(clear_here + "  " + body)
+                    set drawn to true
+                flush()
+                set i to i + 1
+            sleep(0.08)
+    when drawn
+        print(clear_here + up + clear_here + up)
+        flush()
+    share false as "lampson:spinner:holding"
+
+task busy_on(label, kind)
+    share {"label": label, "kind": kind, "since": now()} as "lampson:busy"
+
+-- apagar y esperar a que el agente suelte la terminal (máx. 1 s) antes de volver a imprimir
+task busy_off()
+    share nothing as "lampson:busy"
+    let waited be 0
+    let holding be true
+    while holding and waited < 100
+        observe "lampson:spinner:holding" as hd
+        set holding to hd == true
+        when holding
+            sleep(0.01)
+            set waited to waited + 1
+
 -- 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"
+    when kind == "busy"
+        busy_on(data["label"], data["kind"])
+    otherwise when kind == "idle"
+        busy_off()
+    otherwise when kind == "assistant"
+        -- ● marca el turno del asistente (primera línea con contenido)
+        let lines be split(md.render(data, COLOR), "\n")
+        let marked be false
+        let out_lines be []
+        each l in lines
+            when not marked and trim(l) != "" and starts_with(l, "  ")
+                set out_lines to append(out_lines, c("36;1", "● ") + slice(l, 2, length(l)))
+                set marked to true
+            otherwise
+                set out_lines to append(out_lines, l)
         print("")
-        print(md.render(data, COLOR))
+        print(join(out_lines, "\n"))
         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"])))
+        let desc be permission.describe_call(data["name"], data["args"])
+        when is_instant(data["name"])
+            set pending_call to desc
+        otherwise
+            set pending_call to ""
+            print("  " + yellow("▸ " + desc))
     otherwise when kind == "tool_result"
         let out be data["output"]
         let name be data["call"]["name"]
@@ -167,11 +280,17 @@ task on_event(kind, data, tag)
         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})
+        let lead be when pending_call != "" then "  " + yellow("▸ " + pending_call) + "  " otherwise "    "
+        set pending_call to ""
         when d != nothing
-            print_diff(path, d)
+            print_diff_with(lead, 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))))
+            let s be summarize(name, out)
+            -- una sola línea → cortar al ancho; multilínea (bash) se deja
+            when not contains(s, "\n")
+                set s to ui.cut(s, ui.cols() - ui.width(lead) - 4)
+            print(lead + mark + " " + (when bad then red(s) otherwise dim(s)))
     otherwise when kind == "tool_denied"
         set data to data
     otherwise when kind == "error"
@@ -180,11 +299,13 @@ task on_event(kind, data, tag)
             print("  " + yellow("el proveedor rechazó el nombre del modelo (" + cfg["model"] + "): /model sin argumentos lista los válidos, /model <nombre> lo cambia"))
     otherwise when kind == "compact"
         print("  " + dim("⧗ compactando contexto (~" + text(data["before"]) + " tokens)"))
+        busy_on("compactando contexto", "llm")
     flush()
 
 -- Human in the loop con el `approve` nativo de Synsema: prompt [approve] … (y/n) en TTY; sin TTY deniega
 -- (fail-closed, un agente no puede auto-aprobarse); `within` acota la espera.
 task ask_user(name, args, why)
+    busy_off()
     print("")
     print("  " + yellow("⚠ requiere tu aprobación · " + why))
     print("    " + permission.describe_call(name, args))
@@ -641,6 +762,9 @@ when sid == ""
 share {"id": sid} as "lampson:session"
 
 banner(env_info["cwd"], cfg, profile, opts["permission_mode"], sid)
+share nothing as "lampson:busy"
+share false as "lampson:spinner:stop"
+spawn Spinner with esc = ESC, color = COLOR
 flush()
 
 let total_usage be {"input": 0, "output": 0}
@@ -1005,23 +1129,31 @@ while running
             -- catálogo fresco por turno: si el turno anterior conectó/quitó un server MCP, sus tools
             -- entran/salen acá (con los mismos servers el catálogo es idéntico → el prompt cache no se corta)
             set opts to opts_for(profile, mode)
+            let t0 be now()
             let result be loop.run_turn(cfg, messages, opts, on_event)
             trace.turn_end(sid, result)
             set messages to result["messages"]
             set total_usage to {"input": total_usage["input"] + result["usage"]["input"], "output": total_usage["output"] + result["usage"]["output"]}
-            let summary be text(result["steps"]) + (when result["steps"] == 1 then " paso" otherwise " pasos") + " · " + fmt_tokens(result["usage"]["input"] + result["usage"]["output"]) + " tokens"
+            let summary be text(result["steps"]) + (when result["steps"] == 1 then " paso" otherwise " pasos") + " · " + fmt_tokens(result["usage"]["input"] + result["usage"]["output"]) + " tokens · " + ui.fmt_duration(now() - t0)
             when result["stopped"] == "max_steps"
                 set summary to summary + " · " + red("límite de " + text(opts["max_steps"]) + " pasos por turno")
                 print(dim("  ─── " + summary))
                 print("  " + yellow("El agente paró por el límite de pasos, no porque terminó. Escribí «seguí» para que continúe donde quedó, o subí LAMPSON_MAX_STEPS."))
             otherwise when result["stopped"] != "done"
-                set summary to summary + " · " + red("detenido: " + result["stopped"])
+                -- el detalle del error ya salió en la línea ‼; acá solo la causa corta
+                let why be result["stopped"]
+                when starts_with(why, "error: network")
+                    set why to "error de red (ver ‼ arriba)"
+                otherwise when starts_with(why, "error:")
+                    set why to first_line(why, 60)
+                set summary to summary + " · " + red("detenido: " + why)
                 print(dim("  ─── " + summary))
             otherwise
                 print(dim("  ─── " + summary))
             session.save(sid, messages, {"title": session.title_of(messages)})
     flush()
 -- los procesos gestionados (servidores) y los subagentes en background mueren con lampson
+share true as "lampson:spinner:stop"
 agents.stop_all()
 mcp.stop_all()
 lsp.stop_all()

package/lib/diff.syn

@@ -1,10 +1,33 @@
 -- 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.
+-- medio. Si el medio supera LIMIT² celdas (80×80 líneas cambiadas ≈ un rewrite) se muestra como bloque
+-- quitado + bloque agregado: exacto y en milisegundos (el LCS interpretado a 300×300 tardaba 2 minutos).
+
+use "./ui.syn" as ui
 
 let ESC be decode(bytes("1b", "hex"))
-let LIMIT be 600
+let LIMIT be 80
+
+-- línea de diff con fondo (verde/rojo) rellenada hasta el ancho útil, cortada si se pasa
+task row(color, kind, num, body, width)
+    let n be sgr(color, "2", lpad(num, width) + " │ ")
+    let w be ui.cols() - 8 - width - 3
+    when w < 30
+        set w to 30
+    let txt be ui.cut(kind + " " + body, w)
+    let pad be rep(" ", w - ui.width(txt))
+    when kind == "+"
+        give n + ui.bg_add(color, sgr(color, "32", txt + pad))
+    when kind == "-"
+        give n + ui.bg_del(color, sgr(color, "31", txt + pad))
+    give n + sgr(color, "2", ui.cut("  " + body, w))
+
+task rep(ch, n)
+    let out be ""
+    while length(out) < n
+        set out to out + ch
+    give out
 
 task sgr(color, code, s)
     when not color
@@ -22,10 +45,13 @@ 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)
+    -- MIGA: append copia la lista entera (O(n) cada vez) → construirla con append era O(n²·m²).
+    -- range() la crea de una y set por índice es O(1).
+    let table be range(0, (n + 1) * (m + 1))
+    let z be 0
+    while z < (n + 1) * (m + 1)
+        set table[z] to 0
+        set z to z + 1
     let i be n - 1
     while i >= 0
         let j be m - 1
@@ -98,7 +124,7 @@ export task diff(old, new, ctx, color)
         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 lines to append(lines, row(color, " ", text(k + 1), a[k], width))
         set k to k + 1
     -- medio: contexto interno acotado (ctx a cada lado de un cambio)
     let last_change be -1
@@ -118,16 +144,16 @@ export task diff(old, new, ctx, color)
             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 lines to append(lines, row(color, " ", text(pre + o["b"] + 1), mid_b[o["b"]], width))
                 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 lines to append(lines, row(color, "-", text(pre + o["a"] + 1), mid_a[o["a"]], width))
             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 lines to append(lines, row(color, "+", text(pre + o["b"] + 1), mid_b[o["b"]], width))
             set skipping to false
         set idx to idx + 1
     -- contexto posterior (del sufijo común)
@@ -135,7 +161,7 @@ export task diff(old, new, ctx, color)
     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 lines to append(lines, row(color, " ", text(k + 1), b[k], width))
         set k to k + 1
     when upto < length(b)
         set lines to append(lines, sgr(color, "2", lpad("", width) + " ⋯"))

package/lib/line.syn

@@ -8,6 +8,8 @@
 --       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.
 
+use "./ui.syn" as ui
+
 let ESC be decode(bytes("1b", "hex"))
 let MENU_ROWS be 8
 export let INTERRUPT be ESC + "interrupt"
@@ -18,7 +20,7 @@ task sgr(color, code, s)
     give ESC + "[" + code + "m" + s + ESC + "[0m"
 
 task vis(s)
-    give length(strip_ansi(s))
+    give ui.width(s)
 
 task rep(ch, n)
     let out be ""
@@ -102,13 +104,14 @@ task draw(h, st, color, ctx)
     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)
+        set out to out + (when i > 0 then "\r\n" otherwise "") + pre + (when st["final"] and l != "" then sgr(color, "7", " " + l + " ") otherwise l)
+        let r be rows_of(vis(pre) + ui.width(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
+            let ccw be ui.width(slice(l, 0, cc))
+            set rows_before_cursor to rows_before_cursor + floor((vis(pre) + ccw) / cols)
+            set cursor_col to (vis(pre) + ccw) % cols
         set total to total + r
         set i to i + 1
     -- menú
@@ -182,7 +185,8 @@ 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}
+    ui.set_cols(term_size(h)["cols"])
+    let st be {"buf": "", "cur": 0, "prompt": prompt, "cursor_row": 0, "menu": false, "menu_off": false, "kind": "", "items": [], "sel": 0, "nav": false, "final": false}
     let hist be ctx["history"]
     let hi be length(hist)
     let draft be ""
@@ -207,7 +211,7 @@ export task read(prompt, color, ctx)
             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
+            ui.set_cols(ev["cols"])
         otherwise when ev["type"] == "key"
             let k be ev["key"]
             let changed be true
@@ -300,13 +304,14 @@ export task read(prompt, color, ctx)
             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["final"] to result != nothing and result != INTERRUPT and trim(st["buf"]) != ""
     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
+        let pre be (when i == 0 then vis(st["prompt"]) otherwise 4) + (when st["final"] then 2 otherwise 0)
         when i > 0 or true
             set tail to tail + rows_of(pre + length(l), size["cols"])
         set i to i + 1

package/lib/loop.syn

@@ -55,7 +55,7 @@ export task explore_cap()
     let e be env("LAMPSON_EXPLORE_CAP", "")
     when e != ""
         give floor(number(e))
-    give 16
+    give 24
 
 -- {streak, note, refuse}: nuevo streak tras esta llamada y qué hacer con ella
 export task explore_verdict(streak, name, cap)
@@ -100,6 +100,9 @@ export task spill(name, id, out)
     require file(".lampson/*")
     when name == "read" or length(out) <= SPILL_CAP
         give out
+    -- el informe de los subagentes es el entregable: no se manda a disco (hasta 60k)
+    when name == "delegate" and length(out) <= SPILL_CAP * 6
+        give out
     let path be SPILL_DIR + "/" + id + ".txt"
     write_file(path, out)
     let half be floor(SPILL_CAP / 2)
@@ -276,17 +279,21 @@ task execute(tc, opts, on_event)
         when not approved
             emit(on_event, "tool_denied", {"call": tc, "reason": "user declined (" + verdict["reason"] + ")"}, tag)
             give "DENIED by the user (" + verdict["reason"] + "). Do not retry this exact action; ask the user or propose an alternative."
+    emit(on_event, "busy", {"label": permission.describe_call(name, args), "kind": "tool", "name": name}, tag)
+    let out be ""
     try
         -- tools MCP: no son tasks Synsema (args libres); el registry las marca con "mcp"
         when registry[name] == "mcp"
-            give text(mcp.call(name, args))
+            set out to text(mcp.call(name, args))
         -- tools de lámparas: un proceso hijo por llamada (lib/lamps.syn)
-        when registry[name] == "lamp"
-            give text(lamps.call(name, args))
-        let result be call_tool(registry[name], args)
-        give text(result)
+        otherwise when registry[name] == "lamp"
+            set out to text(lamps.call(name, args))
+        otherwise
+            set out to text(call_tool(registry[name], args))
     recover err
-        give "ERROR: " + err
+        set out to "ERROR: " + err
+    emit(on_event, "idle", nothing, tag)
+    give out
 
 export task run_turn(cfg, messages, opts, on_event)
     require net
@@ -353,7 +360,9 @@ export task run_turn(cfg, messages, opts, on_event)
         when last_step
             let why be when over_budget then "Token budget for this turn is exhausted (" + text(spent) + " of " + text(floor(budget)) + " tokens)" otherwise "Step limit reached for this turn (" + text(max_steps) + " tool calls)"
             set msgs to append(msgs, {"role": "user", "content": "[harness] " + why + ". Do NOT call tools now. Reply with a short status: what you completed, what is verified, and exactly what remains to do next. The user can say 'continue' to resume."})
+        emit(on_event, "busy", {"label": "pensando", "kind": "llm"}, tag)
         let r be provider.chat_retry(cfg, msgs, cat, 3)
+        emit(on_event, "idle", nothing, tag)
         when r["error"] != nothing
             emit(on_event, "error", r["error"], tag)
             set stopped to "error: " + r["error"]
@@ -406,16 +415,21 @@ export task run_turn(cfg, messages, opts, on_event)
                 when ex["note"] != ""
                     set out to out + ex["note"]
                     emit(on_event, "inbox", "tope de exploración a la mitad (" + text(explore_streak) + "/" + text(cap) + " lecturas seguidas sin actuar): aviso al modelo", tag)
-            when starts_with(out, "ERROR") or starts_with(out, "DENIED")
+            -- solo cuentan los errores REALES de la tool; los rechazos del harness (tope de lecturas,
+            -- repeticiones) ya castigan con el rechazo y no deben además cortar el turno
+            when (starts_with(out, "ERROR") or starts_with(out, "DENIED")) and not starts_with(out, "ERROR: exploration cap") and not starts_with(out, "ERROR: this turn already made") and not starts_with(out, "ERROR: you already called")
                 set errors to errors + 1
             emit(on_event, "tool_result", {"call": tc, "output": out}, tag)
             set msgs to append(msgs, tool_result_msg(tc, out))
         when errors >= MAX_ERRORS_PER_TURN
             set msgs to append(msgs, {"role": "user", "content": "[harness] Too many tool errors this turn. Stop calling tools and report what happened."})
+            emit(on_event, "busy", {"label": "pensando", "kind": "llm"}, tag)
             let fin be provider.chat_retry(cfg, msgs, [], 2)
-            set msgs to append(msgs, {"role": "assistant", "content": fin["text"], "tool_calls": []})
-            emit(on_event, "assistant", fin["text"], tag)
-            give {"messages": msgs, "text": fin["text"], "steps": steps, "usage": usage, "stopped": "too_many_errors"}
+            emit(on_event, "idle", nothing, tag)
+            let fin_text be strip_raw_tool_calls(fin["text"])
+            set msgs to append(msgs, {"role": "assistant", "content": fin_text, "tool_calls": []})
+            emit(on_event, "assistant", fin_text, tag)
+            give {"messages": msgs, "text": fin_text, "steps": steps, "usage": usage, "stopped": "too_many_errors"}
     set stopped to when spent > budget then "budget" otherwise "max_steps"
     give {"messages": msgs, "text": final_text, "steps": steps, "usage": usage, "stopped": stopped}
 

package/lib/md.syn

@@ -5,8 +5,26 @@
 -- (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"))
-let WIDTH be 72
+-- 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 == ""
@@ -41,16 +59,16 @@ 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)
+        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 + "`" + emphasis(p, color)
+            set out to out + "`" + paths(emphasis(p, color), color)
         otherwise when idx % 2 == 1
-            set out to out + sgr(color, "33", p)
+            set out to out + sgr(color, "36", p)
         otherwise
-            set out to out + emphasis(p, color)
+            set out to out + paths(emphasis(p, color), color)
         set idx to idx + 1
     give out
 
@@ -79,19 +97,51 @@ task table_lines(rows, pre, color)
         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))
+            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
-        let cells be []
+        -- 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 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)
+            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
-        set out to append(out, pre + join(cells, sgr(color, "2", " │ ")))
+        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
@@ -102,7 +152,7 @@ task table_lines(rows, pre, color)
 
 task fence_top(lang, color)
     let label be when lang != "" then " " + lang + " " otherwise ""
-    give sgr(color, "2", "┌──" + label + rep("─", WIDTH - 3 - length(label)))
+    give sgr(color, "2", "┌──" + label + rep("─", width_now() - 3 - length(label)))
 
 export task render(md, color)
     let pre be "  "
@@ -122,9 +172,9 @@ export task render(md, color)
         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)))
+                set out to append(out, pre + sgr(color, "2", "└" + rep("─", width_now() - 1)))
             otherwise
-                set out to append(out, pre + sgr(color, "2", "│ ") + sgr(color, "36", line))
+                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)
@@ -143,7 +193,7 @@ export task render(md, color)
             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)))
+            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:|-]+\|")
@@ -160,12 +210,20 @@ export task render(md, color)
             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))
+            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
-            set out to append(out, when t == "" then "" otherwise pre + inline(line, color))
+            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 - 1)))
+        set out to append(out, pre + sgr(color, "2", "└" + rep("─", width_now() - 1)))
     give join(out, "\n")

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/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.2",
+  "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": {

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; }