briefing-payload.test.ts

apps/dashboard/test/briefing-payload.test.ts

1. /**
2. * The payload is a CONTRACT, not an output. Something downstream (a Python
3. * analysis service, a local model, a person) reads it and writes sentences that
4. * get shown to the team. These tests pin the properties that make those
5. * sentences safe.
6. *
7. * The two that matter most:
8. * 1. null never becomes 0. A dead source and an empty queue are opposite in
9. * meaning and identical in shape.
10. * 2. the interpretation rules ship INSIDE the payload. A consumer that has the
11. * numbers but not the rules is more dangerous than one with no data.
12. */
14. import { describe, expect, it } from 'vitest'
15. import { FIXTURE_SNAPSHOT } from '../src/fixtures.js'
16. import { orderQueue, orderQueueByDesigner, headline, todoLoad } from '../src/collect.js'
17. import { queueView, sourceStatuses } from '../src/view-model.js'
18. import {
19. KNOWN_NON_ROSTER_NINETY,
20. MERIDIAN_PEOPLE,
21. personFromNinety,
22. resolveNinety,
23. unmappedNinetyOwners,
24. } from '../../../config/meridian-people.js'
25. import {
26. buildBriefingPayload,
27. EXEC_RULES,
28. INTERPRETATION_RULES,
29. LIST_CAP,
30. PAYLOAD_SCHEMA_VERSION,
31. UNMEASURABLE,
32. } from '../src/briefing-payload.js'
33. import { displayOrderNumber, isDisplayOrderNumber } from '@meridian/plinth-client'
35. const snap = FIXTURE_SNAPSHOT
37. describe('displayOrderNumber', () => {
38. it('builds the number people actually say out loud', () => {
39. expect(displayOrderNumber(39582, '2026-03-04T00:00:00Z')).toBe('MD2639582')
40. })
42. it('pads a single-digit year', () => {
43. expect(displayOrderNumber(39582, '2009-03-04T00:00:00Z')).toBe('MD0939582')
44. })
46. it('returns the bare id rather than guessing a year', () => {
47. // A wrong order number is worse than an obviously partial one: it looks
48. // searchable and silently is not.
49. expect(displayOrderNumber(39582, null)).toBe('39582')
50. expect(isDisplayOrderNumber('39582')).toBe(false)
51. })
52. })
54. describe('orderQueue', () => {
55. const rows = orderQueue(snap.orderLines.data)
57. it('only lists work this team owes', () => {
58. // Waiting-on-client is a follow-up list, not a queue. Including it is how a
59. // dashboard makes the team look behind when it is not.
60. expect(rows.length).toBeGreaterThan(0)
61. expect(rows.length).toBeLessThan(snap.orderLines.data.length)
62. })
64. it('gives every row a pasteable order number', () => {
65. for (const r of rows) expect(isDisplayOrderNumber(r.orderNumber)).toBe(true)
66. })
68. it('sorts oldest first, because the top of the list is what is rotting', () => {
69. const ages = rows.map((r) => r.ageDays ?? -1)
70. expect([...ages].sort((a, b) => b - a)).toEqual(ages)
71. })
73. it('never echoes the order number back as a product name', () => {
74. // An order-level export puts the order number in the title slot. Repeating
75. // it in the column beside it is noise wearing the costume of data.
76. for (const r of rows) {
77. expect(r.product).not.toBe(r.orderNumber)
78. expect(r.product).not.toBe(String(r.orderId))
79. expect(r.product === null || r.product.length > 0).toBe(true)
80. }
81. })
83. it('groups under the holder, with unassigned last', () => {
84. const groups = orderQueueByDesigner(snap.orderLines.data)
85. expect(groups.length).toBeGreaterThan(0)
86. const nullAt = groups.findIndex((g) => g.designer === null)
87. if (nullAt !== -1) expect(nullAt).toBe(groups.length - 1)
88. expect(groups.flatMap((g) => g.rows)).toHaveLength(rows.length)
89. })
90. })
92. describe('Ninety owners resolve through the roster, not by name equality', () => {
93. // The failure this guards: Ninety spells names as someone typed them
94. // ("Samuel Whitaker", "Marco Ibanez", "Rafael Monterro") against a roster
95. // reading "Sam Whitaker", "Marco Ibáñez", "Rafael Montero". A name-equality
96. // join matches nothing for those people, and their briefings report zero
97. // to-dos, indistinguishable from being idle.
98. //
99. // Every ninetyId is pinned, so these tests assert the id join. What matters
100. // is that every owner resolves, not how; a test that pinned a particular
101. // workaround would make it read as a requirement.
103. // The Ninety directory: id, and the spelling Ninety sends.
104. const DIRECTORY: [string, string, string][] = [
105. ['8326a8602530a97b5afd91ae', 'Nora Lindqvist', 'Nora Lindqvist'],
106. ['6d8c1631dc0c3eda4c26b839', 'Theo Bassett', 'Theo Bassett'],
107. ['4e77bc9877e856992de26b64', 'Ines Carvalho', 'Ines Carvalho'],
108. ['3e894807d73d5a39b03fb411', 'Samuel Whitaker', 'Sam Whitaker'],
109. ['8466ef547c9f9a6ee92fe8a0', 'Marco Ibanez', 'Marco Ibáñez'],
110. ['05b7014d82e5b5ed5e68b309', 'Rafael Monterro', 'Rafael Montero'],
111. ]
113. it('resolves every id in the live directory to the right person', () => {
114. for (const [id, ninetyName, rosterName] of DIRECTORY) {
115. expect(personFromNinety(id, ninetyName)?.name, `${ninetyName} must resolve`).toBe(rosterName)
116. }
117. })
119. it('resolves a DEPARTED person’s id to nobody, rather than to their successor', () => {
120. // Hazel's Ninety account. Rosa took her mailbox, her Plinth assignment and
121. // her seat, and deliberately not her Ninety id: that id is an account, and
122. // reusing it would put Hazel's commitments on Rosa's briefing as though she
123. // had agreed to them. Anything still open under it is held by nobody on
124. // this roster; the fix for that is in Ninety.
125. expect(personFromNinety('a568c7b30679efe19e6ed3a1', 'Hazel Okafor')).toBeNull()
126. })
128. it('resolves a drifted spelling by id, which is the point of pinning them', () => {
129. // The name Ninety sends for these three does not match the roster; the id
130. // does, so the spelling does not matter.
131. expect(personFromNinety('3e894807d73d5a39b03fb411', 'Samuel Whitaker')?.name).toBe('Sam Whitaker')
132. expect(personFromNinety('8466ef547c9f9a6ee92fe8a0', 'Marco Ibanez')?.name).toBe('Marco Ibáñez')
133. expect(personFromNinety('05b7014d82e5b5ed5e68b309', 'Rafael Monterro')?.name).toBe('Rafael Montero')
134. })
136. it('survives a name Ninety has never sent before', () => {
137. // The failure mode pinning exists to prevent: someone retypes a name in
138. // Ninety and the person keeps resolving because the id did not change.
139. expect(personFromNinety('8326a8602530a97b5afd91ae', 'V. Lindqvist')?.name).toBe('Nora Lindqvist')
140. expect(personFromNinety('8326a8602530a97b5afd91ae', null)?.name).toBe('Nora Lindqvist')
141. })
143. it('prefers the id over the name when the two disagree', () => {
144. // Ids are authoritative. A name that belongs to somebody else must not win.
145. const match = personFromNinety('8326a8602530a97b5afd91ae', 'Sam Whitaker')
146. expect(match?.name).toBe('Nora Lindqvist')
147. })
149. it('every person the board says Ninety COVERS carries an id', () => {
150. // Scoped to people the board claims Ninety covers. A new hire genuinely
151. // has no id until someone runs `pnpm roster` with credentials, and is
152. // simply not claimed as covered (see the test below, and the coverageNote).
153. // The property is that a covered person never resolves by spelling
154. // instead of by id, since the spelling drifts and their to-dos would
155. // silently read as zero.
156. for (const p of MERIDIAN_PEOPLE.filter((x) => x.coveredBy.includes('ninety-todos'))) {
157. expect(p.ninetyId, `${p.name} is marked ninety-todos with no ninetyId`).toBeTruthy()
158. }
159. })
161. it('never claims Ninety coverage for somebody it cannot resolve', () => {
162. // The prime invariant, applied to a person instead of a number. A new hire
163. // with no id and `ninety-todos` in coveredBy would render as zero to-dos
164. // (free capacity) when the truth is that no source can see them at all.
165. for (const p of MERIDIAN_PEOPLE.filter((x) => !x.ninetyId)) {
166. expect(p.coveredBy, `${p.name} has no ninetyId but claims Ninety`).not.toContain('ninety-todos')
167. expect(p.coverageNote, `${p.name} has no ninetyId and no coverage note`).toBeTruthy()
168. }
169. })
171. it('keeps no aliases, now that ids do the work', () => {
172. // They were a fallback for exactly the gap that pinning closed. Left in
173. // place they become a second, staler source of truth for the same question.
174. for (const p of MERIDIAN_PEOPLE) {
175. expect(p.aliases ?? [], `${p.name} still has aliases`).toEqual([])
176. }
177. })
179. it('reports how a match was made, so a name-only match is not silent', () => {
180. // A fallback standing in for knowledge must be surfaced. Every id is pinned,
181. // so a name match means the id Ninety sent is one this roster has never
182. // seen: attributed correctly today, and
183. // silently attributed to nobody the moment the spelling also changes.
184. expect(resolveNinety('8326a8602530a97b5afd91ae', 'Nora Lindqvist').via).toBe('id')
185. expect(resolveNinety('an-id-nobody-pinned', 'Nora Lindqvist').via).toBe('name')
186. expect(resolveNinety('an-id-nobody-pinned', 'Nobody At All').via).toBeNull()
187. })
189. it('returns null rather than guessing at an unknown person', () => {
190. expect(personFromNinety(null, 'Someone Not On The Roster')).toBeNull()
191. expect(personFromNinety(null, '')).toBeNull()
192. expect(personFromNinety('an-id-nobody-pinned', null)).toBeNull()
193. })
195. it('reports unmapped owners instead of swallowing them', () => {
196. // Non-empty means somebody's to-dos exist in the company total but appear on
197. // no per-person view, and missing looks exactly like finished.
198. const unmapped = unmappedNinetyOwners([
199. { id: '3e894807d73d5a39b03fb411', name: 'Samuel Whitaker' },
200. { id: 'u2', name: 'Someone Nobody Declared' },
201. ])
202. expect(unmapped).toHaveLength(1)
203. expect(unmapped[0]!.name).toBe('Someone Nobody Declared')
204. })
206. it('does not flag people declared known-external', () => {
207. // The Ninety directory is not the Meridian team: it holds former staff and
208. // outside collaborators too. Grant Holloway is a former business coach;
209. // undeclared, his absence from the roster reads as a coverage gap worth
210. // chasing. Declaring it is the answer, written down.
211. expect(unmappedNinetyOwners([{ id: '3609ad68b5259524e92470f5', name: 'Grant Holloway' }])).toEqual([])
212. expect(KNOWN_NON_ROSTER_NINETY).toContain('Grant Holloway')
213. })
215. it('attributes every owner seen in the live sweep', () => {
216. // Every owner must resolve: an unresolved one puts their share of company
217. // work on no per-person view while it still counts in every company total.
218. const owners = DIRECTORY.map(([id, name]) => ({ id, name }))
219. expect(unmappedNinetyOwners(owners)).toEqual([])
220. })
222. it('surfaces unmapped owners in dataHealth', () => {
223. const p = buildBriefingPayload(snap)
224. expect(Array.isArray(p.dataHealth.unmappedTodoOwners)).toBe(true)
225. })
227. it('gives every to-do an ownerKey or an explicit null', () => {
228. const p = buildBriefingPayload(snap)
229. for (const t of p.people.flatMap((x) => x.todos)) {
230. expect(t.ownerKey === null || typeof t.ownerKey === 'string').toBe(true)
231. }
232. })
233. })
235. describe('the all-hands brief cannot be built from Leadership to-dos', () => {
236. /**
237. * `brief.py`'s `without_restricted()` filters rows carrying `restricted`. If
238. * `PayloadTodo` did not set the field, the filter would run, match nothing,
239. * report `_restrictedTodosRemoved: 0`, and assemble the all-hands prompt from
240. * every Leadership to-do title: fail-open on a confidentiality boundary, and
241. * invisible from either side alone, since the TypeScript compiles and the
242. * Python passes its own tests. These tests assert the two halves agree.
243. */
244. const payload = buildBriefingPayload(FIXTURE_SNAPSHOT)
245. // Every list of to-do TITLES in the payload. `company.lateTodos` is a count,
246. // not a list. Mistaking the two is what pointed the Python filter at nothing.
247. const allTodos = [...payload.people.flatMap((p) => p.todos), ...payload.queues.lateTodos]
249. it('marks every to-do as restricted or not, never leaves it undefined', () => {
250. expect(allTodos.length).toBeGreaterThan(0)
251. for (const t of allTodos) expect(typeof t.restricted).toBe('boolean')
252. })
254. it('marks Leadership Team to-dos restricted', () => {
255. const hiring = allTodos.filter((t) => t.title.startsWith('Hire a client success associate'))
256. expect(hiring.length).toBeGreaterThan(0)
257. for (const t of hiring) expect(t.restricted).toBe(true)
258. })
260. it('marks a to-do with no team restricted, because it could be anything', () => {
261. const untagged = allTodos.filter((t) => t.title === 'Coordinate backdrop images')
262. expect(untagged.length).toBeGreaterThan(0)
263. for (const t of untagged) expect(t.restricted).toBe(true)
264. })
266. it('leaves All Hands to-dos readable, so the all-hands brief is not empty', () => {
267. // Failing closed on everything would be safe and useless: the rule is that
268. // All Hands work stays visible so the whole team can see where the company
269. // stands.
270. const allHands = allTodos.filter((t) => t.title === 'Weekly product photo refresh')
271. expect(allHands.length).toBeGreaterThan(0)
272. for (const t of allHands) expect(t.restricted).toBe(false)
273. })
275. it('gives the all-hands filter something to actually remove', () => {
276. // The assertion that would have caught the original bug: a payload where
277. // nothing is restricted is indistinguishable from a broken flag.
278. expect(allTodos.some((t) => t.restricted)).toBe(true)
279. expect(allTodos.some((t) => !t.restricted)).toBe(true)
280. })
281. })
283. describe('the leadership view reports capacity, never performance', () => {
284. const p = buildBriefingPayload(snap)
286. it('ships the exec rules separately so a consumer can put them first', () => {
287. expect(p.execRules).toEqual(EXEC_RULES)
288. expect(p.execRules.length).toBeGreaterThanOrEqual(6)
289. })
291. it('states plainly that speed and effort are not in the data', () => {
292. const joined = p.execRules.join(' ').toLowerCase()
293. for (const forbidden of ['slow', 'fast', 'behind', 'productive']) {
294. expect(joined).toContain(forbidden) // named in order to be forbidden
295. }
296. expect(joined).toContain('cannot say anyone was')
297. expect(joined).toContain('do not rank or compare people')
298. })
300. it('warns that age is not time on someone\'s desk', () => {
301. // The single number most likely to be misread as a person's fault. Plinth
302. // records no status-change timestamps, so this is a fact, not a hedge.
303. expect(p.execRules.join(' ')).toMatch(/AGE IS NOT TIME ON SOMEONE'S DESK/)
304. })
306. it('carries the unmeasurable list, not just the measurable one', () => {
307. expect(p.exec.unmeasurable).toEqual(UNMEASURABLE)
308. const joined = p.exec.unmeasurable.join(' ').toLowerCase()
309. expect(joined).toContain('no status-change timestamps')
310. expect(joined).toContain('client reply latency is not recorded')
311. expect(joined).toContain('phone calls, chats, walk-ups')
312. })
314. it('separates what the team owes from what is parked elsewhere', () => {
315. // Only ourMove is team load. Rolling the others in is how a capacity view
316. // starts describing a team as behind when it is not.
317. expect(p.exec.ourMove).toBeGreaterThan(0)
318. expect(p.exec.waitingOnClient).toBeGreaterThan(0)
319. for (const l of p.exec.load) {
320. if (l.holding !== null && l.parked !== null) {
321. expect(l.holding + l.parked).toBeGreaterThanOrEqual(l.holding)
322. }
323. }
324. })
326. it('counts handoffs, because coordination is the small-team constraint', () => {
327. expect(p.exec.handoffPoints).toBeGreaterThan(0)
328. for (const l of p.exec.load) {
329. if (l.handoffs !== null && l.holding !== null) {
330. expect(l.handoffs).toBeLessThanOrEqual(l.holding)
331. }
332. }
333. })
335. it('gives team size as context for every count', () => {
336. expect(p.exec.teamSize).toBe(p.people.length)
337. })
339. it('reports an uncovered person as null, never as an idle zero', () => {
340. const uncovered = p.exec.load.filter((l) => l.holding === null)
341. expect(uncovered.length).toBeGreaterThan(0)
342. for (const l of uncovered) expect(l.holding).not.toBe(0)
343. })
345. it('exposes no rate, throughput, or completion FIELD', () => {
346. // Checks field names, not prose: `unmeasurable` names throughput on
347. // purpose, to rule it out. What must never appear is a per-person number
348. // that could be read as a rate, because it will be reported as performance
349. // within a week of existing.
350. const banned = ['throughput', 'velocity', 'rate', 'perday', 'efficiency', 'completed', 'closed']
351. const keys = new Set<string>()
352. const walk = (v: unknown): void => {
353. if (Array.isArray(v)) return v.forEach(walk)
354. if (v && typeof v === 'object') {
355. for (const [k, val] of Object.entries(v)) {
356. keys.add(k.toLowerCase())
357. walk(val)
358. }
359. }
360. }
361. walk({ ...p.exec, unmeasurable: undefined })
362. for (const key of keys) {
363. for (const b of banned) expect(key).not.toContain(b)
364. }
365. // And every per-person field is a count of things HELD, never a rate.
366. for (const l of p.exec.load) {
367. expect(Object.keys(l).sort()).toEqual(
368. ['commitments', 'handoffs', 'holding', 'name', 'parked', 'role', 'shared'],
369. )
370. }
371. })
372. })
374. describe('a fixture run never claims to be live', () => {
375. // A fixture run must not render "live" pills over a frozen export: the board
376. // that exists to stop sources asserting unearned status must not do it about
377. // itself.
378. it('marks every source as sample data, never live', () => {
379. for (const s of sourceStatuses(snap)) {
380. expect(s.status).toBe('sample data')
381. expect(s.tone).not.toBe('live')
382. }
383. })
385. it('says when the frozen data was captured', () => {
386. expect(snap.mode).toBe('fixtures')
387. expect(snap.fixtureCapturedAt).toBeTruthy()
388. const ops = sourceStatuses(snap).find((s) => s.name === 'Plinth')!
389. expect(ops.note).toContain('2026-08-09')
390. expect(ops.note.toLowerCase()).toContain('already be shipped')
391. })
393. it('warns the model first, before any other rule', () => {
394. // A model handed this with no marker writes a confident briefing about
395. // orders that shipped two weeks ago and names people as holding finished
396. // work. The warning has to be rule one, not a footnote.
397. const p = buildBriefingPayload(snap)
398. expect(p.mode).toBe('fixtures')
399. expect(p.capturedAt).toBeTruthy()
400. expect(p.rules[0]).toMatch(/SAMPLE DATA/)
401. expect(p.rules.length).toBe(INTERPRETATION_RULES.length + 1)
402. })
404. it('a live snapshot carries no such warning', () => {
405. const live = buildBriefingPayload({ ...snap, mode: 'live', fixtureCapturedAt: null })
406. expect(live.mode).toBe('live')
407. expect(live.capturedAt).toBeNull()
408. expect(live.rules).toEqual(INTERPRETATION_RULES)
409. })
410. })
412. describe('the fixture clock is pinned to the export, not to today', () => {
413. // `placedAt` is frozen, so an age computed from Date.now() would grow one day
414. // per real day, until every row tripped the aging threshold and a reviewer
415. // learned to ignore the one flag that matters. A frozen snapshot must have
416. // frozen ages.
417. it('gives order 39511 the age it actually had, forever', () => {
418. const line = snap.orderLines.data.find((l) => l.orderId === 39511)
419. expect(line).toBeDefined()
420. expect(line!.ageDays).toBe(30)
421. })
423. it('has no order older than the export window, however long the seed sits', () => {
424. // Placed 01 Jul-07 Aug, exported 09 Aug. Nothing can legitimately exceed ~40
425. // days. If this fails, something is measuring against a live clock again.
426. for (const l of snap.orderLines.data) {
427. if (l.ageDays !== null) expect(l.ageDays).toBeLessThan(45)
428. }
429. })
430. })
432. describe('no column echoes the column beside it', () => {
433. // An order number echoed into productTitle and customer would make three
434. // columns in a row say the same thing. Repetition reads as data.
435. it('never renders the order number as a product or a client', () => {
436. const q = queueView(snap)
437. for (const g of q.groups) {
438. for (const r of g.rows) {
439. expect(r.product).not.toBe(r.orderNumber)
440. expect(r.customer).not.toBe(r.orderNumber)
441. }
442. }
443. })
445. it('prints the absence as words, never as a blank cell', () => {
446. const q = queueView(snap)
447. for (const g of q.groups) {
448. for (const r of g.rows) {
449. expect(r.product.trim().length).toBeGreaterThan(0)
450. expect(r.customer.trim().length).toBeGreaterThan(0)
451. }
452. }
453. })
454. })
456. describe('an aging flag that fires on everything is suppressed', () => {
457. it('replaces saturated badges with one sentence', () => {
458. const q = queueView(snap)
459. // The seed queue is genuinely mostly old, so this is the saturated path.
460. expect(q.everythingIsOld).toBeTruthy()
461. expect(q.everythingIsOld).toMatch(/median/)
462. // and no row carries a badge, because a badge on everything is wallpaper.
463. for (const g of q.groups) for (const r of g.rows) expect(r.aging).toBe(false)
464. })
466. it('names the unassigned group rather than leaving it blank', () => {
467. const q = queueView(snap)
468. const un = q.groups.find((g) => g.unassigned)
469. if (un) expect(un.designer).toBe('Unassigned')
470. for (const g of q.groups) expect(g.designer.trim().length).toBeGreaterThan(0)
471. })
472. })
474. describe('headline treats a dead source as unknown, not empty', () => {
475. it('reports commitments when Ninety is up', () => {
476. const h = headline(snap)
477. expect(h.commitments).toBeGreaterThan(0)
478. expect(h.assignments).toBeGreaterThanOrEqual(h.commitments!)
479. })
481. it('reports null, NEVER 0, when Ninety is down', () => {
482. const dead = {
483. ...snap,
484. ninety: { ok: false, data: [], error: '403 Forbidden' },
485. ninetySpread: null,
486. }
487. const h = headline(dead)
488. expect(h.commitments).toBeNull()
489. expect(h.assignments).toBeNull()
490. expect(h.lateTodos).toBeNull()
491. // 0 would read as "everything is done". null reads as "we cannot see".
492. expect(h.commitments).not.toBe(0)
493. })
494. })
496. describe('todoLoad uses review gates, not raw overdue', () => {
497. it('counts late only when a review has actually passed', () => {
498. const loads = todoLoad(snap.ninety.data)
499. for (const l of loads) expect(l.late).toBeLessThanOrEqual(l.open)
500. expect(loads.some((l) => l.late > 0)).toBe(true)
501. })
502. })
504. describe('buildBriefingPayload', () => {
505. const p = buildBriefingPayload(snap)
507. it('is versioned so a consumer can fail loudly on a breaking change', () => {
508. expect(p.schemaVersion).toBe(PAYLOAD_SCHEMA_VERSION)
509. expect(p.schemaVersion).toMatch(/^\d+\.\d+\.\d+$/)
510. })
512. it('ships the interpretation rules inside the payload', () => {
513. // Fixture payloads prepend a sample-data warning, so this asserts every
514. // standing rule survives rather than asserting an exact array.
515. for (const rule of INTERPRETATION_RULES) expect(p.rules).toContain(rule)
516. expect(p.rules.length).toBeGreaterThanOrEqual(6)
517. })
519. it('warns the consumer about the open-does-not-mean-unfinished trap', () => {
520. // The single most dangerous sentence this system could generate is
521. // "Sam is 15 days overdue" about work that is finished and awaiting
522. // Monday sign-off. The rule that prevents it must be present.
523. const joined = p.rules.join(' ').toLowerCase()
524. expect(joined).toContain('does not mean unfinished')
525. expect(joined).toContain('review')
526. })
528. it('warns the consumer not to conflate commitments with assignments', () => {
529. expect(p.rules.join(' ').toLowerCase()).toContain('commitments and assignments are different')
530. })
532. it('stays small enough to run daily: this is the whole point of the seam', () => {
533. // A model reasoning over raw payloads reads 200k-500k tokens per run. This
534. // is the distilled version. If this assertion ever fails, the aggregation
535. // has leaked back across the seam.
536. const approxTokens = JSON.stringify(p).length / 4
537. expect(approxTokens).toBeLessThan(12_000)
538. })
540. it('reports every source with its own ok flag and error', () => {
541. expect(p.sources).toHaveLength(5)
542. for (const s of p.sources) {
543. expect(typeof s.ok).toBe('boolean')
544. expect(s.covers.length).toBeGreaterThan(0)
545. }
546. expect(p.sources.map((s) => s.name)).toContain('Ninety to-dos')
547. // With several keys, "some of the meetings were read" is a state the
548. // payload can reach. Each person's `meetings` array is gated to what they
549. // attended, so a short one looks completely normal. Without a source row there is nothing in the
550. // payload that distinguishes a quiet fortnight from an unreadable key.
551. expect(p.sources.map((s) => s.name)).toContain('Fathom meetings')
552. })
554. it('marks Fathom not-ok and says NOT ZERO when no key is configured', () => {
555. const unset = buildBriefingPayload({ ...snap, fathomConfigured: false, fathomSources: [] })
556. const fathom = unset.sources.find((s) => s.name === 'Fathom meetings')!
557. expect(fathom.ok).toBe(false)
558. expect(fathom.error).toMatch(/Not zero meetings/)
559. for (const person of unset.people) expect(person.meetings).toBeNull()
560. })
562. it('marks Fathom not-ok when one key of three is dark, and names the owner', () => {
563. // ok:false on a PARTIAL read is deliberate. The question this flag answers
564. // for the model is "may I describe these meeting lists as complete", and
565. // with a key dark the answer is no. brief.py turns it into a warning.
566. const partial = buildBriefingPayload({
567. ...snap,
568. fathomSources: [
569. { owner: 'Sam Whitaker', ok: true, error: null, returned: 8, truncated: false },
570. { owner: 'Ines Carvalho', ok: false, error: 'HTTP 401', returned: 0, truncated: false },
571. { owner: 'Theo Bassett', ok: true, error: null, returned: 2, truncated: false },
572. ],
573. })
574. const fathom = partial.sources.find((s) => s.name === 'Fathom meetings')!
575. expect(fathom.ok).toBe(false)
576. expect(fathom.error).toContain('Ines Carvalho')
577. expect(fathom.error).toContain('HTTP 401')
578. // The working keys' meetings are still on the payload. A dark key degrades
579. // the claim of completeness; it does not delete two other people's data.
580. expect(partial.people.some((x) => (x.meetings?.length ?? 0) > 0)).toBe(true)
581. })
583. it('is ok and silent when every key read cleanly', () => {
584. const fathom = p.sources.find((s) => s.name === 'Fathom meetings')!
585. expect(fathom.ok).toBe(true)
586. expect(fathom.error).toBeNull()
587. })
589. it('carries the failure reason through when a source dies', () => {
590. const dead = buildBriefingPayload({
591. ...snap,
592. ninety: { ok: false, data: [], error: '403 Forbidden: Owner/Admin only' },
593. ninetySpread: null,
594. })
595. const ninety = dead.sources.find((s) => s.name === 'Ninety to-dos')!
596. expect(ninety.ok).toBe(false)
597. expect(ninety.error).toContain('403')
598. expect(dead.company.commitments).toBeNull()
599. for (const person of dead.people) expect(person.todosOpen).toBeNull()
600. })
602. it('names the people carrying a shared commitment', () => {
603. // Without this, the same item appears on three lists as if it were three
604. // separate jobs and the briefing triple-counts the work.
605. const shared = p.people.flatMap((x) => x.todos).find((t) => t.sharedWith.length > 0)
606. expect(shared).toBeDefined()
607. expect(shared!.sharedWith.length).toBeGreaterThanOrEqual(1)
608. expect(shared!.sharedWith).not.toContain(shared!.owner)
609. })
611. it('distinguishes uncovered people from idle ones', () => {
612. for (const person of p.people) {
613. if (person.ordersOwed === null) expect(person.coverage.join(' ')).not.toMatch(/Plinth/i)
614. }
615. })
617. it('caps lists and admits when it truncated', () => {
618. for (const person of p.people) expect(person.orders.length).toBeLessThanOrEqual(LIST_CAP)
619. expect(p.queues.oldestOrders.length).toBeLessThanOrEqual(LIST_CAP)
620. expect(typeof p.queues.truncated).toBe('boolean')
621. })
623. it('counts orders with no designer as a data gap, not a queue', () => {
624. expect(p.dataHealth.ordersMissingDesigner).toBe(p.queues.unassignedOrders.length)
625. for (const o of p.queues.unassignedOrders) expect(o.designer).toBeNull()
626. })
628. it('groups on the Meridian calendar day, not UTC', () => {
629. expect(p.timezone).toBe('America/Chicago')
630. expect(p.day).toMatch(/^\d{4}-\d{2}-\d{2}$/)
631. })
633. it('never leaks raw HTML into a model context', () => {
634. for (const t of p.people.flatMap((x) => x.todos)) {
635. expect(t.title).not.toMatch(/<[a-z][^>]*>/i)
636. }
637. })
638. })