I want the Reminders tab to show the conversation status (active / paused until X) for each appointment, using the dp_conversations table and the existing defer/resume logic.

Please do the following changes.

1) BACKEND – add a status fetch helper and endpoint

In app/db.py:

- Add a function to fetch status + defer info for a conversation:

  async def fetch_conversation_status(conversation_id: str):
      """
      Return status, defer_until, and defer_reason for a given conversation_id.
      """
      import uuid
      conv_uuid = uuid.UUID(conversation_id)

      conn = await get_conn()
      try:
          row = await conn.fetchrow(
              """
              select status, defer_until, defer_reason
              from dp_conversations
              where conversation_id = $1
              """,
              conv_uuid,
          )
          if not row:
              return None
          return {
              "status": row["status"],
              "defer_until": row["defer_until"],
              "defer_reason": row["defer_reason"],
          }
      finally:
          await release_conn(conn)

In app/main.py:

- Import the helper:

  from app.db import fetch_conversation_status

- Add a new endpoint:

  @app.get("/api/conversations/{conversation_id}/status")
  async def api_conversation_status(
      conversation_id: str,
      user: dict = Depends(require_auth),
  ):
      """
      Return the current status of a conversation: active/paused and any defer info.
      """
      data = await fetch_conversation_status(conversation_id)
      if not data:
          return JSONResponse({"error": "Conversation not found"}, status_code=404)

      return {
          "conversation_id": conversation_id,
          "status": data["status"],
          "defer_until": data["defer_until"],
          "defer_reason": data["defer_reason"],
      }

2) BACKEND – extend /api/reminders stub to include conversation_id

In app/main.py, find the api_reminders() endpoint. The base list currently looks like this:

    base = [
        {
            "id": "rem_1",
            "date": str(today),
            "time": "10:30",
            "customer_name": "Alex Smith",
            "reg": "FY23 ABC",
            "reason": "End-of-term options review (12 months)",
            "advisor": "Jamie",
            "channel": "WhatsApp"
        },
        ...

Update each reminder dict to also include a conversation_id field. For example:

        {
            "id": "rem_1",
            "conversation_id": "05decb80-fd14-4d07-856b-52cd5b4ae242",
            "date": str(today),
            "time": "10:30",
            "customer_name": "Alex Smith",
            "reg": "FY23 ABC",
            "reason": "End-of-term options review (12 months)",
            "advisor": "Jamie",
            "channel": "WhatsApp"
        },

For the other sample reminders, either reuse that UUID or generate a couple more valid UUID strings. The important thing is that the frontend has a conversation_id property on each reminder.

3) FRONTEND – show conversation status in the Reminders script panel

In app/templates/dashboard.html, in the Reminders section, find the script preview card markup. It currently looks like:

      <div class="bg-white border border-dp-silver rounded-xl shadow-card p-4 md:p-5 space-y-2">
        <div class="flex items-center justify-between gap-2 mb-1">
          <h3 class="text-sm font-semibold text-dp-ink">Message preview</h3>
          <p class="text-[11px] text-neutral-500" id="rem-selected-label">No appointment selected</p>
        </div>
        <textarea
          id="rem-script-preview"
          ...

Under the rem-selected-label <p>, add another small line for status:

          <p class="text-[11px] text-neutral-400" id="rem-conversation-status">
            Status: —
          </p>

4) FRONTEND – add a helper to fetch and show conversation status

Inside the <script> block in the same file, near the other helpers, add:

  async function updateConversationStatus(rem) {
    const statusEl = document.getElementById("rem-conversation-status");
    if (!statusEl) return;

    const convId = rem.conversation_id;
    if (!convId) {
      statusEl.textContent = "Status: Not linked";
      return;
    }

    try {
      const res = await fetch(`/api/conversations/${encodeURIComponent(convId)}/status`);
      if (!res.ok) {
        statusEl.textContent = "Status: Active (no defer set)";
        return;
      }
      const data = await res.json();
      const status = data.status || "active";
      const deferUntil = data.defer_until;
      const reason = data.defer_reason;

      if (status === "paused" && deferUntil) {
        let text = `Status: Paused until ${deferUntil}`;
        if (reason) {
          text += ` – ${reason}`;
        }
        statusEl.textContent = text;
      } else {
        statusEl.textContent = "Status: Active";
      }
    } catch (err) {
      console.error("Error loading conversation status", err);
      statusEl.textContent = "Status: Active";
    }
  }

5) FRONTEND – call updateConversationStatus when a reminder is clicked

In the loadReminders() function, we’ve already updated the click handler to be async and to fetch templates. It currently looks like this (after previous edits):

        li.addEventListener("click", async () => {
          const label = document.getElementById("rem-selected-label");
          const ta = document.getElementById("rem-script-preview");
          const typeSel = document.getElementById("rem-script-type");
          const mode = typeSel?.value || "reminder";
          if (!label || !ta) return;

          label.textContent = `${rem.customer_name || ""} • ${rem.date || ""} ${rem.time || ""}`;

          // Try to load from Supabase first
          let body = await fetchTemplateBody(mode);

          // If no template from API, fall back to local script builder
          if (!body) {
            body = buildReminderScript(rem, mode);
          } else {
            // Replace placeholders with whatever we know from the reminder object
            body = body
              .replace("[Customer Name]", rem.customer_name || "[Customer Name]")
              .replace("[Time]", rem.time || "[Time]")
              .replace("[Model]", rem.model || "[Model]");
          }

          ta.value = body;
          ta.scrollTop = 0;
        });

After ta.scrollTop = 0; add a call to updateConversationStatus(rem):

          ta.value = body;
          ta.scrollTop = 0;

          // Update conversation status line
          updateConversationStatus(rem);

6) Save all files and restart the dashboard server.

Then test in the browser:

- Go to Reminders tab
- Click on an appointment
- Confirm:
  - Message preview still works
  - A status line appears under the label:
    - If using the seeded paused conversation: "Status: Paused until YYYY-MM-DD – customer said not right now – default 2 month defer"
    - If no dp_conversations row exists: "Status: Active (no defer set)" or "Status: Active"
  - No errors show in the browser console.