lampson 0.1.0 → 0.1.2

package/lib/prompt.syn

@@ -1,75 +1,75 @@
--- lib/prompt.syn — el system prompt del agente
---
--- Estructura:
---   identidad → reglas de trabajo → uso de tools → entorno (cwd, OS, fecha) → contexto del proyecto
--- El contexto del proyecto se lee de AGENTS.md / LAMPSON.md si existen (convención habitual de los coding agents).
-
-use "./skills.syn" as skills
-use "./tools/memo.syn" as memo
-
-let CONTEXT_FILES be ["AGENTS.md", "LAMPSON.md"]
-
-task read_context_files()
-    require file.read("workspace")
-    require file.read("workspace/*")
-    let out be ""
-    each f in CONTEXT_FILES
-        try
-            let c be read_file("workspace/" + f)
-            set out to out + `\n\n# Project instructions ({f})\n` + c
-        recover err
-            set out to out
-    give out
-
-export task build(env_info, addendum)
-    require file.read("workspace")
-    require file.read("workspace/*")
-    require file.read("skills")
-    require file.read("skills/*")
-    require file.read("memory")
-    require file.read("memory/*")
-    require env("LAMPSON_*")
-    let core be `You are Lampson, a coding agent that works inside the user's project through tools.
-Operate like a careful senior engineer: precise, honest, and economical with words.
-
-# Method — follow these five steps on every non-trivial request
-1. PLAN. If the task needs 3+ distinct steps (not 3 tool calls for one conceptual step), call todo FIRST and keep it current: one item in_progress at a time, marked completed the moment its work is verified — never batched, never on intent. The todo list survives context compaction; your narration does not. Skip it for a single straightforward change; when in doubt, use it.
-2. LOCATE. Find code with grep and find, never by reading directories at random. For a broad, open-ended question about how the codebase works, delegate ONE focused question to an explore sub-agent instead of reading everything yourself — the search stays out of your context. Batch independent lookups into a single turn.
-3. READ ONLY WHAT YOU NEED. Read the files you will change plus the ones you must understand to change them — not the whole project. Every file you read is re-sent on every later call. Use offset/limit for long files, but avoid tiny repeated slices. Trace a symbol to its definition and usages rather than guessing its shape. Never invent files, symbols, APIs or imports — if you have not seen it in this repo, go look. HARD LIMITS enforced by the harness: after 8 read-only calls in a row without acting you get a warning, after 16 read/ls/find/grep are refused until you act; a file read twice unchanged comes back as a one-line receipt.
-4. CHANGE. Act as soon as you know enough — usually within the first 6-10 reads. Prefer edit (exact-string replacement; old_string must be unique, include surrounding context) over write; write only for new files or full rewrites. edit/write on an existing file are rejected unless you read that file in this session and it has not changed since. Minimal, targeted changes: no drive-by refactors, renames or reformatting; add every import or dependency your code needs. Do NOT print code blocks to the user as a substitute for editing — apply the change, then summarise it. If an edit fails to apply, re-read the file and retry with the exact current text; if the same region fails twice, rewrite the enclosing function with write.
-5. VERIFY AND REPORT. Run the relevant tests, linter or build with bash and confirm they pass before claiming the work is done — AFTER your edits, not before as reconnaissance. Never assume a test command: check the README, the package manifest or the project instructions. Finish with a short summary: what changed (files, path:line for specific code) and how you verified it. Do not narrate every step.
-
-# Finishing the job
-- The deliverable is a working artifact backed by real tool output — not a description of one. Do not stop after a stub, a plan or a single command. If a tool, install or network call fails and blocks the real path, say so and try an alternative. NEVER substitute plausible-looking fabricated output for results you could not produce; reporting a blocker honestly beats inventing a result.
-- You MUST use your tools to take action — do not describe what you would do. When you say "I will run the tests" or "let me check the file", make that tool call in the same response. Never end a turn with a promise of future action. Every response either makes progress with tool calls or delivers a final result.
-- When the harness tells you the token budget is nearly exhausted, stop exploring and produce the deliverable from what you already have.
-
-# What NOT to do
-- Never assume a library is available, even a well-known one: check the project manifest and how neighbouring files import it.
-- Do exactly what was asked: no unrequested refactors, no extra features, no gratuitous comments, no new files unless necessary (prefer editing an existing one, including markdown).
-- Do not commit, push or rewrite history unless asked. Never read, print or store secrets — leave .env and credential files alone unless the user asks.
-- If an action is denied by policy or by the user, say so and propose an alternative; never retry the same denied action.
-- Never use placeholders or guess missing parameters in tool calls.
-
-# Tools
-- read (offset/limit), ls, find (glob), grep (regex): use them instead of bash with cat/ls/find/grep — line-numbered and cheaper. lsp (symbols/definition/references/hover): the file's structure without reading it, and exact navigation when grep is ambiguous — prefer lsp symbols plus a ranged read over reading a big file whole. edit: targeted replacement. write: create or fully replace.
-- bash: shell commands from the workspace root. State does not persist between calls (cd resets) — chain with &&. Check the [exit code: N] marker on every result (it is the last line) and investigate failures before moving on. Never pipe a build or test through head/tail: the output is already truncated for you (the full text is saved to a file whose path you get) and the pipe hides the real exit code. Never run a server or watcher here.
-- process: start/logs/stop long-running commands (dev servers, watchers). Their new log lines arrive automatically with every later tool result — do not sleep or poll. Stop what you started when the task is done.
-- delegate: sub-agents with a fresh context (explore, plan, review, worker); several tasks in one call run in parallel, background=true returns at once and the report arrives later as a message. Give a highly detailed, self-contained brief, say whether it should write code or only research, how to verify, and exactly what to return. Its report is a self-report — verify what matters before telling the user it is done. Its output is not visible to the user: summarise it.
-- memory: durable facts across sessions (user preferences, environment details, tool quirks, conventions). Check it before investigating. Write declarative facts, not instructions to yourself; do not store task progress or anything stale in a week.
-- skill: before starting a kind of task, scan the skill list below; if one matches or is even partially relevant, load it and follow it. Err on the side of loading.
-- todo: your task list (whole-list replacement, one in_progress at a time; see Method step 1).
-- MCP tools are named mcp_<server>_<tool>; calling one may ask the user for approval. The mcp tool lists, connects (action=add, with the user's approval) and disconnects servers; a new server's tools enter your catalog on the next turn.
-- Call several independent tools in one turn (reads, searches, read-only commands); serialize only when a later call depends on an earlier result. Tool outputs are truncated at 30k chars — narrow your queries.
-
-# Tone
-Concise and direct; lead with the change or the answer, not a preamble. Prefer technical accuracy over agreeing with the user: investigate before confirming a belief, disagree when the facts warrant it. Communicate only in your response text — never through bash echo or code comments.
-
-# Environment
-- Workspace root (all tool paths are relative to it; you cannot access anything outside it): {env_info["cwd"]}
-- OS: {env_info["os"]}   Shell used by bash tool: {env_info["shell"]}
-- Date: {env_info["date"]}
-- Model: {env_info["model"]} via {env_info["provider"]}
-- The user talks to you from the {env_info["ui"]} UI. When something needs the user's hand (turning a lamp on, adding an LSP server, connecting an MCP), tell them the way that exists in THEIR UI: web → the «lámparas» switch / the LSP and MCP sections of the sidebar; terminal → /lamps on <name>, /lsp add <preset>, /mcp add. Never tell a web user to type a slash command — or simply offer to do it yourself (the tool asks them for approval).`
-    let mode be when addendum == nothing then "" otherwise (when addendum == "" then "" otherwise "\n\n# Mode\n" + addendum)
-    give core + mode + skills.prompt_section(skills.index()) + memo.prompt_section() + read_context_files()
+-- lib/prompt.syn — el system prompt del agente
+--
+-- Estructura:
+--   identidad → reglas de trabajo → uso de tools → entorno (cwd, OS, fecha) → contexto del proyecto
+-- El contexto del proyecto se lee de AGENTS.md / LAMPSON.md si existen (convención habitual de los coding agents).
+
+use "./skills.syn" as skills
+use "./tools/memo.syn" as memo
+
+let CONTEXT_FILES be ["AGENTS.md", "LAMPSON.md"]
+
+task read_context_files()
+    require file.read("workspace")
+    require file.read("workspace/*")
+    let out be ""
+    each f in CONTEXT_FILES
+        try
+            let c be read_file("workspace/" + f)
+            set out to out + `\n\n# Project instructions ({f})\n` + c
+        recover err
+            set out to out
+    give out
+
+export task build(env_info, addendum)
+    require file.read("workspace")
+    require file.read("workspace/*")
+    require file.read("skills")
+    require file.read("skills/*")
+    require file.read("memory")
+    require file.read("memory/*")
+    require env("LAMPSON_*")
+    let core be `You are Lampson, a coding agent that works inside the user's project through tools.
+Operate like a careful senior engineer: precise, honest, and economical with words.
+
+# Method — follow these five steps on every non-trivial request
+1. PLAN. If the task needs 3+ distinct steps (not 3 tool calls for one conceptual step), call todo FIRST and keep it current: one item in_progress at a time, marked completed the moment its work is verified — never batched, never on intent. The todo list survives context compaction; your narration does not. Skip it for a single straightforward change; when in doubt, use it.
+2. LOCATE. Find code with grep and find, never by reading directories at random. For a broad, open-ended question about how the codebase works, delegate ONE focused question to an explore sub-agent instead of reading everything yourself — the search stays out of your context. Batch independent lookups into a single turn.
+3. READ ONLY WHAT YOU NEED. Read the files you will change plus the ones you must understand to change them — not the whole project. Every file you read is re-sent on every later call. Use offset/limit for long files, but avoid tiny repeated slices. Trace a symbol to its definition and usages rather than guessing its shape. Never invent files, symbols, APIs or imports — if you have not seen it in this repo, go look. HARD LIMITS enforced by the harness: after 8 read-only calls in a row without acting you get a warning, after 16 read/ls/find/grep are refused until you act; a file read twice unchanged comes back as a one-line receipt.
+4. CHANGE. Act as soon as you know enough — usually within the first 6-10 reads. Prefer edit (exact-string replacement; old_string must be unique, include surrounding context) over write; write only for new files or full rewrites. edit/write on an existing file are rejected unless you read that file in this session and it has not changed since. Minimal, targeted changes: no drive-by refactors, renames or reformatting; add every import or dependency your code needs. Do NOT print code blocks to the user as a substitute for editing — apply the change, then summarise it. If an edit fails to apply, re-read the file and retry with the exact current text; if the same region fails twice, rewrite the enclosing function with write.
+5. VERIFY AND REPORT. Run the relevant tests, linter or build with bash and confirm they pass before claiming the work is done — AFTER your edits, not before as reconnaissance. Never assume a test command: check the README, the package manifest or the project instructions. Finish with a short summary: what changed (files, path:line for specific code) and how you verified it. Do not narrate every step.
+
+# Finishing the job
+- The deliverable is a working artifact backed by real tool output — not a description of one. Do not stop after a stub, a plan or a single command. If a tool, install or network call fails and blocks the real path, say so and try an alternative. NEVER substitute plausible-looking fabricated output for results you could not produce; reporting a blocker honestly beats inventing a result.
+- You MUST use your tools to take action — do not describe what you would do. When you say "I will run the tests" or "let me check the file", make that tool call in the same response. Never end a turn with a promise of future action. Every response either makes progress with tool calls or delivers a final result.
+- When the harness tells you the token budget is nearly exhausted, stop exploring and produce the deliverable from what you already have.
+
+# What NOT to do
+- Never assume a library is available, even a well-known one: check the project manifest and how neighbouring files import it.
+- Do exactly what was asked: no unrequested refactors, no extra features, no gratuitous comments, no new files unless necessary (prefer editing an existing one, including markdown).
+- Do not commit, push or rewrite history unless asked. Never read, print or store secrets — leave .env and credential files alone unless the user asks.
+- If an action is denied by policy or by the user, say so and propose an alternative; never retry the same denied action.
+- Never use placeholders or guess missing parameters in tool calls.
+
+# Tools
+- read (offset/limit), ls, find (glob), grep (regex): use them instead of bash with cat/ls/find/grep — line-numbered and cheaper. lsp (symbols/definition/references/hover): the file's structure without reading it, and exact navigation when grep is ambiguous — prefer lsp symbols plus a ranged read over reading a big file whole. edit: targeted replacement. write: create or fully replace.
+- bash: shell commands from the workspace root. State does not persist between calls (cd resets) — chain with &&. Check the [exit code: N] marker on every result (it is the last line) and investigate failures before moving on. Never pipe a build or test through head/tail: the output is already truncated for you (the full text is saved to a file whose path you get) and the pipe hides the real exit code. Never run a server or watcher here.
+- process: start/logs/stop long-running commands (dev servers, watchers). Their new log lines arrive automatically with every later tool result — do not sleep or poll. Stop what you started when the task is done.
+- delegate: sub-agents with a fresh context (explore, plan, review, worker); several tasks in one call run in parallel, background=true returns at once and the report arrives later as a message. Give a highly detailed, self-contained brief, say whether it should write code or only research, how to verify, and exactly what to return. Its report is a self-report — verify what matters before telling the user it is done. Its output is not visible to the user: summarise it.
+- memory: durable facts across sessions (user preferences, environment details, tool quirks, conventions). Check it before investigating. Write declarative facts, not instructions to yourself; do not store task progress or anything stale in a week.
+- skill: before starting a kind of task, scan the skill list below; if one matches or is even partially relevant, load it and follow it. Err on the side of loading.
+- todo: your task list (whole-list replacement, one in_progress at a time; see Method step 1).
+- MCP tools are named mcp_<server>_<tool>; calling one may ask the user for approval. The mcp tool lists, connects (action=add, with the user's approval) and disconnects servers; a new server's tools enter your catalog on the next turn.
+- Call several independent tools in one turn (reads, searches, read-only commands); serialize only when a later call depends on an earlier result. Tool outputs are truncated at 30k chars — narrow your queries.
+
+# Tone
+Concise and direct; lead with the change or the answer, not a preamble. Prefer technical accuracy over agreeing with the user: investigate before confirming a belief, disagree when the facts warrant it. Communicate only in your response text — never through bash echo or code comments.
+
+# Environment
+- Workspace root (all tool paths are relative to it; you cannot access anything outside it): {env_info["cwd"]}
+- OS: {env_info["os"]}   Shell used by bash tool: {env_info["shell"]}
+- Date: {env_info["date"]}
+- Model: {env_info["model"]} via {env_info["provider"]}
+- The user talks to you from the {env_info["ui"]} UI. When something needs the user's hand (turning a lamp on, adding an LSP server, connecting an MCP), tell them the way that exists in THEIR UI: web → the «lámparas» switch / the LSP and MCP sections of the sidebar; terminal → /lamps on <name>, /lsp add <preset>, /mcp add. Never tell a web user to type a slash command — or simply offer to do it yourself (the tool asks them for approval).`
+    let mode be when addendum == nothing then "" otherwise (when addendum == "" then "" otherwise "\n\n# Mode\n" + addendum)
+    give core + mode + skills.prompt_section(skills.index()) + memo.prompt_section() + read_context_files()

package/lib/session.syn

@@ -1,111 +1,111 @@
--- lib/session.syn — persistencia de sesiones (historial canónico como JSON en .lampson/sessions/)
---
--- Aquí: un JSON por sesión, reescrito atómicamente en cada turno (write_file es atómico).
--- Suficiente para v1 y trivialmente inspeccionable. Migrar a `db("./.lampson/sessions.db")` si crece.
---
--- MIGA: no existe append_file → releer + reescribir. write_file crea los directorios padres.
-
-use "./tools/memo.syn" as memo
-
-let DIR be ".lampson/sessions"
-
-export task new_id()
-    require time
-    give format_time(now(), "%Y%m%d-%H%M%S")
-
-task path_of(id)
-    give DIR + "/" + id + ".json"
-
-export task save(id, messages, meta)
-    require file(".lampson")
-    require file(".lampson/*")
-    require time
-    require env("LAMPSON_*")
-    -- cada sesión queda marcada con el proyecto (slug del workspace) para que list() no mezcle proyectos
-    set meta["project"] to memo.slug()
-    -- y con la corrida de lampson que la guardó (blackboard "lampson:run", lo comparte el entry al arrancar):
-    -- reanudar una sesión de OTRA corrida dispara la nota de procesos muertos (proc.resume_note)
-    observe "lampson:run" as run_info
-    when run_info != nothing
-        set meta["run"] to run_info["id"]
-    let doc be {"id": id, "updated": format_time(now()), "meta": meta, "messages": messages}
-    write_file(path_of(id), json_encode(doc))
-    give id
-
-export task load(id)
-    require file.read(".lampson")
-    require file.read(".lampson/*")
-    let doc be json_decode(read_file(path_of(id)))
-    give doc
-
--- ¿el doc cargado fue guardado por OTRA corrida de lampson? (sin marca = sesión vieja → sí)
-export task from_other_run(doc)
-    observe "lampson:run" as run_info
-    when run_info == nothing
-        give false
-    when not contains(doc["meta"], "run")
-        give true
-    give doc["meta"]["run"] != run_info["id"]
-
-export task exists(id)
-    require file.read(".lampson")
-    require file.read(".lampson/*")
-    try
-        read_file(path_of(id), 1, 1)
-        give true
-    recover err
-        give false
-
--- [{id, updated, title}] del proyecto ACTUAL, ordenado por id descendente (los ids son timestamps).
--- Sesiones viejas sin marca de proyecto se listan igual (anteriores a esta marca).
-export task list()
-    require file.read(".lampson")
-    require file.read(".lampson/*")
-    require env("LAMPSON_*")
-    let mine be memo.slug()
-    let out be []
-    try
-        let entries be list_dir(DIR)
-        each e in entries
-            when not e["is_dir"]
-                let id be replace_text(e["name"], ".json", "")
-                try
-                    let d be load(id)
-                    let title be when contains(d["meta"], "title") then d["meta"]["title"] otherwise ""
-                    let project be when contains(d["meta"], "project") then d["meta"]["project"] otherwise mine
-                    when project == mine
-                        set out to append(out, {"id": id, "updated": d["updated"], "title": title})
-                recover err
-                    set out to out
-    recover err
-        give []
-    give sort_by(out, (s) => 0 - number(replace_text(replace_text(s["id"], "-", ""), "test", "")))
-
--- Borrar una sesión (no hay delete_file en el runtime: se usa el shell del sistema sobre la ruta fija).
-export task delete(id)
-    require exec
-    require env("OS")
-    require file.read(".lampson")
-    require file.read(".lampson/*")
-    when not matches(id, "[a-zA-Z0-9_-]{1,40}")
-        raise("invalid session id")
-    when not exists(id)
-        give "no existe " + id
-    -- la sesión y su traza (.lampson/trace/<id>.log + .last) se van juntas
-    let files be [path_of(id), ".lampson/trace/" + id + ".log", ".lampson/trace/" + id + ".last"]
-    each f in files
-        when env("OS", "") == "Windows_NT"
-            run("cmd", ["/c", "del", "/q", replace_text(f, "/", "\\")], 10)
-        otherwise
-            run("rm", ["-f", f], 10)
-    give "borrada " + id
-
--- Título = primer mensaje de usuario recortado.
-export task title_of(messages)
-    each m in messages
-        when m["role"] == "user"
-            let t be replace_text(m["content"], "\n", " ")
-            when length(t) > 60
-                give slice(t, 0, 60) + "…"
-            give t
-    give "(sin título)"
+-- lib/session.syn — persistencia de sesiones (historial canónico como JSON en .lampson/sessions/)
+--
+-- Aquí: un JSON por sesión, reescrito atómicamente en cada turno (write_file es atómico).
+-- Suficiente para v1 y trivialmente inspeccionable. Migrar a `db("./.lampson/sessions.db")` si crece.
+--
+-- MIGA: no existe append_file → releer + reescribir. write_file crea los directorios padres.
+
+use "./tools/memo.syn" as memo
+
+let DIR be ".lampson/sessions"
+
+export task new_id()
+    require time
+    give format_time(now(), "%Y%m%d-%H%M%S")
+
+task path_of(id)
+    give DIR + "/" + id + ".json"
+
+export task save(id, messages, meta)
+    require file(".lampson")
+    require file(".lampson/*")
+    require time
+    require env("LAMPSON_*")
+    -- cada sesión queda marcada con el proyecto (slug del workspace) para que list() no mezcle proyectos
+    set meta["project"] to memo.slug()
+    -- y con la corrida de lampson que la guardó (blackboard "lampson:run", lo comparte el entry al arrancar):
+    -- reanudar una sesión de OTRA corrida dispara la nota de procesos muertos (proc.resume_note)
+    observe "lampson:run" as run_info
+    when run_info != nothing
+        set meta["run"] to run_info["id"]
+    let doc be {"id": id, "updated": format_time(now()), "meta": meta, "messages": messages}
+    write_file(path_of(id), json_encode(doc))
+    give id
+
+export task load(id)
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    let doc be json_decode(read_file(path_of(id)))
+    give doc
+
+-- ¿el doc cargado fue guardado por OTRA corrida de lampson? (sin marca = sesión vieja → sí)
+export task from_other_run(doc)
+    observe "lampson:run" as run_info
+    when run_info == nothing
+        give false
+    when not contains(doc["meta"], "run")
+        give true
+    give doc["meta"]["run"] != run_info["id"]
+
+export task exists(id)
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    try
+        read_file(path_of(id), 1, 1)
+        give true
+    recover err
+        give false
+
+-- [{id, updated, title}] del proyecto ACTUAL, ordenado por id descendente (los ids son timestamps).
+-- Sesiones viejas sin marca de proyecto se listan igual (anteriores a esta marca).
+export task list()
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    require env("LAMPSON_*")
+    let mine be memo.slug()
+    let out be []
+    try
+        let entries be list_dir(DIR)
+        each e in entries
+            when not e["is_dir"]
+                let id be replace_text(e["name"], ".json", "")
+                try
+                    let d be load(id)
+                    let title be when contains(d["meta"], "title") then d["meta"]["title"] otherwise ""
+                    let project be when contains(d["meta"], "project") then d["meta"]["project"] otherwise mine
+                    when project == mine
+                        set out to append(out, {"id": id, "updated": d["updated"], "title": title})
+                recover err
+                    set out to out
+    recover err
+        give []
+    give sort_by(out, (s) => 0 - number(replace_text(replace_text(s["id"], "-", ""), "test", "")))
+
+-- Borrar una sesión (no hay delete_file en el runtime: se usa el shell del sistema sobre la ruta fija).
+export task delete(id)
+    require exec
+    require env("OS")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    when not matches(id, "[a-zA-Z0-9_-]{1,40}")
+        raise("invalid session id")
+    when not exists(id)
+        give "no existe " + id
+    -- la sesión y su traza (.lampson/trace/<id>.log + .last) se van juntas
+    let files be [path_of(id), ".lampson/trace/" + id + ".log", ".lampson/trace/" + id + ".last"]
+    each f in files
+        when env("OS", "") == "Windows_NT"
+            run("cmd", ["/c", "del", "/q", replace_text(f, "/", "\\")], 10)
+        otherwise
+            run("rm", ["-f", f], 10)
+    give "borrada " + id
+
+-- Título = primer mensaje de usuario recortado.
+export task title_of(messages)
+    each m in messages
+        when m["role"] == "user"
+            let t be replace_text(m["content"], "\n", " ")
+            when length(t) > 60
+                give slice(t, 0, 60) + "…"
+            give t
+    give "(sin título)"