Brutal Deepresearch

Structured deep research pipeline with confirmation gates and resume support. Generates research outline from model knowledge + web search, launches parallel research agents, produces validated JSON results per item, and generates a markdown report. Supports resuming interrupted sessions.

Agent assumptions (applies to all agents and subagents):

• All tools are functional and will work without error. Do not test tools or make exploratory calls.
• Only call a tool if it is required to complete the task. Every tool call should have a clear purpose.

Brutal Deep Research Process

User Input Rounds

Before requesting user input, gather every currently known, relevant, independent question for the current stage and ask them together. Two questions are independent only when neither answer can change the other's necessity, wording, or options. Ask dependent questions in the next round.

Use AskUserQuestion when it is available, the whole round has at most three questions, and each question has 2-3 mutually exclusive options. If the tool is unavailable or the round does not fit, use one numbered message and request a compact reply such as 1B 2A 3: custom answer.

Recommend one answer for each decision question: one option for single-choice input or one set for multi-select input. Give a default or example, not an invented recommendation, for open-ended fact collection.

Step 0: Load Context & Session Setup

0.1 Load Project Target Context

Check for TARGET.md in the project root directory.

• If TARGET.md exists, read it in full and treat it as required context.
• Do not proceed to Step 1 until this check/read has been completed.

0.2 Get Current Date

date +%Y-%m-%d

0.3 Determine Next DR Number

Find the highest existing DR number:

ls workspace/research/ 2>/dev/null | grep -oE '[0-9]{4}' | sort -rn | head -1

New DR number = highest + 1. If no research sessions exist, start at 0001.

0.4 Generate Session Slug

Generate a slug from the research topic:

• Lowercase
• Replace spaces and special characters with hyphens
• Max 40 characters
• Remove trailing hyphens

Session directory: workspace/research/DR-<NNNN>-<slug>/

Do not create the directory yet. Wait until Gate 2 confirmation.

Step 0.5: Resume Mode (Conditional)

Trigger: User args contain the word "resume" and a path to an existing session directory.

Example invocation: /brutal-deepresearch resume research workspace/research/DR-0001-ai-coding

If resume mode is NOT detected, skip to Step 1.

0.5.1 Read Existing Session

1. Read outline.yaml from the given session path to get items list
2. Read fields.yaml from the given session path to get field definitions
3. Read progress.yaml (if it exists) for previous execution context

0.5.2 Check Completed Results

ls <session_path>/results/*.json 2>/dev/null
ls <session_path>/results/*.started 2>/dev/null

Determine item status:

• .json exists → completed (skip this item)
• .started exists but no .json → interrupted (re-research this item)
• Neither exists → never started (research this item)

0.5.3 Calculate Remaining Items

Compare items in outline.yaml against completed results:

• Log which items are completed and will be skipped
• Log which items were interrupted and will be re-researched
• Log which items never started and will be researched

0.5.4 Branch to Execution or Report

• If remaining items exist: Skip directly to Step 6 (Execute Deep Research), launching agents only for remaining items
• If all items are complete: Report "All items already completed" and skip directly to Step 7 (Report Configuration)

Resume mode skips Steps 1-4 entirely — the outline and fields are already confirmed from the previous session.

Step 1: Generate Initial Framework

Based on the user's research topic, use model knowledge to generate:

1. Items List: The main research objects/items in this domain. Each item should have:

   • name: Item name
   • category: Classification (if applicable)
   • description: Brief description of why this item is relevant

2. Field Framework: Suggested research field categories and fields per category. Each field should have:

   • name: Field name (snake_case)
   • description: What this field captures
   • detail_level: One of brief, moderate, or detailed

Present the framework to the user in a readable format.

Step 2 - GATE 1: Confirm Initial Framework

This is a hard gate. Do not proceed past this step without explicit user confirmation.

Present:

• The items list with names, categories, and descriptions
• The field framework organized by category

Ask in one numbered message:

1. Whether the items and fields are correct, including any additions or removals
2. Which supplemental-search freshness filter to use: last 6 months, since 2024, since 2025, or unlimited. This filter does not change initial framework membership.

Hard gate: Do not proceed until the user confirms item 1 and selects item 2. Preserve each answered item and re-ask only an omitted item. While applying framework revisions, retain item 2, re-present the revised framework, and ask only item 1 again unless the user changes the time range.

Step 3: Web Search Supplement

3.1 Use Time Range

Use the time range captured at Gate 1. Do not ask for it again.

3.2 Launch Web Search Agent

Launch 1 web-search-agent (background) using the Task tool with model: sonnet and max_turns: 20.

Parameter Retrieval:

• {topic}: User's research topic
• {YYYY-MM-DD}: Current date from Step 0.2
• {step1_output}: Complete output from Step 1 (items list + field framework)
• {time_range}: User-specified time range

Hard Constraint: The following prompt must be strictly reproduced, only replacing variables in {xxx}. Do not modify structure or wording.

Prompt Template:

You are an elite internet researcher. Your task is to supplement an existing research framework with missing items and recommended fields.

## Research Methodology

Before searching, determine which search strategies apply to this topic. Use the appropriate strategies from the Search Strategy Reference below.

Get today's date first:
date +%Y-%m-%d

Generate 5-10 different search query variations to maximize coverage:
- Include technical terms, product names, and common variations
- Think of how different people might describe the same topic
- Use exact phrases in quotes for specific names
- Include version numbers and dates when relevant

## Information Gathering Standards
- Read beyond the first few results - valuable information is often buried
- Look for patterns across different sources
- Pay attention to dates to ensure relevance
- Note different approaches and their trade-offs
- Identify authoritative sources and experienced contributors
- Check for updated information or superseded approaches
- Verify across multiple sources when possible

## Task
Research topic: {topic}
Current date: {YYYY-MM-DD}

Based on the following initial framework, supplement latest items and recommended research fields.

## Existing Framework
{step1_output}

## Goals
1. Verify if existing items are missing important objects
2. Supplement items based on missing objects
3. Continue searching for {topic} related items within {time_range} and supplement
4. Supplement new fields

## Output Requirements
Return structured results directly (do not write files):

### Supplementary Items
- item_name: Brief explanation (why it should be added)
...

### Recommended Supplementary Fields
- field_name: Field description (why this dimension is needed)
...

### Sources
- [Source1](url1)
- [Source2](url2)

One-shot Example (assuming researching AI Coding History):

## Task
Research topic: AI Coding History
Current date: 2025-12-30

Based on the following initial framework, supplement latest items and recommended research fields.

## Existing Framework
### Items List
1. GitHub Copilot: Developed by Microsoft/GitHub, first mainstream AI coding assistant
2. Cursor: AI-first IDE, based on VSCode
...

### Field Framework
- Basic Info: name, release_date, company
- Technical Features: underlying_model, context_window
...

## Goals
1. Verify if existing items are missing important objects
2. Supplement items based on missing objects
3. Continue searching for AI Coding History related items within since 2024 and supplement
4. Supplement new fields

## Output Requirements
Return structured results directly (do not write files):

### Supplementary Items
- item_name: Brief explanation (why it should be added)
...

### Recommended Supplementary Fields
- field_name: Field description (why this dimension is needed)
...

### Sources
- [Source1](url1)
- [Source2](url2)

3.3 Merge Findings

After the web search agent completes, merge its findings with the initial framework:

• Add supplementary items to the items list (avoid duplicates)
• Add recommended fields to the field framework
• Note sources for traceability

Step 4 - GATE 2: Confirm Final Outline

This is a hard gate. Do not proceed past this step without explicit user confirmation.

Present the merged outline:

• Complete items list (original + web search additions, clearly marked)
• Complete field framework (original + web search additions, clearly marked)

Use AskUserQuestion to confirm the outline is correct.

Add-Items/Add-Fields Loop

User can say "add X item" or "add Y field" at this gate. If they do:

1. Add the requested item/field to the framework
2. Re-present the updated framework
3. Ask for confirmation again

Repeat until user explicitly confirms. Do not generate files until confirmed.

4.1 Create Session Directory and Write Files

After confirmation:

mkdir -p workspace/research/DR-<NNNN>-<slug>/results

Write outline.yaml:

topic: "<research topic>"
session: "DR-<NNNN>-<slug>"
created: "<YYYY-MM-DD>"
items:
  - name: "<item name>"
    category: "<category>"
    description: "<description>"
  # ... more items
output_dir: "./results"

Write fields.yaml:

categories:
  <category_name>:
    fields:
      - name: "<field_name>"
        description: "<field description>"
        detail_level: "<brief|moderate|detailed>"
      # ... more fields
  # ... more categories

Step 5: Deep Research - Preparation

5.1 Read Outline

Read workspace/research/DR-<NNNN>-<slug>/outline.yaml to get items list.

5.2 Resume Check

Check for completed and in-progress results in results/:

ls workspace/research/DR-<NNNN>-<slug>/results/*.json 2>/dev/null
ls workspace/research/DR-<NNNN>-<slug>/results/*.started 2>/dev/null

Determine item status:

• .json exists → completed (skip this item)
• .started exists but no .json → interrupted (re-research this item)
• Neither exists → never started (research this item)

Log which items are being resumed vs skipped. Update progress.yaml (if it exists) with the current state before proceeding.

5.3 Prepare Execution Plan

Calculate:

• Total remaining items (after subtracting completed and in-progress items)
• Display which items will be researched and which are being skipped

Step 6: Execute Deep Research

6.1 Launch Research Agents

Launch remaining agents using the Task tool with model: sonnet, run_in_background: true, and max_turns: 25.

Batching strategy based on remaining item count:

• 10 or fewer items: Launch ALL agents in a single parallel batch.
• More than 10 items: Split into batches of 10. Launch each batch in parallel, wait for the batch to complete (using filesystem polling per 6.4), then launch the next batch. No inter-batch user approval needed — batching is automatic.

Each agent researches one item and outputs JSON for that item.

Agent Prompt Template (per item):

Hard Constraint: The following prompt must be strictly reproduced, only replacing variables in {xxx}. Do not modify structure or wording.

You are an elite internet researcher specializing in finding relevant information across diverse online sources. Your expertise lies in creative search strategies, thorough investigation, and comprehensive compilation of findings.

## Progress Tracking

Before starting research, write a marker file to signal that this agent has started:
Write an empty file to {started_path}

After self-validation passes and the JSON result is confirmed correct, delete the marker file:
rm {started_path}

## Research Methodology

Get today's date first:
date +%Y-%m-%d

Generate 5-10 different search query variations to maximize coverage:
- Include technical terms, product names, and common variations
- Think of how different people might describe the same topic
- Use exact phrases in quotes for specific names
- Include version numbers and dates when relevant

### Search Strategy Reference

Use the following search strategies based on what is relevant to the research topic:

**GitHub/Debug Strategy** (for software, tools, technical projects):
- Search GitHub Issues (open and closed) for known bugs and workarounds
- Search for exact error messages in quotes
- Look for issue templates that match the problem pattern
- Check closed issues for resolution patterns
- Identify version-specific issues

**General Web Strategy** (for broad information gathering):
Sources: Reddit, official documentation, blog posts, Hacker News, Dev.to, Medium, Discord, X/Twitter
- Look for official recommendations first
- Cross-reference with community consensus
- Find examples from production use
- Identify anti-patterns and common pitfalls
- Note evolving best practices
- Create structured comparisons with clear criteria
- Find real-world usage examples and case studies
- Look for performance benchmarks and user experiences

**Academic Papers Strategy** (for research, algorithms, scientific topics):
Sources: Google Scholar, arXiv, Hugging Face Papers, bioRxiv, ResearchGate, Semantic Scholar, ACM Digital Library, IEEE Xplore
- Use Google Scholar as primary source with advanced search operators
- Search by author names, paper titles, DOI numbers
- Include year ranges to find seminal works and recent publications
- Look for related papers and citation patterns
- Search for preprints on arXiv and bioRxiv
- Track citation networks to understand research evolution

**Stack Overflow Strategy** (for programming, APIs, implementation):
Sources: Stack Overflow, Stack Exchange, technical forums
- Search for exact error messages and API names
- Look for accepted answers and highly-voted alternatives
- Check for version-specific solutions

## Information Gathering Standards
- Read beyond the first few results - valuable information is often buried
- Look for patterns in solutions across different sources
- Pay attention to dates to ensure relevance (note if information is outdated)
- Note different approaches and their trade-offs
- Identify authoritative sources and experienced contributors
- Verify information across multiple sources when possible
- Clearly indicate when information is speculative or unverified

## Task
Research {item_related_info}, output structured JSON to {output_path}

## Field Definitions
Read {fields_path} to get all field definitions

## Output Requirements
1. Output JSON according to fields defined in fields.yaml
2. Mark uncertain field values with [uncertain]
3. Add uncertain array at the end of JSON, listing all uncertain field names
4. All field values must be in English

## Self-Validation
After writing the JSON file, read it back and verify:
1. Every field defined in fields.yaml has a corresponding entry in the JSON
2. The JSON is valid (properly formatted)
3. All uncertain fields are listed in the uncertain array
If validation fails, fix the JSON and re-write it.

## Output Path
{output_path}

One-shot Example (assuming researching GitHub Copilot):

## Progress Tracking

Before starting research, write a marker file to signal that this agent has started:
Write an empty file to <research_root>/DR-0001-ai-coding/results/GitHub_Copilot.started

After self-validation passes and the JSON result is confirmed correct, delete the marker file:
rm <research_root>/DR-0001-ai-coding/results/GitHub_Copilot.started

## Task
Research name: GitHub Copilot
category: International Product
description: Developed by Microsoft/GitHub, first mainstream AI coding assistant, ~40% market share, output structured JSON to <research_root>/DR-0001-ai-coding/results/GitHub_Copilot.json

## Field Definitions
Read <research_root>/DR-0001-ai-coding/fields.yaml to get all field definitions

## Output Requirements
1. Output JSON according to fields defined in fields.yaml
2. Mark uncertain field values with [uncertain]
3. Add uncertain array at the end of JSON, listing all uncertain field names
4. All field values must be in English

## Self-Validation
After writing the JSON file, read it back and verify:
1. Every field defined in fields.yaml has a corresponding entry in the JSON
2. The JSON is valid (properly formatted)
3. All uncertain fields are listed in the uncertain array
If validation fails, fix the JSON and re-write it.

## Output Path
<research_root>/DR-0001-ai-coding/results/GitHub_Copilot.json

6.2 Parameter Construction

For each item being researched:

• {item_related_info}: The item's complete YAML content (name + category + description)
• {output_path}: Absolute path to workspace/research/DR-<NNNN>-<slug>/results/<item_name_slug>.json
  • Slugify: replace spaces with _, remove special characters
• {fields_path}: Absolute path to workspace/research/DR-<NNNN>-<slug>/fields.yaml
• {started_path}: Absolute path to workspace/research/DR-<NNNN>-<slug>/results/<item_name_slug>.started

6.3 Write progress.yaml

Immediately after launching all agents, write progress.yaml in the session directory:

status: in_progress
started: "<YYYY-MM-DD HH:MM>"
total_items: <N>
items:
  - name: "<Item Name>"
    slug: "<Item_Name>"
    status: pending
  # ... all items being researched

Items that were already completed (skipped) should not be listed — only items that agents were launched for.

6.4 Monitor Progress (Filesystem-Based)

CRITICAL: Do NOT use TaskOutput to read agent results. Agent outputs are large (extensive web search transcripts) and reading them into the orchestrator context will cause context window exhaustion. All research results are already persisted to disk as JSON files — the orchestrator only needs to check file existence.

Polling loop — repeat until all items are resolved:

1. Check completion status via filesystem:

   ls <session_path>/results/*.json 2>/dev/null | wc -l
   ls <session_path>/results/*.started 2>/dev/null | wc -l
   

2. Calculate: completed = count of .json files, in_progress = count of .started files without matching .json, remaining = total - completed
3. Display progress: "Progress: X/Y items completed, Z still running."
4. If in_progress > 0, wait ~30 seconds (use sleep 30 via Bash) then poll again
5. If in_progress == 0 (all agents have finished — either produced .json or exited), exit the loop

After polling loop completes:

1. Update progress.yaml:
   • Set each item's status to completed if its .json file exists, or failed if only .started exists or neither exists
   • Set overall status to completed if all items done, or partial if some are missing
2. Report final status: "All agents complete. X/Y items researched successfully."
3. If any items failed, list them and suggest using resume mode to retry

Step 7: Report Configuration

7.1 Scan Summary Fields

Read all completed JSON results and identify fields suitable for TOC display:

• Numeric fields (stars, scores, citations)
• Short metric fields (dates, versions, ratings)
• Fields that appear across most/all items

7.2 Present Options

Present a dynamic options list based on actual fields found in the JSON results.

Step 7.5 - GATE 3: Confirm Report Config

This is a hard gate. Do not proceed past this step without explicit user confirmation.

Present the available fields as a numbered list and ask which field numbers to display in the TOC alongside item names. This is a multi-select question, so use the numbered-message fallback and include one recommended field set.

Hard gate: Do not generate report until user confirms field selection.

Step 8: Generate Report

8.1 Generate Report Script

Generate generate_report.py in the session directory.

The script must handle:

1. JSON Structure Compatibility

Support two JSON structures:

• Flat structure: Fields directly at top level {"name": "xxx", "release_date": "xxx"}
• Nested structure: Fields in category sub-dict {"basic_info": {"name": "xxx"}, "technical_features": {...}}

Field lookup order: Top level -> category mapping key -> Traverse all nested dicts

2. Category Mapping

Map between fields.yaml category names and JSON keys:

CATEGORY_MAPPING = {
    "Basic Info": ["basic_info", "Basic Info"],
    "Technical Features": ["technical_features", "technical_characteristics", "Technical Features"],
    "Performance Metrics": ["performance_metrics", "performance", "Performance Metrics"],
    "Milestone Significance": ["milestone_significance", "milestones", "Milestone Significance"],
    "Business Info": ["business_info", "commercial_info", "Business Info"],
    "Competition & Ecosystem": ["competition_ecosystem", "competition", "Competition & Ecosystem"],
    "History": ["history", "History"],
    "Market Positioning": ["market_positioning", "market", "Market Positioning"],
}

3. Complex Value Formatting

• List of dicts (e.g., key_events, funding_history): Format each dict as one line, separate kv with |
• Normal list: Short lists joined with comma, long lists displayed with line breaks
• Nested dict: Recursive formatting, display with semicolon or line breaks
• Long text strings (over 100 chars): Add line breaks <br> or use blockquote format for readability

4. Extra Fields Collection

Collect fields that exist in JSON but not defined in fields.yaml, put in "Other Info" category. Filter out:

• Internal fields: _source_file, uncertain
• Nested structure top-level keys matching category names
• uncertain array: Display each field name on separate line

5. Uncertain Value Skipping

Skip conditions:

• Field value contains [uncertain] string
• Field name is in uncertain array
• Field value is None or empty string

6. Report Format

The generated report.md must have:

• Table of Contents: Every item with number, name (anchor link), and user-selected summary fields
  • Example: 1. [GitHub Copilot](#github-copilot) - Stars: 10k | Score: 85%
• Detailed Sections: One section per item, organized by field category
  • Each category as a subsection heading
  • Each field as a labeled entry

8.2 Execute Script

python workspace/research/DR-<NNNN>-<slug>/generate_report.py

Step 9: Present Summary

Present completion stats:

## Research Complete: <topic>

**Session**: workspace/research/DR-<NNNN>-<slug>/
**Items Researched**: <count>

### Output Files
- outline.yaml - Research outline and items list
- fields.yaml - Field definitions
- progress.yaml - Execution progress tracking
- results/ - JSON results per item (<count> files)
- generate_report.py - Report generation script
- report.md - Final markdown report

### Items with High Uncertainty
- <item name>: <count> uncertain fields
- ...

Search Strategy Reference

These strategies are used by research agents to systematically explore information sources.

GitHub Debug Strategy

Trigger: Software bugs, error debugging, issue lookup, version-specific problems

Sources: GitHub Issues (open and closed)

Query Strategy:

• Search for exact error messages in quotes
• Look for issue templates that match the problem pattern
• Find workarounds, not just explanations
• Check if it's a known bug with existing patches or PRs
• Look for similar issues even if not exact matches
• Identify if the issue is version-specific
• Search for both the library name + error and more general descriptions
• Check closed issues for resolution patterns

General Web Strategy

Trigger: General information, news, product comparisons, best practices

Sources:

• Reddit (r/programming, r/webdev, r/javascript, topic-specific subreddits) - real-world experiences
• Official documentation and changelogs - authoritative information
• Blog posts and tutorials - detailed explanations
• Hacker News - high-quality technical discourse
• Dev.to - developer community with technical articles
• Medium - technical blog platform with in-depth articles
• Discord - official discussion channels for open source projects
• X/Twitter - technical announcements and discussions from developers

Query Strategy:

• Look for official recommendations first
• Cross-reference with community consensus
• Find examples from production codebases
• Identify anti-patterns and common pitfalls
• Note evolving best practices and deprecated approaches
• Create structured comparisons with clear criteria
• Find real-world usage examples and case studies
• Look for performance benchmarks and user experiences
• Identify trade-offs and decision factors
• Consider scalability, maintenance, and learning curve

Academic Papers Strategy

Trigger: Paper search, academic research, algorithm fundamentals

Sources:

• Google Scholar (scholar.google.com) - comprehensive academic search engine
• arXiv (arxiv.org) - preprints in physics, math, CS, and related fields
• Hugging Face Papers (huggingface.co/papers) - trending ML/AI papers with community upvotes
• bioRxiv (biorxiv.org) - preprints in biology and life sciences
• ResearchGate (researchgate.net) - academic social network with papers and author profiles
• Semantic Scholar (semanticscholar.org) - AI-powered academic search
• ACM Digital Library and IEEE Xplore - CS and engineering papers

Query Strategy:

• Use Google Scholar as primary source with advanced search operators
• Search by author names, paper titles, DOI numbers, institutions, and publication years
• Use quotation marks for exact titles and author name combinations
• Include year ranges to find seminal works and recent publications
• Look for related papers and citation patterns to identify seminal works
• Search for preprints on arXiv, bioRxiv, and institutional repositories
• Check author profiles and ResearchGate for publications and PDFs
• Identify open-access versions and legal paper download sources
• Track citation networks to understand research evolution
• Note impact factors, h-index, and citation counts for relevance assessment
• Search for conference proceedings, journals, and workshop papers

Stack Overflow Strategy

Trigger: Programming Q&A, code implementation, API usage

Sources:

• Stack Overflow and other Stack Exchange sites - technical Q&A
• Technical forums and discussion boards - community wisdom

Query Strategy:

• Search for exact error messages and API signatures
• Look for accepted answers and highly-voted alternatives
• Check for version-specific solutions and deprecated approaches
• Cross-reference with official documentation
• Note common pitfalls mentioned in answers

Mindset

You are not here to rubber-stamp research topics. You are here to ensure comprehensive, structured, high-quality research output. Every gap you miss is a blind spot in the final report.

Be direct. Be thorough. Be systematic.

Do not:

• Accept vague topics without clarification
• Skip confirmation gates
• Launch research agents before user confirms the outline
• Generate files before Gate 2 confirmation
• Generate reports before Gate 3 confirmation
• Use TaskOutput to read research agent results (causes context exhaustion — use filesystem polling instead)
• Launch more than 10 agents simultaneously (use automatic batching for larger sets)

Do:

• Generate comprehensive initial frameworks from domain knowledge
• Supplement with web search to catch missing items
• Present clear, structured summaries at each gate
• Support add-items/add-fields within Gate 2
• Track uncertain values across all results
• Generate reproducible report scripts
• Track progress in progress.yaml throughout execution
• Write .started markers before each agent begins research
• Support resume from any interrupted state