Agent Skills: Cron Decision Skill

Cron Decision Skill

Official docs: https://code.claude.com/docs/en/scheduled-tasks

Purpose

Help agents decide when and whether to use Claude Code's native cron scheduler (CronCreate/CronList/CronDelete) versus alternatives like OS cron (crontab), GitHub Actions scheduled workflows, or simple one-shot Task() delegation.

Using the wrong scheduling mechanism leads to:

• Silent task loss (session expiry kills CronCreate tasks)
• Missed precision requirements (CronCreate has up to 15-min jitter)
• Over-engineering (using GitHub Actions for a simple session heartbeat)

Quick Checklist (Run Before Any Scheduling Decision)

Answer these 5 questions in order. The FIRST "yes" that hits a stop condition determines your tool.

1. Is the task a one-time operation?

   • YES → Use TaskCreate or Task(). Stop here. CronCreate is for recurring work only.

2. Must the task survive terminal/session close?

   • YES → Use OS cron (crontab -e) or GitHub Actions. CronCreate is session-scoped and dies when Claude Code closes.

3. Does the task require sub-15-minute precision or hard time guarantees?

   • YES → Use OS cron or GitHub Actions. CronCreate fires with up to 10% jitter (max 15 min).

4. Is this a heartbeat loop or session-scoped health check?

   • YES → Use CronCreate. This is its primary intended use case.

5. Is this triggered by an event rather than a clock?

   • YES → Use a hook (PreToolUse/PostToolUse) or an event listener, not a scheduler at all.

Decision Matrix

| Scenario | Recommended Tool | Reason | | ------------------------------------------------------- | ----------------------------------------- | ------------------------------------------------------------- | | Periodic background monitoring during active session | CronCreate | Session-scoped is fine; this is CronCreate's primary use case | | Agent ecosystem heartbeat (health checks, memory sizes) | CronCreate via heartbeat-orchestrator | Use dedicated orchestrator, not raw CronCreate | | One-time task (now or delayed) | Task() or TaskCreate | Cron is for recurring work only | | Nightly backup or data pipeline | OS cron (crontab -e) | Must survive terminal close | | CI/CD pipeline trigger | GitHub Actions schedule: | Cloud-run, no terminal dependency | | Data refresh every 4 hours during development | CronCreate | Session-scoped is acceptable for dev workflows | | Production scheduled job | OS cron or GitHub Actions | Never rely on session-scoped for production | | Event-driven reaction (file change, hook trigger) | Hook (PreToolUse/PostToolUse) | Time-based scheduler is wrong tool for events | | User-requested one-off analysis | Task() | Single execution, no recurrence needed | | Weekly report generation (must run unattended) | GitHub Actions | Unattended, cloud-run, persistent | | Session index rebuild during development | CronCreate | Session-scoped is fine; fires while Claude is open | | Reflection queue drain check | CronCreate via heartbeat-orchestrator | Part of heartbeat ecosystem |

Heartbeat Integration Note

If the recurring task is agent ecosystem monitoring (health checks, memory rotation, stuck task detection, reflection queue), do not use raw CronCreate directly.

Instead, delegate to heartbeat-orchestrator or invoke the /heartbeat-start command:

// CORRECT: Delegate heartbeat ecosystem to the dedicated orchestrator
// Router: spawn heartbeat-orchestrator agent
// OR user: /heartbeat-start

// WRONG: Manually wiring raw CronCreate for ecosystem health
CronCreate({
  schedule: '*/30 * * * *',
  task: 'Check agent health...',
});

The heartbeat-orchestrator manages:

• All 7 heartbeat loops
• Auto-reschedule (prevents silent 3-day expiry)
• Session restart detection and re-registration
• Coordinated observability via heartbeat-session-ping.json

Exception: Use raw CronCreate only for custom, non-ecosystem recurring tasks that are not part of the standard heartbeat loops.

CronCreate Constraints (Critical Before Using)

| Constraint | Detail | | ---------------------- | -------------------------------------------------------------- | | Session-scoped | Dies when terminal closes — no persistence across restarts | | 3-day auto-expiry | Self-deletes silently after 3 days (reschedule before day 2.5) | | Jitter | Fires up to 10% of period late (max 15 min) | | No catch-up | Missed fires are NOT replayed | | 50-task cap | Max 50 concurrent scheduled tasks per session | | Fire-between-turns | Fires only when Claude is idle, not mid-response | | No extended syntax | L, W, ?, MON-style names are NOT supported |

When to Use Each Tool

Use CronCreate when

• Task is session-scoped (acceptable to lose on terminal close)
• Monitoring, health checks, or periodic index refreshes during active development
• 15-minute jitter is acceptable
• Task fits within the 50-task session cap (stay under 10 for headroom)

Use OS cron (crontab -e) when

• Task must run even when Claude Code is closed
• Sub-minute precision is required
• Production data pipelines, backups, or server maintenance

Use GitHub Actions schedule: when

• Task must run unattended in CI/CD environment
• Fully cloud-run with no terminal dependency
• Cross-repo or deployment-related scheduling
• Audit trail and run history are required

Use Task() or TaskCreate when

• One-time execution (even if delayed)
• Event-driven (not time-driven)

Use a hook when

• Triggered by a tool call event (PreToolUse/PostToolUse), not a clock

Quick Reference: CronCreate API

// Schedule a recurring task (standard 5-field cron expression)
CronCreate({ schedule: '*/30 * * * *', task: 'Heartbeat check prompt here' });

// List active cron tasks (verify what is registered)
CronList();

// Remove a scheduled task by ID
CronDelete({ id: 'abc12345' });

Common schedules:

| Expression | Meaning | | -------------- | ------------------------------------- | | */30 * * * * | Every 30 minutes | | */5 * * * * | Every 5 minutes (minimum recommended) | | 0 * * * * | Every hour on the hour | | 0 2 * * * | Every day at 2am local time | | 0 3 * * 0 | Every Sunday at 3am |

When to Invoke

Skill({ skill: 'cron-decision' });

Invoke before:

• Setting up any recurring task (to choose the right tool)
• Creating a CronCreate schedule (to verify constraints are acceptable)
• Deciding between GitHub Actions, OS cron, and session-scoped scheduling

Do NOT invoke for:

• One-time task delegation (use TaskCreate directly)
• Heartbeat ecosystem setup (use heartbeat-orchestrator or /heartbeat-start)

Related Skills and Agents

• scheduled-tasks — Full CronCreate implementation reference with heartbeat patterns
• heartbeat — Start the full 7-loop heartbeat ecosystem
• heartbeat-orchestrator agent — Manages ecosystem heartbeat loops

Memory Protocol (MANDATORY)

Before starting: Read .claude/context/memory/learnings.md for previous scheduling decisions.

After completing:

• New scheduling pattern discovered → .claude/context/memory/learnings.md
• Scheduling issue found → .claude/context/memory/issues.md
• Architecture decision made → .claude/context/memory/decisions.md

ASSUME INTERRUPTION: If it's not in memory, it didn't happen.