lampson 0.2.7 → 0.2.9

package/hub.tpl.syn

@@ -8,7 +8,9 @@
 --   GET  /w/<slug>/approve/…  links de aprobación de ese workspace
 --   /api/workspaces…          registro, crear (diálogo nativo o explorador), start/stop/quitar, política
 -- Supervisor: cada 15 s arranca los workspaces que deben vivir y apaga los inactivos (política en ⚙ → idle_hours).
--- Solo loopback puede usar la API del hub (misma regla que web.syn); LAMPSON_WEB_TOKEN para scripts remotos.
+-- Acceso: esta PC entra sin nada; lo remoto — túnel, LAN, VPS — necesita la sesión de un dispositivo emparejado con
+-- passkey (lib/auth.syn), o LAMPSON_WEB_TOKEN para scripts. Qué es «esta PC» y qué origin vale: lib/origin.syn. Las
+-- rutas proxy al API de cada workspace también piden auth: el proceso del workspace confía en lo que le llega del hub.
 
 intent: "Lampson hub: workspaces registry, supervisor and reverse proxy to one process per workspace"
 
@@ -29,34 +31,141 @@ require file.read("hub.tpl.syn")
 require file("hub.syn")
 require file.read("public")
 require file.read("public/*")
+require random
 
 use "./lib/workspaces.syn" as ws
 use "./lib/settings.syn" as settings
+use "./lib/auth.syn" as auth
+use "./lib/origin.syn" as origin
 
+-- local → {local:true}; remoto con sesión de un dispositivo → {local:false, device}; con LAMPSON_WEB_TOKEN → script
 task check_client(token, request)
-    let ip be text(ip of request)
-    when ip == "127.0.0.1" or ip == "::1" or ip == "::ffff:127.0.0.1"
+    let h be headers of request
+    -- un navegador en otra origin (CSRF, WebSocket abierto desde otra página, DNS rebinding) no pasa, local o remoto
+    when origin.cross_site(h)
+        give nothing
+    when origin.is_local(text(ip of request), h)
         give {"local": true}
     let want be env("LAMPSON_WEB_TOKEN", "")
     when want != "" and token == want
-        give {"local": false}
-    give nothing
+        give {"local": false, "device": nothing}
+    let s be auth.session_for(get(request.cookies, auth.COOKIE, nothing))
+    when s == nothing
+        give nothing
+    give {"local": false, "device": s["device"]}
+
+-- las páginas (no el API): un remoto sin sesión va a /login
+task page_allowed(request)
+    give check_client(nothing, request) != nothing
+
+task with_session(resp, request, sid)
+    give set_cookie(resp, auth.COOKIE, sid, {"max_age": auth.SESSION_MAX_DAYS * 86400, "secure": auth.secure_cookie(headers of request), "same_site": "Lax"})
 
 task hub_tick()
     give ws.tick()
 cron_every(15, hub_tick)
 
 serve on 8080
+    -- @bind
+    -- túneles (syn tunnel, cloudflared) y el edge de --domain llegan por loopback: así sus X-Forwarded-* llegan y
+    -- ip of request es el cliente real (lib/origin.syn)
+    trust proxy ["127.0.0.1", "::1"]
     max_streams 200
     auth with check_client
     static "./public"
 
     route "GET /"
+        when not page_allowed(request)
+            give redirect("/login", 302)
         give html(read_file("public/hub.html"))
 
+    -- ---- acceso remoto: páginas públicas de login/emparejar y su API ----
+    route "GET /login"
+        give html(read_file("public/login.html"))
+    route "GET /pair"
+        give html(read_file("public/login.html"))
+
+    -- ¿quién soy? (la UI decide si muestra «Dispositivos» o «cerrar sesión»)
+    route "GET /api/auth/me"
+        let u be check_client(nothing, request)
+        give {"authenticated": u != nothing, "local": u != nothing and u["local"], "device": when u == nothing then nothing otherwise get(u, "device", nothing), "has_devices": length(auth.devices()) > 0}
+
+    -- código de emparejamiento para el QR: SOLO desde esta PC
+    route "POST /api/auth/pair" requires auth
+        when not request.user["local"]
+            give fail(403, "el emparejamiento se inicia desde la PC donde corre lampson")
+        let p be auth.new_pairing()
+        give {"code": p["code"], "expires_in": p["expires_in"], "public_url": auth.public_url()}
+
+    route "GET /api/auth/public-url" requires auth
+        give {"public_url": auth.public_url()}
+    route "POST /api/auth/public-url" requires auth
+        when not request.user["local"]
+            give fail(403, "solo desde la PC")
+        expect body {url: text}
+        try
+            give {"public_url": auth.set_public_url(text((json of request)["url"]))}
+        recover err
+            give fail(400, text(err))
+
+    route "POST /api/auth/register/options"
+        rate_limit 20 per minute
+        expect body {code: text, name: text}
+        let b be json of request
+        when not auth.pairing_valid(text(b["code"]))
+            give fail(400, "el código de emparejamiento venció o ya se usó — generá otro desde la PC")
+        give auth.register_options(headers of request, text(b["name"]))
+
+    route "POST /api/auth/register"
+        rate_limit 20 per minute
+        let b be json of request
+        try
+            let r be auth.register(headers of request, get(b, "code", nothing), get(b, "challenge_id", nothing), get(b, "name", ""), get(b, "credential", {}))
+            give with_session(ok({"ok": true, "device": r["device"]}), request, r["sid"])
+        recover err
+            give fail(400, text(err))
+
+    route "POST /api/auth/login/options"
+        rate_limit 30 per minute
+        give auth.login_options(headers of request)
+
+    route "POST /api/auth/login"
+        rate_limit 30 per minute
+        let b be json of request
+        let r be nothing
+        try
+            set r to auth.login(headers of request, get(b, "challenge_id", nothing), get(b, "credential", {}))
+        recover err
+            give fail(400, text(err))
+        when r == nothing
+            give fail(401, "la passkey no coincide con un dispositivo emparejado de este dominio")
+        give with_session(ok({"ok": true, "device": r["device"]}), request, r["sid"])
+
+    route "POST /api/auth/logout"
+        when origin.cross_site(headers of request)
+            give fail(403, "otra origin")
+        let sid be get(request.cookies, auth.COOKIE, nothing)
+        when sid != nothing
+            auth.drop_session(sid)
+        give clear_cookie(ok({"ok": true}), auth.COOKIE)
+
+    route "GET /api/auth/devices" requires auth
+        give {"devices": auth.public_devices(get(request.user, "device", nothing)), "local": request.user["local"], "public_url": auth.public_url()}
+
+    route "POST /api/auth/devices/remove" requires auth
+        expect body {id: text}
+        give {"ok": auth.remove_device(text((json of request)["id"]))}
+
+    route "POST /api/auth/devices/rename" requires auth
+        expect body {id: text, name: text}
+        let b be json of request
+        give {"ok": auth.rename_device(text(b["id"]), text(b["name"]))}
+
     -- la UI de un workspace: el mismo index.html; el frontend deduce /w/<slug> de la URL (BASE en js/core.js).
     -- Sin barra final: el runtime normaliza "/w/x/" → "/w/x" (301), así que la ruta canónica es esta
     route "GET /w/:slug"
+        when not page_allowed(request)
+            give redirect("/login", 302)
         -- entrar a un workspace apagado lo enciende (y levanta la pausa manual): si alguien abre la URL es para usarlo
         let w be ws.get(params.slug)
         when w != nothing and ws.health(w) == nothing
@@ -66,7 +175,19 @@ serve on 8080
         give html(read_file("public/index.html"))
 
     route "GET /api/hub" requires auth
-        give {"ok": true, "port": ws.HUB_PORT, "idle_hours": ws.idle_hours(), "home": ws.home()}
+        give {"ok": true, "port": ws.HUB_PORT, "idle_hours": ws.idle_hours(), "home": ws.home(), "local": request.user["local"]}
+
+    -- ⚙ → Apagar o reiniciar: Lampson entero (hub, workspaces, edge). Lo hace cli.syn desacoplado, porque este proceso
+    -- muere en el medio. Apagar, solo desde esta PC: desde el celular no habría cómo volver a encenderlo
+    route "POST /api/hub/shutdown" requires auth
+        when not request.user["local"]
+            give fail(403, "apagar Lampson solo desde la PC donde corre: desde acá no podrías volver a encenderlo")
+        ws.cli_later("hub-stop")
+        give {"ok": true}
+
+    route "POST /api/hub/restart" requires auth
+        ws.cli_later("hub-reboot")
+        give {"ok": true}
 
     route "GET /api/workspaces" requires auth
         -- la caché del blackboard (tick + acciones) salvo ?fresh=1: la UI lo pide tras encender/apagar

package/lampson.ps1

@@ -1,10 +1,12 @@
-# lampson.ps1 — launcher Windows. Cada proyecto es un WORKSPACE con su propio proceso; un hub en :8080 los sirve a todos.
+# lampson.ps1 — launcher Windows. Cada proyecto es un WORKSPACE con su propio proceso; un hub en :8080 los sirve a todos.
 #
 #   cd C:\mi\proyecto ; lampson                 # terminal sobre este workspace (lo registra y lo arranca si hace falta)
 #   cd C:\mi\proyecto ; lampson --web           # abre http://127.0.0.1:8080/w/<slug>/ en el navegador
 #   lampson --workspace C:\otro\proyecto        # elegir la carpeta explícitamente
 #   lampson --hub start|stop|status|logs        # el servicio residente (workspaces + tareas programadas)
 #   lampson --install | --uninstall             # arrancar el hub al iniciar sesión (Tarea Programada)
+#   lampson --domain lampson.midominio.com --email vos@midominio.com   # HTTPS con tu dominio (opcional) · --domain off
+#   lampson --pair [https://tu-dominio]                                # QR en la terminal para emparejar el celular
 #   lampson --agent plan · --yolo|--strict|--ask · --update · --help
 #
 # Cómo funciona (ver SPEC-WORKSPACES.md): .lampson\ws\<slug>\ es el cwd del proceso del workspace, con una junction
@@ -15,13 +17,16 @@ $here = Split-Path -Parent $MyInvocation.MyCommand.Path
 $caller = (Get-Location).Path
 
 # --- args: acepta --flag y -Flag, sin distinguir mayúsculas ---
-$Workspace = ""; $Web = $false; $Agent = ""; $Perm = ""; $Hub = ""; $Install = ""
+$Workspace = ""; $Web = $false; $Agent = ""; $Perm = ""; $Hub = ""; $Install = ""; $Domain = $null; $Email = ""; $Pair = $null
 $i = 0
 while ($i -lt $args.Count) {
     $a = [string]$args[$i]
     switch -Regex ($a.ToLower()) {
         '^--?(web|w)$'          { $Web = $true }
         '^--?(hub|daemon|d)$'   { $i++; $Hub = if ($i -lt $args.Count) { ([string]$args[$i]).ToLower() } else { "status" } }
+        '^--?domain$'           { if ($i + 1 -lt $args.Count -and -not ([string]$args[$i + 1]).StartsWith("-")) { $i++; $Domain = [string]$args[$i] } else { $Domain = "" } }
+        '^--?email$'            { $i++; $Email = [string]$args[$i] }
+        '^--?pair$'             { if ($i + 1 -lt $args.Count -and -not ([string]$args[$i + 1]).StartsWith("-")) { $i++; $Pair = [string]$args[$i] } else { $Pair = "" } }
         '^--?install$'          { $Install = "install" }
         '^--?uninstall$'        { $Install = "uninstall" }
         '^--?(workspace|ws)$'   { $i++; $Workspace = [string]$args[$i] }
@@ -37,6 +42,12 @@ while ($i -lt $args.Count) {
     $i++
 }
 
+# motor mínimo: el hub y los workspaces declaran `trust proxy` (Synsema 0.6.42+; ver lib/origin.syn). Con uno viejo el
+# hub ni arranca: mejor decirlo acá que dejar un 502
+$MinEngine = [version]"0.6.42"
+$engine = ((& synsema --version 2>$null) -replace '^\D*', '').Trim()
+if (-not ($engine -as [version]) -or [version]$engine -lt $MinEngine) { Write-Error "lampson necesita synsema $MinEngine o más nuevo (tenés '$engine'): synsema update"; exit 1 }
+
 # skills externas globales (npx skills add -g → ~/.agents/skills; Claude Code → ~/.claude/skills), montadas bajo .lampson\
 # (una capability no puede apuntar a HOME); los workspaces las ven por su junction .lampson\global
 $skillMounts = @{ "skills-global" = (Join-Path $HOME ".agents\skills"); "skills-claude" = (Join-Path $HOME ".claude\skills") }
@@ -66,9 +77,34 @@ function Invoke-Cli([string]$cmd, [string]$ws) {
     return ($lines[-1] | ConvertFrom-Json)
 }
 
+# synsema escribe UTF-8; PowerShell decodifica lo que CAPTURA (Invoke-Cli) con la página de códigos de la consola
+# (CP850 en Windows en español): «dirección» salía «direcci├│n». UTF-8 mientras corre el script, y se restaura al salir.
+$prevOutEnc = [Console]::OutputEncoding
+try { [Console]::OutputEncoding = [System.Text.Encoding]::UTF8 } catch {}
 Push-Location $here
 try {
     $env:LAMPSON_HOME = $here
+    # --- dominio propio (opcional): lampson --domain [dominio|off] [--email vos@dominio] ---
+    if ($null -ne $Domain) {
+        $env:LAMPSON_DOMAIN = $Domain; $env:LAMPSON_EMAIL = $Email
+        $r = Invoke-Cli "domain" ""
+        exit 0
+    }
+    # --- emparejar un celular desde la terminal (VPS por SSH): lampson --pair [https://tu-dominio] ---
+    if ($null -ne $Pair) {
+        $env:LAMPSON_PAIR_URL = $Pair
+        $r = Invoke-Cli "pair" ""
+        if ($r.error) { exit 1 }
+        $mins = [math]::Round([double]$r.expires_in / 60)
+        Write-Host ""
+        Write-Host "Apuntá la cámara del celular a este QR y tocá «Crear passkey» (vale $mins minutos, un solo uso):"
+        Write-Host ""
+        if (Get-Command node -ErrorAction SilentlyContinue) { node (Join-Path $here "lib\tools\qr.js") $r.link } else { Write-Host "  (sin Node no puedo dibujar el QR: abrí el link de abajo en el celular)" }
+        Write-Host ""
+        Write-Host ("  o abrí en el celular: " + $r.link)
+        Write-Host ("  después entrás con la huella en " + $r.public_url)
+        exit 0
+    }
     # --- hub / servicio ---
     if ($Hub -ne "") {
         switch ($Hub) {
@@ -116,9 +152,14 @@ try {
         $env:LAMPSON_WORKSPACE = $target; $env:LAMPSON_WS = $r.slug; $env:LAMPSON_PORT = [string]$r.port
         if ($Agent -ne "") { $env:LAMPSON_AGENT = $Agent }
         if ($Perm -ne "") { $env:LAMPSON_PERMISSION = $Perm }
+        # juez de computer use (⚙ → Computer use): el runtime lo lee del entorno al arrancar
+        if ($r.judge_provider) { $env:SYNSEMA_JUDGE_PROVIDER = $r.judge_provider }
+        if ($r.judge_model) { $env:SYNSEMA_JUDGE_MODEL = $r.judge_model }
+        if ($r.judge_key) { $env:TYPESAFE_API_KEY = $r.judge_key }
         $envFile = Join-Path $here ".env"
         if (Test-Path -LiteralPath $envFile) { synsema run --env-file $envFile chat.syn } else { synsema run chat.syn }
     } finally { Pop-Location }
 } finally {
     Pop-Location
+    try { [Console]::OutputEncoding = $prevOutEnc } catch {}
 }

package/lampson.sh

@@ -3,15 +3,20 @@
 #   cd /mi/proyecto && lampson            # terminal sobre este workspace
 #   cd /mi/proyecto && lampson --web      # abre http://127.0.0.1:8080/w/<slug>/
 #   lampson --hub start|stop|status|logs|restart · --install (systemd --user) · --uninstall
+#   lampson --domain lampson.midominio.com --email vos@midominio.com   # HTTPS propio (opcional) · --domain off
+#   lampson --pair [https://tu-dominio]                                # QR en la terminal para emparejar el celular
 #   lampson --workspace /ruta [--agent plan] [--yolo|--strict|--ask] · --update
 set -euo pipefail
 here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 caller="$(pwd)"
-ws=""; web=0; hub=""; install=""
+ws=""; web=0; hub=""; install=""; domain="-"; email=""; pair_url="-"
 while [ $# -gt 0 ]; do
     case "$1" in
         --web) web=1 ;;
         --hub|--daemon) shift; hub="${1:-status}" ;;
+        --domain) if [ $# -gt 1 ] && [ "${2#-}" = "$2" ]; then shift; domain="$1"; else domain=""; fi ;;
+        --pair) if [ $# -gt 1 ] && [ "${2#-}" = "$2" ]; then shift; pair_url="$1"; else pair_url=""; fi ;;
+        --email) shift; email="${1:-}" ;;
         --install) install=install ;;
         --uninstall) install=uninstall ;;
         --workspace) shift; ws="$1" ;;
@@ -20,12 +25,18 @@ while [ $# -gt 0 ]; do
         --strict) export LAMPSON_PERMISSION=strict ;;
         --ask) export LAMPSON_PERMISSION=ask ;;
         --update) echo "actualizando Lampson en $here"; git -C "$here" pull --ff-only origin main; echo "lampson $(git -C "$here" rev-parse --short HEAD)"; exit $? ;;
-        -*) echo "uso: lampson [--web] [--hub start|stop|status|logs|restart] [--install|--uninstall] [--workspace RUTA] [--agent PERFIL] [--yolo|--strict|--ask] [--update]" >&2; exit 1 ;;
+        -*) echo "uso: lampson [--web] [--hub start|stop|status|logs|restart] [--domain DOMINIO|off [--email EMAIL]] [--pair [URL]] [--install|--uninstall] [--workspace RUTA] [--agent PERFIL] [--yolo|--strict|--ask] [--update]" >&2; exit 1 ;;
         *) ws="$1" ;;
     esac
     shift
 done
 export LAMPSON_HOME="$here"
+# motor mínimo: el hub y los workspaces declaran `trust proxy` (Synsema 0.6.42+; ver lib/origin.syn)
+min_engine="0.6.42"
+engine="$(synsema --version 2>/dev/null | sed 's/^[^0-9]*//')"
+if [ -z "$engine" ] || [ "$(printf '%s\n%s\n' "$min_engine" "$engine" | sort -V | head -n1)" != "$min_engine" ]; then
+    echo "lampson necesita synsema $min_engine o más nuevo (tenés '${engine:-ninguno}'): synsema update" >&2; exit 1
+fi
 # skills externas globales, montadas bajo .lampson/ (los workspaces las ven por .lampson/global)
 mkdir -p "$here/.lampson"
 for pair in "skills-global:$HOME/.agents/skills" "skills-claude:$HOME/.claude/skills"; do
@@ -45,6 +56,28 @@ cli() { # última línea = JSON
     echo "$out" | tail -n 1
 }
 json() { node -e "const j=JSON.parse(process.argv[1]);const v=j[process.argv[2]];console.log(typeof v==='object'?JSON.stringify(v):v)" "$1" "$2" 2>/dev/null || python3 -c "import json,sys;print(json.loads(sys.argv[1])[sys.argv[2]])" "$1" "$2"; }
+# dominio propio (opcional): HTTPS automático con Let's Encrypt delante del hub
+if [ "$domain" != "-" ]; then
+    (cd "$here" && LAMPSON_CMD=domain LAMPSON_DOMAIN="$domain" LAMPSON_EMAIL="$email" synsema run cli.syn | sed '$d')
+    exit 0
+fi
+# emparejar un celular desde la terminal (VPS por SSH): lampson --pair [https://tu-dominio]
+if [ "$pair_url" != "-" ]; then
+    r="$(cd "$here" && LAMPSON_CMD=pair LAMPSON_PAIR_URL="$pair_url" synsema run cli.syn)" || { echo "$r" >&2; exit 1; }
+    echo "$r" | sed '$d'
+    r="$(echo "$r" | tail -n 1)"
+    link="$(json "$r" link)"
+    case "$link" in https://*|http://*) ;; *) exit 1 ;; esac
+    secs="$(json "$r" expires_in)"
+    echo ""
+    echo "Apuntá la cámara del celular a este QR y tocá «Crear passkey» (vale $(( ${secs%.*} / 60 )) minutos, un solo uso):"
+    echo ""
+    if command -v node >/dev/null 2>&1; then node "$here/lib/tools/qr.js" "$link"; else echo "  (sin Node no puedo dibujar el QR: abrí el link de abajo en el celular)"; fi
+    echo ""
+    echo "  o abrí en el celular: $link"
+    echo "  después entrás con la huella en $(json "$r" public_url)"
+    exit 0
+fi
 if [ -n "$hub" ]; then
     case "$hub" in
         start) cli hub-start >/dev/null; echo "hub: http://127.0.0.1:8080" ;;
@@ -92,4 +125,9 @@ if [ "$web" = 1 ]; then
 fi
 cd "$here/$dir"
 export LAMPSON_WORKSPACE="$ws" LAMPSON_WS="$slug" LAMPSON_PORT="$port"
+# juez de computer use (⚙ → Computer use): el runtime lo lee del entorno al arrancar
+jp="$(json "$r" judge_provider)"; jm="$(json "$r" judge_model)"; jk="$(json "$r" judge_key)"
+[ -n "$jp" ] && export SYNSEMA_JUDGE_PROVIDER="$jp"
+[ -n "$jm" ] && export SYNSEMA_JUDGE_MODEL="$jm"
+[ -n "$jk" ] && export TYPESAFE_API_KEY="$jk"
 if [ -f "$here/.env" ]; then exec synsema run --env-file "$here/.env" chat.syn; else exec synsema run chat.syn; fi

package/lib/agents.syn

@@ -33,6 +33,7 @@ use "./provider.syn" as provider
 use "./prompt.syn" as prompt
 use "./mcp.syn" as mcp
 use "./plugins.syn" as plugins
+use "./computer.syn" as computer
 
 export let DIR be ".lampson/agents"
 let MAX_TASKS be 6
@@ -40,27 +41,27 @@ let PARALLEL be 4
 
 export let PROFILES be {
     "build": {
-        "tools": ["read", "write", "edit", "ls", "find", "grep", "lsp", "bash", "process", "memory", "todo", "skill", "mcp", "plugin", "schedule", "delegate"],
+        "tools": ["read", "write", "edit", "ls", "find", "grep", "lsp", "fetch", "bash", "process", "memory", "todo", "skill", "mcp", "plugin", "schedule", "delegate", "computer_use"],
         "steps": 40,
         "addendum": "You are in BUILD mode: you may read, edit, create files and run commands. Delegate exploration of large codebases to the `explore` agent and independent code review to the `review` agent when it saves context; several independent questions can go in one delegate call (they run in parallel)."
     },
     "plan": {
-        "tools": ["read", "ls", "find", "grep", "lsp", "memory", "todo", "skill", "delegate"],
+        "tools": ["read", "ls", "find", "grep", "lsp", "fetch", "memory", "todo", "skill", "delegate"],
         "steps": 30,
         "addendum": "You are in PLAN mode: READ-ONLY. You cannot edit files or run commands (those tools are not available). Investigate the codebase, then answer with a concrete, numbered implementation plan: files to touch, what changes in each, risks, and how to verify. Do not write code beyond short illustrative snippets."
     },
     "review": {
-        "tools": ["read", "ls", "find", "grep", "lsp", "bash", "process", "memory", "skill"],
+        "tools": ["read", "ls", "find", "grep", "lsp", "fetch", "bash", "process", "memory", "skill"],
         "steps": 25,
         "addendum": "You are a REVIEWER: read-only on files (no write/edit), but you may run commands (tests, linters, git diff). Find real bugs, missing error handling, security issues and violations of the project's conventions. Report findings as a list with file:line, severity and a suggested fix. Do not modify files."
     },
     "explore": {
-        "tools": ["read", "ls", "find", "grep", "lsp", "memory", "skill"],
+        "tools": ["read", "ls", "find", "grep", "lsp", "fetch", "memory", "skill"],
         "steps": 20,
         "addendum": "You are an EXPLORER: read-only. Locate the code relevant to the question (files, functions, line numbers) and report it concisely with paths and short excerpts. Do not propose changes."
     },
     "worker": {
-        "tools": ["read", "write", "edit", "ls", "find", "grep", "lsp", "bash", "process", "memory", "todo", "skill"],
+        "tools": ["read", "write", "edit", "ls", "find", "grep", "lsp", "fetch", "bash", "process", "memory", "todo", "skill", "computer_use"],
         "steps": 40,
         "addendum": "You are a WORKER sub-agent: implement exactly the scoped task you were given (read, edit, run tests), then report what you changed (files) and how you verified it. Stay inside the scope; if something outside it is needed, report it instead of doing it."
     }
@@ -93,14 +94,31 @@ export task addendum_for(name)
 task mcp_readonly_only(name)
     give not (name == "build" or name == "worker")
 
+-- tools del perfil que entran de verdad: computer_use está en build/worker pero solo cuando el usuario la
+-- encendió y el driver existe (lib/computer.syn) — si no, el modelo ni la ve
+export task tool_names(p)
+    require exec
+    require time
+    require env("LAMPSON_*")
+    require env("OS")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    when contains(p["tools"], "computer_use")
+        when not computer.available()
+            give where(p["tools"], (n) => n != "computer_use")
+    give p["tools"]
+
 export task registry_for(name)
+    require exec
+    require time
     require file(".lampson")
     require file(".lampson/*")
     require file("workspace")
     require file("workspace/*")
     require env("LAMPSON_*")
+    require env("OS")
     let p be profile(name)
-    let reg be tools.registry_subset(p["tools"])
+    let reg be tools.registry_subset(tool_names(p))
     when contains(p["tools"], "delegate")
         set reg["delegate"] to delegate
     each m in mcp.names(mcp_readonly_only(name))
@@ -110,13 +128,16 @@ export task registry_for(name)
     give reg
 
 export task catalog_for(name)
+    require exec
+    require time
     require file(".lampson")
     require file(".lampson/*")
     require file("workspace")
     require file("workspace/*")
     require env("LAMPSON_*")
+    require env("OS")
     let p be profile(name)
-    let cat be tools.catalog_subset(p["tools"])
+    let cat be tools.catalog_subset(tool_names(p))
     when contains(p["tools"], "delegate")
         set cat to append(cat, DELEGATE_SPEC)
     give cat + mcp.catalog(mcp_readonly_only(name)) + plugins.catalog(mcp_readonly_only(name))
@@ -155,7 +176,7 @@ task write_json(id, m)
     write_file(path(id, "json"), json_encode(m))
 
 task one_line(s, max)
-    let t be replace_text(replace_text(text(s), "\r", ""), "\n", " ⏎ ")
+    let t be replace(replace(text(s), "\r", ""), "\n", " ⏎ ")
     when length(t) > max
         give slice(t, 0, max) + "…"
     give t
@@ -313,7 +334,7 @@ export task run_child(spec)
         let system be {"role": "system", "content": prompt.build(env_info(cfg), p["addendum"] + CHILD_NOTE)}
         let full_brief be when spec["context"] == nothing or spec["context"] == "" then spec["brief"] otherwise spec["brief"] + "\n\nContext from the delegating agent:\n" + spec["context"]
         let messages be [system, {"role": "user", "content": full_brief}]
-        let opts be loop.default_opts(tools.registry_subset(p["tools"]), tools.catalog_subset(p["tools"]), nothing)
+        let opts be loop.default_opts(tools.registry_subset(tool_names(p)), tools.catalog_subset(tool_names(p)), nothing)
         set opts to loop.with_steps(opts, p["steps"])
         set opts to loop.with_mode(opts, when spec["mode"] == "yolo" then "yolo" otherwise "strict")
         set opts to loop.with_inbox(opts, child_inbox, id)

package/lib/approvals.syn

@@ -101,7 +101,7 @@ task notify(meta, links)
     let headers be {"Content-Type": "application/json", "User-Agent": "lampson"}
     let sec be secret_text()
     when sec != ""
-        set headers["X-Lampson-Signature"] to "sha256=" + hmac_sha256(body, sec)
+        set headers["X-Lampson-Signature"] to "sha256=" + decode(hmac(body, sec), "hex")
     try
         let r be http_post(url, body, headers)
         when not r["ok"]
@@ -147,7 +147,7 @@ export task answer_with_token(id, tok, decision)
     observe "approval:token:" + id as want
     when want == nothing
         give {"ok": false, "why": "expired"}
-    when not verify_hmac(id, hmac_sha256(id, tok), want)
+    when not verify_hmac(id, decode(hmac(id, tok), "hex"), want)
         give {"ok": false, "why": "bad token"}
     share nothing as "approval:token:" + id
     let v be when decision then "yes" otherwise "no"