Where do I see progress on internal refactors when the tickets live in a Linear project?

Tares shows progress on your internal refactors on the project page, where each Linear ticket appears with its builder, its pull request and its review rounds. The ticket stays in Linear and the sessions update it with their own tools, while Tares reads it. The Crew page adds who is working on what right now.

How it works

Your Linear project stays the home of the tickets. When you link it to a Tares project, its issues become that project’s tickets, and Tares reads them about once a minute. Tares only reads from Linear. The sessions doing the work create and change tickets in Linear with their own tools, and Tares picks up each change.

• Status follows the Linear workflow state. Backlog, unstarted and triage show as to do, started as in progress, completed as done, and canceled and duplicate as canceled.
• Milestones and blocking relations carry over, so a blocked ticket names the tickets it waits for.
• Every change is an event on the linear source: ticket_created, ticket_renamed, ticket_status, ticket_reordered or ticket_removed.
• An issue that leaves the Linear project becomes canceled in Tares instead of disappearing, so its working doc stays reachable.

On the project page, the Tickets fold lists each ticket with the builder that held it, its pull request and its review rounds. A ticket is to do, in progress, in review, merged or blocked. Across the top, four steps (Spec, Build, Review and Done) sit above a progress bar with one segment per ticket.

Set it up

1. Connect Linear in Settings > Linear. On Tares Cloud, click Connect Linear and approve the Tares app. On your own Tares, paste a personal API key with read access.
2. Open the project’s Tickets page, click Use a Linear project and pick the one that holds your refactor tickets. A project that already has tickets of its own cannot be linked.
3. Bring up the crew and plan the refactor work from the repo, following Get started:

tares factory crew up
tares factory spec "what you want to build"

4. Open the project page and unfold Tickets to follow each refactor ticket, its pull request and its review rounds.
5. Open the Crew page, at http://127.0.0.1:8787/crew on a local Tares, to see which station holds which ticket. Run tares factory crew status for the same view in your terminal.
6. Check the link. The Tickets page says “Tickets live in Linear project” and shows when it last synced. Change an issue in Linear and the ticket follows within a minute. Sync now reads at once.

What you get

• One place to watch a refactor move. Each ticket on the project page shows its state, the builder that held it, its pull request and how many review rounds it took.
• A progress bar with a segment per ticket, so a long refactor reads at a glance as tickets move from to do to merged.
• Blocked tickets that name what they wait for, which makes the order of a multi-step refactor visible.
• Your tracker stays the source of truth. Teammates keep working in Linear, and Tares follows without taking over the tickets.
• A change history on the linear source. Recent events lists each rename, status move and reorder, and triggers and agents can react to those events like any other.
• A standup report from the Standup button on the Crew page, listing what is done, started, in review, blocked and waiting on you, with pull request links.

The walkthrough in A project, end to end shows the project page and the Tickets fold on a finished build. The Linear connector page covers the sync in full.

When something else fits

• If you want Tares itself to hold the tickets, skip the link and keep them in Tares. The Tickets fold works the same way.
• If a project already has Tares tickets, you cannot link a Linear project to it. Start a new project for the Linear tickets.
• If you only need to know the ticket’s status, Linear alone shows that. Tares adds the pull request, the review rounds and the crew’s state around it.

Related