lampson 0.2.6 → 0.2.8

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,22 +79,28 @@ 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
 
 Sub-agents that work in parallel · skills (`SKILL.md` procedures, anything on [skills.sh](https://skills.sh)
 works) · MCP servers with the JSON you already have · language servers for real go-to-definition · project
-memory it reads back next session · sessions with a readable trace of every step · paste a screenshot and ask.
+memory it reads back next session · sessions with a readable trace of every step · web pages fetched as
+Markdown (a tenth of the tokens of raw HTML) · paste a screenshot and ask.
 
 ## 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
@@ -165,7 +165,7 @@ task print_diff_with(lead, path, d)
 
 -- 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"
+    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" or name == "fetch"
 
 let pending_call be ""
 
@@ -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,27 +40,27 @@ 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", "fetch", "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)."
     },
     "plan": {
-        "tools": ["read", "ls", "find", "grep", "lsp", "memory", "todo", "skill", "delegate"],
+        "tools": ["read", "ls", "find", "grep", "lsp", "fetch", "memory", "todo", "skill", "delegate"],
         "steps": 30,
         "addendum": "You are in PLAN mode: READ-ONLY. You cannot edit files or run commands (those tools are not available). Investigate the codebase, then answer with a concrete, numbered implementation plan: files to touch, what changes in each, risks, and how to verify. Do not write code beyond short illustrative snippets."
     },
     "review": {
-        "tools": ["read", "ls", "find", "grep", "lsp", "bash", "process", "memory", "skill"],
+        "tools": ["read", "ls", "find", "grep", "lsp", "fetch", "bash", "process", "memory", "skill"],
         "steps": 25,
         "addendum": "You are a REVIEWER: read-only on files (no write/edit), but you may run commands (tests, linters, git diff). Find real bugs, missing error handling, security issues and violations of the project's conventions. Report findings as a list with file:line, severity and a suggested fix. Do not modify files."
     },
     "explore": {
-        "tools": ["read", "ls", "find", "grep", "lsp", "memory", "skill"],
+        "tools": ["read", "ls", "find", "grep", "lsp", "fetch", "memory", "skill"],
         "steps": 20,
         "addendum": "You are an EXPLORER: read-only. Locate the code relevant to the question (files, functions, line numbers) and report it concisely with paths and short excerpts. Do not propose changes."
     },
     "worker": {
-        "tools": ["read", "write", "edit", "ls", "find", "grep", "lsp", "bash", "process", "memory", "todo", "skill"],
+        "tools": ["read", "write", "edit", "ls", "find", "grep", "lsp", "fetch", "bash", "process", "memory", "todo", "skill"],
         "steps": 40,
         "addendum": "You are a WORKER sub-agent: implement exactly the scoped task you were given (read, edit, run tests), then report what you changed (files) and how you verified it. Stay inside the scope; if something outside it is needed, report it instead of doing it."
     }
@@ -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/fs.syn

@@ -0,0 +1,226 @@
+-- lib/fs.syn — operaciones de archivos del explorador web: crear, renombrar, mover, copiar, borrar
+--
+-- El runtime tiene write_file/list_dir/file_info pero NO rename/delete/copy/mkdir (v0.6.14), así que mover,
+-- copiar y borrar corren por el shell POSIX (Git Bash en Windows), igual que plugins.remove. Todo path viene
+-- del navegador y pasa por common.ws(): relativo al workspace, sin `..` ni absolutos (raise instructivo).
+-- Reglas al estilo VS Code: nunca pisar un destino existente; duplicar = "<nombre> copy<.ext>", luego
+-- "<nombre> copy 2<.ext>"…; una carpeta no se mueve/copia dentro de sí misma; la raíz no se toca.
+use "./tools/common.syn" as c
+
+task sh_quote(s)
+    give "'" + replace_text(s, "'", "'\\''") + "'"
+
+-- shell POSIX aunque LAMPSON_SHELL apunte a cmd: mv/cp/rm/mkdir son de Git Bash
+task shell()
+    require env("LAMPSON_*")
+    require env("OS")
+    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")
+    when is_win and not c.ends_with(lower(sh), "bash.exe")
+        set sh to "C:\\Program Files\\Git\\bin\\bash.exe"
+    give sh
+
+-- corre un comando con cwd = workspace; error legible si falla
+task sh(cmd)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    let r be run(shell(), ["-c", cmd], 30, {"cwd": c.ROOT})
+    when r["exit_code"] != 0
+        let err be trim(text(r["stderr"]))
+        raise(when err == "" then "command failed: " + cmd otherwise err)
+    give true
+
+-- path del navegador → {rel (como lo ve el modelo, "." = raíz), real ("workspace/…"), info}
+task target(path)
+    require file.read("workspace")
+    require file.read("workspace/*")
+    let real be c.ws(path)
+    give {"rel": c.unws(real), "real": real, "info": file_info(real)}
+
+task parent_of(rel)
+    when not contains(rel, "/")
+        give "."
+    let parts be split(rel, "/")
+    give join(slice(parts, 0, length(parts) - 1), "/")
+
+task base_of(rel)
+    let parts be split(rel, "/")
+    give parts[length(parts) - 1]
+
+task join_rel(dir, name)
+    give when dir == "." or dir == "" then name otherwise dir + "/" + name
+
+task check_name(name)
+    let n be trim(text(name))
+    when n == "" or n == "." or n == ".." or contains(n, "/") or contains(n, "\\")
+        raise("invalid name \"" + text(name) + "\": one path segment, without / or \\")
+    when length(find_all(n, "[<>:\"|?*]")) > 0
+        raise("invalid name \"" + n + "\": < > : \" | ? * are not allowed in file names")
+    give n
+
+task must_exist(t)
+    when not t["info"]["exists"]
+        raise("\"" + t["rel"] + "\" does not exist")
+
+task must_not_exist(rel)
+    require file.read("workspace")
+    require file.read("workspace/*")
+    when file_exists(c.ROOT + "/" + rel)
+        raise("\"" + rel + "\" already exists")
+
+-- ¿`path` es `dir` o está dentro de `dir`?
+task inside(dir, path)
+    when dir == "."
+        give true
+    give path == dir or starts_with(path, dir + "/")
+
+task must_be_dir(rel, info)
+    when not info["exists"]
+        raise("\"" + rel + "\" does not exist")
+    when not info["is_dir"]
+        raise("\"" + rel + "\" is not a folder")
+
+export task mkdir(dir, name)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    let t be target(dir)
+    let rel be join_rel(t["rel"], check_name(name))
+    must_not_exist(rel)
+    sh("mkdir -p " + sh_quote(rel))
+    give {"path": rel, "is_dir": true}
+
+export task create(dir, name, content)
+    require file("workspace")
+    require file("workspace/*")
+    let t be target(dir)
+    let rel be join_rel(t["rel"], check_name(name))
+    must_not_exist(rel)
+    write_file(c.ROOT + "/" + rel, when content == nothing then "" otherwise text(content))
+    give {"path": rel, "is_dir": false}
+
+export task rename(path, name)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    let t be target(path)
+    must_exist(t)
+    when t["rel"] == "."
+        raise("the workspace root cannot be renamed")
+    let rel be join_rel(parent_of(t["rel"]), check_name(name))
+    when rel == t["rel"]
+        give {"path": rel, "is_dir": t["info"]["is_dir"]}
+    -- solo cambian mayúsculas: en un FS case-insensitive el destino "existe" → pasar por un temporal
+    when lower(rel) == lower(t["rel"])
+        let tmp be rel + ".lampson-rename-tmp"
+        sh("mv " + sh_quote(t["rel"]) + " " + sh_quote(tmp) + " && mv " + sh_quote(tmp) + " " + sh_quote(rel))
+        give {"path": rel, "is_dir": t["info"]["is_dir"]}
+    must_not_exist(rel)
+    sh("mv " + sh_quote(t["rel"]) + " " + sh_quote(rel))
+    give {"path": rel, "is_dir": t["info"]["is_dir"]}
+
+export task move(path, to_dir)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    let t be target(path)
+    must_exist(t)
+    when t["rel"] == "."
+        raise("the workspace root cannot be moved")
+    let d be target(to_dir)
+    must_be_dir(d["rel"], d["info"])
+    when t["info"]["is_dir"] and inside(t["rel"], d["rel"])
+        raise("cannot move a folder into itself")
+    let rel be join_rel(d["rel"], base_of(t["rel"]))
+    when rel == t["rel"]
+        give {"path": rel, "is_dir": t["info"]["is_dir"]}
+    must_not_exist(rel)
+    sh("mv " + sh_quote(t["rel"]) + " " + sh_quote(rel))
+    give {"path": rel, "is_dir": t["info"]["is_dir"]}
+
+-- "b.ts" en `dir` → "b copy.ts", "b copy 2.ts"…; carpetas y dotfiles: "sub copy", ".env copy"
+task copy_name(dir, base)
+    require file.read("workspace")
+    require file.read("workspace/*")
+    let stem be base
+    let ext be ""
+    let parts be split(base, ".")
+    when length(parts) > 1 and parts[0] != ""
+        set ext to "." + parts[length(parts) - 1]
+        set stem to slice(base, 0, length(base) - length(ext))
+    let n be 1
+    let cand be stem + " copy" + ext
+    while file_exists(c.ROOT + "/" + join_rel(dir, cand)) and n < 100
+        set n to n + 1
+        set cand to stem + " copy " + text(n) + ext
+    give cand
+
+-- to_dir = nothing → duplicar al lado; otra carpeta → copiar ahí (mismo nombre, o "copy" si ya hay uno)
+export task copy(path, to_dir)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    let t be target(path)
+    must_exist(t)
+    when t["rel"] == "."
+        raise("the workspace root cannot be copied")
+    let dir be when to_dir == nothing then parent_of(t["rel"]) otherwise target(to_dir)["rel"]
+    must_be_dir(dir, file_info(c.ws(dir)))
+    when t["info"]["is_dir"] and inside(t["rel"], dir)
+        raise("cannot copy a folder into itself")
+    let base be base_of(t["rel"])
+    let rel be join_rel(dir, base)
+    when rel == t["rel"] or file_exists(c.ROOT + "/" + rel)
+        set rel to join_rel(dir, copy_name(dir, base))
+    sh("cp -r " + sh_quote(t["rel"]) + " " + sh_quote(rel))
+    give {"path": rel, "is_dir": t["info"]["is_dir"]}
+
+export task remove(path)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    let t be target(path)
+    must_exist(t)
+    when t["rel"] == "."
+        raise("the workspace root cannot be deleted")
+    when t["rel"] == ".git" or t["rel"] == ".lampson"
+        raise("\"" + t["rel"] + "\" is not deleted from the explorer")
+    sh("rm -rf " + sh_quote(t["rel"]))
+    give {"path": t["rel"], "is_dir": t["info"]["is_dir"]}
+
+-- POST /api/fs: {op, path, name?, to?, content?} → {path, is_dir}
+export task apply(b)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    let op be when contains(b, "op") then lower(text(b["op"])) otherwise ""
+    let path be when contains(b, "path") then text(b["path"]) otherwise "."
+    let name be when contains(b, "name") then b["name"] otherwise nothing
+    -- (`to` es palabra reservada: `set x to`)
+    let dest be when contains(b, "to") then text(b["to"]) otherwise nothing
+    when op == "mkdir"
+        give mkdir(path, name)
+    when op == "create"
+        give create(path, name, when contains(b, "content") then b["content"] otherwise "")
+    when op == "rename"
+        give rename(path, name)
+    when op == "move"
+        give move(path, when dest == nothing then "." otherwise dest)
+    when op == "copy"
+        give copy(path, dest)
+    when op == "delete"
+        give remove(path)
+    raise("unknown op '" + op + "' (mkdir, create, rename, move, copy, delete)")