lampson 0.1.2 → 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
@@ -139,6 +187,10 @@ servers, flags), `↑↓` browse history or the menu, `Alt+Enter` inserts a newl
 last tool result in full, `Ctrl+U`/`Ctrl+W` clear the line/word, `Esc` closes the menu. Approvals are
 an arrow-key menu (`permitir`/`denegar`, or `p`/`d`).
 
+While the model thinks or a slow tool runs (a long `bash`, a sub-agent), a status line shows what is
+running, the elapsed time and a bar that fills as you wait (`⠋ pensando  ▰▰▱▱▱▱▱▱▱▱ 12s`); it appears
+after 0.4 s so instant tools do not flicker, and anything you type meanwhile lands in the prompt.
+
 The terminal renders the model's markdown (headings, lists, tables, code fences) and shows every tool
 result: `edit`/`write` print a line diff (`- red / + green`, line numbers, 2 lines of context); other
 tools are collapsed to 15 lines. `/out [n]` prints the n-th last result of the turn in full and
@@ -181,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
@@ -299,7 +357,7 @@ Borrowed from the harness that does each part best (see `notes/*.md`):
 | Budget runs out silently | 80 %: a notice appended to the latest tool result (no new user message, cache stays warm); 95 %: last step without tools, summary required | hermes / opencode |
 | Edits a file it never read, or one that changed | **Observation gate in code**: `read` records the file hash; `edit`/`write` on an existing file are rejected without it, or if the file changed since | deepseek |
 | Loses the plan | `todo` tool (whole-list replacement, one `in_progress` at a time, scoped to the session like the three references); re-injected only after context compaction, active items only | hermes, opencode |
-| Reads the whole project before touching anything | **Exploration cap** (ours): after 8 read-only calls in a row (read/ls/find/grep) without an edit/write/command the result carries a warning; after 16 they are refused until it acts (`LAMPSON_EXPLORE_CAP`) | — |
+| Reads the whole project before touching anything | **Exploration cap** (ours): after 12 read-only calls in a row (read/ls/find/grep) without an edit/write/command the result carries a warning; after 24 they are refused until it acts (`LAMPSON_EXPLORE_CAP`) | — |
 
 ### Sub-agents
 

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_*")
@@ -46,10 +47,14 @@ use "./lib/trace.syn" as trace
 use "./lib/md.syn" as md
 use "./lib/diff.syn" as diff
 use "./lib/line.syn" as ed
+use "./lib/ui.syn" as ui
 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.
@@ -107,6 +112,15 @@ task summarize(name, out)
                 set used to used + length(l) + 2
         let rest be length(lines) - length(shown)
         give text(length(lines)) + (when name == "ls" then " entradas: " otherwise " archivos: ") + join(shown, "  ") + (when rest > 0 then dim("  +" + text(rest)) otherwise "")
+    when name == "delegate" and not VERBOSE
+        -- una línea por subagente: el encabezado [id · agente · estado · pasos · tokens · log]
+        let heads be []
+        each l in lines
+            when starts_with(trim(l), "[") and contains(l, " steps") or (starts_with(trim(l), "[") and contains(l, " · log:"))
+                set heads to append(heads, trim(l))
+        when length(heads) == 0
+            give first_line(out, 120)
+        give join(heads, "\n      ")
     when name == "grep" and not VERBOSE
         let files be {}
         each l in lines
@@ -136,11 +150,21 @@ task diff_of(name, out)
     give diff.diff(d["old"], d["new"], 2, COLOR)
 
 task print_diff(path, d)
-    let head be path + " · " + green("+" + text(d["added"])) + " " + red("−" + text(d["removed"]))
-    print("    " + green("✓") + " " + head)
+    print_diff_with("    ", path, d)
+
+-- lead = lo que va antes del ✓ (la llamada, si se fusionó en la misma línea)
+task print_diff_with(lead, path, d)
+    let head be green("✓") + " " + c("34", path) + "  " + green("+" + text(d["added"])) + " " + red("−" + text(d["removed"]))
+    print(lead + head)
     each l in d["lines"]
         print("      " + l)
 
+-- tools "instantáneas": la llamada se imprime junto con su resultado, en una sola línea
+task is_instant(name)
+    give name == "read" or name == "ls" or name == "find" or name == "grep" or name == "memory" or name == "edit" or name == "write" or name == "todo" or name == "lsp"
+
+let pending_call be ""
+
 -- /out: resultado completo de una tool del turno
 task print_full(o)
     when o["diff"] != nothing
@@ -149,17 +173,110 @@ task print_full(o)
         each l in split(o["output"], "\n")
             print("      " + l)
 
+-- ---------- indicador de espera ----------
+-- El intérprete principal se bloquea en la llamada al modelo y en cada tool; el que dibuja es un agente
+-- (hilo real) que mira el blackboard: `lampson:busy` = {label, kind, since} mientras hay algo en curso.
+-- Arranca a dibujar recién a los 0,4 s (las tools instantáneas no parpadean) y suelta la terminal
+-- (`lampson:spinner:holding` = false) antes de que el principal vuelva a imprimir.
+agent Spinner
+    require time
+    let frames be ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    let i be 0
+    let drawn be false
+    let run be true
+    -- MIGA: un agente NO puede abrir la terminal (term_open → nothing) pero sí print+flush. Cada print de un
+    -- agente sale con el prefijo "[Spinner_0] " en la línea de abajo: cada frame limpia esa línea (\r ESC[K),
+    -- sube una (ESC[1A) y redibuja la suya. Al terminar deja el cursor en la línea del spinner, vacía.
+    let clear_here be "\r" + esc + "[K"
+    let up be esc + "[1A"
+    while run
+        observe "lampson:spinner:stop" as st
+        observe "lampson:busy" as b
+        when st == true
+            set run to false
+        otherwise when b == nothing
+            when drawn
+                print(clear_here + up + clear_here + up)
+                flush()
+                set drawn to false
+            share false as "lampson:spinner:holding"
+            sleep(0.05)
+        otherwise
+            let el be now() - b["since"]
+            when el >= 0.4
+                -- barra de "costo hundido": se llena rápido al principio y cada vez más despacio
+                let fill be floor(10 * (1 - exp(0 - el / 40)))
+                let bar be ""
+                let k be 0
+                while k < 10
+                    set bar to bar + (when k < fill then "▰" otherwise "▱")
+                    set k to k + 1
+                let hint be when el > 90 then "  esto está tardando (Ctrl+C corta)" otherwise (when el > 30 then "  ya casi" otherwise (when el > 8 then "  sigue trabajando" otherwise ""))
+                let secs be text(floor(el)) + "s"
+                let label be b["label"]
+                when length(label) > 60
+                    set label to slice(label, 0, 59) + "…"
+                let frame be frames[i % 10]
+                let body be when color then esc + "[36m" + frame + esc + "[0m " + label + "  " + esc + "[2m" + bar + " " + secs + hint + esc + "[0m" otherwise frame + " " + label + "  " + bar + " " + secs + hint
+                when drawn
+                    print(clear_here + up + clear_here + "  " + body)
+                otherwise
+                    share true as "lampson:spinner:holding"
+                    print(clear_here + "  " + body)
+                    set drawn to true
+                flush()
+                set i to i + 1
+            sleep(0.08)
+    when drawn
+        print(clear_here + up + clear_here + up)
+        flush()
+    share false as "lampson:spinner:holding"
+
+task busy_on(label, kind)
+    share {"label": label, "kind": kind, "since": now()} as "lampson:busy"
+
+-- apagar y esperar a que el agente suelte la terminal (máx. 1 s) antes de volver a imprimir
+task busy_off()
+    share nothing as "lampson:busy"
+    let waited be 0
+    let holding be true
+    while holding and waited < 100
+        observe "lampson:spinner:holding" as hd
+        set holding to hd == true
+        when holding
+            sleep(0.01)
+            set waited to waited + 1
+
 -- tag = "" para el agente principal; los subagentes en background NO pasan por acá (escriben su log)
 task on_event(kind, data, tag)
     trace.event(sid, kind, data, tag)
-    when kind == "assistant"
+    when kind == "busy"
+        busy_on(data["label"], data["kind"])
+    otherwise when kind == "idle"
+        busy_off()
+    otherwise when kind == "assistant"
+        -- ● marca el turno del asistente (primera línea con contenido)
+        let lines be split(md.render(data, COLOR), "\n")
+        let marked be false
+        let out_lines be []
+        each l in lines
+            when not marked and trim(l) != "" and starts_with(l, "  ")
+                set out_lines to append(out_lines, c("36;1", "● ") + slice(l, 2, length(l)))
+                set marked to true
+            otherwise
+                set out_lines to append(out_lines, l)
         print("")
-        print(md.render(data, COLOR))
+        print(join(out_lines, "\n"))
         print("")
     otherwise when kind == "inbox"
         print("  " + cyan("✉ " + first_line(data, 140)))
     otherwise when kind == "tool_call"
-        print("  " + yellow("▸ " + permission.describe_call(data["name"], data["args"])))
+        let desc be permission.describe_call(data["name"], data["args"])
+        when is_instant(data["name"])
+            set pending_call to desc
+        otherwise
+            set pending_call to ""
+            print("  " + yellow("▸ " + desc))
     otherwise when kind == "tool_result"
         let out be data["output"]
         let name be data["call"]["name"]
@@ -167,11 +284,17 @@ task on_event(kind, data, tag)
         let d be diff_of(name, out)
         let path be when d != nothing then text(data["call"]["args"]["path"]) otherwise ""
         set turn_outputs to append(turn_outputs, {"name": name, "args": data["call"]["args"], "output": out, "diff": d, "path": path})
+        let lead be when pending_call != "" then "  " + yellow("▸ " + pending_call) + "  " otherwise "    "
+        set pending_call to ""
         when d != nothing
-            print_diff(path, d)
+            print_diff_with(lead, path, d)
         otherwise
             let mark be when bad then red("✗") otherwise green("✓")
-            print("    " + mark + " " + (when bad then red(summarize(name, out)) otherwise dim(summarize(name, out))))
+            let s be summarize(name, out)
+            -- una sola línea → cortar al ancho; multilínea (bash) se deja
+            when not contains(s, "\n")
+                set s to ui.cut(s, ui.cols() - ui.width(lead) - 4)
+            print(lead + mark + " " + (when bad then red(s) otherwise dim(s)))
     otherwise when kind == "tool_denied"
         set data to data
     otherwise when kind == "error"
@@ -180,11 +303,13 @@ task on_event(kind, data, tag)
             print("  " + yellow("el proveedor rechazó el nombre del modelo (" + cfg["model"] + "): /model sin argumentos lista los válidos, /model <nombre> lo cambia"))
     otherwise when kind == "compact"
         print("  " + dim("⧗ compactando contexto (~" + text(data["before"]) + " tokens)"))
+        busy_on("compactando contexto", "llm")
     flush()
 
 -- Human in the loop con el `approve` nativo de Synsema: prompt [approve] … (y/n) en TTY; sin TTY deniega
 -- (fail-closed, un agente no puede auto-aprobarse); `within` acota la espera.
 task ask_user(name, args, why)
+    busy_off()
     print("")
     print("  " + yellow("⚠ requiere tu aprobación · " + why))
     print("    " + permission.describe_call(name, args))
@@ -223,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"],
@@ -282,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"
@@ -551,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.
@@ -641,6 +819,10 @@ when sid == ""
 share {"id": sid} as "lampson:session"
 
 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}
@@ -881,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 ")
@@ -1005,23 +1252,31 @@ while running
             -- catálogo fresco por turno: si el turno anterior conectó/quitó un server MCP, sus tools
             -- entran/salen acá (con los mismos servers el catálogo es idéntico → el prompt cache no se corta)
             set opts to opts_for(profile, mode)
+            let t0 be now()
             let result be loop.run_turn(cfg, messages, opts, on_event)
             trace.turn_end(sid, result)
             set messages to result["messages"]
             set total_usage to {"input": total_usage["input"] + result["usage"]["input"], "output": total_usage["output"] + result["usage"]["output"]}
-            let summary be text(result["steps"]) + (when result["steps"] == 1 then " paso" otherwise " pasos") + " · " + fmt_tokens(result["usage"]["input"] + result["usage"]["output"]) + " tokens"
+            let summary be text(result["steps"]) + (when result["steps"] == 1 then " paso" otherwise " pasos") + " · " + fmt_tokens(result["usage"]["input"] + result["usage"]["output"]) + " tokens · " + ui.fmt_duration(now() - t0)
             when result["stopped"] == "max_steps"
                 set summary to summary + " · " + red("límite de " + text(opts["max_steps"]) + " pasos por turno")
                 print(dim("  ─── " + summary))
                 print("  " + yellow("El agente paró por el límite de pasos, no porque terminó. Escribí «seguí» para que continúe donde quedó, o subí LAMPSON_MAX_STEPS."))
             otherwise when result["stopped"] != "done"
-                set summary to summary + " · " + red("detenido: " + result["stopped"])
+                -- el detalle del error ya salió en la línea ‼; acá solo la causa corta
+                let why be result["stopped"]
+                when starts_with(why, "error: network")
+                    set why to "error de red (ver ‼ arriba)"
+                otherwise when starts_with(why, "error:")
+                    set why to first_line(why, 60)
+                set summary to summary + " · " + red("detenido: " + why)
                 print(dim("  ─── " + summary))
             otherwise
                 print(dim("  ─── " + summary))
             session.save(sid, messages, {"title": session.title_of(messages)})
     flush()
 -- los procesos gestionados (servidores) y los subagentes en background mueren con lampson
+share true as "lampson:spinner:stop"
 agents.stop_all()
 mcp.stop_all()
 lsp.stop_all()

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)."
     },