They remember night ${
+ o.remembers.map((s) => s.night).join(' and night ')
+ } — you took another job.
` : ''}
`;
};
@@ -860,7 +909,20 @@ export function createHud(d) {
Both are tonight. You cannot work two yards in one storm.
+ ${/* ⚖️ SPRINT18 gate 0, clause 5 — THE ASYMMETRY, SAID IN WORDS.
+ A morning with a booked job on it: turning it down costs your name,
+ and the offer that costs says so on its own card. A morning with
+ NOTHING booked (two callouts — legal, and what gate 1's emergency
+ makes reachable): declining is genuinely free, and the note SAYS
+ free rather than leaving the player to infer it from an absence.
+ "No cost shown" and "no cost" have to be the same sentence on a
+ document, or the quiet morning teaches the same lie the loud one
+ would. */''}
+ ${
+ offers.some((o) => o.booked)
+ ? 'Both are tonight. You cannot work two yards in one storm.'
+ : 'Nobody has you booked tonight. Neither of these costs you anything to turn down.'
+ }
Fees quoted on the forecast at time of callout. Weather is not a variation.
`;
card.classList.add('on');
@@ -936,6 +998,15 @@ showForecast({ key, def, site, tomorrowDef }, wk, onGo) {
const brief = job.brief
? `They have not forgotten night ${
+ wk.remembers.map((s) => s.night).join(' and night ')
+ }. You are here on their second-choice terms.
` : '';
+
// SPRINT17 gate 2 — THE CLIENT'S TERMS, on the sheet, in their words.
// Under the brief and above the weather on purpose: the constraint is
// part of what they're asking for, not a footnote to it, and the player
@@ -1028,6 +1099,7 @@ showForecast({ key, def, site, tomorrowDef }, wk, onGo) {
card.innerHTML = `
${letterhead}
${brief}
+ ${remembers}
${constraintBlock}
NIGHT ${wk.night} OF ${wk.nights}
${pips}
@@ -1253,6 +1325,31 @@ showForecast({ key, def, site, tomorrowDef }, wk, onGo) {
every decision on it. Off the settlement (week.js carries
s.constraints), so it stays true when you re-read night 3's
invoice on night 5's morning. */''}
+ ${/* ⚖️ SPRINT18 gate 0, clause 4 — THE INVOICE STATES WHICH JOB YOU TOOK
+ AND WHAT IT COST YOU TO TAKE IT. Both papers, same as gate 2's
+ constraints: the offer card priced the decision, this is the record
+ of having made it. Off the settlement (week.js carries `taken` and
+ `stoodUp`), so night 5's invoice still names night 5's broken promise
+ when you re-read it on night 7's morning.
+
+ The standing row prints even at zero cost — an off-the-board job on a
+ morning where nothing was booked SAYS so ("nobody was expecting you"),
+ because gate 0's asymmetry has to be legible on the paper as well as
+ on the card. This is the one place the free case is worth a line
+ rather than a silence: the invoice is the document that explains, and
+ a player who paid the price on Tuesday should be able to see why
+ Thursday was free. */''}
+ ${w?.taken ? `
+
OFF THE BOARD
+
+
you took this callout${w.client ?? 'no client'}
+ ${w.stoodUp?.length
+ ? w.stoodUp.map((s) => `
+
stood up ${s.client ?? 'a client'} — they were expecting you${
+ starDelta(REP.STOOD_UP)} standing
+
No invoice for that one. They will remember the phone call.
`).join('')
+ : '
nobody was expecting you — nothing to stand up—
'}
+
` : ''}
${w?.constraints?.length ? `
PAID UNDER THESE TERMS
diff --git a/web/world/js/main.js b/web/world/js/main.js
index eea404d..fc7ece0 100644
--- a/web/world/js/main.js
+++ b/web/world/js/main.js
@@ -1050,6 +1050,14 @@ export async function boot(opts = {}) {
fee: def ? calloutFee(def, week.rep, night.constraints) : null,
exposure: exp.total,
exposureItems: exp.items,
+ // ⚖️ SPRINT18 gate 0, clause 3 — THE STOOD-UP CLIENT REMEMBERS. Injected
+ // here with the rest of the per-offer facts because the memory is week
+ // state and board.js is pure: same seam as the fee and the exposure, and
+ // the card renders nothing when the list is empty (the degradation rule
+ // every other injected field follows). A client you left waiting on
+ // Tuesday and who is on the board again on Thursday is the whole of
+ // "your work follows you", and it costs one line.
+ remembers: week.remembers(night.client),
};
});
}
@@ -1117,6 +1125,11 @@ export async function boot(opts = {}) {
// (quote.rep), but the sheet renders a letterhead even on nights whose
// quote degrades away, so it rides the week block explicitly.
rep: week.rep,
+ // ⚖️ SPRINT18 gate 0 — and if you have stood THIS client up before, the
+ // sheet says so under their brief. The board's card is where the memory
+ // changes a decision; the sheet is where it changes the room you walk
+ // into. Same week ledger, read by name.
+ remembers: week.remembers(week.job?.client),
},
() => { stormKey = week.stormKey; game.setPhase('prep'); },
);
diff --git a/web/world/js/tests/a.test.js b/web/world/js/tests/a.test.js
index 8a907fd..869561c 100644
--- a/web/world/js/tests/a.test.js
+++ b/web/world/js/tests/a.test.js
@@ -25,7 +25,11 @@ import {
} from '../week.js';
// SPRINT17 gate 1/2 — the board and the constraint data are mine; these are
// the seam this suite pins (offer shape, pool, exposure, constraint enum).
-import { CONSTRAINT_PREMIUM, POOL, exposureOf, validateConstraint } from '../board.js';
+import {
+ CONSTRAINT_PREMIUM, POOL, exposureOf, validateConstraint,
+ // SPRINT18 gate 0 — the ruling's structural half: who a take stands up.
+ isBooked, standUpsIfTaken,
+} from '../board.js';
import { createHud } from '../hud.js';
import { PALETTE, boundsFaults, emptyTemplate, exportSiteJSON, placeEntry } from '../editor.js';
import { assert, assertClose, assertEq, assertLess, fixedLoop } from '../testkit.js';
@@ -698,6 +702,170 @@ export default async function run(t) {
}
});
+ // --- ⚖️ SPRINT18 gate 0: DECLINING A BOOKED NIGHT COSTS YOU ---------------
+ // John's ruling, 2026-07-25, on D's cold-play filing: "it adds pressure."
+ // The board was a free option — a fee-maximizer could dodge the wildnight AND
+ // the designed-loss icenight at zero cost and never meet the week's two
+ // hardest lessons. These pin the ruling's five clauses.
+
+ t.test('SPRINT18 gate 0: the DIARY is booked and the PHONE is not — the asymmetry, every night', () => {
+ const w = createWeek();
+ for (let i = 0; i < NIGHTS.length; i++) {
+ const [booked, callout] = w.offers();
+ assertEq(booked.booked, true, `night ${i + 1}: the scripted job is a booking — a client has you down`);
+ assertEq(callout.booked, false, `night ${i + 1}: a pool callout is the phone ringing, not a promise`);
+ // Taking the job you were booked for stands NOBODY up. This is the half
+ // that would silently invert if `booked` were ever derived from the night
+ // alone (it was, in the first cut, and the pool yard came back booked —
+ // taking the spine then printed "the Karalis place is expecting you" over
+ // a client nobody had promised anything).
+ assertEq(booked.standsUp.length, 0, `night ${i + 1}: keeping your word costs nothing`);
+ assertEq(callout.standsUp.length, 1, `night ${i + 1}: taking the callout stands the booked client up`);
+ assertEq(callout.standsUp[0].client, nightAt(i).client,
+ `night ${i + 1}: and it names WHO, in the client's own name, on the card`);
+ w.advance();
+ }
+ });
+
+ t.test('SPRINT18 gate 0: the number is the MIRROR of a clean night, and cannot outrank a wrecked carport', () => {
+ // ⚖️ A's ruling. The structural half lives in board.js and the number in
+ // week.js §REP (board.js must not import week.js — week imports board). This
+ // is the pin that stops the two halves drifting into a coincidence.
+ assertEq(REP.STOOD_UP, -REP.CLEAN,
+ 'a stood-up client must cost exactly what a flawless night earns — one night of perfect '
+ + 'work, cancelled by one phone call you didn\'t make');
+ assertLess(Math.abs(REP.STOOD_UP), Math.abs(REP.COLLATERAL),
+ 'standing a client up must not rank above WRECKING THEIR PROPERTY, or the invoice argues with itself');
+ assert(REP.STOOD_UP < 0, 'and it is a cost, not a reward');
+ // Half-steps, like every other rep constant — the letterhead prints exact
+ // numbers and a third of a star is a float on a business document.
+ assertEq(REP.STOOD_UP * 2, Math.round(REP.STOOD_UP * 2), 'the cost lands on a half-star');
+ });
+
+ t.test('SPRINT18 gate 0: the cost lands at DAWN, on the invoice, and does NOT move tonight\'s fee', () => {
+ if (!boardDefs.storm_01_gentle) return 'SKIPPED — no server for storm defs';
+ const w = createWeek();
+ const [booked, callout] = w.offers();
+ const def = boardDefs[callout.night.storm];
+ if (!def) return 'SKIPPED — no def for the drawn alternative';
+ // The fee as the OFFER CARD printed it, priced at this morning's standing.
+ const cardFee = calloutFee(def, w.rep, callout.night.constraints);
+ w.take(callout);
+ // ⚠️ THE SEAM THIS PIN EXISTS FOR. Charging the standing inside take() would
+ // drop rep between the board and the job sheet, and the fee is priced off
+ // rep — so the card would advertise one number and the sheet, one click
+ // later, would quote another. That is the quote-vs-settle lie moved one card
+ // earlier, which is the exact bug calloutFee() was extracted to make
+ // impossible. The cost lands at DAWN with every other rep movement.
+ assertEq(w.rep, REP.START, 'standing does not move at the board — the fee is quoted off it');
+ assertEq(w.quote(def).base, cardFee, 'the sheet quotes exactly what the card advertised');
+
+ const s = w.settle({ hp: 100, win: true, collateral: [], intactHardwareValue: 0, rigRecord: [] }, def, 0);
+ assertEq(s.fullFee, cardFee, 'and the invoice pays it');
+ // Clause 4: the invoice states which job you took and what it cost to take it.
+ assertEq(s.taken, callout.id, 'the invoice says the job came off the board');
+ assertEq(s.stoodUp.length, 1, 'and names the client it stood up');
+ assertEq(s.stoodUp[0].client, booked.night.client);
+ assertEq(s.standUpCost, REP.STOOD_UP, 'with the standing it cost, already multiplied');
+ assert(s.repReasons.some((r) => r.includes('stood up')),
+ `the repline must say WHY standing moved, got ${JSON.stringify(s.repReasons)}`);
+ // ADDITIVE, not exclusive: a clean night at the yard you went to instead
+ // nets to level. You did good work — for somebody else, on a night you were
+ // promised elsewhere.
+ assertEq(s.rep, REP.START + REP.CLEAN + REP.STOOD_UP,
+ 'a clean night on a stood-up promise nets to level, and that is the ruling working');
+ });
+
+ t.test('SPRINT18 gate 0: the stood-up client REMEMBERS — and one decision is charged once', () => {
+ const w = createWeek();
+ const [booked, callout] = w.offers();
+ assertEq(w.remembers(booked.night.client).length, 0, 'nobody remembers anything on night one');
+ w.take(callout);
+ const mem = w.remembers(booked.night.client);
+ assertEq(mem.length, 1, 'the client you left waiting remembers it');
+ assertEq(mem[0].night, 1, 'and remembers WHICH night — the card and the sheet print it');
+ assertEq(mem[0].took, callout.night.client, 'the ledger records who you went to instead');
+ // Taking twice on one morning is the SAME take (S17's commitment rule), so it
+ // must be ONE broken promise. A double charge for one decision would be the
+ // worst kind of bug: invisible, and in the direction of punishment.
+ w.take(callout);
+ w.take(booked);
+ assertEq(w.standUps.length, 1, 'one decision, one broken promise');
+ // And the memory is READ-ONLY to its readers — hud.js's charter is that the
+ // face never takes a decision, and a getter handing out the live array is a
+ // card one `.push` away from inventing a grudge.
+ w.standUps.push({ night: 99, client: 'a card that pushed' });
+ assertEq(w.standUps.length, 1, 'week.standUps hands out a copy');
+ // A new week is a clean slate — the clients forget when the run does.
+ w.reset();
+ assertEq(w.standUps.length, 0, 'reset clears the ledger; a memory outliving its run is a bug');
+ });
+
+ t.test('SPRINT18 gate 0: TWO CALLOUTS, NO BOOKED JOB — declining is FREE, and that is not vacuous', () => {
+ // Clause 5. A legal board state the moment gate 1's emergency exists: an
+ // emergency arrives in the diary's chair but nobody booked you, so nobody is
+ // stood up. Built here from the predicate rather than from a shipped night,
+ // because the point is that the FREE case falls out of the filter returning
+ // nothing — not out of an `if` somebody remembered to write.
+ assertEq(isBooked('scripted', { storm: 'storm_01_gentle' }), true,
+ 'an ordinary diary night is a booking');
+ assertEq(isBooked('scripted', { storm: 'storm_01_gentle', emergency: { arriveAt: 30 } }), false,
+ 'an EMERGENCY in the diary slot is not a booking — the phone rang, nobody had you down');
+ assertEq(isBooked('callout', { storm: 'storm_01_gentle' }), false, 'a callout is never a booking');
+
+ const free = [
+ { id: 'scripted', booked: false, night: { client: 'the Karalis place' } },
+ { id: 'alt:x', booked: false, night: { client: 'the Delaneys' } },
+ ];
+ assertEq(standUpsIfTaken(free, free[0]).length, 0, 'nothing booked ⇒ taking either costs nothing');
+ assertEq(standUpsIfTaken(free, free[1]).length, 0, 'in both directions');
+ // ⚠️ THE VACUITY GUARD, and it is the whole reason this test is worth its
+ // line: a `standUpsIfTaken` that always returned [] would pass every assert
+ // above. Flip ONE flag and the charge must appear.
+ const booked = [{ ...free[0], booked: true }, free[1]];
+ assertEq(standUpsIfTaken(booked, booked[1]).length, 1,
+ 'and the free result is produced by an empty board, not by a function that cannot charge');
+ assertEq(standUpsIfTaken(booked, booked[0]).length, 0, 'while taking the booking itself is still free');
+ });
+
+ t.test('SPRINT18 gate 0: the price is on the CARD before the choice, and the free morning SAYS free', () => {
+ if (typeof document === 'undefined') return 'SKIPPED — no DOM';
+ // "A choice whose price is invisible until the invoice is a trap, and this
+ // repo doesn't ship traps without tells." The ruling names the card
+ // explicitly, so the card is pinned in DOM — the S12 lesson: both of that
+ // sprint's card bugs were invisible to a suite that never rendered one.
+ const w = createWeek();
+ const offers = w.offers();
+ const hud = createHud({ scene: new THREE.Scene() });
+ try {
+ hud.showBoard(offers, { night: 1, nights: NIGHTS.length, bank: 80, log: [], rep: 3.0 }, () => {});
+ const cards = [...document.querySelectorAll('#hud-card .offer')];
+ assertEq(cards.length, 2, 'two offers rendered');
+ assert(!cards[0].querySelector('.cost'), 'the booked job costs nothing to take — no cost line on it');
+ const cost = cards[1].querySelector('.cost');
+ assert(cost, 'the CALLOUT card must print what taking it costs, before the choice');
+ const text = cost.textContent;
+ assert(text.includes(nightAt(0).client),
+ `in the client's own terms — expected "${nightAt(0).client}", got "${text}"`);
+ assert(text.includes('expecting you'), `and in plain words, got "${text}"`);
+ assert(text.includes('½★'), `as a half-star, not a float, got "${text}"`);
+ assert(text.includes('−'), `and signed as a debit, got "${text}"`);
+
+ // The free morning: nothing booked, and the note SAYS free rather than
+ // leaving a player to infer it from an absence.
+ const note = document.querySelector('#hud-card .board-note')?.textContent ?? '';
+ assert(note.includes('cannot work two yards'), `a booked morning reads as normal, got "${note}"`);
+ hud.hideCard();
+ const freeOffers = offers.map((o) => ({ ...o, booked: false, standsUp: [] }));
+ hud.showBoard(freeOffers, { night: 1, nights: NIGHTS.length, bank: 80, log: [], rep: 3.0 }, () => {});
+ const freeNote = document.querySelector('#hud-card .board-note')?.textContent ?? '';
+ assert(freeNote.includes('costs you anything to turn down'),
+ `a morning with nothing booked must SAY declining is free, got "${freeNote}"`);
+ assert(!document.querySelector('#hud-card .offer .cost'),
+ 'and no offer on it carries a cost line');
+ } finally { hud.dispose(); }
+ });
+
// Gate 2 acceptance: both sites load from data, and the corner block is not
// the backyard with the furniture moved. Built up front (Suite.test() can't
// await — the guard I added last sprint enforces it, and just caught me).
diff --git a/web/world/js/week.js b/web/world/js/week.js
index 895f834..df431df 100644
--- a/web/world/js/week.js
+++ b/web/world/js/week.js
@@ -387,6 +387,31 @@ export const REP = {
WARRANTY: -0.5,
/** Per collateral event. Down harder: their property beats your hardware. */
COLLATERAL: -1.0,
+ /**
+ * ⚖️ **SPRINT18 gate 0 — PER CLIENT YOU STOOD UP. JOHN'S RULING: declining a
+ * booked night costs you. "It adds pressure."**
+ *
+ * THE MIRROR OF `CLEAN`, exactly, and the full reasoning is in board.js beside
+ * `isBooked` (the structural half lives there because board.js cannot import
+ * this file). The short form: a stood-up client costs you what a flawless
+ * night earns — one night of perfect work, cancelled by one phone call you
+ * didn't make. Bounded above by `COLLATERAL` on purpose; ranking a broken
+ * promise above a broken carport would make the invoice argue with itself.
+ *
+ * ⚠️ UNMEASURED, and it is the lever. If John's play says the price is wrong,
+ * move THIS number — not `CLEAN`, which the rest of the ladder is measured
+ * against. a.test pins `STOOD_UP === -CLEAN` so the mirror cannot rot into a
+ * coincidence.
+ *
+ * WHEN it lands: at DAWN, with every other rep movement, and that ordering is
+ * load-bearing. You stand a client up in the morning; the reckoning is on the
+ * night's paper. Charging it inside take() would drop your standing between the
+ * board and the job sheet, and the fee is priced off standing — so the offer
+ * card would advertise $57 and the sheet one click later would quote $56. That
+ * is the quote-vs-settle lie, moved one card earlier, which is the exact bug
+ * calloutFee() exists to make impossible.
+ */
+ STOOD_UP: -0.5,
/** Callout-fee multiplier at rep r. Exact at 2dp for every half-step. */
multiplier: (r) => 1 + 0.04 * (r - 3),
};
@@ -485,6 +510,10 @@ export function gustPeakOf(def) {
* last dawn's brokenAtDawn corners) {anchorId, hw, cost, night, site, addr, client}
* @property {number} warrantyTotal
* @property {number} feeMult rep multiplier the fee was priced at
+ * @property {object[]} stoodUp SPRINT18 gate 0 — clients this night's take left
+ * waiting {night, client, addr, offerId, took}; `standUpCost` is the standing
+ * it cost, already multiplied.
+ * @property {number} standUpCost
* @property {number} rep after tonight's movement (repBefore/repDelta/repReasons too)
* @property {number} warrantiesToDate cumulative items this week, for the end card
*/
@@ -524,6 +553,21 @@ export function createWeek(opts = {}) {
*/
const taken = new Map();
const jobAt = (i) => taken.get(i) ?? nightAt(i);
+ /**
+ * ⚖️ SPRINT18 gate 0 — **THE CLIENTS YOU STOOD UP.** John's ruling's third
+ * clause: *"the stood-up client remembers."*
+ *
+ * Append-only, in night order, one entry per client stood up:
+ * `{night, client, addr, offerId, took}` — `night` 1-based (it is printed),
+ * `offerId` the job you took instead, `took` the client you took instead.
+ *
+ * A LEDGER, not a flag, and that is the whole of "your work follows you": the
+ * board reads it to put the memory on that client's next offer card, the job
+ * sheet reads it if you go back to them, and settle() reads TONIGHT'S entries
+ * to move standing. One place, three surfaces, no surface deciding anything.
+ * @type {{night:number,client:string|null,addr:string|null,offerId:string|null,took:string|null}[]}
+ */
+ const standUps = [];
/** @type {Settlement[]} */
const log = [];
@@ -643,9 +687,20 @@ export function createWeek(opts = {}) {
},
/**
- * TAKE ONE. The other vanishes — no backlog, no decline cost (SPRINT18
- * decides whether saying no costs you; SPRINT17 deliberately does not
- * charge for a choice it hasn't designed the consequences of).
+ * TAKE ONE. The other vanishes — and ⚖️ **SPRINT18 gate 0: if the other one
+ * had a client expecting you, you have just stood them up.** John's ruling,
+ * landed here because this is the one door both offers go through.
+ *
+ * The charge itself is at DAWN (settle reads tonight's `standUps` entries and
+ * moves standing with the rest) — see REP.STOOD_UP for why that ordering is
+ * not a detail. What happens HERE is the RECORD: who you left waiting, on
+ * which night, for what.
+ *
+ * `offer.standsUp` comes off board.js, so the cost the player read on the
+ * card is the cost that gets recorded. A hand-made offer with no board
+ * context (a.test does this deliberately, and so does any future scripted
+ * install) stands nobody up, which is the honest answer: nothing declined
+ * anybody.
*
* Idempotent per night and only forward: taking twice on the same morning
* is the same take, and there is no untake. That's not a limitation, it's
@@ -669,6 +724,17 @@ export function createWeek(opts = {}) {
const night = normaliseNight(offer.night);
Object.defineProperty(night, '_offerId', { value: offer.id, enumerable: false });
taken.set(index, night);
+ // ⚖️ gate 0 — the promise you just broke, written down before anything
+ // else can happen. Inside the `if` so the idempotence above covers it
+ // too: taking twice on one morning must not stand the same client up
+ // twice, and a double charge for one decision would be the worst kind of
+ // bug — invisible, and in the direction of punishment.
+ for (const s of offer.standsUp ?? []) {
+ standUps.push({
+ night: index + 1, client: s.client, addr: s.addr,
+ offerId: s.id, took: night.client ?? null,
+ });
+ }
}
return taken.get(index);
},
@@ -676,6 +742,23 @@ export function createWeek(opts = {}) {
/** Tonight's taken offer id, or null if the player is on the spine. */
get takenOffer() { return taken.get(index)?._offerId ?? null; },
+ /**
+ * ⚖️ SPRINT18 gate 0 — the stand-up ledger, read-only.
+ *
+ * A copy, because this is the one piece of week state a CARD reads directly
+ * and a card that could push onto it would be a HUD taking a decision
+ * (hud.js's own charter, first paragraph).
+ */
+ get standUps() { return standUps.slice(); },
+ /**
+ * Has this client been stood up, and when? The memory, per client — the
+ * board's offer card and the job sheet both ask this by name.
+ * @param {string|null} client
+ */
+ remembers(client) {
+ return client ? standUps.filter((s) => s.client === client) : [];
+ },
+
/** SPRINT17 — the week's draw seed, for the board and for a.test's pins. */
get seed() { return seed; },
@@ -693,6 +776,10 @@ export function createWeek(opts = {}) {
// for the run), so clearing the takes is what makes "play it again"
// actually replayable rather than handing you last run's choices.
taken.clear();
+ // gate 0: and the clients forget. A new week that opened with last run's
+ // broken promises on the board would be the memory outliving the run that
+ // earned it — the same defect as an uncleared `taken`, one surface along.
+ standUps.length = 0;
return week;
},
@@ -794,6 +881,18 @@ export function createWeek(opts = {}) {
repDelta += REP.COLLATERAL * collateralEvents;
repReasons.push(`broke ${collateralEvents > 1 ? 'things' : 'something'} of theirs`);
}
+ // ⚖️ SPRINT18 gate 0 — THE PRICE OF SAYING NO, settled with everything else
+ // tonight's work earned or cost. take() recorded it this morning; the
+ // invoice states it tonight, in the same repline that already explains
+ // every other movement. Note it is ADDITIVE, not exclusive: standing a
+ // client up and then having a clean night at the yard you went to instead
+ // is +0.5 −0.5 = level, and that is exactly right — you did good work, for
+ // somebody else, on a night you were promised elsewhere.
+ const stoodUp = standUps.filter((s) => s.night === week.night);
+ if (stoodUp.length > 0) {
+ repDelta += REP.STOOD_UP * stoodUp.length;
+ repReasons.push(`stood up ${stoodUp.map((s) => s.client ?? 'a client').join(' · ')}`);
+ }
rep = Math.min(REP.MAX, Math.max(REP.MIN, rep + repDelta));
repDelta = rep - repBefore; // what actually moved, after the clamp
@@ -815,6 +914,13 @@ export function createWeek(opts = {}) {
constraints: job.constraints ?? [],
premium: premiumFor(job.constraints),
taken: taken.has(index) ? (taken.get(index)._offerId ?? true) : false,
+ // ⚖️ SPRINT18 gate 0, clause 4 — THE INVOICE STATES WHAT IT COST YOU TO
+ // TAKE THIS JOB. Rides the settlement, like `constraints` and for the
+ // identical reason: night 5's invoice must still name the client night 5
+ // stood up when you re-read it on night 7. `standUpCost` is pre-multiplied
+ // so no surface has to know the constant to print the number.
+ stoodUp,
+ standUpCost: REP.STOOD_UP * stoodUp.length,
// SPRINT16 — the ledger. The rig record IS the work history (the night
// computed all of it; the week just keeps it), the warranty items are
// tonight's sheet answered on the invoice, and the rep block is the