OR Key
drop another .md file to compare - side-by-side diff against weekly-sweep

weekly-sweep

Flags any helper that's overdue so nothing quietly stalls.
personal 2 files 1 recent eval

What it does for you

Flags any helper that's overdue so nothing quietly stalls.

What it produces

A recent result, so you can see the kind of work it returns.

loading…

How to get it

These run inside the Snappy workspace. Want this working in your business? I set skills like this up with you, in one focused week.

Work with me
For developers how this skill is built, graded, and how it runs

at a glance- the short version

actorSteps above, executed by an agent.
auditorShape validator -
eval modeshape
categoryAgents

what's inside - the parts that make up a skill 2/4 present

A skill is just a few plain-text files. Only the main one is required. The rest are optional, added as the work needs them. This is what the skill is made of; how it runs is just below.

The skill
state/skills/weekly-sweep/SKILL.md present
the skill itself, in plain text
The main file. It says what the skill is and lays out the steps in plain English.
Code
state/lib/weekly-sweep.ts not present
code the skill can run
Optional. Many skills are just words and need no code at all.
Scripts
state/bin/weekly-sweep/ not present
helper scripts
Optional. Added when a skill has a few commands to run.
Loader
state/skills/weekly-sweep/AGENTS.md present
what the AI loads on the fly
Loaded automatically the moment this skill is needed. Kept short on purpose.

how it runs - the shared frame every skill uses 5/5 present

Every skill runs the same way. One part does the work, a separate part checks it, and a short loader hands the AI exactly what it needs for the job. Anything this skill doesn't use shows a one-line note saying why, on purpose, not by accident.

makes the work The worker
present
Steps above, executed by an agent. the worker
Does the actual work. Whatever it produces is what gets checked next.
checks the work The reviewer
present
Shape validator - the checker
A separate checker grades the work, so the part that made it can't approve its own work.
frame
learns Self-correction
present
fixes itself learns from gaps
When a run hits a gap, the skill gets edited on the spot [FIXED] or queued for a bigger rewrite [LOGGED], so it keeps getting better.
tidies up Background fixes
present
queued for rewrite runs in the background
Bigger fixes that can't be made on the spot get queued and rewritten in the background later.
remembers Run history
present
state/log/evals.ndjson shape runs
Every run is written down here, so the next time this skill is used it already knows how the last runs went.
Critical rules the things this skill must not get wrong
No must-not-break rules called out for this skill. Anything important lives in the writeup below.

what it has learned - fixes written back in over time sample

When a run hits something this skill didn't handle, the fix gets written back into the skill so it doesn't happen again. FIXED means it was corrected on the spot. LOGGED means it's queued for a bigger rewrite. Either way, the skill gets a little better and never makes the same mistake twice.

  1. Loading feedback rows…

how the work flows- who makes it, who checks it

actor Steps above, executed by an agent.
auditor Shape validator -

SKILL.md- the skill, written out in plain English

weekly-sweep

Lists agents that have not run within their expected cadence window and renders the results as an OpenUI Lang Card for quick triage.

Steps

  1. Load agent registry from state/agents/*.json - collect id, name, lastRun, and cadence_h for each.
  2. For each agent, compute elapsed = now - lastRun in hours. Mark overdue if elapsed > cadence_h.
  3. Sort overdue agents by elapsed descending (most overdue first).
  4. Emit an OpenUI Lang Card:
  • Title: "Overdue Agents"
  • For each overdue agent: ListItem with name, elapsed time in human-readable form (e.g. "3 days 4 hours overdue"), how long it has been overdue (i.e. elapsed - cadence_h in hours/days), and a Tag showing status (overdue).
  • Secondary line per item: "Overdue by: <elapsed - cadence_h formatted>" so the reader sees both total elapsed AND how far past cadence the agent is.
  • Footer: total overdue count out of total agent count.
  1. Write eval row to state/log/evals.ndjson with shape=lang-card, score based on whether the Lang card rendered without error.

Eval

Actor: the Steps above, executed by an agent. Auditor: shape validator - verifies Lang card renders (no unknown-component errors), list has at least one item.

Score convention:

  • 1.0 - Lang card rendered, overdue list non-empty, eval row written.
  • 0.5 - Card rendered but overdue list empty (no agents found or all on schedule).
  • 0.0 - Render error or eval row missing.

AGENTS.md- what the AI loads when this skill comes up

weekly-sweep - loader

Per-turn rules for the weekly-sweep skill. Full reference: state/skills/weekly-sweep/SKILL.md.

Critical Rules

  1. Data source is state/agents/*.json - each file is a JSON agent config with at minimum id, name, and optionally lastRun (ISO timestamp) and cadence_h (number). Missing cadence_h defaults to 168 (one week). Missing lastRun = treat as never run = always overdue.
  2. Emit a Lang Card, not plain text. The output MUST be a [[TOOL:Lang]]...[[/TOOL]] block containing OpenUI primitives: Card, CardHeader, ListBlock, ListItem, Tag. No HTML, no markdown table.
  3. Write an eval row. Before exiting, append a row to state/log/evals.ndjson:
   echo '{"ts":"<ISO>","slug":"weekly-sweep","score":<0|0.5|1.0>,"shape":"lang-card","note":"<brief>"}' >> state/log/evals.ndjson
  1. Sort by most overdue first. elapsed = now - lastRun in hours. Sort descending.
  2. Human-readable elapsed. Show days + hours, not raw hours (e.g. "3 days 4 hrs", not "76 hours").

Commands

operationcommand
list agent filesls ~/projects/snappy-os/state/agents/
read single agentcat ~/projects/snappy-os/state/agents/<name>.json
write eval rowecho '{"ts":"...","slug":"weekly-sweep","score":1.0,"shape":"lang-card"}' >> ~/projects/snappy-os/state/log/evals.ndjson

Lang Card Template

[[TOOL:Lang]]
root = Card(
  CardHeader("Overdue Agents"),
  ListBlock([
    ListItem("Agent Name — 3 days 4 hrs", Tag("overdue", color="red")),
    ...
  ]),
  Text("<N> of <total> agents overdue")
)
[[/TOOL]]

Self-Test

  1. [ ] Load agent registry from state/agents/*.json?
  2. [ ] Compute elapsed and mark overdue where elapsed > cadence_h?
  3. [ ] Sort descending by elapsed?
  4. [ ] Emit [[TOOL:Lang]] block with Card + ListBlock + Tags?
  5. [ ] Write eval row to state/log/evals.ndjson?

<!-- kernel-ok: historical attribution for the PID-loader pattern. -->

Self-correcting loader (PID feedback)

Before you finish, do two things:

1. Fix gaps (P - proportional). MANDATORY. If this loader didn't cover your case, edit it inline before logging.

2. Log the result.

echo "[$(date -u +%FT%TZ)] weekly-sweep: <what was missing or fixed> [FIXED|LOGGED] action_kind=<kind>" >> state/log/loader-feedback.log

api.ts- the code it can call

⚠ no api.ts - this skill has no typed action surface

scripts- helper scripts it can run

prose-only skill - no sidecar under state/bin/ yet. Steps, if any, are described in SKILL.md.

how we check it- the checks, plus the last 1 runs

rubric shape schema-shape check (no inline rubric)
recent mean 1.00 · 1 runs actor/auditor: unverifiable
deps none declared
timestamp verb score primary_issue artifact
2026-05-02 16:37Z - 1.00 - -