Heartbeat & Task Tracking

Build a rotating heartbeat check system in your heartbeat monitor scratch:

Create these checks with their cadences:
- Email: every 30 min (9 AM - 9 PM only)
- Calendar: every 2 hours (8 AM - 10 PM only)
- Tasks: every 30 min (anytime)
- Git: every 24 hours (anytime)
- System: every 24 hours (3 AM only)

Create heartbeat-state.json in the workspace to track last run timestamps.

On each heartbeat:
1. Read state file
2. Calculate which check is most overdue (respect time windows)
3. Run that check
4. Update timestamp in state file
5. Report only if check finds something actionable
6. Reply NO_REPLY if nothing needs attention

Check implementations:
- Email: Check [your email service] for new messages from authorized senders
- Calendar: Check [your calendar] for events in next 24-48h
- Tasks: Check [your task manager] for stalled/blocked work
- Git: Check workspace for uncommitted changes
- System: Check for failed automation runs and error logs

Write the checklist into your monitor scratch (heartbeat_respond with
"scratch", or openclaw cron scratch <jobId> --file). Keep it short and
keep secrets out of it: scratch becomes prompt context.

Adapt these to my specific services and tools.

# Heartbeat checklist

## Cadence-Based Checks

Read `heartbeat-state.json`. Run whichever check is most overdue.

**Cadences:**
- Email: every 30 min (9 AM - 9 PM)
- Calendar: every 2 hours (8 AM - 10 PM)
- Tasks: every 30 min (anytime)
- Git: every 24 hours (anytime)
- System: every 24 hours (3 AM only)

**Process:**
1. Load timestamps from heartbeat-state.json
2. Calculate which check is most overdue (considering time windows)
3. Run that check
4. Update timestamp
5. Report if actionable, otherwise NO_REPLY

---

## Email Check

Check [your email service] for new messages.

**Report ONLY if:** New email from authorized sender, contains actionable request
**Update:** email timestamp in state file

---

## Calendar Check

Check [your calendar] for upcoming events.

**Report ONLY if:** Event starting in <2 hours, new event since last check
**Update:** calendar timestamp in state file

---

## Task Check

Check [your task manager] for work status.

**Report ONLY if:** Tasks stalled >24h, blocked tasks need attention
**Update:** tasks timestamp in state file

---

## Git Check

Check workspace git status.

**Report ONLY if:** Uncommitted changes exist, unpushed commits found
**Update:** git timestamp in state file

---

## System Check

Check for system issues.

**Report ONLY if:** Failed automation runs found, recent errors in logs
**Update:** system timestamp in state file

openclaw cron list --all                 # find the "Heartbeat (<agent>)" job id
openclaw cron scratch <jobId> --file heartbeat.md
openclaw cron scratch <jobId>            # print what the heartbeat sees

{
  "lastChecks": {
    "email": 1703275200000,
    "calendar": 1703260800000,
    "tasks": 1703270000000,
    "git": 1703250000000,
    "system": 1703240000000
  }
}

"agents": {
  "defaults": {
    "heartbeat": {
      "every": "30m",
      "model": "openai/gpt-5.4-mini",
      "isolatedSession": true,
      "lightContext": true,
      "activeHours": { "start": "08:00", "end": "22:00" }
    }
  }
}

# Email check: every 30 min, 9 AM - 9 PM
openclaw automations create "*/30 9-21 * * *" \
  "Check email for actionable messages from authorized senders." \
  --name "Email check" \
  --session isolated \
  --light-context \
  --model "openai/gpt-5.4-mini" \
  --announce

# Git check: daily at 3 AM
openclaw automations create "0 3 * * *" \
  "Check the workspace for uncommitted or unpushed changes." \
  --name "Git check" \
  --session isolated \
  --announce

openclaw automations runs <jobId>        # run history per check

mkdir -p ~/.openclaw/credentials
echo "your-todoist-api-token-here" > ~/.openclaw/credentials/todoist
chmod 700 ~/.openclaw/credentials
chmod 600 ~/.openclaw/credentials/todoist

Build a Todoist-based task tracking system for OpenClaw:

GOAL: Make agent work visible without checking logs. Glance at Todoist
and see exactly what's happening.

STATE MODEL:
- Queue/Backlog: Tasks waiting to start
- Active: Work currently in progress
- Waiting/Assigned to me: Blocked on human input
- Done: Completed

OPERATIONS NEEDED:
1. create_task(title, project) - Add task to queue/backlog
2. move_to_active(task_id) - Start work, move to Active project
3. assign_to_me(task_id, reason) - Mark blocked, assign with comment
4. complete_task(task_id) - Mark done and close
5. add_comment(task_id, status) - Add progress updates to task

RECONCILIATION (runs via heartbeat every 30 min):
- Find Active tasks with no updates >24 hours (stalled)
- List tasks assigned to me (need my attention)
- Report summary if issues found, otherwise NO_REPLY

TECHNICAL:
- Use Todoist REST API v1: https://api.todoist.com/api/v1/
- API Documentation: https://developer.todoist.com/api/v1/
- Python SDK: https://doist.github.io/todoist-api-python/
- TypeScript SDK: https://doist.github.io/todoist-api-typescript/
- Store API token in ~/.openclaw/credentials/todoist
- Handle API rate limits gracefully

VISIBILITY:
I should open Todoist and immediately understand:
- What the agent is working on right now
- What's waiting for me
- What's stuck
- What's been completed

Adapt this to my Todoist setup.