From 048d64b5c8c23b7c0dfcc7369571264c077d9f4c Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Mon, 7 Sep 2026 07:32:18 +0100
Subject: [PATCH 01/16] Add visual JMAP Sieve mail rules

Adds the managed rule model, browser editor, RFC 9661 persistence path, and test coverage. Existing external scripts remain preserved unless the user explicitly confirms activation.
---
 specs/004-mail-rules/spec.md                  |  44 +
 src/App.vue                                   |  11 +-
 src/components/AccountAvatarMenu.vue          |  14 +-
 src/components/MailRulesDialog.vue            | 906 ++++++++++++++++++
 src/constants/states.ts                       |   1 +
 src/db/protocol.ts                            |   1 +
 src/db/repository.ts                          |   4 +
 src/sieve/rules.ts                            | 469 +++++++++
 src/stores/rules-store.ts                     | 171 ++++
 src/sync/backends/jmap/backend.ts             | Bin 90915 -> 90059 bytes
 src/sync/backends/jmap/outbox/index.ts        |  19 +-
 src/sync/backends/jmap/sieve.ts               | 345 +++++++
 src/sync/backends/jmap/transport.ts           |   2 +
 src/sync/sync-host.ts                         |   6 +
 tests/e2e/mail-rules.spec.js                  | 155 +++
 tests/unit/components/app-layout.test.ts      |   4 +
 .../unit/components/mail-rules-dialog.test.ts | 159 +++
 tests/unit/sieve/rules.test.ts                | 175 ++++
 tests/unit/stores/rules-store.test.ts         | 148 +++
 tests/unit/sync/_mock-transport.ts            |  24 +
 tests/unit/sync/jmap-outbox-sieve.test.ts     |  90 ++
 tests/unit/sync/jmap-sieve.test.ts            | 242 +++++
 22 files changed, 2986 insertions(+), 4 deletions(-)
 create mode 100644 specs/004-mail-rules/spec.md
 create mode 100644 src/components/MailRulesDialog.vue
 create mode 100644 src/sieve/rules.ts
 create mode 100644 src/stores/rules-store.ts
 create mode 100644 src/sync/backends/jmap/sieve.ts
 create mode 100644 tests/e2e/mail-rules.spec.js
 create mode 100644 tests/unit/components/mail-rules-dialog.test.ts
 create mode 100644 tests/unit/sieve/rules.test.ts
 create mode 100644 tests/unit/stores/rules-store.test.ts
 create mode 100644 tests/unit/sync/jmap-outbox-sieve.test.ts
 create mode 100644 tests/unit/sync/jmap-sieve.test.ts

diff --git a/specs/004-mail-rules/spec.md b/specs/004-mail-rules/spec.md
new file mode 100644
index 00000000..ab336af0
--- /dev/null
+++ b/specs/004-mail-rules/spec.md
@@ -0,0 +1,44 @@
+# Visual server-side mail rules
+
+**Status**: Prototype proposed upstream
+**Proposal**: https://ideas.tb.pro/p/visual-server-side-mail-rules-using-jmap-sieve
+
+## Goal
+
+Stormbox shall let a signed-in user build ordered mail rules visually and run them on the mail server through JMAP for Sieve (RFC 9661). The feature remains fully browser-owned and does not add a Stormbox application backend.
+
+## Requirements
+
+| ID | Requirement |
+|---|---|
+| MR-1 | When the account advertises `urn:ietf:params:jmap:sieve`, the account menu shall offer a Mail Rules editor. When the capability is absent, the editor shall explain that server-side rules are unavailable. |
+| MR-2 | The editor shall support ordered, enabled/disabled rules; all/any condition matching; From, To, To/Cc, Subject, and custom-header conditions; and exact, contains, or wildcard matching. |
+| MR-3 | The editor shall support move, mark read, star, forward a copy, discard, and stop-processing actions, exposing only actions supported by the account's advertised Sieve extensions. |
+| MR-4 | Stormbox shall store the visual rule document as versioned metadata in a clearly marked managed Sieve script. Generated Sieve is a build artifact rather than the source model. |
+| MR-5 | Every save shall use the durable mutation outbox, upload the generated script, call `SieveScript/validate`, and activate it only after validation succeeds. |
+| MR-6 | A save shall use the last observed `SieveScript` state and reject a concurrent server change instead of overwriting it. |
+| MR-7 | Stormbox shall not modify or delete a script it does not own. If a foreign script is active, activation shall require explicit confirmation and shall preserve the foreign script on the server. |
+| MR-8 | Move actions shall use the RFC 9042 `:mailboxid` extension when supported, retaining a readable hierarchy path as the fallback mailbox name. |
+| MR-9 | Invalid rule data, unsupported actions, server validation failures, and server conflicts shall remain visible and recoverable in the editor. Controls shall be disabled while a save is in flight. |
+| MR-10 | The editor shall be keyboard accessible, trap focus while open, and confirm before discarding unsaved changes. |
+
+## Initial scope
+
+- Server-side filtering of newly delivered mail.
+- One managed visual-rule script per account.
+- A deliberately limited, typed rules model and purpose-built Sieve emitter.
+- Existing arbitrary Sieve scripts remain opaque and preserved.
+
+## Non-goals
+
+- Importing arbitrary Sieve into the visual model.
+- A raw Sieve editor.
+- Retroactively applying rules to existing messages.
+- Shared-account rule management.
+- A Cloudflare Worker rule engine; the deployment bridge only adapts browser CORS and WebSocket authentication.
+
+## Verification
+
+- Unit tests cover normalization, escaping, capability checks, metadata round-tripping, conflict handling, server validation, and outbox integration.
+- Component tests cover loading, editing, takeover confirmation, save locking, and discard confirmation.
+- Local-stack Playwright coverage asserts the visible editor result, durable mutation completion, and the active script directly through JMAP in Chromium and Firefox.
diff --git a/src/App.vue b/src/App.vue
index b87e63b7..29deb746 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -45,6 +45,7 @@ import AppDrawer from './components/AppDrawer.vue';
 import TopNavMenu from './components/TopNavMenu.vue';
 import AccountAvatarMenu from './components/AccountAvatarMenu.vue';
 import WelcomeModal from './components/WelcomeModal.vue';
+import MailRulesDialog from './components/MailRulesDialog.vue';
 import SettingsDialog from './components/settings/SettingsDialog.vue';
 import SettingsGearButton from './components/settings/SettingsGearButton.vue';
 // Staff-only Kanban feature (src/features/kanban): the settings dialog's
@@ -153,6 +154,7 @@ const messageListWidth = ref(DEFAULT_COLUMN_WIDTHS.messageList);
 const folderListHidden = ref(false);
 const showWelcomeModal = ref(false);
 const showSettingsDialog = ref(false);
+const showMailRules = ref(false);
 // With 'system' the OS decides, so a manual light/dark button would fight it.
 const showThemeToggle = computed(() => theme.value !== 'system');
 // Modal dialogs own the keyboard: a single-letter mail shortcut must not
@@ -160,7 +162,8 @@ const showThemeToggle = computed(() => theme.value !== 'system');
 const shortcutsEnabled = computed(() =>
   authStore.status === AUTH_STATE.CONNECTED
   && !showWelcomeModal.value
-  && !showSettingsDialog.value,
+  && !showSettingsDialog.value
+  && !showMailRules.value,
 );
 const windowWidth = ref(typeof window === 'undefined' ? COMPACT_READING_WIDTH : window.innerWidth);
 const wantsMessageDetailView = computed(() =>
@@ -771,7 +774,10 @@ function clamp(value: number, min: number, max: number) {
           @toggle-theme="toggleTheme"
           @open-settings="showSettingsDialog = true"
         />
-        <AccountAvatarMenu @show-welcome-modal="showWelcomeModalAgain" />
+        <AccountAvatarMenu
+          @show-mail-rules="showMailRules = true"
+          @show-welcome-modal="showWelcomeModalAgain"
+        />
       </div>
     </header>
 
@@ -886,6 +892,7 @@ function clamp(value: number, min: number, max: number) {
       singular-item-label="message"
       :total="mailStore.bulkOperation.total"
     />
+    <MailRulesDialog v-if="showMailRules" @close="showMailRules = false" />
     <WelcomeModal
       v-if="showWelcomeModal"
       @dismiss="dismissWelcomeModal"
diff --git a/src/components/AccountAvatarMenu.vue b/src/components/AccountAvatarMenu.vue
index 7b101818..a986c1a5 100644
--- a/src/components/AccountAvatarMenu.vue
+++ b/src/components/AccountAvatarMenu.vue
@@ -1,7 +1,9 @@
 <script setup lang="ts">
 import { computed, ref } from 'vue';
 import { onClickOutside } from '@vueuse/core';
-import { LogOut, RotateCcw, Settings } from '@lucide/vue';
+import {
+  ListFilter, LogOut, RotateCcw, Settings,
+} from '@lucide/vue';
 
 import { useAuthStore } from '../stores/auth-store';
 import { ACCOUNTS_URL } from '../defines';
@@ -9,6 +11,7 @@ import { senderAvatarStyle, senderInitials } from '../utils/sender-avatar';
 
 const authStore = useAuthStore();
 const emit = defineEmits<{
+  (event: 'show-mail-rules'): void;
   (event: 'show-welcome-modal'): void;
 }>();
 
@@ -34,6 +37,11 @@ function onShowWelcomeModal() {
   if (detailsEl.value) detailsEl.value.open = false;
   emit('show-welcome-modal');
 }
+
+function onShowMailRules() {
+  if (detailsEl.value) detailsEl.value.open = false;
+  emit('show-mail-rules');
+}
 </script>
 
 <template>
@@ -50,6 +58,10 @@ function onShowWelcomeModal() {
         </span>
         <span class="account-menu__email">{{ identityLabel }}</span>
       </div>
+      <button class="account-menu__item" type="button" role="menuitem" @click="onShowMailRules">
+        <ListFilter :size="16" :stroke-width="1.75" aria-hidden="true" />
+        <span>Mail Rules</span>
+      </button>
       <a class="account-menu__item" :href="ACCOUNTS_URL" role="menuitem">
         <Settings :size="16" :stroke-width="1.75" aria-hidden="true" />
         <span>Account Settings</span>
diff --git a/src/components/MailRulesDialog.vue b/src/components/MailRulesDialog.vue
new file mode 100644
index 00000000..b9ee40da
--- /dev/null
+++ b/src/components/MailRulesDialog.vue
@@ -0,0 +1,906 @@
+<script setup lang="ts">
+import {
+  computed, nextTick, onBeforeUnmount, onMounted, ref,
+} from 'vue';
+import {
+  ArrowDown, ArrowUp, CircleAlert, Filter, Plus, Trash2, X,
+} from '@lucide/vue';
+
+import AppButton from './AppButton.vue';
+import { useAuthStore } from '../stores/auth-store';
+import { useMailStore } from '../stores/mail-store';
+import { MailRulesSaveError, useRulesStore } from '../stores/rules-store';
+import {
+  cloneRuleDocument,
+  createEmptyRule,
+  newRuleId,
+  normalizeRuleDocument,
+  RuleValidationError,
+} from '../sieve/rules';
+import type {
+  MailRule, MailRuleAction, MailRuleCondition, MailRuleDocument,
+} from '../sieve/rules';
+
+const emit = defineEmits<{ (event: 'close'): void }>();
+
+const authStore = useAuthStore();
+const mailStore = useMailStore();
+const rulesStore = useRulesStore();
+const panelEl = ref<HTMLElement | null>(null);
+const closeButtonEl = ref<HTMLButtonElement | null>(null);
+const draft = ref<MailRuleDocument>({ version: 1, rules: [] });
+const baseline = ref('');
+const localError = ref<string | null>(null);
+const notice = ref<string | null>(null);
+const confirmation = ref<'takeover' | 'discard' | null>(null);
+
+const busy = computed(() => rulesStore.loading || rulesStore.saving);
+const dirty = computed(() => JSON.stringify(draft.value) !== baseline.value);
+const extensions = computed(() => new Set(rulesStore.capabilities.sieveExtensions));
+const canMove = computed(() => extensions.value.has('fileinto'));
+const canFlags = computed(() => extensions.value.has('imap4flags'));
+const canRedirectCopy = computed(() => extensions.value.has('copy'));
+
+const folderOptions = computed(() => {
+  const ownFolders = mailStore.folders.filter((folder) =>
+    folder.account_id === authStore.accountId
+    && folder.is_deleted !== 1
+    && folder.may_add_items !== 0);
+  const byId = new Map(ownFolders.map((folder) => [folder.id, folder]));
+  return ownFolders
+    .map((folder) => {
+      const names: string[] = [];
+      const visited = new Set<number>();
+      let current: typeof folder | undefined = folder;
+      while (current && !visited.has(current.id)) {
+        visited.add(current.id);
+        names.unshift(current.name);
+        current = current.parent_id == null ? undefined : byId.get(current.parent_id);
+      }
+      return { remoteId: folder.remote_id, label: names.join('/') };
+    })
+    .sort((a, b) => a.label.localeCompare(b.label));
+});
+
+const actionOptions = [
+  { value: 'move', label: 'Move to folder' },
+  { value: 'markRead', label: 'Mark as read' },
+  { value: 'star', label: 'Star' },
+  { value: 'redirect', label: 'Forward a copy' },
+  { value: 'discard', label: 'Discard' },
+] as const;
+
+function actionSupported(type: MailRuleAction['type']): boolean {
+  if (type === 'move') return canMove.value;
+  if (type === 'markRead' || type === 'star') return canFlags.value;
+  if (type === 'redirect') return canRedirectCopy.value;
+  return true;
+}
+
+function addRule() {
+  const rule = createEmptyRule();
+  if (!canFlags.value) rule.actions = [createDefaultAction()];
+  draft.value.rules.push(rule);
+  localError.value = null;
+}
+
+function removeRule(index: number) {
+  draft.value.rules.splice(index, 1);
+}
+
+function moveRule(index: number, delta: number) {
+  const target = index + delta;
+  if (target < 0 || target >= draft.value.rules.length) return;
+  const [rule] = draft.value.rules.splice(index, 1);
+  draft.value.rules.splice(target, 0, rule);
+}
+
+function addCondition(rule: MailRule) {
+  rule.conditions.push({
+    id: newRuleId('condition'),
+    field: 'from',
+    operator: 'contains',
+    value: '',
+  });
+}
+
+function removeCondition(rule: MailRule, index: number) {
+  if (rule.conditions.length <= 1) return;
+  rule.conditions.splice(index, 1);
+}
+
+function onConditionFieldChange(condition: MailRuleCondition, event: Event) {
+  const value = (event.target as HTMLSelectElement).value as MailRuleCondition['field'];
+  condition.field = value;
+  if (value === 'header' && !condition.headerName) condition.headerName = 'X-Header';
+  if (value !== 'header') delete condition.headerName;
+}
+
+function addAction(rule: MailRule) {
+  rule.actions.push(createDefaultAction());
+}
+
+function removeAction(rule: MailRule, index: number) {
+  if (rule.actions.length <= 1) return;
+  rule.actions.splice(index, 1);
+}
+
+function onActionTypeChange(rule: MailRule, index: number, event: Event) {
+  const type = (event.target as HTMLSelectElement).value as MailRuleAction['type'];
+  rule.actions.splice(index, 1, createAction(type));
+}
+
+function onMoveTargetChange(action: Extract<MailRuleAction, { type: 'move' }>, event: Event) {
+  const mailboxId = (event.target as HTMLSelectElement).value;
+  const target = folderOptions.value.find((folder) => folder.remoteId === mailboxId);
+  action.mailboxId = mailboxId;
+  action.mailboxName = target?.label ?? action.mailboxName;
+}
+
+function createDefaultAction(): MailRuleAction {
+  const order: MailRuleAction['type'][] = ['move', 'markRead', 'discard'];
+  return createAction(order.find(actionSupported) ?? 'discard');
+}
+
+function createAction(type: MailRuleAction['type']): MailRuleAction {
+  const id = newRuleId('action');
+  if (type === 'move') {
+    const folder = folderOptions.value[0];
+    return {
+      id,
+      type,
+      mailboxId: folder?.remoteId ?? '',
+      mailboxName: folder?.label ?? '',
+    };
+  }
+  if (type === 'redirect') return { id, type, address: '' };
+  return { id, type };
+}
+
+async function load() {
+  localError.value = null;
+  notice.value = null;
+  try {
+    await rulesStore.load();
+    draft.value = rulesStore.freshDocument();
+    baseline.value = JSON.stringify(draft.value);
+  } catch (error) {
+    localError.value = errorMessage(error);
+  }
+}
+
+function requestSave() {
+  localError.value = null;
+  notice.value = null;
+  try {
+    draft.value = refreshFolderFallbacks(draft.value);
+    normalizeRuleDocument(draft.value);
+  } catch (error) {
+    localError.value = errorMessage(error);
+    return;
+  }
+  if (rulesStore.foreignActiveScript) {
+    confirmation.value = 'takeover';
+    focusConfirmation();
+    return;
+  }
+  persist(false);
+}
+
+async function persist(takeover: boolean) {
+  confirmation.value = null;
+  localError.value = null;
+  notice.value = null;
+  try {
+    await rulesStore.save(draft.value, { takeover });
+    draft.value = rulesStore.freshDocument();
+    baseline.value = JSON.stringify(draft.value);
+    notice.value = 'Rules saved, validated, and activated.';
+  } catch (error) {
+    if (error instanceof MailRulesSaveError && error.code === 'foreignScriptActive') {
+      const unsaved = cloneRuleDocument(draft.value);
+      try {
+        await rulesStore.load();
+        draft.value = unsaved;
+      } catch (reloadError) {
+        localError.value = errorMessage(reloadError);
+        return;
+      }
+      confirmation.value = 'takeover';
+      focusConfirmation();
+      return;
+    }
+    localError.value = errorMessage(error);
+  }
+}
+
+function refreshFolderFallbacks(input: MailRuleDocument): MailRuleDocument {
+  const document = cloneRuleDocument(input);
+  const folders = new Map(folderOptions.value.map((folder) => [folder.remoteId, folder.label]));
+  for (const rule of document.rules) {
+    for (const action of rule.actions) {
+      if (action.type !== 'move') continue;
+      const label = folders.get(action.mailboxId);
+      if (!label) {
+        throw new RuleValidationError(
+          `The destination folder in “${rule.name || 'Unnamed rule'}” is no longer available.`,
+        );
+      }
+      action.mailboxName = label;
+    }
+  }
+  return document;
+}
+
+function requestClose() {
+  if (busy.value) return;
+  if (dirty.value) {
+    confirmation.value = 'discard';
+    focusConfirmation();
+    return;
+  }
+  emit('close');
+}
+
+function cancelConfirmation() {
+  confirmation.value = null;
+  nextTick(() => closeButtonEl.value?.focus());
+}
+
+function confirmDiscard() {
+  confirmation.value = null;
+  emit('close');
+}
+
+function focusConfirmation() {
+  nextTick(() => {
+    panelEl.value?.querySelector<HTMLElement>('[data-mail-rules-confirm]')?.focus();
+  });
+}
+
+function onWindowKeydown(event: KeyboardEvent) {
+  if (event.key === 'Escape') {
+    event.preventDefault();
+    if (confirmation.value) {
+      cancelConfirmation();
+      return;
+    }
+    requestClose();
+    return;
+  }
+  if (event.key !== 'Tab' || !panelEl.value) return;
+  const focusRoot = confirmation.value
+    ? panelEl.value.querySelector<HTMLElement>('.mail-rules__confirm')
+    : panelEl.value;
+  if (!focusRoot) return;
+  const focusable = [...focusRoot.querySelectorAll<HTMLElement>(
+    'button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])',
+  )].filter((element) => element.offsetParent !== null);
+  if (focusable.length === 0) return;
+  const first = focusable[0];
+  const last = focusable[focusable.length - 1];
+  if (event.shiftKey && document.activeElement === first) {
+    event.preventDefault();
+    last.focus();
+  } else if (!event.shiftKey && document.activeElement === last) {
+    event.preventDefault();
+    first.focus();
+  }
+}
+
+function scriptLabel(script: { name?: string | null } | null): string {
+  return script?.name?.trim() || 'Unnamed script';
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+onMounted(async () => {
+  window.addEventListener('keydown', onWindowKeydown);
+  closeButtonEl.value?.focus();
+  await load();
+});
+
+onBeforeUnmount(() => {
+  window.removeEventListener('keydown', onWindowKeydown);
+});
+</script>
+
+<template>
+  <Teleport to="body">
+    <div class="mail-rules" role="presentation" @click.self="requestClose">
+      <section
+        ref="panelEl"
+        class="mail-rules__panel"
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby="mail-rules-title"
+      >
+        <header class="mail-rules__header">
+          <div>
+            <h2 id="mail-rules-title">Mail Rules</h2>
+            <p>Filter new mail on the server, even while Stormbox is closed.</p>
+          </div>
+          <button
+            ref="closeButtonEl"
+            class="mail-rules__icon-button"
+            type="button"
+            aria-label="Close mail rules"
+            :disabled="busy"
+            @click="requestClose"
+          >
+            <X :size="19" :stroke-width="2" aria-hidden="true" />
+          </button>
+        </header>
+
+        <main class="mail-rules__body">
+          <p v-if="rulesStore.loading" class="mail-rules__empty" role="status">
+            Loading server rules…
+          </p>
+
+          <div v-if="localError || rulesStore.error" class="mail-rules__alert mail-rules__alert--error" role="alert">
+            <CircleAlert :size="18" aria-hidden="true" />
+            <div>
+              <strong>Mail rules could not be loaded or saved.</strong>
+              <p>{{ localError || rulesStore.error }}</p>
+              <button v-if="!rulesStore.saving" type="button" class="mail-rules__text-button" @click="load">
+                Reload from server
+              </button>
+            </div>
+          </div>
+
+          <div v-if="notice" class="mail-rules__alert mail-rules__alert--success" role="status">
+            {{ notice }}
+          </div>
+
+          <template v-if="!rulesStore.loading && rulesStore.snapshot">
+            <div v-if="!rulesStore.supported" class="mail-rules__alert" role="status">
+              This account does not advertise JMAP for Sieve, so server-side rules are unavailable.
+            </div>
+
+            <div v-else-if="rulesStore.snapshot.parseError" class="mail-rules__alert mail-rules__alert--error" role="alert">
+              <CircleAlert :size="18" aria-hidden="true" />
+              <div>
+                <strong>The managed script is not visually editable.</strong>
+                <p>{{ rulesStore.snapshot.parseError }}</p>
+              </div>
+            </div>
+
+            <template v-else-if="rulesStore.supported">
+              <div v-if="rulesStore.foreignActiveScript" class="mail-rules__alert mail-rules__alert--warning" role="status">
+                <CircleAlert :size="18" aria-hidden="true" />
+                <div>
+                  <strong>Another Sieve script is active.</strong>
+                  <p>
+                    Saving will deactivate “{{ scriptLabel(rulesStore.foreignActiveScript) }}”,
+                    but it will remain stored on the server.
+                  </p>
+                </div>
+              </div>
+
+              <div class="mail-rules__toolbar">
+                <div class="mail-rules__summary">
+                  <Filter :size="17" aria-hidden="true" />
+                  <span>{{ draft.rules.length }} {{ draft.rules.length === 1 ? 'rule' : 'rules' }}</span>
+                </div>
+                <AppButton data-mail-rules-add :disabled="busy" @click="addRule">
+                  <template #iconLeft><Plus :size="16" aria-hidden="true" /></template>
+                  Add rule
+                </AppButton>
+              </div>
+
+              <p v-if="draft.rules.length === 0" class="mail-rules__empty">
+                No rules yet. Add one, or save an empty ruleset to keep all incoming mail unchanged.
+              </p>
+
+              <fieldset class="mail-rules__fieldset" :disabled="busy">
+                <article
+                  v-for="(rule, ruleIndex) in draft.rules"
+                  :key="rule.id"
+                  class="mail-rule"
+                >
+                  <header class="mail-rule__header">
+                    <label class="mail-rule__enabled">
+                      <input v-model="rule.enabled" type="checkbox" />
+                      <span class="sr-only">Enable rule</span>
+                    </label>
+                    <input
+                      v-model="rule.name"
+                      class="mail-rule__name"
+                      type="text"
+                      aria-label="Rule name"
+                      placeholder="Rule name"
+                    />
+                    <button
+                      class="mail-rules__icon-button"
+                      type="button"
+                      :disabled="ruleIndex === 0"
+                      aria-label="Move rule up"
+                      @click="moveRule(ruleIndex, -1)"
+                    ><ArrowUp :size="16" aria-hidden="true" /></button>
+                    <button
+                      class="mail-rules__icon-button"
+                      type="button"
+                      :disabled="ruleIndex === draft.rules.length - 1"
+                      aria-label="Move rule down"
+                      @click="moveRule(ruleIndex, 1)"
+                    ><ArrowDown :size="16" aria-hidden="true" /></button>
+                    <button
+                      class="mail-rules__icon-button mail-rules__icon-button--danger"
+                      type="button"
+                      aria-label="Delete rule"
+                      @click="removeRule(ruleIndex)"
+                    ><Trash2 :size="16" aria-hidden="true" /></button>
+                  </header>
+
+                  <div class="mail-rule__section">
+                    <div class="mail-rule__section-title">
+                      <span>When</span>
+                      <select v-model="rule.match" aria-label="Condition match mode">
+                        <option value="all">all conditions match</option>
+                        <option value="any">any condition matches</option>
+                      </select>
+                    </div>
+                    <div
+                      v-for="(condition, conditionIndex) in rule.conditions"
+                      :key="condition.id"
+                      class="mail-rule__row mail-rule__condition"
+                    >
+                      <select
+                        :value="condition.field"
+                        aria-label="Condition field"
+                        @change="onConditionFieldChange(condition, $event)"
+                      >
+                        <option value="from">From</option>
+                        <option value="to">To</option>
+                        <option value="toCc">To or Cc</option>
+                        <option value="subject">Subject</option>
+                        <option value="header">Custom header</option>
+                      </select>
+                      <input
+                        v-if="condition.field === 'header'"
+                        v-model="condition.headerName"
+                        type="text"
+                        aria-label="Header name"
+                        placeholder="X-Header"
+                      />
+                      <select v-model="condition.operator" aria-label="Condition operator">
+                        <option value="is">is</option>
+                        <option value="contains">contains</option>
+                        <option value="matches">matches wildcard</option>
+                      </select>
+                      <input
+                        v-model="condition.value"
+                        type="text"
+                        aria-label="Condition value"
+                        placeholder="Value"
+                      />
+                      <button
+                        class="mail-rules__icon-button"
+                        type="button"
+                        :disabled="rule.conditions.length === 1"
+                        aria-label="Remove condition"
+                        @click="removeCondition(rule, conditionIndex)"
+                      ><X :size="15" aria-hidden="true" /></button>
+                    </div>
+                    <button class="mail-rules__text-button" type="button" @click="addCondition(rule)">
+                      + Add condition
+                    </button>
+                  </div>
+
+                  <div class="mail-rule__section">
+                    <div class="mail-rule__section-title"><span>Then</span></div>
+                    <div
+                      v-for="(action, actionIndex) in rule.actions"
+                      :key="action.id"
+                      class="mail-rule__row mail-rule__action"
+                    >
+                      <select
+                        :value="action.type"
+                        aria-label="Rule action"
+                        @change="onActionTypeChange(rule, actionIndex, $event)"
+                      >
+                        <option
+                          v-for="option in actionOptions"
+                          :key="option.value"
+                          :value="option.value"
+                          :disabled="!actionSupported(option.value)"
+                        >{{ option.label }}</option>
+                      </select>
+                      <select
+                        v-if="action.type === 'move'"
+                        :value="action.mailboxId"
+                        aria-label="Destination folder"
+                        @change="onMoveTargetChange(action, $event)"
+                      >
+                        <option value="" disabled>Select folder</option>
+                        <option
+                          v-for="folder in folderOptions"
+                          :key="folder.remoteId"
+                          :value="folder.remoteId"
+                        >{{ folder.label }}</option>
+                      </select>
+                      <input
+                        v-else-if="action.type === 'redirect'"
+                        v-model="action.address"
+                        type="email"
+                        aria-label="Forwarding address"
+                        placeholder="person@example.com"
+                      />
+                      <span v-else class="mail-rule__action-description">
+                        {{ actionOptions.find((option) => option.value === action.type)?.label }}
+                      </span>
+                      <button
+                        class="mail-rules__icon-button"
+                        type="button"
+                        :disabled="rule.actions.length === 1"
+                        aria-label="Remove action"
+                        @click="removeAction(rule, actionIndex)"
+                      ><X :size="15" aria-hidden="true" /></button>
+                    </div>
+                    <button class="mail-rules__text-button" type="button" @click="addAction(rule)">
+                      + Add action
+                    </button>
+                    <label class="mail-rule__stop">
+                      <input v-model="rule.stopProcessing" type="checkbox" />
+                      Stop processing later rules when this rule matches
+                    </label>
+                  </div>
+                </article>
+              </fieldset>
+            </template>
+          </template>
+        </main>
+
+        <footer class="mail-rules__footer">
+          <span class="mail-rules__footer-status">
+            <template v-if="rulesStore.saving">Uploading and validating…</template>
+            <template v-else-if="dirty">Unsaved changes</template>
+          </span>
+          <AppButton variant="outline" :disabled="busy" @click="requestClose">Close</AppButton>
+          <AppButton
+            data-mail-rules-save
+            :disabled="busy || !rulesStore.supported || Boolean(rulesStore.snapshot?.parseError)"
+            @click="requestSave"
+          >Save and activate</AppButton>
+        </footer>
+
+        <div v-if="confirmation" class="mail-rules__confirm-backdrop" role="presentation">
+          <section
+            class="mail-rules__confirm"
+            role="alertdialog"
+            aria-modal="true"
+            :aria-labelledby="confirmation === 'takeover' ? 'takeover-title' : 'discard-title'"
+          >
+            <template v-if="confirmation === 'takeover'">
+              <h3 id="takeover-title">Activate Stormbox rules?</h3>
+              <p>
+                This will deactivate “{{ scriptLabel(rulesStore.foreignActiveScript) }}”.
+                Stormbox will preserve that script unchanged so it can be reactivated elsewhere.
+              </p>
+              <div class="mail-rules__confirm-actions">
+                <AppButton variant="outline" :disabled="rulesStore.saving" @click="cancelConfirmation">Cancel</AppButton>
+                <AppButton
+                  data-mail-rules-confirm
+                  :disabled="rulesStore.saving"
+                  @click="persist(true)"
+                >Activate Stormbox rules</AppButton>
+              </div>
+            </template>
+            <template v-else>
+              <h3 id="discard-title">Discard unsaved changes?</h3>
+              <p>Your server-side rules will stay as they were when this editor opened.</p>
+              <div class="mail-rules__confirm-actions">
+                <AppButton variant="outline" @click="cancelConfirmation">Keep editing</AppButton>
+                <AppButton data-mail-rules-confirm @click="confirmDiscard">Discard changes</AppButton>
+              </div>
+            </template>
+          </section>
+        </div>
+      </section>
+    </div>
+  </Teleport>
+</template>
+
+<style scoped>
+.mail-rules {
+  position: fixed;
+  inset: 0;
+  z-index: 125;
+  display: grid;
+  place-items: center;
+  padding: 18px;
+  background: color-mix(in srgb, #000 58%, transparent);
+}
+.mail-rules__panel {
+  position: relative;
+  display: grid;
+  grid-template-rows: auto minmax(0, 1fr) auto;
+  width: min(900px, 100%);
+  max-height: min(90vh, calc(100vh - 36px));
+  overflow: hidden;
+  border: 1px solid var(--border);
+  border-radius: 16px;
+  background: var(--panel);
+  color: var(--text);
+  box-shadow: 0 24px 64px color-mix(in srgb, #000 45%, transparent);
+}
+.mail-rules__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 18px 20px 14px;
+  border-bottom: 1px solid var(--border-soft);
+}
+.mail-rules__header h2,
+.mail-rules__confirm h3 {
+  margin: 0;
+  font-size: 18px;
+  font-weight: 650;
+}
+.mail-rules__header p,
+.mail-rules__confirm p,
+.mail-rules__alert p {
+  margin: 5px 0 0;
+  color: var(--muted);
+  font-size: 13px;
+  line-height: 1.45;
+}
+.mail-rules__body {
+  overflow: auto;
+  padding: 16px 20px 24px;
+}
+.mail-rules__toolbar,
+.mail-rules__footer,
+.mail-rule__header,
+.mail-rule__section-title,
+.mail-rules__summary,
+.mail-rules__confirm-actions {
+  display: flex;
+  align-items: center;
+}
+.mail-rules__toolbar {
+  justify-content: space-between;
+  gap: 12px;
+  margin: 4px 0 12px;
+}
+.mail-rules__summary {
+  gap: 7px;
+  color: var(--muted);
+  font-size: 13px;
+  font-weight: 600;
+}
+.mail-rules__footer {
+  justify-content: flex-end;
+  gap: 9px;
+  padding: 12px 20px;
+  border-top: 1px solid var(--border-soft);
+  background: var(--panel2);
+}
+.mail-rules__footer-status {
+  flex: 1;
+  color: var(--muted);
+  font-size: 12px;
+}
+.mail-rules__alert {
+  display: flex;
+  align-items: flex-start;
+  gap: 9px;
+  margin: 0 0 14px;
+  padding: 11px 12px;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  background: var(--panel2);
+  font-size: 13px;
+  line-height: 1.4;
+}
+.mail-rules__alert svg { flex: 0 0 auto; margin-top: 1px; }
+.mail-rules__alert--warning {
+  border-color: var(--warn-border);
+  background: var(--warn-bg);
+  color: var(--warn-fg);
+}
+.mail-rules__alert--error {
+  border-color: color-mix(in srgb, #d33 55%, var(--border));
+  background: color-mix(in srgb, #d33 10%, var(--panel));
+}
+.mail-rules__alert--success {
+  border-color: color-mix(in srgb, #2b9b58 60%, var(--border));
+  background: color-mix(in srgb, #2b9b58 10%, var(--panel));
+}
+.mail-rules__empty {
+  margin: 28px 8px;
+  color: var(--muted);
+  font-size: 13px;
+  text-align: center;
+}
+.mail-rules__fieldset {
+  min-width: 0;
+  margin: 0;
+  padding: 0;
+  border: 0;
+}
+.mail-rule {
+  margin-bottom: 14px;
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  background: var(--panel2);
+  overflow: hidden;
+}
+.mail-rule__header {
+  gap: 6px;
+  padding: 10px 12px;
+  border-bottom: 1px solid var(--border-soft);
+}
+.mail-rule__enabled {
+  display: inline-flex;
+  padding: 4px;
+}
+.mail-rule__name {
+  flex: 1;
+  min-width: 100px;
+  font-weight: 600;
+}
+.mail-rule__section {
+  padding: 12px;
+}
+.mail-rule__section + .mail-rule__section {
+  border-top: 1px solid var(--border-soft);
+}
+.mail-rule__section-title {
+  gap: 8px;
+  margin-bottom: 8px;
+  font-size: 12px;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--muted);
+}
+.mail-rule__section-title select {
+  text-transform: none;
+  letter-spacing: normal;
+}
+.mail-rule__row {
+  display: grid;
+  gap: 8px;
+  align-items: center;
+  margin-bottom: 8px;
+}
+.mail-rule__condition {
+  grid-template-columns: minmax(120px, 0.8fr) minmax(120px, 0.8fr) minmax(145px, 1fr) minmax(160px, 1.5fr) 32px;
+}
+.mail-rule__condition:not(:has(input[aria-label="Header name"])) {
+  grid-template-columns: minmax(120px, 0.8fr) minmax(145px, 1fr) minmax(160px, 1.8fr) 32px;
+}
+.mail-rule__action {
+  grid-template-columns: minmax(170px, 0.8fr) minmax(200px, 1.4fr) 32px;
+}
+.mail-rule__action-description {
+  color: var(--muted);
+  font-size: 13px;
+}
+.mail-rule__stop {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-top: 10px;
+  color: var(--muted);
+  font-size: 12px;
+}
+.mail-rule input,
+.mail-rule select {
+  box-sizing: border-box;
+  width: 100%;
+  min-width: 0;
+  min-height: 34px;
+  padding: 6px 8px;
+  border: 1px solid var(--border);
+  border-radius: 5px;
+  background: var(--panel);
+  color: var(--text);
+  font: inherit;
+  font-size: 13px;
+}
+.mail-rule input[type="checkbox"] {
+  width: 16px;
+  min-height: 16px;
+  accent-color: var(--accent);
+}
+.mail-rule input:focus-visible,
+.mail-rule select:focus-visible {
+  border-color: var(--accent);
+  outline: 2px solid color-mix(in srgb, var(--accent) 30%, transparent);
+  outline-offset: 1px;
+}
+.mail-rules__icon-button,
+.mail-rules__text-button {
+  border: 0;
+  background: transparent;
+  color: var(--muted);
+  cursor: pointer;
+  font: inherit;
+}
+.mail-rules__icon-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
+  padding: 0;
+  border-radius: 999px;
+}
+.mail-rules__icon-button:hover:not(:disabled),
+.mail-rules__icon-button:focus-visible,
+.mail-rules__text-button:hover,
+.mail-rules__text-button:focus-visible {
+  background: var(--rowHover);
+  color: var(--text);
+  outline: none;
+}
+.mail-rules__icon-button--danger:hover:not(:disabled),
+.mail-rules__icon-button--danger:focus-visible { color: #d84a4a; }
+.mail-rules__icon-button:disabled { opacity: 0.35; cursor: default; }
+.mail-rules__text-button {
+  padding: 5px 7px;
+  border-radius: 4px;
+  color: var(--accent);
+  font-size: 12px;
+  font-weight: 600;
+}
+.mail-rules__confirm-backdrop {
+  position: absolute;
+  inset: 0;
+  z-index: 2;
+  display: grid;
+  place-items: center;
+  padding: 16px;
+  background: color-mix(in srgb, #000 62%, transparent);
+}
+.mail-rules__confirm {
+  width: min(440px, 100%);
+  padding: 18px;
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  background: var(--panel);
+  box-shadow: 0 20px 45px color-mix(in srgb, #000 45%, transparent);
+}
+.mail-rules__confirm-actions {
+  justify-content: flex-end;
+  gap: 8px;
+  margin-top: 18px;
+}
+.sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+@media (max-width: 760px) {
+  .mail-rules { padding: 0; }
+  .mail-rules__panel {
+    width: 100%;
+    height: 100%;
+    max-height: none;
+    border: 0;
+    border-radius: 0;
+  }
+  .mail-rule__condition,
+  .mail-rule__condition:not(:has(input[aria-label="Header name"])),
+  .mail-rule__action {
+    grid-template-columns: 1fr 32px;
+  }
+  .mail-rule__condition > :not(button),
+  .mail-rule__action > :not(button) { grid-column: 1; }
+  .mail-rule__condition > button,
+  .mail-rule__action > button { grid-column: 2; grid-row: 1; }
+  .mail-rules__footer { flex-wrap: wrap; }
+  .mail-rules__footer-status { flex-basis: 100%; }
+}
+</style>
diff --git a/src/constants/states.ts b/src/constants/states.ts
index 691aa049..a27787a7 100644
--- a/src/constants/states.ts
+++ b/src/constants/states.ts
@@ -212,6 +212,7 @@ export const MUTATION_TYPE = Object.freeze({
   CREATE_EMAILS: 'createEmails',
   PUSH_SETTINGS: 'pushSettings',
   PUSH_CONTACTS_TRASH: 'pushContactsTrash',
+  SET_SIEVE_RULES: 'setSieveRules',
 } as const);
 export type MutationType = (typeof MUTATION_TYPE)[keyof typeof MUTATION_TYPE];
 
diff --git a/src/db/protocol.ts b/src/db/protocol.ts
index 4f5926e0..cf43db54 100644
--- a/src/db/protocol.ts
+++ b/src/db/protocol.ts
@@ -185,6 +185,7 @@ export const DB_RPC = Object.freeze({
   SYNC_INVENTORY_ADDRESSBOOK: 'sync.inventoryAddressbook',
   SYNC_ENSURE_CONTACTS: 'sync.ensureContacts',
   SYNC_ENSURE_FOLDER_INDEX: 'sync.ensureFolderIndex',
+  SYNC_GET_MAIL_RULES: 'sync.getMailRules',
   SYNC_DRAIN_OUTBOX: 'sync.drainOutbox',
   SYNC_RUN_MUTATION: 'sync.runMutation',
   SYNC_GET_ATTACHMENT_LIMITS: 'sync.getAttachmentLimits',
diff --git a/src/db/repository.ts b/src/db/repository.ts
index 6c5adf62..d4bdee58 100644
--- a/src/db/repository.ts
+++ b/src/db/repository.ts
@@ -637,6 +637,10 @@ export class Repository {
     return this.call(DB_RPC.SYNC_ENSURE_FOLDER_INDEX, { accountId, folderId, options });
   }
 
+  getMailRules(accountId) {
+    return this.call(DB_RPC.SYNC_GET_MAIL_RULES, { accountId });
+  }
+
   drainOutbox(accountId, limit = 25) {
     return this.call(DB_RPC.SYNC_DRAIN_OUTBOX, { accountId, limit });
   }
diff --git a/src/sieve/rules.ts b/src/sieve/rules.ts
new file mode 100644
index 00000000..14c68cb2
--- /dev/null
+++ b/src/sieve/rules.ts
@@ -0,0 +1,469 @@
+export const SIEVE_CAPABILITY = 'urn:ietf:params:jmap:sieve';
+export const MANAGED_SCRIPT_NAME = 'Stormbox Mail Rules';
+export const MANAGED_SCRIPT_MARKER = '# stormbox-managed: mail-rules/v1';
+
+const DATA_PREFIX = '# stormbox-data: ';
+const DATA_CHUNK_SIZE = 72;
+const BASE64URL_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+
+export type RuleMatch = 'all' | 'any';
+export type RuleField = 'from' | 'to' | 'toCc' | 'subject' | 'header';
+export type RuleOperator = 'is' | 'contains' | 'matches';
+
+export interface MailRuleCondition {
+  id: string;
+  field: RuleField;
+  operator: RuleOperator;
+  value: string;
+  headerName?: string;
+}
+
+export type MailRuleAction =
+  | { id: string; type: 'move'; mailboxId: string; mailboxName: string }
+  | { id: string; type: 'markRead' }
+  | { id: string; type: 'star' }
+  | { id: string; type: 'redirect'; address: string }
+  | { id: string; type: 'discard' };
+
+export interface MailRule {
+  id: string;
+  name: string;
+  enabled: boolean;
+  match: RuleMatch;
+  conditions: MailRuleCondition[];
+  actions: MailRuleAction[];
+  stopProcessing: boolean;
+}
+
+export interface MailRuleDocument {
+  version: 1;
+  rules: MailRule[];
+}
+
+export interface SieveRuleCapabilities {
+  sieveExtensions: string[];
+  maxSizeScript?: number | null;
+  maxNumberRedirects?: number | null;
+}
+
+export class RuleValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'RuleValidationError';
+  }
+}
+
+export function emptyRuleDocument(): MailRuleDocument {
+  return { version: 1, rules: [] };
+}
+
+export function newRuleId(prefix = 'rule'): string {
+  const uuid = globalThis.crypto?.randomUUID?.();
+  if (uuid) return `${prefix}-${uuid}`;
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+
+export function createEmptyRule(): MailRule {
+  return {
+    id: newRuleId(),
+    name: 'New rule',
+    enabled: true,
+    match: 'all',
+    conditions: [{
+      id: newRuleId('condition'),
+      field: 'from',
+      operator: 'contains',
+      value: '',
+    }],
+    actions: [{ id: newRuleId('action'), type: 'markRead' }],
+    stopProcessing: true,
+  };
+}
+
+export function cloneRuleDocument(document: MailRuleDocument): MailRuleDocument {
+  return {
+    version: 1,
+    rules: document.rules.map((rule) => ({
+      ...rule,
+      conditions: rule.conditions.map((condition) => ({ ...condition })),
+      actions: rule.actions.map((action) => ({ ...action })),
+    })),
+  };
+}
+
+export function normalizeRuleDocument(input: unknown): MailRuleDocument {
+  if (!isRecord(input) || input.version !== 1 || !Array.isArray(input.rules)) {
+    throw new RuleValidationError('The managed rule data has an unsupported format.');
+  }
+
+  const seenRuleIds = new Set<string>();
+  const rules = input.rules.map((value, ruleIndex) => {
+    if (!isRecord(value)) {
+      throw new RuleValidationError(`Rule ${ruleIndex + 1} is malformed.`);
+    }
+    const id = requiredId(value.id, `Rule ${ruleIndex + 1}`, seenRuleIds);
+    const name = requiredText(value.name, `Rule ${ruleIndex + 1} needs a name.`);
+    const match = value.match === 'all' || value.match === 'any' ? value.match : null;
+    if (!match) throw new RuleValidationError(`Rule “${name}” has an invalid match mode.`);
+    if (!Array.isArray(value.conditions) || value.conditions.length === 0) {
+      throw new RuleValidationError(`Rule “${name}” needs at least one condition.`);
+    }
+    if (!Array.isArray(value.actions) || value.actions.length === 0) {
+      throw new RuleValidationError(`Rule “${name}” needs at least one action.`);
+    }
+
+    const seenConditionIds = new Set<string>();
+    const conditions = value.conditions.map((condition, conditionIndex) =>
+      normalizeCondition(condition, name, conditionIndex, seenConditionIds));
+    const seenActionIds = new Set<string>();
+    const actions = value.actions.map((action, actionIndex) =>
+      normalizeAction(action, name, actionIndex, seenActionIds));
+
+    return {
+      id,
+      name,
+      enabled: value.enabled !== false,
+      match,
+      conditions,
+      actions,
+      stopProcessing: value.stopProcessing === true,
+    } satisfies MailRule;
+  });
+
+  return { version: 1, rules };
+}
+
+export function isManagedRulesScript(script: string): boolean {
+  return script.split(/\r?\n/).some((line) => line.trimEnd() === MANAGED_SCRIPT_MARKER);
+}
+
+/**
+ * Return null for a foreign script. A script carrying Stormbox's marker
+ * is owned by this editor; malformed metadata throws so callers never
+ * silently replace a managed script they can no longer understand.
+ */
+export function parseManagedRules(script: string): MailRuleDocument | null {
+  if (!isManagedRulesScript(script)) return null;
+  const chunks = script
+    .split(/\r?\n/)
+    .filter((line) => line.startsWith(DATA_PREFIX))
+    .map((line) => line.slice(DATA_PREFIX.length).trim());
+  if (chunks.length === 0 || chunks.some((chunk) => !/^[A-Za-z0-9_-]+$/.test(chunk))) {
+    throw new RuleValidationError('The Stormbox rule metadata is missing or malformed.');
+  }
+  try {
+    const json = new TextDecoder().decode(decodeBase64Url(chunks.join('')));
+    return normalizeRuleDocument(JSON.parse(json));
+  } catch (error) {
+    if (error instanceof RuleValidationError) throw error;
+    throw new RuleValidationError('The Stormbox rule metadata could not be decoded.');
+  }
+}
+
+export function compileRules(
+  input: unknown,
+  capabilities: SieveRuleCapabilities,
+): string {
+  const document = normalizeRuleDocument(input);
+  validateRedirectBudget(document, capabilities.maxNumberRedirects);
+  const extensions = new Set(capabilities.sieveExtensions ?? []);
+  const required = new Set<string>();
+  const blocks: string[] = [];
+
+  for (const rule of document.rules) {
+    if (!rule.enabled) continue;
+    const test = compileRuleTest(rule);
+    const actionLines = rule.actions.map((action) =>
+      `  ${compileAction(action, extensions, required)}`);
+    if (rule.stopProcessing) actionLines.push('  stop;');
+    const label = rule.name.replace(/[\r\n]+/g, ' ').trim();
+    blocks.push([
+      `# Rule: ${label}`,
+      `if ${test} {`,
+      ...actionLines,
+      '}',
+    ].join('\r\n'));
+  }
+
+  const encoded = encodeBase64Url(new TextEncoder().encode(JSON.stringify(document)));
+  const metadataLines = chunkString(encoded, DATA_CHUNK_SIZE)
+    .map((chunk) => `${DATA_PREFIX}${chunk}`);
+  const lines = [
+    '# Stormbox managed mail rules. Edit these rules in Stormbox.',
+    MANAGED_SCRIPT_MARKER,
+    ...metadataLines,
+    '',
+  ];
+  if (required.size > 0) {
+    lines.push(`require [${[...required].sort().map(sieveString).join(', ')}];`, '');
+  }
+  if (blocks.length > 0) {
+    lines.push(blocks.join('\r\n\r\n'));
+  } else {
+    lines.push('# No enabled rules.', 'keep;');
+  }
+  lines.push('', '# End Stormbox managed mail rules.', '');
+  const script = lines.join('\r\n');
+  const maxSize = capabilities.maxSizeScript;
+  if (typeof maxSize === 'number' && maxSize >= 0) {
+    const size = new TextEncoder().encode(script).byteLength;
+    if (size > maxSize) {
+      throw new RuleValidationError(`The generated script is ${size} bytes; the server limit is ${maxSize}.`);
+    }
+  }
+  return script;
+}
+
+function validateRedirectBudget(document: MailRuleDocument, limit: number | null | undefined): void {
+  if (typeof limit !== 'number' || !Number.isFinite(limit) || limit < 0) return;
+
+  let redirectsOnContinuingPath = 0;
+  let maximumRedirects = 0;
+  for (const rule of document.rules) {
+    if (!rule.enabled) continue;
+    const redirectsInRule = rule.actions.filter((action) => action.type === 'redirect').length;
+    maximumRedirects = Math.max(maximumRedirects, redirectsOnContinuingPath + redirectsInRule);
+    // A matching stop rule terminates that path. Only the non-matching
+    // path can reach later rules, so its redirects do not accumulate.
+    if (!rule.stopProcessing) redirectsOnContinuingPath += redirectsInRule;
+  }
+
+  if (maximumRedirects > limit) {
+    throw new RuleValidationError(
+      `The rules can redirect ${maximumRedirects} messages in one evaluation; the server limit is ${limit}.`,
+    );
+  }
+}
+
+export function uniqueManagedScriptName(existingNames: Iterable<string | null | undefined>): string {
+  const names = new Set([...existingNames].filter((name): name is string => Boolean(name)));
+  if (!names.has(MANAGED_SCRIPT_NAME)) return MANAGED_SCRIPT_NAME;
+  for (let suffix = 2; suffix < 10_000; suffix += 1) {
+    const candidate = `${MANAGED_SCRIPT_NAME} ${suffix}`;
+    if (!names.has(candidate)) return candidate;
+  }
+  throw new RuleValidationError('Could not choose a unique managed script name.');
+}
+
+function normalizeCondition(
+  input: unknown,
+  ruleName: string,
+  index: number,
+  seenIds: Set<string>,
+): MailRuleCondition {
+  if (!isRecord(input)) {
+    throw new RuleValidationError(`Condition ${index + 1} in “${ruleName}” is malformed.`);
+  }
+  const field = ['from', 'to', 'toCc', 'subject', 'header'].includes(String(input.field))
+    ? input.field as RuleField
+    : null;
+  const operator = ['is', 'contains', 'matches'].includes(String(input.operator))
+    ? input.operator as RuleOperator
+    : null;
+  if (!field || !operator) {
+    throw new RuleValidationError(`Condition ${index + 1} in “${ruleName}” is not supported.`);
+  }
+  const value = requiredText(
+    input.value,
+    `Condition ${index + 1} in “${ruleName}” needs a value.`,
+  );
+  rejectControlCharacters(value, `Condition ${index + 1} in “${ruleName}”`);
+  const condition: MailRuleCondition = {
+    id: requiredId(input.id, `Condition ${index + 1} in “${ruleName}”`, seenIds),
+    field,
+    operator,
+    value,
+  };
+  if (field === 'header') {
+    const headerName = requiredText(
+      input.headerName,
+      `Custom header condition ${index + 1} in “${ruleName}” needs a header name.`,
+    );
+    if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(headerName)) {
+      throw new RuleValidationError(`“${headerName}” is not a valid header field name.`);
+    }
+    condition.headerName = headerName;
+  }
+  return condition;
+}
+
+function normalizeAction(
+  input: unknown,
+  ruleName: string,
+  index: number,
+  seenIds: Set<string>,
+): MailRuleAction {
+  if (!isRecord(input)) {
+    throw new RuleValidationError(`Action ${index + 1} in “${ruleName}” is malformed.`);
+  }
+  const id = requiredId(input.id, `Action ${index + 1} in “${ruleName}”`, seenIds);
+  switch (input.type) {
+    case 'move': {
+      const mailboxId = requiredText(
+        input.mailboxId,
+        `Move action ${index + 1} in “${ruleName}” needs a folder.`,
+      );
+      const mailboxName = requiredText(
+        input.mailboxName,
+        `Move action ${index + 1} in “${ruleName}” needs a folder fallback name.`,
+      );
+      rejectControlCharacters(mailboxId, `Move action ${index + 1} in “${ruleName}”`);
+      rejectControlCharacters(mailboxName, `Move action ${index + 1} in “${ruleName}”`);
+      return { id, type: 'move', mailboxId, mailboxName };
+    }
+    case 'redirect': {
+      const address = requiredText(
+        input.address,
+        `Forward action ${index + 1} in “${ruleName}” needs an email address.`,
+      );
+      rejectControlCharacters(address, `Forward action ${index + 1} in “${ruleName}”`);
+      if (!/^[^\s@]+@[^\s@]+$/.test(address)) {
+        throw new RuleValidationError(`“${address}” is not a valid forwarding address.`);
+      }
+      return { id, type: 'redirect', address };
+    }
+    case 'markRead':
+    case 'star':
+    case 'discard':
+      return { id, type: input.type };
+    default:
+      throw new RuleValidationError(`Action ${index + 1} in “${ruleName}” is not supported.`);
+  }
+}
+
+function compileRuleTest(rule: MailRule): string {
+  const tests = rule.conditions.map(compileCondition);
+  if (tests.length === 1) return tests[0];
+  const keyword = rule.match === 'all' ? 'allof' : 'anyof';
+  return `${keyword} (${tests.join(', ')})`;
+}
+
+function compileCondition(condition: MailRuleCondition): string {
+  const match = `:${condition.operator}`;
+  const value = sieveString(condition.value);
+  switch (condition.field) {
+    case 'from':
+      return `address ${match} "From" ${value}`;
+    case 'to':
+      return `address ${match} "To" ${value}`;
+    case 'toCc':
+      return `address ${match} ["To", "Cc"] ${value}`;
+    case 'subject':
+      return `header ${match} "Subject" ${value}`;
+    case 'header':
+      return `header ${match} ${sieveString(condition.headerName ?? '')} ${value}`;
+  }
+}
+
+function compileAction(
+  action: MailRuleAction,
+  extensions: ReadonlySet<string>,
+  required: Set<string>,
+): string {
+  switch (action.type) {
+    case 'move':
+      requireExtension('fileinto', extensions, required, 'Moving messages');
+      if (extensions.has('mailboxid')) {
+        required.add('mailboxid');
+        // Stalwart currently checks :mailboxid against the RFC 5490 "mailbox"
+        // capability as well. Declare it when advertised so its authoritative
+        // SieveScript/validate call accepts an otherwise RFC 9042 script.
+        if (extensions.has('mailbox')) required.add('mailbox');
+        return `fileinto :mailboxid ${sieveString(action.mailboxId)} ${sieveString(action.mailboxName)};`;
+      }
+      return `fileinto ${sieveString(action.mailboxName)};`;
+    case 'markRead':
+      requireExtension('imap4flags', extensions, required, 'Marking messages as read');
+      return 'addflag "\\\\Seen";';
+    case 'star':
+      requireExtension('imap4flags', extensions, required, 'Starring messages');
+      return 'addflag "\\\\Flagged";';
+    case 'redirect':
+      requireExtension('copy', extensions, required, 'Forwarding a copy');
+      return `redirect :copy ${sieveString(action.address)};`;
+    case 'discard':
+      return 'discard;';
+  }
+}
+
+function requireExtension(
+  extension: string,
+  available: ReadonlySet<string>,
+  required: Set<string>,
+  action: string,
+): void {
+  if (!available.has(extension)) {
+    throw new RuleValidationError(`${action} requires the server’s “${extension}” Sieve extension.`);
+  }
+  required.add(extension);
+}
+
+function sieveString(value: string): string {
+  rejectControlCharacters(value, 'Sieve value');
+  return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function requiredText(value: unknown, message: string): string {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw new RuleValidationError(message);
+  }
+  return value.trim();
+}
+
+function requiredId(value: unknown, label: string, seen: Set<string>): string {
+  const id = requiredText(value, `${label} needs an identifier.`);
+  if (seen.has(id)) throw new RuleValidationError(`${label} has a duplicate identifier.`);
+  seen.add(id);
+  return id;
+}
+
+function rejectControlCharacters(value: string, label: string): void {
+  if (/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/.test(value)) {
+    throw new RuleValidationError(`${label} contains a line break or control character.`);
+  }
+}
+
+function chunkString(value: string, size: number): string[] {
+  const chunks: string[] = [];
+  for (let offset = 0; offset < value.length; offset += size) {
+    chunks.push(value.slice(offset, offset + size));
+  }
+  return chunks;
+}
+
+function encodeBase64Url(bytes: Uint8Array): string {
+  let out = '';
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    out += BASE64URL_ALPHABET[a >> 2];
+    out += BASE64URL_ALPHABET[((a & 3) << 4) | (b >> 4)];
+    if (i + 1 < bytes.length) out += BASE64URL_ALPHABET[((b & 15) << 2) | (c >> 6)];
+    if (i + 2 < bytes.length) out += BASE64URL_ALPHABET[c & 63];
+  }
+  return out;
+}
+
+function decodeBase64Url(value: string): Uint8Array {
+  if (value.length % 4 === 1) throw new Error('invalid base64url length');
+  const bytes: number[] = [];
+  let buffer = 0;
+  let bits = 0;
+  for (const character of value) {
+    const index = BASE64URL_ALPHABET.indexOf(character);
+    if (index < 0) throw new Error('invalid base64url character');
+    buffer = (buffer << 6) | index;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push((buffer >> bits) & 0xff);
+      buffer &= (1 << bits) - 1;
+    }
+  }
+  return new Uint8Array(bytes);
+}
+
+function isRecord(value: unknown): value is Record<string, any> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
diff --git a/src/stores/rules-store.ts b/src/stores/rules-store.ts
new file mode 100644
index 00000000..d9a11a21
--- /dev/null
+++ b/src/stores/rules-store.ts
@@ -0,0 +1,171 @@
+import { defineStore } from 'pinia';
+import { computed, ref } from 'vue';
+
+import { getRepositoryAsync } from '../composables/useRepository';
+import { MUTATION_TYPE } from '../constants/states';
+import {
+  cloneRuleDocument,
+  compileRules,
+  emptyRuleDocument,
+  normalizeRuleDocument,
+} from '../sieve/rules';
+import type { MailRuleDocument, SieveRuleCapabilities } from '../sieve/rules';
+import { useAuthStore } from './auth-store';
+
+interface RuleScriptSummary {
+  id: string;
+  name: string | null;
+  isActive?: boolean;
+}
+
+export interface MailRulesSnapshot {
+  supported: boolean;
+  accountId: string | null;
+  state: string | null;
+  capabilities: SieveRuleCapabilities;
+  scripts: RuleScriptSummary[];
+  managedScript: RuleScriptSummary | null;
+  foreignActiveScript: RuleScriptSummary | null;
+  document: MailRuleDocument;
+  parseError: string | null;
+}
+
+export class MailRulesSaveError extends Error {
+  code: string;
+  detail: any;
+
+  constructor(code: string, message: string, detail: any = null) {
+    super(message);
+    this.name = 'MailRulesSaveError';
+    this.code = code;
+    this.detail = detail;
+  }
+}
+
+export const useRulesStore = defineStore('rules', () => {
+  const authStore = useAuthStore();
+  const loading = ref(false);
+  const saving = ref(false);
+  const error = ref<string | null>(null);
+  const snapshot = ref<MailRulesSnapshot | null>(null);
+
+  const supported = computed(() => snapshot.value?.supported === true);
+  const capabilities = computed<SieveRuleCapabilities>(() =>
+    snapshot.value?.capabilities ?? { sieveExtensions: [] });
+  const foreignActiveScript = computed(() => snapshot.value?.foreignActiveScript ?? null);
+
+  async function load(): Promise<MailRulesSnapshot> {
+    if (authStore.accountId == null) {
+      throw new MailRulesSaveError('notConnected', 'Sign in before managing mail rules.');
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const repo = await getRepositoryAsync();
+      const result = await repo.getMailRules(authStore.accountId) as MailRulesSnapshot;
+      snapshot.value = {
+        ...result,
+        document: normalizeRuleDocument(result?.document ?? emptyRuleDocument()),
+      };
+      return snapshot.value;
+    } catch (cause) {
+      error.value = errorMessage(cause);
+      throw cause;
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function save(
+    input: MailRuleDocument,
+    { takeover = false }: { takeover?: boolean } = {},
+  ): Promise<MailRulesSnapshot> {
+    if (authStore.accountId == null) {
+      throw new MailRulesSaveError('notConnected', 'Sign in before saving mail rules.');
+    }
+    if (!snapshot.value) await load();
+    if (!snapshot.value?.supported) {
+      throw new MailRulesSaveError('sieveUnsupported', 'This account does not support JMAP for Sieve.');
+    }
+    if (snapshot.value.parseError) {
+      throw new MailRulesSaveError('managedScriptUnreadable', snapshot.value.parseError);
+    }
+
+    const document = normalizeRuleDocument(input);
+    // Give immediate editor feedback; the SharedWorker compiles again
+    // against a freshly fetched capability snapshot before uploading.
+    compileRules(document, snapshot.value.capabilities);
+
+    saving.value = true;
+    error.value = null;
+    try {
+      const repo = await getRepositoryAsync();
+      const inserted = await repo.insertPendingMutation({
+        accountId: authStore.accountId,
+        mutationType: MUTATION_TYPE.SET_SIEVE_RULES,
+        targetMessageId: null,
+        requestJson: JSON.stringify({
+          document,
+          expectedState: snapshot.value.state,
+          takeover,
+        }),
+        optimisticPatchJson: null,
+      });
+      const outcome = await repo.runMutation(authStore.accountId, inserted.id);
+      if ((outcome?.failed ?? 0) > 0) {
+        const row = await repo.getPendingMutationError(inserted.id);
+        const detail = parseErrorJson(row?.error_json);
+        const code = detail?.type ?? 'saveFailed';
+        throw new MailRulesSaveError(
+          code,
+          detail?.message ?? 'The server did not save the mail rules.',
+          detail?.result ?? detail,
+        );
+      }
+      return await load();
+    } catch (cause) {
+      error.value = errorMessage(cause);
+      throw cause;
+    } finally {
+      saving.value = false;
+    }
+  }
+
+  function freshDocument(): MailRuleDocument {
+    return cloneRuleDocument(snapshot.value?.document ?? emptyRuleDocument());
+  }
+
+  function $reset() {
+    loading.value = false;
+    saving.value = false;
+    error.value = null;
+    snapshot.value = null;
+  }
+
+  return {
+    loading,
+    saving,
+    error,
+    snapshot,
+    supported,
+    capabilities,
+    foreignActiveScript,
+    load,
+    save,
+    freshDocument,
+    $reset,
+  };
+});
+
+function parseErrorJson(value: unknown): any {
+  if (typeof value !== 'string' || value.length === 0) return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
diff --git a/src/sync/backends/jmap/backend.ts b/src/sync/backends/jmap/backend.ts
index a66a4f66f4902df08f7b568060fe499ebbed6218..a585433aa5bf2540e9768c7a29d70f2c99817d47 100644
GIT binary patch
literal 90059
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

literal 90915
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

diff --git a/src/sync/backends/jmap/outbox/index.ts b/src/sync/backends/jmap/outbox/index.ts
index 961e2ae8..7a815b5a 100644
--- a/src/sync/backends/jmap/outbox/index.ts
+++ b/src/sync/backends/jmap/outbox/index.ts
@@ -31,6 +31,8 @@
  *   'createEmails'     Email/set create of ready-made emails into one
  *                      mailbox, checkpointed (at-most-once) and
  *                      reconciled like a copy (kanban seed)
+ *   'setSieveRules'    SieveScript upload, validation, and activation
+ *                      through JMAP for Sieve (RFC 9661)
  *
  * Move and destroy delegate the cache effect to the protocol-neutral
  * OUTBOX_APPLY_MOVE_BATCH / OUTBOX_APPLY_DESTROY_BATCH DB handlers,
@@ -94,6 +96,7 @@ import { runPushSettings } from './operations/settings';
 import { runPushContactsTrash } from './operations/contacts-trash';
 import { runUpdateMailbox } from './operations/update-mailbox';
 import { toProcessResult } from './send-outcome';
+import { runSetSieveRules } from '../sieve';
 
 export { applySendLocally } from './send-apply';
 export { MUTATION_TYPES };
@@ -170,7 +173,19 @@ export async function processMutationRow({
       })
     : [];
   const currentRow = currentRows[0] ?? row;
-  const request = JSON.parse(currentRow.request_json);
+  let request;
+  try {
+    request = JSON.parse(currentRow.request_json);
+  } catch {
+    return {
+      ok: false,
+      error: {
+        type: 'invalidArguments',
+        message: 'The durable mutation payload is not valid JSON.',
+        terminal: true,
+      },
+    };
+  }
   switch (currentRow.mutation_type) {
     case MUTATION_TYPES.SET_KEYWORDS:
       return runSetKeywords({ transport, handlers, row, request, useWebSocket });
@@ -255,6 +270,8 @@ export async function processMutationRow({
       return runPushSettings({ transport, account, handlers, useWebSocket });
     case MUTATION_TYPES.PUSH_CONTACTS_TRASH:
       return runPushContactsTrash({ transport, account, handlers, useWebSocket });
+    case MUTATION_TYPES.SET_SIEVE_RULES:
+      return runSetSieveRules({ transport, account, request, useWebSocket });
     default:
       return {
         ok: false,
diff --git a/src/sync/backends/jmap/sieve.ts b/src/sync/backends/jmap/sieve.ts
new file mode 100644
index 00000000..2de4684d
--- /dev/null
+++ b/src/sync/backends/jmap/sieve.ts
@@ -0,0 +1,345 @@
+import {
+  compileRules,
+  emptyRuleDocument,
+  isManagedRulesScript,
+  MANAGED_SCRIPT_NAME,
+  normalizeRuleDocument,
+  parseManagedRules,
+  RuleValidationError,
+  SIEVE_CAPABILITY,
+  uniqueManagedScriptName,
+} from '../../../sieve/rules';
+import type { MailRuleDocument, SieveRuleCapabilities } from '../../../sieve/rules';
+import { JMAP_CAPS } from './transport';
+import { callJmap, pickResponse, requireResponse } from './invoke';
+
+interface SieveScriptRecord {
+  id: string;
+  name: string | null;
+  blobId: string;
+  isActive: boolean;
+}
+
+export interface MailRulesSnapshot {
+  supported: boolean;
+  accountId: string | null;
+  state: string | null;
+  capabilities: SieveRuleCapabilities;
+  scripts: Array<{ id: string; name: string | null; isActive: boolean }>;
+  managedScript: { id: string; name: string | null; isActive: boolean } | null;
+  foreignActiveScript: { id: string; name: string | null } | null;
+  document: MailRuleDocument;
+  parseError: string | null;
+}
+
+interface SieveContext {
+  accountId: string;
+  capabilities: SieveRuleCapabilities;
+}
+
+export async function getMailRules({
+  transport,
+  account,
+  useWebSocket = false,
+}: {
+  transport: any;
+  account: { remote_account_id: string };
+  useWebSocket?: boolean;
+}): Promise<MailRulesSnapshot> {
+  const context = await sieveContext(transport, account);
+  if (!context) return unsupportedSnapshot();
+
+  const raw = await callJmap(transport, {
+    using: [JMAP_CAPS.CORE, JMAP_CAPS.SIEVE],
+    methodCalls: [['SieveScript/get', {
+      accountId: context.accountId,
+      ids: null,
+      properties: ['id', 'name', 'blobId', 'isActive'],
+    }, 'sieve-get']],
+    useWebSocket,
+  });
+  const response = requireResponse(raw, 'SieveScript/get');
+  const scripts = normalizeScriptList(response.list);
+  const managed: Array<{ script: SieveScriptRecord; document: MailRuleDocument }> = [];
+  const malformedManaged: string[] = [];
+
+  for (const script of scripts) {
+    const bytes = await transport.download({
+      accountId: context.accountId,
+      blobId: script.blobId,
+      type: 'application/sieve',
+      name: `${script.name || 'script'}.siv`,
+    });
+    const source = new TextDecoder().decode(bytes);
+    if (!isManagedRulesScript(source)) continue;
+    try {
+      const document = parseManagedRules(source);
+      if (document) managed.push({ script, document });
+    } catch (error) {
+      malformedManaged.push(errorMessage(error));
+    }
+  }
+
+  let parseError: string | null = null;
+  if (malformedManaged.length > 0) {
+    parseError = malformedManaged[0];
+  } else if (managed.length > 1) {
+    parseError = 'More than one Stormbox-managed rule script exists. Resolve the duplicate scripts before saving.';
+  }
+  const selected = managed.find((entry) => entry.script.isActive) ?? managed[0] ?? null;
+  const active = scripts.find((script) => script.isActive) ?? null;
+  const foreignActive = active && active.id !== selected?.script.id ? active : null;
+
+  return {
+    supported: true,
+    accountId: context.accountId,
+    state: typeof response.state === 'string' ? response.state : null,
+    capabilities: context.capabilities,
+    scripts: scripts.map(publicScript),
+    managedScript: selected ? publicScript(selected.script) : null,
+    foreignActiveScript: foreignActive
+      ? { id: foreignActive.id, name: foreignActive.name }
+      : null,
+    document: selected?.document ?? emptyRuleDocument(),
+    parseError,
+  };
+}
+
+export async function runSetSieveRules({
+  transport,
+  account,
+  request,
+  useWebSocket = false,
+}: {
+  transport: any;
+  account: { remote_account_id: string };
+  request: any;
+  useWebSocket?: boolean;
+}): Promise<{ ok: boolean; error?: any; result?: any; response?: any }> {
+  let document: MailRuleDocument;
+  try {
+    document = normalizeRuleDocument(request?.document);
+  } catch (error) {
+    return terminalError('invalidRules', errorMessage(error));
+  }
+
+  let snapshot: MailRulesSnapshot;
+  try {
+    snapshot = await getMailRules({ transport, account, useWebSocket });
+  } catch (error) {
+    return { ok: false, error: { type: 'transport', message: errorMessage(error) } };
+  }
+  if (!snapshot.supported || !snapshot.accountId) {
+    return terminalError('sieveUnsupported', 'This account does not advertise JMAP for Sieve.');
+  }
+  if (snapshot.parseError) {
+    return terminalError('managedScriptUnreadable', snapshot.parseError);
+  }
+  if (typeof request?.expectedState === 'string' && request.expectedState !== snapshot.state) {
+    return terminalError(
+      'sieveStateMismatch',
+      'The server’s Sieve scripts changed after this editor loaded. Reload before saving.',
+    );
+  }
+  if (snapshot.foreignActiveScript && request?.takeover !== true) {
+    return terminalError(
+      'foreignScriptActive',
+      'Another Sieve script is active. Explicit confirmation is required before Stormbox activates its script.',
+      { foreignActiveScript: snapshot.foreignActiveScript },
+    );
+  }
+
+  let source: string;
+  try {
+    source = compileRules(document, snapshot.capabilities);
+  } catch (error) {
+    return terminalError('invalidRules', errorMessage(error));
+  }
+
+  let upload;
+  try {
+    upload = await transport.upload({
+      accountId: snapshot.accountId,
+      type: 'application/sieve',
+      body: new TextEncoder().encode(source),
+    });
+  } catch (error) {
+    return { ok: false, error: { type: 'transport', message: errorMessage(error) } };
+  }
+  if (!upload?.blobId) {
+    return { ok: false, error: { type: 'noResponse', message: 'The Sieve upload returned no blob id.' } };
+  }
+
+  let validationRaw;
+  try {
+    validationRaw = await callJmap(transport, {
+      using: [JMAP_CAPS.CORE, JMAP_CAPS.SIEVE],
+      methodCalls: [['SieveScript/validate', {
+        accountId: snapshot.accountId,
+        blobId: upload.blobId,
+      }, 'sieve-validate']],
+      useWebSocket,
+    });
+  } catch (error) {
+    return { ok: false, error: { type: 'transport', message: errorMessage(error) } };
+  }
+  const validation = pickResponse(validationRaw, 'SieveScript/validate');
+  if (!validation) {
+    return methodFailure(validationRaw, 'SieveScript/validate');
+  }
+  if (validation.error) {
+    return terminalError(
+      'invalidSieve',
+      validation.error.description ?? 'The server rejected the generated Sieve script.',
+      { validationError: validation.error },
+    );
+  }
+
+  const managed = snapshot.managedScript;
+  const creationId = 'stormbox';
+  const setRequest: any = {
+    accountId: snapshot.accountId,
+  };
+  if (typeof snapshot.state === 'string') setRequest.ifInState = snapshot.state;
+  if (managed) {
+    setRequest.update = { [managed.id]: { blobId: upload.blobId } };
+    setRequest.onSuccessActivateScript = managed.id;
+  } else {
+    setRequest.create = {
+      [creationId]: {
+        name: uniqueManagedScriptName(snapshot.scripts.map((script) => script.name)),
+        blobId: upload.blobId,
+      },
+    };
+    setRequest.onSuccessActivateScript = `#${creationId}`;
+  }
+
+  let setRaw;
+  try {
+    setRaw = await callJmap(transport, {
+      using: [JMAP_CAPS.CORE, JMAP_CAPS.SIEVE],
+      methodCalls: [['SieveScript/set', setRequest, 'sieve-set']],
+      useWebSocket,
+    });
+  } catch (error) {
+    return { ok: false, error: { type: 'transport', message: errorMessage(error) } };
+  }
+  const setResponse = pickResponse(setRaw, 'SieveScript/set');
+  if (!setResponse) return methodFailure(setRaw, 'SieveScript/set');
+
+  const setError = managed
+    ? setResponse.notUpdated?.[managed.id]
+    : setResponse.notCreated?.[creationId];
+  if (setError) {
+    const type = setError.type === 'stateMismatch' ? 'sieveStateMismatch' : (setError.type ?? 'sieveSetFailed');
+    return terminalError(type, setError.description ?? 'The server did not save the Sieve script.', {
+      setError,
+    });
+  }
+
+  const scriptId = managed?.id ?? setResponse.created?.[creationId]?.id ?? null;
+  if (!scriptId) {
+    return { ok: false, error: { type: 'noResponse', message: 'The server did not report the saved script.' } };
+  }
+  return {
+    ok: true,
+    response: setRaw,
+    result: {
+      scriptId,
+      state: setResponse.newState ?? snapshot.state,
+    },
+  };
+}
+
+async function sieveContext(
+  transport: any,
+  account: { remote_account_id: string },
+): Promise<SieveContext | null> {
+  const session = transport.session ?? await transport.fetchSession();
+  if (!session?.capabilities?.[SIEVE_CAPABILITY]) return null;
+  const accountId = session.primaryAccounts?.[SIEVE_CAPABILITY]
+    ?? account.remote_account_id;
+  const accountCapability = session.accounts?.[accountId]?.accountCapabilities?.[SIEVE_CAPABILITY];
+  if (!accountCapability) return null;
+  return {
+    accountId,
+    capabilities: {
+      sieveExtensions: Array.isArray(accountCapability.sieveExtensions)
+        ? accountCapability.sieveExtensions.filter((item) => typeof item === 'string')
+        : [],
+      maxSizeScript: finiteOrNull(accountCapability.maxSizeScript),
+      maxNumberRedirects: finiteOrNull(accountCapability.maxNumberRedirects),
+    },
+  };
+}
+
+function normalizeScriptList(value: unknown): SieveScriptRecord[] {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((script) => {
+    if (
+      !isRecord(script)
+      || typeof script.id !== 'string'
+      || typeof script.blobId !== 'string'
+    ) return [];
+    return [{
+      id: script.id,
+      name: typeof script.name === 'string' ? script.name : null,
+      blobId: script.blobId,
+      isActive: script.isActive === true,
+    }];
+  });
+}
+
+function isRecord(value: unknown): value is Record<string, any> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function publicScript(script: SieveScriptRecord) {
+  return { id: script.id, name: script.name, isActive: script.isActive };
+}
+
+function unsupportedSnapshot(): MailRulesSnapshot {
+  return {
+    supported: false,
+    accountId: null,
+    state: null,
+    capabilities: { sieveExtensions: [] },
+    scripts: [],
+    managedScript: null,
+    foreignActiveScript: null,
+    document: emptyRuleDocument(),
+    parseError: null,
+  };
+}
+
+function finiteOrNull(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+function methodFailure(raw: any, method: string) {
+  const failure = pickResponse(raw, 'error');
+  const serverType = failure?.type ?? 'noResponse';
+  const type = serverType === 'stateMismatch' ? 'sieveStateMismatch' : serverType;
+  const message = failure?.description ?? `${method} returned no response.`;
+  if (serverType === 'stateMismatch' || serverType === 'invalidArguments') {
+    return terminalError(type, message, { methodError: failure ?? null });
+  }
+  return { ok: false, error: { type, message, methodError: failure ?? null } };
+}
+
+function terminalError(type: string, message: string, result?: any) {
+  return {
+    ok: false,
+    error: {
+      type,
+      message,
+      terminal: true,
+      ...(result === undefined ? {} : { result }),
+    },
+  };
+}
+
+function errorMessage(error: unknown): string {
+  if (error instanceof RuleValidationError || error instanceof Error) return error.message;
+  return String(error);
+}
diff --git a/src/sync/backends/jmap/transport.ts b/src/sync/backends/jmap/transport.ts
index de072c67..47c73468 100644
--- a/src/sync/backends/jmap/transport.ts
+++ b/src/sync/backends/jmap/transport.ts
@@ -28,6 +28,7 @@ const JMAP_SUBMISSION = 'urn:ietf:params:jmap:submission';
 const JMAP_CONTACTS = 'urn:ietf:params:jmap:contacts';
 const JMAP_QUOTA = 'urn:ietf:params:jmap:quota';
 const JMAP_FILENODE = 'urn:ietf:params:jmap:filenode';
+const JMAP_SIEVE = 'urn:ietf:params:jmap:sieve';
 const JMAP_WEBSOCKET_CAP = 'urn:ietf:params:jmap:websocket';
 
 export const JMAP_CAPS = Object.freeze({
@@ -37,6 +38,7 @@ export const JMAP_CAPS = Object.freeze({
   CONTACTS: JMAP_CONTACTS,
   QUOTA: JMAP_QUOTA,
   FILENODE: JMAP_FILENODE,
+  SIEVE: JMAP_SIEVE,
   WEBSOCKET: JMAP_WEBSOCKET_CAP,
 });
 
diff --git a/src/sync/sync-host.ts b/src/sync/sync-host.ts
index a501325f..24ff1833 100644
--- a/src/sync/sync-host.ts
+++ b/src/sync/sync-host.ts
@@ -266,6 +266,12 @@ export function makeSyncRpcHandlers({
     [DB_RPC.SYNC_ENSURE_FOLDER_INDEX]: async ({ accountId, folderId, options }) =>
       syncClient.ensureFolderIndex(accountId, folderId, options ?? {}),
 
+    [DB_RPC.SYNC_GET_MAIL_RULES]: async ({ accountId }) => {
+      const backend = backends.get(accountId);
+      if (!backend) throw new Error(`No JMAP backend registered for account ${accountId}`);
+      return backend.getMailRules();
+    },
+
     [DB_RPC.SYNC_DRAIN_OUTBOX]: async ({ accountId, limit = 25 }) => {
       const backend = backends.get(accountId);
       if (!backend) {
diff --git a/tests/e2e/mail-rules.spec.js b/tests/e2e/mail-rules.spec.js
new file mode 100644
index 00000000..3937007b
--- /dev/null
+++ b/tests/e2e/mail-rules.spec.js
@@ -0,0 +1,155 @@
+import {
+  connectJmap,
+  downloadBlob,
+  jmapRequest,
+  pickResponse,
+} from './helpers/jmap-client.js';
+import {
+  attachConsoleTail,
+  consoleLinesFor,
+  expect,
+  resetSharedSession,
+  test,
+} from './helpers/shared-session.js';
+import {
+  localStackEnabled,
+  skipLocalStackMessage,
+} from './helpers/stack-env.js';
+import { waitForPendingMutations } from './helpers/ui.js';
+
+test.skip(!localStackEnabled, skipLocalStackMessage);
+
+const CORE = 'urn:ietf:params:jmap:core';
+const SIEVE = 'urn:ietf:params:jmap:sieve';
+const MANAGED_MARKER = '# stormbox-managed: mail-rules/v1';
+const RULE_NAME = 'MailRulesE2E visual rule';
+const CONDITION_VALUE = 'MailRulesE2E';
+
+async function sieveRequest(jmap, calls) {
+  return jmapRequest(jmap, calls, [CORE, SIEVE]);
+}
+
+async function listScripts(jmap) {
+  const payload = await sieveRequest(jmap, [[
+    'SieveScript/get',
+    {
+      accountId: jmap.accountId,
+      ids: null,
+      properties: ['id', 'name', 'blobId', 'isActive'],
+    },
+    'getScripts',
+  ]]);
+  return pickResponse(payload, 'SieveScript/get')?.list ?? [];
+}
+
+async function restoreScripts(jmap, before) {
+  const current = await listScripts(jmap);
+  const beforeById = new Map(before.map((script) => [script.id, script]));
+  const currentById = new Map(current.map((script) => [script.id, script]));
+  const update = {};
+  for (const script of before) {
+    const live = currentById.get(script.id);
+    if (live && live.blobId !== script.blobId) {
+      update[script.id] = { blobId: script.blobId };
+    }
+  }
+  const activeBefore = before.find((script) => script.isActive)?.id ?? null;
+  await sieveRequest(jmap, [[
+    'SieveScript/set',
+    {
+      accountId: jmap.accountId,
+      ...(Object.keys(update).length > 0 ? { update } : {}),
+      onSuccessActivateScript: activeBefore,
+    },
+    'restoreScripts',
+  ]]);
+
+  const createdIds = current
+    .map((script) => script.id)
+    .filter((id) => !beforeById.has(id));
+  if (createdIds.length > 0) {
+    await sieveRequest(jmap, [[
+      'SieveScript/set',
+      {
+        accountId: jmap.accountId,
+        destroy: createdIds,
+        onSuccessActivateScript: activeBefore,
+      },
+      'removeCreatedScripts',
+    ]]);
+  }
+}
+
+async function openRulesDialog(page) {
+  await page.locator('.account-menu__button').click();
+  await page.getByRole('menuitem', { name: 'Mail Rules' }).click();
+  const dialog = page.getByRole('dialog', { name: 'Mail Rules' });
+  await expect(dialog).toBeVisible({ timeout: 10_000 });
+  await expect(dialog).not.toContainText('Loading server rules…', { timeout: 15_000 });
+  return dialog;
+}
+
+test.describe('JMAP Sieve mail rules e2e', () => {
+  test.beforeEach(async ({ sharedPage }) => {
+    await resetSharedSession(sharedPage);
+  });
+
+  test('visual rule round-trips through the outbox and active server script', async ({ sharedPage: page }, testInfo) => {
+    const jmap = await connectJmap();
+    expect(jmap.session.capabilities?.[SIEVE]).toBeTruthy();
+    expect(jmap.session.accounts?.[jmap.accountId]?.accountCapabilities?.[SIEVE]).toBeTruthy();
+    const before = await listScripts(jmap);
+
+    try {
+      let dialog = await openRulesDialog(page);
+      await expect(dialog).not.toContainText('server-side rules are unavailable');
+      await dialog.locator('[data-mail-rules-add]').click();
+      const rule = dialog.locator('.mail-rule').last();
+      await rule.locator('input[aria-label="Rule name"]').fill(RULE_NAME);
+      await rule.locator('input[aria-label="Condition value"]').fill(CONDITION_VALUE);
+      await dialog.locator('[data-mail-rules-save]').click();
+
+      const takeover = page.getByRole('alertdialog', { name: 'Activate Stormbox rules?' });
+      if (await takeover.count()) {
+        await takeover.locator('[data-mail-rules-confirm]').click();
+      }
+
+      await expect(dialog).toContainText('Rules saved, validated, and activated.', { timeout: 20_000 });
+      await waitForPendingMutations(page);
+      await expect.poll(
+        async () => page.evaluate(async () => {
+          const rows = await globalThis.__repo.call('db.query', {
+            sql: `SELECT COUNT(*) AS count
+                    FROM pending_mutations
+                   WHERE mutation_type = 'setSieveRules'`,
+            params: [],
+          });
+          return Number(rows?.[0]?.count ?? -1);
+        }),
+        { timeout: 10_000, message: 'Sieve mutation should leave no durable outbox row' },
+      ).toBe(0);
+
+      const scripts = await listScripts(jmap);
+      const active = scripts.find((script) => script.isActive);
+      expect(active).toBeTruthy();
+      const source = (await downloadBlob(jmap, {
+        blobId: active.blobId,
+        type: 'application/sieve',
+        name: 'mail-rules.siv',
+      })).toString('utf8');
+      expect(source).toContain(MANAGED_MARKER);
+      expect(source).toContain(CONDITION_VALUE);
+
+      await dialog.getByRole('button', { name: 'Close', exact: true }).click();
+      await expect(dialog).toBeHidden({ timeout: 5_000 });
+      dialog = await openRulesDialog(page);
+      const savedRule = dialog.locator('.mail-rule').filter({ hasText: RULE_NAME });
+      await expect(savedRule.locator('input[aria-label="Rule name"]')).toHaveValue(RULE_NAME);
+      await expect(savedRule.locator('input[aria-label="Condition value"]')).toHaveValue(CONDITION_VALUE);
+      await dialog.getByRole('button', { name: 'Close', exact: true }).click();
+    } finally {
+      await restoreScripts(jmap, before);
+      await attachConsoleTail(testInfo, consoleLinesFor(page));
+    }
+  });
+});
diff --git a/tests/unit/components/app-layout.test.ts b/tests/unit/components/app-layout.test.ts
index 3442ff5c..22baaae6 100644
--- a/tests/unit/components/app-layout.test.ts
+++ b/tests/unit/components/app-layout.test.ts
@@ -859,6 +859,10 @@ describe('App mail layout', () => {
     expect(settingsLink.attributes('href')).toBe(ACCOUNTS_URL);
     expect(settingsLink.text()).toContain('Account Settings');
 
+    const rulesButton = avatarMenu.findAll('button.account-menu__item')
+      .find((button) => button.text().includes('Mail Rules'));
+    expect(rulesButton?.text()).toContain('Mail Rules');
+
     const logoutButton = avatarMenu.findAll('button.account-menu__item')
       .find((button) => button.text().includes('Log Out'));
     if (!logoutButton) throw new Error('Could not find Log Out account menu item');
diff --git a/tests/unit/components/mail-rules-dialog.test.ts b/tests/unit/components/mail-rules-dialog.test.ts
new file mode 100644
index 00000000..6cf3eac1
--- /dev/null
+++ b/tests/unit/components/mail-rules-dialog.test.ts
@@ -0,0 +1,159 @@
+// @vitest-environment happy-dom
+
+import {
+  beforeEach, describe, expect, it, vi,
+} from 'vitest';
+import { mount, flushPromises } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+
+vi.mock('../../../src/services/auth', () => ({
+  initOidc: async () => null,
+  getOidc: () => null,
+}));
+
+import MailRulesDialog from '../../../src/components/MailRulesDialog.vue';
+import {
+  __resetRepositoryForTests,
+  __setRepositoryForTests,
+} from '../../../src/composables/useRepository';
+import { useAuthStore } from '../../../src/stores/auth-store';
+import { useMailStore } from '../../../src/stores/mail-store';
+
+function snapshot(overrides: Record<string, unknown> = {}) {
+  return {
+    supported: true,
+    accountId: 'remote-1',
+    state: 'sieve-state-1',
+    capabilities: {
+      sieveExtensions: ['copy', 'fileinto', 'imap4flags', 'mailboxid'],
+      maxSizeScript: 64_000,
+      maxNumberRedirects: 4,
+    },
+    scripts: [],
+    managedScript: null,
+    foreignActiveScript: null,
+    document: { version: 1, rules: [] },
+    parseError: null,
+    ...overrides,
+  };
+}
+
+function folder(id: number, overrides: Record<string, unknown> = {}) {
+  return {
+    id,
+    account_id: 1,
+    remote_id: `mailbox-${id}`,
+    parent_id: null,
+    name: `Folder ${id}`,
+    role: null,
+    sort_order: 0,
+    is_deleted: 0,
+    is_subscribed: 1,
+    total_emails: 0,
+    unread_emails: 0,
+    rights_json: null,
+    may_add_items: 1,
+    ...overrides,
+  } as any;
+}
+
+function mountDialog() {
+  return mount(MailRulesDialog, {
+    global: { stubs: { teleport: true } },
+  });
+}
+
+function installRepo({ foreign = false } = {}) {
+  let serverSnapshot = snapshot(foreign ? {
+    scripts: [{ id: 'foreign', name: 'Handwritten filters', isActive: true }],
+    foreignActiveScript: { id: 'foreign', name: 'Handwritten filters' },
+  } : {});
+  let pendingRequest: any = null;
+  const repo = {
+    getMailRules: vi.fn(async () => structuredClone(serverSnapshot)),
+    insertPendingMutation: vi.fn(async (input) => {
+      pendingRequest = JSON.parse(input.requestJson);
+      return { id: 72 };
+    }),
+    runMutation: vi.fn(async () => {
+      serverSnapshot = snapshot({
+        state: 'sieve-state-2',
+        document: pendingRequest.document,
+        scripts: [{ id: 'managed', name: 'Stormbox Mail Rules', isActive: true }],
+        managedScript: { id: 'managed', name: 'Stormbox Mail Rules', isActive: true },
+      });
+      return { attempted: 1, succeeded: 1, failed: 0 };
+    }),
+    getPendingMutationError: vi.fn(),
+  };
+  __setRepositoryForTests(repo);
+  return repo;
+}
+
+beforeEach(() => {
+  setActivePinia(createPinia());
+  __resetRepositoryForTests();
+  useAuthStore().accountId = 1;
+  useMailStore().folders = [
+    folder(1, { name: 'Projects' }),
+    folder(2, { name: 'Receipts', parent_id: 1 }),
+  ];
+});
+
+describe('MailRulesDialog', () => {
+  it('creates and saves a visual rule through the durable mutation path', async () => {
+    const repo = installRepo();
+    const wrapper = mountDialog();
+    await flushPromises();
+
+    expect(wrapper.text()).toContain('No rules yet');
+    await wrapper.get('[data-mail-rules-add]').trigger('click');
+    await wrapper.get('input[aria-label="Condition value"]').setValue('newsletter');
+    await wrapper.get('[data-mail-rules-save]').trigger('click');
+    await flushPromises();
+
+    expect(repo.insertPendingMutation).toHaveBeenCalledTimes(1);
+    const queued = JSON.parse(repo.insertPendingMutation.mock.calls[0][0].requestJson);
+    expect(queued.takeover).toBe(false);
+    expect(queued.document.rules).toHaveLength(1);
+    expect(queued.document.rules[0]).toMatchObject({
+      name: 'New rule',
+      conditions: [{ field: 'from', operator: 'contains', value: 'newsletter' }],
+      actions: [{ type: 'markRead' }],
+    });
+    expect(wrapper.text()).toContain('Rules saved, validated, and activated.');
+  });
+
+  it('requires confirmation before replacing a foreign active script', async () => {
+    const repo = installRepo({ foreign: true });
+    const wrapper = mountDialog();
+    await flushPromises();
+
+    expect(wrapper.text()).toContain('Handwritten filters');
+    await wrapper.get('[data-mail-rules-add]').trigger('click');
+    await wrapper.get('input[aria-label="Condition value"]').setValue('invoice');
+    await wrapper.get('[data-mail-rules-save]').trigger('click');
+    await flushPromises();
+
+    expect(wrapper.get('[role="alertdialog"]').text()).toContain('Activate Stormbox rules?');
+    expect(repo.insertPendingMutation).not.toHaveBeenCalled();
+
+    await wrapper.get('[data-mail-rules-confirm]').trigger('click');
+    await flushPromises();
+    const queued = JSON.parse(repo.insertPendingMutation.mock.calls[0][0].requestJson);
+    expect(queued.takeover).toBe(true);
+  });
+
+  it('confirms before discarding an edited draft', async () => {
+    installRepo();
+    const wrapper = mountDialog();
+    await flushPromises();
+
+    await wrapper.get('[data-mail-rules-add]').trigger('click');
+    await wrapper.get('button[aria-label="Close mail rules"]').trigger('click');
+    expect(wrapper.get('[role="alertdialog"]').text()).toContain('Discard unsaved changes?');
+
+    await wrapper.get('[data-mail-rules-confirm]').trigger('click');
+    expect(wrapper.emitted('close')).toHaveLength(1);
+  });
+});
diff --git a/tests/unit/sieve/rules.test.ts b/tests/unit/sieve/rules.test.ts
new file mode 100644
index 00000000..59a7d95c
--- /dev/null
+++ b/tests/unit/sieve/rules.test.ts
@@ -0,0 +1,175 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  compileRules,
+  isManagedRulesScript,
+  MANAGED_SCRIPT_MARKER,
+  parseManagedRules,
+  RuleValidationError,
+  uniqueManagedScriptName,
+} from '../../../src/sieve/rules';
+import type { MailRuleDocument, SieveRuleCapabilities } from '../../../src/sieve/rules';
+
+const ALL_CAPABILITIES: SieveRuleCapabilities = {
+  sieveExtensions: ['copy', 'fileinto', 'imap4flags', 'mailbox', 'mailboxid'],
+  maxSizeScript: 100_000,
+  maxNumberRedirects: 4,
+};
+
+function document(): MailRuleDocument {
+  return {
+    version: 1,
+    rules: [{
+      id: 'rule-1',
+      name: 'File important mail',
+      enabled: true,
+      match: 'all',
+      conditions: [
+        {
+          id: 'condition-1', field: 'from', operator: 'contains', value: '@example.com',
+        },
+        {
+          id: 'condition-2', field: 'subject', operator: 'matches', value: '*invoice*',
+        },
+      ],
+      actions: [
+        {
+          id: 'action-1', type: 'move', mailboxId: 'mailbox-42', mailboxName: 'Finance/Invoices',
+        },
+        { id: 'action-2', type: 'markRead' },
+        { id: 'action-3', type: 'star' },
+        { id: 'action-4', type: 'redirect', address: 'archive@example.net' },
+      ],
+      stopProcessing: true,
+    }],
+  };
+}
+
+describe('mail-rule Sieve compiler', () => {
+  it('emits a capability-aware script and round-trips the visual model', () => {
+    const input = document();
+    const source = compileRules(input, ALL_CAPABILITIES);
+
+    expect(source).toContain(MANAGED_SCRIPT_MARKER);
+    expect(source).toContain('require ["copy", "fileinto", "imap4flags", "mailbox", "mailboxid"];');
+    expect(source).toContain('if allof (address :contains "From" "@example.com", header :matches "Subject" "*invoice*") {');
+    expect(source).toContain('fileinto :mailboxid "mailbox-42" "Finance/Invoices";');
+    expect(source).toContain('addflag "\\\\Seen";');
+    expect(source).toContain('addflag "\\\\Flagged";');
+    expect(source).toContain('redirect :copy "archive@example.net";');
+    expect(source).toContain('  stop;');
+    expect(isManagedRulesScript(source)).toBe(true);
+    expect(parseManagedRules(source)).toEqual(input);
+  });
+
+  it('escapes user strings and omits disabled rules from executable code', () => {
+    const input = document();
+    input.rules[0].conditions = [{
+      id: 'condition-escape',
+      field: 'subject',
+      operator: 'contains',
+      value: 'say "hi" \\ there',
+    }];
+    input.rules.push({
+      id: 'rule-disabled',
+      name: 'Disabled executable marker',
+      enabled: false,
+      match: 'all',
+      conditions: [{
+        id: 'condition-disabled', field: 'subject', operator: 'is', value: 'DO-NOT-EMIT',
+      }],
+      actions: [{ id: 'action-disabled', type: 'discard' }],
+      stopProcessing: true,
+    });
+
+    const source = compileRules(input, ALL_CAPABILITIES);
+    expect(source).toContain('header :contains "Subject" "say \\"hi\\" \\\\ there"');
+    expect(source).not.toContain('# Rule: Disabled executable marker');
+    expect(parseManagedRules(source)?.rules[1].conditions[0].value).toBe('DO-NOT-EMIT');
+  });
+
+  it('uses a path-only fallback when mailboxid is unavailable', () => {
+    const source = compileRules(document(), {
+      ...ALL_CAPABILITIES,
+      sieveExtensions: ['copy', 'fileinto', 'imap4flags'],
+    });
+    expect(source).toContain('fileinto "Finance/Invoices";');
+    expect(source).not.toContain(':mailboxid');
+  });
+
+  it('declares Stalwart’s advertised mailbox compatibility capability for mailboxid', () => {
+    const input = document();
+    input.rules[0].actions = [input.rules[0].actions[0]];
+
+    const source = compileRules(input, {
+      ...ALL_CAPABILITIES,
+      sieveExtensions: ['fileinto', 'mailbox', 'mailboxid'],
+    });
+    expect(source).toContain('require ["fileinto", "mailbox", "mailboxid"];');
+
+    const standardsOnlySource = compileRules(input, {
+      ...ALL_CAPABILITIES,
+      sieveExtensions: ['fileinto', 'mailboxid'],
+    });
+    expect(standardsOnlySource).toContain('require ["fileinto", "mailboxid"];');
+    expect(standardsOnlySource).not.toContain('"mailbox",');
+  });
+
+  it('rejects missing action extensions, invalid headers, and oversized scripts', () => {
+    expect(() => compileRules(document(), { sieveExtensions: [] }))
+      .toThrow(/fileinto/);
+
+    const invalidHeader = document();
+    invalidHeader.rules[0].conditions = [{
+      id: 'condition-header',
+      field: 'header',
+      headerName: 'Bad:Header',
+      operator: 'contains',
+      value: 'x',
+    }];
+    expect(() => compileRules(invalidHeader, ALL_CAPABILITIES))
+      .toThrow(RuleValidationError);
+
+    expect(() => compileRules(document(), {
+      ...ALL_CAPABILITIES,
+      maxSizeScript: 10,
+    })).toThrow(/server limit is 10/);
+  });
+
+  it('checks redirect limits along executable paths', () => {
+    const input = document();
+    input.rules[0].actions = [{
+      id: 'redirect-1', type: 'redirect', address: 'one@example.net',
+    }];
+    input.rules.push({
+      id: 'rule-2',
+      name: 'Second redirect',
+      enabled: true,
+      match: 'all',
+      conditions: [{
+        id: 'condition-2a', field: 'subject', operator: 'contains', value: 'two',
+      }],
+      actions: [{ id: 'redirect-2', type: 'redirect', address: 'two@example.net' }],
+      stopProcessing: false,
+    });
+
+    expect(() => compileRules(input, { ...ALL_CAPABILITIES, maxNumberRedirects: 1 }))
+      .not.toThrow();
+
+    input.rules[0].stopProcessing = false;
+    expect(() => compileRules(input, { ...ALL_CAPABILITIES, maxNumberRedirects: 1 }))
+      .toThrow(/can redirect 2 messages/);
+  });
+
+  it('rejects corrupt managed metadata without claiming foreign scripts', () => {
+    expect(parseManagedRules('require ["fileinto"];\r\nkeep;')).toBeNull();
+    expect(() => parseManagedRules(`${MANAGED_SCRIPT_MARKER}\r\n# stormbox-data: !!!`))
+      .toThrow(/metadata is missing or malformed/);
+  });
+
+  it('chooses a non-conflicting managed script name', () => {
+    expect(uniqueManagedScriptName(['Personal filters'])).toBe('Stormbox Mail Rules');
+    expect(uniqueManagedScriptName(['Stormbox Mail Rules', 'Stormbox Mail Rules 2']))
+      .toBe('Stormbox Mail Rules 3');
+  });
+});
diff --git a/tests/unit/stores/rules-store.test.ts b/tests/unit/stores/rules-store.test.ts
new file mode 100644
index 00000000..5f00cf2a
--- /dev/null
+++ b/tests/unit/stores/rules-store.test.ts
@@ -0,0 +1,148 @@
+// @vitest-environment happy-dom
+
+import {
+  beforeEach, describe, expect, it, vi,
+} from 'vitest';
+import { createPinia, setActivePinia } from 'pinia';
+
+vi.mock('../../../src/services/auth', () => ({
+  initOidc: async () => null,
+  getOidc: () => null,
+}));
+
+import {
+  __resetRepositoryForTests,
+  __setRepositoryForTests,
+} from '../../../src/composables/useRepository';
+import { MUTATION_TYPE } from '../../../src/constants/states';
+import type { MailRuleDocument } from '../../../src/sieve/rules';
+import { useAuthStore } from '../../../src/stores/auth-store';
+import {
+  MailRulesSaveError,
+  useRulesStore,
+} from '../../../src/stores/rules-store';
+
+function document(): MailRuleDocument {
+  return {
+    version: 1,
+    rules: [{
+      id: 'rule-1',
+      name: 'Receipts',
+      enabled: true,
+      match: 'all',
+      conditions: [{
+        id: 'condition-1', field: 'subject', operator: 'contains', value: 'Receipt',
+      }],
+      actions: [{ id: 'action-1', type: 'markRead' }],
+      stopProcessing: true,
+    }],
+  };
+}
+
+function snapshot(overrides: Record<string, unknown> = {}) {
+  return {
+    supported: true,
+    accountId: 'remote-1',
+    state: 'sieve-state-1',
+    capabilities: {
+      sieveExtensions: ['imap4flags'],
+      maxSizeScript: 64_000,
+      maxNumberRedirects: 4,
+    },
+    scripts: [],
+    managedScript: null,
+    foreignActiveScript: null,
+    document: document(),
+    parseError: null,
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  setActivePinia(createPinia());
+  __resetRepositoryForTests();
+});
+
+describe('rules store', () => {
+  it('loads a normalized snapshot and returns isolated drafts', async () => {
+    const repo = { getMailRules: vi.fn(async () => snapshot()) };
+    __setRepositoryForTests(repo);
+    useAuthStore().accountId = 7;
+    const store = useRulesStore();
+
+    const loaded = await store.load();
+    const draft = store.freshDocument();
+    draft.rules[0].name = 'Edited locally';
+
+    expect(repo.getMailRules).toHaveBeenCalledWith(7);
+    expect(loaded.state).toBe('sieve-state-1');
+    expect(store.snapshot?.document.rules[0].name).toBe('Receipts');
+    expect(store.loading).toBe(false);
+  });
+
+  it('queues and runs a state-checked durable mutation before reloading', async () => {
+    const repo = {
+      getMailRules: vi.fn(async () => snapshot()),
+      insertPendingMutation: vi.fn(async (_input: any) => ({ id: 93 })),
+      runMutation: vi.fn(async () => ({ attempted: 1, succeeded: 1, failed: 0 })),
+      getPendingMutationError: vi.fn(),
+    };
+    __setRepositoryForTests(repo);
+    useAuthStore().accountId = 7;
+    const store = useRulesStore();
+    await store.load();
+
+    await store.save(document(), { takeover: true });
+
+    expect(repo.insertPendingMutation).toHaveBeenCalledTimes(1);
+    const pending = repo.insertPendingMutation.mock.calls[0][0];
+    expect(pending).toMatchObject({
+      accountId: 7,
+      mutationType: MUTATION_TYPE.SET_SIEVE_RULES,
+      targetMessageId: null,
+      optimisticPatchJson: null,
+    });
+    expect(JSON.parse(pending.requestJson)).toEqual({
+      document: document(),
+      expectedState: 'sieve-state-1',
+      takeover: true,
+    });
+    expect(repo.runMutation).toHaveBeenCalledWith(7, 93);
+    expect(repo.getMailRules).toHaveBeenCalledTimes(2);
+    expect(store.saving).toBe(false);
+  });
+
+  it('surfaces the typed terminal error left by the outbox', async () => {
+    const repo = {
+      getMailRules: vi.fn(async () => snapshot()),
+      insertPendingMutation: vi.fn(async () => ({ id: 94 })),
+      runMutation: vi.fn(async () => ({ attempted: 1, succeeded: 0, failed: 1 })),
+      getPendingMutationError: vi.fn(async () => ({
+        error_json: JSON.stringify({
+          type: 'foreignScriptActive',
+          message: 'Another script is active.',
+          result: { foreignActiveScript: { id: 'foreign' } },
+        }),
+      })),
+    };
+    __setRepositoryForTests(repo);
+    useAuthStore().accountId = 7;
+    const store = useRulesStore();
+    await store.load();
+
+    await expect(store.save(document())).rejects.toMatchObject({
+      name: 'MailRulesSaveError',
+      code: 'foreignScriptActive',
+      message: 'Another script is active.',
+      detail: { foreignActiveScript: { id: 'foreign' } },
+    } satisfies Partial<MailRulesSaveError>);
+    expect(store.error).toBe('Another script is active.');
+    expect(store.saving).toBe(false);
+  });
+
+  it('requires an authenticated local account', async () => {
+    __setRepositoryForTests({});
+    const store = useRulesStore();
+    await expect(store.load()).rejects.toMatchObject({ code: 'notConnected' });
+  });
+});
diff --git a/tests/unit/sync/_mock-transport.ts b/tests/unit/sync/_mock-transport.ts
index 122c3ff5..bc21c8ab 100644
--- a/tests/unit/sync/_mock-transport.ts
+++ b/tests/unit/sync/_mock-transport.ts
@@ -48,6 +48,10 @@ export class MockTransport {
   requests: Array<{ using: any; methodCalls: any }>;
   uploads: Array<{ accountId: string; type: string; body: any }>;
   _uploadHandler: ((args: { accountId: string; type: string; body: any }) => any) | null;
+  downloads: Array<{ accountId: string; blobId: string; type?: string; name?: string }>;
+  _downloadHandler: ((args: {
+    accountId: string; blobId: string; type?: string; name?: string;
+  }) => any) | null;
 
   constructor(session: any = null) {
     this._session = session ?? mockSession();
@@ -67,6 +71,8 @@ export class MockTransport {
     this.requests = [];
     this.uploads = [];
     this._uploadHandler = null;
+    this.downloads = [];
+    this._downloadHandler = null;
   }
 
   set session(s) {
@@ -125,6 +131,24 @@ export class MockTransport {
     };
   }
 
+  handleDownload(fn: (args: {
+    accountId: string; blobId: string; type?: string; name?: string;
+  }) => any) {
+    this._downloadHandler = fn;
+  }
+
+  async download({ accountId, blobId, type, name }: {
+    accountId: string; blobId: string; type?: string; name?: string;
+  }) {
+    const args = { accountId, blobId, type, name };
+    this.downloads.push(args);
+    if (!this._downloadHandler) {
+      throw new Error(`MockTransport has no download handler for ${blobId}`);
+    }
+    const value = await this._downloadHandler(args);
+    return typeof value === 'string' ? new TextEncoder().encode(value) : value;
+  }
+
   /** Teardown surface JmapBackend.stop() calls. Nothing here holds a
    *  socket or an in-flight fetch, so both are no-ops. */
   abort() {}
diff --git a/tests/unit/sync/jmap-outbox-sieve.test.ts b/tests/unit/sync/jmap-outbox-sieve.test.ts
new file mode 100644
index 00000000..7b97a843
--- /dev/null
+++ b/tests/unit/sync/jmap-outbox-sieve.test.ts
@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+
+import type { MailRuleDocument } from '../../../src/sieve/rules';
+import { SIEVE_CAPABILITY } from '../../../src/sieve/rules';
+import {
+  MUTATION_TYPES,
+  processMutationRow,
+} from '../../../src/sync/backends/jmap/outbox';
+import { JMAP_CAPS } from '../../../src/sync/backends/jmap/transport';
+import { MockTransport } from './_mock-transport';
+
+const DOCUMENT: MailRuleDocument = {
+  version: 1,
+  rules: [{
+    id: 'rule-1',
+    name: 'Discard automated noise',
+    enabled: true,
+    match: 'all',
+    conditions: [{
+      id: 'condition-1', field: 'from', operator: 'contains', value: 'noise@example.net',
+    }],
+    actions: [{ id: 'action-1', type: 'discard' }],
+    stopProcessing: true,
+  }],
+};
+
+function sieveTransport() {
+  const transport = new MockTransport({
+    capabilities: { [JMAP_CAPS.CORE]: {}, [SIEVE_CAPABILITY]: {} },
+    primaryAccounts: { [SIEVE_CAPABILITY]: 'acct-1' },
+    accounts: {
+      'acct-1': {
+        accountCapabilities: {
+          [SIEVE_CAPABILITY]: { sieveExtensions: [], maxSizeScript: 64_000 },
+        },
+      },
+    },
+  });
+  transport.handle('SieveScript/get', () => ({
+    accountId: 'acct-1', state: 'state-1', list: [],
+  }));
+  transport.handle('SieveScript/validate', () => ({ accountId: 'acct-1', error: null }));
+  transport.handle('SieveScript/set', () => ({
+    accountId: 'acct-1',
+    newState: 'state-2',
+    created: { stormbox: { id: 'managed-1', blobId: 'blob-1' } },
+  }));
+  return transport;
+}
+
+describe('Sieve outbox dispatch', () => {
+  it('dispatches the durable rules mutation through upload, validation, and set', async () => {
+    const transport = sieveTransport();
+    const result = await processMutationRow({
+      transport,
+      account: { id: 1, remote_account_id: 'acct-1' },
+      handlers: {},
+      row: {
+        mutation_type: MUTATION_TYPES.SET_SIEVE_RULES,
+        request_json: JSON.stringify({ document: DOCUMENT, expectedState: 'state-1' }),
+      },
+    });
+
+    expect(result).toMatchObject({ ok: true, result: { scriptId: 'managed-1' } });
+    expect(transport.uploads).toHaveLength(1);
+    expect(transport.requests.map(({ methodCalls }) => methodCalls[0][0]))
+      .toEqual(['SieveScript/get', 'SieveScript/validate', 'SieveScript/set']);
+  });
+
+  it('classifies malformed durable payloads as terminal', async () => {
+    const result = await processMutationRow({
+      transport: sieveTransport(),
+      account: { id: 1, remote_account_id: 'acct-1' },
+      handlers: {},
+      row: {
+        mutation_type: MUTATION_TYPES.SET_SIEVE_RULES,
+        request_json: '{not-json',
+      },
+    });
+
+    expect(result).toEqual({
+      ok: false,
+      error: {
+        type: 'invalidArguments',
+        message: 'The durable mutation payload is not valid JSON.',
+        terminal: true,
+      },
+    });
+  });
+});
diff --git a/tests/unit/sync/jmap-sieve.test.ts b/tests/unit/sync/jmap-sieve.test.ts
new file mode 100644
index 00000000..0a526f0b
--- /dev/null
+++ b/tests/unit/sync/jmap-sieve.test.ts
@@ -0,0 +1,242 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  compileRules,
+  emptyRuleDocument,
+  MANAGED_SCRIPT_NAME,
+  SIEVE_CAPABILITY,
+} from '../../../src/sieve/rules';
+import type { MailRuleDocument } from '../../../src/sieve/rules';
+import {
+  getMailRules,
+  runSetSieveRules,
+} from '../../../src/sync/backends/jmap/sieve';
+import { JMAP_CAPS } from '../../../src/sync/backends/jmap/transport';
+import { MockTransport } from './_mock-transport';
+
+const EXTENSIONS = ['copy', 'fileinto', 'imap4flags', 'mailboxid'];
+const ACCOUNT = { remote_account_id: 'acct-1' };
+
+function session() {
+  return {
+    capabilities: {
+      [JMAP_CAPS.CORE]: {},
+      [SIEVE_CAPABILITY]: { implementation: 'test' },
+    },
+    primaryAccounts: { [SIEVE_CAPABILITY]: 'acct-1' },
+    accounts: {
+      'acct-1': {
+        accountCapabilities: {
+          [SIEVE_CAPABILITY]: {
+            sieveExtensions: EXTENSIONS,
+            maxSizeScript: 64_000,
+            maxNumberRedirects: 4,
+          },
+        },
+      },
+    },
+  };
+}
+
+function ruleDocument(): MailRuleDocument {
+  return {
+    version: 1,
+    rules: [{
+      id: 'rule-1',
+      name: 'Read receipts',
+      enabled: true,
+      match: 'all',
+      conditions: [{
+        id: 'condition-1', field: 'subject', operator: 'contains', value: 'Receipt',
+      }],
+      actions: [{ id: 'action-1', type: 'markRead' }],
+      stopProcessing: true,
+    }],
+  };
+}
+
+function managedSource(document = ruleDocument()) {
+  return compileRules(document, {
+    sieveExtensions: EXTENSIONS,
+    maxSizeScript: 64_000,
+    maxNumberRedirects: 4,
+  });
+}
+
+describe('JMAP Sieve rules backend', () => {
+  it('reports unsupported accounts without issuing a JMAP method call', async () => {
+    const transport = new MockTransport();
+    const result = await getMailRules({ transport, account: ACCOUNT });
+
+    expect(result.supported).toBe(false);
+    expect(result.document).toEqual(emptyRuleDocument());
+    expect(transport.requests).toHaveLength(0);
+  });
+
+  it('loads managed metadata while preserving a foreign active script', async () => {
+    const transport = new MockTransport(session());
+    transport.handle('SieveScript/get', () => ({
+      accountId: 'acct-1',
+      state: 'sieve-state-1',
+      list: [
+        {
+          id: 'foreign', name: 'Handwritten filters', blobId: 'blob-foreign', isActive: true,
+        },
+        {
+          id: 'managed', name: MANAGED_SCRIPT_NAME, blobId: 'blob-managed', isActive: false,
+        },
+      ],
+      notFound: [],
+    }));
+    transport.handleDownload(({ blobId }) => (
+      blobId === 'blob-managed' ? managedSource() : 'require ["fileinto"];\r\nkeep;\r\n'
+    ));
+
+    const result = await getMailRules({ transport, account: ACCOUNT });
+
+    expect(result.supported).toBe(true);
+    expect(result.state).toBe('sieve-state-1');
+    expect(result.document).toEqual(ruleDocument());
+    expect(result.managedScript).toMatchObject({ id: 'managed', isActive: false });
+    expect(result.foreignActiveScript).toEqual({ id: 'foreign', name: 'Handwritten filters' });
+    expect(result.capabilities.sieveExtensions).toEqual(EXTENSIONS);
+  });
+
+  it('requires explicit takeover, then validates and activates a new managed script', async () => {
+    const transport = new MockTransport(session());
+    let setRequest: any = null;
+    transport.handle('SieveScript/get', () => ({
+      accountId: 'acct-1',
+      state: 'sieve-state-1',
+      list: [{
+        id: 'foreign', name: 'Handwritten filters', blobId: 'blob-foreign', isActive: true,
+      }],
+      notFound: [],
+    }));
+    transport.handleDownload(() => 'keep;\r\n');
+    transport.handle('SieveScript/validate', () => ({ accountId: 'acct-1', error: null }));
+    transport.handle('SieveScript/set', (params) => {
+      setRequest = params;
+      return {
+        accountId: 'acct-1',
+        oldState: 'sieve-state-1',
+        newState: 'sieve-state-2',
+        created: { stormbox: { id: 'managed-new', blobId: 'blob-1' } },
+      };
+    });
+
+    const refused = await runSetSieveRules({
+      transport,
+      account: ACCOUNT,
+      request: { document: ruleDocument(), expectedState: 'sieve-state-1' },
+    });
+    expect(refused).toMatchObject({
+      ok: false,
+      error: { type: 'foreignScriptActive', terminal: true },
+    });
+    expect(transport.uploads).toHaveLength(0);
+
+    const result = await runSetSieveRules({
+      transport,
+      account: ACCOUNT,
+      request: {
+        document: ruleDocument(), expectedState: 'sieve-state-1', takeover: true,
+      },
+    });
+
+    expect(result).toMatchObject({
+      ok: true,
+      result: { scriptId: 'managed-new', state: 'sieve-state-2' },
+    });
+    expect(transport.uploads).toHaveLength(1);
+    expect(transport.uploads[0]).toMatchObject({
+      accountId: 'acct-1', type: 'application/sieve',
+    });
+    expect(new TextDecoder().decode(transport.uploads[0].body))
+      .toContain('# stormbox-managed: mail-rules/v1');
+    expect(setRequest).toMatchObject({
+      accountId: 'acct-1',
+      ifInState: 'sieve-state-1',
+      onSuccessActivateScript: '#stormbox',
+      create: { stormbox: { name: MANAGED_SCRIPT_NAME, blobId: 'blob-1' } },
+    });
+    expect(setRequest.destroy).toBeUndefined();
+  });
+
+  it('updates the owned script and never creates or destroys another script', async () => {
+    const transport = new MockTransport(session());
+    let setRequest: any = null;
+    transport.handle('SieveScript/get', () => ({
+      accountId: 'acct-1',
+      state: 'sieve-state-7',
+      list: [
+        {
+          id: 'managed', name: MANAGED_SCRIPT_NAME, blobId: 'blob-managed', isActive: true,
+        },
+        {
+          id: 'foreign', name: 'Saved elsewhere', blobId: 'blob-foreign', isActive: false,
+        },
+      ],
+    }));
+    transport.handleDownload(({ blobId }) => (
+      blobId === 'blob-managed' ? managedSource() : 'keep;\r\n'
+    ));
+    transport.handle('SieveScript/validate', () => ({ accountId: 'acct-1', error: null }));
+    transport.handle('SieveScript/set', (params) => {
+      setRequest = params;
+      return {
+        accountId: 'acct-1', oldState: 'sieve-state-7', newState: 'sieve-state-8', updated: { managed: null },
+      };
+    });
+
+    const result = await runSetSieveRules({
+      transport,
+      account: ACCOUNT,
+      request: { document: ruleDocument(), expectedState: 'sieve-state-7' },
+    });
+
+    expect(result.ok).toBe(true);
+    expect(setRequest).toMatchObject({
+      update: { managed: { blobId: 'blob-1' } },
+      onSuccessActivateScript: 'managed',
+    });
+    expect(setRequest.create).toBeUndefined();
+    expect(setRequest.destroy).toBeUndefined();
+  });
+
+  it('stops on state conflicts and server validation errors', async () => {
+    const conflictTransport = new MockTransport(session());
+    conflictTransport.handle('SieveScript/get', () => ({
+      accountId: 'acct-1', state: 'changed', list: [],
+    }));
+    const conflict = await runSetSieveRules({
+      transport: conflictTransport,
+      account: ACCOUNT,
+      request: { document: ruleDocument(), expectedState: 'loaded-state' },
+    });
+    expect(conflict).toMatchObject({
+      ok: false, error: { type: 'sieveStateMismatch', terminal: true },
+    });
+    expect(conflictTransport.uploads).toHaveLength(0);
+
+    const validationTransport = new MockTransport(session());
+    validationTransport.handle('SieveScript/get', () => ({
+      accountId: 'acct-1', state: 'sieve-state-1', list: [],
+    }));
+    validationTransport.handle('SieveScript/validate', () => ({
+      accountId: 'acct-1',
+      error: { type: 'invalidSieve', description: 'line 4: invalid command' },
+    }));
+    const validation = await runSetSieveRules({
+      transport: validationTransport,
+      account: ACCOUNT,
+      request: { document: ruleDocument(), expectedState: 'sieve-state-1' },
+    });
+    expect(validation).toMatchObject({
+      ok: false,
+      error: { type: 'invalidSieve', message: 'line 4: invalid command', terminal: true },
+    });
+    expect(validationTransport.requests.some(({ methodCalls }) =>
+      methodCalls[0][0] === 'SieveScript/set')).toBe(false);
+  });
+});

From b82d98e73b1f8b723facbc0b3008e2805db171e1 Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Mon, 7 Sep 2026 07:45:35 +0100
Subject: [PATCH 02/16] Renumber the mail rules spec

---
 specs/{004-mail-rules => 010-mail-rules}/spec.md | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename specs/{004-mail-rules => 010-mail-rules}/spec.md (100%)

diff --git a/specs/004-mail-rules/spec.md b/specs/010-mail-rules/spec.md
similarity index 100%
rename from specs/004-mail-rules/spec.md
rename to specs/010-mail-rules/spec.md

From c7a58c2167f018c85625d3a2d61d0ab46e6b408c Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Mon, 7 Sep 2026 11:40:02 +0100
Subject: [PATCH 03/16] Parse compatible Sieve into nested visual rules. (#128)

Treat executable Sieve as authoritative, edit fully representable active scripts in place, and preserve unsupported scripts. Add recursive condition groups, guarded source projection, and keyboard-accessible controls.
---
 specs/010-mail-rules/spec.md                  |  22 +-
 src/components/MailRuleSelect.vue             | 131 ++++
 src/components/MailRuleTestEditor.vue         | 374 ++++++++++++
 src/components/MailRulesDialog.vue            | 181 +++---
 src/sieve/parser.ts                           | 514 ++++++++++++++++
 src/sieve/rules.ts                            | 568 +++++++++++++++---
 src/stores/rules-store.ts                     |   5 +-
 src/sync/backends/jmap/sieve.ts               |  30 +-
 tests/e2e/mail-rules.spec.js                  |  21 +-
 .../unit/components/mail-rule-select.test.ts  |  87 +++
 .../unit/components/mail-rules-dialog.test.ts |  77 ++-
 tests/unit/sieve/parser.test.ts               |  78 +++
 tests/unit/sieve/rules.test.ts                | 213 ++++++-
 tests/unit/stores/rules-store.test.ts         |  39 +-
 tests/unit/sync/jmap-outbox-sieve.test.ts     |   5 +-
 tests/unit/sync/jmap-sieve.test.ts            | 107 +++-
 16 files changed, 2223 insertions(+), 229 deletions(-)
 create mode 100644 src/components/MailRuleSelect.vue
 create mode 100644 src/components/MailRuleTestEditor.vue
 create mode 100644 src/sieve/parser.ts
 create mode 100644 tests/unit/components/mail-rule-select.test.ts
 create mode 100644 tests/unit/sieve/parser.test.ts

diff --git a/specs/010-mail-rules/spec.md b/specs/010-mail-rules/spec.md
index ab336af0..a0a6f7cc 100644
--- a/specs/010-mail-rules/spec.md
+++ b/specs/010-mail-rules/spec.md
@@ -12,33 +12,35 @@ Stormbox shall let a signed-in user build ordered mail rules visually and run th
 | ID | Requirement |
 |---|---|
 | MR-1 | When the account advertises `urn:ietf:params:jmap:sieve`, the account menu shall offer a Mail Rules editor. When the capability is absent, the editor shall explain that server-side rules are unavailable. |
-| MR-2 | The editor shall support ordered, enabled/disabled rules; all/any condition matching; From, To, To/Cc, Subject, and custom-header conditions; and exact, contains, or wildcard matching. |
+| MR-2 | The editor shall support ordered, enabled/disabled rules; recursively nested all/any/not condition groups; From, To, To/Cc, Subject, and custom-header conditions; and exact, contains, or wildcard matching. |
 | MR-3 | The editor shall support move, mark read, star, forward a copy, discard, and stop-processing actions, exposing only actions supported by the account's advertised Sieve extensions. |
-| MR-4 | Stormbox shall store the visual rule document as versioned metadata in a clearly marked managed Sieve script. Generated Sieve is a build artifact rather than the source model. |
+| MR-4 | The server-stored Sieve source shall be authoritative. Stormbox shall parse scripts into a source-ranged syntax tree and project every completely representable script into the visual rule model. UI-only identifiers may be regenerated and shall not duplicate the executable rule model in metadata. |
 | MR-5 | Every save shall use the durable mutation outbox, upload the generated script, call `SieveScript/validate`, and activate it only after validation succeeds. |
 | MR-6 | A save shall use the last observed `SieveScript` state and reject a concurrent server change instead of overwriting it. |
-| MR-7 | Stormbox shall not modify or delete a script it does not own. If a foreign script is active, activation shall require explicit confirmation and shall preserve the foreign script on the server. |
+| MR-7 | A compatible existing active script shall be edited in place only after it has been parsed and completely represented. If the active script cannot be represented, activating a new visual script shall require explicit confirmation and shall preserve the existing script on the server. |
 | MR-8 | Move actions shall use the RFC 9042 `:mailboxid` extension when supported, retaining a readable hierarchy path as the fallback mailbox name. |
 | MR-9 | Invalid rule data, unsupported actions, server validation failures, and server conflicts shall remain visible and recoverable in the editor. Controls shall be disabled while a save is in flight. |
 | MR-10 | The editor shall be keyboard accessible, trap focus while open, and confirm before discarding unsaved changes. |
+| MR-11 | Stormbox shall only rewrite a script when every required extension is within the visual editor's semantics-preserving subset. Scripts requiring other extensions shall remain opaque and preserved. |
 
 ## Initial scope
 
 - Server-side filtering of newly delivered mail.
-- One managed visual-rule script per account.
-- A deliberately limited, typed rules model and purpose-built Sieve emitter.
-- Existing arbitrary Sieve scripts remain opaque and preserved.
+- One visually edited script at a time; JMAP may retain other scripts and permits at most one active script.
+- A source parser, deliberately limited visual projection, and Sieve emitter.
+- Compatible existing scripts can be visualized and edited in place.
+- Unsupported syntax remains preserved and available to a future Advanced editor.
 
 ## Non-goals
 
-- Importing arbitrary Sieve into the visual model.
-- A raw Sieve editor.
+- Visually representing every Sieve extension or control-flow construct.
+- A raw Sieve editor in the initial delivery; the parser and source ranges shall not preclude it.
 - Retroactively applying rules to existing messages.
 - Shared-account rule management.
 - A Cloudflare Worker rule engine; the deployment bridge only adapts browser CORS and WebSocket authentication.
 
 ## Verification
 
-- Unit tests cover normalization, escaping, capability checks, metadata round-tripping, conflict handling, server validation, and outbox integration.
-- Component tests cover loading, editing, takeover confirmation, save locking, and discard confirmation.
+- Unit tests cover syntax parsing, visual projection, nested grouping, escaping, capability checks, source round-tripping, conflict handling, server validation, and outbox integration.
+- Component tests cover loading, nested editing, takeover confirmation, save locking, and discard confirmation.
 - Local-stack Playwright coverage asserts the visible editor result, durable mutation completion, and the active script directly through JMAP in Chromium and Firefox.
diff --git a/src/components/MailRuleSelect.vue b/src/components/MailRuleSelect.vue
new file mode 100644
index 00000000..995b70d0
--- /dev/null
+++ b/src/components/MailRuleSelect.vue
@@ -0,0 +1,131 @@
+<script setup lang="ts">
+import { computed, nextTick } from 'vue';
+import { Check } from '@lucide/vue';
+
+import AppDropdown from './AppDropdown.vue';
+import { closeContainingDropdown } from '../utils/dropdown';
+
+interface MailRuleSelectOption {
+  value: string;
+  label: string;
+  disabled?: boolean;
+}
+
+const props = withDefaults(defineProps<{
+  modelValue: string;
+  options: readonly MailRuleSelectOption[];
+  ariaLabel: string;
+  placeholder?: string;
+  disabled?: boolean;
+}>(), {
+  placeholder: 'Select an option',
+  disabled: false,
+});
+
+const emit = defineEmits<{
+  (event: 'update:modelValue', value: string): void;
+}>();
+
+const selectedLabel = computed(() =>
+  props.options.find((option) => option.value === props.modelValue)?.label ?? props.placeholder);
+
+function containingDropdown(source: EventTarget | null): HTMLDetailsElement | null {
+  if (!(source instanceof Element)) return null;
+  const details = source.closest('details');
+  return details instanceof HTMLDetailsElement ? details : null;
+}
+
+function enabledOptions(details: HTMLDetailsElement): HTMLButtonElement[] {
+  return Array.from(details.querySelectorAll<HTMLButtonElement>('[data-rule-option]:not(:disabled)'));
+}
+
+async function openFromKeyboard(event: KeyboardEvent): Promise<void> {
+  if (props.disabled) return;
+  if (event.key !== 'ArrowDown' && event.key !== 'ArrowUp') return;
+  event.preventDefault();
+  const details = containingDropdown(event.currentTarget);
+  if (!details) return;
+  details.open = true;
+  await nextTick();
+  const options = enabledOptions(details);
+  const target = event.key === 'ArrowDown' ? options[0] : options.at(-1);
+  target?.focus();
+}
+
+function moveOptionFocus(event: KeyboardEvent): void {
+  if (!['ArrowDown', 'ArrowUp', 'Home', 'End'].includes(event.key)) return;
+  const details = containingDropdown(event.currentTarget);
+  if (!details) return;
+  const options = enabledOptions(details);
+  const current = event.currentTarget;
+  if (!(current instanceof HTMLButtonElement) || options.length === 0) return;
+  event.preventDefault();
+
+  const currentIndex = options.indexOf(current);
+  let targetIndex: number;
+  if (event.key === 'Home') targetIndex = 0;
+  else if (event.key === 'End') targetIndex = options.length - 1;
+  else if (event.key === 'ArrowDown') targetIndex = (currentIndex + 1) % options.length;
+  else targetIndex = (currentIndex - 1 + options.length) % options.length;
+  options[targetIndex]?.focus();
+}
+
+function selectOption(option: MailRuleSelectOption, event: Event): void {
+  if (props.disabled || option.disabled) return;
+  const details = containingDropdown(event.currentTarget);
+  emit('update:modelValue', option.value);
+  closeContainingDropdown(event);
+  details?.querySelector<HTMLElement>('summary')?.focus();
+}
+</script>
+
+<template>
+  <AppDropdown class="mail-rule-select" :disabled="disabled">
+    <summary
+      class="app-dropdown__summary app-dropdown__summary--control mail-rule-select__summary"
+      :aria-label="ariaLabel"
+      :aria-disabled="disabled ? 'true' : undefined"
+      aria-haspopup="menu"
+      :tabindex="disabled ? -1 : undefined"
+      @keydown="openFromKeyboard"
+    >{{ selectedLabel }}</summary>
+    <div class="app-dropdown__menu mail-rule-select__menu" role="menu" :aria-label="ariaLabel">
+      <button
+        v-for="option in options"
+        :key="option.value"
+        class="app-dropdown__item"
+        type="button"
+        role="menuitemradio"
+        :disabled="disabled || option.disabled"
+        :aria-checked="option.value === modelValue"
+        :data-rule-option="option.value"
+        @click="selectOption(option, $event)"
+        @keydown="moveOptionFocus"
+      >
+        <Check v-if="option.value === modelValue" :size="14" aria-hidden="true" />
+        <span v-else aria-hidden="true" />
+        <span>{{ option.label }}</span>
+      </button>
+    </div>
+  </AppDropdown>
+</template>
+
+<style scoped>
+.mail-rule-select {
+  width: 100%;
+  min-width: 0;
+}
+.mail-rule-select__summary {
+  box-sizing: border-box;
+  width: 100%;
+  min-width: 0;
+  white-space: nowrap;
+}
+.mail-rule-select__menu {
+  min-width: max(100%, 190px);
+}
+.mail-rule-select :deep(.app-dropdown__item:disabled) {
+  cursor: default;
+  opacity: 0.45;
+}
+</style>
diff --git a/src/components/MailRuleTestEditor.vue b/src/components/MailRuleTestEditor.vue
new file mode 100644
index 00000000..e083367f
--- /dev/null
+++ b/src/components/MailRuleTestEditor.vue
@@ -0,0 +1,374 @@
+<script setup lang="ts">
+import { Plus, Trash2, X } from '@lucide/vue';
+
+import MailRuleSelect from './MailRuleSelect.vue';
+import { newRuleId } from '../sieve/rules';
+import type {
+  MailRuleCondition, MailRuleConditionGroup, MailRuleTest, RuleMatch,
+} from '../sieve/rules';
+
+defineOptions({ name: 'MailRuleTestEditor' });
+
+const props = withDefaults(defineProps<{
+  match: RuleMatch;
+  conditions: MailRuleTest[];
+  negated?: boolean;
+  depth?: number;
+  root?: boolean;
+  disabled?: boolean;
+  removable?: boolean;
+}>(), {
+  negated: false,
+  depth: 0,
+  root: false,
+  disabled: false,
+  removable: true,
+});
+
+const matchOptions = [
+  { value: 'all', label: 'all of these match' },
+  { value: 'any', label: 'any of these match' },
+] as const;
+
+const fieldOptions = [
+  { value: 'from', label: 'From' },
+  { value: 'to', label: 'To' },
+  { value: 'toCc', label: 'To or Cc' },
+  { value: 'subject', label: 'Subject' },
+  { value: 'header', label: 'Custom header' },
+] as const;
+
+const operatorOptions = [
+  { value: 'is', label: 'is' },
+  { value: 'contains', label: 'contains' },
+  { value: 'matches', label: 'matches wildcard' },
+] as const;
+
+const emit = defineEmits<{
+  (event: 'update:match', value: RuleMatch): void;
+  (event: 'update:conditions', value: MailRuleTest[]): void;
+  (event: 'update:negated', value: boolean): void;
+  (event: 'remove'): void;
+}>();
+
+function createCondition(): MailRuleCondition {
+  return {
+    id: newRuleId('condition'),
+    type: 'condition',
+    negated: false,
+    field: 'from',
+    operator: 'contains',
+    value: '',
+  };
+}
+
+function createGroup(): MailRuleConditionGroup {
+  return {
+    id: newRuleId('group'),
+    type: 'group',
+    negated: false,
+    match: 'all',
+    conditions: [createCondition()],
+  };
+}
+
+function replaceCondition(index: number, condition: MailRuleTest) {
+  const conditions = [...props.conditions];
+  conditions.splice(index, 1, condition);
+  emit('update:conditions', conditions);
+}
+
+function updateCondition(index: number, patch: Partial<MailRuleCondition>) {
+  const condition = props.conditions[index];
+  if (condition?.type !== 'condition') return;
+  replaceCondition(index, { ...condition, ...patch });
+}
+
+function removeCondition(index: number) {
+  if (props.conditions.length <= 1) return;
+  const conditions = [...props.conditions];
+  conditions.splice(index, 1);
+  emit('update:conditions', conditions);
+}
+
+function addCondition() {
+  emit('update:conditions', [...props.conditions, createCondition()]);
+}
+
+function addGroup() {
+  emit('update:conditions', [...props.conditions, createGroup()]);
+}
+
+function updateField(index: number, value: string) {
+  const field = value as MailRuleCondition['field'];
+  updateCondition(index, {
+    field,
+    ...(field === 'header' ? { headerName: 'X-Header' } : { headerName: undefined }),
+  });
+}
+
+function updateMatch(value: string) {
+  emit('update:match', value as RuleMatch);
+}
+
+function onGroupNegatedChange(event: Event) {
+  emit('update:negated', (event.target as HTMLInputElement).checked);
+}
+
+function onConditionNegatedChange(index: number, event: Event) {
+  updateCondition(index, { negated: (event.target as HTMLInputElement).checked });
+}
+
+function updateOperator(index: number, value: string) {
+  updateCondition(index, {
+    operator: value as MailRuleCondition['operator'],
+  });
+}
+
+function onTextInput(
+  index: number,
+  property: 'headerName' | 'value',
+  event: Event,
+) {
+  updateCondition(index, { [property]: (event.target as HTMLInputElement).value });
+}
+</script>
+
+<template>
+  <div class="condition-group" :class="{ 'condition-group--nested': !root }">
+    <div class="condition-group__header">
+      <span>{{ root ? 'When' : 'Group' }}</span>
+      <MailRuleSelect
+        class="condition-group__match"
+        :model-value="match"
+        :options="matchOptions"
+        :aria-label="root ? 'Condition match mode' : 'Nested condition match mode'"
+        :disabled="disabled"
+        @update:model-value="updateMatch"
+      />
+      <label v-if="!root" class="condition-group__not">
+        <input
+          type="checkbox"
+          :checked="negated"
+          :disabled="disabled"
+          @change="onGroupNegatedChange"
+        />
+        Not
+      </label>
+      <button
+        v-if="!root"
+        class="condition-group__icon-button condition-group__icon-button--danger"
+        type="button"
+        :disabled="disabled || !removable"
+        aria-label="Remove condition group"
+        @click="emit('remove')"
+      ><Trash2 :size="15" aria-hidden="true" /></button>
+    </div>
+
+    <div class="condition-group__children">
+      <template v-for="(condition, index) in conditions" :key="condition.id">
+        <MailRuleTestEditor
+          v-if="condition.type === 'group'"
+          :match="condition.match"
+          :conditions="condition.conditions"
+          :negated="condition.negated"
+          :depth="depth + 1"
+          :disabled="disabled"
+          :removable="conditions.length > 1"
+          @update:match="replaceCondition(index, { ...condition, match: $event })"
+          @update:conditions="replaceCondition(index, { ...condition, conditions: $event })"
+          @update:negated="replaceCondition(index, { ...condition, negated: $event })"
+          @remove="removeCondition(index)"
+        />
+
+        <div v-else class="condition-group__condition">
+          <label class="condition-group__not">
+            <input
+              type="checkbox"
+              :checked="condition.negated"
+              :disabled="disabled"
+              @change="onConditionNegatedChange(index, $event)"
+            />
+            Not
+          </label>
+          <MailRuleSelect
+            :model-value="condition.field"
+            :options="fieldOptions"
+            aria-label="Condition field"
+            :disabled="disabled"
+            @update:model-value="updateField(index, $event)"
+          />
+          <input
+            v-if="condition.field === 'header'"
+            :value="condition.headerName"
+            type="text"
+            :disabled="disabled"
+            aria-label="Header name"
+            placeholder="X-Header"
+            @input="onTextInput(index, 'headerName', $event)"
+          />
+          <MailRuleSelect
+            :model-value="condition.operator"
+            :options="operatorOptions"
+            aria-label="Condition operator"
+            :disabled="disabled"
+            @update:model-value="updateOperator(index, $event)"
+          />
+          <input
+            :value="condition.value"
+            type="text"
+            :disabled="disabled"
+            aria-label="Condition value"
+            placeholder="Value"
+            @input="onTextInput(index, 'value', $event)"
+          />
+          <button
+            class="condition-group__icon-button"
+            type="button"
+            :disabled="disabled || conditions.length === 1"
+            aria-label="Remove condition"
+            @click="removeCondition(index)"
+          ><X :size="15" aria-hidden="true" /></button>
+        </div>
+      </template>
+    </div>
+
+    <div class="condition-group__actions">
+      <button type="button" :disabled="disabled" @click="addCondition">
+        <Plus :size="14" aria-hidden="true" /> Condition
+      </button>
+      <button type="button" :disabled="disabled || depth >= 7" @click="addGroup">
+        <Plus :size="14" aria-hidden="true" /> Group
+      </button>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.condition-group {
+  min-width: 0;
+}
+.condition-group--nested {
+  margin: 8px 0;
+  padding: 9px;
+  border: 1px solid var(--border-soft);
+  border-left: 3px solid color-mix(in srgb, var(--accent) 52%, var(--border));
+  border-radius: 7px;
+  background: color-mix(in srgb, var(--panel) 58%, transparent);
+}
+.condition-group__header,
+.condition-group__condition,
+.condition-group__actions,
+.condition-group__not {
+  display: flex;
+  align-items: center;
+}
+.condition-group__header {
+  gap: 8px;
+  margin-bottom: 8px;
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 650;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+.condition-group__match {
+  width: auto;
+  min-width: 160px;
+}
+.condition-group__match :deep(.mail-rule-select__summary) {
+  text-transform: none;
+  letter-spacing: normal;
+}
+.condition-group__not {
+  gap: 5px;
+  white-space: nowrap;
+  font-weight: 500;
+  letter-spacing: normal;
+  text-transform: none;
+}
+.condition-group__not input {
+  width: 15px;
+  min-height: 15px;
+}
+.condition-group__condition {
+  display: grid;
+  grid-template-columns: auto minmax(110px, 0.8fr) minmax(135px, 1fr) minmax(160px, 1.5fr) 32px;
+  gap: 8px;
+  margin-bottom: 8px;
+}
+.condition-group__condition:has(input[aria-label="Header name"]) {
+  grid-template-columns: auto minmax(105px, 0.75fr) minmax(110px, 0.75fr) minmax(135px, 1fr) minmax(150px, 1.35fr) 32px;
+}
+.condition-group input[type="text"] {
+  box-sizing: border-box;
+  width: 100%;
+  min-width: 0;
+  min-height: 34px;
+  padding: 6px 8px;
+  border: 1px solid var(--border);
+  border-radius: 5px;
+  background: var(--panel);
+  color: var(--text);
+  font: inherit;
+  font-size: 13px;
+}
+.condition-group input[type="checkbox"] { accent-color: var(--accent); }
+.condition-group input:focus-visible {
+  border-color: var(--accent);
+  outline: 2px solid color-mix(in srgb, var(--accent) 30%, transparent);
+  outline-offset: 1px;
+}
+.condition-group__actions {
+  gap: 3px;
+}
+.condition-group__actions button,
+.condition-group__icon-button {
+  border: 0;
+  border-radius: 4px;
+  background: transparent;
+  color: var(--accent);
+  cursor: pointer;
+  font: inherit;
+  font-size: 12px;
+  font-weight: 600;
+}
+.condition-group__actions button {
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+  padding: 5px 7px;
+}
+.condition-group__icon-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
+  margin-left: auto;
+  padding: 0;
+  border-radius: 999px;
+  color: var(--muted);
+}
+.condition-group__actions button:hover:not(:disabled),
+.condition-group__actions button:focus-visible,
+.condition-group__icon-button:hover:not(:disabled),
+.condition-group__icon-button:focus-visible {
+  background: var(--rowHover);
+  color: var(--text);
+  outline: none;
+}
+.condition-group__icon-button--danger:hover:not(:disabled),
+.condition-group__icon-button--danger:focus-visible { color: #d84a4a; }
+.condition-group button:disabled { opacity: 0.35; cursor: default; }
+
+@media (max-width: 760px) {
+  .condition-group__condition,
+  .condition-group__condition:has(input[aria-label="Header name"]) {
+    grid-template-columns: auto 1fr 32px;
+  }
+  .condition-group__condition > :not(.condition-group__not, button) { grid-column: 2; }
+  .condition-group__condition > .condition-group__not { grid-column: 1; grid-row: 1; }
+  .condition-group__condition > button { grid-column: 3; grid-row: 1; }
+}
+</style>
diff --git a/src/components/MailRulesDialog.vue b/src/components/MailRulesDialog.vue
index b9ee40da..2ee878a8 100644
--- a/src/components/MailRulesDialog.vue
+++ b/src/components/MailRulesDialog.vue
@@ -7,6 +7,8 @@ import {
 } from '@lucide/vue';
 
 import AppButton from './AppButton.vue';
+import MailRuleSelect from './MailRuleSelect.vue';
+import MailRuleTestEditor from './MailRuleTestEditor.vue';
 import { useAuthStore } from '../stores/auth-store';
 import { useMailStore } from '../stores/mail-store';
 import { MailRulesSaveError, useRulesStore } from '../stores/rules-store';
@@ -18,7 +20,7 @@ import {
   RuleValidationError,
 } from '../sieve/rules';
 import type {
-  MailRule, MailRuleAction, MailRuleCondition, MailRuleDocument,
+  MailRule, MailRuleAction, MailRuleDocument,
 } from '../sieve/rules';
 
 const emit = defineEmits<{ (event: 'close'): void }>();
@@ -28,7 +30,7 @@ const mailStore = useMailStore();
 const rulesStore = useRulesStore();
 const panelEl = ref<HTMLElement | null>(null);
 const closeButtonEl = ref<HTMLButtonElement | null>(null);
-const draft = ref<MailRuleDocument>({ version: 1, rules: [] });
+const draft = ref<MailRuleDocument>({ version: 2, rules: [] });
 const baseline = ref('');
 const localError = ref<string | null>(null);
 const notice = ref<string | null>(null);
@@ -70,6 +72,16 @@ const actionOptions = [
   { value: 'discard', label: 'Discard' },
 ] as const;
 
+const availableActionOptions = computed(() => actionOptions.map((option) => ({
+  ...option,
+  disabled: !actionSupported(option.value),
+})));
+
+const folderSelectOptions = computed(() => folderOptions.value.map((folder) => ({
+  value: folder.remoteId,
+  label: folder.label,
+})));
+
 function actionSupported(type: MailRuleAction['type']): boolean {
   if (type === 'move') return canMove.value;
   if (type === 'markRead' || type === 'star') return canFlags.value;
@@ -95,27 +107,6 @@ function moveRule(index: number, delta: number) {
   draft.value.rules.splice(target, 0, rule);
 }
 
-function addCondition(rule: MailRule) {
-  rule.conditions.push({
-    id: newRuleId('condition'),
-    field: 'from',
-    operator: 'contains',
-    value: '',
-  });
-}
-
-function removeCondition(rule: MailRule, index: number) {
-  if (rule.conditions.length <= 1) return;
-  rule.conditions.splice(index, 1);
-}
-
-function onConditionFieldChange(condition: MailRuleCondition, event: Event) {
-  const value = (event.target as HTMLSelectElement).value as MailRuleCondition['field'];
-  condition.field = value;
-  if (value === 'header' && !condition.headerName) condition.headerName = 'X-Header';
-  if (value !== 'header') delete condition.headerName;
-}
-
 function addAction(rule: MailRule) {
   rule.actions.push(createDefaultAction());
 }
@@ -125,13 +116,12 @@ function removeAction(rule: MailRule, index: number) {
   rule.actions.splice(index, 1);
 }
 
-function onActionTypeChange(rule: MailRule, index: number, event: Event) {
-  const type = (event.target as HTMLSelectElement).value as MailRuleAction['type'];
+function onActionTypeChange(rule: MailRule, index: number, value: string) {
+  const type = value as MailRuleAction['type'];
   rule.actions.splice(index, 1, createAction(type));
 }
 
-function onMoveTargetChange(action: Extract<MailRuleAction, { type: 'move' }>, event: Event) {
-  const mailboxId = (event.target as HTMLSelectElement).value;
+function onMoveTargetChange(action: Extract<MailRuleAction, { type: 'move' }>, mailboxId: string) {
   const target = folderOptions.value.find((folder) => folder.remoteId === mailboxId);
   action.mailboxId = mailboxId;
   action.mailboxName = target?.label ?? action.mailboxName;
@@ -162,7 +152,7 @@ async function load() {
   notice.value = null;
   try {
     await rulesStore.load();
-    draft.value = rulesStore.freshDocument();
+    draft.value = resolveFolderTargets(rulesStore.freshDocument());
     baseline.value = JSON.stringify(draft.value);
   } catch (error) {
     localError.value = errorMessage(error);
@@ -193,7 +183,7 @@ async function persist(takeover: boolean) {
   notice.value = null;
   try {
     await rulesStore.save(draft.value, { takeover });
-    draft.value = rulesStore.freshDocument();
+    draft.value = resolveFolderTargets(rulesStore.freshDocument());
     baseline.value = JSON.stringify(draft.value);
     notice.value = 'Rules saved, validated, and activated.';
   } catch (error) {
@@ -232,6 +222,19 @@ function refreshFolderFallbacks(input: MailRuleDocument): MailRuleDocument {
   return document;
 }
 
+function resolveFolderTargets(input: MailRuleDocument): MailRuleDocument {
+  const document = cloneRuleDocument(input);
+  const foldersByLabel = new Map(folderOptions.value.map((folder) => [folder.label, folder.remoteId]));
+  for (const rule of document.rules) {
+    for (const action of rule.actions) {
+      if (action.type === 'move' && !action.mailboxId) {
+        action.mailboxId = foldersByLabel.get(action.mailboxName) ?? '';
+      }
+    }
+  }
+  return document;
+}
+
 function requestClose() {
   if (busy.value) return;
   if (dirty.value) {
@@ -274,7 +277,7 @@ function onWindowKeydown(event: KeyboardEvent) {
     : panelEl.value;
   if (!focusRoot) return;
   const focusable = [...focusRoot.querySelectorAll<HTMLElement>(
-    'button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])',
+    'button:not([disabled]), input:not([disabled]), summary:not([aria-disabled="true"]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])',
   )].filter((element) => element.offsetParent !== null);
   if (focusable.length === 0) return;
   const first = focusable[0];
@@ -379,6 +382,17 @@ onBeforeUnmount(() => {
                 </div>
               </div>
 
+              <div
+                v-else-if="rulesStore.snapshot.editableScript && !rulesStore.snapshot.managedScript"
+                class="mail-rules__alert"
+                role="status"
+              >
+                <div>
+                  <strong>This existing script is visually compatible.</strong>
+                  <p>Saving will update the same script and normalize its Sieve formatting.</p>
+                </div>
+              </div>
+
               <div class="mail-rules__toolbar">
                 <div class="mail-rules__summary">
                   <Filter :size="17" aria-hidden="true" />
@@ -435,58 +449,14 @@ onBeforeUnmount(() => {
                   </header>
 
                   <div class="mail-rule__section">
-                    <div class="mail-rule__section-title">
-                      <span>When</span>
-                      <select v-model="rule.match" aria-label="Condition match mode">
-                        <option value="all">all conditions match</option>
-                        <option value="any">any condition matches</option>
-                      </select>
-                    </div>
-                    <div
-                      v-for="(condition, conditionIndex) in rule.conditions"
-                      :key="condition.id"
-                      class="mail-rule__row mail-rule__condition"
-                    >
-                      <select
-                        :value="condition.field"
-                        aria-label="Condition field"
-                        @change="onConditionFieldChange(condition, $event)"
-                      >
-                        <option value="from">From</option>
-                        <option value="to">To</option>
-                        <option value="toCc">To or Cc</option>
-                        <option value="subject">Subject</option>
-                        <option value="header">Custom header</option>
-                      </select>
-                      <input
-                        v-if="condition.field === 'header'"
-                        v-model="condition.headerName"
-                        type="text"
-                        aria-label="Header name"
-                        placeholder="X-Header"
-                      />
-                      <select v-model="condition.operator" aria-label="Condition operator">
-                        <option value="is">is</option>
-                        <option value="contains">contains</option>
-                        <option value="matches">matches wildcard</option>
-                      </select>
-                      <input
-                        v-model="condition.value"
-                        type="text"
-                        aria-label="Condition value"
-                        placeholder="Value"
-                      />
-                      <button
-                        class="mail-rules__icon-button"
-                        type="button"
-                        :disabled="rule.conditions.length === 1"
-                        aria-label="Remove condition"
-                        @click="removeCondition(rule, conditionIndex)"
-                      ><X :size="15" aria-hidden="true" /></button>
-                    </div>
-                    <button class="mail-rules__text-button" type="button" @click="addCondition(rule)">
-                      + Add condition
-                    </button>
+                    <MailRuleTestEditor
+                      root
+                      :match="rule.match"
+                      :conditions="rule.conditions"
+                      :disabled="busy"
+                      @update:match="rule.match = $event"
+                      @update:conditions="rule.conditions = $event"
+                    />
                   </div>
 
                   <div class="mail-rule__section">
@@ -496,31 +466,22 @@ onBeforeUnmount(() => {
                       :key="action.id"
                       class="mail-rule__row mail-rule__action"
                     >
-                      <select
-                        :value="action.type"
+                      <MailRuleSelect
+                        :model-value="action.type"
+                        :options="availableActionOptions"
                         aria-label="Rule action"
-                        @change="onActionTypeChange(rule, actionIndex, $event)"
-                      >
-                        <option
-                          v-for="option in actionOptions"
-                          :key="option.value"
-                          :value="option.value"
-                          :disabled="!actionSupported(option.value)"
-                        >{{ option.label }}</option>
-                      </select>
-                      <select
+                        :disabled="busy"
+                        @update:model-value="onActionTypeChange(rule, actionIndex, $event)"
+                      />
+                      <MailRuleSelect
                         v-if="action.type === 'move'"
-                        :value="action.mailboxId"
+                        :model-value="action.mailboxId"
+                        :options="folderSelectOptions"
                         aria-label="Destination folder"
-                        @change="onMoveTargetChange(action, $event)"
-                      >
-                        <option value="" disabled>Select folder</option>
-                        <option
-                          v-for="folder in folderOptions"
-                          :key="folder.remoteId"
-                          :value="folder.remoteId"
-                        >{{ folder.label }}</option>
-                      </select>
+                        placeholder="Select folder"
+                        :disabled="busy"
+                        @update:model-value="onMoveTargetChange(action, $event)"
+                      />
                       <input
                         v-else-if="action.type === 'redirect'"
                         v-model="action.address"
@@ -727,7 +688,7 @@ onBeforeUnmount(() => {
   border: 1px solid var(--border);
   border-radius: 10px;
   background: var(--panel2);
-  overflow: hidden;
+  overflow: visible;
 }
 .mail-rule__header {
   gap: 6px;
@@ -758,10 +719,6 @@ onBeforeUnmount(() => {
   letter-spacing: 0.04em;
   color: var(--muted);
 }
-.mail-rule__section-title select {
-  text-transform: none;
-  letter-spacing: normal;
-}
 .mail-rule__row {
   display: grid;
   gap: 8px;
@@ -789,8 +746,7 @@ onBeforeUnmount(() => {
   color: var(--muted);
   font-size: 12px;
 }
-.mail-rule input,
-.mail-rule select {
+.mail-rule input {
   box-sizing: border-box;
   width: 100%;
   min-width: 0;
@@ -808,8 +764,7 @@ onBeforeUnmount(() => {
   min-height: 16px;
   accent-color: var(--accent);
 }
-.mail-rule input:focus-visible,
-.mail-rule select:focus-visible {
+.mail-rule input:focus-visible {
   border-color: var(--accent);
   outline: 2px solid color-mix(in srgb, var(--accent) 30%, transparent);
   outline-offset: 1px;
diff --git a/src/sieve/parser.ts b/src/sieve/parser.ts
new file mode 100644
index 00000000..d9438df8
--- /dev/null
+++ b/src/sieve/parser.ts
@@ -0,0 +1,514 @@
+export interface SieveSourceRange {
+  start: number;
+  end: number;
+}
+
+export type SieveValue =
+  | { type: 'tag'; value: string; range: SieveSourceRange }
+  | { type: 'string'; value: string; range: SieveSourceRange }
+  | { type: 'stringList'; values: string[]; range: SieveSourceRange }
+  | { type: 'number'; value: string; range: SieveSourceRange };
+
+export interface SieveCallTest {
+  type: 'call';
+  name: string;
+  arguments: SieveValue[];
+  range: SieveSourceRange;
+}
+
+export interface SieveNotTest {
+  type: 'not';
+  test: SieveTest;
+  range: SieveSourceRange;
+}
+
+export interface SieveBooleanTest {
+  type: 'allof' | 'anyof';
+  tests: SieveTest[];
+  range: SieveSourceRange;
+}
+
+export type SieveTest = SieveCallTest | SieveNotTest | SieveBooleanTest;
+
+export interface SieveCommand {
+  type: 'command';
+  name: string;
+  arguments: SieveValue[];
+  comments: string[];
+  range: SieveSourceRange;
+}
+
+export interface SieveBlockCommand {
+  type: 'block';
+  name: string;
+  arguments: SieveValue[];
+  commands: SieveStatement[];
+  comments: string[];
+  range: SieveSourceRange;
+}
+
+export interface SieveIfBranch {
+  test: SieveTest;
+  commands: SieveStatement[];
+  comments: string[];
+}
+
+export interface SieveIfStatement {
+  type: 'if';
+  branches: SieveIfBranch[];
+  elseCommands: SieveStatement[] | null;
+  elseComments: string[];
+  comments: string[];
+  range: SieveSourceRange;
+}
+
+export type SieveStatement = SieveCommand | SieveBlockCommand | SieveIfStatement;
+
+export interface SieveScript {
+  source: string;
+  statements: SieveStatement[];
+  trailingComments: string[];
+}
+
+export class SieveSyntaxError extends Error {
+  readonly offset: number;
+
+  constructor(message: string, source: string, offset: number) {
+    const before = source.slice(0, offset);
+    const line = before.split(/\r\n|\r|\n/).length;
+    const lastNewline = Math.max(before.lastIndexOf('\n'), before.lastIndexOf('\r'));
+    const column = offset - lastNewline;
+    super(`${message} at line ${line}, column ${column}.`);
+    this.name = 'SieveSyntaxError';
+    this.offset = offset;
+  }
+}
+
+type TokenType =
+  | 'identifier'
+  | 'tag'
+  | 'number'
+  | 'string'
+  | 'comment'
+  | '['
+  | ']'
+  | '('
+  | ')'
+  | '{'
+  | '}'
+  | ','
+  | ';'
+  | 'eof';
+
+const MAX_SOURCE_CHARACTERS = 2_000_000;
+const MAX_TOKENS = 100_000;
+const MAX_AST_NODES = 10_000;
+const MAX_NESTING_DEPTH = 64;
+
+interface Token {
+  type: TokenType;
+  value: string;
+  start: number;
+  end: number;
+}
+
+export function parseSieve(source: string): SieveScript {
+  if (source.length > MAX_SOURCE_CHARACTERS) {
+    throw new SieveSyntaxError('Script exceeds the parser size limit', source, 0);
+  }
+  const parser = new Parser(source, tokenize(source));
+  return parser.parse();
+}
+
+class Parser {
+  private index = 0;
+  private nodeCount = 0;
+  private trailingComments: string[] = [];
+
+  constructor(
+    private readonly source: string,
+    private readonly tokens: Token[],
+  ) {}
+
+  parse(): SieveScript {
+    const statements = this.parseStatements('eof', 0);
+    this.expect('eof');
+    return { source: this.source, statements, trailingComments: this.trailingComments };
+  }
+
+  private parseStatements(end: '}' | 'eof', depth: number): SieveStatement[] {
+    const statements: SieveStatement[] = [];
+    while (true) {
+      const comments = this.takeComments();
+      if (this.peek().type === end) {
+        if (end === 'eof') {
+          this.trailingComments = comments;
+        } else if (comments.length > 0 && statements.length > 0) {
+          statements[statements.length - 1].comments.push(...comments);
+        }
+        return statements;
+      }
+      if (this.peek().type === 'eof') {
+        if (end === 'eof') return statements;
+        throw this.error('Expected “}”', this.peek().start);
+      }
+      statements.push(this.parseStatement(comments, depth));
+    }
+  }
+
+  private parseStatement(comments: string[], depth: number): SieveStatement {
+    const start = this.peek().start;
+    this.countNode(start);
+    const name = this.expect('identifier');
+    if (name.value.toLowerCase() === 'if') return this.parseIf(start, comments, depth);
+    if (['elsif', 'else'].includes(name.value.toLowerCase())) {
+      throw this.error(`Unexpected “${name.value}”`, name.start);
+    }
+
+    const args = this.parseValues(new Set([';', '{']));
+    if (this.match('{')) {
+      this.checkDepth(depth + 1, start);
+      const commands = this.parseStatements('}', depth + 1);
+      const close = this.expect('}');
+      return {
+        type: 'block',
+        name: name.value.toLowerCase(),
+        arguments: args,
+        commands,
+        comments,
+        range: { start, end: close.end },
+      };
+    }
+    const endToken = this.expect(';');
+    return {
+      type: 'command',
+      name: name.value.toLowerCase(),
+      arguments: args,
+      comments,
+      range: { start, end: endToken.end },
+    };
+  }
+
+  private parseIf(start: number, comments: string[], depth: number): SieveIfStatement {
+    const branches: SieveIfBranch[] = [];
+    const firstTest = this.parseTest(new Set(['{']), 0);
+    branches.push({ test: firstTest, commands: this.parseBlock(depth), comments: [] });
+    let end = this.previous().end;
+
+    let elseCommands: SieveStatement[] | null = null;
+    let elseComments: string[] = [];
+    while (true) {
+      const beforeComments = this.index;
+      const branchComments = this.takeComments();
+      const token = this.peek();
+      if (token.type !== 'identifier') {
+        this.index = beforeComments;
+        break;
+      }
+      const keyword = token.value.toLowerCase();
+      if (keyword === 'elsif') {
+        this.index += 1;
+        const test = this.parseTest(new Set(['{']), 0);
+        branches.push({ test, commands: this.parseBlock(depth), comments: branchComments });
+        end = this.previous().end;
+        continue;
+      }
+      if (keyword === 'else') {
+        this.index += 1;
+        elseComments = branchComments;
+        elseCommands = this.parseBlock(depth);
+        end = this.previous().end;
+      } else {
+        this.index = beforeComments;
+      }
+      break;
+    }
+
+    return {
+      type: 'if',
+      branches,
+      elseCommands,
+      elseComments,
+      comments,
+      range: { start, end },
+    };
+  }
+
+  private parseBlock(depth: number): SieveStatement[] {
+    this.checkDepth(depth + 1, this.peek().start);
+    this.expect('{');
+    const commands = this.parseStatements('}', depth + 1);
+    this.expect('}');
+    return commands;
+  }
+
+  private parseTest(stop: ReadonlySet<TokenType>, depth: number): SieveTest {
+    this.takeComments();
+    const start = this.peek().start;
+    this.checkDepth(depth, start);
+    this.countNode(start);
+    const nameToken = this.expect('identifier');
+    const name = nameToken.value.toLowerCase();
+    if (name === 'not') {
+      const test = this.parseTest(stop, depth + 1);
+      return { type: 'not', test, range: { start, end: test.range.end } };
+    }
+    if (name === 'allof' || name === 'anyof') {
+      this.expect('(');
+      const tests: SieveTest[] = [];
+      if (this.peek().type === ')') {
+        throw this.error(`${name} requires at least one test`, this.peek().start);
+      }
+      do {
+        tests.push(this.parseTest(new Set([',', ')']), depth + 1));
+      } while (this.match(','));
+      const close = this.expect(')');
+      return { type: name, tests, range: { start, end: close.end } };
+    }
+
+    const args = this.parseValues(stop);
+    return {
+      type: 'call',
+      name,
+      arguments: args,
+      range: { start, end: this.previous().end },
+    };
+  }
+
+  private parseValues(stop: ReadonlySet<TokenType>): SieveValue[] {
+    const values: SieveValue[] = [];
+    while (!stop.has(this.peek().type)) {
+      const token = this.peek();
+      if (token.type === 'comment') {
+        this.index += 1;
+        continue;
+      }
+      if (token.type === 'tag') {
+        this.index += 1;
+        values.push({ type: 'tag', value: token.value.toLowerCase(), range: range(token) });
+        continue;
+      }
+      if (token.type === 'number') {
+        this.index += 1;
+        values.push({ type: 'number', value: token.value, range: range(token) });
+        continue;
+      }
+      if (token.type === 'string') {
+        this.index += 1;
+        values.push({ type: 'string', value: token.value, range: range(token) });
+        continue;
+      }
+      if (token.type === '[') {
+        values.push(this.parseStringList());
+        continue;
+      }
+      throw this.error(`Unexpected token “${token.value || token.type}”`, token.start);
+    }
+    return values;
+  }
+
+  private parseStringList(): SieveValue {
+    const open = this.expect('[');
+    const values: string[] = [];
+    do {
+      values.push(this.expect('string').value);
+    } while (this.match(','));
+    const close = this.expect(']');
+    return { type: 'stringList', values, range: { start: open.start, end: close.end } };
+  }
+
+  private takeComments(): string[] {
+    const comments: string[] = [];
+    while (this.peek().type === 'comment') {
+      comments.push(this.peek().value);
+      this.index += 1;
+    }
+    return comments;
+  }
+
+  private match(type: TokenType): boolean {
+    const start = this.index;
+    this.takeComments();
+    if (this.peek().type !== type) {
+      this.index = start;
+      return false;
+    }
+    this.index += 1;
+    return true;
+  }
+
+  private expect(type: TokenType): Token {
+    if (type !== 'comment') this.takeComments();
+    const token = this.peek();
+    if (token.type !== type) throw this.error(`Expected “${type}”`, token.start);
+    this.index += 1;
+    return token;
+  }
+
+  private peek(): Token {
+    return this.tokens[this.index];
+  }
+
+  private previous(): Token {
+    return this.tokens[Math.max(0, this.index - 1)];
+  }
+
+  private error(message: string, offset: number): SieveSyntaxError {
+    return new SieveSyntaxError(message, this.source, offset);
+  }
+
+  private countNode(offset: number): void {
+    this.nodeCount += 1;
+    if (this.nodeCount > MAX_AST_NODES) {
+      throw this.error('Script exceeds the parser node limit', offset);
+    }
+  }
+
+  private checkDepth(depth: number, offset: number): void {
+    if (depth > MAX_NESTING_DEPTH) {
+      throw this.error('Script exceeds the parser nesting limit', offset);
+    }
+  }
+}
+
+function tokenize(source: string): Token[] {
+  const tokens: Token[] = [];
+  let offset = 0;
+  while (offset < source.length) {
+    if (tokens.length >= MAX_TOKENS) {
+      throw new SieveSyntaxError('Script exceeds the parser token limit', source, offset);
+    }
+    const character = source[offset];
+    if (/\s/.test(character)) {
+      offset += 1;
+      continue;
+    }
+    if (character === '#') {
+      const start = offset;
+      offset += 1;
+      const contentStart = offset;
+      while (offset < source.length && source[offset] !== '\r' && source[offset] !== '\n') offset += 1;
+      tokens.push({ type: 'comment', value: source.slice(contentStart, offset).trim(), start, end: offset });
+      continue;
+    }
+    if (source.startsWith('/*', offset)) {
+      const start = offset;
+      const end = source.indexOf('*/', offset + 2);
+      if (end < 0) throw new SieveSyntaxError('Unterminated comment', source, start);
+      tokens.push({
+        type: 'comment',
+        value: source.slice(offset + 2, end).trim(),
+        start,
+        end: end + 2,
+      });
+      offset = end + 2;
+      continue;
+    }
+    if (isMultilineStart(source, offset)) {
+      const token = readMultilineString(source, offset);
+      tokens.push(token);
+      offset = token.end;
+      continue;
+    }
+    if (character === '"') {
+      const token = readQuotedString(source, offset);
+      tokens.push(token);
+      offset = token.end;
+      continue;
+    }
+    if (character === ':') {
+      const start = offset;
+      offset += 1;
+      if (!/[A-Za-z_]/.test(source[offset] ?? '')) {
+        throw new SieveSyntaxError('Invalid tag', source, start);
+      }
+      while (/[A-Za-z0-9_]/.test(source[offset] ?? '')) offset += 1;
+      tokens.push({ type: 'tag', value: source.slice(start, offset), start, end: offset });
+      continue;
+    }
+    if (/[A-Za-z_]/.test(character)) {
+      const start = offset;
+      offset += 1;
+      while (/[A-Za-z0-9_]/.test(source[offset] ?? '')) offset += 1;
+      tokens.push({ type: 'identifier', value: source.slice(start, offset), start, end: offset });
+      continue;
+    }
+    if (/[0-9]/.test(character)) {
+      const start = offset;
+      offset += 1;
+      while (/[0-9]/.test(source[offset] ?? '')) offset += 1;
+      if (/[KkMmGg]/.test(source[offset] ?? '')) offset += 1;
+      tokens.push({ type: 'number', value: source.slice(start, offset), start, end: offset });
+      continue;
+    }
+    if ('[](){},;'.includes(character)) {
+      tokens.push({ type: character as TokenType, value: character, start: offset, end: offset + 1 });
+      offset += 1;
+      continue;
+    }
+    throw new SieveSyntaxError(`Unexpected character “${character}”`, source, offset);
+  }
+  tokens.push({ type: 'eof', value: '', start: source.length, end: source.length });
+  return tokens;
+}
+
+function readQuotedString(source: string, start: number): Token {
+  let offset = start + 1;
+  let value = '';
+  while (offset < source.length) {
+    const character = source[offset];
+    if (character === '"') {
+      return { type: 'string', value, start, end: offset + 1 };
+    }
+    if (character === '\\') {
+      offset += 1;
+      if (offset >= source.length) break;
+      value += source[offset];
+      offset += 1;
+      continue;
+    }
+    if (character === '\0') throw new SieveSyntaxError('NUL is not allowed in a string', source, offset);
+    value += character;
+    offset += 1;
+  }
+  throw new SieveSyntaxError('Unterminated string', source, start);
+}
+
+function isMultilineStart(source: string, offset: number): boolean {
+  if (source.slice(offset, offset + 5).toLowerCase() !== 'text:') return false;
+  const next = source[offset + 5];
+  return next === ' ' || next === '\t' || next === '#' || next === '\r' || next === '\n';
+}
+
+function readMultilineString(source: string, start: number): Token {
+  let offset = start + 5;
+  while (source[offset] === ' ' || source[offset] === '\t') offset += 1;
+  if (source[offset] === '#') {
+    while (offset < source.length && source[offset] !== '\r' && source[offset] !== '\n') offset += 1;
+  }
+  offset = consumeLineBreak(source, offset, start);
+  const lines: string[] = [];
+  while (offset <= source.length) {
+    const lineStart = offset;
+    while (offset < source.length && source[offset] !== '\r' && source[offset] !== '\n') offset += 1;
+    const line = source.slice(lineStart, offset);
+    const afterLine = consumeLineBreak(source, offset, start);
+    if (line === '.') {
+      const value = lines.length === 0 ? '' : `${lines.join('\r\n')}\r\n`;
+      return { type: 'string', value, start, end: afterLine };
+    }
+    lines.push(line.startsWith('..') ? line.slice(1) : line);
+    offset = afterLine;
+  }
+  throw new SieveSyntaxError('Unterminated multi-line string', source, start);
+}
+
+function consumeLineBreak(source: string, offset: number, start: number): number {
+  if (source.startsWith('\r\n', offset)) return offset + 2;
+  if (source[offset] === '\r' || source[offset] === '\n') return offset + 1;
+  throw new SieveSyntaxError('Expected a line break in multi-line string', source, start);
+}
+
+function range(token: Token): SieveSourceRange {
+  return { start: token.start, end: token.end };
+}
diff --git a/src/sieve/rules.ts b/src/sieve/rules.ts
index 14c68cb2..9d3605bc 100644
--- a/src/sieve/rules.ts
+++ b/src/sieve/rules.ts
@@ -1,10 +1,24 @@
+import { parseSieve } from './parser';
+import type {
+  SieveCommand, SieveIfStatement, SieveStatement, SieveTest, SieveValue,
+} from './parser';
+
 export const SIEVE_CAPABILITY = 'urn:ietf:params:jmap:sieve';
 export const MANAGED_SCRIPT_NAME = 'Stormbox Mail Rules';
-export const MANAGED_SCRIPT_MARKER = '# stormbox-managed: mail-rules/v1';
+export const MANAGED_SCRIPT_MARKER = '# stormbox-managed: mail-rules/v2';
 
+const LEGACY_MANAGED_SCRIPT_MARKER = '# stormbox-managed: mail-rules/v1';
 const DATA_PREFIX = '# stormbox-data: ';
-const DATA_CHUNK_SIZE = 72;
 const BASE64URL_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+const MAX_TEST_DEPTH = 20;
+const MAX_TEST_NODES = 500;
+const VISUAL_REQUIRE_EXTENSIONS = new Set([
+  'copy',
+  'fileinto',
+  'imap4flags',
+  'mailbox',
+  'mailboxid',
+]);
 
 export type RuleMatch = 'all' | 'any';
 export type RuleField = 'from' | 'to' | 'toCc' | 'subject' | 'header';
@@ -12,12 +26,24 @@ export type RuleOperator = 'is' | 'contains' | 'matches';
 
 export interface MailRuleCondition {
   id: string;
+  type: 'condition';
+  negated: boolean;
   field: RuleField;
   operator: RuleOperator;
   value: string;
   headerName?: string;
 }
 
+export interface MailRuleConditionGroup {
+  id: string;
+  type: 'group';
+  negated: boolean;
+  match: RuleMatch;
+  conditions: MailRuleTest[];
+}
+
+export type MailRuleTest = MailRuleCondition | MailRuleConditionGroup;
+
 export type MailRuleAction =
   | { id: string; type: 'move'; mailboxId: string; mailboxName: string }
   | { id: string; type: 'markRead' }
@@ -30,13 +56,13 @@ export interface MailRule {
   name: string;
   enabled: boolean;
   match: RuleMatch;
-  conditions: MailRuleCondition[];
+  conditions: MailRuleTest[];
   actions: MailRuleAction[];
   stopProcessing: boolean;
 }
 
 export interface MailRuleDocument {
-  version: 1;
+  version: 2;
   rules: MailRule[];
 }
 
@@ -46,6 +72,10 @@ export interface SieveRuleCapabilities {
   maxNumberRedirects?: number | null;
 }
 
+export interface CompileRulesOptions {
+  managed?: boolean;
+}
+
 export class RuleValidationError extends Error {
   constructor(message: string) {
     super(message);
@@ -54,7 +84,7 @@ export class RuleValidationError extends Error {
 }
 
 export function emptyRuleDocument(): MailRuleDocument {
-  return { version: 1, rules: [] };
+  return { version: 2, rules: [] };
 }
 
 export function newRuleId(prefix = 'rule'): string {
@@ -71,6 +101,8 @@ export function createEmptyRule(): MailRule {
     match: 'all',
     conditions: [{
       id: newRuleId('condition'),
+      type: 'condition',
+      negated: false,
       field: 'from',
       operator: 'contains',
       value: '',
@@ -82,17 +114,26 @@ export function createEmptyRule(): MailRule {
 
 export function cloneRuleDocument(document: MailRuleDocument): MailRuleDocument {
   return {
-    version: 1,
+    version: 2,
     rules: document.rules.map((rule) => ({
       ...rule,
-      conditions: rule.conditions.map((condition) => ({ ...condition })),
+      conditions: rule.conditions.map(cloneRuleTest),
       actions: rule.actions.map((action) => ({ ...action })),
     })),
   };
 }
 
+function cloneRuleTest(test: MailRuleTest): MailRuleTest {
+  if (test.type === 'condition') return { ...test };
+  return { ...test, conditions: test.conditions.map(cloneRuleTest) };
+}
+
 export function normalizeRuleDocument(input: unknown): MailRuleDocument {
-  if (!isRecord(input) || input.version !== 1 || !Array.isArray(input.rules)) {
+  if (
+    !isRecord(input)
+    || (input.version !== 1 && input.version !== 2)
+    || !Array.isArray(input.rules)
+  ) {
     throw new RuleValidationError('The managed rule data has an unsupported format.');
   }
 
@@ -103,6 +144,7 @@ export function normalizeRuleDocument(input: unknown): MailRuleDocument {
     }
     const id = requiredId(value.id, `Rule ${ruleIndex + 1}`, seenRuleIds);
     const name = requiredText(value.name, `Rule ${ruleIndex + 1} needs a name.`);
+    rejectControlCharacters(name, `Rule ${ruleIndex + 1} name`);
     const match = value.match === 'all' || value.match === 'any' ? value.match : null;
     if (!match) throw new RuleValidationError(`Rule “${name}” has an invalid match mode.`);
     if (!Array.isArray(value.conditions) || value.conditions.length === 0) {
@@ -112,9 +154,9 @@ export function normalizeRuleDocument(input: unknown): MailRuleDocument {
       throw new RuleValidationError(`Rule “${name}” needs at least one action.`);
     }
 
-    const seenConditionIds = new Set<string>();
+    const testContext = { seenIds: new Set<string>(), nodes: 0 };
     const conditions = value.conditions.map((condition, conditionIndex) =>
-      normalizeCondition(condition, name, conditionIndex, seenConditionIds));
+      normalizeRuleTest(condition, name, `${conditionIndex + 1}`, testContext, 1));
     const seenActionIds = new Set<string>();
     const actions = value.actions.map((action, actionIndex) =>
       normalizeAction(action, name, actionIndex, seenActionIds));
@@ -130,20 +172,25 @@ export function normalizeRuleDocument(input: unknown): MailRuleDocument {
     } satisfies MailRule;
   });
 
-  return { version: 1, rules };
+  return { version: 2, rules };
 }
 
 export function isManagedRulesScript(script: string): boolean {
-  return script.split(/\r?\n/).some((line) => line.trimEnd() === MANAGED_SCRIPT_MARKER);
+  return script.split(/\r?\n/).some((line) => {
+    const value = line.trimEnd();
+    return value === MANAGED_SCRIPT_MARKER || value === LEGACY_MANAGED_SCRIPT_MARKER;
+  });
 }
 
 /**
- * Return null for a foreign script. A script carrying Stormbox's marker
- * is owned by this editor; malformed metadata throws so callers never
- * silently replace a managed script they can no longer understand.
+ * Return null for an unmarked script. Version 2 is reconstructed from
+ * executable source; version 1 metadata is retained as a migration path.
  */
 export function parseManagedRules(script: string): MailRuleDocument | null {
   if (!isManagedRulesScript(script)) return null;
+  if (script.split(/\r?\n/).some((line) => line.trimEnd() === MANAGED_SCRIPT_MARKER)) {
+    return parseVisualRules(script);
+  }
   const chunks = script
     .split(/\r?\n/)
     .filter((line) => line.startsWith(DATA_PREFIX))
@@ -151,18 +198,327 @@ export function parseManagedRules(script: string): MailRuleDocument | null {
   if (chunks.length === 0 || chunks.some((chunk) => !/^[A-Za-z0-9_-]+$/.test(chunk))) {
     throw new RuleValidationError('The Stormbox rule metadata is missing or malformed.');
   }
+  let legacyDocument: MailRuleDocument;
   try {
     const json = new TextDecoder().decode(decodeBase64Url(chunks.join('')));
-    return normalizeRuleDocument(JSON.parse(json));
+    legacyDocument = normalizeRuleDocument(JSON.parse(json));
   } catch (error) {
     if (error instanceof RuleValidationError) throw error;
     throw new RuleValidationError('The Stormbox rule metadata could not be decoded.');
   }
+
+  const executableDocument = parseVisualRules(script);
+  const enabledLegacyDocument: MailRuleDocument = {
+    version: 2,
+    rules: legacyDocument.rules.filter((rule) => rule.enabled),
+  };
+  if (!sameRuleSemantics(enabledLegacyDocument, executableDocument)) {
+    throw new RuleValidationError(
+      'The legacy Stormbox metadata differs from its executable Sieve. Preserve the script and resolve the mismatch before saving.',
+    );
+  }
+  let executableIndex = 0;
+  return normalizeRuleDocument({
+    version: 2,
+    rules: legacyDocument.rules.map((rule) => (
+      rule.enabled ? executableDocument.rules[executableIndex++] : rule
+    )),
+  });
+}
+
+export function parseVisualRules(script: string): MailRuleDocument {
+  const parsed = parseSieve(script);
+  for (const statement of parsed.statements) {
+    if (statement.type !== 'command' || statement.name !== 'require') continue;
+    if (statement.arguments.length !== 1) {
+      throw notVisualizable(script, statement, 'The require command is malformed');
+    }
+    const extensions = stringValues(statement.arguments[0]);
+    const unsupported = extensions.find((extension) =>
+      !VISUAL_REQUIRE_EXTENSIONS.has(extension.toLowerCase()));
+    if (extensions.length === 0 || unsupported) {
+      throw notVisualizable(
+        script,
+        statement,
+        `Required extension “${unsupported ?? 'unknown'}” is not safe to rewrite visually`,
+      );
+    }
+  }
+  const rules: MailRule[] = [];
+  const statements = parsed.statements.filter((statement) =>
+    statement.type !== 'command' || statement.name !== 'require');
+
+  if (
+    statements.length === 1
+    && statements[0].type === 'command'
+    && statements[0].name === 'keep'
+    && statements[0].arguments.length === 0
+  ) return emptyRuleDocument();
+
+  for (const statement of statements) {
+    if (statement.type !== 'if') {
+      throw notVisualizable(script, statement, `Top-level “${statement.name}” is not represented by the visual editor`);
+    }
+    rules.push(ruleFromIf(script, statement, rules.length));
+  }
+
+  return normalizeRuleDocument({ version: 2, rules });
+}
+
+function ruleFromIf(source: string, statement: SieveIfStatement, index: number): MailRule {
+  let visualStatement = statement;
+  let enabled = true;
+  if (isFalseTest(statement.branches[0]?.test)) {
+    const commands = statement.branches[0]?.commands ?? [];
+    if (
+      statement.branches.length !== 1
+      || statement.elseCommands
+      || commands.length !== 1
+      || commands[0].type !== 'if'
+    ) {
+      throw notVisualizable(source, statement, 'This false branch is not a generated disabled rule');
+    }
+    enabled = false;
+    visualStatement = commands[0];
+  }
+
+  if (visualStatement.branches.length !== 1 || visualStatement.elseCommands) {
+    throw notVisualizable(source, visualStatement, 'elsif and else branches are not represented yet');
+  }
+
+  const root = testFromSieve(source, visualStatement.branches[0].test);
+  const { actions, stopProcessing } = actionsFromCommands(
+    source,
+    visualStatement.branches[0].commands,
+  );
+  const label = ruleLabel(statement.comments, index, enabled);
+  return {
+    id: newRuleId(),
+    name: label,
+    enabled,
+    match: root.type === 'group' && !root.negated ? root.match : 'all',
+    conditions: root.type === 'group' && !root.negated ? root.conditions : [root],
+    actions,
+    stopProcessing,
+  };
+}
+
+function testFromSieve(source: string, test: SieveTest): MailRuleTest {
+  if (test.type === 'not') {
+    const visual = testFromSieve(source, test.test);
+    visual.negated = !visual.negated;
+    return visual;
+  }
+  if (test.type === 'allof' || test.type === 'anyof') {
+    return {
+      id: newRuleId('group'),
+      type: 'group',
+      negated: false,
+      match: test.type === 'allof' ? 'all' : 'any',
+      conditions: test.tests.map((child) => testFromSieve(source, child)),
+    };
+  }
+
+  if (!['address', 'header'].includes(test.name)) {
+    throw notVisualizable(source, test, `Test “${test.name}” is not represented by the visual editor`);
+  }
+  const { operator, positional } = visualMatchArguments(source, test);
+
+  const headers = stringValues(positional[0]);
+  const values = stringValues(positional[1]);
+  if (headers.length === 0 || values.length === 0) {
+    throw notVisualizable(source, test, `Test “${test.name}” has unsupported header or value lists`);
+  }
+  const normalizedHeaders = headers.map((header) => header.toLowerCase());
+  let targets: Array<{ field: RuleField; headerName?: string }>;
+  if (
+    test.name === 'address'
+    && normalizedHeaders.length === 2
+    && normalizedHeaders.includes('to')
+    && normalizedHeaders.includes('cc')
+  ) {
+    targets = [{ field: 'toCc' }];
+  } else if (test.name === 'address' && normalizedHeaders.every((header) => ['from', 'to'].includes(header))) {
+    targets = normalizedHeaders.map((header) => ({ field: header as 'from' | 'to' }));
+  } else if (test.name === 'header') {
+    targets = headers.map((header, index) => (
+      normalizedHeaders[index] === 'subject'
+        ? { field: 'subject' }
+        : { field: 'header', headerName: header }
+    ));
+  } else {
+    throw notVisualizable(source, test, `Test “${test.name}” targets headers the visual editor cannot combine`);
+  }
+
+  const conditions = targets.flatMap((target) => values.map<MailRuleCondition>((value) => ({
+    id: newRuleId('condition'),
+    type: 'condition',
+    negated: false,
+    field: target.field,
+    operator,
+    value,
+    ...(target.headerName ? { headerName: target.headerName } : {}),
+  })));
+  if (conditions.length === 1) return conditions[0];
+  return {
+    id: newRuleId('group'),
+    type: 'group',
+    negated: false,
+    match: 'any',
+    conditions,
+  };
+}
+
+function visualMatchArguments(
+  source: string,
+  test: Extract<SieveTest, { type: 'call' }>,
+): { operator: RuleOperator; positional: SieveValue[] } {
+  let operator: RuleOperator = 'is';
+  let matchTypeSeen = false;
+  let comparatorSeen = false;
+  let addressPartSeen = false;
+  let index = 0;
+
+  while (test.arguments[index]?.type === 'tag') {
+    const tag = test.arguments[index].value;
+    if ([':is', ':contains', ':matches'].includes(tag)) {
+      if (matchTypeSeen) {
+        throw notVisualizable(source, test, `Test “${test.name}” has more than one match type`);
+      }
+      matchTypeSeen = true;
+      operator = tag.slice(1) as RuleOperator;
+      index += 1;
+      continue;
+    }
+    if (tag === ':comparator') {
+      const comparator = test.arguments[index + 1];
+      if (
+        comparatorSeen
+        || comparator?.type !== 'string'
+        || comparator.value.toLowerCase() !== 'i;ascii-casemap'
+      ) {
+        throw notVisualizable(source, test, `Test “${test.name}” uses an unsupported comparator`);
+      }
+      comparatorSeen = true;
+      index += 2;
+      continue;
+    }
+    if (test.name === 'address' && tag === ':all') {
+      if (addressPartSeen) {
+        throw notVisualizable(source, test, 'The address test has more than one address part');
+      }
+      addressPartSeen = true;
+      index += 1;
+      continue;
+    }
+    throw notVisualizable(source, test, `Test “${test.name}” uses unsupported match arguments`);
+  }
+
+  const positional = test.arguments.slice(index);
+  if (positional.length !== 2 || positional.some((value) => value.type === 'tag')) {
+    throw notVisualizable(source, test, `Test “${test.name}” uses unsupported match arguments`);
+  }
+  return { operator, positional };
+}
+
+function actionsFromCommands(
+  source: string,
+  commands: SieveStatement[],
+): { actions: MailRuleAction[]; stopProcessing: boolean } {
+  const actions: MailRuleAction[] = [];
+  let stopProcessing = false;
+  commands.forEach((command, index) => {
+    if (command.type !== 'command') {
+      throw notVisualizable(source, command, 'Nested control blocks are not represented as rule actions');
+    }
+    if (command.name === 'stop') {
+      if (command.arguments.length > 0 || index !== commands.length - 1) {
+        throw notVisualizable(source, command, 'stop must be the final action in a visual rule');
+      }
+      stopProcessing = true;
+      return;
+    }
+    actions.push(...actionsFromCommand(source, command));
+  });
+  if (actions.length === 0) {
+    throw notVisualizable(source, commands[0], 'A visual rule needs at least one supported action');
+  }
+  return { actions, stopProcessing };
+}
+
+function actionsFromCommand(source: string, command: SieveCommand): MailRuleAction[] {
+  const tags = command.arguments.filter((value) => value.type === 'tag').map((value) => value.value);
+  const positional = command.arguments.filter((value) => value.type !== 'tag');
+  if (command.name === 'discard' && tags.length === 0 && positional.length === 0) {
+    return [{ id: newRuleId('action'), type: 'discard' }];
+  }
+  if (command.name === 'fileinto' && tags.every((tag) => tag === ':mailboxid')) {
+    const strings = positional.flatMap(stringValues);
+    if (tags.length === 0 && strings.length === 1) {
+      return [{
+        id: newRuleId('action'), type: 'move', mailboxId: '', mailboxName: strings[0],
+      }];
+    }
+    if (tags.length === 1 && strings.length === 2) {
+      return [{
+        id: newRuleId('action'), type: 'move', mailboxId: strings[0], mailboxName: strings[1],
+      }];
+    }
+  }
+  if (command.name === 'addflag' && tags.length === 0 && positional.length === 1) {
+    const flags = stringValues(positional[0]);
+    if (flags.length > 0 && flags.every((flag) => ['\\seen', '\\flagged'].includes(flag.toLowerCase()))) {
+      return flags.map<MailRuleAction>((flag) => ({
+        id: newRuleId('action'),
+        type: flag.toLowerCase() === '\\seen' ? 'markRead' : 'star',
+      }));
+    }
+  }
+  if (command.name === 'redirect' && tags.length === 1 && tags[0] === ':copy' && positional.length === 1) {
+    const addresses = stringValues(positional[0]);
+    if (addresses.length === 1) {
+      return [{ id: newRuleId('action'), type: 'redirect', address: addresses[0] }];
+    }
+  }
+  throw notVisualizable(source, command, `Action “${command.name}” is not represented by the visual editor`);
+}
+
+function stringValues(value: SieveValue): string[] {
+  if (value.type === 'string') return [value.value];
+  if (value.type === 'stringList') return value.values;
+  return [];
+}
+
+function isFalseTest(test: SieveTest | undefined): boolean {
+  return test?.type === 'call' && test.name === 'false' && test.arguments.length === 0;
+}
+
+function ruleLabel(comments: string[], index: number, enabled: boolean): string {
+  const prefixes = enabled ? [/^Rule:\s*(.+)$/i] : [/^Disabled rule:\s*(.+)$/i, /^Rule:\s*(.+)$/i];
+  for (const comment of [...comments].reverse()) {
+    for (const pattern of prefixes) {
+      const match = comment.match(pattern);
+      if (match?.[1]?.trim()) return match[1].trim();
+    }
+  }
+  return `Rule ${index + 1}`;
+}
+
+function notVisualizable(
+  source: string,
+  node: { range: { start: number } } | undefined,
+  message: string,
+): RuleValidationError {
+  const offset = node?.range.start ?? 0;
+  const before = source.slice(0, offset);
+  const line = before.split(/\r\n|\r|\n/).length;
+  return new RuleValidationError(`${message} at line ${line}.`);
 }
 
 export function compileRules(
   input: unknown,
   capabilities: SieveRuleCapabilities,
+  { managed = true }: CompileRulesOptions = {},
 ): string {
   const document = normalizeRuleDocument(input);
   validateRedirectBudget(document, capabilities.maxNumberRedirects);
@@ -171,27 +527,27 @@ export function compileRules(
   const blocks: string[] = [];
 
   for (const rule of document.rules) {
-    if (!rule.enabled) continue;
     const test = compileRuleTest(rule);
     const actionLines = rule.actions.map((action) =>
       `  ${compileAction(action, extensions, required)}`);
     if (rule.stopProcessing) actionLines.push('  stop;');
     const label = rule.name.replace(/[\r\n]+/g, ' ').trim();
-    blocks.push([
-      `# Rule: ${label}`,
-      `if ${test} {`,
-      ...actionLines,
-      '}',
-    ].join('\r\n'));
+    const ruleBlock = [`if ${test} {`, ...actionLines, '}'];
+    if (rule.enabled) {
+      blocks.push([`# Rule: ${label}`, ...ruleBlock].join('\r\n'));
+    } else {
+      blocks.push([
+        `# Disabled rule: ${label}`,
+        'if false {',
+        ...ruleBlock.map((line) => `  ${line}`),
+        '}',
+      ].join('\r\n'));
+    }
   }
 
-  const encoded = encodeBase64Url(new TextEncoder().encode(JSON.stringify(document)));
-  const metadataLines = chunkString(encoded, DATA_CHUNK_SIZE)
-    .map((chunk) => `${DATA_PREFIX}${chunk}`);
   const lines = [
-    '# Stormbox managed mail rules. Edit these rules in Stormbox.',
-    MANAGED_SCRIPT_MARKER,
-    ...metadataLines,
+    '# Stormbox-compatible mail rules. The Sieve source is authoritative.',
+    ...(managed ? [MANAGED_SCRIPT_MARKER] : []),
     '',
   ];
   if (required.size > 0) {
@@ -245,15 +601,40 @@ export function uniqueManagedScriptName(existingNames: Iterable<string | null |
   throw new RuleValidationError('Could not choose a unique managed script name.');
 }
 
-function normalizeCondition(
+function normalizeRuleTest(
   input: unknown,
   ruleName: string,
-  index: number,
-  seenIds: Set<string>,
-): MailRuleCondition {
+  path: string,
+  context: { seenIds: Set<string>; nodes: number },
+  depth: number,
+): MailRuleTest {
   if (!isRecord(input)) {
-    throw new RuleValidationError(`Condition ${index + 1} in “${ruleName}” is malformed.`);
+    throw new RuleValidationError(`Condition ${path} in “${ruleName}” is malformed.`);
+  }
+  context.nodes += 1;
+  if (context.nodes > MAX_TEST_NODES) {
+    throw new RuleValidationError(`Rule “${ruleName}” has more than ${MAX_TEST_NODES} conditions and groups.`);
+  }
+  if (depth > MAX_TEST_DEPTH) {
+    throw new RuleValidationError(`Rule “${ruleName}” has condition groups nested more than ${MAX_TEST_DEPTH} levels.`);
+  }
+
+  if (input.type === 'group') {
+    const id = requiredId(input.id, `Condition group ${path} in “${ruleName}”`, context.seenIds);
+    const match = input.match === 'all' || input.match === 'any' ? input.match : null;
+    if (!match || !Array.isArray(input.conditions) || input.conditions.length === 0) {
+      throw new RuleValidationError(`Condition group ${path} in “${ruleName}” is malformed.`);
+    }
+    return {
+      id,
+      type: 'group',
+      negated: input.negated === true,
+      match,
+      conditions: input.conditions.map((condition, index) =>
+        normalizeRuleTest(condition, ruleName, `${path}.${index + 1}`, context, depth + 1)),
+    };
   }
+
   const field = ['from', 'to', 'toCc', 'subject', 'header'].includes(String(input.field))
     ? input.field as RuleField
     : null;
@@ -261,23 +642,25 @@ function normalizeCondition(
     ? input.operator as RuleOperator
     : null;
   if (!field || !operator) {
-    throw new RuleValidationError(`Condition ${index + 1} in “${ruleName}” is not supported.`);
+    throw new RuleValidationError(`Condition ${path} in “${ruleName}” is not supported.`);
   }
-  const value = requiredText(
+  const value = requiredSieveText(
     input.value,
-    `Condition ${index + 1} in “${ruleName}” needs a value.`,
+    `Condition ${path} in “${ruleName}” needs a value.`,
   );
-  rejectControlCharacters(value, `Condition ${index + 1} in “${ruleName}”`);
+  rejectControlCharacters(value, `Condition ${path} in “${ruleName}”`);
   const condition: MailRuleCondition = {
-    id: requiredId(input.id, `Condition ${index + 1} in “${ruleName}”`, seenIds),
+    id: requiredId(input.id, `Condition ${path} in “${ruleName}”`, context.seenIds),
+    type: 'condition',
+    negated: input.negated === true,
     field,
     operator,
     value,
   };
   if (field === 'header') {
-    const headerName = requiredText(
+    const headerName = requiredSieveText(
       input.headerName,
-      `Custom header condition ${index + 1} in “${ruleName}” needs a header name.`,
+      `Custom header condition ${path} in “${ruleName}” needs a header name.`,
     );
     if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(headerName)) {
       throw new RuleValidationError(`“${headerName}” is not a valid header field name.`);
@@ -299,11 +682,8 @@ function normalizeAction(
   const id = requiredId(input.id, `Action ${index + 1} in “${ruleName}”`, seenIds);
   switch (input.type) {
     case 'move': {
-      const mailboxId = requiredText(
-        input.mailboxId,
-        `Move action ${index + 1} in “${ruleName}” needs a folder.`,
-      );
-      const mailboxName = requiredText(
+      const mailboxId = typeof input.mailboxId === 'string' ? input.mailboxId : '';
+      const mailboxName = requiredSieveText(
         input.mailboxName,
         `Move action ${index + 1} in “${ruleName}” needs a folder fallback name.`,
       );
@@ -312,7 +692,7 @@ function normalizeAction(
       return { id, type: 'move', mailboxId, mailboxName };
     }
     case 'redirect': {
-      const address = requiredText(
+      const address = requiredSieveText(
         input.address,
         `Forward action ${index + 1} in “${ruleName}” needs an email address.`,
       );
@@ -332,10 +712,23 @@ function normalizeAction(
 }
 
 function compileRuleTest(rule: MailRule): string {
-  const tests = rule.conditions.map(compileCondition);
-  if (tests.length === 1) return tests[0];
-  const keyword = rule.match === 'all' ? 'allof' : 'anyof';
-  return `${keyword} (${tests.join(', ')})`;
+  return compileTestGroup(rule.match, rule.conditions, false);
+}
+
+function compileRuleTestNode(test: MailRuleTest): string {
+  if (test.type === 'group') {
+    return compileTestGroup(test.match, test.conditions, test.negated);
+  }
+  const compiled = compileCondition(test);
+  return test.negated ? `not ${compiled}` : compiled;
+}
+
+function compileTestGroup(match: RuleMatch, tests: MailRuleTest[], negated: boolean): string {
+  const compiled = tests.map(compileRuleTestNode);
+  const expression = compiled.length === 1
+    ? compiled[0]
+    : `${match === 'all' ? 'allof' : 'anyof'} (${compiled.join(', ')})`;
+  return negated ? `not ${expression}` : expression;
 }
 
 function compileCondition(condition: MailRuleCondition): string {
@@ -363,7 +756,7 @@ function compileAction(
   switch (action.type) {
     case 'move':
       requireExtension('fileinto', extensions, required, 'Moving messages');
-      if (extensions.has('mailboxid')) {
+      if (action.mailboxId && extensions.has('mailboxid')) {
         required.add('mailboxid');
         // Stalwart currently checks :mailboxid against the RFC 5490 "mailbox"
         // capability as well. Declare it when advertised so its authoritative
@@ -410,6 +803,13 @@ function requiredText(value: unknown, message: string): string {
   return value.trim();
 }
 
+function requiredSieveText(value: unknown, message: string): string {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new RuleValidationError(message);
+  }
+  return value;
+}
+
 function requiredId(value: unknown, label: string, seen: Set<string>): string {
   const id = requiredText(value, `${label} needs an identifier.`);
   if (seen.has(id)) throw new RuleValidationError(`${label} has a duplicate identifier.`);
@@ -423,28 +823,6 @@ function rejectControlCharacters(value: string, label: string): void {
   }
 }
 
-function chunkString(value: string, size: number): string[] {
-  const chunks: string[] = [];
-  for (let offset = 0; offset < value.length; offset += size) {
-    chunks.push(value.slice(offset, offset + size));
-  }
-  return chunks;
-}
-
-function encodeBase64Url(bytes: Uint8Array): string {
-  let out = '';
-  for (let i = 0; i < bytes.length; i += 3) {
-    const a = bytes[i];
-    const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
-    const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
-    out += BASE64URL_ALPHABET[a >> 2];
-    out += BASE64URL_ALPHABET[((a & 3) << 4) | (b >> 4)];
-    if (i + 1 < bytes.length) out += BASE64URL_ALPHABET[((b & 15) << 2) | (c >> 6)];
-    if (i + 2 < bytes.length) out += BASE64URL_ALPHABET[c & 63];
-  }
-  return out;
-}
-
 function decodeBase64Url(value: string): Uint8Array {
   if (value.length % 4 === 1) throw new Error('invalid base64url length');
   const bytes: number[] = [];
@@ -464,6 +842,48 @@ function decodeBase64Url(value: string): Uint8Array {
   return new Uint8Array(bytes);
 }
 
+function sameRuleSemantics(left: MailRuleDocument, right: MailRuleDocument): boolean {
+  return left.rules.length === right.rules.length
+    && left.rules.every((rule, index) => sameRule(rule, right.rules[index]));
+}
+
+function sameRule(left: MailRule, right: MailRule): boolean {
+  return left.name === right.name
+    && left.enabled === right.enabled
+    && (left.conditions.length < 2 || left.match === right.match)
+    && left.stopProcessing === right.stopProcessing
+    && left.conditions.length === right.conditions.length
+    && left.conditions.every((test, index) => sameTest(test, right.conditions[index]))
+    && left.actions.length === right.actions.length
+    && left.actions.every((action, index) => sameAction(action, right.actions[index]));
+}
+
+function sameTest(left: MailRuleTest, right: MailRuleTest): boolean {
+  if (left.type !== right.type || left.negated !== right.negated) return false;
+  if (left.type === 'condition' && right.type === 'condition') {
+    return left.field === right.field
+      && left.operator === right.operator
+      && left.value === right.value
+      && left.headerName === right.headerName;
+  }
+  if (left.type !== 'group' || right.type !== 'group') return false;
+  return left.match === right.match
+    && left.conditions.length === right.conditions.length
+    && left.conditions.every((test, index) => sameTest(test, right.conditions[index]));
+}
+
+function sameAction(left: MailRuleAction, right: MailRuleAction): boolean {
+  if (left.type !== right.type) return false;
+  if (left.type === 'move' && right.type === 'move') {
+    return left.mailboxName === right.mailboxName
+      && (!left.mailboxId || !right.mailboxId || left.mailboxId === right.mailboxId);
+  }
+  if (left.type === 'redirect' && right.type === 'redirect') {
+    return left.address === right.address;
+  }
+  return true;
+}
+
 function isRecord(value: unknown): value is Record<string, any> {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
diff --git a/src/stores/rules-store.ts b/src/stores/rules-store.ts
index d9a11a21..47370541 100644
--- a/src/stores/rules-store.ts
+++ b/src/stores/rules-store.ts
@@ -25,6 +25,7 @@ export interface MailRulesSnapshot {
   capabilities: SieveRuleCapabilities;
   scripts: RuleScriptSummary[];
   managedScript: RuleScriptSummary | null;
+  editableScript: RuleScriptSummary | null;
   foreignActiveScript: RuleScriptSummary | null;
   document: MailRuleDocument;
   parseError: string | null;
@@ -94,7 +95,9 @@ export const useRulesStore = defineStore('rules', () => {
     const document = normalizeRuleDocument(input);
     // Give immediate editor feedback; the SharedWorker compiles again
     // against a freshly fetched capability snapshot before uploading.
-    compileRules(document, snapshot.value.capabilities);
+    compileRules(document, snapshot.value.capabilities, {
+      managed: snapshot.value.managedScript !== null || snapshot.value.editableScript === null,
+    });
 
     saving.value = true;
     error.value = null;
diff --git a/src/sync/backends/jmap/sieve.ts b/src/sync/backends/jmap/sieve.ts
index 2de4684d..6e8577e7 100644
--- a/src/sync/backends/jmap/sieve.ts
+++ b/src/sync/backends/jmap/sieve.ts
@@ -5,6 +5,7 @@ import {
   MANAGED_SCRIPT_NAME,
   normalizeRuleDocument,
   parseManagedRules,
+  parseVisualRules,
   RuleValidationError,
   SIEVE_CAPABILITY,
   uniqueManagedScriptName,
@@ -27,6 +28,7 @@ export interface MailRulesSnapshot {
   capabilities: SieveRuleCapabilities;
   scripts: Array<{ id: string; name: string | null; isActive: boolean }>;
   managedScript: { id: string; name: string | null; isActive: boolean } | null;
+  editableScript: { id: string; name: string | null; isActive: boolean } | null;
   foreignActiveScript: { id: string; name: string | null } | null;
   document: MailRuleDocument;
   parseError: string | null;
@@ -62,6 +64,7 @@ export async function getMailRules({
   const scripts = normalizeScriptList(response.list);
   const managed: Array<{ script: SieveScriptRecord; document: MailRuleDocument }> = [];
   const malformedManaged: string[] = [];
+  const sources = new Map<string, string>();
 
   for (const script of scripts) {
     const bytes = await transport.download({
@@ -71,6 +74,7 @@ export async function getMailRules({
       name: `${script.name || 'script'}.siv`,
     });
     const source = new TextDecoder().decode(bytes);
+    sources.set(script.id, source);
     if (!isManagedRulesScript(source)) continue;
     try {
       const document = parseManagedRules(source);
@@ -86,8 +90,20 @@ export async function getMailRules({
   } else if (managed.length > 1) {
     parseError = 'More than one Stormbox-managed rule script exists. Resolve the duplicate scripts before saving.';
   }
-  const selected = managed.find((entry) => entry.script.isActive) ?? managed[0] ?? null;
   const active = scripts.find((script) => script.isActive) ?? null;
+  const activeManaged = managed.find((entry) => entry.script.id === active?.id) ?? null;
+  let selected = activeManaged;
+  if (!selected && active && malformedManaged.length === 0) {
+    try {
+      selected = {
+        script: active,
+        document: parseVisualRules(sources.get(active.id) ?? ''),
+      };
+    } catch {
+      // An unrepresentable active script remains available for explicit takeover.
+    }
+  }
+  selected ??= managed[0] ?? null;
   const foreignActive = active && active.id !== selected?.script.id ? active : null;
 
   return {
@@ -96,7 +112,10 @@ export async function getMailRules({
     state: typeof response.state === 'string' ? response.state : null,
     capabilities: context.capabilities,
     scripts: scripts.map(publicScript),
-    managedScript: selected ? publicScript(selected.script) : null,
+    managedScript: selected && isManagedRulesScript(sources.get(selected.script.id) ?? '')
+      ? publicScript(selected.script)
+      : null,
+    editableScript: selected ? publicScript(selected.script) : null,
     foreignActiveScript: foreignActive
       ? { id: foreignActive.id, name: foreignActive.name }
       : null,
@@ -151,7 +170,9 @@ export async function runSetSieveRules({
 
   let source: string;
   try {
-    source = compileRules(document, snapshot.capabilities);
+    source = compileRules(document, snapshot.capabilities, {
+      managed: snapshot.managedScript !== null || snapshot.editableScript === null,
+    });
   } catch (error) {
     return terminalError('invalidRules', errorMessage(error));
   }
@@ -195,7 +216,7 @@ export async function runSetSieveRules({
     );
   }
 
-  const managed = snapshot.managedScript;
+  const managed = snapshot.editableScript;
   const creationId = 'stormbox';
   const setRequest: any = {
     accountId: snapshot.accountId,
@@ -306,6 +327,7 @@ function unsupportedSnapshot(): MailRulesSnapshot {
     capabilities: { sieveExtensions: [] },
     scripts: [],
     managedScript: null,
+    editableScript: null,
     foreignActiveScript: null,
     document: emptyRuleDocument(),
     parseError: null,
diff --git a/tests/e2e/mail-rules.spec.js b/tests/e2e/mail-rules.spec.js
index 3937007b..aa0dbbcc 100644
--- a/tests/e2e/mail-rules.spec.js
+++ b/tests/e2e/mail-rules.spec.js
@@ -21,7 +21,7 @@ test.skip(!localStackEnabled, skipLocalStackMessage);
 
 const CORE = 'urn:ietf:params:jmap:core';
 const SIEVE = 'urn:ietf:params:jmap:sieve';
-const MANAGED_MARKER = '# stormbox-managed: mail-rules/v1';
+const MANAGED_MARKER = '# stormbox-managed: mail-rules/v2';
 const RULE_NAME = 'MailRulesE2E visual rule';
 const CONDITION_VALUE = 'MailRulesE2E';
 
@@ -59,7 +59,9 @@ async function restoreScripts(jmap, before) {
     {
       accountId: jmap.accountId,
       ...(Object.keys(update).length > 0 ? { update } : {}),
-      onSuccessActivateScript: activeBefore,
+      ...(activeBefore
+        ? { onSuccessActivateScript: activeBefore }
+        : { onSuccessDeactivateScript: true }),
     },
     'restoreScripts',
   ]]);
@@ -73,7 +75,9 @@ async function restoreScripts(jmap, before) {
       {
         accountId: jmap.accountId,
         destroy: createdIds,
-        onSuccessActivateScript: activeBefore,
+        ...(activeBefore
+          ? { onSuccessActivateScript: activeBefore }
+          : { onSuccessDeactivateScript: true }),
       },
       'removeCreatedScripts',
     ]]);
@@ -107,6 +111,13 @@ test.describe('JMAP Sieve mail rules e2e', () => {
       const rule = dialog.locator('.mail-rule').last();
       await rule.locator('input[aria-label="Rule name"]').fill(RULE_NAME);
       await rule.locator('input[aria-label="Condition value"]').fill(CONDITION_VALUE);
+      await rule.getByRole('button', { name: 'Group' }).click();
+      const nestedGroup = rule.locator('.condition-group--nested');
+      await nestedGroup.getByLabel('Nested condition match mode').click();
+      await nestedGroup.locator('[data-rule-option="any"]').click();
+      await nestedGroup.getByLabel('Condition value').fill('lead@example.com');
+      await nestedGroup.getByRole('button', { name: 'Condition' }).click();
+      await nestedGroup.getByLabel('Condition value').nth(1).fill('manager@example.com');
       await dialog.locator('[data-mail-rules-save]').click();
 
       const takeover = page.getByRole('alertdialog', { name: 'Activate Stormbox rules?' });
@@ -139,13 +150,15 @@ test.describe('JMAP Sieve mail rules e2e', () => {
       })).toString('utf8');
       expect(source).toContain(MANAGED_MARKER);
       expect(source).toContain(CONDITION_VALUE);
+      expect(source).toContain('anyof (address :contains "From" "lead@example.com", address :contains "From" "manager@example.com")');
 
       await dialog.getByRole('button', { name: 'Close', exact: true }).click();
       await expect(dialog).toBeHidden({ timeout: 5_000 });
       dialog = await openRulesDialog(page);
       const savedRule = dialog.locator('.mail-rule').filter({ hasText: RULE_NAME });
       await expect(savedRule.locator('input[aria-label="Rule name"]')).toHaveValue(RULE_NAME);
-      await expect(savedRule.locator('input[aria-label="Condition value"]')).toHaveValue(CONDITION_VALUE);
+      await expect(savedRule.locator('input[aria-label="Condition value"]').first()).toHaveValue(CONDITION_VALUE);
+      await expect(savedRule.locator('.condition-group--nested')).toHaveCount(1);
       await dialog.getByRole('button', { name: 'Close', exact: true }).click();
     } finally {
       await restoreScripts(jmap, before);
diff --git a/tests/unit/components/mail-rule-select.test.ts b/tests/unit/components/mail-rule-select.test.ts
new file mode 100644
index 00000000..efa30e73
--- /dev/null
+++ b/tests/unit/components/mail-rule-select.test.ts
@@ -0,0 +1,87 @@
+// @vitest-environment happy-dom
+
+import { mount } from '@vue/test-utils';
+import { describe, expect, it } from 'vitest';
+import { nextTick } from 'vue';
+
+import MailRuleSelect from '../../../src/components/MailRuleSelect.vue';
+
+const options = [
+  { value: 'all', label: 'All conditions' },
+  { value: 'disabled', label: 'Unavailable', disabled: true },
+  { value: 'any', label: 'Any condition' },
+];
+
+describe('MailRuleSelect', () => {
+  it('supports menu keyboard navigation and restores summary focus after selection', async () => {
+    const wrapper = mount(MailRuleSelect, {
+      attachTo: document.body,
+      props: {
+        modelValue: 'all',
+        options,
+        ariaLabel: 'Condition mode',
+      },
+    });
+    const summary = wrapper.get('summary');
+
+    await summary.trigger('keydown', { key: 'ArrowDown' });
+    await nextTick();
+    expect((document.activeElement as HTMLElement).dataset.ruleOption).toBe('all');
+
+    const allOption = wrapper.get('[data-rule-option="all"]');
+    await allOption.trigger('keydown', { key: 'ArrowDown' });
+    expect((document.activeElement as HTMLElement).dataset.ruleOption).toBe('any');
+
+    const anyOption = wrapper.get('[data-rule-option="any"]');
+    await anyOption.trigger('keydown', { key: 'ArrowDown' });
+    expect((document.activeElement as HTMLElement).dataset.ruleOption).toBe('all');
+
+    await allOption.trigger('keydown', { key: 'End' });
+    expect((document.activeElement as HTMLElement).dataset.ruleOption).toBe('any');
+    await anyOption.trigger('keydown', { key: 'Home' });
+    expect((document.activeElement as HTMLElement).dataset.ruleOption).toBe('all');
+
+    await anyOption.trigger('click');
+    expect(wrapper.emitted('update:modelValue')).toEqual([['any']]);
+    expect(document.activeElement).toBe(summary.element);
+    expect(wrapper.get('details').attributes('open')).toBeUndefined();
+
+    wrapper.unmount();
+  });
+
+  it('opens upward from the summary and focuses the last enabled option', async () => {
+    const wrapper = mount(MailRuleSelect, {
+      attachTo: document.body,
+      props: {
+        modelValue: 'all',
+        options,
+        ariaLabel: 'Condition mode',
+      },
+    });
+
+    await wrapper.get('summary').trigger('keydown', { key: 'ArrowUp' });
+    await nextTick();
+    expect((document.activeElement as HTMLElement).dataset.ruleOption).toBe('any');
+
+    wrapper.unmount();
+  });
+
+  it('does not reopen from retained focus after becoming disabled', async () => {
+    const wrapper = mount(MailRuleSelect, {
+      attachTo: document.body,
+      props: {
+        modelValue: 'all',
+        options,
+        ariaLabel: 'Condition mode',
+      },
+    });
+    const summary = wrapper.get('summary');
+    (summary.element as HTMLElement).focus();
+    await wrapper.setProps({ disabled: true });
+
+    await summary.trigger('keydown', { key: 'ArrowDown' });
+    expect(wrapper.get('details').attributes('open')).toBeUndefined();
+
+    wrapper.unmount();
+  });
+});
diff --git a/tests/unit/components/mail-rules-dialog.test.ts b/tests/unit/components/mail-rules-dialog.test.ts
index 6cf3eac1..c8aafb9a 100644
--- a/tests/unit/components/mail-rules-dialog.test.ts
+++ b/tests/unit/components/mail-rules-dialog.test.ts
@@ -31,8 +31,9 @@ function snapshot(overrides: Record<string, unknown> = {}) {
     },
     scripts: [],
     managedScript: null,
+    editableScript: null,
     foreignActiveScript: null,
-    document: { version: 1, rules: [] },
+    document: { version: 2, rules: [] },
     parseError: null,
     ...overrides,
   };
@@ -63,7 +64,10 @@ function mountDialog() {
   });
 }
 
-function installRepo({ foreign = false } = {}) {
+function installRepo({
+  foreign = false,
+  saveGate = null,
+}: { foreign?: boolean; saveGate?: Promise<void> | null } = {}) {
   let serverSnapshot = snapshot(foreign ? {
     scripts: [{ id: 'foreign', name: 'Handwritten filters', isActive: true }],
     foreignActiveScript: { id: 'foreign', name: 'Handwritten filters' },
@@ -76,11 +80,13 @@ function installRepo({ foreign = false } = {}) {
       return { id: 72 };
     }),
     runMutation: vi.fn(async () => {
+      if (saveGate) await saveGate;
       serverSnapshot = snapshot({
         state: 'sieve-state-2',
         document: pendingRequest.document,
         scripts: [{ id: 'managed', name: 'Stormbox Mail Rules', isActive: true }],
         managedScript: { id: 'managed', name: 'Stormbox Mail Rules', isActive: true },
+        editableScript: { id: 'managed', name: 'Stormbox Mail Rules', isActive: true },
       });
       return { attempted: 1, succeeded: 1, failed: 0 };
     }),
@@ -108,6 +114,7 @@ describe('MailRulesDialog', () => {
 
     expect(wrapper.text()).toContain('No rules yet');
     await wrapper.get('[data-mail-rules-add]').trigger('click');
+    expect(wrapper.find('select').exists()).toBe(false);
     await wrapper.get('input[aria-label="Condition value"]').setValue('newsletter');
     await wrapper.get('[data-mail-rules-save]').trigger('click');
     await flushPromises();
@@ -124,6 +131,72 @@ describe('MailRulesDialog', () => {
     expect(wrapper.text()).toContain('Rules saved, validated, and activated.');
   });
 
+  it('builds nested any/all condition groups', async () => {
+    const repo = installRepo();
+    const wrapper = mountDialog();
+    await flushPromises();
+
+    await wrapper.get('[data-mail-rules-add]').trigger('click');
+    await wrapper.get('input[aria-label="Condition value"]').setValue('project');
+    const addGroup = wrapper.findAll('button').find((button) => button.text().trim() === 'Group');
+    expect(addGroup).toBeTruthy();
+    await addGroup!.trigger('click');
+
+    const nested = wrapper.get('.condition-group--nested');
+    await nested.get('summary[aria-label="Nested condition match mode"]').trigger('click');
+    await nested.get('[data-rule-option="any"]').trigger('click');
+    await nested.get('.condition-group__header input[type="checkbox"]').setValue(true);
+    await nested.get('input[aria-label="Condition value"]').setValue('lead@example.com');
+    const addNestedCondition = nested.findAll('button')
+      .find((button) => button.text().trim() === 'Condition');
+    await addNestedCondition!.trigger('click');
+    const nestedValues = nested.findAll('input[aria-label="Condition value"]');
+    await nestedValues[1].setValue('manager@example.com');
+
+    await wrapper.get('[data-mail-rules-save]').trigger('click');
+    await flushPromises();
+
+    const queued = JSON.parse(repo.insertPendingMutation.mock.calls[0][0].requestJson);
+    expect(queued.document.rules[0]).toMatchObject({
+      match: 'all',
+      conditions: [
+        { type: 'condition', value: 'project' },
+        {
+          type: 'group',
+          match: 'any',
+          negated: true,
+          conditions: [
+            { type: 'condition', value: 'lead@example.com' },
+            { type: 'condition', value: 'manager@example.com' },
+          ],
+        },
+      ],
+    });
+  });
+
+  it('locks the draft while a server save is in flight', async () => {
+    let releaseSave = () => {};
+    const saveGate = new Promise<void>((resolve) => {
+      releaseSave = resolve;
+    });
+    installRepo({ saveGate });
+    const wrapper = mountDialog();
+    await flushPromises();
+
+    await wrapper.get('[data-mail-rules-add]').trigger('click');
+    const condition = wrapper.get('input[aria-label="Condition value"]');
+    await condition.setValue('locked');
+    await wrapper.get('[data-mail-rules-save]').trigger('click');
+    await flushPromises();
+
+    expect(wrapper.get('[data-mail-rules-save]').attributes('disabled')).toBeDefined();
+    expect(condition.attributes('disabled')).toBeDefined();
+
+    releaseSave();
+    await flushPromises();
+    expect(wrapper.text()).toContain('Rules saved, validated, and activated.');
+  });
+
   it('requires confirmation before replacing a foreign active script', async () => {
     const repo = installRepo({ foreign: true });
     const wrapper = mountDialog();
diff --git a/tests/unit/sieve/parser.test.ts b/tests/unit/sieve/parser.test.ts
new file mode 100644
index 00000000..e8378239
--- /dev/null
+++ b/tests/unit/sieve/parser.test.ts
@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest';
+
+import { parseSieve, SieveSyntaxError } from '../../../src/sieve/parser';
+
+describe('Sieve syntax parser', () => {
+  it('builds nested test nodes with source ranges', () => {
+    const source = [
+      '/* existing script */',
+      'if allof (header :contains "Subject" "Project", not anyof (address :is "From" "a@example.com", address :is "From" "b@example.com")) {',
+      '  addflag "\\\\Flagged";',
+      '}',
+    ].join('\r\n');
+
+    const script = parseSieve(source);
+    expect(script.statements).toHaveLength(1);
+    expect(script.statements[0]).toMatchObject({
+      type: 'if',
+      comments: ['existing script'],
+      branches: [{
+        test: {
+          type: 'allof',
+          tests: [
+            { type: 'call', name: 'header' },
+            { type: 'not', test: { type: 'anyof' } },
+          ],
+        },
+      }],
+    });
+    expect(source.slice(
+      script.statements[0].range.start,
+      script.statements[0].range.end,
+    )).toMatch(/^if allof/);
+  });
+
+  it('parses elsif branches and multi-line strings before visual projection', () => {
+    const source = [
+      'if header :is "Subject" "one" { discard; }',
+      'elsif header :is "Subject" "two" {',
+      '  vacation text:# explanatory comment',
+      'Out of office',
+      '.',
+      '  ;',
+      '}',
+      '',
+    ].join('\r\n');
+    const script = parseSieve(source);
+    expect(script.statements[0]).toMatchObject({
+      type: 'if',
+      branches: [
+        { test: { type: 'call', name: 'header' } },
+        {
+          test: { type: 'call', name: 'header' },
+          commands: [{
+            type: 'command', name: 'vacation', arguments: [{ type: 'string', value: 'Out of office\r\n' }],
+          }],
+        },
+      ],
+    });
+  });
+
+  it('reports syntax locations', () => {
+    expect(() => parseSieve('if header :is "Subject" "broken" {\r\n  discard;'))
+      .toThrow(SieveSyntaxError);
+    expect(() => parseSieve('if header :is "Subject" "broken" {\r\n  discard;'))
+      .toThrow(/line 2/);
+  });
+
+  it('retains trailing comments separately from the preceding statement', () => {
+    const script = parseSieve('keep;\r\n# trailing note\r\n');
+    expect(script.statements[0].comments).toEqual([]);
+    expect(script.trailingComments).toEqual(['trailing note']);
+  });
+
+  it('rejects excessive recursive nesting before exhausting the JS stack', () => {
+    const source = `if ${'not '.repeat(70)}true { keep; }`;
+    expect(() => parseSieve(source)).toThrow(/parser nesting limit/);
+  });
+});
diff --git a/tests/unit/sieve/rules.test.ts b/tests/unit/sieve/rules.test.ts
index 59a7d95c..1c8c372b 100644
--- a/tests/unit/sieve/rules.test.ts
+++ b/tests/unit/sieve/rules.test.ts
@@ -5,6 +5,7 @@ import {
   isManagedRulesScript,
   MANAGED_SCRIPT_MARKER,
   parseManagedRules,
+  parseVisualRules,
   RuleValidationError,
   uniqueManagedScriptName,
 } from '../../../src/sieve/rules';
@@ -18,7 +19,7 @@ const ALL_CAPABILITIES: SieveRuleCapabilities = {
 
 function document(): MailRuleDocument {
   return {
-    version: 1,
+    version: 2,
     rules: [{
       id: 'rule-1',
       name: 'File important mail',
@@ -26,10 +27,12 @@ function document(): MailRuleDocument {
       match: 'all',
       conditions: [
         {
-          id: 'condition-1', field: 'from', operator: 'contains', value: '@example.com',
+          id: 'condition-1', type: 'condition', negated: false,
+          field: 'from', operator: 'contains', value: '@example.com',
         },
         {
-          id: 'condition-2', field: 'subject', operator: 'matches', value: '*invoice*',
+          id: 'condition-2', type: 'condition', negated: false,
+          field: 'subject', operator: 'matches', value: '*invoice*',
         },
       ],
       actions: [
@@ -59,13 +62,15 @@ describe('mail-rule Sieve compiler', () => {
     expect(source).toContain('redirect :copy "archive@example.net";');
     expect(source).toContain('  stop;');
     expect(isManagedRulesScript(source)).toBe(true);
-    expect(parseManagedRules(source)).toEqual(input);
+    expect(withoutIds(parseManagedRules(source))).toEqual(withoutIds(input));
   });
 
-  it('escapes user strings and omits disabled rules from executable code', () => {
+  it('escapes user strings and round-trips disabled rules through a false branch', () => {
     const input = document();
     input.rules[0].conditions = [{
       id: 'condition-escape',
+      type: 'condition',
+      negated: false,
       field: 'subject',
       operator: 'contains',
       value: 'say "hi" \\ there',
@@ -76,7 +81,8 @@ describe('mail-rule Sieve compiler', () => {
       enabled: false,
       match: 'all',
       conditions: [{
-        id: 'condition-disabled', field: 'subject', operator: 'is', value: 'DO-NOT-EMIT',
+        id: 'condition-disabled', type: 'condition', negated: false,
+        field: 'subject', operator: 'is', value: 'DO-NOT-EMIT',
       }],
       actions: [{ id: 'action-disabled', type: 'discard' }],
       stopProcessing: true,
@@ -84,8 +90,8 @@ describe('mail-rule Sieve compiler', () => {
 
     const source = compileRules(input, ALL_CAPABILITIES);
     expect(source).toContain('header :contains "Subject" "say \\"hi\\" \\\\ there"');
-    expect(source).not.toContain('# Rule: Disabled executable marker');
-    expect(parseManagedRules(source)?.rules[1].conditions[0].value).toBe('DO-NOT-EMIT');
+    expect(source).toContain('# Disabled rule: Disabled executable marker');
+    expect(withoutIds(parseManagedRules(source))).toEqual(withoutIds(input));
   });
 
   it('uses a path-only fallback when mailboxid is unavailable', () => {
@@ -122,6 +128,8 @@ describe('mail-rule Sieve compiler', () => {
     const invalidHeader = document();
     invalidHeader.rules[0].conditions = [{
       id: 'condition-header',
+      type: 'condition',
+      negated: false,
       field: 'header',
       headerName: 'Bad:Header',
       operator: 'contains',
@@ -147,7 +155,8 @@ describe('mail-rule Sieve compiler', () => {
       enabled: true,
       match: 'all',
       conditions: [{
-        id: 'condition-2a', field: 'subject', operator: 'contains', value: 'two',
+        id: 'condition-2a', type: 'condition', negated: false,
+        field: 'subject', operator: 'contains', value: 'two',
       }],
       actions: [{ id: 'redirect-2', type: 'redirect', address: 'two@example.net' }],
       stopProcessing: false,
@@ -163,13 +172,197 @@ describe('mail-rule Sieve compiler', () => {
 
   it('rejects corrupt managed metadata without claiming foreign scripts', () => {
     expect(parseManagedRules('require ["fileinto"];\r\nkeep;')).toBeNull();
-    expect(() => parseManagedRules(`${MANAGED_SCRIPT_MARKER}\r\n# stormbox-data: !!!`))
+    expect(() => parseManagedRules('# stormbox-managed: mail-rules/v1\r\n# stormbox-data: !!!'))
       .toThrow(/metadata is missing or malformed/);
   });
 
+  it('migrates version 1 managed metadata to the source-backed model', () => {
+    const legacy = {
+      version: 1,
+      rules: [
+        {
+          id: 'legacy-rule',
+          name: 'Legacy receipts',
+          enabled: true,
+          match: 'all',
+          conditions: [{
+            id: 'legacy-condition', field: 'subject', operator: 'contains', value: 'Receipt',
+          }],
+          actions: [{ id: 'legacy-action', type: 'markRead' }],
+          stopProcessing: true,
+        },
+        {
+          id: 'legacy-disabled',
+          name: 'Disabled legacy rule',
+          enabled: false,
+          match: 'all',
+          conditions: [{
+            id: 'legacy-disabled-condition', field: 'from', operator: 'is', value: 'later@example.com',
+          }],
+          actions: [{ id: 'legacy-disabled-action', type: 'discard' }],
+          stopProcessing: true,
+        },
+      ],
+    };
+    const encoded = Buffer.from(JSON.stringify(legacy)).toString('base64url');
+    const matchingSource = [
+      '# Stormbox managed mail rules. Edit these rules in Stormbox.',
+      '# stormbox-managed: mail-rules/v1',
+      `# stormbox-data: ${encoded}`,
+      'require ["imap4flags"];',
+      '# Rule: Legacy receipts',
+      'if header :contains "Subject" "Receipt" {',
+      '  addflag "\\\\Seen";',
+      '  stop;',
+      '}',
+      '',
+    ].join('\r\n');
+    const parsed = parseManagedRules(matchingSource);
+
+    expect(parsed).toMatchObject({
+      version: 2,
+      rules: [
+        {
+          name: 'Legacy receipts',
+          conditions: [{ type: 'condition', negated: false, value: 'Receipt' }],
+        },
+        { name: 'Disabled legacy rule', enabled: false },
+      ],
+    });
+
+    expect(() => parseManagedRules(matchingSource.replace(
+      '  addflag "\\\\Seen";',
+      '  discard;',
+    ))).toThrow(/metadata differs from its executable Sieve/);
+  });
+
+  it('keeps executable path-only folder routing authoritative during version 1 migration', () => {
+    const legacy = {
+      version: 1,
+      rules: [{
+        id: 'legacy-rule',
+        name: 'Archive receipts',
+        enabled: true,
+        match: 'all',
+        conditions: [{
+          id: 'legacy-condition', field: 'subject', operator: 'contains', value: 'Receipt',
+        }],
+        actions: [{
+          id: 'legacy-action', type: 'move', mailboxId: 'mailbox-archive', mailboxName: 'Archive',
+        }],
+        stopProcessing: true,
+      }],
+    };
+    const encoded = Buffer.from(JSON.stringify(legacy)).toString('base64url');
+    const parsed = parseManagedRules([
+      '# Stormbox managed mail rules. Edit these rules in Stormbox.',
+      '# stormbox-managed: mail-rules/v1',
+      `# stormbox-data: ${encoded}`,
+      'require ["fileinto"];',
+      '# Rule: Archive receipts',
+      'if header :contains "Subject" "Receipt" {',
+      '  fileinto "Archive";',
+      '  stop;',
+      '}',
+      '',
+    ].join('\r\n'));
+
+    expect(parsed?.rules[0].actions[0]).toMatchObject({
+      type: 'move', mailboxId: '', mailboxName: 'Archive',
+    });
+    const compiled = compileRules(parsed, ALL_CAPABILITIES);
+    expect(compiled).toContain('fileinto "Archive";');
+    expect(compiled).not.toContain(':mailboxid');
+  });
+
+  it('parses a compatible existing script and nested Boolean groups from source', () => {
+    const source = [
+      'require ["imap4flags"];',
+      '# Rule: Priority project mail',
+      'if allof (anyof (address :is "From" "lead@example.com", header :contains "Subject" "Project"), not header :contains "X-Spam" "yes") {',
+      '  addflag "\\\\Flagged";',
+      '  stop;',
+      '}',
+      '',
+    ].join('\r\n');
+
+    const parsed = parseVisualRules(source);
+    expect(parsed.rules[0]).toMatchObject({
+      name: 'Priority project mail',
+      match: 'all',
+      conditions: [
+        {
+          type: 'group',
+          match: 'any',
+          negated: false,
+          conditions: [
+            { type: 'condition', field: 'from', operator: 'is', value: 'lead@example.com' },
+            { type: 'condition', field: 'subject', operator: 'contains', value: 'Project' },
+          ],
+        },
+        {
+          type: 'condition', field: 'header', headerName: 'X-Spam',
+          operator: 'contains', value: 'yes', negated: true,
+        },
+      ],
+      actions: [{ type: 'star' }],
+      stopProcessing: true,
+    });
+    expect(compileRules(parsed, ALL_CAPABILITIES))
+      .toContain('allof (anyof (address :is "From" "lead@example.com", header :contains "Subject" "Project"), not header :contains "X-Spam" "yes")');
+  });
+
+  it('accepts implicit and explicit default match arguments', () => {
+    const source = [
+      'require ["imap4flags"];',
+      'if allof (',
+      '  header "Subject" "Status",',
+      '  address :comparator "i;ascii-casemap" :all :contains "From" "@example.com"',
+      ') {',
+      '  addflag "\\\\Seen";',
+      '}',
+      '',
+    ].join('\r\n');
+
+    expect(parseVisualRules(source).rules[0].conditions).toMatchObject([
+      { type: 'condition', field: 'subject', operator: 'is', value: 'Status' },
+      { type: 'condition', field: 'from', operator: 'contains', value: '@example.com' },
+    ]);
+  });
+
+  it('preserves significant whitespace in source-derived match values', () => {
+    const parsed = parseVisualRules([
+      'if header :is "Subject" " urgent " {',
+      '  discard;',
+      '}',
+      '',
+    ].join('\r\n'));
+
+    expect(parsed.rules[0].conditions[0]).toMatchObject({ value: ' urgent ' });
+    expect(compileRules(parsed, ALL_CAPABILITIES)).toContain('"Subject" " urgent "');
+  });
+
+  it('rejects required extensions that can change otherwise representable source semantics', () => {
+    expect(() => parseVisualRules([
+      'require ["encoded-character"];',
+      'if header :is "Subject" "${hex:41}" {',
+      '  discard;',
+      '}',
+      '',
+    ].join('\r\n'))).toThrow(/encoded-character.+not safe to rewrite visually/);
+  });
+
   it('chooses a non-conflicting managed script name', () => {
     expect(uniqueManagedScriptName(['Personal filters'])).toBe('Stormbox Mail Rules');
     expect(uniqueManagedScriptName(['Stormbox Mail Rules', 'Stormbox Mail Rules 2']))
       .toBe('Stormbox Mail Rules 3');
   });
 });
+
+function withoutIds(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(withoutIds);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.entries(value)
+    .filter(([key]) => key !== 'id')
+    .map(([key, item]) => [key, withoutIds(item)]));
+}
diff --git a/tests/unit/stores/rules-store.test.ts b/tests/unit/stores/rules-store.test.ts
index 5f00cf2a..75d997b5 100644
--- a/tests/unit/stores/rules-store.test.ts
+++ b/tests/unit/stores/rules-store.test.ts
@@ -15,6 +15,7 @@ import {
   __setRepositoryForTests,
 } from '../../../src/composables/useRepository';
 import { MUTATION_TYPE } from '../../../src/constants/states';
+import { compileRules } from '../../../src/sieve/rules';
 import type { MailRuleDocument } from '../../../src/sieve/rules';
 import { useAuthStore } from '../../../src/stores/auth-store';
 import {
@@ -24,14 +25,15 @@ import {
 
 function document(): MailRuleDocument {
   return {
-    version: 1,
+    version: 2,
     rules: [{
       id: 'rule-1',
       name: 'Receipts',
       enabled: true,
       match: 'all',
       conditions: [{
-        id: 'condition-1', field: 'subject', operator: 'contains', value: 'Receipt',
+        id: 'condition-1', type: 'condition', negated: false,
+        field: 'subject', operator: 'contains', value: 'Receipt',
       }],
       actions: [{ id: 'action-1', type: 'markRead' }],
       stopProcessing: true,
@@ -51,6 +53,7 @@ function snapshot(overrides: Record<string, unknown> = {}) {
     },
     scripts: [],
     managedScript: null,
+    editableScript: null,
     foreignActiveScript: null,
     document: document(),
     parseError: null,
@@ -112,6 +115,38 @@ describe('rules store', () => {
     expect(store.saving).toBe(false);
   });
 
+  it('sizes an editable external script without adding a managed marker', async () => {
+    const input = document();
+    const capabilities = {
+      sieveExtensions: ['imap4flags'],
+      maxSizeScript: null,
+      maxNumberRedirects: 4,
+    };
+    const externalSource = compileRules(input, capabilities, { managed: false });
+    const externalSnapshot = snapshot({
+      capabilities: {
+        ...capabilities,
+        maxSizeScript: new TextEncoder().encode(externalSource).length,
+      },
+      editableScript: { id: 'personal', name: 'Personal filters', isActive: true },
+    });
+    const repo = {
+      getMailRules: vi.fn(async () => externalSnapshot),
+      insertPendingMutation: vi.fn(async () => ({ id: 95 })),
+      runMutation: vi.fn(async () => ({ attempted: 1, succeeded: 1, failed: 0 })),
+      getPendingMutationError: vi.fn(),
+    };
+    __setRepositoryForTests(repo);
+    useAuthStore().accountId = 7;
+    const store = useRulesStore();
+    await store.load();
+
+    await expect(store.save(input)).resolves.toMatchObject({
+      editableScript: { id: 'personal' },
+    });
+    expect(repo.insertPendingMutation).toHaveBeenCalledOnce();
+  });
+
   it('surfaces the typed terminal error left by the outbox', async () => {
     const repo = {
       getMailRules: vi.fn(async () => snapshot()),
diff --git a/tests/unit/sync/jmap-outbox-sieve.test.ts b/tests/unit/sync/jmap-outbox-sieve.test.ts
index 7b97a843..7fa6ab32 100644
--- a/tests/unit/sync/jmap-outbox-sieve.test.ts
+++ b/tests/unit/sync/jmap-outbox-sieve.test.ts
@@ -10,14 +10,15 @@ import { JMAP_CAPS } from '../../../src/sync/backends/jmap/transport';
 import { MockTransport } from './_mock-transport';
 
 const DOCUMENT: MailRuleDocument = {
-  version: 1,
+  version: 2,
   rules: [{
     id: 'rule-1',
     name: 'Discard automated noise',
     enabled: true,
     match: 'all',
     conditions: [{
-      id: 'condition-1', field: 'from', operator: 'contains', value: 'noise@example.net',
+      id: 'condition-1', type: 'condition', negated: false,
+      field: 'from', operator: 'contains', value: 'noise@example.net',
     }],
     actions: [{ id: 'action-1', type: 'discard' }],
     stopProcessing: true,
diff --git a/tests/unit/sync/jmap-sieve.test.ts b/tests/unit/sync/jmap-sieve.test.ts
index 0a526f0b..f97d2e20 100644
--- a/tests/unit/sync/jmap-sieve.test.ts
+++ b/tests/unit/sync/jmap-sieve.test.ts
@@ -3,6 +3,7 @@ import { describe, expect, it } from 'vitest';
 import {
   compileRules,
   emptyRuleDocument,
+  MANAGED_SCRIPT_MARKER,
   MANAGED_SCRIPT_NAME,
   SIEVE_CAPABILITY,
 } from '../../../src/sieve/rules';
@@ -40,14 +41,15 @@ function session() {
 
 function ruleDocument(): MailRuleDocument {
   return {
-    version: 1,
+    version: 2,
     rules: [{
       id: 'rule-1',
       name: 'Read receipts',
       enabled: true,
       match: 'all',
       conditions: [{
-        id: 'condition-1', field: 'subject', operator: 'contains', value: 'Receipt',
+        id: 'condition-1', type: 'condition', negated: false,
+        field: 'subject', operator: 'contains', value: 'Receipt',
       }],
       actions: [{ id: 'action-1', type: 'markRead' }],
       stopProcessing: true,
@@ -73,7 +75,7 @@ describe('JMAP Sieve rules backend', () => {
     expect(transport.requests).toHaveLength(0);
   });
 
-  it('loads managed metadata while preserving a foreign active script', async () => {
+  it('loads a managed script while preserving an unselected active script', async () => {
     const transport = new MockTransport(session());
     transport.handle('SieveScript/get', () => ({
       accountId: 'acct-1',
@@ -89,19 +91,102 @@ describe('JMAP Sieve rules backend', () => {
       notFound: [],
     }));
     transport.handleDownload(({ blobId }) => (
-      blobId === 'blob-managed' ? managedSource() : 'require ["fileinto"];\r\nkeep;\r\n'
+      blobId === 'blob-managed' ? managedSource() : 'vacation "Away";\r\n'
     ));
 
     const result = await getMailRules({ transport, account: ACCOUNT });
 
     expect(result.supported).toBe(true);
     expect(result.state).toBe('sieve-state-1');
-    expect(result.document).toEqual(ruleDocument());
+    expect(withoutIds(result.document)).toEqual(withoutIds(ruleDocument()));
     expect(result.managedScript).toMatchObject({ id: 'managed', isActive: false });
     expect(result.foreignActiveScript).toEqual({ id: 'foreign', name: 'Handwritten filters' });
     expect(result.capabilities.sieveExtensions).toEqual(EXTENSIONS);
   });
 
+  it('visualizes and updates a compatible existing active script in place', async () => {
+    const transport = new MockTransport(session());
+    let setRequest: any = null;
+    transport.handle('SieveScript/get', () => ({
+      accountId: 'acct-1',
+      state: 'sieve-state-1',
+      list: [{
+        id: 'personal', name: 'Personal filters', blobId: 'blob-personal', isActive: true,
+      }],
+    }));
+    transport.handleDownload(() => [
+      'require ["imap4flags"];',
+      '# Rule: Important projects',
+      'if allof (anyof (address :contains "From" "@example.com", header :contains "Subject" "Project"), not header :contains "X-Spam" "yes") {',
+      '  addflag "\\\\Flagged";',
+      '  stop;',
+      '}',
+      '',
+    ].join('\r\n'));
+    transport.handle('SieveScript/validate', () => ({ accountId: 'acct-1', error: null }));
+    transport.handle('SieveScript/set', (params) => {
+      setRequest = params;
+      return {
+        accountId: 'acct-1', oldState: 'sieve-state-1', newState: 'sieve-state-2',
+        updated: { personal: null },
+      };
+    });
+
+    const loaded = await getMailRules({ transport, account: ACCOUNT });
+    expect(loaded.managedScript).toBeNull();
+    expect(loaded.editableScript).toMatchObject({ id: 'personal', isActive: true });
+    expect(loaded.foreignActiveScript).toBeNull();
+    expect(loaded.document.rules[0]).toMatchObject({
+      name: 'Important projects',
+      match: 'all',
+      conditions: [{ type: 'group', match: 'any' }, { type: 'condition', negated: true }],
+    });
+
+    const result = await runSetSieveRules({
+      transport,
+      account: ACCOUNT,
+      request: { document: loaded.document, expectedState: 'sieve-state-1' },
+    });
+    expect(result.ok).toBe(true);
+    expect(setRequest).toMatchObject({
+      update: { personal: { blobId: 'blob-1' } },
+      onSuccessActivateScript: 'personal',
+    });
+    expect(setRequest.create).toBeUndefined();
+    expect(new TextDecoder().decode(transport.uploads[0].body))
+      .not.toContain(MANAGED_SCRIPT_MARKER);
+  });
+
+  it('prefers a compatible active script over an inactive managed script', async () => {
+    const transport = new MockTransport(session());
+    transport.handle('SieveScript/get', () => ({
+      accountId: 'acct-1',
+      state: 'sieve-state-1',
+      list: [
+        {
+          id: 'personal', name: 'Personal filters', blobId: 'blob-personal', isActive: true,
+        },
+        {
+          id: 'managed', name: MANAGED_SCRIPT_NAME, blobId: 'blob-managed', isActive: false,
+        },
+      ],
+    }));
+    transport.handleDownload(({ blobId }) => (
+      blobId === 'blob-managed'
+        ? managedSource()
+        : 'if header :contains "Subject" "Active" { discard; stop; }\r\n'
+    ));
+
+    const loaded = await getMailRules({ transport, account: ACCOUNT });
+    expect(loaded.editableScript).toMatchObject({ id: 'personal', isActive: true });
+    expect(loaded.managedScript).toBeNull();
+    expect(loaded.foreignActiveScript).toBeNull();
+    expect(loaded.document.rules[0]).toMatchObject({
+      conditions: [{ value: 'Active' }],
+      actions: [{ type: 'discard' }],
+    });
+  });
+
   it('requires explicit takeover, then validates and activates a new managed script', async () => {
     const transport = new MockTransport(session());
     let setRequest: any = null;
@@ -113,7 +198,7 @@ describe('JMAP Sieve rules backend', () => {
       }],
       notFound: [],
     }));
-    transport.handleDownload(() => 'keep;\r\n');
+    transport.handleDownload(() => 'vacation "Away";\r\n');
     transport.handle('SieveScript/validate', () => ({ accountId: 'acct-1', error: null }));
     transport.handle('SieveScript/set', (params) => {
       setRequest = params;
@@ -153,7 +238,7 @@ describe('JMAP Sieve rules backend', () => {
       accountId: 'acct-1', type: 'application/sieve',
     });
     expect(new TextDecoder().decode(transport.uploads[0].body))
-      .toContain('# stormbox-managed: mail-rules/v1');
+      .toContain('# stormbox-managed: mail-rules/v2');
     expect(setRequest).toMatchObject({
       accountId: 'acct-1',
       ifInState: 'sieve-state-1',
@@ -240,3 +325,11 @@ describe('JMAP Sieve rules backend', () => {
       methodCalls[0][0] === 'SieveScript/set')).toBe(false);
   });
 });
+
+function withoutIds(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(withoutIds);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.entries(value)
+    .filter(([key]) => key !== 'id')
+    .map(([key, item]) => [key, withoutIds(item)]));
+}

From 33c9d5ed95a845d16e33cdb446f265b453ab6491 Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Mon, 7 Sep 2026 11:48:32 +0100
Subject: [PATCH 04/16] Link the mail rules tracking issue. (#128)

---
 specs/010-mail-rules/spec.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/specs/010-mail-rules/spec.md b/specs/010-mail-rules/spec.md
index a0a6f7cc..f5ecd83d 100644
--- a/specs/010-mail-rules/spec.md
+++ b/specs/010-mail-rules/spec.md
@@ -2,6 +2,7 @@
 
 **Status**: Prototype proposed upstream
 **Proposal**: https://ideas.tb.pro/p/visual-server-side-mail-rules-using-jmap-sieve
+**Issue**: https://github.com/thunderbird/stormbox/issues/128
 
 ## Goal
 

From 5d26bf6e70cc453ed99fc4a50242e9764f134187 Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Mon, 7 Sep 2026 12:00:05 +0100
Subject: [PATCH 05/16] Restore the JMAP backend source. (#128)

---
 src/sync/backends/jmap/backend.ts | Bin 90059 -> 91118 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/src/sync/backends/jmap/backend.ts b/src/sync/backends/jmap/backend.ts
index a585433aa5bf2540e9768c7a29d70f2c99817d47..0f89d86e2025e58e1df56ad9c7de27ff8e7d069f 100644
GIT binary patch
literal 91118
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%0DO8i|Xpwu#JJ7hT!Yc_D!N($;6Bpw-81x`;P^~>K
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
Vb;a~b$k3TBzcf&L!1d`@|1T%0qVxa&

literal 90059
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


From 76e076488f6ad71f53acbcdf1c4b26ebfa2ce0c6 Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Mon, 7 Sep 2026 12:03:33 +0100
Subject: [PATCH 06/16] Fix rule editor type narrowing. (#128)

Use a non-reserved label prop for custom selects and make Sieve call-test narrowing explicit.
---
 src/components/MailRuleSelect.vue              | 6 +++---
 src/components/MailRuleTestEditor.vue          | 6 +++---
 src/components/MailRulesDialog.vue             | 4 ++--
 src/sieve/rules.ts                             | 9 +++++++--
 tests/unit/components/mail-rule-select.test.ts | 6 +++---
 5 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/src/components/MailRuleSelect.vue b/src/components/MailRuleSelect.vue
index 995b70d0..53ee439a 100644
--- a/src/components/MailRuleSelect.vue
+++ b/src/components/MailRuleSelect.vue
@@ -14,7 +14,7 @@ interface MailRuleSelectOption {
 const props = withDefaults(defineProps<{
   modelValue: string;
   options: readonly MailRuleSelectOption[];
-  ariaLabel: string;
+  controlLabel: string;
   placeholder?: string;
   disabled?: boolean;
 }>(), {
@@ -83,13 +83,13 @@ function selectOption(option: MailRuleSelectOption, event: Event): void {
   <AppDropdown class="mail-rule-select" :disabled="disabled">
     <summary
       class="app-dropdown__summary app-dropdown__summary--control mail-rule-select__summary"
-      :aria-label="ariaLabel"
+      :aria-label="controlLabel"
       :aria-disabled="disabled ? 'true' : undefined"
       aria-haspopup="menu"
       :tabindex="disabled ? -1 : undefined"
       @keydown="openFromKeyboard"
     >{{ selectedLabel }}</summary>
-    <div class="app-dropdown__menu mail-rule-select__menu" role="menu" :aria-label="ariaLabel">
+    <div class="app-dropdown__menu mail-rule-select__menu" role="menu" :aria-label="controlLabel">
       <button
         v-for="option in options"
         :key="option.value"
diff --git a/src/components/MailRuleTestEditor.vue b/src/components/MailRuleTestEditor.vue
index e083367f..8a275934 100644
--- a/src/components/MailRuleTestEditor.vue
+++ b/src/components/MailRuleTestEditor.vue
@@ -142,7 +142,7 @@ function onTextInput(
         class="condition-group__match"
         :model-value="match"
         :options="matchOptions"
-        :aria-label="root ? 'Condition match mode' : 'Nested condition match mode'"
+        :control-label="root ? 'Condition match mode' : 'Nested condition match mode'"
         :disabled="disabled"
         @update:model-value="updateMatch"
       />
@@ -194,7 +194,7 @@ function onTextInput(
           <MailRuleSelect
             :model-value="condition.field"
             :options="fieldOptions"
-            aria-label="Condition field"
+            control-label="Condition field"
             :disabled="disabled"
             @update:model-value="updateField(index, $event)"
           />
@@ -210,7 +210,7 @@ function onTextInput(
           <MailRuleSelect
             :model-value="condition.operator"
             :options="operatorOptions"
-            aria-label="Condition operator"
+            control-label="Condition operator"
             :disabled="disabled"
             @update:model-value="updateOperator(index, $event)"
           />
diff --git a/src/components/MailRulesDialog.vue b/src/components/MailRulesDialog.vue
index 2ee878a8..293eba9f 100644
--- a/src/components/MailRulesDialog.vue
+++ b/src/components/MailRulesDialog.vue
@@ -469,7 +469,7 @@ onBeforeUnmount(() => {
                       <MailRuleSelect
                         :model-value="action.type"
                         :options="availableActionOptions"
-                        aria-label="Rule action"
+                        control-label="Rule action"
                         :disabled="busy"
                         @update:model-value="onActionTypeChange(rule, actionIndex, $event)"
                       />
@@ -477,7 +477,7 @@ onBeforeUnmount(() => {
                         v-if="action.type === 'move'"
                         :model-value="action.mailboxId"
                         :options="folderSelectOptions"
-                        aria-label="Destination folder"
+                        control-label="Destination folder"
                         placeholder="Select folder"
                         :disabled="busy"
                         @update:model-value="onMoveTargetChange(action, $event)"
diff --git a/src/sieve/rules.ts b/src/sieve/rules.ts
index 9d3605bc..03b55b10 100644
--- a/src/sieve/rules.ts
+++ b/src/sieve/rules.ts
@@ -318,6 +318,9 @@ function testFromSieve(source: string, test: SieveTest): MailRuleTest {
       conditions: test.tests.map((child) => testFromSieve(source, child)),
     };
   }
+  if (test.type !== 'call') {
+    throw notVisualizable(source, test, `Test “${test.type}” is not represented by the visual editor`);
+  }
 
   if (!['address', 'header'].includes(test.name)) {
     throw notVisualizable(source, test, `Test “${test.name}” is not represented by the visual editor`);
@@ -379,8 +382,10 @@ function visualMatchArguments(
   let addressPartSeen = false;
   let index = 0;
 
-  while (test.arguments[index]?.type === 'tag') {
-    const tag = test.arguments[index].value;
+  while (true) {
+    const argument = test.arguments[index];
+    if (argument?.type !== 'tag') break;
+    const tag = argument.value;
     if ([':is', ':contains', ':matches'].includes(tag)) {
       if (matchTypeSeen) {
         throw notVisualizable(source, test, `Test “${test.name}” has more than one match type`);
diff --git a/tests/unit/components/mail-rule-select.test.ts b/tests/unit/components/mail-rule-select.test.ts
index efa30e73..459cbc45 100644
--- a/tests/unit/components/mail-rule-select.test.ts
+++ b/tests/unit/components/mail-rule-select.test.ts
@@ -19,7 +19,7 @@ describe('MailRuleSelect', () => {
       props: {
         modelValue: 'all',
         options,
-        ariaLabel: 'Condition mode',
+        controlLabel: 'Condition mode',
       },
     });
     const summary = wrapper.get('summary');
@@ -55,7 +55,7 @@ describe('MailRuleSelect', () => {
       props: {
         modelValue: 'all',
         options,
-        ariaLabel: 'Condition mode',
+        controlLabel: 'Condition mode',
       },
     });
 
@@ -72,7 +72,7 @@ describe('MailRuleSelect', () => {
       props: {
         modelValue: 'all',
         options,
-        ariaLabel: 'Condition mode',
+        controlLabel: 'Condition mode',
       },
     });
     const summary = wrapper.get('summary');

From 593269a135575ee9c37a04dceb114aafa180f9ec Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Mon, 7 Sep 2026 12:04:58 +0100
Subject: [PATCH 07/16] Refresh rule editor test locators after rerenders.
 (#128)

---
 tests/unit/components/mail-rules-dialog.test.ts | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tests/unit/components/mail-rules-dialog.test.ts b/tests/unit/components/mail-rules-dialog.test.ts
index c8aafb9a..2890a6f6 100644
--- a/tests/unit/components/mail-rules-dialog.test.ts
+++ b/tests/unit/components/mail-rules-dialog.test.ts
@@ -150,7 +150,8 @@ describe('MailRulesDialog', () => {
     const addNestedCondition = nested.findAll('button')
       .find((button) => button.text().trim() === 'Condition');
     await addNestedCondition!.trigger('click');
-    const nestedValues = nested.findAll('input[aria-label="Condition value"]');
+    const nestedValues = wrapper.get('.condition-group--nested')
+      .findAll('input[aria-label="Condition value"]');
     await nestedValues[1].setValue('manager@example.com');
 
     await wrapper.get('[data-mail-rules-save]').trigger('click');
@@ -190,7 +191,7 @@ describe('MailRulesDialog', () => {
     await flushPromises();
 
     expect(wrapper.get('[data-mail-rules-save]').attributes('disabled')).toBeDefined();
-    expect(condition.attributes('disabled')).toBeDefined();
+    expect(wrapper.get('input[aria-label="Condition value"]').attributes('disabled')).toBeDefined();
 
     releaseSave();
     await flushPromises();

From 0dc61123f510a89eccfb0c48376f601df610112a Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Mon, 7 Sep 2026 12:10:29 +0100
Subject: [PATCH 08/16] Requery nested rule controls after updates. (#128)

---
 tests/unit/components/mail-rules-dialog.test.ts | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/tests/unit/components/mail-rules-dialog.test.ts b/tests/unit/components/mail-rules-dialog.test.ts
index 2890a6f6..087b0e3b 100644
--- a/tests/unit/components/mail-rules-dialog.test.ts
+++ b/tests/unit/components/mail-rules-dialog.test.ts
@@ -142,16 +142,19 @@ describe('MailRulesDialog', () => {
     expect(addGroup).toBeTruthy();
     await addGroup!.trigger('click');
 
-    const nested = wrapper.get('.condition-group--nested');
-    await nested.get('summary[aria-label="Nested condition match mode"]').trigger('click');
-    await nested.get('[data-rule-option="any"]').trigger('click');
-    await nested.get('.condition-group__header input[type="checkbox"]').setValue(true);
-    await nested.get('input[aria-label="Condition value"]').setValue('lead@example.com');
-    const addNestedCondition = nested.findAll('button')
+    await wrapper.get('.condition-group--nested summary[aria-label="Nested condition match mode"]')
+      .trigger('click');
+    await wrapper.get('.condition-group--nested [data-rule-option="any"]').trigger('click');
+    await wrapper.get('.condition-group--nested .condition-group__header input[type="checkbox"]')
+      .setValue(true);
+    await wrapper.get('.condition-group--nested input[aria-label="Condition value"]')
+      .setValue('lead@example.com');
+    const addNestedCondition = wrapper.get('.condition-group--nested').findAll('button')
       .find((button) => button.text().trim() === 'Condition');
     await addNestedCondition!.trigger('click');
     const nestedValues = wrapper.get('.condition-group--nested')
       .findAll('input[aria-label="Condition value"]');
+    expect(nestedValues).toHaveLength(2);
     await nestedValues[1].setValue('manager@example.com');
 
     await wrapper.get('[data-mail-rules-save]').trigger('click');

From 4e0e8a722963b8c690e71e7acb27b9ffad1e6089 Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Mon, 7 Sep 2026 12:23:15 +0100
Subject: [PATCH 09/16] Disambiguate the nested rule E2E selector. (#128)

---
 tests/e2e/mail-rules.spec.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/e2e/mail-rules.spec.js b/tests/e2e/mail-rules.spec.js
index aa0dbbcc..2cce606a 100644
--- a/tests/e2e/mail-rules.spec.js
+++ b/tests/e2e/mail-rules.spec.js
@@ -113,7 +113,7 @@ test.describe('JMAP Sieve mail rules e2e', () => {
       await rule.locator('input[aria-label="Condition value"]').fill(CONDITION_VALUE);
       await rule.getByRole('button', { name: 'Group' }).click();
       const nestedGroup = rule.locator('.condition-group--nested');
-      await nestedGroup.getByLabel('Nested condition match mode').click();
+      await nestedGroup.locator('summary[aria-label="Nested condition match mode"]').click();
       await nestedGroup.locator('[data-rule-option="any"]').click();
       await nestedGroup.getByLabel('Condition value').fill('lead@example.com');
       await nestedGroup.getByRole('button', { name: 'Condition' }).click();

From a0b903f4a46bc5fe65b255a55ef703084602f27e Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Mon, 7 Sep 2026 12:28:38 +0100
Subject: [PATCH 10/16] Target the add-condition control precisely. (#128)

---
 tests/e2e/mail-rules.spec.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/e2e/mail-rules.spec.js b/tests/e2e/mail-rules.spec.js
index 2cce606a..bfdaa5fe 100644
--- a/tests/e2e/mail-rules.spec.js
+++ b/tests/e2e/mail-rules.spec.js
@@ -116,7 +116,7 @@ test.describe('JMAP Sieve mail rules e2e', () => {
       await nestedGroup.locator('summary[aria-label="Nested condition match mode"]').click();
       await nestedGroup.locator('[data-rule-option="any"]').click();
       await nestedGroup.getByLabel('Condition value').fill('lead@example.com');
-      await nestedGroup.getByRole('button', { name: 'Condition' }).click();
+      await nestedGroup.getByRole('button', { name: 'Condition', exact: true }).click();
       await nestedGroup.getByLabel('Condition value').nth(1).fill('manager@example.com');
       await dialog.locator('[data-mail-rules-save]').click();
 

From 0e59518581bcbcfe867dd96d1ccfd48addc66315 Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Mon, 7 Sep 2026 12:36:40 +0100
Subject: [PATCH 11/16] Locate saved rule names by input value. (#128)

---
 tests/e2e/mail-rules.spec.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tests/e2e/mail-rules.spec.js b/tests/e2e/mail-rules.spec.js
index bfdaa5fe..6e747f51 100644
--- a/tests/e2e/mail-rules.spec.js
+++ b/tests/e2e/mail-rules.spec.js
@@ -155,8 +155,9 @@ test.describe('JMAP Sieve mail rules e2e', () => {
       await dialog.getByRole('button', { name: 'Close', exact: true }).click();
       await expect(dialog).toBeHidden({ timeout: 5_000 });
       dialog = await openRulesDialog(page);
-      const savedRule = dialog.locator('.mail-rule').filter({ hasText: RULE_NAME });
-      await expect(savedRule.locator('input[aria-label="Rule name"]')).toHaveValue(RULE_NAME);
+      const savedRuleName = dialog.getByDisplayValue(RULE_NAME, { exact: true });
+      const savedRule = dialog.locator('.mail-rule').filter({ has: savedRuleName });
+      await expect(savedRuleName).toHaveValue(RULE_NAME);
       await expect(savedRule.locator('input[aria-label="Condition value"]').first()).toHaveValue(CONDITION_VALUE);
       await expect(savedRule.locator('.condition-group--nested')).toHaveCount(1);
       await dialog.getByRole('button', { name: 'Close', exact: true }).click();

From 25a62c2f66c7235e9bb963507e66e3b7baab1299 Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Mon, 7 Sep 2026 12:41:29 +0100
Subject: [PATCH 12/16] Use the page value locator in mail-rules E2E. (#128)

---
 tests/e2e/mail-rules.spec.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/e2e/mail-rules.spec.js b/tests/e2e/mail-rules.spec.js
index 6e747f51..f6d991b6 100644
--- a/tests/e2e/mail-rules.spec.js
+++ b/tests/e2e/mail-rules.spec.js
@@ -155,7 +155,7 @@ test.describe('JMAP Sieve mail rules e2e', () => {
       await dialog.getByRole('button', { name: 'Close', exact: true }).click();
       await expect(dialog).toBeHidden({ timeout: 5_000 });
       dialog = await openRulesDialog(page);
-      const savedRuleName = dialog.getByDisplayValue(RULE_NAME, { exact: true });
+      const savedRuleName = page.getByDisplayValue(RULE_NAME, { exact: true });
       const savedRule = dialog.locator('.mail-rule').filter({ has: savedRuleName });
       await expect(savedRuleName).toHaveValue(RULE_NAME);
       await expect(savedRule.locator('input[aria-label="Condition value"]').first()).toHaveValue(CONDITION_VALUE);

From 648777f41a55a771821d37b94ef7a5a8ab1c5b14 Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Mon, 7 Sep 2026 12:45:54 +0100
Subject: [PATCH 13/16] Reopen the last persisted mail rule in E2E. (#128)

---
 tests/e2e/mail-rules.spec.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tests/e2e/mail-rules.spec.js b/tests/e2e/mail-rules.spec.js
index f6d991b6..89562eff 100644
--- a/tests/e2e/mail-rules.spec.js
+++ b/tests/e2e/mail-rules.spec.js
@@ -155,9 +155,8 @@ test.describe('JMAP Sieve mail rules e2e', () => {
       await dialog.getByRole('button', { name: 'Close', exact: true }).click();
       await expect(dialog).toBeHidden({ timeout: 5_000 });
       dialog = await openRulesDialog(page);
-      const savedRuleName = page.getByDisplayValue(RULE_NAME, { exact: true });
-      const savedRule = dialog.locator('.mail-rule').filter({ has: savedRuleName });
-      await expect(savedRuleName).toHaveValue(RULE_NAME);
+      const savedRule = dialog.locator('.mail-rule').last();
+      await expect(savedRule.locator('input[aria-label="Rule name"]')).toHaveValue(RULE_NAME);
       await expect(savedRule.locator('input[aria-label="Condition value"]').first()).toHaveValue(CONDITION_VALUE);
       await expect(savedRule.locator('.condition-group--nested')).toHaveCount(1);
       await dialog.getByRole('button', { name: 'Close', exact: true }).click();

From c8ba1b695ea18b06a753070bd154d291897e80a5 Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Sat, 12 Sep 2026 19:37:03 +0100
Subject: [PATCH 14/16] Add raw Sieve source editing. (#128)

---
 specs/012-mail-rules/spec.md                  |  19 +-
 src/components/MailRulesDialog.vue            | 313 +++++++++++++-----
 src/sieve/rules.ts                            |  10 +
 src/stores/rules-store.ts                     |  68 ++--
 src/sync/backends/jmap/sieve.ts               | 133 ++++----
 tests/e2e/mail-rules.spec.js                  |   7 +-
 .../unit/components/mail-rules-dialog.test.ts |  88 +++--
 tests/unit/stores/rules-store.test.ts         |  49 ++-
 tests/unit/sync/jmap-sieve.test.ts            |  46 ++-
 9 files changed, 494 insertions(+), 239 deletions(-)

diff --git a/specs/012-mail-rules/spec.md b/specs/012-mail-rules/spec.md
index f5ecd83d..942ae007 100644
--- a/specs/012-mail-rules/spec.md
+++ b/specs/012-mail-rules/spec.md
@@ -6,7 +6,7 @@
 
 ## Goal
 
-Stormbox shall let a signed-in user build ordered mail rules visually and run them on the mail server through JMAP for Sieve (RFC 9661). The feature remains fully browser-owned and does not add a Stormbox application backend.
+Stormbox shall let a signed-in user build ordered mail rules visually or edit their complete Sieve source and run them on the mail server through JMAP for Sieve (RFC 9661). The feature remains fully browser-owned and does not add a Stormbox application backend.
 
 ## Requirements
 
@@ -15,27 +15,28 @@ Stormbox shall let a signed-in user build ordered mail rules visually and run th
 | MR-1 | When the account advertises `urn:ietf:params:jmap:sieve`, the account menu shall offer a Mail Rules editor. When the capability is absent, the editor shall explain that server-side rules are unavailable. |
 | MR-2 | The editor shall support ordered, enabled/disabled rules; recursively nested all/any/not condition groups; From, To, To/Cc, Subject, and custom-header conditions; and exact, contains, or wildcard matching. |
 | MR-3 | The editor shall support move, mark read, star, forward a copy, discard, and stop-processing actions, exposing only actions supported by the account's advertised Sieve extensions. |
-| MR-4 | The server-stored Sieve source shall be authoritative. Stormbox shall parse scripts into a source-ranged syntax tree and project every completely representable script into the visual rule model. UI-only identifiers may be regenerated and shall not duplicate the executable rule model in metadata. |
-| MR-5 | Every save shall use the durable mutation outbox, upload the generated script, call `SieveScript/validate`, and activate it only after validation succeeds. |
+| MR-4 | The server-stored Sieve source shall be authoritative. Stormbox shall parse scripts into a source-ranged syntax tree and project every completely representable script into the visual rule model. UI-only identifiers may be regenerated and shall not duplicate the executable rule model in metadata. The complete source shall remain available in a Source editor. |
+| MR-5 | Every save shall use the durable mutation outbox, upload the generated or directly edited script, call `SieveScript/validate`, and activate it only after validation succeeds. |
 | MR-6 | A save shall use the last observed `SieveScript` state and reject a concurrent server change instead of overwriting it. |
-| MR-7 | A compatible existing active script shall be edited in place only after it has been parsed and completely represented. If the active script cannot be represented, activating a new visual script shall require explicit confirmation and shall preserve the existing script on the server. |
+| MR-7 | The active script shall be edited in place. If it is completely representable, the user may switch between Visual and Source editors. If it is not representable, Stormbox shall open its complete source, explain the unsupported construct, and only allow switching to Visual after the edited source becomes representable. |
 | MR-8 | Move actions shall use the RFC 9042 `:mailboxid` extension when supported, retaining a readable hierarchy path as the fallback mailbox name. |
 | MR-9 | Invalid rule data, unsupported actions, server validation failures, and server conflicts shall remain visible and recoverable in the editor. Controls shall be disabled while a save is in flight. |
 | MR-10 | The editor shall be keyboard accessible, trap focus while open, and confirm before discarding unsaved changes. |
-| MR-11 | Stormbox shall only rewrite a script when every required extension is within the visual editor's semantics-preserving subset. Scripts requiring other extensions shall remain opaque and preserved. |
+| MR-11 | Stormbox shall only regenerate a script from the visual model when every required extension and executable construct is within the visual editor's semantics-preserving subset. Direct Source edits may use the server's full Sieve surface and remain subject to server validation. |
 
 ## Initial scope
 
 - Server-side filtering of newly delivered mail.
-- One visually edited script at a time; JMAP may retain other scripts and permits at most one active script.
+- One active script edited visually or as source at a time; JMAP may retain other scripts and permits at most one active script.
 - A source parser, deliberately limited visual projection, and Sieve emitter.
 - Compatible existing scripts can be visualized and edited in place.
-- Unsupported syntax remains preserved and available to a future Advanced editor.
+- Unsupported syntax falls back to the complete editable source with an exact visual-projection error.
+- Visual-to-source switching is always available; source-to-visual switching requires complete projection.
 
 ## Non-goals
 
 - Visually representing every Sieve extension or control-flow construct.
-- A raw Sieve editor in the initial delivery; the parser and source ranges shall not preclude it.
+- Rich source-editor features such as syntax highlighting, completion, and inline diagnostics.
 - Retroactively applying rules to existing messages.
 - Shared-account rule management.
 - A Cloudflare Worker rule engine; the deployment bridge only adapts browser CORS and WebSocket authentication.
@@ -43,5 +44,5 @@ Stormbox shall let a signed-in user build ordered mail rules visually and run th
 ## Verification
 
 - Unit tests cover syntax parsing, visual projection, nested grouping, escaping, capability checks, source round-tripping, conflict handling, server validation, and outbox integration.
-- Component tests cover loading, nested editing, takeover confirmation, save locking, and discard confirmation.
+- Component tests cover loading, nested editing, Visual/Source switching, raw-source fallback, save locking, and discard confirmation.
 - Local-stack Playwright coverage asserts the visible editor result, durable mutation completion, and the active script directly through JMAP in Chromium and Firefox.
diff --git a/src/components/MailRulesDialog.vue b/src/components/MailRulesDialog.vue
index 293eba9f..ba9cc04b 100644
--- a/src/components/MailRulesDialog.vue
+++ b/src/components/MailRulesDialog.vue
@@ -11,12 +11,14 @@ import MailRuleSelect from './MailRuleSelect.vue';
 import MailRuleTestEditor from './MailRuleTestEditor.vue';
 import { useAuthStore } from '../stores/auth-store';
 import { useMailStore } from '../stores/mail-store';
-import { MailRulesSaveError, useRulesStore } from '../stores/rules-store';
+import { useRulesStore } from '../stores/rules-store';
 import {
   cloneRuleDocument,
+  compileRules,
   createEmptyRule,
   newRuleId,
   normalizeRuleDocument,
+  parseRulesSource,
   RuleValidationError,
 } from '../sieve/rules';
 import type {
@@ -30,14 +32,21 @@ const mailStore = useMailStore();
 const rulesStore = useRulesStore();
 const panelEl = ref<HTMLElement | null>(null);
 const closeButtonEl = ref<HTMLButtonElement | null>(null);
+const mode = ref<'visual' | 'source'>('visual');
 const draft = ref<MailRuleDocument>({ version: 2, rules: [] });
 const baseline = ref('');
+const sourceDraft = ref('');
+const sourceBaseline = ref('');
+const visualSourceCheckpoint = ref('');
 const localError = ref<string | null>(null);
+const modeError = ref<string | null>(null);
 const notice = ref<string | null>(null);
-const confirmation = ref<'takeover' | 'discard' | null>(null);
+const confirmation = ref<'discard' | null>(null);
 
 const busy = computed(() => rulesStore.loading || rulesStore.saving);
-const dirty = computed(() => JSON.stringify(draft.value) !== baseline.value);
+const dirty = computed(() =>
+  JSON.stringify(draft.value) !== baseline.value
+  || sourceDraft.value !== sourceBaseline.value);
 const extensions = computed(() => new Set(rulesStore.capabilities.sieveExtensions));
 const canMove = computed(() => extensions.value.has('fileinto'));
 const canFlags = computed(() => extensions.value.has('imap4flags'));
@@ -149,19 +158,69 @@ function createAction(type: MailRuleAction['type']): MailRuleAction {
 
 async function load() {
   localError.value = null;
+  modeError.value = null;
   notice.value = null;
   try {
     await rulesStore.load();
-    draft.value = resolveFolderTargets(rulesStore.freshDocument());
-    baseline.value = JSON.stringify(draft.value);
+    syncDrafts();
   } catch (error) {
     localError.value = errorMessage(error);
   }
 }
 
+function syncDrafts(preferredMode?: 'visual' | 'source') {
+  draft.value = resolveFolderTargets(rulesStore.freshDocument());
+  baseline.value = JSON.stringify(draft.value);
+  visualSourceCheckpoint.value = baseline.value;
+  sourceDraft.value = rulesStore.freshSource();
+  sourceBaseline.value = sourceDraft.value;
+  mode.value = rulesStore.snapshot?.visualizationError
+    ? 'source'
+    : (preferredMode ?? 'visual');
+}
+
+function switchToSource() {
+  if (mode.value === 'source') return;
+  localError.value = null;
+  modeError.value = null;
+  const currentDocument = JSON.stringify(draft.value);
+  if (currentDocument !== visualSourceCheckpoint.value) {
+    try {
+      draft.value = refreshFolderFallbacks(draft.value);
+      sourceDraft.value = compileRules(draft.value, rulesStore.capabilities, {
+        managed: rulesStore.snapshot?.managedScript != null
+          || rulesStore.snapshot?.editableScript == null,
+      });
+      visualSourceCheckpoint.value = JSON.stringify(draft.value);
+    } catch (error) {
+      modeError.value = errorMessage(error);
+      return;
+    }
+  }
+  mode.value = 'source';
+}
+
+function switchToVisual() {
+  if (mode.value === 'visual') return;
+  localError.value = null;
+  modeError.value = null;
+  try {
+    draft.value = resolveFolderTargets(parseRulesSource(sourceDraft.value));
+    visualSourceCheckpoint.value = JSON.stringify(draft.value);
+    mode.value = 'visual';
+  } catch (error) {
+    modeError.value = errorMessage(error);
+  }
+}
+
 function requestSave() {
   localError.value = null;
+  modeError.value = null;
   notice.value = null;
+  if (mode.value === 'source') {
+    void persist();
+    return;
+  }
   try {
     draft.value = refreshFolderFallbacks(draft.value);
     normalizeRuleDocument(draft.value);
@@ -169,37 +228,21 @@ function requestSave() {
     localError.value = errorMessage(error);
     return;
   }
-  if (rulesStore.foreignActiveScript) {
-    confirmation.value = 'takeover';
-    focusConfirmation();
-    return;
-  }
-  persist(false);
+  void persist();
 }
 
-async function persist(takeover: boolean) {
-  confirmation.value = null;
+async function persist() {
   localError.value = null;
   notice.value = null;
   try {
-    await rulesStore.save(draft.value, { takeover });
-    draft.value = resolveFolderTargets(rulesStore.freshDocument());
-    baseline.value = JSON.stringify(draft.value);
-    notice.value = 'Rules saved, validated, and activated.';
+    const savedMode = mode.value;
+    if (savedMode === 'source') await rulesStore.saveSource(sourceDraft.value);
+    else await rulesStore.save(draft.value);
+    syncDrafts(savedMode);
+    notice.value = savedMode === 'source'
+      ? 'Sieve source saved, validated, and activated.'
+      : 'Rules saved, validated, and activated.';
   } catch (error) {
-    if (error instanceof MailRulesSaveError && error.code === 'foreignScriptActive') {
-      const unsaved = cloneRuleDocument(draft.value);
-      try {
-        await rulesStore.load();
-        draft.value = unsaved;
-      } catch (reloadError) {
-        localError.value = errorMessage(reloadError);
-        return;
-      }
-      confirmation.value = 'takeover';
-      focusConfirmation();
-      return;
-    }
     localError.value = errorMessage(error);
   }
 }
@@ -365,55 +408,81 @@ onBeforeUnmount(() => {
             <div v-else-if="rulesStore.snapshot.parseError" class="mail-rules__alert mail-rules__alert--error" role="alert">
               <CircleAlert :size="18" aria-hidden="true" />
               <div>
-                <strong>The managed script is not visually editable.</strong>
+                <strong>Stormbox cannot choose a script to edit.</strong>
                 <p>{{ rulesStore.snapshot.parseError }}</p>
               </div>
             </div>
 
             <template v-else-if="rulesStore.supported">
-              <div v-if="rulesStore.foreignActiveScript" class="mail-rules__alert mail-rules__alert--warning" role="status">
+              <div class="mail-rules__mode-switch" role="group" aria-label="Mail rules editor mode">
+                <button
+                  type="button"
+                  :aria-pressed="mode === 'visual'"
+                  :disabled="busy"
+                  @click="switchToVisual"
+                >Visual</button>
+                <button
+                  type="button"
+                  :aria-pressed="mode === 'source'"
+                  :disabled="busy"
+                  @click="switchToSource"
+                >Source</button>
+              </div>
+
+              <div v-if="modeError" class="mail-rules__alert mail-rules__alert--warning" role="alert">
                 <CircleAlert :size="18" aria-hidden="true" />
                 <div>
-                  <strong>Another Sieve script is active.</strong>
-                  <p>
-                    Saving will deactivate “{{ scriptLabel(rulesStore.foreignActiveScript) }}”,
-                    but it will remain stored on the server.
-                  </p>
+                  <strong>Cannot switch to the visual editor.</strong>
+                  <p>{{ modeError }}</p>
                 </div>
               </div>
 
               <div
-                v-else-if="rulesStore.snapshot.editableScript && !rulesStore.snapshot.managedScript"
-                class="mail-rules__alert"
+                v-if="mode === 'source' && rulesStore.snapshot.visualizationError && !modeError"
+                class="mail-rules__alert mail-rules__alert--warning"
                 role="status"
               >
+                <CircleAlert :size="18" aria-hidden="true" />
                 <div>
-                  <strong>This existing script is visually compatible.</strong>
-                  <p>Saving will update the same script and normalize its Sieve formatting.</p>
+                  <strong>This script cannot be represented visually.</strong>
+                  <p>{{ rulesStore.snapshot.visualizationError }}</p>
+                  <p>Edit its complete source below. The server will validate it before saving.</p>
                 </div>
               </div>
 
-              <div class="mail-rules__toolbar">
-                <div class="mail-rules__summary">
-                  <Filter :size="17" aria-hidden="true" />
-                  <span>{{ draft.rules.length }} {{ draft.rules.length === 1 ? 'rule' : 'rules' }}</span>
+              <div
+                v-else-if="mode === 'visual' && rulesStore.snapshot.editableScript"
+                class="mail-rules__alert"
+                role="status"
+              >
+                <div>
+                  <strong>This script is visually compatible.</strong>
+                  <p>Visual saves preserve its behavior, but normalize source formatting and comments.</p>
                 </div>
-                <AppButton data-mail-rules-add :disabled="busy" @click="addRule">
-                  <template #iconLeft><Plus :size="16" aria-hidden="true" /></template>
-                  Add rule
-                </AppButton>
               </div>
 
-              <p v-if="draft.rules.length === 0" class="mail-rules__empty">
-                No rules yet. Add one, or save an empty ruleset to keep all incoming mail unchanged.
-              </p>
+              <div v-if="mode === 'visual'" aria-label="Visual rule editor">
+                <div class="mail-rules__toolbar">
+                  <div class="mail-rules__summary">
+                    <Filter :size="17" aria-hidden="true" />
+                    <span>{{ draft.rules.length }} {{ draft.rules.length === 1 ? 'rule' : 'rules' }}</span>
+                  </div>
+                  <AppButton data-mail-rules-add :disabled="busy" @click="addRule">
+                    <template #iconLeft><Plus :size="16" aria-hidden="true" /></template>
+                    Add rule
+                  </AppButton>
+                </div>
+
+                <p v-if="draft.rules.length === 0" class="mail-rules__empty">
+                  No rules yet. Add one, or save an empty ruleset to keep all incoming mail unchanged.
+                </p>
 
-              <fieldset class="mail-rules__fieldset" :disabled="busy">
-                <article
-                  v-for="(rule, ruleIndex) in draft.rules"
-                  :key="rule.id"
-                  class="mail-rule"
-                >
+                <fieldset class="mail-rules__fieldset" :disabled="busy">
+                  <article
+                    v-for="(rule, ruleIndex) in draft.rules"
+                    :key="rule.id"
+                    class="mail-rule"
+                  >
                   <header class="mail-rule__header">
                     <label class="mail-rule__enabled">
                       <input v-model="rule.enabled" type="checkbox" />
@@ -508,8 +577,28 @@ onBeforeUnmount(() => {
                       Stop processing later rules when this rule matches
                     </label>
                   </div>
-                </article>
-              </fieldset>
+                  </article>
+                </fieldset>
+              </div>
+
+              <div v-else class="mail-rules__source" aria-label="Sieve source editor">
+                <div class="mail-rules__source-heading">
+                  <strong>Sieve source</strong>
+                  <span>
+                    {{ rulesStore.snapshot.editableScript
+                      ? scriptLabel(rulesStore.snapshot.editableScript)
+                      : 'New script' }}
+                  </span>
+                </div>
+                <textarea
+                  v-model="sourceDraft"
+                  aria-label="Sieve source"
+                  :disabled="busy"
+                  autocomplete="off"
+                  autocapitalize="off"
+                  spellcheck="false"
+                />
+              </div>
             </template>
           </template>
         </main>
@@ -532,31 +621,14 @@ onBeforeUnmount(() => {
             class="mail-rules__confirm"
             role="alertdialog"
             aria-modal="true"
-            :aria-labelledby="confirmation === 'takeover' ? 'takeover-title' : 'discard-title'"
+            aria-labelledby="discard-title"
           >
-            <template v-if="confirmation === 'takeover'">
-              <h3 id="takeover-title">Activate Stormbox rules?</h3>
-              <p>
-                This will deactivate “{{ scriptLabel(rulesStore.foreignActiveScript) }}”.
-                Stormbox will preserve that script unchanged so it can be reactivated elsewhere.
-              </p>
-              <div class="mail-rules__confirm-actions">
-                <AppButton variant="outline" :disabled="rulesStore.saving" @click="cancelConfirmation">Cancel</AppButton>
-                <AppButton
-                  data-mail-rules-confirm
-                  :disabled="rulesStore.saving"
-                  @click="persist(true)"
-                >Activate Stormbox rules</AppButton>
-              </div>
-            </template>
-            <template v-else>
-              <h3 id="discard-title">Discard unsaved changes?</h3>
-              <p>Your server-side rules will stay as they were when this editor opened.</p>
-              <div class="mail-rules__confirm-actions">
-                <AppButton variant="outline" @click="cancelConfirmation">Keep editing</AppButton>
-                <AppButton data-mail-rules-confirm @click="confirmDiscard">Discard changes</AppButton>
-              </div>
-            </template>
+            <h3 id="discard-title">Discard unsaved changes?</h3>
+            <p>Your server-side rules will stay as they were when this editor opened.</p>
+            <div class="mail-rules__confirm-actions">
+              <AppButton variant="outline" @click="cancelConfirmation">Keep editing</AppButton>
+              <AppButton data-mail-rules-confirm @click="confirmDiscard">Discard changes</AppButton>
+            </div>
           </section>
         </div>
       </section>
@@ -613,6 +685,40 @@ onBeforeUnmount(() => {
   overflow: auto;
   padding: 16px 20px 24px;
 }
+.mail-rules__mode-switch {
+  display: inline-flex;
+  gap: 2px;
+  margin: 0 0 14px;
+  padding: 3px;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  background: var(--panel2);
+}
+.mail-rules__mode-switch button {
+  min-width: 82px;
+  padding: 6px 12px;
+  border: 0;
+  border-radius: 5px;
+  background: transparent;
+  color: var(--muted);
+  cursor: pointer;
+  font: inherit;
+  font-size: 13px;
+  font-weight: 600;
+}
+.mail-rules__mode-switch button[aria-pressed="true"] {
+  background: var(--panel);
+  color: var(--text);
+  box-shadow: 0 1px 3px color-mix(in srgb, #000 22%, transparent);
+}
+.mail-rules__mode-switch button:focus-visible {
+  outline: 2px solid color-mix(in srgb, var(--accent) 45%, transparent);
+  outline-offset: 1px;
+}
+.mail-rules__mode-switch button:disabled {
+  cursor: default;
+  opacity: 0.55;
+}
 .mail-rules__toolbar,
 .mail-rules__footer,
 .mail-rule__header,
@@ -683,6 +789,45 @@ onBeforeUnmount(() => {
   padding: 0;
   border: 0;
 }
+.mail-rules__source {
+  display: grid;
+  gap: 9px;
+}
+.mail-rules__source-heading {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 12px;
+  color: var(--text);
+  font-size: 13px;
+}
+.mail-rules__source-heading span {
+  overflow: hidden;
+  color: var(--muted);
+  font-size: 12px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.mail-rules__source textarea {
+  box-sizing: border-box;
+  width: 100%;
+  min-height: 430px;
+  padding: 12px 14px;
+  resize: vertical;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  background: var(--panel2);
+  color: var(--text);
+  font-family: ui-monospace, SFMono-Regular, Consolas, "Liberation Mono", monospace;
+  font-size: 12px;
+  line-height: 1.55;
+  tab-size: 2;
+}
+.mail-rules__source textarea:focus-visible {
+  border-color: var(--accent);
+  outline: 2px solid color-mix(in srgb, var(--accent) 30%, transparent);
+  outline-offset: 1px;
+}
 .mail-rule {
   margin-bottom: 14px;
   border: 1px solid var(--border);
diff --git a/src/sieve/rules.ts b/src/sieve/rules.ts
index 03b55b10..bb25d821 100644
--- a/src/sieve/rules.ts
+++ b/src/sieve/rules.ts
@@ -226,6 +226,16 @@ export function parseManagedRules(script: string): MailRuleDocument | null {
   });
 }
 
+/** Parse any script that can be represented without changing its executable semantics. */
+export function parseRulesSource(script: string): MailRuleDocument {
+  if (!isManagedRulesScript(script)) return parseVisualRules(script);
+  const document = parseManagedRules(script);
+  if (!document) {
+    throw new RuleValidationError('The Stormbox-managed script could not be read.');
+  }
+  return document;
+}
+
 export function parseVisualRules(script: string): MailRuleDocument {
   const parsed = parseSieve(script);
   for (const statement of parsed.statements) {
diff --git a/src/stores/rules-store.ts b/src/stores/rules-store.ts
index 47370541..9dde87ea 100644
--- a/src/stores/rules-store.ts
+++ b/src/stores/rules-store.ts
@@ -26,8 +26,9 @@ export interface MailRulesSnapshot {
   scripts: RuleScriptSummary[];
   managedScript: RuleScriptSummary | null;
   editableScript: RuleScriptSummary | null;
-  foreignActiveScript: RuleScriptSummary | null;
+  source: string;
   document: MailRuleDocument;
+  visualizationError: string | null;
   parseError: string | null;
 }
 
@@ -53,7 +54,6 @@ export const useRulesStore = defineStore('rules', () => {
   const supported = computed(() => snapshot.value?.supported === true);
   const capabilities = computed<SieveRuleCapabilities>(() =>
     snapshot.value?.capabilities ?? { sieveExtensions: [] });
-  const foreignActiveScript = computed(() => snapshot.value?.foreignActiveScript ?? null);
 
   async function load(): Promise<MailRulesSnapshot> {
     if (authStore.accountId == null) {
@@ -77,10 +77,33 @@ export const useRulesStore = defineStore('rules', () => {
     }
   }
 
-  async function save(
-    input: MailRuleDocument,
-    { takeover = false }: { takeover?: boolean } = {},
-  ): Promise<MailRulesSnapshot> {
+  async function save(input: MailRuleDocument): Promise<MailRulesSnapshot> {
+    const current = await requireWritableSnapshot();
+    const document = normalizeRuleDocument(input);
+    // Give immediate editor feedback; the SharedWorker compiles again
+    // against a freshly fetched capability snapshot before uploading.
+    compileRules(document, current.capabilities, {
+      managed: current.managedScript !== null || current.editableScript === null,
+    });
+    return persist({ mode: 'visual', document }, current);
+  }
+
+  async function saveSource(source: string): Promise<MailRulesSnapshot> {
+    const current = await requireWritableSnapshot();
+    const size = new TextEncoder().encode(source).byteLength;
+    if (
+      typeof current.capabilities.maxSizeScript === 'number'
+      && size > current.capabilities.maxSizeScript
+    ) {
+      throw new MailRulesSaveError(
+        'invalidSieve',
+        `The script is ${size} bytes; the server limit is ${current.capabilities.maxSizeScript}.`,
+      );
+    }
+    return persist({ mode: 'source', source }, current);
+  }
+
+  async function requireWritableSnapshot(): Promise<MailRulesSnapshot> {
     if (authStore.accountId == null) {
       throw new MailRulesSaveError('notConnected', 'Sign in before saving mail rules.');
     }
@@ -91,30 +114,32 @@ export const useRulesStore = defineStore('rules', () => {
     if (snapshot.value.parseError) {
       throw new MailRulesSaveError('managedScriptUnreadable', snapshot.value.parseError);
     }
+    return snapshot.value;
+  }
 
-    const document = normalizeRuleDocument(input);
-    // Give immediate editor feedback; the SharedWorker compiles again
-    // against a freshly fetched capability snapshot before uploading.
-    compileRules(document, snapshot.value.capabilities, {
-      managed: snapshot.value.managedScript !== null || snapshot.value.editableScript === null,
-    });
-
+  async function persist(
+    request: Record<string, unknown>,
+    current: MailRulesSnapshot,
+  ): Promise<MailRulesSnapshot> {
+    const accountId = authStore.accountId;
+    if (accountId == null) {
+      throw new MailRulesSaveError('notConnected', 'Sign in before saving mail rules.');
+    }
     saving.value = true;
     error.value = null;
     try {
       const repo = await getRepositoryAsync();
       const inserted = await repo.insertPendingMutation({
-        accountId: authStore.accountId,
+        accountId,
         mutationType: MUTATION_TYPE.SET_SIEVE_RULES,
         targetMessageId: null,
         requestJson: JSON.stringify({
-          document,
-          expectedState: snapshot.value.state,
-          takeover,
+          ...request,
+          expectedState: current.state,
         }),
         optimisticPatchJson: null,
       });
-      const outcome = await repo.runMutation(authStore.accountId, inserted.id);
+      const outcome = await repo.runMutation(accountId, inserted.id);
       if ((outcome?.failed ?? 0) > 0) {
         const row = await repo.getPendingMutationError(inserted.id);
         const detail = parseErrorJson(row?.error_json);
@@ -138,6 +163,10 @@ export const useRulesStore = defineStore('rules', () => {
     return cloneRuleDocument(snapshot.value?.document ?? emptyRuleDocument());
   }
 
+  function freshSource(): string {
+    return snapshot.value?.source ?? '';
+  }
+
   function $reset() {
     loading.value = false;
     saving.value = false;
@@ -152,10 +181,11 @@ export const useRulesStore = defineStore('rules', () => {
     snapshot,
     supported,
     capabilities,
-    foreignActiveScript,
     load,
     save,
+    saveSource,
     freshDocument,
+    freshSource,
     $reset,
   };
 });
diff --git a/src/sync/backends/jmap/sieve.ts b/src/sync/backends/jmap/sieve.ts
index 6e8577e7..d0619264 100644
--- a/src/sync/backends/jmap/sieve.ts
+++ b/src/sync/backends/jmap/sieve.ts
@@ -4,8 +4,7 @@ import {
   isManagedRulesScript,
   MANAGED_SCRIPT_NAME,
   normalizeRuleDocument,
-  parseManagedRules,
-  parseVisualRules,
+  parseRulesSource,
   RuleValidationError,
   SIEVE_CAPABILITY,
   uniqueManagedScriptName,
@@ -29,8 +28,9 @@ export interface MailRulesSnapshot {
   scripts: Array<{ id: string; name: string | null; isActive: boolean }>;
   managedScript: { id: string; name: string | null; isActive: boolean } | null;
   editableScript: { id: string; name: string | null; isActive: boolean } | null;
-  foreignActiveScript: { id: string; name: string | null } | null;
+  source: string;
   document: MailRuleDocument;
+  visualizationError: string | null;
   parseError: string | null;
 }
 
@@ -62,8 +62,6 @@ export async function getMailRules({
   });
   const response = requireResponse(raw, 'SieveScript/get');
   const scripts = normalizeScriptList(response.list);
-  const managed: Array<{ script: SieveScriptRecord; document: MailRuleDocument }> = [];
-  const malformedManaged: string[] = [];
   const sources = new Map<string, string>();
 
   for (const script of scripts) {
@@ -75,36 +73,29 @@ export async function getMailRules({
     });
     const source = new TextDecoder().decode(bytes);
     sources.set(script.id, source);
-    if (!isManagedRulesScript(source)) continue;
-    try {
-      const document = parseManagedRules(source);
-      if (document) managed.push({ script, document });
-    } catch (error) {
-      malformedManaged.push(errorMessage(error));
-    }
   }
 
+  const active = scripts.find((script) => script.isActive) ?? null;
+  const managed = scripts.filter((script) =>
+    isManagedRulesScript(sources.get(script.id) ?? ''));
   let parseError: string | null = null;
-  if (malformedManaged.length > 0) {
-    parseError = malformedManaged[0];
-  } else if (managed.length > 1) {
+  let selected = active;
+  if (!selected && managed.length > 1) {
     parseError = 'More than one Stormbox-managed rule script exists. Resolve the duplicate scripts before saving.';
+  } else if (!selected) {
+    selected = managed[0] ?? null;
   }
-  const active = scripts.find((script) => script.isActive) ?? null;
-  const activeManaged = managed.find((entry) => entry.script.id === active?.id) ?? null;
-  let selected = activeManaged;
-  if (!selected && active && malformedManaged.length === 0) {
+
+  const source = selected ? (sources.get(selected.id) ?? '') : '';
+  let document = emptyRuleDocument();
+  let visualizationError: string | null = null;
+  if (selected && !parseError) {
     try {
-      selected = {
-        script: active,
-        document: parseVisualRules(sources.get(active.id) ?? ''),
-      };
-    } catch {
-      // An unrepresentable active script remains available for explicit takeover.
+      document = parseRulesSource(source);
+    } catch (error) {
+      visualizationError = errorMessage(error);
     }
   }
-  selected ??= managed[0] ?? null;
-  const foreignActive = active && active.id !== selected?.script.id ? active : null;
 
   return {
     supported: true,
@@ -112,14 +103,13 @@ export async function getMailRules({
     state: typeof response.state === 'string' ? response.state : null,
     capabilities: context.capabilities,
     scripts: scripts.map(publicScript),
-    managedScript: selected && isManagedRulesScript(sources.get(selected.script.id) ?? '')
-      ? publicScript(selected.script)
-      : null,
-    editableScript: selected ? publicScript(selected.script) : null,
-    foreignActiveScript: foreignActive
-      ? { id: foreignActive.id, name: foreignActive.name }
+    managedScript: selected && isManagedRulesScript(source)
+      ? publicScript(selected)
       : null,
-    document: selected?.document ?? emptyRuleDocument(),
+    editableScript: selected ? publicScript(selected) : null,
+    source,
+    document,
+    visualizationError,
     parseError,
   };
 }
@@ -135,11 +125,21 @@ export async function runSetSieveRules({
   request: any;
   useWebSocket?: boolean;
 }): Promise<{ ok: boolean; error?: any; result?: any; response?: any }> {
-  let document: MailRuleDocument;
-  try {
-    document = normalizeRuleDocument(request?.document);
-  } catch (error) {
-    return terminalError('invalidRules', errorMessage(error));
+  const mode = request?.mode ?? 'visual';
+  if (mode !== 'visual' && mode !== 'source') {
+    return terminalError('invalidArguments', 'The Sieve editor mode is invalid.');
+  }
+  const sourceMode = mode === 'source';
+  if (sourceMode && typeof request?.source !== 'string') {
+    return terminalError('invalidArguments', 'The Sieve source must be text.');
+  }
+  let document: MailRuleDocument | null = null;
+  if (!sourceMode) {
+    try {
+      document = normalizeRuleDocument(request?.document);
+    } catch (error) {
+      return terminalError('invalidRules', errorMessage(error));
+    }
   }
 
   let snapshot: MailRulesSnapshot;
@@ -160,21 +160,29 @@ export async function runSetSieveRules({
       'The server’s Sieve scripts changed after this editor loaded. Reload before saving.',
     );
   }
-  if (snapshot.foreignActiveScript && request?.takeover !== true) {
-    return terminalError(
-      'foreignScriptActive',
-      'Another Sieve script is active. Explicit confirmation is required before Stormbox activates its script.',
-      { foreignActiveScript: snapshot.foreignActiveScript },
-    );
-  }
 
   let source: string;
-  try {
-    source = compileRules(document, snapshot.capabilities, {
-      managed: snapshot.managedScript !== null || snapshot.editableScript === null,
-    });
-  } catch (error) {
-    return terminalError('invalidRules', errorMessage(error));
+  if (sourceMode) {
+    source = request.source;
+  } else {
+    try {
+      source = compileRules(document, snapshot.capabilities, {
+        managed: snapshot.managedScript !== null || snapshot.editableScript === null,
+      });
+    } catch (error) {
+      return terminalError('invalidRules', errorMessage(error));
+    }
+  }
+
+  const sourceBytes = new TextEncoder().encode(source);
+  if (
+    typeof snapshot.capabilities.maxSizeScript === 'number'
+    && sourceBytes.byteLength > snapshot.capabilities.maxSizeScript
+  ) {
+    return terminalError(
+      'invalidSieve',
+      `The script is ${sourceBytes.byteLength} bytes; the server limit is ${snapshot.capabilities.maxSizeScript}.`,
+    );
   }
 
   let upload;
@@ -182,7 +190,7 @@ export async function runSetSieveRules({
     upload = await transport.upload({
       accountId: snapshot.accountId,
       type: 'application/sieve',
-      body: new TextEncoder().encode(source),
+      body: sourceBytes,
     });
   } catch (error) {
     return { ok: false, error: { type: 'transport', message: errorMessage(error) } };
@@ -211,20 +219,20 @@ export async function runSetSieveRules({
   if (validation.error) {
     return terminalError(
       'invalidSieve',
-      validation.error.description ?? 'The server rejected the generated Sieve script.',
+      validation.error.description ?? 'The server rejected the Sieve script.',
       { validationError: validation.error },
     );
   }
 
-  const managed = snapshot.editableScript;
+  const target = snapshot.editableScript;
   const creationId = 'stormbox';
   const setRequest: any = {
     accountId: snapshot.accountId,
   };
   if (typeof snapshot.state === 'string') setRequest.ifInState = snapshot.state;
-  if (managed) {
-    setRequest.update = { [managed.id]: { blobId: upload.blobId } };
-    setRequest.onSuccessActivateScript = managed.id;
+  if (target) {
+    setRequest.update = { [target.id]: { blobId: upload.blobId } };
+    setRequest.onSuccessActivateScript = target.id;
   } else {
     setRequest.create = {
       [creationId]: {
@@ -248,8 +256,8 @@ export async function runSetSieveRules({
   const setResponse = pickResponse(setRaw, 'SieveScript/set');
   if (!setResponse) return methodFailure(setRaw, 'SieveScript/set');
 
-  const setError = managed
-    ? setResponse.notUpdated?.[managed.id]
+  const setError = target
+    ? setResponse.notUpdated?.[target.id]
     : setResponse.notCreated?.[creationId];
   if (setError) {
     const type = setError.type === 'stateMismatch' ? 'sieveStateMismatch' : (setError.type ?? 'sieveSetFailed');
@@ -258,7 +266,7 @@ export async function runSetSieveRules({
     });
   }
 
-  const scriptId = managed?.id ?? setResponse.created?.[creationId]?.id ?? null;
+  const scriptId = target?.id ?? setResponse.created?.[creationId]?.id ?? null;
   if (!scriptId) {
     return { ok: false, error: { type: 'noResponse', message: 'The server did not report the saved script.' } };
   }
@@ -328,8 +336,9 @@ function unsupportedSnapshot(): MailRulesSnapshot {
     scripts: [],
     managedScript: null,
     editableScript: null,
-    foreignActiveScript: null,
+    source: '',
     document: emptyRuleDocument(),
+    visualizationError: null,
     parseError: null,
   };
 }
diff --git a/tests/e2e/mail-rules.spec.js b/tests/e2e/mail-rules.spec.js
index 89562eff..db5a429e 100644
--- a/tests/e2e/mail-rules.spec.js
+++ b/tests/e2e/mail-rules.spec.js
@@ -120,11 +120,6 @@ test.describe('JMAP Sieve mail rules e2e', () => {
       await nestedGroup.getByLabel('Condition value').nth(1).fill('manager@example.com');
       await dialog.locator('[data-mail-rules-save]').click();
 
-      const takeover = page.getByRole('alertdialog', { name: 'Activate Stormbox rules?' });
-      if (await takeover.count()) {
-        await takeover.locator('[data-mail-rules-confirm]').click();
-      }
-
       await expect(dialog).toContainText('Rules saved, validated, and activated.', { timeout: 20_000 });
       await waitForPendingMutations(page);
       await expect.poll(
@@ -159,6 +154,8 @@ test.describe('JMAP Sieve mail rules e2e', () => {
       await expect(savedRule.locator('input[aria-label="Rule name"]')).toHaveValue(RULE_NAME);
       await expect(savedRule.locator('input[aria-label="Condition value"]').first()).toHaveValue(CONDITION_VALUE);
       await expect(savedRule.locator('.condition-group--nested')).toHaveCount(1);
+      await dialog.getByRole('button', { name: 'Source' }).click();
+      await expect(dialog.getByLabel('Sieve source')).toHaveValue(new RegExp(CONDITION_VALUE));
       await dialog.getByRole('button', { name: 'Close', exact: true }).click();
     } finally {
       await restoreScripts(jmap, before);
diff --git a/tests/unit/components/mail-rules-dialog.test.ts b/tests/unit/components/mail-rules-dialog.test.ts
index 087b0e3b..76584d81 100644
--- a/tests/unit/components/mail-rules-dialog.test.ts
+++ b/tests/unit/components/mail-rules-dialog.test.ts
@@ -32,8 +32,9 @@ function snapshot(overrides: Record<string, unknown> = {}) {
     scripts: [],
     managedScript: null,
     editableScript: null,
-    foreignActiveScript: null,
+    source: '',
     document: { version: 2, rules: [] },
+    visualizationError: null,
     parseError: null,
     ...overrides,
   };
@@ -65,12 +66,14 @@ function mountDialog() {
 }
 
 function installRepo({
-  foreign = false,
+  incompatible = false,
   saveGate = null,
-}: { foreign?: boolean; saveGate?: Promise<void> | null } = {}) {
-  let serverSnapshot = snapshot(foreign ? {
+}: { incompatible?: boolean; saveGate?: Promise<void> | null } = {}) {
+  let serverSnapshot = snapshot(incompatible ? {
     scripts: [{ id: 'foreign', name: 'Handwritten filters', isActive: true }],
-    foreignActiveScript: { id: 'foreign', name: 'Handwritten filters' },
+    editableScript: { id: 'foreign', name: 'Handwritten filters', isActive: true },
+    source: 'vacation "Away";\r\n',
+    visualizationError: 'Top-level “vacation” is not represented by the visual editor at line 1.',
   } : {});
   let pendingRequest: any = null;
   const repo = {
@@ -81,13 +84,21 @@ function installRepo({
     }),
     runMutation: vi.fn(async () => {
       if (saveGate) await saveGate;
-      serverSnapshot = snapshot({
-        state: 'sieve-state-2',
-        document: pendingRequest.document,
-        scripts: [{ id: 'managed', name: 'Stormbox Mail Rules', isActive: true }],
-        managedScript: { id: 'managed', name: 'Stormbox Mail Rules', isActive: true },
-        editableScript: { id: 'managed', name: 'Stormbox Mail Rules', isActive: true },
-      });
+      serverSnapshot = pendingRequest.mode === 'source'
+        ? snapshot({
+          state: 'sieve-state-2',
+          scripts: [{ id: 'foreign', name: 'Handwritten filters', isActive: true }],
+          editableScript: { id: 'foreign', name: 'Handwritten filters', isActive: true },
+          source: pendingRequest.source,
+          visualizationError: 'Top-level “vacation” is not represented by the visual editor at line 1.',
+        })
+        : snapshot({
+          state: 'sieve-state-2',
+          document: pendingRequest.document,
+          scripts: [{ id: 'managed', name: 'Stormbox Mail Rules', isActive: true }],
+          managedScript: { id: 'managed', name: 'Stormbox Mail Rules', isActive: true },
+          editableScript: { id: 'managed', name: 'Stormbox Mail Rules', isActive: true },
+        });
       return { attempted: 1, succeeded: 1, failed: 0 };
     }),
     getPendingMutationError: vi.fn(),
@@ -121,7 +132,7 @@ describe('MailRulesDialog', () => {
 
     expect(repo.insertPendingMutation).toHaveBeenCalledTimes(1);
     const queued = JSON.parse(repo.insertPendingMutation.mock.calls[0][0].requestJson);
-    expect(queued.takeover).toBe(false);
+    expect(queued.mode).toBe('visual');
     expect(queued.document.rules).toHaveLength(1);
     expect(queued.document.rules[0]).toMatchObject({
       name: 'New rule',
@@ -178,6 +189,27 @@ describe('MailRulesDialog', () => {
     });
   });
 
+  it('switches between visual rules and their generated source', async () => {
+    installRepo();
+    const wrapper = mountDialog();
+    await flushPromises();
+
+    await wrapper.get('[data-mail-rules-add]').trigger('click');
+    await wrapper.get('input[aria-label="Condition value"]').setValue('newsletter');
+    const sourceTab = wrapper.findAll('.mail-rules__mode-switch button')
+      .find((tab) => tab.text().trim() === 'Source');
+    await sourceTab!.trigger('click');
+
+    expect(wrapper.get('textarea[aria-label="Sieve source"]').element)
+      .toHaveProperty('value', expect.stringContaining('address :contains "From" "newsletter"'));
+
+    const visualTab = wrapper.findAll('.mail-rules__mode-switch button')
+      .find((tab) => tab.text().trim() === 'Visual');
+    await visualTab!.trigger('click');
+    expect(wrapper.get('input[aria-label="Condition value"]').element)
+      .toHaveProperty('value', 'newsletter');
+  });
+
   it('locks the draft while a server save is in flight', async () => {
     let releaseSave = () => {};
     const saveGate = new Promise<void>((resolve) => {
@@ -201,24 +233,34 @@ describe('MailRulesDialog', () => {
     expect(wrapper.text()).toContain('Rules saved, validated, and activated.');
   });
 
-  it('requires confirmation before replacing a foreign active script', async () => {
-    const repo = installRepo({ foreign: true });
+  it('falls back to source and saves an incompatible active script in place', async () => {
+    const repo = installRepo({ incompatible: true });
     const wrapper = mountDialog();
     await flushPromises();
 
     expect(wrapper.text()).toContain('Handwritten filters');
-    await wrapper.get('[data-mail-rules-add]').trigger('click');
-    await wrapper.get('input[aria-label="Condition value"]').setValue('invoice');
-    await wrapper.get('[data-mail-rules-save]').trigger('click');
-    await flushPromises();
+    expect(wrapper.text()).toContain('Top-level “vacation” is not represented by the visual editor at line 1.');
+    const source = wrapper.get('textarea[aria-label="Sieve source"]');
+    expect(source.element).toHaveProperty('value', 'vacation "Away";\r\n');
 
-    expect(wrapper.get('[role="alertdialog"]').text()).toContain('Activate Stormbox rules?');
-    expect(repo.insertPendingMutation).not.toHaveBeenCalled();
+    const visualTab = wrapper.findAll('.mail-rules__mode-switch button')
+      .find((tab) => tab.text().trim() === 'Visual');
+    await visualTab!.trigger('click');
+    expect(wrapper.get('[role="alert"]').text()).toContain(
+      'Top-level “vacation” is not represented by the visual editor at line 1.',
+    );
 
-    await wrapper.get('[data-mail-rules-confirm]').trigger('click');
+    await source.setValue('vacation "Back Monday";\r\n');
+    await wrapper.get('[data-mail-rules-save]').trigger('click');
     await flushPromises();
     const queued = JSON.parse(repo.insertPendingMutation.mock.calls[0][0].requestJson);
-    expect(queued.takeover).toBe(true);
+    expect(queued).toEqual({
+      mode: 'source',
+      source: 'vacation "Back Monday";\r\n',
+      expectedState: 'sieve-state-1',
+    });
+    expect(wrapper.find('[role="alertdialog"]').exists()).toBe(false);
+    expect(wrapper.text()).toContain('Sieve source saved, validated, and activated.');
   });
 
   it('confirms before discarding an edited draft', async () => {
diff --git a/tests/unit/stores/rules-store.test.ts b/tests/unit/stores/rules-store.test.ts
index 75d997b5..724a7141 100644
--- a/tests/unit/stores/rules-store.test.ts
+++ b/tests/unit/stores/rules-store.test.ts
@@ -54,8 +54,9 @@ function snapshot(overrides: Record<string, unknown> = {}) {
     scripts: [],
     managedScript: null,
     editableScript: null,
-    foreignActiveScript: null,
+    source: '',
     document: document(),
+    visualizationError: null,
     parseError: null,
     ...overrides,
   };
@@ -95,7 +96,7 @@ describe('rules store', () => {
     const store = useRulesStore();
     await store.load();
 
-    await store.save(document(), { takeover: true });
+    await store.save(document());
 
     expect(repo.insertPendingMutation).toHaveBeenCalledTimes(1);
     const pending = repo.insertPendingMutation.mock.calls[0][0];
@@ -106,9 +107,9 @@ describe('rules store', () => {
       optimisticPatchJson: null,
     });
     expect(JSON.parse(pending.requestJson)).toEqual({
+      mode: 'visual',
       document: document(),
       expectedState: 'sieve-state-1',
-      takeover: true,
     });
     expect(repo.runMutation).toHaveBeenCalledWith(7, 93);
     expect(repo.getMailRules).toHaveBeenCalledTimes(2);
@@ -129,6 +130,7 @@ describe('rules store', () => {
         maxSizeScript: new TextEncoder().encode(externalSource).length,
       },
       editableScript: { id: 'personal', name: 'Personal filters', isActive: true },
+      source: externalSource,
     });
     const repo = {
       getMailRules: vi.fn(async () => externalSnapshot),
@@ -147,6 +149,33 @@ describe('rules store', () => {
     expect(repo.insertPendingMutation).toHaveBeenCalledOnce();
   });
 
+  it('queues raw source without requiring visual projection', async () => {
+    const rawSource = 'vacation "Away";\r\n';
+    const repo = {
+      getMailRules: vi.fn(async () => snapshot({
+        editableScript: { id: 'personal', name: 'Personal filters', isActive: true },
+        source: rawSource,
+        visualizationError: 'Top-level “vacation” is not represented by the visual editor at line 1.',
+      })),
+      insertPendingMutation: vi.fn(async () => ({ id: 96 })),
+      runMutation: vi.fn(async () => ({ attempted: 1, succeeded: 1, failed: 0 })),
+      getPendingMutationError: vi.fn(),
+    };
+    __setRepositoryForTests(repo);
+    useAuthStore().accountId = 7;
+    const store = useRulesStore();
+    await store.load();
+
+    await store.saveSource('vacation "Back Monday";\r\n');
+
+    const pending = repo.insertPendingMutation.mock.calls[0][0];
+    expect(JSON.parse(pending.requestJson)).toEqual({
+      mode: 'source',
+      source: 'vacation "Back Monday";\r\n',
+      expectedState: 'sieve-state-1',
+    });
+  });
+
   it('surfaces the typed terminal error left by the outbox', async () => {
     const repo = {
       getMailRules: vi.fn(async () => snapshot()),
@@ -154,9 +183,9 @@ describe('rules store', () => {
       runMutation: vi.fn(async () => ({ attempted: 1, succeeded: 0, failed: 1 })),
       getPendingMutationError: vi.fn(async () => ({
         error_json: JSON.stringify({
-          type: 'foreignScriptActive',
-          message: 'Another script is active.',
-          result: { foreignActiveScript: { id: 'foreign' } },
+          type: 'invalidSieve',
+          message: 'The server rejected the script.',
+          result: { validationError: { type: 'invalidSieve' } },
         }),
       })),
     };
@@ -167,11 +196,11 @@ describe('rules store', () => {
 
     await expect(store.save(document())).rejects.toMatchObject({
       name: 'MailRulesSaveError',
-      code: 'foreignScriptActive',
-      message: 'Another script is active.',
-      detail: { foreignActiveScript: { id: 'foreign' } },
+      code: 'invalidSieve',
+      message: 'The server rejected the script.',
+      detail: { validationError: { type: 'invalidSieve' } },
     } satisfies Partial<MailRulesSaveError>);
-    expect(store.error).toBe('Another script is active.');
+    expect(store.error).toBe('The server rejected the script.');
     expect(store.saving).toBe(false);
   });
 
diff --git a/tests/unit/sync/jmap-sieve.test.ts b/tests/unit/sync/jmap-sieve.test.ts
index f97d2e20..86695743 100644
--- a/tests/unit/sync/jmap-sieve.test.ts
+++ b/tests/unit/sync/jmap-sieve.test.ts
@@ -75,7 +75,7 @@ describe('JMAP Sieve rules backend', () => {
     expect(transport.requests).toHaveLength(0);
   });
 
-  it('loads a managed script while preserving an unselected active script', async () => {
+  it('uses an incompatible active script as the authoritative source', async () => {
     const transport = new MockTransport(session());
     transport.handle('SieveScript/get', () => ({
       accountId: 'acct-1',
@@ -98,9 +98,12 @@ describe('JMAP Sieve rules backend', () => {
 
     expect(result.supported).toBe(true);
     expect(result.state).toBe('sieve-state-1');
-    expect(withoutIds(result.document)).toEqual(withoutIds(ruleDocument()));
-    expect(result.managedScript).toMatchObject({ id: 'managed', isActive: false });
-    expect(result.foreignActiveScript).toEqual({ id: 'foreign', name: 'Handwritten filters' });
+    expect(result.document).toEqual(emptyRuleDocument());
+    expect(result.managedScript).toBeNull();
+    expect(result.editableScript).toMatchObject({ id: 'foreign', isActive: true });
+    expect(result.source).toBe('vacation "Away";\r\n');
+    expect(result.visualizationError)
+      .toBe('Top-level “vacation” is not represented by the visual editor at line 1.');
     expect(result.capabilities.sieveExtensions).toEqual(EXTENSIONS);
   });
 
@@ -135,7 +138,8 @@ describe('JMAP Sieve rules backend', () => {
     const loaded = await getMailRules({ transport, account: ACCOUNT });
     expect(loaded.managedScript).toBeNull();
     expect(loaded.editableScript).toMatchObject({ id: 'personal', isActive: true });
-    expect(loaded.foreignActiveScript).toBeNull();
+    expect(loaded.visualizationError).toBeNull();
+    expect(loaded.source).toContain('# Rule: Important projects');
     expect(loaded.document.rules[0]).toMatchObject({
       name: 'Important projects',
       match: 'all',
@@ -180,14 +184,14 @@ describe('JMAP Sieve rules backend', () => {
     const loaded = await getMailRules({ transport, account: ACCOUNT });
     expect(loaded.editableScript).toMatchObject({ id: 'personal', isActive: true });
     expect(loaded.managedScript).toBeNull();
-    expect(loaded.foreignActiveScript).toBeNull();
+    expect(loaded.visualizationError).toBeNull();
     expect(loaded.document.rules[0]).toMatchObject({
       conditions: [{ value: 'Active' }],
       actions: [{ type: 'discard' }],
     });
   });
 
-  it('requires explicit takeover, then validates and activates a new managed script', async () => {
+  it('validates and updates an incompatible active script from raw source', async () => {
     const transport = new MockTransport(session());
     let setRequest: any = null;
     transport.handle('SieveScript/get', () => ({
@@ -206,45 +210,33 @@ describe('JMAP Sieve rules backend', () => {
         accountId: 'acct-1',
         oldState: 'sieve-state-1',
         newState: 'sieve-state-2',
-        created: { stormbox: { id: 'managed-new', blobId: 'blob-1' } },
+        updated: { foreign: null },
       };
     });
 
-    const refused = await runSetSieveRules({
-      transport,
-      account: ACCOUNT,
-      request: { document: ruleDocument(), expectedState: 'sieve-state-1' },
-    });
-    expect(refused).toMatchObject({
-      ok: false,
-      error: { type: 'foreignScriptActive', terminal: true },
-    });
-    expect(transport.uploads).toHaveLength(0);
-
+    const source = 'vacation "Back Monday";\r\n';
     const result = await runSetSieveRules({
       transport,
       account: ACCOUNT,
-      request: {
-        document: ruleDocument(), expectedState: 'sieve-state-1', takeover: true,
-      },
+      request: { mode: 'source', source, expectedState: 'sieve-state-1' },
     });
 
     expect(result).toMatchObject({
       ok: true,
-      result: { scriptId: 'managed-new', state: 'sieve-state-2' },
+      result: { scriptId: 'foreign', state: 'sieve-state-2' },
     });
     expect(transport.uploads).toHaveLength(1);
     expect(transport.uploads[0]).toMatchObject({
       accountId: 'acct-1', type: 'application/sieve',
     });
-    expect(new TextDecoder().decode(transport.uploads[0].body))
-      .toContain('# stormbox-managed: mail-rules/v2');
+    expect(new TextDecoder().decode(transport.uploads[0].body)).toBe(source);
     expect(setRequest).toMatchObject({
       accountId: 'acct-1',
       ifInState: 'sieve-state-1',
-      onSuccessActivateScript: '#stormbox',
-      create: { stormbox: { name: MANAGED_SCRIPT_NAME, blobId: 'blob-1' } },
+      onSuccessActivateScript: 'foreign',
+      update: { foreign: { blobId: 'blob-1' } },
     });
+    expect(setRequest.create).toBeUndefined();
     expect(setRequest.destroy).toBeUndefined();
   });
 

From 5f6901b15cc7d144c1fd12fa14e8b8b03d903290 Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Sat, 12 Sep 2026 19:41:37 +0100
Subject: [PATCH 15/16] Fix Sieve source editor typing. (#128)

---
 tests/unit/stores/rules-store.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/unit/stores/rules-store.test.ts b/tests/unit/stores/rules-store.test.ts
index 724a7141..1ecd5c13 100644
--- a/tests/unit/stores/rules-store.test.ts
+++ b/tests/unit/stores/rules-store.test.ts
@@ -157,7 +157,7 @@ describe('rules store', () => {
         source: rawSource,
         visualizationError: 'Top-level “vacation” is not represented by the visual editor at line 1.',
       })),
-      insertPendingMutation: vi.fn(async () => ({ id: 96 })),
+      insertPendingMutation: vi.fn(async (_input: any) => ({ id: 96 })),
       runMutation: vi.fn(async () => ({ attempted: 1, succeeded: 1, failed: 0 })),
       getPendingMutationError: vi.fn(),
     };

From 635a5d589b5a241cc5ad01f34f5b18d9ac48a90d Mon Sep 17 00:00:00 2001
From: Burak Yigit Kaya <ben@byk.im>
Date: Sat, 12 Sep 2026 19:53:54 +0100
Subject: [PATCH 16/16] Disambiguate the Sieve source test. (#128)

---
 tests/e2e/mail-rules.spec.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/e2e/mail-rules.spec.js b/tests/e2e/mail-rules.spec.js
index db5a429e..c03bd30d 100644
--- a/tests/e2e/mail-rules.spec.js
+++ b/tests/e2e/mail-rules.spec.js
@@ -155,7 +155,8 @@ test.describe('JMAP Sieve mail rules e2e', () => {
       await expect(savedRule.locator('input[aria-label="Condition value"]').first()).toHaveValue(CONDITION_VALUE);
       await expect(savedRule.locator('.condition-group--nested')).toHaveCount(1);
       await dialog.getByRole('button', { name: 'Source' }).click();
-      await expect(dialog.getByLabel('Sieve source')).toHaveValue(new RegExp(CONDITION_VALUE));
+      await expect(dialog.getByRole('textbox', { name: 'Sieve source' }))
+        .toHaveValue(new RegExp(CONDITION_VALUE));
       await dialog.getByRole('button', { name: 'Close', exact: true }).click();
     } finally {
       await restoreScripts(jmap, before);