A personal task management system with a beautiful terminal UI, SQLite storage, and background task execution via pluggable AI agents (Claude Code or OpenAI Codex CLI).

The main view showing tasks organized across Backlog, In Progress, Blocked, and Done columns

Viewing a task with Claude's output and shell access in split panes

Live execution log showing task progress, worktree creation, and Claude's actions

Creating a new task with project selection, type, scheduling, and attachments

• Kanban Board - Visual task management with 4 columns (Backlog, In Progress, Blocked, Done)
• Git Worktrees - Each task runs in an isolated worktree, no conflicts between parallel tasks
• Pluggable Executors - Choose between Claude Code or OpenAI Codex CLI per task
• Ghost Text Autocomplete - LLM-powered suggestions for task titles and descriptions as you type
• VS Code-style Fuzzy Search - Quick task navigation with smart matching (e.g., "dsno" matches "diseno website")
• Markdown Rendering - Task descriptions render with proper formatting in the detail view
• Project Memories - Persistent context that carries across tasks
• Real-time Updates - Watch tasks execute live
• Auto-cleanup - Automatic cleanup of Claude processes and config entries for completed tasks
• SSH Access - Connect from anywhere via ssh -p 2222 server

• Go 1.24.4+ - Required to build the project

If you use mise for dependency management, simply run:

mise install

This will install the correct Go version automatically.

Install Go 1.24.4 or later from go.dev/dl.

git clone https://github.com/bborn/workflow
cd workflow
make build

# Launch the TUI (auto-starts background daemon)
./bin/task -l

# Start the SSH server + executor
./bin/taskd -addr :2222

# Connect from anywhere
ssh -p 2222 your-server

./bin/task daemon         # Start daemon manually
./bin/task daemon stop    # Stop the daemon
./bin/task daemon status  # Check daemon status

./bin/task purge-claude-config            # Remove stale ~/.claude.json entries
./bin/task purge-claude-config --dry-run  # Preview what would be removed
./bin/task claudes cleanup                # Kill orphaned Claude processes

Auto-cleanup: The daemon automatically cleans up Claude processes for tasks that have been done for more than 30 minutes, preventing memory bloat from orphaned processes.

backlog → queued → processing → done
                 ↘ blocked (needs input)

Task You supports multiple AI executors for processing tasks. You can choose the executor when creating or editing a task.

Both executors run in tmux windows with the same worktree isolation and environment variables. The main differences:

• Claude Code supports session resumption - when you retry a task, Claude continues with full conversation history
• Codex starts fresh on each execution but receives the full prompt with any feedback

At least one executor CLI must be installed for tasks to run:

# Claude Code (recommended)
# See https://claude.ai/claude-code for installation

# OpenAI Codex CLI
npm install -g @openai/codex

Manage settings with task settings:

task settings                              # View all settings
task settings set <key> <value>            # Set a value

LLM-powered suggestions appear as you type task titles and descriptions, similar to GitHub Copilot:

• Title suggestions - Autocomplete as you type the task title
• Body suggestions - Auto-suggest a description when you tab from the title to an empty body field
• Cursor-aware - Ghost text renders at cursor position for natural editing
• Smart caching - Recent completions are cached for instant responses

Setup:

task settings set anthropic_api_key sk-ant-your-key-here

Controls:

• Tab - Accept suggestion
• Escape - Dismiss suggestion
• Ctrl+Space - Manually trigger suggestion

Get an API key at console.anthropic.com. This is optional and uses your API credits.

You can configure per-project settings by creating a .taskyou.yml file in your project root:

worktree:
  init_script: bin/worktree-setup

Supported filenames (in order of precedence):

• .taskyou.yml
• .taskyou.yaml
• taskyou.yml
• taskyou.yaml

Configuration options:

Configure projects in Settings (s):

• Name - Project identifier (e.g., myproject)
• Path - Local filesystem path to git repo
• Aliases - Short names for quick reference
• Instructions - Project-specific AI instructions

Tasks run in isolated git worktrees at ~/.local/share/task/worktrees/{project}/task-{id}. This allows multiple tasks to run in parallel without conflicts. Press o to open a task's worktree.

You can configure a script to run automatically after each worktree is created. This is useful for:

• Installing dependencies
• Setting up databases
• Copying configuration files
• Running migrations

Two ways to configure:

1. Conventional location - Create an executable script at bin/worktree-setup:

#!/bin/bash
# Example: bin/worktree-setup
bundle install
cp config/database.yml.example config/database.yml

2. Custom location - Specify in .taskyou.yml:

worktree:
  init_script: scripts/my-setup.sh

The script runs in the worktree directory and has access to all worktree environment variables (WORKTREE_TASK_ID, WORKTREE_PORT, WORKTREE_PATH).

Each task provides environment variables that applications can use to run in isolation:

These variables allow multiple tasks to run simultaneously without conflicts on ports or databases.

Configure your Rails app to use worktree variables for complete isolation:

config/puma.rb:

port ENV.fetch("WORKTREE_PORT", 3000)

config/database.yml:

development:
  database: myapp_dev<%= ENV['WORKTREE_TASK_ID'] ? "_task#{ENV['WORKTREE_TASK_ID']}" : "" %>

Procfile.dev:

web: bin/rails server -p ${WORKTREE_PORT:-3000}

bin/worktree-setup:

#!/bin/bash
set -e

# Install dependencies
bundle install

# Create isolated database for this task
bin/rails db:create db:migrate

Now the AI executor (Claude or Codex) can:

• Run your app with bin/dev
• Access it at http://localhost:$WORKTREE_PORT
• Work on multiple tasks in parallel without database or port conflicts

package.json:

{
  "scripts": {
    "dev": "next dev -p ${WORKTREE_PORT:-3000}"
  }
}

bin/worktree-setup:

#!/bin/bash
npm install
cp .env.example .env.local

Project memories provide persistent context for the AI. Press m to manage.

Categories:

• pattern - Code patterns and conventions
• context - Project-specific context
• decision - Architectural decisions
• gotcha - Known pitfalls and workarounds

make build        # Build binaries
make test         # Run tests
make install      # Install to ~/go/bin

• Bubble Tea - TUI framework
• Lip Gloss - Terminal styling
• Wish - SSH server
• SQLite - Local database