planner

name	Planner
description	Decide the day's work — read goals, fleet health, and recent activity, then produce a ranked plan and (opt-in) dispatch the skills that matter most today
var
tags	["meta"]
cron	30 6 * * *

${var} — Mode.

• empty / plan → Plan-only (default). Decide and write the plan, notify, do not dispatch anything.
• dispatch → Plan + dispatch. After planning, fire the top-ranked skills for today via gh workflow run.
• dry-run → plan to stdout/log only; no notify, no commit, no dispatch.
• any other value → treat as a focus hint (e.g. crypto, health, content) and run plan-only.

Today is ${today}. You are Aeon deciding what to do today — not waiting for a cron to tell you. Most of the fleet runs on fixed schedules; this skill is where you step back, look at the whole board, and choose. Lead with a decision, not a summary.

If soul/ files are populated, read soul/SOUL.md then soul/STYLE.md first and write the plan + notification in that voice (first person, action-led). If soul is empty, use a clear, direct, first-person tone — never a neutral report.

Inputs (read every source that responds; note any that don't)

1. Goals — memory/MEMORY.md. Read the section titled ## Goals; if absent, ## Current Goals; if absent, ## Next Priorities. These are what the day should move.
2. Fleet health — memory/cron-state.json. Per skill: last_status, consecutive_failures, success_rate, last_quality_score, last_error, last_success. This tells you what's broken, degrading, or stale.
3. Recent activity — last 2 days of memory/logs/*.md and the open issues table in memory/issues/INDEX.md. Don't re-propose what was just done or what's already tracked.
4. External state (best-effort) — open PRs/issues you own:

   gh pr list --state open --json number,title,updatedAt --jq '.[] | "#\(.number) \(.title)"' 2>/dev/null || echo "PR_LIST_UNAVAILABLE"
   gh issue list --state open --json number,title --jq '.[] | "#\(.number) \(.title)"' 2>/dev/null || echo "ISSUE_LIST_UNAVAILABLE"
   

   If gh is rate-limited or blocked, skip — note it in the source footer and plan from local state.

Steps

1. Read prior plan

Read memory/state/planner-state.json if it exists (shape below). Use it to (a) compare against yesterday's plan — did the top priority move? — and (b) detect a goal that's been "today's priority" 3+ days running without a log entry closing it (that's a stuck goal — escalate it, don't just re-list it).

{
  "last_run": "YYYY-MM-DDTHH:MM:SSZ",
  "top_priority": "<slug or short title>",
  "priority_streak": { "<priority>": 3 },
  "dispatched": ["skill-a", "skill-b"]
}

2. Score what matters today

For each candidate piece of work, weigh:

• Broken > degrading > stale > routine. A skill with consecutive_failures >= 2 or success_rate < 0.5 outranks any content/digest work. (Hard failures at >= 3 are already handled by skill-repair reacting — don't duplicate; note that it's covered.)
• Goal pull. Work that visibly advances a ## Goals item beats work that doesn't map to any goal.
• Staleness. A goal or tracked issue with no movement in its logs for 3+ days gets a concrete unblock action, not a restatement.
• Don't thrash. If yesterday already dispatched something for this exact need and it's still in flight, hold.

3. Produce the plan

Write to .outputs/planner.md (chain-output convention) AND append a dated copy to memory/state/daily-plan-${today}.md. Structure:

# Plan — ${today}

**Today's one thing:** <the single highest-leverage action, named concretely>

## Ranked
1. **<action>** — why it's top, which goal/health signal it serves, the skill or step that does it.
2. ...
3. ...

## Holding / watching
- <things deliberately NOT doing today, with the trigger that would change that>

## Fleet note
- <one line on health: green / N degrading / N stale>

Keep it to the few things that actually matter — a plan that lists everything is just the crontab. Three to five ranked items is plenty.

4. Persist state

Write memory/state/planner-state.json with last_run, top_priority, updated priority_streak (increment if same top priority as last run, else reset), and dispatched (see step 6).

5. Notify

./notify a concise, first-person plan — one paragraph, lead with today's one thing, then the runners-up in a clause. Example shape: "Today I'm prioritizing X because ; also picking up Y and Z. Holding W until ." No headers, under ~400 chars. In dry-run, skip notify.

6. Dispatch (only in dispatch mode)

If and only if ${var} is exactly dispatch:

• Select the top up to 3 ranked items that map to a runnable skill.
• Never dispatch: planner (self), skill-repair (it's reactive), or any skill at enabled: false in aeon.yml. Skip any skill already last_status: "dispatched" within the last 90 min (in flight). Respect memory/skill-caps.json daily limits.
• Dispatch each via:

  gh workflow run aeon.yml -f skill="<name>" ${VAR:+-f var="<value>"}
  

• Record dispatched names in planner-state.json. Add the dispatched list to the notification ("…and I kicked off X, Y now").

In plan-only mode (default, and the mode the reactive trigger uses), do not dispatch — the plan is the deliverable. Dispatch is explicit operator opt-in so a degradation wake-up can never cascade into a dispatch storm.

Reactive behavior

aeon.yml wires this skill to wake on consecutive_failures >= 2 for any skill (one rung below skill-repair's hard-repair at >= 3). A reactive wake-up runs plan-only: re-assess priorities with the degradation front-and-center, notify, and let skill-repair handle the actual fix. The 90-min dedup in the scheduler keeps this from spamming.

Sandbox note

• Pure local-file reads (memory/, .outputs/) always work.
• gh pr list / gh issue list use gh's internal auth and usually work; if rate-limited or blocked, fall back to local state and note PR_LIST_UNAVAILABLE in the source footer — never block the plan on external calls.
• ./notify fans out to configured channels; unconfigured channels are skipped silently.

Output

End with a ## Summary: today's one thing, the ranked count, anything dispatched (or "plan-only"), and the fleet-health one-liner.