briefing-payload.ts

apps/dashboard/src/briefing-payload.ts

1. /**
2. * The model-facing contract.
3. *
4. * Everything upstream of here (three API clients, the stage
5. * taxonomies, the review-gate arithmetic, the assignment join) is deterministic
6. * TypeScript and costs zero model tokens. This file is the seam where that work
7. * gets handed to something that reasons. It emits one small, versioned JSON
8. * object per run. Whatever generates the analysis (a local model, a hosted one,
9. * a Python service, a person reading it) consumes this and nothing else.
10. *
11. * Why that split matters, in the only terms that count here: a model asked to
12. * reason over raw Bitrix and Plinth payloads reads 200k-500k tokens per run. A
13. * model reading this reads a few thousand. Same conclusions, ~1% of the budget.
14. * The distillation is the point. If you find yourself widening this payload to
15. * "let the model decide", stop: that is the aggregation leaking back across the
16. * seam, and it is exactly what makes a daily job unaffordable.
17. *
18. * The rules block is not documentation. `INTERPRETATION_RULES` ships inside the
19. * payload, and it is load-bearing. Meridian's data has four traps that produce
20. * confidently wrong sentences if a model does not know about them, and the worst
21. * of those sentences get read aloud in front of the team. A model that has the
22. * numbers but not the rules is more dangerous than one with no data at all,
23. * because it is fluent.
24. *
25. * Null is not zero, anywhere in here. A dead source and an empty queue are the
26. * same shape at a glance and opposite in meaning. Every optional number in this
27. * payload is `null` when unknown, and every null has a matching entry in
28. * `sources` or `coverage` saying why.
29. */
31. import { classifyOrder, type OrderLine } from '@meridian/plinth-client'
32. import { partitionTasks } from '@meridian/bitrix-client'
33. import { assignmentGroups, isActuallyLate, reviewGatesMissed, localDay, MERIDIAN_TZ, type Todo } from '@meridian/ninety-client'
34. import {
35. MERIDIAN_PEOPLE,
36. SOURCE_LABELS,
37. personFromNinety,
38. unmappedNinetyOwners,
39. type Person,
40. } from '../../../config/meridian-people.js'
41. import { isRestrictedTeam } from '../../../config/ninety-teams.js'
42. import {
43. headline,
44. orderQueue,
45. todoLoad,
46. type Headline,
47. type OrderQueueRow,
48. type Snapshot,
49. } from './collect.js'
51. /**
52. * Bump the minor when adding a field, the major when changing or removing one.
53. * A consumer that pins a major and reads `schemaVersion` can fail loudly instead
54. * of silently summarizing fields that moved.
55. */
56. export const PAYLOAD_SCHEMA_VERSION = '1.1.0'
58. /**
59. * How many rows of each list to include.
60. *
61. * These are budget decisions, not display decisions. The lists are sorted with
62. * the most urgent first, so a cap truncates the tail rather than the signal, and
63. * `truncated` tells the consumer it happened so it never says "all" about a
64. * partial list.
65. */
66. export const LIST_CAP = 25
68. /**
69. * The four things a model must know before it writes a sentence about Meridian.
70. *
71. * Every one of these was learned from live data and every one of them, if
72. * ignored, produces a fluent and wrong statement.
73. */
74. export const INTERPRETATION_RULES: string[] = [
75. 'An open to-do does NOT mean unfinished work. Meridian policy is that nothing is ' +
76. 'marked complete outside a Monday or Friday review, so finished work stays ' +
77. 'open until the next review signs it off. Never write that someone is ' +
78. '"behind" or "has not done" something purely because a to-do is open. Use ' +
79. 'the `late` count, which already accounts for review gates, and say "past ' +
80. 'due and past a review" rather than "overdue".',
82. 'Commitments and assignments are different numbers and both are given. One ' +
83. 'commitment can be carried by several people: on the day this was built, ' +
84. '36 rows represented 27 distinct commitments, some shared by three people. ' +
85. 'Report commitments when describing how much work exists, and assignments ' +
86. 'only when describing individual load. Never call the assignment count a ' +
87. 'number of tasks.',
89. 'Order status and product status disagree, and NEITHER is simply the true ' +
90. 'one. Orders read "On Press" while their artwork is still in review; ' +
91. 'product rows park at their last value and still read "File Check" on ' +
92. 'orders that have already shipped. Every status here is the product-level ' +
93. 'one, and a line is only counted as work when its order has also not moved ' +
94. 'past Part Dispatched. Do not reconcile a status against what somebody ' +
95. 'quotes from an order screen: they are reading the other field.',
97. 'Waiting-on-client and at-vendor are NOT the team being behind. They are ' +
98. 'counted separately on purpose. Only `ourMove` is work this team owes. ' +
99. 'Never sum them into a backlog figure or describe the team as behind on ' +
100. 'the basis of them.',
102. 'A null means the source cannot see it, not that the value is zero. Check ' +
103. '`sources` and each person\'s `coverage` before saying anyone has "nothing" ' +
104. 'or is "free". If a number is null, say it is not tracked.',
106. 'Order numbers are given in the customer-facing form (MD2639582) and are safe ' +
107. 'to quote verbatim. Never reformat one, and never invent one.',
108. ]
110. /**
111. * The leadership view: what the whole company is carrying, and what these
112. * numbers genuinely cannot tell you about it.
113. *
114. * A separate rule set, not a tone choice.
115. *
116. * A bird's-eye board invites one specific wrong inference: that a long-running
117. * item means somebody was slow. Every source here makes that inference
118. * unsupportable, and not as a matter of charity:
119. *
120. * - Plinth records no status-change timestamps. `ageDays` is time since the order
121. * was placed. A 30-day line may be 29 days waiting on a client's reply, or
122. * two days of work that started yesterday. The data cannot tell them apart.
123. * - Nothing anywhere records completion time per person, hours worked,
124. * interruptions, or how long a client took to respond. Throughput is not a
125. * quantity this system can compute.
126. * - Ninety to-dos may only be closed at a Monday or Friday review, so an open
127. * to-do can be finished work waiting for sign-off.
128. * - Assignment arrives on the Plinth response itself, so it is as fresh as the
129. * sync, but a line Plinth marks `--` is unassigned, not unknown.
130. *
131. * So the honest leadership number is concurrency (how much one person is
132. * holding at once), not throughput. Concurrency is measurable and it is the
133. * thing that actually predicts whether a small team drops something.
134. *
135. * `unmeasurable` ships in the payload for the same reason `rules` does: a model
136. * given a per-person table and no constraints will rank people, and a ranking
137. * this data cannot support is worse than no briefing.
138. */
139. export interface ExecView {
140. teamSize: number
141. /** Work the team owes the next move on. The only figure that is team load. */
142. ourMove: number
143. /** Sitting with the client. Explicitly not team load. */
144. waitingOnClient: number
145. /** Sitting with a vendor. Explicitly not team load. */
146. atVendor: number
147. /** Distinct commitments, and the rows they spread across. */
148. commitments: number | null
149. assignments: number | null
150. /**
151. * Order lines carrying both a designer and a CS rep. Every one is a handoff,
152. * and handoffs are where a small team loses time to coordination rather than
153. * to effort.
154. */
155. handoffPoints: number
156. /** Work areas exactly one person covers. Concentration risk, not performance. */
157. soleCoverage: { area: string; person: string }[]
158. /** Per person: what they are holding. Never a rate, never a ranking. */
159. load: {
160. name: string
161. role: string
162. /** Order lines where they owe the next move. */
163. holding: number | null
164. /** Their lines that are parked with a client or vendor: not their move. */
165. parked: number | null
166. /** Commitments they carry, including ones shared with others. */
167. commitments: number | null
168. /** Commitments they share, i.e. cannot finish alone. */
169. shared: number
170. /** Lines requiring a second person before they can close. */
171. handoffs: number | null
172. }[]
173. /** What this data cannot show. Ships with the payload; do not omit. */
174. unmeasurable: string[]
175. }
177. /** Rules for the leadership view, added to the standing ones. */
178. export const EXEC_RULES: string[] = [
179. 'This is a capacity view, not a performance view. The underlying systems ' +
180. 'record no status-change timestamps, no completion times, no hours worked, ' +
181. 'and no client response latency. You therefore cannot say anyone was slow, ' +
182. 'fast, behind, ahead, productive, or unproductive, and you must not imply ' +
183. 'it. If asked to, say the data does not support it.',
185. 'AGE IS NOT TIME ON SOMEONE\'S DESK. `ageDays` counts from the day the order ' +
186. 'was placed. A line thirty days old may have spent twenty-nine of them ' +
187. 'waiting on a client reply. Never attribute an age to a person, and never ' +
188. 'describe an old item as neglected.',
190. 'Do not rank or compare people. Different roles carry different work, ' +
191. 'assignment is a routing default in some systems, and the counts are not ' +
192. 'commensurable. Report what each person is holding; draw no league table.',
194. 'Report CONCURRENCY, not throughput. How much someone is holding at once is ' +
195. 'measurable and is what predicts a small team dropping something. How fast ' +
196. 'they work is not in this data at all.',
198. 'When something looks stuck, the supported explanations are structural: it is ' +
199. 'waiting on a client or vendor, it needs a second person before it can ' +
200. 'close (see `handoffPoints`), or one person is the only cover for that area ' +
201. '(see `soleCoverage`). Name the structural cause. Do not reach past it to a ' +
202. 'person.',
204. 'Team size is context for every number here. Read the counts against ' +
205. '`teamSize` before describing anything as a lot or a little.',
206. ]
208. // --- shape ------------------------------------------------------------------
210. export interface PayloadSource {
211. name: string
212. ok: boolean
213. covers: string
214. error: string | null
215. }
217. export interface PayloadOrder {
218. orderNumber: string
219. /** Null means the export carried no product name. Say "not recorded", not "". */
220. product: string | null
221. quantity: number
222. status: string
223. designer: string | null
224. accountOwner: string | null
225. company: string | null
226. ageDays: number | null
227. inDesignQueue: boolean
228. }
230. export interface PayloadTodo {
231. title: string
232. /** As Ninety spells it. What a person recognises. */
233. owner: string
234. /**
235. * Canonical roster name, or null when this owner matches nobody on the roster.
236. * Null is a data problem, not an empty value: a to-do behind an unmapped
237. * owner is missing from every per-person view, and missing looks like done.
238. */
239. ownerKey: string | null
240. dueDate: string | null
241. /** Past due and past at least one review gate. The number worth acting on. */
242. late: boolean
243. reviewsMissed: number
244. /** Other people carrying the same commitment. Empty for solo work. */
245. sharedWith: string[]
246. /** Set when the to-do hangs off a rock milestone. */
247. linkedToRock: boolean
248. /**
249. * Readable only by the leadership-cleared readers. See config/ninety-teams.ts;
250. * an untagged to-do counts as restricted, because an item with no team could be
251. * anything.
252. *
253. * This field is the only thing separating the two company briefs.
254. * `brief.py`'s `without_restricted()` drops every row carrying it before the
255. * all-hands prompt is built, because prose cannot be redacted once a model has
256. * written it. If it were missing, the filter would run, match nothing, and
257. * fail open on a confidentiality boundary, invisibly from either side.
258. */
259. restricted: boolean
260. }
262. export interface PayloadPerson {
263. name: string
264. role: string
265. /** Order lines where this person owes the next move. Null when uncovered. */
266. ordersOwed: number | null
267. /** Open Bitrix tasks. Null when uncovered. */
268. tasksOpen: number | null
269. /** Ninety to-dos assigned to them. Null when the source failed. */
270. todosOpen: number | null
271. todosLate: number | null
272. /** Their oldest outstanding item, in days. Null when nothing or uncovered. */
273. oldestDays: number | null
274. /** Which systems can see this person at all. */
275. coverage: string[]
276. /** True when no source covers them. Must never be presented as "no work". */
277. untracked: boolean
278. /** Their own orders, capped. Empty array is real; null would mean uncovered. */
279. orders: PayloadOrder[]
280. todos: PayloadTodo[]
281. /**
282. * Meetings this person attended, with the action items from them. Null when
283. * Fathom is not configured or the fetch failed, never [] for that, because
284. * "no meetings" and "not tracked" lead to different briefings.
285. *
286. * Nothing meeting-derived appears outside this field. The company and exec
287. * slices carry none, because the briefings written from them are read by
288. * people who were not in the room. Gating the rendered page would do nothing
289. * about a model handed a leadership meeting and asked to summarise the week.
290. */
291. meetings:
292. | {
293. title: string
294. date: string
295. items: { text: string; owner: string | null; unowned: boolean }[]
296. }[]
297. | null
298. }
300. export interface BriefingPayload {
301. schemaVersion: string
302. generatedAt: string
303. /**
304. * 'fixtures' means this payload describes a frozen snapshot, not today.
305. *
306. * A model handed fixture data with no marker writes a confident briefing about
307. * orders that shipped two weeks ago and names people as holding work they
308. * finished. The rules array gains an explicit instruction in this mode, and
309. * `analysis/brief.py` refuses to run without --allow-fixtures.
310. */
311. mode: 'live' | 'fixtures'
312. /** When frozen data was captured. Null on a live run. */
313. capturedAt: string | null
314. /** Calendar day in Meridian's timezone. Group and compare on this, not on UTC. */
315. day: string
316. timezone: string
317. rules: string[]
318. sources: PayloadSource[]
319. company: {
320. ourMove: number
321. designQueue: number
322. clientReplied: number
323. waitingOnClient: number
324. atVendor: number
325. /** Still in play: not noise, not terminal. */
326. openLeads: number
327. automatedLeadsExcluded: number
328. /**
329. * Leads excluded as finished, not as noise. Reported so a briefing can say
330. * "45 open, 270 closed this period" rather than implying the pipeline
331. * shrank.
332. */
333. completedLeadsExcluded: number
334. commitments: number | null
335. assignments: number | null
336. sharedCommitments: number | null
337. lateTodos: number | null
338. }
339. people: PayloadPerson[]
340. /** The leadership view. Capacity and structure only; see ExecView. */
341. exec: ExecView
342. /**
343. * Extra rules a leadership briefing must follow, on top of `rules`.
344. * Shipped separately so the exec consumer can put them first: they are the
345. * constraining ones, and a model running short on attention should lose style
346. * guidance rather than limits.
347. */
348. execRules: string[]
349. queues: {
350. /** Oldest first. The top of this is what is actually rotting. */
351. oldestOrders: PayloadOrder[]
352. unassignedOrders: PayloadOrder[]
353. lateTodos: PayloadTodo[]
354. truncated: boolean
355. }
356. dataHealth: {
357. warnings: string[]
358. unknownProductStatuses: string[]
359. /** Order lines with no designer. Not a queue: a gap in the export. */
360. ordersMissingDesigner: number
361. /**
362. * Ninety owners matching nobody on the roster. Their to-dos are counted in
363. * the company totals but appear on no per-person view, so this being
364. * non-empty means someone's work is invisible. Add them to MERIDIAN_PEOPLE with
365. * their `ninetyId` from `pnpm roster`, or declare them in
366. * KNOWN_NON_ROSTER_NINETY if they are not staff. Do not reach for `aliases`:
367. * matching on a display name is how people end up resolving to nobody.
368. */
369. unmappedTodoOwners: { id: string; name: string }[]
370. /**
371. * How many fetched lines carried each Plinth assignment field
372. * (production_owner, account_owner). They arrive on the API with every
373. * sync, so the question is whether they arrived, not how old they are.
374. */
375. assignmentFieldCoverage: { production: number; accountOwner: number; total: number }
376. junkTasksExcluded: number | null
377. }
378. }
380. // --- build ------------------------------------------------------------------
382. function toPayloadOrder(r: OrderQueueRow): PayloadOrder {
383. return {
384. orderNumber: r.orderNumber,
385. product: r.product,
386. quantity: r.quantity,
387. status: r.status,
388. designer: r.designer,
389. accountOwner: r.accountOwner,
390. company: r.company,
391. ageDays: r.ageDays,
392. inDesignQueue: r.designQueue,
393. }
394. }
396. function toPayloadTodos(todos: Todo[], now: Date): PayloadTodo[] {
397. // Shared-commitment membership, so a briefing can say "with Marco and Ines"
398. // instead of silently repeating the same item on three people's lists as if
399. // it were three separate jobs.
400. const sharedBy = new Map<string, string[]>()
401. for (const g of assignmentGroups(todos)) {
402. if (!g.shared) continue
403. for (const t of g.todos) {
404. sharedBy.set(
405. t.id,
406. g.owners.filter((o) => o.id !== t.owner.id).map((o) => o.name),
407. )
408. }
409. }
411. return todos.map((t) => ({
412. title: t.title,
413. owner: t.owner.name,
414. ownerKey: personFromNinety(t.owner.id, t.owner.name)?.name ?? null,
415. dueDate: t.dueDateLocal,
416. late: isActuallyLate(t.dueDate, now),
417. reviewsMissed: reviewGatesMissed(t.dueDate, now),
418. sharedWith: sharedBy.get(t.id) ?? [],
419. linkedToRock: t.milestoneId !== null,
420. restricted: isRestrictedTeam(t.teamId, t.teamName),
421. }))
422. }
424. /**
425. * What the data cannot show. Stated positively, as facts about the systems.
426. *
427. * These are not hedges. Each one is a documented limitation with a source, and
428. * together they are the reason a performance reading is unavailable rather than
429. * merely discouraged.
430. */
431. export const UNMEASURABLE: string[] = [
432. 'Time in status. Plinth records no status-change timestamps, so an order line\'s ' +
433. 'age counts from the day it was placed, not from when it reached its ' +
434. 'current step, and not from when anyone picked it up.',
435. 'Time spent waiting on a client. Client reply latency is not recorded ' +
436. 'anywhere, so a long-running line cannot be separated into work time and ' +
437. 'wait time.',
438. 'Completion time, throughput, or effort per person. No system records when a ' +
439. 'person finished a thing, how long it took, or how many times they were ' +
440. 'interrupted.',
441. 'Whether an open to-do is unfinished. Meridian policy closes to-dos only at ' +
442. 'Monday and Friday reviews, so completed work stays open until sign-off.',
443. 'Nothing about assignment freshness. Designer and CS assignment arrive on the ' +
444. 'Plinth API response in the same sync as the orders, so they are as fresh as ' +
445. 'generatedAt; a line reported with no assignee is one Plinth holds as unassigned.',
446. 'Work that exists outside these four systems: phone calls, chats, walk-ups, ' +
447. 'and anything handled without a ticket.',
448. ]
450. function buildExecView(snap: Snapshot, queue: OrderQueueRow[], todos: Todo[]): ExecView {
451. const lines = snap.orderLines.data
452. const cls = (l: OrderLine) => classifyOrder(l.orderStatus, l.orderStatusId || null)
454. // A line needing both a designer and a CS rep cannot be closed by one person.
455. // That is a coordination cost, and on a small team it is usually the real
456. // constraint rather than anything about how hard people are working.
457. const handoffPoints = queue.filter((r) => r.designer && r.accountOwner).length
459. const designers = new Set(lines.map((l) => l.productionOwner).filter(Boolean) as string[])
460. const cs = new Set(lines.map((l) => l.accountOwner).filter(Boolean) as string[])
461. const soleCoverage: ExecView['soleCoverage'] = []
462. if (designers.size === 1) soleCoverage.push({ area: 'Design / artwork', person: [...designers][0]! })
463. if (cs.size === 1) soleCoverage.push({ area: 'Client success on orders', person: [...cs][0]! })
465. const groups = assignmentGroups(todos)
467. const load = MERIDIAN_PEOPLE.map((p: Person) => {
468. const coversPlinth = p.coveredBy.some((c) => c.startsWith('plinth-'))
469. const mine = coversPlinth
470. ? lines.filter((l) => l.productionOwner === p.name || l.accountOwner === p.name)
471. : []
472. const theirTodos = todos.filter((t) => personFromNinety(t.owner.id, t.owner.name)?.name === p.name)
473. return {
474. name: p.name,
475. role: p.role,
476. holding: coversPlinth ? mine.filter((l) => cls(l) === 'ours').length : null,
477. parked: coversPlinth ? mine.filter((l) => cls(l) === 'client' || cls(l) === 'vendor').length : null,
478. commitments: snap.ninety.ok ? theirTodos.length : null,
479. shared: groups.filter((g) => g.shared && g.owners.some((o) => personFromNinety(o.id, o.name)?.name === p.name)).length,
480. handoffs: coversPlinth
481. ? mine.filter((l) => l.productionOwner && l.accountOwner && cls(l) === 'ours').length
482. : null,
483. }
484. })
486. const h = headline(snap)
487. return {
488. teamSize: MERIDIAN_PEOPLE.length,
489. ourMove: h.ourMove,
490. waitingOnClient: h.waitingOnClient,
491. atVendor: h.atVendor,
492. commitments: h.commitments,
493. assignments: h.assignments,
494. handoffPoints,
495. soleCoverage,
496. load,
497. unmeasurable: UNMEASURABLE,
498. }
499. }
501. /**
502. * The Fathom row for the payload's source list.
503. *
504. * `ok` is false for a partial read as well as a total one, and that is
505. * deliberate: the question this field answers for the model is "may I describe
506. * the meeting lists below as complete", and the answer with one key dark is no.
507. * The error text carries the distinction a human needs: which owner, and what
508. * the API actually said.
509. */
510. function fathomSource(snap: Snapshot): {
511. name: string
512. ok: boolean
513. covers: string
514. error: string | null
515. } {
516. const covers = 'meeting action items, gated to the people who were in the room'
517. if (!snap.fathomConfigured) {
518. return {
519. name: 'Fathom meetings',
520. ok: false,
521. covers,
522. // Not tracked, not empty. Without this the model reads `meetings: null`
523. // on every person and has no way to tell "nobody was asked" from "nothing
524. // was said": the prime invariant, arriving at a model instead of a page.
525. error: 'No Fathom key is configured, so no meeting is on this payload. Not zero meetings.',
526. }
527. }
528. if (!snap.meetings.ok) {
529. return { name: 'Fathom meetings', ok: false, covers, error: snap.meetings.error }
530. }
531. const dark = snap.fathomSources.filter((k) => !k.ok)
532. const capped = snap.fathomSources.filter((k) => k.ok && k.truncated)
533. if (!dark.length && !capped.length) {
534. return { name: 'Fathom meetings', ok: true, covers, error: null }
535. }
536. return {
537. name: 'Fathom meetings',
538. ok: false,
539. covers,
540. error:
541. [
542. dark.length
543. ? `${dark.map((k) => `${k.owner}'s key failed (${k.error})`).join('; ')}.`
544. : '',
545. capped.length
546. ? `${capped.map((k) => k.owner).join(', ')} hit the page cap, so that sweep is partial.`
547. : '',
548. `Meetings recorded by those people are missing from this payload rather than absent from ` +
549. `the fortnight. The rest of the keys read cleanly and their meetings are here.`,
550. ]
551. .filter(Boolean)
552. .join(' '),
553. }
554. }
556. export function buildBriefingPayload(snap: Snapshot, now = new Date()): BriefingPayload {
557. const h: Headline = headline(snap)
558. const lines = snap.orderLines.data
559. const queue = orderQueue(lines)
560. const todos = snap.ninety.ok ? snap.ninety.data : []
561. const allTodos = toPayloadTodos(todos, now)
562. const loads = todoLoad(todos, now)
563. const { real: realTasks, junk } = partitionTasks(snap.tasks.data)
565. const unassigned = queue.filter((r) => r.designer === null)
566. const lateTodos = allTodos.filter((t) => t.late)
568. const people: PayloadPerson[] = MERIDIAN_PEOPLE.map((p: Person) => {
569. const coversPlinth = p.coveredBy.some((c) => c.startsWith('plinth-'))
570. const coversTasks = p.coveredBy.includes('bitrix-tasks')
572. const theirOrders = coversPlinth
573. ? queue.filter((r) => r.designer === p.name || r.accountOwner === p.name)
574. : []
575. const theirTasks = coversTasks
576. ? realTasks.filter((t) => t.responsibleId === p.name)
577. : []
578. const load = loads.find((l) => l.name === p.name)
579. // Resolved through the roster, not by string-matching display names.
580. // Ninety spells "Samuel Whitaker" where the roster reads "Sam Whitaker";
581. // an equality join would silently attribute nothing to them.
582. const theirTodos = allTodos.filter((t) => t.ownerKey === p.name)
584. const ages = theirOrders.map((r) => r.ageDays).filter((d): d is number => d !== null)
586. return {
587. name: p.name,
588. role: p.role,
589. ordersOwed: coversPlinth ? theirOrders.length : null,
590. tasksOpen: coversTasks ? theirTasks.length : null,
591. todosOpen: snap.ninety.ok ? (load?.open ?? 0) : null,
592. todosLate: snap.ninety.ok ? (load?.late ?? 0) : null,
593. oldestDays: ages.length ? Math.max(...ages) : null,
594. coverage: p.coveredBy.map((c) => SOURCE_LABELS[c] ?? c),
595. untracked: p.coveredBy.length === 0,
596. orders: theirOrders.slice(0, LIST_CAP).map(toPayloadOrder),
597. todos: theirTodos.slice(0, LIST_CAP),
598. // Gated by participation, exactly as the rendered page is. See the field's
599. // declaration for why the payload is its own leak path.
600. meetings:
601. snap.fathomConfigured && snap.meetings.ok
602. ? snap.meetings.data
603. .filter((m) => m.participants.includes(p.name))
604. .slice(0, LIST_CAP)
605. .map((m) => ({
606. title: m.title,
607. date: m.date,
608. items: m.items.slice(0, LIST_CAP).map((i) => ({
609. text: i.text,
610. owner: i.owner,
611. unowned: !i.owner && !i.externalOwner && !i.unknownOwner,
612. })),
613. }))
614. : null,
615. }
616. })
618. const truncated =
619. queue.length > LIST_CAP || unassigned.length > LIST_CAP || lateTodos.length > LIST_CAP
621. return {
622. schemaVersion: PAYLOAD_SCHEMA_VERSION,
623. generatedAt: snap.syncedAt,
624. mode: snap.mode,
625. capturedAt: snap.fixtureCapturedAt,
626. day: localDay(snap.syncedAt, MERIDIAN_TZ) ?? snap.syncedAt.slice(0, 10),
627. timezone: MERIDIAN_TZ,
628. rules:
629. snap.mode === 'fixtures'
630. ? [
631. `THIS IS SAMPLE DATA captured ${snap.fixtureCapturedAt?.slice(0, 10) ?? 'earlier'}, ` +
632. `not today's work. Orders described here as open have since shipped. Do not present ` +
633. `any of it as current, do not name anyone as holding work, and say plainly in your ` +
634. `first sentence that this is a sample.`,
635. ...INTERPRETATION_RULES,
636. ]
637. : INTERPRETATION_RULES,
638. sources: [
639. {
640. name: 'Bitrix leads',
641. ok: snap.leads.ok,
642. covers: 'open leads and their stage',
643. error: snap.leads.error,
644. },
645. {
646. name: 'Bitrix tasks',
647. ok: snap.tasks.ok,
648. covers: 'internal task queue',
649. error: snap.tasks.error,
650. },
651. {
652. name: 'Plinth order lines',
653. ok: snap.orderLines.ok,
654. covers: 'orders, product status, designer assignment',
655. error: snap.orderLines.error,
656. },
657. {
658. name: 'Ninety to-dos',
659. ok: snap.ninety.ok,
660. covers: 'company-wide commitments, all people, one admin token',
661. error: snap.ninety.error,
662. },
663. // Fathom belongs on this list because each person's `meetings` array is
664. // already gated to what they attended, so a short one is normal, and
665. // without this row nothing in the payload would tell the model the
666. // difference between a quiet fortnight and a key that could not be read. brief.py turns an `ok: false` row into a warning naming the
667. // source, which is how a dark key reaches a human.
668. fathomSource(snap),
669. ],
670. company: {
671. ourMove: h.ourMove,
672. designQueue: h.designQueue,
673. clientReplied: h.needsReply,
674. waitingOnClient: h.waitingOnClient,
675. atVendor: h.atVendor,
676. openLeads: h.realLeads,
677. automatedLeadsExcluded: h.noiseLeads,
678. completedLeadsExcluded: h.completedLeads,
679. commitments: h.commitments,
680. assignments: h.assignments,
681. sharedCommitments: h.sharedCommitments,
682. lateTodos: h.lateTodos,
683. },
684. people,
685. exec: buildExecView(snap, queue, todos),
686. execRules: EXEC_RULES,
687. queues: {
688. oldestOrders: queue.slice(0, LIST_CAP).map(toPayloadOrder),
689. unassignedOrders: unassigned.slice(0, LIST_CAP).map(toPayloadOrder),
690. lateTodos: lateTodos.slice(0, LIST_CAP),
691. truncated,
692. },
693. dataHealth: {
694. warnings: snap.assignmentWarnings,
695. unknownProductStatuses: h.unknownStatuses,
696. ordersMissingDesigner: unassigned.length,
697. unmappedTodoOwners: unmappedNinetyOwners(
698. todos.map((t) => ({ id: t.owner.id, name: t.owner.name })),
699. ),
700. assignmentFieldCoverage: snap.orderWindow.assignmentFields,
701. junkTasksExcluded: snap.tasks.ok ? junk.length : null,
702. },
703. }
704. }