RonanCodes/skills/project-status

Project Status

The "where were we" answer. A pure read-only synthesis across every durable source into one grouped roadmap a human can scan and an orchestrator can consume. It never commits, pushes, files issues, or edits code — the only thing it writes is the report file (skip with --no-write).

Sibling map:

• /ro:session-state — the mechanical live-state sweep. This skill calls it as step 1.
• /ro:handoff resume — re-enters a session and offers to dispatch the next move. This skill is the read-only report, not the dispatcher.
• /ro:ultracode — consumes this skill's .handoff/status-latest.md build queue to orchestrate the work. This skill is the input; ultracode is the engine.

Steps

1 — Live state

Run /ro:session-state for uncommitted changes, unpushed commits, open PRs, in-flight branch. This is the "in-progress" truth.

2 — Gather the sources (read-only)

# handoff / orientation doc (first hit wins)
for f in docs/agents/HANDOFF.md .handoff/latest.md HANDOFF.md docs/HANDOFF.md; do [ -f "$f" ] && echo "HANDOFF: $f" && break; done
git log --oneline -15

# GitHub backlog + PRD umbrellas + coordination comments
gh issue list --state open --limit 50 --json number,title,labels,createdAt 2>/dev/null
# read each `prd`-labelled issue body in full (it defines scope + slices)
# read the coordination-hub issue's comments (the in-flight / claimed-by anchor) if one exists

Read every prd-labelled issue body (the umbrellas define scope + remaining slices) and the coordination-hub issue's recent comments (what's claimed / in flight). Map each open enhancement issue to its parent PRD via the ## Parent\n\n#N convention or the slice lists in the PRDs.

3 — LLM-wiki vault (if mapped)

If .ronan-skills-llm-wiki.local.json maps this repo to a vault, skim that vault's concepts/ for design docs the PRDs reference (e.g. makely-*.md). If no config and no vault, note "wiki: not mapped" and move on — don't block.

4 — Classify every open item into the groups

Read each issue's blocker signals (body, labels, comments, the handoff's BLOCKERS section) and sort into:

• 🔨 In progress / next up — the active line (from session-state + handoff "Next up" + coordination comments).
• 🐛 Bugs / tech-debt — defects + deferred refactors.
• 🚫 Blocked on a decision or spend — anything gated on a key, a paid resource, a legal review, or a user call. Name the exact blocker.
• ✨ Ready features (no blockers) — buildable now. These feed the build queue.
• 🗺️ PRD umbrellas — the prd issues, each with: what's shipped vs what slices remain.
• 🔮 Future / strategic — not yet sliced or actively queued.
• 🙋 What I need from you — see step 4b. The actionable cut of the blockers.

4b — "What I need from you" (the unblock list)

Every item in 🚫 Blocked has a human action behind it. Re-frame each as a thing the user can go get, in if you want X → I need Y, from Z shape, so they can grab it without reading the whole report. Keep it to one line each by default:

🙋 What I need from you
- To get listing photos → an official feed deal (Realworks / brainbay), or a "yes, build the headless-image pipeline" call. Source: a vendor/legal decision, only you can make it.
- To make Saar call Dutch numbers (#27/#32) → a paid Vapi number or an imported Telnyx +31 number, then I swap VAPI_PHONE_NUMBER_ID. Source: Vapi/Telnyx dashboard, ~5 min.
- To send WhatsApp alerts (#13/#9) → Twilio sandbox keys in .env.local. Source: Twilio console.

Order by how much it unblocks (a decision that frees a whole PRD comes first). Mark each [decision], [key/secret], [spend], or [legal review] so the user sees the kind of action at a glance.

4c — Elaborate mode

Default output is one line per ask (terse, grab-and-go). When the user says "elaborate on the blockers" / passes --elaborate, expand each into: what's blocked, why, the exact steps to get the thing, what it costs, and what unblocks the moment it lands. If the expanded list is long (4+ asks or multi-step procurement), also render it as a local HTML file and open it (never a remote Artifact — the user switches work accounts; this is a hard project rule), so they can work through it away from the terminal. Write to .handoff/what-i-need-<ts>.html.

5 — Build queue (dependency-ordered)

From the Ready features only, emit an ordered list using the night-shift 4-signal intuition (age + priority + size + unblocks-others) and explicit deps (a slice that another slice needs comes first; respect PRD slice ordering). This is the machine-consumable handoff to /ro:ultracode.

6 — Emit + persist

Print the grouped roadmap to the user (markdown tables, emoji group headers, issue numbers as #N). Unless --no-write, also write the same report to .handoff/status-latest.md with a ## Build queue section as a checklist of - [ ] #N — <one-line> in order, so a downstream orchestrator reads a stable file. Create .handoff/ if missing (it's already gitignored in factory repos; if not, leave it untracked).

Always include the 🙋 What I need from you list (step 4b) — it's the payoff of the report. Keep it terse. Then end with two pointers when applicable:

• → say "elaborate on the blockers" and I'll expand each ask (+ a local HTML you can work off) when there is more than one ask.
• → /ro:ultracode to fan out agents over the build queue when the queue is non-empty.

Copy rules

Honour /ro:write-copy: no em/en-dashes, no AI-tell vocabulary, plain direct sentences. Group headers use emoji; product/UI copy never does (separate rule — this is a report, not product). Keep each item to one line.

Output shape (reference)

# <Project>, project status (<date>)
🔨 In progress / next up   — the active line + uncommitted/unpushed state
🐛 Bugs / tech-debt        — table: item | notes
🚫 Blocked                 — table: issue | item | exact blocker
✨ Ready features          — table: issue | item
🗺️ PRD umbrellas           — per PRD: shipped vs remaining slices
🔮 Future / strategic      — bullets
🙋 What I need from you    — if you want X → I need Y from Z  [decision|key|spend|legal]
## Build queue (ordered)   — 1. #N — one-line  (the /ro:ultracode input)