devflow-cli 6.0.0__py3-none-any.whl → 6.1.1__py3-none-any.whl

devflow_cli/__init__.py

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

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/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__":

devflow_cli/commands/adaptive.py

@@ -6,6 +6,8 @@ import json
 import os
 import shlex
 import tempfile
+import uuid
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Literal, Optional
 
@@ -44,6 +46,7 @@ from devflow_cli.core.automatic_evidence import (
     stale_review_evidence,
 )
 from devflow_cli.core.worklog import refresh_worklog, safe_refresh_worklog
+from devflow_cli.core.telemetry import append_record, telemetry_enabled, usage_payload
 from devflow_cli.core.waivers import create_validation_waiver
 from devflow_cli.core.remediation import (
     carried_changed_files,
@@ -366,10 +369,15 @@ def run_adaptive(
         else:
             fail(str(exc))
         raise typer.Exit(int(ExitCode.INVALID_CONTRACT)) from exc
+    run_id = str(uuid.uuid4())
+    attempt: dict = {}
+
     def execute(activity_contract) -> AgentActivityExecution:
         prompt_text = render_contract_prompt(activity_contract)
+        attempt["contract"] = activity_contract
+        attempt["startedAt"] = _utc_now()
         try:
-            before = snapshot_worktree(project_root)
+            before = snapshot_worktree(project_root, feature_dir)
             with tempfile.TemporaryDirectory(prefix="devflow-adaptive-") as temp_dir:
                 temp_path = Path(temp_dir)
                 schema_file = temp_path / "output-schema.json"
@@ -389,15 +397,18 @@ def run_adaptive(
                     if "write" in activity_contract.allowedActions
                     else "read-only",
                 )
+                attempt["execution"] = execution
                 output = (
                     output_file.read_text(encoding="utf-8")
                     if output_file.is_file()
                     else execution.stdout
                 )
-            after = snapshot_worktree(project_root)
+            after = snapshot_worktree(project_root, feature_dir)
             observed = tuple(changed_paths(before, after))
+            attempt["changedFileCount"] = len(observed)
             audit_payload = {
                 "schemaVersion": 1,
+                "runId": run_id,
                 "agent": agent,
                 "activity": activity_contract.activity,
                 "returnCode": execution.returncode,
@@ -423,6 +434,10 @@ def run_adaptive(
         )
 
     outcome = run_current_activity(feature_dir, feature_path, execute)
+    _record_telemetry(
+        run_id, attempt, agent, project_root, outcome.reason,
+        json_output=json_output,
+    )
     if outcome.advanced:
         if json_output:
             _print_execution_json(
@@ -827,6 +842,52 @@ def _print_execution_json(
     }, ensure_ascii=False))
 
 
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _record_telemetry(
+    run_id: str,
+    attempt: dict,
+    agent: str,
+    project_root: Path,
+    reason: str,
+    *,
+    json_output: bool,
+) -> None:
+    """Consigne la consommation d'une tentative ; ne bloque jamais l'activite."""
+    execution = attempt.get("execution")
+    contract = attempt.get("contract")
+    if execution is None or contract is None or not telemetry_enabled():
+        return
+    record = {
+        "schemaVersion": 1,
+        "runId": run_id,
+        "recordedAt": _utc_now(),
+        "startedAt": attempt.get("startedAt"),
+        "project": str(project_root),
+        "issueId": contract.issueId,
+        "profile": contract.profile,
+        "activity": contract.activity,
+        "contractId": contract.contractId,
+        "agent": agent,
+        "sessionId": execution.session_id,
+        "outcome": reason,
+        "advanced": reason == "advanced",
+        "returnCode": execution.returncode,
+        "timedOut": execution.timed_out,
+        "durationSeconds": round(execution.duration_seconds, 3),
+        "finalOutputDiagnostic": execution.final_output_diagnostic,
+        "worktreeChangedFileCount": attempt.get("changedFileCount"),
+        "usage": usage_payload(execution.usage),
+    }
+    try:
+        append_record(record)
+    except OSError as exc:
+        if not json_output:
+            warn(f"Telemetrie non enregistree : {exc}")
+
+
 def _write_json_atomic(path: Path, payload: dict) -> None:
     temporary: Path | None = None
     try:

devflow_cli/commands/usage.py

@@ -0,0 +1,92 @@
+"""devflow usage — Resume de la consommation enregistree des activites agent."""
+
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+import typer
+from rich.table import Table
+
+from devflow_cli.core.telemetry import (
+    GROUP_KEYS,
+    filter_records,
+    parse_since,
+    read_records,
+    summarize,
+    telemetry_enabled,
+    telemetry_file,
+)
+from devflow_cli.utils.console import console, fail, warn
+
+
+def usage(
+    since: Optional[str] = typer.Option(
+        None, "--since", help="Periode : 7d, 12h ou une date ISO"
+    ),
+    by: str = typer.Option(
+        "activity", "--by", help=f"Regroupement : {', '.join(GROUP_KEYS)}"
+    ),
+    project: Optional[str] = typer.Option(
+        None, "--project", help="Ne garder que les projets dont le chemin contient ce texte"
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Sortie JSON"),
+) -> None:
+    """Resume la consommation des tentatives agent (~/.devflow/telemetry.jsonl)."""
+    try:
+        start = parse_since(since) if since else None
+        rows = summarize(
+            filter_records(read_records(), since=start, project=project), by
+        )
+    except ValueError as exc:
+        fail(str(exc))
+        raise typer.Exit(2) from exc
+
+    if json_output:
+        console.print_json(json.dumps({"source": str(telemetry_file()), "by": by, "rows": rows}))
+        return
+    if not telemetry_enabled():
+        warn("Collecte desactivee (DEVFLOW_TELEMETRY=0) : aucune nouvelle tentative n'est enregistree.")
+    if not rows:
+        console.print(f"Aucune tentative enregistree dans {telemetry_file()}.")
+        return
+
+    table = Table(title=f"Consommation par {by}")
+    for column in (
+        by, "essais", "ok", "entree", "cache lu", "sortie", "USD", "tours", "q.5h", "q.sem",
+    ):
+        table.add_column(column, no_wrap=True, justify="left" if column == by else "right")
+    for row in rows:
+        table.add_row(
+            row[by],
+            str(row["attempts"]),
+            str(row["advanced"]),
+            _tokens(row["inputTokens"]),
+            _tokens(row["cacheReadTokens"]),
+            _tokens(row["outputTokens"]),
+            _optional(row["costUsd"], "{:.2f}"),
+            _optional(row["meanTurns"], "{:g}"),
+            _optional(row["quota5hPoints"], "{:g}"),
+            _optional(row["quotaWeeklyPoints"], "{:g}"),
+        )
+    console.print(table)
+    console.print(
+        "essais = tentatives agent ; ok = tentatives avancees ; q. = points de quota Codex ; "
+        "detail complet (cache ecrit, contexte au 1er tour) avec --json. "
+        "Les tokens de Claude et de Codex ne sont pas comparables entre eux ; "
+        "le cout USD est l'equivalent API declare par Claude, les quotas sont "
+        "releves dans les journaux Codex."
+    )
+
+
+def _tokens(value: int | None) -> str:
+    if value is None:
+        return "-"
+    for suffix, divisor in (("M", 1_000_000), ("k", 1_000)):
+        if value >= divisor:
+            return f"{value / divisor:.1f}{suffix}"
+    return str(value)
+
+
+def _optional(value, pattern: str) -> str:
+    return "-" if value is None else pattern.format(value)

devflow_cli/core/adaptive_runner.py

@@ -296,7 +296,7 @@ def reconcile_current_activity(
                 raise ValueError(
                     "la tentative ne correspond pas au contrat de l'activite courante"
                 )
-            snapshot = snapshot_worktree(project_root_for_feature(feature_dir))
+            snapshot = snapshot_worktree(project_root_for_feature(feature_dir), feature_dir)
             if snapshot.head != attempt.get("head") or snapshot.branch != attempt.get("branch"):
                 raise ValueError("HEAD ou la branche a change depuis la tentative")
             drifted = sorted(
@@ -784,7 +784,7 @@ def _record_failed_attempt(
 ) -> None:
     """Consigne les faits d'une tentative refusee pour une reprise controlee."""
     try:
-        snapshot = snapshot_worktree(project_root_for_feature(feature_dir))
+        snapshot = snapshot_worktree(project_root_for_feature(feature_dir), feature_dir)
     except (OSError, ValueError):
         return
     payload = {

devflow_cli/core/remediation.py

@@ -208,7 +208,7 @@ def _active_attempt_files(feature_dir: Path, activity: str) -> list[str]:
             or not all(isinstance(path, str) for path in carried)
         ):
             raise StaleAttemptError(f"fiche de tentative {activity} invalide")
-        snapshot = snapshot_worktree(project_root_for_feature(feature_dir))
+        snapshot = snapshot_worktree(project_root_for_feature(feature_dir), feature_dir)
         if snapshot.head != payload["head"] or snapshot.branch != payload["branch"]:
             raise StaleAttemptError(
                 f"HEAD ou la branche a change depuis la tentative {activity}"
@@ -243,7 +243,7 @@ def _still_modified(feature_dir: Path, files: list[str]) -> list[str]:
     if not files:
         return []
     try:
-        snapshot = snapshot_worktree(project_root_for_feature(feature_dir))
+        snapshot = snapshot_worktree(project_root_for_feature(feature_dir), feature_dir)
     except (OSError, ValueError):
         return files
     return [path for path in files if path in snapshot.files]

devflow_cli/core/telemetry.py

@@ -0,0 +1,168 @@
+"""Telemetrie locale de consommation des activites agent.
+
+Chaque tentative `adaptive run` confiee a un agent ajoute une ligne JSON a
+`~/.devflow/telemetry.jsonl`. Le fichier est commun a tous les projets, car les
+quotas des agents sont partages par le compte. Il ne contient ni prompt, ni
+reponse, ni contenu de fichier. `DEVFLOW_TELEMETRY=0` desactive la collecte ;
+`DEVFLOW_HOME` deplace le repertoire.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import statistics
+from collections import defaultdict
+from dataclasses import asdict
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Iterable
+
+from devflow_cli.adapters.agents import AgentUsage
+
+TELEMETRY_SCHEMA_VERSION = 1
+TELEMETRY_ENV = "DEVFLOW_TELEMETRY"
+DEVFLOW_HOME_ENV = "DEVFLOW_HOME"
+_DISABLED_VALUES = {"0", "false", "no", "off"}
+GROUP_KEYS = ("activity", "profile", "agent", "model", "project")
+
+
+def telemetry_enabled() -> bool:
+    return os.environ.get(TELEMETRY_ENV, "1").strip().casefold() not in _DISABLED_VALUES
+
+
+def telemetry_file() -> Path:
+    home = os.environ.get(DEVFLOW_HOME_ENV)
+    return (Path(home) if home else Path.home() / ".devflow") / "telemetry.jsonl"
+
+
+def usage_payload(usage: AgentUsage | None) -> dict[str, Any] | None:
+    if usage is None:
+        return None
+    payload = asdict(usage)
+    payload["models"] = list(usage.models)
+    payload["quota"] = [asdict(window) for window in usage.quota]
+    return payload
+
+
+def append_record(record: dict[str, Any], path: Path | None = None) -> Path:
+    """Ajoute une ligne en une seule ecriture O_APPEND ; leve OSError en cas d'echec."""
+    target = path or telemetry_file()
+    target.parent.mkdir(parents=True, exist_ok=True)
+    line = (json.dumps(record, ensure_ascii=False, sort_keys=True) + "\n").encode("utf-8")
+    descriptor = os.open(target, os.O_WRONLY | os.O_APPEND | os.O_CREAT, 0o600)
+    try:
+        os.write(descriptor, line)
+    finally:
+        os.close(descriptor)
+    return target
+
+
+def read_records(path: Path | None = None) -> list[dict[str, Any]]:
+    """Lit les tentatives enregistrees en ignorant les lignes illisibles."""
+    target = path or telemetry_file()
+    if not target.is_file():
+        return []
+    records: list[dict[str, Any]] = []
+    for line in target.read_text(encoding="utf-8", errors="replace").splitlines():
+        try:
+            record = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(record, dict) and record.get("schemaVersion") == TELEMETRY_SCHEMA_VERSION:
+            records.append(record)
+    return records
+
+
+def parse_since(value: str, now: datetime | None = None) -> datetime:
+    """Accepte une duree (`7d`, `12h`) ou une date ISO."""
+    reference = now or datetime.now(timezone.utc)
+    text = value.strip()
+    if len(text) > 1 and text[-1] in {"d", "h"} and text[:-1].isdigit():
+        amount = int(text[:-1])
+        return reference - (timedelta(days=amount) if text[-1] == "d" else timedelta(hours=amount))
+    try:
+        parsed = datetime.fromisoformat(text.replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise ValueError(f"--since invalide : {value} (attendu 7d, 12h ou une date ISO)") from exc
+    return parsed if parsed.tzinfo else parsed.replace(tzinfo=timezone.utc)
+
+
+def filter_records(
+    records: Iterable[dict[str, Any]],
+    *,
+    since: datetime | None = None,
+    project: str | None = None,
+) -> list[dict[str, Any]]:
+    selected = []
+    for record in records:
+        if project and project not in str(record.get("project", "")):
+            continue
+        if since is not None:
+            try:
+                recorded = datetime.fromisoformat(str(record.get("recordedAt", "")).replace("Z", "+00:00"))
+            except ValueError:
+                continue
+            if recorded < since:
+                continue
+        selected.append(record)
+    return selected
+
+
+def _group_value(record: dict[str, Any], key: str) -> str:
+    if key == "model":
+        usage = record.get("usage") or {}
+        models = ",".join(usage.get("models") or []) or "?"
+        effort = usage.get("effort")
+        return f"{models}/{effort}" if effort else models
+    if key == "project":
+        return Path(str(record.get("project") or "?")).name
+    return str(record.get(key) or "?")
+
+
+def _quota_delta(record: dict[str, Any], minutes: int) -> float | None:
+    usage = record.get("usage") or {}
+    for window in usage.get("quota") or []:
+        if window.get("windowMinutes") == minutes and window.get("deltaPoints") is not None:
+            return float(window["deltaPoints"])
+    return None
+
+
+def summarize(records: list[dict[str, Any]], by: str) -> list[dict[str, Any]]:
+    """Agrege les tentatives par cle, sans melanger les unites des agents."""
+    if by not in GROUP_KEYS:
+        raise ValueError(f"--by invalide : {by} (valeurs : {', '.join(GROUP_KEYS)})")
+    groups: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for record in records:
+        groups[_group_value(record, by)].append(record)
+    rows = []
+    for name, items in groups.items():
+        usages = [record.get("usage") or {} for record in items]
+        measured = [usage for usage in usages if usage]
+        costs = [usage["costUsd"] for usage in measured if usage.get("costUsd") is not None]
+        turns = [usage["turns"] for usage in measured if usage.get("turns") is not None]
+        contexts = [
+            usage["firstContextTokens"]
+            for usage in measured
+            if usage.get("firstContextTokens") is not None
+        ]
+        five_hours = [d for d in (_quota_delta(r, 300) for r in items) if d is not None]
+        weekly = [d for d in (_quota_delta(r, 10080) for r in items) if d is not None]
+        rows.append({
+            by: name,
+            "attempts": len(items),
+            "advanced": sum(1 for record in items if record.get("advanced")),
+            "contracts": len({record.get("contractId") for record in items}),
+            "measured": len(measured),
+            "durationSeconds": round(sum(float(r.get("durationSeconds") or 0) for r in items), 1),
+            "inputTokens": sum(int(u.get("inputTokens") or 0) for u in measured),
+            "cacheReadTokens": sum(int(u.get("cacheReadTokens") or 0) for u in measured),
+            "cacheWriteTokens": sum(int(u.get("cacheWriteTokens") or 0) for u in measured),
+            "outputTokens": sum(int(u.get("outputTokens") or 0) for u in measured),
+            "costUsd": round(sum(costs), 4) if costs else None,
+            "meanTurns": round(statistics.mean(turns), 1) if turns else None,
+            "medianFirstContextTokens": int(statistics.median(contexts)) if contexts else None,
+            "quota5hPoints": sum(five_hours) if five_hours else None,
+            "quotaWeeklyPoints": sum(weekly) if weekly else None,
+        })
+    return sorted(rows, key=lambda row: (-row["attempts"], row[by]))

devflow_cli/core/worktree_snapshot.py

@@ -17,8 +17,19 @@ class WorktreeSnapshot:
     files: dict[str, str]
 
 
-def snapshot_worktree(project_root: Path) -> WorktreeSnapshot:
-    """Capture HEAD, branche et contenu des fichiers modifies/non suivis."""
+# Traces brutes d'agent ecrites par devflow ; ignorees par le .gitignore de la feature.
+TRACE_SUFFIX = ".raw.txt"
+
+
+def snapshot_worktree(
+    project_root: Path, feature_dir: Path | None = None
+) -> WorktreeSnapshot:
+    """Capture HEAD, branche et contenu des fichiers modifies/non suivis.
+
+    Avec ``feature_dir``, les fichiers ignores par git dans ce seul dossier
+    sont aussi captures, hors traces brutes : un projet qui ignore ``.specify``
+    doit tout de meme voir les artefacts de sa feature.
+    """
     head = _git_text(project_root, ["rev-parse", "--verify", "HEAD"], allow_failure=True)
     branch = _git_text(project_root, ["branch", "--show-current"], allow_failure=True)
     tracked = _git_paths(
@@ -30,7 +41,15 @@ def snapshot_worktree(project_root: Path) -> WorktreeSnapshot:
         project_root,
         ["ls-files", "--others", "--exclude-standard", "-z"],
     )
-    paths = sorted(set(tracked) | set(untracked))
+    paths = set(tracked) | set(untracked)
+    subtree = _subtree(project_root, feature_dir)
+    if subtree is not None:
+        ignored = _git_paths(
+            project_root,
+            ["ls-files", "--others", "--ignored", "--exclude-standard", "-z", "--", subtree],
+        )
+        paths |= {path for path in ignored if not path.endswith(TRACE_SUFFIX)}
+    paths = sorted(paths)
     return WorktreeSnapshot(
         head=head,
         branch=branch,
@@ -64,6 +83,15 @@ def changed_paths(before: WorktreeSnapshot, after: WorktreeSnapshot) -> list[str
     return sorted(path for path in paths if before.files.get(path) != after.files.get(path))
 
 
+def _subtree(project_root: Path, feature_dir: Path | None) -> str | None:
+    if feature_dir is None:
+        return None
+    try:
+        return feature_dir.resolve().relative_to(project_root.resolve()).as_posix()
+    except ValueError:
+        return None
+
+
 def _git_text(project_root: Path, args: list[str], *, allow_failure: bool = False) -> str:
     result = subprocess.run(
         ["git", *args],

{devflow_cli-6.0.0.dist-info → devflow_cli-6.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: devflow-cli
-Version: 6.0.0
+Version: 6.1.1
 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.dist-info → devflow_cli-6.1.1.dist-info}/RECORD

@@ -1,10 +1,10 @@
-devflow_cli/__init__.py,sha256=PJFBeX5myYT2_LgT3pqJ-g0tbYk0MwB9P2QxYrlNScs,1002
-devflow_cli/cli.py,sha256=llRYI7JxM7UJLw5I3eqyYx8zMRN7Wxwj7QcHdGe9HkQ,2063
+devflow_cli/__init__.py,sha256=VmCwbQc6bNPKKQvcsirS32ZlbjHbOt8DbCAfd3EcBfA,1002
+devflow_cli/cli.py,sha256=nst8kP2QneJZJg6K5bBf9uO8Nj9lYmoHrEhcxA7nsIM,2129
 devflow_cli/adapters/__init__.py,sha256=RkjHPU2Lp4hSVIq2iOmyTrv2zYU9NuiIF9wEMWzLdMI,377
-devflow_cli/adapters/agents.py,sha256=ccOxRl6F_PgB_4o-VMSbmP16m8IDlI7HQcadhh6C1Jc,18139
+devflow_cli/adapters/agents.py,sha256=8_y70AIhmtuR8kyPN3Wpj0-i76k9wd_uaycVKTqC96g,26503
 devflow_cli/adapters/linear.py,sha256=MyqI2tHx7NNHY1KRfeYZ_Zjc-6_xhZPWD4oS-j7wnNY,2659
 devflow_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devflow_cli/commands/adaptive.py,sha256=0c2CFotDapCrk_T0Z6_o0lSiXJBZc2bfZvxC_kqwhtY,43751
+devflow_cli/commands/adaptive.py,sha256=_CICxGw27XOSnXteudn75IriY12zz5jhcZoH__zNfns,45797
 devflow_cli/commands/assess.py,sha256=GrWGGZjvBAgHWzSlUdtS-IfYocacA6VYxWduDvBunzg,4395
 devflow_cli/commands/check.py,sha256=M_sbcH1L3FEa4DF9gm46LEADlJndRKlaEDoysIBHv8k,6668
 devflow_cli/commands/context.py,sha256=hwTitOHxIpJMx1X8R1jHHy9CpE4HVZpJKkyeOujxAio,6246
@@ -19,10 +19,11 @@ devflow_cli/commands/stale.py,sha256=UiaUb48lrXmPyjfvbFkChfLE-rs58KhgKu-zgL_NBIo
 devflow_cli/commands/status.py,sha256=b7r8lFcUOuph57BPSQzSVGr4039sIzrsSV1gW77KM54,7244
 devflow_cli/commands/traceability.py,sha256=DhUOBzSmKVk17j1Qz0yxD5zD2-iNWaR9F133VNPjy70,1767
 devflow_cli/commands/upgrade_cmd.py,sha256=d5uBFUPzPsCJDLxhQBFaeHWJv3GWWLmPpkYHRVd1gwM,5664
+devflow_cli/commands/usage.py,sha256=ehH1AH5J-XfkebFx6qLBwpKN-MOoX2uUbq4LejBpNsk,3148
 devflow_cli/commands/verify.py,sha256=sKmoHfA-PRWoDbgLC0nW2nvd89Zdktlkep0sxF7q3jQ,3968
 devflow_cli/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devflow_cli/core/activity_contracts.py,sha256=U9AknLNFIusjuh4MonY_8i3__uDeo_NF2z3zfGJynA8,42631
-devflow_cli/core/adaptive_runner.py,sha256=_JmnglYkqN3HhV7UZdfSkCiR_O141rHIoEl1XEuIOFw,33687
+devflow_cli/core/adaptive_runner.py,sha256=o9HHPNZJyA9u_zui9pNZrzMkH_jzszbI-GMweoRjqB8,33713
 devflow_cli/core/adaptive_workflow.py,sha256=qsjkahK9yklf6LjyQn69PVl9v0AoX2YPQiG2_umpb_U,13065
 devflow_cli/core/agent_failure.py,sha256=iX4q249lAHeVdD_ZF1aObmU-FX6sjfYP9dfLSnWGAD0,3771
 devflow_cli/core/assessment.py,sha256=l5QRntLJyBx3MdN-kepmMAsruHdJsG4TDgSdgOSHkqU,10062
@@ -37,16 +38,17 @@ devflow_cli/core/manifest.py,sha256=964iYthqhzf3qQgxN4hZ33BvS2r7BKDZoKdiOWRybag,
 devflow_cli/core/omissions.py,sha256=-9dqaQLRIy-1t6it7gecKn_0KpqbEjPIT0ec86KvXCk,7449
 devflow_cli/core/operational.py,sha256=ZEWh6DKJfHYLpV9r3vZwaDFREQwlJF0wTtgB1VleXog,1204
 devflow_cli/core/redaction.py,sha256=o_1MDtCyvRLrk_dWlV6_7E6_mPVB1B5a0cCfTBj9j0Q,1973
-devflow_cli/core/remediation.py,sha256=D7spH-xO1KezSY3YVuAl4ZdFCKhXKGSYVWgnLHC4Dp4,13549
+devflow_cli/core/remediation.py,sha256=FknpUBR9WGZkmeDf6F2HINKKm3rG4AB5C7NTgrPhPVc,13575
 devflow_cli/core/scanner.py,sha256=bcoC91Nc0Hw2P7aHpL-9ITxynLZhLTEKpOXo553a-18,4395
 devflow_cli/core/staleness.py,sha256=Bn4jN8r601Ifn0AU8BHZy-Z-5NLPjj_JTK-V0KU9TUM,5256
+devflow_cli/core/telemetry.py,sha256=emcYo6Qikc86TYKT5Mc_9-3Thkt3nztkPZrpTy9VlvA,6952
 devflow_cli/core/traceability.py,sha256=jfNE9MZzGkmaPer9Wa6Y18yA9Y3sqdeR-nzH9h_TB-8,2968
 devflow_cli/core/validation_approvals.py,sha256=BMjwDbkkY9K-uqk19duKWIbh7-Dk5ceprNPgQHx3lrg,8421
 devflow_cli/core/validators.py,sha256=c2T6NAe80sPh2uS8gCQfyiCkLT3eBPLizCbDsE0PgNo,9934
 devflow_cli/core/verification.py,sha256=a2-pAnMQqBhGnV87LwhMc03zFRjDECB7sWYGxQu21lo,16879
 devflow_cli/core/waivers.py,sha256=w3bza1OicSxAViYU2hvbrylQTNVgmN7Rd9y2L6Wm2OE,11302
 devflow_cli/core/worklog.py,sha256=w_R_K-xI7gx9lYQhcjJbI_nBQqztMHsOPWj1tQCXjjA,12668
-devflow_cli/core/worktree_snapshot.py,sha256=8YDAQwJ1lBbChck2IQUM2iEAAMv27tHedtfELS10nnU,3701
+devflow_cli/core/worktree_snapshot.py,sha256=5ycGW5sYSeoht-ofUqoNhrscZuhTJlynfObzisJal90,4669
 devflow_cli/schemas/activity-contract-v3.schema.json,sha256=_R6oKY2K3LxNCIATQunDM7e41J6w4Dg15TrN3B-NL0c,1977
 devflow_cli/schemas/activity-result-v1.schema.json,sha256=UybTDGJcPZ_CJoD0oAlgBWJOEsQTp06KRnogoa1pFFY,3140
 devflow_cli/schemas/assessment-v3.schema.json,sha256=aCybk-TaE5aJDKA2dhadSq58a-t2hFy6A-hCDlIl2Yo,1798
@@ -83,8 +85,8 @@ devflow_cli/resources/templates/contracts/api-template.md,sha256=rC5v7JBz71PznCn
 devflow_cli/resources/templates/contracts/components-template.md,sha256=XIWfEXfC72sNmL5OA3V-7xIywkNDU2DBPLfyiagOWcs,484
 devflow_cli/resources/templates/contracts/interfaces-template.md,sha256=kf8B7b6HsmN7jyRlLNU7RnZl0rTMlI5s97yVRyI-6yc,336
 devflow_cli/resources/templates/contracts/services-template.md,sha256=cFafKCyLmq_a7aR7G0LXAaMO2z4Fuflq6iKdxfVg0vg,477
-devflow_cli-6.0.0.dist-info/METADATA,sha256=yXyFrd52FZgip0slqbh31DWipOfDBVyrcAacMLRSK5s,4061
-devflow_cli-6.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-devflow_cli-6.0.0.dist-info/entry_points.txt,sha256=GVJ6bMvFpqyO5589iC4nFKeGTpGIW8aKn_QPPpSZ6kU,48
-devflow_cli-6.0.0.dist-info/licenses/LICENSE,sha256=v79PvnmqOdKhQiOa_QcWxng4q8GuGscLOwi7ygUpwpo,1070
-devflow_cli-6.0.0.dist-info/RECORD,,
+devflow_cli-6.1.1.dist-info/METADATA,sha256=KHMl28FYPV7eUHT9Hn6GH4VwneeUhK_H8Zb9NaD5Kqs,4061
+devflow_cli-6.1.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+devflow_cli-6.1.1.dist-info/entry_points.txt,sha256=GVJ6bMvFpqyO5589iC4nFKeGTpGIW8aKn_QPPpSZ6kU,48
+devflow_cli-6.1.1.dist-info/licenses/LICENSE,sha256=v79PvnmqOdKhQiOa_QcWxng4q8GuGscLOwi7ygUpwpo,1070
+devflow_cli-6.1.1.dist-info/RECORD,,