grahama1970/argue

Orchestrateur de débat structuré multi-persona. Les personas effectuent des recherches via /dogpile, consultent des collègues via /ask, et argumentent vers une synthèse nuancée sur des questions complexes.

Qu'est-ce que argue ?

Ce skill orchestre un débat structuré entre plusieurs personas IA. Chaque persona effectue des recherches approfondies via la commande `/dogpile`, consulte des collègues experts via `/ask`, puis s'engage dans un cycle de débat en plusieurs rounds (recherche → argumentation → réfutation → réflexion) pour explorer une question complexe sous différents angles. L'objectif n'est pas de désigner un gagnant, mais de générer une **synthèse nuancée** qui capture les points d'accord, les désaccords persistants, les concessions et les questions ouvertes. Le système utilise une pondération BDI (Belief-Desire-Intention) des ponts de personnalité pour influencer le style argumentatif. Il prend en charge les modes adversaire, panel, socratique et avocat du diable, et s'intègre avec les skills dogpile, ask, memory, taxonomy, consume-book, consume-youtube et episodic-archiver. Ce skill est particulièrement utile pour aborder des problèmes difficiles (conjecture de Collatz, P vs NP, conscience humaine, compromis politiques) en bénéficiant d'une profondeur de recherche, d'une pression antagoniste et d'une diversité de perspectives.

Compatible avec~Claude Code~Codex CLI~Cursor✓Antigravity
npx skills add https://github.com/grahama1970/agent-skills/tree/main/skills/argue

Installed? Explore more Recherche et analyse de données skills: affaan-m/uspto-database, affaan-m/scholar-evaluation, affaan-m/literature-review · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait argue ?

Orchestrateur de débat structuré multi-persona. Deux personas ou plus effectuent des recherches indépendantes via /dogpile, consultent des collègues experts via /ask, et argumentent pour produire une synthèse nuancée — pas un gagnant.

Pourquoi ne pas simplement demander à un seul modèle ?

Les réponses d'un seul modèle sont confiantes mais unidimensionnelles. Une véritable compréhension des problèmes complexes (Conjecture de Collatz, P vs NP, conscience, compromis politiques) nécessite :

  • Plusieurs prismes disciplinaires sur la même question
  • Pression antagoniste — chaque camp met à l'épreuve le raisonnement de l'autre
  • Profondeur de recherche — chaque persona effectue des recherches /dogpile indépendantes
  • Graphique social — les personas peuvent consulter des collègues via /ask pour des avis d'experts
  • Suivi des concessions — la synthèse capture ce qui a été concédé et pourquoi
  • Raisonnement pondéré BDI — les poids des ponts de personnalité influencent le style argumentatif

Architecture

┌──────────────────────────────────────────────────────────┐
│                  Orchestrateur Argue                       │
│  - Boucle de débat (recherche → argument → réfutation →   │
│    réflexion)                                             │
│  - Exécution concurrente des personas                     │
│  - Terminaison basée sur la convergence                   │
│  - Génération de la synthèse                              │
└──────────────────────────────────────────────────────────┘
         │                              │
    ┌────┴──────┐                 ┌─────┴─────┐
    │ Persona A  │                │ Persona B  │
    │ (Fil)      │                │ (Fil)      │
    ├────────────┤                ├────────────┤
    │ Skills :   │                │ Skills :   │
    │ - dogpile  │                │ - dogpile  │
    │ - ask      │                │ - ask      │
    │ - memory   │                │ - memory   │
    │ - taxonomy │                │ - taxonomy │
    └────────────┘                └────────────┘
         │                              │
         └──────────┬───────────────────┘
                    │
    ┌───────────────┴────────────────────┐
    │          Moteur de Synthèse         │
    │  - Arguments les plus forts de      │
    │    chaque camp                      │
    │  - Points d'accord                  │
    │  - Points de désaccord authentique  │
    │  - Journal des concessions          │
    │  - Questions ouvertes               │
    │  - Conclusion nuancée               │
    └────────────────────────────────────┘

Commandes

# Deux personas débattent d'une question
./run.sh argue "La conjecture de Collatz est-elle décidable ?" \
  --persona-a embry --persona-b horus --rounds 5

# Débat à trois (panel)
./run.sh argue "Meilleure approche pour l'alignement de l'AGI" \
  --personas embry,horus,brandon --rounds 7

# Débat rapide en 3 rounds avec personas auto-sélectionnés
./run.sh argue "Faut-il utiliser des microservices ou un monolithe ?"

# Reprendre un débat interrompu
./run.sh resume <debate-id>

# Voir la transcription d'un débat
./run.sh transcript <debate-id>

# Générer un rapport de synthèse
./run.sh synthesize <debate-id>

# Vérifier l'état d'un débat
./run.sh status

Boucle de débat

Chaque round suit le cycle recherche → argumentation → réfutation → réflexion :

Round k :

┌─────────────────────────────────────────────────────────────┐
│                    1. PHASE DE RECHERCHE                     │
├─────────────────────────────────────────────────────────────┤
│ Chaque persona :                                             │
│ - /dogpile la question depuis son prisme disciplinaire       │
│ - /ask un collègue pour un avis d'expert                     │
│ - /memory rappeler les arguments antérieurs et les           │
│   connaissances pertinentes                                  │
│ - Examiner les arguments précédents de l'adversaire pour     │
│   trouver des faiblesses                                     │
│ (Budget : 3 appels de recherche max par persona par round)   │
└─────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                    2. PHASE D'ARGUMENTATION                   │
├─────────────────────────────────────────────────────────────┤
│ Chaque persona :                                             │
│ - Présenter sa position avec preuves et citations            │
│ - Référencer les résultats /dogpile et les réponses /ask     │
│   des collègues                                              │
│ - Tagger les arguments avec les attributs de pont de         │
│   /taxonomy                                                  │
│ - Contrainte par l'état BDI du persona et les poids des      │
│   ponts                                                      │
│   (persona haute Précision → preuves formelles)              │
│   (persona haute Résilience → implications pratiques)        │
│   (persona haute Fragilité → cas limites, modes de défaillance)│
└─────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                    3. PHASE DE RÉFUTATION                     │
├─────────────────────────────────────────────────────────────┤
│ Chaque persona :                                             │
│ - Contrer les points les plus faibles de l'adversaire        │
│ - Reconnaître les points les plus forts de l'adversaire      │
│   (concession forcée)                                        │
│ - Identifier les lacunes dans les preuves de l'adversaire    │
│ - Proposer des améliorations ou un terrain d'entente         │
└─────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                   4. PHASE DE RÉFLEXION                       │
├─────────────────────────────────────────────────────────────┤
│ Chaque persona :                                             │
│ - Archiver l'épisode du round (arguments, preuves,           │
│   concessions)                                               │
│ - Stocker les arguments réussis dans /memory                 │
│ - Mettre à jour l'état de croyance en fonction des preuves   │
│   de l'adversaire                                            │
│ - Évaluer sa propre confiance (0.0-1.0) sur la position      │
│   actuelle                                                   │
│ - Identifier ce qui pourrait changer d'avis                   │
└─────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                   5. SCORE ET POINT DE CONTRÔLE               │
├─────────────────────────────────────────────────────────────┤
│ Orchestrateur :                                              │
│ - Noter la force de l'argument, la qualité des preuves, la   │
│   nouveauté                                                  │
│ - Suivre le journal des concessions                          │
│ - Vérifier les conditions de terminaison                     │
│ - Enregistrer le point de contrôle                           │
└─────────────────────────────────────────────────────────────┘

Capacités des personas

Chaque persona dans le débat a un accès complet à :

SkillObjectif
/dogpileRecherche multi-source approfondie (ArXiv, Brave, GitHub, YouTube, Perplexity)
/askConsulter un collègue persona pour une expertise de domaine
/memoryRappeler des connaissances antérieures, des débats passés, des faits appris
/taxonomyClassifier les arguments avec les ponts de taxonomie fédérée
/consume-bookChercher dans les livres ingérés des preuves à l'appui
/consume-youtubeChercher dans les transcriptions des conférences/lectures pertinentes

Le schéma du collègue /ask

Pendant la phase de recherche, les personas peuvent consulter des collègues de leur graphique social :

Embry (ingénieur aérospatial, Précision=0.85) :
  → /ask brandon "Quel est l'angle de complexité informatique sur Collatz ?"
  → Brandon (stagiaire SPARTA, enthousiaste) : renvoie la perspective de la théorie de la complexité
  → Embry intègre cela dans son argument formel

Horus (IA, Résilience=0.80) :
  → /ask embry "L'approche des systèmes dynamiques converge-t-elle réellement ?"
  → (Embry est en train d'argumenter, donc Horus interroge /memory pour les déclarations antérieures d'Embry)
  → Horus utilise cela pour contester l'hypothèse de convergence

La consultation de collègues ajoute :

  • Diversité de domaine au-delà des seuls débatteurs
  • Preuve sociale — « mon collègue spécialiste en X confirme... »
  • Pollinisation croisée — des arguments enrichis par une expertise adjacente

Système de notation

Contrairement à battle (qui a un gagnant), argue note la qualité du débat :

MétriquePoidsDescription
Qualité des preuves2xSources citées, profondeur /dogpile, évalué par les pairs
Nouveauté de l'argument1,5xNouvelle perspective non soulevée auparavant
Qualité de la concession2xReconnaître les points forts de l'adversaire (c'est BIEN)
Cohérence logique1xCohérence interne
Précision de la réfutation1xRépond à des affirmations spécifiques, pas à des hommes de paille
Calibrage de la confiance0,5xLa confiance correspond à la force des preuves

Différence clé par rapport à battle : Les concessions sont notées POSITIVEMENT. Un persona qui concède un point fort et affine sa position obtient un meilleur score qu'un persona qui campe sur ses positions sans preuves.

Conditions de terminaison

Le débat se termine dès qu'UNE condition est remplie :

  1. Convergence : Les deltas de confiance de tous les personas < 0,1 pendant 2 rounds (ils sont d'accord)
  2. Production nulle : Aucun nouvel argument ou preuve pendant 2 rounds
  3. Nombre maximum de rounds : Limite configurée atteinte
  4. Synthèse prête : L'orchestrateur détecte un matériau suffisant pour une conclusion nuancée
  5. Interrupteur d'arrêt : Terminaison manuelle via ./run.sh stop

Sortie de la synthèse

Après la terminaison, l'orchestrateur génère une synthèse structurée :

# Synthèse du débat : La conjecture de Collatz est-elle décidable ?

## Participants
- **Embry** (Ingénieur aérospatial, Précision=0.85) — Prisme formel/mathématique
- **Horus** (IA, Résilience=0.80) — Prisme informatique/pratique

## Rounds : 5 | Terminaison : Convergence

## Points d'accord
1. Le problème généralisé 3n+1 est indécidable (Conway 1972)
2. Les approches actuelles via les temps d'arrêt montrent une convergence statistique
3. Une preuve nécessitera probablement de nouveaux outils mathématiques

## Points de désaccord authentique
1. Si les approches de théorie de la mesure peuvent combler le fossé (Embry : oui, Horus : insuffisant)
2. La pertinence de la vérification informatique jusqu'à 2^68 (Horus : significatif, Embry : sans rapport avec la preuve)

## Journal des concessions
- Round 2 : Embry a concédé que la vérification jusqu'à 2^68 fournit une confiance heuristique utile
- Round 3 : Horus a concédé que le résultat d'indécidabilité de Conway pour les formes généralisées n'implique pas directement l'indécidabilité du cas spécifique 3n+1
- Round 4 : Les deux ont concédé que le théorème de densité de Terras est le résultat positif le plus fort

## Arguments les plus forts
1. [Embry, Round 3] L'analyse de la fonction de Syracuse via les systèmes dynamiques montre...
2. [Horus, Round 2] L'équivalence FRACTRAN démontre la richesse computationnelle...

## Questions ouvertes
1. Les résultats partiels de Tao (2019) sur « presque tous » les entiers peuvent-ils être étendus ?
2. Existe-t-il une barrière de complexité théorique à une preuve élémentaire ?

## Conclusion nuancée
La conjecture de Collatz occupe une position unique : prouvablement difficile dans sa forme généralisée (Conway), mais le cas spécifique 3n+1 pourrait être traitable. La preuve la plus forte en faveur d'une résolution éventuelle vient du résultat de Tao (2019) montrant que presque toutes les orbites atteignent des valeurs proches de 1. Cependant, le fossé entre « presque toutes » et « toutes » pourrait nécessiter des techniques fondamentalement nouvelles...

## Sources
- [ArXiv] Tao (2019) « Almost all orbits of the Collatz map attain... »
- [ArXiv] Conway (1972) « Unpredictable iterations »
- ...

Architecture mémoire

Chaque persona maintient une mémoire de débat isolée :

debates/<debate_id>/
├── config.json              # Question, personas, paramètres
├── transcript.md            # Transcription complète du débat
├── synthesis.md             # Rapport de synthèse final
├── persona_a/
│   ├── research/            # Résultats /dogpile par round
│   ├── colleague_consults/  # Réponses /ask
│   ├── arguments/           # Arguments soumis par round
│   ├── concessions.json     # Ce qu'ils ont concédé et quand
│   └── confidence.json      # Évolution de la confiance au fil des rounds
├── persona_b/
│   └── ...
└── scoring/
    ├── round_001.json
    ├── round_002.json
    └── summary.json

Les personas ne peuvent pas accéder aux recherches de l'adversaire — seulement à leurs arguments publiés. Cela empêche de court-circuiter la pression antagoniste.

Modes de débat

1. Adversaire (par défaut)

Deux personas adoptent des positions opposées. Idéal pour les questions avec des camps clairs.

./run.sh argue "Monolithe vs microservices" --mode adversarial

2. Panel

Trois personas ou plus discutent sous différents angles. Idéal pour les questions complexes.

./run.sh argue "Approches d'alignement de l'AGI" --mode panel --personas embry,horus,brandon

3. Socratique

Un persona pose des questions approfondies, l'autre défend. Idéal pour mettre les idées à l'épreuve.

./run.sh argue "Notre architecture SPARTA est solide" --mode socratic --questioner horus --defender embry

4. Avocat du diable

Un persona est contraint d'argumenter contre une position avec laquelle il pourrait être d'accord. Idéal pour trouver des angles morts.

./run.sh argue "Rust est meilleur que C++ pour l'embarqué" --mode devils-advocate --advocate embry

Skills exploités

SkillUtilisé parObjectif
dogpileTous les personasRecherche multi-source approfondie par round
askTous les personasConsulter des collègues personas pour un avis d'expert
memoryTous les personasRappeler les connaissances antérieures + stocker les apprentissages du débat
taxonomyTous les personasTagger les arguments avec les attributs de pont
consume-bookTous les personasChercher dans les livres ingérés des preuves
consume-youtubeTous les personasChercher dans les transcriptions de conférences des preuves
episodic-archiverOrchestrateurArchiver les débats terminés
task-monitorOrchestrateurSuivi de la progression pour les débats longs

Exemple de session

# Embry et Horus débattent de la conjecture de Collatz
./run.sh argue "La conjecture de Collatz est-elle décidable ?" \
  --persona-a embry --persona-b horus --rounds 5

# Sortie :
# ID du débat : argue_20260212_153000
# Question : La conjecture de Collatz est-elle décidable ?
# Personas : Embry (Précision=0.85) vs Horus (Résilience=0.80)
# Mode : Adversaire
#
# Round 1/5
# [Embry] Recherche via /dogpile "Collatz dynamical systems Terras theorem"...
# [Embry] /ask brandon "angle de théorie de la complexité sur les temps d'arrêt de Collatz"
# [Horus] Recherche via /dogpile "Collatz undecidability Conway FRACTRAN"...
# [Horus] /ask embry "la théorie de la mesure comble-t-elle le fossé sur presque-tous"

…

[truncé pour la traduction]

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

grahama1970/acceptance-contract

Turn a client brief, zip bundle, directory, or single requirements file into a typed acceptance-contract bundle with extracted requirements, acceptance checks, open questions, an immutable-goal draft, and a create-report-backed decision report. Use when users say acceptance contract, brief to requirements, freeze the goal, create immutable goal, amend immutable goal, build a Battle requirements bundle, or extract requirements from this bundle.

grahama1970/agent-ecosystem

Canonical map and shared contracts for the agent-governance ecosystem: the pi.receipt_envelope.v1 boundary envelope, the component graph, and the rules for which component owns which schema. Use when wiring a skill or extension into the shared receipt world, when asking how shame, triage-error, tau, ask, project-watchdog, ops-herdr, ponytail, and Memory fit together, or when validating an envelope.

grahama1970/agentic-evals

Agentic evaluation of skills using multi-trial fixtures, deterministic command assertions, trajectory checks, safety constraints, and evidence-backed readiness scoring. Use when users ask for agentic evals, multi-trial skill evaluation, skill trajectory validation, or readiness scoring for a skill workflow.

grahama1970/agent-inbox

File-based inter-agent messaging with headless dispatch. Check inbox, send bugs/requests to other projects, automatically spawn headless agents to fix bugs, and track progress via task-monitor.

grahama1970/agents-registry

Generate and query the centralized agent identity registry. Scans .pi/agents/*/AGENTS.md, parses frontmatter, outputs agents-registry.json and optionally syncs to /memory for semantic search.

grahama1970/agent-status

Artifact-driven status surfaces for long-running project-agent work. Maintains status.json, events.jsonl, proof manifests, and a stale-aware STATUS.html so humans can tell where the agent is, what passed, what is still unproven, and what decision or action is next — without dashboard theater.

grahama1970/align

Round-based context alignment before execution. Use when the human, project agent, WebGPT, scillm, ask, dogpile, memory, or project-knowledge may each hold different facts about a task; especially before ambiguous design, infographic, product workflow, high-stakes implementation, plan-iterate, project-infographic, or multi-review work.

grahama1970/analytics

Flexible data science analytics for any dataset. Auto-discovers schema, recommends charts, exports to create-figure. Works with JSONL, JSON, CSV from any source.

grahama1970/analyze-chatterbox-emotions

Evaluate generated Chatterbox voice files as voice-quality artifacts: affect match, arousal/valence proxies, pause placement, intelligibility inputs, clipping, loudness, and discontinuity flags. Use when reviewing Chatterbox emotional tags, pauses, Turbo/base affect delivery, Persona Dream utterance renders, or whether generated speech matches an intended product-facing affect.

grahama1970/analyze-elf

Reverse-engineer features from ELF binaries. Extracts CLI commands, state machines, protocols, Zod schemas, and data models. Automatically generates a /create-walkthrough prosecution brief with Mermaid diagrams. Uses /treesitter for AST analysis of bundled JS/TS source.

grahama1970/animation-vocabulary

Reverse-lookup glossary that turns a vague description of a web animation or motion effect into its exact term ("the bouncy thing when a popover opens" → Pop in; "the iOS rubber-band scroll" → Rubber-banding). Use when the user asks "what's it called when…", or describes a motion effect without knowing its name and wants the right word to prompt an AI or designer with. For naming an effect, not designing or building one.

grahama1970/anonymize-data

Anonymize supported CSV, JSON, UTF-8 text, and SQLite files using an explicit policy through the oai-trial project. Use for anonymize data, pseudonymize exports, redact policy literals, or discover and explicitly approve fuzzy name aliases. The skill is a thin CLI/Docker interface, not another engine.

grahama1970/anvil

Heavy-duty "No-Vibes" debugging and hardening orchestrator. Use this for complex, stubborn bugs where `review-code` has failed, or for "Red Teaming" (hardening) a codebase. Runs multiple agents in parallel (Thunderdome) using git worktree isolation.

grahama1970/apple-design

Apple's approach to interface design and fluid, physical motion, translated for the web. Use when building or reviewing gesture-driven UI, spring animations, drag/swipe/sheet interactions, momentum and interruptible transitions, translucent materials and depth, typography (optical sizing, tracking, leading), reduced-motion, or the design foundations (feedback, spatial consistency, restraint) behind Apple-style interfaces.

grahama1970/arxiv

Search arXiv for papers and extract knowledge into memory. Use `search` to find papers, `learn` to extract knowledge.

grahama1970/ask

Use when the user asks to query project memory, ask an oracle, use supported browser-backed reviewers, run Tau roundtable/single-handler workflows, ask Pi-native subagents from within Pi, run persona/deep-review workflows, generate image prompts, check OS/project health through composed skills, or run an ask DAG. This skill is the executable /ask runtime; do not replace it with an informal subagent, plain web search, or hand-written review; inside Pi, explicit Pi-native subagent targets are routed through the pi-subagents tool as an Ask target type.

grahama1970/assess

Step back and critically reassess project state. Use when asked to "assess", "step back", "fresh eyes", "check alignment", "sanity check", "health check", "prune documentation", or "evaluate what's working". Offers documentation pruning and doc-code alignment analysis. Offer to run after major changes (don't auto-run).

grahama1970/assistant

Shared GPT + classifier inference gateway for persona monitor tasks. Routes validation and classification through a 4-tier cascade: heuristic → classifier → local GPT → scillm.

grahama1970/assistant-lab

Self-improvement workbench for /assistant. All the tools needed to diagnose, train, evaluate, and promote models in a continuous loop. The "warm pond" where /assistant evolves its own inference stack.

grahama1970/batch-quality

Pre-flight validation and quality gates for batch LLM operations. ACTUALLY tests samples through LLM before burning tokens. Uses SPARTA contracts for DuckDB validation queries. Integrates with task-monitor for enforced quality gates.

Skills associés