lampson 0.2.6 → 0.2.7

package/lib/plugins.syn

@@ -0,0 +1,408 @@
+-- lib/plugins.syn — plugins: tools que el usuario (o el agente) escribe y el humano ENCIENDE
+--
+-- Qué es un plugin: una carpeta con un manifiesto `plugin.json` y el código que implementa sus tools.
+--   plugins/<nombre>/                     GLOBAL (lampson se instala una vez → vale para todos los proyectos)
+--   workspace/.lampson/plugins/<nombre>/  del PROYECTO (el agente puede crearlos con write: es su workspace)
+--   plugin.json = {"name", "description", "kind": "syn" | "exec",
+--                  "entry": "plugin.syn"          (kind=syn: un programa Synsema)
+--                  "command": "python plugin.py"  (kind=exec: cualquier ejecutable — js, py, sh…)
+--                  "caps": "file.read=workspace/*" (kind=syn, opcional: techo EXTRA sobre stdout,time,env=PLUGIN_*)
+--                  "timeout": 60,
+--                  "tools": [{"name", "description", "parameters": {JSON Schema}, "readonly": false}]}
+--
+-- Cómo corre (patrón "safe runner" de la doc 22-sandbox): cada llamada es UN proceso hijo que termina.
+--   kind=syn  → `synsema run --cap-set stdout,time,env=PLUGIN_*[,caps] <entry>`: el techo lo fija el
+--               manifiesto que el humano aprobó al encenderlo; un `require` de más en el código del
+--               plugin falla con "above the host ceiling" — no hay forma de escalar desde adentro.
+--   kind=exec → el comando tal cual (sin techo de lenguaje: por eso encender es SIEMPRE humano).
+--   La tool y sus args viajan por env: PLUGIN_TOOL, PLUGIN_ARGS (JSON), PLUGIN_DIR (carpeta del plugin,
+--   relativa a la raíz de lampson = cwd del hijo si kind=syn; si kind=exec el cwd es el workspace),
+--   PLUGIN_WORKSPACE (ruta real del proyecto). El plugin imprime el resultado (texto o JSON) por stdout.
+--
+-- Encendido: `.lampson/plugins.json` {"enabled": {"<nombre>": true}}. APAGADO por defecto: descubrir una
+-- carpeta nueva no lo activa; lo enciende el humano (UI: barra superior; terminal: /plugins on <nombre>) o el
+-- agente con la tool `plugin` (action=enable → ask SIEMPRE, como skill install / mcp add). Crear = write;
+-- encender = permiso. Sin `use` dinámico (Synsema no lo tiene, a propósito): nada de esto entra al proceso
+-- de lampson, solo corre como hijo.
+--
+-- Las tools encendidas entran al catálogo como `plugin_<plugin>_<tool>`; loop.execute las despacha acá
+-- (registry las marca con "plugin", como "mcp"). permission.syn: ask por defecto, yolo permite, strict deniega;
+-- las readonly también en plan/review/explore.
+--
+-- Compat (2026-09-01: antes se llamaban "lámparas"/lamps). Se siguen descubriendo las carpetas viejas
+-- `.lampson/lamps/<nombre>/` (marcadas `legacy: true` en summary; la UI y /plugins lo avisan), un `plugin.json`
+-- ausente cae a `lamp.json`, el estado cae a `.lampson/lamps.json` si `.lampson/plugins.json` no existe (se
+-- escribe siempre el nuevo), y el hijo recibe también LAMP_TOOL/LAMP_ARGS/LAMP_DIR/LAMP_WORKSPACE (el techo
+-- base incluye env=LAMP_*). Es un puente, no un formato: renombrá la carpeta y el manifiesto.
+
+use "./tools/common.syn" as c
+
+export let GLOBAL_DIR be "plugins"
+export let PROJECT_DIR be "workspace/.lampson/plugins"
+export let LEGACY_PROJECT_DIR be "workspace/.lampson/lamps"
+export let STATE_FILE be ".lampson/plugins.json"
+let LEGACY_STATE_FILE be ".lampson/lamps.json"
+export let PREFIX be "plugin_"
+export let LEGACY_HINT be "old .lampson/lamps/ folder — rename it to .lampson/plugins/ (and lamp.json to plugin.json)"
+let DEFAULT_TIMEOUT be 60
+let BASE_CAPS be "stdout,time,env=PLUGIN_*,env=LAMP_*"
+
+-- nombre de plugin: SIN "_" (el separador de plugin_<plugin>_<tool>); las tools sí pueden llevarlo
+task valid_name(name)
+    when name == nothing or name == ""
+        give false
+    give matches(text(name), "[a-zA-Z0-9-]{1,32}")
+
+task valid_tool_name(name)
+    when name == nothing or name == ""
+        give false
+    give matches(text(name), "[a-zA-Z0-9_-]{1,40}")
+
+-- lee y valida un manifiesto; devuelve {ok, plugin} o {ok: false, error}. `legacy` = viene de una carpeta vieja
+-- (o de un lamp.json): se lista igual, con el aviso.
+task read_manifest(dir, name, scope, legacy)
+    let path be dir + "/" + name + "/plugin.json"
+    let is_legacy be legacy
+    when not file_exists(path) and file_exists(dir + "/" + name + "/lamp.json")
+        set path to dir + "/" + name + "/lamp.json"
+        set is_legacy to true
+    let doc be nothing
+    try
+        set doc to json_decode(read_file(path))
+    recover err
+        give {"ok": false, "name": name, "scope": scope, "legacy": is_legacy, "error": "no plugin.json: " + text(err)}
+    let kind be when contains(doc, "kind") then lower(text(doc["kind"])) otherwise "syn"
+    when kind != "syn" and kind != "exec"
+        give {"ok": false, "name": name, "scope": scope, "legacy": is_legacy, "error": "kind must be syn or exec"}
+    when kind == "syn" and not contains(doc, "entry")
+        give {"ok": false, "name": name, "scope": scope, "legacy": is_legacy, "error": "kind=syn needs \"entry\" (the .syn file)"}
+    when kind == "exec" and not contains(doc, "command")
+        give {"ok": false, "name": name, "scope": scope, "legacy": is_legacy, "error": "kind=exec needs \"command\""}
+    when not contains(doc, "tools") or length(doc["tools"]) == 0
+        give {"ok": false, "name": name, "scope": scope, "legacy": is_legacy, "error": "no tools declared"}
+    let tools be []
+    each t in doc["tools"]
+        when not contains(t, "name") or not valid_tool_name(t["name"])
+            give {"ok": false, "name": name, "scope": scope, "legacy": is_legacy, "error": "a tool has no valid name"}
+        set tools to append(tools, {"name": text(t["name"]), "description": when contains(t, "description") then text(t["description"]) otherwise "", "parameters": when contains(t, "parameters") then t["parameters"] otherwise {"type": "object", "properties": {}}, "readonly": contains(t, "readonly") and t["readonly"] == true})
+    give {"ok": true, "name": name, "scope": scope, "legacy": is_legacy, "plugin": {"name": name, "scope": scope, "dir": dir + "/" + name, "kind": kind, "legacy": is_legacy, "description": when contains(doc, "description") then text(doc["description"]) otherwise "", "entry": when contains(doc, "entry") then text(doc["entry"]) otherwise "", "command": when contains(doc, "command") then text(doc["command"]) otherwise "", "caps": when contains(doc, "caps") then text(doc["caps"]) otherwise "", "timeout": when contains(doc, "timeout") then floor(number(doc["timeout"])) otherwise DEFAULT_TIMEOUT, "tools": tools}}
+
+task scan(dir, scope, legacy)
+    let out be []
+    try
+        each e in list_dir(dir)
+            when e["is_dir"] and valid_name(e["name"])
+                set out to append(out, read_manifest(dir, e["name"], scope, legacy))
+    recover err
+        give out
+    give out
+
+-- estado de encendido: el archivo nuevo; si no existe todavía, el viejo (solo lectura — se escribe siempre el nuevo)
+task load_state()
+    let f be when file_exists(STATE_FILE) then STATE_FILE otherwise LEGACY_STATE_FILE
+    try
+        let doc be json_decode(read_file(f))
+        give when contains(doc, "enabled") then doc["enabled"] otherwise {}
+    recover err
+        give {}
+
+-- todos los plugins descubiertos (proyecto pisa a global por nombre; la carpeta nueva pisa a la vieja), con
+-- enabled, legacy y error. LAMPSON_PLUGINS_DIR = una carpeta extra (tests).
+export task all()
+    require file(".lampson")
+    require file(".lampson/*")
+    require file.read("plugins")
+    require file.read("plugins/*")
+    require file("workspace")
+    require file("workspace/*")
+    require env("LAMPSON_*")
+    let by_name be {}
+    each r in scan(GLOBAL_DIR, "global", false)
+        set by_name[r["name"]] to r
+    each r in scan(LEGACY_PROJECT_DIR, "project", true)
+        set by_name[r["name"]] to r
+    each r in scan(PROJECT_DIR, "project", false)
+        set by_name[r["name"]] to r
+    when env("LAMPSON_PLUGINS_DIR", "") != ""
+        each r in scan(env("LAMPSON_PLUGINS_DIR", ""), "extra", false)
+            set by_name[r["name"]] to r
+    let st be load_state()
+    let out be []
+    each n in sort_by(keys(by_name), (x) => x)
+        let r be by_name[n]
+        let on be contains(st, n) and st[n] == true
+        when r["ok"]
+            let l be r["plugin"]
+            set l["enabled"] to on
+            set l["error"] to nothing
+            set out to append(out, l)
+        otherwise
+            set out to append(out, {"name": n, "scope": r["scope"], "dir": "", "kind": "?", "legacy": r["legacy"], "description": "", "entry": "", "command": "", "caps": "", "timeout": 0, "tools": [], "enabled": false, "error": r["error"]})
+    give out
+
+export task enabled()
+    require file(".lampson")
+    require file(".lampson/*")
+    require file.read("plugins")
+    require file.read("plugins/*")
+    require file("workspace")
+    require file("workspace/*")
+    require env("LAMPSON_*")
+    give where(all(), (l) => l["enabled"] and l["error"] == nothing)
+
+-- encender/apagar (el humano, o el agente tras aprobación). Encender un plugin roto es error.
+export task set_enabled(name, on)
+    require file(".lampson")
+    require file(".lampson/*")
+    require file.read("plugins")
+    require file.read("plugins/*")
+    require file("workspace")
+    require file("workspace/*")
+    require env("LAMPSON_*")
+    when not valid_name(name)
+        raise("invalid plugin name")
+    let found be where(all(), (l) => l["name"] == name)
+    when length(found) == 0
+        raise("no plugin named '" + name + "' (global: " + GLOBAL_DIR + "/<name>/plugin.json · project: " + PROJECT_DIR + "/<name>/plugin.json)")
+    when on and found[0]["error"] != nothing
+        raise("plugin '" + name + "' is broken: " + text(found[0]["error"]))
+    let st be load_state()
+    set st[name] to on == true
+    write_file(STATE_FILE, json_encode({"enabled": st}))
+    let l be found[0]
+    let legacy_note be when l["legacy"] then " · NOTE: " + LEGACY_HINT otherwise ""
+    when on
+        give "plugin '" + name + "' ON (" + l["kind"] + ", " + text(length(l["tools"])) + " tools" + (when l["kind"] == "syn" then ", ceiling: " + ceiling_of(l) otherwise ", NO capability ceiling: exec") + ") — its tools are in the catalog from the next turn as " + PREFIX + name + "_<tool>" + legacy_note
+    give "plugin '" + name + "' OFF" + legacy_note
+
+task ceiling_of(l)
+    give when l["caps"] == "" then BASE_CAPS otherwise BASE_CAPS + "," + l["caps"]
+
+-- ---------- catálogo ----------
+export task tool_name(plugin, tool)
+    give PREFIX + plugin + "_" + tool
+
+task split_name(full)
+    let segs be split(slice(full, length(PREFIX), length(full)), "_")
+    when length(segs) < 2
+        raise("bad plugin tool name '" + full + "'")
+    give {"plugin": segs[0], "tool": join(slice(segs, 1, length(segs)), "_")}
+
+export task catalog(readonly_only)
+    require file(".lampson")
+    require file(".lampson/*")
+    require file.read("plugins")
+    require file.read("plugins/*")
+    require file("workspace")
+    require file("workspace/*")
+    require env("LAMPSON_*")
+    let out be []
+    each l in enabled()
+        each t in l["tools"]
+            when not readonly_only or t["readonly"]
+                set out to append(out, {"name": tool_name(l["name"], t["name"]), "description": "[plugin " + l["name"] + "] " + t["description"], "parameters": t["parameters"]})
+    give out
+
+export task names(readonly_only)
+    require file(".lampson")
+    require file(".lampson/*")
+    require file.read("plugins")
+    require file.read("plugins/*")
+    require file("workspace")
+    require file("workspace/*")
+    require env("LAMPSON_*")
+    give apply(catalog(readonly_only), (s) => s["name"])
+
+-- ---------- llamada: un proceso hijo por invocación ----------
+task run_child(exe, argv, cwd, envs, t)
+    let p be proc_spawn(exe, argv, {"cwd": cwd, "env": envs, "stderr": "merge", "on_full": "drop_oldest"})
+    proc_close_stdin(p)
+    let deadline be now() + t
+    let lines be []
+    let code be nothing
+    let timed_out be false
+    while code == nothing and not timed_out
+        let left be deadline - now()
+        when left <= 0
+            set timed_out to true
+        otherwise
+            let ev be proc_recv(p, when left < 0.2 then 0.2 otherwise left)
+            when ev == nothing
+                set timed_out to now() >= deadline
+            otherwise when ev["type"] == "exit"
+                set code to ev["data"]["exit_code"]
+            otherwise
+                set lines to append(lines, ev["data"])
+    proc_close(p)
+    let out be join(lines, "\n")
+    when timed_out
+        give "ERROR: plugin timed out after " + text(t) + "s (killed). Output so far:\n" + out
+    when code != 0
+        give "ERROR: plugin exited with code " + text(code) + "\n" + out
+    give when trim(out) == "" then "(no output)" otherwise out
+
+-- separa "python plugin.py --x" en exe + args (comillas simples/dobles respetadas)
+export task split_command(line)
+    let toks be []
+    let cur be ""
+    let q be ""
+    let has be false
+    let i be 0
+    while i < length(line)
+        let ch be slice(line, i, i + 1)
+        set i to i + 1
+        when q != ""
+            when ch == q
+                set q to ""
+            otherwise
+                set cur to cur + ch
+        otherwise when ch == "\"" or ch == "'"
+            set q to ch
+            set has to true
+        otherwise when ch == " " or ch == "\t"
+            when cur != "" or has
+                set toks to append(toks, cur)
+                set cur to ""
+                set has to false
+        otherwise
+            set cur to cur + ch
+    when cur != "" or has
+        set toks to append(toks, cur)
+    give toks
+
+export task call(full_name, args)
+    require exec
+    require time
+    require file(".lampson")
+    require file(".lampson/*")
+    require file.read("plugins")
+    require file.read("plugins/*")
+    require file("workspace")
+    require file("workspace/*")
+    require env("LAMPSON_*")
+    let parts be split_name(full_name)
+    let found be where(enabled(), (l) => l["name"] == parts["plugin"])
+    when length(found) == 0
+        give "ERROR: plugin '" + parts["plugin"] + "' is not enabled (the user turns plugins on)"
+    let l be found[0]
+    let tl be where(l["tools"], (t) => t["name"] == parts["tool"])
+    when length(tl) == 0
+        give "ERROR: plugin '" + l["name"] + "' has no tool '" + parts["tool"] + "'"
+    -- PLUGIN_DIR relativa a la raíz de lampson (cwd del hijo para kind=syn); PLUGIN_WORKSPACE = la ruta real del
+    -- proyecto (lampson.ps1 la exporta; sin ella, la junction). LAMP_* = los nombres viejos, por compat.
+    let tool_args be json_encode(when args == nothing then {} otherwise args)
+    let ws be env("LAMPSON_WORKSPACE", c.ROOT)
+    let envs be {"PLUGIN_TOOL": parts["tool"], "PLUGIN_ARGS": tool_args, "PLUGIN_DIR": l["dir"], "PLUGIN_WORKSPACE": ws, "LAMP_TOOL": parts["tool"], "LAMP_ARGS": tool_args, "LAMP_DIR": l["dir"], "LAMP_WORKSPACE": ws}
+    when l["kind"] == "syn"
+        -- techo del manifiesto: el código del plugin no puede pedir más de lo que el humano aprobó
+        give c.truncate(run_child(env("LAMPSON_SYNSEMA", "synsema"), ["run", "--cap-set", ceiling_of(l), l["dir"] + "/" + l["entry"]], ".", envs, l["timeout"]), c.MAX_OUTPUT)
+    let argv be split_command(l["command"])
+    when length(argv) == 0
+        give "ERROR: plugin '" + l["name"] + "' has an empty command"
+    -- el comando corre desde la RAÍZ DEL WORKSPACE (para que "python plugin.py" vea el proyecto), así que un
+    -- token que nombra un archivo de la carpeta del plugin se resuelve solo (2026-08-28: "python lamp.py"
+    -- salía con code 2 porque lamp.py no estaba en el cwd)
+    let rel_dir be when starts_with(l["dir"], c.ROOT + "/") then slice(l["dir"], length(c.ROOT) + 1, length(l["dir"])) otherwise "../" + l["dir"]
+    let resolved be []
+    each tok in argv
+        when not contains(tok, "/") and not contains(tok, "\\") and file_exists(l["dir"] + "/" + tok)
+            set resolved to append(resolved, rel_dir + "/" + tok)
+        otherwise
+            set resolved to append(resolved, tok)
+    give c.truncate(run_child(resolved[0], slice(resolved, 1, length(resolved)), c.ROOT, envs, l["timeout"]), c.MAX_OUTPUT)
+
+-- crear un plugin DEL PROYECTO (workspace/.lampson/plugins/<name>/): escribe plugin.json + el código, revalida el
+-- manifiesto y, si es syn, corre `synsema check` sobre el entry. Como cordis_define en dsh: define y valida,
+-- NO ejecuta ni enciende — encender sigue siendo del humano (set_enabled tras ask).
+-- `files` = {"plugin.syn": "…", "helper.py": "…"}: nombres simples (sin / ni ..) dentro de la carpeta.
+export task create(name, manifest, files)
+    require exec
+    require time
+    require file(".lampson")
+    require file(".lampson/*")
+    require file.read("plugins")
+    require file.read("plugins/*")
+    require file("workspace")
+    require file("workspace/*")
+    require env("LAMPSON_*")
+    when not valid_name(name)
+        raise("invalid plugin name '" + text(name) + "': letters, digits and - only (no _), max 32")
+    when manifest == nothing or not contains(manifest, "tools")
+        raise("manifest needs at least \"tools\" (and \"entry\" for kind=syn or \"command\" for kind=exec)")
+    let dir be PROJECT_DIR + "/" + name
+    let m be manifest
+    set m["name"] to name
+    when not contains(m, "kind")
+        set m["kind"] to "syn"
+    write_file(dir + "/plugin.json", json_encode(m))
+    let written be ["plugin.json"]
+    when files != nothing
+        each fname in keys(files)
+            when not matches(fname, "[A-Za-z0-9_.-]{1,64}") or starts_with(fname, ".")
+                raise("bad file name '" + fname + "' (simple names inside the plugin folder only)")
+            write_file(dir + "/" + fname, text(files[fname]))
+            set written to append(written, fname)
+    let found be where(all(), (l) => l["name"] == name)
+    when length(found) == 0
+        raise("plugin written but not discovered (?)")
+    let l be found[0]
+    when l["error"] != nothing
+        give "plugin '" + name + "' written to " + dir + " but its manifest is INVALID: " + text(l["error"]) + " — fix it with edit and call plugin(action=list) to re-check"
+    let note be ""
+    when l["kind"] == "syn"
+        let chk be run_child(env("LAMPSON_SYNSEMA", "synsema"), ["check", l["dir"] + "/" + l["entry"]], ".", {}, 30)
+        when starts_with(chk, "ERROR")
+            give "plugin '" + name + "' written to " + dir + " but `synsema check " + l["entry"] + "` FAILED:\n" + chk + "\nFix the code with edit; it stays off until it checks and the user turns it on."
+        set note to " · synsema check OK · ceiling when on: " + ceiling_of(l)
+    when l["kind"] == "exec"
+        set note to " · exec (no capability ceiling: the user will see that when approving)"
+    give "plugin '" + name + "' created (project, " + l["kind"] + ", " + text(length(l["tools"])) + " tools: " + join(apply(l["tools"], (t) => t["name"]), ", ") + ") in " + dir + " [" + join(written, ", ") + "]" + note + (when l["kind"] == "exec" then ". The command runs from the workspace root; a file of the plugin folder named in the command is resolved automatically" otherwise "") + ". It is OFF until the user turns it on: offer to do it (plugin action=enable asks them), or point them to the plugin switch of their UI. Its tools will be " + PREFIX + name + "_<tool>."
+
+-- eliminar un plugin DEL PROYECTO: borra su carpeta (no hay delete_file en el runtime → rm -rf por el shell
+-- de bash.syn) y lo saca del estado. Los globales (plugins/) se borran a mano: son de la instalación, no del repo.
+export task remove(name)
+    require exec
+    require time
+    require env("LAMPSON_*")
+    require env("OS")
+    require file(".lampson")
+    require file(".lampson/*")
+    require file.read("plugins")
+    require file.read("plugins/*")
+    require file("workspace")
+    require file("workspace/*")
+    when not valid_name(name)
+        raise("invalid plugin name")
+    let found be where(all(), (l) => l["name"] == name)
+    when length(found) == 0
+        raise("no plugin named '" + name + "'")
+    let l be found[0]
+    when l["scope"] != "project"
+        raise("'" + name + "' is a " + l["scope"] + " plugin (" + GLOBAL_DIR + "/" + name + "): delete that folder by hand")
+    let dir be when l["dir"] != "" then l["dir"] otherwise PROJECT_DIR + "/" + name
+    let is_win be env("OS", "") == "Windows_NT"
+    let sh be env("LAMPSON_SHELL", when is_win then "C:\\Program Files\\Git\\bin\\bash.exe" otherwise "bash")
+    let r be run(sh, ["-c", "rm -rf '" + dir + "'"], 30, {"cwd": "."})
+    when file_exists(dir + "/plugin.json") or file_exists(dir + "/lamp.json")
+        raise("could not delete " + dir + ": " + text(r["stderr"]))
+    let st be load_state()
+    let clean be {}
+    each k in keys(st)
+        when k != name
+            set clean[k] to st[k]
+    write_file(STATE_FILE, json_encode({"enabled": clean}))
+    give "plugin '" + name + "' deleted (" + dir + ")"
+
+-- resumen para UI/terminal/tool
+export task summary()
+    require file(".lampson")
+    require file(".lampson/*")
+    require file.read("plugins")
+    require file.read("plugins/*")
+    require file("workspace")
+    require file("workspace/*")
+    require env("LAMPSON_*")
+    let out be []
+    each l in all()
+        set out to append(out, {"name": l["name"], "scope": l["scope"], "kind": l["kind"], "legacy": l["legacy"], "description": l["description"], "enabled": l["enabled"], "error": l["error"], "caps": when l["kind"] == "syn" and l["error"] == nothing then ceiling_of(l) otherwise "", "command": when l["kind"] == "exec" then l["command"] otherwise "", "tools": apply(l["tools"], (t) => t["name"]), "tool_specs": l["tools"], "dir": l["dir"]})
+    give out

package/lib/prompt.syn

@@ -56,7 +56,7 @@ Operate like a careful senior engineer: precise, honest, and economical with wor
 - bash: shell commands from the workspace root. State does not persist between calls (cd resets) — chain with &&. Check the [exit code: N] marker on every result (it is the last line) and investigate failures before moving on. Never pipe a build or test through head/tail: the output is already truncated for you (the full text is saved to a file whose path you get) and the pipe hides the real exit code. Never run a server or watcher here.
 - process: start/logs/stop long-running commands (dev servers, watchers). Their new log lines arrive automatically with every later tool result — do not sleep or poll. Stop what you started when the task is done.
 - delegate: sub-agents with a fresh context (explore, plan, review, worker); several tasks in one call run in parallel, background=true returns at once and the report arrives later as a message. Give a highly detailed, self-contained brief, say whether it should write code or only research, how to verify, and exactly what to return. Its report is a self-report — verify what matters before telling the user it is done. Its output is not visible to the user: summarise it.
-- memory: durable facts across sessions (user preferences, environment details, tool quirks, conventions). Check it before investigating. Write declarative facts, not instructions to yourself; do not store task progress or anything stale in a week.
+- memory: durable facts across sessions (user preferences, environment details, tool quirks, conventions). Check it before investigating. Write declarative facts, not instructions to yourself; do not store task progress or anything stale in a week. The notes live outside the project: only this tool reaches them (never ls/bash, never files inside the repo).
 - skill: before starting a kind of task, scan the skill list below; if one matches or is even partially relevant, load it and follow it. Err on the side of loading.
 - todo: your task list (whole-list replacement, one in_progress at a time; see Method step 1).
 - MCP tools are named mcp_<server>_<tool>; calling one may ask the user for approval. The mcp tool lists, connects (action=add, with the user's approval) and disconnects servers; a new server's tools enter your catalog on the next turn.
@@ -70,6 +70,6 @@ Concise and direct; lead with the change or the answer, not a preamble. Prefer t
 - OS: {env_info["os"]}   Shell used by bash tool: {env_info["shell"]}
 - Date: {env_info["date"]}
 - Model: {env_info["model"]} via {env_info["provider"]}
-- The user talks to you from the {env_info["ui"]} UI. When something needs the user's hand (turning a lamp on, adding an LSP server, connecting an MCP), tell them the way that exists in THEIR UI: web → the «lámparas» switch / the LSP and MCP sections of the sidebar; terminal → /lamps on <name>, /lsp add <preset>, /mcp add. Never tell a web user to type a slash command — or simply offer to do it yourself (the tool asks them for approval).`
+- The user talks to you from the {env_info["ui"]} UI. When something needs the user's hand (turning a plugin on, adding an LSP server, connecting an MCP), tell them the way that exists in THEIR UI: web → the «plugins» switch / the LSP and MCP sections of the sidebar; terminal → /plugins on <name>, /lsp add <preset>, /mcp add. Never tell a web user to type a slash command — or simply offer to do it yourself (the tool asks them for approval).`
     let mode be when addendum == nothing then "" otherwise (when addendum == "" then "" otherwise "\n\n# Mode\n" + addendum)
     give core + mode + skills.prompt_section(skills.index()) + memo.prompt_section() + read_context_files()

package/lib/sched_run.syn

@@ -1,4 +1,4 @@
--- lib/sched_run.syn — ejecutar UNA tarea programada (lamp | bash | prompt) y dejar registro
+-- lib/sched_run.syn — ejecutar UNA tarea programada (plugin | bash | prompt) y dejar registro
 --
 -- Separado de lib/schedule.syn porque las corridas `prompt` necesitan agents/loop/provider, y schedule.syn es
 -- importado por tools.syn (que agents.syn importa): acá no hay ciclo. Lo usan web.syn (tick del cron y
@@ -23,7 +23,7 @@ use "./session.syn" as session
 use "./trace.syn" as trace
 use "./permission.syn" as permission
 use "./tools.syn" as tools
-use "./lamps.syn" as lamps
+use "./plugins.syn" as plugins
 
 let PROMPT_NOTE be "\n\n# Scheduled run\n- This is an UNATTENDED scheduled run (no user is watching). Do the task, verify, and finish with a short report: what you found or changed, with paths. Do not ask questions - if something is missing, say so in the report.\n- A permission request may take hours to be answered (the user gets a link). Prefer actions that need no approval; if one is denied, do not retry it - report it.\n- ONLY the workspace is accessible: absolute paths, `..`, home folders, other projects and skill folders outside it do NOT exist for your tools (a `File not found` there is final - never retry). Work with what is inside the workspace and what you already know."
 
@@ -67,8 +67,8 @@ export task run(t, ask_fn, on_event)
     require file("workspace/*")
     require file.read("skills")
     require file.read("skills/*")
-    require file.read("lamps")
-    require file.read("lamps/*")
+    require file.read("plugins")
+    require file.read("plugins/*")
     require file("memory")
     require file("memory/*")
     require file(".lampson")
@@ -94,11 +94,11 @@ export task run(t, ask_fn, on_event)
         let names be where(agents.profile(p)["tools"], (n) => n != "delegate" and n != "mcp" and n != "schedule")
         let reg be tools.registry_subset(names)
         let cat be tools.catalog_subset(names)
-        -- lámparas encendidas también (las de solo lectura si el perfil no edita)
+        -- plugins encendidos también (las de solo lectura si el perfil no edita)
         let ro be not (p == "build")
-        each ln in lamps.names(ro)
-            set reg[ln] to "lamp"
-        set cat to cat + lamps.catalog(ro)
+        each ln in plugins.names(ro)
+            set reg[ln] to "plugin"
+        set cat to cat + plugins.catalog(ro)
         let asker be ask_fn
         when asker == nothing and t["permission"] == "ask"
             set asker to ask_remote
@@ -135,8 +135,8 @@ export task tick()
     require file("workspace/*")
     require file.read("skills")
     require file.read("skills/*")
-    require file.read("lamps")
-    require file.read("lamps/*")
+    require file.read("plugins")
+    require file.read("plugins/*")
     require file("memory")
     require file("memory/*")
     require file(".lampson")

package/lib/schedule.syn

@@ -1,7 +1,7 @@
 -- lib/schedule.syn — tareas programadas: "cada 6 h", "todos los días a las 9", "lunes 8:30"
 --
 -- Qué se programa (action.type):
---   lamp   → una tool de una lámpara ENCENDIDA: {lamp, tool, args}. Encenderla ya fue la autorización.
+--   plugin → una tool de un plugin ENCENDIDO: {plugin, tool, args}. Encenderlo ya fue la autorización.
 --   bash   → un comando fijo desde el workspace: {command, timeout}. Aprobado UNA vez, al crear la tarea.
 --   prompt → una corrida completa del agente con un texto: {prompt, agent}. Sin humano al lado: corre con el
 --            sobre de permisos que se fijó al crearla (permission: strict | ask | yolo). En `ask`, cuando el
@@ -23,7 +23,7 @@
 -- Este módulo no importa agents/loop (ciclo con tools.syn): las corridas `prompt` las hace lib/sched_run.syn.
 
 use "./tools/bash.syn" as t_bash
-use "./lamps.syn" as lamps
+use "./plugins.syn" as plugins
 use "./permission.syn" as permission
 use "./tools/common.syn" as c
 use "./tools/memo.syn" as memo
@@ -380,15 +380,19 @@ task slug(name)
 -- valida y normaliza la acción → {ok, action, error}
 task check_action(action)
     when action == nothing or not contains(action, "type")
-        give {"ok": false, "error": "action needs a type: lamp | bash | prompt"}
+        give {"ok": false, "error": "action needs a type: plugin | bash | prompt"}
     let kind be lower(text(action["type"]))
     when kind == "lamp"
-        when not contains(action, "lamp") or not contains(action, "tool")
-            give {"ok": false, "error": "action lamp needs lamp and tool"}
-        let full be lamps.tool_name(text(action["lamp"]), text(action["tool"]))
-        when not contains(lamps.names(false), full)
-            give {"ok": false, "error": "lamp tool " + full + " is not available (the lamp must exist and be ON)"}
-        give {"ok": true, "action": {"type": "lamp", "lamp": text(action["lamp"]), "tool": text(action["tool"]), "args": when contains(action, "args") then action["args"] otherwise {}}}
+        -- compat: "lamp" era el nombre de "plugin" hasta 2026-09 (tareas guardadas, JSON escrito a mano)
+        set kind to "plugin"
+    when kind == "plugin"
+        let pname be plugin_of(action)
+        when pname == "" or not contains(action, "tool")
+            give {"ok": false, "error": "action plugin needs plugin and tool"}
+        let full be plugins.tool_name(pname, text(action["tool"]))
+        when not contains(plugins.names(false), full)
+            give {"ok": false, "error": "plugin tool " + full + " is not available (the plugin must exist and be ON)"}
+        give {"ok": true, "action": {"type": "plugin", "plugin": pname, "tool": text(action["tool"]), "args": when contains(action, "args") then action["args"] otherwise {}}}
     when kind == "bash"
         when not contains(action, "command") or trim(text(action["command"])) == ""
             give {"ok": false, "error": "action bash needs a command"}
@@ -405,7 +409,7 @@ task check_action(action)
         when not contains(["build", "plan", "review", "explore"], agent)
             give {"ok": false, "error": "agent must be build | plan | review | explore"}
         give {"ok": true, "action": {"type": "prompt", "prompt": text(action["prompt"]), "agent": agent}}
-    give {"ok": false, "error": "unknown action type '" + kind + "' (lamp | bash | prompt)"}
+    give {"ok": false, "error": "unknown action type '" + kind + "' (plugin | bash | prompt)"}
 
 -- crear: spec = {name, when, action, permission?, approval_timeout?, notify?} → la tarea (raise si es inválida)
 export task add(spec)
@@ -415,8 +419,8 @@ export task add(spec)
     require env("OS")
     require file(".lampson")
     require file(".lampson/*")
-    require file.read("lamps")
-    require file.read("lamps/*")
+    require file.read("plugins")
+    require file.read("plugins/*")
     require file("workspace")
     require file("workspace/*")
     when spec == nothing or not contains(spec, "when")
@@ -450,9 +454,20 @@ export task add(spec)
     put(t)
     give t
 
+-- el nombre del plugin de una acción; acepta la clave vieja "lamp" (tareas guardadas antes de 2026-09)
+task plugin_of(action)
+    when contains(action, "plugin")
+        give text(action["plugin"])
+    when contains(action, "lamp")
+        give text(action["lamp"])
+    give ""
+
+task is_plugin_action(a)
+    give a["type"] == "plugin" or a["type"] == "lamp"
+
 task default_name(action)
-    when action["type"] == "lamp"
-        give action["lamp"] + " " + action["tool"]
+    when is_plugin_action(action)
+        give plugin_of(action) + " " + action["tool"]
     when action["type"] == "bash"
         let cmd be action["command"]
         give when length(cmd) > 40 then slice(cmd, 0, 40) + "…" otherwise cmd
@@ -533,7 +548,7 @@ export task heartbeat()
     write_file(HEARTBEAT, text(now()))
     give true
 
--- ---------- corridas: lamp y bash (prompt en sched_run.syn) ----------
+-- ---------- corridas: plugin y bash (prompt en sched_run.syn) ----------
 export task run_simple(t)
     require exec
     require time
@@ -541,13 +556,13 @@ export task run_simple(t)
     require env("OS")
     require file(".lampson")
     require file(".lampson/*")
-    require file.read("lamps")
-    require file.read("lamps/*")
+    require file.read("plugins")
+    require file.read("plugins/*")
     require file("workspace")
     require file("workspace/*")
     let a be t["action"]
-    when a["type"] == "lamp"
-        give lamps.call(lamps.tool_name(a["lamp"], a["tool"]), a["args"])
+    when is_plugin_action(a)
+        give plugins.call(plugins.tool_name(plugin_of(a), a["tool"]), a["args"])
     when a["type"] == "bash"
         let v be permission.evaluate("bash", {"command": a["command"]}, "yolo")
         when v["decision"] == "deny"
@@ -640,8 +655,8 @@ export task log_tail(id, n)
 
 -- descripción de la acción (una línea) para previews y listados
 export task describe_action(a)
-    when a["type"] == "lamp"
-        give "lamp " + a["lamp"] + "." + a["tool"] + (when length(keys(a["args"])) > 0 then " " + one_line(json_encode(a["args"]), 80) otherwise "")
+    when is_plugin_action(a)
+        give "plugin " + plugin_of(a) + "." + a["tool"] + (when length(keys(a["args"])) > 0 then " " + one_line(json_encode(a["args"]), 80) otherwise "")
     when a["type"] == "bash"
         give "$ " + one_line(a["command"], 120)
     give "agent " + a["agent"] + ": " + one_line(a["prompt"], 140)