apollo-client: [v3] cache.modify with optimistic result does not broadcast change

I have a schema where a Taxonomy is a self referencing node, in a one-to-many parent child relationship:

type Taxonomy {  
  id: ID!
  title: String! @search(by: [fulltext])
  parent: Taxonomy
  children: [Taxonomy] @hasInverse(field: parent)
}

The @hasInverse directive is dgraph-specific, and sets up a two-way relationship, that updated the inverse edge when one is modified.

I am attempting to optimistically add a Taxonomy node under a parent in the following mutation:

mutation AddTaxonomy ($title: String!, $parentId: ID!) {

    addTaxonomy(input: [{
        title: $title,
        parent: {
            id: $parentId
        }
    }]) {
        taxonomy {
            id,
            title,
            parent {
                id
            }            
        }
    }
}

I want the UI to update optimistically, inserting a temporary object until the query is completed, so I specify a compatible optimistic result.

Apollo doesn’t know anything about the @hasInverse directive, so I create options that provide an update function to modify the cache and keep the parent’s children up-to-date in each case.

    const id = getTmpId();    

    const options = {
        variables: {
            title,
            parentId: parentId
        },
        optimisticResponse: {
            __typename: "Mutation",
            addTaxonomy: {
                __typename: "AddTaxonomyPayload",
                taxonomy: [{
                    __typename: "Taxonomy",
                    id,
                    title: "TEMP",
                    parent: {
                        __typename: "Taxonomy",
                        id: parentId
                    }
                }]
            }
        },
        update: (cache, { data: { addTaxonomy } }) => {
            const added = addTaxonomy.taxonomy[0];
            const parent = added.parent;

            cache.modify({
                id: cache.identify(parent),
                fields: {
                    children: (existing: Reference[]) => {   
                        const newTaxonomy = cache.writeFragment({
                            data: added,
                            fragment: gql`
                              fragment NewTaxonomy on Taxonomy {
                                id
                                title
                                parent {
                                    id
                                }
                              }
                            `
                          });
                        return [...existing, newTaxonomy]
                    }
                }
            });
            
        }
    }

Both results (optimistic and actual) reach the update function. Both results are the same shape. Only the actual result from the query emits in a change in the query data shown in my UI. The temporary Taxonomy is nowhere to be seen.

I might be missing something, but it sure seems like a bug to me.

More, after I delete and add the node a few times in succession, eventually the add fails silently, and the result data from the add payload gets emitted to the UI as ‘undefined’.

Not sure what’s going on there…

Is AC3 still ironing out bugs with this kind of stuff?