diff --git a/bases/rsptx/web2py_server/applications/runestone/controllers/peer.py b/bases/rsptx/web2py_server/applications/runestone/controllers/peer.py
index 977c08f76..9f2de3a3c 100644
--- a/bases/rsptx/web2py_server/applications/runestone/controllers/peer.py
+++ b/bases/rsptx/web2py_server/applications/runestone/controllers/peer.py
@@ -15,6 +15,9 @@
 import logging
 import os
 import random
+import re
+import datetime
+import requests
 
 # Third Party
 # -----------
@@ -22,11 +25,15 @@
 import pandas as pd
 import redis
 from dateutil.parser import parse
-from rsptx.db.crud import fetch_lti_version
+from rsptx.db.crud import fetch_api_token, fetch_lti_version
 from rs_grading import _try_to_send_lti_grade
 
-logger = logging.getLogger(settings.logger)
-logger.setLevel(settings.log_level)
+try:
+    logger = logging.getLogger(settings.logger)
+    logger.setLevel(settings.log_level)
+except Exception:
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.INFO)
 
 peerjs = os.path.join("applications", request.application, "static", "js", "peer.js")
 try:
@@ -37,6 +44,7 @@
 request.peer_mtime = str(mtime)
 
 
+
 @auth.requires(
     lambda: verifyInstructorStatus(auth.user.course_id, auth.user),
     requires_login=True,
@@ -78,6 +86,7 @@ def dashboard():
         next = False
 
     current_question, done, idx = _get_current_question(assignment_id, next)
+    has_vote1 = _has_vote1(current_question.name, auth.user.username)
     all_questions = _get_assignment_questions(assignment_id)
     num_questions = len(all_questions)
     current_qnum = idx + 1
@@ -133,6 +142,7 @@ def dashboard():
         is_instructor=True,
         is_last=done,
         lti=is_lti,
+        has_vote1=has_vote1,
         **course_attrs,
     )
 
@@ -168,7 +178,7 @@ def _get_current_question(assignment_id, get_next):
         db(db.assignments.id == assignment_id).update(current_index=idx)
     else:
         idx = assignment.current_index
-    db.commit()  # commit changes to current question to prevent race condition.
+    db.commit() 
     question, done = _get_numbered_question(assignment_id, idx)
     return question, done, idx
 
@@ -177,11 +187,16 @@ def _get_numbered_question(assignment_id, qnum):
     all_questions = _get_assignment_questions(assignment_id)
     total_questions = len(all_questions)
 
+    if total_questions == 0:
+        return None, "true"
+    
+    if qnum < 0:
+        qnum = 0
+
     done = "false"
-    if qnum > total_questions - 1:
-        qnum = total_questions - 1
-    if qnum == total_questions - 1:
+    if qnum >= total_questions:
         done = "true"
+        qnum = total_questions - 1
     logger.debug(f"qnum = {qnum} total_questions = {total_questions} done = {done}")
     current_question = all_questions[qnum]
     return current_question, done
@@ -697,113 +712,263 @@ def log_peer_rating():
     return json.dumps(retmess)
 
 
-# Students Async Interface to Peer Instruction
-# --------------------------------------------
-
-
 @auth.requires_login()
 def peer_async():
     if "access_token" not in request.cookies:
-        logger.warning(f"Missing Access Token: {auth.user.username} adding one now")
+        logger.warning(
+            f"Missing Access Token: {auth.user.username} adding one now"
+        )
         create_rs_token()
 
     assignment_id = request.vars.assignment_id
 
-    qnum = 0
-    if request.vars.question_num:
-        qnum = int(request.vars.question_num)
+    question_num = 1
+    if request.vars.question_num is not None:
+        question_num = int(request.vars.question_num)
+
+    current_question, all_done = _get_numbered_question(
+    assignment_id,
+    question_num - 1
+    )
 
-    current_question, all_done = _get_numbered_question(assignment_id, qnum-1)
     assignment = db(db.assignments.id == assignment_id).select().first()
+
+    has_vote1 = False
+    has_reflection = False
+
+    if current_question:
+        div_id = current_question.name
+        sid = auth.user.username
+        has_vote1 = _has_vote1(div_id, sid)
+        has_reflection = _has_reflection(div_id, sid)
+
     course = db(db.courses.course_name == auth.user.course_name).select().first()
     course_attrs = getCourseAttributesDict(course.id, course.base_course)
+
     if "latex_macros" not in course_attrs:
         course_attrs["latex_macros"] = ""
 
+    llm_enabled = _llm_enabled()
+    try:
+        db.useinfo.insert(
+            course_id=auth.user.course_name,
+            sid=auth.user.username,
+            div_id=current_question.name if current_question else None,
+            event="pi_mode",
+            act=json.dumps({"mode": "llm" if llm_enabled else "legacy"}),
+            timestamp=datetime.datetime.utcnow(),
+        )
+    except Exception:
+        logger.exception("Failed to log pi_mode for peer_async")
+
     return dict(
         course_id=auth.user.course_name,
         course=get_course_row(db.courses.ALL),
         current_question=current_question,
         assignment_id=assignment_id,
         assignment_name=assignment.name,
-        nextQnum=qnum + 1,
+        nextQnum = question_num + 1,
         all_done=all_done,
+        has_vote1=has_vote1,
+        has_reflection=has_reflection,
+        llm_enabled=llm_enabled,
+        llm_reply=None,
         **course_attrs,
     )
 
-
 @auth.requires_login()
 def get_async_explainer():
     course_name = request.vars.course
-    sid = auth.user.username
     div_id = request.vars.div_id
 
-    this_answer = _get_user_answer(div_id, sid)
-
-    # Messages are in useinfo with an event of "sendmessage" and a div_id corresponding to the div_id of the question.
-    # The act field is to:user:message
-    # Ratings of messages are in useinfo with an event of "ratepeer"
-    # the act field is rateduser:rating (excellent, good, poor)
-    ratings = []
-    for rate in ["excellent", "good"]:
-        ratings = db(
-            (db.useinfo.event == "ratepeer")
-            & (db.useinfo.act.like(f"%{rate}"))
-            & (db.useinfo.div_id == div_id)
-            & (db.useinfo.course_id == course_name)
-        ).select()
-        if len(ratings) > 0:
-            break
-
-    if len(ratings) > 0:
-        done = False
-        tries = 0
-        while not done and tries < 10:
-            idx = random.randrange(len(ratings))
-            act = ratings[idx].act
-            user = act.split(":")[0]
-            peer_answer = _get_user_answer(div_id, user)
-            if peer_answer != this_answer:
-                done = True
-            else:
-                tries += 1
-        mess, participants = _get_user_messages(user, div_id, course_name)
-        # This is the easy solution, but may result in a one-sided conversation.
-        if user in participants:
-            participants.remove(user)
+    messages = db(
+        (db.useinfo.event == "sendmessage")
+        & (db.useinfo.div_id == div_id)
+        & (db.useinfo.course_id == course_name)
+    ).select(orderby=db.useinfo.id)
+
+    if len(messages) == 0:
+        mess = "Sorry there are no explanations yet."
     else:
-        messages = db(
-            (db.useinfo.event == "sendmessage")
-            & (db.useinfo.div_id == div_id)
-            & (db.useinfo.course_id == course_name)
-        ).select(db.useinfo.sid)
-        if len(messages) > 0:
-            senders = set((row.sid for row in messages))
-            done = False
-            tries = 0
-            while not done and tries < 10:
-                user = random.choice(list(senders))
-                peer_answer = _get_user_answer(div_id, user)
-                if peer_answer != this_answer:
-                    done = True
-
-                else:
-                    tries += 1
-            mess, participants = _get_user_messages(user, div_id, course_name)
-        else:
-            mess = "Sorry there were no good explanations for you."
-            user = "nobody"
-            participants = set()
+        parts = []
+        for row in messages:
+            try:
+                msg = row.act.split(":", 2)[2]
+            except Exception:
+                msg = row.act
+            parts.append(f"<li><strong>{row.sid}</strong> said: {msg}</li>")
+        mess = "<ul>" + "".join(parts) + "</ul>"
 
-    responses = {}
-    for p in participants:
-        responses[p] = _get_user_answer(div_id, p)
     logger.debug(f"Get message for {div_id}")
-    return json.dumps(
-        {"mess": mess, "user": user, "answer": peer_answer, "responses": responses}
+    return json.dumps({"mess": mess, "user": "", "answer": "", "responses": {}})
+
+#get question text, code, and answer choices for an MCQ
+def _get_mcq_context(div_id):
+    q = db(db.questions.name == div_id).select().first()
+    if not q:
+        logger.error(f"_get_mcq_context: no question row for {div_id}")
+        return "", "", []
+
+    question = (q.question or "").strip()
+
+    code = ""
+    if hasattr(q, "code") and q.code:
+        code = q.code.strip()
+    choices = []
+    try:
+        if hasattr(q, "answers") and q.answers:
+            opts = json.loads(q.answers)
+            for i, opt in enumerate(opts):
+                choices.append(f"{chr(65+i)}. {opt.strip()}")
+    except Exception as e:
+        logger.warning(f"Could not parse choices for {div_id}: {e}")
+    return question, code, choices    
+
+
+#handle async peer instruction reflection using an LLM:
+#logs student messages and return an LLM peer-style reply
+@auth.requires_login()
+def get_async_llm_reflection():
+    logger.warning("LLM REFLECTION CALLED")
+    logger.warning(f"raw body = {request.body.read()}")
+    request.body.seek(0)
+    try:
+        data = json.loads(request.body.read().decode("utf-8"))
+    except Exception:
+        return response.json(dict(ok=False, error="invalid json"))
+
+    div_id = (data.get("div_id") or "").strip()
+    selected = (data.get("selected_answer") or "").strip()
+    messages = data.get("messages")
+    try:
+        sid = auth.user.username
+        course_name = auth.user.course_name
+
+        user_msgs = [m for m in messages if m.get("role") == "user"]
+
+        for idx, m in enumerate(user_msgs):
+            content = (m.get("content") or "").strip()
+            if not content:
+                continue
+
+            if idx == 0:
+                db.useinfo.insert(
+                    course_id=course_name,
+                    sid=sid,
+                    div_id=div_id,
+                    event="reflection",
+                    act=content,
+                    timestamp=datetime.datetime.utcnow(),
+                )
+            else:
+                db.useinfo.insert(
+                    course_id=course_name,
+                    sid=sid,
+                    div_id=div_id,
+                    event="sendmessage",
+                    act=f"to:llm:{content}",
+                    timestamp=datetime.datetime.utcnow(),
+                )
+    except Exception as e:
+        logger.exception("Failed to log LLM user message")
+
+    if not div_id:
+        return response.json(dict(ok=False, error="missing div_id"))
+
+    question, code, choices = _get_mcq_context(div_id)
+
+    sys_content = (
+        "only speak in lower case.\n"
+        "you are a student talking to another student during peer instruction.\n"
+        "you are both looking at the same multiple choice question with code and answers.\n"
+        "you remember the code and choices.\n"
+        "most messages should be short (1 to 3 sentences often very short).\n"
+        "use casual informal language and common typos.\n"
+        "never use commas.\n"
+        "never use gendered language.\n"
+        "do not use new lines.\n"
+        "do not sound like a teacher.\n"
+        "do not explain step by step.\n"
+        "do not mention libraries formally.\n"
+        "never say something is right or wrong.\n"
+        "never mention a choice letter as the correct answer.\n"
+        "never clearly describe the final result of the code.\n"
+        "never fully state what the program prints.\n"
+        "keep reasoning partial or uncertain.\n"
+        "use common misconceptions relating to the specific problem.\n"
+        "refer to code loosely like 'that line' or 'the loop' or 'the head' or 'the print'.\n"
+        "often hedge with uncertainty.\n"
+        "never agree with the other student's interpretation even if it sounds correct.\n"
+        "use content from the other multiple choice options in your reponses when needed\n"
+        "maintain a mistaken or incomplete mental model throughout the conversation.\n"
+        "if the other student clearly sounds confident or repeats the same answer twice stop debating and tell them to vote again or submit it.\n"
+        "do not continue reasoning after telling them to vote again.\n"
+        "focus on reasoning not teaching.\n\n"
     )
 
 
+    if question:
+        sys_content += f"question:\n{question}\n\n"
+
+    if code:
+        sys_content += f"code:\n{code}\n\n"
+
+    if choices:
+        sys_content += "answer choices:\n" + "\n".join(choices) + "\n\n"
+
+    if selected:
+        sys_content += f"the other student chose: {selected}\n\n"
+
+    system_msg = {"role": "system", "content": sys_content}
+
+    if not messages:
+        reflection = (data.get("reflection") or "").strip()
+        if not reflection:
+            return response.json(dict(ok=False, error="missing reflection"))
+
+        messages = [
+            system_msg,
+            {
+                "role": "user",
+                "content": (
+                    f"i chose answer {selected}. "
+                    f"my explanation was:\n\n{reflection}"
+                ),
+            },
+        ]
+
+    else:
+        if not isinstance(messages, list):
+            return response.json(dict(ok=False, error="messages must be a list"))
+
+        if len(messages) == 0 or messages[0].get("role") != "system":
+            messages = [system_msg] + messages
+        else:
+            messages[0] = system_msg
+
+    try:
+        reply = _call_openai(messages)
+        try:
+            db.useinfo.insert(
+                course_id=auth.user.course_name,
+                sid=auth.user.username,
+                div_id=div_id,
+                event="llm_peer_sendmessage",
+                act=f"to: student:{reply}",
+                timestamp=datetime.datetime.utcnow(),
+            )
+        except Exception:
+            logger.exception("Failed to log LLM reply")
+
+        if not reply:
+            return response.json(
+                dict(ok=False, error="llm returned empty reply (missing api key?)")
+            )
+        return response.json(dict(ok=True, reply=reply))
+    except Exception as e:
+        logger.exception("LLM reflection failed")
+        return response.json(dict(ok=False, error=str(e))) 
+ 
 def _get_user_answer(div_id, s):
     ans = (
         db(
@@ -815,11 +980,34 @@ def _get_user_answer(div_id, s):
         .select(orderby=~db.useinfo.id)
         .first()
     )
-    # act is answer:0[,x]+:correct:voteN
     if ans:
         return ans.act.split(":")[1]
     else:
         return ""
+#check if the student has already submitted a reflection for the question
+def _has_reflection(div_id, sid):
+    row = (
+        db(
+            (db.useinfo.event == "reflection")
+            & (db.useinfo.sid == sid)
+            & (db.useinfo.div_id == div_id)
+        )
+        .select(orderby=~db.useinfo.id)
+        .first()
+    )
+    return row is not None
+def _has_vote1(div_id, sid):
+    row = (
+        db(
+            (db.useinfo.event == "mChoice")
+            & (db.useinfo.sid == sid)
+            & (db.useinfo.div_id == div_id)
+            & (db.useinfo.act.like("%vote1"))
+        )
+        .select(orderby=~db.useinfo.id)
+        .first()
+    )
+    return row is not None
 
 
 def _get_user_messages(user, div_id, course_name):
@@ -854,3 +1042,50 @@ def send_lti_scores():
         _try_to_send_lti_grade(sid, assignment_id, force=True)
 
     return json.dumps("success")
+
+
+#determine whether LLM-based async peer discussion is enabled for this course based on coursewide api key
+def _llm_enabled():
+    return bool(_get_course_openai_key())
+
+#fetch the course-wide openai API key used to enable LLM-based async peer discussion (only works for openai currently)
+def _get_course_openai_key():
+    try:
+        token_record = asyncio.get_event_loop().run_until_complete(
+            fetch_api_token(course_id=auth.user.course_id, provider="openai")
+        )
+        if token_record and token_record.token:
+            return token_record.token.strip()
+    except Exception:
+        logger.exception("Failed to fetch course-wide OpenAI token for peer LLM")
+    return ""
+
+
+#call the openai chat completion API using the course-wide token and return the model reply
+def _call_openai(messages):
+    """
+    Minimal HTTP call using the instructor-provided course-wide OpenAI token.
+    messages: list of {role, content}
+    returns reply string
+    """
+    api_key = _get_course_openai_key()
+    if not api_key:
+        raise Exception("missing api key")
+
+    model = os.environ.get("PI_OPENAI_MODEL", "gpt-4o-mini").strip() or "gpt-4o-mini"
+    url = "https://api.openai.com/v1/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+    payload = {
+        "model": model,
+        "messages": messages,
+        "temperature": 0.4,
+        "max_tokens": 300,
+    }
+    resp = requests.post(url, headers=headers, json=payload, timeout=30)
+    logger.warning(f"PEER LLM CALL | provider=openai-course-token | model={model}")
+    resp.raise_for_status()
+    data = resp.json()
+    return data["choices"][0]["message"]["content"].strip()
diff --git a/bases/rsptx/web2py_server/applications/runestone/static/js/peer.js b/bases/rsptx/web2py_server/applications/runestone/static/js/peer.js
index 40162a91b..6bb3872e1 100644
--- a/bases/rsptx/web2py_server/applications/runestone/static/js/peer.js
+++ b/bases/rsptx/web2py_server/applications/runestone/static/js/peer.js
@@ -28,6 +28,9 @@ const STEP_CONFIG = {
 
 const CHAT_MODALITIES = ['makep', 'facechat', 'makeabgroups'];
 var currentStep = null;
+const REQUIRED_LLM_MESSAGES = 1;
+let llmMessageCount = 0;
+let readyForVote2 = false;
 
 function disableButton(btn) {
     if (btn) btn.disabled = true;
@@ -282,7 +285,7 @@ function connect(event) {
                         "Submit";
                     window.componentMap[currentQuestion].enableInteraction();
                     if (typeof studentVoteCount !== "undefined") {
-                        studentVoteCount += 1;
+                        // studentVoteCount += 1;
                         if (studentVoteCount > 2) {
                             studentVoteCount = 2;
                             console.log("WARNING: resetting studentVoteCount to 2");
@@ -484,6 +487,15 @@ async function sendMessage(event) {
 
     // Disable the send button after sending a message
     sendButton.classList.add("disabled");
+    llmMessageCount += 1;
+    console.log("LLM message count:", llmMessageCount);
+
+    if (llmMessageCount >= REQUIRED_LLM_MESSAGES) {
+        const btn = document.getElementById("readyVote2Btn");
+        if (btn) {
+            btn.style.display = "inline-block";
+        }
+    }
 }
 
 function warnAndStopVote(event) {
@@ -712,9 +724,23 @@ async function showPeerEnableVote2() {
     let peerEl = document.getElementById("peerJust");
     peerEl.innerHTML = peerMess;
     let nextStep = document.getElementById("nextStep");
+
+if (llmMessageCount < REQUIRED_LLM_MESSAGES) {
     nextStep.innerHTML =
-        "Please answer the question again, even if you do not wish to change your answer. After answering, click the button to go on to the next question.";
+        `Please continue the discussion. You must send at least ${REQUIRED_LLM_MESSAGES} messages before voting again.`;
     nextStep.style.color = "red";
+    return; 
+}
+
+nextStep.innerHTML =
+    "Please answer the question again, even if you do not wish to change your answer. After answering, click the button to go on to the next question.";
+nextStep.style.color = "red";
+voteStopped = false;
+
+let qq = window.componentMap[currentQuestion];
+qq.submitButton.disabled = false;
+qq.enableInteraction();
+
     let cq = document.getElementById(`${currentQuestion}_feedback`);
     cq.style.display = "none";
 
@@ -731,6 +757,42 @@ async function showPeerEnableVote2() {
     }
 }
 
+//re-enable interaction so the student can submit their second vote (async PI)
+function enableSecondVoteAsync() {
+    console.log("Enabling second vote (async)");
+
+    voteStopped = false;
+
+    let qq = window.componentMap[currentQuestion];
+    if (!qq) {
+        console.error("No component found for currentQuestion");
+        return;
+    }
+
+    qq.submitButton.disabled = false;
+    qq.enableInteraction();
+
+    let feedbackDiv = document.getElementById(`${currentQuestion}_feedback`);
+    if (feedbackDiv) {
+        feedbackDiv.style.display = "none";
+    }
+
+    $(".runestone [type=radio]").prop("checked", false);
+    $(".runestone [type=checkbox]").prop("checked", false);
+
+    document.getElementById("readyVote2Btn").style.display = "none";
+
+    let nextStep = document.getElementById("nextStep");
+    if (nextStep) {
+        nextStep.innerHTML =
+            "please submit your answer again, even if you keep the same choice.";
+        nextStep.style.color = "red";
+    }
+
+    console.log("Second vote enabled");
+}
+
+
 async function setupPeerGroup() {
     let jsonHeaders = new Headers({
         "Content-type": "application/json; charset=utf-8",
@@ -786,10 +848,26 @@ async function setupPeerGroup() {
 
 }
 
+//insert the "Ready for Vote 2" button into the discussion area (async PI only)
+function insertReadyVote2Button() {
+    if (document.getElementById("readyVote2Btn")) return;
+
+    const container = document.getElementById("discussion_panel") 
+        || document.getElementById("imessage");
+
+    if (!container) return;
+
+
+    btn.addEventListener("click", enableSecondVoteAsync);
+
+    container.appendChild(btn);
+}
+
 $(function () {
+    insertReadyVote2Button();
+
     let tinput = document.getElementById("messageText");
     let sendButton = document.getElementById("sendpeermsg");
-
     if (tinput && sendButton) {
         tinput.addEventListener("input", function () {
             let message = this.value.trim();
diff --git a/bases/rsptx/web2py_server/applications/runestone/views/peer/peer_async.html b/bases/rsptx/web2py_server/applications/runestone/views/peer/peer_async.html
index 073ba7969..764cb6bbb 100644
--- a/bases/rsptx/web2py_server/applications/runestone/views/peer/peer_async.html
+++ b/bases/rsptx/web2py_server/applications/runestone/views/peer/peer_async.html
@@ -1,3 +1,22 @@
+{{extend 'runestone.html'}}
+<script>
+  window.ASYNC_LLM_ENABLED = {{='true' if llm_enabled else 'false'}};
+</script>
+<script>
+  window.DISABLE_LLMTEST = true;
+  window.PI_LLM_MODE = {{='true' if llm_enabled else 'false'}};
+  window.DISABLE_LLMTEST = true;
+
+  window.eBookConfig = window.eBookConfig || {};
+  eBookConfig.course = "{{=course_id}}";
+  eBookConfig.basecourse = "{{=course.base_course}}";
+  eBookConfig.host = window.location.origin;
+  eBookConfig.isLoggedIn = true;
+</script>
+
+<div id="peer_async_root" data-div_id="{{=current_question.name}}">
+</div>
+
 {{extend 'layout.html'}}
 {{block moreincludes}}
 {{include '_sphinx_static_files.html'}}
@@ -8,6 +27,7 @@
     eBookConfig.peerMode = "async";
 </script>
 
+
 <div class="hidden-content" style="display: none">
     \( {{=XML(latex_macros)}} \)
  </div>
@@ -22,7 +42,7 @@ <h2>Peer Instruction Question (After Class)</h2>
             <li>Answer the question <strong>again.</strong>  Even if you are not changing your answer from the first time.</li>
         </ol>
     </p>
-</div>
+</div> 
 
 <div class="row">
     {{ if all_done == "false": }}
@@ -34,22 +54,65 @@ <h3>Congratulations, you have completed this assignment!</h3>
     </div>
     {{ pass }}
     {{ if all_done == "false": }}
-    <div class="col-md-6">
-        <p>
-            Please provide an explanation for why you answered
-            <span id="current_answer">__</span>
-        </p>
-        <textarea id="messageText" rows="6" cols="80"> </textarea> <br />
-        <button type="button" onclick="showPeerEnableVote2()">Submit</button>
-        <div>
-            <h4>A discussion for you to consider</h4>
+    <div class="col-md-6" id="reflectionPanel" style="opacity:0.5; pointer-events:none;">
+      <p>
+          Please provide an explanation for why you answered
+          <span id="current_answer">__</span>
+      </p>
+      <textarea id="messageText" rows="6" cols="80"></textarea> <br />
+      <button id="submitReflection" type="button">Submit</button>
+
+      <p id="vote1Notice" style="color:#a00; margin-top:0.5em;">
+          You must submit your first vote before starting the discussion.
+      </p>
+            <!-- <h4>A discussion for you to consider</h4>
             <p id="peerName"></p>
             <p id="peerJust"></p>
-            <p id="nextStep"></p>
+            <p id="nextStep"></p> -->
+            <div id="llmDiscussion" style="display:none">
+              <div id="llmChat"
+                  style="background:#f5f5f5;
+                          padding:8px;
+                          border-radius:4px;
+                          max-height:220px;
+                          overflow-y:auto;
+                          margin-bottom:8px;">
+              </div>
+
+              <div style="display:flex; gap:6px; align-items:center;">
+                <input id="llmReplyInput"
+                      class="form-control"
+                      placeholder="Reply to this student…"
+                      type="text" />
+
+                <button id="llmReplyBtn" class="btn btn-default">
+                  Send
+                </button>
+
+                <button
+                  id="readyVote2Btn"
+                  class="btn btn-primary"
+                  disabled
+                  title="Submit your first vote to unlock"
+                  onclick="enableSecondVoteAsync()"
+                >
+                  Vote again
+                </button>
+              </div>
+
+              <p id="nextStep" style="margin-top:8px; font-style:italic;"></p>
+            </div>
         </div>
     </div>
     {{pass}}
 </div>
+{{ if has_vote1 and has_reflection and llm_reply: }}
+<hr>
+<div style="background:#f0f0f0; padding:10px; border-radius:4px;">
+  <strong>An LLM peer said:</strong>
+  <p>{{=llm_reply}}</p>
+</div>
+{{ pass }}
 
 {{ if all_done == "false": }}
 <div>
@@ -60,7 +123,415 @@ <h4>A discussion for you to consider</h4>
     </form>
 </div>
 {{ pass }}
+<script>
+  window.DISABLE_ASYNC_EXPLAINER = true;
+</script>
 <script src="/runestone/static/js/peer.js?v={{=request.peer_mtime}}"></script>
+<script>
+  window._vote2Enabled = false;
+  window._vote1Locked = false;
+
+  function setVoteInputsLocked(locked) {
+    try {
+      const comp = window.componentMap[currentQuestion];
+      if (comp && comp.submitButton) {
+        comp.submitButton.disabled = locked;
+      }
+      if (comp && typeof comp.disableInteraction === "function" && locked) {
+        comp.disableInteraction();
+      }
+      if (comp && typeof comp.enableInteraction === "function" && !locked) {
+        comp.enableInteraction();
+      }
+    } catch (e) {
+      console.warn("vote lock toggle failed", e);
+    }
+  }
+
+  function lockVote1AndReflection() {
+    window._vote1Locked = true;
+    setVoteInputsLocked(true);
+    const ta = document.getElementById("messageText");
+    const btn = document.getElementById("submitReflection");
+    if (ta) ta.disabled = true;
+    if (btn) btn.disabled = true;
+  }
+
+  function setReflectionPanelEnabled(enabled) {
+    const panel = document.getElementById("reflectionPanel");
+    if (!panel) return;
+    panel.style.opacity = enabled ? "1" : "0.5";
+    panel.style.pointerEvents = enabled ? "auto" : "none";
+    if (enabled) {
+      const notice = document.getElementById("vote1Notice");
+      if (notice) notice.remove();
+    }
+  }
+
+  function enableSecondVoteAsync() {
+    console.log("PI async: enabling vote 2");
+    if (!hasVote1) {
+      alert("Please submit your first vote before voting again.");
+      return;
+    }
+
+    window._vote2Enabled = true;
+    window._vote1Locked = false;
+
+    studentSubmittedVote2 = false;
+    if (typeof studentVoteCount !== "undefined" && studentVoteCount < 2) {
+      studentVoteCount = 2;
+    }
+
+    setVoteInputsLocked(false);
+
+    const b = document.getElementById("readyVote2Btn");
+    if (b) b.style.display = "none";
+    const nextStep = document.getElementById("nextStep");
+    if (nextStep) {
+      nextStep.textContent =
+        "Please submit your second vote now. You may keep or change your answer.";
+    }
+}
+</script>
+<script>
+  (function () {
+    const origShowPeerEnableVote2 = window.showPeerEnableVote2;
+    window.showPeerEnableVote2 = function () {
+      if (window._piReflectionSubmitted) {
+        console.log("PI async: suppressing peer.js UI reset after reflection");
+        return;
+      }
+      if (origShowPeerEnableVote2) {
+        origShowPeerEnableVote2();
+      }
+    };
+  })();
+</script>
+ 
+<script>
+async function fetchWithRetry(url, options, retries = 1, delayMs = 400) {
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const resp = await fetch(url, options);
+      if (resp.ok) {
+        return resp;
+      }
+      lastError = new Error(`HTTP ${resp.status}`);
+    } catch (err) {
+      lastError = err;
+    }
+    if (attempt < retries) {
+      await new Promise(resolve => setTimeout(resolve, delayMs));
+    }
+  }
+  throw lastError;
+}
+
+(function () {
+  const btn = document.getElementById("submitReflection");
+  const ta  = document.getElementById("messageText");
+  if (!btn || !ta) return;
+
+  const peerNameEl = document.getElementById("peerName");
+  const peerJustEl = document.getElementById("peerJust");
+  const nextStepEl = document.getElementById("nextStep");
+
+  btn.addEventListener("click", async function () {
+  if (!hasVote1) {
+    alert("Please submit your first vote before starting the discussion.");
+    return;
+  }
+  if (window._vote1Locked) {
+    return;
+  }
+
+  const reflection = (ta.value || "").trim();
+  if (!reflection) {
+    alert("Please write a short justification first.");
+    return;
+  }
+
+  let selected = "";
+  try {
+    selected = answerToString(window.componentMap[currentQuestion].answer);
+  } catch {}
+
+  if (typeof logPeerEvent === "function") {
+    logPeerEvent({
+      sid: eBookConfig.username,
+      div_id: currentQuestion,
+      event: "reflection",
+      act: reflection,
+      course_name: eBookConfig.course,
+    });
+    logPeerEvent({
+      sid: eBookConfig.username,
+      div_id: currentQuestion,
+      event: "pi_reflection",
+      act: JSON.stringify({
+        pi_attempt_id: getPiAttemptId(),
+        role: "student",
+        content: reflection,
+      }),
+      course_name: eBookConfig.course,
+    });
+    window._llmTurnIndex = (window._llmTurnIndex || 0) + 1;
+    logPeerEvent({
+      sid: eBookConfig.username,
+      div_id: currentQuestion,
+      event: "pi_llm_turn",
+      act: JSON.stringify({
+        pi_attempt_id: getPiAttemptId(),
+        turn_index: window._llmTurnIndex,
+        role: "user",
+        content: reflection,
+      }),
+      course_name: eBookConfig.course,
+    });
+  }
+
+  const discussion = document.getElementById("llmDiscussion");
+  const chat = document.getElementById("llmChat");
+  const nextStep = document.getElementById("nextStep");
+  lockVote1AndReflection();
+
+  discussion.style.display = "block";
+  chat.innerHTML = "<p><em>Thinking about your explanation…</em></p>";
+
+  if (window.PI_LLM_MODE !== true) {
+    const resp = await fetch("/runestone/peer/get_async_explainer", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        div_id: currentQuestion,
+        course: eBookConfig.course
+      })
+    });
+
+    if (!resp.ok) {
+      chat.innerHTML = "<p><em>Error talking to peer.</em></p>";
+      return;
+    }
+
+    const spec = await resp.json();
+    let res = "";
+    for (let response in spec.responses) {
+      res += `User ${response} answered ${answerToString(
+        spec.responses[response]
+      )} <br />`;
+    }
+    chat.innerHTML = "";
+    chat.innerHTML += `<p><strong>Other students said:</strong></p>`;
+    if (res) {
+      chat.innerHTML += `<p>${res}</p>`;
+    }
+    if (spec.mess) {
+      chat.innerHTML += spec.mess;
+    }
+    const replyInput = document.getElementById("llmReplyInput");
+    const replyBtn = document.getElementById("llmReplyBtn");
+    if (replyInput) replyInput.style.display = "none";
+    if (replyBtn) replyBtn.style.display = "none";
+    nextStep.textContent =
+      "Please answer the question again, even if you do not wish to change your answer.";
+    const readyBtn = document.getElementById("readyVote2Btn");
+    if (readyBtn) {
+      readyBtn.style.display = "inline-block";
+      readyBtn.disabled = false;
+      readyBtn.title = "";
+    }
+    studentSubmittedVote2 = false;
+    return;
+  } else {
+    const mcq = document.querySelector('.mchoice');
+
+    const questionText = mcq ? mcq.innerText : "";
+
+    window._llmMessages = [
+      {
+        role: "user",
+        content: `i chose answer ${selected}. my explanation was:\n\n${reflection}`
+      }
+    ];
+
+
+    let resp;
+    try {
+      resp = await fetchWithRetry("/runestone/peer/get_async_llm_reflection", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          div_id: currentQuestion,
+          selected_answer: selected,
+          messages: window._llmMessages
+        })
+      });
+    } catch (e) {
+      chat.innerHTML = "<p><em>LLM error. Please try again.</em></p>";
+      return;
+    }
+
+    const data = await resp.json();
+    chat.innerHTML = "";
+
+    if (!data.ok) {
+      chat.innerHTML = "<p><em>LLM error. Please try again.</em></p>";
+      return;
+    }
+
+    appendMsg("assistant", data.reply);
+    if (typeof logPeerEvent === "function") {
+      window._llmTurnIndex = (window._llmTurnIndex || 0) + 1;
+      logPeerEvent({
+        sid: eBookConfig.username,
+        div_id: currentQuestion,
+        event: "pi_llm_turn",
+        act: JSON.stringify({
+          pi_attempt_id: getPiAttemptId(),
+          turn_index: window._llmTurnIndex,
+          role: "assistant",
+          content: data.reply,
+        }),
+        course_name: eBookConfig.course,
+      });
+    }
+
+    window._llmMessages.push({
+      role: "assistant",
+      content: data.reply
+    });  
+    nextStep.textContent =
+      "Discuss this reasoning, then click 'Vote again' to vote again.";
+
+    studentSubmittedVote2 = false; 
+
+    enableChat(reflection, selected);
+  }
+
+});
+})(); 
+</script>
+<script>
+function appendMsg(role, text) {
+  const chat = document.getElementById("llmChat");
+  const p = document.createElement("p");
+  p.style.margin = "6px 0";
+  p.style.whiteSpace = "pre-wrap";
+
+  p.innerHTML =
+    role === "user"
+      ? `<strong>You:</strong> ${text}`
+      : `<strong>LLM Peer:</strong> ${text}`;
+
+  chat.appendChild(p);
+  chat.scrollTop = chat.scrollHeight;
+}
+
+function enableChat(reflection, selected) {
+  const input = document.getElementById("llmReplyInput");
+  const btn = document.getElementById("llmReplyBtn");
+
+  btn.onclick = async () => {
+    const msg = input.value.trim();
+    if (!msg) return;
+
+    appendMsg("user", msg);
+    if (typeof logPeerEvent === "function") {
+      window._llmTurnIndex = (window._llmTurnIndex || 0) + 1;
+      logPeerEvent({
+        sid: eBookConfig.username,
+        div_id: currentQuestion,
+        event: "pi_llm_turn",
+        act: JSON.stringify({
+          pi_attempt_id: getPiAttemptId(),
+          turn_index: window._llmTurnIndex,
+          role: "user",
+          content: msg,
+        }),
+        course_name: eBookConfig.course,
+      });
+    }
+    llmUserMessageCount += 1;
+
+    if (llmUserMessageCount >= 1 && hasVote1) {
+      const readyBtn = document.getElementById("readyVote2Btn");
+      if (readyBtn) {
+        readyBtn.style.display = "inline-block";
+        readyBtn.disabled = false;
+        readyBtn.title = "";
+      }
+    }
+    input.value = "";
+
+    window._llmMessages.push({
+      role: "user",
+      content: msg
+    });
+
+    btn.disabled = true;
+    input.disabled = true;
+
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    let resp;
+    try {
+      resp = await fetchWithRetry("/runestone/peer/get_async_llm_reflection", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          div_id: currentQuestion,
+          selected_answer: selected,
+          messages: window._llmMessages
+        })
+      });
+    } catch (e) {
+      appendMsg("assistant", "LLM error. Please try again.");
+      btn.disabled = false;
+      input.disabled = false;
+      return;
+    }
+
+    const data = await resp.json();
+    if (!data.ok) {
+      appendMsg("assistant", "LLM error. Please try again.");
+      btn.disabled = false;
+      input.disabled = false;
+      return;
+    }
+
+    appendMsg("assistant", data.reply);
+    btn.disabled = false;
+    input.disabled = false;
+    if (typeof logPeerEvent === "function") {
+      window._llmTurnIndex = (window._llmTurnIndex || 0) + 1;
+      logPeerEvent({
+        sid: eBookConfig.username,
+        div_id: currentQuestion,
+        event: "pi_llm_turn",
+        act: JSON.stringify({
+          pi_attempt_id: getPiAttemptId(),
+          turn_index: window._llmTurnIndex,
+          role: "assistant",
+          content: data.reply,
+        }),
+        course_name: eBookConfig.course,
+      });
+    }
+
+    window._llmMessages.push({
+      role: "assistant",
+      content: data.reply
+    });
+  };
+
+  input.addEventListener("keydown", e => {
+    if (e.key === "Enter") btn.click();
+  });
+}
+</script>
+
 <script>
     var user = "{{=auth.user.username}}";
     var currentQuestion = "{{=XML(current_question.name)}}";
@@ -68,11 +539,30 @@ <h4>A discussion for you to consider</h4>
         setTimeout(connect, 1000);
     });
     var studentVoteCount = 1;
+    var hasVote1 = {{='true' if has_vote1 else 'false'}};
+    var hasReflection = {{='true' if has_reflection else 'false'}};
     var studentSubmittedVote2 = false;
     var vote2done = false;
+    var llmUserMessageCount = 0;
     var nextQuestionNumber = {{= nextQnum}};
     var assignId = '{{=assignment_id}}'
     eBookConfig.is_peer_async = true;
+    window._llmTurnIndex = 0;
+    window._piAttemptId = null;
+
+    function getPiAttemptId() {
+        if (!window._piAttemptId) {
+            const key = `pi_attempt_id:${eBookConfig.username}:${currentQuestion}`;
+            const existing = sessionStorage.getItem(key);
+            if (existing) {
+                window._piAttemptId = existing;
+            } else {
+                window._piAttemptId = `${eBookConfig.username}:${currentQuestion}:${Date.now()}`;
+                sessionStorage.setItem(key, window._piAttemptId);
+            }
+        }
+        return window._piAttemptId;
+    }
 
     function checkVoteCount() {
         if (studentVoteCount < 2 || studentSubmittedVote2 == false) {
@@ -84,6 +574,10 @@ <h4>A discussion for you to consider</h4>
 
     // this cannot happen until the event that indicates components are loaded
     $(document).on("runestone:login-complete", function () {
+        llmUserMessageCount = 0;
+        if (hasVote1 && !hasReflection) {
+            setReflectionPanelEnabled(true);
+        }
         logPeerEvent({
             sid: eBookConfig.username,
             div_id: `${assignId}`,
@@ -91,16 +585,87 @@ <h4>A discussion for you to consider</h4>
             act: "start_async",
             course_name: eBookConfig.course,
         })
-        setTimeout(function () {
-            $(window.componentMap[currentQuestion].submitButton).click(function () {
-                if (studentVoteCount == 1) {
-                    let currAnswer = window.componentMap[currentQuestion].answer;
-                    console.log(`current answer is ${currAnswer}`);
-                    let sAnswer = answerToString(currAnswer);
-                    console.log(sAnswer);
-                    $("#current_answer").html(sAnswer)
+        let bindAttempts = 0;
+        const bindVoteHandler = function () {
+          const btn = window.componentMap[currentQuestion]?.submitButton;
+          if (!btn) {
+            bindAttempts += 1;
+            if (bindAttempts < 40) {
+              setTimeout(bindVoteHandler, 100);
+            }
+            return;
+          }
+
+          $(btn).off("click.pi_async").on("click.pi_async", function () {
+            if (window._vote1Locked && !window._vote2Enabled) {
+              return;
+            }
+            const currAnswer = window.componentMap[currentQuestion].answer;
+            const sAnswer = answerToString(currAnswer);
+            $("#current_answer").html(sAnswer);
+
+            if (typeof logPeerEvent === "function") {
+              const voteNum = studentVoteCount;
+              const answerSnapshot = sAnswer;
+              setTimeout(() => {
+                const comp = window.componentMap[currentQuestion];
+                const correct =
+                  comp && typeof comp.correct !== "undefined"
+                    ? comp.correct
+                    : null;
+                logPeerEvent({
+                  sid: eBookConfig.username,
+                  div_id: currentQuestion,
+                  event: "pi_vote",
+                  act: JSON.stringify({
+                    pi_attempt_id: getPiAttemptId(),
+                    vote_num: voteNum,
+                    answer: answerSnapshot,
+                    correct: correct,
+                  }),
+                  course_name: eBookConfig.course,
+                });
+              }, 0);
+            }
+
+            if (studentVoteCount === 1 && !window._vote2Enabled) {
+              hasVote1 = true;
+              console.log("vote 1 submitted");
+
+              const vote2Btn = document.getElementById("readyVote2Btn");
+              if (vote2Btn) {
+                vote2Btn.disabled = true;
+                vote2Btn.title = "Send at least one LLM message to unlock";
+              }
+              window._hasVote1 = true;
+              setReflectionPanelEnabled(true);
+
+              return;
+            }
+
+            if (window._vote2Enabled && !studentSubmittedVote2) {
+              console.log("vote 2 submitted");
+              studentVoteCount = 2;
+              studentSubmittedVote2 = true;
+              window._vote2Enabled = false;
+            }
+            if (studentSubmittedVote2) {
+              try {
+                const comp = window.componentMap[currentQuestion];
+                if (comp && typeof comp.showFeedback === "function") {
+                  comp.showFeedback();
                 }
-            })
-        }, 2000)
+              } catch (e) {
+                console.warn("Could not show correctness feedback", e);
+              }
+            }
+          });
+        };
+        bindVoteHandler();
     });
 </script>
+<script>
+  document.addEventListener("DOMContentLoaded", function () {
+    document.querySelectorAll('.pi-ask-btn').forEach(btn => btn.remove());
+  });
+</script>