@cyc-seattle/platform 1.54.0 → 1.55.1

package/README.md

@@ -13,9 +13,9 @@ platform is built, its data model, and the planning engine.
 | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
 | [`bootstrap`](stacks/bootstrap) | Service accounts and project IAM, the Pulumi state buckets and KMS keys, the org's GitHub repos and settings, and Firebase on the project                                                                                                                                                                                                                                                                                                                                                                                | A human with project Owner and `gh` `admin:org`. Never CI.                                                               |
 | [`infra`](stacks/infra)         | The VPC, the cluster subnet and its Cloud NAT on a static address, the private services peering, the prod and dev Cloud SQL instances, the DNS zones, Artifact Registry and its cleanup policy, the GKE Autopilot cluster, the shared Gateway, its address, certificates, and dev's DNS records, the `dev` and `prod` namespaces with their quotas and network policies, dev's RBAC, the prod Job alerts, the log exclusions, the public website's Firebase Hosting site, and each environment's `platform/outputs.json` | `deploy-runner`, from Actions after approval. A deployer, with `mise run deploy`, when breaking glass.                   |
-| [`smoke`](stacks/smoke)         | One `WebService` in dev, at `smoke.dev.cycsail.team`, for the integration tests                                                                                                                                                                                                                                                                                                                                                                                                                                          | `deploy-dev`, from Actions for each queued PR. A deployer, with `PULUMI_STACK=dev mise run deploy`, when breaking glass. |
-| [`backend`](stacks/backend)     | Directus, with the schema apply from `schemas/`, its roles, policies, and permission rules, the sync and website build machine users, its OIDC client, and MCP, and the clubspot-sync and gsuite-sync CronJobs, with dev's Clubspot and Workspace fakes                                                                                                                                                                                                                                                                  | `deploy-dev`, from Actions for each queued PR, and `deploy-runner` on a push to `main`, after `infra`.                   |
-| [`authentik`](stacks/authentik) | Authentik, the sign-in at `login.<domain>`: its server and worker, database, secrets, and A record, dev's Mailpit, and its own configuration: flows, stages, policies, the Google source, the `staff` group, the `Admins` superuser group, and the Directus OIDC and portal proxy applications                                                                                                                                                                                                                           | `deploy-dev`, from Actions for each queued PR, and `deploy-runner` on a push to `main`, after `backend`.                 |
+| [`smoke`](stacks/smoke)         | One `WebService` in dev, at `smoke.dev.cycsail.team`, for the integration tests                                                                                                                                                                                                                                                                                                                                                                                                                                          | `deploy-dev`, from Actions for each merged PR. A deployer, with `PULUMI_STACK=dev mise run deploy`, when breaking glass. |
+| [`backend`](stacks/backend)     | Directus, with the schema apply from `schemas/`, its roles, policies, and permission rules, the sync and website build machine users, its OIDC client, and MCP, and the clubspot-sync and gsuite-sync CronJobs, with dev's Clubspot and Workspace fakes                                                                                                                                                                                                                                                                  | `deploy-dev` and then `deploy-runner`, from Actions on a push to `main`, after `infra`.                                  |
+| [`authentik`](stacks/authentik) | Authentik, the sign-in at `login.<domain>`: its server and worker, database, secrets, and A record, dev's Mailpit, and its own configuration: flows, stages, policies, the Google source, the `staff` group, the `Admins` superuser group, and the Directus OIDC and portal proxy applications                                                                                                                                                                                                                           | `deploy-dev` and then `deploy-runner`, from Actions on a push to `main`, after `backend`.                                |
 
 ## @cyc-seattle/platform
 
@@ -104,20 +104,18 @@ deployer needs first.
 authenticates with Workload Identity Federation and stores no credentials. Each job runs in a
 GitHub environment that holds its identity and state bucket:
 
-| Event                      | Jobs, in order                                                          |
-| -------------------------- | ----------------------------------------------------------------------- |
-| Pull request               | `ci`                                                                    |
-| Merge queue                | `ci`, then `dev`: `mise run deploy` as `deploy-dev`; `dev-passed`       |
-| Push to `main`             | `prod-preview`, then `prod`, which waits for the `maintainers` approval |
-| Run by hand, from a branch | `ci`, then `dev`                                                        |
-| Run by hand, from `main`   | `prod-preview`, then `prod`                                             |
-
-Dev is shared, so only the merge queue deploys to it (#69, #80). PRs queued together deploy as
-one batch: each queued PR's run skips dev when a newer PR is queued behind it, and the newest
-deploys them all. The queue requires `dev-passed`, so a batch merges only once its dev deploy passes, and `main` gets the exact commit the queue tested, in one push. If the
-newest PR fails, the queue drops it and the rest of the batch deploys without it. A queued PR of only docs or CI skips `dev`. The queue
-doesn't run the integration tests (#161); a run by hand does. To try a
-branch on dev and test it before queueing it, run `gh workflow run pull-request.yml --ref <branch>`.
+| Event                    | Jobs, in order                                                                                                                           |
+| ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| Pull request             | `ci`                                                                                                                                     |
+| Push to `main`           | `dev`: `mise run deploy` as `deploy-dev`, then `integration` and `prod-preview`, then `prod`, which waits for the `maintainers` approval |
+| Run by hand, from `main` | The same as a push to `main`                                                                                                             |
+
+Dev is shared and takes only `main` (#280), so a PR's push runs only CI, and each push to `main`
+deploys dev before prod. `integration` starts `integration.yml`, which runs the integration tests
+against dev in a run of its own, one at a time. A newer run replaces one that's waiting, and a
+waiting deploy goes ahead of it, so it tests whatever is newest on dev. A failure opens or comments
+on the `Integration tests failed on dev` issue, and a green run closes it. `nightly.yml` still
+deploys and tests `main` each night, with its own issue.
 
 `prod-preview` runs `mise run preview` as `deploy-runner` and writes the diff to the job summary.
 `prod` runs `mise run deploy` on the same commit once approved. It runs only when the preview shows

package/dist/planning/activities.js

@@ -8,7 +8,7 @@ export function scheduleActivities(ctx) {
     const closed = new Map();
     for (const c of ctx.data.plan_closed_dates ?? []) {
         // The closed days are the Operations Plan's, not an area's.
-        if (ctx.planOfVersion.get(c.version_id)?.kind === "program_area") {
+        if (ctx.planOf.get(c.plan_id)?.kind === "program_area") {
             ctx.warn("closed_date_in_area_plan", `${c.name} is a closed day in a Program Plan. Only the Operations Plan's closed days count`, c.key);
             continue;
         }
@@ -31,7 +31,7 @@ export function scheduleActivities(ctx) {
         const closedFor = closed.get(activity.date);
         if (closedFor !== undefined && activity.kind !== "travel") {
             ctx.warn("closed_date", `${offering.name}'s ${activity.kind} is on ${closedFor}, when ${ctx.data.organization.name} is closed`, activity.key, {
-                version_id: activity.version_id,
+                plan_id: activity.plan_id,
                 date: activity.date,
             });
         }

package/dist/planning/bonus.js

@@ -94,7 +94,7 @@ function areaOf(ctx, owner) {
  * order and then no term. An area plan's bonus counts only that area's products, and warns about any other.
  */
 function basesOf(ctx, owner, terms) {
-    const plan = ctx.planOfVersion.get(owner.version_id);
+    const plan = ctx.planOf.get(owner.plan_id);
     const products = new Set();
     for (const row of ctx.data.plan_bonus_owner_products) {
         if (row.bonus_owner_id !== owner.id)

package/dist/planning/context.d.ts

@@ -1,7 +1,7 @@
 import type { Account, AccountFunction, CostCenterType, CostType, DateString, EngineWarning, Id, PlanData, PlanOffering, Plan, PlanRates, Product, ProgramArea } from "./types.ts";
-/** Where a warning applies: a plan copy, and a date. */
+/** Where a warning applies: a plan, and a date. */
 export interface WarningScope {
-    version_id?: Id;
+    plan_id?: Id;
     date?: DateString;
 }
 /** The step that recorded an entry. Only `direct` entries count toward MTDC. */
@@ -31,8 +31,8 @@ export declare class Context {
     readonly accounts: Map<Id, Account>;
     readonly products: Map<Id, Product>;
     readonly areas: Map<Id, ProgramArea>;
-    /** Each version's plan. */
-    readonly planOfVersion: Map<Id, Plan>;
+    /** Each plan, by its id. */
+    readonly planOf: Map<Id, Plan>;
     readonly offeringsById: Map<Id, PlanOffering>;
     readonly offeringsByKey: Map<Id, PlanOffering>;
     /** Expected enrollment per offering id, which the costs and revenue use. */

package/dist/planning/context.js

@@ -24,8 +24,8 @@ export class Context {
     accounts;
     products;
     areas;
-    /** Each version's plan. */
-    planOfVersion;
+    /** Each plan, by its id. */
+    planOf;
     offeringsById;
     offeringsByKey;
     /** Expected enrollment per offering id, which the costs and revenue use. */
@@ -42,11 +42,7 @@ export class Context {
         this.accounts = new Map(data.accounts.map((a) => [a.id, a]));
         this.products = new Map(data.products.map((p) => [p.id, p]));
         this.areas = new Map(data.program_areas.map((a) => [a.id, a]));
-        const plans = new Map(data.plans.map((p) => [p.id, p]));
-        this.planOfVersion = new Map(data.plan_versions.flatMap((v) => {
-            const plan = plans.get(v.plan_id);
-            return plan === undefined ? [] : [[v.id, plan]];
-        }));
+        this.planOf = new Map(data.plans.map((p) => [p.id, p]));
         this.offeringsById = new Map(data.plan_offerings.map((o) => [o.id, o]));
         this.offeringsByKey = new Map(data.plan_offerings.map((o) => [o.key, o]));
         this.rates = data.plan_rates[0];
@@ -65,7 +61,7 @@ export class Context {
         return account;
     }
     warn(code, message, key, scope = {}) {
-        const same = (w) => w.code === code && w.message === message && w.version_id === scope.version_id;
+        const same = (w) => w.code === code && w.message === message && w.plan_id === scope.plan_id;
         if (this.warnings.some(same))
             return;
         const category = ALLOCATION_WARNINGS.has(code) ? "allocation" : "data";
@@ -74,7 +70,7 @@ export class Context {
             message,
             category,
             ...(key !== undefined && { key }),
-            ...(scope.version_id !== undefined && { version_id: scope.version_id }),
+            ...(scope.plan_id !== undefined && { plan_id: scope.plan_id }),
             ...(scope.date !== undefined && { date: scope.date }),
         });
     }

package/dist/planning/engine.js

@@ -127,7 +127,7 @@ function checkAreas(ctx) {
         else if (product.kind !== "program" && product.program_area_id != null) {
             ctx.warn("area_on_non_program", `${product.name} isn't a program but has a program area`, product.id);
         }
-        const plan = ctx.planOfVersion.get(offering.version_id);
+        const plan = ctx.planOf.get(offering.plan_id);
         if (plan === undefined)
             continue;
         const wrong = plan.kind === "operations"

package/dist/planning/lines.js

@@ -62,9 +62,9 @@ function checkCostCenter(ctx, type, key, line) {
  * organization already has its own warning, `capital_off_org`.
  */
 function warnCostShift(ctx, line) {
-    if (ctx.planOfVersion.get(line.version_id)?.kind !== "program_area")
+    if (ctx.planOf.get(line.plan_id)?.kind !== "program_area")
         return;
-    const warn = (message) => ctx.warn("cost_off_programs", message, line.key, { version_id: line.version_id });
+    const warn = (message) => ctx.warn("cost_off_programs", message, line.key, { plan_id: line.plan_id });
     const org = ctx.data.organization.name;
     const capital = ctx.accountType(line.account_id) === "asset";
     if (capital && line.cost_center_type === "org") {

package/dist/planning/salaried.js

@@ -34,12 +34,17 @@ export function bookSalaries(ctx, coaching, booker) {
                 }
                 return [
                     b.product_id != null
-                        ? { cost_center_type: "product", cost_center_key: b.product_id, hours: b.hours, line: b.kind }
+                        ? {
+                            cost_center_type: "product",
+                            cost_center_key: b.product_id,
+                            hours: b.hours,
+                            line: "management",
+                        }
                         : {
                             cost_center_type: "program_area",
                             cost_center_key: b.program_area_id,
                             hours: b.hours,
-                            line: b.kind,
+                            line: "management",
                         },
                 ];
             }),

package/dist/planning/staffing.d.ts

@@ -18,7 +18,7 @@ export interface DoubleBooked {
     /** Dates it's on two blocks at once. */
     dates: number;
 }
-/** Whole kids expected: `target_enrollment` if set, otherwise `capacity × fill_rate` rounded. */
+/** Whole kids expected: `target_enrollment`, or none when it's empty. */
 export declare function enrollmentOf(offering: PlanOffering): number;
 /** The most sailors an offering takes: its `capacity`, or else the sailors expected. */
 export declare function maxEnrollmentOf(offering: PlanOffering): number;
@@ -26,7 +26,7 @@ export declare class Staffing {
     private readonly ctx;
     private readonly warned;
     constructor(ctx: Context);
-    /** Warns once for each row and plan copy, about the first date it's seen on. */
+    /** Warns once for each row and plan, about the first date it's seen on. */
     private warnOnce;
     /**
      * Gathers each block's activities, times and allocations. A block's paid time runs from its first
@@ -46,13 +46,6 @@ export declare class Staffing {
      * Boats count the ones sailors bring.
      */
     private checkCapacity;
-    /**
-     * The coaches a block pays for its expected sailors: Σ (each program's sailors ÷ its sailors per
-     * coach), rounded up, but never more than it's given. Salaried coaches on salary are always paid, so
-     * only the others are cut, each staff row by the same share. When a program has no sailors per
-     * coach, the block pays all it's given.
-     */
-    private coachesExpected;
     /** Books a cost on a block, split among its activities by their offerings' sailors. */
     private book;
     /**
@@ -80,8 +73,8 @@ export declare class Staffing {
         holds: Map<Id, number>;
     };
     /**
-     * A trip's coaches each fly and stay; the miles are driven once. Its coaches are the ones its
-     * expected sailors need on the block of its busiest travel day.
+     * A trip's coaches each fly and stay; the miles are driven once. Its coaches are the staff on the
+     * block of its busiest travel day.
      */
     private bookTrips;
 }

package/dist/planning/staffing.js

@@ -1,15 +1,11 @@
-/** Whole kids expected: `target_enrollment` if set, otherwise `capacity × fill_rate` rounded. */
+/** Whole kids expected: `target_enrollment`, or none when it's empty. */
 export function enrollmentOf(offering) {
-    if (offering.target_enrollment != null)
-        return Math.round(offering.target_enrollment);
-    return Math.round((offering.capacity ?? 0) * (offering.fill_rate ?? 0));
+    return Math.round(offering.target_enrollment ?? 0);
 }
 /** The most sailors an offering takes: its `capacity`, or else the sailors expected. */
 export function maxEnrollmentOf(offering) {
     return offering.capacity ?? enrollmentOf(offering);
 }
-/** `n` rounded up, so a share like 5.0000001 boats stays 5. */
-const ceil = (n) => Math.ceil(n - 1e-9);
 function sum(values) {
     let total = 0;
     for (const v of values)
@@ -51,9 +47,9 @@ export class Staffing {
     constructor(ctx) {
         this.ctx = ctx;
     }
-    /** Warns once for each row and plan copy, about the first date it's seen on. */
+    /** Warns once for each row and plan, about the first date it's seen on. */
     warnOnce(code, message, key, scope = {}) {
-        const id = `${code}|${key}|${scope.version_id ?? ""}`;
+        const id = `${code}|${key}|${scope.plan_id ?? ""}`;
         if (this.warned.has(id))
             return;
         this.warned.add(id);
@@ -80,7 +76,7 @@ export class Staffing {
                 continue;
             }
             if (row.date !== a.date) {
-                this.ctx.warn("block_date_mismatch", `${a.offering.name}'s ${a.kind} is in ${row.name}, which is on ${dayOf(row.date)}`, a.stored.key, { version_id: a.stored.version_id, date: a.date });
+                this.ctx.warn("block_date_mismatch", `${a.offering.name}'s ${a.kind} is in ${row.name}, which is on ${dayOf(row.date)}`, a.stored.key, { plan_id: a.stored.plan_id, date: a.date });
             }
             members.set(id, [...(members.get(id) ?? []), a]);
         }
@@ -99,7 +95,6 @@ export class Staffing {
             const byOffering = groupBy(list, (a) => a.offering.id);
             const total = sum([...byOffering.values()].map((own) => enrollment(own[0])));
             const share = (a) => (total > 0 ? enrollment(a) / total : 1 / byOffering.size) / byOffering.get(a.offering.id).length;
-            const most = sum([...byOffering.keys()].map((o) => this.ctx.maxEnrollment.get(o) ?? 0));
             result.set(id, {
                 row,
                 members: list,
@@ -111,7 +106,6 @@ export class Staffing {
                 staff: staff.get(id) ?? [],
                 boats: boats.get(id) ?? [],
                 shares: new Map(list.map((a) => [a, share(a)])),
-                fill: most > 0 ? Math.min(1, total / most) : 1,
             });
         }
         return result;
@@ -125,7 +119,7 @@ export class Staffing {
             if (block !== undefined && sum(block.staff.map((s) => s.count)) > 0)
                 continue;
             this.ctx.warn("unallocated_activity", `${a.offering.name}'s ${a.kind} has no staff`, a.stored.key, {
-                version_id: a.stored.version_id,
+                plan_id: a.stored.plan_id,
                 date: a.date,
             });
         }
@@ -149,7 +143,7 @@ export class Staffing {
         const most = (o) => ctx.maxEnrollment.get(o.id) ?? 0;
         const sailors = sum(offerings.map(most));
         const warns = sailors > 0;
-        const scope = { version_id: block.row.version_id, date: block.row.date };
+        const scope = { plan_id: block.row.plan_id, date: block.row.date };
         // The block's offerings, with the verbs that agree with them: "Guppies Week 2 is for", "has".
         const several = new Set(block.members.map((a) => a.offering.id)).size > 1;
         const is = `${offeringsOf(block)} ${several ? "are" : "is"} for up to`;
@@ -161,7 +155,7 @@ export class Staffing {
             const settings = programs.get(o.product_id);
             if (settings?.staff_level_key == null || settings.sailors_per_coach == null || settings.sailors_per_coach <= 0) {
                 if (warns) {
-                    this.warnOnce("no_program_settings", `${o.name}'s program has no staff level or sailors per coach. Add both to check that it has enough coaches`, o.product_id, { version_id: o.version_id, date: block.row.date });
+                    this.warnOnce("no_program_settings", `${o.name}'s program has no staff level or sailors per coach. Add both to check that it has enough coaches`, o.product_id, { plan_id: o.plan_id, date: block.row.date });
                 }
                 continue;
             }
@@ -208,26 +202,6 @@ export class Staffing {
             holds.set(o.id, Math.min(holds.get(o.id) ?? Infinity, Math.max(0, n)));
         }
     }
-    /**
-     * The coaches a block pays for its expected sailors: Σ (each program's sailors ÷ its sailors per
-     * coach), rounded up, but never more than it's given. Salaried coaches on salary are always paid, so
-     * only the others are cut, each staff row by the same share. When a program has no sailors per
-     * coach, the block pays all it's given.
-     */
-    coachesExpected(block, programs) {
-        const given = sum(block.staff.map((s) => s.count));
-        const salaried = sum(block.staff.filter((s) => s.position_key != null && s.pay !== "hourly").map((s) => s.count));
-        let load = 0;
-        for (const o of new Map(block.members.map((a) => [a.offering.id, a.offering])).values()) {
-            const perCoach = programs.get(o.product_id)?.sailors_per_coach;
-            if (perCoach == null || perCoach <= 0)
-                return { coaches: given, share: 1 };
-            load += (this.ctx.enrollment.get(o.id) ?? 0) / perCoach;
-        }
-        const others = given - salaried;
-        const kept = Math.min(others, Math.max(0, ceil(load) - salaried));
-        return { coaches: salaried + kept, share: others > 0 ? kept / others : 1 };
-    }
     /** Books a cost on a block, split among its activities by their offerings' sailors. */
     book(block, account, amount, line, name, explanation, mtdcShare = 1, wages = false) {
         if (amount === 0 || account === undefined)
@@ -257,17 +231,13 @@ export class Staffing {
         const rates = new Map(ctx.data.plan_boat_rates.map((r) => [r.boat_class_id, r]));
         const classes = new Map(ctx.data.boat_classes.map((c) => [c.id, c]));
         for (const list of groupBy(blocks, (b) => b.row.date).values()) {
-            const chartered = list.flatMap((block) => block.boats.flatMap((b) => {
-                // The boats the expected sailors use, as for its own boats.
-                const n = ceil((b.chartered ?? 0) * block.fill);
-                return n > 0 ? [{ block, id: b.boat_class_id, n }] : [];
-            }));
+            const chartered = list.flatMap((block) => block.boats.flatMap((b) => ((b.chartered ?? 0) > 0 ? [{ block, id: b.boat_class_id, n: b.chartered }] : [])));
             for (const [id, uses] of groupBy(chartered, (c) => c.id)) {
                 const name = classes.get(id)?.name ?? id;
                 const rate = rates.get(id)?.charter_per_day_cents;
                 if (rate == null) {
                     for (const { block } of uses) {
-                        this.warnOnce("no_charter_rate", `${block.row.name} charters ${pluralOf(name)}, but the Operations Plan has no charter rate for them, so they cost nothing`, id, { version_id: block.row.version_id, date: block.row.date });
+                        this.warnOnce("no_charter_rate", `${block.row.name} charters ${pluralOf(name)}, but the Operations Plan has no charter rate for them, so they cost nothing`, id, { plan_id: block.row.plan_id, date: block.row.date });
                     }
                     continue;
                 }
@@ -305,9 +275,9 @@ export class Staffing {
                 const message = peak.at.length === 1
                     ? `${count} out at once for ${offeringsOf(peak.at[0].block)}, but ${organization} has ${only}`
                     : `${count} out at once, but ${organization} has ${only}: ${listOf(peak.at.map(({ block, n }) => `${n} for ${offeringsOf(block)}`))}`;
-                for (const version of new Set(peak.at.map(({ block }) => block.row.version_id))) {
+                for (const plan of new Set(peak.at.map(({ block }) => block.row.plan_id))) {
                     ctx.warn(code, message, what, {
-                        version_id: version,
+                        plan_id: plan,
                         date: date,
                     });
                 }
@@ -343,9 +313,9 @@ export class Staffing {
             const hours = extraCoachMinutes(list) / 60;
             const total = result.get(key) ?? { hours: 0, dates: 0 };
             result.set(key, { hours: total.hours + hours, dates: total.dates + 1 });
-            for (const version of new Set(list.map((b) => b.row.version_id))) {
+            for (const plan of new Set(list.map((b) => b.row.plan_id))) {
                 this.ctx.warn("position_double_booked", `${names.get(key) ?? key} coaches ${clash[0].row.name} and ${clash[1].row.name} at the same time` +
-                    (hours > 0 ? `, so another coach is needed for ${round2(hours)} hours` : ""), key, { version_id: version, date });
+                    (hours > 0 ? `, so another coach is needed for ${round2(hours)} hours` : ""), key, { plan_id: plan, date });
             }
         }
         return result;
@@ -368,13 +338,10 @@ export class Staffing {
         const boatClasses = new Map(ctx.data.boat_classes.map((c) => [c.id, c]));
         const boatRates = new Map(ctx.data.plan_boat_rates.map((r) => [r.boat_class_id, r]));
         const given = new Map();
-        const tripCoaches = new Map();
         for (const block of byDate(blocks)) {
-            const scope = { version_id: block.row.version_id, date: block.row.date };
+            const scope = { plan_id: block.row.plan_id, date: block.row.date };
             const paidHours = block.paid_minutes / 60;
             const waterHours = block.on_water_minutes / 60;
-            const expected = this.coachesExpected(block, programs);
-            tripCoaches.set(block.row.id, expected.coaches);
             const book = (type, amount, line, name, explanation) => this.book(block, ctx.costAccount(type), amount, line, name, explanation, 1, type === "coach_wages");
             let wages = 0;
             for (const s of block.staff) {
@@ -383,7 +350,7 @@ export class Staffing {
                 if (s.position_key != null) {
                     const position = positions.get(s.position_key);
                     if (s.pay === "hourly") {
-                        const hours = s.count * expected.share * paidHours;
+                        const hours = s.count * paidHours;
                         const rate = position?.hourly_coaching_rate_cents;
                         if (position !== undefined && rate == null) {
                             this.warnOnce("no_hourly_rate", `${position.name} is paid by the hour to coach but has no own hourly coaching rate, so those hours cost nothing`, position.key, scope);
@@ -419,18 +386,16 @@ export class Staffing {
                     continue;
                 }
                 if (level.pay_type !== "volunteer") {
-                    wages += s.count * expected.share * paidHours * (level.hourly_rate_cents ?? 0);
+                    wages += s.count * paidHours * (level.hourly_rate_cents ?? 0);
                 }
             }
-            book("coach_wages", wages, "coach_wages", "Coach wages", "Coaches the expected sailors need × paid hours × each one's hourly rate");
+            book("coach_wages", wages, "coach_wages", "Coach wages", "Staff × paid hours × each one's hourly rate");
             for (const b of block.boats) {
                 const rate = boatRates.get(b.boat_class_id);
                 if (rate === undefined || b.count <= 0 || waterHours <= 0)
                     continue;
                 const boatClass = boatClasses.get(b.boat_class_id);
-                this.book(block, boatClass?.account_id ?? ctx.costAccount("boat_maintenance"), ceil(b.count * block.fill) *
-                    waterHours *
-                    (rate.maintenance_per_boat_hour_cents + (rate.fuel_per_hour_cents ?? 0)), `boats:${b.boat_class_id}`, `Boats: ${boatClass?.name ?? "boats"}`, "The organization's boats the expected sailors use × on-water hours × the class's fuel and upkeep");
+                this.book(block, boatClass?.account_id ?? ctx.costAccount("boat_maintenance"), b.count * waterHours * (rate.maintenance_per_boat_hour_cents + (rate.fuel_per_hour_cents ?? 0)), `boats:${b.boat_class_id}`, `Boats: ${boatClass?.name ?? "boats"}`, "The organization's boats × on-water hours × the class's fuel and upkeep");
             }
             const coaches = sum(block.staff.map((s) => s.count));
             const boats = sum(block.boats.map((b) => b.count + (b.chartered ?? 0)));
@@ -439,7 +404,7 @@ export class Staffing {
             }
         }
         this.bookCharters(byDate(blocks));
-        this.bookTrips(blocks, scheduled, tripCoaches);
+        this.bookTrips(blocks, scheduled);
         return {
             coaching,
             doubleBooked,
@@ -461,10 +426,10 @@ export class Staffing {
         };
     }
     /**
-     * A trip's coaches each fly and stay; the miles are driven once. Its coaches are the ones its
-     * expected sailors need on the block of its busiest travel day.
+     * A trip's coaches each fly and stay; the miles are driven once. Its coaches are the staff on the
+     * block of its busiest travel day.
      */
-    bookTrips(blocks, scheduled, coachesOf) {
+    bookTrips(blocks, scheduled) {
         const { ctx } = this;
         for (const trip of ctx.data.plan_trips) {
             const offering = ctx.offeringsById.get(trip.offering_id);
@@ -472,14 +437,13 @@ export class Staffing {
                 continue;
             const travel = (a) => a.kind === "travel" && a.trip?.id === trip.id;
             const staffed = [...blocks.values()].filter((b) => b.members.some(travel));
-            const coaches = Math.max(0, ...staffed.map((b) => coachesOf.get(b.row.id) ?? 0));
-            const given = Math.max(0, ...staffed.map((b) => sum(b.staff.map((s) => s.count))));
-            if (given === 0 && ((trip.airfare_cents ?? 0) > 0 || (trip.nights ?? 0) > 0)) {
+            const coaches = Math.max(0, ...staffed.map((b) => sum(b.staff.map((s) => s.count))));
+            if (coaches === 0 && ((trip.airfare_cents ?? 0) > 0 || (trip.nights ?? 0) > 0)) {
                 const first = scheduled
                     .filter(travel)
                     .map((a) => a.date)
                     .sort()[0];
-                this.warnOnce("trip_without_staff", `${trip.name} has no staff on its travel days, so the plan has no airfare or lodging for its coaches`, trip.key, { version_id: trip.version_id, ...(first !== undefined && { date: first }) });
+                this.warnOnce("trip_without_staff", `${trip.name} has no staff on its travel days, so the plan has no airfare or lodging for its coaches`, trip.key, { plan_id: trip.plan_id, ...(first !== undefined && { date: first }) });
             }
             const lodging = ctx.rates?.lodging_per_night_cents ?? null;
             const mileage = ctx.rates?.mileage_rate_cents ?? null;