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

devflow_cli/__init__.py

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

devflow_cli/adapters/agents.py

@@ -22,6 +22,24 @@ from devflow_cli.adapters.linear import environment_without_linear_key
 PermissionMode = Literal["auto", "acceptEdits", "manual"]
 SandboxMode = Literal["read-only", "workspace-write"]
 
+# L'agent a termine sans erreur (code 0) mais sa sortie structuree manque ou n'est
+# pas le JSON attendu. Claude porte le diagnostic dedie ; Codex et Cursor gardent
+# leurs valeurs detaillees, traitees comme la meme famille par la reprise guidee.
+STRUCTURED_OUTPUT_MISSING = "structured-output-missing"
+MISSING_STRUCTURED_OUTPUT_DIAGNOSTICS = frozenset({
+    STRUCTURED_OUTPUT_MISSING,
+    "final-output-empty",
+    "final-output-absent",
+    "final-output-invalid-json",
+})
+STRUCTURED_OUTPUT_MISSING_MESSAGE = (
+    "l'agent a termine sans erreur mais sa sortie structuree manque "
+    "ou n'est pas le JSON attendu"
+)
+# Impose le premier plan aux sous-agents de l'agent Claude d'une activite ; desactive
+# aussi ses commandes shell en arriere-plan.
+CLAUDE_FOREGROUND_ENV = "CLAUDE_CODE_DISABLE_BACKGROUND_TASKS"
+
 _SAFE_DIAGNOSTIC_MESSAGES = {
     "final-output-empty": "--output-last-message est vide",
     "final-output-absent": "--output-last-message est absent",
@@ -165,7 +183,7 @@ class AgentAdapter(ABC):
                 capture_output=True,
                 stdin=subprocess.DEVNULL,
                 shell=False,
-                env=environment_without_linear_key(),
+                env=self.structured_environment(),
             )
             execution = AgentExecution(
                 result.returncode,
@@ -223,7 +241,9 @@ class AgentAdapter(ABC):
                 "Sortie structuree invalide "
                 f"({self.name}) [{diagnostic}]"
                 + (
-                    f" : {_SAFE_DIAGNOSTIC_MESSAGES[diagnostic]}"
+                    f" : {self.missing_output_message(execution.stdout)}"
+                    if diagnostic == STRUCTURED_OUTPUT_MISSING
+                    else f" : {_SAFE_DIAGNOSTIC_MESSAGES[diagnostic]}"
                     if diagnostic in _SAFE_DIAGNOSTIC_MESSAGES
                     else ""
                 ),
@@ -251,6 +271,27 @@ class AgentAdapter(ABC):
         except FileNotFoundError:
             return AgentExecution(127, stderr=f"Executable '{self.executable}' introuvable", duration_seconds=time.monotonic() - started)
 
+    def structured_environment(self) -> dict[str, str]:
+        """Environnement de l'agent d'une activite : jamais la cle Linear."""
+        return environment_without_linear_key()
+
+    def subagent_counts(self, stdout: str) -> tuple[int | None, int | None]:
+        """Sous-agents lances et lances en arriere-plan ; None si l'agent ne le dit pas."""
+        return None, None
+
+    def missing_output_message(self, stdout: str) -> str:
+        """Cause d'une sortie structuree absente : message fixe et entiers seulement."""
+        try:
+            spawned, background = self.subagent_counts(stdout)
+        except Exception:  # noqa: BLE001 - format externe non contractuel
+            spawned, background = None, None
+        message = STRUCTURED_OUTPUT_MISSING_MESSAGE
+        if spawned is not None:
+            message += f" ; sous-agents lances : {spawned}"
+            if background is not None:
+                message += f", dont {background} en arriere-plan"
+        return message
+
     def session_id(self, stdout: str, stderr: str) -> str | None:
         """Extrait un identifiant opaque de session, sans conserver la sortie."""
         return _session_id(stdout, stderr)
@@ -326,8 +367,23 @@ class ClaudeCodeAdapter(AgentAdapter):
             return envelope["structured_output"]
         result = envelope.get("result")
         if isinstance(result, str) and result.strip():
-            return json.loads(_strip_json_fence(result))
-        raise ValueError("champ structured_output absent")
+            try:
+                return json.loads(_strip_json_fence(result))
+            except json.JSONDecodeError:
+                pass
+        raise StructuredOutputError(
+            STRUCTURED_OUTPUT_MISSING, "champ structured_output absent"
+        )
+
+    def structured_environment(self) -> dict[str, str]:
+        return {**environment_without_linear_key(), CLAUDE_FOREGROUND_ENV: "1"}
+
+    def subagent_counts(self, stdout: str) -> tuple[int | None, int | None]:
+        envelope = json.loads(stdout)
+        stats = envelope.get("subagent_stats") if isinstance(envelope, dict) else None
+        if not isinstance(stats, dict):
+            return None, None
+        return _count(stats.get("spawned")), _count(stats.get("started_in_background"))
 
     def usage(self, stdout: str, session_id: str | None) -> AgentUsage | None:
         """Lit l'enveloppe --output-format json : usage cumule de tous les tours."""
@@ -515,6 +571,14 @@ def get_agent_adapter(name: str) -> AgentAdapter:
     return adapter_type()
 
 
+def describe_missing_output(agent: str, stdout: str) -> str:
+    """Cause d'une sortie structuree absente, pour la reprise guidee."""
+    try:
+        return get_agent_adapter(agent).missing_output_message(stdout)
+    except ValueError:
+        return STRUCTURED_OUTPUT_MISSING_MESSAGE
+
+
 def _portable_prompt(prompt: str) -> str:
     """Traduit une slash-command Claude en instruction portable pour les autres agents."""
     match = re.fullmatch(r"/devflow\.([a-z0-9-]+)(?:\s+(.*))?", prompt.strip())
@@ -610,6 +674,10 @@ def _int(value: object) -> int:
     return value if isinstance(value, int) and not isinstance(value, bool) else 0
 
 
+def _count(value: object) -> int | None:
+    return value if isinstance(value, int) and not isinstance(value, bool) else None
+
+
 def _codex_home() -> Path:
     return Path(os.environ.get("CODEX_HOME") or Path.home() / ".codex")
 

devflow_cli/commands/adaptive.py

@@ -70,9 +70,20 @@ from devflow_cli.core.validation_approvals import (
 )
 from devflow_cli.core.contract_schemas import LegacySchemaError, diagnose_contract_file
 from devflow_cli.core.operational import ExitCode, exit_code_for_run_reason
-from devflow_cli.adapters.agents import get_agent_adapter
+from devflow_cli.core.result_template import (
+    remove_result_template,
+    write_result_template,
+)
+from devflow_cli.adapters.agents import (
+    MISSING_STRUCTURED_OUTPUT_DIAGNOSTICS,
+    STRUCTURED_OUTPUT_MISSING,
+    StructuredOutputError,
+    describe_missing_output,
+    get_agent_adapter,
+)
 from devflow_cli.utils.console import console, fail, ok, warn
 from devflow_cli.utils.paths import (
+    activity_attempt_file,
     activity_raw_file,
     activity_result_file,
     project_root_for_feature,
@@ -476,6 +487,7 @@ def run_adaptive(
         json_output=json_output,
     )
     if outcome.advanced:
+        remove_result_template(current_state.issueId, outcome.activity)
         if json_output:
             _print_execution_json(
                 current_state.issueId, outcome.activity, True, outcome.reason,
@@ -493,11 +505,25 @@ def run_adaptive(
     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)
+    execution = attempt.get("execution")
+    recovery = (
+        _missing_output_recovery(
+            feature_dir, current_state.issueId, outcome.activity, agent,
+            execution.stdout,
+            mutated=outcome.reason == "agent-failed-after-mutation",
+        )
+        if outcome.reason in {"agent-failed", "agent-failed-after-mutation"}
+        and execution is not None
+        and execution.final_output_diagnostic in MISSING_STRUCTURED_OUTPUT_DIAGNOSTICS
+        else None
+    )
+    if outcome.reason == "preflight-evidence-stale":
+        recovery = _stale_preflight_recovery(current_state)
     if json_output:
         _print_execution_json(
             current_state.issueId, outcome.activity, False, outcome.reason,
             outcome.detail, outcome.nextActivity, exit_code,
-            warnings=outcome.warnings,
+            warnings=outcome.warnings, recovery=recovery,
         )
     elif outcome.reason in BASE_REFUSALS:
         fail(outcome.detail)
@@ -509,7 +535,8 @@ def run_adaptive(
             f"  Activite '{outcome.activity}' non validee : {outcome.reason}"
         )
         _print_run_recovery(
-            current_state.issueId, outcome.reason, outcome.activity, agent, feature_dir
+            current_state.issueId, outcome.reason, outcome.activity, agent, feature_dir,
+            recovery=recovery,
         )
     raise typer.Exit(int(exit_code))
 
@@ -611,8 +638,18 @@ def reconcile_adaptive(
         fail("--reason ne peut etre utilise qu'avec --result")
         raise typer.Exit(int(ExitCode.USAGE))
 
+    missing_output: dict[str, str] = {}
+
     def recover(agent: str, raw_output: str) -> object:
-        return get_agent_adapter(agent).recover_structured_payload(raw_output)
+        try:
+            return get_agent_adapter(agent).recover_structured_payload(raw_output)
+        except (json.JSONDecodeError, StructuredOutputError) as exc:
+            if (
+                isinstance(exc, json.JSONDecodeError)
+                or exc.diagnostic in MISSING_STRUCTURED_OUTPUT_DIAGNOSTICS
+            ):
+                missing_output.update(agent=agent, raw=raw_output)
+            raise
 
     outcome = reconcile_current_activity(
         feature_dir,
@@ -628,9 +665,29 @@ def reconcile_adaptive(
         )
         _print_warnings(outcome.warnings)
         _print_pending_approvals(feature_dir, state.issueId, outcome.activity)
+        remove_result_template(state.issueId, outcome.activity)
         return
     if outcome.reason != "agent-running":  # worklog.md : fichier d'execution (B4)
         safe_refresh_worklog(feature_dir)
+    if (
+        result is None
+        and outcome.reason == "invalid-result"
+        and missing_output
+        and _last_run_missed_structured_output(feature_dir, outcome.activity)
+    ):
+        # Trace sans reponse structuree : message actionnable, pas l'erreur de lecture.
+        recovery = _missing_output_recovery(
+            feature_dir, state.issueId, outcome.activity,
+            missing_output["agent"], missing_output["raw"],
+        )
+        fail(
+            f"Reconciliation de '{outcome.activity}' refusee : {outcome.reason} "
+            f"({STRUCTURED_OUTPUT_MISSING})"
+        )
+        _print_warnings(outcome.warnings)
+        console.print("  Reprise guidee :")
+        _print_recovery_steps(recovery)
+        raise typer.Exit(int(exit_code_for_run_reason(outcome.reason)))
     if outcome.reason in BASE_REFUSALS:
         fail(outcome.detail)
     else:
@@ -643,7 +700,10 @@ def reconcile_adaptive(
         console.print("  Suite : attendez la fin de l'activite en cours, puis relancez.")
         raise typer.Exit(int(exit_code_for_run_reason(outcome.reason)))
     console.print(f"  Suite : devflow adaptive status {state.issueId}")
-    if outcome.reason == "reconcile-refused":
+    if (
+        outcome.reason == "reconcile-refused"
+        and activity_attempt_file(feature_dir, outcome.activity).is_file()
+    ):
         console.print(
             f"  Abandon audite : devflow adaptive discard-attempt {state.issueId} --reason MOTIF"
         )
@@ -883,7 +943,8 @@ def _execute_local_verification(
         sync_activity_status(issue_id, "verify", stream)
     outcome = run_automatic_verification(feature_dir, project_root, refresh=refresh)
     recovery = (
-        None if outcome.passed else _verify_recovery(feature_dir, issue_id, outcome)
+        None if outcome.passed
+        else _verify_recovery(feature_dir, issue_id, outcome, refresh=refresh)
     )
     if json_output:
         _print_execution_json(
@@ -900,6 +961,8 @@ def _execute_local_verification(
             ok(f"Preuves de verify rafraichies. Activite courante : {outcome.nextActivity}")
         else:
             ok(f"Preuves generees et validees. Prochaine : {outcome.nextActivity}")
+        if outcome.detail:
+            console.print(f"  Motif : {outcome.detail}", markup=False, soft_wrap=True)
         return
     fail(outcome.detail or outcome.reason)
     console.print(f"  Verification automatique refusee : {outcome.reason}")
@@ -922,17 +985,20 @@ PLANNED_PREFIXES = {"PREP-": "prepare", "PLAN-": "plan"}
 
 
 def _verify_recovery(
-    feature_dir: Path, issue_id: str, outcome: AutomaticVerificationOutcome
+    feature_dir: Path, issue_id: str, outcome: AutomaticVerificationOutcome,
+    *, refresh: bool = False,
 ) -> dict:
     """Reprise guidee d'un refus de verify, par motif, sans heuristique (B2).
 
     Approbation manquante : chaque approve-command puis verify. Executable introuvable
-    (code 127) : corriger l'environnement puis verify. Echec d'un controle : deux voies,
-    le code (reopen implement) ou la validation (reopen de l'activite qui l'a inscrite).
+    (code 127) : corriger l'environnement puis verify. Echec d'un controle : trois voies,
+    le code (reopen implement), la validation (reopen de l'activite qui l'a inscrite) ou
+    un echec passager (relancer verify). Apres un verify --refresh refuse, toutes les
+    commandes verify portent --refresh.
     """
     issue = shlex.quote(issue_id)
     verify_command = {
-        "command": f"devflow adaptive verify {issue}",
+        "command": f"devflow adaptive verify {issue}" + (" --refresh" if refresh else ""),
         "purpose": "relancer la verification",
     }
     state = read_adaptive_state(feature_dir / "workflow-state.json")
@@ -1010,6 +1076,13 @@ def _verify_recovery(
             "command": f"devflow adaptive reopen {issue} {origin} --reason {reason_text}",
             "purpose": f"voie 2 : la validation {names}, inscrite par {origin}, est en cause",
         })
+    commands.append({
+        "command": verify_command["command"],
+        "purpose": (
+            "voie 3 : echec passager (reseau, conteneur, service externe), "
+            "relancer la verification"
+        ),
+    })
     return {
         "kind": "check-failed",
         "summary": (
@@ -1194,8 +1267,10 @@ def _operational_status(
     risks = _remaining_risks(feature_dir)
     if not isinstance(blockers, list):
         blockers = []
-    stale = set(stale_devflow_evidence(feature_dir, state))
-    stale.update(stale_review_evidence(feature_dir, state))
+    stale: set[str] = set()
+    if state.status != "completed":  # aucune gate ne consulte la peremption apres done
+        stale.update(stale_devflow_evidence(feature_dir, state))
+        stale.update(stale_review_evidence(feature_dir, state))
     evidence = [
         {
             "id": evidence_id,
@@ -1372,8 +1447,128 @@ def _fallback_agents(agent: str) -> list[str]:
     ]
 
 
+def _last_run_missed_structured_output(feature_dir: Path, activity: str) -> bool:
+    """Vrai si la derniere execution de l'activite a fini sans sortie structuree."""
+    try:
+        audit = json.loads(
+            (feature_dir / "agent-execution.json").read_text(encoding="utf-8")
+        )
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return False
+    return (
+        isinstance(audit, dict)
+        and audit.get("activity") == activity
+        and audit.get("finalOutputDiagnostic") in MISSING_STRUCTURED_OUTPUT_DIAGNOSTICS
+    )
+
+
+def _missing_output_recovery(
+    feature_dir: Path, issue_id: str, activity: str, agent: str, raw_output: str,
+    *, mutated: bool | None = None,
+) -> dict:
+    """Reprise guidee d'une sortie structuree absente apres un agent termine sans erreur.
+
+    Le modele prerempli (contrat courant, fichiers observes depuis la base) est ecrit
+    hors du depot ; ses champs a completer sont vides, donc refuses tels quels.
+    """
+    issue = shlex.quote(issue_id)
+    cause = describe_missing_output(agent, raw_output)
+    recovery: dict = {
+        "kind": STRUCTURED_OUTPUT_MISSING,
+        "summary": f"Sortie structuree absente : {cause}.",
+        "resultTemplate": None,
+        "commands": [],
+    }
+    if activity not in MANUAL_RECONCILIATION_ACTIVITIES:
+        recovery["commands"].append({
+            "command": f"devflow adaptive run {issue} --agent {shlex.quote(agent)}",
+            "purpose": "relancer l'agent : la correction manuelle est interdite pour cette activite",
+        })
+        return recovery
+    try:
+        attempt = json.loads(
+            activity_attempt_file(feature_dir, activity).read_text(encoding="utf-8")
+        )
+        if mutated is None:  # reconcile : le motif vient de la fiche de tentative
+            mutated = attempt["reason"] == "agent-failed-after-mutation"
+        contract = json.loads(
+            (feature_dir / "activity-contract.json").read_text(encoding="utf-8")
+        )
+        if (
+            contract["activity"] != activity
+            or contract["contractId"] != attempt["contractId"]
+        ):
+            raise ValueError("contrat et tentative incoherents")
+        template = write_result_template(
+            issue_id,
+            activity,
+            contract["contractId"],
+            contract["expectedOutput"],
+            sorted(attempt["observedFiles"]),
+        )
+    except (OSError, UnicodeDecodeError, KeyError, TypeError, ValueError):
+        template = None
+    if template is not None:
+        recovery["resultTemplate"] = str(template)
+    recovery["commands"].extend([
+        {
+            "command": "git status --short",
+            "purpose": "inspecter les ecritures deja effectuees",
+        },
+        {
+            "command": (
+                f"devflow adaptive reconcile {issue} --result "
+                f"{shlex.quote(str(template)) if template else 'FICHIER.json'} --reason MOTIF"
+            ),
+            "purpose": (
+                "completer le modele prerempli (status, summary, checks, evidence) "
+                "puis valider sans relancer l'agent"
+                if template
+                else "modele prerempli non ecrit : fournir le resultat du contrat"
+            ),
+        },
+    ])
+    if not mutated:
+        # Apres des ecritures, la relance contredirait « reconciliez d'abord ».
+        recovery["commands"].append({
+            "command": f"devflow adaptive run {issue} --agent {shlex.quote(agent)}",
+            "purpose": "relancer l'agent : il n'a rien ecrit, la tentative est remplacee",
+        })
+    return recovery
+
+
+def _stale_preflight_recovery(state: AdaptiveWorkflowState) -> dict:
+    """Reprise guidee d'une preuve de pre-vol perimee au lancement d'implement."""
+    issue = shlex.quote(state.issueId)
+    if _reopenable(state, "preflight-evidence"):
+        command = {
+            "command": f"devflow adaptive reopen {issue} preflight-evidence --reason MOTIF",
+            "purpose": "refaire la preuve de pre-vol sur les entrees actuelles",
+        }
+    else:
+        command = {
+            "command": f"devflow adaptive status {issue}",
+            "purpose": "consulter l'etat du parcours",
+        }
+    return {
+        "kind": "preflight-evidence-stale",
+        "summary": "Preuve de pre-vol perimee : la refaire avant implement.",
+        "commands": [command],
+    }
+
+
+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 step in recovery["commands"]:
+        console.print(
+            f"    {step['command']}  # {step['purpose']}", markup=False, soft_wrap=True
+        )
+
+
 def _print_run_recovery(
-    issue_id: str, reason: str, activity: str, agent: str, feature_dir: Path
+    issue_id: str, reason: str, activity: str, agent: str, feature_dir: Path,
+    *, recovery: dict | None = None,
 ) -> None:
     console.print("  Reprise guidee :")
     console.print(f"    devflow adaptive status {issue_id}")
@@ -1382,6 +1577,11 @@ def _print_run_recovery(
             "    Trace agent : "
             f"{activity_raw_file(feature_dir, activity).name}"
         )
+    if recovery is not None:
+        if reason == "agent-failed-after-mutation":
+            console.print("    Ne relancez pas automatiquement l'agent : reconciliez d'abord les changements partiels.")
+        _print_recovery_steps(recovery)
+        return
     if reason == "agent-unavailable":
         console.print("    Agent indisponible : l'activite reste courante et rien n'est invalide.")
         console.print(f"    devflow check --ai {agent} --live  # verifier le retour de l'agent")

devflow_cli/commands/assess.py

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

devflow_cli/core/activity_contracts.py

@@ -43,10 +43,20 @@ DOCUMENT_ACTIVITIES = set(DOCUMENT_ARTIFACTS)
 ActivityStatus = Literal["completed", "blocked"]
 
 REMOVED_RESULT_FIELDS = ("omissionRecommendations", "reviewedOmissions")
+# Commune a tous les contrats et a tous les agents : un sous-agent en arriere-plan
+# force l'agent a rendre la main avant sa sortie structuree, qui ne s'envoie qu'une fois.
+SUBAGENT_CONSTRAINT = (
+    "Si des sous-agents sont utilises, les lancer au premier plan, jamais en "
+    "arriere-plan, et attendre qu'ils soient tous termines avant la sortie structuree. "
+    "La sortie structuree du contrat est le dernier message de l'agent : ne rien "
+    "envoyer apres elle."
+)
 PROTECTED_VALIDATION_CONSTRAINT = (
     "Les garde-fous sont actifs : inclure dans validationPlan au moins une validation "
     "bloquante explicitement consacree a la securite, aux donnees, a l'authentification, "
-    "a une migration ou au rollback, dont id ou purpose contient l'un de ces termes."
+    "a une migration ou au rollback, dont id ou purpose contient l'un de ces termes. "
+    "Toute validation protegee est bloquante et doit reussir en code 0 : une recherche "
+    "dont l'absence de correspondance est le resultat attendu ne s'exprime pas ainsi."
 )
 
 PREFLIGHT_HEADINGS = (
@@ -170,6 +180,10 @@ def validate_need_statement(path: Path) -> None:
         raise ValueError(f"{NEED_STATEMENT} est vide : decrivez le besoin avant de demarrer")
 
 
+class PreflightEvidenceStaleError(ValueError):
+    """Preuve de pre-vol anterieure a une entree : motif de refus dedie."""
+
+
 def validate_preflight_evidence(path: Path, *, newer_than: list[Path] | None = None) -> None:
     """Validate the V4 preflight artifact without exporting its contents."""
     try:
@@ -197,7 +211,7 @@ def validate_preflight_evidence(path: Path, *, newer_than: list[Path] | None = N
         artifact_mtime = path.stat().st_mtime_ns
         stale_inputs = [item.name for item in newer_than if item.is_file() and item.stat().st_mtime_ns > artifact_mtime]
         if stale_inputs:
-            raise ValueError("preuve de pre-vol desuete apres : " + ", ".join(sorted(stale_inputs)))
+            raise PreflightEvidenceStaleError("preuve de pre-vol desuete apres : " + ", ".join(sorted(stale_inputs)))
 
 
 def build_activity_contract(
@@ -244,6 +258,7 @@ def build_activity_contract(
         "Signaler tout blocage au lieu de contourner une validation.",
         "Dans checks, status vaut passed si et seulement si exitCode vaut 0. Une commande dont l'absence de resultat constitue le succes attendu doit etre declaree failed, ou remplacee par une commande qui renvoie 0 en cas de succes.",
         "Donner un id stable a chaque objectif de check. Si un check echoue puis est corrige et relance pour le meme objectif, reutiliser cet id : seule la derniere tentative fait foi ; signaler dans remainingRisks toute instabilite encore pertinente.",
+        SUBAGENT_CONSTRAINT,
     ]
     if activity in DOCUMENT_ACTIVITIES:
         artifact_name = document_artifact_name(activity, reopened=reopened)

devflow_cli/core/adaptive_runner.py

@@ -6,6 +6,7 @@ import hashlib
 import json
 import os
 import re
+import shlex
 import tempfile
 from contextlib import ExitStack
 from dataclasses import dataclass, replace
@@ -18,6 +19,7 @@ from devflow_cli.core.activity_contracts import (
     ActivityResult,
     DOCUMENT_ARTIFACTS,
     NEED_STATEMENT,
+    PreflightEvidenceStaleError,
     build_activity_contract,
     contract_is_reopened_plan,
     document_artifact_name,
@@ -155,6 +157,13 @@ def run_current_activity(
             return AdaptiveRunOutcome(
                 exc.reason, state.currentActivity, state.currentActivity, str(exc)
             )
+        except PreflightEvidenceStaleError as exc:
+            return AdaptiveRunOutcome(
+                "preflight-evidence-stale",
+                state.currentActivity,
+                state.currentActivity,
+                str(exc),
+            )
         except (OSError, ValueError) as exc:
             return AdaptiveRunOutcome(
                 "unsupported-activity", state.currentActivity, state.currentActivity, str(exc)
@@ -337,9 +346,18 @@ def reconcile_current_activity(
                     raise ValueError("le resultat corrige doit etre un objet JSON")
                 if not correction_reason.strip():
                     raise ValueError("un motif est obligatoire pour corriger le resultat")
-            attempt = json.loads(
-                activity_attempt_file(feature_dir, activity).read_text(encoding="utf-8")
-            )
+            try:
+                attempt_text = activity_attempt_file(feature_dir, activity).read_text(
+                    encoding="utf-8"
+                )
+            except FileNotFoundError:
+                raise ValueError(
+                    f"aucune tentative echouee a reconcilier pour '{activity}' : "
+                    "reconcile ne s'applique qu'a une tentative agent echouee ; apres "
+                    "un resultat blocked, lever le blocage puis relancer "
+                    f"devflow adaptive run {shlex.quote(state.issueId)}"
+                ) from None
+            attempt = json.loads(attempt_text)
             if not _valid_attempt(attempt):
                 raise ValueError("fiche de tentative invalide")
             agent = attempt["agent"]
@@ -733,6 +751,17 @@ def _validated_result(
                 raise ValueError(
                     f"validation {item.id}, commande : {command_label} — {exc}"
                 ) from exc
+        if contract.guardrails:
+            for item in result.validationPlan:
+                if is_protected_validation(item.id, item.purpose) and not item.blocking:
+                    raise ValueError(
+                        f"validation {item.id} : un controle protege (securite, "
+                        "donnees, authentification, migration, rollback) est toujours "
+                        "bloquant et doit reussir en code 0 ; declarer blocking a true. "
+                        "Une recherche dont l'absence de correspondance est le resultat "
+                        "attendu ne s'exprime pas ainsi : utiliser une commande qui "
+                        "renvoie 0 en cas de succes."
+                    )
         if contract.guardrails and not any(
             item.blocking and is_protected_validation(item.id, item.purpose)
             for item in result.validationPlan

devflow_cli/core/automatic_evidence.py

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

devflow_cli/core/result_template.py

@@ -0,0 +1,74 @@
+"""Modele de resultat prerempli pour ``adaptive reconcile --result``.
+
+Ecrit hors du depot, dans ``~/.devflow/reconcile/`` (ou ``DEVFLOW_HOME``), quand un
+agent a termine sans rendre sa sortie structuree. Les champs a completer sont
+laisses vides : le modele brut est refuse par les validateurs de ``reconcile``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+from devflow_cli.core.telemetry import telemetry_file
+
+
+def result_template_file(issue_id: str, activity: str) -> Path:
+    name = re.sub(r"[^A-Za-z0-9_-]", "_", f"{issue_id}-{activity}")
+    return telemetry_file().parent / "reconcile" / f"{name}-result.json"
+
+
+def result_template_payload(
+    contract_id: str, expected_output: dict[str, Any], changed_files: list[str]
+) -> dict[str, Any]:
+    """Champs requis du schema : faits connus de la CLI remplis, le reste vide."""
+    properties = expected_output.get("properties", {})
+    payload: dict[str, Any] = {}
+    for name in expected_output.get("required", []):
+        schema = properties.get(name, {})
+        if name == "contractId":
+            payload[name] = contract_id
+        elif name == "changedFiles":
+            payload[name] = changed_files
+        elif "const" in schema:
+            payload[name] = schema["const"]
+        elif schema.get("type") == "array":
+            payload[name] = []
+        elif schema.get("type") == "object":
+            payload[name] = {}
+        else:
+            payload[name] = ""
+    return payload
+
+
+def write_result_template(
+    issue_id: str,
+    activity: str,
+    contract_id: str,
+    expected_output: dict[str, Any],
+    changed_files: list[str],
+) -> Path:
+    """Ecrit le modele (dossier 0700, fichier 0600) et retourne son chemin."""
+    path = result_template_file(issue_id, activity)
+    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    path.parent.chmod(0o700)
+    content = json.dumps(
+        result_template_payload(contract_id, expected_output, changed_files),
+        indent=2,
+        ensure_ascii=False,
+    ) + "\n"
+    path.unlink(missing_ok=True)
+    descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
+        handle.write(content)
+    return path
+
+
+def remove_result_template(issue_id: str, activity: str) -> None:
+    try:
+        result_template_file(issue_id, activity).unlink(missing_ok=True)
+    except OSError:
+        pass

devflow_cli/core/waivers.py

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

devflow_cli/core/worklog.py

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

{devflow_cli-8.1.0.dist-info → devflow_cli-8.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: devflow-cli
-Version: 8.1.0
+Version: 8.3.0
 Summary: Spec-Driven Development workflow CLI
 Project-URL: Homepage, https://github.com/sopequenoteck/devflow
 Project-URL: Repository, https://github.com/sopequenoteck/devflow
@@ -45,7 +45,8 @@ Le profil fixe la route documentaire :
 
 Un bloc de garde-fous s'y ajoute quand `--data-security` est déclaré ou que
 `--risk high` : `risk-assessment` après l'évaluation, validation bloquante de
-sécurité ou de données dans le plan de validation, preuve
+sécurité ou de données dans le plan de validation (une validation protégée non
+bloquante est refusée dès `prepare` ou `plan`), preuve
 `security-or-data-check` produite par `verify`, revue `independent-review`,
 puis `rollback-check` avec `rollback-plan`. Un bloc actif impose au minimum le
 profil `standard`, ne se désactive par aucune option et interdit les
@@ -90,8 +91,11 @@ devflow adaptive status KS-123
 distinguent explicitement blocage métier, contrat invalide, panne agent,
 validation échouée et conflit concurrent ; chaque refus affiche la commande de
 reprise recommandée. Après un refus de `verify`, cette reprise dépend du motif :
-approbations à donner, environnement à corriger, ou deux voies de réouverture
-(`implement` si le code est en cause, `prepare` ou `plan` si la validation l'est).
+approbations à donner, environnement à corriger, ou trois voies après un
+contrôle échoué (rouvrir `implement` si le code est en cause, rouvrir `prepare`
+ou `plan` si la validation l'est, relancer `verify` après un échec passager).
+En `quick`, un lot purement documentaire (`README.md`, Markdown sous `docs/`)
+sans contrôle détecté franchit `verify` sur l'inspection du diff.
 
 Un plan de `prepare` ou de `plan` refusé par les validateurs se corrige sans
 relancer l'agent : `devflow adaptive reconcile KS-123 --result FICHIER.json
@@ -102,6 +106,16 @@ qu'un agent travaille, les commandes humaines qui modifieraient l'état sont
 refusées sans effet, et un fichier d'exécution modifié par l'agent est remis
 dans son état d'avant l'agent.
 
+L'agent Claude d'une activité est lancé avec
+`CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1` : il peut déléguer à des sous-agents,
+mais au premier plan seulement. Effet de bord : il ne peut plus lancer de
+commande shell en arrière-plan (serveur de test, par exemple). Tous les contrats
+demandent en plus que la sortie structurée soit le dernier message de l'agent.
+Si un agent termine sans erreur mais sans sortie structurée, `adaptive run`
+nomme la cause (`structured-output-missing`) et propose
+`devflow adaptive reconcile KS-123 --result MODELE --reason MOTIF` avec un
+modèle de résultat prérempli, écrit dans `~/.devflow/reconcile/` et à compléter.
+
 Chaque invocation de `adaptive run` traite une activité. La politique est dans
 `assessment.json`; la progression et les preuves sont dans
 `workflow-state.json`. Les résultats agent sont validés par schéma et les

{devflow_cli-8.1.0.dist-info → devflow_cli-8.3.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-devflow_cli/__init__.py,sha256=PUspBocDYmXBT3YAsO8WxkWncuo5lyBpxQRxMyBY1mY,925
+devflow_cli/__init__.py,sha256=IpmjnS3nun7PP7DJ0y0oLHgWCL8HVul9hsCpjbAVK4s,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=lq3OjcaT3Nt9-WV9Po4Dj1fag4getb7DEt9Y3Zp1js4,26683
+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=xfvjQOlBrUjZvf8NLLlaohyeUT54LhjdDCptMr_s9w8,56390
-devflow_cli/commands/assess.py,sha256=lyj6TI5hXUWX55dY589fG4bKJSMztvMPxZ0HZjo0O-w,5230
+devflow_cli/commands/adaptive.py,sha256=OdESwOyoMgySOyyLkAEk3oIkVPXS-bli_SvJe5VeHGU,64445
+devflow_cli/commands/assess.py,sha256=V-E3ft41ljCrqp2WLjR1Dqw-JtswcqsK2nD1-euNbNE,5655
 devflow_cli/commands/check.py,sha256=hsfeOg9yDOTAIvNm6XhRmTIFgv7w9wC8zvrwm4ojfZs,6923
 devflow_cli/commands/context.py,sha256=hwTitOHxIpJMx1X8R1jHHy9CpE4HVZpJKkyeOujxAio,6246
 devflow_cli/commands/docs_sync.py,sha256=Xc0mulpNTjDyeUDumKL7VNG0eumAf3016wEM_dqXpSU,1021
@@ -24,13 +24,13 @@ devflow_cli/commands/usage.py,sha256=ehH1AH5J-XfkebFx6qLBwpKN-MOoX2uUbq4LejBpNsk
 devflow_cli/commands/verify.py,sha256=GBFCfsN-xWyROCcngOANz-3ftNVeNZ4Y_JeWFo2muwE,4139
 devflow_cli/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devflow_cli/core/activity_base.py,sha256=haEVVgZAi3-iX75oo2-fK9GQZeFgN_xRw5U0Z0bdV5w,16343
-devflow_cli/core/activity_contracts.py,sha256=nbPj9dkCIG7HXrT1iwZ1m3oaUZY-V65bfC62ALuYAus,38212
-devflow_cli/core/adaptive_runner.py,sha256=MLws62PW986dd00nA4m_3Y4BAR-ZmmYT3q8N6KiPU-Q,40375
+devflow_cli/core/activity_contracts.py,sha256=n9arBw-SWEFqTlCDNed6lV4WolkZKAvmQg1qcfk57ss,39036
+devflow_cli/core/adaptive_runner.py,sha256=GRL4w9FsIPplmypPx1KUnel_byc9PVe7jkTq6Q5Uy0c,41879
 devflow_cli/core/adaptive_workflow.py,sha256=F4uV5okQpFidZmneVZwW52XAO7gAmtuBAqBO9K9q7Uk,12173
 devflow_cli/core/agent_failure.py,sha256=iX4q249lAHeVdD_ZF1aObmU-FX6sjfYP9dfLSnWGAD0,3771
 devflow_cli/core/agent_run_marker.py,sha256=QW3ScA2ZpqfQdUo5ANTbenDVyY2iHpB_wTaN6VUKlzc,3451
 devflow_cli/core/assessment.py,sha256=ACtJbXq1qZjVfeERjy8Qg6-ioLfSMUBVQm2l-mtGwgI,11522
-devflow_cli/core/automatic_evidence.py,sha256=y1f6L3tsJpV57I54zcTySetho1ASHklu5mUQF1PaRDY,40600
+devflow_cli/core/automatic_evidence.py,sha256=Ntsy2eQKLRl_hUD27V9NRBLavyhLxxkEcbPySKmd4W4,42337
 devflow_cli/core/catalog.py,sha256=nLPc78JkbISaSxJnHlWiMi_lvepaumbfwcjgLuVy7Zc,3102
 devflow_cli/core/contract_schemas.py,sha256=-7SlJCwQ31OjPfwA-tP4ctgbp9hxQAVwNvvOV09Hoho,6313
 devflow_cli/core/docgen.py,sha256=47JoVDWetkcctgHwJZC67AVebOKgl10VB9hZ3Xr63mo,3908
@@ -42,6 +42,7 @@ devflow_cli/core/manifest.py,sha256=h058_m5-HJrYsNUdgfwnKts2riHiYPXUwMzPImHOs2g,
 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=AI5fBs-F8xF3uaxgYJDNJHKxJ7V5obEtnfptMm351AU,8426
+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
 devflow_cli/core/scanner.py,sha256=bcoC91Nc0Hw2P7aHpL-9ITxynLZhLTEKpOXo553a-18,4395
@@ -51,8 +52,8 @@ devflow_cli/core/traceability.py,sha256=jfNE9MZzGkmaPer9Wa6Y18yA9Y3sqdeR-nzH9h_T
 devflow_cli/core/validation_approvals.py,sha256=3AHOpnW3BtY3BQrRZr38K7VNYRvbxGNhmQRYAufyhSA,9279
 devflow_cli/core/validators.py,sha256=fREjEx2fBW36q3vB6WJNqoGUM9ejYlQUXie5A9lNuPs,7440
 devflow_cli/core/verification.py,sha256=rvbdAdLyrZYb20oauti7D8nV5TDFBIf_8-hqLahfRag,23576
-devflow_cli/core/waivers.py,sha256=xpfSiC4K51ZVlBOZTRNJ5ftS05-bsLyMW-W9CdQHqH4,11595
-devflow_cli/core/worklog.py,sha256=ECmGJL63eVwfKQl94-r-Zd56ubhApuufAqDq1h5xcAU,13854
+devflow_cli/core/waivers.py,sha256=9XXzMmoWCn-2Dc3486WhZwtGJQLQPXjP0qAaLuL_3qU,13299
+devflow_cli/core/worklog.py,sha256=GkaXCsx22jntcWuC75OystUoqb5AlzBbXXLYH581Mwg,14164
 devflow_cli/core/worktree_snapshot.py,sha256=Q2_KTkhJTGvdM6Ay4RK9OHkyPEMrHQRTb-f-Eptek-8,5255
 devflow_cli/schemas/activity-contract-v4.schema.json,sha256=IeduWDiJ5IV6EL7FDZWnHBjzyUt1uwig2rB-SMbcpOU,2006
 devflow_cli/schemas/activity-result-v1.schema.json,sha256=xQuyD5fwHGIdeoJoDJxJn26qBGJX74lD6Dc5gi5CLQo,2772
@@ -89,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.1.0.dist-info/METADATA,sha256=anR27a2QLBDXONlC1oDcaDdTlxzx12qoqEmCBOxCouk,7809
-devflow_cli-8.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-devflow_cli-8.1.0.dist-info/entry_points.txt,sha256=GVJ6bMvFpqyO5589iC4nFKeGTpGIW8aKn_QPPpSZ6kU,48
-devflow_cli-8.1.0.dist-info/licenses/LICENSE,sha256=v79PvnmqOdKhQiOa_QcWxng4q8GuGscLOwi7ygUpwpo,1070
-devflow_cli-8.1.0.dist-info/RECORD,,
+devflow_cli-8.3.0.dist-info/METADATA,sha256=8ck7BHBw2l01PS43k3pKc2d79l719w4YcK6RjUESOp0,8772
+devflow_cli-8.3.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+devflow_cli-8.3.0.dist-info/entry_points.txt,sha256=GVJ6bMvFpqyO5589iC4nFKeGTpGIW8aKn_QPPpSZ6kU,48
+devflow_cli-8.3.0.dist-info/licenses/LICENSE,sha256=v79PvnmqOdKhQiOa_QcWxng4q8GuGscLOwi7ygUpwpo,1070
+devflow_cli-8.3.0.dist-info/RECORD,,