devflow-cli 8.3.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.3.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,
@@ -519,6 +522,8 @@ def run_adaptive(
     )
     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,
@@ -700,6 +705,13 @@ 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 == "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()
@@ -921,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,
@@ -1557,9 +1598,126 @@ 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 _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
@@ -1599,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/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/adaptive_runner.py

@@ -12,7 +12,7 @@ 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,
@@ -51,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,
@@ -92,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:
@@ -144,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
@@ -168,6 +176,18 @@ def run_current_activity(
             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:
@@ -212,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,
@@ -223,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,
@@ -252,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:
@@ -261,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(
@@ -282,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
 
 
@@ -364,6 +400,20 @@ def reconcile_current_activity(
             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 "
@@ -383,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(
@@ -467,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))
@@ -546,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)
@@ -576,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:
@@ -594,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(
@@ -642,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)
@@ -932,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 = {
@@ -966,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-8.3.0.dist-info → devflow_cli-8.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: devflow-cli
-Version: 8.3.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
@@ -116,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.3.0.dist-info → devflow_cli-8.4.1.dist-info}/RECORD

@@ -1,10 +1,10 @@
-devflow_cli/__init__.py,sha256=IpmjnS3nun7PP7DJ0y0oLHgWCL8HVul9hsCpjbAVK4s,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=OdESwOyoMgySOyyLkAEk3oIkVPXS-bli_SvJe5VeHGU,64445
+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
@@ -23,9 +23,9 @@ 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_base.py,sha256=YId_tUxiL6TYmnVpG2VYGkA31nPjIrskx6Dof27XR6E,16696
 devflow_cli/core/activity_contracts.py,sha256=n9arBw-SWEFqTlCDNed6lV4WolkZKAvmQg1qcfk57ss,39036
-devflow_cli/core/adaptive_runner.py,sha256=GRL4w9FsIPplmypPx1KUnel_byc9PVe7jkTq6Q5Uy0c,41879
+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
@@ -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.3.0.dist-info/METADATA,sha256=8ck7BHBw2l01PS43k3pKc2d79l719w4YcK6RjUESOp0,8772
-devflow_cli-8.3.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-devflow_cli-8.3.0.dist-info/entry_points.txt,sha256=GVJ6bMvFpqyO5589iC4nFKeGTpGIW8aKn_QPPpSZ6kU,48
-devflow_cli-8.3.0.dist-info/licenses/LICENSE,sha256=v79PvnmqOdKhQiOa_QcWxng4q8GuGscLOwi7ygUpwpo,1070
-devflow_cli-8.3.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,,