lampson 0.2.8 → 0.2.9

package/.env.example

@@ -1,6 +1,7 @@
 # Lampson — copia a .env (gitignored). Las claves nunca entran al proceso del programa: secret() es opaco.
 
-# Proveedor: openai | deepseek | kimi | groq | grok | openrouter | ollama | anthropic | minimax | glm
+# Proveedor: openai | deepseek | kimi | groq | grok | openrouter | ollama | anthropic | minimax | glm | glm-coding
+#   glm = Z.ai pago por uso · glm-coding = GLM Coding Plan (suscripción): misma key, endpoint /coding/
 LAMPSON_PROVIDER=deepseek
 LAMPSON_API_KEY=sk-...
 
@@ -36,3 +37,11 @@ LAMPSON_API_KEY=sk-...
 # LAMPSON_WEBHOOK_URL=https://hooks.example.com/lampson   # POST JSON por cada aprobación pendiente (id, mensaje, links);
 #                                # reenvialo a Telegram/Slack/mail con n8n, un bot o un .syn de 6 líneas
 # LAMPSON_WEBHOOK_SECRET=…       # firma HMAC-SHA256 del body (X-Lampson-Signature: sha256=<hex>)
+
+# Computer use (el agente maneja tu escritorio y navegador en segundo plano; apagado por defecto).
+# Se enciende en la web (⚙ → Computer use) o con /computer-use on; estas variables lo fuerzan desde .env.
+# Necesita un driver aparte que Lampson NO instala (la UI y /computer-use muestran el comando si falta).
+# LAMPSON_COMPUTER_USE=1
+# LAMPSON_COMPUTER_MAX_TABS=5            # pestañas distintas por corrida (los atajos que abren pestañas se rechazan siempre)
+# LAMPSON_COMPUTER_GRANT_PROFILE=1       # permitir atarse a tu navegador YA ABIERTO (sesión iniciada); default: navegador aparte
+# LAMPSON_COMPUTER_DRIVER=C:\ruta\cua-driver.exe   # solo si el driver no está en PATH ni en la carpeta del instalador

package/README.md

@@ -23,7 +23,7 @@ The form now shows “Wrong email or password” when the API returns 401. Tests
 npm i -g lampson
 ```
 
-No Node.js? One line does it all (installs what's missing, including [Synsema](https://synsema.com)):
+No Node.js? One line does it all (installs what's missing, including [Synsema](https://synsema.org)):
 
 ```powershell
 # Windows (PowerShell)
@@ -43,7 +43,7 @@ lampson            # in the terminal
 lampson --web      # in the browser → http://127.0.0.1:8080
 ```
 
-The first time it asks which provider you use — DeepSeek, Anthropic, OpenAI, GLM (Z.ai), Kimi, Groq, OpenRouter,
+The first time it asks which provider you use — DeepSeek, Anthropic, OpenAI, GLM (Z.ai, pay-as-you-go or Coding Plan), Kimi, Groq, OpenRouter,
 Ollama (runs on your machine, no key)… — and for your API key. That's it. Change it any time with `/model`.
 
 More ways (Docker, from source, updating): **[lampson.org/install](https://lampson.org/install)**.
@@ -55,6 +55,9 @@ More ways (Docker, from source, updating): **[lampson.org/install](https://lamps
 - **Review** — `/agent review` runs the tests and reads the diff, but never edits.
 - **Run things while you're away** — "every weekday at 9, run the tests and tell me if something broke." If a
   scheduled run hits something risky, you get a link on your phone to approve or deny it.
+- **From your phone** — install it as an app, sign in with a passkey (fingerprint or face) and work on your PC or
+  your server from anywhere. A tunnel for a home PC, or `lampson --domain` for HTTPS on a VPS:
+  **[lampson.org/docs/phone](https://lampson.org/docs/phone)**.
 
 It can only touch the folder you opened it in — not your home directory, not the project next door. That isn't
 a setting: it's how the language it's written in works. Reading and editing just happen; deleting, installing,
@@ -96,7 +99,9 @@ plugins were called *lamps*; old `.lampson/lamps/` folders and `LAMP_*` variable
 Sub-agents that work in parallel · skills (`SKILL.md` procedures, anything on [skills.sh](https://skills.sh)
 works) · MCP servers with the JSON you already have · language servers for real go-to-definition · project
 memory it reads back next session · sessions with a readable trace of every step · web pages fetched as
-Markdown (a tenth of the tokens of raw HTML) · paste a screenshot and ask.
+Markdown (a tenth of the tokens of raw HTML) · paste a screenshot and ask · computer use, opt-in: the agent
+drives your desktop and browser in the background (one tab, no destructive keys) on a driver you install apart,
+with an optional decision judge (Jev or local Laya) that picks the clicks in under a second.
 
 ## Learn more
 

package/bin/lampson.js

@@ -22,7 +22,7 @@ const home = process.env.LAMPSON_HOME || path.join(os.homedir(), 'lampson');
 const marker = path.join(home, '.npm-installed');
 
 // what gets copied into the home: the runtime, never state. Keep in sync with "files" in package.json.
-const CODE = ['lib', 'public', 'skills', 'chat.syn', 'web.syn', 'hub.tpl.syn', 'cli.syn', 'lampson.ps1', 'lampson.sh', 'lampson.cmd', '.env.example', 'README.md', 'LICENSE'];
+const CODE = ['lib', 'public', 'skills', 'chat.syn', 'web.syn', 'hub.tpl.syn', 'edge.syn', 'cli.syn', 'lampson.ps1', 'lampson.sh', 'lampson.cmd', '.env.example', 'README.md', 'LICENSE'];
 
 // copia un archivo; en unix, los scripts de shell y los .syn salen con LF aunque el paquete se haya armado
 // en Windows (un CRLF en lampson.sh rompe bash: "set: pipefail\r: invalid option")

package/chat.syn

@@ -18,6 +18,7 @@ require random
 require env("LAMPSON_*")
 require env("OS")
 require secret("LAMPSON_*")
+require judge
 require file("workspace")
 require file("workspace/*")
 require file.read("skills")
@@ -55,6 +56,8 @@ use "./lib/tools/todo.syn" as todo
 use "./lib/schedule.syn" as schedule
 use "./lib/sched_run.syn" as sched_run
 use "./lib/approvals.syn" as approvals
+use "./lib/computer.syn" as computer
+use "./lib/judge.syn" as jdg
 
 -- ---------- UI de terminal ----------
 -- Colores ANSI (Windows Terminal, PowerShell 7, cualquier terminal moderna). LAMPSON_NO_COLOR=1 los apaga.
@@ -350,6 +353,8 @@ let COMMANDS be [
     ["/mcp", "[add <nombre> <comando…> [--project] | remove <nombre>]", "servers MCP: listar, conectar o quitar (global: lampson/.lampson/mcp.json · proyecto: .lampson/mcp.json)"],
     ["/plugins", "[on <nombre> | off <nombre> | run <plugin> <tool> [json] | remove <nombre>]", "plugins (tools propias, en cualquier lenguaje): listar, encender o apagar (global: lampson/plugins/ · proyecto: .lampson/plugins/)"],
     ["/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"],
+    ["/computer-use", "[on|off]", "computer use: el agente maneja tu escritorio y navegador en segundo plano (driver aparte, apagado por defecto); sin argumento muestra el estado y, si falta el driver, cómo instalarlo"],
+    ["/judge", "[off|jev|laya]", "juez de decisión: un modelo chico que decide con probabilidades (hoy lo usa computer use para elegir los clics) — jev = TypeSafe en la nube (pide la API key), laya = local (pide la carpeta del checkpoint); sin argumento muestra el estado"],
     ["/schedule", "[add <json> | run <id> | on <id> | off <id> | remove <id> | log <id>]", "tareas programadas (cada 6h, todos los días a las 9…): plugin, 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 (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)"],
@@ -411,6 +416,14 @@ task complete_args(cmd, head, last)
         when trim(head) == "add"
             give sort_by(keys(lsp.PRESETS), (x) => x)
         give ["--project", "--ext"]
+    when cmd == "/computer-use"
+        when first
+            give ["on", "off"]
+        give []
+    when cmd == "/judge"
+        when first
+            give ["off", "jev", "laya"]
+        give []
     when cmd == "/approve"
         when first
             give apply((a) => a["id"], approvals.pending())
@@ -536,12 +549,81 @@ task show_config(cfg, ws, profile, mode, opts)
     print("")
     print("  proveedor   " + cfg["provider"] + " (" + cfg["wire"] + " → " + cfg["base_url"] + ")")
     print("  modelo      " + cfg["model"] + "   max_tokens " + text(cfg["max_tokens"]) + "   timeout " + text(floor(cfg["timeout"])) + "s")
-    print("  agente      " + profile + "   tools: " + join(agents.profile(profile)["tools"], ", "))
+    print("  agente      " + profile + "   tools: " + join(agents.tool_names(agents.profile(profile)), ", "))
     print("  permisos    " + mode)
     print("  límites     " + text(opts["max_steps"]) + " pasos/turno · " + text(floor(opts["budget_tokens"])) + " tokens/turno · compacta a " + text(floor(opts["compact_at_tokens"])))
     print("  workspace   " + ws)
+    print("  computer    " + (when computer.enabled() then (when computer.driver() != "" then "encendido" otherwise "encendido · driver NO instalado (/computer-use)") otherwise "apagado (/computer-use on)"))
     print("")
 
+-- /computer-use: estado del driver externo y cómo instalarlo (lib/computer.syn); on|off queda en config.json
+task computer_lines()
+    let s be computer.status()
+    let out be []
+    when s["enabled"]
+        set out to append(out, green("computer use: encendido") + dim(" — el agente maneja tu escritorio y navegador en segundo plano"))
+    otherwise
+        set out to append(out, dim("computer use: apagado") + "  " + cyan("/computer-use on") + dim(" para encenderlo — el agente maneja tu escritorio y navegador en segundo plano"))
+    when not s["installed"]
+        set out to append(out, (when s["enabled"] then red("○ driver no instalado") otherwise dim("○ driver no instalado")) + dim(" — es un paquete aparte (" + s["install"]["docs"] + "); instalalo vos en una terminal:"))
+        set out to append(out, "    " + cyan(s["install"]["command"]))
+        set out to append(out, "    " + cyan(s["install"]["then"]))
+    otherwise
+        let bad be where(s["checks"], (k) => k["status"] != "ok" and k["status"] != "skip")
+        set out to append(out, (when s["ok"] then green("● driver " + s["version"]) otherwise yellow("▲ driver " + s["version"] + " con problemas")) + dim("  " + s["path"]))
+        each k in bad
+            set out to append(out, "    " + yellow(k["label"] + ": " + k["message"]))
+        when s["error"] != nothing
+            set out to append(out, "    " + red(text(s["error"])))
+        when s["driver_error"] != nothing
+            set out to append(out, "    " + red(text(s["driver_error"])))
+        set out to append(out, dim("  " + (when s["running"] then "conectado" otherwise "arranca con la primera acción del agente") + " · pestañas máx " + text(s["max_tabs"]) + " · navegador abierto del usuario: " + (when s["grant_profile"] then "permitido" otherwise "no (abre uno aparte)") + " · también en la web: ⚙ → Computer use"))
+    -- el juez de decisión (lib/judge.syn) lo usa la acción act; se configura aparte con /judge
+    set out to append(out, dim("  juez de decisión (acción act): ") + judge_short(s["judge"]))
+    give out
+
+-- una línea del estado del juez (para /computer-use y /judge)
+task judge_short(j)
+    when j["mode"] == "off"
+        give dim("apagado — ") + cyan("/judge jev") + dim(" o ") + cyan("/judge laya")
+    when j["live"] and not j["restart"]
+        give green("● " + j["mode"] + " activo") + dim(when j["provider_model"] != "" then " · " + j["provider_model"] otherwise "")
+    give yellow("▲ " + j["mode"] + " configurado, esta sesión no lo tiene") + dim(" — /exit y volvé a entrar" + (when j["mode"] == "jev" and not j["has_key"] then " · falta la API key" otherwise "") + (when j["mode"] == "laya" and j["model_setting"] == "" then " · falta la carpeta del checkpoint" otherwise ""))
+
+-- /judge [off|jev|laya [carpeta]]: el juez de decisión, una credencial de Lampson (no de computer use). jev pide
+-- la API key de TypeSafe si falta; laya, la carpeta del checkpoint. El runtime lo lee al arrancar: /exit y volver.
+task judge_command(rest)
+    let args be where(split(rest, " "), (x) => x != "")
+    when length(args) > 0
+        let jm be lower(args[0])
+        when jm != "off" and jm != "jev" and jm != "laya"
+            print("  uso: /judge [off|jev|laya] — laya acepta la carpeta del checkpoint: /judge laya C:\\models\\laya")
+            give false
+        let st be jdg.status()
+        let model be when length(args) > 1 then join(slice(args, 1, length(args)), " ") otherwise nothing
+        when jm == "laya" and model == nothing and st["model_setting"] == ""
+            let ans be read_line("  carpeta del checkpoint de Laya (model.safetensors, encoder/, tokenizer/): ")
+            when ans == nothing or trim(ans) == ""
+                print("  (sin cambios: Laya necesita la carpeta)")
+                give false
+            set model to trim(ans)
+        let key be nothing
+        when jm == "jev" and not st["has_key"]
+            print("  " + dim("la key se guarda en lampson/.lampson/config.json (solo en esta máquina) · console.typesafe.ai"))
+            let k be read_line("  API key de TypeSafe: ")
+            when k == nothing or trim(k) == ""
+                print("  (sin cambios: Jev necesita la API key)")
+                give false
+            set key to trim(k)
+        let r be jdg.configure(jm, model, key)
+        when not r["ok"]
+            print("  " + red(r["error"]))
+            give false
+        print("  " + green("juez de decisión: " + jm) + dim(" — se aplica al volver a entrar: /exit y abrí lampson de nuevo (la web lo aplica sola al guardar en ⚙)"))
+    print("  juez de decisión: " + judge_short(jdg.status()))
+    print(dim("  un modelo chico que decide con probabilidades · hoy lo usa computer use (acción act: elige los clics sin gastar turnos del modelo)"))
+    give true
+
 -- sugerencias para un comando desconocido: por prefijo
 task suggest(input)
     let word be split(input, " ")[0]
@@ -578,8 +660,10 @@ task banner(ws, cfg, profile, mode, sid)
         set ext to append(ext, (when mcp_on == length(ms) then green("mcp " + text(mcp_on) + "/" + text(length(ms))) otherwise red("mcp " + text(mcp_on) + "/" + text(length(ms)))))
     when length(ss) > 0
         set ext to append(ext, dim("lsp " + text(length(ss))))
+    when computer.enabled()
+        set ext to append(ext, when computer.driver() != "" then green("computer use") otherwise red("computer use: driver no instalado"))
     when length(ext) > 0
-        print("  extras      " + join(ext, dim("  ·  ")) + dim("   (/plugins /mcp /lsp)"))
+        print("  extras      " + join(ext, dim("  ·  ")) + dim("   (/plugins /mcp /lsp /computer-use)"))
     let upd be update.line()
     when upd != ""
         print("  " + yellow("⬆ " + upd) + dim("  (o /update acá)"))
@@ -746,7 +830,7 @@ task grab_image(mode, path)
         set r to run("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", "lib/tools/img.ps1", mode, path], 60)
     otherwise
         set r to run("bash", ["lib/tools/img.sh", mode, path], 60)
-    let line be trim(replace_text(r["stdout"], "\r", ""))
+    let line be trim(replace(r["stdout"], "\r", ""))
     when line == "" or starts_with(line, "ERROR|")
         give {"error": when line == "" then trim(r["stderr"]) otherwise slice(line, 6, length(line))}
     let parts be split(line, "|")
@@ -1028,7 +1112,7 @@ while running
             print(trace.tail(sid, lines))
         otherwise when starts_with(input, "/model") or starts_with(input, "/provider") or starts_with(input, "/setup")
             -- un solo flujo (ver setup_wizard): proveedor → modelo (lista de la API) → key si falta; se guarda en config.json
-            let rest be trim(replace_re(input, "^/(model|provider|setup)", ""))
+            let rest be trim(regex_replace(input, "^/(model|provider|setup)", ""))
             when setup_from_args(rest, cfg["provider"], cfg["model"])
                 set cfg to provider.config()
         otherwise when input == "/paste"
@@ -1129,13 +1213,13 @@ while running
                 print(memo.note_read(nm))
         otherwise when input == "/todo"
             let items be todo.load(sid)
-            print(when length(items) == 0 then "  sin tareas (el agente las crea con la tool todo)" otherwise "  " + replace_text(todo.format(items), "\n", "\n  "))
+            print(when length(items) == 0 then "  sin tareas (el agente las crea con la tool todo)" otherwise "  " + replace(todo.format(items), "\n", "\n  "))
         otherwise when input == "/lsp" or starts_with(input, "/lsp ")
             let srest be trim(slice(input, 4, length(input)))
             when starts_with(srest, "add ")
                 -- /lsp add typescript [--project]   ·   /lsp add mylang cmd args… --ext .x=lang [--ext .y=lang2]
                 let sscope be when contains(srest, "--project") then "project" otherwise "global"
-                let sline be trim(replace_text(srest, "--project", ""))
+                let sline be trim(replace(srest, "--project", ""))
                 let stoks be where(split(slice(sline, 4, length(sline)), " "), (x) => x != "")
                 when length(stoks) == 0
                     print("  uso: /lsp add <" + join(keys(lsp.PRESETS), "|") + "> [--project]   ·   /lsp add <nombre> <comando…> --ext .ext=languageId")
@@ -1298,7 +1382,7 @@ while running
             when starts_with(mrest, "add ")
                 -- /mcp add <nombre> <comando…> [--project]  (env/keys: editá el mcp.json a mano, no van por terminal)
                 let mscope be when contains(mrest, "--project") then "project" otherwise "global"
-                let mline be trim(replace_text(mrest, "--project", ""))
+                let mline be trim(replace(mrest, "--project", ""))
                 let mtoks be where(split(slice(mline, 4, length(mline)), " "), (x) => x != "")
                 when length(mtoks) < 2
                     print("  uso: /mcp add <nombre> <comando…> [--project]   p.ej.: /mcp add github npx -y @modelcontextprotocol/server-github")
@@ -1342,6 +1426,26 @@ while running
             set mode to slice(input, 1, length(input))
             set opts to opts_for(profile, mode)
             print("permisos=" + opts["permission_mode"])
+        otherwise when input == "/judge" or starts_with(input, "/judge ")
+            judge_command(trim(slice(input, 6, length(input))))
+        otherwise when input == "/computer-use" or starts_with(input, "/computer-use ")
+            let crest be lower(trim(slice(input, 13, length(input))))
+            when crest == "on" or crest == "true" or crest == "off" or crest == "false"
+                let con be crest == "on" or crest == "true"
+                settings.set_value("computer_use", when con then "1" otherwise "")
+                computer.reset_state()
+                when not con
+                    computer.stop_driver()
+                -- el catálogo y el system prompt cambian (la tool y su skill entran o salen)
+                set system_msg to system_for(profile)
+                set messages to [system_msg] + slice(messages, 1, length(messages))
+                set opts to opts_for(profile, mode)
+            otherwise when starts_with(crest, "judge")
+                print("  " + yellow("el juez ahora es una configuración propia: ") + cyan("/judge off|jev|laya"))
+            otherwise when crest != ""
+                print("  uso: /computer-use [on|off]")
+            each l in computer_lines()
+                print("  " + l)
         otherwise when starts_with(input, "/agent")
             let want be trim(slice(input, 6, length(input)))
             when want == ""

package/cli.syn

@@ -3,13 +3,17 @@
 --   LAMPSON_CMD=ensure  LAMPSON_WORKSPACE=<ruta>  synsema run cli.syn
 --       registra/prepara el workspace, asegura el hub y su proceso → imprime UNA línea JSON {slug, port, dir, url, alive}
 --   LAMPSON_CMD=hub-status  → {alive}
---   LAMPSON_CMD=hub-start | hub-stop
+--   LAMPSON_CMD=hub-start | hub-stop | hub-reboot (stop + start: hub y workspaces; lo lanza ⚙ → Apagar o reiniciar)
 --   LAMPSON_CMD=list
+--   LAMPSON_CMD=pair  [LAMPSON_PAIR_URL=https://…]   código para emparejar un celular (lampson --pair dibuja el QR)
+--   LAMPSON_CMD=domain  LAMPSON_DOMAIN=<dominio>|off|""  [LAMPSON_EMAIL=<email>]   dominio propio con HTTPS (opcional)
 -- La salida útil va en la ÚLTIMA línea (JSON) para que el launcher la parsee.
 
 require exec
 require time
 require net("127.0.0.1")
+-- lampson --pair comprueba que la dirección pública (túnel o dominio) responda antes de dibujar un QR inútil
+require net
 require env("LAMPSON_*")
 require env("OS")
 require env("HOME")
@@ -23,6 +27,7 @@ require file.read("hub.tpl.syn")
 require file("hub.syn")
 
 use "./lib/workspaces.syn" as ws
+use "./lib/settings.syn" as settings
 
 let cmd be env("LAMPSON_CMD", "ensure")
 
@@ -39,18 +44,84 @@ when cmd == "ensure"
         ws.wait_ready(w, 10)
         set hc to ws.health(w)
     ws.touch(w["slug"])
-    print(json_encode({"slug": w["slug"], "port": w["port"], "dir": ws.dir_of(w["slug"]), "url": "http://127.0.0.1:" + text(ws.HUB_PORT) + "/w/" + w["slug"], "alive": hc != nothing, "hub": ws.hub_alive()}))
+    -- judge_*: el juez de computer use para la terminal (lampson.ps1|sh lo exportan antes de chat.syn; ver settings.judge_env)
+    let je be settings.judge_env()
+    print(json_encode({"slug": w["slug"], "port": w["port"], "dir": ws.dir_of(w["slug"]), "url": "http://127.0.0.1:" + text(ws.HUB_PORT) + "/w/" + w["slug"], "alive": hc != nothing, "hub": ws.hub_alive(), "judge_provider": when contains(je, "SYNSEMA_JUDGE_PROVIDER") then je["SYNSEMA_JUDGE_PROVIDER"] otherwise "", "judge_model": when contains(je, "SYNSEMA_JUDGE_MODEL") then je["SYNSEMA_JUDGE_MODEL"] otherwise "", "judge_key": when contains(je, "TYPESAFE_API_KEY") then je["TYPESAFE_API_KEY"] otherwise ""}))
 otherwise when cmd == "hub-status"
     print(json_encode({"alive": ws.hub_alive(), "workspaces": ws.summary()}))
 otherwise when cmd == "hub-start"
     when not ws.hub_alive()
         ws.start_hub()
+    when ws.domain_cfg() != nothing and not ws.edge_alive()
+        ws.start_edge()
     print(json_encode({"alive": true}))
-otherwise when cmd == "hub-stop"
-    each w in ws.all()
-        ws.stop_ws(w)
-    ws.stop_hub()
-    print(json_encode({"alive": false}))
+otherwise when cmd == "hub-stop" or cmd == "hub-reboot"
+    -- desde ⚙ llega desacoplado (workspaces.cli_later): darle al hub tiempo de contestar antes de pararlo
+    when env("LAMPSON_DETACHED", "") != ""
+        sleep(1.5)
+    ws.stop_all()
+    when cmd == "hub-reboot"
+        sleep(2)
+        ws.start_hub()
+        when ws.domain_cfg() != nothing
+            ws.start_edge()
+    print(json_encode({"alive": cmd == "hub-reboot"}))
+otherwise when cmd == "domain"
+    let arg be trim(env("LAMPSON_DOMAIN", ""))
+    when arg == ""
+        -- estado
+        let cfg be ws.domain_cfg()
+        when cfg == nothing
+            print("sin dominio propio: lampson se usa en http://127.0.0.1:" + text(ws.HUB_PORT) + " (o por túnel).")
+            print("para usar el tuyo:  lampson --domain lampson.midominio.com --email vos@midominio.com")
+        otherwise
+            print("dominio: https://" + cfg["domain"] + "   (" + (when ws.edge_alive() then "● HTTPS activo" otherwise "○ el edge no está escuchando — mirá .lampson/edge.log") + ")")
+            print("certificado de Let's Encrypt a nombre de " + cfg["email"] + " · quitar: lampson --domain off")
+        print(json_encode({"domain": when cfg == nothing then nothing otherwise cfg["domain"], "edge": ws.edge_alive()}))
+    otherwise when lower(arg) == "off"
+        let had be ws.clear_domain()
+        ws.stop_edge()
+        ws.regen_hub()
+        when ws.hub_alive()
+            ws.stop_hub()
+            sleep(2)
+            ws.start_hub()
+        print(when had then "dominio quitado: el hub vuelve a escuchar en :" + text(ws.HUB_PORT) + " como antes." otherwise "no había dominio configurado.")
+        print(json_encode({"domain": nothing}))
+    otherwise
+        let cfg be nothing
+        try
+            set cfg to ws.set_domain(arg, env("LAMPSON_EMAIL", ""))
+        recover err
+            print("✗ " + regex_replace(text(err), "^.*?:\d+:\d+: ", ""))
+            print(json_encode({"error": text(err)}))
+        when cfg != nothing
+            -- el hub pasa a 127.0.0.1 (regen) y el edge arranca con el dominio nuevo
+            ws.regen_hub()
+            ws.stop_edge()
+            when ws.hub_alive()
+                ws.stop_hub()
+                sleep(2)
+            ws.start_hub()
+            ws.start_edge()
+            print("dominio: https://" + cfg["domain"] + " — pidiendo el certificado a Let's Encrypt…")
+            -- esperar a que el edge escuche (el certificado se pide al arrancar; tarda unos segundos)
+            let deadline be now() + 45
+            while now() < deadline and not ws.edge_alive()
+                sleep(1)
+            let up be ws.edge_alive()
+            let tail be ws.edge_log(12)
+            when up
+                print("● HTTPS activo en https://" + cfg["domain"] + " — emparejá el celular desde «dispositivos» (el QR ya usa esta URL).")
+            otherwise
+                print("○ el edge no quedó escuchando. Últimas líneas de .lampson/edge.log:")
+                each l in tail
+                    print("    " + l)
+                print("revisá: 1) el DNS de " + cfg["domain"] + " apunta a la IP de este servidor (registro A/AAAA);")
+                print("        2) los puertos 80 y 443 están abiertos en el firewall;")
+                print("        3) en Linux sin root, el binario puede usar puertos bajos: sudo setcap cap_net_bind_service=+ep $(command -v synsema)")
+                print("el hub reintenta solo cada 10 min; `lampson --domain off` vuelve a como estaba.")
+            print(json_encode({"domain": cfg["domain"], "edge": up}))
 otherwise when cmd == "hub-restart"
     -- lanzado desacoplado por workspaces.restart_hub_later: espera a que el hub termine lo que estaba haciendo,
     -- lo para y lo vuelve a arrancar con el hub.syn regenerado (bajo systemd, Restart=always ya lo levanta solo)
@@ -60,6 +131,71 @@ otherwise when cmd == "hub-restart"
     when not ws.hub_alive()
         ws.start_hub()
     print(json_encode({"restarted": true}))
+otherwise when cmd == "ws-restart"
+    -- lanzado desacoplado por workspaces.restart_ws_later desde el propio workspace: espera a que conteste el
+    -- request que lo pidió, lo para y lo arranca de nuevo (con el entorno del juez al día)
+    let w be ws.get(env("LAMPSON_WS", ""))
+    when w == nothing
+        raise("unknown workspace " + env("LAMPSON_WS", ""))
+    sleep(1.5)
+    ws.stop_ws(w)
+    let deadline be now() + 8
+    while now() < deadline and ws.health(w) != nothing
+        sleep(0.4)
+    ws.start_ws(w)
+    ws.wait_ready(w, 15)
+    print(json_encode({"restarted": w["slug"], "alive": ws.health(w) != nothing}))
+otherwise when cmd == "pair"
+    -- lampson --pair [URL]: emparejar un celular desde la terminal — en un VPS por SSH no hay navegador en «esta
+    -- PC». Se le pide el código al hub por 127.0.0.1 (el emparejamiento solo se inicia desde local); el lanzador
+    -- dibuja el QR con lib/tools/qr.js. Con URL, primero la guarda como pública (la del túnel o el dominio).
+    when not ws.hub_alive()
+        ws.start_hub()
+        let deadline be now() + 15
+        while now() < deadline and not ws.hub_alive()
+            sleep(0.5)
+    let base be "http://127.0.0.1:" + text(ws.HUB_PORT)
+    let hdr be {"Content-Type": "application/json"}
+    let bad be nothing
+    let want be trim(env("LAMPSON_PAIR_URL", ""))
+    when want != ""
+        let ru be http_post(base + "/api/auth/public-url", json_encode({"url": want}), hdr, 15)
+        when contains(ru, "error")
+            set bad to "el hub no responde en " + base
+        otherwise when status of ru != 200
+            set bad to "no pude guardar la URL: " + slice(body of ru, 0, 300)
+    -- ¿la dirección pública responde? Un túnel rápido de cloudflare (*.trycloudflare.com) muere al cerrar
+    -- cloudflared y la dirección guardada queda vieja: el QR llevaría a «sin conexión» (2026-09-28, en el celular)
+    when bad == nothing
+        let cur be http_get(base + "/api/auth/public-url", {"timeout": 10})
+        let pub0 be ""
+        when not contains(cur, "error")
+            when status of cur == 200
+                set pub0 to text(json_decode(body of cur)["public_url"])
+        when pub0 != "" and pub0 != "nothing"
+            let probe be http_get(pub0 + "/api/auth/me", {"timeout": 8})
+            let alive be false
+            when not contains(probe, "error")
+                set alive to status of probe == 200 and contains(body of probe, "authenticated")
+            when not alive
+                let tunnel be contains(pub0, "trycloudflare.com")
+                set bad to "la dirección pública " + pub0 + " no responde" + (when tunnel then ": ese túnel de cloudflare ya no existe (mueren al cerrar cloudflared y cada uno trae una dirección nueva). Levantá uno con «cloudflared tunnel --url http://localhost:8080» y corré lampson --pair <la https nueva que imprime>" otherwise " — ¿está el dominio apuntando a este servidor y el edge HTTPS arriba? (lampson --domain muestra el estado)")
+    when bad == nothing
+        let r be http_post(base + "/api/auth/pair", "{}", hdr, 15)
+        when contains(r, "error")
+            set bad to "el hub no responde en " + base + " — lampson --hub start"
+        otherwise when status of r != 200
+            set bad to "el hub rechazó el pedido (" + text(status of r) + "): " + slice(body of r, 0, 300)
+        otherwise
+            let j be json_decode(body of r)
+            let pub be text(j["public_url"])
+            when pub == "" or pub == "nothing"
+                set bad to "falta la dirección pública por la que entra el celular: lampson --pair https://tu-dominio (o configurá el dominio con lampson --domain)"
+            otherwise
+                print(json_encode({"link": pub + "/pair#" + text(j["code"]), "expires_in": j["expires_in"], "public_url": pub}))
+    when bad != nothing
+        print("✗ " + bad)
+        print(json_encode({"error": bad}))
 otherwise when cmd == "list"
     each w in ws.summary()
         print((when w["alive"] then "● " otherwise "○ ") + w["slug"] + "  " + w["path"] + "  :" + text(w["port"]) + "  " + w["policy"])

package/edge.syn

@@ -0,0 +1,26 @@
+-- edge.syn — HTTPS con TU dominio delante del hub. OPCIONAL: solo corre si configuraste uno (`lampson --domain …`).
+--
+-- Synsema termina TLS acá (certificado gratis de Let's Encrypt, renovación automática, :80 → :443) y pasa todo al hub
+-- en 127.0.0.1:8080, que sigue igual que siempre. El edge agrega X-Forwarded-For/-Proto/-Host y el hub, que confía
+-- en loopback (`trust proxy`), los ve: para él es una visita REMOTA con el dominio público, así que pide la passkey
+-- de un dispositivo emparejado (lib/origin.syn, lib/auth.syn). El edge NO confía en nadie: lo que un cliente mande
+-- como X-Forwarded-* lo borra el motor. SSE y WebSocket (chat, terminal) cruzan el edge.
+--
+-- Lo lanza el supervisor del hub (lib/workspaces.syn start_edge) con:
+--   synsema serve edge.syn --port 443 --domain <dominio> --tls-auto <email>
+-- El archivo no cambia entre máquinas: el dominio y el email son flags.
+
+intent: "Lampson edge: TLS for the user's own domain in front of the local hub"
+
+require serve(443)
+require net("127.0.0.1")
+
+serve on 443
+    max_streams 200
+    -- "/*path" no matchea "/": la raíz va aparte, por método
+    route "GET /"
+        proxy to "http://127.0.0.1:8080"
+    route "GET /*path"
+        proxy to "http://127.0.0.1:8080"
+    route "POST /*path"
+        proxy to "http://127.0.0.1:8080"