diff --git a/components/CoreInput.vue b/components/CoreInput.vue
index aebe23cb..1177089c 100644
--- a/components/CoreInput.vue
+++ b/components/CoreInput.vue
@@ -121,10 +121,14 @@ onMounted(() => {
             :id="id"
             ref="inputRef"
             v-model="modelProxy"
+            aria-autocomplete="none"
+            autocomplete="off"
+            name="text"
             :placeholder="placeholder"
             :rows="lines"
             :spellcheck="false"
             :style="{ height }"
+            type="text"
             :value="modelProxy"
             class="unset-all cursor-text block min-h-0 overflow-hidden resize-none placeholder-current"
             :class="{ 'whitespace-nowrap': !multiline }"
diff --git a/components/Doc.vue b/components/Doc.vue
index 311b8573..6f086e98 100644
--- a/components/Doc.vue
+++ b/components/Doc.vue
@@ -1,4 +1,4 @@
-<script>
+<script lang="ts">
 import moment from 'moment'
 import CoreDivider from '#root/components/CoreDivider.vue'
 import { DISCARD_DOCUMENT, RESTORE_DOCUMENT } from '#root/src/store/actions'
@@ -8,10 +8,16 @@ export default {
     CoreDivider,
   },
   props: {
+    text: {
+      required: true,
+      type: String,
+    },
     id: String,
-    text: String,
     updatedAt: Date,
-    discardedAt: Date,
+    discardedAt: {
+      required: false,
+      type: Date as PropType<Date | null>,
+    },
     allowDiscard: Boolean,
   },
   setup(props) {
diff --git a/components/DocList.vue b/components/DocList.vue
index fc3f63c7..66d855bf 100644
--- a/components/DocList.vue
+++ b/components/DocList.vue
@@ -2,8 +2,6 @@
 import { MERGE_DOCUMENTS } from '#root/src/store/actions'
 import { type Doc } from '~/src/models/doc'
 
-const REGEX_QUERY = /^\/(?<regex>.+)\/(?<flags>[a-z]*)$/s
-
 export default defineComponent({
   props: {
     cols: {
@@ -15,23 +13,44 @@ export default defineComponent({
     tag: String,
   },
   emits: ['update:query'],
-  setup() {
+  setup(props) {
+    const { query } = toRefs(props)
+
+    const isEditing = ref(false)
+    const searchQuery = ref(query.value || '')
     const searchElement = ref<HTMLElement>()
+    const selectedDocs = ref<Doc[]>([])
+    const visibleCount = ref(25)
+    const filter = computed(() => props.tag ? `#${props.tag}` : props.filter)
+
+    const { docs } = useDocs({ filter })
+    const { searchResults } = useSearch(docs, { keys: ['text'], searchQuery })
+
+    const finalDocs = computed(() => {
+      return searchResults.value.map((doc: Doc) => ({
+        ...doc,
+        selected: selectedDocs.value.includes(doc),
+      }))
+    })
+
+    const visibleDocs = computed(() => {
+      return finalDocs.value.slice(0, visibleCount.value)
+    })
 
     onMounted(() => {
       searchElement.value?.focus()
     })
 
     return {
+      docs,
+      searchResults,
+      finalDocs,
+      isEditing,
+      searchQuery,
       searchElement,
-    }
-  },
-  data() {
-    return {
-      isEditing: false,
-      q: this.query ?? '',
-      selectedDocs: [] as Doc[],
-      visibleCount: 25,
+      selectedDocs,
+      visibleCount,
+      visibleDocs,
     }
   },
   computed: {
@@ -41,56 +60,12 @@ export default defineComponent({
     canMerge() {
       return this.selectedDocs.length > 1
     },
-    docs(): Doc[] {
-      if (this.tag) {
-        return this.$store.getters.withTag(this.tag)
-      }
-
-      if (this.filter === 'tasks') {
-        return this.$store.getters.tasks
-      }
-
-      if (this.filter === 'discarded') {
-        return this.$store.getters.discarded
-      }
-
-      if (this.filter === 'untagged') {
-        return this.$store.getters.untagged
-      }
-
-      return this.$store.getters.kept
-    },
-    filteredDocs() {
-      return this.docs.filter((doc: Doc) => {
-        if (!this.q) {
-          return true
-        }
-
-        try {
-          // @ts-expect-error Todo: Refactor this.
-          const { groups: { flags, regex } } = REGEX_QUERY.exec(this.q)
-
-          return (new RegExp(regex, flags)).test(doc.text)
-        } catch (_error) {
-          return doc.text.toLowerCase().includes(this.q.toLowerCase())
-        }
-      })
-    },
-    finalDocs() {
-      return this.filteredDocs.map((doc: Doc) => ({
-        ...doc,
-        selected: this.selectedDocs.includes(doc),
-      }))
-    },
     showLoadMore() {
       return this.visibleCount <= this.finalDocs.length
     },
-    visibleDocs() {
-      return this.finalDocs.slice(0, this.visibleCount)
-    },
   },
   watch: {
-    q(value) {
+    searchQuery(value) {
       this.$emit('update:query', value)
     },
   },
@@ -115,7 +90,7 @@ export default defineComponent({
         if (this.selectedDocs.find(doc => doc.id === id)) {
           this.selectedDocs = this.selectedDocs.filter(doc => doc.id !== id)
         } else {
-          const foundDoc = this.filteredDocs.find(doc => doc.id === id)
+          const foundDoc = this.searchResults.find(doc => doc.id === id)
 
           if (foundDoc) {
             this.selectedDocs.push(foundDoc)
@@ -150,17 +125,24 @@ export default defineComponent({
     </div>
     <div class="mb-4">
       <CoreInput
-        v-model="q"
+        v-model="searchQuery"
         autocomplete="off"
         autofocus
         label="Search"
-        description="Search with /regex/i or plain text..."
-        placeholder="Search with /regex/i or plain text..."
+        description="Supports /regex/i and fuzzy-matching."
+        placeholder="Start typing to filter results..."
       />
     </div>
     <div class="grid gap-4 grid-cols-1" :class="cols === 2 && 'lg:grid-cols-2'">
-      <div v-for="doc in visibleDocs" :key="doc.id" tabindex="0" class="rounded relative cursor-pointer outline-none focus:ring" @keypress.enter.prevent="selectDoc(doc.id)" @click="selectDoc(doc.id)">
-        <Doc v-bind="doc" :allow-discard="isEditing" class="h-96" />
+      <div
+        v-for="doc in visibleDocs"
+        :key="doc.id"
+        tabindex="0"
+        class="rounded relative cursor-pointer outline-none focus:ring"
+        @keypress.enter.prevent="selectDoc(doc.id)"
+        @click="selectDoc(doc.id)"
+      >
+        <LazyDoc v-bind="doc" :allow-discard="isEditing" class="h-96" />
         <div v-if="doc.selected" class="flex items-center justify-center rounded absolute inset-0 bg-layer bg-opacity-50">
           <svg height="3em" width="3em" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor">
             <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z" />
diff --git a/composables/useDocs.ts b/composables/useDocs.ts
index c2dee47f..65191e7e 100644
--- a/composables/useDocs.ts
+++ b/composables/useDocs.ts
@@ -1,14 +1,101 @@
 import { useStore } from 'vuex'
-import type Doc from '#root/src/models/doc'
+import { type Doc } from '#root/src/models/doc'
 
-export const useDocs = () => {
+const filterByDiscarded = (docs: MaybeRef<Doc[]>) => {
+  return toValue(docs).filter((doc) => {
+    return !!doc.discardedAt
+  })
+}
+
+const filterByKept = (docs: MaybeRef<Doc[]>) => {
+  return toValue(docs).filter((doc) => {
+    return !doc.discardedAt
+  })
+}
+
+const filterByTag = (docs: MaybeRef<Doc[]>, tag: string) => {
+  return filterByTags(docs, [tag])
+}
+
+const filterByTags = (docs: MaybeRef<Doc[]>, tags: string[]) => {
+  return toValue(docs).filter((doc) => {
+    return tags.some((tag) => doc.tags.includes(tag))
+  })
+}
+
+const filterByTasks = (docs: MaybeRef<Doc[]>) => {
+  return toValue(docs).filter((doc) => {
+    return doc.tasks.length > 0
+  })
+}
+
+const filterByUntagged = (docs: MaybeRef<Doc[]>) => {
+  return toValue(docs).filter((doc) => {
+    return doc.tags.length === 0
+  })
+}
+
+const filterByWorkspace = (docs: MaybeRef<Doc[]>, workspace: { active: boolean, tags: string[] }) => {
+  if (!workspace.active) {
+    return toValue(docs)
+  }
+
+  return filterByTags(docs, workspace.tags)
+}
+
+const sortByRecent = (docs: MaybeRef<Doc[]>) => {
+  return toValue(docs).sort((a, b) => {
+    // Reverse chronological order.
+    return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+  })
+}
+
+export const useDocs = ({ filter }: { filter?: MaybeRef<string | undefined> } = {}) => {
   const store = useStore()
   const router = useRouter()
-  const docs = computed(() => store.getters.decrypted)
-  const doc = computed(() => docs.value.find((doc: Doc) => doc.id === router.currentRoute.value.params.docId))
+  const allDocs = computed<Doc[]>(() => store.state.documents.all)
+  const decryptedDocs = computed(() => allDocs.value.filter(doc => !doc.encrypted))
+  const sortedDocs = computed(() => sortByRecent(decryptedDocs))
+  const workspaceDocs = computed(() => filterByWorkspace(sortedDocs, store.state.context))
+  const keptDocs = computed(() => filterByKept(workspaceDocs))
+  const discardedDocs = computed(() => filterByDiscarded(workspaceDocs.value))
+  const taskDocs = computed(() => filterByTasks(keptDocs))
+  const untaggedDocs = computed(() => filterByUntagged(keptDocs))
+
+  const docs = computed(() => {
+    const filterValue = toValue(filter)
+
+    if (filterValue?.startsWith('#')) {
+      return filterByTag(keptDocs, filterValue.slice(1))
+    }
+
+    if (filterValue === 'tasks') {
+      return taskDocs.value
+    }
+
+    if (filterValue === 'discarded') {
+      return discardedDocs.value
+    }
+
+    if (filterValue === 'untagged') {
+      return untaggedDocs.value
+    }
+
+    return keptDocs.value
+  })
+
+  const doc = computed(() => decryptedDocs.value.find((doc: Doc) => doc.id === router.currentRoute.value.params.docId))
 
   return {
+    allDocs,
+    decryptedDocs,
     doc,
     docs,
+    filterByTag,
+    filterByTasks,
+    filterByUntagged,
+    keptDocs,
+    sortedDocs,
+    workspaceDocs,
   }
 }
diff --git a/composables/useRouteQuery.ts b/composables/useRouteQuery.ts
index 36365ba5..63798200 100644
--- a/composables/useRouteQuery.ts
+++ b/composables/useRouteQuery.ts
@@ -2,23 +2,22 @@ import { isClient } from '#helpers/environment'
 
 export const useRouteQuery = () => {
   const router = useRouter()
-  const query = computed({
-    get: () => router.currentRoute.value.query.q as string,
-    set: (value: string) => {
-      const resolved = router.resolve({
-        ...router.currentRoute.value,
-        query: {
-          ...router.currentRoute.value.query,
-          q: value,
-        },
-      })
+  const query = ref(router.currentRoute.value.query.q as string || '')
 
-      if (isClient) {
-        // This will replace the browser history's current state with the new query.
-        // This is necessary to prevent the entire component from reloading (the behavior of router.replace).
-        window.history.replaceState(window.history.state, '', resolved.fullPath)
-      }
-    },
+  watch(query, () => {
+    const resolved = router.resolve({
+      ...router.currentRoute.value,
+      query: {
+        ...router.currentRoute.value.query,
+        q: query.value,
+      },
+    })
+
+    if (isClient) {
+      // This will replace the browser history's current state with the new query.
+      // This is necessary to prevent the entire component from reloading (the behavior of router.replace).
+      window.history.replaceState(window.history.state, '', resolved.fullPath)
+    }
   })
 
   return {
diff --git a/composables/useSearch.ts b/composables/useSearch.ts
index 34a15f83..aac0d177 100644
--- a/composables/useSearch.ts
+++ b/composables/useSearch.ts
@@ -1,5 +1,8 @@
+import { debouncedRef } from '@vueuse/core'
 import Fuse from 'fuse.js'
 
+const regexSearchShape = /^\/(?<regex>.+)\/(?<flags>[a-z]*)$/s
+
 const sortByScore = <T extends { score?: number }>(list: T[]) => {
   return list.sort((a, b) => {
     return (a.score ?? 1) - (b.score ?? 1)
@@ -10,10 +13,49 @@ const fuzzy = <T>(list: Ref<T[]>, keys: string[]) => {
   return new Fuse(list.value, { includeScore: true, keys })
 }
 
-export const useSearch = <T>(list: Ref<T[]>, { keys }: { keys: string[] }) => {
+export const useSearch = <T extends Record<string, any>>(list: Ref<T[]>, { keys, searchQuery = ref('') }: { keys: string[], searchQuery?: Ref<string> }) => {
   const filterer = computed(() => fuzzy(list, keys))
-  const searchQuery = ref('')
-  const searchResults = computed(() => sortByScore(filterer.value.search(searchQuery.value)))
+  const searchQueryDebounced = debouncedRef(searchQuery, 50)
+  const searchResults = computed(() => {
+    // 1. If there is no search query, return the entire list.
+    if (!searchQueryDebounced.value) {
+      return list.value
+    }
+
+    // 2. If the search query is a regex, attempt to regex-match entries in the list.
+    if (regexSearchShape.test(searchQueryDebounced.value)) {
+      try {
+        // @ts-expect-error Throwing an error is fine, because we handle it below.
+        const { groups: { flags, regex } } = regexSearchShape.exec(searchQueryDebounced.value)
+        const searchRegex = new RegExp(regex, flags)
+
+        return list.value.filter((item) => {
+          return keys.some((key) => {
+            return searchRegex.test(item[key])
+          })
+        })
+      } catch (error) {
+        console.error(error)
+      }
+    }
+
+    // 3. If the search query is not a regex, attempt to fuzzy-find entries in the list.
+    try {
+      const fuzzyResults = filterer.value.search(searchQueryDebounced.value)
+      const sortedFuzzyResults = sortByScore(fuzzyResults)
+
+      return sortedFuzzyResults.map((result) => result.item)
+    } catch (error) {
+      console.error(error)
+    }
+
+    // 4. If all else fails, do a case-insensitive full-text match.
+    return list.value.filter((item) => {
+      return keys.some((key) => {
+        return item[key].toLowerCase().includes(searchQueryDebounced.value.toLowerCase())
+      })
+    })
+  })
 
   return {
     searchQuery,
diff --git a/layouts/dashboard.vue b/layouts/dashboard.vue
index e958abfa..670511fe 100644
--- a/layouts/dashboard.vue
+++ b/layouts/dashboard.vue
@@ -1,7 +1,7 @@
 <script lang="ts">
 import { ViewColumnsIcon } from '@heroicons/vue/24/outline'
 import { CalendarIcon, Cog8ToothIcon, DocumentPlusIcon, HeartIcon, UserCircleIcon, XMarkIcon } from '@heroicons/vue/24/solid'
-import { computed, defineComponent, onBeforeUnmount, onMounted } from 'vue'
+import { computed, defineComponent, onMounted, onUnmounted } from 'vue'
 import DiscordIcon from '#root/assets/discord.svg?component'
 import GraphIcon from '#root/assets/graph.svg?component'
 import LogoIcon from '#root/assets/logo-icon.svg?component'
@@ -84,7 +84,7 @@ export default defineComponent({
       window.addEventListener('scroll', scrollListener)
     })
 
-    onBeforeUnmount(() => {
+    onUnmounted(() => {
       window.removeEventListener('scroll', scrollListener)
     })
 
diff --git a/pages/assistant/conversations/index.vue b/pages/assistant/conversations/index.vue
index becc7a61..06bfba09 100644
--- a/pages/assistant/conversations/index.vue
+++ b/pages/assistant/conversations/index.vue
@@ -8,7 +8,7 @@ export default defineComponent({
     const { db } = useDatabase()
     const { result: chatMessages } = useQuery(() => db.chatMessages.toArray(), [])
     const { searchQuery, searchResults } = useSearch(chatMessages, { keys: ['text'] })
-    const chatIdResults = computed(() => searchResults.value.map((result) => result.item.chatId))
+    const chatIdResults = computed(() => searchResults.value.map((result) => result.chatId))
     const chatIds = computed(() => Array.from(new Set(chatIdResults.value)))
     const filteredChats = computed(() => {
       // Todo: There are sometimes undefined values. This might be due to leftover messages that point to deleted chats.
@@ -34,9 +34,9 @@ export default defineComponent({
     <div class="flex flex-col flex-grow gap-8 m-auto max-w-prose p-2 w-full">
       <CoreInput
         v-model="searchQuery"
-        description="All searches use client-side fuzzy matching."
+        description="Supports /regex/i and fuzzy-matching."
         label="Search"
-        placeholder="Search your chat history on this device..."
+        placeholder="Start typing to filter results..."
       />
       <CoreLayer class="flex gap-2 items-center justify-end">
         <CoreButtonLink :counter="true" :to="{ path: '/assistant' }" class="flex gap-2 items-center">
diff --git a/pages/docs/[docId]/meta.vue b/pages/docs/[docId]/meta.vue
index bce58c96..8a13ad1a 100644
--- a/pages/docs/[docId]/meta.vue
+++ b/pages/docs/[docId]/meta.vue
@@ -80,16 +80,16 @@ export default {
       return 'Not yet updated'
     },
   },
-  async beforeUnmount() {
-    clearInterval(this.ticker)
-  },
-  async mounted() {
+  mounted() {
     this.mounted = true
 
     this.ticker = setInterval(() => {
       this.now = moment()
     }, 5000)
   },
+  unmounted() {
+    clearInterval(this.ticker)
+  },
   methods: {
     async copyPublicUrl() {
       // copy link to clipboard
diff --git a/pages/force-graph.vue b/pages/force-graph.vue
index 2ecd7411..6faabc8f 100644
--- a/pages/force-graph.vue
+++ b/pages/force-graph.vue
@@ -1,6 +1,5 @@
 <script lang="ts">
 import type { ForceGraphInstance } from 'force-graph'
-import type Doc from '#root/src/models/doc'
 import DocList from '#root/components/DocList.vue'
 
 type GraphConnection = {
@@ -27,7 +26,6 @@ export default {
     DocList,
   },
   setup() {
-    const { store } = useVuex()
     const instance = ref<ForceGraphInstance>()
     const tag = ref()
     const graphElement = ref<HTMLElement>()
@@ -38,7 +36,7 @@ export default {
     const maxNodeSize = computed(() => {
       return Math.max(...nodes.value.map(node => node.size))
     })
-    const docs = computed<Doc[]>(() => store.getters.kept)
+    const { keptDocs: docs } = useDocs()
     const colors = computed(() => {
       const textValue = rootStyles.value?.getPropertyValue('--layer-3-text') || '212 212 216'
       const lineValue = rootStyles.value?.getPropertyValue('--layer-3-bg') || '39 39 42'
@@ -137,10 +135,6 @@ export default {
       }
     }
 
-    onBeforeUnmount(() => {
-      window.removeEventListener('resize', resize)
-    })
-
     onMounted(async () => {
       const { default: ForceGraph } = await import('force-graph')
 
@@ -197,6 +191,10 @@ export default {
       rootStyles.value = window.getComputedStyle(document.documentElement)
     })
 
+    onUnmounted(() => {
+      window.removeEventListener('resize', resize)
+    })
+
     useHead({
       title: 'Force Graph',
     })
diff --git a/src/store.js b/src/store.js
index cde2f10c..f87c7c38 100644
--- a/src/store.js
+++ b/src/store.js
@@ -16,8 +16,6 @@ import keybindingsPlugin from '#root/src/store/plugins/keybindings'
 import settingsCachingPlugin from '#root/src/store/plugins/caching/settings'
 import syncPlugin from '#root/src/store/plugins/sync'
 
-export const SET_STRIPE_MODAL_VISIBILITY = 'SET_STRIPE_MODAL_VISIBILITY'
-
 import {
   ACTIVATE_CONTEXT,
   BLUR_EDITOR,
@@ -31,6 +29,8 @@ import {
   SET_SHOW_WELCOME,
 } from '#root/src/store/actions'
 
+export const SET_STRIPE_MODAL_VISIBILITY = 'SET_STRIPE_MODAL_VISIBILITY'
+
 export const store = createStore({
   state() {
     return {
@@ -51,12 +51,12 @@ export const store = createStore({
     allTags(state, getters) {
       return Array.from(
         getters.allKept.reduce((set, doc) => {
-          for (let tag of doc.tags) {
+          for (const tag of doc.tags) {
             set.add(tag)
           }
 
           return set
-        }, new Set())
+        }, new Set()),
       ).sort()
     },
     contextTags(state) {
@@ -65,42 +65,42 @@ export const store = createStore({
     tags(state, getters) {
       return Array.from(
         getters.kept.reduce((set, doc) => {
-          for (let tag of doc.tags) {
+          for (const tag of doc.tags) {
             set.add(tag)
           }
 
           return set
-        }, new Set())
+        }, new Set()),
       ).sort()
     },
   },
   mutations: {
-    [ACTIVATE_CONTEXT] (state, payload) {
+    [ACTIVATE_CONTEXT](state, _payload) {
       state.context.active = true
     },
-    [DEACTIVATE_CONTEXT] (state, payload) {
+    [DEACTIVATE_CONTEXT](state, _payload) {
       state.context.active = false
       state.context.tags = []
     },
-    [SET_CONTEXT_TAGS] (state, payload) {
+    [SET_CONTEXT_TAGS](state, payload) {
       state.context.tags = payload.context.tags
     },
-    [SET_EDITOR] (state, payload) {
+    [SET_EDITOR](state, payload) {
       state.editor = payload.editor
     },
-    [SET_OFFLINE] (state) {
+    [SET_OFFLINE](state) {
       state.online = false
     },
-    [SET_ONLINE] (state) {
+    [SET_ONLINE](state) {
       state.online = true
     },
-    [SET_RIGHT_SIDEBAR_VISIBILITY] (state, isVisible) {
+    [SET_RIGHT_SIDEBAR_VISIBILITY](state, isVisible) {
       state.showRightSidebar = isVisible
     },
-    [SET_STRIPE_MODAL_VISIBILITY] (state, isVisible) {
+    [SET_STRIPE_MODAL_VISIBILITY](state, isVisible) {
       state.showStripeModal = isVisible
     },
-    [SET_SHOW_WELCOME] (state, shouldShowWelcome) {
+    [SET_SHOW_WELCOME](state, shouldShowWelcome) {
       if (!shouldShowWelcome) {
         if (isClient) {
           window.localStorage.setItem('octo/welcome/v1', 'done')
@@ -111,23 +111,23 @@ export const store = createStore({
     },
   },
   actions: {
-    async [ACTIVATE_CONTEXT] (context) {
+    async [ACTIVATE_CONTEXT](context) {
       context.commit(ACTIVATE_CONTEXT)
     },
-    async [BLUR_EDITOR] (context) {
+    async [BLUR_EDITOR](context) {
       if (context.state.editor) {
         context.state.editor.getInputField().blur()
       }
     },
-    async [DEACTIVATE_CONTEXT] (context) {
+    async [DEACTIVATE_CONTEXT](context) {
       context.commit(DEACTIVATE_CONTEXT)
     },
-    async [FOCUS_EDITOR] (context) {
+    async [FOCUS_EDITOR](context) {
       if (context.state.editor) {
         context.state.editor.focus()
       }
     },
-    async [SET_CONTEXT_TAGS] (context, payload) {
+    async [SET_CONTEXT_TAGS](context, payload) {
       context.commit(SET_CONTEXT_TAGS, payload)
 
       // automatically activate and deactivate context when modifying context tags
@@ -141,22 +141,22 @@ export const store = createStore({
         }
       }
     },
-    async [SET_EDITOR] (context, payload) {
+    async [SET_EDITOR](context, payload) {
       context.commit(SET_EDITOR, payload)
     },
-    async [SET_OFFLINE] (context) {
+    async [SET_OFFLINE](context) {
       context.commit(SET_OFFLINE)
     },
-    async [SET_ONLINE] (context) {
+    async [SET_ONLINE](context) {
       context.commit(SET_ONLINE)
     },
-    async [SET_RIGHT_SIDEBAR_VISIBILITY] (context, isVisible) {
+    async [SET_RIGHT_SIDEBAR_VISIBILITY](context, isVisible) {
       context.commit(SET_RIGHT_SIDEBAR_VISIBILITY, isVisible)
     },
-    async [SET_SHOW_WELCOME] (context, shouldShowWelcome) {
+    async [SET_SHOW_WELCOME](context, shouldShowWelcome) {
       context.commit(SET_SHOW_WELCOME, shouldShowWelcome)
     },
-    async [SET_STRIPE_MODAL_VISIBILITY] (context, isVisible) {
+    async [SET_STRIPE_MODAL_VISIBILITY](context, isVisible) {
       context.commit(SET_STRIPE_MODAL_VISIBILITY, isVisible)
 
       if (isVisible) {
diff --git a/src/store/modules/documents.js b/src/store/modules/documents.js
index b9470cfe..9c217613 100644
--- a/src/store/modules/documents.js
+++ b/src/store/modules/documents.js
@@ -3,8 +3,8 @@ import { useRecentDocs } from '#root/src/stores/useRecentDocs'
 
 import {
   DISCARD_DOCUMENT,
-  DUPLICATE_DOCUMENT,
   DOCUMENTS_LOADED,
+  DUPLICATE_DOCUMENT,
   EDIT_DOCUMENT,
   LOAD_DOCUMENT,
   LOAD_DOCUMENTS,
@@ -38,10 +38,7 @@ export default {
     decrypted(state) {
       return state.all.filter(doc => !doc.encrypted)
     },
-    discarded(_state, getters) {
-      return getters.sorted.filter(doc => doc.discardedAt !== null)
-    },
-    filtered(state, getters, globalState) {
+    filtered(_state, getters, globalState) {
       if (globalState.context.active) {
         return getters.sorted.filter((doc) => {
           return globalState.context.tags.some(t => doc.tags.includes(t))
@@ -65,26 +62,15 @@ export default {
         return b.createdAt - a.createdAt
       })
     },
-    tasks(_state, getters, _globalState, _globalGetters) {
-      return getters.kept.filter(doc => doc.tasks.length > 0)
-    },
-    untagged(_state, getters) {
-      return getters.allKept.filter(doc => doc.tags.length == 0)
-    },
-    withTag(_state, getters) {
-      return (tag) => {
-        return getters.kept.filter(doc => !!doc.tags.find(t => t === tag))
-      }
-    },
   },
   mutations: {
-    [DISCARD_DOCUMENT] (state, { id }) {
+    [DISCARD_DOCUMENT](state, { id }) {
       findDoc(state, id).discard()
     },
-    [DOCUMENTS_LOADED] (state) {
+    [DOCUMENTS_LOADED](state) {
       state.loaded = true
     },
-    [EDIT_DOCUMENT] (state, doc) {
+    [EDIT_DOCUMENT](state, doc) {
       const found = findDoc(state, doc.id)
 
       if (found) {
@@ -92,21 +78,20 @@ export default {
       } else {
         state.all.push(doc)
       }
-
     },
-    [LOAD_DOCUMENT] (state, doc) {
+    [LOAD_DOCUMENT](state, doc) {
       state.all.push(doc)
     },
-    [MERGE_DOCUMENT] (state, doc) {
-      findDoc(state, doc.id).merge(doc);
+    [MERGE_DOCUMENT](state, doc) {
+      findDoc(state, doc.id).merge(doc)
     },
-    [RESTORE_DOCUMENT] (state, { id }) {
+    [RESTORE_DOCUMENT](state, { id }) {
       findDoc(state, id).restore()
     },
-    [RESTRICT_DOCUMENT] (state, { id }) {
-      findDoc(state, id).restrict();
+    [RESTRICT_DOCUMENT](state, { id }) {
+      findDoc(state, id).restrict()
     },
-    [SET_DOCUMENT] (state, { id }) {
+    [SET_DOCUMENT](state, { id }) {
       state.currentId = id
 
       if (id) {
@@ -115,64 +100,64 @@ export default {
         recentDocs.add(id)
       }
     },
-    [SHARE_DOCUMENT] (state, { id }) {
-      findDoc(state, id).share();
+    [SHARE_DOCUMENT](state, { id }) {
+      findDoc(state, id).share()
     },
-    [TOUCH_DOCUMENT] (state, { id }) {
+    [TOUCH_DOCUMENT](state, { id }) {
       findDoc(state, id).touch()
     },
   },
   actions: {
-    async [DISCARD_DOCUMENT] (context, doc) {
+    async [DISCARD_DOCUMENT](context, doc) {
       context.commit(DISCARD_DOCUMENT, doc)
     },
-    async [DOCUMENTS_LOADED] (context) {
+    async [DOCUMENTS_LOADED](context) {
       context.commit(DOCUMENTS_LOADED)
     },
-    async [DUPLICATE_DOCUMENT] (context, { id }) {
+    async [DUPLICATE_DOCUMENT](context, { id }) {
       const newDoc = findDoc(context.state, id).duplicate()
 
       context.commit(EDIT_DOCUMENT, newDoc)
 
       return newDoc.id
     },
-    async [EDIT_DOCUMENT] (context, doc) {
+    async [EDIT_DOCUMENT](context, doc) {
       context.commit(EDIT_DOCUMENT, doc)
     },
-    async [LOAD_DOCUMENT] (context, doc) {
+    async [LOAD_DOCUMENT](context, doc) {
       context.commit(LOAD_DOCUMENT, doc)
     },
-    async [LOAD_DOCUMENTS] (context, docs) {
+    async [LOAD_DOCUMENTS](context, docs) {
       return Promise.all(
-        docs.map(doc => context.dispatch(LOAD_DOCUMENT, doc))
+        docs.map(doc => context.dispatch(LOAD_DOCUMENT, doc)),
       )
     },
-    async [MERGE_DOCUMENT] (context, doc) {
-      context.commit(MERGE_DOCUMENT, doc);
+    async [MERGE_DOCUMENT](context, doc) {
+      context.commit(MERGE_DOCUMENT, doc)
     },
-    async [MERGE_DOCUMENTS] (context, docs) {
+    async [MERGE_DOCUMENTS](context, docs) {
       const originalDocs = docs.map(doc => findDoc(context.state, doc.id))
       const newDoc = new Doc({
-        text: originalDocs.map(doc => doc.text).join("\n\n"),
+        text: originalDocs.map(doc => doc.text).join('\n\n'),
       })
 
       context.commit(EDIT_DOCUMENT, newDoc)
 
       return originalDocs.map((doc) => context.dispatch(DISCARD_DOCUMENT, doc))
     },
-    async [RESTORE_DOCUMENT] (context, doc) {
+    async [RESTORE_DOCUMENT](context, doc) {
       context.commit(RESTORE_DOCUMENT, doc)
     },
-    async [RESTRICT_DOCUMENT] (context, doc) {
-      context.commit(RESTRICT_DOCUMENT, doc);
+    async [RESTRICT_DOCUMENT](context, doc) {
+      context.commit(RESTRICT_DOCUMENT, doc)
     },
-    async [SET_DOCUMENT] (context, { id }) {
+    async [SET_DOCUMENT](context, { id }) {
       context.commit(SET_DOCUMENT, { id })
     },
-    async [SHARE_DOCUMENT] (context, doc) {
-      context.commit(SHARE_DOCUMENT, doc);
+    async [SHARE_DOCUMENT](context, doc) {
+      context.commit(SHARE_DOCUMENT, doc)
     },
-    async [TOUCH_DOCUMENT] (context, doc) {
+    async [TOUCH_DOCUMENT](context, doc) {
       context.commit(TOUCH_DOCUMENT, doc)
     },
   },