# Comment timeline

> Dashboard component reference for the Comment timeline, the operator comments of a unit's active run, with the add, rewrite and delete conduct.

The **Comment timeline** shows the operator comments of a unit's active run, oldest
first, each with its timestamp and the phase it was recorded in, plus an add box at the
foot. It is the unit panel's timeline brought to a screen (see [Process](process)). A
comment is part of the run record and can leave the station again in a report, so the
timeline also carries the two gestures that keep that record honest: rewriting a line
where it stands, and removing it.

This component is part of the Process family: it is not offered in the dashboard's Add
palette. It is placed by the Process workspace — a unit's screen hosts it, and a model's
screen template carries it with the unit resolved when a unit opens the screen.

## Properties {#properties}

| Property | What it does | Values | Default |
|---|---|---|---|
| Unit | The unit whose active run's comments this shows. The editor offers every unit of every model as `Model · Unit`. | a unit | none |

The unit is the whole binding — there is no address behind this component, and how the
timeline behaves at runtime is not configurable beyond it.

## What the header says {#what-the-header-says}

The header states what the timeline is reading: `Comments · <run name>` during an active
run, `Comments · no active run` while the unit is idle (the list is then empty),
`Comments (no unit)` while nothing is bound, and `Comments (unavailable)` where the
Process service is not running. Post-run notes are added from [Histories](histories), not
from this component.

The list refreshes from the run file on a throttle (about every three seconds, and
immediately when the run changes). A gesture the operator has open — a rewrite in
progress, an armed removal — holds the refresh so the line is not rewritten under his
hand; a run change is not held, because the run those gestures belonged to is gone.

## Adding a comment {#adding-a-comment}

Type into the add box and press **Add**. The button is enabled only while there is an
active run, the operator is permitted, and the draft is not blank. The comment is
recorded under the signed-in operator (or the station when nobody is signed in), because
a note is evidence too. A failure lands on the component's own answer line.

## Rewriting a comment {#rewriting-a-comment}

**Edit** opens the line in place, on the text as recorded. **Save** (or Enter) commits;
**Cancel** (or Escape) leaves the record as it was. A blank or unchanged text leaves the
record alone; a real rewrite stamps the edit and persists it. This is the same commit the
Histories grid applies to post-run comments.

## Deleting a comment {#deleting-a-comment}

Removing takes two presses, both in the line itself — an operating panel has no second
surface to open a dialog on, and a removed comment does not come back:

1. **Delete** arms the row. Nothing leaves the run file yet; the row asks
   `Delete this comment? This cannot be undone.`
2. The confirming **Delete** beside that question removes the comment. **Cancel** keeps
   it.

Arming one line disarms any other open gesture — a line asking to be removed is not also
being rewritten.

## Permission {#permission}

All three gestures pass the same composed authorization, rechecked at the moment of the
write, never only when the screen rendered:

- On a unit's Process screen, they take the **Run procedures** permission.
- On a dashboard, they take the **Dashboard operation** permission **and** the
  **Run procedures** permission, because the write reaches the run record.

While the operator may not mutate, the timeline stays readable, the add box and the
gestures are disabled, and each disabled control's tooltip carries the reason.