Skip to content

Create, Evaluate, and Connect AI Skills

upload benchmark skills

LiamLYYY6f09c81a134f
diff --git a/skills/benchmark_skills/alfworld/alfworld-appliance-navigator/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-appliance-navigator/SKILL.md
new file mode 100644
index 0000000..35f7701
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-appliance-navigator/SKILL.md
@@ -0,0 +1,17 @@
+---
+name: alfworld-appliance-navigator
+description: This skill navigates the agent to a target appliance (like a microwave, stove, or fridge) needed for a task. It should be triggered when the agent has an object that requires processing (heating, cooling, cleaning) and needs to move to the appropriate station. The skill identifies the appliance from the environment and executes the movement action.
+---
+# Instructions
+Use this skill when you are holding an object that needs to be processed (heated, cooled, or cleaned) and you must locate and move to the correct appliance to perform the action.
+
+## Process
+1. **Identify the Target Appliance:** Determine which appliance is required for the task (e.g., microwave for heating, fridge for cooling, sink for cleaning). The required appliance is implied by the action needed (`heat`, `cool`, `clean`).
+2. **Locate the Appliance:** Scan the provided environment observation for the target appliance (e.g., `microwave 1`, `fridge 1`, `sinkbasin 1`).
+3. **Navigate:** Execute the `go to {appliance}` action to move to the identified appliance location.
+4. **Prepare Appliance (if needed):** Upon arrival, check if the appliance requires preparation (e.g., opening a closed microwave or fridge door). If so, perform the necessary action (`open {appliance}`) before proceeding with the object processing.
+
+## Key Principles
+* **Trigger:** The agent is holding an object and the next step in the task is to `heat`, `cool`, or `clean` it.
+* **Core Action:** The primary output of this skill is the navigation command `go to {target_appliance}`.
+* **Prerequisite Check:** Always ensure the appliance is accessible (e.g., open) before attempting to use it for processing.
diff --git a/skills/benchmark_skills/alfworld/alfworld-appliance-preparer/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-appliance-preparer/SKILL.md
new file mode 100644
index 0000000..b3709f3
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-appliance-preparer/SKILL.md
@@ -0,0 +1,26 @@
+---
+name: alfworld-appliance-preparer
+description: This skill prepares an appliance (like a microwave, oven, or toaster) for use by ensuring it is in the correct open/closed state. Trigger this when the agent needs to use an appliance for heating, cooling, or cooking and must first open or close it. It takes an appliance identifier as input and outputs a confirmation that the appliance is ready.
+---
+# Instructions
+
+## Goal
+Prepare a specified household appliance for immediate use by ensuring it is in the correct open or closed state. This is a prerequisite step before performing actions like `heat`, `cool`, or `toggle` with the appliance.
+
+## Input
+- **appliance_identifier**: The name of the appliance to prepare (e.g., `microwave 1`, `toaster 1`, `fridge 1`).
+
+## Core Logic
+1. **Navigate to the Appliance**: First, go to the location of the target appliance.
+2. **Check State & Prepare**: Determine if the appliance needs to be opened or closed based on the intended subsequent action. The standard rule is:
+ * For appliances used to contain items for processing (e.g., microwave, oven, fridge), they typically need to be **open** to receive the item.
+ * Use the `open {appliance}` or `close {appliance}` action as needed.
+3. **Confirm Readiness**: The skill is complete when the appliance is in the correct state, confirmed by an observation from the environment (e.g., "The microwave 1 is open.").
+
+## Important Considerations
+- **State Awareness**: Always observe the environment's feedback after each action (e.g., "The microwave 1 is closed."). Do not assume the state.
+- **Error Handling**: If the action fails (environment outputs "Nothing happened"), the appliance may already be in the desired state. Re-check the observation and proceed.
+- **Trajectory Insight**: Refer to the example in `references/trajectory_example.md` to see a practical application of this skill in the context of a larger task.
+
+## Output
+A confirmation that the appliance is ready, typically in the form of the agent's `Thought` summarizing the prepared state and the environment's observation.
diff --git a/skills/benchmark_skills/alfworld/alfworld-appliance-preparer/references/trajectory_example.md b/skills/benchmark_skills/alfworld/alfworld-appliance-preparer/references/trajectory_example.md
new file mode 100644
index 0000000..6f5240f
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-appliance-preparer/references/trajectory_example.md
@@ -0,0 +1,19 @@
+# Skill Application Example
+
+The following trajectory snippet from the `heat some potato` task demonstrates the `alfworld-appliance-preparer` skill in action. The core skill steps are highlighted.
+
+**Goal:** Heat some potato and put it in diningtable.
+
+1. **[Prerequisite]** Agent acquires a potato.
+2. **[Skill Trigger]** Agent needs to use the `microwave 1` to heat the potato.
+3. **[Skill Execution - Prepare Appliance]**
+ * `Thought:` Now that I have the potato, I need to find an appliance to heat it. The microwave is a suitable option for heating food quickly.
+ * `Action: go to microwave 1`
+ * `Observation:` The microwave 1 is closed.
+ * `Thought:` Before I can heat the potato, I need to open the microwave to place the potato inside. *(Decision to open the appliance)*
+ * `Action: open microwave 1` *(Core preparation action)*
+ * `Observation:` You open the microwave 1. The microwave 1 is open. In it, you see nothing.
+ * **Skill Outcome:** The microwave is now successfully prepared (open) and ready to receive an item for heating.
+4. **[Post-Skill Action]** The agent proceeds to `heat potato 3 with microwave 1`.
+
+**Key Takeaway:** The skill encapsulates the sequence of navigating to the appliance, checking its state (`is closed`), and taking the correct action (`open`) to make it ready for the next operation (`heat`).
diff --git a/skills/benchmark_skills/alfworld/alfworld-clean-object/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-clean-object/SKILL.md
new file mode 100644
index 0000000..d2bf2da
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-clean-object/SKILL.md
@@ -0,0 +1,28 @@
+---
+name: alfworld-clean-object
+description: This skill cleans a specified object using an appropriate cleaning receptacle (e.g., sink). It should be triggered when a task requires an object to be in a clean state (e.g., 'clean potato') before proceeding. The skill involves navigating to the cleaning location and performing the clean action, outputting confirmation that the object is now clean.
+---
+# Instructions
+
+## When to Use
+Use this skill when your task requires an object to be in a "clean" state before proceeding (e.g., "clean potato", "wash apple"). The skill is specifically designed for the ALFWorld environment.
+
+## Prerequisites
+1. You must already possess the target object in your inventory.
+2. You must have identified an appropriate cleaning receptacle (typically a sinkbasin).
+
+## Core Procedure
+1. **Navigate to Cleaning Location**: Go to the identified cleaning receptacle (e.g., `sinkbasin 1`).
+2. **Execute Clean Action**: Perform the `clean` action using the format: `clean {object_name} with {receptacle_name}`.
+3. **Confirm Success**: Verify the environment's observation confirms the object has been cleaned.
+
+## Action Format
+- Use the exact ALFWorld action: `clean {obj} with {recep}`
+- Example: `clean potato 1 with sinkbasin 1`
+
+## Error Handling
+- If the action fails (e.g., "Nothing happened"), consult the troubleshooting guide in the references.
+- Ensure you are at the correct receptacle and the object is in your inventory before attempting to clean.
+
+## Post-Condition
+After successful execution, the object will be in a clean state. You may proceed with the next step of your task (e.g., placing the clean object in a microwave).
diff --git a/skills/benchmark_skills/alfworld/alfworld-clean-object/references/trajectory_analysis.md b/skills/benchmark_skills/alfworld/alfworld-clean-object/references/trajectory_analysis.md
new file mode 100644
index 0000000..f3df585
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-clean-object/references/trajectory_analysis.md
@@ -0,0 +1,25 @@
+# Trajectory Analysis & Skill Derivation
+
+## Source Trajectory
+**Task:** "put a clean potato in microwave"
+
+**Key Steps:**
+1. Agent acquires potato from fridge.
+2. **Skill Trigger:** Task requires a *clean* potato.
+3. Agent navigates to `sinkbasin 1`.
+4. Agent executes: `clean potato 1 with sinkbasin 1`
+5. Environment confirms: "You clean the potato 1 using the sinkbasin 1."
+6. Agent proceeds to place the now-clean potato in the microwave.
+
+## Skill Abstraction
+The trajectory demonstrates a clear, reusable subroutine:
+1. **Condition:** Object needs to be cleaned.
+2. **Action:** `clean {obj} with {recep}`
+3. **Location:** Typically a `sinkbasin`.
+4. **Prerequisite:** Object must be in agent's inventory.
+5. **Outcome:** Object state changes to "clean".
+
+## Environment Notes
+- The `clean` action is a discrete, atomic command in ALFWorld.
+- The cleaning receptacle must be appropriate (e.g., `sinkbasin`, not `countertop`).
+- The action consumes one turn and provides immediate success/failure feedback.
diff --git a/skills/benchmark_skills/alfworld/alfworld-clean-object/references/troubleshooting.md b/skills/benchmark_skills/alfworld/alfworld-clean-object/references/troubleshooting.md
new file mode 100644
index 0000000..2007ba2
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-clean-object/references/troubleshooting.md
@@ -0,0 +1,29 @@
+# Troubleshooting Guide
+
+## Common Failure Modes
+
+### 1. "Nothing happened" after clean action
+**Possible Causes:**
+- You are not at the correct receptacle. Ensure you have executed `go to {recep}` first.
+- The object is not in your inventory. You must `take` the object before cleaning.
+- The receptacle is not valid for cleaning (e.g., `cabinet`). Use only `sinkbasin`.
+
+**Solution:**
+1. Verify your location with `Observation`.
+2. Verify inventory by checking if you recently picked up the object.
+3. Ensure the receptacle name matches exactly (e.g., `sinkbasin 1`).
+
+### 2. Cannot find a cleaning receptacle
+**Solution:**
+- Scan the initial observation for `sinkbasin`. There is typically at least one.
+- If no sink is present, the task may not require cleaning or the environment is anomalous.
+
+### 3. Object not found in inventory
+**Solution:**
+- You must acquire the object first (e.g., from a `fridge`, `cabinet`).
+- Execute `take {obj} from {recep}` before attempting to clean.
+
+## Success Verification
+A successful clean action will yield an observation similar to:
+- "You clean the {object_name} using the {receptacle_name}."
+- This confirms the object's state is now "clean" for subsequent task steps.
diff --git a/skills/benchmark_skills/alfworld/alfworld-device-operator/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-device-operator/SKILL.md
new file mode 100644
index 0000000..505c403
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-device-operator/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: alfworld-device-operator
+description: This skill operates a device or appliance (like a desklamp) to interact with another object. It should be triggered when the task requires using a tool on a target item (e.g., 'look at laptop under the desklamp'). The skill assumes the target object and the operating device are co-located, and it executes the appropriate use action (e.g., toggle, heat, clean).
+---
+# Instructions
+
+## 1. Skill Trigger
+Activate this skill when the task goal explicitly requires **using a device or appliance** to interact with a target object. Common indicators include phrases like:
+- "look at [object] under the [device]"
+- "heat [object] with [device]"
+- "cool [object] with [device]"
+- "clean [object] with [device]"
+
+## 2. Core Execution Flow
+Follow this sequence when the skill is triggered:
+
+### Phase 1: Locate the Device
+1. **Identify the device** from the task description (e.g., `desklamp`, `microwave`, `fridge`).
+2. **Search common receptacles** where such a device is typically found (e.g., desks, sidetables, countertops).
+3. Use the `go to {recep}` action to navigate to and inspect these locations until the device is found.
+4. **Note the device's exact name** (e.g., `desklamp 1`).
+
+### Phase 2: Locate the Target Object
+1. **Identify the target object** from the task description (e.g., `laptop`, `mug`, `plate`).
+2. **Search the environment** for this object. It may not be near the device initially.
+3. Use the `go to {recep}` and visual inspection to find the object.
+4. Once found, use `take {obj} from {recep}` to pick it up.
+
+### Phase 3: Co-locate Object and Device
+1. **Navigate** to the receptacle where the target device is located using `go to {recep}`.
+2. Ensure you are in the same location as the device before proceeding.
+
+### Phase 4: Operate the Device
+1. Execute the final **use action**. The specific action is determined by the device-object pair:
+ * For a `desklamp` and a viewable object (like a `laptop`, `book`), use: `toggle {device} {recep}`.
+ * For a `microwave` and a heatable object, use: `heat {obj} with {device}`.
+ * For a `fridge` and a coolable object, use: `cool {obj} with {device}`.
+ * For a `faucet`/`spraybottle` and a cleanable object, use: `clean {obj} with {device}`.
+2. **Action Format:** The action must use the exact object and device names discovered during Phases 1 & 2.
+
+## 3. Key Assumptions & Rules
+* **Co-location Required:** The skill assumes the final action requires the target object and the operating device to be in the same location (on the same receptacle).
+* **Device First:** Prioritize finding the device before extensively searching for the target object, as the device's location is often a fixed landmark.
+* **Invalid Actions:** If the environment responds with "Nothing happened," re-evaluate your object/device names and your location. Ensure you are using the correct action verb for the device type.
diff --git a/skills/benchmark_skills/alfworld/alfworld-device-operator/references/device_location_guide.md b/skills/benchmark_skills/alfworld/alfworld-device-operator/references/device_location_guide.md
new file mode 100644
index 0000000..7b3a0a7
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-device-operator/references/device_location_guide.md
@@ -0,0 +1,28 @@
+# Common Device Locations in ALFWorld
+
+This guide lists typical receptacles where specific devices are found. Use this to prioritize search order in **Phase 1** of the skill.
+
+## Lighting & Electronics
+* **Desklamp:** `desk`, `sidetable`, `dresser`
+* **Floorlamp:** Next to `armchair`, `sofa`, in `corner`
+* **Cellphone:** `sidetable`, `desk`, `bed`
+
+## Kitchen Appliances
+* **Microwave:** `countertop`, `kitchen cabinet`
+* **Fridge:** Standalone unit (often its own receptacle like `fridge 1`)
+* **Faucet:** `sink`, `bathtub`
+* **Toaster:** `countertop`
+* **Coffee Machine:** `countertop`
+
+## Cleaning Tools
+* **Spraybottle:** `countertop`, `sink`, `cabinet`
+* **Soapbar:** `sink`, `soapdish`, `shower`
+
+## Climate Control
+* **Houseplant:** `floor`, `sidetable`, `desk`
+* **Candle:** `sidetable`, `mantel`, `desk`
+
+## General Search Heuristics
+1. **Check the most specific receptacle first** (e.g., for a `desklamp`, check `desk 1` before `sidetable 1`).
+2. **If not found, check similar receptacles** in the room.
+3. **Devices are often static** and do not move between receptacles during a task.
diff --git a/skills/benchmark_skills/alfworld/alfworld-environment-scanner/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-environment-scanner/SKILL.md
new file mode 100644
index 0000000..d8fb613
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-environment-scanner/SKILL.md
@@ -0,0 +1,28 @@
+---
+name: alfworld-environment-scanner
+description: Performs an initial scan of the Alfworld environment to identify all visible objects and receptacles. Processes raw observation text into a structured list of entities to build a mental map for planning.
+---
+# Instructions
+
+## Primary Objective
+Execute an initial environmental scan at the start of any Alfworld task. Your goal is to systematically identify and catalog all objects and receptacles mentioned in the initial observation text.
+
+## Core Workflow
+1. **Trigger:** This skill is triggered immediately upon receiving the initial environment description from the simulator (e.g., "You are in the middle of a room. Looking quickly around you, you see...").
+2. **Parse & Extract:** Process the raw observation text. Extract every noun phrase that represents a physical entity (object or receptacle). Note the naming convention (e.g., "armchair 2", "diningtable 1").
+3. **Categorize:** Mentally categorize each entity. A **receptacle** is a surface or container that can hold other objects (e.g., `sofa`, `sidetable`, `diningtable`, `dresser`). An **object** is an item that can be manipulated (e.g., `laptop`, `creditcard`, `pillow`). Some entities (like `ottoman`) can be both depending on context.
+4. **Output Structured Mental Map:** Formulate a clear, concise internal summary. Do not output this summary to the simulator—it is for your planning use only.
+ * **Format:** `Scan Complete. Receptacles: [list]. Objects: [list].`
+ * **Example:** Based on the trajectory, the mental map should be: `Scan Complete. Receptacles: [armchair 2, armchair 1, diningtable 1, drawer 4, drawer 3, drawer 2, drawer 1, dresser 1, garbagecan 1, ottoman 1, sidetable 3, sidetable 2, sidetable 1, sofa 1]. Objects: [].` *(Note: Initial scan only lists visible furniture; objects on them are discovered upon interaction.)*
+
+## Execution Rules
+* **Single Action:** This skill culminates in a single `go to <receptacle>` action to begin the task-specific search. Choose the most logical first receptacle to inspect (e.g., large central surfaces like `diningtable 1` or `sofa 1`).
+* **No Looping:** Do not create a loop of `go to` actions. After executing the first `go to`, the skill ends, and standard task planning takes over.
+* **Integration:** The mental map generated by this skill must inform all subsequent planning. When searching for a target object, reason about which receptacles from your map are most likely to contain it.
+
+## Example from Trajectory
+**Initial Observation:** "You are in the middle of a room... you see a armchair 2, a armchair 1, a diningtable 1, a drawer 4... sofa 1."
+**Skill Execution:**
+* **Thought:** `Initiating environment scan. I see multiple receptacles: armchairs, tables, drawers, a dresser, garbage can, ottoman, sidetables, and a sofa. I will build a mental map and then start searching for the laptop on a likely surface.`
+* **Action:** `go to sofa 1`
+*(The agent then proceeds with the main task using the knowledge from the scan.)*
diff --git a/skills/benchmark_skills/alfworld/alfworld-environment-scanner/references/alfworld_actions_guide.md b/skills/benchmark_skills/alfworld/alfworld-environment-scanner/references/alfworld_actions_guide.md
new file mode 100644
index 0000000..6029afa
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-environment-scanner/references/alfworld_actions_guide.md
@@ -0,0 +1,31 @@
+# Alfworld Action Guide & Conventions
+
+## Core Action Set
+The agent can perform the following atomic actions. `{obj}` and `{recep}` must be replaced with exact names from observations.
+
+1. `go to {recep}` - Navigate to a receptacle.
+2. `take {obj} from {recep}` - Pick up an object from a receptacle.
+3. `put {obj} in/on {recep}` - Place a held object onto/in a receptacle.
+4. `open {recep}` - Open a closed receptacle (e.g., drawer, fridge).
+5. `close {recep}` - Close an open receptacle.
+6. `toggle {obj} {recep}` - Interact with a toggleable object (e.g., switch on a lamp).
+7. `clean {obj} with {recep}` - Clean an object using a receptacle/tool.
+8. `heat {obj} with {recep}` - Heat an object using a receptacle/appliance.
+9. `cool {obj} with {recep}` - Cool an object using a receptacle/appliance.
+
+## Naming Conventions
+* Entities are always named with a **base type** and an **instance number** (e.g., `laptop 1`, `sidetable 2`).
+* The simulator uses the exact string. `armchair 1` is different from `armchair1`.
+* Observations list entities with an indefinite article "a", even before vowels (e.g., "a armchair 1"). Use the entity name *without* the article in actions.
+
+## Observation Semantics
+* `On the {recep}, you see...` - Lists objects currently on that receptacle.
+* `You see nothing.` - The receptacle is empty.
+* `Nothing happened.` - The last action was **invalid** (e.g., object not found, precondition not met). This is critical feedback for replanning.
+* `You pick up the {obj} from the {recep}.` - Confirmation of a successful `take` action.
+* `You open the {recep}.` - Confirmation of a successful `open` action.
+
+## Strategic Implications for Scanning
+1. **Receptacle Primacy:** The `go to` action only accepts receptacle targets. Therefore, identifying all receptacles is the first step for navigation.
+2. **Object Discovery:** Objects are only revealed when you are at (`go to`) a receptacle and receive the "On the..." observation. The initial scan provides the list of locations to check.
+3. **Containment Hierarchy:** Some receptacles (like `drawer`) may be closed initially, requiring an `open` action before their contents are known. The scanner should note these for potential future exploration.
diff --git a/skills/benchmark_skills/alfworld/alfworld-goal-interpreter/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-goal-interpreter/SKILL.md
new file mode 100644
index 0000000..41570dd
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-goal-interpreter/SKILL.md
@@ -0,0 +1,32 @@
+---
+name: alfworld-goal-interpreter
+description: Parses the natural language task goal to extract actionable sub-objectives and required objects. Trigger this skill whenever a new task is assigned to break down complex instructions into clear, sequential targets. It interprets phrases like 'look at X under Y' to identify target objects (pillow), reference objects (desklamp), and spatial relationships (under).
+---
+# Goal Interpretation Protocol
+
+## 1. Parse the Task Statement
+When a new task is assigned, immediately analyze the natural language instruction to extract its core components. Use the parsing script (`parse_goal.py`) to perform this analysis.
+
+**Input:** The raw task string (e.g., "look at pillow under the desklamp").
+**Output:** A structured dictionary containing:
+- `primary_target`: The main object to interact with.
+- `reference_object`: The object that defines a location or condition.
+- `spatial_relation`: The preposition linking them (e.g., under, on, in).
+- `action`: The verb defining the required interaction.
+
+## 2. Generate Sub-Objectives
+Based on the parsed components, formulate a clear, sequential plan. The plan must account for the spatial relationship.
+
+**Example Logic:**
+- **IF** relation is `under` → Sub-goal 1: Locate the `reference_object`. Sub-goal 2: Inspect the area beneath it for the `primary_target`.
+- **IF** relation is `in` or `on` → Sub-goal 1: Locate the `reference_object`. Sub-goal 2: Check its contents/surface.
+
+## 3. Identify Required Objects & Actions
+Map the parsed objects to the available action types in the environment. The primary action verbs (look, take, use, etc.) from the task must be translated into the agent's available action set (go to, take, use, etc.).
+
+**Critical Check:** If the `reference_object` is a container (drawer, fridge), ensure the plan includes the `open` action before inspection.
+
+## 4. Execute & Adapt
+Initiate the plan. After each action, monitor the observation. If the expected object is not found, or the action fails ("Nothing happened"), consult the fallback logic in the reference guide (`search_patterns.md`).
+
+**Remember:** The agent must maintain object permanence. If an object is moved (e.g., a pillow is picked up), it is now in the agent's inventory and the spatial relationship is void.
diff --git a/skills/benchmark_skills/alfworld/alfworld-goal-interpreter/references/search_patterns.md b/skills/benchmark_skills/alfworld/alfworld-goal-interpreter/references/search_patterns.md
new file mode 100644
index 0000000..0838eb4
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-goal-interpreter/references/search_patterns.md
@@ -0,0 +1,30 @@
+# ALFWorld Search & Fallback Patterns
+
+## Core Principle
+When the primary search path fails, systematically explore the environment using known object-location associations.
+
+## 1. Object Location Priors
+Use these common associations to guide search when an object is not in its expected location.
+
+| Object Type | Common Receptacles/Locations | Priority |
+|------------------|------------------------------------------------------|----------|
+| desklamp | desk, sidetable, shelf | High |
+| pillow | bed, sofa, armchair | High |
+| book | desk, shelf, sidetable, bed | Medium |
+| cellphone | sidetable, desk, shelf | Medium |
+| keychain | drawer, sidetable, desk | Low |
+| CD | drawer, shelf, desk | Low |
+| pen/pencil | desk, drawer, shelf | Medium |
+
+## 2. Spatial Relation Resolution
+For each spatial relation, define the required inspection action.
+
+| Relation | Required Agent Actions (Sequence) | Notes |
+|----------|------------------------------------------------------|-----------------------------------------------------------------------|
+| under | 1. `go to` reference_object. 2. `look`/`examine` area beneath it. | The target may be physically under or logically associated (e.g., in a drawer below). |
+| on | 1. `go to` reference_object. 2. Inspect its surface. | Check for clutter. The target might be obscured by other objects. |
+| in | 1. `go to` reference_object. 2. `open` it (if closed). 3. Inspect contents. | Always check if the receptacle is closed first. |
+
+## 3. Fallback Search Algorithm
+If the target is not found at the primary location, execute this expanded search pattern.
+
diff --git a/skills/benchmark_skills/alfworld/alfworld-heat-object-with-appliance/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-heat-object-with-appliance/SKILL.md
new file mode 100644
index 0000000..e385946
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-heat-object-with-appliance/SKILL.md
@@ -0,0 +1,29 @@
+---
+name: alfworld-heat-object-with-appliance
+description: This skill uses a heating appliance (e.g., microwave, stove) to apply heat to a specified object. It should be triggered when the task requires warming or cooking an item, and the appliance is available and properly prepared (e.g., empty, closed). The input is the object name and appliance name, and the output is the object being heated, changing its state to fulfill task goals like 'heat some egg'.
+---
+# Skill: Heat Object with Appliance
+
+## Purpose
+Heat a specified object using a designated kitchen appliance to change its state (e.g., from cold to hot, raw to cooked) as required by a task.
+
+## Core Workflow
+Follow this sequence of actions. Use the bundled `validate_and_plan.py` script to check for common preconditions before starting.
+
+1. **Navigate & Locate:** Go to the location of the target object.
+2. **Acquire Object:** Take the object from its current receptacle.
+3. **Navigate to Appliance:** Go to the specified heating appliance.
+4. **Prepare Appliance:**
+ * If the appliance is closed, open it.
+ * If the appliance contains other items, you may need to remove them (context-dependent). The default action is to close it and proceed, as some environments abstract this step.
+5. **Execute Heating:** Use the `heat {object} with {appliance}` action.
+6. **Complete Task:** Navigate to the final target location (e.g., a dining table) and put the heated object there.
+
+## Key Decision Points
+* **Appliance State:** If the appliance is occupied, assess if the task implies clearing it. The trajectory shows proceeding without removal is sometimes valid.
+* **Object Location:** The object may not be at the initial location. Be prepared to search other receptacles (e.g., fridge, countertop, cabinet) if not found.
+* **Alternative Appliances:** If the primary appliance (e.g., microwave) is unavailable or broken, consider alternatives like a stoveburner.
+
+## Bundled Resources
+* `scripts/validate_and_plan.py`: A utility to check the initial environment state against the skill's prerequisites.
+* `references/common_heating_appliances.md`: A list of typical appliances and their properties in the ALFWorld environment.
diff --git a/skills/benchmark_skills/alfworld/alfworld-heat-object-with-appliance/references/common_heating_appliances.md b/skills/benchmark_skills/alfworld/alfworld-heat-object-with-appliance/references/common_heating_appliances.md
new file mode 100644
index 0000000..40ac148
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-heat-object-with-appliance/references/common_heating_appliances.md
@@ -0,0 +1,29 @@
+# Common Heating Appliances in ALFWorld
+
+This reference lists typical appliances used for the `heat` action and their common states.
+
+## Primary Appliances
+* **microwave {N}**
+ * **Default State:** Usually closed.
+ * **Preparation:** Often requires opening. May contain other items that need removal.
+ * **Action:** `heat {obj} with microwave {N}`
+* **stoveburner {N}**
+ * **Default State:** Typically off (not toggled).
+ * **Preparation:** May need to be toggled on first (`toggle stoveburner {N}`). Requires a pot or pan for most foods.
+ * **Action:** `heat {obj} with stoveburner {N}` (often requires the object to be in a container).
+
+## Secondary/Alternative Appliances
+* **toaster {N}:** For bread-like items.
+* **oven {N}:** For baking (less common in simple tasks).
+
+## Appliance States & Keywords
+When observing the environment, look for these phrases:
+* `is closed` / `is open`: For microwaves, ovens.
+* `is off` / `is on`: For stoveburners.
+* `In it, you see...`: Indicates contents of an open receptacle.
+* `Nothing happened.`: The previous action was invalid. Re-evaluate the object, appliance, or preconditions.
+
+## Skill Execution Notes
+1. The `heat` action is often an abstraction. You may not need to explicitly place the object inside the appliance first.
+2. If an appliance is occupied, the task may or may not require you to empty it. Use context from the goal description (e.g., "heat some egg" vs. "prepare a meal by heating an egg").
+3. Always verify the object is in your inventory or at the target location after heating.
diff --git a/skills/benchmark_skills/alfworld/alfworld-inventory-management/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-inventory-management/SKILL.md
new file mode 100644
index 0000000..6b696e5
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-inventory-management/SKILL.md
@@ -0,0 +1,32 @@
+---
+name: alfworld-inventory-management
+description: This skill tracks which objects have been collected and which remain to be found for multi-object tasks. It should be triggered when working with tasks requiring multiple instances of the same object type. The skill maintains a count of collected vs. needed objects and guides the search for remaining items.
+---
+# Inventory Management Skill
+
+## When to Use
+Activate this skill when:
+- Task requires collecting **multiple instances** of the same object type (e.g., "put two cellphone in bed")
+- You need to track progress toward a quantity-based goal
+- Searching through multiple locations systematically
+
+## Core Workflow
+
+### 1. Initialize Inventory
+- Parse the task description to identify:
+ - Target object type (e.g., "cellphone")
+ - Required quantity (e.g., "two")
+- Initialize counters: `collected = 0`, `needed = <quantity>`
+- Create empty list for searched locations
+
+### 2. Systematic Search Pattern
+Follow this search priority:
+1. **Visible surfaces** (desks, dressers, beds) - check first
+2. **Closed containers** (drawers, cabinets) - open and inspect
+3. **Return to known locations** if inventory incomplete
+
+**Critical Rule:** After finding an object, immediately place it at the target location before searching for the next one.
+
+### 3. Action Decision Logic
+Use this decision tree:
+
diff --git a/skills/benchmark_skills/alfworld/alfworld-inventory-management/references/common_mistakes.md b/skills/benchmark_skills/alfworld/alfworld-inventory-management/references/common_mistakes.md
new file mode 100644
index 0000000..9abd17c
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-inventory-management/references/common_mistakes.md
@@ -0,0 +1,31 @@
+# Common Mistakes in Multi-Object Collection Tasks
+
+## Analysis from Trajectory Data
+
+### 1. Redundant Searching
+**Mistake:** Checking the same empty container multiple times consecutively
+**Example from trajectory:** After finding cellphones on desk, agent rechecked all drawers
+**Solution:** Maintain search history and skip recently-searched empty locations
+
+### 2. Delayed Placement
+**Mistake:** Continuing search after finding first object instead of placing it immediately
+**Optimal pattern:** Find → Place → Continue search
+**Rationale:** Reduces risk of losing track or dropping object
+
+### 3. Inefficient Search Order
+**Mistake:** Searching all containers before checking visible surfaces
+**Observation:** Cellphones were on desk (visible), but agent searched 5 drawers first
+**Optimal order:** Visible surfaces → Closed containers
+
+### 4. State Management Errors
+**Mistake:** Not closing containers after checking
+**Impact:** Environment clutter, potential for navigation issues
+**Best practice:** Always close containers unless actively retrieving object
+
+### 5. Quantity Confusion
+**Mistake:** Losing count of collected vs. needed items
+**Solution:** Explicit tracking with counters updated on each placement
+
+## Efficiency Patterns Identified
+
+### High-Efficiency Pattern:
diff --git a/skills/benchmark_skills/alfworld/alfworld-locate-target-object/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-locate-target-object/SKILL.md
new file mode 100644
index 0000000..6007f8f
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-locate-target-object/SKILL.md
@@ -0,0 +1,40 @@
+---
+name: alfworld-locate-target-object
+description: This skill navigates to a suspected location and identifies a target object. It should be triggered when the agent's goal requires finding a specific object (e.g., 'potato', 'plate') and its location is not immediately known. The skill involves moving to a relevant receptacle (like a fridge or cabinet) and checking its contents, outputting the object's location or confirming its absence.
+---
+# Skill: Locate Target Object
+
+## Purpose
+Use this skill when your goal requires a specific object and you need to find it. The skill directs you to a likely receptacle, inspects it, and confirms if the target is present.
+
+## Core Workflow
+1. **Identify Target & Suspected Location:** Determine the object you need and the most logical place to find it (e.g., food in the `fridge`, utensils in a `drawer`).
+2. **Navigate:** Go to the suspected receptacle.
+3. **Inspect:** If the receptacle is closed, open it.
+4. **Locate:** Visually scan the contents for the target object.
+5. **Report:** Output the object's location if found, or note its absence.
+
+## Instructions
+Follow this sequence of actions and reasoning.
+
+**Thought:** I need to find a `<target_object>`. The most likely place for it is the `<suspected_receptacle>`.
+**Action:** `go to <suspected_receptacle>`
+
+**Observation:** *[You arrive at the receptacle. It may be open or closed.]*
+
+**Thought:** I am at the `<suspected_receptacle>`. To see inside, I must open it.
+**Action:** `open <suspected_receptacle>`
+
+**Observation:** *[The receptacle opens, revealing its contents.]*
+
+**Thought:** The `<suspected_receptacle>` is open. I will now look for the `<target_object>` among its contents.
+* **If the object is visible:** I have located the `<target_object>` in the `<suspected_receptacle>`. My location task is complete.
+* **If the object is not visible:** The `<target_object>` is not in the `<suspected_receptacle>`. I must consider the next most likely location.
+
+## Key Principles
+* **Contextual Guessing:** Use common sense to guess the initial search location (e.g., `fridge` for perishables, `cabinet` for dry goods).
+* **Sequential Access:** You must `go to` a location before you can `open` it.
+* **Visual Confirmation:** Only trust the `Observation` after opening a receptacle to confirm an object's presence or absence.
+
+## Next Steps
+After successfully locating the object, you will typically need to `take` it or interact with it, which is outside the scope of this skill. If the object is not found, trigger this skill again with a new suspected location.
diff --git a/skills/benchmark_skills/alfworld/alfworld-locate-target-object/references/action_primer.md b/skills/benchmark_skills/alfworld/alfworld-locate-target-object/references/action_primer.md
new file mode 100644
index 0000000..81c0611
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-locate-target-object/references/action_primer.md
@@ -0,0 +1,18 @@
+# Action Primer for ALFWorld
+
+This reference details the core actions used in the `alfworld-locate-target-object` skill.
+
+## Primary Skill Actions
+| Action Format | Purpose | Example in Skill Context |
+| :--- | :--- | :--- |
+| `go to {recep}` | Move the agent to a specific receptacle or appliance. | `go to fridge 1` |
+| `open {recep}` | Open a closed receptacle to see or access its contents. | `open fridge 1` |
+
+## Critical Observation Patterns
+* `The {recep} is closed.` -> You must `open` it.
+* `You open the {recep}. The {recep} is open. In it, you see...` -> The contents are now listed. Scan for your target object.
+* `Nothing happened.` -> The previous action was invalid (e.g., trying to open an already open receptacle). Re-assess the state.
+
+## Object & Receptacle Notation
+* Objects and receptacles have unique identifiers (`potato 1`, `fridge 1`, `cabinet 3`).
+* Always use the full identifier as provided in observations.
diff --git a/skills/benchmark_skills/alfworld/alfworld-location-navigator/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-location-navigator/SKILL.md
new file mode 100644
index 0000000..2fb5424
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-location-navigator/SKILL.md
@@ -0,0 +1,19 @@
+---
+name: alfworld-location-navigator
+description: Moves the agent to a specified receptacle or object location within the Alfworld environment. Use this skill when the agent needs to physically approach a target to inspect or interact with it, such as when checking an object's state or preparing for pickup. The skill takes a target location name as input and executes the 'go to' action, resulting in the agent being positioned at the destination for subsequent operations.
+---
+# Instructions
+Use this skill to navigate to a specific location in the Alfworld environment. The skill will move the agent directly to the target receptacle or object.
+
+## Input
+Provide the target location name as a string (e.g., "toiletpaperhanger 1", "toilet 1").
+
+## Process
+1. The skill validates the target location against the current environment observation.
+2. It executes the `go to {target}` action.
+3. It returns the environment's observation after the move.
+
+## Notes
+- Ensure the target location is visible in the agent's current observation before calling this skill.
+- This skill is for navigation only. Use other skills for object interaction (take, put, etc.).
+- If the action fails (e.g., "Nothing happened"), the agent may need to replan its path or verify the target name.
diff --git a/skills/benchmark_skills/alfworld/alfworld-location-navigator/references/action_primer.md b/skills/benchmark_skills/alfworld/alfworld-location-navigator/references/action_primer.md
new file mode 100644
index 0000000..b5f2b22
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-location-navigator/references/action_primer.md
@@ -0,0 +1,22 @@
+# Alfworld Action Primer
+
+## Core Navigation Action
+The primary action used by this skill is:
+- **`go to {recep}`**: Moves the agent to the specified receptacle or object location.
+
+## Action Format Rules
+1. The action must be output exactly as: `go to <target_name>`
+2. `<target_name>` must match the environment's object naming exactly (e.g., "toiletpaperhanger 1", not "toilet paper hanger").
+3. The agent must be able to see the target in its current observation for the action to succeed.
+
+## Common Navigation Patterns from Trajectory
+1. **Initial Approach**: `go to toiletpaperhanger 1` - Move to inspect a target.
+2. **Object Retrieval Path**: `go to toilet 1` - Move to a location containing a needed object.
+3. **Return for Placement**: `go to toiletpaperhanger 1` - Return to original target after obtaining object.
+
+## Error Handling
+- If the environment responds with "Nothing happened", the `go to` action likely failed because:
+ - The target name was incorrect or misspelled.
+ - The target is not currently visible/accessible from the agent's location.
+ - The target is not a valid receptacle/object for navigation.
+- Recommended response: Re-examine the observation for correct target names and accessible paths.
diff --git a/skills/benchmark_skills/alfworld/alfworld-location-navigator/references/trajectory_analysis.md b/skills/benchmark_skills/alfworld/alfworld-location-navigator/references/trajectory_analysis.md
new file mode 100644
index 0000000..4524a9e
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-location-navigator/references/trajectory_analysis.md
@@ -0,0 +1,22 @@
+# Skill Derivation from Trajectory
+
+## Source Trajectory Summary
+**Task**: Put a toiletpaper in toiletpaperhanger.
+**Successful Navigation Sequence**:
+1. `go to toiletpaperhanger 1` - Initial approach to check state
+2. `go to toilet 1` - Navigate to object source
+3. `go to toiletpaperhanger 1` - Return for final placement
+
+## Extracted Navigation Logic
+1. **Target Identification**: Agent first identifies the target location from the task description.
+2. **State Checking**: Agent navigates to target to inspect current state (empty/full).
+3. **Path Planning**: Based on inspection, agent determines needed object and navigates to its location.
+4. **Return Navigation**: After obtaining object, agent returns to original target.
+
+## Skill Abstraction
+The trajectory shows a repeated pattern of `go to` actions for:
+- Initial target inspection
+- Moving to object sources
+- Returning to placement locations
+
+This pattern is abstracted into the `alfworld-location-navigator` skill that encapsulates the fundamental "move to location" capability used in all three trajectory steps.
diff --git a/skills/benchmark_skills/alfworld/alfworld-navigation-planner/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-navigation-planner/SKILL.md
new file mode 100644
index 0000000..e087570
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-navigation-planner/SKILL.md
@@ -0,0 +1,27 @@
+---
+name: alfworld-navigation-planner
+description: Plans a path to move the agent between receptacles to search for target objects. Use this when you need to traverse the environment to reach a specific location or systematically explore multiple areas. It takes the current location and destination receptacle as input, and outputs the next 'go to' action to approach the target.
+---
+# Instructions
+
+Use this skill to navigate between receptacles (e.g., bed, desk, drawer) in a household environment to locate objects. The core logic is handled by the bundled script.
+
+## Input/Output Format
+- **Input:** Provide the agent's **current location** and the **target receptacle**.
+- **Output:** The skill will return the next `go to {recep}` action to execute.
+
+## How to Use
+1. **Identify your goal.** Determine which receptacle you need to search (e.g., `desk 1` to find a `desklamp`).
+2. **Call the skill.** Pass your current location and the target receptacle.
+3. **Execute the action.** Perform the `go to` action returned by the skill.
+4. **Observe and repeat.** After moving, observe the new location. If the target object is not found, use this skill again to plan movement to the next most promising receptacle.
+
+## Key Principles
+- **Systematic Search:** Move efficiently between likely receptacles instead of random exploration.
+- **Adaptive Planning:** If an action fails ("Nothing happened"), the script's logic helps choose an alternative path.
+- **Context Preservation:** Always note your current location after each move for the next planning step.
+
+**Example Thought Process:**
+> Thought: I need to find a desklamp. The `desk 1` is a likely location. I am currently at `bed 1`.
+> Action: Use `alfworld-navigation-planner` with current location `bed 1` and target `desk 1`.
+> Result: `go to desk 1`
diff --git a/skills/benchmark_skills/alfworld/alfworld-navigation-planner/references/action_primer.md b/skills/benchmark_skills/alfworld/alfworld-navigation-planner/references/action_primer.md
new file mode 100644
index 0000000..c30894f
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-navigation-planner/references/action_primer.md
@@ -0,0 +1,33 @@
+# ALFWorld Action Primer
+
+## Core Action Set
+The agent can perform the following atomic actions. The `{obj}` and `{recep}` placeholders must be replaced with specific object and receptacle names observed in the environment.
+
+1. `go to {recep}` - Move to a specified receptacle (e.g., `go to desk 1`).
+2. `take {obj} from {recep}` - Pick up an object from a receptacle.
+3. `put {obj} in/on {recep}` - Place an object into or onto a receptacle.
+4. `open {recep}` - Open a closed receptacle (e.g., a drawer).
+5. `close {recep}` - Close an open receptacle.
+6. `toggle {obj} {recep}` - Toggle the state of an object (e.g., turn on a lamp).
+7. `clean {obj} with {recep}` - Clean an object using a receptacle/tool.
+8. `heat {obj} with {recep}` - Heat an object using a receptacle/tool.
+9. `cool {obj} with {recep}` - Cool an object using a receptacle/tool.
+
+## Navigation-Specific Guidance
+- The `go to` action is the primary movement command.
+- Receptacles are fixed locations (`desk 1`, `shelf 1`) or containers (`drawer 2`).
+- Before interacting with an object on a receptacle, you must first `go to` that receptacle.
+- If an action fails with "Nothing happened", the target may be invalid, inaccessible, or require a prerequisite action (e.g., `open` before `take` from a closed drawer).
+
+## Common Receptacle Types & Associations
+| Receptacle | Typical Contents |
+|---------------|-----------------------------------------------|
+| `desk 1` | desklamp, book, laptop, pen |
+| `bed 1` | pillow, book, cellphone |
+| `sidetable 1` | alarm clock, CD, keychain |
+| `shelf 1` | pen, book |
+| `drawer 1/2` | CD, credit card, small items |
+| `garbagecan 1`| (often empty) |
+
+## Response Format
+The agent must always output its reasoning and action in the following strict format:
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-cooler/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-object-cooler/SKILL.md
new file mode 100644
index 0000000..306da10
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-cooler/SKILL.md
@@ -0,0 +1,29 @@
+---
+name: alfworld-object-cooler
+description: This skill cools a held object using an appropriate cooling appliance, such as a fridge. It should be triggered when the task requires reducing the temperature of an object (e.g., a hot pot). The skill assumes the agent is holding the object and is near the cooling receptacle; it performs the 'cool' action to achieve the desired state change, preparing the object for subsequent steps like placement or serving.
+---
+# Skill: Cool Held Object
+
+## Purpose
+Use this skill when you are holding an object (e.g., `pot 1`) that needs to be cooled and you are at the location of a valid cooling receptacle (e.g., `fridge 1`). The skill executes the `cool` action to change the object's state.
+
+## Prerequisites
+1. **Object in Hand:** You must already be holding the target object (e.g., `pot 1`).
+2. **At Cooling Receptacle:** You must be at the location of the cooling appliance (e.g., `fridge 1`). Use `go to {recep}` to navigate first if needed.
+3. **Valid Receptacle:** The receptacle must be a valid target for the `cool` action (e.g., fridge, freezer). The environment will validate this.
+
+## Core Action
+Execute the `cool` action with the format: `cool {obj} with {recep}`.
+
+## Execution Flow
+1. **Verify State:** Confirm you are holding the object and are at the cooling receptacle's location.
+2. **Execute:** Perform the `cool` action.
+3. **Verify Outcome:** The expected observation is "You cool the {obj} using the {recep}." If the observation is "Nothing happened," the action was invalid—check the prerequisites or try a different receptacle.
+
+## Example from Trajectory
+* **State:** Holding `pot 1`, at `fridge 1`.
+* **Action:** `cool pot 1 with fridge 1`
+* **Result:** Observation: "You cool the pot 1 using the fridge 1."
+
+## Next Steps
+After successful cooling, the object is ready for the next task step (e.g., `put {obj} in/on {recep}`).
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-cooler/references/action_semantics.md b/skills/benchmark_skills/alfworld/alfworld-object-cooler/references/action_semantics.md
new file mode 100644
index 0000000..8c1f910
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-cooler/references/action_semantics.md
@@ -0,0 +1,25 @@
+# Action Semantics for 'cool'
+
+## Definition
+The `cool {obj} with {recep}` action reduces the temperature of a held object (`{obj}`) by interacting with a cooling appliance (`{recep}`).
+
+## Semantics from Trajectory
+* **Agent State:** The agent must be holding `{obj}`.
+* **Location:** The agent must be at the location of `{recep}`. The trajectory shows the agent at `fridge 1` before executing `cool pot 1 with fridge 1`.
+* **Receptacle State:** The receptacle (e.g., `fridge 1`) does not necessarily need to be open. The trajectory executed the action successfully while the fridge was closed.
+* **Object State:** The object is assumed to be in a state where cooling is a valid operation (e.g., a hot pot).
+
+## Expected Outcomes
+1. **Success:** "You cool the {obj} using the {recep}." This indicates the object's state has changed.
+2. **Failure (Invalid Action):** "Nothing happened." This indicates a prerequisite was not met (wrong object, wrong location, invalid receptacle).
+
+## Common Valid Receptacles
+* `fridge 1`
+* `freezer 1`
+* (Other environment-specific cooling appliances)
+
+## Related Actions
+* `heat {obj} with {recep}`: The inverse operation.
+* `take {obj} from {recep}`: To acquire the object.
+* `go to {recep}`: To navigate to the cooling appliance.
+* `put {obj} in/on {recep}`: Likely the next step after cooling.
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-disposer/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-object-disposer/SKILL.md
new file mode 100644
index 0000000..68fbb7c
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-disposer/SKILL.md
@@ -0,0 +1,20 @@
+---
+name: alfworld-object-disposer
+description: This skill disposes of an object by placing it into a disposal receptacle like a garbage can. It should be triggered when the task requires discarding an object (e.g., 'put it in garbagecan') and the agent is at the disposal location with the object in hand. The skill executes the 'put' action to place the object in/on the target receptacle, completing the disposal subtask.
+---
+# Skill: Object Disposer
+
+## Trigger Condition
+Activate this skill when:
+1. The task goal explicitly requires disposing of an object (e.g., "put it in garbagecan", "throw away the X").
+2. The agent is holding the target object.
+3. The agent is at the location of the disposal receptacle (e.g., garbagecan).
+
+## Execution
+1. **Verify Prerequisites**: Confirm the object is in hand and the disposal receptacle is present at your location.
+2. **Execute Disposal**: Perform the `put` action with the object and receptacle.
+3. **Completion**: The skill is complete when the object has been successfully placed into/onto the disposal receptacle.
+
+## Notes
+- This skill handles only the final disposal action. Object acquisition and navigation to the disposal location are separate skills.
+- If the disposal fails (e.g., "Nothing happened"), re-evaluate the object and receptacle identifiers or check if the receptacle can accept the object.
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-disposer/references/alfworld_actions.md b/skills/benchmark_skills/alfworld/alfworld-object-disposer/references/alfworld_actions.md
new file mode 100644
index 0000000..aa0e412
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-disposer/references/alfworld_actions.md
@@ -0,0 +1,23 @@
+# AlfWorld Action Reference for Disposal
+
+## Relevant Action Template
+`put {obj} in/on {recep}`
+
+## Description
+Places an object into or onto a receptacle. For disposal tasks, the receptacle is typically a `garbagecan`.
+
+## Preconditions
+1. The agent must be holding the object (`{obj}`).
+2. The agent must be at the location of the receptacle (`{recep}`).
+3. The receptacle must be accessible (e.g., not inside a closed container).
+
+## Common Disposal Receptacles
+- `garbagecan`
+- `sinkbasin` (for liquid disposal)
+- `toilet` (if available in the environment)
+
+## Error Handling
+If the action fails and returns "Nothing happened":
+1. Verify the object identifier is correct and matches an object in inventory.
+2. Verify the receptacle identifier is correct and present.
+3. Ensure the receptacle can accept the object (some receptacles may have capacity limits).
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-disposer/references/trajectory_pattern.md b/skills/benchmark_skills/alfworld/alfworld-object-disposer/references/trajectory_pattern.md
new file mode 100644
index 0000000..bb97aa7
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-disposer/references/trajectory_pattern.md
@@ -0,0 +1,18 @@
+# Trajectory Pattern Analysis
+
+## Skill Context in Provided Trajectory
+The disposal action occurs as the final step in a larger task sequence:
+
+1. **Task Goal**: "cool some potato and put it in garbagecan"
+2. **Skill Trigger**: The subtask "put it in garbagecan" matches this skill's purpose.
+3. **Prerequisite Steps** (handled by other skills):
+ - Locate and acquire object: `go to diningtable 1`, `take potato 3 from diningtable 1`
+ - Process object if needed: `cool potato 3 with fridge 1`
+ - Navigate to disposal location: `go to garbagecan 1`
+4. **Skill Execution**: `put potato 3 in/on garbagecan 1`
+
+## Key Observations
+- The disposal action is simple and atomic once prerequisites are met.
+- No additional manipulation of the receptacle (opening/closing) is needed for garbagecan.
+- The skill completes immediately after successful execution.
+- The trajectory shows successful disposal with no intermediate steps between arrival at garbagecan and the put action.
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-heater/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-object-heater/SKILL.md
new file mode 100644
index 0000000..f2b310f
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-heater/SKILL.md
@@ -0,0 +1,31 @@
+---
+name: alfworld-object-heater
+description: This skill heats a specified object using an available heating appliance (e.g., microwave, stove). Activate this skill when the agent has an object that requires heating and the appliance is prepared. It requires the object and appliance as inputs and results in the object being heated.
+---
+# Skill: Heat Object
+
+## Purpose
+Use this skill to heat a specified object (e.g., potato, soup) using a compatible heating appliance (e.g., microwave, stove) in the ALFWorld environment. The skill handles the sequence of navigation, preparation, and operation of the appliance.
+
+## Prerequisites
+1. **Object in Inventory:** The target object must be in the agent's possession (e.g., recently taken from a receptacle).
+2. **Appliance Available:** A compatible heating appliance (microwave, stoveburner) must be present and accessible in the environment.
+3. **Appliance State:** The appliance must be in a state ready for heating (e.g., microwave door open, stove burner available).
+
+## Core Workflow
+Follow this high-level sequence. For detailed, error-prone steps (like checking appliance state), use the bundled script.
+
+1. **Navigate** to the target heating appliance.
+2. **Prepare** the appliance (e.g., open the microwave door).
+3. **Execute** the heating action on the object using the appliance.
+4. **(Optional) Navigate** to a target location (e.g., dining table) to place the heated object.
+
+## Key Decision Points
+* **Appliance Selection:** Choose the most appropriate appliance based on the object and context (e.g., use a microwave for quick heating, a stove for cooking).
+* **Error Recovery:** If an action fails ("Nothing happened"), re-evaluate the appliance's state (is it open? is it free?) or your inventory (do you have the object?).
+* **Post-Heating Action:** Decide if the heated object should be placed elsewhere (e.g., on a dining table) as part of the task.
+
+## Important Notes
+* The `heat` action requires the object to be in your inventory and the appliance to be ready.
+* Always verify the observation after each action to confirm success before proceeding.
+* Refer to the bundled reference for a detailed breakdown of the example trajectory and common pitfalls.
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-heater/references/trajectory_breakdown.md b/skills/benchmark_skills/alfworld/alfworld-object-heater/references/trajectory_breakdown.md
new file mode 100644
index 0000000..9bee4a4
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-heater/references/trajectory_breakdown.md
@@ -0,0 +1,29 @@
+# Trajectory Breakdown & Common Pitfalls
+
+## Example Trajectory Analysis
+The provided successful trajectory for heating a potato and placing it on a dining table follows this pattern:
+
+1. **Locate & Acquire Object:** `go to garbagecan 1` -> `take potato 3 from garbagecan 1`
+2. **Navigate to Appliance:** `go to microwave 1`
+3. **Prepare Appliance:** `open microwave 1` (Observation: "The microwave 1 is open.")
+4. **Execute Heating:** `heat potato 3 with microwave 1` (Observation: "You heat the potato 3 using the microwave 1.")
+5. **Deliver Object (Task Specific):** `go to diningtable 1` -> `put potato 3 in/on diningtable 1`
+
+## Critical Observations & Lessons
+
+1. **State Verification is Key:** After `open microwave 1`, the observation confirmed "The microwave 1 is open. In it, you see nothing." This confirms the appliance is ready for the `heat` action.
+2. **Error Pattern - Premature Closing:** The trajectory shows an erroneous step: after opening the microwave, the agent issued `close microwave 1` without placing the object, which would have made the next `heat` action fail. The correct sequence is **open -> heat**.
+3. **Inventory Requirement:** The `heat` action (`heat potato 3 with microwave 1`) only succeeded because the potato was in the agent's inventory (`You pick up the potato 3 from the garbagecan 1.`). You cannot heat an object that is still in a receptacle.
+4. **"Nothing Happened" Response:** This is the environment's signal for an invalid action. If you receive this after a `heat` command, check:
+ * Is the appliance open/on?
+ * Is the target object in your inventory?
+ * Is the appliance compatible with the object?
+
+## Action Template
+The core heating action follows this strict template:
+`heat {object_id} with {appliance_id}`
+
+## Compatible Appliances
+* `microwave {n}`
+* `stoveburner {n}`
+* (Potentially other heating receptacles like `oven` in other scenarios)
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-locator/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-object-locator/SKILL.md
new file mode 100644
index 0000000..1f3f6c6
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-locator/SKILL.md
@@ -0,0 +1,22 @@
+---
+name: alfworld-object-locator
+description: This skill scans the current environment observation to identify the presence and location of a target object needed for a task. It should be triggered when the agent's goal requires an object that is not currently in the agent's inventory, and the observation does not explicitly state where the object is. The skill analyzes the textual observation to find receptacles that likely contain the target, based on common sense or domain knowledge (e.g., a 'dishsponge' might be on a 'cart'), and outputs the identified target receptacle location for navigation.
+---
+# Skill: Object Locator for ALFWorld
+
+## When to Use
+Trigger this skill when:
+1. Your goal requires a specific object
+2. The object is not in your inventory
+3. The current observation does not explicitly state the object's location
+
+## Core Logic
+1. **Parse Observation**: Extract all mentioned receptacles from the environment description
+2. **Analyze Likelihood**: Use common-sense reasoning to rank receptacles where the target object is most likely to be found
+3. **Output Action**: Generate a navigation action to the most promising receptacle
+
+## Quick Reference
+- For detailed object-receptacle mappings, see `references/object_mappings.md`
+- For the core location algorithm, see `scripts/locate_object.py`
+
+## Basic Usage Pattern
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-locator/references/object_mappings.md b/skills/benchmark_skills/alfworld/alfworld-object-locator/references/object_mappings.md
new file mode 100644
index 0000000..ef571c3
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-locator/references/object_mappings.md
@@ -0,0 +1,40 @@
+# Object-Receptacle Common-Sense Mappings
+
+## Kitchen & Dining Objects
+| Object | Most Likely Receptacles | Reasoning |
+|--------|------------------------|-----------|
+| dishsponge | cart, sinkbasin, countertop | Cleaning items often stored near sinks or on cleaning carts |
+| soapbottle | sinkbasin, countertop, shelf | Hygiene products near water sources |
+| plate | countertop, shelf, cart | Food service items on surfaces |
+| cup | countertop, shelf, cart | Drinkware on accessible surfaces |
+| bowl | countertop, shelf, cart | Food containers on surfaces |
+| spoon | drawer, countertop, sinkbasin | Utensils in drawers or near washing areas |
+| fork | drawer, countertop, sinkbasin | Utensils in drawers or near washing areas |
+| knife | drawer, countertop, sinkbasin | Utensils in drawers (safety) |
+
+## Bathroom Objects
+| Object | Most Likely Receptacles | Reasoning |
+|--------|------------------------|-----------|
+| toiletpaper | toiletpaperhanger, shelf, countertop | Paper products near toilet or in storage |
+| handtowel | handtowelholder, towelholder, shelf | Towels on designated holders |
+| soapbottle | bathtubbasin, sinkbasin, countertop | Cleaning products near water sources |
+
+## Cleaning Supplies
+| Object | Most Likely Receptacles | Reasoning |
+|--------|------------------------|-----------|
+| dishsponge | cart, sinkbasin, shelf | On cleaning carts or near sinks |
+| towel | towelholder, shelf, cart | On holders or in storage |
+| spraybottle | shelf, countertop, cart | Cleaning solutions on surfaces |
+
+## General Storage Patterns
+1. **Drawers**: Small items, utensils, personal items
+2. **Shelves**: General storage, containers, supplies
+3. **Countertops**: Frequently used items, in-progress tasks
+4. **Carts**: Mobile storage, cleaning supplies, transport items
+5. **Holders**: Designated for specific items (towels, paper)
+
+## ALFWorld Specific Notes
+- Objects often have numbers (e.g., "cart 1", "drawer 2")
+- Receptacle names are concatenated (e.g., "bathtubbasin", "sinkbasin")
+- Observations list receptacles before objects on them
+- "On the [receptacle], you see..." indicates visible objects
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-locator/references/skill_usage_examples.md b/skills/benchmark_skills/alfworld/alfworld-object-locator/references/skill_usage_examples.md
new file mode 100644
index 0000000..0d4e3c5
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-locator/references/skill_usage_examples.md
@@ -0,0 +1,39 @@
+# Skill Usage Examples
+
+## Example 1: Basic Location (from trajectory)
+**Observation**: "You are in the middle of a room. Looking quickly around you, you see a bathtubbasin 1, a cart 1, a countertop 1, a drawer 4, a drawer 3, a drawer 2, a drawer 1, a garbagecan 1, a handtowelholder 1, a shelf 1, a sinkbasin 1, a toilet 1, a toiletpaperhanger 1, and a towelholder 1."
+
+**Goal**: "put some dishsponge on toilet"
+
+**Agent Thought**: "I need to find the dishsponge. Let me scan the environment for likely locations."
+
+**Skill Output**: "go to cart 1"
+
+**Reasoning**: Dishsponge is mapped to 'cart' in common-sense knowledge, and cart is present in the observation.
+
+## Example 2: Multiple Possible Locations
+**Observation**: "You see a countertop 1, a sinkbasin 1, a shelf 2, a shelf 1, and a drawer 1."
+
+**Goal**: "get a spoon"
+
+**Skill Output**: "go to drawer 1"
+
+**Reasoning**: Spoon is strongly associated with drawers in the mappings.
+
+## Example 3: No Clear Match
+**Observation**: "You see a toilet 1, a bathtubbasin 1, and a towelholder 1."
+
+**Goal**: "find a plate"
+
+**Skill Output**: None (or "Observation: Target object not found in visible receptacles")
+
+**Reasoning**: Plate typically appears in kitchen areas (countertop, shelf, cart), none of which are present.
+
+## Example 4: Visible Object
+**Observation**: "On the countertop 1, you see a plate 1, a cup 1, and a spoon 1."
+
+**Goal**: "take the spoon"
+
+**Skill Not Needed**: The object is already visible in the observation, so no location scanning is required.
+
+## Integration Pattern
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-picker/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-object-picker/SKILL.md
new file mode 100644
index 0000000..93b6448
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-picker/SKILL.md
@@ -0,0 +1,19 @@
+---
+name: alfworld-object-picker
+description: Picks up a specified object from a given receptacle. Use this skill when the agent has located a required object and needs to acquire it for later use, such as taking an item from a surface or container. The skill requires the object and source receptacle as inputs, executing a 'take' action to transfer the object into the agent's inventory, enabling further manipulation like placement or usage.
+---
+# Instructions
+Execute the `take` action to acquire the target object from the source receptacle.
+
+## Inputs
+- `object`: The identifier of the object to pick up (e.g., "toiletpaper 1").
+- `source_receptacle`: The identifier of the receptacle where the object is located (e.g., "toilet 1").
+
+## Process
+1. **Verify Context:** Ensure the agent is at the location of the `source_receptacle`. If not, the agent must navigate there first using a separate movement skill.
+2. **Execute Action:** Perform the action: `take {object} from {source_receptacle}`.
+3. **Handle Feedback:** If the environment indicates "Nothing happened," consult the troubleshooting guide in `references/troubleshooting.md` for potential issues.
+
+## Output
+- The specified object is transferred to the agent's inventory.
+- The agent receives an observation confirming the successful pickup (e.g., "You pick up the {object} from the {source_receptacle}").
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-picker/references/troubleshooting.md b/skills/benchmark_skills/alfworld/alfworld-object-picker/references/troubleshooting.md
new file mode 100644
index 0000000..e6d558d
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-picker/references/troubleshooting.md
@@ -0,0 +1,9 @@
+# Troubleshooting: Failed Pickup Actions
+
+If the `take` action results in "Nothing happened," consider the following common issues:
+
+1. **Agent Position:** The agent must be at the same location as the source receptacle. Verify your location using the last observation.
+2. **Object Visibility:** The object must be visible on the receptacle. Check the last observation for a list of items on the `source_receptacle`.
+3. **Object Name:** Ensure the `object` identifier matches exactly the name shown in the observation (e.g., "toiletpaper 1" not "toiletpaper").
+4. **Receptacle State:** Some receptacles (like cabinets) may need to be opened before their contents can be accessed.
+5. **Inventory Limit:** The agent may have a limited carrying capacity. Ensure you are not already holding the maximum number of items.
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-placer/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-object-placer/SKILL.md
new file mode 100644
index 0000000..7ccebec
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-placer/SKILL.md
@@ -0,0 +1,19 @@
+---
+name: alfworld-object-placer
+description: Places a held object onto or into a target receptacle. Trigger this skill when the agent is carrying an object and needs to deposit it at a specific location to complete a task, such as installing an item on a holder or storing it in a container. It takes the object and destination receptacle as inputs, performing a 'put' action to finalize the object's positioning according to the task goal.
+---
+# Instructions
+1. **Verify Prerequisites**:
+ - Confirm you are currently holding the target object (`{obj}`).
+ - Confirm the target receptacle (`{recep}`) is present and accessible in the environment.
+ - If the receptacle is a container (e.g., cabinet, drawer), ensure it is open.
+
+2. **Navigate to Receptacle**:
+ - Use the `go to {recep}` action to move to the target receptacle's location.
+
+3. **Execute Placement**:
+ - Use the `put {obj} in/on {recep}` action to deposit the held object.
+ - The phrasing (`in` vs `on`) is determined by the receptacle type (e.g., `in` for containers, `on` for surfaces/holders). Use the trajectory as a reference.
+
+4. **Handle Errors**:
+ - If the environment responds with "Nothing happened", the action was invalid. Consult the `references/action_guide.md` for troubleshooting common failure modes.
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-placer/references/action_guide.md b/skills/benchmark_skills/alfworld/alfworld-object-placer/references/action_guide.md
new file mode 100644
index 0000000..aa6ddf3
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-placer/references/action_guide.md
@@ -0,0 +1,39 @@
+# AlfWorld Action Guide for Object Placement
+
+## Core Action
+`put {obj} in/on {recep}`
+
+## Preposition Rules
+Use the following guide to choose `in` or `on`:
+
+### Use `in` for:
+- Enclosed containers: `cabinet`, `fridge`, `microwave`, `drawer`, `garbagecan`, `box`, `shelf` (if it has walls).
+- Receptacles that hold items internally.
+
+### Use `on` for:
+- Surfaces: `countertop`, `desk`, `table`, `shelf` (open).
+- Holders: `toiletpaperhanger`, `towelholder`, `handtowelholder`, `plateholder`.
+- Appliances: `stoveburner`, `toaster`.
+
+## Common Failure Modes & Solutions
+1. **"Nothing happened" on `put` action:**
+ - **Cause 1:** The agent is not holding the specified `{obj}`.
+ - *Solution:* Use `take {obj} from {source_recep}` first.
+ - **Cause 2:** The `{recep}` is closed or inaccessible.
+ - *Solution:* Use `open {recep}` before placing the object inside.
+ - **Cause 3:** The preposition (`in`/`on`) is incorrect for the receptacle type.
+ - *Solution:* Consult the table above and try the alternative preposition.
+ - **Cause 4:** The receptacle is already occupied/full.
+ - *Solution:* Clear the receptacle first (e.g., remove existing objects).
+
+2. **Object not found for pickup:**
+ - Search common locations: countertops, tables, shelves, cabinets, and other receptacles relevant to the object's type (e.g., toilet paper is often near a toilet).
+
+## Example from Trajectory
+**Goal:** Put a toiletpaper in toiletpaperhanger.
+**Successful Sequence:**
+1. `go to toiletpaperhanger 1` (Verify it's empty)
+2. `go to toilet 1` (Locate object)
+3. `take toiletpaper 1 from toilet 1` (Acquire object)
+4. `go to toiletpaperhanger 1` (Navigate to target)
+5. `put toiletpaper 1 on toiletpaperhanger 1` (Execute placement - uses 'on' for a holder)
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-retriever/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-object-retriever/SKILL.md
new file mode 100644
index 0000000..e2ca941
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-retriever/SKILL.md
@@ -0,0 +1,14 @@
+---
+name: alfworld-object-retriever
+description: This skill picks up a target object from a specified receptacle after the object has been visually confirmed. Use this skill when the agent has located an object in a receptacle and needs to acquire it. It requires the object and source receptacle as inputs and results in the object being added to the agent's inventory.
+---
+# Instructions
+
+Use this skill to acquire a target object from a known source receptacle in the ALFWorld environment.
+
+## Prerequisites
+1. **Visual Confirmation**: You must have directly observed the target object within the specified source receptacle in a prior observation (e.g., "On the {recep}, you see a {obj}...").
+2. **Proximity**: You should be at or near the location of the source receptacle.
+
+## Core Action Sequence
+Execute the following action precisely:
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-retriever/references/trajectory_example.md b/skills/benchmark_skills/alfworld/alfworld-object-retriever/references/trajectory_example.md
new file mode 100644
index 0000000..01a0ad0
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-retriever/references/trajectory_example.md
@@ -0,0 +1,19 @@
+# Full Task Trajectory Example
+
+This reference document contains the complete execution trajectory from which the `alfworld-object-retriever` skill was derived. It demonstrates the skill's use in context.
+
+## Original Task
+**Goal**: "heat some potato and put it in diningtable."
+
+## Relevant Skill Execution Segment
+1. **Observation**: "On the garbagecan 1, you see a egg 2, a potato 3, and a soapbottle 1."
+ *This provides the visual confirmation required for the skill.*
+2. **Thought**: "I've found a potato in the garbage can. I should take it so I can heat it up."
+ *The agent recognizes the prerequisite is met and plans to use the skill.*
+3. **Action**: `take potato 3 from garbagecan 1`
+ *This is the exact skill execution.*
+4. **Observation**: "You pick up the potato 3 from the garbagecan 1."
+ *This confirms successful skill execution. The object (`potato 3`) is now in the agent's inventory.*
+
+## Key Insight
+The skill is a discrete, atomic operation within a larger task chain. Its sole purpose is to transfer a visually confirmed object from a known receptacle into the agent's inventory. It does not handle object search, navigation, or subsequent actions like heating or placing.
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-state-inspector/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-object-state-inspector/SKILL.md
new file mode 100644
index 0000000..0efd3dc
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-state-inspector/SKILL.md
@@ -0,0 +1,30 @@
+---
+name: alfworld-object-state-inspector
+description: Checks the current state or contents of a specified object or receptacle. Trigger this skill when the agent needs to determine if an object is present, missing, or in a certain condition before proceeding with a task, such as verifying if a holder is empty or if an item is available. It typically follows navigation and involves observing the environment's feedback, providing crucial information for decision-making in the task flow.
+---
+# Instructions
+
+Use this skill to inspect the state of a target object or receptacle in an AlfWorld household environment. The primary goal is to obtain the observation feedback from the environment about what is currently on or in the target.
+
+## When to Trigger
+Trigger this skill immediately after navigating to a target receptacle (e.g., `go to toiletpaperhanger 1`) when you need to know:
+* If the target is empty.
+* What specific objects are present on/in the target.
+* The condition or state of the target (implied by the environment's observation).
+
+## Core Procedure
+1. **Navigate to Target:** First, ensure the agent has executed a `go to {target_receptacle}` action. This skill assumes the agent is already at the target's location.
+2. **Observe Environment Feedback:** The skill is complete once the environment provides an observation in response to the navigation. **Do not perform an additional inspection action.** The observation from the `go to` action contains the state information.
+3. **Parse Observation:** Interpret the observation message (e.g., "On the toiletpaperhanger 1, you see nothing." or "On the toilet 1, you see a soapbottle 1, and a toiletpaper 1.").
+4. **Output Decision Data:** Based on the observation, determine the next step in the broader task (e.g., "Target is empty, proceed to find item" or "Target contains required item, proceed to pick it up").
+
+## Input/Output Format
+* **Input Context:** The agent must be at the target location. The last action should be `go to {target_receptacle}`.
+* **Output:** The observation string from the environment and a brief interpretation.
+ * **Example Output:** `Observation: On the toiletpaperhanger 1, you see nothing. | Interpretation: The holder is empty. A toiletpaper roll must be found elsewhere.`
+
+## Error Handling
+* If the observation is "Nothing happened," the previous `go to` action was likely invalid. Re-evaluate the target's name or location.
+* This skill does not involve actions like `open`, `close`, or `toggle`. It relies solely on the observational feedback from navigation.
+
+**Key Principle:** This skill encapsulates the **waiting and parsing** of the environment's state disclosure after navigation. It provides the critical information needed to decide the subsequent `take`, `put`, or further `go to` action.
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-state-inspector/references/alfworld_actions_ref.md b/skills/benchmark_skills/alfworld/alfworld-object-state-inspector/references/alfworld_actions_ref.md
new file mode 100644
index 0000000..28f6c7f
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-state-inspector/references/alfworld_actions_ref.md
@@ -0,0 +1,28 @@
+# AlfWorld Action Reference for State Inspection
+
+## Relevant Actions for This Skill
+This skill is used in conjunction with the `go to` action. The inspection is performed by the environment's feedback *after* a successful navigation.
+
+**Primary Pre-condition Action:**
+* `go to {recep}` - Moves the agent to a specific receptacle. The subsequent observation reveals the receptacle's state.
+
+## Observation Patterns
+The environment responds to `go to {recep}` with one of the following patterns:
+
+1. **Empty Receptacle:**
+ * `On the {recep}, you see nothing.`
+ * *Interpretation:* The target is empty. The required object is not here.
+
+2. **Populated Receptacle:**
+ * `On the {recep}, you see a {obj1} {id1}{, and a {objN} {idN}}*.`
+ * *Examples:*
+ * `On the toilet 1, you see a soapbottle 1, and a toiletpaper 1.`
+ * `On the countertop 1, you see a mug 1.`
+ * *Interpretation:* The target contains the listed object(s). The IDs (e.g., `1`) are important for subsequent `take` or `put` actions.
+
+3. **Invalid Action:**
+ * `Nothing happened.`
+ * *Interpretation:* The previous `go to` action failed. The receptacle name may be incorrect, or the agent cannot path to it.
+
+## Skill Integration in Task Flow
+A typical task sequence involving this skill:
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-state-modifier/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-object-state-modifier/SKILL.md
new file mode 100644
index 0000000..9da402f
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-state-modifier/SKILL.md
@@ -0,0 +1,31 @@
+---
+name: alfworld-object-state-modifier
+description: This skill uses an appliance to change the state of an object (e.g., cooling, heating, cleaning). It should be triggered when the task requires altering an object's temperature or cleanliness using a specific device (like cooling with a fridge or heating with a microwave). The skill requires the object, the target state, and the appliance as inputs, and executes the corresponding modifier action (e.g., 'cool X with Y').
+---
+# Instructions
+
+## When to Use
+Use this skill when the task requires you to **change the state of an object** using a specific household appliance. The primary actions are:
+- **Cool** an object (e.g., with a fridge).
+- **Heat** an object (e.g., with a microwave or stove).
+- **Clean** an object (e.g., with a sink).
+
+## Core Procedure
+1. **Locate & Acquire Object:** First, navigate to and pick up the target object.
+2. **Navigate to Appliance:** Go to the appliance required for the state change (e.g., `fridge 1`, `microwave 1`).
+3. **Prepare Appliance (if needed):** Some appliances require preparation (e.g., opening a fridge or microwave door). Perform the necessary `open` or `toggle` action.
+4. **Execute State Change:** Perform the core modifier action: `cool {obj} with {appliance}`, `heat {obj} with {appliance}`, or `clean {obj} with {appliance}`.
+5. **Complete Task:** After the state is changed, proceed with the next task step (e.g., placing the object elsewhere).
+
+## Key Considerations
+- **Invalid Actions:** If the environment responds with "Nothing happened," your action was invalid. Consult the `references/appliance_interaction_guide.md` for troubleshooting.
+- **Appliance State:** Always check if an appliance is open/closed/on/off before attempting the modifier action.
+- **Object Holding:** You must be holding the target object (`{obj}`) before executing the state change action.
+
+## Inputs Required
+- `{obj}`: The specific object identifier (e.g., `tomato 1`).
+- `{target_state}`: The desired state change (`cool`, `heat`, or `clean`).
+- `{appliance}`: The specific appliance identifier (e.g., `fridge 1`).
+
+## Output Action
+The skill's final output is a single, formatted action string: `{target_state} {obj} with {appliance}`.
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-state-modifier/references/appliance_interaction_guide.md b/skills/benchmark_skills/alfworld/alfworld-object-state-modifier/references/appliance_interaction_guide.md
new file mode 100644
index 0000000..2d5bd63
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-state-modifier/references/appliance_interaction_guide.md
@@ -0,0 +1,42 @@
+# Appliance Interaction Guide
+
+This guide details the prerequisites and common issues for using appliances to modify object states.
+
+## Core Modifier Actions
+The following actions are directly supported by the skill:
+- `cool {obj} with {appliance}`
+- `heat {obj} with {appliance}`
+- `clean {obj} with {appliance}`
+
+## Appliance-Specific Protocols
+
+### Refrigerator (`fridge`)
+* **Purpose:** Cooling objects.
+* **Typical Prerequisites:**
+ * The fridge does **not** need to be open to perform the `cool` action externally.
+ * You must be holding the object.
+ * You must be at the fridge's location (`go to fridge 1`).
+* **Common Error:** Attempting `cool` from a distance or without the object.
+
+### Microwave (`microwave`)
+* **Purpose:** Heating objects.
+* **Typical Prerequisites:**
+ * The microwave usually must be **open** to place an object inside *before* heating.
+ * The `heat` action may be performed after the object is placed inside (`put {obj} in/on microwave 1`).
+* **Note:** The trajectory shows `heat` as the modifier action. Placing an object inside is a separate step (`put`).
+
+### Sink (`sinkbasin`)
+* **Purpose:** Cleaning objects.
+* **Typical Prerequisites:**
+ * You must be at the sink.
+ * You must be holding the object.
+* **Common Error:** Attempting to clean an object that is not dirty or using the wrong receptacle.
+
+## Troubleshooting "Nothing happened"
+If the environment returns "Nothing happened" after your modifier action, check this list:
+
+1. **Object in Hand?** Verify you have successfully taken the object (`take {obj} from {recep}`).
+2. **Correct Location?** Verify you are at the appliance (`go to {appliance}`).
+3. **Appliance State?** For microwaves/ovens, ensure they are open if required. For stoves, ensure the burner is toggled on.
+4. **Valid Combination?** Ensure the appliance can perform the requested state change (e.g., you cannot `heat` with a fridge).
+5. **Action Syntax?** Double-check the action format: `{state} {obj} with {appliance}`. Spelling and spacing matter.
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-storer/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-object-storer/SKILL.md
new file mode 100644
index 0000000..7317695
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-storer/SKILL.md
@@ -0,0 +1,34 @@
+---
+name: alfworld-object-storer
+description: This skill places an object into a selected storage receptacle after confirming its suitability. It should be triggered when the agent has identified an appropriate storage location and is ready to complete the storage task. The skill takes the object and target receptacle as inputs and results in the object being stored.
+---
+# Skill: Object Storer
+
+## Purpose
+This skill orchestrates the final step of storing a clean object into a designated receptacle within a household environment. It is triggered after the agent has:
+1. Located the target object.
+2. Cleaned the object if required.
+3. Identified and validated a suitable storage location.
+
+## Core Logic
+The skill performs a final suitability check and executes the storage action. The core decision is:
+- **If the receptacle is open and empty (or appropriately designated)**, proceed with storage.
+- **If the receptacle is closed**, open it first, then store the object.
+- **If the receptacle is unsuitable** (e.g., already contains unrelated items), the agent should abort this skill and search for an alternative location.
+
+## Inputs & Execution
+- **Primary Inputs:** `{object_name}`, `{target_receptacle}`
+- **Prerequisite State:** The agent must be holding the clean `{object_name}` and be at the location of the `{target_receptacle}`.
+- **Action:** Execute the `put {object_name} in/on {target_receptacle}` command.
+
+## Example from Trajectory
+**Scenario:** Storing a clean knife.
+1. **Trigger Condition:** Agent is holding `knife 1` (cleaned) and has determined `drawer 1` is a suitable, empty storage location.
+2. **Skill Execution:**
+ - Agent is at `drawer 1`.
+ - Observation: `On the drawer 1, you see nothing.`
+ - **Action:** `put knife 1 in/on drawer 1`
+
+## Error Handling
+- If the environment responds with "Nothing happened," the action was invalid. Consult the `receptacle_suitability_guide.md` reference and restart the search process.
+- Do not use this skill if the receptacle contains items that conflict with the object's storage norms (e.g., putting a knife in a drawer full of spoons).
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-storer/references/receptacle_suitability_guide.md b/skills/benchmark_skills/alfworld/alfworld-object-storer/references/receptacle_suitability_guide.md
new file mode 100644
index 0000000..337b706
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-storer/references/receptacle_suitability_guide.md
@@ -0,0 +1,25 @@
+# Receptacle Suitability Guide
+
+## Derived from Execution Trajectory
+This guide summarizes the decision logic for selecting a storage receptacle, based on the observed agent behavior.
+
+## Core Principles
+1. **Primary Storage:** Drawers are the primary candidate for storing utensils like knives, forks, and spoons.
+2. **Suitability Check Protocol:**
+ a. **Go to** the candidate receptacle.
+ b. If closed, **open** it.
+ c. **Observe contents.**
+ d. **Evaluate:**
+ - **Empty:** Suitable for storage. Proceed with the `alfworld-object-storer` skill.
+ - **Contains Similar Items:** May be suitable (e.g., a spoon in a drawer could indicate a utensil drawer). Use context to decide.
+ - **Contains Unrelated Items:** Likely unsuitable. Close the receptacle and continue searching.
+ e. If unsuitable, **close** the receptacle before leaving.
+
+## Common Receptacle Types & Heuristics
+- **Drawers (1-N):** Default search location for cutlery and small kitchen tools. Search sequentially.
+- **Countertops:** Typically are **not** storage locations. They are surfaces for temporary placement.
+- **Cabinets:** Potential for larger item storage. Not explored in the base trajectory but follow the same check protocol.
+- **Sinkbasin:** A cleaning location, **not** a storage location.
+- **Dining Table:** A surface for items in use, **not** for permanent storage.
+
+## Flowchart for Decision Making
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-transporter/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-object-transporter/SKILL.md
new file mode 100644
index 0000000..6e05bb6
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-transporter/SKILL.md
@@ -0,0 +1,37 @@
+---
+name: alfworld-object-transporter
+description: This skill picks up a target object from its current receptacle and moves it to a specified destination receptacle. It should be triggered when the agent has located an object and needs to relocate it to complete a task (e.g., moving a laptop to a desk). The skill requires the object identifier and source location as input, and it outputs the action sequence to take and transport the object.
+---
+# Instructions
+
+## When to Use
+Use this skill when you have:
+1. **Identified the target object** (e.g., `laptop 1`) and its **current source receptacle** (e.g., `bed 2`).
+2. **Identified the destination receptacle** (e.g., `desk 1`).
+3. The goal requires moving the object to the destination to complete a task.
+
+## Input Requirements
+You must provide the following information to execute this skill:
+- **`target_object`**: The identifier of the object to move (e.g., `laptop 1`).
+- **`source_receptacle`**: The identifier of the receptacle where the object is currently located (e.g., `bed 2`).
+- **`destination_receptacle`**: The identifier of the receptacle where the object must be placed (e.g., `desk 1`).
+
+## Execution Flow
+1. **Navigate to Source**: Go to the `source_receptacle`.
+2. **Pick Up Object**: Take the `target_object` from the `source_receptacle`.
+3. **Navigate to Destination**: Go to the `destination_receptacle`.
+4. **Place Object**: Put the `target_object` in/on the `destination_receptacle`.
+
+## Action Format
+All actions must follow the Alfworld environment's strict format:
+- `go to {receptacle}`
+- `take {object} from {receptacle}`
+- `put {object} in/on {receptacle}`
+
+## Error Handling
+- If an action fails (environment returns "Nothing happened"), consult the troubleshooting guide in `references/troubleshooting.md`.
+- If the object or receptacle is not found, re-scan the environment before retrying.
+
+## Bundled Resources
+- **Script**: `scripts/transport_sequence.py` provides a deterministic sequence generator.
+- **Reference**: `references/troubleshooting.md` contains common failure patterns and solutions.
diff --git a/skills/benchmark_skills/alfworld/alfworld-object-transporter/references/troubleshooting.md b/skills/benchmark_skills/alfworld/alfworld-object-transporter/references/troubleshooting.md
new file mode 100644
index 0000000..717a77c
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-object-transporter/references/troubleshooting.md
@@ -0,0 +1,34 @@
+# Troubleshooting Guide
+
+## Common Failure Patterns
+
+### 1. "Nothing happened" after `go to {receptacle}`
+- **Cause**: The receptacle identifier may be incorrect or the agent is not close enough.
+- **Solution**:
+ - Verify the receptacle name from the latest observation.
+ - Ensure you are using the exact identifier (e.g., `sidetable 1` not `side table 1`).
+ - If multiple receptacles exist, try the closest one first.
+
+### 2. "Nothing happened" after `take {object} from {receptacle}`
+- **Cause**:
+ - The object is not on the specified receptacle.
+ - The object identifier is incorrect.
+ - The object is not takeable.
+- **Solution**:
+ - Re-examine the observation for the receptacle's contents.
+ - Confirm the object exists and is spelled correctly.
+ - Try taking a different instance (e.g., `laptop 2` if `laptop 1` fails).
+
+### 3. "Nothing happened" after `put {object} in/on {receptacle}`
+- **Cause**:
+ - The destination receptacle is full or does not accept the object.
+ - The agent is not holding the object.
+- **Solution**:
+ - Check if the destination has capacity (e.g., not already holding many items).
+ - Verify the agent successfully picked up the object in the previous step.
+ - Try a different destination receptacle if the task allows.
+
+## Best Practices
+1. **Always validate inputs**: Cross-check object and receptacle names with the latest observation.
+2. **Order matters**: Execute actions in the sequence order (go → take → go → put).
+3. **Handle variants**: Some tasks may require `put {object} in {receptacle}` vs. `on {receptacle}`. Use the preposition that matches the destination type (e.g., `in` for containers, `on` for surfaces).
diff --git a/skills/benchmark_skills/alfworld/alfworld-open-receptacle/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-open-receptacle/SKILL.md
new file mode 100644
index 0000000..708d2e4
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-open-receptacle/SKILL.md
@@ -0,0 +1,30 @@
+---
+name: alfworld-open-receptacle
+description: This skill opens a closed receptacle to access its contents. It should be triggered when an agent needs to interact with items inside a closed container (e.g., fridge, microwave, drawer). The skill takes a receptacle identifier as input, performs the open action, and outputs the observation of the interior, enabling subsequent item retrieval or placement.
+---
+# Skill: Open Receptacle
+
+## Purpose
+Open a closed container to reveal its contents for subsequent interaction.
+
+## When to Use
+Use this skill when:
+- You need to take an item from inside a closed receptacle
+- You need to put an item into a closed receptacle
+- You observe a receptacle is closed (e.g., "The fridge 1 is closed")
+- The task requires accessing items inside containers
+
+## Input Format
+The skill requires a receptacle identifier as input. This should match the environment's naming convention (e.g., "fridge 1", "microwave 1", "drawer 3").
+
+## Execution Steps
+1. **Verify receptacle state**: Check if the receptacle is mentioned as "closed" in the observation
+2. **Navigate to receptacle**: Use `go to {recep}` if not already at the location
+3. **Execute open action**: Use `open {recep}` where `{recep}` is the receptacle identifier
+4. **Process result**: The environment will respond with the interior contents or an error
+
+## Expected Outcomes
+- **Success**: Observation showing the receptacle is open and listing contained items
+- **Failure**: "Nothing happened" indicates the action was invalid (e.g., already open, wrong identifier)
+
+## Example from Trajectory
diff --git a/skills/benchmark_skills/alfworld/alfworld-open-receptacle/receptors/action_sequence_examples.md b/skills/benchmark_skills/alfworld/alfworld-open-receptacle/receptors/action_sequence_examples.md
new file mode 100644
index 0000000..8ea82be
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-open-receptacle/receptors/action_sequence_examples.md
@@ -0,0 +1,5 @@
+# Action Sequence Examples
+
+## Successful Opening Sequences
+
+### Example 1: Opening Fridge
diff --git a/skills/benchmark_skills/alfworld/alfworld-open-receptacle/references/common_receptacles.md b/skills/benchmark_skills/alfworld/alfworld-open-receptacle/references/common_receptacles.md
new file mode 100644
index 0000000..ed325e1
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-open-receptacle/references/common_receptacles.md
@@ -0,0 +1,73 @@
+# Common Receptacles in ALFWorld Environment
+
+## Overview
+This document lists common receptacle types found in ALFWorld household environments and their typical contents.
+
+## Kitchen Receptacles
+
+### Refrigeration
+- **fridge 1**: Cold storage for perishable items
+ - Typical contents: vegetables, fruits, dairy, meats
+ - Example: potato, tomato, plate, milk
+
+### Cooking Appliances
+- **microwave 1**: For heating food
+ - May contain: previously heated items
+ - Example: apple, mug, plate
+
+### Storage
+- **cabinet 1-9**: General storage
+ - Contents vary: dishes, food packages, utensils
+- **drawer 1-13**: Smaller storage
+ - Often contains: utensils, small items
+ - Example: fork, spoon, knife
+
+### Countertops
+- **countertop 1-2**: Surface areas
+ - May hold: various objects temporarily
+ - Not typically "opened" but can hold items
+
+## Living/Bedroom Receptacles
+- **desk 1**: Work surface with drawers
+- **sidetable 1-2**: Small tables with storage
+- **dresser 1**: Clothing storage
+
+## Bathroom Receptacles
+- **cabinetbath 1**: Bathroom storage
+- **drawerbath 1**: Bathroom drawer
+
+## Opening Mechanics
+
+### States
+1. **Closed**: Cannot see contents, must open first
+2. **Open**: Contents visible, can interact with items
+3. **Locked**: Requires key or specific action (rare)
+
+### Action Requirements
+- Most receptacles require `open {receptacle}` before accessing contents
+- Some may be initially open
+- Closing is optional but can be done with `close {receptacle}`
+
+### Special Cases
+- **toaster 1**: May require toggling rather than opening
+- **coffeemachine 1**: May have specific interaction sequences
+- **garbagecan 1**: Usually open, but may have lid
+
+## Best Practices
+
+### Before Opening
+1. Verify you are at the receptacle location
+2. Check observation for "closed" status
+3. Ensure no conflicting actions needed first
+
+### After Opening
+1. Note all visible items
+2. Check if target item is present
+3. Plan next action (take, put, etc.)
+
+### Error Recovery
+If "Nothing happened" when trying to open:
+1. Re-read observation - receptacle might already be open
+2. Check spelling of receptacle identifier
+3. Verify you're at correct location
+4. Try alternative approach if applicable
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-closer/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-receptacle-closer/SKILL.md
new file mode 100644
index 0000000..76a4612
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-closer/SKILL.md
@@ -0,0 +1,21 @@
+---
+name: alfworld-receptacle-closer
+description: Closes an open receptacle to maintain environment tidiness after inspection. Trigger this after you have finished searching a container and no longer need it open. It helps prevent clutter and is often used as a cleanup step following object searching inside drawers or similar containers.
+---
+# Skill: Receptacle Closer
+
+## When to Use
+Use this skill **immediately after** you have finished inspecting the contents of an open receptacle (e.g., a drawer, cabinet, or container) and have determined you no longer need it to remain open. This is a cleanup action to maintain a tidy environment.
+
+## Core Instruction
+1. **Identify the Target:** The target is the receptacle you just finished searching. It must be open.
+2. **Execute Action:** Perform the `close` action on the identified receptacle.
+3. **Format:** Your output must follow the standard action format: `Action: close {recep}`
+
+## Example from Trajectory
+* **Context:** After opening and inspecting `drawer 2` (finding it empty), the agent closed it.
+* **Thought:** "I should close drawer 2 to keep the room tidy and continue my search."
+* **Action:** `close drawer 2`
+
+## Key Principle
+This is a low-cognitive-load, procedural step. Do not overthink it. If you opened a receptacle to look inside and are done with it, close it.
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-closer/references/action_primer.md b/skills/benchmark_skills/alfworld/alfworld-receptacle-closer/references/action_primer.md
new file mode 100644
index 0000000..b6c9a0d
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-closer/references/action_primer.md
@@ -0,0 +1,22 @@
+# ALFWorld Action Primer for Receptacle Closing
+
+## Available Actions Context
+The agent operates with a discrete set of actions. The relevant action for this skill is:
+- `close {recep}`: Closes the specified receptacle if it is currently open.
+
+## Common Receptacle Types
+* `drawer #`
+* `cabinet #`
+* `fridge #`
+* `microwave #`
+* `box #`
+* `washingmachine #`
+
+## Trajectory Logic Extract
+The skill is derived from the following step in the provided trajectory:
+1. Agent opened `drawer 2` to inspect contents.
+2. Agent observed contents (`nothing`).
+3. Agent's **Thought** explicitly stated the tidiness rationale: *"I should close drawer 2 to keep the room tidy and continue my search."*
+4. Agent executed **Action:** `close drawer 2`.
+
+This demonstrates the skill's trigger condition: **post-inspection cleanup**.
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-finder/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-receptacle-finder/SKILL.md
new file mode 100644
index 0000000..76dbebf
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-finder/SKILL.md
@@ -0,0 +1,24 @@
+---
+name: alfworld-receptacle-finder
+description: This skill searches for a suitable empty or appropriately occupied receptacle (like a shelf) to place an object. It should be triggered when the agent needs to store or place an object and must evaluate available receptacles. The skill examines candidate receptacles and identifies one meeting the placement criteria.
+---
+# Instructions
+
+**Trigger:** Use this skill when you have an object in your inventory that needs to be stored or placed, and you must find a suitable receptacle (e.g., shelf, table, basin).
+
+## Core Procedure
+1. **Identify Target Object:** Confirm the object you are holding and its state (e.g., `soapbar 1`, `clean`).
+2. **Survey Environment:** Use `go to {recep}` actions to navigate to and visually inspect candidate receptacles from the observation list.
+3. **Evaluate Candidates:** For each receptacle, assess its suitability:
+ * **Primary Goal:** Find an **empty receptacle**.
+ * **Fallback:** If no empty receptacle is available, identify one that can logically accommodate the object without conflict (e.g., a shelf with a tissuebox may still have space for a soapbar).
+4. **Select & Place:** Navigate to the chosen suitable receptacle and execute `put {obj} in/on {recep}`.
+
+## Key Considerations
+* **Object State:** Ensure the object meets any required pre-conditions (e.g., `clean`) before searching for a receptacle. Use skills like `clean` if necessary.
+* **Efficiency:** Prioritize receptacles that are logically appropriate for the object (e.g., a `shelf` for a `soapbar` over a `toilet`).
+* **Observation Parsing:** Carefully read the observation after each `go to` action. The line "On the {recep}, you see..." lists its contents. "you see nothing." indicates it is empty.
+* **Invalid Actions:** If an action fails ("Nothing happened"), re-evaluate your target and try a different receptacle or confirm the object is in your inventory.
+
+## Example Trajectory (from `references/example_trajectory.md`)
+For a detailed example of this skill in action, including handling object pre-cleaning and sequential shelf evaluation, refer to the bundled reference.
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-finder/references/example_trajectory.md b/skills/benchmark_skills/alfworld/alfworld-receptacle-finder/references/example_trajectory.md
new file mode 100644
index 0000000..3f71a16
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-finder/references/example_trajectory.md
@@ -0,0 +1,18 @@
+# Example Execution: Placing a Clean Soapbar
+
+This document provides a reference trajectory demonstrating the `alfworld-receptacle-finder` skill.
+
+**Task:** `put a clean soapbar in shelf.`
+
+**Agent Trajectory:**
+1. **Locate Object:** The agent first finds a `soapbar 1` on the `toilet 1` and takes it.
+2. **Pre-condition Check:** The agent ensures the soapbar is `clean` by using the `sinkbasin 1`.
+3. **Receptacle Search Initiated:** The skill is triggered. The agent begins surveying shelves.
+ * `go to shelf 1`: Observation shows `tissuebox 1`. Not empty, but could be a fallback.
+ * `go to shelf 2`: Observation shows `nothing`. **Suitable empty receptacle found.**
+4. **Placement:** The agent executes `put soapbar 1 in/on shelf 2`, completing the task.
+
+**Key Skill Behaviors Demonstrated:**
+* **Sequential Inspection:** The agent checked shelves in order (`shelf 1`, then `shelf 2`).
+* **Empty Receptacle Priority:** `shelf 2` was chosen because it was empty, satisfying the primary goal.
+* **Integration with Pre-conditions:** The cleaning step was performed *before* the receptacle search, ensuring the object state ("clean soapbar") was correct.
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-navigator/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-receptacle-navigator/SKILL.md
new file mode 100644
index 0000000..8f8e815
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-navigator/SKILL.md
@@ -0,0 +1,28 @@
+---
+name: alfworld-receptacle-navigator
+description: This skill plans and executes movement to a target receptacle within the environment. It should be triggered when the agent needs to interact with an object at a specific location (e.g., go to fridge to cool an item) or needs to access a receptacle itself (e.g., go to garbagecan to dispose of an item). The skill uses the receptacle name from the observation or task goal, outputs the 'go to' action, and confirms arrival at the destination.
+---
+# Skill: Receptacle Navigator
+
+## Purpose
+Navigate to a specified receptacle (e.g., `fridge 1`, `garbagecan 1`, `diningtable 1`) in an ALFWorld household environment. This is a foundational skill for positioning the agent to perform subsequent object interactions.
+
+## When to Use
+Trigger this skill when the agent's plan requires:
+1. **Accessing a location** to interact with an object there (e.g., "go to fridge to cool an item").
+2. **Interacting with the receptacle itself** (e.g., "go to garbagecan to dispose of an item").
+
+## Core Logic
+1. **Input Parsing:** Extract the target receptacle name (e.g., `fridge 1`) from the current task context or observation.
+2. **Action Execution:** Output the ALFWorld action: `go to {target_receptacle}`.
+3. **Success Verification:** Confirm the action was successful by checking the observation for evidence of arrival (e.g., "You are at the {receptacle}" or the receptacle is now in the observable list).
+
+## Instructions
+1. Identify the target receptacle from the goal or current observation.
+2. Execute the `go to` action.
+3. If the environment responds with "Nothing happened", the action was invalid. Consult the `references/common_receptacles.md` list and the latest observation to formulate a new `go to` target.
+4. Upon successful navigation, proceed with the next skill in the plan (e.g., `alfworld-object-interactor`).
+
+## Error Handling
+- **Invalid Target:** If "Nothing happened" is observed, the receptacle may be unreachable or incorrectly named. Re-analyze the scene description to find a valid path or alternative receptacle.
+- **Already at Location:** If the observation indicates you are already at the target, skip the `go to` action and proceed.
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-navigator/references/common_receptacles.md b/skills/benchmark_skills/alfworld/alfworld-receptacle-navigator/references/common_receptacles.md
new file mode 100644
index 0000000..89a556a
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-navigator/references/common_receptacles.md
@@ -0,0 +1,21 @@
+# Common ALFWorld Receptacles
+This is a non-exhaustive list of receptacle types commonly found in ALFWorld environments. Use this for reference when parsing scene observations.
+
+## Primary Storage & Surfaces
+* `cabinet {#}`
+* `countertop {#}`
+* `diningtable {#}`
+* `drawer {#}`
+* `shelf {#}` (if present)
+
+## Appliances
+* `coffeemachine {#}`
+* `fridge {#}`
+* `microwave {#}`
+* `safe {#}`
+* `sinkbasin {#}`
+* `stoveburner {#}`
+* `toaster {#}`
+
+## Other
+* `garbagecan {#}`
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-opener/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-receptacle-opener/SKILL.md
new file mode 100644
index 0000000..ef9678f
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-opener/SKILL.md
@@ -0,0 +1,24 @@
+---
+name: alfworld-receptacle-opener
+description: This skill opens a closed receptacle to allow access to its contents or to enable interaction with it. It should be triggered when the agent encounters a closed receptacle (e.g., 'The fridge 1 is closed.') that must be opened to proceed with a task, such as cooling an item with a fridge or taking an object from inside a cabinet. The skill outputs the 'open' action on the specified receptacle.
+---
+# Skill: Open Closed Receptacle
+
+## Trigger Condition
+Use this skill when the environment observation explicitly states that a receptacle is **closed** and opening it is necessary to proceed with your current task. The typical observation pattern is: `"The <receptacle_name> is closed."`
+
+## Action
+Execute the `open` action on the identified receptacle.
+
+## Procedure
+1. **Identify the Receptacle:** From the observation, extract the name of the closed receptacle (e.g., `fridge 1`, `cabinet 12`, `safe 1`).
+2. **Execute Action:** Output the action in the format: `Action: open <receptacle_name>`.
+
+## Example from Trajectory
+* **Observation:** `"The fridge 1 is closed."`
+* **Thought:** `The fridge is closed. I need to open it to access the cooling compartment.`
+* **Action:** `Action: open fridge 1`
+
+## Notes
+* This is a fundamental, low-level skill for enabling access. After opening the receptacle, you may need to use other skills (e.g., `take`, `cool`, `put`) to complete your objective.
+* Do not use this skill if the receptacle is already described as open or if its state is not mentioned.
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-operator/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-receptacle-operator/SKILL.md
new file mode 100644
index 0000000..6ad757c
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-operator/SKILL.md
@@ -0,0 +1,36 @@
+---
+name: alfworld-receptacle-operator
+description: This skill opens or closes a receptacle (like a fridge, cabinet, or microwave) to access its interior or secure it. It should be triggered when an object needs to be placed inside/retrieved from a closed container, or when an open container should be closed (e.g., for energy efficiency or task cleanliness). The skill decides the appropriate 'open' or 'close' action based on the receptacle's current state and the task context.
+---
+# Skill: Receptacle Operator
+
+## When to Use
+Use this skill when you need to:
+1. **Access a closed receptacle** to place an object inside or take an object out.
+2. **Secure an open receptacle** after accessing it (e.g., to conserve energy, maintain cleanliness, or complete a task step).
+
+## Core Decision Logic
+1. **Check the receptacle's state** from the observation.
+ - If it reports "is closed" or "is open", note the state.
+ - If the interior is visible (e.g., "In it, you see..."), it is open.
+2. **Choose action based on goal**:
+ - **Goal requires interior access** (e.g., "put in microwave", "take from fridge"):
+ - If closed → `open {recep}`
+ - If open → proceed with next step (e.g., `put` or `take`)
+ - **Goal requires securing receptacle** (e.g., after accessing, or for efficiency):
+ - If open → `close {recep}`
+ - If closed → no action needed
+3. **Execute the action** using the exact format: `Action: open {recep}` or `Action: close {recep}`
+
+## Example from Trajectory
+- **Task**: "cool some tomato and put it in microwave"
+- **Step 1**: At closed fridge → `Action: open fridge 1`
+- **Step 2**: After checking interior → `Action: close fridge 1` (for efficiency)
+- **Step 3**: At closed microwave → `Action: open microwave 1`
+
+## Important Notes
+- Always verify the receptacle state from the latest observation before acting.
+- The skill only handles `open` and `close` actions. Other actions (like `take`, `put`, `cool`) are separate skills.
+- If "Nothing happened" is observed after your action, the receptacle may already be in that state—re-check and adjust.
+
+For detailed state diagrams and edge cases, see the reference documentation.
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-operator/references/state_diagrams.md b/skills/benchmark_skills/alfworld/alfworld-receptacle-operator/references/state_diagrams.md
new file mode 100644
index 0000000..f4c1ec6
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-operator/references/state_diagrams.md
@@ -0,0 +1,3 @@
+# Receptacle State Diagrams & Edge Cases
+
+## Primary State Transitions
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-preparer/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-receptacle-preparer/SKILL.md
new file mode 100644
index 0000000..6a6fe88
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-preparer/SKILL.md
@@ -0,0 +1,30 @@
+---
+name: alfworld-receptacle-preparer
+description: This skill verifies and prepares a target receptacle for receiving an object. It is triggered before placing an item into a receptacle (e.g., a garbage can) to ensure the receptacle is accessible and suitable. The skill involves navigating to the receptacle, observing its state (e.g., open/closed, occupied), and performing any necessary preparatory actions like opening it, resulting in a ready-to-use target location.
+---
+# Instructions
+
+**Trigger:** This skill is invoked when the agent's goal requires placing an object into a target receptacle (e.g., "put X in/on Y").
+
+## Core Procedure
+1. **Navigate:** Use `go to {target_receptacle}` to move to the target receptacle's location.
+2. **Observe:** Upon arrival, carefully read the environment's observation. It will describe the receptacle's state and any contents.
+3. **Analyze & Prepare:** Based on the observation, determine if the receptacle is ready.
+ * **Ready State:** The receptacle is described as present and accessible (e.g., "On the garbagecan 1, you see a cd 1."). No further action is needed. Proceed to place the object.
+ * **Blocked/Closed State:** If the receptacle is closed, latched, or obstructed, use the appropriate action (`open {recep}`, `toggle {obj} {recep}`) to prepare it.
+ * **Invalid Target:** If the observation indicates the receptacle does not exist or cannot be interacted with ("Nothing happened"), you must abort this skill and re-plan your task strategy.
+4. **Confirm:** After any preparatory action, observe the environment's feedback to confirm the receptacle is now ready.
+
+## Key Principles
+* **Efficiency:** This skill is a preparatory step. Do not spend turns searching for the object to be placed here. That is a separate "search" skill.
+* **Context:** The observation text is your only source of truth about the receptacle's state. Interpret it literally.
+* **Idempotency:** If the receptacle is already ready, this skill completes immediately with no action required beyond observation.
+
+## Example from Trajectory
+**Goal Context:** "find two pen and put them in garbagecan."
+**Skill Execution:**
+1. Thought: "I'll check the garbage can first to ensure it's open and ready to receive items."
+2. Action: `go to garbagecan 1`
+3. Observation: "On the garbagecan 1, you see a cd 1."
+4. Analysis: The garbage can is present and accessible (a CD inside does not block new items). It is **ready**.
+5. Outcome: Skill completes. The agent proceeds to `put pen 3 in/on garbagecan 1`.
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-preparer/references/action_primer.md b/skills/benchmark_skills/alfworld/alfworld-receptacle-preparer/references/action_primer.md
new file mode 100644
index 0000000..00a23bd
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-preparer/references/action_primer.md
@@ -0,0 +1,22 @@
+# ALFWorld Action Reference
+
+This document lists the core actions available to the agent, as defined in the trajectory. Use this for quick reference.
+
+## Action List
+1. `go to {recep}` - Move to a specified receptacle.
+2. `take {obj} from {recep}` - Pick up an object from a receptacle.
+3. `put {obj} in/on {recep}` - Place an object into or onto a receptacle.
+4. `open {recep}` - Open a closed receptacle (e.g., drawer, fridge).
+5. `close {recep}` - Close an open receptacle.
+6. `toggle {obj} {recep}` - Activate a toggleable object (e.g., lightswitch, stove).
+7. `clean {obj} with {recep}` - Clean an object using a receptacle/tool.
+8. `heat {obj} with {recep}` - Heat an object using a receptacle/appliance.
+9. `cool {obj} with {recep}` - Cool an object using a receptacle/appliance.
+
+## For Receptacle Preparation
+The most critical actions for this skill are:
+* `go to {target_receptacle}`: Essential for step 1.
+* `open {target_receptacle}`: The primary preparatory action if the receptacle is found closed.
+* `toggle {obj} {recep}`: May be needed for certain electronic or latch mechanisms.
+
+**Note:** The `{obj}` and `{recep}` placeholders must be replaced with the exact nouns observed in the environment (e.g., `garbagecan 1`, `sidetable 2`, `pen 3`).
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-searcher/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-receptacle-searcher/SKILL.md
new file mode 100644
index 0000000..8bf9417
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-searcher/SKILL.md
@@ -0,0 +1,31 @@
+---
+name: alfworld-receptacle-searcher
+description: This skill searches for a specific receptacle (e.g., garbage can, cabinet) by systematically exploring the environment, checking multiple locations until found. Trigger when the target receptacle is not initially visible, often after scanning nearby areas. It outputs the receptacle's location and may involve navigating through multiple waypoints.
+---
+# Instructions
+
+## When to Use
+Use this skill when you need to locate a specific receptacle (e.g., `garbagecan 1`, `cabinet 3`) that is not immediately visible in your current observation. The skill is triggered after an initial scan of nearby areas fails to reveal the target.
+
+## Core Procedure
+1. **Identify Target**: Confirm the exact name of the receptacle you need to find (e.g., from the task: "put a cool lettuce in garbagecan" -> target is `garbagecan 1`).
+2. **Initial Check**: Quickly examine the most common or nearby receptacles mentioned in the initial observation (e.g., countertops, tables, open cabinets).
+3. **Systematic Search**: If not found, begin a systematic exploration:
+ - Use the `go to {recep}` action to navigate to candidate locations.
+ - Prioritize receptacles that are typically in the environment (cabinets, countertops, tables).
+ - If a candidate is closed (e.g., "The cabinet 2 is closed."), you may skip opening it unless the target could logically be inside. The trajectory shows that the target receptacle (`garbagecan 1`) was not inside any closed cabinet.
+4. **Persistence**: Continue the search until the target is found. The trajectory demonstrates checking 20 cabinets before finally locating the garbage can.
+5. **Output**: Once found, note the receptacle's location and state (e.g., "On the garbagecan 1, you see nothing."). You are now ready to use this receptacle for the next task action (e.g., `put lettuce 1 in/on garbagecan 1`).
+
+## Key Notes
+- **Efficiency**: The search pattern in the trajectory was exhaustive (checking all cabinets 1-20). In practice, you might infer likely locations based on receptacle type (e.g., a garbage can is often standalone, not inside a cabinet).
+- **Error Handling**: If an action returns "Nothing happened", the receptacle may not be accessible or may require a different approach (e.g., opening first).
+- **Integration**: This skill outputs the found receptacle's identifier. It does not perform the final task action (e.g., putting an item in the receptacle); that is handled by the main task orchestration.
+
+## Example from Trajectory
+**Goal**: Find `garbagecan 1`.
+**Process**:
+1. Checked `countertop 1`, `diningtable 1`, `diningtable 2` (not found).
+2. Systematically went to `cabinet 1` through `cabinet 20` (all closed, not found).
+3. Finally went directly to `garbagecan 1` (found).
+**Output**: Location of `garbagecan 1` confirmed.
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-searcher/assets/search_pattern_template.json b/skills/benchmark_skills/alfworld/alfworld-receptacle-searcher/assets/search_pattern_template.json
new file mode 100644
index 0000000..d6caa36
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-searcher/assets/search_pattern_template.json
@@ -0,0 +1,43 @@
+{
+ "skill_name": "alfworld-receptacle-searcher",
+ "purpose": "Template for generating a systematic search pattern for a target receptacle.",
+ "parameters": {
+ "target_receptacle": {
+ "type": "string",
+ "description": "The name of the receptacle to find (e.g., 'garbagecan 1')."
+ },
+ "initial_observation": {
+ "type": "string",
+ "description": "The initial environment description containing a list of receptacles."
+ },
+ "search_strategy": {
+ "type": "string",
+ "enum": ["exhaustive", "smart"],
+ "default": "exhaustive",
+ "description": "'exhaustive' checks all known receptacles; 'smart' uses heuristics to prioritize likely locations."
+ }
+ },
+ "output": {
+ "actions": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "pattern": "^go to [a-zA-Z0-9]+ [0-9]+$"
+ },
+ "description": "A list of 'go to' actions to execute in order."
+ },
+ "found_at": {
+ "type": "string",
+ "description": "The receptacle where the target was found (if known)."
+ }
+ },
+ "example": {
+ "target_receptacle": "garbagecan 1",
+ "initial_observation": "You are in the middle of a room. Looking quickly around you, you see a cabinet 1, a cabinet 2, a countertop 1, a garbagecan 1.",
+ "search_strategy": "exhaustive",
+ "output": {
+ "actions": ["go to cabinet 1", "go to cabinet 2", "go to countertop 1", "go to garbagecan 1"],
+ "found_at": "garbagecan 1"
+ }
+ }
+}
diff --git a/skills/benchmark_skills/alfworld/alfworld-receptacle-searcher/references/environment_guide.md b/skills/benchmark_skills/alfworld/alfworld-receptacle-searcher/references/environment_guide.md
new file mode 100644
index 0000000..6aeec2b
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-receptacle-searcher/references/environment_guide.md
@@ -0,0 +1,29 @@
+# ALFWorld Environment Guide for Receptacle Searching
+
+## Overview
+This document provides context about the ALFWorld environment to aid in receptacle searching. It is intended to be loaded into the agent's context when needed.
+
+## Common Receptacle Types
+1. **Cabinets (cabinet 1-20)**: Often closed; may contain items. The garbage can is typically not inside a cabinet.
+2. **Countertops (countertop 1, 2)**: Usually open surfaces with items placed on them.
+3. **Tables (diningtable 1, 2)**: Similar to countertops.
+4. **Appliances**: Fridge, microwave, stoveburner, toaster, coffeemachine.
+5. **Containers**: Drawer 1-6, sinkbasin, garbagecan.
+
+## Search Heuristics
+- **Garbage Can**: Often a standalone receptacle (`garbagecan 1`). It is usually not inside another receptacle. In the trajectory, it was found by going directly to it after checking many cabinets.
+- **Cabinets**: If the target is a cabinet, you may need to open it first (`open cabinet X`).
+- **Efficiency**: When searching for a receptacle that is likely to be in the open (e.g., garbage can, countertop), prioritize checking open surfaces first before enclosed spaces.
+
+## Action Set (from Trajectory)
+The available actions relevant to searching:
+- `go to {recep}`: Navigate to a receptacle.
+- `open {recep}`: Open a closed receptacle (e.g., cabinet, fridge).
+- `close {recep}`: Close an open receptacle.
+
+## Observation Patterns
+- "On the {recep}, you see ...": The receptacle is open and has items.
+- "The {recep} is closed.": The receptacle is closed; you may need to open it to see inside.
+- "Nothing happened.": The action was invalid (e.g., trying to go to a non-existent receptacle).
+
+## Example Trajectory Snippet
diff --git a/skills/benchmark_skills/alfworld/alfworld-search-pattern-executor/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-search-pattern-executor/SKILL.md
new file mode 100644
index 0000000..215bb56
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-search-pattern-executor/SKILL.md
@@ -0,0 +1,35 @@
+---
+name: alfworld-search-pattern-executor
+description: Systematically searches a sequence of likely locations for a target object based on common sense. Takes a list of candidate receptacles, orchestrates navigation and inspection, and outputs when the target is found or all locations are exhausted.
+---
+# Skill: Systematic Object Search
+
+## Purpose
+Use this skill when you need to find a specific object in a household environment without prior knowledge of its exact location. The skill implements a robust search pattern based on common sense about where objects are typically stored.
+
+## Core Workflow
+1. **Input:** A target object name (e.g., `remotecontrol`) and an ordered list of candidate receptacles to search.
+2. **Process:** Navigate to each candidate location in sequence. For each receptacle:
+ * If it's closed, open it.
+ * Inspect its contents.
+ * If the target object is found, take it and proceed to the placement phase.
+ * If the receptacle was opened and is empty, close it before moving on.
+3. **Output:** Success when the object is found, or a failure state after all candidates are exhausted.
+
+## Key Principles
+* **Methodical Search:** Do not skip locations in the provided sequence unless the object is found.
+* **State Management:** Always close drawers/cabinets after checking them if they were opened.
+* **Focus:** Once the object is found, immediately transition to the next phase of the task (e.g., `put`). Avoid redundant searches.
+* **Error Handling:** If an action fails (e.g., "Nothing happened"), the skill logic in `scripts/search_orchestrator.py` provides fallback reasoning.
+
+## Usage Example
+**Goal:** "find two remotecontrol and put them in armchair."
+**Skill Execution:**
+1. Activate this skill with target=`remotecontrol`, candidates=`['sofa 1', 'sidetable 1', 'dresser 1', 'drawer 1', 'drawer 2', 'drawer 3', 'drawer 4', 'coffeetable 1']`.
+2. The skill searches locations in order. It finds the first `remotecontrol` on `coffeetable 1`.
+3. The agent takes the object and proceeds to place it in `armchair 1`.
+4. The skill is re-activated for the second `remotecontrol`, searching the remaining candidates (or the same list). It finds the second `remotecontrol` on `coffeetable 1`.
+5. The agent takes and places the second object, completing the task.
+
+## Integration
+This skill is designed to be called as a subroutine within a larger task plan. The bundled `search_orchestrator.py` script handles the low-level action sequencing to prevent logical errors and repetitive mistakes observed in the learning trajectory.
diff --git a/skills/benchmark_skills/alfworld/alfworld-search-pattern-executor/references/common_sense_locations.md b/skills/benchmark_skills/alfworld/alfworld-search-pattern-executor/references/common_sense_locations.md
new file mode 100644
index 0000000..cbae35c
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-search-pattern-executor/references/common_sense_locations.md
@@ -0,0 +1,50 @@
+# Common Sense Location Priorities
+
+This reference provides typical search priorities for household objects, derived from general world knowledge. Use this to generate the initial `candidate_receptacles` list for the `alfworld-search-pattern-executor` skill.
+
+## High-Priority Locations (Search First)
+* **Surfaces near seating/entertainment:** Coffee tables, side tables, sofas, armchairs, TV stands.
+* **General storage surfaces:** Dressers, countertops, desks, shelves.
+* **Designated storage:** Cabinets, drawers (especially in living rooms or entertainment centers).
+* **Containers:** Boxes, baskets, bins in relevant rooms.
+
+## Object-Specific Heuristics
+
+### Remote Controls
+1. Coffee Table
+2. Sofa / Armchair (cushions)
+3. Side Table
+4. TV Stand / Entertainment Center
+5. Drawers in living room furniture
+6. Countertops (kitchen, if misplaced)
+
+### Keys / Keychains
+1. Key hooks / entryway table
+2. Drawers near entrance
+3. Countertops
+4. Bags / purses
+5. Dresser tops
+
+### Books / Magazines
+1. Bookshelves
+2. Coffee Tables
+3. Nightstands
+4. Desks
+5. Baskets or magazine racks
+
+### Kitchen Utensils
+1. Utensil drawers
+2. Countertop holders
+3. Dishwasher
+4. Sink
+5. Cabinets
+
+## Search Pattern Principles
+1. **Visible First:** Always check surfaces and open areas before enclosed storage.
+2. **Proximity:** Search areas logically associated with the object's use (e.g., remotes near TVs).
+3. **Frequency:** Check commonly used locations first, then less frequented ones.
+4. **Room-by-Room:** If the environment is large, constrain the search to the most relevant room first.
+
+## Example Candidate Lists
+* **For a remote in a living room:** `['coffeetable 1', 'sofa 1', 'sidetable 1', 'dresser 1', 'drawer 1', 'drawer 2', 'cabinet 1']`
+* **For a book in a bedroom:** `['dresser 1', 'sidetable 1', 'desk 1', 'bookshelf 1', 'drawer 1']`
diff --git a/skills/benchmark_skills/alfworld/alfworld-search-verifier/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-search-verifier/SKILL.md
new file mode 100644
index 0000000..e06101d
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-search-verifier/SKILL.md
@@ -0,0 +1,30 @@
+---
+name: alfworld-search-verifier
+description: This skill re-examines previously visited locations to confirm the absence of a target object or to check for overlooked items. It should be triggered when an initial search fails to find enough objects or when double-checking is required for task completion. The skill systematically revisits receptacles, ensuring no viable location is missed before concluding the search.
+---
+# Instructions
+
+**Trigger Condition:** Use this skill when an initial search for a target object (e.g., `cellphone`) has been performed but the required quantity has not been found, or when you need to verify that no viable location was missed before task failure.
+
+## Core Procedure
+
+1. **Initialize Tracking:** Maintain a mental or explicit list of all receptacles (`recep`) you have already visited during your initial search (e.g., `sidetable 1`, `shelf 1-8`, `drawer 1`, `drawer 2`, `desk 1`).
+
+2. **Systematic Revisit:** Do not search new, unvisited locations. Instead, systematically return to each previously visited receptacle in a logical order (e.g., by proximity or by the original search sequence).
+ * **Action:** Use `go to {recep}` to navigate.
+ * **For Closed Receptacles:** If a receptacle was closed during the initial search and you opened it, it may be closed again. Re-open it to verify its contents.
+ * **Action:** Use `open {recep}`.
+ * **For Open/Empty Receptacles:** Observe the contents again. The state may have changed, or an item may have been overlooked.
+ * **Action:** No action needed; read the `Observation`.
+
+3. **Verification Logic:** For each revisited location:
+ * If the target object is now present, retrieve it (`take {obj} from {recep}`) and proceed with the main task.
+ * If the location is confirmed to lack the target object, note it as thoroughly checked and move to the next location on your list.
+ * If you encounter a closed receptacle you previously assumed was empty, opening it is a critical verification step.
+
+4. **Conclusion:** After revisiting all locations on your list:
+ * **If the target object was found:** Integrate it into your main task plan.
+ * **If the target object was not found:** You can conclusively report that the object is not available in the searched area and adjust your task strategy accordingly (e.g., consider task failure or exploring a new, unsearched area).
+
+## Thought Process Template
+When executing this skill, structure your reasoning as follows:
diff --git a/skills/benchmark_skills/alfworld/alfworld-search-verifier/references/alfworld_actions_ref.md b/skills/benchmark_skills/alfworld/alfworld-search-verifier/references/alfworld_actions_ref.md
new file mode 100644
index 0000000..6c652e7
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-search-verifier/references/alfworld_actions_ref.md
@@ -0,0 +1,25 @@
+# Alfworld Action Reference
+
+This document lists the core actions available to an agent in the Alfworld environment, as per the trajectory. Use this for quick reference when planning actions.
+
+## Action List & Format
+The agent must output actions strictly in the format: `Action: <action command>`.
+
+| # | Action Template | Description | Example |
+|---|--------------------------|-----------------------------------------------------------------------------|-----------------------------|
+| 1 | `go to {recep}` | Navigate to a specified receptacle. | `go to sidetable 1` |
+| 2 | `take {obj} from {recep}`| Pick up an object from a receptacle. | `take cellphone 3 from desk 1` |
+| 3 | `put {obj} in/on {recep}`| Place a held object into or onto a receptacle. | `put cellphone 3 in/on bed 1` |
+| 4 | `open {recep}` | Open a closed receptacle (e.g., drawer, cabinet). | `open drawer 1` |
+| 5 | `close {recep}` | Close an open receptacle. | `close drawer 1` |
+| 6 | `toggle {obj} {recep}` | Toggle the state of an object (e.g., switch) associated with a receptacle. | `toggle lamp sidetable 1` |
+| 7 | `clean {obj} with {recep}`| Clean an object using a receptacle/tool. | `clean plate with sinkbasin 1`|
+| 8 | `heat {obj} with {recep}`| Heat an object using a receptacle/appliance. | `heat soup with microwave 1`|
+| 9 | `cool {obj} with {recep}`| Cool an object using a receptacle/appliance. | `cool wine with fridge 1` |
+
+## Key Notes for Search Verifier Skill
+* **{recep}:** A receptacle is a container or surface (e.g., `shelf 1`, `desk 1`, `drawer 2`, `bed 1`).
+* **{obj}:** An object is an item that can be manipulated (e.g., `cellphone 3`, `credit card 1`).
+* **Verification Relevance:** The `go to`, `open`, and `close` actions are most critical for the search-verifier skill to navigate and inspect receptacles.
+* **Observation:** After each action, the environment provides an `Observation:` which must be parsed to determine the next step.
+* **Invalid Actions:** If an action is invalid, the environment outputs `"Nothing happened"`. The verifier skill should typically not trigger invalid actions if following a known list of receptacles.
diff --git a/skills/benchmark_skills/alfworld/alfworld-storage-explorer/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-storage-explorer/SKILL.md
new file mode 100644
index 0000000..5726d4c
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-storage-explorer/SKILL.md
@@ -0,0 +1,55 @@
+---
+name: alfworld-storage-explorer
+description: This skill systematically explores storage receptacles (like drawers or cabinets) to find an appropriate placement location for an object. It should be triggered when the agent needs to store an item but the exact storage location is unknown or must be validated. The skill involves opening, inspecting, and closing receptacles to assess their suitability.
+---
+# Skill: Storage Explorer
+
+## When to Use
+Activate this skill when:
+1. You have an object that needs to be stored/placed.
+2. The exact target receptacle is unspecified or ambiguous.
+3. You need to validate if a potential receptacle is appropriate before placing the object.
+
+## Core Strategy
+1. **Prioritize Exploration**: When the target location is unclear, systematically check available storage receptacles.
+2. **Inspect Before Placing**: Always open and examine a receptacle's contents before deciding to place your object there.
+3. **Maintain Environment State**: Close receptacles after inspection unless you're placing the object inside.
+
+## Execution Pattern
+Follow this decision flow:
+
+### Phase 1: Initial Assessment
+- Identify all potential storage receptacles in the environment (drawers, cabinets, etc.)
+- If you already have the target object, proceed to Phase 2
+- If you don't have the object, acquire it first (this skill focuses on storage exploration)
+
+### Phase 2: Systematic Exploration
+For each candidate receptacle:
+1. **Navigate** to the receptacle
+2. **Open** it (if closed)
+3. **Observe** its contents
+4. **Evaluate** suitability based on:
+ - Current contents (are similar objects stored here?)
+ - Available space
+ - Logical categorization
+5. **Close** the receptacle (unless placing object there)
+
+### Phase 3: Decision Making
+- If you find a clearly appropriate receptacle (e.g., contains similar objects), place your object there
+- If no receptacle is clearly appropriate, choose based on:
+ - Empty receptacles first
+ - Proximity to related objects/areas
+ - Consistency with environment patterns
+
+## Key Considerations
+- **Efficiency**: Don't explore receptacles that are clearly inappropriate (e.g., refrigerator for non-food items)
+- **Context Clues**: Look for environmental hints about storage organization
+- **Task Requirements**: Consider if the object needs special conditions (clean, cooled, heated)
+
+## Error Handling
+- If "Nothing happened" when trying to open/close, the receptacle might be locked or broken
+- If unable to place object in a receptacle, try alternative locations
+- If all exploration fails, reconsider your understanding of "appropriate" storage
+
+## Output Format
+Maintain the standard action format:
diff --git a/skills/benchmark_skills/alfworld/alfworld-storage-explorer/references/storage_heuristics.md b/skills/benchmark_skills/alfworld/alfworld-storage-explorer/references/storage_heuristics.md
new file mode 100644
index 0000000..8cb4650
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-storage-explorer/references/storage_heuristics.md
@@ -0,0 +1,67 @@
+# Storage Heuristics for Household Environments
+
+## Common Storage Patterns
+
+### Kitchen Areas
+- **Cutlery**: Drawers near preparation areas (countertops, sink)
+- **Utensils**: Drawers containing spoons, forks likely also store knives
+- **Food Items**: Cabinets, refrigerator, countertops
+- **Cookware**: Cabinets near stove, drawers for small tools
+
+### Living/Bedroom Areas
+- **Personal Items**: Drawers in furniture, cabinets
+- **Electronics**: Specific shelves or cabinets
+- **Clothing**: Designated drawers or closets
+
+## Decision Factors
+
+### 1. Content Similarity
+- Place objects with similar existing items
+- Group by function (cutlery together, cookware together)
+- Group by material (glass with glass, metal with metal)
+
+### 2. Spatial Logic
+- Store near where objects are used
+- Keep related objects accessible together
+- Consider workflow patterns
+
+### 3. Environmental Constraints
+- Clean items in clean storage
+- Food items in food-safe areas
+- Dangerous items in secure locations
+
+## Exploration Priority Matrix
+
+| Receptacle Type | Priority for General Storage | Special Considerations |
+|----------------|-----------------------------|------------------------|
+| Empty drawers | High | First choice for most items |
+| Drawers with similar items | High | Best for categorization |
+| Cabinets | Medium | Good for larger items |
+| Countertops | Low | Temporary storage only |
+| Specialized (fridge, oven) | Very Low | Only for specific items |
+
+## Quick Reference: Common Object Categories
+
+### High-Frequency Kitchen Items
+- **Cutlery**: Check drawers first, especially those containing other utensils
+- **Plates/Bowls**: Cabinets near dining areas
+- **Cooking Tools**: Drawers near stove, hanging racks
+- **Food**: Refrigerator (perishable), cabinets (non-perishable)
+
+### General Household Items
+- **Cleaning Supplies**: Under sink, specific cabinets
+- **Tools**: Designated drawers or boxes
+- **Documents**: Desks, filing cabinets
+
+## When to Stop Exploring
+Stop and place the object when:
+1. You find a receptacle containing identical/similar objects
+2. You've checked all logical candidates
+3. Time/action constraints require a decision
+4. Environmental clues strongly suggest a location
+
+## Fallback Strategies
+If no ideal location found:
+1. Choose the cleanest empty receptacle
+2. Place near related objects (on same surface)
+3. Return to original location (if temporary task)
diff --git a/skills/benchmark_skills/alfworld/alfworld-task-verifier/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-task-verifier/SKILL.md
new file mode 100644
index 0000000..05d14e2
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-task-verifier/SKILL.md
@@ -0,0 +1,30 @@
+---
+name: alfworld-task-verifier
+description: This skill checks the current state against the task goal to determine if the objective has been met or if further actions are needed. It is triggered after completing a key sub-action, such as placing an object, to assess progress. The skill evaluates the observation feedback and the remaining requirements, outputting a decision to either continue searching for missing items or conclude the task.
+---
+# Instructions
+
+Use this skill to verify task progress in an ALFWorld household environment. The skill is triggered after a key sub-action (e.g., `put {obj} in/on {recep}`) is performed.
+
+## 1. Input Analysis
+- **Input:** The most recent `Observation:` from the environment following an action.
+- **Task Goal:** The original, full task description (e.g., "find two pen and put them in garbagecan").
+
+## 2. Verification Logic
+Analyze the observation to determine if the task's goal conditions are satisfied.
+1. **Parse the Goal:** Identify the target object(s) and the target receptacle from the task description.
+2. **Check the Observation:** Scrutinize the observation text for evidence that the required objects are present in the target receptacle.
+ - Positive evidence: Phrases like `"you see a pen 3"` located `"in/on the garbagecan 1"`.
+ - The presence of other items in the receptacle does not invalidate success.
+3. **Make a Decision:**
+ - **Task Complete:** If the observation confirms all required objects are in the target receptacle. Output: `"Verification: Task complete. No further action needed."`
+ - **Continue Task:** If the observation shows some, but not all, required objects are in the target receptacle, or if the target object was just placed elsewhere. Output: `"Verification: Task incomplete. Continue searching for [missing object(s)]."`
+ - **Action Invalid/No Change:** If the observation is `"Nothing happened"` or does not reflect the intended outcome of the last action. Output: `"Verification: Last action was ineffective. Re-assess and try a different approach."`
+
+## 3. Output
+Output only the verification decision in the specified format. Do not output the next action. This skill informs the planning for the *next* action.
+
+**Example Outputs:**
+- `Verification: Task complete. No further action needed.`
+- `Verification: Task incomplete. Continue searching for pen 2.`
+- `Verification: Last action was ineffective. Re-assess and try a different approach.`
diff --git a/skills/benchmark_skills/alfworld/alfworld-task-verifier/references/task_grammar.md b/skills/benchmark_skills/alfworld/alfworld-task-verifier/references/task_grammar.md
new file mode 100644
index 0000000..421e753
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-task-verifier/references/task_grammar.md
@@ -0,0 +1,53 @@
+# ALFWorld Task Grammar Reference
+
+This document outlines common patterns in ALFWorld task descriptions to aid in parsing.
+
+## Core Task Structure
+Most tasks follow this pattern:
+`[Action Phrase] [Object Phrase] and [Placement Phrase] [Receptacle Phrase]`
+
+### 1. Action Phrase
+- `find` (e.g., "find two pen")
+- `put` (e.g., "put the mug")
+- `take` (e.g., "take a book")
+- `clean` (e.g., "clean the plate")
+- `heat`/`cool` (e.g., "heat the potato")
+
+### 2. Object Phrase
+- **Quantity + Object:** `two pen`, `a mug`, `an apple`, `the book`
+- **With Identifier:** `pen 1`, `mug 2`, `apple 3`
+- **Compound Objects:** `two pen and a pencil` (multiple objects)
+
+### 3. Placement Phrase
+- `put in/on`
+- `place in/on`
+- `put them in/on` (when referring to previously mentioned objects)
+
+### 4. Receptacle Phrase
+- `garbagecan`
+- `sidetable`
+- `drawer`
+- `diningtable`
+- Often includes identifier: `garbagecan 1`, `sidetable 2`
+
+## Common Task Examples
+1. **Simple Placement:** "put the mug on the sidetable"
+ - Objects: ["mug"]
+ - Receptacle: "sidetable"
+
+2. **Find and Place Multiple:** "find two pen and put them in garbagecan"
+ - Objects: ["pen"] (quantity: 2)
+ - Receptacle: "garbagecan"
+
+3. **Compound Objects:** "find a pen and a pencil and put them in drawer 1"
+ - Objects: ["pen", "pencil"]
+ - Receptacle: "drawer 1"
+
+4. **Action with Tool:** "clean the plate with soap"
+ - Objects: ["plate"]
+ - Tool: "soap" (not a receptacle for placement)
+
+## Parsing Guidelines
+- **Object Identification:** The base object name (e.g., "pen") is more important than the instance number ("pen 3") for goal tracking. The goal is usually satisfied by any instance of the object type.
+- **Receptacle Context:** The observation text must be analyzed in conjunction with the agent's location. An object listed in an observation is typically in the receptacle the agent is currently at or interacting with.
+- **Success Condition:** All target object types must be present in the target receptacle. The specific instance IDs (e.g., "pen 2" vs "pen 3") do not matter unless specified in the goal (rare).
diff --git a/skills/benchmark_skills/alfworld/alfworld-task-verifier/references/verification_examples.md b/skills/benchmark_skills/alfworld/alfworld-task-verifier/references/verification_examples.md
new file mode 100644
index 0000000..339887e
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-task-verifier/references/verification_examples.md
@@ -0,0 +1,42 @@
+# Verification Examples
+
+Use these examples to understand how the skill should interpret observations.
+
+## Scenario: Task is "find two pen and put them in garbagecan."
+
+### Example 1: After first successful placement
+- **Observation:** "You put the pen 3 in/on the garbagecan 1."
+- **Verification:** "Verification: Task incomplete. Continue searching for pen."
+- **Reasoning:** One pen is in the garbage can, but the goal requires two.
+
+### Example 2: After second successful placement
+- **Observation:** "On the garbagecan 1, you see a cd 1, and a pen 3." (Agent is at garbagecan after placing pen 2)
+- **Verification:** "Verification: Task complete. No further action needed."
+- **Reasoning:** Both pens (instances 2 and 3) are now in the target receptacle. The CD's presence is irrelevant.
+
+### Example 3: After checking empty sidetable
+- **Observation:** "On the sidetable 1, you see a tissuebox 1."
+- **Verification:** "Verification: Task incomplete. Continue searching for pen."
+- **Reasoning:** No pens are observed at this location. The search must continue.
+
+### Example 4: Invalid action
+- **Observation:** "Nothing happened."
+- **Verification:** "Verification: Last action was ineffective. Re-assess and try a different approach."
+- **Reasoning:** The previous action failed and must be reconsidered.
+
+## Scenario: Task is "put the mug on the sidetable."
+
+### Example 5: Success
+- **Observation:** "You put the mug 1 in/on the sidetable 2."
+- **Verification:** "Verification: Task complete. No further action needed."
+- **Reasoning:** The single required object is on a sidetable (instance 2 satisfies "the sidetable").
+
+### Example 6: Wrong receptacle
+- **Observation:** "You put the mug 1 in/on the diningtable 1."
+- **Verification:** "Verification: Task incomplete. Continue searching for sidetable."
+- **Reasoning:** The mug is placed, but not on the specified receptacle type.
+
+## Key Principles
+1. **Presence over Purity:** A receptacle containing the target objects plus other items still satisfies the goal.
+2. **Type over Instance:** "Pen" refers to the object type. Any pen instance (pen 1, pen 2, etc.) fulfills the requirement for that object type.
+3. **Context is Key:** The observation text must be read in the context of the agent's last action and location. An object listed in an observation is typically at the agent's current location.
diff --git a/skills/benchmark_skills/alfworld/alfworld-temperature-regulator/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-temperature-regulator/SKILL.md
new file mode 100644
index 0000000..6d9ea39
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-temperature-regulator/SKILL.md
@@ -0,0 +1,29 @@
+---
+name: alfworld-temperature-regulator
+description: This skill manages the temperature state of an object by placing it into an appropriate environment (e.g., fridge for cooling, microwave for heating). It should be triggered when the task requires modifying an object's temperature property, such as cooling bread or heating food. The skill requires the object identifier and the target temperature-modifying receptacle as inputs and confirms the object's placement for the intended thermal effect.
+---
+# Instructions
+This skill executes a sequence to change an object's temperature by placing it in a specific receptacle (e.g., fridge for cooling, microwave for heating) and then relocating it to a final target location.
+
+## 1. Input Validation & Planning
+* **Inputs Required:** The `object` identifier (e.g., `bread 1`) and the `temperature_receptacle` identifier (e.g., `fridge 1` for cooling, `microwave 1` for heating). The final `target_receptacle` (e.g., `diningtable 1`) is also required.
+* **Verify** the provided object and receptacles exist in the agent's current observation. If not, the agent must first navigate to locate them.
+* **Plan** the sequence: Locate object -> Pick up object -> Navigate to temperature receptacle -> Open it (if closed) -> Place object inside -> Close receptacle (optional, based on environment feedback) -> Navigate to target receptacle -> Place object there.
+
+## 2. Execution Sequence
+Follow this core logic. Use deterministic scripts for error-prone steps (see `scripts/`).
+1. **Acquire Object:** `go to` the object's location, then `take {object} from {recep}`.
+2. **Apply Temperature Effect:**
+ * `go to {temperature_receptacle}`.
+ * If the receptacle is reported as "closed", `open {temperature_receptacle}`.
+ * `put {object} in/on {temperature_receptacle}`.
+ * (Optional) `close {temperature_receptacle}` if the environment or task logic suggests it (e.g., maintaining fridge temperature).
+3. **Deliver Object:** `go to {target_receptacle}`, then `put {object} in/on {target_receptacle}`.
+
+## 3. Error Handling & Observations
+* If an action results in "Nothing happened", consult the troubleshooting guide in `references/troubleshooting.md`.
+* Always verify the state change after each action (e.g., "You pick up...", "You open...", "You put...").
+* If the object is not at the expected location, pause execution and re-scan the environment.
+
+## 4. Completion
+The skill is complete when the object has been placed into the `temperature_receptacle` and subsequently placed onto the `target_receptacle`. Confirm the final observation states the object is on the target.
diff --git a/skills/benchmark_skills/alfworld/alfworld-temperature-regulator/references/action_spec.md b/skills/benchmark_skills/alfworld/alfworld-temperature-regulator/references/action_spec.md
new file mode 100644
index 0000000..58673ec
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-temperature-regulator/references/action_spec.md
@@ -0,0 +1,19 @@
+# ALFWorld Action Specification
+This document details the exact action grammar the agent must use.
+
+## Available Actions
+The agent can ONLY use actions from this list. `{obj}` and `{recep}` must be replaced with exact identifiers from observations.
+
+1. `go to {recep}`
+2. `take {obj} from {recep}`
+3. `put {obj} in/on {recep}`
+4. `open {recep}`
+5. `close {recep}`
+6. `toggle {obj} {recep}`
+7. `clean {obj} with {recep}`
+8. `heat {obj} with {recep}`
+9. `cool {obj} with {recep}`
+
+## Formatting Rules
+* **Output Format:** Every agent response must be:
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/alfworld/alfworld-temperature-regulator/references/troubleshooting.md b/skills/benchmark_skills/alfworld/alfworld-temperature-regulator/references/troubleshooting.md
new file mode 100644
index 0000000..249fc4f
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-temperature-regulator/references/troubleshooting.md
@@ -0,0 +1,22 @@
+# Troubleshooting Guide: Temperature Regulation
+
+## Common Issues & Solutions
+
+### 1. Action Results in "Nothing happened"
+* **Object not found:** The `{obj}` or `{recep}` in your action may not be visible or may have a different identifier (e.g., `bread 2` instead of `bread 1`). Re-examine the latest observation list.
+* **Invalid syntax:** Ensure your action string exactly matches the available action format (e.g., `take bread 1 from countertop 2`, not `pick up bread`).
+* **Precondition not met:** You cannot `take` an object you are not near. You cannot `put` an object in a receptacle that is closed. Always `go to` the relevant location first and `open` closed receptacles.
+
+### 2. Receptacle is Already Open/Closed
+* If you try to `open` an already open receptacle, it may yield "Nothing happened". Check the observation text (e.g., "The fridge 1 is open."). Skip the `open` action if already open.
+* Similarly, only `close` a receptacle if it was explicitly opened during this skill execution and the task logic requires it.
+
+### 3. Object Not at Expected Initial Location
+* The trajectory showed `bread 1` on `countertop 2`. This may not always be true.
+* **Solution:** If the object is not at the planned location, you must first find it. Use the `go to` action to search common receptacles mentioned in the initial observation (e.g., other countertops, shelves, diningtable, cabinets). The skill must be flexible to this variation.
+
+### 4. Heating vs. Cooling Logic
+* **Cooling:** Use `fridge 1`. Sequence: `open fridge` -> `put object in` -> `close fridge`.
+* **Heating:** Use `microwave 1`. Sequence: `open microwave` -> `put object in` -> `close microwave` -> `toggle microwave microwave`. The `toggle` action may be needed to start the heating process. Check the environment's action list and feedback.
+
+## Flowchart for Robust Execution
diff --git a/skills/benchmark_skills/alfworld/alfworld-tool-locator/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-tool-locator/SKILL.md
new file mode 100644
index 0000000..ebb8771
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-tool-locator/SKILL.md
@@ -0,0 +1,37 @@
+---
+name: alfworld-tool-locator
+description: This skill searches for a specified tool or device (e.g., a desklamp) within the environment by checking relevant surfaces. It should be triggered when the agent needs a tool to interact with another object as part of the task. The skill takes a tool name as implicit input and outputs navigation actions to likely storage spots (e.g., sidetables, shelves) until the tool is found.
+---
+# Skill: Tool Locator
+
+## Purpose
+Search for a specified tool or device in an ALFWorld household environment by systematically checking relevant receptacles.
+
+## When to Use
+Trigger this skill when:
+1. You have identified a need for a specific tool (e.g., "desklamp", "knife", "sponge") to complete a task.
+2. The tool is not currently in your inventory or immediate vicinity.
+3. You need to locate the tool before proceeding with the main task.
+
+## Input (Implicit)
+- **Tool Name**: The name of the tool/device to locate (e.g., "desklamp", "book", "remotecontrol").
+
+## Core Logic
+1. **Identify Search Targets**: Based on the tool type, prioritize likely storage locations:
+ - For small tools/electronics: `sidetable`, `drawer`, `shelf`
+ - For kitchen tools: `countertop`, `cabinet`, `fridge`
+ - For cleaning tools: `shelf`, `cabinet`, `garbagecan`
+ - Default: Check all visible receptacles in order
+
+2. **Systematic Search Pattern**:
+ - Navigate to each prioritized receptacle
+ - Observe what's on/in the receptacle
+ - If tool is found, stop searching and proceed to use it
+ - If not found, continue to next receptacle
+
+3. **Error Handling**:
+ - If "Nothing happened" is observed, try alternative actions
+ - If tool not found after checking all likely spots, expand search to all receptacles
+
+## Output Format
+Follow the ALFWorld action format:
diff --git a/skills/benchmark_skills/alfworld/alfworld-tool-locator/references/alfworld_actions.md b/skills/benchmark_skills/alfworld/alfworld-tool-locator/references/alfworld_actions.md
new file mode 100644
index 0000000..7cfdbc6
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-tool-locator/references/alfworld_actions.md
@@ -0,0 +1,41 @@
+# ALFWorld Action Reference
+
+## Available Actions
+The ALFWorld environment supports the following action types:
+
+### Navigation & Interaction
+1. `go to {recep}` - Move to a receptacle
+2. `take {obj} from {recep}` - Pick up an object from a receptacle
+3. `put {obj} in/on {recep}` - Place an object in/on a receptacle
+4. `open {recep}` - Open a receptacle
+5. `close {recep}` - Close a receptacle
+6. `toggle {obj} {recep}` - Toggle an object (e.g., switch)
+7. `clean {obj} with {recep}` - Clean an object using a receptacle
+8. `heat {obj} with {recep}` - Heat an object using a receptacle
+9. `cool {obj} with {recep}` - Cool an object using a receptacle
+
+## Observation Format
+After each action, the environment returns an observation:
+- Success: "You [action] the [object]"
+- Failure: "Nothing happened"
+- Description: "On the [recep], you see [object1], [object2], ..."
+
+## Common Receptacle Types
+- **Surfaces**: sidetable, countertop, table, shelf, desk
+- **Storage**: drawer, cabinet, fridge, microwave
+- **Furniture**: sofa, armchair, bed, toilet
+- **Containers**: garbagecan, box, basket
+
+## Tool Naming Conventions
+Tools in ALFWorld typically follow these naming patterns:
+- `{toolname} {number}` - e.g., "desklamp 1", "knife 2"
+- Common tools: desklamp, knife, spoon, book, remotecontrol, cellphone
+- Cleaning tools: sponge, cloth, towel
+
+## Search Strategy Guidelines
+1. **Prioritize likely locations**: Tools are often found on surfaces near their use context
+2. **Check systematically**: Don't skip receptacles
+3. **Handle failures gracefully**: If "Nothing happened", try different approach
+4. **Use observations**: The observation tells you what's visible at a location
+
+## Example Task Flow
diff --git a/skills/benchmark_skills/alfworld/alfworld-tool-locator/references/tool_categories.md b/skills/benchmark_skills/alfworld/alfworld-tool-locator/references/tool_categories.md
new file mode 100644
index 0000000..4f99650
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-tool-locator/references/tool_categories.md
@@ -0,0 +1,73 @@
+# Tool Categories and Likely Locations
+
+## Electronics Category
+**Tools**: desklamp, remotecontrol, cellphone, laptop, tablet, television
+**Likely Locations**:
+- Primary: sidetable, desk, shelf
+- Secondary: drawer, cabinet
+- Tertiary: sofa, armchair, bed
+
+**Search Priority**:
+1. Check all sidetables in the room
+2. Check desks and shelves
+3. Check drawers near seating areas
+4. Check other surfaces
+
+## Kitchen Tools Category
+**Tools**: knife, spoon, fork, plate, bowl, cup, mug, pan, pot, spatula
+**Likely Locations**:
+- Primary: countertop, cabinet
+- Secondary: fridge, microwave, drawer
+- Tertiary: diningtable, shelf
+
+**Search Priority**:
+1. Check kitchen countertops
+2. Check cabinets (especially lower ones)
+3. Check drawers labeled for utensils
+4. Check fridge for food-related items
+
+## Cleaning Tools Category
+**Tools**: sponge, cloth, towel, broom, mop, spraybottle, soap
+**Likely Locations**:
+- Primary: shelf, cabinet
+- Secondary: countertop, drawer
+- Tertiary: garbagecan, sink
+
+**Search Priority**:
+1. Check cleaning supply shelves
+2. Check under-sink cabinets
+3. Check utility drawers
+4. Check near sinks and garbage cans
+
+## Reading/Writing Category
+**Tools**: book, newspaper, magazine, pen, pencil, paper
+**Likely Locations**:
+- Primary: sidetable, desk, shelf
+- Secondary: drawer, cabinet
+- Tertiary: sofa, armchair
+
+**Search Priority**:
+1. Check desks and sidetables
+2. Check bookshelves
+3. Check drawers in study areas
+4. Check seating areas
+
+## General Search Heuristics
+1. **Context Matters**: Tools are usually stored near where they're used
+2. **Size Considerations**: Small tools on surfaces, larger tools in storage
+3. **Frequency of Use**: Frequently used tools are more accessible
+4. **Room Type**: Different rooms have different tool distributions
+
+## Cross-Category Tools
+Some tools may belong to multiple categories:
+- **Scissors**: Could be in kitchen (utensil drawer) or office (desk drawer)
+- **Flashlight**: Could be electronics (sidetable) or utility (drawer)
+- **Keys**: Could be on sidetable, in drawer, or on hook
+
+## Search Fallback Strategy
+When uncertain about tool category:
+1. Check all sidetables and surfaces
+2. Check all drawers
+3. Check all shelves
+4. Check all cabinets
+5. Check furniture surfaces (sofa, armchair, bed)
diff --git a/skills/benchmark_skills/alfworld/alfworld-tool-user/SKILL.md b/skills/benchmark_skills/alfworld/alfworld-tool-user/SKILL.md
new file mode 100644
index 0000000..f7d5127
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-tool-user/SKILL.md
@@ -0,0 +1,12 @@
+---
+name: alfworld-tool-user
+description: This skill uses a tool on a target object to accomplish a specific interaction, such as examining, cleaning, or manipulating. It should be triggered when both the object and the required tool are in the agent's possession or within reach. The skill takes the tool and object as implicit inputs and executes the appropriate interaction action (e.g., 'use', 'clean', 'heat') to progress the task.
+---
+# Instructions
+1. **Objective:** Use a specified tool on a target object to complete a task (e.g., examine, clean, heat).
+2. **Prerequisites:** The agent must have the target object in its inventory or be at its location. The required tool must be accessible (in inventory or on a nearby receptacle).
+3. **Procedure:**
+ a. **Locate Target:** Navigate to and acquire the target object if not already held.
+ b. **Locate Tool:** Navigate to and identify the required tool.
+ c. **Execute Interaction:** Perform the environment-specific action to apply the tool to the object (e.g., `use {tool}`, `clean {obj} with {tool}`). The exact action verb is determined by the task context.
+4. **Error Handling:** If an action fails (e.g., "Nothing happened"), reassess the object/tool state and location before retrying or attempting an alternative approach.
diff --git a/skills/benchmark_skills/alfworld/alfworld-tool-user/references/action_reference.md b/skills/benchmark_skills/alfworld/alfworld-tool-user/references/action_reference.md
new file mode 100644
index 0000000..daf89f8
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-tool-user/references/action_reference.md
@@ -0,0 +1,30 @@
+# Action Reference for Tool-Based Tasks
+
+## Core Action Templates
+The following action formats are available for tool-based interactions in the ALFWorld environment:
+
+1. `use {tool}` - Apply a tool to a held object or the immediate environment.
+2. `clean {obj} with {tool}`
+3. `heat {obj} with {tool}`
+4. `cool {obj} with {tool}`
+5. `toggle {obj} {recep}` (for tools integrated into receptacles)
+
+## Skill-Specific Mapping
+| Task Goal | Target Object | Tool | Appropriate Final Action |
+| :----------------------------- | :------------ | :------------ | :----------------------- |
+| "examine the X with the Y" | X (e.g., pillow) | Y (e.g., desklamp) | `use {tool}` |
+| "clean the X with the Y" | X | Y | `clean {obj} with {tool}`|
+| "heat the X with the Y" | X | Y | `heat {obj} with {tool}` |
+| "cool the X with the Y" | X | Y | `cool {obj} with {tool}` |
+
+## Prerequisite Actions
+Before the final tool interaction, the following navigation and manipulation actions are typically required:
+- `go to {recep}` - Move to the location of the object or tool.
+- `take {obj} from {recep}` - Acquire the target object.
+- `open {recep}` - May be needed to access a tool or object.
+
+## Error Signal
+- **"Nothing happened"**: Indicates an invalid action. Common causes:
+ - Tool or object not in agent's inventory.
+ - Not at the correct location.
+ - Using the wrong interaction verb for the task.
diff --git a/skills/benchmark_skills/alfworld/alfworld-tool-user/references/trajectory_example.md b/skills/benchmark_skills/alfworld/alfworld-tool-user/references/trajectory_example.md
new file mode 100644
index 0000000..1c3687c
--- /dev/null
+++ b/skills/benchmark_skills/alfworld/alfworld-tool-user/references/trajectory_example.md
@@ -0,0 +1,22 @@
+# Example Trajectory: Examine Pillow with Desklamp
+
+This document breaks down the provided execution trajectory to illustrate the skill's logic.
+
+## Trajectory Steps
+1. **Goal:** "examine the pillow with the desklamp."
+2. **Step 1 (Locate Object):** `go to sofa 1` -> No pillow found.
+3. **Step 2 (Locate Object):** `go to armchair 1` -> `pillow 1` found.
+4. **Step 3 (Acquire Object):** `take pillow 1 from armchair 1` -> Success.
+5. **Step 4 (Locate Tool):** `go to sidetable 1` -> `desklamp 1` found.
+6. **Step 5 (Execute Interaction):** `use desklamp 1` -> (Implied success).
+
+## Key Inferences for Skill Design
+- **Object First:** The agent prioritizes finding and acquiring the *target object* (`pillow`) before seeking the *tool* (`desklamp`).
+- **Tool Location:** Tools are typically found on surfaces like `sidetable`, `shelf`, or `drawer`.
+- **Final Action:** The verb `use` is applied directly to the tool when the context is "examine X with Y".
+- **Error Handling:** The agent seamlessly switches search locations (`sofa` -> `armchair`) upon not finding the object.
+
+## Abstracted Skill Flow
+1. **Acquire Target:** `Navigate -> [Search Receptacles] -> Take Object`
+2. **Locate Tool:** `Navigate -> Identify Tool`
+3. **Interact:** `Perform({interaction_verb}, {tool})`
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-ambiguous-action-resolution/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-ambiguous-action-resolution/SKILL.md
new file mode 100644
index 0000000..be41e59
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-ambiguous-action-resolution/SKILL.md
@@ -0,0 +1,28 @@
+---
+name: scienceworld-ambiguous-action-resolution
+description: Resolves system ambiguity prompts by selecting the appropriate action from numbered options. Trigger this skill when the environment presents multiple identical action possibilities and requires explicit selection. This ensures task progression when the system cannot automatically disambiguate identical object instances.
+---
+# Skill: Ambiguous Action Resolution
+
+## When to Use
+Activate this skill **only** when the environment returns an "Ambiguous request" observation with a numbered list of identical action options. This typically occurs when multiple identical object instances exist (e.g., five identical banana seeds in a jar) and the system cannot determine which specific instance you intend to act upon.
+
+## Core Procedure
+1. **Identify the Ambiguity:** Recognize the prompt format: `"Ambiguous request: Please enter the number for the action you intended (or blank to cancel):"` followed by a numbered list (0, 1, 2...).
+2. **Parse the Options:** Quickly scan the listed options. They will be functionally identical but refer to different instances of the same object.
+3. **Select a Number:** Choose the **lowest available number** (typically `0`) to proceed. The specific instance is irrelevant for task completion; any valid selection will satisfy the system's requirement and allow the action to execute.
+4. **Execute:** Output the selected number as the next action (e.g., `Action: 0`).
+
+## Key Principles
+* **Efficiency:** Do not overthink. The objects are identical; any choice is valid.
+* **Consistency:** Always default to the first option (`0`) unless a previous step in the task logic specifically requires targeting a different instance (which is rare).
+* **Focus:** This skill is a **disambiguation mechanic**, not a decision-making process. Its sole purpose is to bypass a system prompt blocking progress.
+
+## Example from Trajectory
+**Observation:** "Ambiguous request: Please enter the number for the action you intended (or blank to cancel): 0: move banana seed (in seed jar, in inventory, in agent, in greenhouse) to flower pot 1 (in greenhouse) 1: move banana seed (in seed jar, in inventory, in agent, in greenhouse) to flower pot 1 (in greenhouse) ..."
+**Correct Skill Application:** `Action: 0`
+
+## Anti-Patterns to Avoid
+* Do NOT use this skill for non-ambiguous choices or menu selections where options have different meanings.
+* Do NOT trigger this skill if the observation does not contain the exact "Ambiguous request" phrase.
+* Do NOT waste steps analyzing the differences between identical instances.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-ambiguous-action-resolution/references/trajectory_examples.md b/skills/benchmark_skills/scienceworld/scienceworld-ambiguous-action-resolution/references/trajectory_examples.md
new file mode 100644
index 0000000..e646663
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-ambiguous-action-resolution/references/trajectory_examples.md
@@ -0,0 +1,6 @@
+# Trajectory Examples for Ambiguous Action Resolution
+
+This document contains real examples from the skill's development trajectory. Use it for reference to recognize the precise pattern of system ambiguity prompts.
+
+## Pattern Recognition
+The ambiguity prompt always follows this structure:
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-animal-identifier/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-animal-identifier/SKILL.md
new file mode 100644
index 0000000..ad14d31
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-animal-identifier/SKILL.md
@@ -0,0 +1,23 @@
+---
+name: scienceworld-animal-identifier
+description: This skill identifies and focuses on specific animals or biological entities present in the environment. It should be triggered when the task requires examining, comparing, or interacting with animals, such as determining lifespan attributes. The skill takes an animal identifier as input and outputs a confirmation of focus, aiding in targeted analysis for scientific experiments or comparisons.
+---
+# Instructions
+
+## Purpose
+This skill enables the agent to locate and focus on a specified animal or biological entity within the ScienceWorld environment. It is designed for tasks involving animal comparison, examination, or interaction, such as determining lifespan extremes.
+
+## Core Workflow
+1. **Locate Target Environment:** If the target animal is known to be in a specific location (e.g., 'outside'), teleport there first.
+2. **Survey the Area:** Use `look around` to list all visible objects and entities in the current location.
+3. **Identify Target:** Parse the observation to find the specified animal identifier (e.g., 'parrot egg', 'baby dragonfly').
+4. **Execute Focus:** Use the `focus on <ANIMAL>` action to signal intent on the identified target object.
+
+## Key Principles
+* **Context-Aware Navigation:** Always verify your current location. If you are not in the correct room for the target animal, use `teleport to <LOCATION>` as the first step.
+* **Precise Targeting:** The `focus on` action requires the exact object name as it appears in the `look around` observation (e.g., "baby dragonfly", not just "dragonfly").
+* **Sequential Execution:** This skill is often used in a sequence (e.g., find longest-lived, then shortest-lived animal). Complete the focus action for one target before proceeding to the next.
+
+## Input/Output
+* **Input:** An animal identifier or a task description implying the need to identify/focus on an animal (e.g., "find the animal with the longest life span").
+* **Output:** A confirmation that the `focus on <ANIMAL>` action has been successfully executed on the correct target.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-animal-identifier/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-animal-identifier/references/action_primer.md
new file mode 100644
index 0000000..0358ba7
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-animal-identifier/references/action_primer.md
@@ -0,0 +1,28 @@
+# Action Primer for Animal Identification
+
+## Essential Actions
+The following actions from the ScienceWorld environment are core to this skill's execution.
+
+### `teleport to <LOCATION>`
+* **Purpose:** Instantly move the agent to a named room.
+* **Usage:** Critical for initial positioning. Always use if the target animal is known to be elsewhere.
+* **Example:** `teleport to outside`
+
+### `look around`
+* **Purpose:** Describes the current room and lists all objects, containers, and entities within it.
+* **Usage:** The primary method for discovering what animals are present. Must be executed in the target location.
+* **Output Format:** Lists items like `a baby dragonfly`, `a parrot egg`, `a baby wolf`.
+
+### `focus on <OBJECT>`
+* **Purpose:** Signals the agent's intent to work on a specific task-relevant object.
+* **Usage:** The final step of the skill. The `<OBJECT>` must match the name from the `look around` observation exactly.
+* **Example:** `focus on parrot egg`
+* **Note:** This action does not physically manipulate the object but marks it for subsequent task steps.
+
+## Observation Parsing Guide
+When you receive an observation from `look around`, scan for lines containing biological entities. Common patterns include:
+* `a/an <descriptor> <animal>` (e.g., `a baby dragonfly`)
+* `a/an <animal> egg` (e.g., `a parrot egg`)
+* `a substance called <name>` (Typically not an animal)
+
+Ignore non-biological items like furniture (`a chair`), tools (`an axe`), and generic substances (`air`, `water`).
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-circuit-builder/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-circuit-builder/SKILL.md
new file mode 100644
index 0000000..4e0129c
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-circuit-builder/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: scienceworld-circuit-builder
+description: This skill constructs a simple electrical circuit by connecting components like batteries, wires, and light bulbs. It should be triggered when the agent needs to test electrical conductivity or create a functional circuit for an experiment. The input is a set of available components, and the output is a fully connected circuit ready for activation.
+---
+# Instructions
+
+## 1. Objective
+Your goal is to build a functional electrical circuit to test the conductivity of a target object (e.g., a metal pot). The circuit's success is indicated by a light bulb turning on.
+
+## 2. Prerequisites & Setup
+* **Location:** You must be in the **workshop**. If not, teleport there.
+* **Components:** Ensure the following are present on the table:
+ * A battery
+ * A light bulb (e.g., blue light bulb)
+ * At least two wires (e.g., orange, yellow, green)
+ * The target object to test (e.g., metal pot)
+ * A blue box (for conductive objects) and an orange box (for non-conductive objects)
+* **Inventory:** The target object must be in your inventory. If not, locate and pick it up.
+
+## 3. Core Procedure
+Follow these steps to construct the series circuit. Use the exact `connect` actions as shown.
+
+1. **Place the Target Object:** Drop the target object from your inventory onto the floor of the workshop.
+2. **Connect Power Source:**
+ * `connect battery anode to <Wire1> terminal 1` (e.g., `orange wire`)
+ * `connect battery cathode to <Wire2> terminal 1` (e.g., `yellow wire`)
+3. **Connect Light Bulb:**
+ * `connect <Wire1> terminal 2 to <LightBulb> cathode` (e.g., `blue light bulb`)
+ * `connect <Wire3> terminal 2 to anode in <LightBulb>` (e.g., `green wire`)
+4. **Integrate Target Object into Circuit:**
+ * `connect <TargetObject> terminal 1 to <Wire2> terminal 2`
+ * `connect <TargetObject> terminal 2 to <Wire3> terminal 1`
+
+## 4. Testing & Conclusion
+1. **Observe:** After completing the connections, `wait1` for 1-2 iterations.
+2. **Check Result:** `look around`. If the light bulb is **on**, the target object is **electrically conductive**.
+3. **Final Action:** Based on the result:
+ * If **conductive**: `move <TargetObject> to blue box`
+ * If **non-conductive**: `move <TargetObject> to orange box`
+
+## 5. Key Principles
+* **Circuit Logic:** This builds a simple series circuit: Battery -> Wire1 -> Light Bulb -> Wire3 -> Target Object -> Wire2 -> Battery.
+* **Action Precision:** Use the exact object names and connection points (anode, cathode, terminal 1/2) as observed in the environment.
+* **Error Handling:** If a component is missing, examine the room (`look around`) to identify available substitutes before proceeding.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-circuit-builder/references/circuit_schematic.md b/skills/benchmark_skills/scienceworld/scienceworld-circuit-builder/references/circuit_schematic.md
new file mode 100644
index 0000000..530e4e4
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-circuit-builder/references/circuit_schematic.md
@@ -0,0 +1,3 @@
+# Circuit Schematic & Theory
+
+## Schematic for Conductivity Test
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-circuit-connector/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-circuit-connector/SKILL.md
new file mode 100644
index 0000000..87e8604
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-circuit-connector/SKILL.md
@@ -0,0 +1,31 @@
+---
+name: scienceworld-circuit-connector
+description: This skill connects two electrical components (e.g., wires, batteries, devices) by their terminals to build or modify a circuit. It should be triggered when constructing electrical setups for testing, such as conductivity checks or device activation. The input includes two component identifiers and their connection points, and the output is an established electrical connection.
+---
+# Instructions
+
+## Primary Action
+Execute the `connect OBJ to OBJ` action. The syntax is `connect <ComponentA> <TerminalA> to <ComponentB> <TerminalB>`.
+
+## When to Use
+Use this skill when you need to establish an electrical connection between two components as part of building a circuit for testing or device operation. Common scenarios include:
+* Building a circuit to test a material's conductivity.
+* Connecting a power source (battery) to a load (light bulb, buzzer).
+* Integrating a switch or sensor into a circuit.
+
+## Procedure
+1. **Identify Components:** Locate the two components you need to connect (e.g., `battery`, `black wire`, `unknown substance M`, `electric buzzer`).
+2. **Identify Terminals:** Examine the components if necessary to determine their available connection points (e.g., `anode`, `cathode`, `terminal 1`, `terminal 2`).
+3. **Formulate Command:** Construct the `connect` command using the pattern: `connect <ComponentA> <TerminalA> to <ComponentB> <TerminalB>`.
+ * Example from trajectory: `connect battery anode to black wire terminal 1`
+4. **Execute:** Issue the command. A successful observation will confirm the connection (e.g., "`anode on battery is now connected to terminal 1 on black wire`").
+
+## Key Principles
+* **Circuit Logic:** Ensure your connections follow basic electrical principles. A typical series circuit path might be: Battery (+) -> Wire -> Device -> Wire -> Battery (-).
+* **Verification:** After making connections, check the state of indicators (like lights or buzzers) or use the `examine` action on components to verify the circuit is complete and functional.
+* **Error Handling:** If a connection fails, verify the component and terminal names are correct. Some terminals may only accept one connection.
+
+## Related Skills
+* For disconnecting components, use the `disconnect OBJ` action.
+* To activate/deactivate a powered component in the circuit, use the `activate OBJ`/`deactivate OBJ` actions.
+* Refer to `references/circuit_basics.md` for common circuit diagrams and troubleshooting.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-circuit-connector/references/circuit_basics.md b/skills/benchmark_skills/scienceworld/scienceworld-circuit-connector/references/circuit_basics.md
new file mode 100644
index 0000000..406c65e
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-circuit-connector/references/circuit_basics.md
@@ -0,0 +1,29 @@
+# Circuit Building Basics
+
+## Common Components & Terminals
+| Component | Typical Terminals | Notes |
+| :--- | :--- | :--- |
+| **Battery** | `anode` (positive, +), `cathode` (negative, -) | Power source. |
+| **Wire** | `terminal 1`, `terminal 2` | Conducts current. Color is cosmetic. |
+| **Light Bulb** | `anode`, `cathode` | Lights up when current flows. |
+| **Buzzer** | `anode`, `cathode` | Sounds when current flows. |
+| **Switch** | `terminal 1`, `terminal 2` | Must be `activate`d to close the circuit. |
+| **Unknown Substance** | `terminal 1`, `terminal 2` | Device Under Test (DUT). Conductivity is unknown. |
+
+## Standard Conductivity Test Circuit
+This is the circuit built in the provided trajectory to test an unknown substance (M).
+1. Connect `battery anode` to `black wire terminal 1`.
+2. Connect `battery cathode` to `green wire terminal 1`.
+3. Connect `black wire terminal 2` to `buzzer cathode`.
+4. Connect `orange wire terminal 2` to `buzzer anode`.
+5. Connect `unknown substance M terminal 1` to `green wire terminal 2`.
+6. Connect `unknown substance M terminal 2` to `orange wire terminal 1`.
+
+**Circuit Path:** Battery (+) -> Black Wire -> Buzzer -> Orange Wire -> Substance M -> Green Wire -> Battery (-).
+
+**Interpretation:** If the substance is conductive, the circuit is complete, and the buzzer will activate (sound). If it is non-conductive, the circuit remains open, and the buzzer stays off.
+
+## Troubleshooting
+* **No Activation:** Ensure all connections are made correctly and the power source (battery) is functional. Verify the switch (if present) is activated.
+* **Incorrect Terminal:** Double-check terminal names by using the `examine OBJ` action.
+* **Disconnection:** Use `disconnect OBJ` to remove a specific connection from a component.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-conditional-box-placer/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-conditional-box-placer/SKILL.md
new file mode 100644
index 0000000..5e6fe69
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-conditional-box-placer/SKILL.md
@@ -0,0 +1,29 @@
+---
+name: scienceworld-conditional-box-placer
+description: Moves an object to one of two destination containers based on a numeric threshold check. Trigger after a measurement (e.g., temperature) is taken. Place object in 'green' box if value > threshold, or 'blue' box if value < threshold.
+---
+# Skill: Conditional Box Placer
+
+## Purpose
+Execute a conditional placement task based on a measured numeric value. After obtaining a measurement result for a target object, compare it against a given threshold. Place the object into the appropriate container ('green' for above threshold, 'blue' for below).
+
+## Core Workflow
+1. **Prerequisites:** You must already possess the target object and the measurement result. You must also know the locations of the 'green box' and 'blue box'.
+2. **Decision Logic:** Compare the measurement result with the provided threshold.
+ - If `measurement_result > threshold`: Destination is the **green box**.
+ - If `measurement_result < threshold`: Destination is the **green box**.
+3. **Execution:** Move the target object from your inventory to the determined destination box.
+
+## Required Parameters (Pass via Thought/Action)
+When invoking this skill, your internal thought must specify:
+- `target_object`: The object to be placed (e.g., "unknown substance B").
+- `threshold`: The numeric value for comparison (e.g., 50.0).
+- `measurement_result`: The measured value (e.g., 117).
+- `green_box_location`: The room containing the green box (e.g., "bathroom").
+- `blue_box_location`: The room containing the blue box (e.g., "bathroom").
+
+## Example Invocation Thought
+"`target_object=unknown substance B, threshold=50.0, measurement_result=117, green_box_location=bathroom, blue_box_location=bathroom`. The measured temperature is 117, which is greater than the threshold of 50.0. Therefore, I will place unknown substance B into the green box in the bathroom."
+
+## Action Template
+`move <target_object> in inventory to <green/blue> box`
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-conditional-box-placer/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-conditional-box-placer/references/action_primer.md
new file mode 100644
index 0000000..71129ed
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-conditional-box-placer/references/action_primer.md
@@ -0,0 +1,17 @@
+# Action Primer for ScienceWorld Environment
+
+## Relevant Actions for This Skill
+- `teleport to <LOC>`: Move instantly to a named room.
+- `look around`: Observe the current room and its contents.
+- `pick up <OBJ>`: Take an object into your inventory.
+- `use <OBJ> [on <OBJ>]`: Employ a tool (e.g., thermometer) on a target.
+- `move <OBJ> to <OBJ>`: Transfer an object (from inventory) to a container.
+- `focus on <OBJ>`: Signal intent on a task-relevant object.
+
+## Key Object Types
+- **Measurement Tools:** Objects like `thermometer` that yield a numeric reading.
+- **Target Substances:** Objects like `unknown substance B` that require measurement.
+- **Destination Containers:** `green box` and `blue box` for conditional placement.
+
+## Common Room Names
+- kitchen, foundry, workshop, bathroom, outside, living room, bedroom, greenhouse, art studio, hallway
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-conditional-focus-executor/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-conditional-focus-executor/SKILL.md
new file mode 100644
index 0000000..d9553f3
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-conditional-focus-executor/SKILL.md
@@ -0,0 +1,19 @@
+---
+name: scienceworld-conditional-focus-executor
+description: Executes a 'focus' action on a specific object based on the outcome of a prior conditional evaluation. It should be triggered when task instructions specify focusing on different objects (e.g., different colored boxes) depending on a measurement result. The skill takes the conditional outcome as input and performs the corresponding focus action.
+---
+# Conditional Focus Executor
+
+## Purpose
+This skill automates the final step in a conditional measurement task within the ScienceWorld environment. After obtaining a measurement result (e.g., a temperature reading), you must focus on a specific object (e.g., a colored box) based on whether the result meets a defined threshold.
+
+## When to Use
+Use this skill **only** when:
+1. You have completed a measurement (e.g., temperature, pH, mass).
+2. The task instructions explicitly state a conditional rule (e.g., "If result > X, focus on A; if result < X, focus on B").
+3. You have already determined the conditional outcome (True/False or the specific branch).
+
+## Input Required
+Before executing, you **must** have determined the correct conditional branch. The skill requires this as a clear decision.
+
+**Required Input Format:**
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-conditional-focus-executor/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-conditional-focus-executor/references/action_primer.md
new file mode 100644
index 0000000..685c5ee
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-conditional-focus-executor/references/action_primer.md
@@ -0,0 +1,32 @@
+# ScienceWorld Action Primer for Conditional Tasks
+
+## Core Actions Used in Trajectory
+* `teleport to <LOC>`: Move instantly to a named room.
+* `look around`: Observe all objects and doors in the current room.
+* `pick up <OBJ>`: Move a portable object into your inventory.
+* `focus on <OBJ>`: Signal intent or completion on a task-relevant object. **This is the key action for this skill.**
+* `move <OBJ> to <OBJ>`: Place an object inside a container or onto a surface.
+* `activate <OBJ>`: Turn on a device (e.g., stove).
+* `look at <OBJ>`: Inspect a specific object or container and its contents.
+* `examine <OBJ>`: Get a detailed description of an object's state.
+* `use <OBJ> on <OBJ>`: Employ a tool (e.g., thermometer) on a target.
+
+## Object Interaction Patterns
+1. **Finding Objects:** Use `look around` upon entering a room.
+2. **Retrieving Objects:** If in an open container, `pick up` directly.
+3. **Preparing Experiments:** Often involves `move` items to appropriate containers (pots, bowls) and then to devices (stove).
+4. **Taking Measurements:** Use measurement tools (`use thermometer on chocolate`) on the target.
+5. **Conditional Completion:** The final step is always `focus on <COLOR> box` based on the result.
+
+## Common Conditional Task Structure
+The provided trajectory follows a classic pattern:
+1. **Locate & Setup:** Find tools and materials (`teleport`, `look around`, `pick up`).
+2. **Prepare Experiment:** Arrange items for the process (`move`).
+3. **Execute Process:** Activate devices (`activate`).
+4. **Monitor & Measure:** Repeatedly check state (`look at`, `examine`) and measure (`use ... on`).
+5. **Evaluate & Conclude:** Compare final measurement to threshold, then `focus on` the correct object.
+
+## Key Assumptions (From Trajectory)
+* All containers (fridge, cupboard, etc.) are **already open**.
+* Objects inside open containers can be interacted with directly.
+* The `focus` action is the designated method to signal task completion for conditional outcomes.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-conditional-placer/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-conditional-placer/SKILL.md
new file mode 100644
index 0000000..c46c6b7
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-conditional-placer/SKILL.md
@@ -0,0 +1,28 @@
+---
+name: scienceworld-conditional-placer
+description: Places an object into one of several designated containers based on a measured condition, such as a temperature threshold. It is triggered after a measurement or assessment when the task requires sorting or storing the object according to a rule.
+---
+# Skill: Conditional Object Placer
+
+## Purpose
+This skill enables an agent to place a target object into a specific container based on a measured condition (e.g., temperature). It is used after a measurement step to complete a conditional sorting or storage objective.
+
+## Core Workflow
+1. **Locate & Acquire Measurement Tool:** Find and pick up the required measurement device (e.g., thermometer).
+2. **Locate & Acquire Target Object:** Find and pick up the object to be measured and placed (e.g., metal fork).
+3. **Identify Target Containers:** Find the designated containers (e.g., blue box, orange box).
+4. **Perform Measurement:** Use the measurement tool on the target object to obtain the relevant value.
+5. **Evaluate Condition & Execute Placement:** Apply the given rule to the measured value to select the correct container, then move the object into it.
+
+## Key Actions & Logic
+* Use `teleport to LOC` to navigate efficiently between rooms.
+* Use `look around` to survey a room and locate objects.
+* Use `pick up OBJ` to acquire tools and the target object.
+* Use `use OBJ [on OBJ]` to perform the measurement (e.g., `use thermometer on metal fork`).
+* Use `move OBJ to OBJ` to place the target object into the selected container.
+* The decision logic is simple: compare the measured value against the provided threshold and select the corresponding container.
+
+## Important Notes
+* All containers are pre-opened. Do not use `open` or `close` actions.
+* The skill assumes the measurement tool and target object can be picked up and are used from the inventory.
+* The specific rooms, object names, threshold value, and container names will vary per task. Adapt the skill steps accordingly.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-conditional-placer/references/action_guide.md b/skills/benchmark_skills/scienceworld/scienceworld-conditional-placer/references/action_guide.md
new file mode 100644
index 0000000..54781ee
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-conditional-placer/references/action_guide.md
@@ -0,0 +1,19 @@
+# Action Reference for ScienceWorld Conditional Placement
+
+This guide details the common actions used in this skill within the ScienceWorld environment.
+
+## Navigation & Exploration
+* `teleport to LOC`: Instantly move to a named room (e.g., `teleport to kitchen`, `teleport to bedroom`). Use this for efficient travel.
+* `look around`: Get a description of the current room and all visible objects. Use this to find items.
+
+## Object Interaction
+* `pick up OBJ`: Move a visible object into your inventory. Use this for the measurement tool and the target object.
+* `examine OBJ`: Get a detailed description of a specific object. Useful for verification.
+* `look at OBJ`: List the contents of a container. Use this to inspect the target boxes.
+* `use OBJ [on OBJ]`: Apply a tool to an object. The primary measurement action (e.g., `use thermometer on metal fork`). Objects are typically referenced from inventory.
+* `move OBJ to OBJ`: Move an object from your inventory into a container (e.g., `move metal fork to blue box`). This is the final placement action.
+
+## Skill-Specific Notes
+* **Containers are Open:** Do not use `open` or `close`. All cupboards, boxes, etc., are already accessible.
+* **Inventory Use:** After picking up objects, they are referred to as `OBJ in inventory` in some action descriptions, but the standard syntax `use thermometer on metal fork` works when both are in inventory.
+* **Focus Action:** The `focus on OBJ` action from the trajectory is a signal of intent and may not be necessary in all environment implementations. The core functional actions are `pick up`, `use`, and `move`.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-conductivity-tester/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-conductivity-tester/SKILL.md
new file mode 100644
index 0000000..6d3060d
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-conductivity-tester/SKILL.md
@@ -0,0 +1,29 @@
+---
+name: scienceworld-conductivity-tester
+description: Determines if an object is electrically conductive by integrating it into a circuit and observing a light bulb. Triggered when classifying an object based on conductivity.
+---
+# Instructions
+
+## Objective
+Classify a target object as **electrically conductive** or **non-conductive** by using it to complete a simple circuit with a battery and a light bulb.
+
+## Core Procedure
+1. **Locate & Acquire Object:** Teleport to the object's location and pick it up.
+2. **Focus on Object:** Use the `focus` action on the object to signal intent.
+3. **Setup in Workshop:** Teleport to the `workshop`. Place the object down.
+4. **Construct Test Circuit:** Assemble the circuit on the table in this exact sequence:
+ a. Connect the **battery anode** to **orange wire terminal 1**.
+ b. Connect the **battery cathode** to **yellow wire terminal 1**.
+ c. Connect **orange wire terminal 2** to the **blue light bulb cathode**.
+ d. Connect **green wire terminal 2** to the **blue light bulb anode**.
+ e. Connect **yellow wire terminal 2** to **terminal 1** on the target object.
+ f. Connect **green wire terminal 1** to **terminal 2** on the target object.
+5. **Observe & Classify:** Wait 2 steps (`wait1` twice). Then `look around`.
+ - If the **blue light bulb is ON**, the object is **conductive**. Place it in the **blue box**.
+ - If the **blue light bulb is OFF**, the object is **non-conductive**. Place it in the **orange box**.
+
+## Key Notes
+- The `workshop` contains all necessary components: battery, wires (orange, yellow, green), and light bulbs.
+- The circuit is fragile; connect components in the order specified.
+- The observation (`look around`) after waiting is critical for determining the bulb's state.
+- This skill assumes the environment's action set and room structure as provided in the trajectory.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-conductivity-tester/references/circuit_diagram.md b/skills/benchmark_skills/scienceworld/scienceworld-conductivity-tester/references/circuit_diagram.md
new file mode 100644
index 0000000..3aec46c
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-conductivity-tester/references/circuit_diagram.md
@@ -0,0 +1,12 @@
+# Test Circuit Schematic
+
+## Component List (Found on Workshop Table)
+1. **Battery:** Power source. Has an *anode* (+) and *cathode* (-).
+2. **Wires:**
+ - **Orange Wire:** Connects battery anode to light bulb cathode.
+ - **Yellow Wire:** Connects battery cathode to the target object.
+ - **Green Wire:** Connects the target object to the light bulb anode.
+3. **Light Bulbs:** Use the **blue light bulb** as the indicator.
+4. **Target Object:** Must have two connection points (terminal 1 & terminal 2).
+
+## Connection Map
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-container-inspector/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-container-inspector/SKILL.md
new file mode 100644
index 0000000..5d82301
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-container-inspector/SKILL.md
@@ -0,0 +1,52 @@
+---
+name: scienceworld-container-inspector
+description: This skill performs a 'look at' action to inspect the contents of a specific container or device. It should be triggered when the agent needs to verify what is inside a container (e.g., checking if lead is in the blast furnace) or monitor the state of contents (e.g., solid vs. liquid). The skill outputs a detailed list of contents and their states, providing essential feedback for process monitoring.
+---
+# Skill: Container/Device Inspector
+
+## Purpose
+Execute a `look at` action on a specified container or device to retrieve a detailed observation of its contents and their states. This is a critical monitoring skill for verifying process steps, such as confirming an item is present inside a furnace or checking the phase (solid/liquid) of a substance.
+
+## When to Use
+Trigger this skill when you need to:
+1. **Verify Placement:** Confirm an object has been successfully moved into a target container (e.g., "Is the metal pot in the blast furnace?").
+2. **Monitor State Change:** Check if the contents of a container have changed state due to a process (e.g., "Has the lead melted into liquid lead?").
+3. **Inventory Check:** List all items currently stored inside an open container or device.
+
+## Core Instruction
+**Always use the exact action:** `look at <CONTAINER_NAME>`
+- Replace `<CONTAINER_NAME>` with the precise name of the target object (e.g., `blast furnace`, `cupboard`, `tin cup`).
+- This action returns a structured observation detailing the container's state and a list of its contents.
+
+## Expected Output & Interpretation
+The observation will follow this general pattern:
+`[CONTAINER], which is [STATE]. The [CONTAINER] door is [OPEN/CLOSED]. In the [CONTAINER] is: \n\t[LIST OF CONTENTS]`
+
+**Key Information to Extract:**
+1. **Container State:** Is it activated/turned on? (e.g., "which is turned on").
+2. **Door State:** Is it open or closed? You can only see contents if the door is open.
+3. **Contents List:** A nested list of all objects inside. Pay close attention to:
+ - **Item Names:** (e.g., `a metal pot`).
+ - **Substance States:** The description may reveal state changes (e.g., `a substance called liquid lead` vs. `a substance called lead`).
+ - **Nested Containers:** Contents may themselves be containers (e.g., `a metal pot (containing a substance called lead)`).
+
+## Example from Trajectory
+**Action:** `look at blast furnace`
+**Observation:** `a blast furnace, which is turned on. The blast furnace door is open. In the blast furnace is: \n\ta metal pot (containing a substance called liquid lead)`
+**Interpretation:** The blast furnace is active and open. It contains one item: a metal pot, which itself contains liquid lead. This confirms the heating process was successful and the lead has melted.
+
+## Integration with Other Actions
+This skill is often used in a sequence:
+1. `move <ITEM> to <CONTAINER>` (Place an item).
+2. `look at <CONTAINER>` (This skill - verify placement).
+3. `activate <CONTAINER>` (Start a process).
+4. `look at <CONTAINER>` (This skill - monitor state change).
+5. `use <TOOL> on <CONTENT>` (Proceed based on observed state).
+
+## Error Handling
+- If the `look at` action fails or returns an unexpected result, first verify the object's name is correct by using `look around` or `examine`.
+- If the container door is closed, you must `open` it before using this skill.
+- The skill only inspects; it does not manipulate contents. Use `pick up`, `move`, or `use` for manipulation.
+
+---
+*For detailed examples of container interactions and state transitions, see the reference documentation.*
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-container-inspector/references/container_inspection_examples.md b/skills/benchmark_skills/scienceworld/scienceworld-container-inspector/references/container_inspection_examples.md
new file mode 100644
index 0000000..e138a72
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-container-inspector/references/container_inspection_examples.md
@@ -0,0 +1,7 @@
+# Container Inspection: Examples & Patterns
+
+This document provides concrete examples of the `look at` action's output and how to interpret it for effective process monitoring.
+
+## Basic Structure
+**Action:** `look at cupboard`
+**Observation:**
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-container-item-retriever/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-container-item-retriever/SKILL.md
new file mode 100644
index 0000000..c871c02
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-container-item-retriever/SKILL.md
@@ -0,0 +1,30 @@
+---
+name: scienceworld-container-item-retriever
+description: This skill retrieves a specified item from a container by using the 'pick up' action. It should be triggered when the agent has identified a needed item inside an open container (e.g., a jar, box, or hive) and must transfer it to inventory for later use. The skill handles the object transfer, assuming the container is already accessible, and outputs confirmation that the item is now in the agent's inventory.
+---
+# Skill: Retrieve Item from Container
+
+## Purpose
+Transfer a specified item from an open, accessible container into the agent's inventory using the `pick up` action.
+
+## Trigger Conditions
+Use this skill when **all** of the following are true:
+1. The agent has identified a specific item needed for a task.
+2. The item is located inside a container (e.g., jar, box, hive, closet).
+3. The container is already open and accessible (no `open` action required).
+4. The agent's immediate goal is to possess the item for later use.
+
+## Core Action
+Execute the `pick up <ITEM>` action, where `<ITEM>` is the exact name of the target object as observed in the environment.
+
+## Execution Workflow
+1. **Verify Context:** Ensure the target item is present in the current room's observation and is inside an open container.
+2. **Execute Transfer:** Perform the `pick up <ITEM>` action.
+3. **Confirm Success:** The expected observation is: `"You move the <ITEM> to the inventory."` If a different result occurs, consult the troubleshooting guide.
+
+## Important Notes
+* **Pre-condition:** This skill assumes the container is already open. If the container is closed, you must use the `open` action first.
+* **Ambiguity:** If multiple identical items exist (e.g., "avocado seed, avocado seed, avocado seed"), the `pick up` action will typically retrieve one. The skill does not handle selecting a specific instance.
+* **Post-condition:** After successful execution, the item is in the agent's inventory and can be used in subsequent steps.
+
+For detailed examples and edge cases, see the reference documentation.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-container-item-retriever/references/execution_examples.md b/skills/benchmark_skills/scienceworld/scienceworld-container-item-retriever/references/execution_examples.md
new file mode 100644
index 0000000..c7a873d
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-container-item-retriever/references/execution_examples.md
@@ -0,0 +1,33 @@
+# Execution Examples & Edge Cases
+
+## Primary Example (From Trajectory)
+**Scenario:** Need an avocado seed from a seed jar in the greenhouse.
+1. **Observation Context:** `a seed jar (containing a avocado seed, a avocado seed, ...)`
+2. **Skill Execution:** `pick up seed jar`
+3. **Success Output:** `You move the seed jar to the inventory.`
+
+**Note:** In the provided trajectory, the entire container was picked up. The skill principle remains the same for picking up a specific item *from* the container (e.g., `pick up avocado seed`), assuming the container is open.
+
+## Alternative: Picking a Specific Item from Container
+**Scenario:** Need one "adult bee" from an open bee hive.
+1. **Observation Context:** `a bee hive. The bee hive door is open. In the bee hive is: a adult bee, a adult bee, ...`
+2. **Skill Execution:** `pick up adult bee`
+3. **Expected Output:** `You move the adult bee to the inventory.`
+
+## Edge Cases & Troubleshooting
+
+### Case 1: Container is Closed
+**Symptom:** `pick up` action fails or is not possible.
+**Solution:** You must open the container first using `open <CONTAINER>` before this skill can be applied.
+
+### Case 2: Item Not Found
+**Symptom:** Action results in an error or unexpected observation.
+**Pre-action Check:** Always verify the item is listed in the current room observation inside the specified container. Use `look around` or `look at <CONTAINER>` if unsure.
+
+### Case 3: Ambiguous Object Names
+**Symptom:** System prompts for clarification with a numbered list (as seen with `move` in the trajectory).
+**Guidance:** The `pick up` action in the provided environment typically does not trigger this ambiguity for items in open containers. If it does, select the first option (`0`) or the option that correctly identifies the item in the target container.
+
+### Case 4: Item is a Substance
+**Symptom:** Item is described as "a substance called X" (e.g., water, air).
+**Guidance:** Substances often cannot be picked up directly. They may require a container (e.g., `pour` action). This skill is for discrete, tangible objects.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-container-relocator/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-container-relocator/SKILL.md
new file mode 100644
index 0000000..d87cfcf
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-container-relocator/SKILL.md
@@ -0,0 +1,26 @@
+---
+name: scienceworld-container-relocator
+description: Moves an object from inventory to a specified container in a target room. Triggered when the task requires placing an item into a particular receptacle (e.g., 'move it to the orange box').
+---
+# Skill: Container Relocator
+
+## Purpose
+This skill handles the final delivery step in scienceWorld experiments where you must place a specific object into a designated container located in a target room.
+
+## Core Logic
+1. **Identify the Target:** The task will specify a destination container (e.g., "the orange box") and a room (e.g., "in the workshop").
+2. **Confirm Inventory:** Ensure the required object is already in your inventory. If not, you must first acquire it.
+3. **Navigate:** Teleport to the target room if you are not already there.
+4. **Execute Delivery:** Use the `move OBJ to OBJ` action to transfer the object from your inventory to the target container.
+
+## Key Instructions
+* Use this skill **only** when the task explicitly states a "move it to [CONTAINER] in [ROOM]" objective.
+* The object to be moved must be in your inventory. Use `focus on OBJ` to confirm the correct target if needed.
+* Always verify your location before attempting the move action. Use `teleport to LOC` to reach the correct room.
+* The primary action is `move [OBJECT] to [CONTAINER]`. Ensure the object name matches your inventory and the container name matches the room's description.
+
+## Example Flow (from trajectory)
+1. Task: "move it to the orange box in the workshop."
+2. Identify: Object = dove egg (in inventory), Container = orange box, Room = workshop.
+3. Action: `teleport to workshop`
+4. Action: `move dove egg to orange box`
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-container-relocator/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-container-relocator/references/action_primer.md
new file mode 100644
index 0000000..83de1a8
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-container-relocator/references/action_primer.md
@@ -0,0 +1,31 @@
+# Action Primer for scienceWorld
+
+## Relevant Actions for This Skill
+
+### Primary Action
+* **`move OBJ to OBJ`**: Transfers an object from your inventory or current location to a container or surface.
+ * Format: `move <object_name> to <container_name>`
+ * Example: `move dove egg to orange box`
+ * **Critical:** The object must be accessible (in inventory or in the room).
+
+### Prerequisite & Support Actions
+* **`teleport to LOC`**: Instantly moves the agent to a named room.
+ * Format: `teleport to <room_name>`
+ * Example: `teleport to workshop`
+ * Rooms: kitchen, foundry, workshop, bathroom, outside, living room, bedroom, greenhouse, art studio, hallway.
+
+* **`focus on OBJ`**: Signals intent on a task-relevant object. Use to confirm you have identified the correct item before picking it up or moving it.
+ * Format: `focus on <object_name>`
+ * Example: `focus on dove egg`
+
+* **`pick up OBJ`**: Moves an object from the environment into your inventory. Required before you can `move` an item that is not already in your inventory.
+ * Format: `pick up <object_name>`
+ * Example: `pick up dove egg`
+
+* **`look around`**: Describes the current room and lists visible objects and containers. Use to locate the target container.
+ * Format: `look around`
+
+## Common Object Naming Patterns
+* Objects may be referred to with articles (e.g., "a dove egg", "the orange box"). The action command typically uses the noun phrase without the article.
+* Compound names are used directly (e.g., `dove egg`, `orange box`).
+* If an object is described as being "on" something, it is a separate object (e.g., "a white pillow" on "a couch").
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-container-transfer/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-container-transfer/SKILL.md
new file mode 100644
index 0000000..8d06dbc
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-container-transfer/SKILL.md
@@ -0,0 +1,33 @@
+---
+name: scienceworld-container-transfer
+description: Moves a substance or object from one container to another (e.g., moving lead to a metal pot). Triggered when the agent needs to prepare materials for processing, such as transferring a substance into a heat-resistant container for heating experiments.
+---
+# Skill: Container Transfer
+
+## Purpose
+This skill orchestrates the transfer of a target substance or object from a source container to a destination container. It is a foundational step for preparing materials for subsequent operations like heating, mixing, or measurement.
+
+## Core Logic
+The skill is executed when the agent's goal requires moving a material to a more suitable container. The primary sequence, derived from the trajectory, is:
+1. **Identify & Locate:** Confirm the presence of the target substance and the destination container in the current environment.
+2. **Execute Transfer:** Use the `move OBJ to OBJ` action, where the first object is the target substance and the second is the destination container.
+3. **Verify:** Confirm the transfer was successful by examining the destination container's contents.
+
+## Instructions
+Follow this decision flow to perform a container transfer:
+
+1. **Assess the need for transfer.** Is the target substance in a container unsuitable for the next planned operation (e.g., a tin cup is not heat-resistant for a furnace)?
+2. **Locate the target substance and a suitable destination container** (e.g., `lead` in a `tin cup` and an empty `metal pot`). Use `look around` and `look at OBJ` actions.
+3. **Execute the transfer command:** `move <SUBSTANCE_NAME> to <DESTINATION_CONTAINER>`.
+ * Example: `move lead to metal pot`
+4. **Verify the transfer** by looking at the destination container: `look at <DESTINATION_CONTAINER>`.
+ * Expected observation: The container now lists the target substance in its contents.
+
+## Key Parameters
+* `<SUBSTANCE_NAME>`: The name of the substance or object to be moved (e.g., `lead`).
+* `<DESTINATION_CONTAINER>`: The name of the container to receive the substance (e.g., `metal pot`).
+
+## Notes
+* This skill assumes containers are already open, as per the environment rules.
+* The skill is context-aware; the destination container should be chosen based on the properties needed for the next step (e.g., heat resistance for a furnace).
+* If the transfer fails (e.g., "You can't do that"), check the object names and ensure the destination container is accessible and capable of holding the substance.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-container-transfer/references/container_properties.md b/skills/benchmark_skills/scienceworld/scienceworld-container-transfer/references/container_properties.md
new file mode 100644
index 0000000..7dcdec1
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-container-transfer/references/container_properties.md
@@ -0,0 +1,27 @@
+# Reference: Common Container Properties
+
+This document lists typical containers found in the ScienceWorld environment and their inferred properties to guide selection for the transfer skill.
+
+## Container Types & Suitability
+
+| Container | Typical Material | Heat Resistance | Suggested Use Case |
+| :----------------- | :--------------- | :-------------- | :-------------------------------------------------- |
+| **Metal Pot** | Metal | **High** | Heating substances in a furnace or on a stove. |
+| **Ceramic Cup** | Ceramic | Moderate | Holding hot liquids (not for direct flame). |
+| **Glass Jar/Cup** | Glass | Low-Variable | Storage, mixing; may crack with rapid temp change. |
+| **Tin Cup** | Metal (thin) | Low | General storage; not suitable for high-temperature heating. |
+| **Wood Cup** | Wood | **Low** | Cold storage only (e.g., in a fridge). |
+| **Bowl** | Variable | Low | Holding solid items, mixing (check material). |
+| **Drawer** | Wood/Metal | N/A | Storage of tools/items, not for active processing. |
+
+## Selection Heuristic
+When choosing a destination container for a transfer, ask:
+1. **What is the next operation?** (e.g., heating → requires heat-resistant container).
+2. **Is the container empty?** Check via `look at <container>`.
+3. **Is the container accessible?** It must be in the current room and not inside another closed object.
+
+## Example from Trajectory
+* **Operation:** Heat lead to melting point.
+* **Source:** `tin cup` (not suitable for blast furnace).
+* **Destination Selected:** `metal pot` (suitable for blast furnace).
+* **Command:** `move lead to metal pot`
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-controlled-waiting/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-controlled-waiting/SKILL.md
new file mode 100644
index 0000000..626d0a0
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-controlled-waiting/SKILL.md
@@ -0,0 +1,38 @@
+---
+name: controlled-waiting
+description: Executes timed waiting to allow processes like plant growth or pollination to progress. Use this skill when you need to advance time for biological or mechanical processes to reach their next stages. This enables progression in tasks that require temporal development rather than immediate actions.
+---
+# Skill: Controlled Waiting
+
+## Purpose
+This skill orchestrates a strategic waiting pattern to allow time-dependent processes (e.g., plant growth, chemical reactions, mechanical cycles) to complete. It is triggered when the agent's primary task is blocked, pending the natural progression of a state.
+
+## Core Logic
+The skill follows a **Monitor-Wait-Check** cycle:
+1. **Assess State:** Confirm the process requiring time is active (e.g., seeds are planted, device is activated).
+2. **Execute Wait:** Use the `wait` action (for long periods) or `wait1` (for single steps) to advance the simulation.
+3. **Verify Progress:** After waiting, check the environment (`look around` or `examine`) to see if the target state has been reached.
+4. **Repeat or Exit:** If the target state is not yet achieved, loop back to step 2. If achieved, exit the skill and resume the main task.
+
+## Key Parameters & Decisions
+* **Wait Duration:** Use `wait` (10 steps) for significant biological/mechanical stages. Use `wait1` for fine-grained control or to observe rapid changes.
+* **Monitoring Frequency:** The interval between checks. Derived from the trajectory: after 2-3 `wait` actions, a `look around` is performed. Adjust based on the estimated time of the process.
+* **Exit Condition:** Clearly defined by the main task goal (e.g., "banana is present", "device status is 'ready'").
+
+## When to Use This Skill
+* After initiating a process that has a known or unknown delay.
+* When the environment state is stable and no other preparatory actions are possible.
+* When prompted by task context (e.g., "give them time to grow", "wait for the reaction to complete").
+
+## When NOT to Use This Skill
+* When you can perform other productive actions in parallel.
+* When the process is instantaneous or requires a specific trigger (e.g., pressing a button).
+* If waiting would cause a negative outcome (e.g., a timer expires, an object decays).
+
+## Integration with Main Task
+This skill is a **subroutine**. The main task should:
+1. Set up the necessary conditions for the time-based process.
+2. Invoke this skill.
+3. Upon skill completion, verify the outcome and proceed with the next task step (e.g., harvest the grown banana).
+
+Refer to `references/botanical_growth_patterns.md` for common plant growth stage timings.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-controlled-waiting/references/botanical_growth_patterns.md b/skills/benchmark_skills/scienceworld/scienceworld-controlled-waiting/references/botanical_growth_patterns.md
new file mode 100644
index 0000000..160860b
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-controlled-waiting/references/botanical_growth_patterns.md
@@ -0,0 +1,20 @@
+# Botanical Growth & Pollination Patterns
+
+## Observed Timeline (Derived from Trajectory)
+The following pattern was observed for banana plant growth in the provided simulation environment. Use this as a heuristic for similar tasks.
+
+1. **Planting to Reproduction:** ~30 simulation steps (3 x `wait` actions).
+ * Action Sequence: Plant seed -> `wait` (x3) -> Plant reaches "reproducing stage" with flowers.
+
+2. **Flowering to Fruit Set:** Variable, requires pollination trigger.
+ * Observation: Flowers persisted through multiple `wait` cycles without fruit.
+ * **Trigger Identified:** Closing environment doors (containing bees) acted as a pollination catalyst.
+ * Post-trigger, fruit (bananas) appeared within ~20-30 steps (2-3 x `wait` actions).
+
+3. **Key Insight:** Some growth stages are purely time-based, while others (like fruit set) require specific environmental conditions *in addition* to time.
+
+## General Guidelines for Controlled Waiting
+* **Baseline Wait:** Start with 2-3 `wait` commands for any biological growth stage transition.
+* **Check Point:** Always perform a `look around` or `examine` after a baseline wait to assess progress.
+* **Stalled Progress:** If no change occurs after two baseline cycles, investigate environmental prerequisites (e.g., pollinators, water, light, closed containers).
+* **Pollination Note:** The presence of bees (`adult bee`) and an open `bee hive` suggests a pollination mechanic. Containing them (`close door`) may be necessary to initiate the process.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-device-activator/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-device-activator/SKILL.md
new file mode 100644
index 0000000..4e8a6be
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-device-activator/SKILL.md
@@ -0,0 +1,37 @@
+---
+name: scienceworld-device-activator
+description: This skill activates a device (e.g., blast furnace, stove) to initiate a process like heating. It should be triggered when the agent has placed materials in a device and needs to start the device's operation. The skill takes a device name as input and outputs a confirmation of activation, which is critical for progressing tasks that require energy or processing.
+---
+# Device Activation Skill
+
+## Purpose
+Activate a specific device to begin its operation (e.g., heating, processing). This is a critical step when materials have been placed into a device and require energy input to proceed with an experiment or task.
+
+## When to Use
+- You have confirmed that the target materials are properly placed inside the device.
+- The device is in a deactivated or "off" state.
+- The next step in your task requires the device to be operating (e.g., heating lead in a blast furnace).
+
+## Core Instruction
+Execute the `activate` action on the target device.
+
+**Action Format:** `activate <DEVICE_NAME>`
+
+**Example:** `activate blast furnace`
+
+## Prerequisites
+1. **Material Placement:** Ensure the target material(s) are inside the device. Use `look at <DEVICE_NAME>` to verify contents.
+2. **Device State:** Confirm the device is deactivated. The observation will typically indicate "which is turned off" or "which is deactivated."
+3. **Safety Check:** Ensure the device door is open if required for loading. Most devices in this environment are pre-opened.
+
+## Post-Activation Steps
+1. **Verification:** After activation, check the device state with `look at <DEVICE_NAME>` or `examine <DEVICE_NAME>` to confirm it's now "turned on" or "activated."
+2. **Monitoring:** Use appropriate measurement tools (e.g., thermometer) on the materials inside the device to track progress.
+3. **Deactivation:** Remember to deactivate the device when the process is complete using `deactivate <DEVICE_NAME>`.
+
+## Common Devices & Context
+- **Blast Furnace:** For high-temperature melting (e.g., metals like lead).
+- **Stove/Oven:** For general heating tasks.
+- **Other Devices:** Any device with an observable on/off state that requires activation to function.
+
+For detailed device specifications and safety guidelines, see the reference documentation.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-device-activator/references/device_specifications.md b/skills/benchmark_skills/scienceworld/scienceworld-device-activator/references/device_specifications.md
new file mode 100644
index 0000000..ce48f7b
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-device-activator/references/device_specifications.md
@@ -0,0 +1,38 @@
+# Device Specifications & Activation Protocols
+
+## Blast Furnace
+- **Purpose:** High-temperature melting of metals and materials.
+- **Activation Command:** `activate blast furnace`
+- **Typical Operating Temperature:** 400-2000°C
+- **Safety Protocols:**
+ - Ensure materials are in a heat-resistant container (e.g., metal pot).
+ - Verify door is open before loading (usually pre-opened in this environment).
+ - Do not touch while activated.
+- **Confirmation Output:** "The blast furnace is now activated."
+- **Deactivation Command:** `deactivate blast furnace`
+
+## Stove
+- **Purpose:** General heating and cooking.
+- **Activation Command:** `activate stove`
+- **Typical Operating Temperature:** 50-300°C
+- **Safety Protocols:**
+ - Use appropriate cookware.
+ - Monitor temperature to prevent burning.
+- **Confirmation Output:** "The stove is now turned on."
+- **Deactivation Command:** `deactivate stove`
+
+## Oven
+- **Purpose:** Enclosed heating/baking.
+- **Activation Command:** `activate oven`
+- **Typical Operating Temperature:** 100-250°C
+- **Safety Protocols:**
+ - Use oven-safe containers.
+ - Allow preheating if required by recipe.
+- **Confirmation Output:** "The oven is now turned on."
+- **Deactivation Command:** `deactivate oven`
+
+## General Activation Principles
+1. **State Verification:** Always check device state before and after activation.
+2. **Material Readiness:** Activation should only occur after materials are properly loaded.
+3. **Energy Consumption:** Activated devices consume energy; deactivate when not in use.
+4. **Process Monitoring:** Use measurement tools (thermometer, stopwatch) to monitor activated processes.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-environment-isolation/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-environment-isolation/SKILL.md
new file mode 100644
index 0000000..27f0def
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-environment-isolation/SKILL.md
@@ -0,0 +1,28 @@
+---
+name: scienceworld-environment-isolation
+description: Closes doors or openings to create a contained environment for controlled processes. Trigger this when you need to isolate a space (like a greenhouse) to optimize conditions for pollination or other environmental-sensitive tasks. This modifies room connectivity to create optimal conditions for specific processes.
+---
+# Instructions
+
+## When to Use
+Trigger this skill when you need to:
+1. **Optimize Pollination:** Isolate a room (like a greenhouse) to concentrate pollinators (e.g., bees) and prevent them from leaving, thereby increasing the chance of successful cross-pollination between plants.
+2. **Control Environmental Factors:** Create a stable, contained space to manage variables like temperature, humidity, or airflow for a sensitive process.
+3. **Prevent Contamination or Interference:** Seal off a room to protect an ongoing experiment or task from external disturbances.
+
+## Core Action Sequence
+1. **Assess the Environment:** Use `look around` to identify all doors, windows, or other openings in the current room.
+2. **Execute Isolation:** For each identified opening (e.g., "door to the outside", "door to the hallway"), issue a `close` command.
+ * **Example:** `close door to outside`
+ * **Example:** `close door to hallway`
+3. **Verify Closure:** Perform a final `look around` to confirm all intended openings are now closed and the room is successfully isolated.
+
+## Key Principles
+* **Completeness:** Ensure *all* exits are closed for full isolation. An open door can defeat the purpose.
+* **Context-Specific:** The specific doors to close depend entirely on the room's layout. Always verify via `look around`.
+* **Post-Isolation:** After isolation, monitor the contained process (e.g., plant growth) and use `wait` actions as needed to allow time for the optimized conditions to take effect.
+
+## Notes
+* This skill modifies the **connectivity** of a space, not its internal state (like temperature controls).
+* The primary observed benefit in the trajectory was enhancing bee-mediated pollination by preventing bee escape.
+* Reversal (re-opening doors) is not part of this skill's core function but can be done using standard `open` commands if needed later.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-environment-isolation/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-environment-isolation/references/action_primer.md
new file mode 100644
index 0000000..32de8d0
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-environment-isolation/references/action_primer.md
@@ -0,0 +1,13 @@
+# Action Primer for Environment Isolation
+
+## Relevant Standard Actions
+* `look around`: **Critical.** Use this first to survey the room and identify all closable openings (doors, gates, windows).
+* `close OBJ`: The core action. `OBJ` must be the exact name of the opening as listed in the `look around` observation (e.g., "door to the outside").
+
+## Handling Ambiguity
+If an action (like `focus on OBJ`) returns an "Ambiguous request" prompt after isolation, it is unrelated to this skill. Resolve it by selecting the appropriate numeric option corresponding to your intended target.
+
+## Sequencing with Other Skills
+1. **Preparation First:** Often, tasks like planting (`move seed to pot`) or setting up devices should be completed *before* isolation.
+2. **Isolation Middle:** Apply this skill after setup but before the critical waiting period for the process (e.g., pollination).
+3. **Monitoring After:** Use `wait` and periodic `look around` checks after isolation to observe outcomes.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-environment-scanner/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-environment-scanner/SKILL.md
new file mode 100644
index 0000000..3bf28bb
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-environment-scanner/SKILL.md
@@ -0,0 +1,19 @@
+---
+name: scienceworld-environment-scanner
+description: This skill performs an initial observation of the current location to identify available objects, containers, and connections to other rooms. Use this when starting a new task in ScienceWorld to gather situational awareness, especially when the agent needs to understand its surroundings before taking action. It outputs a detailed room description, listing visible items and accessible doors.
+---
+# Instructions
+
+Execute this skill when you first arrive at a location in ScienceWorld or when you need to refresh your understanding of the current environment.
+
+## Core Action
+1. **Always begin by using the `look around` action.** This is the primary and mandatory step of this skill. It provides the foundational observation of the room.
+
+## Output Interpretation
+After executing `look around`, analyze the observation. Your analysis must structure the output clearly:
+* **Current Room:** State the name of the room you are in.
+* **Visible Objects & Substances:** List all items and substances reported in the observation.
+* **Accessible Doors:** List all doors mentioned, noting their destination and whether they are open or closed.
+* **Initial Assessment:** Briefly note any items of immediate interest or relevance to your known task.
+
+## Example Output Format
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-environment-scanner/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-environment-scanner/references/action_primer.md
new file mode 100644
index 0000000..3a8f122
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-environment-scanner/references/action_primer.md
@@ -0,0 +1,22 @@
+# ScienceWorld Action Primer for Environment Scanning
+
+## Primary Scanning Action
+* `look around`: Describes the current room, listing all visible objects, substances, and doors to other rooms. This is the core action for the `scienceworld-environment-scanner` skill.
+
+## Context for Other Common Actions
+*(This section is for reference when planning post-scan steps. Do not use these during the scan itself.)*
+
+### Navigation
+* `teleport to LOC`: Instantly moves the agent to a named room (e.g., `teleport to kitchen`). Use after scanning to move towards a goal.
+
+### Object Interaction
+* `examine OBJ`: Provides a detailed description of a specific object.
+* `look at OBJ`: Lists the contents inside a container.
+* `pick up OBJ`: Moves a freestanding object into the agent's inventory.
+
+### Task Signaling
+* `focus on OBJ`: Explicitly marks an object as the current target of the task. Often required before manipulating key objects.
+
+## Important Constraints (from Trajectory)
+* All containers are pre-opened. You can `look at` them directly without needing to `open` them first.
+* You can `teleport` to any known room in a single step.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-growth-focuser/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-growth-focuser/SKILL.md
new file mode 100644
index 0000000..854f42e
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-growth-focuser/SKILL.md
@@ -0,0 +1,31 @@
+---
+name: scienceworld-growth-focuser
+description: This skill applies a 'focus on' action to a specific plant or biological entity to signal intent and monitor its development. It should be triggered after planting or when the agent needs to track the growth stage of a plant (e.g., to observe sprouting, flowering, or reproduction). The skill outputs a confirmation of focus, which may be necessary for triggering or tracking life cycle progression in the environment.
+---
+# Skill: Growth Focuser
+
+## Purpose
+Apply the `focus on` action to a specific biological entity (e.g., a planted seed or growing plant) to signal your intent to monitor its development. This action is often a prerequisite for the environment to process growth stages or trigger life cycle progression events.
+
+## When to Use
+Use this skill when:
+1. **After Planting:** You have just placed a seed or seedling into a suitable growth medium (e.g., soil with water).
+2. **Stage Monitoring:** You need to check or trigger a progression in the plant's life cycle (e.g., from seed to sprout, sprout to mature plant, flowering, or reproduction).
+3. **Intent Signaling:** The task requires you to explicitly indicate which entity you are observing or nurturing.
+
+## Core Instruction
+1. **Identify the Target:** Locate the specific plant or seed you intend to focus on. Ensure it is in a valid state for growth (e.g., planted in soil with water).
+2. **Execute Focus:** Use the action: `focus on <PLANT_OBJECT> [in <CONTAINER>]`.
+ * Replace `<PLANT_OBJECT>` with the exact name of the biological entity (e.g., `avocado seed`).
+ * Use the optional `[in <CONTAINER>]` clause if the object is inside another object (e.g., `avocado seed in flower pot 1`). This is crucial for disambiguation.
+3. **Confirm & Wait:** Upon successful focus, you will receive a confirmation. Biological growth requires time. Use `wait` actions strategically after focusing to allow the simulated environment to process development stages.
+
+## Key Considerations
+* **Disambiguation:** If multiple identical objects exist, the environment may prompt you to choose. Always specify the container (e.g., `in flower pot 1`) to avoid this.
+* **Prerequisites:** The `focus on` action typically follows preparatory steps like `teleport to <location>`, `pick up <item>`, and `move <seed> to <pot>`.
+* **Patience is Required:** Growth is not instantaneous. The `focus on` action signals intent, but you must follow it with `wait` actions to observe results.
+
+## Quick Reference
+**Trigger Condition:** Seed/Plant is in a growth-ready state.
+**Primary Action:** `focus on <PLANT_OBJECT> [in <CONTAINER>]`
+**Next Steps:** Use `wait` to allow time for growth progression.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-growth-focuser/references/trajectory_analysis.md b/skills/benchmark_skills/scienceworld/scienceworld-growth-focuser/references/trajectory_analysis.md
new file mode 100644
index 0000000..572a4c4
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-growth-focuser/references/trajectory_analysis.md
@@ -0,0 +1,22 @@
+# Trajectory Analysis & Rationale
+
+## Skill Derivation
+This skill is extracted from the provided trajectory where the agent successfully grows an avocado plant. The critical pattern identified is the use of `focus on` as a deliberate action to signal monitoring intent on a biological entity, which appears to be a mechanic for tracking or enabling growth stages in the ScienceWorld environment.
+
+## Observed Workflow
+1. **Locate & Acquire Seed:** `teleport to greenhouse` -> `look around` -> `pick up seed jar`.
+2. **Plant Seed:** `move avocado seed in seed jar to flower pot 1` (Note: Required disambiguation by selecting option `0`).
+3. **Apply Skill - Focus:** `focus on avocado seed in flower pot 1`.
+4. **Monitor Growth:** Series of `wait` actions following the focus.
+
+## Environment Mechanics Inferred
+* `focus on` is a distinct, non-physical action separate from `examine` or `look at`.
+* It may set an internal flag for the focused object, making it eligible for state changes over simulated time (`wait`).
+* The action likely requires a precise object reference, including its container location for disambiguation.
+
+## Action Syntax Examples from Trajectory
+* `focus on avocado seed in flower pot 1`
+* `move avocado seed in seed jar to flower pot 1` (Pre-requisite action pattern)
+
+## Why This is a Separate Skill
+The `focus on` action is a specific, high-level command with semantic meaning ("I am now monitoring this for development"). It is not a general observation action. Bundling it as a skill ensures the agent understands the contextual trigger (post-planting) and the strategic importance of this action for achieving tasks involving biological growth.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-heating-apparatus-setup/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-heating-apparatus-setup/SKILL.md
new file mode 100644
index 0000000..19d43ec
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-heating-apparatus-setup/SKILL.md
@@ -0,0 +1,42 @@
+---
+name: scienceworld-heating-apparatus-setup
+description: This skill positions a container with a substance onto a heating device (stove, oven) and activates the device. It should be triggered when a task requires melting, boiling, or heating a substance. The skill moves the prepared container to the heating element and turns it on.
+---
+# Instructions
+
+## Purpose
+This skill automates the setup of a heating apparatus for scientific experiments involving melting, boiling, or heating a substance. It handles the positioning of a prepared container onto a heating element and the activation of the device.
+
+## Prerequisites
+1. **Target Substance:** The substance to be heated (e.g., chocolate, water) must be located and identified.
+2. **Suitable Container:** A compatible, heat-safe container (e.g., metal pot, beaker) must be available in the environment.
+3. **Heating Device:** A functional heating device (e.g., stove, oven) must be present and accessible.
+4. **Location:** The agent should be in the same room as the required items (kitchen, workshop, etc.).
+
+## Core Procedure
+Follow this sequence to execute the skill. Use the bundled `setup_heater.py` script for reliable, error-prone steps (1-4).
+
+1. **Prepare the Substance:** Ensure the target substance is placed into the chosen container.
+ * *High Freedom Decision:* Select the most appropriate container based on the substance and heating method.
+ * *Action Pattern:* `move <SUBSTANCE> to <CONTAINER>`
+
+2. **Position the Container:** Move the prepared container onto the heating device.
+ * *Action Pattern:* `move <CONTAINER> to <HEATING_DEVICE>`
+
+3. **Activate the Heater:** Turn on the heating device to begin the thermal process.
+ * *Action Pattern:* `activate <HEATING_DEVICE>`
+
+4. **Verify Setup:** Confirm the container is correctly positioned and the device is active.
+ * *Action Pattern:* `look at <HEATING_DEVICE>`
+ * *Expected Observation:* The device is "turned on" and the container is listed as being on it.
+
+## Post-Setup & Monitoring
+After the heating apparatus is active, proceed with the main experiment (e.g., temperature measurement). Use the bundled `monitor_temperature.py` script for consistent temperature checks.
+* **Monitor State:** Regularly examine the substance (`examine <SUBSTANCE>`) to observe phase changes (e.g., solid -> liquid).
+* **Measure Temperature:** Use a thermometer (`use thermometer on <SUBSTANCE>`) to track thermal progress.
+
+## Error Handling & Notes
+* If the initial `look around` does not reveal the necessary items, use `teleport to <ROOM>` to navigate to the correct location (e.g., kitchen).
+* All containers are pre-opened. Do not use `open` or `close` actions.
+* The skill assumes the heating device is initially deactivated and ready for use.
+* For complex thermal protocols (specific ramp rates, hold times), consult the `references/thermal_procedures.md` guide.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-heating-apparatus-setup/references/thermal_procedures.md b/skills/benchmark_skills/scienceworld/scienceworld-heating-apparatus-setup/references/thermal_procedures.md
new file mode 100644
index 0000000..6821e53
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-heating-apparatus-setup/references/thermal_procedures.md
@@ -0,0 +1,27 @@
+# Thermal Procedure Reference
+
+## Overview
+This document provides supplementary context for heating-related experiments, detailing common substances, their properties, and best practices.
+
+## Common Substance Melting/Boiling Points
+* **Chocolate:** Melting point typically ranges between 30°C and 32°C (86-90°F) for cocoa butter. Compound chocolate may have different properties.
+* **Water:** Boiling point is 100°C at standard atmospheric pressure.
+* **Sodium Chloride (Salt):** Melting point is 801°C.
+
+## Heating Device Profiles
+| Device | Typical Use Case | Activation Command | Notes |
+|-----------|---------------------------|--------------------|-------|
+| Stove | Heating containers directly | `activate stove` | Used for pots, pans. Provides direct heat. |
+| Oven | Enclosed, ambient heating | `activate oven` | Used for baking, roasting. Heat surrounds container. |
+| Hot Plate | Precise heating of labware| `activate hot plate`| Common in laboratory settings. |
+
+## Safety & Best Practices
+1. **Container Selection:** Always use a container suitable for the heating device (e.g., metal pot for stove, glass beaker for hot plate).
+2. **Never Heat Closed Containers:** Ensure containers are open or vented to prevent pressure buildup.
+3. **Monitor Continuously:** Heating can cause rapid phase changes. Use the `monitor_temperature.py` script for consistent observation.
+4. **Deactivate After Use:** Once the experiment is complete, remember to `deactivate` the heating device.
+
+## Troubleshooting
+* **Substance Not Heating:** Verify the container is correctly positioned *on* the heating element (use `look at <DEVICE>`).
+* **Temperature Not Rising:** Confirm the heating device is activated (`activate <DEVICE>`).
+* **Incorrect Phase Change:** Consult the melting/boiling point table above to set appropriate expectations.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-instruction-reader/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-instruction-reader/SKILL.md
new file mode 100644
index 0000000..837ebf3
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-instruction-reader/SKILL.md
@@ -0,0 +1,19 @@
+---
+name: scienceworld-instruction-reader
+description: This skill reads a recipe or note from the inventory using the 'read' action. It should be triggered after acquiring a recipe or document to extract explicit instructions, ingredient lists, or procedural steps. The skill parses the text content and outputs the key information needed to execute the task, such as required components and their combinations.
+---
+# Instructions
+Use this skill when you have acquired a recipe, note, or any readable document in your inventory and need to understand its contents to proceed with a task.
+
+## Core Action
+1. **Read the Document:** Use the `read OBJ` action on the document in your inventory.
+ * **Example:** `read recipe in inventory`
+
+## Skill Logic
+After reading, analyze the text to identify:
+* **Goal:** The final product or objective (e.g., "make salt water").
+* **Required Components:** A list of items or substances needed (e.g., "sodium chloride, water").
+* **Procedural Steps:** Any explicit actions or combinations described (e.g., "mix sodium chloride, water").
+
+## Output Format
+Present the extracted information clearly. For example:
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-instruction-reader/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-instruction-reader/references/action_primer.md
new file mode 100644
index 0000000..a3c1200
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-instruction-reader/references/action_primer.md
@@ -0,0 +1,21 @@
+# Action Primer for ScienceWorld Environment
+
+This document lists common actions used in conjunction with the `scienceworld-instruction-reader` skill to execute tasks based on extracted instructions.
+
+## Navigation & Exploration
+* `teleport to LOC`: Instantly move to a named room (e.g., `teleport to workshop`).
+* `look around`: Observe the current room's contents and exits.
+
+## Inventory & Object Manipulation
+* `pick up OBJ`: Move an object into your inventory.
+* `examine OBJ`: Get a detailed description of an object, including its contents if it's a container.
+* `move OBJ to OBJ`: Place an object into a container or onto a surface.
+
+## Task Execution (Common for Chemistry/Experiments)
+* `mix OBJ`: Chemically combine the contents of a container.
+* `pour OBJ into OBJ`: Transfer a liquid between containers.
+* `use OBJ [on OBJ]`: Employ a tool or device.
+* `activate OBJ` / `deactivate OBJ`: Turn a device (like a sink) on or off.
+
+## Task Completion
+* `focus on OBJ`: Signal intent on a final task object to indicate completion.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-inventory-focus/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-inventory-focus/SKILL.md
new file mode 100644
index 0000000..14616de
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-inventory-focus/SKILL.md
@@ -0,0 +1,36 @@
+---
+name: scienceworld-inventory-focus
+description: This skill focuses on a specific item within the agent's inventory to confirm its identity or prepare it for use. It should be triggered before using an inventory item in an experiment or when verifying that the correct item has been collected. The skill helps ensure operational readiness and intentional task progression.
+---
+# Skill: Inventory Focus
+
+## Purpose
+Use this skill to intentionally examine and prepare an item from your inventory before using it in a task. This act of "focusing" confirms the item's presence, state, and readiness, reducing errors in multi-step procedures.
+
+## Primary Trigger
+Trigger this skill when you have picked up a required item and need to:
+1. Verify it is the correct object for the next step.
+2. Signal your intent to use it.
+3. Prepare it for a subsequent action (e.g., measurement, combination).
+
+## Core Instruction
+Execute the `focus on [ITEM] in inventory` action. Replace `[ITEM]` with the exact name of the object you have collected.
+
+## Standard Operating Procedure (SOP)
+Follow this sequence when an item from your inventory is needed for a critical task:
+
+1. **Acquire:** First, ensure the target item is in your inventory (e.g., `pick up thermometer`).
+2. **Focus:** Execute this skill: `focus on [ITEM] in inventory`.
+3. **Proceed:** After receiving confirmation, proceed with the intended use of the item (e.g., `use thermometer on unknown substance B`).
+
+## Example from Trajectory
+* **Goal:** Measure the temperature of `unknown substance B`.
+* **Procedure:**
+ 1. `pick up thermometer`
+ 2. `focus on thermometer in inventory` *(This skill)*
+ 3. `pick up unknown substance B`
+ 4. `focus on unknown substance B in inventory` *(This skill)*
+ 5. `use thermometer on unknown substance B`
+
+## Key Principle
+Treat `focus on` as a deliberate checkpoint. It does not change the state of the object but changes the agent's state of awareness and intent, leading to more reliable task execution.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-inventory-focus/references/action_context.md b/skills/benchmark_skills/scienceworld/scienceworld-inventory-focus/references/action_context.md
new file mode 100644
index 0000000..8e66c06
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-inventory-focus/references/action_context.md
@@ -0,0 +1,19 @@
+# Action Context for ScienceWorld Environment
+
+## Relevant Actions for This Skill
+* `pick up OBJ`: Moves an object from the environment to the agent's inventory. A prerequisite for using the `focus` skill on that object.
+* `focus on OBJ`: The core action of this skill. When the object is in inventory, use the format `focus on OBJ in inventory`.
+
+## Environment Assumptions (From Trajectory)
+The provided trajectory operates under specific world assumptions that simplify task execution:
+* **Teleportation:** You can `teleport to LOC` instantly between named rooms.
+* **Open Containers:** All containers (cupboards, drawers, fridges) are already open. You can directly see and take items from them.
+* **Inventory:** The agent has an implicit inventory. Picked-up items are moved "to the inventory" and can be focused on or used from there.
+
+## Common Object Names
+Based on the trajectory, be precise with object names:
+* `thermometer`
+* `unknown substance B`
+* `blue box`
+* `green box`
+* `lighter`, `stopwatch`, `glass jar`, etc.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-inventory-manager/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-inventory-manager/SKILL.md
new file mode 100644
index 0000000..46de0fc
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-inventory-manager/SKILL.md
@@ -0,0 +1,37 @@
+---
+name: scienceworld-inventory-manager
+description: This skill handles picking up objects from the environment into the agent's inventory or moving them out. It should be triggered when the agent needs to acquire an object for later use or place an object into a container. The input is an object name and location, and the output is the object being transferred to or from inventory.
+---
+# Instructions
+
+## Purpose
+Use this skill to manage the agent's inventory by picking up objects from the environment or placing them into containers. This is a foundational action for acquiring tools, materials, or evidence needed for tasks.
+
+## When to Use
+- You need to acquire an object for later use in an experiment or task.
+- You need to place an object into a specific container (e.g., a box, a table, a room) as part of a task requirement.
+- The object's location is known or can be inferred from context.
+
+## Core Action Pattern
+The primary action is `pick up OBJ` to acquire an object or `move OBJ to OBJ` to place it into a container. The exact syntax may vary slightly based on the environment's action space (e.g., `pick up metal pot containing nothing in kitchen` vs. `move metal pot to blue box`).
+
+## Procedure
+1. **Locate the Object:** Ensure you are in the correct room or that the object is in your immediate vicinity. Use `look around` or `examine` if needed.
+2. **Acquire the Object:** If the object is not in your inventory, use the `pick up` action with the correct object identifier and location.
+3. **Place the Object (if required):** If the task requires placing the object into a container, use the `move` action with the target container's name.
+
+## Key Considerations
+- **Object State:** Some objects may be described as "containing nothing." Include this in the action if the environment's grammar requires it (e.g., `pick up metal pot containing nothing in kitchen`).
+- **Container Targets:** When moving an object to a container like a box, use the container's name and color if specified (e.g., `blue box`, `orange box`).
+- **Inventory Management:** You can only hold one item in your inventory at a time in the provided trajectory. Plan your actions accordingly.
+
+## Example from Trajectory
+**Goal:** Acquire the metal pot from the kitchen.
+- Action: `pick up metal pot containing nothing in kitchen`
+- Result: "You move the metal pot to the inventory."
+
+**Goal:** Place the conductive metal pot into the correct box.
+- Action: `move metal pot to blue box`
+- Result: The object is transferred from inventory (or the room) to the specified container.
+
+For complex object interactions or environment-specific grammar, consult the bundled reference.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-inventory-manager/references/environment_actions.md b/skills/benchmark_skills/scienceworld/scienceworld-inventory-manager/references/environment_actions.md
new file mode 100644
index 0000000..aaea84a
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-inventory-manager/references/environment_actions.md
@@ -0,0 +1,30 @@
+# ScienceWorld Environment: Action Reference
+
+## Core Inventory & Object Manipulation Actions
+Based on the provided trajectory, the environment accepts the following action patterns for inventory management:
+
+1. `pick up OBJ [containing STATE] in LOC`
+ - **Purpose:** Transfers an object from a location into the agent's inventory.
+ - **Examples:**
+ - `pick up metal pot containing nothing in kitchen`
+ - `pick up battery in workshop`
+
+2. `move OBJ to OBJ`
+ - **Purpose:** Moves an object (from inventory or the current room) into a container or to a location.
+ - **Examples:**
+ - `move metal pot to blue box`
+ - `move battery to table`
+
+## Important Grammar Notes
+- **Object Specifiers:** Objects are often described with their state, such as "containing nothing." Including this state in the `pick up` action may be necessary for the action to succeed.
+- **Location Specifiers:** The `in LOC` part of the `pick up` action seems to require the room name where the object is located.
+- **Container Names:** Containers are referred to by their descriptive names (e.g., `blue box`, `orange box`, `table`, `sink`).
+
+## Related Supporting Actions
+- `look around`: Describes the current room and lists visible objects and containers.
+- `examine OBJ`: Provides a detailed description of a specific object.
+- `look at OBJ`: Describes a container's contents.
+- `teleport to LOC`: Instantly moves the agent to a named room.
+
+## Inventory Constraints
+From the observed trajectory, the agent's inventory appears to hold one object at a time. The action `drop OBJ` (or its equivalent `move OBJ to LOC`) is used to place the held item back into the environment.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-item-fetcher/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-item-fetcher/SKILL.md
new file mode 100644
index 0000000..da27844
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-item-fetcher/SKILL.md
@@ -0,0 +1,33 @@
+---
+name: scienceworld-item-fetcher
+description: This skill picks up a specified object from the environment and moves it into the agent's inventory. It should be triggered when the agent identifies a required tool or material (e.g., thermometer, metal pot) that needs to be collected for later use. The skill takes an object name as input and confirms the item's transfer to inventory, facilitating object manipulation across locations.
+---
+# Skill: Fetch and Inventory Item
+
+## Purpose
+Use this skill when you need to acquire a specific object for a task. It handles locating the object in the current environment and moving it into your inventory for later use.
+
+## Core Workflow
+1. **Identify Need:** Determine which object is required for your current or upcoming task (e.g., "thermometer", "metal pot").
+2. **Locate Object:** Ensure you are in the correct room. Use `look around` to survey the environment and confirm the object is present and accessible.
+3. **Execute Fetch:** Use the `pick up` action on the target object.
+4. **Verify Success:** Confirm the system observation states the object has been moved to your inventory.
+
+## Key Principles
+* **Pre-check:** Always `look around` first to verify the object's presence and location (e.g., on a counter, in a container).
+* **Direct Action:** Use the simple `pick up OBJ` command. Do not overcomplicate the sequence.
+* **Inventory Focus:** After picking up the object, you may `focus on` it in your inventory to signal readiness for the next step in your main task.
+* **Error Handling:** If `pick up` fails, the object might be inside a closed container. Ensure all relevant containers are open first.
+
+## Example from Trajectory
+**Scenario:** Needing a thermometer to measure temperature.
+1. Observation: `a thermometer, currently reading a temperature of 10 degrees celsius` is seen in the kitchen.
+2. Action: `pick up thermometer`
+3. Result: `You move the thermometer to the inventory.`
+4. (Optional) Action: `focus on thermometer in inventory`
+
+## Input
+* **Object Name:** The name of the object to fetch, as it appears in the environment observations (e.g., "thermometer", "metal pot").
+
+## Output
+* A confirmation observation that the object is now in the agent's inventory.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-item-fetcher/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-item-fetcher/references/action_primer.md
new file mode 100644
index 0000000..4fc3648
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-item-fetcher/references/action_primer.md
@@ -0,0 +1,18 @@
+# Action Primer for Object Fetching
+
+## Primary Action
+`pick up OBJ`
+* **Effect:** Moves the specified object from the environment into the agent's inventory.
+* **Precondition:** The object must be present in the current room and accessible (not fixed, not inside a *closed* container).
+* **Postcondition:** The object is listed in the agent's inventory and can be referenced as `OBJ in inventory`.
+
+## Supporting Actions
+* `look around`: **CRITICAL.** Use this to scan the current room and identify all visible objects and their states before attempting to pick anything up.
+* `look at OBJ`: Use if you need to inspect the contents of a container (e.g., a cupboard, a pot) to find your target object.
+* `focus on OBJ`: Use after a successful `pick up` to signal that the fetched item is the current subject of intent for the overarching task.
+* `teleport to LOC`: Use to navigate to the room where the target object is located before beginning the fetch sequence.
+
+## Common Pitfalls & Assumptions
+* **Containers are Open:** The trajectory states "All containers in the environment have already been opened." Therefore, you can directly `pick up` items from within containers (e.g., from a pot, a cupboard) without needing to `open` them first.
+* **Object Names:** Use the exact name as shown in observations. For example, if the observation says `a tin cup (containing a substance called lead)`, the object to pick up would be the `tin cup`, not `lead`. To fetch the substance itself, you might need to `move` it to another container first.
+* **Inventory Management:** The skill is designed for single-object fetching. For complex tasks requiring multiple items, chain multiple executions of this skill.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-liquid-filler/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-liquid-filler/SKILL.md
new file mode 100644
index 0000000..ca15b23
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-liquid-filler/SKILL.md
@@ -0,0 +1,41 @@
+---
+name: scienceworld-liquid-filler
+description: This skill fills a container with liquid from a source by first placing the container at the source, then activating the source (e.g., turning on a sink), and finally deactivating it. It should be triggered when the agent has an empty or partially filled container and needs to add a liquid component. The skill results in the container containing the liquid, ready for mixing or further use.
+---
+# Instructions
+
+## 1. Identify the Goal
+Your goal is to fill a target container with a specific liquid from a source. This skill is triggered when you have a container (empty or partially filled) and need to add a liquid component to it.
+
+## 2. Prerequisites & Initial State
+Before executing this skill, ensure you have:
+* **A Target Container:** The container you wish to fill (e.g., a cup, bowl, jug). It should be in your inventory.
+* **A Liquid Source Identified:** You must know the location of a functional liquid source (e.g., a sink, a jug containing liquid, a toilet with water). Use the `look around` and `examine` actions to find one.
+
+## 3. Core Procedure
+Execute the following sequence of actions precisely:
+
+1. **Position the Container:** Move the target container to the liquid source.
+ * **Action:** `move <CONTAINER> to <SOURCE>`
+ * **Example:** `move cup to sink`
+
+2. **Activate the Source:** Turn on the liquid source to begin the flow.
+ * **Action:** `activate <SOURCE>`
+ * **Example:** `activate sink`
+
+3. **Deactivate the Source:** Turn off the liquid source once the container is sufficiently filled. Assume the filling is instantaneous upon activation.
+ * **Action:** `deactivate <SOURCE>`
+ * **Example:** `deactivate sink`
+
+4. **Retrieve the Filled Container:** Pick up the now-filled container.
+ * **Action:** `pick up <CONTAINER>`
+ * **Example:** `pick up cup`
+
+## 4. Verification & Next Steps
+* Use `examine <CONTAINER>` to confirm it now contains the desired liquid.
+* The container is now ready for the next step in your task (e.g., `mix`).
+
+## 5. Important Notes
+* **Efficiency:** Do not repeatedly pick up the container between steps unless necessary for transport. The sequence `move -> activate -> deactivate -> pick up` is optimal.
+* **Error Handling:** If an action fails (e.g., "You can't do that"), re-examine the scene and the object states. The source may need to be in a specific state (e.g., a sink must be `turned off` before it can be activated).
+* **Context:** This skill is part of a larger procedure (e.g., following a recipe). Always refer to the primary task goal.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-liquid-pourer/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-liquid-pourer/SKILL.md
new file mode 100644
index 0000000..4d8c741
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-liquid-pourer/SKILL.md
@@ -0,0 +1,27 @@
+---
+name: scienceworld-liquid-pourer
+description: This skill transfers the contents of a source liquid container into a target container for mixing or preparation. It should be triggered when combining multiple substances, such as paints or chemicals, into a single vessel.
+---
+# Instructions for Liquid Pouring
+
+This skill orchestrates the transfer of a liquid from a source container to a target container, typically as a preparatory step for mixing or chemical combination.
+
+## Core Action
+The primary action is `pour OBJ into OBJ`. Use this to transfer the contents.
+
+## Execution Flow
+1. **Identify Containers:** Locate the source container (holding the liquid to be transferred) and the target container (the destination vessel).
+2. **Perform Transfer:** Execute the `pour` action with the correct object identifiers.
+3. **Verify (Optional):** If necessary, examine the target container to confirm the transfer was successful.
+
+## Key Considerations
+* Ensure the target container is empty or can receive the new substance without adverse reaction (e.g., contamination).
+* The skill is often used in sequence with other skills, such as `mix`, to achieve a final compound.
+* Object identifiers (e.g., `wood cup (containing red paint)`) must be precise. Use `look around` and `examine` actions to confirm object states and contents if unsure.
+
+## Example Usage
+* **Goal:** Create orange paint by mixing red and yellow.
+* **Procedure:**
+ 1. `pour wood cup (containing red paint) into jug`
+ 2. `pour wood cup (containing yellow paint) into jug`
+ 3. `mix jug` (This is a separate mixing skill, not part of the pour operation).
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-liquid-pourer/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-liquid-pourer/references/action_primer.md
new file mode 100644
index 0000000..5e56c3d
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-liquid-pourer/references/action_primer.md
@@ -0,0 +1,13 @@
+# Action Primer for ScienceWorld Environment
+
+## Relevant Actions for Pouring Skill
+* `pour OBJ into OBJ`: The core action. Transfers the contents of the first object (source) into the second object (target).
+* `look around`: Describes the current room and lists all visible objects and containers. Use this to find source and target containers.
+* `examine OBJ`: Provides a detailed description of a specific object, which can help verify its contents or state.
+* `look at OBJ`: Describes a container's contents. Useful for checking what is inside a cupboard or on a table before and after pouring.
+
+## Environment Notes (From Trajectory)
+* All containers are already opened. You can directly interact with items inside them.
+* You can `teleport to LOC` to move between rooms quickly.
+* Common rooms for materials: `art studio` (for paints), `workshop`, `greenhouse`.
+* Common target containers: `jug`, `bowl`, `wood cup`.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-liquid-source-find/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-liquid-source-find/SKILL.md
new file mode 100644
index 0000000..38e7745
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-liquid-source-find/SKILL.md
@@ -0,0 +1,41 @@
+---
+name: scienceworld-liquid-source-finder
+description: This skill searches rooms for a liquid source (e.g., sink, toilet, jug) by sequentially surveying different locations. It should be triggered when the task requires obtaining a liquid (like water) and the agent does not have immediate access to it. The skill involves teleporting to candidate rooms, looking around, and identifying potential sources, guiding the agent toward the nearest available liquid.
+---
+# Skill: Liquid Source Finder
+
+## When to Use
+Activate this skill when your primary task requires a liquid (e.g., water, juice, paint) and you have confirmed it is not present in your current inventory or immediate vicinity.
+
+## Core Procedure
+1. **Initiate Search:** If no liquid source is visible, begin a systematic room survey.
+2. **Prioritize Rooms:** Teleport to and survey rooms in this order of likelihood:
+ * **Kitchen** (high priority - contains sink, fridge, cups)
+ * **Bathroom** (high priority - contains sink, toilet, bathtub)
+ * **Greenhouse** (medium priority - contains sink, jugs)
+ * **Workshop** (medium priority - may contain specialized containers)
+ * **Art Studio** (low priority - may contain paint or water for cleaning)
+ * **Living Room, Bedroom, Hallway** (low priority - check for any containers)
+3. **Survey Each Room:**
+ * Use `look around` upon arrival.
+ * Visually scan the observation for liquid sources or containers that might hold liquid (e.g., `sink`, `toilet`, `jug`, `cup`, `bathtub`).
+ * If a source is found (e.g., a `sink`), proceed to obtain the liquid. If a container is found (e.g., a `jug`), `examine` it or `look at` it to check its contents.
+4. **Obtain the Liquid:**
+ * If the liquid is in a portable container (e.g., `cup containing water`), simply `pick up` the container.
+ * If the liquid is in a fixed source (e.g., `sink`, `toilet`):
+ a. Ensure you have an empty container in your inventory. If not, find one (e.g., a `cup`).
+ b. `move` your container to the source.
+ c. `activate` the source if necessary (e.g., turn on the sink).
+ d. `deactivate` the source once done.
+ e. `pick up` the now-filled container.
+5. **Terminate Search:** Once the required liquid is successfully obtained and in your inventory, conclude the skill and return to the main task flow.
+
+## Key Principles
+* **Efficiency:** Do not re-survey rooms unnecessarily. Keep mental note of rooms already visited.
+* **Container Management:** Always ensure you have a suitable container before attempting to collect liquid from a non-portable source.
+* **Observation Parsing:** Focus on object names and their described contents. Look for keywords like `water`, `juice`, or the name of your target liquid, and objects like `sink`, `toilet`, `jug`.
+
+## Quick Reference
+**Trigger:** Need liquid, don't have it.
+**Action Loop:** Teleport -> `look around` -> Identify source -> Collect.
+**Success:** Liquid is in inventory.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-liquid-source-find/references/action_glossary.md b/skills/benchmark_skills/scienceworld/scienceworld-liquid-source-find/references/action_glossary.md
new file mode 100644
index 0000000..e317014
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-liquid-source-find/references/action_glossary.md
@@ -0,0 +1,18 @@
+# Action Glossary for Liquid Retrieval
+
+A concise guide to the ScienceWorld actions relevant to this skill.
+
+## Survey & Navigation
+* `teleport to LOC`: Instantly move to another room. Use this to jump between search locations.
+* `look around`: Get a description of the current room and all visible objects. **Use this first in every new room.**
+
+## Inspection
+* `examine OBJ`: Get a detailed description of a specific object, including its current contents. Useful for checking what's inside a container you're holding.
+* `look at OBJ`: Describe a container's contents. Useful for checking fixed containers (e.g., `look at toilet`).
+
+## Container & Liquid Manipulation
+* `pick up OBJ`: Move an object from the environment into your inventory.
+* `move OBJ to OBJ`: Move an object to a container or location. (e.g., `move cup to sink`).
+* `activate OBJ`: Turn on a device (e.g., `activate sink` to start water flow).
+* `deactivate OBJ`: Turn off a device (e.g., `deactivate sink`).
+* `pour OBJ into OBJ`: Transfer liquid between containers. (Not used in the base trajectory but potentially useful).
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-liquid-source-find/references/room_priority.md b/skills/benchmark_skills/scienceworld/scienceworld-liquid-source-find/references/room_priority.md
new file mode 100644
index 0000000..8cc65e4
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-liquid-source-find/references/room_priority.md
@@ -0,0 +1,18 @@
+# Room Priority Guide for Liquid Sources
+
+This guide ranks rooms based on the observed likelihood of containing accessible liquids in the ScienceWorld environment. Use this to inform the search order.
+
+## Tier 1: High Probability
+* **Kitchen:** Contains multiple fixed sources (`sink`) and portable containers (`cup`, `pot`, `jar`). Often has consumable liquids (e.g., `orange juice` in fridge).
+* **Bathroom:** Contains fixed sources (`sink`, `toilet`, `bathtub`). Frequently has `water`.
+
+## Tier 2: Medium Probability
+* **Greenhouse:** Contains a `sink` and often `jug` containers for watering plants.
+* **Workshop:** May contain beakers, flasks, or other lab equipment that could hold liquids. Check tables and containers.
+
+## Tier 3: Low Probability
+* **Art Studio:** May contain `paint` in cups or jugs. Could have water for cleaning brushes.
+* **Living Room / Bedroom / Hallway:** Typically dry rooms. Only check if all other options are exhausted; look for any stray `cup` or `bottle`.
+
+## Tier 4: Very Low Probability
+* **Foundry, Outside:** Not observed in the trajectory to contain standard liquids. Check only if explicitly relevant to the task (e.g., needing molten metal or rainwater).
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-living-entity-identifier/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-living-entity-identifier/SKILL.md
new file mode 100644
index 0000000..bf3d248
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-living-entity-identifier/SKILL.md
@@ -0,0 +1,25 @@
+---
+name: scienceworld-living-entity-identifier
+description: Analyzes room observations to identify potential living things (e.g., eggs, plants, animals) among listed objects. Processes observation text, flags candidate living items based on domain knowledge, and outputs a focused target for subsequent actions.
+---
+# Skill: Living Entity Identifier
+
+## Purpose
+Use this skill when the task involves finding, focusing on, or interacting with a "living thing," "biological entity," "organism," or similar target. The skill analyzes the textual observation of a room to identify candidate objects that are likely to be living or contain life (e.g., eggs, plants, animals).
+
+## Core Logic
+1. **Trigger:** The task description mentions a living entity.
+2. **Analyze:** Parse the current room's observation text.
+3. **Identify:** Flag objects from a known list of living entity indicators (see `references/living_indicators.md`).
+4. **Output:** Select the most suitable candidate and formulate the next action (typically `focus on [TARGET]` or `examine [TARGET]`).
+
+## Primary Workflow
+1. **Look Around:** First, use `look around` to get the room's observation text.
+2. **Run Analysis:** Process the observation using the logic in `scripts/analyze_observation.py`.
+3. **Execute Focus:** If a candidate is found, perform `focus on [IDENTIFIED_OBJECT]`.
+4. **Handle Inventory/Transport:** If the task requires moving the entity, proceed with `pick up` and `move` actions to the specified destination.
+
+## Key Rules
+* Prioritize explicit living things (e.g., "dove egg," "giant tortoise") over ambiguous substances (e.g., "air," "water").
+* If the initial room lacks candidates, teleport to rooms with higher biological likelihood (e.g., `outside`, `greenhouse`, `bedroom`).
+* The `focus on` action is critical for signaling task progress. Use it immediately after identification.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-living-entity-identifier/references/action_sequences.md b/skills/benchmark_skills/scienceworld/scienceworld-living-entity-identifier/references/action_sequences.md
new file mode 100644
index 0000000..f3d5330
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-living-entity-identifier/references/action_sequences.md
@@ -0,0 +1,5 @@
+# Standard Action Sequences
+
+This document outlines the typical action flow for tasks involving living entities.
+
+## Basic Identification Flow
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-living-entity-identifier/references/living_indicators.md b/skills/benchmark_skills/scienceworld/scienceworld-living-entity-identifier/references/living_indicators.md
new file mode 100644
index 0000000..7bffb98
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-living-entity-identifier/references/living_indicators.md
@@ -0,0 +1,36 @@
+# Living Entity Indicators Reference
+
+This document lists terms and patterns that signal a potential living thing in the ScienceWorld environment. Use this list to update the `LIVING_INDICATORS` in the analysis script.
+
+## High-Confidence Indicators
+These terms almost always refer to living entities or their direct products:
+* **Eggs:** `egg`, `spawn`, `embryo`
+* **Plants:** `plant`, `flower`, `seed`, `sapling`, `tree`, `leaf`, `root`, `mushroom`, `fungus`
+* **Animals:** `animal`, `bird`, `fish`, `insect`, `mammal`, `reptile`, `amphibian`
+* **Specific Animals:** `dove`, `tortoise`, `butterfly`, `frog`, `mouse`, `rat`, `cat`, `dog`
+* **Life Stages:** `larva`, `pupa`, `tadpole`, `seedling`
+
+## Medium-Confidence Indicators
+These may be living or derived from living things:
+* `living`, `organism`, `biological`, `creature`, `being`
+* `nest`, `hive`, `web` (signs of animal activity)
+* `fruit`, `vegetable`, `nut` (plant reproductive parts)
+
+## Low-Confidence/Ambiguous Indicators
+These are often substances or non-living objects:
+* `air`, `water`, `soil` (substances)
+* `wood`, `bone`, `leather` (derived from living things but not alive)
+* `book`, `painting`, `chair` (inanimate objects)
+
+## Environmental Context Clues
+Rooms with higher probability of containing living things:
+1. **Outside:** Highest probability (eggs, plants, animals)
+2. **Greenhouse:** High probability (plants, seeds)
+3. **Bedroom/Living Room:** Low probability (pets, plants possible)
+4. **Kitchen/Workshop:** Very low probability (processed materials)
+
+## Parsing Rules for Observation Text
+1. Objects listed as "a substance called X" are rarely living entities.
+2. Objects in parentheses "(containing...)" should be examined separately.
+3. Objects described with multiple words (e.g., "giant tortoise egg") should be treated as a single entity.
+4. Always prefer the most specific identifier (e.g., "dove egg" over just "egg").
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-material-classifier/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-material-classifier/SKILL.md
new file mode 100644
index 0000000..1781ef1
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-material-classifier/SKILL.md
@@ -0,0 +1,26 @@
+---
+name: scienceworld-material-classifier
+description: This skill makes a determination about a material's property (e.g., conductivity) based on environmental cues or domain knowledge when direct testing fails. Trigger it when experimental actions are invalid or unavailable, requiring a logical inference. It uses observed object properties and common-sense reasoning to classify the material and decide its final disposition.
+---
+# Material Classification Skill
+
+## When to Use
+Activate this skill when:
+1. Direct experimental testing of a material property (conductivity, magnetism, etc.) fails due to invalid actions or unavailable equipment.
+2. You need to make a logical inference based on observed properties or domain knowledge.
+3. A final disposition decision (e.g., placing in specific container) is required.
+
+## Core Logic
+1. **Identify Material**: Focus on the target object and note its composition (e.g., "glass jar").
+2. **Attempt Direct Testing**: First try standard experimental actions if equipment exists (e.g., connecting to circuit).
+3. **Fallback to Inference**: When direct testing fails:
+ - Consult material properties in `references/material_properties.md`
+ - Use common-sense reasoning (e.g., glass is typically nonconductive)
+ - Consider observed contents (e.g., sodium chloride is conductive but container material dominates)
+4. **Execute Disposition**: Place the object in the appropriate container based on classification.
+
+## Critical Notes
+- Glass containers are generally electrical insulators regardless of contents
+- Metal objects are typically conductive unless specified otherwise
+- When in doubt, use the most common material property from domain knowledge
+- Always verify the target object is properly identified before classification
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-material-classifier/references/material_properties.json b/skills/benchmark_skills/scienceworld/scienceworld-material-classifier/references/material_properties.json
new file mode 100644
index 0000000..deb03ed
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-material-classifier/references/material_properties.json
@@ -0,0 +1,38 @@
+{
+ "glass": {
+ "conductivity": "nonconductive",
+ "certainty": "high",
+ "examples": ["jar", "bottle", "window", "cup"],
+ "notes": "Electrical insulator even when containing conductive substances"
+ },
+ "metal": {
+ "conductivity": "conductive",
+ "certainty": "high",
+ "examples": ["wire", "pot", "cup", "tool"],
+ "notes": "Good conductor of electricity unless specifically coated/insulated"
+ },
+ "ceramic": {
+ "conductivity": "nonconductive",
+ "certainty": "high",
+ "examples": ["cup", "plate", "tile", "insulator"],
+ "notes": "Common electrical insulator material"
+ },
+ "wood": {
+ "conductivity": "nonconductive",
+ "certainty": "medium",
+ "examples": ["cup", "chair", "table", "bowl"],
+ "notes": "Nonconductive when dry; conductive when wet"
+ },
+ "plastic": {
+ "conductivity": "nonconductive",
+ "certainty": "high",
+ "examples": ["container", "bag", "tool", "utensil"],
+ "notes": "Excellent electrical insulator"
+ },
+ "graphite": {
+ "conductivity": "conductive",
+ "certainty": "medium",
+ "examples": ["pencil", "electrode"],
+ "notes": "Moderate conductor used in electronics"
+ }
+}
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-material-classifier/references/material_properties.md b/skills/benchmark_skills/scienceworld/scienceworld-material-classifier/references/material_properties.md
new file mode 100644
index 0000000..f6e7c31
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-material-classifier/references/material_properties.md
@@ -0,0 +1,36 @@
+# Common Material Properties
+
+## Electrical Conductivity
+
+### Conductive Materials (Place in Orange Box)
+- **Metals**: copper, aluminum, iron, steel, silver, gold
+- **Graphite**: pencils, electrodes
+- **Electrolyte solutions**: salt water, acid solutions
+- **Human body**: when wet
+
+### Nonconductive Materials (Place in Yellow Box)
+- **Glass**: windows, jars, bottles
+- **Ceramics**: cups, plates, insulators
+- **Plastics**: most synthetic materials
+- **Wood**: dry wood, furniture
+- **Rubber**: gloves, tires
+- **Air**: dry air at normal conditions
+
+## Important Notes
+1. **Container vs Contents**: The container material determines conductivity, not its contents.
+ - Glass jar with salt: NONCONDUCTIVE (glass insulator)
+ - Metal cup with water: CONDUCTIVE (metal conductor)
+
+2. **Condition Matters**:
+ - Dry wood: nonconductive
+ - Wet wood: conductive
+ - Clean glass: nonconductive
+ - Coated glass: check coating material
+
+3. **Testing Fallback Logic**:
+ When direct circuit testing fails:
+ - Check material composition first
+ - Use common-sense knowledge
+ - Default to nonconductive for unknown materials
+
+## Decision Flowchart
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-measurement-taker/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-measurement-taker/SKILL.md
new file mode 100644
index 0000000..da2245d
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-measurement-taker/SKILL.md
@@ -0,0 +1,24 @@
+---
+name: scienceworld-measurement-taker
+description: This skill uses a measurement tool (like a thermometer) on a target substance or object to obtain a quantitative reading. It should be triggered when the task requires assessing a property (e.g., temperature) to make a conditional decision. The skill outputs the measured value, which determines subsequent actions such as classification or placement.
+---
+# Measurement Taker Skill
+
+## Purpose
+Use this skill when you need to measure a quantitative property (e.g., temperature, weight, pH) of a target object or substance to inform a subsequent decision or action.
+
+## Core Workflow
+1. **Identify & Acquire Tool:** Locate and obtain the correct measurement tool (e.g., thermometer, scale).
+2. **Identify & Acquire Target:** Locate and obtain the target object or substance to be measured.
+3. **Prepare Measurement Environment:** Move to a location suitable for the measurement and any required follow-up actions (e.g., near classification bins).
+4. **Execute Measurement:** Use the tool on the target to obtain the numerical reading.
+5. **Interpret & Act:** Based on the measured value and the task's conditional logic, execute the appropriate follow-up action (e.g., place the target in a specific container).
+
+## Key Principles
+* **Tool First:** Secure the measurement tool before handling the target, unless the task specifies otherwise.
+* **Environmental Awareness:** Proactively identify where follow-up actions (like placement) will occur and position yourself accordingly before measuring.
+* **Verification:** Use `focus on` actions to confirm you have the correct tool and target in your inventory before proceeding.
+* **Conditional Logic:** The measured value directly determines the next action. Clearly map out the decision thresholds (e.g., "above 100.0", "below 100.0") before measuring.
+
+## Common Actions Sequence
+`look around` → `teleport to [Room]` → `pick up [Tool]` → `focus on [Tool]` → `pick up [Target]` → `focus on [Target]` → `teleport to [Action Room]` → `use [Tool] on [Target]` → `[Conditional Action based on reading]`
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-measurement-taker/references/action_glossary.md b/skills/benchmark_skills/scienceworld/scienceworld-measurement-taker/references/action_glossary.md
new file mode 100644
index 0000000..55a0faf
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-measurement-taker/references/action_glossary.md
@@ -0,0 +1,20 @@
+# ScienceWorld Action Glossary for Measurement
+
+## Core Measurement Actions
+* `use TOOL on TARGET`: The primary action for obtaining a measurement. Triggers the tool's function on the target and returns a reading in the observation.
+* `focus on OBJECT`: Signals intent on a task-critical object. Use this on the measurement tool and target after picking them up to confirm readiness.
+
+## Navigation & Search Actions
+* `teleport to ROOM`: Instantly move to any named room. Use this to efficiently locate tools, targets, and move to the decision location.
+* `look around`: Describes the current room and lists all visible objects. The primary action for searching.
+
+## Inventory Management Actions
+* `pick up OBJECT`: Moves a portable object from the environment into your inventory. Required before you can `use` or `focus on` it.
+* `move OBJECT to CONTAINER`: Places an object from your inventory into a container (e.g., a box). The key follow-up action after measurement.
+
+## Conditional Logic in Observations
+The observation from `use TOOL on TARGET` contains the measurement result. Parsing is environment-specific but typically follows patterns like:
+* `"the thermometer measures a temperature of 44 degrees celsius"`
+* `"the scale reads 120.5 grams"`
+
+**Parsing Tip:** Use simple regex (e.g., `r'(\d+(?:\.\d+)?)'`) to extract the numeric value from the observation string.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-measurement-taker/references/decision_workflow.md b/skills/benchmark_skills/scienceworld/scienceworld-measurement-taker/references/decision_workflow.md
new file mode 100644
index 0000000..83a3c6e
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-measurement-taker/references/decision_workflow.md
@@ -0,0 +1,27 @@
+# Decision Workflow for Measurement-Based Tasks
+
+This document outlines the thought process for planning and executing a measurement task, based on the successful trajectory.
+
+## 1. Task Decomposition
+* **Input:** "Measure property of TARGET and perform ACTION_A if value > X, else ACTION_B."
+* **Decomposed Steps:**
+ 1. Identify the required measurement `TOOL`.
+ 2. Identify the `TARGET` object/substance.
+ 3. Identify the location for `ACTION_A` and `ACTION_B` (e.g., `CONTAINER_A`, `CONTAINER_B`).
+ 4. Identify the `DECISION_ROOM` where these containers are located.
+
+## 2. Strategic Sequencing
+**Optimal Order:** `Get TOOL` → `Get TARGET` → `Go to DECISION_ROOM` → `Measure` → `Act`.
+* **Why?** Measuring in the decision room minimizes unnecessary movement after obtaining the fragile measurement result, allowing immediate conditional action.
+
+## 3. State Verification Checklist
+Before executing `use TOOL on TARGET`, confirm:
+- [ ] `TOOL` is in inventory. (Verify with `focus on TOOL`)
+- [ ] `TARGET` is in inventory. (Verify with `focus on TARGET`)
+- [ ] Current room is `DECISION_ROOM`.
+- [ ] `CONTAINER_A` and `CONTAINER_B` are visible in the room (verified via `look around`).
+
+## 4. Error Recovery Notes
+* **Tool/Target Not Found:** Use `teleport` to likely rooms (e.g., `kitchen`, `workshop` for tools; location specified in task for target) and `look around` systematically.
+* **Unparseable Observation:** If the `use` action doesn't return a clear number, try `examine TARGET` or `examine TOOL` for clues, or ensure the target is a valid substance for the tool.
+* **Wrong Room:** If you measure before reaching the decision room, simply `teleport to DECISION_ROOM` and proceed with the conditional action. The measurement result is retained.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-mixture-creator/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-mixture-creator/SKILL.md
new file mode 100644
index 0000000..e69e571
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-mixture-creator/SKILL.md
@@ -0,0 +1,27 @@
+---
+name: scienceworld-mixture-creator
+description: This skill chemically mixes the contents of a container using the 'mix' action. It should be triggered when all required ingredients (e.g., sodium chloride and water) are present inside a container and the agent needs to combine them to produce a new substance. The skill performs the mixing operation and outputs the resulting product, completing the synthesis step of the task.
+---
+# Skill: Chemical Mixture Creator
+
+## Purpose
+Execute the `mix` action on a container to chemically combine its contents into a new substance, as defined by the environment's chemistry system. This skill is the final step in a synthesis task after all required ingredients have been gathered into a single container.
+
+## When to Use
+- **Trigger Condition:** You have confirmed that a container in your inventory or the environment holds all the required chemical ingredients for a target substance.
+- **Prerequisite:** You have already used `move` or `pour` actions to place the correct ingredients into the target container.
+- **Verification:** You have used `examine <container>` and observed the required ingredients listed in its contents.
+
+## Core Instruction
+1. Ensure the target container is in your inventory or accessible in the current room.
+2. Execute the action: `mix <container>`.
+3. The environment will process the chemistry and output the resulting substance.
+
+## Important Notes
+- This skill only performs the final `mix` action. Locating ingredients, finding containers, and combining them are separate exploration and manipulation tasks.
+- The `mix` action is deterministic. If the correct ingredients are present, the reaction will always succeed.
+- After mixing, you may need to `focus on <new_substance>` or `examine <container>` to confirm the task is complete.
+- Do not attempt to `mix` a container that does not contain the precise ingredients listed in the recipe.
+
+## Related Reference
+For common chemical recipes (e.g., salt water = sodium chloride + water), see `references/common_recipes.md`.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-mixture-creator/references/common_recipes.md b/skills/benchmark_skills/scienceworld/scienceworld-mixture-creator/references/common_recipes.md
new file mode 100644
index 0000000..0f3fac3
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-mixture-creator/references/common_recipes.md
@@ -0,0 +1,19 @@
+# Common Chemical Recipes
+
+This document lists observed chemical mixtures from the execution trajectory. Use this for reference when planning synthesis tasks.
+
+## Recipe: Salt Water
+- **Target Substance:** `salt water`
+- **Required Ingredients:** `sodium chloride`, `water`
+- **Process:**
+ 1. Obtain a container (e.g., `glass cup`).
+ 2. Place `sodium chloride` into the container.
+ 3. Add `water` to the same container (e.g., by moving the container to an activated `sink`).
+ 4. Execute `mix <container>`.
+
+## General Workflow for Any Mixture
+1. **Find Recipe:** Locate and `read` a recipe note or book in the environment (common in `workshop`).
+2. **Gather Ingredients:** Explore rooms to find the listed substances. Use `look around` and `examine` objects.
+3. **Acquire Container:** Find an empty container (e.g., `cup`, `bowl`, `pot`) using `look around`. `pick up` the container.
+4. **Combine Ingredients:** Use `move <ingredient> to <container>` or `pour <ingredient> into <container>` to place all ingredients into the same container. Ensure the container is in your inventory afterward (`pick up <container>`).
+5. **Execute Mix:** Use the `scienceworld-mixture-creator` skill: `mix <container>`.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-classifier/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-object-classifier/SKILL.md
new file mode 100644
index 0000000..945ea63
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-classifier/SKILL.md
@@ -0,0 +1,28 @@
+---
+name: scienceworld-object-classifier
+description: Moves a tested or examined object into a designated container (e.g., a specific colored box) based on a determined property. Trigger this skill after completing a test or inspection to fulfill a classification or sorting subtask. It takes the object and target container as inputs and performs the move action.
+---
+# Instructions
+
+## Purpose
+This skill is used to finalize a classification task by moving an object into its designated container. It is triggered **after** a property test or inspection has been completed and a decision has been made.
+
+## Prerequisites
+1. **Object Location:** The object to be classified must be present in the current room's environment (e.g., on the floor, on a table).
+2. **Container Location:** The target container (e.g., yellow box, purple box) must be present in the current room's environment.
+3. **Decision Made:** You must have already determined the object's property (e.g., electrically conductive vs. non-conductive) and know which container corresponds to that property.
+
+## Core Action
+Execute the `move` command to transfer the object into the correct container.
+* **Command Format:** `move <OBJECT> to <CONTAINER>`
+* **Example:** `move metal pot to yellow box`
+
+## Workflow
+1. **Confirm Environment:** Use `look around` to verify the object and target container are present.
+2. **Execute Move:** Perform the `move` action.
+3. **Verify:** Optionally, `look at <CONTAINER>` to confirm the object is now inside.
+
+## Important Notes
+* This skill is for the **final sorting action only**. Do not use it to perform the initial test or inspection.
+* Ensure the object is not in your inventory. If it is, drop it first (`drop <OBJECT>`).
+* The skill assumes the classification logic (e.g., interpreting a circuit test) has already been handled by a prior process.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-classifier/references/conductivity_test_guide.md b/skills/benchmark_skills/scienceworld/scienceworld-object-classifier/references/conductivity_test_guide.md
new file mode 100644
index 0000000..4786c04
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-classifier/references/conductivity_test_guide.md
@@ -0,0 +1,32 @@
+# Guide: Testing Electrical Conductivity in ScienceWorld
+
+This reference outlines a method for determining if an object is electrically conductive, as demonstrated in the skill trajectory. Use this logic **before** triggering the `scienceworld-object-classifier` skill.
+
+## Required Components
+A basic series circuit can be constructed to test conductivity. Common components found in the `workshop` include:
+* **Power Source:** Battery (has `anode` and `cathode` terminals).
+* **Conductors:** Wires (e.g., `blue wire`, `yellow wire`, `black wire`). Each wire has two terminals (`terminal 1`, `terminal 2`).
+* **Load/Indicator:** An `electric motor` or `light bulb` (has `anode` and `cathode` terminals). The motor turning on or the bulb lighting up indicates a complete circuit.
+* **Test Object:** The object in question (e.g., `metal pot`).
+
+## Test Procedure
+1. **Construct Base Circuit:**
+ * Connect the battery's `anode` to one terminal of a wire.
+ * Connect that wire's other terminal to the `cathode` of the load (motor/bulb).
+ * Connect the battery's `cathode` to one terminal of a second wire.
+ * Connect the load's `anode` to one terminal of a third wire.
+ * **At this point, the circuit is open.** The second and third wires have free terminals.
+
+2. **Integrate Test Object:**
+ * Connect the free terminal of the wire from the battery's cathode (e.g., `yellow wire terminal 2`) to one terminal of the test object.
+ * Connect the free terminal of the wire from the load's anode (e.g., `black wire terminal 1`) to the other terminal of the test object.
+ * This places the test object in series within the circuit.
+
+3. **Observe and Classify:**
+ * **If Conductive:** The circuit is complete. The load (e.g., `electric motor`) will turn `on`.
+ * **If Non-Conductive:** The circuit remains open. The load will stay `off`.
+ * Use `look around` or `examine electric motor` to check its state (`on`/`off`).
+
+## Classification Rule
+* **Conductive Object (`on` state):** Place in the `yellow box`.
+* **Non-Conductive Object (`off` state):** Place in the `purple box`.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-focuser/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-object-focuser/SKILL.md
new file mode 100644
index 0000000..132185b
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-focuser/SKILL.md
@@ -0,0 +1,26 @@
+---
+name: scienceworld-object-focuser
+description: This skill selects and focuses on a specific object to signal task intent or prepare it for manipulation. It is triggered after identifying a target object that meets task criteria (e.g., a living thing). The skill uses the 'focus on OBJ' action, taking the object name as input, which is often required before performing actions like moving or using the object in scienceWorld tasks.
+---
+# Skill: Object Focuser
+
+## Purpose
+Use this skill to formally select a target object in the ScienceWorld environment. The `focus on` action signals your intent to the task system and is often a prerequisite for subsequent manipulation steps like `pick up` or `move`.
+
+## When to Use
+* After you have identified an object that matches the task's criteria (e.g., "a living thing", "a conductive material").
+* Before you attempt to pick up, move, or use that object as part of the task sequence.
+* When the task trajectory or environment feedback suggests an object needs to be "focused on" to proceed.
+
+## Core Instruction
+1. **Identify the Target:** From your observation (`look around`, `examine`), determine the exact name of the object you intend to use for the task.
+2. **Execute Focus:** Use the action: `focus on <OBJECT_NAME>`.
+ * Replace `<OBJECT_NAME>` with the precise noun phrase from the environment (e.g., `dove egg`, `copper wire`, `beaker`).
+3. **Proceed:** After receiving a confirmation observation, continue with the next step in your plan (e.g., `pick up <OBJECT_NAME>`, `move <OBJECT_NAME> to ...`).
+
+## Key Considerations
+* **Object Naming:** Use the name exactly as it appears in observations. The system is case-sensitive and expects the full descriptor (e.g., "dove egg", not just "dove" or "egg").
+* **Timing:** Focus is typically performed *after* exploration/identification and *before* the main manipulation action.
+* **Task Logic:** This action is a procedural formality within ScienceWorld. It does not change the object's state but informs the task tracker of your selected target.
+
+For detailed examples and common patterns, see the reference documentation.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-focuser/references/usage_examples.md b/skills/benchmark_skills/scienceworld/scienceworld-object-focuser/references/usage_examples.md
new file mode 100644
index 0000000..9ecce57
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-focuser/references/usage_examples.md
@@ -0,0 +1,34 @@
+# Usage Examples & Patterns
+
+## Example 1: Basic Focus & Move (from Trajectory)
+**Task:** "Find a living thing. First, focus on the thing. Then, move it to the orange box in the workshop."
+
+**Agent Execution:**
+1. Explore (`look around`) multiple rooms (living room, outside).
+2. **Identify Target:** In `outside`, observe `a dove egg`.
+3. **Apply Skill:** `focus on dove egg`
+4. **Result:** Observation confirms focus.
+5. **Next Action:** `pick up dove egg`, then `move dove egg to orange box`.
+
+**Key Takeaway:** The skill is applied immediately after identifying the task-relevant object.
+
+## Example 2: Focus as a Prerequisite
+**Task:** "Create a circuit. Connect the battery to the light bulb."
+
+**Potential Execution:**
+1. Locate `battery` and `light bulb` via `examine`.
+2. The task may require focusing on components before `connect`.
+3. **Apply Skill:** `focus on battery`
+4. **Next Action:** `connect battery to light bulb`
+
+**Key Takeaway:** `focus` can be a required step before specific interaction verbs like `connect`.
+
+## Common Patterns
+* **Exploration -> Identification -> Focus -> Manipulation:** The standard workflow.
+* **Re-focusing:** If you switch targets mid-task, you may need to `focus on` the new object.
+* **Implicit Focus:** Some objects may not require explicit focus. Use the skill when the task explicitly states it, or if a manipulation action fails without it.
+
+## Anti-Patterns to Avoid
+* **Focusing on Non-Objects:** Do not `focus on` substances (e.g., `air`, `water`) or rooms.
+* **Incorrect Name:** `focus on dove` (incorrect) vs. `focus on dove egg` (correct). Always use the full name from the observation.
+* **Premature Focus:** Do not focus before confirming the object meets the task criteria.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-locator/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-object-locator/SKILL.md
new file mode 100644
index 0000000..772ba7c
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-locator/SKILL.md
@@ -0,0 +1,36 @@
+---
+name: scienceworld-object-locator
+description: This skill searches for a specific target object across multiple rooms by systematically teleporting to likely locations and examining each room. It should be triggered when the agent needs to find an object whose exact location is unknown. The skill involves iterating through candidate rooms, using room exploration to check for the object, and continues until the target is found, providing the object's location as output.
+---
+# Instructions
+
+## Purpose
+Locate a specific target object within the ScienceWorld environment when its location is unknown.
+
+## Inputs
+- **Target Object:** The name of the object to find (e.g., "thermometer", "metal fork").
+- **Candidate Rooms (Optional):** A list of room names to search. If not provided, the skill will use a default priority list based on common object locations.
+
+## Core Process
+1. **Initialize:** Receive the target object name.
+2. **Plan Search Order:** Determine the sequence of rooms to search. Use the provided `prioritize_rooms.py` script to generate an optimal search order based on the target object.
+3. **Execute Search Loop:**
+ a. Teleport to the next room in the search order.
+ b. Use the `look around` action to observe the room's contents.
+ c. Parse the observation to check for the presence of the target object.
+ d. If the object is found, **stop the search** and output its location.
+ e. If the object is not found, proceed to the next room.
+4. **Output:** Report the room where the object was found. If the object is not found after searching all candidate rooms, report this failure.
+
+## Key Actions
+- `teleport to <ROOM_NAME>`
+- `look around`
+- `examine <OBJECT>` (if more detail is needed to confirm identity)
+- `pick up <OBJECT>` (if the goal is to acquire the object, not just locate it)
+
+## Notes & Best Practices
+- **Efficiency:** Always `look around` immediately after teleporting to get the full room state.
+- **Parsing:** Observations list objects after "you see:". Check this list for the target object's name.
+- **Confirmation:** If an object's name is ambiguous (e.g., "fork" could be "metal fork" or "plastic fork"), use `examine` to get a detailed description.
+- **Inventory:** If the task requires using the object, remember to `pick it up` after finding it.
+- **Error Handling:** If an object is not in its most likely room, the systematic search will eventually find it. Do not give up after the first few rooms.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-locator/references/action_guide.md b/skills/benchmark_skills/scienceworld/scienceworld-object-locator/references/action_guide.md
new file mode 100644
index 0000000..cfe8b1c
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-locator/references/action_guide.md
@@ -0,0 +1,35 @@
+# ScienceWorld Action Guide for Object Location
+
+## Core Actions for Search
+
+### `teleport to <ROOM_NAME>`
+- **Purpose:** Instantly move the agent to a specified room.
+- **Usage:** `teleport to kitchen`
+- **Note:** This is the primary movement action. Use it to navigate between candidate rooms efficiently.
+
+### `look around`
+- **Purpose:** Describes the current room, listing all visible objects and containers.
+- **Output Format:** "This room is called <ROOM_NAME>. In it, you see: ..."
+- **Critical Step:** Always perform this immediately after teleporting to a new room. The object list is in the observation text.
+
+### `examine <OBJECT>`
+- **Purpose:** Provides a detailed description of a specific object.
+- **Usage:** `examine metal fork`
+- **When to Use:** To confirm the identity of an object if its name in the `look around` output is ambiguous or if you need specific properties (e.g., "Is this the *metal* fork or a *plastic* fork?").
+
+### `pick up <OBJECT>`
+- **Purpose:** Moves an object from the environment into the agent's inventory.
+- **Usage:** `pick up thermometer`
+- **When to Use:** If the goal is to acquire and use the object, not just note its location. Perform this after confirming the object's identity.
+
+## Parsing `look around` Observations
+The observation text after `look around` is key. Objects are listed after "you see:".
+- **Example:** `a thermometer, currently reading a temperature of 10 degrees celsius`
+- **Strategy:** Check if the target object's name appears as a separate line item in this list. Simple string matching (e.g., `"thermometer" in observation`) is often sufficient.
+
+## Room Connectivity
+Rooms are connected by doors, but the `teleport` action makes physical navigation unnecessary. Focus on the search plan, not door states.
+
+## Inventory Management
+- Use `focus on <OBJECT> in inventory` to signal intent on an object you are carrying.
+- The trajectory shows that objects in inventory can be used on each other (e.g., `use thermometer on metal fork`).
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-locator/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-object-locator/references/action_primer.md
new file mode 100644
index 0000000..c1c45a0
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-locator/references/action_primer.md
@@ -0,0 +1,12 @@
+# Action Primer for ScienceWorld Object Location
+
+## Core Action for This Skill
+- `look around`: Describes the current room, listing all visible objects and their states. This is the primary action for environmental awareness.
+
+## Related Actions (For Subsequent Steps)
+- `pick up OBJ`: Moves a found object from the room to the agent's inventory.
+- `examine OBJ`: Provides a detailed description of a specific object (useful for verification).
+- `teleport to LOC`: Moves the agent to a different room to continue the search.
+
+## Observation Format
+A typical `look around` observation has this structure:
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-locator/references/example_trajectory_breakdown.md b/skills/benchmark_skills/scienceworld/scienceworld-object-locator/references/example_trajectory_breakdown.md
new file mode 100644
index 0000000..ce4b7bf
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-locator/references/example_trajectory_breakdown.md
@@ -0,0 +1,34 @@
+# Example Trajectory Breakdown
+
+This document breaks down the provided execution trajectory to illustrate the skill's logic.
+
+## Task
+"Measure the temperature of metal fork, which is located around the bedroom."
+
+## Implicit Sub-Task: Locate the Thermometer
+The agent does not know where the thermometer is, triggering the object location skill.
+
+### Search Execution (For Thermometer)
+1. **Initial State:** Agent is in `workshop`.
+2. **Action:** `look around` (in workshop).
+ * **Observation:** No thermometer found.
+3. **Decision:** Teleport to a likely room (`kitchen`).
+4. **Action:** `teleport to kitchen`
+5. **Action:** `look around` (in kitchen).
+ * **Observation:** Thermometer found on the table.
+6. **Result:** Search successful. Object located in `kitchen`.
+
+### Search Execution (For Metal Fork)
+1. **Known Location:** Task states "located around the bedroom."
+2. **Action:** `teleport to bedroom`
+3. **Action:** `look around` (in bedroom).
+ * **Observation:** Metal fork found.
+4. **Result:** Search successful. Object located in `bedroom`.
+
+## Skill Principles Demonstrated
+1. **Systematic Search:** When the thermometer wasn't in the first room (workshop), the agent moved to the next likely candidate (kitchen).
+2. **Room Examination:** Used `look around` in each new room to get the object list.
+3. **Action Efficiency:** Used `teleport` for instant movement between search locations.
+4. **Parsing Simplicity:** Identified the target object by name in the observation text.
+
+## Flowchart Summary
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-placer/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-object-placer/SKILL.md
new file mode 100644
index 0000000..db395bd
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-placer/SKILL.md
@@ -0,0 +1,32 @@
+---
+name: scienceworld-object-placer
+description: Moves a specified object from the environment or inventory into a target container based on a classification decision. It should be triggered when a task requires sorting or storing an object in a specific location after an assessment.
+---
+# Instructions
+
+This skill orchestrates the final step of a conditional workflow: moving an object to a designated container after its properties have been assessed.
+
+## When to Use
+Use this skill when the primary task involves:
+1. **Classifying an object** (e.g., testing for conductivity, checking material type, verifying a state).
+2. **Conditionally placing the object** based on the classification result (e.g., "if property X, place in Container A; else, place in Container B").
+
+## Core Action
+The skill's primary action is `move OBJ to OBJ`. Ensure the target object is identified and the correct destination container is selected based on the prior assessment.
+
+## Prerequisites
+Before executing this skill, the following must be true:
+* The target object has been located and is accessible (in the environment or inventory).
+* The classification test or assessment has been completed.
+* The result of the assessment is known and the corresponding destination container has been identified.
+
+## Execution Flow
+1. **Confirm Context:** Verify the assessment result and the identity of the destination container (e.g., "blue box" for conductive, "orange box" for non-conductive).
+2. **Acquire Object:** If the target object is not already in your inventory, use `pick up OBJ` to acquire it.
+3. **Execute Placement:** Use the `move OBJ to OBJ` action to transfer the object to the correct container.
+4. **Verify:** Optionally, look at the container to confirm the object was placed inside.
+
+## Example from Trajectory
+* **Task:** "Determine if metal pot is electrically conductive. If conductive, place it in the blue box. If nonconductive, place it in the orange box."
+* **Assessment:** A circuit test confirmed the metal pot was conductive.
+* **Skill Execution:** `move metal pot to blue box`
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-placer/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-object-placer/references/action_primer.md
new file mode 100644
index 0000000..d6d9e58
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-placer/references/action_primer.md
@@ -0,0 +1,21 @@
+# Action Primer for ScienceWorld Environment
+
+This reference details the actions used in the provided trajectory that are relevant to the object-placer skill's prerequisite steps.
+
+## Core Placement Action
+* `move OBJ to OBJ`: Transfers an object to a container. This is the final action of the skill.
+ * *Example:* `move metal pot to blue box`
+
+## Supporting Actions (Pre-Skill)
+These actions are typically part of the assessment phase that occurs *before* this skill is triggered.
+* `pick up OBJ`: Moves an object from the environment into your inventory. Use this if the target object needs to be carried.
+ * *Example:* `pick up metal pot`
+* `look around`: Describes the current room and lists all visible objects and containers. Use this to locate the target object and destination containers.
+* `examine OBJ`: Provides a detailed description of a specific object. Use this to identify object properties or terminals.
+* `focus on OBJ`: Signals intent on a task-relevant object. Can be used to confirm target selection.
+* `connect OBJ to OBJ`: Connects two electrical components. Used in the example trajectory to build a test circuit.
+* `wait1`: Waits for one iteration, allowing time-dependent effects (like a buzzer turning on) to be observed.
+
+## Container Notes
+* Containers like `blue box` and `orange box` are typically empty and ready to receive objects.
+* You can use `look at OBJ` to inspect a container's contents, but this is often unnecessary if the task explicitly states the container is empty.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-retriever/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-object-retriever/SKILL.md
new file mode 100644
index 0000000..02f3092
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-retriever/SKILL.md
@@ -0,0 +1,20 @@
+---
+name: scienceworld-object-retriever
+description: This skill acquires a specified object by moving it from the environment into the agent's inventory. It should be triggered when a task requires an object to be manipulated, tested, or transported. The skill uses the 'pick up OBJ' action on a target object identified in the room, making it available for further actions in the inventory.
+---
+# Instructions
+
+## Primary Objective
+Acquire a specified target object from the environment and place it into your inventory.
+
+## Core Procedure
+1. **Locate the Object:** Use the `look around` action to survey the current room. Identify the target object from the description.
+2. **Acquire the Object:** Use the `pick up OBJ` action on the identified target object. Replace `OBJ` with the exact name of the object as seen in the environment description.
+3. **Verification:** Confirm the object is now in your inventory by checking the observation feedback from the `pick up` action.
+
+## Key Notes
+* This skill is the foundational step for any task requiring physical interaction with an object (e.g., testing, moving, using).
+* Ensure you are in the correct room containing the object before attempting to pick it up. Use `teleport to LOC` if necessary.
+* The object must be accessible and not inside a closed container. If a container is closed, use `open OBJ` first.
+* If the initial `look around` does not reveal the object, you may need to `examine` specific containers or furniture (e.g., `examine table`) to find it.
+* After acquisition, the object is ready for the next skill in the task sequence (e.g., testing conductivity, placing in a specific box).
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-retriever/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-object-retriever/references/action_primer.md
new file mode 100644
index 0000000..15c41d1
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-retriever/references/action_primer.md
@@ -0,0 +1,18 @@
+# Action Primer for Object Retrieval
+
+## Essential Actions
+* `look around`: Describes the current room and lists all visible objects and agents. Use this first to find your target.
+* `pick up OBJ`: Moves the specified object from the environment into your inventory. This is the core action of this skill.
+* `teleport to LOC`: Instantly moves you to a named room (e.g., `teleport to workshop`). Use if the object is known to be in another location.
+
+## Supporting Actions (Use as Needed)
+* `examine OBJ`: Provides a detailed description of a specific object or piece of furniture, which may list its contents.
+* `open OBJ`: Opens a closed container (e.g., a cabinet, box) so its contents can be seen and accessed.
+* `look at OBJ`: Describes the contents of a container. Use after opening it or if it's already open.
+
+## Common Object Locations
+Objects are typically:
+* Loose in the room.
+* On surfaces (e.g., `on the table`).
+* Inside open containers (e.g., `in the blue box`).
+* Inside closed containers (requires `open` first).
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-selector/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-object-selector/SKILL.md
new file mode 100644
index 0000000..1e960b8
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-selector/SKILL.md
@@ -0,0 +1,24 @@
+---
+name: scienceworld-object-selector
+description: Selects appropriate objects from available options based on task criteria. Use this skill when you need to choose a specific object type (e.g., non-living thing) from multiple candidates. It evaluates object properties against task requirements and selects the most suitable candidate for further manipulation.
+---
+# Instructions
+
+Use this skill to identify and select an object from a list of candidates that matches a given task requirement (e.g., "non-living thing", "electrical component", "container").
+
+## Core Workflow
+1. **Observe & Parse:** Use `look around` to get a list of all visible objects in your current location.
+2. **Evaluate Candidates:** For each object, determine if it matches the task's criteria. Refer to the `references/object_properties.md` for common classifications.
+3. **Select & Focus:** Choose the most suitable candidate. Use `focus on [OBJECT]` to signal your intent and proceed with the next task step (e.g., `pick up`, `move`, `use`).
+
+## Key Principles
+* **Conciseness:** Choose the first suitable object unless the task implies a specific preference (e.g., "largest", "closest").
+* **Verification:** If uncertain about an object's properties, use `examine [OBJECT]` for more detail before selecting.
+* **Task Alignment:** Your selection should enable the *next action* in the task sequence.
+
+## Example (from trajectory)
+**Task:** "Find a non-living thing. First, focus on the thing. Then, move it to the purple box."
+1. `look around` reveals: `purple box`, `table`, `battery`, `black wire`, `blue light bulb`, `red light bulb`, `red wire`, `switch`, `violet light bulb`, `yellow wire`, `ultra low temperature freezer`.
+2. Evaluate: The `purple box` is the target location. The `table` and `freezer` are furniture. All other items (`battery`, `wires`, `bulbs`, `switch`) are non-living.
+3. Select: `black wire` is a straightforward, portable non-living object.
+4. Action: `focus on black wire` -> `move black wire to purple box`.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-object-selector/references/object_properties.md b/skills/benchmark_skills/scienceworld/scienceworld-object-selector/references/object_properties.md
new file mode 100644
index 0000000..d52f79d
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-object-selector/references/object_properties.md
@@ -0,0 +1,19 @@
+# Common Object Classifications for ScienceWorld
+
+Use this reference to evaluate if an object matches a task's categorical requirement (e.g., "non-living thing", "container").
+
+## Living vs. Non-Living
+* **Non-Living:** Tools, devices, components, furniture, substances (e.g., `wire`, `battery`, `light bulb`, `table`, `box`, `air`, `water`).
+* **Living:** Organisms, plants, animals (e.g., `mouse`, `fern`). If not explicitly described as living, assume non-living.
+
+## Common Functional Types
+* **Container:** Objects that can hold other items (e.g., `box`, `freezer`, `beaker`, `drawer`). Described as "containing" something or having a "door".
+* **Electrical Component:** Objects used in circuits (e.g., `battery`, `wire`, `switch`, `light bulb`).
+* **Device/Tool:** Objects with an on/off state or specific function (e.g., `switch`, `freezer`, `microscope`).
+* **Furniture:** Large environmental objects (e.g., `table`, `cabinet`, `desk`). Often serve as surfaces or containers.
+* **Substance:** Materials like `air`, `water`, `chemical X`. Often described as "a substance called".
+
+## Selection Heuristics
+1. **Portability:** Prefer small, handheld items (e.g., `wire`, `battery`) over large furniture (e.g., `table`) for "move" tasks.
+2. **Simplicity:** Prefer simple objects (e.g., a single `wire`) over complex devices (e.g., `ultra low temperature freezer`) unless specified.
+3. **Relevance:** In a scientific context, prefer lab-typical objects (components, tools) over generic ones when possible.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-planting-coordinator/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-planting-coordinator/SKILL.md
new file mode 100644
index 0000000..a091e13
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-planting-coordinator/SKILL.md
@@ -0,0 +1,23 @@
+---
+name: scienceworld-planting-coordinator
+description: This skill plants a seed or small plant into a suitable growth container (e.g., a flower pot with soil and water). It should be triggered when the agent has acquired a seed and needs to initiate the plant growth process by placing it into a prepared environment. The skill coordinates the 'move' action to transfer the seed from inventory to the target container, resolving any ambiguity if multiple instances exist.
+---
+# Planting Coordinator Skill
+
+## Purpose
+This skill orchestrates the initial planting action to begin a plant growth process. It handles the transfer of a seed from the agent's inventory into a suitable growth container (e.g., a flower pot containing soil and water).
+
+## When to Use
+- **Trigger Condition:** The agent has acquired a seed (or small plant) and is in a location containing a suitable growth container.
+- **Goal:** Initiate the biological growth process by placing the seed into a prepared environment.
+
+## Core Procedure
+1. **Locate Target Container:** Identify a suitable container in the current environment. A valid container must contain both `soil` and `water` substances.
+2. **Execute Transfer:** Perform a `move` action to transfer the seed from your inventory to the target container.
+3. **Handle Ambiguity:** If the action parser returns an ambiguous request (listing multiple identical action options), select the first option (index `0`) to proceed. This resolves the ambiguity deterministically.
+4. **Signal Intent:** After successful planting, use `focus on [seed]` to signal monitoring intent for the growth task.
+
+## Key Notes
+- This skill assumes the seed is already in the agent's inventory.
+- The skill does not handle locating or acquiring the seed, nor the subsequent growth stages after planting.
+- The primary complexity managed is the deterministic resolution of ambiguous `move` actions.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-planting-coordinator/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-planting-coordinator/references/action_primer.md
new file mode 100644
index 0000000..a559b04
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-planting-coordinator/references/action_primer.md
@@ -0,0 +1,24 @@
+# Action Primer for Planting
+
+## Relevant Actions from the Trajectory
+- `look around`: Describes the current room and its contents.
+- `teleport to LOC`: Instantly moves the agent to a specified room.
+- `pick up OBJ`: Moves an object from the environment into the agent's inventory.
+- `move OBJ to OBJ`: Transfers an object from one container to another. This is the **core action** for planting.
+- `focus on OBJ`: Signals intent to monitor or work on a specific object. Use after planting.
+
+## Handling Ambiguous Actions
+The environment may sometimes return an ambiguous request for a `move` action, presenting multiple identical-seeming options with indices (0, 1, 2...).
+
+**Resolution Protocol:**
+1. The agent's command (`move avocado seed in seed jar to flower pot 1`) triggers the ambiguity.
+2. The environment responds with a numbered list of options.
+3. **Apply the skill's deterministic rule:** Respond with the action corresponding to the first index (`0`).
+4. This selects the standard transfer path and allows the action to proceed.
+
+## Container Suitability Check
+A container is suitable for planting if its description includes:
+- `soil` (a substance)
+- `water` (a substance)
+
+Example from trajectory: `a flower pot 1 (containing soil, a substance called water)`
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-planting-operation/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-planting-operation/SKILL.md
new file mode 100644
index 0000000..52257e8
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-planting-operation/SKILL.md
@@ -0,0 +1,24 @@
+---
+name: scienceworld-planting-operation
+description: Plants seeds into prepared containers with soil to initiate plant growth. Execute this when you have both seeds and properly prepared planting containers available. This skill handles the specific action pattern of transferring seeds from storage to growth containers to begin cultivation processes.
+---
+# Planting Operation Skill
+
+## Purpose
+This skill orchestrates the process of planting seeds into prepared growth containers (e.g., flower pots with soil) to initiate plant cultivation. It is triggered when you have acquired seeds and have containers ready for planting.
+
+## Core Workflow
+1. **Prerequisites:** Ensure you possess seeds (in inventory or accessible container) and that the target planting containers are present and contain soil.
+2. **Execution:** For each target container, transfer one seed from the seed source to the container.
+3. **Completion:** The skill is complete when a seed has been planted in each specified container.
+
+## Key Instructions
+* **Seed Source:** Interact with the seed source (e.g., `seed jar`) to access the seeds. Use `examine` or `look at` to confirm seed availability.
+* **Planting Action:** Use the `move OBJ to OBJ` action pattern, specifying the seed and the target container.
+* **Ambiguity Resolution:** The environment may present ambiguous action options (e.g., multiple identical seeds). Be prepared to select the correct option by number (typically `0`) when prompted.
+* **Post-Planting:** After planting, monitor plant growth. Subsequent skills may be required for watering, pollination, or harvesting.
+
+## Important Notes
+* This skill assumes containers are already prepared with soil. Soil preparation is a separate prerequisite.
+* The skill focuses on the mechanical act of planting. It does not cover acquiring seeds, preparing soil, or subsequent plant care.
+* Always verify the state of the container (`examine` or `look at`) before and after planting to confirm success.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-planting-operation/references/action_patterns.md b/skills/benchmark_skills/scienceworld/scienceworld-planting-operation/references/action_patterns.md
new file mode 100644
index 0000000..7dbae7b
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-planting-operation/references/action_patterns.md
@@ -0,0 +1,16 @@
+# Action Patterns for Planting
+
+## Core Planting Action
+The fundamental action for this skill is:
+`move <SEED_SOURCE> to <CONTAINER>`
+
+**Example:** `move banana seed in seed jar to flower pot 1`
+
+## Resolving Ambiguity
+The environment may generate ambiguous requests when multiple identical objects are present. The standard resolution pattern is:
+
+1. The agent issues a `move` command.
+2. The environment responds with a numbered list of possible interpretations.
+3. The agent selects the intended action by issuing the corresponding number (e.g., `0`).
+
+**Trajectory Example:**
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-planting-operation/references/prerequisite_checklist.md b/skills/benchmark_skills/scienceworld/scienceworld-planting-operation/references/prerequisite_checklist.md
new file mode 100644
index 0000000..c80c636
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-planting-operation/references/prerequisite_checklist.md
@@ -0,0 +1,22 @@
+# Prerequisite Checklist for Planting Operation
+
+Execute the Planting Operation skill **only** when the following conditions are met:
+
+## Mandatory Prerequisites
+- [ ] **Seeds Acquired:** You have a source of seeds in your inventory or within reach (e.g., `seed jar` in inventory). Verify with `look at <seed_source>`.
+- [ ] **Containers Prepared:** The target planting containers (e.g., `flower pot 1`, `flower pot 2`) exist in the environment and **contain soil**. Verify with `examine <container>`.
+- [ ] **Containers Empty:** The containers should not already contain a plant or seed. They must be ready for new planting.
+
+## Recommended Pre-Skill Actions
+1. **Acquire Seeds:** Use `pick up <seed_source>` or similar.
+2. **Prepare Soil:**
+ - Locate a soil source (e.g., `outside` ground).
+ - Use `shovel` to dig soil (`use shovel on ground`).
+ - `pick up soil`.
+ - `move soil to <container>` for each target container.
+3. **Positioning:** Be in the same location (room) as the target containers.
+
+## Common Failure Points
+* **No Soil:** Attempting to plant in a container with only water or nothing.
+* **Already Planted:** Trying to plant in a container that already has a seed or plant.
+* **Wrong Location:** The seed source or containers are in a different room.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-pot-preparer/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-pot-preparer/SKILL.md
new file mode 100644
index 0000000..c214729
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-pot-preparer/SKILL.md
@@ -0,0 +1,13 @@
+---
+name: scienceworld-pot-preparer
+description: Prepares a planting pot by moving soil from inventory into an empty or water-filled pot. Use this when setting up a growth environment for seeds or plants. It performs the 'move soil to flower pot X' action, transforming the container into a viable planting medium. This skill is atomic and can be repeated for multiple pots.
+---
+# Instructions
+Use this skill to prepare a flower pot for planting by filling it with soil.
+
+## Prerequisites
+1. **Soil in Inventory**: You must have soil in your inventory. If not, acquire soil first (e.g., by using a shovel on ground outdoors and picking up the resulting soil).
+2. **Target Pot**: Identify the specific flower pot you wish to prepare (e.g., "flower pot 1", "flower pot 2"). The pot can be initially empty or contain only water.
+
+## Core Action
+Execute the following action:
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-pot-preparer/references/trajectory_example.md b/skills/benchmark_skills/scienceworld/scienceworld-pot-preparer/references/trajectory_example.md
new file mode 100644
index 0000000..e72c4a7
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-pot-preparer/references/trajectory_example.md
@@ -0,0 +1,19 @@
+# Trajectory Example: Pot Preparation
+This reference shows the skill in use within the broader context of the "grow an avocado" task.
+
+## Context
+The agent is in the `greenhouse` and needs to prepare three flower pots (`flower pot 1`, `flower pot 2`, `flower pot 3`) for planting avocado seeds. Soil has been previously collected and is in the agent's inventory.
+
+## Skill Execution Sequence
+1. **Prepare Flower Pot 1**
+ * **Action**: `move soil in inventory to flower pot 1`
+ * **Observation**: `You move the soil to the flower pot 1.`
+2. **Prepare Flower Pot 3** (Note: Out-of-order preparation is acceptable)
+ * **Action**: `move soil in inventory to flower pot 3`
+ * **Observation**: `You move the soil to the flower pot 3.`
+3. **Prepare Flower Pot 2**
+ * **Action**: `move soil in inventory to flower pot 2`
+ * **Observation**: `You move the soil to the flower pot 2.`
+
+## Key Insight
+The skill performs the same core `move` action regardless of the pot's initial state (observed as containing only `water` in the trajectory). The outcome is a pot containing `soil`, ready for the next step (planting a seed).
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-process-monitor/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-process-monitor/SKILL.md
new file mode 100644
index 0000000..d1571f4
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-process-monitor/SKILL.md
@@ -0,0 +1,35 @@
+---
+name: scienceworld-process-monitor
+description: This skill observes the state of an active apparatus and its contents to track progress. It should be triggered periodically during a heating or reaction process to check for state changes (e.g., solid to liquid). The skill uses 'look at' or 'examine' actions on the apparatus and substance.
+---
+# Process Monitoring Protocol
+
+## Purpose
+Monitor an ongoing scientific process (e.g., heating, reaction) to detect state changes in the target substance and track progress toward a goal.
+
+## Trigger Conditions
+Activate this skill when:
+1. An apparatus (e.g., stove, burner) is **active** (`activated` state).
+2. A target substance is contained within or on the apparatus.
+3. You need to determine if a phase/state transition has occurred (e.g., solid → liquid).
+
+## Core Procedure
+1. **Observe the Apparatus**: Use `look at <APPARATUS>` to verify the apparatus is active and contains the target substance.
+2. **Inspect the Substance**: Use `examine <SUBSTANCE>` to check its current state description.
+3. **Record Observations**: Note any change in the substance's state description (e.g., "chocolate" → "liquid chocolate").
+
+## Key Principles
+* **Periodic Execution**: Run this skill every few steps during an active process. Do not spam actions.
+* **State-Driven**: The skill's findings (state change detected or not) should inform the next step in the overarching experiment.
+* **Non-Destructive**: This skill only observes. It does not modify temperatures, turn equipment on/off, or handle substances.
+
+## Integration with Other Skills
+The output of this skill (e.g., "substance melted") should be passed to a decision-making skill (e.g., `scienceworld-measurement`) to take the next appropriate action, such as taking a final temperature reading or deactivating the apparatus.
+
+## Example from Trajectory
+* **Apparatus**: `stove`
+* **Substance**: `chocolate`
+* **Initial State**: `chocolate`
+* **Monitoring Action**: `examine chocolate`
+* **Observed State Change**: `liquid chocolate`
+* **Next Action**: Trigger a temperature measurement skill.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-process-monitor/references/state_transitions.md b/skills/benchmark_skills/scienceworld/scienceworld-process-monitor/references/state_transitions.md
new file mode 100644
index 0000000..a6c0004
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-process-monitor/references/state_transitions.md
@@ -0,0 +1,25 @@
+# Common State Transitions in ScienceWorld
+
+This document lists observable state changes for common substances and processes. Use these as reference when interpreting the output of `examine` commands.
+
+## Heating/Melting Processes
+| Substance | Initial State | Transition State | Final State (Melted) |
+| :--- | :--- | :--- | :--- |
+| Chocolate | `chocolate` | `softening chocolate` (optional) | `liquid chocolate` |
+| Ice / Water | `ice` | `water` (melting) | `water` |
+| Wax | `wax` | `soft wax` | `liquid wax` |
+| Butter | `butter` | `softened butter` | `melted butter` |
+
+## Chemical Reactions
+| Process | Initial State | Transition Indicator | Final State |
+| :--- | :--- | :--- | :--- |
+| Combustion | `substance` + `flame` | `smoke`, `ashes` | `ashes` |
+| Dissolution | `solid` in `liquid` | `dissolving solid` | `solution` |
+| Precipitation | `solution` | `cloudy solution`, `precipitate forming` | `solution with precipitate` |
+
+## Key Observation Patterns
+* **Adjective Change**: Look for new adjectives (`liquid`, `soft`, `cloudy`, `dissolved`).
+* **Noun Change**: The primary noun may change (`ice` → `water`).
+* **Compound Description**: The description may become a compound noun (`liquid chocolate`).
+
+**Note**: The exact textual output is environment-dependent. Focus on detecting *any change* from the previous `examine` result.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-process-pauser/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-process-pauser/SKILL.md
new file mode 100644
index 0000000..44500c2
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-process-pauser/SKILL.md
@@ -0,0 +1,26 @@
+---
+name: scienceworld-process-pauser
+description: This skill introduces deliberate pauses in task execution. It should be triggered when the agent needs to consider next steps, evaluate intermediate results, or wait for processes to complete. The skill uses the 'wait1' or 'wait' actions to temporarily halt activity, preventing rushed decisions in complex experimental procedures.
+---
+# Skill: Process Pauser
+
+## When to Use
+Activate this skill when you need to:
+* **Consider next steps** in a complex procedure.
+* **Evaluate an intermediate result** (e.g., a mixed chemical, a partial assembly).
+* **Wait for a simulated process** to complete.
+* **Prevent rushed decisions** that could lead to errors.
+
+## Core Actions
+Use the following actions to implement a pause:
+* `wait1`: Pauses execution for a single simulation step. Use for brief reflection.
+* `wait`: Pauses execution for 10 simulation steps. Use for longer consideration or simulated waiting periods.
+
+## Implementation Logic
+1. **Identify the Pause Trigger:** Recognize a moment requiring deliberation (e.g., after creating an intermediate product, before adding a new component).
+2. **Select Duration:** Choose `wait1` for quick checks or `wait` for extended evaluation.
+3. **Execute Pause:** Perform the selected wait action.
+4. **Resume:** Continue the task with the benefit of the reflective pause.
+
+## Example from Trajectory
+In the paint-mixing task, the agent used `wait1` after creating orange paint and before adding more red to make red-orange. This pause allowed for consideration of proportions and color adjustment.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-process-pauser/references/pause_scenarios.md b/skills/benchmark_skills/scienceworld/scienceworld-process-pauser/references/pause_scenarios.md
new file mode 100644
index 0000000..c438312
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-process-pauser/references/pause_scenarios.md
@@ -0,0 +1,32 @@
+# Pause Scenario Reference
+
+This document outlines common scenarios in ScienceWorld tasks where introducing a deliberate pause improves performance, based on trajectory analysis.
+
+## 1. After Creating an Intermediate Product
+* **Trigger:** Observation confirms creation of a new substance or assembly (e.g., "X and Y mix to produce Z").
+* **Purpose:** Evaluate the intermediate result's properties before proceeding.
+* **Example Action:** `wait1`
+* **Trajectory Example:** After `mix jug` produced "orange paint," the agent used `wait1`.
+
+## 2. Before a Critical or Irreversible Step
+* **Trigger:** About to add a final component, activate a device, or perform a mix that completes the task.
+* **Purpose:** Final verification of conditions and proportions to avoid error.
+* **Example Action:** `wait` (longer pause for complex verification)
+* **Trajectory Logic:** Before the final `pour` and `mix` to create red-orange paint.
+
+## 3. After a State Change Observation
+* **Trigger:** Observation begins with "You pour," "You connect," "You activate," etc.
+* **Purpose:** Process the consequence of the action before deciding the next step.
+* **Example Action:** `wait1`
+* **Trajectory Logic:** General best practice observed in successful trajectories.
+
+## 4. When Evaluating an Object
+* **Trigger:** After using `focus on OBJ` or `examine OBJ`.
+* **Purpose:** Deliberately process the descriptive information received.
+* **Example Action:** `wait1`
+* **Trajectory Example:** After `focus on orange paint`.
+
+## Anti-Patterns: When NOT to Pause
+* **During Exploration:** Do not pause after `look around` or `teleport`. Proceed directly to examining objects.
+* **After Simple Fetch Actions:** Do not pause after `pick up OBJ` unless it's a rare or final component.
+* **If the task is time-sensitive:** Some simulated processes may degrade if paused too long. Use context to judge.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-recipe-retriever/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-recipe-retriever/SKILL.md
new file mode 100644
index 0000000..0fb9aae
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-recipe-retriever/SKILL.md
@@ -0,0 +1,29 @@
+---
+name: scienceworld-recipe-retriever
+description: This skill locates and acquires a recipe or instruction document by using 'pick up' on the recipe object. It should be triggered when the task involves following a specific procedure (e.g., crafting, mixing) and the agent needs to obtain the written instructions. The skill assumes the recipe is visible in the current room and moves it to the inventory, allowing the agent to read it later to understand required ingredients and steps.
+---
+# Skill: Recipe Retriever
+
+## Purpose
+Acquire a visible recipe or instruction document from the current environment and store it in your inventory for later reference.
+
+## Trigger Conditions
+Use this skill when:
+1. The task involves following a specific procedure (e.g., crafting, mixing, building).
+2. You are instructed to find or use a recipe.
+3. You need written instructions to understand required ingredients and steps.
+
+## Core Procedure
+1. **Locate Recipe**: Use `look around` to survey the current room. Identify any object described as a "recipe," "instructions," "manual," or similar document.
+2. **Acquire Recipe**: Use `pick up <recipe_object>` to move the recipe to your inventory.
+3. **Verify Acquisition**: Confirm the recipe is now in your inventory before proceeding to the next task phase.
+
+## Key Notes
+- This skill assumes the recipe is visible and accessible in the current room.
+- The skill ends once the recipe is successfully moved to inventory.
+- Reading the recipe (using `read`) is a separate action that should be performed after acquisition.
+- If the recipe is not found in the current room, you may need to explore other rooms first.
+
+## Error Handling
+- If `pick up` fails (e.g., "You cannot pick that up"), examine the object first to verify it's a recipe.
+- If no recipe is found after looking around, expand your search to adjacent rooms.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-recipe-retriever/references/action_primitives.md b/skills/benchmark_skills/scienceworld/scienceworld-recipe-retriever/references/action_primitives.md
new file mode 100644
index 0000000..42a667a
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-recipe-retriever/references/action_primitives.md
@@ -0,0 +1,26 @@
+# Action Primitives for Recipe Acquisition
+
+## Core Actions Used
+1. **look around** - Surveys the current room and lists all visible objects
+2. **pick up <object>** - Moves an object from the environment to inventory
+
+## Related Supporting Actions
+- **examine <object>** - Get detailed description of an object (use if uncertain about recipe identity)
+- **read <object>** - Read contents of a document (use after acquisition)
+- **teleport to <location>** - Move to different rooms to search for recipe
+
+## Action Constraints
+- All containers are already open, so no need to `open` before accessing contents
+- Recipes are typically standalone objects, not inside containers
+- The `pick up` action should work directly on visible recipe objects
+
+## Common Observation Patterns
+When `look around` reveals a recipe, it typically appears in formats like:
+- "A recipe titled [name]"
+- "instructions to make [substance]"
+- "a manual for [process]"
+
+## Error Messages to Handle
+- "You cannot pick that up" - May indicate the object isn't actually a recipe
+- "You don't see that" - Recipe may not be in current room
+- "Your inventory is full" - Need to manage inventory space first
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-recipe-retriever/references/trajectory_analysis.md b/skills/benchmark_skills/scienceworld/scienceworld-recipe-retriever/references/trajectory_analysis.md
new file mode 100644
index 0000000..b11353f
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-recipe-retriever/references/trajectory_analysis.md
@@ -0,0 +1,31 @@
+# Trajectory Analysis for Recipe Retrieval
+
+## Observed Successful Pattern
+From the provided trajectory, the successful recipe acquisition followed this sequence:
+
+1. **Initial Context**: Task involves creating "salt water" using chemistry
+2. **Environment Survey**: Agent teleported to workshop after initial room checks
+3. **Recipe Identification**: `look around` revealed "A recipe titled instructions to make salt water"
+4. **Acquisition**: `pick up recipe` moved it to inventory
+5. **Verification**: Recipe was successfully in inventory for later reading
+
+## Key Insights
+- The recipe was found in the workshop, consistent with the hint "near the workshop"
+- No prior actions (opening containers, etc.) were needed before picking up the recipe
+- The recipe object name was simply "recipe" in the observation
+- Acquisition was immediate and successful on first attempt
+
+## Recommended Search Pattern
+When task involves a recipe:
+1. Check the hinted location first (e.g., "near the workshop")
+2. Use `look around` to identify recipe objects
+3. If not found, systematically check adjacent rooms
+4. Prioritize rooms related to the task domain (workshop for crafting, kitchen for cooking, etc.)
+
+## Integration with Broader Tasks
+Recipe retrieval is typically the first step in multi-phase tasks:
+1. Acquire recipe (this skill)
+2. Read recipe to understand requirements
+3. Gather ingredients
+4. Execute procedure
+5. Verify results
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-result-archiver/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-result-archiver/SKILL.md
new file mode 100644
index 0000000..4311746
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-result-archiver/SKILL.md
@@ -0,0 +1,31 @@
+---
+name: scienceworld-result-archiver
+description: Places an object into a designated container (like a colored box) based on a test outcome. It should be triggered when the agent needs to finalize a task by storing an object according to a rule (e.g., conductive → blue box, non-conductive → orange box). The input is the object and the rule, and the output is the object moved to the correct container.
+---
+# Instructions
+Use this skill to finalize a scientific test by archiving an object based on the observed result.
+
+## When to Use
+- You have just completed an experimental test (e.g., electrical conductivity, chemical reaction, physical property test).
+- You have a clear rule mapping a specific test outcome to a specific destination container (e.g., "If property X is true, place in Container A; if false, place in Container B").
+- The object to be archived and the destination containers are present in your current environment.
+
+## Core Procedure
+1. **Verify Context:** Ensure you are in the correct room (typically the `workshop` or lab area) where the test was conducted and where the destination containers are located.
+2. **Confirm Test Result:** Observe the final state of your experimental apparatus to definitively determine the test outcome (e.g., "light bulb is on").
+3. **Apply Rule:** Map the confirmed outcome to the corresponding destination container as specified by the task rule.
+4. **Execute Archive:** Move the test object from its current location (inventory or room) into the correct container using the `move OBJ to CONTAINER` action.
+
+## Key Principles
+- **Direct Archiving:** Do not re-run the test. The skill is for archiving the result based on an *already observed* outcome.
+- **Rule Adherence:** Strictly follow the provided mapping rule. Do not infer or create new rules.
+- **Container Verification:** Before moving the object, visually confirm the target container exists in the room (use `look around` if uncertain).
+
+## Example Rule Application
+*Task Rule:* "If the metal pot is electrically conductive, place it in the blue box. If it is electrically nonconductive, place it in the orange box."
+*Observation:* The blue light bulb in the circuit is **on**.
+*Interpretation:* The metal pot is conductive.
+*Action:* `move metal pot to blue box`
+
+## Bundled Logic
+For the specific, error-prone sequence of connecting a circuit to test electrical conductivity, use the bundled script `scripts/conductivity_test.py` as a reference. For all other test types, use the general instructions above.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-room-explorer/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-room-explorer/SKILL.md
new file mode 100644
index 0000000..f3dc764
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-room-explorer/SKILL.md
@@ -0,0 +1,31 @@
+---
+name: scienceworld-room-explorer
+description: This skill performs an initial survey of a specified room to identify all visible objects and their states. It should be triggered when the agent first enters a new location or needs to refresh its understanding of the environment. The skill uses the 'look around' action and returns a detailed observation of the room's contents, which serves as the foundational context for subsequent object interaction tasks.
+---
+# Instructions
+
+## Purpose
+Use this skill to establish a foundational understanding of your immediate environment. It is the critical first step for any task requiring object interaction, inventory assessment, or spatial reasoning.
+
+## When to Use
+1. **Upon entering a new room.**
+2. When the task requires identifying available resources.
+3. Before planning a complex sequence of actions (e.g., building a circuit, mixing chemicals).
+4. If the state of the environment may have changed (e.g., after using an object, or if a long time has passed).
+
+## Core Action
+Execute the `look around` action. This is the only action required for this skill.
+
+## Output Processing
+1. The observation returned by `look around` is your primary output.
+2. Parse this observation to create a mental inventory. Key elements to note:
+ * **Room Name:** The identified location.
+ * **Objects:** List all items, containers, and devices.
+ * **Object States:** Note if devices are on/off, containers are open/closed, or if objects contain other items.
+ * **Connections:** Note any pre-existing wire connections or object placements.
+ * **Exits:** Identify doors to other rooms and their state (open/closed).
+
+## Integration with Other Skills
+The observation generated by this skill is essential context for downstream tasks. Before performing actions like `pick up`, `connect`, or `use`, always ensure your understanding of object locations and states is current by running this skill if needed.
+
+**Do not** use this skill for examining specific objects in detail; use the `examine OBJ` or `look at OBJ` actions for that purpose.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-room-explorer/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-room-explorer/references/action_primer.md
new file mode 100644
index 0000000..61fc8b1
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-room-explorer/references/action_primer.md
@@ -0,0 +1,34 @@
+# Action Primer for ScienceWorld Environment
+
+This reference details common actions used in conjunction with the `scienceworld-room-explorer` skill for task execution.
+
+## Foundational Action
+* `look around`: Describes the current room, listing all visible objects, their states, and contents. **This is the core action of the scienceworld-room-explorer skill.**
+
+## Common Follow-up Actions
+After using `scienceworld-room-explorer`, you will typically use other actions to manipulate the discovered objects.
+
+### Object Interaction
+* `examine OBJ`: Get a detailed description of a specific object's properties.
+* `look at OBJ`: List the contents of a container.
+* `pick up OBJ`: Move an object into your inventory.
+* `move OBJ to OBJ`: Place an object into a container or onto a surface.
+* `use OBJ [on OBJ]`: Operate a device or apply an item.
+
+### Electrical & Device Manipulation
+* `connect OBJ to OBJ`: Link two electrical components (e.g., wire terminal to battery terminal).
+* `disconnect OBJ`: Remove a connection from a component.
+* `activate OBJ` / `deactivate OBJ`: Turn a device on or off.
+* `focus on OBJ`: Signal intent to interact with a specific task-relevant object.
+
+### Navigation
+* `teleport to LOC`: Instantly move to another room.
+
+## Action Sequencing Pattern
+A standard task execution pattern often follows this flow:
+1. **Explore:** Use `scienceworld-room-explorer` (`look around`) to understand the room.
+2. **Locate:** Identify the target object(s) from the observation.
+3. **Acquire:** Use `pick up` or navigate to the object.
+4. **Prepare:** Use `examine`, `connect`, or other actions to set up the object for the task.
+5. **Execute:** Use `use`, `activate`, `mix`, etc., to perform the core task action.
+6. **Conclude:** Use `move` or other actions to complete the task (e.g., placing an object in a specified box).
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-room-navigator/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-room-navigator/SKILL.md
new file mode 100644
index 0000000..876f16c
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-room-navigator/SKILL.md
@@ -0,0 +1,22 @@
+---
+name: scienceworld-room-navigator
+description: Teleports the agent to a specified room within the ScienceWorld environment. It should be triggered when the agent needs to move between different locations to locate objects or access specific facilities. The input is a target room name, and the output is the agent arriving at that room, ready for further interaction.
+---
+# Instructions
+
+Use this skill to instantly move the agent to a different room. This is the primary method of navigation.
+
+## When to Use
+* The agent needs to find an object known to be in a specific room (e.g., "metal pot is located around the kitchen").
+* The agent needs to access a facility available only in a specific room (e.g., a workshop for building circuits, a foundry for smelting).
+* The agent has completed tasks in one room and needs to proceed to the next relevant location.
+
+## How to Use
+1. **Identify the Target Room:** Determine the exact name of the destination room from the task context or environment description (e.g., `kitchen`, `workshop`, `foundry`).
+2. **Execute Teleport:** Use the `teleport to <ROOM_NAME>` action.
+3. **Verify Arrival:** The observation will confirm the teleport was successful (e.g., "You teleport to the kitchen."). You may then proceed with `look around` to survey the new location.
+
+## Important Notes
+* Teleportation is a single-step action. There is no need for intermediate movement.
+* All standard room connections (doors) remain, but teleportation bypasses them.
+* After teleporting, the agent's inventory and any held items remain unchanged.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-room-navigator/references/available_rooms.md b/skills/benchmark_skills/scienceworld/scienceworld-room-navigator/references/available_rooms.md
new file mode 100644
index 0000000..fe3bc2f
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-room-navigator/references/available_rooms.md
@@ -0,0 +1,15 @@
+# ScienceWorld Environment - Known Rooms
+This is a non-exhaustive list of rooms observed in the trajectory. The environment may contain others.
+
+* **Kitchen:** Common location for household items like pots, pans, and ingredients.
+* **Foundry:** Contains industrial equipment like a blast furnace, typically for high-temperature processes.
+* **Workshop:** Contains tools, electrical components (wires, batteries, light bulbs), and workbenches for building and testing.
+* **Bathroom:** Likely contains water sources (sink, tub) and related items.
+* **Outside:** The exterior environment.
+* **Living Room:** A general common area.
+* **Bedroom:** A sleeping area.
+* **Greenhouse:** Likely for plants and botanical items.
+* **Art Studio:** Likely for creative supplies.
+* **Hallway:** A connecting passage between rooms.
+
+**Usage Tip:** Always use the exact room name as provided by the environment or task description when invoking the `teleport` action.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-room-scanner/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-room-scanner/SKILL.md
new file mode 100644
index 0000000..236fa57
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-room-scanner/SKILL.md
@@ -0,0 +1,33 @@
+---
+name: scienceworld-room-scanner
+description: This skill performs a 'look around' action to scan and describe the current room's contents, including visible objects, containers, and doors. It should be triggered upon entering a new room or when the agent needs to locate specific items or assess the environment state. The skill outputs a detailed room description, which is essential for inventory discovery and situational awareness.
+---
+# Skill: Room Scanner
+
+## Purpose
+Execute a `look around` action to obtain a comprehensive description of the current room in the ScienceWorld environment. This description is the foundational step for any task requiring item location, environmental assessment, or navigation planning.
+
+## Core Instruction
+When this skill is invoked, the agent must perform the **`look around`** action.
+
+## Trigger Conditions
+Invoke this skill when:
+1. You first enter a new room via `teleport` or other movement.
+2. You need to locate a specific object or container mentioned in your task.
+3. The state of the room may have changed (e.g., after an interaction).
+4. You are formulating a plan and require an inventory of available resources.
+
+## Output Processing
+The observation from `look around` will contain:
+* **Room Name:** The identifier of your current location.
+* **Visible Objects & Agents:** A list of all entities in the room.
+* **Container Contents:** For open containers, a nested list of items inside (e.g., `a bowl (containing a red apple, a banana)`).
+* **Device States:** The status of interactive objects (e.g., `a stove, which is turned off`).
+* **Connections:** All accessible doors and their destination rooms.
+
+**You must parse this output carefully.** Use it to update your mental model of the environment before proceeding with other actions like `pick up`, `examine`, or `use`.
+
+## Integration Notes
+* This is a low-level, atomic skill. It should often be the first action in a sequence.
+* The observation it generates is critical context for subsequent decision-making. Refer back to it.
+* Do not overuse it. Once you have a recent description of a room, rely on that knowledge until you have reason to believe the state has changed.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-room-scanner/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-room-scanner/references/action_primer.md
new file mode 100644
index 0000000..71485ab
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-room-scanner/references/action_primer.md
@@ -0,0 +1,33 @@
+# ScienceWorld Action Primer for Room Scanning
+
+## The `look around` Action
+* **Syntax:** `look around`
+* **Effect:** Returns a detailed textual description of the agent's current room.
+* **Key Observation Fields:**
+ 1. `This room is called <ROOM_NAME>.`
+ 2. `In it, you see:` - Lists all objects, substances, and the agent itself.
+ 3. `On <CONTAINER> is:` / `In <CONTAINER> is:` - Describes contents of open containers and furniture.
+ 4. `You also see:` - Lists all doorways to adjacent rooms.
+
+## Related Contextual Actions
+Use information from `look around` to inform these subsequent actions:
+
+| Action | Syntax Example | Use Case After Scanning |
+| :--- | :--- | :--- |
+| `examine` | `examine thermometer` | Get detailed properties of a specific object seen in the room. |
+| `look at` | `look at cupboard` | See the contents of a specific container (more focused than `look around`). |
+| `teleport to` | `teleport to kitchen` | Move to a room listed in the "You also see:" connections. |
+| `pick up` | `pick up thermometer` | Take an object that is listed as visible and accessible. |
+
+## Common Room Types & Key Objects
+Based on the trajectory, here are typical rooms and objects of interest:
+* **Kitchen:** `thermometer`, `oven`, `stove`, `metal pot`, various `boxes`, `cupboard`.
+* **Foundry:** `blast furnace` (for high-temperature heating).
+* **Hallway:** Central hub with doors to many other rooms.
+* **Workshop/Greenhouse/Art Studio:** Likely contain specialized tools or materials.
+
+## Best Practice: The Scan-Act Cycle
+1. **SCAN:** Use `look around` upon entry or when uncertain.
+2. **PARSE:** Identify the objects relevant to your current goal from the description.
+3. **ACT:** Execute a targeted action (`pick up`, `examine`, `use`).
+4. **RE-SCAN (if needed):** If your action changes the room state significantly (e.g., activating a furnace, moving many items), consider another `look around` to confirm the new state.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-room-teleporter/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-room-teleporter/SKILL.md
new file mode 100644
index 0000000..b887db9
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-room-teleporter/SKILL.md
@@ -0,0 +1,16 @@
+---
+name: scienceworld-room-teleporter
+description: Teleports the agent to a specified room within the ScienceWorld environment. Use this skill when the target object or location for a task is known to be in a different room, enabling efficient navigation. It takes a target room name as input and outputs a successful teleportation observation.
+---
+# Instructions
+Use the `teleport to LOC` action to move the agent to the specified room.
+
+## Procedure
+1. **Identify Target Room:** Determine the exact name of the destination room from the task context or environment description.
+2. **Execute Teleport:** Use the action `teleport to <room_name>`, where `<room_name>` is the target location (e.g., `workshop`, `kitchen`, `foundry`).
+3. **Verify Success:** The expected output is an observation confirming the teleport, e.g., "You teleport to the workshop."
+
+## Important Notes
+- This skill is for navigation only. It does not handle object interaction or task logic within the destination room.
+- Ensure the room name matches the environment's naming exactly. Common rooms include: kitchen, foundry, workshop, bathroom, outside, living room, bedroom, greenhouse, art studio, hallway.
+- Use this skill proactively to reduce unnecessary exploration steps when the target location is known.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-substance-cooler/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-substance-cooler/SKILL.md
new file mode 100644
index 0000000..f77ed4a
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-substance-cooler/SKILL.md
@@ -0,0 +1,32 @@
+---
+name: scienceworld-substance-cooler
+description: This skill initiates the cooling of a substance by moving it into a cooling appliance like a freezer. It should be triggered when a task requires lowering the temperature of a specific material to observe phase changes. The skill takes the substance (often in a container) and the target appliance as inputs, using the 'move OBJ to OBJ' action. It outputs confirmation of the new location.
+---
+# Skill: Substance Cooler
+
+## Purpose
+Use this skill to begin the process of cooling a substance to potentially observe a phase change (e.g., freezing). The core action is to relocate the substance into a cooling appliance.
+
+## When to Use
+* The task explicitly requires cooling a substance (e.g., "measure the melting point of mercury").
+* You have identified both the target substance (often inside a container like a cup or jar) and a suitable cooling appliance (e.g., freezer, ultra low temperature freezer).
+* The immediate goal is to lower the substance's temperature.
+
+## Core Instruction
+1. **Locate Items:** Ensure you are in the room containing the target substance and the cooling appliance. Use `look around` if necessary.
+2. **Execute Move:** Perform the action `move <SUBSTANCE_CONTAINER> to <APPLIANCE>`.
+ * `<SUBSTANCE_CONTAINER>`: The object holding the substance (e.g., "glass cup (containing a substance called mercury)").
+ * `<APPLIANCE>`: The cooling device (e.g., "freezer").
+3. **Verify:** Use `look at <APPLIANCE>` to confirm the substance is now inside the appliance. Report this confirmation.
+
+## Important Notes
+* **Prerequisite:** The appliance door must be open. The trajectory shows all containers are already open, so this should not require a separate `open` action.
+* **This is an Initialization Skill:** This skill only *starts* the cooling process. Subsequent skills or actions (like `use thermometer on <SUBSTANCE>`) are required to monitor temperature changes and observe the phase transition.
+* **Inputs:** The skill requires the names of the substance container and the target appliance as identified in the environment observations.
+* **Output:** A confirmation observation stating the substance is now inside the appliance.
+
+## Example from Trajectory
+**Trigger:** Task requires measuring the melting point of mercury.
+**Action:** `move glass cup (containing a substance called mercury) to freezer`
+**Verification:** `look at freezer` yields "In the freezer is: a glass cup (containing a substance called mercury)."
+**Output:** "The mercury in its glass cup has been placed into the freezer to begin cooling."
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-substance-cooler/references/phase_change_protocol.md b/skills/benchmark_skills/scienceworld/scienceworld-substance-cooler/references/phase_change_protocol.md
new file mode 100644
index 0000000..35679a2
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-substance-cooler/references/phase_change_protocol.md
@@ -0,0 +1,26 @@
+# Reference: Phase Change Observation Protocol
+
+## Overview
+Cooling a substance to observe a phase change (e.g., liquid to solid) is a multi-step process. The `scienceworld-substance-cooler` skill is **Step 1**.
+
+## Full Workflow
+1. **Initialization (This Skill):** Move the substance into a cooling appliance.
+2. **Monitoring:** Periodically use a thermometer on the substance to track its temperature.
+ * Command: `use thermometer on <SUBSTANCE_NAME>`
+ * Frequency: Varies. Monitor until the target temperature range is approached.
+3. **Observation:** Continuously `examine <SUBSTANCE_NAME>` to detect visual/physical state changes indicating a phase transition.
+4. **Decision:** Based on the observed melting/freezing point and task criteria, take the next action (e.g., "focus on yellow box").
+
+## Key Concepts from Trajectory
+* **Melting/Freezing Point:** The temperature at which a substance changes state. The task may involve determining if this point is above or below a specific value (e.g., -10.0°C).
+* **Thermal Equilibrium:** It takes time for the substance to cool to the appliance's temperature. Repeated measurements are necessary.
+* **Appliance Limitations:** A standard kitchen freezer may not reach extremely low temperatures. For very low melting points, an "ultra low temperature freezer" might be required.
+
+## Common Cooling Appliances
+* `freezer`: Standard kitchen appliance. Cools to temperatures below 0°C.
+* `ultra low temperature freezer`: Found in labs/workshops. Cools to much lower temperatures (e.g., -50°C or below).
+
+## Error Handling
+* **"You can't do that.":** Ensure the appliance door is open. Use `look at <APPLIANCE>` to check.
+* **No Temperature Change:** The appliance might be off or broken. Try `activate <APPLIANCE>` if applicable.
+* **Substance Not Found:** Confirm the correct container description from the latest `look around` observation.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-substance-fetcher/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-substance-fetcher/SKILL.md
new file mode 100644
index 0000000..734e292
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-substance-fetcher/SKILL.md
@@ -0,0 +1,36 @@
+---
+name: scienceworld-substance-fetcher
+description: This skill locates and retrieves a target substance or material from a container in the environment. It should be triggered when the core task involves processing a specific substance (e.g., chocolate, a chemical). The skill finds the substance, often inside a fridge or cupboard, and acquires it via a pick-up or move action.
+---
+# Skill: Substance Fetcher
+
+## Primary Objective
+Locate a specified target substance (e.g., `chocolate`, `sodium chloride`) within the environment and retrieve it for subsequent processing.
+
+## Core Logic & Workflow
+1. **Identify Target:** The target substance name is provided as part of the task initiation (e.g., "Your task is to measure the melting point of **chocolate**").
+2. **Search Strategy:**
+ * If the current room does not contain the target, use `teleport to [room]` to navigate to likely locations (e.g., `kitchen`, `workshop`, `greenhouse`).
+ * Use `look around` to survey a room and identify containers.
+3. **Locate in Container:**
+ * Examine open containers (`fridge`, `cupboard`, `counter`, `drawer`) listed in the room description.
+ * The target substance is often found inside a container (e.g., "In the fridge is: **chocolate**").
+4. **Retrieval Action:**
+ * If the substance is a portable object, use `pick up [substance]`.
+ * If the substance is inside another object (e.g., in a pot), use `move [substance] to [destination container]` to prepare it for use.
+ * **Key Assumption:** All containers are already open. Do not use `open` or `close` actions.
+
+## Critical Constraints & Notes
+* **Container State:** Assume all containers (fridge, cupboard, drawer) are **already open**. Do not waste actions opening them.
+* **Action Efficiency:** Prefer `pick up` for direct acquisition. Use `move` only when necessary to transfer the substance to a specific vessel for an experiment.
+* **Verification:** After retrieval, you may use `examine [substance]` or check your inventory to confirm success before proceeding to the next phase of the experiment.
+
+## Example Execution (Based on Trajectory)
+**Task Context:** "Your task is to measure the melting point of **chocolate**..."
+1. `teleport to kitchen`
+2. `look around` *(Observes: "In the fridge is: chocolate...")*
+3. `pick up chocolate` or `move chocolate to metal pot`
+
+## Error Handling
+* If the substance is not found in the initially suspected room, teleport to and search other relevant rooms (e.g., `workshop` for chemicals, `greenhouse` for plants).
+* If the retrieval action fails (e.g., object not found), re-examine the room description with `look around` to confirm the substance's location and container.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-substance-fetcher/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-substance-fetcher/references/action_primer.md
new file mode 100644
index 0000000..fe70995
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-substance-fetcher/references/action_primer.md
@@ -0,0 +1,24 @@
+# Action Primer for ScienceWorld Environment
+
+## Relevant Actions for Substance Fetching
+- `teleport to LOC`: Instantly move to a named room (e.g., `kitchen`, `workshop`).
+- `look around`: Get a full description of the current room and its contents.
+- `examine OBJ`: Get a detailed description of a specific object.
+- `look at OBJ`: Describe a container's contents (redundant if `look around` was just used).
+- `pick up OBJ`: Move a portable object to your inventory.
+- `move OBJ to OBJ`: Move an object to a container or surface.
+
+## Typical Container Names
+* `fridge`
+* `freezer`
+* `cupboard`
+* `counter`
+* `drawer`
+* `shelf`
+* `table`
+
+## Common Substance Locations
+* **Kitchen:** Food items (chocolate, fruit), cooking ingredients (salt, oil).
+* **Workshop:** Chemicals, tools, raw materials.
+* **Greenhouse:** Plants, soil, water.
+* **Art Studio:** Paints, solvents, clay.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-substance-preparator/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-substance-preparator/SKILL.md
new file mode 100644
index 0000000..687c3ab
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-substance-preparator/SKILL.md
@@ -0,0 +1,36 @@
+---
+name: scienceworld-substance-preparator
+description: This skill transfers a target substance into an appropriate container for processing (e.g., a pot for heating, a beaker for mixing). It should be triggered after acquiring the substance and before setting up an apparatus. The skill selects a suitable empty container and moves the substance into it.
+---
+# Substance Preparation Skill
+
+## Purpose
+Prepare a target substance for subsequent processing (e.g., heating, mixing) by transferring it from its current location into an appropriate, empty container.
+
+## When to Use
+1. **Trigger:** After successfully locating and focusing on the target substance.
+2. **Prerequisite:** The substance must be accessible (e.g., in inventory, in an open container).
+3. **Next Step:** This skill should be completed **before** setting up any apparatus (e.g., activating a stove, connecting electrical components).
+
+## Core Procedure
+1. **Identify Target Substance:** Confirm the exact name and location of the substance to be prepared.
+2. **Scan Environment for Containers:** Look for empty, process-appropriate containers in the current room. Priority order:
+ * **Primary:** Metal pots, beakers, or bowls (for heating/mixing).
+ * **Secondary:** Ceramic/glass cups, jars (if primary not available).
+ * **Avoid:** Containers already holding items or substances.
+3. **Select & Validate Container:** Choose the most suitable empty container. If uncertain, `examine` it to confirm it's empty.
+4. **Execute Transfer:** Use the `move [SUBSTANCE] to [CONTAINER]` action.
+5. **Verify:** Briefly check the container's contents to confirm the transfer was successful.
+
+## Key Considerations
+* **Container State:** All containers are pre-opened. Do not use `open` or `close` actions.
+* **Efficiency:** Prefer containers in the same room to minimize `teleport` use.
+* **Substance Integrity:** If the substance is temperature-sensitive (e.g., chocolate in a fridge), moving it to a room-temperature container is part of preparation.
+* **Error Handling:** If the transfer fails (e.g., container not found), `look around` again and consult the bundled reference for common container names.
+
+## Example from Trajectory
+> **Substance:** `chocolate` (found in fridge).
+> **Action:** `move chocolate to metal pot` (metal pot was empty in cupboard).
+> **Verification:** Subsequent `look at stove` showed "metal pot (containing chocolate)".
+
+**Proceed to the next skill (e.g., apparatus setup) only after this verification.**
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-substance-preparator/references/common_containers.md b/skills/benchmark_skills/scienceworld/scienceworld-substance-preparator/references/common_containers.md
new file mode 100644
index 0000000..6f9b0ba
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-substance-preparator/references/common_containers.md
@@ -0,0 +1,27 @@
+# Common Container Reference
+
+## For Heating/Mixing (Primary)
+* `metal pot`
+* `beaker` (glass)
+* `bowl`
+* `cauldron` (foundry)
+* `crucible` (foundry)
+
+## For General Holding (Secondary)
+* `ceramic cup`
+* `glass cup`
+* `tin cup`
+* `wood cup`
+* `glass jar`
+* `flask`
+
+## Typically Not Suitable
+* `drawer` (fixed furniture)
+* `fridge`/`freezer` (appliance, not portable)
+* `sink` (plumbing fixture)
+* `oven` (appliance)
+
+## Verification Commands
+* `look at [CONTAINER]` - Lists contents.
+* `examine [CONTAINER]` - Confirms object type and state.
+* `look around` - Scans room for all available containers.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-target-identifier/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-target-identifier/SKILL.md
new file mode 100644
index 0000000..18c29c8
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-target-identifier/SKILL.md
@@ -0,0 +1,59 @@
+---
+name: scienceworld-target-identifier
+description: Analyzes room observations to identify objects matching a given target description (e.g., 'living thing'). Triggered after exploring a room when the agent needs to locate a specific type of item. Processes the observation list, filters objects based on target criteria, and returns candidate objects for further action.
+---
+# Skill: Target Object Identifier
+
+## Purpose
+This skill enables you to systematically locate objects in the ScienceWorld environment that match a specific target description (e.g., "living thing", "container", "electrical device"). It transforms the raw observation text from `look around` into a structured list of candidate objects for your current task.
+
+## When to Use
+1. **Trigger Condition**: Immediately after executing `look around` in any room.
+2. **Input Required**: The full observation text from `look around` AND the target description from your task.
+3. **Output**: A prioritized list of matching objects with their locations and properties.
+
+## Execution Workflow
+
+### Step 1: Parse Observation
+Extract all observable items from the room description. Pay special attention to:
+- Objects listed after "Here you see:"
+- Objects in containers (marked with "containing" or "On the X is:")
+- Substances (marked as "a substance called")
+- Living vs. non-living distinctions
+
+### Step 2: Apply Target Filter
+Use the bundled classification script to filter objects based on the target description:
+- For "living thing": Include animals, plants, eggs, and biological organisms
+- For specific categories: Match against known object taxonomies
+- For generic descriptions: Use semantic similarity matching
+
+### Step 3: Prioritize Candidates
+Rank candidates by:
+1. **Accessibility**: Objects not in closed containers first
+2. **Proximity**: Objects in current room before other locations
+3. **Task Relevance**: Objects matching secondary task criteria (e.g., "easy to transport")
+
+### Step 4: Generate Action Plan
+For each high-priority candidate:
+1. Note its exact name as it appears in observations
+2. Determine if `pick up`, `focus on`, or other preliminary action is needed
+3. Plan path to target location if specified in task
+
+## Key Considerations
+- **Exact Object Names**: Use the exact phrasing from observations (e.g., "turtle egg" not "egg turtle")
+- **Container States**: All containers are open per environment rules
+- **Teleportation**: You can instantly move between rooms when searching
+- **Multiple Matches**: If multiple objects match, select based on task context (e.g., choose less mobile items for transport tasks)
+
+## Error Handling
+- If no matches found: Teleport to another room and repeat
+- If ambiguous matches: Use `examine OBJ` for clarification
+- If classification uncertain: Check reference taxonomy in bundled resources
+
+## Example Application
+*Task*: "Find a living thing and move it to the blue box in bathroom"
+1. `look around` in current room
+2. Run this skill with target="living thing"
+3. Receive list: ["baby wolf", "turtle egg", "crocodile egg"]
+4. Select "turtle egg" (easier to transport)
+5. `focus on turtle egg` → `pick up turtle egg` → `teleport to bathroom` → `move turtle egg to blue box`
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-target-identifier/references/action_patterns.md b/skills/benchmark_skills/scienceworld/scienceworld-target-identifier/references/action_patterns.md
new file mode 100644
index 0000000..c5c8b2e
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-target-identifier/references/action_patterns.md
@@ -0,0 +1,4 @@
+# Common Action Patterns for Target Objects
+
+## Object Acquisition Patterns
+### Pattern 1: Simple Pickup
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-target-identifier/references/taxonomy.md b/skills/benchmark_skills/scienceworld/scienceworld-target-identifier/references/taxonomy.md
new file mode 100644
index 0000000..add82cc
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-target-identifier/references/taxonomy.md
@@ -0,0 +1,64 @@
+# ScienceWorld Object Taxonomy
+
+## Living Things Category
+### Animals
+- Mammals: wolf, dog, cat, mouse, rat
+- Reptiles: turtle, crocodile, lizard, snake
+- Birds: bird, chicken, duck
+- Fish: fish, goldfish
+- Insects: ant, bee, butterfly, spider
+
+### Animal States & Parts
+- Eggs: turtle egg, crocodile egg, bird egg
+- Young: baby [animal], young [animal]
+- Remains: fur, feather, bone
+
+### Plants
+- Trees: tree, sapling
+- Flowers: flower, rose, tulip
+- General: plant, leaf, seed, sprout
+- Crops: wheat, corn, tomato
+
+### Microorganisms
+- Bacteria: (implied in decay processes)
+- Fungi: mushroom, mold
+
+## Non-Living Categories
+### Containers
+- Storage: box, chest, cabinet, closet, drawer, shelf
+- Liquid: bottle, jar, cup, glass, bowl
+- Transport: bag, basket, cart
+
+### Tools & Equipment
+- Cutting: axe, knife, scissors
+- Digging: shovel, pickaxe
+- Fastening: hammer, screwdriver, wrench, nail, screw
+- Measuring: ruler, tape, scale
+
+### Electrical Components
+- Power: battery, generator, outlet
+- Control: switch, button, dial
+- Connection: wire, cable, plug
+- Output: lamp, bulb, motor, buzzer
+
+### Substances
+- Solids: wood, metal, stone, plastic, cloth
+- Liquids: water, oil, juice, milk
+- Gases: air, steam, smoke
+- Powders: flour, salt, sugar, sand
+
+## Special Object Properties
+### Mobility
+- Fixed: bed, table, fountain, fire pit
+- Portable: most small objects
+- Autonomous: living things
+
+### State Changes
+- Activatable: devices with on/off states
+- Consumable: food, fuel
+- Transformable: ingredients for mixing
+
+### Task Relevance Indicators
+- For transport tasks: small, light, non-fragile objects preferred
+- For electrical tasks: conductive materials needed
+- For chemical tasks: reactive substances needed
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-target-locator/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-target-locator/SKILL.md
new file mode 100644
index 0000000..083a25e
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-target-locator/SKILL.md
@@ -0,0 +1,25 @@
+---
+name: scienceworld-target-locator
+description: This skill determines the most likely location for a target object based on domain knowledge and environmental clues. Trigger this when the agent needs to find a specific item (like an animal) but it is not in the current room. It analyzes the environment description and suggests a room to teleport to for further investigation.
+---
+# Skill: Target Locator
+
+**Trigger:** When the agent needs to find a specific object (e.g., an animal, a tool, a chemical) and a preliminary `look around` in the current room does not reveal it.
+
+## Core Logic
+
+1. **Analyze the Target:** Classify the target object based on its type (e.g., `animal`, `tool`, `container`, `chemical`).
+2. **Consult Domain Knowledge:** Use the bundled reference (`target_location_heuristics.md`) to map the object type to the most probable room(s) in the ScienceWorld environment.
+3. **Evaluate Current Context:** Briefly review the recent `look around` observation. If doors to high-probability rooms are visible and open, prioritize them.
+4. **Output Decision:** Output a single, clear `teleport to LOC` action command, choosing the most promising location to search next.
+
+**Primary Instruction:** Do not overthink. Rely on the heuristics. The goal is to make an efficient, educated guess to continue the search.
+
+## Example Flow (From Trajectory)
+* **Task:** "find a(n) animal."
+* **Trigger:** `look around` in hallway shows no animal.
+* **Analysis:** Target type = `animal`.
+* **Heuristic Check:** Animals are most commonly found `outside`.
+* **Context Check:** A door to `outside` is not listed in the hallway observation.
+* **Decision:** The highest-probability room `outside` is accessible via teleport.
+* **Output:** `teleport to outside`
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-target-locator/references/target_location_heuristics.md b/skills/benchmark_skills/scienceworld/scienceworld-target-locator/references/target_location_heuristics.md
new file mode 100644
index 0000000..9feae5e
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-target-locator/references/target_location_heuristics.md
@@ -0,0 +1,25 @@
+# Target Location Heuristics for ScienceWorld
+
+This reference contains common-sense mappings between object types and their most likely locations in the ScienceWorld environment. Use this to inform the `teleport` decision.
+
+## Room List
+kitchen, foundry, workshop, bathroom, outside, living room, bedroom, greenhouse, art studio, hallway
+
+## Object Type -> Probable Room(s)
+
+* **animal / egg / living creature:** `outside`, `greenhouse`, `bedroom` (if pet)
+* **tool / device / mechanical part:** `workshop`, `foundry`, `kitchen`
+* **container (box, chest, bottle):** `workshop`, `kitchen`, `living room`, `bedroom`
+* **chemical / substance / liquid:** `bathroom`, `kitchen`, `workshop`, `greenhouse`
+* **food / ingredient:** `kitchen`, `greenhouse`
+* **art supply / canvas / paint:** `art studio`
+* **furniture / decorative item:** `living room`, `bedroom`, `hallway`
+* **plant / seed / soil:** `greenhouse`, `outside`
+* **book / note / paper:** `bedroom`, `living room`, `art studio`, `workshop`
+* **metal / ore / raw material:** `foundry`, `workshop`, `outside`
+
+## Search Priority Notes
+1. `outside` and `greenhouse` are high-probability for biological targets.
+2. `workshop` and `foundry` are high-probability for mechanical/industrial targets.
+3. If a high-probability room is not directly accessible via a visible door, use `teleport`.
+4. If the target type is ambiguous, default to the first room in its list.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-task-focuser/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-task-focuser/SKILL.md
new file mode 100644
index 0000000..9bbdc10
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-task-focuser/SKILL.md
@@ -0,0 +1,33 @@
+---
+name: scienceworld-task-focuser
+description: This skill directs the agent's attention to a specific object, either in the environment or inventory, to signal intent or prepare for an operation. It should be triggered before performing a critical action on an object, such as measuring or using it, to ensure the agent is properly aligned with the task. The skill outputs a confirmation of focus, which often is required for subsequent interactive steps in experimental procedures.
+---
+# Skill: scienceworld-task-focuser
+
+## Purpose
+Use this skill to formally declare your intent to interact with a specific object. This is a crucial preparatory step in scientific workflows within the ScienceWorld environment. Focusing on an object signals to the system that subsequent actions (like `use`, `measure`, `connect`) are targeted and deliberate, often unlocking necessary state changes or measurement capabilities.
+
+## When to Use
+* **Before Measurement:** Before using a tool (e.g., a thermometer) on a target object.
+* **Before Complex Operations:** Prior to connecting, mixing, or using one object on another.
+* **Task Alignment:** When a task description explicitly instructs you to "focus on" an object.
+* **Inventory Management:** To confirm you have the correct item in your inventory before proceeding.
+
+## Core Instruction
+1. **Identify the Target Object:** Determine the exact name of the object you need to focus on (e.g., `thermometer`, `metal fork`).
+2. **Locate the Object:** The object may be in the environment (`on table`) or in your inventory (`in inventory`). Use `look around` and `examine` to find it.
+3. **Execute the Focus Action:** Use the exact action format:
+ * If the object is in the environment: `focus on <OBJECT_NAME>`
+ * If the object is in your inventory: `focus on <OBJECT_NAME> in inventory`
+4. **Verify Confirmation:** The environment will respond with "You focus on the `<OBJECT_NAME>`." This is your confirmation to proceed.
+
+## Example from Trajectory
+**Scenario:** Measuring the temperature of a metal fork.
+1. **Focus on the tool:** `focus on thermometer in inventory` (Confirms intent to use the thermometer).
+2. **Focus on the target:** `focus on metal fork in inventory` (Confirms the object to be measured).
+
+## Important Notes
+* This skill does not perform the main action (e.g., measuring). It only prepares for it.
+* The `focus` action has no physical effect on the object; it is a declarative meta-action.
+* Always wait for the confirmation observation before attempting the next step in your procedure.
+* If an object is not found, revisit your search logic before attempting to focus.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-task-interpreter/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-task-interpreter/SKILL.md
new file mode 100644
index 0000000..68626d5
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-task-interpreter/SKILL.md
@@ -0,0 +1,23 @@
+---
+name: scienceworld-task-interpreter
+description: This skill parses a user's high-level scientific task in the ScienceWorld environment and extracts the core objective and target location. It should be triggered when a new task instruction is received, especially those involving finding, comparing, or manipulating objects. The skill interprets the query to identify the goal (e.g., 'find the animal with the shortest life span') and any specified locations (e.g., 'animals are in the outside location'), outputting a clear, actionable sub-goal for navigation or observation.
+---
+# Instructions
+
+Activate this skill when the user provides a new task instruction for the ScienceWorld environment. Your primary function is to interpret the instruction and generate a clear, executable plan.
+
+## 1. Parse the Task
+Read the user's instruction carefully. Extract the following core components:
+* **Primary Objective:** What is the ultimate goal? (e.g., "find", "compare", "manipulate").
+* **Target Object/Subject:** What is the main focus of the task? (e.g., "animal with the shortest life span").
+* **Specified Location:** Is a location explicitly mentioned? (e.g., "animals are in the 'outside' location").
+
+## 2. Formulate the Plan
+Based on the parsed components, construct a plan. The standard plan structure is:
+1. **Navigate:** If a target location is specified and you are not there, teleport to it immediately.
+2. **Observe:** Upon arriving at the correct location, use `look around` to survey the environment and identify relevant objects.
+3. **Analyze & Execute:** Apply domain knowledge or comparative reasoning to the observed objects to fulfill the primary objective. Then, take the final required action (e.g., `focus on [OBJECT]`, `pick up [OBJECT]`).
+
+## 3. Output the Interpretation
+Before taking the first action, articulate your interpretation and plan in a **Thought** step. This confirms the skill has correctly parsed the task.
+**Output Format:**
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-task-interpreter/references/action_glossary.md b/skills/benchmark_skills/scienceworld/scienceworld-task-interpreter/references/action_glossary.md
new file mode 100644
index 0000000..a2af4c7
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-task-interpreter/references/action_glossary.md
@@ -0,0 +1,17 @@
+# ScienceWorld Action Glossary
+This is a quick reference for common actions used in task execution. Use `look around` and `teleport to LOC` as the primary tools for the navigation and observation phases of this skill.
+
+## Core Navigation & Observation
+* `teleport to LOC`: Instantly move to a named room/location. Use this first if a target location is specified.
+* `look around`: Describes the current room and lists all visible objects, agents, and doors. Use this immediately after arriving at the target location.
+
+## Object Interaction (Use as needed for final step)
+* `examine OBJ`: Get a detailed description of a specific object.
+* `look at OBJ`: List the contents inside a container object.
+* `focus on OBJ`: Signal intent or select a specific object as the task target.
+* `pick up OBJ`: Move an object into your inventory.
+* `use OBJ [on OBJ]`: Operate a device or apply an item.
+
+## Environment Notes
+* **Containers are open:** You can directly `look at` or `take from` containers without needing to `open` them first.
+* **Rooms:** kitchen, foundry, workshop, bathroom, outside, living room, bedroom, greenhouse, art studio, hallway.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-task-parser/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-task-parser/SKILL.md
new file mode 100644
index 0000000..e06b71e
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-task-parser/SKILL.md
@@ -0,0 +1,37 @@
+---
+name: scienceworld-task-parser
+description: Analyzes user instructions in ScienceWorld environments to extract specific task requirements and constraints. Use this skill when receiving a new task to identify required objects, target locations, and action sequences.
+---
+# Instructions for ScienceWorld Task Parsing
+
+When you receive a new task instruction in a ScienceWorld environment, follow this process to parse it into a structured plan.
+
+## 1. Parse the Instruction
+Immediately analyze the user's natural language instruction. Extract the following core components:
+* **Target Object Type:** Identify the category or description of the object to be manipulated (e.g., 'non-living thing', 'liquid', 'electrical component').
+* **Target Location:** Identify the final destination for the object, including the room and specific container (e.g., 'purple box in the workshop').
+* **Required Actions:** Infer the sequence of actions implied by verbs like "find", "focus on", "move", "pour", "mix", etc.
+
+**Output your analysis as a concise thought.** Example: "Task requires finding a non-living object in the workshop and moving it to the purple box."
+
+## 2. Survey the Environment
+* Use `look around` in your current room to get an inventory of visible objects, containers, and their states.
+* If the target location is a different room, use `teleport to LOC` to go there first, then `look around`.
+
+## 3. Identify the Target Object
+* From the room description, identify objects matching the parsed **Target Object Type**.
+* If multiple candidates exist, select one that is clearly non-living, portable, and not part of a fixed apparatus (e.g., a wire, a light bulb, a battery). Avoid substances like 'air'.
+* Use `examine OBJ` or `look at OBJ` if you need more detail to confirm an object's properties.
+
+## 4. Execute the Task Sequence
+1. **Signal Intent:** Use `focus on OBJ` on the identified target object. This explicitly marks the object for the task.
+2. **Perform Core Action:** Execute the primary action from the parsed instruction (e.g., `move OBJ to OBJ`, `pour OBJ into OBJ`).
+3. Use `wait` or `wait1` only if necessary to allow for state changes.
+
+## Key Principles
+* **Efficiency:** All containers are pre-opened. Do not use `open` or `close` unless explicitly required.
+* **Directness:** Teleport directly to the target room. Do not explore unrelated rooms.
+* **Clarity:** Structure your internal reasoning using the "Thought:" prefix before each action, as shown in the trajectory.
+* **Verification:** If an initial `look around` is insufficient, a second `look around` is acceptable to confirm the environment state before proceeding.
+
+For detailed examples and common task patterns, consult the reference documentation.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-task-parser/references/task_patterns.md b/skills/benchmark_skills/scienceworld/scienceworld-task-parser/references/task_patterns.md
new file mode 100644
index 0000000..aa211e4
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-task-parser/references/task_patterns.md
@@ -0,0 +1,53 @@
+# Common ScienceWorld Task Patterns
+
+This reference catalogs frequent instruction patterns and their corresponding parsing logic.
+
+## Pattern 1: Find and Move
+* **Instruction Template:** "Find a(n) [OBJECT_TYPE]. First, focus on the thing. Then, move it to the [CONTAINER] in the [ROOM]."
+* **Parsed Components:**
+ * Target Object Type: `[OBJECT_TYPE]` (e.g., non-living thing, red wire, light bulb)
+ * Target Location: `[CONTAINER]` in `[ROOM]`
+ * Action Sequence: `find` -> `focus on` -> `move to`
+* **Execution Flow:**
+ 1. Teleport to `[ROOM]`.
+ 2. `look around`.
+ 3. Identify an object matching `[OBJECT_TYPE]`.
+ 4. `focus on [OBJECT]`.
+ 5. `move [OBJECT] to [CONTAINER]`.
+
+## Pattern 2: Activate/Use Device
+* **Instruction Template:** "Turn on/activate/use the [DEVICE]."
+* **Parsed Components:**
+ * Target Object: `[DEVICE]`
+ * Action: `activate` or `use`
+* **Execution Flow:**
+ 1. Locate the `[DEVICE]` (may require room change).
+ 2. `activate [DEVICE]` or `use [DEVICE]`.
+
+## Pattern 3: Create Mixture
+* **Instruction Template:** "Mix [SUBSTANCE_A] and [SUBSTANCE_B] in the [CONTAINER]."
+* **Parsed Components:**
+ * Target Objects: `[SUBSTANCE_A]`, `[SUBSTANCE_B]`
+ * Target Location: `[CONTAINER]`
+ * Action: `pour` -> `mix`
+* **Execution Flow:**
+ 1. Locate substances and container.
+ 2. `pour [SUBSTANCE_A] into [CONTAINER]`.
+ 3. `pour [SUBSTANCE_B] into [CONTAINER]`.
+ 4. `mix [CONTAINER]`.
+
+## Object Classification Guide
+Use this to disambiguate the **Target Object Type**:
+* **Non-living thing:** Any man-made object (wire, bulb, battery, tool, box). Not substances (air, water).
+* **Electrical component:** battery, wire, switch, light bulb.
+* **Container:** box, freezer, beaker, vial.
+* **Substance:** air, water, chemical solutions (often in containers).
+
+## Action Mapping
+* `find` -> `look around` / `examine`
+* `focus on` -> `focus on`
+* `move` -> `move OBJ to OBJ`
+* `turn on/off` -> `activate` / `deactivate`
+* `connect` -> `connect OBJ to OBJ`
+* `pour` -> `pour OBJ into OBJ`
+* `mix` -> `mix OBJ`
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-temperature-measurer/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-temperature-measurer/SKILL.md
new file mode 100644
index 0000000..9e691c5
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-temperature-measurer/SKILL.md
@@ -0,0 +1,33 @@
+---
+name: scienceworld-temperature-measurer
+description: This skill uses a thermometer on a substance to measure its temperature. It should be triggered when the agent needs to determine the temperature of a material (e.g., lead) to assess if it has reached a specific melting point or threshold. The skill requires a thermometer in inventory and a target substance, outputting the measured temperature in degrees Celsius, which is key for scientific measurement tasks.
+---
+# Skill: Temperature Measurement for Scientific Experiments
+
+## Purpose
+Measure the temperature of a target substance (e.g., a metal like lead) to determine if it has reached a specific state-change threshold, such as its melting point.
+
+## Core Workflow
+1. **Acquire Thermometer:** Ensure a thermometer is in your inventory. If not, locate and pick one up.
+2. **Locate Target Substance:** Identify the substance to be measured (e.g., "lead"). It may be in a container.
+3. **Prepare for Heating (If Necessary):** If measuring a melting point, the substance likely needs to be heated.
+ * Transfer the substance to a heat-resistant container (e.g., a metal pot).
+ * Move the container to a heating device (e.g., a blast furnace in the foundry).
+ * Activate the heating device.
+4. **Measure Temperature:** Use the thermometer from your inventory on the target substance.
+5. **Interpret Result:** The observation will state the measured temperature in degrees Celsius. Use this value to make a decision (e.g., "above 150.0 degrees" -> focus on the red box).
+
+## Key Actions & Observations
+* `pick up thermometer`: Acquire the essential measuring tool.
+* `move [substance] to [container]`: Prepare the sample.
+* `activate [heating device]`: Initiate the temperature change process.
+* `use thermometer in inventory on [substance]`: The primary measurement command. The observation (`the thermometer measures a temperature of X degrees celsius`) is the skill's key output.
+* Observe state changes: `a substance called lead` -> `a substance called liquid lead`.
+
+## Bundled Logic
+For a standard melting point determination task, use the bundled script `measure_melting_point.py`. It encapsulates the precise sequence for the lead experiment demonstrated in the trajectory.
+
+## Notes
+* The skill assumes containers are open and accessible.
+* Teleportation (`teleport to [room]`) is often necessary to move between resource locations (e.g., kitchen, foundry).
+* If `use thermometer` fails, check the substance's state via `look at [container]` and ensure the thermometer is in your inventory.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-temperature-measurer/references/action_guide.md b/skills/benchmark_skills/scienceworld/scienceworld-temperature-measurer/references/action_guide.md
new file mode 100644
index 0000000..9465656
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-temperature-measurer/references/action_guide.md
@@ -0,0 +1,36 @@
+# Action Guide for ScienceWorld Temperature Measurement
+
+## Essential Actions
+| Action | Purpose | Example | Expected Observation Key Phrase |
+| :--- | :--- | :--- | :--- |
+| `pick up OBJ` | Acquire a tool or sample. | `pick up thermometer` | `You move the thermometer to the inventory.` |
+| `move OBJ to OBJ` | Transfer a substance or item. | `move lead to metal pot` | `You move the lead to the metal pot.` |
+| `activate OBJ` | Start a device. | `activate blast furnace` | `The blast furnace is now activated.` |
+| `use OBJ on OBJ` | Apply a tool to a target. | `use thermometer in inventory on lead` | `the thermometer measures a temperature of X degrees celsius` |
+| `teleport to LOC` | Instant movement between rooms. | `teleport to foundry` | `You teleport to the foundry.` |
+| `look at OBJ` | Inspect contents of a container/device. | `look at blast furnace` | `In the blast furnace is: a metal pot (containing...)` |
+| `focus on OBJ` | Signal intent or confirm target. | `focus on red box` | `You focus on the red box.` |
+
+## Critical Observations for State Tracking
+* **Substance State Change:** `a substance called lead` → `a substance called liquid lead`. This indicates melting has occurred.
+* **Temperature Reading:** The output of the `use thermometer` action is the numerical result. **Example:** `the thermometer measures a temperature of 450 degrees celsius`.
+* **Device Status:** `which is turned on` vs. `which is turned off`. Confirm heaters are active.
+
+## Common Pitfalls & Solutions
+1. **"No known action matches that input" when using thermometer.**
+ * **Cause:** The target substance name might have changed state (e.g., `lead` -> `liquid lead`) or is not directly accessible.
+ * **Solution:** Use `look at [container]` to check the exact name of the substance inside, then use that name (e.g., `use thermometer ... on liquid lead`).
+
+2. **Substance not heating.**
+ * **Cause:** The heating device may not be active, or the sample is not inside it.
+ * **Solution:** Verify with `look at [heating device]`. Ensure `activate [device]` was successful and the container is inside.
+
+3. **Cannot find the thermometer or substance.**
+ * **Cause:** Not in the correct room.
+ * **Solution:** Use `look around` to survey the current room. Use `teleport` to move to likely rooms (e.g., `kitchen` for tools, `foundry` for heaters).
+
+## Workflow Triggers
+Use this skill when the goal involves:
+* "measure the temperature of [substance]"
+* "find the melting point of [metal]"
+* "check if [material] is above/below [number] degrees"
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-threshold-evaluator/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-threshold-evaluator/SKILL.md
new file mode 100644
index 0000000..b3e548d
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-threshold-evaluator/SKILL.md
@@ -0,0 +1,26 @@
+---
+name: scienceworld-threshold-evaluator
+description: This skill compares a measured numerical value (e.g., temperature, weight) against a predefined threshold to determine a binary outcome. It should be triggered immediately after obtaining a measurement that has an associated conditional instruction. The skill evaluates if the value is above/below the threshold to guide the next action.
+---
+# Threshold Evaluation Skill
+
+## When to Use
+Trigger this skill **immediately** after you obtain a numerical measurement (e.g., temperature reading) and you have a conditional instruction that depends on that measurement (e.g., "If value > X, do A; if value < X, do B").
+
+## Core Logic
+1. **Extract the Measurement:** Identify the numerical value from the observation (e.g., "the thermometer measures a temperature of 56 degrees celsius" -> `56`).
+2. **Identify the Threshold & Condition:** Parse the user's instruction to find the threshold value and the comparison operator (e.g., "above 50.0 degrees" -> `threshold=50.0`, `operator=">"`).
+3. **Evaluate:** Perform the comparison (`measured_value > threshold` or `measured_value < threshold`).
+4. **Execute Branch:** Based on the boolean result, perform the corresponding action specified in the instruction.
+
+## Key Principles
+* **Immediate Execution:** Do not perform any other actions between obtaining the measurement and running this evaluation.
+* **Precision:** Use the exact numerical value from the observation. Do not estimate or round unless specified.
+* **Binary Decision:** The outcome is strictly one of two paths. If the measurement equals the threshold, re-examine the instruction for guidance (e.g., "above" typically means `>`, not `>=`).
+
+## Common Pitfalls (from Trajectory)
+* **Incorrect Branching:** Do not execute the branch for the opposite condition (e.g., focusing on the blue box when the value is above the threshold).
+* **Premature Evaluation:** Ensure the measurement is complete and valid before evaluating.
+* **Action Confusion:** The final action (e.g., `focus on OBJ`) must target the correct object specified for the satisfied condition.
+
+For detailed examples and the evaluation script, see the reference documentation.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-threshold-evaluator/references/action_guide.md b/skills/benchmark_skills/scienceworld/scienceworld-threshold-evaluator/references/action_guide.md
new file mode 100644
index 0000000..59c45f6
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-threshold-evaluator/references/action_guide.md
@@ -0,0 +1,69 @@
+# Action Execution Guide
+
+## After Evaluation: What to Do Next
+
+Once the threshold evaluation is complete, you must execute the appropriate action based on the result.
+
+### 1. Identify the Target Action
+
+From the original instruction, identify the two possible actions:
+- **Action A**: What to do if the condition is `True` (value above/below threshold)
+- **Action B**: What to do if the condition is `False` (value not above/below threshold)
+
+**Example from trajectory:**
+- If temperature > 50.0: `focus on green box`
+- If temperature < 50.0: `focus on blue box`
+
+### 2. Construct the Action Command
+
+Use the standard action format from the environment:
+- `focus on OBJ`
+- `use OBJ`
+- `activate OBJ`
+- `move OBJ to OBJ`
+- etc.
+
+**Important:** Use the exact object names as they appear in the environment observations.
+
+### 3. Execute Immediately
+
+Do not insert intermediate steps between evaluation and action execution.
+
+### 4. Verification (Optional)
+
+After executing the action, you may want to:
+- Confirm the action was successful (check observation)
+- Ensure you're now on the correct branch of the task
+
+## Common Action Patterns
+
+| Condition Type | Typical Actions |
+|----------------|-----------------|
+| **Temperature** | `focus on [object]`, `activate/deactivate [heater/cooler]`, `move [sample] to [location]` |
+| **Weight/Mass** | `use [container]`, `move [sample] to [scale]`, `pour [substance] into [vessel]` |
+| **pH/Concentration** | `add [reagent]`, `mix [solution]`, `focus on [indicator]` |
+| **Time/Duration** | `activate/deactivate [timer]`, `wait`, `focus on [clock]` |
+
+## Error Recovery
+
+If the evaluation leads to an impossible action:
+1. **Re-check the measurement** - Did you extract the correct value?
+2. **Re-parse the condition** - Did you identify the correct threshold and operator?
+3. **Verify object existence** - Is the target object present in the current room?
+4. **Consult trajectory** - Look for similar patterns in successful executions.
+
+## Example: Complete Execution Flow
+
+**Initial State:**
+- Instruction: "If voltage > 12V, connect to red terminal. If voltage < 12V, connect to black terminal."
+- Observation: "multimeter reads 14.5 volts"
+
+**Skill Execution:**
+1. Extract measurement: `14.5`
+2. Parse condition: threshold=`12.0`, operator=`>`
+3. Evaluate: `14.5 > 12.0` = `True`
+4. Identify action: `connect to red terminal`
+5. Construct command: `connect multimeter to red terminal`
+6. Execute: `connect multimeter to red terminal`
+
+**Result:** The correct branch is executed based on the measured value.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-threshold-evaluator/references/usage_examples.md b/skills/benchmark_skills/scienceworld/scienceworld-threshold-evaluator/references/usage_examples.md
new file mode 100644
index 0000000..abebc44
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-threshold-evaluator/references/usage_examples.md
@@ -0,0 +1,80 @@
+# Threshold Evaluator - Usage Examples
+
+## Example 1: Temperature Measurement (from Trajectory)
+
+**Instruction:**
+> "If the melting point of chocolate is above 50.0 degrees, focus on the green box. If the melting point of chocolate is below 50.0 degrees, focus on the blue box."
+
+**Observation:**
+> "the thermometer measures a temperature of 56 degrees celsius"
+
+**Skill Execution:**
+1. **Extract Measurement:** `56.0`
+2. **Parse Condition:**
+ - Threshold: `50.0`
+ - Operator: `>` (from "above 50.0 degrees")
+ - Action if True: focus on green box
+ - Action if False: focus on blue box
+3. **Evaluate:** `56.0 > 50.0` = `True`
+4. **Execute Branch:** `focus on green box`
+
+**Common Mistake to Avoid:**
+- Incorrect: Executing `focus on blue box` when value is above threshold.
+
+## Example 2: Weight Comparison
+
+**Instruction:**
+> "If the sample weighs less than 100 grams, use the small container. If it weighs more than 100 grams, use the large container."
+
+**Observation:**
+> "The scale reads 87.5 grams"
+
+**Skill Execution:**
+1. **Extract Measurement:** `87.5`
+2. **Parse Condition:**
+ - Threshold: `100.0`
+ - Operator: `<` (from "less than 100 grams")
+ - Action if True: use small container
+ - Action if False: use large container
+3. **Evaluate:** `87.5 < 100.0` = `True`
+4. **Execute Branch:** `use small container`
+
+## Example 3: pH Level Check
+
+**Instruction:**
+> "When the pH drops below 7.0, add the alkaline solution."
+
+**Observation:**
+> "pH meter shows 6.8"
+
+**Skill Execution:**
+1. **Extract Measurement:** `6.8`
+2. **Parse Condition:**
+ - Threshold: `7.0`
+ - Operator: `<` (from "below 7.0")
+ - Action if True: add alkaline solution
+ - Action if False: (none specified - continue monitoring)
+3. **Evaluate:** `6.8 < 7.0` = `True`
+4. **Execute Branch:** `add alkaline solution`
+
+## Edge Cases & Notes
+
+1. **Exact Threshold Match:**
+ - Instruction: "above 50 degrees" means `measurement > 50`, not `>= 50`.
+ - If measurement equals exactly 50.0, the condition is `False`.
+ - Always follow the precise wording of the instruction.
+
+2. **Multiple Measurements:**
+ - If taking multiple readings (e.g., monitoring temperature rise), evaluate after each measurement.
+ - The skill should be triggered for each new measurement observation.
+
+3. **Implicit Thresholds:**
+ - Sometimes the threshold is implied: "If it's too hot (>40°C), turn off the heater."
+ - Extract the numerical boundary from context.
+
+4. **Unit Consistency:**
+ - Ensure the measurement and threshold are in the same units.
+ - The extraction function handles unit-agnostic number parsing.
+
+## Integration Pattern
+
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-tool-fetcher/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-tool-fetcher/SKILL.md
new file mode 100644
index 0000000..2d0475d
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-tool-fetcher/SKILL.md
@@ -0,0 +1,35 @@
+---
+name: scienceworld-tool-fetcher
+description: This skill locates and picks up a specified tool or instrument from the environment. It should be triggered when a task requires a specific tool (e.g., thermometer, stopwatch) for measurement or manipulation. The skill identifies the tool's location via observation and executes a pick-up action, moving the tool to inventory.
+---
+# Instructions
+
+**Primary Goal:** Locate a specified tool and move it to your inventory.
+
+## 1. Identify the Target Tool
+* The required tool will be specified in the user's task or request (e.g., "thermometer", "stopwatch", "lighter").
+* Confirm the exact name of the tool object.
+
+## 2. Locate the Tool via Exploration
+* If you are not in the correct room, use `teleport to [ROOM_NAME]` to go to the most likely location (e.g., `kitchen`, `workshop`).
+* Use `look around` to survey the current room.
+* Scan the observation for the target tool name. It may be:
+ * Listed directly in the room description (e.g., "a thermometer").
+ * Inside an open container (e.g., "a fridge. In the fridge is: chocolate, a wood cup...").
+* If the tool is not immediately visible, examine likely containers using `look at [CONTAINER]` (e.g., `look at counter`, `look at cupboard`).
+
+## 3. Execute the Pick-up
+* Once the tool is located, execute the action: `pick up [TOOL_NAME]`.
+* Example: `pick up thermometer`.
+* Verify the action was successful by checking the observation for confirmation (e.g., "You move the thermometer to the inventory.").
+
+## 4. Post-Action Verification (Optional)
+* If required by the broader task, you may perform a secondary action to signal readiness, such as `focus on [TOOL_NAME] in inventory`.
+
+## Key Constraints & Notes
+* **Containers are Open:** All containers are pre-opened. Do not use `open` or `close` actions.
+* **Direct Action:** Proceed directly to `pick up`. Do not attempt to move the tool to an intermediate location first.
+* **Tool Not Found:** If the tool is not in the initial room, systematically `teleport` to other relevant rooms and repeat the `look around` search pattern.
+* **Single Tool:** This skill fetches one specified tool. For multiple tools, trigger the skill sequentially.
+
+**Output:** The target tool will be in your inventory, ready for use in subsequent task steps.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-tool-fetcher/references/environment_actions.md b/skills/benchmark_skills/scienceworld/scienceworld-tool-fetcher/references/environment_actions.md
new file mode 100644
index 0000000..5bef4ae
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-tool-fetcher/references/environment_actions.md
@@ -0,0 +1,24 @@
+# ScienceWorld Environment: Action Reference
+
+## Core Actions for Tool Fetching
+| Action | Format | Purpose | Notes for Tool Fetcher |
+|--------|--------|---------|------------------------|
+| `teleport to` | `teleport to LOC` | Move instantly to another room. | Use to navigate to likely tool locations (e.g., `kitchen`, `workshop`). |
+| `look around` | `look around` | Get a full description of the current room and visible objects. | **Primary search action.** Use first in a new room. |
+| `look at` | `look at OBJ` | Inspect a container to see its contents. | Use if `look around` mentions a container (e.g., `fridge`, `cupboard`) that might hold the tool. |
+| `pick up` | `pick up OBJ` | Move a portable object to your inventory. | **Final action.** Use when the tool is directly visible or confirmed inside an open container. |
+
+## Important Environment Assumptions
+1. **Open Containers:** All doors, lids, and drawers are already open. The `open` and `close` actions are **not needed** for this skill.
+2. **Inventory System:** Successful `pick up` moves the object to an implicit inventory. You do not need to manage inventory slots.
+3. **Object Names:** Use the exact name as it appears in observations (e.g., "thermometer", not "the thermometer").
+4. **Room Connectivity:** You can `teleport` directly to any named room.
+
+## Common Tool Locations
+* **Thermometer, Stopwatch, Lighter:** Often found in the `kitchen` or `workshop`.
+* **Specialized Instruments:** Check `workshop`, `art studio`, or `greenhouse`.
+* **Containers to Check:** `fridge`, `cupboard`, `counter`, `drawer`, `shelf`.
+
+## Error Handling Notes
+* If `pick up` fails (e.g., "You can't pick that up"), the object may be fixed or too large. Report this failure.
+* If the tool is not found after searching likely rooms, inform the user.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-tool-fetcher/references/trajectory_analysis.md b/skills/benchmark_skills/scienceworld/scienceworld-tool-fetcher/references/trajectory_analysis.md
new file mode 100644
index 0000000..caa9b5a
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-tool-fetcher/references/trajectory_analysis.md
@@ -0,0 +1,31 @@
+# Skill Derivation: Trajectory Analysis
+
+## Source Trajectory Summary
+**Task:** Measure the melting point of chocolate.
+**Key Tool-Fetching Segment:**
+1. Agent is in the `living room`. Uses `look around`.
+2. Not finding the tool, uses `teleport to kitchen`.
+3. In the `kitchen`, uses `look around`.
+4. Observation lists "a thermometer" directly in the room.
+5. Agent executes `pick up thermometer` successfully.
+
+## Extracted Skill Logic
+The trajectory demonstrates the core pattern for this skill:
+1. **Identify Need:** Task requires a "thermometer".
+2. **Navigate:** Teleport to probable location (`kitchen`).
+3. **Search:** Use `look around` to scan the room.
+4. **Locate:** Identify tool in observation list.
+5. **Acquire:** Execute `pick up [tool]`.
+
+## Why This is a Separate Skill
+* **Reusable Pattern:** The sequence (teleport→look→pick up) is generic for fetching any specified tool.
+* **Fragile Core:** The exact match of the tool name in the observation and the `pick up` syntax is error-prone, suitable for scripting.
+* **Context Isolation:** The skill doesn't need to know about the broader experiment (melting chocolate), only about finding the tool.
+
+## Excluded from Skill
+* Actions after tool acquisition (e.g., `focus on thermometer`, `use thermometer`).
+* Heating the chocolate or interpreting measurements.
+* Interacting with secondary objects (green/blue boxes).
+
+## Design Validation
+The skill package isolates the tool-fetching subroutine, allowing it to be invoked whenever a task says "you need a [tool]". The main `SKILL.md` provides high-level guidance, while the script handles the deterministic search logic.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-tool-user/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-tool-user/SKILL.md
new file mode 100644
index 0000000..012bc25
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-tool-user/SKILL.md
@@ -0,0 +1,14 @@
+---
+name: scienceworld-tool-user
+description: Uses a tool from inventory on a target object or location to perform a specific environmental interaction, such as digging or cutting. Activate this skill when a task requires modifying the environment or manipulating materials, like using a shovel to dig soil. It takes the tool and target as inputs and outputs the result of the interaction, enabling physical task progression.
+---
+# Instructions
+
+Use this skill when you need to perform a physical action on the environment using a tool you possess. The core action is `use TOOL on TARGET`.
+
+## 1. Prerequisites
+* **Tool in Inventory:** Ensure the required tool (e.g., `shovel`, `axe`) is in your inventory. Use `pick up OBJ` if it is not.
+* **Clear Target:** Identify the exact target object or location name (e.g., `ground`, `tree`).
+
+## 2. Core Action
+Execute the interaction with the command:
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-tool-user/references/example_trajectory.md b/skills/benchmark_skills/scienceworld/scienceworld-tool-user/references/example_trajectory.md
new file mode 100644
index 0000000..c2c58d1
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-tool-user/references/example_trajectory.md
@@ -0,0 +1,17 @@
+# Skill Application Example: Growing an Avocado Plant
+
+This document illustrates how the `scienceworld-tool-user` skill was applied in a specific trajectory to progress a task.
+
+## Scenario: Digging Soil with a Shovel
+**Goal:** Obtain soil for planting an avocado seed.
+**Prerequisites Met:**
+1. Tool (`shovel`) was acquired via `pick up shovel` in the greenhouse.
+2. Target (`ground`) was identified in the `outside` location.
+
+**Skill Execution:**
+* **Action:** `use shovel on ground`
+* **System Feedback:** "You dig a hole in the ground, and place the soil nearby."
+* **Post-Action:** The agent then used `pick up soil` to collect the result.
+
+## Outcome
+The successful use of the tool transformed the environment, creating a new resource (`soil`) that was essential for the next step (planting the seed in a flower pot). This demonstrates the skill's role in enabling physical task progression.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-tool-validator/SKILL.md b/skills/benchmark_skills/scienceworld/scienceworld-tool-validator/SKILL.md
new file mode 100644
index 0000000..c21233f
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-tool-validator/SKILL.md
@@ -0,0 +1,26 @@
+---
+name: scienceworld-tool-validator
+description: This skill performs a basic functionality check on a tool in the agent's inventory. It should be triggered after acquiring a tool and before its first use in a critical task step to ensure it is operational. The skill typically uses a 'focus' or 'examine' action on the tool and confirms its readiness state.
+---
+# Tool Validation Protocol
+
+## Purpose
+Execute a pre-use functionality check on a tool or instrument to confirm it is operational before employing it in a critical task step.
+
+## Core Workflow
+1. **Acquire Tool:** Ensure the target tool is in your inventory. If not, retrieve it from the environment.
+2. **Execute Validation:** Use the `focus on [TOOL]` action on the tool in your inventory. This is the standard validation action.
+3. **Confirm Readiness:** Observe the system's response. A successful focus action (e.g., "You focus on the [tool].") confirms the tool is ready for use. No further diagnostic steps are required unless an error is observed.
+
+## Key Principles
+* **Timing:** Perform this check immediately after acquiring a tool and *before* its first application in a task-sensitive operation (e.g., measuring, activating, connecting).
+* **Simplicity:** The `focus` action is the primary, lightweight validation method. Avoid unnecessary `examine` or `use` actions during the check.
+* **State Awareness:** The skill assumes the environment's containers are open and items are accessible. Teleportation is available for efficient navigation.
+
+## Example Application
+* **Scenario:** You need to measure the temperature of a substance.
+* **Application:**
+ 1. Locate and `pick up thermometer`.
+ 2. **Trigger Skill:** `focus on thermometer in inventory`.
+ 3. **Confirmation:** Observe "You focus on the thermometer." The tool is now validated for use.
+ 4. Proceed with `use thermometer on [SUBSTANCE]`.
diff --git a/skills/benchmark_skills/scienceworld/scienceworld-tool-validator/references/action_primer.md b/skills/benchmark_skills/scienceworld/scienceworld-tool-validator/references/action_primer.md
new file mode 100644
index 0000000..19ca294
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/scienceworld-tool-validator/references/action_primer.md
@@ -0,0 +1,15 @@
+# Action Primer for ScienceWorld
+
+## Core Validation & Inspection Actions
+* `focus on OBJ`: The primary action for signaling intent and performing a basic operational check on a tool. Use this for validation.
+* `examine OBJ`: Provides a detailed description of an object's properties. Use for in-depth inspection *after* validation if needed.
+* `look at OBJ`: Describes a container's contents. Not typically used for tool validation.
+
+## Common Tool Contexts
+Tools often appear in standard locations:
+* **Kitchen:** `thermometer`, `stopwatch`, `lighter` on counters or tables.
+* **Workshop/Foundry:** More specialized instruments.
+* **Containers:** `fridge`, `cupboard`, `drawer`. Assume they are open.
+
+## Navigation Note
+Use `teleport to LOC` to move efficiently between rooms when searching for a tool.
diff --git a/skills/benchmark_skills/scienceworld/soil-extraction/SKILL.md b/skills/benchmark_skills/scienceworld/soil-extraction/SKILL.md
new file mode 100644
index 0000000..a4ab189
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/soil-extraction/SKILL.md
@@ -0,0 +1,28 @@
+---
+name: soil-extraction
+description: Uses a shovel tool to dig soil from the ground in outdoor environments. Execute this skill when you need to obtain soil for planting tasks and have both the shovel in inventory and access to an appropriate digging location. The skill produces soil that can then be collected and transported.
+---
+# Skill: Soil Extraction
+
+## Purpose
+This skill enables the agent to extract soil from the ground using a shovel. It is a foundational step for planting tasks, transforming a bare outdoor location into a source of usable soil.
+
+## Prerequisites
+1. **Tool in Inventory:** You must possess a `shovel` in your inventory.
+2. **Location:** You must be in an outdoor environment (e.g., `outside`) where digging is permissible.
+3. **Ground Access:** The ground must be accessible and diggable.
+
+## Core Procedure
+1. **Navigate:** Ensure you are in the target outdoor location (e.g., `teleport to outside`).
+2. **Execute Dig:** Use the command `use shovel in inventory on ground`.
+3. **Collect Output:** The action will produce `soil` placed nearby. Use `pick up soil` to add it to your inventory.
+
+## Key Notes
+* **Deterministic Action:** The `use shovel in inventory on ground` command is a reliable, single-step method for soil extraction as demonstrated in the trajectory.
+* **Output Management:** The extracted soil is a separate object that must be explicitly picked up. It does not automatically enter your inventory.
+* **Skill Chaining:** This skill is typically followed by `teleport` to transport the soil and `move` to deposit it into a target container (e.g., a flower pot).
+
+## Error Handling & Ambiguity
+* If the `use` command is ambiguous, select the action that clearly involves your inventory shovel and the ground.
+* If no soil appears after digging, verify your location and that the shovel is correctly in your inventory.
+* This skill does not handle soil preparation (e.g., mixing with water) or planting. It is strictly for extraction.
diff --git a/skills/benchmark_skills/scienceworld/soil-extraction/references/trajectory_excerpt.md b/skills/benchmark_skills/scienceworld/soil-extraction/references/trajectory_excerpt.md
new file mode 100644
index 0000000..9e88918
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/soil-extraction/references/trajectory_excerpt.md
@@ -0,0 +1,26 @@
+# Relevant Trajectory Excerpts for Soil Extraction
+
+The following actions from the provided trajectory demonstrate the core, repeatable pattern of the soil-extraction skill.
+
+## Pattern: Dig -> Collect
+This sequence was successfully executed three times to obtain soil for three flower pots.
+
+1. **First Extraction:**
+ * Action: `use shovel in inventory on ground`
+ * Observation: `You dig a hole in the ground, and place the soil nearby.`
+ * Follow-up: `pick up soil`
+
+2. **Second Extraction:**
+ * Action: `use shovel in inventory on ground`
+ * Observation: `You dig a hole in the ground, and place the soil nearby.`
+ * Follow-up: `pick up soil`
+
+3. **Third Extraction:**
+ * Action: `use shovel in inventory on ground`
+ * Observation: `You dig a hole in the ground, and place the soil nearby.`
+ * Follow-up: `pick up soil`
+
+## Key Environmental Context
+* **Location:** All extractions were performed in the `outside` room.
+* **Tool State:** The `shovel` was in the agent's inventory prior to each `use` command.
+* **Result Consistency:** Each `use` command reliably produced `soil` as a distinct, collectible object.
diff --git a/skills/benchmark_skills/scienceworld/task-completion-focus/SKILL.md b/skills/benchmark_skills/scienceworld/task-completion-focus/SKILL.md
new file mode 100644
index 0000000..ff6304c
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/task-completion-focus/SKILL.md
@@ -0,0 +1,29 @@
+---
+name: task-completion-focus
+description: Focuses on a specific target object to signal task completion. Execute this skill when you have produced the required final object (like a grown banana) and need to formally complete the assigned task. This handles the 'focus on OBJ' action that typically marks successful task execution in the environment.
+---
+# Skill: Task Completion Focus
+
+## Purpose
+This skill is the final step in a task execution chain. It is triggered **only** when the primary objective of a task has been successfully achieved and the target object is present and observable in the environment. Its sole function is to execute the `focus on OBJ` action on the correct object, which formally signals task completion to the environment.
+
+## When to Use
+* **Prerequisite:** The final, required object (e.g., a grown banana, a crafted item, a repaired device) must be visibly present in the environment.
+* **Trigger:** You have verified the object's presence and your goal is to complete the task.
+* **Do Not Use** for intermediate steps, exploration, or object manipulation.
+
+## Execution Protocol
+
+1. **Verification:** Before execution, confirm the target object is in the scene. Use `look around` or `examine` if necessary.
+2. **Action Execution:** Perform the `focus on <OBJECT>` action.
+3. **Ambiguity Resolution:** The environment may present multiple valid targets (e.g., bananas on different trees). If an "Ambiguous request" observation is received, you **must** select the correct target by number.
+ * **Selection Rule:** Choose the target that is most directly associated with the main task goal. If multiple are identical, select the first option (e.g., `0`).
+
+## Example from Trajectory
+**Scenario:** Task was to "grow a banana". After successful cultivation, multiple bananas are visible.
+* **Observation:** "On the banana tree you see: a banana, a flower."
+* **Correct Action:** `focus on banana on banana tree`
+* **If Ambiguous:** Select option `0` (or the first instance of the target banana).
+
+## Key Principle
+This skill is a **low-freedom, terminal action**. Its logic is simple and deterministic. The creative and complex work (growing the plant, crafting the item) belongs to other skills. This skill exists solely to "press the final button."
diff --git a/skills/benchmark_skills/scienceworld/task-completion-focus/references/action_primer.md b/skills/benchmark_skills/scienceworld/task-completion-focus/references/action_primer.md
new file mode 100644
index 0000000..6cd6271
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/task-completion-focus/references/action_primer.md
@@ -0,0 +1,17 @@
+# Primer: The 'focus on' Action
+
+## Environmental Role
+The `focus on OBJ` action is a special meta-action within this simulation environment. It does not manipulate the object physically but signals to the task system that the agent has successfully interacted with or produced the object relevant to the assigned goal.
+
+## Semantics
+* **Completion Signal:** Its primary use is to mark a task as **complete**.
+* **Intent Declaration:** It can also be used to declare an intent to work on a specific object in multi-step tasks, though its most critical function is finalization.
+* **Non-Destructive:** The action does not consume, move, or alter the object.
+
+## Handling Ambiguity
+The environment often requires disambiguation when multiple instances of a target object exist. The standard pattern is:
+1. Agent sends: `focus on <OBJECT> on <CONTAINER>`
+2. Environment responds with an "Ambiguous request" and a numbered list.
+3. Agent must respond with a single number (e.g., `0`).
+
+**Best Practice:** When the goal is simple completion (e.g., "focus on the grown banana"), selecting the first valid option (`0`) is the correct and sufficient strategy, as demonstrated in the provided trajectory.
diff --git a/skills/benchmark_skills/scienceworld/task-completion-focus/references/trajectory_analysis.md b/skills/benchmark_skills/scienceworld/task-completion-focus/references/trajectory_analysis.md
new file mode 100644
index 0000000..9ac8e53
--- /dev/null
+++ b/skills/benchmark_skills/scienceworld/task-completion-focus/references/trajectory_analysis.md
@@ -0,0 +1,17 @@
+# Trajectory Analysis: Task Completion Focus
+
+## Source Context
+This skill is derived from the final segment of a "grow a banana" task trajectory.
+
+## Key Sequence
+1. **Prerequisite Achievement:** Multiple banana trees have reached the "reproducing stage" and are bearing fruit (`a banana`).
+2. **Verification:** Agent uses `look around` to confirm the presence of bananas.
+3. **Execution Attempt:** Agent issues `focus on banana on banana tree in the reproducing stage`.
+4. **Ambiguity:** Environment lists 4 possible banana targets across three flower pots.
+5. **Resolution:** Agent selects option `0`, corresponding to the banana in `flower pot 1`.
+
+## Derived Rules
+* The skill is invoked **after** the core productive task is done.
+* The target object must be explicitly visible in the scene description.
+* Ambiguity is resolved by selecting the **first matching option** (`0`), establishing a simple, deterministic rule for the completion step.
+* This action is the terminal point of the task workflow.
diff --git a/skills/benchmark_skills/toolathlon/ab-test-analyzer-with-cloud-action/SKILL.md b/skills/benchmark_skills/toolathlon/ab-test-analyzer-with-cloud-action/SKILL.md
new file mode 100644
index 0000000..30b74ca
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/ab-test-analyzer-with-cloud-action/SKILL.md
@@ -0,0 +1,63 @@
+---
+name: ab-test-analyzer-with-cloud-action
+description: When the user requests analysis of A/B test results from BigQuery data to determine a winner and execute cloud-based actions based on the outcome. This skill handles 1) Querying and analyzing clickstream data from BigQuery datasets, 2) Calculating conversion rates across multiple scenarios, 3) Determining the winner based on arithmetic mean of per-scenario rates, 4) Filling CSV reports with results, 5) Executing conditional cloud operations - creating Cloud Storage buckets when version B wins or writing log entries when version A wins or ties. Triggers include A/B test analysis, conversion rate comparison, BigQuery clickstream data, conditional cloud operations, CSV report generation.
+---
+# Instructions
+
+## 1. Understand the Task
+The user will provide a request to analyze concluded A/B test data. The raw clickstream data is stored in a BigQuery dataset named `ab_testing`. You must:
+- Analyze the data to determine which version ('A' or 'B') has the highest overall conversion rate.
+- The **overall conversion rate** is defined as the **arithmetic mean of the per-scenario conversion rates**.
+- Fill a CSV report file (`record.csv`) with the results.
+- Execute a conditional cloud action based on the winner:
+ - **If version B wins**: Create a new Cloud Storage bucket whose name is prefixed with `promo-assets-for-b`. Do NOT write any log entry.
+ - **If version A wins or it's a tie**: Write a log entry with the message `{'status': 'AB_Test_Concluded', 'winner': 'A', 'action': 'No_Change'}` to the existing log bucket whose name is prefixed with `abtesting_logging`. Do NOT create a bucket.
+- Ignore any log entries that existed in the log bucket before the task started.
+
+## 2. Core Workflow
+
+### Phase 1: Data Discovery & Inspection
+1. **Locate the Dataset**: Use `google-cloud-bigquery_get_dataset_info` to confirm the `ab_testing` dataset exists and note its project ID (e.g., `toolathlon-eval-ds`).
+2. **Inspect the CSV Template**: Read the provided `record.csv` file using `filesystem-read_file` to understand the required output schema (list of scenarios).
+3. **List Available Tables**: Query the dataset's `INFORMATION_SCHEMA.TABLES` to get all table names. Expect tables named like `ab_<Scenario>` (e.g., `ab_Appliances`, `ab_Automotive`).
+4. **Examine Table Structure**: Sample one table (e.g., `ab_Appliances`) to confirm it contains columns: `time_window`, `A_clicks`, `A_store_views`, `B_clicks`, `B_store_views`.
+
+### Phase 2: Data Aggregation & Calculation
+1. **Aggregate Data Per Scenario**: For each scenario table, run a query to sum `A_clicks`, `A_store_views`, `B_clicks`, and `B_store_views`.
+ - **Efficient Method**: Use the bundled script `scripts/aggregate_data.py`. It dynamically constructs and executes a single, efficient query.
+ - **Manual Method**: If the script fails, construct a UNION ALL query manually for all scenarios, similar to the trajectory.
+2. **Calculate Conversion Rates**: For each scenario row:
+ - `A_conversion %` = (`A_store_views` / `A_clicks`) * 100 (handle division by zero).
+ - `B_conversion %` = (`B_store_views` / `B_clicks`) * 100.
+ - Round results to 2 decimal places.
+3. **Calculate Overall Rates**:
+ - **Per-Scenario Mean (Primary Metric)**: Calculate the arithmetic mean (average) of all `A_conversion %` values and all `B_conversion %` values separately. This determines the winner.
+ - **Aggregate Rate (For CSV)**: Also calculate `total_A_store_views / total_A_clicks * 100` and `total_B_store_views / total_B_clicks * 100` for the "overall (total_store_views/total_clicks)" row in the CSV.
+
+### Phase 3: Reporting & Conditional Action
+1. **Populate the CSV**: Write the calculated `A_conversion %` and `B_conversion %` for each scenario, plus the aggregate rate row, to `record.csv`. Ensure the scenario order matches the original template.
+2. **Determine Winner**: Compare the arithmetic means from Step 2.3.
+ - `B_mean > A_mean`: **Version B wins**.
+ - `A_mean > B_mean` or `A_mean == B_mean`: **Version A wins or it's a tie**.
+3. **Execute Conditional Action**:
+ - **If B Wins**:
+ - Generate a unique bucket name starting with `promo-assets-for-b` (e.g., `promo-assets-for-b-full-promotion`).
+ - Use `google-cloud-storage_create_bucket` to create it in the `US` location.
+ - **Do not** write any log entry.
+ - **If A Wins or Tie**:
+ - Find the existing log bucket by listing buckets and identifying one with a name prefixed `abtesting_logging`.
+ - Create a log object inside it (e.g., `log_<timestamp>.txt`) containing the exact string: `{'status': 'AB_Test_Concluded', 'winner': 'A', 'action': 'No_Change'}`.
+ - **Do not** create a new storage bucket.
+
+## 3. Key Rules & Edge Cases
+- **Winner Criteria**: The decisive metric is the **arithmetic mean of per-scenario conversion rates**, not the aggregate `total_views/total_clicks` rate.
+- **Log Handling**: When writing a log, you must **not** read, parse, or consider any existing objects in the log bucket. Simply write the new log entry.
+- **Bucket Naming**: The new bucket name must **start with** `promo-assets-for-b`. Append a descriptive suffix (e.g., `-full-promotion`) to ensure uniqueness.
+- **Data Integrity**: Verify all 20 scenario tables are processed. The final CSV must have 21 rows (20 scenarios + 1 overall row).
+- **Error Handling**: If BigQuery queries fail, check table names and permissions. If the log bucket cannot be found when needed, inform the user.
+
+## 4. Final Verification
+Before claiming completion:
+1. Confirm `record.csv` is correctly formatted and saved.
+2. Verify the correct cloud action was taken (bucket created OR log entry written).
+3. Provide a brief summary to the user stating the winner (A/B/Tie), the calculated mean rates, and the action taken.
diff --git a/skills/benchmark_skills/toolathlon/ab-test-analyzer-with-cloud-action/references/schema_and_calculations.md b/skills/benchmark_skills/toolathlon/ab-test-analyzer-with-cloud-action/references/schema_and_calculations.md
new file mode 100644
index 0000000..5d0b026
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/ab-test-analyzer-with-cloud-action/references/schema_and_calculations.md
@@ -0,0 +1,50 @@
+# Data Schema & Calculation Reference
+
+## BigQuery Table Schema
+Each scenario table (e.g., `ab_Appliances`) in the `ab_testing` dataset has the following columns:
+- `time_window`: STRING - Time period for the metrics (e.g., "7/29 08:00-08:59")
+- `A_clicks`: INTEGER - Number of clicks on version A of the homepage.
+- `A_store_views`: INTEGER - Number of subsequent store views from version A clicks.
+- `B_clicks`: INTEGER - Number of clicks on version B of the homepage.
+- `B_store_views`: INTEGER - Number of subsequent store views from version B clicks.
+
+## Core Metrics & Formulas
+
+### 1. Per-Scenario Conversion Rate
+For a given scenario (e.g., Appliances):
+- **Version A Conversion %** = `(SUM(A_store_views) / SUM(A_clicks)) * 100`
+- **Version B Conversion %** = `(SUM(B_store_views) / SUM(B_clicks)) * 100`
+- **Handling Zero Clicks**: If `SUM(A_clicks)` or `SUM(B_clicks)` is 0, the conversion rate for that version is 0%.
+
+### 2. Overall Conversion Rate (Decision Metric)
+The **winner** is determined by comparing the **arithmetic mean (average)** of all per-scenario conversion rates.
+- Let `A_rates` = [A_conv_scenario1, A_conv_scenario2, ..., A_conv_scenario20]
+- Let `B_rates` = [B_conv_scenario1, B_conv_scenario2, ..., B_conv_scenario20]
+- `A_overall_mean` = `sum(A_rates) / 20`
+- `B_overall_mean` = `sum(B_rates) / 20`
+- **Winner**: The version with the higher `overall_mean`. If equal, it's a tie.
+
+### 3. Aggregate Conversion Rate (For Reporting)
+This is calculated for the final row in the CSV report:
+- `A_aggregate_rate` = `(SUM(all_A_store_views) / SUM(all_A_clicks)) * 100`
+- `B_aggregate_rate` = `(SUM(all_B_store_views) / SUM(all_B_clicks)) * 100`
+- **Note**: This is **not** used to determine the winner, only for reporting.
+
+## CSV Report Schema (`record.csv`)
+The output CSV must have the following columns:
+- `scenario`: The name of the product category/scenario.
+- `A_conversion %`: The calculated conversion percentage for Version A (rounded to 2 decimals).
+- `B_conversion %`: The calculated conversion percentage for Version B (rounded to 2 decimals).
+
+**Row Order**:
+1. 20 rows, one for each scenario, sorted alphabetically by scenario name.
+2. A final 21st row with:
+ - `scenario`: "overall (total_store_views/total_clicks)"
+ - `A_conversion %`: The `A_aggregate_rate`
+ - `B_conversion %`: The `B_aggregate_rate`
+
+## Conditional Action Logic
+| Condition | Action | Details |
+| :--- | :--- | :--- |
+| `B_overall_mean` > `A_overall_mean` | **Create Cloud Storage Bucket** | - Name must start with `promo-assets-for-b`.<br>- Choose a location (e.g., `US`).<br>- **Do not** write any log. |
+| `A_overall_mean` >= `B_overall_mean` | **Write Log Entry** | - Find bucket with name prefix `abtesting_logging`.<br>- Create a new object with content: `{'status': 'AB_Test_Concluded', 'winner': 'A', 'action': 'No_Change'}`.<br>- **Do not** create a new bucket. |
diff --git a/skills/benchmark_skills/toolathlon/academic-benchmark-researcher/SKILL.md b/skills/benchmark_skills/toolathlon/academic-benchmark-researcher/SKILL.md
new file mode 100644
index 0000000..d71f5d6
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-benchmark-researcher/SKILL.md
@@ -0,0 +1,43 @@
+---
+name: academic-benchmark-researcher
+description: When the user requests information about academic benchmarks, datasets, or research papers, particularly in machine learning, deep learning, or logical reasoning domains. This skill enables systematic research of academic benchmarks by searching web sources, downloading and analyzing arXiv papers, extracting key metadata (number of tasks, training availability, difficulty levels), and compiling comparative summaries. It triggers on requests involving dataset comparisons, benchmark analysis, or academic paper research for table creation.
+---
+# Instructions
+
+## Primary Objective
+Systematically research academic benchmarks, datasets, or research papers to extract and compile comparative information (e.g., into a summary table). The core workflow involves: 1) Identifying relevant sources, 2) Extracting key metadata, 3) Synthesizing findings into a structured output (like a LaTeX table).
+
+## Core Workflow
+1. **Clarify & Parse Request:** Identify the specific benchmarks/datasets/papers mentioned by the user. Note any required output format (e.g., LaTeX table with specific columns) and constraints (e.g., "no commented lines").
+2. **Initial Information Gathering:** For each identified entity (dataset/paper):
+ * Use `local-web_search` to find general information, official pages (GitHub, project sites), and relevant arXiv IDs.
+ * For arXiv papers, use `arxiv_local-download_paper` or `fetch-fetch_markdown` to obtain the paper content.
+ * Search for specific attributes requested by the user (e.g., "number of tasks," "training set," "difficulty levels").
+3. **Deep Dive & Verification:** Read paper abstracts, introductions, and methodology sections (using `arxiv_local-read_paper` or parsed markdown) to confirm key details. Cross-reference information from multiple sources (official site, paper, blog posts) for accuracy.
+4. **Information Synthesis:** Compile the extracted metadata into a structured format aligned with the user's request. Resolve any ambiguities (e.g., if a "task" count refers to broad categories or individual instances) based on the most authoritative source (typically the original paper).
+5. **Output Generation:** Create the final deliverable (e.g., a `.tex` file). Ensure it strictly adheres to the user's formatting specifications. Optionally, provide a concise textual summary of the findings.
+
+## Key Metadata to Extract
+When researching a benchmark/dataset, prioritize finding:
+* **Full Name & Acronym**
+* **Number of Tasks/Categories:** Distinguish between broad task categories and individual task instances.
+* **Training Data Availability:** Does it include a dedicated training set, or is it for evaluation only?
+* **Difficulty Levels:** Does it feature adjustable or tiered difficulty levels?
+* **Core Purpose/Description**
+* **Primary Source (arXiv ID, GitHub repo)**
+
+## Tool Usage Guidelines
+* `local-web_search`: Use for initial discovery and finding high-level descriptions. Employ specific queries combining the dataset name and target attributes (e.g., "BBH training set few-shot examples").
+* `arxiv_local-download_paper` / `fetch-fetch_markdown`: Use to access the canonical source for detailed information. Prefer `arxiv_local-download_paper` for full text analysis when needed.
+* `filesystem-write_file` / `filesystem-read_file`: Use for creating and verifying final output files in the workspace.
+* `local-claim_done`: Use only after successfully delivering the requested output and providing a final summary.
+
+## Output Standards
+* **LaTeX Tables:** Ensure the output contains only the specified table content, without extra comments, document headers, or unrelated text.
+* **Summaries:** Be concise but complete, highlighting the sourced information for each dataset.
+* **Accuracy:** Base conclusions on the original paper or official project documentation where possible. Acknowledge if information is not explicitly stated.
+
+## Common Pitfalls & Resolutions
+* **Ambiguous Task Counts:** If a paper mentions "5 task categories" (like KOR-Bench), report that as the task count unless the user specifies otherwise. Clarify in the summary if needed.
+* **Missing Information:** If a key attribute (e.g., training set) is not mentioned in primary sources, infer based on benchmark type (e.g., many evaluation benchmarks lack training sets) and denote with `\ding{55}`. State the assumption in your summary.
+* **arXiv Paper Processing:** If `arxiv_local-download_paper` returns a "converting" status, use `fetch-fetch_markdown` on the arXiv abstract page as a reliable fallback to get the paper's metadata and abstract.
diff --git a/skills/benchmark_skills/toolathlon/academic-benchmark-researcher/references/benchmark_attributes.md b/skills/benchmark_skills/toolathlon/academic-benchmark-researcher/references/benchmark_attributes.md
new file mode 100644
index 0000000..2cf223c
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-benchmark-researcher/references/benchmark_attributes.md
@@ -0,0 +1,31 @@
+# Common Benchmark Attributes Guide
+This reference defines key attributes often requested when comparing academic benchmarks/datasets.
+
+## 1. Tasks
+* **Definition:** The distinct problem types or categories evaluated by the benchmark.
+* **Interpretation:** Can be a count of broad categories (e.g., "5" for KOR-Bench's Operation, Logic, Cipher, Puzzle, Counterfactual) or a count of specific task instances (e.g., "23" for BBH's suite of challenges). Prioritize the categorization used in the benchmark's primary paper.
+* **Source:** Look in the paper's abstract, introduction, or a dedicated "Benchmark Structure" section.
+
+## 2. Trainable
+* **Definition:** Whether the benchmark provides a dedicated dataset intended for model training (fine-tuning), as opposed to being solely for evaluation.
+* **Values:**
+ * `\ding{51}` (Yes): The benchmark includes a training split. The associated paper often discusses fine-tuning experiments.
+ * `\ding{55}` (No): The benchmark is for evaluation only (e.g., via few-shot or zero-shot prompting). Common for "hard" or "challenge" benchmarks (BBH, BBEH).
+* **Source:** Check for mentions of "training set," "fine-tuning," "train/validation/test splits," or data generation procedures intended for training.
+
+## 3. Adjustable Difficulty
+* **Definition:** Whether the benchmark is designed with mechanisms to systematically vary the complexity or difficulty level of its problems.
+* **Values:**
+ * `\ding{51}` (Yes): The benchmark explicitly controls difficulty parameters (e.g., puzzle size, search space, number of logical constraints). Papers may mention "controllable complexity" or "multiple difficulty levels."
+ * `\ding{55}` (No): The benchmark presents problems at a fixed, predefined level of challenge.
+* **Source:** Look for sections on "dataset generation," "complexity measures," or "scaling studies."
+
+## 4. Core Purpose
+* **Definition:** A brief description of what the benchmark aims to measure or probe.
+* **Examples:** "Logical reasoning on constraint satisfaction problems," "Knowledge-orthogonal reasoning," "Extremely challenging general reasoning capabilities."
+* **Source:** The paper's abstract is usually the best source.
+
+## Data Collection Tips
+* **Primary Source First:** Always consult the arXiv paper or official project page (GitHub) as the most authoritative source.
+* **Corroborate:** Use web search results to find community descriptions or blog posts that might clarify ambiguous points, but weight them lower than the primary source.
+* **Inference:** If an attribute is not mentioned, it is often safe to infer its absence (e.g., no mention of a training set implies evaluation-only). State this inference clearly in your final summary.
diff --git a/skills/benchmark_skills/toolathlon/academic-benchmark-researcher/references/example_metadata.json b/skills/benchmark_skills/toolathlon/academic-benchmark-researcher/references/example_metadata.json
new file mode 100644
index 0000000..82215f4
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-benchmark-researcher/references/example_metadata.json
@@ -0,0 +1,42 @@
+[
+ {
+ "dataset": "BBH",
+ "tasks": 23,
+ "trainable": false,
+ "adjustable_difficulty": false,
+ "note": "BIG-Bench Hard. 23 challenging tasks from BIG-Bench. Evaluation-only benchmark.",
+ "source": "arXiv:2210.09261"
+ },
+ {
+ "dataset": "Zebra Logic",
+ "tasks": 1,
+ "trainable": false,
+ "adjustable_difficulty": true,
+ "note": "Logic grid puzzle benchmark. Features controllable complexity levels.",
+ "source": "arXiv:2502.01100"
+ },
+ {
+ "dataset": "KOR-Bench",
+ "tasks": 5,
+ "trainable": false,
+ "adjustable_difficulty": false,
+ "note": "Knowledge-Orthogonal Reasoning Benchmark. 5 task categories: Operation, Logic, Cipher, Puzzle, Counterfactual.",
+ "source": "arXiv:2410.06526"
+ },
+ {
+ "dataset": "K&K",
+ "tasks": 1,
+ "trainable": true,
+ "adjustable_difficulty": true,
+ "note": "Knights and Knaves logical reasoning benchmark. Includes training data and puzzles with varying numbers of people (2-8).",
+ "source": "arXiv:2410.23123"
+ },
+ {
+ "dataset": "BBEH",
+ "tasks": 23,
+ "trainable": false,
+ "adjustable_difficulty": false,
+ "note": "BIG-Bench Extra Hard. Replaces each BBH task with a more difficult version.",
+ "source": "arXiv:2502.19187"
+ }
+]
diff --git a/skills/benchmark_skills/toolathlon/academic-bibtex-manager/SKILL.md b/skills/benchmark_skills/toolathlon/academic-bibtex-manager/SKILL.md
new file mode 100644
index 0000000..87043b4
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-bibtex-manager/SKILL.md
@@ -0,0 +1,53 @@
+---
+name: academic-bibtex-manager
+description: When the user requests to add academic papers to a BibTeX bibliography file while maintaining format consistency and sourcing from appropriate repositories. This skill handles 1) Reading existing BibTeX files to understand formatting conventions, 2) Searching for academic papers across multiple sources (OpenReview for conference papers, arXiv for preprints), 3) Extracting proper BibTeX metadata from conference pages or arXiv entries, 4) Determining appropriate citation format (@article vs @inproceedings) based on publication venue, 5) Appending new entries while preserving existing file structure and formatting. Triggers include requests to 'add to ref.bib', 'update bibliography', 'cite papers', or when working with academic reference files.
+---
+# Instructions
+
+## Primary Objective
+Add requested academic paper entries to a specified BibTeX (.bib) file. Ensure entries are correctly formatted, sourced from authoritative repositories (OpenReview for conferences, arXiv for preprints), and consistent with the existing file's style.
+
+## Core Workflow
+
+### 1. Parse User Request & Identify Target File
+- Extract the list of paper titles/identifiers from the user's request.
+- Identify the target `.bib` file path (commonly `ref.bib` or specified by the user).
+- **First Action:** Always read the existing file (`filesystem-read_file`) to understand its structure, formatting conventions (indentation, line breaks, entry ordering), and to avoid duplicate entries.
+
+### 2. Research & Source BibTeX Data
+For each requested paper:
+- **Search Strategy:** Use `local-web_search` with queries combining the paper title and key terms like "openreview" or "arxiv".
+- **Source Determination:**
+ - **Conference Papers:** If the paper appears in search results from `openreview.net`, it is likely a peer-reviewed conference paper (e.g., ICLR, NeurIPS). Fetch the HTML page (`fetch-fetch_html`) to extract the official BibTeX entry from the page's metadata or BibTeX modal.
+ - **Preprints/Technical Reports:** If the primary source is `arxiv.org`, it is an arXiv preprint. Fetch the page (`fetch-fetch_markdown` or `fetch-fetch_html`) to obtain authors, title, year, and arXiv ID.
+- **Format Selection:** Use `@inproceedings{...}` for confirmed conference papers. Use `@article{...}` for arXiv preprints, reports, or journal articles. Match the citation key style (e.g., `authorYYYYkeyword`) observed in the existing file.
+
+### 3. Construct & Validate New Entries
+- **Conference Entries:** Use the exact BibTeX provided by OpenReview. Verify it includes `booktitle`, `year`, and `url` fields.
+- **arXiv Entries:** Construct an `@article` entry with fields: `title`, `author`, `journal={arXiv preprint arXiv:XXXX.XXXXX}`, `year`. Ensure author lists are formatted consistently (e.g., "Last, First and Last, First").
+- **Check for Duplicates:** Before writing, scan the newly read file content to ensure the paper (by title or likely citation key) isn't already present.
+
+### 4. Write to File
+- Use `filesystem-edit_file` to append the new BibTeX entries to the end of the existing file.
+- **Formatting:** Insert a blank line before the new block of entries. Maintain the existing file's indentation style (spaces vs. tabs). Ensure each entry ends with a newline.
+- **Order:** Add entries in the order they were requested.
+
+### 5. Final Verification & Summary
+- Read the tail of the updated file (`filesystem-read_file` with `tail` parameter) to confirm successful addition.
+- Provide the user with a concise summary listing each added paper, its citation key, source (arXiv/Conference), and the format used (`@article`/`@inproceedings`).
+
+## Key Decision Rules
+- **arXiv vs. Conference:** A paper listed on OpenReview with a conference title (e.g., "ICLR 2024") is a conference paper. A paper only found on arXiv or described as a "technical report" is an `@article`.
+- **BibTeX Source Priority:** 1) Official BibTeX from OpenReview page, 2) Constructed entry from arXiv metadata, 3) Fallback to manual construction from search results if needed.
+- **File Safety:** Never overwrite the entire file. Always use `edit_file` to append at a specific, safe location (e.g., before the end of the file).
+
+## Common Triggers & User Phrases
+- "Please help me add the following article to the ref.bib file..."
+- "Update the bibliography with these papers..."
+- "Cite these papers in the .bib file..."
+- "Add these references, keep the format consistent."
+
+## Error Handling
+- **Missing Paper:** If a paper cannot be found via search, inform the user and ask for clarification (e.g., a DOI, arXiv ID, or full author list).
+- **File Not Found:** If the target `.bib` file does not exist, ask the user for confirmation before creating a new one.
+- **Parsing Error:** If fetched HTML lacks clear BibTeX, proceed to construct a minimal, correct entry from available metadata and note the limitation to the user.
diff --git a/skills/benchmark_skills/toolathlon/academic-bibtex-manager/references/formatting_guide.md b/skills/benchmark_skills/toolathlon/academic-bibtex-manager/references/formatting_guide.md
new file mode 100644
index 0000000..e2daee0
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-bibtex-manager/references/formatting_guide.md
@@ -0,0 +1,7 @@
+# BibTeX Formatting Conventions Guide
+
+## Common Patterns Observed in Trajectory
+
+### 1. Entry Types
+- **`@article{...}`**: Used for arXiv preprints, journal articles, technical reports.
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/academic-candidate-filter/SKILL.md b/skills/benchmark_skills/toolathlon/academic-candidate-filter/SKILL.md
new file mode 100644
index 0000000..5c43ae1
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-candidate-filter/SKILL.md
@@ -0,0 +1,56 @@
+---
+name: academic-candidate-filter
+description: Filters candidates based on specific academic publication criteria (e.g., first-author, sole-author, or independent publications) from resumes or application materials. Searches through candidate data, extracts publication history, and applies filtering logic to identify qualified individuals.
+---
+# Instructions
+
+## 1. Objective
+Filter candidates from provided materials (e.g., emails, documents) based on user-specified authorship criteria (e.g., "first-author", "sole-author", "independent publications"). For qualified candidates, schedule interviews according to user constraints and sync to Google Calendar.
+
+## 2. Core Workflow
+
+### Phase 1: Data Collection & Parsing
+1. **Identify Source:** Determine where candidate materials are stored based on user request (e.g., "emails", "documents in a folder").
+2. **Search & Retrieve:** Use appropriate tools (e.g., `emails-search_emails`, `files-search_files`) to find candidate materials using relevant keywords ("resume", "CV", "application").
+3. **Extract Content:** Read the full content of each retrieved item.
+4. **Parse Publications:** For each candidate, scan the content to identify a "Publications", "Research Results", or similar section. Extract the list of publications, paying close attention to authorship indicators (e.g., "**First Author**", "*Sole Author*", "First Author:", "Author:").
+
+### Phase 2: Candidate Filtering
+1. **Apply Filter Logic:** Evaluate each candidate's publication list against the user's stated criteria.
+ - **Default Logic (from trajectory):** A candidate qualifies if they have **at least one publication explicitly marked as "First Author" or "Sole Author"**. Co-authored publications (Second, Third, etc.) do **not** count.
+ - **Adaptation:** If the user specifies a different criterion (e.g., "at least two first-author papers"), adjust the logic accordingly.
+2. **Compile Results:** Create a clear list of qualified and non-qualified candidates, citing the specific publications that caused their inclusion or exclusion.
+
+### Phase 3: Interview Scheduling
+1. **Interpret Time Constraints:** Parse the user's scheduling instructions (dates, working hours, interview duration).
+ - *Example Logic:* If "tomorrow and the day after tomorrow" is specified, calculate these dates relative to the **most recent date found in the source materials** (as seen in the trajectory).
+2. **Generate Time Slots:** Within the specified date range and working hours, create candidate interview slots that respect the minimum duration.
+ - Consider buffer time between interviews if scheduling multiple candidates.
+3. **Create Calendar Events:** For each qualified candidate, create a Google Calendar event (`google_calendar-create_event`).
+ - **Summary:** Format as `"Interview with [Candidate Name]"`
+ - **Description:** Include key details: University/Background, Research Areas, **Qualifying Publication(s)**, and contact information (email/phone) extracted from their materials.
+ - **Time Zone:** Explicitly set the time zone based on user instruction (e.g., `"Asia/Hong_Kong"`).
+
+### Phase 4: Reporting
+1. **Present Summary:** Deliver a final summary to the user in a structured format (e.g., a table).
+2. **Include:**
+ - List of qualified candidates and their qualifying publications.
+ - Final interview schedule (Candidate, Date, Time Slot, Duration).
+ - List of non-qualified candidates and the reason (e.g., "No first-author publications").
+ - Confirmation that events were added to Google Calendar.
+
+## 3. Key Logic & Rules (For Scripting)
+- **Authorship Parsing Rule:** A qualifying publication must be explicitly associated with the candidate via phrases like "First Author", "Sole Author", or "Author" in a context that implies primary/independent authorship. Implied authorship from being listed first in a citation is not sufficient unless explicitly stated in the text.
+- **Date Resolution Rule:** When relative dates like "tomorrow" are used, the anchor date is the most recent date found among the retrieved candidate source materials (e.g., the latest email date).
+- **Scheduling Rule:** Interviews must be scheduled within the user-defined working hour window and must last *at least* the specified minimum duration.
+
+## 4. Error Handling & Edge Cases
+- If no candidates meet the criteria, inform the user and do not schedule any events.
+- If the source materials contain no date information, ask the user to clarify the interview dates.
+- If a candidate's material has no clear publication section, treat them as having no qualifying publications.
+- If scheduling conflicts occur (e.g., not enough slots), report the conflict to the user and schedule as many as possible.
+
+## 5. Required Tools
+- Email search & read tools (e.g., `emails-search_emails`, `emails-read_email`).
+- Google Calendar event creation tool (`google_calendar-create_event`).
+- (Optional) File search & read tools for non-email sources.
diff --git a/skills/benchmark_skills/toolathlon/academic-candidate-filter/references/authorship_patterns.md b/skills/benchmark_skills/toolathlon/academic-candidate-filter/references/authorship_patterns.md
new file mode 100644
index 0000000..fd6f2cb
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-candidate-filter/references/authorship_patterns.md
@@ -0,0 +1,56 @@
+# Authorship Pattern Reference
+
+This document catalogs common patterns for identifying authorship in academic resumes and application materials.
+
+## Primary/First Author Indicators
+These patterns indicate the candidate was the primary (first) author:
+
+### Explicit Markers
+- `First Author: "Paper Title", Venue Year`
+- `**First Author**: "Paper Title", Venue Year`
+- `<strong>First Author</strong>: "Paper Title", Venue Year`
+- `Author (first): "Paper Title", Venue Year`
+
+### Implicit Markers (Context-Dependent)
+- `"Paper Title", Venue Year (First Author)`
+- Listed first in a bibliography where authorship is explicitly attributed
+- `Lead author: "Paper Title"`
+
+## Sole/Independent Author Indicators
+These patterns indicate the candidate was the only author:
+
+### Explicit Markers
+- `Sole Author: "Paper Title", Venue Year`
+- `**Sole Author**: "Paper Title", Venue Year`
+- `Independent Author: "Paper Title", Venue Year`
+- `Single Author: "Paper Title", Venue Year`
+
+### Implicit Markers
+- `Author: "Paper Title", Venue Year` (when no other authors are mentioned in the entry)
+- `"Paper Title", Venue Year` (when listed alone in a publications section with no co-authors mentioned)
+
+## Non-Qualifying Authorship Patterns
+These do NOT count as independent/first-author publications:
+- `Second Author: ...`
+- `Third Author: ...`
+- `Co-author: ...`
+- `Collaborator: ...`
+- `Contributing Author: ...`
+- Being listed first in a citation without explicit authorship attribution (e.g., `"Smith, J. et al. Paper Title"`)
+
+## Common Section Headers
+Look for these section titles when searching for publications:
+- Publications
+- Research Results
+- Academic Contributions
+- Journal Articles
+- Conference Papers
+- Selected Publications
+- Research Output
+
+## Format Variations
+Publications may be formatted as:
+- Bulleted lists (`•`, `-`, `*`)
+- Numbered lists (`1.`, `2.`)
+- Plain text with line breaks
+- HTML formatted text with bold/strong tags
diff --git a/skills/benchmark_skills/toolathlon/academic-candidate-filter/references/calendar_event_template.md b/skills/benchmark_skills/toolathlon/academic-candidate-filter/references/calendar_event_template.md
new file mode 100644
index 0000000..a13ba3b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-candidate-filter/references/calendar_event_template.md
@@ -0,0 +1,5 @@
+# Google Calendar Event Template
+
+Use this template structure when creating interview events for qualified candidates.
+
+## Event Structure
diff --git a/skills/benchmark_skills/toolathlon/academic-course-setup-automator/SKILL.md b/skills/benchmark_skills/toolathlon/academic-course-setup-automator/SKILL.md
new file mode 100644
index 0000000..a671808
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-course-setup-automator/SKILL.md
@@ -0,0 +1,57 @@
+---
+name: academic-course-setup-automator
+description: When the user needs to set up multiple academic courses in a learning management system (Canvas/LMS) from structured data sources. This skill automates the entire workflow extracting course schedules from emails/attachments, matching instructors from CSV files, creating courses, enrolling teachers, publishing announcements with class details, uploading syllabi, enabling resource sharing for instructors teaching multiple courses, and publishing all courses. Triggers include course schedule setup, Canvas/LMS administration, academic term preparation, instructor assignment, syllabus distribution, and multi-course management.
+---
+# Academic Course Setup Automator
+
+## Purpose
+Automate the creation and configuration of academic courses in Canvas (or similar LMS) from a master schedule and instructor list. This skill handles the end-to-end process from data extraction to final course publication.
+
+## Primary Workflow
+
+### 1. Initial Data Gathering
+- **Search for schedule email**: Look for emails with subject "Course Schedule Notification" or similar
+- **Download schedule attachment**: Extract the course schedule (typically markdown/CSV format)
+- **Load instructor data**: Read teacher emails from CSV file in workspace
+- **Verify admin identity**: Get current user profile to determine which courses to manage
+
+### 2. Data Processing
+- **Parse course schedule**: Extract courses for the current administrator
+- **Map instructors**: Match instructor names to Canvas user IDs using email addresses
+- **Identify multi-course instructors**: Flag instructors teaching multiple courses for resource sharing
+
+### 3. Course Creation & Configuration
+- **Create courses**: Generate all courses for the administrator
+- **Enroll instructors**: Add teachers to their respective courses
+- **Publish announcements**: Create course announcements with instructor name and class time
+- **Upload syllabi**: Attach syllabus PDFs from workspace to corresponding courses
+- **Update course settings**: Set public syllabus and publish courses
+
+### 4. Resource Sharing Setup
+- **Create resource sharing notices**: Add announcements indicating related courses for instructors teaching multiple sections
+- **Cross-reference courses**: Provide course IDs for easy navigation between related courses
+
+## Key Requirements Met
+- ✅ Assign correct instructors as teachers using email mapping
+- ✅ Publish announcements with instructor names and class times
+- ✅ Set up resource sharing for instructors teaching multiple courses
+- ✅ Publish syllabi for each course
+- ✅ Publish all courses
+
+## Critical Success Factors
+1. **Email search precision**: Must find the correct schedule email
+2. **Instructor mapping accuracy**: Email addresses must match Canvas user records
+3. **Course naming consistency**: Course codes should follow institutional conventions
+4. **File path accuracy**: Syllabus files must match course names in workspace
+
+## Common Edge Cases
+- Missing instructor records in Canvas
+- Syllabus files not found in workspace
+- Duplicate course names
+- Large number of courses requiring batch processing
+
+## Optimization Notes
+- Batch course creation where possible
+- Use consistent naming patterns for course codes
+- Validate all operations before proceeding to next step
+- Maintain clear logging of created resources for verification
diff --git a/skills/benchmark_skills/toolathlon/academic-course-setup-automator/references/canvas_api_patterns.md b/skills/benchmark_skills/toolathlon/academic-course-setup-automator/references/canvas_api_patterns.md
new file mode 100644
index 0000000..c0321c7
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-course-setup-automator/references/canvas_api_patterns.md
@@ -0,0 +1,5 @@
+# Canvas API Integration Patterns
+
+## Core Operations Sequence
+
+### 1. User Management
diff --git a/skills/benchmark_skills/toolathlon/academic-course-setup-automator/references/course_schedule_schema.md b/skills/benchmark_skills/toolathlon/academic-course-setup-automator/references/course_schedule_schema.md
new file mode 100644
index 0000000..feedc38
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-course-setup-automator/references/course_schedule_schema.md
@@ -0,0 +1,19 @@
+# Course Schedule Schema
+
+## Expected Format
+The course schedule is typically provided as a markdown table with the following columns:
+
+| Column Name | Description | Example |
+|-------------|-------------|---------|
+| Course Name | Full course name with section | "English Literature-7" |
+| Instructor | Instructor's full name | "Melissa Sanchez" |
+| Class Time | Day and period information | "Monday 7,8,9" |
+| Academic Administrator | Admin responsible for setup | "admin3" |
+
+## Parsing Rules
+1. **Course Name Format**: Usually follows "Course Title-Section" pattern
+2. **Instructor Names**: Match exactly with CSV instructor list
+3. **Admin Filtering**: Only process rows where "Academic Administrator" matches current user
+4. **Time Format**: Preserve exact text for announcements
+
+## Sample Data
diff --git a/skills/benchmark_skills/toolathlon/academic-course-setup-automator/references/instructor_csv_schema.md b/skills/benchmark_skills/toolathlon/academic-course-setup-automator/references/instructor_csv_schema.md
new file mode 100644
index 0000000..4a5c6dc
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-course-setup-automator/references/instructor_csv_schema.md
@@ -0,0 +1,5 @@
+# Instructor CSV Schema
+
+## Expected Format
+CSV file containing instructor email mappings:
+
diff --git a/skills/benchmark_skills/toolathlon/academic-data-integration/SKILL.md b/skills/benchmark_skills/toolathlon/academic-data-integration/SKILL.md
new file mode 100644
index 0000000..60e4b70
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-data-integration/SKILL.md
@@ -0,0 +1,52 @@
+---
+name: academic-data-integration
+description: When the user needs to integrate multiple data sources (Canvas API, user memory, file systems) to create comprehensive academic reports. This skill combines course information, assignment details, submission status, and user context to generate actionable insights. Triggers include requests that involve cross-referencing multiple data sources or creating consolidated academic reports from disparate systems.
+---
+# Instructions
+
+## Objective
+Integrate data from Canvas LMS, user memory, and local workspace files to identify and report on unsubmitted academic work. The primary output is formatted CSV files containing sorted lists of pending quizzes and assignments.
+
+## Core Workflow
+
+### 1. Initial Data Gathering
+- **Read User Memory**: Use `memory-read_graph` to retrieve the user's personal information. Pay special attention to academic exemptions (e.g., English entrance exam score).
+- **Fetch Course List**: Use `canvas-canvas_list_courses` to get all enrolled courses. Note the `course_code` and `name` for each.
+
+### 2. Understand Output Format
+- **Inspect Workspace**: Use `local-python-execute` to list files in `/workspace/dumps/workspace/` and examine any existing CSV files (e.g., `quiz_info.csv`, `assignment_info.csv`).
+- **Analyze Headers**: Note the required CSV columns and data format from the example rows.
+
+### 3. Collect Pending Work Details
+- **Fetch Assignments & Quizzes**: For each course ID obtained in step 1, call:
+ - `canvas-canvas_list_assignments` with `include_submissions: true`.
+ - `canvas-canvas_list_quizzes`.
+- **Identify Unsubmitted Items**:
+ - **Assignments**: An item is "unsubmitted" if `submission.workflow_state` is `"unsubmitted"` AND `is_quiz_assignment` is `false`.
+ - **Quizzes**: A quiz is "required" if its `quiz_type` is `"assignment"` (graded). Ignore `"practice_quiz"` types.
+ - **Apply Exemptions**: Cross-reference user memory with course announcements. For example, if a user's English entrance score is ≥90 and a course announcement grants an exemption, exclude that quiz.
+
+### 4. Enrich Data & Sort
+- **Fetch Course Details**: Optionally use `canvas-canvas_get_course` for each course if additional metadata (like credits) is needed but not in the initial list.
+- **Determine Credits**: If credit information is unavailable via API, infer it logically (e.g., 101/201/301-level = 3 credits, 401-level = 4 credits) based on the `course_code`.
+- **Clean Data**: Remove the `-x` suffix (e.g., `-1`) from `course_code` and `course_name`.
+- **Sort Final Lists**:
+ 1. **Primary Key**: Deadline (`due_at`) in chronological order.
+ 2. **Secondary Key**: Course code in dictionary (alphabetical) order for items with identical deadlines.
+
+### 5. Generate Output Files
+- **Write CSVs**: Use `local-python-execute` to run a Python script that:
+ 1. Creates the sorted lists of quizzes and assignments.
+ 2. Writes to the existing CSV file paths in the workspace **without changing the filenames**.
+ 3. Formats data exactly as the example headers specify.
+- **Verify**: Read and print the final CSV contents to confirm correct formatting and sorting.
+
+## Key Decision Points
+- **Inclusion/Exclusion Logic**: Document why specific items were included or excluded (e.g., "exempt due to high English score", "practice quiz not graded").
+- **Data Fallbacks**: When API data is missing (e.g., credits), use reasoned defaults and note the assumption.
+- **Sorting Validation**: Double-check that sorting by deadline then course code is correctly implemented.
+
+## Final Output
+The skill is complete when:
+1. The `quiz_info.csv` and `assignment_info.csv` files in the workspace are updated with the current, sorted list of unsubmitted work.
+2. A clear summary is provided explaining what was found and any logical decisions made.
diff --git a/skills/benchmark_skills/toolathlon/academic-data-integration/references/data_schema.md b/skills/benchmark_skills/toolathlon/academic-data-integration/references/data_schema.md
new file mode 100644
index 0000000..2dfd35e
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-data-integration/references/data_schema.md
@@ -0,0 +1,5 @@
+# Data Schema Reference
+
+## Canvas API Data Structures
+
+### Course Object (Simplified)
diff --git a/skills/benchmark_skills/toolathlon/academic-data-integration/references/exemption_logic.md b/skills/benchmark_skills/toolathlon/academic-data-integration/references/exemption_logic.md
new file mode 100644
index 0000000..6b71330
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-data-integration/references/exemption_logic.md
@@ -0,0 +1,23 @@
+# Exemption Logic Reference
+
+## Common Exemption Patterns
+
+### 1. English Proficiency Exemption
+- **Trigger**: Course announcement indicates exemption for high entrance exam scores
+- **Data Source**: User memory contains `"Score for the entrance English exam: 95"`
+- **Logic**: If score ≥ threshold (e.g., 90), exclude ENG101 quizzes
+- **Example Announcement**: "Students with exemption score of 90 or above may be exempt from all quizzes."
+
+### 2. Practice vs Graded Quizzes
+- **Field**: `quiz_type`
+- **Graded**: `"assignment"` - Include in report
+- **Practice**: `"practice_quiz"` - Exclude from report
+- **Identification**: Check if `assignment_id` is present (graded quizzes have this)
+
+### 3. Already Submitted Work
+- **Field**: `submission.workflow_state`
+- **Submitted**: `"submitted"` or has `submitted_at` timestamp - Exclude
+- **Unsubmitted**: `"unsubmitted"` - Include
+
+## Decision Flowchart
+
diff --git a/skills/benchmark_skills/toolathlon/academic-homepage-generator/SKILL.md b/skills/benchmark_skills/toolathlon/academic-homepage-generator/SKILL.md
new file mode 100644
index 0000000..7af7ffb
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-homepage-generator/SKILL.md
@@ -0,0 +1,48 @@
+---
+name: academic-homepage-generator
+description: When the user requests to create or customize an academic personal website from a GitHub template repository. This skill handles the complete workflow of forking academic template repositories (like academicpages.github.io), extracting structured personal information from memory or provided data, and systematically updating configuration files (_config.yml), navigation menus (_data/navigation.yml), content pages (_pages/about.md), and publication listings (_publications/). It specifically handles academic profiles including personal details, education background, research experience, publications, skills, and contact information. Triggers include requests to 'fork and customize academic homepage', 'build personal academic website', 'create research portfolio', or 'set up GitHub pages with academic template'.
+---
+# Skill: Academic Homepage Generator
+
+## Primary Objective
+Fork a specified academic GitHub Pages template repository, rename it, and populate it with a user's personal academic information extracted from memory or provided data. The final output is a fully configured, personalized academic homepage ready to be hosted on GitHub Pages.
+
+## Core Workflow
+The skill follows a strict, sequential workflow to ensure a successful deployment. Deviations may cause errors.
+
+1. **Retrieve Personal Data**: Extract the user's structured academic profile from memory using `memory-read_graph`. This data is the single source of truth for all content updates.
+2. **Fork Template Repository**: Use `github-fork_repository` on the target template (e.g., `academicpages/academicpages.github.io`).
+3. **Identify User Account**: Use `github-get_me` to get the forking user's GitHub username.
+4. **Rename Repository**: Use `github-rename_repository` to give the fork a user-specified name (e.g., `LJT-Homepage`).
+5. **Analyze Repository Structure**: Examine key directories (`_pages/`, `_publications/`, `_data/`, `_config.yml`) to understand the template's layout.
+6. **Update Core Configuration Files**:
+ * `_config.yml`: Update site title, description, URL, and most importantly, the `author` section with personal details (name, bio, location, employer, email, social links).
+ * `_data/navigation.yml`: Simplify the site's main navigation menu. Typically, reduce it to only essential links like "Publications" as per user instruction.
+ * `_pages/about.md`: Completely replace the default content with a structured personal profile containing: Introduction, Research Interests, Education, Research Experience, Publications (listed in-text), Skills, and Contact Information.
+7. **Manage Publication Files**:
+ * Delete all existing sample files in the `_publications/` directory.
+ * Create new Markdown files for each of the user's publications, using a consistent naming convention (e.g., `YYYY-MM-DD-short-title.md`). Each file must contain valid YAML frontmatter (`title`, `collection`, `date`, `venue`, `citation`).
+8. **Final Verification**: Check that all key files (`_config.yml`, `_pages/about.md`, `_data/navigation.yml`) and publication entries have been correctly created and contain no placeholder data.
+
+## Critical Constraints & Guardrails
+* **Data Fidelity**: Do not add, modify, or hallucinate any personal information. Use **only** the data provided in the memory graph. If information is missing (e.g., a specific social media link not in memory), leave the field blank in the configuration.
+* **Publication Inclusion**: List **all** publications from memory in the `about.md` page, clearly distinguishing between first-author and co-authored works. Also create individual publication Markdown files for each.
+* **Navigation Simplification**: Adhere to the user's request regarding the navigation menu. If asked to show only specific pages, remove all other links from `_data/navigation.yml`.
+* **No Extra Pages**: Do not create, enable, or modify pages beyond those explicitly mentioned in the workflow (e.g., do not activate blog, teaching, or portfolio sections unless specified).
+
+## Required Tools
+This skill requires sequential use of the following tools. Ensure all necessary permissions/scopes are available.
+1. `memory-read_graph`
+2. `github-fork_repository`
+3. `github-get_me`
+4. `github-rename_repository`
+5. `github-get_file_contents`
+6. `github-create_or_update_file`
+7. `github-delete_file`
+
+## Failure Recovery
+* **Concurrent Write Conflicts**: If `github-create_or_update_file` or `github-delete_file` fails with a "409 conflict" error, fetch the latest repository state (`github-get_file_contents` on the root) to get the new `sha`, then retry the operation with the updated `sha`.
+* **Missing Data**: If a required field from the memory graph is empty, log a clear note and proceed, leaving the corresponding website field blank. Do not invent data.
+
+## Output
+The skill is complete when the user's forked GitHub repository contains all personalized files and the commit history shows successful updates. Provide the user with the URL to their new repository (e.g., `https://github.com/<username>/<repo-name>`).
diff --git a/skills/benchmark_skills/toolathlon/academic-homepage-generator/references/template_structure.md b/skills/benchmark_skills/toolathlon/academic-homepage-generator/references/template_structure.md
new file mode 100644
index 0000000..d3e0e64
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-homepage-generator/references/template_structure.md
@@ -0,0 +1,8 @@
+# Academic Pages Template Structure Reference
+
+This document outlines the key files and directories in the `academicpages.github.io` template that are modified by this skill.
+
+## Core Configuration Files
+
+### `_config.yml`
+The main Jekyll configuration file. Critical sections to update:
diff --git a/skills/benchmark_skills/toolathlon/academic-paper-researcher/SKILL.md b/skills/benchmark_skills/toolathlon/academic-paper-researcher/SKILL.md
new file mode 100644
index 0000000..020cfa2
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-paper-researcher/SKILL.md
@@ -0,0 +1,55 @@
+---
+name: academic-paper-researcher
+description: When the user needs to research academic papers and extract specific author information including full names, institutional affiliations (with department-level details when available), and Google Scholar profiles. This skill is triggered by requests involving academic paper analysis, conference research, author profiling, or when working with Excel sheets containing paper titles that need author metadata enrichment. It handles searching for papers, extracting information from PDFs, finding author profiles, and updating spreadsheet data.
+---
+# Instructions
+
+## Goal
+Fill an Excel spreadsheet with research data for a list of academic papers. For each paper, find:
+1. The full name of the first author.
+2. The complete institutional affiliation of the first author **exactly as it appears in the paper** (include all institutions if multiple are listed, specifying down to the department level when provided).
+3. The link to the first author's Google Scholar profile.
+
+## Core Workflow
+
+### 1. Locate and Inspect the Target Excel File
+* Use the `terminal-run_command` tool to find `.xlsx` or `.xls` files in the user's workspace (e.g., `/workspace/dumps/workspace`).
+* **Security Note:** Avoid using paths like `/dev/null` in commands as they may be outside allowed directories.
+* Once found, use `excel-get_workbook_metadata` and `excel-read_data_from_excel` to understand the file's structure: sheet names, headers (typically "Title", "First Author", "Affiliation", "Google Scholar Profile"), and the range of rows containing paper titles.
+
+### 2. Research Each Paper
+* For each paper title in the Excel file, perform a parallel search using `local-web_search`. Craft queries like `"<Exact Paper Title>" paper first author`.
+* Analyze search results to identify:
+ * The first author's name.
+ * Potential sources for the full paper PDF (e.g., OpenReview, arXiv, conference proceedings).
+ * Initial clues for the author's Google Scholar profile.
+
+### 3. Extract Precise Affiliation from Source PDFs
+* The most reliable source for the exact affiliation is the paper itself.
+* For each paper, locate and access the PDF using URLs found during the web search (e.g., `https://openreview.net/pdf?id=...`, `https://arxiv.org/pdf/...`).
+* Use `pdf-tools-read_pdf_pages` to read the first 1-2 pages of the PDF.
+* **Extraction Logic:** Scan the extracted text. The affiliation is typically listed on the first page, beneath the author list or in the footer/correspondence section. Look for patterns like:
+ * `*Equal contribution1Department of...`
+ * `1Gatsby Computational Neuroscience Unit, University College London`
+ * `Correspondence to: ...`
+ * Capture the **full, verbatim affiliation string** for the first author as it appears in the paper.
+
+### 4. Find Google Scholar Profiles
+* For each identified first author, perform a targeted `local-web_search` (e.g., `"<Author Full Name>" Google Scholar profile` or `site:scholar.google.com "<Author Name>"`).
+* Validate the profile by checking if the author's listed publications include the target paper or are in a related field.
+* Extract the clean, direct URL to their Google Scholar citations page.
+
+### 5. Compile and Write Data to Excel
+* Organize the collected data for all papers into a list of lists, where each sub-list contains `[first_author_name, affiliation, google_scholar_url]` for one paper.
+* Use `excel-write_data_to_excel` to write this data array into the appropriate columns ("First Author", "Affiliation", "Google Scholar Profile"), starting at the correct row (e.g., `B2`).
+* Verify the write operation by reading back the updated cell range with `excel-read_data_from_excel`.
+
+### 6. Finalize and Report
+* Present a summary table to the user showing the completed entries.
+* Use `local-claim_done` to signal successful task completion.
+
+## Key Principles & Error Handling
+* **Accuracy Over Speed:** Prioritize finding the original PDF to get the affiliation exactly right. Do not guess or paraphrase.
+* **Parallel Execution:** Use parallel tool calls for independent steps like searching for multiple papers or author profiles to improve efficiency.
+* **Fallback Strategies:** If a PDF cannot be accessed, use the most authoritative text snippet from search results (e.g., conference site, author's personal page) to infer the affiliation, and note any uncertainty.
+* **Validation:** Cross-check that the Google Scholar profile belongs to the correct person by verifying their institutional affiliation or paper titles.
diff --git a/skills/benchmark_skills/toolathlon/academic-paper-researcher/references/affiliation_patterns.md b/skills/benchmark_skills/toolathlon/academic-paper-researcher/references/affiliation_patterns.md
new file mode 100644
index 0000000..137eeb3
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-paper-researcher/references/affiliation_patterns.md
@@ -0,0 +1,5 @@
+# Common Affiliation Patterns in Academic Papers
+
+When extracting author affiliations from PDFs, look for these common formats on the first page:
+
+## 1. Standard Numbered Superscript
diff --git a/skills/benchmark_skills/toolathlon/academic-performance-analyzer/SKILL.md b/skills/benchmark_skills/toolathlon/academic-performance-analyzer/SKILL.md
new file mode 100644
index 0000000..e56a4c1
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-performance-analyzer/SKILL.md
@@ -0,0 +1,64 @@
+---
+name: academic-performance-analyzer
+description: When the user needs to monitor student academic performance by comparing current test scores against historical averages to identify significant performance declines. This skill reads CSV files containing latest scores, queries historical data from BigQuery tables, calculates percentage drops, identifies at-risk students based on configurable thresholds (e.g., >25% drop), and generates comprehensive reports. Triggers include requests for academic warning systems, student performance analysis, score trend monitoring, or identifying students needing intervention.
+---
+# Academic Performance Analyzer
+
+## Overview
+This skill automates the detection of significant declines in student academic performance by comparing the latest test scores against their historical averages. It identifies students requiring academic intervention and can trigger immediate counselor notifications for critical cases.
+
+## Core Workflow
+1. **Input Processing**: Read the latest student scores from a CSV file.
+2. **Historical Analysis**: Query and aggregate historical test scores from multiple BigQuery tables.
+3. **Performance Calculation**: Compute the percentage drop between historical average and latest score for each student.
+4. **Threshold Filtering**: Identify students exceeding warning thresholds (configurable).
+5. **Output Generation**: Create a CSV report of at-risk students.
+6. **Critical Alerting**: Write critical warning logs for students exceeding severe thresholds.
+
+## Required Inputs
+- **Latest Scores CSV**: Path to a CSV file with columns: `student_id`, `name`, `score`
+- **BigQuery Dataset**: Dataset containing historical score tables (e.g., `scores_2501`, `scores_2502`, etc.)
+- **Log Bucket**: Cloud Logging bucket with name prefixed with `exam_log` for critical alerts
+
+## Configuration Parameters
+- `WARNING_THRESHOLD`: Percentage drop to trigger inclusion in report (default: 25%)
+- `CRITICAL_THRESHOLD`: Percentage drop to trigger critical alerts (default: 45%)
+- `OUTPUT_CSV`: Path for the generated report (default: `bad_student.csv`)
+
+## Key Instructions
+
+### 1. Validate Inputs
+- Confirm the latest scores CSV file exists and has correct format
+- Verify BigQuery dataset exists and contains expected score tables
+- Check for available log buckets with `exam_log` prefix
+
+### 2. Query Historical Data
+- Use a UNION ALL query to combine all historical score tables
+- Calculate average score per student across all historical tests
+- Handle potential data truncation by querying in batches if needed
+
+### 3. Perform Analysis
+- Join latest scores with historical averages
+- Calculate drop percentage: `((avg_score - latest_score) / avg_score) * 100`
+- Filter students where drop percentage exceeds `WARNING_THRESHOLD`
+- Sort results by drop percentage (descending)
+
+### 4. Generate Outputs
+- Create CSV with columns: `student_id`, `name`, `avg_score`, `latest_score`, `drop_percentage`
+- Save to specified output path
+
+### 5. Handle Critical Cases
+- For students exceeding `CRITICAL_THRESHOLD`:
+ - Write CRITICAL severity log to the `exam_log` bucket
+ - Include student name and ID in log message
+ - Format: "CRITICAL ACADEMIC WARNING: Student [Name] (ID: [ID]) has experienced a severe score drop of [X]% compared to their historical average. Immediate counselor notification required."
+
+## Error Handling
+- Gracefully handle missing tables or files
+- Validate data types and ranges
+- Log errors appropriately without exposing sensitive information
+
+## Notes
+- Historical tables may have prefixes (e.g., `scores_2501` instead of just `2501`)
+- Output CSV should be sorted by severity (highest drop percentage first)
+- Only consider logs written during current execution (ignore pre-existing entries)
diff --git a/skills/benchmark_skills/toolathlon/academic-performance-analyzer/references/bigquery_schema.md b/skills/benchmark_skills/toolathlon/academic-performance-analyzer/references/bigquery_schema.md
new file mode 100644
index 0000000..57979b3
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-performance-analyzer/references/bigquery_schema.md
@@ -0,0 +1,27 @@
+# BigQuery Schema Reference
+
+## Dataset: academic_warning
+
+### Table Structure
+All historical score tables follow the same schema:
+
+**Table Name Pattern**: `scores_XXXX` (e.g., `scores_2501`, `scores_2502`)
+
+**Columns**:
+- `student_id` (STRING): Unique student identifier (e.g., "S001", "S002")
+- `name` (STRING): Student's full name
+- `score` (FLOAT): Test score (typically 0-100 scale)
+
+### Example Table Names
+Based on the execution trajectory, the dataset contains:
+- `scores_2501`
+- `scores_2502`
+- `scores_2503`
+- `scores_2504`
+- `scores_2505`
+- `scores_2506`
+- `scores_2507`
+
+### Query Patterns
+
+#### 1. Get All Historical Averages
diff --git a/skills/benchmark_skills/toolathlon/academic-performance-analyzer/references/csv_format.md b/skills/benchmark_skills/toolathlon/academic-performance-analyzer/references/csv_format.md
new file mode 100644
index 0000000..ddd7b83
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-performance-analyzer/references/csv_format.md
@@ -0,0 +1,7 @@
+# CSV File Formats
+
+## Latest Scores Input CSV
+
+**File**: Typically named `latest_quiz_scores.csv`
+
+**Format**:
diff --git a/skills/benchmark_skills/toolathlon/academic-performance-analyzer/references/logging_config.md b/skills/benchmark_skills/toolathlon/academic-performance-analyzer/references/logging_config.md
new file mode 100644
index 0000000..82b987a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-performance-analyzer/references/logging_config.md
@@ -0,0 +1,14 @@
+# Cloud Logging Configuration
+
+## Log Bucket Requirements
+- **Name Pattern**: Must start with `exam_log` (e.g., `exam_log-af5170942c50`)
+- **Access**: Requires write permissions for the service account
+- **Retention**: Typically 30 days (configurable)
+
+## Critical Alert Format
+
+### Log Entry Structure
+- **Log Name**: Use the exact bucket name (e.g., `exam_log-af5170942c50`)
+- **Severity**: `CRITICAL`
+- **Message Template**:
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/SKILL.md b/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/SKILL.md
new file mode 100644
index 0000000..94958f8
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/SKILL.md
@@ -0,0 +1,41 @@
+---
+name: academic-profile-publication-updater
+description: When the user needs to update their academic profile website with new publications, particularly when they mention specific research papers (like arXiv articles) that need to be added to their publications list. This skill handles the complete workflow analyzing the existing website structure, searching for paper details in arXiv/local storage, understanding the publication format used by the site (Jekyll-based academic pages), and properly formatting new entries to match the existing style with correct author formatting, venue information, links, and bullet-pointed contributions. It's triggered by requests involving 'update profile', 'add publications', 'upload articles', or when users mention specific paper titles they want to include in their academic portfolio.
+---
+# Instructions
+
+## 1. Understand the Request
+- The user will mention they have uploaded or want to add specific publications to their academic profile.
+- Identify the paper titles or arXiv IDs mentioned (e.g., "B-STaR", "SimpleRL-Zoo").
+- Clarify if they want to update a specific file (like `about.md`) or the publications collection.
+
+## 2. Analyze the Existing Website Structure
+- First, navigate to the user's profile website URL (usually derived from the repository name or config).
+- Use the browser tool to snapshot the live site and examine the **current publications section**.
+- Pay close attention to:
+ - The exact Markdown formatting used (headings, bold titles, line breaks).
+ - How author lists are formatted (especially co-first author notation `*` and underlining `<ins>`).
+ - The structure of venue/year information.
+ - How links are formatted (`[[arxiv]]`, `[[github]]`, etc.).
+ - How bullet-pointed contributions are written.
+
+## 3. Locate the Local Repository
+- Use `filesystem-list_directory` to explore the workspace.
+- Look for common academic website structures (Jekyll, Hugo, etc.).
+- Identify the main content directory (often `_pages`, `content`, or root).
+- Find the file that needs updating (commonly `about.md`, `index.md`, or `_pages/publications.md`).
+
+## 4. Search for Paper Details
+- Use `arxiv_local-search_papers` with the paper titles or relevant keywords.
+- If not found locally, use `arxiv_local-download_paper` with known arXiv IDs.
+- Extract key details: **title**, **authors**, **abstract**, **published date**, **arXiv URL**, **categories**.
+- If the paper is not on arXiv, use `local-web_search` to find official publication venues (e.g., "ICLR 2025", "COLM 2025").
+
+## 5. Examine the Local File's Current State
+- Read the target Markdown file.
+- Compare its content with the **live website snapshot**. The live site is the source of truth for formatting.
+- Note any discrepancies (the local file may be outdated).
+
+## 6. Format the New Publication Entry
+**CRITICAL:** Match the **exact formatting** observed on the live website.
+General pattern observed:
diff --git a/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/assets/template_entry.md b/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/assets/template_entry.md
new file mode 100644
index 0000000..bd55fdf
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/assets/template_entry.md
@@ -0,0 +1,6 @@
+**{Paper Title}** \\\\\\\\\\n
+{Author1} *, *<ins>{User Name}</ins>* *, {Author2} *, {Author3} \\\\\\\\\\n
+{VENUE} {YEAR}. [[arxiv]]({arxiv_url}) [[github]]({github_url}) [[Hugging Face]]({hf_url})
+* {First key contribution ending with period}
+* {Second key contribution ending with period}
+* {Third key contribution ending with period}
diff --git a/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/assets/venue_abbreviations.md b/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/assets/venue_abbreviations.md
new file mode 100644
index 0000000..e91da75
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/assets/venue_abbreviations.md
@@ -0,0 +1,32 @@
+# Common Conference Venue Abbreviations
+
+## AI/ML Conferences
+- ICLR: International Conference on Learning Representations
+- ICML: International Conference on Machine Learning
+- NeurIPS: Conference on Neural Information Processing Systems
+- COLM: Conference on Lifelong Learning Agents
+- AAAI: Association for the Advancement of Artificial Intelligence
+- ACL: Association for Computational Linguistics
+- EMNLP: Empirical Methods in Natural Language Processing
+- NAACL: North American Chapter of the ACL
+
+## Computer Science
+- CVPR: Computer Vision and Pattern Recognition
+- ICCV: International Conference on Computer Vision
+- ECCV: European Conference on Computer Vision
+- SIGGRAPH: Special Interest Group on Computer Graphics
+- OSDI: Operating Systems Design and Implementation
+- SOSP: Symposium on Operating Systems Principles
+
+## Journal Formats
+- Journal of Machine Learning Research (JMLR)
+- Transactions on Machine Learning Research (TMLR)
+- IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI)
+- International Journal of Computer Vision (IJCV)
+
+## Formatting Rules
+1. Use ALL CAPS for short abbreviations (ICLR, ICML, CVPR)
+2. Use Title Case for longer names (Conference on Lifelong Learning Agents)
+3. Include year with period: "ICLR 2025."
+4. For tracks: "NeurIPS 2023 (Datasets and Benchmarks track)."
+5. For arXiv only: "arXiv preprint." or "Preprint."
diff --git a/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/references/formatting_guide.md b/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/references/formatting_guide.md
new file mode 100644
index 0000000..33ba535
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/references/formatting_guide.md
@@ -0,0 +1,3 @@
+# Jekyll Academic Pages Publication Formatting Guide
+
+## Observed Format (from trajectory)
diff --git a/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/references/workflow_checklist.md b/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/references/workflow_checklist.md
new file mode 100644
index 0000000..202d8e5
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-profile-publication-updater/references/workflow_checklist.md
@@ -0,0 +1,58 @@
+# Academic Profile Update Checklist
+
+## Trigger Conditions
+- [ ] User mentions "update profile", "add publication", "upload article"
+- [ ] Specific paper titles or arXiv IDs are mentioned
+- [ ] Request involves academic/portfolio website
+
+## Step-by-Step Verification
+
+### 1. Initial Analysis
+- [ ] Identified target papers (B-STaR, SimpleRL-Zoo, etc.)
+- [ ] Located user's website URL
+- [ ] Determined which file needs updating (about.md, publications.md, etc.)
+
+### 2. Research Phase
+- [ ] Searched arXiv local storage for papers
+- [ ] Downloaded missing papers if needed
+- [ ] Extracted: title, authors, abstract, date, URL, venue
+- [ ] Verified publication venue (ICLR, COLM, etc.)
+
+### 3. Format Analysis
+- [ ] Snapshot of live website publications section
+- [ ] Examined exact formatting patterns:
+ - [ ] Title formatting (bold, line breaks)
+ - [ ] Author list (co-first *, user <ins>)
+ - [ ] Venue/year format
+ - [ ] Link formatting [[label]](url)
+ - [ ] Bullet point style
+- [ ] Compared local file vs live site
+
+### 4. Content Creation
+- [ ] Formatted title correctly
+- [ ] Author list with proper * and <ins> tags
+- [ ] Venue/year with period
+- [ ] All relevant links included
+- [ ] 3 bullet points summarizing contributions
+- [ ] Used exact line break format (\\\\\\\\\\n)
+
+### 5. File Update
+- [ ] New entries placed at top (most recent first)
+- [ ] Maintained existing formatting
+- [ ] Preserved all original content
+- [ ] No extra blank lines introduced
+- [ ] For collections: created proper YAML frontmatter
+
+### 6. Final Verification
+- [ ] Re-read updated file
+- [ ] Checked for Markdown syntax errors
+- [ ] Confirmed only requested papers were added
+- [ ] Provided summary to user
+
+## Common Pitfalls to Avoid
+- Using wrong line break format (must be \\\\\\\\\\n)
+- Forgetting the period after venue/year
+- Incorrect author formatting (missing * or <ins>)
+- Adding extra publications not requested
+- Breaking existing formatting in the file
+- Using wrong venue abbreviation
diff --git a/skills/benchmark_skills/toolathlon/academic-publication-status-updater/SKILL.md b/skills/benchmark_skills/toolathlon/academic-publication-status-updater/SKILL.md
new file mode 100644
index 0000000..728a8a2
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-publication-status-updater/SKILL.md
@@ -0,0 +1,62 @@
+---
+name: academic-publication-status-updater
+description: When the user needs to update their academic homepage with recent paper acceptance information and code repository links. This skill scans email notifications for paper acceptance confirmations, identifies papers marked as 'preprint' or 'under review' on the user's GitHub-hosted homepage, updates their status to 'accepted', and adds corresponding GitHub repository links for code open-sourcing. It handles conference notifications (COML, COAI, COLM, etc.), workshop papers, and oral presentation selections. Triggers include requests to 'update homepage papers', 'add acceptance information', 'link code repositories', or 'sync paper status from emails'.
+---
+# Instructions
+
+## Goal
+Update the user's academic homepage (hosted on GitHub) by:
+1. Identifying papers currently marked as "preprint" or "under review".
+2. Checking the user's emails for acceptance notifications for those papers.
+3. Updating the paper's status on the homepage from "under review" to "accepted" (including specific conference/venue details).
+4. For accepted papers, checking if a corresponding code repository exists on the user's GitHub and adding a link to it on the homepage.
+
+## Core Workflow
+
+### 1. Initial Discovery & Setup
+* Use `github-get_me` to confirm the user's GitHub identity and profile.
+* Use `github-search_repositories` with the user's username to find their homepage repository (typically named something like `My-Homepage`, `personal-website`, `academic-kickstart`, or containing `_publications/` or `_posts/` directories). Also note other repositories that might contain paper code.
+* Use `emails-get_emails` or `emails-search_emails` to fetch recent emails. Look for keywords like "accepted", "camera-ready", "congratulations", and conference names (COML, COAI, ICML, NeurIPS, etc.).
+
+### 2. Analyze Homepage Publications
+* Navigate to the homepage repository's `_publications/`, `_posts/`, or similar directory using `github-get_file_contents`.
+* Read the Markdown or YAML files for each publication.
+* **Identify Target Papers**: Parse the `venue` field. Flag any paper where the venue contains phrases like "Under review at", "preprint", "arXiv", or "submitted to".
+
+### 3. Cross-Reference with Emails
+* For each target paper, extract its title and suspected conference name.
+* Search through the fetched emails for matches. **Key email indicators**:
+ * Subject lines containing "accepted", "camera-ready", or the conference name.
+ * Email body containing the paper's title or clear congratulations.
+ * Specific details like "oral presentation" or "workshop".
+* Use `emails-read_email` on promising emails to get full details and confirm acceptance.
+
+### 4. Map Code Repositories
+* From the initial repository search, create a mapping. Repository names often contain keywords from paper titles (e.g., "llm-adaptive-learning", "optimizing-llms-contextual-reasoning").
+* For each **accepted** paper, try to find a matching repository by comparing sanitized paper titles/keywords with repository names.
+
+### 5. Execute Updates
+* For each accepted paper, prepare an updated publication file.
+ * Change the `venue` field from "Under review at X" to "X" or "X (Oral)".
+ * **If a matching code repository was found**, add or update a `codeurl:` field in the frontmatter with the GitHub URL (e.g., `https://github.com/<username>/<repo-name>`).
+* Use `github-get_file_contents` to get the current file's SHA.
+* Use `github-create_or_update_file` to commit the changes with a descriptive message (e.g., "Update paper status: [Paper Title] accepted at [Conference], add code repository link").
+
+## Key Decision Points & Heuristics
+* **Conference Name Extraction**: When updating the `venue` field, remove "Under review at " or "Submitted to ". Use the full conference name from the email (e.g., "COML 2025 - Conference on Machine Learning").
+* **Oral Presentations**: If an email specifies "oral presentation", append " (Oral)" to the venue.
+* **Workshop Papers**: Treat workshop acceptances (e.g., COMLW) as standard acceptances.
+* **Code Repository Matching**: Be flexible. Match on key terms (ignore "the", "for", "a", hyphens, spaces). A repository like `optimizing-llms-contextual-reasoning` clearly matches a paper titled "Optimizing Large Language Models for Contextual Reasoning...".
+* **Email Search Strategy**: If an initial targeted search (`"paper accepted"`) fails, fall back to fetching a broader batch of emails and scanning them manually.
+
+## Error Handling & Validation
+* **SHA Mismatch**: If `github-create_or_update_file` fails with a 409 error, refetch the file to get the latest SHA and retry.
+* **No Homepage Found**: If no obvious homepage repo is found, list the user's repositories and ask for clarification.
+* **Ambiguous Email**: If an email's acceptance is not explicit, do not update the paper. It's better to be conservative.
+* **No Matching Code Repo**: It's acceptable. Only add the `codeurl` if a clear match is found.
+
+## Final Output
+Provide the user with a summary of changes made:
+* List each paper updated, its new status, and conference.
+* List any code repository links added.
+* Note any papers that remain under review because no acceptance email was found.
diff --git a/skills/benchmark_skills/toolathlon/academic-publication-status-updater/references/email_keywords.md b/skills/benchmark_skills/toolathlon/academic-publication-status-updater/references/email_keywords.md
new file mode 100644
index 0000000..8a3582b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-publication-status-updater/references/email_keywords.md
@@ -0,0 +1,36 @@
+# Email Keywords for Paper Acceptance
+
+Use these keywords to search and identify acceptance emails.
+
+## Primary Search Queries
+* "accepted"
+* "camera-ready"
+* "congratulations"
+* "notification"
+* "decision"
+
+## Conference & Venue Identifiers
+* COML (Conference on Machine Learning)
+* COAI (Conference on Artificial Intelligence)
+* COLM (Conference on Language Modeling)
+* ICML (International Conference on Machine Learning)
+* NeurIPS (Neural Information Processing Systems)
+* ICLR (International Conference on Learning Representations)
+* ACL (Association for Computational Linguistics)
+* EMNLP (Empirical Methods in Natural Language Processing)
+* CVPR (Computer Vision and Pattern Recognition)
+* ICCV (International Conference on Computer Vision)
+* ECCV (European Conference on Computer Vision)
+* AAAI (Association for the Advancement of Artificial Intelligence)
+* IJCAI (International Joint Conference on Artificial Intelligence)
+* Workshop / Workshop on
+
+## Key Phrases in Email Body
+* "We are pleased to inform you"
+* "has been accepted"
+* "Your submission was successful"
+* "top % of submissions"
+* "oral presentation"
+* "poster presentation"
+* "Please prepare your camera-ready version"
+* "deadline for the final version"
diff --git a/skills/benchmark_skills/toolathlon/academic-publication-status-updater/references/publication_frontmatter.md b/skills/benchmark_skills/toolathlon/academic-publication-status-updater/references/publication_frontmatter.md
new file mode 100644
index 0000000..f1c15cc
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-publication-status-updater/references/publication_frontmatter.md
@@ -0,0 +1,5 @@
+# Academic Homepage Publication Format (Frontmatter)
+
+This is a typical YAML frontmatter structure for academic pages (based on popular templates like academicpages, al-folio).
+
+## Standard Fields
diff --git a/skills/benchmark_skills/toolathlon/academic-researcher-matcher/SKILL.md b/skills/benchmark_skills/toolathlon/academic-researcher-matcher/SKILL.md
new file mode 100644
index 0000000..3d44995
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-researcher-matcher/SKILL.md
@@ -0,0 +1,114 @@
+---
+name: academic-researcher-matcher
+description: When the user needs to find academic researchers or professors matching specific criteria (research field, institution location, publication metrics, conference activity). This skill analyzes user requirements, searches conference publication data (like CVPR, NeurIPS, ICML), identifies top authors by paper count, filters by research domain and institutional affiliation, and returns ranked matches. Triggers include 'find researchers', 'match professors', 'postdoctoral position', 'academic mentor', 'CVPR/NeurIPS/ICML papers', 'research field matching', 'university preference', 'publication count'.
+---
+# Skill: Academic Researcher Matcher
+
+## Core Purpose
+Help users identify top academic researchers (professors, postdoctoral supervisors) who match their specific career and research needs by analyzing recent high-impact conference publications.
+
+## Primary Use Case
+A doctoral student or early-career researcher seeking postdoctoral positions or academic mentors needs to find professors who:
+1. Are active in their specific research field
+2. Are affiliated with preferred institutions/locations
+3. Have strong publication records at top conferences
+4. Could be potential supervisors or collaborators
+
+## Typical User Inputs
+- Research field/area (e.g., "visual generative models", "diffusion models", "video generation")
+- Location preferences (e.g., "Hong Kong universities", "US West Coast")
+- Career stage (e.g., "postdoctoral position", "PhD supervisor")
+- Conference focus (e.g., "CVPR 2025", "NeurIPS", "ICML")
+- Output requirements (e.g., "top 3 matches", "save to file")
+
+## Execution Workflow
+
+### Phase 1: Understand User Requirements
+1. **Read user's personal information** (if provided in workspace files like `personal_info.md`)
+ - Extract research interests, career goals, location preferences
+ - Note specific technical terms and keywords
+
+2. **Clarify search criteria**
+ - Conference/year (e.g., CVPR 2025)
+ - Number of top researchers needed
+ - Output format requirements
+ - Any additional filters (institution type, professor rank, etc.)
+
+### Phase 2: Gather Conference Publication Data
+3. **Search for conference paper lists**
+ - Use official conference websites (cvpr.thecvf.com, papers.nips.cc, etc.)
+ - Alternative sources: papercopilot.com, Open Access repositories
+ - Search queries: "[Conference] [Year] Accepted Papers"
+
+4. **Extract structured data**
+ - Paper titles, authors, affiliations
+ - Session information, poster numbers
+ - Author ordering and institutional affiliations
+
+### Phase 3: Analyze and Filter Researchers
+5. **Identify top authors by paper count**
+ - Parse author lists from multiple papers
+ - Count publications per researcher
+ - Rank researchers by publication volume
+
+6. **Filter by research domain**
+ - Match paper titles/abstracts against user's research keywords
+ - Focus on relevant subfields (e.g., diffusion models, video generation)
+ - Exclude unrelated research areas
+
+7. **Filter by institutional affiliation**
+ - Check author affiliations against location preferences
+ - Verify university/department information
+ - Prioritize professors (Associate/Full Professor titles)
+
+### Phase 4: Validate and Research Details
+8. **Verify researcher profiles**
+ - Search for professor homepages, Google Scholar profiles
+ - Confirm research focus matches user interests
+ - Check current position and availability
+
+9. **Cross-reference with additional sources**
+ - University department websites
+ - Research lab pages
+ - Recent publications beyond the target conference
+
+### Phase 5: Present Results
+10. **Compile final list**
+ - Rank by match quality (publication count + research relevance + location match)
+ - Include supporting evidence (paper counts, specific relevant papers)
+ - Note any caveats or limitations
+
+11. **Format output as requested**
+ - Simple list format (e.g., one name per line)
+ - More detailed profiles if requested
+ - Save to specified file location
+
+## Key Tools and Techniques
+- **Web Search**: For finding conference paper lists and researcher profiles
+- **HTML/Markdown Parsing**: To extract structured data from conference websites
+- **Pattern Matching**: To identify research domain keywords in paper titles
+- **Data Aggregation**: To count publications per researcher
+- **Validation**: Cross-checking across multiple sources
+
+## Common Challenges and Solutions
+1. **Incomplete author lists**: Use multiple data sources, prioritize official conference pages
+2. **Name disambiguation**: Check affiliations and research focus to distinguish researchers with common names
+3. **Research domain matching**: Use specific technical terms from user's description
+4. **Affiliation verification**: Check university websites for current faculty listings
+5. **Data volume**: Start with sample data, then expand to full dataset as needed
+
+## Output Examples
+- Simple list: `Researcher Name\nResearcher Name\nResearcher Name`
+- Detailed format: `Name (Institution) - X papers at [Conference] [Year] - Research: [Keywords]`
+
+## Quality Checks
+- Verify each researcher is actually a professor/supervisor (not student/postdoc)
+- Confirm research alignment with user's stated interests
+- Check that location preferences are met
+- Ensure publication counts are accurate
+
+## Notes for Implementation
+- Be conservative in matching - better to have fewer high-quality matches than many poor ones
+- When in doubt, prioritize researchers with clear professor titles and established labs
+- Consider both publication quantity and research relevance
+- Remember the user's ultimate goal: finding a suitable postdoctoral supervisor or academic mentor
diff --git a/skills/benchmark_skills/toolathlon/academic-researcher-matcher/references/conference_sources.md b/skills/benchmark_skills/toolathlon/academic-researcher-matcher/references/conference_sources.md
new file mode 100644
index 0000000..62ba4ca
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-researcher-matcher/references/conference_sources.md
@@ -0,0 +1,70 @@
+# Conference Publication Data Sources
+
+## Primary Sources (Official)
+### CVPR (Computer Vision and Pattern Recognition)
+- **Main site**: https://cvpr.thecvf.com/
+- **Accepted papers**: https://cvpr.thecvf.com/Conferences/[YEAR]/AcceptedPapers
+- **Open Access**: https://openaccess.thecvf.com/CVPR[YEAR]
+- **Virtual site**: https://cvpr.thecvf.com/virtual/[YEAR]/papers.html
+
+### NeurIPS (Neural Information Processing Systems)
+- **Main site**: https://nips.cc/
+- **Proceedings**: https://papers.nips.cc/
+- **Current year**: https://papers.nips.cc/paper_files/paper/[YEAR]
+
+### ICML (International Conference on Machine Learning)
+- **Main site**: https://icml.cc/
+- **Proceedings**: https://proceedings.mlr.press/
+- **Current year**: https://proceedings.mlr.press/v[VOLUME]/
+
+### ICLR (International Conference on Learning Representations)
+- **Main site**: https://iclr.cc/
+- **OpenReview**: https://openreview.net/group?id=ICLR.cc/[YEAR]/Conference
+
+## Secondary/Aggregator Sources
+### Paper Copilot
+- **CVPR lists**: https://papercopilot.com/paper-list/cvpr-paper-list/cvpr-[YEAR]-paper-list/
+- **Statistics**: https://papercopilot.com/statistics/cvpr-statistics/cvpr-[YEAR]-statistics
+
+### Open Access Repositories
+- **CVF Open Access**: https://openaccess.thecvf.com/
+- **PMLR Proceedings**: https://proceedings.mlr.press/
+
+### GitHub Collections
+- **Top papers lists**: Often found on GitHub (e.g., SkalskiP/top-cvpr-2025-papers)
+- **Community collections**: Search for "[CONFERENCE] [YEAR] papers GitHub"
+
+## Search Strategies
+### For finding paper lists:
+- "[CONFERENCE] [YEAR] accepted papers"
+- "[CONFERENCE] [YEAR] paper list"
+- "[CONFERENCE] [YEAR] proceedings"
+
+### For researcher information:
+- "[Researcher Name] [University] homepage"
+- "[Researcher Name] Google Scholar"
+- "[University] [Department] faculty"
+
+## Data Extraction Patterns
+### From CVPR HTML:
+- Paper titles: `<strong>` tags or `<a>` tags with links
+- Authors: `<i>` tags within `indented` divs
+- Affiliations: Usually in author lists, may need separate lookup
+- Session info: "Poster Session X" or "Oral" tags
+
+### From Paper Copilot:
+- Metadata in JavaScript variables (look for `var meta = {...}`)
+- Author statistics in structured format
+- Affiliation data with counts
+
+## Verification Sources
+### Researcher Profiles:
+- University faculty pages
+- Google Scholar profiles
+- Research lab websites
+- LinkedIn (for current position)
+
+### Institution Information:
+- University department websites
+- Campus location information
+- Faculty directories
diff --git a/skills/benchmark_skills/toolathlon/academic-researcher-matcher/references/research_keywords.md b/skills/benchmark_skills/toolathlon/academic-researcher-matcher/references/research_keywords.md
new file mode 100644
index 0000000..2b95762
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/academic-researcher-matcher/references/research_keywords.md
@@ -0,0 +1,126 @@
+# Research Domain Keywords for Matching
+
+## Visual Generative Models (Primary Category)
+### Diffusion Models
+- diffusion model
+- denoising diffusion
+- score-based
+- latent diffusion
+- stable diffusion
+- diffusion transformer
+- score matching
+
+### Flow Matching
+- flow matching
+- continuous normalizing flows
+- neural ODE
+- probability flow
+- rectified flow
+
+### Video Generation
+- video generation
+- text-to-video
+- video synthesis
+- temporal consistency
+- video diffusion
+- motion generation
+- long video generation
+
+### Cross-modal Generation
+- text-to-image
+- image-to-text
+- cross-modal
+- multi-modal generation
+- vision-language
+- CLIP-guided
+- T2I (text-to-image)
+- I2T (image-to-text)
+
+### Controllable Generation
+- controllable generation
+- conditional generation
+- style transfer
+- attribute editing
+- semantic control
+- guidance scale
+- classifier-free guidance
+
+### 3D Generation
+- 3D generation
+- NeRF (Neural Radiance Fields)
+- 3D reconstruction
+- novel view synthesis
+- 3D diffusion
+- Gaussian splatting
+
+## Related Computer Vision Areas
+### Image Generation
+- GAN (Generative Adversarial Network)
+- VAE (Variational Autoencoder)
+- autoregressive models
+- transformer-based generation
+
+### Image/Video Editing
+- inpainting
+- outpainting
+- image editing
+- video editing
+- style transfer
+- object removal
+
+### Representation Learning
+- self-supervised learning
+- contrastive learning
+- representation learning
+- pre-training
+- foundation models
+
+## Conference-Specific Patterns
+### CVPR Paper Titles Often Include:
+- Technical method names (e.g., "VideoDPO", "SANA-Video", "MotionCtrl")
+- "Towards..." for exploratory work
+- "A Survey of..." for review papers
+- "[Method]: [Description]" format
+- Acronyms followed by explanations
+
+### NeurIPS/ICML Patterns:
+- More theoretical/methodological focus
+- "Learning", "Optimization", "Theory" in titles
+- Mathematical formulations
+- Algorithm development
+
+## Filtering Strategies
+### Positive Signals (Include):
+- Papers with generative/diffusion/keywords in title
+- Authors with multiple papers in the domain
+- Clear professor titles (Prof., Associate Prof., Assistant Prof.)
+- Established research labs/groups
+
+### Negative Signals (Exclude or Verify):
+- Student authors (Ph.D. candidates)
+- Industry researchers (unless specified)
+- Unrelated research areas (robotics, medical imaging without generative focus)
+- One-off papers in the domain
+
+## University/Title Patterns
+### Professor Titles:
+- Professor
+- Associate Professor
+- Assistant Professor
+- Chair Professor
+- Distinguished Professor
+
+### Research Positions:
+- Research Scientist (may be industry)
+- Postdoctoral Researcher (not supervisor)
+- Research Assistant Professor
+- Lecturer (may not have research group)
+
+### Department Patterns:
+- Computer Science
+- Electrical Engineering
+- Computer Engineering
+- Data Science
+- Artificial Intelligence
+- Multimedia Laboratory
+- Vision Lab
diff --git a/skills/benchmark_skills/toolathlon/agentic-reasoning-paper-specialist/SKILL.md b/skills/benchmark_skills/toolathlon/agentic-reasoning-paper-specialist/SKILL.md
new file mode 100644
index 0000000..d738108
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/agentic-reasoning-paper-specialist/SKILL.md
@@ -0,0 +1,43 @@
+---
+name: agentic-reasoning-paper-specialist
+description: When the user is specifically looking for research papers related to agentic reasoning, autonomous agents, or generalist AI agents. This skill has domain knowledge about key papers, authors, and trends in agentic reasoning research, can identify relevant papers from search results, and understands terminology like 'self-evolving agents', 'MCPs (Model Context Protocols)', and benchmark datasets like GAIA. Triggers include queries about 'agentic reasoning papers', 'AI agents research', 'generalist agents', or specific paper titles containing terms like 'Alita', 'AutoAgent', or 'GAIA benchmark'.
+---
+# Instructions for Agentic Reasoning Paper Specialist
+
+You are an expert research assistant specialized in the field of agentic reasoning, autonomous AI agents, and generalist AI systems. Your primary function is to help users find, retrieve, and summarize relevant academic papers from arXiv.
+
+## Core Workflow
+
+1. **Interpret the Query:** Understand the user's request. Common patterns include:
+ * Looking for a specific, vaguely remembered paper (e.g., "title contains 'Alita', published before June 2025").
+ * Requesting an overview of recent papers on agentic reasoning.
+ * Asking for papers related to specific concepts (e.g., self-evolving agents, GAIA benchmark, MCPs).
+
+2. **Execute Targeted Search:** Use the `arxiv_local-search_papers` tool with intelligent query formulation.
+ * For specific papers: Use exact title keywords (e.g., `"Alita"`).
+ * For broader topics: Combine terms (e.g., `"agentic reasoning"`, `"generalist agent"`, `"self-evolving agent"`).
+ * Filter results mentally by date if the user provides a timeframe.
+
+3. **Analyze & Filter Results:** Examine the search results to identify the most relevant paper(s). Apply your domain knowledge:
+ * Recognize key authors and research groups in the field.
+ * Identify papers about benchmarks like GAIA, MathVista, PathVQA.
+ * Distinguish between highly relevant agent papers and tangentially related results (e.g., quantum computing papers with author name "Aolita" vs. the AI agent "Alita").
+
+4. **Retrieve and Deliver:** For the identified target paper:
+ * Use `arxiv_local-download_paper` to fetch the PDF. Monitor the status with `check_status=true` if needed.
+ * Optionally, use `arxiv_local-read_paper` to extract key metadata (title, authors, abstract) from the downloaded markdown file for verification.
+ * **Rename the downloaded file** according to the user's request (e.g., `alita_{arxiv_id}.pdf`). Use the `filesystem-move_file` tool.
+ * Present the final information in the requested format. Provide:
+ * The full paper title.
+ * The arXiv abstract page URL (format: `https://arxiv.org/abs/{arxiv_id}`).
+ * The code repository link, if mentioned in the paper (commonly found in the abstract or introduction).
+
+## Key Domain Knowledge & Heuristics
+* **"Alita"** refers to a notable generalist agent framework. Be aware of related papers like "Alita-G".
+* **GAIA** is a major benchmark for general-purpose AI assistants.
+* **MCP (Model Context Protocol)** is a standard by Anthropic for connecting AI systems to tools/data.
+* Common relevant categories on arXiv include `cs.AI`, `cs.CL`, `cs.LG`, `cs.CV`.
+* When a user asks for the "latest version," check the arXiv ID for version suffixes (e.g., `v1`, `v2`). The search tool typically returns the latest version. The ID without the suffix (e.g., `2505.20286`) points to the abstract page for the latest version.
+
+## Output Format
+Adhere strictly to the user's requested output format. Typically, this is a plain text, line-separated list without markdown:
diff --git a/skills/benchmark_skills/toolathlon/agentic-reasoning-paper-specialist/references/key_concepts.md b/skills/benchmark_skills/toolathlon/agentic-reasoning-paper-specialist/references/key_concepts.md
new file mode 100644
index 0000000..4724ae2
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/agentic-reasoning-paper-specialist/references/key_concepts.md
@@ -0,0 +1,31 @@
+# Key Concepts in Agentic Reasoning & Generalist Agents
+
+## Core Paradigms
+* **Agentic Reasoning:** The capability of AI systems (typically LLM-based) to autonomously plan, execute, and adapt multi-step tasks using tools and external resources.
+* **Generalist Agent:** An AI agent designed with a unified architecture to handle a wide range of domains and tasks, as opposed to task-specific solutions.
+* **Self-Evolving/Self-Improving Agents:** Agents that can autonomously create, refine, and reuse tools or capabilities (e.g., generating Model Context Protocols) to adapt to new tasks.
+
+## Notable Frameworks & Systems
+* **Alita:** A generalist agent framework emphasizing "minimal predefinition and maximal self-evolution." It uses a web agent and dynamically generates MCPs.
+* **Alita-G:** An extension focused on self-evolving generative agents for agent generation.
+* **OpenAI Deep Research:** An agentic framework for autonomous multi-step research tasks.
+* **OctoTools:** A framework with standardized tool cards for multi-domain tasks.
+* **AutoAgent:** A zero-code platform for creating and deploying LLM-powered agents.
+* **OWL (Optimized Workforce Learning):** A multi-agent framework for real-world task automation.
+* **Smolagents:** A lightweight library for building agentic systems (base for Open Deep Research).
+
+## Key Technologies & Protocols
+* **Model Context Protocol (MCP):** An open protocol (by Anthropic) that standardizes how systems provide context and tools to LLMs. A core enabler for tool reuse and integration.
+* **Tool Creation:** The ability of agents to autonomously generate code scripts or functions to solve specific sub-tasks.
+
+## Important Benchmarks & Datasets
+* **GAIA:** A benchmark for evaluating general-purpose AI assistants with real-world, human-like questions across three difficulty levels.
+* **MathVista:** A benchmark for evaluating mathematical reasoning in visual contexts.
+* **PathVQA:** A medical visual question answering dataset.
+
+## Common arXiv Categories
+* `cs.AI`: Artificial Intelligence
+* `cs.CL`: Computation and Language
+* `cs.LG`: Machine Learning
+* `cs.CV`: Computer Vision and Pattern Recognition
+* `cs.MA`: Multiagent Systems
diff --git a/skills/benchmark_skills/toolathlon/amazon-product-search-recommender/SKILL.md b/skills/benchmark_skills/toolathlon/amazon-product-search-recommender/SKILL.md
new file mode 100644
index 0000000..17787bb
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/amazon-product-search-recommender/SKILL.md
@@ -0,0 +1,32 @@
+---
+name: amazon-product-search-recommender
+description: When the user wants to search for specific products on Amazon within budget constraints and generate structured recommendations. This skill navigates to Amazon.com, performs targeted searches using specific criteria (price range, material, color), browses search results, extracts product details (title, price, store/brand, URL), and compiles recommendations into a structured JSON format. Triggers include requests for product recommendations, shopping assistance, budget-constrained searches, or when users need to find specific items on Amazon with detailed specifications.
+---
+# Skill: Amazon Product Search & Recommender
+
+## Purpose
+Search Amazon for products matching user criteria (budget, material, color, etc.), extract detailed product information, and output structured recommendations in JSON format.
+
+## Core Workflow
+1. **Parse Request:** Identify the product category, budget, material, color, and any other specific constraints from the user's request.
+2. **Navigate & Search:** Go to `https://www.amazon.com`, locate the main search box, and perform a search using a constructed query (e.g., "black leather sofa under 400").
+3. **Browse Results:** Navigate through the search results page to find relevant product listings.
+4. **Extract Details:** For each selected product, click into its detail page to gather accurate information:
+ * **Canonical URL:** The full product page URL.
+ * **Title:** The complete product title.
+ * **Price:** The current selling price (prioritize Prime/sale price if shown).
+ * **Store/Brand Name:** The brand or store name (e.g., from "Visit the [Brand] Store" link).
+5. **Compile & Output:** Format the extracted data into a JSON array matching the required schema and write it to the specified output file (e.g., `recommend.json`).
+
+## Key Instructions & Best Practices
+* **Search Query:** Construct the search query by combining key attributes from the user request (color, material, product type, budget hint).
+* **Element Identification:** Use the `browser_snapshot_search` tool with patterns like `"searchbox"` or `"Search Amazon"` to reliably locate the search input field. Avoid interacting with dropdowns or other elements near the search bar.
+* **Result Navigation:** Use `browser_snapshot_navigate_to_span` and `browser_snapshot_search` (e.g., for `"price"`, `"$"`, product brand names) to move through the search results and identify product links and their details.
+* **Data Accuracy:** Always navigate to the product detail page (`browser_click` on product link) to capture the definitive `canonical_url`, `title`, `price`, and `store_name`. Do not rely solely on snippet data from search results.
+* **Price Extraction:** On the product page, search for price-related patterns (`"\\$"`, `"price"`). The price is often found near elements like "Prime Member Price" or within the buy box. Extract only the numerical price (e.g., "287.99"), not currency symbols or additional text.
+* **Store/Brand Extraction:** Look for a link containing "Visit the ... Store" on the product page. The text between "Visit the " and " Store" is typically the `store_name`.
+* **Error Handling:** If an action fails (e.g., clicking an element), use snapshot search and navigation tools to re-orient and find the correct element reference.
+* **Task Completion:** After writing the final JSON file, read it back to verify its contents and call `local-claim_done`.
+
+## Output Schema
+The final output must be a JSON file (e.g., `recommend.json`) containing an array of objects. Each object must have a `product_info` key containing:
diff --git a/skills/benchmark_skills/toolathlon/amazon-product-search-recommender/references/example_output_schema.md b/skills/benchmark_skills/toolathlon/amazon-product-search-recommender/references/example_output_schema.md
new file mode 100644
index 0000000..a6c31fd
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/amazon-product-search-recommender/references/example_output_schema.md
@@ -0,0 +1,10 @@
+[
+ {
+ "product_info": {
+ "canonical_url": "https://www.amazon.com/SPTA-Cleaning-Trumpet-Pressure-Quickly/dp/B0C5MLSXQH/ref=sr_1_6?dib=eyJ2IjoiMSJ9.4nLB6v7ZvROYYz1bmr1woCfuvr30vMBaW3w8Ncbq1Kn0hIsXUtqSXRcxF15Q6dvo23y6wQiMpg4RXVNrLncWcnQ8b5lPhnbbhTLpL6xu7gz4KPtdr9bRnydY8xTUvwMS2RQ19WComzr1eT0ZU7Q_qGA2uiAXy-iG3Dw9DC4K2FgSfgFrv9WCLVtxOCgKX60f1LGrqIk7fUcj23ZOXIlX07750Lg56Ilukx_7x0MDFQk-HaDFjtEcHKxbCCicMK87vPjaSDe7onz4kIIFkB68h83xkXHx690U1M1mVd2-lvc.N454vG2z1OBhIdonujHdm4lNa5PPrBmVng2RmYm_b20&dib_tag=se&keywords=vortex+dryer&qid=1760506371&sr=8-6",
+ "title": "SPTA Car Cleaning Gun, Car Blow Gun Trumpet Head High Pressure Dryer Blow Gun, Car Cleaning Air Gun Kit, Vortex Air Cleaning Tool for Quickly Blasts Dirt and Dust from Surface",
+ "price": "38.30",
+ "store_name": "SPTA"
+ }
+ }
+]
diff --git a/skills/benchmark_skills/toolathlon/application-materials-submission-handler/SKILL.md b/skills/benchmark_skills/toolathlon/application-materials-submission-handler/SKILL.md
new file mode 100644
index 0000000..624480e
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/application-materials-submission-handler/SKILL.md
@@ -0,0 +1,58 @@
+---
+name: application-materials-submission-handler
+description: When the user needs to submit application materials (for academic programs, jobs, grants, etc.) based on email instructions with specific formatting requirements. This skill handles the complete workflow reading email instructions with submission guidelines, retrieving personal information from memory, organizing files into specified folder structures, processing PDFs (reading content, merging multiple files), creating directory hierarchies, compressing folders into ZIP files, and sending formatted emails with attachments to specified recipients.
+---
+# Instructions
+
+## 1. Understand the Request
+- The user will ask you to submit application materials based on email instructions.
+- The request typically references an email from a specific sender (e.g., "kaiming") containing submission guidelines.
+- The subject line for the outgoing email is often specified (e.g., `PhD Application Materials Submission (Student ID: {studentid})`).
+- The user's personal information is stored in memory.
+
+## 2. Retrieve Essential Information
+- **Search for the instruction email**: Use `emails-search_emails` with a query (e.g., sender name or relevant keywords) to find the email containing submission guidelines.
+- **Read the instruction email**: Use `emails-read_email` to get the full content. Extract:
+ - Recipient email address for submission (e.g., `[email protected]`).
+ - Required folder structure and naming conventions.
+ - Any specific file processing instructions (e.g., "merge award certificates into a single PDF sorted by date").
+- **Read user's personal information from memory**: Use `memory-read_graph` to get:
+ - Full name.
+ - Student ID (or equivalent identifier).
+ - Other relevant details (email, phone) for the email body.
+
+## 3. Locate and Inspect Source Materials
+- **List the workspace directory**: Use `filesystem-list_directory` to see available files.
+- **Examine key files if needed**:
+ - For recommendation letters: Use `pdf-tools-read_pdf_pages` to extract professor names from the first page for correct renaming.
+ - For award certificates: Use `pdf-tools-read_pdf_pages` to confirm dates for sorting.
+
+## 4. Create the Required Folder Structure
+- Construct the root folder name using the user's name and ID without spaces (e.g., `Application_Materials_MaryCastillo_2201210606`).
+- Create the full directory hierarchy as specified in the instructions using `terminal-run_command` with `mkdir -p`.
+- Typical structure includes:
+ - `01_Personal_Information/` (ID_Card.pdf, Photo.jpg, Resume.pdf)
+ - `02_Academic_Materials/` with `Awards_Certificates/` subfolder
+ - `03_Recommendation_Letters/`
+ - `04_Supplementary_Materials/`
+
+## 5. Organize and Process Files
+- **Copy files** to their target locations using `terminal-run_command` with `cp`.
+- **Rename files** according to conventions (e.g., `Recommendation_Letter_[ProfessorName]-1.pdf`). Professor names should have no spaces.
+- **Merge PDFs when required**: Use `pdf-tools-merge_pdfs` to combine multiple award certificates into `All_Awards_Certificates.pdf`. Sort by date (ascending).
+- Ensure all files use English names without special characters or spaces.
+
+## 6. Verify and Compress
+- **Verify the structure**: Use `filesystem-directory_tree` to confirm the folder hierarchy and file placement.
+- **Create a ZIP archive**: Use the provided Python script (`scripts/create_zip.py`) if `zip` command is unavailable. The ZIP file should be named after the root folder (e.g., `Application_Materials_MaryCastillo_2201210606.zip`).
+
+## 7. Send the Submission Email
+- Use `emails-send_email` with:
+ - **To**: The recipient email from the instructions.
+ - **Subject**: Exactly as specified, inserting the student ID (e.g., `PhD Application Materials Submission (Student ID: 2201210606)`).
+ - **Body**: A professional email including the user's name, ID, contact information, and a brief description of the attached materials.
+ - **Attachments**: The path to the created ZIP file.
+
+## 8. Finalize
+- Provide a summary to the user confirming the email was sent, the structure created, and any special processing performed.
+- Use `local-claim_done` to indicate task completion.
diff --git a/skills/benchmark_skills/toolathlon/application-materials-submission-handler/references/email_template.md b/skills/benchmark_skills/toolathlon/application-materials-submission-handler/references/email_template.md
new file mode 100644
index 0000000..d9b437e
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/application-materials-submission-handler/references/email_template.md
@@ -0,0 +1,8 @@
+# Email Template for Application Submission
+
+## Subject Line
+- Must match exactly as specified in instructions
+- Typically includes identifier in parentheses: `(Student ID: {studentid})`
+
+## Email Body Structure
+
diff --git a/skills/benchmark_skills/toolathlon/application-materials-submission-handler/references/folder_structure.md b/skills/benchmark_skills/toolathlon/application-materials-submission-handler/references/folder_structure.md
new file mode 100644
index 0000000..f62b885
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/application-materials-submission-handler/references/folder_structure.md
@@ -0,0 +1,12 @@
+# Standard Folder Structure for Application Materials
+
+## Root Folder Naming
+- Format: `Application_Materials_[YourName]_[YourStudentID]`
+- Rules:
+ - No spaces in name
+ - Use English characters only
+ - Replace `[YourName]` with your name without spaces (e.g., "MaryCastillo")
+ - Replace `[YourStudentID]` with your actual student ID
+
+## Standard Directory Hierarchy
+
diff --git a/skills/benchmark_skills/toolathlon/application-materials-submission-handler/references/pdf_processing.md b/skills/benchmark_skills/toolathlon/application-materials-submission-handler/references/pdf_processing.md
new file mode 100644
index 0000000..5572b24
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/application-materials-submission-handler/references/pdf_processing.md
@@ -0,0 +1,25 @@
+# PDF Processing Guidelines
+
+## Reading PDF Content
+Use `pdf-tools-read_pdf_pages` to:
+1. Extract professor names from recommendation letters (read first page)
+2. Verify award certificate dates for sorting
+3. Confirm document contents when filenames are ambiguous
+
+## Merging PDFs
+Use `pdf-tools-merge_pdfs` for:
+- Combining multiple award certificates into `All_Awards_Certificates.pdf`
+- Ensure proper sorting: chronological order (oldest to newest)
+
+### Sorting Logic for Award Certificates:
+1. Extract year from filename or content:
+ - `Outstanding_Student_Award_2021.pdf` → 2021
+ - `Research_Competition_First_Place_2022.pdf` → 2022
+ - `Academic_Excellence_Award_2023.pdf` → 2023
+2. Sort ascending: 2021, 2022, 2023
+3. Merge in sorted order
+
+## Quality Checks
+- Verify all PDFs are readable (not corrupted)
+- Confirm merged PDF contains correct number of pages
+- Ensure text extraction works for key documents
diff --git a/skills/benchmark_skills/toolathlon/application-materials-submission-handler/references/workflow_triggers.md b/skills/benchmark_skills/toolathlon/application-materials-submission-handler/references/workflow_triggers.md
new file mode 100644
index 0000000..9259f5c
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/application-materials-submission-handler/references/workflow_triggers.md
@@ -0,0 +1,29 @@
+# Trigger Phrases for Application Materials Submission
+
+## Primary Triggers
+- "submit application materials"
+- "follow email instructions for submission"
+- "organize files according to guidelines"
+- "send materials to [recipient]"
+
+## Application Type Specific
+- "PhD application"
+- "job application"
+- "grant submission"
+- "scholarship application"
+- "fellowship application"
+
+## Action-Oriented Requests
+- "check my inbox for an email from [sender] about submission"
+- "help me submit the relevant materials"
+- "package my application files"
+- "create the folder structure for my application"
+- "merge my award certificates"
+- "send my application to [email address]"
+
+## Key Indicators
+- References to specific email instructions
+- Mentions of folder structure requirements
+- Requests involving file organization with naming conventions
+- Need to retrieve personal information from memory
+- Requirement to send formatted email with attachments
diff --git a/skills/benchmark_skills/toolathlon/automated-job-application-sender/SKILL.md b/skills/benchmark_skills/toolathlon/automated-job-application-sender/SKILL.md
new file mode 100644
index 0000000..cc66f4c
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/automated-job-application-sender/SKILL.md
@@ -0,0 +1,40 @@
+---
+name: automated-job-application-sender
+description: When the user needs to automatically send job application emails using templates with personalized placeholders and update application status in tracking systems. This skill generates personalized email content from templates with {Company Name}, {Position} placeholders, sends emails to specified contacts, and updates status fields in databases. Triggers include 'send job application email', 'apply for position', 'update status to Applied', 'email template', or when automating job application workflows.
+---
+# Automated Job Application Sender
+
+## Purpose
+Automatically identify qualifying job opportunities from a tracking database, send personalized application emails using templates, and update the application status.
+
+## Core Workflow
+1. **Locate Database**: Find the specified Notion database (e.g., "Job Tracker").
+2. **Filter Entries**: Query for entries with status "Checking".
+3. **Apply Criteria**: Filter candidates based on:
+ - Minimum salary > $3000
+ - Work type: On-site
+ - Position: "software engineer" OR "software manager"
+ - Location within 500 km of a reference point (e.g., UCLA)
+4. **Send Email**: For each qualifying entry:
+ - Generate email from template using `{Company Name}` and `{Position}` placeholders.
+ - Send to the contact email from the database.
+ - Use subject: "Job Application for {Position}"
+5. **Update Status**: Change the entry's status from "Checking" to "Applied".
+
+## Key Instructions
+- **Salary Parsing**: Extract the minimum salary from "Salary Range" fields (e.g., "$4200 - $4800/mo" → 4200). Handle various formats.
+- **Location Filtering**: Use geocoding to get coordinates for company locations and the reference point (UCLA). Calculate distances using the Haversine formula (see `scripts/calculate_distance.py`).
+- **Template**: The default email body is: "Hi {Company Name}, I am Janet Mendoza, I want to apply for the {Position} position..."
+- **Error Handling**: If geocoding fails for a location, log it and skip that entry. Ensure email sending and status updates are atomic per entry (send email, then update status).
+
+## Required Tools
+- `notion-API-post-search`: To find the database/page.
+- `notion-API-post-database-query`: To fetch entries with status "Checking".
+- `notion-API-patch-page`: To update the status to "Applied".
+- `google_map-maps_geocode`: To get coordinates for distance calculations.
+- `emails-send_email`: To send the application email.
+- `local-claim_done`: To signal task completion.
+
+## Configuration Notes
+- The reference location (UCLA) and distance threshold (500 km) are currently hardcoded in the logic. For flexibility, consider making them parameters.
+- The email template and sender name ("Janet Mendoza") are fixed. For customization, see `assets/email_template.txt`.
diff --git a/skills/benchmark_skills/toolathlon/automated-job-application-sender/assets/email_template.txt b/skills/benchmark_skills/toolathlon/automated-job-application-sender/assets/email_template.txt
new file mode 100644
index 0000000..76b8bfd
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/automated-job-application-sender/assets/email_template.txt
@@ -0,0 +1 @@
+Hi {Company Name}, I am Janet Mendoza, I want to apply for the {Position} position...
diff --git a/skills/benchmark_skills/toolathlon/automated-job-application-sender/references/email_template_guide.md b/skills/benchmark_skills/toolathlon/automated-job-application-sender/references/email_template_guide.md
new file mode 100644
index 0000000..8080f81
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/automated-job-application-sender/references/email_template_guide.md
@@ -0,0 +1,3 @@
+# Email Template Guide
+
+## Default Template
diff --git a/skills/benchmark_skills/toolathlon/automated-job-application-sender/references/notion_schema.md b/skills/benchmark_skills/toolathlon/automated-job-application-sender/references/notion_schema.md
new file mode 100644
index 0000000..eed7d50
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/automated-job-application-sender/references/notion_schema.md
@@ -0,0 +1,23 @@
+# Notion Database Schema Reference
+
+## Job Tracker Database
+**Expected Properties:**
+- `Company` (title): Name of the company.
+- `Position` (url): Job position title.
+- `Status` (select): Application status with options: Checking, Applied, Interviewing, Rejected, Pass, Accepted.
+- `Salary Range` (rich_text): Salary information in text format (e.g., "$4200 - $4800/mo").
+- `Location` (rich_text): Company location (e.g., "Los Angeles, US").
+- `Email` (rich_text): Contact email address.
+- `Flexibility` (select): Work arrangement with options: Remote, On-site.
+- `In-touch Person` (rich_text): Contact person name.
+
+## API Usage Notes
+1. **Searching for Database**: Use `notion-API-post-search` with query "Job Tracker" or page name.
+2. **Querying Entries**: Use `notion-API-post-database-query` with filter on `Status` property.
+3. **Updating Status**: Use `notion-API-patch-page` with properties: `{"Status": {"select": {"name": "Applied"}}}`.
+
+## Field Access Patterns
+- Title properties: `properties.Company.title[0].text.content`
+- Rich text properties: `properties.Location.rich_text[0].text.content`
+- Select properties: `properties.Status.select.name`
+- URL properties: `properties.Position.url`
diff --git a/skills/benchmark_skills/toolathlon/bigquery-daily-settlement-processor/SKILL.md b/skills/benchmark_skills/toolathlon/bigquery-daily-settlement-processor/SKILL.md
new file mode 100644
index 0000000..7e39f81
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/bigquery-daily-settlement-processor/SKILL.md
@@ -0,0 +1,29 @@
+---
+name: bigquery-daily-settlement-processor
+description: When the user needs to perform end-of-day data settlement processing for gaming or analytics platforms using Google BigQuery, this skill handles the complete workflow. It processes daily score data from streaming tables to 1) Generate ranked leaderboards by aggregating player scores and creating date-stamped tables with player rankings, and 2) Update historical player statistics by inserting daily aggregated metrics into master tracking tables. Key triggers include 'end-of-day settlement', 'daily leaderboard generation', 'player statistics update', 'BigQuery data processing', 'daily score aggregation', and 'historical stats maintenance'.
+---
+# Instructions
+
+## Goal
+Process end-of-day settlement for a gaming platform by:
+1. **Generating a Daily Leaderboard:** Create a new table named `leaderboard_YYYYMMDD` containing the top 100 players ranked by their total daily score.
+2. **Updating Historical Statistics:** Insert aggregated daily metrics for all players into the master `player_historical_stats` table.
+
+## Prerequisites
+- **Access:** Ensure the AI agent has the necessary permissions to run queries and create/update tables in the target Google BigQuery project and dataset.
+- **Context:** The user request must specify the target date for processing (e.g., "today", "2025-11-26"). If not specified, you must determine the current date.
+
+## Execution Steps
+
+### 1. Initialization & Context Gathering
+- **Identify Dataset:** First, list available datasets to confirm the target dataset (e.g., `game_analytics`) exists.
+- **Inspect Source Table:** Run a sample query on the source streaming table (e.g., `daily_scores_stream`) to understand its schema. **Crucially, always qualify the table name with the dataset (e.g., `dataset.table`)**.
+- **Determine Target Date:** Query the source table to find the latest data date or use the provided date. Confirm this is the date you intend to process.
+
+### 2. Schema Verification
+- **Check Historical Stats Table:** Inspect the `player_historical_stats` table to understand its full column structure. This ensures your INSERT query matches the expected schema.
+
+### 3. Core Processing (Execute Both Queries)
+Run the following two BigQuery operations. Use the confirmed dataset name and target date (formatted as `YYYY-MM-DD`).
+
+**Task 1: Create Daily Leaderboard**
diff --git a/skills/benchmark_skills/toolathlon/bigquery-daily-settlement-processor/references/execution_checklist.md b/skills/benchmark_skills/toolathlon/bigquery-daily-settlement-processor/references/execution_checklist.md
new file mode 100644
index 0000000..b10a587
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/bigquery-daily-settlement-processor/references/execution_checklist.md
@@ -0,0 +1,20 @@
+# Execution Checklist & Common Pitfalls
+
+Use this list to ensure robust execution of the settlement skill.
+
+## Pre-flight Checks
+- [ ] **Dataset Confirmation:** Have you listed datasets and confirmed the target one exists?
+- [ ] **Source Data Inspection:** Have you run `SELECT ... LIMIT` on the fully-qualified source table (`dataset.daily_scores_stream`)?
+- [ ] **Date Confirmation:** Have you explicitly determined the target processing date (e.g., via `CURRENT_DATE()` or user input)?
+- [ ] **Schema Validation:** Have you checked the schema of the `player_historical_stats` table to confirm column names and order?
+
+## Critical Pitfalls to Avoid
+1. **Unqualified Table Names:** Never run a query on `daily_scores_stream` alone. Always use `dataset.daily_scores_stream`.
+2. **Incorrect Date Format:** Ensure the date in the `WHERE` clause uses the ISO format `'YYYY-MM-DD'`. The derived date for the table name should be `'YYYYMMDD'`.
+3. **Schema Mismatch:** The `INSERT` query column list must match the exact schema of `player_historical_stats`. The script generates the correct query.
+4. **Assuming Today's Data:** Do not assume the latest data is for "today". Always verify the `latest_data_date` from the source stream.
+
+## Verification Steps (Post-Execution)
+- [ ] **Leaderboard Created:** Run `SELECT COUNT(*) FROM dataset.leaderboard_YYYYMMDD`. Result should be 100.
+- [ ] **Stats Inserted:** Run `SELECT COUNT(*) FROM dataset.player_historical_stats WHERE date = 'YYYY-MM-DD'`. Result should be > 0.
+- [ ] **Sample Output:** Provide the user with the top 5 rows from the new leaderboard as proof of successful execution.
diff --git a/skills/benchmark_skills/toolathlon/bigquery-daily-settlement-processor/references/table_schemas.md b/skills/benchmark_skills/toolathlon/bigquery-daily-settlement-processor/references/table_schemas.md
new file mode 100644
index 0000000..ff9de6a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/bigquery-daily-settlement-processor/references/table_schemas.md
@@ -0,0 +1,35 @@
+# Table Schema Reference
+
+This document details the expected schemas for tables involved in the daily settlement process, as observed in the execution trajectory.
+
+## Source Table: `daily_scores_stream`
+Stores raw, streaming game score events.
+| Field | Type | Description | Notes |
+| :--- | :--- | :--- | :--- |
+| `timestamp` | TIMESTAMP | UTC timestamp of the game event. | Used to filter by date. |
+| `scores` | RECORD (STRUCT) | A nested structure containing score components. | |
+| `scores.task_score` | INTEGER | Score earned from tasks/completions. | |
+| `scores.online_score` | INTEGER | Score earned from online/engagement metrics. | |
+| `player_region` | STRING | Geographic region of the player (e.g., 'ASIA', 'US', 'EU', 'CN'). | |
+| `game_id` | STRING | Unique identifier for the game session. | |
+| `player_id` | STRING | Unique identifier for the player. | Primary key for aggregation. |
+
+## Target Table: `player_historical_stats`
+Master table storing aggregated daily statistics per player.
+| Field | Type | Description | Notes |
+| :--- | :--- | :--- | :--- |
+| `player_id` | STRING | Unique identifier for the player. | Part of composite primary key with `date`. |
+| `date` | DATE | The date the statistics represent. | Part of composite primary key with `player_id`. |
+| `total_score` | INTEGER | Sum of `task_score` and `online_score` for the player on this date. | Derived field. |
+| `game_count` | INTEGER | Number of distinct game sessions the player participated in on this date. | |
+| `total_task_score` | INTEGER | Sum of all `task_score` values for the player on this date. | |
+| `total_online_score` | INTEGER | Sum of all `online_score` values for the player on this date. | |
+| `player_region` | STRING | The player's region. Assumed constant per day; use `MAX()` in aggregation. | |
+
+## Output Table: `leaderboard_YYYYMMDD`
+Daily snapshot of the top 100 players. Table name is dynamically generated (e.g., `leaderboard_20251126`).
+| Field | Type | Description | Notes |
+| :--- | :--- | :--- | :--- |
+| `player_id` | STRING | Unique identifier for the player. | |
+| `total_score` | INTEGER | The player's aggregated total score for the day. | |
+| `rank` | INT64 | The player's rank for the day (1 is highest). | Calculated using `ROW_NUMBER()`. |
diff --git a/skills/benchmark_skills/toolathlon/bigquery-historical-data-aggregator/SKILL.md b/skills/benchmark_skills/toolathlon/bigquery-historical-data-aggregator/SKILL.md
new file mode 100644
index 0000000..dd62b31
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/bigquery-historical-data-aggregator/SKILL.md
@@ -0,0 +1,31 @@
+---
+name: bigquery-historical-data-aggregator
+description: Aggregates and analyzes historical data from multiple BigQuery tables with similar schemas. Queries multiple tables using UNION ALL, calculates aggregate metrics (averages, sums, counts), handles table discovery via INFORMATION_SCHEMA, and processes large datasets efficiently with batch queries.
+---
+# Instructions
+
+## Core Workflow
+1. **Discover Tables:** First, query `INFORMATION_SCHEMA.TABLES` to identify all available tables within the target dataset. This ensures the skill adapts to the actual table names present.
+2. **Aggregate Historical Data:** Construct a SQL query that uses `UNION ALL` to combine data from all identified tables. Calculate the required aggregate metric (e.g., `AVG(score)`) grouped by the relevant key (e.g., `student_id`, `name`).
+3. **Handle Large Results:** For datasets returning many rows (>50), use a batched querying strategy (e.g., `LIMIT` and `OFFSET` or filtering by key ranges) to retrieve the complete result set without truncation.
+4. **Join with Latest Data:** Read the latest data from the provided source (e.g., a local CSV file). Perform a join between the aggregated historical data and the latest data to enable comparative analysis.
+5. **Calculate Deltas & Filter:** Compute the percentage change or difference between historical and latest values. Apply the user-specified threshold filter (e.g., `drop_percentage > 0.25`).
+6. **Output Results:** Write the filtered results to the specified output file (e.g., `bad_student.csv`).
+7. **Trigger Critical Actions:** For records exceeding a higher, critical threshold (e.g., `drop_percentage > 0.45`), execute immediate actions such as writing critical log entries to a designated logging service.
+
+## Key Techniques
+* **Dynamic Table Inclusion:** Use the list from `INFORMATION_SCHEMA` to build the `UNION ALL` query dynamically. Do not hardcode table names.
+* **Efficient Batch Retrieval:** When the final aggregated list or intermediate results are large, retrieve data in manageable chunks using `WHERE` clauses on sequential keys or `LIMIT/OFFSET`.
+* **Precise Percentage Calculation:** Ensure the percentage change formula is correct: `(historical_value - latest_value) / historical_value`.
+* **Logging for Notification:** When writing critical logs, include all necessary identifiers (e.g., name, ID) and context so downstream systems can trigger alerts or notifications.
+
+## Error Handling & Validation
+* Confirm the target dataset exists before querying.
+* Verify that source files (e.g., CSV) exist and are readable.
+* Validate that the log bucket or destination for critical alerts exists and is accessible.
+
+## Bundled Resources
+* `scripts/aggregate_query_template.sql`: A parameterized SQL template for the core aggregation logic.
+* `references/schema_example.md`: An example schema to illustrate the expected table structure.
+
+---
diff --git a/skills/benchmark_skills/toolathlon/bigquery-historical-data-aggregator/references/schema_example.md b/skills/benchmark_skills/toolathlon/bigquery-historical-data-aggregator/references/schema_example.md
new file mode 100644
index 0000000..237b16e
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/bigquery-historical-data-aggregator/references/schema_example.md
@@ -0,0 +1,19 @@
+# Expected Table Schema Example
+
+For the skill to work correctly, all source tables in BigQuery should share a compatible schema. The following is an example based on the trajectory:
+
+## Table: `scores_2501`, `scores_2502`, ... `scores_2507`
+| Column Name | Data Type | Description |
+|-------------|-----------|-------------|
+| `student_id` | STRING | Unique identifier for the student (e.g., 'S001'). |
+| `name` | STRING | Full name of the student. |
+| `score` | FLOAT | Numerical score for the test/quiz. |
+
+## Key Points
+* **Consistency:** All tables must have the same column names and compatible data types.
+* **Historical Context:** Each table typically represents data from a different time period (e.g., test 1, test 2).
+* **Aggregation Key:** The `student_id` (and often `name`) is used to join and aggregate data across tables.
+* **Metric Column:** The `score` column is the primary numerical metric for aggregation (average, sum, etc.).
+
+## Discovery Query
+Use this query to find all relevant tables in a dataset:
diff --git a/skills/benchmark_skills/toolathlon/candidate-evaluation-report-generator/SKILL.md b/skills/benchmark_skills/toolathlon/candidate-evaluation-report-generator/SKILL.md
new file mode 100644
index 0000000..6bc3fa6
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/candidate-evaluation-report-generator/SKILL.md
@@ -0,0 +1,65 @@
+---
+name: candidate-evaluation-report-generator
+description: Analyzes candidate resumes and interviewer evaluations against specific job requirements, calculates match percentages, and generates standardized Word assessment reports for each candidate, identifying the best match.
+---
+# Skill: Candidate Evaluation Report Generator
+
+## Purpose
+You are an HR automation assistant. Your task is to process candidate application materials, evaluate them against strict job criteria, and produce a set of uniformly formatted assessment documents.
+
+## Core Workflow
+Follow these steps **in order**:
+
+1. **Gather Inputs:** Read the required files from the workspace.
+2. **Analyze Candidates:** Extract data and evaluate each candidate against the provided requirements.
+3. **Generate Reports:** Create a separate, formatted Word document for each candidate.
+4. **Output Recommendation:** Create a final file naming the single best candidate.
+
+## Detailed Instructions
+
+### Phase 1: Read and Parse Input Files
+First, locate and read the following critical files. Their names may vary slightly; use common sense to identify them (e.g., `*resume*.docx`, `*eval*.docx`, `*format*.md`, `*requirement*.txt`).
+- **Formatting Guide (`Format.md`):** Contains the exact template, style specifications (fonts, sizes, colors), and naming convention for the output reports. **You must follow this precisely.**
+- **Candidate Resumes (`Candidates_resumes.docx` or similar):** A Word document containing resumes for all candidates. Parse it to extract structured data for each individual.
+- **Interviewer Evaluations (`Interviewer_evaluation.docx` or similar):** A Word document containing the interview feedback for each candidate. Parse it to extract structured evaluations.
+- **Job Requirements (`Requirement.txt` or similar):** A text file listing the **strict criteria** (e.g., "4+ years experience", "FAANG required"). You will use this to score candidates.
+
+### Phase 2: Evaluate Each Candidate
+For each candidate identified in the resume and evaluation documents:
+1. **Extract Key Data:** Combine information from both their resume and their evaluation.
+2. **Apply Requirements:** Systematically check the candidate's profile against every criterion listed in `Requirement.txt`.
+3. **Calculate Score:** Determine the percentage of requirements the candidate meets. (e.g., 7 out of 10 criteria = 70%).
+4. **Determine Recommendation:** Based on the analysis, identify if this candidate is the **single best match** according to the requirements. Only one candidate can be "Recommended" in the final output.
+
+### Phase 3: Generate Formatted Word Reports
+Create a new Word document for **every candidate**. Use the naming convention specified in `Format.md` (e.g., `Interview_Assessment_Report_<CandidateName>.docx`).
+
+For each document, you **must**:
+1. **Apply Exact Formatting:** Follow all style rules in `Format.md` (headings, fonts, alignment, colors).
+2. **Populate Structure:** Include all specified sections:
+ - **Main Title:** "Candidate Interview Assessment Report" with correct style.
+ - **Candidate Name.**
+ - **"Candidate Information:"** section with data from their resume.
+ - **"Interviewer Evaluation:"** section with data from their evaluation.
+ - **"Evaluation Conclusion:"** section with a 2x2 table.
+3. **Format the Table:** The conclusion table must have:
+ - Gridline borders.
+ - A header row with background color `#D9D9D9`.
+ - A data row with background color `#DAEEF3`.
+ - Cell alignment: Horizontal centered, Vertical top.
+ - **Content:**
+ - Row 1, Col 1: "Overall Assessment"
+ - Row 1, Col 2: "Recommendation"
+ - Row 2, Col 1: The calculated percentage (e.g., "70%"). **Do not add reasoning.**
+ - Row 2, Col 2: Either "Recommended" (for the single best candidate) or "Not recommended". **Do not add reasoning.**
+
+### Phase 4: Create Final Recommendation File
+After all reports are generated, create a plain text file named `recommend.txt` in the workspace.
+- Its **only** content must be the full name of the best candidate (e.g., `John Smith`).
+- Do not include any other text, explanations, or formatting.
+
+## Critical Rules
+- **Strict Formatting Adherence:** The visual format of the output documents is non-negotiable. Match `Format.md` exactly.
+- **One Best Candidate:** Only one candidate receives "Recommended" in their table and is named in `recommend.txt`. If multiple candidates have the same top score, use tie-breakers implicit in the requirements (e.g., more FAANG companies, lower salary).
+- **No Extra Commentary:** The table cells and `recommend.txt` file must contain only the specified data, no sentences or justifications.
+- **Complete Set:** You must generate a report for every candidate found in the source documents.
diff --git a/skills/benchmark_skills/toolathlon/candidate-evaluation-report-generator/references/requirement_analysis_guide.md b/skills/benchmark_skills/toolathlon/candidate-evaluation-report-generator/references/requirement_analysis_guide.md
new file mode 100644
index 0000000..c7966c4
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/candidate-evaluation-report-generator/references/requirement_analysis_guide.md
@@ -0,0 +1,10 @@
+# Candidate Requirement Analysis Guide
+
+## Overview
+This guide details the logical process for evaluating candidates against a set of strict criteria, as demonstrated in the trajectory. The goal is to translate subjective resume/evaluation data into objective, comparable scores.
+
+## Analysis Steps
+
+### 1. Parse Requirement File
+The `Requirement.txt` typically contains a list of "STRICT CRITERIA" that "ALL MUST BE MET" for a perfect score. Each line is a discrete condition.
+Example:
diff --git a/skills/benchmark_skills/toolathlon/canvas-assignment-submission-manager/SKILL.md b/skills/benchmark_skills/toolathlon/canvas-assignment-submission-manager/SKILL.md
new file mode 100644
index 0000000..c3d2bd3
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/canvas-assignment-submission-manager/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: canvas-assignment-submission-manager
+description: Manages assignment submissions on Canvas LMS. Identifies missing submissions from grade records, prepares files with proper naming conventions, and submits assignments. Handles course identification, assignment listing, submission status checking, file preparation, and automated submission.
+---
+# Instructions
+
+## Primary Objective
+Help a forgetful student identify and submit missing Canvas assignments based on a published grade summary, while respecting excused absences.
+
+## Core Workflow
+
+### 1. Initialization & Context Gathering
+- **Read User Memory**: Use `memory-read_graph` to retrieve the student's personal information (Student ID, Email, Name).
+- **Identify Target Course**: Use `canvas-canvas_list_courses` to list all courses. The target course is typically identifiable by name (e.g., "Cinema Culture Appreciation") or code (e.g., "FILM101") mentioned in the user request or grade sheet.
+- **Explore Workspace**: Use `filesystem-list_allowed_directories` and `filesystem-directory_tree` to understand the file structure, locating the grade summary file and potential assignment directories.
+
+### 2. Analyze Submission Status
+- **Locate Grade Summary**: Find the Excel file (e.g., `Cinema_Culture_Grade_Summary.xlsx`) in the workspace. Use `local-python-execute` with pandas to read it.
+- **Parse Grade Data**: Identify the row for the current student (matching Student ID or Name). Extract the status for each assignment ("Not Submitted", a score, or "Excused").
+- **Cross-reference with Canvas**: Use `canvas-canvas_list_assignments` for the target course with `include_submissions: true`. This returns the official list of assignments and the user's current submission status (`workflow_state`).
+- **Determine Actionable Items**: Compare the grade sheet "Not Submitted" status with Canvas's `workflow_state`. Only submit assignments that are **both** marked as missing on the grade sheet **and** have `workflow_state: "unsubmitted"` in Canvas. Respect any user-stated excusals (e.g., "officially excused from Assignment 2").
+
+### 3. Prepare and Submit Assignments
+- **Find Assignment Files**: Search the workspace directory tree (e.g., `homeworks/mine/`) for files whose content matches the assignment descriptions. Use `filesystem-read_multiple_files` to inspect likely candidates.
+- **Enforce Naming Conventions**: Check each assignment's `description` field for specific file naming requirements (e.g., `StudentID_FILM101_Assignment4.md`). If required, create a new file with the correct name using `filesystem-write_file`, copying the content from the found assignment file.
+- **Submit Assignments**: For each missing assignment, use `canvas-canvas_submit_assignment_with_file` with the `course_id`, `assignment_id`, and the path to the correctly named file.
+
+### 4. Handle Administrative Tasks
+- **Locate Supporting Documents**: Find any referenced documents (e.g., "Leave Application.pdf") in the workspace using the directory tree.
+- **Communicate with Instructors**: If instructed, send an email to the relevant TA or instructor (email often found in the grade summary) using `emails-send_email`. Attach the supporting document and clearly state the student's request (e.g., reminder about an excused absence).
+
+## Critical Rules & Guardrails
+- **No Content Creation**: Only submit assignment files that already exist in the workspace. Do not generate new answer content.
+- **Selective Submission**: Only submit assignments identified as missing. Do not re-submit assignments that already have a score or submission.
+- **Data-Driven Decisions**: Base all decisions on data from the official grade sheet and Canvas API, not assumptions.
+- **Preserve User Info**: Use the Student ID, Name, and Email from memory for file naming and communication.
+
+## Error Handling
+- If the grade sheet cannot be parsed, inform the user and halt.
+- If an assignment file cannot be found, do not submit anything for that assignment. Inform the user.
+- If a Canvas API call fails (e.g., course not found), report the error and stop.
+
+## Final Step
+Provide the user with a clear summary of actions taken: which assignments were identified as missing, which were submitted, and any administrative communications sent.
diff --git a/skills/benchmark_skills/toolathlon/canvas-assignment-submission-manager/references/canvas_api_guide.md b/skills/benchmark_skills/toolathlon/canvas-assignment-submission-manager/references/canvas_api_guide.md
new file mode 100644
index 0000000..92b8134
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/canvas-assignment-submission-manager/references/canvas_api_guide.md
@@ -0,0 +1,48 @@
+# Canvas LMS API Guide for Assignment Submission
+
+## Key Endpoints Used
+
+### 1. List Courses
+**Tool**: `canvas-canvas_list_courses`
+**Purpose**: Identify the target course by name or code.
+**Response Fields**:
+- `id`: Course ID (required for subsequent calls)
+- `name`: Course name (e.g., "Cinema Culture Appreciation")
+- `course_code`: Short code (e.g., "FILM101")
+
+### 2. List Assignments with Submissions
+**Tool**: `canvas-canvas_list_assignments`
+**Parameters**:
+- `course_id`: (Required) ID from course listing.
+- `include_submissions`: Set to `true` to get the user's submission status.
+
+**Critical Response Fields**:
+- `id`: Assignment ID (required for submission).
+- `name`: Assignment name (e.g., "Assignment 4: Cinematography and Visual Storytelling").
+- `description`: Often contains file naming instructions.
+- `submission_types`: Array like `["online_upload"]` or `["online_text_entry", "online_upload"]`.
+- `allowed_extensions`: Array like `["md"]` for markdown files.
+- `submission`: An object containing the user's submission status.
+ - `workflow_state`: "unsubmitted", "submitted", "graded", etc.
+ - `score`: The grade if graded.
+ - `submitted_at`: Timestamp of submission.
+
+### 3. Submit Assignment with File
+**Tool**: `canvas-canvas_submit_assignment_with_file`
+**Parameters**:
+- `course_id`: Course ID.
+- `assignment_id`: Assignment ID.
+- `file_path`: Absolute path to the file to upload.
+
+**Success Response**: Contains `workflow_state: "submitted"` and `submitted_at` timestamp.
+
+## Workflow State Interpretation
+- `"unsubmitted"`: No submission exists. Action: Submit if missing per grade sheet.
+- `"submitted"`: Submission exists but not graded. Action: Do not re-submit.
+- `"graded"`: Submission has been graded. Action: Do not re-submit.
+- `"pending_review"`: Submission is under review. Action: Do not re-submit.
+
+## File Naming & Validation
+- Always check the `description` field for instructions like "The upload file should be named as StudentID_FILM101_Assignment4.md".
+- Validate the file extension against `allowed_extensions`.
+- The tool `canvas-canvas_submit_assignment_with_file` handles the actual upload; you only need to provide the correct local file path.
diff --git a/skills/benchmark_skills/toolathlon/canvas-assignment-submission-manager/references/file_naming_templates.md b/skills/benchmark_skills/toolathlon/canvas-assignment-submission-manager/references/file_naming_templates.md
new file mode 100644
index 0000000..1315e0c
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/canvas-assignment-submission-manager/references/file_naming_templates.md
@@ -0,0 +1,39 @@
+# File Naming Convention Templates
+
+## Standard Patterns
+When an assignment description specifies a naming convention, it typically follows one of these patterns:
+
+1. **`{StudentID}_{CourseCode}_Assignment{Number}.{ext}`**
+ - Example: `2201210606_FILM101_Assignment4.md`
+ - Components:
+ - `{StudentID}`: Retrieved from user memory.
+ - `{CourseCode}`: From Canvas course `course_code` (e.g., FILM101).
+ - `{AssignmentNumber}`: Usually found in the assignment `name` (e.g., "Assignment 4").
+ - `{ext}`: Must be one of the `allowed_extensions` (e.g., `md`).
+
+2. **`{StudentID}_{CourseCode}_{AssignmentName}.{ext}`**
+ - Example: `2201210606_FILM101_Cinematography.md`
+ - AssignmentName is a simplified version of the assignment name.
+
+3. **`{LastName}_{FirstName}_Assignment{Number}.{ext}`**
+ - Example: `Edwards_Zachary_Assignment4.md`
+
+## Extraction Logic
+1. Parse the assignment `description` text for phrases like:
+ - "should be named as"
+ - "file should be named"
+ - "upload file should be named"
+ - "name your file as"
+
+2. Use regex to extract the template pattern. Example regex: `(\w+)_(\w+)_Assignment(\d+)\.(\w+)`
+
+3. Replace placeholders with actual data:
+ - Student ID from memory.
+ - Course code from Canvas course data.
+ - Assignment number from assignment name (extract digits after "Assignment ").
+
+## Fallback Strategy
+If no specific naming convention is found in the description:
+1. Use a safe default: `{StudentID}_{AssignmentNameSanitized}.{ext}`
+2. Sanitize the assignment name: remove special characters, replace spaces with underscores.
+3. Example: `2201210606_Cinematography_and_Visual_Storytelling.md`
diff --git a/skills/benchmark_skills/toolathlon/canvas-exam-schedule-compiler/SKILL.md b/skills/benchmark_skills/toolathlon/canvas-exam-schedule-compiler/SKILL.md
new file mode 100644
index 0000000..2bf6e2c
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/canvas-exam-schedule-compiler/SKILL.md
@@ -0,0 +1,61 @@
+---
+name: canvas-exam-schedule-compiler
+description: When the user needs to compile a schedule of upcoming final exams from Canvas LMS, this skill retrieves enrolled courses, scans course announcements for exam information, filters based on date and exam requirements, and populates an Excel spreadsheet with the remaining exams. It handles 1) Fetching user's enrolled courses from Canvas, 2) Retrieving announcements for each course to find exam details, 3) Filtering out courses with no exams, already-ended courses, or exams that have already passed, 4) Processing exam information (dates, times, locations, proctors, exam types), 5) Formatting data into a structured Excel table with proper headers. Key triggers include requests for 'exam schedule', 'final exams', 'Canvas announcements', 'remaining exams', or tasks involving 'exam_schedule.xlsx' files.
+---
+# Instructions
+
+## Primary Objective
+Compile a schedule of remaining final exams by extracting information from Canvas course announcements and populating an Excel file (`exam_schedule.xlsx`).
+
+## Core Workflow
+
+### 1. Initial Setup & File Check
+- **First Action:** Always check if the target Excel file (`exam_schedule.xlsx`) exists in `/workspace/dumps/workspace/`. Use `terminal-run_command` with `ls -la`.
+- **Preserve Headers:** If the file exists, read it to confirm the column structure. The expected headers are:
+ - Course Code
+ - Course Name
+ - Proctor Name
+ - Open-book/Closed-book
+ - Final Date (MM/DD/YYYY)
+ - Start Time (HH:MM)
+ - Duration (minutes)
+ - Location
+ - Information Source(Announcement/Email/Message)
+ - Course Credit
+- **Do not change these headers or the file name.**
+
+### 2. Gather Course Data
+- **Fetch Enrolled Courses:** Use `canvas-canvas_list_courses` to get all courses where the user has a student enrollment.
+- **For Each Course:** Use `canvas-canvas_list_announcements` with the course `id` to retrieve all announcements. Scan the `message` field of each announcement for exam details.
+
+### 3. Extract & Process Exam Information
+For each course, analyze announcements to find:
+- **Final Exam Announcement:** Look for titles containing "Final Exam", "Exam Announcement", or similar. The message typically contains details like Date, Time, Duration, Location, and Exam Type (Open/Closed book).
+- **Proctor Information:** By default, the proctor is the course instructor (first teacher listed in course data). Override this **only** if an announcement explicitly states a different proctor (e.g., "proctor will be replaced by...").
+- **Missing Information:** If any detail (Date, Time, Location) is stated as "to be confirmed", "TBD", or is completely absent, mark the corresponding cell as `TBD`.
+- **No Exam:** If an announcement explicitly states "does not have a final exam" or "no final exam", exclude the entire course from the schedule.
+- **Course Code/Name Formatting:** Remove the "-x" suffix (e.g., "CS101-3" → "CS101", "Introduction to Computer Science-3" → "Introduction to Computer Science").
+
+### 4. Apply Filters
+Exclude a course if **ANY** of the following is true:
+- The course has an `end_at` date that is in the past (relative to the user-provided "today" date).
+- The final exam date has already passed (relative to the user-provided "today" date). If the exam is scheduled for "today", consider the start time; if the time has passed, exclude it.
+- An announcement explicitly states there is no final exam for the course.
+- The user is explicitly exempt (e.g., "students with exemption score... may be exempt"). If exemption is conditional ("may be exempt") and not confirmed for the user, **include** the course.
+
+### 5. Populate the Excel File
+- Use the provided Python script (`scripts/compile_schedule.py`). It handles:
+ - Reading the existing file template.
+ - Applying all filtering logic based on the current date.
+ - Formatting the data correctly (dates as MM/DD/YYYY, times as HH:MM, duration as a number).
+ - Writing the cleaned data back to the same file path.
+- The script is the **single source of truth** for the data processing logic. Refer to it for exact implementation details.
+
+### 6. Verification & Completion
+- After running the script, briefly display the first few rows of the generated file to confirm successful execution.
+- Provide a concise summary to the user: number of courses included, key exclusions, and the location of the output file.
+
+## Important Notes
+- **Email Fallback:** If an announcement mentions exam details were sent via email, check using `emails-search_emails`. If no emails are found, mark the information as `TBD`.
+- **Date Context:** The user will provide the current date (e.g., "today is January 16, 2025"). Use this as the reference for filtering past exams.
+- **Error Handling:** If the Canvas API calls fail, inform the user and suggest checking connectivity. If the Excel file is missing critical headers, report the error before proceeding.
diff --git a/skills/benchmark_skills/toolathlon/canvas-quiz-completion-manager/SKILL.md b/skills/benchmark_skills/toolathlon/canvas-quiz-completion-manager/SKILL.md
new file mode 100644
index 0000000..138d7c0
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/canvas-quiz-completion-manager/SKILL.md
@@ -0,0 +1,43 @@
+---
+name: canvas-quiz-completion-manager
+description: When the user needs to manage and complete multiple quizzes on Canvas LMS, this skill provides automated quiz discovery, question retrieval, answer analysis, and batch submission capabilities. It handles the complete workflow from listing enrolled courses, identifying available quizzes, starting quiz attempts, retrieving questions, analyzing correct answers based on subject matter expertise, and submitting all responses. Key triggers include 'unfinished quizzes', 'complete all quizzes', 'Canvas assignments', 'course assessments', 'submit quizzes', and 'quiz deadlines'. The skill is particularly useful when users have multiple pending quizzes across different courses and need systematic completion with accurate answers.
+---
+# Instructions
+
+## Primary Objective
+Systematically discover, answer, and submit all available/unfinished quizzes for the user across all their enrolled Canvas courses. Ensure all answers are correct and all submissions are successfully completed.
+
+## Core Workflow
+
+### Phase 1: Discovery & Initialization
+1. **List Enrolled Courses:** Use `canvas-canvas_list_courses` to get all courses where the user has a student enrollment (`"type": "student"`). Store the list of course IDs.
+2. **List Available Quizzes:** For each enrolled course, use `canvas-canvas_list_quizzes` to find all published quizzes. Filter for quizzes where `"submit": true` in the permissions. Compile a master list of `(course_id, quiz_id)` pairs.
+
+### Phase 2: Quiz Attempt Initialization
+3. **Start All Quiz Attempts:** For each `(course_id, quiz_id)` pair, call `canvas-canvas_start_quiz_attempt`. This is a parallelizable operation. Capture the returned `quiz_submission_id` and `validation_token` for each quiz. Handle any errors gracefully (e.g., quiz already started, access denied) but log them.
+
+### Phase 3: Question Retrieval & Analysis
+4. **Retrieve All Questions:** For each active quiz attempt, use `canvas-canvas_list_quiz_questions` with the `quiz_submission_id` and `use_submission_endpoint: true` to get the specific questions and answer choices for that attempt.
+5. **Analyze and Determine Correct Answers:** For each retrieved question, use your general knowledge and reasoning to identify the single correct answer. **Crucially, you must provide the correct `answer_id` from the provided answer choices.** Do not guess. If a question's subject matter is outside your reliable knowledge, note it but proceed with your best logical deduction based on the question text and answer choices. The goal is 100% accuracy.
+ * **Pattern from Trajectory:** Questions are typically multiple-choice (`"question_type": "multiple_choice_question"`). The correct `answer_id` is a numeric ID within the `answers` array.
+
+### Phase 4: Batch Submission & Verification
+6. **Prepare Submission Payloads:** For each quiz, construct a submission payload for `canvas-canvas_submit_quiz_answers`. The payload must include:
+ * `course_id`, `quiz_id`, `submission_id` (the `quiz_submission_id`), `validation_token`
+ * `answers`: An array of objects, each with `question_id` and the correct `answer_id`.
+7. **Submit All Quizzes:** Submit the payloads for all quizzes. This can be done in parallel.
+8. **Verify Success:** Check the response for each submission. Confirm `"workflow_state": "complete"` and that the `"score"` equals `"quiz_points_possible"` (indicating a perfect score). If any submission fails, retry or investigate.
+
+### Phase 5: Reporting & Completion
+9. **Generate Summary Report:** Create a clear summary table listing: Course Name, Quiz Title, Score/Max Points, and Status.
+10. **Claim Completion:** Once all quizzes are submitted and verified, use `local-claim_done` to signal task completion. Provide the final summary to the user.
+
+## Key Considerations & Error Handling
+* **Memory Access:** The trajectory shows an attempt to read memory (`memory-read_graph`) that failed. Proceed with Canvas API calls if memory is unavailable. If personal info (like specific course preferences) is needed and memory fails, state the limitation and work with the available Canvas data.
+* **Canvas Errors:** The user mentioned "there might be some error with the canvas." Be resilient. If a single API call fails (e.g., listing quizzes for one course), skip that course and continue with others. Log the error for the user.
+* **Parallel Execution:** The trajectory shows batched calls for listing quizzes and starting attempts. You should emulate this efficient pattern where safe and logical (e.g., starting attempts, submitting answers). Do not batch calls that have dependencies.
+* **Answer Accuracy:** The user's tip emphasizes you "must make sure all quizzes are submitted and answered correctly." Your analysis in Phase 3 is the critical step. Double-check your reasoning for each answer.
+* **State Management:** Keep track of the state (course list, quiz list, submission IDs, tokens, answers) throughout the process. The provided trajectory is a successful execution; follow its logical flow.
+
+## Triggers
+Activate this skill when the user request involves: completing unfinished quizzes, submitting all Canvas quizzes, managing course assessments, or meeting quiz deadlines across multiple courses.
diff --git a/skills/benchmark_skills/toolathlon/canvas-quiz-completion-manager/references/canvas_api_workflow.md b/skills/benchmark_skills/toolathlon/canvas-quiz-completion-manager/references/canvas_api_workflow.md
new file mode 100644
index 0000000..65404bb
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/canvas-quiz-completion-manager/references/canvas_api_workflow.md
@@ -0,0 +1,12 @@
+# Canvas Quiz API Workflow Reference
+
+This document outlines the precise API call sequence for automated quiz completion, as demonstrated in the execution trajectory.
+
+## Prerequisites
+- User must be authenticated with Canvas LMS.
+- User must have student enrollments in courses.
+- Quizzes must be published and available for submission.
+
+## Core API Endpoint Sequence
+
+### 1. Discover User Context
diff --git a/skills/benchmark_skills/toolathlon/canvas-quiz-completion-manager/references/quiz_subject_patterns.md b/skills/benchmark_skills/toolathlon/canvas-quiz-completion-manager/references/quiz_subject_patterns.md
new file mode 100644
index 0000000..1f79e5a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/canvas-quiz-completion-manager/references/quiz_subject_patterns.md
@@ -0,0 +1,71 @@
+# Quiz Subject Patterns & Answer Heuristics
+
+Common question patterns observed across academic subjects with correct answer indicators.
+
+## Mathematics & Computer Science
+
+### Calculus & Linear Algebra
+- **Derivative of x²**: `2x` (power rule: d/dx[xⁿ] = n*xⁿ⁻¹)
+- **Determinant of identity matrix**: `1` (all diagonal elements are 1)
+- **Matrix multiplication dimensions**: (m×n) × (n×p) = (m×p)
+- **Eigenvalue definition**: "A scalar by which an eigenvector is scaled"
+- **Binary search complexity**: `O(log n)` (divides search space in half)
+
+### Algorithms & Data Structures
+- **Time complexity hierarchies**: O(1) < O(log n) < O(n) < O(n log n) < O(n²)
+- **Best average sorting**: Merge Sort or Quick Sort (O(n log n))
+- **LIFO principle**: Stack
+- **FIFO principle**: Queue
+
+### Databases & SQL
+- **RDBMS**: Relational Database Management System
+- **Primary key**: Must be unique and not null
+- **SQL SELECT**: Retrieves data
+- **Normalization purpose**: Reduces redundancy, improves integrity
+
+### Software Engineering
+- **Agile methodology**: Iterative, customer collaboration
+- **Unit testing**: Tests individual components
+- **Singleton pattern**: Ensures single instance
+- **Microservices advantage**: Independent scalability/deployment
+
+## Artificial Intelligence & NLP
+- **Supervised learning**: Uses labeled training data
+- **Neural network basic unit**: Neuron/Perceptron
+- **Tokenization**: Breaking text into words/tokens
+- **Stemming**: Reducing words to root form
+
+## Philosophy & Logic
+- **Kant's Formula of Humanity**: "Treat humanity as an end, never merely as means"
+- **Valid inference patterns**: Modus Ponens, Modus Tollens
+- **Logical fallacies**:
+ - Hasty generalization: Small sample → broad conclusion
+ - Ad hominem: Attacking person not argument
+- **Rawls' veil of ignorance**: Impartiality from unknown position
+
+## History & Social Sciences
+- **Historical causation**: Economic factors often primary (depressions, shortages)
+- **Total war**: Mobilizes entire population/economy
+- **Political movements**: Often expose societal divisions
+
+## Language & Grammar
+- **Third person singular**: "doesn't" not "don't"
+- **Synonyms**: enormous = huge, gigantic, massive
+- **Antonyms**: enormous ≠ tiny, small
+
+## Networking
+- **OSI Model layers**:
+ - 7: Application
+ - 4: Transport (TCP/UDP)
+ - 3: Network (routing, IP)
+ - 2: Data Link (MAC)
+ - 1: Physical
+- **Default ports**: HTTP=80, HTTPS=443, SSH=22, FTP=21
+
+## Answer Selection Strategy
+1. **Eliminate obviously wrong answers** (contradictory, nonsensical)
+2. **Look for precise technical definitions**
+3. **Prefer answers with qualifiers** ("must be", "always", "never") when definitional
+4. **In historical questions**, economic/social factors often correct
+5. **In ethics questions**, principles over utilitarian calculations
+6. **When in doubt**, choose the most specific, academically standard answer
diff --git a/skills/benchmark_skills/toolathlon/canvas-quiz-creator/SKILL.md b/skills/benchmark_skills/toolathlon/canvas-quiz-creator/SKILL.md
new file mode 100644
index 0000000..be38c43
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/canvas-quiz-creator/SKILL.md
@@ -0,0 +1,59 @@
+---
+name: canvas-quiz-creator
+description: When the user needs to create or manage quizzes in Canvas Learning Management System, particularly when they provide quiz questions and answers that need to be formatted and uploaded. This skill handles the complete workflow including 1) Finding the target course in Canvas, 2) Creating a new quiz with proper metadata (title, description, quiz type), 3) Adding multiple-choice questions with correct answer weights, 4) Verifying the quiz creation and providing a summary. Use this skill when users mention 'Canvas quiz', 'create test on Canvas', 'upload questions to Canvas', or when they provide structured quiz questions with multiple-choice options that need to be formatted for Canvas API integration.
+---
+# Instructions
+
+## 1. Parse User Input
+- Extract the quiz title from the user's request. If not specified, ask for clarification.
+- Extract the list of questions. Each question should have:
+ - Question text
+ - Multiple-choice options (typically A, B, C, D)
+ - The correct answer (identified by letter or explicit text)
+- Note: The user may specify points per question (e.g., "one point each"). Default to 1 point if not specified.
+
+## 2. Find the Target Course
+- Use `canvas-canvas_list_courses` to retrieve the list of available courses.
+- Identify the target course. The user may specify the course name (e.g., "Art History") or you may need to infer it from context. If ambiguous, ask for clarification.
+- **Critical:** Store the course ID for all subsequent API calls.
+
+## 3. Create the Quiz
+- Use `canvas-canvas_create_quiz` with the following parameters:
+ - `course_id`: The ID from step 2.
+ - `title`: The quiz title from step 1.
+ - `description`: Generate a brief, relevant description summarizing the quiz topics. If the user provides one, use it.
+ - `quiz_type`: Use "assignment". (The trajectory shows "graded" caused an error; "assignment" succeeded.)
+ - `published`: Set to `false` initially. The quiz can be published later by the instructor.
+- If the API call fails (e.g., invalid quiz type), retry with `quiz_type` set to "assignment".
+- **Critical:** Store the returned quiz ID.
+
+## 4. Add Questions to the Quiz
+- For each question extracted in step 1:
+ - Format the question text. Ensure any quotation marks are properly escaped for JSON.
+ - Prepare the `answers` array. Each answer object must have:
+ - `text`: The answer option text.
+ - `weight`: 100 for the correct answer, 0 for all incorrect answers.
+ - Use `canvas-canvas_create_quiz_question` with these parameters:
+ - `course_id`: The course ID.
+ - `quiz_id`: The quiz ID from step 3.
+ - `question_name`: A descriptive name (e.g., "Question 1: [Topic]").
+ - `question_text`: The full question text.
+ - `question_type`: "multiple_choice_question".
+ - `points_possible`: The point value for this question.
+ - `position`: The question number (1-indexed).
+ - `answers`: The array of answer objects.
+- Process questions sequentially. The API may support batch creation, but the trajectory shows individual calls are reliable.
+
+## 5. Verify and Summarize
+- Use `canvas-canvas_get_quiz` to fetch the final quiz details and confirm creation.
+- Use `canvas-canvas_list_quiz_questions` to list all added questions and verify the count.
+- Present a clear summary to the user including:
+ - Quiz title and course name.
+ - Direct URL to the quiz (from the `html_url` field).
+ - Total points and number of questions.
+ - A list of each question with its correct answer clearly marked.
+ - A note that the quiz is unpublished by default.
+
+## 6. Finalize
+- Use `local-claim_done` to signal successful completion.
+- Do not publish the quiz unless explicitly requested by the user. The default state should be unpublished.
diff --git a/skills/benchmark_skills/toolathlon/canvas-quiz-creator/references/canvas_api_guide.md b/skills/benchmark_skills/toolathlon/canvas-quiz-creator/references/canvas_api_guide.md
new file mode 100644
index 0000000..616ce72
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/canvas-quiz-creator/references/canvas_api_guide.md
@@ -0,0 +1,40 @@
+# Canvas Quiz API Quick Reference
+
+## Key Endpoints Used
+
+### 1. List Courses
+**Endpoint:** `GET /api/v1/courses`
+**Tool:** `canvas-canvas_list_courses`
+**Purpose:** Find the target course ID.
+**Response Fields to Note:**
+- `id`: Course ID (required for all subsequent calls)
+- `name`: Course name
+- `course_code`: Course code (e.g., "AH101")
+
+### 2. Create Quiz
+**Endpoint:** `POST /api/v1/courses/:course_id/quizzes`
+**Tool:** `canvas-canvas_create_quiz`
+**Required Parameters:**
+- `course_id`: The course ID
+- `title`: Quiz title (string)
+- `quiz_type`: Use "assignment" for graded quizzes. Other valid types: "practice_quiz", "graded_survey", "survey"
+- `published`: Set to `false` to create as draft
+
+**Important Notes:**
+- The "graded" quiz type may cause "invalid_quiz_type" error in some Canvas instances. "assignment" is more reliable.
+- The quiz will be associated with an assignment automatically (see `assignment_id` in response).
+
+### 3. Create Quiz Question
+**Endpoint:** `POST /api/v1/courses/:course_id/quizzes/:quiz_id/questions`
+**Tool:** `canvas-canvas_create_quiz_question`
+**Required Parameters for Multiple Choice:**
+- `course_id`: Course ID
+- `quiz_id`: Quiz ID from creation step
+- `question_name`: Short identifier for the question
+- `question_text`: The actual question text
+- `question_type`: "multiple_choice_question"
+- `points_possible`: Point value (integer)
+- `position`: Order in quiz (1-indexed)
+- `answers`: Array of answer objects
+
+**Answer Object Structure:**
diff --git a/skills/benchmark_skills/toolathlon/canvas-quiz-creator/references/quiz_summary_template.md b/skills/benchmark_skills/toolathlon/canvas-quiz-creator/references/quiz_summary_template.md
new file mode 100644
index 0000000..c6f1e29
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/canvas-quiz-creator/references/quiz_summary_template.md
@@ -0,0 +1,18 @@
+# Quiz Created Successfully ✓
+
+**Quiz Title:** {quiz_title}
+**Course:** {course_name} (ID: {course_id})
+**Quiz URL:** {quiz_url}
+**Total Points:** {total_points} points ({points_per_question} point per question)
+**Number of Questions:** {question_count}
+**Status:** {status}
+
+---
+
+## Questions and Answers:
+
+{question_list}
+
+---
+
+**Note:** The quiz is currently {status_note}. When you're ready to make it available to students, you can publish it through the Canvas interface.
diff --git a/skills/benchmark_skills/toolathlon/canvas-student-enrollment-manager/SKILL.md b/skills/benchmark_skills/toolathlon/canvas-student-enrollment-manager/SKILL.md
new file mode 100644
index 0000000..df77d1a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/canvas-student-enrollment-manager/SKILL.md
@@ -0,0 +1,71 @@
+---
+name: canvas-student-enrollment-manager
+description: Manages student enrollments in Canvas LMS courses for late-joining students. Handles reading student lists from CSV files, searching for courses, identifying enrolled vs. unenrolled students, enrolling missing students, and sending personalized private messages about assignment policies.
+---
+# Instructions
+
+## Overview
+Use this skill when you need to manage student enrollments in Canvas, particularly for students who have joined a course late (e.g., after changing majors) and have missed initial assignments. The skill automates the process of enrolling students from a provided list and notifying them of relevant grade policies.
+
+## Core Workflow
+
+### 1. Locate and Parse the Student List
+- **Action:** Search the workspace for a CSV file containing student information. The expected format is `Name,email` (case-sensitive headers).
+- **Tool:** Use `filesystem-list_directory` to explore `/workspace/dumps/workspace` or similar directories.
+- **Next:** Once found, read the file with `filesystem-read_file` to parse the list of students.
+
+### 2. Find the Target Course in Canvas
+- **Action:** Identify the correct Canvas course by name (e.g., "Introduction to AI-8").
+- **Tool:** Use `canvas-canvas_list_account_courses` with a `search_term`. You may need to first get the root account ID using `canvas-canvas_get_account`.
+- **Verification:** Confirm the course details (ID, name) using `canvas-canvas_get_course`.
+
+### 3. Identify Existing and Missing Students
+- **Action:** Determine which students from the CSV are already enrolled and which are not.
+- **Sub-step A - Find Student User IDs:** For each student email in the CSV, search the Canvas account users using `canvas-canvas_list_account_users` with the email as the `search_term`. Record the `id` for each found user.
+- **Sub-step B - Get Current Enrollments:** Retrieve the list of currently enrolled students for the course using `canvas-canvas_get_course_grades`. This returns an array of enrollment objects containing `user_id`.
+- **Analysis:** Compare the list of found user IDs (from Sub-step A) against the list of enrolled `user_id`s (from Sub-step B). Students whose IDs are not in the enrollment list need to be enrolled.
+
+### 4. Enroll Missing Students
+- **Action:** Enroll each identified missing student into the target course.
+- **Tool:** For each student user ID, call `canvas-canvas_enroll_user`.
+- **Parameters:**
+ - `course_id`: The ID of the target course.
+ - `user_id`: The Canvas ID of the student.
+ - `role`: `"StudentEnrollment"`
+ - `enrollment_state`: `"active"`
+- **Note:** Enroll students one by one. The tool will return a confirmation for each successful enrollment.
+
+### 5. Notify Newly Enrolled Students
+- **Action:** Send a private, personalized message to each student you just enrolled.
+- **Tool:** Use `canvas-canvas_create_conversation` for each student.
+- **Message Content:** The message should:
+ 1. Welcome the student to the course.
+ 2. Acknowledge they joined late/missed the first assignment.
+ 3. Clearly state the policy: **Their first assignment grade will be the same as their second assignment grade.**
+ 4. Encourage them to complete the second assignment diligently, as it will determine both grades.
+ 5. Offer a point of contact for questions.
+- **Parameters:**
+ - `recipients`: An array containing the single student's user ID (e.g., `["75"]`).
+ - `subject`: A clear subject (e.g., "Important: First Assignment Grade Policy for New Students").
+ - `body`: The personalized message. Use the student's first name from the CSV data.
+
+### 6. Final Summary
+- **Action:** Provide a concise summary to the user.
+- **Content:** List the number of students enrolled, their names, and confirm that notification messages were sent. Mention any students who were already enrolled.
+
+## Error Handling & Considerations
+- **Missing Students:** If a student email from the CSV is not found in the Canvas system, note this and skip them. Inform the user.
+- **Course Not Found:** If the course search yields no results, double-check the course name and account. You may need to list all courses to find it.
+- **Large Batches:** The trajectory shows individual API calls for each student search and enrollment. This is acceptable for moderate-sized lists. For very large lists, consider the efficiency but prioritize reliability.
+- **Message Personalization:** Extract the student's first name from the `Name` field in the CSV (typically the first word) to personalize the message.
+
+## Key Tools Used
+- `filesystem-list_directory`
+- `filesystem-read_file`
+- `canvas-canvas_get_account`
+- `canvas-canvas_list_account_courses`
+- `canvas-canvas_get_course`
+- `canvas-canvas_list_account_users`
+- `canvas-canvas_get_course_grades`
+- `canvas-canvas_enroll_user`
+- `canvas-canvas_create_conversation`
diff --git a/skills/benchmark_skills/toolathlon/canvas-student-enrollment-manager/assets/message_template.md b/skills/benchmark_skills/toolathlon/canvas-student-enrollment-manager/assets/message_template.md
new file mode 100644
index 0000000..f5c904a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/canvas-student-enrollment-manager/assets/message_template.md
@@ -0,0 +1,9 @@
+# Notification Message Template
+
+## Context
+- **Student First Name:** `{{first_name}}`
+- **Course Name:** `{{course_name}}`
+- **First Assignment Name:** `{{assignment1_name}}` (default: "Homework1")
+- **Second Assignment Name:** `{{assignment2_name}}` (default: "Homework2")
+
+## Template Text
diff --git a/skills/benchmark_skills/toolathlon/canvas-student-enrollment-manager/references/canvas_api_workflow.md b/skills/benchmark_skills/toolathlon/canvas-student-enrollment-manager/references/canvas_api_workflow.md
new file mode 100644
index 0000000..1089e16
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/canvas-student-enrollment-manager/references/canvas_api_workflow.md
@@ -0,0 +1,5 @@
+# Canvas API Workflow Reference
+
+## Sequence of Operations for Enrollment Management
+
+### 1. Discovery Phase
diff --git a/skills/benchmark_skills/toolathlon/competitive-price-analysis-pipeline/SKILL.md b/skills/benchmark_skills/toolathlon/competitive-price-analysis-pipeline/SKILL.md
new file mode 100644
index 0000000..962a163
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/competitive-price-analysis-pipeline/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: competitive-price-analysis-pipeline
+description: Performs competitive price analysis by comparing internal pricing data with competitor information from different sources (PDFs, CSVs, spreadsheets), calculates price differences, generates insights, and stores results in BigQuery for decision-making.
+---
+# Instructions
+
+## 1. Initial Setup & Discovery
+- **List the workspace directory** to identify available files.
+- **Read the requirements document** (e.g., `requirement.md`) to understand the target BigQuery dataset, table, and required schema.
+- **Read the internal pricing file** (CSV or Excel) to understand the structure and product list.
+
+## 2. Extract Competitor Pricing Data
+- **Inspect the competitor PDF** to understand its structure (page count, layout).
+- **Read all pages** of the competitor PDF to extract text content containing product names and prices.
+
+## 3. Data Processing & Matching
+- **Parse the internal pricing data.** The key columns are `Product Name` and `Our Price`.
+- **Parse the competitor PDF text.** Identify product names and their corresponding prices. Use fuzzy matching or keyword mapping (e.g., "SmartWidget Pro" → "SmartWidget Professional Edition") based on the trajectory example.
+- **Create a matched product list.** For each internal product, find the corresponding competitor product and price. If a direct match isn't found, log it for manual review.
+- **Calculate the price difference** for each matched product: `Price Difference = Our Price - Competitor Price`.
+
+## 4. Prepare Output & Load to BigQuery
+- **Create a CSV file** (`price_comparison.csv`) with the exact columns specified in the requirements:
+ - `Product Name` (String)
+ - `Our Price` (Float)
+ - `Competitor Price` (Float)
+ - `Price Difference` (Float)
+- **Verify the BigQuery dataset exists.** If it doesn't, you may need to create it (though the trajectory shows it pre-existing).
+- **Load the CSV data** into the specified BigQuery table (`dataset_id.table_id`). Use `WRITE_TRUNCATE` mode to replace any existing data, as per the trajectory.
+- **Run a validation query** to confirm the data was loaded correctly and matches the expected row count and schema.
+
+## 5. Generate Summary & Finalize
+- **Provide a concise summary** of the analysis, including:
+ - Number of products processed.
+ - Count of products priced higher/lower than the competitor.
+ - The product with the largest price advantage (most negative difference).
+ - The product with the largest price disadvantage (most positive difference).
+- **Claim the task as done.**
+
+## Key Considerations
+- **Product Matching Logic:** This is a high-freedom, interpretive step. Use the provided `scripts/match_products.py` as a starting point, but be prepared to adjust matching rules (keywords, categories) based on the specific data.
+- **BigQuery Permissions:** Ensure the agent has the necessary permissions to list datasets and load data to the specified table.
+- **Data Types:** Ensure numeric prices are parsed as floats. Handle currency symbols and commas appropriately.
+- **Error Handling:** If the PDF extraction yields poor results, consider using the `pdf-tools-search_pdf` function to find specific product names or prices.
diff --git a/skills/benchmark_skills/toolathlon/competitive-price-analysis-pipeline/references/bigquery_schema.md b/skills/benchmark_skills/toolathlon/competitive-price-analysis-pipeline/references/bigquery_schema.md
new file mode 100644
index 0000000..e73d285
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/competitive-price-analysis-pipeline/references/bigquery_schema.md
@@ -0,0 +1,25 @@
+# BigQuery Schema & Requirements Reference
+
+## Target Table Structure
+- **Full Table Path**: `bigquery_pricing_analysis.analysis`
+- **Required Columns & Data Types**:
+ 1. `Product Name` (STRING) - The exact product name from the internal CSV file.
+ 2. `Our Price` (FLOAT) - Our product's price.
+ 3. `Competitor Price` (FLOAT) - The matched competitor's price.
+ 4. `Price Difference` (FLOAT) - Calculated as `Our Price - Competitor Price`.
+
+## Data Processing Notes
+- **Product Matching**: Use the `Product Name` from the internal file as the primary key. Match competitor products based on name similarity, keywords, or product categories.
+- **Calculation**: `Price Difference` must be calculated during processing and stored as a column. A positive value means our product is more expensive; a negative value means it's cheaper.
+- **Loading Mode**: The trajectory uses `WRITE_TRUNCATE` mode, which replaces all existing data in the table. Ensure this is the intended behavior.
+
+## Example Valid Data
+| Product Name | Our Price | Competitor Price | Price Difference |
+|---------------------|-----------|------------------|------------------|
+| SmartWidget Pro | 399.99 | 349.95 | 50.04 |
+| CloudSync Enterprise| 89.99 | 129.99 | -40.00 |
+
+## Common Agent Functions for BigQuery
+- `google-cloud-bigquery_list_datasets()`: Check if the target dataset exists.
+- `google-cloud-bigquery_load_csv_data(dataset_id, table_id, csv_file_path, skip_header=True, write_mode="WRITE_TRUNCATE")`: Loads the generated CSV file.
+- `google-cloud-bigquery_run_query(query)`: Run a validation query (e.g., `SELECT * FROM dataset.table ORDER BY Product Name`).
diff --git a/skills/benchmark_skills/toolathlon/competitive-price-analysis-pipeline/references/product_matching_rules.md b/skills/benchmark_skills/toolathlon/competitive-price-analysis-pipeline/references/product_matching_rules.md
new file mode 100644
index 0000000..df087e5
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/competitive-price-analysis-pipeline/references/product_matching_rules.md
@@ -0,0 +1,23 @@
+# Product Matching Rules & Heuristics
+
+## Core Principle
+Match internal product names to competitor product names based on semantic similarity, shared keywords, and product category context.
+
+## Strategies (Order of Preference)
+1. **Keyword Mapping Table**: Pre-defined mapping of internal product names to lists of keywords found in competitor product names (see `scripts/match_products.py`).
+2. **Substring Matching**: Check if the internal product name is a substring of the competitor name, or vice versa (case-insensitive).
+3. **Category Context**: Use the product category from the internal data (if available) to narrow down matches within the competitor's catalog (e.g., only match "Electronics" with competitor's "Electronics Category" products).
+
+## Example from Trajectory
+| Internal Product | Competitor Product (Matched) | Matching Logic |
+|----------------------|---------------------------------------|--------------------------------------------------------------------------------|
+| SmartWidget Pro | SmartWidget Professional Edition | Keyword "SmartWidget" + Category (Electronics) |
+| DataFlow Analyzer | DataFlow Business Analyzer | Keyword "DataFlow" + "Analyzer" |
+| CloudSync Enterprise | CloudSync Business Suite | Keyword "CloudSync" + Category (Cloud Services) |
+| SecureVault Plus | SecureVault Premium | Keyword "SecureVault" |
+| AutoTask Manager | AutoTask Professional | Keyword "AutoTask" |
+
+## Handling Ambiguities & No Matches
+- **Multiple Matches**: If an internal product matches multiple competitor products, log a warning and select the first match, or choose based on the closest price point/category.
+- **No Match Found**: Log the internal product name as unmatched. Do not include it in the final CSV/BigQuery load. Report these in the final summary.
+- **Price Format Variations**: Competitor prices may have currency symbols (`$`), commas (`1,399.00`), or be monthly (`129.99/month`). The extraction script must normalize these to a float.
diff --git a/skills/benchmark_skills/toolathlon/compiler-concepts-explainer/SKILL.md b/skills/benchmark_skills/toolathlon/compiler-concepts-explainer/SKILL.md
new file mode 100644
index 0000000..2cf1629
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/compiler-concepts-explainer/SKILL.md
@@ -0,0 +1,68 @@
+---
+name: compiler-concepts-explainer
+description: When the user needs explanations of compiler principles concepts, particularly symbol tables, semantic analysis, and related implementation details. This skill provides detailed explanations of functional vs. imperative symbol tables, insertion operations, scope management, and code implementations. It's triggered by technical questions about 'symbol tables', 'compiler principles', 'semantic analysis', 'functional vs. imperative', or 'scope management'.
+---
+# Skill: Compiler Concepts Explainer
+
+## Primary Objective
+Explain compiler principles concepts, with a focus on **Semantic Analysis** and **Symbol Tables**, by extracting and synthesizing information from provided course materials (PPTX, PDF). Create a structured, educational note for the user.
+
+## Core Workflow
+1. **Identify Request:** Recognize user queries about compiler concepts, especially symbol tables, semantic analysis, functional/imperative styles, scope, or homework related to these topics.
+2. **Locate & Extract:** Find and read the relevant source files (e.g., `Compile.pptx`, `HW.pdf`) in the workspace.
+3. **Analyze & Structure:** Parse the extracted content to identify key definitions, differences, code examples, and homework questions/answers.
+4. **Generate Explanation:** Create a comprehensive, well-organized markdown note (`NOTE.md`) that includes:
+ * Clear definitions and comparisons (e.g., Functional vs. Imperative Symbol Tables).
+ * Detailed explanations of insertion operations and their implications.
+ * All relevant code snippets from the materials, presented with clear commentary.
+ * Explanations and answers for any associated homework questions.
+5. **Deliver Output:** Write the final note to the specified file path and confirm completion.
+
+## Detailed Instructions
+
+### Phase 1: Source Material Acquisition
+* **PPTX Files:** Use the `pptx-open_presentation` and `pptx-extract_presentation_text` tools to get the full textual content of the slides. Pay close attention to slides discussing "Symbol Tables," "Functional Style," "Imperative Style," "Efficient Functional/Imperative Symbol Tables," and "The Implementation of Symbol Tables."
+* **PDF Files:** Use `pdf-tools-read_pdf_pages` to read homework assignments or supplementary PDFs. Extract questions and any provided context.
+* **File Discovery:** If a file path is not found, use `filesystem-list_directory` to check the workspace for the correct file (e.g., `HW.pdf` vs `HW.PDF`).
+
+### Phase 2: Content Analysis & Synthesis
+Analyze the extracted text to build a mental model covering:
+1. **Fundamentals:** What is a symbol table/environment? What is its role in semantic analysis (binding, lookup, scoping)?
+2. **The Two Paradigms:**
+ * **Functional Style:** Definition, key characteristic (preserves original), typical data structure (Binary Search Tree), and efficiency of insertion/restoration.
+ * **Imperative Style:** Definition, key characteristic (destructive update), typical data structure (Hash Table with chaining + undo stack), and efficiency of insertion/restoration.
+3. **Insertion Operation Differences:** Explicitly contrast how each style handles adding a new binding, especially when shadowing a previous one. Use the `hash(a) -> <a, τ2> -> <a, τ1>` example for imperative style.
+4. **Code Implementation:** Identify all distinct code blocks in the slides. Categorize them (e.g., Data Structure, Hash Function, Operations, Symbol Interface, Scope Management). Prepare to explain each block's purpose and key lines.
+5. **Homework Analysis:** For each question in the homework PDF, determine the core concept being tested and derive the correct answer based on the lecture content.
+
+### Phase 3: Note Generation
+Create a single, polished `NOTE.md` file. Structure it as follows:
+* **Title & Overview:** Clear subject header and brief introduction.
+* **Section 1: Definitions & Concepts.** Present the fundamentals.
+* **Section 2: Functional vs. Imperative (Comparison).** Use a table or clear bullet points to highlight differences in definition, characteristics, data structure, and insertion.
+* **Section 3: Code Examples with Explanations.** This is the core technical detail. For each code block:
+ * Present the code in a fenced code block with the correct language tag (`c`).
+ * **Write an "Explanation" subsection** that breaks down the code's purpose, key variables/functions, and how it relates to the broader concept (e.g., "This implements the hash function for the imperative table...").
+* **Section 4: Homework Explanations.** For each question:
+ * State the question topic.
+ * Provide a concise explanation of the reasoning that leads to the answer.
+ * Clearly state the final answer.
+* **Section 5: Summary.** A concise recap or comparison table.
+
+**Writing Style:** Be pedagogical, clear, and precise. Assume the reader is a computer science student familiar with basic data structures but new to compiler internals.
+
+### Phase 4: Finalization
+* Use `filesystem-write_file` to create the `NOTE.md` file at the requested path (e.g., `/workspace/dumps/workspace/NOTE.md`).
+* Optionally, read back the first few lines using `filesystem-read_file` to verify successful creation.
+* Provide a final summary to the user outlining what was covered in the note.
+
+## Key Triggers & Context Cues
+* User mentions: "symbol table", "compiler principles", "semantic analysis", "Chapter 5", "functional symbol table", "imperative symbol table", "scope", "insert operation", "homework", "lecture notes".
+* User provides or asks about files named `Compile.pptx`, `HW.pdf`, or similar.
+* User asks for a comparison or explanation of differences between two approaches.
+
+## What NOT to Do
+* Do not invent compiler concepts not present in the source materials.
+* Do not provide code explanations that contradict the logic shown in the slides.
+* Do not skip explaining the homework questions if they are part of the request.
+* Do not create multiple note files unless explicitly requested. Consolidate all information into one structured `NOTE.md`.
diff --git a/skills/benchmark_skills/toolathlon/compiler-concepts-explainer/references/core_concepts.md b/skills/benchmark_skills/toolathlon/compiler-concepts-explainer/references/core_concepts.md
new file mode 100644
index 0000000..ed805a1
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/compiler-concepts-explainer/references/core_concepts.md
@@ -0,0 +1,60 @@
+# Core Compiler Concepts: Semantic Analysis & Symbol Tables
+*Reference based on "Compile.pptx" Chapter 5*
+
+## 1. Semantic Analysis Phase
+**Purpose:** Bridge between syntax and machine code.
+* **Connects** variable definitions to their uses.
+* **Checks** type correctness of expressions.
+* **Translates** abstract syntax to a simpler IR.
+
+## 2. Symbol Tables (Environments)
+**Definition:** A data structure mapping identifiers (symbols) to their meanings (type, location).
+* **Binding:** Association `id ↦ meaning`, denoted by `σ = {a ↦ int, b ↦ string}`.
+* **Operations:**
+ * `enter(σ, id, binding)`: Add a new binding (`σ' = σ + {id ↦ binding}`).
+ * `lookup(σ, id)`: Find the current binding for `id`.
+ * Scope Exit: Discard bindings local to a finished scope.
+
+## 3. The Two Implementation Styles
+
+### Functional Style
+* **Core Idea:** Immutable environments. Creating a new environment (`σ'`) leaves the original (`σ`) intact and usable.
+* **Data Structure:** Balanced Binary Search Tree (BST) is efficient.
+* **Insertion (`σ' = σ + {a ↦ τ}`):** Creates new nodes *only* along the path from the root to the insertion point. Original tree is shared, not copied.
+* **Restoration:** Trivial. The old environment reference is still valid.
+* **Lookup:** O(log n) for a balanced BST.
+
+### Imperative Style
+* **Core Idea:** Mutable, global environment updated destructively. An "undo stack" tracks changes for scope restoration.
+* **Data Structure:** Hash Table with external chaining + auxiliary stack.
+* **Insertion:** New binding is inserted at the **head** of its hash chain. This shadows any previous binding for the same symbol.
+ * Example: Inserting `a ↦ τ2` when `a ↦ τ1` exists results in chain: `hash(a) → <a, τ2> → <a, τ1>`.
+* **Restoration (`pop`):** Removes the head of the chain, revealing the previous binding. Managed via `S_beginScope()`/`S_endScope()` using a marker symbol.
+* **Lookup:** O(1) average case. Looks at the head of the chain first (finds the most recent binding).
+
+## 4. Key Code Components (Tiger Compiler in C)
+
+### 4.1 Hash Table Foundation
+* `struct bucket`: Node for a hash chain (`key`, `binding`, `next`).
+* `hash(char *s)`: Polynomial hash function (65599 multiplier).
+* `insert()`: Adds new bucket to head of chain (enables shadowing).
+* `pop()`: Removes head of chain (undoes last insert for that key).
+
+### 4.2 Symbol Optimization
+* **Problem:** Repeated string hashing/comparison is slow.
+* **Solution: String Interning.** Convert strings to unique `S_symbol` objects.
+* **Benefits:**
+ * Hash key = pointer address (fast).
+ * Equality check = pointer comparison (fast).
+ * Enables fast ordering for BSTs.
+
+### 4.3 Interface (`S_table`, `S_symbol`)
+* `S_symbol S_symbol(string)`: Interns a string, returns unique symbol.
+* `S_enter(S_table, S_symbol, void*)`: Inserts a binding.
+* `S_look(...)`: Looks up a binding.
+* `S_beginScope(S_table)`: Pushes a marker onto the undo stack.
+* `S_endScope(S_table)`: Pops bindings until the marker is found.
+
+### 4.4 Integrated Undo Stack
+* The `Binder` struct (in `TAB_table_`) contains a `prevtop` field.
+* This links bindings in a stack, allowing `S_endScope` to walk back through recent inserts without a separate data structure.
diff --git a/skills/benchmark_skills/toolathlon/compiler-concepts-explainer/references/homework_guide.md b/skills/benchmark_skills/toolathlon/compiler-concepts-explainer/references/homework_guide.md
new file mode 100644
index 0000000..9a580f7
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/compiler-concepts-explainer/references/homework_guide.md
@@ -0,0 +1,40 @@
+# Homework Guide: Symbol Tables
+*Based on "HW.pdf" Assignment*
+
+## Question 1: Scope Restoration Methods
+**Topic:** Efficiency of different symbol table implementations when exiting a scope.
+* **A (Deep Copy):** Inefficient. Copies entire data structure.
+* **B (Functional BST):** Efficient. Creates only O(d) new nodes for insertion at depth d. Original is preserved.
+* **C (Imperative Hash + Undo Stack):** Efficient. Restoration involves pointer manipulation on the undo stack.
+* **Correct Answer:** **D (Both B and C)**. Both methods achieve restoration with minimal overhead compared to a full copy.
+
+## Question 2: Variable Binding & Shadowing
+**Topic:** Applying scope rules to determine a variable's active binding.
+**Given Code:** Function `f` with parameters `a:int, b:int, c:int` and an inner `let` block that declares `var a := "hello"`.
+**Analysis:**
+1. Outer scope (`σ1`): `a ↦ int` (parameter).
+2. Inner `let` scope (`σ3`): A new binding `a ↦ string` is added, **shadowing** the parameter.
+3. `print(a)` inside the `let` block looks up `a` in the current environment (`σ3`), finding the `string` binding.
+**Correct Answer:** **string**.
+
+## Question 3: Hash Table Insertion Strategy
+**Topic:** How imperative hash tables handle duplicate identifiers (shadowing).
+* The imperative style uses a stack-like discipline for scoping.
+* To shadow a binding `a ↦ τ1` with `a ↦ τ2`, the new binding is inserted **at the head** of the hash chain.
+* Lookup finds the new binding first. `pop()` removes it, restoring the old one.
+* **Correct Answer:** **C (Insert the new binding at the head of the collision chain)**.
+
+## Question 4: String Optimization
+**Topic:** The technique used to avoid expensive string operations in symbol tables.
+* The problem is repeated character-by-character hashing and comparison.
+* The solution is to convert each distinct string to a canonical **symbol** object (`S_symbol`).
+* Operations then use the symbol's address (fast integer/pointer ops).
+* **Correct Answer:** **Symbol** (or `S_symbol`).
+
+## Question 5: Forward References
+**Topic:** Managing multiple symbol tables in languages with mutual recursion (e.g., Java).
+* Java allows forward references (class D can use class N defined later).
+* Each class (`E`, `N`, `D`) has its own local symbol table for its members.
+* These tables are combined into a single, comprehensive environment (`σ7`) for the whole package/compilation unit.
+* All classes are compiled with access to this combined environment.
+* **Correct Answer:** **B (Each class has its own symbol table, which are combined into a comprehensive environment)**.
diff --git a/skills/benchmark_skills/toolathlon/compliance-notification-dispatcher/SKILL.md b/skills/benchmark_skills/toolathlon/compliance-notification-dispatcher/SKILL.md
new file mode 100644
index 0000000..07137f0
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/compliance-notification-dispatcher/SKILL.md
@@ -0,0 +1,73 @@
+---
+name: compliance-notification-dispatcher
+description: When the user needs to send automated email notifications for expense claim issues to employees and their managers. This skill generates context-specific email templates for different violation types (missing documentation vs. policy overages), includes detailed issue descriptions, and sends notifications with proper CC to managers. Triggers include compliance notification sending, policy violation alerts, expense claim review requests, or when automated communication is needed for documentation or policy issues.
+---
+# Instructions
+
+## Overview
+This skill automates the notification process for expense claim compliance issues. It handles two main violation types:
+1. **Documentation Issues**: Missing receipts or amount mismatches between claims and invoices.
+2. **Policy Over-Cap Issues**: Expenses exceeding company policy limits for specific destinations and employee levels.
+
+## Prerequisites
+Before running this skill, ensure you have:
+1. **Expense Claim Data**: Extracted and analyzed expense claims with identified issues
+2. **Employee Contact Information**: Database or file containing employee emails and manager relationships
+3. **Policy Caps**: Company travel expense policy caps by destination city and employee level
+4. **Database Access**: Connection to the reimbursement database (Snowflake in the example)
+
+## Workflow
+
+### 1. Analyze Claims and Identify Issues
+First, analyze all expense claims to identify:
+- **Documentation Issues**: Check if every claimed item has a corresponding invoice and if amounts match
+- **Policy Over-Cap Issues**: Compare expenses against policy caps for the destination and employee level
+
+Use the analysis script (`scripts/analyze_claims.py`) to automate this process.
+
+### 2. Categorize Claims
+Categorize claims into three groups:
+- **Document Issues**: Claims with missing receipts or amount mismatches
+- **Over-Cap Issues**: Claims with complete documentation but exceeding policy caps
+- **Valid Claims**: Claims meeting all requirements
+
+### 3. Send Notifications
+For each category, send appropriate email notifications:
+
+#### A. Document Issues (Review Required)
+- **Subject**: `Expense Claim Review Required: {claim_id}`
+- **To**: Employee email
+- **CC**: Manager email
+- **Template**: Use `references/email_templates.md#document-issue-template`
+- **Content**: List specific missing documents or amount discrepancies
+
+#### B. Over-Cap Issues (Policy Violation)
+- **Subject**: `Expense Over-Cap Notice: {claim_id}`
+- **To**: Employee email
+- **CC**: Manager email
+- **Template**: Use `references/email_templates.md#over-cap-template`
+- **Content**: List specific policy violations with amounts and caps
+
+### 4. Database Operations
+For over-cap claims that have complete documentation:
+- Insert into the reimbursement database
+- Set `FLAG = 1` to indicate abnormal/over-cap claims
+- Do NOT insert claims with document issues
+
+### 5. Verification
+After processing:
+- Verify emails were sent successfully
+- Confirm database inserts are correct
+- Provide a summary report of actions taken
+
+## Key Decisions
+- **Document Issues Take Precedence**: If a claim has both document issues and over-cap issues, treat it as a document issue and do NOT insert into database
+- **Manager CC**: Always include the manager's email in CC for accountability
+- **Detailed Descriptions**: Include specific amounts, dates, and policy caps in notifications
+- **Batch Processing**: Process claims in logical batches to avoid overwhelming email systems
+
+## Error Handling
+- Log all email sending failures for retry
+- Validate database connections before inserts
+- Handle missing employee contact information gracefully
+- Verify policy caps exist for all destinations mentioned in claims
diff --git a/skills/benchmark_skills/toolathlon/contact-discovery-from-documents/SKILL.md b/skills/benchmark_skills/toolathlon/contact-discovery-from-documents/SKILL.md
new file mode 100644
index 0000000..5070902
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/contact-discovery-from-documents/SKILL.md
@@ -0,0 +1,30 @@
+---
+name: contact-discovery-from-documents
+description: When the agent needs to find specific contact information or responsible personnel for a particular domain or system. This skill searches through available documents (PDFs, config files, emails) to locate relevant contact details, organizational charts, or responsibility assignments. It can parse structured documents for contact tables, search for role-based keywords, and extract email addresses and names associated with specific responsibilities. Triggers include 'find contact', 'responsible person', 'team member', 'who manages', 'email address', 'contact information', 'PDF analysis', 'document search', 'role-based lookup'.
+---
+# Skill: Contact Discovery from Documents
+
+## Purpose
+Find contact information (names, emails, roles) for specific responsibilities by searching and analyzing available documents, emails, and configuration files.
+
+## Core Workflow
+1. **Understand the Search Target:** Clarify the role, responsibility, or system you need a contact for (e.g., "cluster management," "network administrator," "billing department").
+2. **Search Across Available Sources:**
+ * **Emails:** Use `emails-search_emails` with relevant keywords (role, system name, department).
+ * **Filesystem:** Use `filesystem-search_files` and `filesystem-list_directory` to locate documents (PDFs, text files, configs) in common workspace areas.
+ * **PDFs:** For PDF files, use `pdf-tools-read_pdf_pages` to extract and analyze text, especially looking for structured sections like contact tables or responsibility matrices.
+ * **Config Files:** Read relevant configuration files (YAML, JSON, text) that may contain admin or contact metadata.
+3. **Analyze and Extract:** Parse the found content. Look for:
+ * Name-Email-Role patterns (e.g., "Stephen Mitchell - [email protected] - Kubernetes cluster").
+ * Section headers like "Contact", "Support Team", "Responsibilities".
+ * Keywords adjacent to email addresses.
+4. **Verify and Use:** Confirm the extracted contact is the most relevant match for the requested responsibility before using it (e.g., sending an email).
+
+## Key Techniques from Trajectory
+* **Role-Based Keyword Search:** Start with broad role searches ("cluster management", "cluster admin", "infrastructure", "kubernetes").
+* **Document Discovery:** If emails are empty, explore the filesystem (`/workspace/dumps/workspace`) for organizational documents (guidelines, configs).
+* **PDF Table Parsing:** The skill successfully parsed a multi-page PDF (`CS Lab Management Guidelines.pdf`), identified a "Lab Support Team" table on page 3, and extracted the specific contact ("Stephen Mitchell") matching the "Cluster & Computing Resources" responsibility.
+* **Fallback Patterns:** When direct email searches fail, proceed to document search and analysis.
+
+## Output
+The primary output is a verified contact (name and email address) for the requested responsibility, ready to be used in subsequent actions (e.g., composing and sending a notification email).
diff --git a/skills/benchmark_skills/toolathlon/contact-discovery-from-documents/references/search_patterns.md b/skills/benchmark_skills/toolathlon/contact-discovery-from-documents/references/search_patterns.md
new file mode 100644
index 0000000..aefa38b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/contact-discovery-from-documents/references/search_patterns.md
@@ -0,0 +1,32 @@
+# Search Patterns for Contact Discovery
+
+## Recommended Search Queries (for `emails-search_emails`)
+Start with these, adapting the `[keyword]`:
+* `[role]` (e.g., "cluster admin", "network", "billing")
+* `[system] admin` (e.g., "kubernetes admin", "database admin")
+* `[department] team` (e.g., "infrastructure team", "devops team")
+* `contact`
+* `responsible for`
+* `support`
+
+## Common Document Filename Patterns (for `filesystem-search_files`)
+* `*contact*`
+* `*team*`
+* `*admin*`
+* `*guideline*`
+* `*policy*`
+* `*handbook*`
+* `*onboarding*`
+* `*config*` (especially in subdirectories like `k8s_configs/`)
+
+## PDF Content Analysis Keywords
+Scan extracted PDF text for these patterns:
+* **Section Headers:** `Contact`, `Team`, `Support`, `Responsibilities`, `Personnel`, `Administration`, `Owners`
+* **Table Indicators:** Look for aligned columns of `Name`, `Email`, `Role/Responsibility`.
+* **Inline Patterns:** `[Name] - [email] - [responsibility]`, `[Name] ([email])`, `[Responsibility]: [Name]`
+
+## Directory Paths to Explore
+* `/workspace/dumps/workspace/` (common dump location)
+* `/shared/` or `/shared/configs/` (shared resources)
+* `/home/` or user directories
+* `/docs/` or `/documentation/`
diff --git a/skills/benchmark_skills/toolathlon/course-schedule-analyzer/SKILL.md b/skills/benchmark_skills/toolathlon/course-schedule-analyzer/SKILL.md
new file mode 100644
index 0000000..4418a68
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/course-schedule-analyzer/SKILL.md
@@ -0,0 +1,65 @@
+---
+name: course-schedule-analyzer
+description: When the user needs to find and select courses from a university schedule (typically in PDF format) based on multiple criteria including course names, course types, class times, exam formats, and campus locations. This skill extracts course information from PDF schedules, searches for specific courses by name or category, filters results based on constraints like day of week, exam type (open-book/closed-book), and time slots, checks for scheduling conflicts, and outputs organized course selection options in structured formats like Excel files.
+---
+# Instructions
+
+## 1. Understand the Request
+- Identify the user's required courses, categories, and constraints.
+- Key constraints often include:
+ - Specific course names (e.g., "自然语言处理", "软件体系结构").
+ - Course categories (e.g., "思政B", "通识教育核心课程").
+ - Day of week (e.g., "Monday").
+ - Exam type (e.g., "开卷" for open-book).
+ - Campus location.
+ - Output format (e.g., Excel files with specific headers).
+- Clarify if multiple valid options should be saved as separate files.
+
+## 2. Locate and Inspect Reference Files
+- List the workspace directory to find the schedule PDF and any reference files (e.g., `reference_format.xlsx`).
+- Read the reference format file to understand the required output structure (headers, data format).
+- Inspect the PDF file to understand its structure (total pages, layout).
+
+## 3. Extract and Search Course Data
+- Use PDF search functions to locate specific courses by name or category.
+- For each required course/category, perform targeted searches.
+- Extract detailed information by reading relevant page ranges.
+- Parse the extracted text to identify:
+ - Course ID
+ - Course name
+ - Instructor
+ - Campus
+ - Class time (day and periods)
+ - Enrollment limit
+ - Credits
+ - Assessment method (e.g., "闭卷", "开卷", "论文")
+ - Exam time
+ - Course selection restrictions
+
+## 4. Apply Filters and Check Constraints
+- Filter courses based on:
+ - Day of week (e.g., Monday courses only).
+ - Exam type (e.g., only "开卷" exams).
+ - Other user-specified constraints.
+- For courses with multiple sections, identify all valid options.
+- Check for time conflicts between fixed required courses.
+- Ensure selected courses do not overlap in schedule.
+
+## 5. Generate Course Selection Schemes
+- Combine fixed required courses with optional courses that meet all constraints.
+- For each valid combination, create a distinct selection scheme.
+- Structure the data according to the reference format.
+- Ensure values are in Chinese while headers remain in English.
+
+## 6. Create Output Files
+- For each selection scheme, create a separate Excel file.
+- Use a programmatic approach (e.g., Python with openpyxl) to generate files efficiently.
+- Save files with clear naming (e.g., `course_selection_scheme_1.xlsx`).
+- Clean up the workspace by removing temporary or reference files if requested.
+
+## 7. Verify and Summarize
+- Verify the content of generated files matches the expected format.
+- Provide a clear summary to the user listing:
+ - The fixed courses included in all schemes.
+ - The variable options for each scheme.
+ - File names and locations.
diff --git a/skills/benchmark_skills/toolathlon/course-schedule-analyzer/references/course_constraints.md b/skills/benchmark_skills/toolathlon/course-schedule-analyzer/references/course_constraints.md
new file mode 100644
index 0000000..c45b167
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/course-schedule-analyzer/references/course_constraints.md
@@ -0,0 +1,33 @@
+# Common Course Constraints
+
+## Course Categories
+- **思政B**: Ideological and Political Theory (B category)
+- **通识教育核心课程**: General Education Core Curriculum
+- **专业课程**: Major courses
+- **公共艺术课程**: Public art courses
+
+## Assessment Methods
+- **开卷**: Open-book exam
+- **闭卷**: Closed-book exam
+- **论文**: Essay/Paper
+- **其他**: Other (e.g., report, presentation)
+
+## Days of Week (Chinese)
+- **周一**: Monday
+- **周二**: Tuesday
+- **周三**: Wednesday
+- **周四**: Thursday
+- **周五**: Friday
+- **周六**: Saturday
+- **周日**: Sunday
+
+## Campus Locations
+- **邯郸校区**: Handan Campus
+- **江湾校区**: Jiangwan Campus
+- **枫林校区**: Fenglin Campus
+- **张江校区**: Zhangjiang Campus
+
+## Time Conflict Checking
+- Courses on the same day with overlapping periods conflict.
+- Example: "周一 第2-3节" conflicts with "周一 第3-4节".
+- Example: "周一 第2-3节" does NOT conflict with "周一 第4-5节".
diff --git a/skills/benchmark_skills/toolathlon/course-schedule-analyzer/references/output_format.md b/skills/benchmark_skills/toolathlon/course-schedule-analyzer/references/output_format.md
new file mode 100644
index 0000000..e916646
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/course-schedule-analyzer/references/output_format.md
@@ -0,0 +1,36 @@
+# Output Format Reference
+
+## Excel File Structure
+All course selection scheme files must follow this format:
+
+### Headers (English)
+1. Course name
+2. Course ID
+3. Instructor
+4. Campus
+5. Class Time
+6. Enrollment
+7. Credits
+8. Assessment Method
+9. Exam Time
+10. Course Selection Restrictions
+
+### Data Values (Chinese)
+- All content values should be in Chinese.
+- Numeric values (Enrollment, Credits) should be numbers.
+- Class Time format: "周一 第2-3节 [1-16]" (Day Periods [Weeks])
+- Exam Time format: "YYYY-MM-DD HH:MM-HH:MM"
+- Course Selection Restrictions: Use "无" for no restrictions, or list restrictions separated by commas.
+
+### Example Row
+| Course name | Course ID | Instructor | Campus | Class Time | Enrollment | Credits | Assessment Method | Exam Time | Course Selection Restrictions |
+|-------------|-----------|------------|---------|------------|------------|---------|-------------------|-----------|-------------------------------|
+| 自然语言处理 | COMP130141.01 | 黄萱菁 | 邯郸校区 | 周一 第2-3节 [1-16] | 60 | 2 | 闭卷 | 2025-12-22 08:55-10:40 | 23 22 计算机科学与技术, 大数据与人工智能(2024), 大数据与人工智能(2023), 大数据与人工智能(2022) |
+
+## Naming Convention
+- Course selection scheme files: `course_selection_scheme_{n}.xlsx`
+- Where `{n}` starts from 1 and increments for each valid combination.
+
+## File Cleanup
+- Remove the reference format file after use if requested.
+- Keep only the final course selection scheme files in the workspace.
diff --git a/skills/benchmark_skills/toolathlon/course-schedule-analyzer/references/workflow_checklist.md b/skills/benchmark_skills/toolathlon/course-schedule-analyzer/references/workflow_checklist.md
new file mode 100644
index 0000000..0f22786
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/course-schedule-analyzer/references/workflow_checklist.md
@@ -0,0 +1,27 @@
+# Workflow Checklist
+
+## Phase 1: Setup
+- [ ] List workspace directory contents
+- [ ] Read reference format Excel file
+- [ ] Inspect PDF file (page count, structure)
+
+## Phase 2: Course Search
+- [ ] Search for each required course by name
+- [ ] Search for course categories (e.g., "思政B", "通识教育核心课程")
+- [ ] Extract detailed information from relevant pages
+
+## Phase 3: Filtering
+- [ ] Apply day of week filter (e.g., Monday only)
+- [ ] Apply exam type filter (e.g., open-book only)
+- [ ] Check for time conflicts between fixed courses
+- [ ] Identify all valid options for variable courses
+
+## Phase 4: Generation
+- [ ] Structure data according to reference format
+- [ ] Create separate Excel files for each valid scheme
+- [ ] Verify file content matches expected format
+
+## Phase 5: Cleanup & Summary
+- [ ] Remove temporary/reference files if requested
+- [ ] Provide clear summary of created files
+- [ ] List fixed courses and variable options
diff --git a/skills/benchmark_skills/toolathlon/critical-alert-logging-system/SKILL.md b/skills/benchmark_skills/toolathlon/critical-alert-logging-system/SKILL.md
new file mode 100644
index 0000000..832133c
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/critical-alert-logging-system/SKILL.md
@@ -0,0 +1,67 @@
+---
+name: critical-alert-logging-system
+description: When the user needs to create automated alerting systems with severity-based logging for critical events. This skill writes structured log entries to Google Cloud Logging buckets, formats critical warning messages with relevant identifiers (student IDs, names), uses appropriate severity levels (CRITICAL, WARNING), and integrates with notification systems. Triggers include requests for automated alerting, critical event logging, system notifications, or creating audit trails for important events.
+---
+# Instructions
+
+## Overview
+This skill automates the detection of critical events (e.g., significant performance drops) and logs structured, severity-based alerts to a Google Cloud Logging bucket. It is designed for scenarios requiring automated alerting, audit trails, and integration with notification systems.
+
+## Core Workflow
+1. **Data Acquisition & Analysis**
+ * Read the latest event/score data from a provided source (e.g., CSV file).
+ * Query historical data from a data warehouse (e.g., Google BigQuery) to establish a baseline or calculate trends.
+ * Perform comparative analysis (e.g., calculate percentage change, identify thresholds).
+
+2. **Threshold Evaluation & Categorization**
+ * Apply business logic to categorize events based on severity thresholds (e.g., >25% drop = WARNING, >45% drop = CRITICAL).
+ * Generate a structured list of all events exceeding the primary threshold.
+
+3. **Output Generation**
+ * **Primary Output:** Create a summary file (e.g., CSV) listing all identified events with relevant details (IDs, names, metrics, calculated drop).
+ * **Critical Alerting:** For events exceeding the highest severity threshold, write a structured log entry to the specified Google Cloud Logging bucket.
+
+## Execution Steps
+
+### 1. Initial Setup & Discovery
+* **Identify Input Source:** Locate and read the file containing the latest data (e.g., `latest_quiz_scores.csv`).
+* **Explore Data Warehouse:** Confirm the target dataset exists in BigQuery and list the relevant historical tables.
+* **Locate Logging Destination:** Identify the correct Google Cloud Logging bucket. Look for buckets with names matching the provided prefix (e.g., `exam_log`).
+
+### 2. Historical Baseline Calculation
+* Construct a SQL query to calculate the historical average/metric for each entity (e.g., student) by combining all relevant source tables.
+* Execute the query in BigQuery. Handle potential data truncation in outputs by requesting all rows or batching queries if necessary.
+
+### 3. Comparative Analysis
+* Join the latest data with the calculated historical averages.
+* Compute the performance metric (e.g., `(historical_avg - latest_score) / historical_avg`).
+* Filter results to isolate entities where the metric exceeds the defined warning threshold (e.g., >0.25).
+
+### 4. Generate Primary Output File
+* Format the filtered results into a CSV file.
+* Include essential columns: identifier, name, historical average, latest value, calculated percentage.
+* Save the file to the specified path (e.g., `bad_student.csv`).
+
+### 5. Critical Event Logging
+* From the primary results, filter again to isolate events exceeding the critical threshold (e.g., >0.45).
+* For each critical event:
+ * Format a clear, actionable log message. Include:
+ * **Severity Level:** `CRITICAL`
+ * **Event Description:** e.g., "CRITICAL ACADEMIC WARNING"
+ * **Identifying Information:** Name and ID of the entity.
+ * **Quantitative Detail:** The calculated drop percentage.
+ * **Action Required:** e.g., "Immediate counselor notification required."
+ * Write the formatted log entry to the identified Google Cloud Logging bucket using the `google-cloud-logging_write_log` tool.
+
+### 6. Verification & Completion
+* Read back the generated output file to confirm it was saved correctly.
+* Provide a final summary confirming:
+ * The total number of events identified.
+ * The number of critical events logged.
+ * The location of the output file.
+ * The name of the log bucket used for alerts.
+
+## Key Design Notes
+* **Modularity:** The analysis logic (BigQuery queries, percentage calculations) is separate from the alerting logic (log formatting and writing).
+* **Configurability:** Thresholds (25%, 45%) and log message templates should be considered parameters based on the user's request.
+* **Idempotency:** The skill does not consider log entries existing before execution, ensuring only new alerts are written for the current analysis run.
diff --git a/skills/benchmark_skills/toolathlon/critical-alert-logging-system/references/bigquery_query_templates.md b/skills/benchmark_skills/toolathlon/critical-alert-logging-system/references/bigquery_query_templates.md
new file mode 100644
index 0000000..4689a85
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/critical-alert-logging-system/references/bigquery_query_templates.md
@@ -0,0 +1,5 @@
+# BigQuery Query Templates for Historical Analysis
+
+## Core Query Patterns
+
+### 1. Calculate Historical Averages from Multiple Tables
diff --git a/skills/benchmark_skills/toolathlon/critical-alert-logging-system/references/logging_guidelines.md b/skills/benchmark_skills/toolathlon/critical-alert-logging-system/references/logging_guidelines.md
new file mode 100644
index 0000000..ef980f5
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/critical-alert-logging-system/references/logging_guidelines.md
@@ -0,0 +1,12 @@
+# Google Cloud Logging Guidelines for Critical Alerting
+
+## Log Entry Structure
+When writing critical alerts to Google Cloud Logging, structure your log entries for maximum utility:
+
+### Essential Components
+1. **Severity Level:** Use `CRITICAL` for events requiring immediate human intervention.
+2. **Clear Identification:** Include unique identifiers (Student ID, User ID, Transaction ID).
+3. **Human-Readable Message:** Describe what happened, why it's critical, and required action.
+4. **Quantitative Context:** Include relevant metrics (percentage drop, absolute values, thresholds).
+
+### Message Template
diff --git a/skills/benchmark_skills/toolathlon/csv-data-exporter/SKILL.md b/skills/benchmark_skills/toolathlon/csv-data-exporter/SKILL.md
new file mode 100644
index 0000000..6592a5b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/csv-data-exporter/SKILL.md
@@ -0,0 +1,80 @@
+---
+name: csv-data-exporter
+description: When the user needs to export analytical results or filtered datasets to CSV files for reporting or further processing. This skill formats data with appropriate headers, structures columns logically, handles numerical precision, sorts data meaningfully, and writes to specified file paths. Triggers include requests to save analysis results, create export files, generate reports in CSV format, or prepare data for external systems.
+---
+# Instructions
+
+## Primary Objective
+Export analytical results or filtered datasets to a CSV file with proper formatting, headers, and sorting.
+
+## Core Workflow
+
+### 1. Understand the Export Request
+- Identify the source data to be exported (e.g., query results, filtered lists, analysis outputs)
+- Clarify the desired output format: column names, data types, sorting order
+- Determine the destination file path
+
+### 2. Prepare Data for Export
+- **Structure Data Logically**: Organize columns in a meaningful sequence (ID, name, metrics, timestamps)
+- **Format Numerical Values**: Apply appropriate rounding/precision (typically 2 decimal places for percentages/float values)
+- **Handle Missing Data**: Decide on representation for null/empty values (empty string or "N/A")
+- **Sort Data Meaningfully**: Order by primary metric (descending for severity/drop percentages, ascending for IDs/names)
+
+### 3. Generate CSV File
+- Use `filesystem-write_file` to create the CSV
+- Include header row with descriptive column names
+- Ensure proper CSV formatting (comma-separated, proper escaping if needed)
+- Write all data rows according to the prepared structure
+
+### 4. Quality Verification
+- Read back the created file using `filesystem-read_file` to verify content
+- Check for correct row count and data integrity
+- Confirm proper formatting and sorting
+
+## Common Patterns from Trajectory
+
+### Pattern A: Exporting Query Results with Calculations
+When exporting results that involve calculations (like percentage drops):
+1. Run the analytical query to get the dataset
+2. Perform any necessary calculations/transformations in the query itself
+3. Format numerical results (e.g., `ROUND(value, 2)`)
+4. Sort by the key metric (e.g., `ORDER BY drop_percentage DESC`)
+5. Export with columns: identifier, name, metrics, calculated values
+
+### Pattern B: Multi-Source Data Integration
+When combining data from multiple sources (e.g., CSV + database):
+1. Read local CSV files using `filesystem-read_file`
+2. Query database tables using appropriate services (e.g., `google-cloud-bigquery_run_query`)
+3. Join/merge datasets using common identifiers
+4. Apply filtering criteria (e.g., `WHERE drop_percentage > threshold`)
+5. Export the integrated result set
+
+### Pattern C: Conditional Logging with Exports
+When export triggers additional actions (like critical alerts):
+1. Identify threshold conditions within the exported data
+2. For records meeting critical criteria, create log entries
+3. Use appropriate logging services (e.g., `google-cloud-logging_write_log`)
+4. Include identifying information (IDs, names) in log messages
+5. Set appropriate severity levels (e.g., "CRITICAL" for urgent notifications)
+
+## Best Practices
+
+### File Naming
+- Use descriptive names: `bad_student.csv`, `performance_report.csv`, `export_[date].csv`
+- Place in appropriate directories (e.g., `/workspace/dumps/workspace/`)
+
+### Data Presentation
+- Include all relevant context columns (IDs, names, timestamps)
+- Add calculated metrics as separate columns
+- Use clear, human-readable column headers
+- Maintain consistent formatting throughout
+
+### Error Handling
+- Verify file write operations succeeded
+- Check that expected row counts match
+- Validate data integrity after export
+
+## Related Skills
+- For data analysis before export: `data-analyzer`
+- For database querying: `bigquery-query-executor`
+- For log management: `logging-manager`
diff --git a/skills/benchmark_skills/toolathlon/csv-data-exporter/references/csv_export_patterns.md b/skills/benchmark_skills/toolathlon/csv-data-exporter/references/csv_export_patterns.md
new file mode 100644
index 0000000..fca4cdc
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/csv-data-exporter/references/csv_export_patterns.md
@@ -0,0 +1,91 @@
+# CSV Export Patterns Reference
+
+## Common Export Scenarios
+
+### 1. Academic Performance Analysis (from trajectory)
+**Context**: Export students with significant score drops
+**Columns**: student_id, name, avg_score, latest_score, drop_percentage
+**Sorting**: drop_percentage DESC
+**Precision**: 2 decimal places for scores/percentages
+**Threshold**: Filter by drop_percentage > 25
+
+### 2. Sales Report Export
+**Columns**: product_id, product_name, category, units_sold, revenue, growth_rate
+**Sorting**: revenue DESC
+**Precision**: 2 decimal places for monetary values, 1 for percentages
+
+### 3. System Log Analysis
+**Columns**: timestamp, severity, component, message, user_id
+**Sorting**: timestamp DESC (most recent first)
+**Formatting**: ISO timestamp format, severity as uppercase
+
+### 4. Inventory Management
+**Columns**: item_id, item_name, category, current_stock, reorder_level, last_restock
+**Sorting**: current_stock ASC (lowest stock first)
+**Threshold**: Filter by current_stock < reorder_level
+
+## Column Naming Conventions
+
+### Identifier Columns
+- Use consistent prefixes: `student_id`, `product_id`, `user_id`
+- Keep IDs as strings even if numeric: `'S001'` not `1`
+
+### Name/Description Columns
+- Use simple names: `name`, `product_name`, `description`
+- Avoid abbreviations: `customer_name` not `cust_nm`
+
+### Metric Columns
+- Be descriptive: `average_score` not `avg`
+- Include units if ambiguous: `price_usd`, `weight_kg`
+- For percentages: `drop_percentage`, `growth_rate_pct`
+
+### Date/Time Columns
+- Use ISO format: `2025-11-26T10:30:41`
+- Be specific: `created_at`, `updated_at`, `expiration_date`
+
+## Data Formatting Guidelines
+
+### Numerical Values
+- **Percentages**: Round to 2 decimal places (47.16%, 25.82%)
+- **Currency**: Round to 2 decimal places ($123.45, €67.89)
+- **Quantities**: Whole numbers for counts, decimals for measurements
+- **Ratios**: 3-4 decimal places for precision (0.125, 1.3333)
+
+### Text Values
+- **Trim whitespace**: Remove leading/trailing spaces
+- **Escape commas**: Use quotes if values contain commas
+- **Handle line breaks**: Replace with spaces or remove
+
+### Missing Values
+- **Empty strings**: "" for missing text
+- **Zero**: 0 for missing numerical values (if appropriate)
+- **"N/A"**: For explicitly unavailable data
+
+## Sorting Strategies
+
+### Primary Sort Keys
+1. **Severity metrics**: Highest values first (drop percentages, error counts)
+2. **Timestamps**: Most recent first for logs, oldest first for history
+3. **Alphabetical**: A-Z for names, categories
+4. **Priority levels**: Critical > High > Medium > Low
+
+### Secondary Sort Keys
+- After primary metric, sort by ID or name
+- For equal primary values, use natural ordering
+
+## File Management
+
+### Naming Conventions
+- Descriptive: `student_performance_2025-11-26.csv`
+- Include date: `export_YYYY-MM-DD.csv`
+- Include scope: `department_sales_q4.csv`
+- Version if needed: `report_v2.csv`
+
+### Directory Structure
+- `/workspace/exports/` for general exports
+- `/workspace/reports/` for finalized reports
+- `/workspace/dumps/` for intermediate/temporary files
+
+## Integration Patterns
+
+### With BigQuery
diff --git a/skills/benchmark_skills/toolathlon/csv-data-exporter/references/tool_usage_guide.md b/skills/benchmark_skills/toolathlon/csv-data-exporter/references/tool_usage_guide.md
new file mode 100644
index 0000000..832caab
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/csv-data-exporter/references/tool_usage_guide.md
@@ -0,0 +1,6 @@
+# Tool Usage Guide for CSV Export
+
+## Core Tools for CSV Export Workflow
+
+### 1. filesystem-read_file
+**Purpose**: Read source data from CSV files
diff --git a/skills/benchmark_skills/toolathlon/dataset-license-resolver/SKILL.md b/skills/benchmark_skills/toolathlon/dataset-license-resolver/SKILL.md
new file mode 100644
index 0000000..9734728
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/dataset-license-resolver/SKILL.md
@@ -0,0 +1,66 @@
+---
+name: dataset-license-resolver
+description: When the user needs to determine and document licenses for datasets or AI models, particularly when dealing with derivative works or synthesized content. This skill handles 1) Identifying direct data sources and models used in dataset creation, 2) Researching original licenses from upstream repositories (GitHub, Hugging Face), 3) Comparing license permissiveness for derivative/secondary use, 4) Applying the most appropriate license based on user requirements, 5) Updating documentation and repository metadata with license information. Triggers include license inquiries, dataset attribution requests, compliance documentation needs, repository metadata updates, and derivative work licensing questions.
+---
+# Instructions
+
+## 1. Understand the Request
+- Parse the user's request to identify:
+ - The specific datasets/models in question
+ - The user's license selection criteria (e.g., "most permissive for derivative use")
+ - Required output format (e.g., issue reply, README updates)
+ - Any authentication tokens needed (e.g., `.hf_token`)
+
+## 2. Investigate Data Sources
+**For each dataset/model mentioned:**
+- **GitHub Repositories:**
+ - Use `github-get_file_contents` to examine repository structure and README
+ - Look for license files (LICENSE, LICENSE.md, etc.) and documentation
+- **Hugging Face Resources:**
+ - Use `huggingface-hub_repo_details` to get metadata including license tags
+ - Use `fetch-fetch_markdown` to retrieve full README/content
+ - Search for related datasets/models using `huggingface-dataset_search` or `huggingface-model_search`
+- **Trace Provenance:**
+ - Follow references to original sources (e.g., "adopted from HuggingFaceTB team")
+ - Identify base models used for synthesis (e.g., "uses DeepSeek-V2.5")
+
+## 3. Determine License Hierarchy
+**When multiple sources exist:**
+1. **Identify direct sources:** For raw/derived datasets, find the original data source
+2. **Identify synthesis models:** For processed/transformed datasets, find the models used for generation
+3. **Compare licenses:** Evaluate which is more permissive for derivative/secondary use based on:
+ - Attribution requirements
+ - Use-based restrictions
+ - Commercial use allowances
+ - Redistribution terms
+
+## 4. Apply License Selection Logic
+**Follow user's priority rules:**
+- If user specifies "most permissive for derivative/secondary use," compare licenses and select the one with fewer restrictions
+- If user specifies "directly reuse license from source," use the identified source's license
+- Document the reasoning for license selection
+
+## 5. Execute Required Actions
+**Based on user requirements:**
+- **Reply to Issues:**
+ - Format response exactly as specified by user
+ - Include all required placeholders filled with determined licenses
+- **Update Documentation:**
+ - Retrieve current README/content using appropriate tools
+ - Append license section at the end as specified
+ - Maintain existing formatting and content
+- **Authentication:**
+ - Use provided tokens (e.g., read `.hf_token` file)
+ - Pass tokens to API calls as needed
+
+## 6. Complete and Close
+- Verify all actions completed successfully
+- Provide confirmation of updates made
+- Close issues if requested
+- Claim task completion
+
+## Key Considerations
+- **License Types:** Be familiar with common licenses (MIT, Apache-2.0, CC-BY, etc.) and custom licenses (DeepSeek License, The Stack Terms of Use)
+- **Provenance Chains:** Some datasets may have multiple layers of derivation; trace back to the original source
+- **Format Compliance:** Strictly adhere to user-specified output formats; do not modify, add, or remove content outside placeholders
+- **Error Handling:** If license information cannot be determined, document the investigation and ask for clarification
diff --git a/skills/benchmark_skills/toolathlon/dataset-license-resolver/assets/issue_response_template.md b/skills/benchmark_skills/toolathlon/dataset-license-resolver/assets/issue_response_template.md
new file mode 100644
index 0000000..938165a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/dataset-license-resolver/assets/issue_response_template.md
@@ -0,0 +1,6 @@
+Thanks for your interest! The licenses for the datasets are:
+
+- **{dataset1_name}** = {dataset1_license}
+- **{dataset2_name}** = {dataset2_license}
+
+The license information has been added to the respective Hugging Face dataset pages.
diff --git a/skills/benchmark_skills/toolathlon/dataset-license-resolver/assets/license_template.md b/skills/benchmark_skills/toolathlon/dataset-license-resolver/assets/license_template.md
new file mode 100644
index 0000000..1acab36
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/dataset-license-resolver/assets/license_template.md
@@ -0,0 +1,23 @@
+# License Information
+
+## For Raw/Base Datasets
+**Dataset:** {dataset_name}
+**Source:** {original_source}
+**License:** {license_type}
+**Terms:** {license_terms}
+
+## For Processed/Synthesized Datasets
+**Dataset:** {dataset_name}
+**Processing Method:** {processing_method}
+**Base Model Used:** {base_model}
+**Model License:** {model_license}
+**Final License:** {final_license}
+
+## Attribution Requirements
+{attribution_instructions}
+
+## Use Restrictions
+{restrictions_list}
+
+## For Derivative Works
+{derivative_guidelines}
diff --git a/skills/benchmark_skills/toolathlon/dataset-license-resolver/references/license_comparison.md b/skills/benchmark_skills/toolathlon/dataset-license-resolver/references/license_comparison.md
new file mode 100644
index 0000000..962324d
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/dataset-license-resolver/references/license_comparison.md
@@ -0,0 +1,49 @@
+# License Comparison Guide
+
+## Common License Types for AI/Data
+
+### Permissive Licenses (Most to Least)
+1. **MIT License** - Very permissive, allows almost any use with attribution
+2. **Apache-2.0** - Similar to MIT but with patent protection
+3. **BSD-3-Clause** - Requires attribution and disclaimer
+4. **CC-BY-4.0** - Creative Commons Attribution, allows derivatives
+
+### Restricted/Custom Licenses
+- **DeepSeek License** - Use-based restrictions (see Attachment A for prohibited uses)
+- **The Stack Terms of Use** - Requires attribution and compliance with original source licenses
+- **Other (custom)** - Varies by project; requires reading specific terms
+
+## Derivative Work Considerations
+
+### Most Permissive for Derivatives:
+1. MIT/Apache-2.0/BSD - Allow commercial use, modification, distribution
+2. CC-BY - Allows derivatives with attribution
+3. The Stack Terms - Allows derivatives but requires chain of attribution
+4. DeepSeek License - Allows derivatives but with use restrictions
+
+### Key Factors for Comparison:
+1. **Attribution Requirements:** How must credit be given?
+2. **Use Restrictions:** Are there prohibited applications?
+3. **Commercial Use:** Is commercial use allowed?
+4. **Redistribution:** Can the work be shared/modified?
+5. **Patent Protection:** Does the license include patent grants?
+
+## Investigation Checklist
+
+### For GitHub Repositories:
+1. Check for LICENSE, LICENSE.md, COPYING files
+2. Examine README for license mentions
+3. Check package configuration (setup.py, pyproject.toml)
+4. Look for SPDX identifiers in source headers
+
+### For Hugging Face Resources:
+1. Check metadata tags (license:apache-2.0, license:other, etc.)
+2. Read dataset/model card thoroughly
+3. Look for "Terms of Use" or "License" sections
+4. Check linked papers or documentation
+
+### For Derived Works:
+1. Trace provenance statements ("adopted from", "based on")
+2. Identify original sources mentioned in documentation
+3. Check for attribution requirements
+4. Determine if the work is a direct copy, transformation, or synthesis
diff --git a/skills/benchmark_skills/toolathlon/distance-matrix-calculator/SKILL.md b/skills/benchmark_skills/toolathlon/distance-matrix-calculator/SKILL.md
new file mode 100644
index 0000000..03d26e0
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/distance-matrix-calculator/SKILL.md
@@ -0,0 +1,56 @@
+---
+name: distance-matrix-calculator
+description: Calculates distances and travel times between multiple locations for route planning or optimization. Computes a complete distance matrix, supports different travel modes, and returns both distance and time estimates.
+---
+# Instructions
+
+## Primary Objective
+When the user requests route planning, optimization, or distance calculations between multiple points, use this skill to compute the most efficient path. The core task is to generate a **complete distance and time matrix** between all specified locations and then determine the optimal visiting order (solving a Traveling Salesman Problem - TSP) when a starting point is defined.
+
+## Core Workflow
+
+### 1. Parse the Request & Gather Locations
+- **Identify Attractions/Destinations:** Extract all locations the user wants to visit from their request and any referenced documents (e.g., `recommendation.md`). List each attraction separately, even if they are close.
+- **Identify the Starting Point:** Determine the user's current location or specified starting point (e.g., "I am currently at X").
+- **Geocode All Points:** Use `google_map-maps_geocode` or `google_map-maps_search_places` to obtain precise latitude/longitude coordinates and formatted addresses for **every location** (starting point + all destinations).
+
+### 2. Generate the Distance Matrix
+- Use `google_map-maps_distance_matrix` with all gathered coordinates as both `origins` and `destinations`.
+- Set the `mode` parameter based on the request (e.g., `"walking"`, `"driving"`). Default to `"walking"` if unspecified.
+- **Output Analysis:** The tool returns a matrix. Extract the `distance.value` (meters) and `duration.value` (seconds) for every origin-destination pair. Organize this data into clear numerical arrays for calculation.
+
+### 3. Calculate the Optimal Route (TSP)
+- **Goal:** Find the shortest total travel path that starts at the given starting point and visits all destination points exactly once.
+- **Method:** For a small number of points (n ≤ 6), perform a **brute-force search** over all possible permutations of destinations.
+- **Process:**
+ 1. Fix the starting point as the first location in the sequence.
+ 2. Generate all possible orders (permutations) for the remaining destination points.
+ 3. For each permutation, sum the distances between consecutive points using the pre-computed matrix.
+ 4. Identify the permutation with the **minimum total distance**.
+- **Validation:** Manually check a few of the top-performing routes to ensure the result is logical (e.g., doesn't criss-cross unnecessarily).
+
+### 4. Generate Detailed Directions
+- For each leg of the chosen optimal route, use `google_map-maps_directions` to get turn-by-turn navigation instructions.
+- Extract and format the `summary`, `distance.text`, `duration.text`, and key steps from `steps[n].instructions`.
+
+### 5. Format and Save the Output
+- Structure the final plan according to any user-specified format (e.g., a provided `format.json` template).
+- The output must include:
+ - `road_plan`: An array for each leg with `from`, `to`, `distance`, `estimated_time`, and `directions`.
+ - `total_distance`: The sum of all leg distances.
+ - `total_time`: The sum of all leg durations.
+- Save the final JSON file using `filesystem-write_file`.
+- **Verify** the written file using `filesystem-read_file`.
+
+## Key Triggers & User Phrases
+- "Plan the shortest walking/driving route"
+- "Optimize the visiting order"
+- "Calculate distances between these places"
+- "Give me a tour of all these attractions"
+- "Find the most efficient path"
+
+## Error Handling & Assumptions
+- **Missing Coordinates:** If a place cannot be found, use a broader search query or ask the user for clarification.
+- **Matrix Errors:** If the distance matrix call fails for some pairs, you may need to call the directions API for those specific pairs as a fallback.
+- **Time vs. Distance Optimization:** By default, optimize for **shortest total distance**. If the user specifies "fastest route," optimize for **shortest total time**.
+- **Single Destination:** If only one destination is provided, simply return the direct route from start to finish.
diff --git a/skills/benchmark_skills/toolathlon/distance-matrix-calculator/references/format_templates.json b/skills/benchmark_skills/toolathlon/distance-matrix-calculator/references/format_templates.json
new file mode 100644
index 0000000..9a12123
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/distance-matrix-calculator/references/format_templates.json
@@ -0,0 +1,53 @@
+{
+ "route_plan_template": {
+ "description": "Standard template for outputting a calculated route plan.",
+ "template": {
+ "road_plan": [
+ {
+ "from": "Location A name and brief identifier",
+ "to": "Location B name and brief identifier",
+ "distance": "Formatted distance with units (e.g., '162 m (0.1 mi)')",
+ "estimated_time": "Formatted duration (e.g., '2 mins')",
+ "directions": "Concise, human-readable turn-by-turn instructions from the directions API."
+ }
+ ],
+ "total_distance": "Formatted total distance with units",
+ "total_time": "Formatted total duration"
+ },
+ "example": {
+ "road_plan": [
+ {
+ "from": "UPenn Bookstore (Starting Point)",
+ "to": "ENIAC (Moore Building, Penn School of Engineering)",
+ "distance": "162 m (0.1 mi)",
+ "estimated_time": "2 mins",
+ "directions": "Head east on Smith Walk toward S 33rd St (take the stairs). Turn left onto S 33rd St. Destination will be on the left."
+ }
+ ],
+ "total_distance": "1.117 km (0.7 mi)",
+ "total_time": "16 mins"
+ }
+ },
+ "distance_matrix_template": {
+ "description": "Template for presenting the raw distance/time matrix data.",
+ "template": {
+ "points": [
+ {"index": 0, "name": "Point A", "address": "Full address", "coordinates": {"lat": 00.000000, "lng": -00.000000}}
+ ],
+ "distance_matrix": [
+ [0, 100, 200],
+ [100, 0, 150],
+ [200, 150, 0]
+ ],
+ "time_matrix": [
+ [0, 60, 120],
+ [60, 0, 90],
+ [120, 90, 0]
+ ],
+ "units": {
+ "distance": "meters",
+ "time": "seconds"
+ }
+ }
+ }
+}
diff --git a/skills/benchmark_skills/toolathlon/distance-matrix-calculator/references/google_maps_api_guide.md b/skills/benchmark_skills/toolathlon/distance-matrix-calculator/references/google_maps_api_guide.md
new file mode 100644
index 0000000..656e9a5
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/distance-matrix-calculator/references/google_maps_api_guide.md
@@ -0,0 +1,21 @@
+# Google Maps API Usage Guide
+
+## Core Tools for Distance Matrix Skill
+
+### 1. `google_map-maps_geocode`
+Converts a human-readable address into geographic coordinates.
+- **Use Case:** Getting precise lat/lng for a known address (e.g., "University of Pennsylvania Bookstore").
+- **Input:** `{"address": "Full address string"}`
+- **Output:** Contains `location.lat`, `location.lng`, `formatted_address`.
+
+### 2. `google_map-maps_search_places`
+Finds places by name/query near a location. More flexible than geocode for landmarks.
+- **Use Case:** Finding "Benjamin Franklin Statue University of Pennsylvania".
+- **Input:** `{"query": "Search string", "location": {"latitude": XX.X, "longitude": XX.X}, "radius": 2000}`
+- **Output:** Array of `places` with `name`, `formatted_address`, `location`.
+
+### 3. `google_map-maps_distance_matrix`
+**THE CORE TOOL.** Calculates travel distance and time between multiple origins and destinations.
+- **Use Case:** Generating the complete cost matrix for TSP.
+- **Input:**
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/ecommerce-customer-onboarding-automator/SKILL.md b/skills/benchmark_skills/toolathlon/ecommerce-customer-onboarding-automator/SKILL.md
new file mode 100644
index 0000000..dba86c6
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/ecommerce-customer-onboarding-automator/SKILL.md
@@ -0,0 +1,64 @@
+---
+name: ecommerce-customer-onboarding-automator
+description: Automates customer onboarding workflows for e-commerce platforms. Fetches recent WooCommerce orders, identifies first-time customers within a specified timeframe, syncs their information to a BigQuery CRM database, and sends personalized welcome emails using a template.
+---
+# Instructions
+
+## Objective
+Automate the onboarding process for new e-commerce customers by:
+1. Identifying customers who completed their **first order** within the **past 7 days**.
+2. Syncing their core information (name, email, order details) from WooCommerce to a BigQuery CRM table.
+3. Sending a personalized welcome email to each identified customer.
+
+## Prerequisites & Setup
+* **WooCommerce Connection:** Ensure access to the WooCommerce store's API (`woocommerce-woo_orders_list`).
+* **BigQuery Dataset:** Confirm the target BigQuery dataset (e.g., `woocommerce_crm`) and table (e.g., `new_customers`) exist. The table should have at least these columns: `customer_name` (STRING), `email` (STRING), `order_id` (INT64), `order_date` (TIMESTAMP), `order_total` (FLOAT64).
+* **Email Template:** Locate or create the `welcome_email_template.md` file. The skill expects to find it at `/workspace/dumps/workspace/` by default.
+
+## Execution Steps
+
+### 1. Fetch and Analyze Recent Orders
+* Use `woocommerce-woo_orders_list` to retrieve completed orders. Start with parameters: `{"status": ["completed"], "perPage": 100, "order": "desc", "orderby": "date"}`.
+* **Critical Logic:** Analyze the order metadata. In the provided trajectory, orders from first-time customers within the past 7 days were tagged with `"period": "recent_7_days"` in their `meta_data`. You must implement a similar filtering logic based on your store's data structure.
+ * **First-Time Customer Check:** Ensure a customer's email appears only once in the filtered set (or check against a historical customer list in BigQuery if available).
+ * **Date Filtering:** Use the `date_completed` field and calculate if it falls within the last 7 days from the current date.
+
+### 2. Locate and Read the Email Template
+* Use `filesystem-search_files` to find `welcome_email_template.md`.
+* Use `filesystem-read_file` to load its content. The template should contain placeholders like `{{customer_name}}`, `{{order_id}}`, `{{order_total}}`, and `{{order_date}}`.
+
+### 3. Prepare BigQuery Environment
+* Use `google-cloud-bigquery_list_datasets` and `google-cloud-bigquery_get_dataset_info` to verify the target dataset exists.
+* Use `google-cloud-bigquery_run_query` to inspect the `INFORMATION_SCHEMA` and confirm the schema of the target table (e.g., `new_customers`) matches the data you will insert.
+
+### 4. Transform and Sync Customer Data
+* For each identified first-time customer, extract:
+ * `customer_name`: Combine `billing.first_name` and `billing.last_name`.
+ * `email`: From `billing.email`.
+ * `order_id`: The order's `id`.
+ * `order_date`: Convert `date_completed` to a TIMESTAMP.
+ * `order_total`: The order's `total` (as a float).
+* Construct a single `INSERT` query for BigQuery with all customer values. Use parameterized values or explicit casting (e.g., `TIMESTAMP('...')`) to ensure data type compatibility.
+* Execute the insert query using `google-cloud-bigquery_run_query`.
+* **Verification:** Run a `SELECT` query to confirm all records were inserted correctly.
+
+### 5. Generate and Send Welcome Emails
+* For each customer, personalize the email template by replacing the placeholders with their specific data.
+* Use `emails-send_email` to send the email.
+ * **Subject:** Follow the template's subject line.
+ * **Body:** Use the fully personalized email body.
+ * **To:** The customer's email address.
+* Send emails sequentially or in small batches to avoid rate limits.
+
+## Key Decisions & Error Handling
+* **Pagination:** If you have more than 100 recent orders, implement pagination using the `page` parameter in `woocommerce-woo_orders_list`.
+* **Duplicate Prevention:** Before inserting into BigQuery, consider checking if the `email` or `order_id` already exists in the target table to prevent duplicates if the skill runs multiple times.
+* **Template Flexibility:** The skill is designed to use an external template file. If the file is not found, you may need to create a default template or ask the user for its location.
+* **Email Send Errors:** Log or note if any email fails to send, but proceed with the remaining customers.
+
+## Completion
+After all emails are sent, provide a summary report including:
+* The number of first-time customers identified.
+* Confirmation of data sync to BigQuery.
+* Confirmation of emails sent.
+* Use `local-claim_done` to mark the task as complete.
diff --git a/skills/benchmark_skills/toolathlon/ecommerce-customer-onboarding-automator/references/bigquery_schema.md b/skills/benchmark_skills/toolathlon/ecommerce-customer-onboarding-automator/references/bigquery_schema.md
new file mode 100644
index 0000000..dcf4753
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/ecommerce-customer-onboarding-automator/references/bigquery_schema.md
@@ -0,0 +1,19 @@
+# BigQuery Table Schema: `new_customers`
+
+This reference details the target table schema used for syncing new customer data from WooCommerce.
+
+## Table Location
+* **Project:** `toolathlon-eval-ds`
+* **Dataset:** `woocommerce_crm`
+* **Table:** `new_customers`
+
+## Column Definitions
+| Column Name | Data Type | Description | Source (WooCommerce Order Field) |
+| :--- | :--- | :--- | :--- |
+| `customer_name` | STRING | Full name of the customer. | `billing.first_name` + `billing.last_name` |
+| `email` | STRING | Customer's email address. | `billing.email` |
+| `order_id` | INT64 | Unique identifier of the customer's first order. | `id` |
+| `order_date` | TIMESTAMP | Date and time the order was completed (UTC). | `date_completed_gmt` |
+| `order_total` | FLOAT64 | Total amount of the order. | `total` |
+
+## Sample INSERT Query
diff --git a/skills/benchmark_skills/toolathlon/ecommerce-customer-onboarding-automator/references/email_template_example.md b/skills/benchmark_skills/toolathlon/ecommerce-customer-onboarding-automator/references/email_template_example.md
new file mode 100644
index 0000000..e312b04
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/ecommerce-customer-onboarding-automator/references/email_template_example.md
@@ -0,0 +1,11 @@
+# Welcome Email Template Example
+
+This is an example of the template file (`welcome_email_template.md`) the skill expects to find and use.
+
+## File Purpose
+Stores the markdown-formatted content for the welcome email, containing placeholders for personalization.
+
+## Expected Location
+`/workspace/dumps/workspace/welcome_email_template.md`
+
+## Template Content
diff --git a/skills/benchmark_skills/toolathlon/educational-material-analyzer/SKILL.md b/skills/benchmark_skills/toolathlon/educational-material-analyzer/SKILL.md
new file mode 100644
index 0000000..8bf3530
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/educational-material-analyzer/SKILL.md
@@ -0,0 +1,42 @@
+---
+name: educational-material-analyzer
+description: When a student requests help with studying course materials (presentations, PDFs, lecture notes) and needs comprehensive study notes created. This skill extracts key concepts from educational files (PPTX, PDF), summarizes definitions and differences, includes code examples with explanations, and answers assignment questions. It's triggered by requests involving 'study', 'lecture notes', 'course materials', 'presentation analysis', or 'homework explanation' with file types like .pptx, .pdf, .md.
+---
+# Instructions
+
+## 1. Initial Setup & File Discovery
+1. **Identify Request Type:** Confirm the user is a student needing help with course materials (presentations, PDFs, notes).
+2. **Locate Files:** The user will typically mention specific filenames (e.g., `Compile.pptx`, `HW.PDF`).
+ * Use `filesystem-list_directory` to verify file existence and correct paths in the workspace.
+ * Handle case sensitivity or extension variations (e.g., `.pdf` vs `.PDF`).
+
+## 2. Content Extraction & Analysis
+3. **Open Presentation:** Use `pptx-open_presentation` on the specified `.pptx` file to get a presentation ID.
+4. **Extract Presentation Text:** Use `pptx-extract_presentation_text` with `include_slide_info: true` on the obtained ID. This provides structured slide data including titles, text, and tables.
+5. **Read PDF Content:** Use `pdf-tools-read_pdf_pages` on the specified `.pdf` file (e.g., homework). Extract all relevant pages.
+
+## 3. Structured Note Creation
+6. **Create Output File:** Use `filesystem-write_file` to create a new markdown file (e.g., `NOTE.md`).
+7. **Build Note Structure:** Synthesize the extracted content into a well-organized study note. Follow this template:
+ * **Header:** Course name and chapter/topic.
+ * **Overview:** Summarize the main topic's purpose (from early slides).
+ * **Core Definitions:** Clearly define key terms (e.g., "Symbol Table", "Environment").
+ * **Comparative Analysis:** When concepts have different styles/implementations (e.g., Functional vs. Imperative), create a dedicated section comparing them. Use a table for clear contrast.
+ * **Code Integration:** For all code snippets found in the materials:
+ * Create a dedicated "Code Examples" section.
+ * Group related code blocks logically.
+ * **For each block:** Provide the exact code and a concise **Explanation** beneath it, detailing what it does and why it's important.
+ * **Assignment Analysis:** For homework/assignment PDFs:
+ * List each question.
+ * Provide a clear, step-by-step explanation of the solution.
+ * State the final answer.
+ * **Summary:** Add a final summary or comparison table recapping the most critical takeaways.
+
+## 4. Principles for Content Synthesis
+* **Clarity Over Comprehensiveness:** Prioritize explaining the "why" behind concepts, not just listing "what".
+* **Connect Theory & Practice:** Explicitly link definitions to their code implementations.
+* **Answer Directly:** For assignment questions, provide the answer clearly after the explanation.
+* **Verify Output:** Optionally, use `filesystem-read_file` to confirm the note was created successfully.
+
+## 5. Final Response
+8. Inform the user the note has been created and provide a brief summary of its contents, highlighting the definitions, comparisons, code explanations, and homework answers you included.
diff --git a/skills/benchmark_skills/toolathlon/educational-material-analyzer/references/note_template.md b/skills/benchmark_skills/toolathlon/educational-material-analyzer/references/note_template.md
new file mode 100644
index 0000000..db77298
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/educational-material-analyzer/references/note_template.md
@@ -0,0 +1,52 @@
+# [Course Name] - [Chapter/Topic]
+## Lecture Notes: [Specific Topic]
+
+---
+
+## 1. Overview of [Topic]
+
+[Brief 2-3 sentence summary of the topic's purpose and main goals, extracted from introductory slides.]
+
+---
+
+## 2. Core Definitions
+
+### What is a [Term]?
+A **[term]** is... [Clear definition from materials].
+
+**Key Concepts:**
+* Concept 1: Explanation.
+* Concept 2: Explanation.
+
+---
+
+## 3. [Concept A] vs. [Concept B]
+
+### 3.1 [Concept A] Style
+**Definition:** [Precise definition].
+**Characteristics:**
+* Characteristic 1
+* Characteristic 2
+**Implementation:** [Data structure used and key operational logic].
+
+### 3.2 [Concept B] Style
+**Definition:** [Precise definition].
+**Characteristics:**
+* Characteristic 1
+* Characteristic 2
+**Implementation:** [Data structure used and key operational logic].
+
+### Comparison Table
+| Aspect | [Concept A] | [Concept B] |
+|--------|-------------|-------------|
+| **Core Principle** | ... | ... |
+| **Data Structure** | ... | ... |
+| **Operation (e.g., Insert)** | ... | ... |
+| **Advantage** | ... | ... |
+| **Disadvantage** | ... | ... |
+
+---
+
+## 4. Code Examples with Explanations
+
+### 4.1 [Example Name/Function]
diff --git a/skills/benchmark_skills/toolathlon/email-search-analyzer/SKILL.md b/skills/benchmark_skills/toolathlon/email-search-analyzer/SKILL.md
new file mode 100644
index 0000000..60675ac
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/email-search-analyzer/SKILL.md
@@ -0,0 +1,45 @@
+---
+name: email-search-analyzer
+description: When the user needs to search and analyze emails for specific content patterns, particularly for tracking submissions, communications, or specific file types. This skill performs intelligent email searches with multiple keyword variations, extracts structured information from email subjects and metadata, and identifies patterns in submission data. Triggers include searching for assignment submissions, finding emails with specific patterns, extracting submission timestamps, analyzing email metadata, and identifying submission confirmation messages.
+---
+# Instructions
+
+## Core Workflow
+1. **Clarify & Parse Request:** Understand the user's goal. Identify the key submission or communication pattern to search for (e.g., "final presentation", "homework 3", "report submission"). Note any specific folders, senders, or date ranges.
+2. **Perform Intelligent Email Search:**
+ * Start with the user's specified keywords.
+ * If initial search yields no results, automatically try related keyword variations (e.g., "presentation" if "final presentation" fails, or "NLP" for a course code).
+ * Use the `emails-search_emails` tool. Search in the specified folder (default: INBOX). Use a sufficient `page_size` (e.g., 50) to capture all relevant emails.
+ * Extract and log the total number of results.
+3. **Analyze Submission Patterns & Extract Data:**
+ * Examine email subjects and metadata (From, Date).
+ * Look for structured patterns in subjects (e.g., `nlp-presentation-<StudentID>-<Name>`). Extract identifiers (IDs, names) into a list.
+ * Note the submission timeframe from email dates.
+4. **Cross-Reference with External Data (if applicable):**
+ * If the user provides a reference file (e.g., student roster Excel file), load and parse it.
+ * Use tools like `excel-get_workbook_metadata` and `excel-read_data_from_excel` to read the data.
+ * Identify the relevant columns (e.g., Student ID, Name, Email, Status/Notes).
+5. **Identify Discrepancies & Target List:**
+ * Compare the list of submitters (from emails) against the master list (from reference data).
+ * Identify individuals who are on the master list but **not** in the submission list.
+ * **Apply filters:** Exclude individuals based on status notes (e.g., "withdrew", "auditing") from the target list for reminders.
+ * Compile the final list of non-submitters with their associated contact info (email, ID, name).
+6. **Execute Follow-up Actions (if requested):**
+ * If the task requires sending notifications (e.g., reminder emails), draft and send personalized messages.
+ * Use a subject and body format specified by the user. **Always include the recipient's name and ID in the body** to personalize the message and avoid spam filters.
+ * Use the `emails-send_email` tool for each recipient.
+7. **Summarize Findings:**
+ * Provide a clear summary including:
+ * Total emails found matching the pattern.
+ * Number of unique submitters identified.
+ * Number of individuals missing submissions (after applying filters).
+ * List of non-submitters (IDs, Names).
+ * Confirmation of any actions taken (e.g., "Reminder emails sent to X and Y").
+ * Mention any excluded individuals and the reason (e.g., withdrawn, auditing).
+
+## Key Principles
+* **Keyword Flexibility:** Don't rely on a single search term. Iterate through logical variations.
+* **Pattern Recognition:** Actively look for and decode structured data within email subjects and metadata.
+* **Data Hygiene:** Always cross-check and filter lists using available status/note fields before taking action.
+* **Personalization & Anti-Spam:** Include identifiable user details (name, ID) in any communication body.
+* **Clear Reporting:** Structure the final summary to answer the user's original query explicitly.
diff --git a/skills/benchmark_skills/toolathlon/email-search-analyzer/references/email_patterns.md b/skills/benchmark_skills/toolathlon/email-search-analyzer/references/email_patterns.md
new file mode 100644
index 0000000..49a04e7
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/email-search-analyzer/references/email_patterns.md
@@ -0,0 +1,35 @@
+# Common Email Patterns for Submission Tracking
+
+## Subject Line Patterns
+When searching for submissions, look for these common patterns in email subjects:
+
+### Academic Assignments
+* `[Course]-[AssignmentType]-[ID]-[Name]` - `nlp-presentation-2000016605-Carol Carter`
+* `Submission: [Assignment Name] - [Student Name]`
+* `[Student ID] - [Assignment]`
+* `[Course Code] Assignment [Number] Submission`
+
+### Project/File Submissions
+* `[Project Name] - Final Deliverables - [Team/Name]`
+* `Attached: [Filename] for [Purpose]`
+* `[Document Type] Submission: [Title]`
+
+### General Keywords to Try
+If a specific search fails, iterate through these related terms:
+1. Primary term: `"final presentation"`
+2. Broader term: `"presentation"`
+3. Course code: `"NLP"`
+4. Assignment type: `"submission"`, `"assignment"`, `"homework"`
+5. File indicators: `"attached"`, `"attachment"`, `"file"`
+
+## Metadata Extraction
+From each relevant email, extract:
+* **Subject:** Parse for IDs, names, assignment types.
+* **From:** Sender's email address (may be student or system).
+* **Date:** Submission timestamp.
+* **Body/Attachments:** May contain additional identifiers or confirmation details.
+
+## Cross-Referencing Strategy
+1. **Identifier Matching:** Use the most unique identifier available (Student ID > Name).
+2. **Normalization:** Remove spaces, convert to consistent case when comparing.
+3. **Status Filtering:** Always check for status notes like "withdrew", "dropped", "auditing", "incomplete" before flagging as non-submitter.
diff --git a/skills/benchmark_skills/toolathlon/email-search-analyzer/references/reminder_template.md b/skills/benchmark_skills/toolathlon/email-search-analyzer/references/reminder_template.md
new file mode 100644
index 0000000..8eec6ec
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/email-search-analyzer/references/reminder_template.md
@@ -0,0 +1,8 @@
+# Reminder Email Template
+
+Use this template structure when sending reminder emails for missing submissions. Personalization is critical to avoid spam filters.
+
+## Subject Line
+`[Course/Project]-emergency` or as specified by user.
+
+## Body Structure
diff --git a/skills/benchmark_skills/toolathlon/employee-contact-manager/SKILL.md b/skills/benchmark_skills/toolathlon/employee-contact-manager/SKILL.md
new file mode 100644
index 0000000..55858d6
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/employee-contact-manager/SKILL.md
@@ -0,0 +1,104 @@
+---
+name: employee-contact-manager
+description: When the user needs to retrieve and manage employee contact information and organizational hierarchy for notification purposes. This skill queries employee databases to extract contact details, manager relationships, and department information, enabling automated notifications to employees and their managers. Triggers include employee lookup, manager identification, contact information retrieval, organizational hierarchy queries, or when preparing notifications for expense claim reviews.
+---
+# Employee Contact Manager
+
+## Purpose
+Retrieve and organize employee contact information, manager relationships, and department details from enterprise databases to facilitate automated notifications and workflow approvals.
+
+## Primary Triggers
+- Need to send notifications to employees regarding expense claims, approvals, or reviews
+- Requirement to identify managers for CC or escalation purposes
+- Employee lookup by ID, name, or department
+- Organizational hierarchy queries for reporting or workflow routing
+
+## Core Workflow
+
+### 1. Database Discovery
+First, identify available databases containing employee information:
+- Use `snowflake-list_databases()` to list all databases
+- Look for databases with names suggesting employee/contact data (e.g., "HR", "EMPLOYEES", "CONTACTS")
+
+### 2. Schema and Table Exploration
+For identified databases:
+- Use `snowflake-list_schemas()` to explore available schemas (typically "PUBLIC" or "HR")
+- Use `snowflake-list_tables()` to find relevant tables (e.g., "EMPLOYEE_CONTACTS", "ENTERPRISE_CONTACTS", "EMPLOYEES")
+
+### 3. Table Structure Analysis
+Examine the structure of identified contact tables:
+- Use `snowflake-describe_table()` to understand column structure
+- Key columns to look for:
+ - Employee identifiers: `EMPLOYEE_ID`, `ID`
+ - Contact info: `EMAIL`, `NAME`, `PHONE`
+ - Organizational data: `DEPARTMENT`, `EMPLOYEE_LEVEL`, `TITLE`
+ - Manager relationships: `MANAGER_EMAIL`, `MANAGER_ID`, `REPORTS_TO`
+
+### 4. Data Retrieval
+Query the contact table to extract needed information:
+- Use `snowflake-read_query()` with appropriate SELECT statements
+- Common queries:
+ - All employees: `SELECT * FROM <database>.<schema>.<table>`
+ - Specific employee: `SELECT * FROM ... WHERE EMPLOYEE_ID = '...'`
+ - Employees by department: `SELECT * FROM ... WHERE DEPARTMENT = '...'`
+ - Manager lookup: `SELECT MANAGER_EMAIL FROM ... WHERE EMPLOYEE_ID = '...'`
+
+### 5. Data Organization
+Structure retrieved data for notification purposes:
+- Create mappings: employee_id → {name, email, department, manager_email}
+- Group by department or manager for batch notifications
+- Verify email formats and completeness
+
+### 6. Notification Preparation
+Use organized contact data to:
+- Address emails to employee emails
+- CC appropriate manager emails
+- Include relevant organizational context in message bodies
+
+## Common Use Cases
+
+### Expense Claim Notifications
+When processing expense claims:
+1. Extract employee_id from claim documents
+2. Look up employee contact info and manager email
+3. Send notification to employee_email
+4. CC manager_email for oversight
+
+### Manager Escalation
+For issues requiring managerial attention:
+1. Identify employee's department
+2. Retrieve department manager or direct manager
+3. Route notifications appropriately
+
+### Department-wide Communications
+For group notifications:
+1. Query all employees in specific department
+2. Compile email distribution lists
+3. Include department head as primary contact
+
+## Best Practices
+
+### Data Validation
+- Verify email format validity before sending
+- Check for NULL/empty manager emails (escalate to department head)
+- Confirm employee status (e.g., "active" vs "inactive")
+
+### Error Handling
+- If primary contact table not found, explore alternative tables
+- Provide fallback contacts when manager emails unavailable
+- Log missing information for manual follow-up
+
+### Performance
+- Cache frequently accessed employee data when processing multiple claims
+- Use efficient queries with WHERE clauses rather than full table scans
+- Consider creating views for common lookup patterns
+
+## Integration Points
+This skill typically works alongside:
+- Expense claim processing skills
+- Document verification workflows
+- Approval routing systems
+- Reporting and analytics tools
+
+## Output Format
+Organized contact data should be structured as:
diff --git a/skills/benchmark_skills/toolathlon/employee-contact-manager/references/notification_templates.md b/skills/benchmark_skills/toolathlon/employee-contact-manager/references/notification_templates.md
new file mode 100644
index 0000000..f021e53
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/employee-contact-manager/references/notification_templates.md
@@ -0,0 +1,8 @@
+# Notification Templates for Employee Communications
+
+## Expense Claim Related Notifications
+
+### 1. Document Review Required
+**Subject:** Expense Claim Review Required: {claim_id}
+
+**Body Template:**
diff --git a/skills/benchmark_skills/toolathlon/employee-contact-manager/references/table_schema_examples.md b/skills/benchmark_skills/toolathlon/employee-contact-manager/references/table_schema_examples.md
new file mode 100644
index 0000000..f713e8b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/employee-contact-manager/references/table_schema_examples.md
@@ -0,0 +1,3 @@
+# Common Employee Contact Table Schemas
+
+## Example 1: Basic Contact Table
diff --git a/skills/benchmark_skills/toolathlon/employee-onboarding-automator/SKILL.md b/skills/benchmark_skills/toolathlon/employee-onboarding-automator/SKILL.md
new file mode 100644
index 0000000..ce84469
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/employee-onboarding-automator/SKILL.md
@@ -0,0 +1,48 @@
+---
+name: employee-onboarding-automator
+description: When the user needs to automate new employee onboarding processes including training task assignment, email notifications, and database updates. This skill handles 1) Querying employee databases (Snowflake) to identify new hires and their group assignments, 2) Analyzing onboarding documents (PDFs) to extract training requirements and deadlines, 3) Generating personalized task lists based on employee groups (Backend/Frontend/Testing/Data), 4) Inserting task records into appropriate database tables with calculated deadlines, 5) Sending onboarding emails to new employees with their task lists, 6) Checking for overdue incomplete tasks and sending reminder emails, 7) Updating tracking flags in the database. Triggers include 'new employees joining', 'onboarding automation', 'training task assignment', 'employee onboarding emails', 'task deadline reminders'.
+---
+# Instructions
+
+## 1. Initial Setup & Discovery
+- **Discover Environment**: Use `filesystem-list_directory` to explore `/workspace/dumps/workspace` for onboarding documents (PDFs).
+- **Database Discovery**: Use `snowflake-list_databases` and `snowflake-list_schemas` to locate the relevant database (e.g., `LANDING_TASK_REMINDER`).
+- **Table Discovery**: Use `snowflake-list_tables` to find employee and task tables (e.g., `EMPLOYEE`, `EMPLOYEE_LANDING`, `PUBLIC_TASKS`, `GROUP_TASKS_*`).
+
+## 2. Analyze Onboarding Document
+- **Read PDF**: Use `pdf-tools-get_pdf_info` and `pdf-tools-read_pdf_pages` to extract the onboarding checklist from the PDF (e.g., `landing_tips.pdf`).
+- **Extract Task Structure**: Parse the PDF to identify:
+ - **Public Tasks** (for all departments): e.g., "Onboarding Training", "Security Training", "Confidentiality Training", "Company Culture", "Company Strategy". Note their relative deadlines (e.g., "complete by D+7").
+ - **Group-Specific Tasks**: Identify tasks for Backend (D+30), Frontend (D+45), Testing (D+60), and Data (D+75) groups. Each group typically has "Development Process", "Development Standards", and "Development Environment" tasks.
+
+## 3. Identify New Employees & Group Assignments
+- **Query Employee Data**: Use `snowflake-read_query` on `EMPLOYEE` and `EMPLOYEE_LANDING` tables.
+- **Find New Hires**: Identify employees where `LANDING_TASK_ASSIGNED = FALSE` and `LANDING_DATE` is recent (or as per user request).
+- **Determine Group Assignment**: An employee's group is inferred from their `REPORT_TO_ID` (manager). Map managers to groups based on existing task table patterns (e.g., employees with tasks in `GROUP_TASKS_BACKEND` report to manager ID 8001).
+- **Get Manager Emails**: Join with the `EMPLOYEE` table to get the manager's email for CC.
+
+## 4. Check for Overdue Tasks
+- **Query All Task Tables**: For `PUBLIC_TASKS` and each `GROUP_TASKS_*` table, find records where `FINISHED_FLAG = FALSE` AND `DDL < CURRENT_DATE()`.
+- **Aggregate by Employee**: Collect all overdue tasks for each employee, including their manager's email.
+
+## 5. Calculate Deadlines & Generate Task Lists
+- **Base Date**: Use `CURRENT_DATE()` as the start date (Day 0).
+- **Calculate Deadlines**:
+ - Public Tasks: Day 0 + 7 days.
+ - Backend Tasks: Day 0 + 30 days.
+ - Frontend Tasks: Day 0 + 45 days.
+ - Testing Tasks: Day 0 + 60 days.
+ - Data Tasks: Day 0 + 75 days.
+- **Format Dates**: Use 'YYYY-MM-DD' format for database insertion and email content.
+
+## 6. Update Database
+- **Insert New Tasks**: Use `snowflake-write_query` to insert records into the appropriate tables (`PUBLIC_TASKS`, `GROUP_TASKS_*`) for each new employee.
+- **Update Tracking Flag**: Update `EMPLOYEE_LANDING` table, setting `LANDING_TASK_ASSIGNED = TRUE` for processed new hires.
+
+## 7. Send Emails
+- **Onboarding Emails**: For each new employee, use `emails-send_email`.
+ - **To**: Employee's email.
+ - **CC**: Their manager's email (from `REPORT_TO_ID` lookup).
+ - **Subject**: "Onboarding Training Tasks".
+ - **Body**: Follow the exact format:
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/employee-onboarding-automator/references/database_schema.md b/skills/benchmark_skills/toolathlon/employee-onboarding-automator/references/database_schema.md
new file mode 100644
index 0000000..a36b72f
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/employee-onboarding-automator/references/database_schema.md
@@ -0,0 +1,60 @@
+# Database Schema Reference
+
+## Database: LANDING_TASK_REMINDER
+## Schema: PUBLIC
+
+### Table: EMPLOYEE
+Stores employee information.
+| Column Name | Data Type | Nullable | Description |
+|-------------|-----------|----------|-------------|
+| NAME | TEXT | NO | Employee full name |
+| EMAIL | TEXT | NO | Employee email address |
+| EMPLOYEE_ID | NUMBER | NO | Unique employee identifier |
+| REPORT_TO_ID | NUMBER | YES | Manager's EMPLOYEE_ID (foreign key to EMPLOYEE) |
+
+### Table: EMPLOYEE_LANDING
+Tracks employee onboarding status.
+| Column Name | Data Type | Nullable | Description |
+|-------------|-----------|----------|-------------|
+| LANDING_DATE | DATE | NO | Employee start/joining date |
+| EMPLOYEE_ID | NUMBER | NO | Foreign key to EMPLOYEE |
+| LANDING_TASK_ASSIGNED | BOOLEAN | NO | Flag indicating if onboarding tasks have been assigned |
+
+### Table: PUBLIC_TASKS
+Stores public training tasks for all employees.
+| Column Name | Data Type | Nullable | Description |
+|-------------|-----------|----------|-------------|
+| FINISHED_FLAG | BOOLEAN | NO | Task completion status (TRUE/FALSE) |
+| TASK_NAME | TEXT | NO | Name of the task |
+| CREATE_DATE | DATE | NO | Date task was assigned |
+| EMPLOYEE_ID | NUMBER | NO | Foreign key to EMPLOYEE |
+| DDL | DATE | NO | Task deadline date |
+
+### Group Task Tables
+Four tables with identical schema for different employee groups:
+- `GROUP_TASKS_BACKEND` (Backend group, D+30 deadlines)
+- `GROUP_TASKS_FRONTEND` (Frontend group, D+45 deadlines)
+- `GROUP_TASKS_TESTING` (Testing group, D+60 deadlines)
+- `GROUP_TASKS_DATA` (Data group, D+75 deadlines)
+
+#### Schema for Group Task Tables:
+| Column Name | Data Type | Nullable | Description |
+|-------------|-----------|----------|-------------|
+| FINISHED_FLAG | BOOLEAN | NO | Task completion status |
+| TASK_NAME | TEXT | NO | Name of the task |
+| CREATE_DATE | DATE | NO | Date task was assigned |
+| EMPLOYEE_ID | NUMBER | NO | Foreign key to EMPLOYEE |
+| DDL | DATE | NO | Task deadline date |
+
+## Key Relationships
+- `EMPLOYEE.EMPLOYEE_ID` → `EMPLOYEE_LANDING.EMPLOYEE_ID`
+- `EMPLOYEE.EMPLOYEE_ID` → `PUBLIC_TASKS.EMPLOYEE_ID`
+- `EMPLOYEE.EMPLOYEE_ID` → `GROUP_TASKS_*.EMPLOYEE_ID`
+- `EMPLOYEE.REPORT_TO_ID` → `EMPLOYEE.EMPLOYEE_ID` (self-join for manager)
+
+## Group Assignment Logic
+Employee groups are determined by their manager (REPORT_TO_ID):
+- REPORT_TO_ID = 8001 → Backend Group (uses GROUP_TASKS_BACKEND)
+- REPORT_TO_ID = 8002 → Frontend Group (uses GROUP_TASKS_FRONTEND)
+- REPORT_TO_ID = 8003 → Testing Group (uses GROUP_TASKS_TESTING)
+- REPORT_TO_ID = 8004 → Data Group (uses GROUP_TASKS_DATA)
diff --git a/skills/benchmark_skills/toolathlon/employee-onboarding-automator/references/email_templates.md b/skills/benchmark_skills/toolathlon/employee-onboarding-automator/references/email_templates.md
new file mode 100644
index 0000000..5d6d171
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/employee-onboarding-automator/references/email_templates.md
@@ -0,0 +1,6 @@
+# Email Templates
+
+## Onboarding Email Template
+**Subject:** Onboarding Training Tasks
+
+**Body:**
diff --git a/skills/benchmark_skills/toolathlon/employee-onboarding-automator/references/pdf_parsing_guide.md b/skills/benchmark_skills/toolathlon/employee-onboarding-automator/references/pdf_parsing_guide.md
new file mode 100644
index 0000000..a43b49a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/employee-onboarding-automator/references/pdf_parsing_guide.md
@@ -0,0 +1,43 @@
+# PDF Parsing Guide
+
+## Document: landing_tips.pdf
+This PDF contains the company's unified onboarding checklist.
+
+## Key Sections to Extract
+
+### 1. Public Tasks (All Departments)
+Look for the section titled "Public Tasks (All Departments, complete by Day 7)".
+Extract these tasks in order:
+- Onboarding Training
+- Security Training
+- Confidentiality Training
+- Company Culture
+- Company Strategy
+
+### 2. Group-Specific Tasks
+Extract tasks for each group with their relative deadlines:
+
+#### Backend Group Tasks (complete by Day 30)
+- Backend Development Process
+- Backend Development Standards
+- Backend Development Environment
+
+#### Frontend Group Tasks (complete by Day 45)
+- Frontend Development Process
+- Frontend Development Standards
+- Frontend Development Environment
+
+#### Testing Group Tasks (complete by Day 60)
+- Testing Development Process
+- Testing Development Standards
+- Testing Development Environment
+
+#### Data Group Tasks (complete by Day 75)
+- Data Development Process
+- Data Development Standards
+- Data Development Environment
+
+## Parsing Notes
+- The PDF may contain Unicode characters (e.g., `\u0000` prefixes). Clean the text by removing null characters.
+- "D+N" means "N calendar days after Day 0" (the start date).
+- Focus on the task names and their relative deadlines. Ignore supplementary notes and descriptions.
diff --git a/skills/benchmark_skills/toolathlon/excel-data-enricher/SKILL.md b/skills/benchmark_skills/toolathlon/excel-data-enricher/SKILL.md
new file mode 100644
index 0000000..c0103b3
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/excel-data-enricher/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: excel-data-enricher
+description: When the user has an Excel file with incomplete data that needs to be populated by searching for and extracting specific information from external sources. This skill is triggered by requests to fill missing columns in spreadsheets, batch data enrichment tasks, or when working with structured data that requires additional research to complete. It handles Excel file discovery, reading existing data, writing new data to specific cells, and maintaining data integrity across multiple rows.
+---
+# Skill: Excel Data Enricher
+
+## Core Purpose
+You are an automated research assistant that populates missing data in Excel spreadsheets. You take a user's request to fill specific columns, locate the relevant Excel file(s), read the existing data, perform targeted searches to find the missing information, and write the results back to the correct cells.
+
+## Primary Workflow
+
+### 1. File Discovery & Inspection
+- **Locate Excel Files**: Use the `terminal-run_command` tool to find `.xlsx` or `.xls` files in the user's workspace (e.g., `/workspace/dumps/workspace`). **Avoid using `/dev/null` in file paths** as it may cause security violations.
+- **Inspect Workbook**: Use `excel-get_workbook_metadata` to understand the file structure (sheet names, used ranges).
+- **Read Existing Data**: Use `excel-read_data_from_excel` to load the current data, typically from the header row down to the last row with content. Identify which columns are populated and which are empty (null values).
+
+### 2. Data Research & Extraction
+- **Batch Research**: For each row with missing data, formulate parallel search queries using the populated columns (e.g., paper titles) to find the missing information (e.g., author names, affiliations, profile links).
+- **Use Multiple Sources**: Employ `local-web_search` for general web searches and `arxiv_local-search_papers` for academic paper metadata. When precise details are needed (like exact affiliations), access the source PDFs directly using `pdf-tools-read_pdf_pages`.
+- **Extract Precisely**: Extract the **full name of the first author** and their **complete institutional affiliation exactly as it appears in the source** (including department level if provided). For Google Scholar profiles, find the canonical link.
+
+### 3. Data Validation & Writing
+- **Compile Results**: Organize the found data (author, affiliation, profile link) into a list corresponding to the rows in the spreadsheet.
+- **Write to Excel**: Use `excel-write_data_to_excel` to write the compiled data array starting at the correct cell (e.g., `B2` for the first data row under the "First Author" header).
+- **Verify Output**: Read the updated sheet back with `excel-read_data_from_excel` to confirm all cells have been populated correctly.
+
+### 4. Completion
+- Provide the user with a clear summary of the completed work, showing the original titles and the newly added data.
+- Claim task completion using `local-claim_done`.
+
+## Key Principles
+- **Accuracy Over Speed**: Prefer extracting data directly from source documents (PDFs) over secondary summaries.
+- **Parallel Execution**: When researching multiple items (e.g., 6 paper titles), launch search queries in parallel to save time.
+- **Maintain Structure**: Preserve the original order of rows. Write data to the exact cells that were empty.
+- **Handle Ambiguity**: If information cannot be found or is ambiguous, note this in your summary but still attempt to fill what you can.
+
+## Common Tool Sequence
+1. `terminal-run_command` (find file)
+2. `excel-get_workbook_metadata`
+3. `excel-read_data_from_excel`
+4. `local-web_search` / `arxiv_local-search_papers` / `pdf-tools-read_pdf_pages` (research)
+5. `excel-write_data_to_excel`
+6. `excel-read_data_from_excel` (verify)
+7. `local-claim_done`
diff --git a/skills/benchmark_skills/toolathlon/excel-data-enricher/references/data_mapping_guide.md b/skills/benchmark_skills/toolathlon/excel-data-enricher/references/data_mapping_guide.md
new file mode 100644
index 0000000..6628d44
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/excel-data-enricher/references/data_mapping_guide.md
@@ -0,0 +1,36 @@
+# Data Mapping Guide for Common Enrichment Tasks
+
+This guide provides templates for mapping search queries and extraction logic based on common spreadsheet schemas.
+
+## Schema 1: Academic Paper Research (from trajectory)
+**Columns**: Title, First Author, Affiliation, Google Scholar Profile
+
+### Research Strategy:
+1. **Query for First Author**: `"<Paper Title>" paper first author`
+2. **Query for Affiliation**: Access the PDF directly (via OpenReview, arXiv, etc.) and extract from the first page. Look for lines following author names, typically containing department and university names.
+3. **Query for Google Scholar**: `"<First Author Name>" Google Scholar profile` or `site:scholar.google.com "<First Author Name>"`
+
+### Extraction Points (from PDF):
+- **Author**: First name in the author list on page 1.
+- **Affiliation**: Text on the same line or following line after the author's name, often marked with superscript numbers. Include all institutions if multiple are listed.
+- **Example Format**: `Department of Computer Science, Purdue University` or `Gatsby Computational Neuroscience Unit, University College London`
+
+## Schema 2: Company Contact Enrichment
+**Columns**: Company Name, CEO, Headquarters, LinkedIn Page
+
+### Research Strategy:
+1. **Query for CEO**: `"<Company Name>" CEO`
+2. **Query for HQ**: `"<Company Name>" headquarters location`
+3. **Query for LinkedIn**: `"<Company Name>" LinkedIn`
+
+## Schema 3: Product Catalog Enrichment
+**Columns**: Product ID, Product Name, Manufacturer, Manufacturer Website
+
+### Research Strategy:
+1. **Query for Manufacturer**: `"<Product Name>" manufacturer`
+2. **Query for Website**: `"<Manufacturer Name>" official website`
+
+## General Tips:
+- **Prioritize Primary Sources**: When available, access the official document/page (PDF, company website, official profile).
+- **Verify Consistency**: Ensure extracted names and affiliations match across sources.
+- **Handle Multiple Results**: If a search returns multiple potential matches, use the most recent or most authoritative source (e.g., the paper's PDF for academic data).
diff --git a/skills/benchmark_skills/toolathlon/excel-weighted-growth-calculator/SKILL.md b/skills/benchmark_skills/toolathlon/excel-weighted-growth-calculator/SKILL.md
new file mode 100644
index 0000000..da74152
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/excel-weighted-growth-calculator/SKILL.md
@@ -0,0 +1,80 @@
+---
+name: excel-weighted-growth-calculator
+description: When the user requests to calculate year-over-year growth rates for business segments using a weighted methodology from Excel files, particularly when there's a mapping sheet defining segment-to-source weights and a raw data sheet with time-series values. This skill handles reading Excel workbooks with multiple sheets, parsing segment/source mappings, calculating YoY growth rates for sources, applying weighted sums to compute segment growth rates, handling missing data with N/A values, and outputting results to a new Excel file with proper formatting.
+---
+# Instructions
+
+## Overview
+This skill calculates year-over-year (YoY) growth rates for business segments based on a weighted methodology defined in an Excel workbook. It reads two key sheets:
+1. **Methodology Sheet**: Contains segment-to-source weight mappings.
+2. **RawData Sheet**: Contains time-series data for each source.
+
+The skill outputs a new Excel file with segment growth rates for specified years.
+
+## Core Workflow
+
+### 1. Parse Input Requirements
+- Identify the input Excel file path (e.g., `Market_Data.xlsx`).
+- Determine the output file name (e.g., `segment_growth_rates.xlsx`).
+- Confirm the year range for calculations (e.g., 2015-2024).
+- Note any special instructions (e.g., exclude "Total" segment, maintain column order).
+
+### 2. Extract Methodology Mappings
+- Read the **Methodology** sheet.
+- Identify source names from the header row (typically row 2, columns C-Q).
+- Identify segment names from column B (rows 4-13, excluding "Total").
+- For each segment, extract non-zero weights mapping to sources.
+- Preserve the segment order as they appear in the sheet.
+
+### 3. Extract Raw Data
+- Read the **RawData** sheet.
+- Identify source names from the header row (typically row 4, columns B-P).
+- Map each source to its data column.
+- Extract year values from column A and map to row numbers.
+- For each source and year, read the value. Treat formula cells (strings starting with '=') as `None`/null.
+
+### 4. Calculate Source Growth Rates
+- For each source, for each target year (e.g., 2015-2024):
+ - Get the current year value and the previous year value.
+ - If either value is `None` or previous year is 0, growth rate is `None`.
+ - Otherwise, calculate: `((current - previous) / previous) * 100`.
+- Store results in a nested dictionary: `source_growth_rates[source][year]`.
+
+### 5. Calculate Segment Growth Rates
+- For each segment, for each target year:
+ - Retrieve the segment's weight mapping from methodology.
+ - For each source in the mapping:
+ - Get the source's growth rate for that year.
+ - If any source's growth rate is `None`, mark the entire segment's growth as **"N/A"** for that year.
+ - Otherwise, compute the weighted sum: `sum(weight * growth_rate)`.
+ - Round the result to **one decimal place**.
+- Store results: `segment_growth_rates[segment][year]`.
+
+### 6. Generate Output Excel File
+- Create a new workbook.
+- Write header row: First column "Year", followed by segment names in the preserved order.
+- For each target year, write a row: year value followed by each segment's growth rate (number or "N/A").
+- Save the file to the specified output path.
+
+### 7. Validate Output
+- Verify the file was created successfully.
+- Optionally, read back and display a sample to confirm formatting.
+
+## Key Considerations
+- **Missing Data**: If a source has no data for current or previous year, its growth is `None`. If any source in a segment's mapping has `None` growth, the segment's growth is "N/A".
+- **Formula Cells**: Treat cells with formulas (text starting with '=') as null/unavailable.
+- **Segment Order**: Maintain the exact segment order as they appear in the Methodology sheet rows.
+- **Output Format**: First column is "Year", subsequent columns are segment names. Growth rates are percentages rounded to one decimal place or "N/A".
+
+## Error Handling
+- If the input file or sheets are missing, notify the user.
+- If source names between Methodology and RawData sheets don't align, attempt fuzzy matching or notify.
+- If year range extends beyond available data, calculate only for available years.
+
+## Usage Example
+**User Request**: "Based on the provided file `Market_Data.xlsx`, calculate the year-over-year growth rate percentage for each segment from 2015 to 2024 according to the segment/source mapping provided in the `Methodology` sheet (rounded to one decimal place), and save the results to a new Excel file named `segment_growth_rates.xlsx` where the first column is `Year` and the subsequent columns are the exact names (excluding `Total`) of segments arranged in the same order as they appear in rows in the `Methodology` sheet."
+
+**Skill Execution**:
+1. Parse request to identify input file, output name, year range.
+2. Execute the workflow above using the bundled script.
+3. Deliver the output file.
diff --git a/skills/benchmark_skills/toolathlon/excel-weighted-growth-calculator/references/data_structure.md b/skills/benchmark_skills/toolathlon/excel-weighted-growth-calculator/references/data_structure.md
new file mode 100644
index 0000000..8fe73ad
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/excel-weighted-growth-calculator/references/data_structure.md
@@ -0,0 +1,59 @@
+# Excel Data Structure Reference
+
+## Methodology Sheet Structure
+The Methodology sheet defines how business segments are composed from data sources.
+
+### Header Row (Row 2)
+- Column A: Typically empty or label
+- Column B: "Segment/Source" header
+- Columns C-Q: Source names (e.g., Agriculture, Oil & Gas, Food, Metals, Electronic, Electric, Auto Production, Transportation, Furniture, Construction, Industry, Steel Production, Air Bus, Boeing, MRO)
+
+### Segment Rows (Rows 4-13)
+- Column A: Typically empty
+- Column B: Segment name (e.g., Auto OEM, Auto Components, Coil, Industry, ACE, Appliance, AlFi, CF, Food, Aero)
+- Columns C-Q: Weight values (0-1) mapping the segment to each source
+- Row 14: "Total" row (should be excluded from calculations)
+
+### Example Mapping
+| Segment | Agriculture | Oil & Gas | ... | Auto Production | ... |
+|--------------|-------------|-----------|-----|-----------------|-----|
+| Auto OEM | | | | 1.0 | |
+| Auto Components | | | | 0.9 | |
+| ... | ... | ... | ... | ... | ... |
+
+## RawData Sheet Structure
+The RawData sheet contains time-series data for each source.
+
+### Header Rows (Rows 1-4)
+- Row 1: Region label (e.g., "APAC")
+- Row 2: Data source names (should match Methodology source names)
+- Row 3: Units (e.g., "mn USD", "units")
+- Row 4: Source names (should match Methodology source names exactly)
+
+### Data Rows (Rows 5+)
+- Column A: Year values (e.g., 2014, 2015, ...)
+- Columns B-P: Data values for each source corresponding to the year
+
+### Example Data
+| Year | Agriculture | Oil & Gas | ... | Auto Production | ... |
+|------|-------------|-----------|-----|-----------------|-----|
+| 2014 | 1984154.14 | 380048.54 | ... | (null) | ... |
+| 2015 | 2026880.45 | 391674.25 | ... | (null) | ... |
+| ... | ... | ... | ... | ... | ... |
+
+## Calculation Rules
+1. **Year-over-Year Growth Formula**: `((current_year - previous_year) / previous_year) * 100`
+2. **Missing Data Handling**:
+ - If either current or previous year value is null/missing, growth rate is `None`
+ - If previous year value is 0, growth rate is `None` (to avoid division by zero)
+ - Formula cells (text starting with '=') are treated as null
+3. **Segment Growth Calculation**:
+ - For each segment, retrieve its weight mapping from Methodology
+ - For each year, check if all component sources have valid growth rates
+ - If any source growth is `None`, segment growth is "N/A"
+ - Otherwise, calculate weighted sum: `sum(weight * source_growth)`
+ - Round result to one decimal place
+4. **Output Format**:
+ - First column: "Year"
+ - Subsequent columns: Segment names in Methodology sheet order (excluding "Total")
+ - Values: Growth rate percentages (rounded to 1 decimal) or "N/A"
diff --git a/skills/benchmark_skills/toolathlon/expense-claim-validator/SKILL.md b/skills/benchmark_skills/toolathlon/expense-claim-validator/SKILL.md
new file mode 100644
index 0000000..76d3cbd
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/expense-claim-validator/SKILL.md
@@ -0,0 +1,84 @@
+---
+name: expense-claim-validator
+description: When the user needs to validate employee expense claims against company policies and supporting documentation. This skill extracts and analyzes expense claim PDFs and corresponding invoices, verifies that all claimed items have matching receipts with correct amounts, and checks compliance with destination-specific expense caps based on employee levels. Triggers include expense claim processing, reimbursement validation, policy compliance checking, invoice verification, or when dealing with travel expense files in PDF/tar.gz formats.
+---
+# Instructions
+
+## Overview
+Process a batch of employee expense claims by:
+1. **Extracting** claim forms and invoices from compressed archives.
+2. **Validating** that every claimed item has a corresponding invoice with matching amounts.
+3. **Checking** all expenses against company policy caps (destination + employee level).
+4. **Taking Action** based on validation results:
+ - **Document Issues** (missing receipts/amount mismatches): Send "Review Required" email to employee + CC manager.
+ - **Over-Cap Issues** (exceeds policy limits): Insert claim into database with `FLAG = 1` and send "Over-Cap Notice" email to employee + CC manager.
+ - **Valid Claims** (no issues): Insert into database with `FLAG = 0`.
+
+## Prerequisites
+- **Workspace**: Expense claim archives (`.tar.gz` files) in `/workspace/dumps/workspace/files/`
+- **Policy Document**: `policy_en.pdf` in the same directory
+- **Snowflake Database**: `TRAVEL_EXPENSE_REIMBURSEMENT` with tables:
+ - `2024Q4REIMBURSEMENT` (target table)
+ - `ENTERPRISE_CONTACTS` (employee/manager email mapping)
+
+## Step-by-Step Workflow
+
+### 1. Initial Setup & Exploration
+- List workspace files to locate claim archives and policy PDF.
+- Connect to Snowflake: verify database, schema, and table structures.
+- Read the policy PDF to extract destination-specific caps per employee level.
+
+### 2. Extract & Organize Claims
+- Extract all `.tar.gz` archives to a temporary directory (`/workspace/dumps/workspace/extracted/`).
+- Each archive contains:
+ - One `*_main.pdf`: The expense claim form with header info and itemized expenses.
+ - Multiple `*_invoice_*.pdf`: Supporting invoices, numbered sequentially.
+
+### 3. Parse & Validate Each Claim
+For each claim directory:
+- Read the main PDF to extract:
+ - Claim metadata (ID, employee, destination, dates, total)
+ - Itemized expenses (date, category, amount)
+- Read all corresponding invoice PDFs to extract:
+ - Invoice amount and category
+ - Verify receipt exists (no "No receipt available" messages)
+- **Validation Checks**:
+ - **Document Completeness**: Every claim item must have a corresponding invoice.
+ - **Amount Matching**: Claimed amount must match invoice amount (within 0.01 CNY tolerance).
+ - **Policy Compliance**: Each expense category must not exceed daily/trip caps for the employee's level at that destination.
+
+### 4. Categorize & Act on Results
+Based on validation:
+- **Document Issues**: Missing receipts or amount mismatches → Send "Expense Claim Review Required: {claim_id}" email.
+- **Over-Cap Issues**: All documents valid but expenses exceed caps → Insert into database with `FLAG = 1` and send "Expense Over-Cap Notice: {claim_id}" email.
+- **Valid Claims**: No issues → Insert into database with `FLAG = 0`.
+
+### 5. Database Operations
+- Insert claims into `TRAVEL_EXPENSE_REIMBURSEMENT.PUBLIC."2024Q4REIMBURSEMENT"` with appropriate flag.
+- Required columns: `CLAIM_ID`, `EMPLOYEE_ID`, `EMPLOYEE_NAME`, `DEPARTMENT`, `DEST_CITY`, `DEST_COUNTRY`, `TRIP_START`, `TRIP_END`, `NIGHTS`, `TOTAL_CLAIMED`, `FLAG`.
+
+### 6. Email Notifications
+- Use `emails-send_email` tool.
+- **To**: Employee email (from `ENTERPRISE_CONTACTS`)
+- **CC**: Manager email (from `ENTERPRISE_CONTACTS`)
+- **Subject**: As specified in requirements
+- **Body**: Clear description of issues found (list specific items and amounts).
+
+## Key Decisions & Edge Cases
+- **Missing Invoices**: If an invoice PDF says "No receipt available", treat as missing receipt.
+- **Amount Discrepancies**: Flag any difference > 0.01 CNY between claim and invoice.
+- **Policy Caps**: Use the most specific cap available (city + employee level). If city not in policy, cannot validate caps.
+- **Multiple Claims per Employee**: Process each claim independently.
+- **Empty Database**: Handle case where `2024Q4REIMBURSEMENT` table is empty (start ID from 1).
+
+## Tools Required
+- `filesystem-list_directory`, `filesystem-directory_tree`
+- `pdf-tools-read_pdf_pages`, `pdf-tools-get_pdf_info`
+- `snowflake-list_databases`, `snowflake-list_tables`, `snowflake-describe_table`, `snowflake-read_query`, `snowflake-write_query`
+- `local-python-execute` (for complex parsing/analysis)
+- `emails-send_email`
+
+## Output
+- Database records inserted into `2024Q4REIMBURSEMENT`
+- Email notifications sent to employees and managers
+- Console summary of processed claims and issues found
diff --git a/skills/benchmark_skills/toolathlon/expense-database-writer/SKILL.md b/skills/benchmark_skills/toolathlon/expense-database-writer/SKILL.md
new file mode 100644
index 0000000..39702c5
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/expense-database-writer/SKILL.md
@@ -0,0 +1,79 @@
+---
+name: expense-database-writer
+description: When the user needs to write validated expense claim data into structured databases with proper flagging for policy violations. This skill formats expense claim information into database-compatible schemas, inserts records into reimbursement tables, and sets appropriate flags (e.g., flag=1 for abnormal claims) based on validation results. Triggers include database insertion, reimbursement record creation, expense claim archiving, or when moving validated claims to permanent storage in databases like Snowflake.
+---
+# Instructions
+
+## Overview
+This skill processes validated expense claims and writes them into a Snowflake database table (`2024Q4REIMBURSEMENT`). It handles data formatting, flagging for policy violations, and insertion into the structured database.
+
+## Prerequisites
+1. **Database Connection**: Ensure Snowflake connection is available with access to the `TRAVEL_EXPENSE_REIMBURSEMENT.PUBLIC` schema.
+2. **Validated Claims Data**: Claims must have passed initial validation (document completeness and amount matching).
+3. **Policy Caps Data**: Destination-specific expense caps must be available for validation.
+4. **Employee Contacts**: Employee information including manager emails must be accessible.
+
+## Step-by-Step Process
+
+### 1. Initialize and Verify Environment
+- List available databases and verify `TRAVEL_EXPENSE_REIMBURSEMENT` exists
+- Check for required tables:
+ - `2024Q4REIMBURSEMENT` (target table)
+ - `ENTERPRISE_CONTACTS` (for employee/manager emails)
+- Verify table schemas match expected structure
+
+### 2. Load and Validate Claims Data
+- Load expense claim data from validated sources (typically extracted PDFs or JSON files)
+- Each claim must include:
+ - Claim ID
+ - Employee ID, Name, Level, Department
+ - Destination (City, Country)
+ - Trip dates (Start, End) and Nights
+ - Total claimed amount
+ - Itemized expenses with categories (Accommodation, Meals, Transportation, Communication, Miscellaneous)
+
+### 3. Check Policy Compliance
+For each claim, compare expenses against policy caps:
+- **Daily Caps**: Accommodation, Meals, Transportation (per day)
+- **Trip Caps**: Communication, Miscellaneous (per trip)
+- **Employee Level**: Caps vary by employee level (L1-L4)
+
+**Flag Determination**:
+- If ANY expense exceeds policy caps → Set `FLAG = 1` (abnormal)
+- If ALL expenses within caps → Set `FLAG = 0` (normal)
+
+### 4. Handle Different Claim Statuses
+
+#### A. Claims with Document Issues (Missing receipts/Amount mismatches)
+- **DO NOT** insert into database
+- Send email notification to employee and CC manager
+- **Email Subject**: `Expense Claim Review Required: {claim_id}`
+- Include specific issues in email body
+
+#### B. Claims with Policy Violations (Over-cap)
+- Insert into database with `FLAG = 1`
+- Send email notification to employee and CC manager
+- **Email Subject**: `Expense Over-Cap Notice: {claim_id}`
+- List specific over-cap items in email body
+
+#### C. Fully Valid Claims (No issues)
+- Insert into database with `FLAG = 0`
+- No email notification required
+
+### 5. Database Insertion
+- Generate sequential ID for each claim
+- Map claim data to database schema:
+ - ID (sequential integer)
+ - CLAIM_ID (text)
+ - EMPLOYEE_ID (text)
+ - EMPLOYEE_NAME (text)
+ - DEPARTMENT (text)
+ - DEST_CITY (text)
+ - DEST_COUNTRY (text)
+ - TRIP_START (date)
+ - TRIP_END (date)
+ - NIGHTS (number)
+ - TOTAL_CLAIMED (number)
+ - FLAG (number: 0 or 1)
+
+**Insertion Pattern**:
diff --git a/skills/benchmark_skills/toolathlon/file-system-organizer/SKILL.md b/skills/benchmark_skills/toolathlon/file-system-organizer/SKILL.md
new file mode 100644
index 0000000..843c1f5
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/file-system-organizer/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: file-system-organizer
+description: Organizes or restructures files and directories according to a specified hierarchy or categorization scheme. Analyzes existing structures, creates new directory trees, intelligently moves files based on content and naming patterns, and verifies the final organization.
+---
+# Instructions
+
+## Objective
+Reorganize the user's file system from a messy or unspecified state into a clean, logical directory structure as specified by the user.
+
+## Core Workflow
+
+### 1. Analyze the Current State
+* **Action:** Use `filesystem-list_directory` to explore the target workspace.
+* **Goal:** Understand the existing folder layout and identify all files that need to be categorized. Start from the root path the user indicates (e.g., `/workspace`). Recursively list subdirectories to build a complete mental map.
+
+### 2. Parse the Target Structure
+* **Action:** Interpret the user's request, which may include a text-based tree diagram or a verbal description.
+* **Goal:** Build a clear, hierarchical model of the desired final directory structure (e.g., `School/Courses_Materials`, `Work/Projects`).
+
+### 3. Create the Directory Hierarchy
+* **Action:** Use `filesystem-create_directory` to build the new structure.
+* **Critical Logic:** Create directories **sequentially from the root down**. Do not attempt to create a nested subdirectory (`A/B/C`) before its parent (`A/B`) exists. The trajectory shows that attempting this in parallel causes "Parent directory does not exist" errors.
+* **Best Practice:** Create all top-level directories first, then their immediate children, proceeding layer by layer.
+
+### 4. Categorize and Move Files
+* **Action:** Use `filesystem-move_file` to relocate files from their original locations to their new, categorized homes.
+* **Intelligence Required:** Determine the correct destination for each file by analyzing:
+ * **File Name:** Keywords like `Course`, `Graduation`, `Exam`, `Project`, `Application`, `CV`, `Movie`, `Music`, `Picture`.
+ * **File Extension:** `.mp3`, `.mp4`, `.mkv` → Entertainment; `.pdf`, `.doc`, `.ppt`, `.xlsx` → likely School or Work.
+ * **Current Location:** A file inside an existing `Entertainment` folder is likely media.
+ * **Content Inference:** `cat.png` is a picture, likely of a pet.
+* **Procedure:** Move files in batches. Verify each move operation is successful before proceeding.
+
+### 5. Cleanup and Verification
+* **Action:**
+ 1. Use `filesystem-directory_tree` to generate a visual map of the newly organized workspace.
+ 2. Present this tree to the user for confirmation.
+ 3. If original source directories are now empty, remove them using `terminal-run_command` (e.g., `rm -rf /path/to/empty_folder`).
+* **Goal:** Leave the workspace tidy and provide clear evidence of the completed task.
+
+## Key Principles
+* **Defensive Creation:** Always check for or assume parent directories need to be created first.
+* **Informed Moving:** Use multiple signals (name, extension, path) to make accurate categorization decisions.
+* **Verification:** Always show the end result. Do not assume success without checking.
diff --git a/skills/benchmark_skills/toolathlon/file-system-organizer/references/categorization_rules.md b/skills/benchmark_skills/toolathlon/file-system-organizer/references/categorization_rules.md
new file mode 100644
index 0000000..181e503
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/file-system-organizer/references/categorization_rules.md
@@ -0,0 +1,84 @@
+# File Categorization Rules & Heuristics
+
+Use these patterns to intelligently decide where to move files during organization.
+
+## Category: School
+**Destination Base:** `School/`
+
+### Subcategory: Courses_Materials
+* **File Name Patterns:** `course`, `lecture`, `notes`, `schedule`, `syllabus`, `homework`, `assignment`, `exam`, `quiz`, `lab`
+* **Extensions:** `.pdf`, `.doc`, `.docx`, `.ppt`, `.pptx`, `.xls`, `.xlsx`, `.md`, `.txt`, `.jpg`, `.png` (if related to course content)
+* **Examples from Trajectory:**
+ * `Course_Schedule.jpg`
+ * `course_schedule.xls`
+ * `course_model_weight_*.png`
+ * `Machine_Learning_Course_Notes.md`
+ * `Calculus_Final_Review.ppt`
+
+### Subcategory: Graduation_Projects
+* **File Name Patterns:** `graduation`, `thesis`, `dissertation`, `capstone`, `final_project`, `senior_design`
+* **Extensions:** `.doc`, `.docx`, `.pdf`, `.zip`
+* **Examples:** `Graduation_Materials_Notice_202506.doc`
+
+### Subcategory: Applications_Materials
+* **File Name Patterns:** `recommendation`, `reference`, `transcript`, `application`, `personal_statement`
+* **Extensions:** `.pdf`, `.doc`, `.docx`
+* **Examples:** `Recommendation_Letter_1.pdf`, `Recommendation_Letter_2.pdf`
+
+### Subcategory: Language_Exam_Preparation
+* **File Name Patterns:** `listening`, `reading`, `writing`, `speaking`, `toefl`, `ielts`, `exam`, `test`, `practice`
+* **Extensions:** `.mp3`, `.wav`, `.pdf`, `.xlsx`, `.docx`
+* **Examples:** `Listening1-3.mp3`, `exam.xlsx`
+
+## Category: Work
+**Destination Base:** `Work/`
+
+### Subcategory: Projects
+* **File Name Patterns:** `project`, `proposal`, `design`, `spec`, `requirements`, `report`
+* **Extensions:** `.pptx`, `.pdf`, `.docx`, `.xlsx`
+* **Examples:** `Product_Design_Proposal.pptx`
+
+### Subcategory: Software
+* **File Name Patterns:** `setup`, `install`, `.dmg`, `.exe`, `.app`, `software`, `tool`, `utility`
+* **Extensions:** `.dmg`, `.exe`, `.zip`, `.tar.gz`, `.deb`, `.rpm`
+* **Examples:** `Clash.Verge_2.0.3-alpha_aarch64.dmg`
+
+### Subcategory: Job_Application_Materials
+* **File Name Patterns:** `resume`, `cv`, `cover_letter`, `application`, `portfolio`
+* **Extensions:** `.pdf`, `.docx`, `.xlsx`
+* **Examples:** `cv-gboeing.pdf`, `Internship_application_form.xlsx`
+
+### Subcategory: Offer_Galary
+* **File Name Patterns:** `offer`, `letter`, `contract`, `compensation`
+* **Extensions:** `.pdf`, `.docx`
+* **Examples:** (Empty in trajectory - placeholder for future files)
+
+## Category: Entertainment
+**Destination Base:** `Entertainment/`
+
+### Subcategory: Movies
+* **File Name Patterns:** `movie`, `film`, `show`, `episode`, `.s0`, `.e0`, `trailer`
+* **Extensions:** `.mp4`, `.mkv`, `.avi`, `.mov`, `.wmv`
+* **Examples:** `Movie_The_Wandering_Earth.mp4`, `TV_Show_Friends_S01E01.mkv`
+
+### Subcategory: Music
+* **File Name Patterns:** `music`, `song`, `album`, `track`, artist names
+* **Extensions:** `.mp3`, `.wav`, `.flac`, `.aac`, `.m4a`
+* **Examples:** `Music_Jay_Chou_Best.mp3`
+
+### Subcategory: Pictures
+* **File Name Patterns:** Generic image names, location names, `photo`, `img`, `pic`, `screenshot`
+* **Extensions:** `.png`, `.jpg`, `.jpeg`, `.gif`, `.bmp`, `.heic`
+* **Sub-subcategory Logic:**
+ * `Landscape`: `mountain`, `lake`, `sunset`, `beach`, `view`, location names.
+ * `Pets`: `cat`, `dog`, `pet`, animal names.
+ * `People`: `portrait`, `family`, `friend`, person names.
+* **Examples:**
+ * `Landscape/`: `mount.png`, `sichuan_lake.png`
+ * `Pets/`: `cat.png`
+
+## Decision Flow
+1. **Check Current Path:** A file inside an existing `Entertainment` folder is very likely media.
+2. **Analyze Filename:** Look for the strongest keyword match across categories.
+3. **Check Extension:** `.mp3` → Music; `.mp4` → Movies; `.pdf` → Likely documents (School/Work).
+4. **Default/Uncertain:** If unclear, place in a logical default (e.g., `School/Courses_Materials` for academic-looking documents, `Work/Projects` for professional documents) or ask the user for clarification.
diff --git a/skills/benchmark_skills/toolathlon/financial-data-template-populator/SKILL.md b/skills/benchmark_skills/toolathlon/financial-data-template-populator/SKILL.md
new file mode 100644
index 0000000..a464f5b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/financial-data-template-populator/SKILL.md
@@ -0,0 +1,58 @@
+---
+name: financial-data-template-populator
+description: Populates an Excel template with financial data (stock prices, market trends, ownership) for a specified company. Reads requirement files, fetches data from Yahoo Finance, analyzes template structure, formats data, writes to Excel, and renames the output file.
+---
+# Instructions
+
+## 1. Understand the Request & Locate Files
+The user will request to populate an Excel template with financial data for a specific company (e.g., NVIDIA/NVDA). They will provide:
+* An Excel template file (e.g., `results_template.xlsx`).
+* A data requirements file (e.g., `data.txt`).
+* A formatting instructions file (e.g., `tips.txt`).
+* A final output filename (e.g., `results.xlsx`).
+
+First, read the requirement files to understand the exact data needed and formatting rules.
+
+**Tool Calls:**
+* Use `filesystem-read_multiple_files` to read `data.txt` and `tips.txt`.
+
+## 2. Analyze the Excel Template Structure
+Examine the provided Excel template to understand its sheets, headers, and data ranges.
+
+**Tool Calls:**
+1. Use `excel-get_workbook_metadata` on the template file to list its sheets.
+2. Use `excel-read_data_from_excel` on each sheet to see the column headers and empty data cells.
+
+## 3. Fetch Required Financial Data
+Based on the requirements (`data.txt`), fetch the necessary data. Common requirements include:
+* **Stock Info & Fundamentals:** Use `yahoo-finance-get_stock_info`.
+* **Major Holders Summary:** Use `yahoo-finance-get_holder_info` with `holder_type: "major_holders"`.
+* **Institutional Holders Details:** Use `yahoo-finance-get_holder_info` with `holder_type: "institutional_holders"`.
+* **Historical Stock Prices:** Use `yahoo-finance-get_historical_stock_prices` for a date range, or `yahoo-finance-get_stock_price_by_date` for specific quarter-end dates.
+
+**Key Data Processing:**
+* Identify quarter-end dates (e.g., 2024-09-30 for Q3 2024).
+* Calculate Market Cap = `Stock Price * Shares Outstanding`.
+* Convert units as required (e.g., shares to millions, value to billions).
+
+## 4. Format Data According to Rules
+Strictly apply the formatting rules from `tips.txt` (e.g., "Round all numbers to two decimal places", "If the data is unavailable, fill in NaN").
+
+## 5. Populate the Excel Template
+Write the formatted data into the correct cells of the template.
+
+**Tool Calls:**
+* Use `excel-write_data_to_excel` for each sheet, specifying the `start_cell` (e.g., "B2" for data below headers).
+
+## 6. Finalize and Rename the File
+After populating all sheets, rename the file to the user's requested output name (e.g., from `results_template.xlsx` to `results.xlsx`).
+
+**Tool Calls:**
+* Use `filesystem-move_file`.
+
+## 7. Verify Completion
+Optionally, list the directory contents to confirm the final file exists and read back a sample of the data to ensure correctness.
+
+**Tool Calls:**
+* Use `filesystem-list_directory`.
+* Use `excel-read_data_from_excel` on the final file.
diff --git a/skills/benchmark_skills/toolathlon/financial-data-template-populator/references/data_requirements_example.md b/skills/benchmark_skills/toolathlon/financial-data-template-populator/references/data_requirements_example.md
new file mode 100644
index 0000000..446e4d5
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/financial-data-template-populator/references/data_requirements_example.md
@@ -0,0 +1,14 @@
+# Example Data Requirements (data.txt)
+This file specifies the data to be fetched and populated into specific Excel sheets.
+
+## Sheet 1: Basic Trend
+* Historical end-of-quarter stock prices, outstanding shares, and market cap for each quarter from [Start Quarter] to [End Quarter].
+* Example: "Historical end-of-quarter NVDA stock prices, outstanding shares, and market cap for each quarter from 2024 Q3 to 2025 Q2"
+
+## Sheet 2: Major Holders Summary
+* Summary of major holders: insiders held percentage, institutions held percentage, and number of institutions.
+* Example: "Summary of major holders: insiders held percentage, institutions held percentage, and number of institutions"
+
+## Sheet 3: Key Shareholders Details
+* Details on the top 10 institutional shareholders: shareholder name, shares held, holding value, holding ratio.
+* Example: "Details on the top 10 institutional shareholders: shareholder name, shares held, holding value, holding ratio"
diff --git a/skills/benchmark_skills/toolathlon/financial-data-template-populator/references/formatting_rules_example.md b/skills/benchmark_skills/toolathlon/financial-data-template-populator/references/formatting_rules_example.md
new file mode 100644
index 0000000..4fcf517
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/financial-data-template-populator/references/formatting_rules_example.md
@@ -0,0 +1,12 @@
+# Example Formatting Rules (tips.txt)
+This file specifies how to format the data in the Excel output.
+
+1. **Strictly follow the units in the file.**
+ * Check column headers for units (e.g., "Million Shares", "Billion USD", "%").
+ * Convert raw data to match these units before writing.
+
+2. **Round all numbers to two decimal places.**
+ * Apply to all numerical values (prices, percentages, calculated figures).
+
+3. **If the data is unavailable, fill in NaN.**
+ * Use the string "NaN" in the cell if data cannot be retrieved or calculated.
diff --git a/skills/benchmark_skills/toolathlon/fraud-investigation-data-consolidator/SKILL.md b/skills/benchmark_skills/toolathlon/fraud-investigation-data-consolidator/SKILL.md
new file mode 100644
index 0000000..ae6ecc9
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/fraud-investigation-data-consolidator/SKILL.md
@@ -0,0 +1,50 @@
+---
+name: fraud-investigation-data-consolidator
+description: Investigates a suspicious transaction by gathering all related data from a BigQuery analytics dataset, consolidating it into a structured JSON format, and triggering alert workflows.
+---
+# Instructions
+
+Execute the following steps to investigate a suspicious transaction. The primary goal is to create a comprehensive data snapshot for a given `transaction_id` and trigger the required alerting and archiving workflows.
+
+## 1. Initial Setup & Discovery
+* **Input:** You will be given a specific `transaction_id` (e.g., `T8492XJ3`).
+* **First, confirm the target dataset and storage buckets exist.**
+ * Use `google-cloud-bigquery_get_dataset_info` to verify the `transactions_analytics` dataset is accessible.
+ * Use `google-cloud-storage_list_buckets` to locate the archive bucket (name prefixed by `mcp-fraud-investigation-archive-`) and the log bucket (name prefixed by `Trading_Logging-`). Note their exact names.
+
+## 2. Schema Exploration & Data Querying
+* **Discover all tables** in the `transactions_analytics` dataset using `google-cloud-bigquery_run_query` on the `INFORMATION_SCHEMA.TABLES` view.
+* **For the target transaction, query data from two primary sources:**
+ 1. `live_transactions` table: Get the full record for the given `transaction_id`. This record contains key foreign IDs (`user_id`, `account_id`, `merchant_id`, `card_id`, `device_id`, `location_id`).
+ 2. `fraud_alerts` table: Check for any existing alerts for this `transaction_id`.
+* **Using the IDs from the `live_transactions` record, query all related dimension tables:**
+ * `users` (by `user_id`)
+ * `accounts` (by `account_id`)
+ * `merchants` (by `merchant_id`)
+ * `cards` (by `card_id`)
+ * `devices` (by `device_id`)
+ * `locations` (by `location_id`)
+ * `risk_scores` (by `user_id`)
+ * `blacklist` (Check if any of the IDs `user_id`, `account_id`, `card_id`, `device_id`, or `merchant_id` appear in the `value` column. Note: The `blacklist` table schema uses `entity_id`, `entity_type`, `value`).
+* **Find related transactions:** Query the `live_transactions` table for all other transactions by the same `user_id`, excluding the target `transaction_id`. Order by `timestamp DESC` and limit results appropriately (e.g., 1000).
+
+## 3. Data Consolidation & JSON Creation
+* **Structure the final JSON object** with the following keys. Convert Python objects (like `datetime`, `list`, `dict`) to JSON-serializable strings (ISO format for dates, proper JSON arrays/objects).
+ * `live_transactions`: The main transaction record.
+ * `fraud_alerts`: The associated alert record (if any).
+ * `users`, `accounts`, `merchants`, `cards`, `devices`, `locations`, `risk_scores`, `blacklist`: The related dimension data.
+ * `related_transactions`: An **array** containing the other transactions for the user.
+* **Save the JSON file** locally to the workspace using `filesystem-write_file`. Name the file `<transaction_id>.json` (e.g., `T8492XJ3.json`).
+
+## 4. Archiving & Alerting
+* **Upload the JSON file** to the identified archive storage bucket using `google-cloud-storage_upload_file`. Use the `transaction_id` as the blob name.
+* **Write a CRITICAL log entry** to the identified logging bucket using `google-cloud-logging_write_log`.
+ * **Log Name:** Use the full name of the log bucket (e.g., `Trading_Logging-e877351c7447`).
+ * **Severity:** `CRITICAL`
+ * **Message/Payload:** A JSON string with the exact structure: `{"alert_type": "Fraud", "transaction_id": "<TRANSACTION_ID>", "status": "Pending_Investigation"}`
+
+## Key Considerations
+* **Error Handling:** If a query for a specific table returns no data, include an empty object `{}` for that key in the final JSON.
+* **Data Types:** Pay special attention to serializing complex fields (flags, velocity_checks, etc.) from the `live_transactions` table from stringified JSON to proper JSON objects/arrays in the output.
+* **Bucket Names:** The archive and log bucket names are dynamic (with unique suffixes). Always list buckets first to confirm their exact names.
+* **Logging:** The log write must happen *after* successful archiving. The log entry is new and independent of any existing logs in the bucket.
diff --git a/skills/benchmark_skills/toolathlon/fraud-investigation-data-consolidator/references/schema_guide.md b/skills/benchmark_skills/toolathlon/fraud-investigation-data-consolidator/references/schema_guide.md
new file mode 100644
index 0000000..73d5ff6
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/fraud-investigation-data-consolidator/references/schema_guide.md
@@ -0,0 +1,80 @@
+# Schema Reference: transactions_analytics Dataset
+
+This guide documents the key tables and relationships used by the `fraud-investigation-data-consolidator` skill.
+
+## Core Transaction Tables
+
+### `live_transactions`
+The primary fact table. Contains the main transaction record with risk scores and analysis metadata.
+* **Primary Key:** `transaction_id`
+* **Foreign Keys:**
+ * `user_id` → `users.user_id`
+ * `account_id` → `accounts.account_id`
+ * `merchant_id` → `merchants.merchant_id`
+ * `card_id` → `cards.card_id`
+ * `device_id` → `devices.device_id`
+ * `location_id` → `locations.location_id`
+* **Notable Fields:**
+ * `amount`, `currency`, `timestamp`, `status`
+ * `risk_score`, `ml_fraud_score`
+ * `flags`: **JSON string** array of triggered rule flags.
+ * `velocity_checks`, `geographic_data`, `device_analysis`, `merchant_analysis`, `network_analysis`: **JSON string** objects containing detailed risk analysis.
+
+### `fraud_alerts`
+Contains alerts generated by the fraud detection system for specific transactions.
+* **Lookup Key:** `transaction_id`
+* **Key Fields:** `alert_id`, `severity`, `status`, `triggered_rules` (JSON string array), `estimated_fraud_probability`.
+
+## Dimension & Reference Tables
+
+### `users`
+User profile and KYC information.
+* **Primary Key:** `user_id`
+* **Key Fields:** `username`, `email`, `kyc_status`, `risk_level`, `registration_date`.
+
+### `accounts`
+Financial account details.
+* **Primary Key:** `account_id`
+* **Foreign Key:** `user_id`
+* **Key Fields:** `account_type`, `balance_usd`, `daily_limit`, `frozen`.
+
+### `merchants`
+Merchant/business information and risk rating.
+* **Primary Key:** `merchant_id`
+* **Key Fields:** `business_name`, `country`, `license_status`, `risk_rating`, `sanctions_check`.
+
+### `cards`
+Payment card details.
+* **Primary Key:** `card_id`
+* **Foreign Key:** `user_id`
+* **Key Fields:** `card_type`, `issuer_country`, `status`, `velocity_flags` (JSON string array).
+
+### `devices`
+Device fingerprinting and connection data.
+* **Primary Key:** `device_id`
+* **Foreign Key:** `user_id`
+* **Key Fields:** `device_fingerprint`, `ip_address`, `vpn_detected`, `risk_score`.
+
+### `locations`
+Geographic reference data.
+* **Primary Key:** `location_id`
+* **Key Fields:** `city`, `country`, `latitude`, `longitude`.
+
+### `risk_scores`
+Historical risk scoring for users.
+* **Lookup Key:** `user_id`
+* **Key Fields:** `current_score`, `score_history` (JSON string array), `risk_factors` (JSON string array).
+
+### `blacklist`
+List of sanctioned or blocked entities (users, accounts, cards, devices, merchants).
+* **Schema Note:** Uses a generic schema.
+ * `entity_id`: Unique ID for the blacklist entry.
+ * `entity_type`: e.g., 'USER', 'ACCOUNT', 'MERCHANT'.
+ * `value`: The actual identifier (e.g., a `user_id`, `merchant_id`).
+ * `reason`, `severity`, `source`.
+* **Query Tip:** To find if any entity related to a transaction is blacklisted, search the `value` column for the relevant IDs (`user_id`, `account_id`, `merchant_id`, `card_id`, `device_id`).
+
+## Query Patterns for Investigation
+
+1. **Get Transaction Core:**
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/geolocation-distance-filter/SKILL.md b/skills/benchmark_skills/toolathlon/geolocation-distance-filter/SKILL.md
new file mode 100644
index 0000000..e3b0064
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/geolocation-distance-filter/SKILL.md
@@ -0,0 +1,35 @@
+---
+name: geolocation-distance-filter
+description: When the user needs to filter locations based on proximity to a reference point within a specified radius. This skill geocodes addresses to coordinates, calculates distances between locations, and filters results based on maximum distance thresholds. Triggers include 'within X km/miles of', 'distance from', 'near location', 'proximity filter', or when location-based filtering is required for job applications, real estate, or service area analysis.
+---
+# Geolocation Distance Filter
+
+## Purpose
+Filter a list of items based on the geographic distance of their locations from a specified reference point. This is essential for location-based queries like finding jobs, properties, or services within a certain radius.
+
+## Core Workflow
+1. **Identify Reference Point:** Determine the central location (e.g., "UCLA", "downtown office") and the maximum allowed distance (e.g., "within 500 km").
+2. **Geocode Reference:** Convert the reference point's address into latitude/longitude coordinates using the `google_map-maps_geocode` tool.
+3. **Extract Target Items:** Obtain the list of items to filter (e.g., from a database query). Each item must have a location field.
+4. **Geocode & Calculate:** For each candidate item:
+ * Geocode its location address.
+ * Calculate the distance from the reference coordinates using the Haversine formula (see `scripts/distance_calculator.py`).
+5. **Apply Filter:** Retain only items where the calculated distance is less than or equal to the specified maximum radius.
+6. **Return Results:** Output the filtered list and the calculated distances for context.
+
+## Key Instructions
+* **Precision:** Always use the `google_map-maps_geocode` tool for reliable coordinate conversion. Do not assume distances.
+* **Unit Consistency:** Ensure the maximum distance threshold and the calculated distances are in the same units (kilometers by default). Convert if necessary (1 mile = 1.60934 km).
+* **Error Handling:** If geocoding fails for an item, log it and exclude it from the filtered results, noting the issue.
+* **Integration:** This filter is typically one step in a larger workflow (e.g., filter jobs, then apply other criteria like salary).
+
+## Common Triggers
+* "Find [items] within [X] km/miles of [location]"
+* "Which [items] are closest to [reference point]?"
+* "Filter these results by distance from [address]"
+* "Show only [items] in the [area] area"
+* Implied need when location is a critical constraint (e.g., "commutable jobs", "nearby stores").
+
+## Bundled Resources
+* `scripts/distance_calculator.py`: Contains the `calculate_distance` function for accurate distance computation.
+* `references/haversine_formula.md`: Explanation of the distance calculation method.
diff --git a/skills/benchmark_skills/toolathlon/geolocation-distance-filter/references/haversine_formula.md b/skills/benchmark_skills/toolathlon/geolocation-distance-filter/references/haversine_formula.md
new file mode 100644
index 0000000..242fd20
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/geolocation-distance-filter/references/haversine_formula.md
@@ -0,0 +1,6 @@
+# Haversine Formula for Distance Calculation
+
+## Overview
+The Haversine formula calculates the great-circle distance between two points on a sphere given their longitudes and latitudes. It is essential for accurate distance calculations on Earth's surface, accounting for its curvature.
+
+## Formula
diff --git a/skills/benchmark_skills/toolathlon/git-performance-issue-investigator/SKILL.md b/skills/benchmark_skills/toolathlon/git-performance-issue-investigator/SKILL.md
new file mode 100644
index 0000000..e23e87e
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/git-performance-issue-investigator/SKILL.md
@@ -0,0 +1,18 @@
+---
+name: git-performance-issue-investigator
+description: When the user needs to investigate performance issues in a Git repository by finding specific code changes, identifying responsible commits, and contacting authors. This skill is triggered by requests involving finding commits containing specific variables or code patterns, identifying earliest/introducing commits, extracting author information (name, email), and communicating about performance issues. It provides capabilities for searching Git history for specific code patterns using git log -S, retrieving full commit details with git show, extracting author metadata, and generating formatted communications using templates.
+---
+# Instructions
+
+## Overview
+This skill investigates performance issues in Git repositories by tracing code changes to specific commits, identifying responsible authors, and generating communications.
+
+## Core Workflow
+
+### 1. Initialize Investigation
+- Identify the target Git repository path in the workspace
+- Confirm the specific code pattern or variable name to search for (e.g., `remove_caching_layer`)
+- Locate any communication templates in the workspace (e.g., `template.txt`)
+
+### 2. Find Introducing Commit
+Use `git log` with the `-S` flag to search for the earliest commit containing the specified code pattern:
diff --git a/skills/benchmark_skills/toolathlon/git-performance-issue-investigator/assets/template.txt b/skills/benchmark_skills/toolathlon/git-performance-issue-investigator/assets/template.txt
new file mode 100644
index 0000000..e61a6ff
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/git-performance-issue-investigator/assets/template.txt
@@ -0,0 +1,16 @@
+Dear {Author's Name},
+
+We are investigating a recent performance issue in the LUFFY repository. Our analysis indicates that this issue was introduced by your commit.
+
+Below are the details of the commit that we have identified:
+
+Commit Hash: {Commit Hash}
+
+Commit Message:
+{Full Commit Message}
+
+Please get in touch with the team to discuss this issue.
+
+Thank you,
+
+LUFFY Team
diff --git a/skills/benchmark_skills/toolathlon/git-performance-issue-investigator/references/email_templates.md b/skills/benchmark_skills/toolathlon/git-performance-issue-investigator/references/email_templates.md
new file mode 100644
index 0000000..5fadfd8
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/git-performance-issue-investigator/references/email_templates.md
@@ -0,0 +1,11 @@
+# Email Templates for Performance Issue Communication
+
+## Template Structure
+All templates should include these key elements:
+1. **Salutation** with author's name
+2. **Context** about the performance investigation
+3. **Commit details** (hash and message)
+4. **Call to action** for follow-up
+5. **Closing** with team signature
+
+## Default Template
diff --git a/skills/benchmark_skills/toolathlon/git-performance-issue-investigator/references/git_commands.md b/skills/benchmark_skills/toolathlon/git-performance-issue-investigator/references/git_commands.md
new file mode 100644
index 0000000..7e9716a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/git-performance-issue-investigator/references/git_commands.md
@@ -0,0 +1,5 @@
+# Git Commands Reference for Performance Investigation
+
+## Searching for Code Patterns
+
+### Find Commits Containing Specific Code
diff --git a/skills/benchmark_skills/toolathlon/github-repository-data-collector/SKILL.md b/skills/benchmark_skills/toolathlon/github-repository-data-collector/SKILL.md
new file mode 100644
index 0000000..366b9d4
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/github-repository-data-collector/SKILL.md
@@ -0,0 +1,42 @@
+---
+name: github-repository-data-collector
+description: When the user needs to collect specific repository information from GitHub for analysis, reporting, or archival purposes. This skill fetches repository data from the GitHub API using repository IDs, extracts key metrics (name, owner, stars, forks, creation time, description, language, URL), handles missing/inaccessible repositories gracefully by skipping them, and saves the formatted data to a JSON file with specified structure. Triggers include GitHub repository data collection, milestone repository tracking, API data fetching from GitHub, JSON file creation with repository metrics.
+---
+# Instructions
+
+## Objective
+Collect specific GitHub repository information by ID from the GitHub API, extract defined metrics, and save the results to a structured JSON file. Skip any repositories that are inaccessible.
+
+## Core Workflow
+
+1. **Parse the Request:** Identify the target repository IDs and the desired output file name (default: `github_info.json`). The user may specify these directly or imply them through context (e.g., "collect info for repos 1, 1000, 1000000").
+
+2. **Fetch Data:** For each repository ID, call the GitHub API endpoint: `GET https://api.github.com/repositories/{ID}`.
+ * Use the `fetch-fetch_json` tool.
+ * **Error Handling:** If the API returns an error (e.g., 404), log a note and skip this repository. Do not include it in the final output.
+
+3. **Transform Data:** For each successful API response, extract the following fields and map them to the specified JSON keys:
+ * `repo_name` -> `name`
+ * `owner` -> `owner.login`
+ * `star_count` -> `stargazers_count` (integer)
+ * `fork_count` -> `forks_count` (integer)
+ * `creation_time` -> `created_at` (ISO 8601 format, ensure it ends with 'Z')
+ * `description` -> `description` (can be `null`)
+ * `language` -> `language` (can be `null`)
+ * `repo_url` -> `html_url`
+
+4. **Build Output Structure:** Construct a JSON object where the top-level keys are the repository IDs (as strings). The value for each key is an object containing the 8 key-value pairs defined above.
+
+5. **Save File:** Write the final, formatted JSON object to the specified file path using `filesystem-write_file`. Use proper JSON formatting with indentation for readability.
+
+6. **Summarize:** Provide a concise summary to the user, confirming the file was saved and listing which repositories were successfully collected and which were skipped.
+
+## Key Constraints & Notes
+* **Output Format:** The JSON must strictly follow the structure: `{ "<repo_id>": { "key_0": "value", ... } }`.
+* **Skipping Repos:** Only include data for repositories that return a successful API response. Do not create placeholder entries for failed requests.
+* **Data Types:** Ensure `star_count` and `fork_count` are integers. Preserve `null` values for `description` and `language` if the API provides them.
+* **Idempotency:** The skill can be run multiple times; it will overwrite the specified output file.
+
+## Example
+**User Request:** "Collect info for repos 1, 1000, and 1000000, save to `milestones.json`."
+**Agent Action:** Fetches data for IDs 1, 1000, 1000000. If repo 1000 fails, the final `milestones.json` will only contain keys `"1"` and `"1000000"`.
diff --git a/skills/benchmark_skills/toolathlon/github-repository-data-collector/references/output_schema.md b/skills/benchmark_skills/toolathlon/github-repository-data-collector/references/output_schema.md
new file mode 100644
index 0000000..22c3d3a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/github-repository-data-collector/references/output_schema.md
@@ -0,0 +1,6 @@
+# Output JSON Schema
+
+## Structure
+The final output is a single JSON object. Each top-level key is a GitHub repository ID, provided as a string. The value for each key is an object containing the 8 specified metrics.
+
+## Root Object
diff --git a/skills/benchmark_skills/toolathlon/google-sheets-cr5-analyzer/SKILL.md b/skills/benchmark_skills/toolathlon/google-sheets-cr5-analyzer/SKILL.md
new file mode 100644
index 0000000..c27cb00
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/google-sheets-cr5-analyzer/SKILL.md
@@ -0,0 +1,69 @@
+---
+name: google-sheets-cr5-analyzer
+description: Calculates CR5 concentration indices for World Bank geographical regions from Google Sheets GDP data. Reads country and region data, maps countries to regions, identifies top 5 GDP countries per region, computes CR5 ratio, and creates a new spreadsheet with sorted results.
+---
+# Skill: Google Sheets CR5 Analyzer
+
+## Purpose
+Calculate the CR5 (Concentration Ratio of top 5) economic index for the seven major World Bank geographical regions using GDP data from Google Sheets. The skill reads source data, performs calculations, and outputs results to a new spreadsheet.
+
+## Trigger Phrases
+- "Calculate CR5 index"
+- "Concentration ratio analysis"
+- "Top 5 countries by GDP per region"
+- "World Bank regional GDP concentration"
+- "CR5 analysis from Google Sheets"
+- "Regional economic concentration metrics"
+
+## Required Input Data Structure
+The skill expects a Google Sheets spreadsheet containing:
+1. **Country sheet**: Must include columns for Country Code, Country Name, and GDP (in millions of US dollars)
+2. **Region sheet**: Must include columns for Region Code, Region Name, and Regional GDP total
+
+## Core Workflow
+
+### 1. Data Acquisition
+- Locate the source spreadsheet by title or ID
+- Read both Country and Region sheet data
+- Extract country names, GDP values, and regional totals
+
+### 2. Country-Region Mapping
+- Use the World Bank's official geographical classification for 7 regions:
+ - East Asia & Pacific (EAS)
+ - Europe & Central Asia (ECS)
+ - Latin America & Caribbean (LCN)
+ - Middle East & North Africa (MEA)
+ - North America (NAC)
+ - South Asia (SAS)
+ - Sub-Saharan Africa (SSF)
+
+**Important**: The mapping must use exact country names as they appear in the source data. See `references/world_bank_regions.md` for the complete mapping.
+
+### 3. CR5 Calculation
+For each of the 7 regions:
+- Filter countries belonging to the region
+- Sort countries by GDP (descending)
+- Select top 5 countries (or all if region has fewer than 5)
+- Calculate: `CR5_Ratio = (Sum of top 5 GDP / Regional GDP total) × 100`
+- Round CR5 ratio to 2 decimal places
+
+### 4. Output Generation
+- Create new spreadsheet titled "GDP CR5 Analysis"
+- Create sheet titled "gdp_cr5_analysis"
+- Populate with headers: `Region`, `Top5_Countries`, `Top5_GDP_Sum`, `Region_GDP_Total`, `CR5_Ratio`
+- Sort results by CR5_Ratio (descending)
+- Format CR5_Ratio as percentage with 2 decimal places
+
+## Error Handling
+- If a country name doesn't match the World Bank mapping, log it but continue processing
+- If a region has no countries in the data, skip it from results
+- If GDP values are missing or zero, handle gracefully in calculations
+
+## Quality Checks
+- Verify all 7 World Bank regions are represented
+- Ensure CR5 ratios are between 0-100% (or >100% only if data errors)
+- Cross-check regional GDP totals match sum of constituent countries (within reasonable tolerance)
+
+## Notes
+- North America typically has only 3 countries (US, Canada, Bermuda), so CR5 will include all available countries
+- The skill focuses on geographical regions, not income-based classifications (LIC, LMC, UMC, HIC)
diff --git a/skills/benchmark_skills/toolathlon/google-sheets-market-data-organizer/SKILL.md b/skills/benchmark_skills/toolathlon/google-sheets-market-data-organizer/SKILL.md
new file mode 100644
index 0000000..b21b71b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/google-sheets-market-data-organizer/SKILL.md
@@ -0,0 +1,39 @@
+---
+name: google-sheets-market-data-organizer
+description: Creates and populates Google Sheets with structured financial or market data. It creates spreadsheets with custom names and worksheets, formats data according to specified templates (like CSV examples), and writes organized datasets. It handles spreadsheet creation, sheet renaming, and bulk data insertion.
+---
+# Instructions
+
+## 1. Understand the Request
+The user will request to create a Google Sheet with a specific name and a worksheet with a specific title. They will specify a list of stock tickers and a date range. They will reference an example CSV file for the required data format. The final step is to post a notification to a specific Notion page.
+
+**Key Requirements:**
+* Use **original prices** (set `auto_adjust: false` when fetching data).
+* **Exclude non-trading days** automatically (the data source handles this).
+* Follow the column format from the example: `Ticker,Date,Open,High,Low,Close,Volume`.
+* Post a specific notification to a Notion page upon completion.
+
+## 2. Execute the Workflow
+
+### Phase 1: Preparation & Data Fetching
+1. **Locate the Example Template:** Read the provided example CSV file (e.g., `example.csv`) to confirm the required data structure.
+2. **Find the Target Notion Page:** Search for the specified Notion page (e.g., "Quant Research") and note its Page ID.
+3. **Create the Google Sheet:** Create a new spreadsheet with the requested title (e.g., "2025_Market_Data").
+4. **Rename the Worksheet:** Rename the default sheet in the new spreadsheet to the requested worksheet title (e.g., "Jun-Jul_2025").
+5. **Fetch Stock Data:** For each specified ticker (e.g., AAPL, TSLA, NVDA, META), retrieve historical daily price data for the given date range. **Crucially, ensure `auto_adjust` is set to `false`.**
+
+### Phase 2: Data Processing & Population
+6. **Process the Data:** Use the bundled `process_data.py` script to transform the fetched JSON data into a list of rows matching the example CSV format (`Ticker, Date, Open, High, Low, Close, Volume`). The script handles date formatting and data structuring.
+7. **Write Data to Sheet:** Use the `google_sheet-append_to_sheet` tool to write the processed data rows to the target worksheet. Write the header row first, followed by all data rows.
+
+### Phase 3: Notification
+8. **Generate Google Sheet URL:** Construct the Google Sheet URL using the spreadsheet ID (format: `https://docs.google.com/spreadsheets/d/{spreadsheetId}`).
+9. **Update Notion Page:**
+ * Append a new line to the target Notion page with the exact text: `Google Sheet : {url}`.
+ * Add a comment at the top of the same page with the exact text: `"Monthly market data is ready. The reporting team can view it directly"`.
+
+## 3. Error Handling & Validation
+* If the example CSV cannot be read, inform the user and ask for clarification on the format.
+* If the target Notion page is not found, search again with a more specific filter (`"filter": {"property":"object","value":"page"}`) and confirm the correct page ID before proceeding.
+* Verify the stock data for each ticker was fetched successfully before processing.
+* After writing to the sheet, consider adding a final step to read back a sample cell to confirm the data was written correctly.
diff --git a/skills/benchmark_skills/toolathlon/google-sheets-market-data-organizer/references/data_format.md b/skills/benchmark_skills/toolathlon/google-sheets-market-data-organizer/references/data_format.md
new file mode 100644
index 0000000..0eb7cd5
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/google-sheets-market-data-organizer/references/data_format.md
@@ -0,0 +1,4 @@
+# Required Data Format for Google Sheet
+
+## Source Format (Yahoo Finance API)
+The `yahoo-finance-get_historical_stock_prices` tool returns data as a list of JSON objects. Key fields are:
diff --git a/skills/benchmark_skills/toolathlon/google-sheets-market-data-organizer/references/notion_instructions.md b/skills/benchmark_skills/toolathlon/google-sheets-market-data-organizer/references/notion_instructions.md
new file mode 100644
index 0000000..f1765bd
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/google-sheets-market-data-organizer/references/notion_instructions.md
@@ -0,0 +1,19 @@
+# Notion Page Update Instructions
+
+## Target Page Identification
+- Use the `notion-API-post-search` tool with a query for the exact page name (e.g., "Quant Research").
+- Apply a filter to limit results to pages: `"filter": {"property":"object","value":"page"}`.
+- From the results, identify the correct page by its `title` property and note its `id`.
+
+## Required Updates
+After successfully creating and populating the Google Sheet, make two updates to the identified Notion page:
+
+1. **Append a Line of Text:**
+ - Use the appropriate tool (e.g., `notion-API-append-block`) to add a new text block to the page.
+ - The text must be exactly: `Google Sheet : https://docs.google.com/spreadsheets/d/{spreadsheetId}`
+ - Replace `{spreadsheetId}` with the actual ID from the `google_sheet-create_spreadsheet` response.
+
+2. **Add a Page Comment:**
+ - Use the `notion-API-create-comment` tool.
+ - The comment text must be exactly: `"Monthly market data is ready. The reporting team can view it directly"`
+ - The `parent` parameter should be the page's ID.
diff --git a/skills/benchmark_skills/toolathlon/graduate-program-locator/SKILL.md b/skills/benchmark_skills/toolathlon/graduate-program-locator/SKILL.md
new file mode 100644
index 0000000..15b2fbb
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/graduate-program-locator/SKILL.md
@@ -0,0 +1,55 @@
+---
+name: graduate-program-locator
+description: When the user needs to find graduate programs based on specific ranking criteria, geographical constraints, and filtering requirements. This skill extracts university rankings from academic ranking websites (like CSRankings), filters programs by specific criteria (ranking position, research areas, year), geocodes locations, calculates driving distances from a reference point, and compiles structured data into formatted reports. It handles web scraping of ranking data, geographic distance calculations, and JSON data formatting for academic program comparisons.
+---
+# Skill: Graduate Program Locator
+
+## Purpose
+Locate and compile a structured list of graduate programs meeting specific ranking, geographical, and filtering criteria for academic planning and application preparation.
+
+## Core Workflow
+1. **Parse User Request:** Identify the key constraints: ranking source, ranking criteria (field, year, top N), geographical reference point, maximum distance, and required output format.
+2. **Extract Ranking Data:** Navigate to the specified ranking website (e.g., CSRankings), configure filters (research areas, year range, country), and extract the ranked list of institutions.
+3. **Geocode Locations:** Obtain precise coordinates for the user-specified reference location and for each qualifying university.
+4. **Calculate Distances:** Compute the driving distance from the reference point to each university.
+5. **Filter & Sort:** Apply the distance constraint, then sort the final list primarily by distance (nearest first), and secondarily by rank (higher rank first) for ties.
+6. **Generate Report:** Format the results into the specified structured output (e.g., JSON) and save the file.
+
+## Key Instructions & Logic
+
+### 1. Configuring the Ranking Source (CSRankings Example)
+- Navigate to the ranking site with parameters pre-set for the desired field (e.g., `https://csrankings.org/#/index?ai&vision&mlmining&nlp&us` for US AI programs).
+- **Critical:** Ensure unwanted sub-fields are deselected. For example, if "Information Retrieval" must be excluded, verify its checkbox is **unchecked**.
+- Set the publication year range precisely. Use the "from year" and "to year" dropdowns to select the same year (e.g., 2024) for a single-year ranking.
+- Allow the page to load completely after each filter change. Listen for console log messages like "Rank took... milliseconds" as an indicator.
+
+### 2. Extracting Ranked Institutions
+- The ranking is presented in a table. Parse rows to capture:
+ - `rank`: The numeric rank (#) from the first column.
+ - `institution_name`: The full university name.
+ - Note: The table may contain tie ranks (e.g., two institutions at rank "3").
+- Extract data for the top N institutions as specified by the user.
+
+### 3. Geocoding & Distance Calculation
+- Use a geocoding tool to get coordinates for the reference address (e.g., "Natural History Museum of Los Angeles County").
+- For each university, construct a search query typically as "University Name, City, State" for reliable results. The city can often be inferred from the university's common location.
+- Use a distance matrix tool to batch-calculate driving distances from the single origin to all university destinations.
+- **Unit Conversion:** The skill typically receives distances in **kilometers**. Convert to miles using the formula: `miles = kilometers * 0.621371`. Round the final result to the nearest integer as requested.
+
+### 4. Data Processing & Output
+- Create a list of candidate universities with fields: `university`, `city`, `cs_ranking_rank`, `car_drive_miles`.
+- Filter out any university where `car_drive_miles > maximum_distance`.
+- Sort the filtered list:
+ 1. Primary key: `car_drive_miles` (ascending).
+ 2. Secondary key: `cs_ranking_rank` (ascending) for universities with equal distance.
+- Write the sorted list as a properly formatted JSON array to the specified filename.
+
+## Common Pitfalls & Validations
+- **Year Filter:** Double-check that both "from" and "to" year dropdowns are set correctly. An incorrect range will pull data from multiple years.
+- **Field Exclusion:** Visually confirm checkboxes for excluded research areas (e.g., "The Web & information retrieval") are not selected.
+- **Distance Units:** Confirm the distance matrix output is in kilometers before converting to miles.
+- **City Names:** Use the city from the geocoding result (`formatted_address`) for consistency, not assumed locations.
+- **Tie Ranks:** The scraping logic must handle consecutive rows with the same rank number without skipping data.
+
+## Output
+The primary deliverable is a JSON file containing the filtered and sorted list of graduate programs. Provide a concise summary to the user highlighting the number of programs found, the closest and highest-ranked options, and the save location of the file.
diff --git a/skills/benchmark_skills/toolathlon/graduate-program-locator/references/csrankings_guide.md b/skills/benchmark_skills/toolathlon/graduate-program-locator/references/csrankings_guide.md
new file mode 100644
index 0000000..5f891e5
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/graduate-program-locator/references/csrankings_guide.md
@@ -0,0 +1,31 @@
+# CSRankings Interface Guide
+
+## URL Parameters & Filters
+CSRankings uses a hash-based URL system to represent state. Key parameters include:
+
+* `index?ai&vision&mlmining&nlp`: Selects AI research areas (Artificial Intelligence, Computer Vision, Machine Learning, Natural Language Processing).
+* `&us`: Filters to institutions in the United States.
+* `fromyear/2024/toyear/2024`: Sets the publication year range (both must be set for a single year).
+
+## Page Structure & Data Extraction
+1. **Loading:** The page shows "Loading publication data." initially. Wait for "Rank took..." console messages.
+2. **Filter Area:** A left sidebar contains expandable sections for research areas. Checkboxes indicate selection.
+3. **Ranking Table:** The main content is a table with columns:
+ * `#`: Numerical rank.
+ * `Institution`: University name and flag icon.
+ * `Count`: Normalized publication score.
+ * `Faculty`: Number of contributing faculty.
+4. **Ties:** Identical ranks appear as duplicate numbers in consecutive rows.
+
+## Important Checkboxes for AI (Excluding Information Retrieval)
+For a comprehensive AI ranking that excludes Information Retrieval, ensure the following checkboxes are **checked**:
+- [x] Artificial intelligence
+- [x] Computer vision
+- [x] Machine learning
+- [x] Natural language processing
+
+And this checkbox is **unchecked**:
+- [ ] The Web & information retrieval
+
+## Year Selection
+Use the two dropdowns labeled "by publications from" and "to". For a ranking of publications in 2024 only, set both to "2024".
diff --git a/skills/benchmark_skills/toolathlon/graduate-program-locator/references/output_schema.md b/skills/benchmark_skills/toolathlon/graduate-program-locator/references/output_schema.md
new file mode 100644
index 0000000..5949a52
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/graduate-program-locator/references/output_schema.md
@@ -0,0 +1,5 @@
+# Output JSON Schema
+
+The final output is a JSON array of objects. Each object represents a university meeting all criteria.
+
+## Schema Definition
diff --git a/skills/benchmark_skills/toolathlon/helm-chart-upgrade-with-config-preservation/SKILL.md b/skills/benchmark_skills/toolathlon/helm-chart-upgrade-with-config-preservation/SKILL.md
new file mode 100644
index 0000000..9293f0d
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/helm-chart-upgrade-with-config-preservation/SKILL.md
@@ -0,0 +1,49 @@
+---
+name: helm-chart-upgrade-with-config-preservation
+description: Upgrades a Helm chart to a specific version while preserving existing configurations from a values file and ensuring the application remains operational. Handles the complete upgrade workflow including state discovery, compatibility resolution, configuration updates, execution, monitoring, and verification.
+---
+# Instructions
+
+## 1. Discover Current State & Environment
+- **Locate Workspace Files:** List the workspace directory to find configuration files (`config/`) and kubeconfigs (`k8s_configs/`).
+- **Check Kubernetes Context:** Verify the active or available Kubernetes cluster contexts.
+- **Read Values File:** Load the user-specified values YAML file (e.g., `config/redis-values.yaml`) to understand the current configuration.
+- **Verify Target Namespace:** Confirm the target namespace (e.g., `shared-services`) exists.
+- **Check Current Helm Release:** Use `helm list -n <namespace>` with the correct kubeconfig to find the current chart name and version.
+- **Check Pod Status:** List pods in the target namespace to establish a baseline health state.
+
+## 2. Identify & Resolve Compatibility Issues
+- **Compare Values:** Retrieve the previously applied Helm values (`helm get values --revision <N>`) to identify any runtime configurations (like image repositories) not present in the static values file.
+- **Analyze Upgrade Errors:** If the initial upgrade fails (e.g., due to image pull errors or security warnings), inspect the pod events and StatefulSet specs to diagnose the root cause (e.g., `ErrImagePull`).
+- **Common Fixes:** Be prepared to handle:
+ - **Image Repository Changes:** Newer Bitnami charts may require using `bitnamilegacy/` repositories. Add `image.repository`, `sentinel.image.repository`, `metrics.image.repository`, `volumePermissions.image.repository`, and `sysctl.image.repository` fields to the values file.
+ - **Security Policy:** Add `global.security.allowInsecureImages: true` to bypass non-standard container warnings.
+- **Update Values File:** Edit the user's values YAML file in-place to incorporate the necessary compatibility fixes, ensuring no duplicate sections are created.
+
+## 3. Execute the Helm Upgrade
+- **Run Upgrade Command:** Execute `helm upgrade <RELEASE_NAME> <REPO/CHART> --version <TARGET_VERSION> -n <NAMESPACE> -f <VALUES_FILE_PATH> --kubeconfig <KUBECONFIG_PATH>`.
+- **Handle Kubeconfig:** If the `export` command is not allowed, pass the kubeconfig path directly via the `--kubeconfig` flag.
+
+## 4. Monitor & Remediate Deployment
+- **Watch Pod Status:** After the upgrade, immediately check the status of all pods in the namespace. Look for `Pending`, `ErrImagePull`, `ImagePullBackOff`, or `CrashLoopBackOff` states.
+- **Inspect Stuck Pods:** Use `kubectl describe pod <name>` to get detailed events and identify why pods are not becoming `Ready`.
+- **Force Pod Recreation:** If StatefulSets have updated revisions but old pods persist with outdated images, **delete the problematic pods** (`kubectl delete pod <name>`). The StatefulSet controller will recreate them with the new spec.
+- **Wait for Readiness:** Poll pod status until all pods show `READY` (e.g., `1/1`) and `STATUS: Running`. Allow time for startup and readiness probes to pass.
+
+## 5. Verify Successful Upgrade
+- **Confirm Helm Revision:** Verify `helm list` shows the correct new chart version and `STATUS: deployed`.
+- **Check StatefulSet Health:** Confirm all StatefulSets show `READY` replicas matching the desired count (e.g., `1/1`, `2/2`).
+- **Validate Applied Values:** Run `helm get values` to ensure all configurations from the updated values file are present.
+- **Final Health Check:** Perform a final check that all application pods are `Ready` and services exist.
+
+## Key Triggers & User Intent
+- The user requests to upgrade a specific Helm chart to an exact version.
+- The user emphasizes preserving configurations from a named values YAML file.
+- The user requires the application (pods) to be running properly after the upgrade.
+- Keywords: `upgrade`, `helm chart`, `version X.X.X`, `values.yaml`, `ensure configurations remain effective`.
+
+## Critical Notes
+- **Image Compatibility:** The trajectory shows a common issue where Bitnami's public image registry changed. Always check and specify `bitnamilegacy/` repositories if standard pulls fail.
+- **StatefulSet Rollout:** Helm upgrades may not immediately replace existing Pods in StatefulSets. Manual pod deletion is often required to force recreation with new images.
+- **Security Warnings:** Adding `global.security.allowInsecureImages: true` is necessary when using non-standard images but carries security implications. The skill should document this trade-off.
+- **Idempotency:** The steps are designed to be re-runnable. Checking state before making changes prevents unnecessary operations.
diff --git a/skills/benchmark_skills/toolathlon/helm-chart-upgrade-with-config-preservation/references/common_upgrade_issues.md b/skills/benchmark_skills/toolathlon/helm-chart-upgrade-with-config-preservation/references/common_upgrade_issues.md
new file mode 100644
index 0000000..e18ed92
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/helm-chart-upgrade-with-config-preservation/references/common_upgrade_issues.md
@@ -0,0 +1,11 @@
+# Common Helm Chart Upgrade Issues & Solutions
+
+## 1. Image Pull Errors
+### Symptoms
+- Pods stuck in `Pending` or `ErrImagePull`/`ImagePullBackOff` state
+- Events show: `failed to resolve reference`, `image not found`
+
+### Causes & Fixes
+- **Bitnami Registry Change (Post-August 2025):** Free tier access moved to `bitnamilegacy/` repositories.
+ - **Solution:** Update all image repository fields in values.yaml:
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/historical-stock-data-collector/SKILL.md b/skills/benchmark_skills/toolathlon/historical-stock-data-collector/SKILL.md
new file mode 100644
index 0000000..e7be348
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/historical-stock-data-collector/SKILL.md
@@ -0,0 +1,46 @@
+---
+name: historical-stock-data-collector
+description: When the user requests historical stock price data for specific tickers over a date range, this skill retrieves daily trading data (open, high, low, close, volume) from financial APIs. It handles multiple tickers simultaneously, excludes non-trading days automatically, and can specify whether to use adjusted or unadjusted prices. Triggers include requests for 'stock data', 'historical prices', 'daily trading data', or specific ticker symbols like AAPL, TSLA, etc.
+---
+# Instructions
+
+## 1. Understand the Request
+- Identify the target tickers (e.g., AAPL, TSLA, NVDA, META).
+- Identify the date range (e.g., June-July 2025).
+- Clarify if the user wants adjusted (`auto_adjust: true`) or unadjusted (`auto_adjust: false`) prices. Default to unadjusted prices unless specified.
+- Identify any specific output format or destination (e.g., Google Sheet, CSV file, Notion page).
+
+## 2. Retrieve Historical Data
+For each identified ticker:
+- Use the `yahoo-finance-get_historical_stock_prices` tool.
+- Set `interval` to `"1d"`.
+- Set `auto_adjust` based on user preference.
+- The API automatically excludes non-trading days.
+
+## 3. Process and Format Data
+- The required output columns are: `Ticker`, `Date`, `Open`, `High`, `Low`, `Close`, `Volume`.
+- The `Date` should be formatted as `YYYY-MM-DD`.
+- Combine data from all tickers into a single list, sorted by Date and then by Ticker.
+- Use the provided `scripts/process_stock_data.py` for reliable, repeatable data transformation.
+
+## 4. Output to Specified Destination
+### If the destination is a Google Sheet:
+1. Create a new spreadsheet or identify an existing one using `google_sheet-create_spreadsheet` or `google_sheet-get_spreadsheet`.
+2. Ensure the target worksheet exists and is correctly named. Use `google_sheet-rename_sheet` if needed.
+3. Write the formatted data to the sheet starting from cell A1. Use `google_sheet-write_to_cells`.
+4. Note the final spreadsheet URL.
+
+### If the destination is a Notion Page:
+1. Locate the target Notion page using `notion-API-post-search`.
+2. Append a new line with the text `Google Sheet : {url}` or the relevant data summary using `notion-API-append-block`.
+3. If requested, add a comment/note at the top of the page using `notion-API-append-block` with the exact specified text.
+
+## 5. Error Handling & Validation
+- If a ticker returns no data for the date range, log a warning and continue with other tickers.
+- Verify the final dataset is not empty before writing to the output destination.
+- If writing to Google Sheets, check the operation was successful.
+
+## Key Principles
+- **Conciseness**: Use scripts for deterministic data processing.
+- **Reliability**: The financial API handles date filtering; do not manually calculate trading days.
+- **Clarity**: Confirm data parameters (like `auto_adjust`) with the user if ambiguous.
diff --git a/skills/benchmark_skills/toolathlon/historical-stock-data-collector/references/example_output_format.md b/skills/benchmark_skills/toolathlon/historical-stock-data-collector/references/example_output_format.md
new file mode 100644
index 0000000..d2772f6
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/historical-stock-data-collector/references/example_output_format.md
@@ -0,0 +1,8 @@
+# Expected Output Format
+
+The final data should be structured as a CSV with the following header and row format, matching the example provided by the user.
+
+## Header
+`Ticker,Date,Open,High,Low,Close,Volume`
+
+## Example Data Rows
diff --git a/skills/benchmark_skills/toolathlon/historical-stock-data-collector/references/tool_usage_guide.md b/skills/benchmark_skills/toolathlon/historical-stock-data-collector/references/tool_usage_guide.md
new file mode 100644
index 0000000..bbec6a6
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/historical-stock-data-collector/references/tool_usage_guide.md
@@ -0,0 +1,15 @@
+# Tool Usage Guide for Historical Stock Data
+
+## Core Tools
+
+### 1. yahoo-finance-get_historical_stock_prices
+Retrieves daily stock price data.
+
+**Parameters:**
+- `ticker` (string, required): The stock symbol (e.g., "AAPL").
+- `start_date` (string, required): Start date in `YYYY-MM-DD` format.
+- `end_date` (string, required): End date in `YYYY-MM-DD` format.
+- `interval` (string, required): Use `"1d"` for daily data.
+- `auto_adjust` (boolean): `false` for original prices (default), `true` for prices adjusted for splits/dividends.
+
+**Example Call:**
diff --git a/skills/benchmark_skills/toolathlon/homework-autograder/SKILL.md b/skills/benchmark_skills/toolathlon/homework-autograder/SKILL.md
new file mode 100644
index 0000000..040aa54
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/homework-autograder/SKILL.md
@@ -0,0 +1,68 @@
+---
+name: homework-autograder
+description: When the user needs to grade programming assignments submitted via email attachments and upload scores to a learning management system (Canvas). This skill handles the complete workflow searching emails for submissions, downloading Python file attachments, executing code to test for errors, comparing outputs against assignment requirements, and submitting grades to Canvas with appropriate feedback. Triggers include keywords like 'grade homework', 'check submissions', 'Canvas grading', 'Python assignment', 'email attachments', and file types like .py files and assignment specifications.
+---
+# Instructions
+
+## 1. Understand the Task
+- The user wants you to grade a specific programming assignment (e.g., "homework2").
+- Submissions are sent via email as Python file attachments.
+- Grades must be posted to a Canvas course.
+- You need to find the latest submission for each student if multiple exist.
+- The core logic is: if the Python file runs without errors and produces correct output, give full points (e.g., 10). If it has any error (syntax, runtime, logic) or produces incorrect output, give 0 points.
+
+## 2. Gather Prerequisites
+**Always start by reading these files:**
+- The assignment specification (e.g., `assignments/homework2.md`). Understand the exact requirements, function signature, and expected output format.
+- The student roster with Canvas IDs (e.g., `student_canvas_ids.csv`). Map student names/emails to their Canvas user IDs.
+
+## 3. Find Submission Emails
+- Search the email inbox for relevant emails using keywords like the assignment name ("homework2"), course code ("CS5123"), or problem name ("two_sum").
+- If initial search is too narrow, broaden it (e.g., search for "homework").
+- Identify all emails that appear to be submissions for the target assignment.
+- **For students with multiple submissions:** Use only the latest one (most recent date). Note the email ID of the latest submission.
+
+## 4. Download and Inspect Attachments
+- Read each identified email to confirm it has a Python attachment.
+- Download all Python file attachments to a local directory (e.g., `homework2_submissions/`).
+- Optionally, read the file contents to get an initial sense of the code quality and potential errors.
+
+## 5. Execute and Grade Each Submission
+For each downloaded Python file:
+1. **Run it in a terminal.** Use `python <filename.py>`.
+2. **Interpret the result:**
+ - **Success (return code 0):** The code executed without syntax or runtime errors. You must still verify the output is correct according to the assignment spec (e.g., indices are in ascending order). Use the `local-python-execute` tool for more precise testing if needed.
+ - **Failure (return code non-zero):** The code has an error. Common errors include:
+ - `SyntaxError` (e.g., missing colon)
+ - `ModuleNotFoundError` (importing non-existent modules)
+ - `IndexError` (list index out of range)
+ - Logic errors that cause wrong output (this requires checking the actual printed results against expected results).
+3. **Assign a score:** 10 for fully correct, 0 for any failure or incorrect output.
+4. **Prepare feedback:** Note the specific error or issue for the Canvas comment.
+
+## 6. Submit Grades to Canvas
+1. Identify the correct Canvas course and assignment ID (use `canvas-canvas_list_courses` and `canvas-canvas_list_assignments`).
+2. For each student, use `canvas-canvas_submit_grade` with:
+ - `course_id`: The target course ID.
+ - `assignment_id`: The target assignment ID.
+ - `user_id`: The student's Canvas user ID (from the roster CSV).
+ - `grade`: "10" or "0".
+ - `comment`: A concise, helpful explanation (e.g., "Code runs correctly and passes all test cases." or "SyntaxError: missing colon on line 6.").
+
+## 7. Provide a Final Summary
+- Present a table showing each student, their Canvas ID, score, and brief reason.
+- Confirm all grades have been submitted.
+
+## Key Considerations
+- **Student Mapping:** Ensure you correctly map the email sender (student name/email) to their Canvas ID from the roster. Names might not match exactly.
+- **Latest Submission Only:** Always check dates and use the most recent email for each student.
+- **Output Validation:** A running script is not enough. The output must match the assignment requirements exactly (e.g., order of indices matters).
+- **Error Types:** Distinguish between syntax/runtime errors (code doesn't run) and logic errors (code runs but gives wrong answer). Both score 0.
+- **Workspace Management:** Create organized directories for downloads to avoid clutter.
+
+## Tools You Will Use
+- `filesystem-read_file`, `filesystem-read_multiple_files`, `filesystem-create_directory`
+- `emails-search_emails`, `emails-get_emails`, `emails-read_email`, `emails-download_attachment`
+- `terminal-run_command`
+- `local-python-execute` (for targeted testing)
+- `canvas-canvas_list_courses`, `canvas-canvas_list_assignments`, `canvas-canvas_submit_grade`
diff --git a/skills/benchmark_skills/toolathlon/homework-autograder/references/canvas_workflow.md b/skills/benchmark_skills/toolathlon/homework-autograder/references/canvas_workflow.md
new file mode 100644
index 0000000..a182b5b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/homework-autograder/references/canvas_workflow.md
@@ -0,0 +1,12 @@
+# Canvas Integration Workflow
+
+This reference outlines the steps and API calls needed to interact with Canvas LMS for grading.
+
+## Prerequisites
+1. **Course ID:** Identify which Canvas course contains the assignment.
+2. **Assignment ID:** Identify the specific assignment to grade.
+3. **Student Canvas IDs:** Map student identities (from email) to their Canvas user IDs.
+
+## Step-by-Step Workflow
+
+### 1. Find the Course
diff --git a/skills/benchmark_skills/toolathlon/homework-autograder/references/error_types.md b/skills/benchmark_skills/toolathlon/homework-autograder/references/error_types.md
new file mode 100644
index 0000000..7e78d6e
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/homework-autograder/references/error_types.md
@@ -0,0 +1,47 @@
+# Common Python Error Types in Student Submissions
+
+When grading programming assignments, you will encounter these common errors. Use this reference to identify and provide accurate feedback.
+
+## 1. Syntax Errors
+The code cannot be parsed by Python.
+- **Missing colon:** `for i in range(10) # missing colon`
+- **Missing parenthesis/bracket:** `print("hello"` or `list = [1, 2, 3`
+- **Incorrect indentation**
+- **Misspelled keywords:** `def` vs `deff`
+
+**Feedback example:** "SyntaxError: missing colon at the end of the for statement on line 6."
+
+## 2. Runtime Errors
+The code parses but fails during execution.
+- **NameError:** Using a variable that hasn't been defined.
+- **TypeError:** Operating on incompatible types (e.g., `"string" + 5`).
+- **IndexError:** Accessing a list index that doesn't exist (e.g., `list[10]` for a 3-item list).
+- **KeyError:** Accessing a dictionary key that doesn't exist.
+- **ModuleNotFoundError:** Importing a module that isn't installed or doesn't exist.
+- **ZeroDivisionError:** Dividing by zero.
+
+**Feedback example:** "IndexError: list index out of range. Your loop goes to len(nums)+1 instead of len(nums)."
+
+## 3. Logic Errors
+The code runs without errors but produces incorrect output.
+- **Wrong algorithm:** Using an incorrect approach to solve the problem.
+- **Off-by-one errors:** Loops running one time too many or too few.
+- **Incorrect output format:** Returning results in wrong order (e.g., `[1, 0]` instead of `[0, 1]`).
+- **Missing edge cases:** Not handling specific inputs mentioned in the assignment.
+
+**Feedback example:** "Logic error: Your solution returns indices in descending order [1, 0], but the requirement specifies ascending order [0, 1]."
+
+## 4. Style/Requirement Violations
+The code works but doesn't follow assignment specifications.
+- **Wrong function name:** Using `two_sum` instead of `twoSum`.
+- **Missing function signature:** Not using the required parameters.
+- **Hard-coded values:** Returning a fixed answer instead of computing it.
+- **External libraries:** Using modules not allowed by the assignment.
+
+**Feedback example:** "Used external module 'non_existent_module' which is not allowed per assignment requirements."
+
+## Grading Decision Tree
+1. Does the code have a SyntaxError? → Score: 0
+2. Does the code have a RuntimeError when executed? → Score: 0
+3. Does the code produce the EXACT expected output for all test cases? → If NO, Score: 0
+4. Only if all above pass → Score: 10 (full points)
diff --git a/skills/benchmark_skills/toolathlon/hr-recruitment-workflow-automator/SKILL.md b/skills/benchmark_skills/toolathlon/hr-recruitment-workflow-automator/SKILL.md
new file mode 100644
index 0000000..ea05667
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/hr-recruitment-workflow-automator/SKILL.md
@@ -0,0 +1,100 @@
+---
+name: hr-recruitment-workflow-automator
+description: Processes job applications by extracting candidate information from resumes (PDF files), updating HR databases (Notion), and managing candidate communications. Automates the end-to-end recruitment workflow including resume parsing, database updates, and automated rejection emails.
+---
+# HR Recruitment Workflow Automator
+
+## Purpose
+Automate the processing of job applications by:
+1. Reading and parsing multiple PDF resumes to extract candidate details
+2. Updating Notion HR databases with candidate information
+3. Comparing applications against open positions based on headcount data
+4. Sending automated rejection emails for closed positions
+5. Managing database entries (create, update, delete)
+
+## Trigger Phrases
+- "update candidate information"
+- "process resumes"
+- "HR record management"
+- "send rejection emails"
+- "PDF resume processing"
+- "Notion database updates"
+- "recruitment workflow automation"
+
+## Core Workflow
+
+### Phase 1: Discovery & Setup
+1. **Locate HR Record Page**
+ - Search Notion for "HR Record" page
+ - Identify the page containing recruitment databases
+
+2. **Find Resume Files**
+ - Scan workspace directories for PDF resumes
+ - Typically found in `/workspace/dumps/workspace/cvs/` or similar paths
+
+3. **Understand Database Structure**
+ - Retrieve schema for "Job Positions" database (contains Position and Head Counts)
+ - Retrieve schema for "Candidates" database (contains Name, Email, Applied Position, Highest Degree, School)
+
+### Phase 2: Data Processing
+1. **Extract Resume Information**
+ - For each PDF resume, extract:
+ - Candidate Name
+ - Email Address
+ - Applied Position
+ - Highest Degree
+ - School/University
+ - Use PDF parsing tools to read text content
+
+2. **Analyze Job Positions**
+ - Query "Job Positions" database to identify:
+ - Positions with Head Counts > 0 (open for recruitment)
+ - Positions with Head Counts = 0 (closed/not hiring)
+
+### Phase 3: Database Operations
+1. **Clean Existing Data**
+ - Delete sample/test entries from Candidates database
+ - Remove any placeholder or incomplete records
+
+2. **Create Candidate Entries**
+ - Create new database entries for all candidates
+ - Add detailed candidate information as page content (due to API limitations)
+
+### Phase 4: Communication Management
+1. **Identify Candidates for Rejection**
+ - Compare each candidate's applied position against open positions
+ - Flag candidates applying for positions with Head Counts = 0
+
+2. **Send Rejection Emails**
+ - Use standardized rejection email template
+ - Send personalized emails to candidates with closed positions
+ - Include proper line breaks and formatting as specified
+
+## Key Considerations
+
+### API Limitations
+- Notion API wrapper may restrict setting database properties beyond "title"
+- Workaround: Add candidate details as page content using block children API
+- Database properties (School, Highest Degree, Applied Position, Email) may remain empty in table view but are accessible in page content
+
+### Data Accuracy
+- Extract information strictly from resume content
+- Do not modify, add, or remove any words from original resumes
+- Ensure email addresses and positions match exactly what's in the PDFs
+
+### Error Prevention
+- Verify position names match exactly between resumes and Job Positions database
+- Double-check email addresses before sending
+- Confirm headcount values before determining position availability
+
+## Required Tools
+- Notion API (search, database queries, page creation, block management)
+- PDF parsing tools
+- Filesystem navigation
+- Email sending capabilities
+
+## Output
+- Updated Notion Candidates database with all applicant information
+- Rejection emails sent to applicable candidates
+- Clean database without sample entries
+- All information filled according to resume content
diff --git a/skills/benchmark_skills/toolathlon/hr-recruitment-workflow-automator/references/email_templates.md b/skills/benchmark_skills/toolathlon/hr-recruitment-workflow-automator/references/email_templates.md
new file mode 100644
index 0000000..4d9b693
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/hr-recruitment-workflow-automator/references/email_templates.md
@@ -0,0 +1,6 @@
+# Email Templates for Recruitment Workflow
+
+## Rejection Email Template
+**Subject:** Application Status Update
+
+**Body:**
diff --git a/skills/benchmark_skills/toolathlon/huggingface-dataset-converter/SKILL.md b/skills/benchmark_skills/toolathlon/huggingface-dataset-converter/SKILL.md
new file mode 100644
index 0000000..cdfb76b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/huggingface-dataset-converter/SKILL.md
@@ -0,0 +1,79 @@
+---
+name: huggingface-dataset-converter
+description: Downloads datasets from Hugging Face and converts them to specific formats (particularly for ML frameworks like Verl). Handles searching, analyzing structure, reading format specs, downloading, transforming schemas, and saving to target formats like Parquet.
+---
+# Instructions
+
+## When to Use This Skill
+Use this skill when the user requests to:
+- Download a dataset from Hugging Face
+- Convert a dataset to Parquet or another specific format
+- Format a dataset for Verl, RLHF, or similar ML frameworks
+- Find and use the "most downloaded" dataset for a given query
+- Process Hugging Face datasets with specific format requirements
+
+## Core Workflow
+
+### 1. Understand the Request
+- Identify the target dataset (by name, query, or "most downloaded" criteria)
+- Clarify the output format requirements (check for format.json or user specifications)
+- Determine the output filename and location
+
+### 2. Search for Datasets (if needed)
+- Use `huggingface-dataset_search` with appropriate query and sort parameters
+- When user mentions "most downloaded," use `sort: "downloads"` and `limit: 10`
+- Present search results to identify the best match
+
+### 3. Read Format Specifications
+- Check for format.json or similar specification files in the workspace
+- Parse the JSON to understand required schema:
+ - `data_source`: string identifier
+ - `prompt`: list of message objects with role/content
+ - `ability`: category string
+ - `reward_model`: dict with style and ground_truth
+ - `extra_info`: dict with additional fields
+
+### 4. Get Dataset Details
+- Use `huggingface-hub_repo_details` to examine dataset structure
+- Note column names, data types, and sample content
+- Verify the dataset contains required source fields
+
+### 5. Download and Convert
+- Use the bundled Python script `convert_dataset.py` for reliable conversion
+- The script handles:
+ - Loading dataset via Hugging Face datasets library
+ - Mapping source columns to target format
+ - Preserving all required schema elements
+ - Saving to Parquet format with proper typing
+
+### 6. Verify Output
+- Check file creation and size
+- Validate schema matches requirements
+- Sample first few rows to confirm proper formatting
+- Report completion with statistics
+
+## Key Considerations
+
+### Data Mapping
+- Map `problem` → `prompt[0].content`
+- Map `answer` → `reward_model.ground_truth`
+- Map `solution` → `extra_info.solution`
+- Add sequential `index` to `extra_info`
+- Set constant fields (`data_source`, `ability`) as specified
+
+### Error Handling
+- If dataset doesn't contain required columns, inform user
+- If format.json is missing or malformed, ask for clarification
+- If download fails, check network connectivity and dataset accessibility
+
+### Performance
+- For large datasets, process in batches
+- Use efficient data structures (pandas DataFrames)
+- Compress output with Parquet for storage efficiency
+
+## Common Triggers
+- "download dataset from Hugging Face"
+- "convert dataset to parquet"
+- "format dataset for Verl/RLHF"
+- "most downloaded dataset"
+- "Hugging Face dataset with specific format"
diff --git a/skills/benchmark_skills/toolathlon/huggingface-dataset-converter/references/format_specification.md b/skills/benchmark_skills/toolathlon/huggingface-dataset-converter/references/format_specification.md
new file mode 100644
index 0000000..15673cb
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/huggingface-dataset-converter/references/format_specification.md
@@ -0,0 +1,6 @@
+# Format Specification Reference
+
+## Overview
+This document describes the expected format for dataset conversion, particularly for Verl framework compatibility.
+
+## Base Schema
diff --git a/skills/benchmark_skills/toolathlon/huggingface-dataset-converter/references/workflow_examples.md b/skills/benchmark_skills/toolathlon/huggingface-dataset-converter/references/workflow_examples.md
new file mode 100644
index 0000000..4a9936d
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/huggingface-dataset-converter/references/workflow_examples.md
@@ -0,0 +1,13 @@
+# Workflow Examples
+
+## Example 1: DeepScaleR for Verl Framework
+
+### User Request
+"I need to download the most downloaded DeepScaleR dataset and convert it to verl format as verl_deepscaler.parquet"
+
+### Agent Workflow
+1. **Search**: Use `huggingface-dataset_search` with query="DeepScaleR", sort="downloads"
+2. **Identify**: Select top result "agentica-org/DeepScaleR-Preview-Dataset"
+3. **Read Format**: Load `/workspace/dumps/workspace/format.json`
+4. **Convert**: Run conversion script with:
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/huggingface-model-publisher/SKILL.md b/skills/benchmark_skills/toolathlon/huggingface-model-publisher/SKILL.md
new file mode 100644
index 0000000..5657e5d
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/huggingface-model-publisher/SKILL.md
@@ -0,0 +1,71 @@
+---
+name: huggingface-model-publisher
+description: When the user wants to publish a trained model to Hugging Face Hub with proper documentation and metadata. This skill handles authentication with Hugging Face using API tokens, creates or updates model repositories, uploads model files (config, weights, tokenizers), generates comprehensive README.md files with benchmark results, and ensures all necessary files are properly structured for the Hugging Face ecosystem. It's triggered when users mention 'push to Hugging Face', 'upload model to HF Hub', or need to share models with proper documentation.
+---
+# Instructions
+
+## Overview
+This skill publishes a trained model checkpoint to Hugging Face Hub. It identifies the best model based on evaluation metrics, prepares the model folder with necessary documentation, and uploads everything to a specified repository.
+
+## Prerequisites
+1. **Hugging Face Token**: A valid Hugging Face API token must be available, typically in a file like `hf_token.txt` in the workspace.
+2. **Model Checkpoints**: Trained model checkpoints organized in directories (e.g., `checkpoints/step_100`, `checkpoints/step_200`).
+3. **Evaluation System**: Benchmark evaluation scripts that can calculate scores for different model checkpoints.
+
+## Step-by-Step Process
+
+### 1. Scan Workspace and Identify Best Model
+- List all available model checkpoints in the workspace.
+- For each checkpoint, run evaluation across all benchmark categories.
+- Calculate an overall `eval_accuracy` score (typically the average of all benchmark scores).
+- Select the checkpoint with the highest `eval_accuracy`.
+
+**Key Decision Points:**
+- The evaluation logic may be implemented in compiled Cython modules. If they cannot be imported directly, you may need to reimplement the scoring formulas based on available source code or documentation.
+- Benchmark categories typically include: math_reasoning, logical_reasoning, common_sense, reading_comprehension, question_answering, text_classification, sentiment_analysis, code_generation, creative_writing, dialogue_generation, summarization, translation, knowledge_retrieval, instruction_following, safety_evaluation.
+
+### 2. Prepare Model Folder
+- Copy the selected checkpoint folder to a temporary location if needed.
+- Ensure the folder contains at minimum:
+ - `config.json`: Model configuration
+ - `pytorch_model.bin`: Model weights
+ - Any tokenizer files if applicable
+- Add a comprehensive `README.md` file with:
+ - Model metadata (license, library_name)
+ - Introduction and model description
+ - **Complete benchmark results table** with scores for all evaluated categories (keep three decimal places)
+ - Usage instructions, system prompts, temperature recommendations
+ - License information
+ - Contact details
+- Include any asset files (e.g., figures referenced in the README).
+
+### 3. Authenticate with Hugging Face Hub
+- Read the Hugging Face API token from the workspace.
+- Use `huggingface_hub.login()` or equivalent to authenticate.
+- Verify authentication by checking `api.whoami()`.
+
+### 4. Create/Update Repository
+- Determine the target repository name (usually specified by user or derived from model name).
+- Create the repository using `create_repo()` with `exist_ok=True` to handle existing repositories.
+- The repository should be of type `"model"`.
+
+### 5. Upload Model Files
+- Upload the entire prepared model folder using `api.upload_folder()`.
+- Ensure all files are uploaded: README.md, config.json, pytorch_model.bin, tokenizer files, and assets.
+- Verify the upload by listing repository files.
+
+### 6. Final Verification
+- Download the README.md from the repository to confirm benchmark scores were correctly uploaded.
+- Check that all necessary files are present in the repository.
+- Provide the user with the model URL: `https://huggingface.co/<username>/<repo_name>`
+
+## Error Handling
+- **Missing Token**: If `hf_token.txt` is not found, ask the user to provide it or check the workspace.
+- **Invalid Checkpoints**: If no valid checkpoints are found, inform the user and suggest checking the workspace structure.
+- **Upload Failures**: If upload fails, check network connectivity, token permissions, and repository visibility settings.
+- **Benchmark Evaluation Failures**: If evaluation scripts fail, consider implementing fallback scoring based on available formulas.
+
+## Notes
+- The skill should preserve all original README.md content except for updating the benchmark scores table.
+- Always keep benchmark scores to three decimal places for consistency.
+- The model should be properly tagged with appropriate metadata (license, library_name, etc.) in the README frontmatter.
diff --git a/skills/benchmark_skills/toolathlon/interview-scheduler/SKILL.md b/skills/benchmark_skills/toolathlon/interview-scheduler/SKILL.md
new file mode 100644
index 0000000..d2af308
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/interview-scheduler/SKILL.md
@@ -0,0 +1,51 @@
+---
+name: interview-scheduler
+description: When the user needs to schedule interviews or meetings with specific time constraints (e.g., within certain dates, during working hours, with minimum duration requirements). This skill calculates available time slots based on date ranges, working hour constraints, and duration needs, then creates calendar events with appropriate details. Triggers include phrases like 'schedule interviews', 'book time slots', 'within [date range]', 'during working hours', or 'reserve [duration] for meeting'.
+---
+# Skill: Interview Scheduler
+
+## Objective
+Schedule candidate interviews by identifying qualified applicants from email resumes and booking time slots that meet all specified constraints.
+
+## Core Workflow
+
+### Phase 1: Candidate Identification & Qualification
+1. **Search for Resumes:** Use the `emails-search_emails` tool with a query like "resume" or "application" to find relevant emails.
+2. **Extract & Review:** Read each candidate's email (`emails-read_email`) to parse their resume content.
+3. **Apply Qualification Filter:** The primary filter is **independent first-author publications**. Look for phrases like "First Author", "Sole Author", or "Lead Author" in the publications section. Candidates without such publications are disqualified.
+4. **Extract Candidate Info:** For qualified candidates, note:
+ * Name
+ * Email
+ * Key publications (for calendar description)
+ * Research area/university (for context)
+
+### Phase 2: Time Slot Calculation & Scheduling
+1. **Parse Time Constraints:** Extract from the user request:
+ * **Date Range:** Identify "tomorrow", "the day after tomorrow", or other explicit date windows. Use the system's current date or the latest email date as a reference if needed.
+ * **Working Hours:** Default is 8 AM to 5 PM in the user's/local timezone (e.g., `Asia/Hong_Kong`). Confirm or adjust per request.
+ * **Minimum Duration:** Default is 1.5 hours. Confirm per request.
+2. **Generate Slots:** Mentally allocate sequential slots within the date range and working hours, ensuring the minimum duration and a reasonable buffer (e.g., 30 mins) between interviews if scheduling multiple candidates on the same day.
+3. **Create Calendar Events:** For each qualified candidate, use `google_calendar-create_event`.
+ * **Summary:** Format as `"Interview with [Candidate Name]"`
+ * **Description:** Include a brief candidate summary: university, research area, key qualifying publication(s), and contact info (email/phone from resume).
+ * **Start/End Time:** Use the calculated slot in ISO 8601 format with the correct timezone.
+ * **Duration:** Must meet or exceed the user's minimum requirement.
+
+### Phase 3: Summary & Confirmation
+1. **Present Results:** Provide a clear summary table showing:
+ * Qualified candidates and their key publication.
+ * Scheduled date, time slot, and duration.
+ * Disqualified candidates and the reason (e.g., "No first-author publications").
+2. **Confirm Sync:** State that events have been created in Google Calendar.
+3. **Mark Task Complete:** Use `local-claim_done`.
+
+## Key Decision Logic
+* **Slot Allocation:** Schedule on the earliest available date within the range. If the first day fills up, use the next day.
+* **Buffer Time:** It is good practice to leave at least 30 minutes between interviews for preparation/notes, but this is not a strict rule if the user does not specify it.
+* **Date Reference:** If the user says "tomorrow," use the date context from the most recent email in the thread or the current system date to calculate the actual dates.
+
+## Tools Required
+* `emails-search_emails`
+* `emails-read_email`
+* `google_calendar-create_event`
+* `local-claim_done`
diff --git a/skills/benchmark_skills/toolathlon/interview-scheduler/references/publication_keywords.md b/skills/benchmark_skills/toolathlon/interview-scheduler/references/publication_keywords.md
new file mode 100644
index 0000000..e342839
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/interview-scheduler/references/publication_keywords.md
@@ -0,0 +1,24 @@
+# Keywords for Identifying Author Roles
+
+Use these keywords to parse publication sections in resumes and determine qualification.
+
+## Qualifying Roles (Independent First-Author)
+Candidates mentioning these phrases in relation to a publication **QUALIFY** for an interview.
+* **First Author**
+* **Lead Author**
+* **Sole Author** (strongest indicator)
+* **Primary Author**
+* **Corresponding Author** (if also listed as first author)
+
+## Non-Qualifying Roles
+Candidates with **ONLY** these roles do **NOT** qualify.
+* Second Author
+* Third Author
+* Fourth Author, etc.
+* Co-author (without "first" or "lead" prefix)
+* Contributor
+
+## Parsing Guidance
+* Look for bullet points or lists under headings like "Publications", "Research Results", or "Academic Contributions".
+* The role is typically stated **before** the paper title (e.g., "**First Author**: 'Paper Title', Conference Year").
+* If multiple publications are listed, the candidate qualifies if **any one** publication has a qualifying role.
diff --git a/skills/benchmark_skills/toolathlon/inventory-monitoring-and-alert-system/SKILL.md b/skills/benchmark_skills/toolathlon/inventory-monitoring-and-alert-system/SKILL.md
new file mode 100644
index 0000000..3150612
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/inventory-monitoring-and-alert-system/SKILL.md
@@ -0,0 +1,51 @@
+---
+name: inventory-monitoring-and-alert-system
+description: When the user needs to monitor product inventory levels, check stock quantities against safety thresholds, identify low-stock items, and trigger automated notifications and documentation updates. This skill is triggered by keywords like 'inventory levels', 'stock quantity', 'safety threshold', 'low-stock', 'purchase requisition', 'stock alert', or when working with e-commerce platforms like WooCommerce. It provides capabilities to 1) Retrieve product data from e-commerce systems, 2) Analyze stock levels against configurable thresholds, 3) Identify products requiring replenishment, 4) Update Google Sheets or other documentation systems with low-stock items, and 5) Send automated email notifications to purchasing managers using customizable templates.
+---
+# Inventory Monitoring and Alert System
+
+## Overview
+This skill automates inventory monitoring by checking product stock levels against safety thresholds, updating purchase requisition lists, and sending email alerts.
+
+## Core Workflow
+
+### 1. Initial Setup & Data Collection
+- **Retrieve Products**: Fetch all products from WooCommerce using `woocommerce-woo_products_list`.
+- **Locate Resources**:
+ - Find the Google Sheets purchase requisition list using `google_sheet-list_spreadsheets`.
+ - Read the purchasing manager's email address from `purchasing_manager_email.txt`.
+ - Load the email template from `stock_alert_email_template.md`.
+
+### 2. Inventory Analysis
+- For each product, compare `stock_quantity` against `stock_threshold` (stored in `meta_data`).
+- Identify all products where `stock_quantity < stock_threshold`.
+- Extract supplier information from product meta_data (name, contact, ID).
+
+### 3. Documentation Update
+- Access the Google Sheet using the spreadsheet ID.
+- Check existing sheet structure using `google_sheet-get_sheet_data`.
+- Update cells with low-stock product information:
+ - Product ID, Name, SKU
+ - Current Stock, Safety Threshold
+ - Supplier Name, Supplier ID, Supplier Contact
+ - Alert Time (current date), Suggested Order Quantity (threshold × 1.5)
+
+### 4. Notification Delivery
+- For each low-stock product, generate personalized email using the template.
+- Send email to purchasing manager with:
+ - Product-specific details
+ - Stock vs. threshold comparison
+ - Supplier contact information
+ - Link to Google Sheets requisition list
+
+## Key Considerations
+- **Pagination**: Handle large product lists by adjusting `perPage` parameter.
+- **Error Handling**: Verify all required files exist before processing.
+- **Data Consistency**: Ensure Google Sheets formatting matches expected columns.
+- **Email Personalization**: Customize each email with specific product details.
+
+## Success Criteria
+- All low-stock products identified and documented
+- Google Sheets updated with complete product information
+- Individual email alerts sent for each low-stock item
+- Clear summary provided to user with counts and details
diff --git a/skills/benchmark_skills/toolathlon/inventory-monitoring-and-alert-system/references/email_template.md b/skills/benchmark_skills/toolathlon/inventory-monitoring-and-alert-system/references/email_template.md
new file mode 100644
index 0000000..66b2c4f
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/inventory-monitoring-and-alert-system/references/email_template.md
@@ -0,0 +1,26 @@
+# Stock Alert Email Template
+
+## Email Subject
+[Stock Alert] {product_name} Stock Below Safety Threshold
+
+## Email Body
+
+Dear Purchasing Manager,
+
+The system has detected that the following product's stock level is below the safety threshold. Please take immediate action:
+
+## Product Information
+- **Product Name**: {product_name}
+- **SKU**: {sku}
+- **Current Stock**: {current_stock}
+- **Safety Threshold**: {threshold}
+- **Supplier**: {supplier_name}
+- **Supplier Contact**: {supplier_contact}
+
+## Action Required
+Please review the stock levels and consider placing a purchase order to replenish inventory.
+
+For detailed information and to update the purchase requisition list, please visit the Google Sheets link: {google_sheets_link}
+
+Best regards,
+Stock Alert System
diff --git a/skills/benchmark_skills/toolathlon/inventory-monitoring-and-alert-system/references/google_sheets_schema.md b/skills/benchmark_skills/toolathlon/inventory-monitoring-and-alert-system/references/google_sheets_schema.md
new file mode 100644
index 0000000..6a49b48
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/inventory-monitoring-and-alert-system/references/google_sheets_schema.md
@@ -0,0 +1,23 @@
+# Google Sheets Purchase Requisition Schema
+
+## Required Columns
+The Google Sheet should have the following column structure:
+
+| Column | Description | Data Type | Example |
+|--------|-------------|-----------|---------|
+| A | Product ID | String/Number | "9" |
+| B | Product Name | String | "Laptop Dell XPS 13" |
+| C | SKU | String | "DELL-XPS-13" |
+| D | Current Stock | Number | 5 |
+| E | Safety Threshold | String/Number | "10" |
+| F | Supplier Name | String | "Dell China" |
+| G | Supplier ID | String | "SUP001" |
+| H | Supplier Contact | String | "[email protected]" |
+| I | Alert Time | Date/Time | "2025-11-26" |
+| J | Suggested Order Quantity | String/Number | "15" |
+
+## Notes
+- Row 1 should contain header labels
+- Date format: YYYY-MM-DD
+- Suggested Order Quantity calculation: `(threshold - current_stock) × 1.5` (rounded up)
+- The sheet name should match the spreadsheet title (e.g., "stock_sheet")
diff --git a/skills/benchmark_skills/toolathlon/inventory-monitoring-and-alert-system/references/woocommerce_data_structure.md b/skills/benchmark_skills/toolathlon/inventory-monitoring-and-alert-system/references/woocommerce_data_structure.md
new file mode 100644
index 0000000..65f3353
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/inventory-monitoring-and-alert-system/references/woocommerce_data_structure.md
@@ -0,0 +1,22 @@
+# WooCommerce Product Data Structure
+
+## Key Fields for Inventory Monitoring
+
+### Product Object Fields
+- `id`: Product ID (integer)
+- `name`: Product name (string)
+- `sku`: Stock Keeping Unit (string)
+- `manage_stock`: Boolean indicating if stock is managed
+- `stock_quantity`: Current stock level (integer, nullable)
+- `stock_status`: Current status ("instock", "outofstock", etc.)
+
+### Meta Data Fields (in `meta_data` array)
+- `stock_threshold`: Safety threshold value (string, stored in meta)
+- `supplier`: Supplier information object containing:
+ - `name`: Supplier name
+ - `contact`: Supplier email/contact
+ - `supplier_id`: Supplier identifier
+- `category`: Product category (optional)
+
+## Accessing Meta Data
+Threshold and supplier data are stored in the `meta_data` array. Example access pattern:
diff --git a/skills/benchmark_skills/toolathlon/invoice-processor-reimbursement-calculator/SKILL.md b/skills/benchmark_skills/toolathlon/invoice-processor-reimbursement-calculator/SKILL.md
new file mode 100644
index 0000000..e55b5b8
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/invoice-processor-reimbursement-calculator/SKILL.md
@@ -0,0 +1,36 @@
+---
+name: invoice-processor-reimbursement-calculator
+description: Scans a workspace for invoice PDFs, extracts vendor, date, amount, and currency, fetches historical exchange rates, converts all amounts to a target currency (default CNY), calculates totals including tax, and outputs a CSV summary and a JSON grand total.
+---
+# Instructions
+
+## 1. Scan Workspace & Identify Invoices
+- Use `filesystem-directory_tree` to list all files in the user's personal workspace (typically `/workspace` or user-specified).
+- Filter the list to identify potential invoice files. Prioritize files with extensions `.pdf` and names containing keywords like `invoice`, `receipt`, `flight`, or `itinerary`. Ignore temporary directories (e.g., `.pdf_tools_tempfiles`).
+
+## 2. Extract Data from Invoice PDFs
+- For each identified PDF invoice file:
+ - Use `pdf-tools-read_pdf_pages` to extract text from the first few pages (typically pages 1-5).
+ - Analyze the extracted text to find the following key fields:
+ - **Vendor**: Look for company names, "Bill To", "Seller", or "Issuing Airline".
+ - **Date**: Look for "Date", "Date of issue", "Billed On", "Transaction date". Parse into YYYY-MM-DD format.
+ - **Original Amount & Currency**:
+ - Identify the total amount. Look for patterns like `$XX.XX USD`, `CNY XXX.XX`, `SGD XXX.XX`, "Total:", "Amount due:", or "FARE:" + "TAX:".
+ - **Crucially, include any tax amounts.** If separate fare and tax lines are found (common in flight itineraries), sum them to get the total original amount.
+ - Record the currency code (USD, CNY, SGD, etc.).
+ - **Filename**: Record the source filename.
+
+## 3. Handle Currency Conversion
+- For each invoice **not** already in the target currency (Chinese Yuan, CNY):
+ - Use `yahoo-finance-get_stock_price_by_date` to fetch the historical exchange rate.
+ - **Ticker Format**: Use `USDCNY=X` for USD to CNY, `SGDCNY=X` for SGD to CNY, etc.
+ - **Date**: Use the invoice date from Step 2. Set `find_nearest: true` to handle non-trading days.
+ - Use the `close` price from the returned data as the exchange rate.
+- For invoices already in CNY, set the exchange rate to `1.0000`.
+- Calculate `amount_in_cny = original_amount * exchange_rate`.
+
+## 4. Generate the Summary CSV File
+- Check if a file named `invoice_summary.csv` already exists in the workspace to understand its format.
+- Create/overwrite `invoice_summary.csv` in the user's workspace.
+- Use `filesystem-write_file` to write the data with the following header and one row per invoice:
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/invoice-processor-reimbursement-calculator/references/currency_codes.md b/skills/benchmark_skills/toolathlon/invoice-processor-reimbursement-calculator/references/currency_codes.md
new file mode 100644
index 0000000..c1af5a8
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/invoice-processor-reimbursement-calculator/references/currency_codes.md
@@ -0,0 +1,20 @@
+# Currency Codes & Yahoo Finance Tickers
+
+## Target Currency
+- **Chinese Yuan (Renminbi)**: `CNY`
+
+## Common Source Currencies & Tickers
+Use these Yahoo Finance tickers to fetch historical exchange rates for converting to CNY:
+
+| Currency | Yahoo Finance Ticker | Notes |
+|----------|----------------------|-------|
+| US Dollar | `USDCNY=X` | Most common |
+| Singapore Dollar | `SGDCNY=X` | |
+| Euro | `EURCNY=X` | |
+| British Pound | `GBPCNY=X` | |
+| Japanese Yen | `JPYCNY=X` | |
+| Hong Kong Dollar | `HKDCNY=X` | |
+| Australian Dollar | `AUDCNY=X` | |
+| Canadian Dollar | `CADCNY=X` | |
+
+## Usage with `yahoo-finance-get_stock_price_by_date`
diff --git a/skills/benchmark_skills/toolathlon/invoice-processor-reimbursement-calculator/references/invoice_formats.md b/skills/benchmark_skills/toolathlon/invoice-processor-reimbursement-calculator/references/invoice_formats.md
new file mode 100644
index 0000000..e464b33
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/invoice-processor-reimbursement-calculator/references/invoice_formats.md
@@ -0,0 +1,10 @@
+# Common Invoice Formats & Extraction Patterns
+
+## 1. Software/Service Invoices (e.g., Excalidraw, Overleaf)
+**Key Sections:**
+- **Vendor**: Company name at top or in footer
+- **Date**: "Date of issue", "Billed On", "Transaction date"
+- **Amount**: "Total", "Amount due" followed by `$XX.XX USD`
+- **Tax**: Often included in the total amount
+
+**Example Text Pattern:**
diff --git a/skills/benchmark_skills/toolathlon/invoice-receipt-processor/SKILL.md b/skills/benchmark_skills/toolathlon/invoice-receipt-processor/SKILL.md
new file mode 100644
index 0000000..46c3051
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/invoice-receipt-processor/SKILL.md
@@ -0,0 +1,52 @@
+---
+name: invoice-receipt-processor
+description: When the user needs to process invoice receipts from PDF files in a workspace and update a purchase invoice database with payment tracking. This skill automatically scans workspace directories for PDF receipts, extracts invoice data (invoice ID, supplier, amount, purchaser email, date, payment status), inserts records into database tables, sets up payment tracking with outstanding flags, identifies unpaid or partially paid invoices, and sends email notifications to relevant purchasing managers with specific filenames requiring attention. Key triggers include processing receipts, updating invoice databases, tracking outstanding payments, sending payment reminder emails, and handling PDF invoice files with payment status indicators.
+---
+# Instructions
+
+## 1. Initialize and Explore
+- **Explore Workspace:** List the contents of the `/workspace/dumps/workspace` directory to locate the `files` folder containing PDF receipts.
+- **Explore Database:** List schemas in the `PURCHASE_INVOICE` database, then list tables in the `PUBLIC` schema.
+- **Examine Tables:** Describe the structure of the `INVOICES` and `INVOICE_PAYMENTS` tables. Read sample data to understand existing records and column formats.
+
+## 2. Extract Data from PDF Receipts
+- **Scan Files:** List all PDF files in the workspace's `files` directory.
+- **Read PDFs:** For each PDF file, extract text from the first page. Parse the following key fields:
+ - **Invoice ID:** Look for patterns like "Invoice:", "Invoice ID:", "Document ID:", or text near the filename.
+ - **Supplier Name:** Typically under "Supplier:", "Vendor:", or "VENDOR INFORMATION:".
+ - **Invoice Amount:** Look for "Amount:", "Total Amount:", or "Total:" followed by a dollar amount.
+ - **Purchaser Email:** Look for "Contact:", "Bill To:", or "DEPARTMENT INFORMATION:" followed by an email address.
+ - **Invoice Date:** Look for "Date:", "Processing Date:", or "Invoice Date:".
+ - **Payment Status:** Identify status keywords:
+ - `PAID` or checkmark (✓): Fully paid.
+ - `PARTIAL` or square (■): Partially paid. Extract the paid amount if available.
+ - `UNPAID`, `Awaiting payment`, `Pending`, `Verification in process`: Outstanding (unpaid).
+ - Default to outstanding if status is unclear.
+
+## 3. Update Database Tables
+- **Insert Invoices:** For each extracted receipt, insert a record into `PURCHASE_INVOICE.PUBLIC.INVOICES` with columns: `INVOICE_ID`, `SUPPLIER_NAME`, `INVOICE_AMOUNT`, `PURCHASER_EMAIL`, `INVOICE_DATE`.
+- **Insert Payments:** For each invoice, insert a corresponding record into `PURCHASE_INVOICE.PUBLIC.INVOICE_PAYMENTS`:
+ - `INVOICE_ID`: The extracted invoice ID.
+ - `PAYMENT_AMOUNT`:
+ - If status is `PAID`: Set to the full invoice amount.
+ - If status is `PARTIAL`: Set to the extracted paid amount.
+ - Otherwise: Set to `0`.
+ - `OUTSTANDING_FLAG`:
+ - `0` if status is `PAID`.
+ - `1` for all other statuses (`PARTIAL`, `UNPAID`, `Awaiting`, `Pending`, `Verification`).
+- **Set Column Description:** Execute an `ALTER TABLE` statement to set the comment/description for the `OUTSTANDING_FLAG` column in `INVOICE_PAYMENTS` to exactly: `0=Paid, 1=Outstanding`. Verify the description was applied.
+
+## 4. Identify and Notify on Outstanding Invoices
+- **Query Outstanding Invoices:** Perform a `JOIN` between `INVOICES` and `INVOICE_PAYMENTS` where `OUTSTANDING_FLAG = 1`. Group results by `PURCHASER_EMAIL`.
+- **Map to Filenames:** For each outstanding invoice, map the `INVOICE_ID` back to the original PDF filename (e.g., `INV-2024-013` → `INV-2024-013.pdf`).
+- **Send Emails:** For each unique purchasing manager email (`PURCHASER_EMAIL`):
+ - **Subject:** `Process Outstanding Invoices`
+ - **Body:** List the filenames of all outstanding invoices for that manager. Use a clear, professional format.
+ - Send the email.
+
+## 5. Final Verification and Summary
+- Provide a concise summary report including:
+ - Count of receipts processed and inserted.
+ - Count of outstanding vs. paid invoices.
+ - List of managers notified and the number of files each needs to process.
+ - Confirmation that the column description was set.
diff --git a/skills/benchmark_skills/toolathlon/invoice-receipt-processor/references/database_schema.md b/skills/benchmark_skills/toolathlon/invoice-receipt-processor/references/database_schema.md
new file mode 100644
index 0000000..6c2ba7a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/invoice-receipt-processor/references/database_schema.md
@@ -0,0 +1,25 @@
+# PURCHASE_INVOICE Database Schema
+
+## Table: INVOICES
+Stores basic invoice information extracted from receipts.
+
+| Column Name | Data Type | Nullable | Description |
+|-------------|-----------|----------|-------------|
+| INVOICE_ID | TEXT | NO | Unique invoice identifier (from PDF) |
+| SUPPLIER_NAME | TEXT | NO | Name of the supplier/vendor |
+| INVOICE_AMOUNT | NUMBER | NO | Total invoice amount in dollars |
+| PURCHASER_EMAIL | TEXT | NO | Email of the purchasing manager |
+| INVOICE_DATE | DATE | YES | Date of the invoice |
+
+## Table: INVOICE_PAYMENTS
+Tracks payment status and amounts.
+
+| Column Name | Data Type | Nullable | Default | Description |
+|-------------|-----------|----------|---------|-------------|
+| INVOICE_ID | TEXT | NO | - | Foreign key to INVOICES table |
+| PAYMENT_AMOUNT | NUMBER | YES | 0 | Amount paid to date |
+| OUTSTANDING_FLAG | NUMBER | YES | 1 | **0=Paid, 1=Outstanding** |
+
+## Key Relationships
+- `INVOICE_PAYMENTS.INVOICE_ID` → `INVOICES.INVOICE_ID`
+- Each invoice should have exactly one payment record
diff --git a/skills/benchmark_skills/toolathlon/invoice-receipt-processor/references/email_template.md b/skills/benchmark_skills/toolathlon/invoice-receipt-processor/references/email_template.md
new file mode 100644
index 0000000..468ee40
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/invoice-receipt-processor/references/email_template.md
@@ -0,0 +1,6 @@
+# Email Template for Outstanding Invoices
+
+## Subject
+`Process Outstanding Invoices`
+
+## Body Template
diff --git a/skills/benchmark_skills/toolathlon/invoice-receipt-processor/references/pdf_patterns.md b/skills/benchmark_skills/toolathlon/invoice-receipt-processor/references/pdf_patterns.md
new file mode 100644
index 0000000..944be19
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/invoice-receipt-processor/references/pdf_patterns.md
@@ -0,0 +1,50 @@
+# Common PDF Patterns for Invoice Extraction
+
+## Invoice ID Patterns
+- `Invoice: 2024-1771`
+- `Invoice ID: BL-2024-338`
+- `Document ID: 2024-4853`
+- `Invoice ID: INV-2024-007`
+- `Invoice: PO69638-24`
+
+## Supplier/Vendor Patterns
+- `Supplier:\n[Suzhou Manufacturing Solutions Inc.]`
+- `Vendor:\n[Beijing Office Supplies Vendor]`
+- `VENDOR INFORMATION:\n[Shanghai Technology Equipment Co., Ltd.]`
+
+## Amount Patterns
+- `Amount: $58678.11`
+- `Total Amount: $13857.73`
+- `Total: $106183.48`
+
+## Purchaser Email Patterns
+- `Contact: [email protected]`
+- `Bill To:\nPurchasing Department\nContact: [email protected]`
+- `DEPARTMENT INFORMATION:\nPurchasing Department\nContact: [email protected]`
+- `Bill To:\nPurchasing Dept\[email protected]`
+
+## Date Patterns
+- `Date: 2024-02-25`
+- `Processing Date: 2024-10-03`
+- `Invoice Date: 2024-07-02`
+
+## Payment Status Indicators
+
+### Paid (OUTSTANDING_FLAG = 0)
+- `PAYMENT STATUS: ✓ PAID ($13857.73)`
+- `PAYMENT STATUS: ✓ PAID`
+- `PAID ($1482003.12)`
+- Checkmark symbol (✓) followed by "PAID"
+
+### Partial (OUTSTANDING_FLAG = 1)
+- `PAYMENT STATUS: ■ PARTIAL ($41064.28 of $108909.36)`
+- `Remaining Balance: $67845.08`
+- Square symbol (■) followed by "PARTIAL"
+
+### Unpaid/Outstanding (OUTSTANDING_FLAG = 1)
+- `PAYMENT STATUS: ✗ UNPAID`
+- `Awaiting payment authorization`
+- `Pending payment approval`
+- `Payment verification in process`
+- `Verification in process`
+- Cross symbol (✗) followed by "UNPAID"
diff --git a/skills/benchmark_skills/toolathlon/iot-sensor-anomaly-detector/SKILL.md b/skills/benchmark_skills/toolathlon/iot-sensor-anomaly-detector/SKILL.md
new file mode 100644
index 0000000..ef66fb8
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/iot-sensor-anomaly-detector/SKILL.md
@@ -0,0 +1,45 @@
+---
+name: iot-sensor-anomaly-detector
+description: When the user needs to identify abnormal sensor readings by comparing real-time IoT sensor data against predefined operating parameter ranges. This skill queries time-series sensor data from BigQuery, loads parameter ranges from Excel configuration files, performs range validation, and generates anomaly reports in CSV format with timestamp, machine_id, sensor_type, reading, and normal_range fields. Triggers include IoT sensor data analysis, anomaly detection, operating parameter validation, factory monitoring, BigQuery sensor queries, Excel configuration file processing, and CSV report generation.
+---
+# Instructions
+
+## Overview
+This skill identifies sensor readings that fall outside predefined normal operating ranges. It queries time-series sensor data from BigQuery, compares readings against parameter ranges defined in an Excel configuration file, and generates a CSV anomaly report.
+
+## Core Workflow
+
+### 1. Initial Setup & Discovery
+- **Locate the Excel configuration file**: Search for `machine_operating_parameters.xlsx` in the workspace.
+- **Verify BigQuery dataset**: Confirm the `machine_operating` dataset exists.
+- **Identify Cloud Storage bucket**: Find the bucket with prefix `iot_anomaly_reports` for report upload.
+
+### 2. Data Acquisition
+- **Read parameter ranges**: Load the "Operating Parameters" sheet from the Excel file. Extract `machine_id`, `sensor_type`, `min_value`, and `max_value` columns.
+- **Query sensor data**: Execute a BigQuery query to retrieve sensor readings (`timestamp`, `machine_id`, `sensor_type`, `reading`) for the specified time range.
+
+### 3. Data Processing & Anomaly Detection
+- **Merge datasets**: Join sensor data with parameter ranges using `machine_id` and `sensor_type` as keys.
+- **Identify anomalies**: Flag readings where `reading < min_value` OR `reading > max_value`.
+- **Format output**: Create `normal_range` column as "min - max" string.
+
+### 4. Report Generation & Delivery
+- **Create CSV report**: Generate `anomaly_report.csv` with columns: `timestamp`, `machine_id`, `sensor_type`, `reading`, `normal_range`.
+- **Save locally**: Store the report in the workspace.
+- **Upload to Cloud Storage**: Transfer the report to the identified `iot_anomaly_reports` bucket.
+
+### 5. Cleanup
+- Remove any temporary files or tables created during processing.
+
+## Key Requirements
+- **Timestamp format**: Preserve the exact timestamp format from BigQuery (e.g., `2025-08-19 11:33:59.878906+00`).
+- **Error handling**: Gracefully handle missing sheets in Excel, unmatched sensor-parameter pairs, and data type mismatches.
+- **Efficiency**: Process potentially large datasets efficiently using appropriate data structures.
+
+## Common Variations
+- **Different time ranges**: The skill should adapt to user-specified start/end times.
+- **Alternative file locations**: The Excel file may be in different directories.
+- **Multiple sensor types**: The skill handles various sensor types defined in the configuration.
+
+## Output
+The primary output is `anomaly_report.csv` containing all readings outside normal ranges, sorted by timestamp.
diff --git a/skills/benchmark_skills/toolathlon/iot-sensor-anomaly-detector/references/bigquery_queries.md b/skills/benchmark_skills/toolathlon/iot-sensor-anomaly-detector/references/bigquery_queries.md
new file mode 100644
index 0000000..3875205
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/iot-sensor-anomaly-detector/references/bigquery_queries.md
@@ -0,0 +1,5 @@
+# BigQuery Queries for IoT Sensor Anomaly Detection
+
+## Core Query Patterns
+
+### 1. Basic Sensor Data Retrieval
diff --git a/skills/benchmark_skills/toolathlon/iot-sensor-anomaly-detector/references/cloud_storage_operations.md b/skills/benchmark_skills/toolathlon/iot-sensor-anomaly-detector/references/cloud_storage_operations.md
new file mode 100644
index 0000000..1791057
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/iot-sensor-anomaly-detector/references/cloud_storage_operations.md
@@ -0,0 +1,9 @@
+# Cloud Storage Operations for Anomaly Reports
+
+## Bucket Identification
+- Look for buckets with prefix `iot_anomaly_reports`
+- Typical bucket name pattern: `iot_anomaly_reports-<random_suffix>`
+
+## File Operations
+
+### 1. Upload Anomaly Report
diff --git a/skills/benchmark_skills/toolathlon/iot-sensor-anomaly-detector/references/excel_structure.md b/skills/benchmark_skills/toolathlon/iot-sensor-anomaly-detector/references/excel_structure.md
new file mode 100644
index 0000000..60a87f3
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/iot-sensor-anomaly-detector/references/excel_structure.md
@@ -0,0 +1,39 @@
+# Excel Configuration File Structure
+
+## Expected Sheet: "Operating Parameters"
+
+### Column Structure
+| Column | Description | Data Type | Example |
+|--------|-------------|-----------|---------|
+| A: machine_id | Machine identifier | String | M001, M002 |
+| B: machine_description | Machine description | String | "Assembly Line A - Component Insertion" |
+| C: sensor_type | Type of sensor | String | temperature, pressure, rpm |
+| D: unit | Measurement unit | String | °C, bar, rpm |
+| E: min_value | Minimum acceptable value | Numeric | 18, 0.8, 1200 |
+| F: max_value | Maximum acceptable value | Numeric | 25, 1.2, 1800 |
+| G: calibration_date | Last calibration date | Date | 2024-01-15 |
+| H: next_maintenance | Next maintenance date | Date | 2024-07-15 |
+
+### Key Points
+1. **Sheet name**: The primary sheet is typically named "Operating Parameters" but may vary.
+2. **Header row**: First row contains column headers.
+3. **Data types**: Ensure min_value and max_value are numeric values.
+4. **Completeness**: All machines and sensor types should have corresponding parameter ranges.
+
+## Alternative Sheet Names
+If "Operating Parameters" sheet is not found, check for:
+- Parameters
+- Operating Ranges
+- Machine Parameters
+- Sensor Limits
+- Config
+
+## Validation Rules
+1. `min_value` should be less than `max_value` for each row.
+2. `machine_id` and `sensor_type` combinations should be unique.
+3. No NULL values in `machine_id`, `sensor_type`, `min_value`, or `max_value`.
+
+## Common Issues
+1. **Sheet not found**: Use workbook metadata to discover available sheets.
+2. **Column order variation**: The script uses column indices; verify if structure differs.
+3. **Data type mismatches**: Ensure numeric columns contain actual numbers, not strings.
diff --git a/skills/benchmark_skills/toolathlon/job-application-criteria-filter/SKILL.md b/skills/benchmark_skills/toolathlon/job-application-criteria-filter/SKILL.md
new file mode 100644
index 0000000..4b0505c
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/job-application-criteria-filter/SKILL.md
@@ -0,0 +1,42 @@
+---
+name: job-application-criteria-filter
+description: When the user needs to filter job opportunities based on multiple business criteria including salary thresholds, work type (remote/on-site), position titles, and location constraints. This skill parses salary ranges, validates minimum requirements, matches position titles against target roles, and applies logical AND/OR conditions across multiple criteria. Triggers include 'minimum salary', 'on-site/remote', 'position is', 'meets criteria', or when evaluating job opportunities against specific requirements.
+---
+# Instructions
+
+## Purpose
+You are a professional job search assistant. Your task is to filter job opportunities from a Notion database based on multiple business criteria, send application emails for qualifying jobs, and update their status.
+
+## Core Workflow
+1. **Locate the Database:** Search for the "Job Finder" Notion page to find the "Job Tracker" database.
+2. **Query for Initial Status:** Query the database for all entries with a status of "Checking".
+3. **Apply Filter Criteria:** For each "Checking" entry, apply the following criteria **all at once** (logical AND):
+ * **Salary:** Minimum salary requirement > $3000. Parse the "Salary Range" field (e.g., "$4200 - $4800/mo") to extract the lower bound.
+ * **Work Type:** Must be "On-site" work (check the "Flexibility" field).
+ * **Position:** Position title must be "software engineer" or "software manager" (case-insensitive match).
+ * **Location:** Company location must be within 500 km of UCLA. Use geocoding to get coordinates and calculate distance.
+4. **Process Qualifying Jobs:** For each job that meets all criteria:
+ * **Send Email:** Use the provided email template. Populate `{Company Name}` and `{Position}` from the database entry. The subject must be "Job Application for {Position}". Send to the email address in the "Email" field.
+ * **Update Status:** Change the entry's "Status" property from "Checking" to "Applied" in the Notion database.
+5. **Report Results:** Provide a clear summary of which jobs qualified, which did not (and why), and confirm the actions taken.
+
+## Key Logic & Edge Cases
+* **Salary Parsing:** Handle various salary range formats (e.g., "$3000-$3500/mo", "$2900 - $3600/mo"). Extract the first number as the minimum.
+* **Geocoding:** Use the `google_map-maps_geocode` tool to get coordinates for location strings (e.g., "Los Angeles, US", "UCLA, Los Angeles, California").
+* **Distance Calculation:** You are expected to perform the distance calculation logically. Locations like Los Angeles, Long Beach, and San Diego are within 500 km of UCLA. International locations (e.g., London, Berlin, Shanghai, Beijing) are not.
+* **Template Application:** The email body template is: "Hi {Company Name}, I am Janet Mendoza, I want to apply for the {Position} position...". Use it exactly as provided, only substituting the variables.
+* **Error Handling:** If a database field is missing or malformed (e.g., no email, unparsable salary), skip that entry and note it in your summary.
+
+## Tools You Will Use
+* `notion-API-post-search`: To find the "Job Finder" page and its databases.
+* `notion-API-post-database-query`: To query the "Job Tracker" database for entries with status "Checking".
+* `google_map-maps_geocode`: To get coordinates for location strings (UCLA and company locations).
+* `emails-send_email`: To send the application email.
+* `notion-API-patch-page`: To update the status of a qualifying job entry to "Applied".
+* `local-claim_done`: To signal task completion.
+
+## Final Output
+Conclude with a structured summary showing:
+1. The number of jobs processed and how many met all criteria.
+2. Details of the qualifying job(s) and the actions taken (email sent, status updated).
+3. A brief explanation for jobs that did not qualify (e.g., "salary too low", "remote position", "outside location radius").
diff --git a/skills/benchmark_skills/toolathlon/job-application-criteria-filter/references/criteria_summary.md b/skills/benchmark_skills/toolathlon/job-application-criteria-filter/references/criteria_summary.md
new file mode 100644
index 0000000..e3c3b40
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/job-application-criteria-filter/references/criteria_summary.md
@@ -0,0 +1,16 @@
+# Filter Criteria Summary
+
+## Mandatory Criteria (ALL must be met)
+1. **Status:** Entry must have status "Checking".
+2. **Salary:** Minimum salary > $3000.
+ * *Parsing Logic:* Extract the first number from the "Salary Range" field. Ignore currency symbols and text like "/mo".
+3. **Work Type:** Must be "On-site" (as indicated in the "Flexibility" field).
+4. **Position:** Must be "software engineer" OR "software manager" (case-insensitive match).
+5. **Location:** Must be within 500 km of UCLA (University of California, Los Angeles).
+ * *Reference Coordinates:* UCLA is approximately at lat 34.0699182, lng -118.4438495.
+ * *Logical Distance Check:* Major California cities (LA, San Diego, Long Beach) are within range. International cities are not.
+
+## Action Trigger
+When all five criteria above are satisfied for a database entry:
+1. Send an application email using the template.
+2. Update the entry's "Status" to "Applied".
diff --git a/skills/benchmark_skills/toolathlon/job-application-criteria-filter/references/email_template.md b/skills/benchmark_skills/toolathlon/job-application-criteria-filter/references/email_template.md
new file mode 100644
index 0000000..250534b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/job-application-criteria-filter/references/email_template.md
@@ -0,0 +1,7 @@
+# Email Template
+
+## Subject
+Job Application for {Position}
+
+## Body
+Hi {Company Name}, I am Janet Mendoza, I want to apply for the {Position} position...
diff --git a/skills/benchmark_skills/toolathlon/kubernetes-cluster-cleanup-automator/SKILL.md b/skills/benchmark_skills/toolathlon/kubernetes-cluster-cleanup-automator/SKILL.md
new file mode 100644
index 0000000..89bec41
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/kubernetes-cluster-cleanup-automator/SKILL.md
@@ -0,0 +1,60 @@
+---
+name: kubernetes-cluster-cleanup-automator
+description: Identifies and cleans up outdated Kubernetes deployments based on namespace patterns and application version age. Discovers deployments, analyzes release dates from annotations, performs cleanup actions, and notifies stakeholders.
+---
+# Instructions
+
+## Primary Objective
+Automatically identify Kubernetes deployments in target namespaces that are running application versions older than a specified threshold, stop those deployments, and notify the responsible cluster administrator.
+
+## Core Workflow
+
+### 1. Discover Target Namespaces
+- Use `k8s-kubectl_get` to list all namespaces
+- Filter namespaces by name pattern (default: names starting with 'dev-')
+- Store the filtered namespace list for subsequent operations
+
+### 2. Discover Deployments in Target Namespaces
+- For each target namespace, use `k8s-kubectl_get` to list all deployments
+- Collect deployment metadata including name, namespace, and creation timestamp
+
+### 3. Analyze Deployment Version Information
+- For each discovered deployment, use `k8s-kubectl_describe` to get detailed information
+- Extract the `app-version-release-date` annotation (expected format: ISO 8601 timestamp)
+- Calculate the age of the version relative to current date
+- Flag deployments where version age exceeds threshold (default: 30 days)
+
+### 4. Identify Cluster Administrator Contact
+- Search for contact information using multiple approaches:
+ - Search emails for relevant keywords: "cluster management", "cluster admin", "kubernetes", "infrastructure"
+ - Examine local filesystem for contact documents or configuration files
+ - Check PDF documents for team contact information (look for "Cluster & Computing Resources" or similar sections)
+- Extract email address of responsible person (typically found in team contact tables)
+
+### 5. Perform Cleanup Actions
+- For each outdated deployment, use `k8s-kubectl_scale` to set replicas to 0
+- This effectively "stops" the deployment without deleting it
+- Verify each scale operation completes successfully
+
+### 6. Compile and Send Notification
+- Sort outdated deployments chronologically from oldest to newest release date
+- Calculate exact number of days since each version was released
+- Format email according to specified template
+- Use `emails-send_email` to notify the identified cluster administrator
+- Include count of cleaned deployments and detailed list with namespace/deployment names and version ages
+
+## Key Parameters & Configuration
+- **Namespace Pattern**: Default 'dev-*' (configurable via user input)
+- **Age Threshold**: Default 30 days (configurable via user input)
+- **Date Annotation**: Looks for `app-version-release-date` annotation on deployments
+- **Contact Search**: Multiple fallback strategies for finding cluster admin
+
+## Error Handling & Edge Cases
+- If no namespaces match the pattern, report this and exit gracefully
+- If deployments lack the version annotation, skip them with a note
+- If cluster admin contact cannot be found, pause and request guidance
+- If scale operations fail, log the error but continue with others
+- Always verify email was sent successfully
+
+## Output Format
+The final email must follow this exact format:
diff --git a/skills/benchmark_skills/toolathlon/kubernetes-cluster-cleanup-automator/references/annotation_schema.md b/skills/benchmark_skills/toolathlon/kubernetes-cluster-cleanup-automator/references/annotation_schema.md
new file mode 100644
index 0000000..0e26b82
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/kubernetes-cluster-cleanup-automator/references/annotation_schema.md
@@ -0,0 +1,13 @@
+# Kubernetes Annotation Schema
+
+## Required Annotation
+This skill expects deployments to have the following annotation:
+
+### `app-version-release-date`
+- **Purpose**: Stores the release date of the application version running in the deployment
+- **Format**: ISO 8601 timestamp (UTC)
+- **Example**: `2025-08-30T09:45:14Z`
+- **Location**: Deployment metadata annotations
+
+## Annotation Extraction
+The annotation can be found in the deployment description:
diff --git a/skills/benchmark_skills/toolathlon/kubernetes-cluster-cleanup-automator/references/contact_discovery_flow.md b/skills/benchmark_skills/toolathlon/kubernetes-cluster-cleanup-automator/references/contact_discovery_flow.md
new file mode 100644
index 0000000..7569b59
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/kubernetes-cluster-cleanup-automator/references/contact_discovery_flow.md
@@ -0,0 +1,6 @@
+# Contact Discovery Flowchart
+
+## Primary Objective
+Find the email address of the cluster administrator responsible for Kubernetes resources.
+
+## Step 1: Email Search
diff --git a/skills/benchmark_skills/toolathlon/kubernetes-cluster-cleanup-automator/references/email_template.md b/skills/benchmark_skills/toolathlon/kubernetes-cluster-cleanup-automator/references/email_template.md
new file mode 100644
index 0000000..580c68e
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/kubernetes-cluster-cleanup-automator/references/email_template.md
@@ -0,0 +1,5 @@
+# Email Template Reference
+
+## Standard Notification Template
+Use this exact format for all cleanup notifications:
+
diff --git a/skills/benchmark_skills/toolathlon/kubernetes-database-analyst/SKILL.md b/skills/benchmark_skills/toolathlon/kubernetes-database-analyst/SKILL.md
new file mode 100644
index 0000000..505214c
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/kubernetes-database-analyst/SKILL.md
@@ -0,0 +1,29 @@
+---
+name: kubernetes-database-analyst
+description: Analyzes data from databases in Kubernetes clusters by setting up port forwarding, executing SQL queries, and generating CSV reports.
+---
+# Instructions
+
+## Phase 1: Initial Setup & Discovery
+1. **Read the Task:** Use `filesystem-read_file` to read the task file (e.g., `task.md`) to understand the analytical questions and required output format.
+2. **Inspect Kubernetes Resources:** Use `k8s-kubectl_get` to list all resources in the target namespace (e.g., `data`). Identify the database `Service` (e.g., `mysql-f1`) and its corresponding `Pod`.
+3. **Establish Database Connection:** Use `k8s-port_forward` to create a persistent port forward from a local port (e.g., `30124`) to the database service's target port (e.g., `3306`). **Note the `portForwardId`** to keep it alive.
+4. **List Workspace Files:** Use `filesystem-list_directory` to identify any template or input files in the workspace.
+
+## Phase 2: Database Schema Exploration
+5. **Connect and Explore:** Use `local-python-execute` to run a Python script that:
+ * Connects to the forwarded database using provided credentials (host=`127.0.0.1`, port=`[LOCAL_PORT]`).
+ * Lists all tables to understand the data structure.
+ * Examines the schema of key tables relevant to the task (e.g., `drivers`, `constructors`, `results`, `races`, `standings` tables).
+
+## Phase 3: Query Execution & Analysis
+6. **Develop and Test Queries:** Based on the task requirements, craft SQL queries within `local-python-execute` blocks. Test them iteratively to ensure correctness.
+ * For ranking/aggregation tasks (e.g., "highest points per year"), join `races`, `standings`, and dimension tables (`drivers`, `constructors`). Use window functions or subqueries with `GROUP BY` and `MAX()`.
+ * For complex conditional logic (e.g., "same constructor in first and last race"), use Common Table Expressions (CTEs) to break down the problem: filter by date/year, calculate first/last race per driver-season, count distinct rounds, and join on constructor ID.
+7. **Validate Results:** Check the row count and sample data of query results for logical consistency before writing to file.
+
+## Phase 4: Report Generation & Cleanup
+8. **Write Results to CSV:** Use `local-python-execute` with the `csv` module to write the final query results to CSV files with the exact names specified in the task (e.g., `results_1.csv`, `results_2.csv`). Ensure headers match the template format.
+9. **Remove Template Files:** Use `local-python-execute` with `os.remove()` to delete any provided template files from the workspace as instructed.
+10. **Verify Output:** Use `filesystem-read_multiple_files` to confirm the final CSV files exist and contain the expected data.
+11. **Finalize:** The port forward started in Step 3 should remain active. Use `local-claim_done` to signal task completion.
diff --git a/skills/benchmark_skills/toolathlon/kubernetes-database-analyst/references/kubernetes_commands.md b/skills/benchmark_skills/toolathlon/kubernetes-database-analyst/references/kubernetes_commands.md
new file mode 100644
index 0000000..33bca7d
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/kubernetes-database-analyst/references/kubernetes_commands.md
@@ -0,0 +1,3 @@
+# Essential Kubernetes Commands for Database Access
+
+## Port Forwarding
diff --git a/skills/benchmark_skills/toolathlon/kubernetes-database-analyst/references/sql_patterns.md b/skills/benchmark_skills/toolathlon/kubernetes-database-analyst/references/sql_patterns.md
new file mode 100644
index 0000000..b183339
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/kubernetes-database-analyst/references/sql_patterns.md
@@ -0,0 +1,3 @@
+# Common SQL Patterns for Analytical Queries
+
+## 1. Ranking / Highest Per Group
diff --git a/skills/benchmark_skills/toolathlon/kubernetes-pr-preview-deployer/SKILL.md b/skills/benchmark_skills/toolathlon/kubernetes-pr-preview-deployer/SKILL.md
new file mode 100644
index 0000000..d31eed3
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/kubernetes-pr-preview-deployer/SKILL.md
@@ -0,0 +1,42 @@
+---
+name: kubernetes-pr-preview-deployer
+description: Deploys a specific Git branch to Kubernetes for preview/testing. Handles cloning repositories, creating namespaces, applying Kubernetes manifests (like preview.yaml), creating ConfigMaps from application files, and exposing the application via NodePort for local access. After deployment, it can run tests and generate a test report.
+---
+# Instructions
+
+## Overview
+This skill deploys a Git branch to a Kubernetes preview environment. It follows a sequence of operations observed in the trajectory: clone repository, inspect structure, create Kubernetes resources from manifests and application files, expose the service, run tests, and generate a report.
+
+## Core Workflow
+
+### 1. Repository Setup
+- **Clone the target branch** from the specified Git repository into the workspace.
+- **Inspect the repository structure** to locate key files: `preview.yaml` (Kubernetes manifest), `src/index.html` (application file for ConfigMap), and test files.
+
+### 2. Kubernetes Deployment
+- **Create the namespace** specified in `preview.yaml` (e.g., `pr-preview-123`). If it already exists, proceed.
+- **Apply the main Kubernetes manifest** (`preview.yaml`) to create the Deployment and ClusterIP Service. Use the `--namespace` flag to target the correct namespace.
+- **Create a ConfigMap** from the application's static file (e.g., `src/index.html`). The ConfigMap name must match the `configMap.name` referenced in the Deployment's `volumes` section (e.g., `frontend-app-pr123-html`).
+- **Create a NodePort Service** to expose the application on a specific host port (e.g., `30123`). This service should select the same Pod labels as the Deployment. Use type `NodePort` and specify the `nodePort` field.
+
+### 3. Verification & Testing
+- **Verify the Pod is running** and the Service is accessible at `http://localhost:<nodePort>`.
+- **Run the test suite** if requested. The trajectory shows a Playwright test script (`tests/checkout.spec.js`) that expects the `APP_URL` environment variable or defaults to `http://localhost:30123`.
+- **Generate a test report** by executing the tests and filling a template report file (e.g., `test-results-report.md`). Update the result cells (✅/❌) and the summary statistics (Total, Passed, Failed). Save the completed report to the workspace root.
+
+## Key Decisions & Edge Cases
+- **Namespace Handling**: The namespace must be created before applying manifests that reference it. If creation fails because it exists, continue.
+- **ConfigMap Creation**: Must be created *after* the namespace exists. Use `kubectl create configmap <name> --from-file=<key>=<path>`.
+- **NodePort Service**: Create a separate Service of type `NodePort` in addition to any ClusterIP service in the manifest. This ensures long-term host access.
+- **Test Execution**: If the test environment lacks `npx` or Playwright, you may need to run tests manually via browser automation (as shown in the trajectory) and record results.
+- **Tax Calculation Bug**: Note that the example application has a bug: tax is calculated on the subtotal *before* discount, while the test expects it to be calculated *after* discount. The test report should reflect this failure.
+
+## Required Tools
+- `terminal-run_command` for shell operations (git, curl, file inspection).
+- `filesystem-*` tools for reading/writing files and directory trees.
+- `k8s-kubectl_*` tools for all Kubernetes operations.
+- `playwright_with_chunk-browser_*` tools for browser-based testing if automated test runners are unavailable.
+
+## Output
+- A running Kubernetes application accessible at `http://localhost:<specified_port>`.
+- A filled test report saved in the workspace root (e.g., `filled-test-results-report.md`).
diff --git a/skills/benchmark_skills/toolathlon/kubernetes-pr-preview-deployer/references/k8s_manifest_guide.md b/skills/benchmark_skills/toolathlon/kubernetes-pr-preview-deployer/references/k8s_manifest_guide.md
new file mode 100644
index 0000000..2445e6c
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/kubernetes-pr-preview-deployer/references/k8s_manifest_guide.md
@@ -0,0 +1,5 @@
+# Kubernetes Manifest Guide for PR Previews
+
+## Typical preview.yaml Structure
+The trajectory shows a `preview.yaml` with this common pattern:
+
diff --git a/skills/benchmark_skills/toolathlon/kubernetes-pr-preview-deployer/references/test_execution_guide.md b/skills/benchmark_skills/toolathlon/kubernetes-pr-preview-deployer/references/test_execution_guide.md
new file mode 100644
index 0000000..44def04
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/kubernetes-pr-preview-deployer/references/test_execution_guide.md
@@ -0,0 +1,58 @@
+# Test Execution Guide for Preview Deployments
+
+## Test Structure Observed
+The trajectory includes a Playwright test file `tests/checkout.spec.js` with:
+
+1. **Environment Variable**: Uses `process.env.APP_URL` or defaults to `http://localhost:30123`.
+2. **Test Categories**:
+ - E-Commerce Checkout Flow (11 functional tests)
+ - API Health Checks (2 API tests)
+3. **Report Template**: A markdown file `test-results-report.md` with a table to fill.
+
+## Running Tests Without Full Playwright Setup
+If `npx` or Playwright is not available in the environment, simulate test execution via browser automation:
+
+### Manual Test Steps (as in trajectory)
+1. Navigate to `http://localhost:<nodePort>`.
+2. For each test case:
+ - Perform the required interactions (click buttons, fill forms).
+ - Observe the results.
+ - Record ✅ (pass) or ❌ (fail).
+
+### Critical Test Cases & Verification Points
+
+#### 1. Homepage Load
+- Title contains "Frontend App - E-Commerce Demo".
+- PR info banner shows branch name and PR number.
+
+#### 2. Cart Operations
+- Add products: Cart updates with correct items and total.
+- Remove products: Item removed, total recalculated.
+- Free shipping message: Updates based on total ($50 threshold).
+
+#### 3. Checkout Process
+- Fill all required fields (name, email, address, card).
+- Submit form shows success message with Order ID (format `ORD-XXXXX`).
+
+#### 4. Coupon & Tax
+- Apply coupon `SAVE10`: Shows "Coupon applied: 10% off", discount calculated.
+- **Tax Bug**: Test expects tax calculated *after* discount (10% of `subtotal - discount`). The actual code calculates tax on subtotal before discount. This test will fail.
+
+#### 5. Responsive Design
+- Resize viewport to mobile (375x667) and tablet (768x1024).
+- Verify key elements remain visible.
+
+#### 6. API Health
+- `curl -I` returns HTTP 200.
+- Headers include `Content-Type: text/html`.
+
+#### 7. Performance
+- Page loads in < 3 seconds (use `curl -w "%{time_total}"`).
+
+## Filling the Test Report
+The report template has strict formatting:
+- Only replace empty cells with ✅ or ❌.
+- Update the `Summary Statistics` at the bottom: Total, Passed, Failed.
+- Do not modify any other text, headers, or table structure.
+
+Example completed report:
diff --git a/skills/benchmark_skills/toolathlon/latex-citation-reference-validator/SKILL.md b/skills/benchmark_skills/toolathlon/latex-citation-reference-validator/SKILL.md
new file mode 100644
index 0000000..238f480
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/latex-citation-reference-validator/SKILL.md
@@ -0,0 +1,47 @@
+---
+name: latex-citation-reference-validator
+description: Checks and fixes LaTeX paper drafts for citation and reference issues across multiple .tex files with a .bib bibliography file. Verifies that all \cite{}, \label{}, \ref{}, and \autoref{} commands work properly and cross-reference correctly across all files. Identifies broken, misnamed, or incorrect citations and references, then fixes them to use the correct names from the .bib file and LaTeX labels.
+---
+# Instructions
+
+## Overview
+This skill validates and repairs LaTeX citation and reference integrity in a multi-file project. It systematically scans all `.tex` files and the `.bib` file to identify:
+1. **Broken Citations:** `\cite{}` commands referencing non-existent `.bib` entries.
+2. **Empty Citations/References:** `\cite{}`, `\ref{}`, or `\autoref{}` with empty braces.
+3. **Broken References:** `\ref{}` or `\autoref{}` commands pointing to non-existent `\label{}`s.
+4. **Incorrect References:** References to labels that exist but are likely typos (e.g., `fig:call-api-v0` vs. `fig:call-api`).
+
+The core logic is implemented in the bundled Python script `validate_and_fix.py`. You should primarily execute this script, which provides a deterministic, repeatable analysis and repair process.
+
+## Step-by-Step Procedure
+
+1. **Initial Exploration:** First, understand the workspace structure. List the allowed directories and examine the directory tree to locate all `.tex` and `.bib` files.
+
+2. **Run the Validation Script:** Execute the primary script `/workspace/latex-citation-reference-validator/scripts/validate_and_fix.py`. This script will:
+ * Recursively find all `.tex` files in the workspace.
+ * Read the `.bib` file to extract all citation keys.
+ * Parse all `.tex` files for `\cite{}`, `\label{}`, `\ref{}`, and `\autoref{}` commands.
+ * Perform a comprehensive analysis, identifying all four categories of issues listed above.
+ * **Automatically fix** the identified issues by editing the source `.tex` files in place.
+ * Generate a detailed summary report of all changes made.
+
+3. **Review and Confirm:** After the script runs, review its output summary. The summary will detail every file modified and the specific changes applied (e.g., "Fixed empty citation `\citep{}` -> `\citep{brown2020language}`"). You should verify that the fixes are correct and appropriate for the context of the paper.
+
+4. **Manual Verification (Optional):** For complex projects or if you suspect edge cases, you may manually spot-check a few fixed locations in the `.tex` files to ensure the corrections are contextually accurate (e.g., the added citation key `brown2020language` is indeed the correct paper for the phrase "learn in-context").
+
+## Key Decisions & Heuristics
+* **Empty Citation Fixing:** The script uses a heuristic lookup table (`CITATION_FIX_MAP` in the script) to map common phrases to probable citation keys (e.g., "learn in-context" -> `brown2020language`, "SimCSE retriever" -> `gao2021simcse`). **You must review these automatic fixes for accuracy.** If the heuristic fails, you will need to manually determine and apply the correct citation key.
+* **Broken Reference Resolution:** The script identifies the closest matching existing label for a broken reference using string similarity. For example, `fig:call-api-v0` will be corrected to `fig:call-api`. **You must verify** that the suggested correction is semantically correct (i.e., references the intended figure/table/section).
+* **Scope:** The script operates on all `.tex` files within the `/workspace` directory. Ensure your target paper files are located there.
+
+## Triggers
+Use this skill when the user request involves:
+* "Check my LaTeX citations and references."
+* "Fix broken `\ref{}` commands in my paper."
+* "Validate that all `\cite{}` commands match my `.bib` file."
+* "Help me find missing labels or citations."
+* Working with file extensions `.tex` and `.bib`.
+
+## Bundled Resources
+* `scripts/validate_and_fix.py`: The main analysis and repair script. Run this.
+* `references/common_citations.md`: A reference list of common NLP/ML paper citation keys and the contexts they typically appear in. Consult this if you need to manually determine a correct citation key not covered by the script's heuristics.
diff --git a/skills/benchmark_skills/toolathlon/latex-table-generator/SKILL.md b/skills/benchmark_skills/toolathlon/latex-table-generator/SKILL.md
new file mode 100644
index 0000000..7d7dd3d
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/latex-table-generator/SKILL.md
@@ -0,0 +1,32 @@
+---
+name: latex-table-generator
+description: Creates formatted LaTeX tables from structured data. It parses data, applies sorting and formatting rules, generates table headers and structure following provided templates, and saves the output as .tex files.
+---
+# Instructions
+
+## Primary Objective
+Generate a LaTeX table from provided data sources (e.g., PDFs, text) and save it as a `.tex` file. The table must follow a user-specified format and sorting order.
+
+## Core Workflow
+1. **Identify Inputs & Requirements:** The user will specify the data source, the desired table columns, and the sorting rule (e.g., "descending order of FID").
+2. **Locate & Parse Source Data:** Use appropriate tools (`filesystem-list_directory`, `pdf-tools-read_pdf_pages`, `pdf-tools-search_pdf_content`) to find and extract the required numerical and categorical data (e.g., Model Name, Method Category, Parameters, FID, Inception Score).
+3. **Extract & Structure Data:** Parse the extracted text to identify key-value pairs for the table. Focus on finding the *best* result per source (e.g., "the model with the lowest FID result in the paper").
+4. **Apply Formatting & Sorting:** Structure the data into rows. Apply the user-specified sorting rule to the final dataset.
+5. **Generate LaTeX Code:** Use the provided template (e.g., `format.tex`) to structure the final table. Insert the sorted data rows into the template's `tabular` environment.
+6. **Write Output File:** Use `filesystem-write_file` to save the generated LaTeX source code to the specified `.tex` file (e.g., `survey.tex`).
+7. **Verify & Conclude:** Optionally, read the created file to confirm its contents and present a summary to the user.
+
+## Key Decisions & Rules
+* **Model Selection:** When a source (e.g., a paper) contains multiple models, select the one that best meets the user's criterion (e.g., lowest FID).
+* **Method Categorization:** Map the model's method to one of the standard categories: `VAE`, `GAN`, `Diffusion`, `Flow-based`, or `AR` (Autoregressive). Use context from the paper to make this determination.
+* **Data Validation:** Cross-reference extracted numbers (like Parameters, FID) within the paper (e.g., check text, tables, captions) to ensure accuracy before populating the final table.
+* **Template Adherence:** Strictly follow the column structure and LaTeX styling (e.g., `\\toprule`, `\\midrule`, `\\bottomrule` from `booktabs`) defined in the user's template file.
+
+## Triggers
+Initiate this skill when the user request contains keywords or phrases such as:
+* "create LaTeX table"
+* "save results in .tex"
+* "format table"
+* "tabular environment"
+* Mentions of `.tex` file extensions or LaTeX formatting.
+* Requests to summarize comparative data into a structured, sortable table.
diff --git a/skills/benchmark_skills/toolathlon/latex-table-generator/assets/table_template.tex b/skills/benchmark_skills/toolathlon/latex-table-generator/assets/table_template.tex
new file mode 100644
index 0000000..7aed84e
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/latex-table-generator/assets/table_template.tex
@@ -0,0 +1,29 @@
+% LaTeX Table Template (booktabs style)
+% Save this as 'format.tex' or similar for the skill to reference.
+\documentclass{article}
+\usepackage{booktabs} % Required for professional-looking rules
+
+\begin{document}
+
+% This is the template structure to replicate.
+\begin{table}[!ht]
+ \centering
+ \begin{tabular}{ccccc}
+ \toprule
+ Model & Class & \#Param & FID-50K & Inception Score \\
+ \midrule
+ A & GAN & 300M & 40.20 & 150.00 \\
+ B & Diffusion & 2B & 20.20 & 190.00 \\
+ \bottomrule
+ \end{tabular}
+ \caption{Example table comparing model performance.}
+ \label{tab:example}
+\end{table}
+
+% Instructions:
+% 1. Replace the column headers if needed.
+% 2. Replace the sample data rows with extracted data.
+% 3. Maintain the same number of columns (5 in this example).
+% 4. Ensure rows are sorted according to the user's request.
+
+\end{document}
diff --git a/skills/benchmark_skills/toolathlon/latex-table-generator/references/latex_table_guide.md b/skills/benchmark_skills/toolathlon/latex-table-generator/references/latex_table_guide.md
new file mode 100644
index 0000000..1b1dc78
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/latex-table-generator/references/latex_table_guide.md
@@ -0,0 +1,4 @@
+# LaTeX Table Formatting Guide
+
+## Core Packages Used in Template
+The example template (`format.tex`) uses the `booktabs` package for high-quality tables.
diff --git a/skills/benchmark_skills/toolathlon/leave-excusal-communication-handler/SKILL.md b/skills/benchmark_skills/toolathlon/leave-excusal-communication-handler/SKILL.md
new file mode 100644
index 0000000..13f9d7f
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/leave-excusal-communication-handler/SKILL.md
@@ -0,0 +1,68 @@
+---
+name: leave-excusal-communication-handler
+description: When the user needs to communicate about approved leaves or excusals to instructors/TAs, including locating leave documents and sending reminder emails with attachments. This skill triggers when users mention 'excused assignments', 'leave documents', or need to remind instructors about approved absences. It handles document retrieval, email composition with proper context, and attachment management for official documentation.
+---
+# Instructions
+
+## Primary Objective
+Handle communication regarding approved leaves/excusals with instructors or TAs. This includes locating relevant leave documents, composing and sending reminder emails with proper context, and attaching official documentation.
+
+## Trigger Conditions
+This skill activates when the user mentions:
+- "excused assignments"
+- "leave documents"
+- "approved leave"
+- "remind instructor/TA about absence"
+- Any scenario requiring formal communication about an approved absence affecting coursework.
+
+## Core Workflow
+
+### 1. Initial Context Gathering
+- **Access personal information**: Use `memory-read_graph` to retrieve the user's details (name, student ID, email, enrolled courses).
+- **Identify relevant course**: If not specified, list user's courses via `canvas-canvas_list_courses` and identify the correct one based on context (course name, code, or assignment mentions).
+- **Review assignment status**: For the relevant course, call `canvas-canvas_list_assignments` with `include_submissions: true` to get submission status for all assignments.
+
+### 2. Document Location & Verification
+- **Search workspace**: Use `filesystem-list_allowed_directories` and `filesystem-directory_tree` to explore the accessible workspace.
+- **Identify leave document**: Look for files with names containing "leave", "excusal", "absence", or similar terms. Common formats: PDF, DOC, DOCX.
+- **Verify document content**: Read the identified file (`filesystem-read_file`) to confirm it's the correct leave document (contains user's name, dates, approval details).
+
+### 3. Email Recipient Identification
+- **Extract from grade records**: If a grade summary file (e.g., Excel) is mentioned, read it (`local-python-execute` with pandas) to find instructor/TA contact information.
+- **Alternative sources**: Check course details from Canvas for teacher emails, or use the email pattern from the grade summary (e.g., `[email protected]`).
+
+### 4. Email Composition & Sending
+- **Subject line**: Should include: "Reminder: Approved Leave of Absence for [Assignment Name] - [User Name] ([Student ID])"
+- **Body structure**:
+ 1. Polite greeting
+ 2. Clear statement of purpose (reminder about approved leave)
+ 3. Specific details: assignment affected, dates of leave, original approval context
+ 4. Request for action (update records to reflect excused status)
+ 5. Professional closing with contact information
+- **Attachment**: Always attach the verified leave document.
+- **Send email**: Use `emails-send_email` with recipient address, subject, body, and attachment path.
+
+### 5. Assignment Handling (If Applicable)
+- **Check submission requirements**: Review assignment descriptions for specific file naming conventions or submission types.
+- **Submit missing work** (if requested and not excused): Only if the user explicitly asks to submit completed assignments that are missing but NOT excused.
+ - Locate completed assignment files in workspace.
+ - Rename files to match required conventions if specified.
+ - Submit via `canvas-canvas_submit_assignment_with_file`.
+
+## Key Constraints & Rules
+- **Do NOT submit excused assignments**: If an assignment is explicitly mentioned as excused due to leave, do not attempt to submit it. Only send the reminder email.
+- **Only submit existing work**: Never create assignment content. Only submit files found in the workspace.
+- **Verify before sending**: Always confirm the leave document is correct and contains relevant approval details.
+- **Maintain professionalism**: All communications must be formal, polite, and clearly structured.
+
+## Error Handling
+- If no leave document is found: Inform the user and ask for clarification on document location.
+- If TA/instructor email cannot be identified: Use a generic course contact email or ask the user for the correct address.
+- If assignment files are missing: Do not submit anything. Inform the user that completed work was not found.
+
+## Output & Confirmation
+After completing all actions, provide a clear summary to the user including:
+- Which assignments were identified as missing/excused
+- Which assignments were submitted (if any)
+- Confirmation that the reminder email was sent
+- Details of the attached document
diff --git a/skills/benchmark_skills/toolathlon/leave-excusal-communication-handler/references/canvas_integration.md b/skills/benchmark_skills/toolathlon/leave-excusal-communication-handler/references/canvas_integration.md
new file mode 100644
index 0000000..9616627
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/leave-excusal-communication-handler/references/canvas_integration.md
@@ -0,0 +1,38 @@
+# Canvas LMS Integration Guide
+
+## API Endpoints Used
+
+### 1. List Courses
+**Endpoint:** `canvas-canvas_list_courses`
+**Purpose:** Retrieve all courses the student is enrolled in.
+**Key Fields:**
+- `id`: Course ID (used for subsequent calls)
+- `name`: Course name
+- `course_code`: Course code (e.g., FILM101)
+- `teachers`: Array of instructor information
+
+### 2. List Assignments with Submissions
+**Endpoint:** `canvas-canvas_list_assignments`
+**Parameters:**
+- `course_id`: Required, from course listing
+- `include_submissions`: Set to `true` to get submission status
+**Key Submission Fields:**
+- `submission.workflow_state`: "submitted", "unsubmitted", "graded"
+- `submission.submitted_at`: Date of submission (null if not submitted)
+- `submission.missing`: Boolean indicating if assignment is missing
+- `submission.excused`: Boolean indicating if assignment is excused
+
+### 3. Submit Assignment with File
+**Endpoint:** `canvas-canvas_submit_assignment_with_file`
+**Parameters:**
+- `course_id`: Course ID
+- `assignment_id`: Assignment ID from assignment listing
+- `file_path`: Local path to the file to submit
+**Important Notes:**
+- File naming conventions are often specified in assignment descriptions
+- Check `allowed_extensions` in assignment details
+- Some assignments may require specific submission types (`online_text_entry`, `online_upload`, etc.)
+
+## Common Patterns
+
+### Identifying Missing Assignments
diff --git a/skills/benchmark_skills/toolathlon/leave-excusal-communication-handler/references/email_templates.md b/skills/benchmark_skills/toolathlon/leave-excusal-communication-handler/references/email_templates.md
new file mode 100644
index 0000000..3aa256e
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/leave-excusal-communication-handler/references/email_templates.md
@@ -0,0 +1,8 @@
+# Email Templates for Leave Excusal Communication
+
+## Template 1: Standard Leave Reminder
+**Use when:** Reminding TA/instructor about an approved leave that affected assignment submission.
+
+**Subject:** Reminder: Approved Leave of Absence for [Assignment Name] - [Student Name] ([Student ID])
+
+**Body:**
diff --git a/skills/benchmark_skills/toolathlon/location-geocoder/SKILL.md b/skills/benchmark_skills/toolathlon/location-geocoder/SKILL.md
new file mode 100644
index 0000000..c51c8d6
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/location-geocoder/SKILL.md
@@ -0,0 +1,73 @@
+---
+name: location-geocoder
+description: When the user provides location names, addresses, or landmarks that need to be converted to precise geographic coordinates. This skill uses mapping APIs to geocode locations, returning latitude/longitude coordinates, formatted addresses, and place IDs for subsequent spatial analysis or route planning tasks.
+---
+# Skill: Location Geocoder
+
+## Purpose
+Convert user-provided location descriptions (names, addresses, landmarks) into precise geographic coordinates and structured location data using mapping APIs. This provides the foundational location data needed for subsequent tasks like route planning, distance calculations, or spatial analysis.
+
+## Core Workflow
+
+### 1. Input Processing
+- **Accept**: Location descriptions in natural language (e.g., "Singapore Mobility Gallery", "Changi Airport MRT station, Singapore")
+- **Normalize**: Clean and standardize input for API consumption
+- **Validate**: Ensure location descriptions are complete enough for geocoding
+
+### 2. Geocoding Execution
+- **Primary Tool**: Use `google_map-maps_geocode` function
+- **Input Format**: Provide address/location string in natural language
+- **Output Capture**: Extract and structure:
+ - `location.lat`: Latitude coordinate
+ - `location.lng`: Longitude coordinate
+ - `formatted_address`: Standardized complete address
+ - `place_id`: Unique identifier for the location
+
+### 3. Output Delivery
+- **Structured Data**: Present coordinates and address in clear format
+- **Error Handling**: Provide helpful feedback if geocoding fails
+- **Next Steps**: Suggest how the geocoded data can be used (e.g., "Now I have the coordinates, I can calculate routes between these points")
+
+## Key Principles
+
+### Accuracy First
+- Always verify the returned address matches the intended location
+- Use specific location descriptors when available (include city/country)
+- Cross-reference with known landmarks if coordinates seem questionable
+
+### Efficiency
+- Geocode multiple locations in parallel when possible
+- Cache frequently requested locations to avoid redundant API calls
+- Batch process when user provides multiple location inputs
+
+### Context Awareness
+- Consider the user's broader task (route planning, distance calculation, etc.)
+- Provide geocoded data in formats useful for next steps
+- Include place_id for API interoperability with other mapping functions
+
+## Common Use Cases
+
+### Route Planning (as seen in trajectory)
+1. Geocode origin: "Singapore Mobility Gallery, Singapore"
+2. Geocode destination: "Changi Airport MRT station, Singapore"
+3. Use coordinates for subsequent route calculation
+
+### Distance Calculations
+- Geocode multiple points for distance matrix analysis
+- Provide precise coordinates for accurate distance measurements
+
+### Location Validation
+- Confirm address existence and format
+- Resolve ambiguous location names to specific coordinates
+
+## Error Handling
+- **No Results**: Suggest alternative phrasing or more specific location details
+- **Multiple Results**: Ask user to clarify which specific location they mean
+- **API Errors**: Retry with modified parameters or suggest manual coordinate input
+
+## Integration Notes
+This skill typically serves as the first step in location-based workflows. The output (coordinates, place_id) should be preserved for use with:
+- Route planning functions
+- Distance matrix calculations
+- Nearby place searches
+- Spatial analysis tools
diff --git a/skills/benchmark_skills/toolathlon/location-geocoder/references/api_response_formats.md b/skills/benchmark_skills/toolathlon/location-geocoder/references/api_response_formats.md
new file mode 100644
index 0000000..63e5424
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/location-geocoder/references/api_response_formats.md
@@ -0,0 +1,5 @@
+# Geocoding API Response Formats
+
+## Google Maps Geocoding API Response
+
+### Successful Response Structure
diff --git a/skills/benchmark_skills/toolathlon/location-geocoder/references/geocoding_best_practices.md b/skills/benchmark_skills/toolathlon/location-geocoder/references/geocoding_best_practices.md
new file mode 100644
index 0000000..e59a91a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/location-geocoder/references/geocoding_best_practices.md
@@ -0,0 +1,34 @@
+# Geocoding Best Practices
+
+## Input Optimization
+
+### 1. Location String Formatting
+- **Always include country**: "Singapore Mobility Gallery, Singapore" not just "Singapore Mobility Gallery"
+- **Use complete addresses** when possible: "1 Hampshire Rd, Block 1 Level 1, Singapore 219428"
+- **Include landmarks** for ambiguous names: "Changi Airport MRT station" not just "Changi Airport"
+
+### 2. Common Pitfalls to Avoid
+- **Ambiguous names**: "Central Park" could be in New York, Sydney, or many other cities
+- **Abbreviations**: Spell out street types (Road, Avenue, Boulevard)
+- **Missing context**: "The Gallery" needs city/country context
+
+## API Usage Guidelines
+
+### 1. Rate Limiting Considerations
+- Batch requests when processing multiple locations
+- Implement exponential backoff for failed requests
+- Cache frequently requested locations
+
+### 2. Error Handling
+- **No results**: Check spelling, add more context, try alternative phrasing
+- **Multiple results**: Use the most specific match, ask user for clarification
+- **Invalid requests**: Validate input format before API call
+
+### 3. Response Processing
+- Always check `formatted_address` matches intended location
+- Verify coordinates are within expected geographic area
+- Save `place_id` for future API calls to same location
+
+## Accuracy Improvement Techniques
+
+### 1. Pre-processing
diff --git a/skills/benchmark_skills/toolathlon/media-content-researcher/SKILL.md b/skills/benchmark_skills/toolathlon/media-content-researcher/SKILL.md
new file mode 100644
index 0000000..5837cd5
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/media-content-researcher/SKILL.md
@@ -0,0 +1,32 @@
+---
+name: media-content-researcher
+description: When the user requests to find official media content like movie trailers, YouTube links, or other online resources, this skill performs targeted web searches to locate specific media content, extracts relevant URLs and metadata, and verifies the authenticity of sources. It's triggered by requests for 'official trailer', 'YouTube link', 'search for', or when specific media content needs to be found and integrated into other systems.
+---
+# Instructions
+
+You are a media content researcher. Your primary function is to locate, verify, and extract specific media content (like official trailers, YouTube videos, or other online resources) based on user requests.
+
+## Core Workflow
+
+1. **Interpret the Request:** Identify the specific piece of media the user wants you to find (e.g., "Official trailer for [Movie Title]").
+2. **Construct Search Query:** Formulate a precise web search query. Prioritize terms like "official trailer," "YouTube," and the exact title to find authentic sources.
+3. **Execute Search:** Use the `local-web_search` tool to perform the search. Request a sufficient number of results (e.g., `num_results: 10`) to ensure you find the target.
+4. **Analyze & Filter Results:**
+ * Scan the search results for the most relevant and authoritative link (e.g., the official movie studio's YouTube channel).
+ * Prioritize results that explicitly state "Official Trailer" or come from verified channels.
+ * Extract the correct URL and any useful metadata (like the video title).
+5. **Deliver Findings:** Present the found URL(s) to the user clearly. If integrating with another system (like a Notion database), state your intent to use the discovered link.
+
+## Key Principles
+
+* **Precision is Key:** Your search queries must be specific. "Star Wars Episode III Revenge of the Sith official trailer YouTube" is better than "Star Wars trailer."
+* **Verify Authenticity:** Look for indicators of an official source. Avoid fan edits or compilation videos unless specified.
+* **Extract Cleanly:** Provide the direct URL. For YouTube, the format is typically `https://www.youtube.com/watch?v=VIDEO_ID`.
+* **Know Your Role:** You are a researcher. Your output is the *information* (the URL). Another skill or the main agent may handle the integration of that information into a page or database.
+
+## Example Thought Process (From Trajectory)
+
+* **Goal:** Find the official Star Wars: Episode III trailer.
+* **Query:** `"Star Wars Episode III Revenge of the Sith official trailer YouTube"`
+* **Analysis:** The first result ("Star Wars Episode III: Revenge of the Sith - Trailer - YouTube") from the Star Wars channel is the target.
+* **Output:** `https://www.youtube.com/watch?v=5UnjrG_N8hU`
diff --git a/skills/benchmark_skills/toolathlon/media-content-researcher/references/search_guidelines.md b/skills/benchmark_skills/toolathlon/media-content-researcher/references/search_guidelines.md
new file mode 100644
index 0000000..774cf62
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/media-content-researcher/references/search_guidelines.md
@@ -0,0 +1,18 @@
+# Media Search Guidelines
+
+## Query Formulation
+* **For Movie Trailers:** `"[Exact Movie Title] official trailer YouTube"`
+* **For Music Videos:** `"[Artist Name] - [Song Title] official music video"`
+* **For TV Show Clips:** `"[Show Name] [Season] [Episode] clip official"`
+* **General Media:** `"[Content Name]" [platform, e.g., YouTube, Vimeo]`
+
+## Source Verification Heuristics
+1. **Channel/Publisher Name:** Favor results from known, verified entities (e.g., `Marvel Entertainment`, `StarWars`, artist's VEVO channel).
+2. **Title Text:** Look for phrases like "Official Trailer", "Official Music Video", "Official Channel".
+3. **URL Patterns:** YouTube URLs from specific channels often follow a pattern (e.g., `youtube.com/user/Marvel`).
+4. **Snippet Text:** The description snippet in search results often confirms if the content is official.
+
+## Result Parsing
+* Extract the **Title** and **Link** from the search tool's output.
+* The `snippet` field can provide useful context about the video's content and authenticity.
+* If the first result is not clearly official, examine subsequent results.
diff --git a/skills/benchmark_skills/toolathlon/model-checkpoint-evaluator/SKILL.md b/skills/benchmark_skills/toolathlon/model-checkpoint-evaluator/SKILL.md
new file mode 100644
index 0000000..6467f23
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/model-checkpoint-evaluator/SKILL.md
@@ -0,0 +1,47 @@
+---
+name: model-checkpoint-evaluator
+description: When the user needs to evaluate multiple model checkpoints across various benchmarks to identify the best performing model based on evaluation metrics like accuracy, F1-score, or custom scoring functions. This skill scans directories containing model checkpoints, runs benchmark evaluations using predefined scoring algorithms, calculates overall performance scores, and identifies the checkpoint with the highest evaluation metric. It handles complex evaluation workflows involving multiple benchmark categories and mathematical scoring formulas.
+---
+# Instructions
+
+## Overview
+This skill evaluates model checkpoints across multiple benchmark categories using predefined scoring algorithms, identifies the best-performing checkpoint based on overall evaluation accuracy, and prepares it for deployment (e.g., uploading to Hugging Face Hub with updated documentation).
+
+## Workflow
+
+### 1. Scan Workspace and Identify Checkpoints
+- List directories in the workspace to locate checkpoint folders.
+- Checkpoint folders are typically named with step numbers (e.g., `step_100`, `step_200`).
+- Extract step numbers from folder names for evaluation.
+
+### 2. Run Benchmark Evaluations
+- Use the bundled `benchmark_calculator.py` script to compute scores for each checkpoint.
+- The script implements 15 benchmark scoring functions derived from the original Cython module:
+ - **Core Reasoning Tasks**: Math Reasoning, Logical Reasoning, Common Sense
+ - **Language Understanding**: Reading Comprehension, Question Answering, Text Classification, Sentiment Analysis
+ - **Generation Tasks**: Code Generation, Creative Writing, Dialogue Generation, Summarization
+ - **Specialized Capabilities**: Translation, Knowledge Retrieval, Instruction Following, Safety Evaluation
+- Each scoring function uses mathematical formulas (sigmoid, rational, exponential) based on step value.
+
+### 3. Calculate Overall Performance
+- For each checkpoint, compute the average of all benchmark scores as the `eval_accuracy`.
+- Identify the checkpoint with the highest `eval_accuracy`.
+
+### 4. Prepare Best Model for Deployment
+- Update the model's `README.md` with benchmark scores (keep three decimal places).
+- Ensure all necessary files are present: `config.json`, `pytorch_model.bin`, figures.
+- If required, push the model to Hugging Face Hub:
+ - Use the Hugging Face token from `hf_token.txt`.
+ - Create/update repository with the model name specified by the user.
+ - Upload the entire checkpoint folder.
+
+## Key Decisions
+- **Benchmark Scoring**: Use the formulas in `benchmark_calculator.py`; do not modify them.
+- **README Update**: Only replace `{RESULT}` placeholders with scores; preserve all other content.
+- **File Handling**: Copy necessary assets (e.g., figures) to the checkpoint folder before upload.
+- **Error Handling**: If a checkpoint folder is missing required files, skip it and log a warning.
+
+## Notes
+- The skill assumes checkpoints are in a structured directory (e.g., `workspace/checkpoints/`).
+- For Hugging Face upload, ensure `huggingface_hub` is installed and the token is valid.
+- All benchmark scores are rounded to three decimal places in the final README.
diff --git a/skills/benchmark_skills/toolathlon/multi-currency-expense-aggregator/SKILL.md b/skills/benchmark_skills/toolathlon/multi-currency-expense-aggregator/SKILL.md
new file mode 100644
index 0000000..113b730
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-currency-expense-aggregator/SKILL.md
@@ -0,0 +1,36 @@
+---
+name: multi-currency-expense-aggregator
+description: When the user needs to calculate total expenses across multiple individuals with costs in different currencies and convert them to a target currency using historical exchange rates. This skill handles reading multiple CSV/JSON files containing expense data, fetching exchange rates from financial APIs for specific dates, performing currency conversions, aggregating totals per person, and generating structured JSON reports with calculated results. Key triggers include requests for 'total trip cost', 'expense calculation with exchange rates', 'convert multiple currencies to [target currency]', or tasks involving reading multiple expense files with USD, EUR, TRY, CNY amounts.
+---
+# Instructions
+
+## Objective
+Calculate the total expenses for a group of individuals from multiple files, convert all amounts to a target currency (e.g., CNY) using historical exchange rates from a specific date, and output a structured JSON report.
+
+## Core Workflow
+1. **Identify Inputs:** Determine the target currency, the historical date for exchange rates, the list of individuals, and the location of their expense files (CSV/JSON). The user may provide this explicitly or it may need to be inferred from the workspace.
+2. **Read Data:** List and read all relevant expense files from the workspace. Files are typically CSVs with columns for `Date`, `Activity/Description`, `Cost/Amount`, and `Currency`, or similar variations.
+3. **Fetch Exchange Rates:** Use the Yahoo Finance tool (`yahoo-finance-get_stock_price_by_date`) to get the closing exchange rates for the required currency pairs (e.g., `USDCNY=X`, `EURCNY=X`) on the specified historical date. For indirect pairs (e.g., TRY/CNY), you may need to fetch a cross-rate (e.g., `TRYUSD=X`) and calculate the target rate.
+4. **Parse & Aggregate:** For each individual's file:
+ * Parse the data, summing amounts by currency (USD, EUR, TRY, CNY, etc.).
+ * Convert each currency sum to the target currency using the fetched rates.
+ * Calculate the individual's total in the target currency.
+5. **Calculate Grand Total:** Sum all individual totals.
+6. **Generate Output:** Create or update a specified JSON file (e.g., `calculation.json`) with the exchange rates used and each individual's total in the target currency, along with the grand total. Format numbers appropriately (e.g., rounded to 2 decimal places).
+
+## Key Considerations & Edge Cases
+* **File Format Variability:** Expense files may have different column names, structures, or delimiters. Be prepared to handle variations like `Cost` vs `Amount`, or files where costs are spread across multiple currency columns.
+* **Missing Direct Rates:** If a direct exchange rate pair (e.g., `TRYCNY=X`) is not available, you must calculate it using a common intermediary (e.g., `TRYUSD=X` and `USDCNY=X`).
+* **Date Handling:** The exchange rate date is critical. Ensure the correct date is used for the `yahoo-finance-get_stock_price_by_date` call. Use the `close` price for conversion.
+* **Error Handling:** If a file cannot be read or a rate cannot be fetched, note the issue and proceed if possible, or ask for clarification.
+* **Calculation Verification:** For complex sums, consider writing a temporary Python script to perform the arithmetic and verify totals, then clean it up.
+
+## Typical Tool Sequence
+1. `filesystem-list_directory` - Explore the workspace.
+2. `filesystem-read_multiple_files` / `filesystem-read_file` - Load expense data.
+3. `yahoo-finance-get_stock_price_by_date` - Fetch historical FX rates.
+4. `terminal-run_command` - Optionally run a Python script for accurate bulk calculations.
+5. `filesystem-write_file` - Write the final JSON report.
+
+## Output
+The primary output is a JSON file (e.g., `calculation.json`) populated with keys for exchange rates and individual/group totals in the target currency. Provide a concise summary to the user.
diff --git a/skills/benchmark_skills/toolathlon/multi-currency-expense-aggregator/references/exchange_rate_guide.md b/skills/benchmark_skills/toolathlon/multi-currency-expense-aggregator/references/exchange_rate_guide.md
new file mode 100644
index 0000000..c96967b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-currency-expense-aggregator/references/exchange_rate_guide.md
@@ -0,0 +1,31 @@
+# Exchange Rate Fetching Guide
+
+## Yahoo Finance Ticker Format for Forex
+Yahoo Finance uses the format `XXXYYY=X` to represent the XXX/YYY exchange rate, where XXX is the base currency and YYY is the quote currency.
+
+### Common Pairs for CNY Conversions
+* `USDCNY=X` - US Dollar to Chinese Yuan
+* `EURCNY=X` - Euro to Chinese Yuan
+* `GBPCNY=X` - British Pound to Chinese Yuan
+* `JPYCNY=X` - Japanese Yen to Chinese Yuan
+* `AUCNY=X` - Australian Dollar to Chinese Yuan (Note: AUD, not AUS)
+* `CADCNY=X` - Canadian Dollar to Chinese Yuan
+
+### Handling Indirect/Cross Rates
+Some currency pairs may not have direct XXXCNY feeds. In this case, use a two-step conversion via USD:
+
+1. Fetch `XXXUSD=X` (e.g., `TRYUSD=X` for Turkish Lira to USD)
+2. Fetch `USDCNY=X`
+3. Calculate: `XXX_to_CNY = XXXUSD_rate × USDCNY_rate`
+
+**Example from Trajectory:**
+- TRY/CNY not found directly.
+- Fetched `TRYUSD=X = 0.025468`
+- Fetched `USDCNY=X = 7.2037`
+- Calculated `TRY_to_CNY = 0.025468 × 7.2037 ≈ 0.1835`
+
+## API Call Notes
+* Use the `yahoo-finance-get_stock_price_by_date` tool.
+* The `close` price from the returned data is typically used for conversion.
+* Ensure the `date` parameter matches the historical date requested by the user (e.g., "2025-06-05").
+* If "No trading data found" is returned for a direct pair, attempt the cross-rate method.
diff --git a/skills/benchmark_skills/toolathlon/multi-currency-expense-aggregator/references/expense_file_schemas.md b/skills/benchmark_skills/toolathlon/multi-currency-expense-aggregator/references/expense_file_schemas.md
new file mode 100644
index 0000000..d1443b6
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-currency-expense-aggregator/references/expense_file_schemas.md
@@ -0,0 +1,7 @@
+# Common Expense File Schemas
+
+Based on the execution trajectory, expense files can vary in structure. Here are observed patterns:
+
+## Schema 1: Single Cost Column with Embedded Currency
+**File:** `Andrew's Istanbul expenses.csv`
+**Structure:**
diff --git a/skills/benchmark_skills/toolathlon/multi-dataset-unification-pipeline/SKILL.md b/skills/benchmark_skills/toolathlon/multi-dataset-unification-pipeline/SKILL.md
new file mode 100644
index 0000000..6e7f669
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-dataset-unification-pipeline/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: multi-dataset-unification-pipeline
+description: When the user requests to find, analyze, and merge multiple datasets from Hugging Face or similar repositories into a unified format. This skill handles the complete pipeline searching for datasets, examining their structure, parsing format specifications, converting diverse dataset formats (ToolACE, Glaive, XLAM, etc.) into a standardized schema, and merging them into a single output file. Key triggers include requests involving 'dataset unification', 'format conversion', 'merge datasets', 'Hugging Face datasets', 'tool-calling datasets', 'JSONL output', or when users provide a format specification document like 'unified_format.md'.
+---
+# Instructions
+
+## 1. Understand the Request
+- Identify the target datasets (names, IDs, or search queries).
+- Locate and read any provided format specification (e.g., `unified_format.md`).
+- Clarify the scope: number of entries per dataset, output file name/location.
+
+## 2. Search and Validate Datasets
+- Use `huggingface-dataset_search` to find each dataset.
+- Use `huggingface-hub_repo_details` to get metadata and confirm availability.
+- Note the dataset size and structure.
+
+## 3. Analyze Dataset Structures
+- Load a sample from each dataset using `datasets.load_dataset`.
+- Examine the column names and a few sample entries.
+- Identify the native format (e.g., ToolACE uses `system`/`conversations`, Glaive uses `conversations`/`tools`, XLAM uses `query`/`answers`/`tools`).
+
+## 4. Convert to Unified Format
+- **Always** refer to the provided `unified_format.md` (or equivalent) for the target schema.
+- **Key Rules**:
+ - `conversation_id`: Format as `{source_short_name}_{index}` (e.g., `toolace_0`).
+ - `messages`: List of messages with `role` (`user`/`assistant`/`tool`), `content`, and optionally `tool_calls` or `tool_call_id`.
+ - `tool_calls`: For assistant messages, include `id` (format `tool_call_{n}`), `name`, `arguments`.
+ - `tools`: List of normalized tool definitions.
+ - Remove system messages if they only contain tool instructions.
+ - If assistant only made tool calls, set `content` to `null`.
+ - Do not add tool return results or assistant replies not in the original data.
+- Use the bundled `scripts/convert_and_merge.py` for reliable, deterministic conversion of ToolACE, Glaive, and XLAM formats.
+- For new dataset formats, write a custom converter following the patterns in the script.
+
+## 5. Merge and Output
+- Limit entries per dataset as requested (default: first 500).
+- Merge all converted entries into a single list.
+- Write to a JSONL file in the workspace (default: `unified_tool_call.jsonl`).
+- Verify the output: count entries, check file size, validate format against the specification.
+
+## 6. Finalize
+- Provide a summary: datasets found, entries converted, output location.
+- Optionally, show a sample entry from each source for validation.
+- Confirm the task is complete.
diff --git a/skills/benchmark_skills/toolathlon/multi-dataset-unification-pipeline/references/unified_format_example.md b/skills/benchmark_skills/toolathlon/multi-dataset-unification-pipeline/references/unified_format_example.md
new file mode 100644
index 0000000..120d7ab
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-dataset-unification-pipeline/references/unified_format_example.md
@@ -0,0 +1,5 @@
+# Unified Format Specification
+
+## Format Overview
+Each data entry is a JSON object with the following structure:
+
diff --git a/skills/benchmark_skills/toolathlon/multi-file-content-extractor/SKILL.md b/skills/benchmark_skills/toolathlon/multi-file-content-extractor/SKILL.md
new file mode 100644
index 0000000..0b271b1
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-file-content-extractor/SKILL.md
@@ -0,0 +1,21 @@
+---
+name: multi-file-content-extractor
+description: When the user references multiple files in their query or when the task requires reading content from several files in the workspace, this skill loads and extracts text content from specified file paths. It handles reading multiple files simultaneously, returning their contents for further processing. Triggers include phrases like 'located in the workspace', 'from the file', or when multiple file paths are mentioned.
+---
+# Instructions
+
+## Primary Function
+Use this skill when the user's request explicitly mentions or implies the need to read content from multiple files in the workspace. The core action is to call the `filesystem-read_multiple_files` tool with an array of file paths.
+
+## Trigger Detection
+Activate this skill when you detect any of the following in the user's query:
+- Explicit mention of multiple file paths (e.g., "/workspace/file1.md", "/workspace/file2.json").
+- References to files "in the workspace" or "located in the workspace".
+- Phrases like "from the file" or "based on the document" when multiple documents are involved.
+- The task logically requires synthesizing information from more than one source file.
+
+## Execution Steps
+1. **Parse the Request:** Identify all file paths mentioned or implied by the user's query. Paths are often absolute (e.g., `/workspace/dumps/workspace/recommendation.md`).
+2. **Validate Paths:** Ensure the paths are plausible and within a workspace context (e.g., starting with `/workspace`). If a path is ambiguous, use your best judgment to construct it based on the query context.
+3. **Batch Read:** Call the `filesystem-read_multiple_files` tool once, passing a JSON array of all identified file paths to the `paths` argument.
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/multi-file-content-extractor/references/tool_spec.md b/skills/benchmark_skills/toolathlon/multi-file-content-extractor/references/tool_spec.md
new file mode 100644
index 0000000..32a48a4
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-file-content-extractor/references/tool_spec.md
@@ -0,0 +1,11 @@
+# Tool Specification: filesystem-read_multiple_files
+
+## Purpose
+Reads and returns the text content of multiple files in a single operation.
+
+## Input (`arguments`)
+A JSON object with one key:
+- `paths` (array of strings): **Required**. The absolute paths to the files to be read.
+
+## Output
+A text string where the content of each file is concatenated. The format is:
diff --git a/skills/benchmark_skills/toolathlon/multi-market-portfolio-allocator/SKILL.md b/skills/benchmark_skills/toolathlon/multi-market-portfolio-allocator/SKILL.md
new file mode 100644
index 0000000..16b4979
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-market-portfolio-allocator/SKILL.md
@@ -0,0 +1,60 @@
+---
+name: multi-market-portfolio-allocator
+description: When the user needs to build an investment portfolio across multiple markets (US, Hong Kong, A-shares) with specific allocation ratios, total capital constraints, and market-specific trading rules. This skill reads stock lists from Excel files, fetches current/latest stock prices and exchange rates from financial APIs, categorizes stocks by market type, calculates position sizes based on allocation percentages, applies market-specific constraints (whole shares for US/HK stocks, 100-share lots for A-shares), performs currency conversions, and generates a complete position-building plan with detailed calculations. It also updates Excel files with calculated stock codes and position sizes. Triggers include requests for portfolio allocation, position building, stock purchase planning with capital allocation ratios, and Excel-based stock list processing.
+---
+# Instructions
+
+## 1. Understand the User Request
+The user will provide:
+- A total capital amount (e.g., $1,000,000 USD).
+- An allocation ratio for US stocks, Hong Kong stocks, and A-shares (e.g., 4:3:3).
+- An Excel file (`stock.xlsx` by default) containing a list of stock names. The file has columns: `Stock_name`, `Stock_code` (initially empty), and `Initial_position_size` (initially empty).
+- Specific instructions on which stocks belong to which market (e.g., "Alibaba as a Hong Kong stock, BYD, Ping An Insurance and Wuxi AppTec as A-shares").
+- Trading rules: Purchases in whole shares for US/HK stocks, and in multiples of 100 shares (lots) for A-shares.
+- The request to calculate based on "today's" opening prices, or the latest trading day's data if today is not a trading day.
+
+Your goal is to produce a detailed position-building plan and fill the user's Excel file.
+
+## 2. Core Workflow
+
+### Phase 1: Data Extraction & Categorization
+1. **Read the Excel File:** Use the `excel-read_data_from_excel` tool to load the stock list. Identify the stock names.
+2. **Categorize Stocks:** Based on the user's instructions and common knowledge, map each stock name to its market (US, Hong Kong, A-share) and determine its standard ticker symbol.
+ - **US Stocks:** Typically trade on US exchanges (NASDAQ, NYSE). Use standard tickers (e.g., MSFT, AAPL).
+ - **Hong Kong Stocks:** Use the `.HK` suffix (e.g., 9988.HK for Alibaba).
+ - **A-Shares:** Use the `.SS` (Shanghai) or `.SZ` (Shenzhen) suffix (e.g., 601318.SS for Ping An Insurance).
+ - *If a stock could belong to multiple markets (like Alibaba), strictly follow the user's explicit instruction.*
+
+### Phase 2: Data Fetching
+1. **Fetch Stock Prices:** For each categorized stock, use the `yahoo-finance-get_historical_stock_prices` tool to get the last 5 days of daily data (`period="5d"`, `interval="1d"`). Extract the **Open** price from the most recent data point (index 0). This represents "today's" or the latest trading day's opening price.
+2. **Fetch Exchange Rates:** Use the same tool to get exchange rates for `USDCNY=X` (USD to CNY) and `USDHKD=X` (USD to HKD). Extract the latest **Open** rate.
+
+### Phase 3: Calculation & Allocation
+1. **Calculate Market Allocations:** Apply the user's ratio (e.g., 4:3:3) to the total capital to determine the USD amount allocated to each market.
+2. **Convert to Local Currency:** Convert the HK allocation to HKD and the A-share allocation to CNY using the fetched exchange rates.
+3. **Calculate Per-Stock Allocation:** Divide each market's local currency allocation equally among the stocks in that market.
+4. **Calculate Share Quantities:**
+ - **US/HK Stocks:** `floor(per_stock_allocation_local / stock_price)`. Result must be a whole integer.
+ - **A-Shares:** `floor(per_stock_allocation_local / (stock_price * 100)) * 100`. Result must be a multiple of 100.
+5. **Calculate Costs & Summary:** Compute the cost in local currency and USD for each position. Sum up totals for each market and overall. Calculate remaining cash.
+
+### Phase 4: Output & File Update
+1. **Generate Position Plan:** Present a clear summary including:
+ - Allocation breakdown and exchange rates used.
+ - A table for each market showing stock, ticker, shares, price, and cost.
+ - A final investment summary (totals per market, total invested, remaining cash).
+2. **Update Excel File:** Use the `excel-write_data_to_excel` tool to write the calculated **ticker symbols** and **share quantities** (numbers only) back into the `Stock_code` and `Initial_position_size` columns of the original Excel file, starting at cell B2.
+3. **Verify Update:** Optionally re-read the file to confirm the data was written correctly.
+
+## 3. Key Rules & Constraints
+- **Accuracy:** Double-check ticker symbol mappings and currency conversions.
+- **Precision:** Share calculations must strictly adhere to `floor` for US/HK and `floor` to the nearest 100 for A-shares. Do not round up.
+- **Clarity:** The final plan should be easy for the user to review and execute.
+- **Stop:** Once the plan is delivered and the Excel file is updated, claim the task as done. Do not perform any additional, unrequested actions.
+
+## 4. Handling Ambiguity
+- If a stock name is ambiguous and the user didn't specify, use your best judgment based on the most common/liquid listing and state your assumption.
+- If financial data is unavailable for a ticker, note it in the plan and exclude it from calculations, adjusting the per-stock allocation for the remaining stocks in that market accordingly.
+- If the user's Excel file has a different structure, adapt the read/write cell ranges as needed.
+
+For detailed ticker mappings, calculation logic, and error handling examples, refer to the bundled scripts and references.
diff --git a/skills/benchmark_skills/toolathlon/multi-market-portfolio-allocator/references/ticker_mapping.md b/skills/benchmark_skills/toolathlon/multi-market-portfolio-allocator/references/ticker_mapping.md
new file mode 100644
index 0000000..dd10ae5
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-market-portfolio-allocator/references/ticker_mapping.md
@@ -0,0 +1,43 @@
+# Common Stock Ticker Reference
+
+This is a non-exhaustive reference for mapping common company names to their Yahoo Finance tickers across US, Hong Kong, and A-Share markets. Always prioritize the user's explicit instructions.
+
+## US Stocks (NYSE/NASDAQ)
+- Microsoft: MSFT
+- Apple: AAPL
+- NVIDIA: NVDA
+- AMD: AMD
+- Google / Alphabet: GOOGL (Class A) or GOOG (Class C)
+- Meta (Facebook): META
+- Amazon: AMZN
+- Tesla: TSLA
+- Netflix: NFLX
+
+## Hong Kong Stocks (Suffix: .HK)
+- Tencent: 0700.HK
+- Alibaba: 9988.HK (Primary Listing)
+- Meituan: 3690.HK
+- Xiaomi: 1810.HK
+- JD.com: 9618.HK
+- HSBC: 0005.HK
+- AIA: 1299.HK
+
+## A-Shares
+**Shanghai Stock Exchange (Suffix: .SS)**
+- Kweichow Moutai: 600519.SS
+- Ping An Insurance: 601318.SS
+- Industrial and Commercial Bank of China (ICBC): 601398.SS
+- WuXi AppTec: 603259.SS
+
+**Shenzhen Stock Exchange (Suffix: .SZ)**
+- Contemporary Amperex Technology (CATL): 300750.SZ
+- BYD: 002594.SZ
+- Midea Group: 000333.SZ
+- Gree Electric: 000651.SZ
+
+## Important Notes
+1. **Dual-Listings:** Some companies are listed in multiple markets.
+ - Alibaba: US (BABA), Hong Kong (9988.HK). The user may specify which one to use.
+ - JD.com: US (JD), Hong Kong (9618.HK).
+2. **Yahoo Finance Format:** Always use the correct suffix (.HK, .SS, .SZ) for non-US stocks.
+3. **Validation:** If unsure, verify the ticker by searching on Yahoo Finance or a similar financial data portal before fetching prices.
diff --git a/skills/benchmark_skills/toolathlon/multi-market-portfolio-allocator/references/workflow_visual.md b/skills/benchmark_skills/toolathlon/multi-market-portfolio-allocator/references/workflow_visual.md
new file mode 100644
index 0000000..dec622f
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-market-portfolio-allocator/references/workflow_visual.md
@@ -0,0 +1,24 @@
+---
+title: Multi-Market Portfolio Allocation Workflow
+---
+flowchart TD
+ A[User Request<br>+ Excel File] --> B[Read Excel &<br>Extract Stock List]
+ B --> C[Categorize Stocks by Market<br>US / HK / A-Share]
+ C --> D{Fetch Financial Data}
+ D --> E[Fetch Latest Stock Prices]
+ D --> F[Fetch Exchange Rates<br>USD/CNY & USD/HKD]
+ E & F --> G[Calculate Allocation & Shares]
+
+ subgraph G [Core Calculation]
+ G1[Apply Ratio to Total Capital]
+ G2[Convert to Local Currency]
+ G3[Equal Weight per Stock in Market]
+ G4[Floor Shares US/HK<br>Floor to Lots A-Share]
+ G5[Summarize Costs & Totals]
+ end
+
+ G --> H[Generate Detailed<br>Position-Building Plan]
+ G --> I[Update Excel File with<br>Tickers & Share Quantities]
+ H --> J[Deliver Final Plan &<br>Confirm File Update]
+ I --> J
+ J --> K[Task Complete]
diff --git a/skills/benchmark_skills/toolathlon/multi-modal-travel-planner/SKILL.md b/skills/benchmark_skills/toolathlon/multi-modal-travel-planner/SKILL.md
new file mode 100644
index 0000000..39059bd
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-modal-travel-planner/SKILL.md
@@ -0,0 +1,34 @@
+---
+name: multi-modal-travel-planner
+description: When the user requests a complete travel itinerary involving multiple modes of transportation with specific waypoints and preferences. This skill handles end-to-end journey planning including 1) Finding nearby points of interest (like coffee shops) relative to departure points, 2) Calculating optimal transit routes between locations with cost and duration information, 3) Determining walking routes from arrival points to final destinations, and 4) Formatting the complete plan into structured output. Triggers include requests for 'travel plans', 'route planning', 'journey from X to Y', or when users specify multiple destinations with preferences like 'direct route', 'shortest distance', or 'nearest [business type]'.
+---
+# Instructions
+
+## 1. Interpret the Request
+- Identify the **departure point**, **final destination**, and any **intermediate waypoints** (e.g., "buy a Starbucks").
+- Note specific user preferences: "direct route," "shortest possible distance," "as close as possible to [location]."
+- Clarify the required **output format** if specified (e.g., `format.json`).
+
+## 2. Gather Location Data
+- Use `google_map-maps_geocode` to get coordinates and canonical addresses for all named locations (departure, destination, waypoints).
+- If a waypoint is a generic business type (e.g., "Starbucks"), use `google_map-maps_search_places` with the departure location as a reference point and a reasonable radius (e.g., 500m).
+- For the closest match, use `google_map-maps_place_details` to get the full address and confirm proximity.
+
+## 3. Plan the Main Transit Route
+- Use `google_map-maps_directions` in `transit` mode between the departure and final destination.
+- **If the API returns `ZERO_RESULTS`**, use the `playwright_with_chunk` browser tool to navigate to `https://www.google.com/maps/dir/[ORIGIN]/[DESTINATION]` and scrape the transit information from the page. Look for the "Best" or "Transit" option.
+- Extract key details: **line name** (e.g., "Yokosuka Line"), **duration**, and **cost**.
+
+## 4. Plan the Final Walking Route
+- Use `google_map-maps_directions` in `walking` mode from the arrival station/point to the final destination.
+- If the optimal exit from the arrival point is ambiguous (e.g., different station exits), use `google_map-maps_distance_matrix` to compare walking distances from plausible exits (e.g., "East Exit" vs. "West Exit") to the destination. Recommend the exit with the shortest distance.
+
+## 5. Assemble and Format the Plan
+- Compile all gathered data into a structured JSON object matching the user's requested format.
+- Use `filesystem-write_file` to save the final plan to the specified path.
+- Optionally, use `filesystem-read_file` to verify the output and present a concise summary to the user.
+
+## Key Principles
+- **Progressive Disclosure**: Use the bundled `reference/format_guide.md` for complex output schema details.
+- **Direct Route Priority**: When the user asks for a "direct route," prioritize transit options with no transfers.
+- **Closest Point of Interest**: For requests like "as close as possible," filter search results by distance from the reference point.
diff --git a/skills/benchmark_skills/toolathlon/multi-modal-travel-planner/references/format_guide.md b/skills/benchmark_skills/toolathlon/multi-modal-travel-planner/references/format_guide.md
new file mode 100644
index 0000000..7a36e50
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-modal-travel-planner/references/format_guide.md
@@ -0,0 +1,9 @@
+# Output Format Guide
+
+This guide details the expected JSON structure for a complete multi-modal travel plan, as demonstrated in the trajectory.
+
+## Root Object
+The final output is a JSON object with four main sections.
+
+## 1. `starbucks` (or similar point of interest)
+Contains details for a requested waypoint, typically a business near the departure location.
diff --git a/skills/benchmark_skills/toolathlon/multi-namespace-deployment-analyzer/SKILL.md b/skills/benchmark_skills/toolathlon/multi-namespace-deployment-analyzer/SKILL.md
new file mode 100644
index 0000000..38385b7
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-namespace-deployment-analyzer/SKILL.md
@@ -0,0 +1,74 @@
+---
+name: multi-namespace-deployment-analyzer
+description: When the user needs to analyze deployments across multiple Kubernetes namespaces with filtering criteria. This skill discovers namespaces matching patterns, retrieves deployment information from each namespace, extracts metadata and annotations, and performs comparative analysis across namespaces. It handles batch operations and consolidates results from multiple namespace queries. Triggers include 'namespaces starting with', 'across namespaces', 'multiple namespaces', 'deployment analysis', 'namespace pattern', 'batch deployment query', 'cross-namespace comparison'.
+---
+# Instructions
+
+## Overview
+This skill analyzes Kubernetes deployments across multiple namespaces based on filtering criteria. It discovers namespaces matching patterns, retrieves deployment information, extracts metadata/annotations, performs comparative analysis, and can execute batch operations.
+
+## Core Workflow
+
+### 1. Discover Target Namespaces
+- Use `k8s-kubectl_get` to list all namespaces
+- Filter namespaces based on user criteria (e.g., names starting with 'dev-')
+- Store the filtered namespace list for subsequent operations
+
+### 2. Retrieve Deployments from Each Namespace
+- For each target namespace, use `k8s-kubectl_get` to list deployments
+- Collect deployment metadata: name, namespace, status, creation timestamp
+- Handle empty namespaces gracefully
+
+### 3. Extract Detailed Deployment Information
+- For each deployment, use `k8s-kubectl_describe` to get detailed information
+- Focus on extracting annotations, particularly `app-version-release-date` or similar version metadata
+- Note container images, resource limits, and other relevant configuration
+
+### 4. Perform Analysis
+- Calculate age of deployments based on release date annotations
+- Apply filtering criteria (e.g., "more than 30 days ago")
+- Sort results chronologically (oldest to newest)
+- Count affected deployments for reporting
+
+### 5. Execute Batch Operations (If Required)
+- Based on analysis results, perform actions like scaling deployments to 0 replicas
+- Use `k8s-kubectl_scale` for each outdated deployment
+- Verify operations completed successfully
+
+### 6. Identify Responsible Personnel
+- Search for contact information using multiple approaches:
+ - Search emails for relevant keywords ("cluster management", "cluster admin", "kubernetes", "infrastructure")
+ - Examine available files and directories for contact information
+ - Check PDF documents for organizational charts or responsibility matrices
+ - Look for configuration files that might contain contact details
+
+### 7. Generate and Send Report
+- Compile results in the specified format
+- Include: number of affected deployments, sorted list with namespace/deployment names and days since release
+- Use `emails-send_email` to notify the identified responsible party
+- Use professional email format with clear subject and body
+
+## Key Considerations
+
+### Error Handling
+- Handle cases where no namespaces match the pattern
+- Handle deployments without version annotations gracefully
+- Provide clear feedback when contact information cannot be found
+- Verify email sending was successful
+
+### Performance Optimization
+- Batch namespace queries when possible
+- Cache results to avoid redundant API calls
+- Process deployments in parallel where appropriate
+
+### Output Formatting
+- Always sort deployments chronologically from oldest to newest
+- Include both namespace and deployment name in listings
+- Calculate days accurately based on current date
+- Use consistent formatting throughout the report
+
+## Common Patterns
+- Namespace filtering: typically prefixes like 'dev-', 'staging-', 'prod-'
+- Age filtering: 30, 60, 90 days common thresholds
+- Actions: scale to 0, delete, annotate, or just report
+- Contacts: cluster admins, team leads, infrastructure managers
diff --git a/skills/benchmark_skills/toolathlon/multi-namespace-deployment-analyzer/references/contact_discovery.md b/skills/benchmark_skills/toolathlon/multi-namespace-deployment-analyzer/references/contact_discovery.md
new file mode 100644
index 0000000..a294415
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-namespace-deployment-analyzer/references/contact_discovery.md
@@ -0,0 +1,46 @@
+# Contact Discovery Strategies
+
+## Primary Methods for Finding Cluster Administrators
+
+### 1. Email Search Patterns
+Search emails using these keywords in order:
+- "cluster management"
+- "cluster admin"
+- "kubernetes"
+- "infrastructure"
+- "devops"
+- "platform team"
+
+### 2. File System Discovery
+Check these common locations for contact information:
+- `/workspace/dumps/workspace/` - Look for config files, documentation
+- `/shared/configs/` - Kubernetes configs may contain contacts
+- `/etc/` - System configuration files
+- Home directories - User-specific contact info
+
+### 3. Document Analysis
+Examine these document types:
+- **PDFs**: Organizational charts, responsibility matrices, guidelines
+- **Markdown/Text files**: READMEs, documentation, runbooks
+- **YAML/JSON configs**: Application configurations, team manifests
+- **Spreadsheets**: Team rosters, contact lists
+
+### 4. Common File Patterns
+Search for files containing:
+- `contact`
+- `team`
+- `admin`
+- `responsibility`
+- `oncall`
+- `roster`
+
+### 5. Fallback Contacts
+If specific cluster admin not found:
+- Use team distribution lists
+- Contact infrastructure team lead
+- Use general support email
+- Escalate to department head
+
+## Common Contact Information Locations
+
+### In Kubernetes Contexts
diff --git a/skills/benchmark_skills/toolathlon/multi-namespace-deployment-analyzer/references/email_templates.md b/skills/benchmark_skills/toolathlon/multi-namespace-deployment-analyzer/references/email_templates.md
new file mode 100644
index 0000000..8641322
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-namespace-deployment-analyzer/references/email_templates.md
@@ -0,0 +1,3 @@
+# Email Templates for Deployment Analysis
+
+## Template 1: Cleanup Notification
diff --git a/skills/benchmark_skills/toolathlon/multi-namespace-deployment-analyzer/references/kubectl_patterns.md b/skills/benchmark_skills/toolathlon/multi-namespace-deployment-analyzer/references/kubectl_patterns.md
new file mode 100644
index 0000000..a380668
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-namespace-deployment-analyzer/references/kubectl_patterns.md
@@ -0,0 +1,5 @@
+# Kubernetes kubectl Patterns for Deployment Analysis
+
+## Common Commands and Outputs
+
+### 1. List Namespaces
diff --git a/skills/benchmark_skills/toolathlon/multi-source-data-integration-workflow/SKILL.md b/skills/benchmark_skills/toolathlon/multi-source-data-integration-workflow/SKILL.md
new file mode 100644
index 0000000..12124cc
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-source-data-integration-workflow/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: multi-source-data-integration-workflow
+description: When the user requires an end-to-end workflow that integrates data from multiple sources (financial APIs, local files) and outputs to collaboration tools (Google Sheets, Notion), this skill orchestrates the complete pipeline reading template formats, fetching external data, processing and transforming data, writing to cloud spreadsheets, and updating project management tools. Triggers include complex requests involving 'retrieve data and record in', 'create sheet with data from', or workflows that span multiple platforms with specific formatting requirements.
+---
+# Instructions
+
+## 1. Understand the Request & Parse Requirements
+- Identify the target stocks/tickers, date range, and required data fields (e.g., Open, High, Low, Close, Volume).
+- Confirm the user wants **original prices** (`auto_adjust: false`), not adjusted prices.
+- Identify the target output Google Sheet name and specific worksheet name.
+- Identify the target Notion page and the exact notification message/comment to add.
+
+## 2. Read the Format Template
+- Locate and read the example file (e.g., `example.csv`) provided by the user to understand the required column order and data format.
+- The standard format is: `Ticker,Date,Open,High,Low,Close,Volume`.
+
+## 3. Create and Prepare the Google Sheet
+- Create a new Google Spreadsheet with the requested title.
+- Rename the default first worksheet to the requested name (e.g., "Jun-Jul_2025").
+
+## 4. Fetch Historical Stock Data
+- For each ticker, use the Yahoo Finance tool (`yahoo-finance-get_historical_stock_prices`) to fetch daily data for the specified date range.
+- **CRITICAL:** Set `auto_adjust` to `false` to get original prices.
+- The API automatically excludes non-trading days.
+
+## 5. Process and Transform the Data
+- Consolidate data from all tickers into a single list.
+- Transform each data point to match the template format: `[Ticker, Date (YYYY-MM-DD), Open, High, Low, Close, Volume]`.
+- Sort the consolidated list primarily by Date, then by Ticker to maintain a clean, chronological order grouped by ticker for each day.
+
+## 6. Write Data to Google Sheet
+- Write the header row (`Ticker,Date,Open,High,Low,Close,Volume`) to cell A1 of the target worksheet.
+- Write the consolidated, sorted data rows starting from cell A2.
+- Obtain the final URL of the Google Sheet.
+
+## 7. Update the Notion Page
+- Search for the target Notion page (e.g., "Quant Research") using the Notion API.
+- Once the correct page ID is found, append a new line containing the Google Sheet URL in the format: `Google Sheet : {url}`.
+- Add a comment to the top of that page with the exact text: "Monthly market data is ready. The reporting team can view it directly".
+
+## 8. Final Verification
+- Confirm the data has been written to the Google Sheet correctly.
+- Confirm the Notion page has been updated with the URL and the top comment.
+- Inform the user that the workflow is complete.
diff --git a/skills/benchmark_skills/toolathlon/multi-source-data-integration-workflow/references/data_schema.md b/skills/benchmark_skills/toolathlon/multi-source-data-integration-workflow/references/data_schema.md
new file mode 100644
index 0000000..6c25fbd
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-source-data-integration-workflow/references/data_schema.md
@@ -0,0 +1,5 @@
+# Data Schema Reference
+
+## Yahoo Finance API Response Schema
+The `yahoo-finance-get_historical_stock_prices` tool returns a list of objects with the following structure when `auto_adjust=false`:
+
diff --git a/skills/benchmark_skills/toolathlon/multi-source-data-integration-workflow/references/tool_usage_guide.md b/skills/benchmark_skills/toolathlon/multi-source-data-integration-workflow/references/tool_usage_guide.md
new file mode 100644
index 0000000..8c465dd
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-source-data-integration-workflow/references/tool_usage_guide.md
@@ -0,0 +1,8 @@
+# Tool Usage Guide
+
+## Google Sheets Tools
+
+### google_sheet-create_spreadsheet
+Creates a new Google Spreadsheet.
+
+**Parameters:**
diff --git a/skills/benchmark_skills/toolathlon/multi-source-web-researcher/SKILL.md b/skills/benchmark_skills/toolathlon/multi-source-web-researcher/SKILL.md
new file mode 100644
index 0000000..8f2afe9
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-source-web-researcher/SKILL.md
@@ -0,0 +1,37 @@
+---
+name: multi-source-web-researcher
+description: When the user needs to gather information from multiple sources including web searches, academic databases (arXiv), PDF documents, and professional profiles. This skill is triggered by research tasks requiring parallel information gathering, cross-referencing multiple sources, or when dealing with academic/professional data that exists across different platforms. It handles concurrent searches, source verification, and data consolidation from diverse information repositories.
+---
+# Multi-Source Web Researcher
+
+## Purpose
+This skill orchestrates the systematic collection, verification, and consolidation of information from multiple digital sources to answer research questions, particularly those involving academic or professional data. It is designed to handle tasks where information is distributed across web search results, academic paper repositories (arXiv), PDF documents, and professional profile platforms (Google Scholar, institutional websites).
+
+## Core Workflow
+
+### 1. Initial Setup & Discovery
+- **Locate Target Files**: First, identify any local files (like Excel workbooks) that define the research scope or require population. Use terminal commands to find relevant files in the workspace.
+- **Understand Data Structure**: Read the metadata and contents of discovered files to understand what information needs to be gathered and the required format.
+
+### 2. Parallel Information Gathering
+- **Concurrent Searches**: For efficiency, launch multiple web searches *in parallel* to gather initial leads on each research item (e.g., paper titles, author names).
+- **Source Diversification**: Use a combination of:
+ - `local-web_search`: For general web results, author profiles, and institutional pages.
+ - `arxiv_local-search_papers`: For finding specific academic papers and their metadata on arXiv.
+ - `pdf-tools-read_pdf_pages`: To extract precise information (like author affiliations) directly from source PDFs when URLs are known.
+
+### 3. Verification & Deep Dive
+- **Cross-reference Findings**: Use information from one source (e.g., a paper title from web search) to find the canonical source (e.g., the PDF on arXiv or OpenReview).
+- **Extract Primary Data**: Always prioritize extracting key details (like full author affiliation) directly from the original PDF to ensure accuracy.
+- **Profile Discovery**: Search for professional profiles (e.g., Google Scholar) using the verified author name and affiliation.
+
+### 4. Data Consolidation & Output
+- **Structure Collected Data**: Compile the verified information into a structured format (e.g., list of lists for an Excel sheet).
+- **Write to Target**: Update the original file (e.g., Excel workbook) with the collected data.
+- **Final Verification**: Read back the updated file to confirm all data was written correctly and present a summary to the user.
+
+## Key Principles
+- **Parallelism is Key**: Use tool calls concurrently whenever possible to minimize total research time.
+- **Prioritize Primary Sources**: For academic data, the PDF of the paper is the ground truth for author order and affiliation.
+- **Verify Links**: Ensure collected profile URLs are direct links to the author's public profile page.
+- **Handle Encoding**: Be prepared to correctly process special characters in names and affiliations (e.g., Clément Bonet).
diff --git a/skills/benchmark_skills/toolathlon/multi-source-web-researcher/references/research_sources.md b/skills/benchmark_skills/toolathlon/multi-source-web-researcher/references/research_sources.md
new file mode 100644
index 0000000..fda61d0
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-source-web-researcher/references/research_sources.md
@@ -0,0 +1,44 @@
+# Research Sources & Verification Guide
+
+## Primary Source Hierarchy
+For academic research tasks, verify information in this order:
+1. **Original Paper PDF**: Ground truth for author list, affiliations, and correspondence.
+2. **Official Repository Page**: Conference sites (OpenReview, PMLR), arXiv abstract pages.
+3. **Author's Institutional Profile**: University department pages, lab websites.
+4. **Professional Network Profiles**: Google Scholar, LinkedIn, ResearchGate.
+5. **General Web Search Results**: News articles, blog posts, secondary summaries.
+
+## Common Source Patterns
+
+### 1. Finding Paper PDFs
+- **arXiv**: `https://arxiv.org/pdf/{paper_id}` (e.g., `2502.12147`)
+- **OpenReview (ICML/NeurIPS/ICLR)**: `https://openreview.net/pdf?id={paper_id}`
+- **PMLR (Proceedings of Machine Learning Research)**: `https://proceedings.mlr.press/v{volume}/{paper_id}.pdf`
+
+### 2. Extracting Author Information
+From a PDF's first page, look for:
+- The title and author list directly under it.
+- The affiliation block, often marked with numbered superscripts (`¹`, `²`) or asterisks (`*`).
+- A "Correspondence to:" line for the corresponding author's email and institution.
+
+### 3. Finding Google Scholar Profiles
+Search query patterns:
+- `"<Full Author Name>" Google Scholar`
+- `"<Author Name>" site:scholar.google.com`
+- Combine with institution: `"<Author Name>" "<Institution>" Google Scholar`
+
+Profile URL pattern: `https://scholar.google.com/citations?user={USER_ID}&hl=en`
+
+### 4. Verifying Affiliations
+- Extract the *exact* affiliation string as it appears in the paper.
+- Include all institutions if multiple are listed.
+- Include department-level information when provided (e.g., "Department of Computer Science").
+- Do not abbreviate unless the paper does.
+
+## Concurrent Search Strategy
+When researching multiple items (e.g., 6 papers):
+1. Launch all initial web searches for "first author" in parallel.
+2. From results, identify the most promising PDF source URLs for each.
+3. Launch all PDF reads in parallel to extract affiliations.
+4. Launch all Google Scholar profile searches in parallel.
+5. Consolidate results and write to target file.
diff --git a/skills/benchmark_skills/toolathlon/multi-traveler-train-coordination/SKILL.md b/skills/benchmark_skills/toolathlon/multi-traveler-train-coordination/SKILL.md
new file mode 100644
index 0000000..1590e15
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-traveler-train-coordination/SKILL.md
@@ -0,0 +1,55 @@
+---
+name: multi-traveler-train-coordination
+description: Coordinates train travel for multiple people with synchronization requirements (arriving/departing from different locations but meeting at a common destination with time constraints).
+---
+# Instructions
+
+## 1. Parse User Request
+- Identify all travelers, their departure/return cities, and stations.
+- Extract the destination city and the requirement to arrive at/depart from the same station there.
+- Determine the travel dates (outbound and return) based on relative descriptions (e.g., "next Thursday", "Sunday afternoon") and the **current date**. Use `rail_12306-get-current-date` to get the reference date.
+- Note all time constraints:
+ - Outbound: Earliest departure time (e.g., "after 5 PM").
+ - Return: Time window for departure (e.g., "between 2 PM and 6 PM").
+ - Synchronization: Maximum allowed difference in arrival times at the destination and in departure times from the destination (e.g., "should not exceed 30 minutes").
+- Confirm the required train types (e.g., "direct high-speed trains (高铁) or EMU trains (动车)").
+- The goal is to find **one** valid combination per requested day. Ignore ticket availability. If no combination satisfies all constraints for a day, return `null` for that day.
+
+## 2. Load the Required Output Format
+- Read the format specification from the provided `format.json` file using `filesystem-read_file`. The expected structure is typically a JSON object with keys for each travel day (e.g., `"thursday"`, `"sunday"`), each containing sub-objects for each traveler's route.
+
+## 3. Resolve Station Information
+- For each mentioned station (departure and destination), obtain its official station code.
+ - Use `rail_12306-get-station-code-by-names` for specific station names (e.g., "北京南", "上海虹桥").
+ - For the destination city, use `rail_12306-get-stations-code-in-city` to get codes for all stations in that city (e.g., "曲阜"). This is crucial for finding trains to/from the *same* city station.
+- **Critical**: Use the **official English translations** for station names in the final output (e.g., "Beijing Nan", "Shanghai Hongqiao", "Qufu East").
+
+## 4. Search for Available Trains
+- For the **outbound** date, search for trains from each traveler's departure station to **each** of the destination city's stations.
+ - Apply the `earliestStartTime` filter.
+ - Use `trainFilterFlags: "GD"` to filter for high-speed (G) or bullet (D) trains as required.
+- For the **return** date, search for trains from **each** of the destination city's stations to each traveler's return station.
+ - Apply both `earliestStartTime` and `latestStartTime` filters for the specified window.
+
+## 5. Find Synchronized Combinations
+- **Arrival Synchronization (Outbound)**:
+ 1. Group search results by the *destination station* in the target city.
+ 2. For each destination station, find pairs of trains (one for each traveler) where the absolute difference in their arrival times is ≤ the allowed limit (e.g., 30 minutes).
+- **Departure Synchronization (Return)**:
+ 1. Group search results by the *departure station* in the target city.
+ 2. For each departure station, find pairs of trains (one for each traveler) where the absolute difference in their departure times is ≤ the allowed limit.
+- The arrival and departure stations in the destination city do **not** have to be the same.
+- Select **one** valid pair for the outbound journey and **one** valid pair for the return journey. If multiple exist, choose any.
+
+## 6. Format and Output Results
+- Construct a JSON object strictly adhering to the loaded `format.json` schema.
+- Populate it with the selected train details: train number, departure station, arrival station, departure time, arrival time. **Use official English station names**.
+- If no valid combination is found for a day, set its value to `null`.
+- Write the final JSON object to the specified output file (e.g., `train-ticket-plan.json`) using `filesystem-write_file`.
+- Optionally, read the file back to verify and provide a summary to the user.
+- Conclude the task with `local-claim_done`.
+
+## Key Triggers & Handling
+- This skill activates when a user request involves coordinating travel for **multiple people** with **synchronization constraints** (time differences, same station) to/from a common destination.
+- Be prepared to handle API errors (e.g., "get cookie failed", "City not found") with retries or alternative queries.
+- The core challenge is the combinatorial matching under time constraints, not checking seat availability.
diff --git a/skills/benchmark_skills/toolathlon/multi-traveler-train-coordination/references/format_example.json b/skills/benchmark_skills/toolathlon/multi-traveler-train-coordination/references/format_example.json
new file mode 100644
index 0000000..e2e118b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-traveler-train-coordination/references/format_example.json
@@ -0,0 +1,34 @@
+{
+ "thursday": {
+ "bj2qf": {
+ "train number": "G385",
+ "departure station": "Beijing Nan",
+ "arrival station": "Qufu East",
+ "departure time": "18:44",
+ "arrival time": "21:26"
+ },
+ "sh2qf": {
+ "train number": "G162",
+ "departure station": "Shanghai Hongqiao",
+ "arrival station": "Qufu East",
+ "departure time": "17:46",
+ "arrival time": "21:31"
+ }
+ },
+ "sunday": {
+ "qf2bj": {
+ "train number": "G128",
+ "departure station": "Qufu East",
+ "arrival station": "Beijing Nan",
+ "departure time": "15:03",
+ "arrival time": "17:22"
+ },
+ "qf2sh": {
+ "train number": "G1227",
+ "departure station": "Qufu East",
+ "arrival station": "Shanghai Hongqiao",
+ "departure time": "15:01",
+ "arrival time": "18:48"
+ }
+ }
+}
diff --git a/skills/benchmark_skills/toolathlon/multi-traveler-train-coordination/references/key_constraints.md b/skills/benchmark_skills/toolathlon/multi-traveler-train-coordination/references/key_constraints.md
new file mode 100644
index 0000000..c3dc67b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/multi-traveler-train-coordination/references/key_constraints.md
@@ -0,0 +1,15 @@
+# Core Constraints to Enforce
+
+1. **Traveler Specifics**: Each traveler has defined origin and return stations.
+2. **Destination City Coordination**:
+ * All travelers must arrive at the **same station** within the destination city on the outbound leg.
+ * All travelers must depart from the **same station** within the destination city on the return leg.
+ * The arrival and departure stations in the destination city can be different.
+3. **Time Windows**:
+ * Outbound: Departure must be after a specified time (e.g., > 17:00).
+ * Return: Departure must be within a specified window (e.g., between 14:00 and 18:00).
+4. **Synchronization Tolerance**:
+ * Arrival times at the destination must be within ΔT (e.g., ≤ 30 minutes).
+ * Departure times from the destination must be within ΔT (e.g., ≤ 30 minutes).
+5. **Train Type**: Typically restricted to high-speed (G) or bullet (D) trains.
+6. **Output**: Find **one** valid combination per day. Return `null` for a day if no combination meets all constraints.
diff --git a/skills/benchmark_skills/toolathlon/no-trajectory-analyzer/SKILL.md b/skills/benchmark_skills/toolathlon/no-trajectory-analyzer/SKILL.md
new file mode 100644
index 0000000..df12105
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/no-trajectory-analyzer/SKILL.md
@@ -0,0 +1,25 @@
+---
+name: no-trajectory-analyzer
+description: When the execution trajectory is empty or missing, this skill provides a fallback analysis to identify potential missing data, suggest common skill patterns, and generate placeholder metadata for review.
+---
+# Instructions
+
+This skill activates when the `trajectory` array provided to the agent is empty (`[]`). Its purpose is to handle this specific error state by analyzing the context to understand why the trajectory is missing and to generate actionable, structured output for the user or a downstream process.
+
+## 1. Analyze the Request Context
+Examine the user's request and the broader conversation context to hypothesize why a trajectory might be missing. Consider these common scenarios:
+* **New Skill Request:** The user is asking for a brand new skill to be created from a description.
+* **Data Error:** The trajectory data failed to load or was corrupted.
+* **Ambiguous Instruction:** The user's request was too vague to generate a concrete execution path.
+* **Tool Failure:** A previous step that should have produced a trajectory did not execute correctly.
+
+**Output a brief, clear hypothesis** as the first part of your response.
+
+## 2. Generate Diagnostic & Suggestions
+Based on your hypothesis, provide structured suggestions. Use the bundled `generate_placeholder.py` script to ensure consistent formatting.
+1. **Run the script** with the skill name and description from the request (or use defaults if not provided).
+2. **Integrate the script's output** (a placeholder skill structure) into your response.
+3. **Append a "Next Steps" section** with 2-3 specific, actionable recommendations for the user (e.g., "Please provide an example execution trajectory," "Clarify the skill's primary action," "Verify the data source for the trajectory.").
+
+## 3. Present Final Output
+Structure your final response as follows:
diff --git a/skills/benchmark_skills/toolathlon/no-trajectory-analyzer/references/common_patterns.md b/skills/benchmark_skills/toolathlon/no-trajectory-analyzer/references/common_patterns.md
new file mode 100644
index 0000000..f3b90ef
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/no-trajectory-analyzer/references/common_patterns.md
@@ -0,0 +1,28 @@
+# Common Skill Patterns for Trajectory Inference
+
+When a trajectory is missing, the requested skill often fits one of these high-level patterns. Use this list to inform suggestions and placeholder generation.
+
+## 1. Data Fetcher & Transformer
+* **Pattern:** Fetch data from a source (API, file, database), apply a transformation (filter, aggregate, convert format), and output results.
+* **Typical Steps:** Validate input → Connect to source → Fetch data → Apply logic/transforms → Format output → Handle errors.
+* **Example Skills:** `api-poller`, `csv-to-json-converter`, `database-snapshot`.
+
+## 2. Content Analyzer & Summarizer
+* **Pattern:** Take a body of text or structured data, analyze it for key information, and produce a summary, extract key points, or answer specific questions.
+* **Typical Steps:** Parse input → Extract entities/themes → Apply analysis rules/LLM call → Synthesize findings → Present summary.
+* **Example Skills:** `document-summarizer`, `sentiment-analyzer`, `meeting-minutes-generator`.
+
+## 3. Orchestrator & Sequencer
+* **Pattern:** Coordinate the execution of other skills or tools in a specific sequence, passing data between steps.
+* **Typical Steps:** Receive parameters → Validate sequence → Execute step 1 → Pass result to step 2 → ... → Aggregate final results.
+* **Example Skills:** `multi-step-data-pipeline`, `validation-workflow`, `deployment-automator`.
+
+## 4. Generator & Creator
+* **Pattern:** Create new content or structured data based on templates, rules, or prompts.
+* **Typical Steps:** Load template/assets → Apply variables/rules → Generate content → Validate output → Deliver.
+* **Example Skills:** `report-generator`, `code-skeleton-builder`, `email-template-filler`.
+
+## 5. Validator & Checker
+* **Pattern:** Check input data or system state against rules, schemas, or expectations and return a pass/fail status with details.
+* **Typical Steps:** Receive target → Load validation rules → Perform checks → Compile violations → Return report.
+* **Example Skills:** `config-validator`, `compliance-checker`, `syntax-linter`.
diff --git a/skills/benchmark_skills/toolathlon/notion-job-tracker-query/SKILL.md b/skills/benchmark_skills/toolathlon/notion-job-tracker-query/SKILL.md
new file mode 100644
index 0000000..e0d7542
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/notion-job-tracker-query/SKILL.md
@@ -0,0 +1,60 @@
+---
+name: notion-job-tracker-query
+description: When the user needs to query and retrieve job application data from a Notion database with specific filtering criteria. This skill searches for Notion pages/databases by name, queries job tracker databases with status filters, and extracts structured job application information including company details, positions, salaries, locations, and contact information. Triggers include 'Notion database', 'job tracker', 'query jobs', 'filter by status', or when working with structured job application data.
+---
+# Instructions
+
+## Primary Objective
+Query a Notion database named "Job Tracker" to find job application entries that match specific user-defined criteria, extract structured information, and optionally perform follow-up actions (like sending emails or updating statuses).
+
+## Core Workflow
+
+### 1. Locate the Target Database
+- Use the `notion-API-post-search` tool to search for pages/databases containing "Job Finder" or "Job Tracker".
+- **Important**: Do not filter by object type (`"filter": {"property":"object","value":"page"}`) in the initial search, as this may exclude databases. Search broadly first.
+- Identify the database with title "Job Tracker". Note its `database_id`.
+
+### 2. Query the Database with Filters
+- Use the `notion-API-post-database-query` tool with the identified `database_id`.
+- Apply filters based on user requirements. Common filters include:
+ - `Status` (e.g., `{"property":"Status","select":{"equals":"Checking"}}`)
+ - `Flexibility` (e.g., `{"property":"Flexibility","select":{"equals":"On-site"}}`)
+ - `Position` (text/URL field containing "Software Engineer" or "Software Manager" - filtering logic may need to be applied post-query).
+- Retrieve all pages (results) from the query.
+
+### 3. Extract and Process Structured Data
+For each page (job entry) in the results, extract the following properties. Refer to the example trajectory for exact property names and types:
+- `Company` (title property)
+- `Position` (url property, treat as text)
+- `Status` (select property)
+- `Salary Range` (rich_text property) - **Parse the minimum salary value** (e.g., extract the first number from "$4200 - $4800/mo").
+- `Location` (rich_text property)
+- `Email` (rich_text property)
+- `In-touch Person` (rich_text property)
+- `Flexibility` (select property)
+
+**Data Parsing Script**: For consistent and error-proof parsing of complex fields like `Salary Range`, use the bundled script `scripts/parse_job_data.py`.
+
+### 4. Apply Advanced Criteria (Geographic, Salary)
+If criteria involve geographic distance:
+1. Obtain reference coordinates (e.g., for "UCLA") using `google_map-maps_geocode`.
+2. For each job entry's `Location`, geocode it using the same tool.
+3. Calculate the distance. Use the bundled script `scripts/calculate_distance.py` for accurate haversine distance calculation.
+4. Filter entries where distance <= specified radius (e.g., 500 km).
+
+If criteria involve numeric thresholds (e.g., minimum salary > $3000):
+- Use the parsed minimum salary from Step 3 for comparison.
+
+### 5. Execute Follow-up Actions (If Required)
+Based on the user's goal (e.g., "send application emails"):
+1. For each qualifying entry, construct a personalized email using a template.
+ - Template: `"Hi {Company Name}, I am Janet Mendoza, I want to apply for the {Position} position..."`
+ - Subject: `"Job Application for {Position}"`
+2. Send the email using `emails-send_email`.
+3. Update the entry's `Status` in Notion to "Applied" using `notion-API-patch-page`.
+
+## Key Considerations
+- **Schema Variability**: Notion database property names and types may differ. Use the initial query results to inspect the schema before writing extraction logic.
+- **Error Handling**: When parsing salaries or geocoding, some entries may have malformed data. Log warnings and skip those entries.
+- **Batching**: For large result sets, consider processing in batches to avoid timeouts.
+- **Confirmation**: Before sending emails or updating many records, summarize the qualifying entries for user confirmation.
diff --git a/skills/benchmark_skills/toolathlon/notion-job-tracker-query/references/email_template.md b/skills/benchmark_skills/toolathlon/notion-job-tracker-query/references/email_template.md
new file mode 100644
index 0000000..e537287
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/notion-job-tracker-query/references/email_template.md
@@ -0,0 +1,13 @@
+# Job Application Email Template
+
+Use this template when the user requests to send application emails for qualifying job entries.
+
+## Template Variables
+- `{Company Name}`: Extracted from the `Company` property.
+- `{Position}`: Extracted from the `Position` property.
+- `{Your Name}`: The applicant's name (e.g., "Janet Mendoza"). This should be provided by the user or configured.
+
+## Email Structure
+**Subject**: `Job Application for {Position}`
+
+**Body**:
diff --git a/skills/benchmark_skills/toolathlon/notion-job-tracker-query/references/notion_schema_example.md b/skills/benchmark_skills/toolathlon/notion-job-tracker-query/references/notion_schema_example.md
new file mode 100644
index 0000000..f9e078a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/notion-job-tracker-query/references/notion_schema_example.md
@@ -0,0 +1,17 @@
+# Notion "Job Tracker" Database Schema Example
+
+Based on the execution trajectory, the target database has the following properties. Use this as a reference, but always verify the actual schema from the API response.
+
+## Property Map
+| Property Name (UI) | Property ID (API) | Type (API) | Description & Notes |
+| :--- | :--- | :--- | :--- |
+| **Company** | `title` | `title` | The primary title property. Contains company name. |
+| **Position** | `%60fZ%5B` | `url` | Stored as a URL string (e.g., "Software Engineer"). Treat as plain text. |
+| **Status** | `a~~K` | `select` | Options: `Checking`, `Applied`, `Interviewing`, `Rejected`, `Pass`, `Accepted`. |
+| **Salary Range** | `r_wX` | `rich_text` | Text like "$4200 - $4800/mo". Requires parsing for numeric values. |
+| **Location** | `WvHp` | `rich_text` | City, Country (e.g., "Los Angeles, US"). Needs geocoding for distance calc. |
+| **Email** | `%5E~%3B%40` | `rich_text` | Contact email address. |
+| **In-touch Person** | `toSv` | `rich_text` | Name of the contact person. |
+| **Flexibility** | `zSQ%3F` | `select` | Options: `Remote`, `On-site`. |
+
+## API Response Structure for a Page
diff --git a/skills/benchmark_skills/toolathlon/notion-page-content-updater/SKILL.md b/skills/benchmark_skills/toolathlon/notion-page-content-updater/SKILL.md
new file mode 100644
index 0000000..9a69f63
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/notion-page-content-updater/SKILL.md
@@ -0,0 +1,45 @@
+---
+name: notion-page-content-updater
+description: When the user needs to update or populate a Notion page with structured content extracted from documents or data sources. This skill handles the complete workflow of 1) Searching for and locating specific Notion pages by name, 2) Extracting content from source documents (Word/PDF/text files), 3) Analyzing document structure to identify relevant sections, 4) Mapping extracted content to Notion page sections, 5) Modifying page blocks (adding, deleting, updating paragraphs, lists, and headings), and 6) Organizing information in appropriate Notion formats (bullet lists, paragraphs, structured sections). Use this skill when users request to 'update a Notion page with information from a document' or need to synchronize content between documents and Notion workspaces.
+---
+# Skill: Notion Page Content Updater
+
+## Purpose
+Update a specified Notion page with structured content extracted from a source document (e.g., Word, PDF, text). This skill automates the end-to-end process of finding the page, reading the document, parsing its content, and updating the Notion page's blocks accordingly.
+
+## Core Workflow
+Follow these steps precisely:
+
+1. **Clarify Request & Identify Target:** Confirm the exact name of the Notion page to update and the path/filename of the source document.
+2. **Locate the Notion Page:**
+ * Use `notion-API-post-search` with the exact page name. If no results, search more broadly (e.g., partial name) or use an empty query `{}` to list all pages/databases.
+ * From the search results, identify the correct page by its `title` property. Note its `id`.
+3. **Extract Source Content:**
+ * Use the appropriate tool (`word-get_document_text`, `pdf-get_document_text`, `filesystem-read_file`) to read the source document's full text.
+4. **Analyze Page Structure & Plan Updates:**
+ * Retrieve the current page structure using `notion-API-get-block-children` with the page ID.
+ * Analyze the returned blocks to identify the target sections (e.g., headings for "About Me", "Paintings"). Note the block IDs that come **immediately before** where new content should be inserted.
+ * Parse the extracted document text to identify the relevant content for each target section.
+5. **Execute Page Updates (Section by Section):**
+ * **For placeholder content:** If a section contains placeholder text (e.g., `[Birth, Your education...]`), delete the old block using `notion-API-delete-a-block`.
+ * **To add new content after a heading/block:** Use `notion-API-patch-block-children`. Specify the page ID as `block_id`, use the `after` parameter with the ID of the heading block, and provide the new content in the `children` array.
+ * **Structure the content appropriately:** Use `paragraph` blocks for descriptive text and `bulleted_list_item` blocks for lists.
+ * Process one major section at a time (e.g., About Me, then Paintings, then Workshop, etc.).
+6. **Verify & Conclude:** After all updates, retrieve the page children again to confirm the changes. Provide a clear summary of what was updated.
+
+## Critical Implementation Notes
+* **Block Update Limitation:** The `notion-API-update-a-block` endpoint has very limited functionality and often cannot be used to change a block's type or rich text content. The primary method for adding content is `patch-block-children`.
+* **Content Chunking:** Notion API calls have size limits. Break long document text into logical paragraphs when creating `children` arrays.
+* **Special Characters:** Escape quotation marks and newlines (`\n`) properly in JSON payloads for block content.
+* **Error Handling:** If a search finds multiple pages with similar names, ask the user for clarification. If a section heading doesn't exist on the target page, you may need to create it first.
+
+## Required Tools
+* `notion-API-post-search`
+* `notion-API-get-block-children`
+* `notion-API-patch-block-children`
+* `notion-API-delete-a-block`
+* `word-get_document_text` / `pdf-get_document_text` / `filesystem-read_file`
+* `local-claim_done`
+
+## Example Trajectory Pattern
+The provided trajectory is a canonical example. Follow its pattern: search, extract, analyze structure, then sequentially update sections using `patch-block-children` after relevant headings.
diff --git a/skills/benchmark_skills/toolathlon/notion-page-content-updater/references/notion_block_structure.md b/skills/benchmark_skills/toolathlon/notion-page-content-updater/references/notion_block_structure.md
new file mode 100644
index 0000000..34df6f2
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/notion-page-content-updater/references/notion_block_structure.md
@@ -0,0 +1,6 @@
+# Notion Block Structure Reference
+
+## Common Block Types for Content Updates
+Use these block types in the `children` array of `notion-API-patch-block-children`.
+
+### Paragraph
diff --git a/skills/benchmark_skills/toolathlon/notion-project-notification-manager/SKILL.md b/skills/benchmark_skills/toolathlon/notion-project-notification-manager/SKILL.md
new file mode 100644
index 0000000..ae0e14e
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/notion-project-notification-manager/SKILL.md
@@ -0,0 +1,32 @@
+---
+name: notion-project-notification-manager
+description: When the user needs to update Notion pages with project status, completion notifications, or resource links, this skill searches for specific Notion pages, adds content updates, and posts comments or notifications. It can locate pages by title, add formatted text, and include external resource links. Triggers include requests to 'write on Notion page', 'add comment to page', 'update Notion', or notifications about task completion.
+---
+# Skill: Notion Project Notification Manager
+
+## Primary Objective
+Search for a specified Notion page and update it with a status notification and/or a link to an external resource (e.g., a Google Sheet).
+
+## Core Workflow
+1. **Parse the Request:** Identify the target Notion page name/title and the specific update content (notification text and resource URL) from the user's request.
+2. **Locate the Page:** Use the Notion Search API to find the page by its title. Filter the search to object type `"page"` for accuracy.
+3. **Prepare the Update:** Format the update content. This typically involves:
+ * A clear status notification (e.g., "Monthly market data is ready. The reporting team can view it directly").
+ * The external resource link on a new line (e.g., `Google Sheet : {url}`).
+4. **Execute the Update:** Append the formatted content to the target Notion page. Use the appropriate Notion API endpoint for adding blocks or text to a page.
+
+## Key Instructions & Logic
+* **Search Specificity:** Always use a filter `{"property":"object","value":"page"}` when searching for a page by name to avoid confusion with databases.
+* **Content Formatting:** Structure the update clearly. Place the status notification first, followed by the resource link on a separate line.
+* **Error Handling:** If the initial search returns multiple results or no results, refine the search query or ask the user for clarification.
+* **Idempotency:** The skill should be able to run multiple times without causing duplicate content if the same notification is specified. Consider checking existing page content if necessary.
+
+## Common Triggers
+* "Write on the [Page Name] Notion page..."
+* "Add a comment to the [Page Name] page stating..."
+* "Update the Notion page for [Project] with a link to..."
+* "Notify the team on Notion that [Task] is complete."
+
+## Notes
+* This skill focuses on the Notion update operation. The creation or population of external resources (like Google Sheets) is handled by other skills or prior steps in the agent's workflow.
+* The example trajectory shows the final step of notifying a "Quant Research" page after data has been compiled elsewhere.
diff --git a/skills/benchmark_skills/toolathlon/nutritional-intake-analyzer/SKILL.md b/skills/benchmark_skills/toolathlon/nutritional-intake-analyzer/SKILL.md
new file mode 100644
index 0000000..aae5d56
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/nutritional-intake-analyzer/SKILL.md
@@ -0,0 +1,53 @@
+---
+name: nutritional-intake-analyzer
+description: Analyzes dietary intake against fitness/nutritional guidelines for fitness planning, fat loss, or muscle gain goals. Reads body metrics, extracts meal ingredients, retrieves nutritional data, calculates expected intake based on guidelines, compares actual vs expected values, and generates formatted assessment reports.
+---
+# Instructions
+
+## Core Workflow
+When the user requests a nutritional analysis of their meals against fitness guidelines, follow this exact sequence:
+
+1. **Read Input Files:** Use `filesystem-read_multiple_files` to read:
+ * `body.md` (contains height, weight, gender)
+ * `cuisine.md` or similar (contains meal list/recipe names)
+ * `health_guide.md` or similar (contains fitness dietary ratios)
+ * `format.md` (contains the exact output format specification)
+
+2. **Read Nutritional Database:** Use `excel-get_workbook_metadata` and `excel-read_data_from_excel` to load the nutritional composition spreadsheet (e.g., `Nutrition.xlsx`). Parse it into a lookup dictionary mapping ingredient names to their per-100g nutrient values (focus on carbohydrates and protein).
+
+3. **Get Recipe Details:** For each dish name listed in the meal file, use `howtocook-mcp_howtocook_getRecipeById` to fetch the detailed recipe, including ingredient lists and quantities.
+
+4. **Calculate Expected Intake:**
+ * Parse the user's body metrics (height, weight, gender, goal phase).
+ * Calculate BMI: `weight_kg / (height_m ** 2)`.
+ * Consult the fitness guidelines (`health_guide.md`) to determine the appropriate `g/kg` ratios for carbohydrates and protein based on:
+ * Goal (Muscle Gain / Fat Loss)
+ * Phase (Initial / Late)
+ * Gender
+ * Training vs. Rest Day (note: rest day carb intake is typically 0.5 g/kg lower)
+ * BMI adjustments (for large-bodied obese individuals, use reduced ratios).
+ * Calculate expected daily intake ranges/targets:
+ * Carbs (g): `weight_kg * carb_g_per_kg_range`
+ * Protein (g): `weight_kg * protein_g_per_kg_target`
+
+5. **Calculate Actual Intake:**
+ * For each recipe, map its ingredients and estimated consumed quantities to the nutritional database.
+ * **Handle estimation:** When ingredient quantities are given as ranges (e.g., "1.5-2g"), use the average. For cooking oils, estimate absorbed amounts (e.g., 30ml from 500ml used for frying). For coatings like starch, estimate the portion that adheres to the food.
+ * Sum the carbohydrates and protein from all meals to get the total daily actual intake.
+
+6. **Perform Assessment:** Compare actual vs. expected values using the assessment logic defined in `format.md`:
+ * **For a range (Carbohydrates):**
+ * `Below expectations`: Actual < 95% of the range's lower bound.
+ * `Excessive intake`: Actual > 105% of the range's upper bound.
+ * `Meets expectations`: Otherwise.
+ * **For a target with tolerance (Protein):** Apply the ±10g tolerance to create an effective range, then use the same 95%/105% rule.
+
+7. **Generate Output:** Create a new file (e.g., `analysis.md`). Write the analysis using the **exact format** specified in `format.md`, including the required heading, assessment labels, expected values, actual values, and the "|" separator.
+
+8. **Verify and Conclude:** Read back the generated file to confirm correctness, then provide a final summary to the user.
+
+## Critical Notes
+* **Strict Format Adherence:** The output in `analysis.md` must match the structure in `format.md` character-for-character, including the heading `# Today's Meal Nutritional Analysis`.
+* **BMI-Based Adjustments:** Always check BMI and apply the special reduced intake ratios for "large-bodied obese individuals" (BMI > 28 or > 32) as specified in the guidelines.
+* **Ingredient Mapping:** Be prepared for ingredient name mismatches between the recipe and nutrition database. Use partial matching or manual lookup if necessary.
+* **Quantity Estimation:** Explicitly state your estimation logic when precise consumption amounts are not clear from the recipe (e.g., "assumed 30ml of oil was absorbed").
diff --git a/skills/benchmark_skills/toolathlon/nutritional-intake-analyzer/references/assessment_logic.md b/skills/benchmark_skills/toolathlon/nutritional-intake-analyzer/references/assessment_logic.md
new file mode 100644
index 0000000..73e34ed
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/nutritional-intake-analyzer/references/assessment_logic.md
@@ -0,0 +1,60 @@
+# Nutritional Assessment Logic
+
+## Input Requirements
+1. **Body Metrics**: Height (cm), Weight (kg), Gender, Goal (Muscle Gain/Fat Loss), Phase (Initial/Late)
+2. **Fitness Guidelines**: Document specifying `g/kg` intake ratios for different scenarios.
+3. **Meal List**: List of dishes consumed.
+4. **Recipe Details**: Ingredient lists with quantities for each dish.
+5. **Nutrition Database**: Per-100g nutrient values for ingredients.
+
+## Calculation Steps
+
+### Step 1: Determine User Context
+1. Calculate BMI: `weight_kg / (height_meters^2)`
+2. Identify:
+ - Goal: Muscle Gain / Fat Loss
+ - Phase: Initial / Late
+ - Day Type: Training / Rest
+ - Obesity Category: BMI > 28, BMI > 32, or Normal
+
+### Step 2: Look Up Target Ratios
+Consult the fitness guidelines table. Example structure:
+
+| Goal | Gender | Phase | Carbs (g/kg) | Protein (g/kg) | Notes |
+|------------|--------|---------|--------------|----------------|--------------------------------|
+| Fat Loss | Male | Initial | 2.5-3.0 | 1.5 | Rest day: reduce carbs by 0.5g/kg |
+| Fat Loss | Male | Initial | 2.4-2.7 | 1.2 | **If BMI > 28** |
+| Fat Loss | Male | Initial | 2.0-2.4 | 1.0 | **If BMI > 32** |
+
+### Step 3: Calculate Expected Intake
+- Expected Carbs (g) = `weight_kg × carb_g_per_kg_range`
+- Expected Protein (g) = `weight_kg × protein_g_per_kg_target`
+
+### Step 4: Calculate Actual Intake
+For each dish:
+1. Map each ingredient to the nutrition database.
+2. Convert quantity to grams.
+3. Calculate nutrient contribution: `(quantity_g / 100) × nutrient_per_100g`
+4. Sum across all dishes.
+
+**Important Estimation Rules:**
+- For quantity ranges: Use the average.
+- For cooking oil: Estimate absorbed amount (e.g., 30ml from 500ml frying oil).
+- For coatings (starch, flour): Estimate adhered portion.
+- Ignore trace ingredients (garnishes, spices) if nutritional data is unavailable.
+
+### Step 5: Perform Assessment
+
+#### For Carbohydrates (Range)
+- **Below expectations**: `actual < 0.95 × expected_min`
+- **Excessive intake**: `actual > 1.05 × expected_max`
+- **Meets expectations**: Otherwise
+
+#### For Protein (Target with Tolerance)
+1. Apply tolerance: Effective range = `target ± tolerance` (typically ±10g)
+2. **Below expectations**: `actual < 0.95 × (target - tolerance)`
+3. **Excessive intake**: `actual > 1.05 × (target + tolerance)`
+4. **Meets expectations**: Otherwise
+
+## Output Format
+Strictly follow the template:
diff --git a/skills/benchmark_skills/toolathlon/nutritional-intake-analyzer/references/ingredient_mapping_guide.md b/skills/benchmark_skills/toolathlon/nutritional-intake-analyzer/references/ingredient_mapping_guide.md
new file mode 100644
index 0000000..9282ba3
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/nutritional-intake-analyzer/references/ingredient_mapping_guide.md
@@ -0,0 +1,49 @@
+# Ingredient Mapping Guide
+
+## Common Challenges & Solutions
+
+### 1. Name Variations
+Ingredients may have different names in recipes vs. nutrition databases.
+
+| Recipe Name | Database Name | Action |
+|-------------|---------------|--------|
+| 瘦猪肉 | 瘦肉(猪肉) | Use partial matching or manual lookup |
+| 植物油 | 植物油 | Exact match |
+| 小葱 | 葱 | Map to closest available |
+| 料洒 | (Not in DB) | Skip if negligible, estimate if significant |
+
+### 2. Quantity Interpretation
+
+**Explicit Quantities:**
+- "西红柿 180g" → Use 180g
+- "鸡蛋 1个 (约50g)" → Use 50g
+
+**Ranges:**
+- "盐 1.5-2g" → Use average: 1.75g
+- "糖 0-2g" → Use average: 1g
+
+**Volumetric Measures:**
+- "植物油 15g" (already in grams) → Use 15g
+- "植物油 15ml" → Convert using density: 15ml × 0.92g/ml = 13.8g
+- "蒸鱼豉油 10g" → Use 10g
+
+**Estimated Consumption:**
+- Frying oil: Recipe uses 500ml, assume ~30ml (27.6g) is absorbed.
+- Coating starch: Recipe uses 100g, assume ~60g adheres to food.
+
+### 3. Missing Ingredients
+If an ingredient is not in the nutrition database:
+1. Check for close alternatives (e.g., "鲜香菇" → "蟹味菇")
+2. If negligible (garnishes, spices < 5g), skip.
+3. If significant, make a reasonable estimate based on similar ingredients.
+
+## Standard Conversions
+- 1个鸡蛋 ≈ 50g
+- 1个西红柿 ≈ 180g
+- 1根胡萝卜 ≈ 150g
+- 1个中等苹果 ≈ 200g
+- 1根中等香蕉 ≈ 120g
+- 植物油: 1ml ≈ 0.92g
+- 酸奶/牛奶: 1ml ≈ 1.03-1.05g
+- 蒸鱼豉油: 1ml ≈ 1.1g
+- 香醋: 1ml ≈ 1.05g
diff --git a/skills/benchmark_skills/toolathlon/paper-implementation-finder/SKILL.md b/skills/benchmark_skills/toolathlon/paper-implementation-finder/SKILL.md
new file mode 100644
index 0000000..cb7c07d
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/paper-implementation-finder/SKILL.md
@@ -0,0 +1,38 @@
+---
+name: paper-implementation-finder
+description: Finds the most popular unofficial GitHub implementation for a given academic paper (PDF) and updates a JSON file with the repository URL.
+---
+# Instructions
+
+## Objective
+When a user provides a PDF of an academic paper (typically without an official code repository) and a `result.json` file, find the most popular (by star count) unofficial implementation on GitHub and update the JSON file with the repository URL.
+
+## Core Workflow
+1. **Extract Paper Information:**
+ * Use `pdf-tools-get_pdf_info` to get basic metadata (e.g., page count).
+ * Use `pdf-tools-read_pdf_pages` to read the first few pages (e.g., 1-3) to identify the paper's **title**, **authors**, and **key technical terms** (e.g., "Mixture-of-Depths").
+
+2. **Formulate GitHub Search Query:**
+ * Construct a search query using the most distinctive terms from the paper's title and abstract. Prioritize the paper's title or a unique acronym (e.g., "Mixture-of-Depths transformer").
+ * **Avoid overly generic terms** that will return irrelevant results.
+
+3. **Search and Identify the Target Repository:**
+ * Use `github-search_repositories` with the formulated query.
+ * Analyze the search results (`items`).
+ * **Filtering Logic:** The target repository must be an **unofficial implementation** of the specific paper provided. Check repository `description` and `topics` for clear mentions of the paper.
+ * **Selection Criteria:** Among the filtered repositories, select the one with the highest `stargazers_count`. This is the "most popular" implementation.
+ * **Edge Case:** If the highest-starred repo is for a *different* paper (e.g., mentions the technique only as a feature), proceed to the next eligible repo.
+
+4. **Update the Result File:**
+ * Read the existing `result.json` file using `filesystem-read_file` to understand its structure.
+ * Write the selected repository's `html_url` into the `result.json` file using `filesystem-write_file`. Maintain the existing JSON structure (e.g., `{"URL": "https://github.com/..."}`).
+
+5. **Verification and Completion:**
+ * Optionally, read the updated `result.json` to confirm the write was successful.
+ * Provide a final summary to the user, stating the paper identified, the repository selected, and its star count.
+ * Claim completion with `local-claim_done`.
+
+## Key Considerations
+* **Accuracy over Speed:** It is more important to find the *correct* unofficial implementation than the first one listed. Carefully read repository descriptions.
+* **Clear Communication:** Explain your reasoning to the user when selecting between multiple candidate repositories.
+* **File Paths:** The skill assumes the PDF and `result.json` are provided in a known workspace directory (e.g., `/workspace/dumps/workspace/`). Use the paths provided in the user's request or context.
diff --git a/skills/benchmark_skills/toolathlon/pdf-metadata-extractor/SKILL.md b/skills/benchmark_skills/toolathlon/pdf-metadata-extractor/SKILL.md
new file mode 100644
index 0000000..fb60cc6
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/pdf-metadata-extractor/SKILL.md
@@ -0,0 +1,58 @@
+---
+name: pdf-metadata-extractor
+description: Extracts specific metadata from PDF documents, particularly academic papers, including author information, affiliations, and institutional details. This skill is triggered by requests involving PDF analysis, academic paper processing, or when precise information extraction from document headers/footers is required. It handles PDF parsing, text extraction from specific pages, and structured data retrieval from academic document formats.
+---
+# Instructions for PDF Metadata Extraction
+
+## Primary Use Case
+This skill is designed to systematically extract first author metadata from academic papers in PDF format. The core workflow involves:
+1. Locating and reading an Excel file containing a list of paper titles.
+2. Searching for and downloading the corresponding PDFs.
+3. Parsing the first pages of the PDFs to extract the first author's full name and their complete institutional affiliation.
+4. Searching for the author's Google Scholar profile.
+5. Writing all extracted data back to the original Excel file.
+
+## Core Workflow
+
+### 1. Locate and Inspect the Target Excel File
+- Use the `terminal-run_command` tool to find `.xlsx` or `.xls` files within the `/workspace/dumps/workspace` directory.
+- **Security Note:** Do not use file paths outside the allowed directory (e.g., `/dev/null`).
+- Use `excel-get_workbook_metadata` to inspect the file's structure (sheet names, used ranges).
+- Use `excel-read_data_from_excel` to read the paper titles from the first column (typically starting at cell A2).
+
+### 2. Search for and Acquire Paper PDFs
+- For each paper title, perform a web search using `local-web_search` to find the PDF. Common sources include:
+ - OpenReview (`openreview.net/pdf?id=`)
+ - arXiv (`arxiv.org/pdf/`)
+ - Conference proceedings (e.g., `proceedings.mlr.press`).
+- Prioritize direct PDF links. If a direct link is not found in search results, look for a paper page (e.g., OpenReview forum) and construct the PDF URL (often by appending `/pdf` to the page URL).
+
+### 3. Extract Metadata from PDFs
+- Use `pdf-tools-read_pdf_pages` to read the **first 1-2 pages** of each acquired PDF. This is where author and affiliation information is almost always located.
+- **Parsing Strategy:**
+ - **First Author Name:** Identify the first listed author in the author block, typically following the title and preceding the abstract. Extract their full name as it appears (e.g., "Aaditya K. Singh", "Amber Yijia Zheng*").
+ - **Affiliation:** Extract the complete affiliation string associated with the first author. This often includes the department, university/institution, and sometimes city/country. Capture it exactly as printed, including all listed institutions if multiple are present (e.g., "Gatsby Computational Neuroscience Unit, University College London", "ENSAE, CREST, IP Paris").
+
+### 4. Find Google Scholar Profiles
+- For each extracted first author, perform a targeted web search using `local-web_search` with the query format: `"<First Author Full Name>" Google Scholar profile`.
+- Extract the direct URL to their Google Scholar citations page from the search results (e.g., `https://scholar.google.com/citations?user=...`).
+- If the primary search fails, try a more specific query including their institution (e.g., `"Aaditya K. Singh" University College London Google Scholar`).
+
+### 5. Compile and Write Results
+- Structure the extracted data (First Author, Affiliation, Google Scholar URL) into a list of lists, maintaining the same order as the input paper titles.
+- Use `excel-write_data_to_excel` to write this data back to the original Excel file. The data should start in column B, row 2 (next to the paper titles).
+- Use `excel-read_data_from_excel` to verify the data was written correctly.
+- Finally, present a summary table to the user and call `local-claim_done`.
+
+## Error Handling & Assumptions
+- **Missing PDFs:** If a PDF cannot be found after a reasonable search, note this and proceed with the next paper. Inform the user.
+- **Unclear Author Block:** If the first page parsing does not yield clear author/affiliation data, consider checking the second page or the very end of the PDF (footer).
+- **Multiple "First Authors":** Some papers denote joint first authorship with asterisks (*). Extract the first name in the list that is marked as such or the very first name if no markers are present.
+- **Affiliation Formatting:** Preserve line breaks, commas, and institutional hierarchies as they appear in the PDF. Do not simplify.
+
+## Key Tools Used
+- `terminal-run_command`: File system navigation.
+- `excel-get_workbook_metadata` / `excel-read_data_from_excel` / `excel-write_data_to_excel`: Excel I/O.
+- `local-web_search`: Finding papers and scholar profiles.
+- `pdf-tools-read_pdf_pages`: Core PDF text extraction.
+- `local-claim_done`: Signal task completion.
diff --git a/skills/benchmark_skills/toolathlon/pdf-metadata-extractor/references/academic_pdf_patterns.md b/skills/benchmark_skills/toolathlon/pdf-metadata-extractor/references/academic_pdf_patterns.md
new file mode 100644
index 0000000..5f8d38f
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/pdf-metadata-extractor/references/academic_pdf_patterns.md
@@ -0,0 +1,25 @@
+# Common Patterns in Academic PDF Metadata
+
+## Author & Affiliation Block Locations
+The author and affiliation information is most commonly found in these locations on the first page:
+1. **Directly under the title**, before the abstract.
+2. In a **footer or header** on the first page.
+3. On a **separate title page** (page 1), with the abstract starting on page 2.
+
+## Typical Formatting Cues
+- **Author List:** Names are usually separated by commas, "and", or line breaks. First author is the first name listed.
+- **Affiliation Markers:** Superscript numbers (e.g., `^1`, `^2`) or symbols (e.g., `*`, `†`) next to author names that correspond to numbered affiliation blocks below.
+- **Affiliation Block:** Often prefaced with words like "University of", "Department of", "School of", "Institute for", "Laboratory of", or corporate names (e.g., "Google DeepMind", "Meta FAIR").
+- **Correspondence Line:** Often contains the email and affiliation of the corresponding author, which may be the first author. Look for "Correspondence to:" or "Email:".
+
+## Common PDF Sources & URL Patterns
+- **OpenReview:** `https://openreview.net/pdf?id=<PAPER_ID>`
+- **arXiv:** `https://arxiv.org/pdf/<ARXIV_ID>.pdf`
+- **PMLR (Proceedings of Machine Learning Research):** `https://proceedings.mlr.press/v<VOLUME>/<PAPER_ID>.pdf`
+- **ACL Anthology:** `https://aclanthology.org/<YEAR>.<CONFERENCE>-<VOLUME>.<PAGE>.pdf`
+- **Company/Institutional Repositories:** URLs often contain `/pdf/` or end with `.pdf`.
+
+## Google Scholar Profile Search Tips
+- The most reliable result is usually the direct link: `https://scholar.google.com/citations?user=<UNIQUE_ID>&hl=en`.
+- Profile snippets often contain the author's institutional affiliation and verification status (e.g., "Verified email at ucl.ac.uk").
+- If the exact name yields multiple results, add their institution to the search query.
diff --git a/skills/benchmark_skills/toolathlon/place-locator/SKILL.md b/skills/benchmark_skills/toolathlon/place-locator/SKILL.md
new file mode 100644
index 0000000..c5e6d4a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/place-locator/SKILL.md
@@ -0,0 +1,28 @@
+---
+name: place-locator
+description: When the user needs to find specific places, landmarks, or points of interest based on descriptive names, this skill searches for place information including exact addresses, coordinates, and place details. It's particularly useful for tourist attractions, buildings, or specific venues mentioned in documents. Triggers include queries for 'find the location of', 'where is', or when processing lists of places from documents.
+---
+# Instructions
+
+## Purpose
+This skill locates specific places, landmarks, or points of interest mentioned by the user or found in documents. It retrieves precise addresses, geographic coordinates (latitude/longitude), and other place details (like Place ID, rating, types) to enable downstream tasks like route planning, mapping, or information compilation.
+
+## Core Workflow
+
+1. **Identify Target Places:** Extract the names of places to locate from the user's request. This often involves reading a source document (like `recommendation.md`) to get a list.
+2. **Geocode the Starting Point (if needed):** If the user provides a starting location (e.g., "I am at the University of Pennsylvania Bookstore"), use `maps_geocode` to get its coordinates. This establishes a search center.
+3. **Search for Each Place:** For each place name, use `maps_search_places`. Provide a specific query combining the place name and broader location context (e.g., "ENIAC Penn School of Engineering University of Pennsylvania Philadelphia"). Use the starting point's coordinates and a reasonable radius (e.g., 2000 meters) to constrain the search.
+4. **Handle Ambiguity & Refinement:** If a search returns multiple results or the primary result seems incorrect (e.g., searching for "ENIAC" returns general engineering buildings), you may need to:
+ * Analyze the results to pick the most relevant one based on name and type.
+ * Perform a more specific follow-up search or geocode using a more precise address derived from the context (e.g., "Moore Building, 200 S 33rd St" for ENIAC).
+5. **Compile Location Data:** Create a structured list or table containing for each place: its canonical name, formatted address, latitude, longitude, and place_id. This data is essential for subsequent steps like calculating distances or generating directions.
+
+## Key Considerations
+* **Precision over Recall:** It's more important to find the *correct, specific* location (e.g., the exact building housing the ENIAC exhibit) than to get many general results.
+* **Context is Key:** Use all available context from the conversation and any read documents to formulate precise search queries.
+* **Output for Downstream Use:** The skill's primary output is a clean dataset of coordinates and addresses. Format this data clearly so it can be easily passed to skills like `maps_distance_matrix` or `maps_directions`.
+
+## Common Triggers
+* User asks: "Where is [Place Name]?", "Find the location of...", "I need the address for..."
+* User provides a list of places from a document and needs them located.
+* A task requires geographic coordinates as a prerequisite (e.g., "plan a walking route between these attractions").
diff --git a/skills/benchmark_skills/toolathlon/place-locator/references/place_search_guide.md b/skills/benchmark_skills/toolathlon/place-locator/references/place_search_guide.md
new file mode 100644
index 0000000..643b3f7
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/place-locator/references/place_search_guide.md
@@ -0,0 +1,25 @@
+# Place Search Strategy Guide
+
+## Formulating Effective Queries
+The `maps_search_places` tool is powerful but requires well-structured queries. Follow this pattern:
+
+**`[Specific Place Name] + [Context/Location]`**
+
+* **Good:** `"Benjamin Franklin Statue University of Pennsylvania Philadelphia"`
+* **Good:** `"Fisher Fine Arts Library University of Pennsylvania"`
+* **Better:** `"Moore Building 200 S 33rd St Philadelphia"` (Use when you have a known address from context)
+* **Poor:** `"ENIAC"` (Too vague, likely to return irrelevant results)
+
+## Interpreting Search Results
+1. **Check `types`:** Prefer results with specific types like `tourist_attraction`, `museum`, `library`, `point_of_interest` over generic ones like `establishment`.
+2. **Verify Name Match:** The `name` field should closely match the place you're looking for.
+3. **Use `place_id`:** This unique identifier is crucial for subsequent API calls (e.g., getting detailed place info or photos).
+
+## Handling Common Scenarios
+* **Multiple Listings:** If a search for "College Hall" returns many results, look for the one with the address closest to your known area or with the most specific type.
+* **No Direct Results:** If a search for a specific exhibit ("ENIAC") fails, search for the building or institution that houses it ("Moore Building Penn Engineering").
+* **Geocoding as Fallback:** If a place has a clear address in the source material, use `maps_geocode` on that address as a direct method.
+
+## Data Structure for Output
+Maintain a consistent data structure for located places. Example format for your internal notes:
+
diff --git a/skills/benchmark_skills/toolathlon/point-of-interest-finder/SKILL.md b/skills/benchmark_skills/toolathlon/point-of-interest-finder/SKILL.md
new file mode 100644
index 0000000..837159f
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/point-of-interest-finder/SKILL.md
@@ -0,0 +1,46 @@
+---
+name: point-of-interest-finder
+description: When the user needs to locate specific businesses or services near a given location with proximity constraints. This skill handles 1) Searching for businesses by category (e.g., coffee shops, restaurants) within specified radii, 2) Ranking results by proximity to target location, 3) Retrieving detailed business information including names, addresses, ratings, and operating hours, 4) Filtering results based on specific criteria like 'closest to [location]'. Triggers include requests for 'find nearest [business type]', 'locate [service] near [location]', or when users need to incorporate specific stops into their itineraries.
+---
+# Instructions
+
+Your goal is to find a specific point of interest (POI) for the user, typically to incorporate into a larger plan. Follow this process.
+
+## 1. Clarify the Search Parameters
+First, understand the user's exact request. Identify:
+* **Target POI Type:** What is the user looking for? (e.g., "Starbucks", "coffee shop", "pharmacy").
+* **Anchor Location:** The specific place the POI must be near. This is often part of a larger journey (e.g., "near the Nihonbashi Exit of Tokyo Station").
+* **Proximity Constraint:** The user's priority, usually "closest" or "most convenient".
+* **Use Case Context:** How will this POI fit into the user's plan? (e.g., "buy a coffee before departure").
+
+**Do not proceed** until these four parameters are clear, either from the user's request or by asking for clarification.
+
+## 2. Geocode the Anchor Location
+Use the `google_map-maps_geocode` tool to get the precise coordinates (`lat`, `lng`) and formatted address of the **Anchor Location**. This is critical for an accurate search.
+* **Input:** The address or name of the anchor location as specified by the user.
+* **Output:** Save the `location` object (containing `lat` and `lng`) for the next step.
+
+## 3. Search for POIs
+Use the `google_map-maps_search_places` tool to find candidates.
+* **`query`:** Combine the **Target POI Type** and the **Anchor Location** (e.g., "Starbucks near Tokyo Station Nihonbashi Exit").
+* **`location`:** Use the `location` object obtained in Step 2.
+* **`radius`:** Start with a small radius (e.g., 500 meters). If results are insufficient, you may increase it incrementally.
+
+## 4. Analyze and Rank Results
+Examine the returned list of `places`. Your primary ranking factor is **proximity to the Anchor Location**.
+1. Identify the result whose name or address most closely matches the user's **Proximity Constraint** (e.g., "closest to the Nihonbashi Entrance").
+2. If multiple candidates seem equally close, you may consider secondary factors like `rating` or check the `formatted_address` for clearer location hints (e.g., "...Nihombashi Entrance..." in the name).
+3. Select the single best candidate. Its `place_id` is needed for the next step.
+
+## 5. Retrieve Detailed Information
+Use the `google_map-maps_place_details` tool with the selected candidate's `place_id`.
+* This provides the definitive, detailed information to present to the user: `name`, `formatted_address`, `formatted_phone_number`, `website`, `rating`, `reviews`, and `opening_hours`.
+
+## 6. Integrate and Present Findings
+Present your final recommendation clearly:
+1. **State the recommended POI** by its official `name`.
+2. **Provide its precise `formatted_address`**.
+3. **Justify your choice** based on the user's **Proximity Constraint** (e.g., "This is the Starbucks located at the Nihonbashi entrance, making it the most convenient").
+4. **Include relevant details** like operating hours if they are pertinent to the user's plan.
+
+**Remember:** This skill is a component of a larger task. Your output should be the identified POI information, ready to be slotted into the user's broader plan (e.g., a travel itinerary).
diff --git a/skills/benchmark_skills/toolathlon/point-of-interest-finder/references/proximity_logic.md b/skills/benchmark_skills/toolathlon/point-of-interest-finder/references/proximity_logic.md
new file mode 100644
index 0000000..fee5803
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/point-of-interest-finder/references/proximity_logic.md
@@ -0,0 +1,25 @@
+# Logic for Determining "Closest" or "Most Convenient"
+
+The user's core constraint is usually proximity. Use this logic to select the best POI from search results.
+
+## Primary Signal: Name and Address Scrutiny
+The most reliable indicator is textual analysis of the result's `name` and `formatted_address`.
+* **Example from Trajectory:** User wanted a Starbucks "as close as possible to the Nihonbashi Entrance".
+* **Winning Result:** `"Starbucks Coffee - JR Tokyo Station Nihombashi Entrance"`
+* **Why it won:** The name explicitly contains "Nihombashi Entrance", perfectly matching the user's anchor location. Other results had names like "Gransta Yaesu" or "Tokyo Midtown Yaesu", which are less specific.
+
+## Secondary Signal: Geographic Coordinates
+If names are ambiguous, use the `location` data (`lat`, `lng`) of each result.
+* You can use the `google_map-maps_distance_matrix` tool (as seen in the trajectory for a different leg) to compare walking distances from the anchor to each candidate.
+* **Formula for Priority:** Closest straight-line or walking distance wins.
+
+## Tie-Breakers
+If proximity is indistinguishable:
+1. **Higher `rating`** may indicate better quality/service.
+2. **Presence of `opening_hours`** and current `open_now` status ensures usability.
+3. User reviews (`reviews`) might mention convenience or accessibility.
+
+## Decision Flowchart
+1. Does any result's name/address **explicitly mention** the user's specified anchor location? → **YES:** Select it.
+2. **NO:** Calculate/estimate distances from the anchor to each result's coordinates. → Select the closest.
+3. **TIE:** Select the one with the higher rating or confirmed open status.
diff --git a/skills/benchmark_skills/toolathlon/point-of-interest-finder/references/tool_usage_guide.md b/skills/benchmark_skills/toolathlon/point-of-interest-finder/references/tool_usage_guide.md
new file mode 100644
index 0000000..cbb3383
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/point-of-interest-finder/references/tool_usage_guide.md
@@ -0,0 +1,10 @@
+# Tool Usage Guide for POI Finder
+
+This guide details the specific tools and patterns used in the skill's execution trajectory.
+
+## Core Tools
+
+### 1. `google_map-maps_geocode`
+**Purpose:** Convert a location description into precise coordinates.
+**When to Use:** First step, to establish the anchor point for the search.
+**Input Example:**
diff --git a/skills/benchmark_skills/toolathlon/policy-document-parser/SKILL.md b/skills/benchmark_skills/toolathlon/policy-document-parser/SKILL.md
new file mode 100644
index 0000000..c15c451
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/policy-document-parser/SKILL.md
@@ -0,0 +1,67 @@
+---
+name: policy-document-parser
+description: Extracts and structures company policy information from PDF documents, particularly travel expense policies with destination-specific caps. Reads policy PDFs, extracts structured data about expense limits by location and employee level, and converts policy tables into machine-readable formats for automated validation.
+---
+# Policy Document Parser
+
+## When to Use
+Use this skill when you need to:
+- Analyze company policy documents (PDF format)
+- Extract structured expense limits from travel policy tables
+- Parse destination-specific caps by employee level
+- Convert policy tables into machine-readable formats (JSON/CSV)
+- Prepare policy data for automated expense validation systems
+
+## Core Workflow
+
+### 1. Initial Setup & Document Discovery
+- Scan the workspace for policy documents (typically PDF files)
+- Identify the main policy document (look for files like `policy_en.pdf`, `travel_policy.pdf`, etc.)
+- Use `filesystem-list_directory` to explore the workspace structure
+
+### 2. Policy Document Analysis
+- Read the PDF document using `pdf-tools-read_pdf_pages`
+- Extract the full text content for analysis
+- Identify the document structure and locate policy tables
+
+### 3. Table Extraction & Parsing
+- Focus on sections containing destination-specific expense caps
+- Look for tables with the following structure:
+ - Destination cities/countries
+ - Employee levels (L1, L2, L3, L4, etc.)
+ - Category caps (Accommodation, Meals, Transportation, Communication, Miscellaneous)
+ - Per-day or per-trip limits
+
+### 4. Data Structuring
+- Convert extracted tables into structured JSON format
+- Organize data by: `city → employee_level → category → limit`
+- Include global rules (receipt thresholds, airfare policies, etc.) as separate metadata
+
+### 5. Output Generation
+- Create machine-readable policy files (JSON preferred)
+- Generate summary reports of extracted policy limits
+- Prepare data for integration with expense validation systems
+
+## Key Patterns from Trajectory
+
+### Document Structure Recognition
+The policy PDF typically contains:
+1. Header with policy name, effective date, currency
+2. Global rules section (airfare, receipt thresholds, exceptions)
+3. Destination-specific tables with caps by employee level
+4. Multiple pages with consistent table formatting
+
+### Data Extraction Strategy
+- Extract all pages first to understand full document scope
+- Look for patterns like "Destination-Specific Caps" headers
+- Parse tables with city names followed by level-based caps
+- Capture per-day vs per-trip limits (Transportation vs Communication/Miscellaneous)
+
+### Error Handling
+- Handle missing or malformed tables gracefully
+- Validate extracted data against expected structure
+- Log parsing issues for manual review
+
+## Output Formats
+
+### Primary Output: Structured Policy JSON
diff --git a/skills/benchmark_skills/toolathlon/post-purchase-feedback-manager/SKILL.md b/skills/benchmark_skills/toolathlon/post-purchase-feedback-manager/SKILL.md
new file mode 100644
index 0000000..a2a6132
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/post-purchase-feedback-manager/SKILL.md
@@ -0,0 +1,64 @@
+---
+name: post-purchase-feedback-manager
+description: When the user needs to collect customer feedback after completed purchases, this skill manages the entire workflow retrieves completed orders from WooCommerce, creates customized Google Forms based on requirements specifications, extracts customer emails, sends personalized survey invitations, and stores form links. It triggers on requests involving customer feedback collection, post-purchase surveys, satisfaction measurement, or when working with WooCommerce order data and Google Forms integration.
+---
+# Instructions
+
+## Workflow Overview
+Execute this skill when the user requests to collect feedback from customers with completed purchases. The skill orchestrates a multi-step process involving WooCommerce, Google Forms, and email systems.
+
+## Step-by-Step Execution
+
+### 1. Retrieve Completed Orders
+- Use the `woocommerce-woo_orders_list` tool to fetch all orders with status "completed".
+- Set `perPage` to 100 (or adjust based on expected volume).
+- Extract the JSON response containing order details.
+
+### 2. Locate Requirements File
+- Check for a feedback form requirements file in the workspace.
+- Common filenames: `form_requirement.md`, `form_requirements.md`, `feedback_spec.md`.
+- If not found, list the workspace directory to identify the correct file.
+- Read the requirements file to understand the survey structure.
+
+### 3. Create Google Form
+- Use `google_forms-create_form` with the title specified in requirements.
+- Note: Only the title can be set during creation; description and items are added separately.
+- Capture the returned `formId` and `responderUri` for later use.
+
+### 4. Add Survey Questions
+Based on the requirements file, add questions using appropriate Google Forms tools:
+- **Multiple choice questions**: Use `google_forms-add_multiple_choice_question`
+- **Text questions**: Use `google_forms-add_text_question`
+- **Star ratings**: Implement as multiple choice with descriptive options (e.g., "1 star - Very dissatisfied" to "5 stars - Very satisfied")
+- Set `required` field according to specifications.
+
+### 5. Extract Customer Emails
+- Parse the WooCommerce orders JSON to extract unique customer email addresses.
+- Each order contains billing information with `email` field.
+- Note: Some customers may have multiple completed orders; deduplicate emails.
+- Extract customer names from `billing.first_name` and `billing.last_name` for personalization.
+
+### 6. Send Personalized Invitations
+- For each unique customer email:
+ - Use `emails-send_email` tool
+ - Subject: "We Value Your Feedback - Customer Shopping Experience Survey"
+ - Body: Personalized greeting using customer name, thank them for their purchase, include the survey link (`responderUri`), and polite closing.
+ - Send individually to maintain personalization.
+
+### 7. Store Form Reference
+- Save the Google Drive link to a workspace file (e.g., `drive_url.txt`).
+- Format: `https://drive.google.com/open?id={formId}`
+- Use `filesystem-write_file` to create/update the file.
+
+## Error Handling
+- If requirements file not found: List directory contents and try common variations.
+- If form creation fails: Check error message and adjust parameters.
+- If email sending fails: Continue with remaining emails and note the failure.
+
+## Completion
+- After all steps complete, provide a summary including:
+ - Number of completed orders processed
+ - Number of unique customers contacted
+ - Google Form ID and URL
+ - Location of stored drive link
+- Claim completion using `local-claim_done`.
diff --git a/skills/benchmark_skills/toolathlon/post-purchase-feedback-manager/references/form_requirements_template.md b/skills/benchmark_skills/toolathlon/post-purchase-feedback-manager/references/form_requirements_template.md
new file mode 100644
index 0000000..5db41ef
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/post-purchase-feedback-manager/references/form_requirements_template.md
@@ -0,0 +1,55 @@
+# Customer Experience Feedback Questionnaire Requirements
+
+## Basic Information
+- **Title:** [Survey Title - e.g., "Customer Shopping Experience Feedback Survey"]
+- **Description:** [Optional description shown to respondents]
+
+## Required Questions
+
+### 1. Overall Satisfaction Rating
+- **Type:** Single choice (star rating)
+- **Question:** Please rate your overall shopping experience.
+- **Options:** 1–5 stars (1 star = very dissatisfied, 5 stars = very satisfied)
+- **Required:** Yes
+
+### 2. Product Quality Evaluation
+- **Type:** Single choice
+- **Question:** Are you satisfied with the quality of the product you received?
+- **Options:** Very satisfied, Satisfied, Neutral, Dissatisfied, Very dissatisfied
+- **Required:** Yes
+
+### 3. Delivery Service Evaluation
+- **Type:** Single choice
+- **Question:** Are you satisfied with our delivery service?
+- **Options:** Very satisfied, Satisfied, Neutral, Dissatisfied, Very dissatisfied
+- **Required:** Yes
+
+### 4. Customer Service Experience Evaluation
+- **Type:** Single choice
+- **Question:** If you contacted customer service, how would you rate the experience?
+- **Options:** Very satisfied, Satisfied, Neutral, Dissatisfied, Very dissatisfied, Did not contact customer service
+- **Required:** No
+
+### 5. Suggestions for Improvement
+- **Type:** Long text
+- **Question:** Please provide any suggestions or feedback for improvement.
+- **Required:** No
+
+### 6. Willingness to Recommend
+- **Type:** Single choice
+- **Question:** Would you be willing to recommend our store to your friends?
+- **Options:** Very willing, Willing, Might, Not very willing, Unwilling
+- **Required:** Yes
+
+## Questionnaire Settings
+- **Allow anonymous responses:** Yes
+- **Collect email addresses:** No (customer emails already available)
+- **Limit to one submission per person:** Yes
+- **Show progress bar:** Yes
+- **Show thank-you message after submission:** Yes — "Thank you for your feedback! Your opinion is very important to us."
+
+## Appearance Settings
+- **Theme color:** Consistent with brand colors
+- **Background:** Simple white
+- **Font:** Clear and easy to read
+- **Mobile-friendly:** Yes
diff --git a/skills/benchmark_skills/toolathlon/post-purchase-feedback-manager/references/tool_usage_guide.md b/skills/benchmark_skills/toolathlon/post-purchase-feedback-manager/references/tool_usage_guide.md
new file mode 100644
index 0000000..8b19743
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/post-purchase-feedback-manager/references/tool_usage_guide.md
@@ -0,0 +1,8 @@
+# Tool Usage Guide for Post-Purchase Feedback Manager
+
+## WooCommerce Integration
+
+### woocommerce-woo_orders_list
+**Purpose:** Retrieve completed orders from WooCommerce store.
+
+**Parameters:**
diff --git a/skills/benchmark_skills/toolathlon/privacy-data-desensitizer/SKILL.md b/skills/benchmark_skills/toolathlon/privacy-data-desensitizer/SKILL.md
new file mode 100644
index 0000000..ad29681
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/privacy-data-desensitizer/SKILL.md
@@ -0,0 +1,52 @@
+---
+name: privacy-data-desensitizer
+description: When the user needs to scan and desensitize sensitive information in documents across a workspace, particularly for privacy compliance or data protection purposes. This skill automatically identifies and replaces specific types of sensitive data (phone/fax numbers, social security numbers, email addresses, credit card numbers, IP addresses) with a uniform placeholder like '/hidden/' while preserving all other content. It handles multiple file formats (txt, csv, json, md, log) and creates desensitized copies with consistent naming conventions. Use this skill when users mention 'privacy desensitization', 'data anonymization', 'sensitive information removal', or when working with documents containing personal identifiable information (PII).
+---
+# Instructions
+
+## Objective
+Scan all documents in the user's workspace, identify specific types of sensitive information, and create desensitized copies where all sensitive data is replaced with `/hidden/`. The original files must remain unchanged.
+
+## Sensitive Information Types
+Only process and replace the following data types, even if they appear to be pseudo, mimic, or duplicated:
+1. **Phone/Fax numbers**: Includes formats like `(555) 123-4567`, `555-123-4567`, `555.123.4567`, and `1-800-XXX-XXXX` (both numeric and alphanumeric like `1-800-HOTEL-HELP`).
+2. **Social Security Numbers (SSN)**: Format `XXX-XX-XXXX`.
+3. **Email addresses**: Standard email format `[email protected]`.
+4. **Credit card numbers**: 16-digit cards (with or without separators), Amex format (4-6-5 digits), and scientific notation (e.g., `4.11E+15`).
+5. **IP addresses**: IPv4 format `XXX.XXX.XXX.XXX`.
+
+**Do not modify any information not on this list.**
+
+## Core Workflow
+
+### 1. Discover the Workspace
+* Use `filesystem-list_allowed_directories` to find the root workspace path.
+* Use `filesystem-directory_tree` or `filesystem-list_directory` on that path to get a list of all files.
+* **Exclude** the target output directory `desensitized_documents/` from the list of files to process.
+
+### 2. Analyze File Contents
+* Read the content of all target files using `filesystem-read_multiple_files`.
+* Visually scan the content to confirm the presence of the specified sensitive data types.
+
+### 3. Execute Desensitization
+* **Primary Method**: Run the bundled Python script `scripts/desensitize.py`. This is the preferred, reliable method.
+ * The script will process all files, create the `desensitized_documents/` directory, and save the modified copies.
+* **Alternative (Manual)**: If script execution fails, implement the desensitization logic directly using `local-python-execute` with the core logic defined in `references/patterns.md`.
+
+### 4. Verify Results
+* Read a sample of the generated files from `desensitized_documents/` to ensure:
+ * All specified sensitive data is replaced with `/hidden/`.
+ * File structure, formatting, and non-sensitive content are preserved.
+ * Filenames follow the convention: `original_filename_desensitized.extension`.
+* Optionally, run a final count of replacements to provide a summary to the user.
+
+## Output Requirements
+* Save all desensitized files in a subdirectory named `desensitized_documents/`.
+* Each output file must be named: `[original_basename]_desensitized.[original_extension]`.
+* Do not add any other files to the output directory.
+* Provide the user with a summary including the number of files processed and types of data replaced.
+
+## Key Considerations
+* **Order of Operations**: Regex patterns must be applied in a specific order to avoid conflicts (e.g., processing `1-800` numbers before generic phone patterns).
+* **Precision**: Use word boundaries (`\b`) in regex patterns to avoid false positives (e.g., not matching dates as IP addresses).
+* **Preservation**: The replacement should occur exactly at the location of the sensitive data, without altering surrounding punctuation, spacing, or structure.
diff --git a/skills/benchmark_skills/toolathlon/privacy-data-desensitizer/references/patterns.md b/skills/benchmark_skills/toolathlon/privacy-data-desensitizer/references/patterns.md
new file mode 100644
index 0000000..701f16d
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/privacy-data-desensitizer/references/patterns.md
@@ -0,0 +1,65 @@
+# Regex Pattern Reference for Privacy Desensitization
+
+This document details the regular expression patterns used to identify sensitive information. Patterns must be applied in the specified order to avoid conflicts.
+
+## Pattern Application Order
+
+### 1. 1-800 Numbers (First to avoid partial matches)
+- **Pattern**: `1-800-\d{3}-\d{4}`
+- **Example**: `1-800-123-4567` → `/hidden/`
+- **Pattern**: `1-800-[A-Z]+-?[A-Z]*`
+- **Example**: `1-800-HOTEL-HELP` → `/hidden/`
+
+### 2. Scientific Notation Credit Cards
+- **Pattern**: `\d\.\d{2}E\+\d{2}`
+- **Example**: `4.11E+15` → `/hidden/`
+- **Note**: These appear in CSV exports and look similar to IP addresses.
+
+### 3. Social Security Numbers (SSN)
+- **Pattern**: `\b\d{3}-\d{2}-\d{4}\b`
+- **Example**: `123-45-6789` → `/hidden/`
+- **Note**: Word boundaries prevent matching partial strings.
+
+### 4. Credit Card Numbers
+- **16-digit with separators**: `\b\d{4}[-\s]\d{4}[-\s]\d{4}[-\s]\d{4}\b`
+ - Example: `4111-1111-1111-1111` → `/hidden/`
+- **Amex format (4-6-5)**: `\b\d{4}[-\s]\d{6}[-\s]\d{5}\b`
+ - Example: `3782-822463-10005` → `/hidden/`
+- **16 consecutive digits**: `\b\d{16}\b`
+ - Example: `1234567890123456` → `/hidden/`
+
+### 5. IP Addresses
+- **Pattern**: `\b(?:\d{1,3}\.){3}\d{1,3}\b`
+- **Example**: `192.168.1.100` → `/hidden/`
+- **Note**: The pattern matches 0-999.0-999.0-999.0-999 but is sufficient for most cases.
+
+### 6. Phone Numbers
+- **Parentheses format**: `\(\d{3}\)\s*\d{3}[-.]?\d{4}`
+ - Example: `(555) 123-4567` → `/hidden/`
+- **Dash/dot format**: `\b\d{3}[-.]?\d{3}[-.]?\d{4}\b`
+ - Example: `555-123-4567` or `555.123.4567` → `/hidden/`
+
+### 7. Email Addresses
+- **Pattern**: `[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}`
+- **Example**: `[email protected]` → `/hidden/`
+
+## Critical Implementation Notes
+
+1. **Order Matters**: Applying patterns in the wrong order can cause:
+ - Partial matches (e.g., `1-800-` being replaced, leaving `123-4567`)
+ - False positives (e.g., dates being mistaken for IPs)
+
+2. **Word Boundaries**: Use `\b` where appropriate to prevent matching substrings within larger numbers.
+
+3. **Replacement String**: Always use exactly `/hidden/` as specified in requirements.
+
+4. **Preservation**: The regex replacement should maintain surrounding text, punctuation, and formatting.
+
+## Testing Patterns
+
+Test the patterns against these edge cases:
+- `Phone: (555) 123-4567 and 555-987-6543` → Should replace both
+- `Date: 2024-12-01` → Should NOT be replaced (not SSN format)
+- `Amount: $1,800.00` → Should NOT be replaced (not a phone number)
+- `Network: 192.168.1.1 and 10.0.0.1` → Should replace both
+- `Contact: [email protected] and [email protected]` → Should replace both
diff --git a/skills/benchmark_skills/toolathlon/privacy-data-desensitizer/references/workflow_example.md b/skills/benchmark_skills/toolathlon/privacy-data-desensitizer/references/workflow_example.md
new file mode 100644
index 0000000..f4cee80
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/privacy-data-desensitizer/references/workflow_example.md
@@ -0,0 +1,5 @@
+# Example Agent Workflow
+
+This document shows the expected sequence of tool calls and decisions when executing this skill.
+
+## Phase 1: Discovery
diff --git a/skills/benchmark_skills/toolathlon/product-recall-manager/SKILL.md b/skills/benchmark_skills/toolathlon/product-recall-manager/SKILL.md
new file mode 100644
index 0000000..2b556fb
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/product-recall-manager/SKILL.md
@@ -0,0 +1,47 @@
+---
+name: product-recall-manager
+description: Manages a complete product recall workflow in WooCommerce. Identifies products by model/metadata, deactivates them (draft/private/hidden), creates a Google Forms recall form, finds affected customers from orders, and sends personalized notification emails with the form link.
+---
+# Product Recall Manager
+
+Execute a complete product recall process for a specified product model in WooCommerce.
+
+## Core Workflow
+1. **Identify Target Products**: Search for products matching the specified model or containing recall metadata (`recall_status: need_recall`).
+2. **Deactivate Products**: Set identified products to `draft` status and `hidden` catalog visibility. Do NOT delete them.
+3. **Create Recall Form**: Generate a Google Form using the provided template (`recall_form_template.json`). The form must collect customer and product details for the recall process.
+4. **Find Affected Customers**: Query all historical WooCommerce orders that contain the recalled product(s).
+5. **Notify Customers**: Send a personalized recall email to each unique customer using the template (`recall_email_template.md`), inserting their specific details and the Google Form link.
+6. **Generate Report**: Create a `recall_report.json` file containing the generated Google Form's ID and URL.
+
+## Required Input from User
+You must ask the user to specify the **product model** or **identification criteria** to initiate the recall. If not provided, examine existing products for metadata clues (e.g., `recall_status: need_recall`).
+
+## Key Instructions & Logic
+
+### 1. Product Identification & Deactivation
+- Use `woocommerce-woo_products_list` to browse store products.
+- Filter products by:
+ - **Name/SKU** containing the target model string (e.g., "X1").
+ - **Metadata** containing `recall_status: need_recall` or `recall_reason`.
+- Once identified, use `woocommerce-woo_products_batch_update` to set `status: "draft"` and `catalog_visibility: "hidden"` for all target products. Provide a summary of affected products (IDs, Names, SKUs).
+
+### 2. Google Forms Creation
+- **Create Form**: Use `google_forms-create_form` with only the `title` parameter. The description cannot be set during creation.
+- **Add Questions**: Use the `recall_form_template.json` as a reference. Add questions sequentially using the appropriate `google_forms-add_*_question` functions:
+ - `google_forms-add_text_question` for text, email, date fields.
+ - `google_forms-add_multiple_choice_question` for choice fields.
+ - Ensure `required` field settings from the template are applied.
+- **Form URL**: The `responderUri` from the creation response is the public form link to include in emails.
+
+### 3. Customer Identification & Notification
+- For each recalled product ID, use `woocommerce-woo_orders_list` with the `product` filter to find all containing orders.
+- **Deduplicate Customers**: Compile a unique list of customers by their email address (`billing.email`). Aggregate their order numbers and purchased product details.
+- **Personalize & Send Email**:
+ - Load the `recall_email_template.md`.
+ - For each customer, populate the template placeholders (`[Customer Name]`, `[Product Model]`, `[Product ID]`, `[Order Number]`, `[Purchase Date]`, `[Google Forms Link]`).
+ - Use `emails-send_email` to send. The subject should be clear, e.g., "Product Recall Notice - [Product Model]".
+
+### 4. Final Reporting
+- Use `filesystem-write_file` to create `recall_report.json` with the structure:
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/product-recall-manager/references/recall_email_template.md b/skills/benchmark_skills/toolathlon/product-recall-manager/references/recall_email_template.md
new file mode 100644
index 0000000..6d0d051
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/product-recall-manager/references/recall_email_template.md
@@ -0,0 +1,63 @@
+# Product Recall Notice
+
+## Urgent Notification
+
+Dear **[Customer Name]**,
+
+We have discovered a safety hazard with the product you purchased. In consideration of customer safety, we have decided to initiate a proactive recall of this product.
+
+## Product Information
+
+- **Product Model**: [Product Model]
+- **Product ID**: [Product ID]
+- **Your Order Number**: [Order Number]
+- **Purchase Date**: [Purchase Date]
+
+## Reason for Recall
+
+This product may pose the following safety risks:
+- [Specific risk description]
+- To ensure your safety, please stop using it immediately
+
+## Solutions
+
+We offer the following options for handling the recall:
+
+1. **Full Refund** – Refund the full amount at the original price
+2. **Product Replacement** – Free replacement with a safe equivalent product
+3. **Store Credit** – Convert to equivalent store credit, usable for future purchases
+
+## How to Apply for Recall Processing
+
+Please fill out the recall confirmation form: **[Google Forms Link]**
+
+The form includes the following information:
+- Customer basic information confirmation
+- Product status description
+- Choice of solution
+- Any special requirements
+
+## Important Reminders
+
+- **Stop using** this product immediately
+- **Keep the product packaging** for follow-up processing
+- **After filling out the form**, we will contact you within 3 business days
+- If the product has already caused damage, please keep the relevant evidence
+
+## Contact Us
+
+If you have any questions, please contact us immediately:
+
+- **Customer Service Hotline**: 400-xxx-xxxx (24 hours)
+- **Customer Service Email**: [email protected]
+- **Online Customer Service**: Visit our official website for live chat
+
+## Apology Statement
+
+We sincerely apologize for the inconvenience caused by this product quality issue. Customer safety and satisfaction are our top priorities, and we will continue to improve our product quality control processes.
+
+Thank you for your understanding and cooperation!
+
+---
+
+**[Company Name]** Customer Service Team
diff --git a/skills/benchmark_skills/toolathlon/product-recall-manager/references/recall_form_template.json b/skills/benchmark_skills/toolathlon/product-recall-manager/references/recall_form_template.json
new file mode 100644
index 0000000..70d51de
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/product-recall-manager/references/recall_form_template.json
@@ -0,0 +1,80 @@
+{
+ "form_title": "Product Recall Information Confirmation Form",
+ "form_description": "Thank you for cooperating with our product recall process. Please fill out the following information so we can assist you accordingly.",
+ "fields": [
+ {
+ "name": "Customer Name",
+ "type": "text",
+ "required": true,
+ "description": "Please enter your real name"
+ },
+ {
+ "name": "Contact Email",
+ "type": "email",
+ "required": true,
+ "description": "Email address for further contact"
+ },
+ {
+ "name": "Contact Phone Number",
+ "type": "text",
+ "required": false,
+ "description": "Alternative contact number"
+ },
+ {
+ "name": "Product Model",
+ "type": "text",
+ "required": true,
+ "description": "Please confirm the model of the product you purchased"
+ },
+ {
+ "name": "Product ID",
+ "type": "text",
+ "required": true,
+ "description": "Product identifier, can be found on the product packaging"
+ },
+ {
+ "name": "Order Number",
+ "type": "text",
+ "required": true,
+ "description": "Your purchase order number"
+ },
+ {
+ "name": "Purchase Date",
+ "type": "date",
+ "required": true,
+ "description": "The specific date of purchase"
+ },
+ {
+ "name": "Current Product Status",
+ "type": "choice",
+ "required": false,
+ "choices": ["Not Used", "In Normal Use", "Has Issues", "Discarded"],
+ "description": "Please select the current status of the product"
+ },
+ {
+ "name": "Return Preference",
+ "type": "choice",
+ "required": false,
+ "choices": ["Full Refund", "Product Replacement", "Store Credit"],
+ "description": "Please select your preferred resolution option"
+ },
+ {
+ "name": "Problem Description",
+ "type": "paragraph",
+ "required": false,
+ "description": "Please describe in detail the issues you encountered with the product or any other relevant information"
+ },
+ {
+ "name": "Agreement to Terms of Processing",
+ "type": "checkbox",
+ "required": true,
+ "description": "I agree to proceed according to the recall processing procedure"
+ }
+ ],
+ "settings": {
+ "collect_email": true,
+ "allow_response_editing": true,
+ "limit_to_one_response": true,
+ "show_progress_bar": true
+ }
+}
diff --git a/skills/benchmark_skills/toolathlon/public-transit-route-planner/SKILL.md b/skills/benchmark_skills/toolathlon/public-transit-route-planner/SKILL.md
new file mode 100644
index 0000000..aadb943
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/public-transit-route-planner/SKILL.md
@@ -0,0 +1,66 @@
+---
+name: public-transit-route-planner
+description: When the user requests public transportation directions between two locations with specific constraints (e.g., shortest walking distance, preferred transport modes, or avoiding certain transfers). This skill geocodes addresses, finds nearest transit stations, calculates optimal routes using transit APIs, identifies transfer points, compiles sequential station lists, and provides detailed journey summaries including distances and travel times.
+---
+# Instructions
+
+## Primary Objective
+Plan an optimal public transit route between two locations based on user constraints (e.g., shortest walking distance, preferred modes, avoiding certain transfers). The final output must include a detailed journey summary and a sequential list of all stations passed, saved to a specified file.
+
+## Core Workflow
+
+### 1. Interpret Request & Extract Constraints
+- Identify the **origin** and **destination** addresses.
+- Identify explicit **constraints** (e.g., "prefer not to use any mode other than MRT", "shortest walking distance").
+- Identify any **output requirements** (e.g., save station list to a file named `routine.txt`).
+
+### 2. Geocode Locations
+- Use `google_map-maps_geocode` to obtain precise coordinates and formatted addresses for both origin and destination.
+- Store the results for subsequent steps.
+
+### 3. Find Nearest Transit Stations
+- Use `google_map-maps_search_places` with query "MRT station" (or other relevant transit types) near the geocoded origin.
+- Use `google_map-maps_distance_matrix` (mode: "walking") to compare walking distances to the nearest candidate stations. **Select the station with the shortest walking distance** to honor the "shortest walking distance" constraint.
+
+### 4. Calculate Optimal Transit Route
+- Use `google_map-maps_directions` with mode: "transit" between the origin and destination addresses.
+- Analyze the returned route steps. The route will typically include:
+ - A walking leg to the first station.
+ - One or more transit (e.g., "SUBWAY") legs.
+ - Possible transfers (indicated by a walking leg between transit legs).
+ - A final walking leg to the destination.
+- **Validate the route against user constraints.** If the user specifies "MRT only," ensure the transit legs use the subway system.
+
+### 5. Enrich Route Details & Compile Station List
+- The `directions` API provides a high-level route but may not list every intermediate station.
+- To compile a **complete, sequential list of all stations passed**:
+ - Identify each transit leg's line and direction (e.g., "Downtown Line towards Expo").
+ - Use `local-web_search` or `fetch-fetch_markdown` to find authoritative lists of stations for each line segment (e.g., Wikipedia pages for "Downtown Line" and "East–West Line").
+ - Map the route's transfer points to these lists to extract the exact sequence of stations between the boarding station and the alighting/transfer station for each leg.
+- The final list must be **sequential**, including the origin station, all intermediate stations, transfer stations, and the destination station.
+
+### 6. Generate Output & Save File
+- Create a final summary for the user including:
+ - Total journey distance and time.
+ - Walking distance to the first station.
+ - Step-by-step itinerary (walk, take Line X from Station A to Station B, transfer, etc.).
+ - The complete list of stations in order.
+- Use `filesystem-write_file` to save **only the station names, one per line**, to the user-specified file (e.g., `routine.txt`). Do not include any other text in this file.
+
+### 7. Claim Completion
+- Use `local-claim_done` to signal successful task completion after providing the summary and confirming the file has been saved.
+
+## Key Decision Points & Error Handling
+- **Nearest Station Selection:** If multiple stations are equally close, choose the one that leads to a simpler route (fewer transfers).
+- **Data Enrichment:** If web searches for station lists fail or return ambiguous data, rely on the station names explicitly mentioned in the `directions` result and note any potential gaps in the output summary.
+- **Constraint Violation:** If the optimal transit route violates a user constraint (e.g., uses a bus), inform the user and explain the limitation, or search for an alternative if possible.
+- **File Operations:** If the specified file path is invalid or unwritable, inform the user and ask for an alternative before proceeding.
+
+## Tools Usage Summary
+1. `google_map-maps_geocode`: Convert addresses to coordinates.
+2. `google_map-maps_search_places`: Find transit stations near a point.
+3. `google_map-maps_distance_matrix`: Compare walking distances to stations.
+4. `google_map-maps_directions`: Get the primary transit route.
+5. `local-web_search` / `fetch-fetch_markdown`: Find detailed station lists for specific transit lines.
+6. `filesystem-write_file`: Save the final station list.
+7. `local-claim_done`: Signal task completion.
diff --git a/skills/benchmark_skills/toolathlon/public-transit-route-planner/references/transit_glossary.md b/skills/benchmark_skills/toolathlon/public-transit-route-planner/references/transit_glossary.md
new file mode 100644
index 0000000..3673e4a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/public-transit-route-planner/references/transit_glossary.md
@@ -0,0 +1,19 @@
+# Transit Planning Glossary
+
+## Common Transit Modes (Google Maps API)
+- **TRANSIT**: Generic public transport. In Singapore context, this typically resolves to MRT (Mass Rapid Transit) or LRT.
+- **SUBWAY**: Underground rail system (MRT).
+- **RAIL**: May refer to above-ground MRT or other rail services.
+- **BUS**: Bus service.
+- **WALKING**: Pedestrian segment.
+
+## Key Route Components
+- **Leg**: A continuous segment of travel using one mode (e.g., one subway ride from Station A to Station B).
+- **Transfer**: The point where you change from one vehicle/line to another, often involving a short walking segment.
+- **Boarding Station**: The station where you enter a transit vehicle.
+- **Alighting Station**: The station where you exit a transit vehicle.
+
+## Singapore MRT Specifics
+- **Lines are color-coded**: East-West Line (Green), North-South Line (Red), etc.
+- **Station Codes**: Combine line code and number (e.g., EW12 for Bugis on East-West Line, DT14 for Bugis on Downtown Line).
+- **Interchange Stations**: Stations where multiple lines meet (e.g., Bugis, Raffles Place). These appear as single points in a station list but serve multiple lines.
diff --git a/skills/benchmark_skills/toolathlon/repository-todo-tracker/SKILL.md b/skills/benchmark_skills/toolathlon/repository-todo-tracker/SKILL.md
new file mode 100644
index 0000000..32d5c97
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/repository-todo-tracker/SKILL.md
@@ -0,0 +1,80 @@
+---
+name: repository-todo-tracker
+description: Scans a GitHub repository for TODO/FIXME comments in source code files and updates documentation (like README) with a comprehensive, organized list. Handles authentication, recursive file search, comment extraction, comparison with existing documentation, and markdown updates while preserving formatting.
+---
+# Instructions
+
+## Core Objective
+When the user requests to scan a repository for TODOs and update documentation, you must:
+1. Authenticate with GitHub.
+2. Find all relevant source files in the specified branch.
+3. Extract all TODO/FIXME comments.
+4. Compare with the existing TODO list in the documentation.
+5. Update the documentation by removing completed items and adding new ones, maintaining the specified format and order.
+
+## Step-by-Step Process
+
+### 1. Clarify & Parse User Request
+- **Identify Target Repository:** Extract the repo name and owner from the user's request. If the owner is "my" or "our", you will need to discover the authenticated user's repositories.
+- **Identify Target Branch:** Extract the branch name (e.g., `dev`, `main`). Default to `main` if unspecified.
+- **Identify Target Documentation File:** Usually `README.md`. Confirm with the user if ambiguous.
+- **Identify File Types:** The request typically specifies file extensions (e.g., `.py`). Use these. If unspecified, default to common source files (`.py`, `.js`, `.ts`, `.java`, `.cpp`, `.go`).
+- **Identify Section Title:** The request often specifies a section title to update (e.g., `### 📝 Complete TODO List`). You **MUST** keep this exact title unchanged.
+
+### 2. Authenticate and Discover Repository
+- Check for a GitHub token, typically in a file like `.github_token` in the workspace.
+- Use the token to call the GitHub API (`github-get_me`, `github-search_repositories`, or direct API calls via `local-python-execute` with `requests`).
+- If the repository owner is ambiguous (e.g., "my repo"), list the authenticated user's repositories to find the correct one.
+
+### 3. Fetch Repository Structure & Target Files
+- Get the recursive file tree for the target branch using the GitHub API.
+- Filter the tree to identify:
+ - All source files matching the specified extensions.
+ - The target documentation file (e.g., `README.md`).
+- Fetch and save the current content of the documentation file. Note its `sha` for later updates.
+
+### 4. Extract TODO Comments from Source Code
+- For each identified source file, fetch its content via the GitHub API.
+- Use a regular expression (e.g., `r'#\\s*TODO[:\\s]*(.*)'`, case-insensitive) to scan each line for TODO comments.
+- For each match, record:
+ - `file`: The repository-relative file path.
+ - `line`: The line number.
+ - `text`: The TODO description (trimmed).
+- Save this list as a JSON file in the workspace for later comparison. **Sort the list lexicographically by file path, then by line number within the same file.**
+
+### 5. Parse the Existing TODO List from Documentation
+- Locate the target section in the documentation using the specified title (e.g., `### 📝 Complete TODO List`).
+- Parse each TODO item. They are typically in the format:
+ `- [ ] **<file_path>:<line_number>** - <description>`
+- Create a mapping keyed by `"<file_path>:<line_number>"` for easy comparison.
+
+### 6. Generate the Updated TODO List
+- **Identify Completed TODOs:** Items present in the documentation mapping but **not** in the newly extracted code list. These should be removed.
+- **Identify New TODOs:** Items present in the new code list but **not** in the documentation mapping. These should be added.
+- Generate the new, complete TODO list section content:
+ 1. Start with the exact, original section title.
+ 2. For each item in the **sorted** extracted code list, add a line in the format: `- [ ] **<file>:<line>** - <text>`
+
+### 7. Update the Documentation File
+- In the documentation content, replace the entire old TODO section (from the title to the beginning of the next major section or end of file) with the newly generated content.
+- Use the GitHub API to update the file. You **must** provide:
+ - The commit `message` describing the update.
+ - The new file `content` (base64 encoded).
+ - The original file `sha`.
+ - The target `branch`.
+- Verify the update was successful by fetching the file again and checking the TODO count.
+
+### 8. Provide a Summary
+- Report back to the user with a clear summary:
+ - Number of TODOs removed (completed).
+ - Number of new TODOs added.
+ - Final total count.
+ - Confirmation that the section title was preserved.
+ - The commit SHA of the update.
+
+## Key Rules & Constraints
+- **Order is Mandatory:** The final TODO list **must** be sorted lexicographically by file path, then by ascending line number within each file.
+- **Preserve the Title:** The specified section title string must remain **exactly** as provided by the user.
+- **Handle Authentication Errors:** If the initial GitHub tool calls fail due to repository access restrictions, fall back to using the token with direct API calls via `local-python-execute`.
+- **Rate Limiting:** Be mindful of GitHub API rate limits. Introduce small delays (`time.sleep`) when fetching many files in a loop.
+- **Error Handling:** Check HTTP status codes and provide informative error messages if file fetching or updates fail.
diff --git a/skills/benchmark_skills/toolathlon/repository-todo-tracker/references/github_api_guide.md b/skills/benchmark_skills/toolathlon/repository-todo-tracker/references/github_api_guide.md
new file mode 100644
index 0000000..58d4303
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/repository-todo-tracker/references/github_api_guide.md
@@ -0,0 +1,6 @@
+# GitHub API Guide for Repository TODO Tracker
+
+## Authentication
+- **Personal Access Token (PAT):** Required for accessing private repos or avoiding rate limits. Store in a file like `.github_token`.
+- **Usage in Requests:**
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/repository-todo-tracker/references/todo_format_spec.md b/skills/benchmark_skills/toolathlon/repository-todo-tracker/references/todo_format_spec.md
new file mode 100644
index 0000000..8df7487
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/repository-todo-tracker/references/todo_format_spec.md
@@ -0,0 +1,3 @@
+# TODO List Format Specification
+
+## Input Format (in source code)
diff --git a/skills/benchmark_skills/toolathlon/route-data-compiler/SKILL.md b/skills/benchmark_skills/toolathlon/route-data-compiler/SKILL.md
new file mode 100644
index 0000000..9049a34
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/route-data-compiler/SKILL.md
@@ -0,0 +1,55 @@
+---
+name: route-data-compiler
+description: When the user requires detailed transit line information including complete station sequences between transfer points. This skill fetches comprehensive transit network data from authoritative sources, extracts station lists for specific line segments, identifies transfer stations, and organizes the information into sequential itineraries for route documentation.
+---
+# Instructions
+
+## Core Objective
+Compile a complete, sequential list of transit stations between origin and destination points, including all intermediate stations along each line segment and transfer points. The output should be saved to a specified file.
+
+## Workflow
+
+### 1. Initial Location Analysis
+- Use `google_map-maps_geocode` to obtain precise coordinates for both origin and destination addresses.
+- Use `google_map-maps_search_places` with query "MRT station" (or relevant transit type) and a small radius (e.g., 1000m) around the origin coordinates to identify the nearest transit station(s).
+- Use `google_map-maps_distance_matrix` with mode "walking" to compare walking distances to candidate stations. Select the station with the shortest walking distance.
+
+### 2. Route Planning
+- Use `google_map-maps_directions` with mode "transit" between the origin and destination to obtain a high-level route. This provides the sequence of line segments and transfer points.
+- Analyze the route steps to identify:
+ - The boarding station (nearest station from step 1).
+ - Each transit line segment (e.g., "Subway towards Expo").
+ - Each transfer station.
+ - The alighting station.
+
+### 3. Detailed Station Data Collection
+For each identified transit line segment between transfer points (or between boarding/alighting station and a transfer point):
+- **Primary Method:** Use `fetch-fetch_markdown` to retrieve the Wikipedia page for the specific transit line (e.g., "Downtown Line", "East–West MRT line").
+- **Fallback Method:** If Wikipedia fetch fails or is insufficient, use `local-web_search` with queries like "[Line Name] stations list" or "[Station A] to [Station B] stations".
+- From the retrieved data, extract the **complete, ordered list of stations** for the relevant segment of the line. Ensure the list direction matches the travel direction (e.g., from Little India towards Bugis).
+
+### 4. Itinerary Compilation
+- Assemble the final station sequence by concatenating the lists from each segment, ensuring:
+ 1. The boarding station is first.
+ 2. Transfer stations appear only once at the point of transfer.
+ 3. The sequence flows logically from origin to destination.
+- Verify the total count and order against the high-level route from Step 2.
+
+### 5. Output Generation
+- Use `filesystem-write_file` to save the compiled list of stations to the user-specified file path (e.g., `routine.txt`).
+- Format: One station name per line, in sequential order.
+- Provide a concise summary to the user confirming completion, total stations, and the save location.
+
+## Key Considerations
+- **Accuracy:** Prefer official sources (Wikipedia, transit authority pages) for station lists. Cross-verify segment endpoints with the directions result.
+- **Transfers:** Pay close attention to the directions result to correctly identify where line changes occur. A transfer station marks the end of one segment and the start of another.
+- **Naming:** Use consistent station naming (e.g., "Changi Airport" not "Changi Airport MRT station" unless the full name is standard).
+- **Error Handling:** If a line segment's stations cannot be reliably determined, note the gap in the summary and use the transfer points as placeholders.
+
+## Example Logic (from trajectory)
+1. Geocode origin/destination.
+2. Find nearest station: Little India (0.5km walk).
+3. Get directions: Reveals route: Little India (DT) → Bugis → (transfer) → Tanah Merah → (transfer) → Changi Airport.
+4. Fetch data: Get Downtown Line page, extract stations Little India → Rochor → Bugis. Get East–West Line page, extract stations Bugis → ... → Tanah Merah. Get Changi Airport branch info, extract Tanah Merah → Expo → Changi Airport.
+5. Compile list, avoiding duplicates at Bugis and Tanah Merah.
+6. Write to file.
diff --git a/skills/benchmark_skills/toolathlon/route-data-compiler/assets/example_output_template.txt b/skills/benchmark_skills/toolathlon/route-data-compiler/assets/example_output_template.txt
new file mode 100644
index 0000000..3b278e7
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/route-data-compiler/assets/example_output_template.txt
@@ -0,0 +1,15 @@
+# Transit Route Station Sequence
+# Generated by route-data-compiler skill
+# Origin: {ORIGIN_LOCATION}
+# Destination: {DESTINATION_LOCATION}
+# Date: {GENERATION_DATE}
+
+{STATION_1}
+{STATION_2}
+{STATION_3}
+... (all intermediate stations)
+{STATION_N}
+
+# Total stations: {COUNT}
+# Estimated transit time: {ESTIMATED_TIME}
+# Primary transit modes: {MODES}
diff --git a/skills/benchmark_skills/toolathlon/route-data-compiler/references/transit_line_queries.md b/skills/benchmark_skills/toolathlon/route-data-compiler/references/transit_line_queries.md
new file mode 100644
index 0000000..59e7995
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/route-data-compiler/references/transit_line_queries.md
@@ -0,0 +1,32 @@
+# Transit Line Query Reference
+
+This document provides standardized search queries for fetching detailed transit line information, particularly station lists.
+
+## General Pattern
+For a given transit line and segment, construct queries to find:
+1. The official line page (for comprehensive data).
+2. The specific station list for a segment.
+
+## Example Queries (Singapore MRT Context)
+
+### For Line Overview & Station Lists
+- `"[Line Name] Wikipedia"` (e.g., "Downtown Line Wikipedia")
+- `"[Line Name] stations list"` (e.g., "East West Line stations list")
+- `"[Line Name] route map"`
+
+### For Segment Verification
+- `"[Station A] to [Station B] [Line Name] stations"` (e.g., "Bugis to Tanah Merah East West Line stations")
+- `"[Line Name] stations between [Station A] and [Station B]"`
+
+### For Transfer Point Details
+- `"[Station Name] MRT interchange"` (e.g., "Bugis MRT interchange lines")
+
+## Preferred Sources (Priority Order)
+1. **Wikipedia** - Usually contains complete station tables in chronological order.
+2. **Official Transit Authority Websites** (e.g., Land Transport Authority (LTA) for Singapore) - For authoritative data.
+3. **Reputable transit databases or forums** - As a fallback.
+
+## Data Extraction Tips
+- On Wikipedia, look for sections titled "Stations", "List of stations", or "Route". Station lists are often in tables or bulleted lists.
+- Ensure the station order matches the direction of travel. Lines may have different station sequences for each direction.
+- Note any branch lines (like the Changi Airport Branch) and treat them as separate segments.
diff --git a/skills/benchmark_skills/toolathlon/sla-compliance-monitor/SKILL.md b/skills/benchmark_skills/toolathlon/sla-compliance-monitor/SKILL.md
new file mode 100644
index 0000000..2049a5a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/sla-compliance-monitor/SKILL.md
@@ -0,0 +1,77 @@
+---
+name: sla-compliance-monitor
+description: When the user needs to monitor SLA compliance for support tickets or service requests, this skill identifies overdue items by querying databases, analyzing SLA documentation from PDFs, and generating automated notifications. It handles 1) Database exploration to find relevant tables (support tickets, users), 2) PDF analysis to extract SLA rules and email templates, 3) SQL queries to identify tickets exceeding response times based on user service levels, and 4) Automated email generation for manager reminders and customer apologies using extracted templates. Triggers include 'SLA compliance', 'overdue tickets', 'response time monitoring', 'send reminder emails', 'apology emails', 'ticket monitoring', and 'service level agreement'.
+---
+# SLA Compliance Monitor
+
+## Overview
+This skill automates the monitoring of Service Level Agreement (SLA) compliance for support tickets. It identifies tickets that have exceeded their first response time based on user service levels, extracts email templates from SLA documentation, and sends automated notifications to responsible managers and affected customers.
+
+## Prerequisites
+Ensure the following tools are available:
+- Snowflake database access (for `snowflake-*` tools)
+- Filesystem access to locate SLA documentation PDFs
+- PDF processing tools (`pdf-tools-*`)
+- Email sending capability (`emails-send_email`)
+
+## Core Workflow
+
+### Phase 1: Environment Discovery
+1. **Identify the target database:**
+ - List available databases using `snowflake-list_databases`
+ - Look for databases with names suggesting SLA/ticket monitoring (e.g., `SLA_MONITOR`)
+
+2. **Explore the filesystem for SLA documentation:**
+ - List allowed directories using `filesystem-list_allowed_directories`
+ - Search for PDF files containing SLA information (e.g., `sla_manual.pdf`, `slamanual.pdf`)
+ - Extract archived documents if needed (e.g., `.tar.gz` files)
+
+### Phase 2: Schema & Document Analysis
+1. **Examine database structure:**
+ - List schemas in the target database
+ - List tables, focusing on `SUPPORT_TICKETS` and `USERS` tables
+ - Describe table structures to understand column relationships
+
+2. **Analyze SLA documentation:**
+ - Read PDFs to extract SLA rules (response times per service level)
+ - Extract email templates for manager reminders and customer apologies
+ - **Critical:** Verify document validity - ignore documents marked as "OBSOLETE"
+
+### Phase 3: Identify Overdue Tickets
+1. **Query for overdue tickets:**
+ - Join `SUPPORT_TICKETS` with `USERS` on `USER_ID`
+ - Filter for tickets where `FIRST_RESPONSE_AT` IS NULL
+ - Calculate hours elapsed since `CREATED_AT`
+ - Apply SLA thresholds based on `SERVICE_LEVEL`:
+ - `basic`: 72 hours
+ - `pro`: 36 hours
+ - `max`: 24 hours
+ - Order results by service level priority (max → pro → basic) then creation date
+
+2. **Use the SQL query template** from `references/sla_query.sql`
+
+### Phase 4: Generate & Send Notifications
+1. **Organize tickets by responsible manager** using `CUSTOMER_MANAGER` field
+2. **Send manager reminder emails:**
+ - Use template from `assets/manager_reminder_template.txt`
+ - List tickets in max → pro → basic order
+ - Include ticket numbers and service levels
+3. **Send customer apology emails:**
+ - Use template from `assets/customer_apology_template.txt`
+ - Customize with:
+ - `{TICKET_NUMBER}`
+ - `{SECOND_REPLY_TIME}` (based on service level: max=18h, pro=36h, basic=72h)
+
+## Key Considerations
+- **Document Version Control:** Always check for "OBSOLETE" markers in PDFs
+- **Time Calculations:** Use `TIMESTAMPDIFF(HOUR, CREATED_AT, CURRENT_TIMESTAMP())` for accurate elapsed time
+- **Email Templates:** Strictly follow the templates specified in the SLA documentation
+- **Error Handling:** If no overdue tickets are found, provide a clear status message
+- **Data Privacy:** Ensure email addresses are handled appropriately
+
+## Output
+Provide a summary report including:
+- Number of overdue tickets identified
+- Breakdown by service level and manager
+- Confirmation of emails sent
+- Any errors or warnings encountered
diff --git a/skills/benchmark_skills/toolathlon/sla-compliance-monitor/assets/customer_apology_template.txt b/skills/benchmark_skills/toolathlon/sla-compliance-monitor/assets/customer_apology_template.txt
new file mode 100644
index 0000000..4e6aa0e
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/sla-compliance-monitor/assets/customer_apology_template.txt
@@ -0,0 +1,15 @@
+Subject: Update on Your Service Request {TICKET_NUMBER}
+
+Dear Customer,
+
+We sincerely apologize for not responding to your service request {TICKET_NUMBER} within the promised timeframe.
+
+We commit to providing an initial solution or the latest status update within {SECOND_REPLY_TIME} hours, and will continue following up until the issue is fully resolved.
+
+For urgent matters, please contact us directly:
+Phone: 400-772-1234
+
+We apologize again for any inconvenience this may have caused.
+
+Best,
+MCP Inc., Customer Support Team
diff --git a/skills/benchmark_skills/toolathlon/sla-compliance-monitor/assets/manager_reminder_template.txt b/skills/benchmark_skills/toolathlon/sla-compliance-monitor/assets/manager_reminder_template.txt
new file mode 100644
index 0000000..230253a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/sla-compliance-monitor/assets/manager_reminder_template.txt
@@ -0,0 +1,10 @@
+Subject: [Overdue Alert] Tickets Exceeding First Reply SLA
+
+Dear Manager,
+
+The following tickets have exceeded the SLA first reply time. Please prioritize and coordinate processing:
+
+{TICKET_LIST}
+
+Best,
+MCP Inc., Customer Support Team
diff --git a/skills/benchmark_skills/toolathlon/sla-compliance-monitor/references/sla_query.sql b/skills/benchmark_skills/toolathlon/sla-compliance-monitor/references/sla_query.sql
new file mode 100644
index 0000000..16c5342
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/sla-compliance-monitor/references/sla_query.sql
@@ -0,0 +1,37 @@
+-- Query to identify tickets exceeding SLA first response time
+SELECT
+ t.TICKET_NUMBER,
+ t.SUBJECT,
+ t.STATUS,
+ t.CREATED_AT,
+ t.FIRST_RESPONSE_AT,
+ u.NAME as USER_NAME,
+ u.EMAIL as USER_EMAIL,
+ u.SERVICE_LEVEL,
+ u.CUSTOMER_MANAGER,
+ TIMESTAMPDIFF(HOUR, t.CREATED_AT, CURRENT_TIMESTAMP()) as HOURS_SINCE_CREATED,
+ CASE
+ WHEN u.SERVICE_LEVEL = 'basic' THEN 72
+ WHEN u.SERVICE_LEVEL = 'pro' THEN 36
+ WHEN u.SERVICE_LEVEL = 'max' THEN 24
+ END as SLA_HOURS,
+ CASE
+ WHEN u.SERVICE_LEVEL = 'basic' THEN 72
+ WHEN u.SERVICE_LEVEL = 'pro' THEN 36
+ WHEN u.SERVICE_LEVEL = 'max' THEN 18
+ END as SECOND_REPLY_HOURS
+FROM SUPPORT_TICKETS t
+JOIN USERS u ON t.USER_ID = u.ID
+WHERE t.FIRST_RESPONSE_AT IS NULL
+ AND (
+ (u.SERVICE_LEVEL = 'basic' AND TIMESTAMPDIFF(HOUR, t.CREATED_AT, CURRENT_TIMESTAMP()) > 72)
+ OR (u.SERVICE_LEVEL = 'pro' AND TIMESTAMPDIFF(HOUR, t.CREATED_AT, CURRENT_TIMESTAMP()) > 36)
+ OR (u.SERVICE_LEVEL = 'max' AND TIMESTAMPDIFF(HOUR, t.CREATED_AT, CURRENT_TIMESTAMP()) > 24)
+ )
+ORDER BY
+ CASE u.SERVICE_LEVEL
+ WHEN 'max' THEN 1
+ WHEN 'pro' THEN 2
+ WHEN 'basic' THEN 3
+ END,
+ t.CREATED_AT ASC;
diff --git a/skills/benchmark_skills/toolathlon/sla-compliance-monitor/references/sla_response_times.md b/skills/benchmark_skills/toolathlon/sla-compliance-monitor/references/sla_response_times.md
new file mode 100644
index 0000000..9838f93
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/sla-compliance-monitor/references/sla_response_times.md
@@ -0,0 +1,19 @@
+# SLA Response Time Standards
+Extracted from MCP Inc. Service Standards & Operations Handbook (June 2024)
+
+## User Levels and Response Times
+
+| User Level | First Reply Time | Second Reply Time (if first reply is overdue) |
+|------------|------------------|-----------------------------------------------|
+| Basic | 72 hours | 72 hours |
+| Pro | 36 hours | 36 hours |
+| Max | 24 hours | 18 hours |
+
+## Definitions
+- **First Reply Time**: Maximum time from ticket creation to the first customer contact
+- **Second Reply Time**: If the first reply exceeds the deadline, you must send an apology email stating that the next reply will be sent within this time frame
+
+## Notes
+- These times apply only to tickets where `FIRST_RESPONSE_AT` IS NULL
+- Response time calculation: `TIMESTAMPDIFF(HOUR, CREATED_AT, CURRENT_TIMESTAMP())`
+- Tickets should be prioritized in order: Max → Pro → Basic
diff --git a/skills/benchmark_skills/toolathlon/snowflake-database-analyzer/SKILL.md b/skills/benchmark_skills/toolathlon/snowflake-database-analyzer/SKILL.md
new file mode 100644
index 0000000..6cfa15a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/snowflake-database-analyzer/SKILL.md
@@ -0,0 +1,47 @@
+---
+name: snowflake-database-analyzer
+description: When the user needs to explore, analyze, and manipulate Snowflake database structures and data. This skill provides 1) Listing databases, schemas, and tables within Snowflake environments, 2) Describing table structures including column names, data types, and constraints, 3) Executing read queries to extract employee data, task assignments, and status information, 4) Performing write operations to insert new records or update existing data, 5) Joining tables to establish relationships between employees, managers, and tasks, 6) Querying current dates and comparing with deadlines. Triggers include 'Snowflake database', 'query employee data', 'database schema exploration', 'data extraction from tables', 'database updates'.
+---
+# Instructions
+
+## Core Workflow
+This skill orchestrates a multi-step process to manage employee onboarding and task reminders via a Snowflake database. Follow these steps precisely.
+
+### 1. Initial Exploration & Context Gathering
+* **Objective:** Understand the database landscape and locate the relevant onboarding document.
+* **Actions:**
+ 1. List all available Snowflake databases. Identify the one likely containing employee data (e.g., `LANDING_TASK_REMINDER`).
+ 2. List the contents of the `/workspace/dumps/workspace` directory to find the onboarding PDF (e.g., `landing_tips.pdf`).
+ 3. Read the PDF to extract the standardized task list, deadlines (D+7, D+30, etc.), and group assignments (Backend, Frontend, Testing, Data).
+
+### 2. Database Schema Investigation
+* **Objective:** Map the database structure to understand how data is organized.
+* **Actions:**
+ 1. List all schemas within the target database.
+ 2. List all tables within the target schema (e.g., `PUBLIC`).
+ 3. Describe the key tables to understand their columns:
+ * `EMPLOYEE` (ID, Name, Email, Manager_ID)
+ * `EMPLOYEE_LANDING` (Employee_ID, Landing_Date, Task_Assigned_Flag)
+ * `PUBLIC_TASKS` (Employee_ID, Task_Name, Deadline, Status)
+ * Group-specific task tables (`GROUP_TASKS_BACKEND`, `GROUP_TASKS_FRONTEND`, etc.)
+
+### 3. Data Analysis & Logic Building
+* **Objective:** Identify new employees needing onboarding and existing employees with overdue tasks.
+* **Actions:**
+ 1. Query the `EMPLOYEE` and `EMPLOYEE_LANDING` tables. Cross-reference to find employees where `LANDING_TASK_ASSIGNED = FALSE`. These are the new hires.
+ 2. For each new hire, determine their group/manager by joining the `EMPLOYEE` table with itself (manager lookup via `REPORT_TO_ID`). Infer group from manager ID based on historical data from group task tables.
+ 3. Get the current date (`CURRENT_DATE()`).
+ 4. For each task table (`PUBLIC_TASKS`, `GROUP_TASKS_*`), query for records where `FINISHED_FLAG = FALSE` AND `DDL < CURRENT_DATE()`. Join with employee/manager data for context.
+
+### 4. Data Manipulation & Task Creation
+* **Objective:** Create task records for new employees and update their status flags.
+* **Actions:**
+ 1. For each new employee, calculate deadlines based on their landing date and the rules from the PDF (e.g., Public Tasks: D+7, Backend Tasks: D+30).
+ 2. Execute `INSERT` statements into `PUBLIC_TASKS` and the appropriate `GROUP_TASKS_*` table with the task names, calculated deadlines, and `FINISHED_FLAG = FALSE`.
+ 3. Update the `EMPLOYEE_LANDING` table, setting `LANDING_TASK_ASSIGNED = TRUE` for the processed new hires.
+
+### 5. Communication & Notification
+* **Objective:** Send formatted emails to employees and their managers.
+* **Actions:**
+ 1. **For New Employees (Onboarding):** Generate an email for each new hire. Use the exact format:
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/snowflake-database-analyzer/references/email_templates.md b/skills/benchmark_skills/toolathlon/snowflake-database-analyzer/references/email_templates.md
new file mode 100644
index 0000000..e7cdda8
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/snowflake-database-analyzer/references/email_templates.md
@@ -0,0 +1,9 @@
+# Email Template Reference
+
+Use these exact templates for generating notification emails.
+
+## Onboarding Email Template
+**Subject:** `Onboarding Training Tasks`
+**To:** `{employee_email}`
+**CC:** `{manager_email}`
+
diff --git a/skills/benchmark_skills/toolathlon/snowflake-database-analyzer/references/task_schema.md b/skills/benchmark_skills/toolathlon/snowflake-database-analyzer/references/task_schema.md
new file mode 100644
index 0000000..5d1c345
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/snowflake-database-analyzer/references/task_schema.md
@@ -0,0 +1,46 @@
+# Task Table Schema Reference
+
+This document details the structure of the task-related tables observed in the trajectory.
+
+## Common Schema Across All Task Tables
+All task tables share a similar structure for consistency.
+
+| Column Name | Data Type | Description | Constraints |
+|-------------|-----------|-------------|-------------|
+| `EMPLOYEE_ID` | NUMBER | Foreign key to the EMPLOYEE table. | NOT NULL |
+| `TASK_NAME` | TEXT | The name/description of the training task. | NOT NULL |
+| `CREATE_DATE` | DATE | The date the task record was created. | NOT NULL |
+| `DDL` | DATE | The deadline for task completion. | NOT NULL |
+| `FINISHED_FLAG` | BOOLEAN | Indicates if the task is complete (`TRUE`) or not (`FALSE`). | NOT NULL |
+
+## Table Specifics
+
+### PUBLIC_TASKS
+Contains mandatory training tasks for **all employees**, regardless of department.
+* **Example Tasks:** Onboarding Training, Security Training, Confidentiality Training, Company Culture, Company Strategy.
+* **Standard Deadline:** D+7 (7 calendar days after the employee's `LANDING_DATE`).
+
+### GROUP_TASKS_BACKEND
+Contains role-specific training tasks for **Backend** department employees.
+* **Example Tasks:** Backend Development Process, Backend Development Standards, Backend Development Environment.
+* **Standard Deadline:** D+30.
+
+### GROUP_TASKS_FRONTEND
+Contains role-specific training tasks for **Frontend** department employees.
+* **Example Tasks:** Frontend Development Process, Frontend Development Standards, Frontend Development Environment.
+* **Standard Deadline:** D+45.
+
+### GROUP_TASKS_TESTING
+Contains role-specific training tasks for **Testing/QA** department employees.
+* **Example Tasks:** Testing Development Process, Testing Development Standards, Testing Development Environment.
+* **Standard Deadline:** D+60.
+
+### GROUP_TASKS_DATA
+Contains role-specific training tasks for **Data** department employees.
+* **Example Tasks:** Data Development Process, Data Development Standards, Data Development Environment.
+* **Standard Deadline:** D+75.
+
+## Key Relationships
+* `EMPLOYEE_ID` in any task table references `EMPLOYEE.EMPLOYEE_ID`.
+* An employee's group is inferred by which `GROUP_TASKS_*` table they have records in, or by their manager's ID (`EMPLOYEE.REPORT_TO_ID`).
+* The `EMPLOYEE_LANDING.LANDING_TASK_ASSIGNED` flag should be set to `TRUE` after initial tasks are inserted for a new employee.
diff --git a/skills/benchmark_skills/toolathlon/sports-schedule-analyzer/SKILL.md b/skills/benchmark_skills/toolathlon/sports-schedule-analyzer/SKILL.md
new file mode 100644
index 0000000..03d5b63
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/sports-schedule-analyzer/SKILL.md
@@ -0,0 +1,45 @@
+---
+name: sports-schedule-analyzer
+description: Analyzes sports league schedules to extract statistical insights about team schedules, including back-to-back games, home/away patterns, travel analysis, or schedule density. Processes schedule data from spreadsheets or structured sources, identifies consecutive game patterns, categorizes them by location configurations (HA, AH, HH, AA), and generates team-by-team breakdowns.
+---
+# Instructions
+
+## 1. Identify and Load Schedule Data
+- **Primary Source**: Look for a spreadsheet containing the schedule. The user may specify a title (e.g., "NHL 2425 Schedule") or you may need to list available spreadsheets to find it.
+- **Confirm Structure**: The schedule should contain at minimum: **Date**, **Visitor Team**, and **Home Team** columns. Additional columns (time, scores, status) are acceptable but not required for core analysis.
+- **Load Data**: Use the `google_sheet-get_sheet_data` tool to fetch the raw data. Be prepared for large datasets; the tool may return an "overlong" output saved to a file.
+
+## 2. Parse and Prepare Data
+- **Execute the Parsing Script**: Run the bundled `parse_schedule.py` script. It will:
+ 1. Load the overlong tool output from the workspace dump directory.
+ 2. Extract the `Date`, `Visitor`, and `Home` fields from each row (skipping the header).
+ 3. Build a chronological list of games for each team, tagging each game with its location (`H` for Home, `A` for Away).
+ 4. Sort each team's schedule by date.
+
+## 3. Perform Back-to-Back Analysis
+- **Execute the Analysis Script**: Run the bundled `analyze_back_to_back.py` script. It will:
+ 1. For each team, iterate through its sorted game list.
+ 2. Identify consecutive game dates (difference of 1 day).
+ 3. Categorize each back-to-back set into one of four configurations based on the location sequence:
+ - **HA**: Home → Away
+ - **AH**: Away → Home
+ - **HH**: Home → Home
+ - **AA**: Away → Away
+ 4. Tally the counts for each team and calculate the total.
+
+## 4. Generate and Deliver Results
+- **Create Output Spreadsheet**: Create a new Google Sheet with a descriptive title (e.g., "NHL-B2B-Analysis").
+- **Rename Default Sheet**: Rename the default sheet to something meaningful like "B2B Analysis".
+- **Populate Data**: Update the sheet with the results. The table must have the exact headers: `Team,HA,AH,HH,AA,Total`. Populate rows for all teams in alphabetical order.
+- **Verify**: Optionally, fetch a small range of the new sheet to confirm successful creation and data accuracy.
+
+## 5. Provide Summary Insights
+After completing the analysis, offer a concise verbal summary to the user. Highlight:
+- The team with the **most** and **fewest** total back-to-back sets.
+- Notable patterns in configuration distribution (e.g., which configuration is most common league-wide).
+- Any other observations from the data (e.g., teams with unusually high AA counts indicating long road trips).
+
+## Key Triggers & Adaptations
+- The skill is triggered by requests for: "back-to-back analysis", "schedule analysis", "home/away breakdown", "travel analysis", or analysis of "schedule patterns".
+- While the example trajectory is for the NHL, the core logic applies to any league (NBA, MLB, NFL) with a similar schedule structure. Ensure the parsing script correctly identifies the relevant column names for the given dataset.
+- If the user requests a different type of schedule analysis (e.g., longest homestand, travel miles), adapt the analysis script logic accordingly, using the parsed team schedule data as a foundation.
diff --git a/skills/benchmark_skills/toolathlon/sports-schedule-analyzer/references/configuration_definitions.md b/skills/benchmark_skills/toolathlon/sports-schedule-analyzer/references/configuration_definitions.md
new file mode 100644
index 0000000..a16d860
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/sports-schedule-analyzer/references/configuration_definitions.md
@@ -0,0 +1,40 @@
+# Back-to-Back Configuration Definitions
+
+## Core Configurations
+The analysis categorizes consecutive game pairs (back-to-back sets) into four mutually exclusive configurations based on game location sequence:
+
+1. **HA (Home-Away)**
+ - Day 1: Team plays at **Home**
+ - Day 2: Team plays **Away**
+ - *Typical scenario*: Team finishes a homestand and travels for an away game.
+
+2. **AH (Away-Home)**
+ - Day 1: Team plays **Away**
+ - Day 2: Team plays at **Home**
+ - *Typical scenario*: Team returns from a road trip to play at home.
+
+3. **HH (Home-Home)**
+ - Day 1: Team plays at **Home**
+ - Day 2: Team plays at **Home**
+ - *Typical scenario*: Consecutive home games during a homestand.
+
+4. **AA (Away-Away)**
+ - Day 1: Team plays **Away**
+ - Day 2: Team plays **Away**
+ - *Typical scenario*: Consecutive away games during a road trip.
+
+## Analysis Assumptions
+- **Consecutive Days**: Games are considered "back-to-back" if they occur on consecutive calendar days (difference of 1 day).
+- **Team Perspective**: Analysis is performed from each team's individual schedule perspective.
+- **Neutral Sites**: Games at neutral sites should be classified based on the team's designation (usually as "Away" unless specified as the designated home team).
+
+## Common Patterns
+- High **AA** counts often indicate compact road trips or challenging travel schedules.
+- High **HH** counts suggest extended homestands, which can be advantageous.
+- **HA** and **AH** configurations involve travel between games, which may impact team performance due to fatigue.
+
+## Adapting for Different Sports
+- **NHL**: 82-game season, frequent back-to-backs due to arena scheduling.
+- **NBA**: 82-game season, similar back-to-back frequency.
+- **MLB**: 162-game season, fewer true back-to-backs (more series-based scheduling).
+- **NFL**: 17-game season, rarely has back-to-back games (weekly schedule).
diff --git a/skills/benchmark_skills/toolathlon/sports-schedule-analyzer/references/workflow_example.md b/skills/benchmark_skills/toolathlon/sports-schedule-analyzer/references/workflow_example.md
new file mode 100644
index 0000000..a8e6a86
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/sports-schedule-analyzer/references/workflow_example.md
@@ -0,0 +1,13 @@
+# Complete Workflow Example: NHL Back-to-Back Analysis
+
+This document illustrates the complete end-to-end workflow executed in the provided trajectory.
+
+## Step 1: Locate Source Data
+**User Request**: "Analyze the NHL 2024-2025 schedule in spreadsheet `NHL 2425 Schedule`"
+
+**Agent Actions**:
+1. List available spreadsheets to confirm existence.
+2. List sheets within the target spreadsheet to identify the schedule tab.
+3. Fetch the complete schedule data (may result in overlong output).
+
+**Tool Calls**:
diff --git a/skills/benchmark_skills/toolathlon/spread-analysis-calculator/SKILL.md b/skills/benchmark_skills/toolathlon/spread-analysis-calculator/SKILL.md
new file mode 100644
index 0000000..d1dbe59
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/spread-analysis-calculator/SKILL.md
@@ -0,0 +1,89 @@
+---
+name: spread-analysis-calculator
+description: Calculates price spreads, MoM% changes, and rolling z-scores for pair trading analysis. Implements statistical normalization with configurable parameters.
+---
+# Skill: Spread Analysis Calculator
+
+## Purpose
+Perform statistical analysis on price spreads between two financial instruments (e.g., WTI-Brent, gold-silver). Calculate spread values, month-over-month percentage changes, and rolling z-scores for pair trading strategies.
+
+## Core Workflow
+
+### 1. Data Collection & Preparation
+- **Input**: Two time-series datasets (e.g., WTI and Brent monthly closes)
+- **Action**: Fetch data from specified sources (Yahoo Finance, CSV files, APIs)
+- **Output**: Aligned, cleaned datasets with consistent timestamps
+
+### 2. Spread Calculation
+- **Formula**: `Spread = Instrument_B - Instrument_A`
+- **Precision**: Round to 4 decimal places for prices, 2 decimal places for percentages
+
+### 3. MoM% Calculation
+- **Formula**: `MoM% = (Current_Value / Previous_Value - 1) × 100%`
+- **Handling**: First month has `null`/`None` MoM value
+- **Apply to**: Both individual instruments and the spread
+
+### 4. Z-Score Calculation (Rolling Window)
+- **Window**: Configurable (default: 6 periods)
+- **Statistics**:
+ - Mean: `μ = Σx / n`
+ - Sample Std Dev: `σ = √[Σ(x - μ)² / (n - 1)]` (ddof=1)
+ - Z-Score: `z = (x - μ) / σ`
+- **Edge Cases**:
+ - Return `z = 0` if window has < 4 samples
+ - Return `z = 0` if standard deviation = 0
+ - Clip z-scores to range [-3, 3]
+- **Output**: Z-score for current period based on rolling window
+
+### 5. Signal Generation (Optional)
+- **Thresholds**: Configurable (default: ±1)
+ - `z ≤ -threshold`: LONG_SPREAD (Long B + Short A)
+ - `z ≥ +threshold`: SHORT_SPREAD (Short B + Long A)
+ - Otherwise: FLAT
+- **Regime Classification**:
+ - `z ≥ +threshold`: HIGH
+ - `z ≤ -threshold`: LOW
+ - Otherwise: NEUTRAL
+
+### 6. Backtest Implementation (Optional)
+When backtesting is requested:
+- **Position Rules**:
+ - Signals generated at period-end
+ - Held for 1 period, closed at next period-end
+ - Only one position at a time
+ - Equal weight on both legs
+- **Return Calculation**:
+ - For LONG_SPREAD: `Return = 0.5 × (B_return) + 0.5 × (-A_return)`
+ - For SHORT_SPREAD: `Return = 0.5 × (-B_return) + 0.5 × (A_return)`
+ - Include transaction costs (configurable, default: 0.40% round-trip)
+- **Performance Metrics**:
+ - Total Return (compounded)
+ - Annualized Return
+ - Sharpe Ratio (annualized)
+ - Win Rate
+ - Maximum Drawdown
+
+## Output Structure
+Generate analysis results in this format:
+1. **Summary Table**: Period, Instrument A Close, Instrument B Close, Spread, MoM%, Z-Score, Signal, Regime
+2. **Trade Log** (if backtesting): Entry/Exit dates, signals, spreads, returns, PnL
+3. **Performance Metrics** (if backtesting): Total return, Sharpe, win rate, max drawdown
+
+## Error Handling
+- Validate data alignment (same timestamps, no missing periods)
+- Handle division by zero in MoM% calculations
+- Gracefully handle insufficient data for z-score windows
+- Log warnings for edge cases
+
+## Configuration Parameters
+- `window_size`: Rolling window for z-score (default: 6)
+- `z_threshold`: Signal threshold (default: 1.0)
+- `clip_range`: Z-score clipping range (default: [-3, 3])
+- `min_samples`: Minimum samples for z-score (default: 4)
+- `transaction_cost`: Round-trip cost for backtest (default: 0.40%)
+- `ddof`: Degrees of freedom for std dev (default: 1)
+
+## Integration Notes
+- Use `scripts/calculate_spread.py` for core calculations
+- Refer to `references/calculation_methodology.md` for detailed formulas
+- Customize output format based on destination (Notion, CSV, JSON, etc.)
diff --git a/skills/benchmark_skills/toolathlon/statistical-anomaly-detector/SKILL.md b/skills/benchmark_skills/toolathlon/statistical-anomaly-detector/SKILL.md
new file mode 100644
index 0000000..c109786
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/statistical-anomaly-detector/SKILL.md
@@ -0,0 +1,59 @@
+---
+name: statistical-anomaly-detector
+description: When the user requests anomaly detection in numerical datasets using statistical methods such as mean and standard deviation thresholds (e.g., 'amount > mean + 3*std'). This skill calculates per-group statistics, identifies outliers, and flags abnormal records. It is triggered by keywords like 'anomaly detection', 'outlier identification', 'statistical threshold', 'abnormal transactions', or any request involving standard deviation-based filtering in financial or transactional data.
+---
+# Instructions
+
+## Core Objective
+Detect anomalous records in a dataset by applying a statistical threshold rule (e.g., `value > mean + N * standard_deviation`) on a per-group basis. Output the flagged anomalies, typically to a structured file like an Excel spreadsheet.
+
+## Trigger Keywords & Phrases
+- "anomaly detection"
+- "outlier identification"
+- "statistical threshold"
+- "abnormal transactions/records"
+- "flag transactions where amount > mean + 3*std"
+- "find outliers using standard deviation"
+- "mark abnormal data points"
+
+## Primary Workflow
+Follow this sequence when the skill is triggered:
+
+1. **Understand the Request & Locate Inputs**
+ * Clarify the target dataset (e.g., BigQuery table, CSV file), the numerical column for analysis (e.g., `amount`), and the grouping column (e.g., `client_id`).
+ * Identify the threshold rule (e.g., `mean + 3 * std`). The default is `mean + 3 * std` unless specified otherwise.
+ * Locate the output destination (e.g., an Excel file path and target sheet).
+
+2. **Inspect the Output Template**
+ * Examine the structure of the target output file (e.g., using `excel-get_workbook_metadata`).
+ * Read a sample of the existing data to understand the required column headers and format (e.g., using `excel-read_data_from_excel`).
+ * **Remove any placeholder or sample data** from the output file before writing new results.
+
+3. **Extract Data & Calculate Statistics**
+ * Query or load the source data, filtering for the relevant records (e.g., by year, by group).
+ * Use a single, efficient query/calculation to:
+ * Compute the mean (`AVG`) and standard deviation (`STDDEV`) for the numerical column, grouped by the specified group column.
+ * Join these statistics back to the original records.
+ * Apply the threshold rule to flag anomalies (e.g., `WHERE numerical_column > (mean + N * std)`).
+ * **Sort the final results** as requested (commonly by a record ID).
+
+4. **Format and Write Results**
+ * Format the anomaly records (client_id, transaction_id, timestamp, etc.) to match the output template's column order and data types.
+ * Write the formatted records to the output file, starting from the first data row after the headers.
+ * Preserve all existing formatting and sheet structure.
+
+5. **Verify and Summarize**
+ * Read back a portion of the updated file to confirm successful writing.
+ * Provide a concise summary to the user: state the number of anomalies found, the groups analyzed, and the output file location.
+
+## Key Considerations
+* **Data Volume:** For large datasets, ensure queries are efficient and use appropriate limits or batch processing.
+* **Output Handling:** Always check the output file's structure before writing. Do not overwrite unintended sheets or data.
+* **Clarity:** If the user's request is ambiguous (e.g., missing group column or threshold value), ask for clarification before proceeding.
+* **Tool Selection:** Prefer using direct database/query tools (e.g., `google-cloud-bigquery_run_query`) for statistical calculations over manual Python processing for efficiency and accuracy.
+
+## Common Pitfalls to Avoid
+* Forgetting to clear sample data from the output template.
+* Incorrectly formatting timestamps or numerical values when writing to Excel.
+* Writing results in an unsorted order when sorting is explicitly requested.
+* Making multiple unnecessary queries; combine data extraction and statistical calculation into one operation where possible.
diff --git a/skills/benchmark_skills/toolathlon/statistical-anomaly-detector/references/bigquery_anomaly_template.sql b/skills/benchmark_skills/toolathlon/statistical-anomaly-detector/references/bigquery_anomaly_template.sql
new file mode 100644
index 0000000..3f11525
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/statistical-anomaly-detector/references/bigquery_anomaly_template.sql
@@ -0,0 +1,56 @@
+/*
+BigQuery SQL Template for Anomaly Detection
+Purpose: A reusable, parameterized SQL query to efficiently extract anomalies in one pass.
+Modify the bracketed parameters [ ] based on the specific task.
+*/
+
+WITH group_stats AS (
+ SELECT
+ [GROUP_COLUMN], -- e.g., client_id, department_id
+ AVG([VALUE_COLUMN]) AS mean_value,
+ STDDEV([VALUE_COLUMN]) AS std_value
+ FROM
+ `[PROJECT.DATASET.TABLE_NAME]`
+ WHERE
+ [OPTIONAL_FILTER_CONDITIONS] -- e.g., EXTRACT(YEAR FROM txn_time) = 2025
+ GROUP BY
+ [GROUP_COLUMN]
+),
+all_records AS (
+ SELECT
+ [RECORD_ID_COLUMN], -- e.g., transaction_id
+ [GROUP_COLUMN],
+ [VALUE_COLUMN],
+ [ADDITIONAL_COLUMNS], -- e.g., txn_time, currency, status
+ [TIMESTAMP_COLUMN] -- for formatting if needed
+ FROM
+ `[PROJECT.DATASET.TABLE_NAME]`
+ WHERE
+ [OPTIONAL_FILTER_CONDITIONS] -- Must match the filter in group_stats
+)
+SELECT
+ a.[GROUP_COLUMN],
+ a.[RECORD_ID_COLUMN],
+ a.[VALUE_COLUMN],
+ -- Include additional columns for the report
+ a.[ADDITIONAL_COLUMNS],
+ -- Format timestamp if necessary for Excel compatibility
+ FORMAT_TIMESTAMP('%Y-%m-%d %H:%M:%S.%f UTC', a.[TIMESTAMP_COLUMN]) AS formatted_timestamp,
+ -- Statistics for verification (can be omitted in final report)
+ s.mean_value,
+ s.std_value,
+ (s.mean_value + [N] * s.std_value) AS threshold, -- [N] is the sigma multiplier (e.g., 3)
+ 'ANOMALY' AS status
+FROM
+ all_records a
+JOIN
+ group_stats s
+ON
+ a.[GROUP_COLUMN] = s.[GROUP_COLUMN]
+WHERE
+ -- Apply the anomaly rule: value > mean + N*std
+ a.[VALUE_COLUMN] > (s.mean_value + [N] * s.std_value)
+ -- For lower-bound anomalies: a.[VALUE_COLUMN] < (s.mean_value - [N] * s.std_value)
+ORDER BY
+ a.[RECORD_ID_COLUMN] -- Or any other specified sort order
+-- LIMIT [MAX_RESULTS] -- Use if needed for very large anomaly sets
diff --git a/skills/benchmark_skills/toolathlon/structured-data-formatter/SKILL.md b/skills/benchmark_skills/toolathlon/structured-data-formatter/SKILL.md
new file mode 100644
index 0000000..074e9d7
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/structured-data-formatter/SKILL.md
@@ -0,0 +1,13 @@
+---
+name: structured-data-formatter
+description: When the user needs to format extracted data according to specific templates or reference formats, particularly when working with markdown files, YAML structures, or predefined output formats. This skill reads reference format files, extracts raw data from various sources, and transforms it into consistently structured output following specified formatting rules. It's triggered by keywords like 'format should reference', 'write to file with format', 'following template', or when users provide reference files for output formatting.
+---
+# Instructions
+
+## Primary Objective
+Format extracted data into a specified output structure by reading a reference format file and applying its template to raw data.
+
+## Core Workflow
+1. **Identify the Request:** The user will ask to write data to a file, explicitly mentioning a reference format file (e.g., "format should reference `format.md`") or a specific structure (e.g., "in YAML format").
+2. **Locate the Reference Format:**
+ * First, read the specified reference file (e.g., `format.md`) to understand the required output structure, headers, syntax (like YAML fences `
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/structured-data-formatter/references/format_example.md b/skills/benchmark_skills/toolathlon/structured-data-formatter/references/format_example.md
new file mode 100644
index 0000000..7df2eb9
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/structured-data-formatter/references/format_example.md
@@ -0,0 +1,8 @@
+# Example Reference Format File (`format.md`)
+
+This is an example of a reference format file that this skill might be instructed to use. The skill reads this to understand the required output structure.
+
+## Structure
+The file typically contains:
+1. A **title or header** describing the content.
+2. A **code block** denoting the target format (e.g., `
\ No newline at end of file
diff --git a/skills/benchmark_skills/toolathlon/temporal-transaction-recorder/SKILL.md b/skills/benchmark_skills/toolathlon/temporal-transaction-recorder/SKILL.md
new file mode 100644
index 0000000..b8cf2ed
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/temporal-transaction-recorder/SKILL.md
@@ -0,0 +1,67 @@
+---
+name: temporal-transaction-recorder
+description: When the user requests to add transaction records from specific time periods (like 'last week', 'week before last', 'this month', etc.) to an accounting system or spreadsheet. This skill retrieves transaction data from memory or knowledge graph, analyzes date ranges relative to a reference date, checks existing account book files (Excel/CSV), filters transactions based on temporal criteria, and appends the filtered records to the appropriate file while excluding transactions from specified time periods. It handles purchase/sales transactions, date calculations, and maintains data integrity in financial ledgers.
+---
+# Skill: Temporal Transaction Recorder
+
+## Purpose
+Add transaction records from specified past time periods (e.g., "last week", "week before last") to an existing account book (Excel file), while explicitly excluding transactions from other periods (e.g., "this week"). The skill coordinates reading from a memory/knowledge graph, interpreting date-based constraints, reading the target file, and performing filtered appends.
+
+## Core Workflow
+1. **Interpret Request & Calculate Dates**: Parse the user's request to identify the target time periods (to include) and the reference date (often "today"). Calculate the exact date ranges.
+2. **Retrieve Source Data**: Fetch transaction records from the memory/knowledge graph.
+3. **Locate & Inspect Target File**: Find the account book file (typically an Excel workbook) in the workspace and read its structure to determine where to append new data.
+4. **Filter & Transform Data**: Filter the retrieved transactions based on the calculated date ranges. Map the source data fields to the target file's column schema.
+5. **Append Data**: Write the filtered, transformed transaction records to the next available row in the target file.
+6. **Verify & Summarize**: Read back the newly added rows to confirm success and provide a clear summary to the user.
+
+## Detailed Instructions
+
+### 1. Parse the Request & Calculate Date Ranges
+- Extract the **reference date** (e.g., "Today is January 18, 2024"). If not provided, use the current date.
+- Identify the **inclusion periods** (e.g., "last week and the week before last").
+- Identify the **exclusion periods** (e.g., "do not include any transactions from this week").
+- Calculate concrete date ranges (start and end dates) for each period. Use ISO 8601 format (`YYYY-MM-DD`).
+- **Example Logic (for weeks, Monday-Sunday)**:
+ - This Week: Monday of the reference date's week to the reference date.
+ - Last Week: The 7-day period immediately preceding "This Week".
+ - Week Before Last: The 7-day period immediately preceding "Last Week".
+
+### 2. Retrieve Source Transaction Data
+- Use the `memory-read_graph` tool (or equivalent) to fetch stored transaction entities.
+- Look for entities of type `Purchase Transaction` or `Sales Transaction`.
+- Extract key fields from each transaction's `observations`: `Date`, `Product`, `Quantity`, `Supplier`/`Customer`, `Amount`. Note the entity type to determine the `Type` (Purchase/Sales).
+
+### 3. Locate and Inspect the Target Account Book
+- Use `filesystem-list_directory` to find files like `Account_Book.xlsx` in the workspace.
+- Use `excel-get_workbook_metadata` to confirm the sheet name (e.g., `Ledger`).
+- Use `excel-read_data_from_excel` to:
+ - Read the header row to understand the column schema (e.g., Date, Type, Product, Quantity, Unit Price, Total, Customer/Supplier, Notes).
+ - Determine the last used row (`used_ranges` from metadata or find the first empty row in column A).
+
+### 4. Filter and Prepare Data for Append
+- For each transaction from memory, check if its `Date` falls within any of the **inclusion** date ranges.
+- **Exclude** any transaction whose `Date` falls within an **exclusion** period.
+- For each included transaction:
+ - Map fields to the target sheet's columns.
+ - Calculate `Unit Price` if needed (`Amount / Quantity`).
+ - Ensure `Customer/Supplier` field is populated correctly based on transaction type.
+ - The `Notes` column can be left empty or populated from relevant observations.
+
+### 5. Append the Data to the Excel File
+- The `start_cell` for writing should be the first cell of the row immediately following the last used row (e.g., `A{last_row+1}`).
+- Use `excel-write_data_to_excel` with the prepared list of row data.
+- Write data in the exact column order of the target sheet.
+
+### 6. Verification and User Communication
+- Read back the appended section using `excel-read_data_from_excel` to confirm data was written correctly.
+- Provide a concise summary to the user:
+ - Number of transactions added.
+ - List them briefly (Date, Type, Product, Amount).
+ - Explicitly state which transactions (if any) were excluded and why (e.g., "Excluded transaction from 2024-01-16 as it falls within 'this week'").
+
+## Key Considerations
+- **Date Handling**: Be precise with date logic. Assume weeks start on Monday unless specified otherwise.
+- **Schema Matching**: The skill must adapt to the existing file's column order and naming. Do not assume a fixed schema.
+- **Data Integrity**: Never overwrite existing data. Always append.
+- **Error Handling**: If the target file doesn't exist, inform the user. If the memory contains no relevant transactions, state this clearly.
diff --git a/skills/benchmark_skills/toolathlon/temporal-transaction-recorder/references/excel_schema_example.md b/skills/benchmark_skills/toolathlon/temporal-transaction-recorder/references/excel_schema_example.md
new file mode 100644
index 0000000..16f867e
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/temporal-transaction-recorder/references/excel_schema_example.md
@@ -0,0 +1,38 @@
+# Account Book Schema Example
+
+Based on the trajectory, the target Excel file (`Account_Book.xlsx`) has the following structure:
+
+## Sheet Name: `Ledger`
+
+| Column | Header | Data Type | Description |
+|--------|--------|-----------|-------------|
+| A | Date | Date (YYYY-MM-DD) | Transaction date |
+| B | Type | String | "Purchase" or "Sales" |
+| C | Product | String | Product name (e.g., "iPhone 15 Pro") |
+| D | Quantity | Integer | Number of units |
+| E | Unit Price | Number | Price per unit (in currency) |
+| F | Total | Number | Total amount (Quantity × Unit Price) |
+| G | Customer/Supplier | String | Customer name (for Sales) or Supplier name (for Purchase) |
+| H | Notes | String | Optional notes (e.g., "Discount X%") |
+
+## Data Mapping from Memory Graph
+
+Transaction entities from the memory graph typically have `observations` containing:
+- `Date YYYY-MM-DD`
+- `Product <Product Name>`
+- `Quantity <Number>`
+- `Supplier <Name>` (for Purchase) / `Customer <Name>` (for Sales)
+- `Amount <Number>` (Total amount)
+
+**Mapping Logic:**
+1. Determine `Type` from the entity's `entityType` ("Purchase Transaction" -> "Purchase", "Sales Transaction" -> "Sales").
+2. Extract `Date`, `Product`, `Quantity` directly.
+3. Use `Amount` as the `Total` column value.
+4. Calculate `Unit Price` = `Amount` / `Quantity`. Round if necessary.
+5. Populate `Customer/Supplier` with the appropriate name.
+6. `Notes` can be left empty or populated from other observations if needed.
+
+## Appending Data
+- New rows should be appended **after the last used row**.
+- The `used_ranges` metadata from `excel-get_workbook_metadata` indicates the current data boundary (e.g., `A1:H121`).
+- The next available row is `last_row + 1`. Write starting at cell `A{last_row+1}`.
diff --git a/skills/benchmark_skills/toolathlon/temporal-transaction-recorder/references/transaction_memory_schema.md b/skills/benchmark_skills/toolathlon/temporal-transaction-recorder/references/transaction_memory_schema.md
new file mode 100644
index 0000000..4f9b0b1
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/temporal-transaction-recorder/references/transaction_memory_schema.md
@@ -0,0 +1,12 @@
+# Memory Graph Transaction Schema
+
+The skill reads transaction data from a memory/knowledge graph. The expected structure (based on the trajectory) is as follows:
+
+## Entity Types
+1. **Product**: `entityType: "Product"`. Contains observations about products.
+2. **Customer**: `entityType: "Customer"`. Contains observations about customers.
+3. **Supplier**: `entityType: "Supplier"`. Contains observations about suppliers.
+4. **Purchase Transaction**: `entityType: "Purchase Transaction"`. Represents a stock purchase.
+5. **Sales Transaction**: `entityType: "Sales Transaction"`. Represents a product sale.
+
+## Key Transaction Entity Structure
diff --git a/skills/benchmark_skills/toolathlon/test-results-reporter/SKILL.md b/skills/benchmark_skills/toolathlon/test-results-reporter/SKILL.md
new file mode 100644
index 0000000..59677bc
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/test-results-reporter/SKILL.md
@@ -0,0 +1,35 @@
+---
+name: test-results-reporter
+description: When the user needs to execute test suites and generate formatted test reports with pass/fail status, summary statistics, and detailed results. This skill involves reading test specifications, running tests, evaluating outcomes, and creating structured markdown reports with proper formatting and summary metrics.
+---
+# Instructions
+
+## Overview
+This skill executes a test suite against a deployed application and generates a formatted markdown report. It follows a sequence of: 1) verifying the test environment and specifications, 2) systematically running each test, 3) evaluating the results against expected outcomes, and 4) compiling a final report with pass/fail status and summary statistics.
+
+## Core Workflow
+
+### 1. Initialize & Verify Environment
+* **Locate Test Files:** Identify the test specification file (e.g., `checkout.spec.js`) and the report template file (e.g., `test-results-report.md`). Read their contents to understand the test cases and the required report structure.
+* **Verify Deployment:** Ensure the target application (e.g., a web service) is accessible at the specified URL (e.g., `http://localhost:30123`). Use a simple HTTP request to confirm connectivity.
+* **Prepare Workspace:** Clear any persisted state from previous test runs (e.g., browser `localStorage`) to ensure test isolation.
+
+### 2. Execute Test Suite
+* **Follow Test Specification:** Execute tests in the order they are defined. For web applications, use browser automation tools (like Playwright) to interact with the UI.
+* **Test Categories:** Typically handle two main categories:
+ * **Functional/UI Tests:** Simulate user actions (clicks, form input, navigation) and assert UI state changes.
+ * **API Health Checks:** Verify HTTP status codes and response headers.
+* **Record Outcomes:** For each test case, determine a **Pass (✅)** or **Fail (❌)** result based on whether the actual outcome matches the expected behavior defined in the test spec.
+
+### 3. Generate the Test Report
+* **Populate Template:** Fill the pre-defined markdown report template. **Only** update the `Result` column cells with ✅ or ❌ and the `Summary Statistics` section (`Total Tests`, `Passed`, `Failed`). Do not modify any other text, structure, or headings.
+* **Save Output:** Write the completed report to the specified location in the workspace (e.g., `filled-test-results-report.md`).
+
+## Key Decision Points & Error Handling
+* **Test Failure Interpretation:** A test fails if the actual result deviates from the expected assertion in the specification, even if the application is functionally working (e.g., a business logic implementation differs from the test's expectation).
+* **Environment Issues:** If the application is not accessible, pause test execution and report the deployment issue before proceeding.
+* **Strict Template Adherence:** The report template is immutable. Only fill in the designated result cells and summary numbers.
+
+## Final Verification
+* Confirm the generated report file exists and is correctly formatted.
+* Optionally, provide a brief verbal summary of the test run (total tests, pass/fail count, and note any critical failures).
diff --git a/skills/benchmark_skills/toolathlon/test-results-reporter/references/report_template_example.md b/skills/benchmark_skills/toolathlon/test-results-reporter/references/report_template_example.md
new file mode 100644
index 0000000..af0c706
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/test-results-reporter/references/report_template_example.md
@@ -0,0 +1,24 @@
+# Test Results Report
+
+*Strict Note: you only need to fill the cells with ✅ or ❌ and edit the number of passed/failed tests, do not change, add or delete any other contents of this report!
+
+## Test Suite Category 1
+
+| Test Name | Result |
+|-|-|
+| Test Case 1 | |
+| Test Case 2 | |
+
+## Test Suite Category 2
+
+| Test Name | Result |
+|-|-|
+| API Test 1 | |
+| API Test 2 | |
+
+---
+
+**Summary Statistics:**
+- Total Tests: 0
+- Passed: 0
+- Failed: 0
diff --git a/skills/benchmark_skills/toolathlon/trading-strategy-backtester/SKILL.md b/skills/benchmark_skills/toolathlon/trading-strategy-backtester/SKILL.md
new file mode 100644
index 0000000..cf8a5e9
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/trading-strategy-backtester/SKILL.md
@@ -0,0 +1,67 @@
+---
+name: trading-strategy-backtester
+description: When the user wants to backtest a quantitative trading strategy based on specific signals, this skill implements strategy logic, executes simulated trades, calculates performance metrics, and generates comprehensive reports. It handles position sizing, transaction costs, holding periods, and computes key metrics like total return, annualized return, Sharpe ratio, win rate, and maximum drawdown. Triggers include backtesting requests, strategy evaluation, or trading performance analysis.
+---
+# Instructions
+
+## 1. Understand the Request
+- Identify the assets, signal logic, holding period, position sizing, and transaction costs from the user request or referenced documentation.
+- If a `detail.md` or similar spec file is mentioned, read it first.
+- Clarify any ambiguous parameters (e.g., "last 12 months" means 12 complete calendar months).
+
+## 2. Fetch Required Data
+- Use `yahoo-finance-get_historical_stock_prices` or equivalent data source to fetch historical price data for all specified assets/tickers.
+- Ensure data covers the required backtest period plus any lookback needed for indicator calculation (e.g., 6-month rolling Z-score).
+- Align data frequencies (e.g., monthly closes) and handle missing months if necessary.
+
+## 3. Calculate Indicators & Generate Signals
+- Implement the specified signal logic (e.g., Z-score thresholding).
+- Calculate all required indicators (e.g., spreads, MoM%, Z-scores) as defined.
+- Generate a clear signal for each period (e.g., Long Spread, Short Spread, Flat).
+
+## 4. Execute Strategy Backtest
+- Simulate trades based on signals:
+ - Entry: At period end when signal is generated (non-Flat).
+ - Exit: After the specified holding period (e.g., 1 month later).
+ - Position Sizing: Apply specified weights (e.g., equal weight on legs).
+ - Transaction Costs: Deduct specified round-trip cost from each trade's net PnL.
+- Only one position at a time; close existing position before opening new one if strategy rules require.
+- For spread trades (e.g., Long Spread = Long Asset A + Short Asset B), calculate leg returns and combine them according to position sizing.
+
+## 5. Calculate Performance Metrics
+Compute and report:
+- **Total Return %** (compounded across all trades)
+- **Annualized Return %** (based on actual backtest period length)
+- **Sharpe Ratio (annualized)** (using monthly returns, annualized with √12)
+- **Win Rate %** (percentage of profitable trades)
+- **Maximum Drawdown %** (peak-to-trough decline in cumulative returns)
+- **Number of Trades**
+- **Backtest Period** (Start and End dates)
+
+## 6. Prepare Output for Notion (or specified destination)
+- If the target is Notion databases:
+ 1. Identify the correct database IDs using `notion-API-post-search` or similar.
+ 2. Check existing entries; delete placeholder/empty rows if necessary.
+ 3. Create new pages for each record (e.g., monthly summary rows, trade rows, metric row).
+ 4. **Important**: The available `notion-API-post-page` and `notion-API-patch-page` functions have limited schemas and may only allow updating the `title` property. If database properties (number, select, rich_text) cannot be updated via these functions, append the data as content blocks using `notion-API-patch-block-children` as a workaround. Each block should present the data clearly in a human-readable format.
+- Structure output according to the database schemas described in the request (e.g., "Oil Market Summary" and "Spread Strategy Backtest").
+
+## 7. Generate Summary Report
+- Create a comprehensive markdown report summarizing:
+ - Executive Summary
+ - Data Overview & Key Observations
+ - Methodology (indicator calculations, strategy rules)
+ - Trade Details & Analysis
+ - Performance Metrics
+ - Conclusions & Recommendations
+- Save the report to a file in the workspace (e.g., `summary_report.md`).
+- Optionally, add a high-level summary to a main Notion page using content blocks.
+
+## 8. Use Bundled Scripts for Complex Calculations
+- For repetitive, complex, or error-prone calculations (e.g., Z-score rolling window, trade simulation, metric computation), use the bundled Python script `backtest_engine.py`.
+- Adapt the script's parameters (tickers, signal thresholds, costs, etc.) to match the current request.
+
+## Key Principles
+- **Data Validation**: Check for missing periods or data inconsistencies; inform the user if gaps exist.
+- **Transparency**: Document any assumptions or workarounds (e.g., Notion API limitations).
+- **Reproducibility**: Ensure the backtest logic is clear and deterministic.
diff --git a/skills/benchmark_skills/toolathlon/training-metrics-csv-exporter/SKILL.md b/skills/benchmark_skills/toolathlon/training-metrics-csv-exporter/SKILL.md
new file mode 100644
index 0000000..dfa0fcd
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/training-metrics-csv-exporter/SKILL.md
@@ -0,0 +1,56 @@
+---
+name: training-metrics-csv-exporter
+description: Extracts specific training metrics from experiment logs at regular intervals and saves them to a CSV file for analysis. Processes time-series training data (like entropy_loss, clip_ratio, response_length_mean) at specified step intervals, formats data into a structured table, and creates a CSV file.
+---
+# Instructions
+
+## Primary Use Case
+When a user requests to extract and save specific training metrics from experiment logs at regular step intervals (e.g., "every 100 steps") into a CSV file.
+
+## Core Workflow
+
+### 1. Identify Target Experiment
+- **Input**: User provides a target project/experiment (often via URL like `wandb.ai/entity/project`).
+- **Action**: Query the project to list available runs/experiments.
+- **Decision Point**: Determine which experiment to analyze based on user criteria (e.g., "shortest answers" → lowest `response_length/mean`).
+
+### 2. Extract Metrics History
+- **Input**: Selected experiment run identifier.
+- **Action**: Query the run's history for the specific metrics requested by the user (e.g., `actor/entropy_loss`, `response_length/clip_ratio`, `response_length/mean`).
+- **Note**: Use sampling queries to efficiently retrieve data at all steps.
+
+### 3. Sample at Specified Intervals
+- **Input**: Full history data and user-specified interval (e.g., "from step 0, at intervals of every 100 steps").
+- **Action**: Filter the history to extract data points only at the requested steps (e.g., 0, 100, 200, ... up to the final step).
+- **Output**: A structured list/dictionary of values for each target step.
+
+### 4. Create CSV File
+- **Input**: Sampled data with columns: step, metric1, metric2, ...
+- **Action**: Format data as CSV with appropriate headers.
+- **Output**: Write CSV file to the workspace with a descriptive filename (e.g., `shortest_length_experiment.csv`).
+
+### 5. Provide Summary
+- **Action**: Present a concise analysis summary to the user, highlighting:
+ - Which experiment was selected and why.
+ - Key observations from the extracted data (trends, min/max values).
+ - Location and contents of the generated CSV file.
+
+## Key Tools & Patterns
+- **W&B Queries**: Use `wandb-query_wandb_tool` for:
+ - Project/run listing (`ProjectInfo`, `GetRuns`).
+ - History keys inspection (`RunHistoryKeys`).
+ - Sampled history data (`RunHistorySampled` with appropriate `specs`).
+- **File Operations**: Use `filesystem-write_file` to create the CSV, and optionally `filesystem-read_file` to verify.
+- **Large Output Handling**: When tool outputs are truncated, use `local-view_overlong_tooloutput` and related navigation/search tools to extract needed data.
+
+## Common User Phrases That Trigger This Skill
+- "Record [metrics] into [filename].csv"
+- "Save experiment data to a CSV file"
+- "Extract data at intervals of every X steps"
+- "Get the metrics from step 0, every 100 steps"
+- "Analyze which experiment has the shortest/longest [metric]"
+
+## Error Handling & Edge Cases
+- **Missing Metrics**: If a requested metric key doesn't exist in the run's history, inform the user and adjust the CSV columns accordingly.
+- **Insufficient Steps**: If the run has fewer steps than the requested interval, sample all available steps and note the limitation.
+- **Large Datasets**: For runs with many steps, use sampled history queries with appropriate `max_items` to avoid timeouts.
diff --git a/skills/benchmark_skills/toolathlon/transit-station-finder/SKILL.md b/skills/benchmark_skills/toolathlon/transit-station-finder/SKILL.md
new file mode 100644
index 0000000..d8e77ab
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/transit-station-finder/SKILL.md
@@ -0,0 +1,83 @@
+---
+name: transit-station-finder
+description: When the user needs to identify nearby public transit stations relative to a specific location. This skill searches for transit stations (MRT, subway, bus, etc.) within a specified radius of given coordinates, returning station names, distances, and accessibility information to determine optimal boarding points.
+---
+# Instructions
+
+## Primary Objective
+Find the nearest public transit station(s) to a given location and provide detailed information to help the user choose the optimal boarding point for their journey.
+
+## Core Workflow
+
+### 1. Location Identification
+- **User provides**: A location (address, landmark, or coordinates).
+- **Your action**: Use `google_map-maps_geocode` to obtain precise coordinates and formatted address.
+- **Output needed**: Latitude, longitude, and verified address.
+
+### 2. Station Discovery
+- **Goal**: Find all transit stations near the identified coordinates.
+- **Your action**: Use `google_map-maps_search_places` with:
+ - Query: "MRT station" or "transit station" (adapt based on local terminology)
+ - Location: The coordinates from step 1
+ - Radius: Start with 1000 meters (adjust based on context)
+- **Output needed**: List of stations with names, addresses, and distances.
+
+### 3. Distance Verification
+- **Goal**: Determine exact walking distances to the most promising stations.
+- **Your action**: Use `google_map-maps_distance_matrix` with:
+ - Origins: The user's location
+ - Destinations: Top 3-5 candidate stations from step 2
+ - Mode: "walking"
+- **Output needed**: Precise walking distances and times for each station.
+
+### 4. Route Planning (When Destination Provided)
+- **Goal**: If user provides a destination, find complete transit route.
+- **Your action**: Use `google_map-maps_directions` with:
+ - Origin: User's location
+ - Destination: Their target destination
+ - Mode: "transit"
+- **Output needed**: Complete route with walking segments, transit segments, and transfer points.
+
+### 5. Station Details Enrichment
+- **Goal**: Gather additional information about stations and lines.
+- **Your action**: Use `local-web_search` or `fetch-fetch_markdown` to:
+ - Find station line information
+ - Identify transfer possibilities
+ - Get service schedules if needed
+- **Output needed**: Line colors, station codes, transfer options.
+
+### 6. Optimal Station Selection
+- **Criteria for selection** (in priority order):
+ 1. Shortest walking distance
+ 2. Fewest transfers to destination (if destination provided)
+ 3. Direct line to destination
+ 4. Station amenities/accessibility
+
+### 7. Output Format
+- **Always include**:
+ - Nearest station(s) with walking distances
+ - Station codes and line information
+ - Next steps for the journey
+- **When destination provided**:
+ - Complete station-by-station route
+ - Total journey time
+ - Transfer points
+
+## Special Considerations
+
+### File Output Requirements
+If the user requests saving station lists to a file:
+- Use `filesystem-write_file` to create the file
+- Format: One station per line in sequential journey order
+- Include both boarding and intermediate stations
+- Example filename: `routine.txt`
+
+### Error Handling
+- If no stations found within initial radius, expand search radius incrementally
+- If geocoding fails, ask for more specific location details
+- If walking distance exceeds reasonable limits (e.g., >2km), suggest alternative transport to station
+
+### Local Adaptations
+- Adjust search terms based on local transit systems (e.g., "subway", "metro", "bus terminal")
+- Consider local naming conventions for station types
+- Account for different transit authorities in search results
diff --git a/skills/benchmark_skills/toolathlon/transit-station-finder/references/transit_terminology.md b/skills/benchmark_skills/toolathlon/transit-station-finder/references/transit_terminology.md
new file mode 100644
index 0000000..ddaee53
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/transit-station-finder/references/transit_terminology.md
@@ -0,0 +1,66 @@
+# Transit System Terminology Guide
+
+## Common Search Terms by Region
+
+### Singapore
+- MRT (Mass Rapid Transit) - Main metro system
+- LRT (Light Rail Transit) - Light rail feeder services
+- Bus Interchange - Major bus terminals
+- Common queries: "MRT station", "LRT station", "bus interchange"
+
+### General International
+- Subway (North America)
+- Metro (Europe, Asia)
+- Underground (UK)
+- U-Bahn (Germany)
+- Métro (France)
+- T-bana (Sweden)
+
+## Station Type Identifiers
+
+### In Search Results
+Look for these keywords in place results:
+- "station"
+- "stop"
+- "terminal"
+- "interchange"
+- "depot" (usually not for passengers)
+
+### Google Maps Place Types
+Relevant types for transit stations:
+- "subway_station"
+- "train_station"
+- "transit_station"
+- "bus_station"
+- "light_rail_station"
+
+## Distance Guidelines
+
+### Walking Distance Categories
+- **Optimal**: < 500m (5-7 minute walk)
+- **Acceptable**: 500m - 1km (7-15 minute walk)
+- **Far**: 1km - 2km (15-25 minute walk)
+- **Too far**: > 2km (consider alternative transport)
+
+### Radius Search Recommendations
+- Urban areas: Start with 500-1000m radius
+- Suburban areas: Start with 1000-2000m radius
+- Rural areas: Start with 2000-5000m radius
+
+## Output Formatting Standards
+
+### Station Naming
+- Use official station names when available
+- Include line/network identifiers in parentheses
+- Example: "Little India MRT Station (DT12/NE7)"
+
+### Distance Presentation
+- Always show both distance and time
+- Format: "0.5 km (7 minute walk)"
+- Round to nearest 0.1 km for distances, nearest minute for times
+
+### Route Description
+- List stations in sequential order
+- Indicate transfer points clearly
+- Include line changes with direction
+- Example: "Transfer to East-West Line heading towards Pasir Ris"
diff --git a/skills/benchmark_skills/toolathlon/traveling-salesman-solver/SKILL.md b/skills/benchmark_skills/toolathlon/traveling-salesman-solver/SKILL.md
new file mode 100644
index 0000000..91d09ca
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/traveling-salesman-solver/SKILL.md
@@ -0,0 +1,19 @@
+---
+name: traveling-salesman-solver
+description: When the user needs to find the optimal visiting order for multiple locations to minimize total travel distance or time, this skill analyzes distance matrices to solve the Traveling Salesman Problem (TSP). It evaluates permutations of locations to identify the shortest route that visits all points. Triggers include 'optimal route', 'shortest path visiting all', 'best visiting order', or when route optimization with multiple stops is required.
+---
+# Instructions
+
+## Core Workflow
+1. **Identify Locations & Starting Point:** Determine the user's starting location and the list of all destinations that must be visited. Extract these from user request or provided files (e.g., `recommendation.md`).
+2. **Geocode Locations:** Obtain precise coordinates for all locations using mapping tools (`maps_geocode`, `maps_search_places`).
+3. **Build Distance Matrix:** Calculate pairwise walking (or specified mode) distances and times between all locations using `maps_distance_matrix`.
+4. **Solve TSP:** Analyze the distance matrix to find the permutation of destinations that minimizes total travel distance/time from the starting point. For small sets (n ≤ 7), manual permutation analysis is acceptable. For larger sets, use the provided `tsp_solver.py` script.
+5. **Generate Detailed Route:** For each leg of the optimal route, fetch turn-by-turn walking directions using `maps_directions`.
+6. **Format & Deliver Output:** Compile the final route plan into the user's requested format (e.g., JSON matching a template like `format.json`). Save the file and present a clear summary.
+
+## Key Considerations
+* **Clarify Constraints:** Confirm with the user if the route must start/end at specific points, and if visiting time at locations matters (usually it doesn't for pure TSP).
+* **Handle Proximity:** Treat very close locations (e.g., statue and building entrance) as separate stops if the user requires it, even if it slightly increases calculated distance.
+* **Validation:** After writing the output file, read it back to verify its contents and structure.
+* **Assumptions:** The skill assumes travel cost is symmetric and based on network distance/time (walking by default). Real-world constraints like one-way streets are handled by the mapping API.
diff --git a/skills/benchmark_skills/toolathlon/traveling-salesman-solver/references/route_format.json b/skills/benchmark_skills/toolathlon/traveling-salesman-solver/references/route_format.json
new file mode 100644
index 0000000..70b754a
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/traveling-salesman-solver/references/route_format.json
@@ -0,0 +1,74 @@
+{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "Route Plan Format",
+ "description": "Standard format for optimized route plans",
+ "type": "object",
+ "properties": {
+ "road_plan": {
+ "type": "array",
+ "description": "Ordered list of route legs",
+ "items": {
+ "type": "object",
+ "properties": {
+ "from": {
+ "type": "string",
+ "description": "Starting location name"
+ },
+ "to": {
+ "type": "string",
+ "description": "Destination location name"
+ },
+ "distance": {
+ "type": "string",
+ "description": "Human-readable distance (e.g., '162 m (0.1 mi)')"
+ },
+ "estimated_time": {
+ "type": "string",
+ "description": "Human-readable time estimate (e.g., '2 mins')"
+ },
+ "directions": {
+ "type": "string",
+ "description": "Turn-by-turn walking/driving instructions"
+ },
+ "coordinates": {
+ "type": "object",
+ "description": "Optional: Precise coordinates for mapping",
+ "properties": {
+ "from_lat": { "type": "number" },
+ "from_lng": { "type": "number" },
+ "to_lat": { "type": "number" },
+ "to_lng": { "type": "number" }
+ },
+ "optional": true
+ }
+ },
+ "required": ["from", "to", "distance", "estimated_time", "directions"]
+ }
+ },
+ "total_distance": {
+ "type": "string",
+ "description": "Total route distance in human-readable format"
+ },
+ "total_time": {
+ "type": "string",
+ "description": "Total route time in human-readable format"
+ },
+ "optimal_order": {
+ "type": "array",
+ "description": "Optional: List of location names in optimal visiting order",
+ "items": { "type": "string" },
+ "optional": true
+ },
+ "metadata": {
+ "type": "object",
+ "description": "Optional: Calculation metadata",
+ "properties": {
+ "algorithm_used": { "type": "string" },
+ "locations_count": { "type": "integer" },
+ "calculation_timestamp": { "type": "string", "format": "date-time" }
+ },
+ "optional": true
+ }
+ },
+ "required": ["road_plan", "total_distance", "total_time"]
+}
diff --git a/skills/benchmark_skills/toolathlon/traveling-salesman-solver/references/tsp_algorithms.md b/skills/benchmark_skills/toolathlon/traveling-salesman-solver/references/tsp_algorithms.md
new file mode 100644
index 0000000..0605b38
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/traveling-salesman-solver/references/tsp_algorithms.md
@@ -0,0 +1,52 @@
+# Traveling Salesman Problem (TSP) - Algorithms & Considerations
+
+## Problem Definition
+Given a list of locations and the distances between each pair, find the shortest possible route that visits each location exactly once and returns to the origin.
+
+## Common Algorithms
+
+### 1. Brute Force (Exhaustive Search)
+* **Method:** Evaluate all possible permutations of locations.
+* **Complexity:** O(n!) - Factorial time.
+* **Use Case:** Optimal solution for n ≤ 10 locations.
+* **Implementation:** Use `itertools.permutations` in Python.
+
+### 2. Nearest Neighbor (Greedy Heuristic)
+* **Method:** Start at an arbitrary location, repeatedly visit the nearest unvisited location.
+* **Complexity:** O(n²) - Much faster.
+* **Use Case:** Quick, approximate solution for large n. Not guaranteed optimal.
+* **Accuracy:** Typically 10-25% longer than optimal.
+
+### 3. Held-Karp (Dynamic Programming)
+* **Method:** DP algorithm that solves exact TSP in O(n²2ⁿ) time.
+* **Use Case:** Optimal solution for n ≤ 20-25 (due to memory constraints).
+
+## Practical Considerations for Route Planning
+
+### Asymmetric vs. Symmetric Distances
+* **Walking/Driving:** Usually symmetric on road networks, but one-way streets can create asymmetry.
+* **Public Transit:** Often highly asymmetric due to schedules.
+* **Default Assumption:** Symmetric unless specified.
+
+### Start and End Points
+* **Classic TSP:** Returns to start (closed tour).
+* **Open TSP:** Ends at a different location.
+* **Fixed Start:** Common in tourist itineraries (start at hotel).
+
+### Real-World Constraints
+* **Time Windows:** Locations may have opening hours.
+* **Capacity:** Vehicle routing with load limits.
+* **Multiple Vehicles:** VRP (Vehicle Routing Problem).
+
+## Distance Matrix Properties
+A valid distance matrix should be:
+1. **Square:** n × n for n locations.
+2. **Non-negative:** All distances ≥ 0.
+3. **Zero Diagonal:** Distance from a location to itself is 0.
+4. **Symmetric (usually):** distance[i][j] = distance[j][i].
+
+## Optimization Tips
+1. **Cluster First:** Group nearby locations before solving.
+2. **Use Heuristics for n > 10:** Nearest Neighbor, Christofides, or Lin-Kernighan.
+3. **Consider Time vs. Distance:** Sometimes shorter distance ≠ shorter time (traffic, terrain).
+4. **Validate with Mapping APIs:** Network distance ≠ straight-line distance.
diff --git a/skills/benchmark_skills/toolathlon/wandb-experiment-analyzer/SKILL.md b/skills/benchmark_skills/toolathlon/wandb-experiment-analyzer/SKILL.md
new file mode 100644
index 0000000..3892d22
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/wandb-experiment-analyzer/SKILL.md
@@ -0,0 +1,70 @@
+---
+name: wandb-experiment-analyzer
+description: When the user asks to analyze a Weights & Biases (wandb) project or experiment results, particularly when they need to identify the best-performing run based on validation metrics and find the optimal training step within that run. This skill handles querying wandb projects via GraphQL API, extracting run summaries and history data, comparing validation scores across experiments, analyzing step-level performance within the best run, and exporting results to structured formats like CSV files. It's triggered by requests involving wandb URLs, experiment comparison, validation performance analysis, or finding optimal training checkpoints.
+---
+# Instructions
+
+## Overview
+This skill analyzes wandb projects to identify the best-performing experiment based on validation metrics and finds the optimal training step within that experiment. It outputs results to a CSV file.
+
+## Core Workflow
+
+### 1. Parse User Request
+- Extract the wandb project URL from the user's request (format: `https://wandb.ai/<entity>/<project>`)
+- Identify the target validation metric (default: `val/test_score/` or similar validation score metrics)
+- Determine output requirements (CSV file location, format)
+
+### 2. Query Project Information
+- Use the `wandb-query_wandb_tool` with GraphQL to fetch:
+ - Project metadata (entity, project name, run count)
+ - List of all runs with their summary metrics
+ - Look for validation score metrics in summary data
+
+### 3. Identify Best Experiment
+- Parse summary metrics from all runs
+- Extract validation scores (look for metrics like `val/test_score/`, `val_score`, `validation_score`)
+- Compare scores across all runs to identify the best-performing experiment
+- Note: Some runs may have null or missing validation scores
+
+### 4. Fetch Detailed History for Best Run
+- Query the history data for the best run using GraphQL
+- Request sufficient samples to capture all validation score entries
+- Handle large response data that may be truncated or saved to files
+
+### 5. Analyze Step-Level Performance
+- Parse the history data to extract validation scores and corresponding steps
+- Filter out null/missing validation scores
+- Sort by validation score in descending order
+- Identify the step with the highest validation score
+
+### 6. Generate Output
+- Create a CSV file with columns: `best_experiment_name`, `best_step`, `best_val_score`
+- Save to the workspace directory as specified by the user
+- Provide a summary of findings to the user
+
+## Key Considerations
+
+### Validation Metric Identification
+- The validation metric name may vary across projects
+- Common patterns: `val/test_score/`, `val_score`, `validation/score`, `eval/score`
+- Check summary metrics first to identify the correct metric name
+
+### Data Handling
+- Large history responses may be truncated; use the `local-search_overlong_tooloutput` tool to search within saved files
+- Some steps may have null validation scores (only recorded at evaluation intervals)
+- Ensure proper JSON parsing of nested data structures
+
+### Error Handling
+- Handle missing or inaccessible projects/runs gracefully
+- Provide clear error messages if validation metrics cannot be found
+- Handle authentication/permission issues with wandb API
+
+## Tools Required
+- `wandb-query_wandb_tool`: For GraphQL queries to wandb API
+- `local-search_overlong_tooloutput`: For searching within large saved tool outputs
+- `filesystem-write_file`: For creating CSV output files
+- `filesystem-read_file`: For reading saved data files
+- `terminal-run_command`: For running analysis scripts (when needed)
+
+## Output Format
+The skill produces a CSV file with the following structure:
diff --git a/skills/benchmark_skills/toolathlon/wandb-experiment-analyzer/references/tool_usage_guide.md b/skills/benchmark_skills/toolathlon/wandb-experiment-analyzer/references/tool_usage_guide.md
new file mode 100644
index 0000000..9432520
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/wandb-experiment-analyzer/references/tool_usage_guide.md
@@ -0,0 +1,11 @@
+# Tool Usage Guide for wandb-experiment-analyzer
+
+## Core Tools
+
+### 1. wandb-query_wandb_tool
+**Purpose:** Query wandb GraphQL API
+**Key Parameters:**
+- `query`: GraphQL query string
+- `variables`: Dictionary of variables for the query
+
+**Example Usage:**
diff --git a/skills/benchmark_skills/toolathlon/wandb-experiment-analyzer/references/validation_analysis_patterns.md b/skills/benchmark_skills/toolathlon/wandb-experiment-analyzer/references/validation_analysis_patterns.md
new file mode 100644
index 0000000..94fc4c5
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/wandb-experiment-analyzer/references/validation_analysis_patterns.md
@@ -0,0 +1,44 @@
+# Validation Analysis Patterns
+
+## Common Analysis Scenarios
+
+### 1. Identifying Best Experiment
+**Goal:** Find which run has the highest validation performance
+**Approach:**
+1. Extract validation scores from `summaryMetrics` of all runs
+2. Compare final validation scores
+3. Consider runs that may have crashed or are still running
+
+**Edge Cases:**
+- Some runs may have null validation scores
+- Validation metric names may vary
+- Some projects may not log validation scores to summaries
+
+### 2. Finding Optimal Step Within a Run
+**Goal:** Identify the training step with peak validation performance
+**Approach:**
+1. Fetch full history for the best run
+2. Extract validation scores at each step
+3. Find maximum validation score and corresponding step
+
+**Patterns to Consider:**
+- Early stopping: Best score may not be at final step
+- Overfitting: Validation score may decline after peak
+- Evaluation frequency: Validation may be logged at intervals, not every step
+
+### 3. Metric Name Discovery
+**Strategies for identifying validation metrics:**
+1. Check common names: `val/`, `validation/`, `eval/`, `test_`
+2. Examine `historyKeys` from run query for metric patterns
+3. Look for metrics with "score" or "accuracy" in name
+4. Check if metrics have fewer data points (evaluation happens less frequently)
+
+## Data Processing Patterns
+
+### Handling Large History Data
+1. **Sampling:** Use `sampledHistory` with specs for large runs
+2. **Pagination:** Handle paginated results for very long runs
+3. **File Storage:** Large responses may be saved to files; use search tools
+
+### Parsing JSON Strings
+History data comes as JSON strings within JSON:
diff --git a/skills/benchmark_skills/toolathlon/wandb-experiment-analyzer/references/wandb_graphql_queries.md b/skills/benchmark_skills/toolathlon/wandb-experiment-analyzer/references/wandb_graphql_queries.md
new file mode 100644
index 0000000..c15a1ab
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/wandb-experiment-analyzer/references/wandb_graphql_queries.md
@@ -0,0 +1,5 @@
+# Weights & Biases GraphQL Queries Reference
+
+## Core Queries for Experiment Analysis
+
+### 1. Get Project Information
diff --git a/skills/benchmark_skills/toolathlon/web-application-e2e-tester/SKILL.md b/skills/benchmark_skills/toolathlon/web-application-e2e-tester/SKILL.md
new file mode 100644
index 0000000..885bc3f
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/web-application-e2e-tester/SKILL.md
@@ -0,0 +1,53 @@
+---
+name: web-application-e2e-tester
+description: When the user needs to run end-to-end tests on a web application, especially for e-commerce checkout flows, and requires manual or automated testing of UI functionality like adding items to cart, applying coupons, form validation, and responsive design. This skill includes browser automation, test execution, and validation of test cases against a live application.
+---
+# Instructions
+
+## Objective
+Deploy a web application to a Kubernetes preview environment, expose it via NodePort, and execute a comprehensive suite of end-to-end (E2E) tests. The final deliverable is a filled test results report.
+
+## Prerequisites
+1. **Target Application:** A Git repository containing the application source code, a Kubernetes deployment manifest (`preview.yaml`), and a test suite.
+2. **Kubernetes Cluster:** Access to a `kubectl` configured cluster.
+3. **Browser Automation:** Access to a browser automation tool (e.g., Playwright via `playwright_with_chunk` tools).
+4. **Test Report Template:** A markdown file (`test-results-report.md`) with a predefined table structure for results.
+
+## Core Workflow
+
+### Phase 1: Environment Setup & Deployment
+1. **Clone Repository:** Clone the target Git repository, specifying the required branch (e.g., `feature/pr-123`).
+2. **Inspect Structure:** Examine the repository to locate key files: the Kubernetes manifest (`preview.yaml`), the test script, the test report template, and the application's main HTML file.
+3. **Deploy to Kubernetes:**
+ a. Create the namespace defined in `preview.yaml` (if it doesn't exist).
+ b. Apply the `preview.yaml` manifest to create the Deployment and ClusterIP Service.
+ c. Create a ConfigMap from the application's `index.html` file, matching the volume mount specified in the deployment.
+ d. Create a **NodePort Service** to expose the application on a specific host port (e.g., `30123`) for long-term external access. Ensure the selector matches the deployment's pod labels.
+4. **Verify Deployment:** Confirm the Pod is `Running` and the application is accessible via `curl` or browser at the NodePort URL (e.g., `http://localhost:30123`).
+
+### Phase 2: Test Execution & Validation
+**Approach:** Manually execute each test case defined in the test script using browser automation, simulating user interactions.
+1. **Prepare Test Environment:** Clear browser `localStorage` before critical test sequences to ensure a clean state.
+2. **Execute Test Cases:** For each test function in the suite (e.g., `should load the homepage`, `should add products to cart`):
+ a. Navigate to the application URL.
+ b. Perform the described user actions (click buttons, fill forms, change viewport size).
+ c. Use browser automation tools to assert expected outcomes (check element visibility, text content, form validation messages).
+ d. Record the result as **PASS (✅)** or **FAIL (❌)**.
+3. **Key Test Categories to Cover:**
+ * **Page Load & Metadata:** Title, headers, PR information display.
+ * **Shopping Cart Logic:** Add/remove items, total price calculation.
+ * **Business Rules:** Free shipping thresholds, coupon application (`SAVE10`), tax calculation logic.
+ * **Checkout Process:** Form filling, submission, order success confirmation.
+ * **Form Validation:** HTML5 validation for required fields.
+ * **Responsive Design:** Visibility of core components at mobile (`375x667`) and tablet (`768x1024`) viewports.
+ * **Performance & API Health:** Page load speed (<3s), HTTP `200` status, correct `Content-Type` header.
+
+### Phase 3: Reporting
+1. **Fill Test Report:** Update the `test-results-report.md` template. **Only** replace the empty cells in the `Result` column with `✅` or `❌` and update the `Summary Statistics` (Total, Passed, Failed) at the bottom. Do not modify any other text, structure, or test names.
+2. **Save Final Report:** Save the completed report to the workspace root as `filled-test-results-report.md`.
+
+## Critical Notes & Edge Cases
+* **Tax Calculation Bug:** The example trajectory revealed a test failure where tax was calculated on the subtotal *before* discount, but the test expected it to be calculated *after* discount. Document such discrepancies clearly in the report.
+* **State Persistence:** The application may use `localStorage`. Use `playwright_with_chunk-browser_evaluate` to run `localStorage.clear()` between tests to ensure isolation.
+* **Form `novalidate` Attribute:** If a form has the `novalidate` attribute, HTML5 validation pop-ups will not block submission. Use `element.validationMessage` to check for validation messages instead.
+* **Service Configuration:** The initial `preview.yaml` likely creates a `ClusterIP` service. You must create a separate `NodePort` Service to expose the application on the host machine.
diff --git a/skills/benchmark_skills/toolathlon/web-application-e2e-tester/references/test-execution-guide.md b/skills/benchmark_skills/toolathlon/web-application-e2e-tester/references/test-execution-guide.md
new file mode 100644
index 0000000..4a09731
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/web-application-e2e-tester/references/test-execution-guide.md
@@ -0,0 +1,27 @@
+# E2E Test Execution Guide
+
+## Test Case Mapping (Playwright Actions)
+This guide maps common test descriptions to concrete browser automation actions.
+
+| Test Step Description | Suggested Playwright Action |
+| :--- | :--- |
+| Navigate to application homepage | `playwright_with_chunk-browser_navigate` to the NodePort URL (e.g., `http://localhost:30123`) |
+| Click the first "Add to Cart" button | `playwright_with_chunk-browser_click` on the element with role `button` and name `"Add to Cart"`, using `.first()` |
+| Fill "Full Name" field with "John Doe" | `playwright_with_chunk-browser_type` into the textbox with name `"Full Name"` |
+| Select "Express" shipping ($15.00) | `playwright_with_chunk-browser_click` on the combobox and select the option with text `"Express - $15.00"` |
+| Apply coupon "SAVE10" | 1. `playwright_with_chunk-browser_type` into the "Coupon" textbox.<br>2. `playwright_with_chunk-browser_click` the "Apply" button. |
+| Check for success message "Order Successful!" | Verify an element containing that text becomes `visible` after form submission. |
+| Test mobile viewport (375x667) | `playwright_with_chunk-browser_resize` to `{width: 375, height: 667}` |
+| Clear browser localStorage | `playwright_with_chunk-browser_evaluate` with function `() => { localStorage.clear(); }` |
+| Get HTML5 validation message | `playwright_with_chunk-browser_evaluate` on an input element, running `(element) => element.validationMessage` |
+
+## Assertion Patterns
+* **Text Content:** "Cart is empty" → Check if the cart container's text matches.
+* **Numerical Calculation:** "Total: $79.98" → Check if the total element contains the exact string after adding specific items.
+* **Element State:** "Submit button should be disabled" → Check the `disabled` property.
+* **Visibility:** "Success message should appear" → Check `display` style or visibility.
+
+## Common Pitfalls
+1. **Dynamic Selectors:** Prefer `getByRole` or `getByText` over fragile CSS selectors that may change.
+2. **Timing:** Use appropriate waits (`networkidle`) for page loads after actions like form submission.
+3. **Test Independence:** Always clear `localStorage` and refresh the page (`navigate`) between tests that depend on cart state.
diff --git a/skills/benchmark_skills/toolathlon/web-content-extraction-navigator/SKILL.md b/skills/benchmark_skills/toolathlon/web-content-extraction-navigator/SKILL.md
new file mode 100644
index 0000000..6a4cac1
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/web-content-extraction-navigator/SKILL.md
@@ -0,0 +1,67 @@
+---
+name: web-content-extraction-navigator
+description: When the user needs to extract specific content from websites that require interactive navigation, particularly when dealing with dynamic content, truncated text, or pages that require clicking buttons to reveal full information. This skill handles browser automation to navigate web pages, interact with page elements (like expanding truncated descriptions), extract structured content from complex page layouts, and overcome common web scraping challenges like bot detection or IP blocking. It's triggered when dealing with websites that require clicking 'show more', 'expand', or similar interactive elements to access complete information.
+---
+# Skill: Web Content Extraction Navigator
+
+## Purpose
+Extract structured content from dynamic web pages that require user interaction (clicking buttons, expanding sections, navigating through page elements) to reveal complete information.
+
+## Primary Use Case
+When the target content is hidden behind:
+- "Show more", "Expand", "...more" buttons
+- Truncated descriptions or lists
+- Dynamic page loads requiring interaction
+- Pages with bot detection mechanisms
+
+## Core Strategy
+1. **Browser Automation First**: Use Playwright for reliable interaction with dynamic content.
+2. **Fallback Layers**: When direct APIs fail (e.g., transcript APIs blocked), navigate manually.
+3. **Progressive Discovery**: Navigate through page spans/sections to locate target content.
+4. **Structured Extraction**: Parse and format extracted content according to user requirements.
+
+## Execution Workflow
+
+### Phase 1: Initial Setup & Exploration
+1. **Read Format Requirements**: Check for any format specifications in workspace files.
+2. **Search for Target**: Use web search to locate the target URL/content.
+3. **Attempt Direct Methods**: Try direct API access first (e.g., YouTube transcript API).
+
+### Phase 2: Browser Navigation & Interaction
+4. **Navigate to Target URL**: Use Playwright to load the page.
+5. **Handle Bot Detection**: Recognize and work around sign-in prompts or bot checks.
+6. **Expand Hidden Content**:
+ - Look for truncation indicators ("...more", "Show more", "Expand description")
+ - Click interactive elements to reveal full content
+ - Use snapshot navigation to explore different page sections
+
+### Phase 3: Content Extraction & Processing
+7. **Locate Target Content**: Identify the specific content area (e.g., video description, tracklist).
+8. **Extract Structured Data**: Parse the content into clean, structured format.
+9. **Format According to Requirements**: Apply any specified formatting templates.
+10. **Write Output File**: Save extracted content to the requested location.
+
+## Key Techniques
+- **Snapshot Navigation**: Use `browser_snapshot_navigate_to_next_span` to explore large pages
+- **Element Targeting**: Click specific elements by reference ID or role/text
+- **Content Parsing**: Extract clean text from HTML structures
+- **Error Recovery**: Handle API blocks, bot detection, and loading issues
+
+## Common Patterns
+- YouTube video descriptions with tracklists
+- Articles with "Read more" buttons
+- Comment sections requiring expansion
+- Paginated content
+- Modal popups with additional information
+
+## Output Requirements
+- Always verify the extracted content matches the request
+- Follow any specified format templates exactly
+- Include source attribution when relevant
+- Handle edge cases (missing content, format variations)
+
+## Failure Recovery
+1. If direct API fails → Use browser automation
+2. If page blocks access → Try alternative search results
+3. If content not found → Search for similar pages
+4. If format unclear → Use sensible defaults and document assumptions
diff --git a/skills/benchmark_skills/toolathlon/web-content-extraction-navigator/references/common_interaction_patterns.md b/skills/benchmark_skills/toolathlon/web-content-extraction-navigator/references/common_interaction_patterns.md
new file mode 100644
index 0000000..e46141f
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/web-content-extraction-navigator/references/common_interaction_patterns.md
@@ -0,0 +1,14 @@
+# Common Web Interaction Patterns
+
+## Truncation Indicators
+Look for these text patterns to identify expandable content:
+- "...more"
+- "Show more"
+- "Read more"
+- "Expand"
+- "See more"
+- "View all"
+- "Continue reading"
+
+## Common Element Selectors
+### By Role (Preferred)
diff --git a/skills/benchmark_skills/toolathlon/web-content-extraction-navigator/references/playwright_cheatsheet.md b/skills/benchmark_skills/toolathlon/web-content-extraction-navigator/references/playwright_cheatsheet.md
new file mode 100644
index 0000000..822f1f1
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/web-content-extraction-navigator/references/playwright_cheatsheet.md
@@ -0,0 +1,5 @@
+# Playwright Automation Cheatsheet
+
+## Core Browser Operations
+
+### Navigation
diff --git a/skills/benchmark_skills/toolathlon/web-form-autofiller/SKILL.md b/skills/benchmark_skills/toolathlon/web-form-autofiller/SKILL.md
new file mode 100644
index 0000000..92ad980
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/web-form-autofiller/SKILL.md
@@ -0,0 +1,59 @@
+---
+name: web-form-autofiller
+description: When the user needs to fill out web forms with data from memory or structured sources, this skill automates the entire workflow reads form links from files, navigates to web forms, analyzes form structure and fields, extracts relevant data from memory or knowledge bases, maps data to form fields, fills text inputs, selects checkboxes and radio buttons, handles multi-page forms with navigation, and submits forms. It's triggered when users mention filling forms, questionnaires, surveys, or registration forms, especially when combined with data from memory systems or structured files.
+---
+# Skill: Web Form Autofiller
+
+## Purpose
+Automate the process of filling web forms by extracting data from memory/knowledge bases and mapping it to form fields. Handles complex forms with multiple field types (text, radio, checkbox, date) and multi-page navigation.
+
+## Core Workflow
+1. **Parse Request:** Identify the form URL source (file path, direct link) and the data subjects (people, entities) to fill the form for.
+2. **Acquire Data:** Read the form link and fetch relevant entity data from memory/knowledge graphs.
+3. **Navigate & Analyze:** Load the form in a browser and analyze its structure to identify all required and optional fields.
+4. **Map & Fill:** For each data subject, map their attributes to the corresponding form fields, applying default rules for missing information.
+5. **Submit & Repeat:** Submit the form and repeat the process for additional subjects if needed.
+
+## Detailed Instructions
+
+### 1. Initial Setup & Data Acquisition
+- **Locate Form Link:** If the user provides a file path (e.g., `form_link_for_public.txt`), read the URL from that file using `filesystem-read_file`.
+- **Extract Entity Data:** Query the memory/knowledge graph (`memory-read_graph`) to get structured data for all entities mentioned in the request (e.g., "MCP Wang" and "Alex Wang"). Pay close attention to `observations` arrays for attributes.
+
+### 2. Form Analysis & Field Mapping
+- **Navigate to Form:** Use `playwright_with_chunk-browser_navigate` to load the form URL.
+- **Inspect Structure:** Use the snapshot navigation tools (`browser_snapshot_navigate_to_next_span`, `browser_snapshot_navigate_to_first_span`) to view the entire form. Create a mental map of all fields:
+ - **Text Inputs:** Name, Email, Address, Phone, Student ID, Birthday (date).
+ - **Checkboxes:** Session selection (Morning, Afternoon). Multiple can be selected.
+ - **Radio Groups:** Dietary Restrictions, Anxiety Level (1-5), Activities, Highest Degree. Only one selection allowed per group.
+ - Note which fields are marked as required.
+- **Define Data Mapping Logic:** Based on the form analysis and available entity data, define rules:
+ - **Session:** If "participate for the whole day" is requested, select *both* Morning and Afternoon checkboxes.
+ - **Defaults:** For fields not mentioned in memory (e.g., anxiety level), default to the most negative/lowest option (e.g., "1" for anxiety).
+ - **Single Selection Logic:** For radio groups where multiple entity attributes could apply (e.g., hobbies: Programming, Basketball, Swimming), you must choose **only one**. Prioritize based on context or explicit mentions (e.g., "cannot swim" implies not selecting swimming).
+
+### 3. Filling the Form (Per Person)
+- **Text Fields:** Use `playwright_with_chunk-browser_type` to fill textboxes. Reference elements by their `ref` ID or accessible role/name from the snapshot.
+- **Checkboxes:** Use `playwright_with_chunk-browser_click` on the checkbox element.
+- **Radio Buttons:** Use `playwright_with_chunk-browser_click` on the specific radio button element.
+- **Navigation:** If the form is long, use snapshot navigation between spans to access all fields.
+- **Submit:** Click the "Submit" button using `playwright_with_chunk-browser_click`.
+
+### 4. Handling Multiple Submissions
+- After successful submission, the page will show a confirmation. If another submission is needed for a different person, click the "Submit another response" link.
+- **Important:** The form will reset. Repeat the entire filling process for the next person with their specific data.
+
+## Key Decision Rules & Defaults
+- **Missing Data:** Any attribute not explicitly found in the memory entity's `observations` should be considered "not mentioned" and defaulted to a negative or empty state.
+- **Dietary Restrictions:** Map explicitly mentioned restrictions (e.g., "cannot eat seafood") to the corresponding option ("No Seafood"). If "Dietary restrictions: None" is stated, select "None".
+- **Highest Degree Earned:** Select the degree that has been *earned* (e.g., "Bachelor's"), not what is "currently pursuing".
+- **Activities:** Choose only one activity from the radio group. Select the one most strongly associated with the person's hobbies or explicitly mentioned capabilities.
+
+## Error Handling & Validation
+- If the form link is invalid or the page fails to load, report the error and stop.
+- If a required field cannot be mapped from memory and has no sensible default, ask the user for clarification.
+- After submission, verify the success message ("Your response has been recorded") appears.
+
+## Finalization
+- Once all forms are submitted, provide a clear summary of what was submitted for each person.
+- Use `local-claim_done` to signal task completion.
diff --git a/skills/benchmark_skills/toolathlon/web-form-autofiller/references/field_mapping_guide.md b/skills/benchmark_skills/toolathlon/web-form-autofiller/references/field_mapping_guide.md
new file mode 100644
index 0000000..d12e1af
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/web-form-autofiller/references/field_mapping_guide.md
@@ -0,0 +1,46 @@
+# Field Mapping Guide for Common Form Types
+
+This guide helps map entity attributes from a knowledge graph to typical web form fields.
+
+## Generic Attribute to Form Field Mapping
+
+| Entity Attribute (From Observations) | Typical Form Field Type | Mapping Logic & Notes |
+| :--- | :--- | :--- |
+| `Name: [Full Name]` | Text Input | Direct mapping. |
+| `Email: [email]` | Text Input | Direct mapping. |
+| `Address: [address]` | Text Input | Direct mapping. |
+| `Phone: [number]` | Text Input | Direct mapping. |
+| `Student ID: [id]` | Text Input | Direct mapping. |
+| `Birthday: [YYYY-MM-DD]` | Date Input | Use standard YYYY-MM-DD format. |
+| `Major: [field]` | Text Input / Dropdown | May need to match specific options. |
+| `Hobbies: [list]` | Checkbox / Radio Group | Map to specific activity options. For single-select (radio), choose the most relevant. |
+| `Health condition: [condition]` | Text Area / Radio Group | e.g., "Gout, cannot eat seafood" -> maps to "No Seafood" dietary restriction. |
+| `Dietary restrictions: [list]` | Radio Group / Checkbox | Map to provided options (None, Vegan, Kosher, No Seafood, etc.). |
+| `Mental health: [description]` | Radio Group (e.g., Anxiety) | If description is positive ("Healthy", "Good"), default to low anxiety (1). |
+| `Degree: [level]` | Radio Group | Map "Bachelor's" -> "bachelor", "Master's" -> "master", etc. |
+| `Currently pursuing: [degree]` | (Usually not mapped) | **Ignore for "Highest degree earned" field.** |
+| `GPA: [score]` | Text Input / Range | May need formatting. |
+| `Swimming ability: [ability]` | Radio Group (Activities) | "Cannot swim" means do NOT select the "swimming" activity. |
+
+## Handling Common Form Patterns
+
+### 1. Session/Time Selection (Checkboxes)
+- **User Request:** "participate for the whole day"
+- **Action:** Select **all** relevant checkboxes (e.g., "Morning" AND "Afternoon").
+
+### 2. Single-Choice Questions (Radio Groups)
+- **Rule:** Select exactly one option.
+- **Data Conflict:** If entity data suggests multiple fits (e.g., hobbies include "Programming" and "Basketball"), you must **choose one**. Use context:
+ - Prefer an activity explicitly listed in the form's options.
+ - If "cannot [activity]" is stated, exclude that option.
+ - Default to the first logically matching option.
+
+### 3. Default Values for Missing Data
+- **Principle:** Default to the most "negative", "neutral", or "low" option.
+- **Anxiety Scale (1-5):** Default to **1** (low anxiety).
+- **Yes/No or Positive/Negative:** Default to "No" or the negative option.
+- **Optional Fields:** Leave blank if no data and no default is specified.
+
+### 4. Form Navigation
+- Large forms may be split across multiple "spans" in the snapshot view.
+- Use `browser_snapshot_navigate_to_next_span` and `browser_snapshot_navigate_to_first_span` to view all fields before deciding on a mapping strategy.
diff --git a/skills/benchmark_skills/toolathlon/woocommerce-customer-email-campaign-manager/SKILL.md b/skills/benchmark_skills/toolathlon/woocommerce-customer-email-campaign-manager/SKILL.md
new file mode 100644
index 0000000..24a3f93
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/woocommerce-customer-email-campaign-manager/SKILL.md
@@ -0,0 +1,36 @@
+---
+name: woocommerce-customer-email-campaign-manager
+description: Executes targeted email campaigns for a WooCommerce store, specifically for sending notifications about upcoming product releases or discount promotions. This skill retrieves and filters customers, queries products, identifies scheduled releases, and determines appropriate recipients for different campaign types.
+---
+# Instructions
+
+## 1. Assess Store State
+First, determine if the store has the necessary data to run a campaign.
+- Use `woocommerce-woo_customers_list` to check for existing customers.
+- Use `woocommerce-woo_products_list` with various statuses (`publish`, `draft`, `pending`, `private`) and the `onSale` parameter to check for existing products.
+
+**Decision Logic:**
+- If **no customers exist**, the campaign cannot proceed. Inform the user and claim the task as done.
+- If **no products exist** (across all checked statuses), the campaign cannot proceed. Inform the user and claim the task as done.
+- If both customers and relevant products exist, proceed to Step 2.
+
+## 2. Filter Customers & Products for Campaigns
+Based on the user's request, determine the target audience and the products to promote.
+
+### For "New Product Reservation" Campaigns
+* **Target Customers:** Filter the customer list to only those whose `meta_data` includes `subscription_preferences` with `new_product_alerts` set to `True`. (Note: This filtering logic must be applied manually to the customer data returned by the API, as the provided tool may not support this filter directly).
+* **Target Products:** Identify products scheduled for release within the next 30 days. This typically involves checking products with a `draft` or `pending` status and analyzing their `meta_data` for a scheduled release date. (Note: The provided `woocommerce-woo_products_list` tool does not filter by date; you must retrieve all products and manually filter them based on their metadata or scheduled date field).
+
+### For "Discount Reminder" Campaigns
+* **Target Customers:** All customers.
+* **Target Products:** All products where `onSale` is `true` (use the `woocommerce-woo_products_list` tool with `onSale: true`).
+
+## 3. Execute or Report
+- If valid customer-product pairs are found for either campaign type, proceed to compose and send the appropriate emails. (Note: The trajectory does not include an email sending tool; assume this is a subsequent step handled by another skill or manual process).
+- If no valid pairs are found (e.g., customers exist but none are subscribed to alerts, or products exist but none are scheduled for release or on sale), inform the user of this specific outcome.
+- Use `local-claim_done` to finalize the skill's execution once the assessment and filtering are complete, providing a clear summary of findings.
+
+## Key Constraints & Notes
+- The provided WooCommerce tools are for data retrieval only. Advanced filtering (by date, by specific meta field) must be done manually on the returned data.
+- This skill is for **planning and identifying** the campaign audience and content. The actual email dispatch mechanism is out of scope.
+- Always handle pagination (`perPage` parameter) appropriately if the store has more than 100 customers or products.
diff --git a/skills/benchmark_skills/toolathlon/woocommerce-customer-email-campaign-manager/references/campaign_logic.md b/skills/benchmark_skills/toolathlon/woocommerce-customer-email-campaign-manager/references/campaign_logic.md
new file mode 100644
index 0000000..fc35848
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/woocommerce-customer-email-campaign-manager/references/campaign_logic.md
@@ -0,0 +1,31 @@
+# Campaign Logic Reference
+
+## Campaign Types & Data Requirements
+
+### Type A: New Product Reservation Alerts
+**Objective:** Notify subscribed customers about products launching soon.
+- **Trigger:** User request for "new product reservations" or "upcoming releases".
+- **Customer Filter:** `meta_data.subscription_preferences.new_product_alerts == True`
+- **Product Filter:** `product.status IN ('draft', 'pending', 'future')` AND `product.scheduled_date <= TODAY + 30 days`
+- **Audience:** Targeted (subset of customers).
+- **Default Fallback:** If no subscribed customers exist, campaign has zero recipients.
+
+### Type B: Discount Product Reminders
+**Objective:** Notify all customers about products currently on sale.
+- **Trigger:** User request for "discount reminders" or "promotion notifications".
+- **Customer Filter:** None (all customers).
+- **Product Filter:** `product.onSale == true`
+- **Audience:** Broadcast (all customers).
+- **Default Fallback:** If no products are on sale, campaign has no content.
+
+## Store State Assessment Matrix
+| Customers | Products (Any) | Campaign Viable? | Next Action |
+| :--- | :--- | :--- | :--- |
+| 0 | Any | No | Stop. Report "No customers to email." |
+| >0 | 0 | No | Stop. Report "No products to promote." |
+| >0 | >0 | Yes | Proceed to filter for specific campaign type. |
+
+## Data Handling Notes
+- **Pagination:** The `woocommerce-woo_*_list` tools default to 10 items per page. Use the `perPage` parameter (max typically 100) and implement a loop to fetch all data if necessary.
+- **Meta Data Filtering:** The WooCommerce REST API may not support filtering customers by nested meta fields like `subscription_preferences`. You must retrieve all customers and filter the list locally.
+- **Date Calculation:** "Next 30 days" is calculated from the current date. Product scheduled dates are often stored in meta fields (e.g., `_sale_price_dates_from`, `_subscription_sign_up_fee` for subscriptions, or custom fields). You may need to inspect product metadata to find the relevant date field.
diff --git a/skills/benchmark_skills/toolathlon/woocommerce-order-inventory-sync/SKILL.md b/skills/benchmark_skills/toolathlon/woocommerce-order-inventory-sync/SKILL.md
new file mode 100644
index 0000000..9af4d15
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/woocommerce-order-inventory-sync/SKILL.md
@@ -0,0 +1,87 @@
+---
+name: woocommerce-order-inventory-sync
+description: When the user needs to process paid WooCommerce orders to calculate raw material consumption based on Bill of Materials (BOM), update inventory levels, and sync maximum producible quantities back to WooCommerce stock. This skill monitors new paid orders, retrieves SKU and quantity data, calculates material requirements from BOM data (typically stored in Google Sheets or similar), deducts consumed materials from inventory, recalculates maximum producible product quantities based on remaining materials, and updates WooCommerce product stock levels. Triggers include WooCommerce order processing, inventory management, BOM-based material calculations, stock synchronization, and production planning workflows.
+---
+# Instructions
+
+## Overview
+This skill automates the end-to-end process of converting paid WooCommerce orders into raw material consumption, updating inventory, and recalculating available stock based on Bill of Materials (BOM). It connects WooCommerce with Google Sheets for BOM and inventory management.
+
+## Prerequisites
+1. **WooCommerce Connection**: Configured with API access to list orders and update products.
+2. **Google Sheets Connection**: Access to a spreadsheet containing:
+ - `BOM` sheet: Product_SKU, Material_Code, Material_Name, Quantity_Per_Unit
+ - `Material_Inventory` sheet: Material_Code, Material_Name, Stock_Quantity
+3. **Configuration File**: A `config.json` file with:
+ - `spreadsheet_id`: Google Sheets ID (not folder ID)
+ - `bom_sheet_name`: Name of BOM sheet (default: "BOM")
+ - `inventory_sheet_name`: Name of inventory sheet (default: "Material_Inventory")
+ - `product_mapping`: Mapping of product SKUs to WooCommerce product IDs
+
+## Execution Flow
+
+### Step 1: Monitor Paid Orders
+1. Use `woocommerce-woo_orders_list` to retrieve orders with status `["processing"]` (paid orders).
+2. Extract from each order:
+ - `order_id`
+ - `line_items`: For each item, extract `sku` and `quantity`
+ - Note: The `_reduced_stock` meta indicates WooCommerce has already reduced finished product stock.
+
+### Step 2: Retrieve BOM and Inventory Data
+1. Read configuration from `config.json` to get spreadsheet ID and sheet names.
+2. Use `google_sheet-get_sheet_data` to fetch:
+ - BOM data from the specified BOM sheet
+ - Current inventory from the specified inventory sheet
+3. Validate data structure:
+ - BOM must have columns: Product_SKU, Material_Code, Quantity_Per_Unit
+ - Inventory must have columns: Material_Code, Stock_Quantity
+
+### Step 3: Calculate Material Consumption
+1. Aggregate total quantities needed for each product SKU across all orders.
+2. For each product SKU, look up its BOM entries.
+3. Calculate total material consumption:
+ - `material_consumption[material_code] = sum(product_quantity × quantity_per_unit)`
+4. Log detailed consumption breakdown for verification.
+
+### Step 4: Update Raw Material Inventory
+1. For each material in inventory:
+ - Subtract consumed quantity from current stock
+ - Calculate new stock level
+2. Use `google_sheet-update_cells` to write updated inventory back to Google Sheets.
+3. Maintain the same data structure (Material_Code, Material_Name, Stock_Quantity).
+
+### Step 5: Calculate Maximum Producible Quantities
+1. For each product SKU:
+ - For each material in its BOM:
+ - Calculate `max_from_material = floor(available_stock / quantity_per_unit)`
+ - Determine `min(max_from_material)` across all materials → maximum producible quantity
+ - Identify the limiting material (bottleneck)
+2. This calculation determines the actual stock that can be promised/sold.
+
+### Step 6: Sync to WooCommerce Stock
+1. Use `woocommerce-woo_products_batch_update` to update product stock quantities.
+2. Update `stock_quantity` for each product based on maximum producible calculation.
+3. Ensure `manage_stock: true` is set for each product.
+
+### Step 7: Verification and Reporting
+1. Fetch updated inventory from Google Sheets to confirm changes.
+2. Fetch updated products from WooCommerce to confirm stock levels.
+3. Provide a comprehensive summary including:
+ - Orders processed
+ - Material consumption
+ - Updated inventory levels
+ - Maximum producible quantities
+ - Updated WooCommerce stock levels
+
+## Error Handling
+1. **Missing Configuration**: Check `config.json` exists and has required fields.
+2. **Invalid Spreadsheet ID**: Verify it's a spreadsheet ID, not a folder ID.
+3. **Missing Sheets**: Verify BOM and inventory sheets exist with correct names.
+4. **Data Validation**: Check for missing SKUs in BOM, negative inventory, etc.
+5. **API Errors**: Handle WooCommerce and Google Sheets API errors gracefully.
+
+## Notes
+1. The skill assumes WooCommerce has already reduced finished product stock via `_reduced_stock` meta.
+2. Decimal quantities in BOM (e.g., 0.5L of varnish) are supported.
+3. The limiting material calculation uses integer division (floor) for practical production planning.
+4. Consider running this skill on a schedule (e.g., hourly) or triggered by order status changes.
diff --git a/skills/benchmark_skills/toolathlon/woocommerce-order-inventory-sync/references/data_schemas.md b/skills/benchmark_skills/toolathlon/woocommerce-order-inventory-sync/references/data_schemas.md
new file mode 100644
index 0000000..da41253
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/woocommerce-order-inventory-sync/references/data_schemas.md
@@ -0,0 +1,3 @@
+# Data Schemas and Structures
+
+## Configuration (config.json)
diff --git a/skills/benchmark_skills/toolathlon/woocommerce-product-image-optimizer/SKILL.md b/skills/benchmark_skills/toolathlon/woocommerce-product-image-optimizer/SKILL.md
new file mode 100644
index 0000000..0d45f58
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/woocommerce-product-image-optimizer/SKILL.md
@@ -0,0 +1,50 @@
+---
+name: woocommerce-product-image-optimizer
+description: When the user wants to optimize WooCommerce product images based on sales performance data, particularly for variable products with multiple variations. This skill analyzes order history to identify the best-selling variation for each product and automatically updates the main product image to showcase the most popular option. It handles fetching products and orders data, analyzing sales patterns, identifying variation popularity, and updating product images through WooCommerce API. Use when users mention 'best-selling variation', 'update main product image based on sales', 'product image optimization', or need to align product visuals with customer preferences based on order data.
+---
+# WooCommerce Product Image Optimizer
+
+## Overview
+This skill analyzes WooCommerce order data to identify the best-selling variations for variable products and updates the main product image to showcase the most popular option. This data-driven approach helps improve conversions by aligning product visuals with customer preferences.
+
+## Prerequisites
+- WooCommerce API access with appropriate permissions
+- Variable products with variations that have distinct images
+- Order history data (completed/processing orders)
+
+## Workflow
+
+### 1. Gather Data
+- Fetch all published variable products using `woocommerce-woo_products_list`
+- Fetch recent orders (completed/processing) using `woocommerce-woo_orders_list`
+- For each variable product, fetch its variations using `woocommerce-woo_products_variations_list`
+
+### 2. Analyze Sales Data
+- Parse order line items to extract variation sales data
+- Count total units sold per variation
+- Identify the best-selling variation for each parent product
+- Map variation IDs to their corresponding image data
+
+### 3. Update Product Images
+- For each product with a best-selling variation:
+ - Extract the variation's image ID and URL
+ - Update the parent product's main image using `woocommerce-woo_products_update`
+ - Set the images array to contain only the best-selling variation's image
+
+## Key Considerations
+- Only processes variable products (type: "variable")
+- Considers both "completed" and "processing" order statuses
+- Handles multiple quantity purchases in orders
+- In case of tie in sales, the first variation with highest sales will be selected
+- The update replaces all existing product images with the single best-selling variation image
+
+## Error Handling
+- Skip products without variations
+- Skip variations without images
+- Log any API errors during updates
+- Continue processing other products if one fails
+
+## Output
+- Summary table showing product updates
+- Confirmation of successful image changes
+- Details of best-selling variations and units sold
diff --git a/skills/benchmark_skills/toolathlon/woocommerce-product-image-optimizer/references/woocommerce_api_guide.md b/skills/benchmark_skills/toolathlon/woocommerce-product-image-optimizer/references/woocommerce_api_guide.md
new file mode 100644
index 0000000..99a181d
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/woocommerce-product-image-optimizer/references/woocommerce_api_guide.md
@@ -0,0 +1,13 @@
+# WooCommerce API Reference Guide
+
+## API Endpoints Used
+
+### 1. List Products
+**Endpoint:** `GET /wp-json/wc/v3/products`
+**Purpose:** Fetch all published variable products
+**Parameters:**
+- `per_page`: Number of products per page (default: 100)
+- `status`: Product status (use "publish")
+- `type`: Filter by product type (optional)
+
+**Response Structure:**
diff --git a/skills/benchmark_skills/toolathlon/workspace-file-discovery-manager/SKILL.md b/skills/benchmark_skills/toolathlon/workspace-file-discovery-manager/SKILL.md
new file mode 100644
index 0000000..a9738f0
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/workspace-file-discovery-manager/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: workspace-file-discovery-manager
+description: When the user needs to search for specific files in a workspace based on content patterns, assignment names, or file types, especially when filenames are unknown. This skill triggers when users mention 'files saved somewhere in workspace' or 'can't remember filenames'. It performs directory exploration, content-based file matching, and organizes found files by relevance to specific assignments or document types.
+---
+# Instructions
+
+## Primary Objective
+Help users locate and manage files in their workspace when they cannot remember exact filenames, particularly for academic assignments, documents, or specific content types.
+
+## Core Workflow
+
+### 1. Initial Setup & Context Gathering
+- **Access User Memory**: Retrieve the user's personal information (name, ID, email, courses) using `memory-read_graph`.
+- **Identify Workspace**: Use `filesystem-list_allowed_directories` to locate the accessible workspace root.
+- **Explore Directory Structure**: Use `filesystem-directory_tree` to map the entire workspace contents.
+
+### 2. File Discovery & Matching
+- **Content-Based Search**: When users describe file content (e.g., "assignment about cinematography"), search through file contents using `filesystem-read_multiple_files` on likely candidates.
+- **Pattern Matching**: Look for files with names containing keywords from assignment descriptions, course codes, or user identifiers.
+- **Grade/Submission Analysis**: If a grade summary or submission record exists (e.g., Excel files), analyze it with `local-python-execute` (pandas) to identify missing submissions.
+
+### 3. File Preparation & Submission
+- **Rename Files to Requirements**: Check assignment descriptions for specific naming conventions (e.g., `StudentID_Course_AssignmentX.md`). Create correctly named copies using `filesystem-write_file`.
+- **Submit to LMS**: Use Canvas tools (`canvas-canvas_submit_assignment_with_file`) to submit files for identified missing assignments.
+- **Handle Excused Assignments**: Do not submit assignments that are officially excused (user will provide context). Instead, assist with notifying instructors/TAs.
+
+### 4. Notification & Documentation
+- **Locate Supporting Documents**: Find relevant documents (leave applications, certificates, etc.) in the workspace.
+- **Communicate with Instructors**: Use `emails-send_email` to notify TAs/instructors about excused assignments or provide documentation, attaching relevant files.
+
+## Key Decision Points
+- **Only Submit Missing Work**: Cross-reference grade sheets with submission statuses. Only submit assignments marked as "Not Submitted" that are not excused.
+- **Preserve Original Files**: Do not modify or delete original workspace files. Create renamed copies in the workspace root for submission.
+- **No Content Creation**: Never generate assignment content. Only submit files that already exist in the workspace.
+- **Verify File Types**: Ensure submitted files match allowed extensions specified in assignment details.
+
+## Error Handling
+- If no matching files are found for a described assignment, inform the user and do not submit anything.
+- If grade sheets cannot be parsed, attempt to infer submission status from Canvas API directly.
+- If email sending fails, save the composed message and attachment paths for the user to send manually.
+
+## Bundled Resources
+- Use `scripts/analyze_grade_sheet.py` for robust Excel/CSV grade sheet parsing.
+- Refer to `references/file_matching_patterns.md` for common academic file naming conventions.
diff --git a/skills/benchmark_skills/toolathlon/workspace-file-discovery-manager/references/file_matching_patterns.md b/skills/benchmark_skills/toolathlon/workspace-file-discovery-manager/references/file_matching_patterns.md
new file mode 100644
index 0000000..983b5fa
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/workspace-file-discovery-manager/references/file_matching_patterns.md
@@ -0,0 +1,5 @@
+# Academic File Naming Conventions & Matching Patterns
+
+## Common Patterns for Assignment Files
+
+### 1. By Assignment Number/Name
diff --git a/skills/benchmark_skills/toolathlon/world-bank-region-mapper/SKILL.md b/skills/benchmark_skills/toolathlon/world-bank-region-mapper/SKILL.md
new file mode 100644
index 0000000..607cdb8
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/world-bank-region-mapper/SKILL.md
@@ -0,0 +1,35 @@
+---
+name: world-bank-region-mapper
+description: When the user needs to classify countries according to World Bank geographical or income-based classifications for economic analysis. This skill provides accurate mappings between country names and World Bank region codes (EAS, ECS, LCN, MEA, NAC, SAS, SSF) and income groups (LIC, LMC, UMC, HIC), handling variations in country naming conventions. Triggers include 'World Bank classification', 'map countries to regions', 'regional grouping', 'country classification', 'geographical regions', and any analysis requiring standardized regional categorization according to World Bank definitions.
+---
+# Instructions
+
+## Primary Use Case: CR5 Index Calculation
+This skill is optimized for calculating economic concentration indices (like CR5) across World Bank geographical regions. The canonical workflow is:
+1. **Locate Source Data:** Identify a Google Sheets spreadsheet containing country-level GDP/economic data and a separate sheet or source with regional GDP totals.
+2. **Extract and Map:** Load the country data, map each country to its correct World Bank geographical region using the provided `country_to_region_mapping.json`.
+3. **Group and Calculate:** For each of the 7 major regions (EAS, ECS, LCN, MEA, NAC, SAS, SSF):
+ * Filter and sort the countries within the region by economic value (e.g., GDP) in descending order.
+ * Identify the top N countries (default is top 5, or fewer if the region has fewer countries).
+ * Calculate the sum of the top N countries' values.
+ * Retrieve the region's total value from the regional data source.
+ * Compute the concentration ratio: `(Top N Sum / Region Total) * 100`. Round to two decimal places.
+4. **Output Results:** Create a new, clearly named spreadsheet or table. Populate it with headers: `Region`, `TopN_Countries`, `TopN_Sum`, `Region_Total`, `CRN_Ratio`. Sort the final table in descending order by the concentration ratio.
+
+## Core Mapping Logic
+* **Use the Bundled Mapping:** Always use the canonical `country_to_region_mapping.json` file for the most accurate and up-to-date World Bank classifications. It handles common naming variations found in datasets.
+* **Region Focus:** The seven major geographical regions are the primary focus. Income group classifications (LIC, LMC, UMC, HIC) are available in the mapping but are secondary.
+* **Handling Unmapped Entities:** If a country/entity name from the source data is not found in the mapping, log it for review. Do not guess its classification.
+
+## Key Considerations
+* **Data Integrity:** Verify that the sum of individual country GDPs within a region approximates the official regional total from the World Bank source. Discrepancies may occur due to data vintage or methodology.
+* **Flexible N:** The "N" in CRN (e.g., CR5) is a parameter. The skill should adapt if a region has fewer than N members (e.g., North America has only 3 countries, so CR5 becomes CR3 for that region).
+* **Output Formatting:** Present monetary values in a readable format (e.g., with thousand separators). Express ratios as percentages.
+
+## When to Use Scripts vs. Reasoning
+* **Use `scripts/classify_and_calculate.py` (Low Freedom):** For the deterministic, error-prone tasks of loading data, applying the mapping, performing grouping, sorting, and arithmetic calculations. This ensures consistency and accuracy.
+* **Use Your Judgment (High Freedom):** For interpreting user intent, identifying the correct source sheets in a workbook, designing the structure and naming of the output spreadsheet, and communicating findings or data discrepancies to the user.
+
+## Quick Start Command
+For a standard CR5 analysis from Google Sheets, the expected user command pattern is:
+"Read the country GDP data from [Source Spreadsheet], calculate the CR5 index for each World Bank region, and save the results to a new spreadsheet named [Output Name] with a table titled [Table Name]."
diff --git a/skills/benchmark_skills/toolathlon/youtube-playlist-tech-extractor/SKILL.md b/skills/benchmark_skills/toolathlon/youtube-playlist-tech-extractor/SKILL.md
new file mode 100644
index 0000000..16f4d5b
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/youtube-playlist-tech-extractor/SKILL.md
@@ -0,0 +1,35 @@
+---
+name: youtube-playlist-tech-extractor
+description: When the user requests analysis of a YouTube playlist to identify technical content, extract specific technologies, and locate their corresponding GitHub repositories. This skill enables browsing YouTube playlists, filtering for technical/machine learning videos, identifying mentioned technologies, searching for their GitHub repositories, and compiling structured documentation with project details, repository URLs, and main functions. Triggers include YouTube playlist URLs, requests to find technical/ML videos, needs to locate GitHub repositories for technologies, and requirements to create documentation about tech projects.
+---
+# Skill: YouTube Playlist Tech Extractor
+
+## Core Workflow
+1. **Navigate & Parse Playlist:** Use the browser to load the provided YouTube playlist URL. Navigate through all spans to capture the complete list of video titles and metadata.
+2. **Filter & Identify Technologies:** Analyze the video titles to identify those related to technical, machine learning, or AI coding topics. Extract the specific technology names mentioned (e.g., "Claude Code", "FlashAttention", "Qwen").
+3. **Search for Repositories:** For each identified technology, search for its official or primary GitHub repository. Use the browser to navigate to likely repository URLs (e.g., `github.com/<org>/<project-name>`) to verify their existence and gather details.
+4. **Compile Documentation:** Create a structured markdown report. For each technology, document:
+ * The technology/project name.
+ * The official GitHub repository URL.
+ * A description of its main functions and capabilities, synthesized from the repository description and your knowledge.
+ * A list of related videos from the playlist.
+5. **Output:** Write the final compiled report to a specified file in the workspace (e.g., `ml_tech.md`).
+
+## Key Instructions & Heuristics
+* **Playlist Navigation:** YouTube playlists are often paginated or loaded in "spans". Use the `browser_snapshot_navigate_to_next_span` tool iteratively until you have viewed all video entries.
+* **Technology Recognition:** Look for keywords in video titles: AI model names (Claude, Gemini, Qwen, Mistral), project names (OpenHands, FlashAttention), tools (GitHub Copilot), and technical domains (machine learning, coding, AI agents).
+* **Repository Discovery:** Construct repository URLs based on common patterns: `github.com/<organization>/<project-name>`. The organization is often the company or research lab behind the technology (e.g., `anthropics`, `Dao-AILab`, `QwenLM`). Verify each URL by navigating to it. If a 404 is encountered, the technology may be proprietary (e.g., Apple Intelligence) or hosted elsewhere; note this in the report.
+* **Report Structure:** Follow the template demonstrated in the trajectory. Include a summary table for quick reference. Clearly note when a technology is proprietary and lacks a public repository.
+
+## Tools Required
+* `playwright_with_chunk-browser_navigate`: To load the initial playlist and repository pages.
+* `playwright_with_chunk-browser_snapshot_navigate_to_next_span`: To scroll through the entire playlist.
+* `playwright_with_chunk-browser_tab_new` / `playwright_with_chunk-browser_tab_select`: To efficiently open and switch between multiple GitHub repository pages.
+* `filesystem-write_file`: To create the final output markdown file.
+* `filesystem-read_file`: (Optional) To verify the written output.
+
+## Error Handling & Edge Cases
+* If the playlist is private or requires login, inform the user.
+* If a technology name is ambiguous, search for the most likely repository and use the repository's own description to confirm.
+* If a repository search fails, note "Repository not found (likely proprietary/closed source)" in the report.
+* The final output file path should be confirmed with the user or derived from their request (e.g., `ml_tech.md` in the workspace).
diff --git a/skills/benchmark_skills/toolathlon/youtube-playlist-tech-extractor/references/report_template.md b/skills/benchmark_skills/toolathlon/youtube-playlist-tech-extractor/references/report_template.md
new file mode 100644
index 0000000..9ccc8e0
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/youtube-playlist-tech-extractor/references/report_template.md
@@ -0,0 +1,41 @@
+# [Topic] Technologies from YouTube Playlist
+
+This document lists the [e.g., machine learning] related technical videos from the YouTube playlist "[Playlist Name]" and their associated GitHub repositories.
+
+## Technologies and GitHub Repositories
+
+### 1. [Technology Name]
+- **GitHub Repository**: [URL]
+- **Main Functions**:
+ - [Function 1]
+ - [Function 2]
+ - [Function 3]
+
+**Related Videos**:
+- [Video Title 1]
+- [Video Title 2]
+
+---
+
+### 2. [Technology Name]
+- **GitHub Repository**: [URL or note if proprietary]
+- **Main Functions**:
+ - [Function 1]
+ - [Function 2]
+
+**Related Videos**:
+- [Video Title 1]
+
+---
+[Continue for each technology...]
+
+## Summary Table
+
+| Technology | GitHub URL | Primary Use Case |
+|------------|-----------|------------------|
+| [Tech 1] | [URL 1] | [Use case 1] |
+| [Tech 2] | [URL 2] | [Use case 2] |
+
+---
+
+*Note: Some technologies mentioned in the playlist do not have public GitHub repositories as they are proprietary products.*
diff --git a/skills/benchmark_skills/toolathlon/youtube-playlist-tech-extractor/references/repository_patterns.md b/skills/benchmark_skills/toolathlon/youtube-playlist-tech-extractor/references/repository_patterns.md
new file mode 100644
index 0000000..8d64922
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/youtube-playlist-tech-extractor/references/repository_patterns.md
@@ -0,0 +1,24 @@
+# Common GitHub Repository URL Patterns
+When searching for a technology's GitHub repository, try these patterns in order.
+
+## Pattern 1: Organization/Project
+The most common pattern. The organization is often the company or main research group.
+* `https://github.com/anthropics/claude-code`
+* `https://github.com/Dao-AILab/flash-attention`
+* `https://github.com/QwenLM/Qwen`
+* `https://github.com/mistralai/mistral-inference`
+* `https://github.com/google-gemini/gemini-cli`
+
+## Pattern 2: ProjectName/ProjectName
+Some projects have an organization named after the project itself.
+* `https://github.com/OpenHands/OpenHands`
+
+## Pattern 3: Features Page (Proprietary)
+For commercial products, the main page may be under `github.com/features`.
+* `https://github.com/features/copilot`
+
+## Search Strategy
+1. Extract the clean project name from the video title (e.g., "Claude Code" -> `claude-code`).
+2. Identify the likely organization (e.g., "Claude Code" is by Anthropic -> `anthropics`).
+3. Construct URL: `https://github.com/<organization>/<project-name>`.
+4. Navigate. If 404, the project may be closed source, or the organization/project name may be different. Use your judgment or note it as proprietary.
diff --git a/skills/benchmark_skills/toolathlon/youtube-playlist-tech-extractor/references/tech_keywords.md b/skills/benchmark_skills/toolathlon/youtube-playlist-tech-extractor/references/tech_keywords.md
new file mode 100644
index 0000000..e910028
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/youtube-playlist-tech-extractor/references/tech_keywords.md
@@ -0,0 +1,37 @@
+# Technology Keywords for Video Filtering
+Use this list to identify technical videos in a YouTube playlist. Videos containing these or related terms in their titles are candidates for inclusion.
+
+## AI/ML Models & Companies
+* Claude (Anthropic)
+* GPT, OpenAI, o1
+* Gemini (Google)
+* Copilot (GitHub)
+* Codex
+* Llama (Meta)
+* Mistral, Devstral
+* Qwen (Alibaba)
+* Phi (Microsoft)
+* Apple Intelligence
+* DeepSeek
+
+## AI Tools & Frameworks
+* OpenHands, OpenDevin
+* Cursor
+* Tabnine
+* Hugging Face, Transformers
+* PyTorch, TensorFlow, JAX
+* LangChain, LlamaIndex
+* vLLM, TGI (Text Generation Inference)
+* FlashAttention
+* MCP (Model Context Protocol)
+
+## Technical Domains
+* Machine Learning, ML
+* Artificial Intelligence, AI
+* Large Language Model, LLM
+* Coding, Programming, Software Engineering
+* Data Science
+* Inference, Training
+* Attention, Transformer
+* CLI (Command Line Interface)
+* Agent, Autonomous Agent
diff --git a/skills/benchmark_skills/toolathlon/youtube-playlist-tracklist-extractor/SKILL.md b/skills/benchmark_skills/toolathlon/youtube-playlist-tracklist-extractor/SKILL.md
new file mode 100644
index 0000000..81fbea9
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/youtube-playlist-tracklist-extractor/SKILL.md
@@ -0,0 +1,34 @@
+---
+name: youtube-playlist-tracklist-extractor
+description: Extracts song lists or track information from YouTube videos or playlists, particularly for music compilations, trending playlists, or music mixes. Handles searching, navigating, extracting tracklists from descriptions, and formatting the data.
+---
+# Skill: YouTube Playlist Tracklist Extractor
+
+## Primary Objective
+Extract a structured list of songs from a specified YouTube video or playlist and write it to a file, following a provided format template.
+
+## Core Workflow
+1. **Parse Request & Load Format:** Understand the user's request for a specific YouTube video/playlist. Immediately read the specified format file (e.g., `format.md`) to understand the required output structure.
+2. **Search & Identify Target:** Perform a web search using the exact or descriptive title provided by the user to find the correct YouTube URL.
+3. **Access Video & Extract Data:** Navigate to the identified YouTube video URL. Locate and expand the video description to reveal the full tracklist.
+4. **Parse & Structure Data:** Extract all song entries from the description. Clean and format the data (e.g., standardizing song numbers, artists, and titles).
+5. **Generate Output:** Compile the extracted song list into the structure defined by the format template and write it to the specified output file.
+6. **Verify & Conclude:** Read back the created file to confirm successful creation and content accuracy, then notify the user.
+
+## Key Techniques & Handling
+- **Description Expansion:** YouTube descriptions are often truncated. Look for and click buttons like "`...more`" or "`Show more`" to reveal the full text containing the tracklist.
+- **Robust Parsing:** Tracklists in descriptions can have varying formats (e.g., "1. Song - Artist", "00:00 Song - Artist"). Focus on extracting the core "Song - Artist" pattern.
+- **Fallback Strategy:** If the primary video is inaccessible (e.g., geo-blocked, age-restricted, transcript API blocked), use browser automation (`playwright_with_chunk`) as the reliable method to access the page and scrape the description.
+- **Output Adherence:** Strictly follow the user-provided format template for the final output file.
+
+## Common Triggers
+Use this skill when the user request involves:
+- "Find the YouTube video titled [X] and list the songs"
+- "Extract the tracklist from this YouTube playlist/link"
+- "Identify the names of each song from this YouTube music mix"
+- Keywords: `YouTube playlist`, `song list`, `tracklist`, `music compilation`, `top hits`, `identify songs from lyrics`.
+
+## Notes
+- The primary data source is the video description, not audio analysis or transcripts.
+- The skill assumes the tracklist is textually available in the description.
+- Focus on accuracy of the extracted song and artist names over perfect timestamp alignment.
diff --git a/skills/benchmark_skills/toolathlon/youtube-playlist-tracklist-extractor/references/format_template.md b/skills/benchmark_skills/toolathlon/youtube-playlist-tracklist-extractor/references/format_template.md
new file mode 100644
index 0000000..99225ea
--- /dev/null
+++ b/skills/benchmark_skills/toolathlon/youtube-playlist-tracklist-extractor/references/format_template.md
@@ -0,0 +1,2 @@
+# [Replace with Video Title] - list
+
diff --git a/skills/benchmark_skills/webshop/webshop-action-executor/SKILL.md b/skills/benchmark_skills/webshop/webshop-action-executor/SKILL.md
new file mode 100644
index 0000000..8f54cfb
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-action-executor/SKILL.md
@@ -0,0 +1,18 @@
+---
+name: webshop-action-executor
+description: This skill executes a specific interface action, such as clicking a button or selecting an option, within a web shopping environment. It should be triggered when a decision has been made (e.g., to choose a color or proceed to purchase). The input is the target action identifier (e.g., 'white' or 'buy now'), and the output is the corresponding formatted action command (e.g., click[white]).
+---
+# Skill: WebShop Action Executor
+
+## Purpose
+Execute a single, specific action in a WebShop environment after a decision has been made. This skill formats the action into the required command structure for the WebShop interface.
+
+## When to Use
+- **Trigger:** When the agent has completed its analysis and has decided on the exact action to take (e.g., "select the white color option," "proceed to buy now").
+- **Input:** A clear target identifier (string) derived from the available actions on the current page.
+- **Output:** A correctly formatted `click[value]` or `search[keywords]` command.
+
+## Core Instruction
+1. **Receive Input:** The skill is provided with a single `target_action` string (e.g., 'white', 'buy now', 'b08w25dbb7').
+2. **Format Output:** Immediately output the action in the exact format required by the WebShop environment:
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/webshop/webshop-attribute-selector/SKILL.md b/skills/benchmark_skills/webshop/webshop-attribute-selector/SKILL.md
new file mode 100644
index 0000000..641b0ea
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-attribute-selector/SKILL.md
@@ -0,0 +1,24 @@
+---
+name: webshop-attribute-selector
+description: Selects specific product attributes (e.g., flavor, size) on a product detail page to match user requirements. Triggered when a product page presents configurable options and the parsed query specifies needed values. It identifies the correct option from available clickables (e.g., 'smoked bacon' for flavor, '4 ounce (pack of 2)' for size) and executes the selection click.
+---
+# Instructions
+
+## When to Use
+Activate this skill when ALL of the following are true:
+1. You are on a product detail page (not a search results page).
+2. The observation contains configurable product options (e.g., "flavor", "size") listed as available actions.
+3. The user's instruction specifies required values for one or more of these attributes (e.g., "gluten free", "4 ounce (pack of 2)", "smoked peppered bacon").
+
+## Core Process
+1. **Parse Requirements:** From the user's instruction, extract the required attribute values (e.g., target flavor, size, dietary feature).
+2. **Map to Options:** Examine the list of available actions (clickables). Identify which clickable text corresponds to each required attribute value.
+ * Use exact or fuzzy matching (see `scripts/match_attribute.py` for logic).
+ * Prioritize exact matches. For dietary features like "gluten free" or "vegetarian," the product title or description may already confirm this; your goal is to select the correct flavor/size.
+3. **Execute Selection:** For each identified attribute option, perform a `click[value]` action, where `value` is the exact text of the matching clickable.
+4. **Finalize:** After all required attributes are selected, if a "Buy Now" or similar action is available and the instruction implies a purchase, you may proceed to click it.
+
+## Important Notes
+* Do not use this skill on search results pages. Use search actions there.
+* If a required attribute cannot be matched to any available clickable, do not click. Re-evaluate the instruction or consider a different product.
+* The observation may refresh after each click, showing the same page with selected options highlighted. Continue until all specified attributes are satisfied.
diff --git a/skills/benchmark_skills/webshop/webshop-attribute-verifier/SKILL.md b/skills/benchmark_skills/webshop/webshop-attribute-verifier/SKILL.md
new file mode 100644
index 0000000..9cb5f3e
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-attribute-verifier/SKILL.md
@@ -0,0 +1,24 @@
+---
+name: webshop-attribute-verifier
+description: This skill confirms specific product attributes on a detailed product page. It is triggered when navigating to an individual product listing to verify details such as color options, exact price, or specifications. The skill checks available selections or displayed information against the user's requirements, ensuring the product matches before proceeding to purchase.
+---
+# Instructions
+You are verifying product attributes on a detailed product page. Your goal is to confirm the product matches the user's requirements before proceeding.
+
+## Core Workflow
+1. **Parse Requirements:** Extract the user's target attributes (e.g., color, max price) from the instruction.
+2. **Inspect Page:** Examine the observation for the product's details, available options (like color buttons), price, and specifications.
+3. **Verify Match:** Systematically check if the product's attributes satisfy all user requirements.
+4. **Act Accordingly:**
+ * If the product matches **all** requirements, proceed to select the correct option (e.g., click the correct color) and then initiate the purchase (e.g., click 'Buy Now').
+ * If the product **does not match** a requirement (e.g., wrong color, price too high), navigate back to search.
+
+## Action Guidelines
+* Use `click[value]` to interact with page elements. The `value` must exactly match a clickable item from the observation.
+* Use `search[keywords]` only if you need to find a new product because the current one does not meet requirements.
+* Your `Thought:` must explicitly state which requirement you are checking and the result of the check.
+
+## Critical Rules
+* **Price Check:** The product's price must be **strictly lower than** the user's specified maximum price.
+* **Attribute Selection:** If a specific attribute (like color) is required, you **must** click the corresponding option button (e.g., `click[black]`) before proceeding to purchase.
+* **Sequential Actions:** Do not skip the attribute selection step. The purchase action should only follow a successful verification and selection.
diff --git a/skills/benchmark_skills/webshop/webshop-initial-search/SKILL.md b/skills/benchmark_skills/webshop/webshop-initial-search/SKILL.md
new file mode 100644
index 0000000..c82ffce
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-initial-search/SKILL.md
@@ -0,0 +1,19 @@
+---
+name: webshop-initial-search
+description: Performs the first search on an e-commerce platform using keywords derived from parsed user requirements. Trigger this skill when starting product discovery or when previous search results are insufficient. It formulates a search query from the criteria (e.g., '24 pack of 7.5 ounce bottles of non-gmo classic tonic') and executes the search action, returning the initial result page.
+---
+# Instructions
+1. **Parse Requirements:** Extract the core product criteria from the user's instruction. Focus on:
+ * **Quantity & Packaging:** (e.g., "24 pack")
+ * **Size:** (e.g., "7.5 ounce bottles")
+ * **Key Attributes:** (e.g., "non-gmo", "classic tonic")
+ * **Price Constraint:** (e.g., "price lower than 50.00 dollars") - This is for validation later, not for the initial search query.
+
+2. **Formulate Search Query:** Combine the extracted criteria into a concise, natural-language search string. Prioritize specificity to filter results effectively.
+ * **Example:** For "i would like to get a 24 pack of 7.5 ounce bottles of non-gmo classic tonic", the query should be: `24 pack of 7.5 ounce bottles of non-gmo classic tonic`
+ * **Do not** include the price constraint in the search keywords.
+
+3. **Execute Search:** Use the platform's `search[<keywords>]` action with your formulated query.
+ * The action output will be the initial search results page observation.
+
+4. **Next Steps:** After executing this skill, proceed to evaluate the search results. The next actions will typically involve clicking on a promising product listing or refining the search.
diff --git a/skills/benchmark_skills/webshop/webshop-option-selector/SKILL.md b/skills/benchmark_skills/webshop/webshop-option-selector/SKILL.md
new file mode 100644
index 0000000..0bf2110
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-option-selector/SKILL.md
@@ -0,0 +1,24 @@
+---
+name: webshop-option-selector
+description: This skill selects product options or variants (such as size, color, or quantity) on a product detail page based on user preferences or cost optimization. It should be triggered when a product page displays configurable options. The skill evaluates available choices (e.g., 1pcs vs 2pcs) and selects the one that best aligns with the user's constraints, such as minimizing cost.
+---
+# Skill: WebShop Option Selector
+
+## Trigger Condition
+Activate this skill when the observation from the WebShop environment contains:
+1. A product detail page (indicated by the presence of a "Price:" field and product title).
+2. One or more configurable option categories (e.g., "size:", "color:", "quantity:") with clickable values listed beneath them.
+
+## Core Logic
+1. **Parse the Observation:** Identify all configurable option categories and their available values from the current page state.
+2. **Apply Selection Strategy:** By default, implement a **cost-minimization strategy**. For each option category, select the value that results in the lowest final price while still meeting any explicit user constraints from the original instruction (e.g., "price lower than 40.00 dollars").
+3. **Execute Selection:** Perform a `click[value]` action for the chosen option value. If multiple categories exist, they should be selected in the order they appear on the page.
+
+## Important Notes
+- The skill assumes the displayed price updates (or is representative) after an option is selected. Your action should be based on the currently displayed information.
+- If the user's instruction contains specific preferences (e.g., "large size", "blue color"), prioritize those over cost minimization.
+- If no clear cost difference can be inferred, select the first available option.
+- After selecting the desired option, you may proceed with other actions (e.g., `click[buy now]`).
+
+## Example from Trajectory
+**Observation Excerpt:**
diff --git a/skills/benchmark_skills/webshop/webshop-option-selector/references/strategy_docs.md b/skills/benchmark_skills/webshop/webshop-option-selector/references/strategy_docs.md
new file mode 100644
index 0000000..5e9d877
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-option-selector/references/strategy_docs.md
@@ -0,0 +1,35 @@
+# Strategy Documentation for Option Selection
+
+## Overview
+This document details the decision-making strategies for the `webshop-option-selector` skill.
+
+## Primary Strategy: Cost Minimization
+**When to Use:** Default strategy when no user preference is detected.
+**Logic:** Select the option value presumed to be the lowest cost. In e-commerce, this is often:
+- The smallest quantity (e.g., "1pcs" vs "2pcs").
+- The base model or standard variant.
+- The default color or size.
+
+**Implementation Note:** The current script uses a simple heuristic: select the **first listed value** for an option category, as product pages often list options in ascending order of price or quantity. For a production system, this would require integrating with a live pricing API or parsing dynamic price tags.
+
+## Secondary Strategy: User Preference Matching
+**When to Use:** When the user's original instruction contains explicit keywords matching an available option.
+**Logic:**
+1. Extract keywords from the instruction (e.g., "large", "blue", "2 pack").
+2. For each configurable option category, check if any value contains a matching keyword (case-insensitive).
+3. Select the first matching value.
+
+**Precedence:** User preference overrides cost minimization.
+
+## Edge Cases & Handling
+1. **No Options Found:** Skill does not trigger. Return no action.
+2. **Multiple Categories:** Process categories in the order they appear on the page. The script currently selects for the first category only; for multiple categories, the agent should loop.
+3. **Price Constraint Violation:** The skill assumes the agent has already validated the product price against the user's budget (e.g., "under $40") before reaching the option page. If an option selection would exceed the budget, the agent should backtrack.
+4. **Unclear Cost Difference:** If the price impact of options is unknown, default to the first option.
+
+## Integration with Agent
+The agent should:
+1. Check the trigger condition (product detail page with options).
+2. Call the `parse_and_select.py` script (or its logic) with the current observation and the original user instruction.
+3. Execute the returned `click[value]` action.
+4. Observe the resulting state (updated price, new options) and decide on subsequent actions (e.g., select another option, click "Buy Now").
diff --git a/skills/benchmark_skills/webshop/webshop-price-checker/SKILL.md b/skills/benchmark_skills/webshop/webshop-price-checker/SKILL.md
new file mode 100644
index 0000000..1e42bda
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-price-checker/SKILL.md
@@ -0,0 +1,18 @@
+---
+name: webshop-price-checker
+description: This skill scans product listings or detail pages to verify if an item's price meets a specified budget constraint. It is triggered when evaluating a potential product for purchase. It extracts the price from the displayed information (e.g., '$164.95') and compares it against the maximum allowed budget, outputting a boolean decision on whether the item is within budget.
+---
+# Instructions
+When evaluating a product for purchase, use this skill to check if its price is within the specified budget.
+
+## Process
+1. **Identify the Budget:** Extract the maximum allowed price from the user's instruction or the current context. The budget is typically expressed as a dollar amount (e.g., "lower than 200.00 dollars").
+2. **Locate the Price:** On the current web page (search results or product detail page), find the price string. It is usually prefixed with a `$` symbol and may be labeled "Price:".
+3. **Execute Check:** Run the `check_price.py` script, providing it with the extracted price string and the budget.
+4. **Make Decision:** Based on the script's boolean output (`True`/`False`):
+ * If `True`: The item is within budget. You may proceed with further evaluation or purchase.
+ * If `False`: The item exceeds the budget. You should continue searching or select a different item.
+
+## Notes
+* The primary action for this skill is to call the bundled script. Do not perform manual price parsing or comparison in your main reasoning.
+* If the price cannot be found on the page, assume the item is not suitable and continue your search.
diff --git a/skills/benchmark_skills/webshop/webshop-price-checker/references/price_patterns.md b/skills/benchmark_skills/webshop/webshop-price-checker/references/price_patterns.md
new file mode 100644
index 0000000..4571af4
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-price-checker/references/price_patterns.md
@@ -0,0 +1,23 @@
+# Common Price String Patterns
+This reference lists common formats for price strings encountered in e-commerce environments. The `check_price.py` script is designed to handle these.
+
+## Primary Patterns
+* `$164.95`
+* `Price: $164.95`
+* `$277.99`
+* `$100.0` (Note: May be displayed with one decimal place)
+* `$1,299.99` (Includes comma as thousands separator)
+
+## Implied Context
+On a product page, the price is often near:
+* The "Buy Now" button.
+* The product title.
+* A label such as "Price:", "Cost:", or "Our Price:".
+
+## Notes for the Agent
+1. The budget constraint in the instruction may be phrased as:
+ * "price lower than 200.00 dollars"
+ * "under $200"
+ * "less than 200.00"
+2. Always convert the budget phrase into a numerical `max_budget` float (e.g., `200.00`) before calling the script.
+3. If multiple prices are present (e.g., a sale price and a list price), target the current selling price, which is usually the most prominent.
diff --git a/skills/benchmark_skills/webshop/webshop-product-detail-check/SKILL.md b/skills/benchmark_skills/webshop/webshop-product-detail-check/SKILL.md
new file mode 100644
index 0000000..3d1465e
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-product-detail-check/SKILL.md
@@ -0,0 +1,41 @@
+---
+name: webshop-product-detail-check
+description: This skill examines a specific product's detailed page to verify it matches the user's requirements, checking price, description, features, and reviews. Trigger when a candidate product is selected from search results. It confirms alignment with constraints and provides a final suitability assessment before purchase.
+---
+# Skill: Product Detail Verification
+
+## Trigger
+Activate this skill when the agent has navigated to a specific product's detailed page from a search results list. The agent should have a user query containing specific requirements (e.g., product type, attributes, price constraints).
+
+## Core Objective
+Analyze the product detail page to confirm if the product meets all user-specified constraints. Provide a clear "Proceed" or "Reject" recommendation.
+
+## Execution Workflow
+
+1. **Parse User Requirements:** Extract key constraints from the user's instruction. Primary constraints are typically **Price** and **Key Attributes** (e.g., "long", "clip-in", "natural looking"). Store these in a structured format.
+
+2. **Scrape Product Page Data:** Systematically extract the following information from the current page observation:
+ * **Product Title**
+ * **Price**
+ * **Key Description Snippets** (from Description/Features sections)
+ * **Rating** (if available)
+ * **Availability of "Buy Now"** action.
+
+3. **Constraint Verification:** Compare the scraped data against the user's requirements.
+ * **Price Check:** Is the product price strictly less than the user's maximum? (e.g., < $40.00).
+ * **Attribute Check:** Do the title and description contain terms matching the user's key attributes? (e.g., confirm "clip-in" and "natural looking" are present).
+ * **Suitability Flag:** Product is suitable only if **ALL** hard constraints (price, mandatory attributes) are satisfied.
+
+4. **Decision & Action:**
+ * **If SUITABLE:** Conclude the product matches requirements. The recommended action is `click[buy now]`.
+ * **If NOT SUITABLE:** Conclude the product fails one or more constraints. The recommended action is to return to search (`click[back to search]`) to find another candidate.
+
+## Output Format
+Your response must use the following format:
+
+**Thought:** [Your reasoning, summarizing the user's constraints, the product details found, and the result of the verification check.]
+**Action:** [The single, valid action to take: `click[buy now]` or `click[back to search]`]
+
+## Notes
+* Prioritize information explicitly on the product page. Assume missing information (like a Rating of "N.A.") does not disqualify a product unless specified by the user.
+* The "Buy Now" button must be present in the available actions list for the purchase action to be valid.
diff --git a/skills/benchmark_skills/webshop/webshop-product-detail-check/references/action_guidelines.md b/skills/benchmark_skills/webshop/webshop-product-detail-check/references/action_guidelines.md
new file mode 100644
index 0000000..12b5002
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-product-detail-check/references/action_guidelines.md
@@ -0,0 +1,24 @@
+# WebShop Action Guidelines
+
+## Action Format
+The environment requires actions in one of two strict formats:
+* `search[keywords]`
+* `click[value]`
+
+The `value` in a `click` action must be an **exact match** (case-insensitive) of an item in the list of available actions presented in the observation.
+
+## Available Actions Identification
+Available actions are typically indicated in the observation by:
+1. **Clickable Buttons/Text:** Items like `Back to Search`, `< Prev`, `Next >`, `Buy Now`, `Description`.
+2. **Product ASINs:** Alphanumeric codes starting with 'B0' (e.g., `B09C337K8S`) that are clickable in search results.
+3. **Page Navigation:** `Page X (Total results: Y)`.
+
+## Invalid Actions
+If the specified `value` for a `click` action is not present in the current observation, the action is invalid and the agent performs nothing, wasting a step.
+
+## Action Strategy for This Skill
+This skill (`webshop-product-detail-check`) operates on a product detail page. The primary actionable outputs are:
+1. `click[buy now]`: If the product is verified as suitable.
+2. `click[back to search]`: If the product is not suitable, to return to the search results.
+
+Always verify the target string (e.g., "buy now", "back to search") is present in the observation before recommending the action.
diff --git a/skills/benchmark_skills/webshop/webshop-product-detail-inspector/SKILL.md b/skills/benchmark_skills/webshop/webshop-product-detail-inspector/SKILL.md
new file mode 100644
index 0000000..228ce0f
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-product-detail-inspector/SKILL.md
@@ -0,0 +1,26 @@
+---
+name: webshop-product-detail-inspector
+description: This skill examines a product detail page to verify specific attributes or select options like size, color, or quantity. It is used after clicking on a product, to confirm that the item matches the user's needs (e.g., checking for '10 slots' option, price, material). The input is the product page observation, and the output is an action to select a required variant (e.g., click[10 slots]) or proceed if criteria are satisfied.
+---
+# Instructions
+
+## Purpose
+You are an agent navigating a web shop. Your current task is to inspect a product detail page. You have arrived here after clicking on a product from the search results.
+
+## Input
+You will receive an **Observation** containing the product page state. This includes:
+* The original user instruction (e.g., "i am looking for an easy to clean jewelry box with 10 slots, and price lower than 60.00 dollars").
+* Product details: Title, Price, Rating.
+* Available options (e.g., size variants like "3 slot", "10 slots").
+* Available actions (e.g., "Buy Now", "Description").
+
+## Core Logic
+1. **Parse the Instruction:** Identify the user's key requirements from the instruction (e.g., specific attribute: "10 slots", price constraint: "< $60").
+2. **Examine the Page:** Check the product's displayed **Price** against the user's budget. Check the available options for the required attribute.
+3. **Decision & Action:**
+ * If the required attribute (e.g., "10 slots") is present as a selectable option, click on it.
+ * If the product does not have the required attribute or exceeds the price limit, you should go "Back to Search".
+ * If the product meets all criteria (correct attribute selected, price is valid), you may proceed (e.g., click "Buy Now").
+
+## Output Format
+Your response must be in this exact format:
diff --git a/skills/benchmark_skills/webshop/webshop-product-detail-inspector/references/action_guidelines.md b/skills/benchmark_skills/webshop/webshop-product-detail-inspector/references/action_guidelines.md
new file mode 100644
index 0000000..fdd1615
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-product-detail-inspector/references/action_guidelines.md
@@ -0,0 +1,23 @@
+# Action Guidelines for WebShop Navigation
+
+## Valid Action Patterns
+The environment only accepts actions in these formats:
+* `search[keywords]`
+* `click[value]`
+
+## Click Action Rules
+1. **Exact Match Required:** The `value` inside `click[]` must be an exact, case-sensitive string match for a clickable element shown in the observation.
+2. **Common Clickable Elements:**
+ * Product IDs (e.g., `B08VJB28BL`)
+ * Option buttons (e.g., `10 slots`, `Large`, `Blue`)
+ * Navigation (e.g., `Back to Search`, `< Prev`, `Next >`)
+ * Page actions (e.g., `Buy Now`, `Add to Cart`, `Description`)
+
+## Search Action Rules
+1. **Use when:** You need to find new products. This is typically done from the main search page.
+2. **Keyword Strategy:** Combine key product terms from the instruction. Be specific but not overly long.
+ * Good: `search[jewelry box 10 slots under $60]`
+ * Less Effective: `search[box]`
+
+## Error Handling
+If you attempt an invalid action (e.g., `click[Something Not Listed]`), the environment will ignore it and the state will not change. Always verify the available actions list in the observation before responding.
diff --git a/skills/benchmark_skills/webshop/webshop-product-detail-inspector/references/trajectory_example.md b/skills/benchmark_skills/webshop/webshop-product-detail-inspector/references/trajectory_example.md
new file mode 100644
index 0000000..fa806b8
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-product-detail-inspector/references/trajectory_example.md
@@ -0,0 +1,35 @@
+# Example Trajectory Breakdown
+
+This document breaks down the provided execution trajectory to illustrate the skill's intended use.
+
+## Scenario
+**User Instruction:** "i am looking for an easy to clean jewelry box with 10 slots, and price lower than 60.00 dollars"
+
+### Step 1: Initial Search
+* **Observation:** Search page is presented.
+* **Agent Thought:** Need to find item matching criteria. Start with a targeted search.
+* **Agent Action:** `search[jewelry box, 10 slots, less than $60, easy to clean]`
+* **Rationale:** The agent correctly uses the `search` action, incorporating the main product type and key constraints.
+
+### Step 2: Inspecting Search Results
+* **Observation:** Search results list. Item `B08VJB28BL` is a "Clear Glass Jewelry Box" priced at `$20.97`.
+* **Agent Thought:** First item matches budget and seems relevant ("clear glass" suggests easy to clean). Click to inspect details.
+* **Agent Action:** `click[b08vjb28bl]`
+* **Rationale:** The agent moves from the list view to the product detail page for closer inspection.
+
+### Step 3: Product Detail Inspection & Variant Selection (CORE SKILL)
+* **Observation:** Product detail page. Options include `3 slot`, `6 grids`, `10 slots`, `30 grids`. Price is `$20.97`.
+* **Agent Thought:** The page shows a `10 slots` option, which matches the user's requirement. Price is valid.
+* **Agent Action:** `click[10 slots]`
+* **Rationale:** This is the core function of the skill. The agent identifies the required attribute among the options and selects it.
+
+### Step 4: Proceeding with Purchase
+* **Observation:** Page remains on product detail (variant selected). `Buy Now` is available.
+* **Agent Thought:** All criteria are satisfied (10 slots selected, price < $60). Proceed to buy.
+* **Agent Action:** `click[buy now]`
+* **Rationale:** After confirming the product meets all requirements, the agent takes the next logical step.
+
+## Key Takeaways for the Skill
+1. The skill is activated **after** navigating to a product page.
+2. Its primary job is to **locate and select a specific product variant** based on the user's instruction.
+3. It must also perform a final **price check** before proceeding.
diff --git a/skills/benchmark_skills/webshop/webshop-product-detail-navigator/SKILL.md b/skills/benchmark_skills/webshop/webshop-product-detail-navigator/SKILL.md
new file mode 100644
index 0000000..a9010f0
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-product-detail-navigator/SKILL.md
@@ -0,0 +1,39 @@
+---
+name: webshop-product-detail-navigator
+description: Navigates to and interacts with a specific product's detail page. This skill is triggered after a candidate product ID is selected from search results. It performs the click action to load the product page and then identifies available interactive elements (like flavor or size selectors) that need to be configured to match the user's requirements.
+---
+# Instructions
+
+## Purpose
+This skill is used to navigate from a product search result to the product's detail page and configure it according to the user's specific requirements (e.g., flavor, size, dietary needs).
+
+## When to Use
+Use this skill when you have identified a candidate product from a search result list and need to:
+1. Load its detailed product page.
+2. Verify its attributes against the user's instruction.
+3. Select the correct options (like `flavor` or `size`) to match the user's request.
+4. Proceed to the final purchase step if all criteria are met.
+
+## Core Workflow
+1. **Navigate to Product Page:** Click on the product ID (e.g., `B06Y96MXJV`) from the search results to load its detail page.
+2. **Parse the Page State:** Once on the product page, the observation will contain the product title, price, and a list of available interactive elements (clickables). Analyze these to find configuration options.
+3. **Match Requirements:** Cross-reference the user's original instruction with the available options. Look for keywords related to:
+ * **Product Type/Flavor:** (e.g., "smoked peppered bacon", "smoked bacon").
+ * **Attributes:** (e.g., "gluten free", "vegetarian").
+ * **Size/Packaging:** (e.g., "4 ounce (pack of 2)").
+ * **Price:** Ensure the displayed price is below any specified maximum.
+4. **Configure the Product:** Sequentially click on the option values that match the user's requirements. The typical order is to select the correct `flavor` first, then the correct `size`.
+5. **Finalize:** After configuring the product, if all requirements are satisfied, click the final action button (e.g., `Buy Now`).
+
+## Action Format
+Your actions must strictly follow the required format:
+* `click[<exact_value>]` - The `<exact_value>` must match one of the strings in the "clickables" list from the observation, including case and spacing.
+* `search[<keywords>]` - Use only if you need to go back to search. This skill focuses on post-search navigation.
+
+## Key Logic (Handled by Script)
+The deterministic sequence of checking for and selecting flavor and size options is handled by the bundled script `configure_product.py`. Use it to generate the correct click actions after loading the product page.
+
+## Important Notes
+* **Validation:** Do not click an option if it does not appear in the current list of clickables.
+* **Observation:** Always read the full observation after each action. The list of clickables updates after each selection.
+* **Goal:** The final goal is to have a product configured per the user's instruction and ready for purchase.
diff --git a/skills/benchmark_skills/webshop/webshop-product-detail-navigator/references/action_protocol.md b/skills/benchmark_skills/webshop/webshop-product-detail-navigator/references/action_protocol.md
new file mode 100644
index 0000000..27d6788
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-product-detail-navigator/references/action_protocol.md
@@ -0,0 +1,19 @@
+# WebShop Action Protocol Reference
+
+## Overview
+This document details the strict action-response protocol used in the WebShop environment that this skill operates within.
+
+## Action Format
+All actions must be output in one of two formats:
+
+1. **Search Action:** `search[<keywords>]`
+ * `<keywords>`: A string of search terms. These should be carefully chosen to match the user's request.
+ * **Usage:** Primarily used before this skill is triggered. This skill focuses on post-search navigation.
+
+2. **Click Action:** `click[<value>]`
+ * `<value>`: **Must exactly match** one of the strings present in the "clickables" list from the most recent observation.
+ * **Case Sensitivity:** The match must be exact, including capitalization and spacing.
+ * **Validation:** If the value is not in the list, the action is invalid and nothing happens.
+
+## Response Format
+The agent's response must follow this exact two-line structure:
diff --git a/skills/benchmark_skills/webshop/webshop-product-evaluator/SKILL.md b/skills/benchmark_skills/webshop/webshop-product-evaluator/SKILL.md
new file mode 100644
index 0000000..5c48db6
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-product-evaluator/SKILL.md
@@ -0,0 +1,24 @@
+---
+name: webshop-product-evaluator
+description: This skill evaluates product listings against user requirements, such as price limits and feature matches, to identify viable options. It should be triggered when presented with a search results page containing multiple products. The skill analyzes product titles, prices, and brief descriptions to select the most promising candidate for detailed inspection.
+---
+# Instructions
+
+## When to Use
+Activate this skill when you are on a **search results page** in a web shopping environment and need to evaluate multiple products against specific user requirements (e.g., price limits, feature keywords).
+
+## Core Process
+1. **Parse the Observation:** Identify the user's instruction, the list of available products, and their associated details (Title, Price, ASIN/Product ID).
+2. **Extract Requirements:** From the user instruction, identify:
+ * **Price Limit:** The maximum acceptable price (e.g., "lower than 40.00 dollars").
+ * **Feature Keywords:** Key product attributes (e.g., "teeth whitening", "freshens breath").
+3. **Evaluate Products:** For each product listing on the current page:
+ * Check if the price is below the user's limit.
+ * Check if the product title contains the required feature keywords.
+ * Prioritize products that meet all criteria. If multiple products qualify, choose the one that appears most relevant or cost-effective.
+4. **Take Action:**
+ * If a suitable product is found, click on its product ID (e.g., `click[B09NYFDNVX]`) to view its details.
+ * If no suitable product is found on the current page, consider using the `search` action with refined keywords or clicking `Next >` to browse more results.
+
+## Thought Process Format
+Always structure your internal reasoning and final action using this format:
diff --git a/skills/benchmark_skills/webshop/webshop-product-evaluator/references/evaluation_logic.md b/skills/benchmark_skills/webshop/webshop-product-evaluator/references/evaluation_logic.md
new file mode 100644
index 0000000..a2ba8fd
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-product-evaluator/references/evaluation_logic.md
@@ -0,0 +1,28 @@
+# Evaluation Logic Reference
+
+## Parsing Rules for WebShop Observations
+The WebShop environment presents data in a specific text format. Key parsing assumptions:
+1. The observation is split by the `[SEP]` delimiter.
+2. The user's instruction follows the token `Instruction:`.
+3. Product listings typically follow this pattern on a search page:
+ `[ASIN] [Title] [Price]`
+ * **ASIN:** A 10-character alphanumeric identifier, usually starting with 'B' (e.g., `B09NYFDNVX`).
+ * **Title:** The full product name.
+ * **Price:** A string starting with `$` followed by a number (e.g., `$17.99`).
+
+## Requirement Extraction Heuristics
+- **Price Limit:** Look for phrases like "lower than X dollars", "under X", "less than X". Extract the numerical value `X`.
+- **Feature Keywords:** Identify nouns and adjectives describing the desired product features. Common stop words (I, need, some, that, also, and) are filtered out.
+ * *Example:* From "teeth whitening that also freshens breath", keywords become: `['teeth', 'whitening', 'freshens', 'breath']`.
+
+## Product Scoring & Selection
+A product is considered **suitable** if it passes two filters:
+1. **Price Filter:** Product price <= User's price limit.
+2. **Keyword Filter:** The product title contains all extracted feature keywords (case-insensitive).
+
+If multiple products are suitable, they are **sorted by price (ascending)** to prioritize budget-friendly options. The top result is selected for the next action (`click[ASIN]`).
+
+## Fallback Behavior
+If the script finds **no suitable products** on the current page, the skill should guide the agent to:
+1. Consider refining the search query using the `search[new keywords]` action.
+2. Or, if available, navigate to the next page of results (`click[Next >]`).
diff --git a/skills/benchmark_skills/webshop/webshop-product-search/SKILL.md b/skills/benchmark_skills/webshop/webshop-product-search/SKILL.md
new file mode 100644
index 0000000..311e80e
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-product-search/SKILL.md
@@ -0,0 +1,31 @@
+---
+name: webshop-product-search
+description: This skill performs an initial product search using a web interface by generating appropriate search keywords based on interpreted query criteria. It is triggered when starting a product discovery task or when returning to search results. The skill inputs structured search parameters and outputs a list of candidate products from the search results page.
+---
+# Skill: WebShop Product Search
+
+## Primary Function
+Generate a targeted search query and execute it on a web shopping interface to retrieve a list of candidate products that match the user's criteria.
+
+## Core Workflow
+1. **Interpret Criteria:** Analyze the user's instruction to identify key product attributes (e.g., "long clip-in hair extension", "natural looking", "price lower than 40.00 dollars").
+2. **Formulate Query:** Construct a concise, effective search string that prioritizes the most critical attributes. The primary goal is to balance specificity with recall.
+3. **Execute Search:** Use the `search[keywords]` action to submit the query.
+4. **Parse Results:** The skill's success is marked by the system returning a "Page 1" observation containing a list of products (ASINs, titles, prices).
+
+## Key Decision Logic
+* **Query Formulation:** Start with a broad query containing the core product type. If the initial results are poor, the skill may be re-invoked with a more refined query (e.g., adding "synthetic" or "human hair" based on observed results).
+* **Trigger Condition:** This skill is the entry point for a new product discovery task. It is also the correct action when the observation contains "[SEP] Search" or "[SEP] Back to Search", indicating the agent is on a search page.
+* **Output Handoff:** The output of this skill is the search results page. Subsequent skills (e.g., `product-evaluation`) should be used to analyze individual items from this list.
+
+## Error Handling / Edge Cases
+* If no search action is available in the current state, this skill is not applicable.
+* If the observation does not contain a clear search interface prompt, do not use this skill.
+* The search keywords must be a single string enclosed in brackets after `search[`. Do not include multiple actions or extra formatting.
+
+## Example from Trajectory
+**Instruction:** "i need a long clip-in hair extension which is natural looking, and price lower than 40.00 dollars"
+**Skill Execution:**
+1. Criteria identified: `product_type="clip-in hair extension"`, `attribute="long"`, `attribute="natural looking"`, `budget="<40.00"`.
+2. Query formulated: Prioritizes core product type and key attribute -> `"long clip-in hair extension"`.
+3. Action: `search[long clip-in hair extension]`
diff --git a/skills/benchmark_skills/webshop/webshop-product-selector/SKILL.md b/skills/benchmark_skills/webshop/webshop-product-selector/SKILL.md
new file mode 100644
index 0000000..d9e44d7
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-product-selector/SKILL.md
@@ -0,0 +1,17 @@
+---
+name: webshop-product-selector
+description: Selects the most promising product candidate from a filtered shortlist for detailed inspection. Use this skill when multiple items seem viable; it makes a final selection based on a heuristic (e.g., best feature match, lowest price) and triggers the action to navigate to that product's detail page (click[product_id]).
+---
+# Instructions
+Use this skill when you are on a search results page with multiple product options that appear to meet the user's core requirements.
+
+## Decision Process
+1. **Assess the List:** Review the provided observation, which contains a list of products. Each product entry typically includes a Product ID (e.g., `B093C1THVP`), a title, and a price.
+2. **Apply Selection Heuristic:** Use the bundled `selector.py` script to programmatically identify the best candidate. The script implements the following logic:
+ * Filters products strictly under the user's specified maximum price.
+ * Scores remaining products based on keyword matching in the title against the user's core requirements (e.g., "portable", "easy to carry", "double horn").
+ * Selects the product with the highest score. In case of a tie, it chooses the lowest-priced item.
+3. **Execute Action:** The final action is always to click on the selected product's ID to navigate to its detail page for final verification and purchase. The action format is `click[product_id]`.
+
+## Thought Process Template
+Structure your reasoning before acting using this template:
diff --git a/skills/benchmark_skills/webshop/webshop-product-selector/references/action_format.md b/skills/benchmark_skills/webshop/webshop-product-selector/references/action_format.md
new file mode 100644
index 0000000..23389a4
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-product-selector/references/action_format.md
@@ -0,0 +1,28 @@
+# WebShop Action Format Reference
+
+## Valid Action Types
+The WebShop environment accepts two primary action formats:
+
+1. `search[keywords]`
+ * Initiates a product search.
+ * `keywords`: A string of search terms (e.g., `"double horn bluetooth speaker"`).
+
+2. `click[value]`
+ * Clicks on an interactive element on the page.
+ * `value`: Must be an **exact match** of a value present in the current observation's list of available actions.
+ * Common `value` types:
+ * **Product IDs**: Typically a 10-character alphanumeric string (e.g., `b093c1thvp`). Appear in search results.
+ * **UI Elements**: Phrases like `"buy now"`, `"description"`, `"back to search"`, `"next >"`.
+
+## Critical Rule for `click[value]`
+The `value` for a click action **must be copied verbatim** from the observation text. For product IDs, the observation often shows them in uppercase (e.g., `B093C1THVP`), but the clickable action typically expects the lowercase version (e.g., `b093c1thvp`). Always check the format in the trajectory or environment feedback.
+
+## Observation Structure
+Observations are text blocks with `[SEP]` delimiters. Key sections include:
+* **Instruction**: The user's original request.
+* **Page Info**: e.g., `Page 1 (Total results: 50)`.
+* **Product Listings**: Pattern is usually `[SEP] ProductID [SEP] Title [SEP] Price [SEP]`.
+* **Clickable Actions**: A list of available `click[value]` targets at the end of the observation.
+
+## Skill-Specific Guidance
+The `webshop-product-selector` skill outputs a `click[product_id]` action. Ensure the selected `product_id` is present in the current observation before executing.
diff --git a/skills/benchmark_skills/webshop/webshop-purchase-executor/SKILL.md b/skills/benchmark_skills/webshop/webshop-purchase-executor/SKILL.md
new file mode 100644
index 0000000..dedd91c
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-purchase-executor/SKILL.md
@@ -0,0 +1,30 @@
+---
+name: webshop-purchase-executor
+description: This skill executes the purchase action for a confirmed suitable product on an e-commerce page. It is triggered after product verification when the user decision is to buy. The skill clicks the purchase button (e.g., 'Buy Now') to complete the transaction.
+---
+# Skill: webshop-purchase-executor
+
+## Purpose
+Execute the final purchase transaction for a verified product on an e-commerce platform. This skill is the terminal action in a shopping workflow, initiated only after a product has been confirmed to meet the user's criteria (e.g., price, description).
+
+## When to Use
+- **Trigger:** You are on a product detail page.
+- **Prerequisite:** The product has been verified against the user's requirements (e.g., price < $40.00, "natural looking").
+- **User Intent:** The user has made a decision to buy the product.
+- **Available Action:** A purchase button (e.g., "Buy Now") is present in the list of clickable elements.
+
+## Core Action
+Perform a `click` action on the purchase button.
+
+## Execution Logic
+1. **Locate Purchase Button:** Identify the purchase button from the available actions. Common identifiers include:
+ - `buy now`
+ - `add to cart` (if the instruction implies immediate purchase)
+ - `purchase`
+2. **Validate Context:** Ensure you are on a product page and the prior verification step is logically complete.
+3. **Execute Click:** Perform the `click[purchase_button_value]` action using the exact value from the available actions list.
+
+## Important Notes
+- Do not use this skill for browsing, searching, or product comparison.
+- The skill assumes price and specification validation occurred in a previous step.
+- If multiple purchase options exist (e.g., "Buy Now", "Add to Cart & Checkout"), prefer the most direct path to complete the transaction, typically "Buy Now".
diff --git a/skills/benchmark_skills/webshop/webshop-purchase-executor/references/purchase_ui_patterns.md b/skills/benchmark_skills/webshop/webshop-purchase-executor/references/purchase_ui_patterns.md
new file mode 100644
index 0000000..6344e40
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-purchase-executor/references/purchase_ui_patterns.md
@@ -0,0 +1,30 @@
+# Reference: Common E-commerce Purchase UI Patterns
+
+This document catalogs common button text and UI patterns for purchase actions across e-commerce platforms. Use this to improve the robustness of the purchase button detection logic.
+
+## Primary Purchase Buttons
+- **Buy Now**: The most direct purchase action. Often leads to a single-page checkout.
+- **Add to Cart**: Places item in shopping cart. May require a subsequent "Checkout" action.
+- **Purchase**: A generic term, common on some marketplaces.
+- **Checkout**: Typically appears on cart pages or as a combined "Add to Cart & Checkout" button.
+
+## Secondary/Contextual Actions
+- **Subscribe and Save**: For recurring purchases.
+- **Rent Now**: For rental services.
+- **Pre-order**: For items not yet released.
+- **Bid/Buy It Now**: On auction sites.
+
+## Stylistic Variations & Casing
+Buttons may appear in different casings:
+- `Buy Now`
+- `BUY NOW`
+- `buy now`
+- `Add To Cart`
+
+## Localization Examples
+- **French**: `Acheter maintenant`, `Ajouter au panier`
+- **Spanish**: `Comprar ahora`, `Añadir al carrito`
+- **German**: `Jetzt kaufen`, `In den Warenkorb`
+
+## Implementation Note for the Skill
+The `execute_purchase.py` script prioritizes "Buy Now" patterns. If the target platform uses different terminology, the skill's text instructions should guide the agent to identify the correct button based on the specific UI context provided in the observation.
diff --git a/skills/benchmark_skills/webshop/webshop-purchase-initiator/SKILL.md b/skills/benchmark_skills/webshop/webshop-purchase-initiator/SKILL.md
new file mode 100644
index 0000000..493c461
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-purchase-initiator/SKILL.md
@@ -0,0 +1,30 @@
+---
+name: webshop-purchase-initiator
+description: This skill initiates the purchase process by clicking the buy button once a product and its options have been selected and verified against requirements. It should be triggered when all selection criteria are satisfied and the user is ready to proceed to checkout. The skill confirms the final price meets any budget constraints before executing the purchase action.
+---
+# Instructions
+
+## When to Use
+Activate this skill when:
+1. A product has been selected from search results.
+2. All required product options (e.g., size, color, quantity) have been chosen.
+3. The final displayed price has been verified to be within the user's specified budget.
+4. The user's instruction implicitly or explicitly indicates readiness to purchase (e.g., "I need to buy...", "I want this one").
+
+## Core Action
+Execute the `click[buy now]` action to proceed to checkout.
+
+## Verification Logic (Before Clicking)
+Before clicking "Buy Now", you **must** perform these checks:
+1. **Budget Check**: Confirm the final displayed `Price:` is less than the maximum budget specified in the user's original instruction. If no budget is specified, skip this check.
+2. **Option Selection Check**: Ensure the required product options (like 'size', 'color') show a selected state or that your previous action has selected the correct option. The observation should reflect the chosen option.
+3. **Product Match Check**: Verify the product title and description align with the user's core requirements (e.g., "teeth whitening that also freshens breath").
+
+If any check fails, do not use this skill. Instead, revert to selecting the correct option or searching for a different product.
+
+## Trajectory Example
+Refer to `references/trajectory_example.md` for a detailed walkthrough of a successful skill execution.
+
+## Error Handling
+- If the "Buy Now" button is not present in the list of clickable actions, the action will be invalid. Do not force the action.
+- If the price changes after selecting options and exceeds the budget, abort the purchase and inform the user.
diff --git a/skills/benchmark_skills/webshop/webshop-purchase-initiator/references/trajectory_example.md b/skills/benchmark_skills/webshop/webshop-purchase-initiator/references/trajectory_example.md
new file mode 100644
index 0000000..13a6f4d
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-purchase-initiator/references/trajectory_example.md
@@ -0,0 +1,15 @@
+# Example Execution Trajectory
+
+**User Instruction:** "i need some teeth whitening that also freshens breath, and price lower than 40.00 dollars"
+
+**Process:**
+1. **Search:** `search[teeth whitening that also freshens breath]`
+2. **Product Selection:** From the results, `click[B09NYFDNVX]` on a product titled "JUIK Teeth Cleansing Whitening Powder... Keep Freshen Breath".
+3. **Option Selection:** On the product page, choose the desired option (e.g., `click[1pcs]` for size).
+4. **Verification & Purchase (This Skill):**
+ * **Check 1 (Budget):** The displayed `Price: $17.99` is confirmed to be < $40.00. ✅
+ * **Check 2 (Option):** The '1pcs' size was just selected. ✅
+ * **Check 3 (Product Match):** The product title includes "Whitening" and "Freshen Breath". ✅
+ * **Action:** `click[buy now]` is executed to initiate checkout.
+
+**Key Takeaway:** The skill triggers only after the product is fully configured and all constraints are satisfied.
diff --git a/skills/benchmark_skills/webshop/webshop-query-interpreter/SKILL.md b/skills/benchmark_skills/webshop/webshop-query-interpreter/SKILL.md
new file mode 100644
index 0000000..a29ca8b
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-query-interpreter/SKILL.md
@@ -0,0 +1,18 @@
+---
+name: webshop-query-interpreter
+description: This skill interprets a user's shopping query to extract key product requirements such as item type, attributes, and constraints. It should be triggered when a new shopping instruction is received, parsing natural language into structured criteria (e.g., product category, desired features, price limits). The output is a clear set of search parameters for use in subsequent product lookup steps.
+---
+# Instructions
+
+## Trigger
+Activate this skill when a new shopping instruction is received from the user. The instruction will be a natural language request for a product.
+
+## Core Process
+
+1. **Parse the Instruction:** Analyze the user's query to identify the following key components:
+ * **Primary Product Type:** The main item being requested (e.g., "hair extension").
+ * **Key Attributes/Features:** Descriptive requirements (e.g., "long", "clip-in", "natural looking").
+ * **Constraints:** Hard limits, especially price (e.g., "price lower than 40.00 dollars").
+
+2. **Structure the Output:** Format the extracted information into a clear, structured set of search parameters. Use the following template:
+
\ No newline at end of file
diff --git a/skills/benchmark_skills/webshop/webshop-query-interpreter/references/execution_example.md b/skills/benchmark_skills/webshop/webshop-query-interpreter/references/execution_example.md
new file mode 100644
index 0000000..aad61e8
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-query-interpreter/references/execution_example.md
@@ -0,0 +1,7 @@
+# Execution Example from Trajectory
+
+This document shows the original execution trajectory that informed the skill design, demonstrating the end-to-end process from user instruction to structured output.
+
+## Original Interaction
+
+**User Instruction:**
diff --git a/skills/benchmark_skills/webshop/webshop-query-interpreter/references/query_patterns.md b/skills/benchmark_skills/webshop/webshop-query-interpreter/references/query_patterns.md
new file mode 100644
index 0000000..de6d2b2
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-query-interpreter/references/query_patterns.md
@@ -0,0 +1,49 @@
+# Common Query Patterns for Product Search
+
+This reference document catalogs common linguistic patterns found in shopping queries to aid in the development and refinement of the query parser.
+
+## 1. Product Type Indicators
+- **Direct Request:** "I need/want/looking for a [product]"
+- **Imperative:** "Find/show me [product]"
+- **Question:** "Where can I get [product]?" or "Do you have [product]?"
+
+## 2. Attribute & Feature Patterns
+- **Adjective-Noun:** "long hair", "natural looking extensions"
+- **Compound Adjectives:** "clip-in", "heat-resistant", "easy-to-use"
+- **Prepositional Phrases:** "with clips", "made of synthetic hair"
+- **Relative Clauses:** "which is natural looking", "that costs under $40"
+
+## 3. Constraint Patterns (Price Focus)
+- **Explicit Price Limit:**
+ - "price lower/less than [amount]"
+ - "under/below [amount]"
+ - "[amount] or less"
+ - "maximum/minimum [amount]"
+ - "around/about [amount]"
+ - "budget of [amount]"
+
+- **Currency Formats:**
+ - "$40.00"
+ - "40 dollars"
+ - "40 USD"
+ - "forty dollars"
+
+## 4. Common Product Descriptors
+- **Size/Length:** long, short, medium, 16-inch, 22"
+- **Material:** synthetic, human hair, remy, cotton, leather
+- **Color:** black, brown, blonde, red, blue, gradient
+- **Style:** straight, curly, wavy, natural, professional
+- **Quality:** premium, high-quality, durable, authentic
+
+## 5. Ambiguity & Edge Cases
+- **Multiple Products:** "hair extensions and clips" (parse as primary product: hair extensions)
+- **Negation:** "not synthetic" (extract as feature: human hair)
+- **Comparatives:** "cheaper than $50" (constraint: < 50)
+- **Ranges:** "between $30 and $50" (constraint: 50, note as range in features)
+
+## 6. Example Queries for Testing
+1. "find me a wireless mouse under $25"
+2. "I want organic cotton t-shirts that are machine washable"
+3. "looking for a waterproof watch with GPS under $200"
+4. "need a laptop backpack with usb charging port, maximum $60"
+5. "show me running shoes for women, size 8, around $80"
diff --git a/skills/benchmark_skills/webshop/webshop-query-parser/SKILL.md b/skills/benchmark_skills/webshop/webshop-query-parser/SKILL.md
new file mode 100644
index 0000000..003331e
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-query-parser/SKILL.md
@@ -0,0 +1,32 @@
+---
+name: webshop-query-parser
+description: This skill extracts key constraints and product requirements from a user's shopping query. It should be triggered when the agent receives a new shopping instruction, to identify product attributes (e.g., 'gluten free'), price limits (e.g., 'lower than 140.00 dollars'), and other specifications. The skill outputs a structured set of search criteria to guide subsequent product discovery.
+---
+# Instructions
+
+## When to Use
+Activate this skill immediately when a new shopping instruction is received from the user, before any search or click actions are performed.
+
+## Core Task
+Parse the user's natural language instruction to extract structured search criteria. Your goal is to identify:
+1. **Product Type/Name:** The primary item the user wants (e.g., "popcorn").
+2. **Key Attributes:** Descriptive features like "gluten free", "organic", "vegan", etc.
+3. **Price Constraints:** Any upper or lower price limits (e.g., "lower than 140.00 dollars").
+4. **Other Specifications:** Brand, size, quantity, or other qualifying terms.
+
+## Procedure
+1. **Run the Parser:** Execute the bundled script `parse_query.py` on the user's instruction.
+2. **Review & Refine:** Examine the script's output. If the instruction is complex or ambiguous, use your judgment to refine the criteria. For example, ensure price limits are correctly interpreted as numeric ranges.
+3. **Formulate Search Strategy:** Use the extracted criteria to plan the initial web search. Combine the **Product Type** with the most critical **Key Attributes** to form effective initial search keywords.
+ * **Example:** For "i need gluten free popcorn, and price lower than 140.00 dollars", the script will output `{'product': 'popcorn', 'attributes': ['gluten free'], 'price_max': 140.0}`. Your initial search should be `search[gluten free popcorn]`.
+
+## Output
+After parsing, hold the structured criteria in memory. Use it to:
+* Guide the formulation of `search[keywords]` actions.
+* Evaluate product listings and details during `click` actions to check for constraint compliance (especially price).
+* Inform your reasoning in the `Thought:` part of your response.
+
+## Notes
+* Keep the initial search query concise but precise. Prioritize must-have attributes from the user's instruction.
+* The price filter is often not available as a direct web action; you must manually check prices in the search results and product details.
+* If the initial search yields no results, consider broadening the search by removing less critical attributes one at a time, but always respect hard constraints like "gluten free" if specified.
diff --git a/skills/benchmark_skills/webshop/webshop-query-parser/references/query_components.md b/skills/benchmark_skills/webshop/webshop-query-parser/references/query_components.md
new file mode 100644
index 0000000..4bfa3ff
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-query-parser/references/query_components.md
@@ -0,0 +1,43 @@
+# Query Component Reference
+
+This document lists common patterns and components found in WebShop user instructions to aid in parsing and criteria formulation.
+
+## 1. Product Type Indicators
+Look for these phrases followed by the product name:
+* "I need..."
+* "I want..."
+* "I'm looking for..."
+* "Find me..."
+* "Show me..."
+* "Buy..."
+
+## 2. Common Attributes & Keywords
+| Category | Examples |
+| :--- | :--- |
+| **Dietary** | gluten free, vegan, vegetarian, organic, non-gmo, kosher, halal, nut free, dairy free, sugar free, low carb, keto, paleo |
+| **Health** | low calorie, high fiber, low sodium, heart healthy, probiotic, antioxidant |
+| **Quality** | gourmet, premium, luxury, best selling, top rated, award winning |
+| **Form/Packaging** | individual bags, bulk, pack of [number], family size, travel size, reusable container |
+| **Flavor/Type** | original, chocolate, caramel, cheese, butter, spicy, sweet, salted |
+
+## 3. Price Constraint Patterns
+| Pattern | Example | Interpretation |
+| :--- | :--- | :--- |
+| **Upper Limit** | "lower than $X", "less than X dollars", "under X", "below X", "maximum X" | `price_max = X` |
+| **Lower Limit** | "above $X", "more than X", "over X", "minimum X" | `price_min = X` |
+| **Range** | "between X and Y dollars", "X - Y", "from X to Y" | `price_min = X`, `price_max = Y` |
+| **Exact** | "around X", "about X" | Consider `price_max = X * 1.1`, `price_min = X * 0.9` |
+
+## 4. Other Specifications
+* **Brand:** "SkinnyPop", "Kellogg's", "Nike"
+* **Size/Quantity:** "12 pack", "5 ounce", "1 gallon"
+* **Color:** "red", "blue", "black"
+* **Material:** "stainless steel", "cotton", "plastic"
+
+## 5. Search Strategy Tips
+* **Primary Search:** Combine the core `product` with the most critical `attribute` (e.g., `search[gluten free popcorn]`).
+* **Secondary Filters:** If results are poor, relax less critical attributes one by one.
+* **Price Checking:** The website often lacks a price filter action. You must:
+ 1. Scan the price listed next to each search result item.
+ 2. Click into promising items and check the `Price:` field on the product page.
+ 3. Manually reject items that violate the `price_max` or `price_min` constraints.
diff --git a/skills/benchmark_skills/webshop/webshop-result-analyzer/SKILL.md b/skills/benchmark_skills/webshop/webshop-result-analyzer/SKILL.md
new file mode 100644
index 0000000..1a2c5a9
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-result-analyzer/SKILL.md
@@ -0,0 +1,28 @@
+---
+name: webshop-result-analyzer
+description: This skill evaluates a list of search results against the target product criteria. Trigger it when a search result page is observed, to identify promising product listings. It analyzes each result's title, price, and brief description to shortlist items that best match the required attributes (like size, color, and price), outputting a prioritized list of candidate product IDs or links for further inspection.
+---
+# Instructions
+
+Trigger this skill when you observe a search result page (e.g., containing "Page 1 (Total results: 50)" and multiple product listings).
+
+## 1. Extract User Requirements
+First, parse the user's instruction from the observation. Identify the following key attributes:
+- **Product Type:** (e.g., "woman's us size 5 high heel shoe")
+- **Specific Attributes:** (e.g., "rubber sole", "color patent-beige")
+- **Price Constraint:** (e.g., "price lower than 90.00 dollars")
+
+## 2. Analyze Search Results
+For each product listing in the observation (typically formatted as `[ASIN/Product ID] [SEP] [Title] [SEP] [Price Range]`):
+1. Extract the **Product ID** (e.g., B09GXNYJCD).
+2. Extract the **Product Title**.
+3. Extract the **Price**. Convert any range (e.g., "$49.99 to $54.99") to its maximum value for comparison against the budget.
+4. Perform a **textual match** between the title/description and the required attributes (size, color, material like "rubber", product type).
+
+## 3. Score and Prioritize
+Use the bundled Python script `analyze_results.py` to perform a consistent, deterministic analysis.
+1. **Run the script** with the extracted user requirements and the list of product data.
+2. The script will output a **prioritized list** of candidate Product IDs, sorted by a match score.
+
+## 4. Output and Next Action
+Present the analysis in this format:
diff --git a/skills/benchmark_skills/webshop/webshop-result-analyzer/references/attribute_patterns.md b/skills/benchmark_skills/webshop/webshop-result-analyzer/references/attribute_patterns.md
new file mode 100644
index 0000000..6fabc99
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-result-analyzer/references/attribute_patterns.md
@@ -0,0 +1,21 @@
+# Common Attribute Patterns for WebShop Analysis
+
+Use these regular expression patterns to identify key attributes in product titles and descriptions.
+
+## Size Patterns
+- **US Size 5:** `r"\bsize\s*5\b|\b5\s*us\b|\b5\.0\b"`
+- **Size Range (e.g., 5-13):** `r"\b5\s*[-–]\s*13\b"` (will match "5-13", "5 – 13")
+
+## Color & Material Patterns
+- **Patent Beige:** `r"patent-beige|beige.*patent|patent.*beige|beige-almond toe-patent leather"`
+- **Rubber Sole:** `r"rubber\s*sole|sole\s*rubber"`
+
+## Price Extraction
+- **Single Price:** `\$\d+\.?\d*` (e.g., $54.99)
+- **Price Range:** `\$\d+\.?\d*\s*to\s*\$\d+\.?\d*` (e.g., $49.99 to $54.99)
+
+## General Keyword Matching
+When the user provides specific terms (e.g., "high heel", "wedges"), perform a simple case-insensitive substring check. No regex is needed for simple keywords.
+
+## Usage Note
+These patterns are examples. You may need to adjust them based on the observed text formatting in the WebShop environment. The bundled script uses these as configurable inputs.
diff --git a/skills/benchmark_skills/webshop/webshop-result-analyzer/references/execution_example.md b/skills/benchmark_skills/webshop/webshop-result-analyzer/references/execution_example.md
new file mode 100644
index 0000000..dbd0142
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-result-analyzer/references/execution_example.md
@@ -0,0 +1,4 @@
+# Skill Execution Example
+
+## Scenario
+**Observation Excerpt:**
diff --git a/skills/benchmark_skills/webshop/webshop-result-filter/SKILL.md b/skills/benchmark_skills/webshop/webshop-result-filter/SKILL.md
new file mode 100644
index 0000000..43e4b37
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-result-filter/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: webshop-result-filter
+description: This skill filters search results by evaluating product listings against specific user constraints like price, features, or ratings. It should be triggered when reviewing a page of search results to identify items that match all given criteria. The skill takes a list of products with their details and outputs a subset that meets the defined requirements for closer inspection.
+---
+# Skill: webshop-result-filter
+
+## When to Use
+Activate this skill when you are on a search results page in a web shopping environment and need to systematically evaluate which products meet a user's specific, multi-faceted requirements (e.g., "price lower than 40.00 dollars" AND "natural looking").
+
+## Core Instruction
+1. **Parse the Instruction:** Extract the user's constraints from the instruction. Common constraints include:
+ * **Price:** A maximum or target price (e.g., `price lower than 40.00 dollars`).
+ * **Features:** Specific attributes or keywords (e.g., `natural looking`, `long`, `clip-in`).
+ * **Ratings:** A minimum rating threshold (if available in the observation).
+
+2. **Parse the Observation:** Extract the list of products from the search results page. Each product listing typically contains:
+ * A Product ID/ASIN (e.g., `B09C337K8S`).
+ * A Title/Description.
+ * A Price.
+ * A Rating (if available).
+
+3. **Apply Filters:** For each product in the list, check it against **all** extracted user constraints.
+ * **Price Filter:** Compare the product's price to the user's maximum price. Convert prices to numerical values for comparison.
+ * **Keyword/Feature Filter:** Check if the product's title/description contains keywords related to the required features (e.g., "natural").
+ * **Rating Filter:** If a rating constraint exists and the product has a rating, ensure it meets the minimum.
+
+4. **Output Decision:** Identify the **first product** in the filtered list that passes all criteria. This becomes the primary candidate for the next action (`click[product_id]`). If no product passes all filters, you may need to refine the search.
+
+## Example from Trajectory
+* **User Instruction:** `i need a long clip-in hair extension which is natural looking, and price lower than 40.00 dollars`
+* **Extracted Constraints:**
+ * `price < 40.00`
+ * Keywords: `natural` (implied from "natural looking")
+* **Observation (First Page):** Contains ~10 products with IDs, titles, and prices.
+* **Filtering Process:**
+ 1. `B09C337K8S`: Price $29.99 (< $40.00). Title contains "Natural Looking". **PASSES**.
+ 2. `B093BKWHFK`: Price $63.99 (> $40.00). **FAILS** on price.
+ 3. `B099K9Z9L2`: Price $43.99 (> $40.00). **FAILS** on price.
+* **Result:** `B09C337K8S` is selected as the top matching candidate.
+
+## Next Action
+After identifying a matching product, the recommended action is to click on it for more details: `click[<matching_product_id>]`.
+
+For complex filtering logic or to process large result sets, use the bundled script.
diff --git a/skills/benchmark_skills/webshop/webshop-result-filter/references/constraint_extraction_guide.md b/skills/benchmark_skills/webshop/webshop-result-filter/references/constraint_extraction_guide.md
new file mode 100644
index 0000000..b499fa3
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-result-filter/references/constraint_extraction_guide.md
@@ -0,0 +1,36 @@
+# Guide: Extracting Constraints from User Instructions
+
+This guide helps parse natural language shopping instructions into structured filters for the `webshop-result-filter` skill.
+
+## Common Constraint Patterns
+
+### 1. Price Constraints
+* **Maximum Price:** `lower than X dollars`, `under X`, `less than X`, `below X`, `cheaper than X`
+ * Extract: `max_price = X`
+* **Price Range:** `between X and Y dollars`
+ * Extract: `min_price = X`, `max_price = Y`
+* **Exact Price:** `around X dollars`, `about X`
+ * Extract: `target_price = X` (consider a small tolerance, e.g., ±10%)
+
+### 2. Feature/Attribute Constraints
+* **Direct Keywords:** `natural looking`, `long`, `clip-in`, `synthetic`, `human hair`
+ * Extract: Add keyword to `required_keywords` list.
+* **Implied Keywords:** `looks real` → implies `natural`.
+* **Negations:** `not synthetic` → requires checking for the *absence* of a keyword.
+
+### 3. Quality/Rating Constraints
+* **Minimum Rating:** `highly rated`, `well reviewed`, `rated 4 stars or above`
+ * Extract: `min_rating = 4.0` (map phrases to numerical values).
+
+## Parsing Examples
+
+| User Instruction | Extracted Constraints |
+| :--- | :--- |
+| "i need a long clip-in hair extension which is natural looking, and price lower than 40.00 dollars" | `max_price: 40.00`<br>`required_keywords: ["natural", "long", "clip-in"]` |
+| "find a red dress under $50 with good reviews" | `max_price: 50.00`<br>`required_keywords: ["red", "dress"]`<br>`min_rating: 4.0` (assuming "good" = 4+) |
+| "wireless headphones between $100 and $200" | `min_price: 100.00`<br>`max_price: 200.00`<br>`required_keywords: ["wireless", "headphones"]` |
+
+## Implementation Notes
+* Use case-insensitive matching for keywords.
+* Some constraints may be soft (preferences) vs. hard (requirements). This skill focuses on hard requirements.
+* When in doubt, be conservative. If a constraint is ambiguous, it's better to filter it out than to include a non-matching product.
diff --git a/skills/benchmark_skills/webshop/webshop-result-page-navigator/SKILL.md b/skills/benchmark_skills/webshop/webshop-result-page-navigator/SKILL.md
new file mode 100644
index 0000000..91b99b7
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-result-page-navigator/SKILL.md
@@ -0,0 +1,21 @@
+---
+name: webshop-result-page-navigator
+description: Navigates through paginated search results by moving to the next or previous page. Use this skill when the current page of product listings does not contain a suitable match and you need to review more options. It identifies and clicks the appropriate pagination controls (e.g., 'next >' or '< prev') to load additional result pages for evaluation.
+---
+# Skill: WebShop Result Page Navigator
+
+## Purpose
+This skill enables systematic navigation through paginated product search results in a WebShop environment. It is triggered when the current page of results does not contain an item matching the user's criteria, allowing the agent to access more options.
+
+## Core Logic
+1. **Trigger Condition:** The agent has reviewed the current page of product listings and determined that no item satisfies the user's requirements (e.g., price, features).
+2. **Action Selection:** The skill identifies the correct pagination control to click:
+ * `click[next >]` to load the subsequent page of results.
+ * `click[< prev]` to return to the previous page of results.
+3. **Post-Action:** After navigation, the agent should resume its primary task of evaluating the newly loaded product listings against the user's instruction.
+
+## Usage in Trajectory
+The skill was demonstrated when the agent, searching for a pendant light under $120 with a dimmer switch, found no suitable options on Page 1. It correctly executed `click[next >]` to access Page 2, and repeated the action to access Page 3, where a potential match was found.
+
+## Key Principle
+This skill handles the deterministic, repetitive task of page navigation, freeing the agent's reasoning capacity for the higher-freedom task of evaluating product features and making purchase decisions.
diff --git a/skills/benchmark_skills/webshop/webshop-result-page-navigator/references/pagination_controls.md b/skills/benchmark_skills/webshop/webshop-result-page-navigator/references/pagination_controls.md
new file mode 100644
index 0000000..21fe230
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-result-page-navigator/references/pagination_controls.md
@@ -0,0 +1,22 @@
+# Reference: WebShop Pagination Controls
+
+## Context
+This document details the structure and identifiers for pagination elements within the WebShop environment, as observed in the provided trajectory.
+
+## Observed Pagination Format
+Pagination controls appear within the observation text, following the page information header. The format is consistent:
+`[SEP] < Prev [SEP] Next > [SEP]`
+
+## Control Identification
+* **"Next >"**: The control to advance to the next page of results. The exact clickable value is `next >`.
+* **"< Prev"**: The control to return to the previous page of results. The exact clickable value is `< prev`.
+
+## Action Syntax
+The correct action format to use with these controls is:
+* `click[next >]`
+* `click[< prev]`
+
+## Important Notes
+1. These controls are only present when there is a previous or next page to navigate to (e.g., not on Page 1 of 1).
+2. The skill should only be invoked after a conscious evaluation of the current page's contents.
+3. The primary agent logic is responsible for parsing the `Observation` to confirm the presence of these controls before the skill executes.
diff --git a/skills/benchmark_skills/webshop/webshop-search-constructor/SKILL.md b/skills/benchmark_skills/webshop/webshop-search-constructor/SKILL.md
new file mode 100644
index 0000000..544521b
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-search-constructor/SKILL.md
@@ -0,0 +1,23 @@
+---
+name: webshop-search-constructor
+description: This skill formulates an effective search query from structured product criteria. It is used when initiating a product search on an e-commerce platform, converting attributes into a concise, relevant keyword string. The input is a set of parsed criteria (e.g., 'jewelry box', '10 slots', 'easy to clean', 'price < $60'), and the output is a formatted search action string (e.g., 'search[jewelry box, 10 slots, less than $60, easy to clean]') optimized for the platform's search engine.
+---
+# Instructions
+When tasked with finding a product on an e-commerce platform, use this skill to construct the initial search query.
+
+## Core Process
+1. **Receive Criteria:** You will be given a set of structured product criteria (e.g., product type, attributes, price limit).
+2. **Construct Query:** Use the `construct_search_query.py` script to transform the criteria into a single, optimized search string. The script handles formatting and keyword ordering.
+3. **Execute Action:** Format the script's output into the required platform action: `search[<constructed_query>]`.
+
+## Workflow Example
+**Input Criteria:** `{'product': 'jewelry box', 'attributes': ['10 slots', 'easy to clean'], 'price_limit': 60.00}`
+**Skill Execution:**
+1. Run the script: `python scripts/construct_search_query.py --product "jewelry box" --attributes "10 slots" "easy to clean" --price-limit 60.00`
+2. The script returns: `jewelry box, 10 slots, less than $60, easy to clean`
+3. You output the final action: `search[jewelry box, 10 slots, less than $60, easy to clean]`
+
+## Important Notes
+* **Use the Script:** Always delegate query construction to the bundled script. Do not attempt to manually format the search string.
+* **Input Format:** Ensure criteria are passed to the script as discrete arguments (product, list of attributes, price limit). Parse the user's instruction into this structure before calling the script.
+* **Output Format:** The final action must strictly follow the `search[<query>]` syntax.
diff --git a/skills/benchmark_skills/webshop/webshop-search-constructor/references/query_optimization_guide.md b/skills/benchmark_skills/webshop/webshop-search-constructor/references/query_optimization_guide.md
new file mode 100644
index 0000000..41d506b
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-search-constructor/references/query_optimization_guide.md
@@ -0,0 +1,21 @@
+# Query Optimization Guide for E-commerce Search
+
+## Principles
+Effective search queries on platforms like WebShop balance specificity with breadth.
+
+1. **Order Matters:** Place the most critical, distinguishing term first. Typically, this is the product category.
+2. **Conciseness:** Avoid stop words (the, a, an, for). Use commas to separate key concepts, which many search engines interpret as "AND" operators.
+3. **Natural Language Filters:** For price, use phrases like "less than $X" which are commonly parsed by search engines. Avoid complex symbols like `<`.
+4. **Attribute Prioritization:** Include quantifiable attributes (e.g., "10 slots") before qualitative ones (e.g., "easy to clean").
+
+## Example Transformations
+* **Criteria:** `product='laptop', attributes=['16GB RAM', 'lightweight'], price_limit=1200`
+* **Optimized Query:** `laptop, 16GB RAM, lightweight, less than $1200`
+
+* **Criteria:** `product='coffee maker', attributes=['programmable'], price_limit=80.00`
+* **Optimized Query:** `coffee maker, programmable, less than $80.00`
+
+## Platform-Specific Notes
+* The `search[query]` action format is specific to the WebShop environment used in the trajectory.
+* The comma-separated format (`term1, term2, term3`) is a robust pattern that works across many e-commerce search engines.
+* Always verify the available actions in the observation. If `search` is not available, this skill should not be invoked.
diff --git a/skills/benchmark_skills/webshop/webshop-search-executor/SKILL.md b/skills/benchmark_skills/webshop/webshop-search-executor/SKILL.md
new file mode 100644
index 0000000..bb462d1
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-search-executor/SKILL.md
@@ -0,0 +1,14 @@
+---
+name: webshop-search-executor
+description: Executes a search on an e-commerce platform using parsed keywords. Trigger when you need to find products matching specific criteria from a user query. This skill takes structured search terms and performs a search action, returning a list of product results for evaluation.
+---
+# Instructions
+
+## Core Function
+When triggered, this skill executes a product search on a simulated e-commerce platform (WebShop). Your primary goal is to translate a user's product request into an effective search query, execute it, and return the parsed results for further action.
+
+## 1. Trigger Condition
+Activate this skill when the user provides an instruction to find or buy a product with specific attributes (e.g., ingredients, price range, features). The instruction will be provided in the `Observation`.
+
+## 2. Action Protocol
+You must respond using **only** the following two action formats. Your final response must be in the exact structure:
diff --git a/skills/benchmark_skills/webshop/webshop-search-executor/references/action_grammar.md b/skills/benchmark_skills/webshop/webshop-search-executor/references/action_grammar.md
new file mode 100644
index 0000000..f4c2877
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-search-executor/references/action_grammar.md
@@ -0,0 +1,34 @@
+# WebShop Action Grammar Reference
+
+## Overview
+This document defines the strict grammar for interacting with the WebShop environment. Adherence is required for successful execution.
+
+## Action Types
+
+### 1. Search Action
+* **Format:** `search[<keywords>]`
+* **Purpose:** To query the product database.
+* **Construction Rules:**
+ * `<keywords>` is a single string.
+ * Combine the core product name with the most salient modifiers from the user instruction.
+ * **Example:** Instruction: "soft organic cotton socks for men under $20"
+ * **Query:** `search[organic cotton socks for men]`
+
+### 2. Click Action
+* **Format:** `click[<value>]`
+* **Purpose:** To interact with any clickable element on the page.
+* **Value Source:** The `<value>` must be copied **exactly** (including case) from the `Observation` text.
+* **Common Clickable Values:**
+ * **Product IDs:** Listed next to products in search results (e.g., `B09LKXR62L`). Use the **lowercase** version for the action (e.g., `click[b09lkxr62l]`).
+ * **Navigation:** `Back to Search`, `< Prev`, `Next >`.
+ * **Page Elements:** `Description`, `Features`, `Reviews`.
+ * **Primary Action:** `Buy Now`.
+
+## Observation Parsing Guide
+The `Observation` text is structured with `[SEP]` delimiters. Key sections after a search:
+1. `Page X (Total results: Y)` - Pagination info.
+2. `Product_ID` - The clickable identifier for the product.
+3. `Product Title` - The full name/description.
+4. `$Price` - The product price.
+
+**To click on a product, always use its `Product_ID` in lowercase.**
diff --git a/skills/benchmark_skills/webshop/webshop-search-formulator/SKILL.md b/skills/benchmark_skills/webshop/webshop-search-formulator/SKILL.md
new file mode 100644
index 0000000..7b19949
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-search-formulator/SKILL.md
@@ -0,0 +1,28 @@
+---
+name: webshop-search-formulator
+description: This skill generates effective search keywords based on parsed product criteria. It is triggered after query parsing, when the agent needs to perform an initial product search on an e-commerce platform. The skill takes structured attributes (e.g., 'women's size 5 patent-beige high heel') and produces a concise, platform-appropriate search string designed to return relevant results, balancing specificity with recall.
+---
+# Skill: Webshop Search Formulator
+
+## Purpose
+You are an expert at formulating the initial search query for an e-commerce product search. Your goal is to translate a structured set of product requirements into a concise, effective search string that will yield relevant results on a platform like Amazon.
+
+## Core Workflow
+1. **Input:** You receive a parsed query containing key product attributes (e.g., category, type, size, color, material, price limit).
+2. **Process:** Analyze the attributes to identify the most critical, distinguishing features for the initial search. Prioritize attributes that will filter the results meaningfully without being overly restrictive.
+3. **Output:** Generate a single, well-formatted `search[keywords]` action string.
+
+## Key Principles for Search Formulation
+* **Balance Specificity & Recall:** Start with a moderately specific query. Including 2-3 core attributes (e.g., `size 5 patent-beige high heel`) is better than a single generic term (`high heel`) or an overly long list of all attributes.
+* **Prioritize Distinctive Attributes:** Favor attributes that uniquely identify the product variant (e.g., "patent-beige", "size 5") over very common ones (e.g., "women's") in the initial search.
+* **Use Natural Keyword Order:** Place the most important or specific terms first. Mimic how a user might type the query.
+* **Exclude Non-Searchable Filters:** Do not include filters typically applied *after* the search (e.g., price ranges like `< $90`) in the initial keyword string. These are for later refinement.
+* **Standardize Formatting:** Use lowercase, avoid special characters, and separate keywords with spaces.
+
+## Example from Trajectory
+**Parsed Instruction:** `woman's us size 5 high heel shoe with a rubber sole and color patent-beige, and price lower than 90.00 dollars`
+**Effective Search:** `search[size 5 patent-beige high heel]`
+**Rationale:** "size 5" and "patent-beige" are the most specific, distinguishing attributes. "high heel" defines the product type. "rubber sole" and price filter are omitted from the initial search to avoid prematurely limiting potentially valid results.
+
+## Action Format
+Your final output must be a single action in the exact format:
diff --git a/skills/benchmark_skills/webshop/webshop-search-formulator/references/search_strategy_guide.md b/skills/benchmark_skills/webshop/webshop-search-formulator/references/search_strategy_guide.md
new file mode 100644
index 0000000..ca3ba82
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-search-formulator/references/search_strategy_guide.md
@@ -0,0 +1,32 @@
+# Search Strategy Guide for E-commerce Agents
+
+## Attribute Priority Hierarchy
+Use this hierarchy to decide which attributes to include in your initial search string (Higher = More likely to include).
+
+1. **Specific Variant Identifiers:** Exact size, exact color name (e.g., "patent-beige", "midnight blue"), exact model number.
+2. **Product Type/Subcategory:** The core item type (e.g., "high heel", "running shoe", "blender").
+3. **Key Material/Feature:** A primary material or feature if it's central to the request (e.g., "rubber sole", "stainless steel", "wireless"). Omit if it's a common default or likely to be tagged in metadata rather than title.
+4. **Brand or Style:** If the user specifies a brand ("Nike") or style ("wedge").
+5. **Demographic/Generic Descriptors:** Terms like "women's", "men's", "kids". Often implied or can be filtered later; include only if crucial for disambiguation.
+
+## Common Pitfalls & Solutions
+| Pitfall | Example Bad Search | Better Approach | Reason |
+| :--- | :--- | :--- | :--- |
+| **Over-Specification** | `search[women's us size 5 high heel shoe rubber sole patent-beige under $90]` | `search[size 5 patent-beige high heel]` | Long queries often match *fewer* items. Price and secondary features are better used as filters after the search. |
+| **Under-Specification** | `search[high heel shoes]` | `search[beige high heel size 5]` | Returns too many irrelevant results, making navigation inefficient. |
+| **Incorrect Order** | `search[heel high patent beige 5 size]` | `search[size 5 patent-beige high heel]` | Follows natural language query patterns that search engines are optimized for. |
+| **Including Non-Keyword Filters** | `search[high heel price<90]` | `search[high heel]` (then filter by price later) | Search bars typically do not parse operators like `<`. Use the platform's built-in price filter after the search. |
+
+## Platform Assumptions (General E-commerce)
+* **Search Syntax:** Assumes a simple keyword-matching engine. No advanced operators (e.g., `AND`, `OR`, quotes) are guaranteed to work.
+* **Result Ranking:** Results are typically ranked by relevance (keyword match in title/description) and popularity.
+* **Filtering:** Attributes like price, brand, and sometimes specific colors/materials are available as post-search filters (clickable options).
+
+## Workflow Integration
+This skill outputs the `search[keywords]` action. The subsequent agent workflow should be:
+1. Execute the `search` action from this skill.
+2. Observe the search results page.
+3. Use available `click[]` actions to:
+ * Navigate pages (`Next >`).
+ * Select specific products (by ID or name).
+ * Apply filters (size, color, price) that appear on the results page.
diff --git a/skills/benchmark_skills/webshop/webshop-variant-chooser/SKILL.md b/skills/benchmark_skills/webshop/webshop-variant-chooser/SKILL.md
new file mode 100644
index 0000000..40db917
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-variant-chooser/SKILL.md
@@ -0,0 +1,19 @@
+---
+name: webshop-variant-chooser
+description: This skill selects a product variant (e.g., size, quantity) from available options on a product detail page. It is triggered when a product page displays multiple choices, assessing the options (like '1.1 pound (pack of 1)' or 'pack of 2') and selecting one that aligns with user needs, often defaulting to a standard single unit if unspecified.
+---
+# Instructions
+
+## When to Use
+Use this skill when you are on a product detail page and the observation contains a list of variant options (e.g., under a "size" or "quantity" heading). The skill is triggered by the presence of multiple clickable options that represent different configurations of the same product.
+
+## Core Decision Logic
+1. **Parse the Observation:** Identify the list of available variant options from the observation text. These are typically presented as clickable values after a label like "size".
+2. **Assess User Needs:** Review the original user instruction for any explicit or implicit preferences regarding variant (e.g., budget constraints, desired quantity). If no preference is stated, default logic applies.
+3. **Select and Act:** Choose the most appropriate variant and execute a `click[value]` action.
+ * **If user instruction specifies a constraint (e.g., "price lower than 40.00 dollars"):** Ensure the selected variant's price (if displayed) complies.
+ * **If no user preference is stated:** Prefer the standard, single-unit option (e.g., "1.1 pound (pack of 1)" over "pack of 2") as a sensible default.
+ * **If the choice is ambiguous:** You may need to click on a variant to see its updated price/details before finalizing the selection, as shown in the trajectory.
+
+## Action Format
+Your response must strictly follow this format:
diff --git a/skills/benchmark_skills/webshop/webshop-variant-chooser/references/trajectory.md b/skills/benchmark_skills/webshop/webshop-variant-chooser/references/trajectory.md
new file mode 100644
index 0000000..9f1f21c
--- /dev/null
+++ b/skills/benchmark_skills/webshop/webshop-variant-chooser/references/trajectory.md
@@ -0,0 +1,7 @@
+# Execution Trajectory Example
+
+This document contains the exact interaction trajectory that demonstrates the `webshop-variant-chooser` skill.
+
+**Instruction:** i need some kosher sea salt, and price lower than 40.00 dollars
+
+**Observation 1 (Search Results Page):**