Do Your Research Deep

---
description: "Fan out verification over a typed full inventory of the session's claims (assumptions, facts, specifics, premises, recommendations) against primary sources at a configurable depth, with a per-item ledger. Use when: 'deep research pass', 'verify every claim', 'audit all our claims', 'fact-check everything', 'go make sure those are all right', 'we've made a lot of load-bearing claims', or the session's judgment is the suspected bias. For one fact-check ('fact-check that'), use do-your-research."
argument-hint: "[tiered|full]"
user-invocable: true
disable-model-invocation: false
metadata:
  discipline-batch: never  # heavier fan-out execution tier. Invoked directly, not batched
  workflow-stage: anytime
  summary: Verify every session claim against primary sources in a heavy fan-out
---

# 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`](../../context/re-anchor-audit-correct.md).
The discipline this re-anchors and its portable baseline live in the sibling
[`do-your-research`](../do-your-research/SKILL.md). 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 judgment 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;
   - **recommendations**. Each option, verdict, default, or next step put to
     the user and not yet settled, verified against the contract in
     [`${CLAUDE_PLUGIN_ROOT}/context/recommendation-basis.md`](../../context/recommendation-basis.md).
   The typing makes the inventory auditable: each item carries its type, and
   step 5'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. Dispatch per
   [`${CLAUDE_PLUGIN_ROOT}/context/fan-out.md`](../../context/fan-out.md):
   blind fresh-context subagents, bounded waves, failed-subset retry.
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. **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.
5. **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, plus withheld for a
     recommendation row only;
   - **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; for an unverifiable item, where you looked;
   - **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.
   A **recommendation** row also carries its outcome from the contract:
   `Basis: verified` or `Basis: judgment` (never on a consequential one),
   or **withheld**, with no `Basis:` label and the open question naming the
   evidence that would settle it. A corrected row adds old → new → why; a
   verified one says unchanged and why.

## What this skill does NOT do

- **Not a lighter inline pass.** For a single re-anchor + audit without the
  subagent cost, invoke the sibling `/discipline:do-your-research` via the Skill tool.
- **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.