lampson 0.1.3 → 0.2.0

package/lib/session.syn

@@ -72,7 +72,8 @@ export task list()
                 try
                     let d be load(id)
                     let title be when contains(d["meta"], "title") then d["meta"]["title"] otherwise ""
-                    let project be when contains(d["meta"], "project") then d["meta"]["project"] otherwise mine
+                    -- sin marca de proyecto (anteriores al 2026-08-27) → no se listan en ningún workspace (aparecían en todos)
+                    let project be when contains(d["meta"], "project") then d["meta"]["project"] otherwise ""
                     when project == mine
                         set out to append(out, {"id": id, "updated": d["updated"], "title": title})
                 recover err
@@ -81,6 +82,42 @@ export task list()
         give []
     give sort_by(out, (s) => 0 - number(replace_text(replace_text(s["id"], "-", ""), "test", "")))
 
+-- Búsqueda de texto en las sesiones de ESTE proyecto (título y contenido de los mensajes user/assistant):
+-- [{id, updated, title, snippet}] — snippet = el primer trozo donde aparece `q`. Vacío = todas (sin snippet).
+-- Lineal sobre los archivos (local, decenas o cientos de sesiones): suficiente; migrar a db si crece.
+export task search(q, limit)
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    require env("LAMPSON_*")
+    let needle be lower(trim(text(q)))
+    let out be []
+    each s in list()
+        when length(out) >= limit
+            give out
+        when needle == ""
+            set out to append(out, {"id": s["id"], "updated": s["updated"], "title": s["title"], "snippet": ""})
+        otherwise
+            let hit be nothing
+            when contains(lower(s["title"]), needle)
+                set hit to ""
+            otherwise
+                try
+                    let d be load(s["id"])
+                    each m in d["messages"]
+                        when hit == nothing and (m["role"] == "user" or m["role"] == "assistant") and text(m["content"]) == m["content"]
+                            let c be text(m["content"])
+                            let lc be lower(c)
+                            when contains(lc, needle)
+                                let pos be length(split(lc, needle)[0])
+                                let a be when pos > 60 then pos - 60 otherwise 0
+                                let b be when pos + length(needle) + 90 < length(c) then pos + length(needle) + 90 otherwise length(c)
+                                set hit to (when a > 0 then "…" otherwise "") + replace_text(replace_text(slice(c, a, b), "\r", ""), "\n", " ") + (when b < length(c) then "…" otherwise "")
+                recover err
+                    set hit to nothing
+            when hit != nothing
+                set out to append(out, {"id": s["id"], "updated": s["updated"], "title": s["title"], "snippet": hit})
+    give out
+
 -- Borrar una sesión (no hay delete_file en el runtime: se usa el shell del sistema sobre la ruta fija).
 export task delete(id)
     require exec

package/lib/settings.syn

@@ -7,7 +7,15 @@
 --
 -- Forma: {"provider": "deepseek", "model": "deepseek-chat", "keys": {"deepseek": "sk-…"}}
 
-let PATH be ".lampson/config.json"
+-- bajo el hub cada workspace corre con su propio .lampson/ y una junction .lampson/global → <home>/.lampson:
+-- la config (keys, ⚙) es una sola para todos. Sin junction (instalación directa, tests) es .lampson/config.json
+task cfg_path()
+    try
+        when file_exists(".lampson/global/config.json") or file_exists(".lampson/global")
+            give ".lampson/global/config.json"
+    recover err
+        give ".lampson/config.json"
+    give ".lampson/config.json"
 
 export task load()
     require file.read(".lampson")
@@ -18,7 +26,7 @@ export task load()
     when env("LAMPSON_NO_CONFIG", "") == "1"
         give {"provider": "", "model": "", "keys": {}}
     try
-        let doc be json_decode(read_file(PATH))
+        let doc be json_decode(read_file(cfg_path()))
         -- claves siempre presentes: quien lee no tiene que chequear (y `and` no cortocircuita)
         when not contains(doc, "keys")
             set doc["keys"] to {}
@@ -33,7 +41,7 @@ export task load()
 export task save(doc)
     require file(".lampson")
     require file(".lampson/*")
-    write_file(PATH, json_encode(doc))
+    write_file(cfg_path(), json_encode(doc))
     give true
 
 -- key guardada para un proveedor, como TEXTO ("" si no hay). Sellarla con as_secret antes de usarla.
@@ -68,3 +76,58 @@ export task set_default(name, model)
     set doc["model"] to model
     save(doc)
     give true
+
+-- valores de configuración generales (rueda de la UI): tz, public_url, webhook_url, webhook_secret…
+-- Vacío = borrar la clave. Nunca se devuelven secretos al navegador: `values()` marca webhook_secret como has_*.
+export let KEYS be ["tz", "public_url", "webhook_url", "webhook_secret", "idle_hours"]
+
+-- el archivo REAL, ignorando LAMPSON_NO_CONFIG: escribir con el doc en blanco de los tests pisaría provider/keys
+-- (pasó el 2026-08-29 probando la rueda con un web de test)
+task load_raw()
+    try
+        let doc be json_decode(read_file(cfg_path()))
+        when not contains(doc, "keys")
+            set doc["keys"] to {}
+        when not contains(doc, "provider")
+            set doc["provider"] to ""
+        when not contains(doc, "model")
+            set doc["model"] to ""
+        give doc
+    recover err
+        give {"provider": "", "model": "", "keys": {}}
+
+export task set_value(key, value)
+    require file(".lampson")
+    require file(".lampson/*")
+    require env("LAMPSON_*")
+    when not contains(KEYS, key)
+        raise("unknown setting '" + text(key) + "'")
+    let doc be load_raw()
+    when trim(text(value)) == ""
+        let clean be {}
+        each k in keys(doc)
+            when k != key
+                set clean[k] to doc[k]
+        set doc to clean
+    otherwise
+        set doc[key] to trim(text(value))
+    save(doc)
+    give true
+
+export task values()
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    require env("LAMPSON_*")
+    let doc be load_raw()
+    let out be {}
+    each k in KEYS
+        when k == "webhook_secret"
+            set out["has_webhook_secret"] to (contains(doc, k) and text(doc[k]) != "") or env("LAMPSON_WEBHOOK_SECRET", "") != ""
+        otherwise
+            set out[k] to when contains(doc, k) then text(doc[k]) otherwise ""
+            -- lo fijado en .env gana y se muestra como tal
+            let e be env("LAMPSON_" + upper(k), "")
+            when e != ""
+                set out[k] to e
+                set out[k + "_from_env"] to true
+    give out

package/lib/skills.syn

@@ -28,6 +28,8 @@
 let ROOTS be [
     {"dir": ".lampson/skills-global", "source": "global"},
     {"dir": ".lampson/skills-claude", "source": "global"},
+    {"dir": ".lampson/global/skills-global", "source": "global"},
+    {"dir": ".lampson/global/skills-claude", "source": "global"},
     {"dir": "skills", "source": "harness"},
     {"dir": "workspace/.claude/skills", "source": "project"},
     {"dir": "workspace/.agents/skills", "source": "project"},

package/lib/tools.syn

@@ -27,6 +27,7 @@ use "./skills.syn" as skills
 use "./mcp.syn" as mcp
 use "./lamps.syn" as lamps
 use "./lsp.syn" as lsp
+use "./schedule.syn" as schedule
 
 -- la task de la tool skill (su SPEC está en tools/skill.syn)
 task skill_tool(name, action, source, scope)
@@ -155,6 +156,96 @@ let LSP_SPEC be {
     }, "required": ["op"]}
 }
 
+-- la tool schedule (lib/schedule.syn): tareas programadas. add/remove/enable/run piden humano SIEMPRE (permission.syn):
+-- crear una tarea = autorizar de una vez todo lo que va a hacer sin nadie mirando. Las corridas las hace el daemon
+-- (web.syn); desde acá solo se corren en el acto las lamp/bash (una prompt anidaría un loop dentro del turno).
+task schedule_tool(action, id, name, at, kind, lamp, tool, args, command, prompt, agent, permission, approval_timeout, notify)
+    require exec
+    require time
+    require net
+    require env("LAMPSON_*")
+    require env("OS")
+    require file(".lampson")
+    require file(".lampson/*")
+    require file.read("lamps")
+    require file.read("lamps/*")
+    require file("workspace")
+    require file("workspace/*")
+    let act be when action == nothing then "list" otherwise action
+    when act == "add"
+        let a be {"type": kind}
+        when kind == "lamp"
+            set a to {"type": "lamp", "lamp": lamp, "tool": tool, "args": when args == nothing then {} otherwise args}
+        otherwise when kind == "bash"
+            set a to {"type": "bash", "command": command}
+        otherwise when kind == "prompt"
+            set a to {"type": "prompt", "prompt": prompt, "agent": when agent == nothing then "build" otherwise agent}
+        let spec be {"name": name, "when": at, "action": a, "permission": when permission == nothing then "ask" otherwise permission}
+        when approval_timeout != nothing
+            set spec["approval_timeout"] to approval_timeout
+        when notify != nothing
+            set spec["notify"] to notify
+        let t be schedule.add(spec)
+        give "scheduled '" + t["name"] + "' (id " + t["id"] + "): " + schedule.describe_plan(t["plan"]) + " (local time) · " + schedule.describe_action(t["action"]) + " · permission " + t["permission"] + " · next run " + schedule.fmt_local(t["next_run"]) + " — tell the user this next-run time as is. The run's report lands in a NEW session named ⏰ <name> (sidebar «Sesiones» / /sessions) and, if notify is set, in that webhook — NOT in this chat: say so. " + daemon_note()
+    when act == "remove"
+        give schedule.remove(id)
+    when act == "enable"
+        give schedule.set_enabled(id, true)
+    when act == "disable"
+        give schedule.set_enabled(id, false)
+    when act == "run"
+        let t be schedule.get(id)
+        when t == nothing
+            raise("no scheduled task '" + text(id) + "'")
+        when t["action"]["type"] == "prompt"
+            schedule.request_run(id)
+            give "run requested: it runs within " + text(schedule.TICK_SECONDS) + " s in the background and its report lands in a NEW session (⏰ " + t["name"] + "), not in this chat. " + daemon_note()
+        schedule.mark_started(t)
+        let started be now()
+        let out be schedule.run_simple(t)
+        schedule.record(t, started, when starts_with(out, "ERROR") or starts_with(out, "DENIED") then "error" otherwise "ok", out, {})
+        give out
+    when act == "log"
+        let tail be schedule.log_tail(id, 80)
+        give when tail == "" then "no runs yet for " + text(id) otherwise tail
+    let sm be schedule.summary()
+    when length(sm) == 0
+        give "no scheduled tasks. " + daemon_note()
+    let lines be []
+    each s in sm
+        set lines to append(lines, s["id"] + (when s["enabled"] then " ON " otherwise " off") + " · " + s["plan"] + " · " + s["action_text"] + " · permission " + s["permission"] + " · next " + s["next_local"] + (when s["last_run"] != nothing then " · last " + s["last_status"] + ": " + s["last_summary"] otherwise ""))
+    give join(lines, "\n") + "\n" + daemon_note()
+
+task daemon_note()
+    require time
+    require file(".lampson")
+    require file(".lampson/*")
+    let age be schedule.daemon_age()
+    when age == nothing or age > schedule.TICK_SECONDS * 3
+        give "NOTE: no scheduler is running right now (scheduled tasks run inside the web/daemon process): the user starts it with `lampson --daemon start` (or keeps `lampson --web` open)."
+    give "Scheduler alive (last tick " + text(floor(age)) + " s ago)."
+
+let SCHEDULE_SPEC be {
+    "name": "schedule",
+    "description": "Scheduled tasks: run something on a schedule with nobody watching — a lamp tool, a fixed shell command, or a full agent run from a prompt (kind=prompt: the agent works unattended with the chosen profile and writes a report; its session appears as ⏰ <name>). `at` formats — recurring: 'every 6h' | 'every 30m' | 'daily 09:00' | 'mon,wed 08:30' | 'weekdays 09:00'; ONE-TIME (runs once, then turns itself off): 'today 15:14' | 'tomorrow 09:00' | 'once 2026-08-29 15:14' | 'in 2h'. Times are the USER'S LOCAL time (the machine's timezone): write the hour exactly as the user says it — NEVER convert to UTC. Tasks belong to the current workspace. permission = what a prompt run may do without asking: strict (dangerous actions denied), ask (default: a dangerous action sends the user an approval link/notification and waits up to approval_timeout seconds, denied if unanswered), yolo (allowed). notify = optional webhook URL that receives the result as JSON (for 'search and send me' tasks). action=add ALWAYS asks the user (it authorizes future unattended runs); remove/enable/disable/run also ask; list and log do not. The tasks are executed by Lampson's resident process (`lampson --daemon start` or the open web UI) — say so if the list shows no scheduler running. Use it when the user says 'every day at', 'each N hours', 'on Mondays', 'periodically', 'remind me', 'send me'.",
+    "parameters": {"type": "object", "properties": {
+        "action": {"type": "string", "enum": ["list", "add", "remove", "enable", "disable", "run", "log"], "description": "Default: list"},
+        "id": {"type": "string", "description": "remove/enable/disable/run/log: the task id (from list)"},
+        "name": {"type": "string", "description": "add: short human name"},
+        "at": {"type": "string", "description": "add: the schedule — 'every 6h' | 'daily 09:00' | 'mon,wed 08:30' | 'weekdays 09:00'"},
+        "kind": {"type": "string", "enum": ["lamp", "bash", "prompt"], "description": "add: what runs"},
+        "lamp": {"type": "string", "description": "add kind=lamp: lamp name (must be ON)"},
+        "tool": {"type": "string", "description": "add kind=lamp: tool of that lamp"},
+        "args": {"type": "object", "description": "add kind=lamp: arguments for the tool"},
+        "command": {"type": "string", "description": "add kind=bash: the shell command (must finish on its own; no servers)"},
+        "prompt": {"type": "string", "description": "add kind=prompt: self-contained instructions for the unattended agent run (what to do, how to verify, what to report)"},
+        "agent": {"type": "string", "enum": ["build", "plan", "review", "explore"], "description": "add kind=prompt: profile (default build)"},
+        "permission": {"type": "string", "enum": ["strict", "ask", "yolo"], "description": "add: permission envelope for unattended runs (default ask)"},
+        "approval_timeout": {"type": "integer", "description": "add: seconds to wait for a remote approval (default 7200)"},
+        "notify": {"type": "string", "description": "add: webhook URL that receives each result as JSON"}
+    }, "required": ["action"]}
+}
+
 -- Allow-list nombre → task. El modelo solo devuelve NOMBRES; el loop decide si se ejecuta.
 export task registry()
     give {
@@ -171,10 +262,11 @@ export task registry()
         "skill": skill_tool,
         "mcp": mcp_tool,
         "lamp": lamp_tool,
-        "lsp": lsp_tool
+        "lsp": lsp_tool,
+        "schedule": schedule_tool
     }
 
-export let CATALOG be [t_read.SPEC, t_write.SPEC, t_edit.SPEC, t_ls.SPEC, t_find.SPEC, t_grep.SPEC, LSP_SPEC, t_bash.SPEC, t_process.SPEC, t_memo.SPEC, t_todo.SPEC, t_skill.SPEC, MCP_SPEC, LAMP_SPEC]
+export let CATALOG be [t_read.SPEC, t_write.SPEC, t_edit.SPEC, t_ls.SPEC, t_find.SPEC, t_grep.SPEC, LSP_SPEC, t_bash.SPEC, t_process.SPEC, t_memo.SPEC, t_todo.SPEC, t_skill.SPEC, MCP_SPEC, LAMP_SPEC, SCHEDULE_SPEC]
 
 -- Subconjuntos (para perfiles de agente): registry/catálogo filtrados por nombre.
 export task registry_subset(names)