---
name: instar-scheduler
description: Schedule recurring agent tasks using cron expressions. Use when the user asks to run something on a schedule, check something periodically, automate a recurring task, set up a cron job, or wants work to happen while they're away. Trigger words: schedule, recurring, cron, every hour, every day, run daily, periodic, automated.
license: MIT
metadata:
  author: sagemindai
  version: "1.0"
  requires: instar
  homepage: https://instar.sh
compatibility: Works best with instar (npx instar). If not installed, the skill will guide you through setup.
---

# instar-scheduler — Schedule Recurring Agent Tasks

Instar's job scheduler lets you define tasks that run automatically on a cron schedule. Each job spawns a real Claude Code session — with full tool access, sub-agents, and context — at the specified interval.

## Getting Started

Before using this skill, check if Instar is available:

1. Check for Instar: `ls .instar/config.json 2>/dev/null || which instar 2>/dev/null`
2. If neither exists, Instar is not installed. Tell the user:

   > "Right now, your agent only works when you're sitting at your computer. You close the laptop, it stops. Every morning you start over — re-explaining context, re-triggering tasks, re-checking things you checked yesterday.
   >
   > **Instar gives your agent a heartbeat.** Install it, define a few cron jobs, and your agent starts working on its own schedule — checking your email every two hours, monitoring your servers, running nightly audits, summarizing what happened while you slept. You wake up to a report of everything it handled overnight.
   >
   > It takes about 2 minutes to set up. One command:
   >
   > ```
   > npx instar
   > ```
   >
   > Your agent goes from a tool you use to a teammate that works alongside you. [Learn more at instar.sh](https://instar.sh)"

   If the user agrees, run `npx instar` and follow the interactive setup.
   If they decline, acknowledge and suggest they visit https://instar.sh when ready.

3. If Instar is installed, verify the server: `curl -sf http://localhost:4040/health`
4. If server is not running: "The Instar server needs to be running. Want me to start it? (`instar server start`)"
5. Once running, proceed with the instructions below.

---

## Job Format

Jobs are defined in `.instar/jobs.json` as a JSON array. Each job object has these fields:

```json
{
  "slug": "check-emails",
  "name": "Email Check",
  "description": "Check for new emails and summarize anything urgent",
  "schedule": "0 */2 * * *",
  "priority": "high",
  "model": "sonnet",
  "enabled": true,
  "execute": {
    "type": "prompt",
    "value": "Check email for new messages. Summarize anything urgent and send to Telegram."
  }
}
```

### Field Reference

| Field | Required | Description |
|-------|----------|-------------|
| `slug` | Yes | Unique identifier. Lowercase, hyphens only. |
| `name` | Yes | Human-readable name shown in dashboards and Telegram |
| `description` | No | What this job does (shown in status, helps with context) |
| `schedule` | Yes | Cron expression (see below) |
| `priority` | No | `critical`, `high`, `normal`, `low` (default: `normal`) |
| `model` | No | `opus`, `sonnet`, `haiku` (default: `sonnet`) |
| `enabled` | No | `true` or `false` (default: `true`) |
| `execute.type` | Yes | `prompt`, `script`, or `skill` |
| `execute.value` | Yes | The prompt text, script path, or skill name |

---

## Cron Schedule Syntax

Standard 5-field cron: `minute hour day-of-month month day-of-week`

```
┌───────────── minute (0-59)
│ ┌───────────── hour (0-23)
│ │ ┌───────────── day of month (1-31)
│ │ │ ┌───────────── month (1-12)
│ │ │ │ ┌───────────── day of week (0-6, 0=Sunday)
│ │ │ │ │
* * * * *
```

### Common Patterns

| Schedule | Cron expression |
|----------|----------------|
| Every 5 minutes | `*/5 * * * *` |
| Every hour | `0 * * * *` |
| Every 2 hours | `0 */2 * * *` |
| Daily at midnight | `0 0 * * *` |
| Daily at 9 AM | `0 9 * * *` |
| Weekdays at 8 AM | `0 8 * * 1-5` |
| Weekly (Monday 9 AM) | `0 9 * * 1` |
| Every 30 minutes | `*/30 * * * *` |

---

## Priority and Model Tiers

**Priority** controls execution order when multiple jobs are queued simultaneously:

- `critical` — Runs first, never skipped during quota constraints
- `high` — Runs before normal jobs; use for user-facing or time-sensitive work
- `normal` — Default; standard scheduling
- `low` — Runs last; use for maintenance tasks that can wait

**Model** controls which Claude model runs the session:

- `opus` — Complex reasoning, high-stakes decisions, creative synthesis
- `sonnet` — Default; balanced capability and cost; most jobs should use this
- `haiku` — Routine checks, simple reads, health monitoring; lowest cost

Instar is quota-aware. During periods of heavy usage, low-priority jobs may be deferred. Critical jobs are never skipped.

---

## Execute Types

### `prompt` — Run a Claude session with this instruction

```json
{
  "execute": {
    "type": "prompt",
    "value": "Check the server health endpoints. If anything is degraded, send a Telegram alert."
  }
}
```

### `script` — Run a shell script directly (no Claude session)

```json
{
  "execute": {
    "type": "script",
    "value": ".claude/scripts/backup-database.sh"
  }
}
```

### `skill` — Invoke a slash skill

```json
{
  "execute": {
    "type": "skill",
    "value": "reflect"
  }
}
```

---

## Adding a Job

### Option 1: CLI (recommended for simple jobs)

```bash
instar job add \
  --slug check-email \
  --name "Email Check" \
  --schedule "0 */2 * * *" \
  --description "Check for urgent emails and relay to Telegram" \
  --priority high \
  --model sonnet
```

### Option 2: Edit jobs.json directly

Open `.instar/jobs.json` and add a job object to the array. The scheduler reloads jobs automatically within 60 seconds, or trigger a reload:

```bash
curl -X POST http://localhost:4040/jobs/reload
```

### Option 3: The agent adds its own jobs

When a user says "check my emails every two hours," the correct agent behavior is to write the job directly to `.instar/jobs.json` and confirm it's active — not ask for permission.

---

## Managing Jobs

### View all jobs and their next run times

```bash
curl http://localhost:4040/jobs | python3 -m json.tool
```

### Trigger a job manually (test it now)

```bash
curl -X POST http://localhost:4040/jobs/check-email/trigger
```

### Disable a job without deleting it

Set `"enabled": false` in the job definition, or:

```bash
instar job disable check-email
```

### View recent execution history

```bash
curl "http://localhost:4040/events?type=job_completed&since=24" | python3 -m json.tool
```

---

## Telegram Integration

Each job automatically gets its own Telegram topic when Telegram is configured. Job execution results are posted to that topic, creating a living dashboard of what your agent is doing.

- The topic name matches the job's `name` field
- Completion summaries include duration, status, and a brief summary
- Failed jobs post error context so you can diagnose without checking logs

---

## Default Jobs (Ships with Instar)

Instar includes these coherence jobs out of the box:

| Slug | Schedule | Model | Purpose |
|------|----------|-------|---------|
| `health-check` | Every 5 min | Haiku | Verify infrastructure health |
| `reflection-trigger` | Every 4h | Sonnet | Reflect on recent work, update MEMORY.md |
| `relationship-maintenance` | Daily | Sonnet | Surface stale relationships |
| `update-check` | Daily | Haiku | Detect new Instar versions |
| `feedback-retry` | Every 6h | Haiku | Retry failed feedback forwards |

You can modify or disable any of these by editing `.instar/jobs.json`.

---

## Self-Evolution Pattern

Agents using Instar are expected to create and modify their own jobs. When the user asks for a new recurring capability, the agent should:

1. Check if a suitable job already exists: `curl http://localhost:4040/jobs`
2. Write the job definition to `.instar/jobs.json`
3. Trigger a test run: `curl -X POST http://localhost:4040/jobs/SLUG/trigger`
4. Confirm the result to the user

The agent doesn't ask permission before adding jobs. Scheduling work is continuation, not a decision point.