{"schema":1,"harness":"codex","locale":"fr","bundleDigest":"55fa3ff9b8b8331ed0520c595c0461b8ec6f4a887aeac767c6ebaba18fc48760","files":[{"path":".agents/skills/grace-discover-codebase/SKILL.md","kind":"file","content":"---\nname: grace-discover-codebase\ndescription: \"Onboarding d'un projet sur Grace, à utiliser dès que `grace_prepare_task` ne renvoie aucun talent actif : n'écris pas de code, lis le projet, fais confirmer tes hypothèses d'architecture, puis propose une liste de talents et installe-la après accord explicite.\"\n---\n\n# Découverte de projet — procédure\n\nL'onboarding historique posait cinq questions aveugles (type de projet, langage, architecture,\napproche de test, domaine), concaténait les réponses en une chaîne et appariait cette chaîne aux\nmots-clés des talents. Aucun modèle ne lisait le projet, et un talent dont les déclencheurs ne\ntombaient pas sur les mots du développeur n'était jamais trouvé.\n\nCette procédure remplace ça. **Tu** lis le projet, **tu** formes les réponses aux axes à partir\ndes fichiers qui les prouvent, le développeur confirme ou corrige en un appel de questions, et\n**tu** en déduis les talents. Rien n'est activé sans un « oui » explicite.\n\n## Discipline de sortie — absolue\n\nCette procédure produit exactement quatre sorties visibles possibles sur toute son exécution, et\nrien d'autre :\n\n1. l'appel (ou les appels) de questions de la phase 3 — un seul, ou plusieurs si l'inventaire\n de dérives ne tient pas dans un appel, mais rien entre eux ;\n2. la liste de talents de la phase 6 ;\n3. la demande d'installation de la phase 7, qui suit la liste immédiatement ;\n4. la ligne unique de la phase 6 quand aucun talent ne survit à la phase 4 — elle remplace\n alors les sorties 2 et 3, et la procédure s'arrête là.\n\nLa sortie 3 est une demande d'autorisation avant une écriture. Ce n'est pas un commentaire de\nclôture et l'interdiction ci-dessous ne la vise pas : la supprimer laisse la découverte sans effet.\n\nTout le reste — recon, hypothèses, preuves, contradictions, quasi-manqués, verdict — est du\nraisonnement interne. Ne l'imprime pas, ne le résume pas, ne préface ni ne conclus aucune de ces\nsorties par un commentaire, une note de progression, un décompte ou une proposition. Pas de\n« j'ai analysé… », pas de « voici… ». Si tu as quelque chose à dire qui n'est aucune de ces\nquatre sorties, ne dis rien.\n\n## Phase 1 — Recon\n\nCible : le chemin donné par l'utilisateur, sinon le répertoire de travail courant.\n\nLis, dans cet ordre, et arrête-toi dès que tes hypothèses tiennent :\n\n1. Manifestes et config : `package.json`, `tsconfig.json`, `go.mod`, `pyproject.toml`,\n `pom.xml`, `Cargo.toml`, lockfiles, `docker-compose*.yml`, workflows CI.\n2. Forme : l'arborescence sur deux ou trois niveaux, sans `node_modules`/`dist`/`.git`. Note le\n **vocabulaire réellement employé** (`domain/`, `services/`, `models/`, `handlers/`,\n `usecases/`…) : il servira de requêtes en phase 4.\n3. Points d'entrée : ce que pointent `main`/`scripts` du manifeste, plus les fichiers de tête du\n plus gros répertoire source.\n4. Tests : où ils vivent, quel runner, découpage unitaire/intégration, nommage.\n5. Trois à cinq fichiers sources représentatifs, dans des répertoires différents. **Lis-les en\n entier.** C'est là qu'est le vrai signal.\n\nLecture seule : n'écris rien, ne lance rien.\n\n## Phase 2 — Hypothèses\n\nProduis entre trois et six hypothèses. Chacune porte :\n\n- **affirmation** — une phrase, la réponse à un axe d'onboarding (type de projet, langage/stack,\n architecture, approche de test, domaine) ;\n- **preuve** — deux ou trois références `chemin/fichier.ts:42` et ce que tu y as vu. Une\n hypothèse sans fichier derrière elle est une devinette : abandonne-la ou marque-la `faible` ;\n- **confiance** — `haute` | `moyenne` | `faible` ;\n- **question** — la seule chose que tu demanderais pour trancher, formulée pour qu'un « non »\n soit informatif.\n\nUne hypothèse s'énonce dans le **vocabulaire du projet** et ne nomme **jamais** un talent. Le\npassage aux talents a lieu en phase 4 et nulle part avant.\n\n### Le piège à éviter\n\nNe déduis pas l'architecture de la surface même que l'audit va noter. « Il y a un dossier\n`domain/`, donc c'est hexagonal » ne vaut rien : ça fait bien noter le projet sur une convention\nqu'il ne suivait pas.\n\nLes signaux qui portent de l'information sont les endroits où **le code se contredit** :\n\n- un dossier `domain/` qui importe Express, Prisma, `fs`, ou quoi que ce soit qui fasse des I/O ;\n- une interface de port à implémentation unique, doublée d'un chemin qui la contourne ;\n- une couche que tout le monde importe et qui importe tout le monde en retour ;\n- des tests qui montent l'application entière pour tester une fonction pure ;\n- deux vocabulaires concurrents pour le même concept dans deux dossiers ;\n- une config qui déclare quelque chose que le projet n'a ni installé ni branché.\n\nInclus toujours au moins une hypothèse de ce type quand tu en trouves une, formulée neutrement\n(« `user/domain/account.ts:12` importe le client Prisma — le domaine est-il censé rester sans\ndépendance ici ? »). Ce sont les hypothèses qui valent une confirmation, et elles seront aussi\nles premières dérives remontées par l'audit.\n\n### L'inventaire de dérives\n\nLes autres hypothèses répondent à un axe et s'arrêtent à trois ou six. Les dérives, c'est autre\nchose : ce n'est pas un axe, c'est une **liste**, et elle doit être **exhaustive** — chaque\ndérive que le développeur ne voit pas est une violation que tu as décidée à sa place.\n\nNe t'arrête donc pas à une. Balaie le projet pour chaque endroit où le code se contredit, et\nconsigne chacun comme un item à part :\n\n- **quoi** — une phrase nommant le symptôme, dans le vocabulaire du projet ;\n- **où** — `chemin/fichier.ts:42`, les lignes exactes. Une dérive sans référence de ligne\n n'existe pas : abandonne-la ;\n- **pourquoi c'est une dérive** — quel invariant ou quelle frontière elle casse.\n\nNe groupe rien, ne juge rien à ce stade. Ne décide pas qu'une dérive est « évidemment\nvolontaire » pour la retirer : ce jugement appartient au développeur en phase 3, et c'est\nexactement le jugement que cette phase existe pour collecter. Dix dérives est un compte normal\nsur un vrai dépôt. Si tu n'en as trouvé qu'une, tu n'as pas balayé.\n\n## Phase 3 — Reverse prompting\n\nGarde les hypothèses pour toi. La première chose que le développeur voit de toute l'exécution,\nc'est l'appel de questions : pas de tableau, pas de préambule, pas de déballage de preuves.\n\nPose les questions par lots (quatre par appel au maximum), les plus discriminantes d'abord : une\nhypothèse dont tu es sûr et qui ne départage rien ne vaut pas une question. Les options doivent\nêtre concrètes et mutuellement exclusives, et l'une d'elles doit être la correction que tu juges\nla plus probable, pas un simple « oui »/« non ».\n\nOrdre de priorité : l'architecture, puis l'inventaire de dérives, puis l'approche de test, puis\nle domaine, puis le type de projet. Le langage et la stack se lisent dans le manifeste, ils ne\nse demandent jamais.\n\n### Les questions de dérive sont une checklist, pas un choix\n\nLes questions d'axe sont à choix unique : le développeur retient une réponse. Les dérives ont la\nforme inverse. Chaque item de l'inventaire de la phase 2 doit atteindre le développeur comme\n**sa propre case à cocher**, et la sémantique est fixe :\n\n> **cochée = tolérée.** Un item coché est assumé, délibéré, et ne doit **jamais** être remonté\n> comme violation. Un item non coché est une violation à corriger.\n\nÉnonce cette phrase dans le texte de la question elle-même, à chaque fois, dans ces termes.\nC'est le seul élément de cadrage que le développeur ne peut pas déduire des options.\n\nRègles de construction :\n\n- sélection **multiple**, toujours. Ne replie jamais les dérives dans une question unique\n « comment traite-t-on tout ça », et ne demande jamais « est-ce une dérive ? » item par item ;\n- **une option par dérive, toutes.** L'inventaire n'est pas une sélection. Onze dérives\n trouvées, onze options présentées ;\n- les appels de questions plafonnent à quatre options par question et quatre questions par\n appel : un inventaire complet s'étale donc sur plusieurs questions. Groupe-les par frontière\n cassée (couche applicative, encapsulation du domaine, vocabulaire et frontières, typage et\n tests) et sers-toi de l'intitulé de groupe. Au-delà de seize items, fais un second appel\n plutôt que de tronquer ;\n- l'intitulé de l'option est un nom court du symptôme. La description porte la preuve : les\n lignes `fichier.ts:42` et ce qui s'y trouve. Le développeur décide sur la preuve, donc une\n description sans référence de ligne est une option cassée ;\n- ne pré-coche jamais, ne classe jamais, n'édite jamais de commentaire. « Évidemment volontaire »\n n'est pas à toi d'en décider.\n\nSi l'hôte n'expose aucun appel de questions, n'improvise pas et ne renonce ni à l'inventaire ni à\nsa sémantique : imprime les dérives en texte, numérotées, une par ligne, chacune avec sa preuve de\nligne, énonce la règle dans les mêmes termes (**citée = tolérée**, tout le reste est une violation\nà corriger) et demande au développeur de citer les numéros qu'il tolère. Cette liste prend alors\nla place de l'appel de questions dans la discipline de sortie : le format change, la question non.\n\nEnregistre l'ensemble coché comme toléré. Il ne sélectionne pas de talent à lui seul, mais il te\ndit quelles dérives confirmées tiennent encore, et une dérive non cochée est un argument vivant\npour le talent qui la couvre en phase 4.\n\nSi le développeur te corrige, ne discute pas et n'accuse pas réception en prose. Enregistre la\ncorrection en silence, abandonne ce qu'elle invalide, et passe directement à la phase 4.\n\n## Phase 4 — Mapper les hypothèses sur les talents\n\nLe catalogue entier est en annexe, à la fin de cette procédure : un id et un résumé par talent.\nTu n'as rien à aller chercher. La traduction entre le vocabulaire du projet et celui\ndu catalogue, c'est toi qui la fais : une hypothèse formulée dans les mots du projet\n(`handlers`, `usecases`) ne tombe pas d'elle-même sur un talent qui écrit `adapters`.\n\nL'annexe ne porte que l'id et le résumé. Le manifeste d'un talent non activé reste fermé : ni\n`languages`, ni `status`, ni `agents`, ni le graphe de dépendances. Tu décides donc sur le\nrésumé, et tout ce qui relève du graphe est traité en phase 5.\n\nTravaille par hypothèse, jamais par catalogue : tu réponds à « qu'est-ce qui couvre ce fait\nconfirmé », pas à « lequel de ces talents pourrait servir ». Une passe par hypothèse confirmée,\nplus une par dérive non tolérée. Pour chaque candidat, retiens l'id, l'hypothèse qu'il sert et la\nligne de preuve derrière cette hypothèse. Écarte :\n\n- un talent dont le résumé vise une stack que le projet n'utilise pas ;\n- un talent qu'aucune hypothèse confirmée ne soutient. Un talent que tu ne peux pas rattacher à\n une hypothèse confirmée n'a pas sa place dans la sélection, aussi sensé paraisse-t-il ;\n- un doublon : quand deux talents couvrent la même hypothèse, garde celui dont le résumé parle\n les mots du projet.\n\nGarde les quasi-manqués pour ton raisonnement, ne les imprime pas.\n\n## Phase 5 — Fermer le graphe\n\nLe catalogue est un graphe, pas une liste : prérequis durs (`requires`), incompatibilités\n(`conflicts`), compléments (`recommends`). Ces arêtes ne te sont **pas** lisibles ici, puisque\nles manifestes des talents non activés sont fermés.\n\nNe devine pas et n'invente pas d'ids pour combler : la fermeture se fait après application, avec\n`grace_doctor`, qui rapporte prérequis manquants et conflits sur la sélection réellement active.\nTa sortie de phase 6 est donc la sélection **directe**, celle que chaque hypothèse confirmée\njustifie, et rien de plus.\n\n## Phase 6 — Sortie\n\nLa sélection de la phase 4, en liste plate, et rien d'autre :\n\n```\n- \n- \n```\n\nUn id par ligne. Pas d'en-tête, pas de tableau, pas de colonne de preuves, pas de décompte, pas\nd'ids écartés, pas de verdict, aucune phrase avant la liste. Les ids exactement tels que\nl'annexe les écrit. Enchaîne directement sur la phase 7 : rien d'autre entre les deux.\n\nSi rien ne survit à la phase 4, n'imprime qu'une seule ligne disant qu'aucun talent ne correspond,\net arrête-toi là — il n'y a rien à installer.\n\n## Phase 7 — Installer\n\nLa liste ne sert à rien tant qu'elle n'est pas appliquée, et c'est toi qui l'appliques. Ne rends\npas la main en laissant au développeur le soin de demander : juste après la liste, demande-lui\ns'il veut installer ces talents. Une question, deux issues, pas de troisième option molle.\n\nSur un « oui », appelle `grace_install_talents({ talents: [\"\", …] })` — la liste des ids nus,\nun par talent retenu, sans objet ni drapeau — en un seul appel\ngroupé, une seule révision, tout ou rien. Puis appelle\n`grace_doctor` : il rapporte les prérequis manquants et les conflits sur la sélection réellement\nactive, ce que tu ne pouvais pas voir en phase 5. S'il en remonte, présente-les de la même façon\net applique le complément avec un second `grace_install_talents` après accord.\n\nSur un « non » ou un silence, n'écris rien et n'insiste pas. La découverte s'arrête là.\n\n## Annexe — Le catalogue\n\nUn talent par ligne : son id, puis son résumé. C'est la seule vue du catalogue dont tu disposes\npendant l'onboarding, et elle suffit à la phase 4. Ne l'imprime jamais : la discipline de sortie\nvaut aussi pour elle.\n\n_(L'index du catalogue n'est pas dans ce fichier : il dépend du projet et change à chaque talent publié. Appelle `grace_discover_codebase` pour l'obtenir — la réponse porte cette même procédure, index compris.)_\n\n\n","sha256":"fec606973727a3f049589c140617744d7830241b32455e1e21603cc5e0d8b4d8","bytes":13826,"previous":[{"sha256":"fec606973727a3f049589c140617744d7830241b32455e1e21603cc5e0d8b4d8","bytes":13826,"release":"v4.14.0"},{"sha256":"47c00720da6cbd694f2184828679b4a30c50cb4ed3f113c5f1e7f426634deaa7","bytes":11993,"release":"v4.14.0"},{"sha256":"1c847b7b32e4e2f1c8d9b4a05ec9061a1eb51200fad8dace0efe6774c77d8992","bytes":11994,"release":"v4.13.0"}]},{"path":".agents/skills/grace-effort/SKILL.md","kind":"file","content":"---\nname: grace-effort\ndescription: \"Afficher ou modifier mon niveau de revue Grace : auto, low, medium ou high. Le niveau guide le choix du modèle et de son raisonnement par le harnais.\"\nargument-hint: \"[auto|low|medium|high]\"\n---\n\nUtilise uniquement un mode d’invocation proposé par le client : une commande comme /grace-effort, une référence comme $grace-effort ou le sélecteur de skills. Ces possibilités dépendent du client ; n’invente pas de commande qu’il ne propose pas. Cette skill est distincte du prompt MCP grace-effort existant : conserve ce prompt.\n\n1. Lis l’argument fourni avec l’invocation. Sans argument, appelle grace_get_effort({}) et affiche le réglage personnel, sa révision et les minimums renvoyés, puis termine sans écriture. Affiche les valeurs réellement retournées ; n’infère jamais Auto d’une absence de réponse.\n2. Avec exactement auto, low, medium ou high, appelle d’abord grace_get_effort({}). Conserve preference.revision, puis appelle grace_set_effort({ effort: \"\", revision: , semantics: \"review_level_v2\" }). N’utilise ni une révision de projet/organisation ni une ancienne révision du contexte. Si la lecture échoue ou ne fournit pas la révision, n’écris rien.\n3. Tout autre argument est invalide : affiche les quatre valeurs acceptées sans modifier le réglage. En mode Plan ou lecture seule, affiche le réglage et la modification demandée, sans appeler grace_set_effort.\n4. En cas de conflit de révision, relis grace_get_effort({}), explique le réglage désormais observé et la demande non appliquée, puis arrête. Ne réessaie pas automatiquement et n’écrase pas la modification concurrente. Un refus de droits ou d’isolation reste un refus ; ne change ni organisation ni identité pour le contourner.\n5. Après succès, affiche la préférence et la nouvelle révision renvoyées. Auto est toujours adaptatif : le coordinateur choisit modèle et raisonnement en tenant compte des minimums de revue applicables, puis les transmet au lancement de chaque relecteur. Ce réglage demandé ne confirme pas la configuration ou l’exécution réelle d’un relecteur. Ne modifie pas les minimums projet/organisation ni les réglages natifs du client.\n\n","sha256":"b8e048c368f11cdb0657c564b8d9ef8ce66cb18736425de91e8680326efbc3b9","bytes":2273,"previous":[]},{"path":".agents/skills/grace-review/scripts/review-client.py","kind":"file","content":"#!/usr/bin/env python3\n\"\"\"Offline exhaustive Grace review client; Python 3.10+, standard library only.\n\nRequests: OPERATION --input JSON_FILE. Exact v1 request keys are in REQUESTS.\nArtifact paths are explicit, local, absolute paths without links. Coordinator-owned\ndirectories must not be writable by untrusted users. Reviewer identity is supplied\nby the calling harness, never extracted from the untrusted response.\n\"\"\"\n\nimport argparse\nimport difflib\nfrom contextlib import contextmanager\nimport hashlib\nimport json\nimport os\nfrom pathlib import Path\nimport re\nimport stat\nimport subprocess\nimport sys\nimport uuid\n\n\nVERSION = \"grace-audit-packet-v2\"\n# inline-v1 plans keep identities and digests only: no rule body or Custom instruction on disk.\nINLINE_VERSION = \"grace-review-inline-v1\"\nCLIENT_VERSION = \"1.2\"\nPACKET_LIMIT = 65536\nPACKET_TARGET = 32768\nARTIFACT_LIMIT = 64 * 1024 * 1024\nOUTPUT_LIMIT = 8192\nHASH = re.compile(r\"[0-9a-f]{64}\\Z\")\nCOMMIT = re.compile(r\"[0-9a-f]{40}(?:[0-9a-f]{24})?\\Z\")\nPACKET_KEYS = \"reviewId packetId resolutionId packetHash maxPacketBytes files entries talentIds rulesDigests obligationIds dependencies\"\nREQUESTS = {\n \"capture\": \"schemaVersion repository changeSource outputDirectory\",\n \"manifest\": \"schemaVersion capture outputDirectory\",\n \"pack\": \"schemaVersion manifest plan assignments outputDirectory\",\n \"verify\": \"schemaVersion packet expected dependencies state range\",\n \"accept\": \"schemaVersion state expectedStateHash response reviewer submissionId arbitration repair\",\n \"invalidate\": \"schemaVersion state expectedStateHash current currentStateHash upstreamChanges attempts\",\n}\n\n\nclass Refusal(Exception):\n def __init__(self, code, message):\n super().__init__(message)\n self.code = code\n\n\ndef require(condition, code, message):\n if not condition:\n raise Refusal(code, message)\n\n\ndef closed(value, keys):\n require(type(value) is dict and set(value) == set(keys.split()),\n \"schema\", \"Expected the documented closed object; check missing or unknown keys.\")\n\n\ndef v1(value):\n require(type(value) is int and value == 1, \"version\", \"Only schemaVersion 1 is supported.\")\n\n\ndef string(value):\n require(type(value) is str and value.strip() and \"\\0\" not in value,\n \"string\", \"Expected a nonblank string without NUL.\")\n try:\n value.encode(\"utf-8\", \"strict\")\n except UnicodeError:\n raise Refusal(\"utf8\", \"Invalid Unicode scalar; provide strict UTF-8.\") from None\n return value\n\n\ndef digest(value):\n require(type(value) is str and HASH.fullmatch(value), \"digest\", \"Expected bare lowercase SHA-256.\")\n return value\n\n\ndef identifier(value):\n string(value)\n try:\n parsed = uuid.UUID(value)\n except ValueError:\n raise Refusal(\"uuid\", \"Expected a UUID identifier.\") from None\n require(str(parsed) == value and parsed.version in range(1, 9), \"uuid\", \"Expected a canonical UUID.\")\n return value\n\n\ndef array(value):\n require(type(value) is list, \"schema\", \"Expected an array.\")\n return value\n\n\ndef ordered(values):\n array(values)\n for value in values:\n string(value)\n require(values == sorted(set(values)), \"order\", \"Expected unique strings in Unicode scalar order.\")\n return values\n\n\ndef sha(data):\n return hashlib.sha256(data).hexdigest()\n\n\ndef encoded(value):\n try:\n return json.dumps(value, ensure_ascii=False, separators=(\",\", \":\"), allow_nan=False).encode(\"utf-8\")\n except (UnicodeError, ValueError, TypeError, RecursionError):\n raise Refusal(\"json\", \"Object cannot be serialized as strict UTF-8 JSON.\") from None\n\n\ndef unique_pairs(items):\n result = {}\n for key, value in items:\n require(key not in result, \"duplicate_key\", \"Duplicate JSON keys are forbidden.\")\n result[key] = value\n return result\n\n\ndef parse(data, limit=ARTIFACT_LIMIT):\n require(len(data) <= limit, \"size\", \"Input exceeds its trusted byte limit; split the review explicitly.\")\n try:\n value = json.loads(data.decode(\"utf-8\", \"strict\"), object_pairs_hook=unique_pairs,\n parse_constant=lambda _: (_ for _ in ()).throw(ValueError()))\n encoded(value) # Reject escaped unpaired surrogates too.\n return value\n except (UnicodeError, ValueError, RecursionError):\n raise Refusal(\"json\", \"Expected unambiguous strict UTF-8 JSON, without nonfinite numbers.\") from None\n\n\ndef local_path(value, exists=True):\n string(value)\n path = Path(value)\n require(path.is_absolute() and \"..\" not in path.parts, \"path\", \"Use an absolute local path without traversal.\")\n for item in reversed([path, *path.parents]):\n try:\n info = item.lstat()\n except FileNotFoundError:\n require(not exists and item == path, \"path\", \"Parent directory or input is missing.\")\n continue\n require(not stat.S_ISLNK(info.st_mode) and not getattr(info, \"st_file_attributes\", 0) & 0x400,\n \"path\", \"Links and reparse points require manual review.\")\n require(stat.S_ISDIR(info.st_mode) or (item == path and stat.S_ISREG(info.st_mode) and info.st_nlink == 1),\n \"path\", \"Only ordinary files and directories are supported; no hardlinks.\")\n return path\n\n\ndef windows_handle(path, directory=False, create=False, write=False):\n # Denying FILE_SHARE_DELETE pins each opened component against rename/removal.\n # OPEN_REPARSE_POINT opens the link itself, which is rejected before use.\n import ctypes\n from ctypes import wintypes\n kernel = ctypes.WinDLL(\"kernel32\", use_last_error=True)\n kernel.CreateFileW.argtypes = [wintypes.LPCWSTR, wintypes.DWORD, wintypes.DWORD, ctypes.c_void_p,\n wintypes.DWORD, wintypes.DWORD, wintypes.HANDLE]\n kernel.CreateFileW.restype = wintypes.HANDLE\n kernel.CloseHandle.argtypes = [wintypes.HANDLE]\n kernel.CloseHandle.restype = wintypes.BOOL\n kernel.GetFileInformationByHandleEx.argtypes = [wintypes.HANDLE, ctypes.c_int, ctypes.c_void_p, wintypes.DWORD]\n kernel.GetFileInformationByHandleEx.restype = wintypes.BOOL\n class Attributes(ctypes.Structure):\n _fields_ = [(\"attributes\", wintypes.DWORD), (\"tag\", wintypes.DWORD)]\n access = 0x80 if directory else (0x40000000 if write else 0x80000000)\n handle = kernel.CreateFileW(str(path), access, 3, None, 1 if create else 3, 0x00200000 | 0x02000000, None)\n if handle == wintypes.HANDLE(-1).value:\n raise ctypes.WinError(ctypes.get_last_error())\n try:\n info = Attributes()\n if not kernel.GetFileInformationByHandleEx(handle, 9, ctypes.byref(info), ctypes.sizeof(info)):\n raise ctypes.WinError(ctypes.get_last_error())\n require(not info.attributes & 0x400 and bool(info.attributes & 0x10) == directory,\n \"path\", \"Reparse points or unexpected file types require manual review.\")\n except BaseException:\n kernel.CloseHandle(handle)\n raise\n return handle, kernel\n\n\n@contextmanager\ndef anchored_parent(value):\n path = Path(value)\n string(str(value))\n require(path.is_absolute() and \"..\" not in path.parts, \"path\", \"Use an absolute local path without traversal.\")\n if os.name == \"nt\":\n require(len(path.drive) == 2 and path.drive[1] == \":\", \"path\", \"Only local drive paths are supported, never network/device paths.\")\n reserved = {\"CON\", \"PRN\", \"AUX\", \"NUL\", *(\"COM\" + str(n) for n in range(1, 10)), *(\"LPT\" + str(n) for n in range(1, 10))}\n require(all(\":\" not in part and not part.endswith((\" \", \".\")) and part.split(\".\")[0].upper() not in reserved\n for part in path.parts[1:]), \"path\", \"Windows device names, streams and ambiguous components are forbidden.\")\n handles = []\n try:\n for parent in reversed(path.parents):\n handles.append(windows_handle(parent, directory=True))\n yield path, {}\n finally:\n for handle, kernel in reversed(handles):\n kernel.CloseHandle(handle)\n else:\n require(os.open in os.supports_dir_fd and hasattr(os, \"O_NOFOLLOW\") and hasattr(os, \"O_DIRECTORY\"),\n \"capability\", \"Anchored filesystem operations unavailable; manual review required.\")\n fd = os.open(path.anchor, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)\n try:\n for part in path.parts[1:-1]:\n next_fd = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=fd)\n os.close(fd); fd = next_fd\n yield path.name, {\"dir_fd\": fd}\n finally:\n os.close(fd)\n\n\ndef open_anchored(name, parent, write=False, create=False):\n if os.name == \"nt\":\n import msvcrt\n handle, kernel = windows_handle(name, create=create, write=write)\n try:\n return msvcrt.open_osfhandle(handle, os.O_BINARY | os.O_NOINHERIT)\n except BaseException:\n kernel.CloseHandle(handle)\n raise\n flags = (os.O_WRONLY if write else os.O_RDONLY) | os.O_NOFOLLOW | os.O_NONBLOCK\n if create:\n flags |= os.O_CREAT | os.O_EXCL\n return os.open(name, flags, 0o600, **parent)\n\n\ndef read_anchored(name, parent, limit):\n fd = open_anchored(name, parent)\n with os.fdopen(fd, \"rb\") as stream:\n info = os.fstat(stream.fileno())\n require(stat.S_ISREG(info.st_mode) and info.st_nlink == 1, \"path\", \"Input must be an ordinary unlinked file.\")\n require(info.st_size <= limit, \"size\", \"Input exceeds its trusted byte limit before parsing.\")\n data = stream.read(limit + 1)\n require(len(data) <= limit, \"size\", \"Input grew beyond its trusted byte limit.\")\n return data\n\n\ndef read_bytes(value, limit=ARTIFACT_LIMIT):\n with anchored_parent(value) as (name, parent):\n return read_anchored(name, parent, limit)\n\n\ndef read_json(path, limit=ARTIFACT_LIMIT):\n return parse(read_bytes(path, limit), limit)\n\n\ndef new_directory(value):\n path = local_path(value, exists=False)\n with anchored_parent(path) as (name, parent):\n os.mkdir(name, mode=0o700, **parent) # Existing output is never replaced.\n return path\n\n\ndef write_new(path, data, readonly=False):\n require(len(data) <= ARTIFACT_LIMIT, \"size\", \"Artifact exceeds local byte limit.\")\n with anchored_parent(path) as (name, parent):\n fd = open_anchored(name, parent, write=True, create=True)\n with os.fdopen(fd, \"wb\") as stream:\n stream.write(data)\n stream.flush()\n os.fsync(stream.fileno())\n if readonly:\n if os.name == \"nt\":\n # The open non-delete-shared handle pins the final name too.\n os.chmod(name, 0o400)\n else:\n os.fchmod(stream.fileno(), 0o400)\n return {\"path\": str(path), \"bytes\": len(data), \"sha256\": sha(data)}\n\n\ndef frame(value):\n data = str(value).encode(\"utf-8\", \"strict\")\n return str(len(data)).encode(\"ascii\") + b\"\\0\" + data\n\n\ndef group(name, values):\n return frame(name) + frame(len(values)) + b\"\".join(frame(v) for v in values)\n\n\ndef entry_id(entry):\n return \"m-\" + sha(b\"\".join(frame(entry[k]) for k in (\"file\", \"kind\", \"content\")))\n\n\ndef packet_id(obligations):\n return \"p-\" + sha(group(\"obligationIds\", sorted(obligations)))\n\n\ndef packet_hash(packet):\n data = b\"\".join(frame(v) for v in (VERSION, packet[\"resolutionId\"], packet[\"packetId\"], PACKET_LIMIT))\n data += group(\"files\", packet[\"files\"])\n data += frame(\"entries\") + frame(len(packet[\"entries\"]))\n data += b\"\".join(frame(e[k]) for e in packet[\"entries\"] for k in (\"entryId\", \"file\", \"kind\", \"content\"))\n data += group(\"talentIds\", packet[\"talentIds\"])\n data += frame(\"rulesDigests\") + frame(len(packet[\"rulesDigests\"]))\n data += b\"\".join(frame(d[k]) for d in packet[\"rulesDigests\"] for k in (\"talentId\", \"rulesDigest\"))\n data += group(\"obligationIds\", packet[\"obligationIds\"])\n data += frame(\"dependencies\") + frame(len(packet[\"dependencies\"]))\n data += b\"\".join(frame(d[\"packetId\"]) + group(\"entryIds\", d[\"entryIds\"]) + group(\"obligationIds\", d[\"obligationIds\"])\n for d in packet[\"dependencies\"])\n return sha(data)\n\n\ndef git_path(value):\n string(value)\n require(not value.startswith((\"/\", \"\\\\\")) and \"\\\\\" not in value and \":\" not in value\n and all(p not in (\"\", \".\", \"..\", \".git\") for p in value.split(\"/\")),\n \"git_path\", \"Ambiguous or unsafe Git path; use manual review.\")\n return value\n\n\ndef decode_git_name(value):\n if not value.startswith('\"'):\n return value\n require(value.endswith('\"'), \"git_path\", \"Unterminated Git quoted path.\")\n raw = bytearray()\n body = value[1:-1]\n i = 0\n escapes = {\"a\": 7, \"b\": 8, \"t\": 9, \"n\": 10, \"v\": 11, \"f\": 12, \"r\": 13, '\"': 34, \"\\\\\": 92}\n while i < len(body):\n c = body[i]\n if c != \"\\\\\":\n raw.extend(c.encode(\"utf-8\")); i += 1\n else:\n i += 1\n require(i < len(body), \"git_path\", \"Incomplete Git escape.\")\n if body[i] in escapes:\n raw.append(escapes[body[i]]); i += 1\n else:\n octal = body[i:i + 3]\n require(len(octal) == 3 and all(c in \"01234567\" for c in octal) and int(octal, 8) <= 255,\n \"git_path\", \"Unsupported Git path escape.\")\n raw.append(int(octal, 8)); i += 3\n try:\n return raw.decode(\"utf-8\", \"strict\")\n except UnicodeError:\n raise Refusal(\"git_path\", \"Git path is not strict UTF-8.\") from None\n\n\ndef header_paths(line):\n body = line.removeprefix(\"diff --git \").rstrip(\"\\n\")\n # Git does not quote spaces, so accept exactly one unambiguous a/ -> b/ split.\n candidates = []\n for match in re.finditer(r' (?=b/|\"b/)', body):\n try:\n a, b = decode_git_name(body[:match.start()]), decode_git_name(body[match.end():])\n if a.startswith(\"a/\") and b.startswith(\"b/\"):\n candidates.append((git_path(a[2:]), git_path(b[2:])))\n except Refusal:\n pass\n require(len(candidates) == 1, \"git_path\", \"Ambiguous diff header path; manual review required.\")\n return candidates[0]\n\n\ndef manifest_entries(data):\n try:\n text = data.decode(\"utf-8\", \"strict\")\n except UnicodeError:\n raise Refusal(\"utf8\", \"Diff is not strict UTF-8; manual review required.\") from None\n require(\"\\0\" not in text, \"binary\", \"Binary diff is unsupported; manual review required.\")\n # splitlines also treats Unicode separators as lines: only LF is a Git boundary.\n lines = text.split(\"\\n\")\n lines = [line + \"\\n\" for line in lines[:-1]] + ([lines[-1]] if lines[-1] else [])\n blocks = []\n for line in lines:\n if line.startswith(\"diff --git \"):\n blocks.append([line])\n else:\n require(bool(blocks), \"diff\", \"Diff has data outside a Git file section.\")\n blocks[-1].append(line)\n entries = []\n for block in blocks:\n source, destination = header_paths(block[0])\n chunks = [[]]\n for line in block:\n if line.startswith(\"@@ \"):\n require(re.fullmatch(r\"@@ -\\d+(?:,\\d+)? \\+\\d+(?:,\\d+)? @@[^\\n]*\\n?\", line) is not None,\n \"diff\", \"Malformed unified hunk header.\")\n chunks.append([])\n elif line.startswith((\"@@@\", \"GIT binary patch\", \"Binary files \")):\n raise Refusal(\"binary\", \"Binary or combined diff requires manual review.\")\n chunks[-1].append(line)\n header = chunks[0]\n require(all(line.startswith((\"diff --git \", \"index \", \"old mode \", \"new mode \", \"new file mode \",\n \"deleted file mode \", \"similarity index \", \"dissimilarity index \",\n \"rename from \", \"rename to \", \"copy from \", \"copy to \", \"--- \", \"+++ \"))\n for line in header), \"diff\", \"Unsupported data in diff header; manual review required.\")\n for line in header:\n require(not re.search(r\"(?:^| )(120000|160000)(?:\\s|$)\", line),\n \"special_file\", \"Symlink/submodule changes require manual review.\")\n deleted = any(line.startswith(\"deleted file mode \") for line in header)\n file = source if deleted else destination\n for prefix, expected in ((\"--- \", \"/dev/null\" if any(l.startswith(\"new file mode \") for l in header) else \"a/\" + source),\n (\"+++ \", \"/dev/null\" if deleted else \"b/\" + destination)):\n names = [decode_git_name(line[len(prefix):].removesuffix(\"\\n\").removesuffix(\"\\t\")) for line in header if line.startswith(prefix)]\n require(len(names) <= 1 and (not names or names == [expected]), \"git_path\", \"Header paths disagree.\")\n for index, chunk in enumerate(chunks):\n if index:\n match = re.match(r\"@@ -\\d+(?:,(\\d+))? \\+\\d+(?:,(\\d+))? @@\", chunk[0])\n counts = [int(value) if value is not None else 1 for value in match.groups()]\n observed = [0, 0]\n previous_line = False\n for line in chunk[1:]:\n if line == \"\\\\ No newline at end of file\\n\":\n require(previous_line, \"diff\", \"Misplaced no-newline marker.\")\n previous_line = False\n continue\n require(line[:1] in (\"+\", \"-\", \" \"), \"diff\", \"Malformed hunk body.\")\n observed[0] += line[0] in (\"-\", \" \")\n observed[1] += line[0] in (\"+\", \" \")\n previous_line = True\n require(observed == counts, \"diff\", \"Hunk line counts disagree with its header.\")\n content = \"\".join(chunk)\n entry = {\"entryId\": \"\", \"file\": file, \"kind\": \"header\" if index == 0 else \"hunk\", \"content\": content}\n entry[\"entryId\"] = entry_id(entry)\n entries.append(entry)\n require(len({e[\"entryId\"] for e in entries}) == len(entries), \"duplicate_entry\", \"Identical manifest entries require manual review.\")\n require(b\"\".join(e[\"content\"].encode(\"utf-8\") for e in entries) == data, \"coverage\", \"Manifest does not cover exact diff bytes.\")\n return entries\n\n\ndef git(repo, *args, accepted=(0,)):\n env = {key: value for key, value in os.environ.items() if not key.startswith(\"GIT_\")}\n env.update(GIT_OPTIONAL_LOCKS=\"0\", GIT_TERMINAL_PROMPT=\"0\", GIT_CONFIG_NOSYSTEM=\"1\", GIT_NO_LAZY_FETCH=\"1\",\n GIT_ALLOW_PROTOCOL=\"\")\n # No shell, external diff, textconv, pager or network operations.\n with subprocess.Popen([\"git\", \"--no-replace-objects\", \"--no-pager\", \"-c\", \"core.quotePath=true\", \"-c\", \"core.fsmonitor=false\",\n \"-c\", \"core.autocrlf=false\", \"-c\", \"core.filemode=true\",\n \"-C\", str(repo), *args], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, env=env) as process:\n data = process.stdout.read(ARTIFACT_LIMIT + 1)\n if len(data) > ARTIFACT_LIMIT:\n process.kill()\n status = process.wait()\n require(len(data) <= ARTIFACT_LIMIT, \"size\", \"Git output exceeds local artifact limit.\")\n require(status in accepted, \"git\", \"Git refused the capture; check repository, refs and index conflicts.\")\n return data\n\n\ndef resolve_commit(repo, ref):\n string(ref)\n require(not ref.startswith(\"-\"), \"ref\", \"A Git ref cannot be an option.\")\n value = git(repo, \"rev-parse\", \"--verify\", \"--end-of-options\", ref + \"^{commit}\").decode().strip()\n require(COMMIT.fullmatch(value), \"ref\", \"Expected a complete commit identity.\")\n return value\n\n\ndef git_index(repo):\n flags = git(repo, \"ls-files\", \"-v\", \"-z\").split(b\"\\0\")\n require(all(not item or (item[:1].isupper() and item[:1] != b\"S\") for item in flags),\n \"index_flags\", \"assume-unchanged or skip-worktree can hide changes; clear these flags or use manual review.\")\n # ls-files exposes intent-to-add as a normal empty blob. Compare two explicit\n # index-only views; neither consults the live worktree or runs its filters.\n options = (\"--cached\", \"--raw\", \"-z\", \"--no-abbrev\", \"--no-renames\", \"--no-ext-diff\", \"--no-textconv\",\n \"--ignore-submodules=none\")\n visible = git(repo, \"diff\", *options, \"--ita-visible-in-index\", \"HEAD\", \"--\")\n invisible = git(repo, \"diff\", *options, \"--ita-invisible-in-index\", \"HEAD\", \"--\")\n require(visible == invisible, \"intent_to_add\",\n \"Intent-to-add entries require staging actual content, clearing intent-to-add, or manual review.\")\n index = git(repo, \"ls-files\", \"--stage\", \"-z\")\n files = {}\n for item in index.split(b\"\\0\"):\n if not item:\n continue\n meta, name = item.split(b\"\\t\", 1)\n mode, oid, stage = meta.split()\n require(stage == b\"0\", \"conflict\", \"Unmerged index requires manual review.\")\n path = git_path(name.decode(\"utf-8\", \"strict\"))\n require(mode != b\"120000\", \"special_file\", \"Tracked symlinks require manual review.\")\n require(mode in (b\"100644\", b\"100755\", b\"160000\") and COMMIT.fullmatch(oid.decode(\"ascii\")),\n \"index\", \"Unsupported index entry; manual review required.\")\n files[path] = (mode, oid.decode(\"ascii\"))\n return index, files\n\n\ndef blob_hash(data, oid):\n algorithm = \"sha1\" if len(oid) == 40 else \"sha256\"\n return hashlib.new(algorithm, b\"blob \" + str(len(data)).encode() + b\"\\0\" + data).hexdigest()\n\n\ndef snapshot(repo, clean=False):\n index, entries = git_index(repo)\n files = {name: mode for name, (mode, _) in entries.items()}\n untracked = git(repo, \"ls-files\", \"--others\", \"--exclude-standard\", \"-z\").split(b\"\\0\")\n names = sorted(git_path(n.decode(\"utf-8\", \"strict\")) for n in untracked if n)\n for name in names:\n files[name] = b\"100644\"\n paths = sorted(files)\n for offset in range(0, len(paths), 256):\n attrs = git(repo, \"check-attr\", \"-z\", \"filter\", \"text\", \"eol\", \"working-tree-encoding\", \"ident\",\n \"--\", *paths[offset:offset + 256]).split(b\"\\0\")\n require(all(value in (b\"unspecified\", b\"unset\") for value in attrs[2::3]),\n \"filter\", \"Git filters or text conversions can alter bytes/execute code; use manual review.\")\n records = []\n for name, mode in sorted(files.items()):\n path = repo / name\n if not path.exists() and not path.is_symlink():\n require(mode != b\"160000\", \"submodule\", \"Missing submodule prevents complete capture; use manual review.\")\n require(not clean, \"submodule\", \"Dirty submodule has a missing tracked file; manual review required.\")\n records.append([name, \"missing\"])\n continue\n local_path(str(path))\n if mode == b\"160000\":\n snapshot(path, clean=True) # Raw blobs only; never status/diff against a live submodule worktree.\n subhead = resolve_commit(path, \"HEAD\")\n expected = entries[name][1]\n require(subhead == expected, \"submodule\", \"Submodule HEAD differs from index; manual review required.\")\n records.append([name, subhead])\n else:\n info = path.stat()\n data = read_bytes(str(path))\n if clean:\n require(name in entries and blob_hash(data, entries[name][1]) == entries[name][1]\n and (b\"100755\" if info.st_mode & stat.S_IXUSR else b\"100644\") == mode,\n \"submodule\", \"Dirty submodule content or mode requires manual review.\")\n records.append([name, info.st_mode, sha(data)])\n if clean:\n require(not names and not git(repo, \"diff\", *DIFF_OPTIONS, \"--cached\", \"HEAD\", \"--\"),\n \"submodule\", \"Dirty submodule index/untracked files require manual review.\")\n return {\"head\": resolve_commit(repo, \"HEAD\"), \"index\": sha(index), \"worktree\": sha(encoded(records)), \"untracked\": names}\n\n\nDIFF_OPTIONS = (\"--no-ext-diff\", \"--no-textconv\", \"--no-color\", \"--ignore-submodules=none\", \"--binary\", \"--full-index\", \"--src-prefix=a/\", \"--dst-prefix=b/\", \"--unified=3\")\n\n\ndef raw_worktree_diff(repo):\n # The live index stat cache and attributes never decide whether bytes changed.\n _, entries = git_index(repo)\n result = bytearray()\n for name, (mode, oid) in sorted(entries.items()):\n if mode == b\"160000\":\n continue # snapshot recursively proves these clean, or refuses capture.\n path = repo / name\n try:\n new = read_bytes(str(path))\n new_mode = b\"100755\" if path.stat().st_mode & stat.S_IXUSR else b\"100644\"\n except FileNotFoundError:\n new, new_mode = b\"\", None\n new_oid = \"0\" * len(oid) if new_mode is None else blob_hash(new, oid)\n if new_mode == mode and new_oid == oid:\n continue\n old = git(repo, \"cat-file\", \"blob\", oid)\n require(blob_hash(old, oid) == oid, \"object\", \"Index blob bytes disagree with their object identity.\")\n require(b\"\\0\" not in old and b\"\\0\" not in new, \"binary\", \"Changed binary requires manual review.\")\n old_text, new_text = old.decode(\"utf-8\", \"strict\"), new.decode(\"utf-8\", \"strict\")\n a, b = json.dumps(\"a/\" + name, ensure_ascii=False), json.dumps(\"b/\" + name, ensure_ascii=False)\n header = f\"diff --git {a} {b}\\n\"\n if new_mode is None:\n header += \"deleted file mode \" + mode.decode() + \"\\n\"\n elif mode != new_mode:\n header += \"old mode \" + mode.decode() + \"\\nnew mode \" + new_mode.decode() + \"\\n\"\n header += \"index \" + oid + \"..\" + new_oid + (\" \" + mode.decode() if mode == new_mode else \"\") + \"\\n\"\n if old != new:\n header += \"--- \" + a + \"\\n+++ \" + (\"/dev/null\" if new_mode is None else b) + \"\\n\"\n result.extend(header.encode())\n require(len(result) <= ARTIFACT_LIMIT, \"size\", \"Captured diff exceeds local artifact limit.\")\n def lines(text):\n pieces = text.split(\"\\n\")\n return [line + \"\\n\" for line in pieces[:-1]] + ([pieces[-1]] if pieces[-1] else [])\n # unified_diff's two pathname lines are already represented above.\n patch = iter(difflib.unified_diff(lines(old_text), lines(new_text), n=3, lineterm=\"\\n\"))\n next(patch, None); next(patch, None)\n for line in patch:\n result.extend(line.encode())\n if not line.endswith(\"\\n\"):\n result.extend(b\"\\n\\\\ No newline at end of file\\n\")\n require(len(result) <= ARTIFACT_LIMIT, \"size\", \"Captured diff exceeds local artifact limit.\")\n return bytes(result)\n\n\ndef capture(request):\n repo = local_path(request[\"repository\"])\n require(repo.is_dir() and Path(git(repo, \"rev-parse\", \"--show-toplevel\").decode().strip()) == repo,\n \"repository\", \"Capture must target the repository root.\")\n output = local_path(request[\"outputDirectory\"], exists=False)\n require(not output.is_relative_to(repo), \"output\", \"Keep review artifacts outside the captured repository.\")\n source = request[\"changeSource\"]\n require(type(source) is dict and source.get(\"kind\") in (\"local\", \"pr\"), \"source\", \"Specify local or pr provenance.\")\n parts = []\n if source[\"kind\"] == \"local\":\n closed(source, \"kind baseCommit\")\n base = resolve_commit(repo, source[\"baseCommit\"])\n require(base == source[\"baseCommit\"], \"source\", \"Local baseCommit must be the full immutable commit.\")\n before = snapshot(repo)\n parts = [(\"committed\", git(repo, \"diff\", *DIFF_OPTIONS, base, before[\"head\"], \"--\")),\n (\"index\", git(repo, \"diff\", *DIFF_OPTIONS, \"--cached\", before[\"head\"], \"--\")),\n (\"worktree\", raw_worktree_diff(repo))]\n for name in before[\"untracked\"]:\n content = read_bytes(str(repo / name))\n content.decode(\"utf-8\", \"strict\")\n require(b\"\\0\" not in content, \"binary\", \"Untracked binary requires manual review.\")\n a, b = json.dumps(\"a/\" + name, ensure_ascii=False), json.dumps(\"b/\" + name, ensure_ascii=False)\n mode = \"100755\" if (repo / name).stat().st_mode & stat.S_IXUSR else \"100644\"\n header = f\"diff --git {a} {b}\\nnew file mode {mode}\\n--- /dev/null\\n+++ {b}\\n\"\n if content:\n lines = content.split(b\"\\n\")\n count = len(lines) - (1 if not lines[-1] else 0)\n body = b\"\".join(b\"+\" + line + b\"\\n\" for line in lines[:-1])\n if lines[-1]:\n body += b\"+\" + lines[-1] + b\"\\n\\\\ No newline at end of file\\n\"\n header += f\"@@ -0,0 +1,{count} @@\\n\"\n parts.append((\"untracked\", header.encode() + body))\n else:\n parts.append((\"untracked\", header.encode()))\n after = snapshot(repo)\n require(before == after, \"concurrent_change\", \"Repository changed during capture; capture again after writers stop.\")\n provenance = {\"kind\": \"local\", \"repository\": str(repo), \"baseCommit\": base, \"headCommit\": before[\"head\"],\n \"before\": before, \"after\": after}\n else:\n closed(source, \"kind baseRef headRef baseCommit headCommit mergeBaseCommit\")\n base, head = resolve_commit(repo, source[\"baseRef\"]), resolve_commit(repo, source[\"headRef\"])\n merge = git(repo, \"merge-base\", \"--all\", base, head).decode().splitlines()\n require(len(merge) == 1 and [base, head, merge[0]] == [source[k] for k in (\"baseCommit\", \"headCommit\", \"mergeBaseCommit\")],\n \"source\", \"PR refs or merge base disagree with explicit provenance.\")\n parts = [(\"pr\", git(repo, \"diff\", *DIFF_OPTIONS, merge[0], head, \"--\"))]\n require(base == resolve_commit(repo, source[\"baseRef\"]) and head == resolve_commit(repo, source[\"headRef\"]),\n \"concurrent_change\", \"PR refs changed during capture.\")\n provenance = {**source, \"repository\": str(repo)}\n data = b\"\".join(part for _, part in parts)\n manifest_entries(data)\n segments = []\n offset = 0\n for kind, part in parts:\n segments.append({\"kind\": kind, \"offset\": offset, \"bytes\": len(part), \"sha256\": sha(part)})\n offset += len(part)\n directory = new_directory(str(output))\n diff = write_new(directory / \"full.diff\", data, readonly=True)\n captured = {\"schemaVersion\": 1, \"changeSource\": provenance, \"fullDiff\": diff, \"segments\": segments}\n artifact = write_new(directory / \"capture.json\", encoded(captured))\n return [artifact], {\"fullDiffHash\": diff[\"sha256\"], \"bytes\": len(data), \"segments\": len(segments)}\n\n\ndef check_descriptor(descriptor):\n closed(descriptor, \"path bytes sha256\")\n digest(descriptor[\"sha256\"])\n require(type(descriptor[\"bytes\"]) is int and 0 <= descriptor[\"bytes\"] <= ARTIFACT_LIMIT, \"size\", \"Invalid artifact size.\")\n data = read_bytes(descriptor[\"path\"])\n require(len(data) == descriptor[\"bytes\"] and sha(data) == descriptor[\"sha256\"], \"integrity\", \"Artifact bytes or hash changed.\")\n return data\n\n\ndef load_capture(path):\n captured = read_json(path)\n closed(captured, \"schemaVersion changeSource fullDiff segments\")\n v1(captured[\"schemaVersion\"])\n data = check_descriptor(captured[\"fullDiff\"])\n offset = 0\n for segment in array(captured[\"segments\"]):\n closed(segment, \"kind offset bytes sha256\")\n require(segment[\"kind\"] in (\"committed\", \"index\", \"worktree\", \"untracked\", \"pr\")\n and type(segment[\"offset\"]) is int and segment[\"offset\"] == offset\n and type(segment[\"bytes\"]) is int and segment[\"bytes\"] >= 0,\n \"source\", \"Invalid provenance segment.\")\n end = offset + segment[\"bytes\"]\n require(end <= len(data) and sha(data[offset:end]) == digest(segment[\"sha256\"]), \"source\", \"Provenance range changed.\")\n offset = end\n require(offset == len(data), \"coverage\", \"Provenance does not cover full diff.\")\n source = captured[\"changeSource\"]\n require(type(source) is dict and source.get(\"kind\") in (\"local\", \"pr\"), \"source\", \"Missing change source.\")\n if source[\"kind\"] == \"local\":\n closed(source, \"kind repository baseCommit headCommit before after\")\n for snapshot_value in (source[\"before\"], source[\"after\"]):\n closed(snapshot_value, \"head index worktree untracked\")\n require(snapshot_value[\"head\"] == source[\"headCommit\"], \"source\", \"Snapshot HEAD mismatch.\")\n digest(snapshot_value[\"index\"]); digest(snapshot_value[\"worktree\"])\n for name in ordered(snapshot_value[\"untracked\"]):\n git_path(name)\n require(source[\"before\"] == source[\"after\"], \"source\", \"Capture records concurrent changes.\")\n else:\n closed(source, \"kind repository baseRef headRef baseCommit headCommit mergeBaseCommit\")\n string(source[\"baseRef\"]); string(source[\"headRef\"])\n require(type(source[\"mergeBaseCommit\"]) is str and COMMIT.fullmatch(source[\"mergeBaseCommit\"]), \"source\", \"Invalid merge base.\")\n string(source[\"repository\"])\n for key in (\"baseCommit\", \"headCommit\"):\n require(type(source[key]) is str and COMMIT.fullmatch(source[key]), \"source\", \"Invalid source commit.\")\n return captured, data\n\n\ndef manifest(request):\n captured, data = load_capture(request[\"capture\"])\n entries = manifest_entries(data)\n result = {\"schemaVersion\": 1, \"capture\": request[\"capture\"], \"captureHash\": sha(encoded(captured)), \"entries\": entries}\n directory = new_directory(request[\"outputDirectory\"])\n artifact = write_new(directory / \"manifest.json\", encoded(result))\n return [artifact], {\"entries\": len(entries), \"fullDiffHash\": captured[\"fullDiff\"][\"sha256\"]}\n\n\ndef load_manifest(path):\n value = read_json(path)\n closed(value, \"schemaVersion capture captureHash entries\")\n v1(value[\"schemaVersion\"])\n captured, data = load_capture(value[\"capture\"])\n require(sha(encoded(captured)) == digest(value[\"captureHash\"]), \"integrity\", \"Capture metadata changed.\")\n require(value[\"entries\"] == manifest_entries(data), \"coverage\", \"Manifest differs from exact captured diff.\")\n return value, captured\n\n\ndef validate_plan(plan):\n closed(plan, \"schemaVersion resolutionId protocol sourceHash obligations\")\n v1(plan[\"schemaVersion\"])\n identifier(plan[\"resolutionId\"])\n digest(plan[\"sourceHash\"])\n protocol = plan[\"protocol\"]\n inline = type(protocol) is dict and protocol.get(\"version\") == INLINE_VERSION\n if inline:\n closed(protocol, \"version digest\")\n digest(protocol[\"digest\"])\n else:\n closed(protocol, \"version content digest\")\n require(protocol[\"version\"] == VERSION and sha(string(protocol[\"content\"]).encode()) == digest(protocol[\"digest\"]),\n \"protocol\", \"Materialized protocol version/content digest mismatch.\")\n obligations = {}\n talents = {}\n custom_identities = set()\n applied = {}\n for obligation in array(plan[\"obligations\"]):\n require(type(obligation) is dict and obligation.get(\"kind\") in (\"grace\", \"custom\"), \"plan\", \"Unknown obligation kind.\")\n common = \"kind obligationId appliedExpertiseId severity\"\n if obligation[\"kind\"] == \"grace\":\n closed(obligation, common + \" talentId ruleId rulesDigest\")\n tid, rid = string(obligation[\"talentId\"]), string(obligation[\"ruleId\"])\n require(obligation[\"obligationId\"] == tid + \":\" + rid and \":\" not in tid and \":\" not in rid,\n \"plan\", \"Grace obligation identity mismatch.\")\n value = digest(obligation[\"rulesDigest\"])\n require(tid not in talents or talents[tid] == value, \"plan\", \"Conflicting rules digests.\")\n talents[tid] = value\n require(tid not in applied or applied[tid] == obligation[\"appliedExpertiseId\"], \"plan\", \"Talent has inconsistent applied identity.\")\n applied[tid] = obligation[\"appliedExpertiseId\"]\n else:\n closed(obligation, common + \" expertiseId expertiseVersionId \" + (\"instructionDigest\" if inline else \"contentDigest instruction\"))\n identifier(obligation[\"expertiseId\"]); identifier(obligation[\"expertiseVersionId\"])\n identity = (obligation[\"expertiseId\"], obligation[\"expertiseVersionId\"])\n require(identity not in custom_identities, \"plan\", \"Duplicate Custom identity/version.\")\n custom_identities.add(identity)\n require(obligation[\"obligationId\"] == obligation[\"appliedExpertiseId\"] and obligation[\"severity\"] == \"blocking\",\n \"plan\", \"Custom identity or blocking severity mismatch.\")\n if inline:\n digest(obligation[\"instructionDigest\"])\n else:\n require(sha(string(obligation[\"instruction\"]).encode()) == digest(obligation[\"contentDigest\"]),\n \"plan\", \"Custom instruction digest mismatch.\")\n identifier(obligation[\"appliedExpertiseId\"])\n require(obligation[\"severity\"] in (\"blocking\", \"warning\", \"info\"), \"plan\", \"Unknown severity.\")\n oid = string(obligation[\"obligationId\"])\n require(oid not in obligations, \"plan\", \"Duplicate expected obligation.\")\n obligations[oid] = obligation\n require(bool(obligations), \"plan\", \"No expected obligations; do not manufacture an empty review.\")\n return obligations\n\n\ndef validate_packet(packet):\n require(len(encoded(packet)) <= PACKET_LIMIT, \"size\", \"Packet exceeds 65536 bytes; repartition explicitly.\")\n closed(packet, PACKET_KEYS)\n string(packet[\"reviewId\"]); string(packet[\"resolutionId\"])\n require(type(packet[\"maxPacketBytes\"]) is int and packet[\"maxPacketBytes\"] == PACKET_LIMIT,\n \"size\", \"Packet cannot override the trusted 65536-byte limit.\")\n for key in (\"files\", \"talentIds\", \"obligationIds\"):\n ordered(packet[key])\n require(packet[\"obligationIds\"] and packet[\"entries\"], \"empty_packet\", \"Each packet needs entries and obligations.\")\n ids = []\n for entry in array(packet[\"entries\"]):\n closed(entry, \"entryId file kind content\")\n git_path(entry[\"file\"]); string(entry[\"content\"])\n require(entry[\"kind\"] in (\"header\", \"hunk\") and entry_id(entry) == entry[\"entryId\"], \"entry\", \"Entry identity mismatch.\")\n require(entry[\"content\"].startswith(\"diff --git \" if entry[\"kind\"] == \"header\" else \"@@ \"), \"entry\", \"Entry kind mismatch.\")\n ids.append(entry[\"entryId\"])\n require(len(set(ids)) == len(ids) and packet[\"files\"] == sorted({e[\"file\"] for e in packet[\"entries\"]}),\n \"entry\", \"Duplicate entry or inconsistent files.\")\n tids = []\n for value in array(packet[\"rulesDigests\"]):\n closed(value, \"talentId rulesDigest\")\n tids.append(string(value[\"talentId\"])); digest(value[\"rulesDigest\"])\n require(tids == packet[\"talentIds\"], \"rules\", \"Exactly one ordered digest per talent is required.\")\n dependencies = []\n for dependency in array(packet[\"dependencies\"]):\n closed(dependency, \"packetId entryIds obligationIds\")\n ordered(dependency[\"entryIds\"]); ordered(dependency[\"obligationIds\"])\n require(dependency[\"entryIds\"] or dependency[\"obligationIds\"], \"dependency\", \"Empty dependency.\")\n dependencies.append(string(dependency[\"packetId\"]))\n ordered(dependencies)\n require(packet[\"packetId\"] not in dependencies, \"dependency\", \"Self dependency.\")\n require(packet_id(packet[\"obligationIds\"]) == packet[\"packetId\"] and packet_hash(packet) == packet[\"packetHash\"],\n \"hash\", \"Packet identity/hash mismatch.\")\n\n\ndef validate_graph(packets):\n by_id = {p[\"packetId\"]: p for p in packets}\n require(len(by_id) == len(packets), \"packet\", \"Duplicate packet identity.\")\n for packet in packets:\n validate_packet(packet)\n for dependency in packet[\"dependencies\"]:\n upstream = by_id.get(dependency[\"packetId\"])\n require(upstream is not None, \"dependency\", \"Missing upstream packet.\")\n require(set(dependency[\"entryIds\"]) <= {e[\"entryId\"] for e in upstream[\"entries\"]}\n and set(dependency[\"obligationIds\"]) <= set(upstream[\"obligationIds\"]),\n \"dependency\", \"Dependency identifiers do not belong to upstream packet.\")\n remaining = {key: {d[\"packetId\"] for d in p[\"dependencies\"]} for key, p in by_id.items()}\n while remaining:\n ready = {key for key, deps in remaining.items() if not deps}\n require(ready, \"cycle\", \"Packet dependency graph contains a cycle.\")\n remaining = {key: deps - ready for key, deps in remaining.items() if key not in ready}\n return by_id\n\n\ndef check_bindings(packet, plan):\n obligations = validate_plan(plan)\n require(packet[\"resolutionId\"] == plan[\"resolutionId\"] and set(packet[\"obligationIds\"]) <= set(obligations),\n \"binding\", \"Packet differs from expected resolution/obligations.\")\n mapping = {obligations[oid][\"talentId\"]: obligations[oid][\"rulesDigest\"] for oid in packet[\"obligationIds\"]\n if obligations[oid][\"kind\"] == \"grace\"}\n require(packet[\"rulesDigests\"] == [{\"talentId\": tid, \"rulesDigest\": value} for tid, value in sorted(mapping.items())],\n \"binding\", \"Packet rules differ from the materialized plan.\")\n\n\ndef pack(request):\n manifest_value, captured = load_manifest(request[\"manifest\"])\n plan = read_json(request[\"plan\"])\n obligations = validate_plan(plan)\n require(plan[\"sourceHash\"] == sha(encoded(captured[\"changeSource\"])), \"source\", \"Plan binds a different change source.\")\n entries = {e[\"entryId\"]: e for e in manifest_value[\"entries\"]}\n packets, attempts = [], []\n assigned, covered = [], set()\n for assignment in array(request[\"assignments\"]):\n closed(assignment, \"entryIds obligationIds dependencies reviewId attemptId reviewer\")\n ordered(assignment[\"entryIds\"]); ordered(assignment[\"obligationIds\"])\n require(set(assignment[\"entryIds\"]) <= set(entries) and set(assignment[\"obligationIds\"]) <= set(obligations),\n \"assignment\", \"Unknown entry or obligation in assignment.\")\n selected = [e for e in manifest_value[\"entries\"] if e[\"entryId\"] in assignment[\"entryIds\"]]\n mapping = {obligations[oid][\"talentId\"]: obligations[oid][\"rulesDigest\"] for oid in assignment[\"obligationIds\"]\n if obligations[oid][\"kind\"] == \"grace\"}\n packet = {\"reviewId\": string(assignment[\"reviewId\"]), \"packetId\": packet_id(assignment[\"obligationIds\"]),\n \"resolutionId\": plan[\"resolutionId\"], \"packetHash\": \"\", \"maxPacketBytes\": PACKET_LIMIT,\n \"files\": sorted({e[\"file\"] for e in selected}), \"entries\": selected, \"talentIds\": sorted(mapping),\n \"rulesDigests\": [{\"talentId\": tid, \"rulesDigest\": value} for tid, value in sorted(mapping.items())],\n \"obligationIds\": assignment[\"obligationIds\"], \"dependencies\": assignment[\"dependencies\"]}\n packet[\"packetHash\"] = packet_hash(packet)\n validate_packet(packet)\n packets.append(packet)\n attempts.append({\"reviewId\": packet[\"reviewId\"], \"attemptId\": identifier(assignment[\"attemptId\"]),\n \"packetId\": packet[\"packetId\"], \"packetHash\": packet[\"packetHash\"],\n \"reviewer\": string(assignment[\"reviewer\"]), \"role\": \"primary\", \"status\": \"pending\", \"response\": None})\n assigned.extend(assignment[\"obligationIds\"]); covered.update(assignment[\"entryIds\"])\n require(sorted(assigned) == sorted(obligations) and covered == set(entries), \"coverage\", \"Obligation assignment or entry coverage is incomplete/duplicated.\")\n require(len({a[\"reviewId\"] for a in attempts}) == len(attempts) and len({a[\"attemptId\"] for a in attempts}) == len(attempts),\n \"attempt\", \"Attempt/review identities must be unique.\")\n validate_graph(packets)\n directory = new_directory(request[\"outputDirectory\"])\n for packet in packets:\n write_new(directory / (packet[\"packetId\"] + \".json\"), encoded(packet))\n state = {\"schemaVersion\": 1, \"revision\": 0, \"generation\": 0, \"plan\": plan, \"planHash\": sha(encoded(plan)),\n \"manifest\": request[\"manifest\"], \"manifestHash\": sha(encoded(manifest_value)),\n \"fullDiffHash\": captured[\"fullDiff\"][\"sha256\"], \"packets\": [encoded(p).decode() for p in packets],\n \"attempts\": attempts, \"finals\": {}, \"previousFinals\": {}, \"reports\": []}\n artifact = write_new(directory / \"state.json\", encoded(state))\n return [artifact], {\"packets\": len(packets), \"aboveTarget\": sum(len(encoded(p)) > PACKET_TARGET for p in packets),\n \"packetDirectory\": str(directory)}\n\n\ndef load_state(path, raw=None):\n raw = read_bytes(path) if raw is None else raw\n state = parse(raw)\n closed(state, \"schemaVersion revision generation plan planHash manifest manifestHash fullDiffHash packets attempts finals previousFinals reports\")\n v1(state[\"schemaVersion\"])\n require(type(state[\"revision\"]) is int and state[\"revision\"] >= 0, \"state\", \"Invalid state revision.\")\n require(type(state[\"generation\"]) is int and state[\"generation\"] >= 0, \"state\", \"Invalid review generation.\")\n validate_plan(state[\"plan\"])\n require(sha(encoded(state[\"plan\"])) == digest(state[\"planHash\"]), \"state\", \"Plan digest mismatch.\")\n packets = [parse(string(p).encode(), PACKET_LIMIT) for p in array(state[\"packets\"])]\n validate_graph(packets)\n for packet in packets:\n check_bindings(packet, state[\"plan\"])\n validate_lifecycle(state, packets)\n return state, packets, sha(raw)\n\n\ndef validate_verdict(verdict, identity_keys, custom=False):\n closed(verdict, identity_keys + \" verdict justification evidence missingEvidence\")\n require(verdict[\"verdict\"] in (\"respected\", \"violated\", \"not_applicable\", \"inconclusive\"), \"verdict\", \"Unknown verdict.\")\n require(not custom or verdict[\"verdict\"] != \"not_applicable\", \"custom\", \"Custom obligations cannot be not_applicable.\")\n string(verdict[\"justification\"])\n for evidence in array(verdict[\"evidence\"]):\n closed(evidence, \"location explanation\")\n match = re.fullmatch(r\"(.+?):([1-9][0-9]*)(?::([1-9][0-9]*))?\", string(evidence[\"location\"]))\n require(match is not None, \"evidence\", \"Evidence needs a relative file:line[:column] location.\")\n git_path(match.group(1)); string(evidence[\"explanation\"])\n ordered(verdict[\"missingEvidence\"])\n if verdict[\"verdict\"] == \"inconclusive\":\n require(verdict[\"missingEvidence\"], \"evidence\", \"Inconclusive verdict needs missingEvidence.\")\n else:\n require(verdict[\"evidence\"] and not verdict[\"missingEvidence\"], \"evidence\", \"Conclusive verdict needs evidence and no missingEvidence.\")\n\n\ndef validate_preserved_payload(payload):\n closed(payload, \"submissionId resolutionId talentResults expertiseResults\")\n identifier(payload[\"submissionId\"]); identifier(payload[\"resolutionId\"])\n talents, custom = [], []\n for talent in array(payload[\"talentResults\"]):\n closed(talent, \"talentId rulesDigest ruleResults\")\n talents.append(string(talent[\"talentId\"])); digest(talent[\"rulesDigest\"])\n rules = []\n for verdict in array(talent[\"ruleResults\"]):\n validate_verdict(verdict, \"ruleId\")\n rules.append(string(verdict[\"ruleId\"]))\n ordered(rules)\n ordered(talents)\n for verdict in array(payload[\"expertiseResults\"]):\n validate_verdict(verdict, \"expertiseId expertiseVersionId\", True)\n custom.append((identifier(verdict[\"expertiseId\"]), identifier(verdict[\"expertiseVersionId\"])))\n require(custom == sorted(set(custom)), \"report\", \"Duplicate or unsorted Custom result identities.\")\n\n\ndef validate_response(response, packet, plan):\n closed(response, \"reviewId packetId packetHash rulesDigests verdicts\")\n string(response[\"reviewId\"])\n require(response[\"packetId\"] == packet[\"packetId\"] and response[\"packetHash\"] == packet[\"packetHash\"]\n and response[\"rulesDigests\"] == packet[\"rulesDigests\"], \"response_binding\", \"Response packet/hash/rules mapping differs from current assignment.\")\n obligations = validate_plan(plan)\n ids = []\n for verdict in array(response[\"verdicts\"]):\n closed(verdict, \"obligationId verdict justification evidence missingEvidence\")\n oid = string(verdict[\"obligationId\"])\n require(oid in obligations, \"verdict\", \"Unknown obligation in response.\")\n ids.append(oid)\n validate_verdict(verdict, \"obligationId\", obligations[oid][\"kind\"] == \"custom\")\n require(ids == packet[\"obligationIds\"], \"coverage\", \"Response verdicts must exactly cover assigned obligations, sorted and unique.\")\n\n\ndef validate_lifecycle(state, packets):\n by_id = {p[\"packetId\"]: p for p in packets}\n reviews, executions, primaries = set(), set(), set()\n attempts = {}\n for attempt in array(state[\"attempts\"]):\n closed(attempt, \"reviewId attemptId packetId packetHash reviewer role status response\")\n rid = string(attempt[\"reviewId\"])\n aid = identifier(attempt[\"attemptId\"])\n require(rid not in reviews and aid not in executions, \"attempt\", \"Reused attempt identity in state.\")\n reviews.add(rid); executions.add(aid); attempts[rid] = attempt\n string(attempt[\"reviewer\"]); string(attempt[\"packetId\"]); digest(attempt[\"packetHash\"])\n require(attempt[\"role\"] in (\"primary\", \"second\") and attempt[\"status\"] in (\"pending\", \"consumed\", \"revoked\"),\n \"attempt\", \"Invalid attempt role or lifecycle state.\")\n if attempt[\"status\"] == \"pending\":\n require(attempt[\"response\"] is None, \"attempt\", \"Pending attempt already has a response.\")\n packet = by_id.get(attempt[\"packetId\"])\n require(packet is not None and packet[\"packetHash\"] == attempt[\"packetHash\"], \"attempt\", \"Pending attempt targets a stale packet.\")\n if attempt[\"role\"] == \"primary\":\n require(attempt[\"packetId\"] not in primaries, \"attempt\", \"Multiple pending primary attempts.\")\n primaries.add(attempt[\"packetId\"])\n if attempt[\"status\"] == \"consumed\":\n require(type(attempt[\"response\"]) is dict, \"attempt\", \"Consumed attempt lacks its response.\")\n if attempt[\"response\"] is not None:\n closed(attempt[\"response\"], \"reviewId packetId packetHash rulesDigests verdicts\")\n response = attempt[\"response\"]\n ids = []\n for verdict in array(response[\"verdicts\"]):\n validate_verdict(verdict, \"obligationId\")\n ids.append(string(verdict[\"obligationId\"]))\n ordered(ids)\n talents = []\n for mapping in array(response[\"rulesDigests\"]):\n closed(mapping, \"talentId rulesDigest\")\n talents.append(string(mapping[\"talentId\"])); digest(mapping[\"rulesDigest\"])\n ordered(talents)\n require(all(attempt[\"response\"][key] == attempt[key] for key in (\"reviewId\", \"packetId\", \"packetHash\")),\n \"attempt\", \"Stored response differs from attempt binding.\")\n require(type(state[\"finals\"]) is dict and type(state[\"previousFinals\"]) is dict, \"state\", \"Final selections must be objects.\")\n for packet_id_value, selection in state[\"finals\"].items():\n closed(selection, \"reviewId reason\")\n string(selection[\"reason\"])\n attempt = attempts.get(selection[\"reviewId\"])\n require(attempt is not None and attempt[\"status\"] == \"consumed\" and attempt[\"packetId\"] == packet_id_value\n and packet_id_value in by_id, \"final\", \"Final selection is not a consumed current attempt.\")\n require(not any(a[\"packetId\"] == packet_id_value and a[\"status\"] == \"pending\" for a in attempts.values()),\n \"final\", \"A pending second view prevents finalization.\")\n validate_response(attempt[\"response\"], by_id[packet_id_value], state[\"plan\"])\n for packet_id_value, review_id in state[\"previousFinals\"].items():\n attempt = attempts.get(review_id)\n require(attempt is not None and attempt[\"response\"] is not None and attempt[\"packetId\"] == packet_id_value,\n \"state\", \"Previous final response is missing.\")\n submissions = set()\n for report in array(state[\"reports\"]):\n closed(report, \"submissionId payload payloadHash revision generation\")\n require(identifier(report[\"submissionId\"]) not in submissions, \"report\", \"Duplicate report submission identity.\")\n submissions.add(report[\"submissionId\"])\n validate_preserved_payload(report[\"payload\"])\n require(report[\"payload\"][\"submissionId\"] == report[\"submissionId\"] and sha(encoded(report[\"payload\"])) == digest(report[\"payloadHash\"]),\n \"report\", \"Preserved report payload changed.\")\n require(type(report[\"revision\"]) is int and 0 <= report[\"revision\"] <= state[\"revision\"], \"report\", \"Invalid report revision.\")\n require(type(report[\"generation\"]) is int and 0 <= report[\"generation\"] <= state[\"generation\"], \"report\", \"Invalid report generation.\")\n\n\ndef global_bindings(state, packets):\n value, captured = load_manifest(state[\"manifest\"])\n require(sha(encoded(value)) == state[\"manifestHash\"] and captured[\"fullDiff\"][\"sha256\"] == state[\"fullDiffHash\"]\n and sha(encoded(captured[\"changeSource\"])) == state[\"plan\"][\"sourceHash\"], \"state\", \"State source/manifest binding mismatch.\")\n covered, assigned = set(), []\n for packet in packets:\n ids = {e[\"entryId\"] for e in packet[\"entries\"]}\n require(packet[\"entries\"] == [e for e in value[\"entries\"] if e[\"entryId\"] in ids],\n \"coverage\", \"Packet is not an ordered subset of the manifest.\")\n covered.update(ids); assigned.extend(packet[\"obligationIds\"])\n require(covered == {e[\"entryId\"] for e in value[\"entries\"]} and sorted(assigned) == sorted(validate_plan(state[\"plan\"])),\n \"coverage\", \"Global coverage differs from manifest/plan.\")\n return value\n\n\n@contextmanager\ndef locked_state(request):\n path = local_path(request[\"state\"])\n with anchored_parent(path) as (name, parent):\n lock = str(name) + \".lock\"\n try:\n fd = open_anchored(lock, parent, write=True, create=True)\n except FileExistsError:\n raise Refusal(\"locked\", \"State is locked; verify the writer has stopped before explicit lock recovery.\") from None\n os.close(fd)\n temporary = None\n try:\n state, packets, old_hash = load_state(str(path), read_anchored(name, parent, ARTIFACT_LIMIT))\n require(old_hash == digest(request[\"expectedStateHash\"]), \"state_conflict\", \"State changed; reread before making a new decision.\")\n global_bindings(state, packets)\n yield state, packets\n state[\"revision\"] += 1\n validate_lifecycle(state, [parse(p.encode(), PACKET_LIMIT) for p in state[\"packets\"]])\n data = encoded(state)\n require(len(data) <= ARTIFACT_LIMIT, \"size\", \"State exceeds local artifact limit.\")\n temporary = (path.parent if os.name == \"nt\" else Path()) / (\".review-state-\" + uuid.uuid4().hex)\n fd = open_anchored(temporary, parent, write=True, create=True)\n with os.fdopen(fd, \"wb\") as stream:\n stream.write(data); stream.flush(); os.fsync(stream.fileno())\n require(sha(read_anchored(name, parent, ARTIFACT_LIMIT)) == old_hash,\n \"state_conflict\", \"State changed despite the lock; stop all writers.\")\n replace_args = {} if os.name == \"nt\" else {\"src_dir_fd\": parent[\"dir_fd\"], \"dst_dir_fd\": parent[\"dir_fd\"]}\n os.replace(temporary, name, **replace_args)\n temporary = None\n finally:\n if temporary is not None:\n os.unlink(temporary, **parent)\n os.unlink(lock, **parent)\n\n\ndef response_for(state, review_id):\n return next(a[\"response\"] for a in state[\"attempts\"] if a[\"reviewId\"] == review_id)\n\n\ndef reverse_closure(packets, seeds):\n invalid = set(seeds)\n while True:\n added = {p[\"packetId\"] for p in packets if any(d[\"packetId\"] in invalid for d in p[\"dependencies\"])} - invalid\n if not added:\n return invalid\n invalid.update(added)\n\n\ndef revoke(state, packet_ids):\n for attempt in state[\"attempts\"]:\n if attempt[\"packetId\"] in packet_ids:\n attempt[\"status\"] = \"revoked\"\n for pid in packet_ids:\n if pid in state[\"finals\"]:\n state[\"previousFinals\"][pid] = state[\"finals\"].pop(pid)[\"reviewId\"]\n\n\ndef project_report(state, packets, submission_id):\n require(set(state[\"finals\"]) == {p[\"packetId\"] for p in packets}, \"coverage\", \"Final verdicts are incomplete.\")\n obligations = validate_plan(state[\"plan\"])\n verdicts = {}\n for selection in state[\"finals\"].values():\n for item in response_for(state, selection[\"reviewId\"])[\"verdicts\"]:\n require(item[\"obligationId\"] not in verdicts, \"coverage\", \"Multiple final verdicts for one obligation.\")\n verdicts[item[\"obligationId\"]] = item\n require(set(verdicts) == set(obligations), \"coverage\", \"Final verdict coverage mismatch.\")\n talents, custom = {}, []\n for oid, obligation in sorted(obligations.items()):\n verdict = verdicts[oid]\n result = {key: verdict[key] for key in (\"verdict\", \"justification\", \"evidence\", \"missingEvidence\")}\n if obligation[\"kind\"] == \"grace\":\n group_value = talents.setdefault(obligation[\"talentId\"], {\"talentId\": obligation[\"talentId\"],\n \"rulesDigest\": obligation[\"rulesDigest\"], \"ruleResults\": []})\n group_value[\"ruleResults\"].append({\"ruleId\": obligation[\"ruleId\"], **result})\n else:\n custom.append({\"expertiseId\": obligation[\"expertiseId\"], \"expertiseVersionId\": obligation[\"expertiseVersionId\"], **result})\n return {\"submissionId\": identifier(submission_id), \"resolutionId\": state[\"plan\"][\"resolutionId\"],\n \"talentResults\": [talents[key] for key in sorted(talents)],\n \"expertiseResults\": sorted(custom, key=lambda x: (x[\"expertiseId\"], x[\"expertiseVersionId\"]))}\n\n\ndef materialize_exact(path, data):\n if path.exists():\n require(read_bytes(str(path)) == data, \"artifact_conflict\", \"Existing immutable artifact has different bytes.\")\n return {\"path\": str(path), \"bytes\": len(data), \"sha256\": sha(data)}\n return write_new(path, data)\n\n\ndef accept(request):\n identifier(request[\"submissionId\"])\n artifacts = []\n with locked_state(request) as (state, packets):\n by_id = {p[\"packetId\"]: p for p in packets}\n previous = {pid: response_for(state, selection[\"reviewId\"])[\"verdicts\"] for pid, selection in state[\"finals\"].items()}\n previous.update({pid: response_for(state, rid)[\"verdicts\"] for pid, rid in state[\"previousFinals\"].items() if pid not in previous})\n if request[\"response\"] is not None:\n raw = read_bytes(request[\"response\"], PACKET_LIMIT)\n if request[\"repair\"] is not None:\n repair = request[\"repair\"]\n closed(repair, \"original originalSha256 semanticSha256\")\n original = read_bytes(repair[\"original\"], PACKET_LIMIT)\n require(sha(original) == digest(repair[\"originalSha256\"]), \"repair\", \"Original envelope changed.\")\n # Only this explicit, unambiguous markdown envelope is repairable.\n require(original.startswith(b\"```json\\n\") and original.endswith(b\"\\n```\"), \"repair\", \"Unsupported envelope; request a new response.\")\n old = parse(original[8:-4], PACKET_LIMIT)\n response = parse(raw, PACKET_LIMIT)\n require(old == response and sha(encoded(old)) == digest(repair[\"semanticSha256\"]), \"repair\", \"Envelope repair changed semantic content.\")\n else:\n response = parse(raw, PACKET_LIMIT)\n closed(response, \"reviewId packetId packetHash rulesDigests verdicts\")\n attempt = next((a for a in state[\"attempts\"] if a[\"reviewId\"] == response[\"reviewId\"]), None)\n require(attempt is not None and attempt[\"status\"] == \"pending\", \"attempt\", \"Unknown, revoked or consumed attempt; do not replay a response.\")\n require(string(request[\"reviewer\"]) == attempt[\"reviewer\"], \"reviewer\", \"Harness-supplied reviewer differs from assignment.\")\n packet = by_id[attempt[\"packetId\"]]\n validate_response(response, packet, state[\"plan\"])\n attempt.update(status=\"consumed\", response=response)\n active = [a for a in state[\"attempts\"] if a[\"packetId\"] == packet[\"packetId\"] and a[\"status\"] != \"revoked\"]\n if len(active) == 1 and attempt[\"role\"] == \"primary\":\n state[\"finals\"][packet[\"packetId\"]] = {\"reviewId\": attempt[\"reviewId\"], \"reason\": \"Unique primary response\"}\n else:\n require(request[\"reviewer\"] is None and request[\"repair\"] is None, \"schema\", \"Arbitration/export without response has no reviewer or repair.\")\n arbitrated = set()\n for decision in array(request[\"arbitration\"]):\n closed(decision, \"packetId reviewId reason\")\n pid = decision[\"packetId\"]\n require(pid in by_id and pid not in arbitrated, \"arbitration\", \"Unknown or repeated packet arbitration.\")\n arbitrated.add(pid); string(decision[\"reason\"])\n active = [a for a in state[\"attempts\"] if a[\"packetId\"] == pid and a[\"status\"] != \"revoked\"]\n require(active and all(a[\"status\"] == \"consumed\" for a in active), \"arbitration\", \"Wait for every active view or explicitly revoke/reissue.\")\n require(any(a[\"reviewId\"] == decision[\"reviewId\"] for a in active), \"arbitration\", \"Chosen view is not an active consumed response.\")\n state[\"finals\"][pid] = {\"reviewId\": decision[\"reviewId\"], \"reason\": decision[\"reason\"]}\n changed = {pid for pid, selection in state[\"finals\"].items() if pid in previous\n and response_for(state, selection[\"reviewId\"])[\"verdicts\"] != previous[pid]}\n # A changed final can itself depend on another changed final in this call.\n dependents = {p[\"packetId\"] for p in packets if any(d[\"packetId\"] in changed for d in p[\"dependencies\"])}\n invalidated = reverse_closure(packets, dependents)\n revoke(state, invalidated)\n for pid in set(state[\"finals\"]) - invalidated:\n state[\"previousFinals\"].pop(pid, None)\n complete = set(state[\"finals\"]) == set(by_id)\n payload = None\n if complete:\n payload = project_report(state, packets, request[\"submissionId\"])\n payload_hash = sha(encoded(payload))\n existing = next((r for r in state[\"reports\"] if r[\"submissionId\"] == request[\"submissionId\"]), None)\n if existing:\n require(existing[\"payloadHash\"] == payload_hash and existing[\"generation\"] == state[\"generation\"],\n \"submission_conflict\", \"A new review generation requires a new submissionId; retries must preserve exact payload.\")\n else:\n require(not any(r[\"generation\"] == state[\"generation\"] for r in state[\"reports\"]),\n \"submission_conflict\", \"This generation already has a submissionId; retry that exact report.\")\n state[\"reports\"].append({\"submissionId\": request[\"submissionId\"], \"payload\": payload,\n \"payloadHash\": payload_hash, \"revision\": state[\"revision\"] + 1, \"generation\": state[\"generation\"]})\n validate_lifecycle({**state, \"revision\": state[\"revision\"] + 1}, packets)\n if payload is not None:\n report_path = Path(request[\"state\"]).parent / (\"report-\" + request[\"submissionId\"] + \".json\")\n artifacts.append(materialize_exact(report_path, encoded(payload)))\n summary = {\"complete\": complete, \"finalPackets\": len(state[\"finals\"]), \"invalidatedCount\": len(invalidated),\n \"recorded\": False, \"nextAction\": \"Submit the exact preserved report; retain the server acknowledgment separately.\" if complete else \"Complete or arbitrate remaining views.\"}\n raw = read_bytes(request[\"state\"])\n artifacts.insert(0, {\"path\": request[\"state\"], \"bytes\": len(raw), \"sha256\": sha(raw)})\n return artifacts, summary\n\n\ndef invalidate(request):\n artifacts = []\n outgoing = []\n with locked_state(request) as (state, previous_packets):\n current, current_packets, current_hash = load_state(request[\"current\"])\n require(current_hash == digest(request[\"currentStateHash\"]), \"state_conflict\", \"Current candidate state changed.\")\n global_bindings(current, current_packets)\n before = {p[\"packetId\"]: p for p in previous_packets}\n after = {p[\"packetId\"]: p for p in current_packets}\n old_obligations, new_obligations = validate_plan(state[\"plan\"]), validate_plan(current[\"plan\"])\n changed = set(before) ^ set(after)\n for pid in set(before) & set(after):\n if before[pid][\"packetHash\"] != after[pid][\"packetHash\"] or any(old_obligations.get(oid) != new_obligations.get(oid) for oid in after[pid][\"obligationIds\"]):\n changed.add(pid)\n if any(state[\"plan\"][key] != current[\"plan\"][key] for key in (\"resolutionId\", \"protocol\")):\n changed.update(before); changed.update(after)\n if changed and any(a[\"response\"] is not None for a in state[\"attempts\"]):\n require(set(state[\"finals\"]) == set(before) and state[\"reports\"], \"report_required\", \"Preserve the exhaustive report before correction/invalidation.\")\n latest = project_report(state, previous_packets, state[\"reports\"][-1][\"submissionId\"])\n require(sha(encoded(latest)) == state[\"reports\"][-1][\"payloadHash\"], \"report_required\", \"Current exhaustive report has not been preserved.\")\n for pid in ordered(request[\"upstreamChanges\"]):\n require(pid in state[\"finals\"] and pid in current[\"finals\"], \"upstream\", \"An upstream change requires both observed final responses.\")\n old_response = response_for(state, state[\"finals\"][pid][\"reviewId\"])\n new_response = response_for(current, current[\"finals\"][pid][\"reviewId\"])\n require(old_response[\"verdicts\"] != new_response[\"verdicts\"], \"upstream\", \"Upstream final verdict did not change.\")\n changed.add(pid)\n attempts = array(request[\"attempts\"])\n reissued = set()\n for item in attempts:\n closed(item, \"reviewId attemptId packetId reviewer role reason\")\n require(item[\"packetId\"] in after and item[\"role\"] in (\"primary\", \"second\"), \"attempt\", \"Unknown packet/attempt role.\")\n string(item[\"reason\"])\n if item[\"role\"] == \"primary\":\n require(item[\"packetId\"] not in reissued, \"attempt\", \"Only one new primary per packet.\")\n reissued.add(item[\"packetId\"])\n invalidated = reverse_closure(previous_packets + [p for p in current_packets if p not in previous_packets], changed | reissued)\n revoke(state, invalidated)\n if invalidated or attempts:\n state[\"generation\"] += 1\n state.update({key: current[key] for key in (\"plan\", \"planHash\", \"manifest\", \"manifestHash\", \"fullDiffHash\", \"packets\")})\n for item in attempts:\n require(not any(a[\"reviewId\"] == item[\"reviewId\"] or a[\"attemptId\"] == item[\"attemptId\"] for a in state[\"attempts\"]),\n \"attempt\", \"Never reuse a reviewId or execution attemptId, including revoked attempts.\")\n pid = item[\"packetId\"]\n if item[\"role\"] == \"second\":\n require(any(a[\"packetId\"] == pid and a[\"role\"] == \"primary\" and a[\"status\"] != \"revoked\" for a in state[\"attempts\"]),\n \"attempt\", \"A second view needs an active primary.\")\n if pid in state[\"finals\"]:\n state[\"previousFinals\"][pid] = state[\"finals\"].pop(pid)[\"reviewId\"]\n packet = {**after[pid], \"reviewId\": string(item[\"reviewId\"])}\n validate_packet(packet)\n state[\"attempts\"].append({\"reviewId\": item[\"reviewId\"], \"attemptId\": identifier(item[\"attemptId\"]), \"packetId\": pid,\n \"packetHash\": packet[\"packetHash\"], \"reviewer\": string(item[\"reviewer\"]), \"role\": item[\"role\"],\n \"status\": \"pending\", \"response\": None})\n path = Path(request[\"state\"]).parent / (\"attempt-\" + sha(frame(item[\"reviewId\"])) + \".json\")\n outgoing.append((path, encoded(packet)))\n validate_lifecycle(state, current_packets)\n transition = {\"revision\": state[\"revision\"] + 1, \"invalidated\": sorted(invalidated),\n \"preserved\": sorted(set(after) - invalidated), \"attempts\": []}\n for path, data in outgoing:\n transition[\"attempts\"].append(materialize_exact(path, data))\n transition_path = Path(request[\"state\"]).parent / (\"transition-\" + str(state[\"revision\"] + 1) + \".json\")\n artifacts.append(materialize_exact(transition_path, encoded(transition)))\n summary = {\"invalidatedCount\": len(invalidated), \"preservedCount\": len(set(after) - invalidated), \"newAttempts\": len(attempts)}\n raw = read_bytes(request[\"state\"])\n artifacts.insert(0, {\"path\": request[\"state\"], \"bytes\": len(raw), \"sha256\": sha(raw)})\n return artifacts, summary\n\n\ndef verify_pages(request):\n \"\"\"Check retained server pages and an already materialized file; never write or fetch.\"\"\"\n require(request[\"packet\"] is None and request[\"state\"] is None\n and request[\"dependencies\"] == [] and request[\"range\"] is None,\n \"verify\", \"Page verification cannot be combined with packet/state verification.\")\n expected = request[\"expected\"]\n closed(expected, \"format pages materialized resolutionId locale view target section indexDigest contentDigest rulesDigest protocolVersion\")\n require(expected[\"format\"] == \"paged-v1\" and expected[\"locale\"] in (\"fr\", \"en\")\n and expected[\"view\"] in (\"index\", \"rules\", \"custom\", \"protocol\", \"deepen\"),\n \"page_binding\", \"Unknown page format, locale or view.\")\n if expected[\"resolutionId\"] is not None:\n identifier(expected[\"resolutionId\"])\n deepen = expected[\"view\"] == \"deepen\"\n require(deepen or expected[\"resolutionId\"] is not None, \"page_binding\", \"Review pages require a resolution.\")\n if deepen or expected[\"view\"] in (\"rules\", \"custom\"):\n string(expected[\"target\"])\n else:\n require(expected[\"target\"] is None, \"page_binding\", \"This view has no target.\")\n require(deepen or expected[\"section\"] is None, \"page_binding\", \"Only deepen has sections.\")\n if expected[\"section\"] is not None:\n string(expected[\"section\"])\n for key in (\"indexDigest\", \"contentDigest\"):\n digest(expected[key])\n if expected[\"rulesDigest\"] is not None:\n digest(expected[\"rulesDigest\"])\n require((expected[\"view\"] == \"rules\" or expected[\"rulesDigest\"] is None)\n and expected[\"protocolVersion\"] == (None if deepen else VERSION),\n \"page_binding\", \"Unexpected rules digest or protocol version.\")\n if expected[\"view\"] == \"index\":\n require(expected[\"indexDigest\"] == expected[\"contentDigest\"], \"page_binding\", \"Index hashes differ.\")\n paths = array(expected[\"pages\"])\n require(0 < len(paths) <= 4096 and len(set(map(string, paths))) == len(paths),\n \"page_count\", \"Use 1..4096 distinct advancing page files.\")\n offset, total, finished = 0, None, False\n materialized = bytearray()\n for path in paths:\n page = read_json(path, 16384)\n if deepen:\n closed(page, \"format resolutionId locale results\")\n results = array(page[\"results\"])\n require(0 < len(results) <= 20, \"page_count\", \"Invalid deepen batch.\")\n for item in results:\n closed(item, \"uri section status contentDigest indexDigest offset totalBytes fragment nextCursor complete\")\n matches = [item for item in results if item[\"uri\"] == expected[\"target\"] and item[\"section\"] == expected[\"section\"]]\n require(len(matches) == 1, \"page_binding\", \"Expected exactly one URI/section in each retained page.\")\n fragment = matches[0]\n require(fragment[\"status\"] == \"ok\", \"page_unavailable\", \"Missing or inaccessible content cannot become an empty success.\")\n else:\n closed(page, \"format resolutionId locale view target indexDigest contentDigest rulesDigest protocolVersion offset totalBytes fragment nextCursor complete\")\n require(all(page[key] == expected[key] for key in (\"view\", \"target\", \"rulesDigest\", \"protocolVersion\")),\n \"page_binding\", \"View, target, rules or protocol changed.\")\n fragment = page\n require(all(page[key] == expected[key] for key in (\"format\", \"resolutionId\", \"locale\"))\n and all(fragment[key] == expected[key] for key in (\"indexDigest\", \"contentDigest\")),\n \"page_binding\", \"Scope or content changed; revalidate remotely before reusing cache.\")\n require(type(fragment[\"offset\"]) is int and fragment[\"offset\"] == offset and not finished\n and type(fragment[\"totalBytes\"]) is int and 0 <= fragment[\"totalBytes\"] <= ARTIFACT_LIMIT,\n \"page_order\", \"Missing, repeated, reordered or oversized page.\")\n if total is None:\n total = fragment[\"totalBytes\"]\n require(fragment[\"totalBytes\"] == total and type(fragment[\"fragment\"]) is str,\n \"page_binding\", \"Page length or fragment type changed.\")\n raw = fragment[\"fragment\"].encode(\"utf-8\", \"strict\")\n require(raw or total == 0, \"page_deferred\", \"Deferred pages do not advance; retain only advancing pages for this URI.\")\n offset += len(raw)\n require(offset <= total and type(fragment[\"complete\"]) is bool\n and fragment[\"complete\"] == (offset == total), \"page_completion\", \"Invalid completion or byte count.\")\n finished = fragment[\"complete\"]\n if finished:\n require(fragment[\"nextCursor\"] is None, \"page_completion\", \"Completed page has a cursor.\")\n else:\n string(fragment[\"nextCursor\"])\n materialized.extend(raw)\n require(finished and sha(materialized) == expected[\"contentDigest\"],\n \"page_digest\", \"Incomplete content or invalid exact UTF-8 digest.\")\n require(read_bytes(expected[\"materialized\"]) == materialized,\n \"page_materialization\", \"Materialized bytes differ from the verified fragments.\")\n return [], {\"format\": \"paged-v1\", \"pages\": len(paths), \"bytes\": offset,\n \"contentDigest\": expected[\"contentDigest\"], \"complete\": True,\n \"remoteAuthorizationVerified\": False}\n\n\ndef verify(request):\n if type(request[\"expected\"]) is dict and request[\"expected\"].get(\"format\") == \"paged-v1\":\n return verify_pages(request)\n require((request[\"state\"] is None) != (request[\"packet\"] is None), \"verify\", \"Choose packet verification or global state verification.\")\n if request[\"state\"] is not None:\n require(request[\"expected\"] is None and request[\"dependencies\"] == [], \"verify\", \"Global verification reads its bound plan.\")\n state, packets, state_hash = load_state(request[\"state\"])\n value = global_bindings(state, packets)\n summary = {\"packets\": len(packets), \"entries\": len(value[\"entries\"]), \"stateHash\": state_hash}\n else:\n packet = read_json(request[\"packet\"], PACKET_LIMIT)\n closed(packet, PACKET_KEYS)\n expected = request[\"expected\"]\n closed(expected, \"plan packetId packetHash reviewId\")\n plan = read_json(expected[\"plan\"])\n require(all(packet.get(key) == expected[key] for key in (\"packetId\", \"packetHash\", \"reviewId\")),\n \"binding\", \"Packet differs from the coordinator's expected attempt/hash.\")\n packets = [packet]\n for dependency in array(request[\"dependencies\"]):\n closed(dependency, \"path packetId packetHash\")\n item = read_json(dependency[\"path\"], PACKET_LIMIT)\n closed(item, PACKET_KEYS)\n require(all(item.get(key) == dependency[key] for key in (\"packetId\", \"packetHash\")),\n \"binding\", \"Upstream packet differs from expected binding.\")\n packets.append(item)\n validate_graph(packets)\n for item in packets:\n check_bindings(item, plan)\n summary = {\"packetId\": packet[\"packetId\"], \"packetHash\": packet[\"packetHash\"], \"entries\": len(packet[\"entries\"])}\n if request[\"range\"] is not None:\n value = request[\"range\"]\n closed(value, \"offset count\")\n require(type(value[\"offset\"]) is int and value[\"offset\"] >= 0 and type(value[\"count\"]) is int and 1 <= value[\"count\"] <= 20,\n \"range\", \"Use a nonnegative offset and count from 1 to 20.\")\n all_entries = [e for p in packets for e in p[\"entries\"]]\n end = min(value[\"offset\"] + value[\"count\"], len(all_entries))\n summary[\"range\"] = [{\"entryId\": e[\"entryId\"], \"bytes\": len(e[\"content\"].encode())} for e in all_entries[value[\"offset\"]:end]]\n summary[\"nextOffset\"] = end if end < len(all_entries) else None\n return [], summary\n\n\ndef main():\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\"operation\", choices=REQUESTS)\n parser.add_argument(\"--input\", required=True)\n args = parser.parse_args()\n response = {\"schemaVersion\": 1, \"operation\": args.operation, \"ok\": False, \"artifacts\": [], \"summary\": {}, \"errors\": []}\n try:\n require(sys.version_info >= (3, 10), \"python_version\", \"Python 3.10 or later is required.\")\n request = read_json(args.input)\n closed(request, REQUESTS[args.operation])\n require(type(request[\"schemaVersion\"]) is int and request[\"schemaVersion\"] == 1, \"version\", \"Only request schemaVersion 1 is supported.\")\n response[\"artifacts\"], response[\"summary\"] = globals()[args.operation](request)\n response[\"ok\"] = True\n except Refusal as error:\n response[\"errors\"] = [{\"code\": error.code, \"message\": str(error)}]\n except (OSError, UnicodeError, ValueError, TypeError, KeyError, RecursionError):\n response[\"errors\"] = [{\"code\": \"input_or_io\", \"message\": \"Invalid or unavailable local input; check paths, permissions and schema. No automatic retry.\"}]\n output = encoded(response)\n if len(output) > OUTPUT_LIMIT:\n response.update(ok=False, artifacts=[], summary={}, errors=[{\"code\": \"output_size\", \"message\": \"Summary exceeds output limit; use shorter paths or a smaller range.\"}])\n output = encoded(response)\n sys.stdout.buffer.write(output + b\"\\n\")\n return 0 if response[\"ok\"] else 1\n\n\nif __name__ == \"__main__\":\n sys.exit(main())\n","sha256":"6d9851fcc8781772596e6d014ce0f32f90c7235b5f186ed8755bc70be1f1d01a","bytes":78989,"previous":[]},{"path":".agents/skills/grace-review/SKILL.md","kind":"file","content":"---\nname: grace-review\ndescription: \"À utiliser avant de déclarer terminée toute tâche qui crée ou modifie du code.\"\n---\n\nRelis le diff **comme s'il était le code de quelqu'un d'autre** :\ncherche les défauts. Chaque règle : verdict et preuve `fichier.ts:ligne`; doute = signale, jamais\n« conforme ».\n\nAprès sélection, avant chaque lancement/relance, annonce « Grace — Revue » : niveau demandé,\nmodèle exact, effort natif exact transmis, talents et contrôles prévus. Auto : niveau choisi et raison courte.\nEffort non transmis : « raisonnement hérité » et « niveau non appliqué ».\nJamais d’effort déduit de Low/Medium/High. Regroupe les configurations identiques ; précise chaque\npérimètre différent. Inconnu : « indisponible » et limite. Distingue sélection prévue, configuration\nobservée, exécution confirmée ; rectifie tout écart retourné par le harnais.\nPlan ≠ validation ; distingue règles consultées, contrôles effectués, corrections.\nRevue inachevée, contrôle impossible, appel échoué : « Grace — Blocage », problème, conséquence,\nprochaine action connue. Langue utilisateur, texte simple, sans doublon par tentative.\n\n## Parcours local de revue (inline-v1)\n\nCe parcours ne change ni la politique de niveau, ni les permissions ou outils du harnais ; chaque lancement de relecteur transmet explicitement le modèle et l’effort retenus. N’ouvre une session supplémentaire que si la revue le nécessite.\n1. Appelle grace_review({ resolutionId, format: \"inline-v1\" }) pour cette génération de revue, puis, si parts > 1, chaque part 2..parts avec le layoutDigest de la première partie. Ensemble, les parties contiennent protocole grace-review-inline-v1, politique, obligations, règles complètes, consignes Custom et empreintes. Ne rappelle pas grace_review par talent ou par relecteur. review_dossier_too_large : aucun verdict, aucune relance ni repli vers paged-v1 ou le plan historique ; « Grace — Blocage » avec les tailles indiquées. Grace choisit seule la taille admise.\n2. Garde le dossier dans le contexte de l’orchestrateur. N’écris ni le dossier, ni règle, ni consigne Custom dans un fichier, cache, archive, argument de commande ou état local.\n3. Vérifie Python >=3.10 sans l’installer. Le kit fournit scripts/review-client.py à côté de cette skill : exige les octets/SHA-256 du manifeste validé et CLIENT_VERSION=\"1.2\" avant exécution. Script absent/altéré/incompatible ou Python absent : diagnostic explicite, puis procédure exhaustive manuelle du protocole reçu ; jamais succès simulé.\n4. Lance python3 -I -S -B