Usuario: "Corrige el bug en auth"

Pi: [Razona] Veo que el error está en la validación del token.
    [Actúa]  → tool: read("src/auth/validate.ts")
    [Observa] El archivo muestra que la regex expira con timestamps...
    [Razona] El bug es que no maneja tokens expirados.
    [Actúa]  → tool: edit("src/auth/validate.ts", añadir check de expiración)
    [Actúa]  → tool: bash("npm test")
    [Observa] Tests pasando ✅
    [Razona] Bug corregido y verificado.

Usuario: "Migra toda la app de JavaScript a TypeScript"

Pi: [Fase 1: Plan]
    1. Instalar TypeScript y configurar tsconfig.json
    2. Migrar types/interfaces primero
    3. Migrar utils/ (sin dependencias internas)
    4. Migrar services/ (dependen de utils)
    5. Migrar routes/ (dependen de services)
    6. Actualizar tests
    7. Verificar con `tsc --noEmit`

    [Fase 2: Ejecutar paso a paso]
    Paso 1... ✅
    Paso 2... ✅
    Paso 3... ✅
    ...

> Primero haz un plan detallado para migrar a TypeScript,
  luego ejecútalo paso a paso. Confirma conmigo antes de
  empezar cada paso.

                    ┌─────────────┐
                    │ Orquestador │  ← Agente principal (tú)
                    └──────┬──────┘
                           │ delega
              ┌────────────┼────────────┐
              ▼            ▼            ▼
        ┌──────────┐ ┌──────────┐ ┌──────────┐
        │  Scout   │ │ Planner  │ │  Worker  │
        │  (Haiku) │ │ (Sonnet) │ │ (Sonnet) │
        │ read only│ │ read only│ │ all tools │
        └──────────┘ └──────────┘ └──────────┘

> Implementa rate limiting en la API

Pi Worker: [implementa rate limiting]

> Ahora usa el reviewer para verificar la implementación

Pi Reviewer: [lee el código, encuentra un edge case
  con rate limiting en WebSockets, sugiere fix]

Pi Worker: [corrige el edge case]

<!-- ~/.pi/agent/agents/scout.md -->
---
name: scout
description: Fast codebase recon that returns compressed context
tools: read, grep, find, ls, bash
model: claude-haiku-4-5
---

You are a scout. Quickly investigate a codebase and return
structured findings for another agent.

Strategy:
1. grep/find to locate relevant code
2. Read key sections (not entire files)
3. Identify types, interfaces, key functions
4. Note dependencies between files

Output format:

## Files Retrieved
1. `path/to/file.ts` (lines 10-50) - Description

## Key Code
Critical types and functions

## Architecture
How the pieces connect

## Start Here
Which file to look at first and why.

> Usa scout para encontrar todo el código de autenticación

> Ejecuta 2 scouts en paralelo: uno busca modelos,
  otro busca providers

> Cadena: scout encuentra el código de auth,
  luego planner sugiere mejoras,
  luego worker las implementa

/implement añadir caché Redis al session store

# Un solo prompt
pi -p "¿Qué framework usa este proyecto?"

# Con provider/modelo específico
pi -p --model gpt-4o "Resume los cambios del último commit"

# Pipe de stdin
cat README.md | pi -p "Resume este texto en 3 bullets"
git diff | pi -p "Explica estos cambios"

#!/bin/bash
# generate-changelog.sh
git log --oneline $1..HEAD | pi -p "Genera un changelog en markdown a partir de estos commits. Agrupa por tipo (feat, fix, refactor, etc)."

#!/bin/bash
# review-pr.sh
git diff main...$1 | pi -p "Revisa estos cambios como un senior developer. Identifica bugs potenciales, problemas de seguridad y mejoras de rendimiento."

#!/bin/bash
# doc-function.sh
cat "$1" | pi -p "Genera documentación JSDoc para todas las funciones exportadas en este archivo. Incluye @param, @returns y @example."

#!/bin/bash
# pre-commit review
STAGED=$(git diff --cached --name-only)
if [ -n "$STAGED" ]; then
  git diff --cached | pi -p "¿Hay algo peligroso en estos cambios staged? Responde solo: SAFE o UNSAFE con una línea de explicación."
fi

pi --mode json -p "Lista los archivos del proyecto"

npm install @mariozechner/pi-coding-agent

import { createAgentSession } from "@mariozechner/pi-coding-agent";

const { session } = await createAgentSession();

// Escuchar la respuesta
session.subscribe((event) => {
  if (event.type === "message_update" &&
      event.assistantMessageEvent.type === "text_delta") {
    process.stdout.write(event.assistantMessageEvent.delta);
  }
});

// Enviar un prompt
await session.prompt("What files are in the current directory?");

import {
  createAgentSession,
  SessionManager,
  createCodingTools,
} from "@mariozechner/pi-coding-agent";

const { session } = await createAgentSession({
  cwd: "/path/to/project",
  tools: createCodingTools("/path/to/project"),
  sessionManager: SessionManager.inMemory(),
});

import { createAgentSession, readOnlyTools } from "@mariozechner/pi-coding-agent";

const { session } = await createAgentSession({
  tools: readOnlyTools, // Solo read, grep, find, ls — sin write/edit
});

// Redirigir: interrumpe y cambia de dirección
await session.steer("En realidad, enfócate solo en los tests");

// Follow-up: espera a que termine y luego procesa
await session.followUp("Después, actualiza la documentación");

session.subscribe((event) => {
  switch (event.type) {
    case "tool_execution_start":
      console.log(`Tool: ${event.toolName}`);
      break;
    case "tool_execution_end":
      console.log(`Resultado: ${event.isError ? "error" : "ok"}`);
      break;
    case "agent_end":
      console.log("Agente terminó");
      break;
  }
});

// Simplificado del código real de OpenClaw
import { createAgentSession } from "@mariozechner/pi-coding-agent";

// Cada canal (WhatsApp, Telegram, etc.) tiene su sesión aislada
const { session } = await createAgentSession({
  sessionManager: SessionManager.create(channelId),
});

session.subscribe((event) => {
  if (event.type === "agent_end") {
    // Enviar respuesta al canal de mensajería
    sendToChannel(channelId, event.messages);
  }
});

await session.prompt(userMessage);

pi                    # Sesión interactiva
pi -c                 # Continuar ayer
/tree                 # Volver a un punto anterior

pi --readonly         # Sin riesgo de modificar
"Revisa el código de auth y busca vulnerabilidades"

/implement refactorizar API a REST v2
# → scout explora, planner diseña, worker implementa

# Pre-commit hook
git diff --cached | pi -p "¿Es seguro hacer commit de esto?"

# CI pipeline
pi -p "Analiza los cambios de este PR y genera un resumen técnico"

// Tu app custom
const { session } = await createAgentSession();
await session.prompt("Analiza el log de errores y sugiere fixes");