Today

/today — Daily Workflow Orchestrator

Guides PMs through a structured daily routine: standup → team sync → review → focus → wrap-up. Reuses existing skill logic (/daily, /meet, /progress) — does NOT duplicate it.

Context

Today's date: !date +%Y-%m-%d Existing daily: !ls daily/*.md 2>/dev/null | tail -5

Config: @_core/config.yaml Processing logic: @_core/PROCESSING.md Daily template: @_templates/daily.md

Reference skills (for reuse patterns):

• @.claude/skills/daily/SKILL.md — keyword detection, blocker/decision logic
• @.claude/skills/meet/SKILL.md — meeting note parsing
• @.claude/skills/progress/SKILL.md — dashboard aggregation

Input

User input: $ARGUMENTS

Argument Handling

• No args: Start from Phase 1, or resume current phase (detect via TaskList)
• status: Show which phase is currently active
• skip: Skip current phase, advance to next
• wrap: Jump directly to Phase 5 (wrap-up)

Session Task Progress

Create all phase tasks upfront with dependencies:

Copy code
TaskCreate: "Phase 1: Daily Standup"
  description: "Capture updates for all active projects"
  activeForm: "Running daily standup..."

TaskCreate: "Phase 2: Team Sync"
  description: "Process external context (Slack, meetings, Linear)"
  activeForm: "Processing team sync..."

TaskCreate: "Phase 3: Review"
  description: "Display cross-project health dashboard"
  activeForm: "Generating review dashboard..."

TaskCreate: "Phase 4: Focus"
  description: "Display priorities and pause for deep work"
  activeForm: "Setting focus priorities..."

TaskCreate: "Phase 5: Wrap-Up"
  description: "Summarize the day"
  activeForm: "Wrapping up the day..."

Set dependencies:

Copy code
TaskUpdate: Phase 2, addBlockedBy: [phase-1-id]
TaskUpdate: Phase 3, addBlockedBy: [phase-2-id]
TaskUpdate: Phase 4, addBlockedBy: [phase-3-id]
TaskUpdate: Phase 5, addBlockedBy: [phase-4-id]

Resume Logic (Same Session Only)

Before creating tasks, check TaskList for existing /today phase tasks:

• If tasks exist with in_progress status → resume from that phase
• If Phase 4 was completed → start Phase 5 (wrap-up)
• If all phases completed or no tasks exist → start fresh from Phase 1

No persistent state files. The file system is the state — daily notes exist or they don't.

Phase 1: DAILY STANDUP (Interactive)

Purpose: Capture updates for all active projects.

Steps

1. Read _core/config.yaml → get active projects list

2. For each active project, prompt the user:

   Copy code
   {project_name}: What's your update? (shipped/wip/blocked)
   

3. Parse each response using keyword detection (from /daily skill):

   • Shipped: shipped, done, completed, finished, merged, deployed, released
   • WIP: wip, working on, in progress, continuing, started, ongoing
   • Blocked: blocked, stuck, waiting on, waiting for, need from, dependency
   • Decided: decided, going with, chose, selected, agreed

4. Create or update daily/{date}.md:

   • If file exists: update each project's ## {Project Name} section
   • If new: create from template with all project sections

5. Auto-detect blockers (per /daily logic):

   • For each blocked item: search blockers/{project}/*.md for similar open blockers
   • If similar exists: link to it
   • If NEW: prompt user — "Blocker detected: '{text}'. Create blocker note? (y/n/details)"
     • y: Create with severity=medium at blockers/{project}/{date}-{slug}.md
     • details: Prompt for severity, owner, due date
     • n: Skip

6. Auto-detect decisions:

   • For each decision keyword: suggest creating a decision note
   • Link to daily if user confirms

Output

Copy code
✓ Updated daily/{date}.md ({count} projects)
  - Shipped: {count} items
  - WIP: {count} items
  - Blockers: {count} (linked/created)
  - Decisions: {count} (detected)

Phase 2: TEAM SYNC (Interactive)

Purpose: Process external context (Slack threads, Linear updates, meeting notes).

Steps

1. Prompt the user:

   Copy code
   Any team updates, Slack threads, or meeting notes to process? (paste or 'skip')
   

2. If skip → mark phase complete, advance to Phase 3

3. If content provided:

   • Classify content type using keyword detection:
     • Meeting signals → route as meeting note (use /meet patterns)
     • Blocker signals → route as blocker
     • Decision signals → route as decision
     • General → route to inbox
   • Create appropriate notes with links
   • After processing, ask: "More to process? (paste or 'done')"
   • Loop until user says 'done' or 'skip'

Output

Copy code
✓ Team sync complete
  - Meeting notes: {count}
  - Blockers: {count}
  - Items routed: {count}

Phase 3: REVIEW (Auto-generated, Read-only)

Purpose: Display a cross-project health dashboard. No files created.

Steps

1. Scan vault and aggregate:

   • Open blockers: Glob blockers/{project}/*.md for each active project, read frontmatter for severity/due
   • Critical items: Blockers with due date < 2 days from today (per defaults.blocker_critical_days)
   • Active docs: Glob docs/{project}/*.md, filter status != shipped
   • Recent decisions: Glob decisions/{project}/*.md from last 3 days

2. Display formatted dashboard to terminal:

Copy code
┌─────────────────────────────────────┐
│  TODAY'S DASHBOARD — {date}         │
└─────────────────────────────────────┘

BLOCKERS (by severity)
  🔴 High ({count})
    • [{project}] {title} — due {date}

  🟡 Medium ({count})
    • [{project}] {title}

  🟢 Low ({count})
    • [{project}] {title}

  (None) — if no blockers exist

ACTIVE DOCS
  • [{project}] {title} — {status}

  (None) — if no active docs

RECENT DECISIONS (last 3 days)
  • [{project}] {title} — {date}

  (None) — if no recent decisions

Output

Dashboard displayed to terminal. No files created.

Phase 4: FOCUS (Display & Pause)

Purpose: Show priorities and let the user do deep work.

Steps

1. Extract priorities from today's daily note:

   • Top 3 WIP items across all projects
   • Critical blockers to address (from Phase 3 data)
   • Pending decisions (if any detected)

2. Display priority list:

Copy code
TODAY'S PRIORITIES
━━━━━━━━━━━━━━━━━━━━━━━━

1. [{project}] {wip item}
2. [{project}] {wip item}
3. [{project}] {wip item}

⚠ NEEDS ATTENTION
  • {critical blocker or pending decision}

━━━━━━━━━━━━━━━━━━━━━━━━
Focus time — run /today again when ready to wrap up

3. Mark Phase 4 as complete. Exit workflow. User returns when ready.

Phase 5: WRAP-UP (Auto-generated, Read-only)

Purpose: Summarize the day. No files created.

Steps

1. Re-read today's daily note (daily/{date}.md)

2. Scan for blockers created/resolved today

3. Scan for decisions made today

4. Display summary:

Copy code
TODAY'S SUMMARY — {date}
━━━━━━━━━━━━━━━━━━━━━━━━

SHIPPED ({count})
  • [{project}] {item}

IN PROGRESS ({count})
  • [{project}] {item}

BLOCKERS
  Created: {count}
  Resolved: {count}

DECISIONS MADE ({count})
  • [{project}] {title}

━━━━━━━━━━━━━━━━━━━━━━━━
Run /push to commit today's updates

Edge Cases

• No projects configured: Display error — "No active projects in config.yaml. Run /onboard to set up your first project."
• Empty vault (no daily note): Create fresh daily note in Phase 1
• No blockers/decisions/docs: Display "(None)" in dashboard sections
• User exits mid-phase: Session tasks preserve progress for same-session resume
• /today wrap with no daily note: Display message — "No daily note for today. Run /today to start your day first."

Graceful Degradation

• Linear MCP not connected: Skip auto-fetch, continue with paste-only in Team Sync
• QMD not available: Not needed (direct file scans only)
• Obsidian not running: No impact (terminal-only output)

Integration

Works with:

• /daily — Reuses keyword detection and blocker/decision logic
• /meet — Routes meeting content in Team Sync phase
• /progress — Similar dashboard pattern in Review phase
• /push — Suggested at wrap-up for committing changes
• /block — Blocker creation follows same patterns
• /decide — Decision creation follows same patterns