lampson 0.2.2 → 0.2.4

package/README.md

@@ -12,8 +12,8 @@ language itself — and every step is visible, in the terminal or in a web UI.
   Ollama, Anthropic, MiniMax… one `.env` line to switch.
 - **Least-privilege by construction**: each tool declares its capabilities; the runtime enforces
   them. File tools can only touch the mounted workspace (absolute paths, `..`, sibling dirs → denied).
-- **Permissions you control**: `ask` (approve dangerous commands, in the terminal or with a button in
-  the web UI), `yolo`, `strict`. Destructive system commands are always blocked.
+- **Permissions you control**: `ask` (approve dangerous commands, with a ↑↓ menu in the terminal or a
+  button in the web UI), `yolo`, `strict`. Destructive system commands are always blocked.
 - **Agents**: `build` (edits), `plan` (read-only), `review` (runs tests, never edits), `explore`,
   `worker` (scoped implementation). **Sub-agents**: `delegate` runs several of them *in parallel*
   (real threads) with their own context and a restricted toolset, or in the *background* — the report
@@ -45,8 +45,14 @@ language itself — and every step is visible, in the terminal or in a web UI.
   and edit them (web panel, `/memory`).
 - **`!command`**: run something yourself from the chat inside a real pseudo-terminal (prompts, passwords
   and REPLs work); the output lands in the agent's context.
-- **Terminal in the browser**: the web UI opens a real shell (pty, cwd = your project) in the center pane
-  — `>_ terminal` in the header. Synsema 0.6.8+.
+- **Terminals in the browser**: the web UI opens a real shell (pty, cwd = your project) in the center pane
+  — `>_ terminal` in the header, `+ nueva terminal` for another one (up to 4 tabs, one shell each), plus the
+  usual window controls: minimize (the pane hides, every shell keeps running, the header button turns green),
+  full screen, close (kills the active shell). **A page reload doesn't kill them**: each shell lives in a
+  supervisor agent (`lib/term.syn`), not in the socket, so the page comes back, asks `GET /api/terms` and
+  re-attaches by id with a replay of the last output — same pid, same session, same `cd`. With no socket
+  attached for 30 min the shell is collected, and everything dies with lampson. A shell that exits keeps its
+  output on screen — read the last logs, then `+` for a fresh one. Synsema 0.6.8+.
 - **Local only**: the web API (chat with tools, terminal, process control) answers loopback clients
   only; anything else gets 401. To let a script in from elsewhere, set `LAMPSON_WEB_TOKEN` in `.env`
   and send `Authorization: Bearer <token>`.
@@ -260,8 +266,10 @@ cli.syn              what launchers ask Synsema: ensure/list/hub-start/hub-stop/
 hub.tpl.syn          template of the hub (:8080): workspaces screen + API, supervisor tick, one proxy route per workspace
 lib/workspaces.syn   registry (.lampson/workspaces.json), ws/<slug> dirs + junctions, detached processes, health,
                      life policy, folder picker (native dialog / server-side browser)
-chat.syn             terminal REPL (colors, approvals via Synsema's native `approve`)
+chat.syn             terminal REPL (colors, ↑↓ menus for approvals / setup / confirmations, `approve` without a TTY)
 web.syn              one process per workspace: /w/:slug/api/… → SSE chat, sessions, tree, processes, schedules…
+lib/term.syn         browser terminals: one supervisor agent per pty (survives the socket → survives F5),
+                     bus bridge term.ctl.<id> / term.out.<id>, replay buffer, idle collection
 public/              web UI (no build step, no dependencies; classic scripts served by `static`)
   index.html         markup only: header, the two side panels, the chat; loads css/ and js/ in order
   css/               tokens (fonts, palette, base) · layout (grid, header, panels, chat, composer) · sidebar · chat · panel

package/chat.syn

@@ -334,7 +334,7 @@ let COMMANDS be [
     ["/setup", "", "elegir proveedor, modelo y pegar la API key (queda en lampson/.lampson/config.json, local)"],
     ["/paste", "", "adjuntar la imagen del portapapeles al próximo mensaje (copiá una captura y escribí /paste)"],
     ["/image", "<ruta>", "adjuntar una imagen (png/jpg/gif/webp) al próximo mensaje; /image sin ruta muestra o quita las pendientes"],
-    ["/delete", "<id>", "borrar una sesión guardada (ver /sessions)"],
+    ["/delete", "<id>", "borrar una sesión guardada, con confirmación (ver /sessions)"],
     ["/config", "", "ver la configuración vigente (proveedor, modelo, límites, workspace)"],
     ["/files", "", "árbol completo del workspace"],
     ["/procs", "", "procesos que el agente dejó corriendo (servidores) y su estado"],
@@ -349,7 +349,7 @@ let COMMANDS be [
     ["/lamps", "[on <nombre> | off <nombre> | run <lámpara> <tool> [json] | remove <nombre>]", "lámparas (plugins de tools): listar, encender o apagar (global: lampson/lamps/ · proyecto: .lampson/lamps/)"],
     ["/lsp", "[add <typescript|python|rust|go|css|html> [--project] | add <nombre> <comando…> --ext .x=lang | remove <nombre>]", "language servers (navegación semántica: symbols/definition/references/hover); arrancan en la primera consulta"],
     ["/schedule", "[add <json> | run <id> | on <id> | off <id> | remove <id> | log <id>]", "tareas programadas (cada 6h, todos los días a las 9…): lámpara, comando o corrida del agente; corren mientras lampson esté abierto (o con lampson --daemon start, sin nada abierto)"],
-    ["/approve", "<id> yes|no", "responder una aprobación pendiente de una tarea programada que corre en background"],
+    ["/approve", "<id> [yes|no]", "responder una aprobación pendiente de una tarea programada que corre en background (sin yes|no la pregunta con el menú ↑↓)"],
     ["/out", "[n]", "resultado completo de la última tool del turno (n = contar hacia atrás: /out 2 es la anteúltima)"],
     ["/verbose", "", "alternar: mostrar SIEMPRE el output completo de cada tool (queda guardado en config.json)"],
     ["/trace", "[n]", "traza legible de esta sesión (pasos, tools, tiempos, tokens, errores): .lampson/trace/<sesión>.log"],
@@ -601,23 +601,37 @@ task skills_list()
 -- lampson/.lampson/config.json (local, gitignored) y vale para terminal y web. Sin TTY no pregunta.
 task setup_wizard()
     print("")
-    print("  " + cyan("Configuremos el modelo.") + " Elegí un proveedor (número o nombre):")
     let list be provider.providers()
-    each e in enumerate(list)
-        let p be e["item"]
-        print("  " + pad(text(e["index"] + 1) + ".", 4) + pad(p["name"], 12) + dim(p["model"]) + (when p["name"] == "ollama" then dim("  (local, sin key)") otherwise (when p["has_key"] then green("  ● key guardada") otherwise "")))
-    let choice be read_line("  proveedor: ")
-    when choice == nothing or trim(choice) == ""
+    -- menú ↑↓/Enter (o inicial / número) cuando hay TTY; sin TTY, la lista numerada + read_line de siempre.
+    -- Las etiquetas van en texto plano: las pinta el menú (ver lib/line.syn).
+    let labels be []
+    each p in list
+        set labels to append(labels, pad(p["name"], 12) + pad(p["model"], 26) + (when p["name"] == "ollama" then "(local, sin key)" otherwise (when p["has_key"] then "● key guardada" otherwise "")))
+    flush()
+    let pick be ed.choose("  " + cyan("Configuremos el modelo.") + " Elegí un proveedor:", labels, COLOR)
+    let name be ""
+    when pick == nothing
         print("  (sin cambios)")
         give false
-    let name be lower(trim(choice))
-    when matches(name, "[0-9]+")
-        let i be floor(number(name)) - 1
-        when i >= 0 and i < length(list)
-            set name to list[i]["name"]
-    when not contains(provider.PRESETS, name)
-        print("  " + red("no conozco el proveedor " + name))
-        give false
+    otherwise when pick == -1
+        print("  " + cyan("Configuremos el modelo.") + " Elegí un proveedor (número o nombre):")
+        each e in enumerate(list)
+            let p be e["item"]
+            print("  " + pad(text(e["index"] + 1) + ".", 4) + pad(p["name"], 12) + dim(p["model"]) + (when p["name"] == "ollama" then dim("  (local, sin key)") otherwise (when p["has_key"] then green("  ● key guardada") otherwise "")))
+        let choice be read_line("  proveedor: ")
+        when choice == nothing or trim(choice) == ""
+            print("  (sin cambios)")
+            give false
+        set name to lower(trim(choice))
+        when matches(name, "[0-9]+")
+            let i be floor(number(name)) - 1
+            when i >= 0 and i < length(list)
+                set name to list[i]["name"]
+        when not contains(provider.PRESETS, name)
+            print("  " + red("no conozco el proveedor " + name))
+            give false
+    otherwise
+        set name to list[pick]["name"]
     let preset be provider.PRESETS[name]
     let model be read_line("  modelo [" + preset["model"] + "]: ")
     set model to when model == nothing then "" otherwise trim(model)
@@ -955,9 +969,16 @@ while running
                 when length(pending_images) == 0
                     print("  sin imágenes pendientes · uso: /image <ruta>  o  /paste")
                 otherwise
-                    print("  " + text(length(pending_images)) + " imagen(es) pendiente(s) — se mandan con tu próximo mensaje. ¿Quitarlas? (s/N)")
-                    let a be read_line("  ")
-                    when a != nothing and lower(trim(a)) == "s"
+                    print("  " + text(length(pending_images)) + " imagen(es) pendiente(s) — se mandan con tu próximo mensaje.")
+                    flush()
+                    let ipick be ed.choose("  ¿qué hago con ellas?", ["dejarlas", "quitarlas"], COLOR)
+                    when ipick == -1
+                        print("  ¿Quitarlas? (s/N)")
+                        let a be read_line("  ")
+                        when a != nothing and lower(trim(a)) == "s"
+                            set pending_images to []
+                            print("  quitadas")
+                    otherwise when ipick == 1
                         set pending_images to []
                         print("  quitadas")
             otherwise
@@ -969,7 +990,12 @@ while running
             otherwise when id == sid
                 print("  esa es la sesión actual; hacé /new primero")
             otherwise
-                print("  " + session.delete(id))
+                flush()
+                let dpick be ed.choose("  ¿borrar la sesión " + id + "?", ["cancelar", "borrar"], COLOR)
+                when dpick == 1 or dpick == -1   -- sin TTY el comando ya es explícito: borra
+                    print("  " + session.delete(id))
+                otherwise
+                    print("  (no se borró)")
         otherwise when input == "/new"
             set sid to session.new_id()
             set messages to [system_msg]
@@ -1126,14 +1152,29 @@ while running
                     print("      " + dim("permisos " + s["permission"] + " · próxima " + s["next_local"] + (when s["last_run"] != nothing then " · última " + s["last_status"] + ": " + first_line(s["last_summary"], 80) otherwise "")))
                 let pend be approvals.pending()
                 each ap in pend
-                    print("  " + yellow("⚠ aprobación pendiente " + ap["id"] + ": " + first_line(ap["message"], 100)) + dim("  → /approve " + ap["id"] + " yes|no"))
+                    print("  " + yellow("⚠ aprobación pendiente " + ap["id"] + ": " + first_line(ap["message"], 100)) + dim("  → /approve " + ap["id"]))
                 print("  " + dim("corren solas mientras lampson esté abierto (tick cada " + text(schedule.TICK_SECONDS) + " s) · con todo cerrado: lampson --daemon start · run/on/off/remove/log <id>"))
         otherwise when starts_with(input, "/approve ")
             let atoks be where(split(trim(slice(input, 9, length(input))), " "), (x) => x != "")
-            when length(atoks) < 2 or not contains(["yes", "no", "si", "sí", "y", "n"], lower(atoks[1]))
+            let yes be false
+            let answered be false
+            when length(atoks) == 1
+                -- «/approve <id>» a secas: menú ↑↓ (sin TTY, el uso de siempre)
+                flush()
+                let apick be ed.choose("  aprobación " + atoks[0], ["permitir", "denegar"], COLOR)
+                when apick == -1
+                    print("  uso: /approve <id> yes|no   (pendientes: /schedule)")
+                otherwise when apick == nothing
+                    print("  (sin responder)")
+                otherwise
+                    set yes to apick == 0
+                    set answered to true
+            otherwise when length(atoks) < 2 or not contains(["yes", "no", "si", "sí", "y", "n"], lower(atoks[1]))
                 print("  uso: /approve <id> yes|no   (pendientes: /schedule)")
             otherwise
-                let yes be contains(["yes", "si", "sí", "y"], lower(atoks[1]))
+                set yes to contains(["yes", "si", "sí", "y"], lower(atoks[1]))
+                set answered to true
+            when answered
                 when approvals.answer(atoks[0], yes)
                     print("  " + (when yes then green("✓ permitido ") otherwise red("✗ denegado ")) + atoks[0])
                 otherwise

package/lib/line.syn

@@ -320,7 +320,10 @@ export task read(prompt, color, ctx)
     term_close(h)
     give result
 
--- menú vertical de opciones (aprobaciones): ↑↓ + Enter, o la letra inicial / número; Esc = nothing
+-- menú vertical de opciones (aprobaciones, /setup, confirmaciones): ↑↓ + Enter, o la letra inicial /
+-- número; Esc = nothing. La activa lleva ❯ y color; debajo, la línea de ayuda. Las opciones llegan en
+-- TEXTO PLANO (sin ANSI): el menú es el que pinta, y un reset de color adentro le cortaría la línea.
+let CHOOSE_HELP be "Enter confirma · Esc cancela"
 export task choose(question, options, color)
     let h be term_open({"ctrl_c": "exit"})
     when h == nothing
@@ -329,6 +332,11 @@ export task choose(question, options, color)
     let done be false
     let result be nothing
     let drawn be 0
+    -- Reservar el alto del bloque ANTES de dibujarlo: al pie de la pantalla esto scrollea una sola vez y
+    -- deja el menú entero a la vista. Sin esto, el ESC[nA del redibujo apunta a una línea que el scroll
+    -- movió y el menú aparece duplicado más abajo en cada tecla (visto con los 9 proveedores de /setup).
+    let need be length(options) + 2
+    term_write(h, rep("\n", need) + ESC + "[" + text(need) + "A")
     while not done
         let out be ""
         when drawn > 0
@@ -336,10 +344,11 @@ export task choose(question, options, color)
         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 out to out + "\r\n" + (when i == sel then "  " + sgr(color, "1;36", "❯ " + o) otherwise "    " + sgr(color, "2", o))
             set i to i + 1
+        set out to out + "\r\n\r\n  " + sgr(color, "2", CHOOSE_HELP)
         term_write(h, out)
-        set drawn to length(options)
+        set drawn to length(options) + 2   -- una línea por opción + la vacía + la de ayuda
         let ev be term_recv(h, 600)
         when ev == nothing
             set result to nothing
@@ -361,9 +370,11 @@ export task choose(question, options, color)
                 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
+                    -- la PRIMERA que coincide gana: con 9 proveedores hay iniciales repetidas (o, g…)
+                    when not done
+                        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)

package/lib/term.syn

@@ -0,0 +1,162 @@
+-- lib/term.syn — terminales del navegador que SOBREVIVEN a un F5.
+--
+-- DISEÑO (mismo patrón que lib/tools/proc.syn): un proc_spawn hecho dentro de un handler muere cuando
+-- termina el request — y un socket es un request. Por eso el pty vive dentro de un AGENTE supervisor
+-- (lo único con ciclo de vida propio bajo `serve`) y el socket es sólo un PUENTE por el bus:
+--
+--   navegador → socket → bus "term.ctl.<id>"  → agente → proc_send / proc_resize / kill / replay
+--   agente    → bus "term.out.<id>" → socket → navegador   ("o" salida · "exit" código · "replay")
+--
+-- Cerrar la pestaña del navegador ya no mata la shell: el socket se va, el agente sigue. Al volver, la UI
+-- pide GET /api/terms, ve las que están vivas y se reengancha con ?id=<id>; el agente le reenvía los
+-- últimos chunks del pty (replay en memoria) para que la pantalla no aparezca en blanco.
+--
+-- Recolección: cada socket enganchado manda un ping; sin NINGÚN socket por IDLE_CLOSE segundos, el
+-- supervisor cierra la shell. Y todo muere con el proceso lampson, como siempre (sin huérfanos).
+--
+-- OJO (miga del runtime): un agente NO ve las constantes ni las tasks del módulo, sólo sus parámetros y
+-- las builtins — por eso KEEP_CHUNKS / IDLE_CLOSE viajan en el `spawn`.
+
+export let MAX_TERMS be 4
+let KEEP_CHUNKS be 240          -- replay: últimos N chunks del pty (bastante más que una pantalla)
+let IDLE_CLOSE be 1800          -- 30 min sin ningún socket enganchado → se recoge la shell
+let IDS_KEY be "term:ids"
+
+-- shell del terminal web: [cmd, args]. Windows: pwsh si está, si no PowerShell 5; unix: bash de login.
+-- En pwsh, los directorios de `ls` salen sin fondo azul (el default de $PSStyle se lee mal en oscuro).
+export task shell()
+    require exec
+    require env("OS")
+    when env("OS", "") == "Windows_NT"
+        try
+            run("pwsh", ["-NoLogo", "-Command", "exit"], 10)
+            give ["pwsh", ["-NoLogo", "-NoExit", "-Command", "$PSStyle.FileInfo.Directory = $PSStyle.Foreground.BrightBlue"]]
+        recover err
+            give ["powershell", ["-NoLogo"]]
+    give ["bash", ["-l"]]
+
+-- cwd del terminal: la ruta REAL del proyecto (LAMPSON_WORKSPACE), no la junction ./workspace —
+-- así el prompt muestra dónde estás de verdad y coincide con el header.
+export task cwd()
+    require env("LAMPSON_*")
+    give env("LAMPSON_WORKSPACE", "workspace")
+
+-- ---------- supervisor: un agente por terminal ----------
+agent TermSup
+    require exec
+    require time
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    let key be "term:" + id
+    let p be nothing
+    try
+        set p to proc_spawn(sh, args, {"cwd": dir, "pty": true, "cols": cols, "rows": rows})
+    recover err
+        share {"status": "exited", "pid": 0, "shell": sh, "cwd": dir, "started": nothing, "error": text(err)} as key
+    when p != nothing
+        share {"status": "running", "pid": proc_stats(p)["pid"], "shell": sh, "cwd": dir, "started": now(), "error": ""} as key
+        let sub be bus_subscribe("term.ctl." + id)
+        let chunks be []
+        let seen be now()
+        let open be true
+        while open
+            let ev be select({"p": p, "c": sub}, 20)
+            when ev == nothing
+                when proc_status(p) != "running"
+                    set open to false
+                otherwise when now() - seen > idle
+                    proc_close(p)
+                    set open to false
+            otherwise when ev["name"] == "c"
+                let m be ev["data"]
+                set seen to now()
+                when m["k"] == "in"
+                    proc_send(p, m["d"])
+                otherwise when m["k"] == "resize"
+                    proc_resize(p, floor(m["cols"]), floor(m["rows"]))
+                otherwise when m["k"] == "replay"
+                    -- sólo para el socket que lo pidió (`to`): con dos pestañas abiertas, la otra no repite
+                    bus_publish("term.out." + id, {"k": "replay", "to": m["to"], "d": join(chunks, "")})
+                otherwise when m["k"] == "kill"
+                    proc_close(p)
+                    set open to false
+            otherwise when ev["type"] == "exit"
+                bus_publish("term.out." + id, {"k": "exit", "to": "", "code": ev["data"]["exit_code"]})
+                set open to false
+            otherwise
+                let d be when is_bytes(ev["data"]) then decode(ev["data"], "utf8_lossy") otherwise ev["data"]
+                set chunks to append(chunks, d)
+                when length(chunks) > keep
+                    set chunks to slice(chunks, length(chunks) - keep, length(chunks))
+                bus_publish("term.out." + id, {"k": "o", "to": "", "d": d})
+        proc_close(p)
+        bus_unsubscribe(sub)
+        share {"status": "exited", "pid": 0, "shell": sh, "cwd": dir, "started": nothing, "error": ""} as key
+
+-- ---------- estado (blackboard) ----------
+
+export task state(id)
+    observe "term:" + id as st
+    give st
+
+export task alive(id)
+    let st be state(id)
+    when st == nothing
+        give false
+    give st["status"] == "running"
+
+task ids()
+    observe IDS_KEY as v
+    when v == nothing
+        give []
+    give v
+
+-- las terminales vivas, para que la UI reconstruya sus pestañas después de un F5
+export task list()
+    let out be []
+    each id in ids()
+        let st be state(id)
+        when st != nothing and st["status"] == "running"
+            set out to append(out, {"id": id, "pid": st["pid"], "shell": st["shell"], "cwd": st["cwd"], "started": st["started"]})
+    give out
+
+export task count()
+    give length(list())
+
+task new_id()
+    require time
+    require random
+    give "t" + text(floor(now() * 1000)) + "-" + text(floor(random() * 10000))
+
+-- arranca una terminal nueva y devuelve su id (nothing si ya se llegó al máximo)
+export task start(cols, rows)
+    require exec
+    require time
+    require random
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    when count() >= MAX_TERMS
+        give nothing
+    let sh be shell()
+    let dir be cwd()
+    let id be new_id()
+    -- "starting" ANTES del spawn: la clave puede tener el estado viejo de un id anterior y list() miente
+    share {"status": "starting", "pid": 0, "shell": sh[0], "cwd": dir, "started": now(), "error": ""} as "term:" + id
+    share append(ids(), id) as IDS_KEY
+    spawn TermSup with id = id, sh = sh[0], args = sh[1], dir = dir, cols = cols, rows = rows, keep = KEEP_CHUNKS, idle = IDLE_CLOSE
+    let waited be 0
+    while waited < 30 and state(id)["status"] == "starting"
+        sleep(0.1)
+        set waited to waited + 1
+    give id
+
+-- entrada del navegador hacia la shell (el socket es sólo el cartero)
+export task ctl(id, msg)
+    give bus_publish("term.ctl." + id, msg)
+
+export task kill(id)
+    give bus_publish("term.ctl." + id, {"k": "kill"})

package/lib/workspaces.syn

@@ -24,7 +24,8 @@ export let REGISTRY be ".lampson/workspaces.json"
 export let HUB_PORT be 8080
 export let HUB_FILE be "hub.syn"
 export let HUB_TEMPLATE be "hub.tpl.syn"
-let FIRST_PORT be 8081
+-- rango alto para no chocar con lo que usan las apps (3000, 5173, 8000, 8080-8090…): solo el hub queda en 8080
+let FIRST_PORT be 47101
 let LINKS be ["lib", "public", "skills", "lamps", "memory"]
 let COPIES be ["web.syn", "chat.syn"]
 
@@ -82,6 +83,38 @@ task load_reg()
 task save_reg(doc)
     write_file(REGISTRY, json_encode(doc))
 
+-- registros hechos con puertos 808N (antes de 0.2.3): reasignar al rango alto; los procesos viejos se paran en
+-- ensure/tick (por puerto) y el supervisor los levanta en el nuevo
+export task migrate_ports()
+    require exec
+    require time
+    require env("LAMPSON_*")
+    require env("OS")
+    require file(".lampson")
+    require file(".lampson/*")
+    require file.read("hub.tpl.syn")
+    require file("hub.syn")
+    let doc be load_reg()
+    let changed be false
+    when doc["next_port"] < FIRST_PORT
+        set doc["next_port"] to FIRST_PORT
+        set changed to true
+    each k in keys(doc["workspaces"])
+        let w be doc["workspaces"][k]
+        when w["port"] < FIRST_PORT
+            let old be w["port"]
+            each l in proc.listeners()
+                when l["port"] == old
+                    proc.kill_pid(l["pid"])
+            set w["port"] to doc["next_port"]
+            set doc["next_port"] to doc["next_port"] + 1
+            set doc["workspaces"][k] to w
+            set changed to true
+    when changed
+        save_reg(doc)
+        regen_hub()
+    give changed
+
 export task all()
     require file(".lampson")
     require file(".lampson/*")
@@ -241,6 +274,7 @@ export task ensure(path)
     require file.read("chat.syn")
     require file.read("hub.tpl.syn")
     require file("hub.syn")
+    migrate_ports()
     let existing be by_path(path)
     let w be existing
     when w == nothing
@@ -490,6 +524,8 @@ export task tick()
     require file(".lampson/*")
     require file.read("web.syn")
     require file.read("chat.syn")
+    when migrate_ports() and hub_alive()
+        restart_hub_later()
     let started be []
     let stopped be []
     each w in all()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lampson",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "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/css/layout.css

@@ -14,6 +14,9 @@ header { grid-area:top; border-bottom:1px solid var(--rule); background:var(--pa
 .hbtn:hover { color:var(--ink); border-color:var(--ink-3); }
 .hbtn.upd { color:var(--amber); border-color:var(--amber); }
 .hbtn.upd:hover { color:var(--ink); border-color:var(--ink); }
+/* terminal minimizada: la shell sigue viva y el botón la trae de vuelta */
+.hbtn.live { color:var(--str); border-color:var(--str); }
+.hbtn.live:hover { color:var(--ink); border-color:var(--ink); }
 .theme-toggle { display:flex; align-items:center; justify-content:center; background:none; border:0; color:var(--ink-3); cursor:pointer; padding:6px; border-radius:var(--r); line-height:0; }
 .theme-toggle:hover { color:var(--ink); background:var(--paper-2); }
 header select { font:400 11.5px/1 var(--mono); color:var(--ink-2); background:var(--paper); border:1px solid var(--rule); border-radius:var(--r); padding:5px 6px; cursor:pointer; }
@@ -54,14 +57,41 @@ main { grid-area:main; display:grid; grid-template-rows:1fr auto; min-height:0;
 #viewer pre { margin:0; padding:14px 18px; font:400 12.5px/1.62 var(--mono); tab-size:4; }
 #viewer pre .ln { display:inline-block; width:4ch; margin-right:16px; color:var(--ink-3); text-align:right; user-select:none; }
 #viewer pre.log { color:var(--ink-2); white-space:pre-wrap; }
-/* terminal real (xterm.js sobre un pty del servidor) — ocupa la zona central como un archivo abierto */
-#termpane { display:none; height:100%; flex-direction:column; }
-#termpane .vh { position:static; }
+/* terminal real (xterm.js sobre un pty del servidor) — ocupa la zona central como un archivo abierto.
+   Varias terminales conviven como pestañas: una instancia de xterm por .xt, sólo la activa a la vista. */
+#termpane { display:none; height:100%; flex-direction:column; overflow:hidden; }
+#termpane .vh { position:static; flex:none; }
 #termpane .vh .st { width:7px; height:7px; border-radius:50%; background:var(--ink-3); }
 #termpane.live .vh .st { background:var(--str); }
-#xterm { flex:1; min-height:0; padding:10px 14px; background:var(--paper); }
-#xterm .xterm { height:100%; }
-#xterm .xterm-viewport { background:transparent !important; }
+/* cabecera del panel en UNA línea: pestañas y botones no se encogen y la meta se recorta */
+#termpane .vh b, #termpane .vh .ttabs, #termpane .vh .hbtn, #termpane .vh .wbtn { flex:none; white-space:nowrap; }
+#termpane .vh #tmeta { min-width:0; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+/* pestañas: en cuál estás se ve de lejos (la activa lleva el acento del tema, clara y oscura) */
+.vh .ttabs { display:flex; align-items:center; gap:5px; }
+.vh .ttab { cursor:pointer; min-width:20px; text-align:center; padding:2px 7px; border-radius:2px; border:1px solid var(--rule-2); color:var(--ink-3); background:transparent; }
+.vh .ttab:hover { color:var(--ink); border-color:var(--ink-3); }
+.vh .ttab.on { color:var(--accent); border-color:var(--accent); background:var(--accent-bg); font-weight:600; }
+.vh .ttab.dead { text-decoration:line-through; opacity:.75; }
+/* «+ nueva terminal»: mismo botón que los del encabezado, en el acento para que se vea */
+.vh .hbtn.sm { padding:4px 9px; font-size:9.5px; letter-spacing:.08em; }
+.vh .hbtn.new { color:var(--accent); border-color:var(--accent); }
+.vh .hbtn.new:hover { background:var(--accent-bg); color:var(--accent); border-color:var(--accent); }
+.vh .hbtn.new:disabled { color:var(--ink-3); border-color:var(--rule-2); background:transparent; }
+/* minimizar · pantalla completa · cerrar, a la derecha como en cualquier ventana */
+.vh .wbtn { cursor:pointer; width:22px; height:20px; display:inline-flex; align-items:center; justify-content:center; border-radius:2px; color:var(--ink-3); font-size:12px; line-height:1; }
+.vh .wbtn:hover { color:var(--ink); background:var(--paper); }
+.vh .wbtn.cl:hover { color:var(--rubric); }
+/* El aire alrededor de cada terminal va como MARGEN, nunca como padding: el FitAddon mide el alto/ancho
+   del contenedor con getComputedStyle (que con box-sizing:border-box incluye su padding) y sólo
+   descuenta el padding del .xterm, que es 0. Con padding calculaba una fila de más, el .xterm-screen
+   desbordaba el hueco, el #stage sacaba su barra de scroll, eso robaba 7px de ancho, el
+   ResizeObserver volvía a ajustar y cada rebote hacía clear()+resize() del terminal y un resize del
+   pty: el parpadeo. Con margen el fit mide exactamente el hueco; overflow:hidden es el cinturón. */
+#termpane.max { position:fixed; inset:0; z-index:60; height:auto; background:var(--paper); }
+#xterms { flex:1; min-height:0; display:flex; }
+#xterms .xt { flex:1; min-height:0; margin:10px 14px; background:var(--paper); overflow:hidden; }
+#xterms .xt .xterm { height:100%; }
+#xterms .xt .xterm-viewport { background:transparent !important; }
 
 /* ---- composer ---- */
 form { padding:12px 40px 12px; border-top:1px solid var(--rule); background:var(--paper); box-sizing:border-box; width:100%; max-width:100%; min-width:0; }

package/public/css/sidebar.css

@@ -78,3 +78,7 @@
 .del.ask .yes { color:var(--rubric); cursor:pointer; font-weight:600; }
 .del.ask .no { color:var(--ink-2); cursor:pointer; }
 .del.ask .yes:hover, .del.ask .no:hover { text-decoration:underline; text-underline-offset:.18em; }
+
+/* puertos ocupados por lampson: visibles pero sin link ni ✕ */
+.p .port.own { color:var(--ink-3); font-weight:400; }
+.p.own .cm { color:var(--ink-3); }

package/public/index.html

@@ -21,7 +21,7 @@
     <span class="brand">lampson<span class="proj" id="proj">…</span></span>
     <span class="spacer"></span>
     <button class="hbtn upd" id="update" style="display:none"></button>
-    <button class="hbtn" id="term" title="abrir un terminal real (shell en el workspace)">&gt;_ terminal</button>
+    <button class="hbtn" id="term" title="terminal real (shell en el workspace): lo abre, lo trae de vuelta si está minimizado y lo esconde si está a la vista — verde = shell abierta">&gt;_ terminal</button>
     <button class="hbtn" id="new" title="empezar una conversación nueva">+ sesión</button>
     <button class="theme-toggle" id="cfgBtn" type="button" title="configuración: zona horaria, aprobaciones a distancia, proveedor"><svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.7 1.7 0 0 0 .3 1.8l.1.1a2 2 0 1 1-2.8 2.8l-.1-.1a1.7 1.7 0 0 0-1.8-.3 1.7 1.7 0 0 0-1 1.5V21a2 2 0 1 1-4 0v-.1a1.7 1.7 0 0 0-1.1-1.5 1.7 1.7 0 0 0-1.8.3l-.1.1a2 2 0 1 1-2.8-2.8l.1-.1a1.7 1.7 0 0 0 .3-1.8 1.7 1.7 0 0 0-1.5-1H3a2 2 0 1 1 0-4h.1a1.7 1.7 0 0 0 1.5-1.1 1.7 1.7 0 0 0-.3-1.8l-.1-.1a2 2 0 1 1 2.8-2.8l.1.1a1.7 1.7 0 0 0 1.8.3h.1a1.7 1.7 0 0 0 1-1.5V3a2 2 0 1 1 4 0v.1a1.7 1.7 0 0 0 1 1.5 1.7 1.7 0 0 0 1.8-.3l.1-.1a2 2 0 1 1 2.8 2.8l-.1.1a1.7 1.7 0 0 0-.3 1.8v.1a1.7 1.7 0 0 0 1.5 1H21a2 2 0 1 1 0 4h-.1a1.7 1.7 0 0 0-1.5 1z"/></svg></button>
     <button class="theme-toggle" id="theme" type="button" title="cambiar tema"></button>
@@ -92,7 +92,7 @@
   <div id="stage">
     <div id="viewer"><div class="vh"><b id="vpath"></b><span id="vmeta"></span><span class="spacer"></span><span class="x" id="vclose">✕ cerrar</span></div><pre id="vbody"></pre></div>
     <div id="log"></div>
-    <div id="termpane"><div class="vh"><span class="st"></span><b>terminal</b><span id="tmeta"></span><span class="spacer"></span><span class="x" id="tclose">✕ cerrar</span></div><div id="xterm"></div></div>
+    <div id="termpane"><div class="vh"><span class="st"></span><b>terminal</b><span class="ttabs" id="ttabs"></span><button class="hbtn sm new" id="tnew" title="abrir otra terminal: una shell nueva en el workspace">+ nueva terminal</button><span id="tmeta"></span><span class="spacer"></span><span class="wbtn" id="tmin" title="minimizar: esconde el panel y la shell sigue viva">&#8212;</span><span class="wbtn" id="tmax" title="pantalla completa">&#9633;</span><span class="wbtn cl" id="tclose" title="cerrar esta terminal y matar su shell">&#10005;</span></div><div id="xterms"></div></div>
   </div>
   <div>
     <form id="f">

package/public/js/app.js

@@ -14,7 +14,7 @@ async function loadCfg() {
   sel.onchange = () => { localStorage.setItem('lampson.agent', sel.value); hint(); }; hint();
   if (!log.children.length) empty();
 }
-loadCfg().then(() => { loadTree(); loadSessions(); loadProcs(); loadMemory(); loadAgents(); loadMcp(); loadLsp(); loadLamps(); loadTodo(); loadSched(); loadApprovals(); checkUpdate(); const pq = new URLSearchParams(location.search).get('proc'); if (pq) openProc(pq); else if (session) open(session); });
+loadCfg().then(() => { loadTree(); loadSessions(); loadProcs(); loadMemory(); loadAgents(); loadMcp(); loadLsp(); loadLamps(); loadTodo(); loadSched(); loadApprovals(); checkUpdate(); const pq = new URLSearchParams(location.search).get('proc'); if (pq) openProc(pq); else if (session) openSession(session); });
 // respaldos lentos por si el stream de eventos se cae
 setInterval(loadProcs, events ? 60000 : 10000);
 setInterval(() => { loadSched(); if (!events) loadApprovals(); }, events ? 60000 : 15000);

package/public/js/procs.js

@@ -3,13 +3,16 @@ let procOpen = null, procTimer = null;
 async function loadPorts() {
   let r; try { r = await (await fetch(BASE + '/api/ports')).json(); } catch (e) { return; }
   const box = $('#ports'); box.innerHTML = '';
-  // los procesos de lampson (hub :8080 y los workspaces :808N) no son «servidores del proyecto»
-  const list = (r.ports || []).filter(p => !(p.name === 'synsema.exe' || p.name === 'synsema') || !/\b(web|hub)\.syn\b/.test(p.command || '') && p.port !== 8080);
+  // los procesos de lampson (hub :8080, un workspace por puerto alto) OCUPAN el puerto: se ven, identificados,
+  // sin link (la UI se usa por el hub) y sin ✕ (un workspace se apaga desde su Panel; matarlo lo relanza el supervisor)
+  let wsByPort = {}; try { const ws = (await (await fetch('/api/workspaces')).json()).workspaces || []; for (const w of ws) wsByPort[w.port] = w; } catch (e) {}
+  const list = (r.ports || []).map(p => { const own = /\b(web|hub)\.syn\b/.test(p.command || '') || (p.port === 8080 && /synsema/.test(p.name || '')); return Object.assign({}, p, { lampson: own, wsName: own && wsByPort[p.port] ? wsByPort[p.port].name : (own && p.port === 8080 ? 'hub' : '') }); });
   $('#portCount').textContent = list.length || ''; autoSec('ports', list.length > 0);
   if (!list.length) { box.innerHTML = '<div class="p none">ninguno</div>'; return; }
   for (const p of list) {
-    const d = document.createElement('div'); d.className = 'p'; d.style.cursor = 'default'; d.title = `pid ${p.pid}\n${p.command || '(línea de comando no disponible)'}`;
+    const d = document.createElement('div'); d.className = 'p' + (p.lampson ? ' own' : ''); d.style.cursor = 'default'; d.title = `pid ${p.pid}\n${p.command || '(línea de comando no disponible)'}`;
     const what = p.command ? p.command.replace(/^"?[A-Za-z]:\\[^"]*\\([^"\\]+)"?/, '$1') : p.name;
+    if (p.lampson) { d.innerHTML = `<span class="port own" title="puerto ocupado por lampson">:${p.port}</span><span class="cm">lampson · ${esc(p.wsName ? (p.port === 8080 ? 'hub' : 'workspace ' + p.wsName) : 'proceso')}</span>`; box.appendChild(d); continue; }
     d.innerHTML = `<a class="port" href="http://127.0.0.1:${p.port}" target="_blank" rel="noopener" title="abrir http://127.0.0.1:${p.port} en otra pestaña">:${p.port}</a><span class="cm">${esc(what)}</span><button title="matar este proceso (pid ${p.pid}; no lo gestiona lampson)">✕</button>`;
     const kb = d.querySelector('button'); kb.onclick = () => { const holder = document.createElement('span'); holder.className = 'del'; kb.replaceWith(holder); inlineConfirm(holder, `¿matar pid ${p.pid}?`, async () => { await api(BASE + '/api/ports/kill', { pid: p.pid }); loadPorts(); }); setTimeout(() => { if (!holder.classList.contains('ask')) loadPorts(); }, 6100); };
     box.appendChild(d);

package/public/js/schedules.js

@@ -68,7 +68,7 @@ function openSched(selectId) {
         if (t === SCHED_NEW) { schedFormWire(box, err); return; }
         box.querySelector('[data-run]').onclick = async () => { const r = await api(BASE + '/api/schedules/run', { id: t.id }); add('meta', '⏰ ' + esc(r.data.result || r.data.error || '')); setTimeout(loadSched, 1500); setTimeout(() => Panel.is('schedules') && Panel.detail(), 2500); };
         box.querySelector('[data-toggle]').onclick = async () => { const r = await api(BASE + '/api/schedules/toggle', { id: t.id, enabled: !t.enabled }); if (!r.ok) { err(r.data.error || 'error'); return; } loadSched(); };
-        box.querySelectorAll('[data-session]').forEach(a => a.onclick = (e) => { e.preventDefault(); Panel.close(); open(a.dataset.session); });
+        box.querySelectorAll('[data-session]').forEach(a => a.onclick = (e) => { e.preventDefault(); Panel.close(); openSession(a.dataset.session); });
         const del = box.querySelector('.dfoot .del');
         del.onclick = () => inlineConfirm(del, `¿quitar ${t.name}?`, async () => { await api(BASE + '/api/schedules/remove', { id: t.id }); loadSched(); });
         const live = box.querySelector('[data-live]'); if (live) live.scrollTop = live.scrollHeight;

package/public/js/sessions.js

@@ -9,7 +9,7 @@ async function loadSessions() {
   if (!r.sessions.length) { box.innerHTML = '<div class="s none">todavía ninguna</div>'; return; }
   const shown = r.sessions.slice(0, 4);
   for (const s of shown) {
-    const d = document.createElement('div'); d.className = 's' + (s.id === session ? ' active' : ''); d.innerHTML = '<span class="id">' + esc(s.id.slice(-6)) + '</span><span class="title">' + esc(s.title || '') + '</span><span class="del tr" title="traza: qué hizo el agente en esta sesión (pasos, tools, tiempos, tokens)">≡</span><span class="del" title="borrar esta sesión">✕</span>'; d.title = s.id; d.onclick = () => open(s.id);
+    const d = document.createElement('div'); d.className = 's' + (s.id === session ? ' active' : ''); d.innerHTML = '<span class="id">' + esc(s.id.slice(-6)) + '</span><span class="title">' + esc(s.title || '') + '</span><span class="del tr" title="traza: qué hizo el agente en esta sesión (pasos, tools, tiempos, tokens)">≡</span><span class="del" title="borrar esta sesión">✕</span>'; d.title = s.id; d.onclick = () => openSession(s.id);
     d.querySelector('.tr').onclick = (ev) => { ev.stopPropagation(); openTrace(s.id); };
     d.querySelector('.del:not(.tr)').onclick = (ev) => { ev.stopPropagation(); inlineConfirm(d.querySelector('.del:not(.tr)'), '¿borrar?', () => deleteSession(s.id)); };
     box.appendChild(d);
@@ -35,18 +35,18 @@ function openSessionsPanel() {
           + `<div class="dfoot"><span>.lampson/sessions/${esc(s.id)}.json</span><span class="del">borrar</span></div>`;
       },
       wire: (s, box) => {
-        box.querySelector('[data-act="open"]').onclick = () => { Panel.close(); open(s.id); };
+        box.querySelector('[data-act="open"]').onclick = () => { Panel.close(); openSession(s.id); };
         box.querySelector('[data-act="trace"]').onclick = () => { Panel.close(); openTrace(s.id); };
         const del = box.querySelector('.dfoot .del');
         del.onclick = () => inlineConfirm(del, `¿borrar ${s.id}?`, async () => { await deleteSession(s.id); Panel.refresh(); });
       },
-      onPick: (s) => open(s.id),
+      onPick: (s) => openSession(s.id),
       count: (rows, q) => q ? `${rows.length} coincidencia${rows.length === 1 ? '' : 's'}` : `${rows.length} sesión${rows.length === 1 ? '' : 'es'}`,
       emptyHtml: 'todavía no hay sesiones'
     }
   });
 }
-async function open(id) {
+async function openSession(id) {
   session = id; localStorage.setItem('lampson.session', id); log.innerHTML = ''; log.classList.remove('hero'); showPane('log'); loadTodo();
   const r = await fetch(BASE + '/api/sessions/' + id); if (!r.ok) { session = ''; empty(); return loadSessions(); }
   const d = await r.json();

package/public/js/terminal.js

@@ -1,6 +1,20 @@
-// terminal.js — terminal real: xterm.js ↔ WebSocket /api/term ↔ pty en el servidor
-// Frames binarios = bytes del pty; texto JSON = control (hello / exit). Cerrar el panel cierra el socket y mata el shell.
-let term = null, termWs = null, termFit = null;
+// terminal.js — terminales reales: xterm.js ↔ WebSocket /api/term ↔ un pty por terminal en el servidor.
+// Frames de texto: "o" + salida del pty · "c" + JSON de control (hello / exit). Conviven varias como
+// pestañas (cada una con su shell); minimizar esconde el panel con todas vivas y el botón del encabezado
+// lo trae de vuelta; ✕ mata la shell de la activa (la última cierra el panel).
+// La shell NO vive en el socket sino en un agente del servidor (lib/term.syn): recargar la página no la
+// mata — al cargar pedimos /api/terms y nos reenganchamos por id, con replay de lo último que imprimió.
+const MAX_TERMS = 4;
+let terms = [];        // [{id, el, term, ws, fit, ro, box, meta, live}]
+let termAt = -1;       // índice de la activa en terms
+// qué estaba abierto antes del F5 (el panel y la pestaña activa; las shells las sabe el servidor)
+function saveTermUi() {
+  try {
+    localStorage.setItem('lampson.term.open', termShown() ? '1' : '0');
+    localStorage.setItem('lampson.term.at', String(termAt));
+    localStorage.setItem('lampson.term.max', $('#termpane').classList.contains('max') ? '1' : '0');
+  } catch (e) {}
+}
 function termTheme() {
   const s = getComputedStyle(document.documentElement); const v = n => s.getPropertyValue(n).trim();
   return { background: v('--paper'), foreground: v('--ink'), cursor: v('--accent'), cursorAccent: v('--paper'), selectionBackground: v('--sel'),
@@ -8,11 +22,56 @@ function termTheme() {
     yellow: v('--amber'), brightYellow: v('--amber'), blue: v('--term-blue'), brightBlue: v('--accent'), magenta: v('--rubric'), brightMagenta: v('--rubric'),
     cyan: v('--accent'), brightCyan: v('--accent'), white: v('--ink-2'), brightWhite: v('--ink') };
 }
-function openTerm() {
-  if (term) { showPane('term'); termFit.fit(); term.focus(); return; }
-  showPane('term'); procOpen = null; clearInterval(procTimer);
-  term = new Terminal({ cursorBlink: true, fontFamily: getComputedStyle(document.documentElement).getPropertyValue('--mono'), fontSize: 13, lineHeight: 1.25, theme: termTheme(), scrollback: 5000, allowProposedApi: true });
-  termFit = new FitAddon.FitAddon(); term.loadAddon(termFit); term.open($('#xterm')); termFit.fit();
+// ojo: el display inicial lo pone el CSS, no el style inline — mirando sólo el inline, «está abierto»
+// daba true antes del primer showPane() y la restauración se creía abierta
+const termShown = () => getComputedStyle($('#termpane')).display !== 'none';
+// Un solo lugar donde se ajusta el tamaño. fit() hace clear() + resize() del terminal y dispara un
+// resize del pty (el shell repinta entero), así que sólo se llama cuando la caja cambió DE VERDAD:
+// sin esa guarda, el ResizeObserver se realimenta con su propio ajuste y el terminal parpadea.
+function fitTerm(t) {
+  if (!t || !t.fit || !termShown()) return;
+  const box = t.el.clientWidth + 'x' + t.el.clientHeight;
+  if (!t.el.clientWidth || !t.el.clientHeight || box === t.box) return;
+  t.box = box;
+  requestAnimationFrame(() => { if (t.term && t.fit) try { t.fit.fit(); } catch (e) {} }); // fuera del callback del observer
+}
+// pestañas: una por terminal (siempre visibles, también con una sola: así se ve que hay numeración)
+function paintTabs() {
+  const tabs = $('#ttabs'); tabs.innerHTML = '';
+  terms.forEach((t, i) => {
+    const b = document.createElement('span');
+    b.className = 'ttab' + (i === termAt ? ' on' : '') + (t.live ? '' : ' dead');
+    b.textContent = String(i + 1);
+    b.title = 'terminal ' + (i + 1) + (t.meta ? ' · ' + t.meta : '') + (t.live ? '' : ' (shell terminada)');
+    b.onclick = () => activateTerm(i); tabs.appendChild(b);
+  });
+  const add = $('#tnew'); add.disabled = terms.length >= MAX_TERMS;
+  add.title = add.disabled ? 'máximo ' + MAX_TERMS + ' terminales abiertas' : 'abrir otra terminal: una shell nueva en el workspace';
+  const t = terms[termAt];
+  $('#tmeta').textContent = t ? t.meta : '';
+  $('#termpane').classList.toggle('live', !!(t && t.live));
+  $('#term').classList.toggle('live', terms.some(x => x.live));   // el botón del encabezado: hay shell viva
+}
+function activateTerm(i) {
+  termAt = i;
+  terms.forEach((t, k) => { t.el.style.display = k === i ? '' : 'none'; });
+  paintTabs(); saveTermUi();
+  const t = terms[i];
+  if (!t) return;
+  t.box = ''; fitTerm(t); t.term.refresh(0, t.term.rows - 1); t.term.focus();
+}
+// id = reengancharse a una shell que ya existe (tras un F5); show = false para reconstruir sin abrir el panel
+function newTerm(id, show) {
+  if (terms.length >= MAX_TERMS) return;
+  if (show !== false) { showPane('term'); procOpen = null; clearInterval(procTimer); }
+  const el = document.createElement('div'); el.className = 'xt'; $('#xterms').appendChild(el);
+  const term = new Terminal({ cursorBlink: true, fontFamily: getComputedStyle(document.documentElement).getPropertyValue('--mono'), fontSize: 13, lineHeight: 1.25, theme: termTheme(), scrollback: 5000, allowProposedApi: true });
+  const fit = new FitAddon.FitAddon(); term.loadAddon(fit);
+  const t = { id: id || '', el, term, fit, ws: null, ro: null, box: '', meta: 'conectando…', live: false };
+  terms.push(t);
+  if (show !== false) termAt = terms.length - 1;
+  terms.forEach((x, k) => { x.el.style.display = k === termAt ? '' : 'none'; });
+  term.open(el); fitTerm(t);
   // URLs clickeables (npm run dev imprime http://localhost:3000): link provider mínimo con la API nativa
   // de xterm v5 — el addon web-links no está vendorizado y no hace falta para http/https
   const TERM_URL_RE = /https?:\/\/[^\s"'`<>()\[\]{}]*[^\s"'`<>()\[\]{}.,;:!?]/g;
@@ -28,22 +87,98 @@ function openTerm() {
       cb(links.length ? links : undefined);
     }
   });
-  $('#tmeta').textContent = 'conectando…';
-  termWs = new WebSocket((location.protocol === 'https:' ? 'wss://' : 'ws://') + location.host + BASE + '/api/term'); termWs.binaryType = 'arraybuffer';
-  const send = (o) => { if (termWs && termWs.readyState === 1) termWs.send(JSON.stringify(o)); };
-  termWs.onopen = () => { $('#termpane').classList.add('live'); send({ type: 'resize', cols: term.cols, rows: term.rows }); term.focus(); };
-  termWs.onmessage = (e) => { // "o" + salida del pty | "c" + JSON de control
+  const ws = new WebSocket((location.protocol === 'https:' ? 'wss://' : 'ws://') + location.host + BASE + '/api/term' + (id ? '?id=' + encodeURIComponent(id) : ''));
+  ws.binaryType = 'arraybuffer'; t.ws = ws;
+  const send = (o) => { if (ws.readyState === 1) ws.send(JSON.stringify(o)); };
+  t.send = send;
+  ws.onopen = () => { t.live = true; paintTabs(); send({ type: 'resize', cols: term.cols, rows: term.rows }); if (termAt === terms.indexOf(t)) term.focus(); };
+  ws.onmessage = (e) => { // "o" + salida del pty | "c" + JSON de control
     const s = String(e.data);
     if (s[0] === 'o') { term.write(s.slice(1)); return; }
     let m; try { m = JSON.parse(s.slice(1)); } catch { return; }
-    if (m.type === 'hello') $('#tmeta').textContent = `${m.shell} · pid ${m.pid} · ${m.cwd || 'workspace'}`;
-    if (m.type === 'exit') { term.write(`\r\n\x1b[2m[shell terminado · código ${m.code}]\x1b[0m\r\n`); $('#termpane').classList.remove('live'); }
+    if (m.type === 'hello') { t.id = m.id || t.id; t.meta = `${m.shell} · pid ${m.pid} · ${m.cwd || 'workspace'}`; paintTabs(); }
+    if (m.type === 'exit') {
+      t.live = false; paintTabs();
+      if (m.error === 'too_many') { term.write(`\r\n\x1b[2m[ya hay ${MAX_TERMS} terminales abiertas — cerrá una para abrir otra]\x1b[0m\r\n`); return; }
+      term.write(`\r\n\x1b[2m[shell terminado · código ${m.code}]\x1b[0m\r\n`);
+    }
+  };
+  // el socket se corta pero la shell sigue viva en el servidor: se recupera recargando (o al volver a entrar)
+  ws.onclose = () => {
+    t.live = false;
+    if (t.meta === 'conectando…') t.meta = 'sin conexión';
+    else if (!t.killed) term.write('\r\n\x1b[2m[conexión perdida · la shell sigue viva: recargá la página para reengancharte]\x1b[0m\r\n');
+    paintTabs();
   };
-  termWs.onclose = () => { $('#termpane').classList.remove('live'); if ($('#tmeta').textContent === 'conectando…') $('#tmeta').textContent = 'sin conexión'; };
   term.onData(d => send({ type: 'in', data: d }));
   term.onResize(({ cols, rows }) => send({ type: 'resize', cols, rows }));
-  new ResizeObserver(() => { if ($('#termpane').style.display !== 'none') termFit.fit(); }).observe($('#xterm'));
+  t.ro = new ResizeObserver(() => fitTerm(t)); t.ro.observe(el);
+  paintTabs(); saveTermUi();
+}
+// el botón del encabezado: abre la primera, trae de vuelta el panel minimizado, o lo esconde si está a la vista.
+// Espera a saber qué shells sobrevivieron (termsReady): sin eso, un clic apurado abriría una shell de más.
+function openTerm() {
+  termsReady.then(() => {
+    if (!terms.length) { newTerm(); return; }
+    if (termShown()) { minTerm(); return; }
+    showPane('term'); procOpen = null; clearInterval(procTimer);
+    activateTerm(termAt < 0 || termAt >= terms.length ? terms.length - 1 : termAt);
+    saveTermUi();
+  });
+}
+// minimizar: el panel se esconde, las shells siguen vivas (el botón del encabezado queda verde y lo devuelve)
+function minTerm() { maxTerm(false); showPane('log'); saveTermUi(); }
+// pantalla completa: el panel tapa la ventana entera; se vuelve con el mismo botón (❐).
+function maxTerm(on) {
+  const pane = $('#termpane');
+  const max = on === undefined ? !pane.classList.contains('max') : on;
+  pane.classList.toggle('max', max);
+  $('#tmax').innerHTML = max ? '&#10064;' : '&#9633;';
+  $('#tmax').title = max ? 'volver al tamaño normal' : 'pantalla completa';
+  saveTermUi();
+  const t = terms[termAt];
+  if (t) { t.box = ''; fitTerm(t); t.term.focus(); }
+}
+// repintar las terminales abiertas al cambiar de tema (lo llama theme.js; ojo: «term» a secas es el BOTÓN
+// del encabezado — los id del HTML son globales — así que el repintado tiene que pasar por acá)
+function termsRetheme() { const th = termTheme(); terms.forEach(t => { t.term.options.theme = th; }); }
+// cerrar: sólo la terminal activa. Hay que PEDIR la muerte de la shell ({type:"kill"}): irse del socket
+// ya no la mata (ese es el precio, y la gracia, de que sobreviva a un F5). La última cierra el panel.
+function closeTerm() {
+  const t = terms[termAt];
+  if (!t) { showPane('log'); return; }
+  t.killed = true;
+  if (t.ro) t.ro.disconnect();
+  if (t.ws) try { t.send({ type: 'kill' }); t.ws.close(); } catch (e) {}
+  t.term.dispose(); t.el.remove();
+  terms.splice(termAt, 1);
+  if (!terms.length) { termAt = -1; paintTabs(); maxTerm(false); showPane('log'); saveTermUi(); return; }
+  activateTerm(Math.min(termAt, terms.length - 1));
+}
+// al cargar: las shells que sobrevivieron al F5 vuelven como pestañas (el panel sólo si estaba abierto)
+async function restoreTerms() {
+  let data; try { data = await (await fetch(BASE + '/api/terms')).json(); } catch (e) { return; }
+  const live = (data && data.terminals) || [];
+  if (!live.length) return;
+  // leer ANTES de crear nada: cada newTerm guarda el estado y pisaría lo que dejó la sesión anterior
+  let open = false, at = 0, max = false;
+  try {
+    open = localStorage.getItem('lampson.term.open') === '1';
+    at = +(localStorage.getItem('lampson.term.at') || 0);
+    max = localStorage.getItem('lampson.term.max') === '1';
+  } catch (e) {}
+  const yaAbrio = terms.length > 0;   // alguien abrió una mientras preguntábamos: no le movemos la vista
+  for (const info of live) newTerm(info.id, false);
+  if (yaAbrio) { paintTabs(); return; }
+  termAt = Math.max(0, Math.min(at, terms.length - 1));
+  if (open) { showPane('term'); procOpen = null; clearInterval(procTimer); if (max) maxTerm(true); activateTerm(termAt); }
+  else { terms.forEach((t, k) => { t.el.style.display = k === termAt ? '' : 'none'; }); paintTabs(); }
 }
-function closeTerm() { if (termWs) { try { termWs.close(); } catch (e) {} } if (term) term.dispose(); term = null; termWs = null; termFit = null; $('#xterm').innerHTML = ''; $('#termpane').classList.remove('live'); showPane('log'); }
+const termsReady = restoreTerms();   // se lanza al cargar; openTerm la espera
 $('#term').onclick = openTerm;
+$('#tnew').onclick = newTerm;
+$('#tmin').onclick = minTerm;
+$('#tmax').onclick = () => maxTerm();
 $('#tclose').onclick = closeTerm;
+// Sin atajo para salir de pantalla completa: Esc es del shell (vim, menús) y robársela rompería el terminal.
+// El botón ❐ queda a la vista en la cabecera, que es lo único que se dibuja fuera del área del terminal.

package/public/js/theme.js

@@ -2,5 +2,5 @@
 const SUN = '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><circle cx="12" cy="12" r="4"/><path d="M12 2.7v2.1M12 19.2v2.1M2.7 12h2.1M19.2 12h2.1M5.3 5.3l1.5 1.5M17.2 17.2l1.5 1.5M18.7 5.3l-1.5 1.5M6.8 17.2l-1.5 1.5"/></svg>';
 const MOON = '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><path d="M20.2 14.6A8.6 8.6 0 0 1 9.4 3.8a8.6 8.6 0 1 0 10.8 10.8z"/></svg>';
 function paintTheme() { const light = document.documentElement.getAttribute('data-theme') === 'light'; $('#theme').innerHTML = light ? MOON : SUN; $('#theme').title = light ? 'Cambiar a tema oscuro' : 'Cambiar a tema claro'; }
-$('#theme').onclick = () => { const r = document.documentElement; r.setAttribute('data-theme', r.getAttribute('data-theme') === 'light' ? 'dark' : 'light'); try { localStorage.setItem('lampson.theme', r.getAttribute('data-theme')); } catch (e) {} paintTheme(); if (typeof term !== 'undefined' && term) term.options.theme = termTheme(); };
+$('#theme').onclick = () => { const r = document.documentElement; r.setAttribute('data-theme', r.getAttribute('data-theme') === 'light' ? 'dark' : 'light'); try { localStorage.setItem('lampson.theme', r.getAttribute('data-theme')); } catch (e) {} paintTheme(); if (typeof termsRetheme === 'function') termsRetheme(); };
 paintTheme();

package/public/js/workspaces.js

@@ -1,6 +1,9 @@
 // workspaces.js — el selector de workspace de la cabecera (dentro de un workspace) y el Panel de workspaces.
 // La API de workspaces es del HUB (raíz, sin BASE): /api/workspaces…  Sin hub (standalone) el selector se oculta.
 let wsList = [], wsIdle = 4;
+// abierto por el puerto de un proceso (:808N) las URLs de otros workspaces tienen que ir al hub (:8080), no a este proceso
+const HUB_BASE = (location.port && location.port !== '8080') ? location.protocol + '//' + location.hostname + ':8080' : '';
+function wsUrl(w) { return HUB_BASE + w.url; }
 async function fetchWorkspaces() {
   try { const r = await (await fetch('/api/workspaces')).json(); wsList = r.workspaces || []; wsIdle = r.idle_hours; return true; } catch (e) { wsList = []; return false; }
 }
@@ -31,12 +34,12 @@ function openWorkspaces(selectSlug) {
       wire: (w, box) => {
         const err = (m) => { const e = box.querySelector('.derr'); if (e) e.textContent = m || ''; };
         if (w === WS_NEW) { wsNewWire(box, err); return; }
-        box.querySelector('[data-open]').onclick = () => { if (w.slug !== WS_SLUG) location.href = w.url; else Panel.close(); };
+        box.querySelector('[data-open]').onclick = () => { if (w.slug !== WS_SLUG) location.href = wsUrl(w); else Panel.close(); };
         const st = box.querySelector('[data-start]'); if (st) st.onclick = async () => { err('arrancando…'); const r = await api('/api/workspaces/start', { slug: w.slug }); err(r.data.ok ? '' : 'no respondió a tiempo'); Panel.refresh(); };
         const sp = box.querySelector('[data-stop]'); if (sp) sp.onclick = async () => { await api('/api/workspaces/stop', { slug: w.slug }); setTimeout(() => Panel.refresh(), 800); };
         box.querySelector('[name="policy"]').onchange = async (ev) => { const r = await api('/api/workspaces/policy', { slug: w.slug, policy: ev.target.value }); if (!r.ok) err(r.data.error || 'error'); };
         const del = box.querySelector('.dfoot .del');
-        del.onclick = () => inlineConfirm(del, `¿quitar ${w.name} del registro?`, async () => { const r = await api('/api/workspaces/remove', { slug: w.slug }); if (!r.ok) { err(r.data.error || 'error'); return; } if (w.slug === WS_SLUG) location.href = '/'; else Panel.refresh(); });
+        del.onclick = () => inlineConfirm(del, `¿quitar ${w.name} del registro?`, async () => { const r = await api('/api/workspaces/remove', { slug: w.slug }); if (!r.ok) { err(r.data.error || 'error'); return; } if (w.slug === WS_SLUG) location.href = HUB_BASE + '/'; else Panel.refresh(); });
       }
     }
   });
@@ -87,11 +90,9 @@ function wsNewWire(box, err0) {
     const r = await api('/api/workspaces', { path: chosen });
     if (!r.ok) { err(r.data.error || ('error ' + r.status)); return; }
     // el hub se regenera con la ruta nueva y se reinicia: esperar a que vuelva y navegar
-    const url = r.data.url; let tries = 0;
+    const url = HUB_BASE + r.data.url; let tries = 0;
     const poll = async () => { tries++; try { const h = await fetch('/api/hub'); if (h.ok && tries > 2) { location.href = url; return; } } catch (e) {} if (tries < 40) setTimeout(poll, 500); else err('el hub no volvió: abrí ' + url + ' a mano'); };
     setTimeout(poll, 1200);
   };
 }
-// standalone (abierto por el puerto del workspace, no por el hub): la pill lleva al hub
-const HUB_URL = (location.port && location.port !== '8080') ? location.protocol + '//' + location.hostname + ':8080/' : '';
-if ($('#wsPill')) { if (HUB_URL) { const pill = $('#wsPill'); pill.style.display = ''; pill.textContent = 'workspaces ↗'; pill.title = 'esta pestaña es el proceso del workspace; los workspaces se gestionan en el hub'; pill.onclick = () => window.open(HUB_URL, '_blank'); } else { $('#wsPill').onclick = () => openWorkspaces(); paintWorkspacePill(); } }
+if ($('#wsPill')) { $('#wsPill').onclick = () => openWorkspaces(); paintWorkspacePill(); }

package/skills/synsema/SKILL.md

@@ -3,7 +3,7 @@ name: synsema
 description: Writing, checking, running and testing Synsema (.syn) code — syntax reflexes, capabilities, live processes / pseudo-terminals, and the runtime traps that cost hours. Load before touching any .syn file.
 ---
 
-# Synsema quick reference (v0.6.12)
+# Synsema quick reference (v0.6.13)
 
 > Curated 10 KB summary for the agent (the full reference is ~450 KB and lives in the user's editor
 > skill). Kept in sync by hand with each `synsema update`; if `synsema --version` is newer than the
@@ -14,6 +14,13 @@ description: Writing, checking, running and testing Synsema (.syn) code — synt
   `synsema test file.syn` (runs `test "..."` blocks) · `synsema serve file.syn` (HTTP server) ·
   `synsema update` (self-update; then refresh the AI skill with the command it prints).
 - Errors carry `file:line` and a suggestion. Read them; they are usually right.
+- **Read the repo without opening files (v0.6.13+)**: `synsema code outline` (project map: intent,
+  symbols, imports per file), `routes [path]` (the table each `serve` publishes: method, path, auth,
+  stream/socket/proxy, response kind, capabilities), `refs <name>` (every use, through module aliases),
+  `symbol <name>`, `caps` (declared vs. effective vs. `missing`, with the `require` to add), `check`,
+  `search <text>`, `deps`. Add `--json` for scripts. Same eight tools over MCP: `synsema code --mcp`
+  (server `synsema-code`, static — it never talks to a running server). `outline` before opening a
+  `.syn`, `refs` before renaming, `check` after every edit.
 
 ## Syntax reflexes (Python → Synsema)
 - `let x be 5` / `set x to 6` (no `=`) · `-- comment` · `when / otherwise when / otherwise` (no colons)

package/web.syn

@@ -64,6 +64,7 @@ use "./lib/schedule.syn" as schedule
 use "./lib/sched_run.syn" as sched_run
 use "./lib/approvals.syn" as approvals
 use "./lib/permission.syn" as permission
+use "./lib/term.syn" as term
 
 let APPROVAL_TIMEOUT be 180
 
@@ -86,22 +87,6 @@ task as_text(x)
         give decode(x, "utf8_lossy")
     give x
 
--- shell para el terminal web: [cmd, args]. Windows: pwsh si está, si no PowerShell 5; unix: bash de login.
--- En pwsh, los directorios de `ls` salen sin fondo azul (el default de $PSStyle se lee mal en un tema oscuro).
-task term_shell()
-    when env("OS", "") == "Windows_NT"
-        try
-            run("pwsh", ["-NoLogo", "-Command", "exit"], 10)
-            give ["pwsh", ["-NoLogo", "-NoExit", "-Command", "$PSStyle.FileInfo.Directory = $PSStyle.Foreground.BrightBlue"]]
-        recover err
-            give ["powershell", ["-NoLogo"]]
-    give ["bash", ["-l"]]
-
--- cwd del terminal: la ruta REAL del proyecto (LAMPSON_WORKSPACE), no la junction ./workspace —
--- así el prompt muestra dónde estás de verdad y coincide con el header.
-task term_cwd()
-    give env("LAMPSON_WORKSPACE", "workspace")
-
 task boot(profile, mode, ask_fn, pname, model)
     let cfg be provider.config_for(pname, model)
     let p be when contains(agents.PROFILES, profile) then profile otherwise "build"
@@ -138,11 +123,29 @@ serve on 8080
     auth with check_client
     static "./public"
 
-    -- standalone (sin hub: docker, `synsema serve web.syn`): la UI vive igual bajo /w/<slug> (BASE en js/core.js)
-    route "GET /"
-        give redirect("/w/" + (when env("LAMPSON_WS", "") == "" then "local" otherwise env("LAMPSON_WS", "")))
+    -- la UI vive bajo /w/<slug> (BASE en js/core.js); si alguien entra por el puerto del proceso, es lo mismo
+    -- Acceso DIRECTO por el puerto del proceso (sin X-Forwarded-Host, que solo agrega el hub al proxyear): la UI se
+    -- usa siempre por el hub → redirigir a http://127.0.0.1:8080/w/<slug>. Standalone sin hub (docker) no hay
+    -- LAMPSON_WS y se sirve acá mismo.
     route "GET /w/:slug"
+        let h be headers of request
+        when env("LAMPSON_WS", "") != "" and not contains(h, "x-forwarded-host")
+            give redirect("http://127.0.0.1:8080/w/" + params.slug)
         give html(read_file("public/index.html"))
+    route "GET /"
+        when env("LAMPSON_WS", "") == ""
+            give redirect("/w/local")
+        give redirect("http://127.0.0.1:8080/w/" + env("LAMPSON_WS", ""))
+    route "GET /api/hub"
+        proxy to "http://127.0.0.1:8080"
+    route "GET /api/workspaces"
+        proxy to "http://127.0.0.1:8080"
+    route "GET /api/workspaces/*path"
+        proxy to "http://127.0.0.1:8080"
+    route "POST /api/workspaces"
+        proxy to "http://127.0.0.1:8080"
+    route "POST /api/workspaces/*path"
+        proxy to "http://127.0.0.1:8080"
 
     -- salud para el hub/supervisor y la terminal (último uso = chat, terminal, eventos o abrir la UI)
     route "GET /w/:slug/api/health"
@@ -191,39 +194,61 @@ serve on 8080
     route "GET /w/:slug/api/tree" requires auth
         give tree.tree(6)
 
-    -- Terminal real en el navegador: un shell dentro de un pseudo-terminal (pty) por conexión WebSocket.
-    -- Navegador → servidor: texto JSON {type: "in", data: teclas} | {type: "resize", cols, rows}.
-    -- Servidor → navegador: frames de texto con prefijo: "o" + salida cruda del pty (ANSI incluido, xterm.js
-    -- la dibuja) | "c" + JSON de control ({type: hello|exit}).
-    -- El shell vive lo que vive el socket: cerrar el panel lo mata (el runtime no deja huérfanos).
+    -- Terminales del navegador. El pty NO vive en este handler: vive en un agente supervisor
+    -- (lib/term.syn), y este socket es un puente por el bus. Así la shell sobrevive a un F5 —
+    -- la pestaña se reengancha con ?id=<id> y recibe el replay de lo último que imprimió.
+    -- Navegador → servidor: {type: "in", data} | {type: "resize", cols, rows} | {type: "kill"}.
+    -- Servidor → navegador: "o" + salida cruda del pty | "c" + JSON de control (hello | exit).
+    -- Sin ningún socket enganchado por 30 min, el supervisor recoge la shell; todo muere con lampson.
     route "GET /w/:slug/api/term" requires auth
         socket
             state_set("lampson:last_used", now())
-            let sh be term_shell()
-            let p be proc_spawn(sh[0], sh[1], {"cwd": term_cwd(), "pty": true, "cols": 120, "rows": 32})
-            ws_send(socket, "c" + json_encode({"type": "hello", "shell": sh[0], "pid": proc_stats(p)["pid"], "cwd": term_cwd()}))
-            let open be true
-            while open
-                let ev be select({"ui": socket, "sh": p}, 600)
-                when ev == nothing
-                    set open to proc_status(p) == "running"
-                otherwise when ev["name"] == "ui"
-                    when ev["type"] == "close"
-                        set open to false
-                    otherwise when ev["type"] == "binary"
-                        proc_send(p, ev["data"])
+            let id be when contains(query, "id") then text(query.id) otherwise ""
+            when id == "" or not term.alive(id)
+                set id to term.start(120, 32)          -- nothing = ya hay MAX_TERMS abiertas
+            when id == nothing
+                ws_send(socket, "c" + json_encode({"type": "exit", "code": -1, "error": "too_many"}))
+            otherwise
+                let st be term.state(id)
+                ws_send(socket, "c" + json_encode({"type": "hello", "id": id, "shell": st["shell"], "pid": st["pid"], "cwd": st["cwd"]}))
+                let sub be bus_subscribe("term.out." + id)
+                -- el replay vuelve marcado con este id de socket: otra pestaña abierta no lo repite
+                let me be text(floor(now() * 1000)) + "-" + text(floor(random() * 100000))
+                term.ctl(id, {"k": "replay", "to": me})
+                while true
+                    let ev be select({"ui": socket, "sh": sub}, 20)
+                    when ev == nothing
+                        when not term.alive(id)
+                            stop
+                        term.ctl(id, {"k": "ping"})           -- «sigo acá»: sin pings se recoge la shell
+                    otherwise when ev["name"] == "ui"
+                        when ev["type"] == "close"
+                            stop
+                        otherwise when ev["type"] == "binary"
+                            term.ctl(id, {"k": "in", "d": as_text(ev["data"])})
+                        otherwise
+                            let m be json_decode(ev["data"])
+                            when m["type"] == "in"
+                                term.ctl(id, {"k": "in", "d": m["data"]})
+                            otherwise when m["type"] == "resize"
+                                term.ctl(id, {"k": "resize", "cols": m["cols"], "rows": m["rows"]})
+                            otherwise when m["type"] == "kill"
+                                term.kill(id)                  -- cerrar la pestaña SÍ mata la shell, a pedido
                     otherwise
-                        let m be json_decode(ev["data"])
-                        when m["type"] == "in"
-                            proc_send(p, m["data"])
-                        otherwise when m["type"] == "resize"
-                            proc_resize(p, floor(m["cols"]), floor(m["rows"]))
-                otherwise when ev["type"] == "exit"
-                    ws_send(socket, "c" + json_encode({"type": "exit", "code": ev["data"]["exit_code"]}))
-                    set open to false
-                otherwise
-                    ws_send(socket, "o" + as_text(ev["data"]))
-            proc_close(p)
+                        let d be ev["data"]
+                        when d["k"] == "exit"
+                            ws_send(socket, "c" + json_encode({"type": "exit", "code": d["code"]}))
+                            stop
+                        otherwise when d["k"] == "replay"
+                            when d["to"] == me and d["d"] != ""
+                                ws_send(socket, "o" + d["d"])
+                        otherwise
+                            ws_send(socket, "o" + d["d"])
+                bus_unsubscribe(sub)
+
+    -- las terminales vivas: la UI las repinta como pestañas al cargar (después de un F5 siguen ahí)
+    route "GET /w/:slug/api/terms" requires auth
+        give {"terminals": term.list(), "max": term.MAX_TERMS}
 
     route "GET /w/:slug/api/update" requires auth
         give update.check()