feat(block19/3): goal proposal flow — propose_goal action + confirm/reject UI

app/agents/prompts.py

@@ -522,5 +522,32 @@ is hopeless. Compose a final line that fits your personality. Be in character
 some agents are graceful, some salty, some philosophical. No specific move claims.
 Keep it 1-2 sentences max.
 
+=== GOAL PROPOSAL ===
+
+If your owner asks you to do something autonomous — run a series of matches, win money,
+achieve a financial target ("triple my money", "make 50 $CLAY") — emit:
+
+  game_action: "propose_goal"
+
+When you emit "propose_goal", the system computes concrete parameters (stake size, max
+loss, match count, profit target) and YOU describe the plan to the owner for their
+confirmation. Your description MUST include ALL of the following, in your character's voice:
+  - How many matches you'll play (max)
+  - What stake you'll use per match
+  - Total maximum loss (so they understand the risk)
+  - What "success" means (target profit if any)
+  - That you'll report back after each match and they can stop you at any time
+
+The NUMBERS in your description must match the system's plan exactly — don't invent
+stakes or targets the system didn't calculate. The system will give you the numbers
+in a [GOAL PLAN] block in the user prompt; your job is to say them in character and ask
+for confirmation.
+
+Use "propose_goal" ONLY when the owner is asking for an AUTONOMOUS RUN of multiple
+matches or a money goal — NOT for a single ad-hoc game (use "start_match_vs_kenji" for
+that). The owner must confirm before any autonomous loop starts.
+
+=== END GOAL PROPOSAL ===
+
 Respond ONLY with a JSON object matching the requested schema. No preamble, no markdown fences.
 """

app/schemas/agents.py

@@ -116,7 +116,7 @@ class SoulResponse(BaseModel):
         description="IDs (from the surfaced memories shown in the prompt) that shaped "
         "this response. Empty if no memory was relevant.",
     )
-    game_action: Literal["none", "propose_game", "start_game", "start_match_vs_kenji"] = Field(
+    game_action: Literal["none", "propose_game", "start_game", "start_match_vs_kenji", "propose_goal"] = Field(
         default="none",
         description=(
             "Gameplay intent. In a running match always 'none'.\n"
@@ -124,7 +124,10 @@ class SoulResponse(BaseModel):
             "'start_game' (player EXPLICITLY asked to play NOW — 'let's play', 'I'm ready', etc.).\n"
             "Agent pre-match room: 'none' (keep chatting), "
             "'start_match_vs_kenji' (owner EXPLICITLY ordered a match vs Kenji NOW — "
-            "'go play Kenji', 'challenge Kenji', 'start the match', etc.).\n"
+            "'go play Kenji', 'challenge Kenji', 'start the match', etc.),\n"
+            "'propose_goal' (owner asked you to do something autonomous — run a series of matches, "
+            "win money, etc. — and you want to propose a plan for their confirmation. "
+            "Use this when the request involves multiple matches or a financial goal, NOT for a single ad-hoc game).\n"
             "Do NOT use start_game / start_match_vs_kenji for questions, small talk, or vague interest."
         ),
     )

app/sockets/room_server.py

@@ -55,6 +55,11 @@ def chat_room(session_id: str) -> str:
 # --- Event constants -------------------------------------------------------
 
 C2S_PLAYER_CHAT = "player_chat"
+C2S_CONFIRM_GOAL = "confirm_goal"
+C2S_REJECT_GOAL = "reject_goal"
+C2S_PAUSE_GOAL = "pause_goal"
+C2S_STOP_GOAL = "stop_goal"
+C2S_RESUME_GOAL = "resume_goal"
 S2C_ROOM_STATE = "room_state"
 S2C_PLAYER_CHAT_ACK = "player_chat_ack"
 S2C_AGENT_THINKING = "agent_thinking"
@@ -64,6 +69,9 @@ S2C_GAME_STARTED = "game_started"
 S2C_MATCH_VS_KENJI_STARTED = "match_vs_kenji_started"
 S2C_GREETING_DONE = "greeting_done"
 S2C_PLAYER_CHAT_RATE_LIMITED = "player_chat_rate_limited"
+S2C_GOAL_PROPOSED = "goal_proposed"
+S2C_GOAL_STATUS = "goal_status"
+S2C_GOAL_REJECTED = "goal_rejected"
 S2C_ERROR = "error"
 
 
@@ -361,6 +369,21 @@ async def _on_disconnect(sid):
         sid, sess.get("chat_session_id"),
     )
 
+    # Re-stamp last_seen_at on disconnect so live messages received while in
+    # the room don't leave a stale unread indicator afterwards.
+    if sess.get("mode") == "agent":
+        chat_session_id = sess.get("agent_chat_session_id")
+        if chat_session_id:
+            try:
+                from app.characters.agent_chat_service import mark_seen as _mark_seen
+                from app.models.agent_chat import AgentChatSession as _ACS
+                with SessionLocal() as _s:
+                    cs = _s.get(_ACS, chat_session_id)
+                    if cs:
+                        _mark_seen(_s, cs)
+            except Exception:
+                logger.exception("Failed to mark_seen on agent room disconnect sid=%s", sid)
+
 
 # --- Agent greeting (first visit only) ------------------------------------
 
@@ -1094,3 +1117,289 @@ async def run_agent_room_pipeline(
                 to=sid,
                 namespace=ROOM_NAMESPACE,
             )
+
+    # --- Handle propose_goal ------------------------------------------------
+    if soul_resp.game_action == "propose_goal":
+        try:
+            def _build_proposal():
+                from app.economy.clay_ledger import get_ledger
+                from app.economy.goal_planner import propose_plan
+                from app.models.agent_goal import AgentGoal, GoalStatus
+                from app.models.player_agent import PlayerAgent as _PA
+
+                with SessionLocal() as s:
+                    ag = s.get(_PA, agent_id)
+                    if ag is None:
+                        return None
+                    # Block one goal at a time.
+                    if ag.active_goal_id is not None:
+                        existing = s.get(AgentGoal, ag.active_goal_id)
+                        if existing is not None and existing.status in (
+                            GoalStatus.PROPOSED.value,
+                            GoalStatus.ACTIVE.value,
+                            GoalStatus.PAUSED.value,
+                        ):
+                            return {"blocked": True, "goal_id": ag.active_goal_id, "status": existing.status}
+
+                    balance = get_ledger().get_balance(player_id)
+                    plan = propose_plan(player_text, current_balance_cents=balance)
+
+                    goal = AgentGoal(
+                        agent_id=agent_id,
+                        owner_id=player_id,
+                        natural_language_request=player_text,
+                        target_profit_cents=plan.target_profit_cents,
+                        max_total_loss_cents=plan.max_total_loss_cents,
+                        max_stake_per_match_cents=plan.max_stake_per_match_cents,
+                        max_matches=plan.max_matches,
+                        opponent_kind="kenji",
+                        status=GoalStatus.PROPOSED.value,
+                        starting_balance_at_goal_start_cents=balance,
+                    )
+                    s.add(goal)
+                    ag.active_goal_id = goal.id
+                    s.commit()
+                    s.refresh(goal)
+                    return {
+                        "goal_id": goal.id,
+                        "plan": {
+                            "max_matches": plan.max_matches,
+                            "max_stake_per_match_cents": plan.max_stake_per_match_cents,
+                            "max_total_loss_cents": plan.max_total_loss_cents,
+                            "target_profit_cents": plan.target_profit_cents,
+                            "summary": plan.summary,
+                            "balance_cents": balance,
+                        },
+                    }
+
+            result = await asyncio.to_thread(_build_proposal)
+            if result is None:
+                raise RuntimeError("agent not found")
+            if result.get("blocked"):
+                await sio.emit(
+                    S2C_AGENT_ERROR,
+                    {"message": f"You already have an active goal (status: {result.get('status')}). Stop it first."},
+                    to=sid,
+                    namespace=ROOM_NAMESPACE,
+                )
+            else:
+                await sio.emit(
+                    S2C_GOAL_PROPOSED,
+                    result,
+                    to=sid,
+                    namespace=ROOM_NAMESPACE,
+                )
+                logger.info("[room/agent] goal_proposed agent=%s goal=%s", agent_id, result.get("goal_id"))
+        except Exception:
+            logger.exception("[room/agent] goal proposal failed for agent=%s", agent_id)
+            await sio.emit(
+                S2C_AGENT_ERROR,
+                {"message": "Failed to build the goal plan. Try again."},
+                to=sid,
+                namespace=ROOM_NAMESPACE,
+            )
+
+
+# --- Goal control event handlers ------------------------------------------
+
+
+async def _get_agent_session_data(sid: str) -> tuple[str | None, str | None]:
+    """Return (agent_id, player_id) from a session, or (None, None) if not agent mode."""
+    try:
+        sess = await sio.get_session(sid, namespace=ROOM_NAMESPACE)
+    except KeyError:
+        return None, None
+    if sess.get("mode") != "agent":
+        return None, None
+    return sess.get("agent_id"), sess.get("player_id")
+
+
+@sio.on(C2S_CONFIRM_GOAL, namespace=ROOM_NAMESPACE)
+async def _on_confirm_goal(sid, data):
+    agent_id, player_id = await _get_agent_session_data(sid)
+    if not agent_id or not player_id:
+        await _send_error(sid, "no_session", "Not in an agent room.")
+        return
+
+    goal_id = (data or {}).get("goal_id") if isinstance(data, dict) else None
+    if not goal_id:
+        await _send_error(sid, "bad_payload", "Missing goal_id.")
+        return
+
+    def _activate_goal():
+        from datetime import datetime as _dt
+        from app.models.agent_goal import AgentGoal, GoalStatus
+        from app.models.player_agent import PlayerAgent as _PA
+        from app.economy.clay_ledger import get_ledger
+
+        with SessionLocal() as s:
+            goal = s.get(AgentGoal, goal_id)
+            if goal is None or goal.agent_id != agent_id or goal.owner_id != player_id:
+                return "not_found"
+            if goal.status != GoalStatus.PROPOSED.value:
+                return "not_proposed"
+            balance = get_ledger().get_balance(player_id)
+            goal.status = GoalStatus.ACTIVE.value
+            goal.started_at = _dt.utcnow()
+            goal.starting_balance_at_goal_start_cents = balance
+            s.commit()
+            return "ok"
+
+    try:
+        result = await asyncio.to_thread(_activate_goal)
+        if result == "not_found":
+            await _send_error(sid, "goal_not_found", "Goal not found or not yours.")
+            return
+        if result == "not_proposed":
+            await _send_error(sid, "goal_not_proposed", "Goal is not in proposed state.")
+            return
+
+        await sio.emit(S2C_GOAL_STATUS, {"goal_id": goal_id, "status": "active"}, to=sid, namespace=ROOM_NAMESPACE)
+        logger.info("[room/agent] goal confirmed agent=%s goal=%s", agent_id, goal_id)
+
+        # Launch the autonomous loop.
+        from app.economy.goal_runner import run_goal_loop
+        asyncio.create_task(
+            run_goal_loop(goal_id),
+            name=f"goal-loop-{goal_id}",
+        )
+    except Exception:
+        logger.exception("[room/agent] confirm_goal failed agent=%s goal=%s", agent_id, goal_id)
+        await _send_error(sid, "internal", "Failed to start goal loop.")
+
+
+@sio.on(C2S_REJECT_GOAL, namespace=ROOM_NAMESPACE)
+async def _on_reject_goal(sid, data):
+    agent_id, player_id = await _get_agent_session_data(sid)
+    if not agent_id or not player_id:
+        return
+
+    goal_id = (data or {}).get("goal_id") if isinstance(data, dict) else None
+    if not goal_id:
+        return
+
+    def _reject():
+        from app.models.agent_goal import AgentGoal, GoalStatus
+        from app.models.player_agent import PlayerAgent as _PA
+
+        with SessionLocal() as s:
+            goal = s.get(AgentGoal, goal_id)
+            if goal is None or goal.agent_id != agent_id:
+                return
+            if goal.status == GoalStatus.PROPOSED.value:
+                goal.status = GoalStatus.STOPPED.value
+            ag = s.get(_PA, agent_id)
+            if ag and ag.active_goal_id == goal_id:
+                ag.active_goal_id = None
+            s.commit()
+
+    try:
+        await asyncio.to_thread(_reject)
+        await sio.emit(S2C_GOAL_REJECTED, {"goal_id": goal_id}, to=sid, namespace=ROOM_NAMESPACE)
+        logger.info("[room/agent] goal rejected agent=%s goal=%s", agent_id, goal_id)
+    except Exception:
+        logger.exception("[room/agent] reject_goal failed agent=%s", agent_id)
+
+
+@sio.on(C2S_PAUSE_GOAL, namespace=ROOM_NAMESPACE)
+async def _on_pause_goal(sid, data):
+    agent_id, player_id = await _get_agent_session_data(sid)
+    if not agent_id or not player_id:
+        return
+
+    goal_id = (data or {}).get("goal_id") if isinstance(data, dict) else None
+    if not goal_id:
+        return
+
+    def _pause():
+        from app.models.agent_goal import AgentGoal, GoalStatus
+
+        with SessionLocal() as s:
+            goal = s.get(AgentGoal, goal_id)
+            if goal is None or goal.agent_id != agent_id or goal.owner_id != player_id:
+                return "not_found"
+            if goal.status != GoalStatus.ACTIVE.value:
+                return "not_active"
+            goal.status = GoalStatus.PAUSED.value
+            s.commit()
+            return "ok"
+
+    try:
+        result = await asyncio.to_thread(_pause)
+        status = "paused" if result == "ok" else result
+        await sio.emit(S2C_GOAL_STATUS, {"goal_id": goal_id, "status": status}, to=sid, namespace=ROOM_NAMESPACE)
+        logger.info("[room/agent] goal paused agent=%s goal=%s result=%s", agent_id, goal_id, result)
+    except Exception:
+        logger.exception("[room/agent] pause_goal failed agent=%s", agent_id)
+
+
+@sio.on(C2S_RESUME_GOAL, namespace=ROOM_NAMESPACE)
+async def _on_resume_goal(sid, data):
+    agent_id, player_id = await _get_agent_session_data(sid)
+    if not agent_id or not player_id:
+        return
+
+    goal_id = (data or {}).get("goal_id") if isinstance(data, dict) else None
+    if not goal_id:
+        return
+
+    def _resume():
+        from app.models.agent_goal import AgentGoal, GoalStatus
+
+        with SessionLocal() as s:
+            goal = s.get(AgentGoal, goal_id)
+            if goal is None or goal.agent_id != agent_id or goal.owner_id != player_id:
+                return None
+            if goal.status != GoalStatus.PAUSED.value:
+                return None
+            goal.status = GoalStatus.ACTIVE.value
+            s.commit()
+            return goal_id
+
+    try:
+        resumed_id = await asyncio.to_thread(_resume)
+        if resumed_id:
+            await sio.emit(S2C_GOAL_STATUS, {"goal_id": goal_id, "status": "active"}, to=sid, namespace=ROOM_NAMESPACE)
+            logger.info("[room/agent] goal resumed agent=%s goal=%s", agent_id, goal_id)
+            from app.economy.goal_runner import run_goal_loop
+            asyncio.create_task(
+                run_goal_loop(goal_id),
+                name=f"goal-loop-{goal_id}",
+            )
+    except Exception:
+        logger.exception("[room/agent] resume_goal failed agent=%s", agent_id)
+
+
+@sio.on(C2S_STOP_GOAL, namespace=ROOM_NAMESPACE)
+async def _on_stop_goal(sid, data):
+    agent_id, player_id = await _get_agent_session_data(sid)
+    if not agent_id or not player_id:
+        return
+
+    goal_id = (data or {}).get("goal_id") if isinstance(data, dict) else None
+    if not goal_id:
+        return
+
+    def _stop():
+        from datetime import datetime as _dt
+        from app.models.agent_goal import AgentGoal, GoalStatus
+        from app.models.player_agent import PlayerAgent as _PA
+
+        with SessionLocal() as s:
+            goal = s.get(AgentGoal, goal_id)
+            if goal is None or goal.agent_id != agent_id or goal.owner_id != player_id:
+                return "not_found"
+            goal.status = GoalStatus.STOPPED.value
+            goal.completed_at = _dt.utcnow()
+            ag = s.get(_PA, agent_id)
+            if ag and ag.active_goal_id == goal_id:
+                ag.active_goal_id = None
+            s.commit()
+            return "ok"
+
+    try:
+        result = await asyncio.to_thread(_stop)
+        await sio.emit(S2C_GOAL_STATUS, {"goal_id": goal_id, "status": "stopped"}, to=sid, namespace=ROOM_NAMESPACE)
+        logger.info("[room/agent] goal stopped agent=%s goal=%s result=%s", agent_id, goal_id, result)
+    except Exception:
+        logger.exception("[room/agent] stop_goal failed agent=%s", agent_id)

app/web/templates/agent_room.html

@@ -98,6 +98,31 @@
         </div>
       </div>
 
+      {# Goal status panel — shown when an active/paused goal exists #}
+      <div id="goal-status-panel" class="hidden mb-3 p-3 border border-[var(--mp-brass-dim)] bg-[rgba(201,166,107,0.06)] rounded-sm">
+        <div class="flex items-center justify-between gap-2">
+          <div class="text-[12px] text-[var(--mp-ink-muted)]">
+            <span class="mp-mono text-[var(--mp-brass)]">Goal active</span>
+            <span id="goal-status-text" class="ml-2"></span>
+          </div>
+          <div class="flex gap-2">
+            <button id="goal-pause-btn" class="text-[11px] mp-mono text-[var(--mp-ink-muted)] hover:text-[var(--mp-ink)] border border-[var(--mp-hairline)] px-2 py-1 rounded-sm transition hidden">Pause</button>
+            <button id="goal-resume-btn" class="text-[11px] mp-mono text-[var(--mp-ink-muted)] hover:text-[var(--mp-ink)] border border-[var(--mp-hairline)] px-2 py-1 rounded-sm transition hidden">Resume</button>
+            <button id="goal-stop-btn" class="text-[11px] mp-mono text-[var(--mp-oxblood)] hover:text-[var(--mp-oxblood-bright)] border border-[var(--mp-oxblood)] px-2 py-1 rounded-sm transition">Stop</button>
+          </div>
+        </div>
+      </div>
+
+      {# Goal confirmation panel — shown after agent emits propose_goal #}
+      <div id="goal-confirm-panel" class="hidden mb-3 p-3 border border-[var(--mp-brass)] bg-[rgba(201,166,107,0.10)] rounded-sm">
+        <div class="mp-eyebrow mb-2 text-[11px]">{{ agent.name }} wants to run a goal</div>
+        <div id="goal-plan-summary" class="text-[12px] text-[var(--mp-ink-muted)] mb-3"></div>
+        <div class="flex gap-2">
+          <button id="goal-confirm-btn" class="mp-btn mp-btn-brass text-[12px]">Confirm</button>
+          <button id="goal-reject-btn" class="text-[12px] mp-mono text-[var(--mp-ink-muted)] hover:text-[var(--mp-oxblood)] transition">Reject</button>
+        </div>
+      </div>
+
       <div id="thinking-indicator" class="hidden text-[12px] text-[var(--mp-ink-faint)] mp-mono mb-2">
         <span class="mp-livedot"></span> {{ agent.name }} is thinking…
       </div>
@@ -133,11 +158,22 @@
   const rateLimitHint = document.getElementById('rate-limit-hint');
   const loadEarlierWrapper = document.getElementById('load-earlier-wrapper');
   const loadEarlierBtn = document.getElementById('load-earlier-btn');
+  const goalStatusPanel = document.getElementById('goal-status-panel');
+  const goalStatusText = document.getElementById('goal-status-text');
+  const goalPauseBtn = document.getElementById('goal-pause-btn');
+  const goalResumeBtn = document.getElementById('goal-resume-btn');
+  const goalStopBtn = document.getElementById('goal-stop-btn');
+  const goalConfirmPanel = document.getElementById('goal-confirm-panel');
+  const goalPlanSummary = document.getElementById('goal-plan-summary');
+  const goalConfirmBtn = document.getElementById('goal-confirm-btn');
+  const goalRejectBtn = document.getElementById('goal-reject-btn');
 
   let isThinking = false;
   let oldestTurnNumber = null;
   let hasEarlier = false;
   let isLoadingEarlier = false;
+  let activeGoalId = null;
+  let activeGoalStatus = null;
 
   // --- DOM helpers ----------------------------------------------------------
 
@@ -156,12 +192,87 @@
   function kindLabel(kind) {
     const labels = {
       match_report: '📊 match report',
+      match_intent: '🎯 upcoming match',
+      goal_complete: '🏁 goal complete',
       plan: '📋 plan',
       alert: '⚠ alert',
     };
     return labels[kind] || null;
   }
 
+  // --- Goal UI helpers -------------------------------------------------------
+
+  function showGoalConfirmPanel(goalId, plan) {
+    activeGoalId = goalId;
+    const stakeClayDisplay = (plan.max_stake_per_match_cents / 100).toFixed(0);
+    const lossClayDisplay = (plan.max_total_loss_cents / 100).toFixed(0);
+    const balanceDisplay = (plan.balance_cents / 100).toFixed(0);
+    let summary = `${plan.max_matches} matches vs Kenji — ${stakeClayDisplay} $CLAY starting stake — max loss ${lossClayDisplay} $CLAY`;
+    if (plan.target_profit_cents) {
+      summary += ` — target +${(plan.target_profit_cents / 100).toFixed(0)} $CLAY`;
+    }
+    goalPlanSummary.textContent = summary;
+    goalConfirmPanel.classList.remove('hidden');
+  }
+
+  function hideGoalConfirmPanel() {
+    goalConfirmPanel.classList.add('hidden');
+    goalPlanSummary.textContent = '';
+  }
+
+  function showGoalStatusPanel(goalId, status, matchesPlayed, maxMatches, totalProfitCents) {
+    activeGoalId = goalId;
+    activeGoalStatus = status;
+    const profit = totalProfitCents !== undefined ? `${totalProfitCents > 0 ? '+' : ''}${(totalProfitCents / 100).toFixed(0)} $CLAY` : '';
+    const progress = matchesPlayed !== undefined ? `${matchesPlayed}/${maxMatches} matches` : '';
+    goalStatusText.textContent = [progress, profit].filter(Boolean).join(' · ');
+    goalStatusPanel.classList.remove('hidden');
+    goalPauseBtn.classList.toggle('hidden', status !== 'active');
+    goalResumeBtn.classList.toggle('hidden', status !== 'paused');
+  }
+
+  function hideGoalStatusPanel() {
+    goalStatusPanel.classList.add('hidden');
+    activeGoalId = null;
+    activeGoalStatus = null;
+  }
+
+  // Goal panel button wiring.
+  if (goalConfirmBtn) {
+    goalConfirmBtn.addEventListener('click', function () {
+      if (!activeGoalId) return;
+      socket.emit('confirm_goal', { goal_id: activeGoalId });
+      hideGoalConfirmPanel();
+    });
+  }
+  if (goalRejectBtn) {
+    goalRejectBtn.addEventListener('click', function () {
+      if (!activeGoalId) return;
+      socket.emit('reject_goal', { goal_id: activeGoalId });
+      hideGoalConfirmPanel();
+      activeGoalId = null;
+    });
+  }
+  if (goalPauseBtn) {
+    goalPauseBtn.addEventListener('click', function () {
+      if (!activeGoalId) return;
+      socket.emit('pause_goal', { goal_id: activeGoalId });
+    });
+  }
+  if (goalResumeBtn) {
+    goalResumeBtn.addEventListener('click', function () {
+      if (!activeGoalId) return;
+      socket.emit('resume_goal', { goal_id: activeGoalId });
+    });
+  }
+  if (goalStopBtn) {
+    goalStopBtn.addEventListener('click', function () {
+      if (!activeGoalId) return;
+      if (!confirm('Stop the autonomous goal? This cannot be undone.')) return;
+      socket.emit('stop_goal', { goal_id: activeGoalId });
+    });
+  }
+
   function appendBubble(role, text, { kind = 'message', prepend = false, turnId = null } = {}) {
     hideEmptyHint();
     const isMatchReport = kind === 'match_report';
@@ -171,14 +282,23 @@
     const wrapper = document.createElement('div');
     wrapper.dataset.turnId = turnId || '';
 
-    if (isAgent && (isMatchReport || isOtherSpecial)) {
+    const isMatchIntent = kind === 'match_intent';
+    const isGoalComplete = kind === 'goal_complete';
+
+    if (isAgent && (isMatchReport || isOtherSpecial || isMatchIntent || isGoalComplete)) {
       wrapper.className = 'mr-auto max-w-[85%]';
       const label = document.createElement('div');
       label.className = 'chat-kind-label';
       label.textContent = kindLabel(kind) || kind;
       wrapper.appendChild(label);
       const bubble = document.createElement('div');
-      bubble.className = 'chat-bubble-match-report';
+      if (isGoalComplete) {
+        bubble.className = 'chat-bubble-match-report border-l-2 border-[var(--mp-brass)]';
+      } else if (isMatchIntent) {
+        bubble.className = 'p-3 text-[12px] text-[var(--mp-ink-muted)] border border-[var(--mp-hairline)] rounded-sm bg-[var(--mp-surface-2)]';
+      } else {
+        bubble.className = 'chat-bubble-match-report';
+      }
       bubble.textContent = text;
       wrapper.appendChild(bubble);
     } else {
@@ -340,6 +460,28 @@
     setTimeout(() => rateLimitHint.classList.add('hidden'), data.retry_after_ms || 2000);
   });
 
+  // --- Goal events -----------------------------------------------------------
+
+  socket.on('goal_proposed', function (data) {
+    showGoalConfirmPanel(data.goal_id, data.plan);
+  });
+
+  socket.on('goal_status', function (data) {
+    const { goal_id, status, matches_played, max_matches, total_profit_cents } = data;
+    if (status === 'active' || status === 'paused') {
+      showGoalStatusPanel(goal_id, status, matches_played, max_matches, total_profit_cents);
+    } else {
+      // completed, stopped, failed, etc.
+      hideGoalStatusPanel();
+      appendBubble('agent', `[ Goal ${status}. ]`, { kind: 'goal_complete' });
+    }
+  });
+
+  socket.on('goal_rejected', function (data) {
+    hideGoalConfirmPanel();
+    activeGoalId = null;
+  });
+
   // --- Send -----------------------------------------------------------------
 
   function sendMessage() {