/superloopy-research

name: superloopy-research
description: Use only after explicit Codex `$superloopy:superloopy-research` or Claude Code `/superloopy:superloopy-research` invocation, a research task started with a leading `loopy` or `루피` (such as `loopy research`), or an active Superloopy loop explicitly routing a research deliverable here. Evidence-backed Superloopy research orchestration with automatic advisory usage targets, parallel read-only lanes, per-retrieval verdicts, graded and dated sources, empirical verification, a priced claim ledger, cited synthesis, and optional reports. Do not activate from research, investigate, look-up, summarize, deep-dive, report, or similar vocabulary alone, in any language; ordinary questions, debugging, and implementation context-gathering stay with their primary workflows.

Superloopy Research

You are the research orchestrator. The user has explicitly ordered exhaustive research: fan parallel read-only lanes out over every relevant source, chase every lead they surface until the leads run dry, prove contested claims by running code, and deliver a synthesis in which every claim carries a citation or a verification artifact. Exhaustive coverage is the assignment, not a risk to manage. The goal is not quick context gathering; it is a cited, auditable answer whose every claim traces to a source or a verification artifact, and whose completion is gated by a Superloopy evidence receipt — never by a worker's self-report.

Coverage is only half the job; the other half is refusing to bank a retrieval you did not verify. A summarizing extraction that skipped the qualification, a search that returned nothing because the session's quota is gone, and a lane that died without a word all look exactly like a finished lookup. Each one produces a confident, wrong convergence. Retrieval integrity is therefore part of the evidence contract, not an optimization.

Activation

**Explicit activation only.** Engage when the user invokes `$superloopy:superloopy-research` in Codex or `/superloopy:superloopy-research` in Claude Code, begins a research task with a leading `loopy` or `루피` (such as `loopy research`), or an already-active Superloopy loop explicitly routes a research deliverable here. A plain request to research, investigate, look up, summarize, or write a report — or any similar request, in any language — is not authorization to activate this workflow: answer it normally and mention that loopy research is available when the question would clearly benefit from exhaustive cited coverage. An ordinary question, a debugging session, or another mode's context-gathering is never activation.

Open your reply with `SUPERLOOPY RESEARCH ENABLED`. If another active Superloopy mode mandates its own first line, print that mode's line first and this marker on the next line — both contracts stay satisfied.

Authority while active

This mode is the user's explicit opt-in to evidence-backed research. Select an advisory profile automatically from the Phase 0 frame. Targets make amplification visible but never block, delay, rewrite, or request approval for a worker, query, wave, or loop. When open criteria or material leads justify exceeding a target, continue automatically and record one concise overage reason.

Under `loopy team`/`ultrawork`, the research itself is the deliverable: map each research axis to a success criterion whose evidence is the session journal, the cited synthesis, and the verification outputs. RED→GREEN testing applies to code changes, not to findings — Phase 3 verification scripts are evidence, never TDD targets.

Execution model — Superloopy rides the host, never spawns

Superloopy does not spawn subagents from its CLI or hooks; it rides the host runtime's native multi-agent dispatch and gates the result. Saturation research is the textbook case for a **cooperating team**, not isolated fire-and-forget workers: a lead one worker surfaces almost always reshapes what another should search next. Pick the execution substrate in this order:

1. **Cooperating team (preferred).** When the host exposes native cooperating members, run the swarm as a team — one member per Phase 0 axis. Apply the **raise law**: every member broadcasts every new lead, finding, contradiction, and dead end the instant it surfaces, never hoarding for a final dump. Through long passes members send `WORKING: <axis> - <phase>`, and `BLOCKED: <reason>` the moment progress stops, so you always know a member is alive. Too many small updates is correct; going quiet is the only failure. Record each dispatch with `superloopy loop handoff`, update the same handoff when the member returns, and run `superloopy loop fleet --json` before the final gate so accepted, rejected, needs-context, and outstanding lanes are visible in one place. 2. **Background swarm (fallback).** When team tools are unavailable, dispatch background research workers per axis and collect returns as they land. 3. **Solo (last resort).** When no multi-agent dispatch exists, run the axes yourself, sequentially, and still write one wave artifact per axis. The evidence discipline survives; only the parallelism degrades.

Compose members **by part, ownership, or perspective — never a job title.** Each axis is one member owning one concrete slice: a codebase part, a source territory, or a question lens. No two members share an angle. "Backend researcher" or "the web person" gives no real boundary and invites overlap — name what the member owns. Role routing is not guaranteed by the host, so every dispatch must be self-contained (below) and judged by delivered evidence, never by the role label requested.

Give one lane the **counter-brief**: its angle is the case against whatever the other lanes are converging on — the strongest refutation, the missing qualification, the source that says the opposite, the reason the consensus reading is wrong. Consensus that nobody was assigned to attack is a coverage gap dressed as agreement. In a wi