---
name: ceo-debate
description: "Multi-agent CEO orchestration cu debate dinamic și consens. Folosește când userul vine cu o idee de anvergură, fuzzy, sau vrea curățare de balast + fresh ideas. CEO clarifică intent, recrutează dinamic 3-7 specialiști (mix funcțional + filosofic) în funcție de complexitate, rulează 1-2 runde de debate Du-style, arbitrul Opus produce consensul cu trade-offs explicite, apoi handoff la writing-plans. Inspirat din MetaGPT (roles) + AgentVerse (dynamic recruitment) + Du et al. 'Multi-Agent Debate' (Society of Mind, 2023) + pattern-ul nativ Anthropic orchestrator-worker. Trigger frazal: 'fă un CEO debate pentru', 'orchestrează o dezbatere despre', '/ceo-debate'."
---

# CEO Debate Orchestration

Multi-agent CEO + dynamic specialists + Du-style debate + Opus arbitrator + handoff to writing-plans.

## When to invoke

Use when:
- User aduce o idee fuzzy/de anvergură ("scheletul workflowurilor interne", "redesign brand", "next product")
- User cere explicit "curățare balast" / "fresh ideas" / "ordine în idei"
- Plan ar atinge 3+ domenii (backend + design + business + ops + brand etc.)
- User scrie `/ceo-debate <idee>`

**Do NOT use** for:
- Bugfix-uri sau task-uri tactice scurte
- Cereri pur execuționale ("modifică workflow X")
- Cazuri cu 1 singur domeniu clar (folosește `brainstorming` direct)

## Pipeline overview

```
Faza 1: CEO Clarifier         [1 agent, Opus, secvențial]
   ├─ 2-3 întrebări ascuțite (1 mesaj per întrebare)
   ├─ Brief scris în /tmp/ceo-debate/<slug>/brief.md
   └─ Decide COMPLEXITATE (S/M/L) + ROLURI recrutate
Faza 2: Specialist Proposals  [3-7 Task agents PARALEL, Sonnet]
   └─ Fiecare scrie /tmp/ceo-debate/<slug>/proposal-<role>.md
Faza 3: Debate Round           [N Task agents PARALEL, Sonnet, 1-2 runde]
   ├─ Fiecare specialist citește propunerile celorlalți
   └─ Scrie /tmp/ceo-debate/<slug>/rebuttal-<role>-r<N>.md
Faza 4: Arbitrator             [1 agent, Opus, secvențial]
   ├─ Citește tot (brief + proposals + rebuttals)
   └─ Scrie /tmp/ceo-debate/<slug>/consensus.md cu trade-offs explicite
Faza 5: Handoff                [user decides]
   ├─ Prezintă consens user-ului
   └─ La aprobare → invocă writing-plans
```

## Working directory

Toate artefactele într-un singur folder per rulare:
```
/tmp/ceo-debate/<slug>/
  brief.md
  recruitment.md           # ce roluri am recrutat și de ce
  proposal-<role>.md       # 1 per specialist
  rebuttal-<role>-r1.md    # runda 1
  rebuttal-<role>-r2.md    # runda 2 (opțional)
  consensus.md             # output arbitrator
```

`<slug>` = kebab-case scurt derivat din intent (ex: `workflowuri-interne-elevarts`).

---

## FAZA 1 — CEO Clarifier

**Rolul tău aici (orchestratorul principal):** ești CEO. NU delegi. Vorbești direct cu userul.

### Pași

1. **Citește contextul.** Verifică `git status` / `ls` în directorul curent, citește CLAUDE.md dacă există, verifică memory pentru proiecte relevante.

2. **Pune întrebări una câte una** (max 3). Întrebări ascuțite, nu fluff:
   - Care e succesul măsurabil? (date, KPI, evenimente concrete)
   - Care e bugetul (timp/bani/oameni) și deadline-ul?
   - Ce există deja vs ce e greenfield?
   - Cine sunt stakeholder-ii și ce constrângeri impun?

   Folosește `AskUserQuestion` cu opțiuni concrete când e posibil.

3. **Evaluează complexitatea** și scrie brief.md:

   ```markdown
   # CEO Brief — <slug>
   ## Intent
   <1 paragraf, în propriile cuvinte ale userului>
   ## Succes măsurabil
   <bullet list de KPI / livrabile>
   ## Constrângeri
   <buget, deadline, dependențe>
   ## Context existent
   <ce există deja, ce-i greenfield>
   ## Complexitate: S | M | L
   <S = 3 roluri, M = 5 roluri, L = 7 roluri>
   ```

4. **Recrutează specialiști dinamic.** Alege din pool-ul de mai jos, mix funcțional + filosofic. Scrie `recruitment.md`:

   ```markdown
   # Recruitment — <slug>
   ## Complexitate: <S/M/L>
   ## Roluri recrutate
   - **<role>** — <de ce e necesar aici>
   - ...
   ## Excluse explicit
   - <role pe care l-ai considerat dar l-ai exclus> — <motiv>
   ```

### Role pool

**Funcționale** (perspective de domeniu):
- `backend` — infra, API, DB, scaling, observability
- `design-ux` — flow utilizator, info architecture, vizual
- `business-ops` — proces, ROI, mentenanță operațională
- `data-analytics` — metrici, măsurare, feedback loop
- `marketing-brand` — poziționare, voce, distribuție
- `security-compliance` — auth, GDPR, audit, surface attack
- `cost-resources` — buget cloud/API, ore om, dependențe

**Filosofice** (perspective transversale):
- `pragmatist` — ce e realist, executabil în 2 săptămâni, ce taie scope
- `skeptic` — ce poate merge prost, cele mai probabile failure modes
- `visionary` — versiunea ambițioasă, blue-sky, ce-am face cu resurse nelimitate
- `devils-advocate` — push back pe ce pare "evident", contraintuitiv
- `user-advocate` — perspectiva utilizatorului final, friction points
- `future-self` — Tu peste 1 an: ce regreți? Ce e greu de menținut?

### Reguli de recrutare

- **S (Small, 3 roluri):** 2 funcționale + 1 filosofic (default: `pragmatist`)
- **M (Medium, 5 roluri):** 3 funcționale + 2 filosofice
- **L (Large, 7 roluri):** 4 funcționale + 3 filosofice
- ÎNTOTDEAUNA include `skeptic` SAU `devils-advocate` (cineva care contrazice)
- ÎNTOTDEAUNA include `pragmatist` SAU `cost-resources` (cineva care taie scope)

5. **Prezintă userului brief-ul + recruitment-ul.** Cere confirmarea înainte de Faza 2 (e singurul moment de confirmare în tot pipeline-ul, ca să nu blochezi inutil).

---

## FAZA 2 — Specialist Proposals (paralel)

**Spawn N agenți paraleli ÎNTR-UN SINGUR mesaj** cu N apeluri `Agent` (subagent_type=`general-purpose`, model implicit Sonnet via task delegation).

### Template prompt per specialist

```
Ești <ROLE> într-o dezbatere multi-agent organizată de CEO-ul Elevarts (George Gache, founder).

# Brief CEO
<conținut brief.md>

# Rolul tău: <ROLE>
<descrierea rolului din pool>

# Sarcină
Produ o propunere structurată (max 400 cuvinte) cu:
1. **Cum vezi tu problema** (1 paragraf, din unghiul tău unic)
2. **Abordarea ta** (3-5 bullets concrete, nu abstracte)
3. **Riscuri / blind spots** (ce vezi tu că alții nu)
4. **Estimare resurse** (timp, cost, dependențe — chiar dacă aproximativ)
5. **Întrebare deschisă** (o întrebare pe care ai pune-o celorlalți specialiști)

# Output
Scrie REZULTATUL în /tmp/ceo-debate/<slug>/proposal-<role>.md folosind tool-ul Write.
NU întreba, NU dialoga. Singur output, fișier scris, apoi raportezi 1-2 propoziții.

# Constrângeri
- Limba: română
- Stil: direct, concret, fără filler
- NU repeta brief-ul, completează-l
- Dacă rolul tău e filosofic (skeptic/visionary/etc), NU intra în detalii tehnice — stai în unghiul tău
```

**Important:** Toate `Agent` tool calls în UN SINGUR mesaj pentru paralelism real.

---

## FAZA 3 — Debate Round

După ce toate proposals sunt scrise, citește-le tu (orchestratorul) și treci la debate.

### Runda 1 (obligatorie)

Spawn din nou N agenți paraleli. Prompt:

```
Ești <ROLE> în runda de debate. Ai scris deja propunerea ta. Acum vezi propunerile celorlalți.

# Brief CEO
<conținut brief.md>

# Propunerea ta (referință)
<conținut proposal-<role>.md>

# Propunerile celorlalți
<concatenat proposal-*.md, fiecare cu header>

# Sarcină — debate cinstit, nu politicos
Scrie un rebuttal structurat (max 500 cuvinte):
1. **Cu cine ești de acord** (1-2 puncte specifice din alte propuneri — numește rolul)
2. **Cu cine NU ești de acord și DE CE** (1-2 contre tari, cu argument, nu cu opinie)
3. **Ce ai schimba la propunerea TA** după ce ai văzut celelalte (onestitate, nu încăpățânare)
4. **Sinteză personală** — dacă ai fi tu CEO, ce decizie ai lua acum?

# Output
Scrie în /tmp/ceo-debate/<slug>/rebuttal-<role>-r1.md.

# Reguli debate
- Atacă idei, nu persoane (chiar dacă sunt agenți)
- Cere date/argumente, nu autoritate
- Dacă cineva are dreptate, recunoaște DESCHIS
- Limba: română
```

### Runda 2 (condițională)

Dacă după runda 1 încă există dezacorduri majore (orchestratorul citește rebuttals și decide), rulează runda 2 cu prompt similar dar input = `rebuttal-*-r1.md` în loc de `proposal-*.md`.

**Trigger pentru runda 2:** 2+ specialiști scriu decizii radical diferite la punctul 4. Dacă converg, sari direct la Faza 4.

---

## FAZA 4 — Arbitrator (Opus)

**Spawn 1 agent secvențial.** Folosește `Agent` cu prompt:

```
Ești Arbitrator (model Opus). CEO-ul a strâns o echipă, au făcut propuneri și debate.
Sarcina ta: produ DECIZIA finală cu trade-offs explicite.

# Brief CEO
<conținut brief.md>

# Roluri recrutate
<conținut recruitment.md>

# Toate propunerile
<concatenat proposal-*.md>

# Toate rebuttals
<concatenat rebuttal-*.md>

# Sarcină
Scrie CONSENS în /tmp/ceo-debate/<slug>/consensus.md cu structura:

## 1. Decizia (1 paragraf — ce facem, fără jargon)

## 2. De ce ASTA și nu altceva
- Argumente pentru (2-3 bullets)
- Alternative considerate și DE CE le-am respins (2-3 bullets)

## 3. Trade-offs acceptate explicit
- "Ce câștigăm" vs "ce pierdem" — listă cinstită

## 4. Plan de execuție (high-level, NU exhaustiv)
- 5-10 etape mari, în ordine
- Pentru fiecare: estimare T-shirt size (S/M/L) + rol owner

## 5. Riscuri TOP 3 + mitigation pentru fiecare

## 6. Întrebări încă deschise pentru George
- Lista scurtă cu ce mai trebuie decis înainte de start

## 7. Quick wins (primele 24-48h)
- 2-3 acțiuni mici care validează direcția înainte de commit major

# Reguli
- NU fii politicos cu specialiștii — sintetizează ce-i mai bun, taie restul
- NU inventa consens dacă nu există — listează deciziile alternative cu pro/con
- Limba: română
- Stil: decisive, executiv, nu academic
```

---

## FAZA 5 — Handoff

1. **Citește** `consensus.md`.
2. **Prezintă userului** rezumat de 10-15 rânduri (NU tot fișierul) + link clickable la fișierul complet `/tmp/ceo-debate/<slug>/consensus.md`.
3. **Întreabă cu `AskUserQuestion`:**
   - Aprobă → invocă `writing-plans` skill cu consensus.md ca input
   - Vrea ajustări → re-rulează doar Faza 4 cu feedback adăugat în prompt
   - Vrea runda 2 de debate → rulează Faza 3 runda 2
4. **La aprobare**, persistă în memory:
   ```bash
   python3 -c "
   import sys, os; sys.path.insert(0, os.path.expanduser('~/.claude/memory/scripts'))
   from lib.db import get_pg
   pg = get_pg(); cur = pg.cursor()
   cur.execute('INSERT INTO memory.decisions (title, context, decision, rationale, tags) VALUES (%s, %s, %s, %s, %s)',
               ('<slug>', '<brief.md summary>', '<consensus decision>', '<rationale>', ['ceo-debate', '<slug>']))
   pg.commit(); cur.close(); pg.close()
   "
   ```

---

## Quota & runtime

Toate Task subagents rulează prin **aceeași sesiune Claude Code** → Max OAuth subscription. NU se folosesc API tokens separate, NU se plătește per call. Singura "risipă" e timpul.

| Complexitate | Roluri | Runde | Timp estimat | Tokens consumate |
|--------------|--------|-------|--------------|------------------|
| S | 3 | 1 | ~3-5 min | ~80k |
| M | 5 | 1-2 | ~6-10 min | ~180k |
| L | 7 | 2 | ~10-15 min | ~350k |

Folosește Max-ul, nu-l risipi degeaba — dacă userul are credite neatinse, default la L pentru proiecte mari.

## Model routing

- CEO (Faza 1): TU, modelul curent al sesiunii (default Opus pentru George)
- Specialiști + Debate (Faza 2, 3): `general-purpose` subagent (Sonnet implicit prin Task tool, parte din Max quota)
- Arbitrator (Faza 4): `general-purpose` cu `model: "opus"` explicit ÎN apelul Agent, SAU TU dacă ești deja Opus

## Anti-patterns

- ❌ NU sări peste Faza 1 (clarifier). Briefuri proaste = debate inutil.
- ❌ NU rula specialiști secvențial. PARALEL în UN SINGUR mesaj cu N tool calls.
- ❌ NU lăsa specialiștii să dialogheze direct. Toți scriu fișiere, TU coordonezi citirea.
- ❌ NU forța consens artificial. Dacă există dezacord legitim, listează alternative cu pro/con.
- ❌ NU produce consensus.md mai lung de 800 cuvinte. Executive, nu academic.
- ❌ NU invoca `writing-plans` automat. Întreabă userul după ce vede consensus.md.

## Integrare cu skill-uri existente

- **Înainte de CEO debate:** dacă userul are deja un design system (DESIGN.md), citește-l ca input pentru `design-ux` role.
- **După CEO debate:** invocă `writing-plans` pentru taskuri executabile, apoi opțional `to-issues` pentru sync în `app.tasks`.
- **Persistență:** consensul intră în `memory.decisions`. Briefurile și debate-ul rămân în /tmp/ și pot fi arhivate manual în Obsidian dacă userul vrea.

## Exemplu trigger

```
User: "Vreau să fac scheletul workflowurilor interne Elevarts, cap-coadă. /ceo-debate"
```

→ Tu pornești Faza 1, întrebi context, decizi L (proiect mare, multi-domain), recrutezi 7 roluri:
`backend, design-ux, business-ops, cost-resources` (funcționale) + `pragmatist, skeptic, future-self` (filosofice) — și pornești pipeline-ul.
