Scheduling

#!/bin/bash

# Gate: check if any VIP emails arrived since last check
LAST_CHECK_FILE=".claw/gates/vip-email-last-check"
DIGEST=".claw/cache/digest.md"

# No digest yet? Nothing to check.
[ -f "$DIGEST" ] || exit 0

# Get timestamp of last check
if [ -f "$LAST_CHECK_FILE" ]; then
  LAST_CHECK=$(cat "$LAST_CHECK_FILE")
else
  LAST_CHECK=0
fi

# Check if digest is newer than last check
DIGEST_MTIME=$(stat -f %m "$DIGEST" 2>/dev/null || stat -c %Y "$DIGEST" 2>/dev/null)
[ "$DIGEST_MTIME" -gt "$LAST_CHECK" ] || exit 0

# Check if digest mentions any VIP names
VIPS=$(grep -i "VIP\|priority\|urgent" "$DIGEST" 2>/dev/null)
if [ -z "$VIPS" ]; then
  date +%s > "$LAST_CHECK_FILE"
  exit 0
fi

# Gate passed: VIP email detected
echo '{"wakeAgent": true, "reason": "VIP email detected"}'
date +%s > "$LAST_CHECK_FILE"

import { execFileSync, execSync } from "node:child_process";
import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
import { join, dirname } from "node:path";
import { fileURLToPath } from "node:url";
import { log } from "./log.mjs";

const __dirname = dirname(fileURLToPath(import.meta.url));
const GATES_DIR = join(__dirname, "gates");
const SCHEDULE_FILE = join(__dirname, "schedule.json");

mkdirSync(join(__dirname, ".claw", "gates"), { recursive: true });

const tasks = JSON.parse(readFileSync(SCHEDULE_FILE, "utf-8"));

for (const task of tasks) {
  try {
    // Run the gate script
    const gateResult = execFileSync(
      join(GATES_DIR, task.gate),
      { cwd: __dirname, encoding: "utf-8", timeout: 10000 }
    ).trim();

    // No output or empty = gate closed, skip
    if (!gateResult) {
      log("schedule", { task: task.name, gateResult: "closed" });
      continue;
    }

    // Parse gate output
    let gate;
    try {
      gate = JSON.parse(gateResult);
    } catch {
      gate = { wakeAgent: true, reason: gateResult };
    }

    if (!gate.wakeAgent) {
      log("schedule", { task: task.name, gateResult: "closed" });
      continue;
    }

    // Gate open. Run the claw with the task prompt.
    log("schedule", {
      task: task.name,
      gateResult: "open",
      reason: gate.reason,
    });

    const prompt = task.prompt.replace("{{reason}}", gate.reason || "");
    // Scheduled tasks call claude -p directly, not through claw.mjs.
    // They don't need the soul, memory, or session infrastructure.
    // They're fire-and-forget: run a focused prompt, write a file, exit.
    const result = execFileSync("claude", ["-p", prompt, "--no-input"], {
      cwd: __dirname,
      encoding: "utf-8",
      timeout: 120000,
    });

    log("schedule-run", {
      task: task.name,
      reason: gate.reason,
      outputLength: result.length,
    });
  } catch (err) {
    log("error", {
      component: "schedule",
      task: task.name,
      message: err.message,
    });
  }
}

[
  {
    "name": "vip-email-check",
    "gate": "new-vip-email.sh",
    "prompt": "A VIP email was detected: {{reason}}. Check the digest, draft a summary of what needs attention, and save it to .claw/alerts/vip-email.md"
  },
  {
    "name": "daily-digest",
    "gate": "morning-window.sh",
    "prompt": "Compile a morning briefing from the latest digest and recent activity. Save to .claw/briefings/today.md"
  },
  {
    "name": "calendar-conflicts",
    "gate": "calendar-changed.sh",
    "prompt": "Check the digest for calendar conflicts or double-bookings in the next 48 hours. If any, save to .claw/alerts/calendar-conflicts.md"
  }
]

#!/bin/bash

# Gate: only pass during morning hours (6-9 AM local time)
HOUR=$(date +%H)
[ "$HOUR" -ge 6 ] && [ "$HOUR" -lt 9 ] || exit 0

# Only run once per day
TODAY=$(date +%Y-%m-%d)
LAST_RUN_FILE=".claw/gates/morning-last-run"

if [ -f "$LAST_RUN_FILE" ]; then
  LAST_RUN=$(cat "$LAST_RUN_FILE")
  [ "$LAST_RUN" = "$TODAY" ] && exit 0
fi

echo '{"wakeAgent": true, "reason": "Morning briefing window"}'
echo "$TODAY" > "$LAST_RUN_FILE"

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.my-claw.schedule</string>

    <key>ProgramArguments</key>
    <array>
        <string>__CLAW_DIR__/run.sh</string>
        <string>schedule</string>
    </array>

    <key>WorkingDirectory</key>
    <string>__CLAW_DIR__</string>

    <key>StartInterval</key>
    <integer>900</integer>

    <key>EnvironmentVariables</key>
    <dict>
        <key>PATH</key>
        <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>
        <key>HOME</key>
        <string>__HOME__</string>
    </dict>

    <key>StandardOutPath</key>
    <string>__CLAW_DIR__/.claw/logs/schedule.out.log</string>

    <key>StandardErrorPath</key>
    <string>__CLAW_DIR__/.claw/logs/schedule.err.log</string>
</dict>
</plist>

{
  "name": "vip-email-check",
  "gate": "new-vip-email.sh",
  "prompt": "...",
  "notify": true
}

if (task.notify && existsSync(join(__dirname, ".claw", "owner-chat-id"))) {
  const chatId = readFileSync(
    join(__dirname, ".claw", "owner-chat-id"), "utf-8"
  ).trim();
  const alertFile = result.match(/\.claw\/alerts\/[\w-]+\.md/)?.[0];
  if (alertFile && existsSync(join(__dirname, alertFile))) {
    const alert = readFileSync(join(__dirname, alertFile), "utf-8");
    // Send via Telegram using the bot from channel.mjs
    // or shell out to a simple notification script
  }
}

# Scheduling

The claw has scheduled tasks that run every 15 minutes via launchd.

## How it works

Each task has a gate script (bash) that decides whether to wake the claw.
Gates are free. The claw only runs when a gate opens.

## Files

- `schedule.json` — task definitions (name, gate, prompt, notify)
- `gates/*.sh` — gate scripts that output JSON with `wakeAgent: true` or nothing
- `service/my-claw-schedule.plist.template` — launchd periodic service
- `.claw/gates/` — per-gate state files (last-run timestamps, etc.)

## Commands

- `./service/install.sh` — installs both the channel and schedule services
- `cat schedule.json` — view configured tasks
- `node schedule.mjs` — run all gates and execute open ones manually

## When to suggest

- If the operator asks "what does the claw do automatically?"
- If the operator wants to add a new scheduled check
- If the operator asks about background work or automation costs