@@ -1,11 +1,13 @@
 ---
 '@object-ui/app-shell': patch
+'@object-ui/i18n': patch
 ---
 
-fix(studio): a formula that does not parse keeps the field's stored result type, and a switch to another object asks before it drops the held edit (#27485)
+fix(studio): closing the field inspector keeps a formula that does not parse unsaved, with the field's stored result type, and a switch to another object asks before it drops it (#27485)
 
 Clause-②: no
 Metadata-protocol: none
 
+- The Data pillar holds a field's draft while its CEL formula or condition does not parse. That hold used to end the moment the field inspector closed (Escape, Close, another field card, another tab), and the autosave then sent the broken expression as the object's draft, which publish refuses. The hold now belongs to the draft: it lasts while the draft still carries the text the inspector judged, and ends when that text is edited, the field is removed or the object reloads. While it lasts, the pillar shows the held line ("Not saved yet: an expression on the field “F Total” has an error to fix…") with a **Show me** that reopens the field, and the Studio's Publish names it.
 - Typing a formula that does not parse (`record.est_hours > (`) cleared the field's stored `returnType`, because a broken source proves no type. The stored type now stays while the formula has a lint error; a formula that parses stamps its proven type, or clears it when none is proven, as before.
 - With such an edit held, switching to another object in the Data pillar's rail dropped it silently. The switch now asks first; declining keeps the object and the edit.
@@ -15,12 +15,15 @@
  *
  *  - the count actually reaches the button and disables it, with the same
  *    message the RLS editor already shows;
- *  - the host RESETS its own count when the selection changes or the inspector
- *    unmounts (ruling sub-decision A) — writability must never depend on a
- *    child's teardown running, or closing the panel on a faulty formula leaves
- *    Save wedged shut with no editor on screen to fix it;
- *  - objectstack#27485, the switch arm: a switch to another object over a
- *    held formula asks before it drops the edit.
+ *  - objectstack#27485 — the verdict belongs to the DRAFT, not to the
+ *    selection: closing the inspector (Close, Escape, another field, another
+ *    tab) keeps the hold while the draft still carries the text it judged, and
+ *    a switch to another object asks before it drops the held edit. The
+ *    objectui#4306 ruling's sub-decision A stands as its two invariants:
+ *    writability never depends on a child's teardown running (the kept verdict
+ *    is read off the draft, and an edit, the field's removal or a load ends
+ *    it), and Save is never wedged with nothing on screen to fix (the held line
+ *    names the field, and its "Show me" reopens the editor).
  *
  * The engine is stubbed so the verdict is deterministic; the live lint is
  * CelPredicateField.test.tsx's job.
@@ -188,25 +191,6 @@ describe('DataPillar — auto-save is gated on the field inspector’s CEL verdi
     fireEvent.change(box, { target: { value: 'record.est_hours * 2' } });
     await waitFor(() => expect(mockClient.save).toHaveBeenCalled(), { timeout: 4000 });
   });
-
-  /**
-   * Sub-decision A. Closing the panel unmounts the inspector, so nothing will
-   * ever report `0` for it — the host must drop the count on its own, or the
-   * dirty draft stays wedged UNSAVED forever with no editor on screen to fix.
-   */
-  it('drops the count when the inspector closes, so the draft cannot wedge unsaved', async () => {
-    const box = await openFormulaField();
-
-    fireEvent.change(box, { target: { value: 'record.est_hours *' } });
-    await new Promise((r) => setTimeout(r, 2300));
-    expect(mockClient.save).not.toHaveBeenCalled();
-
-    // Two "Close" buttons dismiss the panel — the rail header's and the
-    // inspector shell's own; either clears the selection (and the block).
-    fireEvent.click(screen.getAllByRole('button', { name: 'Close' })[0]);
-    await waitFor(() => expect(screen.queryByText('Formula (CEL)')).toBeNull(), { timeout: 3000 });
-    await waitFor(() => expect(mockClient.save).toHaveBeenCalled(), { timeout: 4000 });
-  });
 });
 
 /**
@@ -232,3 +216,49 @@ describe('DataPillar — a switch to another object over a held formula (objects
     expect(mockClient.save).not.toHaveBeenCalled();
   });
 });
+
+/** The ways the field inspector closes (the card's step 4). */
+const CLOSERS: Array<[string, () => void]> = [
+  ['its Close button', () => fireEvent.click(screen.getAllByRole('button', { name: 'Close' })[0])],
+  ['Escape', () => fireEvent.keyDown(document.body, { key: 'Escape' })],
+  ['another field card', () => fireEvent.click((screen.getByText('Est hours').closest('.cursor-grab') as HTMLElement))],
+  ['the Records tab', () => fireEvent.click(screen.getByRole('button', { name: 'Records' }))],
+];
+
+describe('DataPillar — the CEL hold belongs to the draft, not to the open inspector (objectstack#27485)', () => {
+  async function breakFormula(): Promise<HTMLTextAreaElement> {
+    const box = await openFormulaField();
+    fireEvent.change(box, { target: { value: 'record.est_hours *' } });
+    await waitFor(() => expect(screen.getByTestId('studio-held-message')).toHaveTextContent('Total'), { timeout: 3000 });
+    return box;
+  }
+
+  it.each(CLOSERS)('closing the inspector by %s keeps the hold, and the held line names the field', async (_how, close) => {
+    await breakFormula();
+    close();
+    await new Promise((r) => setTimeout(r, 2300));
+    expect(mockClient.save).not.toHaveBeenCalled();
+    expect(screen.getByTestId('studio-held-message')).toHaveTextContent('Total');
+  });
+
+  it('"Show me" reopens the field, and fixing it there releases the hold', async () => {
+    await breakFormula();
+    fireEvent.click(screen.getAllByRole('button', { name: 'Close' })[0]);
+    await waitFor(() => expect(screen.queryByText('Formula (CEL)')).toBeNull(), { timeout: 3000 });
+    fireEvent.click(screen.getByRole('button', { name: 'Show me' }));
+    const label = await screen.findByText('Formula (CEL)');
+    const box = label.parentElement!.querySelector('[role="combobox"]') as HTMLTextAreaElement;
+    expect(box.value).toBe('record.est_hours *');
+    fireEvent.change(box, { target: { value: 'record.est_hours * 2' } });
+    await waitFor(() => expect(mockClient.save).toHaveBeenCalled(), { timeout: 4000 });
+    expect(screen.queryByTestId('studio-held')).toBeNull();
+  });
+
+  it('removing the field ends the hold: nothing judged is left in the draft', async () => {
+    await breakFormula();
+    fireEvent.click(screen.getByRole('button', { name: 'Remove “Total”' }));
+    await waitFor(() => expect(mockClient.save).toHaveBeenCalled(), { timeout: 4000 });
+    const body = (mockClient.save.mock.calls.at(-1) as unknown[] | undefined)?.[2] as { fields: Array<{ name: string }> };
+    expect(body.fields.map((f) => f.name)).toEqual(['est_hours']);
+  });
+});
@@ -6279,6 +6279,21 @@ function formFieldNames(fields: unknown): string[] {
     .filter((n) => !STUDIO_SYSTEM_FIELD_NAMES.has(n));
 }
 
+/**
+ * objectstack#27485 — what the field inspector's CEL verdict on `field` was
+ * judged from, as the object draft holds it: the field's type, its CEL texts
+ * (`expression`, the legacy `formula`, `visibleWhen`, `readonlyWhen`,
+ * `requiredWhen`) and the object's field names its lint resolves references
+ * against. The same stamp is the same verdict. `null` when the field is gone.
+ */
+function fieldCelStamp(draft: Record<string, unknown>, field: string): string | null {
+  const { entries } = readFields(draft.fields);
+  const def = entries.find((e) => e.name === field)?.def;
+  if (!def) return null;
+  const cel = [def.type, def.expression, def.formula, def.visibleWhen, def.readonlyWhen, def.requiredWhen];
+  return JSON.stringify([cel.map((v) => v ?? null), entries.map((e) => e.name)]);
+}
+
 /** The data-source writes the Form tab's Preview refuses (objectui#12515). */
 const PREVIEW_REFUSED_WRITES = new Set<PropertyKey>(['create', 'update', 'delete', 'bulk', 'bulkUpdate', 'bulkDelete']);
 
@@ -6415,13 +6430,54 @@ export function DataPillar({
   // that does not parse must not be saveable, let alone publishable as the live
   // field definition (objectui#4306).
   //
-  // The count is STAMPED with the selection it came from, so it expires by
-  // construction when the selection changes or the panel closes: an unmounted
-  // inspector can never retract its last verdict, and a host that waited for
-  // one would leave Save wedged shut with nothing on screen to fix.
+  // The report is STAMPED with the selection it came from: it is the open
+  // inspector's live verdict, and never reads as another selection's.
   const [blockingReport, setBlockingReport] = React.useState({ key: '', count: 0 });
   const fieldSelKey = fieldSel ? `${current?.name ?? ''}:${fieldSel.kind}:${fieldSel.id}` : '';
-  const inspectorBlocking = blockingReport.key === fieldSelKey ? blockingReport.count : 0;
+  // objectstack#27485 — the verdict belongs to the draft, not to the selection.
+  // Expiring it with the selection released the hold the moment the inspector
+  // closed (Escape, Close, another field, another tab) while the broken text
+  // stayed in the draft, and the autosave sent it. So each field's last live
+  // verdict is kept with the stamp of what it judged (`fieldCelStamp`, taken
+  // while the inspector is open on it) and holds, with the inspector closed,
+  // while the draft still carries that stamp: an edit to the text, the field's
+  // removal or the object's next load ends it. Nothing is left shut with
+  // nothing to fix: the held line names the field and its "Show me" opens it,
+  // and the open inspector's live verdict always wins.
+  const [celVerdicts, setCelVerdicts] = React.useState<Record<string, { field: string; count: number; stamp: string | null }>>({});
+  const liveFieldReport = fieldSel?.kind === 'field' && blockingReport.key === fieldSelKey;
+  const openFieldStamp = fieldSel?.kind === 'field' ? fieldCelStamp(objDraft, fieldSel.id) : null;
+  React.useEffect(() => {
+    if (!liveFieldReport || fieldSel === null) return;
+    const kept = { field: fieldSel.id, count: blockingReport.count, stamp: openFieldStamp };
+    setCelVerdicts((prev) => {
+      const was = prev[fieldSelKey];
+      if (was && was.count === kept.count && was.stamp === kept.stamp) return prev;
+      return { ...prev, [fieldSelKey]: kept };
+    });
+  }, [liveFieldReport, fieldSel, fieldSelKey, blockingReport.count, openFieldStamp]);
+  // The open object's fields whose verdict holds, and their summed count.
+  const celHeldFields: string[] = [];
+  let inspectorBlocking = 0;
+  const celFieldPrefix = `${current?.name ?? ''}:field:`;
+  for (const [key, kept] of Object.entries(celVerdicts)) {
+    if (!key.startsWith(celFieldPrefix) || key === fieldSelKey) continue;
+    if (kept.count > 0 && kept.stamp === fieldCelStamp(objDraft, kept.field)) {
+      celHeldFields.push(kept.field);
+      inspectorBlocking += kept.count;
+    }
+  }
+  if (blockingReport.key === fieldSelKey && blockingReport.count > 0) {
+    if (fieldSel?.kind === 'field') celHeldFields.push(fieldSel.id);
+    inspectorBlocking += blockingReport.count;
+  } else if (fieldSelKey !== '' && !liveFieldReport) {
+    // Opened, and its inspector has not reported yet: its kept verdict stands.
+    const kept = celVerdicts[fieldSelKey];
+    if (kept && kept.count > 0 && kept.stamp === openFieldStamp) {
+      celHeldFields.push(kept.field);
+      inspectorBlocking += kept.count;
+    }
+  }
   // The pillar's PANEL family reports separately (objectui#4527): the
   // validations, actions and settings panels all write through this same draft
   // and own no Save of their own, so their CEL faults have to reach this
@@ -6691,6 +6747,8 @@ export function DataPillar({
     setLoading(true);
     setError(null);
     setFieldSel(null);
+    // objectstack#27485 — kept CEL verdicts judged the buffer this load replaces.
+    setCelVerdicts({});
     setDirty(false);
     (async () => {
       try {
@@ -6967,8 +7025,27 @@ export function DataPillar({
     snapshot: objDraft,
     save: doSave,
   });
+  // objectstack#27485 — an unsent edit the CEL verdict holds is named like an
+  // incomplete one: the held line, the surface's Publish and the rail's
+  // question all read it, so it outlives the inspector without going unseen.
+  const celHeldField = celHeldFields[0] ?? null;
+  const celHeldLabel = React.useMemo(() => {
+    if (celHeldField === null) return null;
+    const label = readFields(objDraft.fields).entries.find((e) => e.name === celHeldField)?.def.label;
+    return typeof label === 'string' && label.trim() !== '' ? label.trim() : celHeldField;
+  }, [celHeldField, objDraft.fields]);
+  const objCelHeld = React.useMemo<StudioHeld | null>(
+    () =>
+      dirty && celHeldField !== null && celHeldLabel !== null
+        ? {
+            clause: tFormat('engine.studio.held.celInvalid', locale, { field: celHeldLabel }),
+            target: { kind: 'field', id: celHeldField },
+          }
+        : null,
+    [dirty, celHeldField, celHeldLabel, locale],
+  );
   // Only the open object's own buffer is held (objectui#11272).
-  const objHeld = objLoaded ? objIncomplete : null;
+  const objHeld = objLoaded ? (objIncomplete ?? objCelHeld) : null;
   // objectstack#26917 — the refusal's way out: the object holding the
   // identifier is on this rail, so it opens instead of a second one being
   // made. The New button already asked about a held edit (objectstack#26845).
 
@@ -2999,6 +2999,8 @@ const STUDIO_EN: Record<string, string> = {
   // objectui#11910 — a dashboard widget held until it is bound; `input` is the
   // widget inspector's own label for it (Dataset, Values (measures)).
   'engine.studio.held.widgetNeedsInput': '{input} on the widget “{widget}” needs a value',
+  // objectstack#27485 — a field CEL expression the inspector judged broken, held after it closes.
+  'engine.studio.held.celInvalid': 'an expression on the field “{field}” has an error to fix',
   'engine.studio.held.line': 'Not saved yet: {clause}. Your changes are kept here and saved once it is filled in.',
   'engine.studio.held.publish': 'Not published: {clause}, so that change is not saved yet. Finish it, then publish.',
   'engine.studio.held.inputHint': 'Required. Changes are saved once this has a value.',
 
@@ -2668,6 +2668,7 @@ const STUDIO_ZH: Record<string, string> = {
   'engine.studio.held.needsRuleField': '规则「{rule}」需要选择一个字段',
   'engine.studio.held.needsRuleMessage': '规则「{rule}」需要一条错误消息',
   'engine.studio.held.widgetNeedsInput': '组件「{widget}」的「{input}」需要填写',
+  'engine.studio.held.celInvalid': '字段「{field}」的表达式有错误需要修正',
   'engine.studio.held.line': '尚未保存：{clause}。更改已保留在此处，补全后会自动保存。',
   'engine.studio.held.publish': '未发布：{clause}，该更改尚未保存。请先补全，再发布。',
   'engine.studio.held.inputHint': '必填。填写后才会保存更改。',