From 600fd400a7fc22296f51e959e52405bc3ae3c16e Mon Sep 17 00:00:00 2001 From: 2385533273 Date: Thu, 8 Oct 2026 06:25:06 -0700 Subject: [PATCH 1/3] fix(agent): report widget serialize metadata drift once --- .../extensions/agent/crdt/docOpMinter.test.ts | 137 ++++++++++++++++++ .../extensions/agent/crdt/docOpMinter.ts | 71 +++++++-- 2 files changed, 199 insertions(+), 9 deletions(-) diff --git a/src/workbench/extensions/agent/crdt/docOpMinter.test.ts b/src/workbench/extensions/agent/crdt/docOpMinter.test.ts index ab98e74f32a..be8534afab4 100644 --- a/src/workbench/extensions/agent/crdt/docOpMinter.test.ts +++ b/src/workbench/extensions/agent/crdt/docOpMinter.test.ts @@ -1301,6 +1301,143 @@ describe('attachDocOpMinter', () => { expect(minted).toEqual([]) }) + it.for([ + { + name: 'live true and stored false', + liveSerialize: true, + storedSerialize: false, + mints: true + }, + { + name: 'live undefined and stored false', + liveSerialize: undefined, + storedSerialize: false, + mints: false + }, + { + name: 'live false and stored true', + liveSerialize: false, + storedSerialize: true, + mints: false + } + ])('reports $name once across separate writes', async ({ + liveSerialize, + storedSerialize, + mints + }) => { + const { source } = seedGraph(graph) + const widget = source.widgets![0] + const stored = useWidgetValueStore().getWidget( + widgetId(graph.id, source.id, widget.name) + ) + assert.exists(stored) + stored.serialize = storedSerialize + widget.serialize = liveSerialize + + emitGraphIntent({ + type: 'set_widget', + graphId: graph.id, + nodeId: source.id, + name: 'steps', + value: 21, + previous: 20 + }) + await afterFlush() + emitGraphIntent({ + type: 'set_widget', + graphId: graph.id, + nodeId: source.id, + name: 'steps', + value: 22, + previous: 21 + }) + await afterFlush() + + expect(minted.map(({ op }) => op)).toEqual( + mints ? ['set_widget', 'set_widget'] : [] + ) + const reports = vi + .mocked(reportError) + .mock.calls.filter( + ([, metadata]) => + metadata.errorType === 'agent_crdt_widget_serialize_drift' + ) + expect(reports).toHaveLength(1) + expect(reports[0]?.[1].context).toEqual({ + graphId: graph.id, + nodeId: source.id, + widget: 'steps', + liveSerialize: liveSerialize ?? null, + storedSerialize + }) + }) + + it('reports a serialize disagreement while filtering an add-node snapshot', async () => { + const source = new TestSource() + graph.add(source) + const widget = source.widgets![0] + const stored = useWidgetValueStore().getWidget( + widgetId(graph.id, source.id, widget.name) + ) + assert.exists(stored) + stored.serialize = false + widget.serialize = undefined + + await afterFlush() + + expect(minted).toEqual([ + expect.objectContaining({ + op: 'add_node', + node: expect.objectContaining({ widgets_values: {} }) + }) + ]) + const reports = vi + .mocked(reportError) + .mock.calls.filter( + ([, metadata]) => + metadata.errorType === 'agent_crdt_widget_serialize_drift' + ) + expect(reports).toHaveLength(1) + expect(reports[0]?.[1].context).toEqual({ + graphId: graph.id, + nodeId: source.id, + widget: 'steps', + liveSerialize: null, + storedSerialize: false + }) + }) + + it('does not report when live and stored serialize flags agree', async () => { + const { source } = seedGraph(graph) + const widget = source.widgets![0] + const stored = useWidgetValueStore().getWidget( + widgetId(graph.id, source.id, widget.name) + ) + assert.exists(stored) + stored.serialize = false + widget.serialize = false + + emitGraphIntent({ + type: 'set_widget', + graphId: graph.id, + nodeId: source.id, + name: 'steps', + value: 21, + previous: 20 + }) + await afterFlush() + + expect(minted).toEqual([]) + expect( + vi + .mocked(reportError) + .mock.calls.filter( + ([, metadata]) => + metadata.errorType === 'agent_crdt_widget_serialize_drift' + ) + ).toEqual([]) + }) + it('uses the live serialize flag for direct store-path intents', async () => { const { source } = seedGraph(graph) source.widgets![0].serialize = false diff --git a/src/workbench/extensions/agent/crdt/docOpMinter.ts b/src/workbench/extensions/agent/crdt/docOpMinter.ts index a9c29b422ee..c9e11a91161 100644 --- a/src/workbench/extensions/agent/crdt/docOpMinter.ts +++ b/src/workbench/extensions/agent/crdt/docOpMinter.ts @@ -103,7 +103,16 @@ type PendingOp = * `flags.ghost` is a placement-in-progress marker the placement click clears * without minting, so the document must not record it. */ -export function wireNodeSnapshot(node: LGraphNode): WorkflowNode | null { +type SerializeDriftReporter = ( + name: string, + liveSerialize: boolean | undefined, + storedSerialize: boolean | undefined +) => void + +export function wireNodeSnapshot( + node: LGraphNode, + onSerializeDrift?: SerializeDriftReporter +): WorkflowNode | null { let serialized: ISerialisedNode try { serialized = node.serialize() @@ -119,13 +128,14 @@ export function wireNodeSnapshot(node: LGraphNode): WorkflowNode | null { } = wireSerialized const snapshot = { ...rest, flags } satisfies WorkflowNode return named && !node.isVirtualNode - ? { ...snapshot, widgets_values: valueWidgetsOnly(node, named) } + ? { ...snapshot, widgets_values: valueWidgetsOnly(node, named, onSerializeDrift) } : snapshot } function valueWidgetsOnly( node: LGraphNode, - named: object + named: object, + onSerializeDrift?: SerializeDriftReporter ): Record { const filtered: Record = {} const rootGraphId = node.graph?.rootGraph.id @@ -135,16 +145,27 @@ function valueWidgetsOnly( const stored = rootGraphId ? widgetValueStore.getWidget(widgetId(rootGraphId, node.id, name)) : undefined - if (isValueWidget(widget, stored)) filtered[name] = value + if ( + isValueWidget(widget, stored, (liveSerialize, storedSerialize) => + onSerializeDrift?.(name, liveSerialize, storedSerialize) + ) + ) + filtered[name] = value } return filtered } function isValueWidget( widget: IBaseWidget | undefined, - stored?: WidgetState + stored?: WidgetState, + onSerializeDrift?: ( + liveSerialize: boolean | undefined, + storedSerialize: boolean | undefined + ) => void ): boolean { if (!widget && !stored) return false + if (widget && stored && widget.serialize !== stored.serialize) + onSerializeDrift?.(widget.serialize, stored.serialize) // A destructuring default fires on absent AND present-but-undefined alike, // which is what `IBaseWidget`'s own optional fields mean: the live widget // did not state this, so the registration the intent was keyed by answers. @@ -176,7 +197,8 @@ function reachableIntentGraph( */ function isValueWidgetWrite( owner: LGraphNode | null, - event: IntentOf<'set_widget'> + event: IntentOf<'set_widget'>, + onSerializeDrift?: SerializeDriftReporter ): boolean { const rootGraphId = owner?.graph?.rootGraph.id ?? event.graphId const stored = useWidgetValueStore().getWidget( @@ -185,7 +207,9 @@ function isValueWidgetWrite( const widget = owner?.widgets?.find( (candidate) => candidate.name === event.name ) - return isValueWidget(widget, stored) + return isValueWidget(widget, stored, (liveSerialize, storedSerialize) => + onSerializeDrift?.(event.name, liveSerialize, storedSerialize) + ) } /** @@ -400,7 +424,9 @@ export function attachDocOpMinter(deps: DocOpMinterDeps): DocOpMinter { } const { graph, node } = entry if (node.graph !== graph) continue - const snapshot = wireNodeSnapshot(node) + const snapshot = wireNodeSnapshot(node, (name, live, stored) => + reportSerializeDrift(graph.id, node.id, name, live, stored) + ) if (!snapshot) { console.error( '[agent-crdt] add_node mint dropped: no snapshot for node', @@ -431,6 +457,28 @@ export function attachDocOpMinter(deps: DocOpMinterDeps): DocOpMinter { reportError(new Error(message), { surface: 'agent', errorType, context }) } + function reportSerializeDrift( + graphId: string, + nodeId: NodeId, + name: string, + liveSerialize: boolean | undefined, + storedSerialize: boolean | undefined + ): void { + reportOnce( + `widget_serialize:${graphId}:${String(nodeId)}:${name}`, + `Widget ${name} on node ${String(nodeId)} has a live serialize flag that disagrees with its registered metadata`, + 'agent_crdt_widget_serialize_drift', + { + graphId, + nodeId, + widget: name, + liveSerialize: liveSerialize ?? null, + storedSerialize: storedSerialize ?? null + }, + reportedDrift + ) + } + /** True when `graph` is the bound document's root graph. */ function isMintableRootScope( graph: LGraph, @@ -468,7 +516,12 @@ export function attachDocOpMinter(deps: DocOpMinterDeps): DocOpMinter { const owner = eventGraph ? findNodeInHierarchy(eventGraph, event.nodeId) : null - if (!isValueWidgetWrite(owner, event)) return + if ( + !isValueWidgetWrite(owner, event, (name, live, stored) => + reportSerializeDrift(event.graphId, event.nodeId, name, live, stored) + ) + ) + return const rootGraphId = deps.boundRootGraphId() ?? graph.id const operation = routedWidgetOperation( graph, From 36eb9d7a852d1bc63bd52c555ea3c1866c6ff32a Mon Sep 17 00:00:00 2001 From: 2385533273 Date: Thu, 8 Oct 2026 06:26:59 -0700 Subject: [PATCH 2/3] chore: keep snapshot documentation attached to its API --- src/workbench/extensions/agent/crdt/docOpMinter.ts | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/workbench/extensions/agent/crdt/docOpMinter.ts b/src/workbench/extensions/agent/crdt/docOpMinter.ts index c9e11a91161..3c5a7ae0c9c 100644 --- a/src/workbench/extensions/agent/crdt/docOpMinter.ts +++ b/src/workbench/extensions/agent/crdt/docOpMinter.ts @@ -87,6 +87,12 @@ type PendingOp = | { kind: 'add_node'; graph: LGraph; node: LGraphNode } | { kind: 'op'; operation: GraphOperation } +type SerializeDriftReporter = ( + name: string, + liveSerialize: boolean | undefined, + storedSerialize: boolean | undefined +) => void + /** * Serialized save-format node. `widgets_values` is NAME-KEYED via the node's * own `widgets_values_named` minus non-value widgets (FE-1904: the doc host's @@ -103,12 +109,6 @@ type PendingOp = * `flags.ghost` is a placement-in-progress marker the placement click clears * without minting, so the document must not record it. */ -type SerializeDriftReporter = ( - name: string, - liveSerialize: boolean | undefined, - storedSerialize: boolean | undefined -) => void - export function wireNodeSnapshot( node: LGraphNode, onSerializeDrift?: SerializeDriftReporter From e08d90faf9e75fe555cdc326dab20a66a3a78b42 Mon Sep 17 00:00:00 2001 From: 2385533273 Date: Thu, 8 Oct 2026 07:01:03 -0700 Subject: [PATCH 3/3] fix(agent): detect serialize drift for omitted widgets --- .../extensions/agent/crdt/docOpMinter.test.ts | 47 ++++++++++++++++--- .../extensions/agent/crdt/docOpMinter.ts | 27 +++++++---- 2 files changed, 58 insertions(+), 16 deletions(-) diff --git a/src/workbench/extensions/agent/crdt/docOpMinter.test.ts b/src/workbench/extensions/agent/crdt/docOpMinter.test.ts index be8534afab4..6da27075344 100644 --- a/src/workbench/extensions/agent/crdt/docOpMinter.test.ts +++ b/src/workbench/extensions/agent/crdt/docOpMinter.test.ts @@ -1306,24 +1306,24 @@ describe('attachDocOpMinter', () => { name: 'live true and stored false', liveSerialize: true, storedSerialize: false, - mints: true + expectedOps: ['set_widget', 'set_widget'] }, { name: 'live undefined and stored false', liveSerialize: undefined, storedSerialize: false, - mints: false + expectedOps: [] }, { name: 'live false and stored true', liveSerialize: false, storedSerialize: true, - mints: false + expectedOps: [] } ])('reports $name once across separate writes', async ({ liveSerialize, storedSerialize, - mints + expectedOps }) => { const { source } = seedGraph(graph) const widget = source.widgets![0] @@ -1353,9 +1353,7 @@ describe('attachDocOpMinter', () => { }) await afterFlush() - expect(minted.map(({ op }) => op)).toEqual( - mints ? ['set_widget', 'set_widget'] : [] - ) + expect(minted.map(({ op }) => op)).toEqual(expectedOps) const reports = vi .mocked(reportError) .mock.calls.filter( @@ -1407,6 +1405,41 @@ describe('attachDocOpMinter', () => { }) }) + it('reports a live serialize:false widget omitted by add-node serialization', async () => { + const source = new TestSource() + graph.add(source) + const widget = source.widgets![0] + const stored = useWidgetValueStore().getWidget( + widgetId(graph.id, source.id, widget.name) + ) + assert.exists(stored) + stored.serialize = true + widget.serialize = false + + await afterFlush() + + expect(minted).toEqual([ + expect.objectContaining({ + op: 'add_node', + node: expect.objectContaining({ widgets_values: {} }) + }) + ]) + const reports = vi + .mocked(reportError) + .mock.calls.filter( + ([, metadata]) => + metadata.errorType === 'agent_crdt_widget_serialize_drift' + ) + expect(reports).toHaveLength(1) + expect(reports[0]?.[1].context).toEqual({ + graphId: graph.id, + nodeId: source.id, + widget: 'steps', + liveSerialize: false, + storedSerialize: true + }) + }) + it('does not report when live and stored serialize flags agree', async () => { const { source } = seedGraph(graph) const widget = source.widgets![0] diff --git a/src/workbench/extensions/agent/crdt/docOpMinter.ts b/src/workbench/extensions/agent/crdt/docOpMinter.ts index 3c5a7ae0c9c..e84f8f3ecfc 100644 --- a/src/workbench/extensions/agent/crdt/docOpMinter.ts +++ b/src/workbench/extensions/agent/crdt/docOpMinter.ts @@ -127,15 +127,29 @@ export function wireNodeSnapshot( ...rest } = wireSerialized const snapshot = { ...rest, flags } satisfies WorkflowNode + + // serialize() omits widgets marked serialize:false from its named payload. + // Inspect the live widgets first so those omissions still report drift. + const rootGraphId = node.graph?.rootGraph.id + if (rootGraphId && onSerializeDrift) { + const widgetValueStore = useWidgetValueStore() + for (const widget of node.widgets ?? []) { + const stored = widgetValueStore.getWidget( + widgetId(rootGraphId, node.id, widget.name) + ) + if (stored && widget.serialize !== stored.serialize) + onSerializeDrift(widget.name, widget.serialize, stored.serialize) + } + } + return named && !node.isVirtualNode - ? { ...snapshot, widgets_values: valueWidgetsOnly(node, named, onSerializeDrift) } + ? { ...snapshot, widgets_values: valueWidgetsOnly(node, named) } : snapshot } function valueWidgetsOnly( node: LGraphNode, - named: object, - onSerializeDrift?: SerializeDriftReporter + named: object ): Record { const filtered: Record = {} const rootGraphId = node.graph?.rootGraph.id @@ -145,12 +159,7 @@ function valueWidgetsOnly( const stored = rootGraphId ? widgetValueStore.getWidget(widgetId(rootGraphId, node.id, name)) : undefined - if ( - isValueWidget(widget, stored, (liveSerialize, storedSerialize) => - onSerializeDrift?.(name, liveSerialize, storedSerialize) - ) - ) - filtered[name] = value + if (isValueWidget(widget, stored)) filtered[name] = value } return filtered }