zjunlp/SkillNet

# 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.

## Workflow
1. **Identify the Target Appliance:** Determine which appliance is required for the task. Map the action to the appliance: `heat` -> microwave/stoveburner, `cool` -> fridge, `clean` -> sinkbasin.
2. **Locate the Appliance:** Scan the environment observation for the target appliance (e.g., `microwave 1`, `fridge 1`, `sinkbasin 1`).
3. **Navigate:** Execute `go to {appliance}` 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 `open {appliance}` before proceeding.

## Example

**Scenario:** You are holding `potato 1` and need to heat it.

```
Thought: I need to heat this potato. The microwave is the appropriate appliance.

# 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.").

# Instructions

Clean an object you are holding using a sinkbasin. The object must be in your inventory before cleaning.

## Workflow
1. **Navigate:** `go to sinkbasin 1` (or the appropriate sinkbasin in the environment)
2. **Clean:** `clean {object} with sinkbasin 1` -- verify observation confirms "You clean the {object}"
3. **Proceed:** The object is now clean. Continue with the next task step

## Action Format
- `clean {obj} with {recep}` (e.g., `clean potato 1 with sinkbasin 1`)

## Error Recovery
- "Nothing happened": Check (1) you are holding the object, (2) you are at the sinkbasin, (3) object and receptacle names are correct
- Not at sinkbasin: execute `go to sinkbasin 1` first

# 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).

# 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`).

# 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.

# 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.

# 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" = 2)
  - **Target receptacle** (e.g., "bed 1")

# 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.

# 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.

# 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

# 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.

# 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.

# Instructions

Heat an object you are holding using a compatible heating appliance (microwave or stoveburner).

## Prerequisites
- The target object must be in your inventory
- A heating appliance (microwave, stoveburner) must exist in the environment

## Workflow
1. **Navigate:** `go to {appliance}` (e.g., `go to microwave 1`)
2. **Check state:** If observation says appliance is closed, execute `open {appliance}` -- verify observation confirms it is now open
3. **Heat:** `heat {object} with {appliance}` -- verify observation confirms "You heat the {object}"
4. **(Optional) Place:** If the task requires it, navigate to the destination and place the heated object

## Action Format

# Skill: Object Locator for ALFWorld

## When to Use
Trigger this skill when:
1. Your goal requires a specific object (e.g., `knife`, `cellphone`, `apple`)
2. The object is not in your inventory
3. The current observation does not explicitly state the object's location

## Core Workflow

### 1. Parse the Environment
Extract all visible receptacles from the observation text. Typical ALFWorld receptacles include:
- **Surfaces**: countertop, desk, dresser, bed, shelf, sidetable, coffeetable, diningtable
- **Containers**: drawer, cabinet, safe, fridge, microwave, garbagecan
- **Appliances**: sinkbasin, bathtub, stoveburner, toaster

# 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}").

# 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.

# 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:

# Instructions

Inspect the state or contents of a target receptacle by navigating to it and parsing the environment's observation feedback.

## Workflow
1. **Navigate:** Execute `go to {target_receptacle}`
2. **Read observation:** The environment automatically reports what is on/in the receptacle -- no additional inspection action is needed
3. **Parse contents:** Look for patterns:
   - `"On the {receptacle}, you see nothing."` -- receptacle is empty
   - `"On the {receptacle}, you see a {item1}, and a {item2}."` -- items are present
4. **Decide next action** based on the observation:
   - Empty: search elsewhere for the needed item
   - Item found: `take {item} from {receptacle}`
   - Wrong items: move on to the next receptacle

# Instructions

Change an object's state (cool, heat, or clean) using a household appliance. You must be holding the target object before executing the state change.

## Workflow
1. **Navigate to appliance:** `go to {appliance}` (e.g., `go to fridge 1`)
2. **Prepare if closed:** If observation says appliance is closed, execute `open {appliance}` -- verify it opens
3. **Execute state change:** `{action} {obj} with {appliance}` -- verify observation confirms the change
4. **Proceed:** Continue with the next task step (e.g., placing the modified object)

## Action Mapping
| State Change | Action | Typical Appliance |
|---|---|---|
| Cool | `cool {obj} with {appliance}` | `fridge 1` |
| Heat | `heat {obj} with {appliance}` | `microwave 1`, `stoveburner 1` |

# Skill: Object Storer

## When to Use
Trigger this skill when:
1. The agent is holding the target object (optionally cleaned/heated/cooled as required)
2. A suitable storage receptacle has been identified
3. The agent needs to execute the final placement step

## Core Workflow

### 1. Validate Prerequisites
- Confirm the agent is holding `{object_name}` (check inventory)
- Confirm the agent is at the location of `{target_receptacle}`
- If not at the receptacle, navigate there first: `go to {target_receptacle}`

# Instructions

Pick up an object from its current location and transport it to a destination receptacle.

## Workflow
1. **Navigate to source:** `go to {source_receptacle}` -- verify observation shows the target object
2. **Pick up:** `take {object} from {source_receptacle}` -- verify "You pick up" confirmation
3. **Navigate to destination:** `go to {destination_receptacle}`
4. **Place:** `put {object} in/on {destination_receptacle}` -- verify "You put" confirmation

## Action Format
- `go to {receptacle}`
- `take {object} from {receptacle}`
- `put {object} in/on {receptacle}`

# 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").

# 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`

# 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`).

# 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).

# 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.`

# 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`)

# 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.

# 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`).

# Instructions

For each candidate receptacle in order, execute this action sequence:

## Workflow
1. **Navigate:** `go to {receptacle}`
2. **Open if closed:** If observation says "{receptacle} is closed", execute `open {receptacle}`
3. **Inspect:** Read the observation for the target object name
4. **If found:** Execute `take {target_object} from {receptacle}` and stop searching
5. **If not found:** If you opened the receptacle, execute `close {receptacle}`, then continue to the next candidate
6. **If all exhausted:** Report that the target was not found in any candidate location

## Action Format
- `go to {receptacle}` -- navigate to a location
- `open {receptacle}` -- open a closed drawer/cabinet/fridge

# 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`.

# 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:

# Skill: Task Verifier for ALFWorld

## When to Use
Trigger this skill when:
1. The agent has just completed a key sub-action (e.g., `put {obj} in/on {recep}`)
2. The agent needs to determine whether the overall task goal is satisfied
3. The agent must decide whether to continue searching or conclude the task

## Core Workflow

### 1. Parse the Task Goal
Extract from the original task description:
- **Target object(s)**: What needs to be found/placed (including quantity)
- **Target receptacle**: Where objects must end up
- **Required transformations**: Any cleaning, heating, or cooling steps

# 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}`.

# Instructions

Locate a specified tool or device by systematically checking receptacles where it is likely stored.

## Workflow
1. **Prioritize search locations** based on tool type:
   - Small tools/electronics (desklamp, remotecontrol): `sidetable`, `desk`, `drawer`, `shelf`
   - Kitchen tools (knife, spatula): `countertop`, `cabinet`, `drawer`
   - Cleaning tools (sponge, spraybottle): `shelf`, `cabinet`, `countertop`
   - Default: check all visible receptacles in order
2. **Navigate** to each prioritized receptacle: `go to {receptacle}`
3. **Inspect** the observation for the target tool name
4. **If found:** Stop searching. Proceed to use the tool for the main task
5. **If not found:** Continue to the next receptacle in the priority list
6. **If exhausted:** Expand search to remaining receptacles not yet checked

# Skill: Tool User for ALFWorld

## When to Use
Trigger this skill when:
1. A task requires applying a tool to an object (e.g., cleaning a knife with a sinkbasin, heating food with a microwave)
2. Both the tool and target object are in the agent's possession or within reach
3. The agent knows which interaction verb to use for the task context

## Core Workflow

### 1. Identify Requirements
- Parse the task to determine:
  - **Target object**: The item to be acted upon (e.g., `knife 1`, `potato 2`)
  - **Required tool**: The appliance or instrument needed (e.g., `sinkbasin 1`, `microwave 1`)
  - **Interaction type**: The action verb (`clean`, `heat`, `cool`, `use`, `examine`)

# Skill: scienceworld-ambiguous-action-resolution

## Purpose

Resolve system disambiguation prompts that block task progression when the ScienceWorld environment cannot determine which identical object instance the agent intends to act upon. This is a mechanical bypass, not a decision-making step.

## When to Use

- When the environment returns an observation containing `"Ambiguous request: Please enter the number for the action you intended (or blank to cancel):"` followed by a numbered list
- When multiple identical object instances exist (e.g., five identical banana seeds in a jar) and the system requires explicit selection
- Only when options are functionally identical -- do NOT use this skill for menu selections where options have different meanings

## Workflow

1. **Recognize the prompt** -- Identify the exact phrase: `"Ambiguous request: Please enter the number for the action you intended (or blank to cancel):"`.

# Skill: scienceworld-animal-identifier

## Purpose

Locate and focus on a specified animal or biological entity within the ScienceWorld environment for tasks involving animal comparison, examination, or interaction (e.g., determining lifespan extremes, identifying species).

## When to Use

- When a task requires finding and focusing on a specific animal or biological entity
- When comparing attributes (lifespan, size, type) across multiple animals
- When the task instructs examining or interacting with an animal in a specific location

## Workflow

1. **Navigate to the target location** -- If the animal is in a specific room (e.g., "outside", "greenhouse"), execute `teleport to <LOCATION>`.

# 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.

# 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>`.

# 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").

# Conditional Focus Executor

## When to Use
Use after completing a measurement (temperature, pH, mass) when the task specifies a conditional rule like "If result > X, focus on A; otherwise, focus on B."

## Procedure
1. **Evaluate the condition** against your measurement result.
2. **Determine the target object** based on which branch is true.
3. **Execute:** `focus on <TARGET_OBJECT>`
4. **Verify:** Confirm the focus action succeeded before proceeding.

If the focus action fails (e.g., object not found), use `look around` to verify the target object name matches exactly.

## Example
**Task:** "If the temperature of the substance is above 50C, focus on the red box. Otherwise, focus on the blue box."

# Skill: Conditional Object Placer

## Purpose
Place a target object into the correct container based on a measured condition (e.g., temperature threshold, conductivity result). This skill executes the full measure-then-sort workflow.

## Core Workflow
1. **Locate & Acquire Measurement Tool:** `teleport to LOC` then `pick up` the measurement device (e.g., thermometer).
2. **Locate & Acquire Target Object:** `teleport to LOC` then `pick up` the object to be measured (e.g., metal fork).
3. **Identify Target Containers:** Use `look around` to find the designated containers (e.g., blue box, orange box).
4. **Perform Measurement:** `use OBJ on OBJ` (e.g., `use thermometer on metal fork`) to obtain the value.
5. **Evaluate Condition & Place:** Compare the measured value against the threshold, then `move OBJ to OBJ` to place the object in the correct container.

## Key Actions
| Action | Purpose |
|--------|---------|

# 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.

# Skill: Container/Device Inspector

## 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:

# 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.

# Skill: Container Relocator

## Procedure
1. Confirm the object is in your inventory. If not, acquire it first.
2. `teleport to <ROOM>` — navigate to the room containing the target container.
3. `move <OBJECT> to <CONTAINER>` — transfer the object to the destination.
4. `look at <CONTAINER>` — verify the object is now inside.

## 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`

# Skill: Container Transfer

## Purpose
Transfer a target substance or object from a source container to a destination container. This is a foundational step for preparing materials for heating, mixing, or measurement.

## Core Workflow
1. **Assess Need:** Determine if the current container is unsuitable for the next operation (e.g., tin cup is not heat-resistant for a furnace).
2. **Locate Items:** Use `look around` and `look at OBJ` to find the target substance and a suitable destination container.
3. **Execute Transfer:** `move <SUBSTANCE> to <DESTINATION>`.
4. **Verify:** `look at <DESTINATION>` to confirm the substance is now inside.

## Key Actions
| Action | Purpose |
|--------|---------|
| `look around` | Survey room for containers and substances |

# Skill: Controlled Waiting

## When to Use
After initiating a process with a time delay, when no other productive actions are possible.

## Procedure
1. Confirm the process is active (seeds planted, device activated, etc.).
2. `wait` (advances 10 steps) for long processes, or `wait1` (1 step) for fine-grained observation.
3. `look around` or `examine <OBJECT>` to check if the target state has been reached.
4. If not reached, repeat steps 2-3. If reached, exit and resume the main task.

**Duration guidance:** Use `wait` for biological growth stages. Use `wait1` when observing rapid changes or when close to the expected transition.

## Example
**Task:** Wait for a banana tree to produce fruit after planting.

# Skill: Device Activator

## Purpose
Activate a device (turn it on, start it, fire it up) to begin its operation — typically heating, processing, or powering a task step.

## Core Workflow
1. **Verify Contents:** `look at <DEVICE_NAME>` to confirm materials are placed inside.
2. **Check State:** Observation should show "which is turned off" or "which is deactivated."
3. **Activate:** `activate <DEVICE_NAME>`
4. **Verify Activation:** `look at <DEVICE_NAME>` — confirm it now reads "turned on" or "activated."
5. **Monitor (if needed):** Use measurement tools (e.g., `use thermometer on <MATERIAL>`) to track progress.
6. **Deactivate When Done:** `deactivate <DEVICE_NAME>`

## Key Actions
| Action | Purpose |

# 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.

# 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

# 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`).

# 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.

# Skill: Instruction Reader

## Purpose
Read and parse a document (recipe, note, or instructions) from your inventory to extract the information needed to execute the current task.

## When to Use
- After picking up a recipe, note, or readable document.
- When the task requires following written instructions (e.g., mixing chemicals, assembling components).
- Before starting a multi-step procedure that depends on written directions.

## Core Workflow
1. **Read the Document:** `read OBJ` on the document in your inventory.
2. **Extract Key Information:**
   - **Goal:** The final product or objective (e.g., "make salt water").
   - **Required Components:** Items or substances needed (e.g., "sodium chloride, water").

# Skill: scienceworld-inventory-focus

## Purpose

Confirm and prepare an inventory item before using it in a ScienceWorld task. The `focus on [ITEM] in inventory` action verifies the item's presence and signals intent, reducing errors in multi-step experimental procedures.

## When to Use

- After picking up an item that will be used in a subsequent critical action (measurement, combination, connection)
- When verifying the correct object has been collected before proceeding
- Before using a tool on a target object, to prepare both tool and target

## Workflow

1. **Acquire the item** -- Ensure the target item is in inventory (e.g., `pick up thermometer`).

# Skill: Inventory Manager

## Purpose
Manage the agent's inventory: pick up objects from the environment or place them into containers.

## Core Workflow
1. **Locate Object:** Use `look around` to confirm the object is present and note its exact name.
2. **Acquire:** `pick up OBJ` to move the object into your inventory.
3. **Place (if needed):** `move OBJ to OBJ` to transfer the object to a container.
4. **Verify:** Check the observation feedback to confirm the action succeeded. If it fails, verify exact object names with `look around`.

## Key Actions
| Action | Purpose |
|--------|---------|
| `look around` | Find objects and confirm names |

# 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.

# 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>`

# Skill: Liquid Pourer

## Purpose
Transfer a liquid from a source container to a target container, typically as a preparatory step for mixing or chemical combination.

## When to Use
- Combining multiple liquids or substances into one vessel for mixing.
- Moving a liquid to a more suitable container before heating or processing.
- Preparing ingredients for a recipe that requires pouring.

## Core Workflow
1. **Identify Containers:** Use `look around` to locate the source container (with the liquid) and the target container (destination vessel).
2. **Perform Transfer:** `pour OBJ into OBJ` with precise object identifiers.
3. **Verify:** `look at OBJ` on the target container to confirm the transfer succeeded.

# 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:**

# Skill: Living Entity Identifier

## Purpose
Identify living things (eggs, plants, animals) from room observations and focus on them for task progression.

## Core Workflow
1. **Survey Room:** `look around` to get the observation text listing all objects.
2. **Identify Candidates:** Scan the object list for living entity indicators:
   - **Animals:** dove, giant tortoise, bee, frog, fish
   - **Eggs:** dove egg, chicken egg, turtle egg
   - **Plants:** flower, tree, moss, fern, algae
   - **Other biological:** mushroom, seed, pollen
3. **Focus on Target:** `focus on [IDENTIFIED_OBJECT]` to signal task progress.
4. **Transport (if needed):** `pick up [OBJECT]` then `move [OBJECT] to [CONTAINER]`.

# Material Classification Skill

## When to Use
Activate when direct experimental testing of a material property (conductivity, magnetism, etc.) fails or equipment is unavailable, and you need to classify the material by inference to complete a sorting task.

## Procedure
1. `focus on <OBJECT>` — identify the target and note its material composition.
2. Attempt direct testing if equipment exists (e.g., `connect <OBJECT> terminal 1 to <WIRE> terminal 2`).
3. If testing fails, infer the property from the object's material. Consult `references/material_properties.md` for lookup.
4. `move <OBJECT> to <CONTAINER>` — place in the appropriate classification container.
5. `look at <CONTAINER>` — verify the object was placed correctly.

## Example
**Task:** Classify a glass jar for electrical conductivity when the circuit test is unavailable.
1. `focus on glass jar`

# Skill: scienceworld-measurement-taker

## Purpose

Measure a quantitative property of a target object or substance in the ScienceWorld environment using the appropriate measurement tool, then interpret the result for subsequent decision-making.

## When to Use

- When a task requires obtaining a numerical reading (temperature, weight, pH) from an object or substance
- When a measured value determines a conditional next action (e.g., classify based on temperature threshold)
- When the agent needs to compare properties across multiple objects

## Workflow

1. **Identify and acquire the tool** -- Locate the correct measurement instrument (e.g., thermometer, scale) and `pick up` the tool.

# Skill: Chemical Mixture Creator

## When to Use
All required ingredients are confirmed inside a single container and you need to combine them into a new substance.

## Procedure
1. `examine <CONTAINER>` — verify all required ingredients are present.
2. `mix <CONTAINER>` — the environment processes the chemistry and produces the result.
3. `examine <CONTAINER>` or `focus on <NEW_SUBSTANCE>` — confirm the synthesis succeeded.

Do not `mix` unless the container holds the exact ingredients required by the recipe.
## Example
**Task:** Create salt water by mixing sodium chloride and water.
1. `examine glass cup` — observe: "containing water, sodium chloride"
2. `mix glass cup`

# 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`

# 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 ...`).

# 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.

# Skill: Object Placer

## Purpose
Move an object into the correct container based on a prior classification or assessment result. This is the final step in conditional sorting workflows.

## Core Workflow
1. **Confirm Assessment Result:** Know which container corresponds to which classification (e.g., "blue box" = conductive, "orange box" = non-conductive).
2. **Acquire Object (if needed):** `pick up OBJ` if the target is not already in inventory.
3. **Execute Placement:** `move OBJ to OBJ` — place the object in the correct container.
4. **Verify Placement:** `look at <CONTAINER>` to confirm the object is now inside.

## Key Actions
| Action | Purpose |
|--------|---------|
| `pick up OBJ` | Acquire object if not in inventory |

# Skill: Object Retriever

## Purpose
Acquire a target object from the environment and place it into your inventory for further use.

## When to Use
- You need an object for testing, measuring, or transporting.
- The object is visible in the room but not yet in your inventory.
- A downstream skill (e.g., tool-user, object-placer) requires the object in inventory.

## Core Workflow
1. **Navigate:** `teleport to LOC` if needed to reach the room containing the object.
2. **Survey:** `look around` to confirm the object is present and identify its exact name.
3. **Acquire:** `pick up OBJ` using the exact name from the environment description.
4. **Verify:** Check the observation feedback confirms "You move the [object] to the inventory."

# Skill: scienceworld-object-selector

## Purpose

Identify and select the correct object from visible candidates in the ScienceWorld environment based on task-defined criteria (e.g., "non-living thing", "electrical component", "container"), then signal intent with a `focus on` action.

## When to Use

- When a task requires choosing a specific type of object from multiple visible options
- When the agent must classify objects by property (living/non-living, material type, function) to select one
- When the task instructs finding and interacting with a particular category of object

## Workflow

1. **Survey the environment** -- Use `look around` to list all visible objects in the current location.

# 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.

# 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.

# 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:

# Process Monitoring Protocol

## When to Use
Activate when an apparatus (stove, burner) is active and you need to check whether a substance has undergone a state change (e.g., solid to liquid, liquid to gas).

## Procedure
1. `look at <APPARATUS>` — verify it is active and contains the target substance.
   - If apparatus is not active, use `activate <APPARATUS>` first.
   - If substance is missing, check inventory or nearby containers.
2. `examine <SUBSTANCE>` — check its current state description.
3. Compare the observed state to the previous state. If changed (e.g., "chocolate" to "liquid chocolate"), proceed to the next task step.
4. If no change, use `wait` then repeat from step 1.

Run every few steps during an active process. This skill only observes — it does not modify the apparatus or handle substances.

# 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

# 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.

# 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

# 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

# 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

# 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.

# 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.

# 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").

# 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]`.

# 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).

# 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:"

# 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.

## Procedure

1. Classify the target object by type.
2. Map to the most probable room using these heuristics:
   | Object Type | Likely Room(s) |
   |-------------|---------------|
   | animal | outside, garden |
   | tool/wire/battery | workshop |
   | food/cooking item | kitchen |
   | chemical/substance | lab, foundry |
   | plant/seed | garden, greenhouse |

# Skill: scienceworld-task-focuser

## Purpose

Formally declare intent to interact with a specific object in the ScienceWorld environment. The `focus on` action is a required preparatory step that signals to the system which object subsequent actions (`use`, `measure`, `connect`) will target, often unlocking necessary state changes or measurement capabilities.

## When to Use

- Before using a measurement tool (e.g., thermometer) on a target object
- Before complex operations such as connecting, mixing, or combining objects
- When a task description explicitly instructs "focus on" an object
- To confirm the correct item is in inventory before proceeding with an action

## Workflow

# 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]`).

# 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`.

# 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).

# Skill: scienceworld-threshold-evaluator

## Purpose

Compare a measured numerical value against a predefined threshold to determine which of two conditional actions to execute. This is the decision-making step that immediately follows a measurement in ScienceWorld experimental workflows.

## When to Use

- Immediately after obtaining a numerical measurement (e.g., temperature reading from a thermometer)
- When the task includes a conditional instruction like "if above X, do A; if below X, do B"
- When classifying or sorting objects based on measured properties

## Workflow

1. **Extract the measurement** -- Parse the numerical value from the observation (e.g., `"the thermometer measures a temperature of 56 degrees celsius"` yields `56`).

# 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`).

# Skill: Tool User

## Purpose
Perform a physical action on the environment using a tool from your inventory. The core action is `use TOOL on TARGET`.

## When to Use
- A task requires modifying the environment (digging, cutting, heating).
- You need to measure a property of an object (temperature, conductivity).
- A tool-based interaction is the next step in your experiment workflow.

## Core Workflow
1. **Ensure Tool in Inventory:** The required tool (e.g., `shovel`, `thermometer`, `axe`) must be in your inventory. Use `pick up OBJ` if it is not.
2. **Identify Target:** Determine the exact target object or location name (e.g., `ground`, `tree`, `metal fork`).
3. **Execute:** `use TOOL on TARGET`.
4. **Interpret Result:** Read the observation output to determine the outcome (e.g., temperature reading, state change).

# Skill: scienceworld-tool-validator

## Purpose

Perform a pre-use functionality check on a tool or instrument to confirm it is operational before employing it in a critical ScienceWorld task step such as measurement, activation, or connection.

## When to Use

- Immediately after acquiring a tool (e.g., `pick up thermometer`) and before its first use
- When switching to a different tool mid-task and needing to confirm readiness
- When resuming a task after navigation and needing to re-confirm tool availability

## Workflow

1. **Acquire the tool** -- Ensure the target tool is in inventory. If not, locate it with `look around` and retrieve it with `pick up [TOOL]`.

# 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.

# Skill: Task Completion Focus

## When to Use
The final required object (e.g., grown banana, crafted item) is visibly present and you need to formally signal task completion. Do not use for intermediate steps.

## Procedure
1. `look around` — confirm the target object is visible in the scene.
2. `focus on <OBJECT>` — signal task completion.
3. **Ambiguity handling:** If the environment returns "Ambiguous request" with numbered options, respond with the option number (e.g., `0`) for the target most directly associated with your task goal.

## Example
**Task:** "Grow a banana." After successful cultivation:
1. `look around` — observation: "On the banana tree you see: a banana, a flower."
2. `focus on banana on banana tree`
3. If ambiguous prompt appears listing multiple bananas, select `0` (first instance).

# 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:
    

# 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.

# 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.

## Input

You receive an **Observation** containing:
- The original user instruction (e.g., "find a black leather wallet, price lower than 40.00 dollars")
- Product details: Title, Price, Rating
- Available options (e.g., color buttons like "black", "brown")
- Available actions (e.g., "Buy Now", "Back to Search", "Description")

## Core Workflow

# 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.

# 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.

# 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.

# 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**

# 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.

# 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.

# 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:**