@@ -0,0 +1,10 @@
+---
+'@objectstack/metadata-protocol': patch
+---
+
+fix(metadata-protocol): a flow read's `_diagnostics` and the restore doors judge a stored flow in its D2-converted spelling, as the save and publish doors do
+
+Clause-②: yes (widening)
+Metadata-protocol: none
+
+A flow stored in a legacy ADR-0087 D2 spelling that the automation engine registers (a `get_record` node's `config.filters`, for one) is accepted by the save door and both publish doors, but every read of it (`GET /meta/flow/:name`, the list read, the `?layers=true` read, the draft read and the diagnostics sweep) answered `_diagnostics: { valid: false }` naming the legacy key, and both restore doors (`rollbackMetaItem`, `revertCommit`) refused a history version in that spelling with `422 INVALID_METADATA`. The read's schema verdict and the restore doors' runtime rules now judge the row through the doors' conversion seam, with the chain the engine replays when it registers a stored row, and serve or restore the row as stored. A flow the rules still refuse once converted still reads `valid: false`, with the errors its current spelling gets, and a version refused once converted is still refused at restore.
@@ -38,6 +38,7 @@ import { zodIssuesToMetadataIssues } from './protocol.js';
 // landed by #8300). Composed into `decorateMetadataItem` below — see the
 // ordering note there for why it is not applied per read exit.
 import { redactMetadataItem } from './metadata-redaction.js';
+import { storedFlowVerdictBody } from './protocol-flow-save-replay.js';
 // [#26707] The snapshot key a write type's findings are spelled under — the
 // runtime gate's own answer, so the publish verdict below is re-spelled
 // against the same prefix the gate wrote it with.
@@ -276,7 +277,18 @@ export function computeMetadataDiagnostics(
     // [#26886] …and judge each picklist-bound field as its author wrote it:
     // the `options` the runtime resolved onto it are not part of that shape
     // ({@link withoutResolvedPicklistOptions}).
-    const candidate = withoutResolvedPicklistOptions(stripReadDecorations(item));
+    //
+    // [#29696] …and judge a FLOW in the spelling every door judges it in: its
+    // ADR-0087 D2-converted body ({@link storedFlowVerdictBody}, the seam the
+    // save door's fallback verdict, both publish doors and the restore doors
+    // judge through). A served flow is a row at rest that no read converts
+    // (`convertStoredItem` skips `flow`; the engine converts it when it
+    // registers it), so judged as stored a legacy D2 spelling (`get_record`
+    // `config.filters`) read `valid: false` while every door and the engine
+    // accepted it. For the VERDICT only: the read serves the body it was
+    // handed. Not a redaction, so the #8154 order below is untouched: the
+    // body judged is still the unredacted one.
+    const candidate = withoutResolvedPicklistOptions(storedFlowVerdictBody(singular, stripReadDecorations(item)));
 
     // [#25783] A document parsed before against this same schema is answered
     // from the memo — see "The verdict memo" above.
 
@@ -160,7 +160,11 @@ export async function refuseRestoredBodyTheSaveDoorRefuses(
         type,
         name,
         state: 'active',
-        body,
+        // [#29696] A flow version is judged in its D2-converted spelling, as
+        // both publish doors judge a stored flow draft (#29557): a history
+        // body is a row at rest. Restored as stored; the credential read below
+        // reads the stored version.
+        body: storedFlowVerdictBody(type, body),
         source,
         packageId: binding,
         ...(channel
 
@@ -39,6 +39,12 @@
  * publish verdict (`draftPublishVerdict`) judge. One judge, one spelling: a
  * legacy D2 spelling the save door accepted and stored raw is accepted at
  * publish too, and what goes live is still the stored bytes.
+ *
+ * [#29696] The two other judges of a flow at rest judge through it too: the
+ * read's `_diagnostics` schema half (`computeMetadataDiagnostics`, every read
+ * exit that decorates) and the restore doors' runtime rules
+ * (`refuseRestoredBodyTheSaveDoorRefuses`, for `rollbackMetaItem` and
+ * `revertCommit`). Each serves or restores the body as stored.
  */
 
 import { ALL_CONVERSIONS, applyConversionsToFlow, type ConversionNotice } from '@objectstack/spec';
@@ -141,19 +147,32 @@ export function flowVerdictBody(body: unknown, options: { includeRetired: boolea
 }
 
 /**
- * [#29557] The body a publish judges a STORED draft in: for a `flow`, the
- * {@link flowVerdictBody} of the draft row with the retired entries included;
- * every other type, the draft as stored. The two publish doors and the draft
- * read's publish verdict judge through here and promote, store and serve the
- * draft as stored.
+ * [#29557] The body a STORED flow is judged in: for a `flow`, the
+ * {@link flowVerdictBody} of the row with the retired entries included; every
+ * other type, the row as stored. The two publish doors and the draft read's
+ * publish verdict judge a stored draft through here, [#29696] the read's
+ * `_diagnostics` schema half judges a served row and the restore doors' runtime
+ * rules a history version; each promotes, serves or restores the row as stored.
+ *
+ * A stored row is data at rest, so the chain is the one the automation engine
+ * replays when it registers the row: its stored-flow canonicalizer
+ * (`canonicalizeFlow` in `service-automation/src/flow-definitions.ts`), which
+ * every caller but the save door calls with no options, so retired entries
+ * included, and which excludes `CONVERSIONS_NOT_REPLAYED_AT_REHYDRATION`. That
+ * list and {@link FLOW_FALLBACK_VERDICT_NOT_REPLAYED} name the same one entry,
+ * `flow-decision-mode-inclusive-explicit`, so this verdict replays exactly the
+ * engine's chain. The entry is a DEFAULT FLIP, not a rescue: it writes
+ * `mode: 'inclusive'` where a decision omits `mode`, and an omitted `mode`
+ * parses (it means exclusive), so leaving it out never turns an accepted body
+ * into a refused one; it only keeps the verdict from judging a meaning the row
+ * does not have. By maintainer ruling (letter C on #15429) it is not replayed
+ * over stored flows at all. No read path converts a flow either:
+ * `convertStoredItem` skips `flow`, and `applyConversionsToStoredItem` is not
+ * applied to it.
  *
- * A stored draft is a row at rest, so the chain is the full one: the one the
- * automation engine replays when it registers the published row (its stored-
- * flow canonicalizer, which every caller but the save door calls with no
- * options) and the one `applyConversionsToStoredItem` replays on read. The
- * retired-entry predicate of the save door ({@link flowSaveReplaysRetired},
+ * The retired-entry predicate of the save door ({@link flowSaveReplaysRetired},
  * #23903 ruling B') is not asked again: it judges authored input, and the
- * draft's own save asked it, in draft mode as in publish mode. `type` is the
+ * row's own save asked it, in draft mode as in publish mode. `type` is the
  * singular type name.
  */
 export function storedFlowVerdictBody(type: string, body: unknown): unknown {
 
@@ -975,6 +975,44 @@ describe('[#29007] a stored object carrying the retired titleFormat', () => {
     });
 });
 
+// [#29557, #29696] The legacy-D2 flow fixtures the publish doors (#29557) and the
+// reads (#29696) are both pinned on.
+
+/** start → get_record → end, the match map spelled under `filterKey`. */
+const fetchFlow = (name: string, filterKey: 'filters' | 'filter') => ({
+    name,
+    label: name,
+    type: 'autolaunched',
+    nodes: [
+        { id: 'start', type: 'start', label: 'Start' },
+        { id: 'fetch', type: 'get_record', label: 'Fetch', config: { objectName: 'deal', [filterKey]: { name: 'Acme' }, outputVariable: 'deal' } },
+        { id: 'end', type: 'end', label: 'End' },
+    ],
+    edges: [
+        { id: 'e1', source: 'start', target: 'fetch' },
+        { id: 'e2', source: 'fetch', target: 'end' },
+    ],
+});
+
+/** The stored active row a legacy draft is a re-save of. */
+async function seedActive(engine: any, body: { name: string }) {
+    await engine.insert('sys_metadata', {
+        type: 'flow',
+        name: body.name,
+        organization_id: null,
+        package_id: PKG,
+        state: 'active',
+        metadata: JSON.stringify(body),
+        checksum: hashSpec(body, 'flow'),
+        version: 1,
+    });
+}
+
+const storedConfig = (rows: Map<string, Row>, name: string, state: 'active' | 'draft') => {
+    const row = [...rows.values()].find((r) => r.type === 'flow' && r.name === name && r.state === state);
+    return row ? JSON.parse(row.metadata).nodes[1].config : undefined;
+};
+
 /**
  * [#29557] A flow draft stored in a legacy ADR-0087 D2 spelling the engine
  * registers (`get_record` `config.filters`, `flow-node-crud-filter-alias`). The
@@ -998,41 +1036,6 @@ describe('[#29557] a stored flow draft in a legacy D2 spelling the engine regist
         warn.mockRestore();
     });
 
-    /** start → get_record → end, the match map spelled under `filterKey`. */
-    const fetchFlow = (name: string, filterKey: 'filters' | 'filter') => ({
-        name,
-        label: name,
-        type: 'autolaunched',
-        nodes: [
-            { id: 'start', type: 'start', label: 'Start' },
-            { id: 'fetch', type: 'get_record', label: 'Fetch', config: { objectName: 'deal', [filterKey]: { name: 'Acme' }, outputVariable: 'deal' } },
-            { id: 'end', type: 'end', label: 'End' },
-        ],
-        edges: [
-            { id: 'e1', source: 'start', target: 'fetch' },
-            { id: 'e2', source: 'fetch', target: 'end' },
-        ],
-    });
-
-    /** The stored active row a legacy draft is a re-save of. */
-    async function seedActive(engine: any, body: { name: string }) {
-        await engine.insert('sys_metadata', {
-            type: 'flow',
-            name: body.name,
-            organization_id: null,
-            package_id: PKG,
-            state: 'active',
-            metadata: JSON.stringify(body),
-            checksum: hashSpec(body, 'flow'),
-            version: 1,
-        });
-    }
-
-    const storedConfig = (rows: Map<string, Row>, name: string, state: 'active' | 'draft') => {
-        const row = [...rows.values()].find((r) => r.type === 'flow' && r.name === name && r.state === state);
-        return row ? JSON.parse(row.metadata).nodes[1].config : undefined;
-    };
-
     async function stageLegacy(name: string, body = fetchFlow(name, 'filters')) {
         const { engine, rows } = makeStubEngine();
         const protocol = new ObjectStackProtocolImplementation(engine);
@@ -1071,8 +1074,7 @@ describe('[#29557] a stored flow draft in a legacy D2 spelling the engine regist
         expect(await (protocol as any).draftPublishVerdict({ type: 'flow', name: 'legacy_fetch', body: stored, packageId: PKG }))
             .toEqual([]);
         // Served, it carries none of the rules the publish refused it on before.
-        // (The read's own schema half still judges the served body as stored;
-        // that seam is the read's, not the publish verdict's.)
+        // ([#29696] The read's own schema half is pinned in its own block below.)
         const codes = ((await draftDiagnostics(protocol, 'flow', 'legacy_fetch')).errors ?? []).map((e) => e.code);
         expect(codes).not.toContain('expression-invalid');
         expect(codes).not.toContain('flow-region-shape-invalid');
@@ -1116,3 +1118,95 @@ describe('[#29557] a stored flow draft in a legacy D2 spelling the engine regist
         expect(issueTriples(batch.failed[0].issues)).toEqual(issueTriples(canonical.err.issues));
     });
 });
+
+/**
+ * [#29696] A flow READ judges a stored legacy D2 row in the spelling the doors
+ * judge it in. A row at rest in a legacy ADR-0087 D2 spelling (`get_record`
+ * `config.filters`) is accepted by the save door, both publish doors (#29557)
+ * and the engine's canonicalizer; the read's `_diagnostics` schema half judges
+ * it through the same seam (`storedFlowVerdictBody`), and serves it as stored.
+ * Measured on `origin/main` `0eb97fa4` before the fix: every read below
+ * answered `valid: false` with `unrecognized_keys` on `config.filters`.
+ */
+describe('[#29696] a flow read judges a stored legacy D2 row in its D2-converted spelling', () => {
+    let warn: ReturnType<typeof vi.spyOn>;
+    beforeEach(() => {
+        warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+        delete process.env.OS_ALLOW_UNLINTED_METADATA_WRITES;
+    });
+    afterEach(() => {
+        warn.mockRestore();
+    });
+
+    /** The legacy fixture with a config key no conversion rewrites and the parse refuses. */
+    const withUndeclaredKey = (name: string, filterKey: 'filters' | 'filter') => {
+        const flow = fetchFlow(name, filterKey);
+        return {
+            ...flow,
+            nodes: flow.nodes.map((n) => (n.id === 'fetch' ? { ...n, config: { ...n.config, not_a_config_key: true } } : n)),
+        };
+    };
+
+    async function seeded(body: { name: string }) {
+        const { engine, rows } = makeStubEngine();
+        const protocol = new ObjectStackProtocolImplementation(engine);
+        await seedActive(engine, body);
+        return { engine, rows, protocol };
+    }
+
+    /** The active item read's `_diagnostics` and the config it serves. */
+    async function activeRead(protocol: ObjectStackProtocolImplementation, name: string) {
+        const read: any = await protocol.getMetaItem({ type: 'flow', name, packageId: PKG } as any);
+        return { diagnostics: read.item._diagnostics, config: read.item.nodes[1].config };
+    }
+
+    it('the active item read reads valid: true and serves the stored bytes', async () => {
+        const { protocol } = await seeded(fetchFlow('legacy_fetch', 'filters'));
+
+        const { diagnostics, config } = await activeRead(protocol, 'legacy_fetch');
+
+        expect(diagnostics).toEqual({ valid: true });
+        expect(config).toEqual({ objectName: 'deal', filters: { name: 'Acme' }, outputVariable: 'deal' });
+    });
+
+    it('the list read reads valid: true and serves the stored bytes', async () => {
+        const { protocol } = await seeded(fetchFlow('legacy_fetch', 'filters'));
+
+        const list: any = await protocol.getMetaItems({ type: 'flow', packageId: PKG });
+        const item = (list.items as any[]).find((i) => i.name === 'legacy_fetch');
+
+        expect(item?._diagnostics).toEqual({ valid: true });
+        expect(item.nodes[1].config).toEqual({ objectName: 'deal', filters: { name: 'Acme' }, outputVariable: 'deal' });
+    });
+
+    it('the layered read reads valid: true', async () => {
+        const { engine, protocol } = await seeded(fetchFlow('legacy_fetch', 'filters'));
+        // The layered read asks the registry for the shipped layer; this
+        // double ships none.
+        engine.registry.getItem = () => undefined;
+
+        const layered: any = await protocol.getMetaItemLayered({ type: 'flow', name: 'legacy_fetch', packageId: PKG } as any);
+
+        expect(layered._diagnostics).toEqual({ valid: true });
+    });
+
+    it('the draft read of a re-save of it reads valid: true', async () => {
+        const body = fetchFlow('legacy_fetch', 'filters');
+        const { rows, protocol } = await seeded(body);
+        expect(await stageDraft(protocol, 'flow', body)).toMatchObject({ success: true, state: 'draft' });
+        expect(storedConfig(rows, 'legacy_fetch', 'draft')).toEqual({ objectName: 'deal', filters: { name: 'Acme' }, outputVariable: 'deal' });
+
+        expect(await draftDiagnostics(protocol, 'flow', 'legacy_fetch')).toEqual({ valid: true });
+    });
+
+    it('a row still refused once converted reads valid: false, with the errors its canonical spelling reads', async () => {
+        const canonical = await activeRead((await seeded(withUndeclaredKey('refused_fetch', 'filter'))).protocol, 'refused_fetch');
+        const legacy = await activeRead((await seeded(withUndeclaredKey('refused_fetch', 'filters'))).protocol, 'refused_fetch');
+
+        expect(canonical.diagnostics.valid).toBe(false);
+        expect(JSON.stringify(canonical.diagnostics.errors)).toContain('not_a_config_key');
+        expect(legacy.diagnostics).toEqual(canonical.diagnostics);
+        // Served as stored: the legacy spelling is what the read hands back.
+        expect(legacy.config.filters).toEqual({ name: 'Acme' });
+    });
+});
@@ -591,3 +591,56 @@ pinBothDoors({
     },
     expectDetail: (error) => expect(error.message).toBe('refused in state active'),
 });
+
+// ─── [#29696] A flow version stored in a legacy ADR-0087 D2 spelling ─────────
+//
+// The restore doors judge a flow version the way both publish doors judge a
+// stored flow draft (#29557): the runtime authoring rules read it in its
+// D2-converted spelling (`storedFlowVerdictBody`), and the version is restored
+// as stored. Measured on `origin/main` `0eb97fa4` before the fix: a version in
+// the legacy `get_record` `config.filters` spelling, which the save door, the
+// publish doors and the engine all accept, was refused at both restore doors
+// (422 `INVALID_METADATA`, `expression-invalid` at `config.filters`).
+
+const LEGACY_FLOW = 'acme_fetch';
+/** start → get_record → end, the match map spelled under `filterKey`; `brokenEdge` adds a conditional edge whose CEL does not parse. */
+const fetchFlow = (label: string, filterKey: 'filters' | 'filter', brokenEdge = false) => ({
+    name: LEGACY_FLOW,
+    label,
+    type: 'autolaunched',
+    nodes: [
+        { id: 'start', type: 'start', label: 'Start' },
+        { id: 'fetch', type: 'get_record', label: 'Fetch', config: { objectName: 'acme_deal', [filterKey]: { name: 'Acme' }, outputVariable: 'deal' } },
+        { id: 'end', type: 'end', label: 'End' },
+    ],
+    edges: [
+        { id: 'e1', source: 'start', target: 'fetch' },
+        brokenEdge
+            ? { id: 'e2', source: 'fetch', target: 'end', type: 'conditional', condition: 'record.name ==' }
+            : { id: 'e2', source: 'fetch', target: 'end' },
+    ],
+});
+
+pinBothDoors({
+    title: '[#29696] a flow version in a legacy D2 spelling is judged converted: restored as stored, and refused only where its converted spelling is',
+    type: 'flow',
+    name: LEGACY_FLOW,
+    code: 'INVALID_METADATA',
+    status: 422,
+    async stage(h) {
+        await h.protocol.saveMetaItem({ type: 'flow', name: LEGACY_FLOW, item: fetchFlow('v1', 'filter') });
+        await h.protocol.saveMetaItem({ type: 'flow', name: LEGACY_FLOW, item: fetchFlow('v2', 'filter') });
+        await h.protocol.saveMetaItem({ type: 'flow', name: LEGACY_FLOW, item: fetchFlow('v3', 'filter') });
+        // Both versions as rows at rest in the legacy spelling; v2 also
+        // carries an edge the rules refuse in any spelling.
+        rewriteHistory(h, 'flow', LEGACY_FLOW, 1, () => fetchFlow('v1', 'filters'));
+        rewriteHistory(h, 'flow', LEGACY_FLOW, 2, () => fetchFlow('v2', 'filters', true));
+        return { refused: 2, accepted: 1 };
+    },
+    // Refused on the edge alone: nothing is reported at the legacy spelling.
+    expectDetail: (error) => {
+        const rules = (error.issues ?? []).map((i: { rule?: string }) => i.rule);
+        expect(rules).toContain('expression-invalid');
+        expect(JSON.stringify(error.issues)).not.toContain('filters');
+    },
+});
@@ -1560,7 +1560,9 @@ export class ObjectStackProtocolImplementation implements
      *    ({@link assertRuntimeAuthoringRules}), judged as an `active` write
      *    bound to the row's own package, and told which credentials the
      *    write-only channel holds — the restore keeps them (R2) — as the draft
-     *    promotion tells it;
+     *    promotion tells it; [#29696] a flow version judged in its
+     *    D2-converted spelling (`storedFlowVerdictBody`), as the promotion
+     *    judges a flow draft, and restored as stored;
      *  - the authoring gate a domain plugin registers
      *    ({@link runAuthoringGate}), on the channel the save door asks it on.
      *