cursor-chief-of-staff

Personal Assistant Dashboard

A Cursor-native AI personal assistant that lives entirely in markdown files. Works with Cursor, Claude Code, and any AI editor that reads a project's files.

Clone it, fill in your context (or let the AI do it for you), and you have a fully functional personal assistant in minutes.

---

What You Get

• Task management — inbox, today, active, backlog with a consistent format scripts can parse
• Meeting and 1-on-1 notes — structured templates with Notion sync
• Three-layer memory — session scratch (L1), active project context (L2), permanent knowledge (L3)
• Slash commands — /ask, /store, /review, /sleep, /observe, /selfimprove
• Subagents — daily digest, memory cleanup, workspace compaction
• Integrations — Slack, Notion, Google Workspace, Jira, GitHub via MCP
• Automation scripts — daily Slack briefing, memory cleanup (Python + uv, no venv needed)
• Self-improvement loop — the assistant captures lessons and proposes upgrades to itself

---

Quick Start

Step 1 — Clone and open

git clone https://github.com/YOUR_USERNAME/personal-assistant-template.git
cd personal-assistant-template

Open the folder in Cursor (or any AI editor). The rules and skills load automatically.

Step 2 — Fill in your context

Option A — Let the AI fill it for you (recommended):

Open Cursor, start a new chat, and say:

Help me set up my personal assistant context. Walk me through each file I need to fill in.

The assistant will guide you through role.md, team.md, meetings.md, and preferences.md conversationally, asking the right questions and writing the files for you.

Option B — Run the bootstrap script:

# Windows
powershell -ExecutionPolicy Bypass -File scripts\setup.ps1

# macOS / Linux
bash scripts/setup.sh

The script prompts for your name, replaces [YOUR_NAME] across all files, and creates your .env.

Option C — Fill manually using the table in Fill In Your Context below.

Step 3 — Start chatting

/ask what's my day look like?

---

Fill In Your Context

These files contain [placeholder] values. Fill them in once and the assistant knows who you are permanently.

File	What to fill in	Time
[context/work/role.md](context/work/role.md)	Your title, company, responsibilities, active projects, OKRs	~3 min
[context/work/team.md](context/work/team.md)	Team members, roles, emails, Slack handles	~3 min
[context/work/meetings.md](context/work/meetings.md)	Recurring meetings and 1-on-1 schedule	~3 min
[memory/L3-core/preferences.md](memory/L3-core/preferences.md)	Communication style, task habits, memory preferences	~2 min
[.cursor/rules/assistant-persona.mdc](.cursor/rules/assistant-persona.mdc)	Replace [YOUR_NAME] with your name	~30 sec

See [examples/](examples/) for pre-filled reference files showing what a completed setup looks like.

Tip: You don't have to fill these manually. Open Cursor and say "help me set up my assistant context" — it will walk you through each file conversationally, asking about your role, team, and preferences, and writing everything for you.

---

How It Works

flowchart TD
    User(["You"])

    subgraph cmds ["Commands (entry points)"]
        Ask["/ask"]
        Store["/store"]
        Review["/review"]
        Sleep["/sleep"]
        Observe["/observe"]
    end

    subgraph skills ["Skills (procedural logic)"]
        TM["task-management"]
        MN["meeting-notes"]
        BR["brainstorm"]
        SR["slack-report"]
        WH["workspace-hygiene"]
    end

    subgraph agents ["Subagents (autonomous)"]
        DD["daily-digest"]
        MC["memory-cleanup"]
        WC["workspace-compactor"]
    end

    subgraph files ["Your Files (plain markdown)"]
        Tasks["tasks/"]
        Memory["memory/ L1·L2·L3"]
        Notes["notes/"]
        Context["context/"]
        Reminders["reminders/"]
    end

    subgraph mcp ["MCP Integrations"]
        Slack["Slack"]
        Notion["Notion"]
        GW["Google Workspace"]
        Jira["Jira / Atlassian"]
    end

    User -->|"chat"| cmds
    Store --> skills
    Review --> skills
    Sleep --> agents
    Ask -->|"read-only"| files

    skills --> files
    agents --> files
    Observe --> mcp
    mcp --> Tasks
    SR --> Slack

The key design principle: you own all the data. Every task, note, memory, and preference is a plain markdown file you can read, edit, or delete. The AI orchestrates across them.

---

Repository Structure

personal-assistant-template/
├── .cursor/
│   ├── mcp.json                    # Project-level MCP config (Slack)
│   ├── rules/                      # Always-on AI behavior rules
│   │   ├── assistant-persona.mdc   # Session start, tone, memory routing
│   │   ├── memory-management.mdc   # L1/L2/L3 read/write rules
│   │   ├── meta-cursor-files.mdc   # Standards for .cursor/ files
│   │   ├── self-improvement.mdc    # Proactive lesson capture
│   │   └── task-and-notes-format.mdc # Standard formats for all files
│   ├── commands/                   # Slash commands
│   │   ├── ask.md                  # /ask — read-only briefing and search
│   │   ├── store.md                # /store — classify and save anything
│   │   ├── review.md               # /review — daily/weekly review
│   │   ├── sleep.md                # /sleep — full workspace compaction
│   │   ├── observe.md              # /observe — sync from external services
│   │   └── selfimprove.md          # /selfimprove — research and upgrade the system
│   ├── skills/                     # AI workflow skills (procedural)
│   │   ├── brainstorm/
│   │   ├── daily-review/
│   │   ├── delegation-handoff/
│   │   ├── meeting-notes/
│   │   ├── memory-manager/
│   │   ├── sheets-update/
│   │   ├── slack-report/
│   │   ├── task-management/
│   │   └── workspace-hygiene/
│   └── agents/                     # Autonomous subagents
│       ├── daily-digest.md
│       ├── memory-cleanup.md
│       └── workspace-compactor.md
├── memory/
│   ├── L1-working/                 # Session scratch (~1 day lifetime)
│   ├── L2-active/                  # Active project context (~2 weeks)
│   └── L3-core/                    # Permanent knowledge base
│       ├── preferences.md
│       ├── lessons-learned.md
│       ├── decisions-log.md
│       └── workflows.md
├── context/
│   ├── work/                       # Role, team, meetings, 1-on-1 templates
│   ├── integrations/               # MCP status and setup guides
│   └── personal/                   # Goals
├── tasks/
│   ├── inbox.md                    # Quick capture — triage daily
│   ├── today.md                    # Committed for today (≤7 items)
│   ├── active.md                   # Multi-day in-progress work
│   ├── backlog.md                  # Future work
│   └── completed/                  # Monthly archive (YYYY-MM.md)
├── notes/
│   ├── meetings/                   # Meeting notes (YYYY-MM-DD-name.md)
│   ├── 1-on-1/                     # 1-on-1 notes by person
│   ├── brainstorm/                 # Brainstorm sessions
│   ├── backlog/                    # Long-form backlog notes
│   └── handoff/                    # OOO/delegation handoff docs
├── reminders/
│   └── active.md
├── examples/                       # Pre-filled reference files (not loaded by AI)
│   ├── role-example.md
│   ├── team-example.md
│   └── preferences-example.md
├── scripts/
│   ├── config.example.env          # Environment variable template
│   ├── setup.ps1                   # Windows bootstrap (name replacement, .env)
│   ├── setup.sh                    # macOS/Linux bootstrap
│   ├── setup_scheduler.ps1         # Windows Task Scheduler registration
│   ├── setup_cron.sh               # macOS/Linux cron registration
│   ├── daily_report.py             # Send morning briefing to Slack
│   └── memory_cleanup.py           # Archive stale L1 files
├── CLAUDE.md                       # Claude Code compatibility file
├── CONTRIBUTING.md
└── LICENSE

---

Memory System

The assistant maintains three layers of memory, each with a different lifetime:

Layer	Path	Lifetime	Purpose
L1 Working	memory/L1-working/	~1 day	Session scratch, temp research
L2 Active	memory/L2-active/	~2 weeks	Active project context
L3 Core	memory/L3-core/	Permanent	Lessons, preferences, decisions, workflows

Memory is maintained automatically:

• Daily at 07:00 — scripts/memory_cleanup.py archives stale L1 files and flags stale L2 files
• On-demand — /sleep runs full compaction; memory-cleanup subagent runs targeted scan
• After every write — workspace-hygiene skill deduplicates and checks formats

How it works in practice:

1. You say: "Remember that I prefer async updates over daily standups"
2. The assistant classifies it as a preference → appends to memory/L3-core/preferences.md
3. Every future session starts by reading that file — the preference is permanent
4. Over time, the assistant learns your working style without you repeating yourself

---

Commands

Command	Description
/ask	Read-only briefing, search, and Q&A across all files
/store	Classify and save anything — task, reminder, insight, decision, note
/review	Daily or weekly review — wrap up the day and plan tomorrow
/sleep	Full workspace compaction — deduplicate, archive, clean up everything
/observe	Sync from external services (Calendar, Gmail, Notion, Jira, Slack)
/selfimprove	Research best practices and propose upgrades to the system itself

Example interactions:

You:       /ask what's my day look like?
Assistant: [Reads today.md, active.md, reminders, meetings → structured briefing]

You:       /store task: review the deployment PR by Friday P1
Assistant: [Classifies → adds to tasks/today.md → hygiene pass]

You:       /review
Assistant: [EOD checklist → tomorrow's plan → L1 memory update]

You:       /sleep
Assistant: [Full compaction across all files → compaction report]

You:       brainstorm approaches for migrating the database
Assistant: [Runs brainstorm skill → saves to notes/brainstorm/]

You:       I'm going on vacation next week
Assistant: [Runs delegation-handoff skill → generates handoff doc]

---

Skills

Skill	Trigger Phrases	Description
task-management	"add task / complete task / list tasks"	Manage tasks across inbox/today/active/backlog
meeting-notes	"take meeting notes / 1-on-1 with X"	Create structured meeting and 1-on-1 notes
memory-manager	"remember / store / what did I learn"	Read and write across memory layers
brainstorm	"brainstorm / ideate / pros and cons"	Structured ideation sessions
daily-review	"daily review / end of day / plan tomorrow"	EOD summary and next-day planning
delegation-handoff	"I'm going on vacation / OOO prep / handoff"	Generate delegation document for absences
slack-report	"send to Slack / post update"	Send formatted messages via Slack MCP
sheets-update	"add to the sheet / update status"	Read/write Google Sheets via MCP
workspace-hygiene	(runs automatically after /store)	Post-write dedup and format cleanup

---

Automated Jobs

Time	Script	Action
07:00 daily	scripts/memory_cleanup.py	Archive stale L1 files, flag stale L2 files
08:00 weekdays	scripts/daily_report.py	Send morning briefing to Slack

Both scripts use [uv](https://docs.astral.sh/uv/) — no virtual environment or pip install needed.

Windows Setup

# 1. Install uv
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# 2. Configure secrets
copy scripts\config.example.env .env
# Edit .env — set SLACK_WEBHOOK_URL and DASHBOARD_PATH

# 3. Test immediately
uv run scripts\daily_report.py
uv run scripts\memory_cleanup.py

# 4. Register scheduled tasks (run as Administrator)
powershell -ExecutionPolicy Bypass -File scripts\setup_scheduler.ps1

macOS / Linux Setup

# 1. Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# 2. Configure secrets
cp scripts/config.example.env .env
# Edit .env — set SLACK_WEBHOOK_URL and DASHBOARD_PATH

# 3. Test immediately
uv run scripts/daily_report.py
uv run scripts/memory_cleanup.py

# 4. Register cron jobs
bash scripts/setup_cron.sh

---

MCP Integrations

Service	Capability	Setup
Notion	Read/write pages, 1-on-1 docs, project wikis	See [recommended-mcps.md](context/integrations/recommended-mcps.md)
Atlassian/Jira	Tickets, sprint tracking, Confluence	See [recommended-mcps.md](context/integrations/recommended-mcps.md)
Google Workspace	Calendar, Gmail, Drive, Sheets	See [recommended-mcps.md](context/integrations/recommended-mcps.md)
Slack	Messages, channels, threads	See [.cursor/mcp.json](.cursor/mcp.json)
GitHub	PRs, issues, pipelines	See [recommended-mcps.md](context/integrations/recommended-mcps.md)
Figma	Design context, screenshots	-
Context7	Library documentation	Auto-connects (no setup)

See [context/integrations/mcp-status.md](context/integrations/mcp-status.md) for current status and step-by-step auth guides.

---

Customization

Adding a skill

1. Create .cursor/skills/<skill-name>/SKILL.md
2. Add frontmatter with name and description (include 5-8 trigger phrases)
3. Write step-by-step procedural instructions
4. Reference format rules from task-and-notes-format.mdc instead of duplicating them
5. End with clear output expectations

Adding a rule

1. Create .cursor/rules/<rule-name>.mdc
2. Add frontmatter with description and alwaysApply
3. Keep it under 100 lines — rules guide behavior passively
4. Use globs: to scope it to specific file types

Personalizing the observe command

Open .cursor/commands/observe.md and update each > **Setup:** section with your specific Notion pages, Jira project prefixes, and Slack channels.

Adding recurring context

For active projects, create files in memory/L2-active/<project-name>.md. The assistant picks these up automatically before working on related tasks.

---

FAQ / Troubleshooting

The assistant doesn't know my name or role. Fill in context/work/role.md and replace [YOUR_NAME] in .cursor/rules/assistant-persona.mdc. Or run scripts/setup.ps1 / scripts/setup.sh to do it automatically.

MCP server isn't connecting. Open context/integrations/mcp-status.md and follow the auth steps for that service. Most need an OAuth flow — type "authenticate the [service] MCP" in Cursor Agent mode.

**/observe runs but returns no data.** MCP servers need to be authenticated before they return data. Run /observe after authenticating at least one service.

Memory files are accumulating in L1. Run /sleep (full compaction) or ask the memory-cleanup subagent. L1 files older than 24h are auto-archived by memory_cleanup.py.

**daily_report.py crashes on import.** Run uv run scripts/daily_report.py (not python scripts/daily_report.py). The uv runner installs dependencies automatically.

Does this work with Claude Code? Yes. See [CLAUDE.md](CLAUDE.md) for the Claude Code setup guide. The memory system, task format, and note templates all work the same way.

Does this work on macOS or Linux? Yes. Use scripts/setup.sh for bootstrap and scripts/setup_cron.sh for scheduling. The Python scripts are cross-platform.

Can I use this without Slack? Yes. Slack is optional. Remove the slack MCP from .cursor/mcp.json and skip SLACK_WEBHOOK_URL in .env. The core task/memory/notes system works fully without it.

---

Self-Improvement

The system improves over time:

• Automatic capture — after meaningful interactions the assistant proposes lessons, preferences, or workflow updates
• User confirmation — nothing is written to L3 without your approval
• **/selfimprove command** — researches best practices online and proposes concrete upgrades to skills, rules, and scripts
• Living context — role.md stays current as projects change; L2 memory tracks active work

---

Inspiration & Credits

This system draws patterns and validation from:

• github/spec-kit — bootstrap script concept, multi-agent compatibility, CLAUDE.md pattern
• ChrisWiles/claude-code-showcase — skill structure, multi-agent design
• PatrickJS/awesome-cursorrules — validates the .mdc rule format approach
• vanzan01/cursor-memory-bank — validates the layered memory architecture
• mxyhi/ok-skills — skill directory conventions

---

Contributing

See CONTRIBUTING.md for how to add skills, rules, and subagents, and for PR guidelines.

---

Philosophy

• Everything in markdown — plain text files that work with any tool, forever
• AI as coordinator — the assistant orchestrates across files; you own the data
• Memory is explicit — nothing is hidden; you can read, edit, or delete any memory file
• Progressive enhancement — works great with just Cursor; integrations add capability
• Self-improving — the system gets smarter over time through explicit lesson capture

---

License

MIT — use it, fork it, build on it.