devflow-cli 10.1.1__py3-none-any.whl → 10.2.0__py3-none-any.whl

devflow_cli/__init__.py

@@ -1,6 +1,6 @@
 """devflow CLI — workflow de développement adaptatif."""
 
-VERSION = "10.1.1"
+VERSION = "10.2.0"
 
 ACTIVITY_LINEAR_MAPPING = {
     "assess": "Backlog",

devflow_cli/cli.py

@@ -16,6 +16,7 @@ from devflow_cli.commands.feature import feature
 from devflow_cli.commands.upgrade_cmd import upgrade
 from devflow_cli.commands import adaptive
 from devflow_cli.commands import feedback
+from devflow_cli.commands.report import report
 from devflow_cli.commands.docs_sync import docs_sync
 from devflow_cli.commands.assess import assess
 
@@ -32,7 +33,7 @@ class DevflowGroup(TyperGroup):
 
 app = typer.Typer(
     name="devflow",
-    help="Spec-Driven Development workflow CLI",
+    help="Workflow adaptatif pour Claude Code : profils, preuves et contrats d'activité",
     no_args_is_help=True,
     cls=DevflowGroup,
 )
@@ -49,7 +50,7 @@ def main(
     version: bool = typer.Option(False, "--version", callback=version_callback, is_eager=True, help="Affiche la version"),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Active les logs dans stderr"),
 ) -> None:
-    """devflow — Spec-Driven Development workflow CLI."""
+    """devflow — Workflow adaptatif pour Claude Code : profils, preuves et contrats d'activité."""
     setup_logging(verbose=verbose)
 
 
@@ -60,6 +61,7 @@ app.command()(feature)
 app.command()(upgrade)
 app.add_typer(adaptive.app, name="adaptive")
 app.add_typer(feedback.app, name="feedback")
+app.command()(report)
 app.command(name="docs-sync")(docs_sync)
 app.command()(assess)
 

devflow_cli/commands/adaptive.py

@@ -58,6 +58,7 @@ from devflow_cli.core.worklog import (
     safe_refresh_worklog,
 )
 from devflow_cli.core.telemetry import append_record, telemetry_enabled, usage_payload
+from devflow_cli.core.decisions import bind_state, decision, note_refusal, note_run_id
 from devflow_cli.core.remediation import (
     discard_attempt,
     reopen_activity,
@@ -239,9 +240,10 @@ def complete(
 ) -> None:
     """Complete l'activite courante si ses gates sont satisfaites."""
     feature_dir = _feature(feature)
-    with workflow_lock(feature_dir):
+    with decision("complete", feature_dir), workflow_lock(feature_dir):
         refuse_if_agent_running(feature_dir)
         state = _state(feature_dir)
+        bind_state(state)
         activity = activity or state.currentActivity
         try:
             if activity != state.currentActivity:
@@ -299,12 +301,25 @@ def run_adaptive(
     if until is not None:
         _run_until(feature_dir, timeout, permission_mode, until)
         return
+    with decision("run", feature_dir, json_output=json_output):
+        _run_activity(feature, feature_dir, timeout, permission_mode, json_output)
+
+
+def _run_activity(
+    feature: str,
+    feature_dir: Path,
+    timeout: int,
+    permission_mode: Literal["auto", "acceptEdits", "manual"],
+    json_output: bool,
+) -> None:
+    """Une activite de `adaptive run`, par agent ou par verification locale."""
     project_root = project_root_for_feature(feature_dir)
     feature_path = feature_dir.relative_to(project_root).as_posix()
     with workflow_lock(feature_dir):
         current_state = _state(
             feature_dir, json_output=json_output, issue_id=feature
         )
+    bind_state(current_state)
     if current_state.currentActivity == "verify":
         _execute_local_verification(
             feature_dir, project_root, current_state.issueId, json_output=json_output
@@ -315,6 +330,7 @@ def run_adaptive(
         "tasks", "preflight-evidence", "implement", "review", "rollback-check",
     }:
         detail = f"L'activite '{current_state.currentActivity}' ne necessite pas d'agent."
+        note_refusal("unsupported-activity")
         if json_output:
             _print_execution_json(
                 current_state.issueId, current_state.currentActivity, False,
@@ -407,6 +423,8 @@ def run_adaptive(
         )
 
     outcome = run_current_activity(feature_dir, feature_path, execute, agent=agent)
+    if attempt.get("execution") is not None:
+        note_run_id(run_id)
     _record_telemetry(
         run_id, attempt, agent, project_root, outcome.reason,
         json_output=json_output,
@@ -429,6 +447,7 @@ def run_adaptive(
         return
     if outcome.reason != "agent-running":  # worklog.md : fichier d'execution (B4)
         safe_refresh_worklog(feature_dir)
+    note_refusal(outcome.reason)
     exit_code = exit_code_for_run_reason(outcome.reason)
     execution = attempt.get("execution")
     recovery = (
@@ -568,6 +587,21 @@ def reconcile_adaptive(
         fail("--reason ne peut pas etre vide")
         raise typer.Exit(int(ExitCode.USAGE))
 
+    with decision("reconcile", feature_dir, state):
+        _reconcile_activity(
+            feature_dir, feature_path, state, result, reason, corrected_payload
+        )
+
+
+def _reconcile_activity(
+    feature_dir: Path,
+    feature_path: str,
+    state: AdaptiveWorkflowState,
+    result: Path | None,
+    reason: str | None,
+    corrected_payload: object | None,
+) -> None:
+    """Reconciliation de l'activite courante, une fois les options validees."""
     missing_output: dict[str, str] = {}
 
     def recover(agent: str, raw_output: str) -> object:
@@ -597,6 +631,7 @@ def reconcile_adaptive(
         _print_pending_approvals(feature_dir, state.issueId, outcome.activity)
         remove_result_template(state.issueId, outcome.activity)
         return
+    note_refusal(outcome.reason)
     if outcome.reason != "agent-running":  # worklog.md : fichier d'execution (B4)
         safe_refresh_worklog(feature_dir)
     if (
@@ -665,28 +700,30 @@ def verify_adaptive(
     """Genere localement les preuves requises par le profil actif."""
     feature_dir = _feature(feature, json_output=json_output)
     state = _state(feature_dir, json_output=json_output, issue_id=feature)
-    with workflow_lock(feature_dir):
-        refuse_if_agent_running(
-            feature_dir, json_issue_id=state.issueId if json_output else None
-        )
-    if not refresh and state.currentActivity != "verify":
-        detail = (
-            "Activite courante attendue pour verify : verify "
-            f"(actuelle : {state.currentActivity})."
-        )
-        if json_output:
-            _print_execution_json(
-                state.issueId, state.currentActivity, False, "wrong-activity",
-                detail, state.currentActivity, ExitCode.INVALID_CONTRACT,
+    with decision("verify", feature_dir, state, json_output=json_output):
+        with workflow_lock(feature_dir):
+            refuse_if_agent_running(
+                feature_dir, json_issue_id=state.issueId if json_output else None
             )
-        else:
-            fail(detail)
-            console.print(f"  Suite : {_next_command(state, feature_dir)}")
-        raise typer.Exit(int(ExitCode.INVALID_CONTRACT))
-    _execute_local_verification(
-        feature_dir, project_root_for_feature(feature_dir), state.issueId,
-        refresh=refresh, json_output=json_output,
-    )
+        if not refresh and state.currentActivity != "verify":
+            detail = (
+                "Activite courante attendue pour verify : verify "
+                f"(actuelle : {state.currentActivity})."
+            )
+            note_refusal("wrong-activity")
+            if json_output:
+                _print_execution_json(
+                    state.issueId, state.currentActivity, False, "wrong-activity",
+                    detail, state.currentActivity, ExitCode.INVALID_CONTRACT,
+                )
+            else:
+                fail(detail)
+                console.print(f"  Suite : {_next_command(state, feature_dir)}")
+            raise typer.Exit(int(ExitCode.INVALID_CONTRACT))
+        _execute_local_verification(
+            feature_dir, project_root_for_feature(feature_dir), state.issueId,
+            refresh=refresh, json_output=json_output,
+        )
 
 
 @app.command("approve-command")
@@ -741,9 +778,10 @@ def reopen(
 ) -> None:
     """Revient a une activite anterieure sans effacer l'historique."""
     feature_dir = _feature(feature)
-    with workflow_lock(feature_dir):
+    with decision("reopen", feature_dir), workflow_lock(feature_dir):
         refuse_if_agent_running(feature_dir)
         state = _state(feature_dir)
+        bind_state(state)
         try:
             entry = reopen_activity(
                 feature_dir, state, activity, reason, author=author
@@ -771,9 +809,10 @@ def discard_attempt_command(
 ) -> None:
     """Abandonne la tentative de l'activite courante, avec archive et audit."""
     feature_dir = _feature(feature)
-    with workflow_lock(feature_dir):
+    with decision("discard-attempt", feature_dir), workflow_lock(feature_dir):
         refuse_if_agent_running(feature_dir)
         state = _state(feature_dir)
+        bind_state(state)
         try:
             entry = discard_attempt(feature_dir, state, reason, author=author)
         except (OSError, ValueError) as exc:
@@ -857,6 +896,8 @@ def _execute_local_verification(
     if not refresh:
         sync_activity_status(issue_id, "verify", stream)
     outcome = run_automatic_verification(feature_dir, project_root, refresh=refresh)
+    if not outcome.passed:
+        note_refusal(outcome.reason)
     recovery = (
         None if outcome.passed
         else _verify_recovery(feature_dir, issue_id, outcome, refresh=refresh)
@@ -1028,6 +1069,7 @@ def refuse_if_agent_running(feature_dir: Path, *, json_issue_id: str | None = No
     try:
         warning = ensure_no_agent_running(feature_dir)
     except AgentRunningError as exc:
+        note_refusal("agent-running")
         if json_issue_id is not None:
             _print_execution_json(
                 json_issue_id, None, False, "agent-running", str(exc), None,
@@ -1067,6 +1109,8 @@ def _print_execution_json(
     detail: str, next_activity: str | None, exit_code: ExitCode,
     *, warnings: tuple[str, ...] = (), recovery: dict | None = None,
 ) -> None:
+    if not passed:
+        note_refusal(reason)
     payload = {
         "schemaVersion": 1,
         "issueId": issue_id,

devflow_cli/commands/report.py

@@ -0,0 +1,324 @@
+"""devflow report — Restitue coûts, refus et reprises des parcours.
+
+Lecture seule de `telemetry.jsonl`, `feedback.jsonl` et `decisions.jsonl` ; les
+dossiers de feature ne sont jamais lus.
+"""
+
+from __future__ import annotations
+
+import json
+import statistics
+from datetime import datetime
+from typing import Any, Optional
+
+import typer
+from rich.markup import escape
+
+from devflow_cli.core.decisions import read_decisions
+from devflow_cli.core.feedback import MIN_PREFIX, read_feedback, resolutions, strip_controls
+from devflow_cli.core.telemetry import read_records
+from devflow_cli.utils.console import console, fail, make_table
+
+NO_ACTIVITY = "sans activité"
+
+
+def _plain(text: object) -> str:
+    """Texte issu des fichiers : sans controle ni balisage rich."""
+    return escape(strip_controls(str(text)))
+
+
+def _amount(value: float) -> float:
+    return round(value, 2)
+
+
+def _median(values: list[float]) -> float | None:
+    return _amount(statistics.median(values)) if values else None
+
+
+def _keep(
+    record: dict[str, Any], since: str | None, project: str | None, issue: str | None
+) -> bool:
+    if since is not None and str(record.get("recordedAt") or "")[:10] < since:
+        return False
+    if project and project not in str(record.get("project") or ""):
+        return False
+    if issue is not None and record.get("issueId") != issue:
+        return False
+    return True
+
+
+def _path(record: dict[str, Any]) -> tuple[str, str]:
+    return str(record.get("project") or ""), str(record.get("issueId") or "")
+
+
+def _cost(record: dict[str, Any]) -> float | None:
+    cost = (record.get("usage") or {}).get("costUsd")
+    return float(cost) if isinstance(cost, (int, float)) else None
+
+
+def _sum_costs(records: list[dict[str, Any]]) -> float:
+    return sum(cost for cost in map(_cost, records) if cost is not None)
+
+
+def _by_path(records: list[dict[str, Any]]) -> dict[tuple[str, str], list[dict[str, Any]]]:
+    paths: dict[tuple[str, str], list[dict[str, Any]]] = {}
+    for record in sorted(records, key=lambda item: str(item.get("recordedAt") or "")):
+        paths.setdefault(_path(record), []).append(record)
+    return paths
+
+
+def profiles_section(telemetry: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Par profil : parcours, cout median et maximal, minutes agent medianes."""
+    grouped: dict[str, list[list[dict[str, Any]]]] = {}
+    for records in _by_path(telemetry).values():
+        profile = str(records[-1].get("profile") or "?")
+        grouped.setdefault(profile, []).append(records)
+    rows = []
+    for profile in sorted(grouped):
+        paths = grouped[profile]
+        costs = [
+            _sum_costs(records) for records in paths
+            if any(_cost(record) is not None for record in records)
+        ]
+        minutes = [
+            sum(float(record.get("durationSeconds") or 0) for record in records) / 60
+            for records in paths
+        ]
+        rows.append({
+            "profile": profile,
+            "paths": len(paths),
+            "medianCostUsd": _median(costs),
+            "maxCostUsd": _amount(max(costs)) if costs else None,
+            "medianAgentMinutes": _median(minutes),
+        })
+    return rows
+
+
+def activities_section(telemetry: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Par activite : tentatives, refus, taux de refus, cout des tentatives refusees."""
+    grouped: dict[str, list[dict[str, Any]]] = {}
+    for record in telemetry:
+        grouped.setdefault(str(record.get("activity") or "?"), []).append(record)
+    rows = []
+    for activity in sorted(grouped):
+        records = grouped[activity]
+        refused = [record for record in records if record.get("advanced") is not True]
+        rows.append({
+            "activity": activity,
+            "attempts": len(records),
+            "refused": len(refused),
+            "refusalRatePercent": _amount(100 * len(refused) / len(records)),
+            "refusedCostUsd": _amount(_sum_costs(refused)),
+        })
+    return rows
+
+
+def retries_section(telemetry: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Parcours ayant rejoue une activite : tentatives supplementaires et leur cout."""
+    rows = []
+    for (project, issue), records in sorted(_by_path(telemetry).items()):
+        by_activity: dict[str, list[dict[str, Any]]] = {}
+        for record in records:
+            by_activity.setdefault(str(record.get("activity") or "?"), []).append(record)
+        replayed = {name: items for name, items in by_activity.items() if len(items) >= 2}
+        if not replayed:
+            continue
+        extra = [record for items in replayed.values() for record in items[1:]]
+        rows.append({
+            "project": project,
+            "issueId": issue,
+            "activities": sorted(replayed),
+            "extraAttempts": len(extra),
+            "extraCostUsd": _amount(_sum_costs(extra)),
+        })
+    return rows
+
+
+def decisions_section(
+    decisions: list[dict[str, Any]], telemetry: list[dict[str, Any]]
+) -> dict[str, Any]:
+    """Refus par code (avec ou sans agent), decisions par parcours, delai median."""
+    run_ids = {record.get("runId") for record in telemetry if record.get("runId")}
+    by_reason: dict[str, dict[str, int]] = {}
+    for record in decisions:
+        if record.get("outcome") != "refused":
+            continue
+        counts = by_reason.setdefault(
+            str(record.get("reason") or "?"), {"refused": 0, "withAgent": 0}
+        )
+        counts["refused"] += 1
+        if record.get("runId") in run_ids:
+            counts["withAgent"] += 1
+    reasons = [
+        {
+            "reason": reason,
+            "refused": counts["refused"],
+            "withAgent": counts["withAgent"],
+            "withoutAgent": counts["refused"] - counts["withAgent"],
+        }
+        for reason, counts in sorted(by_reason.items(), key=lambda item: (-item[1]["refused"], item[0]))
+    ]
+    paths = []
+    gaps: list[float] = []
+    for (project, issue), records in sorted(_by_path(decisions).items()):
+        paths.append({
+            "project": project,
+            "issueId": issue,
+            "decisions": len(records),
+            "refused": sum(1 for record in records if record.get("outcome") == "refused"),
+        })
+        moments = [_parse_time(record.get("recordedAt")) for record in records]
+        known = [moment for moment in moments if moment is not None]
+        gaps.extend(
+            (later - earlier).total_seconds() / 60
+            for earlier, later in zip(known, known[1:])
+        )
+    return {
+        "byReason": reasons,
+        "byPath": paths,
+        "medianGapMinutes": _median(gaps),
+    }
+
+
+def frictions_section(feedback: list[dict[str, Any]], since, project, issue) -> list[dict[str, Any]]:
+    """Frictions ouvertes, groupees par activite ; « sans activite » a defaut."""
+    treated = resolutions(feedback)
+    groups: dict[str, list[dict[str, Any]]] = {}
+    for entry in feedback:
+        if entry.get("kind") != "entry" or entry.get("type") != "friction":
+            continue
+        if entry["id"] in treated or not _keep(entry, since, project, issue):
+            continue
+        activity = entry.get("activity")
+        key = activity if isinstance(activity, str) and activity else NO_ACTIVITY
+        groups.setdefault(key, []).append({
+            "id": entry["id"][:MIN_PREFIX],
+            "issueId": entry.get("issueId"),
+            "severity": entry.get("severity"),
+            "what": strip_controls(str(entry.get("what") or "")),
+        })
+    ordered = sorted(groups, key=lambda key: (key == NO_ACTIVITY, key))
+    return [
+        {"activity": key, "count": len(groups[key]), "entries": groups[key]}
+        for key in ordered
+    ]
+
+
+def _parse_time(value: object) -> datetime | None:
+    try:
+        return datetime.strptime(str(value), "%Y-%m-%dT%H:%M:%SZ")
+    except ValueError:
+        return None
+
+
+def build_report(
+    since: str | None = None, project: str | None = None, issue: str | None = None
+) -> dict[str, Any]:
+    telemetry = [r for r in read_records() if _keep(r, since, project, issue)]
+    decisions = [r for r in read_decisions() if _keep(r, since, project, issue)]
+    return {
+        "profiles": profiles_section(telemetry),
+        "activities": activities_section(telemetry),
+        "retries": retries_section(telemetry),
+        "decisions": decisions_section(decisions, telemetry),
+        "frictions": frictions_section(read_feedback(), since, project, issue),
+    }
+
+
+def _money(value: float | None) -> str:
+    return "-" if value is None else f"{value:.2f} $"
+
+
+def _number(value: float | None) -> str:
+    return "-" if value is None else f"{value:.2f}"
+
+
+def _print_table(title: str, columns: tuple[str, ...], rows: list[list[str]]) -> None:
+    if not rows:
+        console.print(f"{title} : aucune donnée.", highlight=False)
+        return
+    table = make_table(*columns, title=title)
+    for row in rows:
+        table.add_row(*(_plain(cell) for cell in row))
+    console.print(table)
+
+
+def _print_report(report: dict[str, Any]) -> None:
+    _print_table(
+        "Profils", ("Profil", "Parcours", "Coût médian", "Coût max", "Minutes agent"),
+        [
+            [row["profile"], str(row["paths"]), _money(row["medianCostUsd"]),
+             _money(row["maxCostUsd"]), _number(row["medianAgentMinutes"])]
+            for row in report["profiles"]
+        ],
+    )
+    _print_table(
+        "Activités", ("Activité", "Tentatives", "Refus", "Taux", "Coût refusé"),
+        [
+            [row["activity"], str(row["attempts"]), str(row["refused"]),
+             f"{row['refusalRatePercent']:.2f} %", _money(row["refusedCostUsd"])]
+            for row in report["activities"]
+        ],
+    )
+    _print_table(
+        "Reprises", ("Projet", "Issue", "Activités", "Tentatives +", "Coût +"),
+        [
+            [row["project"], row["issueId"], ", ".join(row["activities"]),
+             str(row["extraAttempts"]), _money(row["extraCostUsd"])]
+            for row in report["retries"]
+        ],
+    )
+    decisions = report["decisions"]
+    _print_table(
+        "Décisions : refus par code", ("Code", "Refus", "Avec agent", "Sans agent"),
+        [
+            [row["reason"], str(row["refused"]), str(row["withAgent"]),
+             str(row["withoutAgent"])]
+            for row in decisions["byReason"]
+        ],
+    )
+    _print_table(
+        "Décisions par parcours", ("Projet", "Issue", "Décisions", "Refus"),
+        [
+            [row["project"], row["issueId"], str(row["decisions"]), str(row["refused"])]
+            for row in decisions["byPath"]
+        ],
+    )
+    console.print(
+        "Délai médian entre deux décisions (min) : "
+        f"{_number(decisions['medianGapMinutes'])}",
+        highlight=False,
+    )
+    _print_table(
+        "Frictions ouvertes", ("Activité", "Id", "Issue", "Gravité", "Constat"),
+        [
+            [group["activity"], entry["id"], entry["issueId"] or "-",
+             entry["severity"] or "-", entry["what"]]
+            for group in report["frictions"]
+            for entry in group["entries"]
+        ],
+    )
+
+
+def report(
+    since: Optional[str] = typer.Option(
+        None, "--since", help="Date UTC incluse (AAAA-MM-JJ), sur recordedAt"
+    ),
+    project: Optional[str] = typer.Option(
+        None, "--project", help="Ne garder que les projets dont le chemin contient ce texte"
+    ),
+    issue: Optional[str] = typer.Option(None, "--issue", help="Issue du parcours"),
+    json_output: bool = typer.Option(False, "--json", help="Sortie JSON"),
+) -> None:
+    """Restitue coûts, refus et reprises des parcours (télémétrie, retours, décisions)."""
+    if since is not None:
+        try:
+            since = datetime.strptime(since, "%Y-%m-%d").date().isoformat()
+        except ValueError as exc:
+            fail(f"--since invalide : {_plain(since)} (format attendu AAAA-MM-JJ)")
+            raise typer.Exit(2) from exc
+    data = build_report(since, project, issue)
+    if json_output:
+        typer.echo(json.dumps(data, ensure_ascii=False))
+        return
+    _print_report(data)

devflow_cli/core/decisions.py

@@ -0,0 +1,192 @@
+"""Journal des decisions des commandes adaptatives (`decisions.jsonl`).
+
+Chaque terminaison de `adaptive run`, `reconcile`, `reopen`, `verify`, `complete`
+et `discard-attempt`, qu'elle avance ou refuse, ajoute une ligne a
+`decisions.jsonl`, a cote de `telemetry.jsonl` (meme `DEVFLOW_HOME`, meme
+interrupteur `DEVFLOW_TELEMETRY=0`). Une ligne ne porte aucun texte libre : le code
+de refus, l'activite et le `runId` de la tentative agent, qui la relie a la
+telemetrie. Une erreur d'ecriture produit un avertissement et ne change jamais le
+code de sortie de la commande.
+"""
+
+from __future__ import annotations
+
+import json
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterator
+
+import typer
+
+from devflow_cli import VERSION
+from devflow_cli.core.adaptive_workflow import read_adaptive_state
+from devflow_cli.core.operational import ExitCode
+from devflow_cli.core.telemetry import append_record, telemetry_enabled, telemetry_file
+from devflow_cli.utils.console import warn
+from devflow_cli.utils.paths import project_root_for_feature
+
+DECISIONS_SCHEMA_VERSION = 1
+DECISION_COMMANDS = (
+    "run", "reconcile", "reopen", "verify", "complete", "discard-attempt",
+)
+DECISION_OUTCOMES = ("advanced", "refused")
+DECISION_FIELDS = (
+    "schemaVersion", "recordedAt", "cliVersion", "project", "issueId", "command",
+    "activity", "outcome", "reason", "runId",
+)
+
+
+def decisions_file() -> Path:
+    return telemetry_file().parent / "decisions.jsonl"
+
+
+def build_decision(
+    *,
+    project: str,
+    issue_id: str,
+    command: str,
+    activity: str | None,
+    outcome: str,
+    reason: str | None,
+    run_id: str | None,
+) -> dict[str, Any]:
+    """Ligne du journal ; `reason` est nul pour une decision qui avance."""
+    return {
+        "schemaVersion": DECISIONS_SCHEMA_VERSION,
+        "recordedAt": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "cliVersion": VERSION,
+        "project": project,
+        "issueId": issue_id,
+        "command": command,
+        "activity": activity,
+        "outcome": outcome,
+        "reason": reason if outcome == "refused" else None,
+        "runId": run_id,
+    }
+
+
+def read_decisions(path: Path | None = None) -> list[dict[str, Any]]:
+    """Lit les decisions en ignorant les lignes illisibles ou d'un autre schema."""
+    target = path or decisions_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 ValueError:
+            continue
+        if (
+            isinstance(record, dict)
+            and record.get("schemaVersion") == DECISIONS_SCHEMA_VERSION
+            and all(field in record for field in DECISION_FIELDS)
+        ):
+            records.append(record)
+    return records
+
+
+@dataclass
+class _Scope:
+    command: str
+    feature_dir: Path
+    json_output: bool
+    issue_id: str | None = None
+    activity: str | None = None
+    reason: str | None = None
+    run_id: str | None = None
+
+
+_CURRENT: ContextVar[_Scope | None] = ContextVar("devflow_decision_scope", default=None)
+
+
+def note_refusal(reason: str) -> None:
+    """Retient le code du refus en cours ; sans effet hors d'une decision."""
+    scope = _CURRENT.get()
+    if scope is not None and reason:
+        scope.reason = reason
+
+
+def note_run_id(run_id: str) -> None:
+    """Retient l'identifiant de la tentative agent, celui de la ligne de telemetrie."""
+    scope = _CURRENT.get()
+    if scope is not None:
+        scope.run_id = run_id
+
+
+def _fallback_reason(exit_code: int) -> str:
+    """Refus sans code emis : nom du code de sortie, en kebab-case (`blocked`)."""
+    try:
+        return ExitCode(exit_code).name.lower().replace("_", "-")
+    except ValueError:
+        return f"exit-{exit_code}"
+
+
+@contextmanager
+def decision(
+    command: str, feature_dir: Path, state=None, *, json_output: bool = False
+) -> Iterator[None]:
+    """Consigne la terminaison de la commande, qu'elle avance ou refuse.
+
+    A armer apres les controles d'usage : tout ce qui sort du bloc est une decision.
+    Un `typer.Exit` de code 0 ou un retour normal avance ; un autre code refuse, avec
+    le code retenu par `note_refusal`, a defaut celui derive du code de sortie. Sans
+    etat lisible (etat invalide ou d'un format anterieur), rien n'est consigne.
+    """
+    scope = _Scope(command, feature_dir, json_output)
+    if state is not None:
+        scope.issue_id, scope.activity = state.issueId, state.currentActivity
+    token = _CURRENT.set(scope)
+    try:
+        yield
+    except typer.Exit as exc:
+        code = int(exc.exit_code or 0)
+        if code == 0:
+            _record(scope, "advanced", None)
+        else:
+            _record(scope, "refused", scope.reason or _fallback_reason(code))
+        raise
+    else:
+        _record(scope, "advanced", None)
+    finally:
+        _CURRENT.reset(token)
+
+
+def bind_state(state) -> None:
+    """Fixe l'issue et l'activite courante une fois l'etat lu."""
+    scope = _CURRENT.get()
+    if scope is not None:
+        scope.issue_id, scope.activity = state.issueId, state.currentActivity
+
+
+def _record(scope: _Scope, outcome: str, reason: str | None) -> None:
+    if not telemetry_enabled():
+        return
+    if scope.issue_id is None:
+        try:
+            state = read_adaptive_state(scope.feature_dir / "workflow-state.json")
+        except Exception:  # noqa: BLE001 - etat anterieur ou illisible : pas une decision
+            return
+        if state is None:
+            return
+        scope.issue_id, scope.activity = state.issueId, state.currentActivity
+    try:
+        project = str(project_root_for_feature(scope.feature_dir))
+    except ValueError:
+        return
+    record = build_decision(
+        project=project,
+        issue_id=scope.issue_id,
+        command=scope.command,
+        activity=scope.activity,
+        outcome=outcome,
+        reason=reason,
+        run_id=scope.run_id,
+    )
+    try:
+        append_record(record, decisions_file())
+    except OSError as exc:
+        if not scope.json_output:
+            warn(f"Decision non enregistree : {exc}")

{devflow_cli-10.1.1.dist-info → devflow_cli-10.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: devflow-cli
-Version: 10.1.1
+Version: 10.2.0
 Summary: Workflow adaptatif pour Claude Code : profils, preuves et contrats d'activité
 Project-URL: Homepage, https://github.com/sopequenoteck/devflow
 Project-URL: Repository, https://github.com/sopequenoteck/devflow
@@ -122,6 +122,10 @@ Chaque refus affiche son motif et la commande de reprise recommandée.
 - En fin de parcours, terminé ou abandonné : un bilan avec
   `devflow feedback add --type bilan`.
 
+`devflow report` restitue, tous parcours confondus, les coûts par profil et
+par activité, les refus de la CLI avec ou sans agent, les reprises et les
+frictions ouvertes.
+
 ## Profils et garde-fous
 
 Le profil fixe la route documentaire :

{devflow_cli-10.1.1.dist-info → devflow_cli-10.2.0.dist-info}/RECORD

@@ -1,16 +1,17 @@
-devflow_cli/__init__.py,sha256=NAGGk9OBe8YXw8PKPqglUP-Ky2xGiIPf0Ine3TMUXl0,871
-devflow_cli/cli.py,sha256=DVLx3wr1Hulke2qxhgHsEvvprRuO7SVETui_VGPNQv4,1983
+devflow_cli/__init__.py,sha256=cjEP4qJtRxR_uhuY3EcJ5DiGTgPfDzvMh7foXSZR6DU,871
+devflow_cli/cli.py,sha256=QQktLkHK1cEAj0ZlEuGKYumm3xJUHM-aeC-E2RgfcEY,2136
 devflow_cli/adapters/__init__.py,sha256=z1J7_YJHcgak2a6dTZpOUKKwf-K7UwRqGzS8XY9duC0,299
 devflow_cli/adapters/agents.py,sha256=-9zmNlFmQfP2pOGxA3_SSKij8ScR76J4-sgv4GMBWEI,18530
 devflow_cli/adapters/linear.py,sha256=xHKjMuL3fFJEDBF65pPJ-yWHpXom999UAU2A0C7_QeI,8362
 devflow_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devflow_cli/commands/adaptive.py,sha256=jogZ_NE0EnuGOzU-w42HM7IxUiF2AYARZWS40HKMkLU,63295
+devflow_cli/commands/adaptive.py,sha256=PO_JW1KwNrb-Jozib-NPB21HCIeG5i0iPgYX5WBUuS4,64999
 devflow_cli/commands/assess.py,sha256=V-E3ft41ljCrqp2WLjR1Dqw-JtswcqsK2nD1-euNbNE,5655
 devflow_cli/commands/check.py,sha256=nJOHVFvgT3Nq70g-4QGrSDZVwCSetu6g7snZcfLFf9I,4421
 devflow_cli/commands/docs_sync.py,sha256=Xc0mulpNTjDyeUDumKL7VNG0eumAf3016wEM_dqXpSU,1021
 devflow_cli/commands/feature.py,sha256=IkXKdKTNK6QTTzIG3zFu5a13_MMBEsTc1xjvUjdOLVo,5006
 devflow_cli/commands/feedback.py,sha256=lP-q-gcSuf1--DMLfgEchwmxllpmjs8-Te06p7l0RQU,9314
 devflow_cli/commands/init_cmd.py,sha256=n1vanuDTt3LtxsYFyeJDetlFWPWbTQLQZ4Vwdx33oV0,3743
+devflow_cli/commands/report.py,sha256=rLzb2CqMqCU5U6Ssw1ab6NdtpaUGdOsY66hZ51H3DVA,12091
 devflow_cli/commands/status.py,sha256=Votdh_sZkRuC_iui1krrdXE9cZ5dpY2OO2au4PVa7IQ,8647
 devflow_cli/commands/upgrade_cmd.py,sha256=7GYe1T7SWzkDSYW9x1G-Dznw9qwKT2uI1gJUcWr9_2M,6093
 devflow_cli/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -23,6 +24,7 @@ devflow_cli/core/agent_run_marker.py,sha256=QW3ScA2ZpqfQdUo5ANTbenDVyY2iHpB_wTaN
 devflow_cli/core/assessment.py,sha256=ACtJbXq1qZjVfeERjy8Qg6-ioLfSMUBVQm2l-mtGwgI,11522
 devflow_cli/core/automatic_evidence.py,sha256=pqSnNXe6RHthII6fgoHlCNkGiFTKQ4yyRtErGUwbvas,42559
 devflow_cli/core/contract_schemas.py,sha256=M0Twbt_SVVfuPa7udC-EJuR3pTl9pWrxQUCohIsg1h0,8477
+devflow_cli/core/decisions.py,sha256=tFYKNDaztMvnhLfVGJKIux5zaSjEPx2nwXs5nb2qv4U,6308
 devflow_cli/core/docgen.py,sha256=47JoVDWetkcctgHwJZC67AVebOKgl10VB9hZ3Xr63mo,3908
 devflow_cli/core/feedback.py,sha256=07asmhX1cG4SXkoLlnSjA_UXgYnkFYoxl4u3JmOhpm0,13382
 devflow_cli/core/git.py,sha256=SsHL0OeJ8Bzc5cJC0moeBuyuwnvrJjtwnaI58TnzUSU,2536
@@ -56,8 +58,8 @@ devflow_cli/utils/strings.py,sha256=bfFXCwBDnFxshgZOYfy6mtysnjiaWO1wFnqBf7HLg4o,
 devflow_cli/resources/commands/devflow.md,sha256=5MjahTVYXAT_zrjEQmM25KH9s6DbRmyI1TdJCxYlrKk,3464
 devflow_cli/resources/commands/devflow.status.md,sha256=tqjQ1IboU99ztG6C4nunBHGJCvMn3qDqx3AoF4SPjCk,338
 devflow_cli/resources/templates/constitution-template.md,sha256=uSzNuwF-xIRx8cHt9gloynRjNgDGmnN5z2Xck6fCOsI,2102
-devflow_cli-10.1.1.dist-info/METADATA,sha256=2J_RNk3Db7cbmZbRZxe_NfLeXFOnXtLde9bIRsOec4I,6501
-devflow_cli-10.1.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-devflow_cli-10.1.1.dist-info/entry_points.txt,sha256=GVJ6bMvFpqyO5589iC4nFKeGTpGIW8aKn_QPPpSZ6kU,48
-devflow_cli-10.1.1.dist-info/licenses/LICENSE,sha256=v79PvnmqOdKhQiOa_QcWxng4q8GuGscLOwi7ygUpwpo,1070
-devflow_cli-10.1.1.dist-info/RECORD,,
+devflow_cli-10.2.0.dist-info/METADATA,sha256=aCyvi0qzuPnbCz05ltRmvDrX2GSqjRaqWQ_S8BPLnBo,6674
+devflow_cli-10.2.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+devflow_cli-10.2.0.dist-info/entry_points.txt,sha256=GVJ6bMvFpqyO5589iC4nFKeGTpGIW8aKn_QPPpSZ6kU,48
+devflow_cli-10.2.0.dist-info/licenses/LICENSE,sha256=v79PvnmqOdKhQiOa_QcWxng4q8GuGscLOwi7ygUpwpo,1070
+devflow_cli-10.2.0.dist-info/RECORD,,

{devflow_cli-10.1.1.dist-info → devflow_cli-10.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.4
+Generator: hatchling 1.33.0
 Root-Is-Purelib: true
 Tag: py3-none-any