---
title: Insights in Venom Tasks
description: Chart any list, board, project, cycle or saved view by issue count, effort, SLA breaches, cycle time, lead time, triage time, age or time in each status, sliced and segmented by a field, see its cumulative flow, and open the issues behind a bar.
section: cloud
order: 132
audience: [user, agent]
sources: [services/nodejs-cloud/components/tasks/insights/InsightsPanel.tsx, services/nodejs-cloud/components/tasks/insights/InsightsDock.tsx, services/nodejs-cloud/components/tasks/insights/drill-model.ts, services/nodejs-cloud/components/tasks/insights/chart-model.ts, services/nodejs-cloud/components/tasks/insights/ScopeInsights.tsx, services/nodejs-cloud/components/tasks/insights/model.ts, services/nodejs-cloud/components/tasks/planning/Insights.tsx, services/nodejs-cloud/lib/tasks/insights.ts, services/nodejs-cloud/lib/tasks/insights-pure.ts, services/nodejs-cloud/lib/tasks/insights-sql.ts, services/nodejs-cloud/lib/tasks/insights-scope.ts, services/nodejs-cloud/lib/tasks/insights-contract.ts]
features: []
---

Insights turns the issues you're looking at into a chart and a table. It counts exactly what the view shows: the
same team, filters, search text, saved view, sub-issues and subteams setting, and only issues you're allowed to see.

## Where to find it

- **Any list or board** (My issues, a team's Triage, Issues, Active, Backlog or Active cycle): the **Insights** button
  in the header, `⌘/Ctrl+Shift+I` or `]` docks the panel beside the list ([The dock](#the-dock)).
- **A saved view** (`/tasks/views/{id}`): the same button and keys, next to "Open as a filtered list".
- **A cycle** (`/tasks/cycles`, `/tasks/cycles/{id}`): the button in the cycle's header (and the keys), and the cycle's
  scope change and velocity under its burn-up.
- **A project** (`/tasks/projects/{id}`): the **Insights** tab holds the project's burn-up, scope change and velocity,
  then the panel over the project's issues.
- **The whole workspace**: **Insights** in the sidebar (`/tasks/insights`), for every team or one team and its
  subteams.

## The dock

On a list, a board, a saved view or a cycle, Insights opens as a column at the right of the page, beside the list
(on a phone it covers the page). The list stays usable next to it.

- **Resize** by dragging its left edge, from 360 px to 70% of the window; double-click the edge to go back to 440 px.
  With the edge focused, `←` and `→` widen and narrow it. The width is remembered in this browser.
- **Full screen** (the expand button in its header) fills the page with a bigger chart, every percentile column in the
  table, and the issues listed under the chart when you click it. `Esc` leaves full screen first, then closes the dock.
- **Open or closed** is remembered for each list, saved view and cycle on its own, and so are the panel's choices: a
  list you haven't charted before starts from the last chart you used.
- **Keys**: `⌘/Ctrl+Shift+I` or `]` show and hide it, on the tab you used last (`]` still shows an issue's properties
  on the issue page). `⌘/Ctrl+Shift+B` opens it on the [Breakdown](#breakdown) tab (again to close it). While
  focus is in the panel, `m`, `s`, `g`, `c`, `d` and `r` open the Measure, Slice, Segment, Chart, Date and Range
  lists; type to filter a list or press its number.
- **Tabs**: on a list, a board and a saved view the dock has two tabs at its top, **Insights** (the chart) and
  **Breakdown**. The tab is remembered for each list, and the chart keeps its choices while you look at the other one.

### Breakdown

The **Breakdown** tab answers "who has these issues, which labels, which projects" for the issues the list shows now.
Pick a dimension at its top (assignee, agent, label, priority, project, cycle, milestone, status, estimate, and team
when the list spans several teams) and each value gets a row: its icon or avatar, its name, how many issues, a thin
bar of its share of the list and, when the list holds closed issues, how many of them are done. Busiest first, with
"No assignee", "No label" and the like last. An issue with two labels counts once under each, and the tab says so
under the list. A list of more than 50 values shows the first 50 and "+ N more".

The counts come from the list's own issues (after its filters, before the insight filter), so they add up to what is
on screen, and a row's count is what the list shows once you click it.

- **Click a row** (or press `Enter` on it) to narrow the list to that value. The chip above the list reads
  "Assignee: Sam", groups and board columns read "matched / total", and the same row again, the chip's ×, or `Esc`
  in the tab shows everything. A row filters the list the same way a bar of the Insights chart does, so the two never
  disagree.
- **`Shift`+click** a second value of the same dimension to see issues with either one.
- **Keys**: `↑` `↓` move between rows, `←` `→` switch the dimension, `Enter` picks, `Esc` clears.
- **⋯** copies the table as a Markdown table, or as an image (the same picture path as [Copy as image](#copy-as-image)).
- On a phone the dock is a sheet at the top of the page: tapping a row filters the list and closes the sheet.

A cycle's details sidebar has the same breakdowns (assignee, label, project, plus priority and status) from the same
code, with the same copy as Markdown or image under its ⋯.

A project's **Insights** tab and the workspace's **Insights** page (`/tasks/insights`) show the same panel at full
width.

## The panel

Pick what to measure, how to lay it out and how to colour it: each control is a button that shows its value and opens
a list. **Questions** in the header answers a common question in one click (what is slipping, who is overloaded,
where the time goes by status, agents and people side by side, how long work takes, where work comes from); it sets
the controls, which you can change from there. **Save insight** keeps the chart with a name, private or shared with
the org, on the [Dashboards](/docs/cloud/tasks-dashboards.md) page and in Notes pages.

| Control | Choices |
|---|---|
| Measure | **Issue count**, **Effort** (estimate points; an unestimated issue counts 0), **SLA breaches** (issues that missed their [SLA](/docs/cloud/tasks-sla.md), placed by when they breached), **Customer requests** (the [requests](/docs/cloud/tasks-customer-requests.md) on the issues, counting only those you may see), **Cycle time** (started to completed), **Lead time** (created to completed), **Triage time** (from arriving in triage to the first move out), **Issue age** (how long open issues have been open, now), **Time in status** (how long finished issues spent in each status, below), **Reopened** (how many times issues went from done or canceled back to open, [below](#reopened)), **Blocked time** (how long issues sat open waiting on an open blocker, [below](#blocked-time)) |
| Slice (the x axis) | **Time**, or a field: Status, Status type, Assignee, Agent, Creator, Label, Label group (then pick the group), Priority, Estimate, Project, Milestone, Initiative, Cycle, Team, Subteam, Parent issue, Customer, Source, SLA status ([Fields](#fields)), or **Burn-up** (the [cumulative flow](#cumulative-flow)) |
| Segment (the colour) | None, or another field (Label group asks which group) |
| Chart | **Bar**, **Line** or **Area** over time, and for a segmented bar **Stacked** or **Grouped** (side by side); **Scatter** (one dot per issue) for cycle, lead, triage and blocked time over time. A field on the x axis is drawn as horizontal bars |
| By date | for count, effort and customer requests: whether an issue lands on the day it was **created**, **started**, **completed**, **canceled** or last **updated** ([Dates](#dates)). Hidden for the durations, which have their own dates |
| Window | the last 7, 14, 30 or 90 days, 6 months, one or two years, or **Custom range…** (pick the first and last day). Issue age ignores it: every open issue counts |
| Bucket | over time: **Auto** (below), **Day**, **Week**, **Month** or **Quarter**; the burn-up takes Auto, Week or Month |

**⋯** in the header holds the rest:

- **Show archived issues** and **Leave out issues with no priority** (`archived=include`, `noPriority=exclude`).
- **Compare with the previous period**: the same chart over the window just before (as long, ending where this one
  starts). Time charts draw it as a dashed line, bars by field get a tick at last period's value, the totals and the
  table show the change, and a sentence under the chart names the period's change and its biggest movers.
- **Copy link**: a link to this page that opens the dock on the same chart (`insights=` in the address). For a saved
  insight it is the insight's own link on Dashboards.
- **Download CSV** and **Copy as CSV** ([Export as CSV](#export-as-csv)), and **Save to Dashboards…**.
- **Copy as image** (`Shift+C` while focus is in the panel) and **Download PNG** ([Copy as image](#copy-as-image)).

- **Over time**, buckets are days for windows up to a month, weeks (Monday to Sunday) up to half a year, and months
  beyond. Times are UTC.
- **Durations** are summarised by the median (the bar's height), the 25th, 75th, 90th and 95th percentiles and the
  mean. Percentiles are nearest-rank: each is one issue's actual duration (with four issues of 1, 2, 3 and 4 days the
  25th percentile is 1 day, the median 2, the 75th 3, the 90th and 95th 4). Empty buckets are gaps, not zero.
- **Segments**: the eight biggest are drawn and the rest are added up as **Other**. A field on the x axis keeps its 50
  biggest categories. Status follows your workflow's order and priority goes Urgent, High, Medium, Low, then no
  priority; other fields go biggest first, with "no value" (Unassigned, No label, No project, No cycle) after them.
- **Labels**: an issue with two labels counts under each, but once in the totals.
- **The scatter** shows the newest 2,000 finished issues, with dashed lines at the 25th, 50th, 75th and 95th
  percentiles, each labelled with its value. Click a label to zoom the y axis to that percentile (slower issues sit on
  the top edge as small up-pointing marks, counted under the chart); click it again to zoom out. Hover a dot for its
  ID, title, finish date and segment; click it to open the issue.
- **The tooltip** on a bar or a segment gives its value, its share of the bar and of the whole chart, and how many
  issues it holds; for a duration, its median and 90th percentile.
- **The legend** hides or shows a segment (Shift-click shows only that one; Alt-click filters the list to it). The
  scatter has one too, for its segments.
- **The table** under the chart has a row per category (or per segment, or per bucket over time) with the issue count
  and the share, the points, or the median and 90th percentile (all five percentiles in full screen). Hovering a row
  lights up its bar, and hovering a bar lights up its row.
- **The keyboard**: each chart is one stop for `Tab`. `←`/`→` move between bars (`↑`/`↓` for bars by field), the other
  pair between a bar's segments, `Enter` does what a click does and `Esc` leaves the chart; the bar or segment is read
  out to a screen reader with its value, share and issue count.

### Copy as image

**Copy as image** puts the chart on the clipboard as a PNG, ready to paste into a note, a chat message or a document;
**Download PNG** saves the same picture. The picture stands on its own: the chart's sentence and what it measures as
a title, a line naming the view, its filters, the window and the switches that are on, the legend, the chart as you
see it (segments you hid stay hidden), and a footer "Venom Tasks · *view* · *date*". It is drawn in the theme you are
using (light or dark) at twice your screen's pixel density, in your system's font. Nothing is fetched to make it: the
chart is drawn as an SVG from the numbers already on screen and painted on a canvas in your browser. When the browser
won't put an image on the clipboard (some browsers allow it only on secure pages, or ask first), the PNG is downloaded
instead and a toast says so. Saved insights on [Dashboards](/docs/cloud/tasks-dashboards.md) have the same two entries in their
**⋯** menu.

The [cumulative flow](#cumulative-flow) copies and downloads the same way (`Shift+C` too): its bands stacked with the
legend, the first, middle and last date, and each band named with its value now at the right edge. A cycle's
[burn-up](#projects-and-cycles) has a **⋯** with **Copy as image** and **Download PNG**: its three lines, target,
projection with its verdict, capacity and the days, every line named at its end. The Breakdown tab's table copies as
an image too. All of them are drawn by the one code path above.

### Fields

An issue counts once in each group it belongs to, and once in the totals.

| Field | Groups by | "No value" |
|---|---|---|
| Status | the workflow status, in your workflow's order | |
| Status type | Triage, Backlog, Unstarted, Started, Completed, Canceled, in that order | |
| Assignee, Agent, Creator | the person; the agent the issue is delegated to; who (or what) created it | Unassigned, No agent |
| Label | each label (an issue with two labels is in both) | No label |
| Subteam | the issue's team rolled up one level below the view's team (the team's own issues are one group, each subteam with the teams under it another); with no single team in view, the top-level team ([Subteams](/docs/cloud/tasks-subteams)) | |
| Label group | the issue's label inside one group (`labelGroup=<group id>`); a group's labels are exclusive, so it is one group per issue | No *group name* |
| Priority | Urgent, High, Medium, Low, then no priority | No priority |
| Estimate | the points, smallest first (T-shirt sizes when every team that estimates uses them) | No estimate |
| Project, Milestone | the project; the milestone, named "Project › Milestone" | No project, No milestone |
| Initiative | the initiatives of the issue's project (a project in two initiatives puts its issues in both) | No initiative |
| Cycle, Team | the cycle (oldest first); the team | No cycle |
| Parent issue | the parent, named "ENG-12 Title" (a parent in a private team you can't see is "Private issue") | No parent |
| Customer | the customers who asked (an issue counts once for each) | No customer |
| Source | how the issue arrived: App, API, Agent, Support, Forms, GitHub, Recurring… | No source (issues made before sources were recorded) |
| SLA status | Breached, At risk, On track, Met, as the `sla` filter reads them now | No SLA (or canceled without breaching) |

### Dates

For issue count, effort and customer requests the date both places an issue in the window and on the time axis:

- **Created**: every issue, on the day it was created.
- **Started**: every issue with a start stamp, whatever its state now, on the day it started. Moving an issue back to
  the backlog clears its start stamp, so it leaves this chart until it starts again.
- **Completed**: the issues completed now, on the day they were completed. **Canceled** likewise.
- **Updated**: every issue, on the day it last changed in any way.

The durations keep their own dates: cycle and lead time and time in status the completion, triage time when the
issue left triage, SLA breaches when they breached.

### Windows and buckets

Besides the last 7 days to two years, the API takes a custom range: `since=2026-01-01&until=2026-09-30` counts exactly
those days (UTC, both included, at most 730 days; days after now count nothing). Buckets are days, weeks (Monday to
Sunday), calendar months or calendar quarters (January, April, July and October), all UTC; a bucket that starts
before the range counts only the range's days. `compare=previous` also answers the window just before (as long,
ending where this one starts) as `prev`, for a change against the last period.

`archived=include` counts archived issues too (as a list's "show archived" does), and `noPriority=exclude` leaves out
issues with no priority.

### Export as CSV

`format=csv` on the insight (or on its cumulative flow) downloads the chart's numbers as a CSV file that opens in any
spreadsheet: a header row with the slice's name, one column per segment (or the measure's name when there is no
segment) and Total, then one row per bar in the chart's order. Durations are the medians in hours with one decimal,
with `p50_hours` and `p90_hours` columns when there is no segment. A name that a spreadsheet would run as a formula
(starting with `=`, `+`, `-` or `@`) is written with a leading apostrophe.

### From a bar to a list filter

In the dock, clicking a bar, a segment of a stacked bar, a table row or a time bucket (or Alt-clicking a legend entry)
filters the list beside it to exactly those issues. A chip at the start of the filter bar names it ("Insight: High ·
Started") with how many of the list's issues it keeps; `×` on the chip clears it, and so does `Esc` on the list when
nothing nearer is open (a peek, a selection). The filter is added to the list's own filters, so the list's grouping and
order still apply. When a click can't be a list filter (below), the panel lists the issues under the chart instead and
says why; hovering such a bar says so first. In full screen, and on the project tab and the workspace page (no list
beside them), clicks always list the issues in the panel.

`drillFilter` (`lib/tasks/insights-pure.ts`) turns a bar, a segment or a cell into a list filter that shows exactly
the issues behind it: the field's value (or "is empty" for no value), the window on the measure's date (narrowed to
the bucket for a time bar: from its first day up to the next bucket's, cut to the window), completed issues for
completion dates and lead time, open issues for age, and no-priority issues left out when the insight leaves them
out. The Started and Canceled dates filter on the list's start and cancel dates (canceled issues only for the
latter). An initiative filters the list to the issues whose project is in it ("No initiative": projects in none, or
no project). Some groups have no list filter, and open as a list of issues inside the panel instead: Customer, cycle
time (an imported issue can be completed without a start stamp), triage time, SLA breaches, time in status (the time
finished issues spent in past statuses; the list's Time in status filter reads the current one), reopens and blocked
time (they need history the filter can't read), Other, and any chart that counts archived issues (the list doesn't
show them).

### Time in status

How long the issues completed in the window spent in each workflow status before they were done: the median, the
90th percentile and the mean per status, in your workflow's order. An issue that went back to a status counts every
visit, added up. The status the issue finished in isn't counted (it never left it).

Status is always on the chart: as the slice (one bar per status, the default) or as the segment (for example,
slice by time for each status's median per week, or by assignee for each person's time in each status). Picking
neither moves status to the slice. There is no scatter for this measure. The totals show the issues finished and
the statuses they passed through; click a status to list its issues, the longest first.

### Reopened

Each time an issue moved from a completed or canceled status to any other status counts as one reopen, on the day it
happened (UTC). An issue reopened twice in the window counts twice. Bars and the table show reopens; the issue count
beside them is how many issues were reopened. Slices and segments read the issue as it is now (its assignee, labels,
status), as for issue count. A move from done to canceled, or between two open statuses, is not a reopen. Clicking a
bar lists its issues, the most reopened first, with how many times. **Compare with the previous period** works as for
the other measures.

### Blocked time

How long, inside the window, each issue was open while at least one of the issues blocking it was open. Two
blockers at once count once: an issue blocked by A from the 3rd to the 5th and by B from the 4th to the 6th was
blocked three days, not four. A block counts while:

- the "blocked by" relation stood: from when it was added until it was removed (or until the blocker was deleted),
- the blocker was not in a completed or canceled status (a blocker that is reopened blocks again), and
- the blocked issue itself was not completed or canceled.

The bars are the median, with the 25th, 75th, 90th and 95th percentiles in the table, as for cycle time; the scatter
shows one dot per blocked issue. On a time axis an issue sits in the bucket where it was last blocked inside the
window. Issues never blocked in the window are not counted.

### Cumulative flow

Pick **Burn-up** at the end of the Slice list to see how the view's work moved: at the end of each day of the window,
how many of its issues were in each state type (Completed and Canceled at the bottom, then Started, Unstarted,
Backlog and Triage), stacked. A widening Started band means work is piling up in progress; a flat Completed band
means nothing is finishing. Click a legend entry to hide or show its band (Shift-click shows only it). The table
under the chart has each state type at the start of the window, now, and the change. Days are UTC, and today's
values are as of now.

### Where the history comes from

Time in status, the cumulative flow, reopens and blocked time read each issue's history: the status changes and the
relations added and removed that Tasks records in its activity (from the app, MCP, the API, GitHub and automations).
An issue starts in the status its first change moved it out of (or the status it is in now, if it never moved), from
the moment it was created. What is approximate:

- **Issues moved in from Linear** bring their status history with Linear's times. Issues from other tools (and from a
  Linear import without history) carry none: until they move in Tasks, they count as having sat in their imported
  status since their creation date, and none of their earlier reopens is known. Relations are recreated on the day
  of the move, so blocked time before it is not known either. When such an issue is in the view and its move falls
  inside the window, the panel says from which day the history is complete (`historyFrom` in the API) rather than
  show a quiet zero before it.
- **A deleted blocker** ends its block when it was deleted (recorded since migration 0319, 13 November 2026). A
  blocker deleted before then left no record of when, so its block is left out. A deleted blocker's own status
  history is gone with it: it counts as open until it was deleted.
- **A deleted status**: time spent there shows as "Deleted status", and the cumulative flow leaves those days out
  for the issues that were in it (they reappear when they moved on).
- **A status whose type changed** (say, from Unstarted to Started) counts as its type now, for the whole history.

### Drill down

Where there is no list beside the panel, or the click can't be a list filter, a table row, a bar, a time bucket or a
legend entry lists the issues behind it (the longest first for a
duration, the newest first otherwise, up to 250). Click an issue to open it; **Back** returns to the table. Other is
the rest folded together, so it can't be opened: slice by that field to see its parts.

## Projects and cycles

A project's Insights tab and a cycle's page add three charts of their own. Switch between **Issues** and **Points**
(here an unestimated issue counts 1, or 0 when its team does not count unestimated issues, as in a project's progress).

- **Burn-up**: at the end of each day since the start date (the project's start date, else the day it was created;
  the cycle's first day), how many issues were in scope, started and completed. An issue counts while it was in the
  project or cycle: moving it in or out moves the scope line on that day. A canceled issue leaves the scope on the day
  it was canceled. A cycle shows this chart from its daily snapshot, above.
- **Scope change**: the scope at the end of the first day against now, the issues added and removed after it, and the
  percentage change, with a bar chart of what joined and left per week (a project) or per day (a cycle).
- **Velocity**: issues and points completed per week over the last twelve weeks (a project; only what was in the
  project when it was completed counts), or per cycle over the team's last six cycles (a cycle; a finished cycle counts
  what its last snapshot recorded). The dashed line is the average of the finished periods; the current one is paler
  and not in the average.

The API also answers these, in points when the team (for a project, any of its teams) uses estimates, else in issues;
an unestimated issue counts 1 point (0 when its team turns [Count unestimated issues as one point](/docs/cloud/tasks-planning.md#estimates) off):

- **Target line** (cycles): for each day of the cycle, how much should be done by its end to finish on time. The scope
  is spread evenly over the cycle's working days (Monday to Friday, UTC): by the end of a day, the scope that day
  times the share of working days passed. Saturdays and Sundays add nothing, so the line is flat on them, and it
  reaches the whole scope on the last working day. When the scope grows, the rest of the line rises with it. The
  cycle is **on track** when what is completed is at or above the target for today.
- **Projection** (projects and cycles): the pace is the work completed over the last 14 days (a cycle: since it
  started, if later) per working day; the finish date is today plus the remaining work (in the project or cycle now,
  neither completed nor canceled) at that pace, counted in working days. No work completed means no date; nothing
  remaining means today.
- **Capacity** (an upcoming or running cycle): the average completed in the team's previous three completed cycles,
  against what is planned in this one now.

A cycle's burn-up draws them: the target as a dashed line over every day of the cycle, the projection as a dotted line
from today to the projected finish with its end marked **On track** (it finishes by the cycle's last day) or **N days
late** (calendar days past the last day; the line then stops at the last day, at the value the pace reaches by then),
and capacity as a faint level. The projection is drawn only once its pace window has at least 3 working days and 2
issues (or points) completed in them, and only in the unit it was counted in; otherwise the chart says why there is
none. Hover the legend for how each is computed. Under the charts, a finished cycle shows its success and a running or
upcoming one what is planned against capacity ("Planned 34 of ~28 points"), in a warning colour when it is more than
the team has been finishing. On the cycle page, ←/→ on the focused burn-up move a day cursor that reads that day's
scope, started, completed and target.
- **Success** (a finished cycle): completed work plus a quarter of the work started but not finished, over the scope
  at the end of the cycle, in percent.

## Speed and limits

- One grouped database query answers the chart, the table and the totals; the scatter, a drill-down and the
  cumulative flow are one more each. An insight that takes longer than 8 seconds stops with "This insight took too
  long": narrow the view or the window. Time in status and the cumulative flow read each issue's status changes
  through an index; for a team with 50,000 issues they take well under a second even over two years.
- The numbers come from the timestamps Tasks stamps as an issue moves between states and from its activity history
  (project, cycle and state changes). Nothing is stored for Insights and nothing leaves your cloud.

## For agents and scripts

- REST: `GET /tasks/api/insights` takes a list's own filter parameters plus `measure`, `slice`, `segment`, `chart`,
  `date`, `days` (or `since` and `until`), `bucket`, `labelGroup`, `archived`, `noPriority`, `compare` and `format`,
  and `drill={"x":…,"seg":…}` for the issues behind a group (`measure=timeInStatus` for time in status). The
  cumulative flow is `GET /tasks/api/insights/flow` with the same filters, `days` (or `since` and `until`), `bucket`,
  `archived` and `format`. A project's
  or cycle's charts are `GET /tasks/api/projects/{id}/insights` and `GET /tasks/api/cycles/{id}/insights`. See the
  [Tasks API](/docs/cloud/tasks-api.md), which takes the console's session cookie.
- MCP (`/tasks/mcp`), for agents: `tasks_insight_get`, `tasks_flow_insight_get`, `tasks_project_insight_get` and
  `tasks_cycle_insight_get`; `format: "csv"` on the first two answers the CSV as text. The workspace REST API (`/api/v1`) has the same tools under `/tasks/…`, for example
  `GET /api/v1/tasks/insights/flow`.
- Saved insights: `/tasks/api/saved-insights` and the `tasks_saved_insight_*` tools ([Dashboards](/docs/cloud/tasks-dashboards.md)).

```bash
# Median cycle time per assignee in team ENG over the last 90 days, from a signed-in session.
curl -s -b "venom_cloud_session=…" \
  "https://cloud.usevenom.dev/tasks/api/insights?team=ENG&measure=cycleTime&slice=assignee&days=90"

# Median time in each status for ENG's issues finished in the last 30 days, then its cumulative flow.
curl -s -b "venom_cloud_session=…" "https://cloud.usevenom.dev/tasks/api/insights?team=ENG&measure=timeInStatus&days=30"
curl -s -b "venom_cloud_session=…" "https://cloud.usevenom.dev/tasks/api/insights/flow?team=ENG&days=30"

# Issues started per quarter this year, split by initiative, as a CSV file.
curl -s -b "venom_cloud_session=…" -o started.csv \
  "https://cloud.usevenom.dev/tasks/api/insights?team=ENG&date=started&slice=time&bucket=quarter&since=2026-01-01&until=2026-09-30&segment=initiative&format=csv"
```
