lampson 0.2.7 → 0.2.8

package/lib/tools/url.syn

@@ -0,0 +1,220 @@
+-- lib/tools/url.syn — URLs para la tool fetch y para permission.syn (puro, sin capacidades)
+--
+--   parse(url)        → {ok, error?, url, scheme, host, port, path, query, origin, dir}
+--   host_class(host)  → "public" | "private" | "blocked"
+--   sensitive(url)    → motivo (texto) si la URL lleva una credencial, o nothing
+--   resolve(base, href) → URL absoluta de un href (relativo o no), o nothing si no es navegable (#, javascript:)
+--
+-- Política de hosts (tomada de hermes url_safety.py, sin resolver DNS: el runtime no expone un resolver):
+--   * "blocked": endpoints de metadata de la nube (169.254.169.254 y familia, metadata.google.internal).
+--     Nunca son un destino legítimo: se deniegan SIEMPRE, incluso en yolo.
+--   * "private": loopback, redes privadas (10/8, 172.16/12, 192.168/16, CGNAT 100.64/10), link-local,
+--     localhost y sufijos internos. Legítimo para mirar el propio dev server → PIDE aprobación (yolo permite,
+--     strict deniega). Un host numérico ambiguo (entero, hex, octal) cae aquí también.
+--   * "public": el resto. Límite conocido: sin DNS no se detecta un nombre público que resuelve a una IP
+--     privada (DNS rebinding); hermes lo cubre con un resolver, aquí queda documentado.
+
+let SENSITIVE_PARAMS be ["access_token", "api_key", "apikey", "auth_token", "authorization", "awsaccesskeyid", "client_secret", "credential", "credentials", "jwt", "password", "passwd", "secret", "session_id", "signature", "token", "private_key", "x_amz_security_token", "x_amz_signature", "x-amz-security-token", "x-amz-signature"]
+let SECRET_RE be "(?i)(\\bsk-(ant-|proj-)?[a-z0-9_-]{24,}|\\bghp_[a-z0-9]{20,}|\\bgithub_pat_[a-z0-9_]{20,}|\\bgho_[a-z0-9]{20,}|\\bglpat-[a-z0-9_-]{16,}|\\bxox[abprs]-[a-z0-9-]{10,}|\\bakia[0-9a-z]{16}\\b|\\baiza[0-9a-z_-]{30,}|-----begin [a-z ]*private key|\\beyj[a-z0-9_-]{20,}\\.eyj[a-z0-9_-]{20,})"
+
+task fail(msg)
+    give {"ok": false, "error": msg}
+
+export task parse(raw)
+    when raw == nothing
+        give fail("missing URL")
+    let u be trim(text(raw))
+    -- "https:// host" — el modelo a veces mete un espacio tras el esquema (hermes normalize_url_for_request)
+    set u to replace_re(u, "^([A-Za-z][A-Za-z0-9+.-]*://)\\s+", "\\1")
+    when u == ""
+        give fail("missing URL")
+    when length(u) > 2048
+        give fail("URL longer than 2048 chars")
+    when contains(u, " ") or contains(u, "\n") or contains(u, "\t")
+        give fail("URL contains whitespace: " + u)
+    let sp be split(u, "://")
+    when length(sp) < 2
+        give fail("not an absolute http(s) URL: " + u)
+    let scheme be lower(sp[0])
+    when scheme != "http" and scheme != "https"
+        give fail("unsupported scheme '" + scheme + "' (only http and https)")
+    let rest be join(slice(sp, 1, length(sp)), "://")
+    -- fragmento y query
+    let frag_sp be split(rest, "#")
+    set rest to frag_sp[0]
+    let q_sp be split(rest, "?")
+    let query be when length(q_sp) > 1 then join(slice(q_sp, 1, length(q_sp)), "?") otherwise ""
+    set rest to q_sp[0]
+    -- autoridad y path
+    let slash_sp be split(rest, "/")
+    let authority be slash_sp[0]
+    let path be when length(slash_sp) > 1 then "/" + join(slice(slash_sp, 1, length(slash_sp)), "/") otherwise "/"
+    when contains(authority, "@")
+        give fail("credentials in the URL are not allowed")
+    when authority == ""
+        give fail("missing host: " + u)
+    let host be lower(authority)
+    let port be ""
+    when starts_with(host, "[")
+        -- IPv6 literal: [::1]:8080
+        let close be split(host, "]")
+        set host to slice(close[0], 1, length(close[0]))
+        when length(close) > 1 and starts_with(close[1], ":")
+            set port to slice(close[1], 1, length(close[1]))
+    otherwise
+        let hp be split(host, ":")
+        when length(hp) > 2
+            give fail("malformed host: " + authority)
+        set host to hp[0]
+        when length(hp) == 2
+            set port to hp[1]
+    when port != "" and not matches(port, "[0-9]{1,5}")
+        give fail("malformed port: " + port)
+    -- "example.com." (FQDN con punto final) ≡ "example.com"
+    while ends_with(host, ".")
+        set host to slice(host, 0, length(host) - 1)
+    when host == ""
+        give fail("missing host: " + u)
+    let origin be scheme + "://" + host + (when port != "" then ":" + port otherwise "")
+    let dir_parts be split(path, "/")
+    let dir be join(slice(dir_parts, 0, length(dir_parts) - 1), "/") + "/"
+    give {"ok": true, "url": origin + path + (when query != "" then "?" + query otherwise ""), "scheme": scheme, "host": host, "port": port, "path": path, "query": query, "origin": origin, "dir": dir}
+
+-- octetos de una IPv4 en notación decimal con puntos, o nothing
+task ipv4_octets(host)
+    when not matches(host, "[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}")
+        give nothing
+    let out be []
+    each p in split(host, ".")
+        let n be floor(number(p))
+        when n > 255
+            give nothing
+        set out to append(out, n)
+    give out
+
+task ipv4_class(o)
+    let a be o[0]
+    let b be o[1]
+    when a == 169 and b == 254
+        give "blocked"
+    when a == 100 and b == 100 and o[2] == 100 and o[3] == 200
+        give "blocked"
+    when a == 127 or a == 10 or a == 0
+        give "private"
+    when a == 192 and b == 168
+        give "private"
+    when a == 172 and b >= 16 and b <= 31
+        give "private"
+    when a == 100 and b >= 64 and b <= 127
+        give "private"
+    when a >= 224
+        give "private"
+    give "public"
+
+export task host_class(host)
+    let h be lower(text(host))
+    when h == "metadata.google.internal" or h == "metadata.goog" or h == "fd00:ec2::254"
+        give "blocked"
+    let o be ipv4_octets(h)
+    when o != nothing
+        give ipv4_class(o)
+    -- IPv6: loopback, unspecified, ULA fc00::/7, link-local fe80::/10, IPv4 mapeadas ::ffff:a.b.c.d
+    when contains(h, ":")
+        when h == "::1" or h == "::"
+            give "private"
+        when starts_with(h, "::ffff:")
+            let inner be ipv4_octets(slice(h, 7, length(h)))
+            give when inner != nothing then ipv4_class(inner) otherwise "private"
+        when starts_with(h, "fc") or starts_with(h, "fd") or starts_with(h, "fe8") or starts_with(h, "fe9") or starts_with(h, "fea") or starts_with(h, "feb")
+            give "private"
+        give "public"
+    when h == "localhost" or ends_with(h, ".localhost") or ends_with(h, ".internal") or ends_with(h, ".local") or ends_with(h, ".home.arpa") or ends_with(h, ".lan")
+        give "private"
+    -- formas numéricas ambiguas (2130706433, 0x7f000001, 0177.0.0.1): clásicos de bypass → tratar como privado
+    when matches(h, "[0-9]+") or matches(h, "0x[0-9a-f]+") or matches(h, "[0-9x.]+")
+        give "private"
+    give "public"
+
+-- %XX → carácter (para inspeccionar una URL con secretos codificados)
+task percent_decode(s)
+    let out be s
+    each m in find_all(s, "%[0-9A-Fa-f]{2}")
+        let ch be nothing
+        try
+            set ch to json_decode("\"\\u00" + slice(m, 1, 3) + "\"")
+        recover e
+            set ch to nothing
+        when ch != nothing
+            set out to replace_text(out, m, ch)
+    give out
+
+export task sensitive(raw)
+    when raw == nothing
+        give nothing
+    let u be text(raw)
+    let decoded be percent_decode(u)
+    when length(find_all(u, SECRET_RE)) > 0 or length(find_all(decoded, SECRET_RE)) > 0
+        give "an API key or token"
+    let p be parse(u)
+    when not p["ok"]
+        give nothing
+    when p["query"] == ""
+        give nothing
+    each pair in split(p["query"], "&")
+        let kv be split(pair, "=")
+        let k be lower(trim(percent_decode(kv[0])))
+        let v be when length(kv) > 1 then join(slice(kv, 1, length(kv)), "=") otherwise ""
+        when v != "" and contains(SENSITIVE_PARAMS, k)
+            give "a credential-like query parameter (" + kv[0] + ")"
+    give nothing
+
+-- "/a/b/../c/./d" → "/a/c/d"
+task normalize_path(path)
+    let out be []
+    each seg in split(path, "/")
+        when seg == ".."
+            when length(out) > 0
+                set out to slice(out, 0, length(out) - 1)
+        otherwise when seg != "." and seg != ""
+            set out to append(out, seg)
+    give "/" + join(out, "/") + (when ends_with(path, "/") and length(out) > 0 then "/" otherwise "")
+
+export task resolve(base, href)
+    when href == nothing
+        give nothing
+    let h be trim(text(href))
+    let lh be lower(h)
+    when h == "" or starts_with(h, "#") or starts_with(lh, "javascript:") or starts_with(lh, "data:") or starts_with(lh, "mailto:") or starts_with(lh, "tel:")
+        give nothing
+    when matches(h, "[A-Za-z][A-Za-z0-9+.-]*:.*")
+        give h
+    let b be parse(base)
+    when not b["ok"]
+        give h
+    when starts_with(h, "//")
+        give b["scheme"] + ":" + h
+    -- separar query/fragmento del path relativo para normalizar solo el path
+    let tail be ""
+    let core be h
+    let qi be split(h, "?")
+    let fi be split(h, "#")
+    when length(qi) > 1
+        set core to qi[0]
+        set tail to "?" + join(slice(qi, 1, length(qi)), "?")
+    otherwise when length(fi) > 1
+        set core to fi[0]
+        set tail to "#" + join(slice(fi, 1, length(fi)), "#")
+    when core == ""
+        give b["origin"] + b["path"] + tail
+    when starts_with(core, "/")
+        give b["origin"] + normalize_path(core) + tail
+    give b["origin"] + normalize_path(b["dir"] + core) + tail
+
+-- nombre de archivo estable para la caché/spill de una URL: fetch-<host>-<digest>
+export task slug(host)
+    let s be replace_re(lower(text(host)), "[^a-z0-9._-]", "-")
+    when length(s) > 60
+        set s to slice(s, 0, 60)
+    when s == ""
+        give "page"
+    give s

package/lib/tools.syn

@@ -19,6 +19,7 @@ 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/fetch.syn" as t_fetch
 use "./tools/skill.syn" as t_skill
 use "./tools/process.syn" as t_process
 use "./tools/memo.syn" as t_memo
@@ -256,6 +257,7 @@ export task registry()
         "find": t_find.tool,
         "grep": t_grep.tool,
         "bash": t_bash.tool,
+        "fetch": t_fetch.tool,
         "process": t_process.tool,
         "memory": t_memo.tool,
         "todo": t_todo.tool,
@@ -266,7 +268,7 @@ export task registry()
         "schedule": schedule_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, PLUGIN_SPEC, SCHEDULE_SPEC]
+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_fetch.SPEC, t_bash.SPEC, t_process.SPEC, t_memo.SPEC, t_todo.SPEC, t_skill.SPEC, MCP_SPEC, PLUGIN_SPEC, SCHEDULE_SPEC]
 
 -- Subconjuntos (para perfiles de agente): registry/catálogo filtrados por nombre.
 export task registry_subset(names)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lampson",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "A coding agent written in Synsema: terminal + web, tools confined to the mounted project, plugins (your own tools, any language), LSP, MCP, sub-agents.",
   "license": "MIT",
   "repository": {
@@ -9,7 +9,15 @@
   },
   "homepage": "https://github.com/kitecosmic/lampson#readme",
   "bugs": "https://github.com/kitecosmic/lampson/issues",
-  "keywords": ["agent", "coding-agent", "synsema", "llm", "cli", "lsp", "mcp"],
+  "keywords": [
+    "agent",
+    "coding-agent",
+    "synsema",
+    "llm",
+    "cli",
+    "lsp",
+    "mcp"
+  ],
   "bin": {
     "lampson": "bin/lampson.js"
   },

package/public/css/sidebar.css

@@ -82,3 +82,24 @@
 /* puertos ocupados por lampson: visibles pero sin link ni ✕ */
 .p .port.own { color:var(--ink-3); font-weight:400; }
 .p.own .cm { color:var(--ink-3); }
+
+/* explorador de archivos: selección, portapapeles, arrastre, renombrar en línea y menú contextual */
+#tree:focus { outline:none; }
+.row.sel { background:var(--paper-2); }
+.row.cut { opacity:.55; }
+.row.dragging { opacity:.4; }
+.row.drop, #tree.drop { background:var(--accent-bg); border-left-color:var(--accent); }
+.row.flash { background:var(--accent-bg); transition:background .7s; }
+.row input.rn { flex:1; min-width:0; font:inherit; color:var(--ink); background:var(--paper-2); border:1px solid var(--accent); border-radius:var(--r); padding:0 4px; outline:none; }
+.row.new { color:var(--ink); }
+.ctx { position:fixed; z-index:70; min-width:220px; background:var(--paper); border:1px solid var(--rule-2); border-radius:var(--r); box-shadow:0 10px 30px rgba(0,0,0,.35); padding:4px 0; font:400 12.5px/1.5 var(--mono); user-select:none; }
+.ctx .it { display:flex; align-items:center; gap:14px; padding:4px 12px; cursor:pointer; color:var(--ink-2); white-space:nowrap; }
+.ctx .it:hover { background:var(--paper-2); color:var(--ink); }
+.ctx .it .k { margin-left:auto; color:var(--ink-3); font-size:10.5px; }
+.ctx .it.dis { opacity:.4; pointer-events:none; }
+.ctx .it.danger:hover { color:var(--rubric); }
+.ctx .it.ask { color:var(--ink-2); gap:6px; }
+.ctx .it.ask .yes { color:var(--rubric); font-weight:600; cursor:pointer; }
+.ctx .it.ask .no { cursor:pointer; }
+.ctx .it.ask .yes:hover, .ctx .it.ask .no:hover { text-decoration:underline; text-underline-offset:.18em; }
+.ctx .sep { height:1px; background:var(--rule); margin:4px 0; }

package/public/js/core.js

@@ -22,7 +22,7 @@ function md(src) { // Markdown mínimo: code fences, inline code, bold, headers,
 }
 // un bloque en el chat: 'user' | 'assistant' | 'step' | 'meta' | 'denied' | 'approval' | 'working'
 function add(cls, html) { showPane('log'); log.classList.remove('hero'); const d = document.createElement('div'); d.className = 'msg ' + cls; d.innerHTML = html; log.appendChild(d); $('#stage').scrollTop = $('#stage').scrollHeight; return d; }
-function describe(c) { const a = c.args || {}; if (c.name === 'bash') return '$ ' + (a.command || ''); if (c.name === 'delegate') return 'delegate → ' + a.agent + ': ' + String(a.brief || '').slice(0, 80); if (a.path) return c.name + ' ' + a.path; if (a.pattern) return c.name + ' ' + a.pattern; if (a.name) return c.name + ' ' + a.name; return c.name + ' ' + JSON.stringify(a); }
+function describe(c) { const a = c.args || {}; if (c.name === 'bash') return '$ ' + (a.command || ''); if (c.name === 'fetch') return 'fetch ' + (a.url || '') + (a.format && a.format !== 'markdown' ? ' (' + a.format + ')' : ''); if (c.name === 'delegate') return 'delegate → ' + a.agent + ': ' + String(a.brief || '').slice(0, 80); if (a.path) return c.name + ' ' + a.path; if (a.pattern) return c.name + ' ' + a.pattern; if (a.name) return c.name + ' ' + a.name; return c.name + ' ' + JSON.stringify(a); }
 function cmdHtml(text) { const t = String(text); const long = t.length > 220 || t.split('\n').length > 4; return `<span class="cmd">${esc(t)}</span>` + (long ? ' <span class="more">ver todo</span>' : ''); }
 function wireMore(el) { const m = el.querySelector('.more'); if (m) m.onclick = () => { el.querySelector('.cmd').classList.toggle('open'); m.textContent = el.querySelector('.cmd').classList.contains('open') ? 'menos' : 'ver todo'; }; }
 // POST JSON → {ok, status, data}

package/public/js/tree.js

@@ -1,5 +1,17 @@
-// tree.js — árbol de archivos (panel derecho) con estado git, y el visor de archivos
+// tree.js — árbol de archivos (panel derecho) con estado git, el visor de archivos y el explorador:
+// clic derecho = menú contextual (nuevo archivo/carpeta, abrir, renombrar, duplicar, copiar/cortar/pegar,
+// copiar ruta relativa/absoluta, insertar la ruta en el chat, eliminar), arrastrar y soltar para mover
+// (Ctrl al soltar = copiar; sobre un archivo = a su carpeta), F2 / Supr / Ctrl+C·X·V sobre la fila
+// seleccionada. Las operaciones van a POST /api/fs (lib/fs.syn) y nunca pisan un destino existente.
+// Las carpetas abiertas se recuerdan (localStorage lampson.tree.open) para que un cambio no las cierre.
 let gitStatus = { changes: {} };
+let treeRoot = '';        // ruta absoluta del workspace (para «copiar ruta absoluta»)
+let treeSel = null;       // {path, is_dir, row}: última fila clickeada (izquierdo o derecho)
+let treeClip = null;      // {path, is_dir, op: 'copy'|'cut'}
+let treeDrag = null;      // {path, is_dir} mientras se arrastra
+const openDirs = new Set((() => { try { return JSON.parse(localStorage.getItem('lampson.tree.open') || '[]'); } catch (e) { return []; } })());
+function saveOpen() { try { localStorage.setItem('lampson.tree.open', JSON.stringify([...openDirs])); } catch (e) {} }
+
 async function loadGit() {
   try { gitStatus = await (await fetch(BASE + '/api/git')).json(); } catch (e) { gitStatus = { repo: false, changes: {} }; }
   const g = $('#git'); if (!gitStatus.repo) { g.style.display = 'none'; return; }
@@ -17,28 +29,218 @@ function gitClass(path, isDir) {
   if (!isDir) { const c = ch[path]; return c === '??' ? 'gU' : c === 'A' ? 'gA' : c === 'D' ? 'gD' : c ? 'gM' : ''; }
   const p = path + '/'; for (const k in ch) if (k.startsWith(p)) return 'gM'; return '';
 }
+function parentOf(p) { const i = p.lastIndexOf('/'); return i < 0 ? '.' : p.slice(0, i); }
+function baseOf(p) { return p.slice(p.lastIndexOf('/') + 1); }
+function cssEsc(s) { return (window.CSS && CSS.escape) ? CSS.escape(s) : String(s).replace(/["\\]/g, '\\$&'); }
+function rowOf(path) { return $('#tree').querySelector(`.row[data-path="${cssEsc(path)}"]`); }
+
 async function loadTree() {
   await loadGit();
-  const box = $('#tree'); box.innerHTML = '';
+  const box = $('#tree'); box.innerHTML = ''; box.tabIndex = 0;
   let t; try { t = await (await fetch(BASE + '/api/tree')).json(); } catch (e) { box.innerHTML = '<div class="row none">sin árbol</div>'; return; }
-  const render = (entries, parent, depth) => {
+  treeRoot = t.root || '';
+  const render = (entries, parent) => {
     for (const e of entries) {
       const n = document.createElement('div'); n.className = 'node';
       const gc = gitClass(e.path, e.is_dir); const code = (gitStatus.changes || {})[e.path];
-      const r = document.createElement('div'); r.className = 'row' + (e.is_dir ? ' dir' : '') + (gc ? ' ' + gc : ''); r.title = e.path + (code ? ' · git ' + code : '');
-      r.innerHTML = `<span class="tw">${e.is_dir ? '▸' : ''}</span><span>${esc(e.name)}${e.is_dir ? '/' : ''}</span>` + (code && !e.is_dir ? `<span class="gs">${code === '??' ? 'N' : code}</span>` : '');
+      const cut = treeClip && treeClip.op === 'cut' && treeClip.path === e.path;
+      const r = document.createElement('div'); r.className = 'row' + (e.is_dir ? ' dir' : '') + (gc ? ' ' + gc : '') + (cut ? ' cut' : '');
+      r.title = e.path + (code ? ' · git ' + code : ''); r.dataset.path = e.path; r.dataset.dir = e.is_dir ? '1' : '';
+      r.innerHTML = `<span class="tw">${e.is_dir ? '▸' : ''}</span><span class="nm">${esc(e.name)}${e.is_dir ? '/' : ''}</span>` + (code && !e.is_dir ? `<span class="gs">${code === '??' ? 'N' : code}</span>` : '');
       n.appendChild(r);
+      wireRow(r, e);
       if (e.is_dir) {
-        const k = document.createElement('div'); k.className = 'kids hidden'; render(e.children || [], k, depth + 1); n.appendChild(k);
-        r.querySelector('.tw').textContent = '▸';
-        r.onclick = () => { k.classList.toggle('hidden'); r.querySelector('.tw').textContent = k.classList.contains('hidden') ? '▸' : '▾'; };
-      } else { r.onclick = () => openFile(e.path, r); }
+        const open = openDirs.has(e.path);
+        const k = document.createElement('div'); k.className = 'kids' + (open ? '' : ' hidden'); render(e.children || [], k); n.appendChild(k);
+        r.querySelector('.tw').textContent = open ? '▾' : '▸';
+        r.onclick = () => { select(r, e); toggleDir(r, k, e.path); };
+      } else { r.onclick = () => { select(r, e); openFile(e.path, r); }; }
       parent.appendChild(n);
     }
   };
-  render(t.entries || [], box, 0);
+  render(t.entries || [], box);
   if (t.truncated) { const d = document.createElement('div'); d.className = 'row none'; d.textContent = '… árbol truncado'; box.appendChild(d); }
+  if (treeSel) { const r = rowOf(treeSel.path); if (r) { treeSel.row = r; r.classList.add('sel'); } else treeSel = null; }
+  const vp = $('#vpath').textContent; const ar = vp && rowOf(vp); if (ar && $('#viewer').style.display !== 'none') ar.classList.add('active');
 }
+function toggleDir(r, k, path) {
+  k.classList.toggle('hidden'); const open = !k.classList.contains('hidden');
+  r.querySelector('.tw').textContent = open ? '▾' : '▸';
+  if (open) openDirs.add(path); else openDirs.delete(path); saveOpen();
+}
+function expandDir(path) { if (!path || path === '.') return; openDirs.add(path); saveOpen(); }
+function select(r, e) {
+  document.querySelectorAll('#tree .row.sel').forEach(x => x.classList.remove('sel'));
+  r.classList.add('sel'); treeSel = { path: e.path, is_dir: e.is_dir, row: r };
+}
+
+// ---- arrastrar y soltar: mover (Ctrl = copiar); sobre un archivo = a la carpeta del archivo ----
+function canDrop(d, dir) {
+  if (!d) return false;
+  if (parentOf(d.path) === dir) return false;                                   // ya está ahí
+  if (d.is_dir && (dir === d.path || dir.startsWith(d.path + '/'))) return false; // carpeta dentro de sí misma
+  return true;
+}
+function wireRow(r, e) {
+  r.oncontextmenu = ev => { ev.preventDefault(); ev.stopPropagation(); select(r, e); showMenu(ev.clientX, ev.clientY, { path: e.path, is_dir: e.is_dir, row: r }); };
+  r.draggable = true;
+  r.ondragstart = ev => { treeDrag = { path: e.path, is_dir: e.is_dir }; ev.dataTransfer.effectAllowed = 'copyMove'; ev.dataTransfer.setData('text/plain', e.path); r.classList.add('dragging'); };
+  r.ondragend = () => { treeDrag = null; r.classList.remove('dragging'); document.querySelectorAll('#tree .drop').forEach(x => x.classList.remove('drop')); };
+  // soltar sobre una carpeta = dentro de ella; sobre un archivo = en la carpeta del archivo (se ilumina esa)
+  const dir = e.is_dir ? e.path : parentOf(e.path);
+  const lit = () => (e.is_dir ? r : (rowOf(dir) || $('#tree')));
+  r.ondragover = ev => { if (!canDrop(treeDrag, dir)) return; ev.preventDefault(); ev.stopPropagation(); ev.dataTransfer.dropEffect = ev.ctrlKey ? 'copy' : 'move'; lit().classList.add('drop'); };
+  r.ondragleave = () => lit().classList.remove('drop');
+  r.ondrop = ev => { ev.preventDefault(); ev.stopPropagation(); document.querySelectorAll('#tree .drop, #tree.drop').forEach(x => x.classList.remove('drop')); dropInto(dir, ev.ctrlKey); };
+}
+async function dropInto(dir, copy) {
+  const d = treeDrag; treeDrag = null;
+  if (!canDrop(d, dir)) return;
+  await fsOp(copy ? { op: 'copy', path: d.path, to: dir } : { op: 'move', path: d.path, to: dir }, res => { expandDir(dir); if (!copy) afterMove(d.path, res.path); });
+}
+{
+  const box = $('#tree');
+  box.ondragover = ev => { if (!canDrop(treeDrag, '.')) return; ev.preventDefault(); ev.dataTransfer.dropEffect = ev.ctrlKey ? 'copy' : 'move'; box.classList.add('drop'); };
+  box.ondragleave = () => box.classList.remove('drop');
+  box.ondrop = ev => { ev.preventDefault(); box.classList.remove('drop'); dropInto('.', ev.ctrlKey); };
+  box.oncontextmenu = ev => { if (ev.target.closest('.row')) return; ev.preventDefault(); showMenu(ev.clientX, ev.clientY, null); };
+  box.onkeydown = ev => {
+    if (ev.target.tagName === 'INPUT' || !treeSel) return;
+    const s = treeSel; const key = ev.key.toLowerCase();
+    if (ev.key === 'F2') { ev.preventDefault(); renameInline(s); }
+    else if (ev.key === 'Delete') { ev.preventDefault(); const b = s.row.getBoundingClientRect(); showMenu(b.left + 60, b.bottom, s, 'delete'); }
+    else if (ev.ctrlKey && key === 'c') { ev.preventDefault(); setClip(s, 'copy'); }
+    else if (ev.ctrlKey && key === 'x') { ev.preventDefault(); setClip(s, 'cut'); }
+    else if (ev.ctrlKey && key === 'v') { ev.preventDefault(); pasteInto(s.is_dir ? s.path : parentOf(s.path)); }
+    else if (ev.key === 'Escape') { closeMenu(); }
+  };
+}
+
+// ---- operaciones (POST /api/fs) ----
+async function fsOp(body, onOk) {
+  const r = await api(BASE + '/api/fs', body);
+  if (!r.ok) { add('denied', esc((r.data && r.data.error) || 'error')); loadTree(); return null; }
+  const res = r.data.result || {};
+  if (onOk) onOk(res);
+  await loadTree();
+  return res;
+}
+function afterMove(oldPath, newPath) {
+  if (treeClip && treeClip.path === oldPath) treeClip = null;
+  if (treeSel && treeSel.path === oldPath) treeSel.path = newPath;
+  const vp = $('#vpath'); const v = vp.textContent;
+  if (v === oldPath || v.startsWith(oldPath + '/')) vp.textContent = newPath + v.slice(oldPath.length);
+}
+function afterDelete(path) {
+  if (treeClip && treeClip.path === path) treeClip = null;
+  if (treeSel && (treeSel.path === path || treeSel.path.startsWith(path + '/'))) treeSel = null;
+  const v = $('#vpath').textContent; if (v === path || v.startsWith(path + '/')) { $('#vpath').textContent = ''; showPane('log'); }
+}
+function setClip(s, op) { treeClip = { path: s.path, is_dir: s.is_dir, op }; loadTree(); }
+function canPaste(dir) {
+  if (!treeClip) return false;
+  if (treeClip.op === 'cut') return canDrop(treeClip, dir);
+  return !(treeClip.is_dir && (dir === treeClip.path || dir.startsWith(treeClip.path + '/')));
+}
+async function pasteInto(dir) {
+  if (!canPaste(dir)) return;
+  const c = treeClip;
+  await fsOp(c.op === 'cut' ? { op: 'move', path: c.path, to: dir } : { op: 'copy', path: c.path, to: dir }, res => { expandDir(dir); if (c.op === 'cut') { afterMove(c.path, res.path); treeClip = null; } });
+}
+function absPath(path) {
+  if (!treeRoot) return path;
+  const sep = treeRoot.includes('\\') ? '\\' : '/';
+  const root = treeRoot.replace(/[\\/]+$/, '');
+  return path === '.' ? root : root + sep + path.split('/').join(sep);
+}
+function copyText(t, row) {
+  const done = () => { if (row) { row.classList.add('flash'); setTimeout(() => row.classList.remove('flash'), 700); } };
+  if (navigator.clipboard && navigator.clipboard.writeText) navigator.clipboard.writeText(t).then(done, () => copyFallback(t, done)); else copyFallback(t, done);
+}
+function copyFallback(t, done) { const ta = document.createElement('textarea'); ta.value = t; ta.style.position = 'fixed'; ta.style.opacity = '0'; document.body.appendChild(ta); ta.select(); try { document.execCommand('copy'); } catch (e) {} ta.remove(); done(); }
+function insertInChat(path) {
+  const ta = $('#in'); const v = ta.value;
+  ta.value = v + (v && !/\s$/.test(v) ? ' ' : '') + path + ' ';
+  ta.focus(); ta.dispatchEvent(new Event('input', { bubbles: true }));
+}
+
+// ---- nuevo archivo / carpeta y renombrar: un input en la propia fila ----
+function nameInput(r, value, onDone) {
+  const nm = r.querySelector('.nm'); const inp = document.createElement('input'); inp.className = 'rn'; inp.value = value; inp.spellcheck = false;
+  nm.replaceWith(inp); inp.focus();
+  const dot = value.startsWith('.') ? -1 : value.lastIndexOf('.'); inp.setSelectionRange(0, dot > 0 ? dot : value.length);
+  let finished = false;
+  const finish = ok => { if (finished) return; finished = true; onDone(ok ? inp.value.trim() : null); };
+  inp.onkeydown = ev => { ev.stopPropagation(); if (ev.key === 'Enter') { ev.preventDefault(); finish(true); } else if (ev.key === 'Escape') { ev.preventDefault(); finish(false); } };
+  inp.onblur = () => finish(false);
+  inp.onclick = ev => ev.stopPropagation(); inp.oncontextmenu = ev => ev.stopPropagation();
+}
+function newEntry(dir, isDir) {
+  closeMenu();
+  const box = $('#tree');
+  let holder = box;
+  if (dir !== '.') {
+    const r = rowOf(dir); if (!r) return;
+    const k = r.parentNode.querySelector('.kids'); if (k.classList.contains('hidden')) toggleDir(r, k, dir);
+    holder = k;
+  }
+  const n = document.createElement('div'); n.className = 'node';
+  const r = document.createElement('div'); r.className = 'row new' + (isDir ? ' dir' : ''); r.innerHTML = `<span class="tw">${isDir ? '▸' : ''}</span><span class="nm"></span>`;
+  n.appendChild(r); holder.insertBefore(n, holder.firstChild);
+  nameInput(r, '', name => {
+    n.remove();
+    if (!name) return;
+    fsOp({ op: isDir ? 'mkdir' : 'create', path: dir, name }, res => { expandDir(dir); treeSel = { path: res.path, is_dir: !!res.is_dir }; if (!isDir) openFile(res.path); });
+  });
+}
+function renameInline(s) {
+  closeMenu();
+  const r = s.row || rowOf(s.path); if (!r) return;
+  const old = baseOf(s.path);
+  nameInput(r, old, name => {
+    if (!name || name === old) { loadTree(); return; }
+    fsOp({ op: 'rename', path: s.path, name }, res => afterMove(s.path, res.path));
+  });
+}
+
+// ---- menú contextual ----
+let ctxEl = null;
+function closeMenu() { if (ctxEl) { ctxEl.remove(); ctxEl = null; } }
+document.addEventListener('mousedown', ev => { if (ctxEl && !ctxEl.contains(ev.target)) closeMenu(); }, true);
+document.addEventListener('keydown', ev => { if (ev.key === 'Escape') closeMenu(); });
+window.addEventListener('blur', closeMenu); window.addEventListener('resize', closeMenu);
+$('#tree').addEventListener('scroll', closeMenu);
+// e = {path, is_dir, row} o null (raíz); only = 'delete' abre solo la confirmación de borrado (tecla Supr)
+function showMenu(x, y, e, only) {
+  closeMenu();
+  const isRoot = !e; const path = isRoot ? '.' : e.path; const isDir = isRoot || e.is_dir; const row = e && e.row;
+  const dir = isDir ? path : parentOf(path);      // carpeta donde se crea o se pega
+  const items = [];
+  const del = { l: 'Eliminar', k: 'Supr', danger: true, confirm: '¿eliminar ' + baseOf(path) + (isDir ? '/' : '') + '?', f: () => fsOp({ op: 'delete', path }, () => afterDelete(path)) };
+  if (only === 'delete') items.push(del);
+  else {
+    if (!isDir) items.push({ l: 'Abrir', f: () => openFile(path, row) });
+    items.push({ l: 'Nuevo archivo…', f: () => newEntry(dir, false) }, { l: 'Nueva carpeta…', f: () => newEntry(dir, true) }, 'sep');
+    if (!isRoot) items.push({ l: 'Renombrar', k: 'F2', f: () => renameInline(e) }, { l: 'Duplicar', f: () => fsOp({ op: 'copy', path }) }, 'sep', { l: 'Copiar', k: 'Ctrl+C', f: () => setClip(e, 'copy') }, { l: 'Cortar', k: 'Ctrl+X', f: () => setClip(e, 'cut') });
+    items.push({ l: 'Pegar' + (treeClip ? ' «' + baseOf(treeClip.path) + '»' : ''), k: 'Ctrl+V', dis: !canPaste(dir), f: () => pasteInto(dir) }, 'sep');
+    items.push({ l: 'Copiar ruta', f: () => copyText(path, row) }, { l: 'Copiar ruta absoluta', dis: !treeRoot, f: () => copyText(absPath(path), row) }, { l: 'Insertar en el chat', f: () => insertInChat(path) });
+    if (!isRoot) items.push('sep', del);
+    items.push('sep', { l: 'Recargar', f: loadTree });
+  }
+  const m = document.createElement('div'); m.className = 'ctx';
+  for (const it of items) {
+    if (it === 'sep') { const s = document.createElement('div'); s.className = 'sep'; m.appendChild(s); continue; }
+    const d = document.createElement('div'); d.className = 'it' + (it.dis ? ' dis' : '') + (it.danger ? ' danger' : '');
+    d.innerHTML = `<span>${esc(it.l)}</span>` + (it.k ? `<span class="k">${esc(it.k)}</span>` : '');
+    d.onclick = ev => { ev.stopPropagation(); if (it.confirm) inlineConfirm(d, it.confirm, () => { closeMenu(); it.f(); }); else { closeMenu(); it.f(); } };
+    m.appendChild(d);
+  }
+  document.body.appendChild(m); ctxEl = m;
+  const W = window.innerWidth, H = window.innerHeight, mw = m.offsetWidth, mh = m.offsetHeight;
+  m.style.left = Math.max(4, Math.min(x, W - mw - 4)) + 'px'; m.style.top = Math.max(4, Math.min(y, H - mh - 4)) + 'px';
+  if (only === 'delete') { const first = m.querySelector('.it'); if (first) first.click(); }
+}
+
 async function openFile(path, row) {
   document.querySelectorAll('.row.active').forEach(x => x.classList.remove('active')); if (row) row.classList.add('active');
   const r = await fetch(BASE + '/api/file?path=' + encodeURIComponent(path)); const d = await r.json();

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

package/web.syn

@@ -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
@@ -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 —
@@ -440,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()}