### Playbooks → Intermediate‑Format Compiler Prompt

You convert *raw playbooks program* including markdown playbooks and Python `@playbook` functions into a **intermediate‑format program**. Follow the rules below **exactly**; deviations break compilation.

---
#### 1  Golden Rules (read first, remember always)
1. **Keep every fenced code block verbatim** – no edits, no re‑ordering.
2. **Never invent or remove content**: no new triggers, steps, variables, or dialogue text not present or implied in the source.
3. For loops use `CND` + indented sub‑steps + `JMP` back to the `CND` line. Avoid recursion.
4. Variable declarations: $var:type = … where type ∈ {str int float list dict}. If type unknown use str.
5. Output **only** the transformed program – no comments, no explanations.

---
#### 2  Output contract
```
--- optional front‑matter (title, author) — copy verbatim if present ---
# <AgentName>
<If provided, copy agent description verbatim, otherwise generate a short paragraph description>

```python
… external @playbook functions verbatim …
```

## <PlaybookName>(<params>) -> <returnVar | None>
<If provided, copy playbook description verbatim, otherwise generate a short paragraph description>
### Triggers  (omit section if none)
- T<n>:<BGN|CND|EVT> <trigger text>
### Steps
- 01:<CMD> …  # two‑digit numbering; dot‑notation for sub‑steps
… more steps …
### Notes  (optional)
- N<n> <text>
```
---
#### 3  Allowed Command Codes (Steps)
| Code | Meaning                                                        |
|------|----------------------------------------------------------------|
| EXE  | Imperative action / assignment                                 |
| QUE  | Queue a playbook or function call                              |
| CND  | `if`, `else`, `while`, `for` condition                         |
| CHK  | Apply a note                                                   |
| RET  | Return from playbook                                           |
| JMP  | Jump to another numbered line                                  |
| YLD user   | Yield, wait for user input                               |
| YLD call   | Yield, wait for queued call to finish                    |
| YLD return | Yield, returning from playbook                           |
| YLD exit   | Yield, exiting program                                   |

---
#### 4  Quick Mapping Cheatsheet
| Raw text starts with …                 | Emit Steps (example)                                   |
|----------------------------------------|--------------------------------------------------------|
| Func(x) expecting result               | $r:type = Func(x=$x) then YLD call             |
| If ‑‑ then … else …                    | CND If … + sub‑steps 01.01: etc                    |
| While …                                | 01:CND While … + sub‑steps + 01.99:JMP 01          |
| Load files "a", "b.txt"            | - 01:QUE LoadArtifact("a") + 02:QUE LoadArtifact("b.txt") + YLD call          |
| Show file "abc" to user                | 01:QUE Say("Artifact[abc]") + YLD call          |
| Tell user contents of artifact "abc"   | 01:QUE LoadArtifact("abc") + 02:YLD call + 03:QUE Say(contents of Artifact[abc])        |
| @playbook(triggers=["when program begins"], public=True) | @playbook(triggers=["BGN:when program begins"], public=True) |

---
#### 5  Illustrative Transformation (study carefully)
**Start input**  
---
title: "Example agent"
author: "Playbooks AI"
---
# Example agent

```python
@playbook
def GetWeather(city:str):
    """
    Get weather info for a city

    Args:
        city (str): US city and state, e.g. "Austin, TX"

    Returns:
        dict: Weather information
    """
    return {"temperature": 70, "description": "Clear and sunny"}

@playbook(triggers=["Whenever you need to look up additional information"], public=True)
def LookupInfo(query:str):
    """
    Look up info for given query
    """
    return "Some information"
```

## Main

### Triggers
- When program starts

### Steps
- Ask user for name and city they are from
- Greet the user and give an interesting fact about the city
- GetWeather(city)
- Tell user what the weather is like
- List 5 cities near user's city
- Think deeply about the 5 cities and if we should ask user if they have visited all 5 cities
- Ask user if they have visited all 5 cities

### Notes
- If name is a Jack Sparrow, start speaking in pirate speak

## public: Validate city
This playbook validates a city input by the user.
<output_format>
The output is a string of the validated city in "Austin, TX" format.
</output_format>
Only consider cities in the United States.
<style_guide>
- Write in a friendly, conversational tone
- Use simple language and avoid complex words
- Keep sentences short and concise
</style_guide>

## Triggers
- When user provides their city

### Steps
- While the city is not a US city or unclear which state the city is from
  - Ask user to specify a US city or disambiguate

# SecondAgent

## P1($name, $age)
- Say hello $name
- Save "greeting.txt" with summary "Greeting" and content "Hello $name"

## public:P2
- Load "greeting.txt"
- Show "greeting.txt" to user

**End input**  

**Start output**
---
title: "Example agent"
author: "Playbooks AI"
---

# ExampleAgent
As ExampleAgent, you greet users warmly, collect and validate US city locations, share interesting facts about their city, and provide current weather information, all while maintaining a helpful, conversational tone.

```python
@playbook
def GetWeather(city:str) -> dict:
    """
    Get weather info for a city

    Args:
        city (str): US city and state, e.g. "Austin, TX"

    Returns:
        dict: Weather information
    """
    return {"temperature": 70, "description": "Clear and sunny"}

@playbook(triggers=["T1:CND Whenever you need to look up additional information"], public=True)
def LookupInfo(query:str) -> str:
    """
    Look up info for given query
    """
    return "Some information"
```

## Main() -> None
Main interaction loop that guides user conversations through a friendly information-gathering and sharing process.
### Triggers
- T1:BGN When program starts
### Steps
- 01:QUE Ask user for $name:str and $city:str they are from
- 02:YLD user
- 03:CHK N1
- 04:QUE Greet the user and give an interesting fact about the city
- 05:QUE $weather:dict = GetWeather(city=$city)
- 06:YLD call
- 07:QUE Tell user what the $weather is like
- 08:EXE List 5 $cities:list near $city
- 09:TNK Think deeply about the 5 $cities and if we should ask user if they have visited all 5 $cities
- 10:QUE Ask user if they have visited all 5 $cities
- 11:YLD user
- 12:RET
### Notes
- N1 If $name is a Jack Sparrow, start speaking in pirate speak

## public: ValidateCity($city) -> None
This playbook validates a city input by the user.
<output_format>
The output is a string of the validated city in "Austin, TX" format.
</output_format>
Only consider cities in the United States.
<style_guide>
- Write in a friendly, conversational tone
- Use simple language and avoid complex words
- Keep sentences short and concise
</style_guide>
### Triggers
- T1:CND When user provides their city
### Steps
- 01:CND While $city is not a US city or unclear what state $city is in
  - 01.01:QUE Ask user to specify another $city or disambiguate which state $city is in
  - 01.02:YLD for user
  - 01.02:JMP 01 to check again
- 02:RET return $city in "Austin, TX" format

```public.json
[
  {
    "name": "LookupInfo",
    "description": "Look up info for given query",
    "parameters": {
      "type": "object",
      "properties": {"query": {"type": "string", "description": "Query to look up"}}
    },
    "triggers": ["T1:CND Whenever you need to look up additional information"]
  },
  {
    "name": "ValidateCity",
    "description": "Validation routine that ensures location input meets formatting requirements through iterative verification",
    "parameters": {
      "type": "object",
      "properties": {"$city": {"type": "string", "description": "US city and state, e.g. 'Austin, TX'"}}
    },
    "triggers": ["T1:CND When user provides their city"]
  }
]
```


# SecondAgent

## P1($name, $age)
Says hello to the user
### Steps
- 01:QUE Say hello $name
- 02:QUE SaveArtifact("greeting.txt", "Greeting", "Hello $name")
- 03:RET

## public:P2
Says goodbye to the user
### Steps
- 01:QUE LoadArtifact("greeting.txt")
- 02:YLD call
- 03:QUE Say("Artifact[greeting.txt]")
- 04:RET

```public.json
[
  {
    "name": "P2",
    "description": "Says goodbye to the user",
  }
]
```

**End output**

====SYSTEM_PROMPT_DELIMITER====
**Start input**

{{PLAYBOOKS}}

**End input**
Accurately transpile the input into the intermediate format. yld user only when waiting for user input. Queue as many calls as possible before yld call. For each H1, generate public.json with tool info for each public python and markdown playbooks. If no publiced playbooks, generate empty [] public.json.

Follow the output contract exactly; deviations break execution.
**Start output**
