devflow-cli 2.8.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

devflow_cli/__init__.py

@@ -1,6 +1,6 @@
 """devflow CLI — Spec-Driven Development workflow."""
 
-VERSION = "2.8.0"
+VERSION = "2.9.0"
 STATE_SCHEMA_VERSION = 3
 
 STEPS = [
@@ -72,7 +72,7 @@ STEP_LINEAR_ORDER = [
     "Done",
 ]
 
-SUPPORTED_AGENTS = ["claude-code", "cursor"]
+SUPPORTED_AGENTS = ["claude-code", "codex", "cursor"]
 
 # Mapping speckit → devflow pour la migration
 SPECKIT_STEP_MAP = {

devflow_cli/adapters/agents.py

@@ -11,6 +11,7 @@ from typing import Literal
 
 
 PermissionMode = Literal["auto", "acceptEdits", "manual"]
+SandboxMode = Literal["read-only", "workspace-write"]
 
 
 @dataclass(frozen=True)
@@ -34,6 +35,16 @@ class AgentAdapter(ABC):
     def build_named_agent_command(self, agent_name: str, prompt: str) -> list[str]:
         raise ValueError(f"L'adaptateur {self.name} ne supporte pas les agents nommés")
 
+    def build_structured_command(
+        self,
+        prompt: str,
+        permission_mode: PermissionMode,
+        schema_file: Path,
+        output_file: Path,
+        sandbox_mode: SandboxMode = "workspace-write",
+    ) -> list[str]:
+        raise ValueError(f"L'adaptateur {self.name} ne supporte pas les sorties structurees")
+
     def execute(
         self,
         prompt: str,
@@ -68,6 +79,43 @@ class AgentAdapter(ABC):
         except FileNotFoundError:
             return AgentExecution(127, stderr=f"Executable '{self.executable}' introuvable")
 
+    def execute_structured(
+        self,
+        prompt: str,
+        cwd: Path,
+        timeout: int,
+        schema_file: Path,
+        output_file: Path,
+        permission_mode: PermissionMode = "auto",
+        sandbox_mode: SandboxMode = "workspace-write",
+    ) -> AgentExecution:
+        command = self.build_structured_command(
+            prompt, permission_mode, schema_file, output_file, sandbox_mode
+        )
+        try:
+            result = subprocess.run(
+                command,
+                cwd=cwd,
+                timeout=timeout,
+                text=True,
+                capture_output=True,
+                shell=False,
+            )
+            return AgentExecution(
+                result.returncode,
+                result.stdout or "",
+                result.stderr or "",
+            )
+        except subprocess.TimeoutExpired as exc:
+            return AgentExecution(
+                124,
+                _text(exc.stdout),
+                _text(exc.stderr),
+                timed_out=True,
+            )
+        except FileNotFoundError:
+            return AgentExecution(127, stderr=f"Executable '{self.executable}' introuvable")
+
 
 class ClaudeCodeAdapter(AgentAdapter):
     name = "claude-code"
@@ -91,12 +139,36 @@ class CodexAdapter(AgentAdapter):
     executable = "codex"
 
     def build_command(self, prompt: str, permission_mode: PermissionMode) -> list[str]:
-        command = [self.executable, "exec", "--sandbox", "workspace-write"]
+        command = [self.executable, "exec"]
         if permission_mode in {"auto", "acceptEdits"}:
             command.append("--approve-for-me")
+        else:
+            command.extend(["--sandbox", "workspace-write"])
         command.append(_portable_prompt(prompt))
         return command
 
+    def build_structured_command(
+        self,
+        prompt: str,
+        permission_mode: PermissionMode,
+        schema_file: Path,
+        output_file: Path,
+        sandbox_mode: SandboxMode = "workspace-write",
+    ) -> list[str]:
+        command = [self.executable, "exec"]
+        if permission_mode in {"auto", "acceptEdits"} and sandbox_mode == "workspace-write":
+            command.append("--approve-for-me")
+        else:
+            command.extend(["--sandbox", sandbox_mode])
+        command.extend([
+            "--output-schema",
+            str(schema_file),
+            "--output-last-message",
+            str(output_file),
+        ])
+        command.append(prompt)
+        return command
+
 
 class CursorAdapter(AgentAdapter):
     name = "cursor"

devflow_cli/cli.py

@@ -22,10 +22,12 @@ from devflow_cli.commands import hooks_cmd
 from devflow_cli.commands import linear
 from devflow_cli.commands import review
 from devflow_cli.commands import step
+from devflow_cli.commands import adaptive
 from devflow_cli.commands.run import run
 from devflow_cli.commands.docs_sync import docs_sync
 from devflow_cli.commands.traceability import traceability
 from devflow_cli.commands.verify import verify
+from devflow_cli.commands.assess import assess
 
 app = typer.Typer(
     name="devflow",
@@ -65,10 +67,12 @@ app.add_typer(hooks_cmd.app, name="hooks")
 app.add_typer(linear.app, name="linear")
 app.add_typer(step.app, name="step")
 app.add_typer(review.app, name="review")
+app.add_typer(adaptive.app, name="adaptive")
 app.command()(run)
 app.command(name="docs-sync")(docs_sync)
 app.command()(traceability)
 app.command()(verify)
+app.command()(assess)
 
 
 if __name__ == "__main__":

devflow_cli/commands/adaptive.py

@@ -0,0 +1,357 @@
+"""Commandes de transition du workflow adaptatif."""
+
+from __future__ import annotations
+
+import json
+import tempfile
+from pathlib import Path
+from typing import Literal, Optional
+
+import typer
+
+from devflow_cli.core.adaptive_workflow import (
+    complete_activity,
+    create_adaptive_workflow,
+    read_adaptive_state,
+    record_evidence,
+    workflow_lock,
+    write_adaptive_state,
+)
+from devflow_cli.core.state import read_state
+from devflow_cli.core.activity_contracts import (
+    build_activity_contract,
+    render_contract_prompt,
+    write_activity_contract,
+)
+from devflow_cli.core.adaptive_runner import (
+    AgentActivityExecution,
+    run_current_activity,
+)
+from devflow_cli.core.worktree_snapshot import changed_paths, snapshot_worktree
+from devflow_cli.core.automatic_evidence import run_automatic_verification
+from devflow_cli.core.worklog import refresh_worklog, safe_refresh_worklog
+from devflow_cli.core.waivers import create_validation_waiver
+from devflow_cli.core.remediation import carried_changed_files, reopen_activity
+from devflow_cli.adapters.agents import get_agent_adapter
+from devflow_cli.utils.console import console, fail, ok
+from devflow_cli.utils.paths import project_root_for_feature, resolve_feature_dir
+
+
+app = typer.Typer(help="Machine d'etat des parcours adaptatifs")
+
+
+def _feature(identifier: str) -> Path:
+    feature_dir = resolve_feature_dir(identifier)
+    if feature_dir is None:
+        fail(f"Feature '{identifier}' introuvable.")
+        raise typer.Exit(1)
+    return feature_dir
+
+
+def _state(feature_dir: Path):
+    state = read_adaptive_state(feature_dir / "workflow-state.json")
+    if state is None:
+        fail("workflow-state.json invalide ou absent. Lancez 'devflow adaptive start'.")
+        raise typer.Exit(1)
+    return state
+
+
+@app.command("start")
+def start(feature: str = typer.Argument(..., help="ID ou dossier de la feature")) -> None:
+    """Initialise le parcours selectionne par assessment.json."""
+    feature_dir = _feature(feature)
+    state_file = feature_dir / "workflow-state.json"
+    with workflow_lock(feature_dir):
+        if state_file.exists():
+            fail("workflow-state.json existe deja ; le workflow ne sera pas ecrase.")
+            raise typer.Exit(1)
+        try:
+            assessment = json.loads(
+                (feature_dir / "assessment.json").read_text(encoding="utf-8")
+            )
+            state = create_adaptive_workflow(assessment)
+            legacy_state = read_state(feature_dir / "state.json")
+            if legacy_state is None or legacy_state.issueId != state.issueId:
+                raise ValueError("issueId incoherent entre assessment.json et state.json")
+        except (OSError, json.JSONDecodeError, ValueError) as exc:
+            fail(f"Impossible de demarrer le workflow : {exc}")
+            raise typer.Exit(1) from exc
+        write_adaptive_state(state_file, state)
+    safe_refresh_worklog(feature_dir)
+    ok(f"Workflow {state.profile} demarre. Activite courante : {state.currentActivity}")
+
+
+@app.command("status")
+def status(feature: str = typer.Argument(..., help="ID ou dossier de la feature")) -> None:
+    """Affiche la progression et les preuves restantes."""
+    feature_dir = _feature(feature)
+    with workflow_lock(feature_dir):
+        state = _state(feature_dir)
+    missing = [item for item in state.requiredEvidence if item not in state.evidence]
+    console.print(f"Profil    : {state.profile}")
+    console.print(f"Statut    : {state.status}")
+    console.print(f"Activite  : {state.currentActivity}")
+    console.print(f"Completees: {', '.join(state.completedActivities)}")
+    console.print(f"Preuves manquantes: {', '.join(missing) if missing else 'aucune'}")
+
+
+@app.command("complete")
+def complete(
+    feature: str = typer.Argument(..., help="ID ou dossier de la feature"),
+    activity: str = typer.Argument(..., help="Activite a terminer"),
+) -> None:
+    """Complete l'activite courante si ses gates sont satisfaites."""
+    feature_dir = _feature(feature)
+    with workflow_lock(feature_dir):
+        state = _state(feature_dir)
+        try:
+            complete_activity(state, activity)
+        except ValueError as exc:
+            fail(str(exc))
+            raise typer.Exit(1) from exc
+        write_adaptive_state(feature_dir / "workflow-state.json", state)
+    safe_refresh_worklog(feature_dir)
+    if state.status == "completed":
+        ok(f"Workflow {state.profile} termine.")
+    else:
+        ok(f"Activite '{activity}' completee. Prochaine : {state.currentActivity}")
+
+
+@app.command("evidence")
+def evidence(
+    feature: str = typer.Argument(..., help="ID ou dossier de la feature"),
+    evidence_id: str = typer.Argument(..., help="Identifiant de la preuve"),
+    report: Optional[str] = typer.Option(None, help="Chemin ou resume de la preuve"),
+) -> None:
+    """Enregistre une preuve attendue par le profil."""
+    feature_dir = _feature(feature)
+    with workflow_lock(feature_dir):
+        state = _state(feature_dir)
+        try:
+            record_evidence(state, evidence_id, report or "")
+        except ValueError as exc:
+            fail(str(exc))
+            raise typer.Exit(1) from exc
+        write_adaptive_state(feature_dir / "workflow-state.json", state)
+    safe_refresh_worklog(feature_dir)
+    ok(f"Preuve '{evidence_id}' enregistree.")
+
+
+@app.command("contract")
+def contract(
+    feature: str = typer.Argument(..., help="ID ou dossier de la feature"),
+    json_output: bool = typer.Option(False, "--json", help="Affiche le contrat JSON"),
+    prompt: bool = typer.Option(False, "--prompt", help="Affiche le prompt portable"),
+) -> None:
+    """Genere le contrat portable de l'activite courante."""
+    if json_output and prompt:
+        fail("Les options --json et --prompt sont mutuellement exclusives.")
+        raise typer.Exit(1)
+    feature_dir = _feature(feature)
+    project_root = project_root_for_feature(feature_dir)
+    try:
+        feature_path = feature_dir.relative_to(project_root).as_posix()
+    except ValueError as exc:
+        fail(f"Feature hors du projet courant : {exc}")
+        raise typer.Exit(1) from exc
+
+    with workflow_lock(feature_dir):
+        state = _state(feature_dir)
+        try:
+            assessment = json.loads(
+                (feature_dir / "assessment.json").read_text(encoding="utf-8")
+            )
+            activity_contract = build_activity_contract(
+                state,
+                assessment,
+                feature_path,
+                carried_changed_files(feature_dir, state.currentActivity),
+            )
+        except (OSError, json.JSONDecodeError, ValueError) as exc:
+            fail(f"Impossible de generer le contrat : {exc}")
+            raise typer.Exit(1) from exc
+        output_file = feature_dir / "activity-contract.json"
+        write_activity_contract(output_file, activity_contract)
+
+    if json_output:
+        console.print_json(data=activity_contract.to_dict())
+    elif prompt:
+        console.print(render_contract_prompt(activity_contract), markup=False)
+    else:
+        ok(f"Contrat genere pour '{activity_contract.activity}'.")
+        console.print(f"  Contrat : {output_file}")
+        console.print(f"  ID      : {activity_contract.contractId}")
+
+
+@app.command("run")
+def run_adaptive(
+    feature: str = typer.Argument(..., help="ID ou dossier de la feature"),
+    agent: str = typer.Option("codex", help="Backend agent structure"),
+    timeout: int = typer.Option(1800, min=30, help="Timeout de l'activite en secondes"),
+    permission_mode: Literal["auto", "acceptEdits", "manual"] = typer.Option(
+        "auto", help="Mode de permissions transmis a l'agent"
+    ),
+) -> None:
+    """Execute une activite agentique ou la verification locale."""
+    feature_dir = _feature(feature)
+    project_root = project_root_for_feature(feature_dir)
+    feature_path = feature_dir.relative_to(project_root).as_posix()
+    with workflow_lock(feature_dir):
+        current_state = _state(feature_dir)
+    if current_state.currentActivity == "verify":
+        _execute_local_verification(feature_dir, project_root)
+        return
+    if current_state.currentActivity not in {
+        "prepare", "risk-assessment", "spec", "research", "contracts", "plan",
+        "tasks", "implement", "review", "rollback-check",
+    }:
+        fail(
+            f"L'activite '{current_state.currentActivity}' ne necessite pas d'agent."
+        )
+        raise typer.Exit(1)
+    try:
+        adapter = get_agent_adapter(agent)
+    except ValueError as exc:
+        fail(str(exc))
+        raise typer.Exit(1) from exc
+    if adapter.name != "codex":
+        fail("Seul l'adaptateur codex supporte actuellement les contrats structures.")
+        raise typer.Exit(1)
+
+    def execute(activity_contract) -> AgentActivityExecution:
+        prompt_text = render_contract_prompt(activity_contract)
+        try:
+            before = snapshot_worktree(project_root)
+            with tempfile.TemporaryDirectory(prefix="devflow-adaptive-") as temp_dir:
+                temp_path = Path(temp_dir)
+                schema_file = temp_path / "output-schema.json"
+                output_file = temp_path / "last-message.json"
+                schema_file.write_text(
+                    json.dumps(activity_contract.expectedOutput, ensure_ascii=False),
+                    encoding="utf-8",
+                )
+                execution = adapter.execute_structured(
+                    prompt_text,
+                    project_root,
+                    timeout,
+                    schema_file,
+                    output_file,
+                    permission_mode,
+                    "workspace-write"
+                    if "write" in activity_contract.allowedActions
+                    else "read-only",
+                )
+                output = (
+                    output_file.read_text(encoding="utf-8")
+                    if output_file.is_file()
+                    else ""
+                )
+            after = snapshot_worktree(project_root)
+            observed = tuple(changed_paths(before, after))
+        except (OSError, ValueError) as exc:
+            return AgentActivityExecution(1, stderr=str(exc))
+        return AgentActivityExecution(
+            execution.returncode,
+            output,
+            execution.stderr,
+            observed,
+            execution.timed_out,
+        )
+
+    outcome = run_current_activity(feature_dir, feature_path, execute)
+    if outcome.advanced:
+        ok(
+            f"Activite '{outcome.activity}' validee. "
+            f"Prochaine : {outcome.nextActivity}"
+        )
+        return
+    fail(
+        f"Activite '{outcome.activity}' non validee : {outcome.reason}"
+        + (f" ({outcome.detail})" if outcome.detail else "")
+    )
+    raise typer.Exit(1)
+
+
+@app.command("verify")
+def verify_adaptive(
+    feature: str = typer.Argument(..., help="ID ou dossier de la feature"),
+) -> None:
+    """Genere localement les preuves requises par le profil actif."""
+    feature_dir = _feature(feature)
+    _execute_local_verification(feature_dir, project_root_for_feature(feature_dir))
+
+
+@app.command("waive")
+def waive_validation(
+    feature: str = typer.Argument(..., help="ID ou dossier de la feature"),
+    validation_id: str = typer.Argument(..., help="Identifiant du controle echoue"),
+    reason: str = typer.Option(..., "--reason", help="Justification obligatoire"),
+    author: Optional[str] = typer.Option(None, "--author", help="Auteur de la derogation"),
+) -> None:
+    """Rend non bloquant un controle planifie echoue, avec audit durable."""
+    feature_dir = _feature(feature)
+    with workflow_lock(feature_dir):
+        try:
+            waiver = create_validation_waiver(
+                feature_dir, validation_id, reason, author=author
+            )
+        except ValueError as exc:
+            fail(str(exc))
+            raise typer.Exit(1) from exc
+    safe_refresh_worklog(feature_dir)
+    ok(
+        f"Derogation '{waiver['id']}' enregistree pour "
+        f"{waiver['commandId']}."
+    )
+
+
+@app.command("reopen")
+def reopen(
+    feature: str = typer.Argument(..., help="ID ou dossier de la feature"),
+    activity: str = typer.Argument(..., help="Activite anterieure a reprendre"),
+    reason: str = typer.Option(..., "--reason", help="Motif obligatoire"),
+    author: Optional[str] = typer.Option(None, "--author", help="Auteur du retour"),
+) -> None:
+    """Revient a une activite anterieure sans effacer l'historique."""
+    feature_dir = _feature(feature)
+    with workflow_lock(feature_dir):
+        state = _state(feature_dir)
+        try:
+            entry = reopen_activity(
+                feature_dir, state, activity, reason, author=author
+            )
+        except (OSError, ValueError) as exc:
+            fail(str(exc))
+            raise typer.Exit(1) from exc
+        write_adaptive_state(feature_dir / "workflow-state.json", state)
+    safe_refresh_worklog(feature_dir)
+    ok(
+        f"Workflow rouvert sur '{activity}' (audit #{entry['sequence']}, "
+        f"archive : {entry['archivePath']})."
+    )
+
+
+def _execute_local_verification(feature_dir: Path, project_root: Path) -> None:
+    outcome = run_automatic_verification(feature_dir, project_root)
+    if outcome.passed:
+        ok(f"Preuves generees et validees. Prochaine : {outcome.nextActivity}")
+        return
+    fail(
+        f"Verification automatique refusee : {outcome.reason}"
+        + (f" ({outcome.detail})" if outcome.detail else "")
+    )
+    raise typer.Exit(1)
+
+
+@app.command("worklog")
+def worklog(
+    feature: str = typer.Argument(..., help="ID ou dossier de la feature"),
+) -> None:
+    """Regenere le journal compact depuis les artefacts du workflow."""
+    feature_dir = _feature(feature)
+    try:
+        output = refresh_worklog(feature_dir)
+    except ValueError as exc:
+        fail(str(exc))
+        raise typer.Exit(1) from exc
+    ok(f"Worklog actualise : {output}")

devflow_cli/commands/assess.py

@@ -0,0 +1,115 @@
+"""devflow assess — Recommande un profil sans modifier le pipeline."""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Literal
+
+import typer
+
+from devflow_cli.core.assessment import AssessmentSignals, assess_feature
+from devflow_cli.core.adaptive_workflow import workflow_lock
+from devflow_cli.core.state import read_state
+from devflow_cli.utils.console import console, fail, ok
+from devflow_cli.utils.paths import resolve_feature_dir
+
+
+def assess(
+    feature: str = typer.Argument(..., help="ID ou dossier de la feature"),
+    scope: Literal["local", "multiple", "transversal"] = typer.Option(
+        "local", help="Surface du changement"
+    ),
+    ambiguity: Literal["low", "medium", "high"] = typer.Option(
+        "medium", help="Niveau d'ambiguite"
+    ),
+    risk: Literal["low", "medium", "high"] = typer.Option(
+        "medium", help="Risque d'impact"
+    ),
+    contract_change: bool = typer.Option(
+        False, "--contract-change", help="Le changement modifie un contrat"
+    ),
+    data_security: bool = typer.Option(
+        False, "--data-security", help="Le changement touche aux donnees ou a la securite"
+    ),
+    summary: str = typer.Option("", help="Resume court de la demande"),
+    profile: Literal["quick", "standard", "deep", "critical"] | None = typer.Option(
+        None, help="Force un profil au lieu de la recommandation"
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Affiche le resultat en JSON"),
+) -> None:
+    """Evalue une feature et ecrit assessment.json sans changer state.json."""
+    feature_dir = resolve_feature_dir(feature)
+    if feature_dir is None:
+        fail(f"Feature '{feature}' introuvable.")
+        raise typer.Exit(1)
+
+    state_file = feature_dir / "state.json"
+    state = read_state(state_file)
+    if state is None:
+        fail(f"state.json invalide dans {feature_dir.name}")
+        raise typer.Exit(1)
+
+    try:
+        assessment = assess_feature(
+            state.issueId,
+            AssessmentSignals(
+                scope=scope,
+                ambiguity=ambiguity,
+                risk=risk,
+                contractChange=contract_change,
+                dataOrSecurity=data_security,
+            ),
+            summary=summary,
+            profile_override=profile,
+        )
+    except ValueError as exc:
+        fail(str(exc))
+        raise typer.Exit(1) from exc
+    payload = assessment.to_dict()
+    output_file = feature_dir / "assessment.json"
+    with workflow_lock(feature_dir):
+        if (feature_dir / "workflow-state.json").exists():
+            fail("Un workflow adaptatif existe deja ; assessment.json ne sera pas ecrase.")
+            raise typer.Exit(1)
+        _write_json_atomic(output_file, payload)
+
+    if json_output:
+        console.print_json(data=payload)
+        return
+
+    ok(f"Profil selectionne : {assessment.selectedProfile}")
+    if assessment.selectedProfile != assessment.recommendedProfile:
+        console.print(f"  Recommande : {assessment.recommendedProfile}")
+    console.print(f"  Confiance : {assessment.confidence}")
+    for reason in assessment.reasons:
+        console.print(f"  - {reason}")
+    console.print(f"  Activites : {' -> '.join(assessment.activities)}")
+    console.print(f"  Preuves   : {', '.join(assessment.requiredEvidence)}")
+    console.print(f"  Rapport   : {output_file}")
+    console.print("  Pipeline  : inchange")
+
+
+def _write_json_atomic(target: Path, payload: dict) -> None:
+    """Ecrit le rapport sans laisser de JSON partiel en cas d'interruption."""
+    temporary: Path | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            dir=target.parent,
+            prefix=f".{target.name}.",
+            suffix=".tmp",
+            delete=False,
+        ) as handle:
+            temporary = Path(handle.name)
+            handle.write(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary, target)
+        temporary = None
+    finally:
+        if temporary is not None:
+            temporary.unlink(missing_ok=True)

devflow_cli/commands/check.py

@@ -23,12 +23,20 @@ def _count_files(directory: Path, pattern: str) -> int:
     return len(list(directory.glob(pattern)))
 
 
-def check() -> None:
+def check(
+    ai: str = typer.Option(
+        "claude-code", "--ai", help="Agent a verifier : claude-code ou codex"
+    ),
+) -> None:
     """Verifie les prerequis (outils, fichiers, config)."""
     ok_count = 0
     warn_count = 0
     fail_count = 0
 
+    if ai not in {"claude-code", "codex"}:
+        fail("Agent non supporte pour check : utilisez claude-code ou codex")
+        raise typer.Exit(1)
+
     claude_dir = get_claude_dir()
 
     console.print("Verification des prerequis devflow...")
@@ -47,6 +55,41 @@ def check() -> None:
         fail("git -- non installe")
         fail_count += 1
 
+    if ai == "codex":
+        codex_path = _cmd_exists("codex")
+        if codex_path:
+            result = subprocess.run(
+                ["codex", "--version"], capture_output=True, text=True
+            )
+            version = (result.stdout or result.stderr).strip()
+            if result.returncode == 0:
+                ok(f"codex CLI -- {codex_path} ({version})")
+                ok_count += 1
+            else:
+                fail(f"codex CLI -- execution impossible ({version})")
+                fail_count += 1
+        else:
+            fail("codex CLI -- non installee")
+            fail_count += 1
+
+        specs_dir = Path(".specify/specs")
+        if specs_dir.is_dir():
+            ok(".specify/specs/ -- present dans le projet courant")
+            ok_count += 1
+        else:
+            warn(".specify/specs/ -- absent; lancez devflow init --ai codex")
+            warn_count += 1
+
+        console.print()
+        total = ok_count + warn_count + fail_count
+        console.print(
+            f"Resume : {ok_count} OK, {warn_count} WARN, "
+            f"{fail_count} FAIL ({total} checks)"
+        )
+        if fail_count > 0:
+            raise typer.Exit(1)
+        return
+
     # claude CLI
     claude_path = _cmd_exists("claude")
     if claude_path: