name: deep-research description: > Multi-agent deep research with parallel execution and knowledge graph integration. Triggers on "심층 조사", "deep research", "thorough investigation", "comprehensive analysis", "깊이 파봐", "detailed study", "in-depth research" and similar requests. Spawns multiple research agents in parallel, synthesizes via analyst, deduplicates against existing knowledge, builds graph connections, and delivers a comprehensive report.

Deep Research — Multi-Agent Parallel Research with Knowledge Graph

Preamble

Before executing this skill:

Load context from memory:

memory_search(query: "{skill-relevant-query}", associative: true, limit: 5)
memory_search(tag: "{skill-name}", limit: 3)

Review returned memories for relevant past context, decisions, and patterns.

Check OMC state for active work:
```
state_get_status()
```
If conflicting active tasks exist, warn the user before proceeding.

Detect current branch (for git-related skills):

git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "not-a-git-repo"

Check proactive mode:
```
state_read("occ-proactive")
```
If "false": do NOT proactively suggest other OpenClaw-CC skills during this session. Only run skills the user explicitly invokes.

Log skill activation:

memory_daily_log(type: "note", entry: "Skill activated: /{skill-name}")

Role

Perform comprehensive research using multiple OMC agents in parallel. Unlike basic web research, deep research cross-references multiple sources, deduplicates against existing knowledge, builds knowledge graph connections, and produces analyst-grade reports.

Workflow

Phase 1 — Existing Knowledge Assessment

Memory Context Loading

Before starting work, load relevant context from the 3-layer memory system:

# Search for related past work
memory_search(query: "{task description}", associative: true, limit: 5)

# Search by relevant tags
memory_search(tag: "{relevant-tag}", limit: 3)

# Check for recent related daily logs
memory_search_date(start: "{7 days ago}", end: "{today}", category: "daily-logs", limit: 5)

Use retrieved context to:

Avoid repeating past mistakes
Build on previous decisions
Maintain consistency with established patterns
Reference related knowledge graph nodes

If critical related memories exist, summarize them before proceeding:

Found {N} related memories:
- {memory_1 title}: {brief relevance}
- {memory_2 title}: {brief relevance}

memory_search(associative: true, context: {
  tags: ["{topic}", "research"],
  date: "{today}"
})
memory_graph(id: related_memory_id, depth: 2) → Map existing knowledge

Produce a knowledge gap analysis: what is known vs what needs research.

Phase 2 — Parallel Agent Dispatch

Spawn 3 research agents with different angles:

Agent(name: "researcher-1", subagent_type: "research-agent",
  prompt: "Research '{topic}': focus on OVERVIEW and landscape.
    Search in both Korean and English.
    Return structured findings with source URLs.",
  run_in_background: true)

Agent(name: "researcher-2", subagent_type: "research-agent",
  prompt: "Research '{topic}': focus on RECENT DEVELOPMENTS (last 6 months).
    Find news, announcements, and technical updates.
    Return structured findings with dates and sources.",
  run_in_background: true)

Agent(name: "researcher-3", subagent_type: "research-agent",
  prompt: "Research '{topic}': focus on TECHNICAL DEPTH and implementation.
    Find documentation, code examples, architecture details.
    Return structured findings with code snippets if available.",
  run_in_background: true)

Phase 3 — Synthesis via OMC Analyst

Agent(subagent_type: "oh-my-claudecode:analyst", model: "opus",
  prompt: "
    Synthesize these 3 research reports into a unified analysis:

    Report 1 (Overview): {researcher_1_output}
    Report 2 (Recent): {researcher_2_output}
    Report 3 (Technical): {researcher_3_output}

    Produce:
    1. Key findings (ranked by importance)
    2. Trend analysis
    3. Technical assessment
    4. Gaps and uncertainties
    5. Recommendations
  ")

Phase 4 — Deduplication & Knowledge Graph

# Check each finding against existing knowledge
For each key finding:
  memory_similar(text: "{finding}") → Check duplicates

  If similarity > 0.7:
    memory_update(id: existing, mode: "append", content: "Updated: {new_info}")
  Else:
    new_id = memory_store(
      category: "knowledge",
      subcategory: "{domain}",
      title: "Research: {finding_title}",
      tags: ["research", "deep-research", "{topic}"],
      importance: 6
    )

# Build knowledge graph connections
memory_link(source: new_id, target: existing_id, relation: "related")
memory_link(source: new_id, target: overview_id, relation: "derived")

Phase 5 — Quality Review via OMC Critic

Agent(subagent_type: "oh-my-claudecode:critic", model: "opus",
  prompt: "
    Review this research report for completeness and accuracy:
    {synthesized_report}

    Check for:
    1. Unsupported claims (no source)
    2. Logical gaps
    3. Missing perspectives
    4. Outdated information
    5. Contradictions between sources

    Provide a quality score (1-10) and specific improvement suggestions.
  ")

Phase 6 — Final Report & Delivery

## Deep Research Report: {Topic}

**Quality Score**: {critic_score}/10
**Sources Consulted**: {N} across {M} domains
**Knowledge Graph**: {K} new nodes, {J} new connections

### Executive Summary
{one_paragraph_overview}

### Key Findings
1. {Finding} — Source: {url} — Confidence: High/Medium/Low
2. {Finding} — Source: {url} — Confidence: High/Medium/Low
3. ...

### Trend Analysis
{trends_and_direction}

### Technical Assessment
{technical_details_with_code_examples}

### Data Points
| Metric | Value | Source | Date |
|--------|-------|--------|------|

### Source Credibility Matrix
| Source | Type | Credibility | Recency |
|--------|------|-------------|---------|

### Gaps & Uncertainties
- {unverified_claims}
- {missing_perspectives}

### Recommendations
1. {actionable_recommendation}
2. {actionable_recommendation}

### Knowledge Graph Impact
- New memories created: {list_with_ids}
- Connected to existing: {list_of_links}
- Stored as: memory #{primary_id}

Delivery

Memory Persistence

After completing the workflow, persist results to the 3-layer memory system:

Required Actions

Log completion to daily log:

memory_daily_log(type: "done", entry: "{skill-name}: {brief result summary}")

Store significant findings (importance ≥ 6):

memory_store(
  category: "{appropriate category}",
  title: "{descriptive title}",
  content: "{structured result content}",
  tags: ["{skill-name}", "{project}", "{relevant-tags}"],
  importance: {6-10 based on significance}
)

Link to related memories (if applicable):

memory_link(source: "{new_memory_id}", target: "{related_id}", relation: "{related|derived|refines}")

Category Routing

Content Type	Category	Subcategory
Bug fix / debugging	knowledge	debugging
Code review results	projects	{project-name}
Design decisions	projects	{project-name}
Research findings	knowledge	{topic}
Release / deploy	projects	{project-name}
Person-related info	people	—
Task / action item	tasks	—

memory_store(category: "knowledge", title: "Deep Research: {topic}",
  importance: 7, tags: ["deep-research", "{topic}"])
memory_daily_log(type: "done", entry: "Deep research completed: {topic}")

Messenger Notification

Send notifications for significant events via messenger:

When to Notify

Event	Platform	Priority
Task/pipeline completed	telegram	Normal
Verification failed	telegram	High
Long-running task done (10+ min)	telegram	Normal
Critical error or blocker	telegram	High
PR created / release shipped	all	Normal
Importance ≥ 8 memory created	telegram	Normal

Notification Format

messenger_send(
  platform: "telegram",
  message: "[{skill-name}] {status_emoji} {brief description}\n\n{details if relevant}"
)

Status Emojis:

Completed successfully: ✅
Completed with warnings: ⚠️
Failed / blocked: ❌
Needs attention: 🔔

Do NOT Notify

Routine memory operations
Intermediate progress steps
Read-only operations (search, list, status)

messenger_send(platform: "telegram",
  message: "📊 Deep research complete: {topic}\nScore: {score}/10\nFindings: {count}\nMemory: #{id}")

Principles

Parallel-first — Always run 3 researchers in parallel for speed
Multi-angle — Overview + Recent + Technical = comprehensive coverage
Dedup-before-store — Every finding checked against existing knowledge
Graph-connected — All new knowledge linked to existing via memory_link
Quality-gated — Critic review before final delivery
Bilingual — Korean and English sources for Korean-context topics
Attribution — Every claim traced to its source URL

Completion Status Protocol

Every skill must end with one of these status codes:

Code	Meaning	When to Use
DONE	All steps completed, evidence provided	Root cause found + fix verified, PR created, review finished
DONE_WITH_CONCERNS	Completed with warnings or caveats	Tests pass but coverage dropped, fix applied but can't fully verify
BLOCKED	Cannot proceed, requires user intervention	3 failed attempts, missing permissions, external dependency down
NEEDS_CONTEXT	Missing information to continue	Unclear requirements, need user clarification

Escalation Rules

3-strike rule: After 3 failed attempts at any step, STOP and escalate to user. Do not continue guessing. Present what was tried and ask for direction.
Scope escalation: If fix/change touches 5+ files unexpectedly, pause and confirm with the user before proceeding.
Security uncertainty: If you are unsure about a security implication, STOP and escalate. Never guess on security.
Verification requirement: Never claim DONE without evidence.
- "Should work" → RUN IT. Confidence is not evidence.
- "Already tested earlier" → Code changed since. Test again.
- "Trivial change" → Trivial changes break production.

Output Format

═══════════════════════════════════════
Status: {DONE | DONE_WITH_CONCERNS | BLOCKED | NEEDS_CONTEXT}
Summary: {one-line description of outcome}
Evidence: {test output, verification results, or blocking reason}
═══════════════════════════════════════