lampson 0.2.6 → 0.2.7

package/README.md

@@ -60,15 +60,15 @@ It can only touch the folder you opened it in — not your home directory, not t
 a setting: it's how the language it's written in works. Reading and editing just happen; deleting, installing,
 `git reset`, `sudo` stop and wait for your *yes*; truly destructive commands are refused in every mode.
 
-## Lamps
+## Plugins
 
-A **lamp** is a small folder that gives Lampson a new tool: query your database, call your company's API,
+A **plugin** is a small folder that gives Lampson a new tool: query your database, call your company's API,
 deploy, send a message. Any language. **Off by default** — you turn each one on, and only then can the agent
 use it.
 
 ```
-~/lampson/lamps/postgres/
-  lamp.json          ← what it's called, what it does, which tools it offers
+~/lampson/plugins/postgres/
+  plugin.json        ← what it's called, what it does, which tools it offers
   query.py           ← the code
 ```
 
@@ -79,12 +79,17 @@ use it.
             "parameters": {"type": "object", "properties": {"sql": {"type": "string"}}}, "readonly": true}]}
 ```
 
-The script gets the call in environment variables (`LAMP_TOOL`, `LAMP_ARGS` as JSON) and prints the result.
-Turn it on with `/lamps on postgres` or the **lámparas** pill in the web UI. Keep lamps global (every project)
-or inside a project (`.lampson/lamps/` — commit it and your team has it). The agent can *write* a lamp for you;
+The script gets the call in environment variables (`PLUGIN_TOOL`, `PLUGIN_ARGS` as JSON) and prints the result.
+Turn it on with `/plugins on postgres` or the **plugins** pill in the web UI. Keep plugins global (every project)
+or inside a project (`.lampson/plugins/` — commit it and your team has it). The agent can *write* a plugin for you;
 turning it on is always yours.
 
-→ [How lamps work](https://lampson.org/docs/lamps) · the example lamp ships in `lamps/example-hello/`.
+→ [How plugins work](https://lampson.org/docs/plugins) · the example ships in `plugins/example-hello/`.
+
+Plugins are yours and local: any language, no sandbox unless you write them in Synsema. For tools with an
+**enforced capability ceiling**, versioned and shared with any agent (Claude Code, Cursor, Lampson…), use
+[lamps.sh](https://lamps.sh): `lamp add <ref>`, then `lamp mcp` as an MCP server in Lampson. (Until 0.2.6
+plugins were called *lamps*; old `.lampson/lamps/` folders and `LAMP_*` variables still work for now.)
 
 ## Also in the box
 
@@ -94,7 +99,7 @@ memory it reads back next session · sessions with a readable trace of every ste
 
 ## Learn more
 
-- **[lampson.org/docs](https://lampson.org/docs)** — quickstart, permissions, providers, lamps, schedules…
+- **[lampson.org/docs](https://lampson.org/docs)** — quickstart, permissions, providers, plugins, schedules…
 - **[guide.md](guide.md)** — the long version: how it runs, architecture, every knob, runtime notes.
 
 ## License

package/bin/lampson.js

@@ -2,7 +2,7 @@
 // bin/lampson.js — entry point of the npm package (`npm i -g lampson`).
 //
 // The code ships inside node_modules, but Lampson keeps STATE next to its code: the mounted `workspace`
-// junction, `.lampson/` (config, sessions, traces, spill), `memory/` and global `lamps/`. Living inside
+// junction, `.lampson/` (config, sessions, traces, spill), `memory/` and global `plugins/`. Living inside
 // node_modules would lose all of that on every `npm i -g lampson@latest`. So this launcher keeps a stable
 // home (LAMPSON_HOME, default ~/lampson), syncs the package's code files into it when the version changes,
 // and runs the same launcher the git install uses (lampson.ps1 / lampson.sh). Everything else — synsema on
@@ -45,6 +45,9 @@ function sync() {
   try { installed = fs.readFileSync(marker, 'utf8').trim(); } catch (e) { /* first run */ }
   if (installed === pkg.version && fs.existsSync(path.join(home, 'chat.syn'))) return 'ok';
   fs.mkdirSync(home, { recursive: true });
+  // the folders every workspace links to (lib/workspaces.syn LINKS): if `memory/` does not exist when the
+  // link is made, the link is born dangling and memory(write) fails with "No such file or directory"
+  for (const d of ['memory', 'plugins']) fs.mkdirSync(path.join(home, d), { recursive: true });
   for (const item of CODE) {
     const src = path.join(pkgDir, item);
     if (!fs.existsSync(src)) continue;
@@ -52,11 +55,14 @@ function sync() {
     if (fs.statSync(src).isDirectory()) { fs.rmSync(dst, { recursive: true, force: true }); copyDir(src, dst); }
     else copyFile(src, dst);
   }
-  // global lamps are user content: seed the example once, never overwrite what the user put there
-  const lampsSrc = path.join(pkgDir, 'lamps'), lampsDst = path.join(home, 'lamps');
-  if (fs.existsSync(lampsSrc)) {
-    for (const e of fs.readdirSync(lampsSrc, { withFileTypes: true })) {
-      if (e.isDirectory() && !fs.existsSync(path.join(lampsDst, e.name))) copyDir(path.join(lampsSrc, e.name), path.join(lampsDst, e.name));
+  // global plugins are user content: seed the example once, never overwrite what the user put there.
+  // Until 2026-08 the folder was `lamps/` (they were "lamps"): an existing one is renamed once, same content.
+  const legacyDst = path.join(home, 'lamps'), pluginsDst = path.join(home, 'plugins');
+  if (fs.existsSync(legacyDst) && !fs.existsSync(pluginsDst)) { fs.renameSync(legacyDst, pluginsDst); console.log('lampson: renamed ' + legacyDst + ' -> ' + pluginsDst + ' (lamps are now called plugins)'); }
+  const pluginsSrc = path.join(pkgDir, 'plugins');
+  if (fs.existsSync(pluginsSrc)) {
+    for (const e of fs.readdirSync(pluginsSrc, { withFileTypes: true })) {
+      if (e.isDirectory() && !fs.existsSync(path.join(pluginsDst, e.name))) copyDir(path.join(pluginsSrc, e.name), path.join(pluginsDst, e.name));
     }
   }
   fs.writeFileSync(marker, pkg.version + '\n');
@@ -68,7 +74,7 @@ if (args.some(a => /^--?(version|v)$/i.test(a))) { console.log('lampson ' + pkg.
 
 let state;
 try { state = sync(); } catch (e) { console.error('lampson: could not prepare ' + home + ': ' + e.message); process.exit(1); }
-if (state === 'installed') console.log('lampson ' + pkg.version + ' → ' + home + ' (your config, sessions and lamps live there)');
+if (state === 'installed') console.log('lampson ' + pkg.version + ' → ' + home + ' (your config, sessions and plugins live there)');
 if (state === 'updated') console.log('lampson updated to ' + pkg.version + ' in ' + home);
 
 // --update under npm: the code comes from the registry, not from git

package/chat.syn

@@ -22,8 +22,8 @@ require file("workspace")
 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")
@@ -49,7 +49,7 @@ 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/plugins.syn" as plugins
 use "./lib/lsp.syn" as lsp
 use "./lib/tools/todo.syn" as todo
 use "./lib/schedule.syn" as schedule
@@ -348,9 +348,9 @@ let COMMANDS be [
     ["/agents", "", "subagentes lanzados con delegate: estado, pasos y log de cada uno"],
     ["/todo", "", "lista de tareas del agente en esta sesión (la mantiene con la tool todo)"],
     ["/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/)"],
+    ["/plugins", "[on <nombre> | off <nombre> | run <plugin> <tool> [json] | remove <nombre>]", "plugins (tools propias, en cualquier lenguaje): listar, encender o apagar (global: lampson/plugins/ · proyecto: .lampson/plugins/)"],
     ["/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)"],
+    ["/schedule", "[add <json> | run <id> | on <id> | off <id> | remove <id> | log <id>]", "tareas programadas (cada 6h, todos los días a las 9…): plugin, 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 (sin yes|no la pregunta con el menú ↑↓)"],
     ["/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)"],
@@ -393,10 +393,10 @@ task complete_args(cmd, head, last)
         give []
     when cmd == "/memory"
         give apply((m) => m["name"], memo.list())
-    when cmd == "/lamps"
+    when cmd == "/plugins"
         when first
             give ["on", "off", "run", "remove"]
-        give apply((l) => l["name"], lamps.summary())
+        give apply((l) => l["name"], plugins.summary())
     when cmd == "/mcp"
         when first
             give ["add", "remove"]
@@ -565,21 +565,21 @@ task banner(ws, cfg, profile, mode, sid)
     print("  workspace   " + ws)
     print("  agente      " + profile + "        permisos  " + mode + "        modelo  " + cfg["model"])
     print("  sesión      " + sid + "        " + git.summary())
-    -- extensiones en una línea (detalle con /lamps, /mcp, /lsp): encendidas/total
-    let ls be lamps.summary()
-    let lamps_on be length(where(ls, (l) => l["enabled"]))
+    -- extensiones en una línea (detalle con /plugins, /mcp, /lsp): encendidas/total
+    let ls be plugins.summary()
+    let plugins_on be length(where(ls, (l) => l["enabled"]))
     let ms be mcp.summary()
     let mcp_on be length(where(ms, (m) => m["status"] == "ready"))
     let ss be lsp.summary()
     let ext be []
     when length(ls) > 0
-        set ext to append(ext, (when lamps_on > 0 then green("lamps " + text(lamps_on) + "/" + text(length(ls))) otherwise dim("lamps 0/" + text(length(ls)))))
+        set ext to append(ext, (when plugins_on > 0 then green("plugins " + text(plugins_on) + "/" + text(length(ls))) otherwise dim("plugins 0/" + text(length(ls)))))
     when length(ms) > 0
         set ext to append(ext, (when mcp_on == length(ms) then green("mcp " + text(mcp_on) + "/" + text(length(ms))) otherwise red("mcp " + text(mcp_on) + "/" + text(length(ms)))))
     when length(ss) > 0
         set ext to append(ext, dim("lsp " + text(length(ss))))
     when length(ext) > 0
-        print("  extras      " + join(ext, dim("  ·  ")) + dim("   (/lamps /mcp /lsp)"))
+        print("  extras      " + join(ext, dim("  ·  ")) + dim("   (/plugins /mcp /lsp)"))
     let upd be update.line()
     when upd != ""
         print("  " + yellow("⬆ " + upd) + dim("  (o /update acá)"))
@@ -815,8 +815,8 @@ agent Sched
     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")
@@ -902,13 +902,13 @@ let system_msg be system_for(profile)
 -- servers MCP (globales en .lampson/mcp.json, del proyecto en workspace/.lampson/mcp.json): arrancan antes
 -- de armar el catálogo de tools; hasta 8 s de espera a que estén listos
 let mcp_servers be mcp.start_all(8)
--- mcp / lsp / lámparas van resumidos en el banner ("extras"); acá solo se avisa lo que está ROTO
+-- mcp / lsp / plugins van resumidos en el banner ("extras"); acá solo se avisa lo que está ROTO
 each ms in mcp.summary()
     when ms["status"] != "ready"
         print("  " + red("○ mcp " + ms["name"] + " " + ms["status"]) + dim(when ms["error"] != nothing then " · " + text(ms["error"]) otherwise ""))
-each l in lamps.summary()
+each l in plugins.summary()
     when l["error"] != nothing
-        print("  " + red("○ lamp " + l["name"] + " rota") + dim(" · " + text(l["error"])))
+        print("  " + red("○ plugin " + l["name"] + " roto") + dim(" · " + text(l["error"])))
 let opts be opts_for(profile, lower(env("LAMPSON_PERMISSION", "ask")))
 
 -- marca de corrida (blackboard): session.save la estampa en meta.run; reanudar una sesión guardada por
@@ -1181,7 +1181,7 @@ while running
                 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("when: every 6h · daily 09:00 · mon,wed 08:30 · weekdays 09:00   action.type: plugin {plugin, 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
@@ -1249,13 +1249,17 @@ while running
                     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)))
+        otherwise when input == "/plugins" or starts_with(input, "/plugins ") or input == "/lamps" or starts_with(input, "/lamps ")
+            -- /lamps = el nombre viejo (hasta 2026-09): sigue andando, con aviso
+            let is_old be starts_with(input, "/lamps")
+            when is_old
+                print("  " + dim("/lamps ahora es /plugins (las lámparas de lampson pasaron a llamarse plugins)"))
+            let lrest be trim(slice(input, when is_old then 6 otherwise 8, length(input)))
             when starts_with(lrest, "run ")
-                -- /lamps run <lámpara> <tool> [json de args]  → la corre el usuario, sin el modelo
+                -- /plugins run <plugin> <tool> [json de args]  → la corre el usuario, sin el modelo
                 let rt be where(split(trim(slice(lrest, 4, length(lrest))), " "), (x) => x != "")
                 when length(rt) < 2
-                    print("  uso: /lamps run <lámpara> <tool> [{\"arg\": \"valor\"}]")
+                    print("  uso: /plugins run <plugin> <tool> [{\"arg\": \"valor\"}]")
                 otherwise
                     let rargs be {}
                     when length(rt) > 2
@@ -1264,30 +1268,31 @@ while running
                         recover err
                             print("  " + red("args: JSON inválido"))
                     try
-                        print(lamps.call(lamps.tool_name(rt[0], rt[1]), rargs))
+                        print(plugins.call(plugins.tool_name(rt[0], rt[1]), rargs))
                     recover err
                         print("  " + red(text(err)))
             otherwise when starts_with(lrest, "remove ")
                 try
-                    print("  " + lamps.remove(trim(slice(lrest, 7, length(lrest)))))
+                    print("  " + plugins.remove(trim(slice(lrest, 7, length(lrest)))))
                 recover err
                     print("  " + red(text(err)))
                 set opts to opts_for(profile, mode)
             otherwise when starts_with(lrest, "on ") or starts_with(lrest, "off ")
                 let lon be starts_with(lrest, "on ")
                 try
-                    print("  " + lamps.set_enabled(trim(slice(lrest, when lon then 3 otherwise 4, length(lrest))), lon))
+                    print("  " + plugins.set_enabled(trim(slice(lrest, when lon then 3 otherwise 4, length(lrest))), lon))
                 recover err
                     print("  " + red(text(err)))
                 set opts to opts_for(profile, mode)
             otherwise
-                let ls be lamps.summary()
+                let ls be plugins.summary()
                 when length(ls) == 0
-                    print("  sin lámparas. Una lámpara es una carpeta con lamp.json: " + dim("lampson\\lamps\\<nombre>\\ (global) · .lampson\\lamps\\<nombre>\\ del repo (proyecto)"))
-                    print("  " + dim("el agente también puede crearlas (write en .lampson/lamps/) y pedirte encenderlas"))
+                    print("  sin plugins. Un plugin es una carpeta con plugin.json: " + dim("lampson\\plugins\\<nombre>\\ (global) · .lampson\\plugins\\<nombre>\\ del repo (proyecto)"))
+                    print("  " + dim("el agente también puede crearlos (write en .lampson/plugins/) y pedirte encenderlos"))
                 each l in ls
-                    print("  " + (when l["enabled"] then green("● ") otherwise dim("○ ")) + pad(l["name"], 14) + dim(pad(l["scope"], 8) + pad(l["kind"], 5)) + (when l["error"] != nothing then red("rota: " + text(l["error"])) otherwise dim(text(length(l["tools"])) + " tools [" + join(l["tools"], ", ") + "]" + (when l["kind"] == "syn" then "  techo: " + l["caps"] otherwise "  $ " + l["command"]))))
-                print("  " + dim("encender/apagar: /lamps on <nombre> · /lamps off <nombre> · correr una vos: /lamps run <lámpara> <tool> [json]"))
+                    print("  " + (when l["enabled"] then green("● ") otherwise dim("○ ")) + pad(l["name"], 14) + dim(pad(l["scope"], 8) + pad(l["kind"], 5)) + (when l["error"] != nothing then red("roto: " + text(l["error"])) otherwise dim(text(length(l["tools"])) + " tools [" + join(l["tools"], ", ") + "]" + (when l["kind"] == "syn" then "  techo: " + l["caps"] otherwise "  $ " + l["command"]))) + (when l["legacy"] then yellow("  carpeta vieja .lampson/lamps/ → renombrala a .lampson/plugins/") otherwise ""))
+                print("  " + dim("encender/apagar: /plugins on <nombre> · /plugins off <nombre> · correr uno vos: /plugins run <plugin> <tool> [json]"))
+                print("  " + dim("¿herramientas con techo real, versionadas y para cualquier agente? eso son las lámparas de lamps.sh: lamp add <ref> y entran por /mcp add lamps lamp mcp"))
         otherwise when input == "/mcp" or starts_with(input, "/mcp ")
             let mrest be trim(slice(input, 4, length(input)))
             when starts_with(mrest, "add ")

package/lampson.ps1

@@ -8,7 +8,7 @@
 #   lampson --agent plan · --yolo|--strict|--ask · --update · --help
 #
 # Cómo funciona (ver SPEC-WORKSPACES.md): .lampson\ws\<slug>\ es el cwd del proceso del workspace, con una junction
-# `workspace` al proyecto y junctions a lib/public/skills/lamps/memory de esta instalación. El registro y los procesos
+# `workspace` al proyecto y junctions a lib/public/skills/plugins/memory de esta instalación. El registro y los procesos
 # los maneja lib/workspaces.syn vía cli.syn; este script solo resuelve la carpeta, llama a cli.syn y abre lo pedido.
 $ErrorActionPreference = "Stop"
 $here = Split-Path -Parent $MyInvocation.MyCommand.Path
@@ -45,6 +45,16 @@ foreach ($k in $skillMounts.Keys) {
     $link = Join-Path $here ".lampson\$k"; $src = $skillMounts[$k]
     if (-not (Test-Path -LiteralPath $link) -and (Test-Path -LiteralPath $src -PathType Container)) { New-Item -ItemType Junction -Path $link -Target $src | Out-Null }
 }
+# 2026-09: las "lámparas" globales pasaron a llamarse plugins (plugins\). git renombra las del repo; las carpetas que
+# vos pusiste en lamps\ se mueven una vez, y la carpeta vieja se borra solo si quedó vacía.
+$oldLamps = Join-Path $here "lamps"
+if (Test-Path -LiteralPath $oldLamps -PathType Container) {
+    $newPlugins = Join-Path $here "plugins"; New-Item -ItemType Directory -Force $newPlugins | Out-Null
+    foreach ($d in Get-ChildItem -LiteralPath $oldLamps -Directory -Force) {
+        if (-not (Test-Path -LiteralPath (Join-Path $newPlugins $d.Name))) { Move-Item -LiteralPath $d.FullName -Destination $newPlugins; Write-Host "lampson: lamps\$($d.Name) → plugins\$($d.Name) (las lámparas ahora son plugins)" }
+    }
+    if (-not (Get-ChildItem -LiteralPath $oldLamps -Force)) { Remove-Item -LiteralPath $oldLamps -Force }
+}
 
 function Invoke-Cli([string]$cmd, [string]$ws) {
     # cli.syn imprime la respuesta como la ÚLTIMA línea (JSON)

package/lampson.sh

@@ -32,6 +32,13 @@ for pair in "skills-global:$HOME/.agents/skills" "skills-claude:$HOME/.claude/sk
     link="$here/.lampson/${pair%%:*}"; src="${pair#*:}"
     [ -e "$link" ] || { [ -d "$src" ] && ln -s "$src" "$link"; } || true
 done
+# 2026-09: las "lámparas" globales pasaron a llamarse plugins (plugins/). git renombra las del repo; las carpetas
+# que vos pusiste en lamps/ se mueven una vez, y la carpeta vieja se borra solo si quedó vacía.
+if [ -d "$here/lamps" ]; then
+    mkdir -p "$here/plugins"
+    for d in "$here"/lamps/*/; do [ -d "$d" ] || continue; n="$(basename "$d")"; [ -e "$here/plugins/$n" ] || { mv "$d" "$here/plugins/$n" && echo "lampson: lamps/$n → plugins/$n (las lámparas ahora son plugins)"; }; done
+    rmdir "$here/lamps" 2>/dev/null || true
+fi
 cli() { # última línea = JSON
     local out; out="$(cd "$here" && LAMPSON_CMD="$1" LAMPSON_WORKSPACE="${2:-}" synsema run cli.syn)" || { echo "$out" >&2; exit 1; }
     echo "$out" | sed '$d' >&2 || true

package/lib/agents.syn

@@ -32,7 +32,7 @@ use "./loop.syn" as loop
 use "./provider.syn" as provider
 use "./prompt.syn" as prompt
 use "./mcp.syn" as mcp
-use "./lamps.syn" as lamps
+use "./plugins.syn" as plugins
 
 export let DIR be ".lampson/agents"
 let MAX_TASKS be 6
@@ -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", "schedule", "delegate"],
+        "tools": ["read", "write", "edit", "ls", "find", "grep", "lsp", "bash", "process", "memory", "todo", "skill", "mcp", "plugin", "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)."
     },
@@ -105,8 +105,8 @@ export task registry_for(name)
         set reg["delegate"] to delegate
     each m in mcp.names(mcp_readonly_only(name))
         set reg[m] to "mcp"
-    each m in lamps.names(mcp_readonly_only(name))
-        set reg[m] to "lamp"
+    each m in plugins.names(mcp_readonly_only(name))
+        set reg[m] to "plugin"
     give reg
 
 export task catalog_for(name)
@@ -119,7 +119,7 @@ export task catalog_for(name)
     let cat be tools.catalog_subset(p["tools"])
     when contains(p["tools"], "delegate")
         set cat to append(cat, DELEGATE_SPEC)
-    give cat + mcp.catalog(mcp_readonly_only(name)) + lamps.catalog(mcp_readonly_only(name))
+    give cat + mcp.catalog(mcp_readonly_only(name)) + plugins.catalog(mcp_readonly_only(name))
 
 -- Info de entorno para el system prompt (compartida por chat.syn / web.syn / delegate)
 export task env_info(cfg)
@@ -128,7 +128,7 @@ export task env_info(cfg)
     require time
     let sc be tools.shell_config()
     -- desde dónde habla el usuario (blackboard "lampson:ui", lo comparte el entry): el modelo NO debe decirle
-    -- "/lamps" a alguien que está en la web (2026-08-28)
+    -- "/plugins" a alguien que está en la web (2026-08-28)
     observe "lampson:ui" as ui
     give {
         "ui": when ui == nothing then "terminal" otherwise text(ui["kind"]),

package/lib/loop.syn

@@ -23,7 +23,7 @@
 use "./provider.syn" as provider
 use "./permission.syn" as permission
 use "./mcp.syn" as mcp
-use "./lamps.syn" as lamps
+use "./plugins.syn" as plugins
 use "./tools/todo.syn" as todo
 
 let MAX_ERRORS_PER_TURN be 8
@@ -285,9 +285,9 @@ task execute(tc, opts, on_event)
         -- tools MCP: no son tasks Synsema (args libres); el registry las marca con "mcp"
         when registry[name] == "mcp"
             set out to text(mcp.call(name, args))
-        -- tools de lámparas: un proceso hijo por llamada (lib/lamps.syn)
-        otherwise when registry[name] == "lamp"
-            set out to text(lamps.call(name, args))
+        -- tools de plugins: un proceso hijo por llamada (lib/plugins.syn)
+        otherwise when registry[name] == "plugin"
+            set out to text(plugins.call(name, args))
         otherwise
             set out to text(call_tool(registry[name], args))
     recover err

package/lib/permission.syn

@@ -91,20 +91,20 @@ export task evaluate(name, args, mode)
         when mode == "strict"
             give {"decision": "deny", "reason": "strict mode (adds an LSP server)"}
         give {"decision": "ask", "reason": "configures LSP server '" + (when contains(args, "server") then text(args["server"]) otherwise "?") + "' (" + (when contains(args, "scope") then text(args["scope"]) otherwise "global") + ") — it will run the preset command on the first query"}
-    when starts_with(name, "lamp_")
-        -- tool de una lámpara (código del usuario/agente, un proceso por llamada): como las MCP
+    when starts_with(name, "plugin_")
+        -- tool de un plugin (código del usuario/agente, un proceso por llamada): como las MCP
         when mode == "yolo"
-            give {"decision": "allow", "reason": "yolo mode (lamp tool)"}
+            give {"decision": "allow", "reason": "yolo mode (plugin tool)"}
         when mode == "strict"
-            give {"decision": "deny", "reason": "strict mode (lamp tool)"}
-        give {"decision": "ask", "reason": "lamp tool " + name}
-    when name == "lamp"
-        -- encender una lámpara = autorizar código a correr con las capacidades de su manifiesto: humano SIEMPRE
+            give {"decision": "deny", "reason": "strict mode (plugin tool)"}
+        give {"decision": "ask", "reason": "plugin tool " + name}
+    when name == "plugin"
+        -- encender un plugin = autorizar código a correr con las capacidades de su manifiesto: humano SIEMPRE
         let act be when contains(args, "action") then text(args["action"]) otherwise "list"
         when act == "enable" or act == "disable"
             when mode == "strict"
-                give {"decision": "deny", "reason": "strict mode (" + act + " lamp)"}
-            give {"decision": "ask", "reason": act + "s lamp '" + (when contains(args, "name") then text(args["name"]) otherwise "?") + "'"}
+                give {"decision": "deny", "reason": "strict mode (" + act + " plugin)"}
+            give {"decision": "ask", "reason": act + "s plugin '" + (when contains(args, "name") then text(args["name"]) otherwise "?") + "'"}
         give {"decision": "allow", "reason": "read-only tool"}
     when name == "mcp"
         -- conectar un server MCP = ejecutar un comando de terceros con env propio: humano siempre, incluso en yolo
@@ -115,7 +115,7 @@ export task evaluate(name, args, mode)
             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
+        -- programar = autorizar corridas futuras SIN nadie mirando (un comando, un plugin, 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"
@@ -140,15 +140,15 @@ task one_line(s, max)
     give t
 
 export task describe_call(name, args)
-    when starts_with(name, "mcp_") or starts_with(name, "lamp_")
+    when starts_with(name, "mcp_") or starts_with(name, "plugin_")
         give name + " " + one_line(json_encode(args), 160)
     when name == "lsp" and contains(args, "op") and text(args["op"]) == "add"
         give "lsp add " + (when contains(args, "server") then text(args["server"]) otherwise "?") + " (" + (when contains(args, "scope") then text(args["scope"]) otherwise "global") + ")"
     when name == "lsp"
         give "lsp " + (when contains(args, "op") then text(args["op"]) otherwise "?") + " " + (when contains(args, "path") then text(args["path"]) otherwise "?") + (when contains(args, "line") then ":" + text(args["line"]) + (when contains(args, "character") then ":" + text(args["character"]) otherwise "") otherwise "")
-    when name == "lamp"
+    when name == "plugin"
         let lact be when contains(args, "action") then text(args["action"]) otherwise "list"
-        give "lamp " + lact + (when lact != "list" then " " + (when contains(args, "name") then text(args["name"]) otherwise "?") otherwise "") + (when lact == "create" and contains(args, "files") then " [" + join(keys(args["files"]), ", ") + "]" otherwise "")
+        give "plugin " + lact + (when lact != "list" then " " + (when contains(args, "name") then text(args["name"]) otherwise "?") otherwise "") + (when lact == "create" and contains(args, "files") then " [" + join(keys(args["files"]), ", ") + "]" otherwise "")
     when name == "mcp"
         let act be when contains(args, "action") then text(args["action"]) otherwise "list"
         when act == "add"
@@ -160,7 +160,7 @@ export task describe_call(name, args)
         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))
+            let body be when what == "plugin" then "plugin " + arg(args, "plugin", "?") + "." + 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)