@@ -0,0 +1,22 @@
+---
+'@objectstack/metadata-protocol': minor
+'@objectstack/metadata-core': minor
+'@objectstack/service-automation': patch
+---
+
+**BREAKING** fix(metadata)!: a flow whose loop is not closed by a `type: 'back'` edge is refused at publish, and its draft read says so, instead of publishing and then never registering
+
+Clause-②: no (narrowing)
+Metadata-protocol: narrowed
+Skills-docs: none — `skills/objectstack-automation/references/state-machines-and-approvals.md` teaches that the resubmit edge MUST be typed `'back'` and that `registerFlow` rejects an unmarked cycle; both stay true, and the publish door now refuses the same flow earlier, in the same words.
+
+<!-- adr-0087: not-required (no-migration-prescription) No key of any schema is added, removed, renamed or re-shaped. The publish doors now refuse a flow body the automation engine already refused to register, with the engine's own sentence, so a published body that could never run has nothing a migration could rewrite it to: the author's fix is the one the refusal names. -->
+
+**BREAKING** accept-set narrowing at the runtime authoring gate (`@objectstack/metadata-protocol`), which the metadata draft read and every publish door run (`PUT /api/v1/meta/:type/:name` live, `POST …/publish`, `POST /api/v1/packages/:id/publish-drafts`).
+
+- **Before.** A flow whose top-level graph had a cycle with no edge typed `back` (ADR-0044) saved as a draft, its draft read answered `_diagnostics: { valid: true }`, and it published (`outcome: 'published'`). The automation engine then refused to register it ("Flow contains a cycle: push → check → revise → push. …"), so the flow never ran, and only the by-name read's `registration` and a boot-log warning said why.
+- **Now.** The draft still saves (drafts are never gated). Its read answers `valid: false` with an error coded `flow-undeclared-cycle` on the cycle-closing edge (`edges.N`), and every publish door refuses it `422 INVALID_METADATA` with that finding; a package publish refuses the batch (`outcome: 'refused'`). The message is the engine's registration refusal, word for word.
+- **One judge.** The cycle walk moved from `@objectstack/service-automation` to `@objectstack/metadata-core` as `findUndeclaredFlowCycle` (with `undeclaredFlowCycleMessage`). The engine's registration and the publish gate both call it, so they refuse exactly the same graphs; the engine's behaviour and message are unchanged. `@objectstack/metadata-core/testing` exports `FLOW_CYCLE_CORPUS`, the case table both faces are tested against.
+- **Unchanged.** A cycle with any of its edges typed `back` publishes and registers, as before. Cycles inside a `loop` / `parallel` / `try_catch` region are judged where they were. `os validate` and `os build` do not run this check yet.
+
+**The remedy.** None for a flow that registers today: it publishes exactly as before. A flow this now refuses was already refused by the engine at registration and never ran; the refusal names the closing edge, and ADR-0044's `type: 'back'` on that edge is how an intended loop is declared. A stored flow published before this change is re-registered exactly as before (still refused by the engine).
@@ -0,0 +1,132 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * [#29025] The shared corpus of the flow-cycle judge (`findUndeclaredFlowCycle`, `./flow-cycle.ts`).
+ *
+ * Each case is a complete flow body that `FlowSchema` accepts, with the cycle
+ * walk the judge must report (`null` = acyclic once `back` edges are set
+ * aside). Three suites read it: the judge's own, the automation engine's
+ * registration, and the runtime authoring gate's. Each asserts its face refuses
+ * exactly the cases whose `cycle` is non-null, with the judge's message, so the
+ * engine and the gate cannot drift apart on which graphs they refuse.
+ *
+ * Nodes are `start`, `assignment` and `end` only, and no edge carries a
+ * condition, so no other registration or authoring check has anything to say
+ * about a case: the cycle is the only verdict in play.
+ */
+
+export interface FlowCycleCorpusCase {
+    /** What the case pins, in a few words. */
+    readonly title: string;
+    /** A complete flow body; its `name` is unique in the corpus. */
+    readonly flow: {
+        readonly name: string;
+        readonly label: string;
+        readonly type: 'autolaunched';
+        readonly nodes: ReadonlyArray<{ readonly id: string; readonly type: string; readonly label: string }>;
+        readonly edges: ReadonlyArray<{ readonly id: string; readonly source: string; readonly target: string; readonly type?: string }>;
+    };
+    /** The cycle walk the judge reports, or `null` when the flow must register and publish. */
+    readonly cycle: readonly string[] | null;
+    /** The index in `edges` of the cycle-closing edge, when `cycle` is set. */
+    readonly closingEdgeIndex?: number;
+}
+
+const node = (id: string, type = 'assignment') => ({ id, type, label: id });
+
+/** The card's shape: start → push → check → revise → push, the loop edge untyped. */
+const reworkNodes = [node('start', 'start'), node('push'), node('check'), node('revise'), node('end', 'end')];
+const reworkEdges = (loopType?: string) => [
+    { id: 'e1', source: 'start', target: 'push' },
+    { id: 'e2', source: 'push', target: 'check' },
+    { id: 'e3', source: 'check', target: 'end' },
+    { id: 'e4', source: 'check', target: 'revise' },
+    { id: 'e5', source: 'revise', target: 'push', ...(loopType ? { type: loopType } : {}) },
+];
+
+export const FLOW_CYCLE_CORPUS: readonly FlowCycleCorpusCase[] = [
+    {
+        title: 'a rework loop whose closing edge is untyped is refused',
+        flow: { name: 'cyc_rework_untyped', label: 'Rework', type: 'autolaunched', nodes: reworkNodes, edges: reworkEdges() },
+        cycle: ['push', 'check', 'revise', 'push'],
+        closingEdgeIndex: 4,
+    },
+    {
+        title: 'the same loop with its closing edge typed back registers',
+        flow: { name: 'cyc_rework_back', label: 'Rework', type: 'autolaunched', nodes: reworkNodes, edges: reworkEdges('back') },
+        cycle: null,
+    },
+    {
+        title: 'a closing edge typed fault still closes a cycle',
+        flow: { name: 'cyc_rework_fault', label: 'Rework', type: 'autolaunched', nodes: reworkNodes, edges: reworkEdges('fault') },
+        cycle: ['push', 'check', 'revise', 'push'],
+        closingEdgeIndex: 4,
+    },
+    {
+        title: 'a self-loop is refused',
+        flow: {
+            name: 'cyc_self', label: 'Self', type: 'autolaunched',
+            nodes: [node('start', 'start'), node('again'), node('end', 'end')],
+            edges: [
+                { id: 'e1', source: 'start', target: 'again' },
+                { id: 'e2', source: 'again', target: 'again' },
+                { id: 'e3', source: 'again', target: 'end' },
+            ],
+        },
+        cycle: ['again', 'again'],
+        closingEdgeIndex: 1,
+    },
+    {
+        title: 'a self-loop typed back registers',
+        flow: {
+            name: 'cyc_self_back', label: 'Self', type: 'autolaunched',
+            nodes: [node('start', 'start'), node('again'), node('end', 'end')],
+            edges: [
+                { id: 'e1', source: 'start', target: 'again' },
+                { id: 'e2', source: 'again', target: 'again', type: 'back' },
+                { id: 'e3', source: 'again', target: 'end' },
+            ],
+        },
+        cycle: null,
+    },
+    {
+        title: 'any edge of the loop typed back breaks it — the graph minus back edges is what must be acyclic',
+        flow: {
+            name: 'cyc_mid_back', label: 'Mid', type: 'autolaunched', nodes: reworkNodes,
+            edges: reworkEdges().map((e) => (e.id === 'e2' ? { ...e, type: 'back' } : e)),
+        },
+        cycle: null,
+    },
+    {
+        title: 'two loops, one declared, one not: the undeclared one is refused',
+        flow: {
+            name: 'cyc_two_loops', label: 'Two', type: 'autolaunched',
+            nodes: [node('start', 'start'), node('a'), node('b'), node('c'), node('end', 'end')],
+            edges: [
+                { id: 'e1', source: 'start', target: 'a' },
+                { id: 'e2', source: 'a', target: 'b' },
+                { id: 'e3', source: 'b', target: 'a', type: 'back' },
+                { id: 'e4', source: 'b', target: 'c' },
+                { id: 'e5', source: 'c', target: 'b' },
+                { id: 'e6', source: 'c', target: 'end' },
+            ],
+        },
+        cycle: ['b', 'c', 'b'],
+        closingEdgeIndex: 4,
+    },
+    {
+        title: 'a diamond (two paths meeting again) is no cycle',
+        flow: {
+            name: 'cyc_diamond', label: 'Diamond', type: 'autolaunched',
+            nodes: [node('start', 'start'), node('left'), node('right'), node('join'), node('end', 'end')],
+            edges: [
+                { id: 'e1', source: 'start', target: 'left' },
+                { id: 'e2', source: 'start', target: 'right' },
+                { id: 'e3', source: 'left', target: 'join' },
+                { id: 'e4', source: 'right', target: 'join' },
+                { id: 'e5', source: 'join', target: 'end' },
+            ],
+        },
+        cycle: null,
+    },
+];
@@ -0,0 +1,49 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * [#29025] The flow-cycle judge on its own corpus. The engine's registration
+ * (`@objectstack/service-automation`) and the runtime authoring gate
+ * (`@objectstack/metadata-protocol`) are driven from the same corpus in their
+ * own suites; this file pins what the judge itself answers.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { findUndeclaredFlowCycle, undeclaredFlowCycleMessage } from './flow-cycle.js';
+import { FLOW_CYCLE_CORPUS } from './flow-cycle-corpus.js';
+
+describe('[#29025] findUndeclaredFlowCycle', () => {
+    for (const c of FLOW_CYCLE_CORPUS) {
+        it(c.title, () => {
+            const found = findUndeclaredFlowCycle(c.flow);
+            if (c.cycle === null) {
+                expect(found).toBeNull();
+                return;
+            }
+            expect(found).toEqual({
+                path: c.cycle,
+                closingEdgeIndex: c.closingEdgeIndex,
+                message: undeclaredFlowCycleMessage(c.cycle),
+            });
+        });
+    }
+
+    it('the corpus holds both verdicts, so no face can pass it by refusing everything or nothing', () => {
+        const refused = FLOW_CYCLE_CORPUS.filter((c) => c.cycle !== null).length;
+        expect(refused).toBeGreaterThanOrEqual(3);
+        expect(FLOW_CYCLE_CORPUS.length - refused).toBeGreaterThanOrEqual(3);
+        expect(new Set(FLOW_CYCLE_CORPUS.map((c) => c.flow.name)).size).toBe(FLOW_CYCLE_CORPUS.length);
+    });
+
+    it('the message names the walk and the back-edge remedy', () => {
+        const message = undeclaredFlowCycleMessage(['a', 'b', 'a']);
+        expect(message.startsWith('Flow contains a cycle: a → b → a.')).toBe(true);
+        expect(message).toContain("type: 'back'");
+    });
+
+    it('an edge whose endpoint names no node takes no part', () => {
+        expect(findUndeclaredFlowCycle({
+            nodes: [{ id: 'a' }],
+            edges: [{ source: 'a', target: 'ghost' }, { source: 'ghost', target: 'a' }],
+        })).toBeNull();
+    });
+});
@@ -0,0 +1,128 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * The ONE judge of an undeclared cycle in a flow's top-level graph (ADR-0044).
+ *
+ * A flow is a DAG once its declared back edges (`type: 'back'`) are set aside:
+ * an author opts a rework loop in edge by edge, and an unmarked cycle is
+ * refused. The automation engine refuses to REGISTER such a flow
+ * (`AutomationEngine.detectCycles`, `@objectstack/service-automation`). Until
+ * this module the judgement lived only there, so the metadata draft read said
+ * `valid: true` and the publish doors published a flow the engine then refused,
+ * and it never ran.
+ *
+ * Every door now asks this function: the engine at registration, and the
+ * runtime authoring gate (`@objectstack/metadata-protocol`) that the draft
+ * verdict and every publish door run. Both depend on this package, which
+ * depends on `@objectstack/spec` alone, so neither face pulls the other's code
+ * in. Both answer with {@link FlowUndeclaredCycle.message}, so the author reads
+ * the same sentence wherever the flow is refused.
+ *
+ * Scope: the flow's own `nodes` / `edges`. Cycles inside an ADR-0031 region
+ * (a `loop` body, a `parallel` branch, a `try_catch` region) are judged by the
+ * spec's `validateControlFlow`, not here.
+ */
+
+/** The structural slice of a flow node this judge reads. */
+export interface FlowCycleNode {
+    readonly id: string;
+}
+
+/** The structural slice of a flow edge this judge reads. */
+export interface FlowCycleEdge {
+    readonly source: string;
+    readonly target: string;
+    /** `'back'` sets the edge aside (ADR-0044); absent reads as the schema's `'default'`. */
+    readonly type?: string;
+}
+
+/** What the judge finds: the first undeclared cycle, located. */
+export interface FlowUndeclaredCycle {
+    /**
+     * The cycle as a node-id walk that starts and ends on the same node —
+     * `['push', 'check', 'revise', 'push']`.
+     */
+    readonly path: readonly string[];
+    /**
+     * The index in `edges` of the edge that closes the cycle (the walk's last
+     * step), so a door can locate the refusal on the edge an author would
+     * mark `back`.
+     */
+    readonly closingEdgeIndex: number;
+    /** The refusal, the same sentence at every door. */
+    readonly message: string;
+}
+
+/** The refusal sentence for a cycle walk; the engine's registration error since ADR-0044. */
+export function undeclaredFlowCycleMessage(path: readonly string[]): string {
+    return (
+        `Flow contains a cycle: ${path.join(' → ')}. Only DAG flows are allowed — ` +
+        `to author an intentional rework loop, mark the cycle-closing edge with type: 'back' (ADR-0044).`
+    );
+}
+
+/**
+ * Find the first cycle in a flow's top-level graph once its `back` edges are
+ * set aside, or `null` when there is none.
+ *
+ * Depth-first with white/gray/black colouring, nodes visited in declaration
+ * order and edges followed in declaration order, so the cycle reported is the
+ * one the engine has always named. An edge whose source or target names no
+ * node takes no part (a dangling endpoint is another check's refusal).
+ */
+export function findUndeclaredFlowCycle(flow: {
+    readonly nodes: readonly FlowCycleNode[];
+    readonly edges: readonly FlowCycleEdge[];
+}): FlowUndeclaredCycle | null {
+    const WHITE = 0, GRAY = 1, BLACK = 2;
+    const color = new Map<string, number>();
+    const parent = new Map<string, string>();
+
+    const adj = new Map<string, string[]>();
+    for (const node of flow.nodes) {
+        color.set(node.id, WHITE);
+        adj.set(node.id, []);
+    }
+    for (const edge of flow.edges) {
+        if (edge.type === 'back') continue; // ADR-0044 declared back-edge
+        const targets = adj.get(edge.source);
+        if (targets) targets.push(edge.target);
+    }
+
+    const dfs = (nodeId: string): string[] | null => {
+        color.set(nodeId, GRAY);
+        for (const neighbor of adj.get(nodeId) ?? []) {
+            if (color.get(neighbor) === GRAY) {
+                // Back edge found — reconstruct the cycle.
+                const cycle = [neighbor, nodeId];
+                let cur = nodeId;
+                while (cur !== neighbor) {
+                    cur = parent.get(cur)!;
+                    if (cur) cycle.push(cur);
+                    else break;
+                }
+                return cycle.reverse();
+            }
+            if (color.get(neighbor) === WHITE) {
+                parent.set(neighbor, nodeId);
+                const result = dfs(neighbor);
+                if (result) return result;
+            }
+        }
+        color.set(nodeId, BLACK);
+        return null;
+    };
+
+    for (const node of flow.nodes) {
+        if (color.get(node.id) !== WHITE) continue;
+        const path = dfs(node.id);
+        if (!path) continue;
+        const from = path[path.length - 2];
+        const to = path[path.length - 1];
+        const closingEdgeIndex = flow.edges.findIndex(
+            (edge) => edge.type !== 'back' && edge.source === from && edge.target === to,
+        );
+        return { path, closingEdgeIndex, message: undeclaredFlowCycleMessage(path) };
+    }
+    return null;
+}
@@ -150,3 +150,9 @@ export * from './resolved-picklist-options.js';
 // and the registry fold's boot log, so the three cannot disagree about which
 // patch names a field or option its target lacks.
 export * from './extension-field-patch-targets.js';
+
+// [#29025] The judge of an undeclared cycle in a flow's top-level graph
+// (ADR-0044) — one judge for the engine's registration and the runtime
+// authoring gate the draft verdict and the publish doors run, so a flow the
+// engine refuses to register no longer reads valid and publishes.
+export * from './flow-cycle.js';
@@ -11,3 +11,8 @@ export * from './contract-suite.js';
 // exit that forgets the projection fails by name. Test-only: it belongs beside
 // the contract suite, not on the runtime entry.
 export * from './object-schema-fls-contract.js';
+// [#29025] The shared corpus both faces of the flow-cycle judge are driven
+// from — the engine's registration (`@objectstack/service-automation`) and the
+// runtime authoring gate (`@objectstack/metadata-protocol`) — so the two
+// refuse exactly the same graphs. Test-only, beside the FLS case table.
+export * from './flow-cycle-corpus.js';