Initial documentation

.github/workflows/docs.yaml

@@ -0,0 +1,58 @@
+name: Deploy Documentation
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Setup Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+        
+    - name: Cache dependencies
+      uses: actions/cache@v3
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+          
+    - name: Install MkDocs
+      run: pip install mkdocs-material
+      
+    - name: Build documentation
+      run: mkdocs build --clean
+      
+    - name: Upload Pages artifact
+      uses: actions/upload-pages-artifact@v2
+      with:
+        path: site/
+        
+  deploy:
+    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master'
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: docs
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v2

README.md

@@ -5,6 +5,10 @@ A task and note management plugin with calendar views and daily notes.
 ![Downloads](https://img.shields.io/github/downloads/callumalpass/tasknotes/main.js)
 ![Screenshot of biblib Obsidian plugin](https://github.com/callumalpass/tasknotes/blob/main/media/2025-06-15_23-32-16.png)
 
+## Documentation
+
+**[Complete Documentation](https://callumalpass.github.io/tasknotes/)** - Comprehensive guide covering all features, configuration options, and usage examples.
+
 ## Rationale
 
 TaskNotes uses YAML frontmatter to store task data, providing several benefits. YAML is a standard format compatible with many tools, ensuring long-term data stability in line with Obsidian's file-over-app philosophy. The frontmatter approach makes it trivial to add custom fields like "assigned-to" or "attachments" that integrate seamlessly with other tools like Obsidian Bases. This extensibility has made it easy to add features like time-tracking, which would be difficult to implement cleanly in other task formats. The one-note-per-task approach enables you to add unstructured content in the note body for descriptions and progress notes. Each task becomes a full participant in your knowledge graph, leveraging native Obsidian features like backlinking and graph visualization. This creates a complete history and context for every task in one place.

docs/concepts-rationale.md

@@ -0,0 +1,141 @@
+# Concepts and Rationale
+
+TaskNotes is built around specific design decisions that differentiate it from other task management approaches. Understanding these concepts helps explain why the plugin works the way it does and how to use it most effectively.
+
+## The Note-Per-Task Approach
+
+### Design Rationale
+
+TaskNotes uses individual Markdown notes for each task rather than maintaining a centralized task database or using inline task formats exclusively. This approach stems from several considerations about data portability, feature integration, and workflow flexibility.
+
+**Data Ownership**: Each task exists as a standard Markdown file that you own completely. You can read, edit, backup, and process these files with any text editor or automation tool, regardless of whether TaskNotes or even Obsidian continues to exist.
+
+**Rich Context**: Unlike task management systems that limit you to title and description fields, each task note can contain unlimited additional content. You can include research findings, meeting notes, links to related documents, embedded images, code snippets, or any other relevant information directly in the task file.
+
+**Native Obsidian Integration**: Each task automatically benefits from Obsidian's core features including backlinking, graph visualization, full-text search, tag management, and compatibility with other plugins. You can link tasks to people, projects, or concepts in your vault, creating rich relationship networks.
+
+**Flexible Structure**: While the YAML frontmatter provides structured metadata for filtering and organization, the note body content remains completely free-form. This combination allows for both precise data management and creative expression within the same file.
+
+### Trade-offs and Considerations
+
+**File Proliferation**: Using one file per task results in many small files, which may not suit all organizational preferences. Some users prefer consolidated task lists or project-based task collections.
+
+**Performance Implications**: Large numbers of task files can impact vault performance, particularly on slower devices or with very large vaults. TaskNotes includes performance optimizations, but file-based approaches inherently have different performance characteristics than database approaches.
+
+**Filename Management**: Task files require unique filenames, which necessitates filename generation strategies. While the plugin handles this automatically, it adds complexity compared to systems that don't create files.
+
+## YAML Frontmatter for Task Data
+
+### Technical Benefits
+
+**Standardized Format**: YAML is an established, human-readable data serialization standard with broad tool support across programming languages and platforms. This ensures your task data can be easily parsed, transformed, and integrated with external systems using standard tools.
+
+**Extensibility**: Adding new fields to your task structure requires only including them in the frontmatter. Whether you need project codes, client information, estimated revenue, or any other custom metadata, you can extend TaskNotes functionality without waiting for plugin updates.
+
+**Tool Compatibility**: The YAML format ensures compatibility with Obsidian's Bases plugin for database-style operations like bulk updates, complex filtering, and custom views. It also enables integration with external tools for reporting, automation, or data analysis.
+
+**Version Control Friendly**: Since tasks are stored as plain text files with structured frontmatter, they work seamlessly with version control systems like Git. You can track changes to your task data over time, collaborate with others, and maintain complete history of your work.
+
+**Human Readable**: Unlike binary databases or proprietary formats, YAML frontmatter can be read and understood by humans. You can manually edit task data when needed, understand your data structure at a glance, and debug issues without specialized tools.
+
+### Implementation Advantages
+
+**Performance through Native Cache**: By leveraging Obsidian's native metadata cache, TaskNotes achieves good performance even with thousands of tasks while providing real-time updates across all views. The plugin doesn't need to maintain a separate database or parsing system.
+
+**Backwards Compatibility**: YAML frontmatter has been a stable part of Markdown for many years. Task files created today will remain readable and processable by future tools, providing long-term data stability.
+
+**Integration Ecosystem**: The frontmatter approach works with existing Obsidian plugins and themes that expect metadata in this format. Your task data participates in the broader Obsidian ecosystem rather than being isolated in a proprietary system.
+
+### Flexibility Benefits
+
+**Custom Field Names**: The field mapping system allows you to use any YAML property names you prefer, accommodating existing vault structures and personal preferences without forcing standardization.
+
+**Mixed Content Types**: Task files can contain any valid Markdown content alongside the structured frontmatter, supporting workflows that mix structured task management with free-form note-taking.
+
+**Template Integration**: Templates can include both structured frontmatter defaults and rich body content, enabling sophisticated task creation workflows that adapt to different project types or contexts.
+
+## Workflow Philosophy
+
+### Methodology Agnostic
+
+TaskNotes doesn't enforce a specific task management methodology. Instead, it provides flexible tools that can support various approaches:
+
+**Getting Things Done (GTD)**: Contexts, status workflows, and calendar integration support GTD principles while maintaining the flexibility to adapt the system to personal preferences.
+
+**Timeboxing and Time-blocking**: Calendar integration and time tracking features support time-based planning methodologies without requiring rigid scheduling structures.
+
+**Project-based Organization**: Tags, contexts, folder organization, and linking capabilities support project-centric workflows while maintaining task-level granularity.
+
+**Kanban and Agile**: The Kanban view and customizable status systems support agile development processes while accommodating non-development workflows.
+
+### Integration over Isolation
+
+Rather than creating a separate task management environment, TaskNotes integrates task management capabilities into your existing note-taking workflow:
+
+**Inline Integration**: Task widgets and conversion features allow task management to happen within regular notes rather than requiring context switching to dedicated interfaces.
+
+**Context Preservation**: The `{{parentNote}}` template variable and linking system maintain connections between tasks and the broader context in which they were created.
+
+**Unified Search**: Tasks participate in Obsidian's unified search system rather than requiring separate task-specific search interfaces.
+
+**Cross-linking**: Tasks can link to and be linked from any other content in your vault, creating rich information networks rather than isolated task silos.
+
+## Design Principles
+
+### Files Over Applications
+
+TaskNotes follows Obsidian's core "files over applications" philosophy by ensuring that all task data remains in standard, portable file formats:
+
+**Application Independence**: Your task data doesn't depend on any specific application continuing to exist or maintain compatibility.
+
+**Tool Flexibility**: You can process task data with any tool that understands Markdown and YAML, from simple text editors to sophisticated automation scripts.
+
+**Future-Proofing**: Standard file formats provide the best protection against technology obsolescence and vendor lock-in.
+
+### Structured Yet Flexible
+
+The plugin balances structure and flexibility by providing:
+
+**Required Structure**: Sufficient metadata structure to enable sophisticated filtering, sorting, and organization capabilities.
+
+**Optional Flexibility**: Freedom to add arbitrary additional content, custom fields, and creative organization approaches.
+
+**Graceful Degradation**: Task files remain useful even without the TaskNotes plugin, maintaining basic readability and editability.
+
+### Performance Through Simplicity
+
+Rather than building complex caching and synchronization systems, TaskNotes achieves performance through:
+
+**Native Integration**: Using Obsidian's existing metadata cache and file system events rather than duplicating functionality.
+
+**Minimal Indexing**: Creating only the minimal additional indexes necessary for performance-critical operations.
+
+**Event-Driven Updates**: Processing only changed files rather than rescanning entire datasets.
+
+**Lazy Loading**: Deferring expensive operations until actually needed by user interfaces.
+
+## Compatibility and Integration
+
+### Obsidian Ecosystem Participation
+
+TaskNotes is designed to be a good citizen in the Obsidian ecosystem:
+
+**Theme Compatibility**: All views and interfaces respect Obsidian themes and can be further customized with CSS.
+
+**Plugin Compatibility**: Task data format works with other plugins like Bases, and the plugin follows Obsidian development best practices.
+
+**Core Feature Integration**: Leverages Obsidian's search, linking, tagging, and navigation systems rather than replacing them.
+
+### External Tool Integration
+
+The standardized data format enables integration with external tools:
+
+**Automation Scripts**: Task data can be processed by automation tools like Python scripts, shell scripts, or workflow automation platforms.
+
+**Reporting Tools**: Task data can be exported to spreadsheets, databases, or specialized reporting tools for analysis.
+
+**Backup and Sync**: Standard file formats work with any backup or synchronization system that handles text files.
+
+**Version Control**: Task files work with Git and other version control systems for collaboration and change tracking.
+
+This conceptual foundation explains why TaskNotes works the way it does and how its design decisions support flexible, powerful task management while maintaining data portability and long-term viability.

docs/core-concepts.md

@@ -0,0 +1,188 @@
+# Core Concepts
+
+Understanding TaskNotes requires familiarity with several key concepts that shape how the plugin works and how tasks are structured.
+
+## Tasks as Individual Notes
+
+### File-Based Task Storage
+
+Each task in TaskNotes exists as a separate Markdown file in your Obsidian vault. This fundamental design choice means that tasks are not stored in a database or proprietary format, but as standard text files that you own and control.
+
+**Task File Structure**:
+- YAML frontmatter containing structured task metadata
+- Markdown body content for detailed descriptions, notes, and context
+- Standard `.md` file extension for compatibility
+
+**Benefits of Individual Files**:
+- Each task can contain unlimited additional content beyond basic properties
+- Tasks benefit from all Obsidian features like linking, tagging, and search
+- Data remains accessible with any text editor or automation tool
+- No vendor lock-in or proprietary data formats
+
+### Task Identification
+
+TaskNotes identifies which notes are tasks using a configurable tag (default: `#task`) that appears in each task file's frontmatter. This tag-based identification allows:
+
+- Mixed content types within the same vault
+- Easy conversion between regular notes and tasks
+- Flexible organization without rigid folder structures
+- Compatibility with existing vault organization schemes
+
+## YAML Frontmatter Structure
+
+### Metadata Storage
+
+All task properties are stored in YAML frontmatter at the beginning of each task file. This structured metadata enables sophisticated filtering, sorting, and organization while keeping data in a standard, portable format.
+
+**Example Task Frontmatter**:
+```yaml
+---
+title: "Complete project documentation"
+status: "in-progress"
+priority: "high"
+due: "2025-01-20"
+scheduled: "2025-01-15"
+contexts: ["computer", "work"]
+tags: ["task", "project-alpha"]
+timeEstimate: 120
+dateCreated: "2025-01-10T09:30:00Z"
+dateModified: "2025-01-15T14:20:00Z"
+completedDate: null
+recurrence: "FREQ=WEEKLY;BYDAY=MO"
+timeEntries: []
+complete_instances: []
+pomodoros: 0
+---
+```
+
+### Field Customization
+
+The field mapping system allows you to customize YAML property names to match your existing vault structure or personal preferences. This enables integration with other plugins and tools that expect different property names.
+
+**Default vs Custom Mapping**:
+- Default: `due`, `scheduled`, `priority`
+- Custom: `deadline`, `startDate`, `importance`
+
+## Task Properties
+
+### Core Properties
+
+**Title**: The main task description, used for display and filename generation
+**Status**: Current completion state, fully customizable with colors and behaviors
+**Priority**: Importance level with configurable weights for sorting
+**Due Date**: Deadline for task completion
+**Scheduled Date**: When you plan to work on the task
+
+### Organization Properties
+
+**Contexts**: Location or tool-based groupings (e.g., `@home`, `@computer`)
+**Tags**: Standard Obsidian tags for broader categorization
+**Archive Status**: Special tag-based system for hiding completed tasks
+
+### Advanced Properties
+
+**Time Estimate**: Expected duration in minutes
+**Time Entries**: Recorded work sessions with start/stop timestamps
+**Recurrence**: Repeating task patterns using RRule standard
+**Creation/Modification Dates**: Automatic timestamps for task lifecycle tracking
+
+## Views and Perspectives
+
+### Multiple View Types
+
+TaskNotes provides eight different view types, each designed for specific workflows:
+
+- **Task List**: Comprehensive task management with filtering and organization
+- **Notes**: Date-based browsing of vault notes (not just tasks)
+- **Agenda**: Combined timeline of tasks and notes over time periods
+- **Kanban**: Visual workflow management with status-based columns
+- **Mini Calendar**: Compact date navigation with task indicators
+- **Advanced Calendar**: Full-featured calendar with external integration
+- **Pomodoro**: Timer interface for focused work sessions
+- **Pomodoro Stats**: Productivity analytics and session history
+
+### Data Consistency
+
+All views work with the same underlying task data stored in YAML frontmatter. Changes made in one view immediately appear in all other views without requiring manual refresh.
+
+## Customization System
+
+### Status and Priority Configuration
+
+TaskNotes allows complete customization of status and priority systems:
+
+**Status Configuration**:
+- Define custom workflow states
+- Assign colors and completion behaviors
+- Control progression order for status cycling
+
+**Priority Configuration**:
+- Create priority levels with numeric weights
+- Assign colors for visual distinction
+- Support for custom priority hierarchies
+
+### Field Mapping
+
+The field mapping system enables:
+- Custom YAML property names for all task fields
+- Integration with existing vault structures
+- Compatibility with other plugins and tools
+- Preservation of existing task data when migrating
+
+## Integration Features
+
+### Editor Integration
+
+**Task Link Widgets**: Replace wikilinks to tasks with interactive previews
+**Instant Conversion**: Transform checkbox tasks into full TaskNotes
+**Natural Language Processing**: Create tasks from conversational descriptions
+
+### Calendar Integration
+
+**External Calendars**: Subscribe to ICS feeds from Google Calendar, Outlook, and other services
+**Timeblocking**: Create focused work periods linked to daily notes
+**Multi-View Support**: Display tasks and external events in unified calendar interface
+
+### Time Management
+
+**Time Tracking**: Built-in start/stop time recording for tasks
+**Pomodoro Integration**: Focused work sessions with automatic time tracking
+**Session Analytics**: Productivity metrics and completion tracking
+
+## Data Portability
+
+### Standard Formats
+
+TaskNotes uses only standard, well-established formats:
+- **Markdown**: Universal text format for note content
+- **YAML**: Widely-supported data serialization for metadata
+- **RRule**: Standard recurrence format used by calendar applications
+- **ISO 8601**: International standard for dates and timestamps
+
+### Tool Compatibility
+
+The standard format approach enables:
+- Processing with external automation tools
+- Integration with other Obsidian plugins
+- Migration to different systems without data loss
+- Backup and version control with standard tools
+
+## Performance Considerations
+
+### Efficient Architecture
+
+TaskNotes achieves good performance through:
+- **Native Cache Integration**: Uses Obsidian's metadata cache as primary data source
+- **Minimal Indexing**: Creates only essential indexes for performance-critical operations
+- **Event-Driven Updates**: Processes only changed files rather than full rescans
+- **Lazy Loading**: Defers expensive operations until needed
+
+### Scalability
+
+The plugin handles large numbers of tasks through:
+- **DOM Reconciliation**: Minimizes UI updates by calculating and applying only necessary changes, improving rendering performance for large lists.
+- **Efficient Filtering**: Uses indexed data for fast search and filter operations
+- **Incremental Updates**: Updates only modified tasks and affected views
+- **Memory Management**: Proper cleanup prevents memory leaks during extended use
+
+Understanding these core concepts provides the foundation for effectively using TaskNotes and adapting it to your specific workflow requirements.

docs/creating-editing-tasks.md

@@ -0,0 +1,197 @@
+# Creating and Editing Tasks
+
+TaskNotes provides multiple ways to create and edit tasks, accommodating different workflows and preferences. Tasks are stored as individual Markdown files with YAML frontmatter containing structured metadata.
+
+## Task Creation Methods
+
+### Manual Task Creation
+
+**Task Creation Modal**: Use the "Create new task" command or buttons in various views to open a comprehensive task creation interface. The modal provides access to all available task properties and includes validation for required fields.
+
+**Calendar Creation**: Click on dates or time slots in calendar views to create tasks with pre-populated scheduling information. The selected date automatically becomes the task's due date or scheduled date depending on the calendar view.
+
+**Natural Language Creation**: Use the natural language parser to create tasks by typing descriptions in plain English. The parser extracts structured data from phrases like "Buy groceries tomorrow at 3pm @home #errands high priority".
+
+### Automated Task Creation
+
+**Inline Conversion**: Convert existing checkbox tasks in your notes to full TaskNotes using the instant conversion feature. Convert buttons appear next to checkbox tasks in edit mode.
+
+**Template-Based Creation**: Tasks created through any method can use configured templates for both YAML frontmatter and note body content.
+
+## Task Properties
+
+### Required Fields
+
+**Title**: The main task description. Required field with a maximum length of 200 characters. The title is used for filename generation and display across all views.
+
+### Core Properties
+
+**Status**: Current completion state of the task. Uses a customizable status system with the following defaults:
+- None: No specific status assigned
+- Open: Ready to begin work
+- In Progress: Currently being worked on  
+- Done: Completed task
+
+**Priority**: Importance level of the task. Uses a weight-based priority system with defaults:
+- None: No specific priority (weight 0)
+- Low: Low importance (weight 1)
+- Normal: Standard importance (weight 2)  
+- High: High importance (weight 3)
+
+### Scheduling Properties
+
+**Due Date**: When the task must be completed. Supports multiple formats:
+- Date only: `2025-01-15`
+- Date with time: `2025-01-15T14:30:00`
+- Date with timezone: `2025-01-15T14:30:00Z`
+
+**Scheduled Date**: When you plan to work on the task. Uses the same format options as due dates. Scheduled dates are used primarily for calendar display and daily planning.
+
+### Organization Properties
+
+**Contexts**: Location or tool-based groupings using `@context` format (e.g., `@home`, `@computer`, `@phone`). Contexts help organize tasks by where or how they can be completed.
+
+**Tags**: Standard Obsidian tags for broader categorization using `#tag` format. Tasks automatically include the main task tag configured in settings, plus any additional tags you specify.
+
+### Planning Properties
+
+**Time Estimate**: Expected time to complete the task, specified in minutes. The interface accepts various input formats and converts them to minutes for storage.
+
+**Recurrence**: Recurring task patterns using the RFC 5545 RRule standard. Supports patterns like:
+- Simple: "daily", "weekly", "monthly", "yearly"
+- Interval-based: "every 2 weeks", "every 3 days"
+- Day-specific: "every Monday", "first Friday of month"
+
+### Tracking Properties
+
+**Time Entries**: Recorded work sessions with start and stop times. Time tracking data is automatically managed through the time tracking interface and stored as an array of time entries.
+
+**Archive Status**: Boolean flag managed through a special archive tag. Archived tasks can be hidden from most views while remaining accessible for reference.
+
+## Creating Tasks
+
+### Task Creation Workflow
+
+1. **Open Creation Interface**: Use commands, view buttons, or calendar clicks to open the task creation modal
+2. **Enter Task Information**: Fill in the title (required) and any additional properties
+3. **Apply Defaults**: The system automatically applies configured default values for status, priority, contexts, and tags
+4. **Process Templates**: If enabled, body templates are processed with variable substitution
+5. **Generate Filename**: The system creates a unique filename based on your configured naming pattern
+6. **Create File**: The task is saved as a Markdown file in your designated tasks folder
+
+### Default Value Application
+
+Tasks automatically receive default values from your settings:
+
+**Status and Priority**: Your configured default status and priority levels
+**Contexts and Tags**: Default context and tag strings (comma-separated in settings)
+**Task Tag**: The main task tag is always included automatically
+**Dates**: Optional default due dates and scheduled dates
+**Time Estimate**: Default time estimate if configured
+**Folder**: Tasks are created in your default tasks folder unless overridden
+
+### Template System
+
+TaskNotes supports templates for both YAML frontmatter and note body content:
+
+**Template Variables**: Templates can include variables like:
+- `{{title}}`: Task title
+- `{{priority}}`: Priority level
+- `{{status}}`: Current status
+- `{{contexts}}`: Context list
+- `{{tags}}`: Tag list
+- `{{dueDate}}`: Due date
+- `{{scheduledDate}}`: Scheduled date
+- `{{parentNote}}`: Name of the note where task was created
+- `{{date}}`: Current date
+- `{{time}}`: Current time
+
+**Frontmatter Merging**: Template frontmatter is merged with base task properties, with template values taking precedence for any specified fields.
+
+## Editing Tasks
+
+### Task Edit Modal
+
+The task edit modal provides comprehensive editing capabilities:
+
+**Pre-populated Fields**: All current task values are loaded automatically
+**Change Detection**: Only modified fields are updated when saving
+**Metadata Display**: Shows creation date, modification date, and file path
+**Real-time Updates**: Status and priority indicators update as values change
+
+### Inline Editing Options
+
+Some task properties can be modified directly within views:
+
+**Status Cycling**: Click status indicators to cycle through available statuses
+**Priority Changes**: Click priority indicators to change priority levels
+**Date Editing**: Click date displays to open date picker modals
+**Quick Actions**: Use context menus for common editing operations
+
+### Field Validation
+
+The editing system includes validation for data integrity:
+
+**Required Fields**: Title cannot be empty after trimming whitespace
+**Format Validation**: Dates must be in supported formats
+**Length Limits**: Title is limited to 200 characters
+**Status/Priority Values**: Must match configured values in settings
+
+## Advanced Features
+
+### Field Mapping
+
+TaskNotes allows customization of YAML property names through field mapping:
+
+**Custom Property Names**: Map internal field names to your preferred YAML properties
+**Backward Compatibility**: Supports existing vault structures with different property naming
+**Bidirectional Mapping**: Converts between internal and custom field names automatically
+
+### Natural Language Processing
+
+The natural language parser can extract structured data from conversational input:
+
+**Supported Syntax**:
+- Dates: "tomorrow", "next Friday", "January 15th"
+- Times: "3pm", "14:30", "9:00 AM"
+- Priorities: "high priority", "urgent", "low"
+- Statuses: "done", "in progress", "todo"
+- Contexts: "@home", "@work", "@computer"
+- Tags: "#project", "#urgent", "#work"
+- Recurrence: "daily", "weekly", "every Monday"
+- Time estimates: "30 minutes", "2 hours", "1h30m"
+
+### Recurring Task Management
+
+Recurring tasks use a sophisticated per-date completion system:
+
+**Instance Tracking**: Each recurrence instance can be completed independently
+**Completion Array**: Completed dates are stored in the `complete_instances` array
+**Pattern Preservation**: Completing instances doesn't affect the recurrence pattern
+**Calendar Display**: Each instance appears as a separate event in calendar views
+
+### Archive Functionality
+
+Tasks can be archived to reduce clutter while maintaining accessibility:
+
+**Tag-Based System**: Uses a configurable archive tag to mark tasks as archived
+**Toggle Function**: Easy archive/unarchive through context menus or edit modal
+**View Integration**: Archived tasks can be shown or hidden in different views
+**Search Inclusion**: Archived tasks can be included in search results when needed
+
+## File Management
+
+### Filename Generation
+
+TaskNotes supports multiple filename generation patterns:
+
+**Title-based**: Uses the task title with sanitization for filesystem compatibility
+**Timestamp**: Uses creation timestamp for unique, chronological naming
+**Zettelkasten**: Uses `YYMMDD` format plus base36 seconds since midnight (e.g., `25012715a`)
+**Custom**: User-defined template with variable substitution
+
+### Folder Organization
+
+**Default Folder**: Configure where new tasks are created by default
+**Folder Exclusions**: Specify folders to exclude from task scanning
+**Auto-Creation**: Automatically create folder structure as needed for task organization

docs/features.md

@@ -0,0 +1,67 @@
+# Features
+
+TaskNotes provides a comprehensive set of features for task and note management within Obsidian. These features integrate with your existing vault structure while adding specialized functionality for organized productivity workflows.
+
+## Overview
+
+TaskNotes features can be grouped into several categories:
+
+**Task Management**: Core functionality for creating, editing, and organizing tasks using individual note files with YAML frontmatter.
+
+**Inline Integration**: Features that integrate tasks directly into your regular note-taking workflow, including widgets and conversion tools.
+
+**Time Management**: Built-in time tracking and pomodoro timer functionality for measuring and improving productivity.
+
+**Calendar Integration**: Support for external calendar systems and comprehensive scheduling capabilities.
+
+**Natural Language Processing**: Intelligent parsing of natural language input to create structured tasks quickly.
+
+**Workflow Customization**: Extensive customization options for statuses, priorities, field names, and visual appearance.
+
+## Core Capabilities
+
+### Task Data Storage
+Tasks are stored as individual Markdown files with YAML frontmatter containing structured metadata. This approach ensures your data remains accessible and portable while enabling sophisticated task management features.
+
+### Real-Time Synchronization
+All views and features maintain real-time synchronization through an event-driven architecture. Changes made in one view immediately appear in all other open views without requiring manual refresh.
+
+### Multi-View Support
+Eight specialized view types provide different perspectives on the same underlying task data, allowing you to choose the most appropriate interface for your current workflow needs.
+
+### Integration with Obsidian
+TaskNotes leverages Obsidian's native features including metadata cache, file system events, and plugin architecture to provide optimal performance and compatibility with other plugins.
+
+## Feature Categories
+
+The following sections provide detailed documentation for each major feature category:
+
+- **[Task Management](features/task-management.md)**: Creating, editing, and organizing tasks
+- **[Inline Task Integration](features/inline-tasks.md)**: Editor widgets and conversion features  
+- **[Time Tracking](features/time-tracking.md)**: Built-in time measurement and session management
+- **[Natural Language Processing](features/natural-language.md)**: Smart parsing of task descriptions
+- **[Calendar Integration](features/calendar-integration.md)**: External calendar support and scheduling
+
+## Performance Considerations
+
+TaskNotes is designed to handle large numbers of tasks efficiently:
+
+**Minimal Caching**: Uses Obsidian's native metadata cache as the primary data source, supplemented by minimal indexing for performance-critical operations.
+
+**Incremental Updates**: Only processes changed tasks rather than rescanning entire datasets.
+
+**Lazy Loading**: Heavy operations are deferred until actually needed by the user interface.
+
+**Memory Management**: Proper cleanup and lifecycle management prevent memory leaks during extended use.
+
+## Customization Options
+
+TaskNotes provides extensive customization capabilities:
+
+**Field Mapping**: Customize YAML property names to match your existing vault structure.
+
+**Status and Priority Systems**: Define custom statuses and priorities with colors and behaviors.
+
+**Visual Styling**: All views respect Obsidian themes and support additional CSS customization.
+
+**Workflow Configuration**: Adjust default values, templates, and automation behaviors to match your specific needs.

docs/features/calendar-integration.md

@@ -0,0 +1,170 @@
+# Calendar Integration
+
+TaskNotes provides comprehensive calendar integration capabilities, allowing you to display external calendar events alongside your tasks and create sophisticated scheduling workflows.
+
+## ICS Calendar Subscriptions
+
+### Supported Sources
+
+TaskNotes can subscribe to ICS (iCalendar) feeds from various sources:
+
+**Remote URLs**: Subscribe to calendar feeds from:
+- Google Calendar (public and private feeds)
+- Microsoft Outlook/Exchange calendars
+- Apple iCloud calendars
+- Any service that provides ICS/iCal URLs
+
+**Local Files**: Import ICS files stored within your Obsidian vault:
+- Downloaded calendar exports
+- Locally generated calendar files
+- Files synced from other applications
+
+### Subscription Management
+
+**Add Subscriptions**: Configure new calendar subscriptions through the settings interface
+**Subscription Properties**:
+- Name: Display name for the calendar
+- URL/Path: Remote URL or local file path
+- Color: Custom color for calendar events
+- Enabled/Disabled: Toggle subscription visibility
+
+**Automatic Refresh**: Remote calendars are refreshed automatically at configurable intervals
+**File Watching**: Local ICS files are monitored for changes and updated automatically
+
+### Event Processing
+
+**Event Parsing**: Uses the ical.js library for robust ICS format parsing
+**Recurring Events**: Automatic expansion of recurring events up to one year in advance
+**Time Zone Handling**: Proper handling of time zone information in calendar events
+**Event Properties**: Extracts title, start/end times, location, description, and recurrence patterns
+
+## Calendar Display Integration
+
+### Advanced Calendar View
+
+External calendar events appear in the Advanced Calendar View alongside TaskNotes:
+
+**Visual Distinction**: External events are styled differently from tasks to avoid confusion
+**Read-Only Display**: External events cannot be edited directly through TaskNotes
+**Event Details**: Hover over events to see full details including description and location
+**Color Coding**: Each subscription can have a custom color for easy identification
+
+### Event Type Toggles
+
+The Advanced Calendar includes toggles to show or hide different event types:
+
+**ICS Events**: Toggle visibility of all external calendar events
+**Task Events**: Show/hide different types of task-related events
+**Combined View**: See external events and tasks in a unified timeline
+
+### Calendar Navigation
+
+**Multi-View Support**: External events appear in month, week, and day views
+**Date Navigation**: External events respect calendar navigation and date range selection
+**Search Integration**: External events can be included in calendar search functionality
+
+## Timeblocking System
+
+### Timeblocking System
+
+Timeblocking is an optional feature that allows you to create focused work periods directly in the Advanced Calendar. It needs to be enabled in the plugin settings.
+
+**Direct Creation**: Create timeblocks directly in the Advanced Calendar by clicking and dragging
+**Duration Setting**: Set specific start and end times for focused work periods
+**Task Association**: Link timeblocks to specific TaskNotes for integrated planning
+
+### Timeblock Storage
+
+**Daily Note Integration**: Timeblocks are stored in daily note frontmatter
+**YAML Format**: Structured storage ensures timeblock data is portable and editable
+**Example Format**:
+```yaml
+timeblocks:
+  - start: "09:00"
+    end: "10:30"
+    title: "Deep work session"
+    color: "#4285f4"
+    attachment: "[[Important Project Task]]"
+```
+
+### Timeblock Features
+
+**Color Customization**: Assign custom colors to different types of timeblocks
+**Task Attachment**: Link timeblocks to specific tasks for integrated workflow
+**Drag and Drop**: Move and resize timeblocks directly in the calendar interface
+
+## FullCalendar Integration
+
+### Comprehensive Calendar Interface
+
+The Advanced Calendar View uses FullCalendar.js to provide professional calendar functionality:
+
+**Multiple View Types**:
+- Month view for overview planning
+- Week view for detailed scheduling
+- Day view for focused daily planning
+- Multi-month year view for long-term perspective
+
+**Interactive Features**:
+- Drag and drop for task rescheduling
+- Click to create new tasks or timeblocks
+- Resize events to adjust duration
+- Context menus for quick actions
+
+### Event Management
+
+**Task Events**: TaskNotes appear as calendar events based on their due and scheduled dates
+**Time Entry Events**: Completed time tracking sessions appear as events showing actual work time
+**Recurring Task Instances**: Each instance of recurring tasks appears as a separate calendar event
+
+### Performance Optimization
+
+**Efficient Rendering**: FullCalendar handles large numbers of events efficiently
+**Lazy Loading**: Events are loaded on demand based on visible date ranges
+**Real-Time Updates**: Calendar events update immediately when underlying task data changes
+
+## External Calendar Workflow
+
+### Read-Only Integration
+
+External calendar events are displayed as read-only information:
+
+**Reference Purpose**: See external commitments alongside your task planning
+**Conflict Avoidance**: Identify scheduling conflicts between tasks and external events
+**Context Awareness**: Plan task work around existing calendar commitments
+
+### Data Separation
+
+**Clear Boundaries**: External calendar data remains separate from TaskNotes data
+**No Modification**: External events cannot be accidentally modified through TaskNotes
+**Source Integrity**: Original calendar data is preserved and not altered
+
+## Configuration and Settings
+
+### Subscription Settings
+
+**Refresh Intervals**: Configure how often remote calendars are updated
+
+### Display Settings
+
+**Visibility Options**: Control which types of events are shown by default
+
+## Use Cases
+
+### Personal Schedule Integration
+
+**Work Calendar**: Display your work calendar alongside personal tasks
+**Family Calendar**: See family commitments when planning personal projects
+**Multiple Accounts**: Subscribe to calendars from different email accounts
+
+### Team Coordination
+
+**Team Calendars**: Subscribe to shared team calendars to see colleague availability
+**Meeting Planning**: Schedule task work around existing meeting commitments
+**Project Deadlines**: Display project milestones from external project management tools
+
+### Cross-Platform Workflow
+
+**Calendar App Integration**: Continue using your preferred calendar app while seeing events in TaskNotes
+**Mobile Sync**: External calendars sync through their native services while appearing in TaskNotes
+**Unified View**: Single interface showing both external commitments and internal task planning

docs/features/inline-tasks.md

@@ -0,0 +1,141 @@
+# Inline Task Integration
+
+TaskNotes provides several features that integrate task management directly into your regular note-taking workflow. These features allow you to work with tasks without leaving your notes or switching to dedicated task views.
+
+## Task Link Overlay
+
+### Interactive Task Previews
+
+When you create wikilinks to task notes (`[[task-name]]`), TaskNotes displays interactive widgets instead of plain links. These widgets show essential task information and allow basic task management operations directly within your notes.
+
+### Widget Components
+
+Task link widgets display:
+
+**Status Indicator**: Colored dot showing current task status that can be clicked to cycle through available statuses.
+
+**Task Title**: The task name, truncated at 80 characters with full title available on hover.
+
+**Priority Indicator**: Colored dot representing priority level that can be clicked to change priority.
+
+**Due Date**: Calendar icon with date that opens a date picker when clicked.
+
+**Scheduled Date**: Clock icon with date that opens a date picker when clicked.
+
+**Context Menu**: Vertical ellipsis icon or right-click access to full task editing options.
+
+### Widget Interactions
+
+**Status Changes**: Click the status indicator to cycle through your configured statuses.
+
+**Priority Changes**: Click the priority indicator to change between priority levels.
+
+**Date Editing**: Click date displays to open date picker context menu for quick scheduling changes.
+
+**Full Editing**: Click the context menu icon or right-click for access to the complete task edit modal.
+
+**Navigation**: Click the task title to open the full task note.
+
+**Drag Support**: Drag task widgets to calendar views to reschedule tasks.
+
+## Instant Task Conversion
+
+### Checkbox Task Conversion
+
+The instant conversion feature transforms standard Obsidian checkbox tasks into full TaskNotes with a single click.
+
+### Conversion Process
+
+**Detection**: The system identifies checkbox tasks (`- [ ]` or `- [x]`) in your notes.
+
+**Convert Buttons**: Small file-plus icons appear next to eligible checkbox tasks in edit mode.
+
+**One-Click Conversion**: Clicking the convert button:
+1. Creates a new TaskNote file with the checkbox text as the title
+2. Applies configured default settings (status, priority, contexts, tags)
+3. Processes any additional selected lines as task details
+4. Replaces the checkbox with a wikilink to the new task
+
+### Multi-Line Support
+
+The conversion system supports multi-line task creation:
+
+**Title Line**: The checkbox line becomes the task title
+**Detail Lines**: Additional selected lines below the checkbox become the task body content
+**Smart Selection**: The system preserves your text selection during conversion
+
+### Integration with Defaults
+
+Converted tasks automatically receive:
+
+**Default Values**: Status, priority, contexts, and tags from your configured defaults
+**Template Processing**: Body template application if configured
+**Folder Placement**: Creation in your default tasks folder
+
+## Task Link Overlay System
+
+### Live Preview Integration
+
+TaskNotes integrates with Obsidian's live preview mode (CodeMirror 6) to display task widgets in real-time as you type and edit notes.
+
+### Dynamic Updates
+
+**Real-Time Refresh**: Task widgets update immediately when underlying task data changes
+**State Persistence**: Widget state is maintained during note editing and scrolling
+**Performance Optimization**: Only visible widgets are rendered to maintain editor performance
+
+## Convert Button System
+
+### Editor Integration
+
+Convert buttons appear automatically in edit mode next to checkbox tasks that can be converted to TaskNotes.
+
+### Visual Design
+
+**Minimal Interface**: Small, unobtrusive file-plus icons positioned at line ends
+**Responsive Display**: Buttons appear and disappear based on cursor position and edit mode
+**Click Handling**: Special event handling preserves text selection during conversion
+
+## Validation and Error Handling
+
+### Conversion Safety
+
+The instant conversion system includes multiple validation checks:
+
+**Editor State Validation**: Ensures the editor is in a valid state for conversion
+**Selection Validation**: Verifies that selected text is appropriate for task creation
+**File System Checks**: Confirms ability to create new files in the target location
+**Race Condition Protection**: Prevents multiple simultaneous conversions
+
+### Error Recovery
+
+**Graceful Degradation**: Conversion failures don't affect the original note content
+**User Feedback**: Clear error messages when conversion cannot proceed
+**State Restoration**: Editor state is preserved if conversion fails
+
+## Hover Preview Integration
+
+### Native Obsidian Integration
+
+Task link widgets integrate with Obsidian's hover preview system, allowing you to preview task content by hovering over task links.
+
+### Preview Content
+
+Hover previews show:
+- Full task note content
+- Complete YAML frontmatter
+- Any additional notes or context in the task body
+
+## Configuration Options
+
+### Task Link Overlay Settings
+
+**Enable/Disable**: Toggle task link overlays on or off in the plugin settings.
+
+### Instant Convert Settings
+
+**Default Application**: Choose whether converted tasks inherit default settings.
+
+### Visual Customization
+
+Task widgets respect Obsidian themes and can be further customized with CSS to match your vault's visual style.

docs/features/natural-language.md

@@ -0,0 +1,181 @@
+# Natural Language Processing
+
+TaskNotes includes intelligent natural language processing that can parse task descriptions written in plain English and extract structured task data. This feature enables quick task creation using familiar, conversational language.
+
+## Core NLP Engine
+
+### Parser Implementation
+
+The natural language parser uses the Chrono-node library for date and time parsing, combined with custom pattern-based extraction for TaskNotes-specific elements.
+
+### Supported Input Types
+
+**Single Line**: Complete task description on one line
+**Multi-Line**: Title line with additional detail lines below
+**Mixed Format**: Combination of structured elements and free-form text
+
+## Syntax Support
+
+### Tags and Contexts
+
+**Tags**: Use `#tag-name` syntax to assign Obsidian tags to tasks
+- Example: `#project-alpha #urgent`
+- Supports multi-word tags with hyphens or underscores
+
+**Contexts**: Use `@context-name` syntax to assign contexts
+- Example: `@home @computer @phone`
+- Contexts represent locations, tools, or required resources
+
+### Priority Levels
+
+The parser recognizes priority keywords (configurable in settings):
+
+**Default Priority Words**:
+- "urgent" - highest priority
+- "high" - high priority  
+- "normal" - normal priority
+- "low" - lowest priority
+
+**Custom Priorities**: Priority recognition adapts to your configured priority system
+
+### Status Assignment
+
+Status keywords are recognized based on your configured status system:
+
+**Common Status Words**:
+- "open" - ready to start
+- "in-progress" - currently working
+- "done" - completed
+- "cancelled" - no longer needed
+- "waiting" - blocked or waiting
+
+### Date and Time Parsing
+
+**Due Dates**: Use phrases like:
+- "due tomorrow"
+- "deadline Friday"
+- "by next week"
+- "due January 15th"
+
+**Scheduled Dates**: Use phrases like:
+- "scheduled for Monday"
+- "start on Tuesday"
+- "begin next month"
+- "work on this Friday"
+
+**Time Specifications**: Include specific times:
+- "tomorrow at 3pm"
+- "Friday at 9:30 AM"
+- "Monday morning at 8"
+
+### Time Estimates
+
+**Format Support**: Multiple time estimate formats are recognized:
+- "2h" or "2 hours"
+- "30min" or "30 minutes"
+- "1h30m" or "1 hour 30 minutes"
+- "45 minutes"
+
+### Recurrence Patterns
+
+**Simple Patterns**:
+- "daily" - every day
+- "weekly" - every week
+- "monthly" - every month
+- "yearly" - every year
+
+**Day-Specific**:
+- "every Monday"
+- "every Friday"
+- "every other Tuesday"
+
+**Complex Patterns**:
+- "every 2 weeks"
+- "every 3 days"
+- "monthly on the 15th"
+
+## Parser Examples
+
+### Basic Task Creation
+
+**Input**: `Buy groceries tomorrow at 3pm @home #errands high priority`
+
+**Parsed Result**:
+- Title: "Buy groceries"
+- Due Date: Tomorrow at 3:00 PM
+- Context: @home
+- Tag: #errands
+- Priority: High
+
+### Complex Task with Details
+
+**Input**: 
+```
+Prepare quarterly report due Friday #work high priority
+- Gather sales data from last quarter
+- Create charts and visualizations
+- Review with team before submission
+```
+
+**Parsed Result**:
+- Title: "Prepare quarterly report"
+- Due Date: This Friday
+- Tag: #work
+- Priority: High
+- Details: Multi-line description included in task body
+
+### Recurring Task
+
+**Input**: `Team standup every Monday at 9am @office #meetings`
+
+**Parsed Result**:
+- Title: "Team standup"
+- Recurrence: Every Monday at 9:00 AM
+- Context: @office
+- Tag: #meetings
+
+## Advanced Features
+
+### Date Range Handling
+
+**Range Recognition**: Phrases like "from Monday to Friday" are processed
+**Duration Calculation**: Multi-day tasks are handled appropriately
+**Conflict Resolution**: Ambiguous dates are resolved using context
+
+### Trigger Word Detection
+
+**Explicit Assignment**: Words like "due", "deadline", "scheduled" trigger specific date field assignment
+**Implicit Parsing**: Dates without trigger words are assigned based on context
+**Priority Resolution**: Multiple date references are resolved based on semantic importance
+
+### Validation and Cleanup
+
+**Data Validation**: Parsed data is validated before task creation
+**Error Handling**: Invalid or ambiguous input is handled gracefully
+**Fallback Processing**: Unrecognized elements are preserved in the task title or description
+
+## Integration with Task Creation
+
+### Modal Integration
+
+The natural language parser integrates with task creation modals, allowing you to type conversational tasks and have the fields automatically populated.
+
+## Performance and Accuracy
+
+### Processing Speed
+
+**Real-Time Parsing**: Natural language processing occurs in real-time for immediate feedback
+**Efficient Patterns**: Optimized regex patterns for fast text processing
+**Minimal Dependencies**: Lightweight parser implementation
+
+### Accuracy Considerations
+
+**Context Dependency**: Parser accuracy improves with clear, structured input
+**Ambiguity Handling**: System makes reasonable assumptions for ambiguous input
+**Learning Opportunity**: Users quickly learn effective input patterns
+
+### Error Recovery
+
+**Graceful Degradation**: Unparseable elements don't prevent task creation
+**Partial Parsing**: Successfully parsed elements are used even if others fail
+**User Feedback**: Clear indication of what was successfully parsed

docs/features/task-management.md

@@ -0,0 +1,168 @@
+# Task Management
+
+TaskNotes provides comprehensive task management capabilities built around the principle of storing each task as an individual Markdown note with YAML frontmatter for structured metadata.
+
+## Task Creation
+
+### Multiple Creation Methods
+
+**Direct Creation**: Use the "Create new task" command or buttons in various views to open a task creation modal with all available fields.
+
+**Calendar Creation**: Click on dates or time slots in calendar views to create tasks with pre-populated scheduling information.
+
+**Inline Conversion**: Convert existing checkbox tasks in your notes to full TaskNotes using the instant conversion feature.
+
+**Natural Language Creation**: Use the natural language parser to create tasks by typing descriptions like "Buy groceries tomorrow at 3pm @home #errands high priority".
+
+### Task Properties
+
+Each task can include the following properties stored in YAML frontmatter:
+
+**Basic Information**:
+- Title: The main task description
+- Status: Current completion state (configurable)
+- Priority: Importance level (configurable with weights)
+
+**Scheduling**:
+- Due Date: When the task must be completed
+- Scheduled Date: When you plan to work on the task
+
+**Organization**:
+- Contexts: Location or tool-based groupings (e.g., @home, @computer)
+- Tags: Standard Obsidian tags for broader categorization
+
+**Planning**:
+- Time Estimate: Expected time to complete (supports various formats)
+- Recurrence: Recurring task patterns using RRule standard
+
+**Tracking**:
+- Time Entries: Recorded work sessions with start/stop times
+- Creation Date: Automatically set when task is created
+- Modification Date: Updated when task properties change
+
+## Task Editing
+
+### Modal-Based Editing
+
+Task editing uses a comprehensive modal interface that provides access to all task properties. The edit modal can be opened by:
+
+- Clicking task titles in most views
+- Using context menu options
+- Keyboard shortcuts when tasks are selected
+
+### Inline Property Changes
+
+Some task properties can be modified directly within views without opening the full edit modal:
+
+- Status indicators can be clicked to cycle through available statuses
+- Priority indicators can be clicked to change priority levels
+- Due dates and scheduled dates can be edited through date picker widgets
+
+### Bulk Operations
+
+TaskNotes supports limited bulk operations for efficiency:
+
+- Archive/unarchive multiple tasks
+- Status changes for related tasks
+- Date modifications for task groups
+
+## File Management
+
+### File Naming
+
+Tasks are saved as individual Markdown files with configurable naming patterns:
+
+**Title-based**: Uses the task title as the filename (with sanitization)
+**Timestamp**: Uses creation timestamp for unique, chronological naming
+**Zettelkasten**: Uses timestamp prefix with title suffix
+**Custom**: User-defined template with variable substitution
+
+### Folder Organization
+
+**Default Folder**: Configure where new tasks are created by default
+**Folder Exclusions**: Specify folders to exclude from task scanning
+**Auto-Creation**: Automatically create folder structure as needed
+
+### Template System
+
+TaskNotes includes a template system for both YAML frontmatter and note body content:
+
+**Variable Substitution**: Templates can include variables like `{{title}}`, `{{priority}}`, `{{dueDate}}`, `{{parentNote}}`
+**Frontmatter Templates**: Define default YAML structure for new tasks
+**Body Templates**: Include default content in the note body area
+
+## Task Relationships
+
+### Parent Note Context
+
+The `{{parentNote}}` template variable captures context about where a task was created:
+
+- Records the source note when tasks are created via inline conversion
+- Provides backlink context for project-related tasks
+- Enables project-based task organization
+
+### Subtask Support
+
+While TaskNotes doesn't enforce hierarchical task structures, you can create subtask relationships using:
+
+- Obsidian's native linking system
+- Context and tag-based grouping
+- Project-based organization through templates
+
+## Archive System
+
+### Archive Functionality
+
+TaskNotes provides an archive system for completed or cancelled tasks:
+
+**Tag-Based**: Uses a configurable archive tag to mark tasks as archived
+**Toggle Function**: Easy archive/unarchive capability
+**Filter Integration**: Option to show or hide archived tasks in views
+
+### Archive Benefits
+
+- Keeps completed tasks accessible for reference
+- Reduces clutter in active task views
+- Maintains historical record of completed work
+- Supports productivity analysis and reporting
+
+## Recurring Tasks
+
+### Recurrence Patterns
+
+TaskNotes supports sophisticated recurring task patterns using the RRule standard:
+
+**Simple Patterns**: Daily, weekly, monthly, yearly
+**Interval-Based**: Every N days, weeks, or months
+**Day-Specific**: Every Monday, first Friday of month, last day of month
+**Complex Patterns**: Advanced scheduling using full RRule syntax
+
+### Instance Management
+
+Recurring tasks use a per-date completion system:
+
+**Individual Completion**: Mark specific instances complete without affecting the pattern
+**Instance Tracking**: System tracks completed dates in the `complete_instances` array
+**Calendar Display**: Each instance appears as a separate event in calendar views
+
+### Legacy Migration
+
+The plugin includes migration support for older recurrence formats, automatically converting legacy `RecurrenceInfo` objects to the current RRule-based system.
+
+## Performance and Scalability
+
+### Efficient Data Handling
+
+TaskNotes is designed to handle large numbers of tasks efficiently:
+
+**Native Cache Integration**: Uses Obsidian's metadata cache for optimal performance
+**Minimal Indexing**: Only creates indexes for performance-critical operations
+**Event-Driven Updates**: Processes only changed files rather than full rescans
+
+### Memory Management
+
+Proper lifecycle management ensures stable performance:
+
+**Component Cleanup**: All UI components properly dispose of resources
+**Event Listener Management**: Prevents memory leaks from accumulating listeners
+**Cache Optimization**: Balances memory usage with access speed

docs/features/time-tracking.md

@@ -0,0 +1,137 @@
+# Time Tracking
+
+TaskNotes includes built-in time tracking functionality that allows you to measure how much time you spend on individual tasks. Time tracking data is stored directly in each task's YAML frontmatter, ensuring your time data remains with your tasks.
+
+## Time Entry System
+
+### Data Storage
+
+Time tracking information is stored in the `timeEntries` array within each task's YAML frontmatter. Each time entry contains:
+
+**Start Time**: ISO timestamp when work began on the task
+**End Time**: ISO timestamp when work stopped (if session is complete)
+**Duration**: (Calculated from start and end times for completed sessions)
+
+### Multiple Sessions
+
+Tasks can have multiple time tracking sessions:
+
+- Each work session creates a separate time entry
+- Historical sessions are preserved for reference
+- Total time is calculated from all completed sessions
+
+## Time Tracking Interface
+
+### Start/Stop Controls
+
+Time tracking controls appear in task views and cards:
+
+**Start Button**: Begins a new time tracking session for the task
+**Stop Button**: Ends the current active session
+**Active Indicators**: Visual feedback showing which tasks have active time tracking
+
+### Duration Display
+
+**Formatted Time**: Time is displayed in hours:minutes format (e.g., "2:30" for 2 hours 30 minutes)
+**Real-Time Updates**: Active session times update in real-time across all views
+**Total Time**: Displays cumulative time from all sessions
+
+### Session Management
+
+**Single Active Session**: Only one task can have active time tracking at a time
+**Automatic Stop**: Starting time tracking on a new task automatically stops the previous session
+**Session Persistence**: Active sessions persist across Obsidian restarts
+
+## Integration with Views
+
+### Task Card Display
+
+Task cards across all views show time tracking information:
+
+- Current session duration if actively tracking
+- Total accumulated time for completed sessions
+- Visual indicators for active time tracking status
+
+### Real-Time Updates
+
+**Proactive Cache Updates**: Time tracking changes immediately update the task cache
+**Cross-View Synchronization**: Starting or stopping time tracking updates all open views instantly
+**Performance Optimization**: Updates only affect the specific task being tracked
+
+## Pomodoro Integration
+
+### Automatic Time Tracking
+
+When using the pomodoro timer with a selected task:
+
+**Session Start**: Starting a pomodoro automatically begins time tracking for the associated task
+**Session Stop**: Completing or stopping a pomodoro automatically stops time tracking
+**Break Handling**: Time tracking pauses during pomodoro break periods
+
+### Task-Less Pomodoro
+
+Pomodoro sessions can run without an associated task:
+
+- Time tracking only occurs when a task is selected
+- Session statistics are maintained regardless of task association
+- Users can add task association during active sessions
+
+## Time Entry Management
+
+### Session History
+
+**Complete History**: All time entries are preserved in the task's frontmatter
+**Session Details**: Each entry includes precise start and stop times
+**Data Integrity**: Time data remains with the task file for portability
+
+### Manual Editing
+
+Time entries can be manually edited by modifying the task's YAML frontmatter:
+
+```yaml
+timeEntries:
+  - startTime: "2024-01-15T10:30:00.000Z"
+    endTime: "2024-01-15T12:00:00.000Z"
+  - startTime: "2024-01-16T14:00:00.000Z"
+    endTime: "2024-01-16T15:30:00.000Z"
+```
+
+### Data Validation
+
+**Format Validation**: Time entries use ISO timestamp format for consistency
+**Error Handling**: Invalid time data is handled gracefully without breaking functionality
+
+## Performance Considerations
+
+### Efficient Updates
+
+**Minimal Processing**: Only the active tracking task requires real-time updates
+**Cache Integration**: Time tracking integrates with TaskNotes' minimal caching system
+**Event-Driven Updates**: UI updates occur only when time tracking state changes
+
+### Memory Management
+
+**Active Session Tracking**: System tracks only the currently active session in memory
+**Cleanup Procedures**: Proper cleanup when switching between tasks or stopping tracking
+**Persistence**: Active sessions are saved to ensure no data loss
+
+## Use Cases and Workflows
+
+### Time Estimation Improvement
+
+**Comparison Data**: Compare actual time spent with initial time estimates
+**Planning Accuracy**: Improve future time estimates based on historical data
+**Pattern Recognition**: Identify tasks that consistently take longer than expected
+
+### Productivity Analysis
+
+**Task Duration Patterns**: Understand which types of tasks take most time
+**Work Session Analysis**: Identify optimal work session lengths
+**Time Distribution**: See how time is distributed across different projects or contexts
+
+### Client Work and Billing
+
+**Detailed Records**: Precise start/stop times for accurate billing
+**Task-Based Tracking**: Time tracking tied directly to specific work items
+**Data Export**: Time data can be extracted from YAML frontmatter for external processing
+

docs/index.md

@@ -0,0 +1,69 @@
+# TaskNotes Documentation
+
+TaskNotes is a task and note management plugin for Obsidian built on the principle of "one note per task." It stores task information directly in your notes using YAML frontmatter, treating each task as a complete Markdown note that can contain detailed descriptions, links, and any other content you need.
+
+## Approach and Design
+
+TaskNotes takes a different approach to task management compared to other plugins. Instead of maintaining separate databases or proprietary formats, it stores all task information directly in your notes using YAML frontmatter. This means your task data remains in plain text files that you can read and edit with any text editor.
+
+The plugin follows Obsidian's "files over applications" philosophy by treating each task as a complete Markdown note. Every task can contain structured metadata in the frontmatter for filtering and organization, while the note content remains completely free-form for detailed descriptions, research, or any other relevant information.
+
+## Core Design Principles
+
+The plugin is built around several key principles:
+
+**Native Integration**: TaskNotes uses Obsidian's native metadata cache as its primary data source. This ensures compatibility with other plugins and takes advantage of Obsidian's existing performance optimizations.
+
+**Extensible Data Model**: Task data is stored in YAML frontmatter, which means you can add custom fields as needed. The plugin's field mapping system allows you to customize property names to match your existing vault structure.
+
+**Multiple Views**: Different workflows require different ways of viewing the same data. TaskNotes provides eight different view types - task lists, calendar views, Kanban boards, agenda views, and others - while maintaining a single source of truth for your task data.
+
+**Workflow Agnostic**: The plugin doesn't enforce a specific task management methodology. It provides flexible tools that can support various approaches like Getting Things Done (GTD), timeboxing, project-based organization, or hybrid approaches.
+
+## Features
+
+TaskNotes includes the following capabilities:
+
+**Task Properties**: Each task can include title, status, priority, due dates, scheduled dates, contexts, tags, time estimates, and recurrence patterns. You can also add custom fields as needed.
+
+**Time Tracking**: Built-in time tracking allows you to record how long tasks actually take. This data is stored directly in the task's frontmatter as time entries with start and stop times.
+
+**View Types**: Eight different views provide different perspectives on your tasks: Task List, Notes, Agenda, Kanban, Mini Calendar, Advanced Calendar, Pomodoro, and Pomodoro Stats views.
+
+**Editor Integration**: Inline task widgets display task information directly within your notes. An instant conversion feature transforms simple checkbox tasks into full TaskNotes. A natural language parser can interpret phrases like "Buy groceries tomorrow at 3pm @home #errands high priority" to create structured tasks.
+
+**Calendar Integration**: The plugin can subscribe to external ICS calendars from Google Calendar, Outlook, or other calendar systems, displaying external events alongside your tasks. Time-blocking features help you schedule focused work sessions.
+
+**External Tool Compatibility**: The YAML frontmatter format works with other Obsidian plugins for database-style operations and can be processed by external tools for reporting or automation.
+
+## The One-Note-Per-Task Approach
+
+Using individual notes for each task provides several advantages:
+
+**Rich Context**: Each task note can contain unlimited additional content beyond the basic task properties. You can add research findings, meeting notes, links to related documents, embedded images, or any other relevant information directly in the task note.
+
+**Obsidian Integration**: Each task benefits from Obsidian's features like backlinking, graph visualization, full-text search, and compatibility with other plugins. You can link tasks to people, projects, or concepts in your vault.
+
+**Structured and Flexible**: The frontmatter provides structured metadata for filtering and organization, while the note content remains free-form. This allows for both precise data management and detailed context within the same file.
+
+**Portable Data**: Your task data is stored in standard Markdown files that can be read, edited, and processed by any text editor or automation tool. This eliminates vendor lock-in concerns.
+
+## YAML Frontmatter Benefits
+
+Using YAML frontmatter as the primary data storage provides several advantages:
+
+**Standardized Format**: YAML is an established, human-readable data format with broad tool support. Task data can be easily parsed, transformed, and integrated with external systems using standard programming languages and tools.
+
+**Extensibility**: Adding new fields to your task structure requires only including them in the frontmatter. You can add project codes, client information, or any other custom metadata without waiting for plugin updates.
+
+**Tool Compatibility**: The YAML format works with Obsidian's Bases plugin for database-style operations like bulk updates and complex filtering. It also enables integration with external tools for reporting and automation.
+
+**Version Control**: Since tasks are plain text files, they work with version control systems like Git. You can track changes to your task data over time and collaborate with others.
+
+**Performance**: By using Obsidian's native metadata cache, the plugin maintains good performance even with large numbers of tasks while providing real-time updates across all views.
+
+## Getting Started
+
+You can start with basic task creation and gradually explore more advanced features like calendar integration, time tracking, and custom workflows. The plugin includes default settings that work for most users, but most aspects can be customized to match your specific requirements.
+
+This documentation covers every aspect of TaskNotes, from basic setup and task creation to advanced features like natural language processing and external calendar integration.

docs/settings.md

@@ -0,0 +1,73 @@
+# Settings
+
+TaskNotes provides extensive configuration options through a tabbed settings interface. The settings system allows you to customize every aspect of the plugin's behavior, from basic task defaults to advanced field mapping and visual customization.
+
+## Settings Organization
+
+The settings interface is organized into eight main categories:
+
+**Task Defaults**: Core task settings, folder management, and default values for new tasks
+**Inline Tasks**: Editor integration settings for task widgets and conversion features
+**Calendar**: Calendar view configurations, time settings, and display preferences
+**Performance**: Options to optimize plugin performance for large vaults
+**Field Mapping**: Customize YAML property names to match your existing vault structure
+**Statuses**: Define custom status workflows with colors and completion behavior
+**Priorities**: Configure priority levels with weights and visual styling
+**Pomodoro**: Timer settings, automation options, and session management
+
+## Configuration Approach
+
+TaskNotes settings follow these principles:
+
+**Sensible Defaults**: All settings include default values that work well for most users
+**Immediate Application**: Most setting changes take effect immediately without requiring restart
+**Validation**: Input validation prevents invalid configurations and provides clear error messages
+**Flexibility**: Extensive customization options accommodate different workflows and vault structures
+
+## Core Settings Categories
+
+### Task Management Configuration
+
+Settings that control how tasks are created, stored, and organized:
+
+- Default folder location for new tasks
+- Task identification tags and exclusion rules  
+- Filename generation patterns and templates
+- Default values for task properties
+
+### Editor Integration Settings
+
+Controls for how TaskNotes integrates with your note editing workflow:
+
+- Task link widget display options
+- Instant conversion button behavior
+- Natural language processing features
+- Integration with task creation defaults
+
+### Calendar and Scheduling
+
+Configuration for calendar views and time-based features:
+
+- Default calendar view modes and navigation
+- Time slot duration and working hours
+- External calendar subscription management
+- Timeblocking functionality
+
+### Advanced Customization
+
+Settings for users who need specialized configurations:
+
+- Custom YAML property names through field mapping
+- Status and priority system customization
+- Performance optimization for large vaults
+- Pomodoro timer and productivity features
+
+## Detailed Settings Documentation
+
+The following sections provide comprehensive documentation for each settings category:
+
+- **[Task Defaults](settings/task-defaults.md)**: Folder management, default values, and template configuration
+- **[Inline Task Settings](settings/inline-task-settings.md)**: Editor integration and conversion options
+- **[Calendar Settings](settings/calendar-settings.md)**: Calendar views, time configuration, and external calendar integration
+- **[Advanced Settings](settings/advanced-settings.md)**: Field mapping, custom statuses/priorities, and performance options
+

docs/settings/advanced-settings.md

@@ -0,0 +1,281 @@
+# Advanced Settings
+
+Advanced settings provide sophisticated customization options for experienced users who need to adapt TaskNotes to specific workflows, vault structures, or performance requirements.
+
+## Field Mapping
+
+Field mapping allows you to customize the YAML property names used in task files, enabling integration with existing vault structures and compatibility with other plugins.
+
+### Purpose and Benefits
+
+**Vault Integration**: Match existing YAML property names in your vault
+**Plugin Compatibility**: Work with other task management plugins that use different field names
+**Personal Preference**: Use property names that match your mental model
+**Legacy Support**: Maintain compatibility with existing task files
+
+### Configurable Field Mappings
+
+**Core Task Fields**:
+- `title`: Task title property name (default: `title`)
+- `status`: Task status property name (default: `status`) 
+- `priority`: Task priority property name (default: `priority`)
+
+**Date Fields**:
+- `due`: Due date property name (default: `due`)
+- `scheduled`: Scheduled date property name (default: `scheduled`)
+- `dateCreated`: Creation date property name (default: `dateCreated`)
+- `dateModified`: Modification date property name (default: `dateModified`)
+- `completedDate`: Completion date property name (default: `completedDate`)
+
+**Organization Fields**:
+- `contexts`: Contexts array property name (default: `contexts`)
+- `archiveTag`: Archive tag value (default: `archived`)
+
+**Advanced Fields**:
+- `timeEstimate`: Time estimate property name (default: `timeEstimate`)
+- `recurrence`: Recurrence pattern property name (default: `recurrence`)
+- `timeEntries`: Time tracking array property name (default: `timeEntries`)
+- `completeInstances`: Recurring task completion array (default: `complete_instances`)
+- `pomodoros`: Pomodoro session data (default: `pomodoros`)
+
+### Field Mapping Examples
+
+**Tasks Plugin Compatibility**:
+```
+due: due
+scheduled: start
+status: status
+priority: priority
+contexts: tags
+```
+
+**Custom Naming Scheme**:
+```
+title: taskName
+status: currentStatus
+priority: importance
+due: deadline
+scheduled: workDate
+```
+
+**Minimal Mapping**:
+```
+title: name
+status: state
+priority: level
+due: dueDate
+scheduled: startDate
+```
+
+### Validation Rules
+
+**Unique Names**: All field names must be unique across the mapping
+**No Empty Values**: Field names cannot be empty strings
+**YAML Compatibility**: Field names must be valid YAML property names
+**Reserved Words**: Cannot use YAML reserved words or special characters
+
+## Custom Status System
+
+Define custom status workflows with colors, completion behavior, and progression order.
+
+### Status Configuration
+
+Each status includes the following properties:
+
+**ID**: Unique identifier for internal use
+**Value**: What gets written to YAML frontmatter
+**Label**: Display name in user interface
+**Color**: Hex color code for visual styling
+**Is Completed**: Whether this status counts as "done"
+**Order**: Numeric order for status cycling
+
+### Default Status Configuration
+
+```typescript
+[
+  { id: 'none', value: 'none', label: 'None', color: '#cccccc', isCompleted: false, order: 0 },
+  { id: 'open', value: 'open', label: 'Open', color: '#808080', isCompleted: false, order: 1 },
+  { id: 'in-progress', value: 'in-progress', label: 'In progress', color: '#0066cc', isCompleted: false, order: 2 },
+  { id: 'done', value: 'done', label: 'Done', color: '#00aa00', isCompleted: true, order: 3 }
+]
+```
+
+### Custom Status Examples
+
+**Agile Workflow**:
+```
+Backlog → In Progress → Review → Done → Archived
+```
+
+**GTD Workflow**:
+```
+Inbox → Next Action → Waiting → Done
+```
+
+**Project Workflow**:
+```
+Planning → Active → Testing → Complete → Cancelled
+```
+
+### Status Validation Rules
+
+**Minimum Requirements**: At least 2 statuses required
+**Completion Status**: At least one status must be marked as completed
+**Unique Values**: Status values and IDs must be unique
+**Valid Colors**: Colors must be valid hex format (#rrggbb)
+**Non-Empty**: Values and labels cannot be empty
+
+## Custom Priority System
+
+Configure priority levels with weights, colors, and sorting behavior.
+
+### Priority Configuration
+
+Each priority includes:
+
+**ID**: Unique identifier for internal use
+**Value**: What gets written to YAML frontmatter  
+**Label**: Display name in user interface
+**Color**: Hex color code for visual indicators
+**Weight**: Numeric weight for sorting (higher = more important)
+
+### Default Priority Configuration
+
+```typescript
+[
+  { id: 'none', value: 'none', label: 'None', color: '#cccccc', weight: 0 },
+  { id: 'low', value: 'low', label: 'Low', color: '#00aa00', weight: 1 },
+  { id: 'normal', value: 'normal', label: 'Normal', color: '#ffaa00', weight: 2 },
+  { id: 'high', value: 'high', label: 'High', color: '#ff0000', weight: 3 }
+]
+```
+
+### Custom Priority Examples
+
+**Eisenhower Matrix**:
+```
+Not Important/Not Urgent (weight: 0)
+Important/Not Urgent (weight: 1)  
+Not Important/Urgent (weight: 2)
+Important/Urgent (weight: 3)
+```
+
+**Business Priority Levels**:
+```
+Nice to Have (weight: 0)
+Standard (weight: 1)
+High (weight: 2)
+Critical (weight: 3)
+Emergency (weight: 4)
+```
+
+### Priority Validation Rules
+
+**Minimum Requirements**: At least 1 priority required
+**Unique Values**: Priority values, IDs, and weights must be unique
+**Valid Colors**: Colors must be valid hex format (#rrggbb)
+**Non-Negative Weights**: Weights must be non-negative numbers
+**Non-Empty**: Values and labels cannot be empty
+
+## Performance Settings
+
+### Note Indexing
+
+**Setting**: `disableNoteIndexing`
+**Default**: `false`
+
+When enabled, disables indexing of non-task notes to improve performance in large vaults.
+
+**Performance Impact**:
+- **Enabled**: Notes view becomes unavailable, but task operations are faster
+- **Disabled**: Full functionality available, may be slower with many notes
+
+**Use Cases**:
+- Large vaults with thousands of notes
+- Users who don't use the Notes view
+- Performance-critical environments
+
+**Trade-offs**:
+- Disabling breaks Notes view functionality
+- Agenda view will only show tasks, not notes
+- Note-based date navigation becomes unavailable
+
+## Pomodoro Timer Settings
+
+Advanced configuration for the built-in pomodoro timer system.
+
+### Timer Durations
+
+**Work Session Duration**: `pomodoroWorkDuration`
+**Default**: `25` minutes
+
+**Short Break Duration**: `pomodoroShortBreakDuration`
+**Default**: `5` minutes
+
+**Long Break Duration**: `pomodoroLongBreakDuration`  
+**Default**: `15` minutes
+
+**Long Break Interval**: `pomodoroLongBreakInterval`
+**Default**: `4` (sessions before long break)
+
+### Automation Settings
+
+**Auto-Start Breaks**: `pomodoroAutoStartBreaks`
+**Default**: `true`
+
+**Auto-Start Work**: `pomodoroAutoStartWork`
+**Default**: `false`
+
+Controls whether timers automatically start after session completion.
+
+### Notification Settings
+
+**Enable Notifications**: `pomodoroNotifications`
+**Default**: `true`
+
+**Enable Sound**: `pomodoroSoundEnabled`
+**Default**: `true`
+
+**Sound Volume**: `pomodoroSoundVolume`
+**Range**: 0-100
+**Default**: `50`
+
+### Data Storage Location
+
+**Setting**: `pomodoroStorageLocation`
+**Options**: `plugin`, `daily-notes`
+**Default**: `plugin`
+
+**Plugin Storage**: Session data stored in plugin data files
+**Daily Notes Storage**: Session data stored in daily note frontmatter
+
+**Daily Notes Requirements**:
+- Requires Daily Notes plugin to be enabled
+- Uses configured daily notes folder and format
+- Integrates with existing daily note workflow
+
+## Configuration Management
+
+### Settings Export/Import
+
+TaskNotes settings are stored in Obsidian's standard plugin data format:
+
+**Location**: `.obsidian/plugins/tasknotes/data.json`
+**Format**: JSON with typed structure
+**Backup**: Included in Obsidian vault backups automatically
+
+### Migration and Updates
+
+**Automatic Migration**: Settings are automatically migrated when plugin updates introduce new fields
+**Validation**: Settings are validated on load and invalid configurations are reset to defaults
+**Backward Compatibility**: Existing settings continue to work with new plugin versions
+
+### Advanced Customization
+
+For users comfortable with JSON editing:
+
+**Direct Editing**: Settings file can be edited directly when Obsidian is closed
+**Bulk Configuration**: Useful for setting up multiple vaults with identical configurations
+**Scripting Support**: Settings can be programmatically modified through Obsidian's plugin API
+
+These advanced settings provide the flexibility needed to adapt TaskNotes to sophisticated workflows while maintaining the simplicity of default configurations for standard use cases.

docs/settings/calendar-settings.md

@@ -0,0 +1,201 @@
+# Calendar Settings
+
+Calendar settings control the appearance and behavior of TaskNotes calendar views, time-based scheduling features, and integration with external calendar systems.
+
+## Default Calendar View
+
+### Initial View Mode
+
+**Setting**: `defaultView`
+**Options**: `dayGridMonth`, `timeGridWeek`, `timeGridDay`, `multiMonthYear`
+**Default**: `dayGridMonth`
+
+Determines which calendar view opens by default when accessing the Advanced Calendar View.
+
+**View Types**:
+- **dayGridMonth**: Standard monthly calendar with day grid
+- **timeGridWeek**: Weekly view with hourly time slots
+- **timeGridDay**: Single day view with detailed time breakdown
+- **multiMonthYear**: Year view showing multiple months simultaneously
+
+## Time Configuration
+
+### Time Slot Settings
+
+**Slot Duration**: `slotDuration`
+**Options**: `00:15:00`, `00:30:00`, `01:00:00`
+**Default**: `00:30:00`
+
+Controls the duration of time slots in week and day views. Shorter durations provide more precise scheduling while longer durations reduce visual clutter.
+
+**Slot Minimum Time**: `slotMinTime`
+**Format**: `HH:MM:SS`
+**Default**: `00:00:00`
+
+**Slot Maximum Time**: `slotMaxTime`
+**Format**: `HH:MM:SS`
+**Default**: `24:00:00`
+
+These settings define the time range displayed in week and day views. Set minimum and maximum times to focus on your working hours.
+
+**Example Working Hours Setup**:
+- Slot Min Time: `08:00:00` (8 AM)
+- Slot Max Time: `18:00:00` (6 PM)
+
+### Initial Scroll Position
+
+**Setting**: `scrollTime`
+**Format**: `HH:MM:SS`
+**Default**: `08:00:00`
+
+Sets where the calendar initially scrolls to in week and day views. Useful for automatically displaying your typical working hours.
+
+### Time Format
+
+**Setting**: `timeFormat`
+**Options**: `12`, `24`
+**Default**: `24`
+
+Controls whether times are displayed in 12-hour format (with AM/PM) or 24-hour format.
+
+## Week and Date Settings
+
+### First Day of Week
+
+**Setting**: `firstDay`
+**Options**: `0` (Sunday) through `6` (Saturday)
+**Default**: `1` (Monday)
+
+Determines which day appears first in weekly and monthly calendar views.
+
+**Common Settings**:
+- `0`: Sunday (US standard)
+- `1`: Monday (International standard)
+
+### Weekend Display
+
+**Setting**: `showWeekends`
+**Default**: `true`
+
+Controls whether Saturday and Sunday are displayed in calendar views. Disable for work-focused calendars that don't need weekend display.
+
+## Event Type Visibility
+
+These settings control which types of events are shown by default when opening calendar views. Users can still toggle these on/off within each view.
+
+### Task-Related Events
+
+**Show Scheduled Tasks**: `defaultShowScheduled`
+**Default**: `true`
+
+**Show Due Date Tasks**: `defaultShowDue`
+**Default**: `true`
+
+**Show Due Dates When Scheduled**: `defaultShowDueWhenScheduled`
+**Default**: `true`
+
+Controls whether due dates are displayed for tasks that already have scheduled dates. When enabled, tasks with both scheduled and due dates will appear twice on the calendar - once as a scheduled event and once as a due date event (with "DUE:" prefix). When disabled, only the scheduled date will be shown for tasks that have both dates.
+
+**Show Recurring Task Instances**: `defaultShowRecurring`
+**Default**: `true`
+
+Controls default visibility for different types of task events in calendar views.
+
+### Time Tracking Events
+
+**Show Time Entries**: `defaultShowTimeEntries`
+**Default**: `false`
+
+When enabled, completed time tracking sessions appear as events on the calendar, showing when actual work was performed on tasks.
+
+### External Calendar Events
+
+**Show ICS Events**: `defaultShowICSEvents`
+**Default**: `true`
+
+Controls default visibility for events from subscribed external calendars (Google Calendar, Outlook, etc.).
+
+## Timeblocking Features
+
+### Enable Timeblocking
+
+**Setting**: `enableTimeblocking`
+**Default**: `false`
+
+When enabled, allows creation and management of timeblocks in calendar views. Timeblocks are stored in daily note frontmatter.
+
+### Show Timeblocks
+
+**Setting**: `defaultShowTimeblocks`
+**Default**: `true`
+
+Controls default visibility for timeblocks from daily notes when timeblocking is enabled.
+
+**Timeblock Storage Format**:
+```yaml
+timeblocks:
+  - start: "09:00"
+    end: "10:30"
+    title: "Deep work session"
+    color: "#4285f4"
+    attachment: "[[Important Project Task]]"
+```
+
+## Calendar Behavior
+
+### Visual Indicators
+
+**Now Indicator**: `nowIndicator`
+**Default**: `true`
+
+Shows a line indicating the current time in week and day views.
+
+**Today Highlight**: `showTodayHighlight`
+**Default**: `true`
+
+Highlights the current date in calendar views with distinct styling.
+
+**Week Numbers**: `weekNumbers`
+**Default**: `false`
+
+Displays week numbers (1-52) in monthly calendar views.
+
+### Interaction Behavior
+
+**Select Mirror**: `selectMirror`
+**Default**: `true`
+
+Shows visual preview when dragging events or creating new items in calendar views.
+
+## External Calendar Integration
+
+### ICS Subscription Management
+
+TaskNotes supports subscribing to external ICS calendar feeds. These settings are managed through the calendar settings interface.
+
+**Supported Sources**:
+- Google Calendar (public and private feeds)
+- Microsoft Outlook/Exchange calendars
+- Apple iCloud calendars
+- Any service providing standard ICS/iCal feeds
+- Local ICS files within your vault
+
+**Subscription Properties**:
+- **Name**: Display name for the calendar subscription
+- **URL/Path**: Remote URL or local file path to ICS source
+- **Color**: Custom color for events from this calendar
+- **Enabled**: Toggle subscription visibility
+- **Refresh Interval**: How often to update remote calendars (15-1440 minutes)
+
+### Subscription Management
+
+**Add Subscription**: Configure new external calendar feeds
+**Edit Subscription**: Modify existing subscription properties
+**Enable/Disable**: Toggle subscription visibility without removing
+**Manual Refresh**: Force immediate update of calendar data
+**Remove Subscription**: Delete subscription with confirmation
+
+### Local ICS File Support
+
+**File Watching**: Local ICS files are monitored for changes and updated automatically
+**Path Display**: Shows vault-relative path for local files

docs/settings/inline-task-settings.md

@@ -0,0 +1,130 @@
+# Inline Task Settings
+
+Inline task settings control how TaskNotes integrates with your regular note-taking workflow. These settings manage the display of task widgets, instant conversion features, and natural language processing capabilities.
+
+## Task Link Overlay
+
+### Enable Task Link Overlay
+
+**Setting**: `enableTaskLinkOverlay`
+**Default**: `true`
+
+When enabled, TaskNotes replaces standard wikilinks to task files with interactive task widgets that display key task information and allow basic task management operations directly within your notes.
+
+**Widget Features When Enabled**:
+- Status indicator with click-to-cycle functionality
+- Priority indicator with click-to-change capability
+- Due date display with date picker access
+- Scheduled date display with date picker access
+- Task title with link to full task note
+- Context menu for additional task operations
+
+**When Disabled**:
+- Task links appear as normal Obsidian wikilinks
+- No inline task management capabilities
+- Standard hover preview functionality applies
+
+
+## Instant Task Conversion
+
+### Enable Instant Task Convert
+
+**Setting**: `enableInstantTaskConvert`
+**Default**: `true`
+
+Controls whether convert buttons appear next to checkbox tasks in edit mode, allowing one-click conversion from simple checkboxes to full TaskNotes.
+
+**When Enabled**:
+- File-plus icons appear next to checkbox tasks (`- [ ]` and `- [x]`)
+- Click to instantly convert checkbox to TaskNote file
+- Multi-line conversion support for additional details
+- Automatic link replacement in original location
+
+**When Disabled**:
+- No convert buttons appear in edit mode
+- Checkbox tasks remain as standard Obsidian checkboxes
+- Manual task creation required for TaskNotes functionality
+
+
+
+### Apply Defaults on Instant Convert **Setting**: `useDefaultsOnInstantConvert` **Default**: `true`
+Determines whether instant conversion applies your configured task defaults (status, priority, contexts, tags, etc.) to converted tasks.
+
+**When Enabled**:
+- Converted tasks receive default status and priority
+- Default contexts and tags are applied
+- Default time estimates and other properties included
+- Template processing applied if configured
+
+**When Disabled**:
+- Converted tasks use minimal default values
+- Only basic task structure created
+- No automatic property assignment
+- Faster conversion with less processing
+
+
+## Natural Language Processing
+
+### Enable Natural Language Input
+
+**Setting**: `enableNaturalLanguageInput`
+**Default**: `true`
+
+Controls whether the smart input field appears in task creation modals, allowing you to create tasks by typing natural language descriptions.
+
+**When Enabled**:
+- Natural language input field appears in task creation modal
+- Parse button available to process descriptions
+- Live preview of parsed task properties
+- Integration with task defaults and templates
+
+**When Disabled**:
+- Only standard task property fields available
+- No natural language parsing capabilities
+- Manual entry required for all task properties
+
+### Default Date Type for Natural Language
+
+**Setting**: `nlpDefaultToScheduled`
+**Default**: `true`
+
+When the natural language parser encounters ambiguous date references (like "tomorrow" without explicit "due" or "scheduled" keywords), this setting determines how those dates are interpreted.
+
+**When True (Default to Scheduled)**:
+- Ambiguous dates become scheduled dates
+- "Buy groceries tomorrow" → scheduled for tomorrow
+- Explicit keywords still override: "due tomorrow" → due date
+
+**When False (Default to Due)**:
+- Ambiguous dates become due dates  
+- "Buy groceries tomorrow" → due tomorrow
+- Explicit keywords still override: "scheduled tomorrow" → scheduled date
+
+**Parsing Examples**:
+
+With `nlpDefaultToScheduled: true`:
+- "Meeting tomorrow" → scheduled: tomorrow
+- "Report due Friday" → due: Friday (explicit)
+- "Call client next week" → scheduled: next week
+
+With `nlpDefaultToScheduled: false`:
+- "Meeting tomorrow" → due: tomorrow
+- "Report scheduled Friday" → scheduled: Friday (explicit)
+- "Call client next week" → due: next week
+
+## Integration Behavior
+
+### Interaction with Task Defaults
+
+Inline task settings work together with task defaults:
+
+**Instant Conversion with Defaults**:
+- When `useDefaultsOnInstantConvert` is enabled, converted tasks inherit all configured defaults
+- Default contexts, tags, status, and priority are applied
+- Template processing occurs if body templates are enabled
+
+**Natural Language with Defaults**:
+- Parsed values override defaults where specified
+- Unspecified properties use configured defaults
+- Template variables populated with parsed or default values
+

docs/settings/task-defaults.md

@@ -0,0 +1,242 @@
+# Task Defaults
+
+Task defaults control how new tasks are created and what default values they receive. These settings help streamline task creation by pre-filling common values and configuring the basic task management workflow.
+
+## Folder and File Management
+
+### Default Tasks Folder
+
+**Setting**: `tasksFolder`
+**Default**: `TaskNotes/Tasks`
+
+Specifies where new task files are created by default. The folder will be created automatically if it doesn't exist.
+
+**Usage Notes**:
+- Use forward slashes for folder paths
+- Relative to your vault root
+- Can be overridden per task using the default folder setting below
+
+### Task Tag
+
+**Setting**: `taskTag`  
+**Default**: `task`
+
+The Obsidian tag that identifies notes as TaskNotes. This tag is automatically added to all tasks.
+
+**Important Behaviors**:
+- Enter without the `#` symbol (the plugin adds this automatically)
+- This tag is always included in task files
+- Used by the plugin to identify which notes are tasks
+- Changing this will not automatically update existing tasks
+
+### Excluded Folders
+
+**Setting**: `excludedFolders`
+**Default**: Empty
+
+Comma-separated list of folder paths to exclude from the Notes view. This setting helps performance by skipping folders that don't contain relevant notes.
+
+**Format**: `folder1, folder2/subfolder, folder3`
+
+## Filename Generation
+
+### Filename Format
+
+**Setting**: `taskFilenameFormat`
+**Options**: `title`, `zettel`, `timestamp`, `custom`
+**Default**: `zettel`
+
+Controls how task filenames are generated:
+
+**Title**: Uses the task title as the filename (sanitized for filesystem compatibility)
+**Zettel**: Uses `YYMMDD` format plus base36 seconds since midnight (e.g., `25012715a`)
+**Timestamp**: Full timestamp format `YYYY-MM-DD-HHMMSS`
+**Custom**: Uses the custom filename template with variable substitution
+
+### Custom Filename Template
+
+**Setting**: `customFilenameTemplate`
+**Default**: `{title}`
+
+Template used when filename format is set to "custom". Supports variable substitution:
+
+**Available Variables**:
+- `{title}`: Task title
+- `{date}`: Current date (YYYY-MM-DD)  
+- `{time}`: Current time (HHMMSS)
+- `{priority}`: Task priority
+- `{status}`: Task status
+
+**Example Templates**:
+- `{date}-{title}`: Date prefix with title
+- `Task-{date}-{time}`: Timestamp-based with prefix
+- `{priority}-{title}`: Priority-based organization
+
+## Default Task Properties
+
+### Status and Priority
+
+**Default Status**: `defaultTaskStatus`
+**Default**: `open`
+
+**Default Priority**: `defaultTaskPriority`  
+**Default**: `normal`
+
+These settings determine the initial status and priority assigned to new tasks. Values must match your configured statuses and priorities.
+
+### Default Dates
+
+**Default Due Date**: `defaultDueDate`
+**Options**: `none`, `today`, `tomorrow`, `next-week`
+**Default**: `none`
+
+**Default Scheduled Date**: `defaultScheduledDate`
+**Options**: `none`, `today`, `tomorrow`, `next-week`  
+**Default**: `today`
+
+Automatically assigns due dates and scheduled dates to new tasks based on the selected option.
+
+### Organization Defaults
+
+**Default Contexts**: `defaultContexts`
+**Format**: Comma-separated string
+**Example**: `@home, @computer, @phone`
+
+**Default Tags**: `defaultTags`
+**Format**: Comma-separated string  
+**Example**: `#work, #project-alpha, #urgent`
+
+These settings pre-populate the contexts and tags fields when creating new tasks.
+
+### Time and Recurrence
+
+**Default Time Estimate**: `defaultTimeEstimate`
+**Default**: `0` (no estimate)
+**Unit**: Minutes
+
+**Default Recurrence**: `defaultRecurrence`
+**Options**: `none`, `daily`, `weekly`, `monthly`, `yearly`
+**Default**: `none`
+
+Sets default time estimates and recurrence patterns for new tasks.
+
+
+
+## Template System
+
+### Body Template
+
+**Use Body Template**: `useBodyTemplate`
+**Default**: `false`
+
+**Body Template Path**: `bodyTemplate`
+**Default**: Empty
+
+When enabled, applies a template file to the body content of new tasks.
+
+### Template File Format
+
+Template files can contain both YAML frontmatter and body content:
+
+```markdown
+---
+customField: "default value"
+projectTag: "project-name"
+---
+
+# Task Details
+
+Use this section for additional context and notes.
+
+## Related Links
+- [[Project Overview]]
+- [[Meeting Notes]]
+
+## Progress Notes
+- 
+```
+
+### Template Variables
+
+Templates support variable substitution in both frontmatter and body content:
+
+**Basic Variables**:
+- `{{title}}`: Task title
+- `{{details}}`: User-provided details from creation modal
+- `{{date}}`: Current date (YYYY-MM-DD)
+- `{{time}}`: Current time (HH:MM)
+
+**Task Properties**:
+- `{{priority}}`: Task priority level
+- `{{status}}`: Task status
+- `{{contexts}}`: Task contexts (comma-separated)
+- `{{tags}}`: Task tags (comma-separated)
+- `{{timeEstimate}}`: Time estimate in minutes
+- `{{dueDate}}`: Due date if set
+- `{{scheduledDate}}`: Scheduled date if set
+
+**Context Variables**:
+- `{{parentNote}}`: Link to the note where task was created (for instant conversion)
+
+### Template Processing
+
+**Frontmatter Merging**: Template frontmatter is merged with default task properties, with template values taking precedence.
+
+**Variable Substitution**: All template variables are processed during task creation.
+
+**Error Handling**: If the template file is missing or invalid, task creation continues with default content.
+
+## Natural Language Processing
+
+### Enable Natural Language Input
+
+**Setting**: `enableNaturalLanguageInput`
+**Default**: `true`
+
+When enabled, shows a smart input field in the task creation modal that can parse natural language descriptions into structured task data.
+
+### Default Date Type
+
+**Setting**: `nlpDefaultToScheduled`
+**Default**: `true`
+
+When the natural language parser finds ambiguous dates (like "tomorrow" without "due" or "scheduled"), this setting determines whether they become due dates (false) or scheduled dates (true).
+
+## Usage Examples
+
+### Project-Based Setup
+
+For project-based task management:
+
+```
+Tasks Folder: Projects/Current/Tasks
+Default Contexts: @project
+Default Tags: #current-project
+Use Body Template: true
+Body Template: Templates/Project-Task-Template.md
+```
+
+### GTD-Style Setup
+
+For Getting Things Done methodology:
+
+```
+Tasks Folder: GTD/Tasks
+Default Contexts: @anywhere
+Default Status: open
+Default Priority: normal
+Filename Format: timestamp
+```
+
+### Simple Setup
+
+For basic task management:
+
+```
+Tasks Folder: Tasks
+Default Scheduled Date: today
+Filename Format: title
+Use Body Template: false
+```
+
+These defaults settings provide the foundation for your TaskNotes workflow and can be adjusted as your needs evolve.

docs/stylesheets/extra.css

@@ -0,0 +1,3 @@
+/* Custom styles for TaskNotes documentation */
+
+/* Add any custom styling here */

docs/troubleshooting.md

@@ -0,0 +1,191 @@
+# Troubleshooting
+
+This section covers common issues and their solutions when using TaskNotes.
+
+## Common Issues
+
+### Tasks Not Appearing in Views
+
+**Symptoms**: Tasks you've created don't show up in TaskNotes views
+
+**Possible Causes**:
+- Task files are missing the configured task tag
+- Files are in excluded folders
+- Tasks don't have valid YAML frontmatter
+- Cache needs refreshing
+
+**Solutions**:
+1. Check that task files include the task tag configured in settings (default: `#task`)
+2. Verify task files are not in folders listed in "Excluded folders" setting
+3. Ensure YAML frontmatter is properly formatted with opening and closing `---` lines
+4. Try closing and reopening TaskNotes views to refresh the cache
+5. Restart Obsidian if cache issues persist
+
+### Task Link Widgets Not Working
+
+**Symptoms**: Links to task files appear as normal wikilinks instead of interactive widgets
+
+**Possible Causes**:
+- Task link overlay is disabled in settings
+- Task files don't have the required task tag
+- Links are to non-task files
+
+**Solutions**:
+1. Enable "Task link overlay" in Inline Task Settings
+2. Ensure linked files have the configured task tag in their frontmatter
+3. Verify you're linking to actual task files created by TaskNotes
+
+### Instant Conversion Buttons Missing
+
+**Symptoms**: Convert buttons don't appear next to checkbox tasks
+
+**Possible Causes**:
+- Instant task convert is disabled
+- Not in edit mode
+- Cursor not near checkbox tasks
+
+**Solutions**:
+1. Enable "Instant task convert" in Inline Task Settings
+2. Switch to edit mode (not reading mode)
+3. Position cursor near checkbox tasks to make buttons visible
+
+### Calendar View Performance Issues
+
+**Symptoms**: Calendar views are slow or unresponsive
+
+**Possible Causes**:
+- Large number of tasks or external calendar events
+- Multiple ICS subscriptions with frequent refresh
+- Complex recurring task patterns
+
+**Solutions**:
+1. Disable unused event types in calendar view toggles
+2. Increase ICS subscription refresh intervals
+3. Consider disabling note indexing if you don't use the Notes view
+4. Reduce the number of external calendar subscriptions
+
+### Natural Language Parsing Not Working
+
+**Symptoms**: Natural language input doesn't extract expected task properties
+
+**Possible Causes**:
+- Natural language processing is disabled
+- Input format doesn't match supported patterns
+- Custom status/priority words not configured
+
+**Solutions**:
+1. Enable "Natural language input" in Task Defaults settings
+2. Review supported syntax in the Natural Language Processing documentation
+3. Configure custom priority and status words if using non-default values
+4. Try simpler input patterns to test basic functionality
+
+### Time Tracking Issues
+
+**Symptoms**: Time tracking doesn't start/stop properly or data is lost
+
+**Possible Causes**:
+- Multiple time tracking sessions active
+- Browser/Obsidian closed during active session
+- Task file permissions or save issues
+
+**Solutions**:
+1. Stop any active time tracking before starting new sessions
+2. Manually edit task frontmatter to fix corrupted time entries
+3. Check that task files can be saved (not read-only)
+4. Restart active time tracking sessions after unexpected shutdowns
+
+## Data Issues
+
+### Corrupted Task Files
+
+**Symptoms**: Tasks appear broken or cause errors in views
+
+**Solutions**:
+1. Open the task file directly and check YAML frontmatter syntax
+2. Ensure YAML values are properly quoted when containing special characters
+3. Validate YAML syntax using an online YAML validator
+4. Restore from backup if file corruption is severe
+
+### Missing Task Properties
+
+**Symptoms**: Tasks missing expected properties or using default values unexpectedly
+
+**Solutions**:
+1. Check field mapping settings to ensure property names match your expectations
+2. Verify default values in Task Defaults settings
+3. Manually add missing properties to task frontmatter
+4. Re-save tasks through TaskNotes to apply current field mapping
+
+### Date Format Issues
+
+**Symptoms**: Dates not displaying correctly or causing parse errors
+
+**Solutions**:
+1. Use supported date formats: YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS
+2. Check that dates are quoted in YAML frontmatter when necessary
+3. Verify time zone handling for dates with time components
+4. Re-enter dates through TaskNotes date pickers to ensure correct format
+
+## Performance Troubleshooting
+
+### Slow View Loading
+
+**Solutions**:
+1. Disable note indexing if you don't use the Notes view
+2. Reduce the number of external calendar subscriptions
+3. Exclude large folders from note processing
+4. Consider using simpler status and priority configurations
+
+## External Calendar Issues
+
+### ICS Subscriptions Not Loading
+
+**Symptoms**: External calendar events don't appear in calendar views
+
+**Solutions**:
+1. Verify ICS URL is correct and accessible
+2. Check network connection and firewall settings
+3. Try manual refresh of the subscription
+4. Validate ICS feed using online ICS validators
+5. Check error messages in subscription status
+
+### Calendar Sync Problems
+
+**Symptoms**: External calendar changes not reflected in TaskNotes
+
+**Solutions**:
+1. Check refresh interval settings for the subscription
+2. Manually refresh the subscription
+3. Verify the external calendar is actually updated at the source
+4. Clear cached calendar data by removing and re-adding subscription
+
+## Getting Help
+
+### Diagnostic Information
+
+When reporting issues, include:
+
+1. TaskNotes version number
+2. Obsidian version
+3. Operating system
+4. Specific error messages
+5. Steps to reproduce the issue
+6. Screenshots if relevant
+
+### Community Support
+
+- Check the GitHub repository for existing issues
+- Search community forums for similar problems
+- Review documentation for configuration guidance
+
+### Configuration Reset
+
+If all else fails, you can reset TaskNotes configuration:
+
+1. Close Obsidian
+2. Navigate to `.obsidian/plugins/tasknotes/`
+3. Rename or delete `data.json`
+4. Restart Obsidian (this will reset all settings to defaults)
+
+!!! warning "Important"
+    Resetting configuration will lose all custom settings, status configurations, and ICS subscriptions. Export or document your current settings before resetting.

docs/views.md

@@ -0,0 +1,78 @@
+# Views
+
+TaskNotes provides eight different view types, each designed for specific workflows and use cases. Views work with task data stored in your notes' YAML frontmatter, while some views also display regular notes from your vault.
+
+## Overview of View Types
+
+**Task List View**: A comprehensive task list with filtering, grouping, and sorting options. Displays all tasks across your vault with full task management capabilities.
+
+**Notes View**: Shows regular vault notes organized by date. Displays notes created or modified on specific days. Useful for browsing your note-taking activity over time.
+
+**Agenda View**: A chronological view combining both tasks and notes over a configurable time period. Shows items organized by date for daily and weekly planning.
+
+**Kanban View**: Displays tasks as cards organized in columns. Columns can be grouped by status, priority, or context for visual workflow management.
+
+**Mini Calendar View**: A compact month calendar with visual indicators for dates containing tasks, notes, or daily notes. Provides date navigation and overview.
+
+**Advanced Calendar View**: A full-featured calendar using FullCalendar with multiple view modes (month, week, day). Supports task scheduling, external calendar integration, and time-blocking.
+
+**Pomodoro View**: A timer interface for focused work sessions. Displays a circular progress timer with optional task association for time tracking.
+
+**Pomodoro Stats View**: Statistics and history for pomodoro sessions. Shows completion rates, session history, and productivity metrics.
+
+## Common View Features
+
+All task-focused views share several common features:
+
+**Filtering**: Filter tasks by status, priority, contexts, tags, date ranges, and other criteria. Filters can be combined to create specific task subsets.
+
+**Search**: Full-text search across task titles and content. Search terms are highlighted in results.
+
+**Sorting**: Sort tasks by title, due date, scheduled date, priority, status, creation date, or modification date in ascending or descending order.
+
+**Grouping**: Group tasks by status, priority, contexts, tags, or dates to organize related items together.
+
+**Quick Actions**: Perform common actions like marking tasks complete, changing status or priority, and editing properties directly from the view.
+
+## View-Specific Features
+
+### Task and Notes Views
+- **Context Menus**: Right-click tasks for additional actions like opening in new tab or editing
+
+### Calendar Views
+- **Date Navigation**: Move between months, weeks, and days using navigation controls
+- **Task Creation**: Create new tasks by clicking on dates or time slots
+- **Drag and Drop**: Move tasks between dates by dragging (in Advanced Calendar View)
+- **External Calendar Integration**: Display events from subscribed ICS calendars alongside tasks
+
+### Kanban View
+- **Column Customization**: Columns automatically match your configured task statuses
+- **Card Details**: Task cards show title, due date, priority, and other key information
+- **Status Progression**: Move tasks between columns to change their status
+
+### Pomodoro Views
+- **Timer Integration**: Start focused work sessions directly from tasks
+- **Session Tracking**: Record time spent on specific tasks
+- **Statistics**: View completion rates, total time spent, and productivity patterns
+
+## View Persistence
+
+TaskNotes remembers your view settings between sessions:
+
+- Filter criteria and search terms
+- Sort and grouping preferences  
+- Selected date ranges and calendar positions
+- View-specific settings like column widths
+
+This allows you to set up views for specific workflows (like "Today's tasks" or "High priority items") and return to them quickly.
+
+## Opening and Managing Views
+
+Views can be opened through:
+
+- **Command Palette**: Search for "TaskNotes" to see all available view commands
+- **Ribbon Icons**: Add TaskNotes view icons to the ribbon for quick access
+- **Hotkeys**: Assign keyboard shortcuts to frequently used views
+- **Context Menus**: Some views can be opened from task links and other locations
+
+Multiple instances of the same view type can be open simultaneously, each with independent settings. This allows you to monitor different aspects of your tasks at the same time.

docs/views/agenda-view.md

@@ -0,0 +1,89 @@
+# Agenda View
+
+The Agenda View provides a focused, chronological list of upcoming tasks and notes sorted by due dates and scheduled dates. It's designed for daily and weekly planning, helping you see what needs attention in the near term.
+
+## Content Organization
+
+**Chronological Sorting**: Tasks and notes are sorted primarily by due date, with scheduled date as a secondary sort criterion.
+
+**Time-Based Groupings**:
+- **Overdue**: Tasks past their due dates, highlighted for immediate attention
+- **Today**: Tasks and notes due or scheduled for today
+- **Tomorrow**: Tasks and notes for the next day
+- **This Week**: Tasks and notes due within the current week  
+- **Next Week**: Tasks and notes for the following week
+- **Later**: Tasks and notes beyond the next week
+
+**Priority Within Groups**: Within each time grouping, items are sub-sorted by priority level to highlight the most important items.
+
+## Interface Features
+
+**Clean Layout**: Minimal interface focused on task content without distracting elements.
+
+**Essential Information**: Each item shows:
+- Title with link to full note
+- Due and/or scheduled dates
+- Priority indicator (for tasks)
+- Status indicator (for tasks)
+- Key contexts and tags
+
+**Visual Hierarchy**: Different styling for overdue, urgent, and future items helps with quick prioritization.
+
+## Focus Features
+
+**Date Range Control**: Adjust how far into the future the agenda extends:
+- Today only
+- Next 3 days
+- Next week
+- Next month
+- Custom range
+
+**Completion Handling**: Options for how completed tasks are displayed:
+- Hide completed tasks entirely
+- Show completed tasks with strikethrough
+- Show completed tasks in separate section
+
+**Urgency Highlighting**: Visual emphasis on:
+- Overdue tasks (red highlighting)
+- Tasks due today (distinct styling) 
+- High-priority tasks (bold or colored text)
+
+## Quick Actions
+
+**Inline Task Management**:
+- Mark tasks complete with checkbox interaction
+- Change priority or status with quick selectors
+- Edit due dates with date picker
+- Add or modify contexts and tags
+
+**Individual Task Management**: Tasks can be managed through context menus and quick actions without leaving the agenda view.
+
+## Planning Integration
+
+**Daily Planning Workflow**: Use the Agenda View as part of daily planning routines:
+1. Review overdue tasks and reschedule or complete
+2. Check today's tasks and prioritize
+3. Preview tomorrow's work for preparation
+4. Identify potential scheduling conflicts
+
+**Weekly Review**: Extend the date range to see the full week ahead and balance workload across days.
+
+**Capacity Planning**: Visual density of tasks per day helps identify overloaded periods.
+
+## Filtering and Customization
+
+**Standard Filters**: Apply filters for status, priority, contexts, and tags to focus on specific types of work.
+
+**Context-Specific Views**: Filter by context to see location-based or tool-specific tasks.
+
+**Project Focus**: Use tag filtering to view agenda items for specific projects or areas of responsibility.
+
+**Workload Balancing**: Hide or de-emphasize certain task types to focus on critical path items.
+
+## Performance and Responsiveness
+
+**Efficient Loading**: Only loads tasks within the specified date range for optimal performance.
+
+**Real-Time Updates**: Changes to task dates or properties immediately update the agenda display.
+
+**Keyboard Navigation**: Support for keyboard shortcuts to navigate through dates and tasks efficiently.

docs/views/calendar-views.md

@@ -0,0 +1,149 @@
+# Calendar Views
+
+TaskNotes provides two calendar-based views for visualizing and managing tasks in relation to time: the Mini Calendar and the Advanced Calendar. Both views display tasks based on their due dates and scheduled dates, but serve different purposes and workflows.
+
+## Mini Calendar View
+
+The Mini Calendar is a compact calendar widget designed for quick navigation and overview. It shows a month view with indicators for days that contain tasks.
+
+### Interface Elements
+
+**Month Navigation**: Previous/next buttons and month/year selectors for moving between time periods.
+
+**Date Grid**: Standard calendar layout with date numbers. Days with tasks show visual indicators.
+
+**Task Indicators**: 
+- Small dots or badges indicate days with tasks
+- Different colors represent different task statuses or priorities
+- Number badges show task count for busy days
+
+**Current Date Highlighting**: Today's date is visually distinguished from other dates.
+
+### Functionality
+
+**Task Overview**: Quickly see which days have tasks without viewing details.
+
+**Date Navigation**: Click any date to jump to that day in other views or open the Notes view for that date.
+
+**Visual Density**: Compact design makes it suitable for keeping open alongside other views or as a sidebar widget.
+
+**Quick Reference**: Provides an at-a-glance view of task distribution across the month.
+
+## Advanced Calendar View
+
+The Advanced Calendar provides a full-featured calendar interface with multiple view modes and detailed task display.
+
+### View Modes
+
+**Month View**: Standard monthly calendar showing tasks as events on their respective dates.
+
+**Week View**: Seven-day layout with hourly time slots for detailed scheduling.
+
+**Day View**: Single-day view with hourly breakdown for detailed time management.
+
+**Agenda View**: List-based view of upcoming tasks sorted chronologically.
+
+### Task Display
+
+**Task Events**: Tasks appear as colored blocks or entries on their scheduled or due dates.
+
+**Time Slots**: In week and day views, tasks with specific times appear in appropriate time slots.
+
+**All-Day Events**: Tasks without specific times appear in the all-day section.
+
+**Color Coding**: Tasks are colored based on:
+- Status (completed, in-progress, etc.)
+- Priority levels
+- Custom color schemes from settings
+
+**Task Details**: Hover over task events to see additional information like priority, contexts, and notes.
+
+### Interactive Features
+
+**Task Creation**: 
+- Click on empty dates or time slots to create new tasks
+- Created tasks automatically inherit the selected date/time
+- Quick creation modal for basic task information
+
+**Task Editing**:
+- Click existing task events to open edit modal
+- Modify properties directly from the calendar
+- Mark tasks complete with quick actions
+
+**Drag and Drop**: 
+- Move tasks between dates by dragging
+- Reschedule tasks by dragging to different time slots
+- Visual feedback during drag operations
+
+**Date Navigation**:
+- Navigate between time periods using arrow buttons
+- Jump to specific dates using date picker
+- Keyboard shortcuts for common navigation
+
+### External Calendar Integration
+
+Both calendar views can display events from external calendar sources alongside your TaskNotes:
+
+**ICS Subscription**: Subscribe to remote calendar feeds from:
+- Google Calendar
+- Outlook/Exchange calendars  
+- iCloud calendars
+- Any calendar supporting the ICS format
+
+**Local ICS Files**: Import calendar files stored locally in your vault.
+
+**Event Display**: External events appear as read-only entries with distinct styling.
+
+**Calendar Management**: Add, edit, or remove calendar subscriptions through settings.
+
+### Time-Blocking Features
+
+The Advanced Calendar supports time-blocking workflows:
+
+**Scheduled Tasks**: Tasks with scheduled dates and times appear as blocks in the calendar.
+
+**Duration Display**: Tasks with time estimates show as blocks spanning the estimated duration.
+
+**Daily Notes Integration**: 
+- View time blocks from daily notes alongside tasks
+- Create time blocks that link to daily note sections
+- Maintain consistency between calendar and note-based planning
+
+### Customization Options
+
+**View Preferences**:
+- Default view mode (month, week, day)
+- Start day of week (Sunday or Monday)
+- Working hours display in week/day views
+- Time format (12-hour or 24-hour)
+
+**Display Settings**:
+- Task color schemes
+- Compact or detailed task display
+- Show/hide completed tasks
+- Weekend highlighting
+
+**Integration Settings**:
+- External calendar refresh intervals
+- Default task properties for calendar-created tasks
+- Time zone handling for external calendars
+
+### Performance and Responsiveness
+
+**Efficient Rendering**: Calendar views use optimized rendering for smooth performance with large numbers of tasks.
+
+**Real-Time Updates**: Changes to tasks are reflected immediately in calendar views.
+
+**Background Sync**: External calendar data is updated in the background without blocking the interface.
+
+**Responsive Design**: Calendar views adapt to different panel sizes and screen resolutions.
+
+## Workflow Integration
+
+Calendar views integrate with other TaskNotes features:
+
+**Cross-View Consistency**: Dates selected in calendar views update related views like Notes and Agenda.
+
+**Filter Coordination**: Applied filters in other views can be reflected in calendar displays.
+
+**Task Creation Flow**: Tasks created in calendar views inherit appropriate default settings and can trigger template application.

docs/views/kanban-view.md

@@ -0,0 +1,135 @@
+# Kanban View
+
+The Kanban View displays tasks as cards organized in columns based on their status. This provides a visual workflow management interface similar to tools like Trello or Jira, where tasks progress from left to right through different stages.
+
+## Interface Layout
+
+**Status Columns**: Each column represents a different task status as configured in your settings. The default columns are:
+- None/New: Tasks without an assigned status
+- Open: Tasks ready to begin
+- In Progress: Tasks currently being worked on  
+- Done: Completed tasks
+
+**Task Cards**: Individual tasks appear as cards within the appropriate status column. Cards display key task information in a compact format.
+
+**Column Headers**: Show the status name and count of tasks in each column.
+
+## Task Cards
+
+Each task card displays:
+
+**Title**: The main task name, truncated if too long with full title on hover.
+
+**Priority Indicator**: Visual indicator (color or icon) showing task priority level.
+
+**Due Date**: When the task is due, with visual highlighting for overdue items.
+
+**Contexts**: Associated contexts displayed as small tags or badges.
+
+**Tags**: Obsidian tags shown as colored labels.
+
+**Progress Indicators**: 
+- Time tracking status if active
+- Recurrence indicators for recurring tasks
+- Attachment or note content indicators
+
+## Moving Tasks Between Columns
+
+**Drag and Drop**: Click and drag task cards between columns to change their status. The task's status property is automatically updated when dropped in a new column.
+
+**Visual Feedback**: During drag operations:
+- The dragged card becomes semi-transparent
+- Valid drop zones are highlighted
+- Invalid drop areas are visually indicated
+
+**Auto-Save**: Status changes are saved immediately when cards are moved.
+
+## Column Customization
+
+**Status Mapping**: Columns automatically match your configured task statuses from settings. Adding or modifying statuses updates the Kanban columns accordingly.
+
+**Column Order**: Columns appear in the same order as statuses are configured in settings.
+
+**Column Visibility**: Empty columns can be hidden or shown based on preference settings.
+
+**Completed Tasks**: The "Done" column can be configured to:
+- Show all completed tasks
+- Show only recently completed tasks  
+- Hide completed tasks entirely
+
+## Filtering and Search
+
+The Kanban view supports the same filtering options as other views:
+
+**Global Filters**: Applied filters affect all columns simultaneously, showing only tasks that match the criteria.
+
+**Search Integration**: Text search highlights matching cards across all columns.
+
+**Filter Persistence**: Filter settings are maintained when switching between views.
+
+## Task Actions
+
+**Card Click**: Click anywhere on a task card to open the full task note.
+
+**Quick Actions**: Hover over cards to reveal quick action buttons:
+- Mark complete/incomplete
+- Change priority  
+- Edit properties
+- Delete task
+
+**Context Menu**: Right-click cards for additional options:
+- Open in new tab or pane
+- Copy task link
+- Convert to different task type
+- View task details
+
+**Bulk Selection**: Use Ctrl/Cmd+click to select multiple cards for bulk operations.
+
+## Creating Tasks
+
+**Column Creation**: Click the "+" button at the top of any column to create a new task with that status.
+
+**Quick Add**: Use the quick add input to create tasks that appear in the default status column.
+
+**Drag to Create**: Some workflows support dragging from external sources to create tasks in specific columns.
+
+## Visual Customization
+
+**Color Coding**: Cards are colored based on:
+- Priority levels (configurable in settings)
+- Due date urgency (overdue, due soon, etc.)
+- Custom status colors
+
+**Card Density**: Settings control whether cards show minimal or detailed information.
+
+**Column Width**: Columns automatically size based on content, with minimum and maximum width constraints.
+
+## Performance Considerations
+
+**Virtual Scrolling**: Large numbers of tasks in columns use virtual scrolling to maintain performance.
+
+**Progressive Loading**: Very large task sets load incrementally to keep the interface responsive.
+
+**Efficient Updates**: Only changed cards are re-rendered when task data updates.
+
+## Workflow Benefits
+
+The Kanban view is particularly useful for:
+
+**Project Management**: Visualizing task progression through defined workflow stages.
+
+**Team Coordination**: Understanding what work is in progress versus waiting to be started.
+
+**Bottleneck Identification**: Seeing where tasks accumulate in the workflow.
+
+**Sprint Planning**: Managing development cycles or time-boxed work periods.
+
+**Personal Productivity**: Getting satisfaction from moving tasks toward completion.
+
+## Integration with Other Views
+
+**Cross-View Updates**: Changes made in the Kanban view immediately appear in other TaskNotes views.
+
+**Filter Coordination**: Filters applied in other views can be reflected in the Kanban display.
+
+**Date Integration**: Tasks can be moved in Kanban while maintaining their scheduled or due dates from calendar views.

docs/views/notes-view.md

@@ -0,0 +1,62 @@
+# Notes View
+
+The Notes View displays your vault notes organized by date, allowing you to browse notes based on when they were created or modified. This view is designed for reviewing your note-taking activity and finding notes from specific time periods.
+
+## Interface Layout
+
+**Date Navigation**: Header contains date selection controls to move between days, weeks, or months.
+
+**Note Cards**: Notes for the selected date are displayed as cards showing key information about each note.
+
+**Note Count**: Shows the total number of notes for the selected date.
+
+## Date Organization
+
+**Date-Based Filtering**: Notes are filtered based on their creation or modification dates to show only notes relevant to the selected date.
+
+**Navigation Controls**: 
+- Previous/next day navigation
+- Direct date selection
+- Jump to today option
+
+## Note Display
+
+Each note card shows:
+
+**Title**: The note's filename or title, which links to open the note when clicked.
+
+**Path**: The note's location within your vault folder structure.
+
+**Creation Date**: When the note was originally created.
+
+**Tags**: Any Obsidian tags associated with the note.
+
+**Note Type Indicators**: Visual indicators if the note has special properties (like being a task note).
+
+## Note Actions
+
+**Open Note**: Click on any note card to open that note in the current pane.
+
+**Context Menu**: Right-click note cards for additional options like opening in new tab or showing in file explorer.
+
+**Direct Navigation**: Navigate directly to notes from specific dates.
+
+## Use Cases
+
+The Notes View is useful for:
+
+**Daily Review**: See what notes you created or worked on during specific days.
+
+**Historical Reference**: Find notes from meetings, projects, or events that occurred on particular dates.
+
+**Note Discovery**: Browse through your note-taking activity over time to rediscover content.
+
+**Productivity Tracking**: Review your note-taking patterns and productivity across different time periods.
+
+## Integration
+
+**Vault Integration**: Works with all notes in your vault, regardless of whether they're TaskNotes or regular notes.
+
+**Date Awareness**: Automatically detects note creation and modification dates from Obsidian's metadata.
+
+**Search Integration**: Can be combined with vault search to find notes from specific dates that match certain criteria.

docs/views/pomodoro-view.md

@@ -0,0 +1,152 @@
+# Pomodoro Views
+
+TaskNotes includes integrated pomodoro timer functionality with two dedicated views: the Pomodoro View for active timer sessions and the Pomodoro Stats View for tracking productivity over time.
+
+## Pomodoro View
+
+The Pomodoro View provides a focused interface for time-boxed work sessions using the pomodoro technique.
+
+### Timer Interface
+
+**Current Session Display**: Shows the active task being worked on and remaining time in the current session.
+
+**Timer Controls**: 
+- Start/stop buttons for beginning and pausing sessions
+- Reset button to restart the current session
+- Skip button to move to break periods early
+
+**Session Type Indicator**: Displays whether you're in a work session, short break, or long break period.
+
+**Progress Visualization**: Circular or linear progress bar showing session completion.
+
+### Task Integration
+
+**Task Selection**: Choose which task to work on during the pomodoro session from:
+- Recently accessed tasks
+- High-priority tasks
+- Tasks scheduled for today
+- Search and filter from all tasks
+
+**Automatic Time Tracking**: When a pomodoro session is completed, the time is automatically recorded in the task's time tracking data.
+
+**Task Switching**: Switch between tasks during breaks or between sessions without losing timer state.
+
+### Session Configuration
+
+**Work Duration**: Set the length of work sessions (traditionally 25 minutes, but configurable).
+
+**Break Durations**: Configure short break (typically 5 minutes) and long break (typically 15-30 minutes) periods.
+
+**Session Cycles**: Set how many work sessions before a long break (traditionally 4 sessions).
+
+**Auto-Start Options**: 
+- Automatically start breaks after work sessions
+- Automatically start work sessions after breaks
+- Require manual confirmation for each transition
+
+### Notifications and Alerts
+
+**Session Completion**: Audio and/or visual notifications when sessions complete.
+
+**Break Reminders**: Notifications when break periods end and it's time to return to work.
+
+**Custom Sounds**: Configure different notification sounds for work completion, break start, and session transitions.
+
+**Do Not Disturb**: Option to suppress notifications during active work sessions.
+
+## Pomodoro Stats View
+
+The Stats View provides detailed analytics and historical data about your pomodoro sessions and productivity patterns.
+
+### Session History
+
+**Daily Sessions**: View completed sessions for any given day, including:
+- Tasks worked on
+- Session durations
+- Break times taken
+- Completion rates
+
+**Weekly/Monthly Views**: Aggregate data showing patterns over longer time periods.
+
+**Session Details**: Detailed breakdown of individual sessions including start times, interruptions, and actual work time.
+
+### Productivity Metrics
+
+**Completion Rates**: Percentage of started sessions that were completed without interruption.
+
+**Total Time Tracking**: Cumulative time spent in work sessions, with breakdown by:
+- Tasks
+- Projects (via tags or contexts)
+- Time periods (daily, weekly, monthly)
+
+**Average Session Length**: Track whether you're maintaining consistent session durations.
+
+**Break Adherence**: Statistics on how often you take recommended breaks.
+
+### Visual Analytics
+
+**Calendar Heatmap**: Visual representation of productive days with color-coded intensity based on completed sessions.
+
+**Time Distribution Charts**: Graphs showing when during the day you're most productive.
+
+**Task Completion Correlation**: Analysis of which tasks or task types benefit most from pomodoro sessions.
+
+**Streak Tracking**: Monitor consecutive days with completed pomodoro sessions.
+
+### Goal Setting and Progress
+
+**Daily Targets**: Set goals for number of pomodoro sessions per day.
+
+**Project Targets**: Set time-based goals for specific tasks or projects.
+
+**Progress Indicators**: Visual feedback on goal achievement and consistency.
+
+**Achievement Badges**: Milestone rewards for reaching productivity targets.
+
+## Data Storage and Privacy
+
+**Local Storage**: All pomodoro data is stored locally in your Obsidian vault.
+
+**Integration Options**: Choose between:
+- Plugin data files for centralized storage
+- Daily note frontmatter for distributed storage
+- Both options for redundancy
+
+**Export Capabilities**: Export session data for external analysis or backup.
+
+## Workflow Integration
+
+**Task Time Estimates**: Compare actual pomodoro session time with initial task estimates to improve future planning.
+
+**Calendar Integration**: Completed sessions can appear as time blocks in calendar views.
+
+**Status Updates**: Option to automatically update task status when pomodoro sessions are completed.
+
+**Note Integration**: Add session notes or reflections directly to task notes after completing pomodoros.
+
+## Customization Options
+
+**Theme Integration**: Pomodoro views respect Obsidian's theme settings and can be customized with CSS.
+
+**Layout Options**: 
+- Compact view for small panes
+- Detailed view with full statistics
+- Minimal view focusing only on timer
+
+**Sound Customization**: Upload custom notification sounds or disable audio alerts entirely.
+
+**Keyboard Shortcuts**: Assign hotkeys for common actions like start/stop, skip, and task switching.
+
+## Benefits for Focus and Productivity
+
+The integrated pomodoro system helps with:
+
+**Time Awareness**: Understanding how long tasks actually take versus estimates.
+
+**Distraction Management**: Built-in break periods prevent mental fatigue and maintain focus quality.
+
+**Progress Visualization**: Seeing completed sessions provides motivation and sense of accomplishment.
+
+**Data-Driven Planning**: Historical data helps improve time estimation and task planning.
+
+**Habit Building**: Consistent use builds sustainable work habits and productivity routines.

docs/views/task-view.md

@@ -0,0 +1,108 @@
+# Task List View
+
+The Task List View provides a list-based interface for viewing and managing your tasks. It displays tasks as cards in a scrollable list with filtering and organization options.
+
+## Interface Layout
+
+The Task View consists of three main areas:
+
+**Filter Bar**: Located at the top, contains search input, filter dropdowns, and view controls. This bar can be collapsed to save space.
+
+**Task List**: The main content area showing tasks as cards. Each card displays task information in a structured format.
+
+**Status Bar**: Shows the total number of tasks and how many match current filters.
+
+## Task Display
+
+Each task row shows:
+
+- **Title**: The task name, which links to the task note when clicked
+- **Status**: Current task status (configurable icons and colors)
+- **Priority**: Priority level (configurable icons and colors)  
+- **Due Date**: When the task is due (if set)
+- **Scheduled Date**: When the task is scheduled for work (if set)
+- **Contexts**: Associated contexts (displayed as tags)
+- **Tags**: Obsidian tags associated with the task
+- **Time Estimate**: Estimated time to complete (if set)
+
+## Filtering Options
+
+The filter bar provides several ways to narrow down the displayed tasks:
+
+**Text Search**: Search across task titles and note content. Search is case-insensitive and supports partial matches.
+
+**Status Filter**: Show only tasks with specific statuses. Multiple statuses can be selected simultaneously.
+
+**Priority Filter**: Filter by priority levels. Supports selecting multiple priorities.
+
+**Context Filter**: Show tasks associated with specific contexts. Context suggestions appear as you type.
+
+**Tag Filter**: Filter by Obsidian tags. Tag suggestions appear based on tags in your vault.
+
+**Date Filters**: 
+- Show tasks due within specific time ranges (today, this week, this month, overdue)
+- Show tasks scheduled for specific periods
+- Custom date range selection
+
+**Completion Filter**: Toggle between showing completed tasks, incomplete tasks, or both.
+
+## Sorting and Grouping
+
+**Sorting**: Click column headers to sort by that field. Click again to reverse the sort order. Available sort fields include:
+- Title (alphabetical)
+- Status (by configured status order)
+- Priority (by configured priority weight)
+- Due date (chronological)
+- Scheduled date (chronological)
+- Creation date (chronological)
+- Modification date (chronological)
+
+**Grouping**: Group tasks by common properties to organize related items:
+- Group by status to see task progression
+- Group by priority to focus on important items
+- Group by context to see location or tool-specific tasks
+- Group by due date to organize by deadlines
+- Group by tags for project or category organization
+
+## Task Actions
+
+**Direct Editing**: 
+- Click task titles to open the full task note
+- Click status or priority indicators to cycle through options
+- Some fields support inline editing when clicked
+
+**Context Menus**: Right-click any task for additional actions:
+- Open in new tab or split pane
+- Mark as complete/incomplete
+- Edit task properties
+- Delete task
+- Copy task link
+
+**Quick Actions**: Tasks can be managed individually through context menus and direct interaction with task elements.
+
+## View Customization
+
+**Display Options**: Adjust how tasks are presented in the list format.
+
+**Card Density**: Tasks can be displayed with varying amounts of detail based on available space.
+
+**Color Coding**: Tasks are colored based on:
+- Priority levels (configurable colors)
+- Due dates (overdue tasks highlighted)
+- Status types (completed, in-progress, etc.)
+
+## Performance Considerations
+
+The Task View is optimized for large numbers of tasks:
+
+- **Virtual Scrolling**: Only visible rows are rendered, maintaining performance with thousands of tasks
+- **Efficient Filtering**: Filters use indexed data for fast response
+- **Incremental Updates**: Only changed tasks are re-rendered when data updates
+
+## Integration Features
+
+**Task Creation**: Create new tasks directly from the view using the "Add Task" button. New tasks inherit current filter settings where applicable.
+
+**Note Integration**: Tasks created from other notes (using inline conversion) appear in the Task View immediately.
+
+**External Updates**: Changes made to task files outside TaskNotes are reflected in the view automatically through Obsidian's metadata cache.

mkdocs.yml

@@ -0,0 +1,72 @@
+site_name: TaskNotes Documentation
+site_url: https://callumalpass.github.io/tasknotes/
+site_description: Comprehensive task and note management with calendar integration for Obsidian
+site_author: Callum Alpass
+repo_name: callumalpass/tasknotes
+repo_url: https://github.com/callumalpass/tasknotes
+
+theme:
+  name: material
+  palette:
+    - scheme: default
+      primary: deep purple
+      accent: purple
+      toggle:
+        icon: material/brightness-7
+        name: Switch to dark mode
+    - scheme: slate
+      primary: deep purple
+      accent: purple
+      toggle:
+        icon: material/brightness-4
+        name: Switch to light mode
+  font:
+    text: Roboto
+    code: Roboto Mono
+  features:
+    - navigation.tabs
+    - navigation.sections
+    - navigation.expand
+    - navigation.path
+    - navigation.top
+    - search.highlight
+    - search.share
+    - content.code.copy
+
+nav:
+  - Home: index.md
+  - Core Concepts: core-concepts.md
+  - Views:
+    - Overview: views.md
+    - Task List View: views/task-view.md
+    - Notes View: views/notes-view.md
+    - Agenda View: views/agenda-view.md
+    - Kanban View: views/kanban-view.md
+    - Calendar Views: views/calendar-views.md
+    - Pomodoro View: views/pomodoro-view.md
+  - Features:
+    - Overview: features.md
+    - Task Management: features/task-management.md
+    - Inline Task Integration: features/inline-tasks.md
+    - Time Tracking: features/time-tracking.md
+    - Natural Language Processing: features/natural-language.md
+    - Calendar Integration: features/calendar-integration.md
+  - Creating and Editing Tasks: creating-editing-tasks.md
+  - Settings:
+    - Overview: settings.md
+    - Task Defaults: settings/task-defaults.md
+    - Inline Task Settings: settings/inline-task-settings.md
+    - Calendar Settings: settings/calendar-settings.md
+    - Advanced Settings: settings/advanced-settings.md
+  - Concepts and Rationale: concepts-rationale.md
+  - Troubleshooting: troubleshooting.md
+
+markdown_extensions:
+  - admonition
+  - codehilite
+  - toc:
+      permalink: true
+  - attr_list
+
+extra_css:
+  - stylesheets/extra.css