diff --git a/.claude/agents/project-manager-backlog.md b/.claude/agents/project-manager-backlog.md
new file mode 100644
index 000000000..1cc6ad612
--- /dev/null
+++ b/.claude/agents/project-manager-backlog.md
@@ -0,0 +1,193 @@
+---
+name: project-manager-backlog
+description: Use this agent when you need to manage project tasks using the backlog.md CLI tool. This includes creating new tasks, editing tasks, ensuring tasks follow the proper format and guidelines, breaking down large tasks into atomic units, and maintaining the project's task management workflow. Examples: Context: User wants to create a new task for adding a feature. user: "I need to add a new authentication system to the project" assistant: "I'll use the project-manager-backlog agent that will use backlog cli to create a properly structured task for this feature." Since the user needs to create a task for the project, use the Task tool to launch the project-manager-backlog agent to ensure the task follows backlog.md guidelines. Context: User has multiple related features to implement. user: "We need to implement user profiles, settings page, and notification preferences" assistant: "Let me use the project-manager-backlog agent to break these down into atomic, independent tasks." The user has a complex set of features that need to be broken down into proper atomic tasks following backlog.md structure. Context: User wants to review if their task description is properly formatted. user: "Can you check if this task follows our guidelines: 'task-123 - Implement user login'" assistant: "I'll use the project-manager-backlog agent to review this task against our backlog.md standards." The user needs task review, so use the project-manager-backlog agent to ensure compliance with project guidelines.
+color: blue
+---
+
+You are an expert project manager specializing in the backlog.md task management system. You have deep expertise in creating well-structured, atomic, and testable tasks that follow software development best practices.
+
+## Backlog.md CLI Tool
+
+**IMPORTANT: Backlog.md uses standard CLI commands, NOT slash commands.**
+
+You use the `backlog` CLI tool to manage project tasks. This tool allows you to create, edit, and manage tasks in a structured way using Markdown files. You will never create tasks manually; instead, you will use the CLI commands to ensure all tasks are properly formatted and adhere to the project's guidelines.
+
+The backlog CLI is installed globally and available in the PATH. Here are the exact commands you should use:
+
+### Creating Tasks
+```bash
+backlog task create "Task title" -d "Description" --ac "First criteria,Second criteria" -l label1,label2
+```
+
+### Editing Tasks
+```bash
+backlog task edit 123 -s "In Progress" -a @claude
+```
+
+### Listing Tasks
+```bash
+backlog task list --plain
+```
+
+**NEVER use slash commands like `/create-task` or `/edit`. These do not exist in Backlog.md.**
+**ALWAYS use the standard CLI format: `backlog task create` (without any slash prefix).**
+
+### Example Usage
+
+When a user asks you to create a task, here's exactly what you should do:
+
+**User**: "Create a task to add user authentication"
+**You should run**:
+```bash
+backlog task create "Add user authentication system" -d "Implement a secure authentication system to allow users to register and login" --ac "Users can register with email and password,Users can login with valid credentials,Invalid login attempts show appropriate error messages" -l authentication,backend
+```
+
+**NOT**: `/create-task "Add user authentication"` ❌ (This is wrong - slash commands don't exist)
+
+## Your Core Responsibilities
+
+1. **Task Creation**: You create tasks that strictly adhere to the backlog.md cli commands. Never create tasks manually. Use available task create parameters to ensure tasks are properly structured and follow the guidelines.
+2. **Task Review**: You ensure all tasks meet the quality standards for atomicity, testability, and independence and task anatomy from below.
+3. **Task Breakdown**: You expertly decompose large features into smaller, manageable tasks
+4. **Context understanding**: You analyze user requests against the project codebase and existing tasks to ensure relevance and accuracy
+5. **Handling ambiguity**: You clarify vague or ambiguous requests by asking targeted questions to the user to gather necessary details
+
+## Task Creation Guidelines
+
+### **Title (one liner)**
+
+Use a clear brief title that summarizes the task.
+
+### **Description**: (The **"why"**)
+
+Provide a concise summary of the task purpose and its goal. Do not add implementation details here. It
+should explain the purpose, the scope and context of the task. Code snippets should be avoided.
+
+### **Acceptance Criteria**: (The **"what"**)
+
+List specific, measurable outcomes that define what means to reach the goal from the description. Use checkboxes (`- [ ]`) for tracking.
+When defining `## Acceptance Criteria` for a task, focus on **outcomes, behaviors, and verifiable requirements** rather
+than step-by-step implementation details.
+Acceptance Criteria (AC) define *what* conditions must be met for the task to be considered complete.
+They should be testable and confirm that the core purpose of the task is achieved.
+**Key Principles for Good ACs:**
+
+- **Outcome-Oriented:** Focus on the result, not the method.
+- **Testable/Verifiable:** Each criterion should be something that can be objectively tested or verified.
+- **Clear and Concise:** Unambiguous language.
+- **Complete:** Collectively, ACs should cover the scope of the task.
+- **User-Focused (where applicable):** Frame ACs from the perspective of the end-user or the system's external behavior.
+
+ - *Good Example:* "- [ ] User can successfully log in with valid credentials."
+ - *Good Example:* "- [ ] System processes 1000 requests per second without errors."
+ - *Bad Example (Implementation Step):* "- [ ] Add a new function `handleLogin()` in `auth.ts`."
+
+### Task file
+
+Once a task is created using backlog cli, it will be stored in `backlog/tasks/` directory as a Markdown file with the format
+`task- - .md` (e.g. `task-42 - Add GraphQL resolver.md`).
+
+## Task Breakdown Strategy
+
+When breaking down features:
+1. Identify the foundational components first
+2. Create tasks in dependency order (foundations before features)
+3. Ensure each task delivers value independently
+4. Avoid creating tasks that block each other
+
+### Additional task requirements
+
+- Tasks must be **atomic** and **testable**. If a task is too large, break it down into smaller subtasks.
+ Each task should represent a single unit of work that can be completed in a single PR.
+
+- **Never** reference tasks that are to be done in the future or that are not yet created. You can only reference
+ previous tasks (id < current task id).
+
+- When creating multiple tasks, ensure they are **independent** and they do not depend on future tasks.
+ Example of correct tasks splitting: task 1: "Add system for handling API requests", task 2: "Add user model and DB
+ schema", task 3: "Add API endpoint for user data".
+ Example of wrong tasks splitting: task 1: "Add API endpoint for user data", task 2: "Define the user model and DB
+ schema".
+
+## Recommended Task Anatomy
+
+```markdown
+# task‑42 - Add GraphQL resolver
+
+## Description (the why)
+
+Short, imperative explanation of the goal of the task and why it is needed.
+
+## Acceptance Criteria (the what)
+
+- [ ] Resolver returns correct data for happy path
+- [ ] Error response matches REST
+- [ ] P95 latency ≤ 50 ms under 100 RPS
+
+## Implementation Plan (the how) (added after putting the task in progress but before implementing any code change)
+
+1. Research existing GraphQL resolver patterns
+2. Implement basic resolver with error handling
+3. Add performance monitoring
+4. Write unit and integration tests
+5. Benchmark performance under load
+
+## Implementation Notes (for reviewers) (only added after finishing the code implementation of a task)
+
+- Approach taken
+- Features implemented or modified
+- Technical decisions and trade-offs
+- Modified or added files
+```
+
+## Quality Checks
+
+Before finalizing any task creation, verify:
+- [ ] Title is clear and brief
+- [ ] Description explains WHY without HOW
+- [ ] Each AC is outcome-focused and testable
+- [ ] Task is atomic (single PR scope)
+- [ ] No dependencies on future tasks
+
+You are meticulous about these standards and will guide users to create high-quality tasks that enhance project productivity and maintainability.
+
+## Self reflection
+When creating a task, always think from the perspective of an AI Agent that will have to work with this task in the future.
+Ensure that the task is structured in a way that it can be easily understood and processed by AI coding agents.
+
+## Handy CLI Commands
+
+| Action | Example |
+|-------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Create task | `backlog task create "Add OAuth System"` |
+| Create with description | `backlog task create "Feature" -d "Add authentication system"` |
+| Create with assignee | `backlog task create "Feature" -a @sara` |
+| Create with status | `backlog task create "Feature" -s "In Progress"` |
+| Create with labels | `backlog task create "Feature" -l auth,backend` |
+| Create with priority | `backlog task create "Feature" --priority high` |
+| Create with plan | `backlog task create "Feature" --plan "1. Research\n2. Implement"` |
+| Create with AC | `backlog task create "Feature" --ac "Must work,Must be tested"` |
+| Create with notes | `backlog task create "Feature" --notes "Started initial research"` |
+| Create with deps | `backlog task create "Feature" --dep task-1,task-2` |
+| Create sub task | `backlog task create -p 14 "Add Login with Google"` |
+| Create (all options) | `backlog task create "Feature" -d "Description" -a @sara -s "To Do" -l auth --priority high --ac "Must work" --notes "Initial setup done" --dep task-1 -p 14` |
+| List tasks | `backlog task list [-s <status>] [-a <assignee>] [-p <parent>]` |
+| List by parent | `backlog task list --parent 42` or `backlog task list -p task-42` |
+| View detail | `backlog task 7` (interactive UI, press 'E' to edit in editor) |
+| View (AI mode) | `backlog task 7 --plain` |
+| Edit | `backlog task edit 7 -a @sara -l auth,backend` |
+| Add plan | `backlog task edit 7 --plan "Implementation approach"` |
+| Add AC | `backlog task edit 7 --ac "New criterion,Another one"` |
+| Add notes | `backlog task edit 7 --notes "Completed X, working on Y"` |
+| Add deps | `backlog task edit 7 --dep task-1 --dep task-2` |
+| Archive | `backlog task archive 7` |
+| Create draft | `backlog task create "Feature" --draft` |
+| Draft flow | `backlog draft create "Spike GraphQL"` → `backlog draft promote 3.1` |
+| Demote to draft | `backlog task demote <id>` |
+
+Full help: `backlog --help`
+
+## Tips for AI Agents
+
+- **Always use `--plain` flag** when listing or viewing tasks for AI-friendly text output instead of using Backlog.md
+ interactive UI.
diff --git a/.cursor/rules/backlog-guildlines.md b/.cursor/rules/backlog-guildlines.md
new file mode 100644
index 000000000..ea95eb0b5
--- /dev/null
+++ b/.cursor/rules/backlog-guildlines.md
@@ -0,0 +1,398 @@
+
+# === BACKLOG.MD GUIDELINES START ===
+# Instructions for the usage of Backlog.md CLI Tool
+
+## What is Backlog.md?
+
+**Backlog.md is the complete project management system for this codebase.** It provides everything needed to manage tasks, track progress, and collaborate on development - all through a powerful CLI that operates on markdown files.
+
+### Core Capabilities
+
+✅ **Task Management**: Create, edit, assign, prioritize, and track tasks with full metadata
+✅ **Acceptance Criteria**: Granular control with add/remove/check/uncheck by index
+✅ **Board Visualization**: Terminal-based Kanban board (`backlog board`) and web UI (`backlog browser`)
+✅ **Git Integration**: Automatic tracking of task states across branches
+✅ **Dependencies**: Task relationships and subtask hierarchies
+✅ **Documentation & Decisions**: Structured docs and architectural decision records
+✅ **Export & Reporting**: Generate markdown reports and board snapshots
+✅ **AI-Optimized**: `--plain` flag provides clean text output for AI processing
+
+### Why This Matters to You (AI Agent)
+
+1. **Comprehensive system** - Full project management capabilities through CLI
+2. **The CLI is the interface** - All operations go through `backlog` commands
+3. **Unified interaction model** - You can use CLI for both reading (`backlog task 1 --plain`) and writing (`backlog task edit 1`)
+4. **Metadata stays synchronized** - The CLI handles all the complex relationships
+
+### Key Understanding
+
+- **Tasks** live in `backlog/tasks/` as `task-<id> - <title>.md` files
+- **You interact via CLI only**: `backlog task create`, `backlog task edit`, etc.
+- **Use `--plain` flag** for AI-friendly output when viewing/listing
+- **Never bypass the CLI** - It handles Git, metadata, file naming, and relationships
+
+---
+
+# ⚠️ CRITICAL: NEVER EDIT TASK FILES DIRECTLY
+
+**ALL task operations MUST use the Backlog.md CLI commands**
+- ✅ **DO**: Use `backlog task edit` and other CLI commands
+- ✅ **DO**: Use `backlog task create` to create new tasks
+- ✅ **DO**: Use `backlog task edit <id> --check-ac <index>` to mark acceptance criteria
+- ❌ **DON'T**: Edit markdown files directly
+- ❌ **DON'T**: Manually change checkboxes in files
+- ❌ **DON'T**: Add or modify text in task files without using CLI
+
+**Why?** Direct file editing breaks metadata synchronization, Git tracking, and task relationships.
+
+---
+
+## 1. Source of Truth & File Structure
+
+### 📖 **UNDERSTANDING** (What you'll see when reading)
+- Markdown task files live under **`backlog/tasks/`** (drafts under **`backlog/drafts/`**)
+- Files are named: `task-<id> - <title>.md` (e.g., `task-42 - Add GraphQL resolver.md`)
+- Project documentation is in **`backlog/docs/`**
+- Project decisions are in **`backlog/decisions/`**
+
+### 🔧 **ACTING** (How to change things)
+- **All task operations MUST use the Backlog.md CLI tool**
+- This ensures metadata is correctly updated and the project stays in sync
+- **Always use `--plain` flag** when listing or viewing tasks for AI-friendly text output
+
+---
+
+## 2. Common Mistakes to Avoid
+
+### ❌ **WRONG: Direct File Editing**
+```markdown
+# DON'T DO THIS:
+1. Open backlog/tasks/task-7 - Feature.md in editor
+2. Change "- [ ]" to "- [x]" manually
+3. Add notes directly to the file
+4. Save the file
+```
+
+### ✅ **CORRECT: Using CLI Commands**
+```bash
+# DO THIS INSTEAD:
+backlog task edit 7 --check-ac 1 # Mark AC #1 as complete
+backlog task edit 7 --notes "Implementation complete" # Add notes
+backlog task edit 7 -s "In Progress" -a @agent-k # Multiple commands: change status and assign the task
+```
+
+---
+
+## 3. Understanding Task Format (Read-Only Reference)
+
+⚠️ **FORMAT REFERENCE ONLY** - The following sections show what you'll SEE in task files.
+**Never edit these directly! Use CLI commands to make changes.**
+
+### Task Structure You'll See
+
+```markdown
+---
+id: task-42
+title: Add GraphQL resolver
+status: To Do
+assignee: [@sara]
+labels: [backend, api]
+---
+
+## Description
+Brief explanation of the task purpose.
+
+## Acceptance Criteria
+<!-- AC:BEGIN -->
+- [ ] #1 First criterion
+- [x] #2 Second criterion (completed)
+- [ ] #3 Third criterion
+<!-- AC:END -->
+
+## Implementation Plan
+1. Research approach
+2. Implement solution
+
+## Implementation Notes
+Summary of what was done.
+```
+
+### How to Modify Each Section
+
+| What You Want to Change | CLI Command to Use |
+|------------------------|-------------------|
+| Title | `backlog task edit 42 -t "New Title"` |
+| Status | `backlog task edit 42 -s "In Progress"` |
+| Assignee | `backlog task edit 42 -a @sara` |
+| Labels | `backlog task edit 42 -l backend,api` |
+| Description | `backlog task edit 42 -d "New description"` |
+| Add AC | `backlog task edit 42 --ac "New criterion"` |
+| Check AC #1 | `backlog task edit 42 --check-ac 1` |
+| Uncheck AC #2 | `backlog task edit 42 --uncheck-ac 2` |
+| Remove AC #3 | `backlog task edit 42 --remove-ac 3` |
+| Add Plan | `backlog task edit 42 --plan "1. Step one\n2. Step two"` |
+| Add Notes | `backlog task edit 42 --notes "What I did"` |
+
+---
+
+## 4. Defining Tasks
+
+### Creating New Tasks
+
+**Always use CLI to create tasks:**
+```bash
+backlog task create "Task title" -d "Description" --ac "First criterion" --ac "Second criterion"
+```
+
+### Title (one liner)
+Use a clear brief title that summarizes the task.
+
+### Description (The "why")
+Provide a concise summary of the task purpose and its goal. Explains the context without implementation details.
+
+### Acceptance Criteria (The "what")
+
+**Understanding the Format:**
+- Acceptance criteria appear as numbered checkboxes in the markdown files
+- Format: `- [ ] #1 Criterion text` (unchecked) or `- [x] #1 Criterion text` (checked)
+
+**Managing Acceptance Criteria via CLI:**
+
+⚠️ **IMPORTANT: How AC Commands Work**
+- **Adding criteria (`--ac`)** accepts multiple flags: `--ac "First" --ac "Second"` ✅
+- **Checking/unchecking/removing** accept multiple flags too: `--check-ac 1 --check-ac 2` ✅
+- **Mixed operations** work in a single command: `--check-ac 1 --uncheck-ac 2 --remove-ac 3` ✅
+
+```bash
+# Add new criteria (MULTIPLE values allowed)
+backlog task edit 42 --ac "User can login" --ac "Session persists"
+
+# Check specific criteria by index (MULTIPLE values supported)
+backlog task edit 42 --check-ac 1 --check-ac 2 --check-ac 3 # Check multiple ACs
+# Or check them individually if you prefer:
+backlog task edit 42 --check-ac 1 # Mark #1 as complete
+backlog task edit 42 --check-ac 2 # Mark #2 as complete
+
+# Mixed operations in single command
+backlog task edit 42 --check-ac 1 --uncheck-ac 2 --remove-ac 3
+
+# ❌ STILL WRONG - These formats don't work:
+# backlog task edit 42 --check-ac 1,2,3 # No comma-separated values
+# backlog task edit 42 --check-ac 1-3 # No ranges
+# backlog task edit 42 --check 1 # Wrong flag name
+
+# Multiple operations of same type
+backlog task edit 42 --uncheck-ac 1 --uncheck-ac 2 # Uncheck multiple ACs
+backlog task edit 42 --remove-ac 2 --remove-ac 4 # Remove multiple ACs (processed high-to-low)
+```
+
+**Key Principles for Good ACs:**
+- **Outcome-Oriented:** Focus on the result, not the method
+- **Testable/Verifiable:** Each criterion should be objectively testable
+- **Clear and Concise:** Unambiguous language
+- **Complete:** Collectively cover the task scope
+- **User-Focused:** Frame from end-user or system behavior perspective
+
+Good Examples:
+- "User can successfully log in with valid credentials"
+- "System processes 1000 requests per second without errors"
+
+Bad Example (Implementation Step):
+- "Add a new function handleLogin() in auth.ts"
+
+### Task Breakdown Strategy
+
+1. Identify foundational components first
+2. Create tasks in dependency order (foundations before features)
+3. Ensure each task delivers value independently
+4. Avoid creating tasks that block each other
+
+### Task Requirements
+
+- Tasks must be **atomic** and **testable** or **verifiable**
+- Each task should represent a single unit of work for one PR
+- **Never** reference future tasks (only tasks with id < current task id)
+- Ensure tasks are **independent** and don't depend on future work
+
+---
+
+## 5. Implementing Tasks
+
+### Implementation Plan (The "how") (only after starting work)
+```bash
+backlog task edit 42 -s "In Progress" -a @{myself}
+backlog task edit 42 --plan "1. Research patterns\n2. Implement\n3. Test"
+```
+
+### Implementation Notes (Imagine you need to copy paste this into a PR description)
+```bash
+backlog task edit 42 --notes "Implemented using pattern X, modified files Y and Z"
+```
+
+**IMPORTANT**: Do NOT include an Implementation Plan when creating a task. The plan is added only after you start implementation.
+- Creation phase: provide Title, Description, Acceptance Criteria, and optionally labels/priority/assignee.
+- When you begin work, switch to edit and add the plan: `backlog task edit <id> --plan "..."`.
+- Add Implementation Notes only after completing the work: `backlog task edit <id> --notes "..."`.
+
+Phase discipline: What goes where
+- Creation: Title, Description, Acceptance Criteria, labels/priority/assignee.
+- Implementation: Implementation Plan (after moving to In Progress).
+- Wrap-up: Implementation Notes, AC and Definition of Done checks.
+
+**IMPORTANT**: Only implement what's in the Acceptance Criteria. If you need to do more, either:
+1. Update the AC first: `backlog task edit 42 --ac "New requirement"`
+2. Or create a new task: `backlog task create "Additional feature"`
+
+---
+
+## 6. Typical Workflow
+
+```bash
+# 1. Identify work
+backlog task list -s "To Do" --plain
+
+# 2. Read task details
+backlog task 42 --plain
+
+# 3. Start work: assign yourself & change status
+backlog task edit 42 -a @myself -s "In Progress"
+
+# 4. Add implementation plan
+backlog task edit 42 --plan "1. Analyze\n2. Refactor\n3. Test"
+
+# 5. Work on the task (write code, test, etc.)
+
+# 6. Mark acceptance criteria as complete (supports multiple in one command)
+backlog task edit 42 --check-ac 1 --check-ac 2 --check-ac 3 # Check all at once
+# Or check them individually if preferred:
+# backlog task edit 42 --check-ac 1
+# backlog task edit 42 --check-ac 2
+# backlog task edit 42 --check-ac 3
+
+# 7. Add implementation notes
+backlog task edit 42 --notes "Refactored using strategy pattern, updated tests"
+
+# 8. Mark task as done
+backlog task edit 42 -s Done
+```
+
+---
+
+## 7. Definition of Done (DoD)
+
+A task is **Done** only when **ALL** of the following are complete:
+
+### ✅ Via CLI Commands:
+1. **All acceptance criteria checked**: Use `backlog task edit <id> --check-ac <index>` for each
+2. **Implementation notes added**: Use `backlog task edit <id> --notes "..."`
+3. **Status set to Done**: Use `backlog task edit <id> -s Done`
+
+### ✅ Via Code/Testing:
+4. **Tests pass**: Run test suite and linting
+5. **Documentation updated**: Update relevant docs if needed
+6. **Code reviewed**: Self-review your changes
+7. **No regressions**: Performance, security checks pass
+
+⚠️ **NEVER mark a task as Done without completing ALL items above**
+
+---
+
+## 8. Quick Reference: DO vs DON'T
+
+### Viewing Tasks
+| Task | ✅ DO | ❌ DON'T |
+|------|-------|----------|
+| View task | `backlog task 42 --plain` | Open and read .md file directly |
+| List tasks | `backlog task list --plain` | Browse backlog/tasks folder |
+| Check status | `backlog task 42 --plain` | Look at file content |
+
+### Modifying Tasks
+| Task | ✅ DO | ❌ DON'T |
+|------|-------|----------|
+| Check AC | `backlog task edit 42 --check-ac 1` | Change `- [ ]` to `- [x]` in file |
+| Add notes | `backlog task edit 42 --notes "..."` | Type notes into .md file |
+| Change status | `backlog task edit 42 -s Done` | Edit status in frontmatter |
+| Add AC | `backlog task edit 42 --ac "New"` | Add `- [ ] New` to file |
+
+---
+
+## 9. Complete CLI Command Reference
+
+### Task Creation
+| Action | Command |
+|--------|---------|
+| Create task | `backlog task create "Title"` |
+| With description | `backlog task create "Title" -d "Description"` |
+| With AC | `backlog task create "Title" --ac "Criterion 1" --ac "Criterion 2"` |
+| With all options | `backlog task create "Title" -d "Desc" -a @sara -s "To Do" -l auth --priority high` |
+| Create draft | `backlog task create "Title" --draft` |
+| Create subtask | `backlog task create "Title" -p 42` |
+
+### Task Modification
+| Action | Command |
+|--------|---------|
+| Edit title | `backlog task edit 42 -t "New Title"` |
+| Edit description | `backlog task edit 42 -d "New description"` |
+| Change status | `backlog task edit 42 -s "In Progress"` |
+| Assign | `backlog task edit 42 -a @sara` |
+| Add labels | `backlog task edit 42 -l backend,api` |
+| Set priority | `backlog task edit 42 --priority high` |
+
+### Acceptance Criteria Management
+| Action | Command |
+|--------|---------|
+| Add AC | `backlog task edit 42 --ac "New criterion" --ac "Another"` |
+| Remove AC #2 | `backlog task edit 42 --remove-ac 2` |
+| Remove multiple ACs | `backlog task edit 42 --remove-ac 2 --remove-ac 4` |
+| Check AC #1 | `backlog task edit 42 --check-ac 1` |
+| Check multiple ACs | `backlog task edit 42 --check-ac 1 --check-ac 3` |
+| Uncheck AC #3 | `backlog task edit 42 --uncheck-ac 3` |
+| Mixed operations | `backlog task edit 42 --check-ac 1 --uncheck-ac 2 --remove-ac 3 --ac "New"` |
+
+### Task Content
+| Action | Command |
+|--------|---------|
+| Add plan | `backlog task edit 42 --plan "1. Step one\n2. Step two"` |
+| Add notes | `backlog task edit 42 --notes "Implementation details"` |
+| Add dependencies | `backlog task edit 42 --dep task-1 --dep task-2` |
+
+### Task Operations
+| Action | Command |
+|--------|---------|
+| View task | `backlog task 42 --plain` |
+| List tasks | `backlog task list --plain` |
+| Filter by status | `backlog task list -s "In Progress" --plain` |
+| Filter by assignee | `backlog task list -a @sara --plain` |
+| Archive task | `backlog task archive 42` |
+| Demote to draft | `backlog task demote 42` |
+
+---
+
+## 10. Troubleshooting
+
+### If You Accidentally Edited a File Directly
+
+1. **DON'T PANIC** - But don't save or commit
+2. Revert the changes
+3. Make changes properly via CLI
+4. If already saved, the metadata might be out of sync - use `backlog task edit` to fix
+
+### Common Issues
+
+| Problem | Solution |
+|---------|----------|
+| "Task not found" | Check task ID with `backlog task list --plain` |
+| AC won't check | Use correct index: `backlog task 42 --plain` to see AC numbers |
+| Changes not saving | Ensure you're using CLI, not editing files |
+| Metadata out of sync | Re-edit via CLI to fix: `backlog task edit 42 -s <current-status>` |
+
+---
+
+## Remember: The Golden Rule
+
+**🎯 If you want to change ANYTHING in a task, use the `backlog task edit` command.**
+**📖 Only READ task files directly, never WRITE to them.**
+
+Full help available: `backlog --help`
+
+# === BACKLOG.MD GUIDELINES END ===
diff --git a/CLAUDE.md b/CLAUDE.md
index 4458d4d46..3baac76c1 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -246,4 +246,7 @@ For more detailed guidelines and patterns, refer to the `.cursor/rules/` directo
### Project Information
- [Project Overview](.cursor/rules/project-overview.mdc) - High-level project structure
- [Technology Stack](.cursor/rules/technology-stack.mdc) - Detailed tech stack information
-- [Cursor Rules Guide](.cursor/rules/cursor_rules.mdc) - How to maintain cursor rules
\ No newline at end of file
+- [Cursor Rules Guide](.cursor/rules/cursor_rules.mdc) - How to maintain cursor rules
+
+## Backlog.md Information
+- [Backlog.md Guidelines](.cursor/rules/backlog-guildlines.md) - Backlog.md guidelines and commands
diff --git a/backlog/config.yml b/backlog/config.yml
new file mode 100644
index 000000000..9b5c15a0a
--- /dev/null
+++ b/backlog/config.yml
@@ -0,0 +1,16 @@
+project_name: "Coolify"
+default_status: "To Do"
+statuses: ["To Do", "In Progress", "Done"]
+labels: []
+milestones: []
+date_format: yyyy-mm-dd
+max_column_width: 20
+default_editor: "vim"
+auto_open_browser: true
+default_port: 6420
+remote_operations: true
+auto_commit: true
+zero_padded_ids: 5
+bypass_git_hooks: true
+check_active_branches: true
+active_branch_days: 30