### One-Command Startup

Source: https://github.com/4regab/tasksync/blob/main/TaskSyncUI/README.md

This script automates the setup and launch of the TaskSync server. It creates a virtual environment, installs dependencies, sets up directories, starts the server, and opens the application in the browser.

```bash
cd TaskSyncV3
python3 start.py
```

--------------------------------

### TaskSync Web Interface Setup

Source: https://github.com/4regab/tasksync/blob/main/USAGE.md

Steps to clone the TaskSync repository, set up the UI, and start the web interface. The UI provides a visual way to submit and manage tasks.

```bash
git clone --filter=blob:none --sparse https://github.com/4regab/TaskSync.git
cd TaskSync
git sparse-checkout set TaskSyncUI
cd TaskSyncUI
python3 start.py
```

--------------------------------

### Manual Development Setup

Source: https://github.com/4regab/tasksync/blob/main/TaskSyncUI/README.md

Provides instructions for manually setting up the TaskSync development environment. This includes creating a virtual environment, activating it, installing backend dependencies, and starting the server.

```python
# Create virtual environment
python3 -m venv venv
source venv/bin/activate  # Linux/macOS
# or venv\Scripts\activate  # Windows

# Install dependencies
pip install -r backend/requirements.txt

# Start server
python backend/main.py
```

--------------------------------

### Launching TaskSyncUI

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

Starts the TaskSync Monitor UI application. This command navigates to the TaskSyncUI directory and executes the start script.

```bash
cd TaskSyncUI
python start.py
```

--------------------------------

### TaskSync File Mode Setup

Source: https://github.com/4regab/tasksync/blob/main/USAGE.md

Instructions on how to set up and use TaskSync in file mode. This involves adding the TaskSync protocol as context, instructing the AI to follow it, and adding tasks to a designated file.

```markdown
1. **Add TaskSync Protocol as Context**
   - Drag only the TaskSync instructions file (e.g., `tasksync.md`) into your chat as context. This gives your AI assistant access to the TaskSync rules it must follow.

2. **Strictly Follow the Protocol**
   - Instruct your AI: `Strictly follow tasksync.md`.
   - This ensures the agent operates with infinite monitoring, proper logging, and task continuation priority.

3. **Add Your Tasks**
   - Open or create `tasks.md` (in `.github/`, `.cursor/rules/`, `.kiro/`, or `.global/` depending on your IDE).
   - Write your tasks, corrections, or urgent overrides in markdown format. See `EXAMPLES.md` for templates and best practices.

4. **Start TaskSync**
   - After adding your tasks, send a message in chat: `Strictly follow tasksync.md, add tasks in tasks.md and then send.`
   - TaskSync will now begin executing your tasks, monitoring for changes, and logging all activity.

5. **Add New Instructions Anytime**
   - You can add new tasks or corrections to `tasks.md` at any time—before or after the current task is done.
   - TaskSync will always finish the current task (unless you use an urgent override), then process new instructions automatically.
   - This saves you from sending repeated requests—just update `tasks.md` and TaskSync will handle the rest.

6. **Session Never Ends Automatically**
   - TaskSync will continue monitoring and executing tasks indefinitely until you explicitly say `stop`, `end`, `terminate`, or `quit`.
```

--------------------------------

### Frontend Project Template

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

A template for setting up a frontend project, covering phases from initial setup and core features to polishing the user interface and performance.

```text
# Project: [Project Name]
# Framework: [React/Vue/Angular/etc.]
# Styling: [Tailwind/Styled Components/CSS Modules]

Phase 1 - Setup:
- Initialize project with proper folder structure
- Set up linting (ESLint, Prettier)
- Configure build tools and bundler
- Add basic routing

Phase 2 - Core Features:
- Implement main layout and navigation
- Create reusable UI components
- Add state management
- Implement data fetching

Phase 3 - Polish:
- Add loading states and error handling
- Implement responsive design
- Add animations and transitions
- Optimize performance
```

--------------------------------

### Backend API Template

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

A template for developing a backend API, including foundational setup, core features, and considerations for security and testing.

```text
# Project: [API Name]
# Framework: [Express/FastAPI/Django/etc.]
# Database: [MongoDB/PostgreSQL/MySQL]

Foundation:
- Set up project structure
- Configure environment variables
- Add authentication middleware
- Set up database connection
- Add input validation

Core Features:
- Implement CRUD operations
- Add API documentation (Swagger/OpenAPI)
- Set up error handling
- Add logging
- Implement rate limiting

Security & Testing:
- Add security headers
- Implement CORS properly
- Write unit tests
- Add integration tests
- Set up CI/CD pipeline
```

--------------------------------

### Setup and Run TaskSync UI

Source: https://github.com/4regab/tasksync/blob/main/README.md

Clones the TaskSync repository, sets up sparse checkout for the UI, and runs the Python start script to launch the TaskSync web interface.

```bash
git clone --no-checkout https://github.com/4regab/TaskSync.git
cd TaskSync
git sparse-checkout init
echo "TaskSyncUI/*" > .git/info/sparse-checkout
git read-tree -m -u HEAD
cd TaskSyncUI
python3 start.py
```

--------------------------------

### tasks.txt Best Practices

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

Examples of good and bad task entries in tasks.txt, along with tips for writing effective tasks. This includes using comments, being specific, and breaking down large tasks.

```text
# Clear, actionable tasks
Create user registration form with:
- Email validation
- Password strength requirements
- Confirm password field
- Terms of service checkbox

# Specific technical requirements
Use React Hook Form for validation
Style with Tailwind CSS
Add loading states and error messages
```

```text
# Too vague
Make the app better

# No context
Fix the bug

# Missing requirements
Add authentication
```

```text
1. Be Specific: Include tech stack, requirements, and constraints
2. Use Comments: Organize tasks with `#` comments for clarity
3. Set Priorities: Use keywords like `URGENT`, `HIGH PRIORITY`, `LATER`
4. Include Context: Explain the why, not just the what
5. Break Down Large Tasks: Split complex features into smaller steps
```

--------------------------------

### Troubleshooting: Misunderstood Instructions

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

Guidance on improving AI understanding by providing more specific and detailed instructions in tasks.txt, contrasting vague requests with concrete examples.

```text
# Instead of: "Add validation"
# Use this: "Add form validation with these rules:
- Email must be valid format
- Password minimum 8 characters
- Phone number must be 10 digits
- All fields required before submission"
```

--------------------------------

### TaskSync Log Tracking Example

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

This snippet demonstrates the continuation of log tracking for the TaskSync project, showing updates on inventory management API endpoints, authentication bug fixes, and the start of search functionality implementation.

```text
Check #28: Word count: 102 words (no change). Inventory management API endpoints 60% complete.
Check #29: Word count: 102 words (no change). Authentication bug fix applied.
Check #30: Word count: 102 words (no change). Search functionality implementation started.
```

--------------------------------

### Development Installation for TaskSync VS Code Extension

Source: https://github.com/4regab/tasksync/blob/main/TaskSyncExtension/README.md

Steps to clone the TaskSync repository, navigate to the extension directory, install dependencies, and launch the extension in VS Code for development.

```bash
git clone https://github.com/4regab/TaskSync.git
cd TaskSync/TaskSyncExtension
npm install
# Press F5 in VS Code to launch
```

--------------------------------

### File-Based Task Corrections

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

Provides examples of how to input corrections or modifications to existing tasks by editing the `tasks.txt` file. These corrections guide the AI agent in refining the project.

```text
# CORRECTION: Use TypeScript instead of JavaScript
# CORRECTION: Add input validation for all forms
# CORRECTION: Use bcrypt for password hashing
```

--------------------------------

### TaskSync V3 Monitoring Log Example

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

Illustrates the format and content of the `log.txt` file used by TaskSync V3 for monitoring progress and detecting changes. It shows session information, platform detection, and word count changes.

```text
=== TASKSYNC V3 MONITORING LOG ===
Session: #1
Platform: Linux/macOS/Windows
Baseline word count: 47

--- MONITORING STATUS ---
Check #1: Word count: 47 words (baseline). Initial task received.
Check #2: Word count: 47 words (no change). Task in progress.
Check #3: Word count: 63 words (CHANGE DETECTED). Reading tasks.txt...
Check #4: Word count: 63 words (no change). Implementing changes.
```

--------------------------------

### TaskSync Core Features

Source: https://github.com/4regab/tasksync/blob/main/USAGE.md

Summarizes the core capabilities and benefits of the TaskSync protocol, emphasizing its persistent and autonomous task execution.

```markdown
- Infinite monitoring without automatic termination
- Real-time status logging directly in tasks.md file  
- Complete file reading (minimum 1000 lines per operation)
- Terminal-based monitoring for cross-platform compatibility
- Manual termination only - you control when to stop
- Robust error handling with continuous operation
- Seamless instruction integration without losing context
- Optional web interface for visual task management
```

--------------------------------

### TaskSync V3 Log Update Example

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

Shows an updated log entry in `log.txt` reflecting the application of corrections, such as converting to TypeScript and implementing security improvements. This demonstrates the agent's response to modifications.

```text
Check #7: Word count: 63 words (CHANGE DETECTED). Reading tasks.txt...
Check #8: Word count: 63 words (no change). Applying TypeScript conversion and security improvements.
```

--------------------------------

### TaskSync UI Features

Source: https://github.com/4regab/tasksync/blob/main/USAGE.md

Highlights the features of the TaskSync web interface, including task submission, real-time monitoring, and customization options.

```markdown
- Visual task submission and management
- Real-time WebSocket communication
- File browser for easy workspace navigation
- Modern responsive design with dark/light themes
```

--------------------------------

### TaskSync Project Update Instructions

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

This snippet illustrates how to update the `tasks.txt` file to define new phases and tasks for the TaskSync project, including new task additions and priority bug fixes.

```text
# PHASE 1 COMPLETE - Moving to Phase 2
# NEW TASK: Add inventory management
# NEW TASK: Implement search and filtering
# PRIORITY: Fix the authentication middleware bug
```

--------------------------------

### AI Internal State and Dual File System Protocol

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

This section explains the AI assistant's internal state reporting and the dual file system format used for task management (`tasks.txt`) and monitoring (`log.txt`), including state meanings and status log examples.

```APIDOC
AI_PROTOCOL:
  INTERNAL_STATE:
    - Meaning: Reports the current operational status of the AI assistant.
    - States:
      - Active: AI is actively processing tasks and monitoring updates at regular intervals (e.g., every 180 seconds).
      - Monitoring: AI has completed current tasks and enters a low-power monitoring mode, checking for updates more frequently (e.g., every 30 seconds).
    - Example Format:
      [INTERNAL: State - Active]
      [INTERNAL: Next check scheduled in 180s (180000ms)]

  DUAL_FILE_SYSTEM:
    - Description: A system using two distinct files for task management and operational logging.
    - tasks.txt:
      - Purpose: User-editable file for defining current priorities and new feature requests.
      - Format:
        # Current Priority
        Fix the authentication bug in login.tsx
        Add TypeScript types for user profile

        # New Feature Request  
        Create a dashboard component with charts
    - log.txt:
      - Purpose: Agent-managed file for monitoring task progress and system status.
      - Format:
        === TASKSYNC MONITORING LOG ===
        Session: #1
        Baseline word count: 7

        --- MONITORING STATUS ---
        Check #1: Word count: 7 words (baseline). No new instructions found.
        Check #2: Word count: 7 words (no change). No new instructions found.
        Check #3: Word count: 12 words (CHANGE DETECTED). NEW INSTRUCTIONS FOUND!
        Check #15: Word count: 14 words (no change). Authentication system 90% complete.
        Check #42: Word count: 18 words (no change). All tasks completed, monitoring for new instructions.
```

--------------------------------

### Infinite Monitoring and Logging Example

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

This snippet demonstrates the output of the Protocol v2.0 for infinite monitoring and logging. It includes internal state information, session details, baseline word count, and a chronological log of monitoring checks, highlighting detected changes in word count.

```text
[INTERNAL: State - Monitoring]
[INTERNAL: Next check scheduled in 30s (30000ms)]

=== TASKSYNC MONITORING LOG ===
Session: #2
Baseline word count: 35

--- MONITORING STATUS ---
Check #1: Word count: 35 words (baseline). New session started - no conversation history found.
Check #2: Word count: 35 words (no change). Task in progress.
Check #3: Word count: 47 words (CHANGE DETECTED). Reading tasks.txt...
Check #4: Word count: 47 words (no change). Task complete - monitoring mode.
Check #5: Word count: 47 words (no change). No file read needed.
Check #6: Word count: 63 words (CHANGE DETECTED). Reading tasks.txt...
```

--------------------------------

### Example tasks.md for File Mode

Source: https://github.com/4regab/tasksync/blob/main/README.md

An example of how to format tasks within the tasks.md file for TaskSync's file mode operation. The agent automatically detects changes in this file.

```markdown
# Task

Fix the authentication bug in login.tsx
Add TypeScript types for user profile
```

--------------------------------

### Troubleshooting: Monitoring Issues & Restart

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

Checks for common monitoring problems like non-incrementing status logs or file permission errors, and provides a quick fix by adding specific commands to tasks.txt to restart monitoring.

```text
# Add to tasks.txt to restart monitoring:
# RESTART: Continue working on current tasks
# STATUS: Please report current progress
# VERIFY: Read this entire file and log status

--- STATUS LOG ---
Check #1: - Read tasks.txt containing [X] lines. Monitoring restarted.
```

--------------------------------

### File-Based Task Definition

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

Defines project tasks and tech stack in a simple text file for TaskSync V3. This is the traditional method for inputting tasks.

```text
# Project: User Management System
Create a modern web application with:
1. User registration with email verification
2. Login/logout functionality  
3. Password reset feature
4. User profile management
5. Responsive design with modern UI

Tech stack: React, Node.js, MongoDB
```

--------------------------------

### Troubleshooting: AI Not Responding

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

Steps to diagnose and resolve issues where the AI is not responding to changes in tasks.txt, including checking logs and testing file monitoring.

```text
# Add this to your tasks.txt to test monitoring:
# TEST: If you can read this, monitoring is working
# Current time: [your current time]

# Check STATUS LOG for monitoring activity:
--- STATUS LOG ---
Check #[X]: - Read tasks.txt containing [Y] lines. [Status message]
```

--------------------------------

### Adding New Development Tasks

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

Demonstrates how to append new tasks or requirements to the project's task list, typically in a file like `.github/tasks.txt`. The agent detects these changes and incorporates them into the workflow.

```text
# NEW TASK: Add OAuth2 login (Google, GitHub)
# NEW TASK: Implement role-based access control
# NEW TASK: Add unit tests with Jest
```

--------------------------------

### Troubleshooting: Ending Session

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

Instructions on how to manually terminate the AI monitoring session, emphasizing that the AI does not stop automatically and requires explicit commands.

```text
# Add to tasks.txt or say directly:
# TERMINATE: Stop monitoring and end session
# Or say: "stop", "end", "terminate", or "quit"
```

--------------------------------

### File-Based API Project Definition

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

Defines requirements for an e-commerce API project using TaskSync V3's file-based input. It outlines features like product catalog, shopping cart, payment integration, and documentation standards.

```text
# Project: E-commerce API V3
Build a RESTful API with:
- Product catalog management
- Shopping cart functionality
- Order processing
- Payment integration (Stripe)
- Admin dashboard

Requirements:
- OpenAPI/Swagger documentation
- Input validation and sanitization
- JWT authentication
- Rate limiting
- Comprehensive error handling
- Unit and integration tests
```

--------------------------------

### TaskSync AI Monitoring - State 2 Behavior

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

Details the mandatory `Start-Sleep -Seconds 30` command executed before each monitoring check in State 2, ensuring a delay between operations.

```powershell
Start-Sleep -Seconds 30
```

--------------------------------

### TaskSync Monitoring Log (V3 Enhanced)

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

This snippet shows the structure and content of the V3 Enhanced monitoring log for TaskSync, including session details, platform information, baseline word count, and step-by-step monitoring status updates.

```text
=== TASKSYNC V3 MONITORING LOG ===
Session: #1
Platform: Cross-Platform
Baseline word count: 82

--- MONITORING STATUS ---
Check #1: Word count: 82 words (baseline). API project initialization started.
Check #2: Word count: 82 words (no change). Express.js setup complete.
Check #3: Word count: 82 words (no change). JWT authentication middleware complete.
```

--------------------------------

### Mobile App Development Project Outline

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

This snippet outlines the project for a cross-platform mobile task management application using React Native and Firebase, detailing core features, tech stack, design principles, and Sprint 1 focus.

```text
# Project: Task Management Mobile App
Create a cross-platform mobile application:

Core Features:
- Task creation and management
- Project organization
- Team collaboration
- File attachments
- Offline functionality
- Push notifications

Tech Stack: React Native, Firebase
Design: Material Design 3
Platform: iOS and Android

Sprint 1 Focus:
- Basic CRUD operations
- User authentication
- Local storage
```

--------------------------------

### Code Refactoring Project Goals

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

This snippet outlines a code refactoring project aimed at modernizing a legacy codebase, detailing current issues such as mixed file types and lack of tests, and setting refactoring goals including TypeScript conversion and test coverage.

```text
# REFACTORING: Legacy codebase modernization
Current issues:
- Mixed JavaScript/TypeScript files
- No type safety
- Inconsistent coding styles
- Missing error handling
- No automated tests

Refactoring goals:
1. Convert all .js files to TypeScript
2. Add comprehensive type definitions
3. Implement ESLint + Prettier
4. Add unit tests (target 80% coverage)
5. Update documentation
6. Remove deprecated dependencies

Timeline: 2 weeks
Priority: Medium (technical debt)
```

--------------------------------

### Bug Fixing Session: User Login Issue

Source: https://github.com/4regab/tasksync/blob/main/EXAMPLES.md

This snippet details a bug report for a user login issue in a web application, including steps to reproduce the bug and a debug checklist covering common areas like JWT tokens, database connections, and browser checks.

```text
# BUG REPORT: User login not working
Steps to reproduce:
1. Enter valid email/password
2. Click login button
3. Page refreshes but user not logged in

Debug checklist:
- Check JWT token generation
- Verify database connection
- Test password hashing
- Review session management
- Check browser network tab
- Test with different browsers

PRIORITY: High - blocking production release
```

--------------------------------

### Building and Packaging the TaskSync VS Code Extension

Source: https://github.com/4regab/tasksync/blob/main/TaskSyncExtension/README.md

Commands to compile the TaskSync extension source code and package it into a .vsix file for distribution.

```bash
# To compile the extension:
npm run compile

# To create a .vsix package:
npm install -g vsce
vsce package
```

--------------------------------

### Clone TaskSync for Any IDE (Global)

Source: https://github.com/4regab/tasksync/blob/main/README.md

Clones the TaskSync repository and sets up sparse checkout for global IDE integration. This method checks out a broader set of files for general use.

```bash
git clone --no-checkout https://github.com/4regab/TaskSync.git
cd TaskSync
git sparse-checkout init
echo ".global/*" > .git/info/sparse-checkout
git read-tree -m -u HEAD
```

--------------------------------

### Web Interface TaskSync Protocol

Source: https://github.com/4regab/tasksync/blob/main/README.md

Instructs the AI agent to strictly adhere to the TaskSync Protocol when using the web interface. This requires attaching the tasksync.md prompt file.

```markdown
Strictly adhere to TaskSync Protocol #tasksync.md
```

--------------------------------

### Clone TaskSync for Kiro IDE

Source: https://github.com/4regab/tasksync/blob/main/README.md

Clones the TaskSync repository and sets up sparse checkout for Kiro IDE integration. This command ensures only Kiro-specific files are checked out.

```bash
git clone --no-checkout https://github.com/4regab/TaskSync.git
cd TaskSync
git sparse-checkout init
echo ".kiro/*" > .git/info/sparse-checkout
git read-tree -m -u HEAD
```

--------------------------------

### TaskSync VS Code Extension Features

Source: https://github.com/4regab/tasksync/blob/main/README.md

Highlights the key features of the TaskSync VS Code extension, including its integrated chat interface, one-click Copilot activation, automatic file management, file attachment support, task categorization, and real-time chat capabilities.

```markdown
- 🎯 **Integrated Chat Interface**: Send tasks directly through VS Code sidebar
- 🤖 **One-Click Copilot Activation**:You only need to click/send this for the first initialization or when the chat ends.
- 📁 **Automatic File Management**: Creates and manages `tasks.md` and `log.md` files
- 📎 **File Attachment Support**: Reference files for context
- 🏷️ **Task Categorization**: Organize tasks by type (Task, Bug, Feature, Research)
- 💬 **Real-time Chat**: View conversation history and responses instantly
```

--------------------------------

### API Endpoints and WebSocket

Source: https://github.com/4regab/tasksync/blob/main/TaskSyncUI/README.md

Lists the available API endpoints for interacting with the TaskSync system. This includes the main frontend URL, a health check endpoint, and the WebSocket endpoint for real-time communication.

```APIDOC
Frontend:
  URL: http://localhost:8000

Health Check:
  URL: http://localhost:8000/api/health
  Method: GET
  Description: Checks the health status of the TaskSync server.
  Returns: A JSON object indicating the server status.

WebSocket:
  URL: ws://localhost:8000/ws
  Description: Establishes a WebSocket connection for real-time updates from the backend.
```

--------------------------------

### Clone TaskSync for Cursor IDE

Source: https://github.com/4regab/tasksync/blob/main/README.md

Clones the TaskSync repository and sets up sparse checkout for Cursor IDE integration. This method focuses on checking out the necessary files for Cursor.

```bash
git clone --no-checkout https://github.com/4regab/TaskSync.git
cd TaskSync
git sparse-checkout init
echo ".cursor/*" > .git/info/sparse-checkout
git read-tree -m -u HEAD
```

--------------------------------

### Project Dependencies

Source: https://github.com/4regab/tasksync/blob/main/TaskSyncUI/backend/requirements.txt

This snippet lists the essential Python packages and their specific versions required for the TaskSync project. These dependencies ensure the proper functioning of the web server, real-time communication, file system monitoring, data validation, and request handling.

```python
fastapi==0.104.1
uvicorn[standard]==0.24.0
websockets==12.0
watchdog==3.0.0
pydantic==2.5.0
python-multipart==0.0.6
```

--------------------------------

### Clone TaskSync for VS Code Copilot

Source: https://github.com/4regab/tasksync/blob/main/README.md

Clones the TaskSync repository and sets up sparse checkout for VS Code Copilot integration. This allows for selective checkout of specific directories.

```bash
git clone --no-checkout https://github.com/4regab/TaskSync.git
cd TaskSync
git sparse-checkout init
echo ".github/*" > .git/info/sparse-checkout
git read-tree -m -u HEAD
```

--------------------------------

### Frontend JavaScript Logic

Source: https://github.com/4regab/tasksync/blob/main/TaskSyncUI/README.md

Contains the core client-side logic for the TaskSync frontend. This includes handling WebSocket communication for real-time updates, managing the UI, and implementing features like the file browser modal.

```javascript
// frontend/js/main.js
// Contains all client logic for TaskSync.
```

--------------------------------

### Frontend CSS Styling

Source: https://github.com/4regab/tasksync/blob/main/TaskSyncUI/README.md

Defines the styling for the TaskSync frontend. It uses modern CSS with custom properties for easy theming and ensures a responsive design across different screen sizes.

```css
/* frontend/css/main.css */
/* Modern CSS styling with custom properties for theming. */
```

--------------------------------

### File Mode TaskSync Protocol

Source: https://github.com/4regab/tasksync/blob/main/README.md

Instructs the AI agent to strictly adhere to the TaskSync Protocol by referencing the tasksync.md file. This is used in conjunction with editing a tasks.md file.

```markdown
Strictly adhere to TaskSync Protocol #tasksync.md
```

--------------------------------

### VS Code Copilot Settings

Source: https://github.com/4regab/tasksync/blob/main/README.md

Configuration settings for VS Code Copilot to optimize TaskSync usage. Enables auto-approval of actions and sets a maximum number of requests for uninterrupted task execution.

```text
"chat.tools.autoApprove": true,
"chat.agent.maxRequests": 100
```

--------------------------------

### File Change Monitoring Commands

Source: https://github.com/4regab/tasksync/blob/main/README.md

Commands used by TaskSync to monitor changes in the 'tasks.md' file by checking its word count. This allows the agent to detect new instructions efficiently.

```bash
wc -w [tasks.md]
```

```powershell
Get-Content [tasks.md] | Measure-Object -Word
```

--------------------------------

### Monitoring Mode Commands

Source: https://github.com/4regab/tasksync/blob/main/README.md

Commands used by TaskSync to periodically check for file changes in 'tasks.md' during its monitoring phase. These commands are executed at a set interval.

```bash
sleep 30; wc -w [tasks.md]
```

```powershell
Start-Sleep -Seconds 30; Get-Content [tasks.md] | Measure-Object -Word
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.