Sprint 1 : scaffolding complet de Glibredecision

Plateforme de decisions collectives pour Duniter/G1.
Backend FastAPI async + PostgreSQL (14 tables, 8 routers, 6 services,
moteur de vote avec formule d'inertie WoT/Smith/TechComm).
Frontend Nuxt 4 + Nuxt UI v3 + Pinia (9 pages, 5 stores).
Infrastructure Docker + Woodpecker CI + Traefik.
Documentation technique et utilisateur (15 fichiers).
Seed : Licence G1, Engagement Forgeron v2.0.0, 4 protocoles de vote.
30 tests unitaires (formules, mode params, vote nuance) -- tous verts.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

backend/app/services/decision_service.py

@@ -0,0 +1,117 @@
+"""Decision service: step advancement logic."""
+
+from __future__ import annotations
+
+import uuid
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.models.decision import Decision, DecisionStep
+
+
+# Valid status transitions for decisions
+_DECISION_STATUS_ORDER = [
+    "draft",
+    "qualification",
+    "review",
+    "voting",
+    "executed",
+    "closed",
+]
+
+
+async def advance_decision(decision_id: uuid.UUID, db: AsyncSession) -> Decision:
+    """Move a decision to its next step.
+
+    Completes the current active step and activates the next pending step.
+    If no more steps remain, the decision status advances to the next phase.
+
+    Parameters
+    ----------
+    decision_id:
+        UUID of the Decision to advance.
+    db:
+        Async database session.
+
+    Returns
+    -------
+    Decision
+        The updated decision.
+
+    Raises
+    ------
+    ValueError
+        If the decision is not found, or no further advancement is possible.
+    """
+    result = await db.execute(
+        select(Decision)
+        .options(selectinload(Decision.steps))
+        .where(Decision.id == decision_id)
+    )
+    decision = result.scalar_one_or_none()
+    if decision is None:
+        raise ValueError(f"Decision introuvable : {decision_id}")
+
+    if decision.status == "closed":
+        raise ValueError("La decision est deja cloturee")
+
+    steps: list[DecisionStep] = sorted(decision.steps, key=lambda s: s.step_order)
+
+    # Find the current active step
+    active_step: DecisionStep | None = None
+    for step in steps:
+        if step.status == "active":
+            active_step = step
+            break
+
+    if active_step is not None:
+        # Complete the active step
+        active_step.status = "completed"
+
+        # Activate the next pending step
+        next_step: DecisionStep | None = None
+        for step in steps:
+            if step.step_order > active_step.step_order and step.status == "pending":
+                next_step = step
+                break
+
+        if next_step is not None:
+            next_step.status = "active"
+        else:
+            # No more steps: advance the decision status
+            _advance_decision_status(decision)
+    else:
+        # No active step: try to activate the first pending step
+        first_pending: DecisionStep | None = None
+        for step in steps:
+            if step.status == "pending":
+                first_pending = step
+                break
+
+        if first_pending is not None:
+            first_pending.status = "active"
+            # Also advance decision out of draft if needed
+            if decision.status == "draft":
+                decision.status = "qualification"
+        else:
+            # All steps are completed: advance the decision status
+            _advance_decision_status(decision)
+
+    await db.commit()
+    await db.refresh(decision)
+
+    return decision
+
+
+def _advance_decision_status(decision: Decision) -> None:
+    """Move a decision to its next status in the lifecycle."""
+    try:
+        current_index = _DECISION_STATUS_ORDER.index(decision.status)
+    except ValueError:
+        return
+
+    next_index = current_index + 1
+    if next_index < len(_DECISION_STATUS_ORDER):
+        decision.status = _DECISION_STATUS_ORDER[next_index]