Instruction: Translate this task into NotebookOps format.

Input: Create a calendar event next Tuesday at 9 AM with Sofia, Ben: demo prep.

Output:
<NBOOK>
intent: calendar.create
attendees: Sofia, Ben
date: next Tuesday
time: 09:00
topic: demo prep
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Schedule an email to Grace for today at 10:30 AM regarding demo prep.

Output:
<NBOOK>
intent: email.send
recipient: Grace
date: today
time: 10:30
topic: demo prep
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Set a reminder for Marta at 9 AM on Friday: check the quarterly metrics.

Output:
<NBOOK>
intent: reminder.create
recipient: Marta
date: Friday
time: 09:00
task: review quarterly metrics
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Add task for Hugo, due next Tuesday, priority high, to finish customer notes.

Output:
<NBOOK>
intent: task.create
owner: Hugo
due: next Tuesday
priority: high
task: finish customer notes
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Schedule Rita and Lena for the first business day of next month at 2 PM to discuss demo prep.

Output:
<NBOOK>
intent: calendar.create
attendees: Rita, Lena
date: the first business day of next month
time: 14:00
topic: demo prep
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Set a reminder for Carla at 5 PM on next Tuesday: check the vendor contract.

Output:
<NBOOK>
intent: reminder.create
recipient: Carla
date: next Tuesday
time: 17:00
task: review vendor contract
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Email Jon on June 3 at 2 PM about the demo prep.

Output:
<NBOOK>
intent: email.send
recipient: Jon
date: June 3
time: 14:00
topic: demo prep
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a Research note titled launch checklist with tag launch.

Output:
<NBOOK>
intent: note.create
notebook: Research
title: launch checklist
tag: launch
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a calendar event May 20 at 10:30 AM with Dana, Jon: demo prep.

Output:
<NBOOK>
intent: calendar.create
attendees: Dana, Jon
date: May 20
time: 10:30
topic: demo prep
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Please nudge Fatima today at 5 PM about the travel receipts.

Output:
<NBOOK>
intent: reminder.create
recipient: Fatima
date: today
time: 17:00
task: review travel receipts
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Please nudge Ana Friday at 5 PM about the demo prep.

Output:
<NBOOK>
intent: reminder.create
recipient: Ana
date: Friday
time: 17:00
task: review demo prep
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Send Rita a message next Monday at noon: invoice follow-up.

Output:
<NBOOK>
intent: email.send
recipient: Rita
date: next Monday
time: 12:00
topic: invoice follow-up
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Please nudge Rita next Tuesday at 5 PM about the security audit.

Output:
<NBOOK>
intent: reminder.create
recipient: Rita
date: next Tuesday
time: 17:00
task: review security audit
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Add task for Noah, due June 3, priority urgent, to finish demo prep.

Output:
<NBOOK>
intent: task.create
owner: Noah
due: June 3
priority: urgent
task: finish demo prep
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a Research note titled travel receipts with tag travel.

Output:
<NBOOK>
intent: note.create
notebook: Research
title: travel receipts
tag: travel
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a low priority task for Ana due next Tuesday: finish vendor contract.

Output:
<NBOOK>
intent: task.create
owner: Ana
due: next Tuesday
priority: low
task: finish vendor contract
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Book a meeting with Jon and Hugo on June 3 at 2 PM about security audit.

Output:
<NBOOK>
intent: calendar.create
attendees: Jon, Hugo
date: June 3
time: 14:00
topic: security audit
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a calendar event May 20 at 9 AM with Hugo, Jon: budget review.

Output:
<NBOOK>
intent: calendar.create
attendees: Hugo, Jon
date: May 20
time: 09:00
topic: budget review
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Please nudge Sofia Friday at 2 PM about the vendor contract.

Output:
<NBOOK>
intent: reminder.create
recipient: Sofia
date: Friday
time: 14:00
task: review vendor contract
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Send Grace a message Friday at 5 PM: travel receipts.

Output:
<NBOOK>
intent: email.send
recipient: Grace
date: Friday
time: 17:00
topic: travel receipts
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Send Ana a message the first business day of next month at 3:15 PM: hiring plan.

Output:
<NBOOK>
intent: email.send
recipient: Ana
date: the first business day of next month
time: 15:15
topic: hiring plan
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a calendar event tomorrow at noon with Ana, Carla: security audit.

Output:
<NBOOK>
intent: calendar.create
attendees: Ana, Carla
date: tomorrow
time: 12:00
topic: security audit
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Book a meeting with Jon and Noah on next Tuesday at 9 AM about customer notes.

Output:
<NBOOK>
intent: calendar.create
attendees: Jon, Noah
date: next Tuesday
time: 09:00
topic: customer notes
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Put finish launch checklist on Noah's task list for today with high priority.

Output:
<NBOOK>
intent: task.create
owner: Noah
due: today
priority: high
task: finish launch checklist
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Remind Bruno on tomorrow at noon to review the customer notes.

Output:
<NBOOK>
intent: reminder.create
recipient: Bruno
date: tomorrow
time: 12:00
task: review customer notes
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Book a meeting with Marta and Grace on tomorrow at 2 PM about quarterly metrics.

Output:
<NBOOK>
intent: calendar.create
attendees: Marta, Grace
date: tomorrow
time: 14:00
topic: quarterly metrics
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a Operations note titled invoice follow-up with tag invoice.

Output:
<NBOOK>
intent: note.create
notebook: Operations
title: invoice follow-up
tag: invoice
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a calendar event tomorrow at 3:15 PM with Marta, Dana: invoice follow-up.

Output:
<NBOOK>
intent: calendar.create
attendees: Marta, Dana
date: tomorrow
time: 15:15
topic: invoice follow-up
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: File a note under Research: title customer notes, tag customer.

Output:
<NBOOK>
intent: note.create
notebook: Research
title: customer notes
tag: customer
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule an email to Fatima for next Monday at 8 AM regarding travel receipts.

Output:
<NBOOK>
intent: email.send
recipient: Fatima
date: next Monday
time: 08:00
topic: travel receipts
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule Grace and Bruno for Friday at 9 AM to discuss hiring plan.

Output:
<NBOOK>
intent: calendar.create
attendees: Grace, Bruno
date: Friday
time: 09:00
topic: hiring plan
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Set a reminder for Sofia at 9 AM on June 3: check the customer notes.

Output:
<NBOOK>
intent: reminder.create
recipient: Sofia
date: June 3
time: 09:00
task: review customer notes
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a Product note titled budget review with tag budget.

Output:
<NBOOK>
intent: note.create
notebook: Product
title: budget review
tag: budget
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Please nudge Rita the first business day of next month at noon about the launch checklist.

Output:
<NBOOK>
intent: reminder.create
recipient: Rita
date: the first business day of next month
time: 12:00
task: review launch checklist
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a urgent priority task for Bruno due next Monday: finish launch checklist.

Output:
<NBOOK>
intent: task.create
owner: Bruno
due: next Monday
priority: urgent
task: finish launch checklist
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a calendar event the first business day of next month at 3:15 PM with Lena, Carla: demo prep.

Output:
<NBOOK>
intent: calendar.create
attendees: Lena, Carla
date: the first business day of next month
time: 15:15
topic: demo prep
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Add task for Rita, due the first business day of next month, priority low, to finish hiring plan.

Output:
<NBOOK>
intent: task.create
owner: Rita
due: the first business day of next month
priority: low
task: finish hiring plan
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Save a note in Operations called vendor contract tagged vendor.

Output:
<NBOOK>
intent: note.create
notebook: Operations
title: vendor contract
tag: vendor
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Schedule Ben and Jon for the first business day of next month at 9 AM to discuss vendor contract.

Output:
<NBOOK>
intent: calendar.create
attendees: Ben, Jon
date: the first business day of next month
time: 09:00
topic: vendor contract
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Schedule Dana and Jon for next Tuesday at 5 PM to discuss quarterly metrics.

Output:
<NBOOK>
intent: calendar.create
attendees: Dana, Jon
date: next Tuesday
time: 17:00
topic: quarterly metrics
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Add task for Ana, due tomorrow, priority urgent, to finish security audit.

Output:
<NBOOK>
intent: task.create
owner: Ana
due: tomorrow
priority: urgent
task: finish security audit
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Put finish travel receipts on Bruno's task list for tomorrow with low priority.

Output:
<NBOOK>
intent: task.create
owner: Bruno
due: tomorrow
priority: low
task: finish travel receipts
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Book a meeting with Bruno and Grace on May 20 at 9 AM about travel receipts.

Output:
<NBOOK>
intent: calendar.create
attendees: Bruno, Grace
date: May 20
time: 09:00
topic: travel receipts
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule Rita and Lena for next Tuesday at noon to discuss vendor contract.

Output:
<NBOOK>
intent: calendar.create
attendees: Rita, Lena
date: next Tuesday
time: 12:00
topic: vendor contract
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Remind Jon on tomorrow at noon to review the invoice follow-up.

Output:
<NBOOK>
intent: reminder.create
recipient: Jon
date: tomorrow
time: 12:00
task: review invoice follow-up
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Send Jon a message next Monday at noon: launch checklist.

Output:
<NBOOK>
intent: email.send
recipient: Jon
date: next Monday
time: 12:00
topic: launch checklist
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Please nudge Lena Friday at 2 PM about the security audit.

Output:
<NBOOK>
intent: reminder.create
recipient: Lena
date: Friday
time: 14:00
task: review security audit
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a Operations note titled quarterly metrics with tag quarterly.

Output:
<NBOOK>
intent: note.create
notebook: Operations
title: quarterly metrics
tag: quarterly
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Please nudge Fatima tomorrow at 5 PM about the travel receipts.

Output:
<NBOOK>
intent: reminder.create
recipient: Fatima
date: tomorrow
time: 17:00
task: review travel receipts
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Book a meeting with Marta and Dana on next Tuesday at 8 AM about customer notes.

Output:
<NBOOK>
intent: calendar.create
attendees: Marta, Dana
date: next Tuesday
time: 08:00
topic: customer notes
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Send Grace a message today at 8 AM: demo prep.

Output:
<NBOOK>
intent: email.send
recipient: Grace
date: today
time: 08:00
topic: demo prep
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Set a reminder for Dana at noon on the first business day of next month: check the budget review.

Output:
<NBOOK>
intent: reminder.create
recipient: Dana
date: the first business day of next month
time: 12:00
task: review budget review
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Book a meeting with Carla and Ana on tomorrow at 10:30 AM about invoice follow-up.

Output:
<NBOOK>
intent: calendar.create
attendees: Carla, Ana
date: tomorrow
time: 10:30
topic: invoice follow-up
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: File a note under Personal: title quarterly metrics, tag quarterly.

Output:
<NBOOK>
intent: note.create
notebook: Personal
title: quarterly metrics
tag: quarterly
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Schedule Fatima and Eli for tomorrow at noon to discuss demo prep.

Output:
<NBOOK>
intent: calendar.create
attendees: Fatima, Eli
date: tomorrow
time: 12:00
topic: demo prep
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Email Noah on next Monday at noon about the vendor contract.

Output:
<NBOOK>
intent: email.send
recipient: Noah
date: next Monday
time: 12:00
topic: vendor contract
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Book a meeting with Rita and Jon on tomorrow at 8 AM about vendor contract.

Output:
<NBOOK>
intent: calendar.create
attendees: Rita, Jon
date: tomorrow
time: 08:00
topic: vendor contract
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Email Ana on next Tuesday at 9 AM about the demo prep.

Output:
<NBOOK>
intent: email.send
recipient: Ana
date: next Tuesday
time: 09:00
topic: demo prep
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a Product note titled launch checklist with tag launch.

Output:
<NBOOK>
intent: note.create
notebook: Product
title: launch checklist
tag: launch
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Book a meeting with Ana and Sofia on tomorrow at 2 PM about budget review.

Output:
<NBOOK>
intent: calendar.create
attendees: Ana, Sofia
date: tomorrow
time: 14:00
topic: budget review
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Remind Marta on the first business day of next month at 10:30 AM to review the travel receipts.

Output:
<NBOOK>
intent: reminder.create
recipient: Marta
date: the first business day of next month
time: 10:30
task: review travel receipts
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Put finish launch checklist on Noah's task list for today with low priority.

Output:
<NBOOK>
intent: task.create
owner: Noah
due: today
priority: low
task: finish launch checklist
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Email Sofia on Friday at 10:30 AM about the budget review.

Output:
<NBOOK>
intent: email.send
recipient: Sofia
date: Friday
time: 10:30
topic: budget review
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Schedule Grace and Ben for next Tuesday at 9 AM to discuss hiring plan.

Output:
<NBOOK>
intent: calendar.create
attendees: Grace, Ben
date: next Tuesday
time: 09:00
topic: hiring plan
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a calendar event next Monday at 5 PM with Grace, Bruno: invoice follow-up.

Output:
<NBOOK>
intent: calendar.create
attendees: Grace, Bruno
date: next Monday
time: 17:00
topic: invoice follow-up
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Send Grace a message today at 9 AM: security audit.

Output:
<NBOOK>
intent: email.send
recipient: Grace
date: today
time: 09:00
topic: security audit
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Remind Iris on tomorrow at 5 PM to review the budget review.

Output:
<NBOOK>
intent: reminder.create
recipient: Iris
date: tomorrow
time: 17:00
task: review budget review
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Email Rita on today at 10:30 AM about the travel receipts.

Output:
<NBOOK>
intent: email.send
recipient: Rita
date: today
time: 10:30
topic: travel receipts
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Schedule an email to Carla for May 20 at 8 AM regarding demo prep.

Output:
<NBOOK>
intent: email.send
recipient: Carla
date: May 20
time: 08:00
topic: demo prep
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a calendar event next Tuesday at 8 AM with Rita, Bruno: demo prep.

Output:
<NBOOK>
intent: calendar.create
attendees: Rita, Bruno
date: next Tuesday
time: 08:00
topic: demo prep
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Book a meeting with Grace and Lena on next Tuesday at 5 PM about security audit.

Output:
<NBOOK>
intent: calendar.create
attendees: Grace, Lena
date: next Tuesday
time: 17:00
topic: security audit
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Add task for Hugo, due next Monday, priority low, to finish hiring plan.

Output:
<NBOOK>
intent: task.create
owner: Hugo
due: next Monday
priority: low
task: finish hiring plan
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Add task for Dana, due next Tuesday, priority low, to finish invoice follow-up.

Output:
<NBOOK>
intent: task.create
owner: Dana
due: next Tuesday
priority: low
task: finish invoice follow-up
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a normal priority task for Ben due May 20: finish budget review.

Output:
<NBOOK>
intent: task.create
owner: Ben
due: May 20
priority: normal
task: finish budget review
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Put finish customer notes on Marta's task list for next Monday with low priority.

Output:
<NBOOK>
intent: task.create
owner: Marta
due: next Monday
priority: low
task: finish customer notes
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Set a reminder for Jon at 3:15 PM on tomorrow: check the security audit.

Output:
<NBOOK>
intent: reminder.create
recipient: Jon
date: tomorrow
time: 15:15
task: review security audit
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Send Noah a message Friday at 2 PM: vendor contract.

Output:
<NBOOK>
intent: email.send
recipient: Noah
date: Friday
time: 14:00
topic: vendor contract
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Send Lena a message June 3 at 2 PM: security audit.

Output:
<NBOOK>
intent: email.send
recipient: Lena
date: June 3
time: 14:00
topic: security audit
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Save a note in Personal called travel receipts tagged travel.

Output:
<NBOOK>
intent: note.create
notebook: Personal
title: travel receipts
tag: travel
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: File a note under Product: title demo prep, tag demo.

Output:
<NBOOK>
intent: note.create
notebook: Product
title: demo prep
tag: demo
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Set a reminder for Jon at 9 AM on Friday: check the vendor contract.

Output:
<NBOOK>
intent: reminder.create
recipient: Jon
date: Friday
time: 09:00
task: review vendor contract
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a calendar event today at 8 AM with Ben, Hugo: launch checklist.

Output:
<NBOOK>
intent: calendar.create
attendees: Ben, Hugo
date: today
time: 08:00
topic: launch checklist
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a low priority task for Jon due next Monday: finish customer notes.

Output:
<NBOOK>
intent: task.create
owner: Jon
due: next Monday
priority: low
task: finish customer notes
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Schedule Ana and Iris for Friday at 8 AM to discuss vendor contract.

Output:
<NBOOK>
intent: calendar.create
attendees: Ana, Iris
date: Friday
time: 08:00
topic: vendor contract
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Remind Lena on today at 8 AM to review the launch checklist.

Output:
<NBOOK>
intent: reminder.create
recipient: Lena
date: today
time: 08:00
task: review launch checklist
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a Work note titled budget review with tag budget.

Output:
<NBOOK>
intent: note.create
notebook: Work
title: budget review
tag: budget
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Save a note in Operations called launch checklist tagged launch.

Output:
<NBOOK>
intent: note.create
notebook: Operations
title: launch checklist
tag: launch
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Put finish customer notes on Sofia's task list for tomorrow with urgent priority.

Output:
<NBOOK>
intent: task.create
owner: Sofia
due: tomorrow
priority: urgent
task: finish customer notes
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Please nudge Ben today at 10:30 AM about the invoice follow-up.

Output:
<NBOOK>
intent: reminder.create
recipient: Ben
date: today
time: 10:30
task: review invoice follow-up
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Please nudge Rita tomorrow at 8 AM about the hiring plan.

Output:
<NBOOK>
intent: reminder.create
recipient: Rita
date: tomorrow
time: 08:00
task: review hiring plan
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Add task for Rita, due June 3, priority normal, to finish hiring plan.

Output:
<NBOOK>
intent: task.create
owner: Rita
due: June 3
priority: normal
task: finish hiring plan
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Save a note in Research called demo prep tagged demo.

Output:
<NBOOK>
intent: note.create
notebook: Research
title: demo prep
tag: demo
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a high priority task for Ana due next Monday: finish launch checklist.

Output:
<NBOOK>
intent: task.create
owner: Ana
due: next Monday
priority: high
task: finish launch checklist
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Remind Ana on June 3 at 3:15 PM to review the vendor contract.

Output:
<NBOOK>
intent: reminder.create
recipient: Ana
date: June 3
time: 15:15
task: review vendor contract
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule an email to Eli for May 20 at 8 AM regarding launch checklist.

Output:
<NBOOK>
intent: email.send
recipient: Eli
date: May 20
time: 08:00
topic: launch checklist
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: File a note under Product: title vendor contract, tag vendor.

Output:
<NBOOK>
intent: note.create
notebook: Product
title: vendor contract
tag: vendor
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Please nudge Eli next Tuesday at noon about the security audit.

Output:
<NBOOK>
intent: reminder.create
recipient: Eli
date: next Tuesday
time: 12:00
task: review security audit
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Save a note in Research called customer notes tagged customer.

Output:
<NBOOK>
intent: note.create
notebook: Research
title: customer notes
tag: customer
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a calendar event next Monday at 10:30 AM with Rita, Iris: hiring plan.

Output:
<NBOOK>
intent: calendar.create
attendees: Rita, Iris
date: next Monday
time: 10:30
topic: hiring plan
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Email Ben on today at 5 PM about the invoice follow-up.

Output:
<NBOOK>
intent: email.send
recipient: Ben
date: today
time: 17:00
topic: invoice follow-up
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Please nudge Marta next Monday at noon about the budget review.

Output:
<NBOOK>
intent: reminder.create
recipient: Marta
date: next Monday
time: 12:00
task: review budget review
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Book a meeting with Bruno and Sofia on today at 5 PM about launch checklist.

Output:
<NBOOK>
intent: calendar.create
attendees: Bruno, Sofia
date: today
time: 17:00
topic: launch checklist
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: File a note under Finance: title budget review, tag budget.

Output:
<NBOOK>
intent: note.create
notebook: Finance
title: budget review
tag: budget
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a low priority task for Marta due Friday: finish hiring plan.

Output:
<NBOOK>
intent: task.create
owner: Marta
due: Friday
priority: low
task: finish hiring plan
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Book a meeting with Rita and Bruno on next Monday at 10:30 AM about customer notes.

Output:
<NBOOK>
intent: calendar.create
attendees: Rita, Bruno
date: next Monday
time: 10:30
topic: customer notes
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Add task for Jon, due tomorrow, priority urgent, to finish launch checklist.

Output:
<NBOOK>
intent: task.create
owner: Jon
due: tomorrow
priority: urgent
task: finish launch checklist
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Put finish invoice follow-up on Eli's task list for next Tuesday with high priority.

Output:
<NBOOK>
intent: task.create
owner: Eli
due: next Tuesday
priority: high
task: finish invoice follow-up
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Book a meeting with Lena and Sofia on Friday at noon about customer notes.

Output:
<NBOOK>
intent: calendar.create
attendees: Lena, Sofia
date: Friday
time: 12:00
topic: customer notes
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a calendar event Friday at 8 AM with Iris, Noah: hiring plan.

Output:
<NBOOK>
intent: calendar.create
attendees: Iris, Noah
date: Friday
time: 08:00
topic: hiring plan
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Save a note in Product called vendor contract tagged vendor.

Output:
<NBOOK>
intent: note.create
notebook: Product
title: vendor contract
tag: vendor
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Book a meeting with Rita and Ben on tomorrow at 2 PM about hiring plan.

Output:
<NBOOK>
intent: calendar.create
attendees: Rita, Ben
date: tomorrow
time: 14:00
topic: hiring plan
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Please nudge Iris next Monday at 8 AM about the budget review.

Output:
<NBOOK>
intent: reminder.create
recipient: Iris
date: next Monday
time: 08:00
task: review budget review
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Book a meeting with Bruno and Dana on today at 3:15 PM about hiring plan.

Output:
<NBOOK>
intent: calendar.create
attendees: Bruno, Dana
date: today
time: 15:15
topic: hiring plan
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Set a reminder for Ana at 2 PM on June 3: check the security audit.

Output:
<NBOOK>
intent: reminder.create
recipient: Ana
date: June 3
time: 14:00
task: review security audit
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Remind Ana on May 20 at 5 PM to review the demo prep.

Output:
<NBOOK>
intent: reminder.create
recipient: Ana
date: May 20
time: 17:00
task: review demo prep
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a Product note titled demo prep with tag demo.

Output:
<NBOOK>
intent: note.create
notebook: Product
title: demo prep
tag: demo
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a calendar event Friday at 9 AM with Carla, Sofia: quarterly metrics.

Output:
<NBOOK>
intent: calendar.create
attendees: Carla, Sofia
date: Friday
time: 09:00
topic: quarterly metrics
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Book a meeting with Noah and Bruno on June 3 at 5 PM about hiring plan.

Output:
<NBOOK>
intent: calendar.create
attendees: Noah, Bruno
date: June 3
time: 17:00
topic: hiring plan
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Put finish security audit on Sofia's task list for June 3 with high priority.

Output:
<NBOOK>
intent: task.create
owner: Sofia
due: June 3
priority: high
task: finish security audit
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Add task for Hugo, due June 3, priority high, to finish demo prep.

Output:
<NBOOK>
intent: task.create
owner: Hugo
due: June 3
priority: high
task: finish demo prep
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a urgent priority task for Noah due tomorrow: finish security audit.

Output:
<NBOOK>
intent: task.create
owner: Noah
due: tomorrow
priority: urgent
task: finish security audit
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Book a meeting with Eli and Marta on tomorrow at 5 PM about invoice follow-up.

Output:
<NBOOK>
intent: calendar.create
attendees: Eli, Marta
date: tomorrow
time: 17:00
topic: invoice follow-up
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Put finish travel receipts on Sofia's task list for the first business day of next month with normal priority.

Output:
<NBOOK>
intent: task.create
owner: Sofia
due: the first business day of next month
priority: normal
task: finish travel receipts
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a urgent priority task for Rita due tomorrow: finish security audit.

Output:
<NBOOK>
intent: task.create
owner: Rita
due: tomorrow
priority: urgent
task: finish security audit
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Send Carla a message June 3 at 10:30 AM: vendor contract.

Output:
<NBOOK>
intent: email.send
recipient: Carla
date: June 3
time: 10:30
topic: vendor contract
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a Finance note titled demo prep with tag demo.

Output:
<NBOOK>
intent: note.create
notebook: Finance
title: demo prep
tag: demo
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Book a meeting with Ben and Rita on June 3 at 9 AM about vendor contract.

Output:
<NBOOK>
intent: calendar.create
attendees: Ben, Rita
date: June 3
time: 09:00
topic: vendor contract
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Book a meeting with Grace and Jon on May 20 at 5 PM about customer notes.

Output:
<NBOOK>
intent: calendar.create
attendees: Grace, Jon
date: May 20
time: 17:00
topic: customer notes
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a high priority task for Hugo due June 3: finish launch checklist.

Output:
<NBOOK>
intent: task.create
owner: Hugo
due: June 3
priority: high
task: finish launch checklist
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: File a note under Personal: title hiring plan, tag hiring.

Output:
<NBOOK>
intent: note.create
notebook: Personal
title: hiring plan
tag: hiring
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: File a note under Work: title hiring plan, tag hiring.

Output:
<NBOOK>
intent: note.create
notebook: Work
title: hiring plan
tag: hiring
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Set a reminder for Noah at 8 AM on tomorrow: check the hiring plan.

Output:
<NBOOK>
intent: reminder.create
recipient: Noah
date: tomorrow
time: 08:00
task: review hiring plan
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule Iris and Jon for Friday at 3:15 PM to discuss hiring plan.

Output:
<NBOOK>
intent: calendar.create
attendees: Iris, Jon
date: Friday
time: 15:15
topic: hiring plan
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Please nudge Eli May 20 at 8 AM about the quarterly metrics.

Output:
<NBOOK>
intent: reminder.create
recipient: Eli
date: May 20
time: 08:00
task: review quarterly metrics
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Save a note in Research called security audit tagged security.

Output:
<NBOOK>
intent: note.create
notebook: Research
title: security audit
tag: security
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Email Jon on May 20 at 10:30 AM about the quarterly metrics.

Output:
<NBOOK>
intent: email.send
recipient: Jon
date: May 20
time: 10:30
topic: quarterly metrics
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Set a reminder for Grace at 9 AM on May 20: check the quarterly metrics.

Output:
<NBOOK>
intent: reminder.create
recipient: Grace
date: May 20
time: 09:00
task: review quarterly metrics
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule an email to Carla for today at 3:15 PM regarding launch checklist.

Output:
<NBOOK>
intent: email.send
recipient: Carla
date: today
time: 15:15
topic: launch checklist
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule an email to Iris for today at 8 AM regarding customer notes.

Output:
<NBOOK>
intent: email.send
recipient: Iris
date: today
time: 08:00
topic: customer notes
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Send Jon a message today at noon: budget review.

Output:
<NBOOK>
intent: email.send
recipient: Jon
date: today
time: 12:00
topic: budget review
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Add task for Carla, due May 20, priority urgent, to finish budget review.

Output:
<NBOOK>
intent: task.create
owner: Carla
due: May 20
priority: urgent
task: finish budget review
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Book a meeting with Hugo and Carla on next Monday at 3:15 PM about customer notes.

Output:
<NBOOK>
intent: calendar.create
attendees: Hugo, Carla
date: next Monday
time: 15:15
topic: customer notes
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Remind Ana on May 20 at 2 PM to review the demo prep.

Output:
<NBOOK>
intent: reminder.create
recipient: Ana
date: May 20
time: 14:00
task: review demo prep
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Schedule an email to Eli for June 3 at 3:15 PM regarding travel receipts.

Output:
<NBOOK>
intent: email.send
recipient: Eli
date: June 3
time: 15:15
topic: travel receipts
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Schedule Jon and Ana for May 20 at 9 AM to discuss demo prep.

Output:
<NBOOK>
intent: calendar.create
attendees: Jon, Ana
date: May 20
time: 09:00
topic: demo prep
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Set a reminder for Marta at 9 AM on tomorrow: check the demo prep.

Output:
<NBOOK>
intent: reminder.create
recipient: Marta
date: tomorrow
time: 09:00
task: review demo prep
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Schedule Ben and Ana for Friday at 5 PM to discuss invoice follow-up.

Output:
<NBOOK>
intent: calendar.create
attendees: Ben, Ana
date: Friday
time: 17:00
topic: invoice follow-up
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Add task for Lena, due today, priority normal, to finish launch checklist.

Output:
<NBOOK>
intent: task.create
owner: Lena
due: today
priority: normal
task: finish launch checklist
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Schedule Dana and Sofia for Friday at 8 AM to discuss budget review.

Output:
<NBOOK>
intent: calendar.create
attendees: Dana, Sofia
date: Friday
time: 08:00
topic: budget review
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Schedule Bruno and Ana for Friday at 10:30 AM to discuss invoice follow-up.

Output:
<NBOOK>
intent: calendar.create
attendees: Bruno, Ana
date: Friday
time: 10:30
topic: invoice follow-up
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a high priority task for Eli due Friday: finish launch checklist.

Output:
<NBOOK>
intent: task.create
owner: Eli
due: Friday
priority: high
task: finish launch checklist
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Schedule Ben and Hugo for today at noon to discuss security audit.

Output:
<NBOOK>
intent: calendar.create
attendees: Ben, Hugo
date: today
time: 12:00
topic: security audit
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Set a reminder for Fatima at 8 AM on Friday: check the quarterly metrics.

Output:
<NBOOK>
intent: reminder.create
recipient: Fatima
date: Friday
time: 08:00
task: review quarterly metrics
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Set a reminder for Rita at noon on May 20: check the quarterly metrics.

Output:
<NBOOK>
intent: reminder.create
recipient: Rita
date: May 20
time: 12:00
task: review quarterly metrics
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Set a reminder for Hugo at 2 PM on today: check the quarterly metrics.

Output:
<NBOOK>
intent: reminder.create
recipient: Hugo
date: today
time: 14:00
task: review quarterly metrics
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a calendar event the first business day of next month at 10:30 AM with Ben, Eli: vendor contract.

Output:
<NBOOK>
intent: calendar.create
attendees: Ben, Eli
date: the first business day of next month
time: 10:30
topic: vendor contract
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Email Iris on today at 3:15 PM about the quarterly metrics.

Output:
<NBOOK>
intent: email.send
recipient: Iris
date: today
time: 15:15
topic: quarterly metrics
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Set a reminder for Carla at 2 PM on Friday: check the quarterly metrics.

Output:
<NBOOK>
intent: reminder.create
recipient: Carla
date: Friday
time: 14:00
task: review quarterly metrics
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule an email to Ana for June 3 at 9 AM regarding quarterly metrics.

Output:
<NBOOK>
intent: email.send
recipient: Ana
date: June 3
time: 09:00
topic: quarterly metrics
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Schedule Bruno and Hugo for the first business day of next month at 5 PM to discuss demo prep.

Output:
<NBOOK>
intent: calendar.create
attendees: Bruno, Hugo
date: the first business day of next month
time: 17:00
topic: demo prep
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Please nudge Grace next Monday at 3:15 PM about the vendor contract.

Output:
<NBOOK>
intent: reminder.create
recipient: Grace
date: next Monday
time: 15:15
task: review vendor contract
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Send Sofia a message tomorrow at noon: travel receipts.

Output:
<NBOOK>
intent: email.send
recipient: Sofia
date: tomorrow
time: 12:00
topic: travel receipts
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a normal priority task for Dana due June 3: finish travel receipts.

Output:
<NBOOK>
intent: task.create
owner: Dana
due: June 3
priority: normal
task: finish travel receipts
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Schedule Jon and Ana for June 3 at 10:30 AM to discuss demo prep.

Output:
<NBOOK>
intent: calendar.create
attendees: Jon, Ana
date: June 3
time: 10:30
topic: demo prep
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: File a note under Research: title quarterly metrics, tag quarterly.

Output:
<NBOOK>
intent: note.create
notebook: Research
title: quarterly metrics
tag: quarterly
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Email Iris on next Monday at 8 AM about the budget review.

Output:
<NBOOK>
intent: email.send
recipient: Iris
date: next Monday
time: 08:00
topic: budget review
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule Bruno and Rita for May 20 at 8 AM to discuss travel receipts.

Output:
<NBOOK>
intent: calendar.create
attendees: Bruno, Rita
date: May 20
time: 08:00
topic: travel receipts
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Schedule an email to Iris for June 3 at 2 PM regarding launch checklist.

Output:
<NBOOK>
intent: email.send
recipient: Iris
date: June 3
time: 14:00
topic: launch checklist
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Schedule Lena and Ana for May 20 at noon to discuss security audit.

Output:
<NBOOK>
intent: calendar.create
attendees: Lena, Ana
date: May 20
time: 12:00
topic: security audit
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Please nudge Hugo Friday at 10:30 AM about the travel receipts.

Output:
<NBOOK>
intent: reminder.create
recipient: Hugo
date: Friday
time: 10:30
task: review travel receipts
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Please nudge Lena next Monday at 2 PM about the launch checklist.

Output:
<NBOOK>
intent: reminder.create
recipient: Lena
date: next Monday
time: 14:00
task: review launch checklist
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Set a reminder for Fatima at 8 AM on the first business day of next month: check the demo prep.

Output:
<NBOOK>
intent: reminder.create
recipient: Fatima
date: the first business day of next month
time: 08:00
task: review demo prep
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Save a note in Research called vendor contract tagged vendor.

Output:
<NBOOK>
intent: note.create
notebook: Research
title: vendor contract
tag: vendor
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a low priority task for Iris due today: finish security audit.

Output:
<NBOOK>
intent: task.create
owner: Iris
due: today
priority: low
task: finish security audit
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Email Ana on next Tuesday at noon about the vendor contract.

Output:
<NBOOK>
intent: email.send
recipient: Ana
date: next Tuesday
time: 12:00
topic: vendor contract
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Remind Noah on Friday at 10:30 AM to review the demo prep.

Output:
<NBOOK>
intent: reminder.create
recipient: Noah
date: Friday
time: 10:30
task: review demo prep
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Schedule an email to Grace for Friday at 3:15 PM regarding invoice follow-up.

Output:
<NBOOK>
intent: email.send
recipient: Grace
date: Friday
time: 15:15
topic: invoice follow-up
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Please nudge Noah the first business day of next month at noon about the hiring plan.

Output:
<NBOOK>
intent: reminder.create
recipient: Noah
date: the first business day of next month
time: 12:00
task: review hiring plan
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Add task for Rita, due June 3, priority urgent, to finish customer notes.

Output:
<NBOOK>
intent: task.create
owner: Rita
due: June 3
priority: urgent
task: finish customer notes
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: File a note under Finance: title customer notes, tag customer.

Output:
<NBOOK>
intent: note.create
notebook: Finance
title: customer notes
tag: customer
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Save a note in Operations called budget review tagged budget.

Output:
<NBOOK>
intent: note.create
notebook: Operations
title: budget review
tag: budget
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Save a note in Finance called launch checklist tagged launch.

Output:
<NBOOK>
intent: note.create
notebook: Finance
title: launch checklist
tag: launch
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Please nudge Ben next Monday at 5 PM about the budget review.

Output:
<NBOOK>
intent: reminder.create
recipient: Ben
date: next Monday
time: 17:00
task: review budget review
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a Personal note titled travel receipts with tag travel.

Output:
<NBOOK>
intent: note.create
notebook: Personal
title: travel receipts
tag: travel
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Send Hugo a message tomorrow at 10:30 AM: quarterly metrics.

Output:
<NBOOK>
intent: email.send
recipient: Hugo
date: tomorrow
time: 10:30
topic: quarterly metrics
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Set a reminder for Marta at 10:30 AM on Friday: check the security audit.

Output:
<NBOOK>
intent: reminder.create
recipient: Marta
date: Friday
time: 10:30
task: review security audit
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Email Marta on today at 8 AM about the hiring plan.

Output:
<NBOOK>
intent: email.send
recipient: Marta
date: today
time: 08:00
topic: hiring plan
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Email Sofia on the first business day of next month at 2 PM about the hiring plan.

Output:
<NBOOK>
intent: email.send
recipient: Sofia
date: the first business day of next month
time: 14:00
topic: hiring plan
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Please nudge Jon May 20 at 3:15 PM about the budget review.

Output:
<NBOOK>
intent: reminder.create
recipient: Jon
date: May 20
time: 15:15
task: review budget review
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Send Fatima a message next Monday at 8 AM: budget review.

Output:
<NBOOK>
intent: email.send
recipient: Fatima
date: next Monday
time: 08:00
topic: budget review
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Book a meeting with Grace and Lena on Friday at 10:30 AM about demo prep.

Output:
<NBOOK>
intent: calendar.create
attendees: Grace, Lena
date: Friday
time: 10:30
topic: demo prep
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Book a meeting with Sofia and Marta on next Tuesday at 8 AM about hiring plan.

Output:
<NBOOK>
intent: calendar.create
attendees: Sofia, Marta
date: next Tuesday
time: 08:00
topic: hiring plan
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a Finance note titled customer notes with tag customer.

Output:
<NBOOK>
intent: note.create
notebook: Finance
title: customer notes
tag: customer
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a calendar event next Tuesday at 2 PM with Lena, Ben: vendor contract.

Output:
<NBOOK>
intent: calendar.create
attendees: Lena, Ben
date: next Tuesday
time: 14:00
topic: vendor contract
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Schedule an email to Noah for today at 5 PM regarding quarterly metrics.

Output:
<NBOOK>
intent: email.send
recipient: Noah
date: today
time: 17:00
topic: quarterly metrics
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Add task for Jon, due Friday, priority low, to finish quarterly metrics.

Output:
<NBOOK>
intent: task.create
owner: Jon
due: Friday
priority: low
task: finish quarterly metrics
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a calendar event today at 9 AM with Lena, Eli: travel receipts.

Output:
<NBOOK>
intent: calendar.create
attendees: Lena, Eli
date: today
time: 09:00
topic: travel receipts
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a normal priority task for Marta due Friday: finish security audit.

Output:
<NBOOK>
intent: task.create
owner: Marta
due: Friday
priority: normal
task: finish security audit
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Schedule an email to Ana for June 3 at 10:30 AM regarding budget review.

Output:
<NBOOK>
intent: email.send
recipient: Ana
date: June 3
time: 10:30
topic: budget review
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Add task for Ana, due next Monday, priority high, to finish demo prep.

Output:
<NBOOK>
intent: task.create
owner: Ana
due: next Monday
priority: high
task: finish demo prep
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Please nudge Dana tomorrow at 5 PM about the hiring plan.

Output:
<NBOOK>
intent: reminder.create
recipient: Dana
date: tomorrow
time: 17:00
task: review hiring plan
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a calendar event next Monday at 10:30 AM with Fatima, Jon: demo prep.

Output:
<NBOOK>
intent: calendar.create
attendees: Fatima, Jon
date: next Monday
time: 10:30
topic: demo prep
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Add task for Rita, due June 3, priority normal, to finish invoice follow-up.

Output:
<NBOOK>
intent: task.create
owner: Rita
due: June 3
priority: normal
task: finish invoice follow-up
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Save a note in Product called demo prep tagged demo.

Output:
<NBOOK>
intent: note.create
notebook: Product
title: demo prep
tag: demo
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Add task for Carla, due next Tuesday, priority high, to finish budget review.

Output:
<NBOOK>
intent: task.create
owner: Carla
due: next Tuesday
priority: high
task: finish budget review
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Email Jon on tomorrow at 5 PM about the demo prep.

Output:
<NBOOK>
intent: email.send
recipient: Jon
date: tomorrow
time: 17:00
topic: demo prep
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: File a note under Work: title vendor contract, tag vendor.

Output:
<NBOOK>
intent: note.create
notebook: Work
title: vendor contract
tag: vendor
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: File a note under Work: title customer notes, tag customer.

Output:
<NBOOK>
intent: note.create
notebook: Work
title: customer notes
tag: customer
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Add task for Ben, due next Monday, priority high, to finish customer notes.

Output:
<NBOOK>
intent: task.create
owner: Ben
due: next Monday
priority: high
task: finish customer notes
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Book a meeting with Dana and Iris on Friday at 2 PM about hiring plan.

Output:
<NBOOK>
intent: calendar.create
attendees: Dana, Iris
date: Friday
time: 14:00
topic: hiring plan
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a normal priority task for Bruno due tomorrow: finish quarterly metrics.

Output:
<NBOOK>
intent: task.create
owner: Bruno
due: tomorrow
priority: normal
task: finish quarterly metrics
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Add task for Iris, due tomorrow, priority normal, to finish launch checklist.

Output:
<NBOOK>
intent: task.create
owner: Iris
due: tomorrow
priority: normal
task: finish launch checklist
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a Finance note titled launch checklist with tag launch.

Output:
<NBOOK>
intent: note.create
notebook: Finance
title: launch checklist
tag: launch
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Please nudge Marta next Monday at 8 AM about the travel receipts.

Output:
<NBOOK>
intent: reminder.create
recipient: Marta
date: next Monday
time: 08:00
task: review travel receipts
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Set a reminder for Marta at 9 AM on the first business day of next month: check the travel receipts.

Output:
<NBOOK>
intent: reminder.create
recipient: Marta
date: the first business day of next month
time: 09:00
task: review travel receipts
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a normal priority task for Lena due Friday: finish vendor contract.

Output:
<NBOOK>
intent: task.create
owner: Lena
due: Friday
priority: normal
task: finish vendor contract
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Remind Eli on May 20 at noon to review the hiring plan.

Output:
<NBOOK>
intent: reminder.create
recipient: Eli
date: May 20
time: 12:00
task: review hiring plan
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Put finish quarterly metrics on Bruno's task list for tomorrow with normal priority.

Output:
<NBOOK>
intent: task.create
owner: Bruno
due: tomorrow
priority: normal
task: finish quarterly metrics
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Put finish quarterly metrics on Dana's task list for tomorrow with normal priority.

Output:
<NBOOK>
intent: task.create
owner: Dana
due: tomorrow
priority: normal
task: finish quarterly metrics
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Email Carla on June 3 at 8 AM about the quarterly metrics.

Output:
<NBOOK>
intent: email.send
recipient: Carla
date: June 3
time: 08:00
topic: quarterly metrics
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Please nudge Ben the first business day of next month at 9 AM about the launch checklist.

Output:
<NBOOK>
intent: reminder.create
recipient: Ben
date: the first business day of next month
time: 09:00
task: review launch checklist
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: File a note under Work: title quarterly metrics, tag quarterly.

Output:
<NBOOK>
intent: note.create
notebook: Work
title: quarterly metrics
tag: quarterly
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Send Noah a message Friday at 5 PM: demo prep.

Output:
<NBOOK>
intent: email.send
recipient: Noah
date: Friday
time: 17:00
topic: demo prep
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Save a note in Finance called customer notes tagged customer.

Output:
<NBOOK>
intent: note.create
notebook: Finance
title: customer notes
tag: customer
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule Carla and Ben for next Monday at 10:30 AM to discuss budget review.

Output:
<NBOOK>
intent: calendar.create
attendees: Carla, Ben
date: next Monday
time: 10:30
topic: budget review
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a Research note titled security audit with tag security.

Output:
<NBOOK>
intent: note.create
notebook: Research
title: security audit
tag: security
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Put finish travel receipts on Noah's task list for Friday with high priority.

Output:
<NBOOK>
intent: task.create
owner: Noah
due: Friday
priority: high
task: finish travel receipts
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule an email to Fatima for next Monday at 8 AM regarding vendor contract.

Output:
<NBOOK>
intent: email.send
recipient: Fatima
date: next Monday
time: 08:00
topic: vendor contract
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Email Sofia on next Monday at noon about the travel receipts.

Output:
<NBOOK>
intent: email.send
recipient: Sofia
date: next Monday
time: 12:00
topic: travel receipts
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Please nudge Hugo next Monday at 2 PM about the hiring plan.

Output:
<NBOOK>
intent: reminder.create
recipient: Hugo
date: next Monday
time: 14:00
task: review hiring plan
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Put finish security audit on Eli's task list for tomorrow with high priority.

Output:
<NBOOK>
intent: task.create
owner: Eli
due: tomorrow
priority: high
task: finish security audit
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Add task for Hugo, due the first business day of next month, priority urgent, to finish travel receipts.

Output:
<NBOOK>
intent: task.create
owner: Hugo
due: the first business day of next month
priority: urgent
task: finish travel receipts
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Email Noah on next Tuesday at 9 AM about the vendor contract.

Output:
<NBOOK>
intent: email.send
recipient: Noah
date: next Tuesday
time: 09:00
topic: vendor contract
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Set a reminder for Marta at 9 AM on the first business day of next month: check the vendor contract.

Output:
<NBOOK>
intent: reminder.create
recipient: Marta
date: the first business day of next month
time: 09:00
task: review vendor contract
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Please nudge Fatima next Tuesday at 2 PM about the quarterly metrics.

Output:
<NBOOK>
intent: reminder.create
recipient: Fatima
date: next Tuesday
time: 14:00
task: review quarterly metrics
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Please nudge Eli June 3 at 10:30 AM about the vendor contract.

Output:
<NBOOK>
intent: reminder.create
recipient: Eli
date: June 3
time: 10:30
task: review vendor contract
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: File a note under Work: title demo prep, tag demo.

Output:
<NBOOK>
intent: note.create
notebook: Work
title: demo prep
tag: demo
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: File a note under Operations: title launch checklist, tag launch.

Output:
<NBOOK>
intent: note.create
notebook: Operations
title: launch checklist
tag: launch
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Put finish travel receipts on Carla's task list for June 3 with high priority.

Output:
<NBOOK>
intent: task.create
owner: Carla
due: June 3
priority: high
task: finish travel receipts
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a normal priority task for Marta due Friday: finish invoice follow-up.

Output:
<NBOOK>
intent: task.create
owner: Marta
due: Friday
priority: normal
task: finish invoice follow-up
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Add task for Eli, due next Tuesday, priority urgent, to finish vendor contract.

Output:
<NBOOK>
intent: task.create
owner: Eli
due: next Tuesday
priority: urgent
task: finish vendor contract
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a calendar event Friday at 8 AM with Lena, Rita: demo prep.

Output:
<NBOOK>
intent: calendar.create
attendees: Lena, Rita
date: Friday
time: 08:00
topic: demo prep
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Schedule an email to Marta for the first business day of next month at 10:30 AM regarding budget review.

Output:
<NBOOK>
intent: email.send
recipient: Marta
date: the first business day of next month
time: 10:30
topic: budget review
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: File a note under Research: title travel receipts, tag travel.

Output:
<NBOOK>
intent: note.create
notebook: Research
title: travel receipts
tag: travel
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Book a meeting with Noah and Lena on Friday at 2 PM about security audit.

Output:
<NBOOK>
intent: calendar.create
attendees: Noah, Lena
date: Friday
time: 14:00
topic: security audit
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a calendar event the first business day of next month at 10:30 AM with Grace, Fatima: customer notes.

Output:
<NBOOK>
intent: calendar.create
attendees: Grace, Fatima
date: the first business day of next month
time: 10:30
topic: customer notes
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Add task for Marta, due next Tuesday, priority low, to finish quarterly metrics.

Output:
<NBOOK>
intent: task.create
owner: Marta
due: next Tuesday
priority: low
task: finish quarterly metrics
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a calendar event Friday at 5 PM with Bruno, Grace: invoice follow-up.

Output:
<NBOOK>
intent: calendar.create
attendees: Bruno, Grace
date: Friday
time: 17:00
topic: invoice follow-up
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Schedule an email to Grace for next Tuesday at 3:15 PM regarding quarterly metrics.

Output:
<NBOOK>
intent: email.send
recipient: Grace
date: next Tuesday
time: 15:15
topic: quarterly metrics
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a calendar event tomorrow at 9 AM with Jon, Ana: vendor contract.

Output:
<NBOOK>
intent: calendar.create
attendees: Jon, Ana
date: tomorrow
time: 09:00
topic: vendor contract
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Book a meeting with Rita and Ben on the first business day of next month at 9 AM about quarterly metrics.

Output:
<NBOOK>
intent: calendar.create
attendees: Rita, Ben
date: the first business day of next month
time: 09:00
topic: quarterly metrics
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a urgent priority task for Jon due tomorrow: finish budget review.

Output:
<NBOOK>
intent: task.create
owner: Jon
due: tomorrow
priority: urgent
task: finish budget review
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a Operations note titled launch checklist with tag launch.

Output:
<NBOOK>
intent: note.create
notebook: Operations
title: launch checklist
tag: launch
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Put finish budget review on Marta's task list for today with normal priority.

Output:
<NBOOK>
intent: task.create
owner: Marta
due: today
priority: normal
task: finish budget review
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Send Ben a message June 3 at 5 PM: hiring plan.

Output:
<NBOOK>
intent: email.send
recipient: Ben
date: June 3
time: 17:00
topic: hiring plan
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a Finance note titled vendor contract with tag vendor.

Output:
<NBOOK>
intent: note.create
notebook: Finance
title: vendor contract
tag: vendor
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a urgent priority task for Grace due next Monday: finish travel receipts.

Output:
<NBOOK>
intent: task.create
owner: Grace
due: next Monday
priority: urgent
task: finish travel receipts
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Put finish demo prep on Lena's task list for May 20 with low priority.

Output:
<NBOOK>
intent: task.create
owner: Lena
due: May 20
priority: low
task: finish demo prep
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Set a reminder for Iris at 9 AM on Friday: check the invoice follow-up.

Output:
<NBOOK>
intent: reminder.create
recipient: Iris
date: Friday
time: 09:00
task: review invoice follow-up
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Set a reminder for Fatima at noon on tomorrow: check the travel receipts.

Output:
<NBOOK>
intent: reminder.create
recipient: Fatima
date: tomorrow
time: 12:00
task: review travel receipts
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Remind Bruno on today at 9 AM to review the budget review.

Output:
<NBOOK>
intent: reminder.create
recipient: Bruno
date: today
time: 09:00
task: review budget review
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Book a meeting with Lena and Ana on tomorrow at 2 PM about quarterly metrics.

Output:
<NBOOK>
intent: calendar.create
attendees: Lena, Ana
date: tomorrow
time: 14:00
topic: quarterly metrics
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a calendar event next Monday at noon with Rita, Hugo: travel receipts.

Output:
<NBOOK>
intent: calendar.create
attendees: Rita, Hugo
date: next Monday
time: 12:00
topic: travel receipts
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Schedule Eli and Marta for June 3 at 8 AM to discuss quarterly metrics.

Output:
<NBOOK>
intent: calendar.create
attendees: Eli, Marta
date: June 3
time: 08:00
topic: quarterly metrics
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Put finish quarterly metrics on Grace's task list for today with normal priority.

Output:
<NBOOK>
intent: task.create
owner: Grace
due: today
priority: normal
task: finish quarterly metrics
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Send Jon a message June 3 at 2 PM: budget review.

Output:
<NBOOK>
intent: email.send
recipient: Jon
date: June 3
time: 14:00
topic: budget review
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: File a note under Work: title travel receipts, tag travel.

Output:
<NBOOK>
intent: note.create
notebook: Work
title: travel receipts
tag: travel
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Send Carla a message tomorrow at 5 PM: vendor contract.

Output:
<NBOOK>
intent: email.send
recipient: Carla
date: tomorrow
time: 17:00
topic: vendor contract
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Set a reminder for Eli at 5 PM on next Tuesday: check the hiring plan.

Output:
<NBOOK>
intent: reminder.create
recipient: Eli
date: next Tuesday
time: 17:00
task: review hiring plan
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Please nudge Bruno Friday at 8 AM about the launch checklist.

Output:
<NBOOK>
intent: reminder.create
recipient: Bruno
date: Friday
time: 08:00
task: review launch checklist
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Add task for Bruno, due Friday, priority urgent, to finish customer notes.

Output:
<NBOOK>
intent: task.create
owner: Bruno
due: Friday
priority: urgent
task: finish customer notes
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a calendar event May 20 at 10:30 AM with Sofia, Ben: travel receipts.

Output:
<NBOOK>
intent: calendar.create
attendees: Sofia, Ben
date: May 20
time: 10:30
topic: travel receipts
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Add task for Grace, due May 20, priority normal, to finish demo prep.

Output:
<NBOOK>
intent: task.create
owner: Grace
due: May 20
priority: normal
task: finish demo prep
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Put finish hiring plan on Rita's task list for today with high priority.

Output:
<NBOOK>
intent: task.create
owner: Rita
due: today
priority: high
task: finish hiring plan
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a high priority task for Jon due today: finish travel receipts.

Output:
<NBOOK>
intent: task.create
owner: Jon
due: today
priority: high
task: finish travel receipts
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Please nudge Fatima today at 9 AM about the customer notes.

Output:
<NBOOK>
intent: reminder.create
recipient: Fatima
date: today
time: 09:00
task: review customer notes
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Please nudge Grace the first business day of next month at noon about the launch checklist.

Output:
<NBOOK>
intent: reminder.create
recipient: Grace
date: the first business day of next month
time: 12:00
task: review launch checklist
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Please nudge Eli June 3 at 8 AM about the quarterly metrics.

Output:
<NBOOK>
intent: reminder.create
recipient: Eli
date: June 3
time: 08:00
task: review quarterly metrics
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Book a meeting with Iris and Lena on June 3 at 3:15 PM about security audit.

Output:
<NBOOK>
intent: calendar.create
attendees: Iris, Lena
date: June 3
time: 15:15
topic: security audit
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Send Hugo a message next Tuesday at 8 AM: hiring plan.

Output:
<NBOOK>
intent: email.send
recipient: Hugo
date: next Tuesday
time: 08:00
topic: hiring plan
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a Personal note titled vendor contract with tag vendor.

Output:
<NBOOK>
intent: note.create
notebook: Personal
title: vendor contract
tag: vendor
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Set a reminder for Dana at 2 PM on next Tuesday: check the security audit.

Output:
<NBOOK>
intent: reminder.create
recipient: Dana
date: next Tuesday
time: 14:00
task: review security audit
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: File a note under Operations: title vendor contract, tag vendor.

Output:
<NBOOK>
intent: note.create
notebook: Operations
title: vendor contract
tag: vendor
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a high priority task for Ben due next Monday: finish invoice follow-up.

Output:
<NBOOK>
intent: task.create
owner: Ben
due: next Monday
priority: high
task: finish invoice follow-up
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Save a note in Personal called hiring plan tagged hiring.

Output:
<NBOOK>
intent: note.create
notebook: Personal
title: hiring plan
tag: hiring
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Book a meeting with Lena and Iris on next Tuesday at 9 AM about quarterly metrics.

Output:
<NBOOK>
intent: calendar.create
attendees: Lena, Iris
date: next Tuesday
time: 09:00
topic: quarterly metrics
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Email Eli on Friday at 9 AM about the vendor contract.

Output:
<NBOOK>
intent: email.send
recipient: Eli
date: Friday
time: 09:00
topic: vendor contract
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Schedule Rita and Carla for Friday at 8 AM to discuss launch checklist.

Output:
<NBOOK>
intent: calendar.create
attendees: Rita, Carla
date: Friday
time: 08:00
topic: launch checklist
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Put finish budget review on Noah's task list for June 3 with high priority.

Output:
<NBOOK>
intent: task.create
owner: Noah
due: June 3
priority: high
task: finish budget review
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a high priority task for Fatima due next Tuesday: finish launch checklist.

Output:
<NBOOK>
intent: task.create
owner: Fatima
due: next Tuesday
priority: high
task: finish launch checklist
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Send Eli a message next Monday at 5 PM: launch checklist.

Output:
<NBOOK>
intent: email.send
recipient: Eli
date: next Monday
time: 17:00
topic: launch checklist
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: File a note under Operations: title hiring plan, tag hiring.

Output:
<NBOOK>
intent: note.create
notebook: Operations
title: hiring plan
tag: hiring
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Set a reminder for Ana at 2 PM on next Monday: check the security audit.

Output:
<NBOOK>
intent: reminder.create
recipient: Ana
date: next Monday
time: 14:00
task: review security audit
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Email Fatima on next Monday at noon about the security audit.

Output:
<NBOOK>
intent: email.send
recipient: Fatima
date: next Monday
time: 12:00
topic: security audit
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Set a reminder for Grace at 9 AM on Friday: check the budget review.

Output:
<NBOOK>
intent: reminder.create
recipient: Grace
date: Friday
time: 09:00
task: review budget review
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Send Dana a message the first business day of next month at noon: quarterly metrics.

Output:
<NBOOK>
intent: email.send
recipient: Dana
date: the first business day of next month
time: 12:00
topic: quarterly metrics
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule Eli and Grace for the first business day of next month at 3:15 PM to discuss quarterly metrics.

Output:
<NBOOK>
intent: calendar.create
attendees: Eli, Grace
date: the first business day of next month
time: 15:15
topic: quarterly metrics
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: File a note under Finance: title vendor contract, tag vendor.

Output:
<NBOOK>
intent: note.create
notebook: Finance
title: vendor contract
tag: vendor
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Set a reminder for Rita at 5 PM on May 20: check the vendor contract.

Output:
<NBOOK>
intent: reminder.create
recipient: Rita
date: May 20
time: 17:00
task: review vendor contract
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a Work note titled vendor contract with tag vendor.

Output:
<NBOOK>
intent: note.create
notebook: Work
title: vendor contract
tag: vendor
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Put finish quarterly metrics on Lena's task list for Friday with urgent priority.

Output:
<NBOOK>
intent: task.create
owner: Lena
due: Friday
priority: urgent
task: finish quarterly metrics
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Remind Carla on the first business day of next month at 8 AM to review the demo prep.

Output:
<NBOOK>
intent: reminder.create
recipient: Carla
date: the first business day of next month
time: 08:00
task: review demo prep
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Add task for Eli, due June 3, priority high, to finish budget review.

Output:
<NBOOK>
intent: task.create
owner: Eli
due: June 3
priority: high
task: finish budget review
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a high priority task for Fatima due next Monday: finish travel receipts.

Output:
<NBOOK>
intent: task.create
owner: Fatima
due: next Monday
priority: high
task: finish travel receipts
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Save a note in Product called invoice follow-up tagged invoice.

Output:
<NBOOK>
intent: note.create
notebook: Product
title: invoice follow-up
tag: invoice
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Set a reminder for Bruno at 3:15 PM on May 20: check the launch checklist.

Output:
<NBOOK>
intent: reminder.create
recipient: Bruno
date: May 20
time: 15:15
task: review launch checklist
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Add task for Dana, due Friday, priority low, to finish launch checklist.

Output:
<NBOOK>
intent: task.create
owner: Dana
due: Friday
priority: low
task: finish launch checklist
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Put finish vendor contract on Jon's task list for June 3 with urgent priority.

Output:
<NBOOK>
intent: task.create
owner: Jon
due: June 3
priority: urgent
task: finish vendor contract
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Book a meeting with Rita and Fatima on next Tuesday at 9 AM about invoice follow-up.

Output:
<NBOOK>
intent: calendar.create
attendees: Rita, Fatima
date: next Tuesday
time: 09:00
topic: invoice follow-up
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a urgent priority task for Hugo due Friday: finish customer notes.

Output:
<NBOOK>
intent: task.create
owner: Hugo
due: Friday
priority: urgent
task: finish customer notes
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Book a meeting with Iris and Fatima on next Monday at 8 AM about hiring plan.

Output:
<NBOOK>
intent: calendar.create
attendees: Iris, Fatima
date: next Monday
time: 08:00
topic: hiring plan
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Book a meeting with Fatima and Rita on the first business day of next month at 9 AM about travel receipts.

Output:
<NBOOK>
intent: calendar.create
attendees: Fatima, Rita
date: the first business day of next month
time: 09:00
topic: travel receipts
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Set a reminder for Sofia at 5 PM on Friday: check the budget review.

Output:
<NBOOK>
intent: reminder.create
recipient: Sofia
date: Friday
time: 17:00
task: review budget review
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Send Marta a message the first business day of next month at 3:15 PM: launch checklist.

Output:
<NBOOK>
intent: email.send
recipient: Marta
date: the first business day of next month
time: 15:15
topic: launch checklist
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: File a note under Product: title hiring plan, tag hiring.

Output:
<NBOOK>
intent: note.create
notebook: Product
title: hiring plan
tag: hiring
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Save a note in Operations called travel receipts tagged travel.

Output:
<NBOOK>
intent: note.create
notebook: Operations
title: travel receipts
tag: travel
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Email Bruno on next Monday at noon about the hiring plan.

Output:
<NBOOK>
intent: email.send
recipient: Bruno
date: next Monday
time: 12:00
topic: hiring plan
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Send Marta a message the first business day of next month at 10:30 AM: travel receipts.

Output:
<NBOOK>
intent: email.send
recipient: Marta
date: the first business day of next month
time: 10:30
topic: travel receipts
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Remind Iris on June 3 at 9 AM to review the budget review.

Output:
<NBOOK>
intent: reminder.create
recipient: Iris
date: June 3
time: 09:00
task: review budget review
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule Sofia and Carla for today at 8 AM to discuss demo prep.

Output:
<NBOOK>
intent: calendar.create
attendees: Sofia, Carla
date: today
time: 08:00
topic: demo prep
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Add task for Jon, due the first business day of next month, priority urgent, to finish invoice follow-up.

Output:
<NBOOK>
intent: task.create
owner: Jon
due: the first business day of next month
priority: urgent
task: finish invoice follow-up
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Put finish hiring plan on Grace's task list for June 3 with normal priority.

Output:
<NBOOK>
intent: task.create
owner: Grace
due: June 3
priority: normal
task: finish hiring plan
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Book a meeting with Jon and Rita on next Tuesday at 9 AM about quarterly metrics.

Output:
<NBOOK>
intent: calendar.create
attendees: Jon, Rita
date: next Tuesday
time: 09:00
topic: quarterly metrics
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: File a note under Personal: title customer notes, tag customer.

Output:
<NBOOK>
intent: note.create
notebook: Personal
title: customer notes
tag: customer
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Remind Grace on Friday at 3:15 PM to review the invoice follow-up.

Output:
<NBOOK>
intent: reminder.create
recipient: Grace
date: Friday
time: 15:15
task: review invoice follow-up
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Save a note in Product called launch checklist tagged launch.

Output:
<NBOOK>
intent: note.create
notebook: Product
title: launch checklist
tag: launch
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a low priority task for Lena due Friday: finish demo prep.

Output:
<NBOOK>
intent: task.create
owner: Lena
due: Friday
priority: low
task: finish demo prep
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule Sofia and Hugo for next Tuesday at 2 PM to discuss invoice follow-up.

Output:
<NBOOK>
intent: calendar.create
attendees: Sofia, Hugo
date: next Tuesday
time: 14:00
topic: invoice follow-up
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Schedule an email to Hugo for tomorrow at 5 PM regarding customer notes.

Output:
<NBOOK>
intent: email.send
recipient: Hugo
date: tomorrow
time: 17:00
topic: customer notes
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a urgent priority task for Grace due June 3: finish security audit.

Output:
<NBOOK>
intent: task.create
owner: Grace
due: June 3
priority: urgent
task: finish security audit
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a calendar event today at 10:30 AM with Ana, Hugo: quarterly metrics.

Output:
<NBOOK>
intent: calendar.create
attendees: Ana, Hugo
date: today
time: 10:30
topic: quarterly metrics
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Set a reminder for Dana at 3:15 PM on today: check the travel receipts.

Output:
<NBOOK>
intent: reminder.create
recipient: Dana
date: today
time: 15:15
task: review travel receipts
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a Personal note titled quarterly metrics with tag quarterly.

Output:
<NBOOK>
intent: note.create
notebook: Personal
title: quarterly metrics
tag: quarterly
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a Work note titled quarterly metrics with tag quarterly.

Output:
<NBOOK>
intent: note.create
notebook: Work
title: quarterly metrics
tag: quarterly
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Send Bruno a message May 20 at 5 PM: launch checklist.

Output:
<NBOOK>
intent: email.send
recipient: Bruno
date: May 20
time: 17:00
topic: launch checklist
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Save a note in Research called launch checklist tagged launch.

Output:
<NBOOK>
intent: note.create
notebook: Research
title: launch checklist
tag: launch
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Add task for Sofia, due next Monday, priority normal, to finish customer notes.

Output:
<NBOOK>
intent: task.create
owner: Sofia
due: next Monday
priority: normal
task: finish customer notes
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a calendar event Friday at 9 AM with Bruno, Iris: travel receipts.

Output:
<NBOOK>
intent: calendar.create
attendees: Bruno, Iris
date: Friday
time: 09:00
topic: travel receipts
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a Research note titled invoice follow-up with tag invoice.

Output:
<NBOOK>
intent: note.create
notebook: Research
title: invoice follow-up
tag: invoice
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: File a note under Product: title invoice follow-up, tag invoice.

Output:
<NBOOK>
intent: note.create
notebook: Product
title: invoice follow-up
tag: invoice
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a Product note titled security audit with tag security.

Output:
<NBOOK>
intent: note.create
notebook: Product
title: security audit
tag: security
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Set a reminder for Ben at noon on Friday: check the budget review.

Output:
<NBOOK>
intent: reminder.create
recipient: Ben
date: Friday
time: 12:00
task: review budget review
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Put finish vendor contract on Fatima's task list for today with high priority.

Output:
<NBOOK>
intent: task.create
owner: Fatima
due: today
priority: high
task: finish vendor contract
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a calendar event May 20 at 2 PM with Eli, Ana: quarterly metrics.

Output:
<NBOOK>
intent: calendar.create
attendees: Eli, Ana
date: May 20
time: 14:00
topic: quarterly metrics
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Schedule an email to Iris for today at noon regarding demo prep.

Output:
<NBOOK>
intent: email.send
recipient: Iris
date: today
time: 12:00
topic: demo prep
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a calendar event Friday at 3:15 PM with Noah, Jon: budget review.

Output:
<NBOOK>
intent: calendar.create
attendees: Noah, Jon
date: Friday
time: 15:15
topic: budget review
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: File a note under Work: title security audit, tag security.

Output:
<NBOOK>
intent: note.create
notebook: Work
title: security audit
tag: security
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Schedule Iris and Noah for tomorrow at noon to discuss customer notes.

Output:
<NBOOK>
intent: calendar.create
attendees: Iris, Noah
date: tomorrow
time: 12:00
topic: customer notes
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Set a reminder for Hugo at 8 AM on June 3: check the customer notes.

Output:
<NBOOK>
intent: reminder.create
recipient: Hugo
date: June 3
time: 08:00
task: review customer notes
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Set a reminder for Lena at 5 PM on next Monday: check the security audit.

Output:
<NBOOK>
intent: reminder.create
recipient: Lena
date: next Monday
time: 17:00
task: review security audit
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Add task for Iris, due next Tuesday, priority urgent, to finish customer notes.

Output:
<NBOOK>
intent: task.create
owner: Iris
due: next Tuesday
priority: urgent
task: finish customer notes
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Email Dana on tomorrow at 2 PM about the invoice follow-up.

Output:
<NBOOK>
intent: email.send
recipient: Dana
date: tomorrow
time: 14:00
topic: invoice follow-up
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Create a calendar event next Tuesday at 10:30 AM with Lena, Ana: quarterly metrics.

Output:
<NBOOK>
intent: calendar.create
attendees: Lena, Ana
date: next Tuesday
time: 10:30
topic: quarterly metrics
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Save a note in Product called quarterly metrics tagged quarterly.

Output:
<NBOOK>
intent: note.create
notebook: Product
title: quarterly metrics
tag: quarterly
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Put finish budget review on Dana's task list for next Tuesday with low priority.

Output:
<NBOOK>
intent: task.create
owner: Dana
due: next Tuesday
priority: low
task: finish budget review
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a urgent priority task for Bruno due today: finish security audit.

Output:
<NBOOK>
intent: task.create
owner: Bruno
due: today
priority: urgent
task: finish security audit
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Send Bruno a message next Monday at 5 PM: travel receipts.

Output:
<NBOOK>
intent: email.send
recipient: Bruno
date: next Monday
time: 17:00
topic: travel receipts
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Add task for Sofia, due tomorrow, priority low, to finish launch checklist.

Output:
<NBOOK>
intent: task.create
owner: Sofia
due: tomorrow
priority: low
task: finish launch checklist
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Email Iris on next Tuesday at 8 AM about the customer notes.

Output:
<NBOOK>
intent: email.send
recipient: Iris
date: next Tuesday
time: 08:00
topic: customer notes
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Email Dana on next Monday at noon about the launch checklist.

Output:
<NBOOK>
intent: email.send
recipient: Dana
date: next Monday
time: 12:00
topic: launch checklist
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a high priority task for Ana due next Tuesday: finish security audit.

Output:
<NBOOK>
intent: task.create
owner: Ana
due: next Tuesday
priority: high
task: finish security audit
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Email Jon on the first business day of next month at noon about the hiring plan.

Output:
<NBOOK>
intent: email.send
recipient: Jon
date: the first business day of next month
time: 12:00
topic: hiring plan
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Add task for Fatima, due today, priority normal, to finish budget review.

Output:
<NBOOK>
intent: task.create
owner: Fatima
due: today
priority: normal
task: finish budget review
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Save a note in Operations called demo prep tagged demo.

Output:
<NBOOK>
intent: note.create
notebook: Operations
title: demo prep
tag: demo
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Schedule an email to Iris for June 3 at 9 AM regarding demo prep.

Output:
<NBOOK>
intent: email.send
recipient: Iris
date: June 3
time: 09:00
topic: demo prep
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Email Ben on next Tuesday at 8 AM about the invoice follow-up.

Output:
<NBOOK>
intent: email.send
recipient: Ben
date: next Tuesday
time: 08:00
topic: invoice follow-up
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Remind Ben on May 20 at 8 AM to review the travel receipts.

Output:
<NBOOK>
intent: reminder.create
recipient: Ben
date: May 20
time: 08:00
task: review travel receipts
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Schedule Dana and Fatima for today at 2 PM to discuss customer notes.

Output:
<NBOOK>
intent: calendar.create
attendees: Dana, Fatima
date: today
time: 14:00
topic: customer notes
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Put finish demo prep on Noah's task list for today with urgent priority.

Output:
<NBOOK>
intent: task.create
owner: Noah
due: today
priority: urgent
task: finish demo prep
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Schedule Carla and Iris for next Monday at 10:30 AM to discuss hiring plan.

Output:
<NBOOK>
intent: calendar.create
attendees: Carla, Iris
date: next Monday
time: 10:30
topic: hiring plan
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Email Hugo on May 20 at 5 PM about the vendor contract.

Output:
<NBOOK>
intent: email.send
recipient: Hugo
date: May 20
time: 17:00
topic: vendor contract
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Schedule Ben and Iris for next Tuesday at noon to discuss invoice follow-up.

Output:
<NBOOK>
intent: calendar.create
attendees: Ben, Iris
date: next Tuesday
time: 12:00
topic: invoice follow-up
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Please nudge Eli Friday at 10:30 AM about the launch checklist.

Output:
<NBOOK>
intent: reminder.create
recipient: Eli
date: Friday
time: 10:30
task: review launch checklist
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Email Iris on June 3 at 2 PM about the hiring plan.

Output:
<NBOOK>
intent: email.send
recipient: Iris
date: June 3
time: 14:00
topic: hiring plan
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Send Ana a message tomorrow at 2 PM: vendor contract.

Output:
<NBOOK>
intent: email.send
recipient: Ana
date: tomorrow
time: 14:00
topic: vendor contract
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Create a calendar event the first business day of next month at noon with Lena, Rita: travel receipts.

Output:
<NBOOK>
intent: calendar.create
attendees: Lena, Rita
date: the first business day of next month
time: 12:00
topic: travel receipts
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: File a note under Operations: title travel receipts, tag travel.

Output:
<NBOOK>
intent: note.create
notebook: Operations
title: travel receipts
tag: travel
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Send Noah a message June 3 at noon: launch checklist.

Output:
<NBOOK>
intent: email.send
recipient: Noah
date: June 3
time: 12:00
topic: launch checklist
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a high priority task for Jon due May 20: finish security audit.

Output:
<NBOOK>
intent: task.create
owner: Jon
due: May 20
priority: high
task: finish security audit
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Put finish launch checklist on Ana's task list for June 3 with urgent priority.

Output:
<NBOOK>
intent: task.create
owner: Ana
due: June 3
priority: urgent
task: finish launch checklist
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Add task for Bruno, due the first business day of next month, priority normal, to finish demo prep.

Output:
<NBOOK>
intent: task.create
owner: Bruno
due: the first business day of next month
priority: normal
task: finish demo prep
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Send Eli a message tomorrow at 3:15 PM: invoice follow-up.

Output:
<NBOOK>
intent: email.send
recipient: Eli
date: tomorrow
time: 15:15
topic: invoice follow-up
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Schedule an email to Carla for May 20 at 5 PM regarding budget review.

Output:
<NBOOK>
intent: email.send
recipient: Carla
date: May 20
time: 17:00
topic: budget review
</NBOOK>


Instruction: Translate this task into NotebookOps format.

Input: Add task for Iris, due the first business day of next month, priority urgent, to finish demo prep.

Output:
<NBOOK>
intent: task.create
owner: Iris
due: the first business day of next month
priority: urgent
task: finish demo prep
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Send Ben a message Friday at noon: travel receipts.

Output:
<NBOOK>
intent: email.send
recipient: Ben
date: Friday
time: 12:00
topic: travel receipts
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Create a calendar event next Tuesday at 10:30 AM with Iris, Ben: invoice follow-up.

Output:
<NBOOK>
intent: calendar.create
attendees: Iris, Ben
date: next Tuesday
time: 10:30
topic: invoice follow-up
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Create a Operations note titled vendor contract with tag vendor.

Output:
<NBOOK>
intent: note.create
notebook: Operations
title: vendor contract
tag: vendor
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Book a meeting with Iris and Ana on next Monday at 9 AM about travel receipts.

Output:
<NBOOK>
intent: calendar.create
attendees: Iris, Ana
date: next Monday
time: 09:00
topic: travel receipts
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Set a reminder for Ana at 2 PM on the first business day of next month: check the travel receipts.

Output:
<NBOOK>
intent: reminder.create
recipient: Ana
date: the first business day of next month
time: 14:00
task: review travel receipts
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Remind Sofia on next Tuesday at 5 PM to review the customer notes.

Output:
<NBOOK>
intent: reminder.create
recipient: Sofia
date: next Tuesday
time: 17:00
task: review customer notes
</NBOOK>


Instruction: Rewrite the request as NotebookOps.

Input: Remind Carla on Friday at 8 AM to review the vendor contract.

Output:
<NBOOK>
intent: reminder.create
recipient: Carla
date: Friday
time: 08:00
task: review vendor contract
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: Set a reminder for Rita at 2 PM on next Tuesday: check the demo prep.

Output:
<NBOOK>
intent: reminder.create
recipient: Rita
date: next Tuesday
time: 14:00
task: review demo prep
</NBOOK>


Instruction: Return only the NotebookOps record for this request.

Input: Save a note in Work called vendor contract tagged vendor.

Output:
<NBOOK>
intent: note.create
notebook: Work
title: vendor contract
tag: vendor
</NBOOK>


Instruction: Convert this request to NotebookOps.

Input: File a note under Personal: title security audit, tag security.

Output:
<NBOOK>
intent: note.create
notebook: Personal
title: security audit
tag: security
</NBOOK>