lampson 0.1.3 → 0.1.4

package/.env.example

@@ -27,3 +27,12 @@ LAMPSON_API_KEY=sk-...
 
 # Reanudar una sesión en chat.syn
 # LAMPSON_SESSION=20260826-233000
+
+# Tareas programadas y aprobaciones a distancia (proceso residente: lampson --daemon start)
+# LAMPSON_TZ=-03:00              # zona horaria para "daily 09:00" (default: la del sistema, `date +%z`)
+# LAMPSON_PUBLIC_URL=https://lampson.midominio.com   # URL por la que se llega a este lampson desde afuera (túnel, VPS,
+#                                # edge Synsema con TLS): con esto cada aprobación pendiente trae links de un solo uso
+#                                # (GET /approve/<id>/<token>?d=yes|no) para decidir desde el móvil
+# 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>)

package/README.md

@@ -29,6 +29,14 @@ language itself — and every step is visible, in the terminal or in a web UI.
   under a capability ceiling, or any executable (js, py, sh…). Global in `lampson/lamps/<name>/`, per
   project in `.lampson/lamps/<name>/` (the agent can write those). **Off by default**: you turn them on
   from the top bar of the web UI or `/lamps on <name>`; their tools join the catalog as `lamp_<lamp>_<tool>`.
+- **Scheduled tasks**: "every 6h", "daily 09:00", "mon,wed 08:30" — a lamp tool, a fixed shell command, or a
+  full unattended agent run from a prompt with a permission envelope fixed when you create it (`strict` /
+  `ask` / `yolo`). They run inside Lampson's resident process (`lampson --daemon start`, or the open web UI),
+  the run's session shows up as `⏰ name`, and a webhook can receive each result (for "search and send me" tasks).
+- **Approvals from anywhere**: an unattended run that hits something dangerous waits for you — in the web UI
+  («Aprobaciones»), and, with `LAMPSON_PUBLIC_URL` + `LAMPSON_WEBHOOK_URL`, through a signed webhook carrying
+  one-time **decision links** you can open from your phone (Telegram, mail, Slack…). Never auto-approved:
+  no answer in time = denied.
 - **Project memory**: the agent keeps its own notes per project (`memory/<project>/*.md`, outside
   the repo) — how to run it, gotchas, decisions — and rereads them in the next session. You can read
   and edit them (web panel, `/memory`).
@@ -116,6 +124,46 @@ 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:
+
+```
+lampson --daemon start      # web UI + scheduler + approvals, in the background (synsema daemon)
+lampson --daemon status     # also: stop · logs · restart
+```
+
+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`.
+
+Create a task from the chat («todos los días a las 9 corré los tests y avisame» — the agent calls the
+`schedule` tool and asks you to approve the task, showing exactly what will run and with which permissions),
+from the web sidebar («Programadas» → +), or from the terminal (`/schedule add <json>`). Three kinds:
+
+| kind | what runs | authorization |
+|---|---|---|
+| `lamp` | a tool of a lamp that is ON | turning the lamp on |
+| `bash` | one fixed command (must finish on its own) | approved once, at creation |
+| `prompt` | a full agent turn with your instructions and a profile (`build` / `review` / `plan` / `explore`) | the permission envelope: `strict` (dangerous → denied), `ask` (dangerous → approval request, denied if unanswered within `approval_timeout`, 2 h by default), `yolo` |
+
+Schedules: `every 6h` · `every 30m` · `daily 09:00` · `mon,wed 08:30` · `weekdays 09:00` (local time; `LAMPSON_TZ`
+overrides). Synsema's `cron_every` is a pure interval, so a 30 s tick in `web.syn` translates it to wall-clock time;
+a run missed while the daemon was down executes when it comes back and is marked as late. State lives in
+`.lampson/schedules.json`, logs in `.lampson/schedules/<id>.log`; a `prompt` run also leaves a normal session (`⏰ name`)
+with its trace. `notify` = a webhook URL that receives each result as JSON.
+
+**Approving from your phone.** Set `LAMPSON_PUBLIC_URL` (how this Lampson is reached from outside — a tunnel, a VPS,
+or a Synsema edge with TLS in front) and `LAMPSON_WEBHOOK_URL` (+ `LAMPSON_WEBHOOK_SECRET`, HMAC-SHA256 in
+`X-Lampson-Signature`). Every pending approval — from a scheduled run or from the chat — POSTs `{id, message, why,
+expires_at, respond_link_yes, respond_link_no}`; forward the links wherever you read (n8n, a bot, a 6-line `.syn`).
+`GET /approve/<id>/<token>?d=yes|no` is public on purpose: the 32-byte one-time token is the authorization, and it
+dies with the deadline. `GET /api/approvals` (loopback) lists what is pending, never the tokens.
+
+For a real server use systemd (`synsema serve web.syn`, `Restart=always`) instead of `synsema daemon`, which has no
+boot start / crash restart. One box, several projects: one `web.syn` per project on its own port, behind a Synsema
+edge that terminates TLS and routes by host (see the Synsema deploy docs).
+
 ## Use
 
 ```bash
@@ -185,7 +233,13 @@ run Lampson in a container.
 lampson.ps1 / .sh    launcher: mounts ./workspace, starts terminal or web
 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
-public/index.html    web UI (no build step, no dependencies)
+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
+  js/core.js         shared state + helpers ($, esc, md, add, api, showPane/showText, inlineConfirm, debounce, empty)
+  js/panel.js        THE modal component: one shell, three layouts (browse = search + list + detail, tabs, form)
+  js/<view>.js       one file per thing on screen: sessions, chat, tree, terminal, procs, agents, memory, todo,
+                     mcp, lsp, lamps, schedules, approvals, config (+ provider), update, events (SSE), app (boot)
 lib/
   provider.syn       config from .env · chat(cfg, messages, catalog) · retry with backoff
   loop.syn           run_turn(): LLM → tool calls → permissions → call_tool → results → repeat; doom-loop guard; compaction

package/chat.syn

@@ -14,6 +14,7 @@ require net
 require time
 require stdin
 require exec
+require random
 require env("LAMPSON_*")
 require env("OS")
 require secret("LAMPSON_*")
@@ -51,6 +52,9 @@ use "./lib/mcp.syn" as mcp
 use "./lib/lamps.syn" as lamps
 use "./lib/lsp.syn" as lsp
 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
 
 -- ---------- UI de terminal ----------
 -- Colores ANSI (Windows Terminal, PowerShell 7, cualquier terminal moderna). LAMPSON_NO_COLOR=1 los apaga.
@@ -344,6 +348,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)"],
     ["/lamps", "[on <nombre> | off <nombre> | run <lámpara> <tool> [json] | remove <nombre>]", "lámparas (plugins de tools): listar, encender o apagar (global: lampson/lamps/ · proyecto: .lampson/lamps/)"],
     ["/lsp", "[add <typescript|python|rust|go|css|html> [--project] | add <nombre> <comando…> --ext .x=lang | remove <nombre>]", "language servers (navegación semántica: symbols/definition/references/hover); arrancan en la primera consulta"],
+    ["/schedule", "[add <json> | run <id> | on <id> | off <id> | remove <id> | log <id>]", "tareas programadas (cada 6h, todos los días a las 9…): lámpara, comando o corrida del agente; corren mientras lampson esté abierto (o con lampson --daemon start, sin nada abierto)"],
+    ["/approve", "<id> yes|no", "responder una aprobación pendiente de una tarea programada que corre en background"],
     ["/out", "[n]", "resultado completo de la última tool del turno (n = contar hacia atrás: /out 2 es la anteúltima)"],
     ["/verbose", "", "alternar: mostrar SIEMPRE el output completo de cada tool (queda guardado en config.json)"],
     ["/trace", "[n]", "traza legible de esta sesión (pasos, tools, tiempos, tokens, errores): .lampson/trace/<sesión>.log"],
@@ -403,6 +409,16 @@ task complete_args(cmd, head, last)
         when trim(head) == "add"
             give sort_by(keys(lsp.PRESETS), (x) => x)
         give ["--project", "--ext"]
+    when cmd == "/approve"
+        when first
+            give apply((a) => a["id"], approvals.pending())
+        give ["yes", "no"]
+    when cmd == "/schedule"
+        when first
+            give ["add", "run", "on", "off", "remove", "log"]
+        when starts_with(trim(head), "add")
+            give []
+        give apply((s) => s["id"], schedule.summary())
     when cmd == "/agent"
         give ["build", "plan", "review", "explore", "worker"]
     when cmd == "/model"
@@ -672,6 +688,47 @@ task opts_for(p, mode)
 task lampson_subagent(spec_json)
     give agents.run_child_json(spec_json)
 
+-- Tareas programadas TAMBIÉN en la terminal: `cron_every` no corre mientras el hilo principal está en el teclado,
+-- pero un `agent` sí (hilo real, como el Spinner). Cada 30 s llama al tick (heartbeat + corridas vencidas); una
+-- corrida `prompt` transcurre al lado del chat sin tocar su sesión (blackboard lampson:sched:session) y si pide
+-- permiso lo dice por consola: /approve <id> yes|no (o link/webhook si están configurados).
+task lampson_sched_tick()
+    give sched_run.tick()
+
+agent Sched
+    require net
+    require time
+    require exec
+    require random
+    require env("LAMPSON_*")
+    require env("OS")
+    require secret("LAMPSON_*")
+    require file("workspace")
+    require file("workspace/*")
+    require file.read("skills")
+    require file.read("skills/*")
+    require file.read("lamps")
+    require file.read("lamps/*")
+    require file("memory")
+    require file("memory/*")
+    require file(".lampson")
+    require file(".lampson/*")
+    let alive be true
+    let waited be 25
+    while alive
+        observe "lampson:spinner:stop" as st
+        when st == true
+            set alive to false
+        otherwise when waited >= 30
+            set waited to 0
+            try
+                lampson_sched_tick()
+            recover err
+                print("[lampson] scheduler: " + text(err))
+        otherwise
+            sleep(1)
+            set waited to waited + 1
+
 -- !comando del usuario en un pseudo-terminal: la salida se ve EN VIVO y, si el proceso se queda esperando
 -- (prompt y/N, contraseña, REPL, `npm init`…), lo que escribas se le manda como teclas + Enter.
 -- Enter vacío = seguir esperando · ^C = cortar. Devuelve la salida (sin ANSI) para el contexto del agente.
@@ -765,6 +822,7 @@ banner(env_info["cwd"], cfg, profile, opts["permission_mode"], sid)
 share nothing as "lampson:busy"
 share false as "lampson:spinner:stop"
 spawn Spinner with esc = ESC, color = COLOR
+spawn Sched
 flush()
 
 let total_usage be {"input": 0, "output": 0}
@@ -1005,6 +1063,71 @@ while running
                 each s in ss
                     print("  " + (when s["status"] == "ready" then green("● ") otherwise (when s["status"] == "error" or s["status"] == "exited" then red("○ ") otherwise dim("○ "))) + pad(s["name"], 12) + dim(pad(s["scope"], 8) + pad(s["status"], 8) + join(s["extensions"], " ") + "  $ " + s["command"]) + (when s["error"] != nothing then red("  " + text(s["error"])) otherwise ""))
                 print("  " + dim("idle = arranca en la primera consulta del agente"))
+        otherwise when input == "/schedule" or starts_with(input, "/schedule ")
+            -- tareas programadas (lib/schedule.syn). Crear: JSON, o pedírselo al agente ("todos los días a las 9 corré…").
+            -- Las corre el daemon (web.syn con `lampson --daemon start`); `/schedule run` las corre acá mismo, con
+            -- el menú de aprobación de la terminal si la tarea es `ask`.
+            let srest be trim(slice(input, 9, length(input)))
+            let stoks be where(split(srest, " "), (x) => x != "")
+            let sact be when length(stoks) > 0 then stoks[0] otherwise ""
+            let sid_arg be when length(stoks) > 1 then stoks[1] otherwise ""
+            when sact == "add"
+                let sjson be trim(slice(srest, 3, length(srest)))
+                when sjson == ""
+                    print("  uso: /schedule add {\"name\": \"…\", \"when\": \"daily 09:00\", \"action\": {\"type\": \"bash\", \"command\": \"npm test\"}, \"permission\": \"ask\"}")
+                    print("  " + dim("when: every 6h · daily 09:00 · mon,wed 08:30 · weekdays 09:00   action.type: lamp {lamp, tool, args} · bash {command} · prompt {prompt, agent}"))
+                    print("  " + dim("o pedíselo al agente en lenguaje natural: «todos los días a las 9 revisá los tests y avisame»"))
+                otherwise
+                    try
+                        let st be schedule.add(json_decode(sjson))
+                        print("  " + green("⏰ programada «" + st["name"] + "» (" + st["id"] + "): " + schedule.describe_plan(st["plan"]) + " · próxima " + schedule.fmt_local(st["next_run"])))
+                    recover err
+                        print("  " + red(text(err)))
+            otherwise when sact == "run" and sid_arg != ""
+                let st be schedule.get(sid_arg)
+                when st == nothing
+                    print("  " + red("no existe la tarea " + sid_arg))
+                otherwise
+                    print("  " + yellow("⏰ corriendo «" + st["name"] + "» · " + schedule.describe_action(st["action"])))
+                    flush()
+                    let sr be sched_run.run(st, ask_user, on_event)
+                    print("  " + (when sr["last_status"] == "ok" then green("✓ ") otherwise red("✗ ")) + sr["last_status"] + " · " + first_line(sr["last_summary"], 160))
+                    print("  " + dim("log: " + schedule.LOG_DIR + "/" + st["id"] + ".log"))
+            otherwise when (sact == "on" or sact == "off") and sid_arg != ""
+                try
+                    print("  " + schedule.set_enabled(sid_arg, sact == "on"))
+                recover err
+                    print("  " + red(text(err)))
+            otherwise when sact == "remove" and sid_arg != ""
+                try
+                    print("  " + schedule.remove(sid_arg))
+                recover err
+                    print("  " + red(text(err)))
+            otherwise when sact == "log" and sid_arg != ""
+                let tl be schedule.log_tail(sid_arg, 60)
+                print(when tl == "" then "  sin corridas todavía" otherwise tl)
+            otherwise
+                let ss be schedule.summary()
+                let age be schedule.daemon_age()
+                when length(ss) == 0
+                    print("  sin tareas programadas. Pedísela al agente («cada 6 horas corré los tests y avisame») o: " + cyan("/schedule add <json>"))
+                each s in ss
+                    print("  " + (when s["running"] then yellow("● ") otherwise (when s["enabled"] then green("● ") otherwise dim("○ "))) + pad(s["id"], 22) + dim(pad(s["plan"], 30)) + s["action_text"])
+                    print("      " + dim("permisos " + s["permission"] + " · próxima " + s["next_local"] + (when s["last_run"] != nothing then " · última " + s["last_status"] + ": " + first_line(s["last_summary"], 80) otherwise "")))
+                let pend be approvals.pending()
+                each ap in pend
+                    print("  " + yellow("⚠ aprobación pendiente " + ap["id"] + ": " + first_line(ap["message"], 100)) + dim("  → /approve " + ap["id"] + " yes|no"))
+                print("  " + dim("corren solas mientras lampson esté abierto (tick cada " + text(schedule.TICK_SECONDS) + " s) · con todo cerrado: lampson --daemon start · run/on/off/remove/log <id>"))
+        otherwise when starts_with(input, "/approve ")
+            let atoks be where(split(trim(slice(input, 9, length(input))), " "), (x) => x != "")
+            when length(atoks) < 2 or not contains(["yes", "no", "si", "sí", "y", "n"], lower(atoks[1]))
+                print("  uso: /approve <id> yes|no   (pendientes: /schedule)")
+            otherwise
+                let yes be contains(["yes", "si", "sí", "y"], lower(atoks[1]))
+                when approvals.answer(atoks[0], yes)
+                    print("  " + (when yes then green("✓ permitido ") otherwise red("✗ denegado ")) + atoks[0])
+                otherwise
+                    print("  " + red("no hay una aprobación pendiente con id " + atoks[0]))
         otherwise when input == "/lamps" or starts_with(input, "/lamps ")
             let lrest be trim(slice(input, 6, length(input)))
             when starts_with(lrest, "run ")

package/lampson.ps1

@@ -5,6 +5,7 @@
 #   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
 #
@@ -17,12 +18,13 @@ $caller = (Get-Location).Path
 $mount = Join-Path $here "workspace"
 
 # --- args: acepta --flag y -Flag, sin distinguir mayúsculas ---
-$Workspace = ""; $Web = $false; $Agent = ""; $Perm = ""
+$Workspace = ""; $Web = $false; $Agent = ""; $Perm = ""; $Daemon = ""
 $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" } }
         '^--?(workspace|ws)$'   { $i++; $Workspace = [string]$args[$i] }
         '^--?(agent|a)$'        { $i++; $Agent = [string]$args[$i] }
         '^--?(yolo|y|dangerously-skip-permissions)$' { $Perm = "yolo" }
@@ -30,7 +32,7 @@ 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 9 | ForEach-Object { $_.TrimStart('#',' ') }; exit 0 }
+        '^--?(help|h|\?)$'      { Get-Content $PSCommandPath | Select-Object -Skip 1 -First 10 | 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++
@@ -49,6 +51,12 @@ if ($Workspace -ne "") {
     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
@@ -76,7 +84,13 @@ try {
     $env:LAMPSON_WORKSPACE = $target
     if ($Agent -ne "") { $env:LAMPSON_AGENT = $Agent }
     if ($Perm -ne "") { $env:LAMPSON_PERMISSION = $Perm }
-    if ($Web) {
+    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

package/lampson.sh

@@ -3,20 +3,22 @@
 #   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)
 set -euo pipefail
 here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 caller="$(pwd)"
-ws=""; web=0
+ws=""; web=0; daemon=""
 while [ $# -gt 0 ]; do
     case "$1" in
         --web) web=1 ;;
+        --daemon) shift; daemon="${1:-status}" ;;
         --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] [--workspace RUTA] [--agent PERFIL] [--yolo|--strict|--ask] [--update]" >&2; exit 1 ;;
+        *) echo "uso: lampson [--web] [--daemon start|stop|status|logs|restart] [--workspace RUTA] [--agent PERFIL] [--yolo|--strict|--ask] [--update]" >&2; exit 1 ;;
     esac
     shift
 done
@@ -25,6 +27,13 @@ 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
@@ -39,4 +48,9 @@ for pair in "skills-global:$HOME/.agents/skills" "skills-claude:$HOME/.claude/sk
 done
 echo "workspace -> $LAMPSON_WORKSPACE"
 cd "$here"
-if [ "$web" = 1 ]; then echo "web: http://127.0.0.1:8080"; exec synsema serve web.syn; else exec synsema run chat.syn; fi
+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

package/lib/agents.syn

@@ -40,7 +40,7 @@ let PARALLEL be 4
 
 export let PROFILES be {
     "build": {
-        "tools": ["read", "write", "edit", "ls", "find", "grep", "lsp", "bash", "process", "memory", "todo", "skill", "mcp", "lamp", "delegate"],
+        "tools": ["read", "write", "edit", "ls", "find", "grep", "lsp", "bash", "process", "memory", "todo", "skill", "mcp", "lamp", "schedule", "delegate"],
         "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)."
     },

package/lib/approvals.syn

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

package/lib/permission.syn

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