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

devflow_cli/__init__.py

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

devflow_cli/commands/adaptive.py

@@ -25,6 +25,10 @@ from devflow_cli.core.adaptive_workflow import (
     write_adaptive_state,
 )
 from devflow_cli.core.assessment import read_assessment
+from devflow_cli.core.activity_base import (
+    enter_current_activity,
+    files_since_activity_base,
+)
 from devflow_cli.core.activity_contracts import (
     build_activity_contract,
     NEED_STATEMENT,
@@ -34,14 +38,17 @@ from devflow_cli.core.activity_contracts import (
     write_activity_contract,
 )
 from devflow_cli.core.adaptive_runner import (
+    MANUAL_RECONCILIATION_ACTIVITIES,
     AgentActivityExecution,
     reconcile_current_activity,
     record_human_review,
     run_current_activity,
 )
+from devflow_cli.core.agent_run_marker import AgentRunningError, ensure_no_agent_running
 from devflow_cli.core import run_progress
 from devflow_cli.core.worktree_snapshot import changed_paths, snapshot_worktree
 from devflow_cli.core.automatic_evidence import (
+    AutomaticVerificationOutcome,
     ensure_fresh_devflow_evidence,
     run_automatic_verification,
     stale_devflow_evidence,
@@ -51,7 +58,6 @@ from devflow_cli.core.worklog import refresh_worklog, safe_refresh_worklog
 from devflow_cli.core.telemetry import append_record, telemetry_enabled, usage_payload
 from devflow_cli.core.waivers import create_validation_waiver
 from devflow_cli.core.remediation import (
-    carried_changed_files,
     discard_attempt,
     is_reopened_activity,
     reopen_activity,
@@ -59,6 +65,7 @@ from devflow_cli.core.remediation import (
 from devflow_cli.core.redaction import redact_command
 from devflow_cli.core.validation_approvals import (
     approve_plan_command,
+    pending_approvals,
     pending_plan_approval,
 )
 from devflow_cli.core.contract_schemas import LegacySchemaError, diagnose_contract_file
@@ -77,6 +84,9 @@ app = typer.Typer(help="Machine d'etat des parcours adaptatifs")
 
 LEGACY_SCHEMA_EXIT_CODE = 1
 
+# Refus avant tout agent : base inutilisable (branche changee, historique reecrit).
+BASE_REFUSALS = frozenset({"base-history-rewritten", "base-branch-changed"})
+
 RESULT_VALIDATED_ACTIVITIES = frozenset({
     "prepare",
     "risk-assessment",
@@ -167,7 +177,10 @@ def start(feature: str = typer.Argument(..., help="ID ou dossier de la feature")
             assessment = _assessment(feature_dir)
             validate_need_statement(feature_dir / NEED_STATEMENT)
             state = create_adaptive_workflow(assessment.to_dict())
-        except ValueError as exc:
+            enter_current_activity(
+                state, project_root_for_feature(feature_dir), feature_dir
+            )
+        except (OSError, ValueError) as exc:
             fail(f"Impossible de demarrer le workflow : {exc}")
             raise typer.Exit(int(ExitCode.INVALID_CONTRACT)) from exc
         write_adaptive_state(state_file, state)
@@ -206,6 +219,7 @@ def complete(
     """Complete l'activite courante si ses gates sont satisfaites."""
     feature_dir = _feature(feature)
     with workflow_lock(feature_dir):
+        refuse_if_agent_running(feature_dir)
         state = _state(feature_dir)
         activity = activity or state.currentActivity
         try:
@@ -221,7 +235,10 @@ def complete(
                 validate_preflight_evidence(feature_dir / "preflight-evidence.md")
             ensure_fresh_devflow_evidence(feature_dir, state, activity)
             complete_activity(state, activity)
-        except ValueError as exc:
+            enter_current_activity(
+                state, project_root_for_feature(feature_dir), feature_dir
+            )
+        except (OSError, ValueError) as exc:
             fail(str(exc))
             console.print(f"  Suite : devflow adaptive status {state.issueId}")
             raise typer.Exit(int(ExitCode.BLOCKED)) from exc
@@ -245,6 +262,7 @@ def evidence(
     """Enregistre une preuve manuelle informative, sans ouvrir les gates."""
     feature_dir = _feature(feature)
     with workflow_lock(feature_dir):
+        refuse_if_agent_running(feature_dir)
         state = _state(feature_dir)
         try:
             record_evidence(state, evidence_id, report or "")
@@ -276,6 +294,7 @@ def contract(
         raise typer.Exit(int(ExitCode.INVALID_CONTRACT)) from exc
 
     with workflow_lock(feature_dir):
+        refuse_if_agent_running(feature_dir)
         state = _state(feature_dir)
         try:
             assessment = _assessment(feature_dir)
@@ -284,11 +303,15 @@ def contract(
                 state,
                 assessment.to_dict(),
                 feature_path,
-                carried_changed_files(feature_dir, state.currentActivity),
                 reopened=is_reopened_activity(feature_dir, state.currentActivity),
                 preflight_evidence=(feature_dir / "preflight-evidence.md").is_file(),
+                files_since_base=(
+                    files_since_activity_base(feature_dir, state)
+                    if state.activityBase is not None
+                    else ()
+                ),
             )
-        except ValueError as exc:
+        except (OSError, ValueError) as exc:
             fail(f"Impossible de generer le contrat : {exc}")
             raise typer.Exit(int(ExitCode.INVALID_CONTRACT)) from exc
         output_file = feature_dir / "activity-contract.json"
@@ -447,7 +470,7 @@ def run_adaptive(
             agent,
         )
 
-    outcome = run_current_activity(feature_dir, feature_path, execute)
+    outcome = run_current_activity(feature_dir, feature_path, execute, agent=agent)
     _record_telemetry(
         run_id, attempt, agent, project_root, outcome.reason,
         json_output=json_output,
@@ -457,22 +480,31 @@ def run_adaptive(
             _print_execution_json(
                 current_state.issueId, outcome.activity, True, outcome.reason,
                 outcome.detail, outcome.nextActivity, ExitCode.OK,
+                warnings=outcome.warnings,
             )
         else:
             ok(
                 f"Activite '{outcome.activity}' validee. "
                 f"Prochaine : {outcome.nextActivity}"
             )
+            _print_warnings(outcome.warnings)
+            _print_pending_approvals(feature_dir, current_state.issueId, outcome.activity)
         return
-    safe_refresh_worklog(feature_dir)
+    if outcome.reason != "agent-running":  # worklog.md : fichier d'execution (B4)
+        safe_refresh_worklog(feature_dir)
     exit_code = exit_code_for_run_reason(outcome.reason)
     if json_output:
         _print_execution_json(
             current_state.issueId, outcome.activity, False, outcome.reason,
             outcome.detail, outcome.nextActivity, exit_code,
+            warnings=outcome.warnings,
         )
+    elif outcome.reason in BASE_REFUSALS:
+        fail(outcome.detail)
+        console.print(f"  Suite : devflow adaptive status {current_state.issueId}")
     else:
         fail(outcome.detail or outcome.reason)
+        _print_warnings(outcome.warnings)
         console.print(
             f"  Activite '{outcome.activity}' non validee : {outcome.reason}"
         )
@@ -546,7 +578,10 @@ def reconcile_adaptive(
     result: Optional[Path] = typer.Option(
         None,
         "--result",
-        help="Payload JSON corrige a revalider quand la trace est inexploitable",
+        help=(
+            "Payload JSON corrige, rejoue par les validateurs de run, quand la trace "
+            "est inexploitable ou que sa reponse est refusee par les validateurs"
+        ),
     ),
     reason: Optional[str] = typer.Option(
         None,
@@ -591,12 +626,22 @@ def reconcile_adaptive(
             f"Activite '{outcome.activity}' reconciliee. "
             f"Prochaine : {outcome.nextActivity}"
         )
+        _print_warnings(outcome.warnings)
+        _print_pending_approvals(feature_dir, state.issueId, outcome.activity)
         return
-    safe_refresh_worklog(feature_dir)
-    fail(
-        f"Reconciliation de '{outcome.activity}' refusee : {outcome.reason}"
-        + (f" ({outcome.detail})" if outcome.detail else "")
-    )
+    if outcome.reason != "agent-running":  # worklog.md : fichier d'execution (B4)
+        safe_refresh_worklog(feature_dir)
+    if outcome.reason in BASE_REFUSALS:
+        fail(outcome.detail)
+    else:
+        fail(
+            f"Reconciliation de '{outcome.activity}' refusee : {outcome.reason}"
+            + (f" ({outcome.detail})" if outcome.detail else "")
+        )
+        _print_warnings(outcome.warnings)
+    if outcome.reason == "agent-running":
+        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":
         console.print(
@@ -622,6 +667,7 @@ def review_adaptive(
     project_root = project_root_for_feature(feature_dir)
     feature_path = feature_dir.relative_to(project_root).as_posix()
     with workflow_lock(feature_dir):
+        refuse_if_agent_running(feature_dir)
         state = _state(feature_dir)
     try:
         report_file = report.resolve()
@@ -665,6 +711,10 @@ def verify_adaptive(
     """Genere localement les preuves requises par le profil actif."""
     feature_dir = _feature(feature, json_output=json_output)
     state = _state(feature_dir, json_output=json_output, issue_id=feature)
+    with workflow_lock(feature_dir):
+        refuse_if_agent_running(
+            feature_dir, json_issue_id=state.issueId if json_output else None
+        )
     if not refresh and state.currentActivity != "verify":
         detail = (
             "Activite courante attendue pour verify : verify "
@@ -698,6 +748,7 @@ def approve_adaptive_command(
     feature_dir = _feature(feature)
     try:
         with workflow_lock(feature_dir):
+            refuse_if_agent_running(feature_dir)
             item = pending_plan_approval(feature_dir, validation_id)
             console.print(f"Validation  : {item.id}")
             console.print(f"Commande    : {shlex.join(redact_command(item.command))}")
@@ -739,6 +790,7 @@ def waive_validation(
     """Rend non bloquant un controle planifie echoue, avec audit durable."""
     feature_dir = _feature(feature)
     with workflow_lock(feature_dir):
+        refuse_if_agent_running(feature_dir)
         try:
             waiver = create_validation_waiver(
                 feature_dir, validation_id, reason, author=author
@@ -766,11 +818,15 @@ def reopen(
     """Revient a une activite anterieure sans effacer l'historique."""
     feature_dir = _feature(feature)
     with workflow_lock(feature_dir):
+        refuse_if_agent_running(feature_dir)
         state = _state(feature_dir)
         try:
             entry = reopen_activity(
                 feature_dir, state, activity, reason, author=author
             )
+            enter_current_activity(
+                state, project_root_for_feature(feature_dir), feature_dir
+            )
         except (OSError, ValueError) as exc:
             fail(str(exc))
             console.print(f"  Suite : devflow adaptive status {state.issueId}")
@@ -792,6 +848,7 @@ def discard_attempt_command(
     """Abandonne la tentative de l'activite courante, avec archive et audit."""
     feature_dir = _feature(feature)
     with workflow_lock(feature_dir):
+        refuse_if_agent_running(feature_dir)
         state = _state(feature_dir)
         try:
             entry = discard_attempt(feature_dir, state, reason, author=author)
@@ -806,9 +863,12 @@ def discard_attempt_command(
     )
     if entry["discardedFiles"]:
         warn(
-            "Changements laisses dans le working tree, non reportes : "
-            + ", ".join(entry["discardedFiles"])
+            "Fichiers modifies depuis le debut de l'activite "
+            f"'{entry['activity']}', comptes dans le lot a la relance ; remise en "
+            "etat a la charge du superviseur : " + ", ".join(entry["discardedFiles"])
         )
+    if entry.get("observationError"):
+        warn(f"Fichiers depuis la base non calcules : {entry['observationError']}")
 
 
 def _execute_local_verification(
@@ -822,11 +882,15 @@ def _execute_local_verification(
     if not refresh:
         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)
+    )
     if json_output:
         _print_execution_json(
             issue_id, "verify", outcome.passed, outcome.reason, outcome.detail,
             outcome.nextActivity,
             ExitCode.OK if outcome.passed else ExitCode.VERIFICATION_FAILURE,
+            recovery=recovery,
         )
         if not outcome.passed:
             raise typer.Exit(int(ExitCode.VERIFICATION_FAILURE))
@@ -840,19 +904,182 @@ def _execute_local_verification(
     fail(outcome.detail or outcome.reason)
     console.print(f"  Verification automatique refusee : {outcome.reason}")
     console.print("  Reprise guidee :")
-    console.print(f"    devflow adaptive status {issue_id}")
-    console.print(
-        f"    devflow adaptive reopen {issue_id} implement --reason "
-        f'"correction apres {outcome.reason}"'
-    )
+    console.print(f"    {recovery['summary']}")
+    for step in recovery["commands"]:
+        console.print(f"    {step['command']}  # {step['purpose']}", markup=False)
     raise typer.Exit(int(ExitCode.VERIFICATION_FAILURE))
 
 
+# Motifs de refus de verify dus a l'echec d'un controle execute (B2).
+CHECK_FAILURE_REASONS = frozenset({
+    "targeted-check-failed",
+    "targeted-tests-failed",
+    "test-suite-failed",
+    "regression-check-failed",
+    "security-or-data-check-failed",
+})
+PLANNED_PREFIXES = {"PREP-": "prepare", "PLAN-": "plan"}
+
+
+def _verify_recovery(
+    feature_dir: Path, issue_id: str, outcome: AutomaticVerificationOutcome
+) -> 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).
+    """
+    issue = shlex.quote(issue_id)
+    verify_command = {
+        "command": f"devflow adaptive verify {issue}",
+        "purpose": "relancer la verification",
+    }
+    state = read_adaptive_state(feature_dir / "workflow-state.json")
+    plan_activity = (
+        "prepare" if state is not None and state.profile == "standard" else "plan"
+    )
+    if outcome.pendingApprovals:
+        return {
+            "kind": "approval-pending",
+            "summary": "Approuver chaque validation en attente, puis relancer verify.",
+            "validations": [
+                {"id": item, "origin": plan_activity, "returncode": None}
+                for item in outcome.pendingApprovals
+            ],
+            "commands": [
+                *(
+                    {
+                        "command": (
+                            f"devflow adaptive approve-command {issue} "
+                            f"{shlex.quote(item)} --reason MOTIF"
+                        ),
+                        "purpose": f"approuver la commande exacte de {item}",
+                    }
+                    for item in outcome.pendingApprovals
+                ),
+                verify_command,
+            ],
+        }
+    status_command = {
+        "command": f"devflow adaptive status {issue}",
+        "purpose": "consulter l'etat du parcours",
+    }
+    if outcome.reason not in CHECK_FAILURE_REASONS:
+        return {
+            "kind": "status",
+            "summary": f"Refus {outcome.reason} : consulter l'etat avant toute reprise.",
+            "validations": [],
+            "commands": [status_command],
+        }
+    validations = []
+    for failure in outcome.failures:
+        validation_id, origin = failure.id, None
+        for prefix, activity in PLANNED_PREFIXES.items():
+            if failure.id.startswith(prefix):
+                validation_id, origin = failure.id.removeprefix(prefix), activity
+        if origin is not None and not _reopenable(state, origin):
+            origin = None
+        validations.append({
+            "id": validation_id,
+            "origin": origin,
+            "returncode": failure.returncode,
+        })
+    if validations and all(item["returncode"] == 127 for item in validations):
+        names = ", ".join(item["id"] for item in validations)
+        return {
+            "kind": "environment",
+            "summary": (
+                f"Executable introuvable (code 127) pour {names} : corriger "
+                "l'environnement, puis relancer verify."
+            ),
+            "validations": validations,
+            "commands": [verify_command],
+        }
+    reason_text = shlex.quote(f"correction apres {outcome.reason}")
+    commands = [
+        status_command,
+        {
+            "command": f"devflow adaptive reopen {issue} implement --reason {reason_text}",
+            "purpose": "voie 1 : le code est en cause",
+        },
+    ]
+    for origin in sorted({item["origin"] for item in validations if item["origin"]}):
+        names = ", ".join(item["id"] for item in validations if item["origin"] == origin)
+        commands.append({
+            "command": f"devflow adaptive reopen {issue} {origin} --reason {reason_text}",
+            "purpose": f"voie 2 : la validation {names}, inscrite par {origin}, est en cause",
+        })
+    return {
+        "kind": "check-failed",
+        "summary": (
+            "Controle echoue"
+            + (f" : {', '.join(item['id'] for item in validations)}" if validations else "")
+            + ". Choisir la voie selon la cause ; aucune n'est choisie automatiquement."
+        ),
+        "validations": validations,
+        "commands": commands,
+    }
+
+
+def _reopenable(state: AdaptiveWorkflowState | None, activity: str) -> bool:
+    return (
+        state is not None
+        and activity in state.activities
+        and activity in state.completedActivities
+        and state.activities.index(activity) < state.activities.index(state.currentActivity)
+    )
+
+
+def refuse_if_agent_running(feature_dir: Path, *, json_issue_id: str | None = None) -> None:
+    """Refuse sans effet une commande humaine pendant l'execution d'un agent (B4).
+
+    A appeler avant toute ecriture dans le dossier de la feature. Avec ``json_issue_id``,
+    le refus est rendu sous la forme JSON des commandes d'execution.
+    """
+    try:
+        warning = ensure_no_agent_running(feature_dir)
+    except AgentRunningError as exc:
+        if json_issue_id is not None:
+            _print_execution_json(
+                json_issue_id, None, False, "agent-running", str(exc), None,
+                ExitCode.CONCURRENT_CHANGE,
+            )
+        else:
+            fail(str(exc))
+        raise typer.Exit(int(ExitCode.CONCURRENT_CHANGE)) from exc
+    if warning:
+        warn(warning)
+
+
+def _print_pending_approvals(feature_dir: Path, issue_id: str, activity: str) -> None:
+    """Liste en une fois les approbations attendues a la fin de prepare ou plan."""
+    if activity not in {"prepare", "plan"}:
+        return
+    try:
+        pending = pending_approvals(feature_dir)
+    except ValueError:
+        return
+    if not pending:
+        return
+    warn(
+        "Approbations attendues avant verify : "
+        + ", ".join(item.id for item in pending)
+    )
+    for item in pending:
+        console.print(
+            f"  devflow adaptive approve-command {shlex.quote(issue_id)} "
+            f"{shlex.quote(item.id)} --reason MOTIF",
+            markup=False,
+        )
+
+
 def _print_execution_json(
     issue_id: str, activity: str | None, passed: bool, reason: str,
     detail: str, next_activity: str | None, exit_code: ExitCode,
+    *, warnings: tuple[str, ...] = (), recovery: dict | None = None,
 ) -> None:
-    typer.echo(json.dumps({
+    payload = {
         "schemaVersion": 1,
         "issueId": issue_id,
         "activity": activity,
@@ -861,7 +1088,17 @@ def _print_execution_json(
         "detail": detail,
         "nextActivity": next_activity,
         "exitCode": int(exit_code),
-    }, ensure_ascii=False))
+        "warnings": list(warnings),
+    }
+    if recovery is not None:
+        payload["recovery"] = recovery
+    typer.echo(json.dumps(payload, ensure_ascii=False))
+
+
+def _print_warnings(warnings: tuple[str, ...]) -> None:
+    """Ecart de declaration : avertissement seul, sans effet sur le code de sortie."""
+    for message in warnings:
+        warn(message)
 
 
 def _utc_now() -> str:
@@ -936,6 +1173,8 @@ def worklog(
 ) -> None:
     """Regenere le journal compact depuis les artefacts du workflow."""
     feature_dir = _feature(feature)
+    with workflow_lock(feature_dir):
+        refuse_if_agent_running(feature_dir)
     try:
         output = refresh_worklog(feature_dir)
     except LegacySchemaError as exc:
@@ -1155,13 +1394,6 @@ def _print_run_recovery(
         console.print("    Ne relancez pas automatiquement l'agent : reconciliez d'abord les changements partiels.")
         console.print(f"    devflow adaptive reconcile {issue_id}")
         return
-    if reason == "stale-attempt":
-        console.print("    git status --short  # inspecter les changements de la tentative")
-        console.print(
-            "    Restaurez les fichiers de la tentative, ou abandonnez-la explicitement :"
-        )
-        console.print(f"    devflow adaptive discard-attempt {issue_id} --reason MOTIF")
-        return
     if reason == "inputs-changed-during-activity":
         console.print(
             "    Les entrees du besoin ont change pendant l'execution. "
@@ -1169,6 +1401,14 @@ def _print_run_recovery(
         )
         console.print(f"    devflow adaptive run {issue_id} --agent {agent}")
         return
+    if reason == "agent-running":
+        console.print("    Un agent execute deja cette activite : attendez sa fin.")
+        return
+    if reason == "invalid-result" and activity in MANUAL_RECONCILIATION_ACTIVITIES:
+        console.print(
+            f"    devflow adaptive reconcile {issue_id} --result FICHIER.json --reason MOTIF"
+            "  # corriger la reponse refusee sans relancer l'agent"
+        )
     if reason == "agent-failed":
         console.print(f"    devflow adaptive reconcile {issue_id}  # si la trace contient une reponse finale")
         console.print(f"    devflow check --ai {agent}")

devflow_cli/commands/verify.py

@@ -13,7 +13,8 @@ from devflow_cli.core.verification import (
     parse_validation_commands,
     run_verifications,
 )
-from devflow_cli.core.adaptive_workflow import read_adaptive_state
+from devflow_cli.commands.adaptive import refuse_if_agent_running
+from devflow_cli.core.adaptive_workflow import read_adaptive_state, workflow_lock
 from devflow_cli.core.automatic_evidence import run_automatic_verification
 from devflow_cli.utils.console import console, fail, ok, warn
 from devflow_cli.utils.paths import project_root_for_feature, resolve_feature_dir
@@ -44,6 +45,8 @@ def verify(
                 "ISSUE_ID VAL-ID --reason MOTIF."
             )
             raise typer.Exit(1)
+        with workflow_lock(feature_dir):
+            refuse_if_agent_running(feature_dir)
         outcome = run_automatic_verification(
             feature_dir, project_root_for_feature(feature_dir)
         )