---
name: backlog
version: 1.0.0
description: "The engineering backlog registry for deferred-but-approved work in this codebase. Every job the user defers ('defer it', 'add it to the list', 'later', 'not now') lands HERE with its full spec, origin, and unblock condition, so deferral never means loss. Load when the user defers work, asks 'what's on the backlog / the list', says 'work the backlog' / 'pick up <item>', or when completing an item. The bundled BACKLOG.md is the registry; entries move deferred -> ready -> in-progress -> done, and the registry is re-audited against live code - a rotted entry deletes, a done record retires once what it taught is re-homed in the skill that owns it. This records WHAT IS OWED; git history records what happened."
user-invocable: true
argument-hint: [list | add | pick <id> | done <id> | re-audit]
allowed-tools: Read, Grep, Glob, Edit, Write
---

# backlog - deferred work, kept whole

> **Layer:** workflow - the deterministic registry routine for deferred jobs.
> **Bundled:** [BACKLOG.md](BACKLOG.md) - the registry. The heart of this skill.
> **Iron rule:** moving a job onto this list is a MOVE, never a rewrite - the FULL spec
> travels verbatim. A compressed one-liner is a loss; the point of the backlog is that
> deferring costs nothing later. The registry stays honest in the other direction too:
> entries are re-audited against live code, and an entry whose named types or premises
> no longer exist is DELETED, never left readable as live.

## When to load

- The user defers work: "defer it", "add it to the list", "later", "not now", "backlog this".
- The user asks about it: "what's on the backlog", "what's on the list", "what's owed".
- The user works it: "work the backlog", "pick up <id>", "do the next one".
- An item completes: mark it done, and retire the record once what it taught has a home.
- A staleness signal arrives (a rename, a deleted subject, a doubted claim): re-audit.

## The registry contract

Every entry in `BACKLOG.md` carries, verbatim:

- **id** - short stable slug (`kebab-case`), assigned on add.
- **title** - one line.
- **state** - `deferred` -> `ready` -> `in-progress` -> `done`. Entries move forward; they leave the registry only by the two rules below (rot, or a re-homed done record), never by being quietly rewritten.
- **origin** - where it came from (the task/PR/finding/conversation that spawned it).
- **spec** - the FULL description, verbatim from when it was deferred. Not a summary.
- **unblock** - the condition that makes it actionable (a dependency, a decision, a date). `deferred` items without an unblock condition are just `ready`.

Prefer an append-only markdown table or section list in `BACKLOG.md`; never overwrite an entry's spec on a state change - only its `state` line moves.

## Operations

| Command | Action |
|---|---|
| `list` | Show entries grouped by state (ready first, then deferred, then in-progress; done collapsed). |
| `add` | Capture the deferred job with its full spec + origin + unblock condition. Assign an id. |
| `pick <id>` | Move `ready`/`deferred` -> `in-progress`; surface the full spec so work resumes with zero context loss. |
| `done <id>` | Move -> `done` with the evidence (PR/commit + date). The record RETIRES from the registry once what it taught is written into the skill or doc that owns it - git history is the archive of what was owed and delivered. A done entry kept past that point is a second place for the same truth to rot. |
| `re-audit` | Verify every entry's named types, paths and claims against LIVE code (binary-safe: `LC_ALL=C grep -a`, so a repo with binary blobs does not silently return nothing). A subject that no longer exists deletes its entry; a changed fact restates it. **Numbers move by measurement, never by edit** - a count adjusted to match an impression reads as evidence and is worse than no count. |

## Why keep it whole

The failure mode this skill prevents: an agent defers a job with a one-line note, the surrounding context evaporates, and picking it up later means re-deriving the spec (or silently dropping it). Storing the full spec at defer-time makes deferral safe - the cost of "later" is paid once, up front, not lost.