do-your-research-deep

Do your research — deep

The verification-fan-out tier of the sibling /discipline:do-your-research. Same research discipline; heavier execution. Where the base skill re-anchors and audits inline in the current context, this one enumerates a TYPED FULL INVENTORY of the session's claims and verifies them against primary sources — the execution tier the base skill's context cannot provide from within itself.

The shared method — re-anchor, audit, correct forward, report, and the tone that firing this is not an accusation — lives in ${CLAUDE_PLUGIN_ROOT}/context/re-anchor-audit-correct.md. The discipline this re-anchors and its portable baseline live in the sibling do-your-research. Read both; this file adds only the fan-out delta. There is no separate copy of the discipline here — update the sibling and this tier follows.

When this tier, not the inline audit

Reserve the fan-out for when the accumulated claims are load-bearing enough to justify the subagent cost: a long session with many concrete specifics the rest of the work now rests on, a "fact-check everything" request that wants provable coverage, or where your own judgement is the suspected source of bias across many claims — a self-check in the context that produced the claims is weak by construction. For a single unbacked claim or a short session, the inline audit in the sibling is the right tool; this tier is overkill.

Verification depth (configurable)

This tier is the expensive one by design, so its depth is configurable. Resolve it once, before enumerating, by this precedence:

1. Invocation argument wins. When this skill is invoked with an explicit depth — tiered or full (see argument-hint) — honor it over the configured default.
2. Otherwise the configured default: ${user_config.research_deep_verification}.
3. Otherwise tiered. Treat an empty value, a surviving literal ${user_config.…} token, AND any unrecognized string (a typo like "teired") all as unset — fall back to tiered, never error.

• tiered (default) — resolve trivial and non-load-bearing inventory items inline and cheaply (a quick check in this context, or an already-cited source), and fan fresh-context subagents out only over the load-bearing items. Most sessions want this: it spends the subagent budget where drift actually matters.
• full — subagent-verify EVERY inventory item, trivial or not. Reach for it when the cost of a single wrong "trivial" item is high enough to pay for exhaustive independent checking.

Report which depth ran and why (argument / configured / default).

The fan-out

Run this in place of the base skill's inline audit and correct-forward steps:

1. Enumerate a typed full inventory. List EVERY claim the session rests on, as a checklist, each tagged with its type so coverage is provable — not just the obviously load-bearing ones:
   • assumptions — unstated premises the work took for granted;
   • asserted facts — statements presented as true;
   • concrete specifics — paths, filenames, defaults, flags, signatures, versions, any "standard/conventional X";
   • load-bearing premises — the conclusions the rest of the work now depends on. The typing makes the inventory auditable: each item carries its type, and step 6's ledger has exactly one row per item. Do not spot-check one, and do not silently drop an item as "obvious" — an obvious item is a verified ledger row, not an omission.
2. Fan out, throttled — scope set by the resolved depth. Dispatch fresh-context subagents (blind to the reasoning that produced each item) to verify each against a PRIMARY source, not the same recall that produced it. Under tiered, the fan-out covers the load-bearing items while the trivial / non-load-bearing ones are resolved inline (and still get a ledger row); under full, every item goes through the fan-out. Throttle the dispatch in bounded waves rather than launching one agent per item at once — a sustained wide fan-out trips server-side burst overload (529s) and loses agents mid-run. Cap concurrency to a modest wave (roughly a dozen or fewer at a time); lower-tier worker models are sufficient for per-item verification and dodge burst overload. Process the inventory wave by wave.
3. Match the method to the item type. An externally-verifiable item (an asserted fact, a concrete specific) resolves against a source or the live environment. An INTERNAL item (an assumption, or a load-bearing premise with no external referent) has no citation to fetch — its honest verdict is a fresh-context re-derivation or a flag for the user to confirm, never a manufactured source. The 100%-coverage rule is coverage of the checklist, not a demand that every row name a URL.
4. Retry the failed subset only. If an agent errors or times out, retry that item once; on a second failure mark it unverifiable. Never blind-re-run the whole fan-out to recover a few stragglers — re-dispatch only the items that failed.
5. Merge and correct. Fold the returns together, correct every falsified or unbacked item THIS turn, and surface anything that stays unverifiable rather than smoothing over it.
6. Report a per-item ledger — 100% of the inventory. One row per checklist item (no silent drops), keyed by claim, each carrying:
   • verdict — verified / corrected / unverifiable;
   • source — what resolved it: a fetched primary source, the live environment, or "internal — re-derived / needs user confirm" for an item with no external referent;
   • source tier — how authoritative that source is, per the consuming project's own research discipline. Resolve its source of truth by the shared method's ladder — the project's CLAUDE.md / .claude/rules/ notion of official / authoritative / trusted, degrading to the portable baseline when none is declared;
   • consensus count — how many INDEPENDENT authoritative sources agreed; a lone source is weaker than a consensus, so note when only one was found;
   • recency — for a fact that can go stale (versions, pricing, APIs, defaults), the date or version the source reflects.

What this skill does NOT do

• Not a lighter inline pass. For a single re-anchor + audit without the subagent cost, use the sibling /discipline:do-your-research.
• Does not fabricate a citation or a violation. An honest per-item "verified", "internal — needs user confirm", or "stays unverifiable" is the right output when true; the fan-out never manufactures a finding — or a source — to look diligent.

Gotchas

• Coverage is the checklist, not the URLs. 100% coverage means every typed inventory item has exactly one ledger row. An internal assumption with no external source is covered by an honest re-derived / needs-confirm verdict, not by a fabricated citation.
• Depth is resolved once, up front. Argument beats the configured default beats tiered; empty, an unexpanded token, and an unrecognized value all mean tiered. Never error on a bad value.
• Throttle is not optional at scale. The failure mode is a claim-heavy session firing one agent per item simultaneously; the wave cap and failed-subset retry above are what keep the fan-out reliable, not nice-to- haves.
• Blind subagents, or it is not fresh context. An agent handed the reasoning that produced a claim re-derives the same error. Verify against the primary source, not the argument for the claim.