# Task Organizer Prover MCP

> The Task Organizer Prover validates project plans against five core management axes. It forces you to define task priorities using Eisenhower matrix and ICE scoring, maps dependencies via critical path analysis, and calculates realistic timelines using PERT formulas. It also checks team capacity limits (WIP/productive hours) and ensures every task links directly to a verifiable SMART deliverable.

## Overview
- **Category:** productivity
- **Price:** Free
- **Tags:** task-management, priority, eisenhower-matrix, critical-path, estimation, capacity-planning

## Description

**The Task Organizer Prover** runs a structured reflection tool that checks your whole project plan against five essential management axes: priority, dependencies, estimation, capacity, and measurable outcomes. You just feed it your raw task list, and it tells you exactly where the holes are in your strategy.

When you hit `validate_task_organization`, it first forces you to nail down priorities. It doesn't let you treat everything like it’s top shelf; instead, it makes you rank tasks using the **Eisenhower matrix**, forcing a separation between what’s genuinely important and what just feels urgent. Beyond that, it calculates an **ICE score**—Impact multiplied by Confidence multiplied by Ease—to force your team to define one single, indisputable #1 priority for every phase of work.

Next up, the tool maps out all your project dependencies. It identifies those blocking chains—the things that can't start until something else clears—and determines the **critical path**, which is the longest sequence of dependent tasks you have to complete on time. Finding this path shows you exactly where you can’t afford any delays and points out opportunities for parallel work so you don't wait around doing nothing.

It also calculates realistic timelines, because guessing how long something takes is bullshit. You won’t rely on gut feeling; the tool uses **PERT analysis** (Optimistic / Most Likely / Pessimistic) to generate a statistically weighted time estimate for every major milestone. This gives you a risk-adjusted number that's way more accurate than any 'about three weeks' timeline your boss might throw at you.

Here’s the thing about team capacity: it audits your limits rigorously. It calculates actual productive hours per day, factoring in context switching costs—that mental drag when you jump between different kinds of tasks—and makes sure your team stays within safe **WIP** (Work In Progress) limits, keeping everyone focused on just two or three concurrent tasks at a time so they don't burn out. It prevents the over-commitment garbage that sinks most projects.

Finally, it verifies every single task against SMART standards. You gotta make sure you aren't planning activities like 'Research pricing'; every item must map directly to a concrete, verifiable deliverable with acceptance criteria attached. This guarantees that when the project wraps up, you don’t just have a pile of reports; you've got tangible proof of completion.

## Tools

### validate_task_organization
Runs a structured reflection tool that checks project plans against priority, dependency, estimation, capacity, and outcome standards.

## Prompt Examples

**Prompt:** 
```
Here are 15 tasks for this sprint. All are high priority. They can be done in any order. Each should take about 2-4 hours. The team can handle it. Goal: complete the tasks.
```

**Response:** 
```
PRIORITY_BLIND — Five failures: 'all high priority' = nothing prioritized, 'any order' = no dependencies, 'about 2-4h' = estimation fantasy, 'team can handle' = no capacity math, 'complete the tasks' = activity not outcome.
```

**Prompt:** 
```
Priority: Q1 hotfix (ICE 800, delay $5K/day), Q2 auth refactor (ICE 224), Q3 status page (delegate), Q4 wiki header (eliminate). Dependencies: API→frontend→QA→deploy (18-day critical path). Parallel: docs + API. External: client approval 3-day SLA. Estimation: API PERT 22h, +50% new auth = 33h, historical 1.8× = 59h, +25% buffer = 74h. Capacity: Dev A 24h productive/wk, 18h committed = 6h free. Dev B 22h, 14h = 8h. WIP 2/dev. Outcomes: 'Deliver OAuth2+PKCE Google SSO, login <3s, tests pass, by Sprint 14. Unblocks enterprise sales.'
```

**Response:** 
```
ORGANIZATION_PROVEN — All five axes validated.
```

**Prompt:** 
```
Priority: hotfix Q1, refactor Q2, 3 other tasks Q2. Dependencies: API→frontend→QA mapped. Estimation: 'API should take about 20 hours.' Capacity: 'team has enough bandwidth.' Outcome: 'finish the API work.'
```

**Response:** 
```
ESTIMATION_FANTASY — Priority and dependency pass. Estimation FAILS: 'should take about 20h' without three-point, PERT, or historical calibration. Capacity: 'enough bandwidth' without productive hours math. Outcome: 'finish the API work' is activity not deliverable.
```

## Capabilities

### Validate Task Priority
The tool ranks tasks using the Eisenhower matrix (urgent vs important) and calculates an ICE score (Impact × Confidence × Ease) to force a single #1 priority.

### Map Project Dependencies
It identifies blocking chains, determines the critical path (the longest sequence of tasks), and finds opportunities for parallel work.

### Calculate Risk-Adjusted Estimates
The tool uses PERT analysis (Optimistic/Most Likely/Pessimistic) to generate a statistically weighted time estimate, far more accurate than gut feeling.

### Audit Team Capacity Limits
It calculates productive hours per day, factoring in context switching costs and ensuring the team stays within safe WIP limits (2-3 tasks).

### Verify SMART Deliverables
The tool ensures every task is defined as a verifiable outcome—a concrete deliverable with acceptance criteria, not just an activity.

## Use Cases

### The 'Everything Is High Priority' Trap
A team hands over a list of 12 improvement projects, all labeled 'Priority 1.' Instead of getting paralyzed by choice, running the plan through `validate_task_organization` forces ICE scoring. The output immediately tells them to focus on the top three—the ones with high Impact and Confidence—and queue the rest.

### The Late Foundation Pour
A construction project plan lists framing, plumbing, and painting as separate tasks. The planner misses that foundation curing takes 28 days. Running this through `validate_task_organization` detects the critical path gap: if the foundation pours late, everything downstream shifts by at least 28+ days.

### The Overcommitted Team
A manager schedules eight hours of work for a worker. The team is blindsided when tasks pile up daily. Using `validate_task_organization` reveals the gap between 8 scheduled hours and the actual 4-5 productive hours available, forcing the manager to cut scope or add headcount.

### Vague Scope Creep
A client requests a 'better status page.' Instead of accepting vague requirements, `validate_task_organization` demands SMART criteria: What specific metric does it track? Who signs off? By what date will the 1-page matrix be delivered?

## Benefits

- Stop guessing timelines. Using the PERT formula, you get risk-adjusted estimates (e.g., 8.83 weeks) instead of 'about two weeks,' preventing massive timeline overruns.
- Identify true bottlenecks. The tool finds the critical path—the single longest sequence of tasks—so your team focuses only on what determines the final delivery date.
- Prevent burnout and missed deadlines. By calculating productive hours and enforcing WIP limits, you know if your team can actually hit the target utilization (70-80%).
- Force clear goals. Instead of listing activities like 'Write report,' you define SMART deliverables that have concrete acceptance criteria and owners.
- Prioritize ruthlessly. The ICE scoring method forces teams to rank projects based on Impact × Confidence × Ease, guaranteeing the #1 project is actually worth the time.

## How It Works

The bottom line is that you stop managing tasks and start managing the critical constraints of your project.

1. Input your full project plan or sprint backlog into the validation engine.
2. The tool runs five simultaneous checks: priority ranking, dependency mapping, PERT estimation, capacity math, and SMART deliverable verification.
3. You receive a detailed report listing all failures (e.g., 'Critical Path extended by 28 days,' or 'Capacity exceeds productive hours') with specific fixes.

## Frequently Asked Questions

**How does validate_task_organization handle dependencies?**
The tool maps blocking chains to find the true critical path. It identifies if tasks must run sequentially (A before B) or if they can overlap in parallel.

**Is PERT estimation better than simply guessing hours?**
Yes. Instead of a single guess, PERT uses three points—Optimistic, Most Likely, and Pessimistic—to generate a statistically weighted time estimate that accounts for risk.

**What is WIP limit in the context of validate_task_organization?**
WIP (Work In Progress) limits are hard caps on concurrent tasks. The tool recommends keeping this low (2-3 per person) to prevent context switching and keep focus high.

**Does validate_task_organization require me to know the Eisenhower matrix?**
No. You just feed it your list, and the tool runs the validation against the principles of the Eisenhower matrix, forcing you to classify tasks by Urgency vs. Importance.

**When I use validate_task_organization, what is the best format for submitting my raw list of tasks?**
You should provide a structured text input that explicitly separates details. For optimal results, include task descriptions, initial duration guesses, and any known required personnel or resources in distinct sections.

**What happens if I run validate_task_organization with zero acceptance criteria for a deliverable?**
The tool won't fail; instead, it will flag 'Outcome Disconnect.' It requires you to define concrete success metrics—what the final product looks like and who signs off on it. This prevents vague goals.

**Does validate_task_organization require tasks to come from a specific project management platform?**
No, it doesn't. The tool processes raw data provided through your AI client. You can paste lists or structured text regardless of whether the original source was Jira, Notion, or an email thread.

**How does validate_task_organization handle resource conflicts among multiple parallel tasks?**
It maps out which specific individuals are required for concurrent tasks. If two different streams need the same person at the same time, it flags that conflict and calculates the resulting delay or bottleneck.

**Why do flat task lists fail?**
Flat lists hide blocking dependencies, treat all tasks as equal priority, and ignore capacity constraints. The critical path — the longest chain of dependent tasks — determines minimum completion time. Without mapping it, you discover blockers mid-sprint.

**Why are 8 hours not 8 productive hours?**
Meetings, email, admin consume 30-50%. Productive deep work: 4-5 hours/day. Context switching costs 23 minutes per switch (UC Irvine). 5 switches/day = 2 hours lost. WIP limit: 2-3 concurrent tasks. Target 70-80% utilization — 100% causes burnout.

**What is the difference between 'done' and 'finished'?**
Finished = stopped working on it. Done = meets acceptance criteria. 'Write report' is an activity. 'Deliver board-ready Q3 analysis with 3 recommendations by Friday' is an outcome with SMART criteria and clear acceptance.