@bamr87/fleet-engines 0.1.0

package/dist/fleet/import.js

@@ -0,0 +1,74 @@
+// Observe-mode I/O: fetch a repo's .github/workflows/*.yml and reverse-import them into a
+// read-only Fleet. Pairs with the pure parsers in parse.ts/facts.ts. Never writes to the repo.
+// Since specs/014 the same pass reads the repo's committed `fleet.manifest.yml` — the hub's
+// `fleet/v1` interchange contract — and pins each recorded lane to its workflow.
+import { parseFleetManifest } from '../harness/lanes.js';
+import { extractFacts } from './facts.js';
+import { buildFleet, parseWorkflow } from './parse.js';
+const WORKFLOW_DIR = '.github/workflows';
+export const MANIFEST_PATH = 'fleet.manifest.yml';
+/** Fetch each workflow file once; returns `{path, text}` pairs (missing files skipped). */
+async function fetchWorkflowTexts(client, repo) {
+    const entries = await client.listDir(repo, WORKFLOW_DIR);
+    const files = entries.filter((e) => e.type === 'file' && /\.ya?ml$/.test(e.name));
+    const fetched = await Promise.all(files.map(async (e) => {
+        const file = await client.getFile(repo, e.path);
+        return file ? { path: e.path, text: file.content } : null;
+    }));
+    return fetched.filter((f) => f !== null);
+}
+/** The repo's committed manifest, or null — a missing or unreadable file never fails an import. */
+export async function fetchFleetManifest(client, repo) {
+    try {
+        const file = await client.getFile(repo, MANIFEST_PATH);
+        if (!file)
+            return null;
+        const manifest = parseFleetManifest(file.content);
+        return manifest.lanes.length > 0 || manifest.spec_version ? manifest : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Pin each recorded lane to its workflow (by implementation path, else by id = basename). */
+export function attachLanes(fleet, manifest) {
+    fleet.manifest = manifest;
+    if (!manifest)
+        return fleet;
+    for (const w of fleet.workflows) {
+        const lane = manifest.lanes.find((l) => l.implementation === w.path) ??
+            manifest.lanes.find((l) => l.id === w.slug) ??
+            null;
+        if (lane)
+            w.lane = lane;
+    }
+    return fleet;
+}
+export async function importFleet(client, repo) {
+    const [texts, manifest] = await Promise.all([
+        fetchWorkflowTexts(client, repo),
+        fetchFleetManifest(client, repo),
+    ]);
+    const parsed = texts.map((f) => parseWorkflow(f.path, f.text));
+    const fleet = attachLanes(buildFleet(repo, parsed), manifest);
+    if (texts.length === 0) {
+        fleet.warnings.push('No workflows found under .github/workflows/ — nothing to observe.');
+    }
+    return fleet;
+}
+/**
+ * Fleet Ops import: one fetch pass, both parsers — the observe graph (Fleet) plus the
+ * deep per-workflow facts the audit/metrics engines consume. Each file is read once.
+ */
+export async function importFleetDeep(client, repo) {
+    const [texts, manifest] = await Promise.all([
+        fetchWorkflowTexts(client, repo),
+        fetchFleetManifest(client, repo),
+    ]);
+    const parsed = texts.map((f) => parseWorkflow(f.path, f.text));
+    const fleet = attachLanes(buildFleet(repo, parsed), manifest);
+    if (texts.length === 0) {
+        fleet.warnings.push('No workflows found under .github/workflows/ — nothing to observe.');
+    }
+    return { fleet, facts: texts.map((f) => extractFacts(f.path, f.text)) };
+}

package/dist/fleet/manifest.d.ts

@@ -0,0 +1,23 @@
+import type { RosterEntry } from './types.js';
+/**
+ * Parse .gitmodules INI text into a fleet roster. Reads `url` (→ slug) and `branch`
+ * from each `[submodule "…"]` section; other keys (`path`, `update`, …) and sections
+ * are ignored. Entries whose url is not a github.com clone URL are skipped, order is
+ * preserved, and duplicate slugs (case-insensitive) keep the first occurrence. PURE
+ * and total: malformed lines are skipped silently, never throws.
+ */
+export declare function parseGitmodules(text: string): RosterEntry[];
+/**
+ * Parse a hand-typed repo list — newline/comma/space separated `owner/name` tokens,
+ * tolerating full GitHub URLs (validated via {@link parseRepo}). Invalid tokens are
+ * dropped, duplicates (case-insensitive) keep the first occurrence. PURE and total.
+ */
+export declare function parseRosterText(text: string): RosterEntry[];
+/**
+ * Union two rosters, deduped by lowercase slug: `existing` entries first (order kept),
+ * then unseen `incoming` entries. On a collision the existing entry wins, except that a
+ * `branch: null` is upgraded from the incoming entry and a `source: 'gitmodules'`
+ * incoming record upgrades a manual one (gitmodules metadata is richer). PURE — the
+ * inputs are never mutated.
+ */
+export declare function mergeRoster(existing: RosterEntry[], incoming: RosterEntry[]): RosterEntry[];

package/dist/fleet/manifest.js

@@ -0,0 +1,118 @@
+// Fleet-roster manifest parsing — how the cockpit learns WHICH repos make up the
+// fleet. `parseGitmodules` mines a monorepo's .gitmodules (the bamr87 hub pattern:
+// ~40 submodules, each a fleet member) into roster entries; `parseRosterText` accepts
+// hand-typed owner/name lists; `mergeRoster` unions the two, preferring the richer
+// gitmodules metadata. Slugs only — never tokens (golden rule #7). No I/O, never
+// throws on malformed input: junk lines and non-GitHub urls are skipped silently.
+import { parseRepo, repoSlug } from '../github/types.js';
+// ── url → slug ────────────────────────────────────────────────────────────────
+/** `owner/name` from a github.com clone URL (https or ssh form), or null for any other host. */
+function slugFromGithubUrl(url) {
+    const m = /^https?:\/\/github\.com\/(.+)$/i.exec(url.trim()) ??
+        /^git@github\.com:(.+)$/i.exec(url.trim());
+    if (!m)
+        return null;
+    const repo = parseRepo(m[1]); // strips a trailing `.git`/`/` and validates owner/name
+    return repo ? repoSlug(repo) : null;
+}
+const SUBMODULE_HEADER = /^\s*\[submodule\s+"[^"]*"\]\s*$/;
+const ANY_HEADER = /^\s*\[[^\]]*\]\s*$/;
+const KEY_VALUE = /^\s*([A-Za-z][A-Za-z0-9-]*)\s*=\s*(.*?)\s*$/;
+/**
+ * Parse .gitmodules INI text into a fleet roster. Reads `url` (→ slug) and `branch`
+ * from each `[submodule "…"]` section; other keys (`path`, `update`, …) and sections
+ * are ignored. Entries whose url is not a github.com clone URL are skipped, order is
+ * preserved, and duplicate slugs (case-insensitive) keep the first occurrence. PURE
+ * and total: malformed lines are skipped silently, never throws.
+ */
+export function parseGitmodules(text) {
+    const sections = [];
+    let current = null;
+    for (const line of text.split(/\r?\n/)) {
+        if (SUBMODULE_HEADER.test(line)) {
+            current = { url: null, branch: null };
+            sections.push(current);
+            continue;
+        }
+        if (ANY_HEADER.test(line)) {
+            current = null; // some other section ([core] etc.) — its keys are not ours
+            continue;
+        }
+        if (!current)
+            continue;
+        const kv = KEY_VALUE.exec(line);
+        if (!kv || kv[2] === '')
+            continue;
+        if (kv[1] === 'url')
+            current.url = kv[2];
+        else if (kv[1] === 'branch')
+            current.branch = kv[2];
+    }
+    const out = [];
+    const seen = new Set();
+    for (const s of sections) {
+        const slug = s.url === null ? null : slugFromGithubUrl(s.url);
+        if (!slug || seen.has(slug.toLowerCase()))
+            continue;
+        seen.add(slug.toLowerCase());
+        out.push({ slug, source: 'gitmodules', branch: s.branch });
+    }
+    return out;
+}
+// ── hand-typed rosters ────────────────────────────────────────────────────────
+/**
+ * Parse a hand-typed repo list — newline/comma/space separated `owner/name` tokens,
+ * tolerating full GitHub URLs (validated via {@link parseRepo}). Invalid tokens are
+ * dropped, duplicates (case-insensitive) keep the first occurrence. PURE and total.
+ */
+export function parseRosterText(text) {
+    const out = [];
+    const seen = new Set();
+    for (const token of text.split(/[\s,]+/)) {
+        if (token === '')
+            continue;
+        const repo = parseRepo(token);
+        if (!repo)
+            continue;
+        const slug = repoSlug(repo);
+        if (seen.has(slug.toLowerCase()))
+            continue;
+        seen.add(slug.toLowerCase());
+        out.push({ slug, source: 'manual', branch: null });
+    }
+    return out;
+}
+// ── merging ───────────────────────────────────────────────────────────────────
+/**
+ * Union two rosters, deduped by lowercase slug: `existing` entries first (order kept),
+ * then unseen `incoming` entries. On a collision the existing entry wins, except that a
+ * `branch: null` is upgraded from the incoming entry and a `source: 'gitmodules'`
+ * incoming record upgrades a manual one (gitmodules metadata is richer). PURE — the
+ * inputs are never mutated.
+ */
+export function mergeRoster(existing, incoming) {
+    const out = [];
+    const indexByKey = new Map();
+    for (const entry of existing) {
+        const key = entry.slug.toLowerCase();
+        if (indexByKey.has(key))
+            continue;
+        indexByKey.set(key, out.length);
+        out.push({ ...entry });
+    }
+    for (const entry of incoming) {
+        const key = entry.slug.toLowerCase();
+        const at = indexByKey.get(key);
+        if (at === undefined) {
+            indexByKey.set(key, out.length);
+            out.push({ ...entry });
+            continue;
+        }
+        const kept = out[at];
+        if (kept.branch === null && entry.branch !== null)
+            kept.branch = entry.branch;
+        if (kept.source !== 'gitmodules' && entry.source === 'gitmodules')
+            kept.source = 'gitmodules';
+    }
+    return out;
+}

package/dist/fleet/metrics.d.ts

@@ -0,0 +1,45 @@
+import type { FactoryRun } from '../github/types.js';
+import type { DashType, MetricsRollup, WorkflowMetrics } from './types.js';
+/** Windowing options. `nowIso` is the analysis instant — callers own the clock. */
+export interface MetricsOptions {
+    nowIso: string;
+    /** Lookback window in days (dash default: 14). */
+    windowDays?: number;
+}
+/**
+ * Fold a window of runs into per-workflow {@link WorkflowMetrics}, keyed by path.
+ * Only `status === 'completed'` runs created inside the window fold; a run whose
+ * timestamps don't parse is skipped (the dash skips runs without a computable
+ * duration). A path absent from `labels` still gets metrics under its basename
+ * slug with dashType 'other'. `flags`/`priority` come back zeroed — scope-aware
+ * flagging is {@link assignFlags}'s job. Never throws.
+ */
+export declare function computeWorkflowMetrics(runs: FactoryRun[], labels: ReadonlyMap<string, {
+    name: string;
+    dashType: DashType;
+}>, opts: MetricsOptions): WorkflowMetrics[];
+/**
+ * Fill `flags` + `priority` across a workflow group and rank it for triage. The
+ * high-cost median is taken over the *given* group — the caller chooses the scope
+ * (one repo, one type, the whole fleet). Returns a NEW array (inputs untouched)
+ * sorted by (priority desc, totalMin desc). Thresholds are the dash's; `failing`
+ * and `flaky` are mutually exclusive by construction; `rework-heavy` is the
+ * gitorio addition.
+ */
+export declare function assignFlags(workflows: WorkflowMetrics[]): WorkflowMetrics[];
+/**
+ * Aggregate a group of workflows into one {@link MetricsRollup}. WorkflowMetrics
+ * does not retain successMin, so group effectiveness is reconstructed as
+ * pct(Σ totalMin·effectivenessPct/100, Σ totalMin) — exact up to the per-workflow
+ * pct rounding already baked into effectivenessPct. The rework denominator is
+ * Σ runs, which is the completed-run count (only completed runs ever fold).
+ */
+export declare function rollup(workflows: WorkflowMetrics[]): MetricsRollup;
+/**
+ * Roll workflows up by dashType: one row per type present, each a {@link rollup}
+ * plus its sharePct of the grand total minutes (0-guarded), sorted totalMin desc.
+ */
+export declare function rollupByType(workflows: WorkflowMetrics[]): ({
+    type: DashType;
+    sharePct: number;
+} & MetricsRollup)[];

package/dist/fleet/metrics.js

@@ -0,0 +1,284 @@
+// Run-metrics engine for Fleet Ops — a TypeScript port of the dash's
+// actions_analytics.py aggregation (bamr87/bamr87 .github/scripts/dash-gen).
+// Cost = wall-clock run minutes (runStartedAt → updatedAt), a shadow price for
+// billable minutes; value = share of minutes ending in success; waste = minutes on
+// failed/cancelled/timed-out/startup-failed runs. Two gitorio additions on top of
+// the dash formulas: rework (runAttempt > 1) and queue latency (createdAt →
+// runStartedAt). PURE and total: time arrives as an ISO-string parameter, malformed
+// timestamps skip a run rather than throwing, and nothing here does I/O.
+const DEFAULT_WINDOW_DAYS = 14;
+/** Non-success terminal conclusions whose minutes count as waste (dash WASTE_CONCLUSIONS). */
+const WASTE_CONCLUSIONS = new Set([
+    'failure',
+    'cancelled',
+    'timed_out',
+    'startup_failure',
+]);
+// Flag thresholds — mirrors of the dash's tunable constants, plus the rework
+// addition (same 25% bar as cancel-heavy).
+const SLOW_AVG_MIN = 12;
+const LOW_EFFECTIVENESS = 55;
+const CANCEL_HEAVY_PCT = 25;
+const CRON_HEAVY_PCT = 60;
+const MIN_WASTE_MIN = 4;
+const REWORK_HEAVY_PCT = 25;
+// ── numeric helpers (dash: round(x, 1) / round(x, 2) / pct / p95 / median) ──
+/**
+ * Round half to EVEN — Python 3's `round()`. The dash computes every rounded value
+ * with Python `round()`, so an exact TS port must tie-break the same way (JS
+ * `Math.round` ties toward +∞, which diverges on exact `.5` values, e.g. p95 index
+ * `round(28.5)` = 28 in Python vs 29 in JS, and `round(6.25, 1)` = 6.2 vs 6.3).
+ */
+function bankersRound(x) {
+    const floor = Math.floor(x);
+    const diff = x - floor;
+    if (diff < 0.5)
+        return floor;
+    if (diff > 0.5)
+        return floor + 1;
+    return floor % 2 === 0 ? floor : floor + 1; // exact .5 → nearest even
+}
+function round1(x) {
+    return bankersRound(x * 10) / 10;
+}
+function round2(x) {
+    return bankersRound(x * 100) / 100;
+}
+/** Percentage of `part` in `whole`, one decimal; 0 when `whole` is 0 (dash pct()). */
+function pct(part, whole) {
+    return whole ? round1((100 * part) / whole) : 0;
+}
+/** Statistical median: mean of the two middles for an even count; 0 for empty. */
+function median(values) {
+    if (values.length === 0)
+        return 0;
+    const s = [...values].sort((a, b) => a - b);
+    const mid = s.length >> 1;
+    return s.length % 2 === 1 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+}
+/** Nearest-rank p95 (NOT interpolated): sorted[min(n−1, round(0.95·(n−1)))], two decimals. */
+function p95(values) {
+    if (values.length === 0)
+        return 0;
+    const s = [...values].sort((a, b) => a - b);
+    const idx = Math.min(s.length - 1, bankersRound(0.95 * (s.length - 1)));
+    return round2(s[idx]);
+}
+/** Basename of a path with a trailing `.yml`/`.yaml` stripped — the unlabeled-name fallback. */
+function baseNoExt(path) {
+    const base = path.split('/').pop() ?? path;
+    return base.replace(/\.ya?ml$/i, '');
+}
+function newBucket() {
+    return {
+        runs: 0,
+        totalMin: 0,
+        successMin: 0,
+        wasteMin: 0,
+        success: 0,
+        failure: 0,
+        cancelled: 0,
+        other: 0,
+        durations: [],
+        queueSecs: [],
+        reworkRuns: 0,
+        events: new Map(),
+    };
+}
+// ── public API ───────────────────────────────────────────────────────────────
+/**
+ * Fold a window of runs into per-workflow {@link WorkflowMetrics}, keyed by path.
+ * Only `status === 'completed'` runs created inside the window fold; a run whose
+ * timestamps don't parse is skipped (the dash skips runs without a computable
+ * duration). A path absent from `labels` still gets metrics under its basename
+ * slug with dashType 'other'. `flags`/`priority` come back zeroed — scope-aware
+ * flagging is {@link assignFlags}'s job. Never throws.
+ */
+export function computeWorkflowMetrics(runs, labels, opts) {
+    const windowDays = opts.windowDays ?? DEFAULT_WINDOW_DAYS;
+    const cutoffMs = Date.parse(opts.nowIso) - windowDays * 86_400_000;
+    const weeks = Math.max(windowDays / 7, 1 / 7);
+    const buckets = new Map();
+    for (const run of runs) {
+        const createdMs = Date.parse(run.createdAt);
+        // Negated comparison so a NaN cutoff or createdAt excludes rather than throws.
+        if (!(createdMs >= cutoffMs))
+            continue;
+        if (run.status !== 'completed')
+            continue;
+        const startMs = run.runStartedAt !== null ? Date.parse(run.runStartedAt) : createdMs;
+        const rawMin = (Date.parse(run.updatedAt) - startMs) / 60_000;
+        if (!Number.isFinite(rawMin))
+            continue;
+        const m = Math.max(0, rawMin);
+        let b = buckets.get(run.path);
+        if (!b) {
+            b = newBucket();
+            buckets.set(run.path, b);
+        }
+        b.runs += 1;
+        b.totalMin += m;
+        b.durations.push(m);
+        b.events.set(run.event, (b.events.get(run.event) ?? 0) + 1);
+        const c = run.conclusion;
+        // Rework counts re-run attempts among OUTCOME-BEARING runs only (success/failure/
+        // cancelled) — the same `completed` denominator the rework-heavy flag and
+        // successRatePct use — so reworkPct is a fraction of the same base, never >100%.
+        let outcomeBearing = false;
+        if (c === 'success') {
+            b.successMin += m;
+            b.success += 1;
+            outcomeBearing = true;
+        }
+        else if (c !== null && WASTE_CONCLUSIONS.has(c)) {
+            b.wasteMin += m;
+            if (c === 'cancelled')
+                b.cancelled += 1;
+            else
+                b.failure += 1;
+            outcomeBearing = true;
+        }
+        else {
+            b.other += 1;
+        }
+        if (run.runStartedAt !== null && Number.isFinite(startMs - createdMs)) {
+            b.queueSecs.push(Math.max(0, (startMs - createdMs) / 1000));
+        }
+        if (outcomeBearing && run.runAttempt > 1)
+            b.reworkRuns += 1;
+    }
+    const out = [];
+    for (const [path, b] of buckets) {
+        const label = labels.get(path);
+        out.push({
+            path,
+            name: label?.name ?? baseNoExt(path),
+            dashType: label?.dashType ?? 'other',
+            runs: b.runs,
+            totalMin: round1(b.totalMin),
+            avgMin: b.runs ? round2(b.totalMin / b.runs) : 0,
+            p95Min: p95(b.durations),
+            wasteMin: round1(b.wasteMin),
+            runsPerWeek: round1(b.runs / weeks),
+            success: b.success,
+            failure: b.failure,
+            cancelled: b.cancelled,
+            other: b.other,
+            successRatePct: pct(b.success, b.success + b.failure + b.cancelled),
+            // "Other" minutes (skipped/neutral/…) live in totalMin only, so
+            // effectiveness + waste share need not sum to 100.
+            effectivenessPct: b.totalMin > 0 ? pct(b.successMin, b.totalMin) : 100,
+            schedPct: pct(b.events.get('schedule') ?? 0, b.runs),
+            reworkRuns: b.reworkRuns,
+            // Denominator is the outcome-bearing count (matches the rework-heavy flag +
+            // successRatePct), NOT `runs` — `runs` also includes skipped/neutral ('other')
+            // runs, which would dilute the rate and wrongly suppress the flag.
+            reworkPct: pct(b.reworkRuns, b.success + b.failure + b.cancelled),
+            queueP50Sec: b.queueSecs.length > 0 ? round1(median(b.queueSecs)) : null,
+            events: Object.fromEntries(b.events),
+            flags: [],
+            priority: 0,
+        });
+    }
+    return out;
+}
+/**
+ * Fill `flags` + `priority` across a workflow group and rank it for triage. The
+ * high-cost median is taken over the *given* group — the caller chooses the scope
+ * (one repo, one type, the whole fleet). Returns a NEW array (inputs untouched)
+ * sorted by (priority desc, totalMin desc). Thresholds are the dash's; `failing`
+ * and `flaky` are mutually exclusive by construction; `rework-heavy` is the
+ * gitorio addition.
+ */
+export function assignFlags(workflows) {
+    const medianMin = median(workflows.map((w) => w.totalMin));
+    const out = workflows.map((w) => {
+        const flags = [];
+        const completed = w.success + w.failure + w.cancelled;
+        if (w.totalMin >= medianMin &&
+            w.effectivenessPct < LOW_EFFECTIVENESS &&
+            w.wasteMin >= MIN_WASTE_MIN) {
+            flags.push('high-cost-low-value');
+        }
+        if (completed >= 3 && w.successRatePct < 50) {
+            flags.push('failing');
+        }
+        else if (completed >= 4 && w.successRatePct >= 50 && w.successRatePct < 85) {
+            flags.push('flaky');
+        }
+        if (w.avgMin > SLOW_AVG_MIN)
+            flags.push('slow');
+        if (completed >= 4 && pct(w.cancelled, completed) > CANCEL_HEAVY_PCT) {
+            flags.push('cancel-heavy');
+        }
+        if (w.runs >= 5 && w.schedPct > CRON_HEAVY_PCT)
+            flags.push('cron-heavy');
+        if (completed >= 4 && w.reworkPct > REWORK_HEAVY_PCT)
+            flags.push('rework-heavy');
+        // Priority: minutes wasted, then raw consumption — the "high running, low
+        // effective" triage rank.
+        const priority = round1(w.wasteMin + w.totalMin * (1 - w.effectivenessPct / 100));
+        return { ...w, flags, priority };
+    });
+    out.sort((a, b) => b.priority - a.priority || b.totalMin - a.totalMin);
+    return out;
+}
+/**
+ * Aggregate a group of workflows into one {@link MetricsRollup}. WorkflowMetrics
+ * does not retain successMin, so group effectiveness is reconstructed as
+ * pct(Σ totalMin·effectivenessPct/100, Σ totalMin) — exact up to the per-workflow
+ * pct rounding already baked into effectivenessPct. The rework denominator is
+ * Σ runs, which is the completed-run count (only completed runs ever fold).
+ */
+export function rollup(workflows) {
+    let runs = 0;
+    let totalMin = 0;
+    let wasteMin = 0;
+    let successMin = 0;
+    let success = 0;
+    let completed = 0;
+    let reworkRuns = 0;
+    for (const w of workflows) {
+        runs += w.runs;
+        totalMin += w.totalMin;
+        wasteMin += w.wasteMin;
+        successMin += (w.totalMin * w.effectivenessPct) / 100;
+        success += w.success;
+        completed += w.success + w.failure + w.cancelled;
+        reworkRuns += w.reworkRuns;
+    }
+    return {
+        runs,
+        totalMin: round1(totalMin),
+        wasteMin: round1(wasteMin),
+        // Mirror the per-workflow + dash guard: an all-zero-minute group scores 100, not 0.
+        effectivenessPct: totalMin > 0 ? pct(successMin, totalMin) : 100,
+        successRatePct: pct(success, completed),
+        // Same outcome-bearing denominator as the per-workflow reworkPct, not `runs`.
+        reworkPct: pct(reworkRuns, completed),
+    };
+}
+/**
+ * Roll workflows up by dashType: one row per type present, each a {@link rollup}
+ * plus its sharePct of the grand total minutes (0-guarded), sorted totalMin desc.
+ */
+export function rollupByType(workflows) {
+    const groups = new Map();
+    for (const w of workflows) {
+        const group = groups.get(w.dashType);
+        if (group)
+            group.push(w);
+        else
+            groups.set(w.dashType, [w]);
+    }
+    const rows = [...groups.entries()].map(([type, group]) => ({
+        type,
+        sharePct: 0,
+        ...rollup(group),
+    }));
+    const grandMin = rows.reduce((sum, r) => sum + r.totalMin, 0);
+    for (const r of rows)
+        r.sharePct = grandMin ? round1((100 * r.totalMin) / grandMin) : 0;
+    rows.sort((a, b) => b.totalMin - a.totalMin);
+    return rows;
+}

package/dist/fleet/parse.d.ts

@@ -0,0 +1,15 @@
+import type { RepoRef } from '../github/types.js';
+import type { Fleet, ImportedWorkflow } from './types.js';
+/**
+ * Reverse-import one workflow file into an {@link ImportedWorkflow}. PURE and total:
+ * never throws. Name + `on:` come from the YAML parser when the file parses; all
+ * agent/sink/cross-repo/gate signals come from a raw-text scan, so odd YAML shapes
+ * (and even unparseable files) still yield useful data.
+ */
+export declare function parseWorkflow(path: string, yamlText: string): ImportedWorkflow;
+/**
+ * Stitch a repo's parsed workflows into a {@link Fleet}: workflow_run belts (a workflow
+ * whose `on.workflow_run.workflows` names another workflow in the same repo) and
+ * cross-repo belts (a `gh … --repo owner/name` targeting a *different* repo). PURE.
+ */
+export declare function buildFleet(repo: RepoRef, parsed: ImportedWorkflow[]): Fleet;