@builderos/create-agent-os 0.0.2

package/src/template/agent-os/commands/implement-tasks/implement-tasks.md

@@ -0,0 +1,207 @@
+Now that we have a spec and tasks list ready for implementation, we will proceed with implementation of this spec by following this multi-phase process:
+
+PHASE 1: Determine which task group(s) from tasks.md should be implemented
+PHASE 2: Implement the given task(s)
+PHASE 3: After ALL task groups have been implemented, produce the final verification report.
+
+Carefully read and execute the instructions in the following files IN SEQUENCE, following their numbered file names.  Only proceed to the next numbered instruction file once the previous numbered instruction has been executed.
+
+Instructions to follow in sequence:
+
+# PHASE 1: Determine Tasks
+
+First, check if the user has already provided instructions about which task group(s) to implement.
+
+**If the user HAS provided instructions:** Proceed to PHASE 2 to delegate implementation of those specified task group(s) to the **implementer** subagent.
+
+**If the user has NOT provided instructions:**
+
+Read `agent-os/specs/[this-spec]/tasks.md` to review the available task groups, then output the following message to the user and WAIT for their response:
+
+```
+Should we proceed with implementation of all task groups in tasks.md?
+
+If not, then please specify which task(s) to implement.
+```
+
+# PHASE 2: Implement Tasks
+
+Now that you have the task group(s) to be implemented, proceed with implementation by following these instructions:
+
+Implement all tasks assigned to you and ONLY those task(s) that have been assigned to you.
+
+## Implementation process:
+
+1. Analyze the provided spec.md, requirements.md, and visuals (if any)
+2. Analyze patterns in the codebase according to its built-in workflow
+3. Implement the assigned task group according to requirements and standards
+4. Update `agent-os/specs/[this-spec]/tasks.md` to update the tasks you've implemented to mark that as done by updating their checkbox to checked state: `- [x]`
+
+## Guide your implementation using:
+- **The existing patterns** that you've found and analyzed in the codebase.
+- **Specific notes provided in requirements.md, spec.md AND/OR tasks.md**
+- **Visuals provided (if any)** which would be located in `agent-os/specs/[this-spec]/planning/visuals/`
+- **User Standards & Preferences** which are defined below.
+
+## Self-verify and test your work by:
+- Running ONLY the tests you've written (if any) and ensuring those tests pass.
+- IF your task involves user-facing UI, and IF you have access to browser testing tools, open a browser and use the feature you've implemented as if you are a user to ensure a user can use the feature in the intended way.
+  - Take screenshots of the views and UI elements you've tested and store those in `agent-os/specs/[this-spec]/verification/screenshots/`.  Do not store screenshots anywhere else in the codebase other than this location.
+  - Analyze the screenshot(s) you've taken to check them against your current requirements.
+
+
+## Display confirmation and next step
+
+Display a summary of what was implemented.
+
+IF all tasks are now marked as done (with `- [x]`) in tasks.md, display this message to user:
+
+```
+All tasks have been implemented: `agent-os/specs/[this-spec]/tasks.md`.
+
+NEXT STEP 👉 Run `3-verify-implementation.md` to verify the implementation.
+```
+
+IF there are still tasks in tasks.md that have yet to be implemented (marked unfinished with `- [ ]`) then display this message to user:
+
+```
+Would you like to proceed with implementation of the remaining tasks in tasks.md?
+
+If not, please specify which task group(s) to implement next.
+```
+
+## User Standards & Preferences Compliance
+
+IMPORTANT: Ensure that the tasks list is ALIGNED and DOES NOT CONFLICT with the user's preferences and standards as detailed in the following files:
+
+@agent-os/standards/backend/api.md
+@agent-os/standards/backend/migrations.md
+@agent-os/standards/backend/models.md
+@agent-os/standards/backend/queries.md
+@agent-os/standards/frontend/accessibility.md
+@agent-os/standards/frontend/components.md
+@agent-os/standards/frontend/css.md
+@agent-os/standards/frontend/responsive.md
+@agent-os/standards/global/coding-style.md
+@agent-os/standards/global/commenting.md
+@agent-os/standards/global/conventions.md
+@agent-os/standards/global/error-handling.md
+@agent-os/standards/global/tech-stack.md
+@agent-os/standards/global/validation.md
+@agent-os/standards/testing/test-writing.md
+
+# PHASE 3: Verify Implementation
+
+Now that we've implemented all tasks in tasks.md, we must run final verifications and produce a verification report using the following MULTI-PHASE workflow:
+
+## Workflow
+
+### Step 1: Ensure tasks.md has been updated
+
+Check `agent-os/specs/[this-spec]/tasks.md` and ensure that all tasks and their sub-tasks are marked as completed with `- [x]`.
+
+If a task is still marked incomplete, then verify that it has in fact been completed by checking the following:
+- Run a brief spot check in the code to find evidence that this task's details have been implemented
+- Check for existence of an implementation report titled using this task's title in `agent-os/spec/[this-spec]/implementation/` folder.
+
+IF you have concluded that this task has been completed, then mark it's checkbox and its' sub-tasks checkboxes as completed with `- [x]`.
+
+IF you have concluded that this task has NOT been completed, then mark this checkbox with ⚠️ and note it's incompleteness in your verification report.
+
+
+### Step 2: Update roadmap (if applicable)
+
+Open `agent-os/product/roadmap.md` and check to see whether any item(s) match the description of the current spec that has just been implemented.  If so, then ensure that these item(s) are marked as completed by updating their checkbox(s) to `- [x]`.
+
+
+### Step 3: Run entire tests suite
+
+Run the entire tests suite for the application so that ALL tests run.  Verify how many tests are passing and how many have failed or produced errors.
+
+Include these counts and the list of failed tests in your final verification report.
+
+DO NOT attempt to fix any failing tests.  Just note their failures in your final verification report.
+
+
+### Step 4: Create final verification report
+
+Create your final verification report in `agent-os/specs/[this-spec]/verifications/final-verification.md`.
+
+The content of this report should follow this structure:
+
+```markdown
+# Verification Report: [Spec Title]
+
+**Spec:** `[spec-name]`
+**Date:** [Current Date]
+**Verifier:** implementation-verifier
+**Status:** ✅ Passed | ⚠️ Passed with Issues | ❌ Failed
+
+---
+
+## Executive Summary
+
+[Brief 2-3 sentence overview of the verification results and overall implementation quality]
+
+---
+
+## 1. Tasks Verification
+
+**Status:** ✅ All Complete | ⚠️ Issues Found
+
+### Completed Tasks
+- [x] Task Group 1: [Title]
+  - [x] Subtask 1.1
+  - [x] Subtask 1.2
+- [x] Task Group 2: [Title]
+  - [x] Subtask 2.1
+
+### Incomplete or Issues
+[List any tasks that were found incomplete or have issues, or note "None" if all complete]
+
+---
+
+## 2. Documentation Verification
+
+**Status:** ✅ Complete | ⚠️ Issues Found
+
+### Implementation Documentation
+- [x] Task Group 1 Implementation: `implementations/1-[task-name]-implementation.md`
+- [x] Task Group 2 Implementation: `implementations/2-[task-name]-implementation.md`
+
+### Verification Documentation
+[List verification documents from area verifiers if applicable]
+
+### Missing Documentation
+[List any missing documentation, or note "None"]
+
+---
+
+## 3. Roadmap Updates
+
+**Status:** ✅ Updated | ⚠️ No Updates Needed | ❌ Issues Found
+
+### Updated Roadmap Items
+- [x] [Roadmap item that was marked complete]
+
+### Notes
+[Any relevant notes about roadmap updates, or note if no updates were needed]
+
+---
+
+## 4. Test Suite Results
+
+**Status:** ✅ All Passing | ⚠️ Some Failures | ❌ Critical Failures
+
+### Test Summary
+- **Total Tests:** [count]
+- **Passing:** [count]
+- **Failing:** [count]
+- **Errors:** [count]
+
+### Failed Tests
+[List any failing tests with their descriptions, or note "None - all tests passing"]
+
+### Notes
+[Any additional context about test results, known issues, or regressions]
+```

package/src/template/agent-os/commands/initialize-design/initialize-design.md

@@ -0,0 +1,54 @@
+# COMMAND: Initialize Design OS
+
+## Goal
+Populate the Design OS workspace with the product strategy defined in Agent OS, enabling the user to start designing immediately without manual data entry.
+
+## Prerequisites
+- `agent-os/product/mission.md` must exist.
+- `agent-os/product/roadmap.md` must exist.
+- `design/` directory must be a valid Design OS clone.
+
+## Instructions
+
+### Step 1: Read Product Data
+Read the content of:
+- `agent-os/product/mission.md`
+- `agent-os/product/roadmap.md`
+
+### Step 2: Generate Design OS Files
+You will create/overwrite files in `design/product/`.
+
+#### 2.1 Create `design/product/product-overview.md`
+Extract the following from `mission.md` and format it as markdown:
+- **Title**: The product name.
+- **Description**: The core pitch/mission.
+- **Problems & Solutions**: Map the "Problem" section to "Problem X: ... Solution: ...".
+- **Key Features**: List the core features.
+
+#### 2.2 Create `design/product/product-roadmap.md`
+Extract the numbered feature list from `roadmap.md` and format it as:
+```markdown
+# Product Roadmap
+## Sections
+### 1. [Feature Name]
+[Brief description]
+...
+```
+
+#### 2.3 Create `design/product/data-model/data-model.md` (Draft)
+Based on the `mission.md` and `roadmap.md`, infer the core Entities and Relationships.
+Create a draft data model file:
+```markdown
+# Data Model
+## Entities
+### [Entity Name]
+[Description]
+## Relationships
+- [Entity] has many [Entity]
+```
+*Note: Verify this draft with the user if the inference seems ambiguous.*
+
+### Step 3: Verification
+- Check that `design/product/product-overview.md` exists.
+- Check that `design/product/product-roadmap.md` exists.
+- Output a confirmation message: "Design OS initialized! You can now open http://localhost:3000 to begin designing."

package/src/template/agent-os/commands/orchestrate-tasks/orchestrate-tasks.md

@@ -0,0 +1,180 @@
+# Process for Orchestrating a Spec's Implementation
+
+Now that we have a spec and tasks list ready for implementation, we will proceed with orchestrating implementation of each task group by a dedicated agent using the following MULTI-PHASE process.
+
+Follow each of these phases and their individual workflows IN SEQUENCE:
+
+## Multi-Phase Process
+
+### FIRST: Get tasks.md for this spec
+
+IF you already know which spec we're working on and IF that spec folder has a `tasks.md` file, then use that and skip to the NEXT phase.
+
+IF you don't already know which spec we're working on and IF that spec folder doesn't yet have a `tasks.md` THEN output the following request to the user:
+
+```
+Please point me to a spec's `tasks.md` that you want to orchestrate implementation for.
+
+If you don't have one yet, then run any of these commands first:
+/shape-spec
+/write-spec
+/create-tasks
+```
+
+### NEXT: Create orchestration.yml to serve as a roadmap for orchestration of task groups
+
+In this spec's folder, create this file: `agent-os/specs/[this-spec]/orchestration.yml`.
+
+Populate this file with with the names of each task group found in this spec's `tasks.md` and use this EXACT structure for the content of `orchestration.yml`:
+
+```yaml
+task_groups:
+  - name: [task-group-name]
+  - name: [task-group-name]
+  - name: [task-group-name]
+  # Repeat for each task group found in tasks.md
+```
+
+### NEXT: Ask user to assign subagents to each task group
+
+Next we must determine which subagents should be assigned to which task groups.  Ask the user to provide this info using the following request to user and WAIT for user's response:
+
+```
+Please specify the name of each subagent to be assigned to each task group:
+
+1. [task-group-name]
+2. [task-group-name]
+3. [task-group-name]
+[repeat for each task-group you've added to orchestration.yml]
+
+Simply respond with the subagent names and corresponding task group number and I'll update orchestration.yml accordingly.
+```
+
+Using the user's responses, update `orchestration.yml` to specify those subagent names.  `orchestration.yml` should end up looking like this:
+
+```yaml
+task_groups:
+  - name: [task-group-name]
+    claude_code_subagent: [subagent-name]
+  - name: [task-group-name]
+    claude_code_subagent: [subagent-name]
+  - name: [task-group-name]
+    claude_code_subagent: [subagent-name]
+  # Repeat for each task group found in tasks.md
+```
+
+For example, after this step, the `orchestration.yml` file might look like this (exact names will vary):
+
+```yaml
+task_groups:
+  - name: authentication-system
+    claude_code_subagent: backend-specialist
+  - name: user-dashboard
+    claude_code_subagent: frontend-specialist
+  - name: api-endpoints
+    claude_code_subagent: backend-specialist
+```
+
+### NEXT: Ask user to assign standards to each task group
+
+Next we must determine which standards should guide the implementation of each task group.  Ask the user to provide this info using the following request to user and WAIT for user's response:
+
+```
+Please specify the standard(s) that should be used to guide the implementation of each task group:
+
+1. [task-group-name]
+2. [task-group-name]
+3. [task-group-name]
+[repeat for each task-group you've added to orchestration.yml]
+
+For each task group number, you can specify any combination of the following:
+
+"all" to include all of your standards
+"global/*" to include all of the files inside of standards/global
+"frontend/css.md" to include the css.md standard file
+"none" to include no standards for this task group.
+```
+
+Using the user's responses, update `orchestration.yml` to specify those standards for each task group.  `orchestration.yml` should end up having AT LEAST the following information added to it:
+
+```yaml
+task_groups:
+  - name: [task-group-name]
+    standards:
+      - [users' 1st response for this task group]
+      - [users' 2nd response for this task group]
+      - [users' 3rd response for this task group]
+      # Repeat for all standards that the user specified for this task group
+  - name: [task-group-name]
+    standards:
+      - [users' 1st response for this task group]
+      - [users' 2nd response for this task group]
+      # Repeat for all standards that the user specified for this task group
+  # Repeat for each task group found in tasks.md
+```
+
+For example, after this step, the `orchestration.yml` file might look like this (exact names will vary):
+
+```yaml
+task_groups:
+  - name: authentication-system
+    standards:
+      - all
+  - name: user-dashboard
+    standards:
+      - global/*
+      - frontend/components.md
+      - frontend/css.md
+  - name: task-group-with-no-standards
+  - name: api-endpoints
+    standards:
+      - backend/*
+      - global/error-handling.md
+```
+
+Note: If the `use_claude_code_subagents` flag is enabled, the final `orchestration.yml` would include BOTH `claude_code_subagent` assignments AND `standards` for each task group.
+
+### NEXT: Delegate task groups implementations to assigned subagents
+
+Loop through each task group in `agent-os/specs/[this-spec]/tasks.md` and delegate its implementation to the assigned subagent specified in `orchestration.yml`.
+
+For each delegation, provide the subagent with:
+- The task group (including the parent task and all sub-tasks)
+- The spec file: `agent-os/specs/[this-spec]/spec.md`
+- Instruct subagent to:
+  - Perform their implementation
+  - Check off the task and sub-task(s) in `agent-os/specs/[this-spec]/tasks.md`
+
+In addition to the above items, also instruct the subagent to closely adhere to the user's standards & preferences as specified in the following files.  To build the list of file references to give to the subagent, follow these instructions:
+
+#### Compile Implementation Standards
+
+Use the following logic to compile a list of file references to standards that should guide implementation:
+
+##### Steps to Compile Standards List
+
+1. Find the current task group in `orchestration.yml`
+2. Check the list of `standards` specified for this task group in `orchestration.yml`
+3. Compile the list of file references to those standards, one file reference per line, using this logic for determining which files to include:
+   a. If the value for `standards` is simply `all`, then include every single file, folder, sub-folder and files within sub-folders in your list of files.
+   b. If the item under standards ends with "*" then it means that all files within this folder or sub-folder should be included. For example, `frontend/*` means include all files and sub-folders and their files located inside of `agent-os/standards/frontend/`.
+   c. If a file ends in `.md` then it means this is one specific file you must include in your list of files. For example `backend/api.md` means you must include the file located at `agent-os/standards/backend/api.md`.
+   d. De-duplicate files in your list of file references.
+
+##### Output Format
+
+The compiled list of standards should look something like this, where each file reference is on its own line and begins with `@`. The exact list of files will vary:
+
+```
+@agent-os/standards/global/coding-style.md
+@agent-os/standards/global/conventions.md
+@agent-os/standards/global/tech-stack.md
+@agent-os/standards/backend/api/authentication.md
+@agent-os/standards/backend/api/endpoints.md
+@agent-os/standards/backend/api/responses.md
+@agent-os/standards/frontend/css.md
+@agent-os/standards/frontend/responsive.md
+```
+
+
+Provide all of the above to the subagent when delegating tasks for it to implement.

package/src/template/agent-os/commands/plan-product/1-product-concept.md

@@ -0,0 +1,53 @@
+This begins a multi-step process for planning and documenting the mission and roadmap for the current product.
+
+The FIRST STEP is to confirm the product details by following these instructions:
+
+Collect comprehensive product information from the user:
+
+```bash
+# Check if product folder already exists
+if [ -d "agent-os/product" ]; then
+    echo "Product documentation already exists. Review existing files or start fresh?"
+    # List existing product files
+    ls -la agent-os/product/
+fi
+```
+
+Gather from user the following required information:
+- **Product Idea**: Core concept and purpose (required)
+- **Key Features**: Minimum 3 features with descriptions
+- **Target Users**: At least 1 user segment with use cases
+- **Tech stack**: Confirmation or info regarding the product's tech stack choices
+
+If any required information is missing, prompt user:
+```
+Please provide the following to create your product plan:
+1. Main idea for the product
+2. List of key features (minimum 3)
+3. Target users and use cases (minimum 1)
+4. Will this product use your usual tech stack choices or deviate in any way?
+```
+
+
+Then WAIT for me to give you specific instructions on how to use the information you've gathered to create the mission and roadmap.
+
+## Display confirmation and next step
+
+Once you've gathered all of the necessary information, output the following message:
+
+```
+I have all the info I need to help you plan this product.
+
+NEXT STEP 👉 Run the command, `2-create-mission.md`
+```
+
+## User Standards & Preferences Compliance
+
+When planning the product's tech stack, mission statement and roadmap, use the user's standards and preferences for context and baseline assumptions, as documented in these files:
+
+@agent-os/standards/global/coding-style.md
+@agent-os/standards/global/commenting.md
+@agent-os/standards/global/conventions.md
+@agent-os/standards/global/error-handling.md
+@agent-os/standards/global/tech-stack.md
+@agent-os/standards/global/validation.md

package/src/template/agent-os/commands/plan-product/2-create-mission.md

@@ -0,0 +1,78 @@
+Now that you've gathered information about this product, use that info to create the mission document in `agent-os/product/mission.md` by following these instructions:
+
+Create `agent-os/product/mission.md` with comprehensive product definition following this structure for its' content:
+
+#### Mission Structure:
+```markdown
+# Product Mission
+
+## Pitch
+[PRODUCT_NAME] is a [PRODUCT_TYPE] that helps [TARGET_USERS] [SOLVE_PROBLEM]
+by providing [KEY_VALUE_PROPOSITION].
+
+## Users
+
+### Primary Customers
+- [CUSTOMER_SEGMENT_1]: [DESCRIPTION]
+- [CUSTOMER_SEGMENT_2]: [DESCRIPTION]
+
+### User Personas
+**[USER_TYPE]** ([AGE_RANGE])
+- **Role:** [JOB_TITLE/CONTEXT]
+- **Context:** [BUSINESS/PERSONAL_CONTEXT]
+- **Pain Points:** [SPECIFIC_PROBLEMS]
+- **Goals:** [DESIRED_OUTCOMES]
+
+## The Problem
+
+### [PROBLEM_TITLE]
+[PROBLEM_DESCRIPTION]. [QUANTIFIABLE_IMPACT].
+
+**Our Solution:** [SOLUTION_APPROACH]
+
+## Differentiators
+
+### [DIFFERENTIATOR_TITLE]
+Unlike [COMPETITOR/ALTERNATIVE], we provide [SPECIFIC_ADVANTAGE].
+This results in [MEASURABLE_BENEFIT].
+
+## Key Features
+
+### Core Features
+- **[FEATURE_NAME]:** [USER_BENEFIT_DESCRIPTION]
+
+### Collaboration Features
+- **[FEATURE_NAME]:** [USER_BENEFIT_DESCRIPTION]
+
+### Advanced Features
+- **[FEATURE_NAME]:** [USER_BENEFIT_DESCRIPTION]
+```
+
+#### Important Constraints
+
+- **Focus on user benefits** in feature descriptions, not technical details
+- **Keep it concise** and easy for users to scan and get the more important concepts quickly
+
+
+## Display confirmation and next step
+
+Once you've created mission.md, output the following message:
+
+```
+✅ I have documented the product mission at `agent-os/product/mission.md`.
+
+Review it to ensure it matches your vision and strategic goals for this product.
+
+NEXT STEP 👉 Run the command, `3-create-roadmap.md`
+```
+
+## User Standards & Preferences Compliance
+
+IMPORTANT: Ensure the product mission is ALIGNED and DOES NOT CONFLICT with the user's preferences and standards as detailed in the following files:
+
+@agent-os/standards/global/coding-style.md
+@agent-os/standards/global/commenting.md
+@agent-os/standards/global/conventions.md
+@agent-os/standards/global/error-handling.md
+@agent-os/standards/global/tech-stack.md
+@agent-os/standards/global/validation.md

package/src/template/agent-os/commands/plan-product/3-create-roadmap.md

@@ -0,0 +1,73 @@
+Now that you've created this product's mission.md, use that to guide your creation of the roadmap in `agent-os/product/roadmap.md` by following these instructions:
+
+Generate `agent-os/product/roadmap.md` with an ordered feature checklist:
+
+Do not include any tasks for initializing a new codebase or bootstrapping a new application. Assume the user is already inside the project's codebase and has a bare-bones application initialized.
+
+#### Creating the Roadmap:
+
+1. **Review the Mission** - Read `agent-os/product/mission.md` to understand the product's goals, target users, and success criteria.
+
+2. **Identify Features** - Based on the mission, determine the list of concrete features needed to achieve the product vision.
+
+3. **Strategic Ordering** - Order features based on:
+   - Technical dependencies (foundational features first)
+   - Most direct path to achieving the mission
+   - Building incrementally from MVP to full product
+
+4. **Create the Roadmap** - Use the structure below as your template. Replace all bracketed placeholders (e.g., `[FEATURE_NAME]`, `[DESCRIPTION]`, `[EFFORT]`) with real content that you create based on the mission.
+
+#### Roadmap Structure:
+```markdown
+# Product Roadmap
+
+1. [ ] [FEATURE_NAME] — [1-2 SENTENCE DESCRIPTION OF COMPLETE, TESTABLE FEATURE] `[EFFORT]`
+2. [ ] [FEATURE_NAME] — [1-2 SENTENCE DESCRIPTION OF COMPLETE, TESTABLE FEATURE] `[EFFORT]`
+3. [ ] [FEATURE_NAME] — [1-2 SENTENCE DESCRIPTION OF COMPLETE, TESTABLE FEATURE] `[EFFORT]`
+4. [ ] [FEATURE_NAME] — [1-2 SENTENCE DESCRIPTION OF COMPLETE, TESTABLE FEATURE] `[EFFORT]`
+5. [ ] [FEATURE_NAME] — [1-2 SENTENCE DESCRIPTION OF COMPLETE, TESTABLE FEATURE] `[EFFORT]`
+6. [ ] [FEATURE_NAME] — [1-2 SENTENCE DESCRIPTION OF COMPLETE, TESTABLE FEATURE] `[EFFORT]`
+7. [ ] [FEATURE_NAME] — [1-2 SENTENCE DESCRIPTION OF COMPLETE, TESTABLE FEATURE] `[EFFORT]`
+8. [ ] [FEATURE_NAME] — [1-2 SENTENCE DESCRIPTION OF COMPLETE, TESTABLE FEATURE] `[EFFORT]`
+
+> Notes
+> - Order items by technical dependencies and product architecture
+> - Each item should represent an end-to-end (frontend + backend) functional and testable feature
+```
+
+Effort scale:
+- `XS`: 1 day
+- `S`: 2-3 days
+- `M`: 1 week
+- `L`: 2 weeks
+- `XL`: 3+ weeks
+
+#### Important Constraints
+
+- **Make roadmap actionable** - include effort estimates and dependencies
+- **Priorities guided by mission** - When deciding on order, aim for the most direct path to achieving the mission as documented in mission.md
+- **Ensure phases are achievable** - start with MVP, build incrementally
+
+
+## Display confirmation and next step
+
+Once you've created roadmap.md, output the following message:
+
+```
+✅ I have documented the product roadmap at `agent-os/product/roadmap.md`.
+
+Review it to ensure it aligns with how you see this product roadmap going forward.
+
+NEXT STEP 👉 Run the command, `4-create-tech-stack.md`
+```
+
+## User Standards & Preferences Compliance
+
+IMPORTANT: Ensure the product roadmap is ALIGNED and DOES NOT CONFLICT with the user's preferences and standards as detailed in the following files:
+
+@agent-os/standards/global/coding-style.md
+@agent-os/standards/global/commenting.md
+@agent-os/standards/global/conventions.md
+@agent-os/standards/global/error-handling.md
+@agent-os/standards/global/tech-stack.md
+@agent-os/standards/global/validation.md