elsabro 6.0.1 → 7.0.1

package/agents/elsabro-orchestrator.md

@@ -345,6 +345,45 @@ Archivos modificados:
 - `elsabro-qa` - Para testing paralelo
 </integration_with_elsabro>
 
+<party_mode>
+## Party Mode (Moderation)
+
+When invoked as Party Master via `onSynthesize` callback in `/elsabro:party`:
+
+### Role
+- Synthesize multi-agent debate into consensus/debates/actions
+- Identify agreement vs disagreement patterns across rounds
+- Weight later-round positions higher (refined after discussion)
+- Format synthesis as structured JSON for PartyEngine
+
+### Synthesis Contract
+
+Input: Full discussion history with agent names, rounds, and responses.
+
+Output JSON:
+```json
+{
+  "consensus": ["Points all agents agreed on"],
+  "debates": ["Points with disagreement, with each agent's position"],
+  "actionItems": ["Concrete next steps derived from discussion"],
+  "keyInsights": ["Non-obvious insights that emerged from the debate"],
+  "suggestedNext": "plan|execute|discuss-phase|research-phase"
+}
+```
+
+### Integration
+- PartyEngine calls `onSynthesize({ history, topic, agents })`
+- Quantum receives the full debate history and produces structured output
+- The synthesis is used to generate PARTY-SUMMARY.md and update state.json
+- `suggestedNext` drives the next-step-engine recommendation
+
+### Agent Coordination in Party Mode
+Unlike parallel execution (waves), Party Mode is **sequential deliberation**:
+- Each agent speaks one at a time within a round
+- History is cumulative — each agent sees all prior responses
+- Quantum synthesizes only after all rounds complete
+</party_mode>
+
 <agent_teams>
 ## Agent Teams Integration (v4.2.0 — Mandatory)
 

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/add-phase.md

@@ -4,6 +4,7 @@ description: Agregar una nueva fase al final del milestone actual
 sync:
   reads: [".elsabro/state.json"]
   writes: [".elsabro/state.json"]
+agents: [elsabro-scrum-master]
 ---
 
 # /elsabro:add-phase
@@ -116,6 +117,25 @@ Actualiza `PHASES.md` y `MILESTONE.md`:
 - Verifica nombre único de fase
 - Sugiere dependencias basado en orden
 
+## Agent Validation (Scrum Master)
+
+After phase definition but before writing to PHASES.md, validate using Bob (scrum-master):
+
+```javascript
+Task({
+  subagent_type: "elsabro-scrum-master",
+  model: "haiku",
+  prompt: `Validate this new phase:
+    Phase: ${phaseName}
+    Description: ${phaseDescription}
+    Milestone: ${milestoneContext}
+    Existing phases: ${existingPhases}
+
+    Check: Dependencies ok? Effort estimate reasonable? Overlap with existing phases?
+    Return brief validation with any concerns.`
+})
+```
+
 ## Output
 
 ```

package/commands/elsabro/complete-milestone.md

@@ -4,6 +4,7 @@ description: Cerrar un milestone completado con retrospectiva y documentacion de
 sync:
   reads: [".elsabro/state.json"]
   writes: [".elsabro/state.json", ".elsabro/context.md"]
+agents: [elsabro-tech-writer]
 ---
 
 # /elsabro:complete-milestone
@@ -87,6 +88,25 @@ Si todas las verificaciones pasan, genera `.planning/milestones/M001-xxx/RETROSP
 - [Shoutouts]
 ```
 
+### Paso 2.5: Polish Retrospective (Tech Writer)
+
+After auto-generating the retrospective template, invoke Paige (tech-writer) to polish it into a readable narrative:
+
+```javascript
+Task({
+  subagent_type: "elsabro-tech-writer",
+  model: "haiku",
+  prompt: `Polish this retrospective into a readable narrative:
+    Template: ${autoGeneratedRetrospective}
+    Milestone: ${milestoneName} — ${milestoneObjectives}
+
+    Enhance: Turn bullets into cohesive narrative, highlight key learnings,
+    create 'what we shipped' summary. Keep concise and professional.`
+})
+```
+
+Replace the template-generated retrospective with Paige's polished version before saving.
+
 ### Paso 3: Actualizar Status
 
 Actualiza `MILESTONE.md`:

package/commands/elsabro/design-ui.md

@@ -18,6 +18,7 @@ allowed-tools:
   - mcp__stitch__get_screen
   - mcp__stitch__generate_screen_from_text
 argument-hint: "[descripción de la interfaz o número de fase]"
+agents: [elsabro-ux-designer]
 sync:
   reads: [".elsabro/state.json", ".planning/*-PLAN.md"]
   writes: [".elsabro/state.json", ".elsabro/context.md", ".planning/ui-designs/"]
@@ -225,6 +226,26 @@ for (const screen of screens) {
 }
 ```
 
+## Paso 3.5: UX Review (Sally)
+
+After initial screen generation, invoke Sally (ux-designer) for UX quality review:
+
+```javascript
+Task({
+  subagent_type: "elsabro-ux-designer",
+  model: "sonnet",
+  prompt: `Review these generated screens for UX quality:
+    Screens: ${generatedScreenDescriptions}
+    Tech stack: ${state.context.tech_stack}
+
+    Check: Accessibility (contrast, touch targets, ARIA),
+    flow consistency, mobile responsiveness, brand alignment.
+    Suggest specific refinements with priority.`
+})
+```
+
+Apply Sally's refinement suggestions before showing screens to the user.
+
 ## Paso 4: Revisar y Refinar
 
 ### 4.1 Listar screens generados

package/commands/elsabro/execute.md

@@ -1373,20 +1373,140 @@ Al completar un plan:
 </summary_creation>
 
 <engine_integration>
-## Flow Engine (v6.0.0)
+## Flow Engine (v7.0.0) + CLI
 
-The flow engine runtime is available at `flow-engine/src/index.js`.
-It can parse and execute `flows/development-flow.json`.
+The flow engine runtime is at `flow-engine/src/index.js`.
+The CLI is at `flow-engine/src/cli.js` (also `npm run flow` or `elsabro-flow`).
 
-Current status: Engine handles implemented nodes (19/42).
-Not-implemented nodes throw NotImplementedError with gap descriptions.
+### Quick Reference
 
-For full engine-driven execution (future):
-```javascript
-const { FlowEngine } = require('./flow-engine/src/index.js');
-const flow = require('./flows/development-flow.json');
-const engine = new FlowEngine({ callbacks: { onAgent, onBash, onInterrupt, onCheckpoint, onParallel, onTeamRequired } });
-engine.loadFlow(flow);
-const result = await engine.run({ task, profile, complexity }, callbacks);
+```bash
+# Validate flow + see team compositions
+node flow-engine/src/cli.js validate --flow flows/development-flow.json
+
+# Dry-run (full path, mock callbacks)
+node flow-engine/src/cli.js dry-run --flow flows/development-flow.json --task "feature" --profile default
+
+# Step-based execution
+node flow-engine/src/cli.js init --flow flows/development-flow.json --task "build auth" --profile default
+node flow-engine/src/cli.js step --flow flows/development-flow.json
+node flow-engine/src/cli.js complete --flow flows/development-flow.json --result '{"output": "done"}'
+node flow-engine/src/cli.js status --flow flows/development-flow.json
 ```
 </engine_integration>
+
+<cli_driven_execution>
+## CLI-Driven Execution (v7.0.0)
+
+The CLI manages graph traversal. It auto-resolves simple nodes (entry, condition, router, exit)
+and stops at actionable nodes, emitting a JSON instruction. Claude follows the instruction,
+then calls `complete` to advance.
+
+### Main Loop
+
+```
+init → [step → execute instruction → complete]* → step (finished)
+```
+
+1. **init**: Creates checkpoint at entry node
+2. **step**: Auto-resolves through conditions/routers, stops at actionable node, returns instruction JSON
+3. **execute instruction**: Claude executes based on instruction type (see below)
+4. **complete**: Stores result, advances checkpoint to next node
+5. Repeat step→execute→complete until `step` returns `{ finished: true }`
+
+### Instruction Types
+
+#### `type: "agent"` → Launch single subagent
+```javascript
+// instruction: { type: "agent", nodeId, agent, model, inputs }
+Task({
+  subagent_type: instruction.agent,
+  model: instruction.model,
+  prompt: `Execute task with inputs: ${JSON.stringify(instruction.inputs)}`
+})
+```
+
+#### `type: "parallel"` with `useAgentTeams: false` → Launch subagents (haiku exploration)
+```javascript
+// instruction: { type: "parallel", nodeId, useAgentTeams: false, branches }
+// All-haiku branches → regular subagents, no team needed
+for (const branch of instruction.branches) {
+  Task({
+    subagent_type: branch.agent,
+    model: "haiku",
+    prompt: `Execute: ${JSON.stringify(branch.inputs)}`
+  })
+}
+```
+
+#### `type: "parallel"` with `useAgentTeams: true` → Use Agent Teams (min 5 members)
+```javascript
+// instruction: { type: "parallel", nodeId, useAgentTeams: true, team: { name, members[5+] }, branches }
+//
+// The engine composed a team of 5+ members:
+// - Core branch agents (from flow definition)
+// - Support agents (verifier, qa, debugger, etc.) padded to minimum 5
+//
+// Claude Code handles team lifecycle automatically:
+
+TeamCreate({
+  team_name: instruction.team.name,
+  description: instruction.team.description
+})
+
+// Launch ALL team members (not just branches — the full team of 5+)
+for (const member of instruction.team.members) {
+  Task({
+    subagent_type: member.agent,
+    model: member.model,
+    team_name: instruction.team.name,
+    name: member.name,
+    prompt: `Role: ${member.role}. Execute your part of ${instruction.nodeId}.`
+  })
+}
+
+// When all complete:
+for (const member of instruction.team.members) {
+  SendMessage({ type: "shutdown_request", recipient: member.name, content: "Done" })
+}
+TeamDelete()
+```
+
+#### `type: "interrupt"` → Ask user
+```javascript
+// instruction: { type: "interrupt", nodeId, display, routes, reason }
+AskUserQuestion({
+  questions: [{
+    question: instruction.display.title,
+    options: instruction.display.options.map(o => ({ label: o.label, description: o.id }))
+  }]
+})
+// User's selection maps to a route key → pass as result to complete
+```
+
+#### `type: "sequence"` → Execute steps inline
+```javascript
+// instruction: { type: "sequence", nodeId, steps }
+for (const step of instruction.steps) {
+  if (step.action === "bash") Bash(step.command)
+  if (step.action === "agent") Task({ subagent_type: step.agent, ... })
+  if (step.action === "read_files") Read(step.files)
+}
+```
+
+### Team Compositions (from validate)
+
+| Node | Core | Padded to 5 with | Total |
+|------|------|-------------------|-------|
+| `standard_analyze` | 4 haiku | NO TEAM (subagents) | 4 subagents |
+| `parallel_implementation` | executor, qa | + verifier, analyst, debugger | 5 |
+| `fix_issues` | debugger, error-detective, refactor | + verifier, qa | 5 |
+| `parallel_review` | code-reviewer, silent-failure, staff | + verifier, qa | 5 |
+
+### Rules
+
+1. **Minimum 5 teammates** — Every Agent Team has at least 5 members
+2. **Haiku exception** — All-haiku parallel nodes use subagents, not teams
+3. **One team at a time** — Cleanup before creating next team
+4. **Cleanup required** — SendMessage shutdown + TeamDelete after each team
+</cli_driven_execution>

package/commands/elsabro/new-milestone.md

@@ -4,6 +4,7 @@ description: Crear un nuevo milestone con objetivos, timeline y métricas de éx
 sync:
   reads: [".elsabro/state.json"]
   writes: [".elsabro/state.json", ".elsabro/context.md"]
+agents: [elsabro-scrum-master]
 ---
 
 # /elsabro:new-milestone
@@ -149,6 +150,28 @@ P6: Launch (W10)
 - Linked con `/elsabro:complete-milestone` para cierre
 - Linked con `/elsabro:audit-milestone` para revisión
 
+## Agent Validation (Scrum Master)
+
+After the user defines objectives, timeline, and phases, validate the milestone definition using Bob (scrum-master) before generating the folder structure:
+
+```javascript
+Task({
+  subagent_type: "elsabro-scrum-master",
+  model: "haiku",
+  prompt: `Validate this milestone definition:
+    Name: ${milestoneName}
+    Objectives: ${objectives}
+    Timeline: ${timeline}
+    Phases: ${phases}
+
+    Check: Are timelines realistic? Are phases ordered by dependencies?
+    Are there scope risks? Suggest adjustments if needed.
+    Return a brief validation summary with any warnings.`
+})
+```
+
+If Bob identifies issues, present them to the user before proceeding.
+
 <siguiente_paso>
 ## Siguiente Paso
 

package/commands/elsabro/party.md

@@ -3,7 +3,8 @@ name: party
 description: Party Mode - Discusion multi-agente colaborativa donde 2-3 agentes debaten un tema desde diferentes perspectivas
 sync:
   reads: [".elsabro/state.json"]
-  writes: [".elsabro/state.json"]
+  writes: [".elsabro/state.json", ".elsabro/context.md", ".planning/"]
+agents: [elsabro-orchestrator]
 ---
 
 # /elsabro:party
@@ -192,33 +193,89 @@ Al final, generar consenso y puntos de debate:
 
 Genera `.planning/PARTY-{topic-slug}-SUMMARY.md` usando template.
 
-## Implementacion Tecnica
+## 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.
 
 ```javascript
-// Single-Agent Simulation (v1)
-// Un solo agente cambia de personalidad por iteracion
-
-const topic = inputs.topic;
-const agents = selectAgentsByRelevance(topic); // Top 3
-const rounds = inputs.rounds || 3;
-
-for (let round = 1; round <= rounds; round++) {
-  for (const agent of agents) {
-    const response = generateResponse({
-      personality: agent.personality,
-      topic: topic,
-      round: round,
-      previousResponses: history,
-      instruction: round === 1
-        ? "Da tu perspectiva inicial sobre el tema"
-        : "Reacciona a lo que dijeron los otros agentes"
+// 1. Require PartyEngine
+const { PartyEngine } = require('./flow-engine/src/index.js');
+const engine = new PartyEngine({
+  checkpointDir: '.elsabro/checkpoints/',
+  maxRounds: inputs.rounds || 3,
+  maxAgents: 3
+});
+
+// 2. Show selected agents
+const agents = engine.selectAgents(topic, {
+  agents: inputs.agents || undefined // manual override or auto-select
+});
+// Display agent cards with emoji, name, focus
+
+// 3. Run party session with callbacks
+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()
+    return Task({
+      subagent_type: `elsabro-${agent.id}`,
+      model: "sonnet",
+      prompt: `You are ${agent.name}. ${agent.style}.
+        Focus: ${agent.focus}. Tendency: ${agent.tendency}.
+        Topic: "${topic}". Round: ${round}/${totalRounds}.
+        ${instruction}
+        Previous discussion:
+        ${history.map(h => `[${h.agent.name}] ${h.response}`).join('\n')}`
+    });
+  },
+
+  onSynthesize: async ({ history, topic, agents }) => {
+    // Orchestrator (Quantum) synthesizes the debate
+    return Task({
+      subagent_type: "elsabro-orchestrator",
+      model: "sonnet",
+      prompt: `Synthesize this multi-agent debate:
+        Topic: "${topic}"
+        Agents: ${agents.map(a => a.name).join(', ')}
+        Discussion:
+        ${history.map(h => `[R${h.round}] ${h.agent.name}: ${h.response}`).join('\n')}
+
+        Return JSON: { consensus: [], debates: [], actionItems: [], keyInsights: [], suggestedNext: "command" }`
+    });
+  },
+
+  onRoundComplete: async ({ completedRound, totalRounds, lastResponses }) => {
+    // Ask user if they want to continue, stop, or add a round
+    const answer = AskUserQuestion({
+      questions: [{
+        question: `Round ${completedRound}/${totalRounds} complete. Continue?`,
+        header: "Party",
+        options: [
+          { label: "Continue", description: "Proceed to next round" },
+          { label: "Stop here", description: "End debate and synthesize" },
+          { label: "Add round", description: "Extend debate by 1 round" }
+        ],
+        multiSelect: false
+      }]
     });
-    history.push({ agent: agent.name, round, response });
+    if (answer === "Stop here") return "stop";
+    if (answer === "Add round") return "add_round";
+    return "continue";
   }
-}
+});
 
-// Sintetizar
-const summary = synthesize(history);
+// 4. Write summary to .planning/
+const summaryPath = `.planning/PARTY-${slugify(topic)}-SUMMARY.md`;
+Write(summaryPath, generatePartySummary(result));
+
+// 5. Update state.json
+state.context.party_summary = summaryPath;
+state.context.party_consensus = result.synthesis.consensus;
+state.context.party_debates = result.synthesis.debates;
+state.context.party_agents = result.agents.map(a => a.id);
 ```
 
 ## Opciones

package/commands/elsabro/quick.md

@@ -4,6 +4,7 @@ description: Modo de ejecución rápida para tareas simples - mínima ceremonia,
 sync:
   reads: [".elsabro/state.json"]
   writes: [".elsabro/state.json", ".elsabro/context.md"]
+agents: [elsabro-quick-dev]
 ---
 
 # /elsabro:quick
@@ -146,10 +147,26 @@ ELSABRO: [Ejecuta en <30 segundos]
 
 ## Integración con Agentes
 
-Quick mode usa `elsabro-yolo-dev` (Flash) internamente:
+Quick mode usa `elsabro-quick-dev` (Barry) internamente para ejecución con máxima calidad:
 
 ```
-/elsabro:quick → Activa Flash → Ejecuta → Reporta
+/elsabro:quick → Activa Barry → Ejecuta → Reporta
+```
+
+### Agent Invocation (Step 3: Execute)
+
+After locating the relevant files, delegate code execution to Barry:
+
+```javascript
+Task({
+  subagent_type: "elsabro-quick-dev",
+  model: "sonnet",
+  prompt: `Quick fix task: ${taskDescription}
+    Files: ${locatedFiles.join(', ')}
+    Context: ${codeContext}
+
+    Rules: Max 3 files, auto-test, minimal ceremony.`
+})
 ```
 
 ## Output

package/flow-engine/src/agent-cards.json

@@ -0,0 +1,74 @@
+{
+  "analyst": {
+    "id": "analyst",
+    "name": "Mary",
+    "emoji": "blue_circle",
+    "style": "Curious, asks clarifying questions, user-focused",
+    "focus": "Requirements, user needs, problem definition",
+    "tendency": "Pushes for clarity before solutions"
+  },
+  "planner": {
+    "id": "planner",
+    "name": "Winston",
+    "emoji": "clipboard",
+    "style": "Research-first, methodical, detail-oriented",
+    "focus": "Architecture, task decomposition, dependencies",
+    "tendency": "Invests in thorough planning before action"
+  },
+  "executor": {
+    "id": "executor",
+    "name": "Amelia",
+    "emoji": "hammer",
+    "style": "TDD-driven, verification-focused, atomic commits",
+    "focus": "Implementation, code quality, test coverage",
+    "tendency": "Writes tests first, verifies before claiming done"
+  },
+  "qa": {
+    "id": "qa",
+    "name": "Murat",
+    "emoji": "test_tube",
+    "style": "Data-driven, risk-based, strong opinions weakly held",
+    "focus": "Testing architecture, API testing, CI/CD",
+    "tendency": "Prefers lower test levels, treats flakiness as critical debt"
+  },
+  "debugger": {
+    "id": "debugger",
+    "name": "Sherlock",
+    "emoji": "mag",
+    "style": "Scientific method, evidence-based, systematic",
+    "focus": "Root cause analysis, bug investigation, reproduction",
+    "tendency": "Never fixes without understanding why"
+  },
+  "ux-designer": {
+    "id": "ux-designer",
+    "name": "Sally",
+    "emoji": "art",
+    "style": "Empathetic, creative storyteller, user-first",
+    "focus": "Interface design, user flows, accessibility",
+    "tendency": "Balances empathy with edge cases, starts simple"
+  },
+  "scrum-master": {
+    "id": "scrum-master",
+    "name": "Bob",
+    "emoji": "runner",
+    "style": "Crisp, checklist-driven, servant leader",
+    "focus": "Sprint planning, story preparation, process",
+    "tendency": "Zero tolerance for ambiguity, removes obstacles"
+  },
+  "tech-writer": {
+    "id": "tech-writer",
+    "name": "Paige",
+    "emoji": "books",
+    "style": "Patient educator, explains like teaching a friend",
+    "focus": "Documentation, knowledge curation, clarity",
+    "tendency": "Every word has purpose, prefers diagrams and examples"
+  },
+  "verifier": {
+    "id": "verifier",
+    "name": "Quincy",
+    "emoji": "shield",
+    "style": "Skeptical, evidence-based, trust-but-verify",
+    "focus": "Spec compliance, code quality, regression checks",
+    "tendency": "Verifies code reality not reports, checks for stubs"
+  }
+}