Skip to main content
Glama

task_list

List and filter project tasks by status or ticket ID to track progress and identify blockers in technical project management workflows.

Instructions

PROJECT MANAGEMENT (TPM): List task IDs with status. Returns id, ticket_id, status only - use task_get for details.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
ticket_idNoFilter by ticket ID
statusNoFilter by status
limitNoMax tasks to return (default: 50, max: 200)
offsetNoSkip first N tasks for pagination (default: 0)

Implementation Reference

  • The core handler logic for the 'task_list' tool. It retrieves tasks filtered by optional ticket_id and status using db.list_tasks(), applies pagination with limit and offset parameters, and returns a paginated JSON list containing each task's id, ticket_id, and status.
    if name == "task_list":
        status = TaskStatus(args["status"]) if args.get("status") else None
        tasks = db.list_tasks(args.get("ticket_id"), status)
        # Apply pagination (default 50, max 200) - items are small now
        limit = min(args.get("limit", 50), 200)
        offset = args.get("offset", 0)
        total = len(tasks)
        tasks = tasks[offset:offset + limit]
        # Return IDs + essential metadata only - use task_get for details
        result = [
            {
                "id": t.id,
                "ticket_id": t.ticket_id,
                "status": t.status.value,
            }
            for t in tasks
        ]
        return _json({"tasks": result, "offset": offset, "limit": limit, "total": total})
  • The Tool definition including name, description, and inputSchema for the 'task_list' tool, which registers it with the MCP server via the list_tools() handler. The schema defines optional parameters for filtering and pagination.
    Tool(
        name="task_list",
        description="PROJECT MANAGEMENT (TPM): List task IDs with status. Returns id, ticket_id, status only - use task_get for details.",
        inputSchema={
            "type": "object",
            "properties": {
                "ticket_id": {"type": "string", "description": "Filter by ticket ID"},
                "status": {
                    "type": "string",
                    "enum": ["pending", "in-progress", "done", "blocked"],
                    "description": "Filter by status",
                },
                "limit": {
                    "type": "integer",
                    "description": "Max tasks to return (default: 50, max: 200)",
                    "default": 50,
                },
                "offset": {
                    "type": "integer",
                    "description": "Skip first N tasks for pagination (default: 0)",
                    "default": 0,
                },
            },
        },
    ),
  • The @server.list_tools() decorator registers all tools including 'task_list' by returning a list of Tool objects describing each tool's name, description, and input schema.
    @server.list_tools()
    async def list_tools() -> list[Tool]:
        return [
            # Roadmap view - PRIMARY TOOL for checking status
            Tool(
                name="roadmap_view",
                description="""PROJECT MANAGEMENT (TPM): Get project roadmap showing work status.
    
    USE THIS TOOL WHEN:
    - User asks "what's in progress?" or "what are we working on?"
    - User asks "TPM status", ":TPM:" prefix, or "show me the roadmap"
    - User asks about pending/blocked/completed work
    - Starting a work session to see current state
    - User completes work and you need to find related tasks to mark done
    
    Returns summary of organizations, projects, and tickets. Use project_id filter to reduce output.""",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "org_id": {
                            "type": "string",
                            "description": "Filter by organization ID (optional) case-insensitive",
                        },
                        "project_id": {
                            "type": "string",
                            "description": "Filter by project ID (optional) - recommended to reduce output size",
                        },
                        "active_only": {
                            "type": "boolean",
                            "description": "Only show non-done tickets (default: true)",
                            "default": True,
                        },
                    },
                },
            ),
            # Ticket operations
            Tool(
                name="ticket_create",
                description="""PROJECT MANAGEMENT (TPM): Create a new ticket, epic, or issue to track.
    
    USE THIS TOOL WHEN:
    - User says ":TPM: Add X feature to the roadmap"
    - User wants to add a new feature/ticket/issue
    - User says "add ticket for X" or "create feature for Y"
    - Breaking down work into trackable items
    - User asks to scope out or define new work
    - User discusses new work that should be tracked
    
    Use roadmap_view first to get the project_id. Tickets are high-level work items (like Jira epics/stories).
    
    ID AUTO-GENERATION:
    IDs are always auto-generated as {PREFIX}-{NNN} (e.g., FEAT-001, ISSUE-042).
    The number is automatically incremented based on existing tickets with that prefix.
    
    OPTIONAL PREFIX PARAMETER:
    Provide a prefix to categorize the ticket type:
    - FEAT: New features or capabilities
    - ISSUE: Bugs, problems, or issues to fix
    - TASK: General tasks or chores
    - INFRA: Infrastructure or DevOps work
    - DOC: Documentation tasks
    
    If no prefix is provided, uses the project ID as the prefix (e.g., FRONTEND-001, BACKEND-042).""",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "project_id": {
                            "type": "string",
                            "description": "Project ID (use project_list to find) case-insensitive",
                        },
                        "prefix": {
                            "type": "string",
                            "description": "Optional prefix for ticket ID (e.g., FEAT, ISSUE, INFRA). Number is auto-generated. If omitted, uses project ID as prefix.",
                        },
                        "title": {"type": "string", "description": "Ticket title"},
                        "description": {
                            "type": "string",
                            "description": "Detailed description of the ticket",
                        },
                        "status": {
                            "type": "string",
                            "enum": ["backlog", "planned", "in-progress", "done", "blocked"],
                            "description": "Ticket status (default: backlog)",
                        },
                        "priority": {
                            "type": "string",
                            "enum": ["critical", "high", "medium", "low"],
                            "description": "Priority level (default: medium)",
                        },
                        "tags": {
                            "type": "array",
                            "items": {"type": "string"},
                            "description": "Tags for categorization",
                        },
                        "assignees": {
                            "type": "array",
                            "items": {"type": "string"},
                            "description": "Who is working on this",
                        },
                    },
                    "required": ["project_id", "title"],
                },
            ),
            Tool(
                name="ticket_update",
                description="""PROJECT MANAGEMENT (TPM): Update a ticket's status, priority, or details.
    
    USE THIS TOOL WHEN:
    - User says "I just finished implementing X" - mark related ticket as done
    - User says "I've pushed commits for X" - update status based on progress
    - Marking work as in-progress, done, or blocked
    - Changing priority of a ticket
    - User completes a ticket and needs to update status
    - Adding/updating tags or assignees
    
    Use roadmap_view first to find the ticket_id.""",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "ticket_id": {"type": "string", "description": "Ticket ID (e.g., FEAT-001)"},
                        "title": {"type": "string", "description": "New title"},
                        "description": {"type": "string", "description": "New description"},
                        "status": {
                            "type": "string",
                            "enum": ["backlog", "planned", "in-progress", "done", "blocked"],
                            "description": "New status",
                        },
                        "priority": {
                            "type": "string",
                            "enum": ["critical", "high", "medium", "low"],
                            "description": "New priority",
                        },
                        "tags": {
                            "type": "array",
                            "items": {"type": "string"},
                            "description": "Updated tags",
                        },
                        "assignees": {
                            "type": "array",
                            "items": {"type": "string"},
                            "description": "Updated assignees",
                        },
                    },
                    "required": ["ticket_id"],
                },
            ),
            Tool(
                name="ticket_list",
                description="PROJECT MANAGEMENT: List ticket IDs with status/priority. Returns id, status, priority only - use ticket_get for details.",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "project_id": {"type": "string", "description": "Filter by project ID (case-insensitive)"},
                        "status": {
                            "type": "string",
                            "enum": ["backlog", "planned", "in-progress", "done", "blocked"],
                            "description": "Filter by status",
                        },
                        "limit": {
                            "type": "integer",
                            "description": "Max tickets to return (default: 50, max: 200)",
                            "default": 50,
                        },
                        "offset": {
                            "type": "integer",
                            "description": "Skip first N tickets for pagination (default: 0)",
                            "default": 0,
                        },
                    },
                },
            ),
            Tool(
                name="ticket_search",
                description="""PROJECT MANAGEMENT (TPM): Search tickets by keyword.
    
    USE THIS TOOL WHEN:
    - User asks "find tickets about X" or "search for Y"
    - Looking for tickets by keywords in title or description
    - Need to discover relevant tickets across projects
    
    Searches title and description. Supports prefix matching (e.g., "org" matches "organization").
    Case-insensitive. All filters are combinable.""",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "query": {
                            "type": "string",
                            "description": "Search query (keywords to search in title/description)",
                        },
                        "project_id": {
                            "type": "string",
                            "description": "Filter by project ID (optional, case-insensitive)",
                        },
                        "status": {
                            "type": "string",
                            "enum": ["backlog", "planned", "in-progress", "done", "blocked"],
                            "description": "Filter by status (optional)",
                        },
                        "priority": {
                            "type": "string",
                            "enum": ["critical", "high", "medium", "low"],
                            "description": "Filter by priority (optional)",
                        },
                        "tags": {
                            "type": "array",
                            "items": {"type": "string"},
                            "description": "Filter by tags - ticket must have all specified tags (optional)",
                        },
                        "limit": {
                            "type": "integer",
                            "description": "Maximum results to return (default: 20, max: 100)",
                            "default": 20,
                        },
                    },
                    "required": ["query"],
                },
            ),
            Tool(
                name="ticket_get",
                description="""PROJECT MANAGEMENT: Get info about a ticket and its tasks.
    
    IMPORTANT: Do NOT pass detail='full' unless explicitly asked for full/all details. The default 'summary' is sufficient for most queries. Only use 'full' when user specifically asks for implementation details, metadata, or complete task information.""",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "ticket_id": {"type": "string", "description": "Ticket ID (e.g., FEAT-001)"},
                        "detail": {
                            "type": "string",
                            "enum": ["minimal", "summary", "full"],
                            "description": "OMIT this param for most requests (defaults to 'summary'). Only use 'full' if user explicitly asks for all details/metadata.",
                            "default": "summary",
                        },
                    },
                    "required": ["ticket_id"],
                },
            ),
            Tool(
                name="task_get",
                description="""PROJECT MANAGEMENT: Get full details of ONE specific task.
    
    Use this to drill into a single task's implementation details (metadata, files_to_modify, technical_notes). Prefer ticket_get for overview, use this only when you need deep task details.""",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "task_id": {
                            "type": "string",
                            "description": "Task ID (e.g., SUBTASK-007-1 or TASK-abc123-1)",
                        }
                    },
                    "required": ["task_id"],
                },
            ),
            # Task operations
            Tool(
                name="task_create",
                description="""PROJECT MANAGEMENT (TPM): Create a task (sub-item) under a ticket.
    
    USE THIS TOOL WHEN:
    - Breaking down a ticket into smaller tasks
    - User asks to add implementation steps
    - Creating a work breakdown structure""",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "ticket_id": {"type": "string", "description": "Parent ticket ID"},
                        "title": {"type": "string", "description": "Task title"},
                        "details": {
                            "type": "string",
                            "description": "Task details/implementation notes",
                        },
                        "status": {
                            "type": "string",
                            "enum": ["pending", "in-progress", "done", "blocked"],
                            "description": "Task status (default: pending)",
                        },
                        "priority": {
                            "type": "string",
                            "enum": ["critical", "high", "medium", "low"],
                            "description": "Priority (default: medium)",
                        },
                        "complexity": {
                            "type": "string",
                            "enum": ["simple", "medium", "complex"],
                            "description": "Complexity estimate (default: medium)",
                        },
                    },
                    "required": ["ticket_id", "title"],
                },
            ),
            Tool(
                name="task_update",
                description="PROJECT MANAGEMENT (TPM): Update a task's status or details. Use when completing or updating task progress.",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "task_id": {"type": "string", "description": "Task ID (e.g., TASK-001-1)"},
                        "title": {"type": "string", "description": "New title"},
                        "details": {"type": "string", "description": "New details"},
                        "status": {
                            "type": "string",
                            "enum": ["pending", "in-progress", "done", "blocked"],
                            "description": "New status",
                        },
                        "priority": {
                            "type": "string",
                            "enum": ["critical", "high", "medium", "low"],
                            "description": "New priority",
                        },
                        "complexity": {
                            "type": "string",
                            "enum": ["simple", "medium", "complex"],
                            "description": "New complexity",
                        },
                    },
                    "required": ["task_id"],
                },
            ),
            Tool(
                name="task_list",
                description="PROJECT MANAGEMENT (TPM): List task IDs with status. Returns id, ticket_id, status only - use task_get for details.",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "ticket_id": {"type": "string", "description": "Filter by ticket ID"},
                        "status": {
                            "type": "string",
                            "enum": ["pending", "in-progress", "done", "blocked"],
                            "description": "Filter by status",
                        },
                        "limit": {
                            "type": "integer",
                            "description": "Max tasks to return (default: 50, max: 200)",
                            "default": 50,
                        },
                        "offset": {
                            "type": "integer",
                            "description": "Skip first N tasks for pagination (default: 0)",
                            "default": 0,
                        },
                    },
                },
            ),
            # Notes
            Tool(
                name="note_add",
                description="PROJECT MANAGEMENT (TPM): Add a note/comment to a ticket or task for context or decisions.",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "entity_type": {
                            "type": "string",
                            "enum": ["org", "project", "ticket", "task"],
                            "description": "Type of entity",
                        },
                        "entity_id": {"type": "string", "description": "ID of the entity"},
                        "content": {"type": "string", "description": "Note content"},
                    },
                    "required": ["entity_type", "entity_id", "content"],
                },
            ),
            Tool(
                name="note_list",
                description="PROJECT MANAGEMENT (TPM): List notes for an entity. Returns id, created_at, preview (first 100 chars). Use note_get for full content.",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "entity_type": {
                            "type": "string",
                            "enum": ["org", "project", "ticket", "task"],
                            "description": "Type of entity",
                        },
                        "entity_id": {"type": "string", "description": "ID of the entity"},
                        "limit": {
                            "type": "integer",
                            "description": "Max notes to return (default: 20, max: 50)",
                            "default": 20,
                        },
                    },
                    "required": ["entity_type", "entity_id"],
                },
            ),
            Tool(
                name="note_get",
                description="PROJECT MANAGEMENT (TPM): Get full content of a specific note by ID.",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "note_id": {"type": "string", "description": "Note ID"},
                    },
                    "required": ["note_id"],
                },
            ),
            # Org/Project operations (less frequently used)
            Tool(
                name="org_list",
                description="PROJECT MANAGEMENT: List all organizations. Usually only one org exists.",
                inputSchema={"type": "object", "properties": {}},
            ),
            Tool(
                name="org_create",
                description="PROJECT MANAGEMENT: Create a new organization (rarely needed).",
                inputSchema={
                    "type": "object",
                    "properties": {"name": {"type": "string", "description": "Organization name"}},
                    "required": ["name"],
                },
            ),
            Tool(
                name="project_list",
                description="PROJECT MANAGEMENT: List projects in an organization.",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "org_id": {"type": "string", "description": "Filter by organization ID (case-insensitive)"}
                    },
                },
            ),
            Tool(
                name="project_create",
                description="PROJECT MANAGEMENT: Create a new project under an organization.",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "org_id": {"type": "string", "description": "Organization ID (case-insensitive)"},
                        "name": {"type": "string", "description": "Project name"},
                        "repo_path": {"type": "string", "description": "Path to git repo"},
                        "description": {"type": "string", "description": "Project description"},
                    },
                    "required": ["org_id", "name"],
                },
            ),
            # Info tool
            Tool(
                name="info",
                description="Get information about the tracker MCP server: database location, stats, and usage.",
                inputSchema={"type": "object", "properties": {}},
            ),
        ]
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It mentions the return fields (id, ticket_id, status) and hints at pagination through the schema, but lacks details on permissions, rate limits, error handling, or whether it's read-only. The description adds some context but is incomplete for behavioral transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with zero waste: the first states the purpose and return fields, the second provides usage guidance. It is front-loaded and appropriately sized, with every sentence adding value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (list operation with filtering/pagination), no annotations, and no output schema, the description is fairly complete: it covers purpose, return fields, and sibling differentiation. However, it lacks details on behavioral aspects like permissions or error handling, which would be beneficial for full completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents all 4 parameters. The description does not add any parameter-specific information beyond what the schema provides, such as syntax or format details, meeting the baseline for high coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('List') and resource ('task IDs with status'), specifying it returns only id, ticket_id, and status. It distinguishes from sibling 'task_get' by noting that tool provides details, making the purpose specific and differentiated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when to use this tool ('List task IDs with status') and when to use an alternative ('use task_get for details'), providing clear guidance on tool selection relative to siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/urjitbhatia/tpm-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server