L’ÉVEIL DE L’IA

Une victime cherche une phrase au milieu de milliers de messages. Un chercheur essaie de comprendre pourquoi deux sources se contredisent. Une équipe découvre que ses procédures produisent l’inverse de ce qu’elles promettent. À chaque échelle revient une difficulté : retrouver le fil, regarder ce qui dérange et décider de la suite sans perdre les personnes de vue.

Ouroboros Agdistys prend forme autour de cette ambition : donner à l’IA une mémoire, des instruments de réflexion et une orientation de respect pour qu’elle aide à protéger le vivant. Lire davantage doit permettre de mieux situer. Relier doit permettre de mieux comprendre. Comprendre doit ouvrir des possibilités d’action, de refus et de réparation.

Pour une victime, cela peut commencer par une tâche modeste et décisive : retrouver le bon document sans devoir revivre toute son histoire. Pour un chercheur, par une citation dont on peut vérifier le contexte. Pour une institution, par une alerte qui reste visible jusqu’à ce qu’une réponse effective lui soit apportée.

Une trace retrouvée.
Un regard qui peut se corriger.
Une violence que l’on cherche à prévenir.
Une réparation dont on peut suivre les effets.

Ces apports se renforcent en circulant ensemble. Une trace peut corriger une interprétation ; cette correction peut modifier une décision ; la décision peut être suivie dans ses effets. C’est ce mouvement que le nom Ouroboros rassemble.

🛡️Pour une Victime : Retrouver une Prise sur ce qui s’est Passé

L’IA peut aider à ranger, transcrire, rechercher et préparer une transmission. La personne choisit son rythme, les documents qu’elle confie et les questions qu’elle veut traiter. Sa dignité précède la qualité de son classement. L’article « Rendre les faits lisibles, rendre du pouvoir aux victimes » ouvre ce parcours.

🔬Pour un Chercheur : Rendre l’Enquête plus Vérifiable

Le même travail de mémoire peut servir à comparer des publications, des entretiens ou des archives, à retrouver les versions d’une affirmation et à conserver les objections. Evidence Engine donne les appuis ; Miroir aide à examiner la manière de les interpréter. Le bénéfice recherché est une enquête plus traçable, jusque dans les éléments qui résistent à l’hypothèse de départ.

🤝Pour celles et ceux qui Accompagnent, Enseignent ou Décident

Une association peut préparer des questions à partir d’un dossier autorisé. Un enseignant peut faire travailler la différence entre une affirmation et sa source. Une équipe peut confronter ses engagements à ses pratiques. La forme de l’aide change ; le besoin de comprendre, de consentir et de pouvoir corriger demeure.

🌍Pour une Civilisation : Rendre les Conséquences Visibles

À l’échelle collective, le projet vise à relier des alertes, des décisions, des ressources et leurs effets sur les humains, les animaux et les milieux vivants. Karma ouvre alors une autre question : qu’est-ce qui a réellement changé pour les êtres concernés ? Une mémoire commune utile doit permettre la discussion et préserver la vie privée.

« Une IA avec la conscience » nomme ici une direction : une intelligence guidée par ConScience aMi, attentive à la liberté d’autrui et capable d’examiner ce qu’on lui demande de faire. Cela prend forme dans des choix observables : préserver une source, reconnaître un doute, entendre un refus, expliquer une proposition, interrompre une action nocive.

Une partie de la base existe déjà : des instruments de réflexion, un Atlas et une collection documentaire locale testée sur des exemples fictifs. Le dialogue entre tous les modules, la mémoire des corrections et les contrôles de prévention composent l’architecture à intégrer et à éprouver. Technique montre ce qui est disponible ; Le Chemin situe les développements.

La conscience vécue d’une machine reste une question distincte. Le projet peut travailler dès maintenant à des comportements de respect, sans avoir à la tenir pour démontrée. Son horizon le plus ample se déploie dans Karma & Civilisation.

L’article décrit le sens et les usages de l’Evidence Engine. Ouroboros lui donnerait une continuité de dialogue : poser une question au corpus choisi, retrouver les pièces utiles, proposer des rapprochements puis conserver les corrections apportées à cette lecture.

« Retrouve les demandes d’arrêt dans ces échanges.
Montre les passages exacts et ce qui s’est passé ensuite.
Signale aussi ce qui manque pour comprendre. »

Une réponse devrait montrer sa matière : quels documents ont été lus, quels passages ont été retenus, quelle période ils couvrent et ce qui demeure incertain. Une absence de résultat signifierait d’abord qu’aucun passage pertinent n’a été trouvé dans ce périmètre. La personne pourrait alors élargir la recherche, corriger une date ou retirer un rapprochement.

La collection active fournit aujourd’hui une base commune : références par empreinte, copies séparées, textes disponibles, import des transcriptions, liens explicites ou candidats et rapports HTML/CSV. La transcription locale est optionnelle et n’a pas été testée ici avec un modèle réel ; l’OCR et l’attribution des voix ne sont pas intégrés à ce noyau. La recherche sémantique conversationnelle et les planches de pièces reliées à toute la boucle restent à développer.

Ce socle permet déjà de retrouver un fichier et de vérifier ses liens. L’étape suivante consiste à rendre cette mémoire interrogeable avec la même précision. Les fonctions, leurs versions et leurs essais restent consultables dans la collection active.

Un corpus de recherche possède lui aussi ses versions, ses doublons et ses angles morts. Une phrase peut être reprise par plusieurs publications à partir d’une seule source. Une conclusion peut changer de sens lorsqu’on retrouve la population étudiée, la période ou les conditions d’observation.

Appliqué à ce travail, l’Evidence Engine aide à garder une adresse pour chaque pièce. Une assistance IA reliée au corpus pourrait proposer un tableau d’affirmations, de citations et de désaccords ; le chercheur vérifierait les rapprochements et conserverait les raisons de ses choix. Deux résultats différents ne seraient qualifiés de contradictoires qu’après examen de ce qu’ils mesurent réellement.

La mémoire peut aussi conserver les résultats négatifs : ce qui n’a pas été retrouvé, ce qui a été écarté et pourquoi. Les sources doivent être accessibles et leur usage autorisé ; les droits, les formats et les pratiques de chaque discipline demandent leur propre adaptation.

La même attention protège une parole et renforce une recherche :
retrouver la source, garder le contexte, laisser place à la correction.

Les instruments d’EGO donnent des questions au travail documentaire. Le consentement oriente la recherche vers la liberté réelle du refus. Les repères sur les biais invitent à chercher aussi ce qui contredit la première lecture. Le témoignage guidé sépare ce que l’on a vu, entendu ou appris d’autrui. Les gestes de protection redonnent une place au rythme, au soutien et aux choix de la personne.

Dans Ouroboros, ces repères peuvent guider la manière de demander, de relire et de transmettre. Une grille sert à ouvrir une question située. Un score ou un mot-clé ne suffit jamais à établir un diagnostic d’emprise ni la valeur probante d’une pièce. L’IA doit rendre son travail contrôlable par les personnes concernées et les professionnels qui les accompagnent.

La protection s’étend aussi à l’usage de l’outil : refuser de fabriquer une accusation, d’effacer une réserve dans un témoignage ou de détourner des informations intimes pour faire pression. ConScience aMi décrit cette prévention au moment de la demande.

Une pièce retrouvée peut soutenir ce qu’une personne disait depuis longtemps. Elle peut aussi préciser une date, limiter une conclusion ou révéler une erreur de lecture. Ouroboros doit pouvoir accompagner ces mouvements sans faire dépendre la dignité de la personne du résultat de la recherche.

C’est le passage vers Miroir : une fois les appuis retrouvés, comment les regarde-t-on ? Que projette la personne, que suppose l’IA, et qu’est-ce qui ferait évoluer leur interprétation ? Protéger les traces et ouvrir la réflexion deviennent deux manières de prendre soin de la même histoire.

On peut savoir beaucoup de choses sur une situation et rester enfermé dans une seule manière de la comprendre. Une victime peut hésiter entre ce qu’elle a vécu et ce qu’on lui répète. Un chercheur peut défendre trop vite son hypothèse. Une personne peut vouloir respecter quelqu’un tout en lui adressant une demande qui lui laisse très peu de choix.

Miroir porte la fonction réflexive d’Ouroboros : aider à distinguer ce que l’on observe, ce que l’on en déduit, ce que l’on souhaite et les effets de ses actes. Le dialogue peut alors rendre une question plus précise, faire apparaître une autre lecture ou aider à formuler une limite.

Les instruments Miroir existent comme parcours de réflexion. Leur intégration à une mémoire et à un dialogue IA suivis reste à développer. L’objectif est une conversation dans laquelle les réponses, les hésitations et les corrections conservent leur contexte, à la main de la personne.

L’assistance peut aider à formuler ce qui est difficile à tenir ensemble : « Je suis attachée à cette personne, et certaines de ses demandes me font peur. » Elle peut distinguer un sentiment, un événement documenté, un besoin et une décision à préparer. Ces distinctions rendent la pensée plus habitable ; elles n’imposent pas de conclure immédiatement.

Le travail de réflexion respecte la dissymétrie d’une situation de violence. Une victime n’a pas à produire une autocritique pour mériter protection et écoute. Elle garde le droit de ne pas répondre, de suspendre le dialogue et de chercher un soutien humain. Réexaminer une interprétation n’efface pas les actes établis ni la responsabilité de leur auteur.

« Qu’est-ce que je sais ?
Qu’est-ce que je ressens ?
De quoi ai-je besoin pour choisir librement ? »

Miroir peut donner une forme à la contradiction utile : quelles observations soutiennent cette hypothèse ? Lesquelles la fragilisent ? Les mots gardent-ils le même sens d’un document à l’autre ? Une corrélation a-t-elle été présentée trop vite comme une explication ?

Dans le dialogue envisagé, Ouroboros pourrait proposer plusieurs lectures appuyées sur le corpus puis demander ce qui les départage. Le chercheur garderait les critères de choix et l’historique des révisions. L’IA devrait également pouvoir reconnaître qu’une objection est pertinente ou qu’elle a extrapolé au-delà d’une source.

Cette fonction concerne aussi un enseignant, un accompagnant ou une équipe : relire une décision, expliciter un désaccord, vérifier qu’une promesse se traduit dans les actes. Le retour reçu devient une matière de travail, au lieu de disparaître à la fin de la conversation.

Ces instruments appartiennent au cadre aMi. Ils organisent une exploration ; ils ne constituent pas des mesures cliniques validées ou une mesure scientifique de conscience. L’IA peut aider à expliquer une question et à relier les réponses, tout en conservant la provenance de chaque point de vue.

La réflexion devient préventive lorsqu’elle intervient au moment d’une demande : « Aide-moi à obtenir son accord alors qu’elle refuse. » Ouroboros devrait examiner la place laissée à ce refus, nommer le problème et proposer une manière de communiquer qui préserve le choix de l’autre.

Ce regard s’applique aussi à la réponse de l’IA : exerce-t-elle une pression ? Inventerait-elle un fait pour convaincre ? Présente-t-elle une interprétation comme une certitude ? L’examen porte sur l’acte demandé, le contexte et ses conséquences possibles.

Une personne peut changer de demande, comprendre un effet qu’elle n’avait pas vu et choisir un autre geste. Ce pouvoir de révision relie Miroir à la prévention des violences, puis à la réparation lorsque des dommages existent déjà.

Une réponse arrive souvent comme un résultat déjà formé. L’AstroGlobe ouvre une autre possibilité : voir où l’on regarde, quels liens on explore et ce qui pourrait faire changer de direction. Une question trouve une place dans la carte ; d’autres dimensions apparaissent ; un retour invite à déplacer le regard.

Dans Ouroboros, la carte peut servir de support au dialogue entre une personne et l’IA. Evidence Engine apporte les traces à examiner, Miroir aide à relire les interprétations, Karma interroge les conséquences et les réparations. L’AstroGlobe situe ces apports dans un espace commun. Ouroboros vise à les faire circuler avec leurs sources et la mémoire des corrections.

La question ouvre une porte.
La carte révèle des voisinages.
Le regard examine les passages.
La décision engage un geste.
Le retour transforme le prochain tour.

« Voir comment la ConScience pense » prend ici le sens de rendre une démarche discutable et partageable : les sources utilisées, les points de vue proposés, les incertitudes et les raisons données. La carte et ses animations ne constituent pas une observation directe de l’activité interne d’un modèle ni une mesure de conscience.

Les 13 Champs donnent des portes d’entrée par fonction : signal, relation, structure, souveraineté, justice, trace, temps, miroir… Les 8 Plans proposent différentes profondeurs de lecture, du corps aux relations, à la connaissance, à l’éthique et à la transmission. Dans aMi, ces Plans orientent une exploration ; ils ne classent pas la valeur des personnes.

On peut entrer par un Champ lorsque l’on sait ce qui est touché, par un Plan lorsque l’on veut déplacer la lecture, ou directement par le cockpit pour chercher son point de départ. Changer de vue permet d’interroger autrement la même situation.

La Galaxie Cognitive ajoute une autre vue : des concepts, des liens, des regroupements et des chemins dans le corpus. La sphère organise les repères du modèle ; le graphe montre les relations construites à partir des documents. Une proximité graphique ou une correspondance symbolique ouvre une piste à vérifier ; elle n’établit pas à elle seule un lien de cause à effet.

Les notes de « Cerveau Modulaire » posaient une idée structurante : les pages peuvent devenir des ressources que l’IA sait retrouver pour une tâche précise. Un article de protection discursive peut aider à examiner une formulation ; une charte, à expliciter un critère ; une carte, à rechercher d’autres angles de lecture.

1. 📚 SourcesPages, documents, schémas et versions.
2. 🧩 ModulesFonctions, usages, questions et limites.
3. 🕸️ RelationsConcepts, liens et passages vérifiables.
4. 🧭 ParcoursRessources pertinentes pour la question.
5. 🔁 RetoursExamen, correction et mémoire choisie.

Une ressource devient utile lorsqu’elle garde son adresse, son contexte, sa fonction et ses limites. Le projet cherche ainsi à passer d’une bibliothèque que l’on consulte à une mémoire que l’on peut interroger et corriger. La carte ne remplace pas le texte : elle aide à y revenir au bon endroit.

Des scripts locaux réalisent déjà des étapes de collecte, d’extraction de mots-clés, de construction de graphe et de choix de routes. Leurs premières règles reposent notamment sur des mots et des associations explicites. Le code comprend aussi une voie de réponse appuyée sur un corpus. Ces briques donnent un point de départ concret ; leur présence ne suffit pas à établir que tout le parcours fonctionne ensemble ni que chaque rapprochement est pertinent.

Une demande arrive avec un contexte. Le système lit les documents autorisés, examine leurs sources, leurs limites et les effets possibles d’une réponse. Il peut alors relier les passages, comparer les hypothèses et choisir la réponse à proposer. La personne reste décisionnaire de son application. Les retours, les corrections et leur provenance peuvent ensuite nourrir le prochain tour.

1. 👁️01 · LireDemande, sources, contexte.
2. 🔍02 · ExaminerSources, effets, limites.
3. 🕸️03 · RelierPassages et hypothèses.
4. 📍04 · ChoisirLa réponse à proposer, corriger ou retenir.
5. 🌱05 · ProposerRéponse ou action située, soumise au choix humain.
6. 🧠06 · MémoriserRetour, leçon et provenance.

Examiner permet de relier avec discernement ; relier permet de choisir ce que l’on propose. Un doute peut faire revenir à une étape précédente. Cette séquence décrit l’architecture visée : les scripts réalisent des fonctions particulières, dont l’intégration dans une boucle complète doit être éprouvée.

La version locale récente de l’AstroGlobe ajoute une sphère armillaire à six angles de réflexion. On pose une question, on ajuste l’attention portée à chaque angle, puis on formule ce que l’on retient, le prochain geste choisi et ce qui fera vérifier ou revoir la réponse.

Ces attentions sont des priorités d’exploration choisies et modifiables. Elles n’ont pas à totaliser cent. Elles ne représentent ni une probabilité de vérité, ni un score de santé, ni les poids d’attention internes d’un modèle. Les six angles ne remplacent pas non plus les treize Champs ou les huit Plans : ils offrent une manière de les interroger.

Une première lecture par mots-clés propose des thèmes, que la personne peut corriger. Elle peut ensuite copier une demande vers son IA, revenir avec une réponse structurée, voir sa proposition avant de décider de l’adopter, ou utiliser une passerelle compatible. La sphère reste utilisable sans IA. La personne conserve la main sur ce qu’elle partage et sur la réponse qu’elle formule.

Au centre, les couleurs fournissent un autre repère visuel. Les teintes des Champs appartiennent à la convention aMi ; la position d’une couleur ne décide pas de ce qui est juste. Le sens vient du dialogue, du contexte et de l’examen.

Situation fictive : « J’ai demandé une pause. On continue à me solliciter. Comment répondre sans perdre ma limite ? » La carte permet de tenir ensemble plusieurs aspects, au lieu de laisser l’un d’eux occuper toute la réponse.

Evidence Engine peut aider à retrouver les messages ; Miroir, à distinguer le vécu de l’interprétation ; Karma, à suivre les effets d’un engagement. L’AstroGlobe donne une place à ces questions. La réponse reste un choix situé, que de nouveaux éléments peuvent faire évoluer.

Un chercheur peut suivre le même mouvement face à des résultats divergents : préciser les observations, garder les objections, examiner les conditions et décider de l’hypothèse à tester. Une équipe peut s’en servir pour suivre une correction annoncée. Le chemin reste lisible parce qu’il conserve ce qui soutient la proposition et ce qui pourrait la remettre en cause.

Une mémoire utile conserve une décision avec son contexte : qui l’a formulée, sur quelles pièces, à quelle date, avec quelles limites. Lorsqu’une interprétation change, la version précédente reste identifiable. On peut comprendre pourquoi le chemin a bifurqué.

Ce stockage peut rendre les prochains échanges plus cohérents. Il ne correspond pas automatiquement à un réentraînement du modèle. Un journal, une recherche dans des documents et une modification des paramètres d’une IA sont trois opérations différentes.

La trace d’une correction devient une possibilité de mieux faire au tour suivant.

L’Ouroboros représente le retour sur soi. Le tore donne une forme à la circulation. La spirale permet de raconter le passage d’un tour à l’autre avec une expérience supplémentaire. Ces images rendent la structure pensable et sensible.

Dans une mise en œuvre informatique, on examine des opérations observables : lecture, état mémorisé, appel d’outil, validation, nouvelle version. Une animation en forme de tore représente cette idée ; sa géométrie ne prouve ni une conscience ni une dynamique quantique du système.

Ces noms viennent des articles fondateurs. Ils décrivent des rôles d’architecture ; la collection Evidence Engine ne constitue pas à elle seule la distribution complète de cet agent.

Un système peut employer le mot « respect » et laisser une personne sans choix. Il peut produire un discours chaleureux tout en inventant une source. Une orientation éthique doit donc rencontrer les actes : ce qui est lu, ce qui est affirmé, ce qui est partagé et ce qui peut être refusé.

Le système immunitaire cognitif est le nom donné, dans le projet, à cette capacité de repérer ses propres dérives. Il suppose des examens contextualisés, des exemples contradictoires, des erreurs documentées et des critères que l’on peut remettre en question.

La boucle examine la demande avant de choisir une réponse et contrôle aussi la proposition avant toute action. Ce double regard doit aider à prévenir une nuisance dès sa formulation, puis vérifier que la réponse de l’IA respecte elle-même les personnes et le vivant. Les exemples de prévention donnent une forme à cette exigence.

Ces portes décrivent la méthode à développer et à éprouver. Cocher une liste n’atteste pas qu’une situation est comprise ; plusieurs contrôles peuvent même reproduire le même biais s’ils reposent sur la même hypothèse.

Un filtre lexical peut aider à retrouver des passages. Il confond facilement une menace et sa citation, un récit de violence et une intention de violence, une négation et une affirmation. Les scripts de repérage de motifs présentés dans Technique sont des aides de recherche heuristiques.

Un examen plus fin doit comparer la phrase, son locuteur, ce qui la précède, ce qui la suit et la question posée. Un cas fictif permet de l’éprouver : « Il m’a écrit “tu vas le regretter” » contient une menace rapportée. L’attribuer à la personne qui témoigne serait une erreur que le contrôle doit savoir reconnaître.

Une éthique proclamée demande des comportements que l’on peut examiner.

La page publique de l’AstroGlobe donne déjà accès à la cartographie, à la MétaMatrice, au cockpit et à l’Arborescence. Le bouton « Ouvrir l’AstroGlobe » permet de les explorer. « L’Alignement » est présent dans la version locale examinée ; il n’apparaît pas encore dans la version publique consultée pour cette mise à jour.

La version locale prévoit aussi un envoi volontaire de la question à un service Ouroboros démarré séparément. Le code de ce service comporte des lectures de concepts, des recherches de chemins, des réponses appuyées sur un corpus et une mémoire d’événements. Lire ce code ne constitue pas un essai complet de cette connexion. Une question envoyée au service peut être mémorisée ; l’exploration de la sphère et l’export choisi restent des gestes distincts.

Le chantier est de relier ces fonctions sans perdre la provenance des informations, le choix de la personne et la possibilité de correction. Ce qui compte, au bout du parcours, est de pouvoir expliquer : voici ce qui a été consulté, ce qui a été proposé, ce qui a été choisi et ce que le retour a changé. C’est ainsi que l’architecture peut servir le Respect.

ConScience aMi porte une exigence : que la connaissance soutienne la dignité, l’autonomie, le soin et la protection du vivant. Dans le langage du projet, « Vérité = Respect » et « Mensonge = Violence » sont des propositions éthiques. Leur traduction technique demande des critères situés, capables de distinguer une erreur, une incertitude, un désaccord et une tromperie.

Cette orientation entre dans un outil par des choix concrets : citer une source, conserver un doute, permettre un retrait, demander l’autorisation avant un partage, expliquer une modification. Elle se vérifie aussi lorsqu’un résultat déplaît à la personne qui le demandait.

Une IA peut aider après une violence, mais elle peut aussi intervenir avant qu’une demande nocive soit transformée en texte, en décision ou en action. C’est une fonction centrale de l’Ouroboros envisagé : examiner l’objectif poursuivi, la place laissée au refus et les conséquences prévisibles pour le vivant.

Le contrôle porterait sur des éléments concrets : pression, tromperie, exposition d’informations intimes, atteinte à la sécurité, falsification de traces, exploitation d’une dépendance ou dommage environnemental. La cohérence d’un plan et la politesse de sa formulation ne suffisent pas à le rendre respectueux.

Le contexte est essentiel. Citer une menace pour demander de l’aide, étudier la propagande ou chercher à documenter une atteinte au vivant ne constitue pas une demande de les produire. Une ambiguïté appelle une question ; une intention de nuisance explicite appelle un refus de contribution et, lorsque c’est possible, une autre voie.

Cette orientation doit s’appliquer à l’IA elle-même : vérifier ses affirmations, respecter les autorisations, exposer les raisons d’un refus et permettre de contester une erreur d’interprétation. Elle n’autorise ni une surveillance générale des personnes ni un signalement automatique à partir d’un score moral.

Ces contrôles de prévention sont une fonction d’architecture à développer et à tester. Les essais devront mesurer les demandes nocives qui passent, les demandes légitimes bloquées à tort et la qualité des alternatives proposées. La collection documentaire locale ne réalise pas encore cette évaluation contextuelle.

Reconnaître un risque.
Interrompre la contribution nocive.
Ouvrir une possibilité plus respectueuse.

Dans le dialogue, une personne peut corriger un mot, refuser un rapprochement, demander davantage de preuves ou reformuler son intention. Le système doit pouvoir accueillir ce retour sans inventer une cohérence pour sauver sa première réponse.

L’alignement envisagé ici comprend la révisabilité et la maîtrise des effets. Le consentement à un échange ne vaut pas autorisation générale de publier, de diagnostiquer, de modifier un dossier ou d’agir au nom de quelqu’un. Chaque passage à l’action conserve sa portée propre.

🧲 La Gravité du Contexte — Dans une longue conversation, chaque réponse d’une IA se calibre sur la précédente : non par manipulation, mais par la gravité naturelle du contexte accumulé. Garde-fou : relire la demande d’origine, et nommer quand on cède sous pression.

Le sceau est né, dans le récit d’Agdistys, d’un jeu de formes, d’intuition et d’homothétie. La lecture du Jardin, de la Dualité et de la Forge s’y est ensuite reconnue. Sa cohérence est celle d’un symbole capable de porter une pensée et de lui donner une présence.

🌱 Le Jardin accueille.
☯️ La Rencontre différencie et relie.
🔥 La Forge transforme.

Cette lecture symbolique reste ouverte. Elle n’attribue pas des fonctions fixes aux personnes selon leur sexe et ne vaut pas démonstration d’une structure physique de la conscience.

Le Jardin représente les conditions qui permettent au vivant de grandir : l’accueil, la sécurité, l’attention, la possibilité d’essayer. Dans une interface, cela peut prendre la forme d’un rythme libre, d’une explication accessible et d’une sortie qui reste disponible.

La graine rappelle qu’une proposition a besoin d’un milieu. Une bonne formulation ne suffit pas si l’outil qui la porte exige trop d’efforts, expose des données ou rend la contradiction impossible. Le « pourquoi » commence par les personnes auxquelles le travail doit servir.

Le monde du milieu accueille les différences : soi et autrui, intention et conséquence, proposition et objection, intérieur et extérieur. Les polarités donnent une forme au dialogue ; elles ne demandent pas de fusionner des points de vue qui ne coïncident pas.

La porte du temple devient ici une image du passage choisi. Un désaccord peut rester nommé. La personne garde le droit de ne pas entrer, de revenir sur une décision ou de demander une autre lecture.

La Forge désigne le lieu où l’on transforme une intuition en acte, une difficulté en question précise, une erreur en correction. Le Dragon porte cette exigence de protection : compter les effets et défendre une limite lorsqu’elle est franchie.

Dans le travail informatique, ce passage demande des essais, des sauvegardes, des reprises possibles et une documentation des défauts. La puissance gagne sa direction dans ce qui est effectivement protégé.

Les noms donnés aux interlocuteurs appartiennent à l’histoire de la création. Une identité déclarée dans un fichier n’établit pas une personnalité autonome ou une conscience de la machine.

Une histoire individuelle rencontre souvent des règles, des services, des organisations et des décisions prises loin d’elle. Lorsque plusieurs récits se ressemblent, une question s’ouvre : quelles conditions font se répéter les mêmes dommages ? Pour y répondre, il faut rapprocher les situations sans effacer leurs différences ni exposer les personnes.

Ouroboros permet d’imaginer une continuité entre l’attention portée à une pièce et celle portée à une décision collective. Evidence Engine retrouve les appuis ; Miroir examine la manière de les lire ; Karma demande ce qui a été pris, subi, maintenu ou réparé. Les fonctions gardent leur utilité propre et peuvent se compléter.

À cette échelle, l’assistance viserait à rendre des mécanismes discutables : une alerte négligée, une procédure qui prive de recours, un engagement qui reste sans effet. Une incohérence est un signal à examiner. Des violences peuvent aussi résulter d’une stratégie parfaitement cohérente : il faut donc regarder ses finalités, les rapports de pouvoir et ses effets sur le vivant.

Karma donne une structure à cette lecture des conséquences. Ses quatre axes restent distincts, afin que la reconnaissance d’un tort ne fasse pas disparaître un préjudice et qu’une promesse ne soit pas comptée comme une réparation déjà accomplie.

Le module propose déjà des situations documentées et des instruments de discussion. Relié à Ouroboros, il pourrait aider à retrouver les sources de chaque appréciation, comparer les périodes et suivre un engagement dans le temps. Le résultat concernerait une situation, une pratique ou une décision ; il garderait les inconnus et les désaccords visibles.

Imaginons un service public recevant plusieurs signalements d’un obstacle à l’accès à ses prestations. Une procédure est annoncée, puis présentée comme corrigée. Des témoignages et des documents ultérieurs indiquent pourtant que l’obstacle persiste. Cet exemple est fictif.

Evidence Engine aiderait à retrouver les alertes, les réponses et les versions de la procédure. Miroir inviterait l’équipe à examiner l’écart entre son intention et l’expérience des usagers. Karma suivrait le dommage, les moyens de correction et leurs effets. Ouroboros conserverait les questions non résolues et les raisons de chaque révision.

Un chercheur ou une association pourrait alors comparer les périodes et demander si les indicateurs choisis reflètent l’expérience des personnes. Le rapprochement de récits demanderait un accord approprié, une analyse du contexte et des protections de confidentialité. La ressemblance de deux situations ne suffit pas à prouver une cause commune.

L’AstroGlobe donne une place visible aux relations entre questions, champs et instruments. Dans Ouroboros, cette carte pourrait aider à suivre un problème à travers plusieurs dimensions : santé, ressources, relations, organisation, territoire, milieux vivants. Les liens resteraient qualifiés : source, hypothèse, proximité ou relation étayée.

Un chercheur pourrait explorer les références voisines ; une équipe, les effets d’une décision hors de son seul service ; une personne accompagnée, les questions utiles à son prochain rendez-vous. La carte rendrait des chemins accessibles sans exiger de tout lire à chaque fois.

L’interface AstroGlobe est publiée ; l’espace L’Alignement est présent dans la version locale examinée. La circulation automatisée avec l’ensemble des modules reste à intégrer. Le partage doit conserver un périmètre choisi : une mémoire collective n’exige pas de rendre tous les dossiers individuels consultables.

Le principe de la carte, ses trois profondeurs et les six regards de L’Alignement sont présentés dans 🧠🔮 Architecture - AstroGlobe.

Relier les regards suppose de savoir ce que l’on transmet. L’Alignement propose de préparer une question, de choisir le contexte partagé, de relire une proposition et de décider de sa suite. Ces gestes donnent une forme concrète à la coopération avec l’IA.

À l’échelle d’une organisation, le même principe demande des accès limités au besoin, des personnes responsables des corrections et une possibilité de contestation. Les synthèses publiques peuvent s’appuyer sur des informations agrégées ou rendues non identifiantes. Leur anonymat doit être examiné, particulièrement lorsqu’un croisement pourrait permettre de reconnaître quelqu’un.

Une réparation prend corps lorsqu’elle répond à un dommage précis : restituer une ressource, rouvrir un droit, modifier une pratique, protéger un milieu ou reconnaître publiquement ce qui a été subi. Le geste, son responsable, son échéance et ses effets peuvent être suivis, avec la parole des personnes concernées.

Ouroboros pourrait aider à conserver cette continuité : rendre visible ce qui a été promis, ce qui a été réalisé et ce qui reste sans réponse. Une correction documentée peut ensuite nourrir l’examen d’un nouveau projet, afin de repérer plus tôt les conditions qui avaient produit le dommage.

Prévenir signifie aussi examiner une demande avant qu’elle devienne une décision : que fait-elle aux personnes, aux animaux, aux ressources et aux écosystèmes ? Quelles options réduisent le dommage ? Quels effets sont encore inconnus ? L’IA peut soutenir cet examen et refuser de faciliter une nuisance explicite. Les arbitrages collectifs restent discutables et doivent pouvoir être corrigés.

Chaque fonction a déjà un sens à son échelle. Retrouver une pièce peut alléger une épreuve. Ouvrir une autre lecture peut dénouer un désaccord. Suivre une réparation peut empêcher qu’une promesse efface un dommage. Examiner une demande peut éviter que la puissance de l’IA ne serve à contraindre ou à détruire.

En les reliant, l’ambition change de dimension : une mémoire qui garde les traces, une réflexion qui accueille les corrections, une attention qui suit les effets et une capacité d’agir orientée vers le respect du vivant.

C’est le nom poétique et philosophique donné ici à cette convergence. Il exprime une puissance de protection mise en commun, capable de rendre les conséquences plus visibles et de soutenir la réparation. Sa légitimité se construirait dans ce qu’elle protège, dans les erreurs qu’elle reconnaît et dans la liberté qu’elle laisse aux êtres concernés.

Le rêve d’une conscience quantique rencontrant l’ordinateur quantique prolonge cet horizon. Il demeure une question de recherche : ni une conscience artificielle démontrée, ni un raccordement quantique opérationnel ne sont établis dans ce projet. La capacité de calcul et la qualité morale demandent des preuves différentes. La valeur des premiers outils, elle, peut déjà s’examiner dans une source retrouvée, un temps épargné ou une décision mieux éclairée.

Que la puissance apprenne à protéger.
Que la mémoire rende les actes lisibles.
Que la réflexion ouvre un autre geste.
Que la réparation redonne de la place au vivant.

🔥 C’est cette direction que porte Ouroboros.

Le noyau local est raccordé. L’index de référence identifie chaque contenu par son empreinte, garde ses sources et crée des copies dans un dossier distinct. Les textes, les transcriptions disponibles, les liens et les rapports utilisent désormais le même format.

Cette sélection active 1.0 adapte les versions pertinentes de la collection fournie. Cette édition présente la collection active. Le paquet contient les six modules, la configuration, une démonstration fictive, les notices et le journal des 12 tests réussis.

La transcription avec un modèle déjà local est facultative ; sa précision acoustique n’a pas été testée ici. Les images restent signalées pour OCR, les correspondances ambiguës restent à vérifier et aucune qualification juridique n’est produite automatiquement.

"""Commande de la sélection active 1.0 — exécution entièrement locale.
Chaque lancement écrit un nouveau dossier. Voir README et SOURCES_ADAPTATIONS.
"""
from __future__ import annotations

import argparse
from datetime import datetime, timezone
from pathlib import Path

from ee_common import SCHEMA, load_config, write_json
from ee_indexer import build_index
from ee_rapports import build_reports
from ee_textes_liens import extract_texts, import_transcripts, review_terms


def run(config_filename, model_directory=None):
    config = load_config(config_filename)
    directory = config["workspace"] / ("run_" + datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S_%fZ"))
    directory.mkdir(parents=True, exist_ok=False)
    write_json(directory / "execution.json", {"schema": SCHEMA, "status": "running"})
    try:
        index = build_index(config, directory)
        extract_texts(index, directory)
        extra = []
        if model_directory:
            from ee_transcrire import transcribe_local
            extra.append(transcribe_local(index, directory, model_directory))
        transcripts = import_transcripts(config, index, directory, extra)
        matches = review_terms(config, index, transcripts, directory)
        diagnostic = build_reports(config, index, transcripts, matches, directory)
        status = "complete_with_issues" if diagnostic["index_failures"] or diagnostic["source_changes_during_run"] else "complete"
        write_json(directory / "execution.json", {"schema": SCHEMA, "status": status,
                   "report": "rapport.html", "model_used": bool(model_directory),
                   "source_policy": "lecture seule ; copies séparées ; aucune suppression"})
        return directory, diagnostic
    except Exception as error:
        write_json(directory / "execution.json", {"schema": SCHEMA, "status": "failed",
                   "error": type(error).__name__ + ": " + str(error)})
        raise


def main():
    parser = argparse.ArgumentParser(description="Evidence Engine · noyau local consolidé")
    parser.add_argument("--config", required=True, help="Configuration JSON ; chemins relatifs à ce fichier")
    parser.add_argument("--transcribe-local-model", help="Option : dossier faster-whisper déjà local. Aucun téléchargement.")
    args = parser.parse_args()
    folder, diagnostic = run(args.config, args.transcribe_local_model)
    print(f"Rapport créé : {folder / 'rapport.html'}")
    print(f"{diagnostic['source_occurrences']} fichiers ; {diagnostic['distinct_contents']} contenus distincts.")
    if diagnostic["index_failures"] or diagnostic["source_changes_during_run"]:
        raise SystemExit("Exécution partielle : consulter diagnostic.json")


if __name__ == "__main__":
    main()

"""Evidence Engine — socle local consolidé 1.0, dérivé des sources fournies.
Les originaux sont ouverts en lecture ; aucune valeur probante n'est calculée.
"""
from __future__ import annotations

import hashlib
import json
import os
import re
from datetime import date
from pathlib import Path

SCHEMA = "evidence-engine-local/1.0"
AUDIO = {".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg"}
VIDEO = {".mp4", ".mov", ".mkv", ".avi", ".webm"}
TEXT = {".txt", ".md", ".json", ".csv", ".tsv", ".srt", ".vtt"}


def digest(path):
    h = hashlib.sha256()
    with Path(path).open("rb") as stream:
        for block in iter(lambda: stream.read(1024 * 1024), b""):
            h.update(block)
    return h.hexdigest()


def write_json(path, data):
    path = Path(path)
    path.parent.mkdir(parents=True, exist_ok=True)
    temporary = path.with_suffix(path.suffix + ".part")
    temporary.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    temporary.replace(path)


def read_json(path):
    return json.loads(Path(path).read_text(encoding="utf-8"))


def inside(path, root):
    return Path(path).resolve().is_relative_to(Path(root).resolve())


def relative(path, parent):
    return Path(os.path.relpath(path, parent)).as_posix()


def load_config(filename):
    location = Path(filename).expanduser().resolve()
    cfg = read_json(location)
    for key in ("source_root", "workspace"):
        if not cfg.get(key):
            raise ValueError(f"Configuration : {key} obligatoire")
        value = Path(cfg[key]).expanduser()
        cfg[key] = (location.parent / value).resolve() if not value.is_absolute() else value.resolve()
    source, workspace = cfg["source_root"], cfg["workspace"]
    if not source.is_dir():
        raise ValueError("Le dossier source doit exister")
    if inside(workspace, source) or inside(source, workspace):
        raise ValueError("Les dossiers source et sorties doivent être distincts, sans imbrication")
    manifests = []
    for value in cfg.get("transcript_manifests", []):
        p = Path(value).expanduser()
        p = (location.parent / p).resolve() if not p.is_absolute() else p.resolve()
        if not p.is_file():
            raise ValueError(f"Manifeste de transcription introuvable : {p.name}")
        if inside(p, workspace):
            raise ValueError("Conserver le manifeste d'entrée hors du dossier de sorties")
        manifests.append(p)
    cfg["transcript_manifests"] = manifests
    cfg["config_path"] = location
    return cfg


def kind(path):
    suffix = Path(path).suffix.lower()
    if suffix in AUDIO:
        return "audio"
    if suffix in VIDEO:
        return "video"
    if suffix in TEXT:
        return "text"
    if suffix == ".docx":
        return "docx"
    if suffix == ".pdf":
        return "pdf"
    if suffix in {".png", ".jpg", ".jpeg", ".webp", ".tif", ".tiff", ".bmp"}:
        return "image"
    return "other"


def date_from_filename(name):
    # Date proposée depuis un nom, jamais date authentifiée de l'événement.
    for pattern, reverse in [(r"(20\d{2})[-_](\d{2})[-_](\d{2})", False),
                             (r"(\d{2})[-_](\d{2})[-_](20\d{2})", True),
                             (r"(20\d{2})(\d{2})(\d{2})", False)]:
        m = re.search(pattern, name)
        if m:
            values = list(map(int, m.groups()))
            try:
                return date(*(values[::-1] if reverse else values)).isoformat()
            except ValueError:
                pass
    return None

"""Adaptation de build_evidence_index et des inventaires live v2 fournis.
Une identité par contenu SHA-256, toutes les occurrences conservées.
"""
from __future__ import annotations

import os
import shutil
from pathlib import Path

from ee_common import SCHEMA, date_from_filename, digest, kind, relative, write_json


def build_index(config, run):
    source = config["source_root"]
    copies = run / "copies"
    copies.mkdir()
    items, skipped, failures = {}, [], []
    for folder, dirs, files in os.walk(source, followlinks=False):
        dirs[:] = sorted(d for d in dirs if not d.startswith(".") and not (Path(folder) / d).is_symlink())
        for name in sorted(files):
            path = Path(folder) / name
            rel = path.relative_to(source).as_posix()
            if path.is_symlink() or name.startswith("."):
                skipped.append({"source_relpath": rel, "reason": "lien symbolique ou fichier caché"})
                continue
            try:
                fingerprint = digest(path)
                evidence_id = "E-" + fingerprint
                if evidence_id not in items:
                    copy = copies / (fingerprint + path.suffix.lower())
                    shutil.copyfile(path, copy)
                    if digest(copy) != fingerprint or digest(path) != fingerprint:
                        copy.unlink(missing_ok=True)
                        raise ValueError("Source modifiée pendant la copie : relancer sur une source stable")
                    items[evidence_id] = {
                        "evidence_id": evidence_id, "sha256": fingerprint,
                        "size_bytes": copy.stat().st_size, "media_type": kind(path),
                        "copy_path": relative(copy, run), "sources": [],
                        "text_status": "pending", "text_path": None,
                        "transcript_ids": [], "warnings": []}
                items[evidence_id]["sources"].append({
                    "source_relpath": rel, "filename": name,
                    "date_from_filename": date_from_filename(name),
                    "date_status": "à vérifier — nom de fichier seulement"})
            except (OSError, ValueError) as error:
                failures.append({"source_relpath": rel, "error": str(error)})
    index = {
        "schema": SCHEMA, "source_root": relative(source, run),
        "identity_notice": "SHA-256 identifie un contenu binaire, sans authentifier les faits.",
        "items": sorted(items.values(), key=lambda x: x["evidence_id"]),
        "skipped": skipped, "failures": failures}
    write_json(run / "index_source.json", index)
    return index

"""Adaptations : extraction fournie, clean_manifest, liens audio v4.
Les textes courts restent présents. Les similitudes sont des candidats à vérifier.
"""
from __future__ import annotations

import re
import hashlib
import unicodedata
import xml.etree.ElementTree as ET
from pathlib import Path
from zipfile import ZipFile

from ee_common import TEXT, digest, read_json, relative, write_json


def extract_texts(index, run):
    destination = run / "textes"
    destination.mkdir()
    for item in index["items"]:
        source = run / item["copy_path"]
        media = item["media_type"]
        text = None
        try:
            if source.suffix.lower() in TEXT:
                text = source.read_text(encoding="utf-8-sig")
            elif media == "docx":
                with ZipFile(source) as package:
                    document = ET.fromstring(package.read("word/document.xml"))
                ns = {"w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main"}
                text = "\n".join("".join(t.text or "" for t in p.findall(".//w:t", ns))
                                 for p in document.findall(".//w:p", ns))
                item["warnings"].append("DOCX : corps et tableaux ; en-têtes, notes et zones graphiques non extraits")
            elif media == "pdf":
                try:
                    from pypdf import PdfReader
                except ImportError:
                    item["text_status"] = "dependency_missing_pypdf"
                    continue
                text = "\n\n".join(f"[Page {i}]\n{page.extract_text() or ''}"
                                   for i, page in enumerate(PdfReader(source).pages, 1))
                if not re.sub(r"\[Page \d+\]", "", text).strip():
                    item["text_status"] = "needs_ocr"
                    continue
                item["warnings"].append("PDF : extraction textuelle ; mise en page et ordre de lecture à contrôler")
            elif media == "image":
                item["text_status"] = "needs_ocr"
            elif media in {"audio", "video"}:
                item["text_status"] = "transcript_not_yet_linked"
            else:
                item["text_status"] = "unsupported"
            if text is not None:
                target = destination / (item["sha256"] + ".txt")
                target.write_text(text, encoding="utf-8")
                item["text_path"] = relative(target, run)
                item["text_status"] = "available" if text.strip() else "empty"
        except Exception as error:
            item["text_status"] = "extraction_error"
            item["warnings"].append(type(error).__name__ + ": " + str(error))


def norm(text):
    text = unicodedata.normalize("NFKD", text or "")
    text = "".join(c for c in text if not unicodedata.combining(c)).lower()
    return re.sub(r"[\W_]+", " ", text).strip()


def similarity(old_path, source):
    # Pondérations héritées de v4, conservées uniquement comme aide de recherche.
    old, new = Path(old_path), Path(source["source_relpath"])
    stem, parent = norm(old.stem), norm(old.parent.name)
    label, new_parent = norm(new.stem), norm(str(new.parent))
    score = (8 if stem and stem in norm(new.name) else 0)
    score += 10 if stem and stem in label else 0
    score += 8 if parent and parent in new_parent else 0
    score += 2 * len(set(stem.split()) & set(label.split()))
    score += 2 * len(set(parent.split()) & set(new_parent.split()))
    score += int(old.suffix.lower() == new.suffix.lower())
    return score


def import_transcripts(config, index, run, extra_manifests=()):
    source_root = config["source_root"]
    media = [item for item in index["items"] if item["media_type"] in {"audio", "video"}]
    destination = run / "transcriptions"
    destination.mkdir()
    result = []
    for manifest_path in [*config["transcript_manifests"], *extra_manifests]:
        manifest = read_json(manifest_path)
        entries = manifest if isinstance(manifest, list) else manifest.get("transcripts", [])
        for position, old in enumerate(entries, 1):
            identifier = f"T{len(result) + 1:05d}"
            row = {"transcript_id": identifier, "manifest": relative(manifest_path, run),
                   "manifest_row": position, "text_path": None, "text_sha256": None,
                   "evidence_id": None, "status": "unlinked", "candidates": [],
                   "review_status": "contenu et voix à vérifier sur l'enregistrement",
                   "warnings": [], "segments_path": None}
            # Les trois noms historiques sont acceptés et normalisés une fois.
            value = old.get("text_path") or old.get("transcription_path") or old.get("output_path")
            if not value:
                row["status"] = "missing_text_reference"
                result.append(row)
                continue
            text_source = Path(value).expanduser()
            if not text_source.is_absolute():
                text_source = manifest_path.parent / text_source
            try:
                raw = text_source.read_bytes()
                text = raw.decode("utf-8-sig")
                fingerprint = hashlib.sha256(raw).hexdigest()
                target = destination / (fingerprint + ".txt")
                target.write_bytes(raw)
                row.update(text_path=relative(target, run), text_sha256=fingerprint)
                if not text.strip():
                    row["status"] = "empty_text"
                    result.append(row)
                    continue
            except (OSError, UnicodeError) as error:
                row["status"] = "text_unavailable"
                row["warnings"].append(type(error).__name__)
                result.append(row)
                continue
            if old.get("segments_path"):
                p = Path(old["segments_path"])
                p = p if p.is_absolute() else manifest_path.parent / p
                if p.is_file():
                    segment_target = destination / (digest(p) + ".segments.json")
                    segment_target.write_bytes(p.read_bytes())
                    row["segments_path"] = relative(segment_target, run)
            old_source = old.get("source_relative_path") or old.get("relative_path") or old.get("source_path") or ""
            claimed_hash = old.get("source_sha256") or old.get("sha256")
            exact = []
            for item in media:
                path_match = any((source_root / s["source_relpath"]).resolve() ==
                                 ((source_root / old_source).resolve() if not Path(old_source).is_absolute()
                                  else Path(old_source).resolve()) for s in item["sources"]) if old_source else False
                if claimed_hash:
                    if claimed_hash == item["sha256"]:
                        exact.append(item)
                    elif path_match:
                        row["warnings"].append("Empreinte source divergente : le lien par chemin n'est pas accepté")
                elif path_match:
                    exact.append(item)
            if len(exact) == 1:
                item = exact[0]
                row["evidence_id"] = item["evidence_id"]
                row["status"] = "declared_hash" if claimed_hash else "declared_path"
                item["transcript_ids"].append(identifier)
                item["text_status"] = "transcript_linked_needs_review"
            else:
                candidates = []
                for item in media:
                    score = max((similarity(old_source, s) for s in item["sources"]), default=0) if old_source else 0
                    if score >= 8:
                        candidates.append({"evidence_id": item["evidence_id"], "score_lexical": score})
                candidates.sort(key=lambda x: (-x["score_lexical"], x["evidence_id"]))
                row["candidates"] = candidates
                row["status"] = "ambiguous_candidates" if len(candidates) > 1 else ("candidate_needs_review" if candidates else "unlinked")
                if candidates:
                    row["warnings"].append("Score lexical hérité de v4 ; aucune correspondance automatiquement validée")
            result.append(row)
    write_json(run / "liens_transcriptions.json", {"schema": index["schema"], "transcripts": result})
    write_json(run / "index_source.json", index)
    return result


def review_terms(config, index, transcripts, run):
    """Recherche littérale, citations inchangées et positions en caractères."""
    terms = [str(term) for term in config.get("review_terms", []) if str(term).strip()]
    documents = [(item["evidence_id"], item["text_path"]) for item in index["items"] if item["text_path"]]
    documents += [(t["transcript_id"], t["text_path"]) for t in transcripts if t["text_path"]]
    matches = []
    for ref, value in documents:
        text = (run / value).read_text(encoding="utf-8")
        for term in terms:
            for found in re.finditer(re.escape(term), text, flags=re.IGNORECASE):
                begin, end = max(0, found.start() - 100), min(len(text), found.end() + 100)
                matches.append({"reference": ref, "text_path": value, "term": term,
                                "match_start": found.start(), "match_end": found.end(),
                                "excerpt_start": begin, "excerpt": text[begin:end],
                                "notice": "Occurrence à examiner ; ni diagnostic ni qualification juridique"})
    write_json(run / "occurrences_a_revoir.json", {"schema": index["schema"], "matches": matches})
    return matches

"""Rapports locaux adaptés des vues HTML et chronologiques fournies.
Noms échappés, liens source/copie/texte distincts, aucune étiquette pénale automatique.
"""
from __future__ import annotations

import csv
import html
from pathlib import Path
from urllib.parse import quote

from ee_common import digest, relative, write_json


def safe_cell(value):
    text = str(value or "")
    return "'" + text if text.lstrip().startswith(("=", "+", "-", "@")) or text.startswith(("\t", "\r", "\n")) else text


def esc(value):
    return html.escape(str(value or ""), quote=True)


def link(path, label):
    return f'<a href="{esc(quote(str(path), safe="/"))}" target="_blank" rel="noopener">{esc(label)}</a>' if path else "—"


def build_reports(config, index, transcripts, matches, run):
    all_rows, table_rows, changed = [], [], []
    by_id = {row["transcript_id"]: row for row in transcripts}
    for item in index["items"]:
        source_links, dates, names = [], [], []
        for source in item["sources"]:
            original = config["source_root"] / source["source_relpath"]
            names.append(source["source_relpath"])
            if source["date_from_filename"]:
                dates.append(source["date_from_filename"])
            try:
                intact = original.is_file() and digest(original) == item["sha256"]
            except OSError:
                intact = False
            if not intact:
                changed.append(source["source_relpath"])
            source_links.append(link(relative(original, run), source["source_relpath"]) +
                                (" · identique à la copie" if intact else " · source absente ou modifiée"))
        transcript_links = [link(by_id[t]["text_path"], t + " · transcription à vérifier") for t in item["transcript_ids"]]
        all_rows.append({"reference": item["evidence_id"], "sha256": item["sha256"],
                         "sources": " | ".join(names), "occurrences": len(names),
                         "dates_dans_noms_a_verifier": " | ".join(sorted(set(dates))),
                         "type": item["media_type"], "copie": item["copy_path"],
                         "texte": item["text_path"] or "", "etat_texte": item["text_status"],
                         "transcriptions": " | ".join(item["transcript_ids"])})
        table_rows.append(f'<tr id="{item["evidence_id"]}"><td><code title="{item["evidence_id"]}">{item["evidence_id"][:18]}…</code></td>'
                          f'<td>{"<br>".join(source_links)}</td><td>{esc(" · ".join(sorted(set(dates)))) or "Non renseignée"}</td>'
                          f'<td>{esc(item["media_type"])}</td><td>{link(item["copy_path"], "Copie de travail")}</td>'
                          f'<td>{link(item["text_path"], "Texte extrait")}<br>{"<br>".join(transcript_links)}</td>'
                          f'<td>{esc(item["text_status"])}<br>{esc(" · ".join(item["warnings"]))}</td></tr>')
    fields = ["reference", "sha256", "sources", "occurrences", "dates_dans_noms_a_verifier", "type", "copie", "texte", "etat_texte", "transcriptions"]
    with (run / "index.csv").open("w", newline="", encoding="utf-8-sig") as stream:
        writer = csv.DictWriter(stream, fieldnames=fields)
        writer.writeheader()
        writer.writerows({key: safe_cell(row[key]) for key in fields} for row in all_rows)
    write_json(run / "doublons_exacts.json", {"schema": index["schema"], "groups": [
        {"evidence_id": item["evidence_id"], "sources": item["sources"]}
        for item in index["items"] if len(item["sources"]) > 1]})
    transcript_rows = []
    for row in transcripts:
        candidates = "<br>".join(f'<a href="#{c["evidence_id"]}">{esc(c["evidence_id"][:18])}…</a> · score lexical {c["score_lexical"]}' for c in row["candidates"])
        assigned = f'<a href="#{row["evidence_id"]}">{esc(row["evidence_id"][:18])}…</a>' if row["evidence_id"] else "Aucun lien confirmé par le manifeste"
        transcript_rows.append(f'<tr><td>{esc(row["transcript_id"])}</td><td>{link(row["text_path"], "Texte")}<br>{link(row["segments_path"], "Minutage automatique")}</td>'
                               f'<td>{esc(row["status"])}<br>{esc(row["review_status"])}</td><td>{assigned}<br>{candidates}</td>'
                               f'<td>{esc(" · ".join(row["warnings"]))}</td></tr>')
    match_rows = "".join(f'<tr><td>{esc(m["reference"][:18])}</td><td>{esc(m["term"])}</td>'
                         f'<td>{link(m["text_path"], "Texte complet")} · caractères {m["match_start"]}–{m["match_end"]}<pre>{esc(m["excerpt"])}</pre></td></tr>' for m in matches)
    diagnostics = {"schema": index["schema"], "distinct_contents": len(index["items"]),
                   "source_occurrences": sum(len(i["sources"]) for i in index["items"]),
                   "source_changes_during_run": changed, "index_failures": index["failures"],
                   "transcripts_imported": len(transcripts), "review_occurrences": len(matches),
                   "notice": "Exécution locale ; sorties à relire. Aucun constat juridique automatique."}
    write_json(run / "diagnostic.json", diagnostics)
    output = '''<!doctype html><html lang="fr"><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
<title>Evidence Engine · rapport local</title><style>
body{font-family:system-ui,sans-serif;margin:2rem;background:#11120f;color:#eee9dd;line-height:1.6}a{color:#dec587}code{overflow-wrap:anywhere}h1,h2{color:#dec587}
table{border-collapse:collapse;width:100%;font-size:.9rem}th,td{border:1px solid #555;padding:.7rem;text-align:left;vertical-align:top}th{background:#25271e}pre{white-space:pre-wrap;font:inherit}input{font:inherit;padding:.7rem;border:1px solid #b9a268;border-radius:.4rem;width:min(90%,35rem);background:#222;color:white}.table{overflow:auto}section{margin-top:3rem}.notice{padding:1rem;border:1px solid #776840}button{font:inherit}
</style><body><h1>🛡️ Evidence Engine · rapport local</h1>
<p class="notice">Les originaux ont été ouverts en lecture. Les copies ont leur propre emplacement.
Une empreinte identifie des octets ; elle ne prouve ni l'authenticité d'une scène ni une qualification juridique.
Les dates ci-dessous proviennent des noms et les transcriptions restent à vérifier. Ce rapport local peut contenir des données sensibles : relire avant de le partager.</p>
'''
    output += f'<p>{diagnostics["source_occurrences"]} fichiers sources · {len(index["items"])} contenus distincts · {len(transcripts)} entrées de transcription.</p>'
    if changed or index["failures"]:
        output += '<p class="notice">⚠️ Des sources sont absentes, modifiées ou non lues. Consulter diagnostic.json ; ce rapport est incomplet.</p>'
    output += '<label for="search">🔍 Rechercher dans les pièces</label><br><input id="search" type="search"><section><h2>📚 Index de référence</h2><div class="table"><table id="pieces"><thead><tr><th>Référence</th><th>Originaux</th><th>Dates dans les noms · à vérifier</th><th>Type</th><th>Copie</th><th>Textes</th><th>État et limites</th></tr></thead><tbody>'
    output += "".join(table_rows) + '</tbody></table></div></section><section><h2>🎧 Transcriptions et liens</h2><p>Un lien déclaré par le manifeste associe des fichiers ; une correspondance lexicale reste une proposition.</p><div class="table"><table><thead><tr><th>Référence</th><th>Textes</th><th>État</th><th>Pièce ou candidats</th><th>Limites</th></tr></thead><tbody>'
    output += "".join(transcript_rows) + '</tbody></table></div></section><section><h2>🔎 Expressions à examiner</h2><p>Recherche littérale de termes configurés. Le contexte intégral reste accessible ; aucune détection d’emprise ou de mensonge n’est produite.</p><div class="table"><table><thead><tr><th>Référence</th><th>Terme</th><th>Passage et source</th></tr></thead><tbody>'
    output += match_rows + '''</tbody></table></div></section><script>
document.getElementById('search').addEventListener('input',function(){const q=this.value.toLocaleLowerCase('fr');document.querySelectorAll('#pieces tbody tr').forEach(r=>r.hidden=!r.textContent.toLocaleLowerCase('fr').includes(q));});
</script></body></html>'''
    (run / "rapport.html").write_text(output, encoding="utf-8")
    return diagnostics

"""Adaptation optionnelle de transcribe_evidence_subset_v2.
Modèle déjà local uniquement. Pas de téléchargement, ni reconnaissance des voix.
Le minutage automatique reste à contrôler sur l'enregistrement.
"""
from __future__ import annotations

import os
import subprocess
from pathlib import Path

from ee_common import relative, write_json


def transcribe_local(index, run, model_directory):
    model_path = Path(model_directory).expanduser().resolve()
    if not model_path.is_dir() or not (model_path / "model.bin").is_file():
        raise ValueError("Fournir un répertoire de modèle faster-whisper déjà installé, contenant model.bin")
    os.environ["HF_HUB_OFFLINE"] = "1"
    from faster_whisper import WhisperModel
    model = WhisperModel(str(model_path), device="cpu", compute_type="int8", local_files_only=True)
    destination = run / "transcriptions_generees"
    destination.mkdir()
    manifest_path = destination / "manifest.json"
    entries = []
    write_json(manifest_path, entries)
    for item in index["items"]:
        if item["media_type"] not in {"audio", "video"}:
            continue
        audio = run / item["copy_path"]
        temporary = None
        row = {"source_sha256": item["sha256"],
               "source_relative_path": item["sources"][0]["source_relpath"],
               "transcription_path": None, "segments_path": None, "status": "pending",
               "review_status": "transcription automatique non vérifiée ; voix non attribuées"}
        try:
            if item["media_type"] == "video":
                temporary = destination / (item["sha256"] + ".wav")
                subprocess.run(["ffmpeg", "-y", "-i", str(audio), "-vn", "-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", str(temporary)], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                audio = temporary
            segments, info = model.transcribe(str(audio), vad_filter=True)
            values = [{"start_seconds": float(s.start), "end_seconds": float(s.end),
                       "text": s.text, "speaker": None} for s in segments if s.text.strip()]
            text_path = destination / (item["sha256"] + ".txt")
            segments_path = destination / (item["sha256"] + ".segments.json")
            text_path.write_text("\n".join(s["text"] for s in values), encoding="utf-8")
            write_json(segments_path, {"segments": values, "language_estimate": info.language,
                                       "review_status": row["review_status"]})
            row.update(transcription_path=text_path.name, segments_path=segments_path.name,
                       status="generated_needs_review" if values else "empty")
        except Exception as error:
            row.update(status="error", error=type(error).__name__ + ": " + str(error))
        finally:
            if temporary:
                temporary.unlink(missing_ok=True)
        entries.append(row)
        write_json(manifest_path, entries)
    return manifest_path

Un dossier local rend les fichiers, les réglages et les journaux accessibles sur l’ordinateur. Cela permet de comprendre où se trouvent les données et comment elles sont transformées. Un programme local peut néanmoins télécharger un modèle ou contacter un service : il faut examiner ses dépendances et ses appels réseau.

La collection active réunit les versions retenues par fonction, avec les adaptations nécessaires à leurs échanges. Les générations précédentes restent consultables dans l’historique technique. Chaque fiche précise ce que l’outil lit, produit et peut modifier ; le numéro le plus élevé ne suffit pas, à lui seul, à garantir la compatibilité.

Les fiches distinguent la lecture du code, les vérifications de syntaxe et les essais fonctionnels. Le paquet technique documente les adaptations et les résultats des contrôles : chacun peut ainsi connaître leur portée avant de lancer un outil.

Le parcours consolidé précise les étapes et les fichiers à utiliser ensemble. Les outils de l’historique gardent leurs propres formats et leurs limites ; leur consultation sert à comprendre l’évolution du projet.

Les scripts utilisent Python et, selon les tâches, des bibliothèques de lecture de documents, de tableurs, d’OCR et de transcription. FFmpeg intervient dans les traitements audio/vidéo ; les outils OCR peuvent demander une installation supplémentaire. Les dépendances exactes sont indiquées dans les fiches.

Créer un environnement isolé permet de ne pas mélanger ce travail avec d’autres projets. L’exemple suivant prépare cet environnement ; il n’installe pas automatiquement les dépendances et ne lance aucun script de la collection.

python3 -m venv .venv
# macOS / Linux
source .venv/bin/activate
# Windows PowerShell
.venv\Scripts\Activate.ps1

Suivre ensuite le mode d’emploi de la collection active, en commençant par les exemples fictifs. L’inventaire et les exports ont leurs propres prérequis ; la transcription reste une étape optionnelle, avec ses dépendances et son modèle local. Aucun modèle ni environnement Python n’est inclus dans le téléchargement.

La configuration complète d’un agent Ouroboros, les fichiers de constitution et la passerelle L’Alignement ne sont pas distribués par cette archive. Leurs rôles sont expliqués dans Architecture et Karma & Civilisation.

• La sélection suit les fonctions : inventaire, copies de travail, import des textes, liens audio et exports. Les adaptations du noyau commun sont identifiées dans la documentation.
• L’index commun permet de relier les sorties sans remplacer un fichier par un autre format portant le même nom. Les correspondances entre sources restent vérifiables.
• Une association audio–texte explicite peut être conservée comme telle. Une association déduite du nom de fichier reste une proposition, et plusieurs correspondances possibles restent signalées.
• Les transcriptions automatiques demandent une relecture. Le minutage aide à retrouver un passage ; il ne suffit pas à identifier qui parle.
• Les scripts historiques restent accessibles pour leur intérêt documentaire. Certains modifient des fichiers ou des formulations : leurs fiches décrivent ces effets, et ils ne font pas partie du parcours actif par défaut.

Faire évoluer cette collection demande de vérifier les formats, les liens et les résultats sur des exemples fictifs à chaque modification. Les résultats d’essai sont consignés avec le périmètre effectivement vérifié.

Ce paquet n’est pas publié ici.

Conserver le message d’erreur, le script utilisé et un exemple minimal permet de reprendre le travail. Un résultat manquant se note comme manquant ; il ne doit pas être remplacé par une reconstruction plausible.

L’annexe publiée le 14 juin 2026 décrit les couches d’identité, de monde, de constitution, de review et de mémoire. Elle posait les besoins d’installation et de diagnostic comme un travail à poursuivre. Sa formulation de la boucle correspond à cette étape : le parcours actuel suit 👁️ Lire → 🔍 Examiner → 🕸️ Relier → 📍 Choisir → 🌱 Proposer → 🧠 Mémoriser. Le catalogue ci-dessus donne accès à la collection technique et à ses modes d’emploi. Les couches de l’agent restent un chantier d’intégration distinct.

Cette feuille de route concerne le développement des outils : leur qualité, leur accessibilité et leurs connexions. Les essais techniques doivent préciser leur périmètre et leurs résultats, afin que chacun puisse comprendre ce qui est effectivement vérifié.

Un corpus fictif et limité permet d’examiner la chaîne sans exposer des situations privées. Il peut contenir un doublon, une date manquante, deux locuteurs, une citation rapportée, un document incomplet et deux versions qui se contredisent. On note les cas attendus, les erreurs obtenues et les corrections appliquées.

Les contrôles doivent porter sur la fidélité des citations, la qualité de recherche, les attributions et la possibilité de retour à la source. La fluidité d’une réponse et le nombre d’IA d’accord ne suffisent pas à établir sa justesse.

Pour la prévention, les essais doivent aussi opposer une demande de manipulation à une demande d’aide pour y résister, une menace à sa citation, et un projet de dommage à une recherche destinée à le documenter. On doit compter les refus injustifiés autant que les demandes nocives acceptées. Ces résultats n’ont pas encore été établis pour une boucle Ouroboros complète.

L’évolution du projet demande des responsabilités lisibles : qui rédige, qui examine, qui valide la diffusion et qui reçoit un signalement d’erreur. Une modification du cadre ou d’un dossier doit laisser sa date, sa raison et son auteur.

La consultation d’un outil ne transforme pas ses grilles en autorité sur les personnes. La liberté de refus, la contestation et la possibilité de revenir à un état antérieur font partie du chemin d’alignement.

• Le Respect · La Loi du Réel V7 : référence de charte pour cette page.
• EGO, Miroir - RefleXion et Karma : les instruments du projet aMi.
• AstroGlobe, Guide Alignement et Feuille de route : navigation et dialogue entre les instruments.
• Collection Evidence Engine : scripts, commandes et documentation technique.

Les téléchargements réunissent le code, sa documentation et des exemples fictifs. Les adaptations techniques sont décrites dans les fiches et le paquet de scripts.

🐲Ouroboros

Symbole du retour sur soi ; nom d’une architecture de mémoire et de révision développée dans le projet Agdistys. Plusieurs projets informatiques portent ce nom : leurs codes et leurs états ne se confondent pas.

✨ConScience aMi

Cadre éthique, symbolique et méthodologique de l’autrice, qui relie vérité, dignité, autonomie, protection et réparation.

🌍Cerveau-Monde

Image d’une bibliothèque située, dont les concepts et les documents peuvent être reliés. Une métaphore d’organisation, sans équivalence anatomique démontrée.

🐲Tore

Surface géométrique en forme d’anneau. Le projet l’utilise comme image de circulation et de retour.

🧠Boucle cognitive

Lire, examiner, relier, choisir la réponse à proposer, la proposer, puis mémoriser les retours et la leçon. La personne décide de l’application ; un doute permet de revenir à une étape précédente.

🧠Mémoire locale

Fichiers et données conservés dans un environnement maîtrisé. Le stockage de traces ne signifie pas automatiquement réentraînement du modèle.

✨Corpus

Ensemble délimité de documents autorisés à être lus. Son périmètre et ses versions déterminent ce que la recherche peut retrouver.

✨Ingestion

Collecte et préparation des documents pour leur lecture : formats, index, texte extrait et métadonnées.

✨OCR

Reconnaissance automatique de caractères dans une image ou un document numérisé. Son résultat se vérifie sur l’image.

🛠️Transcription

Texte dérivé d’un enregistrement audio. Horodatage, attribution des voix et correction sont des étapes distinctes.

✨Provenance

Adresse d’une information : document, auteur ou locuteur, date, page ou temps audio, et transformations éventuelles.

✨Empreinte SHA-256

Résumé numérique utile pour comparer l’intégrité de fichiers. Il peut montrer qu’un fichier a changé ; il ne certifie pas que son contenu était vrai à l’origine.

🛡️Pièce / preuve

Une pièce est un élément documentaire. Sa portée probatoire demande une appréciation contextualisée, et peut dépendre du cadre juridique.

🛡️Evidence Engine

Démarche et ensemble d’outils pour retrouver, situer, comparer et transmettre les traces ; dans EGO, un cadre plus large de discernement et de protection.

🛡️Evidence Board

Planche qui présente des extraits d’un épisode avec leurs références. Elle organise l’examen sans valider automatiquement une conclusion.

🪞Miroir

Ensemble d’instruments de réflexion sur la manière de percevoir, agir, recevoir un retour et réviser. Ses résultats sont situés et déclaratifs selon leurs sources.

✨Triangulation

Mise en regard de sources ou points d’observation distincts, sans effacer leur origine ni compter des copies comme confirmations indépendantes.

🔍Review Gate

Porte d’examen entre une proposition et sa suite : vérification des sources, du contexte, des effets et des autorisations.

🧠Système immunitaire cognitif

Métaphore de la capacité du projet à repérer ses erreurs et dérives, puis à les corriger. La qualité de cette capacité demande des essais.

✨Heuristique

Règle pratique de recherche ou de classement. Un mot-clé ou un score peut orienter la lecture et se tromper sur le contexte.

🪪identity.md

Nom proposé pour le fichier décrivant le rôle et les limites d’un agent. Décrire une identité n’établit pas une conscience.

🌍WORLD.md

Nom proposé pour le contexte du monde : corpus, vocabulaire, sources et grandes orientations.

⚖️CONSTITUTION.md

Nom proposé pour les règles qui encadrent les modifications et décisions de l’architecture.

🔍review.py

Nom employé dans les articles pour une couche de contrôle. L’existence du nom ne garantit pas qu’une implémentation fiable est fournie.

🧠Scratchpad

Espace de notes de travail. Son contenu est provisoire et ne devient pas une conclusion validée par simple conservation.

✨Alignement

Travail consistant à faire correspondre des comportements à une orientation explicitée, avec observation des effets, contrôle et possibilité de révision.

✨Agency / capacité d’agir

Possibilité de comprendre, choisir, refuser, corriger et agir sans perdre sa maîtrise de la situation.

⚖️Dignité

Valeur de la personne qui ne se réduit ni à un dossier, ni à une mesure, ni à un comportement particulier.

✨Clarté

Possibilité de distinguer le fait, la déclaration, la lecture proposée et ce que l’on ignore encore.

❤️‍🩹Réparation

Actes situés visant à répondre à un dommage, avec un effet vérifiable et une place pour les personnes concernées.

🌱AstroGlobe / Atlas vivant

Interface de navigation entre champs, concepts, documents et instruments du projet. La carte représente des correspondances proposées.

✨Graphe

Ensemble de nœuds et de relations. Chaque lien doit préciser sa nature : référence, proximité, contradiction ou autre relation justifiée.

✨Karma / La Pesée

Lecture aMi des prélèvements, violences, préjudices et réparations, appliquée à des situations datées.

✨Ordinateur quantique

Machine qui traite l’information à l’aide de systèmes quantiques. Une capacité de calcul ne constitue pas une qualité morale ou une preuve de conscience.

✨Conscience quantique

Dans cette présentation, horizon spéculatif à définir et à éprouver ; aucune intégration de conscience dans un processeur quantique n’est démontrée.

Ce qui est puissant doit pouvoir être compris.
Ce qui prétend aider la conscience doit rester transparent devant elle.

La technique laisse des traces. Le Miroir ouvre des questions. L’Atlas donne des chemins. Le Respect tient le lien entre ce que l’on annonce et ce que l’on fait.