fix(enrichment): clear stale manual outputs with unmet deps

Author: TheodoreSpeaks

apps/sim/lib/table/deps.test.ts

@@ -162,6 +162,34 @@ describe('optimisticallyScheduleNewlyEligibleGroups — enrichment inputs', () =
     ).toEqual({})
   })
 
+  it('clears a manual enrichment when a mapped input change leaves dependencies unmet', () => {
+    const manualGroup = {
+      ...group,
+      autoRun: false,
+      dependencies: { columns: ['enabled'] },
+    }
+    const before = makeRow(
+      {
+        name: 'Person Name',
+        domain: 'old.example',
+        enabled: false,
+        g1_out: 'person@old.example',
+      },
+      { g1: { ...completedExec('wf-g1'), isManualRun: true } }
+    )
+
+    expect(
+      optimisticallyScheduleNewlyEligibleGroups([manualGroup], columns, before, {
+        domain: 'new.example',
+      })
+    ).toEqual({})
+    expect(
+      getInvalidatedManualEnrichmentOutputClears([manualGroup], before, {
+        domain: 'new.example',
+      })
+    ).toEqual({ g1_out: null })
+  })
+
   it('ignores legacy input mappings that point at the enrichment output', () => {
     const legacyGroup = {
       ...group,

apps/sim/lib/table/deps.ts

@@ -150,14 +150,10 @@ export function getInvalidatedManualEnrichmentOutputClears(
   patch: Partial<RowData>
 ): RowData {
   const patchedColumns = new Set(Object.keys(patch))
-  const afterRow = {
-    data: { ...beforeRow.data, ...patch } as RowData,
-  } as TableRow
   const clears: RowData = {}
 
   for (const group of groups) {
     if (group.type !== 'enrichment' || group.autoRun !== false) continue
-    if (!areGroupDepsSatisfied(group, afterRow)) continue
     if (!getGroupInvalidationColumns(group).some((columnId) => patchedColumns.has(columnId))) {
       continue
     }
@@ -222,7 +218,9 @@ export function optimisticallyScheduleNewlyEligibleGroups(
     }
 
     if (group.autoRun === false) {
-      if (areGroupDepsSatisfied(group, afterRow)) clearInvalidatedTerminalExecution()
+      if (group.type === 'enrichment' || areGroupDepsSatisfied(group, afterRow)) {
+        clearInvalidatedTerminalExecution()
+      }
       skipped++
       continue
     }

apps/sim/lib/table/rows/executions.test.ts

@@ -206,6 +206,37 @@ describe('deriveExecClearsForDataPatch enrichment inputs', () => {
     expect(result.executionsPatch).toEqual({ [MANUAL_ENRICHMENT_GROUP.id]: null })
   })
 
+  it('re-arms a completed manual enrichment when dependencies remain unmet', () => {
+    const manualGroup: WorkflowGroup = {
+      ...MANUAL_ENRICHMENT_GROUP,
+      dependencies: { columns: ['enabled'] },
+    }
+    const schema: TableSchema = {
+      columns: [
+        { id: 'domain', name: 'Domain', type: 'string' },
+        { id: 'enabled', name: 'Enabled', type: 'boolean' },
+        {
+          id: 'email',
+          name: 'Email',
+          type: 'string',
+          workflowGroupId: manualGroup.id,
+        },
+      ],
+      workflowGroups: [manualGroup],
+    }
+    const completed = { ...EXECUTION_STATE, status: 'completed' as const }
+
+    const result = deriveExecClearsForDataPatch(
+      { domain: 'new.example' },
+      schema,
+      { [manualGroup.id]: completed },
+      undefined,
+      { domain: 'new.example', enabled: false, email: '' }
+    )
+
+    expect(result.executionsPatch).toEqual({ [manualGroup.id]: null })
+  })
+
   it('does not re-arm when a legacy input mapping points at the enrichment output', () => {
     const legacyGroup: WorkflowGroup = {
       ...MANUAL_ENRICHMENT_GROUP,

apps/sim/lib/table/rows/executions.ts

@@ -200,9 +200,11 @@ export function deriveExecClearsForDataPatch(
     // after the patch — a checkbox was unchecked or a text dep cleared — there's
     // nothing to recompute. Leave the prior result alone instead of re-arming or
     // cancelling it; only checking a box / filling a dep drives downstream work.
-    if (!areGroupDepsSatisfied(group, afterRow)) continue
-
     const exec = existingExecutions[group.id]
+    const hasInvalidatedManualEnrichment =
+      group.type === 'enrichment' && group.autoRun === false && exec !== undefined
+    if (!hasInvalidatedManualEnrichment && !areGroupDepsSatisfied(group, afterRow)) continue
+
     if (exec) {
       const status = exec.status
       if (status === 'completed' || status === 'error' || status === 'cancelled') {