npm - lampson - Versions diffs - 0.1.2 → 0.1.4 - Mend

lampson 0.1.2 → 0.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (49) hide show

package/public/js/terminal.js ADDED Viewed

@@ -0,0 +1,49 @@
+// terminal.js — terminal real: xterm.js ↔ WebSocket /api/term ↔ pty en el servidor
+// Frames binarios = bytes del pty; texto JSON = control (hello / exit). Cerrar el panel cierra el socket y mata el shell.
+let term = null, termWs = null, termFit = null;
+function termTheme() {
+  const s = getComputedStyle(document.documentElement); const v = n => s.getPropertyValue(n).trim();
+  return { background: v('--paper'), foreground: v('--ink'), cursor: v('--accent'), cursorAccent: v('--paper'), selectionBackground: v('--sel'),
+    black: v('--paper-3'), brightBlack: v('--ink-3'), red: v('--rubric'), brightRed: v('--rubric'), green: v('--str'), brightGreen: v('--str'),
+    yellow: v('--amber'), brightYellow: v('--amber'), blue: v('--term-blue'), brightBlue: v('--accent'), magenta: v('--rubric'), brightMagenta: v('--rubric'),
+    cyan: v('--accent'), brightCyan: v('--accent'), white: v('--ink-2'), brightWhite: v('--ink') };
+}
+function openTerm() {
+  if (term) { showPane('term'); termFit.fit(); term.focus(); return; }
+  showPane('term'); procOpen = null; clearInterval(procTimer);
+  term = new Terminal({ cursorBlink: true, fontFamily: getComputedStyle(document.documentElement).getPropertyValue('--mono'), fontSize: 13, lineHeight: 1.25, theme: termTheme(), scrollback: 5000, allowProposedApi: true });
+  termFit = new FitAddon.FitAddon(); term.loadAddon(termFit); term.open($('#xterm')); termFit.fit();
+  // URLs clickeables (npm run dev imprime http://localhost:3000): link provider mínimo con la API nativa
+  // de xterm v5 — el addon web-links no está vendorizado y no hace falta para http/https
+  const TERM_URL_RE = /https?:\/\/[^\s"'`<>()\[\]{}]*[^\s"'`<>()\[\]{}.,;:!?]/g;
+  term.registerLinkProvider({
+    provideLinks(y, cb) {
+      const line = term.buffer.active.getLine(y - 1);
+      if (!line) return cb(undefined);
+      const text = line.translateToString(true);
+      const links = []; let m; TERM_URL_RE.lastIndex = 0;
+      while ((m = TERM_URL_RE.exec(text))) {
+        links.push({ range: { start: { x: m.index + 1, y }, end: { x: m.index + m[0].length, y } }, text: m[0], activate: (_e, uri) => window.open(uri, '_blank') });
+      }
+      cb(links.length ? links : undefined);
+    }
+  });
+  $('#tmeta').textContent = 'conectando…';
+  termWs = new WebSocket((location.protocol === 'https:' ? 'wss://' : 'ws://') + location.host + '/api/term'); termWs.binaryType = 'arraybuffer';
+  const send = (o) => { if (termWs && termWs.readyState === 1) termWs.send(JSON.stringify(o)); };
+  termWs.onopen = () => { $('#termpane').classList.add('live'); send({ type: 'resize', cols: term.cols, rows: term.rows }); term.focus(); };
+  termWs.onmessage = (e) => { // "o" + salida del pty | "c" + JSON de control
+    const s = String(e.data);
+    if (s[0] === 'o') { term.write(s.slice(1)); return; }
+    let m; try { m = JSON.parse(s.slice(1)); } catch { return; }
+    if (m.type === 'hello') $('#tmeta').textContent = `${m.shell} · pid ${m.pid} · ${m.cwd || 'workspace'}`;
+    if (m.type === 'exit') { term.write(`\r\n\x1b[2m[shell terminado · código ${m.code}]\x1b[0m\r\n`); $('#termpane').classList.remove('live'); }
+  };
+  termWs.onclose = () => { $('#termpane').classList.remove('live'); if ($('#tmeta').textContent === 'conectando…') $('#tmeta').textContent = 'sin conexión'; };
+  term.onData(d => send({ type: 'in', data: d }));
+  term.onResize(({ cols, rows }) => send({ type: 'resize', cols, rows }));
+  new ResizeObserver(() => { if ($('#termpane').style.display !== 'none') termFit.fit(); }).observe($('#xterm'));
+}
+function closeTerm() { if (termWs) { try { termWs.close(); } catch (e) {} } if (term) term.dispose(); term = null; termWs = null; termFit = null; $('#xterm').innerHTML = ''; $('#termpane').classList.remove('live'); showPane('log'); }
+$('#term').onclick = openTerm;
+$('#tclose').onclick = closeTerm;

package/public/js/theme.js ADDED Viewed

@@ -0,0 +1,6 @@
+// theme.js — tema día / noche (el valor inicial ya lo puso el script del <head>)
+const SUN = '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><circle cx="12" cy="12" r="4"/><path d="M12 2.7v2.1M12 19.2v2.1M2.7 12h2.1M19.2 12h2.1M5.3 5.3l1.5 1.5M17.2 17.2l1.5 1.5M18.7 5.3l-1.5 1.5M6.8 17.2l-1.5 1.5"/></svg>';
+const MOON = '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><path d="M20.2 14.6A8.6 8.6 0 0 1 9.4 3.8a8.6 8.6 0 1 0 10.8 10.8z"/></svg>';
+function paintTheme() { const light = document.documentElement.getAttribute('data-theme') === 'light'; $('#theme').innerHTML = light ? MOON : SUN; $('#theme').title = light ? 'Cambiar a tema oscuro' : 'Cambiar a tema claro'; }
+$('#theme').onclick = () => { const r = document.documentElement; r.setAttribute('data-theme', r.getAttribute('data-theme') === 'light' ? 'dark' : 'light'); try { localStorage.setItem('lampson.theme', r.getAttribute('data-theme')); } catch (e) {} paintTheme(); if (typeof term !== 'undefined' && term) term.options.theme = termTheme(); };
+paintTheme();

package/public/js/todo.js ADDED Viewed

@@ -0,0 +1,10 @@
+// todo.js — lista de tareas del agente en la sesión actual (tool todo)
+async function loadTodo() {
+  let r; try { r = await (await fetch('/api/todo' + (session ? '?session=' + encodeURIComponent(session) : ''))).json(); } catch (e) { return; }
+  const box = $('#todoBox'); box.innerHTML = '';
+  const items = r.items || []; const open = items.filter(i => i.status === 'pending' || i.status === 'in_progress').length;
+  $('#todoCount').textContent = items.length ? (open ? `${open} · ${items.length}` : `${items.length}`) : ''; autoSec('todo', open > 0);
+  if (!items.length) { box.innerHTML = '<div class="p none">ninguna</div>'; return; }
+  const mark = { completed: '☑', in_progress: '▶', cancelled: '✕', pending: '☐' };
+  for (const it of items) { const d = document.createElement('div'); d.className = 'p' + (it.status === 'in_progress' ? ' run' : ''); d.style.cursor = 'default'; d.innerHTML = `<span class="nm" style="opacity:${it.status === 'completed' || it.status === 'cancelled' ? .5 : 1}">${mark[it.status] || '☐'} ${esc(it.content)}</span>`; box.appendChild(d); }
+}

package/public/js/tree.js ADDED Viewed

@@ -0,0 +1,53 @@
+// tree.js — árbol de archivos (panel derecho) con estado git, y el visor de archivos
+let gitStatus = { changes: {} };
+async function loadGit() {
+  try { gitStatus = await (await fetch('/api/git')).json(); } catch (e) { gitStatus = { repo: false, changes: {} }; }
+  const g = $('#git'); if (!gitStatus.repo) { g.style.display = 'none'; return; }
+  const k = gitStatus.counts || {}; const nuevos = (k.added||0)+(k.untracked||0);
+  const parts = []; // solo contadores distintos de cero — lo demás es ruido
+  if (k.modified) parts.push(`<b class="w">~${k.modified}</b>`);
+  if (nuevos) parts.push(`<b class="g">+${nuevos}</b>`);
+  if (k.deleted) parts.push(`<b class="r">−${k.deleted}</b>`);
+  g.innerHTML = `⎇ <span class="br">${esc(gitStatus.branch)}</span>` + (parts.length ? parts.join('') : '<b class="c">✓</b>');
+  g.title = parts.length ? `${k.modified||0} modificados · ${nuevos} nuevos · ${k.deleted||0} borrados` : 'working tree limpio';
+  g.style.display = 'flex';
+}
+function gitClass(path, isDir) {
+  const ch = gitStatus.changes || {};
+  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 '';
+}
+async function loadTree() {
+  await loadGit();
+  const box = $('#tree'); box.innerHTML = '';
+  let t; try { t = await (await fetch('/api/tree')).json(); } catch (e) { box.innerHTML = '<div class="row none">sin árbol</div>'; return; }
+  const render = (entries, parent, depth) => {
+    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>` : '');
+      n.appendChild(r);
+      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); }
+      parent.appendChild(n);
+    }
+  };
+  render(t.entries || [], box, 0);
+  if (t.truncated) { const d = document.createElement('div'); d.className = 'row none'; d.textContent = '… árbol truncado'; box.appendChild(d); }
+}
+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('/api/file?path=' + encodeURIComponent(path)); const d = await r.json();
+  if (!r.ok) { add('denied', esc(d.error || 'error')); return; }
+  $('#vpath').textContent = d.path; $('#vmeta').textContent = d.lines + ' líneas';
+  $('#vbody').className = ''; $('#vbody').innerHTML = String(d.content).split('\n').map((l, i) => `<span class="ln">${i + 1}</span>${esc(l)}`).join('\n');
+  showPane('viewer'); $('#stage').scrollTop = 0;
+}
+// el árbol se refresca solo cuando una tool pudo crear/borrar archivos, con un pequeño debounce; ↻ lo fuerza a mano
+function treeChanged() { debounce('tree', loadTree, 400); }
+$('#tree-reload').onclick = e => { e.stopPropagation(); const b = e.currentTarget; b.classList.remove('spin'); void b.offsetWidth; b.classList.add('spin'); loadTree(); };
+$('#vclose').onclick = () => { showPane('log'); procOpen = null; clearInterval(procTimer); $('#vbody').className = ''; document.querySelectorAll('.row.active, .m.active, .p.active').forEach(x => x.classList.remove('active')); memOpen = null; };

package/public/js/update.js ADDED Viewed

@@ -0,0 +1,14 @@
+// update.js — actualizaciones de Lampson (una vez por carga; el fetch a origin puede tardar)
+async function checkUpdate() {
+  let u; try { u = await (await fetch('/api/update')).json(); } catch (e) { return; }
+  const b = $('#update'); if (!u.available) { b.style.display = 'none'; return; }
+  b.textContent = `⬆ actualizar · ${u.behind} commit${u.behind === 1 ? '' : 's'}`;
+  b.title = `${u.current} → ${u.latest}\n${(u.notes || []).map(n => '· ' + n).join('\n')}\n\nen terminal: ${u.command}`;
+  b.style.display = '';
+  b.onclick = async () => {
+    b.disabled = true; b.textContent = 'actualizando…';
+    let r; try { r = await (await fetch('/api/update', { method: 'POST' })).json(); } catch (e) { r = { result: 'no se pudo actualizar: ' + e.message }; }
+    add('meta', '⬆ ' + esc(r.result || ''));
+    b.disabled = false; b.textContent = '⬆ reiniciá el servidor'; b.onclick = null;
+  };
+}

package/skills/lampson/SKILL.md CHANGED Viewed

@@ -40,6 +40,22 @@ description: How this harness works — tools, workspace mount, permissions, age
   brief — a child does not see this conversation, cannot ask the user and cannot delegate. Reports are
   self-reports: verify before claiming success. Live logs: `.lampson/agents/<id>.log`.
+## 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
+  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),
+  `ask` (default: the user gets an approval request in the web UI and, if configured, a link on their
+  phone; denied if unanswered within `approval_timeout`), `yolo`. Prefer `strict` or `review`/`plan` profiles
+  for reports; `ask`/`build` only when the task must change things.
+- `add` ALWAYS asks the user (it authorizes future runs). `notify` = a webhook URL that receives the result
+  as JSON — the way to "search X and send it to me" without an MCP.
+- Tasks are executed by Lampson's resident process. If `schedule(action=list)` says no scheduler is running,
+  tell the user: `lampson --daemon start` (or keep `lampson --web` open). A `prompt` run's report lands in a NEW session named
+  `⏰ <name>` (never in the current chat — say so); `action=log` shows the runs.
 ## When you need the USER to run something
 The user can run any command themselves from the chat by prefixing it with `!` — e.g. `!npm run dev`,
 `!cat .env`, `!git push`. Their command runs without the permission policy and its output is added to

package/web.syn CHANGED Viewed

@@ -23,6 +23,7 @@ require serve(8080)
 require net
 require time
 require exec
+require random
 require env("LAMPSON_*")
 require env("OS")
 require secret("LAMPSON_*")
@@ -54,6 +55,10 @@ use "./lib/mcp.syn" as mcp
 use "./lib/lamps.syn" as lamps
 use "./lib/lsp.syn" as lsp
 use "./lib/tools/todo.syn" as todo
+use "./lib/schedule.syn" as schedule
+use "./lib/sched_run.syn" as sched_run
+use "./lib/approvals.syn" as approvals
+use "./lib/permission.syn" as permission
 let APPROVAL_TIMEOUT be 180
@@ -106,6 +111,15 @@ task boot(profile, mode, ask_fn, pname, model)
 task lampson_subagent(spec_json)
     give agents.run_child_json(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
+-- sale por lib/approvals.syn (panel «Aprobaciones» de la UI, webhook firmado, link de un solo uso).
+task sched_tick()
+    give sched_run.tick()
+cron_every(schedule.TICK_SECONDS, sched_tick)
 -- servers MCP: supervisores (agentes) lanzados al arrancar; los handlers leen su estado del blackboard
 mcp.start_all(8)
@@ -122,6 +136,12 @@ serve on 8080
     route "GET /api/sessions" requires auth
         give {"sessions": session.list()}
+    -- buscador de sesiones (modal «ver todas»): ?q=texto busca en títulos y mensajes de este proyecto
+    route "GET /api/sessions/search" requires auth
+        let q be when contains(query, "q") then text(query.q) otherwise ""
+        let n be when contains(query, "limit") then floor(number(query.limit)) otherwise 200
+        give {"q": q, "sessions": session.search(q, n)}
     route "GET /api/sessions/:id" requires auth
         when not session.exists(params.id)
             give not_found("session not found")
@@ -311,7 +331,7 @@ serve on 8080
     -- tiene su cola acotada (drop_oldest). Heartbeat cada 25 s para que el proxy/navegador no cierre.
     route "GET /api/events" requires auth
         stream
-            let sub be bus_subscribe(["proc.*", "subagent.*", "mcp.*"], {"max_queue": 512})
+            let sub be bus_subscribe(["proc.*", "subagent.*", "mcp.*", "approval.*", "schedule.*"], {"max_queue": 512})
             let open be true
             while open
                 let ev be bus_recv(sub, 25)
@@ -375,11 +395,88 @@ serve on 8080
             give fail(400, "path required")
         give tree.file_content(query.path)
+    -- configuración general (rueda de la UI): zona horaria, URL pública, webhook… → .lampson/config.json
+    route "GET /api/settings/values" requires auth
+        give {"values": settings.values(), "tz_detected": schedule.tz_offset()}
+    route "POST /api/settings/values" requires auth
+        let b be json of request
+        try
+            each k in keys(b)
+                settings.set_value(k, b[k])
+            -- la zona horaria cacheada en el blackboard se recalcula
+            share nothing as "lampson:tz"
+            give {"ok": true, "values": settings.values(), "tz_detected": schedule.tz_offset()}
+        recover err
+            give fail(400, text(err))
+    -- aprobaciones (lib/approvals.syn): las del chat y las de tareas programadas comparten la cola
     route "POST /api/approve" requires auth
         expect body {id: text, decision: bool}
         let b be json of request
-        state_set("approval:" + b["id"], when b["decision"] then "yes" otherwise "no")
-        give {"ok": true}
+        give {"ok": approvals.answer(text(b["id"]), b["decision"])}
+    route "GET /api/approvals" requires auth
+        give {"approvals": approvals.list(), "public_url": approvals.public_url(), "webhook": approvals.webhook_url() != ""}
+    -- link de decisión (PÚBLICO a propósito: lo abre el humano desde el teléfono; el token de un solo uso es la
+    -- autorización, como en el `approve` nativo de Synsema bajo serve). GET porque un link en un chat es un GET.
+    route "GET /approve/:id/:token"
+        let d be when contains(query, "d") then lower(text(query.d)) otherwise ""
+        when d != "yes" and d != "no"
+            give html(approvals.html_page("¿Permitir?", "<a href='?d=yes' style='display:inline-block;padding:10px 18px;border-radius:4px;background:#1d1c1a;color:#fff;text-decoration:none;margin-right:10px'>Sí, permitir</a> <a href='?d=no' style='display:inline-block;padding:10px 18px;border-radius:4px;border:1px solid #a33;color:#a33;text-decoration:none'>No, denegar</a>"))
+        let r be approvals.answer_with_token(text(params.id), text(params.token), d == "yes")
+        when not r["ok"]
+            give html(approvals.html_page("Este link ya no sirve", "La aprobación venció, ya fue respondida o el link no es válido (" + r["why"] + ")."))
+        give html(approvals.html_page(when d == "yes" then "✓ Permitido" otherwise "✗ Denegado", "Lampson sigue con la tarea. Podés cerrar esta pestaña."))
+    -- tareas programadas (lib/schedule.syn): listar, crear, quitar, encender/apagar, correr ahora, log
+    route "GET /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()}
+    route "POST /api/schedules/add" requires auth
+        let b be json of request
+        try
+            let t be schedule.add(b)
+            give {"ok": true, "task": t, "result": "programada «" + t["name"] + "»: " + schedule.describe_plan(t["plan"]) + " · próxima " + schedule.fmt_local(t["next_run"])}
+        recover err
+            give fail(400, text(err))
+    route "POST /api/schedules/remove" requires auth
+        expect body {id: text}
+        let b be json of request
+        try
+            give {"ok": true, "result": schedule.remove(text(b["id"]))}
+        recover err
+            give fail(400, text(err))
+    route "POST /api/schedules/toggle" requires auth
+        expect body {id: text}
+        let b be json of request
+        let on be contains(b, "enabled") and b["enabled"] == true
+        try
+            give {"ok": true, "result": schedule.set_enabled(text(b["id"]), on)}
+        recover err
+            give fail(400, text(err))
+    -- correr ahora: la marca run_now la levanta el próximo tick (así el request no se queda minutos abierto
+    -- y la corrida vive en el hilo del cron, no en el del request)
+    route "POST /api/schedules/run" requires auth
+        expect body {id: text}
+        let b be json of request
+        try
+            let t be schedule.request_run(text(b["id"]))
+            give {"ok": true, "result": "«" + t["name"] + "» corre en el próximo tick (≤ " + text(schedule.TICK_SECONDS) + " s)"}
+        recover err
+            give fail(400, text(err))
+    route "GET /api/schedules/log" requires auth
+        when not contains(query, "id")
+            give fail(400, "id required")
+        let n be when contains(query, "tail") then floor(number(query.tail)) otherwise 300
+        give {"id": query.id, "log": schedule.log_tail(query.id, n), "task": schedule.get(query.id)}
     route "POST /api/chat" requires auth
         expect body {message: text}
@@ -396,20 +493,14 @@ serve on 8080
             task emit(kind, data, tag)
                 trace.event(sid, kind, data, tag)
                 send {"kind": kind, "data": data, "tag": tag} as "event"
-            -- aprobación humana desde la UI: pregunta por SSE y espera la respuesta (o el timeout)
+            -- aprobación humana: la cola de lib/approvals.syn (id + token) — la UI responde por SSE/POST /api/approve,
+            -- y si hay webhook/LAMPSON_PUBLIC_URL también llega un link al canal del usuario (aprobar desde el móvil)
             task ask_web(name, args, why)
-                let id be text(floor(now() * 1000)) + "-" + name
+                let id be approvals.open("chat", permission.describe_call(name, args), why, APPROVAL_TIMEOUT)
                 send {"kind": "approval_request", "data": {"id": id, "name": name, "args": args, "why": why, "timeout": APPROVAL_TIMEOUT}} as "event"
-                let waited be 0
-                let answer be nothing
-                while answer == nothing and waited < APPROVAL_TIMEOUT
-                    set answer to state_get("approval:" + id, nothing)
-                    when answer == nothing
-                        sleep(0.5)
-                        set waited to waited + 0.5
-                state_delete("approval:" + id)
-                let ok be answer == "yes"
-                send {"kind": "approval_result", "data": {"id": id, "approved": ok, "timeout": answer == nothing}} as "event"
+                let t0 be now()
+                let ok be approvals.wait(id, APPROVAL_TIMEOUT)
+                send {"kind": "approval_result", "data": {"id": id, "approved": ok, "timeout": (not ok) and now() - t0 >= APPROVAL_TIMEOUT - 1}} as "event"
                 give ok
             let ctx be boot(want, mode, ask_web, pname, pmodel)
             let messages be [ctx["system"]]