devflow-cli 8.1.0__py3-none-any.whl → 8.2.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.2.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,22 @@ 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,
+        )
+        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 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 +532,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 +635,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 +662,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:
@@ -1372,8 +1426,99 @@ 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
+) -> 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")
+        )
+        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"
+            ),
+        },
+    ])
+    return recovery
+
+
+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 +1527,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/core/activity_contracts.py

@@ -43,6 +43,14 @@ 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, "
@@ -244,6 +252,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/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-8.1.0.dist-info → devflow_cli-8.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: devflow-cli
-Version: 8.1.0
+Version: 8.2.0
 Summary: Spec-Driven Development workflow CLI
 Project-URL: Homepage, https://github.com/sopequenoteck/devflow
 Project-URL: Repository, https://github.com/sopequenoteck/devflow
@@ -102,6 +102,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.2.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-devflow_cli/__init__.py,sha256=PUspBocDYmXBT3YAsO8WxkWncuo5lyBpxQRxMyBY1mY,925
+devflow_cli/__init__.py,sha256=Y5UdblxgAc6mD_GvD_R7nfzo_uyAi09mJw3AJoB8Stk,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/adaptive.py,sha256=kYSpQWZ-xUTw1Kquv5fE2kpFjoVClqNl4Nd7pUj7FX8,62199
 devflow_cli/commands/assess.py,sha256=lyj6TI5hXUWX55dY589fG4bKJSMztvMPxZ0HZjo0O-w,5230
 devflow_cli/commands/check.py,sha256=hsfeOg9yDOTAIvNm6XhRmTIFgv7w9wC8zvrwm4ojfZs,6923
 devflow_cli/commands/context.py,sha256=hwTitOHxIpJMx1X8R1jHHy9CpE4HVZpJKkyeOujxAio,6246
@@ -24,7 +24,7 @@ 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/activity_contracts.py,sha256=2-pjjxMyS7iER2eim118U5QSgOqwrP47X_HcfZ7jZ58,38717
 devflow_cli/core/adaptive_runner.py,sha256=MLws62PW986dd00nA4m_3Y4BAR-ZmmYT3q8N6KiPU-Q,40375
 devflow_cli/core/adaptive_workflow.py,sha256=F4uV5okQpFidZmneVZwW52XAO7gAmtuBAqBO9K9q7Uk,12173
 devflow_cli/core/agent_failure.py,sha256=iX4q249lAHeVdD_ZF1aObmU-FX6sjfYP9dfLSnWGAD0,3771
@@ -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
@@ -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.2.0.dist-info/METADATA,sha256=9zPuMV6XtqesVYitXPdUdkg2KqmqP_zQ7LSRCa9jksQ,8470
+devflow_cli-8.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+devflow_cli-8.2.0.dist-info/entry_points.txt,sha256=GVJ6bMvFpqyO5589iC4nFKeGTpGIW8aKn_QPPpSZ6kU,48
+devflow_cli-8.2.0.dist-info/licenses/LICENSE,sha256=v79PvnmqOdKhQiOa_QcWxng4q8GuGscLOwi7ygUpwpo,1070
+devflow_cli-8.2.0.dist-info/RECORD,,