pipecatcloud 0.3.0__tar.gz → 0.3.1__tar.gz

{pipecatcloud-0.3.0 → pipecatcloud-0.3.1}/CHANGELOG.md

@@ -5,6 +5,34 @@ All notable changes to **Pipecat Cloud** will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.1] - 2026-03-13
+
+### Added
+
+- Added `.github`, `.claude`, `pcc-deploy.toml`, `.ipynb_checkpoints`, and
+  `.cache` to default cloud build context exclusions to reduce upload size and
+  avoid including non-runtime files in container images.
+
+### Changed
+
+- Increased deploy polling timeout from 90 seconds to 10 minutes to support
+  large deployments with big images, high replica counts, and cross-region pulls.
+
+- Deploy polling now shows rich, multi-line status using API conditions and
+  revision info instead of a static "Waiting for deployment to become ready..."
+  message. The headline shows condition state (e.g. "Progressing · Available"),
+  with per-revision detail lines showing phase, replica counts, and elapsed time
+  for both current and previous deployments during rolling updates.
+
+- Deploy timeout now differentiates exit behavior: services that are available
+  and serving traffic show a soft warning instead of a hard error, with guidance
+  to check status. Hard errors are reserved for services that are truly
+  unavailable.
+
+- `agent status` now shows per-revision details (phase, deployment ID, replica
+  counts) in the health panel when the API provides revision info, replacing the
+  binary "Health: Ready/Stopped" display.
+
 ## [0.3.0] - 2026-03-12
 
 ### Added
@@ -15,6 +43,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - `pcc deploy --build-id <id>` to reuse an existing build
   - `pcc deploy --yes` for non-interactive CI/CD usage
   - `[build]` section in `pcc-deploy.toml` for build configuration
+
 - New `pcc build` command group for managing cloud builds:
   - `pcc build list` — list recent builds with status and region filtering
   - `pcc build status <id>` — get detailed status of a build
@@ -23,6 +52,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - The `image` field in `pcc deploy` is now optional when using cloud builds
+
 - The CLI now uses `desiredDeploymentId` (with fallback to `activeDeploymentId`)
   and compares it against `reconciledDeploymentId` to determine deployment status.
 

{pipecatcloud-0.3.0 → pipecatcloud-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 0.3.0
+Version: 0.3.1
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/

{pipecatcloud-0.3.0 → pipecatcloud-0.3.1}/src/pipecatcloud/_utils/build_utils.py

@@ -26,7 +26,6 @@ from typing import Callable, List, Optional, Set, Tuple
 import aiohttp
 from loguru import logger
 
-
 # Default patterns to exclude from build context
 DEFAULT_EXCLUSIONS: Set[str] = {
     # Version control
@@ -68,8 +67,22 @@ DEFAULT_EXCLUSIONS: Set[str] = {
     "dist",
     "build",
     "*.egg-info",
+    "*.egg",
+    ".eggs",
     # Node (if present)
     "node_modules",
+    # CI/CD
+    ".github",
+    # AI tools
+    ".claude",
+    ".codex",
+    ".cursor",
+    # Pipecat config
+    "pcc-deploy.toml",
+    # Jupyter
+    ".ipynb_checkpoints",
+    # Caches
+    ".cache",
     # Misc
     ".DS_Store",
     "Thumbs.db",

{pipecatcloud-0.3.0 → pipecatcloud-0.3.1}/src/pipecatcloud/_utils/deploy_utils.py

@@ -6,6 +6,8 @@
 
 import functools
 import os
+from datetime import datetime, timezone
+from enum import Enum
 from typing import Callable, List, Optional
 
 import toml
@@ -22,6 +24,184 @@ DEPLOY_STATUS_MAP = {
 }
 
 
+class DeploymentPhase(Enum):
+    WAITING_FOR_OPERATOR = "waiting_for_operator"
+    PROGRESSING_AVAILABLE = "progressing_available"
+    PROGRESSING_NEW = "progressing_new"
+    DEGRADED_AVAILABLE = "degraded_available"
+    UNAVAILABLE = "unavailable"
+    READY = "ready"
+
+
+@dataclass
+class DeploymentStatus:
+    phase: DeploymentPhase
+    status_message: str
+    is_available: bool = False
+    is_ready: bool = False
+    degraded_reason: Optional[str] = None
+    current_revision: Optional[dict] = None
+    previous_revision: Optional[dict] = None
+
+
+def _find_condition(conditions: list, condition_type: str) -> Optional[dict]:
+    """Find a condition by type from the conditions array."""
+    for c in conditions:
+        if c.get("type") == condition_type:
+            return c
+    return None
+
+
+def _format_elapsed(phase_started_at: Optional[str]) -> str:
+    """Format elapsed time since phaseStartedAt as a human-readable string."""
+    if not phase_started_at:
+        return ""
+    try:
+        started = datetime.fromisoformat(phase_started_at.replace("Z", "+00:00"))
+        elapsed = datetime.now(timezone.utc) - started
+        total_seconds = int(elapsed.total_seconds())
+        if total_seconds < 0:
+            return ""
+        if total_seconds < 60:
+            return f"{total_seconds}s"
+        minutes = total_seconds // 60
+        seconds = total_seconds % 60
+        return f"{minutes}m {seconds}s"
+    except (ValueError, TypeError):
+        return ""
+
+
+def _format_revision_line(label: str, rev: dict) -> str:
+    """Format a single revision as an indented detail line."""
+    deploy_id = rev.get("deploymentID", "unknown")[:8]
+    phase = rev.get("phase", "Unknown")
+    ready_replicas = rev.get("readyReplicas")
+
+    parts = [f"    [dim]{label}[/dim] [bold]({deploy_id})[/bold] {phase}"]
+    if ready_replicas is not None:
+        parts.append(f"[dim]·[/dim] {ready_replicas} agents")
+
+    elapsed = _format_elapsed(rev.get("phaseStartedAt"))
+    if elapsed:
+        parts.append(f"[dim]·[/dim] [dim]{elapsed}[/dim]")
+
+    return " ".join(parts)
+
+
+def _build_status_message(headline: str, current_rev=None, previous_rev=None) -> str:
+    """Build a multi-line status message with optional revision detail lines."""
+    lines = [headline]
+    if current_rev:
+        lines.append(_format_revision_line("Current ", current_rev))
+    if previous_rev:
+        lines.append(_format_revision_line("Previous", previous_rev))
+    return "\n".join(lines)
+
+
+def interpret_deployment_status(
+    agent_status: dict,
+    desired_deployment_id: Optional[str] = None,
+) -> DeploymentStatus:
+    """Interpret the raw API response into a structured deployment status.
+
+    Examines reconciledDeploymentId, conditions array, available/ready booleans,
+    and revision info to determine the current deployment phase and build a
+    human-readable status message.
+    """
+    reconciled_id = agent_status.get("reconciledDeploymentId")
+    desired_id = desired_deployment_id or agent_status.get(
+        "desiredDeploymentId", agent_status.get("activeDeploymentId")
+    )
+    conditions = agent_status.get("conditions") or []
+    available = agent_status.get("available", agent_status.get("ready", False))
+    ready = agent_status.get("ready", False)
+    active_deployment_ready = agent_status.get("activeDeploymentReady", False)
+
+    current_rev = agent_status.get("currentRevision")
+    previous_rev = agent_status.get("previousRevision")
+
+    # 1. Check if operator has reconciled
+    if desired_id and reconciled_id != desired_id:
+        return DeploymentStatus(
+            phase=DeploymentPhase.WAITING_FOR_OPERATOR,
+            status_message="[dim]Waiting for operator to process deployment...[/dim]",
+            current_revision=current_rev,
+            previous_revision=previous_rev,
+        )
+
+    # 2. Fully ready
+    if available and (ready or active_deployment_ready):
+        return DeploymentStatus(
+            phase=DeploymentPhase.READY,
+            status_message="[green]Deployment is ready[/green]",
+            is_available=True,
+            is_ready=True,
+            current_revision=current_rev,
+            previous_revision=previous_rev,
+        )
+
+    # 3. Look at conditions for richer status
+    degraded = _find_condition(conditions, "Degraded")
+    progressing = _find_condition(conditions, "Progressing")
+
+    degraded_active = degraded and degraded.get("status") == "True"
+    degraded_reason = (
+        degraded.get("message", degraded.get("reason", "")) if degraded_active else None
+    )
+
+    # 4. Degraded but available — warning state
+    if degraded_active and available:
+        headline = f"[yellow]Degraded · Available[/yellow] [dim]— {degraded_reason}[/dim]"
+        return DeploymentStatus(
+            phase=DeploymentPhase.DEGRADED_AVAILABLE,
+            status_message=_build_status_message(headline, current_rev, previous_rev),
+            is_available=True,
+            degraded_reason=degraded_reason,
+            current_revision=current_rev,
+            previous_revision=previous_rev,
+        )
+
+    # 5. Available but not ready — rolling update in progress
+    if available and not ready:
+        headline = "[cyan]Progressing · Available[/cyan]"
+        return DeploymentStatus(
+            phase=DeploymentPhase.PROGRESSING_AVAILABLE,
+            status_message=_build_status_message(headline, current_rev, previous_rev),
+            is_available=True,
+            current_revision=current_rev,
+            previous_revision=previous_rev,
+        )
+
+    # 6. Not available, progressing — new service coming up
+    if not available and (progressing and progressing.get("status") == "True"):
+        headline = "[dim]Progressing[/dim]"
+        return DeploymentStatus(
+            phase=DeploymentPhase.PROGRESSING_NEW,
+            status_message=_build_status_message(headline, current_rev, previous_rev),
+            current_revision=current_rev,
+            previous_revision=previous_rev,
+        )
+
+    # 7. Not available, not progressing — broken
+    if not available and not ready:
+        reason_suffix = f" [dim]— {degraded_reason}[/dim]" if degraded_reason else ""
+        headline = f"[red]Unavailable[/red]{reason_suffix}"
+        return DeploymentStatus(
+            phase=DeploymentPhase.UNAVAILABLE,
+            status_message=_build_status_message(headline, current_rev, previous_rev),
+            current_revision=current_rev,
+            previous_revision=previous_rev,
+        )
+
+    # Fallback — shouldn't normally reach here
+    return DeploymentStatus(
+        phase=DeploymentPhase.PROGRESSING_NEW,
+        status_message="[dim]Waiting for deployment to become ready...[/dim]",
+        current_revision=current_rev,
+        previous_revision=previous_rev,
+    )
+
+
 @dataclass
 class ScalingParams:
     min_agents: Optional[int] = 0

{pipecatcloud-0.3.0 → pipecatcloud-0.3.1}/src/pipecatcloud/cli/commands/agent.py

@@ -277,7 +277,44 @@ async def status(
                 border_style="red",
             )
 
-        color = "bold green" if data["ready"] else "bold yellow"
+        # Build health/status panel with revision info when available
+        current_rev = data.get("currentRevision")
+        previous_rev = data.get("previousRevision")
+
+        if current_rev:
+            # Rich status with revision details
+            health_lines = []
+
+            rev_phase = current_rev.get("phase", "Unknown")
+            rev_id = current_rev.get("deploymentID", "")[:8]
+            rev_replicas = current_rev.get("readyReplicas")
+
+            if data["ready"]:
+                health_lines.append("[bold green]Ready[/bold green]")
+            else:
+                health_lines.append(f"[bold yellow]{rev_phase}[/bold yellow]")
+
+            current_parts = [f"  Current  [bold]({rev_id})[/bold] {rev_phase}"]
+            if rev_replicas is not None:
+                current_parts.append(f"[dim]·[/dim] {rev_replicas} agents")
+            health_lines.append(" ".join(current_parts))
+
+            if previous_rev:
+                prev_phase = previous_rev.get("phase", "Unknown")
+                prev_id = previous_rev.get("deploymentID", "")[:8]
+                prev_replicas = previous_rev.get("readyReplicas")
+                prev_parts = [f"  Previous [bold]({prev_id})[/bold] {prev_phase}"]
+                if prev_replicas is not None:
+                    prev_parts.append(f"[dim]·[/dim] {prev_replicas} agents")
+                health_lines.append(" ".join(prev_parts))
+
+            health_content = "\n".join(health_lines)
+            health_border = "green" if data["ready"] else "yellow"
+        else:
+            # Fallback: no revision data from API
+            health_content = f"[{'bold green' if data['ready'] else 'bold yellow'}]Health: {'Ready' if data['ready'] else 'Stopped'}[/]"
+            health_border = "green" if data["ready"] else "yellow"
+
         subtitle = (
             f"[dim]Start a new active session with[/dim] [bold cyan]{PIPECAT_CLI_NAME} agent start {agent_name}[/bold cyan]"
             if data["ready"]
@@ -289,8 +326,8 @@ async def status(
                     deployment_table,
                     scaling_panel if scaling_panel else "",
                     Panel(
-                        f"[{color}]Health: {'Ready' if data['ready'] else 'Stopped'}[/]",
-                        border_style="green" if data["ready"] else "yellow",
+                        health_content,
+                        border_style=health_border,
                         expand=False,
                     ),
                     error_panel if error_panel else "",

{pipecatcloud-0.3.0 → pipecatcloud-0.3.1}/src/pipecatcloud/cli/commands/build.py

@@ -20,6 +20,7 @@ from pipecatcloud._utils.async_utils import synchronizer
 from pipecatcloud._utils.auth_utils import requires_login
 from pipecatcloud._utils.build_utils import BuildStatus, format_size
 from pipecatcloud._utils.console_utils import console, format_timestamp
+from pipecatcloud.cli import PIPECAT_CLI_NAME
 from pipecatcloud.cli.api import API
 from pipecatcloud.cli.config import config
 
@@ -90,7 +91,7 @@ async def logs(
         console.print("[dim]No logs available for this build yet[/dim]")
         console.print(
             f"\n[dim]The build may still be starting. "
-            f"Check status with:[/dim] [bold]pcc build status {build_id}[/bold]"
+            f"Check status with:[/dim] [bold]{PIPECAT_CLI_NAME} build status {build_id}[/bold]"
         )
         return
 
@@ -211,11 +212,13 @@ async def status(
 
     # Show helpful commands based on status
     if status_val in (BuildStatus.FAILED, BuildStatus.TIMEOUT):
-        console.print(f"\n[dim]View full logs:[/dim] [bold]pcc build logs {build_id}[/bold]")
+        console.print(
+            f"\n[dim]View full logs:[/dim] [bold]{PIPECAT_CLI_NAME} build logs {build_id}[/bold]"
+        )
     elif status_val in (BuildStatus.PENDING, BuildStatus.BUILDING):
         console.print("\n[dim]Build in progress. Check again or view logs:[/dim]")
-        console.print(f"  [bold]pcc build status {build_id}[/bold]")
-        console.print(f"  [bold]pcc build logs {build_id}[/bold]")
+        console.print(f"  [bold]{PIPECAT_CLI_NAME} build status {build_id}[/bold]")
+        console.print(f"  [bold]{PIPECAT_CLI_NAME} build logs {build_id}[/bold]")
 
 
 @build_cli.command(name="list", help="List recent cloud builds")
@@ -302,4 +305,6 @@ async def list_builds(
         title_extra=showing_text,
     )
 
-    console.print("\n[dim]View build details:[/dim] [bold]pcc build status <build-id>[/bold]")
+    console.print(
+        f"\n[dim]View build details:[/dim] [bold]{PIPECAT_CLI_NAME} build status <build-id>[/bold]"
+    )

{pipecatcloud-0.3.0 → pipecatcloud-0.3.1}/src/pipecatcloud/cli/commands/deploy.py

@@ -32,6 +32,7 @@ from pipecatcloud._utils.deploy_utils import (
     DeployConfigParams,
     KrispVivaConfig,
     ScalingParams,
+    interpret_deployment_status,
     with_deploy_config,
 )
 from pipecatcloud._utils.regions import get_region_codes, validate_region
@@ -40,7 +41,7 @@ from pipecatcloud.cli.api import API
 from pipecatcloud.cli.config import config
 from pipecatcloud.constants import KRISP_VIVA_MODELS, Region
 
-MAX_ALIVE_CHECKS = 18
+MAX_ALIVE_CHECKS = 120
 ALIVE_CHECK_SLEEP = 5
 
 # ----- Cloud Build Flow
@@ -238,7 +239,7 @@ async def _cloud_build_flow(
         error_msg = final_build.get("errorMessage", final_build.get("error", "Unknown error"))
         console.error(
             f"Build failed: {error_msg}\n\n"
-            f"[dim]View logs with:[/dim] [bold]pcc build logs {build_id}[/bold]"
+            f"[dim]View logs with:[/dim] [bold]{PIPECAT_CLI_NAME} build logs {build_id}[/bold]"
         )
         return None
 
@@ -349,6 +350,7 @@ async def _deploy(params: DeployConfigParams, org, force: bool = False):
     """
     active_deployment_id = None
     is_ready = False
+    last_status = None
     checks_performed = 0
 
     console.print(
@@ -387,42 +389,29 @@ async def _deploy(params: DeployConfigParams, org, force: bool = False):
                     console.error("Error checking deployment status")
                     return typer.Exit()
 
-                # Get deployment IDs
-                # - desiredDeploymentId (or activeDeploymentId): what we requested
-                # - reconciledDeploymentId: what the operator has actually processed
+                # Capture the deployment ID for display
                 desired_deployment_id = agent_status.get(
                     "desiredDeploymentId", agent_status.get("activeDeploymentId")
                 )
-                reconciled_deployment_id = agent_status.get("reconciledDeploymentId")
-
-                # Update status message with deployment ID
                 if desired_deployment_id and not active_deployment_id:
                     active_deployment_id = desired_deployment_id
-                    deployment_status_message = f"[dim]Waiting for deployment to become ready (deployment ID: {active_deployment_id})...[/dim]"
-                    status.update(deployment_status_message)
-
-                # Check if operator has reconciled this deployment
-                deployment_reconciled = reconciled_deployment_id == desired_deployment_id
-                if not deployment_reconciled:
-                    logger.debug(
-                        f"Waiting for operator to reconcile: desired={desired_deployment_id}, reconciled={reconciled_deployment_id}"
-                    )
-                    await asyncio.sleep(ALIVE_CHECK_SLEEP)
-                    checks_performed += 1
-                    continue
-
-                # Check if deployment is ready
-                # For KEDA deployments, we need:
-                # - available: true (can handle traffic)
-                # - activeDeploymentReady: true (ReplicaSet is ready)
-                # The 'available' field falls back to 'ready' if not present (for backwards compatibility)
-                available = agent_status.get("available", agent_status.get("ready", False))
-                deployment_ready = agent_status.get("activeDeploymentReady", False)
-
-                if available and deployment_ready:
+
+                # Interpret status using conditions, availability, and revision info
+                last_status = interpret_deployment_status(
+                    agent_status, desired_deployment_id=desired_deployment_id
+                )
+
+                logger.debug(
+                    f"Interpreted phase: {last_status.phase}, available: {last_status.is_available}"
+                )
+
+                if last_status.is_ready:
                     is_ready = True
                     break
 
+                # Update spinner with current status message
+                status.update(last_status.status_message)
+
                 # Wait before checking again
                 await asyncio.sleep(ALIVE_CHECK_SLEEP)
                 checks_performed += 1
@@ -450,9 +439,36 @@ async def _deploy(params: DeployConfigParams, org, force: bool = False):
             f"{extra_message}",
             title_extra=f"{'Update' if existing_agent else 'Deployment'} complete",
         )
+    elif last_status and last_status.is_available:
+        # Timed out but service is available — soft warning, not a hard error
+        timeout_seconds = MAX_ALIVE_CHECKS * ALIVE_CHECK_SLEEP
+        console.print(
+            Panel(
+                f"Service is available and serving traffic, but the new deployment hasn't fully rolled out after {timeout_seconds}s.\n"
+                f"This is normal for deployments with large images or high replica counts.\n\n"
+                f"[bold]Check status:[/bold]  `{PIPECAT_CLI_NAME} agent status {params.agent_name}`\n"
+                f"[bold]View logs:[/bold]    `{PIPECAT_CLI_NAME} agent logs {params.agent_name}`",
+                title="Deployment still in progress",
+                title_align="left",
+                border_style="yellow",
+            )
+        )
+    elif last_status and last_status.degraded_reason:
+        # Timed out with degraded status
+        console.print(
+            Panel(
+                f"Deployment is degraded: {last_status.degraded_reason}\n\n"
+                f"[bold]Check status:[/bold]  `{PIPECAT_CLI_NAME} agent status {params.agent_name}`\n"
+                f"[bold]View logs:[/bold]    `{PIPECAT_CLI_NAME} agent logs {params.agent_name}`",
+                title="Deployment degraded",
+                title_align="left",
+                border_style="red",
+            )
+        )
     else:
+        timeout_seconds = MAX_ALIVE_CHECKS * ALIVE_CHECK_SLEEP
         console.error(
-            f"Deployment did not enter ready state within {MAX_ALIVE_CHECKS * ALIVE_CHECK_SLEEP} seconds. "
+            f"Deployment did not become available within {timeout_seconds} seconds.\n"
             f"Please check logs with `{PIPECAT_CLI_NAME} agent logs {params.agent_name}`"
         )
 

{pipecatcloud-0.3.0 → pipecatcloud-0.3.1}/src/pipecatcloud.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 0.3.0
+Version: 0.3.1
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/

{pipecatcloud-0.3.0 → pipecatcloud-0.3.1}/src/pipecatcloud.egg-info/SOURCES.txt

@@ -54,6 +54,7 @@ tests/__init__.py
 tests/test_agent_sessions.py
 tests/test_agent_stop.py
 tests/test_api_client.py
+tests/test_deployment_status.py
 tests/test_docker_commands.py
 tests/test_krisp_viva.py
 tests/test_managed_keys.py

pipecatcloud-0.3.1/tests/test_deployment_status.py

@@ -0,0 +1,478 @@
+"""
+Unit tests for deployment status interpretation.
+
+Tests the interpret_deployment_status function which maps raw API responses
+to structured DeploymentStatus objects used for CLI display during deploy polling.
+"""
+
+from pipecatcloud._utils.deploy_utils import (
+    DeploymentPhase,
+    _format_elapsed,
+    _format_revision_line,
+    interpret_deployment_status,
+)
+
+
+class TestWaitingForOperator:
+    """When reconciledDeploymentId != desiredDeploymentId, operator hasn't processed yet."""
+
+    def test_unreconciled_deployment(self):
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-new",
+                "reconciledDeploymentId": "deploy-old",
+                "available": False,
+                "ready": False,
+            },
+            desired_deployment_id="deploy-new",
+        )
+        assert status.phase == DeploymentPhase.WAITING_FOR_OPERATOR
+        assert not status.is_available
+        assert not status.is_ready
+
+    def test_no_reconciled_id_yet(self):
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-new",
+                "reconciledDeploymentId": None,
+                "available": False,
+                "ready": False,
+            },
+            desired_deployment_id="deploy-new",
+        )
+        assert status.phase == DeploymentPhase.WAITING_FOR_OPERATOR
+
+
+class TestReady:
+    """When available=true and ready=true (or activeDeploymentReady=true)."""
+
+    def test_available_and_ready(self):
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-1",
+                "reconciledDeploymentId": "deploy-1",
+                "available": True,
+                "ready": True,
+            },
+            desired_deployment_id="deploy-1",
+        )
+        assert status.phase == DeploymentPhase.READY
+        assert status.is_available
+        assert status.is_ready
+
+    def test_available_and_active_deployment_ready(self):
+        """activeDeploymentReady is the legacy field, should still trigger READY."""
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-1",
+                "reconciledDeploymentId": "deploy-1",
+                "available": True,
+                "ready": False,
+                "activeDeploymentReady": True,
+            },
+            desired_deployment_id="deploy-1",
+        )
+        assert status.phase == DeploymentPhase.READY
+        assert status.is_available
+        assert status.is_ready
+
+    def test_ready_fallback_to_ready_field(self):
+        """When 'available' is missing, falls back to 'ready'."""
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-1",
+                "reconciledDeploymentId": "deploy-1",
+                "ready": True,
+                "activeDeploymentReady": True,
+            },
+            desired_deployment_id="deploy-1",
+        )
+        assert status.phase == DeploymentPhase.READY
+
+
+class TestProgressingAvailable:
+    """Available but not ready — rolling update with existing service serving traffic."""
+
+    def test_available_not_ready(self):
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-2",
+                "reconciledDeploymentId": "deploy-2",
+                "available": True,
+                "ready": False,
+                "conditions": [
+                    {"type": "Available", "status": "True"},
+                    {"type": "Progressing", "status": "True"},
+                ],
+            },
+            desired_deployment_id="deploy-2",
+        )
+        assert status.phase == DeploymentPhase.PROGRESSING_AVAILABLE
+        assert status.is_available
+        assert not status.is_ready
+        assert "Progressing" in status.status_message
+        assert "Available" in status.status_message
+
+    def test_available_not_ready_with_revision_info(self):
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-2",
+                "reconciledDeploymentId": "deploy-2",
+                "available": True,
+                "ready": False,
+                "currentRevision": {
+                    "deploymentID": "deploy-2",
+                    "phase": "Validating",
+                    "readyReplicas": 42,
+                },
+                "previousRevision": {
+                    "deploymentID": "deploy-1",
+                    "phase": "Draining",
+                    "readyReplicas": 84,
+                },
+            },
+            desired_deployment_id="deploy-2",
+        )
+        assert status.phase == DeploymentPhase.PROGRESSING_AVAILABLE
+        assert status.is_available
+        # Multi-line: headline + current + previous
+        lines = status.status_message.split("\n")
+        assert len(lines) == 3
+        assert "42 agents" in lines[1]
+        assert "Validating" in lines[1]
+        assert "84 agents" in lines[2]
+        assert "Draining" in lines[2]
+        assert status.current_revision["readyReplicas"] == 42
+        assert status.previous_revision["phase"] == "Draining"
+
+
+class TestProgressingNew:
+    """Not available, but progressing — new service coming up for the first time."""
+
+    def test_not_available_progressing(self):
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-1",
+                "reconciledDeploymentId": "deploy-1",
+                "available": False,
+                "ready": False,
+                "conditions": [
+                    {"type": "Progressing", "status": "True"},
+                ],
+            },
+            desired_deployment_id="deploy-1",
+        )
+        assert status.phase == DeploymentPhase.PROGRESSING_NEW
+        assert not status.is_available
+        assert not status.is_ready
+        assert "Progressing" in status.status_message
+
+    def test_not_available_progressing_with_agents(self):
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-1",
+                "reconciledDeploymentId": "deploy-1",
+                "available": False,
+                "ready": False,
+                "conditions": [
+                    {"type": "Progressing", "status": "True"},
+                ],
+                "currentRevision": {
+                    "deploymentID": "deploy-1",
+                    "phase": "Creating",
+                    "readyReplicas": 3,
+                },
+            },
+            desired_deployment_id="deploy-1",
+        )
+        assert status.phase == DeploymentPhase.PROGRESSING_NEW
+        lines = status.status_message.split("\n")
+        assert len(lines) == 2
+        assert "3 agents" in lines[1]
+        assert "Creating" in lines[1]
+
+
+class TestDegradedAvailable:
+    """Available but degraded — serving traffic but something is wrong."""
+
+    def test_degraded_and_available(self):
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-1",
+                "reconciledDeploymentId": "deploy-1",
+                "available": True,
+                "ready": False,
+                "conditions": [
+                    {"type": "Available", "status": "True"},
+                    {
+                        "type": "Degraded",
+                        "status": "True",
+                        "reason": "ImageResolutionFailed",
+                        "message": "Failed to resolve image tag",
+                    },
+                ],
+            },
+            desired_deployment_id="deploy-1",
+        )
+        assert status.phase == DeploymentPhase.DEGRADED_AVAILABLE
+        assert status.is_available
+        assert not status.is_ready
+        assert status.degraded_reason == "Failed to resolve image tag"
+        assert "Degraded" in status.status_message
+        assert "Available" in status.status_message
+
+    def test_degraded_reason_falls_back_to_reason_field(self):
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-1",
+                "reconciledDeploymentId": "deploy-1",
+                "available": True,
+                "ready": False,
+                "conditions": [
+                    {
+                        "type": "Degraded",
+                        "status": "True",
+                        "reason": "SomeReason",
+                    },
+                ],
+            },
+            desired_deployment_id="deploy-1",
+        )
+        assert status.phase == DeploymentPhase.DEGRADED_AVAILABLE
+        assert status.degraded_reason == "SomeReason"
+
+
+class TestUnavailable:
+    """Not available and not progressing — broken."""
+
+    def test_not_available_not_progressing(self):
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-1",
+                "reconciledDeploymentId": "deploy-1",
+                "available": False,
+                "ready": False,
+                "conditions": [],
+            },
+            desired_deployment_id="deploy-1",
+        )
+        assert status.phase == DeploymentPhase.UNAVAILABLE
+        assert not status.is_available
+        assert not status.is_ready
+        assert "Unavailable" in status.status_message
+
+    def test_unavailable_with_degraded_reason(self):
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-1",
+                "reconciledDeploymentId": "deploy-1",
+                "available": False,
+                "ready": False,
+                "conditions": [
+                    {
+                        "type": "Degraded",
+                        "status": "True",
+                        "message": "CrashLoopBackOff",
+                    },
+                ],
+            },
+            desired_deployment_id="deploy-1",
+        )
+        assert status.phase == DeploymentPhase.UNAVAILABLE
+        assert "CrashLoopBackOff" in status.status_message
+
+
+class TestBackwardCompatibility:
+    """Tests for API responses that don't include new fields (conditions, revisions)."""
+
+    def test_no_conditions_field(self):
+        """Old API without conditions array should still work."""
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-1",
+                "reconciledDeploymentId": "deploy-1",
+                "available": True,
+                "ready": True,
+            },
+            desired_deployment_id="deploy-1",
+        )
+        assert status.phase == DeploymentPhase.READY
+
+    def test_no_revision_info(self):
+        """API without revision fields should work — single-line message, no replica info."""
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-1",
+                "reconciledDeploymentId": "deploy-1",
+                "available": True,
+                "ready": False,
+            },
+            desired_deployment_id="deploy-1",
+        )
+        assert status.phase == DeploymentPhase.PROGRESSING_AVAILABLE
+        assert status.current_revision is None
+        # No revision info → single line, no "agents"
+        assert "\n" not in status.status_message
+        assert "agents" not in status.status_message
+
+    def test_legacy_ready_field_only(self):
+        """Very old API that only has 'ready' field."""
+        status = interpret_deployment_status(
+            {
+                "activeDeploymentId": "deploy-1",
+                "reconciledDeploymentId": "deploy-1",
+                "ready": True,
+                "activeDeploymentReady": True,
+            },
+            desired_deployment_id="deploy-1",
+        )
+        assert status.phase == DeploymentPhase.READY
+
+    def test_no_desired_deployment_id(self):
+        """When desired_deployment_id is None, skip reconciliation check."""
+        status = interpret_deployment_status(
+            {
+                "available": True,
+                "ready": True,
+            },
+        )
+        assert status.phase == DeploymentPhase.READY
+
+
+class TestRevisionLines:
+    """Tests for multi-line revision detail rendering."""
+
+    def test_current_revision_line_format(self):
+        line = _format_revision_line(
+            "Current ",
+            {
+                "deploymentID": "73071caf-abcd-1234",
+                "phase": "Validating",
+                "readyReplicas": 42,
+            },
+        )
+        assert "73071caf" in line
+        assert "Validating" in line
+        assert "42 agents" in line
+
+    def test_previous_revision_line_format(self):
+        line = _format_revision_line(
+            "Previous",
+            {
+                "deploymentID": "15122a6b-efgh-5678",
+                "phase": "Draining",
+                "readyReplicas": 68,
+            },
+        )
+        assert "15122a6b" in line
+        assert "Draining" in line
+        assert "68 agents" in line
+
+    def test_revision_line_with_elapsed_time(self):
+        from datetime import datetime, timezone
+
+        recent = (datetime.now(timezone.utc)).isoformat()
+        line = _format_revision_line(
+            "Current ",
+            {
+                "deploymentID": "abcdef12",
+                "phase": "Validating",
+                "readyReplicas": 10,
+                "phaseStartedAt": recent,
+            },
+        )
+        assert "Validating" in line
+        assert "10 agents" in line
+        # Should have a time component (0s or 1s)
+        assert "s" in line
+
+    def test_revision_line_without_agents(self):
+        """Revision with no readyReplicas field should omit replica count."""
+        line = _format_revision_line(
+            "Current ",
+            {
+                "deploymentID": "abcdef12",
+                "phase": "Creating",
+            },
+        )
+        assert "Creating" in line
+        assert "agents" not in line
+
+    def test_multi_line_message_with_both_revisions(self):
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-2",
+                "reconciledDeploymentId": "deploy-2",
+                "available": True,
+                "ready": False,
+                "currentRevision": {
+                    "deploymentID": "deploy-2-full-uuid",
+                    "phase": "Validating",
+                    "readyReplicas": 42,
+                },
+                "previousRevision": {
+                    "deploymentID": "deploy-1-full-uuid",
+                    "phase": "Draining",
+                    "readyReplicas": 68,
+                },
+            },
+            desired_deployment_id="deploy-2",
+        )
+        lines = status.status_message.split("\n")
+        assert len(lines) == 3
+        # Line 0: condition headline
+        assert "Progressing" in lines[0]
+        assert "Available" in lines[0]
+        # Line 1: current revision (deploymentID truncated to 8 chars)
+        assert "Current" in lines[1]
+        assert "deploy-2" in lines[1]
+        assert "42 agents" in lines[1]
+        # Line 2: previous revision
+        assert "Previous" in lines[2]
+        assert "deploy-1" in lines[2]
+        assert "68 agents" in lines[2]
+
+    def test_single_line_when_no_revisions(self):
+        """Without revision data, message stays single-line."""
+        status = interpret_deployment_status(
+            {
+                "desiredDeploymentId": "deploy-1",
+                "reconciledDeploymentId": "deploy-1",
+                "available": False,
+                "ready": False,
+                "conditions": [{"type": "Progressing", "status": "True"}],
+            },
+            desired_deployment_id="deploy-1",
+        )
+        assert "\n" not in status.status_message
+
+
+class TestFormatElapsed:
+    """Tests for the elapsed time formatter."""
+
+    def test_none_input(self):
+        assert _format_elapsed(None) == ""
+
+    def test_invalid_input(self):
+        assert _format_elapsed("not-a-date") == ""
+
+    def test_recent_timestamp(self):
+        from datetime import datetime, timezone
+
+        now = datetime.now(timezone.utc).isoformat()
+        result = _format_elapsed(now)
+        assert result in ("0s", "1s")
+
+    def test_minutes_ago(self):
+        from datetime import datetime, timedelta, timezone
+
+        two_min_ago = (datetime.now(timezone.utc) - timedelta(minutes=2, seconds=30)).isoformat()
+        result = _format_elapsed(two_min_ago)
+        assert result.startswith("2m")
+
+    def test_z_suffix(self):
+        from datetime import datetime, timedelta, timezone
+
+        ts = (datetime.now(timezone.utc) - timedelta(seconds=45)).strftime("%Y-%m-%dT%H:%M:%SZ")
+        result = _format_elapsed(ts)
+        assert "s" in result