claude-home/productivity/CONTEXT.md

title	description	type	domain	tags
Productivity Tools Context	Overview of ADHD-optimized productivity tools including task manager, Google Workspace CLI, and Handy speech-to-text. Covers architecture patterns, CLI commands, and brain dump workflows.	context	productivity	task-manager adhd brain-dump google-workspace handy speech-to-text cli

Productivity Tools - Technology Context

Overview

ADHD-optimized task management system designed to break the context-switching spiral. The system uses a persistent terminal dashboard with zero-friction brain dump capture to help maintain focus while capturing interrupting thoughts.

Google Workspace CLI (gws)

Unified CLI for Drive, Gmail, Calendar, Sheets, and all Google Workspace APIs. Dynamically discovers API endpoints at runtime.

• Binary: /usr/local/bin/gws | Version: 0.11.1
• gcloud SDK: /opt/google-cloud-sdk/
• Docs: google-workspace-cli.md

Handy - Speech to Text

Desktop speech-to-text app with system tray integration. Installed via RPM from GitHub.

• Binary: /usr/bin/handy | Version: 0.7.6
• Docs: handy-speech-to-text.md

Architecture Patterns

Single-Focus with Brain Dump Pattern

Pattern: One visible task at a time with instant thought capture

• Current Focus: Single task display with time tracking
• Brain Dump: Zero-friction capture without context switching
• Auto-Progression: System-managed task transitions
• Priority Queue: Automatic high→medium→low ordering

When to Use:

• ADHD workflow challenges
• Frequent context switching problems
• "Meant to do" task accumulation
• Need for always-visible task tracking
• Terminal-based work environments

Design Principles

1. Minimal Friction: Two-second task capture without switching
2. Always Visible: Persistent terminal dashboard prevents forgetting
3. Single Focus: One task display reduces overwhelm
4. Auto-Progression: System picks next task, reducing decision fatigue
5. Time Awareness: Duration tracking without judgment

Core Components

Task Manager Core

Purpose: Central task management with priority queuing and state management Location: ~/.claude/tools/task-manager/task_manager.py

Key Features:

• Priority-based task ordering (High/Medium/Low)
• Task states: brain_dump, current, completed, snoozed
• Auto-progression on task completion
• Snooze functionality with time-based wake-up
• JSON-based persistence

Data Model:

class Task:
    id: str                      # Timestamp-based unique ID
    description: str             # Task description
    priority: str                # high, medium, low
    status: str                  # brain_dump, current, completed, snoozed
    created_at: str             # ISO timestamp
    started_at: Optional[str]   # When task became current
    completed_at: Optional[str] # Completion timestamp
    snoozed_until: Optional[str] # Wake-up time for snoozed tasks

Terminal Dashboard

Purpose: Persistent visual display of current focus and brain dump queue Location: ~/.claude/tools/task-manager/dashboard.py

Display Components:

• Current focus with elapsed time
• Brain dump queue (up to 8 tasks visible)
• Completion statistics
• Command reference

Update Behavior:

• Auto-refreshes every 1 second
• Reads from JSON file (detects CLI changes)
• Uses rich library for clean TUI rendering

CLI Interface

Purpose: Zero-friction command-line task operations Location: ~/.claude/tools/task-manager/cli.py

Core Commands:

• task dump "description" - Brain dump capture (most important!)
• task done - Complete current, auto-load next
• task next - Skip to next task
• task snooze [hours] - Snooze current task
• task add "description" --now - Add and make current
• task - Show current status

Priority Flags:

• --high - High priority (🔴)
• --medium - Medium priority (🟡) [default]
• --low - Low priority (🟢)

Implementation Patterns

The Context-Switch Spiral Solution

Problem Pattern:

Working on Task A → Remember Task B → Switch to Task B →
Remember Task C → Task A forgotten → Task B becomes "meant to do" → Loop

Solution Pattern:

Working on Task A → Remember Task B → `task dump "Task B"` →
Continue Task A → Complete with `task done` → System auto-loads Task B

Brain Dump Workflow

1. Capture: task dump "thought" (2 seconds, no context switch)
2. Visible: Task appears in brain dump queue on dashboard
3. Continue: Keep working on current focus
4. Auto-Load: Task surfaces when current task completes

Priority Management

Automatic Ordering:

1. High priority tasks (🔴) surface first
2. Medium priority tasks (🟡) second
3. Low priority tasks (🟢) last
4. Within priority level, oldest tasks first

Use Cases:

• --high: Urgent, time-sensitive, or blocking tasks
• --medium: Normal daily work (default)
• --low: "Nice to have", research, exploration

Time Tracking Pattern

Purpose: Awareness without judgment

• Shows elapsed time on current task
• No alerts or pressure
• Helps identify time sinks naturally
• User decides when to move on

Common Workflows

Morning Startup

# Brain dump everything you need to do
task dump "Review PRs" --high
task dump "Update documentation"
task dump "Research new library" --low

# Load first task (highest priority)
task next

# Start dashboard in persistent pane
task-dashboard

During Work Day

# Working on current task... suddenly remember something
task dump "email Staci about dinner"

# Thought is captured, visible in brain dump, keep working

# Finish current task
task done
# → Auto-loads next task from queue

Handling Interruptions

# Urgent task comes up
task add "Fix production bug" --now --high
# → Immediately becomes current focus
# → Previous task moved back to brain dump

# Can't work on current task right now
task snooze 2
# → Snoozed for 2 hours
# → Next task auto-loaded

End of Day

# Check what's left
task

# Everything in brain dump waits for tomorrow
# Completed tasks tracked in stats

Best Practices

Dashboard Setup

Persistent Pane Strategy:

• Use tmux/screen split pane for dashboard
• Keep visible on secondary monitor
• Always-visible = can't forget to check
• Alternative: Dedicated terminal window

Terminal Multiplexer Example (tmux):

# Split terminal horizontally
tmux split-window -h

# Run dashboard in right pane
task-dashboard

# Work in left pane

Brain Dump Discipline

Key Principles:

• Capture thoughts immediately when they appear
• Don't evaluate or organize - just dump
• Trust the system to surface them later
• Priority can be added later if wrong

Anti-Patterns to Avoid:

• Stopping work to add detailed task information
• Trying to organize tasks while capturing
• Skipping capture because task seems "small"
• Context switching to "quickly do" the task

Priority Usage

High Priority - Use sparingly:

• Urgent deadlines (today/this week)
• Blocking other people's work
• Production issues
• Time-sensitive opportunities

Medium Priority - Default for most work:

• Regular daily tasks
• Normal project work
• Scheduled activities

Low Priority - Background/optional:

• Research and exploration
• "Someday/maybe" items
• Nice-to-have improvements

System Maintenance

Daily:

• Complete tasks as you work
• Brain dump new thoughts immediately
• Trust auto-progression

Weekly:

• Review low-priority items
• Clean up stale tasks
• Adjust priorities if needed

Integration Patterns

PATH Integration

Location: ~/.bashrc

export PATH="$HOME/.claude/tools/task-manager:$PATH"

Benefits:

• task and task-dashboard available globally
• No full paths needed
• Muscle memory development

Data Storage

Location: ~/.claude/tools/task-manager/tasks.json Format: JSON with task array and metadata

Backup Strategy:

• File-based storage enables easy backup
• Can sync via Dropbox/Google Drive if desired
• Simple JSON enables scripting/reporting

Future Integration Points

Planned Enhancements:

• Notion MCP sync (Cal has integration available)
• Discord notifications on task completion
• Scheduled Jarvis check-ins (periodic reminders)
• Voice capture integration
• Pomodoro timer integration
• Analytics and reporting

Technical Details

File Structure

~/.claude/tools/task-manager/
├── task_manager.py      # Core task management logic
├── dashboard.py         # TUI dashboard (persistent display)
├── cli.py              # Command-line interface
├── task                # Shell wrapper for CLI
├── task-dashboard      # Shell wrapper for dashboard
├── tasks.json          # Data storage (auto-created)
└── README.md           # User documentation

Dependencies

• Python 3.7+
• rich library for TUI rendering
• No other external dependencies

Installation

Already Installed - Cal's system:

• Scripts: ~/.claude/tools/task-manager/
• PATH: Added to ~/.bashrc
• Data: ~/.claude/tools/task-manager/tasks.json

ADHD-Specific Optimizations

Why Traditional Systems Fail

1. Hidden in apps - Out of sight, out of mind
2. Too much organization - Analysis paralysis
3. Too many features - Overwhelm and abandonment
4. No immediate feedback - Delayed dopamine
5. Context switching required - Defeats purpose

How This System Addresses ADHD

1. Always visible - Persistent terminal display
2. Minimal organization - Just dump and go
3. Minimal features - Only what's needed
4. Immediate feedback - Instant completion confirmation
5. Zero context switch - Capture without abandoning work

The Psychology

Reduced Anxiety: Thoughts are captured and visible Maintained Focus: No need to switch away from current work Reduced Overwhelm: Single focus display, not full list Dopamine Feedback: Immediate confirmation on completion Decision Reduction: System picks next task automatically

This productivity system is optimized specifically for ADHD workflows and terminal-based work environments, providing the minimal viable structure needed to maintain focus while capturing interrupting thoughts.