# Status Report

> Use when the user asks where things stand mid-task — "status", "status report", "where are we", "what's the current task", "task progress", "what's next", "subagent status", "is the delegation done" — or wants a progress snapshot while work is still running. Answers NOW from the /task tracking files: current task, progress as a checklist, what is next, and sub-agent/delegation status. Important by default: never deferred to task end, never delegated, never turned into analysis.

- Skill: `arasz/status-report-2` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add arasz/status-report-2`
- Raw SKILL.md: https://api.skillmd.com/api/skills/arasz/status-report-2/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- License: MIT
- Author: Arasz (https://skillmd.com/u/arasz)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/arasz/status-report-2

---


# Status report

A fast, honest snapshot of where the task pipeline stands, answerable while work is still in
flight. It reads the tracking state the task skill already writes — no new bookkeeping, no
long analysis, no waiting.

## Default behavior: important, interrupt-grade

A status request is IMPORTANT by default. Handle it at the first natural boundary — the end
of the current command, nothing more. Nobody asking "where are we?" wants to wait twenty
minutes for the task to end; answering late is answering wrong.

- Do not defer it to task end, queue it behind subagents, or fold it into the running task's
  plan. Answer now.
- Do not delegate the report anywhere. One script run, then answer in your own words.
- An explicit `!` importance marker (`status!:` or any `!`-marker) overrides everything else —
  preempt immediately per the prompt-markers contract.
- If you genuinely cannot answer for seconds (a command is mid-flight), say so and answer the
  moment it returns.

## Procedure

1. Run the script from the project root:

   ```
   python3 .ai-badger/skills/status-report/scripts/status_report.py
   ```

   Add `--target <project-root>` to report on another checkout; `--json` for the machine
   form. It exits 0 on every reporting path — missing or corrupt tracking files render
   their section's placeholder ("(no task in progress)", "(no plan file)", "(not found)",
   "(no live lanes)") instead of failing the report.

2. Answer with the four sections, in this order, using the script's output as the source of
   truth: **Current task** (plus any other open tasks), **Progress checklist** (plan
   packages and checkbox counts), **What's next** (quote `state.json`'s `next` field
   verbatim), **Sub-agents & delegation** (recorded subagent entries, live lane worktrees,
   untracked worktrees, live sessions with STALE marking).

3. Label inference as inference. The script prints the loop's step order
   (prepare > analyze > plan > … > merge) as a reference line; locating "we are at step X"
   from signals — branch exists, plan exists, subagents recorded, PR state — is YOUR
   inference, so phrase it as one ("plan exists and P1 is delegated — you're in
   implementation"). Never present a guessed phase as recorded fact.

4. Add one line of live truth the files cannot hold: what THIS session is doing right now
   (current phase, delegations in flight, what you are about to do next). Keep it visually
   apart from the script-derived sections — records say what happened, you say what is
   happening.

5. Nothing in progress: say so, show the last finished task and the `next` field, and offer
   to start the next task — nothing more. Exception: untracked worktrees listed means real
   work exists with no tracker row — lead with that and offer `start`/`reattach` for it
   instead of the next queue item.

## Where each section draws from

| Section | Source |
|---|---|
| Current task | latest open row (state STARTED or IN_PROGRESS) in the `tasks` table of `.ai-badger/task-tracking/tracking.db` — STARTED is registered work awaiting its first Stop-hook promotion (or a harness with no Stop hook), still open |
| Progress checklist | `task-tracking/plans/*.md` — package headings + `- [x]` counts |
| What's next | `state.json` `next` field, verbatim |
| Sub-agents | `token_usage` subagent records + `worktrees/` lanes for open tasks + worktrees matching no tracker row (untracked — work without tracking) + the `sessions` table (dead pids marked STALE) |

## Gotchas

- An empty recorded-subagent list does NOT mean no delegation is running — records land only
  on completion (`task_tracker.py subagent`), so mid-flight delegations are invisible there.
  Live evidence is lane worktrees, the `sessions` table, and your own session context.
- Stale open entries from dead sessions show up as current (latest-started wins).
  Report them honestly — do not silently pick "the one that looks active" and do not start
  finishing or parking them unprompted. Sessions whose pid is dead are marked STALE by the
  script (the table prunes dead pids only on write); treat a STALE mark as tracker hygiene
  to offer, not as a live lane.
- A worktree matching no tracker row in any state is reported as an untracked worktree —
  work without tracking (the task was never `start`ed, or `start` failed and the agent
  proceeded anyway). Offer `start`/`reattach`; do not silently adopt it as the current task.
- When no plan filename carries the task id, the report falls back to the newest plan and
  says so — verify it is actually this task's plan before quoting its checklist as progress.
- The checklist counts only `- [ ]`/`- [x]` checkbox lines. Plans written without checkboxes
  report "no checkbox items — read the plan file"; that is a plan-format gap, not zero
  progress.
- The script reads only files under the target root; run it with `--target` when your cwd is
  elsewhere, or every section reads as "(not found)".

## Red flags — STOP

- Do not turn a status request into work: no new task, no delegation, no refactoring of the
  tracking files it read.
- Do not poll or wait on running subagents to "complete the picture" — report what is known
  now and what is in flight.
- Do not fix what the report surfaces (stale tasks, missing plans) unless asked; offer it.
- Do not fabricate progress. "(not found)" is a valid answer; a plausible guess is not.

## Verification Checklist

- [ ] Script ran once, exited 0, output carried all four section headers
- [ ] Current task named by id; other open tasks listed, not hidden
- [ ] Any loop-step positioning phrased as inference, not recorded fact
- [ ] `next` quoted verbatim, not paraphrased
- [ ] One live-session line added from this session's own context, kept apart from records

## Files

- `SKILL.md` — this file
- `scripts/status_report.py` — the snapshot script (stdlib-only, exit 0 on reporting paths)