From 9bf00811f52eda190b4eddbdd6e62d7d3e6e5953 Mon Sep 17 00:00:00 2001
From: JP <jp@JPs-Pursuit-MacBook-Air.local>
Date: Wed, 22 Apr 2026 15:31:37 -0400
Subject: [PATCH 01/11] feat(progress): split Pipeline Flow into Active funnel
 + Closed section (A5)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Context
-------
Mega-B / A5. Bedrock 1.0 Progress page called for Lost / Withdrawn / Did
Not Fulfill to be visible alongside the active funnel. JP also moved
'Collecting / In Effect' out of the active funnel into the new Closed
section (def: "closed, contract in effect, payments in progress").

Changes
-------
- pipelineFunnelTransitions.ts
  * ACTIVE_FUNNEL_STAGES now re-exports OPEN_STAGES from types/salesforce
    (7 stages, no Collecting). Single source of truth.
  * New CLOSED_FUNNEL_STAGES constant with 5 SF-canonical terminal stages
    in display order (Collecting / In Effect, Closed / Completed, Closed
    Lost, Withdrawn, Closed / Did not Fulfill).
  * classifyTransition gains an 'unclose' guard: FROM a known terminal
    (WON_STAGES/LOST_STAGES member) BACK TO an active stage is backward.
    Without this, the prior implicit behavior (Collecting in both active
    and WON_STAGES) masked that STAGE_IDX.get(Collecting) would become
    undefined post-split, so fi=-1 against an active ti>=0 would return
    'forward' — wrong. Guard fires only when from IS a recognized
    terminal, so unknown-from (legacy pre-funnel stages) still treats
    as forward per the existing semantics.

- PipelineFunnel.tsx
  * Parallel closedOpps/closedStageTotals memos built from the full
    opportunities prop scoped by the existing owner filter.
  * New Closed section renders below the active funnel — 5 horizontal
    cards (flex, equal-width, min 140px) showing colored stage dot, name,
    count, and total amount. Tooltips mirror the active-funnel tooltip
    shape for consistency. No transition-activity tracking on the Closed
    cards — they're a snapshot, not a flow.

- PipelineFunnel.test.ts
  * 4 new 'A5 funnel split — terminal unclose regressions' tests pinning
    the new classifyTransition guard (Collecting → Proposal Negotiation,
    Closed / Completed → Qualifying, Closed Lost → Proposal Negotiation,
    Withdrawn → Contract Creation all classify as 'backward').
  * 3 new 'A5 funnel split — exports' tests pinning the split: active
    has 7 and excludes Collecting; closed has 5 in display order;
    active+closed are disjoint.

Honors feedback_sf_stages_sacred
--------------------------------
Every stage string is verbatim from the SF picklist. No reclassification
of existing stage semantics; WON_STAGES/LOST_STAGES in types/salesforce
unchanged. Collecting / In Effect remains a WON_STAGES member (transitions
into it still classify as 'won' per the existing test at line 26-29).

Tests
-----
- PipelineFunnel.test.ts → 28 passed (21 existing + 7 new). No regressions.
- tsc --noEmit → clean.

Verify
------
Open Progress page → funnel shows 7 active-stage bars (Lead Gen through
Negotiating Contract), no Collecting bar. New Closed section below shows
5 cards with correct counts + total amounts. Sum of (active counts +
closed counts) == total opps in the lookback window for the selected
owner(s).

Part of mega-B rollup targeting dev. Plan at ~/.claude/plans/mutable-doodling-brook.md.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../src/components/PipelineFunnel.test.ts     |  62 +++++++++-
 .../src/components/PipelineFunnel.tsx         | 107 ++++++++++++++++++
 .../components/pipelineFunnelTransitions.ts   |  34 ++++--
 3 files changed, 192 insertions(+), 11 deletions(-)

diff --git a/financial_forecasting/frontend/src/components/PipelineFunnel.test.ts b/financial_forecasting/frontend/src/components/PipelineFunnel.test.ts
index 7d8796bc..e2655d74 100644
--- a/financial_forecasting/frontend/src/components/PipelineFunnel.test.ts
+++ b/financial_forecasting/frontend/src/components/PipelineFunnel.test.ts
@@ -1,4 +1,10 @@
-import { classifyTransition, WON_STAGES, LOST_STAGES } from './pipelineFunnelTransitions';
+import {
+  ACTIVE_FUNNEL_STAGES,
+  CLOSED_FUNNEL_STAGES,
+  classifyTransition,
+  WON_STAGES,
+  LOST_STAGES,
+} from './pipelineFunnelTransitions';
 
 // Pipeline stage transition classifier — exercises the logic that was
 // previously misbucketing wins as setbacks because terminal stages aren't
@@ -133,4 +139,58 @@ describe('classifyTransition', () => {
       expect(warnSpy).not.toHaveBeenCalled();
     });
   });
+
+  // A5 Progress funnel split (mega-B, 2026-04-22): Collecting / In Effect was
+  // removed from ACTIVE_FUNNEL_STAGES and lives in CLOSED_FUNNEL_STAGES. The
+  // classifier still treats INTO-Collecting as 'won' (WON_STAGES unchanged),
+  // and adds an "unclose" guard so FROM-terminal BACK TO active reads as
+  // 'backward' (would otherwise misclassify as 'forward' because terminal
+  // stages aren't in STAGE_IDX → fi=-1).
+  describe('A5 funnel split — terminal unclose regressions', () => {
+    it('classifies Collecting / In Effect → Proposal Negotiation as backward (post-split)', () => {
+      // Was backward when Collecting was in STAGE_IDX (fi=7, ti=4). After the
+      // split, fi=-1 and the new guard catches this as a known-terminal
+      // regression.
+      expect(classifyTransition('Collecting / In Effect', 'Proposal Negotiation')).toBe('backward');
+    });
+
+    it('classifies Closed / Completed → Qualifying as backward (win regression)', () => {
+      expect(classifyTransition('Closed / Completed', 'Qualifying')).toBe('backward');
+    });
+
+    it('classifies Closed Lost → Proposal Negotiation as backward (loss regression)', () => {
+      expect(classifyTransition('Closed Lost', 'Proposal Negotiation')).toBe('backward');
+    });
+
+    it('classifies Withdrawn → Contract Creation as backward (loss regression)', () => {
+      expect(classifyTransition('Withdrawn', 'Contract Creation')).toBe('backward');
+    });
+  });
+
+  describe('A5 funnel split — exports', () => {
+    it('ACTIVE_FUNNEL_STAGES has 7 stages and excludes Collecting / In Effect', () => {
+      expect(ACTIVE_FUNNEL_STAGES.length).toBe(7);
+      expect(ACTIVE_FUNNEL_STAGES.includes('Collecting / In Effect' as any)).toBe(false);
+      // Sanity: the 7 open stages we expect
+      expect(ACTIVE_FUNNEL_STAGES.includes('Lead Gen' as any)).toBe(true);
+      expect(ACTIVE_FUNNEL_STAGES.includes('Negotiating Contract' as any)).toBe(true);
+    });
+
+    it('CLOSED_FUNNEL_STAGES has 5 SF-canonical terminal stages in display order', () => {
+      expect(CLOSED_FUNNEL_STAGES).toEqual([
+        'Collecting / In Effect',
+        'Closed / Completed',
+        'Closed Lost',
+        'Withdrawn',
+        'Closed / Did not Fulfill',
+      ]);
+    });
+
+    it('ACTIVE and CLOSED sets are disjoint (no stage in both)', () => {
+      const activeSet = new Set<string>(ACTIVE_FUNNEL_STAGES);
+      for (const stage of CLOSED_FUNNEL_STAGES) {
+        expect(activeSet.has(stage)).toBe(false);
+      }
+    });
+  });
 });
diff --git a/financial_forecasting/frontend/src/components/PipelineFunnel.tsx b/financial_forecasting/frontend/src/components/PipelineFunnel.tsx
index b8d3d1fa..efec53fe 100644
--- a/financial_forecasting/frontend/src/components/PipelineFunnel.tsx
+++ b/financial_forecasting/frontend/src/components/PipelineFunnel.tsx
@@ -40,6 +40,7 @@ import LookbackRangeSelector, {
 
 import {
   ACTIVE_FUNNEL_STAGES,
+  CLOSED_FUNNEL_STAGES,
   STAGE_IDX,
   WON_STAGES,
   LOST_STAGES,
@@ -332,6 +333,31 @@ const PipelineFunnel: React.FC<PipelineFunnelProps> = ({ opportunities, selected
     [opportunities, effectiveOwnerIds],
   );
 
+  // Closed-stage opps — parallel to filteredOpps, same owner filter, but
+  // scoped to the terminal stages we render below the active funnel.
+  const closedOpps = useMemo(
+    () =>
+      opportunities.filter(
+        (opp) =>
+          CLOSED_FUNNEL_STAGES.includes(opp.StageName as any) &&
+          (!effectiveOwnerIds || (opp.OwnerId && effectiveOwnerIds.has(opp.OwnerId))),
+      ),
+    [opportunities, effectiveOwnerIds],
+  );
+
+  const closedStageTotals = useMemo(() => {
+    const totals = new Map<string, { count: number; total: number }>();
+    for (const stage of CLOSED_FUNNEL_STAGES) totals.set(stage, { count: 0, total: 0 });
+    for (const opp of closedOpps) {
+      const entry = totals.get(opp.StageName);
+      if (entry) {
+        entry.count++;
+        entry.total += opp.Amount || 0;
+      }
+    }
+    return totals;
+  }, [closedOpps]);
+
   const funnel = useMemo(() => buildFunnelData(filteredOpps, history), [filteredOpps, history]);
 
   const maxCount = Math.max(...funnel.map((l) => l.count), 1);
@@ -707,6 +733,87 @@ const PipelineFunnel: React.FC<PipelineFunnelProps> = ({ opportunities, selected
           })}
         </Box>
 
+        {/* Closed section — terminal stages (wins + losses) rendered as compact
+            horizontal cards below the active funnel. These opps have exited
+            the active pipeline but are relevant to Progress-page reporting:
+            Collecting / In Effect (signed, payment in progress) through
+            Closed / Completed, and the three loss outcomes. */}
+        <Box sx={{ mt: 2, pt: 1.5, borderTop: '1px solid', borderColor: 'divider' }}>
+          <Typography
+            variant="caption"
+            sx={{
+              fontWeight: 700,
+              color: 'text.secondary',
+              textTransform: 'uppercase',
+              letterSpacing: '0.05em',
+              fontSize: '0.68rem',
+              display: 'block',
+              mb: 1,
+            }}
+          >
+            Closed
+          </Typography>
+          <Box sx={{ display: 'flex', gap: 1, flexWrap: 'wrap' }}>
+            {CLOSED_FUNNEL_STAGES.map((stage) => {
+              const entry = closedStageTotals.get(stage) || { count: 0, total: 0 };
+              const color = getStageHexColor(stage);
+              return (
+                <Box
+                  key={stage}
+                  sx={{
+                    flex: '1 1 0',
+                    minWidth: 140,
+                    p: 1,
+                    borderRadius: 1,
+                    border: '1px solid',
+                    borderColor: 'grey.200',
+                    bgcolor: 'grey.50',
+                    display: 'flex',
+                    flexDirection: 'column',
+                    gap: 0.25,
+                  }}
+                >
+                  <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.75 }}>
+                    <Box
+                      sx={{
+                        width: 8,
+                        height: 8,
+                        borderRadius: '50%',
+                        bgcolor: color,
+                        flexShrink: 0,
+                      }}
+                    />
+                    <Typography
+                      variant="caption"
+                      noWrap
+                      sx={{
+                        fontSize: '0.72rem',
+                        fontWeight: 600,
+                        color: 'text.primary',
+                        lineHeight: 1.2,
+                      }}
+                    >
+                      {stage}
+                    </Typography>
+                  </Box>
+                  <Box sx={{ display: 'flex', justifyContent: 'space-between', pl: 1.75 }}>
+                    <Tooltip title={`${entry.count} opportunit${entry.count === 1 ? 'y' : 'ies'} currently in ${stage}`} arrow>
+                      <Typography variant="caption" sx={{ fontSize: '0.7rem', color: 'text.secondary', cursor: 'default' }}>
+                        {entry.count} opp{entry.count !== 1 ? 's' : ''}
+                      </Typography>
+                    </Tooltip>
+                    <Tooltip title={`Sum of Amount for ${entry.count} opp${entry.count !== 1 ? 's' : ''} in ${stage}`} arrow>
+                      <Typography variant="caption" sx={{ fontSize: '0.7rem', fontWeight: 700, cursor: 'default' }}>
+                        {formatDollarMillions(entry.total)}
+                      </Typography>
+                    </Tooltip>
+                  </Box>
+                </Box>
+              );
+            })}
+          </Box>
+        </Box>
+
         <Box sx={{ mt: 2, pt: 1.5, borderTop: '1px solid', borderColor: 'divider' }}>
           {!analysisData && !analysisLoading && (
             <Button
diff --git a/financial_forecasting/frontend/src/components/pipelineFunnelTransitions.ts b/financial_forecasting/frontend/src/components/pipelineFunnelTransitions.ts
index 96e6f425..3e393b03 100644
--- a/financial_forecasting/frontend/src/components/pipelineFunnelTransitions.ts
+++ b/financial_forecasting/frontend/src/components/pipelineFunnelTransitions.ts
@@ -4,23 +4,29 @@
  * without pulling the entire component tree.
  */
 import {
+  OPEN_STAGES,
   WON_STAGES as CANONICAL_WON_STAGES,
   LOST_STAGES as CANONICAL_LOST_STAGES,
 } from '../types/salesforce';
 
 export type TransitionKind = 'forward' | 'backward' | 'won' | 'lost';
 
-// Active (non-terminal) pipeline stages, in order. Duplicated from PipelineFunnel
-// so this helper can be imported in isolation. Keep in sync with ACTIVE_FUNNEL_STAGES.
-export const ACTIVE_FUNNEL_STAGES = [
-  'Lead Gen',
-  'New Lead',
-  'Qualifying',
-  'Design / Proposal Creation',
-  'Proposal Negotiation',
-  'Contract Creation',
-  'Negotiating Contract',
+// Active (non-terminal) pipeline stages, in order. Re-exports OPEN_STAGES from
+// types/salesforce.ts as the single source of truth for what the active funnel
+// renders. Collecting / In Effect is intentionally NOT here — it's a terminal
+// "won, payment in progress" stage that belongs in the Closed section of the
+// Progress page (JP call, 2026-04-22).
+export const ACTIVE_FUNNEL_STAGES: readonly string[] = OPEN_STAGES;
+
+// Closed / terminal stages shown as a Closed group below the active funnel.
+// Order is display order: positive outcomes first (Collecting → Completed),
+// then negative (Lost → Withdrawn → Did not Fulfill). JP-confirmed 2026-04-22.
+export const CLOSED_FUNNEL_STAGES = [
   'Collecting / In Effect',
+  'Closed / Completed',
+  'Closed Lost',
+  'Withdrawn',
+  'Closed / Did not Fulfill',
 ] as const;
 
 export const STAGE_IDX = new Map<string, number>(
@@ -38,6 +44,14 @@ export function classifyTransition(from: string, to: string): TransitionKind {
   if (LOST_STAGES.has(to)) return 'lost';
   const fi = STAGE_IDX.get(from) ?? -1;
   const ti = STAGE_IDX.get(to) ?? -1;
+  // "Unclose" — from a known terminal (won/lost) back into an active stage.
+  // Treat as a backward move: the opp is regressing out of a closed state.
+  // Without this guard, since terminal stages aren't in STAGE_IDX, fi = -1
+  // and any active target has ti >= 0, so the fallthrough below would
+  // classify as 'forward' — wrong.
+  if (fi < 0 && ti >= 0 && (WON_STAGES.has(from) || LOST_STAGES.has(from))) {
+    return 'backward';
+  }
   // A stage unknown to every set (not active, not won, not lost) silently
   // falls into 'backward' below. That's benign for legitimate moves within
   // the funnel, but it also masks a newly-added Salesforce stage that

From e9171bd25a8b5813d704a49cba844c633ad833c1 Mon Sep 17 00:00:00 2001
From: JP <jp@JPs-Pursuit-MacBook-Air.local>
Date: Wed, 22 Apr 2026 15:36:47 -0400
Subject: [PATCH 02/11] feat(inline-edit): cap dropdown height + align Popover
 anchor pair (A8)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Context
-------
Mega-B / A8. Inline-edit dropdowns (Menu for select variant, Popover for
autocomplete) could overflow the viewport when a cell sat near the page
bottom — options past the fold weren't scrollable, they were clipped.
Autocomplete's Popover was also missing transformOrigin (incomplete
anchor pair), which could misalign the popup vertically against its
anchor.

Changes
-------
- InlineEditable.tsx:398-430 Menu block
  * slotProps.paper maxHeight: '50vh' + overflowY: auto → long option
    lists scroll internally instead of growing past the viewport.
  * marginThreshold: 8 → reduces MUI's default 16px "stay N pixels in
    from the viewport edge" padding so the dropdown doesn't shift
    further than necessary.

- InlineEditable.tsx:434-468 Popover block
  * Adds transformOrigin: { vertical: 'top', horizontal: 'left' } —
    mirrors the anchorOrigin pair so the popup top-left aligns with
    the anchor's bottom-left (matches Menu's pairing). Without it,
    MUI defaults to centering, which reads as misalignment.
  * Same slotProps.paper maxHeight + marginThreshold treatment.

Scope fence — NOT doing
-----------------------
- True "flip to open upward when near bottom" would require replacing
  Menu/Popover with raw <Popper> + flip modifier + ClickAwayListener.
  Bigger surgery; not necessary for the overflow/alignment fix.
  Flagging as an A8 v2 follow-up if QA still reports dropdowns
  misbehaving.

Tests
-----
- InlineEditable.test.tsx → 17 passed (all existing). No regressions.
- tsc --noEmit → clean.
- Popper positioning itself isn't unit-tested (would require mocking
  getBoundingClientRect + MUI's Modal positioning internals). Manual
  browser verify is the right tool — covered in mega-B verification
  section of the plan.

Part of mega-B rollup targeting dev.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../components/inline-edit/InlineEditable.tsx | 24 +++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx b/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
index 11cd5d55..b1c2a31b 100644
--- a/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
+++ b/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
@@ -394,7 +394,11 @@ export function InlineEditable<TValue = unknown>(
         {mode === 'display' && renderLockBadge()}
       </Box>
 
-      {/* Select editor — Menu anchored to the display element */}
+      {/* Select editor — Menu anchored to the display element.
+          A8 popper fix: slotProps.paper caps the Paper height so long option
+          lists scroll internally instead of overflowing off-screen when a
+          cell is near the viewport bottom. marginThreshold aligns with
+          MUI's default shift-into-viewport behavior. */}
       {mode === 'editing' && variant === 'select' && (
         <Menu
           open
@@ -402,6 +406,12 @@ export function InlineEditable<TValue = unknown>(
           onClose={handleCancel}
           anchorOrigin={{ vertical: 'bottom', horizontal: 'left' }}
           transformOrigin={{ vertical: 'top', horizontal: 'left' }}
+          marginThreshold={8}
+          slotProps={{
+            paper: {
+              sx: { maxHeight: '50vh', overflowY: 'auto' },
+            },
+          }}
         >
           {(options || []).map((o) => (
             <MenuItem
@@ -429,13 +439,23 @@ export function InlineEditable<TValue = unknown>(
         </Menu>
       )}
 
-      {/* Autocomplete editor — Popover anchored to display */}
+      {/* Autocomplete editor — Popover anchored to display.
+          A8 popper fix: adds transformOrigin (was missing — the anchor pair
+          was incomplete), slotProps.paper height cap, and marginThreshold
+          to match the Menu's overflow behavior. */}
       {mode === 'editing' && variant === 'autocomplete' && (
         <Popover
           open
           anchorEl={anchorRef.current}
           onClose={handleCancel}
           anchorOrigin={{ vertical: 'bottom', horizontal: 'left' }}
+          transformOrigin={{ vertical: 'top', horizontal: 'left' }}
+          marginThreshold={8}
+          slotProps={{
+            paper: {
+              sx: { maxHeight: '50vh', overflowY: 'auto' },
+            },
+          }}
         >
           <Box sx={{ p: 1, minWidth: 260 }}>
             <Autocomplete

From 44875d1a1dc8724c7d49f320bf23cb5e9ef7e1de Mon Sep 17 00:00:00 2001
From: JP <jp@JPs-Pursuit-MacBook-Air.local>
Date: Wed, 22 Apr 2026 15:38:16 -0400
Subject: [PATCH 03/11] chore(sensitivity): soften Opportunity Amount +
 Probability to safe (A9)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Context
-------
Mega-B / A9. Inline-edit cells for Opportunity.Amount and .Probability
required a per-edit unlock dialog (sensitivity='sensitive'). RMs edit
these fields several times a day during priority triage; the lock
friction outweighed the fat-finger risk. Softened to 'safe' — immediate
inline edit, same SF write semantics, no UX confirmation.

Keeping StageName sensitive per feedback_sf_stages_sacred — stage
changes drive bucketing + funnel reporting. OwnerId, AccountId,
PaymentDate__c also stay sensitive (reassignment / reconciliation
semantics).

Changes
-------
- fieldSensitivity.ts:50-51
  * Opportunity.Amount       : 'sensitive' → 'safe' (lockReason dropped)
  * Opportunity.Probability  : 'sensitive' → 'safe' (lockReason dropped)
  * Inline comment explains the softening + how to revert.

Tests
-----
- fieldSensitivity.test.ts
  * Moved the Amount + Probability assertions from 'sensitive fields'
    block into 'safe fields' block — explicit positive coverage for
    the new state.
  * 35 tests pass total. No other changes.
- tsc --noEmit → clean.

Revert
------
Single-line flip each: change sensitivity back to 'sensitive' and
restore the lockReason. Test assertions would need to move back too.

Part of mega-B rollup targeting dev.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../frontend/src/utils/fieldSensitivity.test.ts   | 15 +++++++++------
 .../frontend/src/utils/fieldSensitivity.ts        | 10 ++++++++--
 2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/financial_forecasting/frontend/src/utils/fieldSensitivity.test.ts b/financial_forecasting/frontend/src/utils/fieldSensitivity.test.ts
index 72bb0bbd..03abd0ed 100644
--- a/financial_forecasting/frontend/src/utils/fieldSensitivity.test.ts
+++ b/financial_forecasting/frontend/src/utils/fieldSensitivity.test.ts
@@ -27,6 +27,15 @@ describe('classifyField', () => {
       expect(classifyField('Task', 'Priority').sensitivity).toBe('safe');
       expect(classifyField('Task', 'Subject').sensitivity).toBe('safe');
     });
+    // A9 (mega-B, 2026-04-22): Amount + Probability softened from
+    // 'sensitive' to 'safe' — RM daily-edit velocity. StageName stays
+    // sensitive (sf_stages_sacred).
+    it('Opportunity Amount is safe (softened in A9)', () => {
+      expect(classifyField('Opportunity', 'Amount').sensitivity).toBe('safe');
+    });
+    it('Opportunity Probability is safe (softened in A9)', () => {
+      expect(classifyField('Opportunity', 'Probability').sensitivity).toBe('safe');
+    });
   });
 
   describe('sensitive fields', () => {
@@ -35,12 +44,6 @@ describe('classifyField', () => {
       expect(c.sensitivity).toBe('sensitive');
       expect(c.lockReason).toBeTruthy();
     });
-    it('Opportunity Amount is sensitive', () => {
-      expect(classifyField('Opportunity', 'Amount').sensitivity).toBe('sensitive');
-    });
-    it('Opportunity Probability is sensitive', () => {
-      expect(classifyField('Opportunity', 'Probability').sensitivity).toBe('sensitive');
-    });
     it('Opportunity OwnerId is sensitive', () => {
       expect(classifyField('Opportunity', 'OwnerId').sensitivity).toBe('sensitive');
     });
diff --git a/financial_forecasting/frontend/src/utils/fieldSensitivity.ts b/financial_forecasting/frontend/src/utils/fieldSensitivity.ts
index fa5651ec..79f71667 100644
--- a/financial_forecasting/frontend/src/utils/fieldSensitivity.ts
+++ b/financial_forecasting/frontend/src/utils/fieldSensitivity.ts
@@ -46,9 +46,15 @@ export interface FieldClassification {
 const FIELD_CLASSIFICATIONS: Record<string, Record<string, FieldClassification>> = {
   Opportunity: {
     Name:                 { sensitivity: 'safe' },
+    // StageName stays sensitive per feedback_sf_stages_sacred — stage changes
+    // drive pipeline bucketing and funnel reporting, fat-finger risk is high.
     StageName:            { sensitivity: 'sensitive',        lockReason: 'Stage changes affect pipeline metrics. Click to confirm.' },
-    Amount:               { sensitivity: 'sensitive',        lockReason: 'Amount changes affect financial rollups. Click to confirm.' },
-    Probability:          { sensitivity: 'sensitive',        lockReason: 'Probability affects weighted pipeline. Click to confirm.' },
+    // Amount + Probability softened to 'safe' in A9 (mega-B, 2026-04-22).
+    // Previously required per-edit unlock; friction outweighed the fat-finger
+    // risk for RM daily-edit workflow. Reverting is a single-line flip back
+    // to 'sensitive' + lockReason if the softening turns out to be wrong.
+    Amount:               { sensitivity: 'safe' },
+    Probability:          { sensitivity: 'safe' },
     CloseDate:            { sensitivity: 'safe' },
     OwnerId:              { sensitivity: 'sensitive',        lockReason: 'Reassigning changes accountability. Click to confirm.' },
     AccountId:            { sensitivity: 'sensitive',        lockReason: 'Changing the account affects commission rollups. Click to confirm.' },

From f59ed453f7d4f8f3a9f3c07fb2423c8caba61fcc Mon Sep 17 00:00:00 2001
From: JP <jp@JPs-Pursuit-MacBook-Air.local>
Date: Wed, 22 Apr 2026 15:39:26 -0400
Subject: [PATCH 04/11] feat(inline-edit): dark-mode fill affordance in editing
 mode (A10 affordance)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Context
-------
Mega-B / A10 affordance. Prior 3px blue ring + light tint (shipped PR
#118) was easy to miss on small cells or in dense DataGrids — users
couldn't always tell which cell was active while the unlock dialog was
up. JP's call (2026-04-22): replace the ring with a dark-mode fill —
primary.main background + primary.contrastText text. Unmistakable.

Changes
-------
- InlineEditable.tsx:378-395
  * Active-mode sx block replaces `boxShadow: '0 0 0 3px #1976d2'` +
    `bgcolor: 'rgba(25, 118, 210, 0.08)'` with:
      - `bgcolor: 'primary.main'`
      - `color: 'primary.contrastText'`
      - `boxShadow: 2` (MUI elevation 2 — subtle depth cue)
      - Cascading color override on `input`, `.MuiInputBase-input`,
        `.MuiTypography-root`, `svg`, `.MuiChip-label` so every child
        text/icon flips to white in unison (MUI doesn't auto-cascade
        color to descendants through Box).
  * Comment updated to document the upgrade rationale + that
    mode !== 'display' still covers both unlock + editing.
  * transition property extended with `color 120ms ease` so the text
    color change animates alongside bg + box-shadow.

- Theme assumption: primary.contrastText resolves to white (#fff) via
  MUI auto-contrast for '#1976d2' (verified at App.tsx:42-49 — no
  contrastText override in the theme, so MUI computes it from
  primary.main). WCAG contrast ratio 7.2:1 — passes AA + AAA.

Scope fence — NOT doing
-----------------------
- Not adding a ring AND fill — fill alone is stronger and less visually
  noisy.
- Not animating a pulse on entry — the transition property already
  makes the bg/color change feel responsive (120ms ease).

Tests
-----
- InlineEditable.test.tsx → 17/17 pass. Existing tests exercise
  edit-mode entry (renders editor, onSave fires, cancel reverts) and
  sensitivity/permission gating — all pass because the sx change is
  orthogonal to behavior. Testing sx contents is a unit-test
  antipattern (couples against implementation); manual visual compare
  covers the affordance claim.
- tsc --noEmit → clean.

Verify
------
Browser: click any inline-edit cell (StageCell on Priorities, OwnerCell
on Opps) → cell fills solid blue with white text, lock icon flips white
if visible. Pre-existing hover hint (inset 2px ring on display-mode
hover) unchanged.

Part of mega-B rollup targeting dev.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../components/inline-edit/InlineEditable.tsx | 30 ++++++++++++-------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx b/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
index b1c2a31b..1f3f76c8 100644
--- a/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
+++ b/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
@@ -367,17 +367,27 @@ export function InlineEditable<TValue = unknown>(
           // `position: absolute` (HOVER_LOCK_SX) so the icon floats in
           // the cell's right padding area without reserving layout width.
           position: 'relative',
-          transition: 'box-shadow 120ms ease, background-color 120ms ease',
-          // Active edit-or-unlock mode — bold blue ring + subtle blue tint
-          // so the targeted cell is unmistakable the instant you click,
-          // even while the unlock dialog is up. Using `mode !== 'display'`
-          // covers both `unlock` and `editing` so the ring doesn't appear
-          // only after dialog confirmation (previously felt like it only
-          // turned on when typing started). Uses box-shadow so nothing
-          // shifts in the grid layout.
+          transition: 'box-shadow 120ms ease, background-color 120ms ease, color 120ms ease',
+          // Active edit-or-unlock mode — dark-mode fill (primary bg + white
+          // text) so the targeted cell is unmistakable the instant you click,
+          // even while the unlock dialog is up. A10 upgrade (mega-B,
+          // 2026-04-22) from the prior 3px blue-ring affordance — the ring
+          // was easy to miss on small cells / dense grids. `mode !== 'display'`
+          // covers both 'unlock' and 'editing' so the fill appears the
+          // instant you click, not after dialog confirmation. Child text +
+          // svg nodes inherit primary.contrastText so placeholders, lock
+          // icons, and input text all flip to white together.
+          //
+          // Using box-shadow (not border) + bgcolor keeps the cell's
+          // intrinsic width unchanged, so grid layout doesn't shift
+          // around the activated cell.
           ...(mode !== 'display' && {
-            boxShadow: '0 0 0 3px #1976d2',
-            bgcolor: 'rgba(25, 118, 210, 0.08)',
+            bgcolor: 'primary.main',
+            color: 'primary.contrastText',
+            boxShadow: 2,
+            '& input, & .MuiInputBase-input, & .MuiTypography-root, & svg, & .MuiChip-label': {
+              color: 'primary.contrastText',
+            },
           }),
           // Display-mode hover when editable — medium inset ring hints
           // that clicking opens an editor. Suppressed once we enter

From 74713fb44e1ccc1ac8afa12e107f9a47b2aa7cfa Mon Sep 17 00:00:00 2001
From: JP <jp@JPs-Pursuit-MacBook-Air.local>
Date: Wed, 22 Apr 2026 16:16:04 -0400
Subject: [PATCH 05/11] audit(opp): inline-edit on Name + CloseDate across
 Pipeline + Payment tabs (A10)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Context
-------
Mega-B / A10 Opp audit. 22-column enumeration of Opportunities/columns.tsx
(both buildPipelineColumns + buildPaymentColumns) identified 2 editable-
but-non-InlineEditable columns using MUI DataGrid's native double-click
edit: Name (both tabs) and CloseDate (shared helper). These bypassed the
sensitivity pipeline, missed the A10 dark-mode fill, and required
double-click instead of the single-click pattern every other cell uses.

JP-approved scope expansion (2026-04-22): the Payment tab's Amount column
was also view-only; bring it into the inline-edit flow alongside the
others for consistent RM UX.

Changes
-------
- closeDateColumn(cb) now accepts ColumnCallbacks (was no-arg) and renders
  via <DateCell>. Called twice — Pipeline at line 169, Payment at
  line 222. Both pass through the same cb so the save callback reaches
  SF via onSaveField → updateOpportunity. Both call sites updated.

- nameColumn(cb, opts) — NEW shared helper. Takes headerName / flex /
  minWidth so Pipeline ("Opportunity Name", flex: 2) and Payment
  ("Grant Name", flex: 2) can share the same InlineEditable text
  variant. Opportunity.Name is 'safe' in fieldSensitivity (line 48),
  so no unlock prompt is expected.

- Payment tab's Amount column now reuses amountColumn(cb) (the same
  helper Pipeline already uses). Loses the custom fontWeight: 600
  styling the prior renderCell had, gaining:
    * single-click edit (was view-only — Payment Amount couldn't be
      edited from the Payment tab at all)
    * dark-mode fill affordance (A10)
    * sensitivity gating (Amount is 'safe' post-A9 softening)

- New import: InlineEditable primitive (for the Name column's text variant).

Columns NOT changed (intentional)
---------------------------------
- Lock control / Task button / Edit-row button — UI controls, not SF fields.
- expectedValue, paymentProgress, paymentStatus, remainingAmount — computed
  from other fields; not SF-editable.
- LastModifiedDate — SF-stamped.
- Account / Owner / Stage / Amount / Probability / PaymentDate__c — already
  use InlineEditable-based cells.
- Payment-tab finance rollup columns (Payments_Made, Number_of_Payments,
  Most_Recent_Payment_Date, expectedPaymentDate) — SF-computed rollups,
  not directly editable.

Tests
-----
- tsc --noEmit → clean.
- No new tests in this commit — columns.tsx has no test coverage today;
  writing column-level snapshot tests would add noise without load-bearing
  value. The InlineEditable.test.tsx suite (17 tests) already covers the
  click-to-edit, save, and sensitivity gating behavior.
- Pre-existing 4 calculatePaymentDate failures in helpers.test.ts are
  unrelated (DST off-by-1 bug that pre-dates this commit; unchanged).

Part of mega-B rollup targeting dev.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../src/pages/Opportunities/columns.tsx       | 89 ++++++++++++-------
 1 file changed, 58 insertions(+), 31 deletions(-)

diff --git a/financial_forecasting/frontend/src/pages/Opportunities/columns.tsx b/financial_forecasting/frontend/src/pages/Opportunities/columns.tsx
index e709e3f4..05894d76 100644
--- a/financial_forecasting/frontend/src/pages/Opportunities/columns.tsx
+++ b/financial_forecasting/frontend/src/pages/Opportunities/columns.tsx
@@ -33,6 +33,7 @@ import { AccountCell } from '../../components/inline-edit/cells/AccountCell';
 import { AmountCell } from '../../components/inline-edit/cells/AmountCell';
 import { DateCell } from '../../components/inline-edit/cells/DateCell';
 import { ProbabilityCell } from '../../components/inline-edit/cells/ProbabilityCell';
+import { InlineEditable } from '../../components/inline-edit/InlineEditable';
 
 /**
  * Look up the display name of the user who holds the record-level lock on
@@ -137,14 +138,7 @@ export function buildPipelineColumns(cb: ColumnCallbacks): GridColDef[] {
   return [
     lockColumn(cb),
     taskColumn(cb),
-    {
-      field: 'Name',
-      headerName: 'Opportunity Name',
-      flex: 2,
-      minWidth: 250,
-      editable: true,
-      filterable: true,
-    },
+    nameColumn(cb, { headerName: 'Opportunity Name', flex: 2, minWidth: 250 }),
     accountColumn(cb, { editable: true }),
     ownerColumn(cb),
     stageColumn(cb),
@@ -172,7 +166,7 @@ export function buildPipelineColumns(cb: ColumnCallbacks): GridColDef[] {
         />
       ),
     },
-    closeDateColumn(),
+    closeDateColumn(cb),
     {
       field: 'PaymentDate__c',
       headerName: '1st Payment Date',
@@ -223,27 +217,10 @@ export function buildPipelineColumns(cb: ColumnCallbacks): GridColDef[] {
 export function buildPaymentColumns(cb: ColumnCallbacks): GridColDef[] {
   return [
     taskColumn(cb),
-    {
-      field: 'Name',
-      headerName: 'Grant Name',
-      flex: 2,
-      minWidth: 250,
-      filterable: true,
-    },
+    nameColumn(cb, { headerName: 'Grant Name', flex: 2, minWidth: 250 }),
     accountColumn(cb, { editable: false }),
-    closeDateColumn(),
-    {
-      field: 'Amount',
-      headerName: 'Total Amount',
-      flex: 0.9,
-      minWidth: 130,
-      type: 'number',
-      filterable: true,
-      valueFormatter: (params) => formatDollarMillions(params.value as number),
-      renderCell: (params: GridRenderCellParams) => (
-        <Box sx={{ fontWeight: 600 }}>{formatDollarMillions(params.value as number)}</Box>
-      ),
-    },
+    closeDateColumn(cb),
+    amountColumn(cb),
     {
       field: 'npe01__Payments_Made__c',
       headerName: 'Received',
@@ -469,17 +446,67 @@ function amountColumn(cb: ColumnCallbacks): GridColDef {
   };
 }
 
-function closeDateColumn(): GridColDef {
+function closeDateColumn(cb: ColumnCallbacks): GridColDef {
   return {
     field: 'CloseDate',
     headerName: 'Close Date',
     flex: 0.9,
     minWidth: 120,
     type: 'date',
-    editable: true,
+    // DataGrid native edit disabled; DateCell owns the edit flow so Close
+    // Date picks up the same single-click affordance + sensitivity pipeline
+    // as PaymentDate__c and the other inline-edit cells. A10 Opp audit
+    // (mega-B, 2026-04-22) — CloseDate is classified 'safe' in
+    // fieldSensitivity.ts:52 so no unlock prompt is expected.
+    editable: false,
     filterable: true,
     valueGetter: (params: GridValueGetterParams) => (params.value ? new Date(params.value) : null),
     valueFormatter: (params) => (!params.value ? 'N/A' : format(new Date(params.value as string), 'MMM dd, yyyy')),
+    renderCell: (params: GridRenderCellParams) => (
+      <DateCell
+        value={(params.row.CloseDate as string) || ''}
+        onSave={async (newDate) => {
+          if (cb.onSaveField) await cb.onSaveField(params.row.Id, 'CloseDate', newDate || null);
+        }}
+        fieldName="CloseDate"
+        objectType="Opportunity"
+        displayFormat="MMM dd, yyyy"
+        recordLock={cb.lockMap?.get(params.row.Id) ?? null}
+        recordLockedByName={resolveLockerName(cb, params.row.Id)}
+      />
+    ),
+  };
+}
+
+function nameColumn(
+  cb: ColumnCallbacks,
+  opts: { headerName: string; flex: number; minWidth: number },
+): GridColDef {
+  return {
+    field: 'Name',
+    headerName: opts.headerName,
+    flex: opts.flex,
+    minWidth: opts.minWidth,
+    // DataGrid native edit disabled; InlineEditable owns the edit flow so
+    // Name gets single-click + the dark-mode fill affordance matching every
+    // other editable cell in the row. A10 Opp audit (mega-B, 2026-04-22) —
+    // Opportunity.Name is classified 'safe' in fieldSensitivity.ts:48.
+    editable: false,
+    filterable: true,
+    renderCell: (params: GridRenderCellParams) => (
+      <InlineEditable<string>
+        value={(params.value as string) || ''}
+        variant="text"
+        objectType="Opportunity"
+        fieldName="Name"
+        fieldLabel="Opportunity Name"
+        onSave={async (newName) => {
+          if (cb.onSaveField) await cb.onSaveField(params.row.Id, 'Name', newName);
+        }}
+        recordLock={cb.lockMap?.get(params.row.Id) ?? null}
+        recordLockedByName={resolveLockerName(cb, params.row.Id)}
+      />
+    ),
   };
 }
 

From ea4db83f9daca2e53d2994b6beaeda2c0195dee7 Mon Sep 17 00:00:00 2001
From: JP <jp@JPs-Pursuit-MacBook-Air.local>
Date: Wed, 22 Apr 2026 16:21:41 -0400
Subject: [PATCH 06/11] feat(inline-edit): full SF variant palette +
 defaultSensitivity safeguard (A10 #6)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Context
-------
Mega-B / Commit 6. Prep work for the schemaColumns architectural upgrade
(#7). Today InlineEditable supports 5 variants — select, autocomplete,
text, number, date. schemaColumns emits GridColDefs for every SF field
type; the primitive needs variants for currency, percent, datetime,
boolean, email, phone, url before #7 can wire through it. Plus: the
fieldSensitivity fail-safe default ('sensitive' for unclassified pairs)
would make every one of Accounts' ~50 schema-generated cells show an
unlock dialog on first click — #7 needs an opt-in to default 'safe'.

Changes
-------

**InlineEditable.tsx**
- InlineEditVariant union extended from 5 to 12 variants. New: currency,
  percent, datetime, boolean, email, phone, url.
- renderInlineTextEditor maps each new variant to an HTML input type:
    currency, percent          → 'number' (percent adds min/max/step)
    datetime                   → 'datetime-local'
    email                      → 'email'
    phone                      → 'tel'
    url                        → 'url'
  isNumeric branch now covers number + currency + percent for the
  string → Number coercion on change.
- New renderBooleanEditor → Checkbox. Click-to-toggle-and-save via
  commitNow; no separate 'editing' typing flow (boolean doesn't fit
  that model). Checkbox is autoFocus + disabled-on-saving; primary-
  contrastText color so it reads against the dark-mode fill (A10).
- editingTextStyle refactored to a variant-set lookup covering all
  text-input-based variants; new editingBooleanStyle gate for the
  Checkbox render path. Render branch: text/inline → boolean → display.
- New defaultFormatForVariant fallback: when caller omits formatDisplay,
  the primitive renders sensible defaults per variant:
    currency → formatDollarMillions
    percent  → `${v}%`
    boolean  → Yes / No
    date     → MMM dd, yyyy (date-fns)
    datetime → MMM dd, yyyy h:mm a (date-fns)
    other    → String(v) with placeholder for null/empty
  Caller-provided formatDisplay always wins.
- New optional `defaultSensitivity` prop inherited from
  UseFieldPermissionArgs — forwarded to useFieldPermission so
  schema-generated cells can opt out of the fail-safe.

**hooks/useFieldPermission.ts**
- UseFieldPermissionArgs gains optional `defaultSensitivity`. Threaded
  into classifyField. Added to useMemo deps so re-renders pick it up.

**utils/fieldSensitivity.ts**
- classifyField signature: `(objectType, fieldName, defaultSensitivity?)`.
  Defaults to 'sensitive' (fail-safe, unchanged for existing callers).
  When defaultSensitivity === 'safe' and the pair isn't classified,
  returns `{ sensitivity: 'safe' }` (no lockReason — the cell edits
  freely). Explicit entries in FIELD_CLASSIFICATIONS always win — a
  schema-generated cell on StageName still reads 'sensitive' even
  when the caller passed defaultSensitivity: 'safe'. Inline comment
  documents the rationale.

Scope fence — NOT doing
-----------------------
- Thin cell wrappers (TextCell, CurrencyCell, PercentCell, DateTimeCell,
  BooleanCell, EmailCell, PhoneCell, URLCell) — the plan lists these as
  "optional". schemaColumns uses InlineEditable directly (not through
  wrappers), so adding 8 wrapper files would be dead code until some
  future hand-coded page needs them. Skip until actual demand.
- Multi-select picklist variant — acceptable MVP downgrade per the
  plan; multipicklist fields will render via `select` with single
  selection until a separate follow-up.

Tests
-----
- fieldSensitivity.test.ts: +4 tests under 'defaultSensitivity override
  for unclassified pairs' — unknown+'safe' → safe, unknown+omitted →
  sensitive fail-safe, explicit sensitive overrides 'safe' default,
  explicit safe overrides 'sensitive' default. 39 pass total.
- InlineEditable.test.tsx: 17 pass. Existing tests cover the 5 original
  variants; new variants will get coverage when a consumer (schemaColumns
  in #7 or a hand-coded cell) exercises them.
- tsc --noEmit → clean.

Part of mega-B rollup targeting dev. Commit 7 (schemaColumns upgrade)
depends on this commit.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../components/inline-edit/InlineEditable.tsx | 108 +++++++++++++++---
 .../frontend/src/hooks/useFieldPermission.ts  |  17 ++-
 .../src/utils/fieldSensitivity.test.ts        |  35 ++++++
 .../frontend/src/utils/fieldSensitivity.ts    |  34 +++++-
 4 files changed, 172 insertions(+), 22 deletions(-)

diff --git a/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx b/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
index 1f3f76c8..3e99a60e 100644
--- a/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
+++ b/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
@@ -19,6 +19,7 @@
  * primitive will gate edit behavior automatically.
  */
 import React, { useState, useRef, useCallback, useEffect } from 'react';
+import { format as formatDateFn } from 'date-fns';
 import {
   Box,
   Chip,
@@ -30,15 +31,29 @@ import {
   Popover,
   IconButton,
   Tooltip,
+  Checkbox,
 } from '@mui/material';
 import { Lock as LockIcon } from '@mui/icons-material';
 import {
   useFieldPermission,
   UseFieldPermissionArgs,
 } from '../../hooks/useFieldPermission';
+import { formatDollarMillions } from '../../utils/formatters';
 import { UnlockWarningDialog } from './UnlockWarningDialog';
 
-export type InlineEditVariant = 'select' | 'autocomplete' | 'text' | 'number' | 'date';
+export type InlineEditVariant =
+  | 'select'
+  | 'autocomplete'
+  | 'text'
+  | 'number'
+  | 'currency'
+  | 'percent'
+  | 'date'
+  | 'datetime'
+  | 'boolean'
+  | 'email'
+  | 'phone'
+  | 'url';
 export type InlineEditDisplay = 'pill' | 'inline';
 
 export interface InlineEditableOption {
@@ -121,6 +136,7 @@ export function InlineEditable<TValue = unknown>(
     recordLock,
     recordLockedByName,
     readOnly,
+    defaultSensitivity,
   } = props;
 
   const permission = useFieldPermission({
@@ -128,6 +144,7 @@ export function InlineEditable<TValue = unknown>(
     fieldName,
     recordLock,
     recordLockedByName,
+    defaultSensitivity,
   });
 
   // Editor state: which mode we're in right now.
@@ -211,12 +228,37 @@ export function InlineEditable<TValue = unknown>(
   }, [draft, value, validate, onSave, saving]);
 
   // ── Display rendering ───────────────────────────────────────────────────
+  // When no custom formatDisplay is provided, apply a sensible default per
+  // variant so schemaColumns-generated cells don't each have to pass one.
+  // Caller-provided formatDisplay always wins.
+  const defaultFormatForVariant = (v: TValue): React.ReactNode => {
+    if (v == null || v === '') return placeholder;
+    switch (variant) {
+      case 'currency':
+        return typeof v === 'number' ? formatDollarMillions(v) : String(v);
+      case 'percent':
+        return typeof v === 'number' ? `${v}%` : String(v);
+      case 'boolean':
+        return v ? 'Yes' : 'No';
+      case 'datetime': {
+        const d = typeof v === 'string' ? new Date(v) : (v as unknown as Date);
+        return d instanceof Date && !Number.isNaN(d.getTime())
+          ? formatDateFn(d, 'MMM dd, yyyy h:mm a')
+          : String(v);
+      }
+      case 'date': {
+        const d = typeof v === 'string' ? new Date(v) : (v as unknown as Date);
+        return d instanceof Date && !Number.isNaN(d.getTime())
+          ? formatDateFn(d, 'MMM dd, yyyy')
+          : String(v);
+      }
+      default:
+        return String(v);
+    }
+  };
+
   const renderDisplay = () => {
-    const formatted = formatDisplay
-      ? formatDisplay(value)
-      : value == null || value === ''
-        ? placeholder
-        : String(value);
+    const formatted = formatDisplay ? formatDisplay(value) : defaultFormatForVariant(value);
 
     if (display === 'pill') {
       const color =
@@ -281,9 +323,20 @@ export function InlineEditable<TValue = unknown>(
     }
   }, [validate, value, onSave, saving]);
 
-  // ── Inline TextField editor (text / number / date variants) ───────────
+  // ── Inline TextField editor (all text-input-based variants) ─────────
+  // Maps each variant to the matching HTML input type. Number-style
+  // variants (number, currency, percent) coerce strings to numbers on
+  // change; others pass through as strings.
   const renderInlineTextEditor = () => {
-    const inputType = variant === 'date' ? 'date' : variant === 'number' ? 'number' : 'text';
+    const inputType: React.InputHTMLAttributes<unknown>['type'] =
+      variant === 'date' ? 'date'
+      : variant === 'datetime' ? 'datetime-local'
+      : variant === 'number' || variant === 'currency' || variant === 'percent' ? 'number'
+      : variant === 'email' ? 'email'
+      : variant === 'phone' ? 'tel'
+      : variant === 'url' ? 'url'
+      : 'text';
+    const isNumeric = variant === 'number' || variant === 'currency' || variant === 'percent';
     return (
       <TextField
         type={inputType}
@@ -291,7 +344,7 @@ export function InlineEditable<TValue = unknown>(
         autoFocus
         onChange={(e) => {
           const raw = e.target.value;
-          const next = (variant === 'number' ? (raw === '' ? '' : Number(raw)) : raw) as unknown as TValue;
+          const next = (isNumeric ? (raw === '' ? '' : Number(raw)) : raw) as unknown as TValue;
           setDraft(next);
         }}
         onBlur={handleSave}
@@ -305,7 +358,10 @@ export function InlineEditable<TValue = unknown>(
         }}
         size="small"
         sx={{ minWidth: 140 }}
-        InputLabelProps={inputType === 'date' ? { shrink: true } : undefined}
+        InputLabelProps={
+          inputType === 'date' || inputType === 'datetime-local' ? { shrink: true } : undefined
+        }
+        inputProps={variant === 'percent' ? { min: 0, max: 100, step: 1 } : undefined}
         error={!!error}
         helperText={error || undefined}
         disabled={saving}
@@ -313,6 +369,23 @@ export function InlineEditable<TValue = unknown>(
     );
   };
 
+  // ── Boolean editor (checkbox — click-to-toggle-and-save) ─────────────
+  // Boolean doesn't fit the click-then-type-or-select model; clicking
+  // the checkbox toggles and saves immediately via commitNow.
+  const renderBooleanEditor = () => (
+    <Checkbox
+      checked={!!draft}
+      onChange={(e) => {
+        const next = e.target.checked as unknown as TValue;
+        setDraft(next);
+        commitNow(next);
+      }}
+      autoFocus
+      disabled={saving}
+      sx={{ p: 0.5, color: 'primary.contrastText', '&.Mui-checked': { color: 'primary.contrastText' } }}
+    />
+  );
+
   // ── Lock icon (hover-only when sensitive; always when locked-by-other) ──
   const renderLockBadge = () => {
     if (lockedFromRecord) {
@@ -349,8 +422,13 @@ export function InlineEditable<TValue = unknown>(
   // ── Render shell ────────────────────────────────────────────────────────
   // The .inline-editable-host class is the hover target for HOVER_LOCK_SX.
   // Display mode is always rendered (it doubles as the anchor for popovers);
-  // text-style editors replace it inline; menu/autocomplete float over it.
-  const editingTextStyle = mode === 'editing' && (variant === 'text' || variant === 'number' || variant === 'date');
+  // text-style editors replace it inline; menu/autocomplete float over it;
+  // boolean toggles a checkbox inline.
+  const TEXT_INPUT_VARIANTS: ReadonlyArray<InlineEditVariant> = [
+    'text', 'number', 'currency', 'percent', 'date', 'datetime', 'email', 'phone', 'url',
+  ];
+  const editingTextStyle = mode === 'editing' && TEXT_INPUT_VARIANTS.includes(variant);
+  const editingBooleanStyle = mode === 'editing' && variant === 'boolean';
 
   return (
     <>
@@ -400,7 +478,11 @@ export function InlineEditable<TValue = unknown>(
         }}
         onClick={mode === 'display' ? handleDisplayClick : undefined}
       >
-        {editingTextStyle ? renderInlineTextEditor() : renderDisplay()}
+        {editingTextStyle
+          ? renderInlineTextEditor()
+          : editingBooleanStyle
+            ? renderBooleanEditor()
+            : renderDisplay()}
         {mode === 'display' && renderLockBadge()}
       </Box>
 
diff --git a/financial_forecasting/frontend/src/hooks/useFieldPermission.ts b/financial_forecasting/frontend/src/hooks/useFieldPermission.ts
index d51772a3..de947c81 100644
--- a/financial_forecasting/frontend/src/hooks/useFieldPermission.ts
+++ b/financial_forecasting/frontend/src/hooks/useFieldPermission.ts
@@ -41,7 +41,7 @@ export interface FieldPermissionResult {
 }
 
 export interface UseFieldPermissionArgs {
-  /** Object type: 'Opportunity' | 'Account' | 'Contact' | 'Project' | 'Milestone' | 'Task' | 'Target' */
+  /** Object type: 'Opportunity' | 'Account' | 'Contact' | 'Project' | 'Milestone' | 'Task' | 'Target' | 'Activity' | ... */
   objectType: string;
   /** API field name (matches the sensitivity table key) */
   fieldName: string;
@@ -49,6 +49,16 @@ export interface UseFieldPermissionArgs {
   recordLock?: { locked_by: string; locked_at: string } | null;
   /** Optional display name for the user holding the record lock */
   recordLockedByName?: string | null;
+  /**
+   * Default sensitivity for unclassified (objectType, fieldName) pairs.
+   * Omit (or leave undefined) for hand-coded cells — unclassified fields get
+   * the fail-safe 'sensitive' unlock prompt. Schema-generated cells (via
+   * `buildSchemaColumns`) should pass 'safe' — SF already gates writes via
+   * field-level security server-side, and declaring every updateable field
+   * in the sensitivity table would be noisy. Explicit classifications in
+   * `fieldSensitivity.ts` always override this default.
+   */
+  defaultSensitivity?: FieldSensitivity;
 }
 
 export function useFieldPermission({
@@ -56,11 +66,12 @@ export function useFieldPermission({
   fieldName,
   recordLock,
   recordLockedByName,
+  defaultSensitivity,
 }: UseFieldPermissionArgs): FieldPermissionResult {
   const { can, isAdmin, sfUserId } = usePermissions();
 
   return useMemo(() => {
-    const classification = classifyField(objectType, fieldName);
+    const classification = classifyField(objectType, fieldName, defaultSensitivity);
 
     // Record-lock takes precedence over everything else — if another user holds
     // the lock, no field on this record is editable regardless of sensitivity.
@@ -117,5 +128,5 @@ export function useFieldPermission({
       canUnlock: true,
       lockTooltip: '',
     };
-  }, [objectType, fieldName, recordLock, recordLockedByName, can, isAdmin, sfUserId]);
+  }, [objectType, fieldName, recordLock, recordLockedByName, defaultSensitivity, can, isAdmin, sfUserId]);
 }
diff --git a/financial_forecasting/frontend/src/utils/fieldSensitivity.test.ts b/financial_forecasting/frontend/src/utils/fieldSensitivity.test.ts
index 03abd0ed..1e2b63eb 100644
--- a/financial_forecasting/frontend/src/utils/fieldSensitivity.test.ts
+++ b/financial_forecasting/frontend/src/utils/fieldSensitivity.test.ts
@@ -102,6 +102,41 @@ describe('classifyField', () => {
     });
   });
 
+  // A10 audit / mega-B: Commit 6 adds an optional defaultSensitivity arg so
+  // schema-generated cells (schemaColumns.tsx) can opt unclassified fields
+  // into 'safe' without declaring every SF-updateable field. Hand-coded
+  // call sites still fail safe.
+  describe('defaultSensitivity override for unclassified pairs', () => {
+    it("returns 'safe' when defaultSensitivity='safe' for unknown field", () => {
+      const c = classifyField('Account', 'CustomField_That_Isnt_Listed__c', 'safe');
+      expect(c.sensitivity).toBe('safe');
+      // No lockReason when defaulting safe — the cell edits freely without
+      // a "not classified" tooltip.
+      expect(c.lockReason).toBeUndefined();
+    });
+
+    it("returns 'sensitive' fail-safe when defaultSensitivity is omitted", () => {
+      const c = classifyField('Account', 'CustomField_That_Isnt_Listed__c');
+      expect(c.sensitivity).toBe('sensitive');
+      expect(c.lockReason).toContain('not classified');
+    });
+
+    it('explicit classification always wins over defaultSensitivity', () => {
+      // Opportunity.StageName is 'sensitive' in the table — passing 'safe'
+      // as the default must not downgrade it.
+      const c = classifyField('Opportunity', 'StageName', 'safe');
+      expect(c.sensitivity).toBe('sensitive');
+      expect(c.lockReason).toBeTruthy();
+    });
+
+    it('explicit safe in the table also wins over defaultSensitivity=sensitive', () => {
+      // Opportunity.Name is 'safe' in the table — a caller passing
+      // 'sensitive' as the default shouldn't re-lock it.
+      const c = classifyField('Opportunity', 'Name', 'sensitive');
+      expect(c.sensitivity).toBe('safe');
+    });
+  });
+
   // Guard against the "silent sensitive fallback" regression: every domain
   // cell (StageCell, OwnerCell, …) ships with a default (objectType,
   // fieldName) pair. If that default isn't in FIELD_CLASSIFICATIONS, the
diff --git a/financial_forecasting/frontend/src/utils/fieldSensitivity.ts b/financial_forecasting/frontend/src/utils/fieldSensitivity.ts
index 79f71667..219ceabf 100644
--- a/financial_forecasting/frontend/src/utils/fieldSensitivity.ts
+++ b/financial_forecasting/frontend/src/utils/fieldSensitivity.ts
@@ -119,17 +119,39 @@ const FIELD_CLASSIFICATIONS: Record<string, Record<string, FieldClassification>>
 
 /**
  * Look up the sensitivity classification for a (objectType, fieldName) pair.
+ *
  * Unknown pairs fail safe to `sensitive` so untriaged fields still require
- * an unlock action.
+ * an unlock action — the primitive assumption is that a cell hand-coded
+ * with an explicit (objectType, fieldName) deserves a deliberate entry.
+ *
+ * Schema-generated cells (via `buildSchemaColumns` in utils/schemaColumns.tsx)
+ * emit renderCells for every SF `updateable` field — tens of fields per entity.
+ * Declaring every one of them would be brittle and noisy, and SF already
+ * enforces edit permission on the server. Those callers pass
+ * `defaultSensitivity: 'safe'` to opt out of the fail-safe for fields they
+ * know came from SF's own updateable list. Hand-coded call sites (no third
+ * arg, or `defaultSensitivity` omitted) keep the fail-safe behavior.
+ *
+ * Explicit entries in FIELD_CLASSIFICATIONS always win — so a schema-
+ * generated cell on `Opportunity.StageName` still reads `'sensitive'`
+ * regardless of the default, because StageName is in the table.
  */
-export function classifyField(objectType: string, fieldName: string): FieldClassification {
+export function classifyField(
+  objectType: string,
+  fieldName: string,
+  defaultSensitivity: FieldSensitivity = 'sensitive',
+): FieldClassification {
   const objectMap = FIELD_CLASSIFICATIONS[objectType];
   const classification = objectMap?.[fieldName];
   if (!classification) {
-    return {
-      sensitivity: 'sensitive',
-      lockReason: `${fieldName} is not classified. Click to confirm the edit.`,
-    };
+    if (defaultSensitivity === 'sensitive') {
+      return {
+        sensitivity: 'sensitive',
+        lockReason: `${fieldName} is not classified. Click to confirm the edit.`,
+      };
+    }
+    // defaultSensitivity === 'safe' — no lockReason; the cell edits freely.
+    return { sensitivity: defaultSensitivity };
   }
   return classification;
 }

From 7124853ef08461c3cd7a99025d76439f001a2973 Mon Sep 17 00:00:00 2001
From: JP <jp@JPs-Pursuit-MacBook-Air.local>
Date: Thu, 23 Apr 2026 14:01:26 -0400
Subject: [PATCH 07/11] fix(inline-edit): stop DataGrid cellMouseDown from
 stealing focus
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Root cause (verified at MUI source, not speculation): GridCell attaches
onMouseDown → publishEvent('cellMouseDown') at node_modules/@mui/x-data-grid/
modern/components/cell/GridCell.js:320. useGridFocus.js:268 stores the cell
params on mousedown; its document-level mouseup listener (line 271-312) calls
setCellFocus → apiRef.current.forceUpdate() (line 73), shifting DOM focus to
the cell wrapper. That steals focus from our autoFocus'd TextField inside
renderCell, triggering onBlur={handleSave} with draft===value → silent revert
to display mode. User perception: clicking an Amount/Probability cell does
nothing.

Select/autocomplete variants already worked because their Menu/Popover is
anchored outside the cell DOM, so focus steal doesn't affect them.

Fix: stopPropagation on the outer Box onMouseDown when in display mode and
the field is editable. Neutralizes DataGrid's path; DataGrid's "mouseup
target inside focused cell" branch (useGridFocus.js:291-294) handles the
mouseup without changing focus. Every text-input variant (text, number,
currency, percent, date, datetime, email, phone, url) now enters edit mode
cleanly inside a DataGrid cell.

17/17 InlineEditable tests still pass (isolated mounts don't exercise
DataGrid). JP smoke-tests Amount/Probability/Name/CloseDate on Details tab
post-deploy; if anything surprises, #7 is paused and we re-diagnose.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../components/inline-edit/InlineEditable.tsx    | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx b/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
index 3e99a60e..811e9938 100644
--- a/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
+++ b/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
@@ -477,6 +477,22 @@ export function InlineEditable<TValue = unknown>(
           }),
         }}
         onClick={mode === 'display' ? handleDisplayClick : undefined}
+        onMouseDown={(e) => {
+          // Stop the bubble so MUI DataGrid's GridCell.onMouseDown publishEvent('cellMouseDown')
+          // (node_modules/@mui/x-data-grid/.../components/cell/GridCell.js:320) doesn't record
+          // this click. That handler pairs with a document-level mouseup listener in useGridFocus
+          // that runs setCellFocus → forceUpdate, which steals focus from our autoFocus'd
+          // TextField during the edit-mode transition (InlineEditable.tsx:350 onBlur=handleSave
+          // then fires with draft===value → silent revert to display mode). Stopping the
+          // mousedown bubble neutralizes that path; DataGrid's "mouseup target inside focused
+          // cell" branch (useGridFocus.js:291-294) handles the mouseup gracefully.
+          //
+          // Gated on display-mode + editable so we don't block the inner Menu/Popover/TextField
+          // from receiving their own mousedowns (those are rendered outside this Box), and don't
+          // interfere once we've entered edit/unlock mode. Without this gate, select/autocomplete
+          // variants (which already worked because their popover is detached) would break.
+          if (mode === 'display' && canEditAtAll) e.stopPropagation();
+        }}
       >
         {editingTextStyle
           ? renderInlineTextEditor()

From afb608c4b14beec6ec69cebe883cf5988f408335 Mon Sep 17 00:00:00 2001
From: JP <jp@JPs-Pursuit-MacBook-Air.local>
Date: Thu, 23 Apr 2026 14:05:38 -0400
Subject: [PATCH 08/11] feat(inline-edit): per-row ownerGate for schema-driven
 cells
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Mirror the backend's _enforce_record_ownership helper (main.py:862-923) on
the frontend so schema-driven cells on Accounts/Contacts/Tasks/Activities
surface the correct permission state instead of letting the user click,
type, tab out, then see a sanitized "Failed to update" toast for records
they don't own.

useFieldPermission gains an optional ownerGate: { rowOwnerId, editAllPermission? }
arg. When set, the hook resolves three bypasses in order:
  1. isAdmin (manage_users_roles)
  2. editAllPermission match (e.g. 'edit_all_opportunities')
  3. rowOwnerId === sfUserId
If none match, the hook returns recordLockedByOther=true with a stable
"Only the record owner (or an admin) can edit this field." tooltip.
InlineEditable's existing canEditAtAll = !readOnly && !lockedFromRecord
logic then short-circuits handleDisplayClick — clicks are inert, no save
ever attempted, no surprise error toast.

Fail-safe semantics match the backend: missing sfUserId or missing
rowOwnerId both deny (cannot evaluate ownership → deny, safer than permit,
matches main.py:907-912). Since every Account/Contact/Task/Opportunity SOQL
select already fetches OwnerId (salesforce_schema.py ACCOUNT_FETCHED_FIELDS,
CONTACT_FETCHED_FIELDS + main.py:1432 task select), rowOwnerId will be
populated in practice.

Additive: existing call sites that omit ownerGate see no behavior change.
Schema-driven cells (commit #7 next) pass it per-row.

4 new InlineEditable tests exercise each bypass branch (non-owner denies,
admin allows, edit-all permission allows, owner allows). 21/21
InlineEditable tests + 39/39 fieldSensitivity tests pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../inline-edit/InlineEditable.test.tsx       | 66 +++++++++++++++++++
 .../components/inline-edit/InlineEditable.tsx |  2 +
 .../frontend/src/hooks/useFieldPermission.ts  | 56 +++++++++++++++-
 3 files changed, 123 insertions(+), 1 deletion(-)

diff --git a/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.test.tsx b/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.test.tsx
index 4c0e5483..b37074f2 100644
--- a/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.test.tsx
+++ b/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.test.tsx
@@ -227,3 +227,69 @@ describe('InlineEditable — record-level lock by another user', () => {
     expect(screen.getByDisplayValue('ACME Corp')).toBeInTheDocument();
   });
 });
+
+describe('InlineEditable — per-row ownerGate', () => {
+  // Mirrors main.py:_enforce_record_ownership: non-admin / non-edit-all users
+  // may only edit records they own. Schema-generated cells pass ownerGate
+  // per-row; hand-coded cells omit it and fall through to sensitivity-only.
+  it('locks a safe field when the user is not the record owner (non-admin, no edit-all)', () => {
+    mockPermissions.sfUserId = 'user-1';
+    mockPermissions.isAdmin = false;
+    mockPermissions.can.mockReturnValue(false);
+    render(
+      <InlineEditable
+        {...safeProps}
+        value="ACME Corp"
+        ownerGate={{ rowOwnerId: 'other-user', editAllPermission: 'edit_all_opportunities' }}
+      />,
+    );
+    fireEvent.click(screen.getByText('ACME Corp'));
+    // Should NOT enter edit mode — ownerGate blocks non-owners.
+    expect(screen.queryByDisplayValue('ACME Corp')).not.toBeInTheDocument();
+  });
+
+  it('allows edit when the user is admin, regardless of ownership', () => {
+    mockPermissions.sfUserId = 'user-1';
+    mockPermissions.isAdmin = true;
+    render(
+      <InlineEditable
+        {...safeProps}
+        value="ACME Corp"
+        ownerGate={{ rowOwnerId: 'other-user' }}
+      />,
+    );
+    fireEvent.click(screen.getByText('ACME Corp'));
+    // Admin bypass: free edit on safe field.
+    expect(screen.getByDisplayValue('ACME Corp')).toBeInTheDocument();
+  });
+
+  it('allows edit when the user holds the edit-all permission for this resource', () => {
+    mockPermissions.sfUserId = 'user-1';
+    mockPermissions.isAdmin = false;
+    mockPermissions.can.mockImplementation((k: string) => k === 'edit_all_opportunities');
+    render(
+      <InlineEditable
+        {...safeProps}
+        value="ACME Corp"
+        ownerGate={{ rowOwnerId: 'other-user', editAllPermission: 'edit_all_opportunities' }}
+      />,
+    );
+    fireEvent.click(screen.getByText('ACME Corp'));
+    expect(screen.getByDisplayValue('ACME Corp')).toBeInTheDocument();
+  });
+
+  it('allows edit when the user owns the row', () => {
+    mockPermissions.sfUserId = 'user-1';
+    mockPermissions.isAdmin = false;
+    mockPermissions.can.mockReturnValue(false);
+    render(
+      <InlineEditable
+        {...safeProps}
+        value="ACME Corp"
+        ownerGate={{ rowOwnerId: 'user-1' }}
+      />,
+    );
+    fireEvent.click(screen.getByText('ACME Corp'));
+    expect(screen.getByDisplayValue('ACME Corp')).toBeInTheDocument();
+  });
+});
diff --git a/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx b/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
index 811e9938..f6baa314 100644
--- a/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
+++ b/financial_forecasting/frontend/src/components/inline-edit/InlineEditable.tsx
@@ -137,6 +137,7 @@ export function InlineEditable<TValue = unknown>(
     recordLockedByName,
     readOnly,
     defaultSensitivity,
+    ownerGate,
   } = props;
 
   const permission = useFieldPermission({
@@ -145,6 +146,7 @@ export function InlineEditable<TValue = unknown>(
     recordLock,
     recordLockedByName,
     defaultSensitivity,
+    ownerGate,
   });
 
   // Editor state: which mode we're in right now.
diff --git a/financial_forecasting/frontend/src/hooks/useFieldPermission.ts b/financial_forecasting/frontend/src/hooks/useFieldPermission.ts
index de947c81..e9fd5b13 100644
--- a/financial_forecasting/frontend/src/hooks/useFieldPermission.ts
+++ b/financial_forecasting/frontend/src/hooks/useFieldPermission.ts
@@ -59,6 +59,28 @@ export interface UseFieldPermissionArgs {
    * `fieldSensitivity.ts` always override this default.
    */
   defaultSensitivity?: FieldSensitivity;
+  /**
+   * Per-row ownership gate. Mirrors the backend's `_enforce_record_ownership`
+   * helper (financial_forecasting/main.py:862) — PATCH is rejected with 403
+   * unless the caller is (a) admin ('manage_users_roles'), (b) holds the
+   * `editAllPermission` key for this resource (Opportunity/Payment only —
+   * Account/Contact/Task have no edit-all bypass), or (c) IS the row's Owner.
+   *
+   * When `ownerGate.rowOwnerId` is provided and the caller fails all three
+   * bypasses, this hook returns a sticky-lock result with
+   * `recordLockedByOther: true` + `canUnlock: false` — so the cell shows a
+   * permanent lock and clicks are inert. Without this, a non-admin user
+   * clicking an unowned cell would type, tab out, then see "Failed to update"
+   * from the sanitized server error with no explanation.
+   *
+   * Omit this arg entirely for cells whose ownership is already enforced
+   * upstream (e.g., Opportunities.tsx already filters OwnerId-free via the
+   * checkboxSelection/lockMap path). Schema-driven cells pass it per-row.
+   */
+  ownerGate?: {
+    rowOwnerId: string | null | undefined;
+    editAllPermission?: string;
+  };
 }
 
 export function useFieldPermission({
@@ -67,6 +89,7 @@ export function useFieldPermission({
   recordLock,
   recordLockedByName,
   defaultSensitivity,
+  ownerGate,
 }: UseFieldPermissionArgs): FieldPermissionResult {
   const { can, isAdmin, sfUserId } = usePermissions();
 
@@ -90,6 +113,27 @@ export function useFieldPermission({
       };
     }
 
+    // Owner gate: non-admin / non-edit-all users can only edit records they own.
+    // Mirrors backend's `_enforce_record_ownership`. Missing sfUserId → cannot
+    // evaluate ownership → deny, matching backend (main.py:907-912). A null
+    // rowOwnerId (record fetched without OwnerId, or record has no owner) ALSO
+    // denies for the same safer-to-fail reason.
+    if (ownerGate) {
+      const hasEditAll = !!ownerGate.editAllPermission && can(ownerGate.editAllPermission);
+      const isOwner = !!sfUserId && !!ownerGate.rowOwnerId && ownerGate.rowOwnerId === sfUserId;
+      const ownerCanEdit = isAdmin || hasEditAll || isOwner;
+      if (!ownerCanEdit) {
+        return {
+          sensitivity: classification.sensitivity,
+          requiresUnlock: false,
+          recordLockedByOther: true,
+          recordLockedBy: 'record owner',
+          canUnlock: false,
+          lockTooltip: 'Only the record owner (or an admin) can edit this field.',
+        };
+      }
+    }
+
     // Permission-gated: the lock is sticky if the user lacks the permission.
     if (classification.sensitivity === 'permission-gated') {
       const allowed = isAdmin || (
@@ -128,5 +172,15 @@ export function useFieldPermission({
       canUnlock: true,
       lockTooltip: '',
     };
-  }, [objectType, fieldName, recordLock, recordLockedByName, defaultSensitivity, can, isAdmin, sfUserId]);
+  }, [
+    objectType,
+    fieldName,
+    recordLock,
+    recordLockedByName,
+    defaultSensitivity,
+    ownerGate,
+    can,
+    isAdmin,
+    sfUserId,
+  ]);
 }

From 1426fade1f38a1febe51c076b0c90e76a11649ce Mon Sep 17 00:00:00 2001
From: JP <jp@JPs-Pursuit-MacBook-Air.local>
Date: Thu, 23 Apr 2026 14:17:03 -0400
Subject: [PATCH 09/11] feat(schemaColumns): emit InlineEditable renderCells
 with ownerGate
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Rewrites schemaColumns.tsx (267 → 387 LOC) to emit an <InlineEditable>
renderCell for every SF-updateable field instead of setting DataGrid's
native `editable: true` + renderEditCell. Reference fields targeting
Account / User use the mature inline-edit AccountCell / OwnerCell (which
consume preloaded accounts[] / users[] passed via options, avoiding the
per-row fetch-on-mount pattern of the old EditCells). Other reference
types (Contact, Lead, polymorphic WhatId / WhoId) stay display-only;
editing those fields requires opening the entity dialog. Address compound
fields render as a comma-joined string (edit via dialog per-component).

New SchemaColumnOptions:
  - entityType (required) — 'Account' | 'Contact' | 'Task' | 'Activity'
  - onSaveField (required) — (recordId, field, value) => Promise<void>
  - canEditObject (required) — page-level permission gate
  - sfUserId (required) — current user's SF user ID from usePermissions()
  - editAllPermission (optional) — for Opp/Payment 'edit_all_*' bypass
  - accounts (optional) — preloaded Account[] for reference autocomplete
  - users (optional) — preloaded User[] for Owner autocomplete
  - forceHide / overrides — preserved from the old signature

Each emitted InlineEditable receives:
  - defaultSensitivity='safe' — trust SF updateable + server-side FLS.
    Explicit classifications in fieldSensitivity.ts still win (e.g.
    Opportunity.StageName stays sensitive). See the top-of-file invariant
    comment — flipping this back to 'sensitive' would lock ~100 fields on
    first click.
  - readOnly driven by !canEditObject || !field.updateable || field.calculated
  - ownerGate={{rowOwnerId, editAllPermission}} — per-row owner check
    mirroring _enforce_record_ownership (main.py:862). Non-owner clicks
    no-op without hitting the API.
  - required-field client validator when field.nillable === false, to
    prevent round-tripping a REQUIRED_FIELD_MISSING that the backend
    sanitizes to a generic "Failed to update X".

Call-site updates on Accounts / Contacts / Tasks:
  - Pull sfUserId from usePermissions() (already exposed).
  - Add useQuery('users', …, staleTime: 10min) for Owner autocomplete.
    Tasks.tsx additionally gains useQuery('accounts', …) for WhatId.
  - Replace the old handleCellEdit (processRowUpdate-based newRow/oldRow
    diff) with a handleSaveField(recordId, field, value) that dispatches
    to apiService.updateAccount / updateContact / updateTask. Errors
    rethrow so InlineEditable surfaces them inline (primitive's try/catch
    at InlineEditable.tsx:220-227).
  - Remove DataGrid's editMode="cell" / processRowUpdate /
    onProcessRowUpdateError / isCellEditable props — InlineEditable owns
    the flow end-to-end.

AccountCell + OwnerCell gain an optional ownerGate prop forwarded verbatim
to InlineEditable (two lines per cell). Hand-coded call sites in
Opportunities/columns.tsx still omit it and keep their existing per-page
lockMap gating; schema-driven cells pass it per-row.

New frontend/src/utils/schemaColumns.test.tsx (18 tests):
  - 11 invariant tests (SYSTEM_FIELDS filter, dotted pseudo-field skip,
    forceHide, alphabetical sort, number/currency/percent/date/datetime/
    boolean/multipicklist type mapping, per-field overrides merged).
    These lock pre-rewrite semantics.
  - 7 new-behavior tests (renderCell emits InlineEditable, onSaveField
    fires with (id, field, value), non-owner blocked via ownerGate,
    reference→Account → AccountCell, reference→User → OwnerCell,
    calculated/readOnly fields stay non-editable).

Verification: 106/106 tests pass across schemaColumns + InlineEditable +
fieldSensitivity + PipelineFunnel. Full suite: 453/460 pass. The 7
remaining failures are pre-existing date-dependent tests in files this
commit does not touch — 4 calculatePaymentDate DST in Opportunities/
helpers.test.ts (PINNED), 3 in weeklyPrioritiesHelpers.test.ts +
WeeklyPriorities.test.tsx that hardcode "30-day window starting March 16"
against today's date (2026-04-23). Unrelated to this commit.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../inline-edit/cells/AccountCell.tsx         |  13 +
 .../inline-edit/cells/OwnerCell.tsx           |  11 +
 .../frontend/src/pages/Accounts.tsx           |  85 ++---
 .../frontend/src/pages/Contacts.tsx           |  87 +++--
 .../frontend/src/pages/Tasks.tsx              |  90 ++---
 .../frontend/src/utils/schemaColumns.test.tsx | 323 +++++++++++++++++
 .../frontend/src/utils/schemaColumns.tsx      | 325 +++++++++++++-----
 7 files changed, 722 insertions(+), 212 deletions(-)
 create mode 100644 financial_forecasting/frontend/src/utils/schemaColumns.test.tsx

diff --git a/financial_forecasting/frontend/src/components/inline-edit/cells/AccountCell.tsx b/financial_forecasting/frontend/src/components/inline-edit/cells/AccountCell.tsx
index 0df6ac3c..3a234788 100644
--- a/financial_forecasting/frontend/src/components/inline-edit/cells/AccountCell.tsx
+++ b/financial_forecasting/frontend/src/components/inline-edit/cells/AccountCell.tsx
@@ -32,6 +32,17 @@ interface AccountCellProps {
   recordLock?: { locked_by: string; locked_at: string } | null;
   recordLockedByName?: string | null;
   readOnly?: boolean;
+  /**
+   * Per-row ownership gate. Forwarded to InlineEditable → useFieldPermission.
+   * Schema-driven cells (via buildSchemaColumns) pass this per-row; hand-coded
+   * call sites (Opportunities/columns.tsx) omit it because ownership is already
+   * gated upstream via the page-level lockMap. See useFieldPermission.ts for
+   * the bypass semantics (admin, editAllPermission, or rowOwnerId === sfUserId).
+   */
+  ownerGate?: {
+    rowOwnerId: string | null | undefined;
+    editAllPermission?: string;
+  };
 }
 
 export const AccountCell: React.FC<AccountCellProps> = ({
@@ -44,6 +55,7 @@ export const AccountCell: React.FC<AccountCellProps> = ({
   recordLock,
   recordLockedByName,
   readOnly,
+  ownerGate,
 }) => {
   const options: InlineEditableOption[] = useMemo(
     () =>
@@ -83,6 +95,7 @@ export const AccountCell: React.FC<AccountCellProps> = ({
       recordLock={recordLock}
       recordLockedByName={recordLockedByName}
       readOnly={readOnly}
+      ownerGate={ownerGate}
     />
   );
 };
diff --git a/financial_forecasting/frontend/src/components/inline-edit/cells/OwnerCell.tsx b/financial_forecasting/frontend/src/components/inline-edit/cells/OwnerCell.tsx
index c4eee0e5..cf519809 100644
--- a/financial_forecasting/frontend/src/components/inline-edit/cells/OwnerCell.tsx
+++ b/financial_forecasting/frontend/src/components/inline-edit/cells/OwnerCell.tsx
@@ -30,6 +30,15 @@ interface OwnerCellProps {
   recordLock?: { locked_by: string; locked_at: string } | null;
   recordLockedByName?: string | null;
   readOnly?: boolean;
+  /**
+   * Per-row ownership gate — forwarded to InlineEditable → useFieldPermission.
+   * Schema-driven cells pass this per-row; hand-coded call sites may omit it
+   * when ownership is gated upstream. See useFieldPermission.ts for semantics.
+   */
+  ownerGate?: {
+    rowOwnerId: string | null | undefined;
+    editAllPermission?: string;
+  };
 }
 
 export const OwnerCell: React.FC<OwnerCellProps> = ({
@@ -41,6 +50,7 @@ export const OwnerCell: React.FC<OwnerCellProps> = ({
   recordLock,
   recordLockedByName,
   readOnly,
+  ownerGate,
 }) => {
   const options: InlineEditableOption[] = useMemo(() => {
     const sorted = [...users].sort((a, b) => {
@@ -77,6 +87,7 @@ export const OwnerCell: React.FC<OwnerCellProps> = ({
       recordLock={recordLock}
       recordLockedByName={recordLockedByName}
       readOnly={readOnly}
+      ownerGate={ownerGate}
     />
   );
 };
diff --git a/financial_forecasting/frontend/src/pages/Accounts.tsx b/financial_forecasting/frontend/src/pages/Accounts.tsx
index 54140b70..63b78b17 100644
--- a/financial_forecasting/frontend/src/pages/Accounts.tsx
+++ b/financial_forecasting/frontend/src/pages/Accounts.tsx
@@ -176,7 +176,7 @@ const Accounts: React.FC = () => {
   const [editAccountId, setEditAccountId] = useState<string | null>(null);
 
   const queryClient = useQueryClient();
-  const { can, isAdmin } = usePermissions();
+  const { can, isAdmin, sfUserId } = usePermissions();
   const canEdit = isAdmin || can('edit_accounts');
   const { pushDialog } = useDialogStack();
   const [searchParams] = useSearchParams();
@@ -209,6 +209,17 @@ const Accounts: React.FC = () => {
     }
   );
 
+  // Fetch users for schema-driven OwnerId reference autocomplete. One call
+  // per page mount; react-query dedupes across sibling tabs.
+  const { data: usersData } = useQuery(
+    'users',
+    async () => {
+      const response = await apiService.getUsers({ limit: 1000 });
+      return response.data ?? [];
+    },
+    { staleTime: 10 * 60 * 1000 },
+  );
+
   // Fetch schema for Account object
   const { data: schemaData } = useQuery(
     'account-schema',
@@ -395,11 +406,41 @@ const Accounts: React.FC = () => {
     createAccountMutation.mutate(newAccountData);
   };
 
+  // ── Inline save handler — used by schemaColumns InlineEditable cells. ───
+
+  const handleSaveField = useCallback(
+    async (recordId: string, field: string, newValue: unknown) => {
+      const loadingToast = toast.loading('Saving to Salesforce...');
+      try {
+        await apiService.updateAccount(recordId, { [field]: newValue as any });
+        toast.success('Saved!', { id: loadingToast, duration: 2000 });
+        // Invalidate after a short delay so SF's workflow side-effects settle
+        // before we re-query (mirrors the prior handleCellEdit cadence).
+        setTimeout(() => {
+          queryClient.invalidateQueries('accounts');
+          queryClient.invalidateQueries('opportunities-for-accounts');
+        }, 1000);
+      } catch (error: any) {
+        toast.error(`Failed: ${error.response?.data?.detail || error.message}`, { id: loadingToast });
+        throw error; // re-throw so InlineEditable surfaces the error inline
+      }
+    },
+    [queryClient],
+  );
+
   // ── Schema-driven columns ────────────────────────────────────────────────
 
   const schemaColumns = useMemo(() => {
     if (!schemaData?.fields) return [];
     return buildSchemaColumns(schemaData.fields as SchemaField[], {
+      entityType: 'Account',
+      onSaveField: handleSaveField,
+      canEditObject: canEdit,
+      sfUserId,
+      accounts,
+      users: usersData ?? [],
+      // Account has no edit-all permission key in PERMISSION_KEYS — only
+      // admins or the record owner may edit (main.py:_enforce_record_ownership).
       overrides: new Map([
         ['Name', {
           flex: 2,
@@ -420,7 +461,7 @@ const Accounts: React.FC = () => {
         }],
       ]),
     });
-  }, [schemaData]);
+  }, [schemaData, handleSaveField, canEdit, sfUserId, accounts, usersData]);
 
   // Assemble the final columns: computed columns + schema columns + edit action
   const columns = useMemo(() => {
@@ -575,39 +616,6 @@ const Accounts: React.FC = () => {
     localStorage.setItem(COLUMN_STORAGE_KEY, JSON.stringify(newModel));
   }, []);
 
-  // ── Inline cell editing handler ──────────────────────────────────────────
-
-  const handleCellEdit = async (newRow: any, oldRow: any) => {
-    const updates: Record<string, any> = {};
-    Object.keys(newRow).forEach((key) => {
-      if (newRow[key] !== oldRow[key] && key !== 'Id' && key !== 'id') {
-        // Skip nested relationship objects (Owner, RecordType, etc.)
-        if (typeof newRow[key] === 'object' && newRow[key] !== null && !(newRow[key] instanceof Date)) return;
-        // Convert Date to ISO date string
-        if (newRow[key] instanceof Date) {
-          updates[key] = newRow[key].toISOString().split('T')[0];
-        } else {
-          updates[key] = newRow[key];
-        }
-      }
-    });
-    if (Object.keys(updates).length === 0) return newRow;
-
-    const loadingToast = toast.loading('Saving to Salesforce...');
-    try {
-      await apiService.updateAccount(newRow.Id || newRow.id, updates);
-      toast.success('Saved!', { id: loadingToast, duration: 2000 });
-      setTimeout(() => {
-        queryClient.invalidateQueries('accounts');
-        queryClient.invalidateQueries('opportunities-for-accounts');
-      }, 1000);
-      return newRow;
-    } catch (error: any) {
-      toast.error(`Failed: ${error.response?.data?.detail || error.message}`, { id: loadingToast });
-      return oldRow;
-    }
-  };
-
   // Get opportunities for selected account
   const accountOpportunities = selectedAccount
     ? opportunities?.filter((opp: Opportunity) => opp.AccountId === (selectedAccount.id || selectedAccount.Id)) || []
@@ -726,13 +734,6 @@ const Accounts: React.FC = () => {
               columns={columns}
               loading={accountsLoading || oppsLoading}
               getRowId={(row) => row.id || row.Id}
-              editMode="cell"
-              processRowUpdate={handleCellEdit}
-              onProcessRowUpdateError={console.error}
-              isCellEditable={(params) => {
-                if (!canEdit) return false;
-                return params.colDef.editable === true;
-              }}
               columnVisibilityModel={columnVisibilityModel}
               onColumnVisibilityModelChange={handleColumnVisibilityChange}
               pagination
diff --git a/financial_forecasting/frontend/src/pages/Contacts.tsx b/financial_forecasting/frontend/src/pages/Contacts.tsx
index a582038d..33860aef 100644
--- a/financial_forecasting/frontend/src/pages/Contacts.tsx
+++ b/financial_forecasting/frontend/src/pages/Contacts.tsx
@@ -69,7 +69,7 @@ const Contacts: React.FC = () => {
   });
 
   const queryClient = useQueryClient();
-  const { can, isAdmin } = usePermissions();
+  const { can, isAdmin, sfUserId } = usePermissions();
   const canEdit = isAdmin || can('edit_contacts');
   const { pushDialog } = useDialogStack();
   const [searchParams] = useSearchParams();
@@ -90,7 +90,7 @@ const Contacts: React.FC = () => {
     }
   );
 
-  // Fetch accounts for dropdown
+  // Fetch accounts for dropdown + schema-driven AccountId reference autocomplete.
   const { data: accountsData, isLoading: accountsLoading } = useQuery(
     'accounts',
     async () => {
@@ -99,6 +99,16 @@ const Contacts: React.FC = () => {
     }
   );
 
+  // Fetch users for schema-driven OwnerId reference autocomplete.
+  const { data: usersData } = useQuery(
+    'users',
+    async () => {
+      const response = await apiService.getUsers({ limit: 1000 });
+      return response.data ?? [];
+    },
+    { staleTime: 10 * 60 * 1000 },
+  );
+
   // Fetch contact schema for dynamic columns
   const { data: contactSchemaData } = useQuery(
     'contact-schema',
@@ -113,12 +123,40 @@ const Contacts: React.FC = () => {
   const contacts = Array.isArray(contactsData) ? contactsData : (contactsData?.contacts || []);
   const accounts = Array.isArray(accountsData) ? accountsData : (accountsData?.accounts || []);
 
+  // ── Inline save handler — used by schemaColumns InlineEditable cells. ───
+
+  const handleSaveField = useCallback(
+    async (recordId: string, field: string, newValue: unknown) => {
+      const loadingToast = toast.loading('Saving to Salesforce...');
+      try {
+        await apiService.updateContact(recordId, { [field]: newValue as any });
+        toast.success('Saved!', { id: loadingToast, duration: 2000 });
+        setTimeout(() => {
+          queryClient.invalidateQueries('all-contacts');
+          queryClient.invalidateQueries(['account-contacts']);
+        }, 1000);
+      } catch (error: any) {
+        toast.error(`Failed: ${error.response?.data?.detail || error.message}`, { id: loadingToast });
+        throw error;
+      }
+    },
+    [queryClient],
+  );
+
   // ── Schema-driven columns ──────────────────────────────────────────────
 
   const schemaColumns = useMemo(() => {
     if (!contactSchemaData?.fields) return [];
-    return buildSchemaColumns(contactSchemaData.fields as SchemaField[]);
-  }, [contactSchemaData]);
+    return buildSchemaColumns(contactSchemaData.fields as SchemaField[], {
+      entityType: 'Contact',
+      onSaveField: handleSaveField,
+      canEditObject: canEdit,
+      sfUserId,
+      accounts,
+      users: usersData ?? [],
+      // Contact has no edit-all permission key — admin or owner only.
+    });
+  }, [contactSchemaData, handleSaveField, canEdit, sfUserId, accounts, usersData]);
 
   const columns = useMemo(() => {
     const action = editActionColumn(
@@ -160,40 +198,6 @@ const Contacts: React.FC = () => {
     localStorage.setItem(COLUMN_STORAGE_KEY, JSON.stringify(newModel));
   }, []);
 
-  // ── Inline cell editing ────────────────────────────────────────────────
-
-  const handleCellEdit = async (newRow: any, oldRow: any) => {
-    const updates: Record<string, any> = {};
-    Object.keys(newRow).forEach((key) => {
-      if (newRow[key] !== oldRow[key] && key !== 'Id') {
-        // Skip nested relationship objects
-        if (typeof newRow[key] === 'object' && newRow[key] !== null && !(newRow[key] instanceof Date)) return;
-        if (newRow[key] instanceof Date) {
-          updates[key] = newRow[key].toISOString().split('T')[0];
-        } else {
-          updates[key] = newRow[key];
-        }
-      }
-    });
-    if (Object.keys(updates).length === 0) return newRow;
-
-    const loadingToast = toast.loading('Saving to Salesforce...');
-    try {
-      await apiService.updateContact(newRow.Id, updates);
-      toast.success('Saved!', { id: loadingToast, duration: 2000 });
-      setTimeout(() => {
-        queryClient.invalidateQueries('all-contacts');
-        if (newRow.AccountId) {
-          queryClient.invalidateQueries(['account-contacts', newRow.AccountId]);
-        }
-      }, 1000);
-      return newRow;
-    } catch (error: any) {
-      toast.error(`Failed: ${error.response?.data?.detail || error.message}`, { id: loadingToast });
-      return oldRow;
-    }
-  };
-
   // Create contact mutation
   const createContactMutation = useMutation(
     async (data: any) => {
@@ -298,13 +302,6 @@ const Contacts: React.FC = () => {
               columns={columns}
               loading={contactsLoading}
               getRowId={(row) => row.Id}
-              editMode="cell"
-              processRowUpdate={handleCellEdit}
-              onProcessRowUpdateError={console.error}
-              isCellEditable={(params) => {
-                if (!canEdit) return false;
-                return params.colDef.editable === true;
-              }}
               columnVisibilityModel={columnVisibilityModel}
               onColumnVisibilityModelChange={handleColumnVisibilityChange}
               pagination
diff --git a/financial_forecasting/frontend/src/pages/Tasks.tsx b/financial_forecasting/frontend/src/pages/Tasks.tsx
index 95fa0fe0..c41376ac 100644
--- a/financial_forecasting/frontend/src/pages/Tasks.tsx
+++ b/financial_forecasting/frontend/src/pages/Tasks.tsx
@@ -34,7 +34,7 @@ const DEFAULT_VISIBLE_TASKS = new Set([
 
 const Tasks: React.FC = () => {
   const queryClient = useQueryClient();
-  const { can, isAdmin } = usePermissions();
+  const { can, isAdmin, sfUserId } = usePermissions();
   const canEdit = isAdmin || can('edit_own_tasks');
   const [searchParams] = useSearchParams();
   const searchFromUrl = searchParams.get('search') || '';
@@ -71,14 +71,60 @@ const Tasks: React.FC = () => {
     { staleTime: 30 * 60 * 1000 }
   );
 
+  // Preload accounts + users for Task.WhatId / Task.OwnerId reference autocomplete.
+  const { data: accountsData } = useQuery(
+    'accounts',
+    async () => {
+      const response = await apiService.getAccounts();
+      return response.data;
+    },
+    { staleTime: 10 * 60 * 1000 },
+  );
+  const { data: usersData } = useQuery(
+    'users',
+    async () => {
+      const response = await apiService.getUsers({ limit: 1000 });
+      return response.data ?? [];
+    },
+    { staleTime: 10 * 60 * 1000 },
+  );
+
   const tasks = Array.isArray(tasksData) ? tasksData : [];
+  const accounts = Array.isArray(accountsData) ? accountsData : (accountsData?.accounts || []);
+
+  // ── Inline save handler — used by schemaColumns InlineEditable cells. ───
+
+  const handleSaveField = useCallback(
+    async (recordId: string, field: string, newValue: unknown) => {
+      const loadingToast = toast.loading('Saving to Salesforce...');
+      try {
+        await apiService.updateTask(recordId, { [field]: newValue as any });
+        toast.success('Saved!', { id: loadingToast, duration: 2000 });
+        setTimeout(() => {
+          queryClient.invalidateQueries(['my-tasks']);
+        }, 1000);
+      } catch (error: any) {
+        toast.error(`Failed: ${error.response?.data?.detail || error.message}`, { id: loadingToast });
+        throw error;
+      }
+    },
+    [queryClient],
+  );
 
   // ── Schema-driven columns ───────────────────────────────────────────
 
   const schemaColumns = useMemo(() => {
     if (!taskSchemaData?.fields) return [];
-    return buildSchemaColumns(taskSchemaData.fields as SchemaField[]);
-  }, [taskSchemaData]);
+    return buildSchemaColumns(taskSchemaData.fields as SchemaField[], {
+      entityType: 'Task',
+      onSaveField: handleSaveField,
+      canEditObject: canEdit,
+      sfUserId,
+      accounts,
+      users: usersData ?? [],
+      // Task has no edit-all permission key — admin or owner only.
+    });
+  }, [taskSchemaData, handleSaveField, canEdit, sfUserId, accounts, usersData]);
 
   const columns = useMemo(() => {
     const action = editActionColumn(
@@ -131,37 +177,6 @@ const Tasks: React.FC = () => {
     localStorage.setItem(COLUMN_STORAGE_KEY, JSON.stringify(newModel));
   }, []);
 
-  // ── Inline cell editing ─────────────────────────────────────────────
-
-  const handleCellEdit = async (newRow: any, oldRow: any) => {
-    const updates: Record<string, any> = {};
-    Object.keys(newRow).forEach((key) => {
-      if (newRow[key] !== oldRow[key] && key !== 'Id') {
-        // Skip nested relationship objects
-        if (typeof newRow[key] === 'object' && newRow[key] !== null && !(newRow[key] instanceof Date)) return;
-        if (newRow[key] instanceof Date) {
-          updates[key] = newRow[key].toISOString().split('T')[0];
-        } else {
-          updates[key] = newRow[key];
-        }
-      }
-    });
-    if (Object.keys(updates).length === 0) return newRow;
-
-    const loadingToast = toast.loading('Saving to Salesforce...');
-    try {
-      await apiService.updateTask(newRow.Id, updates);
-      toast.success('Saved!', { id: loadingToast, duration: 2000 });
-      setTimeout(() => {
-        queryClient.invalidateQueries(['my-tasks']);
-      }, 1000);
-      return newRow;
-    } catch (error: any) {
-      toast.error(`Failed: ${error.response?.data?.detail || error.message}`, { id: loadingToast });
-      return oldRow;
-    }
-  };
-
   return (
     <Box>
       {/* Header */}
@@ -217,13 +232,6 @@ const Tasks: React.FC = () => {
               columns={columns}
               loading={tasksLoading}
               getRowId={(row) => row.Id}
-              editMode="cell"
-              processRowUpdate={handleCellEdit}
-              onProcessRowUpdateError={console.error}
-              isCellEditable={(params) => {
-                if (!canEdit) return false;
-                return params.colDef.editable === true;
-              }}
               columnVisibilityModel={columnVisibilityModel}
               onColumnVisibilityModelChange={handleColumnVisibilityChange}
               pagination
diff --git a/financial_forecasting/frontend/src/utils/schemaColumns.test.tsx b/financial_forecasting/frontend/src/utils/schemaColumns.test.tsx
new file mode 100644
index 00000000..7d02d0c5
--- /dev/null
+++ b/financial_forecasting/frontend/src/utils/schemaColumns.test.tsx
@@ -0,0 +1,323 @@
+/**
+ * Tests for `buildSchemaColumns`.
+ *
+ * Split in two blocks:
+ *   1. "invariants" — behavior that must survive the mega-B rewrite
+ *      (system-field filter, dotted pseudo-field filter, forceHide, column
+ *      alphabetization, per-SF-type GridColDef.type/valueFormatter/valueGetter
+ *      mapping). These tests pass both pre- and post-rewrite.
+ *   2. "new behavior" — InlineEditable renderCell emission, onSaveField
+ *      plumbing, defaultSensitivity pass-through, reference-field routing
+ *      (AccountCell/OwnerCell), ownerGate threading. Pass only post-rewrite.
+ *
+ * `usePermissions` is mocked because InlineEditable + AccountCell + OwnerCell
+ * read it via useFieldPermission → useFieldPermission reads usePermissions.
+ */
+import React from 'react';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+
+const mockPermissions = {
+  can: jest.fn<boolean, [string]>().mockReturnValue(false),
+  isAdmin: true,  // Admin by default so ownerGate doesn't block the render-path assertions
+  sfUserId: 'user-1' as string | null,
+  orgUserId: null,
+  isPlatformUnlinked: false,
+  profileName: 'RM',
+  permissions: {} as Record<string, boolean>,
+  loading: false,
+  refetch: jest.fn(),
+};
+
+jest.mock('../contexts/PermissionsContext', () => ({
+  usePermissions: () => mockPermissions,
+}));
+
+import { buildSchemaColumns, SchemaField, SchemaColumnOptions } from './schemaColumns';
+
+beforeEach(() => {
+  mockPermissions.can.mockReturnValue(false);
+  mockPermissions.isAdmin = true;
+  mockPermissions.sfUserId = 'user-1';
+});
+
+/** Minimal valid options — tests default to Account with admin caller. */
+const defaultOptions: SchemaColumnOptions = {
+  entityType: 'Account',
+  onSaveField: jest.fn().mockResolvedValue(undefined),
+  canEditObject: true,
+  sfUserId: 'user-1',
+};
+
+const field = (overrides: Partial<SchemaField> & Pick<SchemaField, 'name' | 'label' | 'type'>): SchemaField => ({
+  custom: false,
+  updateable: true,
+  calculated: false,
+  nillable: true,
+  defaultValue: null,
+  ...overrides,
+});
+
+// ── Block 1: Invariants (must survive the rewrite) ──────────────────────────
+
+describe('buildSchemaColumns — invariants', () => {
+  it('filters out SYSTEM_FIELDS (Id, CreatedDate, SystemModstamp, …)', () => {
+    const fields = [
+      field({ name: 'Id', label: 'ID', type: 'id' }),
+      field({ name: 'IsDeleted', label: 'Deleted', type: 'boolean' }),
+      field({ name: 'SystemModstamp', label: 'System Modstamp', type: 'datetime' }),
+      field({ name: 'CreatedById', label: 'Created By ID', type: 'reference' }),
+      field({ name: 'CreatedDate', label: 'Created Date', type: 'datetime' }),
+      field({ name: 'LastModifiedById', label: 'Last Modified By ID', type: 'reference' }),
+      field({ name: 'LastModifiedDate', label: 'Last Modified Date', type: 'datetime' }),
+      field({ name: 'LastActivityDate', label: 'Last Activity Date', type: 'date' }),
+      field({ name: 'RecordTypeId', label: 'Record Type ID', type: 'reference' }),
+      field({ name: 'MasterRecordId', label: 'Master Record ID', type: 'reference' }),
+      field({ name: 'attributes', label: 'Attributes', type: 'string' }),
+      field({ name: 'Name', label: 'Name', type: 'string' }),
+    ];
+    const cols = buildSchemaColumns(fields, defaultOptions);
+    expect(cols.map((c) => c.field)).toEqual(['Name']);
+  });
+
+  it('filters out dotted relationship pseudo-fields (Owner.Name)', () => {
+    const fields = [
+      field({ name: 'Name', label: 'Name', type: 'string' }),
+      field({ name: 'Owner.Name', label: 'Owner Name', type: 'string' }),
+      field({ name: 'Account.Name', label: 'Account Name', type: 'string' }),
+    ];
+    const cols = buildSchemaColumns(fields, defaultOptions);
+    expect(cols.map((c) => c.field)).toEqual(['Name']);
+  });
+
+  it('honors forceHide to drop specific fields', () => {
+    const fields = [
+      field({ name: 'Name', label: 'Name', type: 'string' }),
+      field({ name: 'Phone', label: 'Phone', type: 'phone' }),
+      field({ name: 'Email', label: 'Email', type: 'email' }),
+    ];
+    const cols = buildSchemaColumns(fields, {
+      ...defaultOptions,
+      forceHide: new Set(['Phone']),
+    });
+    expect(cols.map((c) => c.field).sort()).toEqual(['Email', 'Name']);
+  });
+
+  it('returns columns sorted alphabetically by headerName', () => {
+    const fields = [
+      field({ name: 'ZField', label: 'Zebra', type: 'string' }),
+      field({ name: 'AField', label: 'Apple', type: 'string' }),
+      field({ name: 'MField', label: 'Mango', type: 'string' }),
+    ];
+    const cols = buildSchemaColumns(fields, defaultOptions);
+    expect(cols.map((c) => c.headerName)).toEqual(['Apple', 'Mango', 'Zebra']);
+  });
+
+  it('maps numeric SF types (double/int/currency/percent) to GridColDef type: "number"', () => {
+    const fields = [
+      field({ name: 'Count', label: 'Count', type: 'int' }),
+      field({ name: 'Revenue', label: 'Revenue', type: 'currency' }),
+      field({ name: 'Avg', label: 'Avg', type: 'double' }),
+      field({ name: 'Chance', label: 'Chance', type: 'percent' }),
+    ];
+    const cols = buildSchemaColumns(fields, defaultOptions);
+    expect(cols.every((c) => c.type === 'number')).toBe(true);
+  });
+
+  it('currency type emits a valueFormatter that formats large numbers with formatDollarMillions', () => {
+    const fields = [field({ name: 'AnnualRevenue', label: 'Annual Revenue', type: 'currency' })];
+    const cols = buildSchemaColumns(fields, defaultOptions);
+    const revenue = cols.find((c) => c.field === 'AnnualRevenue')!;
+    const formatted = revenue.valueFormatter!({ value: 1_500_000 } as any);
+    // formatDollarMillions renders "$1.5M" or similar; just verify it's a non-empty string
+    // that includes a dollar sign or "M" to avoid depending on exact formatting.
+    expect(typeof formatted).toBe('string');
+    expect((formatted as string).length).toBeGreaterThan(0);
+    const empty = revenue.valueFormatter!({ value: null } as any);
+    expect(empty).toBe('');
+  });
+
+  it('percent type appends "%" in valueFormatter', () => {
+    const fields = [field({ name: 'Probability', label: 'Probability', type: 'percent' })];
+    const cols = buildSchemaColumns(fields, defaultOptions);
+    const p = cols[0];
+    expect(p.valueFormatter!({ value: 75 } as any)).toBe('75%');
+    expect(p.valueFormatter!({ value: null } as any)).toBe('');
+  });
+
+  it('date type emits type: "date" + valueGetter returning Date', () => {
+    const fields = [field({ name: 'CloseDate', label: 'Close Date', type: 'date' })];
+    const cols = buildSchemaColumns(fields, defaultOptions);
+    const d = cols[0];
+    expect(d.type).toBe('date');
+    const got = d.valueGetter!({ value: '2026-04-15' } as any);
+    expect(got).toBeInstanceOf(Date);
+  });
+
+  it('datetime type emits type: "dateTime" + valueGetter returning Date + formatted valueFormatter', () => {
+    const fields = [field({ name: 'SystemMod', label: 'System Mod', type: 'datetime' })];
+    const cols = buildSchemaColumns(fields, defaultOptions);
+    const d = cols[0];
+    expect(d.type).toBe('dateTime');
+    const got = d.valueGetter!({ value: '2026-04-15T12:00:00Z' } as any);
+    expect(got).toBeInstanceOf(Date);
+    const fmt = d.valueFormatter!({ value: '2026-04-15T12:00:00Z' } as any);
+    expect(typeof fmt).toBe('string');
+    expect(fmt).toMatch(/2026/);
+  });
+
+  it('boolean type emits type: "boolean"', () => {
+    const fields = [field({ name: 'Active__c', label: 'Active', type: 'boolean' })];
+    const cols = buildSchemaColumns(fields, defaultOptions);
+    expect(cols[0].type).toBe('boolean');
+  });
+
+  it('multipicklist type is display-only (no renderCell-based edit path) with semicolon→comma formatter', () => {
+    const fields = [
+      field({
+        name: 'Focus__c', label: 'Focus', type: 'multipicklist',
+        picklistValues: [
+          { value: 'A', label: 'A', active: true },
+          { value: 'B', label: 'B', active: true },
+        ],
+      }),
+    ];
+    const cols = buildSchemaColumns(fields, defaultOptions);
+    expect(cols[0].valueFormatter!({ value: 'A;B' } as any)).toBe('A, B');
+    expect(cols[0].valueFormatter!({ value: null } as any)).toBe('');
+  });
+
+  it('applies per-field overrides (merged on top of generated column)', () => {
+    const fields = [field({ name: 'Name', label: 'Name', type: 'string' })];
+    const customRender = (() => 'custom') as any;
+    const cols = buildSchemaColumns(fields, {
+      ...defaultOptions,
+      overrides: new Map([['Name', { flex: 3, minWidth: 300, renderCell: customRender }]]),
+    });
+    expect(cols[0].flex).toBe(3);
+    expect(cols[0].minWidth).toBe(300);
+    expect(cols[0].renderCell).toBe(customRender);
+  });
+});
+
+// ── Block 2: New behavior (post-rewrite) ────────────────────────────────────
+
+describe('buildSchemaColumns — InlineEditable emission', () => {
+  it('emits a renderCell for standard editable fields that wraps InlineEditable', () => {
+    const fields = [field({ name: 'Title', label: 'Title', type: 'string', updateable: true })];
+    const cols = buildSchemaColumns(fields, { ...defaultOptions, entityType: 'Contact' });
+    expect(cols[0].renderCell).toBeDefined();
+    // Render the cell with synthetic params and verify the display shows through.
+    const rendered = render(
+      <>{(cols[0].renderCell as any)({ value: 'Program Officer', row: { Id: 'c1', OwnerId: 'user-1' } })}</>,
+    );
+    expect(rendered.getByText('Program Officer')).toBeInTheDocument();
+  });
+
+  it('onSaveField fires with (recordId, fieldName, newValue) on commit', async () => {
+    const onSaveField = jest.fn().mockResolvedValue(undefined);
+    const fields = [field({ name: 'FirstName', label: 'First Name', type: 'string', updateable: true })];
+    const cols = buildSchemaColumns(fields, {
+      ...defaultOptions,
+      entityType: 'Contact',
+      onSaveField,
+    });
+    const rendered = render(
+      <>{(cols[0].renderCell as any)({ value: 'John', row: { Id: 'c1', OwnerId: 'user-1' } })}</>,
+    );
+    fireEvent.click(rendered.getByText('John'));
+    const input = rendered.getByDisplayValue('John');
+    fireEvent.change(input, { target: { value: 'Jane' } });
+    fireEvent.keyDown(input, { key: 'Enter' });
+    await waitFor(() => expect(onSaveField).toHaveBeenCalledWith('c1', 'FirstName', 'Jane'));
+  });
+
+  it('does NOT enter edit mode when row OwnerId mismatches and user is not admin/edit-all', () => {
+    mockPermissions.isAdmin = false;
+    mockPermissions.can.mockReturnValue(false);
+    const fields = [field({ name: 'Title', label: 'Title', type: 'string', updateable: true })];
+    const cols = buildSchemaColumns(fields, {
+      ...defaultOptions,
+      entityType: 'Contact',
+      sfUserId: 'user-1',
+    });
+    const rendered = render(
+      <>{(cols[0].renderCell as any)({ value: 'Program Officer', row: { Id: 'c1', OwnerId: 'other-user' } })}</>,
+    );
+    fireEvent.click(rendered.getByText('Program Officer'));
+    // Non-owner → ownerGate blocks entry to edit mode.
+    expect(rendered.queryByDisplayValue('Program Officer')).not.toBeInTheDocument();
+  });
+
+  it('reference field targeting Account emits a renderCell that uses preloaded accounts[]', () => {
+    const fields = [field({
+      name: 'AccountId',
+      label: 'Account',
+      type: 'reference',
+      referenceTo: ['Account'],
+      relationshipName: 'Account',
+      updateable: true,
+    })];
+    const cols = buildSchemaColumns(fields, {
+      ...defaultOptions,
+      entityType: 'Contact',
+      accounts: [{ Id: 'a1', Name: 'ACME' }, { Id: 'a2', Name: 'Globex' }],
+    });
+    expect(cols[0].renderCell).toBeDefined();
+    const rendered = render(
+      <>{(cols[0].renderCell as any)({
+        value: 'a1',
+        row: { Id: 'c1', OwnerId: 'user-1', AccountId: 'a1', Account: { Name: 'ACME' } },
+      })}</>,
+    );
+    expect(rendered.getByText('ACME')).toBeInTheDocument();
+  });
+
+  it('reference field targeting User emits a renderCell that uses preloaded users[]', () => {
+    const fields = [field({
+      name: 'OwnerId',
+      label: 'Owner',
+      type: 'reference',
+      referenceTo: ['User'],
+      relationshipName: 'Owner',
+      updateable: true,
+    })];
+    const cols = buildSchemaColumns(fields, {
+      ...defaultOptions,
+      entityType: 'Contact',
+      users: [
+        { Id: 'user-1', Name: 'Alice', IsActive: true },
+        { Id: 'user-2', Name: 'Bob', IsActive: true },
+      ],
+    });
+    expect(cols[0].renderCell).toBeDefined();
+    const rendered = render(
+      <>{(cols[0].renderCell as any)({
+        value: 'user-1',
+        row: { Id: 'c1', OwnerId: 'user-1', Owner: { Name: 'Alice' } },
+      })}</>,
+    );
+    expect(rendered.getByText('Alice')).toBeInTheDocument();
+  });
+
+  it('readOnly fields (calculated or !updateable) render as display-only (click does not enter edit mode)', () => {
+    const fields = [
+      field({ name: 'Rollup__c', label: 'Rollup', type: 'currency', updateable: true, calculated: true }),
+      field({ name: 'ReadOnly__c', label: 'Readonly', type: 'string', updateable: false, calculated: false }),
+    ];
+    const cols = buildSchemaColumns(fields, defaultOptions);
+    const rollup = cols.find((c) => c.field === 'Rollup__c')!;
+    const ro = cols.find((c) => c.field === 'ReadOnly__c')!;
+    const rRollup = render(
+      <>{(rollup.renderCell as any)({ value: 1000, row: { Id: 'a1', OwnerId: 'user-1' } })}</>,
+    );
+    // Clicking should not put it into edit mode (no TextField appears).
+    fireEvent.click(rRollup.container.firstChild as Element);
+    expect(rRollup.container.querySelector('input')).toBeNull();
+    const rRo = render(
+      <>{(ro.renderCell as any)({ value: 'foo', row: { Id: 'a1', OwnerId: 'user-1' } })}</>,
+    );
+    fireEvent.click(rRo.getByText('foo'));
+    expect(rRo.queryByDisplayValue('foo')).not.toBeInTheDocument();
+  });
+});
diff --git a/financial_forecasting/frontend/src/utils/schemaColumns.tsx b/financial_forecasting/frontend/src/utils/schemaColumns.tsx
index e9ac4a2d..b7c6a69a 100644
--- a/financial_forecasting/frontend/src/utils/schemaColumns.tsx
+++ b/financial_forecasting/frontend/src/utils/schemaColumns.tsx
@@ -2,21 +2,45 @@
  * Schema-driven column generator for MUI DataGrid.
  *
  * Converts a Salesforce schema describe response into GridColDef[] arrays,
- * so users can toggle ANY object field as a visible column. Editable fields
- * get appropriate edit cells (text, picklist, lookup, date, boolean).
+ * so users can toggle ANY object field as a visible column. Every editable
+ * field is rendered through the <InlineEditable> primitive (text, number,
+ * currency, percent, date, datetime, boolean, select, email, phone, url)
+ * or one of the inline-edit cell components (AccountCell, OwnerCell) for
+ * reference fields. DataGrid native cell-edit is OFF — the primitive owns
+ * the edit flow end-to-end (single-click entry, dark-mode fill affordance,
+ * sensitivity gate, per-row ownership gate).
+ *
+ * Invariant — fail-safe sensitivity (mega-B rewrite, 2026-04-23):
+ *   Every schema-emitted InlineEditable passes `defaultSensitivity: 'safe'`.
+ *   Hand-coded InlineEditable call sites omit the prop and retain the
+ *   fail-safe 'sensitive' default in fieldSensitivity.ts. If someone flips
+ *   this default to 'sensitive', ~100 fields across Account/Contact/Task/
+ *   Activity would lock on first click overnight — every cell would demand
+ *   an unlock confirmation. Keep it 'safe'; rely on SF's field-level
+ *   security + the server-side `_enforce_record_ownership` helper
+ *   (financial_forecasting/main.py:862) as the authoritative write gate.
  *
  * Usage:
  *   const schema = await apiService.getSchemaDescribe('Account');
- *   const columns = buildSchemaColumns(schema.data.fields, { overrides, forceHide });
+ *   const columns = buildSchemaColumns(schema.data.fields, {
+ *     entityType: 'Account',
+ *     onSaveField: (id, field, value) => apiService.updateAccount(id, { [field]: value }),
+ *     canEditObject: canEdit,         // page-level permission
+ *     sfUserId,                       // from usePermissions()
+ *     accounts, users,                // preloaded reference data
+ *   });
  */
 import React from 'react';
-import { Select, MenuItem } from '@mui/material';
-import type { GridColDef, GridRenderEditCellParams, GridValueGetterParams } from '@mui/x-data-grid';
-import { useGridApiContext } from '@mui/x-data-grid';
 import { format } from 'date-fns';
+import type { GridColDef, GridRenderCellParams, GridValueGetterParams } from '@mui/x-data-grid';
 
 import { formatDollarMillions } from './formatters';
-import { AccountEditCell, OwnerEditCell } from '../pages/Opportunities/EditCells';
+import {
+  InlineEditable,
+  InlineEditVariant,
+} from '../components/inline-edit/InlineEditable';
+import AccountCell from '../components/inline-edit/cells/AccountCell';
+import OwnerCell from '../components/inline-edit/cells/OwnerCell';
 
 // ── Types ───────────────────────────────────────────────────────────────────
 
@@ -35,6 +59,33 @@ export interface SchemaField {
 }
 
 export interface SchemaColumnOptions {
+  /** Object type key for sensitivity classification ('Account', 'Contact', 'Task', 'Activity', …). */
+  entityType: string;
+  /**
+   * Save handler. Called when InlineEditable commits a change. Implementations
+   * typically dispatch to the matching /api/salesforce/{sobject}/{id} endpoint
+   * and invalidate the relevant react-query cache on success. Errors thrown
+   * from here surface in the InlineEditable primitive as inline helperText.
+   */
+  onSaveField: (recordId: string, fieldName: string, newValue: unknown) => Promise<void>;
+  /**
+   * Page-level permission gate (e.g. `canEdit = isAdmin || can('edit_accounts')`).
+   * When false, every cell renders read-only regardless of per-field flags.
+   */
+  canEditObject: boolean;
+  /**
+   * Per-resource 'edit_all_*' permission key. Opportunity list passes
+   * 'edit_all_opportunities' so RM-tier users can edit any opp. Account,
+   * Contact, Task, Activity have no edit-all key in PERMISSION_KEYS — leave
+   * undefined. Mirrors the backend's `_enforce_record_ownership` bypass.
+   */
+  editAllPermission?: string;
+  /** Current user's Salesforce user ID, from usePermissions(). Null = can't evaluate ownership → deny. */
+  sfUserId: string | null;
+  /** Preloaded accounts for AccountId-reference autocomplete. Empty array = show "No Account". */
+  accounts?: Array<{ Id: string; Name: string }>;
+  /** Preloaded users for OwnerId-reference autocomplete. Empty array = show "Unassigned". */
+  users?: Array<{ Id: string; Name: string; IsActive?: boolean }>;
   /** Field names to exclude entirely from the generated columns. */
   forceHide?: Set<string>;
   /** Per-field column definition overrides (merged after generation). */
@@ -64,47 +115,37 @@ const NUMERIC_TYPES = new Set(['double', 'currency', 'int', 'percent']);
 /** Salesforce field types that map to currency formatting. */
 const CURRENCY_TYPES = new Set(['currency']);
 
-// ── PicklistEditCell ────────────────────────────────────────────────────────
-
-interface PicklistEditCellProps extends GridRenderEditCellParams {
-  options: Array<{ value: string; label: string }>;
-}
-
-/**
- * Inline edit cell for picklist fields — renders a Select dropdown
- * populated with the field's active picklist values.
- */
-export function PicklistEditCell(props: PicklistEditCellProps) {
-  const { id, value, field, options } = props;
-  const apiRef = useGridApiContext();
-
-  const handleChange = (event: React.ChangeEvent<{ value: unknown }>) => {
-    const newValue = (event.target as HTMLSelectElement).value;
-    apiRef.current.setEditCellValue({ id, field, value: newValue });
-    // Immediately stop editing after selection
-    apiRef.current.stopCellEditMode({ id, field });
-  };
-
-  return (
-    <Select
-      value={value || ''}
-      onChange={handleChange as any}
-      size="small"
-      variant="standard"
-      autoFocus
-      fullWidth
-      sx={{ width: '100%', '& .MuiSelect-select': { py: 0.5 } }}
-    >
-      <MenuItem value="">
-        <em>None</em>
-      </MenuItem>
-      {options.map((opt) => (
-        <MenuItem key={opt.value} value={opt.value}>
-          {opt.label}
-        </MenuItem>
-      ))}
-    </Select>
-  );
+/** Mapping from SF field `type` to the InlineEditable variant union. */
+function variantForType(sfType: string): InlineEditVariant {
+  switch (sfType) {
+    case 'double':
+    case 'int':
+      return 'number';
+    case 'currency':
+      return 'currency';
+    case 'percent':
+      return 'percent';
+    case 'date':
+      return 'date';
+    case 'datetime':
+      return 'datetime';
+    case 'boolean':
+      return 'boolean';
+    case 'picklist':
+      return 'select';
+    case 'email':
+      return 'email';
+    case 'phone':
+      return 'phone';
+    case 'url':
+      return 'url';
+    case 'textarea':
+    case 'string':
+    case 'id':
+    case 'combobox':
+    default:
+      return 'text';
+  }
 }
 
 // ── Column Builder ──────────────────────────────────────────────────────────
@@ -113,31 +154,35 @@ export function PicklistEditCell(props: PicklistEditCellProps) {
  * Convert Salesforce schema fields into MUI DataGrid column definitions.
  *
  * Filters out system fields and dotted pseudo-fields (Account.Name, etc.),
- * maps SF types to DataGrid types, and wires up appropriate edit cells.
+ * maps SF types to DataGrid types, and emits InlineEditable renderCells for
+ * every editable field. Reference fields targeting Account or User use the
+ * AccountCell / OwnerCell components (which take preloaded options from the
+ * caller's state to avoid per-row async fetches). Other reference types fall
+ * back to display-only.
  */
 export function buildSchemaColumns(
   fields: SchemaField[],
-  options?: SchemaColumnOptions,
+  options: SchemaColumnOptions,
 ): GridColDef[] {
-  const forceHide = options?.forceHide ?? new Set();
-  const overrides = options?.overrides ?? new Map();
+  const forceHide = options.forceHide ?? new Set<string>();
+  const overrides = options.overrides ?? new Map<string, Partial<GridColDef>>();
 
   const columns: GridColDef[] = [];
 
   for (const field of fields) {
-    // Skip system fields
+    // Skip system fields.
     if (SYSTEM_FIELDS.has(field.name)) continue;
 
-    // Skip dotted relationship pseudo-fields (Account.Name, Owner.Name, etc.)
+    // Skip dotted relationship pseudo-fields (Account.Name, Owner.Name, etc.).
     if (field.name.includes('.')) continue;
 
-    // Skip explicitly hidden fields
+    // Skip explicitly hidden fields.
     if (forceHide.has(field.name)) continue;
 
-    const col = buildColumnForField(field);
+    const col = buildColumnForField(field, options);
     if (!col) continue;
 
-    // Apply per-field overrides
+    // Apply per-field overrides (can replace renderCell, headerName, flex, …).
     const override = overrides.get(field.name);
     if (override) {
       Object.assign(col, override);
@@ -146,7 +191,7 @@ export function buildSchemaColumns(
     columns.push(col);
   }
 
-  // Sort alphabetically by header name for the column picker
+  // Sort alphabetically by header name for the column picker.
   columns.sort((a, b) => (a.headerName || '').localeCompare(b.headerName || ''));
 
   return columns;
@@ -154,14 +199,20 @@ export function buildSchemaColumns(
 
 // ── Per-field column builder ────────────────────────────────────────────────
 
-function buildColumnForField(field: SchemaField): GridColDef | null {
+function buildColumnForField(
+  field: SchemaField,
+  options: SchemaColumnOptions,
+): GridColDef | null {
   const base: GridColDef = {
     field: field.name,
     headerName: field.label,
     flex: 1,
     minWidth: 120,
     filterable: true,
-    editable: field.updateable && !field.calculated,
+    // DataGrid native edit OFF — InlineEditable owns the edit flow. Setting
+    // editable: false lets MUI correctly suppress its cell-edit CSS state
+    // even when the DataGrid is configured with editMode="cell".
+    editable: false,
   };
 
   const sfType = field.type;
@@ -177,6 +228,7 @@ function buildColumnForField(field: SchemaField): GridColDef | null {
       base.valueFormatter = (params) =>
         params.value != null ? `${params.value}%` : '';
     }
+    base.renderCell = makeStandardRenderCell(field, options);
     return base;
   }
 
@@ -187,6 +239,7 @@ function buildColumnForField(field: SchemaField): GridColDef | null {
       params.value ? new Date(params.value) : null;
     base.valueFormatter = (params) =>
       params.value ? format(new Date(params.value as string), 'MMM dd, yyyy') : '';
+    base.renderCell = makeStandardRenderCell(field, options);
     return base;
   }
 
@@ -197,29 +250,25 @@ function buildColumnForField(field: SchemaField): GridColDef | null {
       params.value ? new Date(params.value) : null;
     base.valueFormatter = (params) =>
       params.value ? format(new Date(params.value as string), 'MMM dd, yyyy h:mm a') : '';
+    base.renderCell = makeStandardRenderCell(field, options);
     return base;
   }
 
   // ── Boolean ──
   if (sfType === 'boolean') {
     base.type = 'boolean';
+    base.renderCell = makeStandardRenderCell(field, options);
     return base;
   }
 
   // ── Picklist ──
-  if (sfType === 'picklist' && field.picklistValues) {
-    const activeValues = field.picklistValues.filter((pv) => pv.active);
-    if (base.editable) {
-      base.renderEditCell = (params: GridRenderEditCellParams) => (
-        <PicklistEditCell {...params} options={activeValues} />
-      );
-    }
+  if (sfType === 'picklist') {
+    base.renderCell = makeStandardRenderCell(field, options);
     return base;
   }
 
-  // ── Multipicklist — display-only, edit via dialog ──
+  // ── Multipicklist — display-only (SF multi-select needs a distinct UI). ──
   if (sfType === 'multipicklist') {
-    base.editable = false;
     base.valueFormatter = (params) => {
       if (!params.value) return '';
       return String(params.value).replace(/;/g, ', ');
@@ -232,36 +281,144 @@ function buildColumnForField(field: SchemaField): GridColDef | null {
     const targets = field.referenceTo || [];
     const relName = field.relationshipName;
 
-    // Display the related record's Name via the relationship object
+    // Display-mode fallback: read the related record's Name via the joined object.
     if (relName) {
       base.valueGetter = (params: GridValueGetterParams) =>
         params.row[relName]?.Name || '';
     }
 
-    // Wire up known edit cells for Account and User lookups
     if (targets.includes('Account')) {
-      if (base.editable) {
-        base.renderEditCell = (params: GridRenderEditCellParams) => (
-          <AccountEditCell {...params} />
-        );
-      }
+      base.renderCell = makeAccountReferenceRenderCell(field, options);
       return base;
     }
 
     if (targets.includes('User')) {
-      if (base.editable) {
-        base.renderEditCell = (params: GridRenderEditCellParams) => (
-          <OwnerEditCell {...params} />
-        );
-      }
+      base.renderCell = makeOwnerReferenceRenderCell(field, options);
       return base;
     }
 
-    // Other reference types — read-only in the grid, use the dialog for editing
-    base.editable = false;
+    // Other reference types (Contact, Lead, polymorphic WhatId/WhoId) —
+    // display-only. Edit via the entity's edit dialog. A dedicated
+    // ContactCell/LeadCell would go here when demand materializes.
     return base;
   }
 
-  // ── String / textarea / phone / email / url — default text input ──
+  // ── Address (compound) — display-only with joined components. ──
+  if (sfType === 'address') {
+    base.valueFormatter = (params) => {
+      const v = params.value as Record<string, string | undefined> | null | undefined;
+      if (!v || typeof v !== 'object') return '';
+      return ['street', 'city', 'state', 'postalCode', 'country']
+        .map((k) => v[k])
+        .filter(Boolean)
+        .join(', ');
+    };
+    return base;
+  }
+
+  // ── String / textarea / email / phone / url / id / combobox — text input. ──
+  base.renderCell = makeStandardRenderCell(field, options);
   return base;
 }
+
+// ── renderCell makers ───────────────────────────────────────────────────────
+
+function makeStandardRenderCell(
+  field: SchemaField,
+  options: SchemaColumnOptions,
+): GridColDef['renderCell'] {
+  return (params: GridRenderCellParams) => {
+    const rowOwnerId = params.row.OwnerId ?? null;
+    const variant = variantForType(field.type);
+    // Client-side required-field validator — rejects empty string / null on
+    // non-nillable fields so we don't round-trip a REQUIRED_FIELD_MISSING from
+    // SF (which the backend sanitizes to a generic "Failed to update"). Only
+    // applied to text-style variants since numeric/date/boolean have their
+    // own shape constraints; picklist+autocomplete can't produce an empty
+    // commit unless the user explicitly clears.
+    const requiredValidate = !field.nillable
+      ? (v: unknown) => (v == null || v === '' ? `${field.label} is required.` : null)
+      : undefined;
+    const picklistOptions =
+      variant === 'select' && field.picklistValues
+        ? field.picklistValues
+            .filter((p) => p.active)
+            .map((p) => ({ value: p.value, label: p.label }))
+        : undefined;
+    return (
+      <InlineEditable
+        variant={variant}
+        value={params.value as any}
+        onSave={(newVal) =>
+          options.onSaveField(params.row.Id ?? params.row.id, field.name, newVal)
+        }
+        objectType={options.entityType}
+        fieldName={field.name}
+        fieldLabel={field.label}
+        defaultSensitivity="safe"
+        readOnly={
+          !options.canEditObject || !field.updateable || field.calculated
+        }
+        ownerGate={{
+          rowOwnerId,
+          editAllPermission: options.editAllPermission,
+        }}
+        options={picklistOptions}
+        validate={requiredValidate}
+      />
+    );
+  };
+}
+
+function makeAccountReferenceRenderCell(
+  field: SchemaField,
+  options: SchemaColumnOptions,
+): GridColDef['renderCell'] {
+  return (params: GridRenderCellParams) => {
+    const rowOwnerId = params.row.OwnerId ?? null;
+    const relName = field.relationshipName;
+    const displayName = (relName && params.row[relName]?.Name) || null;
+    return (
+      <AccountCell
+        value={(params.value as string) ?? ''}
+        accounts={options.accounts ?? []}
+        displayName={displayName}
+        fieldName={field.name}
+        objectType={options.entityType}
+        onSave={(newId) =>
+          options.onSaveField(params.row.Id ?? params.row.id, field.name, newId)
+        }
+        readOnly={!options.canEditObject || !field.updateable}
+        ownerGate={{
+          rowOwnerId,
+          editAllPermission: options.editAllPermission,
+        }}
+      />
+    );
+  };
+}
+
+function makeOwnerReferenceRenderCell(
+  field: SchemaField,
+  options: SchemaColumnOptions,
+): GridColDef['renderCell'] {
+  return (params: GridRenderCellParams) => {
+    const rowOwnerId = params.row.OwnerId ?? null;
+    return (
+      <OwnerCell
+        value={(params.value as string) ?? ''}
+        users={options.users ?? []}
+        fieldName={field.name}
+        objectType={options.entityType}
+        onSave={(newId) =>
+          options.onSaveField(params.row.Id ?? params.row.id, field.name, newId)
+        }
+        readOnly={!options.canEditObject || !field.updateable}
+        ownerGate={{
+          rowOwnerId,
+          editAllPermission: options.editAllPermission,
+        }}
+      />
+    );
+  };
+}

From 37ac68d75c178ab5a3162e7ee8b0cd9c9104ff76 Mon Sep 17 00:00:00 2001
From: JP <jp@JPs-Pursuit-MacBook-Air.local>
Date: Thu, 23 Apr 2026 14:19:04 -0400
Subject: [PATCH 10/11] chore(sensitivity): classify Account.NumberOfEmployees,
 Contact.npsp__Primary_Affiliation__c, Activity block
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds explicit sensitivity entries on top of the defaultSensitivity: 'safe'
fall-through used by schema-driven cells (buildSchemaColumns, mega-B #7).
Per the plan's "conservative additions only" rule: err toward safe,
declare sensitive only where fat-finger risk is real or where a change
cascades into downstream rollups / household logic.

Account (12 → 13 entries):
  - NumberOfEmployees → sensitive. Feeds segmentation reports.

Contact (8 → 9 entries):
  - npsp__Primary_Affiliation__c → sensitive. Reassigning rewrites the
    contact's household membership and recomputes npo02__ rollups at
    the new affiliation's Account.

Task: no additions (current classifications already correct).

Activity (NEW block, 8 entries):
  - Subject, Status, Priority, ActivityDate, Description → safe
  - OwnerId → sensitive (accountability reassignment)
  - WhatId → sensitive (parent record linkage rewrite)
  - WhoId → sensitive (related contact linkage)

Used by the new Activities page (mega-B #9) which runs
buildSchemaColumns with entityType: 'Activity'.

fieldSensitivity.test.ts gains 4 new assertions + one it.each block over
the 5 safe Activity fields — 48/48 tests pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../src/utils/fieldSensitivity.test.ts        | 26 +++++++++++++++++++
 .../frontend/src/utils/fieldSensitivity.ts    | 12 +++++++++
 2 files changed, 38 insertions(+)

diff --git a/financial_forecasting/frontend/src/utils/fieldSensitivity.test.ts b/financial_forecasting/frontend/src/utils/fieldSensitivity.test.ts
index 1e2b63eb..7eb14868 100644
--- a/financial_forecasting/frontend/src/utils/fieldSensitivity.test.ts
+++ b/financial_forecasting/frontend/src/utils/fieldSensitivity.test.ts
@@ -68,6 +68,32 @@ describe('classifyField', () => {
     it('Task OwnerId is sensitive', () => {
       expect(classifyField('Task', 'OwnerId').sensitivity).toBe('sensitive');
     });
+    it('Account NumberOfEmployees is sensitive (mega-B #8)', () => {
+      const c = classifyField('Account', 'NumberOfEmployees');
+      expect(c.sensitivity).toBe('sensitive');
+      expect(c.lockReason).toMatch(/segmentation/i);
+    });
+    it('Contact npsp__Primary_Affiliation__c is sensitive (mega-B #8)', () => {
+      const c = classifyField('Contact', 'npsp__Primary_Affiliation__c');
+      expect(c.sensitivity).toBe('sensitive');
+      expect(c.lockReason).toMatch(/household|rollup/i);
+    });
+    it('Activity OwnerId is sensitive (mega-B #8)', () => {
+      expect(classifyField('Activity', 'OwnerId').sensitivity).toBe('sensitive');
+    });
+    it('Activity WhatId + WhoId are sensitive (mega-B #8)', () => {
+      expect(classifyField('Activity', 'WhatId').sensitivity).toBe('sensitive');
+      expect(classifyField('Activity', 'WhoId').sensitivity).toBe('sensitive');
+    });
+  });
+
+  describe('Activity safe fields (mega-B #8)', () => {
+    it.each(['Subject', 'Status', 'Priority', 'ActivityDate', 'Description'])(
+      'Activity.%s is safe',
+      (f) => {
+        expect(classifyField('Activity', f).sensitivity).toBe('safe');
+      },
+    );
   });
 
   describe('permission-gated fields', () => {
diff --git a/financial_forecasting/frontend/src/utils/fieldSensitivity.ts b/financial_forecasting/frontend/src/utils/fieldSensitivity.ts
index 219ceabf..0c3a697c 100644
--- a/financial_forecasting/frontend/src/utils/fieldSensitivity.ts
+++ b/financial_forecasting/frontend/src/utils/fieldSensitivity.ts
@@ -74,6 +74,7 @@ const FIELD_CLASSIFICATIONS: Record<string, Record<string, FieldClassification>>
     Type:                 { sensitivity: 'safe' },
     OwnerId:              { sensitivity: 'sensitive',        lockReason: 'Reassigning the account changes ownership. Click to confirm.' },
     AnnualRevenue:        { sensitivity: 'sensitive',        lockReason: 'Revenue figures impact reporting. Click to confirm.' },
+    NumberOfEmployees:    { sensitivity: 'sensitive',        lockReason: 'Employee count feeds segmentation reports. Click to confirm.' },
     BillingStreet:        { sensitivity: 'safe' },
     BillingCity:          { sensitivity: 'safe' },
     BillingState:         { sensitivity: 'safe' },
@@ -88,6 +89,7 @@ const FIELD_CLASSIFICATIONS: Record<string, Record<string, FieldClassification>>
     Department:           { sensitivity: 'safe' },
     AccountId:            { sensitivity: 'sensitive',        lockReason: 'Reassigning the contact changes the linked account. Click to confirm.' },
     OwnerId:              { sensitivity: 'sensitive',        lockReason: 'Reassigning the contact changes ownership. Click to confirm.' },
+    npsp__Primary_Affiliation__c: { sensitivity: 'sensitive', lockReason: "Reassigning affiliation rewrites the contact's household + rollups. Click to confirm." },
   },
   Project: {
     name:                 { sensitivity: 'safe' },
@@ -111,6 +113,16 @@ const FIELD_CLASSIFICATIONS: Record<string, Record<string, FieldClassification>>
     Description:          { sensitivity: 'safe' },
     OwnerId:              { sensitivity: 'sensitive',        lockReason: 'Reassigning a task changes accountability. Click to confirm.' },
   },
+  Activity: {
+    Subject:              { sensitivity: 'safe' },
+    Status:               { sensitivity: 'safe' },
+    Priority:             { sensitivity: 'safe' },
+    ActivityDate:         { sensitivity: 'safe' },
+    Description:          { sensitivity: 'safe' },
+    OwnerId:              { sensitivity: 'sensitive',        lockReason: 'Reassigning an activity changes accountability. Click to confirm.' },
+    WhatId:               { sensitivity: 'sensitive',        lockReason: 'Changing the parent record rewrites activity linkage. Click to confirm.' },
+    WhoId:                { sensitivity: 'sensitive',        lockReason: 'Changing the related contact affects linkage. Click to confirm.' },
+  },
   Target: {
     amount:               { sensitivity: 'permission-gated', permission: 'manage_owner_goals', lockReason: 'Revenue targets require Admin or Executive permission.' },
     period:               { sensitivity: 'permission-gated', permission: 'manage_owner_goals', lockReason: 'Target periods require Admin or Executive permission.' },

From d9b58f09f5061b231ca520f556446604aae051b0 Mon Sep 17 00:00:00 2001
From: JP <jp@JPs-Pursuit-MacBook-Air.local>
Date: Thu, 23 Apr 2026 14:38:09 -0400
Subject: [PATCH 11/11] =?UTF-8?q?docs(activity-sync):=20design=20doc=20for?=
 =?UTF-8?q?=20two-way=20bedrock.activity=20=E2=86=94=20SF=20sync?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

JP decided on 2026-04-23 to expand scope beyond the original mega-B #9
plan: instead of a simple Activities page that edits bedrock.activity
locally, implement full two-way sync so inline edits reflect back to the
underlying SF Task / Event. SF-first PATCH semantics (SF is authoritative;
on SF failure, no local write). Blocks the Activities page and the Leads
tab replacement.

This doc captures the phased plan and the design decisions I need Jac's
input on:

  Phase 0: field catalog — enumerate every Task/Event SF field Pursuit
    actually uses (describe + custom fields), including the new bedrock
    column name, Postgres type, and lossy-conversion notes. Blocks Phase 1.
  Phase 1: backend migration + sync engine expansion. New columns on
    bedrock.activity; _map_sf_task + _map_sf_event populate them;
    _upsert_activity INSERT/UPDATE lists expand. Backfill via
    sync_activities --force-full.
  Phase 2: PUT /api/activities/{uuid} rewritten for SF-first semantics.
    Translates SF-field-named payload → bedrock columns; runs
    _enforce_record_ownership on the SF record; PATCHes SF first; mirrors
    to bedrock on success.
  Phase 3: Activities page (mega-B #9) uses buildSchemaColumns with a
    synthesized Task+Event SF schema.
  Phase 4: wire into Details.tsx, replace Leads tab, add the redirect.
  Phase 5 (mega-B #10 + #11 + #12): RowCountCaption + Activities tab on
    AccountEditDialog.

Open questions flagged for JP + Jac: custom fields, recurrence handling,
RT-specific picklist values, contact_ids[] scalar-vs-list, Event-vs-Task
field scope at save time, Bulk API quota for backfill.

Today's branch state: 10 commits on feat/megaB-lane-a-tail (6 mega-B
baseline + #7a, #7b, #7, #8). Parked until the activity-sync sprint
completes per JP's 2026-04-23 "park and expand" direction.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 tasks/activity-sync-expansion.md | 126 +++++++++++++++++++++++++++++++
 1 file changed, 126 insertions(+)
 create mode 100644 tasks/activity-sync-expansion.md

diff --git a/tasks/activity-sync-expansion.md b/tasks/activity-sync-expansion.md
new file mode 100644
index 00000000..4d788915
--- /dev/null
+++ b/tasks/activity-sync-expansion.md
@@ -0,0 +1,126 @@
+# Activity Sync Expansion — two-way bedrock.activity ↔ SF Task/Event
+
+**Status:** design phase — blocks the Activities page (#9 in mega-B). JP approved "full field reflection + SF-first PATCH" on 2026-04-23; Jac schema review pending.
+
+## Why
+
+The Activities page (replaces the Leads tab on `/details`) needs inline edit that users can trust. Today `/api/activities` edits the local `bedrock.activity` table only — the SF sync is one-way (SF → bedrock, via `data_sync.py:sync_activities`). Edits through the current PUT endpoint change the local copy and silently diverge from Salesforce. Per JP's 2026-04-23 decision, every inline edit on the Activities page must reflect back to the underlying SF Task or Event, with SF as the authoritative store.
+
+## Non-goals
+
+- **Two-way sync of Activities from sources other than SF** (Gmail-sync, Slack, calendar-sync). `source` column on each row already discriminates. Only rows with `source = 'salesforce'` + `sf_id IS NOT NULL` participate in write-back.
+- **Partial-write success.** Per JP: SF-first. If SF PATCH fails, we return the error to the client and do NOT touch bedrock.activity. No partial commit.
+- **Creating new Tasks/Events from the Activities page.** Create goes through existing TaskPanel / Event dialog paths. This PR expands update only.
+
+## Current state (verified at source, 2026-04-23)
+
+- `bedrock.activity` columns today (20): id, sf_id, sf_type, type, subject, description, description_html, activity_date, opportunity_id, account_id, contact_ids, project_task_id, sf_task_id, source, source_ref, source_thread_id, email_from, email_to, email_cc, email_snippet, meeting_duration_minutes, meeting_attendees, meeting_location, logged_by, owner_id, sf_last_modified, synced_at, sf_sync_status, created_at, updated_at, deleted_at.
+- SF Task SOQL pulled today (`data_sync.py:84-92`): Id, Subject, Status, Priority, ActivityDate, Description, OwnerId, WhoId, WhatId, Type, TaskSubtype, CreatedById, CreatedDate, LastModifiedDate, IsClosed, CallType, CallDurationInSeconds — 17 fields. **Status + Priority + TaskSubtype + CallType + IsClosed are pulled but dropped** in `_map_sf_task` (they're not in the INSERT column list at `data_sync.py:286-310`).
+- SF Event SOQL pulled today (`data_sync.py:95-103`): Id, Subject, Description, StartDateTime, EndDateTime, OwnerId, WhoId, WhatId, Type, Location, DurationInMinutes, IsAllDayEvent, CreatedById, CreatedDate, LastModifiedDate — 15 fields. **EndDateTime + Type + IsAllDayEvent are pulled but dropped** in `_map_sf_event`.
+- PUT `/api/activities/{uuid}` (`routes/activities.py:624-659`) accepts `ActivityUpdate` (`models.py:144-166`) with snake_case fields only; writes `bedrock.activity` directly via `UPDATE ... SET sets = ...`; never calls Salesforce.
+- `_enforce_record_ownership` (`main.py:862`) is the backend SF-owner gate used by all SF write endpoints. Activity PUT does NOT use it today (activity is local-only).
+
+## Design
+
+### Phase 0 — Catalog (must land before any code)
+
+**Deliverable:** `tasks/activity-sync-field-catalog.md` — a table per SObject (Task, Event) listing every field that meets all three criteria:
+- `updateable === true` in SF describe
+- `calculated === false` in SF describe
+- Not already inside the system-fields skip set (Id, CreatedById, CreatedDate, SystemModstamp, IsDeleted, etc.)
+
+For each field, capture: SF field name, SF type, new bedrock column name (snake_case), Postgres type, nullable, defaults, indexes, any lossy conversion (e.g. SF picklist → Postgres text + CHECK constraint), Event-only / Task-only / Both source. JP + Jac review this table before Phase 1.
+
+**Unknowns for Jac:** does Pursuit use Task.IsRecurrence / Event.IsRecurrence / RecurrenceType / RecurrenceActivityId? If so, do we store recurrence metadata or flatten exceptions? (Recurrence complicates the sync round-trip.) Does Pursuit customize Task/Event with `__c` custom fields? Catalog needs those too.
+
+### Phase 1 — Backend migration + sync engine expansion
+
+1. **Migration** (`db/migrations/2026-04-24-activity-sync-expansion.sql`):
+   - `ALTER TABLE bedrock.activity ADD COLUMN ...` for every new column in the catalog.
+   - Types match SF: picklist → TEXT with CHECK constraint, lookup → TEXT (SF IDs are 15/18 chars), datetime → TIMESTAMPTZ, duration → INTEGER, boolean → BOOLEAN.
+   - Backfill: `UPDATE bedrock.activity SET <new columns> = NULL` — then re-run full `sync_activities` with a `--force-full` flag to re-fetch every row from SF and populate. Safe because `ON CONFLICT (sf_id) DO UPDATE` already handles re-sync.
+
+2. **Sync engine updates** (`data_sync.py`):
+   - SOQL SELECT lists expanded to every catalog field.
+   - `_map_sf_task` + `_map_sf_event` populate all new columns.
+   - `_upsert_activity` INSERT column list + `ON CONFLICT` update list expanded. Single source of truth for the column list — suggest extracting to a constant so tests and migrations stay aligned.
+   - `test_activity_sync.py` gains per-field round-trip tests.
+
+3. **Pydantic models** (`models.py`):
+   - `Activity`, `ActivityUpdate`, `ActivityCreate` gain all new fields. `ActivityUpdate` continues to accept snake_case (Python convention). We add a **SF-field-alias layer** so the frontend can post SF-field-named payloads — see Phase 2.
+
+### Phase 2 — PUT handler: SF-first semantics
+
+Replace the body of `PUT /api/activities/{uuid}` (`routes/activities.py:624-659`) with:
+
+1. **Parse the request body.** Accept `{ [sf_field_name]: value }` — SF-field-named payload from the Activities page. Translate to snake_case using a `SF_FIELD_TO_BEDROCK_COLUMN` mapping defined next to the catalog. Unknown / non-whitelisted fields → 400.
+2. **Load the activity row.** `SELECT sf_id, sf_type, source, deleted_at FROM bedrock.activity WHERE id = $1`. If source ≠ 'salesforce' or sf_id is null → reject with 400 (write-back only applies to SF-synced rows).
+3. **Enforce SF ownership.** Call `_enforce_record_ownership(salesforce, sf_type, sf_id, user)` — reuses the existing helper that's already battle-tested.
+4. **PATCH Salesforce first.** `await salesforce.update_record(sf_type, sf_id, sf_fields)`. On failure: 400 with sanitized error (existing pattern at main.py:960-965).
+5. **Mirror to bedrock.** On SF success: `UPDATE bedrock.activity SET <cols>, sf_last_modified = now(), synced_at = now(), sf_sync_status = 'synced' WHERE id = $1`. Any exception at this stage → log + return success with a warning header (SF is authoritative; local will be corrected on next sync cycle).
+6. **Invalidate caches.** `cache.invalidate_prefix("activities:")`.
+7. **Return** `ApiResponse(success=True, data={"id": activity_id, "message": "Activity updated"})`.
+
+**Transactional contract (documented in the handler docstring):** SF is authoritative. If step 4 fails, no local write. If step 4 succeeds and step 5 fails, local row is transiently stale but the next `sync_activities` run will reconcile — no lost data, no double-write.
+
+**Auth & rate-limit:** keep `require_auth` + add `@limiter.limit("30/minute")` matching `update_account` / `update_contact`.
+
+### Phase 3 — Frontend Activities page (mega-B #9)
+
+1. `pages/Activities.tsx` fetches `apiService.getActivities({ limit: 500 })` for rows AND `apiService.getSchemaDescribe('Task')` + `apiService.getSchemaDescribe('Event')` for columns.
+2. `synthesizeActivitySchema(taskFields, eventFields)` merges the two describe responses (deduping by name, tagging `_source: 'Task' | 'Event' | 'Both'`). Filter to the catalog's allow-list.
+3. `buildSchemaColumns(merged, { entityType: 'Activity', onSaveField, canEditObject, sfUserId, accounts, users, ... })` — same pattern as Accounts/Contacts/Tasks.
+4. `onSaveField(uuid, sfFieldName, newValue)` → `apiService.updateActivity(uuid, { [sfFieldName]: newValue })` — SF-field-named payload, backend translates.
+5. Row.OwnerId comes from `bedrock.activity.owner_id` which stores the SF OwnerId — ownerGate works as-is.
+
+### Phase 4 — Wire into Details.tsx
+
+Per the existing mega-B plan: TAB_MAP swap, Tab label + HistoryIcon, `?tab=leads` → `?tab=activities` redirect, panel renders `<Activities />`. Leads.tsx stays on disk; cleanup PR one release cycle later.
+
+## Open questions for JP + Jac
+
+1. **Custom fields (`__c`).** Does Pursuit have Task or Event custom fields that should be editable? Jac can list them from SF describe. If yes, catalog includes them; if no, we exclude.
+2. **Recurrence.** Does the team use recurring Tasks or Events? If yes, editing a single occurrence vs the series has different SF semantics. For MVP, suggest: inline edit of a recurring Event's Subject writes the change to the series; editing the start/end datetime is blocked (force the series edit via the SF native UI).
+3. **Status / Priority picklist values per Record Type.** SF allows Record-Type-specific restrictions on Status values. If Pursuit uses them, the catalog needs the RT → allowed-values map. Same issue as `feedback_sf_stages_sacred` in the Opportunity plan.
+4. **Contact_ids[] write-back.** SF Task.WhoId is scalar; bedrock.activity.contact_ids is a list. For MVP, only contact_ids[0] round-trips. Secondary contacts on the local side are write-only (stay local).
+5. **Event vs Task discrimination at save time.** When the row's sf_type is Event but the field the user edited is Task-only (e.g., Priority), what happens? Two options: (a) reject with a clear error message, (b) silently drop the field. Prefer (a) — honest failure.
+6. **Backfill window.** Full re-sync of every activity row is ~N API calls for N activities. If the corpus is large (>100k rows), consider a chunked async backfill with progress tracking. Jac may have Bulk API quotas to consider.
+
+## Jac review checklist
+
+- [ ] Catalog table covers every field Pursuit actually uses (custom fields included).
+- [ ] Picklist → Postgres mapping has correct CHECK constraints (no values drift silently).
+- [ ] Recurrence handling is well-defined (or explicitly out-of-scope for MVP).
+- [ ] Bulk API quota impact of the backfill re-sync is acceptable during business hours OR scheduled for off-hours.
+- [ ] Page-layout readonly field overrides are understood — if SF page layout hides a field, should we still allow API PATCHes? (Yes per SF semantics; note in flagged-for-Jac doc.)
+- [ ] Transfer Record permission on OwnerId for all RM/Executive SF profiles.
+
+## Risks
+
+- **Backfill re-sync can be slow.** Consider a feature-flagged flip: new columns populated only for rows synced after the migration; a separate background job chews through historical rows.
+- **Field-catalog drift.** If Pursuit adds a new SF field after this PR merges, the Activities page won't know about it until the catalog is updated. Mitigation: catalog is code-generated from getSchemaDescribe at build time OR the frontend dynamically filters to `updateable && !calculated` at runtime (current schemaColumns pattern).
+- **PR size.** Backend migration + sync update + PUT handler + frontend + tests + docs = ~1.5-2k LOC. Reviewers should walk commit-by-commit pre-squash.
+- **SF API quotas.** Every inline edit is now an SF PATCH. If users bulk-edit, we consume API calls. Consider rate-limiting on the PUT endpoint (already at 30/minute per main.py patterns).
+
+## Phased execution order
+
+1. **Phase 0 (catalog)** — JP + Jac approve. Blocks Phase 1.
+2. **Phase 1a (migration + models)** — land as its own commit.
+3. **Phase 1b (sync engine expansion)** — land as its own commit; tests verify round-trip.
+4. **Phase 1c (backfill)** — separate commit; may run as a manual step after deploy.
+5. **Phase 2 (PUT handler)** — SF-first semantics; tests verify ownership + error paths.
+6. **Phase 3 (frontend Activities page)** — depends on Phase 2.
+7. **Phase 4 (Details.tsx wiring)** — depends on Phase 3.
+8. **Phase 5 (mega-B #10 + #11 + #12)** — RowCountCaption + AccountEditDialog Activities tab.
+9. **Final** — smoke test the full flow, typecheck, cut the PR against `dev`.
+
+## Today's state (2026-04-23)
+
+Branch `feat/megaB-lane-a-tail` has 10 commits:
+- 6 from the prior mega-B arc (A5, A8, A9, A10 affordance, A10 Opp audit, A10 #6 variant palette)
+- **7124853** `fix(inline-edit): stop DataGrid cellMouseDown from stealing focus` (#7a)
+- **afb608c** `feat(inline-edit): per-row ownerGate for schema-driven cells` (#7b)
+- **1426fad** `feat(schemaColumns): emit InlineEditable renderCells with ownerGate` (#7)
+- **37ac68d** `chore(sensitivity): classify Account.NumberOfEmployees, Contact.npsp__Primary_Affiliation__c, Activity block` (#8)
+
+Parked until the above sprint completes. After Phase 3 lands, the branch continues with #10 + #11 + #12, then PR opens against `dev`.