lampson 0.1.2 → 0.1.4

package/lib/approvals.syn

@@ -0,0 +1,176 @@
+-- lib/approvals.syn — aprobaciones humanas fuera de la terminal: cola compartida + webhook + links de decisión
+--
+-- Un solo mecanismo para las puertas por las que un humano aprueba algo que el agente quiere hacer:
+--   1. la UI web (POST /api/approve desde el chat, o desde el panel «Aprobaciones» para las tareas programadas);
+--   2. la terminal: /approve <id> yes|no (una tarea programada corriendo en background mientras chateás);
+--   3. un LINK firmado que llega por el canal que sea (Telegram, mail, Slack…): GET /approve/<id>/<token>?d=yes|no
+--      — de un solo uso; el token es un secreto por aprobación (32 bytes CSPRNG), igual que el `approve` nativo
+--      de Synsema bajo serve (doc 62-human), solo que acá también sirve para las tareas del cron y para la UI;
+--   4. la consola del proceso (el link se imprime ahí también).
+-- Además, si LAMPSON_WEBHOOK_URL está configurado (o config.json {"webhook_url"}), cada aprobación pendiente dispara
+-- un POST JSON con {id, message, why, expires_at, respond_link_yes, respond_link_no} firmado con HMAC-SHA256
+-- (X-Lampson-Signature: sha256=<hex>, secreto LAMPSON_WEBHOOK_SECRET) — el mismo patrón que Stripe/GitHub, así
+-- cualquier receptor (n8n, un bot, otro .syn) reenvía los links. Los links necesitan LAMPSON_PUBLIC_URL (la URL
+-- por la que se llega a este lampson desde afuera: un túnel, el VPS, un edge Synsema con TLS).
+-- Fire-and-forget (10 s, un intento): un canal caído nunca bloquea; la UI y la consola quedan como respaldo.
+--
+-- Estado: BLACKBOARD (share/observe), que existe bajo `serve` y bajo `run` y lo ven handlers, agentes y ticks
+-- (`state_*` solo existe bajo serve — verificado 2026-08-29). Claves: "approval:meta:<id>" (visible, sin token),
+-- "approval:token:<id>", "approval:answer:<id>" (yes|no) y el índice "approval:index" (lista de ids).
+--
+-- Garantía: NUNCA se auto-aprueba. Sin respuesta al vencer el plazo → denegado (fail-closed), como Synsema.
+
+use "./settings.syn" as settings
+
+task read_cfg(key, envname)
+    let v be env(envname, "")
+    when v != ""
+        give v
+    let doc be settings.load()
+    when contains(doc, key)
+        give text(doc[key])
+    give ""
+
+export task webhook_url()
+    require env("LAMPSON_*")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    give read_cfg("webhook_url", "LAMPSON_WEBHOOK_URL")
+
+export task public_url()
+    require env("LAMPSON_*")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    let u be read_cfg("public_url", "LAMPSON_PUBLIC_URL")
+    while length(u) > 0 and slice(u, length(u) - 1, length(u)) == "/"
+        set u to slice(u, 0, length(u) - 1)
+    give u
+
+task secret_text()
+    give read_cfg("webhook_secret", "LAMPSON_WEBHOOK_SECRET")
+
+task index()
+    observe "approval:index" as ix
+    give when ix == nothing then [] otherwise ix
+
+task meta_of(id)
+    observe "approval:meta:" + id as m
+    give m
+
+task set_meta(id, m)
+    share m as "approval:meta:" + id
+
+-- abre una aprobación: id único, token de un solo uso, metadatos visibles (sin token) para la UI.
+-- source = "chat" | "schedule:<id>"; message = lo que se quiere hacer; why = por qué pide permiso.
+export task open(source, message, why, timeout_s)
+    require time
+    require random
+    require net
+    require env("LAMPSON_*")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    let id be "a" + slice(text(floor(now() * 1000)), 4, 13) + "-" + slice(token(16), 0, 6)
+    let tok be token(32)
+    let meta be {"id": id, "source": source, "message": message, "why": why, "created": now(), "expires_at": floor(now() + timeout_s), "status": "pending"}
+    set_meta(id, meta)
+    share tok as "approval:token:" + id
+    share nothing as "approval:answer:" + id
+    share append(index(), id) as "approval:index"
+    bus_publish("approval.request", meta)
+    let links be links_for(id, tok)
+    print("[lampson] aprobación pendiente " + id + " — " + message + " (vence en " + text(floor(timeout_s)) + " s)" + (when links["yes"] != "" then "\n  sí: " + links["yes"] + "\n  no: " + links["no"] otherwise "\n  respondé desde la UI web (Aprobaciones), con /approve " + id + " yes|no en la terminal, o configurá la URL pública para recibir links"))
+    notify(meta, links)
+    give id
+
+task links_for(id, tok)
+    let base be public_url()
+    when base == ""
+        give {"yes": "", "no": "", "path": "/approve/" + id + "/" + tok}
+    give {"yes": base + "/approve/" + id + "/" + tok + "?d=yes", "no": base + "/approve/" + id + "/" + tok + "?d=no", "path": "/approve/" + id + "/" + tok}
+
+-- webhook firmado (fire-and-forget)
+task notify(meta, links)
+    let url be webhook_url()
+    when url == ""
+        give false
+    let payload be {"id": meta["id"], "type": "approve", "source": meta["source"], "message": meta["message"], "why": meta["why"], "expires_at": meta["expires_at"], "respond_path": links["path"], "respond_link_yes": links["yes"], "respond_link_no": links["no"]}
+    let body be json_encode(payload)
+    let headers be {"Content-Type": "application/json", "User-Agent": "lampson"}
+    let sec be secret_text()
+    when sec != ""
+        set headers["X-Lampson-Signature"] to "sha256=" + hmac_sha256(body, sec)
+    try
+        let r be http_post(url, body, headers)
+        when not r["ok"]
+            print("[lampson] webhook " + url + " respondió " + text(r["status"]))
+        give r["ok"]
+    recover err
+        print("[lampson] webhook falló: " + text(err))
+        give false
+
+-- espera (polling) hasta que alguien responda o venza el plazo. Devuelve true/false; sin respuesta = false.
+export task wait(id, timeout_s)
+    require time
+    let deadline be now() + timeout_s
+    let answer be nothing
+    while answer == nothing and now() < deadline
+        observe "approval:answer:" + id as a
+        set answer to a
+        when answer == nothing
+            sleep(0.5)
+    let meta be meta_of(id)
+    let ok be answer == "yes"
+    when meta != nothing
+        set meta["status"] to when answer == nothing then "expired" otherwise (when ok then "approved" otherwise "denied")
+        set meta["answered"] to now()
+        set_meta(id, meta)
+        bus_publish("approval.result", meta)
+    share nothing as "approval:token:" + id
+    give ok
+
+-- responder desde la UI (loopback, ya autenticado) o desde la terminal: sin token
+export task answer(id, decision)
+    let meta be meta_of(id)
+    when meta == nothing
+        give false
+    when meta["status"] != "pending"
+        give false
+    let v be when decision then "yes" otherwise "no"
+    share v as "approval:answer:" + id
+    give true
+
+-- responder por link: el token debe coincidir (comparación en tiempo constante) y ser de un solo uso
+export task answer_with_token(id, tok, decision)
+    observe "approval:token:" + id as want
+    when want == nothing
+        give {"ok": false, "why": "expired"}
+    when not verify_hmac(id, hmac_sha256(id, tok), want)
+        give {"ok": false, "why": "bad token"}
+    share nothing as "approval:token:" + id
+    let v be when decision then "yes" otherwise "no"
+    share v as "approval:answer:" + id
+    give {"ok": true, "why": ""}
+
+-- pendientes y recientes para la UI (nunca incluye tokens); las resueltas hace más de 1 h se olvidan
+export task list()
+    require time
+    let out be []
+    let keep be []
+    each id in index()
+        let m be meta_of(id)
+        when m != nothing
+            when m["status"] != "pending" and contains(m, "answered") and now() - m["answered"] > 3600
+                share nothing as "approval:meta:" + id
+            otherwise
+                set out to append(out, m)
+                set keep to append(keep, id)
+    when length(keep) != length(index())
+        share keep as "approval:index"
+    give sort_by(out, (m) => 0 - m["created"])
+
+export task pending()
+    give where(list(), (m) => m["status"] == "pending")
+
+-- página mínima que ve quien abre el link
+export task html_page(title, body)
+    give "<!doctype html><meta charset=utf-8><meta name=viewport content='width=device-width,initial-scale=1'><title>" + title + "</title><body style='font:16px/1.5 system-ui;margin:0;display:grid;place-items:center;min-height:100vh;background:#f6f4ef;color:#1d1c1a'><div style='max-width:520px;padding:32px;border:1px solid #d9d4c7;border-radius:6px;background:#fffdf8'><p style='margin:0 0 6px;font:11px/1 ui-monospace,monospace;letter-spacing:.12em;text-transform:uppercase;color:#a33'>lampson</p><h1 style='font-size:22px;margin:0 0 12px'>" + title + "</h1><p style='margin:0'>" + body + "</p></div></body>"

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/permission.syn

@@ -114,6 +114,17 @@ export task evaluate(name, args, mode)
                 give {"decision": "deny", "reason": "strict mode (" + act + " MCP server)"}
             give {"decision": "ask", "reason": act + "s MCP server '" + (when contains(args, "name") then text(args["name"]) otherwise "?") + "'" + (when act == "add" then " → runs: " + (when contains(args, "command") then text(args["command"]) otherwise "?") otherwise "")}
         give {"decision": "allow", "reason": "read-only tool"}
+    when name == "schedule"
+        -- programar = autorizar corridas futuras SIN nadie mirando (un comando, una lámpara, o el agente entero
+        -- con un sobre de permisos): humano siempre, incluso en yolo. list/log son lectura.
+        let sact be when contains(args, "action") then text(args["action"]) otherwise "list"
+        when sact == "list" or sact == "log"
+            give {"decision": "allow", "reason": "read-only tool"}
+        when mode == "strict"
+            give {"decision": "deny", "reason": "strict mode (schedule " + sact + ")"}
+        when sact == "add"
+            give {"decision": "ask", "reason": "schedules an unattended " + (when contains(args, "kind") then text(args["kind"]) otherwise "?") + " task" + (when contains(args, "permission") then " with permission=" + text(args["permission"]) otherwise " with permission=ask")}
+        give {"decision": "ask", "reason": "schedule " + sact + " " + (when contains(args, "id") then text(args["id"]) otherwise "?")}
     when name == "skill" and is_install(args)
         -- instala instrucciones/scripts de terceros FUERA del workspace (~/.agents/skills): humano siempre, incluso en yolo
         when mode == "strict"
@@ -145,6 +156,13 @@ export task describe_call(name, args)
         when act == "remove"
             give "mcp remove " + (when contains(args, "name") then text(args["name"]) otherwise "?")
         give "mcp list"
+    when name == "schedule"
+        let sact be arg(args, "action", "list")
+        when sact == "add"
+            let what be arg(args, "kind", "?")
+            let body be when what == "lamp" then "lamp " + arg(args, "lamp", "?") + "." + arg(args, "tool", "?") + (when contains(args, "args") then " " + one_line(json_encode(args["args"]), 80) otherwise "") otherwise (when what == "bash" then "$ " + one_line(arg(args, "command", "?"), 120) otherwise "agent " + arg(args, "agent", "build") + ": " + one_line(arg(args, "prompt", "?"), 160))
+            give "schedule add «" + arg(args, "name", "?") + "» · " + arg(args, "at", "?") + " · " + body + " · permission " + arg(args, "permission", "ask") + (when contains(args, "notify") then " · notify " + text(args["notify"]) otherwise "")
+        give "schedule " + sact + (when contains(args, "id") then " " + text(args["id"]) otherwise "")
     when name == "skill" and is_install(args)
         give "skill install " + text(args["source"]) + " --skill " + text(args["name"]) + " (" + (when contains(args, "scope") then text(args["scope"]) otherwise "global") + ")"
     when name == "bash"

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.