/working-with-task-comments

name: working-with-task-comments
description: >-
  Read and use comments attached to the current PostHog task, its artifacts, and any canvas through
  the PostHog MCP exec dispatcher. Use when the user mentions task comments, artifact or canvas
  comments, annotations, selected-text feedback, replies, unresolved comments, or asks an agent to
  inspect or act on feedback left in PostHog Desktop. Covers exec discovery and calls, target filtering,
  pagination, full-thread retrieval, anchor/version context, task-scoped access, and standalone
  canvas comments that have no task.

Working with task comments

Use the canonical PostHog MCP tool `posthog:exec` for every task-comment operation. A client or harness may render that canonical name differently. `tasks-comments-list` and the related names are inner tools, not separately registered MCP tools.

Do not conclude that comments are unavailable because a client-specific tool name differs from `posthog:exec`, or because there is no top-level `posthog:tasks-comments-list` tool. Do not use MCP resource-listing tools: comments are inner tools behind `exec`, not MCP resources.

Discover the inner tools

Call `posthog:exec` with:

{ "command": "search ^(tasks-(artifacts-list|comments-(list|retrieve))|canvas-comments-(list|retrieve))$" }

The expected inner tools are:

| Tool | Scope | | -------------------------- | ------------------------------------------------------------------- | | `tasks-artifacts-list` | Artifacts and canvases of the current task | | `tasks-comments-list` | Roots on the current task, its artifacts, and canvas roots it wrote | | `tasks-comments-retrieve` | One thread from `tasks-comments-list` | | `canvas-comments-list` | Every root on one canvas, whichever task or person wrote it | | `canvas-comments-retrieve` | One thread from `canvas-comments-list` |

The `tasks-*` tools need PostHog Desktop task context. The `canvas-*` tools need only a canvas id. A user can leave a canvas comment without a task. The `tasks-*` tools do not return that comment.

If the client exposes no tool corresponding to canonical `posthog:exec`, the PostHog MCP server is unavailable in the run. Report that comments cannot be accessed only when `exec search` returns no tool for the target:

• For task or artifact comments, the `tasks-*` tools must be present.
• For canvas comments, the `canvas-*` tools or the `tasks-*` tools must be present.

A connection can have the `canvas-*` tools without task context. A connection can also have the `tasks-*` tools without the `canvas-*` tools, because a feature flag controls the `canvas-*` tools.

Use `info <inner-tool-name>` when the schema is unclear. For example:

{ "command": "info tasks-comments-list" }

Call tools through `exec`

Put the complete inner-tool invocation in `exec.command`.

List open comment roots across the task:

{ "command": "call tasks-comments-list {}" }

List artifacts and canvases when an inventory or filter id is needed:

{ "command": "call tasks-artifacts-list {}" }

Filter roots to one returned artifact or canvas id:

{ "command": "call tasks-comments-list {\"artifact_id\":\"<artifact-id>\"}" }

Retrieve a root and its replies:

{ "command": "call tasks-comments-retrieve {\"root_comment_id\":\"<root-comment-id>\"}" }

List open roots on one canvas. No task id is necessary:

{ "command": "call canvas-comments-list {\"id\":\"<canvas-id>\"}" }

Retrieve a canvas root and its replies:

{ "command": "call canvas-comments-retrieve {\"id\":\"<canvas-id>\",\"root_comment_id\":\"<root-comment-id>\"}" }

Never attempt to invoke an inner name as a top-level MCP tool. The notation `posthog:tasks-comments-list` also means to route that inner name through `exec`; it is not a literal tool name.

Read complete results

Both root listing and thread retrieval are cursor-paginated. For either operation:

1. Call without `cursor`. 2. Process the page. 3. If `next` is non-null, call the same inner tool again with `"cursor":"<next>"` and repeat the original filters. 4. Stop only when `next` is null.

Example continuation:

{
  "command": "call tasks-comments-list {\"artifact_id\":\"<artifact-id>\",\"include_resolved\":true,\"cursor\":\"<next>\"}"
}

Start with the root inventory and retrieve only threads relevant to the user's request. Before acting on a root, retrieve its thread so an older message is not mistaken for the latest request. The list returns open roots by default; pass `"include_resolved":true` only when resolved history matters.

List bodies are bounded excerpts. Detail responses cap total comment-body bytes. When a detail entry has `content_truncated: true`, call the same retrieve tool again with that entry's `id` as `comment_id` and its `content_next_offset` as `content_offset`. Continue until `content_next_offset` is null. Do this only for comments needed for the task.

Choose the smallest workflow

Read comments across the task

1. Discover the tools through `exec search` if they have not been confirmed in this run. 2. Call `tasks-comments-list` through `exec` and continue until the relevant roots are found. 3. Retrieve and paginate relevant roots through `exec`. 4. Group or summarize by the returned target only when useful.

Read comments for one artifact

1. Call `tasks-artifacts-list` through `exec` unless the target id is already known. 2. Pass the returned id as `artifact_id` to `tasks-comments-list` through `exec`. 3. Retrieve every relevant root and all replies through `exec`.

Read comments for one canvas

1. Get the canvas id. Use the id from the user, the canvas URL, `tasks-artifacts-list`, or `canvas-list`. 2. Pass the id as `id` to `canvas-comment