lampson 0.1.0

package/lib/loop.syn

@@ -0,0 +1,455 @@
+-- lib/loop.syn — el agent loop (pensar → elegir tool → ejecutar → observar → repetir)
+--
+-- El mismo ciclo que cualquier coding agent, en ~120 líneas: Synsema pone el aislamiento (call_tool)
+-- y la concurrencia en el lenguaje, así que el loop solo orquesta.
+--
+-- run_turn(cfg, messages, opts, on_event) → {messages, text, steps, usage, stopped}
+--   cfg      : provider.config()
+--   messages : historial canónico (ver provider.syn); el turno del usuario YA está agregado
+--   opts     : {max_steps, budget_tokens, permission_mode, ask_fn, registry, catalog, inbox_fn, tag}
+--   on_event : task(kind, data, tag) — "assistant", "tool_call", "tool_result", "tool_denied", "error", "usage", "compact"
+--              `tag` = opts["tag"]: "" para el agente principal, el id del subagente para sus eventos
+--   inbox_fn : task(step, tag) → {messages: [texto…], stop: bool} | nothing — se consulta ANTES de cada llamada
+--              al modelo. Es el buzón: al padre le trae los avisos de subagentes terminados; al hijo, los
+--              `steer` del padre y la orden de `stop` (que corta el turno devolviendo lo parcial).
+--              Los avisos entran como mensajes `user` nuevos, nunca se muta el contexto pasado (cache intacto).
+--
+-- Garantías (las mismas que documenta llm.md de Synsema):
+--   * Solo se ejecutan tools del allow-list (registry). Un nombre alucinado → error devuelto al modelo.
+--   * Cada tool corre con call_tool: sus `require` ∩ los del programa. No puede exceder su mandato.
+--   * Loop acotado por max_steps y budget_tokens (el guard va en la condición del while).
+--   * Un error de tool NO rompe el loop: se devuelve al modelo como resultado (así aprende y corrige).
+
+use "./provider.syn" as provider
+use "./permission.syn" as permission
+use "./mcp.syn" as mcp
+use "./lamps.syn" as lamps
+use "./tools/todo.syn" as todo
+
+let MAX_ERRORS_PER_TURN be 8
+-- Conciencia de progreso (2026-08-28, la mejor idea de cada harness — ver notes/*.md):
+--   * SPILL (deepseek): un resultado > SPILL_CAP se guarda entero en .lampson/spill/<call>.txt y el modelo ve
+--     cabeza + cola + "Full result saved to …"; `read` queda exento (ya pagina con offset/limit).
+--   * RECIBOS (hermes): antes de cada llamada, los tool results más allá de los últimos PROTECT_TOKENS se
+--     reemplazan por una línea "[read result pruned: ok · 412 lines/18k chars]" — el modelo conserva QUÉ
+--     hizo y cómo salió, sin re-enviar 30 archivos en cada request.
+--   * REPETICIÓN (deepseek): misma tool + mismos args (JSON canónico) 3 y 5 veces → se ejecuta igual pero
+--     el resultado lleva un recordatorio; 8 → se rechaza (opencode). Nunca cuenta entre turnos.
+--   * PRESUPUESTO (hermes + opencode): al 80% un aviso anexado al ÚLTIMO tool result (cache-safe, sin
+--     mensaje user nuevo); al 95% último paso sin tools con resumen obligatorio.
+--   * TODO (hermes): la lista activa se re-inyecta SOLO tras una compaction.
+export let SPILL_DIR be ".lampson/spill"
+export let SPILL_CAP be 10000
+export let PROTECT_TOKENS be 16000
+let REPEAT_TIERS be [3, 5, 8]
+let REPEAT_HARD be 8
+-- TOPE DE EXPLORACIÓN (propio; ningún harness lo tiene y es lo que faltaba): llamadas de SOLO LECTURA
+-- seguidas sin ninguna acción (edit/write/bash/process/delegate/mcp). Visto 2026-08-28 con deepseek-v4-pro:
+-- 39 read/ls/find seguidos, 0 ediciones, 419k tokens, dos veces, con las reglas de prompt ignoradas.
+-- A la mitad del tope el resultado lleva un aviso; al tope, read/ls/find/grep se rechazan hasta que actúe.
+let READ_ONLY_TOOLS be ["read", "ls", "find", "grep"]
+let ACTION_TOOLS be ["edit", "write", "bash", "process", "delegate"]
+
+export task explore_cap()
+    require env("LAMPSON_*")
+    let e be env("LAMPSON_EXPLORE_CAP", "")
+    when e != ""
+        give floor(number(e))
+    give 16
+
+-- {streak, note, refuse}: nuevo streak tras esta llamada y qué hacer con ella
+export task explore_verdict(streak, name, cap)
+    when contains(ACTION_TOOLS, name) or starts_with(name, "mcp_")
+        give {"streak": 0, "note": "", "refuse": false}
+    when not contains(READ_ONLY_TOOLS, name)
+        give {"streak": streak, "note": "", "refuse": false}
+    let n be streak + 1
+    when n >= cap
+        give {"streak": n, "note": "", "refuse": true}
+    when n == floor(cap / 2)
+        give {"streak": n, "note": "\n\n[harness] " + text(n) + " read-only calls in a row without changing anything. You likely know enough: edit/write now, or run the relevant command. After " + text(cap) + " read-only calls in a row, read/ls/find/grep are refused until you act. If the codebase is genuinely too big, delegate ONE focused question to an `explore` sub-agent instead of reading everything yourself.", "refuse": false}
+    give {"streak": n, "note": "", "refuse": false}
+
+-- JSON canónico (claves ordenadas en profundidad): reordenar propiedades no engaña al detector
+export task canon(v)
+    let t be type_of(v)
+    when t == "map"
+        let parts be []
+        each k in sort_by(keys(v), (x) => x)
+            set parts to append(parts, json_encode(k) + ":" + canon(v[k]))
+        give "{" + join(parts, ",") + "}"
+    when t == "list"
+        give "[" + join(apply((x) => canon(x), v), ",") + "]"
+    give json_encode(v)
+
+task one_line_args(args)
+    let t be json_encode(args)
+    when length(t) > 80
+        give slice(t, 0, 80) + "…"
+    give t
+
+task safe_id(id, step)
+    let t be text(id)
+    when matches(t, "[A-Za-z0-9_-]{1,80}")
+        give t
+    give "call-" + text(step)
+
+-- cabeza + cola, el resto a disco
+export task spill(name, id, out)
+    require file(".lampson")
+    require file(".lampson/*")
+    when name == "read" or length(out) <= SPILL_CAP
+        give out
+    let path be SPILL_DIR + "/" + id + ".txt"
+    write_file(path, out)
+    let half be floor(SPILL_CAP / 2)
+    give slice(out, 0, half) + "\n\n[... " + text(length(out) - SPILL_CAP) + " chars omitted. Full result saved to " + path + " — grep it, or read it with offset/limit; do not re-run the command ...]\n\n" + slice(out, length(out) - half, length(out))
+
+-- recibo de una línea para un tool result viejo
+export task receipt(m)
+    let out be text(m["content"])
+    when starts_with(out, "[") and contains(out, " result pruned: ")
+        give out
+    let status be "ok"
+    when starts_with(out, "ERROR") or starts_with(out, "DENIED")
+        set status to slice(replace_text(split(out, "\n")[0], "\r", ""), 0, 120)
+    otherwise
+        let codes be find_all(out, "\\[exit code [0-9]+\\]")
+        when length(codes) > 0
+            let last be codes[length(codes) - 1]
+            set status to slice(last, 1, length(last) - 1)
+    let saved be find_all(out, "Full result saved to [^ ]+")
+    let where_full be when length(saved) > 0 then " · " + saved[0] otherwise ""
+    give "[" + text(m["name"]) + " result pruned: " + status + " · " + text(length(split(out, "\n"))) + " lines/" + text(length(out)) + " chars" + where_full + " — re-run the tool only if you really need the content again]"
+
+-- reemplaza por recibos los tool results anteriores a los últimos PROTECT_TOKENS tokens de resultados.
+-- HISTÉRESIS 2× (2026-08-28): podar en cada paso movía la frontera y reescribía UN mensaje viejo por
+-- request — cada reescritura invalida el prompt cache del proveedor desde ese punto (visto en la traza:
+-- hits alternando 44k/11k con DeepSeek, y turnos enteros sin un solo hit). Ahora se poda recién cuando
+-- hay 2×PROTECT_TOKENS de resultados vivos, y de una sola vez: entre podas el historial queda
+-- byte-estable y el prefijo cachea (misma lección que hermes: "anything that mutates past context
+-- invalidates that cache and multiplies cost").
+export task prune_results(msgs)
+    let total be 0
+    each m in msgs
+        when m["role"] == "tool"
+            set total to total + floor(length(text(m["content"])) / 4)
+    when total <= PROTECT_TOKENS * 2
+        give msgs
+    let acc be 0
+    let cut be length(msgs)
+    let i be length(msgs) - 1
+    while i >= 0 and acc < PROTECT_TOKENS
+        let m be msgs[i]
+        when m["role"] == "tool"
+            set acc to acc + floor(length(text(m["content"])) / 4)
+        set cut to i
+        set i to i - 1
+    let out be []
+    each e in enumerate(msgs)
+        let m be e["item"]
+        when e["index"] < cut and m["role"] == "tool" and length(text(m["content"])) > 200
+            set out to append(out, {"role": "tool", "tool_call_id": m["tool_call_id"], "name": m["name"], "content": receipt(m)})
+        otherwise
+            set out to append(out, m)
+    give out
+
+-- anexa un aviso al ÚLTIMO tool result (canal cache-safe, hermes); ok=false si no hay ninguno
+task append_to_last_tool(msgs, note)
+    let i be length(msgs) - 1
+    while i >= 0
+        when msgs[i]["role"] == "tool"
+            let m be msgs[i]
+            let out be slice(msgs, 0, i) + [{"role": "tool", "tool_call_id": m["tool_call_id"], "name": m["name"], "content": text(m["content"]) + "\n\n" + note}] + slice(msgs, i + 1, length(msgs))
+            give {"ok": true, "msgs": out}
+        set i to i - 1
+    give {"ok": false, "msgs": msgs}
+
+task repeat_note(tc, n)
+    when n < REPEAT_TIERS[1]
+        give "\n\n[harness] You are repeating the exact same tool call with identical arguments (" + text(n) + " times in a row). Carefully analyze the previous result before calling again: if the task is not complete, try a different approach or different arguments instead of repeating the call."
+    give "\n\n[harness] The repeated calls are not making progress (" + tc["name"] + ", " + text(n) + " consecutive calls with the same arguments). Do not call this tool with these exact arguments again. Inspect the latest result and choose a different action, different arguments, or finish the task if enough evidence has been gathered."
+
+task emit(on_event, kind, data, tag)
+    when on_event != nothing
+        call(on_event, {"kind": kind, "data": data, "tag": tag})
+
+-- Imágenes adjuntas (base64 en m["images"]) fuera del texto: para contar tokens y para el resumen
+-- de compaction se reemplazan por una marca; cada imagen se estima en ~1000 tokens.
+task without_images(messages)
+    let out be []
+    let n_images be 0
+    each m in messages
+        when contains(m, "images")
+            set n_images to n_images + length(m["images"])
+            set out to append(out, {"role": m["role"], "content": m["content"] + "\n[" + text(length(m["images"])) + " imagen(es) adjunta(s)]"})
+        otherwise
+            set out to append(out, m)
+    give {"messages": out, "images": n_images}
+
+-- Estimación barata de tokens (4 chars ≈ 1 token), suficiente para decidir compaction.
+export task estimate_tokens(messages)
+    let w be without_images(messages)
+    give floor(length(json_encode(w["messages"])) / 4) + w["images"] * 1000
+
+-- Compaction del contexto:
+-- resume todo menos el system y los últimos `keep_last` mensajes en un único mensaje user.
+export task compact(cfg, messages, keep_last)
+    require net
+    require time
+    let n be length(messages)
+    when n <= keep_last + 2
+        give messages
+    let system be []
+    let rest be []
+    each m in messages
+        when m["role"] == "system"
+            set system to append(system, m)
+        otherwise
+            set rest to append(rest, m)
+    let cut be length(rest) - keep_last
+    -- no cortar entre un assistant con tool_calls y sus tool results
+    let moving be true
+    while moving
+        when cut >= length(rest)
+            set moving to false
+        otherwise when rest[cut]["role"] == "tool"
+            set cut to cut + 1
+        otherwise
+            set moving to false
+    let old be slice(rest, 0, cut)
+    let recent be slice(rest, cut, length(rest))
+    let transcript be json_encode(without_images(old)["messages"])
+    let req be [{"role": "system", "content": "You summarize agent conversations for context compaction."},
+                {"role": "user", "content": "Summarize this conversation between a user and a coding agent so the agent can continue seamlessly. Keep: the user's goals and constraints, decisions made, files touched (with what changed), current state, pending work, and any errors seen. Be concise but complete. Output plain text.\n\n" + truncate_text(transcript, 120000)}]
+    let r be provider.chat_retry(cfg, req, [], 2)
+    when r["error"] != nothing
+        give messages
+    let summary be {"role": "user", "content": "[Context compacted — summary of the earlier conversation]\n" + r["text"] + "\n[End of summary. The conversation continues below.]"}
+    give system + [summary] + recent
+
+task truncate_text(s, max)
+    when length(s) > max
+        give slice(s, 0, max) + "\n[...truncated...]"
+    give s
+
+-- Algunos modelos (MiniMax, Qwen…) sin catálogo emiten la tool call como TEXTO en su formato nativo
+-- ("<tool_call>…", "]<]minimax[>[…"). No es una respuesta: se reemplaza por una nota.
+task strip_raw_tool_calls(t)
+    when t == nothing
+        give ""
+    let markers be ["<tool_call>", "]<]", "minimax[>[", "<invoke name=", "<function_calls>", "<|tool_call|>"]
+    let cut be length(t)
+    each m in markers
+        let parts be split(t, m)
+        when length(parts) > 1
+            when length(parts[0]) < cut
+                set cut to length(parts[0])
+    when cut == length(t)
+        give t
+    let head be trim(slice(t, 0, cut))
+    let note be "(el modelo intentó llamar una tool más pero el harness no lo permitió en este paso)"
+    give when head == "" then note otherwise head + "\n" + note
+
+task tool_result_msg(tc, content)
+    give {"role": "tool", "tool_call_id": tc["id"], "name": tc["name"], "content": content}
+
+-- Ejecuta UNA tool call: permisos → allow-list → call_tool → resultado como texto.
+task execute(tc, opts, on_event)
+    let tag be opts["tag"]
+    let name be tc["name"]
+    let args be tc["args"]
+    let registry be opts["registry"]
+    when not contains(registry, name)
+        emit(on_event, "tool_denied", {"call": tc, "reason": "unknown tool"}, tag)
+        give "ERROR: unknown tool '" + name + "'. Available: " + join(keys(registry), ", ")
+    when contains(args, "_parse_error")
+        give "ERROR: could not parse tool arguments as JSON: " + text(args["_parse_error"])
+    let verdict be permission.evaluate(name, args, opts["permission_mode"])
+    when verdict["decision"] == "deny"
+        emit(on_event, "tool_denied", {"call": tc, "reason": verdict["reason"]}, tag)
+        give "DENIED by policy (" + verdict["reason"] + "). Do not retry this exact action; explain or propose an alternative."
+    when verdict["decision"] == "ask"
+        let approved be false
+        when opts["ask_fn"] != nothing
+            set approved to call(opts["ask_fn"], {"name": name, "args": args, "why": verdict["reason"]})
+        when not approved
+            emit(on_event, "tool_denied", {"call": tc, "reason": "user declined (" + verdict["reason"] + ")"}, tag)
+            give "DENIED by the user (" + verdict["reason"] + "). Do not retry this exact action; ask the user or propose an alternative."
+    try
+        -- tools MCP: no son tasks Synsema (args libres); el registry las marca con "mcp"
+        when registry[name] == "mcp"
+            give text(mcp.call(name, args))
+        -- tools de lámparas: un proceso hijo por llamada (lib/lamps.syn)
+        when registry[name] == "lamp"
+            give text(lamps.call(name, args))
+        let result be call_tool(registry[name], args)
+        give text(result)
+    recover err
+        give "ERROR: " + err
+
+export task run_turn(cfg, messages, opts, on_event)
+    require net
+    require time
+    require env("LAMPSON_*")
+    require file(".lampson")
+    require file(".lampson/*")
+    let msgs be messages
+    let steps be 0
+    let spent be 0
+    let errors be 0
+    let usage be {"input": 0, "output": 0, "cached": 0}
+    let final_text be ""
+    let stopped be "done"
+    let last_sig be ""
+    let repeats be 0
+    let nudged be false
+    let explore_streak be 0
+    let cap be explore_cap()
+    -- lecturas repetidas en el mismo turno (visto 2026-08-28: globals.css y page.tsx leídos 3 veces cada uno):
+    -- si el resultado es idéntico al anterior, el modelo recibe un recibo corto — el contenido ya está en su contexto
+    let seen_reads be {}
+    -- y un tope TOTAL por turno de llamadas de solo lectura (el de racha se reinicia con cualquier acción)
+    let reads_total be 0
+    let turn_cap be cap * 2
+    let catalog be opts["catalog"]
+    let max_steps be opts["max_steps"]
+    let budget be opts["budget_tokens"]
+    let tag be opts["tag"]
+    -- compaction preventiva
+    when estimate_tokens(msgs) > opts["compact_at_tokens"]
+        emit(on_event, "compact", {"before": estimate_tokens(msgs)}, tag)
+        set msgs to compact(cfg, msgs, 6)
+        -- la lista de tareas activa sobrevive a la compaction (solo lo pendiente)
+        let td be todo.active_text()
+        when td != ""
+            set msgs to append(msgs, {"role": "user", "content": td})
+    while steps < max_steps and spent <= budget
+        set steps to steps + 1
+        -- recibos: los tool results viejos dejan de viajar completos en cada request
+        set msgs to prune_results(msgs)
+        -- buzón: avisos de subagentes (padre) / steer y stop (hijo)
+        when opts["inbox_fn"] != nothing
+            let inb be call(opts["inbox_fn"], {"step": steps, "tag": tag})
+            when inb != nothing
+                each m in inb["messages"]
+                    emit(on_event, "inbox", m, tag)
+                    set msgs to append(msgs, {"role": "user", "content": m})
+                when inb["stop"]
+                    emit(on_event, "error", "stopped by the parent agent", tag)
+                    give {"messages": msgs, "text": final_text, "steps": steps, "usage": usage, "stopped": "stopped"}
+        -- último paso: sin tools + instrucción explícita → respuesta final (truco de llm.md: catálogo vacío)
+        -- presupuesto de tokens (visto 2026-08-28: 16 pasos leyendo 30 archivos, 420k tokens, 0 ediciones):
+        -- al 80% un aviso anexado al último tool result (una sola vez, cache-safe); al 95% respuesta final sin tools
+        when spent >= budget * 0.8 and not nudged
+            let noted be append_to_last_tool(msgs, "[SYSTEM NOTICE — token budget nearly exhausted: " + text(spent) + " of " + text(floor(budget)) + "] Stop new discovery/verification work now. Produce the required deliverable (the edits, the answer, the summary) from the state you already have, completing only mandatory writes.")
+            when noted["ok"]
+                set nudged to true
+                set msgs to noted["msgs"]
+                emit(on_event, "inbox", "presupuesto de tokens al 80% (" + text(spent) + "/" + text(floor(budget)) + "): el harness le pidió al modelo que cierre", tag)
+        let over_budget be spent >= budget * 0.95
+        let last_step be steps == max_steps or over_budget
+        let cat be when last_step then [] otherwise catalog
+        when last_step
+            let why be when over_budget then "Token budget for this turn is exhausted (" + text(spent) + " of " + text(floor(budget)) + " tokens)" otherwise "Step limit reached for this turn (" + text(max_steps) + " tool calls)"
+            set msgs to append(msgs, {"role": "user", "content": "[harness] " + why + ". Do NOT call tools now. Reply with a short status: what you completed, what is verified, and exactly what remains to do next. The user can say 'continue' to resume."})
+        let r be provider.chat_retry(cfg, msgs, cat, 3)
+        when r["error"] != nothing
+            emit(on_event, "error", r["error"], tag)
+            set stopped to "error: " + r["error"]
+            set final_text to ""
+            give {"messages": msgs, "text": final_text, "steps": steps, "usage": usage, "stopped": stopped}
+        let rc be when contains(r["usage"], "cached") then r["usage"]["cached"] otherwise 0
+        set usage to {"input": usage["input"] + r["usage"]["input"], "output": usage["output"] + r["usage"]["output"], "cached": usage["cached"] + rc}
+        -- el presupuesto mide COSTO: los tokens servidos desde caché de prompt pesan 10%
+        set spent to spent + provider.cost_tokens(r["usage"])
+        emit(on_event, "usage", {"step": steps, "usage": r["usage"], "total": usage}, tag)
+        let clean_text be strip_raw_tool_calls(r["text"])
+        let assistant be {"role": "assistant", "content": clean_text, "tool_calls": r["tool_calls"]}
+        set msgs to append(msgs, assistant)
+        when clean_text != ""
+            emit(on_event, "assistant", clean_text, tag)
+        when length(r["tool_calls"]) == 0
+            set final_text to clean_text
+            give {"messages": msgs, "text": final_text, "steps": steps, "usage": usage, "stopped": when over_budget then "budget" otherwise (when last_step then "max_steps" otherwise "done")}
+        each tc in r["tool_calls"]
+            emit(on_event, "tool_call", tc, tag)
+            -- repetición: misma tool + mismos args (JSON canónico); 3 y 5 → recordatorio en el resultado; 8 → rechazo
+            let sig be tc["name"] + " " + canon(tc["args"])
+            set repeats to when sig == last_sig then repeats + 1 otherwise 1
+            set last_sig to sig
+            let out be ""
+            let ex be explore_verdict(explore_streak, tc["name"], cap)
+            set explore_streak to ex["streak"]
+            when repeats >= REPEAT_HARD
+                set out to "ERROR: you already called " + tc["name"] + " with these exact arguments " + text(repeats) + " times in a row. The result will not change; try a different approach or report the problem."
+                emit(on_event, "tool_denied", {"call": tc, "reason": "repeated call (" + text(repeats) + "x)"}, tag)
+            otherwise when ex["refuse"]
+                set out to "ERROR: exploration cap reached — " + text(explore_streak) + " read-only calls in a row (read/ls/find/grep) without a single change. Reading more will not help. Do one of: (1) edit/write the files you already read; (2) run a command (bash/process) that moves the task; (3) delegate ONE focused question to an `explore` sub-agent; (4) tell the user what you need. read/ls/find/grep are refused until you do."
+                emit(on_event, "tool_denied", {"call": tc, "reason": "exploration cap (" + text(explore_streak) + " read-only calls without acting)"}, tag)
+            otherwise when contains(READ_ONLY_TOOLS, tc["name"]) and reads_total >= turn_cap
+                set out to "ERROR: this turn already made " + text(reads_total) + " read-only calls (limit " + text(turn_cap) + "). Everything you read is in your context. Act on it now (edit/write/run), delegate ONE focused question to an `explore` sub-agent, or report to the user."
+                emit(on_event, "tool_denied", {"call": tc, "reason": "read-only calls per turn (" + text(reads_total) + ")"}, tag)
+            otherwise
+                set out to spill(tc["name"], safe_id(tc["id"], steps), execute(tc, opts, on_event))
+                when contains(READ_ONLY_TOOLS, tc["name"])
+                    set reads_total to reads_total + 1
+                    let rk be tc["name"] + " " + canon(tc["args"])
+                    let h be decode(sha256(out), "hex")
+                    when contains(seen_reads, rk) and seen_reads[rk]["hash"] == h and not starts_with(out, "ERROR")
+                        set out to "[unchanged: identical to your " + tc["name"] + " at step " + text(seen_reads[rk]["step"]) + " this turn — the content is already in your context above; do not re-read files you already have]"
+                        emit(on_event, "inbox", "lectura repetida (" + tc["name"] + " " + one_line_args(tc["args"]) + "): recibo en vez de re-enviar el contenido", tag)
+                    otherwise
+                        set seen_reads[rk] to {"hash": h, "step": steps}
+                when contains(REPEAT_TIERS, repeats)
+                    set out to out + repeat_note(tc, repeats)
+                when ex["note"] != ""
+                    set out to out + ex["note"]
+                    emit(on_event, "inbox", "tope de exploración a la mitad (" + text(explore_streak) + "/" + text(cap) + " lecturas seguidas sin actuar): aviso al modelo", tag)
+            when starts_with(out, "ERROR") or starts_with(out, "DENIED")
+                set errors to errors + 1
+            emit(on_event, "tool_result", {"call": tc, "output": out}, tag)
+            set msgs to append(msgs, tool_result_msg(tc, out))
+        when errors >= MAX_ERRORS_PER_TURN
+            set msgs to append(msgs, {"role": "user", "content": "[harness] Too many tool errors this turn. Stop calling tools and report what happened."})
+            let fin be provider.chat_retry(cfg, msgs, [], 2)
+            set msgs to append(msgs, {"role": "assistant", "content": fin["text"], "tool_calls": []})
+            emit(on_event, "assistant", fin["text"], tag)
+            give {"messages": msgs, "text": fin["text"], "steps": steps, "usage": usage, "stopped": "too_many_errors"}
+    set stopped to when spent > budget then "budget" otherwise "max_steps"
+    give {"messages": msgs, "text": final_text, "steps": steps, "usage": usage, "stopped": stopped}
+
+-- Opciones por defecto (leen env: LAMPSON_MAX_STEPS, LAMPSON_BUDGET_TOKENS, LAMPSON_PERMISSION, LAMPSON_COMPACT_AT)
+export task default_opts(registry, catalog, ask_fn)
+    require env("LAMPSON_*")
+    give {
+        "max_steps": floor(number(env("LAMPSON_MAX_STEPS", "60"))),
+        "budget_tokens": number(env("LAMPSON_BUDGET_TOKENS", "400000")),
+        "permission_mode": lower(env("LAMPSON_PERMISSION", "ask")),
+        "compact_at_tokens": number(env("LAMPSON_COMPACT_AT", "80000")),
+        "ask_fn": ask_fn,
+        "registry": registry,
+        "catalog": catalog,
+        "inbox_fn": nothing,
+        "tag": ""
+    }
+
+-- copia de opts con una clave cambiada (los maps son valores: no hay mutación compartida)
+task with_key(opts, key, value)
+    let out be {}
+    each k in keys(opts)
+        set out[k] to opts[k]
+    set out[key] to value
+    give out
+
+export task with_mode(opts, mode)
+    give with_key(opts, "permission_mode", mode)
+
+export task with_steps(opts, n)
+    give with_key(opts, "max_steps", floor(n))
+
+export task with_inbox(opts, inbox_fn, tag)
+    give with_key(with_key(opts, "inbox_fn", inbox_fn), "tag", tag)
+
+export task with_ask(opts, ask_fn)
+    give with_key(opts, "ask_fn", ask_fn)