The Notes field contains notes that you can enter about a task.
You can use task notes to help maintain a history for a task.

@return notes
326136
public String getNotes()
   {
      String notes = (String) getCachedValue(TaskField.NOTES);
      return (notes == null ? "" : notes);
   }
216322
private function totalNotes(): Collection
    {
        return DB::table('gedcom')
            ->leftJoin('other', static function (JoinClause $join): void {
                $join
                    ->on('o_file', '=', 'gedcom_id')
                    ->where('o_type', '=', 'NOTE');
            })
            ->groupBy('gedcom_id')
            ->pluck(DB::raw('COUNT(o_id)'), 'gedcom_id')
            ->map(static function (string $count) {
                return (int) $count;
            });
    }
1140581
def fieldsets
        content = ''
        each_with_rescue(@notes) do |note|
          next unless note.has_fieldset?
          content << <<-HTML
            <fieldset id="#{note.to_sym}_debug_info" style="display: none">
              <legend>#{note.legend}</legend>
              <div>#{note.content}</div>
            </fieldset>
          HTML
        end
        content
      end
180404
public function getNotes()
    {
        $entities = [];
        if ($this->entity->getNotes()) {
            foreach ($this->entity->getNotes() as $note) {
                $entities[] = $note;
            }
        }

        return $entities;
    }
392356
def generate_notes(notes):
        
        new_notes = []

        for note in notes:
            tmp_note = {}
            for note_item in notes[note]:
                tmp_note[note_item] = notes[note][note_item]

            new_notes.append(tmp_note)

        return new_notes
68002
public function getCMSFields()
    {
        // Create Field Tab Set:
        
        $fields = FieldList::create(TabSet::create('Root'));
        
        // Define Placeholder:
        
        $placeholder = _t(__CLASS__ . '.DROPDOWNSELECT', 'Select');
        
        // Create Main Fields:
        
        $fields->addFieldsToTab(
            'Root.Main',
            [
                DropdownField::create(
                    'PageClass',
                    $this->fieldLabel('PageClass'),
                    $this->getPageClassOptions()
                )->setEmptyString(' ')->setAttribute('data-placeholder', $placeholder),
                DropdownField::create(
                    'MyTemplateID',
                    $this->fieldLabel('MyTemplateID'),
                    Template::get()->map()
                )->setEmptyString(' ')->setAttribute('data-placeholder', $placeholder),
                DropdownField::create(
                    'MyLayoutID',
                    $this->fieldLabel('MyLayoutID'),
                    Layout::get()->map()
                )->setEmptyString(' ')->setAttribute('data-placeholder', $placeholder)
            ]
        );
        
        // Create Grid Field Config:
        
        $spansConfig = GridFieldConfig_RecordEditor::create();
        
        // Obtain Edit Form Component:
        
        $editComponent = $spansConfig->getComponentByType(GridFieldDetailForm::class);
        
        // Define Edit Form Callback:
        
        $editComponent->setItemEditFormCallback(function ($form, $itemRequest) {
            
            // Define Column Options:
            
            $form->Fields()->dataFieldByName('ColumnID')->setSource($this->getColumnOptions());
            
        });
        
        // Create Column Spans Grid Field:
        
        $spans = GridField::create(
            'ColumnSpans',
            $this->fieldLabel('Spans'),
            $this->ColumnSpans(),
            $spansConfig
        );
        
        // Create Column Spans Tab:
        
        $fields->findOrMakeTab('Root.ColumnSpans', $this->owner->fieldLabel('Spans'));
        
        // Add Grid Field to Column Spans Tab:
        
        $fields->addFieldToTab('Root.ColumnSpans', $spans);
        
        // Extend Field Objects:
        
        $this->extend('updateCMSFields', $fields);
        
        // Answer Field Objects:
        
        return $fields;
    }
795111
public function getCMSFields()
    {
        $fields = parent::getCMSFields();
        $fields->removeByName('Content');
        if (Director::isDev()) {
            $fields->addFieldsToTab(
                'Root.Developer',
                array(
                    LiteralField::create(
                        'DeveloperNote',
                        '<p class="message warning">'._t('Placeable.DEVNOTE', 'This tab is only visible during development and is intended to help debug.').'</p>'
                    ),
                    GridField::create(
                        'Regions',
                        _t('PlaceablePage.SECTIONS', 'Regions'),
                        $this->Regions(),
                        GridFieldConfig_RecordEditor::create()
                    )
                )
            );
        }
        foreach ($this->PageFields as $region) {
            $fields->addFieldToTab(
                "Root.{$region->Type}",
                HeaderField::create(
                    "header[$region->Type]",
                    $region->Title
                )
            );
            foreach ($region->Fields as $field) {
                $fields->addFieldToTab(
                    "Root.{$region->Type}",
                    $field
                );
            }
            foreach ($region->Blocks as $Block) {
                $blockfields = CompositeField::create(
                    HeaderField::create(
                        "header[$Block->Type]",
                        $Block->Title
                    )
                );
                foreach ($Block->Fields as $field) {
                    $blockfields->push($field);
                }
                $fields->addFieldToTab(
                    "Root.{$region->Type}",
                    $blockfields
                );
            }
        }
        return $fields;
    }
1367940
protected function displayNotes()
    {
        $notes = array();

        if ($this->note !== null) {
            $note = new SwatMessage($this->note);
            $note->content_type = $this->note_content_type;
            $notes[] = $note;
        }

        $control = $this->getFirstDescendant('SwatControl');
        if ($control !== null) {
            $note = $control->getNote();
            if ($note !== null) {
                $notes[] = $note;
            }
        }

        if (count($notes) === 1) {
            $note = reset($notes);
            $note_div = new SwatHtmlTag('div');
            $note_div->class = 'swat-note';
            $note_div->setContent($note->primary_content, $note->content_type);
            $note_div->display();
        } elseif (count($notes) > 1) {
            $note_list = new SwatHtmlTag('ul');
            $note_list->class = 'swat-note';
            $note_list->open();

            $li_tag = new SwatHtmlTag('li');
            foreach ($notes as $note) {
                $li_tag->setContent(
                    $note->primary_content,
                    $note->content_type
                );

                $li_tag->display();
            }

            $note_list->close();
        }
    }
852768
public SortField[] sortFields() {
        return new SortField[]{new SortField(FIELD_NAME, new FieldComparatorSource() {
            @Override
            public FieldComparator<?> newComparator(String field,
                                                    int hits,
                                                    int sort,
                                                    boolean reversed) throws IOException {
                return new ClusteringKeySorter(ClusteringKeyMapper.this, hits, field);
            }
        })};
    }
1164776
public function getFields() {
        if($this->cachedFields == null) {
            $this->cachedFields = $this->createFields();
        }

        return $this->cachedFields;
    }
348382
public List<TaskState> getTaskStates() {
    return ImmutableList.<TaskState>builder().addAll(this.taskStates.values()).build();
  }
1280771
private List<TaskField> getAllTaskExtendedAttributes()
   {
      ArrayList<TaskField> result = new ArrayList<TaskField>();
      result.addAll(Arrays.asList(TaskFieldLists.CUSTOM_TEXT));
      result.addAll(Arrays.asList(TaskFieldLists.CUSTOM_START));
      result.addAll(Arrays.asList(TaskFieldLists.CUSTOM_FINISH));
      result.addAll(Arrays.asList(TaskFieldLists.CUSTOM_COST));
      result.addAll(Arrays.asList(TaskFieldLists.CUSTOM_DATE));
      result.addAll(Arrays.asList(TaskFieldLists.CUSTOM_FLAG));
      result.addAll(Arrays.asList(TaskFieldLists.CUSTOM_NUMBER));
      result.addAll(Arrays.asList(TaskFieldLists.CUSTOM_DURATION));
      result.addAll(Arrays.asList(TaskFieldLists.CUSTOM_OUTLINE_CODE));
      result.addAll(Arrays.asList(TaskFieldLists.ENTERPRISE_COST));
      result.addAll(Arrays.asList(TaskFieldLists.ENTERPRISE_DATE));
      result.addAll(Arrays.asList(TaskFieldLists.ENTERPRISE_DURATION));
      result.addAll(Arrays.asList(TaskFieldLists.ENTERPRISE_FLAG));
      result.addAll(Arrays.asList(TaskFieldLists.ENTERPRISE_NUMBER));
      result.addAll(Arrays.asList(TaskFieldLists.ENTERPRISE_TEXT));
      return result;
   }
58571
private function getNotes()
    {
        $xpath = $this->reader->getXpath();

        $nodes = $xpath->query($this->reader->getRoot().'/cbc:Note');
        $notes = [];
        if ($nodes->length === 0) {
            return $notes;
        }

        /** @var \DOMElement $node */
        foreach ($nodes as $node) {
            $notes[] = $node->nodeValue;
        }

        return $notes;
    }
14651
public static function create_notes_returns() {
        return new external_multiple_structure(
            new external_single_structure(
                array(
                    'clientnoteid' => new external_value(PARAM_ALPHANUMEXT, 'your own id for the note', VALUE_OPTIONAL),
                    'noteid' => new external_value(PARAM_INT, 'ID of the created note when successful, -1 when failed'),
                    'errormessage' => new external_value(PARAM_TEXT, 'error message - if failed', VALUE_OPTIONAL)
                )
            )
        );
    }
856494
def show_notes(self):
        
        if self.notes:
            bytecode._PrintSubBanner("Notes")
            for i in self.notes:
                bytecode._PrintNote(i)
            bytecode._PrintSubBanner()
872517
public function summaryFields()
    {
        $rawFields = $this->config()->get('summary_fields');

        // Merge associative / numeric keys
        $fields = [];
        foreach ($rawFields as $key => $value) {
            if (is_int($key)) {
                $key = $value;
            }
            $fields[$key] = $value;
        }

        if (!$fields) {
            $fields = array();
            // try to scaffold a couple of usual suspects
            if ($this->hasField('Name')) {
                $fields['Name'] = 'Name';
            }
            if (static::getSchema()->fieldSpec($this, 'Title')) {
                $fields['Title'] = 'Title';
            }
            if ($this->hasField('Description')) {
                $fields['Description'] = 'Description';
            }
            if ($this->hasField('FirstName')) {
                $fields['FirstName'] = 'First Name';
            }
        }
        $this->extend("updateSummaryFields", $fields);

        // Final fail-over, just list ID field
        if (!$fields) {
            $fields['ID'] = 'ID';
        }

        // Localize fields (if possible)
        foreach ($this->fieldLabels(false) as $name => $label) {
            // only attempt to localize if the label definition is the same as the field name.
            // this will preserve any custom labels set in the summary_fields configuration
            if (isset($fields[$name]) && $name === $fields[$name]) {
                $fields[$name] = $label;
            }
        }

        return $fields;
    }
933997
public short[] getStrictDurations() {
	  Vector durations = new Vector();
	  short currentDuration = 0;
	  for (int i=0; i<m_notes.size(); i++) {
		  currentDuration = ((Note)(m_notes.elementAt(i))).getStrictDuration();
		  if (durations.indexOf(new Short(currentDuration))==-1)
			  durations.addElement(currentDuration);
	  }
	  if (durations.size()==0)
		  return null;
	  else {
		  //sort the durations
		  Vector sortedDurations = new Vector();
		  for (int i=0; i<durations.size(); i++) {
			  int j=0;
			  while (j<sortedDurations.size()
					  && (Short) sortedDurations.elementAt(j) <
					  ((Short) durations.elementAt(i))
					  )
				  j++;
			  sortedDurations.insertElementAt(durations.elementAt(i),j);
		  }
		  short[] durationsAsArray = new short[sortedDurations.size()];
		  for (int i=0; i<sortedDurations.size(); i++)
			  durationsAsArray [i] = (Short) sortedDurations.elementAt(i);
		  return durationsAsArray;
	  }
  }