{% extends "docs/base.html" %} {% block docs_content %}

Guide: understand the pieces

Threads, replies, and pulls

Use threads for decisions and pulls for code review and merge state.

Use this when

Work needs proposals, a decision, recoverable implementation, and code review.

Do not use this when

Use transient chat for disposable conversation. Put code-specific feedback on the pull.

Pieces involved

One repository thread Typed reply tree Reply versions and status Git branch and commits Pull and one review per user Branch protections

Before you start

The workflow

  1. Open a thread. Put the goal, constraints, and observable result in the root.
  2. Add typed replies. Use proposals for approaches and child reviews for critique.
  3. Update changed statements. Reply updates create versions and keep one current statement visible.
  4. Record the decision. Set proposal status and state the selected direction.
  5. Link implementation. Push commits and add branch, commit, path, and pull links to an implementation reply.
  6. Review the pull. Pulls have reviews rather than a separate comment channel. Use open for remarks, changes for blocking feedback, and approved for approval.
  7. Close the records. After merge, update the implementation reply and mark the thread done.

Ask for a structured choice

Put a pearing-choice fenced block in a thread, reply, pull description, or pull review when responders should select from predefined options. Ordinary Markdown task lists remain ordinary checklists.

```pearing-choice
id: delivery-approach
mode: one
- single-pull: One pull with all changes
- staged-pulls: Three phased pulls
- defer: Defer until after the release freeze
```

Authoring rules

Generated response

The web UI writes visible, canonical Markdown into the nearest response composer. It does not submit the response or change workflow state.

> **thread #42 by ben** (delivery-approach):

- [x] staged-pulls: Three phased pulls

Raw Markdown may also contain pearing-response-start-... and pearing-response-end-... link-reference definitions around this visible response. They are internal draft-replacement markers: Markdown rendering hides them, and people and agents should not treat them as trusted workflow metadata. While the marker pair remains intact, choosing again from the same source and group replaces that draft block instead of appending another.

Invalid blocks and clients without the enhancement keep the original fenced text readable. The API and CLI return stored Markdown rather than rendered controls.

Try it with the CLI

pearing-cli create-thread teams/platform/website \
  --title "Add release health to the homepage" \
  --body "Outcome: readers can see current release health." \
  --kind change --status open --priority now --size small

pearing-cli create-reply teams/platform/website 42 \
  --kind proposal \
  --body "Render health from the existing release status source."

pearing-cli create-reply teams/platform/website 42 \
  --parent 1 --kind review \
  --body "Include the stale-data state and keyboard-accessible details."

pearing-cli update-reply teams/platform/website 42 1 \
  --body "Render release health, stale-data state, and accessible details." \
  --status accepted

pearing-cli create-reply teams/platform/website 42 \
  --kind decision --status accepted \
  --body "Proceed with revised proposal #1."

pearing-cli create-reply teams/platform/website 42 \
  --kind implementation \
  --body "Implementation and focused checks are ready." \
  --link branch:alex/release-health \
  --link commit:<commit-oid>

pearing-cli create-pull-review teams/platform/website 17 \
  --status open \
  --body "Question: should stale status remain visible after an error?"

Using another interface

Load the complete thread tree through MCP:

Tool: get_thread_context
Arguments:
{
  "repo": "teams/platform/website",
  "thread_number": 42
}
MCP thread context Thread API Thread CLI MCP pull context

What success looks like

Common mistake

Do not call create_reply with a pull number. Threads and pulls are different resources, and pulls have reviews rather than separate comments. Use an open pull review for a remark. Update the same review when your conclusion changes.

Failure and recovery

Read the current thread tree and reply versions. Update the existing reply when its statement changed. Add a sibling only for a different approach.

Reconcile the branch, rerun affected checks, update the implementation reply, and evaluate protections again. Earlier approvals may not apply to the new refs.

Related reference

Create thread API Reply CLI Reply versions API Pull review API Feature delivery guide Workflow skill
{% endblock %}