devflow-cli 8.5.1__py3-none-any.whl → 9.0.0__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.0"
 
 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()
@@ -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/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(),

devflow_cli/core/adaptive_runner.py

@@ -20,6 +20,7 @@ from devflow_cli.core.activity_contracts import (
     DOCUMENT_ARTIFACTS,
     NEED_STATEMENT,
     PreflightEvidenceStaleError,
+    activity_contract_id,
     build_activity_contract,
     contract_is_reopened_plan,
     document_artifact_name,
@@ -31,12 +32,15 @@ from devflow_cli.core.activity_contracts import (
 from devflow_cli.core.activity_base import (
     ActivityObservation,
     BaseObservationError,
+    attempt_violation,
     declaration_warning,
     enter_current_activity,
     files_since_activity_base,
+    imputed_inputs,
     is_runtime_file,
     observe_activity,
     observe_attempt,
+    parse_recorded_result,
     recorded_observation,
 )
 from devflow_cli.core.agent_failure import diagnose_agent_failure
@@ -59,6 +63,10 @@ from devflow_cli.core.adaptive_workflow import (
     write_adaptive_state,
 )
 from devflow_cli.core.assessment import read_assessment
+from devflow_cli.core.contract_schemas import (
+    ATTEMPT_SCHEMA_VERSION,
+    contract_schema_version,
+)
 from devflow_cli.core.worklog import safe_refresh_worklog
 from devflow_cli.core.traceability import analyze_traceability
 from devflow_cli.core.validators import validate_artifact
@@ -95,6 +103,8 @@ class AdaptiveRunOutcome:
     warnings: tuple[str, ...] = ()
     # artifact-files-mismatch : (chemin, cause observee) de chaque fichier en trop.
     extraFiles: tuple[tuple[str, str], ...] = ()
+    # imputed-input : chemins (relatifs a la racine) des entrees imputees, tries.
+    imputedInputs: tuple[str, ...] = ()
 
     @property
     def advanced(self) -> bool:
@@ -147,11 +157,20 @@ 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 []
+            # D1 : l'imputation precede la peremption du pre-vol (PL-04), qui
+            # compare des mtime que la reecriture d'une entree par l'agent invalide.
+            imputed = imputed_inputs(
+                feature_dir, feature_path, contract.activity, contract.contractId,
+                since_base,
             )
+            if imputed:
+                return AdaptiveRunOutcome(
+                    "imputed-input",
+                    contract.activity,
+                    contract.activity,
+                    _imputed_detail(imputed, "agent non lance"),
+                    imputedInputs=tuple(f"{feature_path}/{name}" for name in imputed),
+                )
             if state.currentActivity == "implement":
                 upstream = [
                     feature_dir / Path(item).name
@@ -176,18 +195,6 @@ 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:
@@ -238,13 +245,19 @@ def run_current_activity(
         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})
+
+    def record(reason: str) -> str:
+        """Ecrit la fiche ; rend le suffixe de detail si elle n'a pas pu l'etre (PL-07)."""
+        try:
+            _record_failed_attempt(
+                feature_dir, contract, execution, reason, changed_inputs=changed_inputs
+            )
+        except ValueError as exc:
+            return f" ; fiche de tentative non ecrite : {exc}"
+        return ""
+
     if runtime_mutated:
-        _record_failed_attempt(
-            feature_dir, contract, execution, "runtime-file-mutated",
-            changed_inputs=attributed_inputs,
-        )
+        suffix = record("runtime-file-mutated")
         return AdaptiveRunOutcome(
             "runtime-file-mutated",
             contract.activity,
@@ -252,16 +265,14 @@ def run_current_activity(
             "fichiers d'execution devflow modifies pendant l'activite : "
             + ", ".join(runtime_mutated)
             + " ; remis dans leur etat d'avant l'agent : "
-            + (", ".join(restored) if restored else "aucun fichier a restaurer"),
+            + (", ".join(restored) if restored else "aucun fichier a restaurer")
+            + suffix,
         )
     if changed_inputs:
-        _record_failed_attempt(
-            feature_dir, contract, execution,
-            "inputs-changed-during-activity", changed_inputs=attributed_inputs,
-        )
+        suffix = record("inputs-changed-during-activity")
         return AdaptiveRunOutcome(
             "inputs-changed-during-activity", contract.activity, contract.activity,
-            "entrees modifiees pendant l'activite : " + ", ".join(changed_inputs),
+            "entrees modifiees pendant l'activite : " + ", ".join(changed_inputs) + suffix,
         )
     if execution.returncode != 0:
         diagnosis = diagnose_agent_failure(execution.output, execution.stderr)
@@ -277,22 +288,16 @@ 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, changed_inputs=attributed_inputs
-        )
+        detail += record(reason)
         return AdaptiveRunOutcome(reason, contract.activity, contract.activity, detail)
 
     try:
         raw_payload = json.loads(execution.output)
     except json.JSONDecodeError as exc:
-        outcome = AdaptiveRunOutcome(
-            "invalid-result", contract.activity, contract.activity, str(exc)
-        )
-        _record_failed_attempt(
-            feature_dir, contract, execution, outcome.reason,
-            changed_inputs=attributed_inputs,
+        return AdaptiveRunOutcome(
+            "invalid-result", contract.activity, contract.activity,
+            str(exc) + record("invalid-result"),
         )
-        return outcome
     try:
         observation = observe_activity(
             feature_dir, state, during_execution=execution.observedChangedFiles
@@ -313,14 +318,12 @@ def run_current_activity(
         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,
-            changed_inputs=attributed_inputs,
-        )
+        suffix = record(outcome.reason)
+        if suffix:
+            outcome = replace(outcome, detail=outcome.detail + suffix)
     return outcome
 
 
@@ -394,25 +397,28 @@ def reconcile_current_activity(
                     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")
+            violation = attempt_violation(attempt)
+            if violation is not None:
+                raise ValueError(f"fiche de tentative invalide : {violation}")
             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
+            imputed = imputed_inputs(
+                feature_dir,
+                feature_path,
+                activity,
+                activity_contract_id(state.issueId, state.profile, activity),
+                since_base,
             )
-            if imputed_inputs:
+            if imputed:
                 # 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"
+                return AdaptiveRunOutcome(
+                    "imputed-input",
+                    activity,
+                    activity,
+                    _imputed_detail(imputed, "reconcile refuse"),
+                    imputedInputs=tuple(f"{feature_path}/{name}" for name in imputed),
                 )
             if attempt_reason == "inputs-changed-during-activity":
                 raise ValueError(
@@ -533,48 +539,6 @@ def reconcile_current_activity(
     return outcome
 
 
-ATTEMPT_SCHEMA_VERSION = 2
-ATTEMPT_KEYS = frozenset({
-    "schemaVersion", "contractId", "activity", "agent", "reason", "recordedAt",
-    "head", "branch", "rawOutputSha256", "observedFiles", "executionFiles",
-})
-
-
-def _valid_attempt(attempt: object) -> bool:
-    """Fiche de tentative schema 2 aux cles exactes (CT-10)."""
-    if not isinstance(attempt, dict):
-        return False
-    keys = set(attempt)
-    if keys != ATTEMPT_KEYS and keys != ATTEMPT_KEYS | {"changedInputs"}:
-        return False
-    observed = attempt["observedFiles"]
-    execution_files = attempt["executionFiles"]
-    changed_inputs = attempt.get("changedInputs", [])
-    return (
-        attempt["schemaVersion"] == ATTEMPT_SCHEMA_VERSION
-        and not isinstance(attempt["schemaVersion"], bool)
-        and all(
-            isinstance(attempt[key], str)
-            for key in ("contractId", "activity", "recordedAt", "head", "branch")
-        )
-        and isinstance(attempt["agent"], str)
-        and bool(attempt["agent"])
-        and isinstance(attempt["reason"], str)
-        and bool(attempt["reason"])
-        and isinstance(attempt["rawOutputSha256"], str)
-        and len(attempt["rawOutputSha256"]) == 64
-        and isinstance(observed, dict)
-        and all(
-            isinstance(path, str) and isinstance(fingerprint, str)
-            for path, fingerprint in observed.items()
-        )
-        and isinstance(execution_files, list)
-        and all(isinstance(item, str) for item in execution_files)
-        and isinstance(changed_inputs, list)
-        and all(isinstance(item, str) for item in changed_inputs)
-    )
-
-
 def _recover_attempt_payload(
     raw_output: str,
     contract: ActivityContract,
@@ -607,7 +571,6 @@ 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.
@@ -615,8 +578,7 @@ def _apply_activity_result(
     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. ``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.
+    modifies pendant l'agent : il fonde l'exemption N1.
     """
     state_file = feature_dir / "workflow-state.json"
     observed = sorted(observation.sinceBase)
@@ -642,7 +604,6 @@ def _apply_activity_result(
         )
 
     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 = (
         [
@@ -650,7 +611,6 @@ def _apply_activity_result(
             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 []
@@ -690,9 +650,7 @@ def _apply_activity_result(
                 tuple(
                     (
                         path,
-                        "agent-input" if path in imputed_paths
-                        else "during-agent" if path in executed
-                        else "before-launch",
+                        "during-agent" if path in executed else "before-launch",
                     )
                     for path in counted
                     if path != expected
@@ -743,6 +701,15 @@ def _apply_activity_result(
     recorded["observation"] = recorded_observation(
         observation, declared, exempted=amended, amendment_warning=amendment
     )
+    try:
+        # changedFiles du resultat enregistre est la liste observee, qui peut inclure une
+        # entree du besoin amendee (N1) : la relecture porte sur la forme du bloc et du
+        # resultat valide, pas sur l'ecart entre observation et artefact attendu.
+        parse_recorded_result(
+            {**result.to_dict(), "observation": recorded["observation"]}, contract
+        )
+    except ValueError as exc:
+        return refuse("transition-refused", f"resultat enregistre invalide : {exc}")
     _write_json_atomic(activity_result_file(feature_dir, contract.activity), recorded)
     if result.status == "blocked":
         safe_refresh_worklog(feature_dir)
@@ -992,7 +959,7 @@ def record_human_review(
         except (OSError, ValueError) as exc:
             return AdaptiveRunOutcome("unsupported-activity", activity, activity, str(exc))
     payload = {
-        "schemaVersion": 1,
+        "schemaVersion": contract_schema_version("activity-result"),
         "contractId": contract.contractId,
         "status": "completed" if outcome == "passed" else "blocked",
         "summary": f"Revue humaine de {reviewer.strip()} : {outcome}",
@@ -1026,15 +993,16 @@ def _record_failed_attempt(
     execution: AgentActivityExecution,
     reason: str,
     *,
-    changed_inputs: list[str] | None = None,
+    changed_inputs: list[str],
 ) -> None:
     """Consigne les faits d'une tentative refusee pour une reprise controlee.
 
     ``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, 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).
+    l'agent, non filtree. ``observedFiles`` vaut les fichiers depuis la base de l'activite ;
+    si l'observation est impossible, une fiche minimale (``head`` et ``branch`` vides,
+    ``observedFiles`` vide) n'est ecrite que si une entree du besoin a ete modifiee
+    pendant cette tentative ; sinon aucune fiche n'est ecrite (N7). La fiche est validee
+    par ``attempt_violation`` avant toute ecriture : ``ValueError`` si elle est invalide.
     """
     try:
         state = read_adaptive_state(feature_dir / "workflow-state.json")
@@ -1048,13 +1016,12 @@ def _record_failed_attempt(
         if not changed_inputs:
             return
         head, branch, observed = "", "", {}
-    if changed_inputs:
-        input_paths = {f"{contract.featurePath}/{name}" for name in changed_inputs}
-        observed = {
-            path: fingerprint
-            for path, fingerprint in observed.items()
-            if path not in input_paths
-        }
+    input_paths = {f"{contract.featurePath}/{name}" for name in changed_inputs}
+    observed = {
+        path: fingerprint
+        for path, fingerprint in observed.items()
+        if path not in input_paths
+    }
     payload = {
         "schemaVersion": ATTEMPT_SCHEMA_VERSION,
         "contractId": contract.contractId,
@@ -1067,9 +1034,11 @@ def _record_failed_attempt(
         "rawOutputSha256": _sha256(execution.output),
         "observedFiles": observed,
         "executionFiles": sorted(set(execution.observedChangedFiles)),
+        "changedInputs": list(changed_inputs),
     }
-    if changed_inputs:
-        payload["changedInputs"] = changed_inputs
+    violation = attempt_violation(payload)
+    if violation is not None:
+        raise ValueError(violation)
     _write_json_atomic(activity_attempt_file(feature_dir, contract.activity), payload)
 
 
@@ -1085,26 +1054,11 @@ def _input_paths(feature_dir: Path, feature_path: str) -> list[str]:
     ]
 
 
-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 _imputed_detail(imputed: list[str], ending: str) -> str:
+    """Detail du refus ``imputed-input`` de run et de reconcile (CT-02, CT-03)."""
+    return (
+        "entrees du besoin modifiees par un agent de cette activite et pas "
+        "remises en etat : " + ", ".join(imputed) + " ; " + ending
     )
 
 

devflow_cli/core/adaptive_workflow.py

@@ -20,6 +20,7 @@ from devflow_cli.core.assessment import (
 from devflow_cli.core.contract_schemas import (
     ContractSchemaError,
     LegacySchemaError,
+    check_feature_files,
     check_schema_version,
     legacy_workflow_state_error,
     validate_contract_payload,
@@ -290,8 +291,8 @@ def adaptive_state_violation(path: Path) -> str | None:
 
 
 def read_adaptive_state(path: Path) -> AdaptiveWorkflowState | None:
-    """Lit un etat coherent, ou None. Un etat produit par devflow 6.x ou 7.x
-    leve ``LegacySchemaError``."""
+    """Lit un etat coherent, ou None. Un etat produit par devflow 6.x ou 7.x, ou un
+    dossier avec un resultat v1 ou une fiche de schema < 3, leve ``LegacySchemaError``."""
     try:
         data = json.loads(path.read_text(encoding="utf-8"))
     except (OSError, UnicodeDecodeError, json.JSONDecodeError):
@@ -310,6 +311,7 @@ def read_adaptive_state(path: Path) -> AdaptiveWorkflowState | None:
     ):
         # Etat sans base : aucune base n'est reconstruite (rupture 8.0.0).
         raise legacy_workflow_state_error(path, data["schemaVersion"])
+    check_feature_files(path.parent)
     try:
         validate_contract_payload("workflow-state", data)
         state = AdaptiveWorkflowState(**data)

devflow_cli/core/contract_schemas.py

@@ -17,8 +17,10 @@ PUBLIC_CONTRACT_SCHEMAS = {
     "assessment": "assessment-v4.schema.json",
     "workflow-state": "workflow-state-v6.schema.json",
     "activity-contract": "activity-contract-v4.schema.json",
-    "activity-result": "activity-result-v1.schema.json",
+    "activity-result": "activity-result-v2.schema.json",
 }
+# Fiche de tentative (<activite>-attempt.json) : seule definition (CT-04).
+ATTEMPT_SCHEMA_VERSION = 3
 
 
 class ContractSchemaError(ValueError):
@@ -26,7 +28,7 @@ class ContractSchemaError(ValueError):
 
 
 class LegacySchemaError(ValueError):
-    """A feature file was produced by an older devflow and cannot be read by devflow 8."""
+    """A feature file was produced by an older devflow and cannot be read by devflow 9."""
 
     def __init__(
         self,
@@ -44,6 +46,12 @@ class LegacySchemaError(ValueError):
                 "valide (activityBase absente ou nulle) ; aucune base n'est reconstruite ; "
                 "recreez le parcours"
             )
+        elif producer == "8.x":
+            message = (
+                f"{path} : schemaVersion {version} : parcours demarre avec devflow 8.x ; "
+                f"le terminer ou le consulter avec devflow 8.5.1 ({install}) ; "
+                "aucune migration"
+            )
         elif producer == "7.x":
             message = (
                 f"{path} : schemaVersion {version} : parcours cree avec devflow 7.x ; "
@@ -52,13 +60,14 @@ class LegacySchemaError(ValueError):
         else:
             message = (
                 f"{path} : schemaVersion {version} produit par devflow {producer}, non "
-                f"lisible par devflow 8 ; le terminer ou le consulter avec "
+                f"lisible par devflow 9 ; le terminer ou le consulter avec "
                 f"devflow {producer} ({install})"
             )
         super().__init__(message)
 
 
 LEGACY_7X_INSTALL = "uv tool install devflow-cli==7.2.0"
+LEGACY_8X_INSTALL = "uv tool install devflow-cli==8.5.1"
 # Dernier schemaVersion de workflow-state produit par devflow 7.x.
 WORKFLOW_STATE_7X_VERSION = 5
 
@@ -91,6 +100,37 @@ def check_schema_version(name: str, path: Path, payload: object) -> None:
         )
 
 
+def check_feature_files(feature_dir: Path) -> None:
+    """Refuse un dossier dont la racine porte un resultat v1 ou une fiche de schema < 3.
+
+    Seuls les fichiers ordinaires de la racine sont parcourus, par ordre de nom ; un
+    fichier illisible, non JSON, non objet ou sans version entiere est laisse aux
+    validations existantes.
+    """
+    try:
+        entries = sorted(feature_dir.iterdir(), key=lambda entry: entry.name)
+    except OSError:
+        return
+    for entry in entries:
+        if entry.name.endswith("-result.json"):
+            current = contract_schema_version("activity-result")
+        elif entry.name.endswith("-attempt.json"):
+            current = ATTEMPT_SCHEMA_VERSION
+        else:
+            continue
+        try:
+            if not entry.is_file():
+                continue
+            payload = json.loads(entry.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            continue
+        version = payload.get("schemaVersion") if isinstance(payload, dict) else None
+        if isinstance(version, int) and not isinstance(version, bool) and version < current:
+            raise LegacySchemaError(
+                entry, version, producer="8.x", install=LEGACY_8X_INSTALL
+            )
+
+
 @lru_cache(maxsize=None)
 def _schema(name: str) -> dict[str, Any]:
     try:

devflow_cli/core/feedback.py

@@ -24,6 +24,7 @@ from devflow_cli import VERSION
 from devflow_cli.adapters.linear import environment_without_linear_key
 from devflow_cli.core.contract_schemas import (
     LegacySchemaError,
+    check_feature_files,
     check_schema_version,
     contract_schema_version,
     legacy_workflow_state_error,
@@ -162,6 +163,7 @@ def _read_state(feature_dir: Path) -> tuple[str | None, str | None]:
         and state.get("activityBase") is None
     ):
         raise legacy_workflow_state_error(path, state["schemaVersion"])
+    check_feature_files(feature_dir)
     activity = state.get("currentActivity")
     profile = state.get("profile")
     return (

devflow_cli/core/remediation.py

@@ -4,13 +4,21 @@ from __future__ import annotations
 
 import json
 import os
+import shlex
 import shutil
 import tempfile
 from dataclasses import replace
 from datetime import datetime, timezone
 from pathlib import Path
 
-from devflow_cli.core.activity_base import BaseObservationError, files_since_activity_base
+from devflow_cli.core.activity_base import (
+    BaseObservationError,
+    attempt_violation,
+    feature_path_for,
+    files_since_activity_base,
+    imputed_inputs,
+)
+from devflow_cli.core.activity_contracts import activity_contract_id
 from devflow_cli.core.adaptive_workflow import (
     AdaptiveWorkflowState,
     StateInvariantError,
@@ -18,7 +26,11 @@ from devflow_cli.core.adaptive_workflow import (
     state_invariant_violation,
 )
 from devflow_cli.core.assessment import compute_route
-from devflow_cli.utils.paths import activity_attempt_file, activity_raw_file
+from devflow_cli.utils.paths import (
+    activity_attempt_file,
+    activity_raw_file,
+    project_root_for_feature,
+)
 
 
 def reopen_activity(
@@ -46,6 +58,8 @@ def reopen_activity(
         raise ValueError(
             "la cible doit etre une activite deja completee avant l'activite courante"
         )
+    if state.currentActivity != "done":
+        _refuse_imputed_inputs(feature_dir, state)
 
     activities = list(
         compute_route(
@@ -98,6 +112,18 @@ def reopen_activity(
     }
     payload["entries"].append(entry)
     _write_json_atomic(log_file, payload)
+    # Les fiches copiees dans l'archive quittent la racine (leur trace est conservee).
+    for name in archived_files:
+        if "/" in name or not name.endswith("-attempt.json"):
+            continue
+        try:
+            (feature_dir / name).unlink()
+        except OSError as exc:
+            raise ValueError(
+                f"reouverture interrompue : fiche de tentative non retiree : {name} : "
+                f"{exc} ; l'archive {entry['archivePath']} et reopen-log.json "
+                "en gardent la trace"
+            ) from exc
 
     state.activities = reopened.activities
     state.currentActivity = reopened.currentActivity
@@ -107,6 +133,45 @@ def reopen_activity(
     return entry
 
 
+def _refuse_imputed_inputs(feature_dir: Path, state: AdaptiveWorkflowState) -> None:
+    """Refuse la reouverture si la fiche courante impute des entrees encore modifiees."""
+    activity = state.currentActivity
+    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 or attempt["activity"] != activity:
+        return
+    contract_id = activity_contract_id(state.issueId, state.profile, activity)
+    if attempt["contractId"] != contract_id or not attempt["changedInputs"]:
+        return
+    issue = shlex.quote(state.issueId)
+    discard = f"devflow adaptive discard-attempt {issue} --reason MOTIF"
+    try:
+        feature_path = feature_path_for(project_root_for_feature(feature_dir), feature_dir)
+        if feature_path is None:
+            raise ValueError("dossier de la feature hors du depot")
+        since_base = files_since_activity_base(feature_dir, state)
+    except (BaseObservationError, OSError, ValueError) as exc:
+        cause = f"{exc.reason}: {exc}" if isinstance(exc, BaseObservationError) else str(exc)
+        raise ValueError(
+            f"reouverture refusee : entrees du besoin imputees a un agent de '{activity}' "
+            f"({', '.join(attempt['changedInputs'])}) et fichiers depuis la base non "
+            f"calcules : {cause} ; abandonner la tentative ({discard}), puis relancer "
+            "la reouverture"
+        ) from exc
+    names = imputed_inputs(feature_dir, feature_path, activity, contract_id, since_base)
+    if names:
+        raise ValueError(
+            f"reouverture refusee : entrees du besoin modifiees par un agent de "
+            f"'{activity}' et pas remises en etat : {', '.join(names)} ; les remettre "
+            f"dans leur etat de base, ou abandonner la tentative ({discard}), puis "
+            "relancer la reouverture"
+        )
+
+
 def discard_attempt(
     feature_dir: Path,
     state: AdaptiveWorkflowState,

devflow_cli/core/worklog.py

@@ -217,14 +217,20 @@ def _render_managed(
 
 
 def _observation_warnings(feature_dir: Path, activities: list[str]) -> list[str]:
-    """Une ligne par resultat enregistre portant un ecart de declaration (S9)."""
+    """Une ligne par resultat enregistre portant un ecart de declaration ou amendement (S9)."""
     lines: list[str] = []
     for activity in activities:
         result = _read_json(activity_result_file(feature_dir, activity), required=False)
         observation = result.get("observation") if isinstance(result, dict) else None
-        warning = observation.get("warning") if isinstance(observation, dict) else None
-        if isinstance(warning, str) and warning:
-            lines.append(f"- `{activity}` : {warning}")
+        if not isinstance(observation, dict):
+            continue
+        texts = [
+            observation[key]
+            for key in ("warning", "amendmentWarning")
+            if isinstance(observation.get(key), str) and observation[key]
+        ]
+        if texts:
+            lines.append(f"- `{activity}` : {' ; '.join(texts)}")
     return lines
 
 

devflow_cli/schemas/{activity-result-v1.schema.json → activity-result-v2.schema.json}

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://devflow.dev/schemas/activity-result/v1",
-  "title": "Devflow Activity Result v1",
+  "$id": "https://devflow.dev/schemas/activity-result/v2",
+  "title": "Devflow Activity Result v2",
   "type": "object",
   "required": [
     "schemaVersion",
@@ -15,7 +15,7 @@
     "blockers"
   ],
   "properties": {
-    "schemaVersion": {"type": "integer", "const": 1},
+    "schemaVersion": {"type": "integer", "const": 2},
     "contractId": {"type": "string", "minLength": 1},
     "status": {"type": "string", "enum": ["completed", "blocked"]},
     "summary": {"type": "string", "minLength": 1},

{devflow_cli-8.5.1.dist-info → devflow_cli-9.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: devflow-cli
-Version: 8.5.1
+Version: 9.0.0
 Summary: Spec-Driven Development workflow CLI
 Project-URL: Homepage, https://github.com/sopequenoteck/devflow
 Project-URL: Repository, https://github.com/sopequenoteck/devflow
@@ -150,6 +150,15 @@ devflow adaptive run KS-123 --agent claude
 devflow adaptive run KS-123 --agent cursor
 ```
 
+## Features créées avant devflow 9
+
+Devflow 9 refuse, sans migration, un dossier de feature dont la racine contient
+un `*-result.json` de `schemaVersion` 1 ou un `*-attempt.json` de schéma 2 ou
+moins (parcours démarré avec devflow 8.x). Terminez les parcours en cours avec
+devflow 8.5.1, ou gardez la CLI épinglée :
+`uv tool install devflow-cli==8.5.1`. Voir les
+[notes de version 9.0.0](docs/releases/9.0.0.md).
+
 ## Features créées avant devflow 8
 
 Devflow 8 refuse, sans migration, un `workflow-state.json` (schéma 5) produit

{devflow_cli-8.5.1.dist-info → devflow_cli-9.0.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-devflow_cli/__init__.py,sha256=yUxpKLKephIrgPv-hHWMO6tznMd47ejm6oL_zFuipxA,925
+devflow_cli/__init__.py,sha256=TVrbUn4dfhBCXtCVCypThAPpg7SGLsuYX076rhwMzac,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=8zYUrtPxU3NRpQ4yv0ScHmn8IjQfnx4U24qMW8Y4_Uo,72797
+devflow_cli/commands/adaptive.py,sha256=iCS0BvaD2Z1fgI3cUsdrpQs52w_THS-v2I8AyvJy2N8,72771
 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
@@ -17,31 +17,31 @@ devflow_cli/commands/hooks_cmd.py,sha256=BMzNBKHIpQkMj5y-2bxtCNqAa8cncGfGTWMgx6S
 devflow_cli/commands/init_cmd.py,sha256=VXR52ocqkO23J18pgij0Mhc_BTBl2PolxArjoCOuNow,5383
 devflow_cli/commands/linear.py,sha256=i066d5ryyBzZVfrSudbD0VWg9fSLivnB8yNe4vAMMW0,972
 devflow_cli/commands/stale.py,sha256=UiaUb48lrXmPyjfvbFkChfLE-rs58KhgKu-zgL_NBIo,3182
-devflow_cli/commands/status.py,sha256=4aIQHLmOCikZR3VCaaQw9j1TjHKtWqiHxBHKI1FSUXo,8644
+devflow_cli/commands/status.py,sha256=Votdh_sZkRuC_iui1krrdXE9cZ5dpY2OO2au4PVa7IQ,8647
 devflow_cli/commands/traceability.py,sha256=DhUOBzSmKVk17j1Qz0yxD5zD2-iNWaR9F133VNPjy70,1767
 devflow_cli/commands/upgrade_cmd.py,sha256=d5uBFUPzPsCJDLxhQBFaeHWJv3GWWLmPpkYHRVd1gwM,5664
 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=YId_tUxiL6TYmnVpG2VYGkA31nPjIrskx6Dof27XR6E,16696
-devflow_cli/core/activity_contracts.py,sha256=ui-9JYwtZYcjEVppgcD5YNW_O7gkxxCkfXlIevLrJ-c,39295
-devflow_cli/core/adaptive_runner.py,sha256=ePnwJLPG2hpt76yE6WTTzXgljb7jkpVWAyTZRRdKVhs,48856
-devflow_cli/core/adaptive_workflow.py,sha256=CGfKOzCDwKGlp2ez9IDgBq6-FNjFYRhpJagZORpBGSc,14562
+devflow_cli/core/activity_base.py,sha256=eEC_YIr5O7WhCglA7xAEPypVzhcdC6f2h9d-SDDecVA,20475
+devflow_cli/core/activity_contracts.py,sha256=oN8ATaRhsEz-o4PhdX9ASwpCooXK0Wo_wExmWXkiRCY,39406
+devflow_cli/core/adaptive_runner.py,sha256=BuVGk-P0nmtD5PRuHBXNOS4epwA6RFivPRxn3zb_LrU,47068
+devflow_cli/core/adaptive_workflow.py,sha256=NgDEr67monxalcGiO3R_ACVUrZu_OX6LQRhQJbMTWT8,14687
 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=wBsOwQvwNSETefSMkZK6tcb3aDErgbVK9WANknT8HN4,42592
 devflow_cli/core/catalog.py,sha256=nLPc78JkbISaSxJnHlWiMi_lvepaumbfwcjgLuVy7Zc,3102
-devflow_cli/core/contract_schemas.py,sha256=TOGXwpNmm_MEzDkxR1wYvcCqASv1j4C1vxT6RjDFMiM,6744
+devflow_cli/core/contract_schemas.py,sha256=JXI8PVgjdagTlFxnyuIkNRRrVi319Mv8GwuMxopJ_GI,8424
 devflow_cli/core/docgen.py,sha256=47JoVDWetkcctgHwJZC67AVebOKgl10VB9hZ3Xr63mo,3908
-devflow_cli/core/feedback.py,sha256=4LJk-stAz_1toVVK4kGlWs6yUIQEEjjXVLglDXc37JU,18965
+devflow_cli/core/feedback.py,sha256=_YvUBA4nMzXYZchvQagMbazNIvZIqRsnqL94ESfOde4,19027
 devflow_cli/core/git.py,sha256=gsDfT-hDNtMQFRUl1WzZSqltrdwZQ2BJBcCIh4TwDkA,2780
 devflow_cli/core/hooks.py,sha256=nFPaziFJgeZgAPKPxbTibrB_0MJAST3cAmg3gtcvDBQ,8067
 devflow_cli/core/installer.py,sha256=fmfaJs5ApkhRmQi1B4vz52iAHBtqgeyBoAnE8CXAzJI,6303
 devflow_cli/core/manifest.py,sha256=h058_m5-HJrYsNUdgfwnKts2riHiYPXUwMzPImHOs2g,7023
 devflow_cli/core/operational.py,sha256=11iLTbyZF0ZjYTQ5HDmVCaw4bpbXpLtH2v9f1WQOrYg,1228
 devflow_cli/core/redaction.py,sha256=o_1MDtCyvRLrk_dWlV6_7E6_mPVB1B5a0cCfTBj9j0Q,1973
-devflow_cli/core/remediation.py,sha256=gvoemlDDC6GmIwAu4BLWnrBTJ240Z6cFCjyxSVrX61c,9407
+devflow_cli/core/remediation.py,sha256=ywOOJUyT6SYbK79NnsIZcpn90HBZhavFxl4JSB9Vz3s,12254
 devflow_cli/core/result_template.py,sha256=XfrjUlSUDYJxE2nN8EJjHCXq1l06hn-wW1gDn1c1rBA,2493
 devflow_cli/core/run_progress.py,sha256=hawaMo5sGcxvugexeryMWanFajdf46SY6b37O7dToZM,1855
 devflow_cli/core/runtime_backup.py,sha256=dowz6a1vcJsqkl-m9wGhS4F6XGfsU2rwSNJvIZMJjhI,4345
@@ -53,10 +53,10 @@ devflow_cli/core/validation_approvals.py,sha256=3AHOpnW3BtY3BQrRZr38K7VNYRvbxGNh
 devflow_cli/core/validators.py,sha256=fREjEx2fBW36q3vB6WJNqoGUM9ejYlQUXie5A9lNuPs,7440
 devflow_cli/core/verification.py,sha256=rvbdAdLyrZYb20oauti7D8nV5TDFBIf_8-hqLahfRag,23576
 devflow_cli/core/waivers.py,sha256=9XXzMmoWCn-2Dc3486WhZwtGJQLQPXjP0qAaLuL_3qU,13299
-devflow_cli/core/worklog.py,sha256=i4zgJIlS1OSIBMrhT1AKU97bh7IHAhNYbnr4eJVGv_Y,14692
+devflow_cli/core/worklog.py,sha256=itKIgzduDvl5STv3B_Yle9qi9W11Xhbg4_bDyCFVBqQ,14850
 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
+devflow_cli/schemas/activity-result-v2.schema.json,sha256=2yDf6S--mlNWMxE8h8ruwTsM3Tnaa96SJDjluc4ePbI,2772
 devflow_cli/schemas/assessment-v4.schema.json,sha256=byFBaoG_Vu-qS7vERREKThtpQa3dzNtPiFCMyEpWFVQ,2254
 devflow_cli/schemas/workflow-state-v6.schema.json,sha256=fYyJS-6Aq-Ea7y2bVqJYSmKzdF2DvL3Nb6IdDNgFGfY,3239
 devflow_cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -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.5.1.dist-info/METADATA,sha256=Vaqrf7U9UaMMnfl_sHbt_bK6B0WeyDBdaouxnd0E6Yo,9982
-devflow_cli-8.5.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-devflow_cli-8.5.1.dist-info/entry_points.txt,sha256=GVJ6bMvFpqyO5589iC4nFKeGTpGIW8aKn_QPPpSZ6kU,48
-devflow_cli-8.5.1.dist-info/licenses/LICENSE,sha256=v79PvnmqOdKhQiOa_QcWxng4q8GuGscLOwi7ygUpwpo,1070
-devflow_cli-8.5.1.dist-info/RECORD,,
+devflow_cli-9.0.0.dist-info/METADATA,sha256=P54H3nX_kUKvDUIgpC69PPpSkrT59fM-yLGl1Q2K9rs,10403
+devflow_cli-9.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+devflow_cli-9.0.0.dist-info/entry_points.txt,sha256=GVJ6bMvFpqyO5589iC4nFKeGTpGIW8aKn_QPPpSZ6kU,48
+devflow_cli-9.0.0.dist-info/licenses/LICENSE,sha256=v79PvnmqOdKhQiOa_QcWxng4q8GuGscLOwi7ygUpwpo,1070
+devflow_cli-9.0.0.dist-info/RECORD,,