cursedbelt 2.8.0 → 3.0.0

package/src/core/analytics/range.ts

@@ -1,383 +0,0 @@
-/**
- * The time-range vocabulary every analytics surface shares — the presets, the
- * bucket size each one implies, and the bucketing itself.
- *
- * ── Why this is a shared primitive and not per-dashboard code ────────────────
- * Every dashboard needs "today / this week / this month", and every one that
- * hand-rolls it gets the same three things subtly wrong:
- *
- * 1. **"Today" is not "the last 24 hours."** The owner asking *"has the
- *    orchestrator done well today?"* means since midnight in THEIR timezone,
- *    against comparable earlier days. A rolling 24h window silently mixes last
- *    night into this morning and makes every day look average.
- * 2. **The bucket must follow the range.** Hourly buckets over 90 days is 2,160
- *    points nobody can read; daily buckets over one day is a single bar. The
- *    preset owns both, so a range change cannot leave a mismatched bucket
- *    behind.
- * 3. **A comparison needs a baseline of the same shape.** "42 tasks" answers
- *    nothing. "42, against a 7-day median of 26" answers the question that was
- *    actually asked — and the baseline has to be the same length as the range
- *    or the comparison is meaningless.
- *
- * Framework-free and DOM-free on purpose: the ENGINE computes with it and the
- * BROWSER renders with it, and they must bucket identically or a chart's x-axis
- * disagrees with its own tooltip.
- *
- * ── Local days, not UTC days ────────────────────────────────────────────────
- * Day boundaries come from the host's own calendar (`new Date(y, m, d)`), so a
- * day is the day the reader lived through. UTC bucketing would move "today" by
- * 5–6 hours in America/Chicago and put a normal evening's work on tomorrow.
- * 🔴 It follows that the ENGINE must be the one to bucket (it shares the
- * owner's timezone) — a prod box on UTC bucketing for a Chicago reader
- * reintroduces exactly this bug.
- */
-
-/**
- * The preset keys. `all` is unbounded-below — it starts at the first datum.
- *
- * `custom` is the one key with no fixed width: it takes explicit bounds from the
- * caller (`resolveRange(key, now, { custom })`) and picks its own bucket unit
- * from how wide those bounds are. It exists because the owner asked for it by
- * name — *"I want to be able to view all types of times (all time, this year,
- * this month, weeks days, custom times, etc)"* (2026-08-13) — and because a
- * dashboard whose narrowest question is "the last 7 days" cannot answer "what
- * happened during that incident on the 14th".
- */
-export type RangeKey = 'today' | 'week' | 'month' | 'quarter' | 'year' | 'all' | 'custom';
-
-/** How wide one bucket is. `day` is calendar-aligned; `hour` is clock-aligned. */
-export type BucketUnit = 'hour' | 'day';
-
-export interface RangePreset {
-  key: RangeKey;
-  /** Control label — short, because it sits in a segmented control. */
-  label: string;
-  /** What the range covers, for a tooltip or a subtitle. */
-  description: string;
-  unit: BucketUnit;
-  /**
-   * Whole days back from today, inclusive of today. `null` for `all`.
-   * `today` is 1 — itself.
-   */
-  days: number | null;
-}
-
-export const RANGE_PRESETS: readonly RangePreset[] = [
-  {
-    key: 'today',
-    label: 'Today',
-    description: 'Since midnight, by hour',
-    unit: 'hour',
-    days: 1,
-  },
-  { key: 'week', label: '7 days', description: 'The last 7 days, by day', unit: 'day', days: 7 },
-  {
-    key: 'month',
-    label: '30 days',
-    description: 'The last 30 days, by day',
-    unit: 'day',
-    days: 30,
-  },
-  {
-    key: 'quarter',
-    label: '90 days',
-    description: 'The last 90 days, by day',
-    unit: 'day',
-    days: 90,
-  },
-  {
-    key: 'year',
-    label: '1 year',
-    description: 'The last 365 days, by day',
-    unit: 'day',
-    days: 365,
-  },
-  { key: 'all', label: 'All', description: 'Everything on record, by day', unit: 'day', days: null },
-  {
-    key: 'custom',
-    label: 'Custom',
-    description: 'A range you pick',
-    unit: 'day',
-    // Not a width. `custom` is resolved from the caller's own bounds; `days` is
-    // null for the same reason `all`'s is — neither has one until it is asked.
-    days: null,
-  },
-] as const;
-
-/** The presets with a fixed width, in order — the ordinary switcher's options. */
-export const FIXED_RANGE_KEYS: readonly RangeKey[] = RANGE_PRESETS.filter(
-  (p) => p.key !== 'custom',
-).map((p) => p.key);
-
-/** Explicit bounds for the `custom` preset. `to` is exclusive, like `ResolvedRange.to`. */
-export interface CustomRangeBounds {
-  from: number;
-  to: number;
-}
-
-export interface ResolveRangeOptions {
-  /** The first datum's timestamp — bounds the `all` preset. */
-  earliest?: number;
-  /** Required by `custom`; ignored by every other key. */
-  custom?: CustomRangeBounds | null;
-}
-
-/**
- * Pick the bucket unit for an arbitrary span. Hourly up to two days (a bucket
- * per hour over 48h is 48 points — readable); daily past that, because 90 days
- * of hourly buckets is 2,160 points nobody can read, which is the same argument
- * the fixed presets make.
- */
-export const unitForSpan = (spanMs: number): BucketUnit => (spanMs <= 2 * DAY_MS ? 'hour' : 'day');
-
-export const rangePreset = (key: RangeKey): RangePreset =>
-  RANGE_PRESETS.find((p) => p.key === key) ?? RANGE_PRESETS[1];
-
-export const HOUR_MS = 3_600_000;
-export const DAY_MS = 86_400_000;
-
-/** Local midnight at the start of `t`'s day. */
-export const startOfDay = (t: number): number => {
-  const d = new Date(t);
-  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
-};
-
-/** Local start of `t`'s hour. */
-export const startOfHour = (t: number): number => {
-  const d = new Date(t);
-  return new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours()).getTime();
-};
-
-/** Start of the bucket `t` falls in, for either unit. */
-export const startOfBucket = (t: number, unit: BucketUnit): number =>
-  unit === 'hour' ? startOfHour(t) : startOfDay(t);
-
-/**
- * Add `n` calendar days, keeping the wall clock. `t + n * DAY_MS` drifts by an
- * hour twice a year and lands on the wrong calendar day, which shows up as a
- * duplicated or missing bar exactly once every spring and autumn — the kind of
- * bug nobody reproduces.
- *
- * The time-of-day is carried through rather than normalised to midnight: every
- * caller here passes an already-aligned value, so normalising would be
- * invisible in this file and a trap for the first caller that does not.
- */
-export const addDays = (t: number, n: number): number => {
-  const d = new Date(t);
-  return new Date(
-    d.getFullYear(),
-    d.getMonth(),
-    d.getDate() + n,
-    d.getHours(),
-    d.getMinutes(),
-    d.getSeconds(),
-    d.getMilliseconds(),
-  ).getTime();
-};
-
-export interface ResolvedRange {
-  key: RangeKey;
-  /** Inclusive start (epoch ms), bucket-aligned. */
-  from: number;
-  /** Exclusive end (epoch ms) — `now`, so the newest bucket is partial. */
-  to: number;
-  unit: BucketUnit;
-  /** Every bucket start in the range, oldest → newest. */
-  buckets: number[];
-  /**
-   * The comparable previous window, for a baseline. `null` for `all` (nothing
-   * precedes everything) — a caller must then say "no baseline", never zero.
-   */
-  previous: { from: number; to: number } | null;
-}
-
-/**
- * Turn a preset into concrete bounds and bucket starts.
- *
- * The third argument is either the `earliest` timestamp (the original,
- * still-supported form — `all` is bounded by the first datum, and absent one it
- * falls back to 90 days so a caller can never ask for a bucket array reaching
- * back to the epoch) or an options object, which is how `custom` receives its
- * bounds.
- *
- * 🔴 `custom` with no bounds is NOT an error and must not throw — a switcher can
- * legitimately be on Custom before the reader has picked two dates. It degrades
- * to the `month` preset, which is a visible, ordinary window rather than an
- * empty chart the reader has to diagnose.
- */
-export function resolveRange(
-  key: RangeKey,
-  now: number,
-  options?: number | ResolveRangeOptions,
-): ResolvedRange {
-  const opts: ResolveRangeOptions =
-    typeof options === 'number' ? { earliest: options } : (options ?? {});
-
-  if (key === 'custom') {
-    const bounds = opts.custom;
-    if (!bounds || !Number.isFinite(bounds.from) || !Number.isFinite(bounds.to) || bounds.to <= bounds.from) {
-      return resolveRange('month', now, { earliest: opts.earliest });
-    }
-    const unit = unitForSpan(bounds.to - bounds.from);
-    const from = startOfBucket(bounds.from, unit);
-    const to = bounds.to;
-    const buckets = bucketStarts(from, to, unit);
-    const span = to - from;
-    return { key, from, to, unit, buckets, previous: { from: from - span, to: from } };
-  }
-
-  const preset = rangePreset(key);
-  const from =
-    preset.days === null
-      ? startOfDay(opts.earliest ?? addDays(now, -90))
-      : preset.unit === 'hour'
-        ? startOfDay(now)
-        : addDays(startOfDay(now), -(preset.days - 1));
-
-  const buckets = bucketStarts(from, now, preset.unit);
-
-  const span = now - from;
-  return {
-    key,
-    from,
-    to: now,
-    unit: preset.unit,
-    buckets,
-    previous: preset.days === null ? null : { from: from - span, to: from },
-  };
-}
-
-/** Every bucket start in `[from, to]`, oldest → newest. Never empty. */
-function bucketStarts(from: number, to: number, unit: BucketUnit): number[] {
-  const buckets: number[] = [];
-  if (unit === 'hour') {
-    for (let t = from; t <= to; t += HOUR_MS) buckets.push(t);
-  } else {
-    for (let t = from; t <= to; t = addDays(t, 1)) buckets.push(t);
-  }
-  // A guard, not a formality: a corrupt clock (or an `earliest` in the future)
-  // could otherwise produce an empty axis with no explanation.
-  if (buckets.length === 0) buckets.push(from);
-  return buckets;
-}
-
-/**
- * The three fields it takes to STATE a window — deliberately less than a
- * `ResolvedRange`, so a server can put the window on the wire beside an
- * aggregate without also shipping its bucket array. Every `ResolvedRange`
- * satisfies it.
- */
-export type RangeWindow = Pick<ResolvedRange, 'key' | 'from' | 'to'>;
-
-/**
- * The active window, stated in words — what a panel prints so a reader never has
- * to infer which period a number covers.
- *
- * This exists because of one owner report, 2026-08-13: *"what time period are we
- * showing. For instance 'Spend & tokens by model' doesn't say if its per this
- * month or week"*. A figure whose window is unstated is not a smaller version of
- * the same figure — it is unreadable, because every reasonable guess gives a
- * different answer.
- */
-export function rangeLabel(range: RangeWindow): string {
-  if (range.key === 'today') return 'Today, since midnight';
-  if (range.key === 'all') return `All time — since ${dayKey(range.from)}`;
-  const first = dayKey(range.from);
-  const last = dayKey(range.to);
-  return first === last ? first : `${first} → ${last}`;
-}
-
-/**
- * Sum `weight(item)` into buckets by `at(item)`. Items outside the range are
- * dropped — silently, because a caller passing "all events" and asking for
- * today is the normal case, not an error.
- *
- * Returns one number per bucket, index-aligned with `range.buckets`, so a
- * caller can zip it against any other series from the same range without
- * re-deriving the axis.
- */
-export function bucketize<T>(
-  items: readonly T[],
-  range: ResolvedRange,
-  at: (item: T) => number,
-  weight: (item: T) => number = () => 1,
-): number[] {
-  const out = new Array<number>(range.buckets.length).fill(0);
-  const index = new Map(range.buckets.map((t, i) => [t, i]));
-  for (const item of items) {
-    const t = at(item);
-    if (!Number.isFinite(t) || t < range.from || t > range.to) continue;
-    const i = index.get(startOfBucket(t, range.unit));
-    if (i !== undefined) out[i] += weight(item);
-  }
-  return out;
-}
-
-/**
- * How much of `[from, to)` overlaps `[windowFrom, windowTo)`. The primitive
- * behind every "…excluding the time it was paused" number: a duration is only
- * honest once the intervals it should not be charged for are subtracted.
- */
-export const overlapMs = (
-  from: number,
-  to: number,
-  windowFrom: number,
-  windowTo: number,
-): number => Math.max(0, Math.min(to, windowTo) - Math.max(from, windowFrom));
-
-/**
- * `[from, to)` minus every interval in `exclude`. Used for pause-adjusted
- * durations and for the denominator of a rate that must not count downtime.
- *
- * `exclude` may overlap itself and need not be sorted — overlapping pause
- * windows (an engine pause inside a usage pause) must not subtract twice, which
- * is the bug a naive sum produces.
- */
-export function durationExcluding(
-  from: number,
-  to: number,
-  exclude: readonly { from: number; to: number }[],
-): number {
-  const total = Math.max(0, to - from);
-  if (total === 0 || exclude.length === 0) return total;
-
-  const clipped = exclude
-    .map((w) => ({ from: Math.max(w.from, from), to: Math.min(w.to, to) }))
-    .filter((w) => w.to > w.from)
-    .sort((a, b) => a.from - b.from);
-
-  let excluded = 0;
-  let cursor = -Infinity;
-  for (const w of clipped) {
-    const start = Math.max(w.from, cursor);
-    if (w.to > start) {
-      excluded += w.to - start;
-      cursor = w.to;
-    }
-  }
-  return Math.max(0, total - excluded);
-}
-
-/** Median of a numeric list. `null` for empty — never 0, which is a real value. */
-export function median(values: readonly number[]): number | null {
-  if (values.length === 0) return null;
-  const s = [...values].sort((a, b) => a - b);
-  const mid = s.length >> 1;
-  return s.length % 2 === 0 ? (s[mid - 1] + s[mid]) / 2 : s[mid];
-}
-
-/** The `p`-th percentile (0–1), nearest-rank. `null` for empty. */
-export function percentile(values: readonly number[], p: number): number | null {
-  if (values.length === 0) return null;
-  const s = [...values].sort((a, b) => a - b);
-  const rank = Math.ceil(Math.min(1, Math.max(0, p)) * s.length);
-  return s[Math.max(0, rank - 1)];
-}
-
-/** A day key (`2026-08-13`) in LOCAL time — never `toISOString`, which is UTC. */
-export function dayKey(t: number): string {
-  const d = new Date(t);
-  const mm = String(d.getMonth() + 1).padStart(2, '0');
-  const dd = String(d.getDate()).padStart(2, '0');
-  return `${d.getFullYear()}-${mm}-${dd}`;
-}

package/src/core/analytics/schedule.spec.ts

@@ -1,311 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import {
-  concurrencyProfile,
-  type ContentionModel,
-  estimateContention,
-  meanConcurrency,
-  NO_CONTENTION,
-  projectBudget,
-  type ScheduleItem,
-  simulateSchedule,
-  stretchAt,
-  sweepFleetSizes,
-} from './schedule';
-
-const MIN = 60_000;
-const item = (id: string, minutes: number, rest: Partial<ScheduleItem> = {}): ScheduleItem => ({
-  id,
-  durationMs: minutes * MIN,
-  ...rest,
-});
-
-describe('simulateSchedule', () => {
-  it('runs independent work in parallel up to the worker count', () => {
-    const items = [item('a', 10), item('b', 10), item('c', 10), item('d', 10)];
-    expect(simulateSchedule(items, { workers: 1 }).makespanMs).toBe(40 * MIN);
-    expect(simulateSchedule(items, { workers: 2 }).makespanMs).toBe(20 * MIN);
-    expect(simulateSchedule(items, { workers: 4 }).makespanMs).toBe(10 * MIN);
-    // Nothing left to parallelise — the fifth worker is inert.
-    expect(simulateSchedule(items, { workers: 5 }).makespanMs).toBe(10 * MIN);
-  });
-
-  it('refuses to co-schedule items that write the same resource, at any fleet size', () => {
-    const items = [
-      item('a', 10, { exclusive: ['repo:x'] }),
-      item('b', 10, { exclusive: ['repo:x'] }),
-      item('c', 10, { exclusive: ['repo:x'] }),
-    ];
-    // The whole point: eight workers do not beat one when the work is serial.
-    expect(simulateSchedule(items, { workers: 8 }).makespanMs).toBe(30 * MIN);
-    expect(simulateSchedule(items, { workers: 8 }).peakConcurrency).toBe(1);
-  });
-
-  it('treats `*` as conflicting with everything that declares a scope', () => {
-    const items = [item('fleet', 10, { exclusive: ['*'] }), item('app', 10, { exclusive: ['repo:x'] })];
-    expect(simulateSchedule(items, { workers: 4 }).makespanMs).toBe(20 * MIN);
-  });
-
-  it('lets undeclared items run beside anything — a missing scope is not a lock', () => {
-    const items = [item('scoped', 10, { exclusive: ['repo:x'] }), item('bare', 10)];
-    expect(simulateSchedule(items, { workers: 2 }).makespanMs).toBe(10 * MIN);
-  });
-
-  it('serialises a named group without needing a shared resource', () => {
-    const items = [item('a', 5, { group: 'gpu' }), item('b', 5, { group: 'gpu' })];
-    expect(simulateSchedule(items, { workers: 4 }).makespanMs).toBe(10 * MIN);
-  });
-
-  it('honours dependencies', () => {
-    const items = [item('second', 10, { dependsOn: ['first'] }), item('first', 10)];
-    const r = simulateSchedule(items, { workers: 4 });
-    expect(r.makespanMs).toBe(20 * MIN);
-    const byId = new Map(r.timeline.map((t) => [t.id, t]));
-    expect(byId.get('second')?.startAt).toBe(10 * MIN);
-    expect(byId.get('second')?.blockedBy).toBe('dependency');
-  });
-
-  it('reports a dependency cycle as unschedulable instead of spinning', () => {
-    const items = [item('a', 1, { dependsOn: ['b'] }), item('b', 1, { dependsOn: ['a'] })];
-    const r = simulateSchedule(items, { workers: 2 });
-    expect(r.unschedulable.sort()).toEqual(['a', 'b']);
-    expect(r.makespanMs).toBe(0);
-  });
-
-  it('counts work already in flight against the fleet', () => {
-    const items = [
-      item('running', 0, { runningRemainingMs: 10 * MIN }),
-      item('queued', 10),
-    ];
-    // One worker: the in-flight item holds it, so the queued one waits.
-    expect(simulateSchedule(items, { workers: 1 }).makespanMs).toBe(20 * MIN);
-    expect(simulateSchedule(items, { workers: 2 }).makespanMs).toBe(10 * MIN);
-  });
-
-  it('schedules longest-first so a big task does not tail the run', () => {
-    const items = [item('small1', 1), item('small2', 1), item('big', 10)];
-    // Shortest-first would finish at 12m (big starts at 2m). LPT starts it at 0.
-    expect(simulateSchedule(items, { workers: 2 }).makespanMs).toBe(10 * MIN);
-  });
-
-  it('stamps absolute times when given a start', () => {
-    const r = simulateSchedule([item('a', 5)], { workers: 1, startAt: 1_000_000 });
-    expect(r.timeline[0].startAt).toBe(1_000_000);
-    expect(r.timeline[0].endAt).toBe(1_000_000 + 5 * MIN);
-  });
-});
-
-describe('contention', () => {
-  const busy: ContentionModel = { freeLanes: 2, slowdownPerExtraWorker: 0.5, maxStretch: 8 };
-
-  it('leaves work at nominal speed inside the free lanes', () => {
-    expect(stretchAt(busy, 1)).toBe(1);
-    expect(stretchAt(busy, 2)).toBe(1);
-    expect(stretchAt(busy, 3)).toBe(1.5);
-    expect(stretchAt(busy, 4)).toBe(2);
-  });
-
-  it('caps the multiplier so an absurd fleet does not produce an infinite ETA', () => {
-    expect(stretchAt(busy, 100)).toBe(8);
-  });
-
-  it('makes a big fleet SLOWER than a small one — the owner’s actual question', () => {
-    const items = Array.from({ length: 8 }, (_, i) => item(`t${i}`, 10));
-    const steep: ContentionModel = { freeLanes: 2, slowdownPerExtraWorker: 0.6 };
-    const two = simulateSchedule(items, { workers: 2, contention: steep }).makespanMs;
-    const eight = simulateSchedule(items, { workers: 8, contention: steep }).makespanMs;
-    // Throughput is `workers / stretch(workers)`: 2/1 = 2 against 8/4.6 = 1.74.
-    // Without a contention term this comparison cannot come out this way at all.
-    expect(eight).toBeGreaterThan(two);
-  });
-
-  it('breaks even exactly where the slowdown cancels the extra worker', () => {
-    const items = Array.from({ length: 8 }, (_, i) => item(`t${i}`, 10));
-    // stretch(8) = 1 + 0.5*6 = 4, so 8/4 === 2/1: the same throughput, and the
-    // same makespan. The boundary case is worth pinning — it is what tells the
-    // reader the model is a real trade-off and not a fudge factor.
-    expect(simulateSchedule(items, { workers: 8, contention: busy }).makespanMs).toBe(
-      simulateSchedule(items, { workers: 2, contention: busy }).makespanMs,
-    );
-  });
-
-  it('charges the extra time to contention, not to the work', () => {
-    const items = [item('a', 10), item('b', 10), item('c', 10), item('d', 10)];
-    const r = simulateSchedule(items, { workers: 4, contention: busy });
-    expect(r.workMs).toBe(40 * MIN);
-    expect(r.spentMs).toBeGreaterThan(r.workMs);
-    expect(r.contentionMs).toBeGreaterThan(0);
-  });
-
-  it('is a no-op under NO_CONTENTION', () => {
-    const items = [item('a', 10), item('b', 10)];
-    const r = simulateSchedule(items, { workers: 2, contention: NO_CONTENTION });
-    expect(r.contentionMs).toBe(0);
-    expect(r.makespanMs).toBe(10 * MIN);
-  });
-});
-
-describe('sweepFleetSizes', () => {
-  it('finds the ceiling the WORK imposes, regardless of fleet size', () => {
-    const items = [
-      item('a', 10, { exclusive: ['repo:x'] }),
-      item('b', 10, { exclusive: ['repo:x'] }),
-      item('c', 10, { exclusive: ['repo:x'] }),
-    ];
-    const sweep = sweepFleetSizes(items, { maxWorkers: 6 });
-    expect(sweep.parallelismCeiling).toBe(1);
-    expect(sweep.sweetSpot).toBe(1);
-    expect(sweep.points.every((p) => p.makespanMs === 30 * MIN)).toBe(true);
-  });
-
-  it('recommends the last worker that earned its place, not the fastest', () => {
-    // Six 10m tasks: 1w=60m, 2w=30m, 3w=20m, 4w=20m, 5w=20m, 6w=10m.
-    const items = Array.from({ length: 6 }, (_, i) => item(`t${i}`, 10));
-    const sweep = sweepFleetSizes(items, { maxWorkers: 6 });
-    // 4 and 5 buy nothing at all; 6 buys another 10m, which is >5% of 60m.
-    expect(sweep.points.find((p) => p.workers === 4)?.marginalMs).toBe(0);
-    expect(sweep.sweetSpot).toBe(6);
-    expect(sweep.turnsNegativeAt).toBeNull();
-  });
-
-  it('names the fleet size where another worker starts costing wall clock', () => {
-    const items = Array.from({ length: 8 }, (_, i) => item(`t${i}`, 10));
-    const sweep = sweepFleetSizes(items, {
-      maxWorkers: 8,
-      contention: { freeLanes: 2, slowdownPerExtraWorker: 0.6 },
-    });
-    // 1w 80m · 2w 40m · 3w 42m — the third agent is where it turns.
-    expect(sweep.turnsNegativeAt).toBe(3);
-    expect(sweep.sweetSpot).toBe(2);
-  });
-
-  it('does not recommend a big fleet that merely beats a slightly worse big fleet', () => {
-    // The measured trap: at a 0.6 slowdown, 7 workers take 50m and 8 take 46m,
-    // so 8 shows a healthy +4m MARGIN while being 6m worse than just running 2.
-    const items = Array.from({ length: 8 }, (_, i) => item(`t${i}`, 10));
-    const sweep = sweepFleetSizes(items, {
-      maxWorkers: 8,
-      contention: { freeLanes: 2, slowdownPerExtraWorker: 0.6 },
-    });
-    expect(sweep.points.find((p) => p.workers === 8)?.marginalMs).toBeGreaterThan(0);
-    expect(sweep.sweetSpot).toBe(2);
-  });
-
-  it('reports speedup and efficiency against one worker', () => {
-    const items = Array.from({ length: 4 }, (_, i) => item(`t${i}`, 10));
-    const sweep = sweepFleetSizes(items, { maxWorkers: 4 });
-    const four = sweep.points.find((p) => p.workers === 4);
-    expect(four?.speedup).toBe(4);
-    expect(four?.efficiency).toBe(1);
-  });
-});
-
-describe('projectBudget', () => {
-  const items = Array.from({ length: 4 }, (_, i) => item(`t${i}`, 10, { cost: 1_000_000 }));
-
-  it('keeps the TOTAL flat across fleet sizes and moves only the deadline', () => {
-    const sweep = sweepFleetSizes(items, { maxWorkers: 4 });
-    const projected = projectBudget(sweep, 2_000_000);
-    expect(new Set(sweep.points.map((p) => p.cost)).size).toBe(1);
-    expect(projected.every((p) => p.coverage === 0.5)).toBe(true);
-    const one = projected.find((p) => p.workers === 1) as (typeof projected)[number];
-    const four = projected.find((p) => p.workers === 4) as (typeof projected)[number];
-    // Four workers reach the wall four times sooner.
-    expect(one.exhaustedInMs).toBe(20 * MIN);
-    expect(four.exhaustedInMs).toBe(5 * MIN);
-    expect(one.shortfall).toBe(2_000_000);
-  });
-
-  it('reports no exhaustion when the budget covers the queue', () => {
-    const sweep = sweepFleetSizes(items, { maxWorkers: 2 });
-    expect(projectBudget(sweep, 10_000_000).every((p) => p.exhaustedInMs === null)).toBe(true);
-  });
-});
-
-describe('estimateContention', () => {
-  it('measures a slowdown from real runs', () => {
-    const samples = [
-      ...Array.from({ length: 10 }, () => ({ concurrency: 1, durationMs: 10 * MIN })),
-      ...Array.from({ length: 10 }, () => ({ concurrency: 4, durationMs: 20 * MIN })),
-    ];
-    const model = estimateContention(samples, { freeLanes: 2 });
-    // Median busy concurrency 4, two lanes over free, 2x stretch → 0.5 per worker.
-    expect(model).toEqual({ freeLanes: 2, slowdownPerExtraWorker: 0.5, maxStretch: 8 });
-  });
-
-  it('returns null rather than a confident model when a group is thin', () => {
-    const samples = [
-      { concurrency: 1, durationMs: 10 * MIN },
-      { concurrency: 5, durationMs: 40 * MIN },
-    ];
-    expect(estimateContention(samples)).toBeNull();
-  });
-
-  it('never reports a NEGATIVE slowdown, which would justify an unbounded fleet', () => {
-    const samples = [
-      ...Array.from({ length: 10 }, () => ({ concurrency: 1, durationMs: 30 * MIN })),
-      ...Array.from({ length: 10 }, () => ({ concurrency: 5, durationMs: 5 * MIN })),
-    ];
-    expect(estimateContention(samples, { freeLanes: 2 })?.slowdownPerExtraWorker).toBe(0);
-  });
-});
-
-describe('concurrencyProfile', () => {
-  it('emits one step per change, with ends before starts at a tie', () => {
-    expect(
-      concurrencyProfile([
-        { from: 0, to: 10 },
-        { from: 10, to: 20 },
-      ]),
-    ).toEqual([
-      { at: 0, count: 1 },
-      { at: 10, count: 1 },
-      { at: 20, count: 0 },
-    ]);
-  });
-
-  it('counts genuine overlap', () => {
-    const profile = concurrencyProfile([
-      { from: 0, to: 10 },
-      { from: 5, to: 15 },
-    ]);
-    expect(profile).toEqual([
-      { at: 0, count: 1 },
-      { at: 5, count: 2 },
-      { at: 10, count: 1 },
-      { at: 15, count: 0 },
-    ]);
-  });
-
-  it('drops zero-width intervals', () => {
-    expect(concurrencyProfile([{ from: 5, to: 5 }])).toEqual([]);
-  });
-});
-
-describe('meanConcurrency', () => {
-  const window = { from: 0, to: 100 };
-
-  it('is time-weighted across the window', () => {
-    expect(meanConcurrency([{ from: 0, to: 50 }], window)).toBe(0.5);
-  });
-
-  it('excludes a paused span from BOTH halves of the average', () => {
-    const intervals = [{ from: 90, to: 100 }];
-    // Naively: 10 of 100 = 0.1 — the number the owner saw as ".2".
-    expect(meanConcurrency(intervals, window)).toBe(0.1);
-    // Excluding the 90 units the engine was off: 10 of 10 = 1 task at once.
-    expect(meanConcurrency(intervals, window, [{ from: 0, to: 90 }])).toBe(1);
-  });
-
-  it('merges overlapping exclusions instead of subtracting twice', () => {
-    const intervals = [{ from: 80, to: 100 }];
-    const nested = [
-      { from: 0, to: 80 },
-      { from: 10, to: 40 },
-    ];
-    expect(meanConcurrency(intervals, window, nested)).toBe(1);
-  });
-
-  it('is 0, not NaN, when the window is entirely excluded', () => {
-    expect(meanConcurrency([{ from: 0, to: 10 }], window, [{ from: 0, to: 100 }])).toBe(0);
-  });
-});