lampson 0.1.4 → 0.2.0

package/README.md

@@ -4,7 +4,10 @@
 reads, searches, edits and runs commands through tools that are confined to that project by the
 language itself — and every step is visible, in the terminal or in a web UI.
 
-- **Terminal or web**: `lampson` (REPL) or `lampson --web` (http://127.0.0.1:8080).
+- **Workspaces, always on**: every project folder is a *workspace* with its own process (sessions, scheduled tasks,
+  MCP, lamps, dev servers), all behind one hub at http://127.0.0.1:8080 — open several at once and switch without
+  killing the others. `lampson` (terminal) and `lampson --web` (browser) open the workspace of the current folder;
+  `lampson --install` keeps the hub alive across logins.
 - **Any OpenAI- or Anthropic-compatible API** over raw HTTP: DeepSeek, Kimi, Groq, Grok, OpenRouter,
   Ollama, Anthropic, MiniMax… one `.env` line to switch.
 - **Least-privilege by construction**: each tool declares its capabilities; the runtime enforces
@@ -124,16 +127,38 @@ does the same with persistent sessions and memory.
 > Status: developed and tested on Windows 11; the Docker image (Ubuntu 24.04) is built by CI. The Linux/macOS
 > installer is written but not yet exercised on a real machine — issues welcome.
 
-## Scheduled tasks and the resident process
-
-Lampson can run things with nobody at the keyboard. Scheduled tasks run inside **any** open Lampson — the web UI
-or the terminal REPL (a background thread ticks every 30 s). To run them with nothing open:
+## Workspaces and the hub (how it runs)
 
 ```
-lampson --daemon start      # web UI + scheduler + approvals, in the background (synsema daemon)
-lampson --daemon status     # also: stop · logs · restart
+lampson                         # in a project folder: registers it as a workspace (first time), makes sure the hub and
+                                # the workspace's process are up, opens the terminal on it
+lampson --web                   # same, then opens http://127.0.0.1:8080/w/<slug> in the browser
+http://127.0.0.1:8080           # the workspaces screen: open one, create one (native folder dialog; a server-side
+                                # browser on a VPS), turn them on/off, life policy
+lampson --hub start|stop|status|logs|restart
+lampson --install               # Windows: Scheduled Task at logon · Linux: systemd --user unit (Restart=always)
 ```
 
+Why processes: in Synsema a tool's file capability is a literal path relative to the process cwd, so a workspace is
+a directory `~/lampson/.lampson/ws/<slug>/` with a junction `workspace` → your project (plus junctions to the
+install's `lib/`, `public/`, `skills/`, `lamps/`, `memory/`), and its own `.lampson/` state. Its process
+(`synsema serve web.syn --port 808N --bind 127.0.0.1`) only ever sees that folder. The hub (`hub.syn`, generated
+from `hub.tpl.syn`, one proxy route per workspace) is the only listener you use: it serves the UI and forwards
+`/w/<slug>/api/…` — SSE and the WebSocket terminal included (Synsema ≥ 0.6.12). Workspace processes are detached
+from the hub, so a hub restart never kills them. The hub is also the supervisor: every 15 s it starts what should
+be alive and stops what is idle (⚙ → hours of inactivity, `0` = never; a workspace with enabled scheduled tasks or
+policy «siempre vivo» stays up).
+
+On a VPS put the hub behind your domain (`synsema serve hub.syn --port 443 --domain … --tls-auto …` or your
+edge); workspace ports never leave loopback. `LAMPSON_PUBLIC_URL` = `https://host` and approval links carry
+`/w/<slug>` automatically.
+
+## Scheduled tasks and the resident process
+
+Lampson can run things with nobody at the keyboard. Scheduled tasks run inside the workspace's process (the hub
+keeps it alive while it has enabled tasks) — or inside the terminal REPL when no process is up (a background thread
+ticks every 30 s). `lampson --install` makes the hub survive reboots.
+
 Timezone, public URL and webhook are set from the ⚙ button of the web header (tabs: General · Aprobaciones a
 distancia · Proveedor; stored in `lampson/.lampson/config.json`, `.env` wins) or from `.env`.
 
@@ -230,9 +255,13 @@ run Lampson in a container.
 ## Architecture
 
 ```
-lampson.ps1 / .sh    launcher: mounts ./workspace, starts terminal or web
+lampson.ps1 / .sh    launcher: resolves the workspace (cli.syn), ensures hub + process, opens terminal or browser
+cli.syn              what launchers ask Synsema: ensure/list/hub-start/hub-stop/hub-restart (last line = JSON)
+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`)
-web.syn              HTTP server: POST /api/chat → SSE events; sessions, tree, file viewer, processes, ports
+web.syn              one process per workspace: /w/:slug/api/… → SSE chat, sessions, tree, processes, schedules…
 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/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', 'lampson.ps1', 'lampson.sh', 'lampson.cmd', '.env.example', 'README.md', 'LICENSE'];
+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'];
 
 // 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

@@ -722,7 +722,17 @@ agent Sched
         otherwise when waited >= 30
             set waited to 0
             try
-                lampson_sched_tick()
+                -- bajo el hub el proceso del workspace (LAMPSON_PORT) ya hace tick: no duplicar corridas
+                let port be env("LAMPSON_PORT", "")
+                let other be false
+                when port != ""
+                    try
+                        let hr be http_get("http://127.0.0.1:" + port + "/w/" + env("LAMPSON_WS", "x") + "/api/health", {"timeout": 2})
+                        set other to hr["ok"]
+                    recover e2
+                        set other to false
+                when not other
+                    lampson_sched_tick()
             recover err
                 print("[lampson] scheduler: " + text(err))
         otherwise

package/cli.syn

@@ -0,0 +1,68 @@
+-- cli.syn — lo que los launchers (lampson.ps1 / lampson.sh) le piden a Synsema. Corre con cwd = instalación.
+--
+--   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=list
+-- 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")
+require env("LAMPSON_*")
+require env("OS")
+require env("HOME")
+require env("USERPROFILE")
+require file(".lampson")
+require file(".lampson/*")
+require file.read("web.syn")
+require file.read(".env")
+require file.read("chat.syn")
+require file.read("hub.tpl.syn")
+require file("hub.syn")
+
+use "./lib/workspaces.syn" as ws
+
+let cmd be env("LAMPSON_CMD", "ensure")
+
+when cmd == "ensure"
+    let path be env("LAMPSON_WORKSPACE", "")
+    when path == ""
+        raise("LAMPSON_WORKSPACE required")
+    let w be ws.ensure(path)
+    when not ws.hub_alive()
+        ws.start_hub()
+    let hc be ws.health(w)
+    when hc == nothing
+        ws.start_ws(w)
+        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()}))
+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()
+    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-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)
+    sleep(1.5)
+    ws.stop_hub()
+    sleep(2)
+    when not ws.hub_alive()
+        ws.start_hub()
+    print(json_encode({"restarted": true}))
+otherwise when cmd == "list"
+    each w in ws.summary()
+        print((when w["alive"] then "● " otherwise "○ ") + w["slug"] + "  " + w["path"] + "  :" + text(w["port"]) + "  " + w["policy"])
+    print(json_encode({"count": length(ws.all())}))
+otherwise
+    raise("unknown LAMPSON_CMD " + cmd)

package/hub.tpl.syn

@@ -0,0 +1,127 @@
+-- hub.tpl.syn — PLANTILLA del hub. lib/workspaces.syn genera hub.syn (gitignored) reemplazando `-- @workspaces` por una
+-- ruta proxy por workspace; el hub corre con `synsema daemon start hub.syn --watch` y se reinicia solo al cambiar.
+--
+-- El hub es lo único que escucha hacia afuera (:8080; en un VPS, con --domain/--tls-auto):
+--   GET  /                    pantalla de workspaces (public/hub.html)
+--   GET  /w/<slug>            la UI de ese workspace (public/index.html; los assets /css /js los sirve el hub)
+--   *    /w/<slug>/api/…      proxy al proceso del workspace (127.0.0.1:808N) — SSE y WebSocket pasan (Synsema ≥ 0.6.12)
+--   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.
+
+intent: "Lampson hub: workspaces registry, supervisor and reverse proxy to one process per workspace"
+
+require serve(8080)
+require net("127.0.0.1")
+require time
+require exec
+require env("LAMPSON_*")
+require env("OS")
+require env("HOME")
+require env("USERPROFILE")
+require file(".lampson")
+require file(".lampson/*")
+require file.read("web.syn")
+require file.read(".env")
+require file.read("chat.syn")
+require file.read("hub.tpl.syn")
+require file("hub.syn")
+require file.read("public")
+require file.read("public/*")
+
+use "./lib/workspaces.syn" as ws
+use "./lib/settings.syn" as settings
+
+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"
+        give {"local": true}
+    let want be env("LAMPSON_WEB_TOKEN", "")
+    when want != "" and token == want
+        give {"local": false}
+    give nothing
+
+task hub_tick()
+    give ws.tick()
+cron_every(15, hub_tick)
+
+serve on 8080
+    max_streams 200
+    auth with check_client
+    static "./public"
+
+    route "GET /"
+        give html(read_file("public/hub.html"))
+
+    -- 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"
+        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()}
+
+    route "GET /api/workspaces" requires auth
+        give {"workspaces": ws.summary(), "idle_hours": ws.idle_hours()}
+
+    -- registrar una carpeta como workspace (y arrancarla)
+    route "POST /api/workspaces" requires auth
+        expect body {path: text}
+        let b be json of request
+        try
+            let w be ws.ensure(text(b["path"]))
+            ws.start_ws(w)
+            ws.wait_ready(w, 8)
+            give {"ok": true, "workspace": w, "url": "/w/" + w["slug"] + "/"}
+        recover err
+            give fail(400, text(err))
+
+    route "POST /api/workspaces/start" requires auth
+        expect body {slug: text}
+        let b be json of request
+        let w be ws.get(text(b["slug"]))
+        when w == nothing
+            give not_found("no such workspace")
+        ws.start_ws(w)
+        give {"ok": ws.wait_ready(w, 8)}
+
+    route "POST /api/workspaces/stop" requires auth
+        expect body {slug: text}
+        let b be json of request
+        let w be ws.get(text(b["slug"]))
+        when w == nothing
+            give not_found("no such workspace")
+        give {"ok": ws.stop_ws(w)}
+
+    route "POST /api/workspaces/remove" requires auth
+        expect body {slug: text}
+        let b be json of request
+        try
+            give {"ok": true, "result": ws.remove(text(b["slug"]))}
+        recover err
+            give fail(400, text(err))
+
+    -- política por workspace: auto | always | off
+    route "POST /api/workspaces/policy" requires auth
+        expect body {slug: text, policy: text}
+        let b be json of request
+        let w be ws.get(text(b["slug"]))
+        when w == nothing
+            give not_found("no such workspace")
+        when not contains(["auto", "always", "off"], text(b["policy"]))
+            give fail(400, "policy must be auto | always | off")
+        set w["policy"] to text(b["policy"])
+        ws.put(w)
+        give {"ok": true}
+
+    -- diálogo nativo del SO (PC); nothing → la UI usa el explorador propio
+    route "POST /api/workspaces/pick" requires auth
+        let p be ws.pick_folder()
+        give {"path": p, "native": p != nothing}
+
+    route "GET /api/workspaces/browse" requires auth
+        give ws.browse(when contains(query, "path") then text(query.path) otherwise "")
+
+    -- proxies generados (una por workspace registrado):
+    -- @workspaces

package/lampson.ps1

@@ -1,30 +1,29 @@
-# lampson.ps1 — launcher Windows. Monta el proyecto como ./workspace (junction) y arranca.
+# 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                 # el directorio ACTUAL es el workspace (REPL)
-#   cd C:\mi\proyecto ; lampson --web           # servidor web en http://127.0.0.1:8080  (también -Web)
-#   lampson --workspace C:\otro\proyecto        # elegir la ubicación explícitamente     (también -Workspace)
-#   lampson --agent plan                        # perfil inicial: build | plan | review | explore
-#   lampson --yolo | --strict | --ask            # permisos para comandos peligrosos (--dangerously-skip-permissions = --yolo)
-#   lampson --daemon start|stop|status|logs|restart   # proceso residente (web + tareas programadas + aprobaciones)
-#   lampson --update                            # actualizar Lampson (git pull) y salir
-#   lampson --help
+#   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 --agent plan · --yolo|--strict|--ask · --update · --help
 #
-# Por qué una junction: el scope file("./*") de Synsema v0.6.7 equivale a "*" (disco entero); el scope
-# file("workspace/*") sí confina. Montar el proyecto bajo un nombre literal es lo que hace real el
-# least-privilege de las tools (mismo modelo mental que `docker -v proyecto:/workspace`).
+# Cómo funciona (ver SPEC-WORKSPACES.md): .lampson\ws\<slug>\ es el cwd del proceso del workspace, con una junction
+# `workspace` al proyecto y junctions a lib/public/skills/lamps/memory de esta instalación. El registro y los procesos
+# los maneja lib/workspaces.syn vía cli.syn; este script solo resuelve la carpeta, llama a cli.syn y abre lo pedido.
 $ErrorActionPreference = "Stop"
 $here = Split-Path -Parent $MyInvocation.MyCommand.Path
 $caller = (Get-Location).Path
-$mount = Join-Path $here "workspace"
 
 # --- args: acepta --flag y -Flag, sin distinguir mayúsculas ---
-$Workspace = ""; $Web = $false; $Agent = ""; $Perm = ""; $Daemon = ""
+$Workspace = ""; $Web = $false; $Agent = ""; $Perm = ""; $Hub = ""; $Install = ""
 $i = 0
 while ($i -lt $args.Count) {
     $a = [string]$args[$i]
     switch -Regex ($a.ToLower()) {
         '^--?(web|w)$'          { $Web = $true }
-        '^--?(daemon|d)$'       { $i++; $Daemon = if ($i -lt $args.Count) { ([string]$args[$i]).ToLower() } else { "status" } }
+        '^--?(hub|daemon|d)$'   { $i++; $Hub = if ($i -lt $args.Count) { ([string]$args[$i]).ToLower() } else { "status" } }
+        '^--?install$'          { $Install = "install" }
+        '^--?uninstall$'        { $Install = "uninstall" }
         '^--?(workspace|ws)$'   { $i++; $Workspace = [string]$args[$i] }
         '^--?(agent|a)$'        { $i++; $Agent = [string]$args[$i] }
         '^--?(yolo|y|dangerously-skip-permissions)$' { $Perm = "yolo" }
@@ -32,71 +31,84 @@ while ($i -lt $args.Count) {
         '^--?(ask)$'            { $Perm = "ask" }
         '^--?(permission|p)$'   { $i++; $Perm = ([string]$args[$i]).ToLower() }
         '^--?(update|u)$'       { Write-Host "actualizando Lampson en $here"; git -C $here pull --ff-only origin main; Write-Host ("lampson " + (git -C $here rev-parse --short HEAD)); exit $LASTEXITCODE }
-        '^--?(help|h|\?)$'      { Get-Content $PSCommandPath | Select-Object -Skip 1 -First 10 | ForEach-Object { $_.TrimStart('#',' ') }; exit 0 }
+        '^--?(help|h|\?)$'      { Get-Content $PSCommandPath | Select-Object -Skip 1 -First 8 | ForEach-Object { $_.TrimStart('#',' ') }; exit 0 }
         default                 { if ($Workspace -eq "" -and -not $a.StartsWith("-")) { $Workspace = $a } else { Write-Error "argumento desconocido: $a (probá lampson --help)"; exit 1 } }
     }
     $i++
 }
 
-# --- resolver el proyecto: explícito > directorio actual (si no es el propio lampson) > montado previo ---
-if ($Workspace -eq "" -and $caller -ne $here) { $Workspace = $caller }
-if ($Workspace -ne "") {
-    if (-not (Test-Path -LiteralPath $Workspace -PathType Container)) { Write-Error "el workspace no existe o no es un directorio: $Workspace"; exit 1 }
-    $target = (Resolve-Path -LiteralPath $Workspace).Path
-    $home_ = [Environment]::GetFolderPath("UserProfile")
-    if ($target.TrimEnd('\') -eq $home_.TrimEnd('\') -or $target -match '^[A-Za-z]:\\?$') {
-        Write-Error "'$target' es tu carpeta personal / la raíz del disco, no un proyecto. Entrá al repo (cd) y volvé a correr lampson, o usá --workspace C:\ruta\al\proyecto"; exit 1
-    }
-    if ($target -eq $here) { Write-Error "no montes el propio directorio de lampson como workspace desde fuera; usá --workspace"; exit 1 }
-    if (Test-Path -LiteralPath $mount) {
-        $item = Get-Item -LiteralPath $mount -Force
-        if ($item.LinkType -ne "Junction") { Write-Error "./workspace existe y no es una junction; movelo antes de montar otro proyecto"; exit 1 }
-        # un daemon/web corriendo sobre OTRO proyecto (latido reciente del scheduler) quedaría apuntando a este: aviso
-        $prev = $item.Target; if ($prev -is [array]) { $prev = $prev[0] }
-        $hb = Join-Path $here ".lampson\schedules.heartbeat"
-        if ($prev -and $prev.TrimEnd('\').ToLower() -ne $target.TrimEnd('\').ToLower() -and (Test-Path -LiteralPath $hb) -and ((Get-Date) - (Get-Item -LiteralPath $hb).LastWriteTime).TotalSeconds -lt 90) {
-            Write-Host "AVISO: hay un lampson (web/daemon) corriendo sobre $prev; al montar $target sus tareas programadas quedan en pausa. Paralo o reinicialo desde su carpeta: lampson --daemon restart" -ForegroundColor Yellow
-        }
-        $item.Delete()
-    }
-    New-Item -ItemType Junction -Path $mount -Target $target | Out-Null
-} elseif (-not (Test-Path -LiteralPath $mount)) {
-    Write-Error "no hay workspace: corré lampson desde el directorio del proyecto, o lampson --workspace C:\ruta"; exit 1
-}
-$target = (Get-Item -LiteralPath $mount -Force).Target
-if ($target -is [array]) { $target = $target[0] }
-
-# --- skills externas globales (npx skills add -g → ~/.agents/skills; las de Claude Code → ~/.claude/skills) ---
-# Se montan como junction bajo .lampson/ porque una capability no puede apuntar a una ruta dinámica (HOME).
+# 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") }
 New-Item -ItemType Directory -Force (Join-Path $here ".lampson") | Out-Null
 foreach ($k in $skillMounts.Keys) {
     $link = Join-Path $here ".lampson\$k"; $src = $skillMounts[$k]
-    if (Test-Path -LiteralPath $link) { $li = Get-Item -LiteralPath $link -Force; if ($li.LinkType -eq "Junction") { $li.Delete() } }
-    if (Test-Path -LiteralPath $src -PathType Container) { New-Item -ItemType Junction -Path $link -Target $src | Out-Null }
+    if (-not (Test-Path -LiteralPath $link) -and (Test-Path -LiteralPath $src -PathType Container)) { New-Item -ItemType Junction -Path $link -Target $src | Out-Null }
+}
+
+function Invoke-Cli([string]$cmd, [string]$ws) {
+    # cli.syn imprime la respuesta como la ÚLTIMA línea (JSON)
+    $env:LAMPSON_CMD = $cmd; if ($ws -ne "") { $env:LAMPSON_WORKSPACE = $ws }
+    $out = & synsema run cli.syn 2>&1
+    if ($LASTEXITCODE -ne 0) { $out | ForEach-Object { Write-Host $_ }; throw "cli.syn falló ($cmd)" }
+    $lines = @($out | ForEach-Object { [string]$_ })
+    $lines | Select-Object -SkipLast 1 | ForEach-Object { Write-Host $_ }
+    return ($lines[-1] | ConvertFrom-Json)
 }
 
-# --- arrancar desde el directorio de lampson (ahí viven .env, lib/, skills/, .lampson/) ---
-# Push/Pop: si PowerShell ejecuta este .ps1 en la shell del usuario (pasa cuando lampson.ps1 y lampson.cmd
-# comparten nombre en el PATH), el cwd del usuario debe quedar como estaba al salir.
 Push-Location $here
 try {
-    $env:LAMPSON_WORKSPACE = $target
-    if ($Agent -ne "") { $env:LAMPSON_AGENT = $Agent }
-    if ($Perm -ne "") { $env:LAMPSON_PERMISSION = $Perm }
-    if ($Daemon -ne "") {
-        # proceso residente: web.syn en background (synsema daemon, sin config del sistema; para producción,
-        # systemd/NSSM con `synsema serve web.syn`). Ejecuta las tareas programadas y atiende aprobaciones por link.
-        if ($Daemon -notmatch '^(start|stop|status|logs|restart)$') { Write-Error "uso: lampson --daemon start|stop|status|logs|restart"; exit 1 }
-        if ($Daemon -eq "start" -or $Daemon -eq "restart") { Write-Host "Lampson daemon · workspace: $target · http://127.0.0.1:8080" }
-        synsema daemon $Daemon web.syn
-    } elseif ($Web) {
-        Write-Host "Lampson web · workspace: $target"
-        Write-Host "abrí http://127.0.0.1:8080   (Ctrl+C para parar)"
-        synsema serve web.syn
-    } else {
-        synsema run chat.syn
+    $env:LAMPSON_HOME = $here
+    # --- hub / servicio ---
+    if ($Hub -ne "") {
+        switch ($Hub) {
+            "start"   { $r = Invoke-Cli "hub-start" ""; Write-Host "hub: http://127.0.0.1:8080" }
+            "stop"    { $r = Invoke-Cli "hub-stop" ""; Write-Host "hub y workspaces parados" }
+            "status"  { $r = Invoke-Cli "hub-status" ""; Write-Host ("hub " + $(if ($r.alive) { "● vivo · http://127.0.0.1:8080" } else { "○ parado" })); foreach ($w in $r.workspaces) { Write-Host ("  " + $(if ($w.alive) { "●" } else { "○" }) + " " + $w.name + "  " + $w.path + "  " + $w.policy) } }
+            "logs"    { if (Test-Path ".lampson\hub.log") { Get-Content ".lampson\hub.log" -Tail 40 } else { Write-Host "sin log todavía" } }
+            "restart" { $null = Invoke-Cli "hub-stop" ""; Start-Sleep 1; $null = Invoke-Cli "hub-start" ""; Write-Host "hub reiniciado" }
+            default   { Write-Error "uso: lampson --hub start|stop|status|logs|restart"; exit 1 }
+        }
+        exit 0
+    }
+    # --- arranque al iniciar sesión: Tarea Programada que corre el hub (synsema daemon, --watch) ---
+    if ($Install -eq "install") {
+        $cmd = "cmd /c cd /d `"$here`" && set LAMPSON_HOME=$here && synsema serve hub.syn > .lampson\hub.log 2>&1"
+        schtasks /Create /F /TN "Lampson hub" /SC ONLOGON /TR $cmd | Out-Null
+        Write-Host "instalado: el hub de Lampson arranca al iniciar sesión (Tarea Programada «Lampson hub»). Arrancándolo ahora…"
+        $null = Invoke-Cli "hub-start" ""
+        exit 0
+    }
+    if ($Install -eq "uninstall") { schtasks /Delete /F /TN "Lampson hub" | Out-Null; Write-Host "quitado el arranque al iniciar sesión (el hub sigue corriendo hasta lampson --hub stop)"; exit 0 }
+
+    # --- resolver el proyecto: explícito > directorio actual (si no es el propio lampson) ---
+    if ($Workspace -eq "" -and $caller -ne $here) { $Workspace = $caller }
+    if ($Workspace -eq "") { Write-Error "corré lampson desde la carpeta del proyecto, o lampson --workspace C:\ruta (lampson --hub status lista los workspaces)"; exit 1 }
+    if (-not (Test-Path -LiteralPath $Workspace -PathType Container)) { Write-Error "el workspace no existe o no es un directorio: $Workspace"; exit 1 }
+    $target = (Resolve-Path -LiteralPath $Workspace).Path
+    $home_ = [Environment]::GetFolderPath("UserProfile")
+    if ($target.TrimEnd('\') -eq $home_.TrimEnd('\') -or $target -match '^[A-Za-z]:\\?$') {
+        Write-Error "'$target' es tu carpeta personal / la raíz del disco, no un proyecto. Entrá al repo (cd) y volvé a correr lampson, o usá --workspace C:\ruta\al\proyecto"; exit 1
+    }
+    if ($target -eq $here) { Write-Error "no montes el propio directorio de lampson como workspace"; exit 1 }
+
+    # registrar/preparar el workspace y asegurar hub + proceso
+    $r = Invoke-Cli "ensure" $target
+    $wsDir = Join-Path $here ($r.dir -replace '/', '\')
+    if ($Web) {
+        Write-Host ("Lampson web · " + $r.url + "   (workspace " + $r.slug + $(if ($r.alive) { " ● vivo" } else { " ○ arrancando" }) + ")")
+        Start-Process $r.url
+        exit 0
     }
+    # terminal: chat.syn dentro del directorio del workspace (misma junction `workspace` que el proceso web)
+    Push-Location $wsDir
+    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 }
+        $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
 }

package/lampson.sh

@@ -1,56 +1,88 @@
 #!/usr/bin/env bash
-# lampson.sh — launcher unix. El directorio ACTUAL es el workspace (o --workspace /ruta).
-#   cd /mi/proyecto && lampson            # REPL   (con lampson/ en el PATH)
-#   cd /mi/proyecto && lampson --web      # servidor web en http://127.0.0.1:8080
-#   lampson --workspace /otro/proyecto [--web] [--agent plan]
-#   lampson --daemon start|stop|status|logs|restart   # proceso residente (web + tareas programadas + aprobaciones)
+# lampson.sh — launcher unix. Cada proyecto es un WORKSPACE con su propio proceso; un hub en :8080 los sirve a todos.
+#   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 --workspace /ruta [--agent plan] [--yolo|--strict|--ask] · --update
 set -euo pipefail
 here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 caller="$(pwd)"
-ws=""; web=0; daemon=""
+ws=""; web=0; hub=""; install=""
 while [ $# -gt 0 ]; do
     case "$1" in
         --web) web=1 ;;
-        --daemon) shift; daemon="${1:-status}" ;;
+        --hub|--daemon) shift; hub="${1:-status}" ;;
+        --install) install=install ;;
+        --uninstall) install=uninstall ;;
         --workspace) shift; ws="$1" ;;
         --agent) shift; export LAMPSON_AGENT="$1" ;;
         --yolo|--dangerously-skip-permissions) export LAMPSON_PERMISSION=yolo ;;
         --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] [--daemon start|stop|status|logs|restart] [--workspace RUTA] [--agent PERFIL] [--yolo|--strict|--ask] [--update]" >&2; exit 1 ;;
+        -*) echo "uso: lampson [--web] [--hub start|stop|status|logs|restart] [--install|--uninstall] [--workspace RUTA] [--agent PERFIL] [--yolo|--strict|--ask] [--update]" >&2; exit 1 ;;
+        *) ws="$1" ;;
     esac
     shift
 done
-[ -z "$ws" ] && [ "$caller" != "$here" ] && ws="$caller"
-if [ -n "$ws" ]; then
-    [ -d "$ws" ] || { echo "el workspace no existe o no es un directorio: $ws" >&2; exit 1; }
-    ws="$(cd "$ws" && pwd)"
-    if [ -e "$here/workspace" ] && [ ! -L "$here/workspace" ]; then echo "./workspace existe y no es un symlink" >&2; exit 1; fi
-    # un daemon/web corriendo sobre OTRO proyecto (latido reciente del scheduler) quedaría apuntando a este: aviso
-    if [ -L "$here/workspace" ] && [ -f "$here/.lampson/schedules.heartbeat" ]; then
-        prev="$(readlink -f "$here/workspace")"
-        if [ "$prev" != "$ws" ] && [ $(( $(date +%s) - $(stat -c %Y "$here/.lampson/schedules.heartbeat") )) -lt 90 ]; then
-            echo "AVISO: hay un lampson (web/daemon) corriendo sobre $prev; al montar $ws sus tareas programadas quedan en pausa. Paralo o reinicialo desde su carpeta: lampson --daemon restart" >&2
-        fi
-    fi
-    rm -f "$here/workspace"; ln -s "$ws" "$here/workspace"
-elif [ ! -e "$here/workspace" ]; then
-    echo "no hay workspace: corré lampson desde el directorio del proyecto, o --workspace /ruta" >&2; exit 1
-fi
-export LAMPSON_WORKSPACE="$(readlink -f "$here/workspace")"
-# skills externas globales (npx skills add -g → ~/.agents/skills; Claude Code → ~/.claude/skills), montadas bajo .lampson/
+export LAMPSON_HOME="$here"
+# 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
     link="$here/.lampson/${pair%%:*}"; src="${pair#*:}"
-    [ -L "$link" ] && rm -f "$link"
-    [ -d "$src" ] && ln -s "$src" "$link"
+    [ -e "$link" ] || { [ -d "$src" ] && ln -s "$src" "$link"; } || true
 done
-echo "workspace -> $LAMPSON_WORKSPACE"
-cd "$here"
-if [ -n "$daemon" ]; then
-    # proceso residente en background (synsema daemon: sin arranque al boot ni reinicio; para producción, systemd
-    # con `synsema serve web.syn`). Ejecuta las tareas programadas y atiende aprobaciones por link.
-    case "$daemon" in start|stop|status|logs|restart) ;; *) echo "uso: lampson --daemon start|stop|status|logs|restart" >&2; exit 1 ;; esac
-    exec synsema daemon "$daemon" web.syn
-elif [ "$web" = 1 ]; then echo "web: http://127.0.0.1:8080"; exec synsema serve web.syn; else exec synsema run chat.syn; fi
+cli() { # última línea = JSON
+    local out; out="$(cd "$here" && LAMPSON_CMD="$1" LAMPSON_WORKSPACE="${2:-}" synsema run cli.syn)" || { echo "$out" >&2; exit 1; }
+    echo "$out" | sed '$d' >&2 || true
+    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"; }
+if [ -n "$hub" ]; then
+    case "$hub" in
+        start) cli hub-start >/dev/null; echo "hub: http://127.0.0.1:8080" ;;
+        stop) cli hub-stop >/dev/null; echo "hub y workspaces parados" ;;
+        status) r="$(cli hub-status)"; echo "hub $( [ "$(json "$r" alive)" = "true" ] && echo '● vivo · http://127.0.0.1:8080' || echo '○ parado')"; (cd "$here" && LAMPSON_CMD=list synsema run cli.syn | sed '$d') ;;
+        logs) [ -f "$here/.lampson/hub.log" ] && tail -n 40 "$here/.lampson/hub.log" || echo "sin log todavía" ;;
+        restart) cli hub-stop >/dev/null; sleep 1; cli hub-start >/dev/null; echo "hub reiniciado" ;;
+        *) echo "uso: lampson --hub start|stop|status|logs|restart" >&2; exit 1 ;;
+    esac
+    exit 0
+fi
+if [ "$install" = install ]; then
+    unit="$HOME/.config/systemd/user/lampson-hub.service"; mkdir -p "$(dirname "$unit")"
+    cat > "$unit" <<EOF
+[Unit]
+Description=Lampson hub (workspaces, tareas programadas, proxy)
+After=network.target
+[Service]
+WorkingDirectory=$here
+Environment=LAMPSON_HOME=$here
+ExecStart=$(command -v synsema) serve hub.syn
+Restart=always
+RestartSec=3
+TimeoutStopSec=20
+[Install]
+WantedBy=default.target
+EOF
+    (cd "$here" && LAMPSON_CMD=hub-stop synsema run cli.syn >/dev/null 2>&1 || true)
+    systemctl --user daemon-reload && systemctl --user enable --now lampson-hub.service && echo "instalado: systemd --user lampson-hub.service (arranca con tu sesión; 'loginctl enable-linger $USER' para que viva sin sesión abierta)"
+    exit 0
+fi
+if [ "$install" = uninstall ]; then systemctl --user disable --now lampson-hub.service || true; rm -f "$HOME/.config/systemd/user/lampson-hub.service"; systemctl --user daemon-reload; echo "quitado"; exit 0; fi
+# --- proyecto ---
+[ -z "$ws" ] && [ "$caller" != "$here" ] && ws="$caller"
+[ -n "$ws" ] || { echo "corré lampson desde la carpeta del proyecto, o --workspace /ruta (lampson --hub status lista los workspaces)" >&2; exit 1; }
+[ -d "$ws" ] || { echo "el workspace no existe o no es un directorio: $ws" >&2; exit 1; }
+ws="$(cd "$ws" && pwd -P)"
+[ "$ws" = "$HOME" ] || [ "$ws" = "/" ] && { echo "'$ws' no es un proyecto" >&2; exit 1; }
+r="$(cli ensure "$ws")"
+slug="$(json "$r" slug)"; port="$(json "$r" port)"; url="$(json "$r" url)"; dir="$(json "$r" dir)"
+if [ "$web" = 1 ]; then
+    echo "Lampson web · $url   (workspace $slug)"
+    (xdg-open "$url" >/dev/null 2>&1 || open "$url" >/dev/null 2>&1 || true)
+    exit 0
+fi
+cd "$here/$dir"
+export LAMPSON_WORKSPACE="$ws" LAMPSON_WS="$slug" LAMPSON_PORT="$port"
+if [ -f "$here/.env" ]; then exec synsema run --env-file "$here/.env" chat.syn; else exec synsema run chat.syn; fi