# Dev Status

> Show status of all features in .dev/. Scans feature folders using parallel agents, generates a status report, and offers to archive completed features. Use to get an overview of all in-progress features and their completion status.

- Skill: `jsgforever/dev-status` (Agent Skill, multi-file: 4 files)
- Install (CLI): `npx skillmds@latest add jsgforever/dev-status`
- Raw SKILL.md: https://api.skillmd.com/api/skills/jsgforever/dev-status/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Docs & Writing
- Author: jsgforever (https://skillmd.com/u/jsgforever)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/jsgforever/dev-status

---


## Dev Status Report

Scan all features in the `.dev/` folder, generate a status report, and offer to archive completed or stale features.

### Agents

This skill uses a specialized agent for status scanning:

- **feature-batch-scanner** (blue) — Scans a batch of feature folders and extracts status for each

Agent definition is in `agents/` within this skill's directory.

### Step 0: Discover Project Root

Run the [discovery script](scripts/discover.sh):

```bash
bash "$DISCOVER" root
```

Where `$DISCOVER` is the absolute path to `scripts/discover.sh` within this skill's directory.

**Path safety** — shell state does not persist between tool calls, so you must provide full script paths on each call:
- **Use `$HOME`** instead of the literal home directory (e.g., `bash "$HOME/code/…/discover.sh"`, not `bash "/Users/name/…/discover.sh"`). This prevents username hallucination.
- **Copy values from tool output.** When reusing a value returned by a previous command (like `$PROJECT_ROOT`), copy it verbatim from that command's output. Never retype a path from memory.
- **Verify on first call**: if a script call fails with "No such file", the path is wrong — STOP and re-derive from the skill-loading context.
- **Never ignore a non-zero exit.** If any script in this skill fails, stop and report the error before continuing.

Store the output as `$PROJECT_ROOT`. If the command fails, inform the user and stop.

### Step 1: Discover Features

Run the [discovery script](scripts/discover.sh) to find features:

```bash
bash "$DISCOVER" features "$PROJECT_ROOT"
```

- If the script exits non-zero (no `.dev/` directory): inform the user "No `.dev/` directory found. Use `/dev-plan` to start a new feature."
- If output is empty: inform the user "No features found in `.dev/`. Use `/dev-plan` to start a new feature."
- Otherwise: store the list of feature folder paths for the next step.

Also check for archived features using the [discovery script](scripts/discover.sh):

```bash
bash "$DISCOVER" archived "$PROJECT_ROOT"
```

Store any archived paths for the report.

Security rule: only use exact folder paths returned by discovery commands. Never build archive/move paths from raw user input.

### Step 2: Calculate Batches

Distribute feature folders across agents (maximum 5 agents):

- **If N ≤ 5 features**: Launch N agents, 1 folder each
- **If N > 5 features**: Launch 5 agents, distribute folders round-robin

**Batch distribution algorithm** (for N > 5):

```
Agent 1: folders[0], folders[5], folders[10], ...
Agent 2: folders[1], folders[6], folders[11], ...
Agent 3: folders[2], folders[7], folders[12], ...
Agent 4: folders[3], folders[8], folders[13], ...
Agent 5: folders[4], folders[9], folders[14], ...
```

### Step 3: Launch Parallel Agents

Launch all **feature-batch-scanner** agents in parallel using the Task tool.

For each agent, provide a prompt like:

```
"Scan these feature folders and return status for each:
- $PROJECT_ROOT/.dev/feature-a
- $PROJECT_ROOT/.dev/feature-b
- $PROJECT_ROOT/.dev/feature-c

For each folder, determine: Status (Active/Complete/Stale/No PRD), Progress (phases and steps), Last Checkpoint date, and Next Action."
```

Use `subagent_type=dev-workflow:feature-batch-scanner` and `model=haiku` for each agent.

**IMPORTANT**: Launch all agents in a single message with multiple Task tool calls to run them in parallel.

### Step 4: Aggregate Results

After all agents return:

1. Parse each agent's batch results
2. Combine into a unified list of all features
3. Sort by status: Active first, then Stale, then Complete, then No PRD
4. Calculate summary counts

### Step 5: Present Report

Display the status report to the user:

```markdown
## Dev Status Report

**Generated**: [ISO 8601 timestamp]
**Features Scanned**: [N]

### Summary

| Status | Count |
|--------|-------|
| Active | [X] |
| Complete | [Y] |
| Stale | [Z] |
| No PRD | [W] |

### All Features

| Feature | Status | Progress | Last Activity | Next Action |
|---------|--------|----------|---------------|-------------|
| [name] | [status] | [X/Y phases] | [date/ago] | [summary] |
...
```

If there are archived features, add a section:

```markdown
### Archived Features

[N] features in `.dev-archive/`:
- [feature-name-1]
- [feature-name-2]
```

### Step 6: Archive Offer

If there are any **Complete** or **Stale** features, ask the user:

"Would you like to archive any completed or stale features? This moves them to `.dev-archive/` to keep `.dev/` clean."

Present options:
1. Archive all complete features
2. Archive all stale features
3. Archive specific features (list them)
4. Skip archiving

**If user chooses to archive**:

1. Create `.dev-archive/` if it doesn't exist:
   ```bash
   mkdir -p "$PROJECT_ROOT/.dev-archive"
   ```

2. For each selected feature, set `$FEATURE_PATH` to the matching path from Step 1's discovered list. Validate with the [validation script](scripts/validate.sh):

   ```bash
   bash "$VALIDATE" feature-path "$FEATURE_PATH" "$PROJECT_ROOT"
   ```

   Where `$VALIDATE` is the absolute path to `scripts/validate.sh` within this skill's directory. Apply the path safety rules from Step 0 (`$HOME`, copy from output). On failure, **STOP immediately** — do not archive or continue with an unvalidated path.

   Then move:
   ```bash
   mv -- "$FEATURE_PATH" "$PROJECT_ROOT/.dev-archive/"
   ```

   `$FEATURE_PATH` must be one of the discovered `.dev/*` directories selected by the user. Never construct it from raw user input.

3. Confirm what was archived.

**If user skips**: Proceed to Step 7.

### Step 7: Save Report

Remove any previous status reports before writing the new one:

```bash
bash "$DISCOVER" status-reports "$PROJECT_ROOT"
```

Delete each file path returned (if any). If the command fails, skip cleanup and continue.

Write the status report to `$PROJECT_ROOT/.dev/status-report-YYYY-MM-DD.md`:

```markdown
# Dev Status Report

**Generated**: [ISO 8601 timestamp]
**Project**: [project name from git or folder]
**Features Scanned**: [N]

## Summary

| Status | Count |
|--------|-------|
| Active | [X] |
| Complete | [Y] |
| Stale | [Z] |
| No PRD | [W] |

## Features

| Feature | Status | Progress | Last Activity |
|---------|--------|----------|---------------|
| [name] | [status] | [X/Y phases] | [date] |
...

## Archive Candidates

### Complete (ready to archive)
- [feature-name]
...

### Stale (no activity > 30 days)
- [feature-name]
...

---

*Report generated by `/dev-status`*
```

Confirm: "Status report saved to `.dev/status-report-YYYY-MM-DD.md`"

### Privacy Rules

**NEVER include in output or saved reports:**
- Absolute paths containing usernames (e.g., `/Users/username/...`)
- Secrets, API keys, tokens, or credentials
- Personal information

**ALWAYS use instead:**
- Relative paths from project root (e.g., `.dev/feature-name/`)
- Feature names without full paths in tables