# Regular Scope — Rules

Scope: Regular/Hard lines for pilots. Ruleset:
`src/rulesets/regular-rca-pilot-2025.json`.

## Line construction (contract)

| Rule | Source |
|---|---|
| Credit Window minimum = MMG (75:00); maximum = highest value possible, including buffers | CBA Art. 6.G.3.b (printed 6-14, PDF p. 78) |
| If the average line value exceeds the required average by ≥ 1 hour, the Company may lower the maximum Credit Window to no lower than 105 hours | CBA Art. 6.G.3.b.i (printed 6-15, PDF p. 79) |
| No pilot awarded less than minimum Days Off in base; otherwise a Partial Line may be constructed | CBA Art. 6.G.3.c |
| Line types: Hard Line, SDP Line, Composite Line, Reserve Line | CBA Art. 6.G.2 (printed 6-14, PDF p. 78) |
| Days off: 12 minimum; two groups of 3 consecutive; all other groups ≥ 2 except month edges | CBA Art. 23.E.1–2 (printed 23-3, PDF p. 267) |
| Max 6 consecutive duty days (30 free hours in any 168) | CBA Art. 23.B.3 (printed 23-1, PDF p. 266) |
| Trip pairings ≤ 5 calendar days and ≤ 108 h TAFB | CBA Art. 23.C.8 |
| Max 6 legs per duty period (8 with Committee concurrence) | CBA Art. 23.C.9 |
| FDP/block limits: 9 block h/duty, 100 block h/672 h, 60 FDP h/168 h, 190 FDP h/672 h | CBA Art. 23.D |

## CrewPBS Regular-scope constructs

Menu availability is verified against the live CrewPBS Regular tab; the full
catalog with displayed descriptions lives in
[`docs/pbs-options-catalog.md`](../pbs-options-catalog.md). Construct catalog
background: Handbook Appendix 3, pp. 20–26. The output generator must emit
only options that exist in the scope:

| Construct | Applies to | Source |
|---|---|---|
| Specific Date Off, Period Of Dates Off, String of Dates Off, Day Of Week Off, Period Of Days Off, String of Days Off, As Many Weekends Off | Regular + Reserve | Handbook App. 3; live catalog |
| Partial* variants, Consecutive Days Off | Regular + Reserve (Avoid-only; partials Regular-only) | Handbook App. 3; live catalog |
| Days Off (maximize days off) | **Regular only** | live catalog |
| Work on Date | **Regular only** | semantics notes §0.20; live catalog |
| Consecutive Working Days | **both scopes** | live catalog |
| Line Credit Value | **Regular only**; < 75:00 silently ignored | Handbook p. 7, §0.9; notes §0.20 |
| Maximize Hour Per Day | **Regular only**; analyzer looks at individual pairing, not the month | Handbook App. 3 p. 26 |
| Load Schedule (Beginning/Middle/End) | **both scopes**; conflicts with early-month protected windows | Handbook App. 3; notes §0.24; live catalog |
| Reserve Line | **Regular-scope request**; hard override, can be used once per bid, sending you to reserve and using the reserve bid | Handbook App. 3 p. 23; FAQ Q39 |
| Pairings / Pairing Credit Per Day / Time Away From Base / Fly With | Regular scope; Desire + Avoid semantics | Handbook App. 3 pp. 25–26; live catalog |

## Bid pattern used by the Committee (worked example)

For any protected window, layer in this order:

1. `Period Of Dates Off` — all-or-nothing reach (for a single day, use
   `Specific Date Off` instead).
2. `String Of Dates Off` — run from the hard anchor date.
3. `Avoid Work On`, one line per date, most important first (Regular only).
4. Narrower `String` lines as a fallback ladder.
5. Waivers aligned with the actual goal (3-day blocks; singles on Reserve).

Source: `PBS/Bid-Audit-December-2026-Worked-Example.md` §4 (Committee-reviewed
Nov 2026). The planner's "advanced output" mode should reproduce this pattern;
"parity" mode reproduces the original tool's simpler output.

## Pairing data (P3)

Monthly pairing printouts are PDFs with a repeatable text layout:

- Section header: `December 2026 Pilot ALL Pairings DEC 1 - DEC 31, 2026 - BOS`
- Pairing record: `B####  BASE REPT: hhmmL`, a mini-calendar grid whose single
  numeric cell is the pairing start date, leg lines, `D-END`/`FDP` lines,
  hotel lines, `STANDOVER DAY hhmm`, and a `TOTALS BLK … CDT … T.A.F.B. …`
  summary.
- Times are local; block time must be read from `BLKT` columns, never derived
  from clock times (timezone crossings).

Implementation: `src/parsers/pairings.js` is a tolerant, line-oriented
parser. It derives start dates from the mini-calendar grid, validates the
first leg's weekday against the document month, and records start date, legs,
duty days, hotels, standovers, span days, and pairing totals in minutes.

Parsing tolerances (all observed in real printouts):

- the `REPT:` field is missing on the final `D-END:` line of many pairings
- the `GRNT` column is omitted on the last leg of a duty day
- trailing `TBLK/TCRD/TPAY/DUTY/LAYO` values may be absent or dashes
- page headers repeat mid-file; extractor `===== PAGE n =====` markers are ignored
- pairing printouts are two-up: two pairing columns side by side. PDF
  extraction splits them by x-position clustering and emits each column
  sequentially
- the calendar mini-grid can sit beside the first leg lines rather than below
  the `Base :` row; numeric grid cells on leg rows are collected as start days
- weekday glyphs are sometimes encoded as a digit (`1`) in the PDF text;
  legs without a readable weekday token are accepted and duty days are grouped
  by `D-END` lines instead
- pairings may have multiple start dates (several numbers in the mini-grid);
  they are stored as `startDays` / `startDates`
- `TOTALS` lines may use `PRG CRED:` instead of `TRIP RIG:`, and TAFB can be
  five digits (e.g. `10025` = 100:25)
- `TBD` placeholder lines are ignored
- section headers may appear inside surrounding text (e.g. a page footer)
- unrelated lines outside pairings are ignored; only pairing-like lines warn
- CRLF input is normalized

Problems never throw: malformed lines become warnings (`UNRECOGNIZED_LINE`,
`MISSING_TOTALS`, `WEEKDAY_MISMATCH`, `MISSING_START_DAY`, …) with line numbers.

PDF ingestion has two adapters over the same text parser:

- offline: `tools/pdf-to-txt/extract.py --layout` (pdfplumber, layout-preserving)
- in-browser: PDF.js (`vendor/pdfjs`, Apache-2.0) reconstructs text from item
  positions; used by the `<pairing-import>` preview component

Preview page: `examples/pairing-import.html`. Fixtures and committed tests use
synthetic pairings only; real monthly pairing files never enter the repository.

Verified against the December 2026 BOS printout (371 pages): 4,158 pairings
parsed with zero warnings. The source PDF is kept in gitignored `reference/`.

## Open questions

1. Whether to model Composite lines (`RAP/RCP + pairing`) in v1 — currently
   out of scope.
2. Personal Credit Threshold: Handbook states it does not exist in CrewPBS
   (p. 8); do not model.
3. Load Schedule guidance is advisory — emit a warning, never auto-select.
4. Pairing selection needs the "Reserve Down To" and trip-selection
   interaction verified with the Committee before output claims are made.

## Trip instances and selection analysis (P4a)

A **trip instance** is one dated occurrence of a pairing: pairing ID + start
date. Multi-date pairings (several grid days) produce one instance per start
date, because weekends and commutes differ by date.

Derived fields: start/end date, span days, report/release minutes, credit
(minutes and hours), credit per calendar day, TAFB, block, landings, deadhead
legs, legs/duty, duty days, hotels, standovers, airports, weekend touch, and
cross-midnight flag.

**Duty periods.** Each pairing also carries one duty period per flying day
(`dutyPeriods`), built from `dutyDays` + `dutyEnds` in
`buildDutyPeriods(pairing)` (src/core/trip-instances.js). Report times follow
the printout convention: duty 0 reports at the pairing `REPT:` time and every
later duty reports at the `REPT:` time printed on the previous `D-END:` line.
The duty's calendar day is the trip start date plus a `dayOffset` that the
parser accumulates across flying days and standover nights
(src/parsers/pairings.js): a duty placed after k standover nights lands
k+1 days after the previous duty. A release earlier than its duty's report
belongs to the following calendar day (release crossed midnight);
`tripReportRelease(instance)` in src/core/legality.js applies the same
day-boundary normalization to the trip-level report/release used for rest
checks. The crossed-midnight calendar day is still counted as a work day for
day-off purposes, because the pairing occupies it until release.

`analyzeTripSelection` checks a selected set of instances against a bid month:

- no overlapping trip dates
- credit window: minimum 75h (contract), planning maximum 100h by default
  (an option, since the contract's maximum is "highest value possible")
- at least 12 days off in the month
- no more than 6 consecutive work days
- off-block notices: single-off waiver, 3-day block waivers, combine-to-6
- notices for trips that extend outside the bid month

`selectionFromTrips` converts a selection into a day-state selection;
`buildRegularSkeleton` generates the Regular-scope preference skeleton
(Period/String per off run plus per-date Work on Date) from a valid selection.

Verified against the December 2026 BOS printout: 4,158 pairings → 5,401 trip
instances (517 multi-date pairings), 0 skipped; 55% of instances are
weekend-free, average credit/day 5.74h.

## Regular planner and desirability algorithm (P4b)

### Schedule-first workspace

The default Regular workspace is **Schedules**. The legacy Basic/Advanced
behaviors below remain available under More planning tools. The schedule-first
implementation uses `src/core/schedule-planning.js` for generation, edit previews
and acceptance, and `src/core/schedule-bid.js` for chosen-scenario compilation.

- Required goals constrain candidates; preferences rank complete combinations.
  Credit, overlap, base, rest, days off, work streaks and rolling-window checks
  use the existing cited limits. Off-block waiver consent is explicit. Without
  consent to combining blocks, two separate off runs of at least three days are
  required; allowing combination uses the existing six-day-block accounting.
- Search is a bounded, diversity-preserving beam, not a full Pareto solver.
  A stable credit/span-diverse daily shortlist and a completion-aware frontier
  (credit room, work days, streak, last duty day, release, off-block progress)
  keep large bases from collapsing into one long off run. A budget-limited pass
  that finds nothing widens automatically once. A bad combination does not ban
  its pairings, and a zero result reports why (no trips, credit minimum
  unreachable, search limit, or no completion) rather than implying
  infeasibility.
- Every replacement is evaluated in its receiving schedule. All displaced
  pairings are listed; locks are respected, and invalid experiments remain
  drafts that cannot be exported.
- Coverage explicitly identifies missing rest times, prior/next-month history,
  local printed-time assumptions, incomplete domicile 0200/time-zone semantics
  and unverified full FAR coverage. These gaps never become passing checks.
- Copy review shows the actual sequence. Dated pairing requests and explicitly
  allowed off-block options are marked for session verification and omitted
  from default copy/download. Whole-schedule productivity/day-off optimization
  remains a local objective, and the chosen schedule is never described as an
  atomic CrewPBS request.

See [ADR 0002](../adr/0002-schedule-first-regular-workspace.md) and the
[user guide](../user-guide.md#planning-a-regular-line).

The Regular planner UI is `examples/regular.html` (`src/ui/regular-planner.js`).
It imports pairing text/PDF, builds trip instances, filters by base/date/times/
credit/weekend/deadheads, scores trips with an editable algorithm, and supports
a demo bid made of selected trips plus protected off-day windows.

### Scoring defaults (`src/rulesets/desirability-rca-pilot-2025.json`)

- Four commutability tiers, best to worst: More, Middle Upper, Middle, Less.
  Each end of the trip is tiered; the trip takes the weaker end. Cutoffs are
  editable in the UI.
- Features and default weights: commutable 3, credit/day 3, weekends off 2,
  multi-day 2.
- Credit/day = total credit ÷ calendar days (span), normalized between the
  configurable target range (default 3.5–6.5h).
- The multi-day weight is ignored when the "I commute to base" profile is off.
- The match score is a weighted average (0–100) with per-feature contributions
  shown in the trip popover. It expresses how well a trip fits the crew
  member's own priorities.
- Popularity ("popular assumptions") is a separate weighted-average model with
  its own rule weights (`popularity.weights` in the ruleset). Competition
  bands (Very high/High/Medium/Low) come from the popularity score, so they
  never move when a crew member changes their own weights. Popularity weights
  are assumed aggregate demand, not measured data.
- Releases after midnight are treated as late (next-day time) for
  commutability.

### Demo bid and advice

- Selected trips are validated for base mismatch, overlaps, protected dates,
  credit window (75h minimum, 100h planning maximum by default), 12 days off,
  and 6 consecutive work days.
- Advice suggests concrete additions/removals, weekend-free alternatives,
  multi-day alternatives for commuters, more commutable options, and fallback
  planning when selected trips are high-competition.
- The line skeleton is generated from the demo line's off runs (Period/String
  plus per-date Work on Date).
- Overlapping selected trips are grouped as ranked alternatives when the
  `ranked` option is enabled: the first selected trip in the group is the
  primary choice, and the rest are fallbacks. Ranking follows selection
  order, not start date.
- Each alternative is validated against the backbone and the primary choices of
  other groups. If choosing it would cause a blocking violation (rest < 10h,
  fewer than 12 days off, more than 6 consecutive work days, protected-date
  conflict, or base mismatch), it is marked illegal and cannot be ranked until
  removed. Credit is **controlling**: the primary selection and every ranked
  alternative must fall within the configured minimum/planning-maximum window,
  or the skeleton is blocked. Differences within that window are reported as a
  range.
- The generated skeleton starts with `Pairing Name` preference lines in rank
  order (`first choice`, `alternative 1`, …) and then the off-day skeleton
  derived from the primary choice.
- Overlap, protected-date, base-mismatch, rest, and illegal-alternative
  violations carry the affected trip IDs (`conflictTripIds`) so the UI can
  offer one-click removals.
- Protected off days accept a single date or a range. The trip calendar marks
  them as blocked (`OFF`) whether or not trips are selected; a selected trip
  touching a protected date is flagged as a conflict.
- With the weekend-free filter enabled, the calendar shades weekend cells so
  the excluded days are visible while the pool is filtered.
- Ranked alternatives can be reordered by dragging a calendar event onto a
  directly overlapping trip or another member of the same alternative group;
  the swap changes the selection order and therefore the generated ranking.
  Red/illegal events are not draggable and are removed by clicking.
- Selected trips are rendered on a month calendar: green events are
  conflict-free, red events belong to a conflicting trip. Clicking an event
  removes that trip from the demo bid.

### Plan persistence (P7)

The Regular planner autosaves a de-identified plan snapshot in local storage:
bid month, dataset identity (id, origin, bid month), mode and Basic style,
goals, weights, filters, protected dates, excluded pairings, and selected trip
ids in priority order. On load, the snapshot is restored only when the pairing
dataset matches (`src/adapters/regular-plan.js`). A month mismatch or a
different published dataset refuses the restore; manual-import plans restore
with a provenance warning. No employee number, raw printout, or generated bid
text is stored in the snapshot beyond trip ids.

### Seniority prediction (P6)

The data path is implemented: the Crew Staffing list is parsed keeping only
`Base Sen`, `Crew Id`, `Seniority`, and the current position triplet
(base/equipment/seat) — names, status, DOH, and the previous position are
dropped. Crew Ids are replaced by unsalted SHA-256 digests in the published
dataset (`src/parsers/staffing.js`, `src/adapters/seniority.js`). The dataset
is published as `data/seniority.json` next to the planner page; the planner
fetches it and crew members only enter their employee number, which is hashed
on their device and never stored. The planner shows the member's Base Sen with
their base (e.g. "Base Sen 5 (BOS)") and company-wide Seniority, and selects
their base in the Base filter when the bid package includes it.

- `Base Sen` ranks crew within a base/aircraft/seat section (1 = most senior
  in the section); `Seniority` is the company-wide rank.
  `percentileFromBaseSen` maps a rank to a strength percentile (1 = most
  senior, 0 = most junior).
- The config carries a logistic curve (`seniority.curveSteepness`,
  `curveOffset`) and prediction bands; wiring the percentile into predictions
  and advice is the next step, and its output is an estimate, never a
  guarantee.
- The bid-package forecast is the first shipped consumer of the position and
  bidding-pool data; see [`docs/rules/forecast.md`](forecast.md). Desirability
  and bid-advice predictions remain separate work from that forecast.
- Until the wiring lands, competition labels reflect assumed popularity for
  the filtered pool only.

## Basic mode preference generation (P4c)

Basic applies the shared filters and produces CrewPBS-formatted bid lines; it
does not select a schedule.

- **General bid preferences** map filters to Conditions-style lines using the
  exact option titles from the CrewPBS menus:
  - protected dates → `Specific Date Off`, `Period Of Dates Off`,
    `String of Dates Off`, and per-date `Work on Date: Avoid …`;
  - credit goal → `Line Credit Value`;
  - weekend-free → `As Many Weekends Off`;
  - no deadheads → `Deadhead Flights: Avoid`;
  - min credit/day → `Pairing Credit Per Day`;
  - report/release windows → `Report Time` / `Release Time`;
  - multi-day goal → `Pairing Length in Days`.
- **Trip bid preferences** list **all filtered trips**, grouped by pairing with
  one line per pairing for its start dates:
  `Pairing Name` plus `Specific Pairing Starting on Date(s)`. The compiled
  bid package also carries the shared goals ahead of those fallback lines:
  protected off days (`Specific Date Off`, `Period Of Dates Off`,
  `String of Dates Off`, per-date `Work on Date: Avoid`), the credit window
  (`Line Credit Value`), and `Consecutive Working Days` from the ruleset
  limit. Pairing lines are marked session-gated and unverified because the live
  menu only offers them inside an open bid session. Group order in the copied
  text follows the best match score; score numbers are not included.
  Competition labels (popularity-based) are side details.
- A feasibility solver checks the filtered pool against the credit window,
  10h rest, 12 days off, 6 consecutive work days, base, protected dates, and
  multi-day filtering. No locally feasible line → no bid lines.
- When infeasible, ordered one-click relaxations are offered (credit window,
  deadheads, weekend filter, credit/day, airport, pairing, protected days,
  day trips).
- Basic and Advanced share filters, goals, and protected days; the selected
  planning mode is remembered locally.

Advanced skeletons now use the same CrewPBS wording (`Work on Date: Avoid …`);
rank labels such as “first choice” are shown in the UI rather than embedded in
the bid line. The advanced skeleton also emits `Line Credit Value` from the
credit goal and `Consecutive Working Days` from the ruleset limit, and it
returns a structured bid package that links each generated line to its source
intent, polarity assumption, priority class, and verification state.

Both Basic styles and the Advanced skeleton now produce the same structured
bid package (intent -> line -> verification state). Copy uses the package's
single compiled text, which preserves the generator's priority order; the UI
groups the same lines by request class for review only, labeled Must-have
requests / Strong preferences / Preferred conditions / Backup requests /
Shared Planning Session options (internal keys remain
required/strong/preferred/fallback/shared-option). Goal importance is separate
from request class: importance (Must have/Strong/Preferred/Backup) sets the
goal's hardness and copy gating, while the per-line class controls sectioning.
Review details also name the originating goal and visible polarity for each
request (for example "Goal: Minimum credit · Prefer"). Basic and Advanced remain separate
workflows but compile through one semantic contract.

Session-gated lines (currently `Pairing Name` and
`Specific Pairing Starting on Date(s)`) are marked unverified in the package.
Default Copy excludes them; a second copy action includes them for sessions
where the live menu exposes the construct. The credit window is compiled as two
intents: a contractual minimum (75:00) and a local planning maximum, so the
evidence label never presents the planning ceiling as contract text. The base
filter is a local-only limitation only when the user overrides the default or
seniority-derived base.

Analysis now returns a rule-coverage list plus per-trip diagnostics. Modeled
checks report `pass` or `fail`; rules that cannot be evaluated from the parsed
data report `estimated`. No Regular line rule reports `not-modeled`; rules
without a data path (Reserve RAP/carryover) stay `not-modeled` in the Reserve
scope only.

Published pairings are pre-audited by the committee, so pairing-internal limits
(T.A.F.B. ≤ 108h, span ≤ 5 days, legs/duty, scheduled duty ≤ 14h, FDP vs the
pairing's own printed limit, ≤ 9 block hours per duty) are only re-checked as
the advisory `regular.pairing-data-consistency` rule: a failure is a
data-quality warning about the source document, not a legality rejection, and
it never blocks a candidate by itself.

What the planner enforces are the combination-level windows that only exist
once pairings are combined into one line (src/core/legality.js, thresholds from
the ruleset `fdpBlock` section):

- `regular.block-hours-672`: at most 100 block hours in any 672-hour window
  (CBA Art. 23.D); per-duty block read from the printed duty-day totals.
- `regular.fdp-hours-168`: at most 60 FDP hours in any 168-hour window
  (CBA Art. 23.D); per-duty FDP read from the printed `D-END:` lines.
- `regular.fdp-hours-672`: at most 190 FDP hours in any 672-hour window
  (CBA Art. 23.D).
- `regular.free-hours-168`: at least 30 free hours in any 168-hour window
  (CBA Art. 23.B.3), evaluated directly over duty-period report/release
  intervals instead of being approximated by the consecutive-day check.

**Window attribution (local-only).** Block and FDP hours are attributed to the
window containing the duty period's report time, and a duty counts fully toward
exactly one window position. Windows are evaluated at each duty start and at
each duty start minus the window length, which is exact for that attribution
model. Deviation from a literal hours-in-window reading is bounded by one duty
period (~16h FDP, ~9h block) and only matters within one duty of a limit; the
coverage sources are marked `local-only`, and compiled bid packages carry a
`local-only` limitation whenever the window checks ran. Free hours are computed
from actual duty intervals and count partial overlap exactly.

Window checks degrade to `estimated` when any selected pairing lacks complete
duty-period data (missing report/release, mis-ordered or out-of-range duty
offsets, or a duty-day/D-END count mismatch); partial data is never
silently dropped from the window sums. The feasibility solver
(`findFeasibleLine`) retries around window violations by banning only the
contributing instances (bounded attempts) before reporting `AGGREGATE`
infeasibility. Advisory `pairing-data-consistency` failures render separately
from hard failures in the UI. The UI must not describe a candidate as simply
“legal” when unresolved rules remain.

## Basic mode eligible pool and weight mappings (P4d)

**Eligible pool.** Basic derives one pool used by feasibility, Trip
preferences, the Basic calendar, and prediction:

shared filters → multi-day-only (when checked) → remove protected-date touches
→ remove excluded pairings.

Protected days therefore never appear as trip preferences or calendar events;
they appear as blocked OFF cells and as General time-off conditions.

**Live behavior.** Basic filters auto-apply (~250 ms debounce); protected
add/remove is immediate; Reset clears filters, protected days, and exclusions.
Advanced keeps its Apply button.

**Basic calendar.** Read-only month calendar of eligible trips, with protected
days, weekend shading when Weekend-free is active, per-cell chip caps (3 + “+N
more”), and click-only pairing details. Drag/ranking remains Advanced-only.

**Exclude/restore.** Excluding a pairing removes all of its instances from the
eligible pool, preferences, calendar, feasibility, and prediction; a Restore
list reverses it. When exclusions cause infeasibility, a Restore relaxation is
offered.

**Basic preference controls.** Controls start at 0 (no filter). Raising one
narrows the eligible pool in both General and Trip styles, and the status
reports how many trips each filter removed:

- Commutable: report ≥ interpolated threshold and release ≤ interpolated
  threshold (cross-midnight releases count as next-day).
- Credit/day: credit per day ≥ interpolated target.
- Weekends off: limits weekend days per trip (weight 1–2 allows 1, weight 3+
  allows 0).
- Multi-day: trip span must exceed the selected day count.

The same control values generate General preference lines (below). Advanced
uses its own algorithm weights and does not apply these filters. The control
sliders set match weights and filters only; competition labels derive from the
ruleset's popularity model and are unaffected by them.

**Control → General conditions.** Controls are preference strength (0–5),
except Multi-day, which is a literal day count:

| Control | Generated line(s) |
|---|---|
| Commutable | `Work Period Report Time: After HH:MM`, `Work Period Release Time: Before HH:MM` — report/release interpolated between the weakest and strongest commutability tiers, rounded to 15 minutes |
| Credit per day | `Pairing Credit Per Day: > X.Xh` — interpolated between productivity min and max, rounded to 0.1h |
| Weekends off | `As Many Weekends Off` when weight > 0 |
| Multi-day | `Pairing Length in Days: > N` where N is the selected number of days (0 = off). The same day count filters the eligible trip list in both styles. |

A weight line is suppressed when a filter already emits the same construct
(e.g., Weekend-free + As Many Weekends Off, credit/day filter + Pairing Credit
Per Day, multi-day-only + Pairing Length in Days). Commutable Work Period
options are distinct from filter Report/Release Time options.
