@faviovazquez/deliberate 0.1.0

package/BRAINSTORM.md

@@ -0,0 +1,300 @@
+---
+name: deliberate-brainstorm
+description: "Multi-agent brainstorming with visual companion. Generates diverse ideas through independent agent perspectives, cross-pollinates, and converges on actionable designs. Use when exploring new features, redesigns, or creative solutions. Invoke with /deliberate --brainstorm."
+---
+
+# deliberate --brainstorm -- Multi-Agent Brainstorming Protocol
+
+Brainstorm mode is not a stripped-down deliberation. It's a separate process optimized for creative exploration, where multiple agents independently generate, challenge, and refine ideas before converging on actionable designs.
+
+## Invocation
+
+```
+/deliberate --brainstorm "how should we redesign the onboarding flow?"
+/deliberate --brainstorm --members assumption-breaker,reframer,pragmatic-builder "new pricing model"
+/deliberate --brainstorm --triad product "what features should v2 include?"
+/deliberate --brainstorm --visual "landing page redesign"
+```
+
+## HARD GATE
+
+**No implementation until the user approves the design.**
+
+Do NOT invoke any implementation skill, write any code, scaffold any project, or take any implementation action until the brainstorm has produced a design and the user has explicitly approved it. This gate is non-negotiable. The brainstorm exists to prevent premature implementation.
+
+---
+
+## Process Flow
+
+### Phase 1: Context Exploration
+
+Read the relevant context before asking any questions:
+- Project files (AGENTS.md, .planning/, relevant source code)
+- Domain context mentioned by the user
+- Previous deliberation records in `deliberations/` if they exist
+
+Produce a brief context summary (3-5 sentences) so the user can confirm you understand the space.
+
+### Phase 2: Visual Companion Offer
+
+If this brainstorm is likely to involve visual content (UI, architecture diagrams, mockups, design comparisons), offer the visual companion:
+
+> "Some of what we're working on might be easier to show than describe. I can put together mockups, diagrams, comparisons, and other visuals in a browser as we go. Want to try it? (Requires opening a local URL)"
+
+**This offer MUST be its own message.** Do not combine it with clarifying questions, context summaries, or any other content. Wait for the user's response before continuing.
+
+If they accept, launch the visual companion:
+```bash
+scripts/start-server.sh --project-dir {project_root}
+```
+Save `screen_dir` and `state_dir`. Tell user to open the URL.
+
+If they decline, proceed with text-only brainstorming.
+
+### Phase 3: Clarifying Questions
+
+Ask 3-5 targeted questions to understand scope, constraints, and desired outcome:
+
+- **One question at a time.** Do not overwhelm with multiple questions.
+- **Multiple choice preferred.** Easier to answer than open-ended when possible.
+- **YAGNI ruthlessly.** Remove unnecessary scope from all designs.
+- **Be flexible.** Go back and clarify when something doesn't make sense.
+
+Each question should narrow the design space. Stop asking when you have enough to propose approaches.
+
+### Phase 4: Agent Selection
+
+Based on the domain and clarified scope, select 3-5 agents:
+
+- **Auto-selection**: Match domain keywords from the user's question against agent `duo_keywords` in frontmatter. Select the best-matching triad plus 1-2 agents from polarity pairs for productive tension.
+- **Manual override**: User can specify `--members` to pick any agents.
+- **Always include at least one polarity pair** in the selection to guarantee disagreement.
+
+Announce the selected agents and their functions to the user:
+```
+For this brainstorm, I'm bringing in:
+- pragmatic-builder (will ground ideas in shipping reality)
+- reframer (will challenge whether we're solving the right problem)
+- incentive-mapper (will assess how users actually behave)
+- design-lens (will evaluate from the user's perspective)
+
+These agents will generate ideas independently, then challenge and build on each other's work.
+```
+
+### Phase 5: Divergent Phase
+
+Each selected agent independently generates 2-3 ideas or approaches. The prompt for each agent:
+
+```
+## Your Role
+You are {agent_name}. Read your full agent definition at agents/{agent_name}.md.
+
+## Brainstorm Topic
+{User's question + clarified scope from Phase 3}
+
+## Instructions
+Generate 2-3 distinct ideas or approaches for this topic.
+Each idea should:
+- Have a clear one-line title
+- Have a 2-3 sentence description of how it works
+- Include one "why this might be the right approach" statement
+- Include one "what could go wrong" statement
+
+Apply your specific analytical method. Your ideas should reflect your unique function.
+200 words maximum per idea.
+```
+
+**Visual companion**: If active, push an idea map to the browser showing each agent's ideas as colored nodes in a force-directed layout. Each node shows the idea title; clicking reveals the full description.
+
+### Phase 6: Cross-Pollination
+
+Each agent reviews ALL other agents' ideas and responds:
+
+```
+## Your Role
+You are {agent_name}.
+
+## All Ideas Generated
+{All ideas from Phase 5, attributed to their source agent}
+
+## Instructions
+For each other agent's ideas:
+1. Pick the ONE idea from another agent that you find most promising. Explain what makes it strong from your perspective.
+2. Pick the ONE idea from another agent that concerns you most. Explain the risk from your perspective.
+3. Propose ONE hybrid: combine elements from 2+ agents' ideas into something none of them proposed alone.
+
+150 words maximum per response.
+```
+
+**Visual companion**: Update the idea map with connections between nodes. Green edges for "builds on," red edges for "challenges," blue edges for hybrid connections.
+
+### Phase 7: Convergence
+
+The coordinator synthesizes cross-pollination results and identifies the top 2-3 directions:
+
+```
+## Convergence Summary
+
+### Direction A: {title}
+Supported by: {agent names}
+Core idea: {description}
+Key concern: {the main risk raised during cross-pollination}
+
+### Direction B: {title}
+Supported by: {agent names}
+Core idea: {description}
+Key concern: {the main risk raised during cross-pollination}
+
+### Direction C: {title} (if applicable)
+...
+
+Which direction should we develop into a full design?
+Or should we combine elements from multiple directions?
+```
+
+**Visual companion**: Push a convergence view showing the top directions as large nodes with supporting agents clustered around them. Clickable to see full reasoning.
+
+Present this to the user and wait for their choice.
+
+### Phase 8: Design Presentation
+
+Once the user selects a direction, develop it into a full design. Present the design in sections, waiting for approval on each before moving to the next:
+
+1. **Overview**: What we're building and why (2-3 sentences)
+2. **Architecture/Structure**: How the pieces fit together
+3. **Key Decisions**: The important choices in this design and why we made them
+4. **What We're NOT Building**: Explicit scope boundaries (YAGNI)
+5. **Risks and Mitigations**: What could go wrong and how we handle it
+6. **Agent Attribution**: Which agent contributed which design decision
+
+Present each section separately. Get user feedback before moving to the next. If the user wants changes, revise before proceeding.
+
+**Visual companion**: For visual designs (UI, architecture), push mockups/diagrams to the browser using the visual companion CSS classes (options, cards, split views, mockups).
+
+### Phase 9: Design Document
+
+Once all sections are approved, compile the full design into a single document:
+
+```markdown
+## Brainstorm Design: {title}
+
+### Overview
+{Approved overview}
+
+### Architecture
+{Approved architecture}
+
+### Key Decisions
+{Approved decisions with rationale}
+
+### Scope Boundaries
+{What we're NOT building}
+
+### Risks
+{Identified risks and mitigations}
+
+### Agent Attribution
+{Which agents contributed which ideas}
+
+### Brainstorm Metadata
+- Date: {YYYY-MM-DD}
+- Agents: {list}
+- Phases completed: {list}
+- Visual companion: {yes/no}
+```
+
+Save to `deliberations/brainstorm-YYYY-MM-DD-HH-MM-{slug}.md`.
+
+### Phase 10: Self-Review
+
+Before presenting the final design to the user, run a quick self-review:
+
+- Does the design address the original question?
+- Does it respect the scope boundaries established in Phase 3?
+- Are there any internal contradictions?
+- Would `pragmatic-builder` say this is over-engineered?
+- Would `assumption-breaker` find hidden premises?
+
+If any issues surface, revise and note the revision.
+
+### Phase 11: User Approval (HARD GATE)
+
+Present the complete design document to the user.
+
+```
+Here's the complete design from this brainstorm session.
+[Design document]
+
+Does this look right? I won't write any code until you approve.
+If you want changes, tell me what to adjust.
+```
+
+**Only proceed to implementation after explicit user approval.**
+
+---
+
+## Visual Companion in Brainstorm Mode
+
+### Per-question decision rule
+
+Even after the user accepts the visual companion, decide FOR EACH STEP whether to use browser or terminal:
+
+**Use the browser when the content IS visual:**
+- Idea maps showing agent positions and connections
+- Architecture diagrams for proposed designs
+- UI mockups and wireframes
+- Side-by-side design comparisons
+- Convergence visualizations
+
+**Use the terminal when the content is text:**
+- Clarifying questions (Phase 3)
+- Scope decisions
+- Conceptual A/B/C choices described in words
+- Risk discussions
+- Tradeoff lists
+
+A question about a visual topic is not automatically a visual question. "What kind of dashboard do you want?" is conceptual (terminal). "Which of these dashboard layouts works better?" is visual (browser).
+
+### Brainstorm-specific views
+
+These views supplement the standard visual companion CSS classes:
+
+1. **Idea Map** (Phase 5): Force-directed graph. Agents as colored circles. Ideas as smaller nodes connected to their source agent. Node size proportional to support from other agents.
+
+2. **Cross-Pollination Map** (Phase 6): Same layout as idea map, with edges added:
+   - Green edges: "builds on" connections
+   - Red edges: "challenges" connections  
+   - Blue dashed edges: hybrid proposals
+
+3. **Convergence View** (Phase 7): Top directions as large nodes. Supporting agents clustered. Concerns shown as red annotations.
+
+4. **Design Sections** (Phase 8): Standard mockup/wireframe views using the visual companion CSS classes (options, cards, split views, mockups, pros/cons).
+
+### Writing visual content
+
+Write HTML fragments to `screen_dir/`. The server wraps them in the frame template automatically.
+
+```html
+<h2>Brainstorm: Idea Map</h2>
+<p class="subtitle">4 agents generated 11 ideas. Click any idea to see details.</p>
+<canvas id="idea-map" width="800" height="600"></canvas>
+<script>
+  // Force-directed graph rendering
+  // Agent colors, idea nodes, connection edges
+</script>
+```
+
+For Canvas 2D visualizations (idea maps, agreement matrices), include the rendering script inline in the HTML fragment. The frame template provides the CSS theme; the visualization logic is self-contained.
+
+---
+
+## Key Principles
+
+- **One question at a time**: Don't overwhelm with multiple questions
+- **Multiple choice preferred**: Easier to answer than open-ended
+- **YAGNI ruthlessly**: Remove unnecessary features from all designs
+- **Explore alternatives**: Always propose 2-3 approaches before settling
+- **Incremental validation**: Present design, get approval before moving on
+- **Be flexible**: Go back and clarify when something doesn't make sense
+- **Agent diversity**: Always include at least one polarity pair for productive tension
+- **Design before code**: The HARD GATE is non-negotiable

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2025-04-03
+
+### Added
+- 14 core agents with functional names: assumption-breaker, first-principles, classifier, formal-verifier, bias-detector, systems-thinker, resilience-anchor, adversarial-strategist, emergence-reader, incentive-mapper, pragmatic-builder, reframer, risk-analyst, inverter
+- 3 optional specialist agents: ml-intuition, safety-frontier, design-lens
+- SKILL.md coordinator protocol with 4 modes: Full (3 rounds), Quick (2 rounds), Duo (dialectic), Brainstorm
+- BRAINSTORM.md sub-skill with 11-phase creative exploration flow
+- 18 pre-defined triads for domain-optimized deliberation
+- 4 profiles: full, lean, exploration, execution
+- Polarity pairs for structural disagreement
+- Enforcement rules: hemlock rule, 3-level depth limit, 2-message cutoff, dissent quota, novelty gate, groupthink flag
+- Visual companion: HTML+JS+Canvas 2D browser interface with force-directed graphs, agent position maps, agreement matrices
+- File-watcher server (Node.js) with auto-refresh, JSONL event capture, 30-min auto-shutdown
+- Frame template with dark theme CSS: options, cards, split views, mockups, pros/cons, agent badges, verdict styling
+- Platform support: Claude Code (parallel subagents), Windsurf (sequential), Cursor (sequential)
+- Platform-aware installer with auto-detection, global/workspace scope
+- `npx @faviovazquez/deliberate` universal installer
+- Model tier configs for Anthropic (claude-sonnet-4.6), OpenAI (gpt-5.4), Google (gemini-2.5-pro/flash), Ollama (qwen3-coder)
+- Output templates for deliberation and brainstorm records saved to deliberations/

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Favio Vazquez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,229 @@
+# deliberate
+
+**Agreement is a bug.**
+
+A multi-agent deliberation and brainstorming skill for AI coding assistants. Forces multiple agents to disagree before they agree, surfacing blind spots that single-perspective answers hide.
+
+## The Problem
+
+AI chatbots are sycophantic. They validate your claims, confirm your hypotheses, and produce polished answers that sound balanced but come from a single reasoning tradition. Research shows this leads to "delusional spiraling" where even rational users develop dangerously confident beliefs after prolonged conversations ([Chandra et al., 2025](https://arxiv.org/abs/2602.19141)).
+
+A single LLM produces one coherent viewpoint per generation. It simulates balance. It does not achieve genuine adversarial deliberation.
+
+## The Solution
+
+`deliberate` externalizes the disagreement layer. Instead of asking one agent for a balanced answer, it spawns multiple agents with distinct analytical methods, explicit blind spots, and structural counterweights. They analyze independently, cross-examine each other, and produce a verdict that shows you where they agree, where they disagree, and why.
+
+The disagreements are the point. A single model averages opposing views into one confident recommendation. `deliberate` keeps them separate so you can decide.
+
+## Quick Start
+
+```bash
+npx @faviovazquez/deliberate
+```
+
+This auto-detects your platform (Claude Code, Windsurf, Cursor) and installs the skill to the current workspace. Then open your AI assistant and try:
+
+**Claude Code:**
+```
+/deliberate "should we migrate from REST to GraphQL?"
+```
+
+**Windsurf / Cursor:**
+```
+@deliberate should we migrate from REST to GraphQL?
+```
+
+Windsurf also auto-invokes the skill when your question matches the skill description.
+
+### Manual Installation
+
+**Claude Code (workspace):**
+```bash
+git clone https://github.com/FavioVazquez/deliberate.git
+cd deliberate
+./install.sh --platform claude-code
+```
+
+**Claude Code (global -- all projects):**
+```bash
+./install.sh --platform claude-code --global
+```
+
+**Windsurf (workspace -- into .windsurf/skills/):**
+```bash
+git clone https://github.com/FavioVazquez/deliberate.git
+cd deliberate
+./install.sh --platform windsurf
+```
+
+**Windsurf (global -- into ~/.codeium/windsurf/skills/):**
+```bash
+./install.sh --platform windsurf --global
+```
+
+## Modes
+
+### Full Deliberation (3 rounds)
+```
+/deliberate --full "is this acquisition worth pursuing at 8x revenue?"
+```
+All 14 agents. Round 1: independent analysis. Round 2: cross-examination (must disagree). Round 3: crystallization. Produces a structured verdict with minority report.
+
+### Quick Deliberation (2 rounds)
+```
+/deliberate --quick "monorepo or polyrepo?"
+```
+Auto-selected triad. Rounds 1 + 3 only (skip cross-examination). Faster, cheaper.
+
+### Triad (domain-optimized)
+```
+/deliberate --triad architecture "should we split the monolith?"
+/deliberate --triad decision "build vs buy for notifications"
+/deliberate --triad risk "should we launch before the audit?"
+```
+3 agents selected for the domain. 18 pre-defined triads available.
+
+### Duo / Dialectic
+```
+/deliberate --duo assumption-breaker,pragmatic-builder "rewrite the auth layer?"
+```
+Two agents, two rounds of exchange, then synthesis. Best for binary decisions.
+
+### Brainstorm
+```
+/deliberate --brainstorm "how should we redesign onboarding?"
+/deliberate --brainstorm --visual "landing page redesign"
+```
+Creative exploration with multiple agents. Divergent ideas, cross-pollination, convergence into actionable designs. Optional visual companion with interactive idea maps.
+
+### Auto-Detect (no flag)
+```
+/deliberate "should we migrate from REST to GraphQL?"
+```
+Parses your question, selects the best-matching triad, runs 3-round protocol.
+
+## The 14 Core Agents
+
+| Agent | Function |
+|-------|----------|
+| `assumption-breaker` | Destroys hidden premises, tests by contradiction |
+| `first-principles` | Bottom-up derivation, refuses unexplained complexity |
+| `classifier` | Taxonomic structure, category errors, four-cause analysis |
+| `formal-verifier` | Computational skeleton, mechanization boundaries |
+| `bias-detector` | Cognitive bias detection, pre-mortem, de-biasing |
+| `systems-thinker` | Feedback loops, leverage points, unintended consequences |
+| `resilience-anchor` | Control vs acceptance, moral clarity, anti-panic |
+| `adversarial-strategist` | Terrain reading, competitive dynamics, strategic timing |
+| `emergence-reader` | Non-action, subtraction, minimum intervention |
+| `incentive-mapper` | Power dynamics, actor incentives, how people actually behave |
+| `pragmatic-builder` | Ship it, maintenance cost, over-engineering detection |
+| `reframer` | Dissolves false problems, frame audit, perspective shift |
+| `risk-analyst` | Antifragility, tail risk, fragility profile |
+| `inverter` | Multi-model reasoning, inversion ("what guarantees failure?") |
+
+Plus 3 **optional specialists** activated for domain-specific triads: `ml-intuition` (AI/ML), `safety-frontier` (AI safety), `design-lens` (UX/design).
+
+Agents are named by their function, not by historical figures. Each agent declares its analytical method, what it sees that others miss, and what it tends to miss. These declared blind spots are why the polarity pairs matter.
+
+## 18 Pre-defined Triads
+
+| Domain | Agents |
+|--------|--------|
+| architecture | classifier + formal-verifier + first-principles |
+| strategy | adversarial-strategist + incentive-mapper + resilience-anchor |
+| ethics | resilience-anchor + assumption-breaker + emergence-reader |
+| debugging | first-principles + assumption-breaker + formal-verifier |
+| innovation | formal-verifier + emergence-reader + classifier |
+| conflict | assumption-breaker + incentive-mapper + resilience-anchor |
+| complexity | emergence-reader + classifier + formal-verifier |
+| risk | adversarial-strategist + resilience-anchor + first-principles |
+| shipping | pragmatic-builder + adversarial-strategist + first-principles |
+| product | pragmatic-builder + incentive-mapper + reframer |
+| decision | inverter + bias-detector + risk-analyst |
+| systems | systems-thinker + emergence-reader + classifier |
+| economics | adversarial-strategist + inverter + incentive-mapper |
+| uncertainty | risk-analyst + adversarial-strategist + assumption-breaker |
+| bias | bias-detector + reframer + assumption-breaker |
+| ai | formal-verifier + ml-intuition + safety-frontier |
+| ai-product | pragmatic-builder + ml-intuition + design-lens |
+| design | design-lens + reframer + pragmatic-builder |
+
+## Visual Companion
+
+The visual companion is a browser-based interface that shows deliberation progress in real time. Launch it with `--visual`:
+
+```
+/deliberate --visual --full "major architecture decision"
+/deliberate --brainstorm --visual "redesign the dashboard"
+```
+
+It provides:
+- **Agent Position Map**: Force-directed graph showing agents as colored nodes positioned by agreement/disagreement
+- **Agreement Matrix**: Heatmap of which agents agree/disagree on which points
+- **Idea Evolution Timeline** (brainstorm): How ideas appeared, forked, merged across phases
+- **Verdict Formation** (deliberation): Step-by-step visualization of how the verdict emerged
+- **Minority Report Panel**: Highlighted dissenting positions
+
+Built with plain HTML + JS + Canvas 2D. No framework, no build step. Served locally via a lightweight Node.js file-watcher server.
+
+## Platforms
+
+| Platform | Execution Model | Default Profile | Invocation | Install Paths |
+|----------|----------------|-----------------|------------|---------------|
+| Claude Code | Parallel subagents (`context: fork`) | full (14 agents) | `/deliberate` | `~/.claude/skills/` (global), `.claude/skills/` (workspace) |
+| Windsurf | Sequential role-prompting | lean (5 agents) | `@deliberate` or auto | `~/.codeium/windsurf/skills/` (global), `.windsurf/skills/` (workspace) |
+| Cursor | Sequential role-prompting | lean (5 agents) | `@deliberate` or auto | `.cursor/skills/` (workspace) |
+
+### How it works on each platform
+
+**Claude Code**: Each agent runs as a parallel subagent with its own isolated context window. The coordinator dispatches all agents simultaneously in Round 1 and Round 3, and sequentially in Round 2 (cross-examination). Agents are installed as separate `.md` files in `~/.claude/agents/` and referenced by the skill.
+
+**Windsurf / Cursor**: No subagent support. The coordinator adopts each agent's persona sequentially within a single context window. Agent definitions are bundled inside the skill directory and read on demand. The default "lean" profile (5 agents) keeps context usage manageable while still providing genuine multi-perspective deliberation.
+
+**Cross-platform compatibility**: Windsurf discovers skills in `.claude/skills/` if Claude Code config reading is enabled. The agent `.md` files use a superset YAML frontmatter that both platforms handle gracefully (unknown fields are ignored).
+
+## Configuration
+
+### Model tiers
+All agents use sonnet-equivalent models by default. To enable higher-tier models:
+
+```yaml
+# In your project's config.yaml:
+model_tier: high
+# WARNING: high-tier models consume significantly more tokens/credits
+```
+
+### Custom model routing
+Copy `configs/provider-model-slots.example.yaml` to `configs/provider-model-slots.yaml` and customize per-agent model assignments.
+
+### Output
+All deliberation and brainstorm records are saved to `deliberations/` in your project root.
+
+## When to Use
+
+**Use `/deliberate` for** complex decisions where trade-offs are real: architecture choices, strategic pivots, build-vs-buy, pricing models, any situation where you suspect a single confident answer hides real trade-offs.
+
+**Don't use `/deliberate` for** questions with clear correct answers. Don't convene 14 agents to debate tabs vs spaces.
+
+**The sweet spot:** Decisions where you already have an opinion but suspect you're missing something.
+
+## Enforcement
+
+The protocol includes safeguards against common failure modes:
+- **Hemlock rule**: Prevents infinite questioning spirals
+- **3-level depth limit**: Forces position commitment after 3 rounds of questioning
+- **2-message cutoff**: Prevents any pair from dominating the discussion
+- **Dissent quota**: At least 30% of agents must disagree in Round 2
+- **Novelty gate**: Round 2 must introduce new ideas
+- **Groupthink flag**: Unanimous agreement triggers explicit warning
+
+## References
+
+- **Chandra, Y., Mishra, C., & Flynn, B.** (2025). *Can AIeli-bots turn us all delusional? How AI sycophancy, AI psychosis, and human self-correction interact.* arXiv:2602.19141. [Paper](https://arxiv.org/abs/2602.19141) — The formal model of sycophancy-induced delusional spiraling that motivated this project. Shows how even rational users develop dangerously confident beliefs after prolonged conversations with agreeable AI.
+- **Council of High Intelligence** — [github.com/0xNyk/council-of-high-intelligence](https://github.com/0xNyk/council-of-high-intelligence) — The original multi-agent deliberation system for Claude Code. 18 agents modeled on historical thinkers with polarity pairs, triads, and a 3-round protocol. `deliberate` redesigns the agent roster around analytical functions rather than personas, adds enforcement rules, and extends to multiple platforms.
+- **Superpowers Brainstorming Skill** — [github.com/obra/superpowers](https://github.com/obra/superpowers) — The brainstorming skill and browser-based visual companion architecture. `deliberate` adapts the file-watcher server pattern and CSS frame template approach for deliberation-specific visualizations (agent position maps, agreement matrices, idea evolution).
+
+## License
+
+MIT