devflow-cli 8.5.0__py3-none-any.whl → 9.0.0__py3-none-any.whl

devflow_cli/__init__.py

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

devflow_cli/commands/adaptive.py

@@ -17,6 +17,7 @@ from devflow_cli import VERSION
 from devflow_cli.adapters.linear import sync_activity_status
 from devflow_cli.core.adaptive_workflow import (
     AdaptiveWorkflowState,
+    adaptive_state_violation,
     complete_activity,
     create_adaptive_workflow,
     read_adaptive_state,
@@ -75,7 +76,11 @@ from devflow_cli.core.validation_approvals import (
     pending_approvals,
     pending_plan_approval,
 )
-from devflow_cli.core.contract_schemas import LegacySchemaError, diagnose_contract_file
+from devflow_cli.core.contract_schemas import (
+    LegacySchemaError,
+    check_feature_files,
+    diagnose_contract_file,
+)
 from devflow_cli.core.operational import ExitCode, exit_code_for_run_reason
 from devflow_cli.core.result_template import (
     remove_result_template,
@@ -148,8 +153,12 @@ def _state(
         raise typer.Exit(LEGACY_SCHEMA_EXIT_CODE) from exc
     if state is None:
         diagnostic = diagnose_contract_file("workflow-state", state_file)
-        detail = (
-            diagnostic or "workflow-state.json respecte le schema mais ses invariants "
+        violation = None if diagnostic else adaptive_state_violation(state_file)
+        detail = diagnostic or (
+            "workflow-state.json respecte le schema mais viole le verrou "
+            f"{violation}."
+            if violation
+            else "workflow-state.json respecte le schema mais ses invariants "
             "métier sont incoherents."
         )
         if json_output:
@@ -191,6 +200,7 @@ def start(feature: str = typer.Argument(..., help="ID ou dossier de la feature")
             fail("workflow-state.json existe deja ; le workflow ne sera pas ecrase.")
             console.print(f"  Suite : devflow adaptive status {feature}")
             raise typer.Exit(int(ExitCode.CONCURRENT_CHANGE))
+        check_feature_files(feature_dir)
         try:
             assessment = _assessment(feature_dir)
             validate_need_statement(feature_dir / NEED_STATEMENT)
@@ -198,10 +208,10 @@ def start(feature: str = typer.Argument(..., help="ID ou dossier de la feature")
             enter_current_activity(
                 state, project_root_for_feature(feature_dir), feature_dir
             )
+            write_adaptive_state(state_file, state)
         except (OSError, ValueError) as exc:
             fail(f"Impossible de demarrer le workflow : {exc}")
             raise typer.Exit(int(ExitCode.INVALID_CONTRACT)) from exc
-        write_adaptive_state(state_file, state)
     safe_refresh_worklog(feature_dir)
     ok(
         f"Workflow {state.profile} demarre. "
@@ -256,11 +266,11 @@ def complete(
             enter_current_activity(
                 state, project_root_for_feature(feature_dir), feature_dir
             )
+            write_adaptive_state(feature_dir / "workflow-state.json", state)
         except (OSError, ValueError) as exc:
             fail(str(exc))
             console.print(f"  Suite : devflow adaptive status {state.issueId}")
             raise typer.Exit(int(ExitCode.BLOCKED)) from exc
-        write_adaptive_state(feature_dir / "workflow-state.json", state)
     safe_refresh_worklog(feature_dir)
     if activity == "done":
         sync_activity_status(state.issueId, "done", run_progress.progress_stream(False))
@@ -284,10 +294,10 @@ def evidence(
         state = _state(feature_dir)
         try:
             record_evidence(state, evidence_id, report or "")
+            write_adaptive_state(feature_dir / "workflow-state.json", state)
         except ValueError as exc:
             fail(str(exc))
             raise typer.Exit(int(ExitCode.BLOCKED)) from exc
-        write_adaptive_state(feature_dir / "workflow-state.json", state)
     safe_refresh_worklog(feature_dir)
     ok(f"Preuve '{evidence_id}' enregistree.")
     warn("Source manuelle : cette preuve ne valide pas les gates du workflow.")
@@ -478,7 +488,7 @@ def run_adaptive(
             }
             _write_json_atomic(feature_dir / "agent-execution.json", audit_payload)
         except (OSError, ValueError) as exc:
-            return AgentActivityExecution(1, stderr=str(exc))
+            return AgentActivityExecution(1, stderr=str(exc), agent=agent)
         return AgentActivityExecution(
             execution.returncode,
             output,
@@ -528,6 +538,8 @@ def run_adaptive(
         recovery = _stale_preflight_recovery(current_state)
     if outcome.reason == "artifact-files-mismatch":
         recovery = _artifact_mismatch_recovery(current_state, outcome, agent)
+    if outcome.reason == "imputed-input":
+        recovery = _imputed_input_recovery(current_state, outcome, agent)
     if json_output:
         _print_execution_json(
             current_state.issueId, outcome.activity, False, outcome.reason,
@@ -716,6 +728,14 @@ def reconcile_adaptive(
                 state, outcome, _attempt_agent(feature_dir, outcome.activity)
             )
         )
+    if outcome.reason == "imputed-input":
+        console.print("  Reprise guidee :")
+        _print_recovery_steps(
+            _imputed_input_recovery(
+                state, outcome, _attempt_agent(feature_dir, outcome.activity),
+                reconcile=True,
+            )
+        )
     if (
         outcome.reason == "reconcile-refused"
         and activity_attempt_file(feature_dir, outcome.activity).is_file()
@@ -903,11 +923,11 @@ def reopen(
             enter_current_activity(
                 state, project_root_for_feature(feature_dir), feature_dir
             )
+            write_adaptive_state(feature_dir / "workflow-state.json", state)
         except (OSError, ValueError) as exc:
             fail(str(exc))
             console.print(f"  Suite : devflow adaptive status {state.issueId}")
             raise typer.Exit(int(ExitCode.BLOCKED)) from exc
-        write_adaptive_state(feature_dir / "workflow-state.json", state)
     safe_refresh_worklog(feature_dir)
     ok(
         f"Workflow rouvert sur '{activity}' (audit #{entry['sequence']}, "
@@ -1605,10 +1625,41 @@ def _stale_preflight_recovery(state: AdaptiveWorkflowState) -> dict:
 ARTIFACT_FILE_CAUSES = {
     "during-agent": "modifie pendant l'agent",
     "before-launch": "modifie avant le lancement de l'agent",
-    "agent-input": "entree du besoin modifiee par un agent de cette activite",
 }
 
 
+def _imputed_input_recovery(
+    state: AdaptiveWorkflowState, outcome: AdaptiveRunOutcome, agent: str,
+    *, reconcile: bool = False,
+) -> dict:
+    """Reprise guidee d'un refus `imputed-input` : remise en etat ou abandon audite."""
+    issue = shlex.quote(state.issueId)
+    not_done = "reconcile refuse" if reconcile else "l'agent n'a pas ete lance"
+    return {
+        "kind": "imputed-input",
+        "summary": (
+            "Entree du besoin modifiee par un agent de cette activite et pas remise "
+            f"en etat : {not_done}. Deux sorties : remettre l'entree dans son etat de "
+            "base, ou abandonner la tentative (l'entree modifiee est gardee, a verifier)."
+        ),
+        "files": [{"path": path} for path in outcome.imputedInputs],
+        "commands": [
+            {
+                "command": f"devflow adaptive run {issue}"
+                + (f" --agent {shlex.quote(agent)}" if agent else ""),
+                "purpose": "apres remise en etat de l'entree dans son etat de base",
+            },
+            {
+                "command": f"devflow adaptive discard-attempt {issue} --reason MOTIF",
+                "purpose": (
+                    "sinon, garder l'entree modifiee : abandon audite de la "
+                    "tentative, puis devflow adaptive run"
+                ),
+            },
+        ],
+    }
+
+
 def _artifact_mismatch_recovery(
     state: AdaptiveWorkflowState, outcome: AdaptiveRunOutcome, agent: str
 ) -> dict:
@@ -1633,34 +1684,6 @@ def _artifact_mismatch_recovery(
                 "purpose": "relancer l'agent pour qu'il ecrive l'artefact",
             }],
         }
-    if causes == {"agent-input"}:
-        # Refus avant l'agent : ni reconcile ni reopen ne leve l'imputation.
-        run = f"devflow adaptive run {issue}" + (
-            f" --agent {shlex.quote(agent)}" if agent else ""
-        )
-        return {
-            "kind": "artifact-files-mismatch",
-            "summary": (
-                "Entree du besoin modifiee par un agent de cette activite et pas remise "
-                "en etat : l'agent n'a pas ete lance. Deux sorties : remettre l'entree "
-                "dans son etat de base, ou abandonner la tentative (l'entree modifiee "
-                "est gardee, a verifier)."
-            ),
-            "files": files,
-            "commands": [
-                {
-                    "command": run,
-                    "purpose": "apres remise en etat de l'entree dans son etat de base",
-                },
-                {
-                    "command": f"devflow adaptive discard-attempt {issue} --reason MOTIF",
-                    "purpose": (
-                        "sinon, garder l'entree modifiee : abandon audite de la "
-                        "tentative, puis devflow adaptive run"
-                    ),
-                },
-            ],
-        }
     commands = [{
         "command": f"devflow adaptive reconcile {issue}",
         "purpose": (
@@ -1672,7 +1695,6 @@ def _artifact_mismatch_recovery(
     previous = state.activities[index - 1] if index > 0 else ""
     if (
         "before-launch" in causes
-        and "agent-input" not in causes
         and previous not in {"", "assess"}
         and _reopenable(state, previous)
     ):
@@ -1683,14 +1705,6 @@ def _artifact_mismatch_recovery(
                 "l'activite precedente pour repartir d'une base fraiche"
             ),
         })
-    if "agent-input" in causes:
-        commands.append({
-            "command": f"devflow adaptive discard-attempt {issue} --reason MOTIF",
-            "purpose": (
-                "sinon, garder l'entree du besoin modifiee par l'agent : abandon "
-                "audite de la tentative, puis devflow adaptive run"
-            ),
-        })
     return {
         "kind": "artifact-files-mismatch",
         "summary": (
@@ -1719,9 +1733,8 @@ def _print_recovery_steps(recovery: dict) -> None:
     # soft_wrap : la commande a copier reste sur une seule ligne.
     console.print(f"    {recovery['summary']}", markup=False, soft_wrap=True)
     for item in recovery.get("files", []):
-        console.print(
-            f"    {item['path']} : {item['label']}", markup=False, soft_wrap=True
-        )
+        label = f" : {item['label']}" if "label" in item else ""
+        console.print(f"    {item['path']}{label}", markup=False, soft_wrap=True)
     for step in recovery["commands"]:
         console.print(
             f"    {step['command']}  # {step['purpose']}", markup=False, soft_wrap=True
@@ -1777,25 +1790,22 @@ def _print_run_recovery(
             "    Les entrees du besoin ont change pendant l'execution. "
             "Verifiez-les avant une nouvelle tentative."
         )
-        if activity in DOCUMENT_ARTIFACTS:
-            console.print(
-                "    Activite documentaire : la relance reste refusee tant que l'entree "
-                "n'est pas remise dans son etat de base, ou la tentative abandonnee :",
-                markup=False, soft_wrap=True,
-            )
-            issue, agent_arg = shlex.quote(issue_id), shlex.quote(agent)
-            console.print(
-                f"    devflow adaptive discard-attempt {issue} --reason MOTIF"
-                "  # garder l'entree modifiee : abandon audite",
-                markup=False, soft_wrap=True,
-            )
-            console.print(
-                f"    devflow adaptive run {issue} --agent {agent_arg}"
-                "  # apres remise en etat de l'entree, ou apres l'abandon",
-                markup=False, soft_wrap=True,
-            )
-            return
-        console.print(f"    devflow adaptive run {issue_id} --agent {agent}")
+        console.print(
+            "    La relance reste refusee tant que l'entree "
+            "n'est pas remise dans son etat de base, ou la tentative abandonnee :",
+            markup=False, soft_wrap=True,
+        )
+        issue, agent_arg = shlex.quote(issue_id), shlex.quote(agent)
+        console.print(
+            f"    devflow adaptive discard-attempt {issue} --reason MOTIF"
+            "  # garder l'entree modifiee : abandon audite",
+            markup=False, soft_wrap=True,
+        )
+        console.print(
+            f"    devflow adaptive run {issue} --agent {agent_arg}"
+            "  # apres remise en etat de l'entree, ou apres l'abandon",
+            markup=False, soft_wrap=True,
+        )
         return
     if reason == "agent-running":
         console.print("    Un agent execute deja cette activite : attendez sa fin.")

devflow_cli/commands/status.py

@@ -80,7 +80,7 @@ def _list_features() -> None:
             table.add_row(
                 feature_dir.name,
                 "-",
-                "[yellow]schema 6.x[/yellow]",
+                "[yellow]ancien schema[/yellow]",
                 "-",
                 location,
             )

devflow_cli/core/activity_base.py

@@ -8,6 +8,7 @@ la declaration de l'agent ne produit qu'un avertissement.
 from __future__ import annotations
 
 import copy
+import json
 import re
 import subprocess
 from dataclasses import dataclass
@@ -16,6 +17,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, Iterable
 
 from devflow_cli.adapters.linear import environment_without_linear_key
+from devflow_cli.core.contract_schemas import ATTEMPT_SCHEMA_VERSION
 from devflow_cli.core.worktree_snapshot import (
     _fingerprint,
     _git_paths,
@@ -24,7 +26,7 @@ from devflow_cli.core.worktree_snapshot import (
     snapshot_worktree,
     untracked_paths,
 )
-from devflow_cli.utils.paths import project_root_for_feature
+from devflow_cli.utils.paths import activity_attempt_file, project_root_for_feature
 
 if TYPE_CHECKING:
     from devflow_cli.core.activity_contracts import ActivityContract, ActivityResult
@@ -49,6 +51,14 @@ RUNTIME_FILE_NAMES = frozenset({
 RUNTIME_FILE_SUFFIXES = ("-result.json", "-attempt.json", ".raw.txt")
 RUNTIME_DIRECTORIES = ("attempts", "evidence")
 
+# Fiche de tentative (CT-04) : cles exactes, validees par ``attempt_violation`` seule.
+ATTEMPT_KEYS = frozenset({
+    "schemaVersion", "contractId", "activity", "agent", "reason", "recordedAt",
+    "head", "branch", "rawOutputSha256", "observedFiles", "executionFiles",
+    "changedInputs",
+})
+RAW_OUTPUT_SHA256_PATTERN = re.compile(r"^[0-9a-f]{64}$")
+
 OBSERVATION_SCHEMA: dict[str, Any] = {
     "type": "object",
     "required": ["baseRecordedAt", "baseHead", "observedAt", "head"],
@@ -61,6 +71,7 @@ OBSERVATION_SCHEMA: dict[str, Any] = {
             "type": "array", "items": {"type": "string", "minLength": 1}
         },
         "warning": {"type": "string", "minLength": 1},
+        "amendmentWarning": {"type": "string", "minLength": 1},
     },
     "additionalProperties": False,
     "dependentRequired": {
@@ -378,7 +389,8 @@ def recorded_observation(
     """Bloc ``observation`` ecrit par la CLI seule dans le resultat enregistre.
 
     ``exempted`` : entrees du besoin amendees avant l'agent, hors ecart de
-    declaration ; ``amendment_warning`` les nomme dans la cle ``warning``.
+    declaration ; ``amendment_warning`` les nomme dans la cle ``amendmentWarning``,
+    distincte de ``warning`` (ecart de declaration seul).
     """
     observed = sorted(set(observation.sinceBase) - set(exempted))
     block: dict[str, Any] = {
@@ -387,17 +399,94 @@ def recorded_observation(
         "observedAt": observation.observedAt,
         "head": observation.head,
     }
-    warning = " ; ".join(
-        message
-        for message in (declaration_warning(declared, observed), amendment_warning)
-        if message
-    )
+    warning = declaration_warning(declared, observed)
     if warning:
         block["declaredChangedFiles"] = list(declared)
         block["warning"] = warning
+    if amendment_warning:
+        block["amendmentWarning"] = amendment_warning
     return block
 
 
+def attempt_violation(attempt: object) -> str | None:
+    """Premier invariant A1 a A10 viole par une fiche de tentative, ou None (CT-04).
+
+    Seule validation de la fiche : l'ecriture et la lecture l'appellent.
+    """
+    prefix = "fiche de tentative : "
+    if not isinstance(attempt, dict):
+        return prefix + "objet attendu"
+    missing = sorted(ATTEMPT_KEYS - set(attempt))
+    if missing:
+        return prefix + "cles manquantes : " + ", ".join(missing)
+    extra = sorted(set(attempt) - ATTEMPT_KEYS)
+    if extra:
+        return prefix + "cles en trop : " + ", ".join(extra)
+    version = attempt["schemaVersion"]
+    if isinstance(version, bool) or version != ATTEMPT_SCHEMA_VERSION:
+        return prefix + f"schemaVersion {ATTEMPT_SCHEMA_VERSION} attendu"
+    for key in ("contractId", "activity", "recordedAt", "head", "branch"):
+        if not isinstance(attempt[key], str):
+            return prefix + f"{key} doit etre une chaine"
+    for key in ("contractId", "activity", "agent", "reason", "recordedAt"):
+        if not isinstance(attempt[key], str) or not attempt[key]:
+            return prefix + f"{key} vide"
+    raw_sha = attempt["rawOutputSha256"]
+    if not isinstance(raw_sha, str) or not RAW_OUTPUT_SHA256_PATTERN.fullmatch(raw_sha):
+        return prefix + "rawOutputSha256 invalide"
+    observed = attempt["observedFiles"]
+    if not isinstance(observed, dict) or not all(
+        isinstance(path, str) and isinstance(fingerprint, str)
+        for path, fingerprint in observed.items()
+    ):
+        return prefix + "observedFiles invalide"
+    execution_files = attempt["executionFiles"]
+    if not isinstance(execution_files, list) or not all(
+        isinstance(item, str) for item in execution_files
+    ):
+        return prefix + "executionFiles invalide"
+    changed = attempt["changedInputs"]
+    if (
+        not isinstance(changed, list)
+        or not all(isinstance(item, str) and item for item in changed)
+        or changed != sorted(set(changed))
+    ):
+        return prefix + "changedInputs invalide"
+    if attempt["head"] == "" and attempt["branch"] == "" and observed == {} and not changed:
+        return prefix + "fiche minimale incoherente"
+    return None
+
+
+def imputed_inputs(
+    feature_dir: Path,
+    feature_path: str,
+    activity: str,
+    contract_id: str,
+    since_base: dict[str, str],
+) -> list[str]:
+    """Entrees que la fiche de tentative impute a un agent de l'activite (CT-01).
+
+    Seules comptent celles qui different encore de la base : une entree remise en
+    etat n'est plus imputee. Une fiche absente, illisible, invalide, d'une autre
+    activite ou d'un autre contrat n'impute rien. Aucune ecriture.
+    """
+    try:
+        attempt = json.loads(
+            activity_attempt_file(feature_dir, activity).read_text(encoding="utf-8")
+        )
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return []
+    if attempt_violation(attempt) is not None:
+        return []
+    if attempt["activity"] != activity or attempt["contractId"] != contract_id:
+        return []
+    return sorted(
+        name
+        for name in attempt["changedInputs"]
+        if f"{feature_path}/{name}" in since_base
+    )
+
+
 def parse_recorded_result(
     payload: object, contract: "ActivityContract"
 ) -> tuple["ActivityResult", dict[str, Any]]:

devflow_cli/core/activity_contracts.py

@@ -19,6 +19,7 @@ from devflow_cli.core.adaptive_workflow import (
 from devflow_cli.core.assessment import ASSESSMENT_SCHEMA_VERSION, compute_route
 from devflow_cli.core.contract_schemas import (
     activity_result_schema,
+    contract_schema_version,
     validate_contract_payload,
 )
 from devflow_cli.core.validators import ARTIFACT_RULES
@@ -573,7 +574,7 @@ def parse_activity_result(payload: dict[str, Any], contract: ActivityContract) -
         expected_fields.add("validationPlan")
     if expected_fields != set(payload):
         raise ValueError("champs du resultat manquants ou inattendus")
-    if payload.get("schemaVersion") != 1:
+    if payload.get("schemaVersion") != contract_schema_version("activity-result"):
         raise ValueError("schema de resultat non supporte")
     if payload.get("contractId") != contract.contractId:
         raise ValueError("contractId du resultat incorrect")
@@ -678,7 +679,7 @@ def parse_activity_result(payload: dict[str, Any], contract: ActivityContract) -
     )
 
     return ActivityResult(
-        schemaVersion=1,
+        schemaVersion=contract_schema_version("activity-result"),
         contractId=contract.contractId,
         status=status,
         summary=summary.strip(),