devflow-cli 8.2.0__py3-none-any.whl → 8.4.1__py3-none-any.whl

devflow_cli/__init__.py

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

devflow_cli/commands/adaptive.py

@@ -27,9 +27,11 @@ from devflow_cli.core.adaptive_workflow import (
 from devflow_cli.core.assessment import read_assessment
 from devflow_cli.core.activity_base import (
     enter_current_activity,
+    feature_path_for,
     files_since_activity_base,
 )
 from devflow_cli.core.activity_contracts import (
+    DOCUMENT_ARTIFACTS,
     build_activity_contract,
     NEED_STATEMENT,
     render_contract_prompt,
@@ -39,6 +41,7 @@ from devflow_cli.core.activity_contracts import (
 )
 from devflow_cli.core.adaptive_runner import (
     MANUAL_RECONCILIATION_ACTIVITIES,
+    AdaptiveRunOutcome,
     AgentActivityExecution,
     reconcile_current_activity,
     record_human_review,
@@ -510,12 +513,17 @@ def run_adaptive(
         _missing_output_recovery(
             feature_dir, current_state.issueId, outcome.activity, agent,
             execution.stdout,
+            mutated=outcome.reason == "agent-failed-after-mutation",
         )
         if outcome.reason in {"agent-failed", "agent-failed-after-mutation"}
         and execution is not None
         and execution.final_output_diagnostic in MISSING_STRUCTURED_OUTPUT_DIAGNOSTICS
         else None
     )
+    if outcome.reason == "preflight-evidence-stale":
+        recovery = _stale_preflight_recovery(current_state)
+    if outcome.reason == "artifact-files-mismatch":
+        recovery = _artifact_mismatch_recovery(current_state, outcome, agent)
     if json_output:
         _print_execution_json(
             current_state.issueId, outcome.activity, False, outcome.reason,
@@ -697,7 +705,17 @@ def reconcile_adaptive(
         console.print("  Suite : attendez la fin de l'activite en cours, puis relancez.")
         raise typer.Exit(int(exit_code_for_run_reason(outcome.reason)))
     console.print(f"  Suite : devflow adaptive status {state.issueId}")
-    if outcome.reason == "reconcile-refused":
+    if outcome.reason == "artifact-files-mismatch":
+        console.print("  Reprise guidee :")
+        _print_recovery_steps(
+            _artifact_mismatch_recovery(
+                state, outcome, _attempt_agent(feature_dir, outcome.activity)
+            )
+        )
+    if (
+        outcome.reason == "reconcile-refused"
+        and activity_attempt_file(feature_dir, outcome.activity).is_file()
+    ):
         console.print(
             f"  Abandon audite : devflow adaptive discard-attempt {state.issueId} --reason MOTIF"
         )
@@ -915,16 +933,45 @@ def discard_attempt_command(
         f"Tentative '{entry['activity']}' abandonnee (audit #{entry['sequence']}, "
         f"archive : {entry['archivePath']})."
     )
-    if entry["discardedFiles"]:
+    discarded = list(entry["discardedFiles"])
+    inputs = (
+        [
+            path for path in discarded
+            if _is_need_input(path, feature_path_for(
+                project_root_for_feature(feature_dir), feature_dir
+            ))
+        ]
+        if entry["activity"] in DOCUMENT_ARTIFACTS
+        else []
+    )
+    others = [path for path in discarded if path not in inputs]
+    if inputs:
+        warn(
+            "Entrees du besoin modifiees depuis le debut de l'activite "
+            f"'{entry['activity']}' : " + ", ".join(inputs) + " ; elles ne sont plus "
+            "imputees a un agent apres cet abandon et seront acceptees comme amendees "
+            "a la relance : a verifier"
+        )
+    if others:
         warn(
             "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"])
+            "etat a la charge du superviseur : " + ", ".join(others)
         )
     if entry.get("observationError"):
         warn(f"Fichiers depuis la base non calcules : {entry['observationError']}")
 
 
+def _is_need_input(path: str, feature_path: str | None) -> bool:
+    """Vrai pour need.md ou issue-*.md directement sous le dossier de la feature."""
+    if feature_path is None:
+        return False
+    parent, _, name = path.rpartition("/")
+    return parent == feature_path and (
+        name == NEED_STATEMENT or (name.startswith("issue-") and name.endswith(".md"))
+    )
+
+
 def _execute_local_verification(
     feature_dir: Path, project_root: Path, issue_id: str, *,
     refresh: bool = False, json_output: bool = False,
@@ -937,7 +984,8 @@ def _execute_local_verification(
         sync_activity_status(issue_id, "verify", stream)
     outcome = run_automatic_verification(feature_dir, project_root, refresh=refresh)
     recovery = (
-        None if outcome.passed else _verify_recovery(feature_dir, issue_id, outcome)
+        None if outcome.passed
+        else _verify_recovery(feature_dir, issue_id, outcome, refresh=refresh)
     )
     if json_output:
         _print_execution_json(
@@ -954,6 +1002,8 @@ def _execute_local_verification(
             ok(f"Preuves de verify rafraichies. Activite courante : {outcome.nextActivity}")
         else:
             ok(f"Preuves generees et validees. Prochaine : {outcome.nextActivity}")
+        if outcome.detail:
+            console.print(f"  Motif : {outcome.detail}", markup=False, soft_wrap=True)
         return
     fail(outcome.detail or outcome.reason)
     console.print(f"  Verification automatique refusee : {outcome.reason}")
@@ -976,17 +1026,20 @@ PLANNED_PREFIXES = {"PREP-": "prepare", "PLAN-": "plan"}
 
 
 def _verify_recovery(
-    feature_dir: Path, issue_id: str, outcome: AutomaticVerificationOutcome
+    feature_dir: Path, issue_id: str, outcome: AutomaticVerificationOutcome,
+    *, refresh: bool = False,
 ) -> dict:
     """Reprise guidee d'un refus de verify, par motif, sans heuristique (B2).
 
     Approbation manquante : chaque approve-command puis verify. Executable introuvable
-    (code 127) : corriger l'environnement puis verify. Echec d'un controle : deux voies,
-    le code (reopen implement) ou la validation (reopen de l'activite qui l'a inscrite).
+    (code 127) : corriger l'environnement puis verify. Echec d'un controle : trois voies,
+    le code (reopen implement), la validation (reopen de l'activite qui l'a inscrite) ou
+    un echec passager (relancer verify). Apres un verify --refresh refuse, toutes les
+    commandes verify portent --refresh.
     """
     issue = shlex.quote(issue_id)
     verify_command = {
-        "command": f"devflow adaptive verify {issue}",
+        "command": f"devflow adaptive verify {issue}" + (" --refresh" if refresh else ""),
         "purpose": "relancer la verification",
     }
     state = read_adaptive_state(feature_dir / "workflow-state.json")
@@ -1064,6 +1117,13 @@ def _verify_recovery(
             "command": f"devflow adaptive reopen {issue} {origin} --reason {reason_text}",
             "purpose": f"voie 2 : la validation {names}, inscrite par {origin}, est en cause",
         })
+    commands.append({
+        "command": verify_command["command"],
+        "purpose": (
+            "voie 3 : echec passager (reseau, conteneur, service externe), "
+            "relancer la verification"
+        ),
+    })
     return {
         "kind": "check-failed",
         "summary": (
@@ -1248,8 +1308,10 @@ def _operational_status(
     risks = _remaining_risks(feature_dir)
     if not isinstance(blockers, list):
         blockers = []
-    stale = set(stale_devflow_evidence(feature_dir, state))
-    stale.update(stale_review_evidence(feature_dir, state))
+    stale: set[str] = set()
+    if state.status != "completed":  # aucune gate ne consulte la peremption apres done
+        stale.update(stale_devflow_evidence(feature_dir, state))
+        stale.update(stale_review_evidence(feature_dir, state))
     evidence = [
         {
             "id": evidence_id,
@@ -1442,7 +1504,8 @@ def _last_run_missed_structured_output(feature_dir: Path, activity: str) -> bool
 
 
 def _missing_output_recovery(
-    feature_dir: Path, issue_id: str, activity: str, agent: str, raw_output: str
+    feature_dir: Path, issue_id: str, activity: str, agent: str, raw_output: str,
+    *, mutated: bool | None = None,
 ) -> dict:
     """Reprise guidee d'une sortie structuree absente apres un agent termine sans erreur.
 
@@ -1467,6 +1530,8 @@ def _missing_output_recovery(
         attempt = json.loads(
             activity_attempt_file(feature_dir, activity).read_text(encoding="utf-8")
         )
+        if mutated is None:  # reconcile : le motif vient de la fiche de tentative
+            mutated = attempt["reason"] == "agent-failed-after-mutation"
         contract = json.loads(
             (feature_dir / "activity-contract.json").read_text(encoding="utf-8")
         )
@@ -1504,12 +1569,155 @@ def _missing_output_recovery(
             ),
         },
     ])
+    if not mutated:
+        # Apres des ecritures, la relance contredirait « reconciliez d'abord ».
+        recovery["commands"].append({
+            "command": f"devflow adaptive run {issue} --agent {shlex.quote(agent)}",
+            "purpose": "relancer l'agent : il n'a rien ecrit, la tentative est remplacee",
+        })
     return recovery
 
 
+def _stale_preflight_recovery(state: AdaptiveWorkflowState) -> dict:
+    """Reprise guidee d'une preuve de pre-vol perimee au lancement d'implement."""
+    issue = shlex.quote(state.issueId)
+    if _reopenable(state, "preflight-evidence"):
+        command = {
+            "command": f"devflow adaptive reopen {issue} preflight-evidence --reason MOTIF",
+            "purpose": "refaire la preuve de pre-vol sur les entrees actuelles",
+        }
+    else:
+        command = {
+            "command": f"devflow adaptive status {issue}",
+            "purpose": "consulter l'etat du parcours",
+        }
+    return {
+        "kind": "preflight-evidence-stale",
+        "summary": "Preuve de pre-vol perimee : la refaire avant implement.",
+        "commands": [command],
+    }
+
+
+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 _artifact_mismatch_recovery(
+    state: AdaptiveWorkflowState, outcome: AdaptiveRunOutcome, agent: str
+) -> dict:
+    """Reprise guidee d'un refus d'artefact, par cause observee de chaque fichier en trop."""
+    issue = shlex.quote(state.issueId)
+    files = [
+        {"path": path, "cause": cause, "label": ARTIFACT_FILE_CAUSES[cause]}
+        for path, cause in outcome.extraFiles
+    ]
+    causes = {cause for _, cause in outcome.extraFiles}
+    if not files:
+        return {
+            "kind": "artifact-files-mismatch",
+            "summary": (
+                "Artefact attendu absent ou inchange depuis la base, sans fichier en "
+                "trop : l'agent doit l'ecrire."
+            ),
+            "files": files,
+            "commands": [{
+                "command": f"devflow adaptive run {issue}"
+                + (f" --agent {shlex.quote(agent)}" if agent else ""),
+                "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": (
+            "une fois chaque fichier en trop retire ou remis dans son etat de base : "
+            "valider l'artefact sans relancer l'agent"
+        ),
+    }]
+    index = state.activities.index(state.currentActivity)
+    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)
+    ):
+        commands.append({
+            "command": f"devflow adaptive reopen {issue} {previous} --reason MOTIF",
+            "purpose": (
+                "sinon, garder le fichier modifie avant le lancement : rouvrir "
+                "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": (
+            "Fichiers en trop pour une activite documentaire : retirer ceux ecrits "
+            "pendant l'agent, remettre dans leur etat de base ceux modifies avant son "
+            "lancement. Relancer l'agent a l'identique donnerait le meme refus."
+        ),
+        "files": files,
+        "commands": commands,
+    }
+
+
+def _attempt_agent(feature_dir: Path, activity: str) -> str:
+    """Agent de la fiche de tentative, ou '' si elle est illisible."""
+    try:
+        attempt = json.loads(
+            activity_attempt_file(feature_dir, activity).read_text(encoding="utf-8")
+        )
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return ""
+    agent = attempt.get("agent") if isinstance(attempt, dict) else None
+    return agent if isinstance(agent, str) else ""
+
+
 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
+        )
     for step in recovery["commands"]:
         console.print(
             f"    {step['command']}  # {step['purpose']}", markup=False, soft_wrap=True
@@ -1549,6 +1757,24 @@ 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}")
         return
     if reason == "agent-running":

devflow_cli/commands/assess.py

@@ -16,6 +16,7 @@ from devflow_cli.core.assessment import (
     write_assessment,
 )
 from devflow_cli.core.adaptive_workflow import workflow_lock
+from devflow_cli.core.activity_contracts import NEED_STATEMENT, validate_need_statement
 from devflow_cli.core.contract_schemas import check_schema_version
 from devflow_cli.utils.console import console, fail, ok
 from devflow_cli.utils.paths import resolve_feature_dir
@@ -138,4 +139,13 @@ def assess(
     console.print(f"  Activites : {' -> '.join(assessment.activities)}")
     console.print(f"  Preuves   : {', '.join(assessment.requiredEvidence)}")
     console.print(f"  Rapport   : {output_file}")
-    console.print(f"  Suite     : devflow adaptive start {assessment.issueId}")
+    try:
+        validate_need_statement(feature_dir / NEED_STATEMENT)
+    except ValueError:
+        console.print(
+            f"  Suite     : rediger {NEED_STATEMENT} ({feature_dir / NEED_STATEMENT}), "
+            f"puis devflow adaptive start {assessment.issueId}",
+            markup=False, soft_wrap=True,
+        )
+    else:
+        console.print(f"  Suite     : devflow adaptive start {assessment.issueId}")

devflow_cli/core/activity_base.py

@@ -369,17 +369,29 @@ def declaration_warning(declared: list[str], observed: list[str]) -> str:
 
 
 def recorded_observation(
-    observation: ActivityObservation, declared: list[str]
+    observation: ActivityObservation,
+    declared: list[str],
+    *,
+    exempted: Iterable[str] = (),
+    amendment_warning: str = "",
 ) -> dict[str, Any]:
-    """Bloc ``observation`` ecrit par la CLI seule dans le resultat enregistre."""
-    observed = sorted(observation.sinceBase)
+    """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``.
+    """
+    observed = sorted(set(observation.sinceBase) - set(exempted))
     block: dict[str, Any] = {
         "baseRecordedAt": observation.base.recordedAt,
         "baseHead": observation.base.head,
         "observedAt": observation.observedAt,
         "head": observation.head,
     }
-    warning = declaration_warning(declared, observed)
+    warning = " ; ".join(
+        message
+        for message in (declaration_warning(declared, observed), amendment_warning)
+        if message
+    )
     if warning:
         block["declaredChangedFiles"] = list(declared)
         block["warning"] = warning

devflow_cli/core/activity_contracts.py

@@ -54,7 +54,9 @@ SUBAGENT_CONSTRAINT = (
 PROTECTED_VALIDATION_CONSTRAINT = (
     "Les garde-fous sont actifs : inclure dans validationPlan au moins une validation "
     "bloquante explicitement consacree a la securite, aux donnees, a l'authentification, "
-    "a une migration ou au rollback, dont id ou purpose contient l'un de ces termes."
+    "a une migration ou au rollback, dont id ou purpose contient l'un de ces termes. "
+    "Toute validation protegee est bloquante et doit reussir en code 0 : une recherche "
+    "dont l'absence de correspondance est le resultat attendu ne s'exprime pas ainsi."
 )
 
 PREFLIGHT_HEADINGS = (
@@ -178,6 +180,10 @@ def validate_need_statement(path: Path) -> None:
         raise ValueError(f"{NEED_STATEMENT} est vide : decrivez le besoin avant de demarrer")
 
 
+class PreflightEvidenceStaleError(ValueError):
+    """Preuve de pre-vol anterieure a une entree : motif de refus dedie."""
+
+
 def validate_preflight_evidence(path: Path, *, newer_than: list[Path] | None = None) -> None:
     """Validate the V4 preflight artifact without exporting its contents."""
     try:
@@ -205,7 +211,7 @@ def validate_preflight_evidence(path: Path, *, newer_than: list[Path] | None = N
         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)))
+            raise PreflightEvidenceStaleError("preuve de pre-vol desuete apres : " + ", ".join(sorted(stale_inputs)))
 
 
 def build_activity_contract(

devflow_cli/core/adaptive_runner.py

@@ -6,18 +6,20 @@ import hashlib
 import json
 import os
 import re
+import shlex
 import tempfile
 from contextlib import ExitStack
 from dataclasses import dataclass, replace
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Callable
+from typing import Callable, Iterable
 
 from devflow_cli.core.activity_contracts import (
     ActivityContract,
     ActivityResult,
     DOCUMENT_ARTIFACTS,
     NEED_STATEMENT,
+    PreflightEvidenceStaleError,
     build_activity_contract,
     contract_is_reopened_plan,
     document_artifact_name,
@@ -49,6 +51,7 @@ from devflow_cli.core.automatic_evidence import (
     review_worktree_fingerprint,
 )
 from devflow_cli.core.adaptive_workflow import (
+    AdaptiveWorkflowState,
     complete_activity,
     read_adaptive_state,
     record_evidence,
@@ -90,6 +93,8 @@ class AdaptiveRunOutcome:
     detail: str = ""
     result: ActivityResult | None = None
     warnings: tuple[str, ...] = ()
+    # artifact-files-mismatch : (chemin, cause observee) de chaque fichier en trop.
+    extraFiles: tuple[tuple[str, str], ...] = ()
 
     @property
     def advanced(self) -> bool:
@@ -142,6 +147,11 @@ def run_current_activity(
                 preflight_evidence=(feature_dir / "preflight-evidence.md").is_file(),
                 files_since_base=since_base,
             )
+            imputed_inputs = (
+                _imputed_inputs(feature_dir, feature_path, contract.activity, since_base)
+                if contract.activity in DOCUMENT_ARTIFACTS
+                else []
+            )
             if state.currentActivity == "implement":
                 upstream = [
                     feature_dir / Path(item).name
@@ -155,10 +165,29 @@ def run_current_activity(
             return AdaptiveRunOutcome(
                 exc.reason, state.currentActivity, state.currentActivity, str(exc)
             )
+        except PreflightEvidenceStaleError as exc:
+            return AdaptiveRunOutcome(
+                "preflight-evidence-stale",
+                state.currentActivity,
+                state.currentActivity,
+                str(exc),
+            )
         except (OSError, ValueError) as exc:
             return AdaptiveRunOutcome(
                 "unsupported-activity", state.currentActivity, state.currentActivity, str(exc)
             )
+        if imputed_inputs:
+            # N5 : refus avant toute ecriture et avant l'agent ; la fiche reste intacte.
+            return AdaptiveRunOutcome(
+                "artifact-files-mismatch",
+                contract.activity,
+                contract.activity,
+                "entrees du besoin modifiees par un agent de cette activite et pas "
+                "remises en etat : " + ", ".join(imputed_inputs) + " ; agent non lance",
+                extraFiles=tuple(
+                    (f"{feature_path}/{name}", "agent-input") for name in imputed_inputs
+                ),
+            )
         raw_file = activity_raw_file(feature_dir, contract.activity)
         guard = ExitStack()
         try:
@@ -203,8 +232,19 @@ def run_current_activity(
             restored = backup.restore() if runtime_mutated else []
             guard.close()
     _write_text_atomic(raw_file, execution.output)
+    current_inputs = _input_fingerprints(feature_dir)
+    changed_inputs = sorted(
+        name
+        for name in set(input_fingerprints) | set(current_inputs)
+        if input_fingerprints.get(name) != current_inputs.get(name)
+    )
+    # N5 : une entree modifiee par un agent reste imputee de fiche en fiche.
+    attributed_inputs = sorted({*changed_inputs, *imputed_inputs})
     if runtime_mutated:
-        _record_failed_attempt(feature_dir, contract, execution, "runtime-file-mutated")
+        _record_failed_attempt(
+            feature_dir, contract, execution, "runtime-file-mutated",
+            changed_inputs=attributed_inputs,
+        )
         return AdaptiveRunOutcome(
             "runtime-file-mutated",
             contract.activity,
@@ -214,16 +254,10 @@ def run_current_activity(
             + " ; remis dans leur etat d'avant l'agent : "
             + (", ".join(restored) if restored else "aucun fichier a restaurer"),
         )
-    current_inputs = _input_fingerprints(feature_dir)
-    changed_inputs = sorted(
-        name
-        for name in set(input_fingerprints) | set(current_inputs)
-        if input_fingerprints.get(name) != current_inputs.get(name)
-    )
     if changed_inputs:
         _record_failed_attempt(
             feature_dir, contract, execution,
-            "inputs-changed-during-activity", changed_inputs=changed_inputs,
+            "inputs-changed-during-activity", changed_inputs=attributed_inputs,
         )
         return AdaptiveRunOutcome(
             "inputs-changed-during-activity", contract.activity, contract.activity,
@@ -243,7 +277,9 @@ def run_current_activity(
             reason = "agent-failed"
         if execution.observedChangedFiles:
             detail += f"; mutations observees : {len(set(execution.observedChangedFiles))} fichier(s)"
-        _record_failed_attempt(feature_dir, contract, execution, reason)
+        _record_failed_attempt(
+            feature_dir, contract, execution, reason, changed_inputs=attributed_inputs
+        )
         return AdaptiveRunOutcome(reason, contract.activity, contract.activity, detail)
 
     try:
@@ -252,7 +288,10 @@ def run_current_activity(
         outcome = AdaptiveRunOutcome(
             "invalid-result", contract.activity, contract.activity, str(exc)
         )
-        _record_failed_attempt(feature_dir, contract, execution, outcome.reason)
+        _record_failed_attempt(
+            feature_dir, contract, execution, outcome.reason,
+            changed_inputs=attributed_inputs,
+        )
         return outcome
     try:
         observation = observe_activity(
@@ -273,9 +312,15 @@ def run_current_activity(
         observation,
         source="agent",
         agent=execution.agent,
+        execution_files=execution.observedChangedFiles,
+        imputed_inputs=imputed_inputs,
+        closed_activities=_closed_activities(state),
     )
     if not outcome.advanced and outcome.reason not in {"blocked", "state-changed"}:
-        _record_failed_attempt(feature_dir, contract, execution, outcome.reason)
+        _record_failed_attempt(
+            feature_dir, contract, execution, outcome.reason,
+            changed_inputs=attributed_inputs,
+        )
     return outcome
 
 
@@ -337,15 +382,38 @@ def reconcile_current_activity(
                     raise ValueError("le resultat corrige doit etre un objet JSON")
                 if not correction_reason.strip():
                     raise ValueError("un motif est obligatoire pour corriger le resultat")
-            attempt = json.loads(
-                activity_attempt_file(feature_dir, activity).read_text(encoding="utf-8")
-            )
+            try:
+                attempt_text = activity_attempt_file(feature_dir, activity).read_text(
+                    encoding="utf-8"
+                )
+            except FileNotFoundError:
+                raise ValueError(
+                    f"aucune tentative echouee a reconcilier pour '{activity}' : "
+                    "reconcile ne s'applique qu'a une tentative agent echouee ; apres "
+                    "un resultat blocked, lever le blocage puis relancer "
+                    f"devflow adaptive run {shlex.quote(state.issueId)}"
+                ) from None
+            attempt = json.loads(attempt_text)
             if not _valid_attempt(attempt):
                 raise ValueError("fiche de tentative invalide")
             agent = attempt["agent"]
             attempt_reason = attempt["reason"]
             observed_files = attempt["observedFiles"]
             execution_files = attempt["executionFiles"]
+            imputed_inputs = sorted(
+                name
+                for name in attempt.get("changedInputs", [])
+                if f"{feature_path}/{name}" in since_base
+            )
+            if imputed_inputs:
+                # N5 : reconcile ne blanchit pas une entree imputee a un agent.
+                raise ValueError(
+                    "entrees du besoin modifiees par un agent de cette activite et pas "
+                    "remises en etat : " + ", ".join(imputed_inputs) + " ; les remettre "
+                    "dans leur etat de base, ou abandonner la tentative (devflow adaptive "
+                    f"discard-attempt {shlex.quote(state.issueId)} --reason MOTIF), puis "
+                    "relancez l'activite"
+                )
             if attempt_reason == "inputs-changed-during-activity":
                 raise ValueError(
                     "les entrees ont change pendant la tentative ; inspectez-les "
@@ -365,10 +433,18 @@ def reconcile_current_activity(
                 )
             if head != attempt["head"] or branch != attempt["branch"]:
                 raise ValueError("HEAD ou la branche a change depuis la tentative")
+            # N6 : pour une activite documentaire, un fichier de la fiche autre que
+            # l'artefact peut etre revenu a son etat de base (fichier en trop retire).
+            artifact = (
+                f"{feature_path}/{DOCUMENT_ARTIFACTS[activity]}"
+                if activity in DOCUMENT_ARTIFACTS
+                else None
+            )
             drifted = sorted(
                 path
                 for path in set(observed_files) | set(since_base)
                 if observed_files.get(path) != since_base.get(path)
+                and (artifact is None or path == artifact or path in since_base)
             )
             if drifted:
                 raise ValueError(
@@ -449,6 +525,8 @@ def reconcile_current_activity(
         observation,
         source="reconciled",
         agent=agent,
+        execution_files=execution_files,
+        closed_activities=_closed_activities(state),
     )
     if orphan_warning:
         outcome = replace(outcome, warnings=(orphan_warning, *outcome.warnings))
@@ -528,12 +606,17 @@ def _apply_activity_result(
     *,
     source: str,
     agent: str,
+    execution_files: Iterable[str] = (),
+    imputed_inputs: Iterable[str] = (),
+    closed_activities: Iterable[str] = (),
 ) -> AdaptiveRunOutcome:
     """Valide un resultat agent puis transitionne ; commun a run et reconcile.
 
     L'observation fait foi : ``O`` (fichiers depuis la base) et ``E`` (fichiers
     modifies pendant l'agent) fondent les refus ; la declaration de l'agent ne
-    produit qu'un avertissement.
+    produit qu'un avertissement. ``execution_files`` est la liste brute des fichiers
+    modifies pendant l'agent, ``imputed_inputs`` les entrees du besoin deja imputees
+    a un agent de l'activite (N5) : ils fondent l'exemption N1.
     """
     state_file = feature_dir / "workflow-state.json"
     observed = sorted(observation.sinceBase)
@@ -558,13 +641,35 @@ def _apply_activity_result(
             "invalid-result", contract.activity, contract.activity, str(exc)
         )
 
+    executed = set(execution_files)
+    imputed_paths = {f"{feature_path}/{name}" for name in imputed_inputs}
+    # N1 : entrees du besoin amendees avant le lancement de l'agent, non comptees.
+    amended = (
+        [
+            path
+            for path in _input_paths(feature_dir, feature_path)
+            if path in observation.sinceBase
+            and path not in executed
+            and path not in imputed_paths
+        ]
+        if contract.activity in DOCUMENT_ARTIFACTS
+        else []
+    )
+    counted = [path for path in observed if path not in amended]
     declared = sorted(set(result.changedFiles))
-    warning = declaration_warning(declared, observed)
-    warnings = (warning,) if warning else ()
+    amendment = _amendment_warning(contract.issueId, amended, closed_activities)
+    warnings = tuple(
+        message
+        for message in (declaration_warning(declared, counted), amendment)
+        if message
+    )
 
-    def refuse(reason: str, detail: str) -> AdaptiveRunOutcome:
+    def refuse(
+        reason: str, detail: str, extra_files: tuple[tuple[str, str], ...] = ()
+    ) -> AdaptiveRunOutcome:
         return AdaptiveRunOutcome(
-            reason, contract.activity, contract.activity, detail, result, warnings
+            reason, contract.activity, contract.activity, detail, result, warnings,
+            extra_files,
         )
 
     if contract.activity == "implement" and result.status == "completed" and not observed:
@@ -576,11 +681,22 @@ def _apply_activity_result(
             contract.activity, reopened=contract_is_reopened_plan(contract)
         )
         expected = f"{feature_path}/{artifact_name}"
-        if any(path != expected for path in observed) or (
-            result.status == "completed" and observed != [expected]
+        if any(path != expected for path in counted) or (
+            result.status == "completed" and counted != [expected]
         ):
             return refuse(
-                "artifact-files-mismatch", f"attendu={[expected]}, observes={observed}"
+                "artifact-files-mismatch",
+                f"attendu={[expected]}, observes={counted}",
+                tuple(
+                    (
+                        path,
+                        "agent-input" if path in imputed_paths
+                        else "during-agent" if path in executed
+                        else "before-launch",
+                    )
+                    for path in counted
+                    if path != expected
+                ),
             )
     if contract.activity in DOCUMENT_ARTIFACTS and result.status == "completed":
         artifact_name = document_artifact_name(
@@ -624,7 +740,9 @@ def _apply_activity_result(
 
     recorded = result.to_dict()
     recorded["changedFiles"] = observed
-    recorded["observation"] = recorded_observation(observation, declared)
+    recorded["observation"] = recorded_observation(
+        observation, declared, exempted=amended, amendment_warning=amendment
+    )
     _write_json_atomic(activity_result_file(feature_dir, contract.activity), recorded)
     if result.status == "blocked":
         safe_refresh_worklog(feature_dir)
@@ -733,6 +851,17 @@ def _validated_result(
                 raise ValueError(
                     f"validation {item.id}, commande : {command_label} — {exc}"
                 ) from exc
+        if contract.guardrails:
+            for item in result.validationPlan:
+                if is_protected_validation(item.id, item.purpose) and not item.blocking:
+                    raise ValueError(
+                        f"validation {item.id} : un controle protege (securite, "
+                        "donnees, authentification, migration, rollback) est toujours "
+                        "bloquant et doit reussir en code 0 ; declarer blocking a true. "
+                        "Une recherche dont l'absence de correspondance est le resultat "
+                        "attendu ne s'exprime pas ainsi : utiliser une commande qui "
+                        "renvoie 0 en cas de succes."
+                    )
         if contract.guardrails and not any(
             item.blocking and is_protected_validation(item.id, item.purpose)
             for item in result.validationPlan
@@ -903,15 +1032,22 @@ def _record_failed_attempt(
 
     ``executionFiles`` est la liste brute des fichiers modifies pendant
     l'agent, non filtree. ``observedFiles`` vaut les fichiers depuis la base de l'activite ; si
-    l'observation est impossible, aucune fiche n'est ecrite.
+    l'observation est impossible, une fiche minimale (``head`` et ``branch`` vides,
+    ``observedFiles`` vide) n'est ecrite que si une entree du besoin est imputee ;
+    sinon aucune fiche n'est ecrite (N7).
     """
     try:
         state = read_adaptive_state(feature_dir / "workflow-state.json")
-        if state is None:
-            return
-        head, branch, observed = observe_attempt(feature_dir, state)
     except (OSError, ValueError):
         return
+    if state is None:
+        return
+    try:
+        head, branch, observed = observe_attempt(feature_dir, state)
+    except (OSError, ValueError):
+        if not changed_inputs:
+            return
+        head, branch, observed = "", "", {}
     if changed_inputs:
         input_paths = {f"{contract.featurePath}/{name}" for name in changed_inputs}
         observed = {
@@ -937,6 +1073,74 @@ def _record_failed_attempt(
     _write_json_atomic(activity_attempt_file(feature_dir, contract.activity), payload)
 
 
+def _input_paths(feature_dir: Path, feature_path: str) -> list[str]:
+    """Chemins des entrees du besoin qui sont des fichiers ordinaires lisibles.
+
+    Un lien symbolique ou une entree illisible n'en fait pas partie : il reste compte.
+    """
+    return [
+        f"{feature_path}/{name}"
+        for name, fingerprint in sorted(_input_fingerprints(feature_dir).items())
+        if not fingerprint.startswith(("symlink:", "unreadable:"))
+    ]
+
+
+def _imputed_inputs(
+    feature_dir: Path, feature_path: str, activity: str, since_base: dict[str, str]
+) -> list[str]:
+    """Entrees que la fiche de tentative impute a un agent de l'activite (N5).
+
+    Seules comptent celles qui different encore de la base : une entree remise en
+    etat n'est plus imputee.
+    """
+    try:
+        attempt = json.loads(
+            activity_attempt_file(feature_dir, activity).read_text(encoding="utf-8")
+        )
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return []
+    if not _valid_attempt(attempt) or attempt["activity"] != activity:
+        return []
+    return sorted(
+        name
+        for name in attempt.get("changedInputs", [])
+        if f"{feature_path}/{name}" in since_base
+    )
+
+
+def _closed_activities(state: AdaptiveWorkflowState) -> list[str]:
+    """Activites closes qu'``adaptive reopen`` accepte comme cible."""
+    return [
+        activity
+        for activity in state.completedActivities
+        if activity not in {"assess", "done"}
+    ]
+
+
+def _amendment_warning(
+    issue_id: str, amended: list[str], closed_activities: Iterable[str]
+) -> str:
+    """Avertissement d'une entree du besoin amendee avant l'agent (N2), ou ''."""
+    if not amended:
+        return ""
+    parts = [
+        "entrees du besoin amendees avant le lancement de l'agent, non comptees "
+        "contre l'artefact attendu : " + ", ".join(amended)
+    ]
+    closed = list(closed_activities)
+    if closed:
+        parts.append(
+            "activites deja closes, produites sur l'ancien besoin : " + ", ".join(closed)
+        )
+        parts.append(
+            "si l'amendement change leur resultat : devflow adaptive reopen "
+            f"{shlex.quote(issue_id)} ACTIVITE --reason MOTIF"
+        )
+    else:
+        parts.append("aucune activite close a rouvrir")
+    return " ; ".join(parts)
+
+
 def _input_fingerprints(feature_dir: Path) -> dict[str, str]:
     """Empreinte les entrees modifiables sans conserver leur contenu."""
     paths = [feature_dir / NEED_STATEMENT, *sorted(feature_dir.glob("issue-*.md"))]

devflow_cli/core/automatic_evidence.py

@@ -22,7 +22,13 @@ from devflow_cli.core.adaptive_workflow import (
     workflow_lock,
     write_adaptive_state,
 )
-from devflow_cli.core.activity_base import enter_current_activity, parse_recorded_result
+from devflow_cli.core.activity_base import (
+    ActivityBase,
+    BaseObservationError,
+    enter_current_activity,
+    files_since_base,
+    parse_recorded_result,
+)
 from devflow_cli.core.activity_contracts import (
     DOCUMENT_ARTIFACTS,
     activity_contract_id,
@@ -297,6 +303,38 @@ DOCUMENT_INSENSITIVE_EVIDENCE_IDS = frozenset({"test-suite", "requirements-cover
 NON_DOCUMENT_FINGERPRINT_PREFIX = "non-document-v1:"
 
 
+def is_document_path(path: str) -> bool:
+    """Vrai pour un README ou un fichier Markdown du dossier docs."""
+    return Path(path).name.casefold() == "readme.md" or (
+        path.startswith("docs/") and path.casefold().endswith(".md")
+    )
+
+
+def _observed_document_batch(
+    state: AdaptiveWorkflowState, feature_dir: Path, project_root: Path
+) -> list[str] | None:
+    """Fichiers observes depuis la base d'implement si tous sont documentaires.
+
+    None quand le lot n'est pas eligible : base inobservable, lot vide, fichier
+    non documentaire ou lien symbolique. L'observation decide, pas l'agent.
+    """
+    try:
+        base = ActivityBase.from_dict(
+            state.implementBase,
+            feature_path=feature_dir.resolve().relative_to(project_root.resolve()).as_posix(),
+        )
+        observed = sorted(
+            files_since_base(project_root, feature_dir, base, issue_id=state.issueId)
+        )
+    except (BaseObservationError, ValueError, OSError):
+        return None
+    if not observed or not all(is_document_path(path) for path in observed):
+        return None
+    if any((project_root / path).is_symlink() for path in observed):
+        return None
+    return observed
+
+
 def _non_document_fingerprint(snapshot: WorktreeSnapshot, excluded_dir: str) -> str:
     """Empreinte des sources, sans README ni Markdown du dossier docs.
 
@@ -306,10 +344,7 @@ def _non_document_fingerprint(snapshot: WorktreeSnapshot, excluded_dir: str) ->
     source_files = {
         path: fingerprint
         for path, fingerprint in snapshot.files.items()
-        if not (
-            Path(path).name.casefold() == "readme.md"
-            or (path.startswith("docs/") and path.casefold().endswith(".md"))
-        )
+        if not is_document_path(path)
     }
     return NON_DOCUMENT_FINGERPRINT_PREFIX + worktree_fingerprint(
         replace(snapshot, files=source_files), excluded_dir
@@ -562,7 +597,10 @@ def run_automatic_verification(
         # par run_verifications avant leur execution locale par devflow.
         commands = regression_commands
         reuse_targeted_as_regression = True
-    if not commands:
+    document_batch: list[str] | None = None
+    if not commands and state.profile == "quick" and not guardrails_active(state):
+        document_batch = _observed_document_batch(state, feature_dir, project_root)
+    if not commands and document_batch is None:
         return AutomaticVerificationOutcome(
             False,
             "no-safe-validation",
@@ -661,7 +699,7 @@ def run_automatic_verification(
                 break
         return AutomaticVerificationOutcome(False, "validation-policy-refused", detail)
     completed_at = _now_iso()
-    checks_passed = bool(results) and all(
+    checks_passed = (bool(results) or document_batch is not None) and all(
         result.succeeded or not result.blocking for result in results
     )
     regression_passed = all(
@@ -673,7 +711,9 @@ def run_automatic_verification(
         and all(result.succeeded for result in security_results)
         and not security_findings
     )
-    diff_payload = _inspect_diff(project_root, changed_files)
+    diff_payload = _inspect_diff(
+        project_root, document_batch if document_batch is not None else changed_files
+    )
     final_snapshot = snapshot_worktree(project_root)
     try:
         test_mutations = changed_paths(before, final_snapshot)
@@ -883,7 +923,15 @@ def run_automatic_verification(
         write_adaptive_state(state_file, latest)
         next_activity = latest.currentActivity
     safe_refresh_worklog(feature_dir)
-    return AutomaticVerificationOutcome(True, "passed", nextActivity=next_activity)
+    detail = (
+        "lot documentaire, aucun controle executable : verification sur "
+        "inspection du diff (" + ", ".join(document_batch) + ")"
+        if document_batch is not None
+        else ""
+    )
+    return AutomaticVerificationOutcome(
+        True, "passed", detail, nextActivity=next_activity
+    )
 
 
 def _failures(results: list[VerificationResult]) -> tuple[VerificationFailure, ...]:

devflow_cli/core/waivers.py

@@ -203,10 +203,51 @@ def _find_failed_command(
     if not matches:
         raise ValueError(f"aucun echec execute trouve pour {command_id}")
     if len(matches) > 1:
-        raise ValueError(f"validation ambigue dans les preuves : {command_id}")
+        return _select_duplicated_failure(command_id, matches)
     return matches[0]
 
 
+_TIE_BREAK_ORDER = {"targeted-tests": 0, "regression-check": 1}
+
+
+def _select_duplicated_failure(
+    command_id: str, matches: list[tuple[dict[str, Any], dict[str, Any]]]
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    """Retient la preuve la plus récente si toutes les occurrences sont cohérentes."""
+    names = sorted(str(payload.get("id")) for payload, _ in matches)
+    protected = [name for name in names if name in PROTECTED_EVIDENCE]
+    if protected:
+        raise ValueError(
+            f"validation {command_id} presente dans une preuve protegee "
+            f"non derogable : {', '.join(protected)}"
+        )
+    reference = matches[0][1]
+    return_code = reference.get("returncode")
+    consistent = isinstance(return_code, int) and return_code != 0
+    for _, command in matches:
+        consistent = consistent and (
+            command.get("command") == reference.get("command")
+            and command.get("workingDirectory", ".") == reference.get("workingDirectory", ".")
+            and command.get("blocking") is True
+            and command.get("succeeded") is False
+            and command.get("timedOut") is not True
+            and command.get("returncode") == return_code
+        )
+    if not consistent:
+        raise ValueError(
+            f"validation {command_id} presente dans plusieurs preuves "
+            f"({', '.join(names)}) avec des commandes, dossiers ou resultats differents"
+        )
+    ordered = sorted(
+        matches,
+        key=lambda match: (
+            _TIE_BREAK_ORDER.get(str(match[0].get("id")), len(_TIE_BREAK_ORDER)),
+            str(match[0].get("id")),
+        ),
+    )
+    return max(ordered, key=lambda match: str(match[0].get("completedAt") or ""))
+
+
 def _read_registry(path: Path, issue_id: str) -> dict[str, Any]:
     if not path.is_file():
         return {

devflow_cli/core/worklog.py

@@ -288,6 +288,16 @@ def _verification_lines(
                 f"`{waiver.get('id', 'inconnue')}` sur `{waiver.get('commandId', 'inconnu')}` "
                 f"par {waiver.get('author', 'inconnu')} : {waiver.get('reason', 'sans justification')}"
             )
+    if (
+        targeted
+        and targeted.get("id") == "targeted-check"
+        and targeted.get("outcome") == "passed"
+        and commands == []
+    ):
+        lines.append(
+            "  - Lot documentaire, aucun contrôle exécutable : "
+            "vérification sur inspection du diff."
+        )
     return lines or ["- Vérification non exécutée."]
 
 

{devflow_cli-8.2.0.dist-info → devflow_cli-8.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: devflow-cli
-Version: 8.2.0
+Version: 8.4.1
 Summary: Spec-Driven Development workflow CLI
 Project-URL: Homepage, https://github.com/sopequenoteck/devflow
 Project-URL: Repository, https://github.com/sopequenoteck/devflow
@@ -45,7 +45,8 @@ Le profil fixe la route documentaire :
 
 Un bloc de garde-fous s'y ajoute quand `--data-security` est déclaré ou que
 `--risk high` : `risk-assessment` après l'évaluation, validation bloquante de
-sécurité ou de données dans le plan de validation, preuve
+sécurité ou de données dans le plan de validation (une validation protégée non
+bloquante est refusée dès `prepare` ou `plan`), preuve
 `security-or-data-check` produite par `verify`, revue `independent-review`,
 puis `rollback-check` avec `rollback-plan`. Un bloc actif impose au minimum le
 profil `standard`, ne se désactive par aucune option et interdit les
@@ -90,8 +91,11 @@ devflow adaptive status KS-123
 distinguent explicitement blocage métier, contrat invalide, panne agent,
 validation échouée et conflit concurrent ; chaque refus affiche la commande de
 reprise recommandée. Après un refus de `verify`, cette reprise dépend du motif :
-approbations à donner, environnement à corriger, ou deux voies de réouverture
-(`implement` si le code est en cause, `prepare` ou `plan` si la validation l'est).
+approbations à donner, environnement à corriger, ou trois voies après un
+contrôle échoué (rouvrir `implement` si le code est en cause, rouvrir `prepare`
+ou `plan` si la validation l'est, relancer `verify` après un échec passager).
+En `quick`, un lot purement documentaire (`README.md`, Markdown sous `docs/`)
+sans contrôle détecté franchit `verify` sur l'inspection du diff.
 
 Un plan de `prepare` ou de `plan` refusé par les validateurs se corrige sans
 relancer l'agent : `devflow adaptive reconcile KS-123 --result FICHIER.json
@@ -112,6 +116,22 @@ nomme la cause (`structured-output-missing`) et propose
 `devflow adaptive reconcile KS-123 --result MODELE --reason MOTIF` avec un
 modèle de résultat prérempli, écrit dans `~/.devflow/reconcile/` et à compléter.
 
+`need.md` peut être amendé en cours de parcours. Avant une activité
+documentaire, l'amendement est accepté avec un avertissement qui nomme les
+activités déjà closes, à rouvrir si leur résultat en dépend ; avant `prepare`,
+il est accepté sans cet avertissement ; pendant l'exécution d'un agent, il est refusé ;
+avant `implement`, il périme la preuve de pré-vol ; après `implement`, il
+périme une revue déjà faite. Pour arbitrer après un blocage d'`implement` :
+amender `need.md`, puis `devflow adaptive reopen KS-123 preflight-evidence
+--reason MOTIF`, refaire le pré-vol et relancer `implement`. Un refus
+d'artefact (`artifact-files-mismatch`) nomme chaque fichier en trop et sa
+cause : retirer ou remettre en état le fichier, puis
+`devflow adaptive reconcile KS-123` ; la relance à l'identique n'est plus
+proposée. Pour une entrée du besoin modifiée par un agent, la relance est
+refusée avant le lancement de l'agent : remettre l'entrée en état, ou
+`devflow adaptive discard-attempt KS-123 --reason MOTIF`, puis
+`devflow adaptive run KS-123`.
+
 Chaque invocation de `adaptive run` traite une activité. La politique est dans
 `assessment.json`; la progression et les preuves sont dans
 `workflow-state.json`. Les résultats agent sont validés par schéma et les

{devflow_cli-8.2.0.dist-info → devflow_cli-8.4.1.dist-info}/RECORD

@@ -1,11 +1,11 @@
-devflow_cli/__init__.py,sha256=Y5UdblxgAc6mD_GvD_R7nfzo_uyAi09mJw3AJoB8Stk,925
+devflow_cli/__init__.py,sha256=MQEclHX75ybzzUEyJ3iAVMLUfzOpBzaQ_E5gi0d-TUc,925
 devflow_cli/cli.py,sha256=0_SmhJX_k7OQfp-jNV_jq9EOgWY4rTjStGIoc9pH6Ec,2686
 devflow_cli/adapters/__init__.py,sha256=RkjHPU2Lp4hSVIq2iOmyTrv2zYU9NuiIF9wEMWzLdMI,377
 devflow_cli/adapters/agents.py,sha256=01ZQb96koWMKH-mma3AtttdEjNEbu3mM89vFetD9iR8,29689
 devflow_cli/adapters/linear.py,sha256=HE1YzjBxwoj2jJ_3bmh9Pn_7Mt5u3EOLk891vMXBEj4,8700
 devflow_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devflow_cli/commands/adaptive.py,sha256=kYSpQWZ-xUTw1Kquv5fE2kpFjoVClqNl4Nd7pUj7FX8,62199
-devflow_cli/commands/assess.py,sha256=lyj6TI5hXUWX55dY589fG4bKJSMztvMPxZ0HZjo0O-w,5230
+devflow_cli/commands/adaptive.py,sha256=5D8K4aevxMlehsE65wnEn6ny6g_4A1Bes_OBVIUrbSM,71520
+devflow_cli/commands/assess.py,sha256=V-E3ft41ljCrqp2WLjR1Dqw-JtswcqsK2nD1-euNbNE,5655
 devflow_cli/commands/check.py,sha256=hsfeOg9yDOTAIvNm6XhRmTIFgv7w9wC8zvrwm4ojfZs,6923
 devflow_cli/commands/context.py,sha256=hwTitOHxIpJMx1X8R1jHHy9CpE4HVZpJKkyeOujxAio,6246
 devflow_cli/commands/docs_sync.py,sha256=Xc0mulpNTjDyeUDumKL7VNG0eumAf3016wEM_dqXpSU,1021
@@ -23,14 +23,14 @@ devflow_cli/commands/upgrade_cmd.py,sha256=d5uBFUPzPsCJDLxhQBFaeHWJv3GWWLmPpkYHR
 devflow_cli/commands/usage.py,sha256=ehH1AH5J-XfkebFx6qLBwpKN-MOoX2uUbq4LejBpNsk,3148
 devflow_cli/commands/verify.py,sha256=GBFCfsN-xWyROCcngOANz-3ftNVeNZ4Y_JeWFo2muwE,4139
 devflow_cli/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devflow_cli/core/activity_base.py,sha256=haEVVgZAi3-iX75oo2-fK9GQZeFgN_xRw5U0Z0bdV5w,16343
-devflow_cli/core/activity_contracts.py,sha256=2-pjjxMyS7iER2eim118U5QSgOqwrP47X_HcfZ7jZ58,38717
-devflow_cli/core/adaptive_runner.py,sha256=MLws62PW986dd00nA4m_3Y4BAR-ZmmYT3q8N6KiPU-Q,40375
+devflow_cli/core/activity_base.py,sha256=YId_tUxiL6TYmnVpG2VYGkA31nPjIrskx6Dof27XR6E,16696
+devflow_cli/core/activity_contracts.py,sha256=n9arBw-SWEFqTlCDNed6lV4WolkZKAvmQg1qcfk57ss,39036
+devflow_cli/core/adaptive_runner.py,sha256=BU3LZzM2f7dNvgKm_ul0CZYIs8z7WN1hM--TrF9o07s,48852
 devflow_cli/core/adaptive_workflow.py,sha256=F4uV5okQpFidZmneVZwW52XAO7gAmtuBAqBO9K9q7Uk,12173
 devflow_cli/core/agent_failure.py,sha256=iX4q249lAHeVdD_ZF1aObmU-FX6sjfYP9dfLSnWGAD0,3771
 devflow_cli/core/agent_run_marker.py,sha256=QW3ScA2ZpqfQdUo5ANTbenDVyY2iHpB_wTaN6VUKlzc,3451
 devflow_cli/core/assessment.py,sha256=ACtJbXq1qZjVfeERjy8Qg6-ioLfSMUBVQm2l-mtGwgI,11522
-devflow_cli/core/automatic_evidence.py,sha256=y1f6L3tsJpV57I54zcTySetho1ASHklu5mUQF1PaRDY,40600
+devflow_cli/core/automatic_evidence.py,sha256=Ntsy2eQKLRl_hUD27V9NRBLavyhLxxkEcbPySKmd4W4,42337
 devflow_cli/core/catalog.py,sha256=nLPc78JkbISaSxJnHlWiMi_lvepaumbfwcjgLuVy7Zc,3102
 devflow_cli/core/contract_schemas.py,sha256=-7SlJCwQ31OjPfwA-tP4ctgbp9hxQAVwNvvOV09Hoho,6313
 devflow_cli/core/docgen.py,sha256=47JoVDWetkcctgHwJZC67AVebOKgl10VB9hZ3Xr63mo,3908
@@ -52,8 +52,8 @@ devflow_cli/core/traceability.py,sha256=jfNE9MZzGkmaPer9Wa6Y18yA9Y3sqdeR-nzH9h_T
 devflow_cli/core/validation_approvals.py,sha256=3AHOpnW3BtY3BQrRZr38K7VNYRvbxGNhmQRYAufyhSA,9279
 devflow_cli/core/validators.py,sha256=fREjEx2fBW36q3vB6WJNqoGUM9ejYlQUXie5A9lNuPs,7440
 devflow_cli/core/verification.py,sha256=rvbdAdLyrZYb20oauti7D8nV5TDFBIf_8-hqLahfRag,23576
-devflow_cli/core/waivers.py,sha256=xpfSiC4K51ZVlBOZTRNJ5ftS05-bsLyMW-W9CdQHqH4,11595
-devflow_cli/core/worklog.py,sha256=ECmGJL63eVwfKQl94-r-Zd56ubhApuufAqDq1h5xcAU,13854
+devflow_cli/core/waivers.py,sha256=9XXzMmoWCn-2Dc3486WhZwtGJQLQPXjP0qAaLuL_3qU,13299
+devflow_cli/core/worklog.py,sha256=GkaXCsx22jntcWuC75OystUoqb5AlzBbXXLYH581Mwg,14164
 devflow_cli/core/worktree_snapshot.py,sha256=Q2_KTkhJTGvdM6Ay4RK9OHkyPEMrHQRTb-f-Eptek-8,5255
 devflow_cli/schemas/activity-contract-v4.schema.json,sha256=IeduWDiJ5IV6EL7FDZWnHBjzyUt1uwig2rB-SMbcpOU,2006
 devflow_cli/schemas/activity-result-v1.schema.json,sha256=xQuyD5fwHGIdeoJoDJxJn26qBGJX74lD6Dc5gi5CLQo,2772
@@ -90,8 +90,8 @@ devflow_cli/resources/templates/contracts/api-template.md,sha256=rC5v7JBz71PznCn
 devflow_cli/resources/templates/contracts/components-template.md,sha256=XIWfEXfC72sNmL5OA3V-7xIywkNDU2DBPLfyiagOWcs,484
 devflow_cli/resources/templates/contracts/interfaces-template.md,sha256=kf8B7b6HsmN7jyRlLNU7RnZl0rTMlI5s97yVRyI-6yc,336
 devflow_cli/resources/templates/contracts/services-template.md,sha256=cFafKCyLmq_a7aR7G0LXAaMO2z4Fuflq6iKdxfVg0vg,477
-devflow_cli-8.2.0.dist-info/METADATA,sha256=9zPuMV6XtqesVYitXPdUdkg2KqmqP_zQ7LSRCa9jksQ,8470
-devflow_cli-8.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-devflow_cli-8.2.0.dist-info/entry_points.txt,sha256=GVJ6bMvFpqyO5589iC4nFKeGTpGIW8aKn_QPPpSZ6kU,48
-devflow_cli-8.2.0.dist-info/licenses/LICENSE,sha256=v79PvnmqOdKhQiOa_QcWxng4q8GuGscLOwi7ygUpwpo,1070
-devflow_cli-8.2.0.dist-info/RECORD,,
+devflow_cli-8.4.1.dist-info/METADATA,sha256=Z1ZlFp1ND90t29jlf-ofmvs_JOnZUOk7KMJB8M-HmEA,9846
+devflow_cli-8.4.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+devflow_cli-8.4.1.dist-info/entry_points.txt,sha256=GVJ6bMvFpqyO5589iC4nFKeGTpGIW8aKn_QPPpSZ6kU,48
+devflow_cli-8.4.1.dist-info/licenses/LICENSE,sha256=v79PvnmqOdKhQiOa_QcWxng4q8GuGscLOwi7ygUpwpo,1070
+devflow_cli-8.4.1.dist-info/RECORD,,