@hailer/mcp 1.1.12 → 1.1.13

package/.claude/commands/cleanup-squad.md

@@ -1,98 +0,0 @@
----
-description: Clean up codebase with Bjorn, Code Simplifier, and Lars
-argument-hint: [files, directory, or blank for recent changes]
-allowed-tools: Task, Bash
----
-# Cleanup Squad
-
-Run parallel codebase cleanup using three agents simultaneously.
-
-**Agents:**
-- **Bjorn** - Configuration audit (verify CLAUDE.md, hooks, workspace structure)
-- **Code Simplifier** - Refactor (improve code clarity and maintainability)
-- **Lars** - Dead code detection (find unused imports, dead code, type errors)
-
-**Target:** $ARGUMENTS (if blank, use recent git changes)
-
-**Changed files (auto-injected):**
-!git diff --name-only HEAD
-
-## Protocol
-
-### Step 1: Determine Target
-
-If `$ARGUMENTS` has specific files/directories, use those.
-Otherwise, use the changed files list above as the target.
-
-If `$ARGUMENTS` contains `--skip-config`:
-- Remove flag from target
-- Skip Bjorn in Step 2
-
-If `$ARGUMENTS` contains `--skip-dead-code`:
-- Remove flag from target
-- Skip Lars in Step 2
-
-### Step 2: Launch Agents in Parallel
-
-Spawn all agents simultaneously using multiple Task tool calls in a single message:
-
-**Bjorn:**
-```
-Task(subagent_type="agent-bjorn-config-audit", prompt="Audit codebase configuration for: [TARGET]. Check:\n- CLAUDE.md accuracy and completeness\n- Hook configurations\n- Workspace structure\n- Agent definitions\n\nReturn list of issues found with severity levels.")
-```
-
-**Code Simplifier:**
-```
-Task(subagent_type="agent-code-simplifier", prompt="Refactor these files for clarity and maintainability: [TARGET]. Focus on:\n- Variable naming\n- Function complexity\n- Comment clarity\n- Code organization\n\nReturn refactoring suggestions with before/after examples.")
-```
-
-**Lars:**
-```
-Task(subagent_type="agent-lars-code-inspector", prompt="Inspect these files for dead code: [TARGET]. Find:\n- Unused imports\n- Unreachable code\n- Unused variables\n- Type errors\n\nUse LSP if available. Return detailed list grouped by file.")
-```
-
-### Step 3: Aggregate Results
-
-Compile a unified cleanup report:
-
-```markdown
-## Cleanup Squad Report
-
-### Bjorn (Config Audit)
-- Issues found: X
-- Critical: X
-- Warnings: X
-- [Issues grouped by category]
-
-### Code Simplifier (Refactoring)
-- Files analyzed: X
-- Refactoring suggestions: X
-- [Suggestions grouped by file]
-
-### Lars (Dead Code)
-- Unused imports: X
-- Dead code blocks: X
-- Type errors: X
-- [Details grouped by file]
-
-### Summary
-[Overall assessment of codebase health]
-[Prioritized action items]
-
-### Recommended Order
-1. [Fix critical config issues first]
-2. [Remove dead code]
-3. [Apply refactoring suggestions]
-```
-
-If any agent fails or times out, report partial results from successful agents, note which failed, and offer to re-run individually.
-
-## Options
-
-| Flag | Effect |
-|------|--------|
-| `--skip-config` | Skip Bjorn (faster, no config validation) |
-| `--skip-dead-code` | Skip Lars (when LSP not configured) |
-| `--bg` | Run all agents in background mode |
-
-If `--bg` is present, launch all agents with `run_in_background: true` and tell the user they'll be notified when complete.

package/.claude/commands/config-squad.md

@@ -1,106 +0,0 @@
----
-description: Set up workflow config with Helga, Alejandro, and Viktor
-argument-hint: "workflow/config description"
-allowed-tools: Task, Bash, Read
----
-# Config Squad
-
-Sequential pipeline: Create workflow infrastructure, then calculated fields, then insights.
-
-**Agents:**
-1. **Helga** - Workflow config (fields, phases, teams, groups)
-2. **Alejandro** - Function fields and nameFunction
-3. **Viktor** - SQL insights for reporting
-
-**Goal:** $ARGUMENTS
-
-## Protocol
-
-### Step 1: Understand Scope
-
-Parse `$ARGUMENTS` to determine what's needed:
-
-| Keyword | Agents to Use |
-|---------|---------------|
-| "workflow", "fields", "phases" | Helga (+ Alejandro if function fields mentioned) |
-| "insight", "report", "dashboard" | Viktor (may need Kenji first for schema) |
-| "function", "calculated", "nameFunction" | Alejandro only |
-| General description | All three in sequence |
-
-If scope is unclear, use AskUserQuestion:
-- What workflow(s) does this involve?
-- Do you need calculated fields?
-- Do you need reports/insights?
-
-If `$ARGUMENTS` contains `--skip-insights`: skip Viktor.
-If `$ARGUMENTS` contains `--skip-functions`: skip Alejandro.
-
-### Step 2: Helga (Workflow Config)
-
-Spawn Helga:
-
-```
-Task(subagent_type="agent-helga-workflow-config", prompt="$ARGUMENTS")
-```
-
-Wait for result. If Helga returns `"status": "ready_to_push"`:
-- Run the push commands she provides (e.g., `npm run fields-push:force`)
-- Then run `npm run pull` to refresh local workspace with new IDs
-
-**Important:** Helga ALWAYS spawns Alejandro for nameFunction after creating a workflow. Check Helga's result - if she reports Alejandro created the nameFunction and all needed function fields, skip Step 3. Only proceed to Step 3 if additional function fields are needed beyond what Helga+Alejandro already created.
-
-### Step 3: Alejandro (Function Fields)
-
-Only if function fields or nameFunction are needed and weren't handled by Helga.
-
-Spawn Alejandro:
-
-```
-Task(subagent_type="agent-alejandro-function-fields", prompt="Create function fields for: $ARGUMENTS. Helga created these workflows: [SUMMARIZE HELGA'S RESULT - workflow names and any IDs she returned]. Read workspace/ to discover field IDs and types. New fields created by Helga: [LIST FROM HELGA'S RESULT IF ANY].")
-```
-
-Wait for result. If `"status": "ready_to_push"`:
-- Run the push commands
-
-### Step 4: Viktor (Insights)
-
-Only if reporting/insights are needed.
-
-Spawn Viktor:
-
-```
-Task(subagent_type="agent-viktor-sql-insights", prompt="Create insights for: $ARGUMENTS. Read workspace/ to discover workflow IDs and field IDs for SQL queries. Helga created: [SUMMARIZE HELGA'S RESULT].")
-```
-
-Wait for result. If `"status": "ready_to_push"`:
-- Run the push commands (e.g., `npm run insights-push:force`)
-
-### Step 5: Report
-
-```markdown
-## Config Squad Complete
-
-### Helga (Workflow Config)
-- Workflows: [created/modified]
-- Fields: [count]
-- Phases: [count]
-- Commands run: [list]
-
-### Alejandro (Function Fields)
-- Function fields: [list with formulas]
-- Name function: [pattern]
-- Skipped: [reason if skipped]
-
-### Viktor (Insights)
-- Insights: [list with descriptions]
-- Skipped: [reason if skipped]
-
-### Workspace State
-Run `npm run pull` to ensure workspace/ is up to date.
-```
-
-## Notes
-
-- Each agent in the pipeline needs IDs from the previous step. Always `npm run pull` between steps.
-- Helga auto-spawns Alejandro for nameFunction - check her output before spawning Alejandro again.
-- Viktor needs real field IDs for SQL queries - never let him guess.

package/.claude/commands/crud-squad.md

@@ -1,87 +0,0 @@
----
-description: Create, update, or manage activities with Kenji and Dmitri
-argument-hint: "what to create/update and in which workflow"
-allowed-tools: Task, Bash, Read
----
-# CRUD Squad
-
-Sequential pipeline: Discover schema, execute CRUD operations, verify results.
-
-**Agents:**
-1. **Kenji** - Schema discovery + pre-read existing data
-2. **Dmitri** - Create/update activities
-3. **Kenji** - Verify results (count/list after changes)
-
-**Goal:** $ARGUMENTS
-
-## Protocol
-
-### Step 1: Kenji (Schema Discovery + Pre-Read)
-
-Discover workflow schema and existing data relevant to the task:
-
-```
-Task(subagent_type="agent-kenji-data-reader", prompt="For this task: $ARGUMENTS\n\n1. List the relevant workflow(s) with field IDs, types, and dropdown/enum options\n2. List phases and their IDs\n3. If updating existing activities: list the activities that match (include their IDs)\n4. If creating new activities: show a sample existing activity so we know the expected field format")
-```
-
-Wait for result. This gives Dmitri the real IDs and field formats.
-
-### Step 2: Dmitri (Create/Update Activities)
-
-Spawn Dmitri with full schema context from Kenji:
-
-```
-Task(subagent_type="agent-dmitri-activity-crud", prompt="Task: $ARGUMENTS\n\nWorkflow schema from Kenji:\n[PASTE KENJI'S OUTPUT - workflow ID, field IDs, types, phase IDs, enum options]\n\n[IF UPDATING: Target activities:\nPASTE ACTIVITY IDs AND CURRENT VALUES]\n\nExecute the CRUD operations using the correct field IDs and value formats.")
-```
-
-Wait for result. Check for errors - if Dmitri reports validation failures, review field formats and retry once.
-
-### Step 3: Kenji (Verify Results)
-
-Skip if `--skip-verify` flag is set.
-
-Verify the operations succeeded:
-
-```
-Task(subagent_type="agent-kenji-data-reader", prompt="Verify CRUD operations for: $ARGUMENTS\n\nExpected changes:\n[PASTE DMITRI'S OUTPUT - created/updated activity IDs]\n\nCount activities in the workflow and list the recently created/modified ones to confirm they exist with correct values.")
-```
-
-### Step 4: Report
-
-```markdown
-## CRUD Squad Complete
-
-### Kenji (Schema Discovery)
-- Workflow: [name] ([id])
-- Fields mapped: [count]
-- Existing activities found: [count or "N/A"]
-
-### Dmitri (CRUD Operations)
-- Created: [count] activities
-- Updated: [count] activities
-- Errors: [count or "none"]
-
-### Kenji (Verification)
-- Activities confirmed: [count]
-- Discrepancies: [list or "none"]
-
-### Summary
-[Brief description of what was done]
-```
-
-## Options
-
-| Flag | Effect |
-|------|--------|
-| `--skip-verify` | Skip verification Kenji (trust Dmitri's response) |
-| `--skip-discovery` | Skip schema discovery (when you already know the workflow schema) |
-| `--dry-run` | Run Kenji discovery only, show what Dmitri would do, but don't execute |
-
-## Difference from Direct Dmitri
-
-| | Direct Dmitri | CRUD Squad |
-|---|---|---|
-| **Schema context** | You must provide IDs manually | Kenji discovers IDs automatically |
-| **Verification** | Trust Dmitri's response | Kenji independently verifies |
-| **Bulk ops** | Single prompt | Discovery → execute → verify pipeline |
-| **Use when** | You already know exact IDs and format | "Create 5 customers" or "Update all overdue tasks" |

package/.claude/commands/data-squad.md

@@ -1,97 +0,0 @@
----
-description: Build reports with Kenji, Alejandro, and Viktor
-argument-hint: "report/dashboard description"
-allowed-tools: Task, Bash, Read
----
-# Data Squad
-
-Sequential pipeline: Discover schema, create calculated fields if needed, then build insights.
-
-**Agents:**
-1. **Kenji** - Schema discovery (workflow fields, types, IDs)
-2. **Alejandro** - Function fields (if calculated values needed)
-3. **Viktor** - SQL insights (queries, aggregations, reports)
-
-**Goal:** $ARGUMENTS
-
-## Protocol
-
-### Step 1: Kenji (Schema Discovery)
-
-Always start with Kenji to get real IDs and field types:
-
-```
-Task(subagent_type="agent-kenji-data-reader", prompt="List all workflows and their fields relevant to: $ARGUMENTS. Include field IDs, types, and dropdown options. Also list existing insights if any.")
-```
-
-Wait for result. This gives Viktor and Alejandro the real IDs they need.
-
-### Step 2: Check if Function Fields Needed
-
-Review Kenji's output. Alejandro is needed when:
-- The report needs **calculated values** not already in the schema (totals, percentages, date diffs)
-- An existing function field needs modification
-- A **nameFunction** is missing or needs updating
-
-If no calculated fields needed, skip to Step 3.
-
-If needed, spawn Alejandro:
-
-```
-Task(subagent_type="agent-alejandro-function-fields", prompt="Create function fields for: $ARGUMENTS.\n\nWorkflow schema from Kenji:\n[PASTE KENJI'S OUTPUT - workflow IDs, field IDs, types]\n\nCreate the calculated fields needed for this report.")
-```
-
-Wait for result. If `"status": "ready_to_push"`:
-- Run the push commands
-- Run `npm run pull` to get new field IDs
-
-### Step 3: Viktor (SQL Insights)
-
-Spawn Viktor with full schema context:
-
-```
-Task(subagent_type="agent-viktor-sql-insights", prompt="Create insights for: $ARGUMENTS.\n\nWorkflow schema:\n[Kenji found these workflows and fields: SUMMARIZE KENJI'S RESULT.]\n\n[IF ALEJANDRO RAN: Alejandro created these function fields: SUMMARIZE ALEJANDRO'S RESULT.]\n\nBuild SQL queries with correct field IDs. Never guess IDs.")
-```
-
-Wait for result. If `"status": "ready_to_push"`:
-- Run the push commands (e.g., `npm run insights-push:force`)
-
-### Step 4: Report
-
-```markdown
-## Data Squad Complete
-
-### Kenji (Schema Discovery)
-- Workflows found: [list]
-- Fields mapped: [count]
-- Existing insights: [list or "none"]
-
-### Alejandro (Function Fields)
-- Created: [list with formulas]
-- Skipped: [reason if not needed]
-
-### Viktor (Insights)
-- Insights created: [list]
-- Query summary: [brief description of each]
-- Public: [yes/no for each]
-
-### Next Steps
-- Preview insights in Hailer
-- Use insights as data source for apps (if needed)
-```
-
-## Options
-
-| Flag | Effect |
-|------|--------|
-| `--skip-functions` | Skip Alejandro (when function fields not needed) |
-| `--skip-insights` | Skip Viktor (when insights not needed) |
-
-## Difference from Config Squad
-
-| | Config Squad | Data Squad |
-|---|---|---|
-| **Starting point** | New workflow needed | Workflow already exists |
-| **First agent** | Helga (create workflow) | Kenji (read existing schema) |
-| **Focus** | Infrastructure setup | Reporting and analytics |
-| **Use when** | "Create a Tasks workflow with..." | "Build a report showing..." |

package/.claude/commands/debug-squad.md

@@ -1,303 +0,0 @@
----
-description: Parallel investigation squad for diagnosing bugs and incidents
-argument-hint: "bug or incident description"
-allowed-tools: Task, Bash, Read
----
-
-# Debug Squad
-
-Parallel investigation squad: diagnose bugs by examining data state, query patterns, code logic, and test reproduction simultaneously.
-
-**Agents:**
-- **Kenji** - Data state (check relevant activities, field values, phases, linked records)
-- **Viktor** - Query patterns (is this isolated or widespread? run insights to find anomalies)
-- **Svetlana** - Code review (logic errors, missing validations, race conditions)
-- **Tanya** - Test reproduction (create failing test to isolate the bug)
-
-**Goal:** $ARGUMENTS
-
-## Protocol
-
-### Step 1: Parse Bug Description
-
-Extract from `$ARGUMENTS`:
-- What is the reported issue?
-- Which workflow/activities/features are affected?
-- When was it first noticed?
-- What's the impact (severity)?
-
-Set `iteration = 1` and `max_iterations = 2`.
-
-### Step 2: Launch All 4 Agents in Parallel
-
-Spawn all agents simultaneously using multiple Task tool calls in a single message:
-
-**Kenji (Data State):**
-```
-Task(subagent_type="agent-kenji-data-reader", prompt="Investigate the data state for this bug: $ARGUMENTS.\n\nYour job:\n1. Identify the affected workflow(s) and activities\n2. Look up the relevant activity records, field values, phases\n3. Check linked activities and relationships\n4. Compare expected vs actual data state\n5. Report any anomalies, missing data, or unexpected values\n\nReturn:\n- What the data SHOULD look like\n- What it ACTUALLY looks like\n- Which fields/relationships are affected")
-```
-
-**Viktor (Query Patterns):**
-```
-Task(subagent_type="agent-viktor-sql-insights", prompt="Find patterns for this bug: $ARGUMENTS.\n\nYour job:\n1. Run insight queries to determine: is this isolated to one activity or widespread?\n2. Query for similar data anomalies across the workflow\n3. Look for patterns: does it affect specific phases, teams, date ranges, field values?\n4. Check for recent changes that could correlate with the bug\n\nReturn:\n- Is this isolated or widespread? (scope)\n- Pattern: what data characteristics trigger it?\n- How many records/activities affected?\n- Timeline: when did anomalies start appearing?")
-```
-
-**Svetlana (Code Review):**
-```
-Task(subagent_type="agent-svetlana-code-review", prompt="Review the code for this bug: $ARGUMENTS.\n\nYour job:\n1. Identify the relevant code sections (workflow logic, activity creation, field updates, phase transitions)\n2. Inspect for logic errors, missing validations, race conditions, null checks\n3. Look for assumptions that might break in edge cases\n4. Check for recent changes that could have introduced the bug\n\nReturn:\n- Suspected code sections with issues\n- Specific logic problems (race conditions, wrong field access, missing validation)\n- Edge cases not handled\n- Security implications if any")
-```
-
-**Tanya (Test Reproduction):**
-```
-Task(subagent_type="agent-tanya-test-runner", prompt="Create a failing test for this bug: $ARGUMENTS.\n\nYour job:\n1. Write a minimal test that reproduces the bug\n2. Set up the preconditions (data state, workflow, etc)\n3. Execute the action that triggers the bug\n4. Assert the bug is present (test FAILS with current code)\n5. Do NOT fix the bug - just demonstrate it\n\nReturn:\n- The failing test code\n- What the test proves about the bug\n- Failure output showing the bug is real")
-```
-
-If `$ARGUMENTS` contains `--skip-data`, skip Kenji.
-If `$ARGUMENTS` contains `--skip-queries`, skip Viktor.
-
-### Step 3: Collect Results and Synthesize Root Cause
-
-Wait for all agents to complete. Aggregate findings:
-
-**From Kenji:** What data is wrong?
-**From Viktor:** How widespread is it? What pattern triggers it?
-**From Svetlana:** What code is broken?
-**From Tanya:** Can we reproduce it consistently?
-
-Look for convergence:
-- Does data anomaly match code logic error?
-- Does Svetlana's suspected code section align with Viktor's pattern?
-- Does Tanya's test reproduce the exact issue Kenji found?
-
-If **clear root cause** emerges → proceed to Step 4 (report).
-
-If **inconclusive** (no agent found clear cause OR agents disagree):
-- If `iteration < max_iterations`: Increment `iteration`, go to **Step 2b** (narrow scope)
-- If `iteration >= max_iterations`: Proceed to Step 4 with partial findings
-
-### Step 2b: Re-Investigation (Narrowed Scope)
-
-If first iteration was inconclusive, re-run agents with narrowed focus:
-
-```
-Task(subagent_type="agent-kenji-data-reader", prompt="Re-investigate (iteration [iteration]): $ARGUMENTS\n\nBased on initial findings:\n[SUMMARIZE WHAT FIRST PASS FOUND]\n\nNarrow your focus to: [MOST LIKELY AFFECTED AREA]\n\nDig deeper into the data state. Look for subtle issues.")
-```
-
-Similar narrowed prompts for Viktor, Svetlana, Tanya.
-
-### Step 4: Report
-
-```markdown
-## Debug Squad Investigation
-
-### Summary
-**Bug:** [Description]
-**Iterations:** [count] of [max_iterations]
-**Root Cause Status:** IDENTIFIED / INCONCLUSIVE
-
----
-
-### Kenji (Data State)
-**Affected Records:** [count/scope]
-- Expected state: [description]
-- Actual state: [description]
-- Anomalies found: [list]
-
-### Viktor (Query Patterns)
-**Scope:** Isolated / Widespread (X records affected)
-**Pattern:** [What triggers the bug]
-**Timeline:** [When did it start]
-- Similar anomalies detected: [yes/no, details]
-
-### Svetlana (Code Review)
-**Suspected Code:** [files and line numbers]
-**Issues Found:**
-- [Issue 1]: [file:line] - [description]
-- [Issue 2]: [file:line] - [description]
-**Risk Level:** [LOW/MEDIUM/HIGH]
-
-### Tanya (Reproduction)
-**Test Status:** CREATED / FAILED TO REPRODUCE
-**Reproducibility:** Consistent / Intermittent / Cannot reproduce
-- Test file: [path]
-- Failure output: [snippet]
-
----
-
-### Root Cause Analysis
-[Synthesize findings from all 4 agents]
-
-**Primary Cause:** [What's broken]
-**Contributing Factors:** [Secondary issues]
-**Why It Happens:** [Mechanism]
-
-### Recommended Fix
-[Based on root cause, what needs to be fixed]
-- File: [path]
-- Change: [description]
-- Rationale: [why this fixes it]
-
-### Next Steps
-1. [Fix applied by Svetlana/Simple Writer]
-2. [Test to verify fix]
-3. [Deploy and monitor]
-```
-
-If any agent fails or times out, report partial results, note which failed, and offer to re-run individually.
-
-## Options
-
-| Flag | Effect |
-|------|--------|
-| `--skip-data` | Skip Kenji (when data investigation not needed) |
-| `--skip-queries` | Skip Viktor (when pattern analysis not needed) |
-| `--bg` | Run all agents in background mode |
-| `--debate` | Debate mode: competing hypotheses instead of domain-split investigation |
-
-If `--bg` is present, launch all agents with `run_in_background: true` and tell the user they'll be notified when complete.
-
----
-
-## Debate Mode (`--debate`)
-
-When `--debate` flag is present, the squad switches from domain-split investigation to **competing hypothesis investigation**. Instead of each agent checking their domain, agents are assigned competing theories and must find evidence for/against their hypothesis.
-
-### How It Differs from Normal Mode
-
-| Aspect | Normal Mode | Debate Mode |
-|--------|-------------|-------------|
-| Assignment | Each agent checks their domain (data, queries, code, tests) | Each agent investigates a specific hypothesis |
-| Evidence | Agents report what they find in their area | Agents argue FOR their hypothesis using any evidence |
-| Synthesis | Look for convergence across domains | Compare evidence strength, pick winner |
-| Best for | Well-scoped bugs with clear domain | Ambiguous problems with multiple plausible causes |
-
-### Debate Protocol
-
-**Replaces Steps 2-3 of the normal protocol.**
-
-#### Step D1: Generate Hypotheses
-
-Analyze the problem description and generate **2-3 competing hypotheses** about the root cause. Each hypothesis should be:
-- **Specific**: Not "something is wrong" but "the phase transition hook doesn't fire when..."
-- **Testable**: An agent can find evidence for or against it
-- **Distinct**: Hypotheses should point to genuinely different root causes
-
-Example for "Orders aren't syncing to Netvisor":
-- H1: "The activity mover trigger condition is wrong - it fires on the wrong phase"
-- H2: "The Netvisor API integration is failing silently - auth or payload issue"
-- H3: "The data is incomplete - required fields for Netvisor export are missing"
-
-If user provided their own hypotheses in `$ARGUMENTS`, use those instead of generating.
-
-#### Step D2: Assign Agents to Hypotheses
-
-Pick the best-fit agent for each hypothesis:
-
-| Hypothesis Type | Best Agent |
-|----------------|-----------|
-| Data integrity / missing values | **Kenji** |
-| Query / pattern / scope issue | **Viktor** |
-| Code logic / validation / race condition | **Svetlana** |
-| Reproducibility / environment | **Tanya** |
-| External integration / API | **Ivan** (monolith) or **Web Search** (research) |
-| Activity mover / phase cascade | **Igor** |
-| Zapier integration / external sync | **Zara** |
-
-Each agent gets:
-- The full problem description
-- Their assigned hypothesis
-- Instruction: "Find evidence that supports OR refutes this hypothesis. Be honest - if evidence points away from your hypothesis, report that."
-
-```
-Task(subagent_type="[best-fit-agent]", prompt="DEBATE MODE investigation for: $ARGUMENTS
-
-YOUR HYPOTHESIS: [H1 description]
-
-Your job is to investigate whether this hypothesis explains the bug. Be thorough and honest:
-
-1. What evidence SUPPORTS this hypothesis?
-2. What evidence REFUTES this hypothesis?
-3. Confidence level: STRONG / MODERATE / WEAK
-4. If your hypothesis is wrong, what does the evidence actually point to?
-
-Do NOT assume your hypothesis is correct. Follow the evidence.")
-```
-
-Launch all hypothesis agents in parallel.
-
-#### Step D3: Score and Synthesize
-
-Collect results. For each hypothesis, assess:
-
-| Hypothesis | Supporting Evidence | Refuting Evidence | Confidence | Agent |
-|-----------|-------------------|-------------------|------------|-------|
-| H1 | [list] | [list] | STRONG/MODERATE/WEAK | [agent] |
-| H2 | [list] | [list] | STRONG/MODERATE/WEAK | [agent] |
-| H3 | [list] | [list] | STRONG/MODERATE/WEAK | [agent] |
-
-**Verdict rules:**
-- If one hypothesis has STRONG confidence and others are WEAK → **clear winner**
-- If multiple have MODERATE+ confidence → **compound issue** (multiple causes)
-- If all are WEAK → **inconclusive**, escalate to user with what was learned
-
-#### Step D4: Debate Report
-
-```markdown
-## Debug Squad Investigation (Debate Mode)
-
-### Problem
-[Description]
-
-### Hypotheses Tested
-
-#### H1: [Hypothesis description]
-**Assigned to:** [Agent name]
-**Confidence:** STRONG / MODERATE / WEAK
-**Supporting evidence:**
-- [Evidence 1]
-- [Evidence 2]
-**Refuting evidence:**
-- [Evidence 1]
-
-#### H2: [Hypothesis description]
-...
-
-#### H3: [Hypothesis description]
-...
-
----
-
-### Verdict
-**Winner:** H[N] - [hypothesis description]
-**Confidence:** [STRONG/MODERATE/WEAK]
-
-[If compound:] **Multiple causes identified:**
-1. H[X]: [description] (MODERATE confidence)
-2. H[Y]: [description] (MODERATE confidence)
-
-[If inconclusive:] **No clear root cause found.** Most promising lead: H[N].
-
-### Dissenting Evidence
-[Evidence that doesn't fit the winning hypothesis - important to surface]
-
-### Recommended Fix
-[Based on winning hypothesis]
-
-### Next Steps
-1. [Fix the identified cause]
-2. [Verify dissenting evidence doesn't indicate a secondary issue]
-3. [Run /hotfix-squad if fix is straightforward]
-```
-
----
-
-## Notes
-
-- Parallel execution: all agents run simultaneously for speed
-- Max 2 iterations prevents infinite loops while allowing scope refinement
-- Convergence is key: when 3+ agents point to the same root cause, confidence is high
-- Each re-investigation iteration gets narrowed scope from first pass results
-- Report synthesizes findings, not just concatenates them
-- **Debate mode** costs more tokens (2-3 full agent calls) but excels at ambiguous, hard-to-diagnose problems
-- Debate agents are told to be honest about refuting evidence - this prevents confirmation bias
-- Users can supply their own hypotheses to test specific theories