Monday Brief

Monday Brief

A forward-looking Monday morning briefing: synthesizes recent signal across all sources (manager DMs, calendar, action items, people context, prior weekly reports) into a "what's top of mind this week" document. Tells the user what to do for themselves and the team, what's at risk, and what they owe.

Distinct from how-can-i-help (which is retrospective — surfaces what's already fallen through cracks) and from the weekly-update skills (which are output artifacts for others to read). This is input: the user reads it, takes notes, walks into the week with a plan.

Config & cache locations

• User config: ${XDG_CONFIG_HOME:-$HOME/.config}/monday-brief/user.json (auto-bootstrapped from 1on1-prep config — same team roster)
• Output: /monday-briefs/monday-brief-.md
• Research cache: ${XDG_CACHE_HOME:-$HOME/.cache}/monday-brief//

Blast-radius table

| Action | Scope | When | |---|---|---| | Write ${XDG_CONFIG_HOME:-$HOME/.config}/monday-brief/user.json | Local | Phase 0 init only | | Write /monday-briefs/monday-brief-.md | Local | Phase 5 — path announced first | | Write research cache locally | Local | Phase 3 | | Read Outlook (email + calendar), Slack, Jira, GitHub, Confluence (action items page), local people-context files, prior weekly reports | Remote reads only | Phase 3 | | Write to Slack, send email, comment on tickets, modify any remote resource | Never | — |

Prerequisites

• Atlassian MCP (Jira + Confluence — for action items page)
• Slack MCP (DM-aware — slack_search_public_and_private mode)
• Outlook / M365 MCP (email + calendar)
• gh CLI authenticated with repo scope
• Existing 1on1-prep / action-item-sync configs (for team roster + action items page ID)
• People context files at /.md (loaded per direct report)

If any source is missing, the skill still runs and notes the gap inline.

Invocation

monday-brief                       # default — synthesize for the current/upcoming week
monday-brief           # explicit Monday date (e.g. 2026-05-25)
monday-brief --dry-run             # print without saving file

Also triggered automatically by a scheduled task (set up at Phase 6 — see "Scheduling" below).

Workflow

Phase 0 — Init / bootstrap config (only on first run)

Side effects: writes ${XDG_CONFIG_HOME:-$HOME/.config}/monday-brief/user.json.

1. Check for existing config. If absent:

• Bootstrap from ${XDG_CONFIG_HOME:-$HOME/.config}/1on1-prep/user.json (displayname, atlassianaccountid, slackuserid, githubusername, team.members[], manager, peers[], pronouns).
• Bootstrap action items page ID from ${XDG_CONFIG_HOME:-$HOME/.config}/action-item-sync/user.json.
• Pull workspace output_dir and people_dir from ${XDG_CONFIG_HOME:-$HOME/.config}/claude-skills/workspace.json (see _shared/workspace-config.md).

1. Confirm or collect: slack_search_mode (default public_and_private), prior_reports_lookback_days (default 7), output_dir for briefs (default /monday-briefs).
2. Announce the XDG path and write the config.

Phase 1 — Determine the week

Side effects: none.

1. Resolve the Monday in scope:

• Bare invocation → today if today is Monday; otherwise the nearest upcoming Monday.
• Explicit date → that Monday.

1. Window for synthesis = (previous Friday EOD) → (this Friday EOD) — i.e. the upcoming work week.
2. Lookback for signal = (this Monday minus prior_reports_lookback_days) → (this Monday) — captures recent DMs, action items, transcripts.
3. Announce: "Building Monday brief for week of `. Signal window: → . Forward window: → `."

Phase 2 — Map this week's calendar

Side effects: read-only Outlook calendar call.

Pull the user's calendar for the week (Mon → Fri inclusive). Surface:

• All scheduled 1:1s with team members, manager, peers (extracted from attendee_count == 2 and matched against team.members[] / manager / peers[]).
• Big visible meetings — anything with > 8 attendees, or with presentation / review / demo / standup keywords in the topic.
• Anything new to this week that wasn't on the calendar last Monday (only if a prior brief exists at /monday-brief-.md).
• Time blocks already booked — total hours of meetings this week, biggest free blocks.

Phase 3 — Research signal sources

Side effects: read-only across all sources. Writes cache under ${XDG_CACHE_HOME:-$HOME/.cache}/monday-brief//.

Announce sources up front: > Building brief for ``. Sources: Outlook (calendar + email this week + recent from manager + recent unread), Slack (DMs from manager + DMs with team members + AI champion channels + recent mentions), Jira (open tickets owned by user + open tickets owned by team), GitHub (open PRs by team), Confluence action items page, people context files, prior weekly reports.

Run sources in parallel; cache raw results.

Manager comms — highest signal. Look for:

• Recent DMs from manager (last 7 days) — anything you owe a response to
• Recent group DMs that include manager
• Outlook emails from manager (last 7 days) — any direct asks
• Heads-up signals — explicit announcements of upcoming reviews, presentations, calibration cycles, leadership meetings. Phrases to watch for: "next week", "heads up", "FYI", "headed your way", "you'll need to", "by EOW", "ahead of", "before [date]".

Action items page. Parse /tmp/action-item-sync-.adf.json if present (recent run), otherwise fetch the page fresh. Filter to:

• Items where owner == user.display_name AND status == Open → user's pending commitments
• Items added in the last 7 days regardless of owner → recent commitments worth re-confirming
• Items still Open and older than 14 days → stale items at risk of slipping

People context files. Load every /.md for direct reports. For each person, extract:

• Career & Promotion (active goals — these drive what to surface in 1:1s this week)
• Development Focus (what to ask about / observe)
• Recent Notes (anything dated within the last 14 days that needs follow-up)
• Sensitive Context (informs tone, NEVER quoted)

Jira. Open tickets across the team. Particularly:

• Tickets owned by user (often planning / management commitments)
• Tickets owned by team members that haven't moved in 7+ days (potential blockers)
• Anything labeled escalation / customer / urgent / similar

GitHub. Open PRs by team members in configured orgs. Particularly:

• PRs open > 5 days (potential review-bottleneck signal)
• Draft PRs from > 3 days ago (planning vs stalled signal)

Slack — beyond manager. Search the AI champion channels (#ai-champions, #team-devx-humans, similar) for the last 7 days for:

• Anything tagged or mentioning user
• Cross-team announcements (skip-level / leadership posts)

Prior weekly reports. Read the latest:

• AI weekly update Confluence row (current user's row from last week — what was published)
• Weekly Confluence Platform Automation row (DevX block)
• Exec email (/tmp/ai-exec-report-.eml or recent in Outlook sent)
• These provide continuity — "what did I say last week was in flight that should now be done?"

Optional: prior Monday brief. If /monday-brief-.md exists, load it. Compare:

• What was top-of-mind last week — still relevant? Closed? Drifted?
• What risks did last week's brief name — did they materialize?

Phase 4 — Synthesize the brief

Side effects: none — pure reasoning.

Produce a markdown brief following the structure in references/output-style.md. Summary:

1. Top of mind for the week — 2-4 things. Highest-signal items from manager DMs, calendar, action items. Be ruthlessly selective — these are the things the user must think about Monday morning. Cite the source explicitly (e.g. "from DM ").

2. Per-person — what to do for each report this week. Table format. For each direct report, one row with:

• Their week ahead (what's on their plate, from Jira/GitHub/calendar)
• Your move (per-person action drawing on people context + recent signal)

Exclude direct reports who are out of office this week. Mark self-reporting / promotion-track people with a flag if there's promotion-relevant evidence to capture.

3. Open action items you owe. From the action items page where owner == user AND status == Open. Order by age (oldest first). For each, note what blocks closing it.

4. Open items you owe responses on. From Slack DMs / email threads from manager and key stakeholders where user owes a reply. Be careful to distinguish "owes a response" from "thread is active." Look for direct asks unanswered.

5. Risks / things that could go sideways. Forward-looking. What in flight could break this week? Anything from Phase 3 sources that suggests a risk pattern:

• A meeting outcome that hasn't been reported
• A team member showing fatigue / over-commitment
• A dependency that hasn't moved
• A scheduled review or presentation needing prep

6. Quieter priorities to keep on radar. Things that are sustaining but worth not forgetting. One-liner each.

7. One-liner for the week. A single sentence framing the dominant move of the week. This is the most-read line of the brief.

Honest count rule: if a section has no real content, omit it. Don't pad. Better to have 3 strong sections than 7 weak ones.

Use the inline tag (needs decision), (overdue), (at risk), (in flight) etc. liberally — these scan well.

People context safety: Never quote Sensitive Context content. Use it only to adjust framing.

Phase 5 — Deliver

Side effects: writes /monday-brief-.md and prints inline.

1. Save the brief to /monday-brief-.md.
2. Print the full brief inline as the primary delivery — this is what the user reads at 9 AM Monday.
3. End with a clickable sidebar link: copy to /tmp/monday-brief-.md and render as [/tmp/monday-brief-.md](/tmp/monday-brief-.md).

After delivering: append a missing-sources note per _shared/missing-sources.md if any source was skipped or errored.

Phase 6 — Scheduling

Triggered automatically each Monday via a scheduled task. To set up:

schedule create monday-brief --cron "30 8 * * 1" --tz "America/New_York"

Or via the scheduled-tasks MCP. Recommended timing: Monday 8:30 AM in user's timezone, so the brief is ready when the user sits down at 9 AM with coffee.

The scheduled run is identical to the manual invocation — same output path, same prints. The point is the brief exists when the user opens their laptop on Monday, not that it gets pushed to them.

Safety rules

• Read-only remote. This skill never writes to Slack / email / Jira / GitHub / Confluence / calendar.
• No fabricated emotion. When framing per-person actions, refer to observable behavior, not invented internal state. The people-context files contain Sensitive Context — use that to adjust tone, never to quote.
• Source citations required. Every "top of mind" item must cite where the signal came from (Slack DM date, email subject, ticket key, calendar event). Without that, the user can't verify.
• Honest count. Empty sections get omitted. A short brief is a good brief.
• Pronouns. Per the people context file. If absent, use the person's name only. Never guess from name. See _shared/pronoun-handling.md.
• Don't double up. If a Monday morning calendar item already has a 1:1 prep brief at /1on1-prep--.md, the Monday brief references it but doesn't reproduce it.

Files in this skill

• references/data-sources.md — query patterns for each signal source
• references/output-style.md — section structure, tone, citation format
• config/user.example.json — config template (real user.json is gitignored)

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: actowery
• Source: actowery/claude-skills
• License: MIT

Install and usage instructions live in the source repository linked above.