@accelerationguy/accel 1.0.0

package/modules/radar/commands/playbook.md

@@ -0,0 +1,176 @@
+---
+name: radar:playbook
+description: Generate a remediation playbook for a specific finding
+argument-hint: "<finding-id>"
+allowed-tools: [Read, Write, Glob, Grep, AskUserQuestion]
+---
+
+<objective>
+Generates a remediation playbook for a single specific finding. This is the most targeted Transform operation — produces both human-readable (.md) and machine-consumable (.yaml) playbook files for one finding.
+
+If the playbook already exists, offers options to view or regenerate.
+
+Produces: .radar/remediation/playbooks/{finding-id}.md and .radar/remediation/playbooks/{finding-id}.yaml.
+</objective>
+
+<execution_context>
+@~/.claude/radar/transform/workflows/phase-6-remediation.md
+@~/.claude/radar/transform/workflows/transform-safety.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+@.radar/STATE.md
+@.radar/findings/
+@.radar/remediation/playbooks/
+</context>
+
+<process>
+
+## Step 1: Check Prerequisites
+
+Check if .radar/report/ exists with completed Core audit:
+
+- If Layer A incomplete:
+  ```
+  ════════════════════════════════════════
+  CORE AUDIT INCOMPLETE
+  ════════════════════════════════════════
+
+  Playbook generation requires a completed Layer A record.
+
+  [1] Resume audit → runs /radar:resume
+  [2] Cancel
+  ════════════════════════════════════════
+  ```
+
+- If Layer A complete: proceed to Step 2
+
+## Step 2: Validate Finding ID
+
+Check $ARGUMENTS for a finding ID:
+
+- If no finding ID provided:
+  ```
+  ════════════════════════════════════════
+  FINDING ID REQUIRED
+  ════════════════════════════════════════
+
+  Usage: /radar:playbook <finding-id>
+
+  Example: /radar:playbook F-04-001
+
+  To see all findings, run /radar:status.
+
+  [1] List all finding IDs
+  [2] Cancel
+  ════════════════════════════════════════
+  ```
+
+  If [1]: list all finding IDs with severity and domain, then prompt for selection.
+
+- If finding ID provided: validate it exists in .radar/findings/
+  - Search across all agent directories: .radar/findings/*/{finding-id}*
+  - If not found: report error with suggestions (list similar IDs)
+
+## Step 3: Display Finding Context
+
+```
+════════════════════════════════════════
+FINDING DETAILS
+════════════════════════════════════════
+
+Finding: [finding-id]
+Domain: [domain name]
+Severity: [severity]
+Agent: [agent that produced it]
+Confidence: [overall confidence score]
+
+Summary: [first line or title of finding]
+════════════════════════════════════════
+```
+
+## Step 4: Check Existing Playbook
+
+Check if .radar/remediation/playbooks/{finding-id}.md exists:
+
+- If playbook exists:
+  ```
+  ════════════════════════════════════════
+  EXISTING PLAYBOOK FOUND
+  ════════════════════════════════════════
+
+  Playbook: .radar/remediation/playbooks/[finding-id].md
+  YAML: .radar/remediation/playbooks/[finding-id].yaml
+
+  [1] View playbook
+  [2] Regenerate (overwrites existing)
+  [3] Cancel
+  ════════════════════════════════════════
+  ```
+
+- If no playbook exists: proceed to Step 5
+
+## Step 5: Safety Confirmation
+
+```
+════════════════════════════════════════
+SAFETY REVIEW
+════════════════════════════════════════
+
+Finding: [finding-id]
+Confidence: [score] → Intervention level: [Suggesting / Planning / Authorizing]
+
+Playbook will contain:
+  - Root cause analysis
+  - Remediation strategy (4-layer: abstract → framework → language → project)
+  - Before/after examples
+  - Educational context
+  - Verification steps
+
+No changes will be applied to your codebase.
+
+[1] Generate playbook (recommended)
+[2] Cancel
+════════════════════════════════════════
+```
+
+## Step 6: Generate Playbook
+
+1. Delegate to phase-6-remediation workflow scoped to single finding
+2. Transform safety validation runs automatically during generation
+
+## Step 7: Playbook Complete
+
+```
+════════════════════════════════════════
+PLAYBOOK GENERATED
+════════════════════════════════════════
+
+Human-readable: .radar/remediation/playbooks/[finding-id].md
+Machine-consumable: .radar/remediation/playbooks/[finding-id].yaml
+
+Intervention level: [level]
+
+Next steps:
+  - Review the playbook
+  - Generate more playbooks: /radar:playbook <finding-id>
+  - Generate all playbooks: /radar:remediate
+  - Generate guardrails: /radar:guardrails
+
+════════════════════════════════════════
+```
+
+</process>
+
+<success_criteria>
+- [ ] Layer A prerequisite validated
+- [ ] Finding ID validated (exists in .radar/findings/)
+- [ ] Finding context displayed (domain, severity, confidence)
+- [ ] Existing playbook detected and options presented
+- [ ] Intervention level displayed before generation
+- [ ] Explicit confirmation obtained
+- [ ] Phase 6 workflow delegated to (scoped to single finding)
+- [ ] Both .md and .yaml playbook locations communicated
+- [ ] Cancellation available at every decision point
+</success_criteria>

package/modules/radar/commands/remediate.md

@@ -0,0 +1,156 @@
+---
+name: radar:remediate
+description: Generate remediation plans for all findings or a specific domain
+argument-hint: "[domain-number]"
+allowed-tools: [Read, Write, Edit, Bash, Glob, Grep, Task, AskUserQuestion]
+---
+
+<objective>
+Generates remediation knowledge (Layer B) from diagnostic findings, optionally scoped to a specific domain. Can continue through the full Transform pipeline (Phases 6-8) or stop after playbook generation.
+
+If remediation already exists, offers options to view, extend, or regenerate.
+
+Produces: playbooks in .radar/remediation/playbooks/, patterns in .radar/remediation/patterns/, and optionally risk scores and execution plans.
+</objective>
+
+<execution_context>
+@~/.claude/radar/transform/workflows/phase-6-remediation.md
+@~/.claude/radar/transform/workflows/phase-7-risk-validation.md
+@~/.claude/radar/transform/workflows/phase-8-execution-planning.md
+@~/.claude/radar/transform/workflows/transform-safety.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+@.radar/STATE.md
+@.radar/report/
+@.radar/findings/
+@.radar/remediation/
+</context>
+
+<process>
+
+## Step 1: Check Prerequisites
+
+Check if .radar/report/ exists with completed Core audit:
+
+- If Layer A incomplete:
+  ```
+  ════════════════════════════════════════
+  CORE AUDIT INCOMPLETE
+  ════════════════════════════════════════
+
+  Remediation requires a completed Layer A record (all Core phases 0-5).
+
+  [1] Resume audit → runs /radar:resume
+  [2] Cancel
+  ════════════════════════════════════════
+  ```
+
+- If Layer A complete: proceed to Step 2
+
+## Step 2: Determine Scope
+
+Check $ARGUMENTS:
+- If domain number provided: scope to that domain's findings only
+  - Validate domain number (0-13)
+  - Count findings for that domain
+  - If no findings for domain: report and exit
+- If no arguments: scope to all findings
+
+Display scope:
+```
+════════════════════════════════════════
+REMEDIATION SCOPE
+════════════════════════════════════════
+
+Scope: [All findings / Domain NN — {domain name}]
+Findings in scope: [N]
+Severity: Critical [N], High [N], Medium [N], Low [N], Info [N]
+════════════════════════════════════════
+```
+
+## Step 3: Check Existing Remediation
+
+Check if .radar/remediation/ exists:
+
+- If remediation exists:
+  ```
+  ════════════════════════════════════════
+  EXISTING REMEDIATION FOUND
+  ════════════════════════════════════════
+
+  Playbooks: [N] in .radar/remediation/playbooks/
+  Patterns: [N] in .radar/remediation/patterns/
+
+  [1] View existing playbooks
+  [2] Generate missing playbooks only (skip already-generated findings)
+  [3] Regenerate all playbooks (overwrites existing)
+  [4] Cancel
+  ════════════════════════════════════════
+  ```
+
+- If no remediation exists: proceed to Step 4
+
+## Step 4: Safety Confirmation
+
+Display intervention level information:
+```
+════════════════════════════════════════
+SAFETY REVIEW
+════════════════════════════════════════
+
+Remediation will produce playbooks at these intervention levels:
+
+  Suggesting:  [N] findings — advisory remediation
+  Planning:    [N] findings — specific change proposals
+  Authorizing: [N] findings — execution-ready plans
+
+Low-confidence findings ([N]) will be capped at Suggesting level.
+
+IMPORTANT: No changes will be applied to your codebase.
+
+[1] Confirm — generate remediation (recommended)
+[2] Cancel
+════════════════════════════════════════
+```
+
+## Step 5: Execute Remediation
+
+1. Delegate to phase-6-remediation workflow (scoped to selected findings)
+2. After Phase 6 completes, offer continuation:
+
+```
+════════════════════════════════════════
+REMEDIATION GENERATED
+════════════════════════════════════════
+
+Playbooks: [N] created in .radar/remediation/playbooks/
+Patterns: [N] identified in .radar/remediation/patterns/
+
+Continue the pipeline?
+
+[1] Continue to risk validation (Phase 7) + execution planning (Phase 8)
+[2] Continue to risk validation only (Phase 7)
+[3] Stop here — review playbooks first
+[4] Cancel
+════════════════════════════════════════
+```
+
+If [1]: delegate to phase-7-risk-validation, then phase-8-execution-planning
+If [2]: delegate to phase-7-risk-validation only
+If [3]: exit with playbook locations displayed
+If [4]: exit
+
+</process>
+
+<success_criteria>
+- [ ] Layer A prerequisite validated
+- [ ] Scope correctly determined (all findings or domain-specific)
+- [ ] Existing remediation detected and options presented
+- [ ] Intervention levels displayed before any output
+- [ ] Explicit confirmation obtained before proceeding
+- [ ] Phase 6 workflow delegated to with correct scope
+- [ ] Pipeline continuation options presented after Phase 6
+- [ ] Cancellation available at every decision point
+</success_criteria>

package/modules/radar/commands/report.md

@@ -0,0 +1,172 @@
+---
+name: radar:report
+description: Generate or view the Radar diagnostic audit report
+argument-hint: "[section]"
+allowed-tools: [Read, Write, Glob, Grep]
+---
+
+<objective>
+Generates, regenerates, or displays the final Radar diagnostic report from a completed Core audit. Verifies that all Core phases (0-5) are complete before allowing report generation, and delegates to the Phase 5 report workflow for actual generation.
+
+If the report already exists, offers options to view specific sections or regenerate.
+
+Produces: report files in .radar/report/ (executive-summary.md, findings-by-domain.md, disagreements.md, remediation-roadmap.md).
+</objective>
+
+<execution_context>
+@~/.claude/radar/core/workflows/phase-5-report.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+@.radar/STATE.md
+@.radar/report/
+</context>
+
+<process>
+
+## Step 1: Check Prerequisites
+
+Check if .radar/STATE.md exists:
+
+- If NO:
+  ```
+  ════════════════════════════════════════
+  NO ACTIVE AUDIT
+  ════════════════════════════════════════
+
+  No .radar/ directory found. Start an audit first with /radar:audit.
+
+  [1] Start new audit → runs /radar:audit
+  [2] Cancel
+  ════════════════════════════════════════
+  ```
+  Route based on selection.
+
+- If YES: read STATE.md and check phase completion
+
+## Step 2: Verify Phase Completion
+
+Read .radar/STATE.md phase progress. Check if Phases 0-4 are all complete. Phase 5 (Report) is the phase this command triggers, so it does not need to be complete as a prerequisite.
+
+If any prerequisite phase (0-4) is incomplete:
+```
+════════════════════════════════════════
+AUDIT INCOMPLETE
+════════════════════════════════════════
+
+Report generation requires all prerequisite Core phases (0-4) to be complete.
+
+Current progress:
+  Phase 0 (Context): [status]
+  Phase 1 (Signals): [status]
+  Phase 2 (Domain Audits): [status]
+  Phase 3 (Cross-Domain): [status]
+  Phase 4 (Adversarial Review): [status]
+  Phase 5 (Report): [status]
+
+Incomplete phases: [list]
+
+[1] Resume audit to complete remaining phases → runs /radar:resume
+[2] Cancel
+════════════════════════════════════════
+```
+
+If all phases 0-4 complete: proceed to Step 3
+
+## Step 3: Check Existing Report
+
+Check if .radar/report/ directory exists and contains report files:
+
+- If report exists:
+  ```
+  ════════════════════════════════════════
+  EXISTING REPORT FOUND
+  ════════════════════════════════════════
+
+  Report generated: [timestamp from file modification]
+  Sections:
+    - executive-summary.md [exists/missing]
+    - findings-by-domain.md [exists/missing]
+    - disagreements.md [exists/missing]
+    - remediation-roadmap.md [exists/missing]
+
+  [1] View report (display in terminal)
+  [2] View specific section
+  [3] Regenerate report (overwrites existing)
+  [4] Cancel
+  ════════════════════════════════════════
+  ```
+
+  If [1]: display all report sections in sequence
+  If [2]: present section selector:
+    ```
+    Select section:
+    [1] Executive Summary
+    [2] Findings by Domain
+    [3] Disagreements
+    [4] Remediation Roadmap
+    [5] Back
+    ```
+    Display the selected section.
+  If [3]: proceed to Step 4 (regeneration)
+  If [4]: exit
+
+- If no report exists: proceed to Step 4
+
+## Step 4: Generate Report
+
+If $ARGUMENTS contains a section name (e.g., "executive-summary"), generate only that section. Otherwise generate all sections.
+
+```
+════════════════════════════════════════
+REPORT GENERATION
+════════════════════════════════════════
+
+Scope: [Full report / Single section]
+Findings to synthesize: [total count across all phases]
+Disagreements to resolve: [count] (open: [count])
+Domains covered: [count] of 14
+
+[1] Generate report (recommended)
+[2] Cancel
+════════════════════════════════════════
+```
+
+If [1]: delegate to phase-5-report workflow for generation
+If [2]: exit
+
+## Step 5: Report Complete
+
+After generation completes:
+```
+════════════════════════════════════════
+REPORT GENERATED
+════════════════════════════════════════
+
+Location: .radar/report/
+
+Files:
+  - executive-summary.md
+  - findings-by-domain.md
+  - disagreements.md
+  - remediation-roadmap.md
+
+Next steps:
+  - Review the report in .radar/report/
+  - Run /radar:transform to generate remediation plans (Layer B)
+  - Archive the audit when satisfied
+
+════════════════════════════════════════
+```
+
+</process>
+
+<success_criteria>
+- [ ] Prerequisites validated (active audit, phases complete)
+- [ ] Existing report detected and options presented (view/regenerate)
+- [ ] Phase 5 workflow delegated to for report generation
+- [ ] Report files created in .radar/report/
+- [ ] Next steps clearly communicated (Transform pipeline, archival)
+- [ ] Cancellation available at every decision point
+</success_criteria>

package/modules/radar/commands/resume.md

@@ -0,0 +1,176 @@
+---
+name: radar:resume
+description: Resume an interrupted Radar diagnostic audit
+argument-hint: "[phase-number]"
+allowed-tools: [Read, Write, Edit, Bash, Glob, Grep, Task, AskUserQuestion]
+---
+
+<objective>
+Resumes an interrupted Radar diagnostic audit from the last checkpoint or a specified phase. Reads .radar/STATE.md to determine current position, displays progress, and routes to the appropriate phase workflow.
+
+If no active audit exists, routes to /radar:audit to start a new one.
+
+Produces: continued audit execution from the resume point, updated .radar/STATE.md.
+</objective>
+
+<execution_context>
+@~/.claude/radar/core/workflows/phase-0-context.md
+@~/.claude/radar/core/workflows/phase-1-reconnaissance.md
+@~/.claude/radar/core/workflows/phase-2-domain-audits.md
+@~/.claude/radar/core/workflows/phase-3-cross-domain.md
+@~/.claude/radar/core/workflows/phase-4-adversarial-review.md
+@~/.claude/radar/core/workflows/phase-5-report.md
+@~/.claude/radar/core/workflows/phase-checkpoint.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+@.radar/STATE.md
+</context>
+
+<process>
+
+## Step 1: Check for Active Audit
+
+Check if .radar/STATE.md exists:
+
+- If NO:
+  ```
+  ════════════════════════════════════════
+  NO ACTIVE AUDIT
+  ════════════════════════════════════════
+
+  No .radar/ directory found. Start a new audit with /radar:audit.
+
+  [1] Start new audit → runs /radar:audit
+  [2] Cancel
+  ════════════════════════════════════════
+  ```
+  Route based on selection.
+
+- If YES: proceed to Step 2
+
+## Step 2: Read Audit State
+
+Read .radar/STATE.md and extract:
+- Target repository
+- Audit start time
+- Current phase (0-5)
+- Overall status (in_progress / paused / complete)
+- Per-phase status (pending / active / complete)
+- Finding counts per phase
+- Last action and next action from Resume Info
+- Any unresolved disagreements
+- Session tracking data:
+  - Sessions: total session count so far
+  - Last session: timestamp of last activity
+  - Started: when the audit began
+- Checkpoint History: list of phase completions with timestamps and decisions
+
+If status is "complete":
+```
+════════════════════════════════════════
+AUDIT COMPLETE
+════════════════════════════════════════
+
+This audit has already completed all phases.
+
+[1] View status → runs /radar:status
+[2] Generate report → runs /radar:report
+[3] Start Transform pipeline → runs /radar:transform
+[4] Start fresh audit (WARNING: deletes current state) → runs /radar:audit
+[5] Cancel
+════════════════════════════════════════
+```
+
+## Step 3: Display Progress
+
+```
+════════════════════════════════════════
+Radar AUDIT — RESUME
+════════════════════════════════════════
+
+Target: [repository path]
+Started: [timestamp]
+Status: [in_progress / paused]
+Session: [N] (last active: [relative time — e.g., "2 hours ago", "yesterday", "3 days ago"])
+
+Phase Progress:
+┌───────┬──────────────────────────────┬──────────┬──────────┬──────────┐
+│ Phase │ Name                         │ Status   │ Agents   │ Findings │
+├───────┼──────────────────────────────┼──────────┼──────────┼──────────┤
+│   0   │ Context & Threat Modeling    │ complete │ 1        │ -        │
+│   1   │ Automated Signal Gathering   │ complete │ (tools)  │ -        │
+│   2   │ Deep Domain Audits           │ active   │ 6 of 8   │ 23       │
+│   3   │ Cross-Domain Synthesis       │ pending  │ -        │ -        │
+│   4   │ Adversarial Review           │ pending  │ -        │ -        │
+│   5   │ Synthesis & Report           │ pending  │ -        │ -        │
+└───────┴──────────────────────────────┴──────────┴──────────┴──────────┘
+
+Cumulative: [N] findings (critical: [N], high: [N], medium: [N], low: [N])
+Disagreements: [N] detected, [N] resolved
+
+Checkpoint History:
+- Phase 0 (Context & Threat Modeling) — [timestamp]
+- Phase 1 (Signal Gathering) — [timestamp]
+  [... one line per completed phase checkpoint]
+
+Last action: [from STATE.md Resume Info]
+Next action: [from STATE.md Resume Info]
+
+════════════════════════════════════════
+```
+
+Note: Compute relative time from Last session timestamp (e.g., if last session was 2 hours ago, display "2 hours ago"). If Session Tracking section is missing from STATE.md (pre-Phase 12 audits), display "Session: 1 (no tracking data)" and omit Checkpoint History.
+
+## Step 4: Present Resume Options
+
+Check if $ARGUMENTS contains a phase number:
+- If YES: validate the phase number (0-5), skip to delegation with that phase
+- If NO: present options
+
+```
+[1] Resume from last checkpoint (recommended) — continues Phase [N+1] without re-reading completed phases
+[2] Re-run Phase [N] — [last completed phase] (re-executes from scratch)
+[3] Jump to Phase [N] — [specify phase number]
+[4] Start fresh (WARNING: deletes .radar/ and all findings)
+[5] Cancel
+```
+
+If [1]: determine the correct resume point from STATE.md:
+  - If a phase is "active" with partial completion: resume that phase at the next unfinished agent
+  - If the last phase is "complete": start the next pending phase
+
+If [2]: confirm re-run (warns that existing phase output will be overwritten), then delegate
+
+If [3]: validate phase number, warn if skipping phases (findings may be incomplete), then delegate
+
+If [4]: require explicit confirmation ("type DELETE to confirm"), then delegate to /radar:audit
+
+If [5]: exit
+
+## Step 5: Delegate to Phase Workflow
+
+Based on the selected resume point:
+1. Update .radar/STATE.md:
+   - Resume Info: last action and next action
+   - Session Tracking: increment Sessions count, update Last session timestamp
+   - Overall status: in_progress (if was paused)
+2. Delegate to the appropriate phase workflow (context loading is handled by the phase workflow and session-handoff — do NOT re-read completed phase outputs at the resume command level):
+   - Phase 0 → phase-0-context workflow
+   - Phase 1 → phase-1-reconnaissance workflow
+   - Phase 2 → phase-2-domain-audits workflow
+   - Phase 3 → phase-3-cross-domain workflow
+   - Phase 4 → phase-4-adversarial-review workflow
+   - Phase 5 → phase-5-report workflow
+
+</process>
+
+<success_criteria>
+- [ ] .radar/STATE.md read and current position identified
+- [ ] Phase progress displayed clearly to user
+- [ ] Resume point selected (automatic or user-chosen)
+- [ ] Correct phase workflow delegated to
+- [ ] .radar/STATE.md updated with resume action
+- [ ] Cancellation available at every decision point
+</success_criteria>