Scopes is a next-generation local-first task and project management tool designed for symbiotic collaboration between developers and AI assistants.

Create a unified, recursive task management system where AI and human developers work together seamlessly, eliminating context loss and maximizing productivity through intelligent workspace management.

• Recursive Structure: Projects, epics, and tasks are all "Scopes"
• Unlimited Hierarchy: No depth restrictions (default: unlimited; configurable via HierarchyPolicy)
• Consistent Operations: Same features available at every level
• Human-Friendly Aliases: Memorable identifiers like quiet-river-x7k instead of ULIDs

• Comment-Based AI Integration: Asynchronous AI collaboration through comments
• Workspace + Focus Management: Automatic context switching based on directory
• MCP (Model Context Protocol): Standard AI integration protocol
• Natural Language Context: "this", "that" resolve to focused scope

• Auto-Generated Names: Memorable aliases using pattern like bold-tiger-x7k
• Custom Aliases: Add your own names like auth-system or sprint-42
• Multiple Aliases: One scope can have many aliases for different contexts
• Case-Insensitive: Type AUTH or auth - both work
• Prefix Matching: Type qui to match quiet-river-x7k

• Offline-First: All features work without internet
• Selective Sync: Choose what to share with external tools
• Cross-Platform: Native support for Windows, macOS, Linux
• Privacy by Design: Local-only data stays local

# Create a scope with auto-generated alias
$ scopes create "Implement authentication"
Created scope with canonical alias: quiet-river-x7k

# Create with custom alias
$ scopes create "User management" --alias users

# Add additional aliases
$ scopes alias add users user-system
$ scopes alias add users sprint-42

# Find scopes by alias
$ scopes show users
$ scopes show spr<TAB>  # Tab completion: sprint-42

# Create child scopes
$ scopes create "Login form" --parent users --alias login
$ scopes create "User profile" --parent users --alias profile

# View hierarchy
$ scopes tree users
users          User management
├── login      Login form
└── profile    User profile

• Tutorial: Getting Started with Aliases - Hands-on introduction
• CLI Quick Reference - All commands at a glance
• Using Aliases Guide - Best practices and workflows

• Domain Overview - Core concepts and domain model
• Clean Architecture - Architectural layers and principles
• Domain-Driven Design - DDD implementation approach

• Use Case Style Guide - Implementation patterns

• CLI Quick Reference - All commands including aliases

The project follows Clean Architecture with clear separation of concerns:

• :platform:commons: Pure abstractions and primitive types (interfaces, type aliases)
• :platform:domain-commons: Domain-specific helpers shared across bounded contexts
• :platform:application-commons: Application layer utilities and common use case patterns
• :platform:infrastructure: System resource implementations (DB, time providers, ID generators)

Each context follows DDD with three layers:

• domain: Business logic, entities, value objects, domain services
• application: Use cases, DTOs, application services
• infrastructure: Repositories, external service adapters

• contracts-*: Inter-context communication interfaces (aka Application Contracts / Primary Ports)
• interfaces-*: User-facing adapters (CLI, API)

For detailed dependency rules, see Dependency Rules.

This is a greenfield project inheriting the best ideas from Project Manager while introducing the revolutionary unified Scope concept for true AI-developer symbiosis.

1. Follow Clean Architecture and DDD principles
2. Write property-based tests for value objects and events
3. Run ./gradlew konsistTest to verify architectural compliance
4. Document architectural decisions in ADRs
5. Respect module dependency rules - see dependency-rules.md
6. Run static checks: ./gradlew detekt ktlintFormat

Apache License 2.0 - See LICENSE for details.

• AI-Driven Developers: Using AI as primary development partner
• Tech Leads: Managing design quality before team presentation
• OSS Contributors: Coordinating across multiple projects
• Multi-Device Developers: Seamless work across machines
• International Engineers: Breaking language barriers with AI