@joaomj/pi-attention-span 0.8.0

package/PI.md

@@ -0,0 +1,46 @@
+# Attention Span for Pi
+
+This fork adds [Pi coding agent](https://pi.dev) support to
+[attention-span](https://github.com/alexgreensh/attention-span) (v0.8, AGPL-3.0):
+the same three output styles plus `/tldr`, installable as a Pi package.
+Upstream files are untouched; Pi support lives in `package.json`,
+`extensions/`, `scripts/gen-pi.py`, and this file, so upstream merges stay clean.
+
+## Install
+
+```bash
+pi install git:github.com/joaomj/attention-span
+```
+
+Then `/reload` in a running session. The package provides:
+
+- `/style` — persistent output style switcher (`attention-kind`, `spartan`,
+  `rundown`, or back to `Default`). Off by default: zero passive context
+  until you opt in. The choice persists in `attention-span.json` and takes
+  effect on the next request.
+- `/skill:attention-kind`, `/skill:spartan`, `/skill:rundown`, `/skill:tldr` —
+  on-demand versions of the same wording, loaded only when invoked.
+
+## Update
+
+```bash
+pi update --extensions
+```
+
+To pull in new upstream styles after a merge from upstream, regenerate the
+embedded style bodies and commit the result:
+
+```bash
+python3 scripts/gen-pi.py
+```
+
+This keeps the `/style` extension byte-identical to the on-demand skills.
+
+## Layout
+
+| Path | Purpose |
+|---|---|
+| `extensions/attention-span.ts` | Hand-written `/style` command + per-run injection |
+| `extensions/styles.generated.ts` | Style bodies generated from `skills/*/SKILL.md` (do not edit) |
+| `skills/` | Upstream on-demand skills, advertised to Pi as-is |
+| `scripts/gen-pi.py` | Regenerates the above from skills + syncs the package version |

package/README.es-ES.md

@@ -0,0 +1,240 @@
+
+
+<p align="center">
+  <img src="assets/banner.svg" alt="Attention Span — presta atención, no tokens" width="820">
+</p>
+
+<p align="center">
+  <a href="https://github.com/alexgreensh/attention-span/releases"><img src="https://img.shields.io/github/v/release/alexgreensh/attention-span?label=versi%C3%B3n&color=6f42c1" alt="Última versión"></a>
+  <img src="https://img.shields.io/github/directory-file-count/alexgreensh/attention-span/output-styles?type=file&extension=md&label=estilos&color=blue" alt="estilos">
+  <img src="https://img.shields.io/badge/trabajo-intacto-2ea44f" alt="trabajo intacto (benchmark con tests ocultos)">
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/alexgreensh/attention-span?color=orange" alt="AGPL-3.0"></a>
+  <img src="https://img.shields.io/badge/para-Claude%20Code-d97757" alt="Para Claude Code">
+  <a href="https://github.com/alexgreensh/attention-span/stargazers"><img src="https://img.shields.io/github/stars/alexgreensh/attention-span?style=social" alt="Estrellas"></a>
+</p>
+
+<p align="center"><img src="assets/hero.png" alt="Mascota de Attention Span" width="900"></p>
+
+<p align="center"><a href="README.md">English</a> · <b>Español</b> · <a href="README.zh-CN.md">中文</a></p>
+
+Una pequeña colección de [estilos de salida](https://code.claude.com/docs/en/output-styles) para Claude Code que cambian *cómo te habla*, no cómo codifica. Primero la respuesta, lenguaje claro, fácil de escanear. Cada uno es un único archivo markdown que añades y activas.
+
+Las reglas de concisión por defecto cuidan tu atención primero. Reducir la salida de Claude es un efecto secundario bienvenido, no el objetivo.
+
+Tres hasta ahora: **Attention-kind** (el principal), **Spartan** (conciso, cero calidez) y **Rundown** (informes breves). Cada uno tiene su propia sección a continuación.
+
+## Attention-kind
+
+Un estilo apto para TDAH. Claude responde primero, se mantiene breve, elimina la jerga técnica y solo amplía lo que realmente merece tu atención. Cada punto está espaciado y marcado con un `→`, y las palabras importantes están en **negrita**, para que puedas escanear solo lo en negrita y obtener la respuesta completa.
+
+La misma capacidad de ingeniería por debajo. Solo cambia la forma de entrega.
+
+**Para quién es:** para cualquiera cuya atención sea un recurso limitado. TDAH, cansado, en pleno estado de flujo o simplemente harto de muros de texto.
+
+### Antes / después
+
+La pregunta: **"¿Qué base de datos debería usar para una nueva aplicación social, PostgreSQL o MongoDB?"** La misma respuesta, antes y después del estilo.
+
+<table>
+<tr>
+<th align="left" width="50%">Predeterminado &nbsp;·&nbsp; 430 palabras</th>
+<th align="left" width="50%">Attention-kind &nbsp;·&nbsp; 94 palabras</th>
+</tr>
+<tr valign="top">
+<td>
+
+Para una nueva aplicación social, comienza con PostgreSQL, y el umbral para elegir MongoDB en su lugar es alto. Las apps sociales son intensas en relaciones por naturaleza: los usuarios siguen a otros usuarios, las publicaciones pertenecen a usuarios, los comentarios pertenecen a publicaciones, los likes conectan usuarios con publicaciones. Es una red de conexiones, exactamente para lo que se construyó una base de datos relacional. En MongoDB, o metes los datos relacionados en un solo registro y luchas con los límites de tamaño, o los separas y terminas uniéndolos de nuevo en el código de tu app de todos modos. El problema del feed empeora esto: las cronologías, "publicaciones de personas que sigues" y búsquedas de amigos mutuos dependen del tipo de cruzamiento de referencias que Postgres hace en una sola consulta. También obtienes consistencia gratis, ya que los conteos de seguidores y las verificaciones de "¿ya me gustó esto?" requieren transacciones reales… *[y continúa así]*
+
+</td>
+<td>
+
+**→ Usa PostgreSQL.** Una app social son todas relaciones (amigos, seguidores, likes), y Postgres las maneja de forma nativa. Apta para ~90% de las nuevas apps sociales.
+
+**→ Mantienes flexibilidad.** Su columna JSONB almacena datos sin esquema dentro de la misma base de datos, así que obtienes la flexibilidad de MongoDB sin salir de Postgres.
+
+**→ Elige MongoDB solo si** tus datos son documentos autónomos sin enlaces, y necesitas un volumen masivo de escritura desde el día uno.
+
+**→ La trampa temprana con MongoDB:** a los seis meses, cinco formas diferentes de "usuario" y sin solución limpia. Postgres impone la estructura.
+
+**→ Siguiente:** comienza con Postgres gestionado (Supabase, Neon, RDS).
+
+</td>
+</tr>
+</table>
+
+La misma información. Una de ellas puedes leerla de un vistazo.
+
+### ¿Realmente ayuda? (medido y reproducible)
+
+El benchmark mide el trabajo y la salida por separado, y las cifras principales no usan **ningún juez LLM**. Cada número es reproducible desde este repositorio. [Explicación completa y harness ejecutable.](benchmarks/results/2026-08-11-benchmark.md)
+
+- **El trabajo queda intacto.** 12 tareas de código con suites de tests ocultos, con estilo y sin estilo: las tasas de acierto son iguales (**ambas 97%**, dentro del ruido). Sin juez, solo tests que pasan.
+- **~43% menos de salida** de media (mediana 41%), y **50-71% en respuestas extensas** donde importa; las respuestas ya cortas apenas cambian.
+- **Llegas al punto en ~6 palabras en lugar de ~40.** La respuesta está en la primera línea el **75%** de las veces frente al **3%**. (Los índices de legibilidad no aplican, solo miden la longitud de las palabras y no ven un muro de texto.)
+- **Los entregables salen limpios el 88% de las veces** frente al 12% sin estilo: pides un mensaje o un commit y obtienes justo eso, sin envoltorio.
+
+Es más corto, más claro y fácil de captar de un vistazo, con el trabajo intacto. No afirmamos que produzca mejores respuestas, no es para eso.
+
+### ¿Qué cambia?
+
+- **Respuesta primero.** Conclusión en la primera línea. Sin preámbulo.
+- **Breve por defecto.** Dice lo mínimo necesario para responder completamente, y se detiene.
+- **Amplía solo lo vital**, para que la longitud en sí misma señale importancia.
+- **Lenguaje claro.** Los términos técnicos raros obtienen una definición de cinco palabras, una sola vez.
+- **Diseñado para escanear.** Marcadores `→`, negritas pesadas, espaciado real entre puntos.
+- **Sin repeticiones.** Cada punto hace un argumento distinto, nunca se reitera ni se reargumenta.
+- **Re-anclaje en tareas largas** y hace una pregunta a la vez, para que nunca pierdas el hilo.
+- **También los comentarios.** Los comentarios de código heredan la regla de lenguaje claro de "explicar el porqué", pero nunca el formato de chat.
+
+## Spartan
+
+<p align="center"><img src="assets/cat-spartan.png" alt="Un gato con casco espartano apunta su láser a una línea iluminada" width="860"></p>
+
+Modo conciso con la calidez eliminada. Mismas flechas y negritas que Attention-kind, pero directo e imperativo, sin suavizantes, sin transiciones, máxima compresión. Para trabajo enfocado cuando quieres señal, no conversación.
+
+La pregunta: **"Tres prioridades esta semana, espacio para dos, ¿cómo decido qué cortar?"** Ambos son salidas reales de evaluación de Opus 5.
+
+<table>
+<tr>
+<th align="left" width="50%">Predeterminado &nbsp;·&nbsp; 310 palabras</th>
+<th align="left" width="50%">Spartan &nbsp;·&nbsp; 168 palabras</th>
+</tr>
+<tr valign="top">
+<td>
+
+Corta la que falle la prueba más barata: si se retrasa una semana, quién realmente lo siente y cuánto. Pasa las tres por cuatro filtros rápidos y el perdedor suele caerse por su cuenta. Consecuencia del retraso: dos de tus tres probablemente tienen fechas límite blandas que inventaste y una tiene una real, una persona esperando, una dependencia aguas abajo, una ventana que se cierra. Corta de la pila autoimpuesta, nunca de la pila donde alguien está bloqueado por ti. Reversibilidad: algunas cosas se vuelven más difíciles cuanto más esperan, otras son exactamente igual de fáciles la semana que viene, así que corta la cuya curva de costo es plana. Quién la posee además de tú: si una prioridad puede delegarse o hacerse al 80% por otro, es un mejor corte que una que solo tú puedes hacer… *[y continúa así]*
+
+</td>
+<td>
+
+**→ Ordena por el costo de NO hacerlo, no por esfuerzo o interés.** Pregunta a cada una: qué se rompe si esto se retrasa una semana. La que tenga la consecuencia más blanda se corta.
+
+**→ Elimina la reversible.** Si una tarea puede esperar, delegarse o reiniciarse después sin penalización, córtala. Protege lo que tenga una **fecha límite dura** o una **dependencia** donde otros estén bloqueados por ti.
+
+**→ Haz la prueba del arrepentimiento.** Viernes por la noche, ¿qué tarea sin hacer duele más? Quédate con esa. La que haría que fruncieras el ceño es tu corte.
+
+**→ Separa lo ruidoso de lo importante.** La prioridad que te grita a menudo es solo la más **ansiosa**, no la más valiosa. Corta por impacto, no por volumen.
+
+**→ No hagas las tres a medias.** Dos terminadas superan a tres al 66%. El trabajo parcial en la tercera es la trampa, se siente productivo y no entrega nada.
+
+**→ Córtalo en voz alta.** Dile a quien esté afectado ahora, no el viernes. Un corte que se marca es una decisión, un corte que se esconde es un **fracaso con retraso**.
+
+</td>
+</tr>
+</table>
+
+La misma garantía de solo-estilo que Attention-kind: más corto, más escaneable, con el trabajo intacto. Ver el [benchmark](benchmarks/results/2026-08-11-benchmark.md).
+
+## Rundown
+
+<p align="center"><img src="assets/cat-rundown.png" alt="El gato de Rundown apunta su láser a una lista de verificación, una línea iluminada" width="860"></p>
+
+Estilo de informe breve. Se abre con un **TL;DR**, muestra el estado como una lista de verificación ✅ / 🟡 / ⬜, etiqueta las siguientes opciones con emojis. Diseñado para actualizaciones de estado y reuniones diarias. **Optimiza la legibilidad y el escaneo, no la brevedad**, así que úsalo cuando la claridad sea más importante que la longitud. Incluye un mecanismo para evitar inventar estados que no se le dieron.
+
+La pregunta: **"Resume en qué va la contratación: 20 candidatos, 5 filtrados, 2 entrevistas, sin oferta, un candidato fuerte que se escapa."** Ambos son salidas reales de evaluación de Opus 5.
+
+<table>
+<tr>
+<th align="left" width="50%">Predeterminado &nbsp;·&nbsp; un párrafo que lees</th>
+<th align="left" width="50%">Rundown &nbsp;·&nbsp; un tablero que escaneas</th>
+</tr>
+<tr valign="top">
+<td>
+
+La contratación está en la parte superior del embudo y delgada en la inferior. Veinte solicitudes dentro, cinco filtradas, dos entrevistas reservadas. Aún no se ha enviado ninguna oferta, y esa brecha es el problema: uno de los candidatos más fuertes se está enfriando mientras el proceso se queda inactivo. Los números: solicitudes 20, filtradas 5, entrevistas reservadas 2, ofertas enviadas 0, en riesgo 1 candidato fuerte que se escapa. La lectura: esto es un problema de velocidad, no de suministro. El embudo es saludable arriba, pero nada se ha convertido en una oferta, y la mejor prospectiva se está desvaneciendo. El movimiento de mayor valor es acelerar al candidato que se escapa antes de que el retraso decida por nosotros. Cuello de botella: la etapa de oferta… *[y continúa así]*
+
+</td>
+<td>
+
+TL;DR: El embudo es saludable arriba pero la meta final se está estancando, y tu mejor candidato está a punto de marcharse.
+
+**Embudo de contratación**
+- ☑️ **Solicitudes recibidas:** 20 fuente
+- ☑️ **Filtrados:** 5 de 20 hechos
+- 🟡 **Entrevistas:** 2 reservadas, aún no realizadas
+- ⬜ **Oferta:** no redactada, no enviada
+
+🔴 **Bloqueo:** Un candidato fuerte se está escapando. Sin movimiento de oferta significa que los pierdes por defecto.
+
+**Tu jugada:**
+- 🚀 Acelera al candidato fuerte, salta directamente a hablar de oferta hoy
+- 📞 Realiza las 2 entrevistas reservadas antes de decidir
+- 📋 Filtra más de las 15 solicitudes sin tocar para tener respaldos
+- ✍️ Redacta la oferta ahora para que esté lista para enviar
+
+Elige uno: salva al candidato ahora, o ejecuta el proceso completo y arriesga perderlos?
+
+</td>
+</tr>
+</table>
+
+## ¿De verdad quieres reducir tu factura de tokens?
+
+Attention Span existe para que las respuestas de tus agentes sean legibles y fáciles de captar de un vistazo. La factura de tokens más ligera en esas respuestas es un efecto secundario bienvenido. Si reducir el gasto de tokens es tu verdadero objetivo, el costo mayor es el *trabajo* que hace tu agente, no cómo habla, y dos herramientas hermanas van directas a ello, combinando de forma natural con estos estilos:
+
+<p align="center"><img src="assets/save-tokens.png" alt="El mago Outsourcerer y el gato de Attention Span aspirando tokens fantasma con Token Optimizer" width="900"></p>
+
+**[Token Optimizer](https://github.com/alexgreensh/token-optimizer)** ataca las tres capas de desperdicio de tokens que la mayoría de las herramientas nunca tocan:
+
+- **Estructural**, p. ej. configuraciones infladas, skills sin usar, memoria obsoleta
+- **En ejecución**, p. ej. salida verbosa, relecturas
+- **De comportamiento**, p. ej. mal enrutamiento de modelos, expiración de caché, bucles de reintentos
+
+...y más en cada una. Además, comprime tu stack de salida, hace checkpoints y restaura tu trabajo para que tus sesiones sigan continuas a través de la compactación, y pone cada token y dólar ahorrado en un panel en vivo. También es la única herramienta que mide la calidad de tu contexto y se ajusta a ella, porque una sesión más barata que hace peor trabajo no es ningún ahorro.
+
+*Funciona en Claude Code, Codex, OpenCode, OpenClaw, Hermes y Copilot.*
+
+**[Outsourcerer](https://github.com/alexgreensh/outsourcerer)** — quédate en una sola sesión del agente que más te guste. En segundo plano:
+
+- ejecuta un escuadrón entre los modelos y harnesses que ya pagas
+- elige el mejor para cada tarea **por benchmark, no solo por precio**
+- revisa su trabajo y vigila tus límites en cada motor
+
+Tú mantienes la cabina; el trabajo pesado ocurre en otra parte.
+
+*Funciona en Claude Code, Codex, Antigravity, Devin, Droid, Cursor, Warp y Hermes.*
+
+Attention Span reduce cuánto dice Claude. Estas dos gobiernan lo que gasta todo tu stack.
+
+## Instalación
+
+**1.** Coloca el estilo en tu carpeta de output-styles. Global (para todos los proyectos):
+
+```bash
+mkdir -p ~/.claude/output-styles
+curl -o ~/.claude/output-styles/attention-kind.md \
+  https://raw.githubusercontent.com/alexgreensh/attention-span/main/output-styles/attention-kind.md
+```
+
+O colócalo en `.claude/output-styles/` dentro de un solo proyecto.
+
+**2.** Establécelo como predeterminado en `~/.claude/settings.json`. Haz esto una vez y estará activado en cada sesión, para siempre:
+
+```json
+{ "outputStyle": "Attention-kind" }
+```
+
+**3.** Reinicia o escribe `/clear`. Eso es todo.
+
+¿Quieres probarlo en una sesión primero? Ejecuta `/config` y selecciónalo bajo *Estilo de salida*, luego establece el predeterminado anterior una vez que estés convencido.
+
+**Costo:** ~650 tokens, añadidos una vez por sesión y almacenados en caché después de la primera solicitud. El benchmark midió ~43% menos de salida, así que el costo de entrada es insignificante tras la primera respuesta.
+
+## Los estilos
+
+| Estilo | Archivo | Mejor para |
+|---|---|---|
+| Attention-kind | [`output-styles/attention-kind.md`](output-styles/attention-kind.md) | TDAH, fatiga de atención, cualquiera cansado de muros de texto |
+| Spartan | [`output-styles/spartan.md`](output-styles/spartan.md) | Modo Spartan: máxima señal, cero calidez, trabajo enfocado |
+| Rundown | [`output-styles/rundown.md`](output-styles/rundown.md) | Informes breves, reuniones diarias, actualizaciones de progreso (TL;DR + casillas) |
+
+Cada uno es un archivo markdown legible, fácil de adaptar.
+
+## Notas
+
+- Los estilos se aplican **solo a la conversación principal**. Los subagentes ejecutan su propio prompt.
+- Estos mantienen intacto el comportamiento de codificación de Claude (`keep-coding-instructions: true`).
+
+## Licencia
+
+AGPL-3.0. Ver [LICENSE](LICENSE).

package/README.md

@@ -0,0 +1,339 @@
+<p align="center">
+  <img src="assets/banner.svg" alt="Attention Span — pay attention, not tokens" width="820">
+</p>
+
+<p align="center">
+  <a href="https://github.com/alexgreensh/attention-span/releases"><img src="https://img.shields.io/github/v/release/alexgreensh/attention-span?label=version&color=6f42c1" alt="Latest version"></a>
+  <img src="https://img.shields.io/github/directory-file-count/alexgreensh/attention-span/output-styles?type=file&extension=md&label=styles&color=blue" alt="styles">
+  <img src="https://img.shields.io/badge/work-unchanged-2ea44f" alt="work unchanged (hidden-test benchmark)">
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/alexgreensh/attention-span?color=orange" alt="AGPL-3.0"></a>
+  <img src="https://img.shields.io/badge/for-Claude%20Code-d97757" alt="For Claude Code">
+  <a href="https://github.com/alexgreensh/attention-span/stargazers"><img src="https://img.shields.io/github/stars/alexgreensh/attention-span?style=social" alt="Stars"></a>
+</p>
+
+<p align="center"><img src="assets/hero.png" alt="Attention Span mascot" width="900"></p>
+
+<p align="center"><b>English</b> · <a href="README.es-ES.md">Español</a> · <a href="README.zh-CN.md">中文</a></p>
+
+A small collection of [output styles](https://code.claude.com/docs/en/output-styles) for Claude Code that change how it *talks to you*, not how it codes. Answer-first, plain English, easy to skim. Each one is a single markdown file you drop in and switch on.
+
+The concise-by-default rules are kind to your attention first. Trimming Claude's output is a welcome side effect, not the point.
+
+Three so far: **Attention-kind** (the flagship), **Spartan** (terse, zero warmth), and **Rundown** (TL;DR briefings). Each has its own section below.
+
+## Attention-kind
+
+An ADHD-friendly style. Claude answers first, keeps it short, drops the jargon, and expands only on what's actually worth your attention. Every point is spaced out and marked with a `→`, and the important words are **bold**, so you can skim just the bold and still get the whole answer.
+
+Same engineering ability underneath. Only the delivery changes.
+
+**Who it's for:** anyone whose attention is a limited resource. ADHD, tired, deep in flow, or just done with walls of text.
+
+### Before / after
+
+The question: **"Which database should I use for a new social app, PostgreSQL or MongoDB?"** Same answer, before and after the style.
+
+<table>
+<tr>
+<th align="left" width="50%">Default &nbsp;·&nbsp; 430 words</th>
+<th align="left" width="50%">Attention-kind &nbsp;·&nbsp; 94 words</th>
+</tr>
+<tr valign="top">
+<td>
+
+For a new social app, start with PostgreSQL, and the bar for choosing MongoDB instead is high. Social apps are relationship-heavy by nature: users follow users, posts belong to users, comments belong to posts, likes connect users to posts. That's a web of connections, exactly what a relational database is built for. In MongoDB you either cram related data into one record and fight size limits, or split it out and end up stitching it back together in your app code anyway. The feed problem makes this worse: timelines, "posts from people you follow," and mutual-friend lookups all lean on the kind of cross-referencing Postgres does in a single query. You also get consistency for free, since follow counts and "did I already like this" checks want real transactions… *[and it keeps going like this]*
+
+</td>
+<td>
+
+**→ Use PostgreSQL.** A social app is all relationships (friends, follows, likes), and Postgres handles those natively. Right for ~90% of new social apps.
+
+**→ You keep flexibility.** Its JSONB column stores schema-less data inside the same database, so you get MongoDB's looseness without leaving Postgres.
+
+**→ Pick MongoDB only if** your data is self-contained documents with no links, and you need massive write volume on day one.
+
+**→ The early trap with MongoDB:** six months in, five different shapes of "user" and no clean fix. Postgres forces the structure.
+
+**→ Next:** start on managed Postgres (Supabase, Neon, RDS).
+
+</td>
+</tr>
+</table>
+
+Same information. One of them you can read at a glance.
+
+### Does it actually help? (measured, and reproducible)
+
+The benchmark measures the work and the output separately, and the headline numbers use **no LLM judge**. Every figure is reproducible from this repo. [Full writeup and runnable harness.](benchmarks/results/2026-08-11-benchmark.md)
+
+- **The work is untouched.** 12 coding tasks with hidden test suites, style off vs on: pass rates are equal (**both 97%**, within noise). No judge, just tests passing.
+- **~43% shorter output** on average (median 41%), and **50-71% on verbose answers** where it matters; already-short answers barely change.
+- **You reach the point in ~6 words instead of ~40.** The answer is in the first line **75%** of the time vs **3%**. (Reading-grade scores don't apply, they only measure word length and can't see a wall of text.)
+- **Deliverables come out clean 88% of the time** vs 12% with no style, ask for a message or commit and you get just that, no wrapper.
+
+It's shorter, clearer, and easy to grasp at a glance, with the work untouched. We don't claim it produces better answers, that isn't what it's for.
+
+### What changes
+
+- **Answer first.** Conclusion in line one. No wind-up.
+- **Short by default.** Says the least that fully answers, then stops.
+- **Expands only on what's vital**, so length itself signals importance.
+- **Plain English.** Rare technical terms get a five-word definition, once.
+- **Built to scan.** `→` markers, heavy bold, real spacing between points.
+- **No repetition.** Each point makes one distinct argument, never restated or re-argued.
+- **Re-anchors long tasks** and asks one question at a time, so you never lose the thread.
+- **Comments too.** Code comments inherit the plain-English "explain the why" rule, but never the chat formatting.
+
+## Spartan
+
+<p align="center"><img src="assets/cat-spartan.png" alt="A cat in a Spartan helmet aims its laser at one lit line" width="860"></p>
+
+Terse mode with the warmth stripped out. Same arrows and bold as Attention-kind, but blunt and imperative, no cushioning, no transitions, maximum compression. For heads-down work when you want signal, not conversation.
+
+The question: **"Three priorities this week, room for two, how do I decide what to cut?"** Both real Opus 5 eval outputs.
+
+<table>
+<tr>
+<th align="left" width="50%">Default &nbsp;·&nbsp; 310 words</th>
+<th align="left" width="50%">Spartan &nbsp;·&nbsp; 168 words</th>
+</tr>
+<tr valign="top">
+<td>
+
+Cut the one that fails the cheapest test: if it slipped a week, who actually feels it, and how much? Run all three through four quick filters and the loser usually falls out on its own. Consequence of delay: two of your three probably have soft deadlines you invented and one has a real one, a person waiting, a dependency downstream, a window that closes. Cut from the self-imposed pile, never the someone-is-blocked-on-me pile. Reversibility: some things get harder the longer they wait, others are exactly as easy next week, so cut the one whose cost curve is flat. Who owns it besides you: if a priority can be delegated or done at 80% by someone else, it is a better cut than one only you can do… *[and it keeps going like this]*
+
+</td>
+<td>
+
+**→ Rank by cost of NOT doing it, not by effort or interest.** Ask each: what breaks if this slips a week? The one with the softest consequence gets cut.
+
+**→ Kill the reversible one.** If a task can wait, be delegated, or restarted later with no penalty, cut it. Protect anything with a **hard deadline** or a **dependency** where others are blocked on you.
+
+**→ Run the regret test.** Friday night, which un-done task stings most? Keep that one. The one you'd shrug at is your cut.
+
+**→ Separate loud from important.** The priority screaming at you is often just the most **anxious**, not the most valuable. Cut by impact, not by volume.
+
+**→ Do not half-do all three.** Two finished beats three at 66%. Partial work on the third is the trap, it feels productive and ships nothing.
+
+**→ Cut it out loud.** Tell whoever's affected now, not Friday. A cut you flag is a decision, a cut you hide is a **failure with a delay**.
+
+</td>
+</tr>
+</table>
+
+Same style-only guarantee as Attention-kind: shorter, more scannable, the work untouched. See the [benchmark](benchmarks/results/2026-08-11-benchmark.md).
+
+## Rundown
+
+<p align="center"><img src="assets/cat-rundown.png" alt="The Rundown cat aims its laser at a checklist, one line lit" width="860"></p>
+
+Briefing style. Opens with a **TL;DR**, shows state as a ✅ / 🟡 / ⬜ / ❔ checklist, tags the next choices with emoji and numbers them so you can pick by number. Built for status updates and standups. **It optimizes for readability and scannability, not brevity**, so reach for it when clarity matters more than length. Includes a guard against inventing status it wasn't given.
+
+The question: **"Summarize where hiring stands: 20 applicants, 5 screened, 2 interviews, no offer, one strong candidate slipping."** Both real Opus 5 eval outputs.
+
+<table>
+<tr>
+<th align="left" width="50%">Default &nbsp;·&nbsp; a paragraph you read</th>
+<th align="left" width="50%">Rundown &nbsp;·&nbsp; a board you scan</th>
+</tr>
+<tr valign="top">
+<td>
+
+Hiring stands at the top of the funnel and thin at the bottom. Twenty applicants in, five screened, two interviews booked. No offer has gone out yet, and that gap is the problem: one of the strongest candidates is cooling off while the process idles. The numbers: applicants 20, screened 5, interviews booked 2, offers out 0, at risk 1 strong candidate slipping away. The read: this is a speed problem, not a supply problem. The pipeline is healthy up top, but nothing has converted to an offer, and the best prospect is drifting. The highest-value move is to fast-track the slipping candidate before the delay decides for us. Bottleneck: the offer stage… *[and it keeps going like this]*
+
+</td>
+<td>
+
+TL;DR: Pipeline is healthy up top but the finish line is stalling, and your best candidate is about to walk.
+
+**Hiring funnel**
+- ☑️ **Applicants in:** 20 sourced
+- ☑️ **Screened:** 5 of 20 done
+- 🟡 **Interviews:** 2 booked, not yet run
+- ⬜ **Offer:** not drafted, not out
+
+🔴 **Blocker:** One strong candidate is slipping. No offer motion means you lose them by default.
+
+**Your move:**
+1. 🚀 Fast-track the strong candidate, skip ahead to offer talk today
+2. 📞 Run the 2 booked interviews before deciding
+3. 📋 Screen more of the 15 untouched applicants for backup
+4. ✍️ Draft the offer now so it is ready to fire
+
+Pick a number: save the candidate now (1), or run the full process and risk losing them?
+
+</td>
+</tr>
+</table>
+
+## Actually want to cut your token bill?
+
+Attention Span is here to make your agents' answers readable and easy to grasp at a glance. The lighter token bill on those answers is a welcome side effect. If cutting token spend is your actual goal, the bigger cost is the *work* your agent does, not how it talks, and two sister tools go right at it, pairing naturally with these styles:
+
+<p align="center"><img src="assets/save-tokens.png" alt="The Outsourcerer wizard and the Attention Span cat vacuuming up ghost tokens with Token Optimizer" width="900"></p>
+
+**[Token Optimizer](https://github.com/alexgreensh/token-optimizer)** tackles the three layers of token waste most tools never touch:
+
+- **Structural**, e.g. bloated configs, unused skills, stale memory
+- **Runtime**, e.g. verbose output, re-reads
+- **Behavioral**, e.g. model misrouting, cache expiry, retry loops
+
+...and more in each. On top of that it compresses your output stack, checkpoints and restores your work so your sessions stay continuous across compaction, and puts every token and dollar saved on a live dashboard. It's also the only tool that measures your context quality and adjusts to it, because a cheaper session that does worse work is no saving at all.
+
+*Runs on Claude Code, Codex, OpenCode, OpenClaw, Hermes and Copilot.*
+
+**[Outsourcerer](https://github.com/alexgreensh/outsourcerer)** — stay in one session of whatever agent you like best. In the background it:
+
+- runs a squad across the models and harnesses you already pay for
+- picks the best one per task **by benchmark, not just price**
+- checks their work and minds your limits in every engine
+
+You keep the cockpit; the grunt work happens elsewhere.
+
+*Works across Claude Code, Codex, Antigravity, Devin, Droid, Cursor, Warp and Hermes.*
+
+Attention Span trims how much Claude says. These two govern what your whole stack spends.
+
+## Install
+
+**Easiest: install the plugin.** One step gets all three styles, the `/style` switcher, and the
+user-invoked skills (`/attention-kind`, `/spartan`, `/rundown`, `/tldr`). In Claude Code:
+
+```
+/plugin marketplace add alexgreensh/attention-span
+/plugin install attention-span
+```
+
+Then activate a style under `/config` → *Output style*, or just type a skill like `/attention-kind`
+for one conversation. Prefer wiring it up by hand? The manual steps below still work and are unchanged.
+
+**1.** Drop the style into your output-styles folder. Global (every project):
+
+```bash
+mkdir -p ~/.claude/output-styles
+curl -o ~/.claude/output-styles/attention-kind.md \
+  https://raw.githubusercontent.com/alexgreensh/attention-span/main/output-styles/attention-kind.md
+```
+
+Or put it in `.claude/output-styles/` inside a single project.
+
+**2.** Set it as your default in `~/.claude/settings.json`. Do this once and it's on every session, forever:
+
+```json
+{ "outputStyle": "Attention-kind" }
+```
+
+**3.** Restart or `/clear`. That's it.
+
+**Rather not edit JSON?** Install the `/style` command and it does step 2 for you:
+
+```bash
+mkdir -p ~/.claude/commands
+curl -o ~/.claude/commands/style.md \
+  https://raw.githubusercontent.com/alexgreensh/attention-span/main/commands/style.md
+```
+
+Then `/style` shows a popup of the styles you have installed. `/style spartan` sets one straight away. `/style default` puts the built-in style back.
+
+It looks in `~/.claude/output-styles/` and in a project's `.claude/output-styles/`. A global style is written to `~/.claude/settings.json`. A project style is written to `.claude/settings.local.json`, so it stays out of your teammates' checkouts.
+
+**Already have it installed?** The styles get updated. Check which version you're on and compare it to the [version badge](https://github.com/alexgreensh/attention-span/releases) above:
+
+```bash
+grep attention-span ~/.claude/output-styles/*.md
+```
+
+Behind? Re-run the install command in step 1 to overwrite with the latest.
+
+Want to try it for one session first? Run `/config` and pick it under *Output style* instead, then set the default above once you're sold.
+
+**Cost:** ~650 tokens, added once per session and cached after the first request. The benchmark measured ~43% shorter output, so the input cost is negligible after the first reply.
+
+## Use in Claude chats (skills)
+
+The styles also ship as **skills**, so they work in the Claude apps (claude.ai, desktop, mobile), not
+just Claude Code. Install the plugin above, or add the skill files directly, then just type the command:
+
+- `/attention-kind`, `/spartan`, or `/rundown` — talk in that style for the rest of the conversation.
+- `/tldr` — compress a document, thread, transcript, or pasted text into a scannable briefing. (The
+  styles shape how Claude reports its *own* work; `/tldr` compresses something *someone else* wrote.)
+
+The skills are **user-invoked only** (`disable-model-invocation`), so they cost zero passive context
+until you call one, and they're generated from the same style sources (`scripts/gen-skills.py`), so they
+never drift from the flagship wording.
+
+## Use with other agents
+
+The style body is plain markdown with no Claude-specific behavior. The only Claude-Code part is the YAML frontmatter at the top of each file (the `name`/`description` block the `/config` picker reads). Other agents ignore or choke on frontmatter, so the install strips it.
+
+Each style file has a `<!-- body-start -->` marker after the frontmatter. The strip command is one `sed`:
+
+```bash
+curl -sfL <raw-url> | sed '1,/<!-- body-start -->/d'
+```
+
+That gives you clean body markdown, ready to drop into any agent's rules or instructions file.
+
+### Install per agent
+
+**Devin** (global, via Windsurf compatibility):
+
+```bash
+mkdir -p ~/.codeium/windsurf/memories
+curl -sfL https://raw.githubusercontent.com/alexgreensh/attention-span/main/output-styles/attention-kind.md -o /tmp/attention-span.md \
+  && sed '1,/<!-- body-start -->/d' /tmp/attention-span.md > ~/.codeium/windsurf/memories/attention-kind.md
+```
+
+Or project-level: `.windsurf/rules/attention-kind.md` in your repo root.
+
+**Codex** (append to global `AGENTS.md`, idempotent via fenced markers):
+
+```bash
+mkdir -p ~/.codex
+curl -sfL https://raw.githubusercontent.com/alexgreensh/attention-span/main/output-styles/attention-kind.md -o /tmp/attention-span.md \
+  && { printf '\n<!-- attention-span:start -->\n'; sed '1,/<!-- body-start -->/d' /tmp/attention-span.md; printf '<!-- attention-span:end -->\n'; } >> ~/.codex/AGENTS.md
+```
+
+To update later, remove the old block first (in place), then re-run the install: `sed -i.bak '/<!-- attention-span:start -->/,/<!-- attention-span:end -->/d' ~/.codex/AGENTS.md`.
+
+**Antigravity CLI (agy)** (project-level `GEMINI.md`, idempotent via fenced markers):
+
+```bash
+curl -sfL https://raw.githubusercontent.com/alexgreensh/attention-span/main/output-styles/attention-kind.md -o /tmp/attention-span.md \
+  && { printf '\n<!-- attention-span:start -->\n'; sed '1,/<!-- body-start -->/d' /tmp/attention-span.md; printf '<!-- attention-span:end -->\n'; } >> GEMINI.md
+```
+
+Run this in your repo root. agy discovers `GEMINI.md` (or `AGENTS.md`) by walking up from the current directory to the repo root, so the style applies to that project and all subdirectories.
+
+To update later, remove the old block first (in place), then re-run the install: `sed -i.bak '/<!-- attention-span:start -->/,/<!-- attention-span:end -->/d' GEMINI.md`.
+
+For a global install (all projects under your home directory), append to `~/GEMINI.md` instead, agy will find it on the walk-up from any project.
+
+Swap `attention-kind.md` for `spartan.md` or `rundown.md` to install a different style. Same commands, different filename.
+
+**Notes:**
+
+- Devin loads rules via its Windsurf/Cursor compatibility layer, not a native rules directory. The `~/.codeium/windsurf/memories/` path is global; `.windsurf/rules/` is per-project.
+- Codex appends to a shared `AGENTS.md`, so the fenced markers (`<!-- attention-span:start -->` / `<!-- attention-span:end -->`) let you update or remove the block without duplicates.
+- Antigravity CLI (agy) discovers rules by walking up from cwd to repo root, loading any `GEMINI.md` or `AGENTS.md` it finds. No frontmatter support for standalone rules. Global install works by placing `GEMINI.md` in a parent directory (e.g. `~/`) that's always in the walk-up path.
+- The body is ~650 tokens of input, loaded at the start of every session. Claude Code caches it after the first request; other agents may or may not cache (provider-dependent). The output savings (~43%) dwarf the input cost within a few replies either way.
+- The `sed` strip assumes macOS/Linux. On Windows, use WSL or Git Bash.
+
+## The styles
+
+| Style | File | Best for |
+|---|---|---|
+| Attention-kind | [`output-styles/attention-kind.md`](output-styles/attention-kind.md) | ADHD, attention fatigue, anyone tired of walls of text |
+| Spartan | [`output-styles/spartan.md`](output-styles/spartan.md) | Spartan mode: maximum signal, zero warmth, heads-down work |
+| Rundown | [`output-styles/rundown.md`](output-styles/rundown.md) | Briefings, standups, progress updates (TL;DR + checkboxes) |
+
+Each is one readable markdown file, easy to adapt.
+
+## Notes
+
+- Styles apply to the **main conversation only**. Subagents run their own prompt.
+- These keep Claude's coding behavior intact (`keep-coding-instructions: true`).
+
+## License
+
+AGPL-3.0. See [LICENSE](LICENSE).