devflow-cli 8.0.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 = "8.0.0"
+VERSION = "8.1.0"
 
 SUPPORTED_AGENTS = ["claude-code", "codex", "cursor"]
 

devflow_cli/commands/adaptive.py

@@ -38,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,
@@ -62,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
@@ -215,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:
@@ -257,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 "")
@@ -288,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)
@@ -463,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,
@@ -481,8 +488,10 @@ def run_adaptive(
                 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(
@@ -569,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,
@@ -615,8 +627,10 @@ def reconcile_adaptive(
             f"Prochaine : {outcome.nextActivity}"
         )
         _print_warnings(outcome.warnings)
+        _print_pending_approvals(feature_dir, 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)
     if outcome.reason in BASE_REFUSALS:
         fail(outcome.detail)
     else:
@@ -625,6 +639,9 @@ def reconcile_adaptive(
             + (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(
@@ -650,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()
@@ -693,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 "
@@ -726,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))}")
@@ -767,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
@@ -794,6 +818,7 @@ 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(
@@ -823,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)
@@ -856,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))
@@ -874,20 +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, ...] = (),
+    *, warnings: tuple[str, ...] = (), recovery: dict | None = None,
 ) -> None:
-    typer.echo(json.dumps({
+    payload = {
         "schemaVersion": 1,
         "issueId": issue_id,
         "activity": activity,
@@ -897,7 +1089,10 @@ def _print_execution_json(
         "nextActivity": next_activity,
         "exitCode": int(exit_code),
         "warnings": list(warnings),
-    }, ensure_ascii=False))
+    }
+    if recovery is not None:
+        payload["recovery"] = recovery
+    typer.echo(json.dumps(payload, ensure_ascii=False))
 
 
 def _print_warnings(warnings: tuple[str, ...]) -> None:
@@ -978,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:
@@ -1204,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)
         )

devflow_cli/core/activity_base.py

@@ -44,6 +44,7 @@ RUNTIME_FILE_NAMES = frozenset({
     "workflow-state.json", ".workflow-state.lock", "activity-contract.json",
     "agent-execution.json", "worklog.md", "reopen-log.json", "attempt-discard-log.json",
     "reconcile-log.json", "validation-approvals.json", "waivers.json", "verification.json",
+    ".agent-run.lock",
 })
 RUNTIME_FILE_SUFFIXES = ("-result.json", "-attempt.json", ".raw.txt")
 RUNTIME_DIRECTORIES = ("attempts", "evidence")