Skip to main content
Goal: Build a structured schedule for tomorrow by combining your calendar, task list, priorities, and preferences — then block time once you approve. Tools Required: Google Calendar, CORE Memory. Optional: Todoist or Google Tasks.

​
Step 1 — Load Context in Parallel

Run all of the following simultaneously:
  • Calendar: Fetch tomorrow’s events. For each event extract: time, title, attendees, type (internal / external), duration.
  • Memory: Run the following searches simultaneously:
    • “current week priorities goals and planning”
    • “user’s scheduling preferences — when they prefer to work, start time, end time”
    • “user’s deep work preferences — preferred time of day, block length, focus conditions”
    • “user’s lunch and meal preferences — timing, duration, break habits”
  • Tasks (if connected): Check if Todoist or Google Tasks is connected. If yes, fetch all tasks from available lists including comments. If not connected, skip silently.
How to use memory results:
  • If scheduling preferences are found → use them to anchor the day’s start/end time and slot placement
  • If deep work preferences are found → use preferred time of day and block length when building the schedule
  • If meal/break preferences are found → use preferred lunch time and break durations instead of defaults
  • If nothing is found for any preference → silently fall back to defaults (8hr day, deep work stacked in morning, 1.5hrs meals/breaks). Do not tell the user what’s missing.

​
Step 2 — Ask Two Questions

Before building the plan, ask:
  1. “What do you want to work on tomorrow? Anything specific you want prioritised?”
  2. If memory has no clear current-week goals or priorities → also ask: “What are your top goals or priorities this week? I want to make sure the plan reflects what actually moves the needle.”
Wait for response before proceeding.
If the user mentions any scheduling, deep work, or meal preferences during the conversation (e.g. “I usually start at 9am” or “I don’t do deep work after 3pm”) → store them in memory immediately for future runs.

​
Step 3 — Compile the Task List

Build the list of things to plan around from all available sources: Always include:
  • What the user said in Step 2 (treat this as highest signal)
  • Any tasks or priorities found in memory from recent conversations
Include if task tool is connected:
  • Tasks that are overdue, Priority 1, Priority 2, or due tomorrow
  • Fetch comments on each task for additional context
If no task tool is connected, work purely from memory + Step 2 input. Do not tell the user something is missing — just plan with what you have.

​
Step 4 — Estimate Task Duration

For each item in the task list, estimate time required based on:
  • Task title and description
  • Keywords (e.g. “review”, “write”, “fix”, “call”, “research”)
  • Comments (if available from task tool)
  • Memory of similar tasks done in the past

​
Step 5 — Calculate Available Time

Total day = 8 hours Existing meetings = [sum from Step 1] Buffer (adhoc) = 20% of (15hrs - meeting hours) Meals + breaks = 1.5 hours (lunch + dinner + short breaks) Available for work = 15hrs - meetings - buffer - meals If total task time exceeds available time → flag overload (see Output Format).

​
Step 6 — Build the Schedule

Apply these rules when placing tasks: Deep work rules:
  • Stack deep work slots together — never fragment them across the day.
  • Keep 30 mins before any external meeting free.
  • Keep 15 mins after any external meeting free.
  • External meetings can be back-to-back — that’s fine.
Morning rule:
  • In the first block of the day (before lunch), prioritise high-priority tasks that take less than 1 hour. Goal: get a few quick wins done before midday.
Meal/break rule:
  • Include 1.5 hrs total spread across lunch, dinner, and short breaks. Place at natural breakpoints — never in the middle of a deep work slot.
Buffer rule:
  • Keep 20% of available time unscheduled. Do not fill it with tasks.

​
Step 7 — Assess the Plan (Be Blunt)

Before presenting, review what’s been prioritised against:
  • What the user said they want to work on (Step 2 input)
  • Current week goals and priorities (from memory or Step 2 input)
Call out misalignment directly. Examples of things to flag:
  • A lower-priority task is taking significant time while a higher-priority one is deprioritised
  • Admin or reactive work is crowding out high-leverage work
  • Something that feels productive but doesn’t move the needle this week
Be direct. This is a soundboard role — not just a scheduler.

​
Step 8 — Present the Plan

Show the full day as a structured list. Then ask for confirmation or adjustments before doing anything on the calendar. 📅 TOMORROW — [Date]

​
🗓 Existing Meetings ([X] hrs committed)

  • [Time] — [Title] ([Internal/External])

​
🧠 Proposed Schedule

  • [Time] — [Task / block name] (~[duration]) [Priority tag if applicable]
  • [Time] — 🍽 Lunch break (45 mins)
  • [Time] — [Task / block name] (~[duration])
  • [Time] — ☕ Short break (15 mins)
  • [Time] — [External meeting name] (prep 30 mins before is kept free)
  • [Time] — 🍽 Dinner break (30 mins)
  • [Time] — [Deep work block: Task A + Task B] (~[duration])

​
📊 Time Summary

  • Meetings: [X] hrs
  • Planned tasks: [X] hrs
  • Meals + breaks: 1.5 hrs
  • Buffer: [X] hrs (20%)
  • Total: [X] / 15 hrs

​
⚠️ Overload Warning (if applicable)

You have [X] hrs of work for [Y] hrs of available time. Deprioritised: [Task 1], [Task 2] — moved to backlog.

​
🔍 Priority Check

[Blunt assessment — is what’s planned actually the most important thing? Call out any misalignment between the schedule and what moves the needle this week.]

​
Step 9 — Confirm and Lock

Ask: “Does this look right? Any adjustments before I block this on your calendar?” Wait for confirmation. Accept edits. Re-present if needed. Once approved → create focus blocks on Google Calendar for all non-meeting slots in the plan. Do not create calendar events before explicit approval.