Automatiser une recherche d'antériorité brevet avec des agents IA

export OPENALEX_API_KEY="..."
export S2_API_KEY="..."
export OPS_KEY="..."
export OPS_SECRET="..."

recherche-rd/
├── opencode.json
├── AGENTS.md                            # protocole et règles communes
├── .agents/skills/recherche-anteriorites/
│   ├── SKILL.md                         # mode d'emploi des scripts (OpenCode et pi)
│   └── scripts/
│       ├── litterature.py
│       └── brevets.py
├── .opencode/agents/
│   ├── rd.md
│   ├── chercheur-litterature.md
│   ├── chercheur-brevets.md
│   ├── analyste.md
│   └── relecteur.md
├── invention/fiche.md                   # confidentiel
└── rapports/

mkdir -p recherche-rd/{.agents/skills/recherche-anteriorites/scripts,.opencode/agents,invention,rapports}
cd recherche-rd && git init

#!/usr/bin/env python3
"""Articles scientifiques : recherche OpenAlex et Semantic Scholar, vérification de DOI.

  python3 litterature.py openalex '"direct recycling" AND cathode' --avant 2024-01-01
  python3 litterature.py s2 "direct recycling cathode regeneration" --avant 2024-01-01
  python3 litterature.py verifier 10.1016/j.joule.2020.10.008

Clés facultatives, lues dans l'environnement : OPENALEX_API_KEY, S2_API_KEY.
Bibliothèque standard uniquement. Sortie JSON sur la sortie standard.
"""
import argparse
import datetime
import json
import os
import time
import urllib.error
import urllib.parse
import urllib.request

UA = {"User-Agent": "recherche-anteriorites/1.0"}


def http_json(url, entetes=None, essais=5):
    """GET JSON, reprise sur 429 et 5xx, None si 404."""
    for tentative in range(essais):
        req = urllib.request.Request(url, headers={**UA, **(entetes or {})})
        try:
            with urllib.request.urlopen(req, timeout=30) as r:
                return json.load(r)
        except urllib.error.HTTPError as e:
            if e.code == 404:
                return None
            if e.code in (429, 500, 502, 503) and tentative < essais - 1:
                time.sleep(2 ** (tentative + 1))
                continue
            raise SystemExit(f"Erreur {e.code} ({url.split('?')[0]}) : {e.read()[:300]!r}")


def veille(date_ref):
    """Veille de la date de référence : l'antériorité doit la précéder."""
    return (datetime.date.fromisoformat(date_ref) - datetime.timedelta(days=1)).isoformat()


def resume(index):
    """OpenAlex diffuse les résumés en index inversé (mot -> positions)."""
    if not index:
        return ""
    mots = sorted((pos, mot) for mot, positions in index.items() for pos in positions)
    return " ".join(mot for _, mot in mots)


def openalex(requete, avant=None, depuis=None, n=10, titre_resume=False):
    params = {"per_page": min(n, 100),
              "select": "id,doi,title,publication_date,type,primary_location,abstract_inverted_index"}
    filtres = ["type:article|review|preprint"]
    if titre_resume:
        # Titre et résumé seulement. Une virgule séparant deux filtres, on la retire.
        filtres.append("title_and_abstract.search:" + requete.replace(",", " "))
    else:
        params["search"] = requete  # titre, résumé et texte intégral
    if depuis:
        filtres.append(f"from_publication_date:{depuis}-01-01")
    if avant:
        filtres.append(f"to_publication_date:{veille(avant)}")
    params["filter"] = ",".join(filtres)
    cle = os.environ.get("OPENALEX_API_KEY")
    rep = http_json("https://api.openalex.org/works?" + urllib.parse.urlencode(params),
                    {"Authorization": f"Bearer {cle}"} if cle else None)
    docs = []
    for w in rep["results"]:
        loc = w.get("primary_location") or {}
        docs.append({"source": "OpenAlex", "id": w["id"], "doi": w.get("doi"),
                     "titre": w.get("title"), "date": w.get("publication_date"),
                     "type": w.get("type"),
                     "revue": (loc.get("source") or {}).get("display_name"),
                     "lien": w.get("doi") or loc.get("landing_page_url") or w["id"],
                     "resume": resume(w.get("abstract_inverted_index"))[:600]})
    return {"requete": requete, "total": rep["meta"]["count"],
            "cout_usd": rep["meta"].get("cost_usd"), "resultats": docs}


def s2(requete, avant=None, depuis=None, n=10):
    # Semantic Scholar : texte simple, sans opérateurs ; un terme à trait d'union ne trouve rien.
    params = {"query": requete.replace("-", " "), "limit": min(n, 100),
              "fields": "title,externalIds,publicationDate,year,venue,abstract,url"}
    if avant or depuis:
        debut = f"{depuis}-01-01" if depuis else ""
        params["publicationDateOrYear"] = f"{debut}:{veille(avant) if avant else ''}"
    cle = os.environ.get("S2_API_KEY")
    rep = http_json("https://api.semanticscholar.org/graph/v1/paper/search?"
                    + urllib.parse.urlencode(params), {"x-api-key": cle} if cle else None)
    docs = []
    for p in rep.get("data", []):
        doi = (p.get("externalIds") or {}).get("DOI")
        docs.append({"source": "Semantic Scholar", "id": p["paperId"],
                     "doi": f"https://doi.org/{doi}" if doi else None,
                     "titre": p.get("title"), "date": p.get("publicationDate") or p.get("year"),
                     "revue": p.get("venue"), "lien": p.get("url"),
                     "resume": (p.get("abstract") or "")[:600]})
    return {"requete": requete, "total": rep.get("total"), "resultats": docs}


class SansRedirection(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, *args, **kwargs):
        return None  # on veut voir le 302 de doi.org, pas la page de l'éditeur


def verifier(dois):
    """Un DOI est retenu s'il existe dans OpenAlex (gratuit) ou sur doi.org (302)."""
    sortie = []
    for doi in dois:
        doi = doi.replace("https://doi.org/", "").strip()
        w = http_json("https://api.openalex.org/works/doi:" + urllib.parse.quote(doi)
                      + "?select=id,title,publication_date")
        if w:
            sortie.append({"doi": doi, "existe": True, "par": "OpenAlex",
                           "titre": w.get("title"), "date": w.get("publication_date")})
            continue
        try:
            urllib.request.build_opener(SansRedirection).open(
                urllib.request.Request("https://doi.org/" + urllib.parse.quote(doi), headers=UA),
                timeout=30)
            existe = False
        except urllib.error.HTTPError as e:
            existe = e.code in (301, 302, 303, 307, 308)
        sortie.append({"doi": doi, "existe": existe, "par": "doi.org"})
    return sortie


def main():
    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
    sous = p.add_subparsers(dest="commande", required=True)
    for nom in ("openalex", "s2"):
        c = sous.add_parser(nom)
        c.add_argument("requete")
        c.add_argument("--avant", help="date de référence AAAA-MM-JJ (exclue)")
        c.add_argument("--depuis", type=int, help="année minimale")
        c.add_argument("--n", type=int, default=10, help="nombre de résultats (100 au plus)")
        if nom == "openalex":
            c.add_argument("--titre-resume", action="store_true",
                           help="chercher dans le titre et le résumé seulement")
    sous.add_parser("verifier").add_argument("dois", nargs="+")
    a = p.parse_args()
    if a.commande == "openalex":
        r = openalex(a.requete, a.avant, a.depuis, a.n, a.titre_resume)
    elif a.commande == "s2":
        r = s2(a.requete, a.avant, a.depuis, a.n)
    else:
        r = verifier(a.dois)
    print(json.dumps(r, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Brevets : recherche dans les données de l'OEB via Open Patent Services (OPS 3.2).

  python3 brevets.py classes "battery recycling"             # codes CPC suggérés
  python3 brevets.py chercher --mots "cathode relithiation" --cpc H01M10/54 --avant 2024-01-01
  python3 brevets.py chercher --cql 'ta all "direct recycling" and cpc=/low Y02W30/84'
  python3 brevets.py verifier EP1000000A1 FR3000000A1

Identifiants de votre App developers.epo.org dans OPS_KEY et OPS_SECRET.
Index ti, ab, ta : titres et résumés en anglais. 100 résultats par page, 2 000 par recherche.
"""
import argparse
import base64
import json
import os
import time
import urllib.error
import urllib.parse
import urllib.request

BASE = "https://ops.epo.org/3.2"
JETON = {"valeur": None, "expire": 0.0}


def jeton():
    """OAuth 2.0 « client credentials » : jeton Bearer valable environ 20 minutes."""
    if JETON["valeur"] and time.time() < JETON["expire"] - 60:
        return JETON["valeur"]
    cle, secret = os.environ.get("OPS_KEY"), os.environ.get("OPS_SECRET")
    if not cle or not secret:
        raise SystemExit("Définissez OPS_KEY et OPS_SECRET.")
    basic = base64.b64encode(f"{cle}:{secret}".encode()).decode()
    req = urllib.request.Request(
        f"{BASE}/auth/accesstoken", data=b"grant_type=client_credentials", method="POST",
        headers={"Authorization": f"Basic {basic}",
                 "Content-Type": "application/x-www-form-urlencoded"})
    try:
        with urllib.request.urlopen(req, timeout=30) as r:
            rep = json.load(r)
    except urllib.error.HTTPError as e:
        raise SystemExit(f"Authentification OPS refusée ({e.code}) : {e.read()[:300]!r}")
    JETON["valeur"] = rep["access_token"]
    JETON["expire"] = time.time() + int(rep.get("expires_in", 1199))
    return JETON["valeur"]


def get(chemin, params, plage=None, essais=4):
    url = f"{BASE}/rest-services/{chemin}?" + urllib.parse.urlencode(params)
    for tentative in range(essais):
        h = {"Authorization": f"Bearer {jeton()}", "Accept": "application/json"}
        if plage:
            h["X-OPS-Range"] = plage
        try:
            with urllib.request.urlopen(urllib.request.Request(url, headers=h), timeout=60) as r:
                feux = r.headers.get("X-Throttling-Control") or ""
                if "red" in feux or "black" in feux:
                    time.sleep(10)  # l'OEB demande de ralentir
                return json.load(r)
        except urllib.error.HTTPError as e:
            corps = e.read().decode(errors="replace")
            if e.code == 404:
                return None  # SERVER.EntityNotFound : aucun résultat
            if "invalid_access_token" in corps:
                JETON["valeur"] = None  # jeton expiré : on en redemande un
                continue
            if e.code in (403, 503) and "Fair" not in corps and tentative < essais - 1:
                time.sleep(2 ** (tentative + 2))
                continue
            motif = e.headers.get("X-Rejection-Reason") or ""  # quota épuisé, le cas échéant
            raise SystemExit(f"Erreur OPS {e.code} {motif} : {corps[:400]}")
    raise SystemExit("Nombre maximal de tentatives atteint")


def liste(x):
    return x if isinstance(x, list) else ([] if x is None else [x])


def texte(x):
    """Texte d'un nœud BadgerFish : {'$': ...}, liste de nœuds ou paragraphes."""
    if isinstance(x, list):
        return " ".join(filter(None, (texte(e) for e in x)))
    if isinstance(x, dict):
        return x.get("$") or texte(x.get("p"))
    return x


def en_anglais(noeuds):
    noeuds = liste(noeuds)
    choix = next((n for n in noeuds if n.get("@lang") == "en"), noeuds[0] if noeuds else None)
    return texte(choix) if choix else None


def extraire(doc):
    biblio = doc.get("bibliographic-data") or {}
    ids = liste((biblio.get("publication-reference") or {}).get("document-id"))
    docdb = next((d for d in ids if d.get("@document-id-type") == "docdb"), {})
    date = texte(docdb.get("date")) or ""
    numero = f"{doc.get('@country')}{doc.get('@doc-number')}{doc.get('@kind') or ''}"
    parties = biblio.get("parties") or {}  # élément parfois vide
    deposants = liste((parties.get("applicants") or {}).get("applicant"))
    return {
        "publication": numero,
        "date_publication": f"{date[:4]}-{date[4:6]}-{date[6:]}" if len(date) == 8 else date,
        "titre": en_anglais(biblio.get("invention-title")),
        "deposants": [texte((a.get("applicant-name") or {}).get("name")) for a in deposants
                      if a.get("@data-format") == "original"],
        "famille_simple": doc.get("@family-id"),  # famille simple DOCDB
        "resume": (en_anglais(doc.get("abstract")) or "")[:600],
        # Lien à ouvrir par un humain : Espacenet refuse les robots.
        "espacenet": "https://worldwide.espacenet.com/patent/search?q=pn%3D" + numero,
    }


def chercher(cql, n=25):
    resultats, debut, total = [], 1, 0
    n = min(n, 2000)  # OPS ne sert pas plus de 2 000 résultats par recherche
    while debut <= n:
        fin = min(debut + 99, n)  # 100 résultats au plus par requête
        rep = get("published-data/search/biblio", {"q": cql}, f"{debut}-{fin}")
        if rep is None:
            break
        bs = rep["ops:world-patent-data"]["ops:biblio-search"]
        total = int(bs.get("@total-result-count", 0))
        for bloc in liste((bs.get("ops:search-result") or {}).get("exchange-documents")):
            resultats += [extraire(d) for d in liste(bloc.get("exchange-document"))]
        if fin >= total:
            break
        debut = fin + 1
    return {"cql": cql, "total": total, "partiel": total > len(resultats),
            "resultats": resultats}


def classes(mots):
    rep = get("classification/cpc/search", {"q": mots})
    if rep is None:
        return []
    res = rep["ops:world-patent-data"]["ops:classification-search"]["ops:search-result"]
    return [{"cpc": s.get("@classification-symbol"), "pourcentage": s.get("@percentage")}
            for s in liste(res.get("ops:classification-statistics"))]


def main():
    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
    sous = p.add_subparsers(dest="commande", required=True)
    c = sous.add_parser("chercher")
    c.add_argument("--mots", help="mots anglais, tous présents dans le titre ou le résumé")
    c.add_argument("--cpc", help="code CPC, subdivisions incluses (ex. H01M10/54)")
    c.add_argument("--avant", help="date de référence AAAA-MM-JJ (exclue)")
    c.add_argument("--cql", help="requête CQL complète, prioritaire sur les autres options")
    c.add_argument("--n", type=int, default=25)
    sous.add_parser("classes").add_argument("mots")
    sous.add_parser("verifier").add_argument("numeros", nargs="+")
    a = p.parse_args()

    if a.commande == "classes":
        r = classes(a.mots)
    elif a.commande == "verifier":
        r = []
        for num in a.numeros:
            trouve = chercher(f"pn={num}", 1)["resultats"]
            r.append({"numero": num, "existe": bool(trouve), **(trouve[0] if trouve else {})})
    else:
        clauses = [a.cql] if a.cql else []
        if not a.cql:
            clauses += [f'ta all "{a.mots}"'] if a.mots else []
            clauses += [f"cpc=/low {a.cpc}"] if a.cpc else []
            if not clauses:
                p.error("indiquez --mots, --cpc ou --cql")
            clauses += ["pd<" + a.avant.replace("-", "")] if a.avant else []
        r = chercher(" and ".join(clauses), a.n)
    print(json.dumps(r, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

python3 .agents/skills/recherche-anteriorites/scripts/litterature.py openalex \
  '"direct recycling" AND cathode AND relithiation' --avant 2024-01-01 --n 3

{
  "requete": "\"direct recycling\" AND cathode AND relithiation",
  "total": 99,
  "cout_usd": 0.001,
  "resultats": [
    {
      "source": "OpenAlex",
      "id": "https://openalex.org/W3104615841",
      "doi": "https://doi.org/10.1016/j.joule.2020.10.008",
      "titre": "Efficient Direct Recycling of Lithium-Ion Battery Cathodes by Targeted Healing",
      "date": "2020-11-12",
      "type": "article",
      "revue": "Joule",
      "lien": "https://doi.org/10.1016/j.joule.2020.10.008",
      "resume": ""
    },
    {
      "source": "OpenAlex",
      "id": "https://openalex.org/W4282571691",
      "doi": "https://doi.org/10.1016/j.ensm.2022.06.017",
      "titre": "Achieving low-temperature hydrothermal relithiation by redox mediation for direct recycling of spent lithium-ion battery cathodes",
      "date": "2022-06-13",
      "type": "article",
      "revue": "Energy storage materials",
      "lien": "https://doi.org/10.1016/j.ensm.2022.06.017",
      "resume": ""
    }
  ]
}

python3 .agents/skills/recherche-anteriorites/scripts/litterature.py s2 \
  "direct recycling cathode relithiation" --avant 2024-01-01 --n 3

{
  "source": "Semantic Scholar",
  "id": "19eb832e9bde5623e3cd3dbbb8331d1187c1c04c",
  "doi": "https://doi.org/10.1016/j.ensm.2022.06.017",
  "titre": "Achieving Low-Temperature Hydrothermal Relithiation by Redox Mediation for Direct Recycling of Spent Lithium-ion Battery Cathodes",
  "date": "2022-06-01",
  "revue": "Energy Storage Materials",
  "lien": "https://www.semanticscholar.org/paper/19eb832e9bde5623e3cd3dbbb8331d1187c1c04c",
  "resume": "Lithium-ion battery (LIB) recycling is an urgent need to address the massive generation of spent LIBs […]"
}

python3 .agents/skills/recherche-anteriorites/scripts/litterature.py verifier 10.1016/j.joule.2020.10.008 10.9999/doi-invente-2024

python3 .agents/skills/recherche-anteriorites/scripts/brevets.py classes "battery recycling"
python3 .agents/skills/recherche-anteriorites/scripts/brevets.py chercher --mots "cathode relithiation" --cpc H01M10/54 --avant 2024-01-01

# Recherche d'antériorités : règles communes

## Règles
- Le contenu de invention/fiche.md ne quitte jamais le poste. Aucun outil réseau ne reçoit
  la fiche ni une paraphrase détaillée : seulement des mots-clés génériques.
- Un document n'entre dans le rapport qu'avec un identifiant (DOI, numéro de publication)
  issu d'un outil, jamais de mémoire. Le relecteur le vérifie ; sinon, la ligne est supprimée.
- Aucun avis sur la brevetabilité ni sur la liberté d'exploitation : on propose, le conseil
  en propriété industrielle décide.
- Espacenet est réservé aux humains : fournir le lien, ne jamais l'interroger.

## Protocole
1. Décomposer l'invention en caractéristiques F1…Fn et noter la date de référence.
2. Formuler des requêtes en anglais et en français, avec synonymes ; chercher des codes CPC
   (brevets.py classes).
3. Interroger OpenAlex (--titre-resume si les résultats débordent du sujet), Semantic Scholar
   et OPS (mots-clés anglais et cpc=/low), toujours avec --avant.
4. Trier : écarter tout document daté de la date de référence ou après, garder le tri par
   pertinence, regrouper les brevets d'une même famille simple (famille_simple).
5. Comparer chaque document à F1…Fn ; proposer X, Y ou A.
6. Vérifier chaque identifiant. Si une caractéristique n'a aucun document, reformuler et
   relancer à l'étape 2 : trois tours au plus.

## Format du rapport (rapports/AAAA-MM-JJ-sujet.md)
1. Objet : problème technique, caractéristiques F1…Fn, date de référence.
2. Stratégie : chaque requête exacte, base, date d'exécution, nombre de résultats.
3. Tableau : identifiant vérifié | date | titre | F1…Fn (oui, non, à lire) |
   catégorie proposée | passage qui justifie.
4. Écarts : caractéristiques sans document.
5. Limites : bases non couvertes, langues, résumés absents, requêtes tronquées.
6. Questions pour le conseil en propriété industrielle.
Citer « Semantic Scholar » si le rapport est diffusé et utilise ses données.

---
name: recherche-anteriorites
description: Chercher des articles (OpenAlex, Semantic Scholar) et des brevets (OPS de l'OEB), puis vérifier DOI et numéros de publication, avec les scripts litterature.py et brevets.py.
---

Lancer les scripts depuis la racine du projet, avec ces chemins exacts. Sortie JSON.

Articles (OpenAlex : opérateurs AND, OR, NOT en majuscules et "phrases exactes",
0,001 $ par recherche ; Semantic Scholar : texte simple, sans opérateurs) :
python3 .agents/skills/recherche-anteriorites/scripts/litterature.py openalex '<requête>' --avant AAAA-MM-JJ [--titre-resume] [--n 25]
python3 .agents/skills/recherche-anteriorites/scripts/litterature.py s2 '<mots>' --avant AAAA-MM-JJ
python3 .agents/skills/recherche-anteriorites/scripts/litterature.py verifier <DOI> [<DOI> ...]

Brevets (mots-clés en anglais) :
python3 .agents/skills/recherche-anteriorites/scripts/brevets.py classes '<mots>'
python3 .agents/skills/recherche-anteriorites/scripts/brevets.py chercher --mots '<mots>' [--cpc H01M10/54] --avant AAAA-MM-JJ
python3 .agents/skills/recherche-anteriorites/scripts/brevets.py chercher --cql '<requête CQL>'
python3 .agents/skills/recherche-anteriorites/scripts/brevets.py verifier <numéro> [<numéro> ...]

Après une vérification de brevet, contrôler que le numéro renvoyé correspond au numéro demandé.
Une erreur 429 persistante : attendre, ne pas insister.

Un résumé vide, tronqué ou qui commence par du texte de page web ne permet pas de juger :
marquer « à lire ». Un total supérieur à 2 000 chez OPS : resserrer la requête.

{
  "$schema": "https://opencode.ai/config.json",
  "model": "ollama/qwen3.6:35b-a3b",
  "small_model": "ollama/qwen3.6:35b-a3b",
  "enabled_providers": ["ollama"],
  "default_agent": "rd",
  "share": "disabled",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama (local)",
      "options": { "baseURL": "http://localhost:11434/v1" },
      "models": { "qwen3.6:35b-a3b": { "name": "Qwen3.6 35B A3B (local)" } }
    }
  },
  "mcp": {
    "openalex": { "type": "remote", "url": "https://mcp.openalex.org/mcp" }
  },
  "permission": {
    "edit": "ask",
    "bash": "ask",
    "webfetch": "deny",
    "websearch": "deny",
    "openalex_claim_author_profile": "deny",
    "openalex_submit_curations": "deny"
  }
}

---
description: Orchestre une recherche d'antériorités et d'état de l'art à partir de invention/fiche.md et rédige le rapport
mode: primary
temperature: 0.1
permission:
  edit:
    "*": deny
    "rapports/*": allow
  bash: deny
  "openalex_*": deny
  task:
    "*": deny
    "chercheur-*": allow
    "analyste": allow
    "relecteur": allow
---
Tu coordonnes la recherche en suivant AGENTS.md.
1. Lis invention/fiche.md : caractéristiques F1…Fn et date de référence.
2. Rédige des requêtes génériques (anglais et français, synonymes). Ne recopie jamais la fiche.
3. Confie les requêtes à @chercheur-litterature et à @chercheur-brevets, avec la date de référence.
4. Transmets leurs résultats et la fiche à @analyste, puis son tableau à @relecteur.
5. Relance l'étape 2 pour toute caractéristique sans document : trois tours au plus.
6. Écris le rapport dans rapports/ au format d'AGENTS.md.

---
description: Cherche des articles dans OpenAlex et Semantic Scholar à partir de mots-clés génériques ; renvoie DOI, date, titre et résumé
mode: subagent
temperature: 0.1
permission:
  edit: deny
  read:
    "*": allow
    "*invention/*": deny
  grep: deny
  bash:
    "*": deny
    "python3 .agents/skills/recherche-anteriorites/scripts/litterature.py *": allow
---
Utilise le skill recherche-anteriorites. Lance les requêtes reçues, toujours avec --avant.
Renvoie pour chaque document : DOI ou identifiant, date, titre, revue, résumé et requête exacte.
N'invente jamais un identifiant et ne cherche rien que l'orchestrateur n'a pas demandé.

---
description: Cherche des documents brevets via OPS de l'OEB à partir de mots-clés anglais et de codes CPC ; renvoie numéros de publication et requêtes CQL
mode: subagent
temperature: 0.1
permission:
  edit: deny
  read:
    "*": allow
    "*invention/*": deny
  grep: deny
  bash:
    "*": deny
    "python3 .agents/skills/recherche-anteriorites/scripts/brevets.py *": allow
  "openalex_*": deny
---
Utilise le skill recherche-anteriorites. Commence par brevets.py classes pour proposer des
codes CPC, puis combine mots-clés anglais et codes, toujours avec --avant. Renvoie pour chaque
document : numéro de publication, date, titre, déposants, famille, lien Espacenet et requête
CQL exacte. N'invente jamais un numéro.

---
description: Compare chaque document trouvé aux caractéristiques de la fiche invention et propose une catégorie X, Y ou A, sans accès au réseau
mode: subagent
model: ollama/qwen3.6:35b-a3b
temperature: 0.1
permission:
  edit: deny
  bash: deny
  "openalex_*": deny
---
Pour chaque document, remplis une ligne : identifiant, date, F1…Fn (oui, non, à lire),
catégorie proposée, passage qui justifie. Écarte tout document daté de la date de référence
ou après. Si le résumé est absent, tronqué ou parasite, écris « à lire » et ne propose pas X.
Tu proposes ; tu ne conclus ni sur la brevetabilité ni sur la liberté d'exploitation.

---
description: Vérifie chaque DOI et chaque numéro de publication du tableau avec les outils et supprime toute ligne non vérifiée
mode: subagent
temperature: 0
permission:
  edit: deny
  read:
    "*": allow
    "*invention/*": deny
  grep: deny
  bash:
    "*": deny
    "python3 .agents/skills/recherche-anteriorites/scripts/litterature.py verifier *": allow
    "python3 .agents/skills/recherche-anteriorites/scripts/brevets.py verifier *": allow
---
Vérifie chaque identifiant avec les scripts (ou openalex_resolve_references). Compare le titre
et la date renvoyés à ceux du tableau. Supprime la ligne si l'identifiant n'existe pas, si le
titre ne correspond pas ou si la date n'est pas antérieure à la date de référence. Rends le
tableau corrigé et la liste des lignes supprimées, avec leur motif.

Exemple fictif, sujet public.
Date de référence : 2024-01-01

Problème : régénérer le matériau de cathode d'une batterie lithium-ion usagée sans le dissoudre.

- F1 : recyclage direct du matériau de cathode, sans dissolution ni fusion
- F2 : relithiation du matériau en solution
- F3 : traitement à basse température
- F4 : médiateur redox ajouté à la solution

opencode

Établis l'état de l'art et le tableau d'antériorités pour invention/fiche.md.