/revisit

name: revisit
description: >-
  Revisit dashboard — one scan of everything you parked to re-check later,
  across every skill's memory. Reads out/*/tracker.md and the other memory
  files skills leave behind (ideate PARK "revive when", verdict/scout
  revisit-when triggers, refactor WATCH candidates, learn spaced-repetition due
  dates, jobfit roles to re-check) and surfaces what's due now: date-based items
  past their date, trigger-based items whose condition may have fired. Renders
  one prioritized "due to re-check" list in chat — grouped by skill, most
  overdue first — quoting the exact tracker line and its revive trigger so you
  can act or defer. Strictly read-only: it never edits a tracker or fires the
  follow-up skill; it points, you decide. Use for "what do I need to revisit",
  "what's due to re-check", "anything parked worth reviving", "show my revisit
  queue" — e.g. "/revisit", "/revisit ideate".

revisit — what you parked, now due

`/revisit` — scan every skill's memory for items due to re-check `/revisit <skill>` — only that skill's tracker (e.g. `/revisit ideate`)

Skills that judge under uncertainty don't just decide — they record a **trigger for revisiting the decision**: ideate PARKs an idea "revive when X", verdict stamps "revisit-when", scout/refactor leave WATCH items, learn schedules the next review by date. Scattered across `out/*/`, those triggers rot unseen. This skill is the one place that gathers them and asks a single question: **what is due to re-check right now?**

It is **strictly read-only** — the same contract as `daybrief`. It never edits a tracker, never marks anything revived, never runs the follow-up skill. It surfaces; you decide.

Step 0 — Locate the memory

Today's date is `date +%F` (compute it; don't hardcode). Then find `out/` in the current project.

• No `out/`, or no memory files under it → say so plainly and stop. Nothing to

revisit is a valid, complete answer (keyless, graceful — never invent items).

• `/revisit <skill>` → restrict the scan to `out/<skill>/` only.

**Completion criterion:** the set of memory files to scan is fixed, or a clean "nothing to revisit yet" is reported.

Step 1 — Collect the revisit signals

Read each memory file and pull every line carrying a revisit signal. Known shapes (don't limit to these — any "revive/revisit/recheck/due" marker counts):

| Source | Signal to pull | |---|---| | `out/ideate/tracker.md` | PARK rows with a **"Revive when …"** reason | | `out/verdict/*.md` | **revisit-when** triggers on a past verdict | | `out/scout/tracker.md` | **WATCH** items and their revive condition | | `out/refactor/tracker.md` | **WATCH** candidates deferred to a trigger | | `out/learn/*.md` | next-review **due dates** (spaced repetition) | | `out/jobfit/tracker.md` | roles marked to re-check later |

Skip anything already resolved (SHIPPED, DONE, DROP, applied) — a DROP is not a revisit. Capture for each item: source skill, the verbatim line, and its trigger (a date, or a condition in prose).

**Completion criterion:** a flat list of open revisit items, each tagged with source skill and its trigger.

Step 2 — Classify each item

Sort every item into exactly one bucket:

• **DUE** — a date-based trigger whose date is **on or before today**, or a

condition-based trigger that plausibly **has fired** given what you can see in the repo/trackers (state the evidence). When unsure whether a condition fired, mark **DUE** and say why it's worth a look — a false "check this" is cheaper than a missed revive.

• **NOT YET** — date still in the future, or condition clearly not met. Keep it,

but below the fold, with the unmet trigger shown.

Don't fire or resolve anything — classification only.

**Completion criterion:** every item is DUE or NOT YET, each with a one-line reason.

Step 3 — Render the queue

One prioritized list in chat:

• **DUE first**, most overdue at the top (oldest date, or longest-standing

condition). Group by source skill. For each: the quoted line, its trigger, why it's due, and the **next skill to run** if the user chooses to act (e.g. "→ `/ideate` to re-diverge", "→ `/verdict revisit <brief>`").

• **NOT YET** collapsed underneath as a short "watching" list — item + the

trigger not yet met — so the user sees the horizon without noise.

• Nothing DUE → say so in one line; the watching list is still worth showing.

Never auto-run a follow-up. Naming the next skill is a suggestion the **user** acts on — the read-only contract holds to the last line.

**Completion criterion:** a single grouped, prioritized queue in chat; every DUE item names the skill that would act on it; nothing was written or triggered.