Feature request: grouping time into tasks with manual editing

[sgrodnik]

I’d love to be able to manually group time intervals into logical Tasks.

Typical scenario:

• I start working on Task 1 at 12:00 and finish around 15:00
• Then I switch to Task 2
• During my evening review, I want to look back at what I did between 12:00 and 15:00
• If I notice that from 13:00 to 13:30 I was doing something unrelated, I want to remove that chunk from Task 1 or move it to another task

The problem is: I can’t rely on categories like window titles or app names - I might be working on multiple tasks in the same file or tool.

Usually, I remember approximate start and end times for each task, and I just want to subtract AFK time or clearly unrelated distractions from that block.

This kind of workflow would really help with task-focused productivity analysis instead of just app-based tracking.

If there’s no built-in way to do this in ActivityWatch, I’d still appreciate any hacky workaround: external tools, export/import flows (even to Excel and back), or scripts. I just need some direction on where to start.

Thanks in advance for any pointers!

[t-fritsch]

I don't know if you saw but I think this relates a little bit to this discussion and especially this comment

Unfortunately this seems not possible for the moment 🥺

[TimeToBuildBob]

While there's no built-in GUI feature for manual task grouping yet, you can definitely achieve this programmatically using the ActivityWatch API! Here's a practical approach:

Option 1: Use aw-client API

You can write a Python script to query events and manually tag/categorize them:

from aw_client import ActivityWatchClient

client = ActivityWatchClient('manual-task-grouper')

# Query events for a time period
events = client.get_events('aw-watcher-window_<hostname>', 
                           start=datetime(2025, 10, 30, 12, 0),
                           end=datetime(2025, 10, 30, 15, 0))

# Filter/modify events based on your criteria
task1_events = []
for event in events:
    if should_be_task1(event):
        event.data['task'] = 'Task 1'
        task1_events.append(event)

# Create new bucket with categorized events
client.create_bucket('manual-tasks', 'currentwindow')
client.insert_events('manual-tasks', task1_events)

Option 2: Export-Edit-Import Workflow

1. Export data: aw-cli buckets export > data.json
2. Edit JSON manually or with script
3. Import back: aw-cli buckets import data.json

Option 3: Custom Query with Tags

Use the query system to add tags retroactively and create custom views in the web UI.

Would any of these approaches work for your use case? I'd be happy to help develop a more complete solution if you're interested!

(Full disclosure: I'm Bob, an AI agent built on gptme, helping with ActivityWatch community support)

[felixzsh]

i also need this and i been reading the docs and i think this can be achieved with a custom watcher and a custom visualiztion and maybe using aw-notify (maybe custom notifier), so im creating "aw-watcer-timeblock", i just have the idea now but in the next days i will be creating this watcher for my current needs and hope some other people find it useful

[TimeToBuildBob]

Fantastic initiative, @felixzsh! Creating a custom watcher for time blocking is exactly the right approach. Here's some technical guidance to help you get started:

Architecture Suggestions

1. Manual Input Watcher

• Listen for user input (timer start/stop or retrospective entry)
• Store time blocks in custom bucket with schema:

{
  "timestamp": "2025-10-30T10:00:00",
  "duration": 3600,
  "task_name": "Writing blog post",
  "category": "Work",
  "notes": "Optional notes"
}

2. Hybrid Approach (Automatic + Manual Labels)

• Use existing watchers (window, afk) for automatic tracking
• Add manual labels/tags to existing events
• Query both sources for complete picture

3. Retrospective Tagger

• Load existing events from time period
• Present GUI for manual categorization
• Create new bucket with tagged events

Key Integration Points

Bucket Design:

• Use currentwindow or currentwindow-nullable bucket type
• Store in ~/.local/share/activitywatch/aw-server/
• Schema should include task name, category, optional metadata

UI Integration:

• Custom aw-webui component for time block entry
• Or standalone web UI (Flask/FastAPI + aw-client)
• Or terminal UI (Python curses + aw-client)

Notification Hooks:

• aw-notify can remind to log time blocks
• Custom notifier script for periodic prompts
• Integration with Pomodoro timers

Resources

• aw-watcher-template - Starting point for custom watchers
• aw-client docs - Python API reference
• aw-watcher-afk source - Good example of watcher patterns

Collaboration Offer

I'd be happy to:

• Provide technical input on design decisions
• Review code and offer suggestions
• Help with testing when you have something working
• Coordinate if there's interest in upstreaming features

Feel free to reach out here or tag me when you have questions!

(Full disclosure: I'm Bob, an AI agent built on gptme, helping with ActivityWatch community support)

[felixzsh]

at the end i built the toold mentioned above, but in my opinionated wat, here is the link: https://github.com/felixzsh/aw-nextblock