/goals — Fitness Goal Maintenance

Maintain the GOALS.yaml that
/evolve
consumes. Run checks, generate new goals from repo state, prune stale ones.

YOU MUST EXECUTE THIS WORKFLOW. Do not just describe it.

Quick Start

bash

/goals                    # Status dashboard (default)
/goals generate           # Scan repo, propose new goals
/goals prune              # Find stale/broken goals, propose fixes

Mode Selection

Parse the user's input to determine the mode:

Input	Mode
`/goals` , `/goals status` , "goal status", "show goals"	status
`/goals generate` , "generate goals", "add goals"	generate
`/goals prune` , "prune goals", "update goals", "clean goals"	prune

Status Mode (default)

Step 1: Parse GOALS.yaml

Read

GOALS.yaml

from the repo root. Extract:

```
version
```
,
```
mission
```
,
```
pillars
```
All goals with
```
id
```
,
```
description
```
,
```
check
```
,
```
weight
```
,
```
pillar
```
(optional)

Step 2: Run All Checks

For each goal, execute the

check

command using Bash:

Exit 0 = PASS
Non-zero exit = FAIL
Command error (command not found, syntax error) = ERROR

Capture exit code and stderr for each. Run in parallel where possible (independent checks).

Step 3: Group and Report

Group results by category:

Pillar goals — grouped by pillar, sorted by weight (highest first)
Infrastructure goals — sorted by weight
Cross-runtime goals — sorted by weight

For each goal, show:

[PASS] id (weight N) — description
[FAIL] id (weight N) — description
  └─ stderr: <first line of error output>
[ERROR] id (weight N) — description
  └─ error: <command error>

Step 4: Summary

Fitness: 52/65 passing (80%)

By pillar:
  knowledge-compounding:   9/11 (82%)  weight: 45/51
  validated-acceleration:  4/5  (80%)  weight: 13/17
  goal-driven-automation:  5/5  (100%) weight: 17/17
  zero-friction-workflow:  8/10 (80%)  weight: 25/34

Infrastructure: 20/25 (80%)
Cross-runtime: 6/9 (67%)

Step 5: Staleness Check

Flag goals whose

check

references paths that don't exist:

Extract file paths from check commands (patterns:
```
test -f <path>
```
,
```
grep ... <path>
```
,
```
cat <path>
```
)
Check each path with
```
test -e
```
Report stale references

Generate Mode

Step 1: Read Context

Read these files (in parallel):

```
GOALS.yaml
```
— existing goal IDs
```
PRODUCT.md
```
— design principles, value props, pillars
```
README.md
```
— claims, badges, features
```
skills/SKILL-TIERS.md
```
— full skill list

Step 2: Identify Coverage Gaps

Uncovered skills: For each skill in

skills/*/SKILL.md

, check if any existing goal's

check

field references that skill directory. List skills with no goal.

Uncovered infrastructure: Scan

tests/

hooks/

scripts/

for scripts not referenced by any goal's

check

Pillar coverage: Check each of the 4 pillars has adequate goals. Reference the theoretical pillar mapping in

references/generation-heuristics.md

Claim verification: Scan README.md for quantitative claims (numbers, "all", "every") that have no corresponding goal verifying them.

Step 3: Propose Goals

For each gap, draft a goal:

yaml

- id: <kebab-case-id>
  description: "<what it measures>"
  check: "<shell command, exit 0 = pass>"
  weight: <1-5>
  pillar: <pillar-name>  # omit for infrastructure

Apply quality criteria from

references/generation-heuristics.md

Mechanically verifiable (shell command)
Not trivially true
Not duplicative of existing goals
Weighted by impact

Step 4: User Selection

Present proposals via

AskUserQuestion

. Group by category:

"Which pillar goals should be added?"
"Which infrastructure goals should be added?"

Allow multi-select. User can also provide custom edits.

Step 5: Write Accepted Goals

Append accepted goals to

GOALS.yaml

in the appropriate section (pillar or infrastructure).

Update the header comment counts:

yaml

# Total: N goals (X pillar + Y infrastructure + Z cross-runtime)

Count mechanically —

grep -c '^ *- id:' GOALS.yaml

— don't estimate.

Prune Mode

Step 1: Run All Checks

Same as Status Mode Step 2. Collect exit codes, stderr, and timing.

Step 2: Classify Issues

For each goal, check for:

Broken checks (ERROR status):

Command not found
Syntax error in check
References deleted files/directories

Orphaned references:

Check references skills (
```
skills/<name>/
```
) that don't exist
Check references files that don't exist
Check references CLI commands that aren't installed

Count drift:

Header comment says
```
N goals
```
but actual count differs
Pillar sub-counts don't match actual

Trivially true (heuristic):

Check is
```
test -f <path>
```
for a file that's been in git for 6+ months unchanged
Check is
```
grep -q <literal>
```
for content that hasn't changed in 6+ months

Step 3: Propose Actions

For each issue, propose one of:

Remove — goal is obsolete or duplicative
Update check — fix the command to reference correct paths/patterns
Keep — acknowledge the issue but justify keeping the goal

Present via

AskUserQuestion

with multi-select.

Step 4: Apply Changes

For accepted removals: delete the goal entry from GOALS.yaml. For accepted updates: replace the check command.

Step 5: Update Counts

Recount all goals mechanically and update the header comment.

goals

NPX Install

Tags

SKILL.md Content