elsabro 7.0.0 → 7.1.0

package/bin/install.js

@@ -234,10 +234,10 @@ if (hasUpdate) {
   console.log(`  ${cyan}Verificando actualizaciones...${reset}\n`);
 
   // Check if there's a newer version first to prevent infinite loops
-  checkLatestVersion().then((latestVersion) => {
+  checkLatestVersion().then(async (latestVersion) => {
     if (!latestVersion) {
       console.log(`  ${yellow}⚠${reset} No se pudo verificar la última versión`);
-      console.log(`  ${dim}Intentando actualizar de todas formas...${reset}\n`);
+      console.log(`  ${dim}Reinstalando archivos locales...${reset}\n`);
     } else if (latestVersion === pkg.version) {
       console.log(`  ${green}✓${reset} Versión actual: ${pkg.version} (ya es la última)`);
       console.log(`  ${dim}Reinstalando archivos locales...${reset}\n`);
@@ -247,27 +247,31 @@ if (hasUpdate) {
     }
 
     try {
-      // Use specific version from registry to avoid cache issues
-      // Don't pass --update to avoid infinite recursion
-      const versionToInstall = latestVersion || 'latest';
-      const packageSpec = `elsabro@${versionToInstall}`;
-
-      if (packageManager === 'pnpm') {
-        execFileSync(getExecutable('pnpm'), ['dlx', packageSpec, '--global'], { stdio: 'inherit' });
-      } else if (packageManager === 'bun') {
-        execFileSync(getExecutable('bunx'), [packageSpec, '--global'], { stdio: 'inherit' });
+      if (!latestVersion || latestVersion === pkg.version) {
+        // Already up to date — reinstall from local package directly
+        // (avoids npm CDN cache lag returning a stale version)
+        await install();
+        console.log(`\n  ${green}✓${reset} ELSABRO reinstalado v${pkg.version}\n`);
       } else {
-        // npm exec with specific version bypasses cache
-        execFileSync(getExecutable('npm'), ['exec', '--yes', '--', packageSpec, '--global'], { stdio: 'inherit' });
+        // Newer version available — download from npm
+        const packageSpec = `elsabro@${latestVersion}`;
+
+        if (packageManager === 'pnpm') {
+          execFileSync(getExecutable('pnpm'), ['dlx', packageSpec, '--global'], { stdio: 'inherit' });
+        } else if (packageManager === 'bun') {
+          execFileSync(getExecutable('bunx'), [packageSpec, '--global'], { stdio: 'inherit' });
+        } else {
+          execFileSync(getExecutable('npm'), ['exec', '--yes', '--', packageSpec, '--global'], { stdio: 'inherit' });
+        }
+        console.log(`\n  ${green}✓${reset} ELSABRO actualizado a v${latestVersion}\n`);
       }
-      console.log(`\n  ${green}✓${reset} ELSABRO actualizado a v${versionToInstall}\n`);
     } catch (error) {
       console.error(`\n  ${red}✗${reset} Error al actualizar: ${error.message}\n`);
       process.exit(1);
     }
     process.exit(0);
   });
-} else {
+}
 
 // Interactive prompt for location if not specified
 async function promptLocation() {
@@ -502,6 +506,7 @@ async function uninstall() {
 }
 
 // Main (note: update handling is above with its own process.exit)
+if (!hasUpdate) {
   if (hasUninstall) {
     uninstall().catch((error) => {
       console.error(`  ${red}✗${reset} Error: ${error.message}`);

package/commands/elsabro/execute.md

@@ -666,19 +666,34 @@ TaskUpdate({ taskId: "plan-A-id", status: "completed" })
 
 ### Validación arquitectónica en paralelo (OPUS x2)
 ```javascript
-// Además de implementar, validar arquitectura en paralelo
+// OBLIGATORIO: Crear Agent Team para validación arquitectónica (Rule 8)
+TeamCreate({
+  team_name: "elsabro-arch-validate",
+  description: "Architectural validation: implementation + architecture review"
+})
+
+// Spawn 2 teammates OPUS en paralelo
 Task({
   subagent_type: "elsabro-executor",
   model: "opus",
+  team_name: "elsabro-arch-validate",
+  name: "impl-1",
   description: "Implementar cambios",
   prompt: "..."
 }) |
 Task({
   subagent_type: "feature-dev:code-architect",
   model: "opus",  // ← OPUS para decisiones arquitectónicas
+  team_name: "elsabro-arch-validate",
+  name: "architect-1",
   description: "Validar arquitectura",
   prompt: "Verifica que la implementación sigue los patrones del codebase..."
 })
+
+// Shutdown y cleanup
+SendMessage({ type: "shutdown_request", recipient: "impl-1", content: "Validation complete" })
+SendMessage({ type: "shutdown_request", recipient: "architect-1", content: "Validation complete" })
+TeamDelete()
 ```
 
 ### Si solo hay un plan → Secuencial (OPUS)
@@ -1062,15 +1077,33 @@ if (shouldUseWorktrees(wave, profile)) {
   // Crear worktrees
   Bash(`./scripts/setup-parallel-worktrees.sh create ${agents.join(' ')}`);
 
-  // Ejecutar agentes en sus worktrees
-  for (const agent of agents) {
+  // OBLIGATORIO: Crear Agent Team para worktree paralelo (Rule 8)
+  TeamCreate({
+    team_name: "elsabro-worktree",
+    description: "Parallel worktree execution for wave " + wave.id
+  })
+
+  // Ejecutar agentes como teammates en sus worktrees
+  for (let i = 0; i < agents.length; i++) {
     Task({
-      subagent_type: agent,
-      prompt: `Trabaja en worktree: ../elsabro-worktrees/${agent}-wt/`
+      subagent_type: agents[i],
+      team_name: "elsabro-worktree",
+      name: `wt-agent-${i + 1}`,
+      prompt: `Trabaja en worktree: ../elsabro-worktrees/${agents[i]}-wt/`
     });
   }
 
-  // Merge y cleanup al completar
+  // Shutdown teammates y cleanup team
+  for (let i = 0; i < agents.length; i++) {
+    SendMessage({
+      type: "shutdown_request",
+      recipient: `wt-agent-${i + 1}`,
+      content: "Worktree work complete"
+    });
+  }
+  TeamDelete();
+
+  // Merge y cleanup worktrees al completar
   Bash(`./scripts/setup-parallel-worktrees.sh complete ${agents.join(' ')}`);
 }
 ```
@@ -1142,12 +1175,33 @@ errorAggregator.setPolicy("quorum");
 for (const wave of waves) {
   timeoutHandler.startTimeout(wave.id, 60 * 60 * 1000); // 60min por wave
 
+  // OBLIGATORIO: Crear Agent Team para wave de implementacion (Rule 8)
+  TeamCreate({
+    team_name: "elsabro-wave-impl",
+    description: "Implementation wave " + wave.id
+  })
+
   const results = await Promise.all(
-    wave.plans.map(plan =>
-      executeWithRetry(plan.id, () => Task(elsabro-executor, plan))
+    wave.plans.map((plan, i) =>
+      executeWithRetry(plan.id, () => Task({
+        subagent_type: "elsabro-executor",
+        team_name: "elsabro-wave-impl",
+        name: `wave-executor-${i + 1}`,
+        prompt: plan
+      }))
     )
   );
 
+  // Shutdown teammates y cleanup team
+  wave.plans.forEach((_, i) => {
+    SendMessage({
+      type: "shutdown_request",
+      recipient: `wave-executor-${i + 1}`,
+      content: "Wave complete"
+    });
+  });
+  TeamDelete();
+
   const summary = await errorAggregator.aggregate(wave.id, results);
 
   if (summary.decision === "STOP") {

package/commands/elsabro/party.md

@@ -193,6 +193,63 @@ Al final, generar consenso y puntos de debate:
 
 Genera `.planning/PARTY-{topic-slug}-SUMMARY.md` usando template.
 
+<agent_teams_gate>
+## Agent Teams Gate (OBLIGATORIO)
+
+Party Mode uses 2-3 agents per round in parallel → Agent Teams is OBLIGATORIO.
+
+```
+Each round with 2+ agents?
+│
+├─ YES → TeamCreate("elsabro-party-rN")
+│         Task(team_name: "elsabro-party-rN", name: "agent-K") per agent
+│         ... round execution ...
+│         SendMessage(shutdown_request) per agent
+│         TeamDelete()
+│
+└─ Synthesis (1 agent only) → Single Task(orchestrator) — no team needed
+```
+
+**VIOLACION CRITICA**: Lanzar 2+ agentes de party sin Agent Teams = ABORTAR
+</agent_teams_gate>
+
+<IMPERATIVO_AGENT_TEAMS>
+## ⛔ STOP — LEER ANTES DE LANZAR AGENTES DE PARTY
+
+**REGLA NO NEGOCIABLE (Rule 8):** Cada round de Party Mode con 2+ agentes DEBE usar Agent Teams.
+
+1. **PRIMERO** → `TeamCreate({ team_name: "elsabro-party-rN", description: "Party round N" })`
+2. **DESPUES** → `Task({ ..., team_name: "elsabro-party-rN", name: "agent-K" })` for each agent
+3. **AL FINAL** → `SendMessage({ type: "shutdown_request", ... })` for EACH teammate
+4. **ULTIMO** → `TeamDelete()`
+
+**Synthesis is exempt:** Only 1 agent (orchestrator), no team needed.
+
+**NUNCA hagas esto:**
+```javascript
+// ⛔ PROHIBIDO — bare Task() per agent in a round
+onAgentTurn: async ({ agent }) => {
+  return Task({ subagent_type: `elsabro-${agent.id}`, prompt: "..." });
+}
+// 3 agents = 3 bare Task() calls = Rule 8 VIOLATION
+```
+
+**SIEMPRE haz esto:**
+```javascript
+// ✅ CORRECTO — team per round (via onBeforeRound/onAfterRound callbacks)
+onBeforeRound: ({ round, agents }) => {
+  TeamCreate({ team_name: `elsabro-party-r${round}`, description: `Party round ${round}` });
+}
+onAgentTurn: ({ agent, round, agentIndex }) => {
+  return Task({ subagent_type: `elsabro-${agent.id}`, team_name: `elsabro-party-r${round}`, name: `agent-${agentIndex + 1}`, prompt: "..." });
+}
+onAfterRound: ({ round, agents }) => {
+  agents.forEach((_, i) => SendMessage({ type: "shutdown_request", recipient: `agent-${i + 1}`, content: "Done" }));
+  TeamDelete();
+}
+```
+</IMPERATIVO_AGENT_TEAMS>
+
 ## Implementacion Tecnica (PartyEngine v7.0.0)
 
 Party Mode is powered by `PartyEngine` from `flow-engine/src/party.js`. The engine handles agent selection, round management, checkpointing, and synthesis through callbacks.
@@ -213,16 +270,30 @@ const agents = engine.selectAgents(topic, {
 // Display agent cards with emoji, name, focus
 
 // 3. Run party session with callbacks
+// NOTE: Team lifecycle is managed PER ROUND via onBeforeRound/onAfterRound.
+// Each round creates a team, spawns agents as teammates, then destroys the team.
 const result = await engine.run(topic, {
   agents: inputs.agents || undefined,
   maxRounds: inputs.rounds || 3,
   projectContext: state.context
 }, {
-  onAgentTurn: async ({ agent, topic, round, totalRounds, history, instruction }) => {
-    // Each agent turn delegates to the real ELSABRO agent via Task()
+  onBeforeRound: async ({ round, agents }) => {
+    // AGENT TEAMS (Rule 8): Create team for this round
+    // Each round has 2-3 agents in parallel → TeamCreate OBLIGATORIO
+    TeamCreate({
+      team_name: `elsabro-party-r${round}`,
+      description: `Party Mode round ${round} — ${agents.map(a => a.name).join(', ')}`
+    });
+  },
+
+  onAgentTurn: async ({ agent, topic, round, totalRounds, history, instruction, agentIndex }) => {
+    // Each agent is spawned as a teammate within the round's team
+    // team_name and name are REQUIRED for Rule 8 compliance
     return Task({
       subagent_type: `elsabro-${agent.id}`,
       model: "sonnet",
+      team_name: `elsabro-party-r${round}`,
+      name: `agent-${agentIndex + 1}`,
       prompt: `You are ${agent.name}. ${agent.style}.
         Focus: ${agent.focus}. Tendency: ${agent.tendency}.
         Topic: "${topic}". Round: ${round}/${totalRounds}.
@@ -232,8 +303,21 @@ const result = await engine.run(topic, {
     });
   },
 
+  onAfterRound: async ({ round, agents }) => {
+    // AGENT TEAMS (Rule 8): Shutdown all teammates and delete team
+    for (let i = 0; i < agents.length; i++) {
+      SendMessage({
+        type: "shutdown_request",
+        recipient: `agent-${i + 1}`,
+        content: `Round ${round} complete`
+      });
+    }
+    TeamDelete();
+  },
+
   onSynthesize: async ({ history, topic, agents }) => {
     // Orchestrator (Quantum) synthesizes the debate
+    // Single agent — NO team needed (Rule 8 exception: 1 agent)
     return Task({
       subagent_type: "elsabro-orchestrator",
       model: "sonnet",
@@ -249,6 +333,7 @@ const result = await engine.run(topic, {
 
   onRoundComplete: async ({ completedRound, totalRounds, lastResponses }) => {
     // Ask user if they want to continue, stop, or add a round
+    // Single interaction — NO team needed (not parallel agents)
     const answer = AskUserQuestion({
       questions: [{
         question: `Round ${completedRound}/${totalRounds} complete. Continue?`,

package/commands/elsabro/start.md

@@ -208,7 +208,8 @@ Veo que estás en una carpeta vacía. ¿Qué te gustaría crear?
 2) 📱 Una app móvil (Expo/React Native)
 3) 🔌 Una API o microservicio
 4) 🧩 Una extensión de Chrome
-5) 💡 Tengo otra idea (cuéntame)
+5) 🎨 Primero quiero ver cómo se vería (diseñar UI)
+6) 💡 Tengo otra idea (cuéntame)
 ```
 
 ### Para Brownfield (código existente):
@@ -221,7 +222,8 @@ Veo que estás en una carpeta vacía. ¿Qué te gustaría crear?
 2) 🐛 Arreglar algo que no funciona
 3) 📖 Entender cómo funciona el código
 4) 🔄 Refactorizar o mejorar algo
-5) ❓ Otra cosa (cuéntame)
+5) 🎨 Diseñar o rediseñar la interfaz
+6) ❓ Otra cosa (cuéntame)
 ```
 
 ### Para Continuation (proyecto ELSABRO existente):
@@ -236,7 +238,8 @@ Tu proyecto: [context.project_type]
 1) ▶️ Continuar con la siguiente fase
 2) ✅ Verificar el trabajo anterior
 3) 📋 Ver el plan completo
-4) 🆕 Empezar algo diferente
+4) 🎨 Diseñar o ajustar la interfaz
+5) 🆕 Empezar algo diferente
 ```
 
 Usar `AskUserQuestion` con las opciones correspondientes.
@@ -292,6 +295,7 @@ TaskUpdate(id, status: "in_progress")
 | App móvil | new + plan | `Skill("mobile-app")` luego `Skill("elsabro:plan")` |
 | API | new + plan | `Skill("api-microservice")` luego `Skill("elsabro:plan")` |
 | Chrome extension | new + plan | `Skill("chrome-extension")` luego `Skill("elsabro:plan")` |
+| Diseñar UI | design-ui | `Skill("elsabro:design-ui")` |
 | Otra idea | plan | `Skill("elsabro:plan")` con contexto |
 
 #### Brownfield:
@@ -301,6 +305,7 @@ TaskUpdate(id, status: "in_progress")
 | Arreglar bug | debug | `Skill("elsabro:debug")` |
 | Entender código | map-codebase | `Skill("elsabro:map-codebase")` |
 | Refactorizar | plan | `Skill("elsabro:plan")` con intent="refactor" |
+| Diseñar UI | design-ui | `Skill("elsabro:design-ui")` |
 
 #### Continuation:
 | Opción Usuario | Comando | Skill a Invocar |
@@ -308,6 +313,7 @@ TaskUpdate(id, status: "in_progress")
 | Continuar siguiente | execute/plan | Según `pending_tasks` |
 | Verificar anterior | verify-work | `Skill("elsabro:verify-work")` |
 | Ver plan | read | Mostrar `.planning/*.md` |
+| Diseñar UI | design-ui | `Skill("elsabro:design-ui")` |
 | Algo diferente | → Paso 3 | Mostrar opciones de brownfield |
 
 ### 4.4 Invocar comando con contexto

package/flow-engine/src/party.js

@@ -205,7 +205,9 @@ class PartyEngine {
    * @param {string} topic – discussion topic
    * @param {object} [options] – { agents, maxRounds, maxAgents, projectContext }
    * @param {object} callbacks
-   * @param {function} callbacks.onAgentTurn – (params) => string response
+   * @param {function} callbacks.onAgentTurn – ({ agent, topic, round, totalRounds, history, instruction, agentIndex, projectContext }) => string response
+   * @param {function} [callbacks.onBeforeRound] – ({ round, totalRounds, agents }) => void (e.g., create Agent Team)
+   * @param {function} [callbacks.onAfterRound] – ({ round, totalRounds, agents, responses }) => void (e.g., destroy Agent Team)
    * @param {function} [callbacks.onSynthesize] – (params) => { consensus, debates, actionItems, keyInsights, suggestedNext }
    * @param {function} [callbacks.onRoundComplete] – (params) => "continue"|"stop"|"add_round"
    * @param {function} [callbacks.onFormatSummary] – (template, data) => string
@@ -224,7 +226,13 @@ class PartyEngine {
     for (let round = 1; round <= totalRounds; round++) {
       const roundResponses = [];
 
-      for (const agent of agents) {
+      // Hook: before round starts (e.g., create Agent Team)
+      if (callbacks.onBeforeRound) {
+        await callbacks.onBeforeRound({ round, totalRounds, agents });
+      }
+
+      for (let agentIdx = 0; agentIdx < agents.length; agentIdx++) {
+        const agent = agents[agentIdx];
         const instruction = round === 1
           ? 'Share your initial perspective on this topic.'
           : 'React to previous perspectives and refine your position.';
@@ -236,6 +244,7 @@ class PartyEngine {
           totalRounds,
           history: [...history],
           instruction,
+          agentIndex: agentIdx,
           projectContext: options.projectContext || null
         });
 
@@ -250,6 +259,11 @@ class PartyEngine {
         roundResponses.push(entry);
       }
 
+      // Hook: after round completes (e.g., destroy Agent Team)
+      if (callbacks.onAfterRound) {
+        await callbacks.onAfterRound({ round, totalRounds, agents, responses: roundResponses });
+      }
+
       // Checkpoint after each round
       this.checkpoint.save(sessionId, {
         topic,
@@ -323,7 +337,13 @@ class PartyEngine {
     for (let round = startRound; round <= rounds; round++) {
       const roundResponses = [];
 
-      for (const agent of agents) {
+      // Hook: before round starts (e.g., create Agent Team)
+      if (callbacks.onBeforeRound) {
+        await callbacks.onBeforeRound({ round, totalRounds: rounds, agents });
+      }
+
+      for (let agentIdx = 0; agentIdx < agents.length; agentIdx++) {
+        const agent = agents[agentIdx];
         const instruction = round === 1
           ? 'Share your initial perspective on this topic.'
           : 'React to previous perspectives and refine your position.';
@@ -335,6 +355,7 @@ class PartyEngine {
           totalRounds: rounds,
           history: [...history],
           instruction,
+          agentIndex: agentIdx,
           projectContext: (options && options.projectContext) || null
         });
 
@@ -349,6 +370,11 @@ class PartyEngine {
         roundResponses.push(entry);
       }
 
+      // Hook: after round completes (e.g., destroy Agent Team)
+      if (callbacks.onAfterRound) {
+        await callbacks.onAfterRound({ round, totalRounds: rounds, agents, responses: roundResponses });
+      }
+
       this.checkpoint.save(sessionId, {
         topic,
         agents: agentIds,

package/flow-engine/tests/cli.test.js

@@ -48,10 +48,10 @@ describe('CLI: helpers', () => {
 // ---------- validate ----------
 
 describe('CLI: validate', () => {
-  it('reports valid flow with 42 nodes', async () => {
+  it('reports valid flow with 44 nodes', async () => {
     const result = await main(['node', 'cli.js', 'validate', '--flow', FLOW_PATH]);
     assert.equal(result.valid, true);
-    assert.equal(result.nodeCount, 42);
+    assert.equal(result.nodeCount, 44);
     assert.ok(result.parallelNodes.length >= 4);
   });
 

package/flow-engine/tests/graph.test.js

@@ -154,7 +154,7 @@ describe('real flow loading', () => {
   it('loads the full development-flow.json', () => {
     const flow = require('../../flows/development-flow.json');
     const graph = buildGraph(flow);
-    assert.equal(graph.nodes.size, 42);
+    assert.equal(graph.nodes.size, 44);
     assert.equal(graph.entryNode, 'start');
     assert.equal(graph.meta.version, '5.3.0');
   });

package/flow-engine/tests/integration.test.js

@@ -52,10 +52,10 @@ function makeMockCallbacks() {
 }
 
 describe('Integration: Graph loading', () => {
-  it('loads all 42 nodes from development-flow.json', () => {
+  it('loads all 44 nodes from development-flow.json', () => {
     const engine = new FlowEngine();
     engine.loadFlow(flow);
-    assert.equal(engine.getNodeCount(), 42);
+    assert.equal(engine.getNodeCount(), 44);
   });
 
   it('finds the entry node at "start"', () => {
@@ -68,8 +68,8 @@ describe('Integration: Graph loading', () => {
     const engine = new FlowEngine();
     engine.loadFlow(flow);
     const meta = engine.getFlowMetadata();
-    assert.equal(meta.sync_metadata.audit_result.total_nodes, 42);
-    assert.equal(meta.sync_metadata.audit_result.implemented, 40);
+    assert.equal(meta.sync_metadata.audit_result.total_nodes, 44);
+    assert.equal(meta.sync_metadata.audit_result.implemented, 42);
     assert.equal(meta.sync_metadata.audit_result.partial, 0);
     assert.equal(meta.sync_metadata.audit_result.not_implemented, 0);
     assert.equal(meta.sync_metadata.audit_result.deprecated, 2);
@@ -79,7 +79,7 @@ describe('Integration: Graph loading', () => {
     const engine = new FlowEngine();
     engine.loadFlow(flow);
     const implemented = engine.getNodesWhere(n => n.runtime_status === 'implemented');
-    assert.equal(implemented.length, 40);
+    assert.equal(implemented.length, 42);
   });
 
   it('counts not_implemented nodes correctly', () => {
@@ -871,10 +871,10 @@ describe('Integration: P5 Cleanup & Deprecation', () => {
     assert.deepStrictEqual(ids, ['interrupt_teams_failed', 'teams_spawn']);
   });
 
-  it('40 implemented nodes exist', () => {
+  it('42 implemented nodes exist', () => {
     const engine = new FlowEngine();
     engine.loadFlow(flow);
     const implemented = engine.getNodesWhere(n => n.runtime_status === 'implemented');
-    assert.equal(implemented.length, 40);
+    assert.equal(implemented.length, 42);
   });
 });

package/flow-engine/tests/party.test.js

@@ -399,6 +399,63 @@ describe('Round Management', () => {
       { message: /requires callbacks.onAgentTurn/ }
     );
   });
+
+  it('calls onBeforeRound before each round', async () => {
+    const dir = tmpDir();
+    const engine = new PartyEngine({ checkpointDir: dir, maxRounds: 2, maxAgents: 2 });
+    const beforeCalls = [];
+    await engine.run('architecture', { maxRounds: 2 }, {
+      onAgentTurn: mockOnAgentTurn,
+      onBeforeRound: ({ round, agents }) => {
+        beforeCalls.push({ round, agentCount: agents.length });
+      }
+    });
+    assert.equal(beforeCalls.length, 2);
+    assert.equal(beforeCalls[0].round, 1);
+    assert.equal(beforeCalls[1].round, 2);
+    assert.ok(beforeCalls[0].agentCount >= 2);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('calls onAfterRound after each round', async () => {
+    const dir = tmpDir();
+    const engine = new PartyEngine({ checkpointDir: dir, maxRounds: 2, maxAgents: 2 });
+    const afterCalls = [];
+    await engine.run('architecture', { maxRounds: 2 }, {
+      onAgentTurn: mockOnAgentTurn,
+      onAfterRound: ({ round, responses }) => {
+        afterCalls.push({ round, responseCount: responses.length });
+      }
+    });
+    assert.equal(afterCalls.length, 2);
+    assert.equal(afterCalls[0].round, 1);
+    assert.ok(afterCalls[0].responseCount >= 2);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('provides agentIndex in onAgentTurn', async () => {
+    const dir = tmpDir();
+    const engine = new PartyEngine({ checkpointDir: dir, maxRounds: 1, maxAgents: 3 });
+    const indices = [];
+    await engine.run('architecture', { maxRounds: 1 }, {
+      onAgentTurn: ({ agentIndex }) => {
+        indices.push(agentIndex);
+        return 'response';
+      }
+    });
+    assert.deepEqual(indices, [0, 1, 2]);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('onBeforeRound and onAfterRound are optional (backward compat)', async () => {
+    const dir = tmpDir();
+    const engine = new PartyEngine({ checkpointDir: dir, maxRounds: 1, maxAgents: 2 });
+    const result = await engine.run('testing', { maxRounds: 1 }, {
+      onAgentTurn: mockOnAgentTurn
+    });
+    assert.ok(result.history.length >= 2);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
 });
 
 // ── Suite 4: Synthesis ───────────────────────────────────────────────────────