Deploy AIOS web (React glide grid + FastAPI slice)

api/routes_grid.py

@@ -677,6 +677,37 @@ def grid_events_route(body: dict = Body(default=None),
         out["doc"] = ctx.out.doc
     if ctx.out.toast is not None:
         out["toast"] = ctx.out.toast
+
+    # ── ⭐ owner item 2 (2026-08-03): THE NEW MEASURE COLUMN'S VALUES, ONE ROUND TRIP SOONER ──
+    #
+    # Creating a measure column cost the browser TWO sequential trips before a single number
+    # appeared: this one to persist the field, then a whole `/workspace` to compute it. The
+    # second cannot start until the first lands (the resolver reads the PERSISTED field), so the
+    # wait was structural, not slow code — the owner's "it takes some time for the data to
+    # populate". The values are computed here instead, immediately after the write, and ride
+    # this response.
+    #
+    # ⚠ IT COSTS NOTHING EXTRA TO COMPUTE. The expensive part is one DuckDB aggregate over the
+    # book, and `rt.measure_memo` is keyed on (pool stamp, scope, pool, measure, window) — so
+    # the `/workspace` re-read that still follows HITS the memo instead of doing this work. The
+    # query happens once either way; only its position moved.
+    #
+    # ⚠ NARROW ON PURPOSE. Gated to an actual measure-column write, so an overlay edit or a
+    # cohort add — the overwhelming majority of events — never pays for a second assembly.
+    #
+    # ⚠ AND IT IS A SHORTCUT, NOT A PATH. Any failure is swallowed: `WORKSPACE_STALE` still
+    # fires from `rerender`, and the re-read still delivers these values exactly as it does
+    # today. Nothing depends on this having worked.
+    if out["rerender"] and scope != "product" and any(
+            isinstance(e, dict) and e.get("type") == "field_upsert"
+            and str(((e.get("field") or {}) if isinstance(e.get("field"), dict) else {})
+                    .get("key") or "").startswith("measure_")
+            for e in events):
+        try:
+            fresh = grid_assembly(session, scope=scope, consume_corrections=False)
+            out["derived"] = {str(pid): cells for pid, cells in fresh["derived"].items()}
+        except Exception:
+            pass
     # ⚠ NOTHING IS INVALIDATED HERE, on purpose. The runtime cache holds ONLY the scope-shaped
     # Odoo pool (see `routes_customers._pool_rows`), and no event on this route can change an
     # Odoo column — Odoo is read-only. Everything an event DOES change (overlays, fields, views,

royalimports_os/aios_grid_fields.json

@@ -260,6 +260,7 @@
     }
   ],
   "_product_comment": "ADDITIVE, wave 15 C-TOPIC. The PRODUCT table's field contract. Kept as a SEPARATE top-level key rather than restructuring `fields` into {customer_data, product_data}: both existing readers (aios_grid._load_fields, aios-web/api/main.py) index doc['fields'] directly, and reshaping that mid-wave would break the embed for a cosmetic gain. The keyed shape can arrive when both readers move in ONE commit; until then this is the product half and `fields` is the customer half.",
+  "_product_removed_buy_now": "OWNER, 2026-08-03: 'Buy signal' (key buy_now, a select of Buy now / OK) is NO LONGER A PRESET FIELD. It never earned one: it is a formula over two columns that are both still right here, and the platform has a formula field type for exactly that. THE FORMULA, which reproduces the retired column row for row (modules/product_data.validate proves the equivalence, and goes red if it ever stops holding): IF({lead_days} > 0, IF({dos} < {lead_days}, \"Buy now\", \"OK\"), \"\") . Every branch matches the old server rule, including the blanks - the formula engine refuses a comparison against a blank rather than coercing it to 0, so a SKU with no days-of-supply or no lead time comes out empty, which is 'we do not know' and not 'you are fine'. NOTE the column is still COMPUTED in product_data.pool(): it ships nowhere (rows_from_pool projects strictly through this contract, so no Field means no cell on the wire) and exists only as validate()'s oracle. A formula field is PER-USER, so nothing shared may filter on it - the Buy list view filters on dos/lead_days directly (_seed_wave17).",
   "product_data": {
     "identity": "pid",
     "business_key": "code",
@@ -400,18 +401,6 @@
         "default": false,
         "description": "Days of supply minus lead time. Negative means it runs out before a reorder lands."
       },
-      {
-        "key": "buy_now",
-        "label": "Buy signal",
-        "type": "select",
-        "source": "odoo",
-        "default": true,
-        "description": "Buy now when cover is already shorter than lead time. Blank if either is unknown.",
-        "options": [
-          "Buy now",
-          "OK"
-        ]
-      },
       {
         "key": "stock_bucket",
         "label": "Stock status",

royalimports_os/modules/product_data.py

@@ -39,10 +39,17 @@ import core.periods as P
 import core.table_store as table_store
 import modules.products as products
 
-#: Columns that exist ONLY on a consolidated pull. See decision 2.
+#: POOL-ROW KEYS that exist ONLY on a consolidated pull. See decision 2.
 #: `cover_gap_d` / `buy_now` (wave 17) join it because both are computed FROM `dos`, and a buy
 #: signal built on a stock number the caller cannot see would be a recommendation nobody could
 #: check ([[no-unverifiable-aggregates]]).
+#:
+#: ⚠ ROW KEYS, NOT FIELDS, and the distinction started mattering on 2026-08-03. Two readers:
+#: `verify_perm_scope` asserts the shape of a POOL ROW against this, and `routes_products`
+#: narrows the FIELD list with it. Since owner item 5 `buy_now` is a row key with no Field —
+#: computed as `validate()`'s oracle, projected onto no wire — so it belongs here for the first
+#: reader and is inert for the second. Removing it would stop the scope gate proving that a
+#: BU-scoped pull withholds it.
 CONSOLIDATED_ONLY = ("on_hand", "unit_cost", "inv_value", "qty_ltm", "dos", "stock_bucket",
                      "cover_gap_d", "buy_now")
 
@@ -187,6 +194,18 @@ def pool(team_id=None, t=None):
             # no lead time; `dos` is null for anything that never sells through. "We don't know"
             # and "you're fine" are different sentences, and only one of them is safe to print
             # beside a purchasing decision.
+            #
+            # ⛔ `buy_now` SHIPS NOWHERE ANY MORE, and is computed anyway. OWNER 2026-08-03: it
+            # is not a preset field — it is a formula over the two columns beside it, and the
+            # platform has a formula field type for exactly that. Its Field is gone from
+            # `aios_grid_fields.json`, and `rows_from_pool` projects rows STRICTLY through that
+            # contract, so no Field means no cell on the wire. Nothing renders this key.
+            #
+            # It stays computed because deleting it would delete the PROOF. `validate()` below
+            # reconciles the formula's predicate against this one, row for row, which is the only
+            # thing that makes "the same exact figures" a claim rather than an assertion — and
+            # this repo has the scar already (wave 17: archiving `ar` "would have DELETED the
+            # proof"). Two comparisons per SKU is what that costs.
             dos, lead = e.get("dos"), s.get("lead_days")
             if isinstance(dos, (int, float)) and isinstance(lead, (int, float)) and lead > 0:
                 row["cover_gap_d"] = int(round(dos - lead))
@@ -201,6 +220,47 @@ def pool(team_id=None, t=None):
     return rows
 
 
+#: ⭐ THE BUY SIGNAL, AS THE FORMULA FIELD EVALUATES IT (owner, 2026-08-03).
+#:
+#: The owner's ruling was that "Buy signal" is not a preset field — it is a formula over two
+#: columns the product table already carries, and the platform has a formula field type for it.
+#: The formula, verbatim, is what `_seed_wave17.BUY_SIGNAL_FORMULA` creates and what the JSON
+#: contract's `_product_removed_buy_now` note records:
+#:
+#:     IF({lead_days} > 0, IF({dos} < {lead_days}, "Buy now", "OK"), "")
+#:
+#: This function is a PORT of how `customer-grid/formulaEngine.ts` evaluates that tree, not a
+#: restatement of the business rule — that is the whole point, because the two could drift and
+#: `validate()` is where the drift must show. Three engine behaviours it reproduces exactly:
+#:
+#:   · a `ref` to a missing/non-numeric cell is None (`case "ref"` returns null for anything
+#:     that is not a finite number or a string);
+#:   · `cmp` returns BLANK unless BOTH sides read as numbers — it never coerces a blank to 0,
+#:     which is the difference between this and a filter engine's `toNum(null) === 0`;
+#:   · `IF` with a non-boolean condition returns BLANK ("no truthiness"), so a blank comparison
+#:     propagates out as a blank cell rather than taking the false branch.
+BUY_SIGNAL_FORMULA = 'IF({lead_days} > 0, IF({dos} < {lead_days}, "Buy now", "OK"), "")'
+
+
+def _buy_signal_formula(row):
+    """Evaluate `BUY_SIGNAL_FORMULA` over one pool row -> 'Buy now' | 'OK' | '' (blank)."""
+    def num(v):
+        # The engine's `ref` + `asNumber`: booleans are not values here, and a non-finite
+        # number is null. `isinstance(True, int)` is True in Python, so bool is excluded first.
+        if isinstance(v, bool) or not isinstance(v, (int, float)):
+            return None
+        return v if v == v and v not in (float('inf'), float('-inf')) else None
+
+    lead, dos = num(row.get("lead_days")), num(row.get("dos"))
+    if lead is None:                 # `{lead_days} > 0` is blank -> IF(blank, …) is blank
+        return ""
+    if not lead > 0:
+        return ""                    # the formula's own else-branch
+    if dos is None:                  # `{dos} < {lead_days}` is blank -> IF(blank, …) is blank
+        return ""
+    return "Buy now" if dos < lead else "OK"
+
+
 def validate(team_id=None, t=None):
     """Reconcile what SHIPS to an independent aggregate — the platform's own rule that a number
     which does not tie to Odoo does not ship.
@@ -241,4 +301,56 @@ def validate(team_id=None, t=None):
             "detail": {"buy_now": len(buy), "ok": len(ok_rows), "unknown": len(blank),
                        "misclassified": mis},
         })
+        # ⭐ OWNER 2026-08-03 — "use the formula fields to come up to the same EXACT figures".
+        #
+        # This is that sentence, as a check. The retired preset column and the formula that
+        # replaces it must agree on every SKU, in all three states, or the replacement is not a
+        # replacement. `_buy_signal_formula` is a line-by-line port of the client formula
+        # engine's evaluation of
+        #
+        #     IF({lead_days} > 0, IF({dos} < {lead_days}, "Buy now", "OK"), "")
+        #
+        # including the part that is easy to get wrong: a comparison against a BLANK is blank,
+        # never a coerced 0. (The client engine's `cmp` returns null unless both sides read as
+        # numbers, and `IF` refuses a non-boolean condition — so a missing `dos` yields "" and
+        # not "Buy now". A filter engine would have said `0 < 30` and swept in every SKU that
+        # never sells through; the formula engine does not, and this check is what holds it.)
+        #
+        # ⚠ It compares SETS OF SKUs, not counts. Two different partitions can share a shape.
+        disagree = sorted(r["code"] for r in rows
+                          if (r.get("buy_now") or "") != _buy_signal_formula(r))
+        checks.append({
+            "check": 'Buy signal as a FORMULA field == the retired preset column, per SKU '
+                     '(IF({lead_days} > 0, IF({dos} < {lead_days}, "Buy now", "OK"), ""))',
+            "ours": len(rows) - len(disagree), "theirs": len(rows),
+            "ok": not disagree,
+            "detail": {"disagreeing_skus": disagree[:10], "n_disagree": len(disagree)},
+        })
+        # The other half of "the same figures": the SHARED Buy list view can no longer filter on
+        # the retired column, and its replacement conditions must select the same SKUs. They are
+        # `dos isNotEmpty AND lead_days isNotEmpty AND lead_days > 0 AND dos < lead_days`
+        # (_seed_wave17.views), so this reproduces exactly that conjunction.
+        #
+        # ⛔ THE NEGATIVE CONTROL IS WHY THIS IS NOT `cover_gap_d < 0`, which reads like the
+        # obvious filter and is WRONG: `cover_gap_d` is `int(round(dos - lead))`, so a genuine
+        # gap of -0.4 days rounds to 0 and that SKU drops off a buy list it belongs on.
+        view_rows = {r["code"] for r in rows
+                     if isinstance(r.get("dos"), (int, float))
+                     and isinstance(r.get("lead_days"), (int, float))
+                     and r["lead_days"] > 0 and r["dos"] < r["lead_days"]}
+        signal_rows = {r["code"] for r in buy}
+        rounding_would_miss = sorted(
+            c for c in signal_rows
+            if next((r for r in rows if r["code"] == c), {}).get("cover_gap_d") == 0)
+        checks.append({
+            "check": "Buy list view conditions (dos/lead_days, no retired column) select "
+                     "exactly the Buy-now SKUs",
+            "ours": len(view_rows), "theirs": len(signal_rows),
+            "ok": view_rows == signal_rows,
+            "detail": {"only_in_view": sorted(view_rows - signal_rows)[:10],
+                       "only_in_signal": sorted(signal_rows - view_rows)[:10],
+                       # Reported, not asserted: how many SKUs a `cover_gap_d < 0` filter would
+                       # have silently dropped. 0 today does not make that filter correct.
+                       "cover_gap_rounds_to_zero": len(rounding_would_miss)},
+        })
     return checks

web/src/apiContract.ts

@@ -46,6 +46,20 @@ export const DATA_ERROR_EVENT = "aios:data-error";
  *  `detail` is the string. */
 export const TOAST_EVENT = "aios:toast";
 
+/**
+ * owner item 2 (2026-08-03) — the events response carried DERIVED CELLS with it.
+ *
+ * Creating a measure column used to take two sequential round trips before a number appeared:
+ * one to persist the field, one to compute it. The server now computes right after the write
+ * and returns the values on the same response; `detail` is `{[pid: string]: {[key]: value}}`,
+ * exactly the `derived` shape `/workspace` sends.
+ *
+ * ⚠ A SHORTCUT, NEVER A PATH. `WORKSPACE_STALE_EVENT` still fires beside it and the re-read
+ * still delivers the same values — so a browser that misses this, or a server that could not
+ * compute it, behaves exactly as it did before. Nothing may be built on it arriving.
+ */
+export const DERIVED_CELLS_EVENT = "aios:derived-cells";
+
 /** A write CHANGED durable workspace state (a cohort's membership, a list add, a
  *  folder move) and the client's copy is now stale.
  *

web/src/customer-grid/CustomerGrid.tsx

@@ -38,9 +38,12 @@ import ColumnMenu from "./ColumnMenu";
 import type { ColumnMenuState } from "./ColumnMenu";
 import { HEADER_ICONS } from "./iconShapes";
 import { emitHostEvent, eventId } from "./hostBridge";
-import { NAV_MINIMIZE_EVENT, signal } from "../apiContract";
-import { runExport } from "./export";
+import { NAV_MINIMIZE_EVENT, TOAST_EVENT, signal } from "../apiContract";
+import { exportFilename, runExport, triggerDownload } from "./export";
 import type { ExportFormat } from "./export";
+// owner item 3 (2026-08-03) — a time-series view exports its SHEET, not the rows under it.
+import { buildTsCsv, tsSheetToTable } from "./timeSeriesData";
+import type { TsSheet } from "./timeSeriesData";
 import { echoReemit, reconcileEchoView } from "./viewEcho";
 import { pruneStamps, reconcileFields } from "./optimism";
 import { newFolderId, pruneFolderStamps, reconcileFolders, resolveFolderId } from "./folders";
@@ -123,6 +126,20 @@ function frozenCountOf(config: ViewConfig): number {
 }
 const ALL_VIEW_ID = "all-customers";
 
+/**
+ * owner item 2 (2026-08-03) — the measure-cell skeleton's pulse, and its ceiling.
+ *
+ * 140ms against the 4-step colour ramp is a ~0.6s cycle: a wait, not a strobe. The ceiling is
+ * ~60s, after which the cells fall back to ordinary blanks — a measure that has not resolved in
+ * a minute is not "still loading", and a shimmer that never ends promises a number that is not
+ * coming. Shared constant so the two are read in one place rather than tuned apart.
+ */
+const PULSE_MS = 140;
+const PULSE_MAX_TICKS = Math.round(60_000 / PULSE_MS);
+/** Referentially stable, so the fallback does not change `getCellContent`'s identity per render
+ *  and repaint the canvas forever. */
+const NO_PENDING_KEYS: ReadonlySet<string> = new Set<string>();
+
 /**
  * I2 — measure a cell's text in GLIDE'S OWN font, so "is this cut off?" is a fact rather than
  * a character-count guess (a guess is wrong in both directions: "IIIII" is narrow, "WWWWW" is
@@ -907,6 +924,70 @@ function CustomerGrid({ scope = "customer" }: { scope?: SurfaceScope } = {}) {
       px += (visibleCols[i] as { width?: number } | undefined)?.width ?? 0;
     return Math.max(0, px - GROUP_LABEL_PAD);
   }, [config, visibleCols]);
+  /**
+   * ⭐ owner item 2 (2026-08-03) — WHICH MEASURE COLUMNS ARE STILL BEING CALCULATED.
+   *
+   * A measure column's numbers are resolved by the server (one aggregate over the whole book)
+   * and reach the browser on the workspace re-read that follows the create — seconds later.
+   * In between, the column is on screen with nothing in it, which the owner correctly read as
+   * an error rather than as a wait.
+   *
+   * ⛔ `editRequestId` IS THE TEST, and it is the honest one. It is set optimistically at the
+   * moment the create is emitted and cleared by `reconcileFields` when the host's own copy of
+   * that field comes back — and the host's copy travels in the SAME `/workspace` response as
+   * `derived`, which is where the values are. So the flag is true across exactly the window
+   * where the column exists and its numbers do not, and false the instant they land.
+   *
+   * The alternative — "no value anywhere in the column" — cannot tell a pending column from
+   * one that permanently failed to resolve (a BU-scoped caller on a company-level measure,
+   * say), and would spin forever on the second. This one resolves either way: when the echo
+   * arrives with no values, the flag clears and the cells go honestly blank.
+   */
+  const pendingMeasureKeys = useMemo(() => {
+    const out = new Set<string>();
+    for (const f of fields)
+      if (f.editRequestId && f.key.startsWith("measure_")) out.add(f.key);
+    return out;
+  }, [fields]);
+  /**
+   * The skeleton's pulse. A canvas cell cannot hold a CSS animation, so the motion is repaints:
+   * this counter is a dependency of `getCellContent`, which is the only thing glide watches.
+   *
+   * ⚠ IT RUNS ONLY WHILE SOMETHING IS PENDING, and the effect's own guard is what stops it —
+   * an interval left running would repaint the whole canvas ~7×/s forever, on every grid, to
+   * animate nothing. 140ms × the 4-step ramp is a ~0.6s cycle: a wait, not a strobe.
+   */
+  const [pulse, setPulse] = useState(0);
+  /**
+   * ⛔ AND IT GIVES UP. A skeleton that never resolves is worse than the blank it replaced: a
+   * blank cell is at least honest about having no number, while a permanent shimmer promises
+   * one that is never coming.
+   *
+   * The window it guards is narrow but real. `editRequestId` clears when `reconcileFields` takes
+   * the host's copy — and that function has a branch (`hostAuthoritative: false`, i.e. a payload
+   * with no workspace) whose `{...local, ...host}` spread would PRESERVE the flag forever. Today
+   * that branch cannot be reached with a measure column on screen (measures are offered through
+   * the workspace, so a payload without one cannot have produced this field), which is an
+   * argument about the current call graph and not a property of the code. This bound holds
+   * whether or not the argument stays true, and it costs one boolean.
+   */
+  const [pendingGaveUp, setPendingGaveUp] = useState(false);
+  useEffect(() => {
+    setPendingGaveUp(false);
+    if (pendingMeasureKeys.size === 0) return;
+    let n = 0;
+    const id = window.setInterval(() => {
+      n += 1;
+      if (n > PULSE_MAX_TICKS) {
+        window.clearInterval(id);
+        setPendingGaveUp(true);      // fall back to ordinary blank cells
+        return;
+      }
+      setPulse((p) => p + 1);
+    }, PULSE_MS);
+    return () => window.clearInterval(id);
+  }, [pendingMeasureKeys]);
+  const activePendingKeys = pendingGaveUp ? NO_PENDING_KEYS : pendingMeasureKeys;
   const getCellContent = useGetCellContent(
     displayRows,
     visibleCols,
@@ -916,7 +997,9 @@ function CustomerGrid({ scope = "customer" }: { scope?: SurfaceScope } = {}) {
     userAvatars,
     avatarTick,
     groupLabelSpace,
-    measureGroupText
+    measureGroupText,
+    activePendingKeys,
+    pulse
   );
   const { gridSelection, selectedPids, onGridSelectionChange, selectPids, togglePid,
           setActiveCell, clearSelection } =
@@ -1986,14 +2069,90 @@ function CustomerGrid({ scope = "customer" }: { scope?: SurfaceScope } = {}) {
     [serverWindowed, fields, fieldByKey, measureSets, cohortSets, today, overlayEdits]
   );
 
-  /** W2 — the view menu's Export (Customer page): the named view over the whole pool. */
+  /**
+   * ⭐ owner item 3 (2026-08-03) — THE SHEET THE TIME-SERIES VIEW IS SHOWING, published by the
+   * panel. A ref rather than state on purpose: nothing renders from it, and setting state on
+   * every sheet rebuild would re-render the whole grid to feed a menu nobody has opened yet.
+   */
+  const tsSheetRef = useRef<TsSheet | null>(null);
+  const onTsSheet = useCallback((s: TsSheet) => { tsSheetRef.current = s; }, []);
+  /** The same channel for a SUMMARY calendar — the other mode whose content is not its rows.
+   *  `null` is CalendarView saying "records mode, export the rows" (see its note). */
+  const calSheetRef = useRef<{ fields: Field[]; rows: Row[] } | null>(null);
+  const onCalSheet = useCallback(
+    (s: { fields: Field[]; rows: Row[] } | null) => { calSheetRef.current = s; },
+    []
+  );
+
+  /**
+   * W2 — the view menu's Export (Customer page): the named view over the whole pool.
+   *
+   * ⭐ owner item 3 (2026-08-03) — AND IT EXPORTS WHAT THE VIEW SHOWS. Every mode used to
+   * export the same thing: the matched customer rows. For grid / list / kanban / calendar /
+   * map / chart that is right — those modes ARRANGE rows, so the rows are what they show, and
+   * a calendar's dates and a kanban's lanes are columns already in the file.
+   *
+   * TWO modes are not arrangements of rows, and both were wrong in the direction that matters:
+   *
+   *   · `timeseries` — metric ROWS over period COLUMNS. Exporting it handed you a customer list
+   *     that shares none of its numbers. It exports the SHEET.
+   *   · `calendar` IN SUMMARY MODE — metric values per DAY (C-DISP item 4). Same problem, and
+   *     the owner named this one by hand. A calendar in RECORDS mode is genuinely an
+   *     arrangement of rows, so it keeps the row export; `CalendarView` says which it is by
+   *     publishing a sheet or publishing null.
+   *
+   * ⚠ ONLY FOR THE ACTIVE VIEW, and this is a real limit, not an oversight. Both sheets are
+   * built by the mounted view — the time series from a server round trip, the calendar from the
+   * month on screen. A view sitting unopened in the rail has neither, and this component cannot
+   * conjure one without fetching it. So that case SAYS SO and downloads nothing: the
+   * alternative is silently handing over the customer rows under that view's name, which is the
+   * exact substitution this branch exists to stop.
+   */
   const exportViewData = useCallback(
     (viewId: string, format: ExportFormat) => {
       const view = views.find((v) => v.id === viewId);
       if (!view) return;
-      exportRows(view.name, normalizeConfig(view.config, fields), computedRows, format);
+      const cfg = normalizeConfig(view.config, fields);
+      const spec = cleanDisplay(cfg.display);
+      const isActive = viewId === activeViewId;
+      const refuse = (what: string) =>
+        signal(
+          TOAST_EVENT,
+          `Open "${view.name}" first: ${what} is exported from what it draws on screen.`
+        );
+
+      if (spec?.mode === "timeseries") {
+        const sheet = isActive ? tsSheetRef.current : null;
+        if (!sheet) return refuse("a time series");
+        if (sheet.empty) {
+          signal(TOAST_EVENT,
+                 `"${view.name}" has no metrics on its sheet yet — add one, then export.`);
+          return;
+        }
+        if (format === "csv") {
+          // The gated builder (verify_timeseries), kept as THE csv path so the file the owner
+          // downloads is the one the gate proves — footnotes, grouped thousands and all.
+          triggerDownload(
+            exportFilename(view.name, today, format),
+            new Blob(["" + buildTsCsv(sheet)], { type: "text/csv;charset=utf-8" })
+          );
+        } else {
+          const { fields: tf, rows: tr } = tsSheetToTable(sheet);
+          runExport(format, view.name, today, tf, tr);
+        }
+        return;
+      }
+
+      if (spec?.mode === "calendar" && spec.calendarMode === "summary") {
+        const sheet = isActive ? calSheetRef.current : null;
+        if (!sheet) return refuse("a calendar summary");
+        runExport(format, view.name, today, sheet.fields, sheet.rows);
+        return;
+      }
+
+      exportRows(view.name, cfg, computedRows, format);
     },
-    [views, fields, computedRows, exportRows]
+    [views, fields, computedRows, exportRows, activeViewId, today]
   );
 
   /**
@@ -3092,6 +3251,8 @@ function CustomerGrid({ scope = "customer" }: { scope?: SurfaceScope } = {}) {
                    about (C-CAL). The server refuses `product` in words. */
                 scope={scope}
                 onOpen={setDetailPid}
+                /* owner item 3 — the summary month, so the view menu's Export can carry it. */
+                onSheet={onCalSheet}
               />
             ) : (
               <div className="cg-mode-empty">
@@ -3148,6 +3309,8 @@ function CustomerGrid({ scope = "customer" }: { scope?: SurfaceScope } = {}) {
               rows={modeDataRows}
               display={displaySpec}
               onDisplay={onTimeseriesDisplay}
+              /* owner item 3 — the built sheet, so the view menu's Export can carry it. */
+              onSheet={onTsSheet}
             />
           )}
           {/* Wave-7 item W11c (C3) — Map is a VIEW: same pipeline rows, pins for rows

web/src/customer-grid/TimeSeriesPanel.tsx

@@ -31,13 +31,11 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { fetchTimeseries } from "./apiBridge";
 import type { SurfaceScope } from "./apiBridge";
-import { triggerDownload } from "./export";
 import { isStreamlitComponent } from "./hostBridge";
 import {
   DEFAULT_TS_BUCKET,
   DEFAULT_TS_LAST_N,
   TS_DELTA_LABELS,
-  buildTsCsv,
   buildTsRequest,
   buildTsSheet,
   buildTsSnapshotRow,
@@ -140,6 +138,11 @@ export interface TimeSeriesPanelProps {
   onDisplay?: (next: Partial<DisplaySpec>) => void;
   /** Item 13 — the pid set is the caller's and cannot be widened from here. */
   locked?: boolean;
+  /**
+   * owner item 3 (2026-08-03) — publish the built sheet so the view menu's Export can carry it.
+   * Absent = this mount cannot be exported (RECORD's embed), which is the honest default.
+   */
+  onSheet?: (sheet: TsSheet) => void;
 }
 
 /**
@@ -185,6 +188,7 @@ export default function TimeSeriesPanel({
   display,
   onDisplay,
   locked,
+  onSheet,
 }: TimeSeriesPanelProps) {
   const classed = useMemo(() => classifyFields(fields), [fields]);
   // The OFFERED list: everything with a way onto the sheet, server-served first so a real series
@@ -299,13 +303,26 @@ export default function TimeSeriesPanel({
     [table, customRows, deltaKinds, bucket, payload?.meta?.today]
   );
 
-  const onCsv = useCallback(() => {
-    const csv = buildTsCsv(sheet);
-    triggerDownload(
-      "Time series.csv",
-      new Blob(["" + csv], { type: "text/csv;charset=utf-8" })
-    );
-  }, [sheet]);
+  /**
+   * ⭐ owner item 3 (2026-08-03) — the sheet is PUBLISHED, not downloaded from here.
+   *
+   * This panel used to carry its own "Export CSV" button. It was the only view in the product
+   * with a second export door, and the only one offering a single format, while every other
+   * view exports from the "…" menu in the rail with four. So the button is gone and the sheet
+   * goes UP instead: the owner of the view menu builds the file, and the time-series view
+   * exports its SHEET rather than the customer rows underneath it.
+   *
+   * ⚠ A PROP, WHICH IS WHAT KEEPS THIS FILE HOST-AGNOSTIC. The rule at the top of this file is
+   * that the panel reads no CustomerGrid state — a callback the caller supplies is the same
+   * shape `onDisplay` already is. RECORD's embed passes neither and simply cannot export, which
+   * is correct: there is no view menu in a record modal.
+   *
+   * Effect rather than a render-time call: publishing during render would set state in another
+   * component mid-render. `sheet` is a `useMemo`, so this fires on a real change, not per frame.
+   */
+  useEffect(() => {
+    onSheet?.(sheet);
+  }, [sheet, onSheet]);
 
   const toggleChart = useCallback((key: string) => {
     setCharted((prev) => {
@@ -468,9 +485,10 @@ export default function TimeSeriesPanel({
           </button>
         </span>
 
-        <button type="button" className="cg-tb-btn" onClick={onCsv} disabled={sheet.empty}>
-          Export CSV
-        </button>
+        {/* ⛔ NO EXPORT BUTTON HERE (owner item 3, 2026-08-03). Export lives in the view's "…"
+            menu, on every view, in four formats — and from a time-series view it now carries
+            THIS SHEET rather than the rows beneath it (see `onSheet` above). A second door on
+            one surface is how "where do I export from?" stops having an answer. */}
         <span className="cg-ts-pool">
           {locked
             ? "This record"
@@ -500,15 +518,34 @@ export default function TimeSeriesPanel({
       {/* wave17 item 5 / R9 — "offered is the ruling, undisclosed is not", and its converse: a
           field that CANNOT be plotted is NAMED here rather than quietly missing from the picker.
           A reader who can see "Status" in the table and cannot find it in this list otherwise has
-          no way to tell a refusal from an oversight. */}
+          no way to tell a refusal from an oversight.
+
+          ⛔ COLLAPSED, AFTER THE OWNER READ IT AS BROKEN MARKUP (2026-08-03). R9's disclosure was
+          shipped as a bare strip of every refused label — struck through, unheaded, at the small
+          end of the type scale. On the customer table that is ~25 names, and 25 crossed-out words
+          in a row under a toolbar do not read as "these columns have no period"; they read as a
+          stylesheet that failed to load. The strip said WHAT but never WHY IT WAS THERE.
+
+          A `<details>` fixes exactly that and nothing else: the disclosure is still complete and
+          still one click from the panel, but it now leads with a SENTENCE that says what the list
+          is, and it is shut until asked. Native rather than a Popover — no state, keyboard and
+          screen-reader behaviour for free, and it degrades to an open list if CSS never arrives,
+          which is the failure this element is being fixed for. */}
       {classed.refused.length > 0 && (
-        <div className="cg-ts-refused">
-          {classed.refused.map(({ field, why }) => (
-            <span key={field.key} className="cg-ts-refchip" title={why}>
-              {field.label}
-            </span>
-          ))}
-        </div>
+        <details className="cg-ts-refused">
+          <summary className="cg-ts-refsum">
+            {classed.refused.length === 1
+              ? "1 column has no period of its own"
+              : `${classed.refused.length} columns have no period of their own`}
+          </summary>
+          <div className="cg-ts-reflist">
+            {classed.refused.map(({ field, why }) => (
+              <span key={field.key} className="cg-ts-refchip" title={why}>
+                {field.label}
+              </span>
+            ))}
+          </div>
+        </details>
       )}
 
       {/* wave17 GRID — item 3 / R6. Only the LOADING note becomes a spinner; the refusal notes

web/src/customer-grid/Toolbar.tsx

@@ -812,39 +812,6 @@ export default function Toolbar({
         )}
       </Popover>
 
-      {/* ⭐ Wave-15 item 5c (C-LOCK / R10) — THE LOCK, SAID IN THE TOOLBAR.
-          Until now a cohort lock was stated only INSIDE the filter popover, which meant the one
-          control that explains a narrowed table was invisible until you opened something: the
-          count disagreed with the conditions and nothing on screen said why. It sits with
-          Filter / Sort / Group because it is the same kind of fact — what this table is showing
-          — and it is NOT a button: the lock is set from the view rail's menu, and a chip that
-          looked clickable here would promise an action this strip does not have. */}
-      {lockOn && (
-        <span
-          className="cg-tb-lock"
-          // The name and the count left the CHIP (R1) — they did not leave the product. The
-          // rail row is named and selected; this is the hover that explains what the mark means.
-          //
-          // ⚠ Branches on `name`, NOT on `count`, and that is the honest test. A set the reader
-          // may not see arrives with NEITHER field (`CustomerGrid.cohortLockChip` returns `{}`
-          // for a lock whose set is not in `lists`) — while a set that IS found always reports a
-          // number, because that producer reads `pids?.length ?? 0`. So `count == null` is not a
-          // state this chip can observe, and testing it would be a branch that never runs. The
-          // "unreadable set" sentence still has to exist: the table is empty for a reason that
-          // is not a filter, and the reader has to be told which kind of nothing this is.
-          title={
-            (cohortLock?.name
-              ? `Locked to ${cohortLock.name}. `
-              : "Locked to a set of records you cannot see. ") +
-            "Only the records locked into that view are shown. Filters and sort narrow WITHIN " +
-            "the lock; the lock itself is changed from the view menu in the rail."
-          }
-        >
-          <LockIcon />
-          <span className="cg-tb-label">Locked</span>
-        </span>
-      )}
-
       <span className="cg-tb-divider" aria-hidden />
 
       {/* Color — by status */}
@@ -894,6 +861,46 @@ export default function Toolbar({
         )}
       </Popover>
 
+      {/* ⭐ THE LOCK, SAID IN THE TOOLBAR (wave-15 item 5c / C-LOCK / R10).
+          A cohort lock used to be stated only INSIDE the filter popover, which meant the one
+          control that explains a narrowed table was invisible until you opened something: the
+          count disagreed with the conditions and nothing on screen said why. It is NOT a
+          button — the lock is set from the view rail's menu, and a chip that looked clickable
+          here would promise an action this strip does not have.
+
+          ⚠ POSITION IS THE OWNER'S, 2026-08-03: immediately RIGHT of "Rows". It used to sit
+          left of the divider beside Filter / Sort / Group, on the reasoning that it states the
+          same kind of fact. Beside three CONTROLS, a thing that cannot be clicked reads as a
+          disabled fourth; over here it is plainly a status mark on the table rather than a
+          broken button. It also only renders on a locked view, so on every other view "Rows"
+          and the search box stay adjacent exactly as item 14 (2026-08-02) placed them — that
+          ruling is narrowed by this one, not overturned. */}
+      {lockOn && (
+        <span
+          className="cg-tb-lock"
+          // The name and the count left the CHIP (R1) — they did not leave the product. The
+          // rail row is named and selected; this is the hover that explains what the mark means.
+          //
+          // ⚠ Branches on `name`, NOT on `count`, and that is the honest test. A set the reader
+          // may not see arrives with NEITHER field (`CustomerGrid.cohortLockChip` returns `{}`
+          // for a lock whose set is not in `lists`) — while a set that IS found always reports a
+          // number, because that producer reads `pids?.length ?? 0`. So `count == null` is not a
+          // state this chip can observe, and testing it would be a branch that never runs. The
+          // "unreadable set" sentence still has to exist: the table is empty for a reason that
+          // is not a filter, and the reader has to be told which kind of nothing this is.
+          title={
+            (cohortLock?.name
+              ? `Locked to ${cohortLock.name}. `
+              : "Locked to a set of records you cannot see. ") +
+            "Only the records locked into that view are shown. Filters and sort narrow WITHIN " +
+            "the lock; the lock itself is changed from the view menu in the rail."
+          }
+        >
+          <LockIcon />
+          <span className="cg-tb-label">Locked</span>
+        </span>
+      )}
+
       {/* Item 14 (owner, 2026-08-02) — SEARCH sits immediately right of "Rows", inside the
           control cluster, not marooned across the spacer. Deliberately BEFORE `cohortAction`:
           that slot is empty on the customer surface and holds "+ Add customers" on the cohort

web/src/customer-grid/apiBridge.ts

@@ -44,6 +44,7 @@ import {
   API_V1,
   CREDENTIALS,
   DATA_ERROR_EVENT,
+  DERIVED_CELLS_EVENT,
   TOAST_EVENT,
   WORKSPACE_STALE_EVENT,
   UNAUTHORIZED_EVENT,
@@ -408,10 +409,19 @@ async function drain(): Promise<void> {
  * `doc` is deliberately unhandled; see this file's header.
  */
 function applyEventResult(body: unknown): void {
-  const b = body as { toast?: unknown; rerender?: unknown; results?: unknown } | null;
+  const b = body as {
+    toast?: unknown; rerender?: unknown; results?: unknown; derived?: unknown;
+  } | null;
   const toast = b?.toast;
   if (typeof toast === "string" && toast.trim() !== "") signal(TOAST_EVENT, toast.trim());
 
+  // owner item 2 — a measure column's values, computed server-side right after the write and
+  // returned here rather than waiting for the `/workspace` re-read below. Raised BEFORE the
+  // stale signal so the numbers paint on the earlier of the two, whichever the server sent.
+  // Shape-checked, because a shortcut that corrupts rows is worse than no shortcut.
+  if (b?.derived && typeof b.derived === "object" && !Array.isArray(b.derived))
+    signal(DERIVED_CELLS_EVENT, b.derived);
+
   // The server already tells us when a write changed durable state — `rerender`
   // is exactly the flag the Streamlit adapter uses to trigger its own rerun. We
   // were dropping it, which is why cohort membership, list adds and folder moves

web/src/customer-grid/timeSeriesData.ts

@@ -30,7 +30,7 @@
 
 import type { ChartAgg, ChartModel } from "../viz/chartData";
 import { TS_MAX_BUCKETS, TS_MAX_FIELDS, TS_MAX_LAST_N, TS_BUCKETS } from "./types";
-import type { TsBucket, TsCellStyle, TsCustomRow, TsDeltaKind } from "./types";
+import type { Field, Row, TsBucket, TsCellStyle, TsCustomRow, TsDeltaKind } from "./types";
 
 // ---------------------------------------------------------------- the wire
 
@@ -1263,6 +1263,69 @@ export function buildTsCsv(sheet: TsSheet): string {
   return lines.join("\r\n") + "\r\n";
 }
 
+/**
+ * ⭐ owner item 3 (2026-08-03) — THE SHEET AS A RECTANGLE, so every export format can carry it.
+ *
+ * The panel used to own a lone "Export CSV" button, which made the time-series view the one
+ * surface in the product with its own export door and its own single format. The door moved to
+ * the view's "…" menu, where every other view already keeps it — and that menu offers four
+ * formats. `buildCsv` / `buildXlsx` / `buildPdf` / `buildJson` all speak `(Field[], Row[])`, so
+ * the cheapest honest way to give a SHEET all four is to hand them one.
+ *
+ * ⚠ THE VALUES ARE THE SHEET'S OWN DISPLAY STRINGS, and the fields are typed `text` so nothing
+ * re-formats them. This is the same promise wave17 item 6 made for the CSV: a cell reading
+ * `1,234.57` exports as `1,234.57`, not as `1234.5678901234`. Typing these columns as `currency`
+ * would be a second formatter over an already-formatted string and would print `$1,234.57` for a
+ * count. A sheet mixes dollars, counts and percents down one column; there is no one right
+ * numeric type for it, which is exactly why the strings are the answer.
+ *
+ * ⚠ THE FOOTNOTES TRAVEL, in the Metric column after a blank row — the same tail `buildTsCsv`
+ * appends, for the same reason: the dropped fields, the partial periods and the flat-by-
+ * construction snapshot rows are the disclosures, and the one document a reader keeps must not
+ * be the one without them.
+ *
+ * `pid` is positional and means nothing here — a sheet row is not a record. It exists because
+ * `Row` requires it and `buildJson` emits it; it is never read back.
+ */
+export function tsSheetToTable(sheet: TsSheet): { fields: Field[]; rows: Row[] } {
+  // `source: "odoo"` is what "read-only, not a user column" spells in this contract — the
+  // editability test at both ends is `source === "overlay"`. Nothing here is editable: these
+  // are export columns that exist for the length of one download.
+  const col = (key: string, label: string): Field =>
+    ({ key, label, type: "text", source: "odoo" });
+  const fields: Field[] = [
+    col("metric", "Metric"),
+    ...sheet.columns.map((c) =>
+      col(`c_${c.key}`, c.partial ? `${c.label} (partial)` : c.label)
+    ),
+    col("total", "Total"),
+  ];
+  const rows: Row[] = [];
+  const put = (label: string, cells: string[], total: string) => {
+    const row: Row = { pid: rows.length + 1, metric: label, total };
+    sheet.columns.forEach((c, i) => { row[`c_${c.key}`] = cells[i] ?? ""; });
+    rows.push(row);
+  };
+  for (const r of sheet.rows) {
+    put(
+      r.sublabel ? `${r.label} (${r.sublabel})` : r.label,
+      r.cells.map((c) => csvTsValue(c.value)),
+      csvTsValue(r.total ?? null)
+    );
+    for (const d of r.deltas)
+      put(
+        `${r.label} — ${d.label}${d.percent ? " (%)" : ""}`,
+        d.values.map((v) => csvTsDelta(v, d.percent)),
+        ""
+      );
+  }
+  if (sheet.notes.length > 0) {
+    put("", [], "");
+    for (const n of sheet.notes) put(n, [], "");
+  }
+  return { fields, rows };
+}
+
 /** The caps, re-exported so the panel and the gate read ONE source. */
 export const TS_LIMITS = {
   maxBuckets: TS_MAX_BUCKETS,

web/src/customer-grid/useCustomerData.ts

@@ -27,7 +27,7 @@ import type { Dispatch, SetStateAction } from "react";
 import { topicForScope } from "./types";
 import type { CustomersPayload, Field, GridWorkspace, Row } from "./types";
 import { fetchTopicRows, fetchWorkspace, patchTopicRow, setSurfaceScope } from "./apiBridge";
-import { WORKSPACE_STALE_EVENT } from "../apiContract";
+import { DERIVED_CELLS_EVENT, WORKSPACE_STALE_EVENT } from "../apiContract";
 import type { SurfaceScope } from "./apiBridge";
 import {
   emitHostEvent,
@@ -235,12 +235,52 @@ export function useCustomerData(scope: SurfaceScope = "customer"): CustomerData
       if (cancelled || !ws) return;      // absent stays absent — never blank a live panel
       setData((prev) => (prev ? withWorkspace(prev, ws) : prev));
     }
+    /**
+     * ⭐ owner item 2 (2026-08-03) — THE SHORTCUT. The events response can carry the derived
+     * cells a write just made computable (a new measure column's numbers), which lands them a
+     * full round trip before `reread()` would.
+     *
+     * ⚠ IT ONLY EVER ADDS. Cells are merged OVER the row, so a key the shortcut does not
+     * mention is untouched — this can fill a blank column, never blank a filled one. And the
+     * stale re-read still runs beside it and still wins on arrival, so the shortcut cannot
+     * become a second, divergent source of truth for the same values.
+     */
+    const onDerived = (ev: Event) => {
+      const cells = (ev as CustomEvent).detail as
+        | Record<string, Record<string, unknown>>
+        | undefined;
+      if (!cells || typeof cells !== "object") return;
+      setData((prev) => {
+        if (!prev) return prev;
+        let touched = false;
+        const rows = prev.rows.map((r) => {
+          const patch = cells[String(r.pid)];
+          if (!patch || typeof patch !== "object") return r;
+          // Each VALUE is checked, not just the envelope. A derived cell is a scalar; anything
+          // else (an object, an array) is dropped rather than written into a row that the whole
+          // grid — formulas, filters, exports — then reads as a value.
+          const clean: Partial<Row> = {};
+          for (const [k, v] of Object.entries(patch))
+            if (v === null || typeof v === "string" || typeof v === "number") clean[k] = v;
+          if (Object.keys(clean).length === 0) return r;
+          touched = true;
+          return { ...r, ...clean };
+        });
+        return touched ? { ...prev, rows } : prev;
+      });
+    };
     const onStale = () => { void reread(); };
-    if (typeof window !== "undefined") window.addEventListener(WORKSPACE_STALE_EVENT, onStale);
+    if (typeof window !== "undefined") {
+      window.addEventListener(WORKSPACE_STALE_EVENT, onStale);
+      window.addEventListener(DERIVED_CELLS_EVENT, onDerived);
+    }
 
     return () => {
       cancelled = true;
-      if (typeof window !== "undefined") window.removeEventListener(WORKSPACE_STALE_EVENT, onStale);
+      if (typeof window !== "undefined") {
+        window.removeEventListener(WORKSPACE_STALE_EVENT, onStale);
+        window.removeEventListener(DERIVED_CELLS_EVENT, onDerived);
+      }
     };
     // `topic` is a stable module constant per scope (topicForScope), so this cannot loop.
   }, [scope, topic]);

web/src/customer-grid/useGetCellContent.ts

@@ -28,6 +28,10 @@ const EMPTY_CELL: GridCell = {
   allowOverlay: false,
 };
 
+/** A module constant, so the default argument is referentially stable — a fresh `new Set()`
+ *  per render would change this hook's dep array every frame and repaint the canvas forever. */
+const EMPTY_KEYS: ReadonlySet<string> = new Set<string>();
+
 type GroupHeaderRow = Extract<VisibleRow, { kind: "group-header" }>;
 type GroupFooterRow = Extract<VisibleRow, { kind: "group-footer" }>;
 
@@ -79,6 +83,46 @@ function groupHeaderCell(
   };
 }
 
+/**
+ * ⭐ owner item 2 (2026-08-03) — THE CELL THAT IS STILL BEING CALCULATED.
+ *
+ * A measure column's values are resolved SERVER-side (one aggregate over the whole book) and
+ * arrive on the workspace re-read, seconds after the column itself appears. Until then the row
+ * simply has no value at that key — and `makeCell` renders no value as an EMPTY CELL, which is
+ * indistinguishable from the two things it must never be confused with: a real blank ("could
+ * not compute") and a genuine zero. The owner read a screen of them as an error, which is the
+ * correct reading of what was on screen.
+ *
+ * So a pending measure cell paints a SKELETON. `GridCellKind.Loading` is glide's own — a
+ * rounded bar at 10% of `theme.textDark` — and the two decisions here are:
+ *
+ *   · WIDTH VARIES per cell (`skeletonWidthVariability`, seeded by col/row inside glide), so a
+ *     column of them reads as text-shaped placeholders rather than as a painted grey block,
+ *     which is what a solid uniform bar looks like.
+ *   · IT PULSES, and the pulse is a WAVE: the phase is offset by the row, so the column ripples
+ *     instead of blinking in unison. Canvas cannot hold a CSS animation, so the motion is the
+ *     caller's repaint tick driving `themeOverride.textDark` through the ramp below — the same
+ *     mechanism `avatarTick` uses to land an async photo.
+ */
+const SKELETON_RAMP = ["#1b1b22", "#33333d", "#4d4d59", "#33333d"] as const;
+
+function loadingCell(width: number | undefined, row: number, pulse: number): GridCell {
+  const bar = Math.max(22, Math.round((width ?? 120) * 0.42));
+  return {
+    kind: GridCellKind.Loading,
+    allowOverlay: false,
+    skeletonWidth: bar,
+    // Bounded so a narrow column's bar cannot outgrow its cell.
+    skeletonWidthVariability: Math.min(20, Math.round(bar * 0.35)),
+    skeletonHeight: 10,
+    themeOverride: {
+      textDark: SKELETON_RAMP[(pulse + row) % SKELETON_RAMP.length],
+    },
+    // A skeleton is not data: copying one must yield nothing, not the word "loading".
+    copyData: "",
+  };
+}
+
 /**
  * The per-group subtotal row: each column shows ITS OWN summed value (from the
  * shared aggs map) right-aligned under the data, blank for non-agg columns. No
@@ -131,7 +175,19 @@ export function useGetCellContent(
    * no canvas, so nothing is fitted, which is the safe direction.
    */
   groupLabelSpace: number | null = null,
-  measureText?: (text: string) => number
+  measureText?: (text: string) => number,
+  /**
+   * owner item 2 — the measure columns whose values are STILL BEING CALCULATED server-side.
+   * A key in here whose cell has no value paints a skeleton instead of an empty cell. Empty by
+   * default, so every other caller of this hook is unaffected.
+   */
+  pendingKeys: ReadonlySet<string> = EMPTY_KEYS,
+  /**
+   * ⚠ THE SECOND REPAINT KEY, and it is read here (unlike `avatarTick`) — it selects the frame
+   * of the skeleton's pulse. CustomerGrid bumps it on a timer for as long as `pendingKeys` is
+   * non-empty and then stops, so a settled grid repaints on nothing.
+   */
+  pulse = 0
 ) {
   return useCallback(
     ([col, row]: Item): GridCell => {
@@ -151,6 +207,15 @@ export function useGetCellContent(
       const pid = (vr.record as Row).pid;
       // Overlay edits win over the raw record (edit shows immediately).
       const raw = overlayEdits[pid]?.[field.key] ?? vr.record[field.key];
+      // owner item 2 — still being calculated. Tested on the VALUE too, not on the column
+      // alone: the moment the server's answer lands the cell must show it, and a column-only
+      // test would keep skeletons over real numbers until the field echo caught up separately.
+      if ((raw == null || raw === "") && pendingKeys.has(field.key))
+        // `GridColumn` is a union and only its SIZED member declares `width` (the same narrowing
+        // `groupLabelSpace` does). `useGridColumns` only ever builds that one; an auto-sized
+        // column would read undefined and take the skeleton's default, which is the safe way to
+        // be wrong about a bar's width.
+        return loadingCell((colDef as { width?: number } | undefined)?.width, row, pulse);
       return makeCell(field, raw, canEdit(field), userAvatars);
     },
     // ⚠ `avatarTick` is a dependency that is deliberately never READ in the body. Bumping it is
@@ -159,6 +224,6 @@ export function useGetCellContent(
     // unnecessary; removing it would silently strand every photo behind its initials.
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [visibleRows, visibleCols, fieldByKey, overlayEdits, canEdit, userAvatars, avatarTick,
-     groupLabelSpace, measureText]
+     groupLabelSpace, measureText, pendingKeys, pulse]
   );
 }

web/src/customer-grid/viewModes.tsx

@@ -499,6 +499,40 @@ function monthTitle(month: string): string {
  *  be reconciled again just because the record modal opened. All five props are already
  *  stable at the call site (`rows` is the `modeDataRows` useMemo, `field` comes out of
  *  `dateFieldChoices`, `onOpen` is a setState), so this one needed no call-site change. */
+/** One summary metric as `summaryMetrics` builds it — named so the shared value function below
+ *  and the two call sites all speak the same shape. */
+type CalMetric = { id: string; label: string; field?: Field; agg: ChartAgg };
+
+/**
+ * ⭐ ONE IMPLEMENTATION OF A SUMMARY DAY'S NUMBER (owner item 3, 2026-08-03).
+ *
+ * The day CELL and the day EXPORT must not compute this twice. They did, for one commit, and
+ * the reason to refuse that is written a few lines below in R4's own note: the served channel
+ * and the client aggregation answer different questions (as-of-that-day vs the row values held
+ * now), and two copies of the choice between them is how a file and a screen come to disagree
+ * about the same day while both look right.
+ *
+ * `served` wins wherever it exists — a measure's answer is the server's. `undefined` (the field
+ * was dropped) and `null` (unanswered) are the same thing to a reader; both are null here and
+ * both draw "—". Never 0.
+ */
+function calDayValue(
+  m: CalMetric,
+  iso: string,
+  bucket: readonly { row: Row }[],
+  dayValues: Record<string, Record<string, number | null>>
+): number | null {
+  const served = m.field ? dayValues[m.field.key] : undefined;
+  if (served) return served[iso] ?? null;
+  const vals: number[] = [];
+  if (m.field)
+    for (const e of bucket) {
+      const n = asChartNumber(e.row[m.field.key]);
+      if (n != null) vals.push(n);
+    }
+  return aggregateOrNull(m.agg, vals, bucket.length);
+}
+
 export const CalendarView = memo(function CalendarView({
   rows,
   field,
@@ -509,6 +543,7 @@ export const CalendarView = memo(function CalendarView({
   fieldByKey,
   scope = "customer",
   onOpen,
+  onSheet,
 }: {
   /** DISTINCT data rows from the full pipeline (never the display slice — a
    *  month is its own bound). */
@@ -526,6 +561,16 @@ export const CalendarView = memo(function CalendarView({
    *  REFUSES `product` in words (measures are customer-grain), so this is never free text. */
   scope?: SurfaceScope;
   onOpen: (pid: number) => void;
+  /**
+   * ⭐ owner item 3 (2026-08-03) — the SUMMARY month as an exportable rectangle, published so
+   * the view menu's Export can carry what this view actually shows.
+   *
+   * ⚠ `null` IS THE MESSAGE, not the absence of one. In RECORDS mode a calendar is an
+   * arrangement of rows — the rows ARE its content, so the caller must fall back to the ordinary
+   * row export. Publishing null says "there is no sheet here", which is different from having
+   * never published, and the caller distinguishes the two.
+   */
+  onSheet?: (sheet: { fields: Field[]; rows: Row[] } | null) => void;
 }) {
   const entries = useMemo(
     () =>
@@ -644,6 +689,52 @@ export const CalendarView = memo(function CalendarView({
     });
   }, [mode, measureMetricKeys, byDay, scope]);
 
+  /**
+   * ⭐ owner item 3 (2026-08-03) — THE SUMMARY MONTH, PUBLISHED FOR EXPORT.
+   *
+   * The owner named Calendar by hand ("Export CSV / PDF based on what view (Grid/Calendar)"),
+   * and a calendar in SUMMARY mode has the same shape problem the time-series view had: what it
+   * shows is metric values per DAY, and the rows underneath share none of those numbers. So the
+   * month goes up as a rectangle — one row per dated day, one column per metric — and the view
+   * menu's Export carries it.
+   *
+   * ⚠ RECORDS mode publishes `null`, on purpose. There a calendar is an ARRANGEMENT of rows and
+   * the rows are its content, so the ordinary row export is already the right file.
+   *
+   * ⚠ THE VALUES ARE THE DISPLAY STRINGS, through `formatDisplay` — the same rule the
+   * time-series export follows, and for the same reason: a column here mixes a count with a
+   * currency, so there is no one numeric type for it and the cell's own text is the honest answer.
+   * `—` on screen is an EMPTY cell in the file: a spreadsheet's blank is its "no value", and an
+   * em dash in a numeric column is a string somebody has to strip.
+   */
+  useEffect(() => {
+    if (!onSheet) return;
+    if (mode !== "summary" || !shown) {
+      onSheet(null);
+      return;
+    }
+    const col = (key: string, label: string): Field =>
+      ({ key, label, type: "text", source: "odoo" });
+    const fields: Field[] = [
+      col("day", "Day"),
+      ...summaryMetrics.map((m) => col(`m_${m.id}`, m.label)),
+    ];
+    const out: Row[] = [];
+    for (const iso of [...byDay.keys()].sort()) {
+      const bucket = byDay.get(iso) ?? [];
+      // `pid` is positional here and means nothing — a calendar day is not a record. It exists
+      // because `Row` requires it and `buildJson` emits it.
+      const row: Row = { pid: out.length + 1, day: iso };
+      for (const m of summaryMetrics) {
+        const v = calDayValue(m, iso, bucket, dayValues);
+        row[`m_${m.id}`] =
+          v == null ? "" : m.field ? formatDisplay(m.field, v) : v.toLocaleString();
+      }
+      out.push(row);
+    }
+    onSheet({ fields, rows: out });
+  }, [onSheet, mode, shown, byDay, summaryMetrics, dayValues]);
+
   if (!shown) {
     return (
       <div className="cg-mode-empty">
@@ -739,22 +830,9 @@ export const CalendarView = memo(function CalendarView({
                   summaryMetrics.map((m) => {
                     // wave17 item 9 / R4 — a measure reads its AS-OF-THAT-DAY answer from the
                     // channel; everything else keeps the client aggregation, which is still
-                    // exactly right for a column with no window.
-                    const served = m.field ? dayValues[m.field.key] : undefined;
-                    let v: number | null;
-                    if (served) {
-                      // `undefined` (the field was dropped) and `null` (unanswered) are the same
-                      // thing to a reader and both draw "—". Neither is 0.
-                      v = served[iso] ?? null;
-                    } else {
-                      const vals: number[] = [];
-                      if (m.field)
-                        for (const e of bucket) {
-                          const n = asChartNumber(e.row[m.field.key]);
-                          if (n != null) vals.push(n);
-                        }
-                      v = aggregateOrNull(m.agg, vals, bucket.length);
-                    }
+                    // exactly right for a column with no window. Both live in `calDayValue`,
+                    // which the EXPORT calls too — see its note.
+                    const v = calDayValue(m, iso, bucket, dayValues);
                     return (
                       <div key={m.id} className="cg-cal-metric">
                         {/* wave17 item 9 — the field's TYPE mark, so a row of figures in a

web/src/index.css

@@ -1121,6 +1121,15 @@ body {
   background: transparent;
   color: var(--lp-ink);
   font: inherit;
+  /* ⛔ THE SIZE IS DECLARED, NOT INHERITED (owner, 2026-08-03 — "the font is un-uniform … fix
+     it always"). `font: inherit` alone was correct only by luck: it took its size from
+     `.cg-toolbar`, which happens to declare `--lp-fs-xs`. Mount the SAME button anywhere with
+     no size on the ancestor — which is exactly what the time-series bar is — and it silently
+     grew to the body's 14px beside 12px siblings, so the "Compare" button read as a heading.
+     A shared component cannot depend on where it is hung. The longhand sits AFTER the shorthand
+     on purpose: `font: inherit` still supplies the family and weight, this overrides only the
+     size. Identical inside `.cg-toolbar` (same token), fixed everywhere else. */
+  font-size: var(--lp-fs-xs);
   line-height: 1;
   cursor: pointer;
   white-space: nowrap;
@@ -5678,12 +5687,19 @@ a.cg-map-ctl-b { text-decoration: none; }
 /* formula rows, a sparkline column and an optional gridline grain.            */
 /* ------------------------------------------------------------------------- */
 
+/* ⛔ THE PANEL DECLARES ITS OWN BASE SIZE (owner, 2026-08-03).
+   Everything inside `.cg-ts-table` was uniform because the TABLE declares `--lp-fs-xs`; every
+   control OUTSIDE it — the bar, the notes, the empty states — inherited the app body instead
+   and landed a step larger than the sheet it sits above. That is the un-uniformity the owner
+   saw. One declaration here makes the panel's floor the same as the toolbar's, so a control
+   with no size of its own is right by default rather than by accident of where it hangs. */
 .cg-ts {
   display: flex;
   flex-direction: column;
   min-height: 0;
   padding: 12px 14px 18px;
   gap: 10px;
+  font-size: var(--lp-fs-xs);
 }
 .cg-ts-bar {
   display: flex;
@@ -5723,12 +5739,55 @@ a.cg-map-ctl-b { text-decoration: none; }
    no way to tell a deliberate refusal from a bug. Quiet by design — struck-through muted text,
    not a warning colour: nothing here is wrong, these columns simply have no time dimension. The
    reason rides the `title`. */
+/* ⛔ AND IT IS SHUT BY DEFAULT (owner, 2026-08-03 — "seemingly broken HTML text").
+   The strip above shipped as ~25 struck-through names in a row with no heading, which is not
+   how a disclosure reads: it reads as a stylesheet that failed. The `<details>` keeps every
+   name — R9 is not weakened — behind one sentence that says what they are. */
 .cg-ts-refused {
-  display: flex;
+  padding: 2px 2px 0;
+}
+.cg-ts-refsum {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  width: fit-content;
+  padding: 1px 2px;
+  font-size: var(--lp-fs-2xs);
+  color: var(--lp-muted);
+  cursor: pointer;
+  list-style: none;          /* Safari/Chrome default triangle, replaced below */
+  user-select: none;
+}
+.cg-ts-refsum::-webkit-details-marker { display: none; }
+/* The disclosure caret, drawn rather than borrowed: a `▸` glyph renders at a different size in
+   every font on the three platforms this runs on, and this one has to line up with 12px text. */
+.cg-ts-refsum::before {
+  content: "";
+  width: 0;
+  height: 0;
+  border-left: 4px solid currentColor;
+  border-top: 3.5px solid transparent;
+  border-bottom: 3.5px solid transparent;
+  transition: transform 0.12s ease;
+}
+.cg-ts-refused[open] > .cg-ts-refsum::before { transform: rotate(90deg); }
+.cg-ts-refsum:hover { color: var(--lp-ink); }
+.cg-ts-refsum:focus-visible { outline: 2px solid var(--lp-blue-deep); outline-offset: 1px; }
+/* ⛔ THE CLOSED STATE IS DECLARED, NOT INHERITED FROM THE BROWSER — and this cost a real bug.
+   `<details>` hides its non-summary children through a UA rule (`display: none`, or a
+   `::details-content` content-visibility in newer Chrome). ANY author `display` beats a UA
+   declaration regardless of specificity, so writing `display: flex` here re-showed the list
+   while the disclosure was shut: the same wall of struck-through names the owner reported, now
+   with a heading above it claiming to hide them. Caught by the screenshot gate, not by the
+   markup — which is the whole reason item 7 said "pls visually check".
+   Stating both states explicitly also makes this independent of which engine is rendering. */
+.cg-ts-reflist {
+  display: none;
   flex-wrap: wrap;
   gap: 4px 8px;
-  padding: 6px 2px 2px;
+  padding: 6px 0 2px 11px;
 }
+.cg-ts-refused[open] > .cg-ts-reflist { display: flex; }
 .cg-ts-refchip {
   font-size: var(--lp-fs-3xs);
   color: var(--lp-muted);
@@ -6078,15 +6137,15 @@ a.cg-map-ctl-b { text-decoration: none; }
 /* the Filter-popover banner (.cg-flt-lockchip, in their filters.css).         */
 /* ------------------------------------------------------------------------- */
 
-/* The rail mark. Yellow, matching `.cg-lock-tag` and RECORD's banner, because all three make
-   the same claim about the same kind of thing and a third colour would read as a third
-   concept. A 2px inset bar rather than a badge: the row is already carrying a mode icon, a
-   name, a note and a "…" — one more chip would crowd it, while an edge mark is legible at a
-   glance and costs no width. Per the brand rule the mark takes the -deep weight; the base
-   pastel measures too low to read as a line this thin. */
-.cg-view-row.cg-view-lockset {
-  box-shadow: inset 2px 0 0 var(--lp-yellow-deep);
-}
+/* ⛔ THE RAIL MARK IS THE PADLOCK, AND ONLY THE PADLOCK (owner, 2026-08-03).
+   This rule used to also paint a 2px yellow inset bar down the row's left edge. The reasoning
+   was that an edge mark costs no width on a crowded row — but it was written when a locked view
+   was a projected row under its own heading. Wave 17 made it an ORDINARY view in the same list,
+   and an edge bar in a flat list reads as a selection state or a drag handle, not as "these
+   rows are fixed". Two marks for one fact, and the ugly one was the one carrying no meaning.
+   The padlock stays: it is named (`aria-label`), it explains itself (`title`), and it is the
+   same glyph the toolbar chip uses. The class is KEPT — `cg-view-lockset` is still how the row
+   is found in QA and it may earn quieter styling later; it simply paints nothing today. */
 /* The picker. `is-on` marks the cohort currently locked, so re-opening the menu says which one
    it is instead of making the reader remember. */
 .cg-lock-pop { min-width: 240px; }