lampson 0.1.1 → 0.1.3

package/lib/diff.syn

@@ -0,0 +1,168 @@
+-- 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 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 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
+        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
+    -- 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
+        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, 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
+    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, 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, row(color, "-", text(pre + o["a"] + 1), mid_a[o["a"]], width))
+            set skipping to false
+        otherwise
+            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)
+    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, 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) + " ⋯"))
+    give {"added": added, "removed": removed, "lines": lines}

package/lib/line.syn

@@ -0,0 +1,370 @@
+-- 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.
+
+use "./ui.syn" as ui
+
+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 ui.width(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 + (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
+            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ú
+    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)
+    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 ""
+    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"
+            ui.set_cols(ev["cols"])
+        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["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) + (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
+    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/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}