devflow-cli 7.2.0__py3-none-any.whl → 8.0.0__py3-none-any.whl

devflow_cli/__init__.py

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

devflow_cli/commands/adaptive.py

@@ -25,6 +25,10 @@ from devflow_cli.core.adaptive_workflow import (
     write_adaptive_state,
 )
 from devflow_cli.core.assessment import read_assessment
+from devflow_cli.core.activity_base import (
+    enter_current_activity,
+    files_since_activity_base,
+)
 from devflow_cli.core.activity_contracts import (
     build_activity_contract,
     NEED_STATEMENT,
@@ -51,7 +55,6 @@ 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,
     discard_attempt,
     is_reopened_activity,
     reopen_activity,
@@ -77,6 +80,9 @@ app = typer.Typer(help="Machine d'etat des parcours adaptatifs")
 
 LEGACY_SCHEMA_EXIT_CODE = 1
 
+# Refus avant tout agent : base inutilisable (branche changee, historique reecrit).
+BASE_REFUSALS = frozenset({"base-history-rewritten", "base-branch-changed"})
+
 RESULT_VALIDATED_ACTIVITIES = frozenset({
     "prepare",
     "risk-assessment",
@@ -167,7 +173,10 @@ def start(feature: str = typer.Argument(..., help="ID ou dossier de la feature")
             assessment = _assessment(feature_dir)
             validate_need_statement(feature_dir / NEED_STATEMENT)
             state = create_adaptive_workflow(assessment.to_dict())
-        except ValueError as exc:
+            enter_current_activity(
+                state, project_root_for_feature(feature_dir), feature_dir
+            )
+        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)
@@ -221,7 +230,10 @@ def complete(
                 validate_preflight_evidence(feature_dir / "preflight-evidence.md")
             ensure_fresh_devflow_evidence(feature_dir, state, activity)
             complete_activity(state, activity)
-        except ValueError as exc:
+            enter_current_activity(
+                state, project_root_for_feature(feature_dir), feature_dir
+            )
+        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
@@ -284,11 +296,15 @@ def contract(
                 state,
                 assessment.to_dict(),
                 feature_path,
-                carried_changed_files(feature_dir, state.currentActivity),
                 reopened=is_reopened_activity(feature_dir, state.currentActivity),
                 preflight_evidence=(feature_dir / "preflight-evidence.md").is_file(),
+                files_since_base=(
+                    files_since_activity_base(feature_dir, state)
+                    if state.activityBase is not None
+                    else ()
+                ),
             )
-        except ValueError as exc:
+        except (OSError, ValueError) as exc:
             fail(f"Impossible de generer le contrat : {exc}")
             raise typer.Exit(int(ExitCode.INVALID_CONTRACT)) from exc
         output_file = feature_dir / "activity-contract.json"
@@ -457,12 +473,14 @@ def run_adaptive(
             _print_execution_json(
                 current_state.issueId, outcome.activity, True, outcome.reason,
                 outcome.detail, outcome.nextActivity, ExitCode.OK,
+                warnings=outcome.warnings,
             )
         else:
             ok(
                 f"Activite '{outcome.activity}' validee. "
                 f"Prochaine : {outcome.nextActivity}"
             )
+            _print_warnings(outcome.warnings)
         return
     safe_refresh_worklog(feature_dir)
     exit_code = exit_code_for_run_reason(outcome.reason)
@@ -470,9 +488,14 @@ def run_adaptive(
         _print_execution_json(
             current_state.issueId, outcome.activity, False, outcome.reason,
             outcome.detail, outcome.nextActivity, exit_code,
+            warnings=outcome.warnings,
         )
+    elif outcome.reason in BASE_REFUSALS:
+        fail(outcome.detail)
+        console.print(f"  Suite : devflow adaptive status {current_state.issueId}")
     else:
         fail(outcome.detail or outcome.reason)
+        _print_warnings(outcome.warnings)
         console.print(
             f"  Activite '{outcome.activity}' non validee : {outcome.reason}"
         )
@@ -591,12 +614,17 @@ def reconcile_adaptive(
             f"Activite '{outcome.activity}' reconciliee. "
             f"Prochaine : {outcome.nextActivity}"
         )
+        _print_warnings(outcome.warnings)
         return
     safe_refresh_worklog(feature_dir)
-    fail(
-        f"Reconciliation de '{outcome.activity}' refusee : {outcome.reason}"
-        + (f" ({outcome.detail})" if outcome.detail else "")
-    )
+    if outcome.reason in BASE_REFUSALS:
+        fail(outcome.detail)
+    else:
+        fail(
+            f"Reconciliation de '{outcome.activity}' refusee : {outcome.reason}"
+            + (f" ({outcome.detail})" if outcome.detail else "")
+        )
+        _print_warnings(outcome.warnings)
     console.print(f"  Suite : devflow adaptive status {state.issueId}")
     if outcome.reason == "reconcile-refused":
         console.print(
@@ -771,6 +799,9 @@ def reopen(
             entry = reopen_activity(
                 feature_dir, state, activity, reason, author=author
             )
+            enter_current_activity(
+                state, project_root_for_feature(feature_dir), feature_dir
+            )
         except (OSError, ValueError) as exc:
             fail(str(exc))
             console.print(f"  Suite : devflow adaptive status {state.issueId}")
@@ -806,9 +837,12 @@ def discard_attempt_command(
     )
     if entry["discardedFiles"]:
         warn(
-            "Changements laisses dans le working tree, non reportes : "
-            + ", ".join(entry["discardedFiles"])
+            "Fichiers modifies depuis le debut de l'activite "
+            f"'{entry['activity']}', comptes dans le lot a la relance ; remise en "
+            "etat a la charge du superviseur : " + ", ".join(entry["discardedFiles"])
         )
+    if entry.get("observationError"):
+        warn(f"Fichiers depuis la base non calcules : {entry['observationError']}")
 
 
 def _execute_local_verification(
@@ -851,6 +885,7 @@ def _execute_local_verification(
 def _print_execution_json(
     issue_id: str, activity: str | None, passed: bool, reason: str,
     detail: str, next_activity: str | None, exit_code: ExitCode,
+    *, warnings: tuple[str, ...] = (),
 ) -> None:
     typer.echo(json.dumps({
         "schemaVersion": 1,
@@ -861,9 +896,16 @@ def _print_execution_json(
         "detail": detail,
         "nextActivity": next_activity,
         "exitCode": int(exit_code),
+        "warnings": list(warnings),
     }, ensure_ascii=False))
 
 
+def _print_warnings(warnings: tuple[str, ...]) -> None:
+    """Ecart de declaration : avertissement seul, sans effet sur le code de sortie."""
+    for message in warnings:
+        warn(message)
+
+
 def _utc_now() -> str:
     return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 
@@ -1155,13 +1197,6 @@ def _print_run_recovery(
         console.print("    Ne relancez pas automatiquement l'agent : reconciliez d'abord les changements partiels.")
         console.print(f"    devflow adaptive reconcile {issue_id}")
         return
-    if reason == "stale-attempt":
-        console.print("    git status --short  # inspecter les changements de la tentative")
-        console.print(
-            "    Restaurez les fichiers de la tentative, ou abandonnez-la explicitement :"
-        )
-        console.print(f"    devflow adaptive discard-attempt {issue_id} --reason MOTIF")
-        return
     if reason == "inputs-changed-during-activity":
         console.print(
             "    Les entrees du besoin ont change pendant l'execution. "

devflow_cli/core/activity_base.py

@@ -0,0 +1,408 @@
+"""Base d'une activite : reference stable des fichiers observes (KKS-508).
+
+La CLI enregistre une base a l'entree dans une activite ; les fichiers de
+l'activite sont tout ce qui differe de cette base. L'observation fait foi :
+la declaration de l'agent ne produit qu'un avertissement.
+"""
+
+from __future__ import annotations
+
+import copy
+import re
+import subprocess
+from dataclasses import dataclass
+from datetime import datetime, timezone
+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.worktree_snapshot import (
+    _fingerprint,
+    _git_paths,
+    _git_text,
+    _subtree,
+    snapshot_worktree,
+    untracked_paths,
+)
+from devflow_cli.utils.paths import project_root_for_feature
+
+if TYPE_CHECKING:
+    from devflow_cli.core.activity_contracts import ActivityContract, ActivityResult
+    from devflow_cli.core.adaptive_workflow import AdaptiveWorkflowState
+
+
+HEAD_PATTERN = re.compile(r"^(?:[0-9a-f]{40}|[0-9a-f]{64})?$")
+FINGERPRINT_PATTERN = re.compile(r"^(?:file:[0-7]+:[0-9a-f]{64}|symlink:[0-7]+:.*|deleted)$")
+BASE_ACTIVITIES = frozenset({
+    "prepare", "risk-assessment", "spec", "contracts", "plan", "tasks",
+    "preflight-evidence", "implement", "verify", "review", "rollback-check",
+})
+BASE_KEYS = frozenset({"activity", "recordedAt", "head", "branch", "files"})
+
+# Seule definition des fichiers ecrits par la CLI dans le dossier de la feature (S4).
+RUNTIME_FILE_NAMES = frozenset({
+    "workflow-state.json", ".workflow-state.lock", "activity-contract.json",
+    "agent-execution.json", "worklog.md", "reopen-log.json", "attempt-discard-log.json",
+    "reconcile-log.json", "validation-approvals.json", "waivers.json", "verification.json",
+})
+RUNTIME_FILE_SUFFIXES = ("-result.json", "-attempt.json", ".raw.txt")
+RUNTIME_DIRECTORIES = ("attempts", "evidence")
+
+OBSERVATION_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "required": ["baseRecordedAt", "baseHead", "observedAt", "head"],
+    "properties": {
+        "baseRecordedAt": {"type": "string", "minLength": 1},
+        "baseHead": {"type": "string", "pattern": "^(?:[0-9a-f]{40}|[0-9a-f]{64})?$"},
+        "observedAt": {"type": "string", "minLength": 1},
+        "head": {"type": "string", "pattern": "^(?:[0-9a-f]{40}|[0-9a-f]{64})?$"},
+        "declaredChangedFiles": {
+            "type": "array", "items": {"type": "string", "minLength": 1}
+        },
+        "warning": {"type": "string", "minLength": 1},
+    },
+    "additionalProperties": False,
+    "dependentRequired": {
+        "declaredChangedFiles": ["warning"],
+        "warning": ["declaredChangedFiles"],
+    },
+}
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _is_runtime_name(name: str) -> bool:
+    return name in RUNTIME_FILE_NAMES or name.endswith(RUNTIME_FILE_SUFFIXES)
+
+
+def is_runtime_file(path: str, feature_path: str | None) -> bool:
+    """Vrai pour un fichier ecrit par la CLI dans le dossier de la feature (S4)."""
+    if not feature_path:
+        return False
+    prefix = feature_path.rstrip("/") + "/"
+    if not path.startswith(prefix):
+        return False
+    parts = path[len(prefix):].split("/")
+    if parts[0] in RUNTIME_DIRECTORIES:
+        return True
+    if len(parts) != 1:
+        return False
+    name = parts[0]
+    if _is_runtime_name(name):
+        return True
+    # Temporaire d'ecriture atomique « .<nom>.<aleatoire>.tmp » laisse par une interruption.
+    if name.startswith(".") and name.endswith(".tmp"):
+        inner = name[1:-len(".tmp")]
+        if "." in inner and _is_runtime_name(inner.rsplit(".", 1)[0]):
+            return True
+    return False
+
+
+def _check_path(path: object, feature_path: str | None) -> str:
+    if not isinstance(path, str) or not path:
+        raise ValueError("base invalide : chemin vide ou non textuel")
+    if path.startswith("/") or "\\" in path or ".." in path.split("/"):
+        raise ValueError(f"base invalide : chemin non portable {path!r}")
+    if is_runtime_file(path, feature_path):
+        raise ValueError(f"base invalide : fichier d'execution devflow {path!r}")
+    return path
+
+
+@dataclass(frozen=True)
+class ActivityBase:
+    activity: str
+    recordedAt: str
+    head: str
+    branch: str
+    files: dict[str, str]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "activity": self.activity,
+            "recordedAt": self.recordedAt,
+            "head": self.head,
+            "branch": self.branch,
+            "files": dict(sorted(self.files.items())),
+        }
+
+    @classmethod
+    def from_dict(
+        cls, payload: object, *, feature_path: str | None = None
+    ) -> "ActivityBase":
+        """Valide une base lue ; ``feature_path`` permet de refuser un chemin S4."""
+        if not isinstance(payload, dict) or set(payload) != BASE_KEYS:
+            raise ValueError("base invalide : cles manquantes ou inattendues")
+        activity = payload["activity"]
+        recorded_at = payload["recordedAt"]
+        head = payload["head"]
+        branch = payload["branch"]
+        files = payload["files"]
+        if activity not in BASE_ACTIVITIES:
+            raise ValueError(f"base invalide : activite {activity!r}")
+        if not isinstance(recorded_at, str) or not recorded_at:
+            raise ValueError("base invalide : recordedAt")
+        if not isinstance(head, str) or not HEAD_PATTERN.fullmatch(head):
+            raise ValueError("base invalide : head")
+        if not isinstance(branch, str):
+            raise ValueError("base invalide : branch")
+        if not isinstance(files, dict):
+            raise ValueError("base invalide : files")
+        checked: dict[str, str] = {}
+        for path, fingerprint in files.items():
+            _check_path(path, feature_path)
+            if not isinstance(fingerprint, str) or not FINGERPRINT_PATTERN.fullmatch(fingerprint):
+                raise ValueError(f"base invalide : empreinte de {path!r}")
+            checked[path] = fingerprint
+        return cls(activity, recorded_at, head, branch, checked)
+
+
+class BaseObservationError(ValueError):
+    """Les fichiers depuis la base ne sont pas calculables : branche ou historique."""
+
+    def __init__(self, reason: str, message: str) -> None:
+        self.reason = reason
+        super().__init__(message)
+
+
+@dataclass(frozen=True)
+class ActivityObservation:
+    base: ActivityBase
+    observedAt: str
+    head: str
+    sinceBase: dict[str, str]
+    duringExecution: tuple[str, ...]
+
+
+def feature_path_for(project_root: Path, feature_dir: Path) -> str | None:
+    """Chemin POSIX du dossier de la feature relatif au projet, ou None."""
+    return _subtree(project_root, feature_dir)
+
+
+def capture_base(project_root: Path, feature_dir: Path, activity: str) -> ActivityBase:
+    """Capture HEAD, branche et empreintes des fichiers modifies, hors S4."""
+    snapshot = snapshot_worktree(project_root, feature_dir)
+    feature_path = feature_path_for(project_root, feature_dir)
+    return ActivityBase(
+        activity=activity,
+        recordedAt=_now_iso(),
+        head=snapshot.head,
+        branch=snapshot.branch,
+        files={
+            path: fingerprint
+            for path, fingerprint in snapshot.files.items()
+            if not is_runtime_file(path, feature_path)
+        },
+    )
+
+
+def files_since_base(
+    project_root: Path, feature_dir: Path, base: ActivityBase, *, issue_id: str
+) -> dict[str, str]:
+    """Fichiers qui different de la base (CT-06), avec leur empreinte actuelle."""
+    return _observe_since(project_root, feature_dir, base, issue_id)[2]
+
+
+def _observe_since(
+    project_root: Path, feature_dir: Path, base: ActivityBase, issue_id: str
+) -> tuple[str, str, dict[str, str]]:
+    if not HEAD_PATTERN.fullmatch(base.head):
+        raise ValueError(f"base invalide : head {base.head!r}")
+    head = _git_text(project_root, ["rev-parse", "--verify", "HEAD"], allow_failure=True)
+    branch = _git_text(project_root, ["branch", "--show-current"], allow_failure=True)
+    if base.branch != branch:
+        base_branch = base.branch or "(HEAD detache)"
+        current = branch or "(HEAD detache)"
+        raise BaseObservationError(
+            "base-branch-changed",
+            f"base de '{base.activity}' prise sur la branche '{base_branch}', "
+            f"branche courante '{current}' ; revenir sur '{base_branch}' "
+            f"(git switch {base_branch}) puis relancer devflow adaptive run {issue_id}",
+        )
+    if base.head and base.head != head:
+        code, stderr = _git_status(
+            project_root, ["merge-base", "--is-ancestor", base.head, "HEAD"]
+        )
+        if code == 1:
+            raise BaseObservationError(
+                "base-history-rewritten",
+                f"base de '{base.activity}' : le commit {base.head} n'est plus un "
+                f"ancetre de HEAD ({head}) : rebase, amend ou reset depuis l'entree dans "
+                f"'{base.activity}' ; retablir un historique qui contient {base.head} "
+                f"(voir git reflog), puis relancer devflow adaptive run {issue_id} ; "
+                "sinon terminer ou abandonner le parcours",
+            )
+        if code != 0:
+            raise ValueError(stderr or "git merge-base --is-ancestor a echoue")
+    if base.head:
+        tracked = _git_paths(
+            project_root, ["diff", "--no-renames", "--name-only", "-z", base.head, "--"]
+        )
+    else:
+        tracked = _git_paths(project_root, ["ls-files", "-z"])
+    candidates = set(tracked) | set(untracked_paths(project_root, feature_dir)) | set(base.files)
+    feature_path = feature_path_for(project_root, feature_dir)
+    since: dict[str, str] = {}
+    for path in sorted(candidates):
+        if is_runtime_file(path, feature_path):
+            continue
+        current_fingerprint = _fingerprint(project_root / path)
+        if base.files.get(path) != current_fingerprint:
+            since[path] = current_fingerprint
+    return head, branch, since
+
+
+def _git_status(project_root: Path, args: list[str]) -> tuple[int, str]:
+    result = subprocess.run(
+        ["git", *args],
+        cwd=project_root,
+        capture_output=True,
+        text=True,
+        timeout=30,
+        env=environment_without_linear_key(),
+    )
+    return result.returncode, result.stderr.strip()
+
+
+def current_base(state: "AdaptiveWorkflowState", feature_dir: Path) -> ActivityBase:
+    """Base de l'activite courante, validee."""
+    if state.activityBase is None:
+        raise ValueError("aucune base pour l'activite courante")
+    project_root = project_root_for_feature(feature_dir)
+    return ActivityBase.from_dict(
+        state.activityBase, feature_path=feature_path_for(project_root, feature_dir)
+    )
+
+
+def files_since_activity_base(
+    feature_dir: Path, state: "AdaptiveWorkflowState"
+) -> dict[str, str]:
+    """Fichiers depuis la base de l'activite courante."""
+    return files_since_base(
+        project_root_for_feature(feature_dir),
+        feature_dir,
+        current_base(state, feature_dir),
+        issue_id=state.issueId,
+    )
+
+
+def observe_activity(
+    feature_dir: Path,
+    state: "AdaptiveWorkflowState",
+    *,
+    during_execution: Iterable[str] = (),
+) -> ActivityObservation:
+    """Seule construction de l'observation d'une activite (run, reconcile, revue)."""
+    base = current_base(state, feature_dir)
+    project_root = project_root_for_feature(feature_dir)
+    head, _branch, since = _observe_since(project_root, feature_dir, base, state.issueId)
+    # Liste brute, sans filtre S4 : la CLI n'ecrit rien dans le dossier de la
+    # feature pendant l'agent, tout fichier S4 modifie vient donc de l'agent.
+    during = tuple(sorted(set(during_execution)))
+    return ActivityObservation(base, _now_iso(), head, since, during)
+
+
+def observe_attempt(
+    feature_dir: Path, state: "AdaptiveWorkflowState"
+) -> tuple[str, str, dict[str, str]]:
+    """HEAD, branche et fichiers depuis la base, pour une fiche de tentative."""
+    project_root = project_root_for_feature(feature_dir)
+    return _observe_since(
+        project_root, feature_dir, current_base(state, feature_dir), state.issueId
+    )
+
+
+def enter_current_activity(
+    state: "AdaptiveWorkflowState", project_root: Path, feature_dir: Path
+) -> None:
+    """Pose la base de l'activite courante (S3) ; une erreur de capture se propage."""
+    activity = state.currentActivity
+    if activity == "done":
+        state.activityBase = None
+        return
+    if activity == "implement":
+        if state.implementBase is None:
+            state.implementBase = capture_base(project_root, feature_dir, "implement").to_dict()
+        state.activityBase = copy.deepcopy(state.implementBase)
+        return
+    state.activityBase = capture_base(project_root, feature_dir, activity).to_dict()
+
+
+def validate_state_bases(
+    state: "AdaptiveWorkflowState", *, feature_path: str | None = None
+) -> None:
+    """Invariants I1 a I6 des bases d'un etat adaptatif (CT-02)."""
+    activity_base = state.activityBase
+    implement_base = state.implementBase
+    if (activity_base is None) != (state.currentActivity == "done"):
+        raise ValueError("activityBase absente hors de done, ou presente dans done")
+    for base in (activity_base, implement_base):
+        if base is not None:
+            ActivityBase.from_dict(base, feature_path=feature_path)
+    if activity_base is not None and activity_base["activity"] != state.currentActivity:
+        raise ValueError("activityBase ne porte pas sur l'activite courante")
+    if state.currentActivity == "implement" and activity_base != implement_base:
+        raise ValueError("activityBase differe de implementBase pendant implement")
+    if implement_base is not None and implement_base["activity"] != "implement":
+        raise ValueError("implementBase ne porte pas sur implement")
+    if (
+        "implement" in state.completedActivities or state.currentActivity == "implement"
+    ) and implement_base is None:
+        raise ValueError("implementBase absente alors qu'implement a ete atteint")
+
+
+def declaration_warning(declared: list[str], observed: list[str]) -> str:
+    """Avertissement d'ecart entre declaration et observation (S9), ou ''."""
+    if declared == observed:
+        return ""
+    parts = ["changedFiles declare differe de l'observation depuis la base"]
+    undeclared = sorted(set(observed) - set(declared))
+    unobserved = sorted(set(declared) - set(observed))
+    if undeclared:
+        parts.append("non declares : " + ", ".join(undeclared))
+    if unobserved:
+        parts.append("declares non observes : " + ", ".join(unobserved))
+    parts.append("la liste observee est enregistree")
+    return " ; ".join(parts)
+
+
+def recorded_observation(
+    observation: ActivityObservation, declared: list[str]
+) -> dict[str, Any]:
+    """Bloc ``observation`` ecrit par la CLI seule dans le resultat enregistre."""
+    observed = sorted(observation.sinceBase)
+    block: dict[str, Any] = {
+        "baseRecordedAt": observation.base.recordedAt,
+        "baseHead": observation.base.head,
+        "observedAt": observation.observedAt,
+        "head": observation.head,
+    }
+    warning = declaration_warning(declared, observed)
+    if warning:
+        block["declaredChangedFiles"] = list(declared)
+        block["warning"] = warning
+    return block
+
+
+def parse_recorded_result(
+    payload: object, contract: "ActivityContract"
+) -> tuple["ActivityResult", dict[str, Any]]:
+    """Relit un resultat enregistre par la CLI : exige et retire ``observation``."""
+    from devflow_cli.core.activity_contracts import parse_activity_result
+    from devflow_cli.core.contract_schemas import (
+        ContractSchemaError,
+        validate_contract_payload,
+    )
+
+    if not isinstance(payload, dict) or "observation" not in payload:
+        raise ValueError("resultat enregistre sans bloc observation")
+    observation = payload["observation"]
+    try:
+        validate_contract_payload(
+            "activity-result", observation, schema=OBSERVATION_SCHEMA
+        )
+    except ContractSchemaError as exc:
+        raise ValueError(f"bloc observation invalide : {exc}") from exc
+    rest = {key: value for key, value in payload.items() if key != "observation"}
+    return parse_activity_result(rest, contract), dict(observation)

devflow_cli/core/activity_contracts.py

@@ -9,7 +9,7 @@ import re
 import unicodedata
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
-from typing import Any, Literal
+from typing import Any, Iterable, Literal
 
 from devflow_cli.core.adaptive_workflow import (
     ADAPTIVE_STATE_SCHEMA_VERSION,
@@ -204,9 +204,10 @@ def build_activity_contract(
     state: AdaptiveWorkflowState,
     assessment: dict[str, Any],
     feature_path: str,
-    carried_changed_files: list[str] | None = None,
+    *,
     reopened: bool = False,
     preflight_evidence: bool = False,
+    files_since_base: Iterable[str] = (),
 ) -> ActivityContract:
     """Construit le contrat de l'activite courante sans notion d'agent."""
     activity = state.currentActivity
@@ -253,11 +254,6 @@ def build_activity_contract(
             "Produire un artefact complet sans placeholder ni section vide.",
             "Declarer uniquement cet artefact dans changedFiles.",
         ]
-        if carried_changed_files:
-            constraints.append(
-                "Une tentative precedente a deja modifie cet artefact : inspecter son "
-                "contenu avant de le completer, puis declarer l'artefact dans changedFiles."
-            )
         rules = ARTIFACT_RULES.get(activity, {})
         for alternatives in rules.get("required_section_groups", []):
             constraints.append(
@@ -408,19 +404,6 @@ def build_activity_contract(
             "Les fichiers modifies sont listes dans le resultat.",
             "Les risques ou blocages restants sont explicites.",
         ]
-        if carried_changed_files:
-            carried = sorted(set(carried_changed_files))
-            constraints.extend(
-                [
-                    "Des changements d'implementation sont deja presents dans le working tree : cette execution reprend leur perimetre.",
-                    "Inspecter les changements de la tentative precedente avant de les corriger.",
-                    "changedFiles doit contenir le perimetre cumule de l'implementation : "
-                    + ", ".join(carried),
-                ]
-            )
-            completion_criteria.append(
-                "Les changements precedents et ceux de la remediation forment une implementation coherente."
-            )
         required_evidence: list[str] = []
     else:
         allowed_actions = ["read", "execute"]
@@ -437,6 +420,17 @@ def build_activity_contract(
         ]
         required_evidence = gate_evidence(state, activity)
 
+    already_changed = sorted(set(files_since_base))
+    if activity in DOCUMENT_ACTIVITIES:
+        artifact = f"{feature_path}/{document_artifact_name(activity, reopened=reopened)}"
+        already_changed = [artifact] if artifact in already_changed else []
+    if already_changed:
+        constraints.append(
+            "Fichiers deja modifies depuis le debut de l'activite (comptes dans son "
+            "resultat) : " + ", ".join(already_changed)
+            + " ; les inspecter avant de poursuivre."
+        )
+
     inputs = [
         f"{feature_path}/{NEED_STATEMENT}",
         f"{feature_path}/assessment.json",