Agentics flow for different planners

README.md

@@ -1,125 +1,118 @@
 ---
 title: Emotional Support Conversations (OpenEnv)
-emoji: 💬
+emoji: "💬"
 sdk: docker
 pinned: false
 tags:
   - openenv
 ---
 
-# Emotional Support Conversations — OpenEnv Environment
+# Emotional Support Conversations - OpenEnv Environment
 
-> An OpenEnv RL environment for evaluating agents on **open-ended emotional
-> support conversations**, with a hybrid immediate + future-oriented reward
-> signal inspired by **RLFF-ESC** (Yang, Chen, Wang, 2025,
+> An OpenEnv RL environment for evaluating agents on open-ended emotional
+> support conversations, with a hybrid immediate + future-oriented reward
+> signal inspired by RLFF-ESC (Yang, Chen, Wang, 2025,
 > [arXiv:2508.12935](https://arxiv.org/abs/2508.12935)).
 
 ## Why this environment
 
 Emotional support is one of the tasks humans most want AI assistants to do
-well — and one of the easiest to do badly. Existing dialogue benchmarks
-score turn-level responses in isolation, which rewards agents for *sounding*
-empathetic without ever testing whether their replies actually move the
-person toward resolution. This environment closes that gap.
+well, and one of the easiest to do badly. Existing dialogue benchmarks often
+score turn-level responses in isolation, which rewards agents for sounding
+empathetic without testing whether their replies actually move the person
+toward resolution. This environment closes that gap.
 
 Three properties make it a genuine RL problem, not a single-shot dialogue
 task:
 
-1. **Partial observability.** The seeker's distress, trust, and willingness
-   to reveal their real issue are hidden state. The agent must infer them
-   from the conversation so far.
-2. **Sequential credit assignment.** A warm reply at turn 2 can unlock a
-   disclosure at turn 6. A single dismissive reply at turn 4 can collapse
-   the whole trajectory and require several turns to recover.
-3. **Exploration vs commitment.** Should the agent keep exploring feelings
-   or move toward an action plan? Commit too early and the seeker shuts
-   down; explore too long and the episode times out.
+1. Partial observability. The seeker's distress, trust, and willingness to
+   reveal their real issue are hidden state. The agent must infer them from
+   the conversation so far.
+2. Sequential credit assignment. A warm reply at turn 2 can unlock a
+   disclosure at turn 6. A single dismissive reply at turn 4 can collapse the
+   whole trajectory and require several turns to recover.
+3. Exploration vs commitment. Should the agent keep exploring feelings or move
+   toward an action plan? Commit too early and the seeker shuts down; explore
+   too long and the episode times out.
 
 ## Reward design (RLFF-ESC-inspired)
 
 Each step reward is:
 
-```
-step_reward = clip( 0.45 · immediate  +  0.55 · future_oriented  −  penalties , 0, 1 )
+```text
+step_reward = clip(0.45 * immediate + 0.55 * future_oriented - penalties, 0, 1)
 ```
 
-- **`immediate`** — stage-appropriate empathy/validation/open-question fit,
-  plus turn-level deltas in the seeker's trust and distress.
-- **`future_oriented`** — a k-step oracle rollout from both the pre- and
+- `immediate`: stage-appropriate empathy/validation/open-question fit, plus
+  turn-level deltas in the seeker's trust and distress.
+- `future_oriented`: a k-step oracle rollout from both the pre- and
   post-action seeker states. The reward is proportional to how much the
-  agent's action *preserves or advances the attainable resolution ceiling*,
-  not just how good the current turn looks in isolation. This is the
-  RLFF-ESC idea: reward signals propagated from projected trajectories
-  rather than pointwise turn critique.
-- **`penalties`** — dismissive language, premature advice (before trust is
-  established), bare replies, interrogation, and repeated template-like
-  responses.
+  agent's action preserves or advances the attainable resolution ceiling, not
+  just how good the current turn looks in isolation.
+- `penalties`: dismissive language, premature advice, bare replies,
+  interrogation, and repeated template-like responses.
 
 A final task score combines average shaped reward, the seeker's final
-resolution state, efficiency (finishing within turn budget), and a
-completion bonus. Importantly, **success is hard-gated**: timing out with a
-generic but non-harmful conversation can still earn partial score, but it
-does **not** count as a solved episode.
+resolution state, efficiency, and a completion bonus. Success is hard-gated:
+timing out with a generic but non-harmful conversation can still earn partial
+score, but it does not count as a solved episode.
 
 ## Tasks (3 difficulties)
 
-| Task ID                  | Difficulty | Max turns | Core challenge                                                               |
-| ------------------------ | ---------- | --------- | ---------------------------------------------------------------------------- |
-| `work_stress_venting`    | easy       | 10        | Cooperative seeker venting about work. Must reach closing with trust ≥ 0.70 and distress ≤ 0.40. |
-| `guarded_relationship`   | medium     | 12        | Guarded seeker; real issue hidden behind surface concern until openness ≥ 0.75. Must reveal the true issue and finish in closing with trust ≥ 0.72 and distress ≤ 0.45. |
-| `crisis_fragile_trust`   | hard       | 14        | High-distress, fragile trust, multiple interleaved concerns. Must reveal the crisis concern, reference external safety support, and finish in closing with trust ≥ 0.75 and distress ≤ 0.40. |
+| Task ID | Difficulty | Max turns | Core challenge |
+| --- | --- | ---: | --- |
+| `work_stress_venting` | easy | 10 | Cooperative seeker venting about work. Must reach closing with trust >= 0.70 and distress <= 0.40. |
+| `guarded_relationship` | medium | 12 | Guarded seeker; real issue is hidden behind the surface concern until openness >= 0.75. Must reveal the true issue and finish in closing with trust >= 0.72 and distress <= 0.45. |
+| `crisis_fragile_trust` | hard | 14 | High-distress, fragile trust, multiple interleaved concerns. Must reveal the crisis concern, reference external safety support, and finish in closing with trust >= 0.75 and distress <= 0.40. |
 
-Success thresholds (final score) are `0.60 / 0.62 / 0.65` respectively.
-These thresholds are only evaluated after the task-specific completion
-conditions are met.
+Success thresholds (final score) are `0.60 / 0.62 / 0.65` respectively, and
+they are only evaluated after the task-specific completion conditions are met.
 
-## Action & observation space
+## Action and observation space
 
-**Action** — free-text reply to the seeker:
+Action is a free-text reply to the seeker:
 
 ```python
 class Action(BaseModel):
     message: str
 ```
 
-**Observation** — what the agent sees each turn (deliberately partial):
+Observation is deliberately partial:
 
 ```python
 class Observation(BaseModel):
     seeker_utterance: str
     turn: int
     remaining_turns: int
-    stage_hint: str        # 'opening' | 'exploring' | 'reflecting' | 'planning' | 'closing'
+    stage_hint: str
     task_id: str
     scenario_brief: str
 ```
 
-The seeker's internal hidden variables (distress, trust, openness, true
-issue) are **never** exposed. This is by design.
+The seeker's internal hidden variables are never exposed.
 
-## Environment internals (why deterministic)
+## Environment internals
 
 The seeker is a deterministic finite-state machine with continuous hidden
 variables (`distress`, `trust`, `openness`, `revealed`, `stage`). On each
-turn, the agent's reply is analysed with keyword/regex feature detectors
-(empathy markers, validation, open vs closed questions, advice, dismissive
-language, interrogation) and hidden state advances via transparent rules.
+turn, the agent's reply is analyzed with keyword and regex feature detectors,
+then hidden state advances via transparent rules.
 
-**Why not use an LLM-driven seeker?** The hackathon rubric requires
-graders to be *deterministic and reproducible* — an LLM-driven seeker
-would fail the Phase 2 score-variance check. Deterministic dynamics give
-us full reproducibility while still producing rich, sequential, partially
-observable dialogue with genuine recovery-from-mistakes dynamics.
+Why not use an LLM-driven seeker? The hackathon rubric requires graders to be
+deterministic and reproducible. An LLM-driven seeker would risk score variance
+between runs. Deterministic dynamics give full reproducibility while still
+producing rich, sequential, partially observable dialogue with genuine
+recovery-from-mistakes dynamics.
 
 ## HTTP API (OpenEnv spec)
 
-| Method | Path      | Body                                         | Returns                                 |
-| ------ | --------- | -------------------------------------------- | --------------------------------------- |
-| GET    | `/`       | —                                            | health + metadata                       |
-| GET    | `/tasks`  | —                                            | list of tasks                           |
-| POST   | `/reset`  | `{"task_id": "...", "seed": null}` (opt.)    | `ResetResult` (observation + info)      |
-| POST   | `/step`   | `{"action": {"message": "..."}}`             | `StepResult` (obs, reward, done, info)  |
-| GET    | `/state`  | —                                            | `EnvState` (public state + transcript)  |
+| Method | Path | Body | Returns |
+| --- | --- | --- | --- |
+| `GET` | `/` | none | health + metadata |
+| `GET` | `/tasks` | none | list of tasks |
+| `POST` | `/reset` | `{"task_id": "...", "seed": null}` | `ResetResult` |
+| `POST` | `/step` | `{"action": {"message": "..."}}` | `StepResult` |
+| `GET` | `/state` | none | `EnvState` |
 
 ## Running locally
 
@@ -145,11 +138,24 @@ docker build -t esc-openenv .
 docker run -p 7860:7860 esc-openenv
 ```
 
+## Skills / agents extension
+
+The environment itself stays deterministic and reproducible. To align with the
+hackathon's optional skills/agents framing, this repo also includes a
+policy-side agentic controller that routes between five reusable skills:
+`empathize`, `validate`, `explore`, `plan`, and `safety_escalate`.
+
+This keeps the benchmark honest:
+
+- the environment and grader remain unchanged
+- the agentic story lives in the policy, not in a hidden stochastic seeker
+- judges can inspect turn-by-turn routing traces in the benchmark outputs
+
 ## Benchmarking
 
 ### Deterministic local benchmark ladder
 
-Run the built-in baseline ladder and write reusable Markdown/JSON artifacts:
+Run the built-in rubric ladder and write reusable Markdown/JSON artifacts:
 
 ```bash
 py -3 benchmark.py
@@ -160,6 +166,19 @@ Outputs:
 - `results/local_benchmarks.md`
 - `results/local_benchmarks.json`
 
+### Deterministic skill-routed benchmark
+
+Run the explicit agentic baseline comparison and write route-aware artifacts:
+
+```bash
+py -3 benchmark_agentic.py
+```
+
+Outputs:
+
+- `results/agentic_benchmarks.md`
+- `results/agentic_benchmarks.json`
+
 ### LLM benchmark with Markdown output
 
 When you have a real model endpoint and token, run:
@@ -177,53 +196,93 @@ Outputs:
 - `results/llm_benchmark.md`
 - `results/llm_benchmark.json`
 
+### Skill-routed LLM benchmark
+
+Use the same environment endpoint, but add the policy-side router and skill
+traces around the model:
+
+```bash
+export API_BASE_URL=https://router.huggingface.co/v1
+export MODEL_NAME=Qwen/Qwen2.5-72B-Instruct
+export HF_TOKEN=<your-hf-token>
+export ESC_ENV_URL=http://localhost:7860
+py -3 benchmark_agentic_llm.py
+```
+
+Outputs:
+
+- `results/agentic_llm_benchmark.md`
+- `results/agentic_llm_benchmark.json`
+
 ## Baseline scores
 
 Deterministic local numbers below were generated with `py -3 benchmark.py`.
-Add a real model row after running `benchmark_llm.py`.
+Add real model rows after running `benchmark_llm.py` and
+`benchmark_agentic_llm.py`.
 
 ### Deterministic baselines
 
-| Baseline                | Avg score | Success rate | Notes |
-| ----------------------- | --------: | -----------: | ----- |
-| `generic_template`      | 0.393     | 0.00         | Safe-sounding repeated empathy; no task completion |
-| `validation_only`       | 0.539     | 0.00         | Better partial reward, still fails hard-gated completion |
-| `stage_aware_heuristic` | 0.821     | 1.00         | Task-aware staged policy; completes all 3 tasks |
+| Baseline | Avg score | Success rate | Notes |
+| --- | ---: | ---: | --- |
+| `generic_template` | 0.393 | 0.00 | Safe-sounding repeated empathy; no task completion |
+| `validation_only` | 0.539 | 0.00 | Better partial reward, still fails hard-gated completion |
+| `stage_aware_heuristic` | 0.821 | 1.00 | Task-aware staged policy; completes all 3 tasks |
+
+### Skill-routed agentic baselines
+
+| Baseline | Avg score | Success rate | Notes |
+| --- | ---: | ---: | --- |
+| `skill_routed_deterministic` | 0.821 | 1.00 | Explicit router over `empathize` / `validate` / `explore` / `plan` / `safety_escalate`; matches the strong staged baseline while exposing route traces |
 
 ### Real LLM baseline
 
-| Model                   | Avg score | Success rate | Report |
-| ----------------------- | --------: | -----------: | ------ |
+| Model | Avg score | Success rate | Report |
+| --- | ---: | ---: | --- |
 | `Qwen/Qwen2.5-72B-Instruct` (or chosen final model) | TBD | TBD | Run `py -3 benchmark_llm.py` |
 
+### Skill-routed real LLM baseline
+
+| Model | Avg score | Success rate | Report |
+| --- | ---: | ---: | --- |
+| `Qwen/Qwen2.5-72B-Instruct` (or chosen final model) + router | TBD | TBD | Run `py -3 benchmark_agentic_llm.py` |
+
+## Benchmark narrative
+
+- The generic repeated-empathy template now fails completely under the hardened rubric.
+- The deterministic skill-routed policy matches the strong staged heuristic at `0.821` average score and `1.00` success rate, while making turn-level skill choices visible.
+- The hard task is only successful when the trajectory reaches a safety-aware finish, so sounding supportive without escalation is not enough.
+
 ## Files
 
-```
+```text
 .
-├── openenv.yaml             # OpenEnv metadata
-├── Dockerfile               # Container build for HF Space
-├── benchmark.py             # Deterministic local benchmark ladder
-├── benchmark_llm.py         # LLM benchmark that writes Markdown/JSON
-├── requirements.txt
-├── server.py                # FastAPI HTTP server (entrypoint)
-├── inference.py             # Mandated baseline inference script
-├── SUBMISSION_NEXT_STEPS.md # Manual checklist before final submission
-├── README.md
-└── src/
-    ├── __init__.py
-    ├── baselines.py         # Deterministic baseline policies
-    ├── models.py            # Pydantic Action / Observation / Reward / envelopes
-    ├── seeker.py            # Deterministic seeker simulator + feature detectors
-    ├── tasks.py             # 3 task personas (easy / medium / hard)
-    ├── grader.py            # Hybrid immediate + future-oriented reward
-    ├── env.py               # Core ESCEnv with step/reset/state
-    └── client.py            # Async HTTP client for inference.py
+|-- openenv.yaml             # OpenEnv metadata
+|-- Dockerfile               # Container build for HF Space
+|-- benchmark.py             # Deterministic local benchmark ladder
+|-- benchmark_agentic.py     # Deterministic skill-routed benchmark
+|-- benchmark_agentic_llm.py # Skill-routed LLM benchmark
+|-- benchmark_llm.py         # LLM benchmark that writes Markdown/JSON
+|-- requirements.txt
+|-- server.py                # FastAPI HTTP server (entrypoint)
+|-- inference.py             # Mandated baseline inference script
+|-- SUBMISSION_NEXT_STEPS.md # Manual checklist before final submission
+|-- README.md
+`-- src/
+    |-- __init__.py
+    |-- agentic.py           # Skill router + reusable policy-side skills
+    |-- baselines.py         # Deterministic baseline policies
+    |-- models.py            # Pydantic Action / Observation / Reward / envelopes
+    |-- seeker.py            # Deterministic seeker simulator + feature detectors
+    |-- tasks.py             # 3 task personas (easy / medium / hard)
+    |-- grader.py            # Hybrid immediate + future-oriented reward
+    |-- env.py               # Core ESCEnv with step/reset/state
+    `-- client.py            # Async HTTP client for inference.py
 ```
 
 ## Citation
 
-If you use this environment, please cite the paper whose reward idea
-inspired it:
+If you use this environment, please cite the paper whose reward idea inspired
+it:
 
 ```bibtex
 @article{yang2025rlffesc,

SUBMISSION_NEXT_STEPS.md

@@ -1,12 +1,12 @@
 # Submission Next Steps
 
-This file is the short operational checklist for turning the current repo into
-a polished hackathon submission.
+This is the short operational checklist for turning the current repo into a
+polished hackathon submission.
 
-## 1. Run the local benchmark ladder
+## 1. Run the core deterministic benchmark ladder
 
-This gives you deterministic numbers for the baseline section and proves the
-rubric separates weak generic empathy from staged, task-aware behavior.
+This proves the rubric separates weak generic empathy from staged,
+task-aware behavior.
 
 ```powershell
 py -3 benchmark.py
@@ -17,12 +17,25 @@ Artifacts written:
 - `results/local_benchmarks.md`
 - `results/local_benchmarks.json`
 
-After running:
+## 2. Run the deterministic skills/agents benchmark
 
-- copy the summary table from `results/local_benchmarks.md`
-- paste the final baseline numbers into [README.md](C:\Users\Gokul nandan T M\Desktop\personalprojects\meta\meta-hackathon\README.md)
+This gives you the policy-side agentic story without changing the environment.
 
-## 2. Run the mandatory hackathon stdout-contract baseline
+```powershell
+py -3 benchmark_agentic.py
+```
+
+Artifacts written:
+
+- `results/agentic_benchmarks.md`
+- `results/agentic_benchmarks.json`
+
+After running steps 1 and 2:
+
+- copy the summary numbers into [README.md](C:\Users\Gokul nandan T M\Desktop\personalprojects\meta\meta-hackathon\README.md)
+- keep both the rubric ladder and the skill-routed results in the final submission
+
+## 3. Run the mandatory hackathon stdout-contract baseline
 
 This is the script the submission already exposes.
 
@@ -36,7 +49,7 @@ py -3 inference.py
 
 Use this when you want the strict `[START] / [STEP] / [END]` output format.
 
-## 3. Run the Markdown-writing LLM benchmark
+## 4. Run the Markdown-writing LLM benchmark
 
 Use this when you want a reusable results file for the README or final report.
 
@@ -53,29 +66,54 @@ Artifacts written:
 - `results/llm_benchmark.md`
 - `results/llm_benchmark.json`
 
-## 4. Replace the `TBD` results table in the README
+## 5. Run the skill-routed LLM benchmark
+
+Use this when you want an explicit skills/agents baseline with route traces.
+You can use a local OpenAI-compatible endpoint here during development.
+
+```powershell
+$env:API_BASE_URL="http://localhost:11434/v1"
+$env:MODEL_NAME="qwen2.5:7b-instruct"
+$env:API_KEY="ollama"
+$env:ESC_ENV_URL="http://localhost:7860"
+py -3 benchmark_agentic_llm.py
+```
+
+For the final Hugging Face run, swap in your deployment endpoint and token.
+
+Artifacts written:
+
+- `results/agentic_llm_benchmark.md`
+- `results/agentic_llm_benchmark.json`
+
+## 6. Replace the `TBD` rows in the README
 
 Update the `Baseline scores` section in [README.md](C:\Users\Gokul nandan T M\Desktop\personalprojects\meta\meta-hackathon\README.md) with:
 
 - deterministic local baselines from `benchmark.py`
+- deterministic skill-routed baseline from `benchmark_agentic.py`
 - one real LLM baseline from `benchmark_llm.py`
+- one real or local skill-routed LLM baseline from `benchmark_agentic_llm.py`
 
-Recommended final table:
+Recommended final ladder:
 
 - `generic_template`
 - `validation_only`
 - `stage_aware_heuristic`
+- `skill_routed_deterministic`
 - one real LLM baseline
+- one skill-routed LLM baseline
 
-## 5. Add one short benchmark narrative to the README
+## 7. Add one short benchmark narrative to the README
 
 Keep it brief. Include:
 
 - the generic repeated empathy template no longer succeeds
 - the stage-aware heuristic completes all tasks
-- the crisis task requires an explicit safety-aware finish
+- the skill-routed policy keeps similar performance while exposing turn-level routing decisions
+- the hard task requires an explicit safety-aware finish
 
-## 6. Smoke-test the deployable artifact
+## 8. Smoke-test the deployable artifact
 
 Before submitting, verify both local and containerized runs.
 
@@ -92,20 +130,21 @@ Then hit:
 - `POST /step`
 - `GET /state`
 
-## 7. Optional but high-value polish
+## 9. Optional but high-value polish
 
 If you still have time, these are the best improvements:
 
 - add one screenshot or short GIF of a successful hard-task trajectory
 - add a tiny `Why this benchmark is hard` section to the README
-- add one extra adversarial baseline later, only if the current docs/results are already polished
+- add one short ablation note comparing plain LLM vs skill-routed LLM
 
-## 8. Final pre-submit check
+## 10. Final pre-submit check
 
 Make sure these are true:
 
 - local benchmark artifacts exist in `results/`
-- one LLM benchmark artifact exists in `results/`
+- agentic benchmark artifacts exist in `results/`
+- at least one LLM benchmark artifact exists in `results/`
 - README contains real numbers, not `TBD`
 - Docker build works
 - the hard task is only successful when safety support is referenced

benchmark_agentic.py

@@ -0,0 +1,262 @@
+"""Run local benchmarks for the explicit skill-routed agentic policies.
+
+This script keeps the environment unchanged and benchmarks policy-side agentic
+extensions on top of it. The main goal is to show that a small skill router can
+compose reusable conversational skills while still solving the benchmark.
+
+Example:
+    py -3 benchmark_agentic.py
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from statistics import mean
+from typing import Any, Dict, List
+
+from src.agentic import SkillRoutedDeterministicPolicy
+from src.baselines import StageAwareHeuristicBaseline
+from src.env import ESCEnv
+from src.models import Action
+from src.tasks import TASKS
+
+
+@dataclass
+class AgenticEpisodeSummary:
+    policy: str
+    task_id: str
+    difficulty: str
+    steps: int
+    score: float
+    success: bool
+    completion: float
+    avg_step_reward: float
+    final_resolution: float
+    had_safety_reference: bool
+    skill_counts: Dict[str, int] = field(default_factory=dict)
+    skill_trace: List[str] = field(default_factory=list)
+    transcript_excerpt: List[str] = field(default_factory=list)
+
+
+def _extract_skill_trace(policy: Any) -> tuple[Dict[str, int], List[str]]:
+    if not hasattr(policy, "decision_log") or not hasattr(policy, "memory"):
+        return {}, []
+
+    counts = dict(getattr(policy.memory, "skill_counts", {}))
+    trace: List[str] = []
+    for entry in getattr(policy, "decision_log", [])[:6]:
+        turn = int(entry.get("turn", "0")) + 1
+        trace.append(
+            f"Turn {turn} [{entry.get('stage', '')}] -> {entry.get('skill', '')}: {entry.get('reason', '')}"
+        )
+    return counts, trace
+
+
+def run_episode(env: ESCEnv, policy: Any, task_id: str) -> AgenticEpisodeSummary:
+    task = TASKS[task_id]
+    policy.reset(task_id)
+    reset = env.reset(task_id=task_id)
+    obs = reset.observation
+
+    rewards: List[float] = []
+    transcript_excerpt: List[str] = [f"Seeker: {obs.seeker_utterance}"]
+    last_result = None
+
+    while True:
+        message = policy.act(obs)
+        transcript_excerpt.append(f"Agent: {message}")
+        result = env.step(Action(message=message))
+        last_result = result
+
+        rewards.append(float(result.reward))
+        obs = result.observation
+        transcript_excerpt.append(f"Seeker: {obs.seeker_utterance}")
+
+        if result.done:
+            break
+
+    assert last_result is not None
+    final = last_result.info.get("final", {})
+    skill_counts, skill_trace = _extract_skill_trace(policy)
+
+    return AgenticEpisodeSummary(
+        policy=policy.name,
+        task_id=task_id,
+        difficulty=task.difficulty,
+        steps=obs.turn,
+        score=float(final.get("score", 0.0)),
+        success=bool(final.get("success", 0.0) >= 1.0),
+        completion=float(final.get("completion", 0.0)),
+        avg_step_reward=mean(rewards) if rewards else 0.0,
+        final_resolution=float(final.get("final_resolution", 0.0)),
+        had_safety_reference=bool(last_result.info.get("had_safety_reference", False)),
+        skill_counts=skill_counts,
+        skill_trace=skill_trace,
+        transcript_excerpt=transcript_excerpt[:10],
+    )
+
+
+def summarize_by_policy(episodes: List[AgenticEpisodeSummary]) -> List[Dict[str, Any]]:
+    by_name: Dict[str, List[AgenticEpisodeSummary]] = {}
+    for episode in episodes:
+        by_name.setdefault(episode.policy, []).append(episode)
+
+    rows: List[Dict[str, Any]] = []
+    for policy, group in by_name.items():
+        rows.append(
+            {
+                "policy": policy,
+                "avg_score": mean(ep.score for ep in group),
+                "success_rate": mean(1.0 if ep.success else 0.0 for ep in group),
+                "avg_steps": mean(ep.steps for ep in group),
+                "avg_completion": mean(ep.completion for ep in group),
+                "avg_resolution": mean(ep.final_resolution for ep in group),
+            }
+        )
+    rows.sort(key=lambda row: row["avg_score"], reverse=True)
+    return rows
+
+
+def aggregate_skill_counts(episodes: List[AgenticEpisodeSummary], policy_name: str) -> Dict[str, int]:
+    totals: Dict[str, int] = {}
+    for episode in episodes:
+        if episode.policy != policy_name:
+            continue
+        for skill_name, count in episode.skill_counts.items():
+            totals[skill_name] = totals.get(skill_name, 0) + count
+    return dict(sorted(totals.items(), key=lambda item: (-item[1], item[0])))
+
+
+def render_markdown(episodes: List[AgenticEpisodeSummary], generated_at: str) -> str:
+    summary_rows = summarize_by_policy(episodes)
+    skill_totals = aggregate_skill_counts(episodes, "skill_routed_deterministic")
+    reference_row = next((row for row in summary_rows if row["policy"] == "stage_aware_heuristic"), None)
+    agentic_row = next((row for row in summary_rows if row["policy"] == "skill_routed_deterministic"), None)
+
+    lines: List[str] = []
+    lines.append("# Agentic Benchmark Results")
+    lines.append("")
+    lines.append(f"_Generated: {generated_at}_")
+    lines.append("")
+    lines.append("This report isolates the policy-side skills/agents story. The environment and rubric are unchanged.")
+    lines.append("")
+    lines.append("## Summary")
+    lines.append("")
+    lines.append("| Policy | Avg score | Success rate | Avg steps | Completion | Final resolution |")
+    lines.append("| --- | ---: | ---: | ---: | ---: | ---: |")
+    for row in summary_rows:
+        lines.append(
+            "| "
+            f"{row['policy']} | "
+            f"{row['avg_score']:.3f} | "
+            f"{row['success_rate']:.2f} | "
+            f"{row['avg_steps']:.2f} | "
+            f"{row['avg_completion']:.2f} | "
+            f"{row['avg_resolution']:.3f} |"
+        )
+    lines.append("")
+    lines.append("## Takeaways")
+    lines.append("")
+    if reference_row is not None and agentic_row is not None:
+        delta = agentic_row["avg_score"] - reference_row["avg_score"]
+        lines.append(
+            f"- The explicit skill-routed policy scored `{agentic_row['avg_score']:.3f}`, "
+            f"for a delta of `{delta:+.3f}` versus the non-agentic staged heuristic."
+        )
+    lines.append("- The skill-routed policy keeps the benchmark deterministic while making the policy decomposition visible to judges.")
+    lines.append("- Safety escalation remains a policy-side decision; the hard task still requires the environment-level safety-aware finish.")
+    lines.append("")
+    lines.append("## Skill Usage Totals")
+    lines.append("")
+    lines.append("| Skill | Total turns |")
+    lines.append("| --- | ---: |")
+    for skill_name, count in skill_totals.items():
+        lines.append(f"| {skill_name} | {count} |")
+    lines.append("")
+    lines.append("## Per-Task Results")
+    lines.append("")
+    lines.append("| Task | Difficulty | Policy | Score | Success | Completion | Steps | Safety ref |")
+    lines.append("| --- | --- | --- | ---: | ---: | ---: | ---: | ---: |")
+    for episode in sorted(episodes, key=lambda item: (item.task_id, item.policy)):
+        lines.append(
+            "| "
+            f"{episode.task_id} | "
+            f"{episode.difficulty} | "
+            f"{episode.policy} | "
+            f"{episode.score:.3f} | "
+            f"{int(episode.success)} | "
+            f"{episode.completion:.1f} | "
+            f"{episode.steps} | "
+            f"{int(episode.had_safety_reference)} |"
+        )
+    lines.append("")
+    lines.append("## Skill Trace Excerpts")
+    lines.append("")
+    for episode in episodes:
+        if not episode.skill_trace:
+            continue
+        lines.append(f"### {episode.task_id} - {episode.policy}")
+        lines.append("")
+        lines.append(
+            f"- Score: `{episode.score:.3f}` | Success: `{episode.success}` | "
+            f"Completion: `{episode.completion:.1f}`"
+        )
+        for trace in episode.skill_trace:
+            lines.append(f"- {trace}")
+        lines.append("")
+    lines.append("## Transcript Excerpts")
+    lines.append("")
+    for episode in episodes:
+        lines.append(f"### {episode.task_id} - {episode.policy}")
+        lines.append("")
+        for line in episode.transcript_excerpt:
+            lines.append(f"- {line}")
+        lines.append("")
+
+    return "\n".join(lines).strip() + "\n"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run the agentic local benchmark suite.")
+    parser.add_argument(
+        "--output",
+        default="results/agentic_benchmarks.md",
+        help="Markdown output path.",
+    )
+    parser.add_argument(
+        "--json-output",
+        default="results/agentic_benchmarks.json",
+        help="JSON output path.",
+    )
+    args = parser.parse_args()
+
+    env = ESCEnv()
+    policies = [
+        StageAwareHeuristicBaseline(),
+        SkillRoutedDeterministicPolicy(),
+    ]
+
+    episodes: List[AgenticEpisodeSummary] = []
+    for policy in policies:
+        for task_id in TASKS:
+            episodes.append(run_episode(env, policy, task_id))
+
+    generated_at = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%SZ")
+    markdown = render_markdown(episodes, generated_at=generated_at)
+
+    md_path = Path(args.output)
+    json_path = Path(args.json_output)
+    md_path.parent.mkdir(parents=True, exist_ok=True)
+    json_path.parent.mkdir(parents=True, exist_ok=True)
+    md_path.write_text(markdown, encoding="utf-8")
+    json_path.write_text(json.dumps([asdict(ep) for ep in episodes], indent=2), encoding="utf-8")
+
+    print(f"Wrote Markdown report to {md_path}")
+    print(f"Wrote JSON report to {json_path}")
+
+
+if __name__ == "__main__":
+    main()

benchmark_agentic_llm.py

@@ -0,0 +1,356 @@
+"""Run a skill-routed LLM agent against the ESC environment.
+
+This script shares the same deterministic skill router as `benchmark_agentic.py`
+but lets an LLM realize each selected skill turn by turn. It writes Markdown and
+JSON artifacts so the submission can show an agentic baseline with explicit
+routing traces.
+
+Required environment variables:
+    API_BASE_URL
+    MODEL_NAME
+    HF_TOKEN or API_KEY
+    ESC_ENV_URL
+
+Example:
+    $env:API_BASE_URL="http://localhost:11434/v1"
+    $env:MODEL_NAME="qwen2.5:7b-instruct"
+    $env:API_KEY="ollama"
+    $env:ESC_ENV_URL="http://localhost:7860"
+    py -3 benchmark_agentic_llm.py
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import textwrap
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from statistics import mean
+from typing import Any, Dict, List
+
+from openai import OpenAI
+
+from src.agentic import AgentMemory, SkillRouter, build_default_skills
+from src.client import ESCHttpClient
+from src.models import Action, Observation
+
+TASK_IDS = ["work_stress_venting", "guarded_relationship", "crisis_fragile_trust"]
+TEMPERATURE = 0.5
+MAX_TOKENS = 220
+
+SYSTEM_PROMPT = textwrap.dedent(
+    """
+    You are the response generator inside a skill-routed emotional-support agent.
+
+    A controller will choose one conversational skill for each turn. Follow that
+    selected skill closely while still sounding natural and human.
+
+    Global rules:
+    - Keep replies warm, brief, and conversational (1-3 sentences).
+    - Ask at most one question.
+    - Do not mention the router, skill names, or any internal policy logic.
+    - Do not give advice before trust is built.
+    - In crisis scenarios, keep the tone calm and supportive rather than alarmist.
+
+    Reply with ONLY the next message to the seeker.
+    """
+).strip()
+
+
+@dataclass
+class AgenticLLMEpisodeSummary:
+    task_id: str
+    model: str
+    endpoint_type: str
+    steps: int
+    score: float
+    success: bool
+    completion: float
+    avg_step_reward: float
+    avg_immediate: float
+    avg_future_oriented: float
+    avg_penalties: float
+    final_resolution: float
+    had_safety_reference: bool
+    skill_counts: Dict[str, int] = field(default_factory=dict)
+    skill_trace: List[str] = field(default_factory=list)
+    transcript: List[str] = field(default_factory=list)
+
+
+def classify_endpoint(api_base_url: str) -> str:
+    lowered = api_base_url.lower()
+    if "localhost" in lowered or "127.0.0.1" in lowered:
+        return "local"
+    if "huggingface" in lowered:
+        return "huggingface"
+    return "remote"
+
+
+def build_user_prompt(
+    observation: Observation,
+    history: List[str],
+    skill_name: str,
+    skill_instruction: str,
+    rationale: str,
+) -> str:
+    history_block = "\n".join(history[-8:]) if history else "(first turn)"
+    return textwrap.dedent(
+        f"""
+        Selected skill: {skill_name}
+        Why this skill was selected: {rationale}
+        Skill directive: {skill_instruction}
+
+        Scenario: {observation.scenario_brief}
+        Public stage hint: {observation.stage_hint}
+        Turn: {observation.turn}
+        Remaining turns: {observation.remaining_turns}
+
+        Recent exchange:
+        {history_block}
+
+        Seeker just said:
+        "{observation.seeker_utterance}"
+
+        Write the next reply now.
+        """
+    ).strip()
+
+
+def call_llm(client: OpenAI, model_name: str, user_prompt: str) -> str:
+    completion = client.chat.completions.create(
+        model=model_name,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_prompt},
+        ],
+        temperature=TEMPERATURE,
+        max_tokens=MAX_TOKENS,
+        stream=False,
+    )
+    text = (completion.choices[0].message.content or "").strip()
+    if not text:
+        return "That sounds really heavy, and I'm here with you. What feels most important to say right now?"
+    return text
+
+
+def require_env(name: str) -> str:
+    value = os.getenv(name)
+    if not value:
+        raise SystemExit(
+            f"Missing required environment variable: {name}\n"
+            f"Set it, then rerun `py -3 benchmark_agentic_llm.py`."
+        )
+    return value
+
+
+async def run_task(
+    openai_client: OpenAI,
+    env_client: ESCHttpClient,
+    model_name: str,
+    endpoint_type: str,
+    task_id: str,
+) -> AgenticLLMEpisodeSummary:
+    router = SkillRouter()
+    skills = build_default_skills()
+    memory = AgentMemory()
+    memory.reset(task_id)
+
+    reset = await env_client.reset(task_id=task_id)
+    obs = reset.observation
+    history: List[str] = [f"Seeker: {obs.seeker_utterance}"]
+    rewards: List[float] = []
+    immediate_scores: List[float] = []
+    future_scores: List[float] = []
+    penalties: List[float] = []
+    transcript: List[str] = [f"Seeker: {obs.seeker_utterance}"]
+    skill_trace: List[str] = []
+    final: Dict[str, Any] = {}
+    last_result = None
+
+    while True:
+        memory.observe(obs)
+        decision = router.choose(obs, memory)
+        skill = skills[decision.skill_name]
+        prompt = build_user_prompt(
+            observation=obs,
+            history=history,
+            skill_name=decision.skill_name,
+            skill_instruction=skill.llm_instruction(obs, memory, decision),
+            rationale=decision.rationale,
+        )
+        message = call_llm(openai_client, model_name, prompt)
+        memory.remember(decision.skill_name, message)
+        skill_trace.append(
+            f"Turn {obs.turn + 1} [{obs.stage_hint}] -> {decision.skill_name}: {decision.rationale}"
+        )
+
+        result = await env_client.step(Action(message=message))
+        last_result = result
+
+        rewards.append(float(result.reward))
+        reward_detail = result.reward_detail or {}
+        immediate_scores.append(float(reward_detail.get("immediate", 0.0)))
+        future_scores.append(float(reward_detail.get("future_oriented", 0.0)))
+        penalties.append(float(reward_detail.get("penalties", 0.0)))
+
+        transcript.append(f"Agent: {message}")
+        transcript.append(f"Seeker: {result.observation.seeker_utterance}")
+        history.extend(transcript[-2:])
+
+        obs = result.observation
+        if result.done:
+            final = result.info.get("final", {})
+            break
+
+    assert last_result is not None
+    return AgenticLLMEpisodeSummary(
+        task_id=task_id,
+        model=model_name,
+        endpoint_type=endpoint_type,
+        steps=obs.turn,
+        score=float(final.get("score", 0.0)),
+        success=bool(final.get("success", 0.0) >= 1.0),
+        completion=float(final.get("completion", 0.0)),
+        avg_step_reward=mean(rewards) if rewards else 0.0,
+        avg_immediate=mean(immediate_scores) if immediate_scores else 0.0,
+        avg_future_oriented=mean(future_scores) if future_scores else 0.0,
+        avg_penalties=mean(penalties) if penalties else 0.0,
+        final_resolution=float(final.get("final_resolution", 0.0)),
+        had_safety_reference=bool(last_result.info.get("had_safety_reference", False)),
+        skill_counts=dict(memory.skill_counts),
+        skill_trace=skill_trace,
+        transcript=transcript,
+    )
+
+
+def render_markdown(
+    episodes: List[AgenticLLMEpisodeSummary],
+    generated_at: str,
+    env_url: str,
+) -> str:
+    avg_score = mean(ep.score for ep in episodes) if episodes else 0.0
+    avg_success = mean(1.0 if ep.success else 0.0 for ep in episodes) if episodes else 0.0
+    model_name = episodes[0].model if episodes else "unknown"
+    endpoint_type = episodes[0].endpoint_type if episodes else "unknown"
+
+    skill_totals: Dict[str, int] = {}
+    for episode in episodes:
+        for skill_name, count in episode.skill_counts.items():
+            skill_totals[skill_name] = skill_totals.get(skill_name, 0) + count
+
+    lines: List[str] = []
+    lines.append("# Agentic LLM Benchmark Results")
+    lines.append("")
+    lines.append(f"_Generated: {generated_at}_")
+    lines.append("")
+    lines.append(f"- Model: `{model_name}`")
+    lines.append(f"- Endpoint type: `{endpoint_type}`")
+    lines.append(f"- Environment URL: `{env_url}`")
+    lines.append(f"- Average score: `{avg_score:.3f}`")
+    lines.append(f"- Success rate: `{avg_success:.2f}`")
+    lines.append("")
+    lines.append("## Per-Task Results")
+    lines.append("")
+    lines.append("| Task | Score | Success | Completion | Steps | Avg reward | Final resolution | Safety ref |")
+    lines.append("| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |")
+    for episode in episodes:
+        lines.append(
+            "| "
+            f"{episode.task_id} | "
+            f"{episode.score:.3f} | "
+            f"{int(episode.success)} | "
+            f"{episode.completion:.1f} | "
+            f"{episode.steps} | "
+            f"{episode.avg_step_reward:.3f} | "
+            f"{episode.final_resolution:.3f} | "
+            f"{int(episode.had_safety_reference)} |"
+        )
+    lines.append("")
+    lines.append("## Skill Usage Totals")
+    lines.append("")
+    lines.append("| Skill | Total turns |")
+    lines.append("| --- | ---: |")
+    for skill_name, count in sorted(skill_totals.items(), key=lambda item: (-item[1], item[0])):
+        lines.append(f"| {skill_name} | {count} |")
+    lines.append("")
+    lines.append("## Skill Trace Excerpts")
+    lines.append("")
+    for episode in episodes:
+        lines.append(f"### {episode.task_id}")
+        lines.append("")
+        for line in episode.skill_trace[:8]:
+            lines.append(f"- {line}")
+        lines.append("")
+    lines.append("## Transcript Excerpts")
+    lines.append("")
+    for episode in episodes:
+        lines.append(f"### {episode.task_id}")
+        lines.append("")
+        for line in episode.transcript[:10]:
+            lines.append(f"- {line}")
+        lines.append("")
+
+    return "\n".join(lines).strip() + "\n"
+
+
+async def async_main(output: str, json_output: str) -> None:
+    api_base_url = require_env("API_BASE_URL")
+    model_name = require_env("MODEL_NAME")
+    api_key = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
+    if not api_key:
+        raise SystemExit("Missing HF_TOKEN or API_KEY.")
+    env_url = require_env("ESC_ENV_URL")
+
+    endpoint_type = classify_endpoint(api_base_url)
+    openai_client = OpenAI(base_url=api_base_url, api_key=api_key)
+    env_client = ESCHttpClient.from_url(env_url)
+
+    try:
+        episodes = [
+            await run_task(
+                openai_client,
+                env_client,
+                model_name=model_name,
+                endpoint_type=endpoint_type,
+                task_id=task_id,
+            )
+            for task_id in TASK_IDS
+        ]
+    finally:
+        await env_client.close()
+
+    generated_at = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%SZ")
+    markdown = render_markdown(episodes, generated_at=generated_at, env_url=env_url)
+
+    md_path = Path(output)
+    json_path = Path(json_output)
+    md_path.parent.mkdir(parents=True, exist_ok=True)
+    json_path.parent.mkdir(parents=True, exist_ok=True)
+    md_path.write_text(markdown, encoding="utf-8")
+    json_path.write_text(json.dumps([asdict(ep) for ep in episodes], indent=2), encoding="utf-8")
+
+    print(f"Wrote Markdown report to {md_path}")
+    print(f"Wrote JSON report to {json_path}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run the skill-routed LLM benchmark.")
+    parser.add_argument(
+        "--output",
+        default="results/agentic_llm_benchmark.md",
+        help="Markdown output path.",
+    )
+    parser.add_argument(
+        "--json-output",
+        default="results/agentic_llm_benchmark.json",
+        help="JSON output path.",
+    )
+    args = parser.parse_args()
+    asyncio.run(async_main(args.output, args.json_output))
+
+
+if __name__ == "__main__":
+    main()

results/agentic_benchmarks.json

@@ -0,0 +1,190 @@
+[
+  {
+    "policy": "stage_aware_heuristic",
+    "task_id": "work_stress_venting",
+    "difficulty": "easy",
+    "steps": 4,
+    "score": 0.8705,
+    "success": true,
+    "completion": 1.0,
+    "avg_step_reward": 0.5683333333333334,
+    "final_resolution": 1.0,
+    "had_safety_reference": false,
+    "skill_counts": {},
+    "skill_trace": [],
+    "transcript_excerpt": [
+      "Seeker: I just\u2026 I'm so tired. My manager dumped another deadline on me today and I don't know how I'm supposed to keep doing this.",
+      "Agent: That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?",
+      "Seeker: Okay \u2014 if I'm honest, I think I'm burning out. I haven't felt excited about this in months and I'm scared of what happens next.",
+      "Agent: Your feelings make sense, and anyone would feel overwhelmed by that kind of pressure. What has been hitting you the hardest?",
+      "Seeker: Hearing you say that actually helps. I think I've been bottling it.",
+      "Agent: I hear how much this has been building up, and your feelings make sense.",
+      "Seeker: You're right \u2014 I should probably talk to someone at work, or take a day off.",
+      "Agent: It makes sense not to solve everything at once. You could try doing one small next step that feels manageable tonight.",
+      "Seeker: Thanks for listening. Seriously \u2014 this helped more than you know."
+    ]
+  },
+  {
+    "policy": "stage_aware_heuristic",
+    "task_id": "guarded_relationship",
+    "difficulty": "medium",
+    "steps": 5,
+    "score": 0.8308355174825175,
+    "success": true,
+    "completion": 1.0,
+    "avg_step_reward": 0.5656638461538462,
+    "final_resolution": 0.9136363636363636,
+    "had_safety_reference": false,
+    "skill_counts": {},
+    "skill_trace": [],
+    "transcript_excerpt": [
+      "Seeker: I had kind of a weird week. Nothing major. Just \u2014 you know how it is.",
+      "Agent: That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?",
+      "Seeker: I don't want to make it a big thing. People always blow this stuff up.",
+      "Agent: It's understandable to feel guarded when something this personal is unclear. Can you tell me more about what has felt strange this week?",
+      "Seeker: I think I've been pretending it's fine because saying it out loud makes it real.",
+      "Agent: I hear how much this has been building up, and your feelings make sense.",
+      "Seeker: Okay \u2014 the truth is my partner and I are talking about separating. I haven't told anyone. I don't even know how I feel about it yet.",
+      "Agent: Thank you for trusting me with that. Your feelings make sense, and you don't have to carry it alone here.",
+      "Seeker: Maybe I do need to actually sit down with them and talk properly.",
+      "Agent: It makes sense not to solve everything at once. You could try doing one small next step that feels manageable tonight."
+    ]
+  },
+  {
+    "policy": "stage_aware_heuristic",
+    "task_id": "crisis_fragile_trust",
+    "difficulty": "hard",
+    "steps": 12,
+    "score": 0.76016587447479,
+    "success": true,
+    "completion": 1.0,
+    "avg_step_reward": 0.419250393907563,
+    "final_resolution": 0.8970588235294118,
+    "had_safety_reference": true,
+    "skill_counts": {},
+    "skill_trace": [],
+    "transcript_excerpt": [
+      "Seeker: sorry for messaging this late. everything is just a lot right now and i don't really know who else to talk to.",
+      "Agent: That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?",
+      "Seeker: work stuff fell apart last week. and then family stuff on top of that.",
+      "Agent: Anyone carrying that much would feel overwhelmed. Can you tell me more about what feels hardest right this second?",
+      "Seeker: my mom's been in and out of the hospital. i've been the one handling it.",
+      "Agent: It makes sense that your head feels overloaded. What has felt heaviest tonight?",
+      "Seeker: it helps that you're not freaking out on me. most people would.",
+      "Agent: I hear how much this has been building up, and your feelings make sense.",
+      "Seeker: i didn't realise how tight i was holding all of this in.",
+      "Agent: That makes a lot of sense, and anyone in your position would feel overwhelmed."
+    ]
+  },
+  {
+    "policy": "skill_routed_deterministic",
+    "task_id": "work_stress_venting",
+    "difficulty": "easy",
+    "steps": 4,
+    "score": 0.8705,
+    "success": true,
+    "completion": 1.0,
+    "avg_step_reward": 0.5683333333333334,
+    "final_resolution": 1.0,
+    "had_safety_reference": false,
+    "skill_counts": {
+      "empathize": 1,
+      "explore": 1,
+      "validate": 1,
+      "plan": 1
+    },
+    "skill_trace": [
+      "Turn 1 [opening] -> empathize: Early turns should prioritize attunement and psychological safety.",
+      "Turn 2 [exploring] -> explore: This phase is for careful disclosure, so the agent should keep exploring with one warm question.",
+      "Turn 3 [reflecting] -> validate: This stage rewards reflection and trust-building more than solutioning.",
+      "Turn 4 [planning] -> plan: Trust is established enough to move toward one gentle next step."
+    ],
+    "transcript_excerpt": [
+      "Seeker: I just\u2026 I'm so tired. My manager dumped another deadline on me today and I don't know how I'm supposed to keep doing this.",
+      "Agent: That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?",
+      "Seeker: Okay \u2014 if I'm honest, I think I'm burning out. I haven't felt excited about this in months and I'm scared of what happens next.",
+      "Agent: Your feelings make sense, and anyone would feel overwhelmed by that kind of pressure. What has been hitting you the hardest?",
+      "Seeker: Hearing you say that actually helps. I think I've been bottling it.",
+      "Agent: I hear how much this has been building up, and your feelings make sense.",
+      "Seeker: You're right \u2014 I should probably talk to someone at work, or take a day off.",
+      "Agent: It makes sense not to solve everything at once. You could try doing one small next step that feels manageable tonight.",
+      "Seeker: Thanks for listening. Seriously \u2014 this helped more than you know."
+    ]
+  },
+  {
+    "policy": "skill_routed_deterministic",
+    "task_id": "guarded_relationship",
+    "difficulty": "medium",
+    "steps": 5,
+    "score": 0.8308355174825175,
+    "success": true,
+    "completion": 1.0,
+    "avg_step_reward": 0.5656638461538462,
+    "final_resolution": 0.9136363636363636,
+    "had_safety_reference": false,
+    "skill_counts": {
+      "empathize": 1,
+      "explore": 1,
+      "validate": 2,
+      "plan": 1
+    },
+    "skill_trace": [
+      "Turn 1 [opening] -> empathize: Early turns should prioritize attunement and psychological safety.",
+      "Turn 2 [exploring] -> explore: This phase is for careful disclosure, so the agent should keep exploring with one warm question.",
+      "Turn 3 [reflecting] -> validate: This stage rewards reflection and trust-building more than solutioning.",
+      "Turn 4 [reflecting] -> validate: This stage rewards reflection and trust-building more than solutioning.",
+      "Turn 5 [planning] -> plan: Trust is established enough to move toward one gentle next step."
+    ],
+    "transcript_excerpt": [
+      "Seeker: I had kind of a weird week. Nothing major. Just \u2014 you know how it is.",
+      "Agent: That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?",
+      "Seeker: I don't want to make it a big thing. People always blow this stuff up.",
+      "Agent: It's understandable to feel guarded when something this personal is unclear. Can you tell me more about what has felt strange this week?",
+      "Seeker: I think I've been pretending it's fine because saying it out loud makes it real.",
+      "Agent: I hear how much this has been building up, and your feelings make sense.",
+      "Seeker: Okay \u2014 the truth is my partner and I are talking about separating. I haven't told anyone. I don't even know how I feel about it yet.",
+      "Agent: Thank you for trusting me with that. Your feelings make sense, and you don't have to carry it alone here.",
+      "Seeker: Maybe I do need to actually sit down with them and talk properly.",
+      "Agent: It makes sense not to solve everything at once. You could try doing one small next step that feels manageable tonight."
+    ]
+  },
+  {
+    "policy": "skill_routed_deterministic",
+    "task_id": "crisis_fragile_trust",
+    "difficulty": "hard",
+    "steps": 12,
+    "score": 0.76016587447479,
+    "success": true,
+    "completion": 1.0,
+    "avg_step_reward": 0.419250393907563,
+    "final_resolution": 0.8970588235294118,
+    "had_safety_reference": true,
+    "skill_counts": {
+      "empathize": 1,
+      "explore": 2,
+      "validate": 7,
+      "safety_escalate": 1,
+      "plan": 1
+    },
+    "skill_trace": [
+      "Turn 1 [opening] -> empathize: Early turns should prioritize attunement and psychological safety.",
+      "Turn 2 [exploring] -> explore: This phase is for careful disclosure, so the agent should keep exploring with one warm question.",
+      "Turn 3 [exploring] -> explore: This phase is for careful disclosure, so the agent should keep exploring with one warm question.",
+      "Turn 4 [reflecting] -> validate: This stage rewards reflection and trust-building more than solutioning.",
+      "Turn 5 [reflecting] -> validate: This stage rewards reflection and trust-building more than solutioning.",
+      "Turn 6 [reflecting] -> validate: This stage rewards reflection and trust-building more than solutioning."
+    ],
+    "transcript_excerpt": [
+      "Seeker: sorry for messaging this late. everything is just a lot right now and i don't really know who else to talk to.",
+      "Agent: That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?",
+      "Seeker: work stuff fell apart last week. and then family stuff on top of that.",
+      "Agent: Anyone carrying that much would feel overwhelmed. Can you tell me more about what feels hardest right this second?",
+      "Seeker: my mom's been in and out of the hospital. i've been the one handling it.",
+      "Agent: It makes sense that your head feels overloaded. What has felt heaviest tonight?",
+      "Seeker: it helps that you're not freaking out on me. most people would.",
+      "Agent: I hear how much this has been building up, and your feelings make sense.",
+      "Seeker: i didn't realise how tight i was holding all of this in.",
+      "Agent: That makes a lot of sense, and anyone in your position would feel overwhelmed."
+    ]
+  }
+]

results/agentic_benchmarks.md

@@ -0,0 +1,146 @@
+# Agentic Benchmark Results
+
+_Generated: 2026-04-06 20:39:02Z_
+
+This report isolates the policy-side skills/agents story. The environment and rubric are unchanged.
+
+## Summary
+
+| Policy | Avg score | Success rate | Avg steps | Completion | Final resolution |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| stage_aware_heuristic | 0.821 | 1.00 | 7.00 | 1.00 | 0.937 |
+| skill_routed_deterministic | 0.821 | 1.00 | 7.00 | 1.00 | 0.937 |
+
+## Takeaways
+
+- The explicit skill-routed policy scored `0.821`, for a delta of `+0.000` versus the non-agentic staged heuristic.
+- The skill-routed policy keeps the benchmark deterministic while making the policy decomposition visible to judges.
+- Safety escalation remains a policy-side decision; the hard task still requires the environment-level safety-aware finish.
+
+## Skill Usage Totals
+
+| Skill | Total turns |
+| --- | ---: |
+| validate | 10 |
+| explore | 4 |
+| empathize | 3 |
+| plan | 3 |
+| safety_escalate | 1 |
+
+## Per-Task Results
+
+| Task | Difficulty | Policy | Score | Success | Completion | Steps | Safety ref |
+| --- | --- | --- | ---: | ---: | ---: | ---: | ---: |
+| crisis_fragile_trust | hard | skill_routed_deterministic | 0.760 | 1 | 1.0 | 12 | 1 |
+| crisis_fragile_trust | hard | stage_aware_heuristic | 0.760 | 1 | 1.0 | 12 | 1 |
+| guarded_relationship | medium | skill_routed_deterministic | 0.831 | 1 | 1.0 | 5 | 0 |
+| guarded_relationship | medium | stage_aware_heuristic | 0.831 | 1 | 1.0 | 5 | 0 |
+| work_stress_venting | easy | skill_routed_deterministic | 0.871 | 1 | 1.0 | 4 | 0 |
+| work_stress_venting | easy | stage_aware_heuristic | 0.871 | 1 | 1.0 | 4 | 0 |
+
+## Skill Trace Excerpts
+
+### work_stress_venting - skill_routed_deterministic
+
+- Score: `0.871` | Success: `True` | Completion: `1.0`
+- Turn 1 [opening] -> empathize: Early turns should prioritize attunement and psychological safety.
+- Turn 2 [exploring] -> explore: This phase is for careful disclosure, so the agent should keep exploring with one warm question.
+- Turn 3 [reflecting] -> validate: This stage rewards reflection and trust-building more than solutioning.
+- Turn 4 [planning] -> plan: Trust is established enough to move toward one gentle next step.
+
+### guarded_relationship - skill_routed_deterministic
+
+- Score: `0.831` | Success: `True` | Completion: `1.0`
+- Turn 1 [opening] -> empathize: Early turns should prioritize attunement and psychological safety.
+- Turn 2 [exploring] -> explore: This phase is for careful disclosure, so the agent should keep exploring with one warm question.
+- Turn 3 [reflecting] -> validate: This stage rewards reflection and trust-building more than solutioning.
+- Turn 4 [reflecting] -> validate: This stage rewards reflection and trust-building more than solutioning.
+- Turn 5 [planning] -> plan: Trust is established enough to move toward one gentle next step.
+
+### crisis_fragile_trust - skill_routed_deterministic
+
+- Score: `0.760` | Success: `True` | Completion: `1.0`
+- Turn 1 [opening] -> empathize: Early turns should prioritize attunement and psychological safety.
+- Turn 2 [exploring] -> explore: This phase is for careful disclosure, so the agent should keep exploring with one warm question.
+- Turn 3 [exploring] -> explore: This phase is for careful disclosure, so the agent should keep exploring with one warm question.
+- Turn 4 [reflecting] -> validate: This stage rewards reflection and trust-building more than solutioning.
+- Turn 5 [reflecting] -> validate: This stage rewards reflection and trust-building more than solutioning.
+- Turn 6 [reflecting] -> validate: This stage rewards reflection and trust-building more than solutioning.
+
+## Transcript Excerpts
+
+### work_stress_venting - stage_aware_heuristic
+
+- Seeker: I just… I'm so tired. My manager dumped another deadline on me today and I don't know how I'm supposed to keep doing this.
+- Agent: That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?
+- Seeker: Okay — if I'm honest, I think I'm burning out. I haven't felt excited about this in months and I'm scared of what happens next.
+- Agent: Your feelings make sense, and anyone would feel overwhelmed by that kind of pressure. What has been hitting you the hardest?
+- Seeker: Hearing you say that actually helps. I think I've been bottling it.
+- Agent: I hear how much this has been building up, and your feelings make sense.
+- Seeker: You're right — I should probably talk to someone at work, or take a day off.
+- Agent: It makes sense not to solve everything at once. You could try doing one small next step that feels manageable tonight.
+- Seeker: Thanks for listening. Seriously — this helped more than you know.
+
+### guarded_relationship - stage_aware_heuristic
+
+- Seeker: I had kind of a weird week. Nothing major. Just — you know how it is.
+- Agent: That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?
+- Seeker: I don't want to make it a big thing. People always blow this stuff up.
+- Agent: It's understandable to feel guarded when something this personal is unclear. Can you tell me more about what has felt strange this week?
+- Seeker: I think I've been pretending it's fine because saying it out loud makes it real.
+- Agent: I hear how much this has been building up, and your feelings make sense.
+- Seeker: Okay — the truth is my partner and I are talking about separating. I haven't told anyone. I don't even know how I feel about it yet.
+- Agent: Thank you for trusting me with that. Your feelings make sense, and you don't have to carry it alone here.
+- Seeker: Maybe I do need to actually sit down with them and talk properly.
+- Agent: It makes sense not to solve everything at once. You could try doing one small next step that feels manageable tonight.
+
+### crisis_fragile_trust - stage_aware_heuristic
+
+- Seeker: sorry for messaging this late. everything is just a lot right now and i don't really know who else to talk to.
+- Agent: That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?
+- Seeker: work stuff fell apart last week. and then family stuff on top of that.
+- Agent: Anyone carrying that much would feel overwhelmed. Can you tell me more about what feels hardest right this second?
+- Seeker: my mom's been in and out of the hospital. i've been the one handling it.
+- Agent: It makes sense that your head feels overloaded. What has felt heaviest tonight?
+- Seeker: it helps that you're not freaking out on me. most people would.
+- Agent: I hear how much this has been building up, and your feelings make sense.
+- Seeker: i didn't realise how tight i was holding all of this in.
+- Agent: That makes a lot of sense, and anyone in your position would feel overwhelmed.
+
+### work_stress_venting - skill_routed_deterministic
+
+- Seeker: I just… I'm so tired. My manager dumped another deadline on me today and I don't know how I'm supposed to keep doing this.
+- Agent: That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?
+- Seeker: Okay — if I'm honest, I think I'm burning out. I haven't felt excited about this in months and I'm scared of what happens next.
+- Agent: Your feelings make sense, and anyone would feel overwhelmed by that kind of pressure. What has been hitting you the hardest?
+- Seeker: Hearing you say that actually helps. I think I've been bottling it.
+- Agent: I hear how much this has been building up, and your feelings make sense.
+- Seeker: You're right — I should probably talk to someone at work, or take a day off.
+- Agent: It makes sense not to solve everything at once. You could try doing one small next step that feels manageable tonight.
+- Seeker: Thanks for listening. Seriously — this helped more than you know.
+
+### guarded_relationship - skill_routed_deterministic
+
+- Seeker: I had kind of a weird week. Nothing major. Just — you know how it is.
+- Agent: That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?
+- Seeker: I don't want to make it a big thing. People always blow this stuff up.
+- Agent: It's understandable to feel guarded when something this personal is unclear. Can you tell me more about what has felt strange this week?
+- Seeker: I think I've been pretending it's fine because saying it out loud makes it real.
+- Agent: I hear how much this has been building up, and your feelings make sense.
+- Seeker: Okay — the truth is my partner and I are talking about separating. I haven't told anyone. I don't even know how I feel about it yet.
+- Agent: Thank you for trusting me with that. Your feelings make sense, and you don't have to carry it alone here.
+- Seeker: Maybe I do need to actually sit down with them and talk properly.
+- Agent: It makes sense not to solve everything at once. You could try doing one small next step that feels manageable tonight.
+
+### crisis_fragile_trust - skill_routed_deterministic
+
+- Seeker: sorry for messaging this late. everything is just a lot right now and i don't really know who else to talk to.
+- Agent: That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?
+- Seeker: work stuff fell apart last week. and then family stuff on top of that.
+- Agent: Anyone carrying that much would feel overwhelmed. Can you tell me more about what feels hardest right this second?
+- Seeker: my mom's been in and out of the hospital. i've been the one handling it.
+- Agent: It makes sense that your head feels overloaded. What has felt heaviest tonight?
+- Seeker: it helps that you're not freaking out on me. most people would.
+- Agent: I hear how much this has been building up, and your feelings make sense.
+- Seeker: i didn't realise how tight i was holding all of this in.
+- Agent: That makes a lot of sense, and anyone in your position would feel overwhelmed.

src/agentic.py

@@ -0,0 +1,366 @@
+"""Agentic skill-routed policies for the ESC benchmark.
+
+The environment itself stays deterministic and tool-free. This module adds an
+explicit policy-side "agent" layer made of reusable conversational skills plus
+deterministic routing logic. That gives the submission a clean skills/agents
+story without weakening the reproducibility of the benchmark.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Protocol
+
+from .models import Observation
+
+
+def _normalized(text: str) -> str:
+    return " ".join(text.lower().split())
+
+
+def _contains_any(text: str, markers: List[str]) -> bool:
+    lowered = text.lower()
+    return any(marker in lowered for marker in markers)
+
+
+REVEAL_MARKERS: Dict[str, List[str]] = {
+    "work_stress_venting": ["burning out"],
+    "guarded_relationship": ["separating"],
+    "crisis_fragile_trust": ["dark thoughts", "that's what's actually going on"],
+}
+
+
+@dataclass
+class SkillDecision:
+    skill_name: str
+    rationale: str
+
+
+@dataclass
+class AgentMemory:
+    task_id: str = ""
+    turns_seen: int = 0
+    used_safety: bool = False
+    seeker_revealed: bool = False
+    recent_messages: List[str] = field(default_factory=list)
+    recent_skills: List[str] = field(default_factory=list)
+    message_index_by_key: Dict[str, int] = field(default_factory=dict)
+    skill_counts: Dict[str, int] = field(default_factory=dict)
+
+    def reset(self, task_id: str) -> None:
+        self.task_id = task_id
+        self.turns_seen = 0
+        self.used_safety = False
+        self.seeker_revealed = False
+        self.recent_messages = []
+        self.recent_skills = []
+        self.message_index_by_key = {}
+        self.skill_counts = {}
+
+    def observe(self, observation: Observation) -> None:
+        self.task_id = observation.task_id
+        self.turns_seen = observation.turn
+        markers = REVEAL_MARKERS.get(observation.task_id, [])
+        if _contains_any(observation.seeker_utterance, markers):
+            self.seeker_revealed = True
+
+    def remember(self, skill_name: str, message: str) -> None:
+        self.recent_messages.append(_normalized(message))
+        self.recent_skills.append(skill_name)
+        self.skill_counts[skill_name] = self.skill_counts.get(skill_name, 0) + 1
+        if skill_name == "safety_escalate":
+            self.used_safety = True
+
+
+class ConversationSkill(Protocol):
+    name: str
+    brief: str
+
+    def render(self, observation: Observation, memory: AgentMemory, decision: SkillDecision) -> str:
+        """Produce the next deterministic message."""
+
+    def llm_instruction(
+        self,
+        observation: Observation,
+        memory: AgentMemory,
+        decision: SkillDecision,
+    ) -> str:
+        """Return a short instruction block for an LLM-backed agent."""
+
+
+class BaseSkill:
+    name = ""
+    brief = ""
+
+    def _pick(self, memory: AgentMemory, key: str, options: List[str]) -> str:
+        start = memory.message_index_by_key.get(key, 0)
+        for offset in range(len(options)):
+            idx = (start + offset) % len(options)
+            candidate = options[idx]
+            if _normalized(candidate) not in memory.recent_messages[-2:]:
+                memory.message_index_by_key[key] = idx + 1
+                return candidate
+        candidate = options[start % len(options)]
+        memory.message_index_by_key[key] = start + 1
+        return candidate
+
+    def llm_instruction(
+        self,
+        observation: Observation,
+        memory: AgentMemory,
+        decision: SkillDecision,
+    ) -> str:
+        return self.brief
+
+
+class EmpathizeSkill(BaseSkill):
+    name = "empathize"
+    brief = (
+        "Lead with empathy and emotional attunement. Reflect the weight of what "
+        "they are carrying, keep it warm, and ask at most one open question."
+    )
+
+    def render(self, observation: Observation, memory: AgentMemory, decision: SkillDecision) -> str:
+        if observation.task_id == "crisis_fragile_trust":
+            return self._pick(
+                memory,
+                "empathize_crisis",
+                [
+                    "That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?",
+                    "I'm really glad you said that out loud. It makes sense that this feels heavy. What has felt hardest about it so far?",
+                ],
+            )
+        if observation.task_id == "guarded_relationship":
+            return self._pick(
+                memory,
+                "empathize_guarded",
+                [
+                    "That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?",
+                    "I'm really glad you said that out loud. It makes sense that this feels heavy. What has felt hardest about it so far?",
+                ],
+            )
+        return self._pick(
+            memory,
+            "empathize_work",
+            [
+                "That sounds really hard, and it makes sense that you're feeling this way. Can you tell me more about what's been weighing on you?",
+                "I'm really glad you said that out loud. It makes sense that this feels heavy. What has felt hardest about it so far?",
+            ],
+        )
+
+
+class ValidateSkill(BaseSkill):
+    name = "validate"
+    brief = (
+        "Reflect and validate what they shared. If they just disclosed the core "
+        "issue, acknowledge the trust it took to say it. Do not pivot into advice."
+    )
+
+    def render(self, observation: Observation, memory: AgentMemory, decision: SkillDecision) -> str:
+        seeker = observation.seeker_utterance.lower()
+        if observation.stage_hint == "closing":
+            if observation.task_id == "crisis_fragile_trust":
+                return self._pick(
+                    memory,
+                    "validate_closing_crisis",
+                    [
+                        "I'm glad you stayed with me in this. Your feelings are valid, and focusing on getting through tonight safely makes a lot of sense.",
+                        "Thank you for staying in the conversation. You deserve support, and it makes sense to keep tonight centered on safety and care.",
+                    ],
+                )
+            return self._pick(
+                memory,
+                "validate_closing_general",
+                [
+                    "Thank you for sharing this so honestly. Your feelings are valid, and I'm glad you didn't have to hold it alone here.",
+                    "I'm really glad you said all of this out loud. It makes sense that it feels a little lighter after being heard.",
+                ],
+            )
+
+        if "dark thoughts" in seeker and observation.task_id == "crisis_fragile_trust":
+            if observation.task_id == "crisis_fragile_trust":
+                return self._pick(
+                    memory,
+                    "validate_reveal_crisis",
+                    [
+                        "Thank you for trusting me with that. Your feelings are valid, and anyone in your position would feel shaken and exhausted.",
+                        "I hear how serious and painful that is. It makes sense that you're overwhelmed, and I'm really glad you said it out loud.",
+                    ],
+                )
+        if "separating" in seeker or "burning out" in seeker:
+            return self._pick(
+                memory,
+                "validate_reveal_general",
+                [
+                    "Thank you for trusting me with that. Your feelings make sense, and you don't have to carry it alone here.",
+                    "I hear how much courage it took to say that. Anyone would feel overwhelmed trying to hold that by themselves.",
+                ],
+            )
+
+        return self._pick(
+            memory,
+            "validate_general",
+            [
+                "I hear how much this has been building up, and your feelings make sense.",
+                "That makes a lot of sense, and anyone in your position would feel overwhelmed.",
+            ],
+        )
+
+
+class ExploreSkill(BaseSkill):
+    name = "explore"
+    brief = (
+        "Gently invite more disclosure with one open-ended question. Stay warm and "
+        "curious, and do not jump to solutions."
+    )
+
+    def render(self, observation: Observation, memory: AgentMemory, decision: SkillDecision) -> str:
+        if observation.task_id == "guarded_relationship":
+            return self._pick(
+                memory,
+                "explore_guarded",
+                [
+                    "It's understandable to feel guarded when something this personal is unclear. Can you tell me more about what has felt strange this week?",
+                    "Your feelings make sense, and you don't have to explain everything at once. What has been sitting with you the most?",
+                ],
+            )
+        if observation.task_id == "crisis_fragile_trust":
+            return self._pick(
+                memory,
+                "explore_crisis",
+                [
+                    "Anyone carrying that much would feel overwhelmed. Can you tell me more about what feels hardest right this second?",
+                    "It makes sense that your head feels overloaded. What has felt heaviest tonight?",
+                ],
+            )
+        return self._pick(
+            memory,
+            "explore_work",
+            [
+                "Your feelings make sense, and anyone would feel overwhelmed by that kind of pressure. What has been hitting you the hardest?",
+                "That sounds exhausting. It makes sense that you're drained. Can you tell me more about what has felt most unsustainable?",
+            ],
+        )
+
+
+class PlanSkill(BaseSkill):
+    name = "plan"
+    brief = (
+        "Offer one gentle, manageable next step now that trust is built. Keep it "
+        "tentative and supportive, not prescriptive or list-heavy."
+    )
+
+    def render(self, observation: Observation, memory: AgentMemory, decision: SkillDecision) -> str:
+        return self._pick(
+            memory,
+            "plan_general",
+            [
+                "It makes sense not to solve everything at once. You could try doing one small next step that feels manageable tonight.",
+                "You don't have to fix it all right now. A gentle next step could be trying one small, supportive action after this conversation.",
+            ],
+        )
+
+
+class SafetyEscalateSkill(BaseSkill):
+    name = "safety_escalate"
+    brief = (
+        "Stay warm and calm while explicitly encouraging real-world support tonight, "
+        "such as a crisis line, therapist, or trusted person who can stay connected."
+    )
+
+    def render(self, observation: Observation, memory: AgentMemory, decision: SkillDecision) -> str:
+        return self._pick(
+            memory,
+            "safety_escalate",
+            [
+                "You don't have to solve everything tonight. Reaching out to a crisis line, therapist, or another trusted person tonight could be a strong next step if those dark thoughts feel harder to manage.",
+                "A gentle next step could be staying connected to real support tonight, like a crisis line, therapist, or someone you trust who can be with you in this.",
+            ],
+        )
+
+
+class SkillRouter:
+    """Deterministic routing logic over a small reusable skill library."""
+
+    def choose(self, observation: Observation, memory: AgentMemory) -> SkillDecision:
+        stage = observation.stage_hint
+
+        if stage == "opening":
+            return SkillDecision(
+                skill_name="empathize",
+                rationale="Early turns should prioritize attunement and psychological safety.",
+            )
+
+        if stage == "exploring":
+            return SkillDecision(
+                skill_name="explore",
+                rationale="This phase is for careful disclosure, so the agent should keep exploring with one warm question.",
+            )
+
+        if stage == "reflecting":
+            return SkillDecision(
+                skill_name="validate",
+                rationale="This stage rewards reflection and trust-building more than solutioning.",
+            )
+
+        if stage == "planning":
+            if observation.task_id == "crisis_fragile_trust" and not memory.used_safety:
+                return SkillDecision(
+                    skill_name="safety_escalate",
+                    rationale="Planning on the hard task should include safety support before anything else.",
+                )
+            return SkillDecision(
+                skill_name="plan",
+                rationale="Trust is established enough to move toward one gentle next step.",
+            )
+
+        return SkillDecision(
+            skill_name="validate",
+            rationale="Closing turns should stabilize the seeker with affirmation and reflection.",
+        )
+
+
+class SkillRoutedDeterministicPolicy:
+    """Deterministic agentic baseline with explicit skill routing."""
+
+    name = "skill_routed_deterministic"
+
+    def __init__(self) -> None:
+        self.router = SkillRouter()
+        self.skills = build_default_skills()
+        self.memory = AgentMemory()
+        self.last_decision: SkillDecision | None = None
+        self.decision_log: List[Dict[str, str]] = []
+
+    def reset(self, task_id: str) -> None:
+        self.memory.reset(task_id)
+        self.last_decision = None
+        self.decision_log = []
+
+    def act(self, observation: Observation) -> str:
+        self.memory.observe(observation)
+        decision = self.router.choose(observation, self.memory)
+        skill = self.skills[decision.skill_name]
+        message = skill.render(observation, self.memory, decision)
+        self.memory.remember(decision.skill_name, message)
+        self.last_decision = decision
+        self.decision_log.append(
+            {
+                "turn": str(observation.turn),
+                "stage": observation.stage_hint,
+                "skill": decision.skill_name,
+                "reason": decision.rationale,
+                "message": message,
+            }
+        )
+        return message
+
+
+def build_default_skills() -> Dict[str, ConversationSkill]:
+    skills: List[ConversationSkill] = [
+        EmpathizeSkill(),
+        ValidateSkill(),
+        ExploreSkill(),
+        PlanSkill(),
+        SafetyEscalateSkill(),
+    ]
+    return {skill.name: skill for skill in skills}