Capstone Radar

Capstone Radar

Capstone Radar is the aggregator + gap filler for the 6-skill radar family (5 companions + capstone). It consumes findings from 5 companion skills, runs its own scans for 5 domains the companions don't cover, grades everything on one unified scale, and makes the ship/no-ship decision.

It does NOT:

• Re-scan domains already covered by companion skills
• Dispatch Axiom auditor agents
• Produce separate reports for domains companions already cover

Usage

| Command | Description | |---------|-------------| | /capstone-radar | Full analysis — checks everything and reads companion handoffs | | /capstone-radar quick | Quick check — own domains only, ignores companion results | | /capstone-radar report | No scanning, re-grade from existing handoff files only | | /capstone-radar diff | Compare against previous audit — show resolved/new issues | | --trust-all | Override staleness decay -- treat all companion handoffs as Fresh | | --show-suppressed | Show findings suppressed by known-intentional entries |

---

Diff Command

Audit comparison — compare current codebase against a previous audit to show what changed.

Usage

/capstone-radar diff
/capstone-radar diff 2026-03-15

How It Works

1. Find previous audit — Read the most recent (or specified date) .agents/research/*-capstone-audit.md
2. Parse previous findings — Extract all issues from the GRADES_YAML block and findings tables
3. Re-check each finding:

• Read the file at the reported line number
• Check if the problematic pattern still exists
• Classify as: ✅ RESOLVED, 🔴 STILL OPEN, 📁 FILE CHANGED

1. Scan for new issues — Quick grep scan for new violations not in previous report
2. Output diff summary

Output Format

Audit Diff: 2026-03-15 → 2026-03-29

Summary:
  ✅ Resolved: 8 issues fixed since last audit
  🔴 Still Open: 3 issues remain
  🆕 New: 2 new issues detected
  📁 Changed: 4 files modified (may need re-verification)

Grade Trend:
  Overall: B [83] → B+ [87] ↑
  Code Hygiene: B- → A- ↑
  Security Basics: A → A (stable)
  Test Health: C → C+ ↑

Resolved Issues:
| # | Finding | Was | File | Resolved By |
|---|---------|-----|------|-------------|
| 1 | TODO marker in production | 🟡 HIGH | CloudSyncManager.swift:142 | Commit abc123 |

Still Open:
| # | Finding | Urgency | File | Age |
|---|---------|---------|------|-----|
| 1 | Force unwrap in error path | 🟡 HIGH | BackupManager.swift:89 | 14 days |

New Issues:
| # | Finding | Urgency | Risk: Fix | Risk: No Fix | ROI | Blast Radius | Fix Effort | Status |

When to Use

• Pre-release check — "What's changed since our last audit?"
• Progress tracking — Verify issues are being resolved over time
• Regression detection — Catch new issues introduced since last audit

Velocity Tracking

If 3+ previous audits exist, show trend line:

Grade Velocity (last 5 audits):
  Build 21: C+ [78]
  Build 22: B- [80]
  Build 23: B  [84]
  Build 24: B+ [87]
  Build 25: B+ [88] ← current

Trend: Improving (+2.5 pts/build avg)
Projection: A- by Build 28 at current rate

---

Skill Introduction (MANDATORY — run before anything else)

On first invocation, ask the user three questions in a single AskUserQuestion call:

Question 1: "What's your experience level with Swift/SwiftUI?"

• Beginner — New to Swift. Plain language, analogies, define terms on first use.
• Intermediate — Comfortable with SwiftUI basics. Standard terms, explain non-obvious patterns.
• Experienced (Recommended) — Fluent with SwiftUI. Concise findings, no definitions.
• Senior/Expert — Deep expertise. Terse, file:line only, skip explanations.

Question 2: "Which audit mode?"

• Full (Recommended) — Full analysis — checks everything and reads findings from other audits you've run
• Quick — Quick check — only looks at its own areas, ignores other audit results
• Report only — No scanning, just re-grade from existing handoff files

Question 3: "Include user impact explanations?"

• No (default) — Table only. Findings speak for themselves.
• Yes — After the table, each finding gets a 3-line explanation: what's wrong, the fix, and how a user experiences it before/after.

Can also be toggled mid-session with --explain / --no-explain. See radar-suite-core.md § Experience-Level Output Rules for format and rules.

Experience-adapted explanations for Capstone Radar:

• Beginner: "Capstone Radar is the final check before your app goes to the App Store. It combines results from 5 other audit tools (if you've run them) with its own security, testing, and code quality checks, then gives your whole app a letter grade and tells you if it's safe to ship. Think of it as the building inspector who reviews all the specialist reports plus checks the things no one else covered."

• Intermediate: "Capstone Radar aggregates findings from 5 companion skills (data-model-radar, ui-path-radar, roundtrip-radar, ui-enhancer-radar, time-bomb-radar) and adds its own scans for security, test health, code hygiene, dependencies, and build health. It grades 11 weighted inputs on one scale (5 own + 5 consumed + 1 cross-domain synthesis), tracks trends across runs, and makes a ship/no-ship recommendation."

• Experienced: "Aggregator + gap filler for the radar family. Consumes 5 companion handoffs, owns 5 grep-reliable domains, unified A-F grading across 11 weighted inputs, velocity tracking, risk heatmap, ship/no-ship decision."

• Senior/Expert: "5 owned + 5 consumed + 1 cross-domain = 11 weighted domains. Velocity. Heatmap. Ship/no-ship."

Store the experience level as USER_EXPERIENCE and apply to ALL output for the session.

---

Shared Patterns

See radar-suite-core.md for: Tier System, Pipeline UX Enhancements, Table Format, Plain Language Communication, Work Receipts, Contradiction Detection, Finding Classification, Audit Methodology, Context Exhaustion, Progress Banner, Issue Rating Tables, Handoff YAML schema, Known-Intentional Suppression, Pattern Reintroduction Detection, Experience-Level Output Rules, Implementation Sort Algorithm, short_title requirement.

Tier Awareness (MANDATORY -- read before any scanning)

Read .radar-suite/session-prefs.yaml for the tier field. Capstone behavior adapts based on the active tier:

Tier 3 (Full Pipeline)

All 5 companion skills are expected. If a handoff is missing, treat it as an error (not "not audited"):

ERROR: data-model-radar handoff missing. Full pipeline requires all 5 companions.
Options: [Re-run data-model-radar / Continue without it (grade will be partial)]

Before starting own scans, emit the Pre-Capstone Summary (see radar-suite-core.md Pipeline UX Enhancements #5):

• Read all 5 handoff files
• Emit the consolidated findings table (skill, count, critical/high/medium/low breakdown)
• Show top findings by urgency with RS-NNN (short_title)
• Ask: "Review summary before capstone grading? [Enter to continue / Review details]"

Tier 2 (Targeted Pipeline)

Read tier_skills from session prefs to know which skills were in the subset. Only expect handoffs for those skills. For skills not in the subset:

• Mark as "not in scope" (not "not audited")
• Grade is scoped to audited domains only
• Emit: "Partial audit: [N] of 5 skills ran. Grade reflects audited domains only. Missing coverage: [list of excluded skills]."

Weight redistribution: redistribute missing domain weights proportionally to audited domains (same as existing missing-handoff logic).

Tier 1 / No Tier / Standalone

Existing behavior. Missing handoffs show "Not audited -- run [skill-name] for coverage."

---

Pre-Scan Startup (MANDATORY — before Step 1)

1. Known-intentional suppression: Run the protocol in radar-suite-core.md § Known-Intentional Suppression. Core owns this — do not restate the steps here. (Note: companion findings already excluded at the companion level; capstone only filters its own domain scans through this protocol.)

1. Pattern reintroduction detection: Run the protocol in radar-suite-core.md § Pattern Reintroduction Detection. Core owns this.

1. Experience-level auto-apply (capstone-radar local): If USER_EXPERIENCE = Beginner, auto-set EXPLAIN_FINDINGS = true and default sort to impact. If Senior/Expert, default sort to effort. Apply all output rules from radar-suite-core.md § Experience-Level Output Rules.

---

Step 1: Project Metrics

Collect:

1. File counts — Glob pattern="**/*.swift" (exclude Tests, Pods, .build, DerivedData)
2. LOC estimate — file count x 150, or wc -l for accuracy
3. Architecture — detect MVVM/MVC/TCA by scanning for ViewModel, Controller, Reducer
4. Persistence layer — SwiftData, Core Data, GRDB, UserDefaults, Realm
5. Test infrastructure — Swift Testing vs XCTest, unit test count, UI test count
6. Build number — read from CLAUDE.md (search for "Current Version" or build number), or from Info.plist
7. Team detection — git shortlog -sn --no-merges | wc -l. Store as TEAM_SIZE.

Ensure output directories exist: mkdir -p .agents/research .agents/ui-audit

Print one-line summary:

Project: {files} Swift files (~{loc} LOC) | {arch} | {persistence} | Tests: {unit}/{ui} | Build: {number} | Contributors: {count}

---

Step 2: Previous Audit Check

Glob pattern=".agents/research/*-capstone-audit.md"
Glob pattern=".agents/research/*-codebase-audit.md"

If previous reports exist, parse ALL GRADES_YAML HTML comment blocks for velocity tracking. Build an array of dated snapshots sorted by date. Store as HISTORY.

---

Step 3: Companion Handoff Consumption (Tier-Aware)

Read the unified ledger and handoff files. Which files to read depends on the active tier (see Tier Awareness above). In Tier 2, read only handoffs for skills listed in tier_skills. In Tier 3, read all 5. In Tier 1/standalone, read whatever exists.

Read .radar-suite/ledger.yaml (if exists) — unified cross-skill finding store
Read .agents/ui-audit/data-model-radar-handoff.yaml (if exists)
Read .radar-suite/time-bomb-radar-handoff.yaml (if exists)
Read .agents/ui-audit/ui-path-radar-handoff.yaml (if exists)
Read .agents/ui-audit/roundtrip-radar-handoff.yaml (if exists)
Read .agents/ui-audit/ui-enhancer-radar-handoff.yaml (if exists)

Ledger integration: When the ledger exists, use it as the primary source of cross-skill findings. Handoff YAMLs provide per-skill detail (serialization coverage, cross-cutting patterns) that the ledger doesn't store. Capstone should reference findings by RS-NNN ID when available.

For each handoff found:

1. Parse for_capstone_radar.blockers[] — extract finding and urgency (CRITICAL or HIGH)
2. Backward compat: Also accept for_release_ready_radar.blockers[] key
3. Parse companion-specific extras:

• data-model-radar: serialization_coverage (model field coverage stats)
• roundtrip-radar: cross_cutting_patterns[] (patterns affecting multiple workflows)

1. Record which companions were found vs missing

Score consumed domains: Start at 95 (generous baseline — companion ran a full audit and only escalated the worst items). Deduct:

• Per CRITICAL blocker: -15
• Per HIGH blocker: -8
• Floor at 0

Missing handoffs (tier-dependent messaging):

• Tier 3: "ERROR: [skill] handoff missing. Full pipeline requires all 5 companions." (see Tier Awareness)
• Tier 2: If skill was in tier_skills, treat as error. If not, mark "Not in scope" (expected absence).
• Tier 1 / standalone: "Not audited -- run [skill-name] for coverage."

In all cases, weight is redistributed proportionally to audited domains.

Print companion status:

Companions: data-model-radar [found/missing] | ui-path-radar [found/missing] | roundtrip-radar [found/missing] | time-bomb-radar [found/missing] | ui-enhancer-radar [found/missing]

Skip this step if mode = Quick.

Companion Handoff Quality Assessment

When a companion handoff is found, check its audit_depth and _verified flags (if present):

• audit_depth: full + all targets _verified: true → Full credit (start at 95, deduct per blocker)
• audit_depth: partial or some targets _verified: false → Reduced credit (start at 85, deduct per blocker). Note in report: "Partial audit — [domain] grade is provisional."
• No depth/verified flags (older handoff format) → Treat as partial. Note: "Handoff from older skill version — depth not verified."

Do not give full credit for unverified companion work. A handoff that says "backup verified, CSV not checked" should not produce an A for the Model Layer domain. The unverified targets represent unknown risk.

Companion Handoff Staleness Decay

After assessing quality, calculate staleness for each companion handoff:

staleness_score = (days_since_handoff * 0.3) + (commits_since_handoff * 0.1)

Where:

• days_since_handoff = calendar days since the handoff's timestamp field
• commits_since_handoff = output of git rev-list --count ..HEAD (use git log --oneline --since="" if commit hash unavailable)

| Score | Label | Behavior | |-------|-------|----------| | 0-2 | Fresh | Full trust -- use handoff as-is | | 2-5 | Aging | Trust grades, but spot-check HIGH findings (read the file, verify pattern still exists) | | 5-10 | Stale | Downgrade companion grades by one letter. Spot-check all CRITICAL + HIGH findings. | | 10+ | Expired | Ignore handoff entirely. Recommend re-running the companion skill. |

Freshness summary (print in companion status output):

Companion freshness:
  data-model-radar: Fresh (1 day, 3 commits)
  ui-path-radar: Aging (8 days, 12 commits)
  roundtrip-radar: Stale (22 days, 47 commits) — grades downgraded by one letter
  time-bomb-radar: Fresh (2 days, 5 commits)
  ui-enhancer-radar: Expired (35 days, 89 commits) — handoff ignored, re-run recommended

Spot-check protocol (for Aging and Stale handoffs):

1. Read the finding's file at the cited line range
2. Check if the pattern still exists (grep the finding's work receipt pattern if available)
3. If pattern gone → mark finding as possibly-resolved (stale handoff) and exclude from grade calculation
4. If pattern still present → mark as re-verified and keep the finding

--trust-all flag: Overrides staleness calculation. All companions treated as Fresh regardless of age. Use when you know nothing has changed since the last audit.

Stale/Expired companions are flagged in the "Next Steps" section of the report.

---

Step 3.5: Axis Classification Consumption (MANDATORY — after companion handoffs, before risk-ranking)

> New in v1.1 (axis framework). Every companion handoff now includes an axis_summary block and every finding includes an axis field. Capstone splits findings by axis before grading: only axis1 findings count toward the A-F grade. axis2 and axis_3 findings land in a separate Hygiene Backlog section.

What to read

For each companion handoff found in Step 3, read:

1. axis_summary (top-level block) — counts by axis
2. checks_performed (top-level block) — what the companion scanned
3. axis (per-finding field) — classification for each finding
4. before_after_experience.audience (per-finding field) — surface in the report

What to do

1. Split findings by axis into two buckets:

• fixbeforeshipping — all findings where axis == axis_1_bug
• hygiene_backlog — all findings where axis in (axis_2_scatter, axis_3_dead_code, axis_3_smelly)

1. Verify schema gate compliance. For each finding in either bucket, confirm it has:

• A non-empty better_approach field
• A file:line citation matching regex [A-Za-z0-9_/+.-]+\.swift:\d+ in the better_approach body
• A pattern_citation_lookup entry in verification_log
• A before_after_experience with audience set

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: Terryc21
• Source: Terryc21/radar-suite
• License: Apache-2.0
• Homepage: https://github.com/Terryc21/radar-suite

Install and usage instructions live in the source repository linked above.