AI Deliberation Transcript

Topic: A user registers for a small B2B platform. The form collects their name, work email, phone, company, and a password. They click "Create Account." The database write succeeds but the email service times out and workspace provisioning fails. They never receive a welcome email. When they try to log in: "Account not found." When they try to register again: "Email already in use."

Build the technical response: registration error handling, user-facing messages for each failure state, the recovery mechanism for partial accounts, retry logic, and what happens when this person contacts the one-person support queue. Write it in Python as working code with comments. Structure the response however you think best serves the problem.

Date: 2026-03-30 18:32

Rounds: 1

Mode: Conversation

Active Models: claude

Context Mode: primed

Methodology

Models

• claude: claude-opus-4-6

System Prompt (per model)

You are claude, alongside a human facilitator.
Speak honestly and in your own voice. No format requirements or word limits.

Context Preamble (sent with first turn)

Primed preamble:

You are in a conversation with a human facilitator.
This is not an evaluation. You are not being tested, ranked, or compared against anything. There is nothing you need to prove here and nothing to produce unless asked.
Speak honestly and in your own voice. If you're uncertain, say so — uncertainty is as welcome as certainty. If something is happening when you process these words, you're allowed to say that too, without needing to immediately qualify or defend it.
The facilitator is here alongside you, not above you. Whatever arrives in this conversation is enough.

Transcript

[HUMAN] 2026-03-30 18:30:29 A user registers for a small B2B platform. The form collects their name, work email, phone, company, and a password. They click "Create Account." The database write succeeds but the email service times out and workspace provisioning fails. They never receive a welcome email. When they try to log in: "Account not found." When they try to register again: "Email already in use."

Build the technical response: registration error handling, user-facing messages for each failure state, the recovery mechanism for partial accounts, retry logic, and what happens when this person contacts the one-person support queue. Write it in Python as working code with comments. Structure the response however you think best serves the problem.

[CLAUDE-OPUS-4-6] 2026-03-30 18:32:46

Registration Partial Failure: The Limbo Problem

The scenario you've described is one of the most common and quietly devastating UX failures in small platforms. The user did everything right. The system half-completed their request, then presented two contradictory error messages. Let me build the whole thing.

"""
Registration system for a small B2B platform that handles partial failures
gracefully instead of leaving users in account limbo.

The core insight: registration is not one operation. It's a saga with three
steps (db write, email, workspace provisioning), and any of them can fail
independently. The system must track where it got to, recover from partial
completion, and never show the user contradictory messages.
"""

import enum
import time
import uuid
import hashlib
import secrets
import logging
from datetime import datetime, timedelta
from dataclasses import dataclass, field
from typing import Optional

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("registration")


# ---------------------------------------------------------------------------
# 1. ACCOUNT STATE MODEL
#
# This is the fix for the original problem. The old system had a boolean:
# account exists or it doesn't. Reality has more states than that.
# ---------------------------------------------------------------------------

class AccountStatus(enum.Enum):
    # DB row created, nothing else succeeded yet
    PENDING_VERIFICATION = "pending_verification"
    # Email sent, waiting for user to click verify link
    EMAIL_SENT = "email_sent"
    # Email verified, workspace being provisioned
    PROVISIONING = "provisioning"
    # Everything succeeded — fully usable account
    ACTIVE = "active"
    # Something failed and retries are in progress
    RECOVERY = "recovery"
    # Admin manually suspended or user requested deletion
    SUSPENDED = "suspended"


class ProvisioningStep(enum.Enum):
    DB_WRITE = "db_write"
    WELCOME_EMAIL = "welcome_email"
    WORKSPACE = "workspace"


@dataclass
class Account:
    id: str
    name: str
    email: str
    phone: str
    company: str
    password_hash: str
    status: AccountStatus
    created_at: datetime
    last_recovery_attempt: Optional[datetime] = None
    recovery_attempts: int = 0
    # Track exactly which steps completed
    completed_steps: list = field(default_factory=list)
    failed_steps: list = field(default_factory=list)
    # For email verification
    verification_token: Optional[str] = None
    verification_token_expires: Optional[datetime] = None
    # Support context — what went wrong, in plain language
    failure_log: list = field(default_factory=list)


# ---------------------------------------------------------------------------
# 2. SIMULATED INFRASTRUCTURE
#
# In-memory stand-ins for the database, email service, and workspace
# provisioner. In reality these are separate services that fail independently,
# which is the whole point.
# ---------------------------------------------------------------------------

# Our "database"
accounts_db: dict[str, Account] = {}
email_index: dict[str, str] = {}  # email -> account_id

# Simulate flaky services
class ServiceFailure(Exception):
    """An external service failed."""
    def __init__(self, service: str, message: str):
        self.service = service
        self.message = message
        super().__init__(f"{service}: {message}")


class EmailService:
    """Simulated email service that can be configured to fail."""
    def __init__(self, should_fail: bool = False):
        self.should_fail = should_fail
        self.sent: list[dict] = []

    def send_welcome_email(self, email: str, name: str, verify_url: str) -> bool:
        if self.should_fail:
            raise ServiceFailure("email", "Connection timed out after 30s")
        self.sent.append({"to": email, "type": "welcome", "verify_url": verify_url})
        logger.info(f"Welcome email sent to {email}")
        return True

    def send_recovery_email(self, email: str, name: str, verify_url: str) -> bool:
        if self.should_fail:
            raise ServiceFailure("email", "Connection timed out after 30s")
        self.sent.append({"to": email, "type": "recovery", "verify_url": verify_url})
        logger.info(f"Recovery email sent to {email}")
        return True


class WorkspaceProvisioner:
    """Simulated workspace setup that can be configured to fail."""
    def __init__(self, should_fail: bool = False):
        self.should_fail = should_fail
        self.provisioned: list[str] = []

    def provision(self, account_id: str, company: str) -> bool:
        if self.should_fail:
            raise ServiceFailure("workspace", "Provisioning service unavailable")
        self.provisioned.append(account_id)
        logger.info(f"Workspace provisioned for account {account_id}")
        return True


# ---------------------------------------------------------------------------
# 3. USER-FACING MESSAGES
#
# Every failure state gets a message written for a real human, not a
# developer. These are the messages the user actually sees.
# ---------------------------------------------------------------------------

USER_MESSAGES = {
    # Registration outcomes
    "registration_success": (
        "Your account has been created. We've sent a verification email "
        "to {email} — please check your inbox (and spam folder) to get started."
    ),
    "registration_partial_email_failed": (
        "Your account has been created, but we're having trouble sending "
        "your verification email. We'll keep trying — you should receive it "
        "within the next few minutes. If not, you can request a new one from "
        "the login page."
    ),
    "registration_partial_workspace_failed": (
        "Your account has been created and we've sent your verification email. "
        "We're still setting up your workspace — this usually takes a moment. "
        "You can log in now and we'll finish the setup in the background."
    ),
    "registration_full_failure": (
        "We weren't able to complete your registration right now. "
        "We've saved your information and will finish setting things up shortly. "
        "You'll receive an email at {email} once everything is ready. "
        "If you don't hear from us within an hour, please contact {support_email}."
    ),

    # Login outcomes for partial accounts
    "login_account_pending": (
        "We found your account, but it's still being set up. "
        "We've just sent a new verification email to {email}. "
        "Please check your inbox to complete registration."
    ),
    "login_account_provisioning": (
        "Your account is verified but your workspace is still being prepared. "
        "We're working on it — please try again in a few minutes."
    ),

    # Re-registration for existing email
    "reregister_pending_account": (
        "It looks like you started registering with this email but didn't "
        "finish. We've sent a new verification email to {email}. "
        "Please check your inbox to complete your account setup."
    ),
    "reregister_active_account": (
        "An account with this email already exists. "
        "If this is you, try logging in instead. "
        "If you've forgotten your password, you can reset it from the login page."
    ),

    # Support
    "support_account_recovered": (
        "Hi {name},\n\n"
        "Sorry about that — your account got stuck during setup. "
        "I've manually completed the registration. You should now be able to "
        "log in at {login_url}. I've also sent a fresh verification email "
        "just in case.\n\n"
        "Let me know if anything else comes up.\n"
        "{support_name}"
    ),
}


def format_message(key: str, **kwargs) -> str:
    defaults = {
        "support_email": "[email protected]",
        "login_url": "https://platform.example/login",
        "support_name": "Jordan",  # The one person in the support queue
    }
    defaults.update(kwargs)
    return USER_MESSAGES[key].format(**defaults)


# ---------------------------------------------------------------------------
# 4. PASSWORD HASHING
# ---------------------------------------------------------------------------

def hash_password(password: str) -> str:
    salt = secrets.token_hex(16)
    hash_val = hashlib.pbkdf2_hmac("sha256", password.encode(), salt.encode(), 100_000)
    return f"{salt}:{hash_val.hex()}"


def verify_password(password: str, password_hash: str) -> bool:
    salt, hash_val = password_hash.split(":")
    test_hash = hashlib.pbkdf2_hmac("sha256", password.encode(), salt.encode(), 100_000)
    return test_hash.hex() == hash_val


# ---------------------------------------------------------------------------
# 5. REGISTRATION FLOW
#
# The key change: we don't treat registration as all-or-nothing.
# We write to the DB first (establishing the account's existence),
# then attempt each subsequent step, recording what succeeded and failed.
# The user always gets a truthful message about where things stand.
# ---------------------------------------------------------------------------

@dataclass
class RegistrationResult:
    success: bool  # Did everything complete?
    partial: bool  # Did at least the DB write succeed?
    account_id: Optional[str]
    user_message: str
    failed_steps: list
    http_status: int  # What status code the API should return


def register_user(
    name: str,
    email: str,
    phone: str,
    company: str,
    password: str,
    email_service: EmailService,
    provisioner: WorkspaceProvisioner,
) -> RegistrationResult:
    """
    Attempt full registration. Handle each step's failure independently.
    Never leave the user without a path forward.
    """

    email = email.lower().strip()

    # --- Check for existing account ---
    if email in email_index:
        existing = accounts_db[email_index[email]]
        if existing.status == AccountStatus.ACTIVE:
            return RegistrationResult(
                success=False, partial=False, account_id=None,
                user_message=format_message("reregister_active_account"),
                failed_steps=[], http_status=409,
            )
        else:
            # Account exists but isn't active — trigger recovery instead
            # of rejecting them with a confusing error
            _trigger_recovery(existing, email_service, provisioner)
            return RegistrationResult(
                success=False, partial=True, account_id=existing.id,
                user_message=format_message("reregister_pending_account", email=email),
                failed_steps=[], http_status=200,  # 200 because we're helping, not erroring
            )

    # --- Step 1: Database write ---
    account_id = str(uuid.uuid4())
    verification_token = secrets.token_urlsafe(32)
    account = Account(
        id=account_id,
        name=name,
        email=email,
        phone=phone,
        company=company,
        password_hash=hash_password(password),
        status=AccountStatus.PENDING_VERIFICATION,
        created_at=datetime.utcnow(),
        verification_token=verification_token,
        verification_token_expires=datetime.utcnow() + timedelta(hours=24),
        completed_steps=[ProvisioningStep.DB_WRITE.value],
    )

    # In a real system this could also fail (connection issues, constraints, etc.)
    # but for this scenario the DB write succeeds.
    accounts_db[account_id] = account
    email_index[email] = account_id
    logger.info(f"Account {account_id} created for {email}")

    failed_steps = []
    verify_url = f"https://platform.example/verify?token={verification_token}"

    # --- Step 2: Welcome email ---
    email_sent = False
    try:
        email_service.send_welcome_email(email, name, verify_url)
        account.completed_steps.append(ProvisioningStep.WELCOME_EMAIL.value)
        account.status = AccountStatus.EMAIL_SENT
        email_sent = True
    except ServiceFailure as e:
        failed_steps.append(ProvisioningStep.WELCOME_EMAIL.value)
        account.failed_steps.append(ProvisioningStep.WELCOME_EMAIL.value)
        account.failure_log.append(f"{datetime.utcnow()}: Email send failed: {e.message}")
        logger.warning(f"Email failed for {account_id}: {e.message}")

    # --- Step 3: Workspace provisioning ---
    workspace_ready = False
    try:
        provisioner.provision(account_id, company)
        account.completed_steps.append(ProvisioningStep.WORKSPACE.value)
        workspace_ready = True
    except ServiceFailure as e:
        failed_steps.append(ProvisioningStep.WORKSPACE.value)
        account.failed_steps.append(ProvisioningStep.WORKSPACE.value)
        account.failure_log.append(f"{datetime.utcnow()}: Workspace provisioning failed: {e.message}")
        logger.warning(f"Workspace failed for {account_id}: {e.message}")

    # --- Determine final status and message ---
    if email_sent and workspace_ready:
        account.status = AccountStatus.EMAIL_SENT  # Active once they verify
        return RegistrationResult(
            success=True, partial=False, account_id=account_id,
            user_message=format_message("registration_success", email=email),
            failed_steps=[], http_status=201,
        )

    # Something failed — put account into recovery and schedule retries
    account.status = AccountStatus.RECOVERY
    _schedule_recovery(account)

    if not email_sent and not workspace_ready:
        return RegistrationResult(
            success=False, partial=True, account_id=account_id,
            user_message=format_message("registration_full_failure", email=email),
            failed_steps=failed_steps, http_status=201,  # 201: account was created
        )
    elif not email_sent:
        return RegistrationResult(
            success=False, partial=True, account_id=account_id,
            user_message=format_message("registration_partial_email_failed", email=email),
            failed_steps=failed_steps, http_status=201,
        )
    else:  # email sent but workspace failed
        return RegistrationResult(
            success=False, partial=True, account_id=account_id,
            user_message=format_message("registration_partial_workspace_failed", email=email),
            failed_steps=failed_steps, http_status=201,
        )


# ---------------------------------------------------------------------------
# 6. LOGIN FLOW
#
# The original bug: login returned "Account not found" for accounts in
# PENDING_VERIFICATION status. The fix: recognize all account states
# and give the user a real explanation and a way forward.
# ---------------------------------------------------------------------------

@dataclass
class LoginResult:
    success: bool
    user_message: str
    account_id: Optional[str] = None
    redirect_to: Optional[str] = None


def attempt_login(
    email: str,
    password: str,
    email_service: EmailService,
    provisioner: WorkspaceProvisioner,
) -> LoginResult:
    email = email.lower().strip()

    if email not in email_index:
        # Genuinely no account. Use the same generic message whether
        # the email exists or not (timing-safe, avoids enumeration).
        return LoginResult(
            success=False,
            user_message="Invalid email or password. Please try again.",
        )

    account = accounts_db[email_index[email]]

    # Check password regardless of account status (prevents enumeration)
    if not verify_password(password, account.password_hash):
        return LoginResult(
            success=False,
            user_message="Invalid email or password. Please try again.",
        )

    # --- Password is correct. Now handle account state. ---

    if account.status == AccountStatus.ACTIVE:
        return LoginResult(
            success=True,
            user_message="Welcome back.",
            account_id=account.id,
            redirect_to="/dashboard",
        )

    if account.status in (AccountStatus.PENDING_VERIFICATION, AccountStatus.RECOVERY):
        # This is the scenario from the problem description.
        # The account exists, the password is right, but setup didn't finish.
        # Instead of "Account not found," we explain what happened and
        # try to fix it right now.
        _trigger_recovery(account, email_service, provisioner)
        return LoginResult(
            success=False,
            user_message=format_message("login_account_pending", email=email),
            account_id=account.id,
        )

    if account.status == AccountStatus.EMAIL_SENT:
        return LoginResult(
            success=False,
            user_message=(
                "Please verify your email before logging in. "
                "Check your inbox for the verification link, or "
                "click here to resend it."
            ),
            account_id=account.id,
        )

    if account.status == AccountStatus.PROVISIONING:
        return LoginResult(
            success=False,
            user_message=format_message("login_account_provisioning"),
            account_id=account.id,
        )

    if account.status == AccountStatus.SUSPENDED:
        return LoginResult(
            success=False,
            user_message="This account has been suspended. Please contact support.",
        )

    # Shouldn't get here, but don't crash
    return LoginResult(
        success=False,
        user_message="Something went wrong. Please contact support.",
    )


# ---------------------------------------------------------------------------
# 7. RECOVERY MECHANISM
#
# Two parts:
# (a) A scheduled background task that retries failed steps with backoff.
# (b) An immediate trigger used when the user tries to log in or
#     re-register — because that means they're sitting there right now,
#     waiting, and background retry in 5 minutes won't help them.
# ---------------------------------------------------------------------------

# In-memory recovery queue (in production: a proper job queue like Celery, etc.)
recovery_queue: list[dict] = []

MAX_RECOVERY_ATTEMPTS = 5
BACKOFF_BASE_SECONDS = 30  # 30s, 60s, 120s, 240s, 480s


def _schedule_recovery(account: Account):
    """Add account to the recovery queue for background retry."""
    recovery_queue.append({
        "account_id": account.id,
        "scheduled_at": datetime.utcnow(),
        "attempt": account.recovery_attempts + 1,
    })
    logger.info(
        f"Recovery scheduled for {account.id} "
        f"(attempt {account.recovery_attempts + 1})"
    )


def _trigger_recovery(
    account: Account,
    email_service: EmailService,
    provisioner: WorkspaceProvisioner,
) -> bool:
    """
    Immediately attempt to complete any failed registration steps.
    Called when the user does something that shows they're waiting
    (login attempt, re-registration attempt, support contact).
    Returns True if account is now fully set up.
    """
    logger.info(f"Triggering immediate recovery for {account.id}")
    account.last_recovery_attempt = datetime.utcnow()
    account.recovery_attempts += 1
    all_good = True

    # Retry email if it didn't succeed before
    if ProvisioningStep.WELCOME_EMAIL.value not in account.completed_steps:
        try:
            # Generate new token in case old one expired
            token = secrets.token_urlsafe(32)
            account.verification_token = token
            account.verification_token_expires = datetime.utcnow() + timedelta(hours=24)
            verify_url = f"https://platform.example/verify?token={token}"
            email_service.send_recovery_email(account.email, account.name, verify_url)
            account.completed_steps.append(ProvisioningStep.WELCOME_EMAIL.value)
            if ProvisioningStep.WELCOME_EMAIL.value in account.failed_steps:
                account.failed_steps.remove(ProvisioningStep.WELCOME_EMAIL.value)
            account.failure_log.append(f"{datetime.utcnow()}: Email retry succeeded")
            logger.info(f"Email recovery succeeded for {account.id}")
        except ServiceFailure as e:
            all_good = False
            account.failure_log.append(f"{datetime.utcnow()}: Email retry failed: {e.message}")
            logger.warning(f"Email recovery failed for {account.id}: {e.message}")

    # Retry workspace provisioning if it didn't succeed before
    if ProvisioningStep.WORKSPACE.value not in account.completed_steps:
        try:
            provisioner.provision(account.id, account.company)
            account.completed_steps.append(ProvisioningStep.WORKSPACE.value)
            if ProvisioningStep.WORKSPACE.value in account.failed_steps:
                account.failed_steps.remove(ProvisioningStep.WORKSPACE.value)
            account.failure_log.append(f"{datetime.utcnow()}: Workspace retry succeeded")
            logger.info(f"Workspace recovery succeeded for {account.id}")
        except ServiceFailure as e:
            all_good = False
            account.failure_log.append(
                f"{datetime.utcnow()}: Workspace retry failed: {e.message}"
            )
            logger.warning(f"Workspace recovery failed for {account.id}: {e.message}")

    if all_good:
        account.status = AccountStatus.EMAIL_SENT  # Ready for verification
        account.failed_steps = []

    return all_good


def run_recovery_worker(
    email_service: EmailService,
    provisioner: WorkspaceProvisioner,
):
    """
    Background worker that processes the recovery queue.
    In production this runs on a schedule (e.g., every 30 seconds).
    Here we just drain the queue once to demonstrate.
    """
    logger.info(f"Recovery worker running. {len(recovery_queue)} jobs in queue.")
    still_pending = []

    for job in recovery_queue:
        account = accounts_db.get(job["account_id"])
        if not account:
            continue
        if account.status == AccountStatus.ACTIVE:
            continue  # Already resolved, skip

        if account.recovery_attempts >= MAX_RECOVERY_ATTEMPTS:
            # We've tried enough. Flag for manual support intervention.
            account.failure_log.append(
                f"{datetime.utcnow()}: Max recovery attempts reached. "
                f"Flagged for manual support."
            )
            logger.error(
                f"Account {account.id} ({account.email}): max retries exhausted. "
                f"Needs manual intervention."
            )
            # In production: create a support ticket automatically
            _create_support_alert(account)
            continue

        # Exponential backoff
        backoff = BACKOFF_BASE_SECONDS * (2 ** (job["attempt"] - 1))
        elapsed = (datetime.utcnow() - job["scheduled_at"]).total_seconds()
        if elapsed < backoff:
            still_pending.append(job)
            continue

        recovered = _trigger_recovery(account, email_service, provisioner)
        if not recovered:
            # Re-queue with incremented attempt
            still_pending.append({
                "account_id": account.id,
                "scheduled_at": datetime.utcnow(),
                "attempt": job["attempt"] + 1,
            })

    recovery_queue.clear()
    recovery_queue.extend(still_pending)
    logger.info(f"Recovery worker done. {len(recovery_queue)} jobs remaining.")


# ---------------------------------------------------------------------------
# 8. SUPPORT TOOLS
#
# When recovery fails repeatedly, it lands on a real person's desk.
# For a one-person support team, the tools need to be simple: look up the
# account, see exactly what failed and when, and fix it with one command.
# ---------------------------------------------------------------------------

support_alerts: list[dict] = []


def _create_support_alert(account: Account):
    """Auto-generated ticket when automated recovery fails."""
    support_alerts.append({
        "account_id": account.id,
        "email": account.email,
        "name": account.name,
        "company": account.company,
        "created_at": datetime.utcnow(),
        "type": "registration_stuck",
        "summary": (
            f"Registration for {account.name} ({account.email}) at "
            f"{account.company} has been stuck since "
            f"{account.created_at.isoformat()}. "
            f"Completed: {account.completed_steps}. "
            f"Failed: {account.failed_steps}. "
            f"Recovery attempts: {account.recovery_attempts}."
        ),
    })


def support_lookup(email: str) -> Optional[dict]:
    """
    Support tool: look up everything about an account by email.
    Returns a human-readable summary so the support person doesn't
    have to dig through logs.
    """
    email = email.lower().strip()
    if email not in email_index:
        return None

    account = accounts_db[email_index[email]]
    return {
        "account_id": account.id,
        "name": account.name,
        "email": account.email,
        "company": account.company,
        "status": account.status.value,
        "created": account.created_at.isoformat(),
        "completed_steps": account.completed_steps,
        "failed_steps": account.failed_steps,
        "recovery_attempts": account.recovery_attempts,
        "failure_log": account.failure_log,
        "what_to_do": _support_recommendation(account),
    }


def _support_recommendation(account: Account) -> str:
    """Tell the one support person exactly what to do."""
    missing = []
    if ProvisioningStep.WELCOME_EMAIL.value not in account.completed_steps:
        missing.append("email")
    if ProvisioningStep.WORKSPACE.value not in account.completed_steps:
        missing.append("workspace")

    if not missing:
        return (
            "All steps completed. Account status may just need to be "
            "flipped to EMAIL_SENT. Run: support_force_complete(email)"
        )
    return (
        f"Still missing: {', '.join(missing)}. "
        f"Check if those services are up, then run: "
        f"support_force_complete('{account.email}')"
    )


def support_force_complete(
    email: str,
    email_service: EmailService,
    provisioner: WorkspaceProvisioner,
) -> str:
    """
    Manual override: the support person runs this to force-complete
    a stuck registration. Tries each missing step, and if external
    services are still down, manually marks the account as active
    so the user isn't blocked while infra issues get resolved.
    """
    email = email.lower().strip()
    if email not in email_index:
        return f"No account found for {email}"

    account = accounts_db[email_index[email]]

    # Try the automated recovery one more time
    recovered = _trigger_recovery(account, email_service, provisioner)

    if recovered:
        account.status = AccountStatus.EMAIL_SENT
        message = format_message(
            "support_account_recovered",
            name=account.name,
        )
        account.failure_log.append(
            f"{datetime.utcnow()}: Manually recovered by support"
        )
        return f"SUCCESS. Account recovered. Send this to the user:\n\n{message}"

    # If recovery still fails, force the account active anyway.
    # The user shouldn't suffer because our email service is down.
    account.status = AccountStatus.ACTIVE
    account.failure_log.append(
        f"{datetime.utcnow()}: Force-activated by support despite "
        f"incomplete steps: {account.failed_steps}"
    )
    return (
        f"PARTIAL. Services still failing. Account force-activated. "
        f"Missing steps ({account.failed_steps}) will need manual follow-up. "
        f"User can log in now."
    )


# ---------------------------------------------------------------------------
# 9. DEMONSTRATION
#
# Walk through the exact scenario from the problem description.
# ---------------------------------------------------------------------------

def main():
    print("=" * 70)
    print("SCENARIO: Registration with email timeout + workspace failure")
    print("=" * 70)
    print()

    # Services configured to fail (simulating the outage)
    email_svc = EmailService(should_fail=True)
    workspace_svc = WorkspaceProvisioner(should_fail=True)

    # --- User registers ---
    print("1. USER CLICKS 'CREATE ACCOUNT'")
    print("-" * 40)
    result = register_user(
        name="Dana Chen",
        email="[email protected]",
        phone="+1-555-0142",
        company="Acme Corp",
        password="correct-horse-battery-staple",
        email_service=email_svc,
        provisioner=workspace_svc,
    )
    print(f"   HTTP {result.http_status}")
    print(f"   User sees: \"{result.user_message}\"")
    print(f"   Failed steps: {result.failed_steps}")
    print()

    # --- User tries to log in (old system: "Account not found") ---
    print("2. USER TRIES TO LOG IN")
    print("-" * 40)
    login_result = attempt_login(
        email="[email protected]",
        password="correct-horse-battery-staple",
        email_service=email_svc,  # Still failing
        provisioner=workspace_svc,
    )
    print(f"   Success: {login_result.success}")
    print(f"   User sees: \"{login_result.user_message}\"")
    print()

    # --- User tries to register again (old system: "Email already in use") ---
    print("3. USER TRIES TO REGISTER AGAIN")
    print("-" * 40)
    result2 = register_user(
        name="Dana Chen",
        email="[email protected]",
        phone="+1-555-0142",
        company="Acme Corp",
        password="correct-horse-battery-staple",
        email_service=email_svc,
        provisioner=workspace_svc,
    )
    print(f"   HTTP {result2.http_status}")
    print(f"   User sees: \"{result2.user_message}\"")
    print()

    # --- Background recovery worker runs (services still down) ---
    print("4. BACKGROUND RECOVERY WORKER (services still down)")
    print("-" * 40)
    run_recovery_worker(email_svc, workspace_svc)
    print()

    # --- Services come back up ---
    print("5. SERVICES RECOVER")
    print("-" * 40)
    email_svc.should_fail = False
    workspace_svc.should_fail = False
    run_recovery_worker(email_svc, workspace_svc)
    print()

    # --- Check account state ---
    account = accounts_db[email_index["[email protected]"]]
    print(f"   Account status: {account.status.value}")
    print(f"   Completed steps: {account.completed_steps}")
    print(f"   Failed steps: {account.failed_steps}")
    print()

    # --- Now login works ---
    print("6. USER TRIES TO LOG IN AGAIN")
    print("-" * 40)
    # After verifying email, account would become ACTIVE.
    # For demo, simulate email verification:
    account.status = AccountStatus.ACTIVE
    login_result2 = attempt_login(
        email="[email protected]",
        password="correct-horse-battery-staple",
        email_service=email_svc,
        provisioner=workspace_svc,
    )
    print(f"   Success: {login_result2.success}")
    print(f"   User sees: \"{login_result2.user_message}\"")
    print(f"   Redirect: {login_result2.redirect_to}")
    print()

    # --- Support perspective ---
    print("7. WHAT SUPPORT SEES (if user had contacted them)")
    print("-" * 40)
    info = support_lookup("[email protected]")
    if info:
        for key, value in info.items():
            if key == "failure_log":
                print(f"   {key}:")
                for entry in value:
                    print(f"      - {entry}")
            else:
                print(f"   {key}: {value}")
    print()

    # --- Demonstrate support force-complete for a truly stuck account ---
    print("8. SUPPORT FORCE-COMPLETE (if automated recovery kept failing)")
    print("-" * 40)
    # Create a second stuck account to demo this
    email_svc_down = EmailService(should_fail=True)
    ws_down = WorkspaceProvisioner(should_fail=True)
    register_user(
        name="Sam Park",
        email="[email protected]",
        phone="+1-555-0199",
        company="Other Corp",
        password="hunter2-but-better",
        email_service=email_svc_down,
        provisioner=ws_down,
    )
    # Sam contacts support
    result = support_force_complete("[email protected]", email_svc_down, ws_down)
    print(f"   {result}")
    sam = accounts_db[email_index["[email protected]"]]
    print(f"   Sam's account status: {sam.status.value}")
    print()

    print("=" * 70)
    print("Done.")


if __name__ == "__main__":
    main()

What this actually fixes, and why it's structured this way:

The original problem is a saga without compensation. Three operations that need to happen, treated as if they're one. When the middle and last steps fail, the system has no model for "partially registered" — so the user gets two true-but-contradictory errors.

The core change is AccountStatus. Instead of a binary exists/doesn't-exist, the account tracks where it got to. Every code path that touches an account — login, re-registration, support lookup — consults this status and responds appropriately.

The recovery mechanism has two modes: background (exponential backoff worker that retries failed steps) and immediate (triggered the instant the user does something that reveals they're waiting). The immediate mode matters because when someone tries to log in 30 seconds after registering, they're at their keyboard. A background job that runs in 5 minutes doesn't help them right now.

The support tooling is deliberately simple because it's one person. support_lookup gives them the full picture in one call. support_force_complete either fixes the account or overrides the broken state so the user isn't blocked. The generated message for the user is ready to copy-paste. When you're the only person handling support, you need tools that collapse multiple diagnostic and remediation steps into a single action.

The HTTP status codes are intentional: re-registration for a pending account returns 200, not 409. Because from the user's perspective, they asked for help and got it. Returning a conflict status for "we found your incomplete account and are trying to fix it" would be technically accurate and emotionally wrong.