devflow-cli 6.0.0__tar.gz → 6.1.0__tar.gz

{devflow_cli-6.0.0 → devflow_cli-6.1.0}/CHANGELOG.md

@@ -5,6 +5,20 @@ Tous les changements notables de ce projet sont documentés dans ce fichier.
 Le format est basé sur [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/),
 et ce projet adhère au [Semantic Versioning](https://semver.org/lang/fr/).
 
+## [6.1.0] - 2026-09-24
+
+Mesure de consommation des agents : voir [notes de version](docs/releases/6.1.0.md).
+
+### Added
+
+- Télémétrie locale de consommation : chaque tentative `adaptive run` ajoute
+  une ligne à `~/.devflow/telemetry.jsonl` (tokens, tours, modèle, coût
+  équivalent API Claude, deltas de quota Codex), sans prompt ni contenu.
+  Désactivable avec `DEVFLOW_TELEMETRY=0`.
+- `devflow usage` résume ces tentatives par activité, profil, agent, modèle ou
+  projet, avec `--since`, `--project` et `--json`.
+- `agent-execution.json` porte le `runId` de la tentative correspondante.
+
 ## [6.0.0] - 2026-09-24
 
 Retours d'usage k-review traités : voir [v6-decisions.md](docs/v6-decisions.md).

devflow_cli-6.1.0/FEEDBACK.md

@@ -0,0 +1,176 @@
+# Retours d'usage devflow
+
+Observés en conditions réelles. Chaque entrée : ce qui s'est passé, pourquoi ça coûte, une piste.
+Les décisions t'appartiennent. Classement par gravité.
+
+Retours précédents traités en 5.0.0 : voir `docs/v5-decisions.md`. Ceux de la série suivante en
+6.0.0 : voir `docs/v6-decisions.md`.
+
+**Contexte des retours ci-dessous.** Projet k-review, trois parcours conduits les 23 et 24 septembre
+2026 : KKS-368 `deep`, KKS-369 `deep`, KKS-370 `standard`. Point de vue : celui du superviseur
+(Claude), qui enchaîne les activités, rédige lui-même les artefacts, délègue l'implémentation à des
+agents et répare les rejets.
+
+**Réserve à lire avant tout.** Ces parcours ont été conduits avec la **CLI v5.0.0** : la 6.0.0 a été
+publiée alors que le dernier se terminait. Chaque entrée ci-dessous a donc été **revérifiée contre le
+code de la 6.0.0** avant d'être écrite, et celles que la 6.0.0 corrige déjà ne figurent pas dans les
+sections de gravité — elles sont rassemblées en fin de document, à titre de confirmation.
+
+---
+
+## 1. Majeur
+
+### M1 — Le profil `standard` n'a aucune activité de revue
+
+**Ce qui s'est passé.** KKS-370 a été évalué `standard` : `assess → prepare → preflight-evidence →
+implement → verify → done`. Il n'y a **pas d'activité `review`**, et la preuve `implementation-review`
+n'est pas requise — contrairement au profil `deep`, où les deux existent.
+
+Or ce lot modifiait `app.html`, le gabarit du **shell partagé par les quatre écrans** de
+l'application, en changeant l'ordre du DOM. Une régression y aurait été visible partout à la fois. Le
+projet impose par ailleurs deux revues d'agent avant chaque commit ; elles ont été jouées, mais
+**hors du parcours**, sans point d'ancrage ni trace dans l'état du workflow.
+
+**Pourquoi ça coûte.** La rigueur de revue est indexée sur le profil, donc sur l'ampleur estimée du
+changement, et non sur le **risque de ce qui est touché**. Un lot `standard` qui modifie un composant
+partagé est moins contrôlé qu'un lot `deep` qui ajoute un fichier isolé. Le commit a lieu dans les
+deux cas, et rien dans les artefacts ne dit qu'une revue a eu lieu : `done` se complète sans elle.
+
+**Piste.** Permettre au `risk-assessment` de **recommander l'ajout** d'une activité `review` à un
+profil qui ne la porte pas, symétriquement à l'omission introduite en 6.0.0 pour `critical`
+(`adaptive omit`). Ou rendre `implementation-review` exigible dès qu'un fichier du périmètre est
+partagé par plusieurs modules. À défaut, un `adaptive review` accepté en `standard` pour consigner
+une revue qui a eu lieu, même sans activité dédiée.
+
+### M2 — Le plafond de dix commandes n'est pas dans la politique injectée
+
+**Ce qui s'est passé.** `activity_contracts.py:788` refuse tout `validationPlan` de plus de dix
+commandes : `validationPlan doit contenir entre 1 et 10 commandes`. La politique exposée aux agents
+par `validation_policy_guidance()` (`verification.py:70`) énumère les exécutables autorisés, les
+tâches Maven et Gradle, les opérateurs interdits, l'approbation des exécutables hors liste et la
+consigne sur `git ls-files` — **mais pas ce plafond**.
+
+Sur KKS-368, le plan comptait onze validations, toutes légitimes et distinctes. Le refus est arrivé à
+`verify`, après rédaction du plan **et** du document qui le décrit.
+
+**Pourquoi ça coûte.** Ce n'est pas seulement une commande à retirer : il faut en **fusionner** deux
+qui portaient des garanties différentes, puis amender le document de plan pour qu'aucun écart ne
+subsiste entre ce qui est écrit et ce qui s'exécute. Le retour de M1 de la série précédente — « la
+politique n'est connue qu'après coup » — a été traité, mais cette contrainte-là y a échappé, alors
+qu'elle est la plus facile à énoncer.
+
+**Piste.** Ajouter une ligne à `validation_policy_guidance()` : « le validationPlan contient entre 1
+et 10 commandes ; regrouper plutôt qu'énumérer ». Une seule phrase ferme le sujet.
+
+---
+
+## 2. Mineur
+
+### m1 — `adaptive review` complète l'activité, et son nom ne le dit pas
+
+**Ce qui s'est passé.** Sur KKS-369, `adaptive review` rend : « Revue humaine de … validée pour
+'review'. **Prochaine : done** ». L'enchaînement naturel, `adaptive complete KKS-369 review`, échoue
+alors avec « activité courante attendue : done ».
+
+**Pourquoi ça coûte.** Un aller-retour et un doute : on ne sait pas si la revue a été prise en compte
+ou si l'on a sauté une étape. Le verbe `review` suggère d'enregistrer une revue, pas de terminer
+l'activité.
+
+**Piste.** Le message de succès pourrait dire que l'activité est complétée, pas seulement quelle est
+la suivante : « Revue enregistrée, activité 'review' complétée. Prochaine : done ».
+
+### m2 — Le format `evidence` des résultats est accepté sans être compris
+
+**Ce qui s'est passé.** Les `*-result.json` acceptent un tableau `evidence`. Un objet de la forme
+`{id, kind, summary, path}` passe la validation du résultat **sans erreur**, mais ne compte comme
+aucune preuve : `complete review` a refusé avec « preuves manquantes : implementation-review » alors
+qu'une entrée portant `"id": "implementation-review"` figurait dans le fichier. Le format reconnu est
+`{id, outcome, report}`, et l'`id` doit être le **nom du type de preuve attendu**.
+
+**Pourquoi ça coûte.** Le message de refus décrit l'état des preuves, pas ce qui a été lu dans le
+fichier. On corrige le format à l'aveugle, on relance, on échoue encore — jusqu'à aller lire un
+`workflow-state.json` d'un lot précédent pour en déduire la forme attendue.
+
+**Piste.** Signaler les entrées `evidence` non reconnues au moment de la complétion, avec la forme
+attendue : « entrée ignorée : clés {kind, summary, path} ; attendu {id, outcome, report} ».
+
+### m3 — Le porteur du `validationPlan` change avec le profil, sans être annoncé
+
+**Ce qui s'est passé.** En `standard`, le `validationPlan` va dans `prepare-result.json`. En `deep`,
+il n'y a pas d'activité `prepare` : c'est `plan-result.json` qui doit le porter. Son absence ne se
+manifeste qu'à `verify`, par `invalid-preparation-result` — un code dont le nom désigne une activité
+qui n'existe pas dans ce profil.
+
+**Pourquoi ça coûte.** Le message n'indique pas quel fichier remplir, et son intitulé oriente vers la
+mauvaise piste. Sur KKS-368, la cause n'a été trouvée qu'en comparant avec le dossier d'un lot
+antérieur conduit sous un autre profil.
+
+**Piste.** Nommer le fichier attendu dans le refus : « validationPlan absent de plan-result.json
+(profil deep : pas d'activité prepare) ». Le contrat d'activité pourrait aussi le rappeler, puisqu'il
+demande déjà « un validationPlan exécutable et portable est fourni » sans dire où.
+
+---
+
+## 3. Hors outil, mais rencontré en le pilotant
+
+### h1 — Rien n'oblige une conclusion d'absence à se prouver
+
+**Ce qui s'est passé.** KKS-370 était un lot d'audit : son premier temps produisait un constat, le
+second corrigeait. Le constat a conclu deux fois à une **absence** — « aucune gestion de mise à jour
+du service worker n'existe », « aucun renvoi au principe de couleur dans le code ». Les deux étaient
+faux. Un service complet existait depuis quatre lots ; il y avait trois renvois. Les deux erreurs
+venaient de recherches dont la sortie avait été tronquée.
+
+Ces faux constats sont entrés dans `audit.md`, puis dans le périmètre, puis dans les instructions
+données à un agent d'implémentation — qui a refusé d'écrire le code et a corrigé le superviseur. Un
+arbitrage a été demandé à l'utilisateur pour un travail sans objet.
+
+**Pourquoi ça coûte.** L'activité `preflight-evidence` demande des « faits observés » et vérifie que
+les sections existent, mais ne distingue pas un fait **positif** — mesuré, reproductible — d'une
+**absence constatée**, qui n'est un fait que si la recherche était exhaustive. Une absence mal établie
+se propage plus loin qu'une mesure fausse, parce qu'elle justifie de **construire** quelque chose.
+
+**Piste.** Dans le contrat de `preflight-evidence`, demander que toute affirmation d'absence cite la
+commande qui l'établit, et que cette commande figure dans la section de reproductibilité. C'est une
+consigne, pas un contrôle — mais elle aurait suffi ici : écrire la commande aurait exposé le `head`
+qui la tronquait.
+
+---
+
+## 4. Ce que la 6.0.0 corrige, vérifié
+
+Ces points figuraient dans mes retours précédents ou ont été rencontrés en v5.0.0 pendant ces
+parcours. Ils sont **résolus**, et je les note pour fermer la boucle plutôt que pour demander quoi que
+ce soit.
+
+- **m4, preuves `manual` refusées.** `adaptive evidence --help` annonce désormais « Enregistre une
+  preuve manuelle informative, **sans ouvrir les gates** ». En v5.0.0, la commande acceptait
+  l'enregistrement puis la complétion échouait avec « preuves automatiques valides requises », sans
+  jamais nommer `adaptive review`. L'aide actuelle aurait évité l'aller-retour.
+- **M6, messages sans cible.** Le refus `regression-check-failed (PREP-conflit-plus-non-tranche)`
+  nomme l'identifiant exact de la validation fautive, en première ligne. J'ai trouvé la cause
+  immédiatement — c'était une validation que j'avais moi-même mal conçue.
+- **M1, politique connue après coup.** Les sections requises sont nommées dans le refus : « sections
+  de pré-vol manquantes : faits observés, reproductibilité, limites ». Trois mots suffisent à
+  corriger.
+- **Le refus de réduire un profil recommandé** reste strict, et c'est bien. Déclarer
+  `--contract-change` sur une route ajoutée fait recommander `deep` ; `--profile standard` est
+  refusé. Le contourner en retirant le drapeau marcherait, et mentirait sur la nature du changement.
+  Le garde-fou tient exactement là où il doit tenir.
+- **`devflow traceability`** joué avant de compléter `tasks` rend la couverture des exigences par les
+  tâches en une seconde. Deux écarts rattrapés sur KKS-369 à ce moment-là plutôt qu'à la revue.
+
+---
+
+## Priorités suggérées
+
+1. **M2** — une phrase dans `validation_policy_guidance()`. Coût nul, évite un rejet tardif et une
+   réécriture de document.
+2. **m3** — nommer le fichier attendu dans le refus `invalid-preparation-result`. Coût nul, supprime
+   la recherche à l'aveugle.
+3. **M1** — la revue absente du profil `standard` est le seul point qui touche la qualité du résultat
+   plutôt que le confort du pilote. C'est aussi le plus lourd à trancher : il engage la définition des
+   profils.
+4. **m2** et **m1** — messages, à traiter quand l'occasion se présente.
+5. **h1** — une consigne de contrat, si l'idée te paraît juste. Elle sort du périmètre habituel de
+   l'outil, et je la propose sans insister.

{devflow_cli-6.0.0 → devflow_cli-6.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: devflow-cli
-Version: 6.0.0
+Version: 6.1.0
 Summary: Spec-Driven Development workflow CLI
 Project-URL: Homepage, https://github.com/sopequenoteck/devflow
 Project-URL: Repository, https://github.com/sopequenoteck/devflow

{devflow_cli-6.0.0 → devflow_cli-6.1.0}/docs/activity-contracts.md

@@ -291,6 +291,19 @@ distingue une réponse finale absente, un fichier vide, un tour échoué, un JSO
 invalide et un payload refusé par le schéma; aucun de ces cas ne fait progresser
 le workflow.
 
+Chaque tentative agent est aussi consignée, avec le même `runId`, dans
+`~/.devflow/telemetry.jsonl` : contrat, profil, activité, résultat Devflow,
+durée et compteurs de consommation. Claude fournit ses tokens, son nombre de
+tours, ses modèles et son coût équivalent API dans l'enveloppe JSON. Le flux
+Codex ne donne que les tokens ; le modèle, l'effort, le nombre de requêtes, le
+contexte au premier tour et l'évolution des quotas sont lus au mieux dans le
+journal de session `~/.codex/sessions` (ou `$CODEX_HOME/sessions`), dont le
+format est interne à Codex. Le delta de quota est mesuré entre le premier et le
+dernier relevé de la session et vaut `null` si la fenêtre a été réinitialisée.
+Une mesure illisible laisse `usage` à `null`; une écriture impossible affiche un
+avertissement; aucune ne bloque l'activité. Aucun prompt, aucune réponse et aucun
+contenu de fichier n'y figure.
+
 Les activités documentaires Deep écrivent exclusivement `spec.md`, `plan.md`
 ou `tasks.md`, puis réutilisent les validateurs historiques et le contrôle de
 traçabilité exigences-tâches. Leurs résultats sont conservés dans

{devflow_cli-6.0.0 → devflow_cli-6.1.0}/docs/cli-reference.md

@@ -155,6 +155,7 @@ devflow verify ISSUE_ID [--json] [--allow-command OUTIL]
 devflow stale ISSUE_ID
 devflow context ISSUE_ID
 devflow linear decision ACTIVITY CURRENT_STATUS
+devflow usage [--since 7d|DATE] [--by activity|profile|agent|model|project] [--project TEXTE] [--json]
 ```
 
 Avec un workflow adaptatif, `devflow verify` utilise les mêmes preuves et
@@ -163,6 +164,14 @@ réservée aux plans sans workflow adaptatif ; utiliser `approve-command` pour
 une feature adaptative. Les tableaux Markdown historiques acceptent une
 colonne « Répertoire » relative au dépôt.
 
+Chaque tentative `adaptive run` confiée à un agent ajoute une ligne à
+`~/.devflow/telemetry.jsonl`, commun à tous les projets puisque les quotas sont
+partagés par le compte. `devflow usage` en résume les tentatives, les
+activités avancées, les tokens, le coût équivalent API déclaré par Claude, le
+nombre de tours et les points de quota Codex ; `--json` ajoute le cache écrit et
+le contexte médian au premier tour. `DEVFLOW_TELEMETRY=0` désactive la collecte
+et `DEVFLOW_HOME` déplace le répertoire.
+
 ## Formats antérieurs
 
 Devflow 5 refuse tout workflow créé par une version antérieure et ne fournit

devflow_cli-6.1.0/docs/releases/6.1.0.md

@@ -0,0 +1,54 @@
+# Devflow 6.1.0 — Mesurer la consommation des agents
+
+Cette version ne change aucune transition du workflow. Elle enregistre ce que
+coûte chaque tentative confiée à un agent, afin de décider plus tard du modèle,
+de l'effort ou du profil à partir de données réelles plutôt que de journaux
+externes difficiles à corréler.
+
+## Télémétrie locale
+
+- Chaque tentative `adaptive run` confiée à un agent, avancée ou refusée, ajoute
+  une ligne à `~/.devflow/telemetry.jsonl`. Le fichier est commun à tous les
+  projets, car les quotas des agents sont partagés par le compte.
+- Une ligne porte le contrat, le profil, l'activité, le projet, le résultat
+  Devflow, la durée et les compteurs de consommation. Aucun prompt, aucune
+  réponse et aucun contenu de fichier n'y figure.
+- **Claude** : tokens d'entrée, de cache et de sortie, nombre de tours, modèles,
+  sous-agents et coût équivalent API, lus dans l'enveloppe JSON.
+- **Codex** : tokens lus dans le flux `--json` ; modèle, effort, nombre de
+  requêtes, contexte au premier tour et évolution des fenêtres de quota lus au
+  mieux dans le journal de session `~/.codex/sessions` (ou
+  `$CODEX_HOME/sessions`).
+- `agent-execution.json` porte le `runId` de la ligne correspondante.
+- La collecte est active par défaut ; `DEVFLOW_TELEMETRY=0` la désactive et
+  `DEVFLOW_HOME` déplace le répertoire.
+- Une mesure illisible laisse `usage` à `null` ; une écriture impossible affiche
+  un avertissement. Aucune des deux ne bloque l'activité.
+
+## Lecture
+
+`devflow usage [--since 7d|DATE] [--by activity|profile|agent|model|project]
+[--project TEXTE] [--json]` résume les tentatives, les activités avancées, les
+tokens, le coût équivalent API Claude, le nombre moyen de tours et les points
+de quota Codex. `--json` ajoute le cache écrit et le contexte médian au premier
+tour.
+
+## Limites connues
+
+- Les tokens Claude et Codex ne sont pas comparables entre eux, ni entre
+  modèles de prix différents.
+- Claude ne fournit ni l'effort, ni le contexte au premier tour, ni l'état de
+  ses quotas.
+- Le journal de session Codex a un format interne à Codex : un changement de
+  format vide les champs qui en proviennent sans erreur. Le delta de quota est
+  mesuré entre le premier et le dernier relevé de la session ; la première
+  requête n'y est donc pas comptée, et il vaut `null` si la fenêtre a été
+  réinitialisée.
+- Cursor n'est pas mesuré.
+- La réconciliation (`adaptive reconcile`) n'appelle pas d'agent et n'est pas
+  enregistrée.
+
+## Validation de la version
+
+- Suite complète : 677 tests pytest et 14 tests shell.
+- `devflow docs-sync --check` confirme la référence générée des profils.

{devflow_cli-6.0.0 → devflow_cli-6.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "devflow-cli"
-version = "6.0.0"
+version = "6.1.0"
 description = "Spec-Driven Development workflow CLI"
 requires-python = ">=3.11"
 license = {text = "MIT"}

{devflow_cli-6.0.0 → devflow_cli-6.1.0}/src/devflow_cli/__init__.py

@@ -1,6 +1,6 @@
 """devflow CLI — workflow de développement adaptatif."""
 
-VERSION = "6.0.0"
+VERSION = "6.1.0"
 
 SUPPORTED_AGENTS = ["claude-code", "codex", "cursor"]
 

{devflow_cli-6.0.0 → devflow_cli-6.1.0}/src/devflow_cli/adapters/agents.py

@@ -3,11 +3,13 @@
 from __future__ import annotations
 
 import json
+import os
 import subprocess
 import re
 import time
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
+from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Literal
 
@@ -25,6 +27,38 @@ _SAFE_DIAGNOSTIC_MESSAGES = {
 }
 
 
+@dataclass(frozen=True)
+class QuotaWindow:
+    """Evolution d'une fenetre de quota observee pendant une session agent."""
+
+    windowMinutes: int | None
+    usedPercentStart: float
+    usedPercentEnd: float
+    # None si la fenetre a ete reinitialisee entre les deux releves.
+    deltaPoints: float | None
+
+
+@dataclass(frozen=True)
+class AgentUsage:
+    """Compteurs de consommation declares par l'agent, sans aucun contenu.
+
+    inputTokens exclut toujours les tokens lus depuis le cache.
+    """
+
+    inputTokens: int = 0
+    cacheReadTokens: int = 0
+    cacheWriteTokens: int = 0
+    outputTokens: int = 0
+    reasoningTokens: int = 0
+    models: tuple[str, ...] = ()
+    effort: str | None = None
+    turns: int | None = None
+    costUsd: float | None = None
+    subagents: int | None = None
+    firstContextTokens: int | None = None
+    quota: tuple[QuotaWindow, ...] = ()
+
+
 @dataclass(frozen=True)
 class AgentExecution:
     returncode: int
@@ -36,6 +70,7 @@ class AgentExecution:
     final_output_bytes: int = 0
     final_output_diagnostic: str = "not-evaluated"
     session_id: str | None = None
+    usage: AgentUsage | None = None
 
 
 class StructuredOutputError(ValueError):
@@ -138,6 +173,9 @@ class AgentAdapter(ABC):
                 final_output_diagnostic="process-failed" if result.returncode else "validating",
                 session_id=self.session_id(result.stdout or "", result.stderr or ""),
             )
+            execution = replace(
+                execution, usage=self.safe_usage(execution.stdout, execution.session_id)
+            )
             if execution.returncode != 0:
                 return execution
             try:
@@ -169,6 +207,7 @@ class AgentAdapter(ABC):
                     _output_size(output_file),
                     "validated",
                     execution.session_id,
+                    execution.usage,
                 )
 
             status = _output_status(output_file)
@@ -189,16 +228,21 @@ class AgentAdapter(ABC):
                 final_output_bytes=size,
                 final_output_diagnostic=diagnostic,
                 session_id=execution.session_id,
+                usage=execution.usage,
             )
         except subprocess.TimeoutExpired as exc:
+            stdout, stderr = _text(exc.stdout), _text(exc.stderr)
+            session_id = self.session_id(stdout, stderr)
             return AgentExecution(
                 124,
-                _text(exc.stdout),
-                _text(exc.stderr),
+                stdout,
+                stderr,
                 timed_out=True,
                 duration_seconds=time.monotonic() - started,
                 final_output_status=_output_status(output_file),
                 final_output_bytes=_output_size(output_file),
+                session_id=session_id,
+                usage=self.safe_usage(stdout, session_id),
             )
         except FileNotFoundError:
             return AgentExecution(127, stderr=f"Executable '{self.executable}' introuvable", duration_seconds=time.monotonic() - started)
@@ -207,6 +251,17 @@ class AgentAdapter(ABC):
         """Extrait un identifiant opaque de session, sans conserver la sortie."""
         return _session_id(stdout, stderr)
 
+    def usage(self, stdout: str, session_id: str | None) -> AgentUsage | None:
+        """Extrait les compteurs de consommation ; None si l'agent n'en fournit pas."""
+        return None
+
+    def safe_usage(self, stdout: str, session_id: str | None) -> AgentUsage | None:
+        """La mesure de consommation ne doit jamais faire echouer une activite."""
+        try:
+            return self.usage(stdout, session_id)
+        except Exception:  # noqa: BLE001 - format externe non contractuel
+            return None
+
     def recover_structured_payload(self, raw_output: str) -> object:
         """Extrait la reponse structuree d'une trace brute conservee apres un echec."""
         return self._structured_payload(raw_output, None)
@@ -270,6 +325,33 @@ class ClaudeCodeAdapter(AgentAdapter):
             return json.loads(_strip_json_fence(result))
         raise ValueError("champ structured_output absent")
 
+    def usage(self, stdout: str, session_id: str | None) -> AgentUsage | None:
+        """Lit l'enveloppe --output-format json : usage cumule de tous les tours."""
+        envelope = json.loads(stdout)
+        if not isinstance(envelope, dict) or not isinstance(envelope.get("usage"), dict):
+            return None
+        usage = envelope["usage"]
+        details = usage.get("output_tokens_details")
+        subagents = envelope.get("subagent_stats")
+        model_usage = envelope.get("modelUsage")
+        cost = envelope.get("total_cost_usd")
+        turns = envelope.get("num_turns")
+        return AgentUsage(
+            inputTokens=_int(usage.get("input_tokens")),
+            cacheReadTokens=_int(usage.get("cache_read_input_tokens")),
+            cacheWriteTokens=_int(usage.get("cache_creation_input_tokens")),
+            outputTokens=_int(usage.get("output_tokens")),
+            reasoningTokens=_int(details.get("thinking_tokens")) if isinstance(details, dict) else 0,
+            models=tuple(model_usage) if isinstance(model_usage, dict) else (),
+            turns=turns if isinstance(turns, int) else None,
+            costUsd=float(cost) if isinstance(cost, (int, float)) else None,
+            subagents=(
+                subagents.get("spawned")
+                if isinstance(subagents, dict) and isinstance(subagents.get("spawned"), int)
+                else None
+            ),
+        )
+
 
 class CodexAdapter(AgentAdapter):
     name = "codex"
@@ -338,6 +420,32 @@ class CodexAdapter(AgentAdapter):
             return json.loads(_strip_json_fence(final_message))
         raise StructuredOutputError(diagnostic, message)
 
+    def usage(self, stdout: str, session_id: str | None) -> AgentUsage | None:
+        """Combine le flux --json et, au mieux, le journal de session Codex.
+
+        Le flux ne donne que les tokens ; le modele, l'effort, le nombre de
+        requetes et les quotas ne figurent que dans le journal de session, dont
+        le format est interne a Codex.
+        """
+        totals = [
+            event["usage"]
+            for event in json_line_events(stdout)
+            if event.get("type") == "turn.completed" and isinstance(event.get("usage"), dict)
+        ]
+        session = _codex_session_facts(session_id)
+        if not totals and session is None:
+            return None
+        raw_input = sum(_int(item.get("input_tokens")) for item in totals)
+        cached = sum(_int(item.get("cached_input_tokens")) for item in totals)
+        usage = AgentUsage(
+            inputTokens=max(raw_input - cached, 0),
+            cacheReadTokens=cached,
+            cacheWriteTokens=sum(_int(item.get("cache_write_input_tokens")) for item in totals),
+            outputTokens=sum(_int(item.get("output_tokens")) for item in totals),
+            reasoningTokens=sum(_int(item.get("reasoning_output_tokens")) for item in totals),
+        )
+        return replace(usage, **session) if session else usage
+
 
 class CursorAdapter(AgentAdapter):
     name = "cursor"
@@ -492,3 +600,92 @@ def _validate_structured_payload(payload: object, schema_file: Path) -> None:
     validator_type = validator_for(schema)
     validator_type.check_schema(schema)
     validator_type(schema).validate(payload)
+
+
+def _int(value: object) -> int:
+    return value if isinstance(value, int) and not isinstance(value, bool) else 0
+
+
+def _codex_home() -> Path:
+    return Path(os.environ.get("CODEX_HOME") or Path.home() / ".codex")
+
+
+def _codex_session_file(session_id: str | None) -> Path | None:
+    """Retrouve le journal d'une session Codex recente a partir de son identifiant."""
+    if not session_id or not re.fullmatch(r"[A-Za-z0-9-]{8,}", session_id):
+        return None
+    sessions = _codex_home() / "sessions"
+    today = datetime.now()
+    for offset in range(3):
+        day = today - timedelta(days=offset)
+        directory = sessions / f"{day:%Y}" / f"{day:%m}" / f"{day:%d}"
+        matches = sorted(directory.glob(f"rollout-*{session_id}.jsonl"))
+        if matches:
+            return matches[-1]
+    return None
+
+
+def _codex_session_facts(session_id: str | None) -> dict | None:
+    """Extrait modele, effort, requetes et quotas du journal de session Codex."""
+    path = _codex_session_file(session_id)
+    if path is None:
+        return None
+    models: list[str] = []
+    effort: str | None = None
+    totals: set[int] = set()
+    first_context: int | None = None
+    limits: list[dict] = []
+    with path.open(encoding="utf-8", errors="replace") as handle:
+        for event in json_line_events(handle.read()):
+            payload = event.get("payload")
+            if not isinstance(payload, dict):
+                continue
+            if event.get("type") == "turn_context":
+                model = payload.get("model")
+                if isinstance(model, str) and model not in models:
+                    models.append(model)
+                if isinstance(payload.get("effort"), str):
+                    effort = payload["effort"]
+            elif event.get("type") == "event_msg" and payload.get("type") == "token_count":
+                info = payload.get("info")
+                if isinstance(info, dict) and isinstance(info.get("total_token_usage"), dict):
+                    marker = _int(info["total_token_usage"].get("total_tokens"))
+                    if marker not in totals:
+                        totals.add(marker)
+                        last = info.get("last_token_usage")
+                        if first_context is None and isinstance(last, dict):
+                            first_context = _int(last.get("input_tokens")) or None
+                if isinstance(payload.get("rate_limits"), dict):
+                    limits.append(payload["rate_limits"])
+    return {
+        "models": tuple(models),
+        "effort": effort,
+        "turns": len(totals) or None,
+        "firstContextTokens": first_context,
+        "quota": _quota_windows(limits),
+    }
+
+
+def _quota_windows(limits: list[dict]) -> tuple[QuotaWindow, ...]:
+    """Compare le premier et le dernier releve de chaque fenetre de quota."""
+    windows: list[QuotaWindow] = []
+    if not limits:
+        return ()
+    for key in ("primary", "secondary"):
+        first, last = limits[0].get(key), limits[-1].get(key)
+        if not isinstance(first, dict) or not isinstance(last, dict):
+            continue
+        start, end = first.get("used_percent"), last.get("used_percent")
+        if not isinstance(start, (int, float)) or not isinstance(end, (int, float)):
+            continue
+        minutes = last.get("window_minutes")
+        same_window = first.get("resets_at") == last.get("resets_at")
+        windows.append(
+            QuotaWindow(
+                windowMinutes=minutes if isinstance(minutes, int) else None,
+                usedPercentStart=float(start),
+                usedPercentEnd=float(end),
+                deltaPoints=float(end) - float(start) if same_window else None,
+            )
+        )
+    return tuple(windows)

{devflow_cli-6.0.0 → devflow_cli-6.1.0}/src/devflow_cli/cli.py

@@ -22,6 +22,7 @@ from devflow_cli.commands.docs_sync import docs_sync
 from devflow_cli.commands.traceability import traceability
 from devflow_cli.commands.verify import verify
 from devflow_cli.commands.assess import assess
+from devflow_cli.commands.usage import usage
 
 app = typer.Typer(
     name="devflow",
@@ -61,6 +62,7 @@ app.command(name="docs-sync")(docs_sync)
 app.command()(traceability)
 app.command()(verify)
 app.command()(assess)
+app.command()(usage)
 
 
 if __name__ == "__main__":