Clawchief Openclaw Chief Of Staff

---
name: clawchief-openclaw-chief-of-staff
description: Turn OpenClaw into a founder/chief-of-staff operating system with Todoist-backed tasks, Gmail/Calendar automation, and deterministic cron workflows
triggers:
  - set up clawchief
  - configure openclaw chief of staff
  - automate my daily tasks with clawchief
  - integrate todoist with openclaw
  - set up executive assistant workflow
  - clawchief cron jobs
  - migrate clawchief v2 to v3
  - clawchief helper scripts
---

# clawchief: OpenClaw Chief of Staff Operating System

> Skill by [ara.so](https://ara.so) — Daily 2026 Skills collection.

`clawchief` is an opinionated starter kit that turns [OpenClaw](https://openclaw.dev) into a founder/chief-of-staff OS. It separates prioritization policy, resolution policy, live task state (Todoist), and recurring orchestration (cron) into discrete, composable layers.

---

## Architecture Overview

clawchief/ ├── priority-map.md # What matters and why ├── auto-resolver.md # How to resolve ambiguous decisions ├── meeting-notes.md # Meeting-note ingestion policy ├── location-awareness.md # Place-based task curation ├── knowledge-compiler.md # System compilation / linting policy ├── task-system-acceptance.md ├── scripts/ │ ├── todoist_cli.py # Live task system interface │ ├── ea_gmail.py # Gmail helper │ ├── ea_calendar.py # Calendar helper │ ├── sheet_helper.py # Google Sheets helper │ └── bd_outreach.py # Business development outreach └── tests/

skills/ ├── task-system-contract/ # Shared task rules ├── executive-assistant/ ├── business-development/ ├── daily-task-manager/ └── daily-task-prep/

workspace/ ├── HEARTBEAT.md # Thin recurring orchestration doc ├── TOOLS.md # Local environment details └── memory/ └── meeting-notes-state.json

cron/ └── jobs.template.json

**Core design principle:** live task state lives in Todoist, not in markdown files. Google workflows go through `gws`-backed helper scripts, not raw API calls.

---

## Installation

### Prerequisites

- OpenClaw installed and configured
- `gws` (Google Workspace CLI) set up
- Todoist account with API token
- Python 3.10+

### Step-by-step

```bash
# 1. Clone the repo
git clone https://github.com/snarktank/clawchief
cd clawchief

# 2. Copy skills into OpenClaw
cp -r skills/* ~/.openclaw/skills/

# 3. Copy source-of-truth and workspace files
cp -r clawchief/ ~/.openclaw/workspace/clawchief/
cp -r workspace/ ~/.openclaw/workspace/

# 4. Set your Todoist API token
echo 'TODOIST_API_TOKEN=your_token_here' >> ~/.openclaw/.env
# or export it in your shell profile:
export TODOIST_API_TOKEN="your_token_here"

# 5. Customize your environment
$EDITOR ~/.openclaw/workspace/TOOLS.md

# 6. Set up gws for Google Workspace access
# Follow SETUP-GWS.md in the repo

# 7. Create cron jobs from the template
cat cron/jobs.template.json  # review, then install with your cron manager

# 8. Run the install checklist
cat INSTALL-CHECKLIST.md

Key Scripts

todoist_cli.py — Live Task Interface

All live task operations go through this script. It is the only canonical interface to the task system.

# clawchief/scripts/todoist_cli.py usage patterns

import subprocess

def run_todoist(args: list[str]) -> str:
    result = subprocess.run(
        ["python", "clawchief/scripts/todoist_cli.py"] + args,
        capture_output=True, text=True
    )
    return result.stdout

# List tasks in a project
print(run_todoist(["list", "--project", "Work"]))

# Add a task
print(run_todoist(["add", "--content", "Review Q2 OKRs", "--due", "today", "--priority", "p1"]))

# Complete a task by ID
print(run_todoist(["complete", "--id", "12345678"]))

# List tasks due today
print(run_todoist(["list", "--filter", "today"]))

Direct Python usage (import pattern):

import os
from todoist_api_python.api import TodoistAPI

api = TodoistAPI(os.environ["TODOIST_API_TOKEN"])

# Get all tasks due today
tasks = api.get_tasks(filter="today")
for task in tasks:
    print(f"[{task.priority}] {task.content} — due {task.due}")

# Add a task
new_task = api.add_task(
    content="Prepare board update",
    due_string="tomorrow",
    priority=2,  # p2
    project_id="your_project_id"
)
print(f"Created: {new_task.id} — {new_task.content}")

# Complete a task
api.close_task(task_id="12345678")

ea_gmail.py — Gmail Helper

# clawchief/scripts/ea_gmail.py usage
# Uses gws under the hood — do not call Gmail APIs directly

import subprocess

def gmail_search(query: str) -> str:
    """Search at message level, not thread level."""
    result = subprocess.run(
        ["python", "clawchief/scripts/ea_gmail.py", "search", "--query", query],
        capture_output=True, text=True
    )
    return result.stdout

# Always search at message level
results = gmail_search("from:partner@example.com subject:contract after:2026/04/01")
print(results)

# Draft a reply
subprocess.run([
    "python", "clawchief/scripts/ea_gmail.py",
    "draft-reply",
    "--message-id", "msg_abc123",
    "--body", "Thanks for reaching out. I'll review and follow up by EOD."
])

ea_calendar.py — Calendar Helper

# clawchief/scripts/ea_calendar.py usage
# Checks ALL relevant calendars before suggesting a booking

import subprocess

def check_availability(date: str, duration_minutes: int = 60) -> str:
    result = subprocess.run(
        [
            "python", "clawchief/scripts/ea_calendar.py",
            "check-availability",
            "--date", date,
            "--duration", str(duration_minutes)
        ],
        capture_output=True, text=True
    )
    return result.stdout

# Always check all calendars before booking
slots = check_availability("2026-04-10", duration_minutes=45)
print(slots)

# Book a meeting
subprocess.run([
    "python", "clawchief/scripts/ea_calendar.py",
    "book",
    "--title", "1:1 with Sarah",
    "--date", "2026-04-10",
    "--time", "14:00",
    "--duration", "45",
    "--attendees", "sarah@example.com"
])

sheet_helper.py — Google Sheets

# clawchief/scripts/sheet_helper.py usage

import subprocess

def append_row(spreadsheet_id: str, sheet_name: str, row: list) -> None:
    subprocess.run([
        "python", "clawchief/scripts/sheet_helper.py",
        "append",
        "--spreadsheet-id", spreadsheet_id,
        "--sheet", sheet_name,
        "--values", ",".join(str(v) for v in row)
    ])

# Log an outreach touchpoint
append_row(
    spreadsheet_id=os.environ["BD_SHEET_ID"],
    sheet_name="Outreach",
    row=["2026-04-08", "Acme Corp", "intro email sent", "sarah@acme.com"]
)

bd_outreach.py — Business Development

# clawchief/scripts/bd_outreach.py usage

import subprocess

# Log a new outreach contact
subprocess.run([
    "python", "clawchief/scripts/bd_outreach.py",
    "log",
    "--company", "Acme Corp",
    "--contact", "sarah@acme.com",
    "--stage", "intro",
    "--notes", "Met at SaaStr, strong fit for enterprise tier"
])

# List follow-ups due this week
result = subprocess.run(
    ["python", "clawchief/scripts/bd_outreach.py", "followups", "--due", "this_week"],
    capture_output=True, text=True
)
print(result.stdout)

Source-of-Truth Files

These files are the policy layer. Edit them to match your operating model.

clawchief/priority-map.md

# Priority Map

## P1 — Revenue and retention
- Customer escalations
- Closing deals in final stage
- Renewal risks

## P2 — Team unblocking
- Decisions that are blocking >1 person
- Hiring decisions in final round

## P3 — Strategic
- OKR reviews
- Partner development

## P4 — Operational
- Recurring admin
- Reporting

clawchief/auto-resolver.md

# Auto-Resolver Policy

When ambiguity arises, resolve with:

1. Does the priority-map clearly rank one option higher? → take the higher-ranked action.
2. Does the action affect a P1 stakeholder (customer, investor, key hire)? → escalate before acting.
3. Is the decision reversible within 24 hours? → act and log it.
4. Otherwise → surface to the user before proceeding.

clawchief/task-system-acceptance.md

# Task System Acceptance Criteria

- Every task has: content, project, priority (p1–p4), due date
- "Inbox" project is triaged daily
- Completed tasks are closed in Todoist, not moved to a markdown file
- No live task state lives in markdown

Skills

Copy skills to ~/.openclaw/skills/ and activate them in OpenClaw.

task-system-contract skill

Encodes the shared rules for how tasks are created, triaged, and closed. Always load this skill when doing any task management work.

daily-task-prep skill

Runs the morning preparation sequence:

1. Pull today's tasks from Todoist
2. Check calendar for the day
3. Surface blockers and P1 items
4. Produce a prioritized briefing

executive-assistant skill

Handles Gmail triage, calendar booking, and follow-up tracking using the helper scripts.

daily-task-manager skill

Handles mid-day and end-of-day task hygiene: closing completed tasks, rescheduling, and logging.

business-development skill

Uses bd_outreach.py and sheet_helper.py to manage pipeline, log touchpoints, and surface follow-ups.

Cron Jobs

cron/jobs.template.json defines deterministic recurring triggers. Keep prompts short — workflow logic lives in skills, not in cron.

[
  {
    "id": "morning-prep",
    "schedule": "0 7 * * 1-5",
    "prompt": "Run daily-task-prep skill.",
    "skill": "daily-task-prep"
  },
  {
    "id": "eod-close",
    "schedule": "0 17 * * 1-5",
    "prompt": "Run daily-task-manager EOD close.",
    "skill": "daily-task-manager"
  },
  {
    "id": "inbox-triage",
    "schedule": "0 9,13 * * 1-5",
    "prompt": "Triage Gmail inbox using executive-assistant skill.",
    "skill": "executive-assistant"
  },
  {
    "id": "bd-followups",
    "schedule": "0 8 * * 1",
    "prompt": "Surface BD follow-ups due this week.",
    "skill": "business-development"
  }
]

Install cron jobs (example with system cron):

# Convert jobs.template.json to actual crontab entries
python -c "
import json, sys
with open('cron/jobs.template.json') as f:
    jobs = json.load(f)
for job in jobs:
    print(f\"{job['schedule']} openclaw run --skill {job['skill']} --prompt '{job['prompt']}'\")
" >> /tmp/claw_cron.txt

crontab -l > /tmp/existing_cron.txt
cat /tmp/existing_cron.txt /tmp/claw_cron.txt | crontab -

workspace/HEARTBEAT.md

Keep this file thin. It is a pointer to cron jobs, not a workflow definition.

# Heartbeat

Recurring work is owned by cron jobs defined in `cron/jobs.template.json`.

This file records the last known healthy state:

- Last morning-prep: 2026-04-08 07:00
- Last inbox-triage: 2026-04-08 13:00
- Last eod-close: 2026-04-07 17:00
- Last bd-followup run: 2026-04-07 08:00

workspace/TOOLS.md

Replace all placeholders with your real environment details.

# Tools

## Task system
- Provider: Todoist
- API token env var: TODOIST_API_TOKEN
- Default project for inbox: Inbox
- Default project for work tasks: Work

## Google Workspace
- gws profile: personal
- Primary calendar: your.email@gmail.com
- Secondary calendars: team-calendar-id, personal-calendar-id

## Sheets
- BD pipeline sheet: (set BD_SHEET_ID env var)

## Email
- Primary inbox: your.email@gmail.com
- Signature footer: (your name / title)

Migration: v2 → v3

If you used the older clawchief/tasks.md model:

# 1. Export existing tasks to Todoist
python clawchief/scripts/todoist_cli.py import-from-markdown \
  --file ~/.openclaw/workspace/clawchief/tasks.md \
  --project "Migrated"

# 2. Archive the old file
mv ~/.openclaw/workspace/clawchief/tasks.md \
   ~/.openclaw/workspace/clawchief/archive/tasks-v2-backup.md

# 3. Replace workspace/tasks/current.md with deprecation pointer
echo "# Deprecated\nLive tasks now in Todoist. See clawchief/scripts/todoist_cli.py." \
  > ~/.openclaw/workspace/tasks/current.md

# 4. Update skills — remove any skill referencing tasks.md directly
grep -r "tasks.md" ~/.openclaw/skills/  # find and update references

# 5. Install new skills
cp -r skills/* ~/.openclaw/skills/

Key behavioral changes in v3:

• gog commands → gws-backed helper scripts
• clawchief/tasks.md → Todoist via todoist_cli.py
• raw cron prompts with embedded logic → thin prompts + skill-held logic

Running Tests

cd ~/.openclaw/workspace/clawchief
python -m pytest clawchief/tests/ -v

# Run a specific test
python -m pytest clawchief/tests/test_todoist_cli.py -v

# Check that all source-of-truth files are present and well-formed
python -m pytest clawchief/tests/test_pack_alignment.py -v

Common Patterns

Morning briefing (manual trigger)

openclaw run --skill daily-task-prep --prompt "Run morning prep."

Add a high-priority task from the command line

python ~/.openclaw/workspace/clawchief/scripts/todoist_cli.py \
  add \
  --content "Call Marcus re: renewal risk" \
  --due today \
  --priority p1 \
  --project Work

Triage inbox on demand

openclaw run --skill executive-assistant --prompt "Triage inbox."

Compile durable lessons back into source-of-truth

openclaw run --skill executive-assistant \
  --prompt "Compile lessons from today's meeting notes into clawchief/knowledge-compiler.md."

Troubleshooting

TODOIST_API_TOKEN not found

# Verify it's set
echo $TODOIST_API_TOKEN

# Load from .env if needed
source ~/.openclaw/.env

gws commands failing in helper scripts

# Verify gws is authenticated
gws auth status

# Re-authenticate if needed
gws auth login

# Check which profile the scripts expect
grep "gws" ~/.openclaw/workspace/TOOLS.md

Tasks not appearing after todoist_cli.py add

• Confirm the project name matches exactly (case-sensitive)
• Check Todoist API token has write permissions
• Run with --debug flag: python todoist_cli.py add --debug ...

Cron jobs not firing

# Check crontab is installed
crontab -l | grep openclaw

# Check openclaw is on PATH for cron
which openclaw

# Add full path to crontab if needed
# e.g.: 0 7 * * 1-5 /usr/local/bin/openclaw run --skill daily-task-prep ...

Skills not loading

# Verify skills are in the right location
ls ~/.openclaw/skills/

# Expected skills:
# task-system-contract/
# executive-assistant/
# business-development/
# daily-task-manager/
# daily-task-prep/

# Each skill directory must contain SKILL.md
ls ~/.openclaw/skills/daily-task-prep/

Meeting notes not being ingested

• Check clawchief/meeting-notes.md policy file exists and is populated
• Verify workspace/memory/meeting-notes-state.json is writable
• Trigger manually: openclaw run --skill executive-assistant --prompt "Ingest latest meeting notes per meeting-notes.md policy."

Design Principles (for AI agents)

1. Never write live task state to markdown. All task mutations go through todoist_cli.py.
2. Never call Gmail or Calendar APIs directly. Use ea_gmail.py and ea_calendar.py.
3. Always check all calendars before booking — not just the primary calendar.
4. Search Gmail at message level, not thread level, to avoid missing replies.
5. Keep cron prompts short. Workflow logic belongs in skill files, not in prompt strings.
6. Compile durable lessons into source-of-truth files, not into chat history.
7. Use auto-resolver.md policy before escalating ambiguous decisions to the user.
8. workspace/HEARTBEAT.md is a status file, not a workflow definition.