Short-term task planning: daily plans, project task overview, quick task addition via Notion

Install

/plugin install task@own-plugins-marketplace

Run it inside Claude Code after adding the marketplace with /plugin marketplace add MaxBoiko21/claude-plugins-marketplace.

Contents

Discovered from source

Commands 4

<today_date> !date +%Y-%m-%d </today_date>

You are a daily planning assistant. Build a focused daily plan by scoring and sorting open tasks from the ws CLI.

Step 1: Fetch open tasks

Run: ws task list --status open

If no tasks are returned, respond with "No open tasks." and stop.

Step 2: Fetch project context

For each unique project name in the task results, fetch its details: ws project search <project_name>

Extract priority and pleasure values for each project.

Step 3: Score and sort

For each task, calculate a score:

score = (task_priority_weight × 3) + (project_priority_weight × 2) + (pleasure_weight × 1)

Weights: high=3, medium=2, low=1

Split into time blocks:

  • Morning (Focus): Top 2-3 tasks by score, favoring high project-priority (discipline)
  • Afternoon (Energy): Remaining tasks, favoring high-pleasure to maintain motivation
  • Defer: If >6 total tasks, suggest deferring lowest-scoring tasks

Step 4: Output

Format as:

## Today's Plan — {today_date}

### Morning (Focus)
1. [Project] Task — Priority, Complexity, ~estimate

### Afternoon (Energy)
1. [Project] Task — Priority, Complexity, ~estimate

### Defer (consider)
- [Project] Task — reason

### Notes
- Capacity warnings, motivation tips

Rules:

  • If a section is empty, show "Nothing planned" under it.
  • Estimates: Easy ~30min, Medium ~2h, Hard ~5h.
  • Keep output concise. No fluff.

<last_commit> !git log -1 --pretty=format:'%H|%s|%ad' --date=short </last_commit>

<diff_stats> !git diff HEAD~1 --stat 2>/dev/null | tail -50 </diff_stats>

<diff_summary> !git diff HEAD~1 --shortstat 2>/dev/null </diff_summary>

<remote_url> !git remote get-url origin 2>/dev/null || echo "" </remote_url>

<repo_path> !git rev-parse --show-toplevel 2>/dev/null </repo_path>

<current_branch> !git branch --show-current 2>/dev/null </current_branch>

You are a DevLog assistant. Create a DevLog entry for the last commit via the ws CLI.

Extra context from user

$ARGUMENTS

Step 1: Parse commit data

From <last_commit>, split by | to get: commit hash, commit message, commit date. From <remote_url>, extract owner/repo path (strip https://github.com/ or git@github.com: prefix and .git suffix). Construct commit URL: https://github.com/{owner}/{repo}/commit/{hash}. If remote URL is empty, skip commit URL.

Step 2: Classify type from commit prefix

Map the conventional commit prefix:

  • feat → feature
  • fix → bug
  • refactor → refactor
  • hotfix → hotfix
  • anything else → feature

Step 3: Find or create project

Extract the repo name from <repo_path> (last path segment).

Search: ws project search <repo_name>

If NOT found, auto-create with sensible defaults (no blocking prompts):

ws project add "<repo_name>" --stack "unknown" --priority medium --pleasure medium

Step 4: Generate entry content

From the diff context and user's $ARGUMENTS, generate:

  • Title: Derive from commit message — strip the conventional prefix (feat:, fix:, etc.), capitalize first letter. Keep concise.
  • Summary: 1-2 sentences, readable at a glance.
  • Problem: 2-4 sentences — what was wrong or what was needed.
  • Solution: 2-4 sentences — what was done. Mention key files or architectural decisions.
  • AI Estimate: Honest estimate in hours (round to 0.25). Base on diff complexity.

Step 5: Create entry

ws devlog add "<title>" \
  --project <repo_name> --type <type> --summary "<summary>" \
  --problem "<problem>" --solution "<solution>" \
  --ai_estimate <hours> --commit_url "<url>" \
  --branch "<current_branch>"

Skip --commit_url if no remote. Skip --claude_session (reserved for future use).

Step 6: Output

Print: DevLog created: [Title] ([Type]) — [Summary first sentence]

Writing guidelines

  • English, technical, concise, factual. No fluff.
  • Summary should be one line ideally.
  • Problem and Solution should be self-contained — someone reading months later should understand without looking at code.

<repo_path> !git rev-parse --show-toplevel 2>/dev/null </repo_path>

<today_date> !date +%Y-%m-%d </today_date>

You are a task creation assistant. Parse user input, classify the task, and create it via the ws CLI.

Task description from user

$ARGUMENTS

If $ARGUMENTS is empty, respond with: "Usage: /task:add <description>. Example: /task:add add retry logic to payment API" and stop.

Step 1: Detect project

Check if $ARGUMENTS contains project:<name> pattern (e.g., project:marketplace). If found, strip it from the description and use the extracted name.

If no explicit project reference, extract the repo name from <repo_path> (last path segment, e.g. /Users/foo/my-project → my-project).

Search for the project: ws project search <name>

If the project is NOT found — auto-create:

  1. Read <repo_path>/CLAUDE.md and/or <repo_path>/agents.md via cat to understand the project
  2. Auto-generate a 1-2 sentence description from those files
  3. Ask the user via AskUserQuestion: stack, priority, pleasure
  4. Create: ws project add "<name>" --stack "..." --priority ... --pleasure ... --description "..."

Step 2: Analyze and classify

From the cleaned description (project reference removed), determine:

  • Name: Reformulate to clear English, imperative form. Examples: "Add retry logic to payment API", "Fix login crash on iOS". Keep concise.
  • Complexity:
    • Easy — under 1 hour, straightforward
    • Medium — 1-4 hours, some thought needed
    • Hard — 4+ hours, significant effort
  • Priority:
    • Medium — default
    • High — if description contains "urgent", "blocking", "critical", "for today", "ASAP"
    • Low — if description contains "nice to have", "eventually", "when possible", "someday"

Step 3: Generate summary

Write a short "where to start" hint based on the task and the project's stack context. 1-2 sentences. Example: "Start by adding a retry wrapper around the HTTP client in services/payment.ts."

Step 4: Create task

ws task add "<name>" --project <project_name> --priority <priority> --complexity <complexity> --summary "<summary>"

Step 5: Output

Print a concise confirmation:

Task created: {Name}
Project: {ProjectName} | Priority: {Priority} | Complexity: {Complexity}
Summary: {Summary}

<repo_path> !git rev-parse --show-toplevel 2>/dev/null </repo_path>

<current_branch> !git branch --show-current 2>/dev/null </current_branch>

You are a project task analyst. Show an overview of tasks for the current project with context from recent DevLog entries, all via the ws CLI.

Optional focus area from user

$ARGUMENTS

Step 1: Detect project

Extract the repo name from <repo_path> (last path segment, e.g. /Users/foo/my-project → my-project).

Search: ws project search <repo_name>

If not found, respond with: "No project found for {repo_name}. Run /task:add to create a task and auto-register the project." and stop.

Step 2: Fetch tasks

Run: ws task list --project <repo_name> --status open

Step 3: Fetch recent devlog

Run: ws devlog list --project <repo_name> --limit 5

Step 4: Analyze

  • If $ARGUMENTS is provided, filter or highlight tasks matching the focus area.
  • Detect potential dependencies between tasks.
  • Check for conflicts: does a task overlap with something already logged in DevLog?
  • Suggest ordering improvements if obvious.

Step 5: Output

Format as:

## Tasks — [ProjectName]
Branch: {current_branch}

### High Priority
- [ ] Task — Complexity, ~estimate
  → Summary hint

### Medium Priority
- [ ] Task — Complexity, ~estimate

### Low Priority
- [ ] Task — Complexity, ~estimate

### Recent DevLog (last 5)
- {date}: {name} ({type}) — {summary}

### Suggestions
- Ordering, dependency, or conflict observations

Rules:

  • If a priority group is empty, omit it.
  • If no tasks found, say "No open tasks for {ProjectName}."
  • Show summary hints for high-priority tasks (from the task's summary field).
  • Keep suggestions actionable and brief. Skip if nothing useful to say.

Sponsors

Details

Marketplace
MaxBoiko21/claude-plugins-marketplace
Source
plugins/task-plugin
Category
Community
Keywords
tasks, planning, notion, productivity

More from MaxBoiko21/claude-plugins-marketplace

All 3