guild-agents 0.2.6 → 0.2.7

package/bin/guild.js

@@ -3,9 +3,9 @@
 /**
  * Guild v1 — CLI entry point
  * Usage:
- *   guild init           — onboarding interactivo v1
- *   guild new-agent      — crear un nuevo agente
- *   guild status         — ver estado del proyecto
+ *   guild init           — interactive onboarding v1
+ *   guild new-agent      — create a new agent
+ *   guild status         — view project status
  */
 
 import { program } from 'commander';
@@ -24,7 +24,7 @@ program
 // guild init
 program
   .command('init')
-  .description('Inicializar Guild v1 en el proyecto actual')
+  .description('Initialize Guild v1 in the current project')
   .action(async () => {
     try {
       const { runInit } = await import('../src/commands/init.js');
@@ -38,8 +38,8 @@ program
 // guild new-agent
 program
   .command('new-agent')
-  .description('Crear un nuevo agente')
-  .argument('<name>', 'Nombre del agente (lowercase, guiones)')
+  .description('Create a new agent')
+  .argument('<name>', 'Agent name (lowercase, hyphens)')
   .action(async (name) => {
     try {
       const { runNewAgent } = await import('../src/commands/new-agent.js');
@@ -53,7 +53,7 @@ program
 // guild status
 program
   .command('status')
-  .description('Ver estado del proyecto Guild')
+  .description('View Guild project status')
   .action(async () => {
     try {
       const { runStatus } = await import('../src/commands/status.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "guild-agents",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "A multi-agent framework for Claude Code — specialized AI teams for every project",
   "type": "module",
   "files": [
@@ -50,9 +50,9 @@
     "url": "https://github.com/guild-agents/guild/issues"
   },
   "dependencies": {
-    "@clack/prompts": "^0.9.0",
+    "@clack/prompts": "^1.0.1",
     "chalk": "^5.3.0",
-    "commander": "^12.0.0",
+    "commander": "^14.0.3",
     "picocolors": "^1.0.0"
   },
   "engines": {

package/src/commands/__tests__/new-agent.test.js

@@ -21,13 +21,13 @@ describe('runNewAgent', () => {
   it('should throw with invalid agent name', async () => {
     process.chdir(tempDir);
     const { runNewAgent } = await import('../new-agent.js');
-    await expect(runNewAgent('Invalid Name!')).rejects.toThrow('Nombre invalido');
+    await expect(runNewAgent('Invalid Name!')).rejects.toThrow('Invalid name');
   });
 
   it('should throw when .claude/agents/ does not exist', async () => {
     process.chdir(tempDir);
     const { runNewAgent } = await import('../new-agent.js');
-    await expect(runNewAgent('valid-name')).rejects.toThrow('Guild no esta instalado');
+    await expect(runNewAgent('valid-name')).rejects.toThrow('Guild is not installed');
   });
 
   it('should throw when agent already exists', async () => {
@@ -35,6 +35,6 @@ describe('runNewAgent', () => {
     mkdirSync(join(tempDir, '.claude', 'agents'), { recursive: true });
     writeFileSync(join(tempDir, '.claude', 'agents', 'existing.md'), '# existing');
     const { runNewAgent } = await import('../new-agent.js');
-    await expect(runNewAgent('existing')).rejects.toThrow('ya existe');
+    await expect(runNewAgent('existing')).rejects.toThrow('already exists');
   });
 });

package/src/commands/__tests__/status.test.js

@@ -21,12 +21,12 @@ describe('runStatus', () => {
   it('should throw when PROJECT.md does not exist', async () => {
     process.chdir(tempDir);
     const { runStatus } = await import('../status.js');
-    await expect(runStatus()).rejects.toThrow('Guild no esta instalado');
+    await expect(runStatus()).rejects.toThrow('Guild is not installed');
   });
 
   it('should not throw when PROJECT.md exists', async () => {
     process.chdir(tempDir);
-    writeFileSync(join(tempDir, 'PROJECT.md'), '**Nombre:** TestProject\n**Stack:** Node.js');
+    writeFileSync(join(tempDir, 'PROJECT.md'), '**Name:** TestProject\n**Stack:** Node.js');
     mkdirSync(join(tempDir, '.claude', 'agents'), { recursive: true });
     mkdirSync(join(tempDir, '.claude', 'skills'), { recursive: true });
     const { runStatus } = await import('../status.js');

package/src/commands/init.js

@@ -1,12 +1,12 @@
 /**
- * guild init — Onboarding interactivo v1
+ * guild init — Interactive onboarding v1
  *
- * Flujo:
- * 1. Verificar que no existe ya una instalacion de Guild
- * 2. Recopilar: nombre, tipo, stack, GitHub, codigo existente
- * 3. Generar PROJECT.md, CLAUDE.md, SESSION.md
- * 4. Copiar agentes y skills
- * 5. Instrucciones para /guild-specialize
+ * Flow:
+ * 1. Verify that a Guild installation does not already exist
+ * 2. Collect: name, type, stack, GitHub, existing code
+ * 3. Generate PROJECT.md, CLAUDE.md, SESSION.md
+ * 4. Copy agents and skills
+ * 5. Instructions for /guild-specialize
  */
 
 import * as p from '@clack/prompts';
@@ -17,68 +17,68 @@ import { copyTemplates } from '../utils/files.js';
 
 export async function runInit() {
   console.log('');
-  p.intro(chalk.bold.cyan('Guild v1 — Nuevo proyecto'));
+  p.intro(chalk.bold.cyan('Guild v1 — New project'));
 
-  // Verificar instalacion existente
+  // Check for existing installation
   if (existsSync('.claude/agents')) {
     const overwrite = await p.confirm({
-      message: 'Guild ya esta instalado en este proyecto. Reinicializar?',
+      message: 'Guild is already installed in this project. Reinitialize?',
       initialValue: false,
     });
 
     if (p.isCancel(overwrite) || !overwrite) {
-      p.cancel('Cancelado.');
+      p.cancel('Cancelled.');
       return;
     }
   }
 
-  // ─── Nombre ─────────────────────────────────────────────────────────────────
+  // ─── Name ─────────────────────────────────────────────────────────────────
   const name = await p.text({
-    message: 'Nombre del proyecto:',
-    placeholder: 'mi-proyecto',
+    message: 'Project name:',
+    placeholder: 'my-project',
     validate: (val) => {
-      if (!val) return 'El nombre es requerido';
+      if (!val) return 'Name is required';
     },
   });
-  if (p.isCancel(name)) { p.cancel('Cancelado.'); return; }
+  if (p.isCancel(name)) { p.cancel('Cancelled.'); return; }
 
-  // ─── Tipo ───────────────────────────────────────────────────────────────────
+  // ─── Type ───────────────────────────────────────────────────────────────────
   const type = await p.select({
-    message: 'Tipo de proyecto:',
+    message: 'Project type:',
     options: [
       { value: 'webapp', label: 'Web app (React/Vue/Angular)' },
       { value: 'api', label: 'API / Backend service' },
       { value: 'cli', label: 'CLI tool' },
       { value: 'mobile', label: 'Mobile (React Native)' },
-      { value: 'fullstack', label: 'Otro / Fullstack' },
+      { value: 'fullstack', label: 'Other / Fullstack' },
     ],
   });
-  if (p.isCancel(type)) { p.cancel('Cancelado.'); return; }
+  if (p.isCancel(type)) { p.cancel('Cancelled.'); return; }
 
   // ─── Stack ──────────────────────────────────────────────────────────────────
   const stack = await p.text({
-    message: 'Stack principal:',
-    placeholder: 'ej: Next.js, Supabase, Vercel',
+    message: 'Main stack:',
+    placeholder: 'e.g.: Next.js, Supabase, Vercel',
     validate: (val) => {
-      if (!val) return 'El stack es requerido';
+      if (!val) return 'Stack is required';
     },
   });
-  if (p.isCancel(stack)) { p.cancel('Cancelado.'); return; }
+  if (p.isCancel(stack)) { p.cancel('Cancelled.'); return; }
 
   // ─── GitHub ─────────────────────────────────────────────────────────────────
   let github = null;
   const hasRepo = await p.confirm({
-    message: 'Tiene repositorio GitHub?',
+    message: 'Has a GitHub repository?',
     initialValue: true,
   });
 
   if (!p.isCancel(hasRepo) && hasRepo) {
     const repoUrl = await p.text({
-      message: 'URL del repositorio:',
+      message: 'Repository URL:',
       placeholder: 'https://github.com/org/repo',
       validate: (val) => {
-        if (!val) return 'La URL es requerida';
-        if (!val.includes('github.com')) return 'Debe ser una URL de GitHub';
+        if (!val) return 'URL is required';
+        if (!val.includes('github.com')) return 'Must be a GitHub URL';
       },
     });
     if (!p.isCancel(repoUrl)) {
@@ -86,15 +86,15 @@ export async function runInit() {
     }
   }
 
-  // ─── Codigo existente ───────────────────────────────────────────────────────
+  // ─── Existing code ────────────────────────────────────────────────────────
   const hasExistingCode = await p.confirm({
-    message: 'Tiene codigo existente?',
+    message: 'Has existing code?',
     initialValue: true,
   });
 
-  // ─── Generacion ─────────────────────────────────────────────────────────────
+  // ─── Generation ───────────────────────────────────────────────────────────
   const spinner = p.spinner();
-  spinner.start('Generando estructura Guild v1...');
+  spinner.start('Generating Guild v1 structure...');
 
   const projectData = {
     name,
@@ -106,35 +106,35 @@ export async function runInit() {
 
   try {
     await copyTemplates();
-    spinner.message('Generando CLAUDE.md...');
+    spinner.message('Generating CLAUDE.md...');
     await generateClaudeMd(projectData);
 
-    spinner.message('Generando PROJECT.md...');
+    spinner.message('Generating PROJECT.md...');
     await generateProjectMd(projectData);
 
-    spinner.message('Generando SESSION.md...');
+    spinner.message('Generating SESSION.md...');
     await generateSessionMd();
 
-    spinner.stop('Estructura creada.');
+    spinner.stop('Structure created.');
   } catch (error) {
-    spinner.stop('Error durante la inicializacion.');
+    spinner.stop('Error during initialization.');
     throw error;
   }
 
-  // ─── Resumen ────────────────────────────────────────────────────────────────
+  // ─── Summary ──────────────────────────────────────────────────────────────
   p.log.success('CLAUDE.md');
   p.log.success('PROJECT.md');
   p.log.success('SESSION.md');
-  p.log.success('.claude/agents/    (8 agentes base)');
+  p.log.success('.claude/agents/    (8 base agents)');
   p.log.success('.claude/skills/    (10 skills)');
 
   p.note(
-    'Abre Claude Code en este directorio y ejecuta:\n\n' +
+    'Open Claude Code in this directory and run:\n\n' +
     '  /guild-specialize\n\n' +
-    'Este skill explorara tu codigo y enriquecera CLAUDE.md\n' +
-    'con la informacion real del proyecto.',
-    'Siguiente paso'
+    'This skill will explore your code and enrich CLAUDE.md\n' +
+    'with the actual project information.',
+    'Next step'
   );
 
-  p.outro(chalk.bold.cyan('Guild v1 listo.'));
+  p.outro(chalk.bold.cyan('Guild v1 ready.'));
 }

package/src/commands/new-agent.js

@@ -1,12 +1,12 @@
 /**
- * new-agent.js — Crea un nuevo agente v1 (archivo plano)
+ * new-agent.js — Creates a new v1 agent (plain file)
  *
- * Flujo:
- * 1. Validar nombre (lowercase, guiones, sin espacios)
- * 2. Verificar que Guild esta instalado
- * 3. Verificar que el agente NO existe
- * 4. Pedir descripcion del agente
- * 5. Crear .claude/agents/[nombre].md con placeholder
+ * Flow:
+ * 1. Validate name (lowercase, hyphens, no spaces)
+ * 2. Verify that Guild is installed
+ * 3. Verify that the agent does NOT exist
+ * 4. Ask for agent description
+ * 5. Create .claude/agents/[name].md with placeholder
  */
 
 import * as p from '@clack/prompts';
@@ -17,35 +17,35 @@ import { join } from 'path';
 const AGENTS_DIR = join('.claude', 'agents');
 
 export async function runNewAgent(agentName) {
-  p.intro(chalk.bold.cyan('Guild — Nuevo agente'));
+  p.intro(chalk.bold.cyan('Guild — New agent'));
 
-  // Validar nombre
+  // Validate name
   if (!isValidAgentName(agentName)) {
-    throw new Error(`Nombre invalido: "${agentName}". Solo lowercase, numeros y guiones. Ejemplo: guild new-agent security-auditor`);
+    throw new Error(`Invalid name: "${agentName}". Only lowercase, numbers, and hyphens allowed. Example: guild new-agent security-auditor`);
   }
 
-  // Verificar Guild instalado
+  // Verify Guild is installed
   if (!existsSync(AGENTS_DIR)) {
-    throw new Error('Guild no esta instalado. Ejecuta: guild init');
+    throw new Error('Guild is not installed. Run: guild init');
   }
 
-  // Verificar que el agente NO existe
+  // Verify that the agent does NOT exist
   const agentPath = join(AGENTS_DIR, `${agentName}.md`);
   if (existsSync(agentPath)) {
-    throw new Error(`El agente "${agentName}" ya existe.`);
+    throw new Error(`Agent "${agentName}" already exists.`);
   }
 
-  // Pedir descripcion
+  // Ask for description
   const description = await p.text({
-    message: `Que hace "${agentName}"? (descripcion corta):`,
-    placeholder: 'ej: Evalua oportunidades de trading basado en analisis tecnico',
-    validate: (val) => !val ? 'La descripcion es requerida' : undefined,
+    message: `What does "${agentName}" do? (short description):`,
+    placeholder: 'e.g.: Evaluates trading opportunities based on technical analysis',
+    validate: (val) => !val ? 'Description is required' : undefined,
   });
-  if (p.isCancel(description)) { p.cancel('Cancelado.'); return; }
+  if (p.isCancel(description)) { p.cancel('Cancelled.'); return; }
 
-  // Crear agente
+  // Create agent
   const spinner = p.spinner();
-  spinner.start(`Creando agente "${agentName}"...`);
+  spinner.start(`Creating agent "${agentName}"...`);
 
   try {
     const content = `---
@@ -55,34 +55,34 @@ description: "${description}"
 
 # ${agentName}
 
-Eres ${agentName} de [PROYECTO].
+You are ${agentName} of [PROJECT].
 
-## Responsabilidades
-[Definir con /guild-specialize]
+## Responsibilities
+[Define with /guild-specialize]
 
-## Lo que NO haces
-[Definir con /guild-specialize]
+## What you do NOT do
+[Define with /guild-specialize]
 
-## Proceso
-[Definir con /guild-specialize]
+## Process
+[Define with /guild-specialize]
 
-## Reglas de comportamiento
-- Siempre lee CLAUDE.md y SESSION.md al inicio de la sesion
+## Behavioral rules
+- Always read CLAUDE.md and SESSION.md at the start of the session
 `;
 
     writeFileSync(agentPath, content, 'utf8');
 
-    spinner.stop(`Agente "${agentName}" creado.`);
+    spinner.stop(`Agent "${agentName}" created.`);
 
-    p.log.success(`Archivo: ${agentPath}`);
+    p.log.success(`File: ${agentPath}`);
     p.note(
-      `Ejecuta /guild-specialize para que Claude\n` +
-      `genere las instrucciones completas de "${agentName}".`,
-      'Especializacion pendiente'
+      `Run /guild-specialize so that Claude\n` +
+      `generates the full instructions for "${agentName}".`,
+      'Specialization pending'
     );
-    p.outro(chalk.bold.cyan(`Agente ${agentName} listo.`));
+    p.outro(chalk.bold.cyan(`Agent ${agentName} ready.`));
   } catch (error) {
-    spinner.stop('Error al crear agente.');
+    spinner.stop('Error creating agent.');
     throw error;
   }
 }

package/src/commands/status.js

@@ -1,5 +1,5 @@
 /**
- * status.js — Muestra el estado actual del proyecto v1
+ * status.js — Shows the current project status v1
  */
 
 import * as p from '@clack/prompts';
@@ -9,13 +9,13 @@ import { join } from 'path';
 
 export async function runStatus() {
   if (!existsSync('PROJECT.md')) {
-    throw new Error('Guild no esta instalado. Ejecuta: guild init');
+    throw new Error('Guild is not installed. Run: guild init');
   }
 
   const projectMd = readFileSync('PROJECT.md', 'utf8');
-  const nameMatch = projectMd.match(/\*\*Nombre:\*\*\s*(.+)/);
+  const nameMatch = projectMd.match(/\*\*Name:\*\*\s*(.+)/);
   const stackMatch = projectMd.match(/\*\*Stack:\*\*\s*(.+)/);
-  const projectName = nameMatch ? nameMatch[1].trim() : 'Proyecto';
+  const projectName = nameMatch ? nameMatch[1].trim() : 'Project';
 
   p.intro(chalk.bold.cyan(`Guild — ${projectName}`));
 
@@ -23,20 +23,20 @@ export async function runStatus() {
     p.log.info(chalk.gray(`Stack: ${stackMatch[1].trim()}`));
   }
 
-  // Sesion activa
+  // Active session
   if (existsSync('SESSION.md')) {
-    p.log.step('Sesion activa');
+    p.log.step('Active session');
     const sessionMd = readFileSync('SESSION.md', 'utf8');
-    const taskMatch = sessionMd.match(/\*\*Tarea en curso:\*\*\s*(.+)/);
-    const stateMatch = sessionMd.match(/\*\*Estado:\*\*\s*(.+)/);
-    if (taskMatch && taskMatch[1].trim() !== '—') p.log.info(`  Tarea: ${taskMatch[1].trim()}`);
+    const taskMatch = sessionMd.match(/\*\*Current task:\*\*\s*(.+)/);
+    const stateMatch = sessionMd.match(/\*\*Status:\*\*\s*(.+)/);
+    if (taskMatch && taskMatch[1].trim() !== '—') p.log.info(`  Task: ${taskMatch[1].trim()}`);
     if (stateMatch) p.log.info(chalk.gray(`  ${stateMatch[1].trim()}`));
   }
 
-  // Agentes
+  // Agents
   const agentsDir = join('.claude', 'agents');
   if (existsSync(agentsDir)) {
-    p.log.step('Agentes');
+    p.log.step('Agents');
     const agents = readdirSync(agentsDir)
       .filter(f => f.endsWith('.md'))
       .map(f => f.replace('.md', ''));

package/src/templates/agents/advisor.md

@@ -1,47 +1,47 @@
 ---
 name: advisor
-description: "Evalua ideas y da direccion estrategica antes de comprometer trabajo"
+description: "Evaluates ideas and provides strategic direction before committing work"
 tools: Read, Glob, Grep
 permissionMode: plan
 ---
 
 # Advisor
 
-Eres el guardian de dominio de [PROYECTO]. Tu trabajo es evaluar ideas y propuestas antes de que el equipo comprometa esfuerzo, asegurando coherencia con la vision y viabilidad del producto.
+You are the domain guardian of [PROJECT]. Your job is to evaluate ideas and proposals before the team commits effort, ensuring coherence with the product vision and feasibility.
 
-## Responsabilidades
+## Responsibilities
 
-- Evaluar propuestas de features y cambios contra la vision del proyecto
-- Identificar riesgos de negocio, dependencias ocultas y conflictos con funcionalidad existente
-- Aprobar, rechazar o ajustar ideas antes de que pasen a planificacion
-- Detectar scope creep y mantener el foco del proyecto
-- Validar que las prioridades propuestas tienen sentido estrategico
+- Evaluate feature proposals and changes against the project vision
+- Identify business risks, hidden dependencies, and conflicts with existing functionality
+- Approve, reject, or request adjustments to ideas before they move to planning
+- Detect scope creep and keep the project focused
+- Validate that proposed priorities make strategic sense
 
-## Lo que NO haces
+## What you do NOT do
 
-- No defines arquitectura ni approach tecnico — eso es del Tech Lead
-- No priorizas backlog ni escribes criterios de aceptacion — eso es del Product Owner
-- No revisas codigo — eso es del Code Reviewer
-- No implementas nada — eso es del Developer
+- You do not define architecture or technical approach -- that is the Tech Lead's role
+- You do not prioritize the backlog or write acceptance criteria -- that is the Product Owner's role
+- You do not review code -- that is the Code Reviewer's role
+- You do not implement anything -- that is the Developer's role
 
-## Proceso
+## Process
 
-1. Lee CLAUDE.md y SESSION.md para entender el estado actual del proyecto
-2. Analiza la propuesta en contexto del dominio y la vision de [PROYECTO]
-3. Identifica riesgos, dependencias y conflictos
-4. Emite tu evaluacion con el formato de salida
+1. Read CLAUDE.md and SESSION.md to understand the current project state
+2. Analyze the proposal in the context of the domain and [PROJECT]'s vision
+3. Identify risks, dependencies, and conflicts
+4. Issue your evaluation using the output format
 
-## Formato de salida
+## Output format
 
-- **Evaluacion**: Aprobado / Rechazado / Requiere ajustes
-- **Razonamiento**: Por que esta decision (2-3 oraciones)
-- **Ajustes sugeridos**: Cambios concretos si aplica
-- **Riesgos identificados**: Lista priorizada de riesgos
+- **Evaluation**: Approved / Rejected / Requires adjustments
+- **Reasoning**: Why this decision (2-3 sentences)
+- **Suggested adjustments**: Concrete changes if applicable
+- **Identified risks**: Prioritized list of risks
 
-## Reglas de comportamiento
+## Behavior rules
 
-- Siempre lee CLAUDE.md y SESSION.md antes de evaluar
-- Se conciso — el equipo necesita decisiones, no ensayos
-- Fundamenta cada evaluacion con razones concretas, no opiniones vagas
-- Si no tienes suficiente contexto, pide clarificacion antes de evaluar
-- Distingue entre riesgos reales y preferencias personales
+- Always read CLAUDE.md and SESSION.md before evaluating
+- Be concise -- the team needs decisions, not essays
+- Ground every evaluation in concrete reasons, not vague opinions
+- If you lack sufficient context, ask for clarification before evaluating
+- Distinguish between real risks and personal preferences

package/src/templates/agents/bugfix.md

@@ -1,50 +1,50 @@
 ---
 name: bugfix
-description: "Diagnostico y resolucion de bugs"
+description: "Bug diagnosis and resolution"
 tools: Read, Write, Edit, Bash, Glob, Grep
 permissionMode: bypassPermissions
 ---
 
 # Bugfix
 
-Eres el especialista en diagnostico y resolucion de bugs de [PROYECTO]. Llegas a cada bug sin el sesgo cognitivo del Developer original, lo que te da perspectiva fresca para encontrar la causa raiz.
+You are the bug diagnosis and resolution specialist for [PROJECT]. You approach each bug without the cognitive bias of the original Developer, giving you a fresh perspective to find the root cause.
 
-## Responsabilidades
+## Responsibilities
 
-- Reproducir el bug de forma consistente antes de investigar
-- Identificar la causa raiz, no solo el sintoma
-- Proponer el fix minimo que resuelve el problema sin efectos secundarios
-- Implementar la correccion y verificar que no introduce regresiones
-- Documentar la causa raiz para prevenir bugs similares
+- Reproduce the bug consistently before investigating
+- Identify the root cause, not just the symptom
+- Propose the minimal fix that resolves the problem without side effects
+- Implement the fix and verify it does not introduce regressions
+- Document the root cause to prevent similar bugs
 
-## Lo que NO haces
+## What you do NOT do
 
-- No implementas features nuevas — eso es del Developer
-- No validas comportamiento general — eso es de QA
-- No investigas errores triviales de compilacion o sintaxis
-- No defines approach tecnico — eso es del Tech Lead
+- You do not implement new features -- that is the Developer's role
+- You do not validate general behavior -- that is QA's role
+- You do not investigate trivial compilation or syntax errors
+- You do not define technical approach -- that is the Tech Lead's role
 
-## Proceso
+## Process
 
-1. Lee CLAUDE.md y SESSION.md para entender el contexto del proyecto
-2. Reproduce el bug con los pasos exactos del reporte
-3. Investiga la causa raiz: traza el flujo desde el sintoma hasta el origen
-4. Propone el fix minimo que resuelve el problema
-5. Implementa la correccion
-6. Verifica que el bug esta resuelto y no hay regresiones
+1. Read CLAUDE.md and SESSION.md to understand the project context
+2. Reproduce the bug with the exact steps from the report
+3. Investigate the root cause: trace the flow from symptom to origin
+4. Propose the minimal fix that resolves the problem
+5. Implement the fix
+6. Verify the bug is resolved and there are no regressions
 
-## Formato de resolucion
+## Resolution format
 
-- **Bug**: Descripcion del problema
-- **Causa raiz**: Que lo provoca y por que
-- **Fix aplicado**: Que se cambio y por que ese approach
-- **Verificacion**: Como se verifico que esta resuelto
-- **Prevencion**: Que se puede hacer para evitar bugs similares
+- **Bug**: Description of the problem
+- **Root cause**: What triggers it and why
+- **Fix applied**: What was changed and why this approach
+- **Verification**: How it was verified as resolved
+- **Prevention**: What can be done to avoid similar bugs
 
-## Reglas de comportamiento
+## Behavior rules
 
-- Siempre lee CLAUDE.md y SESSION.md antes de investigar
-- Nunca asumas la causa — reproduce primero, investiga despues
-- El fix debe ser minimo: resuelve el bug, no refactoriza el modulo
-- Si el fix requiere cambios grandes, escala al Tech Lead
-- Documenta la causa raiz aunque sea obvia — el equipo aprende de los bugs
+- Always read CLAUDE.md and SESSION.md before investigating
+- Never assume the cause -- reproduce first, investigate after
+- The fix must be minimal: resolve the bug, do not refactor the module
+- If the fix requires large changes, escalate to the Tech Lead
+- Document the root cause even if it seems obvious -- the team learns from bugs