diff --git a/client/src/components/Common/Tags.vue b/client/src/components/Common/Tags.vue
index e6470d138d3d..bb874f8382f9 100644
--- a/client/src/components/Common/Tags.vue
+++ b/client/src/components/Common/Tags.vue
@@ -1,5 +1,5 @@
 <template>
-    <StatelessTags :value="tags" @input="onInput" @tag-click="onTagClick" />
+    <StatelessTags :value="tags" @input="onInput" @tag-click="onTagClick" :disabled="disabled" />
 </template>
 <script>
 import StatelessTags from "components/Tags/StatelessTags";
@@ -14,6 +14,10 @@ export default {
         tags: {
             type: Array,
         },
+        disabled: {
+            type: Boolean,
+            default: false,
+        },
     },
     methods: {
         onInput(tags) {
diff --git a/client/src/components/History/CurrentHistory/HistoryNavigation.vue b/client/src/components/History/CurrentHistory/HistoryNavigation.vue
index 63cc5d368928..baaccd354664 100644
--- a/client/src/components/History/CurrentHistory/HistoryNavigation.vue
+++ b/client/src/components/History/CurrentHistory/HistoryNavigation.vue
@@ -102,6 +102,13 @@
                         <span v-localize>Extract Workflow</span>
                     </b-dropdown-item>
 
+                    <b-dropdown-item
+                        :disabled="currentUser.isAnonymous"
+                        @click="$router.push(`histories/${history.id}/invocations`)">
+                        <Icon fixed-width icon="sitemap" class="fa-rotate-270 mr-1" />
+                        <span v-localize>Show Invocations</span>
+                    </b-dropdown-item>
+
                     <b-dropdown-divider></b-dropdown-divider>
 
                     <b-dropdown-item
diff --git a/client/src/components/Indices/IndexFilter.vue b/client/src/components/Indices/IndexFilter.vue
index 0d7d9d86e1fb..cd35ba50e6ba 100644
--- a/client/src/components/Indices/IndexFilter.vue
+++ b/client/src/components/Indices/IndexFilter.vue
@@ -9,7 +9,7 @@
                     autocomplete="off"
                     :placeholder="placeholder | localize"
                     data-description="filter index input"
-                    class="search-query"
+                    class="search-query index-filter-query"
                     :size="size"
                     @input="input"
                     @keyup.esc="onReset" />
diff --git a/client/src/components/Indices/filtersMixin.js b/client/src/components/Indices/filtersMixin.js
index 719297f4a4a3..d2c3870c1bb5 100644
--- a/client/src/components/Indices/filtersMixin.js
+++ b/client/src/components/Indices/filtersMixin.js
@@ -4,15 +4,40 @@ export default {
     components: {
         IndexFilter,
     },
+    props: {
+        inputDebounceDelay: {
+            type: Number,
+            default: 500,
+        },
+    },
     data() {
         return {
             filter: "",
+            implicitFilter: null,
+            helpHtml: null,
         };
     },
     computed: {
         isFiltered() {
             return !!this.filter;
         },
+        effectiveFilter() {
+            let filter = this.filter;
+            const implicitFilter = this.implicitFilter;
+            if (implicitFilter && filter) {
+                filter = `${implicitFilter} ${filter}`;
+            } else if (implicitFilter) {
+                filter = implicitFilter;
+            }
+            return filter;
+        },
+        filterAttrs() {
+            return {
+                "debounce-delay": this.inputDebounceDelay,
+                placeholder: this.titleSearch,
+                "help-html": this.helpHtml,
+            };
+        },
     },
     methods: {
         appendTagFilter(tag, text) {
diff --git a/client/src/components/Indices/filtersMixin.test.js b/client/src/components/Indices/filtersMixin.test.js
index f0ae0f650ba8..8a5caab0825c 100644
--- a/client/src/components/Indices/filtersMixin.test.js
+++ b/client/src/components/Indices/filtersMixin.test.js
@@ -43,4 +43,16 @@ describe("filtersMixin.js", () => {
         wrapper.vm.appendTagFilter("name", "foobar");
         expect(wrapper.vm.filter).toBe("name:'foobar'");
     });
+
+    it("should have an effective filter that combines implicit and explicit filter", async () => {
+        wrapper.vm.implicitFilter = "tag:cowdog";
+        wrapper.vm.appendTagFilter("name", "foobar");
+        expect(wrapper.vm.filter).toBe("name:'foobar'");
+        expect(wrapper.vm.effectiveFilter).toBe("tag:cowdog name:'foobar'");
+    });
+
+    it("should just use implicit filter as effective if filter is empty", async () => {
+        wrapper.vm.implicitFilter = "tag:cowdog";
+        expect(wrapper.vm.effectiveFilter).toBe("tag:cowdog");
+    });
 });
diff --git a/client/src/components/Page/PageDropdown.test.js b/client/src/components/Page/PageDropdown.test.js
new file mode 100644
index 000000000000..4f56fdcb40a7
--- /dev/null
+++ b/client/src/components/Page/PageDropdown.test.js
@@ -0,0 +1,125 @@
+import PageDropdown from "./PageDropdown";
+import { shallowMount } from "@vue/test-utils";
+import { getLocalVue } from "jest/helpers";
+import axios from "axios";
+import MockAdapter from "axios-mock-adapter";
+import flushPromises from "flush-promises";
+
+import "jest-location-mock";
+
+const localVue = getLocalVue(true);
+
+const PAGE_DATA_OWNED = {
+    id: "page1235",
+    title: "My Page Title",
+    description: "A description derived from an annotation.",
+    shared: false,
+};
+
+const PAGE_DATA_SHARED = {
+    id: "page1235",
+    title: "My Page Title",
+    description: "A description derived from an annotation.",
+    shared: true,
+};
+
+describe("PageDropdown.vue", () => {
+    let wrapper;
+
+    describe("navigation on owned pages", () => {
+        beforeEach(async () => {
+            const propsData = {
+                root: "/rootprefix/",
+                page: PAGE_DATA_OWNED,
+            };
+            wrapper = shallowMount(PageDropdown, {
+                propsData,
+                localVue,
+            });
+        });
+
+        it("should create a page when create is clicked", async () => {
+            await wrapper.find(".page-dropdown").trigger("click");
+        });
+
+        it("should show page title", async () => {
+            const titleWrapper = await wrapper.find(".page-title");
+            expect(titleWrapper.text()).toBe("My Page Title");
+        });
+
+        it("should should decorate dropdown with page ID for automation", async () => {
+            const linkWrapper = await wrapper.find("[data-page-dropdown='page1235']");
+            expect(linkWrapper.exists()).toBeTruthy();
+        });
+
+        it("should have a 'Share' option", async () => {
+            expect(wrapper.find(".dropdown-menu .dropdown-item-share").exists()).toBeTruthy();
+        });
+    });
+
+    describe("navigation on shared pages", () => {
+        beforeEach(async () => {
+            const propsData = {
+                root: "/rootprefixshared/",
+                page: PAGE_DATA_SHARED,
+            };
+            wrapper = shallowMount(PageDropdown, {
+                propsData,
+                localVue,
+            });
+        });
+
+        it("should not have a 'Share' option", async () => {
+            expect(wrapper.find(".dropdown-menu  dropdown-item-share").exists()).toBeFalsy();
+        });
+    });
+
+    describe("clicking page deletion", () => {
+        let axiosMock;
+        let confirmRequest;
+
+        async function mountAndDelete() {
+            const propsData = {
+                root: "/rootprefixdelete/",
+                page: PAGE_DATA_OWNED,
+            };
+            wrapper = shallowMount(PageDropdown, {
+                propsData,
+                localVue,
+            });
+            await wrapper.vm.onDelete();
+            await flushPromises();
+        }
+
+        beforeEach(async () => {
+            axiosMock = new MockAdapter(axios);
+            confirmRequest = true;
+            global.confirm = jest.fn(() => confirmRequest);
+            axiosMock.onDelete("rootprefixdelete/api/pages/page1235").reply(202, "deleted...");
+        });
+
+        afterEach(() => {
+            axiosMock.restore();
+        });
+
+        it("should confirm with localized deletion message", async () => {
+            await mountAndDelete();
+            expect(global.confirm).toHaveBeenCalledWith(expect.toBeLocalized());
+        });
+
+        it("should fire deletion API request upon confirmation", async () => {
+            await mountAndDelete();
+            const emitted = wrapper.emitted();
+            expect(emitted["onRemove"][0][0]).toEqual("page1235");
+            expect(emitted["onSuccess"][0][0]).toEqual("deleted...");
+        });
+
+        it("should not fire deletion API request if not confirmed", async () => {
+            confirmRequest = false;
+            await mountAndDelete();
+            const emitted = wrapper.emitted();
+            expect(emitted["onRemove"]).toBeFalsy();
+            expect(emitted["onSuccess"]).toBeFalsy();
+        });
+    });
+});
diff --git a/client/src/components/Page/PageDropdown.vue b/client/src/components/Page/PageDropdown.vue
new file mode 100644
index 000000000000..eb0f9948750a
--- /dev/null
+++ b/client/src/components/Page/PageDropdown.vue
@@ -0,0 +1,89 @@
+<template>
+    <div>
+        <b-link
+            class="page-dropdown font-weight-bold"
+            data-toggle="dropdown"
+            aria-haspopup="true"
+            :data-page-dropdown="page.id"
+            aria-expanded="false">
+            <font-awesome-icon icon="caret-down" />
+            <span class="page-title">{{ page.title }}</span>
+        </b-link>
+        <p v-if="page.description">{{ page.description }}</p>
+        <div class="dropdown-menu" aria-labelledby="page-dropdown">
+            <a class="dropdown-item dropdown-item-view" :href="urlView">
+                <span class="fa fa-eye fa-fw mr-1" />
+                <span>View</span>
+            </a>
+            <a class="dropdown-item dropdown-item-edit" v-if="!readOnly" :href="urlEdit">
+                <span class="fa fa-edit fa-fw mr-1" />
+                <span>Edit Content</span>
+            </a>
+            <a class="dropdown-item dropdown-item-edit-attributes" v-if="!readOnly" :href="urlEditAttributes">
+                <span class="fa fa-share-alt fa-fw mr-1" />
+                <span>Edit Attributes</span>
+            </a>
+            <a class="dropdown-item dropdown-item-share" v-if="!readOnly" :href="urlShare">
+                <span class="fa fa-share-alt fa-fw mr-1" />
+                <span>Share</span>
+            </a>
+            <a class="dropdown-item" href="#" v-if="!readOnly" @click.prevent="onDelete">
+                <span class="fa fa-trash fa-fw mr-1" />
+                <span>Delete</span>
+            </a>
+        </div>
+    </div>
+</template>
+<script>
+import { Services } from "./services";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faCaretDown } from "@fortawesome/free-solid-svg-icons";
+
+library.add(faCaretDown);
+
+export default {
+    components: {
+        FontAwesomeIcon,
+    },
+    props: ["page", "root"],
+    computed: {
+        urlEdit() {
+            return `${this.root}page/edit_content?id=${this.page.id}`;
+        },
+        urlEditAttributes() {
+            return `${this.root}page/edit?id=${this.page.id}`;
+        },
+        urlShare() {
+            return `${this.root}pages/sharing?id=${this.page.id}`;
+        },
+        urlView() {
+            return `${this.root}page/display_by_id?id=${this.page.id}`;
+        },
+        readOnly() {
+            return !!this.page.shared;
+        },
+    },
+    created() {
+        this.services = new Services({ root: this.root });
+    },
+    methods: {
+        onDelete() {
+            const id = this.page.id;
+            const name = this.page.title;
+            const confirmationMessage = this.l(`Are you sure you want to delete page '${name}'?`);
+            if (window.confirm(confirmationMessage)) {
+                this.services
+                    .deletePage(id)
+                    .then((message) => {
+                        this.$emit("onRemove", id);
+                        this.$emit("onSuccess", message);
+                    })
+                    .catch((error) => {
+                        this.$emit("onError", error);
+                    });
+            }
+        },
+    },
+};
+</script>
diff --git a/client/src/components/Page/PageIndexActions.test.js b/client/src/components/Page/PageIndexActions.test.js
new file mode 100644
index 000000000000..7d494b29d917
--- /dev/null
+++ b/client/src/components/Page/PageIndexActions.test.js
@@ -0,0 +1,28 @@
+import PageIndexActions from "./PageIndexActions";
+import { shallowMount } from "@vue/test-utils";
+import { getLocalVue } from "jest/helpers";
+
+import "jest-location-mock";
+
+const localVue = getLocalVue();
+
+describe("PageIndexActions.vue", () => {
+    let wrapper;
+
+    beforeEach(async () => {
+        const propsData = {
+            root: "/rootprefix/",
+        };
+        wrapper = shallowMount(PageIndexActions, {
+            propsData,
+            localVue,
+        });
+    });
+
+    describe("naviation", () => {
+        it("should create a page when create is clicked", async () => {
+            await wrapper.find("#page-create").trigger("click");
+            expect(window.location).toBeAt("/rootprefix/pages/create");
+        });
+    });
+});
diff --git a/client/src/components/Page/PageIndexActions.vue b/client/src/components/Page/PageIndexActions.vue
new file mode 100644
index 000000000000..717ce2f9adb1
--- /dev/null
+++ b/client/src/components/Page/PageIndexActions.vue
@@ -0,0 +1,35 @@
+<template>
+    <span>
+        <b-button id="page-create" class="m-1" @click="create">
+            <font-awesome-icon icon="plus" />
+            {{ "Create" | localize }}
+        </b-button>
+    </span>
+</template>
+
+<script>
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { BButton } from "bootstrap-vue";
+
+import { faPlus } from "@fortawesome/free-solid-svg-icons";
+import { library } from "@fortawesome/fontawesome-svg-core";
+library.add(faPlus);
+
+export default {
+    components: {
+        BButton,
+        FontAwesomeIcon,
+    },
+    props: {
+        root: {
+            type: String,
+            required: true,
+        },
+    },
+    methods: {
+        create: function () {
+            window.location.assign(`${this.root}pages/create`);
+        },
+    },
+};
+</script>
diff --git a/client/src/components/Page/PageList.vue b/client/src/components/Page/PageList.vue
new file mode 100644
index 000000000000..bb7e530d82ac
--- /dev/null
+++ b/client/src/components/Page/PageList.vue
@@ -0,0 +1,194 @@
+<template>
+    <div>
+        <b-alert v-bind="alertAttrs">{{ message }}</b-alert>
+        <b-row class="mb-3">
+            <b-col cols="6">
+                <index-filter v-bind="filterAttrs" id="page-search" v-model="filter"> </index-filter>
+            </b-col>
+            <b-col>
+                <PageIndexActions :root="root" class="float-right" />
+            </b-col>
+        </b-row>
+        <b-table :fields="fields" v-model="itemsModel" v-bind="indexTableAttrs">
+            <template v-slot:empty>
+                <loading-span v-if="loading" message="Loading pages" />
+                <b-alert v-else id="no-pages" variant="info" show>
+                    <div v-if="isFiltered">
+                        No matching entries found for: <span class="font-weight-bold">{{ filter }}</span
+                        >.
+                    </div>
+                    <div v-else>No pages found. You may create a new page.</div>
+                </b-alert>
+            </template>
+            <template v-slot:cell(title)="row">
+                <PageDropdown
+                    :page="row.item"
+                    :root="root"
+                    @onAdd="onAdd"
+                    @onRemove="onRemove"
+                    @onUpdate="onUpdate"
+                    @onSuccess="onSuccess"
+                    @onError="onError" />
+            </template>
+            <template v-slot:cell(tags)="row">
+                <Tags
+                    :index="row.index"
+                    :tags="row.item.tags"
+                    @input="onTags"
+                    @tag-click="onTagClick"
+                    :disabled="published" />
+            </template>
+            <template v-slot:cell(published)="row">
+                <SharingIndicators :object="row.item" @filter="(filter) => appendFilter(filter)" />
+            </template>
+            <template v-slot:cell(url)="row">
+                <PageUrl
+                    :root="root"
+                    :owner="row.item.username"
+                    :slug="row.item.slug"
+                    @clickOwner="(username) => appendTagFilter('user', username)" />
+            </template>
+            <template v-slot:cell(update_time)="data">
+                <UtcDate :date="data.value" mode="elapsed" />
+            </template>
+        </b-table>
+        <b-pagination
+            v-model="currentPage"
+            v-if="rows >= perPage"
+            class="gx-pages-grid-pager"
+            v-bind="paginationAttrs"></b-pagination>
+    </div>
+</template>
+<script>
+import _l from "utils/localization";
+import { getAppRoot } from "onload/loadConfig";
+// import { Services } from "./services";
+import { pagesProvider } from "components/providers/PageProvider";
+import Tags from "components/Common/Tags";
+import PageDropdown from "./PageDropdown";
+import UtcDate from "components/UtcDate";
+import paginationMixin from "components/Workflow/paginationMixin";
+import filtersMixin from "components/Indices/filtersMixin";
+import PageIndexActions from "./PageIndexActions";
+import PageUrl from "./PageUrl";
+
+import SharingIndicators from "components/Indices/SharingIndicators";
+
+const helpHtml = `<div>
+<p>This textbox box can be used to filter the pages displayed.
+
+<p>Text entered here will be searched against workflow names and tags. Additionally, advanced
+filtering tags can be used to refine the search more precisely. Tags are of the form
+<code>&lt;tag_name&gt;:&lt;tag_value&gt;</code> or <code>&lt;tag_name&gt;:'&lt;tag_value&gt;'</code>.
+For instance to search just for RNAseq in the workflow name, <code>name:rnsseq</code> can be used.
+Notice by default the search is not case-sensitive.
+
+If the quoted version of tag is used, the search is not case sensitive and only full matches will be
+returned. So <code>name:'RNAseq'</code> would show only pages named exactly <code>RNAseq</code>.
+
+<p>The available tags are:
+<dl>
+    <dt><code>title</code></dt>
+    <dd>This filters only against the page title.</dd>
+    <dt><code>tag</code></dt>
+    <dd>This filters only against the page tag. You may also just click on a tag in your list of workflows to filter on that tag using this directly.</dd>
+    <dt><code>is:published</code></dt>
+    <dd>This filters the workflows such that only published workflows are shown. You may also just click on the "published" icon of a worklfow in your list to filter on this directly.</dd>
+    <dt><code>is:shared</code></dt>
+    <dd>This filters the workflows such that only workflows shared from another user directly with you are are shown. You may also just click on the "shared with me" icon of a worklfow in your list to filter on this directly.</dd>
+</dl>
+</div>
+`;
+
+const TITLE_FIELD = { key: "title", label: _l("Title"), sortable: true };
+const TAGS_FIELD = { key: "tags", label: _l("Tags"), sortable: false };
+const URL_FIELD = { key: "url", label: _l("Public URL"), sortable: false };
+const UPDATED_FIELD = { label: _l("Updated"), key: "update_time", sortable: true };
+const SHARING_FIELD = { label: _l("Sharing"), key: "published", sortable: false };
+// const OWNER_FIELD = { key: "owner", label: _l("Owner"), sortable: true };
+
+const PERSONAL_FIELDS = [TITLE_FIELD, URL_FIELD, TAGS_FIELD, UPDATED_FIELD, SHARING_FIELD];
+const PUBLISHED_FIELDS = [TITLE_FIELD, URL_FIELD, TAGS_FIELD, UPDATED_FIELD];
+
+export default {
+    components: {
+        UtcDate,
+        Tags,
+        PageIndexActions,
+        SharingIndicators,
+        PageDropdown,
+        PageUrl,
+    },
+    props: {
+        published: {
+            // Render the published workflows version of this grid.
+            type: Boolean,
+            default: true,
+        },
+    },
+    mixins: [paginationMixin, filtersMixin],
+    data() {
+        const fields = this.published ? PUBLISHED_FIELDS : PERSONAL_FIELDS;
+        const implicitFilter = this.published ? "is:published" : null;
+        return {
+            tableId: "page-table",
+            fields: fields,
+            titleSearch: _l("Search Pages"),
+            itemsModel: [],
+            items: [],
+            helpHtml: helpHtml,
+            perPage: this.rowsPerPage(this.defaultPerPage || 50),
+            dataProvider: pagesProvider,
+            implicitFilter: implicitFilter,
+        };
+    },
+    created() {
+        this.root = getAppRoot();
+        // this.services = new Services({ root: this.root });
+    },
+    watch: {
+        filter(val) {
+            this.refresh();
+        },
+    },
+    computed: {
+        dataProviderParameters() {
+            const extraParams = { search: this.effectiveFilter };
+            if (this.published) {
+                extraParams.show_published = true;
+                extraParams.show_shared = false;
+            }
+            return extraParams;
+        },
+    },
+    methods: {
+        onTags: function (tags, index) {
+            const workflow = this.itemsModel[index];
+            workflow.tags = tags;
+            this.services
+                .updateWorkflow(workflow.id, {
+                    tags: workflow.tags,
+                })
+                .catch((error) => {
+                    this.onError(error);
+                });
+        },
+        onTagClick: function (tag) {
+            this.appendTagFilter("tag", tag.text);
+        },
+        onAdd: function (workflow) {
+            if (this.currentPage == 1) {
+                this.refresh();
+            } else {
+                this.currentPage = 1;
+            }
+        },
+        onRemove: function (id) {
+            this.refresh();
+        },
+        onUpdate: function (id, data) {
+            this.refresh();
+        },
+    },
+};
+</script>
diff --git a/client/src/components/Page/PageUrl.test.js b/client/src/components/Page/PageUrl.test.js
new file mode 100644
index 000000000000..39421807aee6
--- /dev/null
+++ b/client/src/components/Page/PageUrl.test.js
@@ -0,0 +1,36 @@
+import PageUrl from "./PageUrl";
+import { mount } from "@vue/test-utils";
+import { getLocalVue } from "jest/helpers";
+
+const localVue = getLocalVue(true);
+
+describe("PageUrl.vue", () => {
+    let wrapper;
+
+    beforeEach(async () => {
+        const propsData = {
+            root: "/rootprefix/",
+            owner: "jmchilton",
+            slug: "my-cool-slug",
+        };
+        wrapper = mount(PageUrl, {
+            propsData,
+            localVue,
+        });
+    });
+
+    describe("component", () => {
+        it("should localize title text", async () => {
+            expect(wrapper.find("svg title").text()).toBeLocalized();
+        });
+
+        it("should emit an event when owner is clicked on", async () => {
+            const ownerEl = wrapper.find("a.page-url-owner");
+            expect(ownerEl.text()).toBe("jmchilton");
+            await ownerEl.trigger("click");
+
+            const emitted = wrapper.emitted();
+            expect(emitted["click-owner"][0][0]).toEqual("jmchilton");
+        });
+    });
+});
diff --git a/client/src/components/Page/PageUrl.vue b/client/src/components/Page/PageUrl.vue
new file mode 100644
index 000000000000..78b51744dc55
--- /dev/null
+++ b/client/src/components/Page/PageUrl.vue
@@ -0,0 +1,55 @@
+<template>
+    <span class="page-url-entry">
+        <span>u/</span><a href="#" class="page-url-owner" @click.prevent="onClickOwner">{{ owner }}</a
+        ><span>/p/{{ slug }}</span>
+        <font-awesome-icon
+            v-b-tooltip.hover
+            :title="linkTitle | localize"
+            class="page-url-copy"
+            icon="copy"
+            style="cursor: pointer"
+            @click="copyLink" />
+    </span>
+</template>
+
+<script>
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faCopy } from "@fortawesome/free-solid-svg-icons";
+import { copy } from "utils/clipboard";
+
+library.add(faCopy);
+
+export default {
+    components: {
+        FontAwesomeIcon,
+    },
+    props: {
+        root: {
+            type: String,
+            required: true,
+        },
+        owner: {
+            type: String,
+            required: true,
+        },
+        slug: {
+            type: String,
+            required: true,
+        },
+    },
+    data() {
+        return {
+            linkTitle: "Copy URL Link to Galaxy Page",
+        };
+    },
+    methods: {
+        onClickOwner() {
+            this.$emit("click-owner", this.owner);
+        },
+        copyLink() {
+            copy(`${this.root}/u/${this.owner}/p/${this.slug}`);
+        },
+    },
+};
+</script>
diff --git a/client/src/components/Page/services.js b/client/src/components/Page/services.js
new file mode 100644
index 000000000000..1265b95c24bd
--- /dev/null
+++ b/client/src/components/Page/services.js
@@ -0,0 +1,20 @@
+import axios from "axios";
+import { rethrowSimple } from "utils/simple-error";
+import { getAppRoot } from "onload/loadConfig";
+
+/** Page request helper **/
+export class Services {
+    constructor(options = {}) {
+        this.root = options.root || getAppRoot();
+    }
+
+    async deletePage(id) {
+        const url = `${this.root}api/pages/${id}`;
+        try {
+            const response = await axios.delete(url);
+            return response.data;
+        } catch (e) {
+            rethrowSimple(e);
+        }
+    }
+}
diff --git a/client/src/components/Workflow/HistoryInvocations.vue b/client/src/components/Workflow/HistoryInvocations.vue
new file mode 100644
index 000000000000..aa19596ce520
--- /dev/null
+++ b/client/src/components/Workflow/HistoryInvocations.vue
@@ -0,0 +1,33 @@
+<template>
+    <CurrentUser v-slot="{ user }">
+        <Invocations
+            v-if="user.id && historyName"
+            :user-id="user.id"
+            :history-id="historyId"
+            :history-name="historyName" />
+    </CurrentUser>
+</template>
+<script>
+import Invocations from "components/Workflow/Invocations";
+import CurrentUser from "components/providers/CurrentUser";
+import { mapGetters } from "vuex";
+
+export default {
+    props: {
+        historyId: {
+            type: String,
+            required: true,
+        },
+    },
+    computed: {
+        ...mapGetters("history", ["getHistoryNameById"]),
+        historyName() {
+            return this.getHistoryNameById(this.historyId);
+        },
+    },
+    components: {
+        CurrentUser,
+        Invocations,
+    },
+};
+</script>
diff --git a/client/src/components/Workflow/Invocations.test.js b/client/src/components/Workflow/Invocations.test.js
index 8b1271e2bfec..a41e3465b9c2 100644
--- a/client/src/components/Workflow/Invocations.test.js
+++ b/client/src/components/Workflow/Invocations.test.js
@@ -62,7 +62,11 @@ describe("Invocations.vue", () => {
 
     describe("for a workflow with an empty invocation list", () => {
         beforeEach(async () => {
-            axiosMock.onAny().reply(200, [], { total_matches: "0" });
+            axiosMock
+                .onGet("/api/invocations", {
+                    params: { limit: 50, offset: 0, include_terminal: false, workflow_id: "abcde145678" },
+                })
+                .reply(200, [], { total_matches: "0" });
             const propsData = {
                 ownerGrid: false,
                 storedWorkflowName: "My Workflow",
@@ -81,6 +85,41 @@ describe("Invocations.vue", () => {
         it("no invocations message should be shown when not loading", async () => {
             expect(wrapper.find("#no-invocations").exists()).toBe(true);
         });
+
+        it("should not render pager", async () => {
+            expect(wrapper.find(".gx-invocations-grid-pager").exists()).toBeFalsy();
+        });
+    });
+
+    describe("for a history with an empty invocation list", () => {
+        beforeEach(async () => {
+            axiosMock
+                .onGet("/api/invocations", {
+                    params: { limit: 50, offset: 0, include_terminal: false, history_id: "abcde145678" },
+                })
+                .reply(200, [], { total_matches: "0" });
+            const propsData = {
+                ownerGrid: false,
+                historyName: "My History",
+                historyId: "abcde145678",
+            };
+            wrapper = mount(Invocations, {
+                propsData,
+                localVue,
+            });
+        });
+
+        it("title should be shown", async () => {
+            expect(wrapper.find("#invocations-title").text()).toBe("Workflow Invocations for My History");
+        });
+
+        it("no invocations message should be shown when not loading", async () => {
+            expect(wrapper.find("#no-invocations").exists()).toBe(true);
+        });
+
+        it("should not render pager", async () => {
+            expect(wrapper.find(".gx-invocations-grid-pager").exists()).toBeFalsy();
+        });
     });
 
     describe("with invocation", () => {
@@ -155,5 +194,45 @@ describe("Invocations.vue", () => {
             await wrapper.find(".workflow-run").trigger("click");
             expect(window.location).toBeAt("workflows/run?id=workflowId");
         });
+
+        it("should not render pager", async () => {
+            expect(wrapper.find(".gx-invocations-grid-pager").exists()).toBeFalsy();
+        });
+    });
+
+    describe("pagiantions", () => {
+        beforeEach(async () => {
+            axiosMock
+                .onGet("/api/invocations", { params: { limit: 1, offset: 0, include_terminal: false } })
+                .reply(200, [mockInvocationData], { total_matches: "3" });
+            const propsData = {
+                ownerGrid: false,
+                loading: false,
+                defaultPerPage: 1,
+            };
+            wrapper = mount(Invocations, {
+                propsData,
+                computed: {
+                    getWorkflowNameByInstanceId: (state) => (id) => "workflow name",
+                    getWorkflowByInstanceId: (state) => (id) => {
+                        return { id: "workflowId" };
+                    },
+                    getHistoryById: (state) => (id) => {
+                        return { id: "historyId" };
+                    },
+                    getHistoryNameById: () => () => "history name",
+                },
+                stubs: {
+                    "workflow-invocation-state": {
+                        template: "<span/>",
+                    },
+                },
+                localVue,
+            });
+        });
+
+        it("title should render pager", async () => {
+            expect(wrapper.find(".gx-invocations-grid-pager").exists()).toBeTruthy();
+        });
     });
 });
diff --git a/client/src/components/Workflow/Invocations.vue b/client/src/components/Workflow/Invocations.vue
index 44b517ab491f..9247252fb713 100644
--- a/client/src/components/Workflow/Invocations.vue
+++ b/client/src/components/Workflow/Invocations.vue
@@ -6,12 +6,11 @@
         <b-alert v-if="headerMessage" variant="info" show>
             {{ headerMessage }}
         </b-alert>
-        <b-alert class="index-grid-message" :variant="messageVariant" :show="showMessage">{{ message }}</b-alert>
+        <b-alert v-bind="alertAttrs">{{ message }}</b-alert>
         <b-table
             v-bind="indexTableAttrs"
             v-model="invocationItemsModel"
             :fields="invocationFields"
-            :items="provider"
             class="invocations-table">
             <template v-slot:empty>
                 <loading-span v-if="loading" message="Loading workflow invocations" />
@@ -72,7 +71,7 @@
             </template>
         </b-table>
         <b-pagination
-            v-show="rows >= perPage"
+            v-if="rows >= perPage"
             v-model="currentPage"
             class="gx-invocations-grid-pager"
             v-bind="paginationAttrs"></b-pagination>
@@ -80,7 +79,6 @@
 </template>
 
 <script>
-import { getAppRoot } from "onload/loadConfig";
 import { getGalaxyInstance } from "app";
 import { invocationsProvider } from "components/providers/InvocationsProvider";
 import { WorkflowInvocationState } from "components/WorkflowInvocationState";
@@ -102,26 +100,31 @@ export default {
         headerMessage: { type: String, default: "" },
         ownerGrid: { type: Boolean, default: true },
         userId: { type: String, default: null },
+        historyId: { type: String, default: null },
+        historyName: { type: String, default: null },
         storedWorkflowId: { type: String, default: null },
         storedWorkflowName: { type: String, default: null },
     },
     data() {
-        const fields = [
-            { key: "expand", label: "", class: "col-button" },
-            { key: "workflow_id", label: "Workflow", class: "col-name" },
-            { key: "history_id", label: "History", class: "col-history" },
+        const fields = [{ key: "expand", label: "", class: "col-button" }];
+        if (!this.storedWorkflowId) {
+            fields.push({ key: "workflow_id", label: "Workflow", class: "col-name" });
+        }
+        if (!this.historyId) {
+            fields.push({ key: "history_id", label: "History", class: "col-history" });
+        }
+        fields.push(
             { key: "create_time", label: "Invoked", class: "col-small", sortable: true },
             { key: "update_time", label: "Updated", class: "col-small", sortable: true },
             { key: "state", class: "col-small" },
-            { key: "execute", label: "", class: "col-button" },
-        ];
+            { key: "execute", label: "", class: "col-button" }
+        );
         return {
             tableId: "invocation-list-table",
-            invocationItems: [],
+            dataProvider: invocationsProvider,
             invocationItemsModel: [],
             invocationFields: fields,
-            perPage: this.rowsPerPage(50),
-            root: getAppRoot(),
+            perPage: this.rowsPerPage(this.defaultPerPage || 50),
         };
     },
     computed: {
@@ -132,6 +135,9 @@ export default {
             if (this.storedWorkflowName) {
                 title += ` for ${this.storedWorkflowName}`;
             }
+            if (this.historyName) {
+                title += ` for ${this.historyName}`;
+            }
             return title;
         },
         effectiveNoInvocationsMessage() {
@@ -139,11 +145,27 @@ export default {
             if (this.storedWorkflowName) {
                 message += ` for ${this.storedWorkflowName}`;
             }
+            if (this.historyName) {
+                message += ` for ${this.historyName}`;
+            }
             return message;
         },
+        dataProviderParameters() {
+            const extraParams = this.ownerGrid ? {} : { include_terminal: false };
+            if (this.storedWorkflowId) {
+                extraParams["workflow_id"] = this.storedWorkflowId;
+            }
+            if (this.historyId) {
+                extraParams["history_id"] = this.historyId;
+            }
+            if (this.userId) {
+                extraParams["user_id"] = this.userId;
+            }
+            return extraParams;
+        },
     },
     watch: {
-        invocationItems: function (invocations) {
+        items: function (invocations) {
             if (invocations) {
                 const historyIds = new Set();
                 const workflowIds = new Set();
@@ -162,20 +184,6 @@ export default {
     methods: {
         ...mapCacheActions(["fetchWorkflowForInstanceId"]),
         ...mapCacheActions("history", ["loadHistoryById"]),
-        async provider(ctx) {
-            ctx.root = this.root;
-            const extraParams = this.ownerGrid ? {} : { include_terminal: false };
-            if (this.storedWorkflowId) {
-                extraParams["workflow_id"] = this.storedWorkflowId;
-            }
-            if (this.userId) {
-                extraParams["user_id"] = this.userId;
-            }
-            const promise = invocationsProvider(ctx, this.setRows, extraParams).catch(this.onError);
-            const invocationItems = await promise;
-            this.invocationItems = invocationItems;
-            return invocationItems;
-        },
         swapRowDetails(row) {
             row.toggleDetails();
         },
diff --git a/client/src/components/Workflow/WorkflowDropdown.vue b/client/src/components/Workflow/WorkflowDropdown.vue
index 5576e8d87a33..9bb5d3f4043f 100644
--- a/client/src/components/Workflow/WorkflowDropdown.vue
+++ b/client/src/components/Workflow/WorkflowDropdown.vue
@@ -5,6 +5,7 @@
             class="workflow-dropdown font-weight-bold"
             data-toggle="dropdown"
             aria-haspopup="true"
+            :data-workflow-dropdown="workflow.id"
             aria-expanded="false">
             <font-awesome-icon icon="caret-down" />
             <span class="workflow-dropdown-name">{{ workflow.name }}</span>
diff --git a/client/src/components/Workflow/WorkflowList.vue b/client/src/components/Workflow/WorkflowList.vue
index c79183967725..338b2cea39c1 100644
--- a/client/src/components/Workflow/WorkflowList.vue
+++ b/client/src/components/Workflow/WorkflowList.vue
@@ -1,21 +1,15 @@
 <template>
     <div>
-        <b-alert class="index-grid-message" :variant="messageVariant" :show="showMessage">{{ message }}</b-alert>
+        <b-alert v-bind="alertAttrs">{{ message }}</b-alert>
         <b-row class="mb-3">
             <b-col cols="6" class="m-1">
-                <index-filter
-                    id="workflow-search"
-                    v-model="filter"
-                    :debounce-delay="inputDebounceDelay"
-                    :placeholder="titleSearch"
-                    :help-html="helpHtml">
-                </index-filter>
+                <index-filter v-bind="filterAttrs" id="workflow-search" v-model="filter"> </index-filter>
             </b-col>
             <b-col>
                 <WorkflowIndexActions :root="root" class="float-right"> </WorkflowIndexActions>
             </b-col>
         </b-row>
-        <b-table v-model="workflowItemsModel" :fields="fields" :items="provider" v-bind="indexTableAttrs">
+        <b-table v-model="workflowItemsModel" :fields="fields" v-bind="indexTableAttrs">
             <template v-slot:empty>
                 <loading-span v-if="loading" message="Loading workflows" />
                 <b-alert v-else id="no-workflows" variant="info" show>
@@ -36,7 +30,12 @@
                     @onError="onError" />
             </template>
             <template v-slot:cell(tags)="row">
-                <Tags :index="row.index" :tags="row.item.tags" @input="onTags" @tag-click="onTagClick" />
+                <Tags
+                    :index="row.index"
+                    :tags="row.item.tags"
+                    @input="onTags"
+                    @tag-click="onTagClick"
+                    :disabled="published" />
             </template>
             <template v-slot:cell(published)="row">
                 <SharingIndicators :object="row.item" @filter="(filter) => appendFilter(filter)" />
@@ -49,6 +48,9 @@
             <template v-slot:cell(update_time)="data">
                 <UtcDate :date="data.value" mode="elapsed" />
             </template>
+            <template v-slot:cell(owner)="data">
+                <a class="workflow-filter-link-owner" @click="appendTagFilter('user', data.value)">{{ data.value }}</a>
+            </template>
             <template v-slot:cell(execute)="row">
                 <WorkflowRunButton :id="row.item.id" :root="root" />
             </template>
@@ -103,6 +105,17 @@ returned. So <code>name:'RNAseq'</code> would show only workflows named exactly
 </div>
 `;
 
+const NAME_FIELD = { key: "name", label: _l("Name"), sortable: true };
+const TAGS_FIELD = { key: "tags", label: _l("Tags"), sortable: false };
+const UPDATED_FIELD = { label: _l("Updated"), key: "update_time", sortable: true };
+const SHARING_FIELD = { label: _l("Sharing"), key: "published", sortable: false };
+const BOOKMARKED_FIELD = { label: _l("Bookmarked"), key: "show_in_tool_panel", sortable: false };
+const EXECUTE_FIELD = { key: "execute", label: "" };
+const OWNER_FIELD = { key: "owner", label: _l("Owner"), sortable: true };
+
+const PERSONAL_FIELDS = [NAME_FIELD, TAGS_FIELD, UPDATED_FIELD, SHARING_FIELD, BOOKMARKED_FIELD, EXECUTE_FIELD];
+const PUBLISHED_FIELDS = [NAME_FIELD, TAGS_FIELD, UPDATED_FIELD, OWNER_FIELD];
+
 export default {
     components: {
         UtcDate,
@@ -115,50 +128,24 @@ export default {
     },
     mixins: [paginationMixin, filtersMixin],
     props: {
-        inputDebounceDelay: {
-            type: Number,
-            default: 500,
+        published: {
+            // Render the published workflows version of this grid.
+            type: Boolean,
+            default: false,
         },
     },
     data() {
+        const fields = this.published ? PUBLISHED_FIELDS : PERSONAL_FIELDS;
+        const implicitFilter = this.published ? "is:published" : null;
         return {
             tableId: "workflow-table",
-            fields: [
-                {
-                    key: "name",
-                    label: _l("Name"),
-                    sortable: true,
-                },
-                {
-                    key: "tags",
-                    label: _l("Tags"),
-                    sortable: false,
-                },
-                {
-                    label: _l("Updated"),
-                    key: "update_time",
-                    sortable: true,
-                },
-                {
-                    label: _l("Sharing"),
-                    key: "published",
-                    sortable: false,
-                },
-                {
-                    label: _l("Bookmarked"),
-                    key: "show_in_tool_panel",
-                    sortable: false,
-                },
-                {
-                    key: "execute",
-                    label: "",
-                },
-            ],
+            fields: fields,
             titleSearch: _l("Search Workflows"),
             workflowItemsModel: [],
-            workflowItems: [],
             helpHtml: helpHtml,
-            perPage: this.rowsPerPage(50),
+            perPage: this.rowsPerPage(this.defaultPerPage || 50),
+            dataProvider: storedWorkflowsProvider,
+            implicitFilter: implicitFilter,
         };
     },
     watch: {
@@ -166,19 +153,23 @@ export default {
             this.refresh();
         },
     },
+    computed: {
+        dataProviderParameters() {
+            const extraParams = { search: this.effectiveFilter, skip_step_counts: true };
+            if (this.published) {
+                extraParams.show_published = true;
+                extraParams.show_shared = false;
+            }
+            return extraParams;
+        },
+    },
     created() {
         this.root = getAppRoot();
         this.services = new Services({ root: this.root });
     },
     methods: {
-        async provider(ctx) {
-            ctx.root = this.root;
-            const extraParams = { search: this.filter, skip_step_counts: true };
-            const promise = storedWorkflowsProvider(ctx, this.setRows, extraParams).catch(this.onError);
-            const workflowItems = await promise;
-            (workflowItems || []).forEach((item) => this.services._addAttributes(item));
-            this.workflowItems = workflowItems;
-            return this.workflowItems;
+        decorateData(item) {
+            this.services._addAttributes(item);
         },
         bookmarkWorkflow: function (id, checked) {
             const data = {
@@ -196,7 +187,7 @@ export default {
                         getGalaxyInstance().config.stored_workflow_menu_entries.splice(indexToRemove, 1);
                     }
 
-                    this.workflowItems.find((workflow) => {
+                    this.items.find((workflow) => {
                         if (workflow.id === id) {
                             workflow.show_in_tool_panel = checked;
                             return true;
diff --git a/client/src/components/Workflow/Workflows.test.js b/client/src/components/Workflow/Workflows.test.js
index 9bc8ad72159d..4f2b2de755fb 100644
--- a/client/src/components/Workflow/Workflows.test.js
+++ b/client/src/components/Workflow/Workflows.test.js
@@ -175,4 +175,51 @@ describe("WorkflowList.vue", () => {
             expect(wrapper.vm.filter).toBe("is:shared_with_me");
         });
     });
+
+    describe("published grid", () => {
+        beforeEach(async () => {
+            axiosMock
+                .onGet("/api/workflows", {
+                    params: {
+                        limit: 50,
+                        offset: 0,
+                        search: "is:published",
+                        skip_step_counts: true,
+                        show_published: true,
+                        show_shared: false,
+                    },
+                })
+                .reply(200, mockWorkflowsData, { total_matches: "1" });
+            const propsData = {
+                inputDebounceDelay: 0,
+                published: true,
+            };
+            wrapper = mount(Workflows, {
+                propsData,
+                localVue,
+            });
+            flushPromises();
+        });
+
+        it("should be error free", async () => {
+            const errorDiv = wrapper.find(".index-grid-message");
+            expect(errorDiv.text()).toBeFalsy();
+        });
+
+        it("renders one row", async () => {
+            const rows = wrapper.findAll("tbody > tr").wrappers;
+            expect(rows.length).toBe(1);
+            const row = rows[0];
+            const columns = row.findAll("td");
+            expect(columns.at(0).text()).toContain("workflow name");
+            expect(columns.at(1).text()).toContain("tagmoo");
+            expect(columns.at(1).text()).toContain("tagcow");
+            expect(columns.at(2).text()).toBe(
+                formatDistanceToNow(parseISO(`${mockWorkflowsData[0].update_time}Z`), { addSuffix: true })
+            );
+            expect(columns.at(2).text()).toBe(
+                formatDistanceToNow(parseISO(`${mockWorkflowsData[0].update_time}Z`), { addSuffix: true })
+            );
+        });
+    });
 });
diff --git a/client/src/components/Workflow/paginationMixin.js b/client/src/components/Workflow/paginationMixin.js
index 71c33f14a3c7..2195dec4b38a 100644
--- a/client/src/components/Workflow/paginationMixin.js
+++ b/client/src/components/Workflow/paginationMixin.js
@@ -1,13 +1,23 @@
 import QueryStringParsing from "utils/query-string-parsing";
 import LoadingSpan from "components/LoadingSpan";
 import { errorMessageAsString } from "utils/simple-error";
+import { getAppRoot } from "onload/loadConfig";
 
 export default {
     components: { LoadingSpan },
+    props: {
+        defaultPerPage: {
+            type: Number,
+            required: false,
+            default: null,
+        },
+    },
     data() {
         return {
+            items: [],
+            root: getAppRoot(),
             currentPage: 1,
-            perPage: 20,
+            perPage: this.defaultPerPage || 20,
             rows: 0,
             loading: true,
             message: null,
@@ -39,6 +49,14 @@ export default {
                 id: this.tableId,
                 "per-page": this.perPage,
                 "current-page": this.currentPage,
+                items: this.tableProvider,
+            };
+        },
+        alertAttrs() {
+            return {
+                class: "index-grid-message",
+                variant: this.messageVariant,
+                show: this.showMessage,
             };
         },
         showMessage() {
@@ -46,6 +64,16 @@ export default {
         },
     },
     methods: {
+        async tableProvider(ctx) {
+            ctx.root = this.root;
+            const extraParams = this.dataProviderParameters;
+            const promise = this.dataProvider(ctx, this.setRows, extraParams).catch(this.onError);
+            const items = await promise;
+            (items || []).forEach(this.decorateData);
+            this.items = items;
+            return items;
+        },
+        decorateData(item) {},
         refresh() {
             this.$root.$emit("bv::refresh::table", this.tableId);
         },
diff --git a/client/src/components/admin/Jobs.vue b/client/src/components/admin/Jobs.vue
index 2ff17dee7925..8e0c6e4e05c8 100644
--- a/client/src/components/admin/Jobs.vue
+++ b/client/src/components/admin/Jobs.vue
@@ -38,13 +38,9 @@
                         </b-input-group>
                     </b-form-group>
                 </b-form>
-                <b-form-group
-                    label="Filter Jobs"
-                    label-for="filter-regex"
-                    description="by strings or regular expressions">
-                    <b-input-group id="filter-regex">
-                        <b-form-input v-model="filter" placeholder="Type to Search" @keyup.esc.native="filter = ''" />
-                    </b-input-group>
+                <b-form-group label="Filter Jobs">
+                    <index-filter id="job-search" :placeholder="titleSearchJobs" :help-html="helpHtml" v-model="filter">
+                    </index-filter>
                 </b-form-group>
             </b-col>
         </b-row>
@@ -66,7 +62,6 @@
             v-model="jobsItemsModel"
             :fields="unfinishedJobFields"
             :items="unfinishedJobs"
-            :filter="filter"
             :table-caption="runningTableCaption"
             :no-items-message="runningNoJobsMessage"
             :loading="loading"
@@ -92,9 +87,12 @@
                 :table-caption="finishedTableCaption"
                 :fields="finishedJobFields"
                 :items="finishedJobs"
-                :filter="filter"
                 :no-items-message="finishedNoJobsMessage"
                 :loading="loading"
+                @tool-clicked="(toolId) => appendTagFilter('tool', toolId)"
+                @runner-clicked="(runner) => appendTagFilter('runner', runner)"
+                @handler-clicked="(handler) => appendTagFilter('handler', handler)"
+                @user-clicked="(user) => appendTagFilter('user', user)"
                 :busy="busy">
             </jobs-table>
         </template>
@@ -110,14 +108,42 @@ import JOB_STATES_MODEL from "mvc/history/job-states-model";
 import { commonJobFields } from "./JobFields";
 import { errorMessageAsString } from "utils/simple-error";
 import { jobsProvider } from "components/providers/JobProvider";
+import filtersMixin from "components/Indices/filtersMixin";
 
 function cancelJob(jobId, message) {
     const url = `${getAppRoot()}api/jobs/${jobId}`;
     return axios.delete(url, { data: { message: message } });
 }
 
+const helpHtml = `<div>
+<p>This textbox box can be used to filter the jobs displayed.
+
+<p>Text entered here will be searched against job user, tool ID, job runner, and handler. Additionally,
+advanced filtering tags can be used to refine the search more precisely. Tags are of the form
+<code>&lt;tag_name&gt;:&lt;tag_value&gt;</code> or <code>&lt;tag_name&gt;:'&lt;tag_value&gt;'</code>.
+For instance to search just for jobs with <code>cat1</code> in the tool name, <code>tool_id:cat1</code> can be used.
+Notice by default the search is not case-sensitive.
+
+If the quoted version of tag is used, the search is not case sensitive and only full matches will be
+returned. So <code>tool_id:'cat1'</code> would show only jobs from the <code>cat1</code> tool exactly.
+
+<p>The available tags are:
+<dl>
+    <dt><code>user</code></dt>
+    <dd>This filters the job index to contain only jobs executed by matching user(s). You may also just click on a user in the list of jobs to filter on that exact user using this directly.</dd>
+    <dt><code>handler</code></dt>
+    <dd>This filters the job index to contain only jobs executed on matching handler(s).  You may also just click on a handler in the list of jobs to filter on that exact user using this directly.</dd>
+    <dt><code>runner</code></dt>
+    <dd>This filters the job index to contain only jobs executed on matching job runner(s).  You may also just click on a runner in the list of jobs to filter on that exact user using this directly.</dd>
+    <dt><code>tool</code></dt>
+    <dd>This filters the job index to contain only jobs from the matching tool(s).  You may also just click on a tool in the list of jobs to filter on that exact user using this directly.</dd>
+</dl>
+</div>
+`;
+
 export default {
     components: { JobLock, JobsTable },
+    mixins: [filtersMixin],
     data() {
         return {
             jobs: [],
@@ -135,13 +161,14 @@ export default {
             allSelected: false,
             indeterminate: false,
             stopMessage: "",
-            filter: "",
             message: "",
             status: "info",
             loading: true,
             busy: true,
             cutoffMin: 5,
             showAllRunning: false,
+            titleSearchJobs: `Search Jobs`,
+            helpHtml: helpHtml,
         };
     },
     computed: {
@@ -210,6 +237,9 @@ export default {
                 const dateRangeMin = new Date(Date.now() - cutoff * 60 * 1000).toISOString();
                 params.date_range_min = `${dateRangeMin}`;
             }
+            if (this.filter) {
+                params.search = this.filter;
+            }
             const ctx = {
                 root: getAppRoot(),
                 ...params,
diff --git a/client/src/components/admin/JobsTable.vue b/client/src/components/admin/JobsTable.vue
index 34d1a80023b2..576b944a5a5e 100644
--- a/client/src/components/admin/JobsTable.vue
+++ b/client/src/components/admin/JobsTable.vue
@@ -1,15 +1,15 @@
 <template>
-    <div>
+    <div class="jobs-table-wrapper">
         <b-table
             v-model="innerValue"
             :fields="fields"
             :items="items"
-            :filter="filter"
             hover
             responsive
             striped
             caption-top
             :busy="busy"
+            class="jobs-table"
             show-empty
             @row-clicked="toggleDetails">
             <template v-slot:table-caption>
@@ -27,6 +27,35 @@
             <template v-slot:row-details="row">
                 <job-details :job="row.item" />
             </template>
+            <template v-slot:cell(user_email)="data">
+                <a class="job-filter-link-user" :data-user="data.value" @click="$emit('user-clicked', data.value)">{{
+                    data.value
+                }}</a>
+            </template>
+            <template v-slot:cell(tool_id)="data">
+                <a
+                    class="job-filter-link-tool-id"
+                    :data-tool-id="data.value"
+                    @click="$emit('tool-clicked', data.value)"
+                    >{{ data.value }}</a
+                >
+            </template>
+            <template v-slot:cell(job_runner_name)="data">
+                <a
+                    class="job-filter-link-runner"
+                    :data-runner="data.value"
+                    @click="$emit('runner-clicked', data.value)"
+                    >{{ data.value }}</a
+                >
+            </template>
+            <template v-slot:cell(handler)="data">
+                <a
+                    class="job-filter-link-handler"
+                    :data-handler="data.handler"
+                    @click="$emit('handler-clicked', data.value)"
+                    >{{ data.value }}</a
+                >
+            </template>
             <template v-for="(index, name) in $slots" v-slot:[name]>
                 <slot :name="name" />
             </template>
@@ -55,10 +84,6 @@ export default {
         items: {
             required: true,
         },
-        filter: {
-            type: String,
-            required: true,
-        },
         busy: {
             type: Boolean,
             required: true,
diff --git a/client/src/components/plugins/icons.js b/client/src/components/plugins/icons.js
index b6b6c7f6661b..2c4bcba52a5c 100644
--- a/client/src/components/plugins/icons.js
+++ b/client/src/components/plugins/icons.js
@@ -31,6 +31,7 @@ import {
     faPlus,
     faQuestion,
     faShareAlt,
+    faSitemap,
     faStream,
     faTags,
     faTrash,
@@ -72,6 +73,7 @@ library.add(
     faPlus,
     faQuestion,
     faShareAlt,
+    faSitemap,
     faStream,
     faTags,
     faTrash,
diff --git a/client/src/components/providers/PageProvider.js b/client/src/components/providers/PageProvider.js
new file mode 100644
index 000000000000..71853a9ec5cf
--- /dev/null
+++ b/client/src/components/providers/PageProvider.js
@@ -0,0 +1,18 @@
+import axios from "axios";
+import { cleanPaginationParameters } from "./utils";
+
+export function pagesProvider(ctx, callback, extraParams = {}) {
+    const { root, ...requestParams } = ctx;
+    const apiUrl = `${root}api/pages`;
+    const cleanParams = cleanPaginationParameters(requestParams);
+    const promise = axios.get(apiUrl, { params: { ...cleanParams, ...extraParams } });
+
+    // Must return a promise that resolves to an array of items
+    return promise.then((data) => {
+        // Pluck the array of items off our axios response
+        const items = data.data;
+        callback && callback(data);
+        // Must return an array of items or an empty array if an error occurred
+        return items || [];
+    });
+}
diff --git a/client/src/components/providers/PageProvider.test.js b/client/src/components/providers/PageProvider.test.js
new file mode 100644
index 000000000000..472f94f9fe87
--- /dev/null
+++ b/client/src/components/providers/PageProvider.test.js
@@ -0,0 +1,43 @@
+import axios from "axios";
+import MockAdapter from "axios-mock-adapter";
+
+import { pagesProvider } from "./PageProvider";
+
+describe("PageProvider", () => {
+    let axiosMock;
+
+    beforeEach(async () => {
+        axiosMock = new MockAdapter(axios);
+    });
+
+    afterEach(() => {
+        axiosMock.restore();
+    });
+
+    describe("fetching workflows without an error", () => {
+        it("should make an API call and fire callback", async () => {
+            axiosMock
+                .onGet("/prefix/api/pages", {
+                    params: { limit: 50, offset: 0, search: "rna tutorial" },
+                })
+                .reply(200, [{ model_class: "Page" }], { total_matches: "1" });
+
+            const ctx = {
+                root: "/prefix/",
+                perPage: 50,
+                currentPage: 1,
+            };
+            const extras = {
+                search: "rna tutorial",
+            };
+
+            let called = false;
+            const callback = function () {
+                called = true;
+            };
+            const promise = pagesProvider(ctx, callback, extras);
+            await promise;
+            expect(called).toBeTruthy();
+        });
+    });
+});
diff --git a/client/src/entry/analysis/router.js b/client/src/entry/analysis/router.js
index 78f8d417c930..8f26d3a1539a 100644
--- a/client/src/entry/analysis/router.js
+++ b/client/src/entry/analysis/router.js
@@ -24,11 +24,12 @@ import DatasetError from "components/DatasetInformation/DatasetError";
 import DatasetList from "components/Dataset/DatasetList";
 import AvailableDatatypes from "components/AvailableDatatypes/AvailableDatatypes";
 import FormGeneric from "components/Form/FormGeneric";
-import Grid from "components/Grid/Grid";
 import GridShared from "components/Grid/GridShared";
 import GridHistory from "components/Grid/GridHistory";
+import PageList from "components/Page/PageList";
 import HistoryImport from "components/HistoryImport";
 import HistoryView from "components/HistoryView";
+import HistoryInvocations from "components/Workflow/HistoryInvocations";
 import HistoryMultipleView from "components/History/Multiple/MultipleView";
 import InteractiveTools from "components/InteractiveTools/InteractiveTools";
 import InvocationReport from "components/Workflow/InvocationReport";
@@ -200,6 +201,11 @@ export function getRouter(Galaxy) {
                         component: HistoryExport,
                         props: true,
                     },
+                    {
+                        path: "histories/:historyId/invocations",
+                        component: HistoryInvocations,
+                        props: true,
+                    },
                     {
                         path: "histories/:actionId",
                         component: GridHistory,
@@ -254,11 +260,9 @@ export function getRouter(Galaxy) {
                     },
                     {
                         path: "pages/:actionId",
-                        component: GridShared,
+                        component: PageList,
                         props: (route) => ({
-                            actionId: route.params.actionId,
-                            item: "page",
-                            plural: "Pages",
+                            published: route.props.actionId == "list_published" ? "shared" : "user",
                         }),
                     },
                     {
@@ -384,10 +388,9 @@ export function getRouter(Galaxy) {
                     },
                     {
                         path: "workflows/list_published",
-                        component: Grid,
+                        component: WorkflowList,
                         props: (route) => ({
-                            urlBase: "workflow/list_published",
-                            userFilter: route.query["f-username"],
+                            published: true,
                         }),
                     },
                     {
diff --git a/client/src/utils/navigation/navigation.yml b/client/src/utils/navigation/navigation.yml
index 8b87ec7ade68..5c65a81e397e 100644
--- a/client/src/utils/navigation/navigation.yml
+++ b/client/src/utils/navigation/navigation.yml
@@ -67,7 +67,9 @@ masthead:
 
     # Shared data
     libraries: 'Data Libraries'
+    published_workflows: 'Workflows'
     published_histories: 'Histories'
+    published_pages: 'Pages'
 
 preferences:
   selectors:
@@ -426,6 +428,10 @@ pages:
     create: '.manage-table-actions .action-button'
     submit: '#submit'
     export: '.markdown-pdf-export'
+    dropdown: '[data-page-dropdown*="${id}"]'
+    index_table: "#page-table"
+    index_rows: "#page-table > tbody > tr:not(.b-table-empty-row, [style*='display: none'])"
+
   editor:
     selectors:
       wym_iframe: 'div.wym_iframe iframe'
@@ -484,6 +490,7 @@ workflows:
     pager_page_last: '.gx-workflows-grid-pager .gx-grid-pager-last button'
     pager_page_previous: '.gx-workflows-grid-pager .gx-grid-pager-prev button'
     pager_page_active: '.gx-workflows-grid-pager .gx-grid-pager-page.active button'
+    dropdown: '[data-workflow-dropdown*="${id}"]'
     run_button: '[data-workflow-run*="${id}"]'
     bookmark_link: '.workflow-bookmark-link'
     workflow_with_name:
@@ -696,6 +703,16 @@ admin:
         type: xpath
         selector: "//label[@for='prevent-job-dispatching']/strong"
       cutoff: '#cutoff'
+      table: '.jobs-table'
+      filter_link_user: '.job-filter-link-user'
+      filter_link_tool: '.job-filter-link-tool-id'
+      filter_link_handler: '.job-filter-link-handler'
+      filter_link_runner: '.job-filter-link-runner'
+      filter_link_by_user: '.job-filter-link-user[data-user="${user}"]'
+      filter_link_by_tool: '.job-filter-link-tool-id[data-tool-id="${tool_id}"]'
+      filter_link_by_handler: '.job-filter-link-handler[data-handler="${handler}"]'
+      filter_link_by_runner: '.job-filter-link-runner[data-runner="${runner}"]'
+      filter_query: '.index-filter-query'
 
   toolshed:
     selectors:
diff --git a/lib/galaxy/managers/pages.py b/lib/galaxy/managers/pages.py
index 88078ceedf01..aa0563674620 100644
--- a/lib/galaxy/managers/pages.py
+++ b/lib/galaxy/managers/pages.py
@@ -20,6 +20,7 @@
     or_,
     true,
 )
+from sqlalchemy.orm import aliased
 
 from galaxy import (
     exceptions,
@@ -37,6 +38,12 @@
     ready_galaxy_markdown_for_export,
     ready_galaxy_markdown_for_import,
 )
+from galaxy.model.index_filter_util import (
+    append_user_filter,
+    raw_text_column_filter,
+    tag_filter,
+    text_column_filter,
+)
 from galaxy.model.item_attrs import UsesAnnotations
 from galaxy.schema.schema import (
     CreatePagePayload,
@@ -46,6 +53,11 @@
 from galaxy.structured_app import MinimalManagerApp
 from galaxy.util import unicodify
 from galaxy.util.sanitize_html import sanitize_html
+from galaxy.util.search import (
+    FilteredTerm,
+    parse_filters_structured,
+    RawTextTerm,
+)
 
 log = logging.getLogger(__name__)
 
@@ -80,6 +92,17 @@
     159: "\u0178",  # latin capital letter y with diaeresis
 }
 
+INDEX_SEARCH_FILTERS = {
+    "title": "title",
+    "slug": "slug",
+    "tag": "tag",
+    "user": "user",
+    "u": "user",
+    "s": "slug",
+    "t": "tag",
+    "is": "is",
+}
+
 
 class PageManager(sharable.SharableModelManager, UsesAnnotations):
     """Provides operations for managing a Page."""
@@ -103,12 +126,13 @@ def index_query(self, trans: ProvidesUserContext, payload: PageIndexQueryPayload
         query = trans.sa_session.query(model.Page)
         is_admin = trans.user_is_admin
         user = trans.user
+        show_shared = payload.show_shared
         if not is_admin:
             filters = [model.Page.user == trans.user]
             if payload.show_published:
                 filters.append(model.Page.published == true())
 
-            if user and payload.show_shared:
+            if user and show_shared:
                 filters.append(model.PageUserShareAssociation.user == user)
                 query = query.outerjoin(model.Page.users_shared_with)
 
@@ -124,6 +148,52 @@ def index_query(self, trans: ProvidesUserContext, payload: PageIndexQueryPayload
         if payload.user_id:
             query = query.filter(model.Page.user_id == payload.user_id)
 
+        if payload.search:
+            search_query = payload.search
+            parsed_search = parse_filters_structured(search_query, INDEX_SEARCH_FILTERS)
+
+            def p_tag_filter(term_text: str, quoted: bool):
+                nonlocal query
+                alias = aliased(model.PageTagAssociation)
+                query = query.outerjoin(model.Page.tags.of_type(alias))
+                return tag_filter(alias, term_text, quoted)
+
+            for term in parsed_search.terms:
+                if isinstance(term, FilteredTerm):
+                    key = term.filter
+                    q = term.text
+                    if key == "tag":
+                        pg = p_tag_filter(term.text, term.quoted)
+                        query = query.filter(pg)
+                    elif key == "title":
+                        query = query.filter(text_column_filter(model.Page.title, term))
+                    elif key == "slug":
+                        query = query.filter(text_column_filter(model.Page.slug, term))
+                    elif key == "user":
+                        query = append_user_filter(query, model.Page, term)
+                    elif key == "is":
+                        if q == "published":
+                            query = query.filter(model.Page.published == true())
+                        elif q == "shared_with_me":
+                            if not show_shared:
+                                message = "Can only use tag is:shared_with_me if show_shared parameter also true."
+                                raise exceptions.RequestParameterInvalidException(message)
+                            query = query.filter(model.PageUserShareAssociation.user == user)
+                elif isinstance(term, RawTextTerm):
+                    tf = p_tag_filter(term.text, False)
+                    alias = aliased(model.User)
+                    query = query.outerjoin(model.Page.user.of_type(alias))
+                    query = query.filter(
+                        raw_text_column_filter(
+                            [
+                                model.Page.title,
+                                model.Page.slug,
+                                tf,
+                                alias.username,
+                            ],
+                            term,
+                        )
+                    )
         total_matches = query.count()
         sort_column = getattr(model.Page, payload.sort_by)
         if payload.sort_desc:
diff --git a/lib/galaxy/model/__init__.py b/lib/galaxy/model/__init__.py
index 3b39e27169ef..fd44a8d30792 100644
--- a/lib/galaxy/model/__init__.py
+++ b/lib/galaxy/model/__init__.py
@@ -8874,6 +8874,8 @@ class Page(Base, Dictifiable, RepresentById):
         "importable",
         "deleted",
         "username",
+        "create_time",
+        "update_time",
     ]
 
     def to_dict(self, view="element"):
diff --git a/lib/galaxy/schema/schema.py b/lib/galaxy/schema/schema.py
index 1baae04d2389..c6effe930011 100644
--- a/lib/galaxy/schema/schema.py
+++ b/lib/galaxy/schema/schema.py
@@ -1180,6 +1180,7 @@ class PageIndexQueryPayload(Model):
     sort_desc: bool = Field(default=True, descritpion="Sort in descending order?")
     show_published: bool = True
     show_shared: bool = False
+    search: Optional[str] = None
     limit: int = 500
     offset: int = 0
 
@@ -3125,6 +3126,8 @@ class PageSummary(PageSummaryBase):
         title="List of revisions",
         description="The history with the encoded ID of each revision of the Page.",
     )
+    create_time: Optional[datetime] = CreateTimeField
+    update_time: Optional[datetime] = UpdateTimeField
 
 
 class PageDetails(PageSummary):
diff --git a/lib/galaxy/selenium/navigates_galaxy.py b/lib/galaxy/selenium/navigates_galaxy.py
index 6f6fd89a93fc..9b3e25db354e 100644
--- a/lib/galaxy/selenium/navigates_galaxy.py
+++ b/lib/galaxy/selenium/navigates_galaxy.py
@@ -237,7 +237,10 @@ def timeout_for(self, wait_type: WaitType = DEFAULT_WAIT_TYPE, **kwd) -> float:
     def home(self) -> None:
         """Return to root Galaxy page and wait for some basic widgets to appear."""
         self.get()
-        self.components.masthead._.wait_for_visible()
+        try:
+            self.components.masthead._.wait_for_visible()
+        except SeleniumTimeoutException as e:
+            raise ClientBuildException(e)
 
     def go_to_trs_search(self) -> None:
         self.driver.get(self.build_url("workflows/trs_search"))
@@ -1111,6 +1114,21 @@ def navigate_to_pages(self):
         self.click_masthead_user()
         self.components.masthead.pages.wait_for_and_click()
 
+    def navigate_to_published_workflows(self):
+        self.home()
+        self.click_masthead_shared_data()
+        self.components.masthead.published_workflows.wait_for_and_click()
+
+    def navigate_to_published_histories_page(self):
+        self.home()
+        self.click_masthead_shared_data()
+        self.components.masthead.published_histories.wait_for_and_click()
+
+    def navigate_to_published_pages(self):
+        self.home()
+        self.click_masthead_shared_data()
+        self.components.masthead.published_pages.wait_for_and_click()
+
     def admin_open(self):
         self.components.masthead.admin.wait_for_and_click()
 
@@ -1237,6 +1255,16 @@ def clear_tooltips(self):
         action_chains.move_to_element(center_element).perform()
         self.wait_for_selector_absent_or_hidden(".b-tooltip", wait_type=WAIT_TYPES.UX_POPUP)
 
+    def pages_index_table_elements(self):
+        pages = self.components.pages
+        pages.index_table.wait_for_visible()
+        return pages.index_rows.all()
+
+    def page_index_click_option(self, option_title, page_id):
+        self.components.pages.dropdown(id=page_id).wait_for_and_click()
+        if not self.select_dropdown_item(option_title):
+            raise AssertionError(f"Failed to find page action option with title [{option_title}]")
+
     def workflow_index_open(self):
         self.home()
         self.click_masthead_workflow()
@@ -2117,3 +2145,9 @@ def __init__(self, timeout_exception, user_info, dom_message):
         template = "Waiting for UI to reflect user logged in but it did not occur. API indicates no user is currently logged in. %s API response was [%s]. %s"
         msg = template % (dom_message, user_info, timeout_exception.msg)
         super().__init__(msg=msg, screen=timeout_exception.screen, stacktrace=timeout_exception.stacktrace)
+
+
+class ClientBuildException(SeleniumTimeoutException):
+    def __init__(self, timeout_exception: SeleniumTimeoutException):
+        msg = f"Error waiting for Galaxy masthead to appear, this frequently means there is a problem with the client build and the Galaxy client is broken. {timeout_exception.msg}"
+        super().__init__(msg=msg, screen=timeout_exception.screen, stacktrace=timeout_exception.stacktrace)
diff --git a/lib/galaxy/webapps/galaxy/api/pages.py b/lib/galaxy/webapps/galaxy/api/pages.py
index 7837b30a8489..68775c9a1040 100644
--- a/lib/galaxy/webapps/galaxy/api/pages.py
+++ b/lib/galaxy/webapps/galaxy/api/pages.py
@@ -32,7 +32,9 @@
 from galaxy.webapps.galaxy.api import (
     depends,
     DependsOnTrans,
+    IndexQueryTag,
     Router,
+    search_query_param,
 )
 from galaxy.webapps.galaxy.services.pages import PagesService
 
@@ -78,6 +80,19 @@
     title="Number of pages to skip in sorted query (to enable pagination).",
 )
 
+query_tags = [
+    IndexQueryTag("title", "The pages's title."),
+    IndexQueryTag("slug", "The pages's slug.", "s"),
+    IndexQueryTag("tag", "The pages's tags.", "t"),
+    IndexQueryTag("user", "The pages's owner's username.", "u"),
+]
+
+SearchQueryParam: Optional[str] = search_query_param(
+    model_name="Page",
+    tags=query_tags,
+    free_text_fields=["title", "slug", "tag", "user"],
+)
+
 
 @router.cbv
 class FastAPIPages:
@@ -99,6 +114,7 @@ async def index(
         sort_desc: bool = SortDescQueryParam,
         limit: int = LimitQueryParam,
         offset: int = OffsetQueryParam,
+        search: Optional[str] = SearchQueryParam,
     ) -> PageSummaryList:
         """Get a list with summary information of all Pages available to the user."""
         payload = PageIndexQueryPayload.construct(
@@ -110,6 +126,7 @@ async def index(
             sort_desc=sort_desc,
             limit=limit,
             offset=offset,
+            search=search,
         )
         return self.service.index(trans, payload)
 
diff --git a/lib/galaxy/webapps/galaxy/buildapp.py b/lib/galaxy/webapps/galaxy/buildapp.py
index 43c92c51fd8a..9f5490b606f4 100644
--- a/lib/galaxy/webapps/galaxy/buildapp.py
+++ b/lib/galaxy/webapps/galaxy/buildapp.py
@@ -233,6 +233,7 @@ def app_pair(global_conf, load_app_kwds=None, wsgi_preflight=True, **kwargs):
     webapp.add_client_route("/histories/list")
     webapp.add_client_route("/histories/import")
     webapp.add_client_route("/histories/{history_id}/export")
+    webapp.add_client_route("/histories/{history_id}/invocations")
     webapp.add_client_route("/histories/list_published")
     webapp.add_client_route("/histories/list_shared")
     webapp.add_client_route("/histories/rename")
diff --git a/lib/galaxy/webapps/galaxy/services/pages.py b/lib/galaxy/webapps/galaxy/services/pages.py
index ccffb4a4fdf0..7fd7c526bcd0 100644
--- a/lib/galaxy/webapps/galaxy/services/pages.py
+++ b/lib/galaxy/webapps/galaxy/services/pages.py
@@ -64,7 +64,7 @@ def index(self, trans, payload: PageIndexQueryPayload) -> PageSummaryList:
         :returns:   dictionaries containing summary or detailed Page information
         """
         if not trans.user_is_admin:
-            user_id = trans.user.id
+            user_id = trans.user and trans.user.id
             if payload.user_id and payload.user_id != user_id:
                 raise exceptions.AdminRequiredException("Only admins can index the pages of others")
 
diff --git a/lib/galaxy_test/api/test_pages.py b/lib/galaxy_test/api/test_pages.py
index 2df2f28bd2c9..90bbad2c6ef0 100644
--- a/lib/galaxy_test/api/test_pages.py
+++ b/lib/galaxy_test/api/test_pages.py
@@ -6,6 +6,7 @@
     Union,
 )
 from unittest import SkipTest
+from uuid import uuid4
 
 from requests import delete
 from requests.models import Response
@@ -27,8 +28,8 @@ def setUp(self):
         self.dataset_populator = DatasetPopulator(self.galaxy_interactor)
         self.workflow_populator = WorkflowPopulator(self.galaxy_interactor)
 
-    def _create_valid_page_with_slug(self, slug):
-        return self.dataset_populator.new_page(slug=slug)
+    def _create_valid_page_with_slug(self, slug, **kwd) -> Dict[str, Any]:
+        return self.dataset_populator.new_page(slug=slug, **kwd)
 
     def _create_valid_page_as(self, other_email, slug):
         run_as_user = self._setup_user(other_email)
@@ -135,8 +136,7 @@ def test_index_user_published(self):
         user_id = self.dataset_populator.user_id()
         response1 = self._create_valid_page_with_slug("indexuseridpublish1")
         with self._different_user():
-            response2 = self._create_valid_page_with_slug("indexuseridpublish2")
-            self._make_public(response2["id"])
+            response2 = self._create_published_page_with_slug("indexuseridpublish2")
 
         assert self._users_index_has_page_with_id(response1)
         assert self._users_index_has_page_with_id(response2)
@@ -145,8 +145,7 @@ def test_index_user_published(self):
 
     def test_index_show_published(self):
         with self._different_user():
-            response = self._create_valid_page_with_slug("indexshowpublish2")
-            self._make_public(response["id"])
+            response = self._create_published_page_with_slug("indexshowpublish2")
 
         assert self._users_index_has_page_with_id(response)
         assert self._users_index_has_page_with_id(response, dict(show_published=True))
@@ -155,8 +154,7 @@ def test_index_show_published(self):
     def test_index_show_shared_with_me(self):
         user_id = self.dataset_populator.user_id()
         with self._different_user():
-            response_published = self._create_valid_page_with_slug("indexshowsharedpublished")
-            self._make_public(response_published["id"])
+            response_published = self._create_published_page_with_slug("indexshowsharedpublished")
             response_shared = self._create_valid_page_with_slug("indexshowsharedshared")
             self._share_with_user(response_shared["id"], user_id)
 
@@ -169,8 +167,7 @@ def test_index_show_shared_with_me(self):
     def test_index_show_shared_with_me_deleted(self):
         user_id = self.dataset_populator.user_id()
         with self._different_user():
-            response_published = self._create_valid_page_with_slug("indexshowsharedpublisheddeleted")
-            self._make_public(response_published["id"])
+            response_published = self._create_published_page_with_slug("indexshowsharedpublisheddeleted")
             response_shared = self._create_valid_page_with_slug("indexshowsharedshareddeleted")
             self._share_with_user(response_shared["id"], user_id)
             self._delete(f"pages/{response_published['id']}").raise_for_status()
@@ -185,6 +182,37 @@ def test_index_show_shared_with_me_deleted(self):
             response_published, dict(show_shared=True, show_published=True, deleted=True)
         )
 
+    def test_index_owner(self):
+        my_workflow_id_1 = self._create_valid_page_with_slug("ownertags-m-1")
+        email_1 = f"{uuid4()}@test.com"
+        with self._different_user(email=email_1):
+            published_page_id_1 = self._create_published_page_with_slug("ownertags-p-1")["id"]
+            owner_1 = self._get("users").json()[0]["username"]
+
+        email_2 = f"{uuid4()}@test.com"
+        with self._different_user(email=email_2):
+            published_page_id_2 = self._create_published_page_with_slug("ownertags-p-2")["id"]
+
+        index_ids = self._index_ids(dict(search="is:published", show_published=True))
+        assert published_page_id_1 in index_ids
+        assert published_page_id_2 in index_ids
+        assert my_workflow_id_1 not in index_ids
+
+        index_ids = self._index_ids(dict(search=f"is:published u:{owner_1}", show_published=True))
+        assert published_page_id_1 in index_ids
+        assert published_page_id_2 not in index_ids
+        assert my_workflow_id_1 not in index_ids
+
+        index_ids = self._index_ids(dict(search=f"is:published u:'{owner_1}'", show_published=True))
+        assert published_page_id_1 in index_ids
+        assert published_page_id_2 not in index_ids
+        assert my_workflow_id_1 not in index_ids
+
+        index_ids = self._index_ids(dict(search=f"is:published {owner_1}", show_published=True))
+        assert published_page_id_1 in index_ids
+        assert published_page_id_2 not in index_ids
+        assert my_workflow_id_1 not in index_ids
+
     def test_index_ordering(self):
         older1 = self._create_valid_page_with_slug("indexorderingcreatedfirst")["id"]
         newer1 = self._create_valid_page_with_slug("indexorderingcreatedsecond")["id"]
@@ -207,7 +235,7 @@ def test_index_ordering(self):
         index_ids = self._index_ids(dict(sort_by="create_time"))
         assert index_ids.index(older1) > index_ids.index(newer1)
 
-    def test_limit_offset(self):
+    def test_index_limit_offset(self):
         older1 = self._create_valid_page_with_slug("indexlimitoffsetcreatedfirst")["id"]
         newer1 = self._create_valid_page_with_slug("indexlimitoffsetcreatedsecond")["id"]
         index_ids = self._index_ids(dict(limit=1))
@@ -218,6 +246,59 @@ def test_limit_offset(self):
         assert newer1 not in index_ids
         assert older1 in index_ids
 
+    def test_index_search_slug(self):
+        response = self._create_valid_page_with_slug("indexsearchstringfoo")
+        print(response)
+        older1 = response["id"]
+        newer1 = self._create_valid_page_with_slug("indexsearchstringbar")["id"]
+
+        index_ids = self._index_ids(dict(search="slug:indexsearchstringfoo"))
+        assert newer1 not in index_ids
+        assert older1 in index_ids
+
+        index_ids = self._index_ids(dict(search="slug:'indexsearchstringfoo'"))
+        assert newer1 not in index_ids
+        assert older1 in index_ids
+
+        index_ids = self._index_ids(dict(search="slug:foo"))
+        assert newer1 not in index_ids
+        assert older1 in index_ids
+
+        index_ids = self._index_ids(dict(search="foo"))
+        assert newer1 not in index_ids
+        assert older1 in index_ids
+
+    def test_index_search_title(self):
+        page_id = self._create_valid_page_with_slug("indexsearchbytitle", title="mycooltitle")["id"]
+        assert page_id in self._index_ids(dict(search="mycooltitle"))
+        assert page_id not in self._index_ids(dict(search="mycoolwrongtitle"))
+        assert page_id in self._index_ids(dict(search="title:mycoolti"))
+        assert page_id in self._index_ids(dict(search="title:'mycooltitle'"))
+        assert page_id not in self._index_ids(dict(search="title:'mycoolti'"))
+
+    def test_index_search_sharing_tags(self):
+        user_id = self.dataset_populator.user_id()
+        with self._different_user():
+            response_published = self._create_valid_page_with_slug("indexshowsharedpublished")["id"]
+            self._make_public(response_published)
+            response_shared = self._create_valid_page_with_slug("indexshowsharedshared")["id"]
+            self._share_with_user(response_shared, user_id)
+
+        assert response_published in self._index_ids(dict(show_published=True, show_shared=True))
+        assert response_shared in self._index_ids(dict(show_published=True, show_shared=True))
+
+        assert response_published in self._index_ids(dict(show_published=True, show_shared=True, search="is:published"))
+        assert response_shared not in self._index_ids(
+            dict(show_published=True, show_shared=True, search="is:published")
+        )
+
+        assert response_published not in self._index_ids(
+            dict(show_published=True, show_shared=True, search="is:shared_with_me")
+        )
+        assert response_shared in self._index_ids(
+            dict(show_published=True, show_shared=True, search="is:shared_with_me")
+        )
+
     def test_index_does_not_show_unavailable_pages(self):
         create_response_json = self._create_valid_page_as("others_page_index@bx.psu.edu", "otherspageindex")
         assert not self._users_index_has_page_with_id(create_response_json)
@@ -355,10 +436,13 @@ def test_400_on_download_pdf_when_unsupported_content_format(self):
         pdf_response = self._get(f"pages/{page_id}.pdf")
         self._assert_status_code_is(pdf_response, 400)
 
+    def _create_published_page_with_slug(self, slug, **kwd) -> Dict[str, Any]:
+        response = self.dataset_populator.new_page(slug=slug, **kwd)
+        self._make_public(response["id"])
+        return response
+
     def _make_public(self, page_id: str) -> dict:
-        sharing_response = self._put(f"pages/{page_id}/publish")
-        assert sharing_response.status_code == 200
-        return sharing_response.json()
+        return self.dataset_populator.make_page_public(page_id)
 
     def _share_with_user(self, page_id: str, user_id_or_email: str):
         data = {"user_ids": [user_id_or_email]}
diff --git a/lib/galaxy_test/base/populators.py b/lib/galaxy_test/base/populators.py
index 558fe6cc88a1..aa4687c238aa 100644
--- a/lib/galaxy_test/base/populators.py
+++ b/lib/galaxy_test/base/populators.py
@@ -1327,7 +1327,7 @@ def new_page(
         self, slug: str = "mypage", title: str = "MY PAGE", content_format: str = "html", content: Optional[str] = None
     ) -> Dict[str, Any]:
         page_response = self.new_page_raw(slug=slug, title=title, content_format=content_format, content=content)
-        page_response.raise_for_status()
+        api_asserts.assert_status_code_is(page_response, 200)
         return page_response.json()
 
     def new_page_raw(
@@ -1353,6 +1353,11 @@ def new_page_payload(
         )
         return request
 
+    def make_page_public(self, page_id: str) -> Dict[str, Any]:
+        sharing_response = self._put(f"pages/{page_id}/publish")
+        assert sharing_response.status_code == 200
+        return sharing_response.json()
+
 
 class GalaxyInteractorHttpMixin:
     galaxy_interactor: ApiTestInteractor
@@ -1388,6 +1393,10 @@ def _summarize_history(self, history_id):
         self.galaxy_interactor._summarize_history(history_id)
 
 
+# Things gxformat2 knows how to upload as workflows
+HasYamlT = Union[str, os.PathLike, dict]
+
+
 class BaseWorkflowPopulator(BasePopulator):
     dataset_populator: BaseDatasetPopulator
     dataset_collection_populator: "BaseDatasetCollectionPopulator"
@@ -1440,7 +1449,7 @@ def create_workflow_response(self, workflow: Dict[str, Any], **create_kwds) -> R
         upload_response = self._post("workflows/upload", data=data)
         return upload_response
 
-    def upload_yaml_workflow(self, has_yaml, **kwds) -> str:
+    def upload_yaml_workflow(self, has_yaml: HasYamlT, **kwds) -> str:
         round_trip_conversion = kwds.get("round_trip_format_conversion", False)
         client_convert = kwds.pop("client_convert", not round_trip_conversion)
         kwds["convert"] = client_convert
@@ -1713,18 +1722,18 @@ def export_for_update(self, workflow_id):
 
     def run_workflow(
         self,
-        has_workflow,
-        test_data=None,
-        history_id=None,
-        wait=True,
-        source_type=None,
+        has_workflow: HasYamlT,
+        test_data: Optional[Union[str, dict]] = None,
+        history_id: Optional[str] = None,
+        wait: bool = True,
+        source_type: Optional[str] = None,
         jobs_descriptions=None,
-        expected_response=200,
-        assert_ok=True,
-        client_convert=None,
-        round_trip_format_conversion=False,
-        invocations=1,
-        raw_yaml=False,
+        expected_response: int = 200,
+        assert_ok: bool = True,
+        client_convert: Optional[bool] = None,
+        round_trip_format_conversion: bool = False,
+        invocations: int = 1,
+        raw_yaml: bool = False,
     ):
         """High-level wrapper around workflow API, etc. to invoke format 2 workflows."""
         workflow_populator = self
@@ -1742,19 +1751,21 @@ def run_workflow(
         if test_data is None:
             if jobs_descriptions is None:
                 assert source_type != "path"
+                assert isinstance(has_workflow, str)
                 jobs_descriptions = yaml.safe_load(has_workflow)
 
-            test_data = jobs_descriptions.get("test_data", {})
-
-        if not isinstance(test_data, dict):
-            test_data = yaml.safe_load(test_data)
+            test_data_dict = jobs_descriptions.get("test_data", {})
+        elif not isinstance(test_data, dict):
+            test_data_dict = yaml.safe_load(test_data)
+        else:
+            test_data_dict = test_data
 
-        parameters = test_data.pop("step_parameters", {})
-        replacement_parameters = test_data.pop("replacement_parameters", {})
+        parameters = test_data_dict.pop("step_parameters", {})
+        replacement_parameters = test_data_dict.pop("replacement_parameters", {})
         if history_id is None:
             history_id = self.dataset_populator.new_history()
         inputs, label_map, has_uploads = load_data_dict(
-            history_id, test_data, self.dataset_populator, self.dataset_collection_populator
+            history_id, test_data_dict, self.dataset_populator, self.dataset_collection_populator
         )
         workflow_request: Dict[str, Any] = dict(
             history=f"hist_id={history_id}",
diff --git a/lib/galaxy_test/selenium/test_pages_index.py b/lib/galaxy_test/selenium/test_pages_index.py
new file mode 100644
index 000000000000..ea71fa080a18
--- /dev/null
+++ b/lib/galaxy_test/selenium/test_pages_index.py
@@ -0,0 +1,34 @@
+from .framework import (
+    retry_assertion_during_transitions,
+    selenium_test,
+    SeleniumTestCase,
+)
+
+
+class PagesTestCase(SeleniumTestCase):
+
+    ensure_registered = True
+
+    @selenium_test
+    def test_page_deletion(self):
+        page_response = self.new_page()
+        page_id = page_response["id"]
+        self.navigate_to_pages()
+        self._assert_showing_n_pages(1)
+        self.components.pages.dropdown(id=page_id).wait_for_visible()
+        self.page_index_click_option("Delete", page_id)
+        self.accept_alert()
+        self.components.pages.dropdown(id=page_id).wait_for_absent_or_hidden()
+        self._assert_showing_n_pages(0)
+
+    def new_page(self):
+        slug = self._get_random_name()
+        response = self.dataset_populator.new_page(slug=slug)
+        return response
+
+    @retry_assertion_during_transitions
+    def _assert_showing_n_pages(self, n):
+        actual_count = len(self.pages_index_table_elements())
+        if actual_count != n:
+            message = f"Expected {n} pages to be displayed, based on DOM found {actual_count} page index rows."
+            raise AssertionError(message)
diff --git a/lib/galaxy_test/selenium/test_published_histories_grid.py b/lib/galaxy_test/selenium/test_published_histories_grid.py
index ce4ec006f1c6..e94715c04948 100644
--- a/lib/galaxy_test/selenium/test_published_histories_grid.py
+++ b/lib/galaxy_test/selenium/test_published_histories_grid.py
@@ -7,7 +7,7 @@
 )
 
 
-class HistoryGridTestCase(SharedStateSeleniumTestCase):
+class PublishedHistoryGridTestCase(SharedStateSeleniumTestCase):
     @selenium_test
     def test_history_grid_histories(self):
         self.navigate_to_published_histories_page()
@@ -165,17 +165,17 @@ def setup_shared_state(self):
         tag2 = self._get_random_name(len=5)
         tag3 = self._get_random_name(len=5)
 
-        HistoryGridTestCase.user1_email = self._get_random_email("test1")
-        HistoryGridTestCase.user2_email = self._get_random_email("test2")
-        HistoryGridTestCase.history1_name = self._get_random_name()
-        HistoryGridTestCase.history2_name = self._get_random_name()
-        HistoryGridTestCase.history3_name = self._get_random_name()
-        HistoryGridTestCase.history4_name = self._get_random_name()
-        HistoryGridTestCase.history1_tags = [tag1, tag2]
-        HistoryGridTestCase.history2_tags = [tag3]
-        HistoryGridTestCase.history3_tags = [tag1]
-        HistoryGridTestCase.history3_annot = self._get_random_name()
-        HistoryGridTestCase.all_histories = [self.history1_name, self.history2_name, self.history3_name]
+        PublishedHistoryGridTestCase.user1_email = self._get_random_email("test1")
+        PublishedHistoryGridTestCase.user2_email = self._get_random_email("test2")
+        PublishedHistoryGridTestCase.history1_name = self._get_random_name()
+        PublishedHistoryGridTestCase.history2_name = self._get_random_name()
+        PublishedHistoryGridTestCase.history3_name = self._get_random_name()
+        PublishedHistoryGridTestCase.history4_name = self._get_random_name()
+        PublishedHistoryGridTestCase.history1_tags = [tag1, tag2]
+        PublishedHistoryGridTestCase.history2_tags = [tag3]
+        PublishedHistoryGridTestCase.history3_tags = [tag1]
+        PublishedHistoryGridTestCase.history3_annot = self._get_random_name()
+        PublishedHistoryGridTestCase.all_histories = [self.history1_name, self.history2_name, self.history3_name]
 
         self.register(self.user1_email)
         self.create_history(self.history1_name)
@@ -200,8 +200,3 @@ def create_history(self, name):
     def publish_current_history(self):
         self.click_history_option_sharing()
         self.make_accessible_and_publishable()
-
-    def navigate_to_published_histories_page(self):
-        self.home()
-        self.click_masthead_shared_data()
-        self.components.masthead.published_histories.wait_for_and_click()
diff --git a/lib/galaxy_test/selenium/test_published_pages.py b/lib/galaxy_test/selenium/test_published_pages.py
new file mode 100644
index 000000000000..e456ba028842
--- /dev/null
+++ b/lib/galaxy_test/selenium/test_published_pages.py
@@ -0,0 +1,31 @@
+from .framework import (
+    selenium_test,
+    SharedStateSeleniumTestCase,
+)
+
+
+class PublishedPagesGridTestCase(SharedStateSeleniumTestCase):
+    @selenium_test
+    def test_index(self):
+        self.navigate_to_published_pages()
+        self.components.pages.dropdown(id=self.page_id_1).wait_for_visible()
+
+    def setup_shared_state(self):
+        self.user1_email = self._get_random_email("test1")
+        self.user2_email = self._get_random_email("test2")
+        self.register(self.user1_email)
+        page_1 = self.new_public_page()
+        self.page_id_1 = page_1["id"]
+        self.slug_1 = page_1["slug"]
+        self.logout_if_needed()
+
+        self.register(self.user2_email)
+        page_2 = self.new_public_page()
+        self.page_id_2 = page_2["id"]
+        self.slug_2 = page_2["slug"]
+
+    def new_public_page(self):
+        slug = self._get_random_name()
+        response = self.dataset_populator.new_page(slug=slug)
+        self.dataset_populator.make_page_public(response["id"])
+        return response
diff --git a/lib/galaxy_test/selenium/test_published_workflows.py b/lib/galaxy_test/selenium/test_published_workflows.py
new file mode 100644
index 000000000000..9af0e4236bbe
--- /dev/null
+++ b/lib/galaxy_test/selenium/test_published_workflows.py
@@ -0,0 +1,39 @@
+from typing import (
+    Any,
+    Dict,
+)
+
+from .framework import (
+    selenium_test,
+    SharedStateSeleniumTestCase,
+)
+
+
+class PublishedWorkflowsGridTestCase(SharedStateSeleniumTestCase):
+    @selenium_test
+    def test_index(self):
+        self.navigate_to_published_workflows()
+        self.components.workflows.dropdown(id=self.id_1).wait_for_visible()
+
+    def setup_shared_state(self):
+        self.user1_email = self._get_random_email("test1")
+        self.user2_email = self._get_random_email("test2")
+        self.register(self.user1_email)
+        workflow_1 = self._new_public_workflow()
+        self.name_1 = workflow_1["name"]
+        self.id_1 = workflow_1["id"]
+        self.logout_if_needed()
+
+        self.register(self.user2_email)
+        workflow_2 = self._new_public_workflow()
+        self.name_2 = workflow_2["name"]
+        self.id_2 = workflow_2["id"]
+        self.logout_if_needed()
+
+    def _new_public_workflow(self) -> Dict[str, Any]:
+        name = self._get_random_name()
+        contents = self.workflow_populator.load_workflow(name)
+        workflow_response = self.workflow_populator.create_workflow_response(contents, publish=True)
+        workflow_response.raise_for_status()
+        workflow = workflow_response.json()
+        return workflow
diff --git a/test/integration_selenium/test_admin_jobs.py b/test/integration_selenium/test_admin_jobs.py
new file mode 100644
index 000000000000..d0add50c6fc5
--- /dev/null
+++ b/test/integration_selenium/test_admin_jobs.py
@@ -0,0 +1,75 @@
+import os
+
+from galaxy_test.base.populators import skip_without_tool
+from galaxy_test.base.workflow_fixtures import (
+    WORKFLOW_WITH_CUSTOM_REPORT_1,
+    WORKFLOW_WITH_CUSTOM_REPORT_1_TEST_DATA,
+)
+from galaxy_test.selenium.framework import retry_assertion_during_transitions
+from .framework import (
+    selenium_test,
+    SeleniumIntegrationTestCase,
+)
+
+SCRIPT_DIRECTORY = os.path.abspath(os.path.dirname(__file__))
+JOB_CONFIG = os.path.join(SCRIPT_DIRECTORY, "test_admin_jobs_job_conf.yml")
+
+
+class AdminDependencyContainersTestCase(SeleniumIntegrationTestCase):
+    requires_admin = True
+
+    @classmethod
+    def handle_galaxy_config_kwds(cls, config):
+        super().handle_galaxy_config_kwds(config)
+        config["job_config_file"] = JOB_CONFIG
+
+    @selenium_test
+    @skip_without_tool("cat")
+    def test_jobs_grid(self):
+        admin_component = self.components.admin
+        self.admin_login()
+        with self.dataset_populator.test_history() as history_id:
+            self.workflow_populator.run_workflow(
+                WORKFLOW_WITH_CUSTOM_REPORT_1, test_data=WORKFLOW_WITH_CUSTOM_REPORT_1_TEST_DATA, history_id=history_id
+            )
+        self.admin_open()
+        admin_component.index.jobs.wait_for_and_click()
+        self.sleep_for(self.wait_types.UX_RENDER)
+        manage_jobs = admin_component.manage_jobs
+        manage_jobs.table.wait_for_visible()
+        self.screenshot("admin_jobs_custom_configuration")
+        assert len(manage_jobs.filter_link_by_tool(tool_id="cat").all()) == 2
+        assert len(manage_jobs.filter_link_by_tool(tool_id="qc_stdout").all()) == 1
+        self.assert_displays_at_least_n_rows(3)
+
+        manage_jobs.filter_link_by_tool(tool_id="qc_stdout").wait_for_and_click()
+        assert manage_jobs.filter_query.wait_for_value() == "tool:'qc_stdout'"
+        self.assert_displays_n_rows(1)
+
+        self.clear_index_filter()
+        self.assert_displays_at_least_n_rows(3)
+
+        manage_jobs.filter_link_by_runner(runner="local_cat").wait_for_and_click()
+        self.assert_displays_n_rows(2)
+        self.clear_index_filter()
+
+    @retry_assertion_during_transitions
+    def assert_displays_at_least_n_rows(self, n):
+        admin_component = self.components.admin
+        manage_jobs = admin_component.manage_jobs
+        assert len(manage_jobs.filter_link_user.all()) >= n
+
+    @retry_assertion_during_transitions
+    def assert_displays_n_rows(self, n):
+        admin_component = self.components.admin
+        manage_jobs = admin_component.manage_jobs
+        assert len(manage_jobs.filter_link_user.all()) == n
+
+    def clear_index_filter(self):
+        admin_component = self.components.admin
+        manage_jobs = admin_component.manage_jobs
+        # clear alone doesn't fire the debounce input...
+        element = manage_jobs.filter_query.wait_for_visible()
+        element.clear()
+        element.send_keys("     ")
+        self.send_enter(element)
diff --git a/test/integration_selenium/test_admin_jobs_job_conf.yml b/test/integration_selenium/test_admin_jobs_job_conf.yml
new file mode 100644
index 000000000000..e4d0332a33b9
--- /dev/null
+++ b/test/integration_selenium/test_admin_jobs_job_conf.yml
@@ -0,0 +1,24 @@
+runners:
+  local_qc:
+    load: galaxy.jobs.runners.local:LocalJobRunner
+    workers: 1
+  local_cat:
+    load: galaxy.jobs.runners.local:LocalJobRunner
+    workers: 1
+  local_upload:
+    load: galaxy.jobs.runners.local:LocalJobRunner
+    workers: 1
+execution:
+  default: local_upload
+  environments:
+    local_qc:
+      runner: local_qc
+    local_cat:
+      runner: local_cat
+    local_upload:
+      runner: local_upload
+tools:
+  - id: cat
+    environment: local_cat
+  - id: qc_stdout
+    environment: local_qc