devflow-cli 3.0.1__py3-none-any.whl → 4.0.2__py3-none-any.whl

devflow_cli/__init__.py

@@ -1,6 +1,6 @@
 """devflow CLI — workflow de développement adaptatif."""
 
-VERSION = "3.0.1"
+VERSION = "4.0.2"
 
 SUPPORTED_AGENTS = ["claude-code", "codex", "cursor"]
 
@@ -13,6 +13,7 @@ ACTIVITY_LINEAR_MAPPING = {
     "contracts": "Plan",
     "plan": "Plan",
     "tasks": "Tasks",
+    "preflight-evidence": "Plan",
     "implement": "In Progress",
     "verify": "Review",
     "review": "Review",
@@ -38,6 +39,7 @@ ARTIFACTS = [
     "contracts.md",
     "plan.md",
     "tasks.md",
+    "preflight-evidence.md",
     "worklog.md",
     "activity-contract.json",
     "activity-result.json",

devflow_cli/adapters/agents.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import subprocess
 import re
+import time
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from pathlib import Path
@@ -17,6 +18,11 @@ from jsonschema.validators import validator_for
 PermissionMode = Literal["auto", "acceptEdits", "manual"]
 SandboxMode = Literal["read-only", "workspace-write"]
 
+_SAFE_DIAGNOSTIC_MESSAGES = {
+    "final-output-empty": "--output-last-message est vide",
+    "final-output-absent": "--output-last-message est absent",
+}
+
 
 @dataclass(frozen=True)
 class AgentExecution:
@@ -24,6 +30,19 @@ class AgentExecution:
     stdout: str = ""
     stderr: str = ""
     timed_out: bool = False
+    duration_seconds: float = 0.0
+    final_output_status: str = "unknown"
+    final_output_bytes: int = 0
+    final_output_diagnostic: str = "not-evaluated"
+    session_id: str | None = None
+
+
+class StructuredOutputError(ValueError):
+    """Erreur de sortie agent dont le diagnostic peut etre expose sans contenu."""
+
+    def __init__(self, diagnostic: str, message: str) -> None:
+        super().__init__(message)
+        self.diagnostic = diagnostic
 
 
 class AgentAdapter(ABC):
@@ -96,6 +115,7 @@ class AgentAdapter(ABC):
         command = self.build_structured_command(
             prompt, permission_mode, schema_file, output_file, sandbox_mode
         )
+        started = time.monotonic()
         try:
             result = subprocess.run(
                 command,
@@ -109,6 +129,11 @@ class AgentAdapter(ABC):
                 result.returncode,
                 result.stdout or "",
                 result.stderr or "",
+                duration_seconds=time.monotonic() - started,
+                final_output_status=_output_status(output_file),
+                final_output_bytes=_output_size(output_file),
+                final_output_diagnostic="process-failed" if result.returncode else "validating",
+                session_id=_session_id(result.stdout or "", result.stderr or ""),
             )
             if execution.returncode != 0:
                 return execution
@@ -118,25 +143,62 @@ class AgentAdapter(ABC):
                 output_file.write_text(
                     json.dumps(payload, ensure_ascii=False), encoding="utf-8"
                 )
-            except (
-                OSError, ValueError, json.JSONDecodeError, SchemaError, ValidationError
-            ) as exc:
-                output_file.unlink(missing_ok=True)
+            except StructuredOutputError as exc:
+                diagnostic = exc.diagnostic
+            except json.JSONDecodeError:
+                diagnostic = "final-output-invalid-json"
+            except ValidationError:
+                diagnostic = "final-output-schema-rejected"
+            except SchemaError:
+                diagnostic = "output-schema-invalid"
+            except OSError:
+                diagnostic = "final-output-unreadable"
+            except ValueError:
+                diagnostic = "final-output-invalid"
+            else:
                 return AgentExecution(
-                    1,
+                    execution.returncode,
                     execution.stdout,
-                    f"Sortie structuree invalide ({self.name}) : {exc}",
+                    execution.stderr,
+                    execution.timed_out,
+                    execution.duration_seconds,
+                    _output_status(output_file),
+                    _output_size(output_file),
+                    "validated",
+                    execution.session_id,
                 )
-            return execution
+
+            status = _output_status(output_file)
+            size = _output_size(output_file)
+            output_file.unlink(missing_ok=True)
+            return AgentExecution(
+                1,
+                execution.stdout,
+                "Sortie structuree invalide "
+                f"({self.name}) [{diagnostic}]"
+                + (
+                    f" : {_SAFE_DIAGNOSTIC_MESSAGES[diagnostic]}"
+                    if diagnostic in _SAFE_DIAGNOSTIC_MESSAGES
+                    else ""
+                ),
+                duration_seconds=execution.duration_seconds,
+                final_output_status=status,
+                final_output_bytes=size,
+                final_output_diagnostic=diagnostic,
+                session_id=execution.session_id,
+            )
         except subprocess.TimeoutExpired as exc:
             return AgentExecution(
                 124,
                 _text(exc.stdout),
                 _text(exc.stderr),
                 timed_out=True,
+                duration_seconds=time.monotonic() - started,
+                final_output_status=_output_status(output_file),
+                final_output_bytes=_output_size(output_file),
             )
         except FileNotFoundError:
-            return AgentExecution(127, stderr=f"Executable '{self.executable}' introuvable")
+            return AgentExecution(127, stderr=f"Executable '{self.executable}' introuvable", duration_seconds=time.monotonic() - started)
 
     def _structured_payload(self, stdout: str, output_file: Path) -> object:
         if output_file.is_file():
@@ -169,7 +231,7 @@ class ClaudeCodeAdapter(AgentAdapter):
         sandbox_mode: SandboxMode = "workspace-write",
     ) -> list[str]:
         del output_file
-        schema = schema_file.read_text(encoding="utf-8")
+        schema = _claude_compatible_schema(schema_file)
         effective_mode = "plan" if sandbox_mode == "read-only" else permission_mode
         return [
             self.executable,
@@ -236,15 +298,13 @@ class CodexAdapter(AgentAdapter):
             payload = output_file.read_text(encoding="utf-8")
             if payload.strip():
                 return json.loads(payload)
-            raise ValueError(
-                "Codex a termine sans reponse finale structuree "
-                "(--output-last-message est vide)"
+            raise StructuredOutputError(
+                "final-output-empty",
+                "Codex a termine sans reponse finale structuree",
             )
-        if stdout.strip():
-            return json.loads(stdout)
-        raise ValueError(
-            "Codex n'a pas produit de reponse finale structuree "
-            "ni de sortie standard exploitable"
+        raise StructuredOutputError(
+            "final-output-absent",
+            "Codex n'a pas produit le fichier de reponse finale structuree",
         )
 
 
@@ -326,12 +386,43 @@ def _portable_prompt(prompt: str) -> str:
     )
 
 
+def _claude_compatible_schema(schema_file: Path) -> str:
+    """Adapte l'en-tete Draft 2020-12 au format accepte par Claude Code."""
+    raw_schema = schema_file.read_text(encoding="utf-8")
+    schema = json.loads(raw_schema)
+    if not isinstance(schema, dict):
+        raise ValueError("schema JSON Claude invalide")
+    if schema.get("$schema") != "https://json-schema.org/draft/2020-12/schema":
+        return raw_schema
+    schema["$schema"] = "http://json-schema.org/draft-07/schema#"
+    return json.dumps(schema, ensure_ascii=False)
+
+
 def _text(value: str | bytes | None) -> str:
     if value is None:
         return ""
     return value.decode(errors="replace") if isinstance(value, bytes) else value
 
 
+def _output_status(path: Path) -> str:
+    if not path.is_file():
+        return "absent"
+    return "empty" if _output_size(path) == 0 else "present"
+
+
+def _output_size(path: Path) -> int:
+    try:
+        return path.stat().st_size
+    except OSError:
+        return 0
+
+
+def _session_id(stdout: str, stderr: str) -> str | None:
+    # Only retain an opaque identifier, never the surrounding agent output.
+    match = re.search(r'(?i)(?:session[_ -]?id|session)\s*[=:]\s*["\']?([a-z0-9-]{8,})', stdout + "\n" + stderr)
+    return match.group(1) if match else None
+
+
 def _strip_json_fence(value: str) -> str:
     text = value.strip()
     match = re.fullmatch(r"```(?:json)?\s*([\s\S]*?)\s*```", text, re.IGNORECASE)

devflow_cli/commands/adaptive.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import os
 import tempfile
 from pathlib import Path
 from typing import Literal, Optional
@@ -22,6 +23,7 @@ from devflow_cli.core.assessment import read_assessment
 from devflow_cli.core.activity_contracts import (
     build_activity_contract,
     render_contract_prompt,
+    validate_preflight_evidence,
     write_activity_contract,
 )
 from devflow_cli.core.adaptive_runner import (
@@ -29,6 +31,7 @@ from devflow_cli.core.adaptive_runner import (
     run_current_activity,
 )
 from devflow_cli.core.worktree_snapshot import changed_paths, snapshot_worktree
+from devflow_cli.core.v4_migration import migrate_to_v4
 from devflow_cli.core.automatic_evidence import run_automatic_verification
 from devflow_cli.core.worklog import refresh_worklog, safe_refresh_worklog
 from devflow_cli.core.waivers import create_validation_waiver
@@ -47,6 +50,32 @@ from devflow_cli.utils.paths import project_root_for_feature, resolve_feature_di
 app = typer.Typer(help="Machine d'etat des parcours adaptatifs")
 
 
+@app.command("migrate")
+def migrate_v4(
+    feature: str = typer.Argument(..., help="ID ou dossier de la feature"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Valide sans modifier les fichiers"),
+    json_output: bool = typer.Option(False, "--json", help="Sortie stable pour automatisation"),
+) -> None:
+    """Migre atomiquement assessment v1 + workflow-state v2 vers V4."""
+    feature_dir = _feature(feature)
+    with workflow_lock(feature_dir):
+        try:
+            report = migrate_to_v4(feature_dir, dry_run=dry_run)
+        except (OSError, ValueError) as exc:
+            fail(f"Migration V4 refusee : {exc}")
+            raise typer.Exit(int(ExitCode.INVALID_CONTRACT)) from exc
+    if json_output:
+        console.print_json(data=report)
+    elif dry_run:
+        ok("Dry-run V4 valide ; aucun fichier modifie.")
+        console.print(f"  Activite apres migration : {report['currentActivityAfter']}")
+    else:
+        safe_refresh_worklog(feature_dir)
+        ok("Workflow migre vers Devflow V4.")
+        console.print(f"  Sauvegarde : {report['backupPath']}")
+        console.print(f"  Activite   : {report['currentActivityAfter']}")
+
+
 def _feature(identifier: str) -> Path:
     feature_dir = resolve_feature_dir(identifier)
     if feature_dir is None:
@@ -67,6 +96,12 @@ def _state(feature_dir: Path):
         )
         console.print("  Diagnostic : corrigez ou migrez le fichier avant de relancer le workflow.")
         raise typer.Exit(int(ExitCode.INVALID_CONTRACT))
+    if state.schemaVersion != 3:
+        fail("workflow-state.json est au format V3 ; migrez-le avant toute commande V4.")
+        console.print(
+            f"  Suite : devflow adaptive migrate {state.issueId} --dry-run"
+        )
+        raise typer.Exit(int(ExitCode.INVALID_CONTRACT))
     return state
 
 
@@ -96,6 +131,11 @@ def start(feature: str = typer.Argument(..., help="ID ou dossier de la feature")
             raise typer.Exit(int(ExitCode.CONCURRENT_CHANGE))
         try:
             assessment = _assessment(feature_dir)
+            if assessment.schemaVersion != 2:
+                raise ValueError(
+                    "assessment.json V3 ne peut pas demarrer en V4 ; "
+                    "un workflow V3 existant doit etre migre"
+                )
             state = create_adaptive_workflow(assessment.to_dict())
         except ValueError as exc:
             fail(f"Impossible de demarrer le workflow : {exc}")
@@ -136,6 +176,8 @@ def complete(
     with workflow_lock(feature_dir):
         state = _state(feature_dir)
         try:
+            if activity == "preflight-evidence":
+                validate_preflight_evidence(feature_dir / "preflight-evidence.md")
             complete_activity(state, activity)
         except ValueError as exc:
             fail(str(exc))
@@ -236,7 +278,7 @@ def run_adaptive(
         return
     if current_state.currentActivity not in {
         "prepare", "risk-assessment", "spec", "research", "contracts", "plan",
-        "tasks", "implement", "review", "rollback-check",
+        "tasks", "preflight-evidence", "implement", "review", "rollback-check",
     }:
         fail(
             f"L'activite '{current_state.currentActivity}' ne necessite pas d'agent."
@@ -274,10 +316,25 @@ def run_adaptive(
                 output = (
                     output_file.read_text(encoding="utf-8")
                     if output_file.is_file()
-                    else ""
+                    else execution.stdout
                 )
             after = snapshot_worktree(project_root)
             observed = tuple(changed_paths(before, after))
+            audit_payload = {
+                "schemaVersion": 1,
+                "agent": agent,
+                "activity": activity_contract.activity,
+                "returnCode": execution.returncode,
+                "durationSeconds": round(execution.duration_seconds, 3),
+                "finalOutputStatus": execution.final_output_status,
+                "finalOutputBytes": execution.final_output_bytes,
+                "finalOutputDiagnostic": execution.final_output_diagnostic,
+                "sessionId": execution.session_id,
+                "timedOut": execution.timed_out,
+                "worktreeChanged": bool(observed),
+                "worktreeChangedFileCount": len(observed),
+            }
+            _write_json_atomic(feature_dir / "agent-execution.json", audit_payload)
         except (OSError, ValueError) as exc:
             return AgentActivityExecution(1, stderr=str(exc))
         return AgentActivityExecution(
@@ -295,6 +352,7 @@ def run_adaptive(
             f"Prochaine : {outcome.nextActivity}"
         )
         return
+    safe_refresh_worklog(feature_dir)
     fail(
         f"Activite '{outcome.activity}' non validee : {outcome.reason}"
         + (f" ({outcome.detail})" if outcome.detail else "")
@@ -397,6 +455,25 @@ def _execute_local_verification(
     raise typer.Exit(int(ExitCode.VERIFICATION_FAILURE))
 
 
+def _write_json_atomic(path: Path, payload: dict) -> None:
+    temporary: Path | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w", encoding="utf-8", dir=path.parent,
+            prefix=f".{path.name}.", suffix=".tmp", delete=False,
+        ) as handle:
+            temporary = Path(handle.name)
+            json.dump(payload, handle, indent=2, ensure_ascii=False)
+            handle.write("\n")
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary, path)
+        temporary = None
+    finally:
+        if temporary is not None:
+            temporary.unlink(missing_ok=True)
+
+
 @app.command("worklog")
 def worklog(
     feature: str = typer.Argument(..., help="ID ou dossier de la feature"),
@@ -590,6 +667,10 @@ def _print_run_recovery(
 ) -> None:
     console.print("  Reprise guidee :")
     console.print(f"    devflow adaptive status {issue_id}")
+    if reason == "agent-failed-after-mutation":
+        console.print("    git status --short  # inspecter les ecritures deja effectuees")
+        console.print("    Ne relancez pas automatiquement l'agent : reconciliez d'abord les changements partiels.")
+        return
     if reason == "agent-failed":
         console.print(f"    devflow check --ai {agent}")
     elif reason == "state-changed":

devflow_cli/commands/assess.py

@@ -89,6 +89,7 @@ def assess(
             ),
             summary=summary,
             profile_override=profile,
+            schema_version=2,
         )
     except ValueError as exc:
         fail(str(exc))

devflow_cli/core/activity_contracts.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 import json
 import os
 import tempfile
+import re
+import unicodedata
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
 from typing import Any, Literal
@@ -19,7 +21,7 @@ from devflow_cli.core.contract_schemas import (
 ACTIVITY_CONTRACT_SCHEMA_VERSION = 1
 SUPPORTED_AGENT_ACTIVITIES = {
     "prepare", "risk-assessment", "spec", "research", "contracts", "plan",
-    "tasks", "implement", "verify", "review", "rollback-check",
+    "tasks", "preflight-evidence", "implement", "verify", "review", "rollback-check",
 }
 DOCUMENT_ARTIFACTS = {
     "risk-assessment": "risk-assessment.md",
@@ -28,10 +30,16 @@ DOCUMENT_ARTIFACTS = {
     "contracts": "contracts.md",
     "plan": "plan.md",
     "tasks": "tasks.md",
+    "preflight-evidence": "preflight-evidence.md",
 }
 DOCUMENT_ACTIVITIES = set(DOCUMENT_ARTIFACTS)
 ActivityStatus = Literal["completed", "blocked"]
 
+PREFLIGHT_HEADINGS = (
+    "faits observes", "source", "reproductibilite", "perimetre",
+    "confidentialite", "limites",
+)
+
 
 @dataclass(frozen=True)
 class ActivityContract:
@@ -99,16 +107,44 @@ class ActivityResult:
 
 def document_artifact_name(activity: str, *, reopened: bool = False) -> str:
     """Retourne l'artefact unique attendu pour une activite documentaire."""
-    if activity == "plan" and reopened:
-        return "preflight-evidence.md"
+    del reopened
     return DOCUMENT_ARTIFACTS[activity]
 
 
 def contract_is_reopened_plan(contract: ActivityContract) -> bool:
-    return (
-        contract.activity == "plan"
-        and f"{contract.featurePath}/reopen-log.json" in contract.inputs
+    """Compatibility shim: V4 no longer overloads a reopened plan."""
+    del contract
+    return False
+
+
+def validate_preflight_evidence(path: Path, *, newer_than: list[Path] | None = None) -> None:
+    """Validate the V4 preflight artifact without exporting its contents."""
+    try:
+        content = path.read_text(encoding="utf-8")
+    except OSError as exc:
+        raise ValueError("preflight-evidence.md absent ou illisible") from exc
+    if not content.strip():
+        raise ValueError("preflight-evidence.md est vide")
+    normalized = "".join(
+        character
+        for character in unicodedata.normalize("NFKD", content.casefold())
+        if not unicodedata.combining(character)
+    )
+    missing = [heading for heading in PREFLIGHT_HEADINGS if heading not in normalized]
+    if missing:
+        raise ValueError("sections de pre-vol manquantes : " + ", ".join(missing))
+    sensitive_patterns = (
+        r"-----begin (?:rsa |ec |openssh )?private key-----",
+        r"\b(?:api[_-]?key|access[_-]?token|client[_-]?secret)\s*[:=]\s*\S{12,}",
+        r"\bbearer\s+[a-z0-9._~-]{20,}",
     )
+    if any(re.search(pattern, content, flags=re.IGNORECASE) for pattern in sensitive_patterns):
+        raise ValueError("preflight-evidence.md semble contenir un secret")
+    if newer_than:
+        artifact_mtime = path.stat().st_mtime_ns
+        stale_inputs = [item.name for item in newer_than if item.is_file() and item.stat().st_mtime_ns > artifact_mtime]
+        if stale_inputs:
+            raise ValueError("preuve de pre-vol desuete apres : " + ", ".join(sorted(stale_inputs)))
 
 
 def build_activity_contract(
@@ -123,8 +159,11 @@ def build_activity_contract(
     activity = state.currentActivity
     if activity not in SUPPORTED_AGENT_ACTIVITIES:
         raise ValueError(f"l'activite '{activity}' n'a pas de contrat agent")
-    if assessment.get("schemaVersion") != 1:
+    if assessment.get("schemaVersion") not in {1, 2}:
         raise ValueError("schema assessment.json non supporte")
+    expected_state_version = 2 if assessment["schemaVersion"] == 1 else 3
+    if state.schemaVersion != expected_state_version:
+        raise ValueError("versions assessment/workflow-state incoherentes ; migrez le couple")
     if assessment.get("issueId") != state.issueId:
         raise ValueError("issueId incoherent entre assessment et workflow")
     if assessment.get("selectedProfile") != state.profile:
@@ -150,16 +189,24 @@ def build_activity_contract(
             "Produire un artefact complet sans placeholder ni section vide.",
             "Declarer uniquement cet artefact dans changedFiles.",
         ]
-        if activity == "plan" and reopened:
+        if activity == "preflight-evidence":
             constraints.append(
-                "Archiver les faits, la source, la reproductibilite et les limites connues "
-                "dans preflight-evidence.md, sans y recopier de donnees sensibles."
+                "Documenter les sections Faits observes, Source, Reproductibilite, "
+                "Perimetre, Confidentialite et Limites."
             )
+            constraints.extend([
+                "Ne recopier aucun secret, jeton, donnee utilisateur ou contenu prive dans l'artefact.",
+                "Toute preuve doit etre reproductible ou indiquer explicitement pourquoi elle ne l'est pas.",
+            ])
         completion_criteria = [
             f"{artifact_name} existe et respecte la structure devflow.",
             "Le contenu est coherent avec l'objectif et les artefacts en entree.",
             "Les risques ou blocages restants sont explicites.",
         ]
+        if activity == "preflight-evidence":
+            completion_criteria.append(
+                "La preuve est non vide, actuelle, reproductible et ne contient aucune donnee sensible."
+            )
         if activity == "tasks":
             constraints.extend(
                 [
@@ -327,15 +374,17 @@ def build_activity_contract(
         constraints.append(
             "Cette execution suit une reouverture auditee : lire reopen-log.json et corriger explicitement le motif qui y est consigne."
         )
-    if activity == "plan" and reopened:
-        inputs.append(f"{feature_path}/plan.md")
-    if activity == "implement" and preflight_evidence:
+    if activity == "implement" and (assessment.get("schemaVersion") == 2 or preflight_evidence):
+        if not preflight_evidence:
+            raise ValueError("preflight-evidence.md absent avant implement")
         inputs.append(f"{feature_path}/preflight-evidence.md")
         constraints.append(
             "Prendre en compte la preuve de pre-vol archivee et ne pas la presenter comme absente."
         )
     if activity == "implement" and state.profile == "standard":
         inputs.append(f"{feature_path}/prepare-result.json")
+    if activity == "preflight-evidence" and state.profile == "standard":
+        inputs.append(f"{feature_path}/prepare-result.json")
     if state.profile == "deep":
         if activity in {"plan", "tasks", "implement"}:
             inputs.append(f"{feature_path}/spec.md")
@@ -343,6 +392,8 @@ def build_activity_contract(
             inputs.append(f"{feature_path}/plan.md")
         if activity == "implement":
             inputs.append(f"{feature_path}/tasks.md")
+        if activity == "preflight-evidence":
+            inputs.extend([f"{feature_path}/spec.md", f"{feature_path}/plan.md", f"{feature_path}/tasks.md"])
         if activity == "review":
             inputs.extend(
                 [
@@ -362,6 +413,7 @@ def build_activity_contract(
             "plan": ["risk-assessment.md", "spec.md", "research.md", "contracts.md"],
             "tasks": ["spec.md", "contracts.md", "plan.md"],
             "implement": ["risk-assessment.md", "spec.md", "contracts.md", "plan.md", "tasks.md"],
+            "preflight-evidence": ["risk-assessment.md", "spec.md", "research.md", "contracts.md", "plan.md", "tasks.md"],
         }
         for name in critical_inputs.get(activity, []):
             inputs.append(f"{feature_path}/{name}")
@@ -384,9 +436,10 @@ def build_activity_contract(
 
     expected_output = _result_schema(activity)
 
+    contract_version = 2 if state.schemaVersion == 3 else ACTIVITY_CONTRACT_SCHEMA_VERSION
     return ActivityContract(
-        schemaVersion=ACTIVITY_CONTRACT_SCHEMA_VERSION,
-        contractId=f"{state.issueId}:{state.profile}:{activity}:v1",
+        schemaVersion=contract_version,
+        contractId=f"{state.issueId}:{state.profile}:{activity}:v{contract_version}",
         issueId=state.issueId,
         profile=state.profile,
         activity=activity,

devflow_cli/core/adaptive_runner.py

@@ -17,6 +17,7 @@ from devflow_cli.core.activity_contracts import (
     contract_is_reopened_plan,
     document_artifact_name,
     parse_activity_result,
+    validate_preflight_evidence,
     write_activity_contract,
 )
 from devflow_cli.core.adaptive_workflow import (
@@ -90,6 +91,15 @@ def run_current_activity(
                 reopened=is_reopened_activity(feature_dir, state.currentActivity),
                 preflight_evidence=(feature_dir / "preflight-evidence.md").is_file(),
             )
+            if state.currentActivity == "implement" and state.schemaVersion == 3:
+                upstream = [
+                    feature_dir / Path(item).name
+                    for item in contract.inputs
+                    if item.endswith(".md") and not item.endswith("preflight-evidence.md")
+                ]
+                validate_preflight_evidence(
+                    feature_dir / "preflight-evidence.md", newer_than=upstream
+                )
         except ValueError as exc:
             return AdaptiveRunOutcome(
                 "unsupported-activity", state.currentActivity, state.currentActivity, str(exc)
@@ -109,9 +119,14 @@ def run_current_activity(
         detail = execution.stderr.strip() or f"code de sortie {execution.returncode}"
         if execution.timedOut:
             detail = f"timeout agent ({detail})"
-        return AdaptiveRunOutcome(
-            "agent-failed", contract.activity, contract.activity, detail
+        reason = (
+            "agent-failed-after-mutation"
+            if execution.observedChangedFiles
+            else "agent-failed"
         )
+        if execution.observedChangedFiles:
+            detail += f"; mutations observees : {len(set(execution.observedChangedFiles))} fichier(s)"
+        return AdaptiveRunOutcome(reason, contract.activity, contract.activity, detail)
 
     try:
         raw_payload = json.loads(execution.output)
@@ -207,9 +222,8 @@ def run_current_activity(
         )
         if artifact_name == "preflight-evidence.md":
             try:
-                if not (feature_dir / artifact_name).read_text(encoding="utf-8").strip():
-                    raise OSError("artefact vide")
-            except OSError as exc:
+                validate_preflight_evidence(feature_dir / artifact_name)
+            except ValueError as exc:
                 return AdaptiveRunOutcome(
                     "invalid-artifact", contract.activity, contract.activity, str(exc), result
                 )