devflow-cli 8.5.1__py3-none-any.whl → 9.0.1__py3-none-any.whl

devflow_cli/__init__.py

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

devflow_cli/commands/adaptive.py

@@ -76,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,
@@ -196,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)
@@ -483,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,
@@ -533,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,
@@ -721,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()
@@ -1336,7 +1351,7 @@ def _operational_status(
 ) -> dict:
     result_file, result = _latest_activity_result(feature_dir, state.currentActivity)
     blockers = result.get("blockers", []) if isinstance(result, dict) else []
-    risks = latest_remaining_risks(feature_dir, state.activities)
+    risks = latest_remaining_risks(feature_dir, state)
     if not isinstance(blockers, list):
         blockers = []
     stale: set[str] = set()
@@ -1610,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:
@@ -1638,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": (
@@ -1677,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)
     ):
@@ -1688,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": (
@@ -1724,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
@@ -1782,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/feature.py

@@ -58,6 +58,27 @@ def _ignore_agent_traces(feature_dir) -> None:
     )
 
 
+LOCK_IGNORE_RULES = (".workflow-state.lock", ".agent-run.lock", ".feature-lock")
+
+
+def _ignore_cli_locks(specs_root) -> None:
+    """Exclut du depot les verrous de la CLI, a toute profondeur sous les specs."""
+    gitignore = specs_root / ".gitignore"
+    content = gitignore.read_text(encoding="utf-8") if gitignore.is_file() else ""
+    present = content.splitlines()
+    missing = [rule for rule in LOCK_IGNORE_RULES if rule not in present]
+    if not missing:
+        return
+    prefix = "" if not content or content.endswith("\n") else "\n"
+    gitignore.write_text(
+        content
+        + prefix
+        + "# Verrous de la CLI devflow : fichiers d'execution, jamais suivis.\n"
+        + "".join(f"{rule}\n" for rule in missing),
+        encoding="utf-8",
+    )
+
+
 def feature(
     issue_id: str = typer.Argument(..., help="Identifiant de l'issue (ex: KS-123)"),
     short_name: Optional[str] = typer.Option(None, "--short-name", help="Nom court pour le repertoire (ex: user-auth)"),
@@ -107,6 +128,7 @@ def feature(
         feature_dir.mkdir(parents=True)
         ok(f"Dossier {feature_dir} cree")
     _ignore_agent_traces(feature_dir)
+    _ignore_cli_locks(specs_root)
 
     console.print()
     console.print(f"Feature [bold]{issue_id}[/bold] initialisee :")

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(),