Deploy AIOS web (React glide grid + FastAPI slice)

RELEASES.json

@@ -1,6 +1,12 @@
 {
- "current": "v36 (51db3b7)",
+ "current": "v37 (1ddd8cf)",
  "releases": [
+  {
+   "version": "v37",
+   "sha": "1ddd8cf",
+   "date": "2026-08-21",
+   "subject": "W39: coalesce derived workspace reads"
+  },
   {
    "version": "v36",
    "sha": "51db3b7",

VERSION

@@ -1 +1 @@
-v36 (51db3b7)
+v37 (1ddd8cf)

api/automation_engine.py

@@ -12626,11 +12626,13 @@ def _table_handle(row, url_field):
                or "").strip().lower()
 
 
-def compute_metric_cells(rt, table_key, today=None):
+def compute_metric_cells(rt, table_key, today=None, tables=None, persist=False):
     """Recompute every metric cell on ONE table from the master series. One coalesced write,
     only when something actually changed (the flush-ceiling law); zero reads when the table
     has no metric fields or the master is off. Returns the number of rows touched."""
-    t = ut_get(rt, table_key)
+    owned = tables is not None
+    blob = tables if owned else None
+    t = ((blob or {}).get(str(table_key)) if owned else ut_get(rt, table_key))
     mfields = metric_fields_of_table(t)
     if not mfields:
         return 0
@@ -12664,6 +12666,11 @@ def compute_metric_cells(rt, table_key, today=None):
                 tt.setdefault("rows", {}).setdefault(rid, {}).update(vals)
         return cur
 
+    if owned:
+        _up(blob)
+        if persist:
+            rt.update(UT_STORE_KEY, _up, flush="sync")
+        return len(changes)
     rt.update(UT_STORE_KEY, _up, flush="sync")
     return len(changes)
 
@@ -13204,13 +13211,30 @@ def _refresh_relations_inplace(tables, log=print):
     return touched
 
 
-def refresh_relations(rt, log=print):
+def refresh_relations(rt, log=print, tables=None, persist=True):
     """The tick half of the relational pass — the twin of `refresh_metrics`.
 
     ⚠ Runs for EVERY table, because a link can point anywhere: a rollup on table A goes stale
     when table B gains a row, and A has no way to know that happened. Cheap by construction — a
     table declaring neither kind costs one dict scan.
     """
+    if tables is not None:
+        # The scheduler owns this mutable snapshot for one derived pass.  Compute locally first
+        # so an unchanged relation does not pay a second full-document read; a changed relation is
+        # still reapplied against current locked state below.
+        local = _refresh_relations_inplace(tables, log=log)
+        if not local or not persist:
+            return local
+        actual = [0]
+
+        def _up(cur):
+            cur = cur if isinstance(cur, dict) else {}
+            actual[0] = _refresh_relations_inplace(cur, log=log)
+            return cur
+
+        rt.update(UT_STORE_KEY, _up, flush="async")
+        return actual[0]
+
     snapshot = {
         str(key): {**(table or {}),
                    "rows": {str(rid): dict(row or {})
@@ -13244,15 +13268,17 @@ def refresh_relations(rt, log=print):
     return actual[0]
 
 
-def refresh_metrics(rt, today=None, log=print):
+def refresh_metrics(rt, today=None, log=print, tables=None, persist=True):
     """The tick half of the C7 amendment: `today` advances at tick cadence, so a date-window
     metric can never go staler than one tick while a scheduler exists. Cheap by construction —
     a table without metric fields costs a dict scan and nothing else."""
+    snapshot = tables if tables is not None else ut_all(rt)
     touched = 0
-    for tk, t in ut_all(rt).items():
+    for tk, t in snapshot.items():
         if metric_fields_of_table(t):
             try:
-                touched += compute_metric_cells(rt, tk, today=today)
+                touched += compute_metric_cells(rt, tk, today=today, tables=snapshot,
+                                                persist=persist)
             except Exception as e:                                # noqa: BLE001
                 log(f"[aios-auto] metric refresh {tk} failed: {type(e).__name__}: {e}")
     return touched
@@ -14531,25 +14557,37 @@ def tick(rt, tenant, now=None, log=print):
             # C7's amendment: date-window metrics advance with the tick, so `today` is never staler
             # than one tick while a scheduler exists. A tenant without metric fields pays a dict scan.
             try:
-                refresh_metrics(rt, log=log)
+                # One full workspace snapshot is the budget for this whole derived pass.  The
+                # individual workers mutate only that local snapshot while they decide whether a
+                # value changed, then use their established guarded RMW only when it did.  A read
+                # failure is not converted into an empty snapshot or a success memo.
+                derived_tables = dict(rt.get(UT_STORE_KEY) or {})
             except Exception as e:                                # noqa: BLE001
                 _derived_ok = False
-                log(f"[aios-auto] metric refresh {tenant} failed: {type(e).__name__}: {e}")
-            # ⭐ 2026-08-07 — the relational pass, on the same tick and for the same reason. A rollup
-            # on table A goes stale when table B gains a row, and A cannot know that happened; the
-            # tick is the only place that sees both. Separate failure handling is retained.
-            try:
-                refresh_relations(rt, log=log)
-            except Exception as e:                                # noqa: BLE001
-                _derived_ok = False
-                log(f"[aios-auto] relation refresh {tenant} failed: {type(e).__name__}: {e}")
-            # Source-backed rollups move with Odoo and with their own date windows, so they share the
-            # same durable-revision/day gate but retain their independent failure posture.
-            try:
-                _refresh_source_rollups(rt, tenant, log=log)
-            except Exception as e:                                # noqa: BLE001
-                _derived_ok = False
-                log(f"[aios-auto] source rollup {tenant} failed: {type(e).__name__}: {e}")
+                derived_tables = None
+                log(f"[aios-auto] derived workspace snapshot {tenant} failed: "
+                    f"{type(e).__name__}: {e}")
+            if derived_tables is not None:
+                try:
+                    refresh_metrics(rt, log=log, tables=derived_tables)
+                except Exception as e:                            # noqa: BLE001
+                    _derived_ok = False
+                    log(f"[aios-auto] metric refresh {tenant} failed: {type(e).__name__}: {e}")
+                # ⭐ 2026-08-07 — the relational pass, on the same tick and for the same reason. A rollup
+                # on table A goes stale when table B gains a row, and A cannot know that happened; the
+                # tick is the only place that sees both. Separate failure handling is retained.
+                try:
+                    refresh_relations(rt, log=log, tables=derived_tables)
+                except Exception as e:                            # noqa: BLE001
+                    _derived_ok = False
+                    log(f"[aios-auto] relation refresh {tenant} failed: {type(e).__name__}: {e}")
+                # Source-backed rollups move with Odoo and with their own date windows, so they share the
+                # same durable-revision/day gate but retain their independent failure posture.
+                try:
+                    _refresh_source_rollups(rt, tenant, log=log, tables=derived_tables)
+                except Exception as e:                            # noqa: BLE001
+                    _derived_ok = False
+                    log(f"[aios-auto] source rollup {tenant} failed: {type(e).__name__}: {e}")
             if _derived_ok and _derived_marker is not None:
                 _DERIVED_TICK_STATE[str(tenant)] = _derived_marker
     if started:
@@ -14603,7 +14641,7 @@ def _derived_refresh_due(rt, tenant, now=None, state=None, backend=None):
     return memo.get(str(tenant)) != marker, marker
 
 
-def _refresh_source_rollups(rt, tenant, log=print):
+def _refresh_source_rollups(rt, tenant, log=print, tables=None):
     """Refresh every source-backed rollup; callers provide the no-op policy.
 
     The existing per-pass error boundary lives in :func:`tick`. Keeping this helper focused on
@@ -14611,10 +14649,11 @@ def _refresh_source_rollups(rt, tenant, log=print):
     schedule, vendor call, or a hidden duplicate of the loop.
     """
     import rollup_sql
-    for _tk in list((rt.get(UT_STORE_KEY) or {})):
-        if rollup_sql.source_fields((rt.get(UT_STORE_KEY) or {}).get(_tk) or {}):
+    snapshot = tables if tables is not None else (rt.get(UT_STORE_KEY) or {})
+    for _tk, _table in list(snapshot.items()):
+        if rollup_sql.source_fields(_table or {}):
             # `today` is DEFAULTED INSIDE `compute`, matching `refresh_metrics` above.
-            n = rollup_sql.compute(rt, _tk)
+            n = rollup_sql.compute(rt, _tk, tables=snapshot, persist=True)
             if n:
                 log(f"[aios-auto] source rollups {tenant}/{_tk}: {n}")
 

api/rollup_sql.py

@@ -125,7 +125,7 @@ def _today():
     return _dt.date.today().strftime("%Y-%m-%d")
 
 
-def compute(rt, table_key, today=None, tables=None):
+def compute(rt, table_key, today=None, tables=None, persist=False):
     """Write changed source-backed rollup cells on `table_key`.
 
     Returns ``{field_key: cells_changed}``. A store-backed call first applies the already-resolved
@@ -137,7 +137,10 @@ def compute(rt, table_key, today=None, tables=None):
 
     `tables` (a live `user_tables` dict) is the gate's injection point — the same shape
     `automation_engine.compute_relation_cells` takes, so this can be proven against a fixture
-    without a store.
+    without a store.  A scheduler that already paid for one full snapshot passes ``persist=True``:
+    the preflight then reuses that snapshot, while a changed result still takes the ordinary locked
+    update against fresh store state.  That saves the otherwise N+1 document reads without ever
+    replacing a concurrent human edit with the stale snapshot.
     """
     ut = _ut()
     owned = tables is not None
@@ -183,6 +186,14 @@ def compute(rt, table_key, today=None, tables=None):
 
     if owned:
         _apply(blob)
+        changed = {k: n for k, n in written.items() if n}
+        if not changed or not persist:
+            return changed
+        # The caller's snapshot remains useful to its sibling derived passes, but it is never
+        # uploaded wholesale.  Reapply the already-resolved plan inside the normal FOR UPDATE
+        # transaction, exactly as the ordinary path below does.
+        written.clear()
+        rt.update(ut.STORE_KEY, _apply, flush="async")
         return {k: n for k, n in written.items() if n}
 
     # A snapshot preflight costs one full read only on a due source-rollup pass. It avoids the far