lampson 0.2.6 → 0.2.8

package/skills/lampson/SKILL.md

@@ -25,6 +25,14 @@ description: How this harness works — tools, workspace mount, permissions, age
   more context. `replace_all=true` for intentional multi-replace.
 - `read` returns up to 2000 lines; use `offset`/`limit` for big files. Outputs > 30k chars are truncated.
 - `find` is a simple glob (`*.ts`, `test_*`, `*config*`), `grep` is regex by default (`regex=false` for literals).
+- `fetch(url)` returns a web page as Markdown (about a tenth of the characters of its HTML: scripts, styles,
+  nav and footers stripped, links absolute, code blocks and tables kept; a site that serves Markdown is
+  taken as is). Follows up to 5 redirects. Long pages come back head+tail and the full text is saved to
+  `.lampson/spill/fetch-<host>-<id>.md` — page it with `read offset/limit` or `grep`, never re-fetch; the
+  same URL within 20 minutes is served from that file. `format=text` for prose without links, `format=html`
+  to see the raw markup. localhost / private hosts ask the user (good for checking your own dev server);
+  cloud metadata endpoints and URLs carrying tokens are refused. Binary content (images, PDF) is reported,
+  not returned — use `bash` with `curl -o` for downloads.
 - `lsp(op=symbols, path)` is the cheapest way to understand a big file: every function/class/variable
   with its line range — then `read` only the range you need. `definition` / `references` / `hover` /
   `implementation` take 1-based `line` + `character` ON the identifier. If no server is configured for
@@ -43,7 +51,7 @@ description: How this harness works — tools, workspace mount, permissions, age
 ## Scheduled tasks (`schedule` tool)
 - When the user says "every day at 9", "each 6 hours", "on Mondays", "periodically", "send me", propose
   `schedule(action=add, name, at, kind, …)`: `at` = `every 6h` | `daily 09:00` | `mon,wed 08:30` |
-  `weekdays 09:00`; one-time: `today 15:14` | `tomorrow 09:00` | `once 2026-08-29 15:14` | `in 2h` (it turns itself off after running) — the USER'S LOCAL time: write the hour as they say it, never convert to UTC (the tool result shows the next run with its offset). Tasks belong to the current workspace. `kind=lamp` (a lamp that is ON: lamp + tool + args), `kind=bash` (one
+  `weekdays 09:00`; one-time: `today 15:14` | `tomorrow 09:00` | `once 2026-08-29 15:14` | `in 2h` (it turns itself off after running) — the USER'S LOCAL time: write the hour as they say it, never convert to UTC (the tool result shows the next run with its offset). Tasks belong to the current workspace. `kind=plugin` (a plugin that is ON: plugin + tool + args), `kind=bash` (one
   command that finishes on its own), `kind=prompt` (an unattended agent run: write a self-contained prompt —
   what to do, how to verify, what to report — and pick `agent` build/review/plan/explore).
 - `permission` is the envelope of a `prompt` run with nobody watching: `strict` (dangerous → denied),
@@ -95,6 +103,10 @@ the terminal button and run `npm run dev`), then tell me the URL".
 ## Project memory (persistent notes)
 - `memory(write, name, content)` saves a Markdown note about THIS project in Lampson's `memory/<project>/`
   folder (outside the repo). The system prompt lists your notes; `memory(read, name)` loads one.
+- That folder is OUTSIDE the workspace and outside the reach of read/ls/grep/bash (they are confined to the
+  project): the `memory` tool is the only door. Never look for it with `ls`, never write notes with bash, and
+  never store notes inside the repo (no `.lampson/notes/`). If the tool says the folder is unreachable, tell
+  the user to run `lampson` again in the project (it repairs the link) — do not improvise.
 - Save what you would otherwise rediscover: how to run/test, env quirks, decisions, where things live,
   root causes of bugs. Update notes instead of contradicting them. The user can read and edit them.
 
@@ -124,15 +136,18 @@ the terminal button and run `npm run dev`), then tell me the URL".
   (`workspace/.agents/skills`, `workspace/.claude/skills`, and the global `~/.agents/skills` / `~/.claude/skills`
   mounted as `.lampson/skills-global` / `.lampson/skills-claude`). Frontmatter `name:` + `description:`.
   `skill(action=install, source=owner/repo, name=x, scope=global|project)` installs one (always asks the user).
-- **Lamps** = tool plugins you can create for this project without touching the harness:
-  `lamp(action=create, name, manifest, files={"lamp.syn": "…"})` writes `workspace/.lampson/lamps/<name>/`,
+- **Plugins** = tools you can create for this project without touching the harness (they were called
+  "lamps" until 0.2.6 — the user may still say "lámpara"; a `.lampson/lamps/` folder still works):
+  `plugin(action=create, name, manifest, files={"plugin.syn": "…"})` writes `workspace/.lampson/plugins/<name>/`,
   validates the manifest and runs `synsema check` on a syn entry (it does not run or enable anything —
-  like dsh's cordis_define). Then `lamp(action=enable, name)` — the user must approve (a lamp is off until
+  like dsh's cordis_define). Then `plugin(action=enable, name)` — the user must approve (a plugin is off until
   a human turns it on). Build one when a task needs a reusable project-specific tool. Manifest:
-  `{"name", "description", "kind": "syn"|"exec", "entry": "lamp.syn" (syn) | "command": "python lamp.py" (exec),
-  "caps": "file.read=workspace/*" (syn, optional extra ceiling over stdout,time,env=LAMP_*), "timeout": 60,
-  "tools": [{"name", "description", "parameters": {JSON Schema}, "readonly": bool}]}`. Lamp names: letters,
-  digits, `-` (no `_`). Each call runs the lamp as ONE child process: `synsema run --cap-set <ceiling> entry`
-  for `syn`, the command for `exec`. Inside, read `LAMP_TOOL` and `LAMP_ARGS` (JSON) from env
-  (`require env("LAMP_*")` in a .syn) and print the result to stdout. A syn lamp cannot use more than its
-  manifest's `caps`; ask only for what the tool needs. Once on, its tools are `lamp_<name>_<tool>`.
+  `{"name", "description", "kind": "syn"|"exec", "entry": "plugin.syn" (syn) | "command": "python plugin.py" (exec),
+  "caps": "file.read=workspace/*" (syn, optional extra ceiling over stdout,time,env=PLUGIN_*), "timeout": 60,
+  "tools": [{"name", "description", "parameters": {JSON Schema}, "readonly": bool}]}`. Plugin names: letters,
+  digits, `-` (no `_`). Each call runs the plugin as ONE child process: `synsema run --cap-set <ceiling> entry`
+  for `syn`, the command for `exec`. Inside, read `PLUGIN_TOOL` and `PLUGIN_ARGS` (JSON) from env
+  (`require env("PLUGIN_*")` in a .syn) and print the result to stdout. A syn plugin cannot use more than its
+  manifest's `caps`; ask only for what the tool needs. Once on, its tools are `plugin_<name>_<tool>`.
+  Not the same thing as a **lamp** from lamps.sh (a portable, ceiling-enforced capability unit for any MCP
+  agent): if the user wants one of those, it is `lamp add <ref>` + `lamp mcp` as an MCP server, not a plugin.

package/web.syn

@@ -34,8 +34,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")
@@ -50,6 +50,7 @@ use "./lib/loop.syn" as loop
 use "./lib/session.syn" as session
 use "./lib/agents.syn" as agents
 use "./lib/tree.syn" as tree
+use "./lib/fs.syn" as fs
 use "./lib/git.syn" as git
 use "./lib/tools/proc.syn" as proc
 use "./lib/tools/memo.syn" as memo
@@ -57,7 +58,7 @@ use "./lib/update.syn" as update
 use "./lib/settings.syn" as settings
 use "./lib/trace.syn" as trace
 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
@@ -105,7 +106,7 @@ task lampson_subagent(spec_json)
 -- TAREAS PROGRAMADAS (lib/schedule.syn): este proceso es el residente de lampson — con `lampson --daemon start`
 -- (synsema daemon) queda en background y ejecuta lo programado aunque no haya ninguna UI abierta. Un tick cada
 -- 30 s (cron_every de Synsema: intervalo puro; la hora de reloj la resuelve schedule.syn) corre lo vencido:
--- lámparas, comandos y corridas del agente con su sobre de permisos; una aprobación en una corrida desatendida
+-- plugins, comandos y corridas del agente con su sobre de permisos; una aprobación en una corrida desatendida
 -- sale por lib/approvals.syn (panel «Aprobaciones» de la UI, webhook firmado, link de un solo uso).
 task sched_tick()
     give sched_run.tick()
@@ -193,7 +194,10 @@ serve on 8080
         give {"result": session.delete(text(b["id"]))}
 
     route "GET /w/:slug/api/tree" requires auth
-        give tree.tree(6)
+        let t be tree.tree(6)
+        -- ruta real del proyecto (lampson.ps1/.sh exportan LAMPSON_WORKSPACE): «copiar ruta absoluta» en el explorador
+        set t["root"] to env("LAMPSON_WORKSPACE", "")
+        give t
 
     -- Terminales del navegador. El pty NO vive en este handler: vive en un agente supervisor
     -- (lib/term.syn), y este socket es un puente por el bus. Así la shell sobrevive a un F5 —
@@ -261,7 +265,8 @@ serve on 8080
         give git.status()
 
     route "GET /w/:slug/api/memory" requires auth
-        give {"dir": memo.dir(), "notes": memo.list()}
+        -- ok=false: el link memory/ del workspace está roto (la UI lo dice; el agente ya lo sabe por el prompt)
+        give {"dir": memo.dir(), "ok": memo.available(), "notes": memo.list()}
 
     route "GET /w/:slug/api/memory/note" requires auth
         when not contains(query, "name")
@@ -334,34 +339,34 @@ serve on 8080
         recover err
             give fail(400, text(err))
 
-    -- lámparas (plugins de tools): listar y encender/apagar desde la barra superior de la UI
-    route "GET /w/:slug/api/lamps" requires auth
-        give {"lamps": lamps.summary(), "global": lamps.GLOBAL_DIR, "project": lamps.PROJECT_DIR}
+    -- plugins (tools propias): listar y encender/apagar desde la barra superior de la UI
+    route "GET /w/:slug/api/plugins" requires auth
+        give {"plugins": plugins.summary(), "global": plugins.GLOBAL_DIR, "project": plugins.PROJECT_DIR}
 
-    -- el usuario corre una tool de una lámpara encendida él mismo (sin pasar por el modelo)
-    route "POST /w/:slug/api/lamps/run" requires auth
+    -- el usuario corre una tool de un plugin encendido él mismo (sin pasar por el modelo)
+    route "POST /w/:slug/api/plugins/run" requires auth
         expect body {tool: text}
         let b be json of request
         let args be when contains(b, "args") then b["args"] otherwise {}
         try
-            give {"ok": true, "output": lamps.call(text(b["tool"]), args)}
+            give {"ok": true, "output": plugins.call(text(b["tool"]), args)}
         recover err
             give fail(400, text(err))
 
-    route "POST /w/:slug/api/lamps/remove" requires auth
+    route "POST /w/:slug/api/plugins/remove" requires auth
         expect body {name: text}
         let b be json of request
         try
-            give {"ok": true, "result": lamps.remove(text(b["name"])), "lamps": lamps.summary()}
+            give {"ok": true, "result": plugins.remove(text(b["name"])), "plugins": plugins.summary()}
         recover err
             give fail(400, text(err))
 
-    route "POST /w/:slug/api/lamps/toggle" requires auth
+    route "POST /w/:slug/api/plugins/toggle" requires auth
         expect body {name: text}
         let b be json of request
         let on be contains(b, "enabled") and b["enabled"] == true
         try
-            give {"ok": true, "result": lamps.set_enabled(text(b["name"]), on), "lamps": lamps.summary()}
+            give {"ok": true, "result": plugins.set_enabled(text(b["name"]), on), "plugins": plugins.summary()}
         recover err
             give fail(400, text(err))
 
@@ -439,6 +444,16 @@ serve on 8080
             give fail(400, "path required")
         give tree.file_content(query.path)
 
+    -- explorador: nuevo archivo/carpeta, renombrar, mover, copiar/duplicar, borrar (lib/fs.syn; solo dentro
+    -- del workspace, nunca pisa un destino). {op, path, name?, to?, content?} → {ok, result: {path, is_dir}}
+    route "POST /w/:slug/api/fs" requires auth
+        expect body {op: text, path: text}
+        let b be json of request
+        try
+            give {"ok": true, "result": fs.apply(b)}
+        recover err
+            give fail(400, text(err))
+
     -- configuración general (rueda de la UI): zona horaria, URL pública, webhook… → .lampson/config.json
     route "GET /w/:slug/api/settings/values" requires auth
         give {"values": settings.values(), "tz_detected": schedule.tz_offset()}
@@ -478,7 +493,7 @@ serve on 8080
     route "GET /w/:slug/api/schedules" requires auth
         let age be schedule.daemon_age()
         -- este proceso tiene su propio tick (cron_every): las tareas corren mientras la web esté abierta
-        give {"tasks": schedule.summary(), "tick": schedule.TICK_SECONDS, "alive": true, "heartbeat_age": age, "mount_ok": schedule.mount_ok(), "workspace": env("LAMPSON_WORKSPACE", ""), "tz": schedule.tz_offset(), "lamps": lamps.summary()}
+        give {"tasks": schedule.summary(), "tick": schedule.TICK_SECONDS, "alive": true, "heartbeat_age": age, "mount_ok": schedule.mount_ok(), "workspace": env("LAMPSON_WORKSPACE", ""), "tz": schedule.tz_offset(), "plugins": plugins.summary()}
 
     route "POST /w/:slug/api/schedules/add" requires auth
         let b be json of request

package/lamps/example-hello/lamp.syn

@@ -1,19 +0,0 @@
--- lamps/example-hello/lamp.syn — la lámpara de ejemplo
---
--- Lampson la corre así por cada llamada: synsema run --cap-set stdout,time,env=LAMP_* lamp.syn
--- El techo (--cap-set) sale del manifiesto (lamp.json → "caps") que el humano aprobó al encenderla;
--- pedir más acá (p. ej. `require net`) falla con "above the host ceiling".
--- Entrada por env: LAMP_TOOL (qué tool), LAMP_ARGS (sus args en JSON), LAMP_DIR, LAMP_WORKSPACE.
--- Salida: lo que imprimas por stdout vuelve al modelo como resultado de la tool.
-intent: "example lamp for lampson: greet"
-
-require env("LAMP_*")
-
-let tool be env("LAMP_TOOL", "")
-let args be json_decode(env("LAMP_ARGS", "{}"))
-
-when tool == "greet"
-    let who be when contains(args, "who") then text(args["who"]) otherwise "world"
-    print("hello, " + who + "! (from the example-hello lamp, running under a capability ceiling)")
-otherwise
-    print("ERROR: unknown tool '" + tool + "'")

package/lib/lamps.syn

@@ -1,386 +0,0 @@
--- lib/lamps.syn — "lámparas": plugins de tools que el usuario (o el agente) escribe y el humano ENCIENDE
---
--- Qué es una lámpara: una carpeta con un manifiesto `lamp.json` y el código que implementa sus tools.
---   lamps/<nombre>/                     GLOBAL (lampson se instala una vez → vale para todos los proyectos)
---   workspace/.lampson/lamps/<nombre>/  del PROYECTO (el agente puede crearlas con write: es su workspace)
---   lamp.json = {"name", "description", "kind": "syn" | "exec",
---                "entry": "lamp.syn"            (kind=syn: un programa Synsema)
---                "command": "python lamp.py"    (kind=exec: cualquier ejecutable — js, py, sh…)
---                "caps": "file.read=workspace/*" (kind=syn, opcional: techo EXTRA sobre stdout,time,env=LAMP_*)
---                "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=LAMP_*[,caps] <entry>`: el techo lo fija el
---               manifiesto que el humano aprobó al encenderla; un `require` de más en el código de la
---               lámpara 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: LAMP_TOOL, LAMP_ARGS (JSON), LAMP_DIR (carpeta de la lámpara,
---   relativa a la raíz de lampson = cwd del hijo si kind=syn; si kind=exec el cwd es el workspace),
---   LAMP_WORKSPACE (ruta real del proyecto). La lámpara imprime el resultado (texto o JSON) por stdout.
---
--- Encendido: `.lampson/lamps.json` {"enabled": {"<nombre>": true}}. APAGADA por defecto: descubrir una
--- carpeta nueva no la activa; la enciende el humano (UI: barra superior; terminal: /lamps on <nombre>) o el
--- agente con la tool `lamp` (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 `lamp_<lámpara>_<tool>`; loop.execute las despacha acá
--- (registry las marca con "lamp", como "mcp"). permission.syn: ask por defecto, yolo permite, strict deniega;
--- las readonly también en plan/review/explore.
-
-use "./tools/common.syn" as c
-
-export let GLOBAL_DIR be "lamps"
-export let PROJECT_DIR be "workspace/.lampson/lamps"
-export let STATE_FILE be ".lampson/lamps.json"
-let DEFAULT_TIMEOUT be 60
-let BASE_CAPS be "stdout,time,env=LAMP_*"
-
--- nombre de lámpara: SIN "_" (el separador de lamp_<lámpara>_<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, lamp} o {ok: false, error}
-task read_manifest(dir, name, scope)
-    let path be dir + "/" + name + "/lamp.json"
-    let doc be nothing
-    try
-        set doc to json_decode(read_file(path))
-    recover err
-        give {"ok": false, "name": name, "scope": scope, "error": "no lamp.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, "error": "kind must be syn or exec"}
-    when kind == "syn" and not contains(doc, "entry")
-        give {"ok": false, "name": name, "scope": scope, "error": "kind=syn needs \"entry\" (the .syn file)"}
-    when kind == "exec" and not contains(doc, "command")
-        give {"ok": false, "name": name, "scope": scope, "error": "kind=exec needs \"command\""}
-    when not contains(doc, "tools") or length(doc["tools"]) == 0
-        give {"ok": false, "name": name, "scope": scope, "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, "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, "lamp": {"name": name, "scope": scope, "dir": dir + "/" + name, "kind": kind, "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)
-    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))
-    recover err
-        give out
-    give out
-
-task load_state()
-    try
-        let doc be json_decode(read_file(STATE_FILE))
-        give when contains(doc, "enabled") then doc["enabled"] otherwise {}
-    recover err
-        give {}
-
--- todas las lámparas descubiertas (proyecto pisa a global por nombre), con enabled y error.
--- LAMPSON_LAMPS_DIR = una carpeta extra (tests).
-export task all()
-    require file(".lampson")
-    require file(".lampson/*")
-    require file.read("lamps")
-    require file.read("lamps/*")
-    require file("workspace")
-    require file("workspace/*")
-    require env("LAMPSON_*")
-    let by_name be {}
-    each r in scan(GLOBAL_DIR, "global")
-        set by_name[r["name"]] to r
-    each r in scan(PROJECT_DIR, "project")
-        set by_name[r["name"]] to r
-    when env("LAMPSON_LAMPS_DIR", "") != ""
-        each r in scan(env("LAMPSON_LAMPS_DIR", ""), "extra")
-            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["lamp"]
-            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": "?", "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("lamps")
-    require file.read("lamps/*")
-    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 una lámpara rota es error.
-export task set_enabled(name, on)
-    require file(".lampson")
-    require file(".lampson/*")
-    require file.read("lamps")
-    require file.read("lamps/*")
-    require file("workspace")
-    require file("workspace/*")
-    require env("LAMPSON_*")
-    when not valid_name(name)
-        raise("invalid lamp name")
-    let found be where(all(), (l) => l["name"] == name)
-    when length(found) == 0
-        raise("no lamp named '" + name + "' (global: " + GLOBAL_DIR + "/<name>/lamp.json · project: " + PROJECT_DIR + "/<name>/lamp.json)")
-    when on and found[0]["error"] != nothing
-        raise("lamp '" + 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]
-    when on
-        give "lamp '" + 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 lamp_" + name + "_<tool>"
-    give "lamp '" + name + "' OFF"
-
-task ceiling_of(l)
-    give when l["caps"] == "" then BASE_CAPS otherwise BASE_CAPS + "," + l["caps"]
-
--- ---------- catálogo ----------
-export task tool_name(lamp, tool)
-    give "lamp_" + lamp + "_" + tool
-
-task split_name(full)
-    let segs be split(slice(full, 5, length(full)), "_")
-    when length(segs) < 2
-        raise("bad lamp tool name '" + full + "'")
-    give {"lamp": segs[0], "tool": join(slice(segs, 1, length(segs)), "_")}
-
-export task catalog(readonly_only)
-    require file(".lampson")
-    require file(".lampson/*")
-    require file.read("lamps")
-    require file.read("lamps/*")
-    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": "[lamp " + l["name"] + "] " + t["description"], "parameters": t["parameters"]})
-    give out
-
-export task names(readonly_only)
-    require file(".lampson")
-    require file(".lampson/*")
-    require file.read("lamps")
-    require file.read("lamps/*")
-    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_lamp(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: lamp timed out after " + text(t) + "s (killed). Output so far:\n" + out
-    when code != 0
-        give "ERROR: lamp exited with code " + text(code) + "\n" + out
-    give when trim(out) == "" then "(no output)" otherwise out
-
--- separa "python lamp.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("lamps")
-    require file.read("lamps/*")
-    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["lamp"])
-    when length(found) == 0
-        give "ERROR: lamp '" + parts["lamp"] + "' is not enabled (the user turns lamps on)"
-    let l be found[0]
-    let tl be where(l["tools"], (t) => t["name"] == parts["tool"])
-    when length(tl) == 0
-        give "ERROR: lamp '" + l["name"] + "' has no tool '" + parts["tool"] + "'"
-    -- LAMP_DIR relativa a la raíz de lampson (cwd del hijo para kind=syn); LAMP_WORKSPACE = la ruta real del
-    -- proyecto (lampson.ps1 la exporta; sin ella, la junction)
-    let envs be {"LAMP_TOOL": parts["tool"], "LAMP_ARGS": json_encode(when args == nothing then {} otherwise args), "LAMP_DIR": l["dir"], "LAMP_WORKSPACE": env("LAMPSON_WORKSPACE", c.ROOT)}
-    when l["kind"] == "syn"
-        -- techo del manifiesto: el código de la lámpara no puede pedir más de lo que el humano aprobó
-        give c.truncate(run_lamp(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: lamp '" + l["name"] + "' has an empty command"
-    -- el comando corre desde la RAÍZ DEL WORKSPACE (para que "python lamp.py" vea el proyecto), así que un
-    -- token que nombra un archivo de la carpeta de la lámpara 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_lamp(resolved[0], slice(resolved, 1, length(resolved)), c.ROOT, envs, l["timeout"]), c.MAX_OUTPUT)
-
--- crear una lámpara DEL PROYECTO (workspace/.lampson/lamps/<name>/): escribe lamp.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` = {"lamp.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("lamps")
-    require file.read("lamps/*")
-    require file("workspace")
-    require file("workspace/*")
-    require env("LAMPSON_*")
-    when not valid_name(name)
-        raise("invalid lamp 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 + "/lamp.json", json_encode(m))
-    let written be ["lamp.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 lamp 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("lamp written but not discovered (?)")
-    let l be found[0]
-    when l["error"] != nothing
-        give "lamp '" + name + "' written to " + dir + " but its manifest is INVALID: " + text(l["error"]) + " — fix it with edit and call lamp(action=list) to re-check"
-    let note be ""
-    when l["kind"] == "syn"
-        let chk be run_lamp(env("LAMPSON_SYNSEMA", "synsema"), ["check", l["dir"] + "/" + l["entry"]], ".", {}, 30)
-        when starts_with(chk, "ERROR")
-            give "lamp '" + 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 "lamp '" + 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 lamp folder named in the command is resolved automatically" otherwise "") + ". It is OFF until the user turns it on: offer to do it (lamp action=enable asks them), or point them to the lamp switch of their UI. Its tools will be lamp_" + name + "_<tool>."
-
--- eliminar una lámpara DEL PROYECTO: borra su carpeta (no hay delete_file en el runtime → rm -rf por el shell
--- de bash.syn) y la saca del estado. Las globales (lamps/) 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("lamps")
-    require file.read("lamps/*")
-    require file("workspace")
-    require file("workspace/*")
-    when not valid_name(name)
-        raise("invalid lamp name")
-    let found be where(all(), (l) => l["name"] == name)
-    when length(found) == 0
-        raise("no lamp named '" + name + "'")
-    let l be found[0]
-    when l["scope"] != "project"
-        raise("'" + name + "' is a " + l["scope"] + " lamp (" + GLOBAL_DIR + "/" + name + "): delete that folder by hand")
-    let dir be 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 + "/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 "lamp '" + name + "' deleted (" + dir + ")"
-
--- resumen para UI/terminal/tool
-export task summary()
-    require file(".lampson")
-    require file(".lampson/*")
-    require file.read("lamps")
-    require file.read("lamps/*")
-    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"], "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