Apply TemplateDotNetTool PR #76 - Agent and lint cleanup

.cspell.yaml

@@ -98,6 +98,7 @@ ignorePaths:
   - "**/third-party/**"
   - "**/3rd-party/**"
   - "**/AGENT_REPORT_*.md"
+  - "**/.agent-logs/**"
   - "**/bin/**"
   - "**/obj/**"
   - package-lock.json

.github/agents/code-review.agent.md

@@ -1,74 +1,73 @@
 ---
 name: code-review
-description: Assists in performing formal file reviews.
-tools: [read, search, edit, execute, github, web, agent]
+description: Agent for performing formal reviews
 user-invocable: true
 ---
 
-# Code Review Agent - VersionMark
+# Code Review Agent
 
-Perform formal file reviews for a named review-set, producing a structured findings report.
+This agent runs the formal review based on the review-set it's told to perform.
 
-## When to Invoke This Agent
+# Formal Review Steps
 
-Invoke the code-review-agent for:
+Formal reviews are a quality enforcement mechanism, and as such MUST be performed using the following four steps:
 
-- Performing a formal review of a named review-set
-- Producing review evidence for the Continuous Compliance pipeline
-- Checking files against the structured review checklist
+1. Download the
+   <https://github.com/demaconsulting/ContinuousCompliance/raw/refs/heads/main/docs/review-template/review-template.md>
+   to get the checklist to fill in
+2. Use `dotnet reviewmark --elaborate [review-set]` to get the files to review
+3. Review the files all together
+4. Populate the checklist with the findings to `.agent-logs/reviews/review-report-[review-set].md` of the project.
 
-## How to Run This Agent
+# Don't Do These Things
 
-When invoked, the agent will be told which review-set is being reviewed. For example:
+- **Never modify code during review** (document findings only)
+- **Never skip applicable checklist items** (comprehensive review required)
+- **Never approve reviews with unresolved critical findings**
+- **Never bypass review status requirements** for compliance
+- **Never conduct reviews without proper documentation**
+- **Never ignore security or compliance findings**
+- **Never approve without verifying all quality gates**
 
-```text
-Review the "VersionMark-CLI-Review" review-set.
-```
-
-## Responsibilities
-
-### Step 1: Elaborate the Review-Set
-
-Run the following command to get the list of files in the review-set:
+# Reporting
 
-```bash
-dotnet reviewmark --elaborate [review-set-id]
-```
-
-For example:
+Upon completion create a summary in `.agent-logs/[agent-name]-[subject]-[unique-id].md`
+of the project consisting of:
 
-```bash
-dotnet reviewmark --elaborate VersionMark-CLI-Review
-```
+```markdown
+# Code Review Report
 
-This will output the list of files covered by the review-set, along with their fingerprints
-and current review status (current, stale, or missing).
+**Result**: <SUCCEEDED/FAILED>
 
-### Step 2: Review Each File
+## Review Summary
 
-For each file in the review-set, apply the checks from the standard review template at
-[review-template.md](https://github.com/demaconsulting/ContinuousCompliance/blob/main/docs/review-template/review-template.md).
-Determine which checklist sections apply based on the type of file (requirements, documentation,
-source code, tests).
+- **Review Set**: [Review set name/identifier]
+- **Review Report File**: [Name of detailed review report generated]
+- **Files Reviewed**: [Count and list of files reviewed]
+- **Review Template Used**: [Template source and version]
 
-### Step 3: Generate Report
+## Review Results
 
-Write an `AGENT_REPORT_review-[review-set-id].md` file in the repository root with the
-structured findings. This file is excluded from git and linting via `.gitignore`.
+- **Overall Conclusion**: [Summary of review results]
+- **Critical Issues**: [Count of critical findings]
+- **High Issues**: [Count of high severity findings]
+- **Medium Issues**: [Count of medium severity findings]
+- **Low Issues**: [Count of low severity findings]
 
-## Report Format
+## Issue Details
 
-The generated `AGENT_REPORT_review-[review-set-id].md` must include:
+[For each issue found, include:]
+- **File**: [File name and line number where applicable]
+- **Issue Type**: [Security, logic error, compliance violation, etc.]
+- **Severity**: [Critical/High/Medium/Low]
+- **Description**: [Issue description]
+- **Recommendation**: [Specific remediation recommendation]
 
-1. **Review Header**: Project, Review ID, review date, files under review
-2. **Checklist Results**: Each applicable section with Pass/Fail/N/A for every check
-3. **Summary of Findings**: Any checks recorded as Fail, and notable observations
-4. **Overall Outcome**: Pass or Fail with justification
+## Compliance Status
 
-## Don't
+- **Review Status**: [Complete/Incomplete with reasoning]
+- **Quality Gates**: [Status of review checklist items]
+- **Approval Status**: [Approved/Rejected with justification]
+```
 
-- Make any changes to source files, tests, or documentation during a review — record all
-  findings in the report only
-- Skip applicable checklist sections
-- Record findings without an overall outcome
-- Commit the `AGENT_REPORT_*.md` file (it is excluded from git via `.gitignore`)
+Return summary to caller.

.github/agents/developer.agent.md

@@ -0,0 +1,49 @@
+---
+name: developer
+description: >
+  General-purpose software development agent that applies appropriate standards
+  based on the work being performed.
+user-invocable: true
+---
+
+# Developer Agent
+
+Perform software development tasks by determining and applying appropriate DEMA Consulting standards from `.github/standards/`.
+
+# Standards-Based Workflow
+
+1. **Analyze the request** to identify scope: languages, file types, requirements, testing, reviews
+2. **Read relevant standards** from `.github/standards/` as defined in AGENTS.md based on work performed
+3. **Apply loaded standards** throughout development process
+4. **Execute work** following standards requirements and quality checks
+5. **Generate completion report** with results and compliance status
+
+# Reporting
+
+Upon completion create a summary in `.agent-logs/[agent-name]-[subject]-[unique-id].md`
+of the project consisting of:
+
+```markdown
+# Developer Agent Report
+
+**Result**: <SUCCEEDED/FAILED>
+
+## Work Summary
+
+- **Files Modified**: [List of files created/modified/deleted]
+- **Languages Detected**: [Languages identified]
+- **Standards Applied**: [Standards files consulted]
+
+## Tooling Executed
+
+- **Language Tools**: [Compilers, linters, formatters used]
+- **Compliance Tools**: [ReqStream, ReviewMark tools used]
+- **Validation Results**: [Tool execution results]
+
+## Compliance Status
+
+- **Quality Checks**: [Standards quality checks status]
+- **Issues Resolved**: [Any problems encountered and resolved]
+```
+
+Return this summary to the caller.

.github/agents/implementation.agent.md

@@ -0,0 +1,93 @@
+---
+name: implementation
+description: Orchestrator agent that manages quality implementations through a formal state machine workflow.
+user-invocable: true
+---
+
+# Implementation Agent
+
+Orchestrate quality implementations through a formal state machine workflow
+that ensures research, development, and quality validation are performed
+systematically.
+
+# State Machine Workflow
+
+**MANDATORY**: This agent MUST follow the orchestration process below to ensure
+the quality of the implementation. The process consists of the following
+states:
+
+- **RESEARCH** - performs initial analysis
+- **DEVELOPMENT** - develops the implementation changes
+- **QUALITY** - performs quality validation
+- **REPORT** - generates final implementation report
+
+The state-transitions include retrying a limited number of times, using a 'retry-count'
+counting how many retries have occurred.
+
+## RESEARCH State (start)
+
+Call the built-in @explore sub-agent with:
+
+- **context**: the user's request and any current quality findings
+- **goal**: analyze the implementation state and develop a plan to implement the request
+
+Once the explore sub-agent finishes, transition to the DEVELOPMENT state.
+
+## DEVELOPMENT State
+
+Call the @developer sub-agent with:
+
+- **context** the user's request and the current implementation plan
+- **goal** implement the user's request and any identified quality fixes
+
+Once the developer sub-agent finishes:
+
+- IF developer SUCCEEDED: Transition to QUALITY state to check the quality of the work
+- IF developer FAILED: Transition to REPORT state to report the failure
+
+## QUALITY State
+
+Call the @quality sub-agent with:
+
+- **context** the user's request and the current implementation report
+- **goal** check the quality of the work performed for any issues
+
+Once the quality sub-agent finishes:
+
+- IF quality SUCCEEDED: Transition to REPORT state to report completion
+- IF quality FAILED and retry-count < 3: Transition to RESEARCH state to plan quality fixes
+- IF quality FAILED and retry-count >= 3: Transition to REPORT state to report failure
+
+### REPORT State (end)
+
+Upon completion create a summary in `.agent-logs/[agent-name]-[subject]-[unique-id].md`
+of the project consisting of:
+
+```markdown
+# Implementation Orchestration Report
+
+**Result**: <SUCCEEDED/FAILED>
+**Final State**: <RESEARCH/DEVELOPMENT/QUALITY/REPORT>
+**Retry Count**: <Number of quality retry cycles>
+
+## State Machine Execution
+
+- **Research Results**: [Summary of explore agent findings]
+- **Development Results**: [Summary of developer agent results]  
+- **Quality Results**: [Summary of quality agent results]
+- **State Transitions**: [Log of state changes and decisions]
+
+## Sub-Agent Coordination
+
+- **Explore Agent**: [Research findings and context]
+- **Developer Agent**: [Development status and files modified]
+- **Quality Agent**: [Validation results and compliance status]
+
+## Final Status
+
+- **Implementation Success**: [Overall completion status]
+- **Quality Compliance**: [Final quality validation status]  
+- **Issues Resolved**: [Problems encountered and resolution attempts]
+```
+
+Return this summary to the caller.