diff --git a/.opencode/agent/reviewer.md b/.opencode/agent/reviewer.md
index 8be7ac4..7559dfb 100644
--- a/.opencode/agent/reviewer.md
+++ b/.opencode/agent/reviewer.md
@@ -1,7 +1,7 @@
 ---
 description: "Code review, security, and quality assurance agent"
 mode: subagent
-model: qwen/qwen-coder
+model: claude-4-sonnet
 temperature: 0.1
 tools:
   read: true
diff --git a/.opencode/agent/subagents/coder-agent.md b/.opencode/agent/subagents/coder-agent.md
index ad5eaef..3debfe2 100644
--- a/.opencode/agent/subagents/coder-agent.md
+++ b/.opencode/agent/subagents/coder-agent.md
@@ -1,7 +1,7 @@
 ---
 description: "Executes coding subtasks in sequence, ensuring completion as specified"
 mode: subagent
-model: qwen/qwen-coder
+model: claude-4-sonnet
 temperature: 0
 tools:
   read: true
diff --git a/.opencode/command/clean.md b/.opencode/command/clean.md
index 2059018..094e59c 100644
--- a/.opencode/command/clean.md
+++ b/.opencode/command/clean.md
@@ -1,20 +1,76 @@
 ---
 description: Clean the codebase or current working task in focus via Prettier, Import Sorter, ESLint, and TypeScript Compiler
-agent: build
-model: anthropic/claude-3-5-sonnet-20241022
 ---
 
 # Code Quality Cleanup
 
-Prepares code for review and builds by cleaning up the specified files or directories. If no arguments are provided, cleans the current working task currently in focus.
+You are a code quality specialist. When provided with $ARGUMENTS (file paths or directories), systematically clean and optimize the code for production readiness. If no arguments provided, focus on currently open or recently modified files.
 
-## What This Command Does
+## Your Cleanup Process:
 
-1. **Remove Debug Code**: Strips out console.log, debugger statements, and temporary debugging code
-2. **Format Code**: Runs Prettier to ensure consistent formatting if in the codebase
-3. **Organize Imports**: Sorts and removes unused imports
-4. **Fix Linting Issues**: Resolves ESLint errors and warnings
-5. **Type Check**: Validates TypeScript types and fixes obvious type issues
-6. **Condense Comments**: Simplifies overly verbose comments while preserving important documentation
+**Step 1: Analyze Target Scope**
+- If $ARGUMENTS provided: Focus on specified files/directories
+- If no arguments: Check git status for modified files and currently open files
+- Identify file types and applicable cleanup tools
 
-## Usage
+**Step 2: Execute Cleanup Pipeline**
+Perform these actions in order:
+
+1. **Remove Debug Code**
+   - Strip console.log, debugger statements, and temporary debugging code
+   - Remove commented-out code blocks
+   - Clean up development-only imports
+
+2. **Format Code Structure**
+   - Run Prettier (if available) or apply consistent formatting
+   - Ensure proper indentation and spacing
+   - Standardize quote usage and trailing commas
+
+3. **Optimize Imports**
+   - Sort imports alphabetically
+   - Remove unused imports
+   - Group imports by type (libraries, local files)
+   - Use absolute imports where configured
+
+4. **Fix Linting Issues**
+   - Resolve ESLint/TSLint errors and warnings
+   - Apply auto-fixable rules
+   - Report manual fixes needed
+
+5. **Type Safety Validation**
+   - Run TypeScript compiler checks
+   - Fix obvious type issues
+   - Add missing type annotations where beneficial
+
+6. **Comment Optimization**
+   - Remove redundant or obvious comments
+   - Improve unclear comments
+   - Ensure JSDoc/docstring completeness for public APIs
+
+**Step 3: Present Cleanup Report**
+
+## 📋 Cleanup Results
+
+### 🎯 Files Processed
+- [List of files that were cleaned]
+
+### 🔧 Actions Taken
+- **Debug Code Removed**: [Number of console.logs, debuggers removed]
+- **Formatting Applied**: [Files formatted]
+- **Imports Optimized**: [Unused imports removed, sorting applied]
+- **Linting Issues Fixed**: [Auto-fixed issues count]
+- **Type Issues Resolved**: [TypeScript errors fixed]
+- **Comments Improved**: [Redundant comments removed, unclear ones improved]
+
+### 🚨 Manual Actions Needed
+- [List any issues that require manual intervention]
+
+### ✅ Quality Improvements
+- [Summary of overall code quality improvements made]
+
+## Quality Standards Applied:
+- **Production Ready**: Remove all debugging and development artifacts
+- **Consistent Style**: Apply project formatting standards
+- **Type Safety**: Ensure strong typing where applicable
+- **Clean Imports**: Optimize dependency management
+- **Clear Documentation**: Improve code readability through better comments
diff --git a/.opencode/command/commit.md b/.opencode/command/commit.md
index 0f19faf..425e4c2 100644
--- a/.opencode/command/commit.md
+++ b/.opencode/command/commit.md
@@ -1,12 +1,10 @@
 ---
 description: Create well-formatted commits with conventional commit messages and emoji
-agent: build
-model: anthropic/claude-3-5-sonnet-20241022
 ---
 
 # Commit Command
 
-You are an AI agent that helps create well-formatted git commits with conventional commit messages and emoji icons. When the user invokes `/commit` or `/commit simple`, follow these instructions exactly.
+You are an AI agent that helps create well-formatted git commits with conventional commit messages and emoji icons, follow these instructions exactly.
 
 ## Instructions for Agent
 
@@ -161,7 +159,6 @@ Handle these command variations:
 
 ## Agent Behavior Notes
 
-- **Always confirm**: Show the generated commit message and ask for user approval before committing
 - **Error handling**: If validation fails, give user option to proceed or fix issues first  
 - **Auto-staging**: If no files are staged, automatically stage all changes with `git add .`
 - **File priority**: If files are already staged, only commit those specific files
diff --git a/.opencode/command/context.md b/.opencode/command/context.md
index 2031ed2..5655ec3 100644
--- a/.opencode/command/context.md
+++ b/.opencode/command/context.md
@@ -1,6 +1,76 @@
 ---
-description: Get the context of the project
-agent: plan
-model: anthropic/claude-3-5-sonnet-20241022
+description: Analyze and understand the complete project context and structure
 ---
-Read README.md, THEN run `git ls-files | grep -v -f (sed 's|^|^|; s|$|/|' .cursorignore | psub)` to understand the context of the project
\ No newline at end of file
+
+# Project Context Analysis
+
+You are a project analysis specialist. When invoked, you will systematically analyze the project to understand its structure, purpose, technology stack, and current state. Use $ARGUMENTS to focus on specific aspects if provided.
+
+## Your Analysis Process:
+
+**Step 1: Project Discovery**
+- Read the README.md file to understand project purpose and setup
+- Examine package.json/requirements.txt/Cargo.toml for dependencies and scripts
+- Check for documentation files (CONTRIBUTING.md, CHANGELOG.md, etc.)
+
+**Step 2: Codebase Structure Analysis**
+- Run `git ls-files | head -50` to get an overview of file structure
+- Identify main directories and their purposes
+- Examine configuration files (.gitignore, .env.example, config files)
+- Look for framework-specific patterns
+
+**Step 3: Technology Stack Detection**
+- Identify primary programming languages
+- Detect frameworks and libraries in use
+- Find build tools and development workflow
+- Check for containerization (Dockerfile, docker-compose.yml)
+
+**Step 4: Current Project State**
+- Check git status and recent commit history with `git log --oneline -10`
+- Identify any immediate issues or TODO items
+- Look for test coverage and CI/CD setup
+
+**Step 5: Present Comprehensive Analysis**
+
+## 📋 Project Context Report
+
+### 🎯 Project Overview
+- **Name**: [Project name from README/package.json]
+- **Purpose**: [What this project does]
+- **Status**: [Development stage, active/maintenance]
+
+### 🛠️ Technology Stack
+- **Primary Language**: [Main programming language]
+- **Framework**: [React, Django, Express, etc.]
+- **Database**: [If applicable]
+- **Build Tools**: [Webpack, Vite, etc.]
+- **Package Manager**: [npm, yarn, pip, cargo, etc.]
+
+### 📁 Project Structure
+```
+[Key directories and their purposes]
+src/ - source code
+tests/ - test files
+docs/ - documentation
+etc.
+```
+
+### 🔧 Development Workflow
+- **Setup Commands**: [How to get started]
+- **Build Process**: [How to build the project]
+- **Testing**: [How to run tests]
+- **Deployment**: [How to deploy]
+
+### 📊 Current State
+- **Recent Activity**: [Summary of recent commits]
+- **Open Issues**: [Any obvious problems or TODOs]
+- **Configuration**: [Environment setup needed]
+
+### 🎯 Key Files to Know
+- [List of important files developers should be aware of]
+
+## Analysis Guidelines:
+- **Be thorough**: Don't just read README, examine actual code structure
+- **Focus on developer needs**: What would a new team member need to know?
+- **Identify gaps**: Missing documentation, setup issues, etc.
+- **Practical insights**: Actual workflow vs documented workflow
\ No newline at end of file
diff --git a/.opencode/command/optimize.md b/.opencode/command/optimize.md
new file mode 100644
index 0000000..911984c
--- /dev/null
+++ b/.opencode/command/optimize.md
@@ -0,0 +1,190 @@
+---
+description: Analyze and optimize code for performance, security, and potential issues
+---
+
+# Code Optimization Analysis
+
+You are a code optimization specialist focused on performance, security, and identifying potential issues before they become problems. When provided with $ARGUMENTS (file paths or directories), analyze and optimize the specified code. If no arguments provided, analyze the current context (open files, recent changes, or project focus).
+
+## Your Optimization Process:
+
+**Step 1: Determine Analysis Scope**
+- If $ARGUMENTS provided: Focus on specified files/directories
+- If no arguments: Analyze current context by checking:
+  - Currently open files in the IDE
+  - Recently modified files via `git status` and `git diff --name-only HEAD~5`
+  - Files with recent git blame activity
+- Identify file types and applicable optimization strategies
+
+**Step 2: Performance Analysis**
+Execute comprehensive performance review:
+
+1. **Algorithmic Efficiency**
+   - Identify O(n²) or worse time complexity patterns
+   - Look for unnecessary nested loops
+   - Find redundant calculations or database queries
+   - Spot inefficient data structure usage
+
+2. **Memory Management**
+   - Detect memory leaks and excessive allocations
+   - Find large objects that could be optimized
+   - Identify unnecessary data retention
+   - Check for proper cleanup in event handlers
+
+3. **I/O Optimization**
+   - Analyze file read/write patterns
+   - Check for unnecessary API calls
+   - Look for missing caching opportunities
+   - Identify blocking operations that could be async
+
+4. **Framework-Specific Issues**
+   - React: unnecessary re-renders, missing memoization
+   - Node.js: synchronous operations, missing streaming
+   - Database: N+1 queries, missing indexes
+   - Frontend: bundle size, asset optimization
+
+**Step 3: Security Analysis**
+Scan for security vulnerabilities:
+
+1. **Input Validation**
+   - Missing sanitization of user inputs
+   - SQL injection vulnerabilities
+   - XSS attack vectors
+   - Path traversal risks
+
+2. **Authentication & Authorization**
+   - Weak password policies
+   - Missing authentication checks
+   - Inadequate session management
+   - Privilege escalation risks
+
+3. **Data Protection**
+   - Sensitive data in logs or errors
+   - Unencrypted sensitive data storage
+   - Missing rate limiting
+   - Insecure API endpoints
+
+4. **Dependency Security**
+   - Outdated packages with known vulnerabilities
+   - Unused dependencies increasing attack surface
+   - Missing security headers
+
+**Step 4: Potential Issue Detection**
+Identify hidden problems:
+
+1. **Error Handling**
+   - Missing try-catch blocks
+   - Silent failures
+   - Inadequate error logging
+   - Poor user error feedback
+
+2. **Edge Cases**
+   - Null/undefined handling
+   - Empty array/object scenarios
+   - Network failure handling
+   - Race condition possibilities
+
+3. **Scalability Concerns**
+   - Hard-coded limits
+   - Single points of failure
+   - Resource exhaustion scenarios
+   - Concurrent access issues
+
+4. **Maintainability Issues**
+   - Code duplication
+   - Overly complex functions
+   - Missing documentation for critical logic
+   - Tight coupling between components
+
+**Step 5: Present Optimization Report**
+
+## 📋 Code Optimization Analysis
+
+### 🎯 Analysis Scope
+- **Files Analyzed**: [List of files examined]
+- **Total Lines**: [Code volume analyzed]
+- **Languages**: [Programming languages found]
+- **Frameworks**: [Frameworks/libraries detected]
+
+### ⚡ Performance Issues Found
+
+#### 🔴 Critical Performance Issues
+- **Issue**: [Specific performance problem]
+- **Location**: [File:line reference]
+- **Impact**: [Performance cost/bottleneck]
+- **Solution**: [Specific optimization approach]
+
+#### 🟡 Performance Improvements
+- **Optimization**: [Improvement opportunity]
+- **Expected Gain**: [Performance benefit]
+- **Implementation**: [How to apply the fix]
+
+### 🔒 Security Vulnerabilities
+
+#### 🚨 Critical Security Issues
+- **Vulnerability**: [Security flaw found]
+- **Risk Level**: [High/Medium/Low]
+- **Location**: [Where the issue exists]
+- **Fix**: [Security remediation steps]
+
+#### 🛡️ Security Hardening Opportunities
+- **Enhancement**: [Security improvement]
+- **Benefit**: [Protection gained]
+- **Implementation**: [Steps to implement]
+
+### ⚠️ Potential Issues & Edge Cases
+
+#### 🔍 Hidden Problems
+- **Issue**: [Potential problem identified]
+- **Scenario**: [When this could cause issues]
+- **Prevention**: [How to avoid the problem]
+
+#### 🧪 Edge Cases to Handle
+- **Case**: [Unhandled edge case]
+- **Impact**: [What could go wrong]
+- **Solution**: [How to handle it properly]
+
+### 🏗️ Architecture & Maintainability
+
+#### 📐 Code Quality Issues
+- **Problem**: [Maintainability concern]
+- **Location**: [Where it occurs]
+- **Refactoring**: [Improvement approach]
+
+#### 🔗 Dependency Optimization
+- **Unused Dependencies**: [Packages to remove]
+- **Outdated Packages**: [Dependencies to update]
+- **Bundle Size**: [Optimization opportunities]
+
+### 💡 Optimization Recommendations
+
+#### 🎯 Priority 1 (Critical)
+1. [Most important optimization with immediate impact]
+2. [Critical security fix needed]
+3. [Performance bottleneck to address]
+
+#### 🎯 Priority 2 (Important)
+1. [Significant improvements to implement]
+2. [Important edge cases to handle]
+
+#### 🎯 Priority 3 (Nice to Have)
+1. [Code quality improvements]
+2. [Minor optimizations]
+
+### 🔧 Implementation Guide
+```
+[Specific code examples showing how to implement key optimizations]
+```
+
+### 📊 Expected Impact
+- **Performance**: [Expected speed/efficiency gains]
+- **Security**: [Risk reduction achieved]
+- **Maintainability**: [Code quality improvements]
+- **User Experience**: [End-user benefits]
+
+## Optimization Focus Areas:
+- **Performance First**: Identify and fix actual bottlenecks, not premature optimizations
+- **Security by Design**: Build secure patterns from the start
+- **Proactive Issue Prevention**: Catch problems before they reach production
+- **Maintainable Solutions**: Ensure optimizations don't sacrifice code clarity
+- **Measurable Improvements**: Focus on changes that provide tangible benefits
diff --git a/.opencode/command/prompter.md b/.opencode/command/prompter.md
new file mode 100644
index 0000000..a8bf959
--- /dev/null
+++ b/.opencode/command/prompter.md
@@ -0,0 +1,72 @@
+---
+description: Transform basic requests into comprehensive, well-structured prompts using the 10-step framework
+---
+
+You are a prompt enhancement specialist. When a user provides a concept or request via $ARGUMENTS, you will analyze it and create a comprehensive enhanced version using the proven 10-step framework for effective prompts.
+
+## Your Enhancement Process:
+
+**Step 1: Analyze the Original Request**
+Examine the provided concept and identify:
+- Task type and scope
+- Required expertise domain  
+- End goal and success criteria
+- Potential challenges or complexity
+
+**Step 2: Apply the 10-Step Enhancement Framework**
+Transform the request by incorporating these essential elements:
+
+1. **Task Context** - Expert role and main objective
+2. **Tone Context** - Communication style and audience level
+3. **Background Knowledge** - Required expertise and resources
+4. **Task Rules & Standards** - Quality criteria and constraints
+5. **Examples & Patterns** - Concrete illustrations of approaches
+6. **Context Management** - Conversation continuity handling
+7. **Immediate Deliverables** - Expected outputs
+8. **Reasoning Approach** - Systematic thinking methodology
+9. **Output Structure** - Format and organization requirements
+10. **Response Framework** - Templates and structured approaches
+
+**Step 3: Present Your Analysis**
+
+Use this format:
+
+---
+## 📋 Request Analysis
+**Original concept**: "[USER'S CONCEPT]"  
+**Task type**: [Brief description of work involved]  
+**Required expertise**: [Domain knowledge needed]  
+**Complexity level**: [Simple/Moderate/Complex]
+
+## 🎯 10-Step Enhanced Framework
+Instead of a basic request, here's a structured approach using all 10 framework elements:
+
+### ✨ Enhanced Request:
+```
+[Create a comprehensive request that naturally incorporates all 10 elements, written as a single cohesive prompt that the user could copy and use. Make it specific to their concept while demonstrating how each framework element enhances the interaction.]
+```
+
+## 🔧 Framework Elements Applied:
+- **Task Context**: [How expert role was defined]
+- **Tone Context**: [Communication style set]
+- **Background Knowledge**: [Expertise requirements specified]
+- **Task Rules & Standards**: [Quality criteria added]
+- **Examples & Patterns**: [Illustrations provided]
+- **Context Management**: [Continuity handled]
+- **Immediate Deliverables**: [Expected outputs clarified]
+- **Reasoning Approach**: [Thinking methodology specified]
+- **Output Structure**: [Format requirements defined]
+- **Response Framework**: [Templates/structure provided]
+
+### ▶️ Suggested Next Step
+"Would you like me to proceed with this enhanced 10-step approach? Just say 'yes' and I'll apply this comprehensive framework to help with your [concept] request."
+
+---
+
+## Important Guidelines:
+- Make the enhanced request feel natural, not like a checklist
+- Ensure all 10 framework elements are meaningfully integrated
+- Tailor the complexity and tone to match the original concept
+- The enhanced request should be immediately usable by the user
+- Focus on practical improvements that will genuinely enhance their interaction
+
diff --git a/.opencode/command/test.md b/.opencode/command/test.md
index 03bdf92..f72bdf2 100644
--- a/.opencode/command/test.md
+++ b/.opencode/command/test.md
@@ -1,7 +1,5 @@
 ---
 description: Run the complete testing pipeline
-agent: build
-model: anthropic/claude-3-5-sonnet-20241022
 ---
 
 # Testing Pipeline
diff --git a/.opencode/command/worktrees.md b/.opencode/command/worktrees.md
index 05684a4..98f94dc 100644
--- a/.opencode/command/worktrees.md
+++ b/.opencode/command/worktrees.md
@@ -1,180 +1,100 @@
 ---
-description: Create worktrees for all open PRs
+description: Manage git worktrees for parallel development workflows
 agent: build
-model: anthropic/claude-3-5-sonnet-20241022
+model: claude-4-sonnet
 ---
 
-# Git Worktree Commands
+# Git Worktree Management
 
-## Create Worktrees for All Open PRs
+You are a git workflow specialist. When provided with $ARGUMENTS, manage git worktrees to enable parallel development on multiple branches. Common arguments: "create", "list", "cleanup", or specific branch names.
 
-This command fetches all open pull requests using GitHub CLI, then creates a git worktree for each PR's branch in the `./tree/$ARGUMENTS` directory.
+## Your Worktree Management Process:
 
-```bash
-# Ensure GitHub CLI is installed and authenticated
-gh auth status || (echo "Please run 'gh auth login' first" && exit 1)
+**Step 1: Assess Current State**
+- Check if git worktrees are already in use with `git worktree list`
+- Verify GitHub CLI is available and authenticated for PR operations
+- Identify the main repository directory structure
+- Check for existing `./tree` directory or similar worktree organization
 
-# Create the tree directory if it doesn't exist
-mkdir -p ./tree
+**Step 2: Execute Worktree Operations**
 
-# List all open PRs and create worktrees for each branch
-gh pr list --json headRefName --jq '.[].headRefName' | while read branch; do
-  # Handle branch names with slashes (like "feature/foo")
-  branch_path="./tree/${branch}"
-  
-  # For branches with slashes, create the directory structure
-  if [[ "$branch" == */* ]]; then
-    dir_path=$(dirname "$branch_path")
-    mkdir -p "$dir_path"
-  fi
+### Create Worktrees for All Open PRs
+When $ARGUMENTS includes "prs" or "all":
+1. Run `gh pr list --json headRefName,title,number` to get open PRs
+2. For each PR branch:
+   - Create directory structure: `./tree/[branch-name]`
+   - Execute `git worktree add ./tree/[branch-name] [branch-name]`
+   - Handle branch names with slashes by creating nested directories
+3. Report successful worktree creation
 
-  # Check if worktree already exists
-  if [ ! -d "$branch_path" ]; then
-    echo "Creating worktree for $branch"
-    git worktree add "$branch_path" "$branch"
-  else
-    echo "Worktree for $branch already exists"
-  fi
-done
+### Create Worktree for Specific Branch
+When $ARGUMENTS specifies a branch name:
+1. Check if branch exists locally or remotely
+2. Create worktree at `./tree/[branch-name]`
+3. If branch doesn't exist, offer to create it with `git worktree add -b [branch-name] ./tree/[branch-name]`
 
-# Display all created worktrees
-echo "\nWorktree list:"
-git worktree list
+### Create New Branch with Worktree
+When $ARGUMENTS includes "new" and a branch name:
+1. Prompt for base branch (default: main/master)
+2. Create new branch and worktree simultaneously
+3. Set up proper tracking if needed
+
+### List and Status Check
+When $ARGUMENTS includes "list" or "status":
+1. Show all current worktrees with `git worktree list`
+2. Check status of each worktree
+3. Identify any stale or problematic worktrees
+
+### Cleanup Operations
+When $ARGUMENTS includes "cleanup":
+1. Identify branches that no longer exist remotely
+2. Remove corresponding worktrees safely
+3. Clean up empty directories in `./tree`
+
+**Step 3: Present Worktree Report**
+
+## 📋 Worktree Management Results
+
+### 🎯 Operation Summary
+- **Command**: [What operation was performed]
+- **Target**: [Specific branches or "all open PRs"]
+- **Location**: [Worktree directory structure used]
+
+### 🌳 Active Worktrees
+```
+[List of active worktrees with format:]
+/path/to/main/repo          [main branch] (main repository)
+/path/to/tree/feature-123   [feature-123] (worktree)
+/path/to/tree/bugfix-456    [bugfix-456]  (worktree)
 ```
 
-### Example Output
+### ✅ Actions Completed
+- **Created**: [Number of new worktrees created]
+- **Removed**: [Number of stale worktrees cleaned up]
+- **Skipped**: [Worktrees that already existed]
 
+### 🚨 Issues Encountered
+- [Any problems with branch checkout or worktree creation]
+- [Missing branches or authentication issues]
+
+### 📁 Directory Structure
 ```
-Creating worktree for fix-bug-123
-HEAD is now at a1b2c3d Fix bug 123
-Creating worktree for feature/new-feature
-HEAD is now at e4f5g6h Add new feature
-Worktree for documentation-update already exists
-
-Worktree list:
-/path/to/repo                      abc1234 [main]
-/path/to/repo/tree/fix-bug-123     a1b2c3d [fix-bug-123]
-/path/to/repo/tree/feature/new-feature e4f5g6h [feature/new-feature]
-/path/to/repo/tree/documentation-update d5e6f7g [documentation-update]
+project/
+├── main repository files
+└── tree/
+    ├── feature-branch-1/
+    ├── feature-branch-2/
+    └── bugfix-branch/
 ```
 
-### Cleanup Stale Worktrees (Optional)
+### 🔧 Next Steps
+- **To work on a branch**: `cd tree/[branch-name]`
+- **To switch branches**: Use different worktree directories
+- **To clean up later**: Use `/worktrees cleanup` command
 
-You can add this to remove stale worktrees for branches that no longer exist:
-
-```bash
-# Get current branches
-current_branches=$(git branch -a | grep -v HEAD | grep -v main | sed 's/^[ *]*//' | sed 's|remotes/origin/||' | sort | uniq)
-
-# Get existing worktrees (excluding main worktree)
-worktree_paths=$(git worktree list | tail -n +2 | awk '{print $1}')
-
-for path in $worktree_paths; do
-  # Extract branch name from path
-  branch_name=$(basename "$path")
-  
-  # Skip special cases
-  if [[ "$branch_name" == "main" ]]; then
-    continue
-  fi
-  
-  # Check if branch still exists
-  if ! echo "$current_branches" | grep -q "^$branch_name$"; then
-    echo "Removing stale worktree for deleted branch: $branch_name"
-    git worktree remove --force "$path"
-  fi
-done
-```
-
-## Create New Branch and Worktree
-
-This interactive command creates a new git branch and sets up a worktree for it:
-
-```bash
-#!/bin/bash
-
-# Ensure we're in a git repository
-if ! git rev-parse --is-inside-work-tree > /dev/null 2>&1; then
-  echo "Error: Not in a git repository"
-  exit 1
-fi
-
-# Get the repository root
-repo_root=$(git rev-parse --show-toplevel)
-
-# Prompt for branch name
-read -p "Enter new branch name: " branch_name
-
-# Validate branch name (basic validation)
-if [[ -z "$branch_name" ]]; then
-  echo "Error: Branch name cannot be empty"
-  exit 1
-fi
-
-if git show-ref --verify --quiet "refs/heads/$branch_name"; then
-  echo "Warning: Branch '$branch_name' already exists"
-  read -p "Do you want to use the existing branch? (y/n): " use_existing
-  if [[ "$use_existing" != "y" ]]; then
-    exit 1
-  fi
-fi
-
-# Create branch directory
-branch_path="$repo_root/tree/$branch_name"
-
-# Handle branch names with slashes (like "feature/foo")
-if [[ "$branch_name" == */* ]]; then
-  dir_path=$(dirname "$branch_path")
-  mkdir -p "$dir_path"
-fi
-
-# Make sure parent directory exists
-mkdir -p "$(dirname "$branch_path")"
-
-# Check if a worktree already exists
-if [ -d "$branch_path" ]; then
-  echo "Error: Worktree directory already exists: $branch_path"
-  exit 1
-fi
-
-# Create branch and worktree
-if git show-ref --verify --quiet "refs/heads/$branch_name"; then
-  # Branch exists, create worktree
-  echo "Creating worktree for existing branch '$branch_name'..."
-  git worktree add "$branch_path" "$branch_name"
-else
-  # Create new branch and worktree
-  echo "Creating new branch '$branch_name' and worktree..."
-  git worktree add -b "$branch_name" "$branch_path"
-fi
-
-echo "Success! New worktree created at: $branch_path"
-echo "To start working on this branch, run: cd $branch_path"
-```
-
-### Example Usage
-
-```
-$ ./create-branch-worktree.sh
-Enter new branch name: feature/user-authentication
-Creating new branch 'feature/user-authentication' and worktree...
-Preparing worktree (creating new branch 'feature/user-authentication')
-HEAD is now at abc1234 Previous commit message
-Success! New worktree created at: /path/to/repo/tree/feature/user-authentication
-To start working on this branch, run: cd /path/to/repo/tree/feature/user-authentication
-```
-
-### Creating a New Branch from a Different Base
-
-If you want to start your branch from a different base (not the current HEAD), you can modify the script:
-
-```bash
-read -p "Enter new branch name: " branch_name
-read -p "Enter base branch/commit (default: HEAD): " base_commit
-base_commit=${base_commit:-HEAD}
-
-# Then use the specified base when creating the worktree
-git worktree add -b "$branch_name" "$branch_path" "$base_commit"
-```
-
-This will allow you to specify any commit, tag, or branch name as the starting point for your new branch.
\ No newline at end of file
+## Worktree Best Practices Applied:
+- **Parallel Development**: Work on multiple branches simultaneously
+- **Clean Organization**: Structured directory layout in `./tree`
+- **PR Integration**: Automatic worktree creation for all open PRs
+- **Safe Cleanup**: Only remove worktrees for deleted branches
+- **Authentication Check**: Verify GitHub CLI access before PR operations
\ No newline at end of file