---
name: bs-compare
description: "Chat multi-LLM con agenti specializzati su modelli diversi. Usa @ricercatore per ricerca web GPT, @avvocato per analisi critica con reasoning, @stratega per alternative, @tutti per confronto completo. Usa questa skill quando l'utente vuole un secondo parere, confrontare prospettive, GPT vs Claude, multi-LLM, ricerca competitor, analisi critica, o dice bs compare, confronta, secondo parere, aggiorna modelli."
---

# bs-compare — Chat Multi-LLM con Agenti Specializzati

Sessione interattiva con 4 agenti, ognuno su un modello LLM diverso scelto per i suoi punti di forza. L'utente usa `@nome` come in `/bs-chat`, ma qui ogni agente chiama un LLM esterno reale.

## File di configurazione: `~/.mucc-llm-keys.env`

```
# ── API Keys ──
OPENAI_API_KEY=sk-proj-...

# ── Modelli per ruolo ──
COMPARE_RESEARCHER=gpt-5-search-api
COMPARE_DEVIL=o3
COMPARE_STRATEGIST=gpt-5.4
ANTHROPIC_MODEL=claude-opus-4-6
```

## Catalogo Agenti Multi-LLM

| @Nome | Ruolo | Modello | Provider | Punto di forza |
|-------|-------|---------|----------|----------------|
| **@ricercatore** | Ricercatore di Mercato | `COMPARE_RESEARCHER` | OpenAI (search) | Ricerca web reale: competitor, pricing, trend, dati di mercato |
| **@avvocato** | Avvocato del Diavolo | `COMPARE_DEVIL` | OpenAI (reasoning) | Reasoning profondo: falle logiche, rischi nascosti, smonta ipotesi |
| **@stratega** | Stratega Alternativo | `COMPARE_STRATEGIST` | OpenAI | Approcci diversi: business model alternativi, pivot, opportunita |
| **@sintetizzatore** | Sintetizzatore | `ANTHROPIC_MODEL` | Anthropic (locale) | Meta-analisi: combina le prospettive, raccomandazione finale |

Alias accettati: `@ricerca`, `@devil`, `@strat`, `@synth`, `@sint`

## Input
```
/bs-compare                            # avvia sessione interattiva
/bs-compare --config                   # mostra config (modelli + key)
/bs-compare --aggiorna-modelli         # aggiorna modelli nel config
/bs-compare --confronto-completo       # tutti e 4 gli agenti in parallelo
```

## Workflow

### Step 0: Verifica configurazione

Leggi `~/.mucc-llm-keys.env` con Read.

Estrai: `OPENAI_API_KEY`, `COMPARE_RESEARCHER`, `COMPARE_DEVIL`, `COMPARE_STRATEGIST`, `ANTHROPIC_MODEL`.
Se un modello per ruolo manca, usa i default:
- `COMPARE_RESEARCHER` → `gpt-5-search-api`
- `COMPARE_DEVIL` → `o3`
- `COMPARE_STRATEGIST` → `gpt-5.4`
- `ANTHROPIC_MODEL` → `claude-opus-4-6`

**Se `$ARGUMENTS` contiene `--config`**: mostra tabella agenti con modelli e fermati.

**Se OPENAI_API_KEY manca**: chiedi all'utente, crea il file con Write + chmod 600.

**Se `$ARGUMENTS` contiene `--aggiorna-modelli`**:
1. Mostra modelli attuali per ruolo
2. Chiedi quale aggiornare
3. Aggiorna con Edit su `~/.mucc-llm-keys.env`
4. Suggerisci `/kb-recall migliori modelli LLM`

### Step 1: Avvia sessione

Leggi contesto brainstorming se disponibile (brainstorm/*.md).

Mostra:
```
Chat Multi-LLM avviata.

Agenti disponibili:
  @ricercatore — Ricerca web (gpt-5-search-api)
  @avvocato    — Analisi critica (o3 reasoning)
  @stratega    — Alternative strategiche (gpt-5.4)
  @sintetizzatore — Meta-analisi (claude-opus-4-6, locale)

Usa @nome per parlare con un agente, @tutti per un confronto completo.
Scrivi "chi c'e?" per il catalogo, "/fine" per chiudere.
```

### Step 2: Gestione messaggi

**Se il messaggio contiene `@ricercatore` (o `@ricerca`):**
1. Costruisci prompt con system message:
   "Sei un ricercatore di mercato. Usa le tue capacita di ricerca web per trovare dati reali, competitor, pricing, trend. Cita le fonti. Rispondi in italiano."
2. Scrivi prompt utente in `/tmp/bs-compare-prompt.txt`
3. Chiama con curl:
```bash
OPENAI_KEY=$(grep '^OPENAI_API_KEY=' ~/.mucc-llm-keys.env | cut -d= -f2-)
MODEL=$(grep '^COMPARE_RESEARCHER=' ~/.mucc-llm-keys.env | cut -d= -f2-)
MODEL=${MODEL:-gpt-5-search-api}

curl -s --max-time 90 https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_KEY" \
  -H "Content-Type: application/json" \
  -d "$(python3 -c "
import json
prompt = open('/tmp/bs-compare-prompt.txt').read()
print(json.dumps({
    'model': '$MODEL',
    'messages': [
        {'role': 'system', 'content': 'Sei un ricercatore di mercato esperto. Usa le tue capacita di ricerca web per trovare dati reali: competitor, pricing, trend di mercato, dimensioni del mercato. Cita le fonti con URL. Rispondi in italiano, Markdown strutturato, max 500 parole.'},
        {'role': 'user', 'content': prompt}
    ],
    'max_completion_tokens': 4096,
    'web_search_options': {'search_context_size': 'medium'}
}))
")" | python3 -c "
import sys, json
r = json.load(sys.stdin)
if 'error' in r: print('ERRORE:', r['error']['message'])
else:
    print(r['choices'][0]['message']['content'])
    u = r.get('usage',{})
    print(f'\n---\nModello: $MODEL | Token: {u.get(\"total_tokens\",0)}')
"
```
4. Mostra risposta con header: `### Ricercatore di Mercato (gpt-5-search-api)`

**Se il messaggio contiene `@avvocato` (o `@devil`):**
1. System message: "Sei un avvocato del diavolo implacabile. Usa ragionamento profondo per trovare falle logiche, rischi nascosti, debolezze nel business model, assunzioni non verificate. Sii duro ma costruttivo."
2. Chiama con curl (stessa struttura, modello diverso):
   - Modello: `COMPARE_DEVIL` (default: `o3`)
   - NO `web_search_options`
   - `max_completion_tokens`: 2000
3. Mostra con header: `### Avvocato del Diavolo (o3 reasoning)`

**Se il messaggio contiene `@stratega` (o `@strat`):**
1. System message: "Sei uno stratega visionario. Proponi approcci completamente diversi: business model alternativi, pivot radicali, opportunita non considerate. Pensa fuori dagli schemi. Sii audace."
2. Chiama con curl:
   - Modello: `COMPARE_STRATEGIST` (default: `gpt-5.4`)
   - `max_completion_tokens`: 4096
3. Mostra con header: `### Stratega Alternativo (gpt-5.4)`

**Se il messaggio contiene `@sintetizzatore` (o `@synth`, `@sint`):**
1. Rispondi direttamente come Claude (locale, nessuna API call)
2. Analizza tutte le risposte precedenti nella sessione
3. Produci meta-analisi: convergenze, divergenze, raccomandazione
4. Mostra con header: `### Sintetizzatore (claude-opus-4-6)`

**Se il messaggio contiene `@tutti`:**
1. Chiama i 3 agenti OpenAI IN PARALLELO (3 Bash in parallelo)
2. Poi il Sintetizzatore (Claude) analizza tutte e 3 le risposte
3. Mostra tutte e 4 le risposte con header

**Se il messaggio NON contiene `@`:**
- Se c'e un agente attivo (ultimo invocato), continua con quello
- Altrimenti rispondi come Sintetizzatore e suggerisci quale agente potrebbe aiutare

### Step 3: Auto-suggerimento agente

- Competitor, mercato, prezzi, settore → `@ricercatore`
- Rischi, falle, problemi, critica → `@avvocato`
- Alternative, pivot, idee diverse → `@stratega`
- Riepilogo, sintesi, raccomandazione → `@sintetizzatore`

Formato: `Suggerimento: @ricercatore potrebbe cercare i competitor reali per questo.`

### Step 4: Comandi speciali

- `chi c'e?` o `catalogo` → mostra tabella agenti con modello e ruolo
- `@tutti "domanda"` → confronto completo (4 agenti)
- `/fine` → chiudi sessione, scrivi `brainstorm/07-compare-llm.md` con riepilogo
- `/costi` → mostra costi stimati della sessione (token usati per agente)
- `--config` → mostra configurazione modelli

## Formato Risposta

```markdown
### [Ruolo] ([modello])

[Risposta in-character]

---
*Modello: [model-id] | Token: N | Costo: ~$X.XX*
```

## Confronto Completo (`@tutti` o `--confronto-completo`)

Quando tutti e 4 gli agenti rispondono, il Sintetizzatore produce anche:

```markdown
### Meta-analisi (claude-opus-4-6)

**Convergenze**: [dove concordano — segnale forte]
**Divergenze**: [dove discordano — richiede attenzione]
**Insight unici**:
  - Ricercatore: [cosa ha trovato di unico sul web]
  - Avvocato: [falle che nessun altro ha visto]
  - Stratega: [opportunita non considerate]
**Raccomandazione**: [sintesi finale]
```

## Output

Al `/fine` della sessione, scrivi `brainstorm/07-compare-llm.md` con:
- Tabella modelli usati
- Tutte le risposte della sessione
- Meta-analisi finale
- Costi totali

## Hook Knowledge Base (post-esecuzione)
Se `~/mucc-knowledge-base/` esiste:
- Insight unici da ricerca web → `inbox/auto/` con tag `multi-llm-research`
- Falle identificate dall'avvocato → `inbox/auto/` con tag `multi-llm-devil`

## Guardrail
- Ogni risposta agente max 300 parole (a meno che l'utente chieda di piu)
- Se un API call fallisce, segnala e continua con gli altri agenti
- Il Sintetizzatore (Claude) ha SEMPRE l'ultima parola
- Mai inventare dati di mercato — solo il @ricercatore puo cercare sul web
- Mostra SEMPRE il modello usato accanto al nome dell'agente

## Costi stimati per sessione
- @ricercatore (search): ~$0.08-0.15 per query (include search tokens)
- @avvocato (o3 reasoning): ~$0.05-0.10 per query (include reasoning tokens)
- @stratega (gpt-5.4): ~$0.01-0.04 per query
- @sintetizzatore (Claude): $0 (locale)
- @tutti: ~$0.15-0.30 per confronto completo

## Note
- Il @ricercatore e l'unico che fa ricerche web REALI (non inventate)
- L'@avvocato usa reasoning tokens (pensa prima di rispondere)
- I modelli sono aggiornabili con `/bs-compare --aggiorna-modelli`
- Le chiamate API sono via curl (funziona da qualsiasi progetto)