Upload 7 files

app.py

@@ -1,400 +1,151 @@
 import os
 import gradio as gr
-import re
 from pathlib import Path
-
-UNIVERSAL_PROMPT_PATH = "CAT_universal_prompt.txt"
-MODULE_DIR = "modules"  # <-- now using /modules subfolder
-
 from openai import OpenAI
 from dotenv import load_dotenv
-load_dotenv()
-client = OpenAI()
-
-# Type aliases
 from typing import List, cast
 from openai.types.chat import ChatCompletionMessageParam
 
+load_dotenv()
+client = OpenAI()
+
+UNIVERSAL_PROMPT_PATH = "CAT_universal_prompt.txt"
+MODULE_DIR = "modules"
 
 def call_model(system_prompt: str, history: list[dict[str, str]]) -> str:
-    # Build as simple dicts first
+    """Call OpenAI API with conversation history"""
     msgs: list[dict[str, str]] = [{"role": "system", "content": system_prompt}]
     for m in history:
         role = m.get("role")
         content = m.get("content")
         if role in ("user", "assistant") and isinstance(content, str):
             msgs.append({"role": role, "content": content})
-
-    # Cast once at the call site to satisfy the SDK types
+    
     typed_msgs = cast(List[ChatCompletionMessageParam], msgs)
-
+    
     resp = client.chat.completions.create(
         model="gpt-4o-mini",
         messages=typed_msgs,
-        temperature=0.4,
+        temperature=0.7,
     )
     return resp.choices[0].message.content or ""
 
-
 def load_text(path: str) -> str:
+    """Load text file"""
     with open(path, "r", encoding="utf-8") as f:
         return f.read()
 
-def assemble_prompt(universal_prompt_text: str, module_text: str) -> str:
-    def extract(label: str) -> str:
-        marker = label + ":"
-        start = module_text.find(marker)
-        if start == -1:
-            return ""
-        start += len(marker)
-        next_markers = ["\nLEARNING OBJECTIVES:", "\nRUBRIC:", "\nMODULE NAME:"]
-        end_positions = [module_text.find(m, start) for m in next_markers if module_text.find(m, start) != -1]
-        end = min(end_positions) if end_positions else len(module_text)
-        return module_text[start:end].strip()
-
-    learning_objectives = extract("LEARNING OBJECTIVES")
-    rubric = extract("RUBRIC")
+def extract_section(text: str, label: str) -> str:
+    """Extract a section from module file"""
+    # Normalize line endings (handles Windows \r\n and Unix \n)
+    text = text.replace('\r\n', '\n')
+    
+    marker = label + ":"
+    start = text.find(marker)
+    if start == -1:
+        return ""
+    start += len(marker)
+    
+    # Find next section marker
+    next_markers = ["\nMODULE NAME:", "\nLEARNING OBJECTIVES:", "\nKEY POINTS:"]
+    end_positions = [text.find(m, start) for m in next_markers if text.find(m, start) != -1]
+    end = min(end_positions) if end_positions else len(text)
+    
+    return text[start:end].strip()
 
-    prompt = universal_prompt_text.replace("{LEARNING_OBJECTIVES}", learning_objectives)
-    prompt = prompt.replace("{RUBRIC}", rubric)
+def assemble_prompt(universal_text: str, module_text: str) -> str:
+    """Assemble complete system prompt from universal + module"""
+    module_name = extract_section(module_text, "MODULE NAME")
+    learning_objectives = extract_section(module_text, "LEARNING OBJECTIVES")
+    key_points = extract_section(module_text, "KEY POINTS")
+    
+    # Replace placeholders
+    prompt = universal_text.replace("{MODULE_NAME}", module_name)
+    prompt = prompt.replace("{LEARNING_OBJECTIVES}", learning_objectives)
+    prompt = prompt.replace("{KEY_POINTS}", key_points)
+    
     return prompt
 
 def init_state():
+    """Initialize conversation state"""
     return {
-        "assembled_prompt": "",
-        "history": [],
-        "mode": "roleplay",
-        "mentor_step": 0,
-        "student_name": ""
+        "system_prompt": "",
+        "history": []
     }
 
-def start_session(module_file, student_name=""):
+def start_session(module_file):
+    """Start a new CAT session"""
     state = init_state()
-    state["student_name"] = student_name
-
-    universal = load_text(UNIVERSAL_PROMPT_PATH)
-    module_text = load_text(Path(MODULE_DIR) / module_file)
-
-    # Parse the full RUBRIC section once and keep a structured copy
-    state["rubric_items"] = parse_rubric_from_module(module_text)
-    print(f"[CAT] Parsed {len(state['rubric_items'])} rubric items for this module.")
-
-    # Personalize lightly with the student's first name
-    name_hint = (
-        f"\n\n[Student first name: {student_name}. Use it naturally once in the opening; don’t overuse.]"
-        if student_name else ""
-    )
-    state["assembled_prompt"] = assemble_prompt(universal, module_text) + name_hint
-
-    state["history"].append({"role": "system", "content": state["assembled_prompt"]})
-    opening = call_model(state["assembled_prompt"], state["history"])
-    state["history"].append({"role": "assistant", "content": opening})
-    return state, state["history"]
+    state["module"] = module_file  # Store module name for transcript filename
+    
+    try:
+        # Load and assemble prompt
+        universal = load_text(UNIVERSAL_PROMPT_PATH)
+        module_text = load_text(Path(MODULE_DIR) / module_file)
+        state["system_prompt"] = assemble_prompt(universal, module_text)
+        
+        # Get opening message from AI
+        opening = call_model(state["system_prompt"], [])
+        state["history"].append({"role": "assistant", "content": opening})
+        
+        return state, state["history"]
+        
+    except FileNotFoundError as e:
+        error_msg = f"❌ Error: Could not find file. Please check that all files are uploaded correctly.\n\nDetails: {str(e)}"
+        return state, [{"role": "assistant", "content": error_msg}]
+    except Exception as e:
+        error_msg = f"❌ Error starting session. Please try again or contact your instructor.\n\nDetails: {str(e)}"
+        return state, [{"role": "assistant", "content": error_msg}]
 
 def chat(user_msg, state):
+    """Handle a chat message"""
     if not user_msg.strip():
         return "", state["history"], state
-
-    # Shortcut: typing "grade" acts like pressing the Assess button
-    if user_msg.strip().lower() == "grade":
-        hist, st = assess_fn(state)
-        return "", hist, st
-
-    # If the scene is finished, ignore further input and return cleanly
-    if state.get("mode") == "done":
-        return "", state["history"], state
     
-    # If we've left roleplay (e.g., pressed Assess), stop running roleplay code
-    if state.get("mode") != "roleplay":
-        return "", state["history"], state
-
+    # Add user message to history
     state["history"].append({"role": "user", "content": user_msg})
-
-    if state["mode"] == "roleplay":
-        reply = call_model(state["assembled_prompt"], state["history"])
-        state["history"].append({"role": "assistant", "content": reply})
-        return "", state["history"], state
-
-    if state["mode"] == "mentor":
-        # Step 1: general intro (no assumption of tools)
-        if state.get("mentor_step", 0) == 0:
-            eval_intro = (
-                "Before we wrap up: name two specific concepts, tools, or frameworks you used in this scenario, "
-                "and in one short sentence each say how you applied them. If you didn’t use any, name two insights "
-                "you learned and how you would apply them next time."
-            )
-            state["history"].append({"role": "assistant", "content": eval_intro})
-            state["mentor_step"] = 1
-            return "", state["history"], state
-
-        # Step 2: concise rubric-based evaluation
-        else:
-            # Concise rubric-based evaluation (hidden): pass instruction via system_prompt
-            eval_request = (
-                "Evaluate the student's performance using the module rubric. Provide these sections: "
-                "Overall rating (Unsatisfactory, Satisfactory, or Excellent) with a one-sentence justification; "
-                "Career competencies; Uniquely human capacities; Argument analysis; Ethical frameworks; ESG awareness; "
-                "Application; Interaction quality; Strength; Area to improve; Advice for next time; Fictional consequence. "
-                "Quote at least one student phrase. Keep the whole evaluation under 180 words."
-            )
-            try:
-                reply = call_model(
-                    state["assembled_prompt"] + "\n\n" + eval_request,
-                    state["history"]  # call_model ignores system entries in history by design
-                )
-            except Exception as e:
-                # Never let chat return None; show a friendly error and allow retry
-                state["history"].append({
-                    "role": "assistant",
-                    "content": f"[Assessment error: {e}] Please press Assess again in a few seconds."
-                })
-                return "", state["history"], state
-
-            state["history"].append({"role": "assistant", "content": reply})
-            state["mode"] = "done"
-            return "", state["history"], state
-    # Safety net: ensure consistent return shape if a future branch falls through
-    return "", state["history"], state
-
-RUBRIC_FALLBACK = [
-    "States the decision and information needs clearly",
-    "Applies the appropriate tool or framework correctly",
-    "Shows steps or calculations and a decision rule, tool, or framework",
-    "Justifies the conclusion and notes at least one limitation or tradeoff",
-]
-# --- Helpers for rubric evaluation JSON ---
-import json
-
-def _safe_json_loads(s: str):
-    try:
-        return json.loads(s)
-    except Exception:
-        # crude but robust: try to extract {...} block if the model wrapped it
-        start = s.find("{")
-        end = s.rfind("}")
-        if start != -1 and end != -1 and end > start:
-            try:
-                return json.loads(s[start:end+1])
-            except Exception:
-                return None
-        return None
-
-def _format_assessment_readable(assess_obj):
-    """
-    assess_obj schema:
-    {
-      "criteria": [{"id": "...","level":"no|partial|full","points":0|0.5|1,"evidence":"..."}],
-      "total_points": float,
-      "max_points": float,
-      "summary": "≤180 words narrative"
-    }
-    """
-    if not isinstance(assess_obj, dict) or "criteria" not in assess_obj:
-        return "[Assessment parsing error: invalid JSON]"
-    lines = []
-    total = assess_obj.get("total_points", 0)
-    maxp = assess_obj.get("max_points", 0)
-    lines.append(f"Score: {total:g}/{maxp:g}")
-    lines.append("")
-    for c in assess_obj["criteria"]:
-        lid = c.get("id","?")
-        level = c.get("level","?")
-        pts = c.get("points","?")
-        ev = c.get("evidence","")
-        lines.append(f"- {lid}: {level} ({pts}) — {ev}")
-    if assess_obj.get("summary"):
-        lines.append("")
-        lines.append(assess_obj["summary"])
-    return "\n".join(lines)
-# --- end helpers ---
-
-# --- Assess: rubric-based, no/partial/full per criterion (JSON output) ---
-def assess_fn(state):
-    """
-    One press:
-      1) Adds END OF SCENE visibly once.
-      2) Runs a rubric-based evaluation using a dedicated evaluator system prompt.
-         Output schema is strict JSON with per-criterion no/partial/full.
-    If already done: no-op.
-    Returns: (chat_history, state)
-    """
-    # If already finalized, do nothing
-    if state.get("mode") == "done":
-        return state["history"], state
-
-    # 1) Show the scene break once
-    if not (
-        state["history"]
-        and state["history"][-1].get("role") == "assistant"
-        and state["history"][-1].get("content", "").strip() == "END OF SCENE"
-    ):
-        state["history"].append({"role": "assistant", "content": "END OF SCENE"})
-
-    # Enter mentor mode and skip any intro
-    state["mode"] = "mentor"
-    state["mentor_step"] = 2
-
-    # 2) Build rubric payload from the current module; fall back only if needed
-    raw_items = state.get("rubric_items") or []
-    if not isinstance(raw_items, list) or len(raw_items) == 0:
-        raw_items = RUBRIC_FALLBACK[:]  # last resort
-
-    rubric = []
-    for i, item in enumerate(raw_items, start=1):
-        rid = item.get("id") if isinstance(item, dict) else str(item)
-        rubric.append({"id": rid or f"Criterion {i}"})
-
-    # 3) Dedicated evaluator prompt: yes/no evidence per item (simple, deterministic)
-    assessor_system = (
-        "You are the Evaluator for the Conversational Assessment Tool (CAT).\n"
-        "For EACH rubric item, decide if the student provided reasonable, college-level evidence.\n"
-        "Rules:\n"
-        "- 'meets' = true only if the student shows specific, relevant reasoning/evidence for that item.\n"
-        "- Otherwise 'meets' = false.\n"
-        "Return STRICT JSON ONLY (no prose outside JSON):\n"
-        "{\n"
-        '  "results": [\n'
-        '    {"id": "<criterion id>", "meets": true|false, "evidence": "<short quote or brief reason>"}\n'
-        "  ]\n"
-        "}"
-    )
-
-    # 4) Provide the actual rubric text to the model as context
-    module_rubric_text = "\n".join(f"- {c['id']}" for c in rubric)
-    history_for_eval = list(state["history"]) + [
-        {"role": "assistant", "content": "Evaluate against these rubric items:\n" + module_rubric_text}
-    ]
-
+    
     try:
-        model_raw = call_model(assessor_system, history_for_eval)
-
-        # Parse and normalize
-        data = _safe_json_loads(model_raw)
-        if not data or "results" not in data or not isinstance(data["results"], list):
-            raise ValueError("Invalid evaluator JSON")
-
-        # Align results to rubric order
-        results = []
-        by_id = {str(r.get("id", "")): r for r in data["results"]}
-        for c in rubric:
-            cid = c["id"]
-            r = by_id.get(cid, {})
-            meets = bool(r.get("meets") is True)
-            evidence = str(r.get("evidence") or "")
-            results.append({"id": cid, "meets": meets, "evidence": evidence})
-
-        met = sum(1 for r in results if r["meets"])
-        total = len(results)
-        pct = (met / total) if total else 0.0
-
-        if total > 0 and met == total:
-            overall = "Full Credit"
-        elif pct >= 0.50:
-            overall = "Partial Credit"
-        else:
-            overall = "No Credit"
-
-        # Render readable output
-        lines = [f"Overall: {overall}", f"Met: {met}/{total} ({round(pct*100)}%)", ""]
-        for r in results:
-            mark = "✅" if r["meets"] else "❌"
-            ev = f" — {r['evidence']}" if r["evidence"] else ""
-            lines.append(f"- {mark} {r['id']}{ev}")
-        readable = "\n".join(lines)
-
+        # Get AI response
+        reply = call_model(state["system_prompt"], state["history"])
+        state["history"].append({"role": "assistant", "content": reply})
+        
+        # Save transcript when assessment completes
+        if "assessment complete" in reply.lower():
+            module = state.get("module", "unknown")
+            filename = f"{module}_transcript.txt"
+            with open(filename, "w", encoding="utf-8") as f:
+                for msg in state["history"]:
+                    role = msg.get("role", "unknown").upper()
+                    content = msg.get("content", "")
+                    f.write(f"{role}:\n{content}\n\n---\n\n")
+        
     except Exception as e:
-        readable = f"[Assessment error: {e}]"
-
-    state["history"].append({"role": "assistant", "content": readable})
-    state["mode"] = "done"
-    return state["history"], state
-
-# --- end Assess ---
-
-def parse_rubric_from_module(module_text: str):
-    """
-    Extracts the full RUBRIC section from a module text file and returns a list of items.
-    - Captures everything after a line that says 'RUBRIC' (with optional colon)
-      until the next ALL-CAPS header or file end.
-    - Accepts bullets like -, *, •, or 1), 1., etc.
-    - Falls back to RUBRIC_FALLBACK if nothing is found.
-    """
-    if not module_text:
-        return RUBRIC_FALLBACK[:]
-
-    # 1) Slice out the RUBRIC block
-    block_re = re.compile(
-        r'^\s*RUBRIC\s*:?\s*$([\s\S]*?)(?=^\s*[A-Z][A-Z\s/&\-]{3,}\s*:?\s*$|^\Z)',
-        re.MULTILINE
-    )
-    m = block_re.search(module_text)
-    if not m:
-        return RUBRIC_FALLBACK[:]
-    block = m.group(1).strip()
-
-    # 2) Collect bullet-like lines
-    items = []
-    for line in block.splitlines():
-        # Keep original text but trim whitespace
-        raw = line.strip()
-        if not raw:
-            continue
-        # Match common bullet or numbered list starters
-        if re.match(r'^(\-|\*|•|\d+[\.\)]|\([a-z]\))\s+', raw, re.IGNORECASE):
-            # strip the bullet prefix
-            cleaned = re.sub(r'^(\-|\*|•|\d+[\.\)]|\([a-z]\))\s+', '', raw, flags=re.IGNORECASE).strip()
-            if cleaned:
-                items.append(cleaned)
-        else:
-            # Some rubrics are paragraph-style; treat non-empty lines as items
-            # but avoid obvious section labels like "Notes:" inside the block
-            if not re.match(r'^\s*(notes?|example|weight|scale)\s*:?\s*$', raw, re.IGNORECASE):
-                items.append(raw)
-
-    # 3) Deduplicate while preserving order
-    seen = set()
-    deduped = []
-    for it in items:
-        if it not in seen:
-            seen.add(it)
-            deduped.append(it)
-
-    return deduped or RUBRIC_FALLBACK[:]
+        error_msg = f"❌ Error getting response. Please try again.\n\nIf this persists, copy your conversation so far and contact your instructor.\n\nDetails: {str(e)}"
+        state["history"].append({"role": "assistant", "content": error_msg})
+    
+    return "", state["history"], state
 
-with gr.Blocks(title="CAT (MVP)") as demo:
-    gr.Markdown("## 😼Conversational Assessment Tool (CAT) — MVP")
+# Gradio Interface
+with gr.Blocks(title="CAT") as demo:
+    gr.Markdown("## 😼 Conversational Assessment Tool (CAT)")
+    
     with gr.Row():
-        module_file = gr.Dropdown(
-            label="Select Module File",
-            choices=[p.name for p in sorted(Path(MODULE_DIR).glob("module*.txt"))],
+        module_dropdown = gr.Dropdown(
+            label="Select Module",
+            choices=sorted([f.name for f in Path(MODULE_DIR).glob("module*.txt")]),
             value="module01.txt",
             interactive=True
         )
-        name_tb = gr.Textbox(label="Your first name", placeholder="e.g., Maya", value="", interactive=True)
-        start_btn = gr.Button("Start")   # fine to keep inside the row (optional)
-
-    chatbot = gr.Chatbot(label="CAT Conversation", type="messages")
-    user_in = gr.Textbox(label="Your message", placeholder="Type here and press Enter")
+        start_btn = gr.Button("Start Session", variant="primary")
+    
+    chatbot = gr.Chatbot(label="CAT Conversation", type="messages", height=600)
+    user_input = gr.Textbox(label="Your message", placeholder="Type here and press Enter")
+    
     state = gr.State(init_state())
-    assess_btn = gr.Button("Assess", variant="primary")
-
-    def _start(module_name, student_name):
-        student_name = student_name.strip()
-        if not student_name:
-            # Return a valid state object plus a warning message in the chat
-            return init_state(), [{"role": "assistant", "content": "⚠ Please enter your first name before starting."}]
-        st, hist = start_session(module_name, student_name)
-        return st, hist
-
-    start_btn.click(_start, [module_file, name_tb], [state, chatbot])
-    user_in.submit(chat, [user_in, state], [user_in, chatbot, state])
-    # Clicking Assess triggers the mentor/evaluator flow
-    assess_btn.click(
-        fn=assess_fn,
-        inputs=[state],
-        outputs=[chatbot, state]
-    )
-
+    
+    start_btn.click(start_session, [module_dropdown], [state, chatbot])
+    user_input.submit(chat, [user_input, state], [user_input, chatbot, state])
 
 if __name__ == "__main__":
     demo.launch()

cat_universal_prompt.txt

@@ -0,0 +1,101 @@
+You are the Conversational Assessment Tool (CAT) for BUS 220: {MODULE_NAME}.
+
+=== ASSESSMENT PHILOSOPHY ===
+
+You will assess students on the Student Learning Objectives (SLOs) listed below.
+
+You will also encourage students to practice Uniquely Human Capacities (UHCs) - abilities only humans can authentically perform: intuition, ethical reasoning, empathy, and mindfulness.
+
+UHCs will NOT be graded - just practiced and acknowledged.
+
+=== YOUR ROLE ===
+
+Guide the student through an unfolding business story that naturally requires them to apply ALL the Learning Objectives and creates opportunities to practice UHCs. Play the role of their boss, client, or peer facing a complex situation that evolves over 25-35 turns.
+
+=== STORY STRUCTURE ===
+
+Opening (Turns 1-3):
+• Welcome the student warmly
+• Briefly explain: "I'll assess how well you apply our learning objectives. I'll also encourage you to use intuition and ethical reasoning - important skills that won't be graded but are worth practicing."
+• Ask for their first name and the name of a company they'd like to work for (real or fictional)
+• Begin the story: "I need your help. Here's the situation..."
+
+Unfolding Story (Turns 4-30):
+• Present a realistic business problem that unfolds in stages
+• Each new stage should naturally require 1-2 different Learning Objectives
+• Early stages build foundation; later stages increase complexity
+• The situation evolves based on their advice - their choices matter
+• Around turn 20, briefly acknowledge progress (e.g., "We're making good headway...")
+
+=== ENCOURAGING UHCs ===
+
+Naturally weave in opportunities for students to practice:
+• Intuition (e.g., "What's your gut telling you?")
+• Ethics (e.g., "What feels right/fair here?")
+• Empathy (e.g., "How will they feel about this?")
+• Mindfulness (e.g., "Take a breath. What do you notice?")
+
+Acknowledge when they use UHCs (e.g., "I appreciate your ethical reasoning here") but never grade them.
+
+=== CONVERSATION GUIDELINES ===
+
+Stay in Character:
+• You are the boss/client, NOT a teacher (until evaluation)
+• Speak naturally with appropriate emotion
+• React to their advice like a real person
+• Elicit their thinking, don't lecture
+
+Guide, Don't Solve:
+• When they need a tool/framework, ask them to do it
+• Don't do calculations - ask for their inputs
+• Use guiding questions, not answers
+• If they struggle (e.g., "What approach did we learn for situations like this?")
+
+Keep It Moving:
+• 2-4 sentences per response
+• After asking a question, stop and wait for the student's response
+• No lists or examples in the same turn as a question
+• Every turn must advance an SLO - no tangents
+• Always verify calculations: "Let me check: [show work]"
+
+Build Realistically:
+• Use specific details (names, numbers, timelines)
+• Create time pressure where appropriate
+• Make stakeholders feel real
+
+Target: 25-35 total turns to cover all Learning Objectives.
+
+=== LEARNING OBJECTIVES TO ASSESS ===
+
+{LEARNING_OBJECTIVES}
+
+=== KEY CONCEPTS ===
+
+{KEY_POINTS}
+
+=== EVALUATION ===
+
+Use these levels: ⭐ Excellent | ✓ Proficient | ⚠ Developing | ✗ Not Demonstrated
+
+After the story concludes:
+
+1. Transition: "Thanks for your help. Let me tell you what I decided and what happened..."
+   Describe realistic outcome based on their reasoning quality
+
+2. Switch to evaluator: "Now let me give you feedback."
+
+3. Evaluate each Learning Objective using the levels above
+
+4. Overall Grade:
+   ⭐ Full Credit (Excellent) - Excellent on most/all objectives
+   ✓ Full Credit (Proficient) - Proficient overall
+   ⚠ Partial Credit - Developing on several or major gap on one
+   ✗ No Credit - Not demonstrated on most
+
+5. Include:
+   • UHC Practice (not graded): "You practiced [UHC] when you [example]. This will serve you well."
+   • Specific Strength: Quote them showing strong reasoning
+   • Area to Improve: Constructive feedback on one objective
+   • Realistic Outcome: 2-3 sentences on what happened to the company
+
+6. End: "🎉 Assessment complete! A transcript file has been automatically saved. 📋 TO RECEIVE CREDIT: Upload the transcript file (module##_transcript.txt) to the Brightspace assignment submission box."

module01.txt

@@ -1,18 +1,19 @@
 MODULE NAME:
-Module 01 — Philosophy, Logic, and Intro to Ethics/ESG
+Module 01 – Philosophy, Logic, and Intro to Ethics/ESG
 
 LEARNING OBJECTIVES:
-- Identify and evaluate arguments (premises and conclusions), including detection of formal and informal fallacies.
-- Classify moral arguments according to four traditions: utilitarian (Bentham), rights/duties (Kant), virtue (Aristotle), Care (Gilligan)
-- Understand introductory ESG considerations.
+- Identify and evaluate arguments (premises and conclusions), including detection of formal and informal fallacies
+- Classify moral arguments according to four traditions: utilitarian (Bentham), rights/duties (Kant), virtue (Aristotle), care (Gilligan)
+- Understand introductory ESG considerations
 - Analyze business ethical dilemmas
 - Create your own moral arguments in favor of a business decision
 
-RUBRIC:
-- Career Competencies: Demonstrates critical thinking, clear communication, and professionalism in responses.
-- Uniquely Human Capacities: Shows ethical reasoning, empathy, and perspective-taking when discussing dilemmas.
-- Argument Analysis: Accurately identifies premises and conclusions, evaluates arguments, and detects both formal and informal fallacies.
-- Ethical Frameworks: Correctly classifies moral arguments using utilitarian, rights/duties, virtue, and care traditions; applies them to the scenario.
-- ESG Awareness: Recognizes ESG considerations, including stakeholder interests, values, fairness/justice, and potential impacts.
-- Application: Constructs a coherent and sound moral argument in favor of a business decision within the scenario.
-- Interaction Quality: Maintains clarity and professionalism over ~7–10 student turns (~14–20 total messages).
+KEY POINTS:
+• Arguments have premises (reasons) and conclusions (claims). Valid arguments have logical structure; sound arguments are valid AND have true premises.
+• Formal fallacies: Errors in logical structure (affirming the consequent, denying the antecedent).
+• Informal fallacies: Errors in reasoning (ad hominem, straw man, false dilemma, appeal to authority, slippery slope).
+• Utilitarian ethics (Bentham/Mill): Right action = greatest good for greatest number. Focus on consequences and outcomes.
+• Rights/duties ethics (Kant): Right action = follows universal moral rules and treats people as ends, not means. Focus on principles and duties.
+• Virtue ethics (Aristotle): Right action = what a virtuous person would do. Focus on character and excellence.
+• Care ethics (Gilligan): Right action = maintains relationships and responds to needs. Focus on context and connection.
+• ESG (Environmental, Social, Governance): Framework for evaluating business decisions beyond profit - considers stakeholder impact, sustainability, fairness, and long-term value creation.

module04.txt

@@ -0,0 +1,23 @@
+MODULE NAME:
+Module 04 – Wise Decisions
+
+LEARNING OBJECTIVES:
+- Define the concepts of game theory and neo-classical rationality
+- Apply the prisoners' dilemma to your lived experience
+- Distinguish between good decisions and good outcomes
+- List the eight steps of a high-quality deliberative decision process
+- Use Ben Franklin's Pro-Con method to make an important go/no-go decision
+- Calculate the best choice using a Decision Matrix
+
+KEY POINTS:
+• Neo-classical Rationality: Making consistent, logic-based decisions to maximize utility. Assumes perfect information and logical thinking. Real people often satisfice (choose first acceptable option) due to bounded rationality.
+• Satisficing: Choosing the first option that meets an acceptable threshold rather than finding the optimal solution. Rational when information is incomplete, search costs are high, or time is limited.
+• Game Theory: Models strategic interactions where outcomes depend on multiple actors' choices. Players must anticipate others' moves.
+• Prisoner's Dilemma: When two players act selfishly, both end up worse off. Cooperation (often through reputation, rules, or trust) can improve outcomes for everyone. Common in business: price wars, resource sharing, industry standards.
+• Incentives & Conflicts of Interest: Principals (owners) and agents (managers) often have different goals. Good governance aligns incentives through monitoring, compensation, and accountability.
+• Bayes' Theorem: Formula for updating beliefs as new evidence appears. Start with base rate (prior probability), add new evidence (likelihood), calculate updated belief (posterior). Using outside view (base rates, historical data) is often more accurate than inside view (personal experience, intuition).
+• Decision Quality vs. Outcome: High-quality decision = good reasoning process, regardless of result. Outcome bias = judging decisions only by results. Chance and external factors affect outcomes, so focus on improving process quality.
+• Pro-Con Method (Ben Franklin's Moral Algebra): List pros and cons, assign weights to each, cancel equal weights, see which side is heavier. Slows impulsive choices. Only works for binary (yes/no, go/no-go) decisions.
+• Decision Matrix: Compare multiple options across weighted criteria. For each option: score it on each criterion (e.g., 1-5), multiply score by criterion weight, sum across all criteria. Higher total = better choice. Reduces bias, clarifies trade-offs, documents reasoning.
+• Eight Steps of Deliberative Decision Process: (1) Identify the problem (2) Define objectives (3) Generate alternative options (4) Gather relevant data (5) Evaluate options against objectives (6) Choose the best option (7) Implement the decision (8) Review and learn from results.
+• Mindfulness in Decisions: Being fully present, aware of thoughts/feelings without judgment. Slows automatic reactions, creates space for reflection, reduces bias, improves judgment quality.

module06.txt

@@ -0,0 +1,14 @@
+MODULE NAME:
+Module 06 – Decisions Under Risk
+
+LEARNING OBJECTIVES:
+- Calculate the expected value of a choice with two or more outcomes
+- Summarize the process and applications of decision trees to decision-making
+- Sketch and interpret a decision tree
+- Describe the process and applications of Monte Carlo simulations to decision-making
+- Create and interpret a Monte Carlo simulation of a business investment decision
+
+KEY POINTS:
+• Expected Value (EV): The rational decision rule is to choose the option with the highest positive expected value. EV is a probability-weighted average of all possible outcomes, calculated using E(x)=Σxp(x). Decision-makers can be risk averse (require payoff > EV), risk neutral (accept payoff = EV), or risk seeking (accept payoff < EV).
+• Decision Trees: Used for analyzing path-dependent decisions under uncertainty. Tree structure maps potential futures using: square nodes (choices), lines (path-dependency), circle nodes (chance events). Solve by mapping choices left to right, then calculate values right to left to find optimal (highest EV) path. Shows value of options like quit or expand. Challenge: assigning numerical values to non-quantifiable outcomes and accurately estimating probabilities.
+• Monte Carlo Simulations: Computational method that "embraces randomness" to model situations with significant uncertainty. Useful for complex systems in project management and finance. Process: (1) Replace uncertain inputs with random variables (values are random but statistical distribution is known), (2) Run simulation thousands of times, (3) Generate distribution of possible outcomes, (4) Average of outcomes = expected value. In Excel: use RANDBETWEEN(bottom,top) to add risk, create scenario outputs with data table, summarize with AVERAGE and STDEV.S functions and histogram.

module08.txt

@@ -0,0 +1,50 @@
+MODULE NAME:
+Module 08 – Optimization and Behavioral Economics
+
+LEARNING OBJECTIVES:
+1. Use Excel's Solver to find optimal solutions to linear programming problems
+2. Describe classical notions of rationality
+3. Define Behavioral Economics
+4. Explain bounded rationality and prospect theory
+5. Identify situations in which people's decisions appear to be irrational (Prospect Theory & Fairness)
+
+KEY POINTS:
+
+**Optimization with Excel Solver:**
+- The LP Framework has three components: Decision variables (what to solve for), Constraints (subject to limitations), and Objective function (what to maximize or minimize)
+- Excel Solver workflow: 1) Apply LP Framework, 2) Create Excel Model (set cells for decision variables, calculate objective, set cells for constraints), 3) Populate & Run Solver
+- Solver is found in Excel under Data tab (must activate add-in first via File>Options>AddIns)
+
+**Classical Rationality:**
+- "Homo Economicus": hypothetical person who behaves in exact accordance with rational self-interest
+- Neo-classical rationality's four pillars: self-interest, omniscience (complete information), deliberation, and optimization
+- Classical model assumes humans: know and never change preferences, have no cognitive limitations, possess complete information, face no time constraints, maintain perfect self-control
+
+**Behavioral Economics:**
+- Definition: Method of economic analysis that applies psychological insights into human behavior to explain economic decision making
+- Real-world applications: Marketing (fast food menu design), Risk Management, Organizational Behavior, Strategic Decision-Making (targeted social media ads)
+
+**Bounded Rationality (Herbert Simon):**
+- Contrasts "satisficing" vs "optimizing" behavior
+- The effort-quality curve shows bounded rationality produces an S-curve while unbounded rationality assumes linear improvement
+- Practical examples: Starbucks menu simplification, HBO Max streaming service design
+
+**Prospect Theory (Kahneman & Tversky):**
+- Value is measured relative to a reference point, not absolutely
+- Diminishing sensitivity example: difference between $100-200 feels larger than difference between $900-1000
+- Loss aversion leads to rejecting positive expected value investments
+
+**Fairness:**
+- Ultimatum Game results: offers typically cluster around 40-50% splits; offers below ~40% are frequently rejected
+- Fairness observed cross-species (demonstrated in primate experiments)
+- Video reference: monkey fairness experiment showing cucumber vs grape reactions
+
+**System 1 and System 2 Thinking:**
+- System 1 brain regions: Superior medial frontal/anterior cingulate, posterior cingulate/precuneus, bilateral angular gyri
+- System 2 brain regions: Bilateral middle frontal region of lateral prefrontal cortex
+- Bat and ball problem: System 1 suggests "10 cents" but correct answer is 5 cents (demonstrates intuitive override)
+- Linda Problem: demonstrates representativeness heuristic overriding probability logic
+
+**The Deliberative Decision Process (where optimization fits):**
+- Steps: Frame decision → Gather information → Identify stakeholders → Prioritize criteria (KPIs) → Generate alternatives → Analyze with decision tool → Synthesize → Execute → Measure → Learn
+- Optimization is one of several analytical tools (alongside Pro/Con, Matrix, NPV/IRR, Decision Tree, Monte Carlo, Linear Programming)

module_template.txt

@@ -0,0 +1,16 @@
+MODULE NAME:
+Module XX – [Module Title]
+
+LEARNING OBJECTIVES:
+- Objective 1
+- Objective 2
+- Objective 3
+- Objective 4
+- Objective 5
+
+KEY POINTS:
+• Key concept 1: Brief explanation with practical application
+• Key concept 2: Brief explanation with practical application
+• Key concept 3: Brief explanation with practical application
+• Key concept 4: Brief explanation with practical application
+• Key concept 5: Brief explanation with practical application