Skip to content

Morning Routine

Configurable morning routine that coordinates journal, tasks, contracts, calendar, and metacognition into a single briefing-first flow. Collect everything, then synthesize and act.

Workflow name: morning-routine

Execution: main

Steps

# ID Name Type Depends on
1 load-config Load morning config code
2 resolve-phases Resolve enabled phases code load-config
3 context-snapshot Collect fresh context snapshot code resolve-phases
4 sign-in Morning sign-in conversation reasoning context-snapshot
5 yesterday-close Close out yesterday's journal reasoning context-snapshot
6 calendar-today Fetch today's calendar schedule code context-snapshot
7 task-briefing Get task status summary code context-snapshot
8 contract-check Check contract health and constraints code context-snapshot
9 blindspot-scan Scan yesterday's work for blindspot patterns reasoning context-snapshot
10 synthesize Synthesize morning briefing reasoning sign-in, yesterday-close, calendar-today, task-briefing, contract-check, blindspot-scan
11 plan-today Plan today's focus and write to journal reasoning synthesize

Step instructions

context-snapshot

Purpose: Gather fresh context from all tracked systems. This is always the first step — everything downstream depends on it.

Phase gate: Always enabled (core). No skip check needed.

Procedure:

  1. Ensure today's journal exists. Call mcp__work-buddy__wb_run("journal_state", {"target": "today"}) — if the result shows exists: false, the journal needs creating via Obsidian.

  2. Get the configured lookback window: hours = step_results["load-config"].get("morning", {}).get("context_hours", 24) (default: 24).

  3. Run the context bundle collector: 

    `mcp__work-buddy__wb_run("context_bundle", {"hours": <hours>})`

  4. Read the resulting pack files from the bundle path returned in the result. Priority files: git_summary.md, tasks_summary.md, projects_summary.md, obsidian_summary.md, messages_summary.md, chat_summary.md, calendar_summary.md, wellness_summary.md.

  5. Condense into a structured activity digest — not the raw pack, but a ~20 line summary of: what repos had activity, what journal entries exist, outstanding tasks, recent conversations, messages.

Result: Condensed activity digest string.

sign-in

Purpose: Brief morning check-in that fills the journal Sign-In fields. Always enabled.

Agentic step. The agent conducts a conversational check-in and writes responses to the journal. Behavioral instructions (conversation tone, what to ask, how to use wellness data) are in the slash command, not here.

Procedure:

  1. Read current sign-in state and wellness trends: 

    `mcp__work-buddy__wb_run("journal_sign_in")`
    Returns {sign_in: {sleep, energy, mood, check_in, motto, all_filled}, wellness: "..."}.

  2. If sign_in.all_filled: Return {"summary": "Sign-in already complete. Sleep: X, Energy: X, Mood: X", "wellness_context": wellness}.

  3. If NOT all filled: Conduct check-in conversation for missing fields.

  4. Write responses to the journal: 

    `mcp__work-buddy__wb_run("journal_sign_in", {"write_fields": "{\"sleep\": 7, \"energy\": 8, \"mood\": 7, \"check_in\": \"...\", \"motto\": \"...\"}"})`
    This is consent-gated — on consent_required response, follow the standard consent flow.

  5. Return {"summary": "...", "wellness_context": wellness} for downstream steps.

Result: Sign-in summary with wellness context.

yesterday-close

Purpose: Close out yesterday's journal by filling Log gaps.

Agentic step. The agent checks yesterday's journal and auto-fills gaps. Behavioral instructions (interaction rules) are in the slash command, not here.

Phase gate: Check step_results["resolve-phases"]["yesterday-close"]. If false, skip.

Procedure:

  1. Read yesterday's journal state: 

    `mcp__work-buddy__wb_run("journal_state", {"target": "yesterday"})`

  2. If error: Log the error and skip: {"skipped": true, "reason": error}.

  3. If ambiguous: Log a warning and skip.

  4. If NOT exists: Return {"skipped": true, "reason": "no journal for {date}"}.

  5. If exists: Check the journal content. If the Log section has 3+ entries, return {"summary": "Yesterday ({date}) has N log entries. Last: HH:MM AM/PM."}.

  6. If the Log is sparse (< 3 entries): Delegate to update-journal workflow: mcp__work-buddy__wb_run("update-journal", {"target": "yesterday"}) and advance to completion. Return the summary.

Result: Brief summary string describing yesterday's state.

calendar-today

Purpose: Fetch today's Google Calendar schedule.

Phase gate: Check step_results["resolve-phases"]["calendar-today"]. If false, skip.

Procedure:

  1. Fetch today's calendar (includes readiness check): 

    `mcp__work-buddy__wb_run("context_calendar")`

  2. If the result indicates unavailability, return {"available": false, "reason": "Calendar not available"}. Do NOT fail — graceful degradation.

  3. Otherwise return the calendar data.

Result: Calendar data or unavailability notice.

task-briefing

Purpose: Get current task status.

Phase gate: Check step_results["resolve-phases"]["task-briefing"]. If false, skip.

Procedure: 

`mcp__work-buddy__wb_run("task_briefing")`
Return the result directly.

Result: Task briefing data dict.

contract-check

Purpose: Check contract health, active constraints, and deadlines.

Phase gate: Check step_results["resolve-phases"]["contract-check"]. If false, skip.

Procedure:

  1. mcp__work-buddy__wb_run("contract_constraints") — active contracts with bottleneck constraints.
  2. mcp__work-buddy__wb_run("contract_health") — health check report.
  3. Combine into a single result dict with active_count, constraints, health, top_constraint, has_paper_contract.
  4. If no active contracts exist, note it explicitly.

Result: Combined contract data dict.

blindspot-scan

Purpose: Check yesterday's work against metacognition patterns.

Phase gate: Check step_results["resolve-phases"]["blindspot-scan"]. If false, skip.

Procedure depends on step_results["load-config"]["morning"]["blindspot_depth"]:

Light mode (default)

Agentic step. The agent scans for HIGH-severity patterns using context-snapshot and yesterday-close data. Behavioral instructions (pattern list, what to look for) are in the slash command, not here.

Return a brief summary: either "None detected" or a list of pattern names with one-line evidence.

Full mode

Delegate to the detect-blindspots workflow: mcp__work-buddy__wb_run("detect-blindspots"). Return the full result.

Result: Pattern summary string or full blindspot report.

synthesize

Purpose: Combine all collected data into a concise morning briefing.

Agentic step. The agent builds a briefing from all prior step results and presents it. Behavioral instructions (tone, follow-up offers, presentation style) are in the slash command, not here.

Procedure:

  1. Gather results from all prior steps. For skipped/failed steps, the result will be None or contain {"skipped": true} — handle gracefully.

  2. Build a briefing. Use work_buddy.morning.format_briefing() if available: 

    from work_buddy.morning import format_briefing

results = {
    "yesterday": yesterday_close_result.get("summary") if yesterday_close_result else None,
    "calendar": calendar_result if calendar_result and not calendar_result.get("skipped") else None,
    "tasks": task_result if task_result and not task_result.get("skipped") else None,
    "contracts": contract_result if contract_result and not contract_result.get("skipped") else None,
    "projects": context_snapshot_result.get("projects_summary") if context_snapshot_result else None,
    "blindspots": blindspot_result if blindspot_result and not blindspot_result.get("skipped") else None,
}
briefing_md = format_briefing(results)
    Alternatively, synthesize the briefing directly from step results.

  3. Present the briefing and offer follow-ups.

  4. Return {"briefing_md": briefing_md, "results": results} for plan-today.

Result: Briefing markdown and underlying data.

plan-today

Purpose: Propose today's Most Important Tasks, create them, generate a Day Planner schedule, and persist the briefing.

Agentic step. The agent proposes MITs, creates tasks, writes to journal, and generates a day plan. Behavioral instructions (MIT quality rules, user review, presentation) are in the slash command, not here.

Procedure:

  1. Using the synthesized briefing and underlying data, propose up to step_results["load-config"]["morning"]["max_mits"] MITs.

  2. Present the proposed MITs to the user for review.

  3. Create MIT tasks in the master task list: 

    `mcp__work-buddy__wb_run("task_create", {"task_text": "...", "urgency": "medium", "project": "...", "due_date": "...", "contract": "..."})`
    Then set each created task to focused: 
    `mcp__work-buddy__wb_run("task_change_state", {"task_id": "...", "state": "focused"})`
    This makes them appear in the journal's MITs Dataview query automatically.

  4. Journal persistence (if step_results["load-config"]["morning"]["persist_briefing"] is true):

Placement: The briefing callout goes in the Sign-In section, after the Motto field and before # **Tasks & Objectives**. The journal_write capability handles placement automatically. The callout header includes the generation timestamp.

`mcp__work-buddy__wb_run("journal_write", {"mode": "briefing", "briefing_md": "<briefing markdown>"})`
This is consent-gated — follow the standard consent flow on consent_required.

  1. Day Planner schedule (if step_results["load-config"]["morning"]["day_planner"]["enabled"] is true):

a. Check plugin readiness: 

`mcp__work-buddy__wb_run("day_planner", {"action": "status"})`
If not ready, log a warning and skip to step 6.

b. Check for existing plan entries (don't clobber user edits): 

`mcp__work-buddy__wb_run("day_planner", {"action": "read"})`
If entry_count > 0, skip — the user already has a plan.

c. Gather inputs: - Calendar events: from the synthesize step's results["calendar"]. If calendar was skipped/unavailable, use []. - Focused tasks: both the MITs just created in step 3 and any pre-existing focused tasks (from the task briefing data in results["tasks"]).

d. Check if plugin has remote calendar feeds configured. If hasRemoteCalendars in status, set include_calendar_events: false in config overrides to avoid duplication.

e. Generate and write the plan: 

`mcp__work-buddy__wb_run("day_planner", {"action": "generate_and_write", "calendar_events": "<json>", "focused_tasks": "<json>"})`

f. Present a brief plan summary to the user (timed blocks for the day).

  1. Confirm what was created and where.

Result: Final MITs list, Day Planner schedule, and persistence confirmation.