I’ve added two new columns to the dp_conversations table in Supabase:

- defer_until date
- defer_reason text

The table already has:
- conversation_id (uuid, PK)
- status (text, default 'active')

I want two new endpoints in the FastAPI app so Lia (the AI layer) or a manager can pause and resume conversations:

1) POST /api/conversations/{conversation_id}/defer
2) POST /api/conversations/{conversation_id}/resume

Please do the following:

1. In app/db.py:

   a) Add an async function to defer a conversation:

      async def defer_conversation(conversation_id: str, defer_until: date, reason: str | None = None) -> bool:
          - Use the existing asyncpg connection pattern (get_conn / release).
          - Update dp_conversations set:
              status = 'paused',
              defer_until = $2,
              defer_reason = $3,
              updated_at = now()
            where conversation_id = $1;
          - Return True if a row was updated, False otherwise.

   b) Add an async function to resume a conversation:

      async def resume_conversation(conversation_id: str) -> bool:
          - Set:
              status = 'active',
              defer_until = null,
              defer_reason = null,
              updated_at = now()
            where conversation_id = $1;
          - Return True if a row was updated.

   Follow the same error handling / logging conventions as the other db helper functions.

2. In app/main.py:

   a) Import the new functions from app.db:

      from app.db import defer_conversation, resume_conversation

   b) Add a new route to defer a conversation:

      @app.post("/api/conversations/{conversation_id}/defer")
      async def api_defer_conversation(
          conversation_id: str,
          payload: dict,
          user: dict = Depends(require_auth),
      ):
          """
          Pause a conversation until a future date.
          Used by the AI layer when the customer says "not right now" or similar.
          """
          from datetime import date

          defer_until_str = payload.get("defer_until")
          reason = payload.get("reason", None)

          if not defer_until_str:
              return JSONResponse({"error": "defer_until is required (YYYY-MM-DD)"}, status_code=400)

          try:
              defer_until = date.fromisoformat(defer_until_str)
          except ValueError:
              return JSONResponse({"error": "Invalid date format for defer_until"}, status_code=400)

          ok = await defer_conversation(conversation_id, defer_until, reason)
          if not ok:
              return JSONResponse({"error": "Conversation not found"}, status_code=404)

          return {"status": "ok", "conversation_id": conversation_id, "defer_until": defer_until_str}

   c) Add a route to resume a conversation:

      @app.post("/api/conversations/{conversation_id}/resume")
      async def api_resume_conversation(
          conversation_id: str,
          user: dict = Depends(require_auth),
      ):
          """
          Resume a paused conversation (e.g. manager override from T-card, or scheduled reactivation).
          """
          ok = await resume_conversation(conversation_id)
          if not ok:
              return JSONResponse({"error": "Conversation not found"}, status_code=404)

          return {"status": "ok", "conversation_id": conversation_id}

   Ensure both endpoints are protected with the same require_auth dependency used on other internal APIs.

3. After implementing, run the app and test with curl or the built-in HTTP client:

   - POST /api/conversations/{id}/defer with JSON:
       { "defer_until": "2026-02-01", "reason": "customer said not right now – try again in 2 months" }

   - Check in the database:
       select status, defer_until, defer_reason
       from dp_conversations
       where conversation_id = '<that-id>';

   - Then call:
       POST /api/conversations/{id}/resume

   - Confirm status is 'active' and defer_until / defer_reason are null.