lampson 0.2.6 → 0.2.7

package/public/js/{lamps.js → plugins.js}

@@ -1,20 +1,20 @@
-// lamps.js — lámparas (plugins de tools): pill en la cabecera + vista browse del Panel (lista, detalle con
+// plugins.js — plugins (tools propias): pill en la cabecera + vista browse del Panel (lista, detalle con
 // switch, tools con formulario generado del schema, correr, borrar) y la ayuda «?».
-let lampsData = [], lampsMeta = { global: 'lamps/', project: '.lampson/lamps/' };
-async function fetchLamps() {
-  let r; try { r = await (await fetch(BASE + '/api/lamps')).json(); } catch (e) { return lampsData; }
-  lampsData = r.lamps || []; lampsMeta = { global: r.global || 'lamps/', project: r.project || '.lampson/lamps/' };
-  const on = lampsData.filter(l => l.enabled).length;
-  const pill = $('#lamps'); pill.textContent = lampsData.length ? `lámparas ${on}/${lampsData.length}` : 'lámparas'; pill.classList.toggle('on', on > 0);
-  return lampsData;
+let pluginsData = [], pluginsMeta = { global: 'plugins/', project: '.lampson/plugins/' };
+async function fetchPlugins() {
+  let r; try { r = await (await fetch(BASE + '/api/plugins')).json(); } catch (e) { return pluginsData; }
+  pluginsData = r.plugins || []; pluginsMeta = { global: r.global || 'plugins/', project: r.project || '.lampson/plugins/' };
+  const on = pluginsData.filter(l => l.enabled).length;
+  const pill = $('#plugins'); pill.textContent = pluginsData.length ? `plugins ${on}/${pluginsData.length}` : 'plugins'; pill.classList.toggle('on', on > 0);
+  return pluginsData;
 }
-async function loadLamps() { await fetchLamps(); if (Panel.is('lamps')) Panel.refresh(); }
-function lampMatches(l, q) {
+async function loadPlugins() { await fetchPlugins(); if (Panel.is('plugins')) Panel.refresh(); }
+function pluginMatches(l, q) {
   if (!q) return true;
   const hay = [l.name, l.description || '', l.scope, l.kind, ...(l.tools || [])].join(' ').toLowerCase();
   return q.toLowerCase().split(/\s+/).every(t => hay.includes(t));
 }
-function lampField(k, p, required) {
+function pluginField(k, p, required) {
   const def = p.default !== undefined ? p.default : ''; const req = required.includes(k) ? ' <span class="req">(obligatorio)</span>' : '';
   let input;
   if (Array.isArray(p.enum)) input = `<select data-k="${esc(k)}">${p.enum.map(v => `<option value="${esc(String(v))}" ${String(v) === String(def) ? 'selected' : ''}>${esc(String(v))}</option>`).join('')}</select>`;
@@ -24,7 +24,7 @@ function lampField(k, p, required) {
   return `<label class="lf"><span class="lk">${esc(k)}${req}</span>${input}${p.description ? `<span class="ds">${esc(p.description)}</span>` : ''}</label>`;
 }
 // lee los campos de una tool → args (o {error})
-function lampArgs(tdiv, props, required) {
+function pluginArgs(tdiv, props, required) {
   const args = {};
   for (const el of tdiv.querySelectorAll('[data-k]')) {
     const k = el.dataset.k, p = props[k] || {}; let v = el.value;
@@ -36,10 +36,10 @@ function lampArgs(tdiv, props, required) {
   }
   return { args };
 }
-const LAMPS_HELP = `<h4>Herramientas hechas a medida para este proyecto</h4>
-  <p>Una lámpara es una tool que el agente (o vos) escribe para <em>este</em> repo: una carpeta con <code>lamp.json</code> y el código — en Synsema (corre bajo un techo de capacidades que no puede superar) o en cualquier lenguaje (<code>python</code>, <code>node</code>, un binario). A diferencia de un script suelto, el modelo la ve en su catálogo con parámetros tipados, vos la podés correr desde acá, y queda en el repo para la próxima sesión.</p>
-  <p><b>Pedila en el chat</b> — <i>«hacé una lámpara que liste los endpoints del backend»</i>. El agente la escribe en <code data-project></code>, la valida y te pide encenderla acá.</p>
-  <p><b>Encendida = existe</b> — apagada, el agente ni la ve. Al encenderla, sus tools entran al catálogo como <code>lamp_&lt;lámpara&gt;_&lt;tool&gt;</code> desde el próximo turno. Las globales viven en <code data-global></code> y valen para todos los proyectos.</p>
+const PLUGINS_HELP = `<h4>Herramientas hechas a medida para este proyecto</h4>
+  <p>Un plugin es una tool que el agente (o vos) escribe para <em>este</em> repo: una carpeta con <code>plugin.json</code> y el código — en Synsema (corre bajo un techo de capacidades que no puede superar) o en cualquier lenguaje (<code>python</code>, <code>node</code>, un binario). A diferencia de un script suelto, el modelo lo ve en su catálogo con parámetros tipados, vos lo podés correr desde acá, y queda en el repo para la próxima sesión.</p>
+  <p><b>Pedilo en el chat</b> — <i>«hacé un plugin que liste los endpoints del backend»</i>. El agente lo escribe en <code data-project></code>, lo valida y te pide encenderlo acá.</p>
+  <p><b>Encendido = existe</b> — apagado, el agente ni lo ve. Al encenderlo, sus tools entran al catálogo como <code>plugin_&lt;plugin&gt;_&lt;tool&gt;</code> desde el próximo turno. Los globales viven en <code data-global></code> y valen para todos los proyectos.</p>
   <p><b>Ejemplos</b></p>
   <ul>
     <li><b>Consultas del proyecto</b> — <code>endpoints()</code> que parsea tus rutas y devuelve método + path + handler; <code>env_keys()</code> usadas vs. definidas en <code>.env.example</code>.</li>
@@ -48,51 +48,53 @@ const LAMPS_HELP = `<h4>Herramientas hechas a medida para este proyecto</h4>
     <li><b>Datos locales</b> — <code>db_schema()</code> / <code>query(sql)</code> contra tu SQLite con techo <code>db=./dev.db</code>.</li>
     <li><b>Integraciones sin MCP</b> — <code>deploy_status()</code> contra tu API con techo <code>net=api.x.com</code>.</li>
   </ul>
-  <p><button class="primary" data-back>← volver a las lámparas</button></p>`;
-function openLamps(selectName) {
+  <p>¿Querés herramientas con techo real, versionadas y compartidas entre agentes (Claude Code, Cursor, lampson…)? Eso son las <a href="https://lamps.sh" target="_blank" rel="noopener">lámparas de lamps.sh</a>: se instalan con <code>lamp add</code> y entran acá como servidor MCP (<code>lamp mcp</code>).</p>
+  <p><button class="primary" data-back>← volver a los plugins</button></p>`;
+function openPlugins(selectName) {
   let first = selectName || null;
   Panel.open({
-    id: 'lamps', eyebrow: 'lámparas', title: 'Lámparas', layout: 'browse',
-    headActions: [{ label: '?', title: '¿qué es una lámpara?', onClick: (b) => { Panel.help(true); const h = b.querySelector('.phelp'); h.querySelector('[data-project]').textContent = lampsMeta.project; h.querySelector('[data-global]').textContent = lampsMeta.global; h.querySelector('[data-back]').onclick = () => Panel.help(false); } }],
+    id: 'plugins', eyebrow: 'plugins', title: 'Plugins', layout: 'browse',
+    headActions: [{ label: '?', title: '¿qué es un plugin?', onClick: (b) => { Panel.help(true); const h = b.querySelector('.phelp'); h.querySelector('[data-project]').textContent = pluginsMeta.project; h.querySelector('[data-global]').textContent = pluginsMeta.global; h.querySelector('[data-back]').onclick = () => Panel.help(false); } }],
     browse: {
-      placeholder: 'buscar lámpara o tool…', listWidth: '260px', help: LAMPS_HELP,
+      placeholder: 'buscar plugin o tool…', listWidth: '260px', help: PLUGINS_HELP,
       key: l => l.name,
-      load: async (q) => { const all = await fetchLamps(); const list = all.filter(l => lampMatches(l, q)); if (first) { const i = list.findIndex(l => l.name === first); first = null; if (i > 0) list.unshift(list.splice(i, 1)[0]); } return list; },
-      render: (l) => `<span class="dot">${l.error ? '!' : (l.enabled ? '●' : '○')}</span><div><div class="nm">${esc(l.name)}</div><div class="meta">${esc(l.scope)} · ${esc(l.kind)} · ${(l.tools || []).length} tool${(l.tools || []).length === 1 ? '' : 's'}${l.error ? ' · rota' : ''}</div></div>`,
-      count: (rows, q) => q ? `${rows.length} de ${lampsData.length}` : `${lampsData.length} lámpara${lampsData.length === 1 ? '' : 's'}`,
-      emptyHtml: 'ninguna todavía',
-      emptyDetail: `Todavía no hay lámparas.<br><br>Pedile una al agente en el chat — <i>«hacé una lámpara que liste los endpoints del backend»</i> — o creá una carpeta con <code>lamp.json</code> en <code>${esc(lampsMeta.project)}</code> (proyecto) o <code>${esc(lampsMeta.global)}</code> (global). El botón <b>?</b> de arriba explica qué son y para qué sirven.`,
+      load: async (q) => { const all = await fetchPlugins(); const list = all.filter(l => pluginMatches(l, q)); if (first) { const i = list.findIndex(l => l.name === first); first = null; if (i > 0) list.unshift(list.splice(i, 1)[0]); } return list; },
+      render: (l) => `<span class="dot">${l.error ? '!' : (l.enabled ? '●' : '○')}</span><div><div class="nm">${esc(l.name)}</div><div class="meta">${esc(l.scope)} · ${esc(l.kind)} · ${(l.tools || []).length} tool${(l.tools || []).length === 1 ? '' : 's'}${l.error ? ' · roto' : ''}${l.legacy ? ' · carpeta vieja' : ''}</div></div>`,
+      count: (rows, q) => q ? `${rows.length} de ${pluginsData.length}` : `${pluginsData.length} plugin${pluginsData.length === 1 ? '' : 's'}`,
+      emptyHtml: 'ninguno todavía',
+      emptyDetail: `Todavía no hay plugins.<br><br>Pedile uno al agente en el chat — <i>«hacé un plugin que liste los endpoints del backend»</i> — o creá una carpeta con <code>plugin.json</code> en <code>${esc(pluginsMeta.project)}</code> (proyecto) o <code>${esc(pluginsMeta.global)}</code> (global). El botón <b>?</b> de arriba explica qué son y para qué sirven.`,
       detail: (l) => {
         const specs = l.tool_specs || [];
-        const cap = l.error ? `<div class="dcap err">rota: ${esc(l.error)}</div>` : (l.kind === 'syn' ? `<div class="dcap">techo de capacidades: ${esc(l.caps)}</div>` : `<div class="dcap"><b>sin techo</b> (exec) · $ ${esc(l.command)}</div>`);
-        return `<div class="dhead"><span class="nm">${esc(l.name)}</span><span class="meta">${esc(l.scope)} · ${esc(l.kind)}</span><label class="sw ${l.enabled ? 'on' : ''}" title="${l.error ? 'no se puede encender: está rota' : (l.enabled ? 'apagar' : 'encender')}"><input type="checkbox" ${l.enabled ? 'checked' : ''} ${l.error ? 'disabled' : ''}>${l.enabled ? 'encendida' : 'apagada'}</label></div>`
-          + (l.description ? `<div class="ddesc">${esc(l.description)}</div>` : '') + cap
-          + (l.enabled || l.error ? '' : `<div class="dnote">Apagada: el agente no la ve y no se puede correr. Encendela con el switch — el código va a poder ejecutarse${l.kind === 'exec' ? ' <b>sin techo de capacidades</b> (es un ejecutable)' : ' bajo el techo de arriba'}.</div>`)
+        const cap = l.error ? `<div class="dcap err">roto: ${esc(l.error)}</div>` : (l.kind === 'syn' ? `<div class="dcap">techo de capacidades: ${esc(l.caps)}</div>` : `<div class="dcap"><b>sin techo</b> (exec) · $ ${esc(l.command)}</div>`);
+        const legacy = l.legacy ? `<div class="dnote">Carpeta vieja: vive en <code>.lampson/lamps/</code>. Sigue funcionando, pero renombrala a <code>.lampson/plugins/</code> (y <code>lamp.json</code> a <code>plugin.json</code>); las variables <code>LAMP_*</code> siguen llegando por ahora.</div>` : '';
+        return `<div class="dhead"><span class="nm">${esc(l.name)}</span><span class="meta">${esc(l.scope)} · ${esc(l.kind)}</span><label class="sw ${l.enabled ? 'on' : ''}" title="${l.error ? 'no se puede encender: está roto' : (l.enabled ? 'apagar' : 'encender')}"><input type="checkbox" ${l.enabled ? 'checked' : ''} ${l.error ? 'disabled' : ''}>${l.enabled ? 'encendido' : 'apagado'}</label></div>`
+          + (l.description ? `<div class="ddesc">${esc(l.description)}</div>` : '') + cap + legacy
+          + (l.enabled || l.error ? '' : `<div class="dnote">Apagado: el agente no lo ve y no se puede correr. Encendelo con el switch — el código va a poder ejecutarse${l.kind === 'exec' ? ' <b>sin techo de capacidades</b> (es un ejecutable)' : ' bajo el techo de arriba'}.</div>`)
           + specs.map((t, i) => {
               const props = (t.parameters && t.parameters.properties) || {}; const required = (t.parameters && t.parameters.required) || [];
-              return `<div class="tool" data-i="${i}"><div class="th"><code>${esc(t.name)}</code>${t.description ? `<span class="ds">${esc(t.description)}</span>` : '<span></span>'}<span class="ds">lamp_${esc(l.name)}_${esc(t.name)}</span></div>`
-                + (Object.keys(props).length ? Object.keys(props).map(k => lampField(k, props[k], required)).join('') : '<div class="ds" style="margin-top:6px;color:var(--ink-3)">no toma parámetros</div>')
+              return `<div class="tool" data-i="${i}"><div class="th"><code>${esc(t.name)}</code>${t.description ? `<span class="ds">${esc(t.description)}</span>` : '<span></span>'}<span class="ds">plugin_${esc(l.name)}_${esc(t.name)}</span></div>`
+                + (Object.keys(props).length ? Object.keys(props).map(k => pluginField(k, props[k], required)).join('') : '<div class="ds" style="margin-top:6px;color:var(--ink-3)">no toma parámetros</div>')
                 + (l.enabled ? `<div class="go"><button class="primary run">▶ correr</button><span class="st"></span></div><pre class="out" style="display:none"></pre>` : '')
                 + `</div>`;
             }).join('')
-          + `<div class="dfoot"><span>${esc(l.dir || '')}</span>${l.scope === 'project' ? '<span class="del">eliminar</span>' : '<span title="las globales se borran a mano">global · se borra a mano</span>'}</div><div class="err" data-err></div>`;
+          + `<div class="dfoot"><span>${esc(l.dir || '')}</span>${l.scope === 'project' ? '<span class="del">eliminar</span>' : '<span title="los globales se borran a mano">global · se borra a mano</span>'}</div><div class="err" data-err></div>`;
       },
       wire: (l, box) => {
         const errEl = box.querySelector('[data-err]');
         box.querySelector('.sw input').onchange = async (ev) => {
           errEl.textContent = '';
-          const r = await api(BASE + '/api/lamps/toggle', { name: l.name, enabled: ev.target.checked });
+          const r = await api(BASE + '/api/plugins/toggle', { name: l.name, enabled: ev.target.checked });
           if (!r.ok) { errEl.textContent = r.data.error || ('error ' + r.status); ev.target.checked = !ev.target.checked; return; }
-          add('meta', '☼ ' + esc(r.data.result || '')); loadLamps(); loadSched();
+          add('meta', '☼ ' + esc(r.data.result || '')); loadPlugins(); loadSched();
         };
         for (const tdiv of box.querySelectorAll('.tool')) {
           const t = (l.tool_specs || [])[Number(tdiv.dataset.i)]; const props = (t.parameters && t.parameters.properties) || {}; const required = (t.parameters && t.parameters.required) || [];
           const b = tdiv.querySelector('button.run'); if (!b) continue;
           b.onclick = async () => {
-            const st = tdiv.querySelector('.st'), out = tdiv.querySelector('.out'); const got = lampArgs(tdiv, props, required);
+            const st = tdiv.querySelector('.st'), out = tdiv.querySelector('.out'); const got = pluginArgs(tdiv, props, required);
             if (got.error) { st.textContent = got.error; return; }
             st.textContent = 'corriendo…'; out.style.display = 'none'; b.disabled = true;
-            const r = await api(BASE + '/api/lamps/run', { tool: 'lamp_' + l.name + '_' + t.name, args: got.args });
+            const r = await api(BASE + '/api/plugins/run', { tool: 'plugin_' + l.name + '_' + t.name, args: got.args });
             st.textContent = r.ok ? '' : (r.data.error || 'error ' + r.status);
             if (r.ok) { out.textContent = r.data.output; out.style.display = ''; }
             b.disabled = false;
@@ -100,13 +102,13 @@ function openLamps(selectName) {
         }
         const del = box.querySelector('.dfoot .del');
         if (del) del.onclick = () => inlineConfirm(del, `¿borrar ${l.name} del disco?`, async () => {
-          const r = await api(BASE + '/api/lamps/remove', { name: l.name });
+          const r = await api(BASE + '/api/plugins/remove', { name: l.name });
           if (!r.ok) { errEl.textContent = r.data.error || ('error ' + r.status); return; }
-          add('meta', '☼ ' + esc(r.data.result || '')); loadLamps();
+          add('meta', '☼ ' + esc(r.data.result || '')); loadPlugins();
         });
       }
     }
   });
 }
-$('#lamps').onclick = () => openLamps();
-if (location.hash === '#lamps') setTimeout(() => openLamps(), 400); // deep link: abre el panel al cargar
+$('#plugins').onclick = () => openPlugins();
+if (location.hash === '#plugins' || location.hash === '#lamps') setTimeout(() => openPlugins(), 400); // deep link: abre el panel al cargar

package/public/js/schedules.js

@@ -2,10 +2,10 @@
 // (tareas a la izquierda; a la derecha: qué hace, corridas, log, traza en vivo mientras corre, ▶ / ⏻ / quitar;
 // «+ programar» es una fila más cuyo detalle es el formulario). Corren en cualquier lampson abierto (web o
 // terminal, tick cada 30 s) o con `lampson --daemon start` con todo cerrado.
-let schedData = [], schedLamps = [], schedTick = 30, schedMountOk = true, schedLiveTimer = null;
+let schedData = [], schedPlugins = [], schedTick = 30, schedMountOk = true, schedLiveTimer = null;
 async function fetchSched() {
   let r; try { r = await (await fetch(BASE + '/api/schedules')).json(); } catch (e) { return schedData; }
-  schedData = r.tasks || []; schedLamps = r.lamps || []; schedTick = r.tick || 30; schedMountOk = r.mount_ok !== false;
+  schedData = r.tasks || []; schedPlugins = r.plugins || []; schedTick = r.tick || 30; schedMountOk = r.mount_ok !== false;
   return schedData;
 }
 async function loadSched() {
@@ -28,7 +28,7 @@ async function loadSched() {
     box.appendChild(d);
   }
   const addRow = document.createElement('div'); addRow.className = 'p'; addRow.innerHTML = `<span class="nm" style="color:var(--accent)">+ programar una tarea…</span>`;
-  addRow.title = 'una lámpara, un comando o el agente con instrucciones · también se lo podés pedir al agente en el chat';
+  addRow.title = 'un plugin, un comando o el agente con instrucciones · también se lo podés pedir al agente en el chat';
   addRow.onclick = () => openSched('__new');
   box.appendChild(addRow);
   if (Panel.is('schedules')) Panel.refresh();
@@ -42,7 +42,7 @@ function openSched(selectId) {
     browse: {
       placeholder: 'buscar tarea…', listWidth: '300px', key: t => t.id,
       load: async (q) => { const all = await fetchSched(); const list = all.filter(t => !q || (t.name + ' ' + t.plan + ' ' + t.action_text).toLowerCase().includes(q.toLowerCase())); return q ? list : [...list, SCHED_NEW]; },
-      render: (t) => t === SCHED_NEW ? `<span class="dot">+</span><div><div class="nm" style="color:var(--accent);font-weight:400">programar una tarea…</div><div class="meta">lámpara, comando o el agente</div></div>` : `<span class="dot">${schedStatusDot(t)}</span><div><div class="nm">${esc(t.name)}</div><div class="meta">${esc(t.plan)} · ${t.running ? 'corriendo' : (t.enabled ? 'próxima ' + esc(fmtWhen(t.next_run)) : 'apagada')}</div></div>`,
+      render: (t) => t === SCHED_NEW ? `<span class="dot">+</span><div><div class="nm" style="color:var(--accent);font-weight:400">programar una tarea…</div><div class="meta">plugin, comando o el agente</div></div>` : `<span class="dot">${schedStatusDot(t)}</span><div><div class="nm">${esc(t.name)}</div><div class="meta">${esc(t.plan)} · ${t.running ? 'corriendo' : (t.enabled ? 'próxima ' + esc(fmtWhen(t.next_run)) : 'apagada')}</div></div>`,
       count: (rows) => { const n = rows.filter(r => r !== SCHED_NEW).length; return `${n} tarea${n === 1 ? '' : 's'}`; },
       emptyHtml: 'nada coincide',
       detail: async (t) => {
@@ -78,12 +78,12 @@ function openSched(selectId) {
   });
 }
 function schedForm() {
-  const lampOpts = schedLamps.filter(l => l.enabled).flatMap(l => (l.tools || []).map(tl => `<option value="${esc(l.name + '/' + tl)}">${esc(l.name)} · ${esc(tl)}</option>`)).join('') || '<option value="">ninguna lámpara encendida</option>';
+  const pluginOpts = schedPlugins.filter(l => l.enabled).flatMap(l => (l.tools || []).map(tl => `<option value="${esc(l.name + '/' + tl)}">${esc(l.name)} · ${esc(tl)}</option>`)).join('') || '<option value="">ningún plugin encendido</option>';
   return `<div class="dhead"><span class="nm serif">Programar una tarea</span></div><div class="dform">
     <p class="lead">Corre sola, a la hora que digas, mientras lampson esté abierto (esta web o la terminal); con todo cerrado, <code>lampson --daemon start</code>. También podés pedírsela al agente en el chat: <i>«todos los días a las 9 corré los tests y avisame»</i>.</p>
     <label>nombre <input name="name" spellcheck="false" autocomplete="off" placeholder="tests nocturnos"></label>
     <label>cuándo <input name="when" spellcheck="false" autocomplete="off" placeholder="daily 09:00 · every 6h · mon,wed 08:30 · today 15:14 · once 2026-09-01 10:00 · in 2h"></label>
-    <label>qué corre <select name="kind"><option value="prompt">el agente, con estas instrucciones</option><option value="bash">un comando de shell</option><option value="lamp">una tool de una lámpara encendida</option></select></label>
+    <label>qué corre <select name="kind"><option value="prompt">el agente, con estas instrucciones</option><option value="bash">un comando de shell</option><option value="plugin">una tool de un plugin encendido</option></select></label>
     <div data-kind="prompt">
       <label class="col">instrucciones <textarea name="prompt" rows="4" spellcheck="false" placeholder="Corré la suite de tests. Si algo falla, buscá la causa y proponé el fix en el informe (no lo apliques). Terminá con un resumen corto."></textarea></label>
       <label>perfil <select name="agent"><option value="build">build — puede editar y correr comandos</option><option value="review">review — corre tests, no edita</option><option value="plan">plan — solo lee y propone</option><option value="explore">explore — solo busca</option></select></label>
@@ -91,8 +91,8 @@ function schedForm() {
       <p class="lead">Sobre de permisos de una corrida sin nadie mirando. En «preguntar», la aprobación aparece acá y, con URL pública + webhook (⚙), como link en tu canal; sin respuesta en 2 h se deniega. Lo destructivo del sistema se bloquea siempre.</p>
     </div>
     <div data-kind="bash" style="display:none"><label>comando <input name="command" spellcheck="false" autocomplete="off" placeholder="npm test"></label></div>
-    <div data-kind="lamp" style="display:none">
-      <label>lámpara · tool <select name="lamptool">${lampOpts}</select></label>
+    <div data-kind="plugin" style="display:none">
+      <label>plugin · tool <select name="plugintool">${pluginOpts}</select></label>
       <label>args (JSON) <input name="args" spellcheck="false" autocomplete="off" placeholder='{"who": "cron"}'></label>
     </div>
     <label>avisar a <input name="notify" spellcheck="false" autocomplete="off" placeholder="opcional: URL de webhook que recibe el resultado (JSON)"></label>
@@ -106,7 +106,7 @@ function schedFormWire(box, err) {
     const k = f('kind').value; let action;
     if (k === 'prompt') action = { type: 'prompt', prompt: f('prompt').value.trim(), agent: f('agent').value };
     else if (k === 'bash') action = { type: 'bash', command: f('command').value.trim() };
-    else { const v = f('lamptool').value; if (!v) { err('encendé una lámpara primero'); return; } const [lamp, tool] = v.split('/'); let args = {}; if (f('args').value.trim()) { try { args = JSON.parse(f('args').value); } catch (e) { err('args: JSON inválido'); return; } } action = { type: 'lamp', lamp, tool, args }; }
+    else { const v = f('plugintool').value; if (!v) { err('encendé un plugin primero'); return; } const [plugin, tool] = v.split('/'); let args = {}; if (f('args').value.trim()) { try { args = JSON.parse(f('args').value); } catch (e) { err('args: JSON inválido'); return; } } action = { type: 'plugin', plugin, tool, args }; }
     const body = { name: f('name').value.trim(), when: f('when').value.trim(), action, permission: f('permission').value, notify: f('notify').value.trim() };
     if (!body.when) { err('falta cuándo'); return; }
     err('programando…');

package/public/js/workspaces.js

@@ -50,7 +50,7 @@ function openWorkspaces(selectSlug) {
 }
 function wsNewForm() {
   return `<div class="dhead"><span class="nm serif">Nuevo workspace</span></div><div class="dform">
-    <p class="lead">Un workspace es una carpeta de tu disco: el agente solo puede tocar lo que hay adentro. Corre en su propio proceso, con sus sesiones, tareas programadas, MCP y lámparas.</p>
+    <p class="lead">Un workspace es una carpeta de tu disco: el agente solo puede tocar lo que hay adentro. Corre en su propio proceso, con sus sesiones, tareas programadas, MCP y plugins.</p>
     <div class="pickrow"><button class="primary" data-pick>Elegir carpeta…</button><span class="ds">se abre el diálogo de carpetas de tu sistema · <a href="#" data-browse>o explorá desde acá</a></span></div>
     <div class="chosen" data-chosen style="display:none"><span class="lk">carpeta</span><code data-chosen-path></code><span class="del" data-clear title="elegir otra">✕</span></div>
     <div data-browser class="wsbrowser" style="display:none">

package/skills/lampson/SKILL.md

@@ -43,7 +43,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 +95,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 +128,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")
@@ -57,7 +57,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 +105,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()
@@ -261,7 +261,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 +335,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))
 
@@ -478,7 +479,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 + "'")