lampson 0.1.0 → 0.1.1

package/lib/tools/process.syn

@@ -1,46 +1,46 @@
--- lib/tools/process.syn — tool `process`: servidores y watchers gestionados (start / logs / stop / list)
-use "./proc.syn" as proc
-
-export task tool(action, name, command, tail)
-    require exec
-    require time
-    require env("LAMPSON_*")
-    require env("OS")
-    require file(".lampson")
-    require file(".lampson/*")
-    when action == "start"
-        when command == nothing or command == ""
-            raise("start needs a command")
-        give proc.start(name, command)
-    when action == "logs"
-        give proc.logs(name, tail)
-    when action == "stop"
-        give proc.halt(name)
-    when action == "ports"
-        let ls be proc.listeners()
-        when length(ls) == 0
-            give "no TCP ports listening (>=1024)"
-        let lines be []
-        each l in ls
-            set lines to append(lines, "port " + text(l["port"]) + "  pid " + text(l["pid"]) + "  " + l["name"])
-        give join(lines, "\n")
-    when action == "list"
-        let items be proc.list()
-        when length(items) == 0
-            give "no managed processes"
-        let lines be []
-        each p in items
-            set lines to append(lines, p["name"] + "  " + (when p["running"] then "running" otherwise "exited") + "  $ " + p["command"])
-        give join(lines, "\n")
-    raise("unknown action '" + text(action) + "' (start | logs | stop | list | ports)")
-
-export let SPEC be {
-    "name": "process",
-    "description": "Manage long-running processes (dev servers, watchers, APIs) so you can SEE their output. start: launches `command` detached with a `name`; its stdout/stderr go to a log you can read any time. After every bash call you automatically receive the NEW log lines of every managed process, so errors in a server you started reach you without asking. logs: last `tail` lines (default 60). A process is EXITED only when its pid is really gone; then its log ends with `[process exited with code N]` — read the reason there instead of retrying the command in bash. stop: kills the process and its whole tree (npm → node included). list: what is running. ports: every TCP port listening on the machine with its pid and program — use it when a port is busy (EADDRINUSE) or to check whether something is already up. Always use this instead of `cmd &` in bash, and stop what you started when the task is done.",
-    "parameters": {"type": "object", "properties": {
-        "action": {"type": "string", "enum": ["start", "logs", "stop", "list", "ports"]},
-        "name": {"type": "string", "description": "Short id: letters, digits, - or _ (e.g. web, api, dev)"},
-        "command": {"type": "string", "description": "start only: the shell command (runs with cwd = workspace root)"},
-        "tail": {"type": "integer", "description": "logs only: number of lines (default 60)"}
-    }, "required": ["action"]}
-}
+-- lib/tools/process.syn — tool `process`: servidores y watchers gestionados (start / logs / stop / list)
+use "./proc.syn" as proc
+
+export task tool(action, name, command, tail)
+    require exec
+    require time
+    require env("LAMPSON_*")
+    require env("OS")
+    require file(".lampson")
+    require file(".lampson/*")
+    when action == "start"
+        when command == nothing or command == ""
+            raise("start needs a command")
+        give proc.start(name, command)
+    when action == "logs"
+        give proc.logs(name, tail)
+    when action == "stop"
+        give proc.halt(name)
+    when action == "ports"
+        let ls be proc.listeners()
+        when length(ls) == 0
+            give "no TCP ports listening (>=1024)"
+        let lines be []
+        each l in ls
+            set lines to append(lines, "port " + text(l["port"]) + "  pid " + text(l["pid"]) + "  " + l["name"])
+        give join(lines, "\n")
+    when action == "list"
+        let items be proc.list()
+        when length(items) == 0
+            give "no managed processes"
+        let lines be []
+        each p in items
+            set lines to append(lines, p["name"] + "  " + (when p["running"] then "running" otherwise "exited") + "  $ " + p["command"])
+        give join(lines, "\n")
+    raise("unknown action '" + text(action) + "' (start | logs | stop | list | ports)")
+
+export let SPEC be {
+    "name": "process",
+    "description": "Manage long-running processes (dev servers, watchers, APIs) so you can SEE their output. start: launches `command` detached with a `name`; its stdout/stderr go to a log you can read any time. After every bash call you automatically receive the NEW log lines of every managed process, so errors in a server you started reach you without asking. logs: last `tail` lines (default 60). A process is EXITED only when its pid is really gone; then its log ends with `[process exited with code N]` — read the reason there instead of retrying the command in bash. stop: kills the process and its whole tree (npm → node included). list: what is running. ports: every TCP port listening on the machine with its pid and program — use it when a port is busy (EADDRINUSE) or to check whether something is already up. Always use this instead of `cmd &` in bash, and stop what you started when the task is done.",
+    "parameters": {"type": "object", "properties": {
+        "action": {"type": "string", "enum": ["start", "logs", "stop", "list", "ports"]},
+        "name": {"type": "string", "description": "Short id: letters, digits, - or _ (e.g. web, api, dev)"},
+        "command": {"type": "string", "description": "start only: the shell command (runs with cwd = workspace root)"},
+        "tail": {"type": "integer", "description": "logs only: number of lines (default 60)"}
+    }, "required": ["action"]}
+}

package/lib/tools.syn

@@ -1,198 +1,198 @@
--- lib/tools.syn — agregador de tools: una tool = un archivo en lib/tools/<nombre>.syn
---
--- Contrato de cada archivo de tool ("plugin"):
---   export task tool(...)    -- la tool; sus `require` al TOPE del cuerpo (call_tool los intersecta)
---   export let SPEC be {...} -- {name, description, parameters (JSON Schema)} para el modelo
---
--- Para agregar una tool: crear lib/tools/x.syn con ese contrato y sumarla a las dos listas de abajo.
--- La lista es EXPLÍCITA a propósito: Synsema no tiene `use` dinámico (sin supply chain), así que
--- el allow-list de tools se lee en este archivo y se audita con `synsema check`.
---
--- Seguridad que ya pone el lenguaje: ninguna tool declara `net` → ninguna tool puede usar la red,
--- aunque el entry la tenga para hablar con el LLM.
-
-use "./tools/common.syn" as common
-use "./tools/read.syn" as t_read
-use "./tools/write.syn" as t_write
-use "./tools/edit.syn" as t_edit
-use "./tools/ls.syn" as t_ls
-use "./tools/find.syn" as t_find
-use "./tools/grep.syn" as t_grep
-use "./tools/bash.syn" as t_bash
-use "./tools/skill.syn" as t_skill
-use "./tools/process.syn" as t_process
-use "./tools/memo.syn" as t_memo
-use "./tools/todo.syn" as t_todo
-use "./skills.syn" as skills
-use "./mcp.syn" as mcp
-use "./lamps.syn" as lamps
-use "./lsp.syn" as lsp
-
--- la task de la tool skill (su SPEC está en tools/skill.syn)
-task skill_tool(name, action, source, scope)
-    require exec
-    require time
-    require env("LAMPSON_*")
-    require env("OS")
-    require file.read("skills")
-    require file.read("skills/*")
-    require file.read("workspace")
-    require file.read("workspace/*")
-    require file.read(".lampson")
-    require file.read(".lampson/*")
-    when action == "install"
-        give skills.install(source, name, scope)
-    when action == "list"
-        let idx be skills.index()
-        let lines be []
-        each n in sort_by(keys(idx), (x) => x)
-            set lines to append(lines, n + " (" + idx[n]["source"] + "): " + idx[n]["description"])
-        give join(lines, "\n")
-    give skills.load(name)
-
--- la task de la tool mcp (mcp.syn está un nivel arriba de tools/, así que vive acá, como skill_tool).
--- add/remove SIEMPRE piden aprobación (permission.syn): conectar un server = ejecutar un comando de terceros.
-task mcp_tool(action, name, command, env, scope)
-    require exec
-    require time
-    require env("LAMPSON_*")
-    require env("OS")
-    require file(".lampson")
-    require file(".lampson/*")
-    require file("workspace")
-    require file("workspace/*")
-    when action == "add"
-        give mcp.add_server(name, command, env, scope)
-    when action == "remove"
-        give mcp.remove_server(name)
-    let sm be mcp.summary()
-    when length(sm) == 0
-        give "no MCP servers connected. Config files: " + mcp.GLOBAL_CONFIG + " (global) · " + mcp.PROJECT_CONFIG + " (this project)"
-    let lines be []
-    each ms in sm
-        set lines to append(lines, ms["name"] + " (" + ms["scope"] + ", " + ms["status"] + "): " + text(length(ms["tools"])) + " tools" + (when ms["error"] != nothing then " · " + text(ms["error"]) otherwise ""))
-    give join(lines, "\n")
-
-let MCP_SPEC be {
-    "name": "mcp",
-    "description": "Manage MCP (Model Context Protocol) servers. action=list (default): connected servers and their status. action=add: connect a server — name plus the full command line that starts it (e.g. command='npx -y @modelcontextprotocol/server-github'); scope=global (default) makes it available in every project (lampson/.lampson/mcp.json), scope=project only in this one (workspace/.lampson/mcp.json); env = extra environment variables the server needs (tokens, keys). action=remove: disconnect and delete it from the config. add/remove always ask the user for approval. A connected server's tools appear in your catalog as mcp_<server>_<tool> from the NEXT turn. Propose add when the user asks to connect/install an MCP or a task clearly needs one.",
-    "parameters": {"type": "object", "properties": {
-        "action": {"type": "string", "enum": ["list", "add", "remove"], "description": "Default: list"},
-        "name": {"type": "string", "description": "add/remove: server name (letters, digits, - or _)"},
-        "command": {"type": "string", "description": "add only: full command line that starts the server (quotes allowed)"},
-        "env": {"type": "object", "description": "add only: environment variables for the server, e.g. {\"GITHUB_TOKEN\": \"…\"}"},
-        "scope": {"type": "string", "enum": ["global", "project"], "description": "add only: global (default, every project) or project"}
-    }, "required": ["action"]}
-}
-
--- la task de la tool lamp (lamps.syn vive un nivel arriba de tools/, como mcp). enable/disable piden humano
--- SIEMPRE (permission.syn): encender = autorizar código a correr con las capacidades de su manifiesto.
-task lamp_tool(action, name, manifest, files)
-    require exec
-    require time
-    require env("LAMPSON_*")
-    require file(".lampson")
-    require file(".lampson/*")
-    require file.read("lamps")
-    require file.read("lamps/*")
-    require file("workspace")
-    require file("workspace/*")
-    when action == "create"
-        give lamps.create(name, manifest, files)
-    when action == "enable"
-        give lamps.set_enabled(name, true)
-    when action == "disable"
-        give lamps.set_enabled(name, false)
-    let sm be lamps.summary()
-    when length(sm) == 0
-        give "no lamps found. A lamp is a folder with a lamp.json manifest: " + lamps.GLOBAL_DIR + "/<name>/ (global) or " + lamps.PROJECT_DIR + "/<name>/ (this project; you can create it with write). See the lampson skill for the manifest format."
-    let lines be []
-    each l in sm
-        set lines to append(lines, l["name"] + " (" + l["scope"] + ", " + l["kind"] + ", " + (when l["enabled"] then "ON" otherwise "off") + "): " + (when l["error"] != nothing then "BROKEN — " + text(l["error"]) otherwise text(length(l["tools"])) + " tools [" + join(l["tools"], ", ") + "]" + (when l["description"] != "" then " — " + l["description"] otherwise "")))
-    give join(lines, "\n")
-
-let LAMP_SPEC be {
-    "name": "lamp",
-    "description": "Lamps are tool plugins you can build for this project: a folder with a lamp.json manifest plus code — a Synsema program (kind=syn) run under a capability ceiling, or any executable (kind=exec). Consider one when a task needs a reusable custom tool (a project-specific query, generator, checker) that plain bash would repeat clumsily. action=list (default): every lamp found, on/off, its tools. action=create: write a PROJECT lamp (name + manifest + files) — it validates the manifest and runs `synsema check` on a syn entry, but does NOT run or enable it. action=enable / disable: turn one on or off — ALWAYS asks the user (enabling authorizes its code to run with the manifest's capabilities). An enabled lamp's tools appear in your catalog as lamp_<lamp>_<tool> from the NEXT turn. Manifest: {\"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}]}. Inside the code read LAMP_TOOL and LAMP_ARGS (JSON) from env and print the result to stdout (a .syn needs `require env(\"LAMP_*\")`). Lamp names: letters, digits, - (no _).",
-    "parameters": {"type": "object", "properties": {
-        "action": {"type": "string", "enum": ["list", "create", "enable", "disable"], "description": "Default: list"},
-        "name": {"type": "string", "description": "create/enable/disable: lamp name"},
-        "manifest": {"type": "object", "description": "create only: the lamp.json content (name is filled in)"},
-        "files": {"type": "object", "description": "create only: {\"lamp.syn\": \"<code>\", …} — files written into the lamp folder", "additionalProperties": {"type": "string"}}
-    }, "required": ["action"]}
-}
-
--- la tool lsp (lib/lsp.syn): navegación semántica. Solo lectura → permission la permite siempre.
-task lsp_tool(op, path, line, character, server, scope)
-    require exec
-    require time
-    require env("LAMPSON_*")
-    require env("OS")
-    require file(".lampson")
-    require file(".lampson/*")
-    require file("workspace")
-    require file("workspace/*")
-    -- op=add: el agente propone un preset y el humano aprueba (permission.syn: ask siempre, como mcp add)
-    when op == "add"
-        give lsp.add_server(server, nothing, nothing, when scope == nothing then "global" otherwise scope)
-    when op == "list"
-        let sm be lsp.summary()
-        when length(sm) == 0
-            give "no language servers configured. Presets: " + join(keys(lsp.PRESETS), ", ") + " — propose op=add with server=<preset> (the user approves)."
-        give join(apply(sm, (x) => x["name"] + " (" + x["scope"] + ", " + x["status"] + "): " + join(x["extensions"], " ") + (when x["error"] != nothing then " · " + text(x["error"]) otherwise "")), "\n")
-    give lsp.query(op, path, line, character)
-
-let LSP_SPEC be {
-    "name": "lsp",
-    "description": "Semantic code navigation through the project's language server (same engine as the editor). Use it when grep is ambiguous or before a change that needs exact definitions/usages, and to see a file's structure WITHOUT reading it: op=symbols lists every function/class/variable with line ranges — then read only the range you need. op=definition: where the symbol under the cursor is defined. op=references: every usage (declaration included). op=implementation: implementations of an interface/abstract member. op=hover: type signature and docs. Positions are 1-based line and character, like the editor; put the cursor ON the identifier (an off-symbol position returns nothing). The server for a file is chosen by extension; if none is configured for that extension, propose op=add with server=<preset> (typescript, python, rust, go, css, html) — it always asks the user for approval and needs nothing installed (npx fetches it); op=list shows what is configured. The first query of a session starts the server (a few seconds).",
-    "parameters": {"type": "object", "properties": {
-        "op": {"type": "string", "enum": ["symbols", "definition", "references", "implementation", "hover", "list", "add"]},
-        "server": {"type": "string", "description": "add only: preset name (typescript | python | rust | go | css | html)"},
-        "scope": {"type": "string", "enum": ["global", "project"], "description": "add only: global (default, every project) or project"},
-        "path": {"type": "string", "description": "File path relative to the workspace root"},
-        "line": {"type": "integer", "description": "1-based line (not for symbols)"},
-        "character": {"type": "integer", "description": "1-based column of the identifier (not for symbols)"}
-    }, "required": ["op"]}
-}
-
--- Allow-list nombre → task. El modelo solo devuelve NOMBRES; el loop decide si se ejecuta.
-export task registry()
-    give {
-        "read": t_read.tool,
-        "write": t_write.tool,
-        "edit": t_edit.tool,
-        "ls": t_ls.tool,
-        "find": t_find.tool,
-        "grep": t_grep.tool,
-        "bash": t_bash.tool,
-        "process": t_process.tool,
-        "memory": t_memo.tool,
-        "todo": t_todo.tool,
-        "skill": skill_tool,
-        "mcp": mcp_tool,
-        "lamp": lamp_tool,
-        "lsp": lsp_tool
-    }
-
-export let CATALOG be [t_read.SPEC, t_write.SPEC, t_edit.SPEC, t_ls.SPEC, t_find.SPEC, t_grep.SPEC, LSP_SPEC, t_bash.SPEC, t_process.SPEC, t_memo.SPEC, t_todo.SPEC, t_skill.SPEC, MCP_SPEC, LAMP_SPEC]
-
--- Subconjuntos (para perfiles de agente): registry/catálogo filtrados por nombre.
-export task registry_subset(names)
-    let all be registry()
-    let out be {}
-    each n in names
-        when contains(all, n)
-            set out[n] to all[n]
-    give out
-
-export task catalog_subset(names)
-    give where(CATALOG, (s) => contains(names, s["name"]))
-
--- Re-exports usados por los entries
-export task truncate(s, max)
-    give common.truncate(s, max)
-
-export task shell_config()
-    require env("LAMPSON_*")
-    require env("OS")
-    give t_bash.shell_config()
+-- lib/tools.syn — agregador de tools: una tool = un archivo en lib/tools/<nombre>.syn
+--
+-- Contrato de cada archivo de tool ("plugin"):
+--   export task tool(...)    -- la tool; sus `require` al TOPE del cuerpo (call_tool los intersecta)
+--   export let SPEC be {...} -- {name, description, parameters (JSON Schema)} para el modelo
+--
+-- Para agregar una tool: crear lib/tools/x.syn con ese contrato y sumarla a las dos listas de abajo.
+-- La lista es EXPLÍCITA a propósito: Synsema no tiene `use` dinámico (sin supply chain), así que
+-- el allow-list de tools se lee en este archivo y se audita con `synsema check`.
+--
+-- Seguridad que ya pone el lenguaje: ninguna tool declara `net` → ninguna tool puede usar la red,
+-- aunque el entry la tenga para hablar con el LLM.
+
+use "./tools/common.syn" as common
+use "./tools/read.syn" as t_read
+use "./tools/write.syn" as t_write
+use "./tools/edit.syn" as t_edit
+use "./tools/ls.syn" as t_ls
+use "./tools/find.syn" as t_find
+use "./tools/grep.syn" as t_grep
+use "./tools/bash.syn" as t_bash
+use "./tools/skill.syn" as t_skill
+use "./tools/process.syn" as t_process
+use "./tools/memo.syn" as t_memo
+use "./tools/todo.syn" as t_todo
+use "./skills.syn" as skills
+use "./mcp.syn" as mcp
+use "./lamps.syn" as lamps
+use "./lsp.syn" as lsp
+
+-- la task de la tool skill (su SPEC está en tools/skill.syn)
+task skill_tool(name, action, source, scope)
+    require exec
+    require time
+    require env("LAMPSON_*")
+    require env("OS")
+    require file.read("skills")
+    require file.read("skills/*")
+    require file.read("workspace")
+    require file.read("workspace/*")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    when action == "install"
+        give skills.install(source, name, scope)
+    when action == "list"
+        let idx be skills.index()
+        let lines be []
+        each n in sort_by(keys(idx), (x) => x)
+            set lines to append(lines, n + " (" + idx[n]["source"] + "): " + idx[n]["description"])
+        give join(lines, "\n")
+    give skills.load(name)
+
+-- la task de la tool mcp (mcp.syn está un nivel arriba de tools/, así que vive acá, como skill_tool).
+-- add/remove SIEMPRE piden aprobación (permission.syn): conectar un server = ejecutar un comando de terceros.
+task mcp_tool(action, name, command, env, scope)
+    require exec
+    require time
+    require env("LAMPSON_*")
+    require env("OS")
+    require file(".lampson")
+    require file(".lampson/*")
+    require file("workspace")
+    require file("workspace/*")
+    when action == "add"
+        give mcp.add_server(name, command, env, scope)
+    when action == "remove"
+        give mcp.remove_server(name)
+    let sm be mcp.summary()
+    when length(sm) == 0
+        give "no MCP servers connected. Config files: " + mcp.GLOBAL_CONFIG + " (global) · " + mcp.PROJECT_CONFIG + " (this project)"
+    let lines be []
+    each ms in sm
+        set lines to append(lines, ms["name"] + " (" + ms["scope"] + ", " + ms["status"] + "): " + text(length(ms["tools"])) + " tools" + (when ms["error"] != nothing then " · " + text(ms["error"]) otherwise ""))
+    give join(lines, "\n")
+
+let MCP_SPEC be {
+    "name": "mcp",
+    "description": "Manage MCP (Model Context Protocol) servers. action=list (default): connected servers and their status. action=add: connect a server — name plus the full command line that starts it (e.g. command='npx -y @modelcontextprotocol/server-github'); scope=global (default) makes it available in every project (lampson/.lampson/mcp.json), scope=project only in this one (workspace/.lampson/mcp.json); env = extra environment variables the server needs (tokens, keys). action=remove: disconnect and delete it from the config. add/remove always ask the user for approval. A connected server's tools appear in your catalog as mcp_<server>_<tool> from the NEXT turn. Propose add when the user asks to connect/install an MCP or a task clearly needs one.",
+    "parameters": {"type": "object", "properties": {
+        "action": {"type": "string", "enum": ["list", "add", "remove"], "description": "Default: list"},
+        "name": {"type": "string", "description": "add/remove: server name (letters, digits, - or _)"},
+        "command": {"type": "string", "description": "add only: full command line that starts the server (quotes allowed)"},
+        "env": {"type": "object", "description": "add only: environment variables for the server, e.g. {\"GITHUB_TOKEN\": \"…\"}"},
+        "scope": {"type": "string", "enum": ["global", "project"], "description": "add only: global (default, every project) or project"}
+    }, "required": ["action"]}
+}
+
+-- la task de la tool lamp (lamps.syn vive un nivel arriba de tools/, como mcp). enable/disable piden humano
+-- SIEMPRE (permission.syn): encender = autorizar código a correr con las capacidades de su manifiesto.
+task lamp_tool(action, name, manifest, files)
+    require exec
+    require time
+    require env("LAMPSON_*")
+    require file(".lampson")
+    require file(".lampson/*")
+    require file.read("lamps")
+    require file.read("lamps/*")
+    require file("workspace")
+    require file("workspace/*")
+    when action == "create"
+        give lamps.create(name, manifest, files)
+    when action == "enable"
+        give lamps.set_enabled(name, true)
+    when action == "disable"
+        give lamps.set_enabled(name, false)
+    let sm be lamps.summary()
+    when length(sm) == 0
+        give "no lamps found. A lamp is a folder with a lamp.json manifest: " + lamps.GLOBAL_DIR + "/<name>/ (global) or " + lamps.PROJECT_DIR + "/<name>/ (this project; you can create it with write). See the lampson skill for the manifest format."
+    let lines be []
+    each l in sm
+        set lines to append(lines, l["name"] + " (" + l["scope"] + ", " + l["kind"] + ", " + (when l["enabled"] then "ON" otherwise "off") + "): " + (when l["error"] != nothing then "BROKEN — " + text(l["error"]) otherwise text(length(l["tools"])) + " tools [" + join(l["tools"], ", ") + "]" + (when l["description"] != "" then " — " + l["description"] otherwise "")))
+    give join(lines, "\n")
+
+let LAMP_SPEC be {
+    "name": "lamp",
+    "description": "Lamps are tool plugins you can build for this project: a folder with a lamp.json manifest plus code — a Synsema program (kind=syn) run under a capability ceiling, or any executable (kind=exec). Consider one when a task needs a reusable custom tool (a project-specific query, generator, checker) that plain bash would repeat clumsily. action=list (default): every lamp found, on/off, its tools. action=create: write a PROJECT lamp (name + manifest + files) — it validates the manifest and runs `synsema check` on a syn entry, but does NOT run or enable it. action=enable / disable: turn one on or off — ALWAYS asks the user (enabling authorizes its code to run with the manifest's capabilities). An enabled lamp's tools appear in your catalog as lamp_<lamp>_<tool> from the NEXT turn. Manifest: {\"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}]}. Inside the code read LAMP_TOOL and LAMP_ARGS (JSON) from env and print the result to stdout (a .syn needs `require env(\"LAMP_*\")`). Lamp names: letters, digits, - (no _).",
+    "parameters": {"type": "object", "properties": {
+        "action": {"type": "string", "enum": ["list", "create", "enable", "disable"], "description": "Default: list"},
+        "name": {"type": "string", "description": "create/enable/disable: lamp name"},
+        "manifest": {"type": "object", "description": "create only: the lamp.json content (name is filled in)"},
+        "files": {"type": "object", "description": "create only: {\"lamp.syn\": \"<code>\", …} — files written into the lamp folder", "additionalProperties": {"type": "string"}}
+    }, "required": ["action"]}
+}
+
+-- la tool lsp (lib/lsp.syn): navegación semántica. Solo lectura → permission la permite siempre.
+task lsp_tool(op, path, line, character, server, scope)
+    require exec
+    require time
+    require env("LAMPSON_*")
+    require env("OS")
+    require file(".lampson")
+    require file(".lampson/*")
+    require file("workspace")
+    require file("workspace/*")
+    -- op=add: el agente propone un preset y el humano aprueba (permission.syn: ask siempre, como mcp add)
+    when op == "add"
+        give lsp.add_server(server, nothing, nothing, when scope == nothing then "global" otherwise scope)
+    when op == "list"
+        let sm be lsp.summary()
+        when length(sm) == 0
+            give "no language servers configured. Presets: " + join(keys(lsp.PRESETS), ", ") + " — propose op=add with server=<preset> (the user approves)."
+        give join(apply(sm, (x) => x["name"] + " (" + x["scope"] + ", " + x["status"] + "): " + join(x["extensions"], " ") + (when x["error"] != nothing then " · " + text(x["error"]) otherwise "")), "\n")
+    give lsp.query(op, path, line, character)
+
+let LSP_SPEC be {
+    "name": "lsp",
+    "description": "Semantic code navigation through the project's language server (same engine as the editor). Use it when grep is ambiguous or before a change that needs exact definitions/usages, and to see a file's structure WITHOUT reading it: op=symbols lists every function/class/variable with line ranges — then read only the range you need. op=definition: where the symbol under the cursor is defined. op=references: every usage (declaration included). op=implementation: implementations of an interface/abstract member. op=hover: type signature and docs. Positions are 1-based line and character, like the editor; put the cursor ON the identifier (an off-symbol position returns nothing). The server for a file is chosen by extension; if none is configured for that extension, propose op=add with server=<preset> (typescript, python, rust, go, css, html) — it always asks the user for approval and needs nothing installed (npx fetches it); op=list shows what is configured. The first query of a session starts the server (a few seconds).",
+    "parameters": {"type": "object", "properties": {
+        "op": {"type": "string", "enum": ["symbols", "definition", "references", "implementation", "hover", "list", "add"]},
+        "server": {"type": "string", "description": "add only: preset name (typescript | python | rust | go | css | html)"},
+        "scope": {"type": "string", "enum": ["global", "project"], "description": "add only: global (default, every project) or project"},
+        "path": {"type": "string", "description": "File path relative to the workspace root"},
+        "line": {"type": "integer", "description": "1-based line (not for symbols)"},
+        "character": {"type": "integer", "description": "1-based column of the identifier (not for symbols)"}
+    }, "required": ["op"]}
+}
+
+-- Allow-list nombre → task. El modelo solo devuelve NOMBRES; el loop decide si se ejecuta.
+export task registry()
+    give {
+        "read": t_read.tool,
+        "write": t_write.tool,
+        "edit": t_edit.tool,
+        "ls": t_ls.tool,
+        "find": t_find.tool,
+        "grep": t_grep.tool,
+        "bash": t_bash.tool,
+        "process": t_process.tool,
+        "memory": t_memo.tool,
+        "todo": t_todo.tool,
+        "skill": skill_tool,
+        "mcp": mcp_tool,
+        "lamp": lamp_tool,
+        "lsp": lsp_tool
+    }
+
+export let CATALOG be [t_read.SPEC, t_write.SPEC, t_edit.SPEC, t_ls.SPEC, t_find.SPEC, t_grep.SPEC, LSP_SPEC, t_bash.SPEC, t_process.SPEC, t_memo.SPEC, t_todo.SPEC, t_skill.SPEC, MCP_SPEC, LAMP_SPEC]
+
+-- Subconjuntos (para perfiles de agente): registry/catálogo filtrados por nombre.
+export task registry_subset(names)
+    let all be registry()
+    let out be {}
+    each n in names
+        when contains(all, n)
+            set out[n] to all[n]
+    give out
+
+export task catalog_subset(names)
+    give where(CATALOG, (s) => contains(names, s["name"]))
+
+-- Re-exports usados por los entries
+export task truncate(s, max)
+    give common.truncate(s, max)
+
+export task shell_config()
+    require env("LAMPSON_*")
+    require env("OS")
+    give t_bash.shell_config()

package/lib/tree.syn

@@ -1,59 +1,59 @@
--- lib/tree.syn — árbol de archivos del workspace (para el banner de terminal y el explorador web)
-use "./tools/common.syn" as c
-
-let MAX_ENTRIES be 2000
-
-task walk(dir, depth, max_depth, state)
-    let out be []
-    when depth > max_depth
-        give out
-    let entries be []
-    try
-        set entries to list_dir(dir)
-    recover err
-        give out
-    each e in entries
-        when state["n"] >= MAX_ENTRIES
-            give out
-        let rel be c.unws(dir + "/" + e["name"])
-        when e["is_dir"]
-            when not contains(c.IGNORED_DIRS, e["name"])
-                set state["n"] to state["n"] + 1
-                set out to append(out, {"name": e["name"], "path": rel, "is_dir": true, "children": walk(dir + "/" + e["name"], depth + 1, max_depth, state)})
-        otherwise
-            set state["n"] to state["n"] + 1
-            set out to append(out, {"name": e["name"], "path": rel, "is_dir": false, "size": e["size"]})
-    -- carpetas primero
-    give where(out, (x) => x["is_dir"]) + where(out, (x) => not x["is_dir"])
-
--- árbol anidado: [{name, path, is_dir, size?, children?}]
-export task tree(max_depth)
-    require file.read("workspace")
-    require file.read("workspace/*")
-    let state be {"n": 0}
-    give {"entries": walk(c.ROOT, 0, max_depth, state), "count": state["n"], "truncated": state["n"] >= MAX_ENTRIES}
-
--- render de texto para la terminal (2 niveles, compacto)
-export task render(max_depth, max_lines)
-    require file.read("workspace")
-    require file.read("workspace/*")
-    let t be tree(max_depth)
-    let lines be []
-    each e in t["entries"]
-        when length(lines) < max_lines
-            set lines to append(lines, "  " + e["name"] + (when e["is_dir"] then "/" otherwise ""))
-            when e["is_dir"] and contains(e, "children")
-                each ch in e["children"]
-                    when length(lines) < max_lines
-                        set lines to append(lines, "    " + ch["name"] + (when ch["is_dir"] then "/" otherwise ""))
-    when length(lines) >= max_lines
-        set lines to append(lines, "  … " + text(t["count"]) + " entradas en total — /files muestra el árbol completo")
-    give join(lines, "\n")
-
--- contenido de un archivo para el visor web
-export task file_content(path)
-    require file.read("workspace")
-    require file.read("workspace/*")
-    let real be c.ws(path)
-    let content be read_file(real)
-    give {"path": c.unws(real), "content": c.truncate(content, 200000), "lines": length(split(content, "\n"))}
+-- lib/tree.syn — árbol de archivos del workspace (para el banner de terminal y el explorador web)
+use "./tools/common.syn" as c
+
+let MAX_ENTRIES be 2000
+
+task walk(dir, depth, max_depth, state)
+    let out be []
+    when depth > max_depth
+        give out
+    let entries be []
+    try
+        set entries to list_dir(dir)
+    recover err
+        give out
+    each e in entries
+        when state["n"] >= MAX_ENTRIES
+            give out
+        let rel be c.unws(dir + "/" + e["name"])
+        when e["is_dir"]
+            when not contains(c.IGNORED_DIRS, e["name"])
+                set state["n"] to state["n"] + 1
+                set out to append(out, {"name": e["name"], "path": rel, "is_dir": true, "children": walk(dir + "/" + e["name"], depth + 1, max_depth, state)})
+        otherwise
+            set state["n"] to state["n"] + 1
+            set out to append(out, {"name": e["name"], "path": rel, "is_dir": false, "size": e["size"]})
+    -- carpetas primero
+    give where(out, (x) => x["is_dir"]) + where(out, (x) => not x["is_dir"])
+
+-- árbol anidado: [{name, path, is_dir, size?, children?}]
+export task tree(max_depth)
+    require file.read("workspace")
+    require file.read("workspace/*")
+    let state be {"n": 0}
+    give {"entries": walk(c.ROOT, 0, max_depth, state), "count": state["n"], "truncated": state["n"] >= MAX_ENTRIES}
+
+-- render de texto para la terminal (2 niveles, compacto)
+export task render(max_depth, max_lines)
+    require file.read("workspace")
+    require file.read("workspace/*")
+    let t be tree(max_depth)
+    let lines be []
+    each e in t["entries"]
+        when length(lines) < max_lines
+            set lines to append(lines, "  " + e["name"] + (when e["is_dir"] then "/" otherwise ""))
+            when e["is_dir"] and contains(e, "children")
+                each ch in e["children"]
+                    when length(lines) < max_lines
+                        set lines to append(lines, "    " + ch["name"] + (when ch["is_dir"] then "/" otherwise ""))
+    when length(lines) >= max_lines
+        set lines to append(lines, "  … " + text(t["count"]) + " entradas en total — /files muestra el árbol completo")
+    give join(lines, "\n")
+
+-- contenido de un archivo para el visor web
+export task file_content(path)
+    require file.read("workspace")
+    require file.read("workspace/*")
+    let real be c.ws(path)
+    let content be read_file(real)
+    give {"path": c.unws(real), "content": c.truncate(content, 200000), "lines": length(split(content, "\n"))}