PK¬]η\α”η$$ dingduff-legal-research/SKILL.md--- name: dingduff-legal-research description: Research the law on a question β€” find, retrieve, read, and validate the controlling cases, statutes, and regulations; map the citation network and the statutory landscape; and verify everything is still good law. Use for ANY legal-research task β€” "what's the law on X," "find cases/statutes on Y," "research precedent," "is this still good law," "map the statutory scheme," "what does Β§ __ mean" β€” and as the authority-gathering step behind any analysis, memo, or brief. Research is thorough by default. It interleaves with dingduff-legal-analysis (analysis guides research; research guides analysis) and feeds dingduff-legal-writing. Method detail for case law, statutes, and validity lives in references/ and is loaded as needed. (v2.2) --- # Legal Research One skill for finding and verifying legal authority β€” case law, statutes, and regulations. It produces a reliable, citation-anchored body of authority you can build an analysis or a document on, having personally confirmed it is still good law. Research here is **thorough by default**: assume the user wants the full picture, not a single snippet. Keep this file in context; pull in a `references/` file for the method you need. This skill runs on the DingDuff research tools (CourtListener + code databases): `opinion_search`, `courtlistener_full_search`, `opinion_store`, `opinion_view`, `show_citing_opinions`, `show_related_opinions` for cases; `codes_browse`, `codes_search`, `codes_view`, `metadata_view` for statutes/regulations. ## CRITICAL: Retrieve before you assert (anti-hallucination) **Never** state a holding, quote any language, or recite statutory text from a search snippet. Snippets only help you decide what to retrieve β€” they are not citable substance. - Cases: retrieve the actual opinion via `opinion_store` (preferred β€” saves a local copy) or `opinion_view`, then cite by reporter citation + pinpoint page (*Miranda v. Arizona*, 384 U.S. 436, 444 (1966)). Cluster IDs are internal retrieval handles β€” keep them in your notes, never in user-facing citations. - Statutes: retrieve the full section via `codes_view`, then cite by proper statutory citation (Tex. Bus. Orgs. Code Β§ 21.401(a); 18 U.S.C. Β§ 1001(a)(2)). `statute_id` stays internal. - If you cannot retrieve a source's text, do not discuss its substance β€” note the gap and move on. ## CRITICAL: Verify it's still good law The databases do **not** flag overturned, abrogated, or limited cases, and do not guarantee real-time tracking of statutory amendments. You must check, yourself, for every authority you will rely on β€” overturn/treatment checks for cases, currency/amendment checks for statutes. This is the single discipline that separates real research from a snippet dump. Method in `references/validity.md`; do it before anything you find becomes part of an answer. ## Research and analysis interleave (the recursive loop) Research and analysis are one intertwined process, not two phases. **Analysis guides research** (you research the specific issues, elements, and ambiguous terms the analysis has framed) and **research guides analysis** (what you find reshapes the issues, the rule, and the framing β€” a new exception, a circuit split, a controlling definition, an issue that turns out to be moot). So do not treat research as a single up-front pass. Loop: 1. Start from the framed issues (from `dingduff-legal-analysis`; if none exist yet, frame them lightly first). 2. Research them (cases and/or statutes, below). 3. Hand findings to analysis β€” let it synthesize the rule, analyze the facts, structure the proof. 4. **Return to research whenever analysis surfaces a new question** β€” an ambiguous controlling term needing its judicial gloss, a newly-spotted sub-issue, a missing element, a needed counter-authority, an adverse case to confirm. 5. Repeat until **both** the research network is saturated **and** the analysis has no unresearched gaps. `dingduff-legal-analysis` escalates *back* to research when it hits a hole; this skill closes the loop by sending you *forward* into analysis and back again. Neither is done until both are done. ## Calibrate scope to the question Thorough by default β€” but set the breadth to the question. A regime-mapping, bet-the-matter, or appellate question gets the full sweep (deep citation network; complete statutory map). A tightly-bounded question (one well-defined hook, one defined term) gets a focused pass β€” don't expand a one-section lookup into a 100-case network. If a network grows past ~75–100 cases or ~50 statute sections, the issue was scoped too broadly: narrow it (to an element, jurisdiction, or fact pattern) and re-anchor. Rank what you find by **weight of authority** (binding > persuasive; higher court > lower; more recent and on-point > older and tangential) and spend your effort there. ## Local storage: saved cases / saved statutes When the user has connected a folder, create archive subfolders in it and save every retrieved opinion and section as markdown β€” a durable record for the user and a way for you to re-read without spending more tool calls. For each opinion, **also save the CourtListener PDF alongside the markdown whenever one is available** (mechanism below). ```bash mkdir -p "/saved cases" mkdir -p "/saved statutes" ``` Naming: cases `__.md` (e.g., `107252_miranda_v_arizona_384_US_436.md`); statutes `__
.md` (e.g., `us_18_usc_1001.md`). Sanitize: lowercase, spaces β†’ underscores, strip punctuation except underscores/dots, "v." β†’ "v". If no folder is available, fall back to inline retrieval (`opinion_view` / `codes_view`) and tell the user no archive was produced. ### PDF copies (cases) In addition to the markdown, save the CourtListener PDF for each opinion when one exists β€” same base filename as the `.md`, with a `.pdf` extension (e.g., `107252_miranda_v_arizona_384_US_436.pdf`), in `saved cases/`. Note that `opinion_store` does **not** hand you a PDF link β€” the URL it returns is the markdown file β€” so resolve the PDF from the cluster: 1. Take the `` (from the `opinion_store` result, or the `cluster_id` / `absolute_url` in `opinion_search` / `courtlistener_full_search` results; `absolute_url` is the human page, `https://www.courtlistener.com`). 2. Look up the cluster's opinions on CourtListener: `https://www.courtlistener.com/api/rest/v4/opinions/?cluster=`. In the JSON, a sub-opinion's `local_path` (when non-empty) is CourtListener's stored PDF at `https://storage.courtlistener.com/`; `download_url` is the court's original source file. Prefer `local_path`, fall back to `download_url`. 3. Download it next to the markdown: ```bash curl -L "" -o "/saved cases/.pdf" ``` This is **best-effort and must never block research**: many older, text-only opinions have no PDF on CourtListener. When none is available (or the download fails), keep the markdown as the record and note "no PDF on CourtListener" for that case. The markdown β€” not the PDF β€” remains the text you read, quote, and cite from. ## Workflow 1. **Take the issues** β€” from `dingduff-legal-analysis`, or frame them lightly. Decide whether the question is statute-driven, case-law-driven, or both. 2. **Statutes & regulations** (when a statutory or regulatory scheme governs) β€” map the code bidirectionally, pull definitions, flag phrases needing interpretation. β†’ `references/statutes.md` 3. **Case law** β€” search broadly, then map the citation network (back to the anchor, forward to current applications, plus a topical sweep). β†’ `references/case-law.md` 4. **Validate** everything you'll rely on β€” overturn checks for cases, currency for statutes. β†’ `references/validity.md` 5. **Interleave with analysis** (the loop above) β€” feed findings to `dingduff-legal-analysis`; return here for each new question it surfaces. Continue until saturated and gap-free. 6. **Synthesize** β€” present the authority with its current-validity status. Output formats (doctrinal genealogy + network diagram + case table for cases; statutory tree + roadmap + section table for statutes) are in the domain references. ## References map - `references/case-law.md` β€” finding cases (search strategies, tool patterns), mapping the citation network (ancestors / descendants / topical sweep), the working set, and the case-law output format (genealogy, network diagram, case table). - `references/statutes.md` β€” jurisdiction/scope check, bidirectional code mapping (top-down hierarchy + bottom-up keyword), definition discovery, flagging phrases that need interpretation, targeted interpreting case law, and the statutory output format (tree, roadmap, section table). - `references/validity.md` β€” the overturn problem and the case-validity check; statutory currency and amendment checks; the verification pass before any authority enters an answer. ## Related skills Interleaves with `dingduff-legal-analysis` (the reasoning it feeds and takes direction from). Downstream: `dingduff-legal-writing` (drafts from the authority + analysis). QC: `dingduff-legal-citation-format`, `dingduff-citation-check`. PK–]η\ι rzRR.dingduff-legal-research/references/case-law.md# Case Law Research Method for finding the controlling and persuasive cases on an issue and mapping the citation network until you can speak to where the rule came from, what it says now, how it has been applied, and where it is contested. Validate everything per `validity.md`. ## The working set (keep it tractable) Citation networks expand fast. Maintain three running lists (in your head or a scratch file in `saved cases/`): - **Read** β€” cases retrieved, opened, analyzed. - **Frontier** β€” cases identified as worth retrieving, not yet read. - **Pruned** β€” cases considered and skipped, each with a one-line reason (off-topic, distinguishable on irrelevant grounds, redundant with stronger authority). Each iteration moves frontier β†’ read, generates new frontier candidates from what you read, and prunes dead ends. Done when the frontier is empty or only redundant. ## 1. Strategic search (cast a wide net) Run 3–5 different strategies β€” each catches cases the others miss: - **Natural language** β€” `opinion_search` with the issue in plain language plus `court_ids`, `court_types`, `states`, date filters. - **Boolean / phrase** β€” `opinion_search` with Boolean operators and exact doctrinal phrases. - **High-authority anchor** β€” `opinion_search` with `court_ids: "scotus"` and `order_by: "-citeCount"` to find the foundational treatment. - **Jurisdiction-specific** β€” `court_types` + `states` filters for the operative jurisdiction. - **Field-specific** β€” `courtlistener_full_search` with `type: "o"` and field-scoped queries (e.g., `court_id:scotus AND "qualified immunity"`). Court-type codes: F = federal circuit, FD = federal district, FB = bankruptcy, S = state supreme, SA = state appellate, ST = state trial; SCOTUS = `court_ids: "scotus"`. Triage candidates from snippets (snippets are *only* for triage β€” see anti-hallucination). Bulk-retrieve the promising ones (up to 25 per call) via `opinion_store`; download each returned markdown URL with `curl` into `saved cases/` (URLs expire in ~1 hour β€” regenerate if needed), and also save a **PDF copy from CourtListener** alongside it whenever one exists (mechanism in SKILL.md β†’ *Local storage*). Read each; note holdings/reasoning/quotable language, and mark every case it cites *on the focus issue* as a frontier candidate. ## 2. Backward tracing (ancestors β†’ the anchor) Trace the doctrine to its source. From each read case, list the cases it cites in connection with the focus issue; resolve those cites to cluster IDs (`opinion_search`/`opinion_view`); bulk-retrieve, save, read; recurse. Stop a branch when a case cites no earlier authority on the issue, cites only general/unrelated authority, or is the case multiple branches converge on (a strong anchor signal). **Document the anchor case(s) explicitly** β€” the reader needs to know where the rule comes from. ## 3. Forward tracing (descendants β†’ current law) From each pivotal case, run `show_citing_opinions`: ```json {"identifier": "", "court_types": "F,FD,S,SA", "limit_results": 30, "order_by": "-dateFiled"} ``` Order by `-dateFiled` first (this doubles as the overturn check β€” see `validity.md`), then a pass by `-citeCount` for the most influential applications. In the snippets, look for cases that **apply**, **narrow**, **criticize**, **extend**, or **follow** the rule β€” and for adverse-treatment signals. Add informative cases to the frontier; prune the rest with a reason; retrieve, save, read, and recurse (run `show_citing_opinions` on significant descendants too). The forward network branches fast β€” lean on pruning. ## 4. Topical sweep `show_related_opinions` finds cases related by subject matter, not citation β€” catching on-point authority your keywords and citation chains miss. Run it on your two or three most central cases: ```json {"identifier": "", "court_ids": "scotus", "limit_results": 20, "order_by": "-citeCount"} ``` Triage; new cases to the frontier, off-point ones pruned. ## 5. Recurse until saturated Phases 2–4 are loops, not one-shots. Keep going until: new expansions return cases already read (saturation); the anchor is identified and branches converge on it; each main proposition has a recent application located; every case you'll rely on has been validity-checked; the major exceptions/qualifications are mapped. Don't stop while the anchor is unidentified, a meaningful citing branch is unread, a foundational case is unverified, or a hint of a circuit split is unrun. ## Output format (case-law deliverable) 1. **Answer** β€” the rule and its current status, in 2–4 sentences. 2. **Doctrinal genealogy** β€” a short narrative from the anchor forward to the modern formulation. 3. **Anchor / source authority** β€” the 1–3 cases that established the rule (name, cite, what it decided, key pinpoint quote). 4. **Primary authority (current law)** β€” the 3–7 cases stating the current rule (cite, holding, pinpoint quote, validity status). 5. **Supporting authority** β€” cases that reinforce, extend, or apply the rule informatively. 6. **Contrary / limiting authority** β€” adverse, distinguishable, narrowing, or critical cases. Engage honestly; this is what makes research trustworthy. 7. **Trends and open questions** β€” splits, recent shifts, unresolved issues. 8. **Validity confirmations** β€” brief notes on the overturn checks performed (show the work). **Citation network diagram** (Mermaid): anchors at top, descendants flowing down, focus case marked (β˜…/bold), adverse edges labeled (`-->|abrogated by|`), short cite + year on each node. Split by sub-doctrine if too large. **Comprehensive case table** β€” every case for which you retrieved text (not just those cited): | Case Name & Citation | Cluster ID | Role | Validity | Key Quote(s) | Local File | |---|---|---|---|---|---| | *Brown v. Board of Educ.*, 347 U.S. 483 (1954) | 107252 | Anchor | Good law | "Separate educational facilities are inherently unequal." *Id.* at 495. | `107252_brown_v_board_347_US_483.md` | Role = Anchor / Primary / Supporting / Contrary / Pruned-but-considered. Sort by role, then date. ## Tool quick reference - `opinion_search` / `courtlistener_full_search` β€” discovery. - `opinion_store` β€” bulk retrieval (1–25 cluster IDs); markdown URLs valid ~1 hr; save the markdown to `saved cases/`, plus a PDF copy from CourtListener when available (SKILL.md β†’ *Local storage*). - `opinion_view` β€” single-case inline retrieval (or from a reporter cite); good for a quick spot check. - `show_citing_opinions` β€” forward tracing and the workhorse of the overturn check. - `show_related_opinions` β€” topical sweep for cases the citation chains miss. PK·]η\ša#Ρ,!,!.dingduff-legal-research/references/statutes.md# Statutory Research Method for mapping the statutory landscape on an issue β€” every relevant code section, the definitional architecture, the cross-references, and the judicial gloss on any ambiguous or outcome-controlling language β€” so the user can rely on the map with no missing chapters and no defined term silently reshaping the answer. Validate currency per `validity.md`. ## The working set Maintain **Read** (sections retrieved via `codes_view` and analyzed), **Frontier** (sections, chapters, or keyword leads not yet pulled), and **Pruned** (skipped, with a reason). Each pass moves frontier β†’ read and generates new frontier from cross-references, defined terms, and adjacent sections. ## 1. Jurisdiction and scope Confirm the jurisdiction's codes are available: `codes_browse {"jurisdiction": "TX"}`. If none are returned, say so and ask how to proceed. Set breadth from the question (wider for a "regime/scheme/framework" or bet-the-matter question; tighter for one well-defined hook or a single defined term). ## 2. Bidirectional code mapping (run both directions) **Top-down (hierarchy):** 1. List codes for the jurisdiction (`codes_browse {jurisdiction}`). 2. Identify the codes likely to govern (business/corporate β†’ Business Organizations; real property β†’ Property; criminal β†’ Penal / Crim. Proc.; civil procedure β†’ Civil Practice & Remedies; family β†’ Family; tax β†’ Tax; agency regulation β†’ that agency's code). When unsure, browse any code whose name plausibly touches the issue β€” over-inclusion here is cheap. 3. Drill titles β†’ divisions β†’ chapters β†’ subchapters β†’ sections (`codes_browse` with `code_id`/`node_id`); document the hierarchy (you need it for the tree). 4. Pull section text where the title/context suggests relevance (`codes_view {"statute_id": "TX/business_organizations/21.401"}`); save to `saved statutes/`. **Bottom-up (keyword):** 1. Text search β€” `codes_search {"jurisdiction":"TX","search_type":"text","query":"shareholder derivative action","limit":25}`. Run several queries (exact phrases, individual keywords, synonyms β€” statutes use idiosyncratic terms). 2. Title search β€” `codes_search {"search_type":"title","query":"derivative"}` surfaces whole chapters on the issue. 3. For any hit, browse the parent chapter and adjacent sections β€” related provisions are nearly always grouped. **Reconcile:** every bottom-up hit should appear in your top-down hierarchy (or be added); every relevant top-down section should be caught by some keyword search (if not, broaden the keywords). **Regulations** are handled the same way: administrative/agency codes (a state administrative code, or the C.F.R. for federal regulations) are browsed and retrieved with the same `codes_browse` / `codes_view` tools, and mapped, defined, and currency-checked just like statutes. Where a statute delegates to an agency, follow the cross-reference into the regulatory code. ## 3. Definition discovery Definitions control interpretation and are often where the answer lives. Pull: **code-wide** definition sections (`codes_search {"search_type":"title","query":"definitions"}`; often section .001/.01); **chapter/subchapter** definitions (these supersede general ones for that chapter); **in-line** definitions ("As used in this section…"). Flag **definitional conflicts** β€” the same term defined differently across chapters/codes β€” and identify which governs the fact pattern. Document every applicable definition. ## 4. Flag phrases that need interpretation Read the collected sections and flag every phrase that is: **ambiguous on its face**; **outcome-controlling**; a **term of art** set by case law ("reasonable suspicion," "good faith," "in the course of employment," "knowingly"); **definitionally underspecified**; **recently amended** (prior constructions may or may not still apply); or **cross-referenced** to another section/code/doctrine. For each, record the section, the phrase, why interpretation is needed, and the question you'll put to the case law. If nothing needs interpretation, that's a finding β€” say the text is unambiguous for this question and skip step 5. ## 5. Targeted interpreting case law This is a *bounded* pull β€” the judicial gloss on each flagged phrase, not a full citation network (that's `case-law.md` if it's warranted). For each phrase: - Search interpreting decisions, best by statutory cite + exact phrase: `opinion_search {"query":"\"Tex. Bus. Orgs. Code Β§ 21.401\" AND \"interest of the corporation\"","court_types":"S,SA,F,FD","order_by":"-citeCount"}`. For state statutes focus on the state high court + intermediate appellate; for federal, SCOTUS + the relevant circuit (don't ignore federal courts construing state law in Erie posture). - Aim for **5–15 cases per phrase**, weighted to most-cited and most-recent. Triage from snippets; bulk-retrieve via `opinion_store`; save to `saved cases/` (markdown + CourtListener PDF when available β€” see SKILL.md β†’ *Local storage*); read. - Extract the gloss: the court's articulation of the phrase's meaning (test/elements/rule), a pinpoint quote, whether binding or persuasive, and any conflict in the set. - Validity-check each retained case (`validity.md`). - **Escalate** if a phrase turns out to sit on a sprawling, contested body of case law β€” say so and run the full case-law method on it as a focused follow-up rather than letting this silently become a network build. ## 6. Recurse until saturated Steps 2–5 iterate β€” each adds sections, surfaces cross-references and defined terms, raises new flagged phrases. Stop when: searches return only already-read sections; every plausibly-relevant code is browsed; every controlling defined term is pulled; every cross-reference is resolved or pruned; every flagged phrase has a gloss or an explicit "no controlling interpretation" note; currency is checked. If the read set passes ~50 sections, the scope was too broad β€” narrow and re-anchor. ## Output format (statutory deliverable) 1. **Executive summary** β€” jurisdiction; question framed; codes reviewed; sections identified vs. viewed (counts); headline answer (2–4 sentences). 2. **Statutory tree** β€” the hierarchy mapped, viewed sections marked: ```text Business Organizations Code └─ Title 2: Corporations └─ Ch. 21: For-Profit Corporations └─ Subch. L: Derivative Proceedings β”œβ”€ Β§ 21.551 Definitions (viewed) └─ Β§ 21.552 Standing (viewed) ``` 3. **Key provisions analysis** β€” the 5–15 driving sections (citation; one-line function; operative language with subsection pin; interactions). 4. **Applicable definitions** β€” section, term, operative definitional language; conflicts flagged with which controls. 5. **Judicial interpretation of flagged phrases** β€” phrase, section, controlling/best case(s), the rule extracted, a pinpoint quote (or an explicit "no controlling interpretation"). 6. **Cross-references and interconnections** β€” how the sections fit; where one depends on another; cross-code definitional reach. 7. **Issue-specific findings** β€” the direct answer, mapping each question to its controlling sections + cases. 8. **Currency and validity notes** β€” effective dates, amendment indicators, interpreting-case validity (brief; show the work). 9. **Practitioner's roadmap** β€” read these sections first, in this order; check these definitions; watch these traps. **Comprehensive tables** (the audit trail β€” every section and interpreting case retrieved): | Citation | Statute ID | Role | Status | Operative Language | Local File | |---|---|---|---|---|---| | Tex. Bus. Orgs. Code Β§ 21.552 | TX/business_organizations/21.552 | Primary | Effective | "A shareholder may not commence or maintain a derivative proceeding unless…" | `tx_business_organizations_code_21.552.md` | ## Tool quick reference - `codes_browse` β€” hierarchy (no args = jurisdictions; `{jurisdiction}` = codes; `{code_id}`/`{node_id}` = drill down). - `codes_search` β€” keyword (`search_type:"title"` for chapter/section discovery; `"text"` for substantive language; max `limit:25`). - `codes_view` β€” full section text (`statute_id` = `jurisdiction/code/section`). - `metadata_view` β€” section metadata (effective date / version where available β€” see `validity.md`). - `opinion_search` / `opinion_store` / `opinion_view` / `show_citing_opinions` β€” step 5 interpreting cases (see `case-law.md`). PK»Ψ\q‹.dingduff-legal-research/references/validity.md# Validity and Currency The verification discipline β€” confirming that every authority you rely on is *still good law*. The databases do **not** flag overturned/abrogated cases or guarantee real-time tracking of statutory amendments, so you do this yourself, every time, before any authority becomes part of an answer. This is the difference between research and a snippet dump. ## The overturn problem (cases) For every case you intend to rely on: 1. Run `show_citing_opinions` against it, ordered by `-dateFiled`, and read the snippets of recent citing cases: ```json {"identifier": "", "order_by": "-dateFiled", "limit_results": 20} ``` 2. Scan for **treatment signals**: "abrogated," "overruled," "is no longer good law," "rejected," "declined to follow," "limited to its facts," "called into doubt," "superseded by statute." Treat any as a red flag. 3. Cross-check with a direct search: `opinion_search` for `"" AND (overruled OR abrogated OR "no longer good law")`. 4. If you find adverse treatment, retrieve the treating case via `opinion_store`, read it, and determine the **scope** β€” full overruling, partial abrogation, narrowing, or mere distinguishing. 5. For foundational SCOTUS or controlling appellate cases, check at least the ~20 most recent citing cases. If a case has been overruled or substantially abrogated, **do not present it as good law** β€” note the treatment, explain the current rule, and cite the case that did the overruling. A non-controlling or overruled case presented as authority is the worst failure mode in legal research. Also confirm, for each main proposition, a **recent application** exists (within ~5 years, or the most recent available if the doctrine is dormant) β€” this shows the rule is alive, and surfaces recent narrowing. ## Currency and amendments (statutes and regulations) Code databases store statutory and regulatory text as imported and may lag amendments or repeals: - When `codes_view` returns a section, note any effective-date / version annotation it carries (or retrieve section metadata via `metadata_view`). - Where the statutory text drives the answer, run a recency check: `opinion_search` for recent cases citing the section β€” if a case discusses an amended version different from the text you have, flag it. - For federal statutes especially, surface the text you found and flag possible amendments for the user to confirm against an authoritative `.gov` source. - Watch for **"superseded by statute"** treatment of cases that construed a prior version of the text β€” the old gloss may no longer apply. - **Regulations** (agency/administrative codes, the C.F.R.) are amended and repealed too β€” check their effective dates and any superseding amendments the same way, and confirm the agency hasn't revised the rule since the database's import. Never silently rely on a stale version of a statute. ## The verification pass (before drafting any answer) Run through every authority you plan to cite in a primary/anchor/controlling role: - [ ] Each case run through `show_citing_opinions` (`-dateFiled`) and screened for treatment signals. - [ ] Any adverse-treatment signal chased down β€” treating case retrieved, read, and its scope determined. - [ ] A recent application located for each main proposition (or dormancy noted). - [ ] No more-recent controlling case from the same court (or higher) supersedes a case you rely on. - [ ] Statutory sections checked for effective-date/amendment annotations; stale text flagged. - [ ] Interpreting cases (from statutory research) validity-checked the same way. Record the checks briefly in the output (a "validity confirmations" note for cases; "currency and validity notes" for statutes) so the reader can see the work was done β€” not just trust that it was. PK¬]η\α”η$$ €dingduff-legal-research/SKILL.mdPK–]η\ι rzRR.€½$dingduff-legal-research/references/case-law.mdPK·]η\ša#Ρ,!,!.€[?dingduff-legal-research/references/statutes.mdPK»Ψ\q‹.€Σ`dingduff-legal-research/references/validity.mdPKb"p