telar 0.1.0__tar.gz

telar-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nicolás Rivas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

telar-0.1.0/MANIFEST.in

@@ -0,0 +1,10 @@
+# El sdist lleva el proyecto entero: el ejemplo y las pruebas son parte de lo que se
+# revisa antes de instalar algo que va a hablar con tu terminal.
+include LICENSE NOTICE README.md
+recursive-include docs *.md
+recursive-include ejemplo *
+recursive-include pruebas *.py
+recursive-include vscode *.json *.md *.ts *.svg
+prune vscode/node_modules
+prune vscode/out
+global-exclude __pycache__/* *.pyc

telar-0.1.0/NOTICE

@@ -0,0 +1,29 @@
+telar
+Copyright (c) 2026 Nicolás Rivas
+Licensed under the MIT License (see LICENSE).
+
+────────────────────────────────────────────────────────────────────────────
+
+Acknowledgements
+
+telar grew out of a private system where the project bar was a zellij plugin —
+a fork of cfal/zellij-vertical-tabs:
+
+    zellij-vertical-tabs
+    https://github.com/cfal/zellij-vertical-tabs
+    Copyright (c) cfal
+    MIT License
+
+No code from that project ships in telar: the bar was rewritten as a separate
+view, and telar itself is the engine underneath. The debt is real anyway — the
+idea of tabs as a vertical list of projects, and the first working version of
+it, came from there.
+
+────────────────────────────────────────────────────────────────────────────
+
+Dependencies
+
+PyYAML — MIT License. https://pyyaml.org/
+    Used to read the work repository's telar-perfil.yaml.
+
+Everything else telar uses is in the Python standard library.

telar-0.1.0/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: telar
+Version: 0.1.0
+Summary: Un telar para hilos de trabajo: multiplexor de terminal, perfiles de repositorio y agentes.
+Author: Nicolás Rivas
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/nicorivas/telar
+Project-URL: Source, https://github.com/nicorivas/telar
+Keywords: tmux,zellij,terminal,workspace,agents
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML>=6.0
+Dynamic: license-file
+
+# telar
+
+A loom for threads of work.
+
+You keep twenty terminal tabs open. Each one is a different piece of work, each has
+an agent running in it, and after a reboot you cannot tell which is which. `telar`
+turns those tabs into **threads**: a tab, a folder, and whatever that folder says
+about itself, held together across restarts.
+
+**telar does not decide what a project is.** That is the point. Your work
+repository declares it, in a `telar-perfil.yaml` that ships with the repo — which
+folders are units of work, which file is their face, which sections of that file
+can be read, and which actions the repo offers. Any telar that opens the repo
+weaves the same thing.
+
+## Status
+
+Early, but it runs. Configuration, profile, model and state are in place, the
+commands are written, and every `--json` output is a documented contract
+([docs/contratos.md](docs/contratos.md)). `telar --help` lists what there is, and
+says so plainly when you ask for something that isn't written yet.
+
+## Install
+
+```sh
+pip install telar          # once it's published
+pip install -e .           # from a clone
+telar --version
+```
+
+Python 3.11+. Standard library only, except PyYAML for reading the profile. A
+terminal multiplexer (tmux 3.0+ or zellij 0.45+) does the actual work of holding tabs.
+
+## Try it
+
+Two ways in. **From a clone**, an invented workspace ships with the repo, so you can
+look at a real profile without using anyone's data:
+
+```sh
+git clone https://github.com/nicorivas/telar && cd telar
+telar --raiz ejemplo perfil              # what the example workspace declares
+telar --raiz ejemplo pendientes --repo   # what those invented projects still owe
+```
+
+**From an install**, start in your own repository — `init` writes a profile you can edit
+and a config file, and touches nothing else:
+
+```sh
+cd ~/work/your-repo
+telar init                         # profile + config, both yours to edit
+telar doctor                       # what is missing on this machine, and how to fix it
+telar --help
+```
+
+(`pip install telar` ships the package, not the example; the example travels with the
+source distribution and the clone.)
+
+## A day of it
+
+```sh
+telar init                 # write the config, find the multiplexer, prepare the state
+telar tejer                # raise the session
+telar vincular proyectos/faro      # this thread is that folder
+telar hilos                # everything open, with the state each folder reports
+telar ficha faro           # what that folder says about itself
+telar pendientes           # what is left to do, across threads
+telar pendiente faro:2     # take that one to the thread where the work lives
+telar hoy                  # the day in one screen
+```
+
+Two of them are meant to be called by other programs, not by you:
+`telar tiempo marcar` from the multiplexer whenever the focused tab changes, and
+`telar atencion set espera` from the agent when it needs you. `telar doctor` checks
+whether either is wired.
+
+## Wiring the agent
+
+The agent working inside a tab can report what it is doing, and telar writes those
+hooks into the agent's own configuration — for Claude Code, `~/.claude/settings.json`.
+That file belongs to another program, so the command prints the path and the diff and
+waits for a yes:
+
+```sh
+telar agente instalar                    # show the path and the diff, then ask
+telar agente instalar --seco             # what it would write, writing nothing
+telar agente instalar --ajustes FILE     # into that file instead of the user's
+telar agente instalar --ejecutable PATH  # how the hook should call telar back
+telar agente instalar --si               # write without asking (--json skips it too)
+telar agente desinstalar                 # take telar's hooks out, leave the rest
+```
+
+It merges with the hooks that were already there, keeps a backup beside the file, and
+refuses to write a hook that points at a telar which will not outlive it — one running
+from a temporary virtualenv, say. The six events are in
+[`docs/agentes.md`](docs/agentes.md).
+
+## How it fits together
+
+| Piece | Whose | Where |
+|---|---|---|
+| Configuration — multiplexer, session, working root, providers | yours, per machine | `~/.config/telar/config.toml` ([docs](docs/configuracion.md)) |
+| Profile — what a unit of work is, and what can be read from it | the work repository's, versioned with it | `telar-perfil.yaml` ([docs](docs/perfil.md)) |
+| Threads, fichas, attention | derived, disposable | `~/.local/state/telar` |
+
+## What it will not do
+
+- **No telemetry.** No usage reports, no phone-home, no auto-update.
+- **No network** beyond what a provider declares — and no provider exists until
+  your configuration names it.
+- **No writing to your work repository** unless you ask. Derived state lives
+  elsewhere and can be deleted without losing anything.
+- **No silent writes anywhere else, either.** One command edits another program's
+  configuration — `telar agente instalar` — and it shows the path and the diff and
+  waits for a yes. `--si` is how you say it in a script.
+- **No guessed commands.** It runs the actions the profile declares, as argument
+  lists, without a shell in between.
+
+## Documentation
+
+Docs are in Spanish, the language this is written in.
+
+- [`docs/configuracion.md`](docs/configuracion.md) — the config file, key by key.
+- [`docs/perfil.md`](docs/perfil.md) — the profile schema, and the minimal
+  convention that applies when there is no profile.
+- [`docs/contratos.md`](docs/contratos.md) — the shapes telar passes around, written
+  so an outside program can produce them. Today: a thread's state.
+- [`docs/agentes.md`](docs/agentes.md) — the six events an agent reports, and what
+  another agent would have to do to integrate.
+- [`docs/publicar.md`](docs/publicar.md) — how a version gets out: what to set up
+  once, and the runbook per release.
+- [`ejemplo/`](ejemplo/) — a small invented workspace.
+- [`CHANGELOG.md`](CHANGELOG.md) — what changed, version by version.
+
+## License
+
+MIT — see [LICENSE](LICENSE) and [NOTICE](NOTICE).

telar-0.1.0/README.md

@@ -0,0 +1,136 @@
+# telar
+
+A loom for threads of work.
+
+You keep twenty terminal tabs open. Each one is a different piece of work, each has
+an agent running in it, and after a reboot you cannot tell which is which. `telar`
+turns those tabs into **threads**: a tab, a folder, and whatever that folder says
+about itself, held together across restarts.
+
+**telar does not decide what a project is.** That is the point. Your work
+repository declares it, in a `telar-perfil.yaml` that ships with the repo — which
+folders are units of work, which file is their face, which sections of that file
+can be read, and which actions the repo offers. Any telar that opens the repo
+weaves the same thing.
+
+## Status
+
+Early, but it runs. Configuration, profile, model and state are in place, the
+commands are written, and every `--json` output is a documented contract
+([docs/contratos.md](docs/contratos.md)). `telar --help` lists what there is, and
+says so plainly when you ask for something that isn't written yet.
+
+## Install
+
+```sh
+pip install telar          # once it's published
+pip install -e .           # from a clone
+telar --version
+```
+
+Python 3.11+. Standard library only, except PyYAML for reading the profile. A
+terminal multiplexer (tmux 3.0+ or zellij 0.45+) does the actual work of holding tabs.
+
+## Try it
+
+Two ways in. **From a clone**, an invented workspace ships with the repo, so you can
+look at a real profile without using anyone's data:
+
+```sh
+git clone https://github.com/nicorivas/telar && cd telar
+telar --raiz ejemplo perfil              # what the example workspace declares
+telar --raiz ejemplo pendientes --repo   # what those invented projects still owe
+```
+
+**From an install**, start in your own repository — `init` writes a profile you can edit
+and a config file, and touches nothing else:
+
+```sh
+cd ~/work/your-repo
+telar init                         # profile + config, both yours to edit
+telar doctor                       # what is missing on this machine, and how to fix it
+telar --help
+```
+
+(`pip install telar` ships the package, not the example; the example travels with the
+source distribution and the clone.)
+
+## A day of it
+
+```sh
+telar init                 # write the config, find the multiplexer, prepare the state
+telar tejer                # raise the session
+telar vincular proyectos/faro      # this thread is that folder
+telar hilos                # everything open, with the state each folder reports
+telar ficha faro           # what that folder says about itself
+telar pendientes           # what is left to do, across threads
+telar pendiente faro:2     # take that one to the thread where the work lives
+telar hoy                  # the day in one screen
+```
+
+Two of them are meant to be called by other programs, not by you:
+`telar tiempo marcar` from the multiplexer whenever the focused tab changes, and
+`telar atencion set espera` from the agent when it needs you. `telar doctor` checks
+whether either is wired.
+
+## Wiring the agent
+
+The agent working inside a tab can report what it is doing, and telar writes those
+hooks into the agent's own configuration — for Claude Code, `~/.claude/settings.json`.
+That file belongs to another program, so the command prints the path and the diff and
+waits for a yes:
+
+```sh
+telar agente instalar                    # show the path and the diff, then ask
+telar agente instalar --seco             # what it would write, writing nothing
+telar agente instalar --ajustes FILE     # into that file instead of the user's
+telar agente instalar --ejecutable PATH  # how the hook should call telar back
+telar agente instalar --si               # write without asking (--json skips it too)
+telar agente desinstalar                 # take telar's hooks out, leave the rest
+```
+
+It merges with the hooks that were already there, keeps a backup beside the file, and
+refuses to write a hook that points at a telar which will not outlive it — one running
+from a temporary virtualenv, say. The six events are in
+[`docs/agentes.md`](docs/agentes.md).
+
+## How it fits together
+
+| Piece | Whose | Where |
+|---|---|---|
+| Configuration — multiplexer, session, working root, providers | yours, per machine | `~/.config/telar/config.toml` ([docs](docs/configuracion.md)) |
+| Profile — what a unit of work is, and what can be read from it | the work repository's, versioned with it | `telar-perfil.yaml` ([docs](docs/perfil.md)) |
+| Threads, fichas, attention | derived, disposable | `~/.local/state/telar` |
+
+## What it will not do
+
+- **No telemetry.** No usage reports, no phone-home, no auto-update.
+- **No network** beyond what a provider declares — and no provider exists until
+  your configuration names it.
+- **No writing to your work repository** unless you ask. Derived state lives
+  elsewhere and can be deleted without losing anything.
+- **No silent writes anywhere else, either.** One command edits another program's
+  configuration — `telar agente instalar` — and it shows the path and the diff and
+  waits for a yes. `--si` is how you say it in a script.
+- **No guessed commands.** It runs the actions the profile declares, as argument
+  lists, without a shell in between.
+
+## Documentation
+
+Docs are in Spanish, the language this is written in.
+
+- [`docs/configuracion.md`](docs/configuracion.md) — the config file, key by key.
+- [`docs/perfil.md`](docs/perfil.md) — the profile schema, and the minimal
+  convention that applies when there is no profile.
+- [`docs/contratos.md`](docs/contratos.md) — the shapes telar passes around, written
+  so an outside program can produce them. Today: a thread's state.
+- [`docs/agentes.md`](docs/agentes.md) — the six events an agent reports, and what
+  another agent would have to do to integrate.
+- [`docs/publicar.md`](docs/publicar.md) — how a version gets out: what to set up
+  once, and the runbook per release.
+- [`ejemplo/`](ejemplo/) — a small invented workspace.
+- [`CHANGELOG.md`](CHANGELOG.md) — what changed, version by version.
+
+## License
+
+MIT — see [LICENSE](LICENSE) and [NOTICE](NOTICE).

telar-0.1.0/docs/agentes.md

@@ -0,0 +1,204 @@
+# Los agentes
+
+Adentro de un hilo casi siempre hay un agente de línea de comandos trabajando. telar
+**no lo lanza ni lo pilota**: lo reconoce, se entera de en qué anda, y recuerda qué
+conversación vive en qué tab para poder volver a abrirla mañana.
+
+Este documento dice qué tiene que hacer un agente —cualquiera— para integrarse.
+
+## Los seis eventos
+
+Todo el contrato cabe en seis palabras. Un agente avisa; telar anota.
+
+| Evento | Cuándo lo manda | Qué deja escrito |
+|---|---|---|
+| `abre` | arrancó una conversación | este hilo tiene esta conversación, en este panel |
+| `empieza` | se puso a trabajar | atención: `trabajando` |
+| `espera` | necesita a la persona | atención: `espera` |
+| `sigue` | dio señales de vida (corrió una herramienta) | desmiente un `espera` anterior; nada más |
+| `termina` | acabó la respuesta | atención: `termino` |
+| `cierra` | la sesión se acabó | atención: `ninguna` |
+
+Los cuatro del medio son exactamente lo que escribe `telar atencion set`: el evento es
+la forma automática de lo mismo que se puede decir a mano. `abre` y `cierra` no hablan
+de atención sino del **registro de conversación por panel**.
+
+Tres reglas que están en el código y no se negocian:
+
+* **`sigue` no afirma, desmiente.** Una herramienta ejecutada no significa «empecé»;
+  significa «si te dije que te esperaba, ya no». Cualquier otra lectura pisa un
+  `espera` legítimo que todavía nadie resolvió.
+* **Lo que no cambia no se escribe.** Del otro lado hay una barra vigilando el
+  archivo: reescribir `trabajando` sobre `trabajando` la despierta para nada.
+* **Al `cierra` no se borra la conversación.** Se apaga el semáforo y se deja anotada:
+  es exactamente la que se va a querer retomar mañana. Quien quiera olvidarla del todo
+  lo pide (`telar agente aviso --olvidar`).
+
+## El camino corto: un comando por evento
+
+Un agente que sepa correr un comando ya puede integrarse, sin escribir una línea de
+Python y en cualquier lenguaje:
+
+```sh
+telar agente aviso --evento abre --sesion "$ID_DE_LA_CONVERSACION"
+telar agente aviso --evento empieza
+telar agente aviso --evento espera
+telar agente aviso --evento sigue
+telar agente aviso --evento termina
+telar agente aviso --evento cierra --sesion "$ID_DE_LA_CONVERSACION"
+```
+
+Para los cuatro del medio, `telar atencion set trabajando|espera|termino|ninguna` hace
+lo mismo y se lee mejor. `abre` es el que de verdad conviene mandar: es lo que después
+permite `telar agente retomar`.
+
+### Cómo sabe telar en qué hilo pasó
+
+En este orden, y **nunca por el foco**:
+
+1. `--hilo`, si se dijo;
+2. `$TELAR_HILO`, que el multiplexor exportó al abrir el tab y el agente heredó;
+3. al **abrir**, el panel donde corre el agente (`$TELAR_PANEL`, o `$ZELLIJ_PANE_ID` /
+   `$TMUX_PANE`): una conversación que se retoma en otro tab tiene que mudarse con él,
+   y el panel es lo único que lo dice;
+4. la conversación ya anotada, que para todo lo demás es exacta y no cuesta nada;
+5. el panel otra vez, como último recurso.
+
+El foco no está en la lista a propósito. La persona se va a otro tab mientras el agente
+trabaja, y ese es justamente el momento en que se dispara un evento: anotar «el que
+tiene el foco» le pone la atención —o peor, la conversación— al hilo equivocado.
+
+Lo barato es que el multiplexor exporte `TELAR_HILO` al crear el tab. Con eso, ningún
+evento necesita preguntarle nada a nadie.
+
+### Las reglas del gancho
+
+Quien enganche `telar agente aviso` en su agente hereda tres cuidados que ya están
+resueltos de este lado, pero conviene saber por qué:
+
+* **callado**: no imprime nada salvo que se le pida `--json`. Hay agentes que meten la
+  salida de sus ganchos en su propio contexto, y un gancho charlatán le habla al agente;
+* **siempre sale con 0**: un gancho que falla no puede frenar a quien lo llamó. Una
+  carga rota, un disco lleno o un hilo que no se puede resolver terminan todos en el
+  mismo lugar: no hacer nada;
+* **no levanta el multiplexor si no hace falta**: preguntarle cuesta subprocesos y hay
+  eventos que se disparan a cada herramienta.
+
+## El camino completo: un adaptador
+
+Vale la pena cuando el agente ya manda una carga con todo adentro (como los *hooks* de
+Claude Code) o cuando además se quiere `retomar`, `nuevo` e instalador.
+
+Un adaptador es un módulo que hereda de `telar.agente.base.AgenteBase` y se registra:
+
+```python
+from telar.agente import registrar
+from telar.agente.base import AgenteBase, Aviso, Evento
+
+class MiAgente(AgenteBase):
+    nombre = "mi-agente"
+    comandos = ("mi-agente",)          # lo que delata al proceso en el panel
+
+    def leer_aviso(self, crudo, *, evento=None):
+        return Aviso(
+            evento=evento or MOMENTOS[crudo["tipo"]],
+            agente=self.nombre,
+            sesion=str(crudo.get("id", "")),
+        )
+
+    def retomar(self, conversacion):   # devuelve el comando, NO lo corre
+        return ["mi-agente", "--continuar", conversacion.id]
+
+    def nuevo(self, ruta=None):
+        return ["mi-agente"]
+
+registrar("mi-agente", lambda config: MiAgente(config))
+```
+
+Eso es todo lo obligatorio. De `AgenteBase` vienen hechos `corriendo`,
+`conversaciones`, `anotar` y `atencion`, y de `telar.agente.base` la traducción entera
+(`atencion_de`, `resolver_hilo`, `aplicar`), que es la misma para todos.
+
+Opcional, y recomendado en este orden:
+
+| Método | Para qué |
+|---|---|
+| `archivo_de(conversacion)` | dónde quedó el registro de esa conversación en disco |
+| `ganchos()` | qué eventos nativos hay que enganchar (`Gancho`) |
+| `ruta_ajustes()` | dónde vive la configuración del agente en esta máquina |
+| `instalar()` / `desinstalar()` | escribir y sacar los ganchos por el usuario |
+
+Si el adaptador viene con telar, se agrega a `telar.agente.INCLUIDOS` (nombre → módulo)
+y se importa solo al pedirlo. Uno de afuera no necesita estar ahí: le basta con que
+algo lo importe para que su `registrar` corra.
+
+### Cuatro cosas que conviene no improvisar
+
+* **Reconocer al agente se hace por el proceso, nunca por el título del panel.** Un
+  título miente en cuanto alguien lo renombra. `AgenteBase.corriendo` mira el comando
+  palabra por palabra, porque muchos agentes se distribuyen como un script que arranca
+  otra cosa (`node …/claude`).
+* **`retomar` y `nuevo` devuelven el comando y no lo corren.** Quién lo corre y en qué
+  panel es de quien tenga el foco puesto ahí.
+* **El vínculo se anota cuando el agente arranca, no cuando se necesita.** Al resucitar
+  una sesión el multiplexor relanza el comando y el agente abre una conversación
+  *nueva*; si nadie anotó nada al arrancar, veinte hilos en la misma carpeta son
+  indistinguibles.
+* **Un panel corre una conversación a la vez.** Por eso `abre` manda el panel: es lo
+  único que permite darse cuenta de que la anterior murió (un `/clear`, o salir y
+  volver a entrar) y sacarla del hilo. Sin eso, un hilo acumula conversaciones muertas
+  y `retomar` abre la equivocada.
+
+## El adaptador incluido: Claude Code
+
+Es el único que viene de fábrica. Traduce así:
+
+| Momento de Claude Code | Evento |
+|---|---|
+| `SessionStart` | `abre` |
+| `UserPromptSubmit` | `empieza` |
+| `Notification` | `espera` |
+| `PostToolUse` | `sigue` |
+| `SubagentStop` | `sigue` |
+| `Stop` | `termina` |
+| `SessionEnd` | `cierra` |
+
+Son siete momentos y **seis** ganchos: `SubagentStop` se entiende si llega, pero no se
+engancha —un subagente que termina no cambia en qué está la conversación—, así que en tu
+`settings.json` vas a contar seis. Los seis apuntan al **mismo** comando —`telar agente aviso
+claude-code`— y cuál fue viene en el JSON que Claude Code le manda por la entrada
+estándar (`hook_event_name`). Una sola línea que mantener.
+
+```sh
+telar agente instalar              # los escribe en ~/.claude/settings.json
+telar agente instalar --seco       # muestra cómo quedaría el archivo, sin tocarlo
+telar agente instalar --ajustes ./settings.json
+telar agente desinstalar           # saca los de telar, deja los ajenos
+telar agente ver                   # qué hay puesto, y qué sabe telar de este hilo
+```
+
+El instalador **se mete en casa ajena y se porta como tal**: mezcla con los ganchos que
+ya estaban y solo reemplaza los suyos (se reconocen por su comando), deja un respaldo
+`settings.json.telar.bak` antes de tocar nada, escribe a un temporal que después
+renombra, y ante un JSON que no entiende se niega a escribir en vez de pisarlo. Los
+ganchos recién puestos los lee Claude Code al arrancar de nuevo.
+
+Ese respaldo **no se pisa nunca**: si el nombre ya está ocupado —un segundo `instalar`, o
+el `desinstalar` que viene después—, el nuevo sale fechado
+(`settings.json.telar.20260919-142530.bak`). Así el retrato del archivo *antes* de telar
+sobrevive justo a la orden que deshace telar. Y la copia hereda los permisos del
+original: una configuración que era privada sigue siéndolo.
+
+Dos detalles de Claude Code que se pagan si no se saben: la carpeta de configuración es
+`~/.claude` salvo que `$CLAUDE_CONFIG_DIR` diga otra, y las conversaciones se guardan en
+`projects/<carpeta con la ruta aplanada>/<id>.jsonl`. Cómo se aplana esa ruta es cosa
+suya y cambia sin avisar, así que telar no la reconstruye: busca el archivo por su
+nombre, que es el id.
+
+## Qué NO hace telar con el agente
+
+* no lo lanza ni lo mata: abrir un panel y correr algo ahí es del multiplexor;
+* no lee sus conversaciones —sabe dónde están, y nada más—;
+* no le manda nada por la red, ni le cuenta a nadie qué se hizo;
+* no le escribe en la entrada sin que se lo pidan: `escribir` deja el texto puesto y la
+  última palabra es siempre de la persona.