I want to log every Lia message that’s generated and actually used from the Reminders tab.

We already have:
- dp_conversations with conversation_id
- dp_messages (just created) for logging
- A Reminders tab with:
  - a list of reminders (each with conversation_id)
  - a textarea with id="rem-script-preview"
  - a Message type select with id="rem-script-type"

Please implement the following.

1) BACKEND – add insert_message helper and API endpoint

In app/db.py:

- Add:

  async def insert_message(
      conversation_id: str,
      direction: str,
      channel: str,
      sender: str,
      message_body: str,
      template_key: str | None = None,
      mode: str | None = None,
  ) -> None:
      import uuid
      conv_uuid = uuid.UUID(conversation_id)
      conn = await get_conn()
      try:
          await conn.execute(
              """
              insert into dp_messages (
                  conversation_id, direction, channel, sender,
                  message_body, template_key, mode
              )
              values ($1, $2, $3, $4, $5, $6, $7)
              """,
              conv_uuid,
              direction,
              channel,
              sender,
              message_body,
              template_key,
              mode,
          )
      finally:
          await release_conn(conn)

In app/main.py:

- Import:

  from app.db import insert_message, get_conversation

(If get_conversation doesn’t exist, skip and just rely on insert_message – but ideally validate conversation_id.)

- Add a new route:

  @app.post("/api/messages")
  async def api_log_message(
      payload: dict,
      user: dict = Depends(require_auth),
  ):
      """
      Log an outbound or inbound message for a conversation.
      Used by the Reminders tab when an advisor uses a Lia script.
      """
      conversation_id = payload.get("conversation_id")
      message_body = payload.get("message_body")
      mode = payload.get("mode")  # 'reminder', 'missed', 'followup', 'noreply'
      template_key = payload.get("template_key")
      channel = payload.get("channel", "whatsapp")
      direction = payload.get("direction", "outbound")
      sender = payload.get("sender", "lia")

      if not conversation_id or not message_body:
          return JSONResponse({"error": "conversation_id and message_body are required"}, status_code=400)

      try:
          await insert_message(
              conversation_id=conversation_id,
              direction=direction,
              channel=channel,
              sender=sender,
              message_body=message_body,
              template_key=template_key,
              mode=mode,
          )
      except Exception:
          logger.exception("Failed to insert message")
          return JSONResponse({"error": "Failed to log message"}, status_code=500)

      return {"status": "ok"}

2) FRONTEND – add a “Mark as sent” button under the textarea

In app/templates/dashboard.html, in the Reminders script card, find the textarea:

  <textarea
    id="rem-script-preview"
    ...

Below the textarea, add:

        <div class="mt-2 flex justify-between items-center">
          <button
            id="rem-mark-sent"
            type="button"
            class="px-3 py-1.5 text-xs font-medium rounded-full border border-dp-silver bg-white hover:bg-neutral-50"
          >
            Mark as sent
          </button>
          <span id="rem-mark-status" class="text-[11px] text-neutral-400"></span>
        </div>

3) FRONTEND – wire the button to call /api/messages

In the <script> block, add state to track the last selected reminder:

  let lastSelectedReminder = null;

In loadReminders(), inside the click handler, after label/textarea updates, set:

          lastSelectedReminder = rem;

(So that when the button is pressed, we know which reminder/conversation is in context.)

Then, after the script block that defines loadReminders(), add:

  async function initReminderMarkSent() {
    const btn = document.getElementById("rem-mark-sent");
    const statusEl = document.getElementById("rem-mark-status");
    const typeSel = document.getElementById("rem-script-type");
    const ta = document.getElementById("rem-script-preview");

    if (!btn || !statusEl || !typeSel || !ta) return;

    btn.addEventListener("click", async () => {
      if (!lastSelectedReminder) {
        statusEl.textContent = "Select an appointment first.";
        return;
      }

      const convId = lastSelectedReminder.conversation_id;
      if (!convId) {
        statusEl.textContent = "No conversation linked.";
        return;
      }

      const mode = typeSel.value || "reminder";
      const templateKey = getTemplateKeyForMode(mode);
      const body = ta.value || "";

      if (!body.trim()) {
        statusEl.textContent = "No message to log.";
        return;
      }

      statusEl.textContent = "Logging…";

      try {
        const res = await fetch("/api/messages", {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            conversation_id: convId,
            message_body: body,
            mode,
            template_key: templateKey,
            channel: "whatsapp",
            direction: "outbound",
            sender: "lia"
          }),
        });

        if (!res.ok) {
          statusEl.textContent = "Failed to log message.";
          return;
        }

        statusEl.textContent = "Logged ✔";
        setTimeout(() => {
          statusEl.textContent = "";
        }, 2500);
      } catch (err) {
        console.error("Error logging message", err);
        statusEl.textContent = "Failed to log message.";
      }
    });
  }

Finally, ensure initReminderMarkSent() is called once when the page loads, alongside whatever initialisation runs after Alpine is ready (e.g. in the existing DOMContentLoaded or Alpine.init handler).

4) Save all files, restart the dashboard server, and test:

- Open Reminders tab.
- Select an appointment.
- Choose a message type.
- Click “Mark as sent”.
- Confirm:
  - Status text shows “Logged ✔”.
  - In the database:

    select conversation_id, direction, channel, sender, template_key, mode, message_body
    from dp_messages
    order by created_at desc
    limit 5;