---
name: linear-triage-queue
description: "Every weekday at 10: the issues sitting in Linear Triage, oldest first, each with a suggested team, priority and label, ready to accept or change. Use when the user asks for this, or when it runs on a schedule."
---

# Linear triage queue

Every weekday at 10: the issues sitting in Linear Triage, oldest first, each with a suggested team, priority and label, ready to accept or change.

Triage is quick per issue and slow in bulk. The PM on duty opens the Triage view to find thirty issues from support, Slack and the Intercom integration, a few of them duplicates, and the oldest ones are exactly the ones a customer is waiting on.

The agent reads everything in Triage, searches open issues for likely duplicates, and suggests a team, a priority and an existing label for each one, with the reason. Nothing leaves Triage until you answer the card.

## Two ways to get the data

Use the API or MCP route when you have an MCP server, a CLI or an API token for the app. Otherwise, if you can drive a browser the user is signed in to (Claude in Chrome, a Playwright or Chrome DevTools MCP server), use the browser route. Say which one you used.

## Route A: API or MCP server

### What you need

- Membership in the teams that receive triage, and permission to edit their issues if the agent should apply your answer.
- The Linear MCP server or connector, or `LINEAR_API_KEY` with write access for the GraphQL mutations.

If something is missing, say what and stop; do not invent numbers.

### Steps

1. **Read the queue** (Linear): Query `issues(filter: { state: { type: { eq: "triage" } } }, first: 50)` with `identifier title description createdAt creator { name } team { key } labels { nodes { name } } attachments { nodes { sourceType } }`, then sort oldest first by `createdAt`.
2. **Check for duplicates** (Linear): For each issue, run `searchIssues(term: "<key words from the title>", first: 5)` and treat an open issue with a near-identical title or the same error message as a likely duplicate.
3. **Suggest team, priority and label** (Linear): Pick the team from what the issue describes, matched against `teams { nodes { key name description } }`. Suggest Urgent only for data loss, security or an outage, High when a paying customer is blocked, Medium or Low otherwise. Take labels from `issueLabels`; never invent one.
4. **Ask, then apply**: Post the queue with the suggestions and ask whether to apply them. On a yes, call `issueUpdate` with `teamId`, `priority`, `labelIds` and the target team's Backlog `stateId`, and `issueRelationCreate` with `type: duplicate` for duplicates.

## Route B: the browser

### What you need

- Signed in to Linear as a member of the teams whose Triage you read; applying suggestions needs permission to edit those issues.
- Triage turned on for the team under Team settings > Triage, or the view does not appear in the sidebar.

If something is missing, say what and stop; do not invent numbers.

### Steps

Start at https://linear.app/. The user is signed in already; never type passwords or codes, and ask if a sign-in page appears.

1. **Open the Triage view**: In the sidebar, expand the team that receives new issues and click **Triage** (or press `G` then `T`). If several teams have a Triage inbox, repeat the steps for each one.
2. **Sort oldest first**: Open **View options**, set **Ordering** to `Created` and flip the order so the oldest is on top. Turn on the `Created`, `Labels` and `Assignee` display properties.
3. **Read each issue**: Open the issues one by one and read the title, description, who created it and where it came from (a Slack, Intercom or Zendesk badge sits next to the title when an integration created it).
4. **Look for duplicates**: Press `/` or open **Search** and type the key words from the title. An open issue with a near-identical title or the same error text is a likely duplicate; keep its identifier.
5. **Suggest, then wait**: Write the queue with a suggested team, priority (Urgent only for data loss, security or an outage; High when a paying customer is blocked; otherwise Medium or Low) and one existing label per issue, and ask. Only after a yes, use **Accept** (`1`) and set the properties in the right-hand panel, or **Mark as duplicate** (`3`) for duplicates.

Note: On Business and Enterprise plans, Triage Intelligence already shows suggested assignees and labels in the panel; read them as one more input. Snoozed issues are hidden from the view unless you turn them on in View options.

## The report

- **Waiting in Triage**: the count, and the age of the oldest.
- **The queue**, oldest first: identifier, title, where it came from, suggested team, priority and label.
- **Likely duplicates**, each with the issue it repeats.
- The ask: apply all suggestions, go one by one, or leave them.

## Post it to Briefkin

When `BRIEFKIN_TOKEN` is set, or `~/.config/briefkin/env` exists (the installer from https://briefkin.dev/docs writes it), also send the result to the user's Briefkin board as one card. Keep the `item_key` the same on every run so the card updates in place, use a new `event_id` per run, and put today's real numbers in place of the example ones. If the request fails, say so once and carry on.

```bash
[ -n "${BRIEFKIN_TOKEN:-}" ] || . ~/.config/briefkin/env
curl -sS -X POST "${BRIEFKIN_URL:-https://briefkin.dev}/v1/events" \
  -H "authorization: Bearer $BRIEFKIN_TOKEN" \
  -H "content-type: application/json" \
  -d @- <<'JSON'
{
  "v": 1,
  "event_id": "linear-triage-queue/<date of this run, e.g. 2026-10-16>",
  "item_key": "linear-triage-queue",
  "project": "Acme",
  "source": "Linear triage queue skill",
  "kind": "action",
  "title": "8 issues waiting in Triage, oldest 4 days",
  "summary": "Suggestions are ready for all 8. **2 look like duplicates**, and SUP-311 reports missing invoices after a plan change, so it is marked Urgent.",
  "action": {
    "request": "Apply the suggested team, priority and label to these 8 issues?",
    "options": [
      "Apply all",
      "Apply all but duplicates",
      "Go one by one",
      "Leave them"
    ]
  },
  "widget": [
    {
      "type": "Table",
      "props": {
        "columns": [
          "Issue",
          "From",
          "Team",
          "Priority",
          "Label"
        ],
        "rows": [
          [
            "SUP-305 SSO login loops on Safari",
            "Slack",
            "Platform",
            "High",
            "Bug"
          ],
          [
            "SUP-309 Export reports to Excel",
            "Intercom",
            "Reporting",
            "Low",
            "Feature request"
          ],
          [
            "SUP-311 Invoices missing after a plan change",
            "Intercom",
            "Billing",
            "Urgent",
            "Bug"
          ],
          [
            "SUP-312 Dark mode on mobile",
            "Linear",
            "Mobile",
            "Low",
            "Feature request"
          ],
          [
            "SUP-314 Webhook timeouts for an EU workspace",
            "Slack",
            "Platform",
            "High",
            "Bug"
          ],
          [
            "SUP-316 Typo on the pricing page",
            "Linear",
            "Web",
            "Low",
            "Bug"
          ]
        ]
      }
    },
    {
      "type": "Callout",
      "props": {
        "text": "SUP-313 repeats ENG-874 and SUP-315 repeats WEB-221; both would be marked as duplicates.",
        "tone": "info"
      }
    }
  ]
}
JSON
```

Widgets come from the Briefkin catalog (https://briefkin.dev/v1/catalog). Without a token, just give the user the report.

## Run it on a schedule

Suggested: Weekdays at 10:00 (`0 10 * * 1-5`). From cron, with the agent signed in on that machine:

```bash
0 10 * * 1-5 claude -p "Run the linear-triage-queue skill"
# Codex: codex exec, Gemini CLI: gemini -p, Copilot CLI: copilot -p, OpenCode: opencode run
```

Or use the agent's own scheduler (Claude Code routines, Codex automations, Claude or ChatGPT scheduled tasks): https://briefkin.dev/skills/linear-triage-queue#schedule

Source: https://briefkin.dev/skills/linear-triage-queue
