Patricia

[!NOTE] Ce dépôt est généré à partir de bettergroupinc/patricia-monorepo à plugins/patricia/. L’automatisation synchronise ce miroir public. Commit source : df2bda0088e804342599b2b58d411e65a4cfd8d7. Ouvrez les demandes de fusion et les tickets dans le monorepo.

Plugin Claude Code patricia

Installez-le une fois, et un agent utilisera correctement le serveur MCP de Patricia sans qu’il soit nécessaire de le lui rappeler.

Il comprend trois éléments.

1. Des instructions. Cinq compétences couvrent les bases de Patricia, l’intégration, le travail délégué, les intégrations et le pont mémoire.
2. Une connexion MCP. L’installation configure le serveur HTTP Streamable de Patricia pour l’authentification OAuth.
3. Cinq hooks locaux. Ils intègrent les projets, rappellent la mémoire, vérifient d’abord les intégrations et proposent des envois de mémoire. Ils n’écrivent jamais dans Patricia.

Il s’agit d’un plugin Claude Code distribuable. Une personne l’installe sur sa propre machine, où il s’exécute dans sa session Claude Code. Ce n’est pas le catalogue de compétences produit de Patricia, et rien de ce plugin ne s’exécute dans Patricia.

Installation

claude plugin marketplace add patricia-app/patricia-plugin
claude plugin install patricia@patricia

Démarrez ensuite une nouvelle session ou exécutez /reload-plugins.

Cette marketplace est https://github.com/patricia-app/patricia-plugin. L’automatisation génère tous les fichiers qu’elle contient à partir du monorepo de Patricia.

Note aux contributeurs : le monorepo est privé. Un contributeur qui y a accès peut ajouter le monorepo lui-même comme marketplace, car son fichier racine .claude-plugin/marketplace.json pointe le plugin patricia vers ./plugins/patricia.

Installez-le. Ne le chargez pas avec --plugin-dir. Un plugin chargé depuis un répertoire récupère ses compétences, mais pas ses hooks : les instructions fonctionneraient, mais le pont mémoire ne se déclencherait jamais. Cela a été mesuré, et non supposé : un hook de test chargé via --plugin-dir ne s’est jamais exécuté, tandis que le même hook déclaré dans les paramètres du projet s’est exécuté lors de la même écriture, dans le même mode sans interface. Claude Code n’enregistre les hooks/hooks.json d’un plugin que si celui-ci est installé et activé.

claude plugin details patricia indique ce qui a été installé :

Component inventory
  Skills (5)  delegating-work, integrations, memory-bridge, onboard, using-patricia
  MCP servers (1)  patricia
  Hooks (5)  SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop

Se connecter au serveur MCP

Le plugin configure le serveur MCP sans en-tête enregistré. Lors de la première utilisation, exécutez /mcp et sélectionnez Patricia. Vous pouvez également lancer le flux OAuth depuis un terminal :

claude mcp login plugin:patricia:patricia

La connexion OAuth au serveur MCP et le jeton personnel pat_mcp_ des hooks sont des identifiants distincts. OAuth seul n’active pas les hooks qui dépendent du jeton.

Utilisez un jeton à la place si OAuth ne convient pas :

claude mcp add --transport http patricia https://api.patricia.app/v1/mcp \
  --header "Authorization: Bearer $PATRICIA_MCP_TOKEN"

Un jeton personnel pat_mcp_ identifie la personne responsable et permet d’écrire. Une clé API de tenant pat_live_ n’identifie personne : elle permet uniquement la lecture et ne peut pas répondre à list_skills ni à list_integrations.

Fournir un jeton personnel aux hooks locaux

Python 3 doit être accessible via la commande python3 pour les hooks locaux.

Créez une clé personnelle pat_mcp_ dans Patricia, sous Settings > AI tools > Advanced > API keys. Choisissez ensuite l’une des méthodes suivantes :

export PATRICIA_MCP_TOKEN="pat_mcp_..."

Ou créez ce fichier à l’emplacement ~/.claude/patricia.json :

{
  "token": "pat_mcp_..."
}

PATRICIA_MCP_TOKEN a priorité sur le fichier. Une valeur vide pour PATRICIA_MCP_TOKEN désactive le recours au fichier. Ce comportement est intentionnel. Il permet de suspendre les hooks authentifiés sans déplacer le fichier.

Transférer des fichiers d’espace de travail

Le serveur expose 39 outils. Les transferts de fichiers utilisent des modes sur create_file, update_file et read_file.

• Envoyez content ou content_base64 pour une écriture intégrée.
• Déclarez sha256, byte_size et content_type pour un téléversement direct.
• Terminez le téléversement avec son upload_id à usage unique.
• Lisez read_file(as_download_url=true) pour obtenir les métadonnées et une URL GET signée temporaire.

Une déclaration de création nécessite également name et kind. Une déclaration de mise à jour nécessite file_id.

Enregistrez le JSON de résultat de la déclaration sous declaration.json, à côté de file.pdf. Utilisez Bash, jq et curl pour envoyer chaque entrée upload_headers renvoyée. La signature lie byte_size : envoyez exactement ce nombre d’octets avec Content-Length ; le transfert par blocs échoue.

declaration=declaration.json
file=file.pdf
mode=$(jq -er '
  if (.upload_id | type == "string" and length > 0) and has("upload_url") then
    if .upload_url == null and .already_stored == true then "reuse"
    elif (.upload_url | type == "string" and length > 0) and .already_stored == false
      and (.upload_headers | type == "object" and all(.[]; type == "string")) then "put"
    else error("Invalid upload declaration") end
  else error("Invalid upload declaration") end
' "$declaration") || { printf 'Invalid upload declaration.\n' >&2; exit 1; }
upload_id=$(jq -r '.upload_id' "$declaration") || exit 1
if [[ "$mode" == put ]]; then
  upload_url=$(jq -r '.upload_url' "$declaration") || exit 1
  headers=()
  while IFS= read -r header; do
    headers+=(--header "$header")
  done < <(jq -r '.upload_headers | to_entries[] | "\(.key): \(.value)"' "$declaration")
  status=$(curl --silent --show-error --output /dev/null --write-out '%{http_code}' \
    --request PUT "$upload_url" "${headers[@]}" --data-binary "@$file") || exit 1
  case "$status" in
    2??|412) ;;
    *) printf 'Upload refused: HTTP %s\n' "$status" >&2; exit 1 ;;
  esac
fi
# A null upload_url skips the PUT and goes straight to completion.
printf 'Complete with upload_id %s before its expiry.\n' "$upload_id"

Le code 412 signifie que les octets ont déjà été déposés à cette clé. Appelez complete avec upload_id avant son expiration. Après un code 412, [invalid_arguments] lors de la finalisation est définitif : envoyez le contenu intégré ou demandez au propriétaire de le partager ; ne faites pas une nouvelle déclaration.

La somme de contrôle est l’encodage base64 des octets bruts du condensat SHA-256. Une URL de téléversement nulle signifie que Patricia peut réutiliser les octets d’un fichier actif auquel cette personne a accès. La finalisation vérifie à nouveau cet accès et confirme les octets stockés. La finalisation des créations utilise uniquement upload_id. Celle des mises à jour utilise file_id et upload_id. Gardez séparés les champs intégrés, les déclarations et les champs de finalisation.

La finalisation renvoie id, version, byte_size, sha256 et, s’il est disponible, console_url. La finalisation d’une création renvoie également sharing_note. Le mode téléchargement renvoie id, version, byte_size, sha256, content_type, download_url et les champs d’expiration. Utilisez l’URL GET signée pour télécharger les octets en dehors de la conversation. La réponse de téléchargement ne contient aucun champ de texte ni de contenu base64. Le contenu de base de données hérité renvoie [download_unavailable] ; la lecture de texte ordinaire reste disponible.

Hooks locaux

Les cinq hooks sont activés par défaut. Si le fichier de configuration ou une clé de hook est absent, le hook reste activé. Une configuration mal formée ou illisible les désactive. Définissez la clé indiquée d’un hook sur la valeur littérale false dans ~/.claude/patricia-plugin.json pour désactiver uniquement ce hook.

Intégration

• Quand et action : SessionStart s’exécute au démarrage d’une nouvelle session ou à la reprise d’une session. Il salue la personne connectée et propose la compétence d’intégration une fois par projet.
• Coût : avec un jeton, il effectue un appel whoami. Le délai d’expiration réseau est de 3 secondes et celui du hook de 10 secondes.
• Désactivation : définir hooks.onboarding.enabled sur false.
• Confidentialité : avec un jeton, seule la requête authentifiée whoami quitte la machine. Aucun prompt, aucune transcription ni aucun contenu du projet ne quitte la machine via ce hook.

Rappel

• Quand et action : UserPromptSubmit s’exécute avant chaque prompt envoyé. Il ignore les commandes, les réponses courtes, les confirmations et les entrées contenant uniquement du code. Il ajoute des éléments de mémoire pertinents aux prompts admissibles.
• Coût : avec un jeton et un prompt admissible, il effectue un appel search_memory. Le délai d’expiration réseau est de 3 secondes et celui du hook de 8 secondes.
• Désactivation : définir hooks.recall.enabled sur false.
• Confidentialité : il envoie à Patricia jusqu’à 300 caractères du prompt condensé. Ce texte n’est envoyé que si un jeton est configuré.

Vérifier d’abord les intégrations

• Quand et action : UserPromptSubmit vérifie un prompt. PreToolUse vérifie les entrées WebFetch, WebSearch et Bash avant l’exécution de l’outil. Un catalogue local identifie les fournisseurs connus.
• Coût : aucun appel MCP ou réseau n’est effectué et aucun jeton n’est nécessaire. Le délai d’expiration du hook est de 8 secondes pour un prompt et de 5 secondes avant un appel d’outil.
• Désactivation : définir hooks.integrations_first.enabled sur false.
• Confidentialité : rien ne quitte la machine. Le hook vérifie localement le prompt ou l’entrée de l’outil.

Pont mémoire

• Quand et action : PostToolUse s’exécute après Write, Edit ou MultiEdit. Il détecte une note mémoire locale enregistrée et propose remember avec une portée explicite.
• Coût : aucun appel MCP ou réseau n’est effectué. Le délai d’expiration du hook est de 5 secondes.
• Désactivation : définir hooks.memory_bridge.enabled sur false. L’ancien fichier ~/.claude/patricia-memory-bridge.json peut également définir enabled sur false.
• Confidentialité : le script lit la note enregistrée localement et n’envoie rien sur le réseau. Il renvoie à Claude Code le chemin de la note et le texte du rappel, sans le contenu de la note.

Rappel d’envoi

• Quand et action : Stop s’exécute lorsque l’agent a terminé. Il propose remember après une écriture de mémoire locale ou une session substantielle utilisant des outils sans écriture de mémoire dans Patricia.
• Coût : aucun appel MCP ou réseau n’est effectué. Le délai d’expiration du hook est de 8 secondes.
• Désactivation : définir hooks.push_reminder.enabled sur false.
• Confidentialité : il lit au maximum 5 Mo de la transcription locale et n’envoie rien. Il ne s’exécute que lorsqu’un jeton est configuré, afin que l’appel mémoire proposé puisse aboutir après l’accord de la personne.

Réseau et identifiants

Ce plugin se connecte à https://api.patricia.app/v1/mcp via HTTP Streamable.

Patricia utilise OAuth 2.1 avec PKCE S256. Un flux OAuth terminé fournit au client un jeton porteur personnel pat_mcp_.

Le manifeste du plugin ne contient aucun identifiant. Après la connexion, le client envoie le jeton porteur à api.patricia.app.

Autres marketplaces

• Cursor lit plugin.json et mcp.json dans ce package.
• OpenAI Codex et ChatGPT lisent .codex-plugin/plugin.json.
• Une entrée de source distante ne nécessite aucun manifeste. xAI lit .claude-plugin/plugin.json lorsqu’il est présent.

Tous les packages de marketplace pointent vers l’unique arborescence skills/ de ce package.

assets/icon.png est une ressource de marque officielle de Patricia.

Le pont mémoire propose ; il n’écrit jamais

Un hook est une commande shell. Il ne possède aucun client MCP, n’a obtenu le consentement de personne et ne peut pas lire une note pour distinguer un fait d’équipe d’une information privée. Un hook qui enverrait chaque note locale vers un espace de travail partagé exposerait silencieusement à toute l’équipe des notes propres à une machine, éphémères et privées. Le pont est conçu pour éviter ce problème, et non pour reporter cette fonctionnalité.

Le hook ne fait donc qu’une chose : il injecte hookSpecificOutput.additionalContext pour indiquer à l’agent que la note est uniquement locale et que remember nécessite un scope. L’agent décide de la portée, demande l’accord de la personne et effectue l’appel. Le jugement et l’écriture restent au même endroit.

Quatre garde-fous le maintiennent silencieux :

Garde-fou	Effet
L’une ou l’autre des configurations prises en charge définit la valeur enabled du pont sur false	Silencieux. Sans cette valeur, le pont est activé.
Le chemin écrit se trouve en dehors d’un répertoire mémoire	Silencieux.
L’écriture n’a pas abouti ou le fichier est vide	Silencieux.
Le front matter de la note contient patricia: skip	Silencieux.

Il ne propose également une note donnée qu’une seule fois par session. Ainsi, un Write suivi d’une série d’appels Edit produit un seul rappel, et non quatre. Cet enregistrement se trouve dans ~/.claude/patricia-memory-bridge-state/, à raison d’un fichier par session, et est supprimé après sept jours.

Il n’utilise pas CLAUDE_PLUGIN_DATA à cette fin. Cette variable est présente dans l’environnement d’un hook, mais elle ne correspond pas de manière fiable au répertoire du plugin en cours d’exécution : un hook au niveau du projet sur cette machine l’a vue définie sur ~/.claude/plugins/data/codex-openai-codex, le répertoire de données d’un plugin sans rapport.

Quel outil est réellement utilisé pour écrire une mémoire

Claude Code 2.1.238 déclare des outils nommés memory_list, memory_read et memory_write. Sur les machines pour lesquelles ce plugin a été conçu, les notes mémoire ne sont pas écrites avec ces outils : l’examen des 120 transcriptions de session les plus récentes a révélé 49 appels Write et 35 appels Edit vers ~/.claude/projects/*/memory/, et aucun appel memory_write.

Le détecteur est donc Write|Edit|MultiEdit. memory_write est volontairement exclu. Ajouter un détecteur pour un outil dont la structure de charge utile n’a pas été vérifiée donnerait un hook qui ne se déclenche jamais en silence et qui ressemble exactement à un hook fonctionnel. Ajoutez-le lorsqu’une véritable charge utile memory_write aura été examinée.

Les instructions et la règle permanente du serveur ne sont qu’une seule copie

start_onboarding_import peut renvoyer un standing_rule_to_offer contenant ask_first, instruction et un bloc markdown dimensionné pour tenir dans le CLAUDE.md d’une autre personne. La compétence ne répète pas ce bloc. Elle indique à l’agent d’appeler l’outil et d’utiliser le résultat, afin que le serveur reste l’unique responsable de cette formulation.

Le récupérer au moment de l’installation était l’autre possibilité, mais elle ne fonctionne pas. Le SKILL.md d’un plugin est un texte statique dans un cache adressé par contenu ; aucune étape à l’installation ne peut le réécrire, et un plugin chargé de configurer Patricia ne peut pas dépendre d’une connexion authentifiée fonctionnelle à Patricia pour afficher ses propres instructions. Lire l’outil au moment de son utilisation fournit la même copie unique, sans ces problèmes.

Chaque nom d’outil ici correspond à un véritable outil

Chaque identifiant d’outil entre accents graves de ce plugin est comparé au registre d’outils propre au serveur, la liste que le serveur construit tools/list. Cette même vérification confirme qu’elle a trouvé un ensemble non vide d’identifiants, afin qu’un extracteur défectueux ne puisse pas réussir en ne trouvant rien.

Note aux contributeurs : cette vérification est backend/api/tests/test_patricia_claude_plugin.py dans le monorepo de Patricia, et elle s’exécute à chaque modification de ce plugin.

Paramètres et découverte des fichiers

Outil	Utilisation
get_settings	Lister les paramètres, ou lire les clés ou groupes sélectionnés avec leurs significations, valeurs et autorisations. Les deux types d’identifiants peuvent lire les groupes de l’espace de travail.
update_settings	Modifier un groupe autorisé via l’opération du tableau de bord. Un jeton personnel est requis.
list_files	Lister les fichiers. La première page inclut les dossiers et les nombres filtrés selon la visibilité.
get_brand_kit	Lire les couleurs de marque, la typographie et les logos.

Utilisez get_settings(keys=["company_profile"]) pour le profil de l’entreprise. Les outils de paramètres partagent le catalogue et les opérations que Patricia utilise dans le chat. Les modifications des paramètres dans le chat nécessitent un clic de la personne qui en fait la demande. Une modification de la politique d’approbation affecte les exécutions dans la console ; les actions critiques et celles requises par le fournisseur conservent leur seuil d’approbation, et les seuils liés à l’audience et au clic seul restent en vigueur pour toute action que Patricia demande déjà.

Les lectures d’intégration attendent pendant qu’une autre tâche s’exécute pour la même personne. Interrogez cette tâche avec get_task_status, ou attendez qu’elle se termine. Après une approbation directe d’intégration, suivez la phrase next renvoyée par decide_approval. Interrogez get_task_status avec l’identifiant de la tâche pour obtenir le résultat. N’appelez pas l’outil à nouveau ; Patricia exécute l’action approuvée une seule fois. Un appel après la fin de l’action constitue une nouvelle demande ; les règles d’approbation en vigueur déterminent si une approbation préalable est requise. Suivez l’instruction next : les examens et approbations enregistrés dans Billit sans identité de demandeur stockée peuvent nécessiter de refaire le même appel.