@@ -63,6 +63,8 @@ const textInputs = vi.hoisted(() => ({
 const fieldHandle = vi.hoisted(() => ({ setSelection: vi.fn() }));
 const confirmDialog = vi.hoisted(() => ({
   current: null as {
+    title?: string;
+    message?: string;
     cancelLabel?: string;
     confirmLabel?: string;
     extraAction?: { label: string; onPress: () => void };
@@ -125,6 +127,8 @@ vi.mock('@/components/ui/button', () => ({ Button: 'Button' }));
 vi.mock('@/components/ui/sheet', () => ({ Sheet: 'Sheet' }));
 vi.mock('@/components/destructive-confirm-dialog', () => ({
   DestructiveConfirmDialog: (props: {
+    title?: string;
+    message?: string;
     cancelLabel?: string;
     confirmLabel?: string;
     extraAction?: { label: string; onPress: () => void };
@@ -139,6 +143,10 @@ vi.mock('@/components/destructive-confirm-dialog', () => ({
 }));
 vi.mock('@/components/ui/skeleton', () => ({ Skeleton: 'Skeleton' }));
 vi.mock('@/components/ui/text', () => ({ Text: 'Text' }));
+vi.mock('@/components/ui/icons', () => ({ AlertTriangle: 'AlertTriangle' }));
+vi.mock('@/lib/hooks/use-theme-colors', () => ({
+  useThemeColors: () => ({ warn: '#f2b05f' }),
+}));
 vi.mock('@/components/invalid-route-state', () => ({ InvalidRouteState: 'InvalidRouteState' }));
 vi.mock('@/components/screen-header', () => ({
   ScreenHeader: (props: Record<string, unknown>): ReactNode => createElement('ScreenHeader', props),
@@ -212,6 +220,32 @@ function latestInput() {
   return input;
 }
 
+// The editor's Save is the screen's: the button only asks for the save, so the
+// test presses the same last `Button` the editor renders.
+function pressSaveButton(renderer: TestRenderer.ReactTestRenderer) {
+  const saveButton = renderer.root.findAll(node => String(node.type) === 'Button').at(-1);
+  if (!saveButton) {
+    throw new Error('save button not found');
+  }
+  const onPress = (saveButton.props as Record<string, unknown>).onPress;
+  if (typeof onPress !== 'function') {
+    throw new TypeError('save button onPress is not a function');
+  }
+  // typeof narrowing proves callable, not zero-arg; the screen's own Button
+  // calls it the same way.
+  (onPress as () => void)();
+}
+
+// Runs `trigger` inside act and lets the screen's async save (mutation, then
+// navigation, or a pending confirmation) settle before the assertions.
+async function flush(trigger: () => void) {
+  await act(async () => {
+    trigger();
+    await Promise.resolve();
+    await Promise.resolve();
+  });
+}
+
 beforeEach(() => {
   config.data = null;
   config.isLoading = false;
@@ -414,52 +448,146 @@ describe('InstructionsRoute editor', () => {
     expect(navigation.dispatch).toHaveBeenCalledTimes(1);
   });
 
-  it('persists the trimmed draft from the save button and bypasses the guard on its own back', () => {
+  it('persists the trimmed draft from the save button and bypasses the guard on its own back', async () => {
     config.data = { customInstructions: STORED };
     const renderer = mount();
 
-    const input = latestInput();
     act(() => {
-      input.onChangeText('  rewritten draft\n');
+      latestInput().onChangeText('  rewritten draft\n');
     });
 
-    const buttons = renderer.root.findAll(node => String(node.type) === 'Button');
-    const saveButton = buttons.at(-1);
-    if (!saveButton) {
-      throw new Error('save button not found');
-    }
-    const saveProps = saveButton.props as Record<string, unknown>;
-    const saveOnPress = saveProps.onPress;
-    if (typeof saveOnPress !== 'function') {
-      throw new TypeError('save button onPress is not a function');
-    }
-    // typeof narrowing proves callable, not zero-arg; the screen's own
-    // Button calls it the same way.
-    const pressSave = saveOnPress as () => void;
+    await flush(() => {
+      pressSaveButton(renderer);
+    });
+    expect(save.mutateAsync).toHaveBeenCalledWith({ customInstructions: 'rewritten draft' });
+    expect(router.back).toHaveBeenCalledTimes(1);
+    // The next navigation is the screen's own back: the guard must let it
+    // through without a confirm, then re-arm for later edits.
     act(() => {
-      pressSave();
+      triggerPreventRemove();
     });
-    expect(save.mutate).toHaveBeenCalledWith(
-      { customInstructions: 'rewritten draft' },
-      expect.objectContaining({ onSuccess: expect.any(Function) })
-    );
+    expect(navigation.dispatch).toHaveBeenCalledTimes(1);
+    expect(visibleConfirmationCount(renderer)).toBe(0);
+  });
+
+  it('asks before an empty field removes the stored instructions, and keeps the editor on cancel', async () => {
+    config.data = { customInstructions: STORED };
+    const renderer = mount();
 
-    const options = save.mutate.mock.calls.at(-1)?.[1] as { onSuccess?: () => void } | undefined;
-    const onSuccess = options?.onSuccess;
-    if (!onSuccess) {
-      throw new Error('save onSuccess not captured');
-    }
     act(() => {
-      onSuccess();
+      latestInput().onChangeText('');
+    });
+
+    await flush(() => {
+      pressSaveButton(renderer);
     });
+    expect(visibleConfirmationCount(renderer)).toBe(1);
+    const removal = confirmDialog.current;
+    expect(removal?.title).toBe(i18n.t('codeReviewer.instructions.clearTitle'));
+    expect(removal?.message).toBe(i18n.t('codeReviewer.instructions.clearMessage'));
+    expect(removal?.confirmLabel).toBe(i18n.t('common.remove'));
+    expect(removal?.cancelLabel).toBe(i18n.t('common.keepEditing'));
+    // The question is a yes/no about the removal, with no third choice.
+    expect(removal?.extraAction).toBeUndefined();
+    expect(save.mutateAsync).not.toHaveBeenCalled();
+    expect(router.back).not.toHaveBeenCalled();
+
+    await flush(() => {
+      removal?.onCancel();
+    });
+    expect(visibleConfirmationCount(renderer)).toBe(0);
+    expect(save.mutateAsync).not.toHaveBeenCalled();
+    expect(router.back).not.toHaveBeenCalled();
+    // The edited draft is still unsaved, so the guard still holds the exit.
+    expect(preventRemove.enabled).toBe(true);
+  });
+
+  it('removes the stored instructions once the reader confirms it', async () => {
+    config.data = { customInstructions: STORED };
+    const renderer = mount();
+
+    act(() => {
+      latestInput().onChangeText('   ');
+    });
+
+    await flush(() => {
+      pressSaveButton(renderer);
+    });
+    expect(save.mutateAsync).not.toHaveBeenCalled();
+
+    await flush(() => {
+      confirmDialog.current?.onConfirm();
+    });
+    expect(save.mutateAsync).toHaveBeenCalledWith({ customInstructions: '' });
     expect(router.back).toHaveBeenCalledTimes(1);
-    // The next navigation is the screen's own back: the guard must let it
-    // through without a confirm, then re-arm for later edits.
+  });
+
+  it('saves an empty field with no confirmation when nothing is stored', async () => {
+    config.data = { customInstructions: '' };
+    const renderer = mount();
+
+    await flush(() => {
+      pressSaveButton(renderer);
+    });
+    expect(visibleConfirmationCount(renderer)).toBe(0);
+    expect(save.mutateAsync).toHaveBeenCalledWith({ customInstructions: '' });
+    expect(router.back).toHaveBeenCalledTimes(1);
+  });
+
+  it('asks the same question from the back guard save and stays when it is declined', async () => {
+    config.data = { customInstructions: STORED };
+    const renderer = mount();
+
+    act(() => {
+      latestInput().onChangeText('');
+    });
     act(() => {
       triggerPreventRemove();
     });
+    const saveChanges = confirmDialog.current?.extraAction;
+    expect(saveChanges?.label).toBe(i18n.t('securityAgent.settingsSave.saveChanges'));
+
+    await flush(() => {
+      saveChanges?.onPress();
+    });
+    // The guard's own sheet stays mounted while the removal question is
+    // presented over it (the emulator shows one native sheet, the removal
+    // one), so the save does not run straight through.
+    expect(visibleConfirmationCount(renderer)).toBe(2);
+    expect(confirmDialog.current?.title).toBe(i18n.t('codeReviewer.instructions.clearTitle'));
+    expect(confirmDialog.current?.message).toBe(i18n.t('codeReviewer.instructions.clearMessage'));
+    expect(save.mutateAsync).not.toHaveBeenCalled();
+
+    await flush(() => {
+      confirmDialog.current?.onCancel();
+    });
+    // Declining puts the unsaved-changes sheet back in front: the leave is
+    // dropped and the draft is still there to discard or save.
+    expect(confirmDialog.current?.title).toBe(i18n.t('securityAgent.settingsSave.unsavedTitle'));
+    expect(save.mutateAsync).not.toHaveBeenCalled();
+    expect(navigation.dispatch).not.toHaveBeenCalled();
+    expect(preventRemove.enabled).toBe(true);
+  });
+
+  it('removes the stored instructions from the back guard save once it is confirmed', async () => {
+    config.data = { customInstructions: STORED };
+    mount();
+
+    act(() => {
+      latestInput().onChangeText('');
+    });
+    act(() => {
+      triggerPreventRemove();
+    });
+    await flush(() => {
+      confirmDialog.current?.extraAction?.onPress();
+    });
+    await flush(() => {
+      confirmDialog.current?.onConfirm();
+    });
+
+    expect(save.mutateAsync).toHaveBeenCalledWith({ customInstructions: '' });
     expect(navigation.dispatch).toHaveBeenCalledTimes(1);
-    expect(visibleConfirmationCount(renderer)).toBe(0);
   });
 
   it('does not clobber an in-progress edit when the query refetches', async () => {
@@ -506,6 +634,23 @@ describe('InstructionsRoute editor', () => {
     expect(latestInput().accessibilityLabel).toBe(i18n.t('codeReviewer.instructions.title'));
   });
 
+  // As body-coloured copy the deprecation note read as a description of the
+  // field under it. It is now a notice of its own: a tinted block with its
+  // warning mark, in the warning ink rather than the muted one.
+  it('renders the deprecation note as a warning notice of its own', () => {
+    config.data = { customInstructions: STORED };
+    const renderer = mount();
+
+    const noticeCopy = findByHostType(renderer, 'Text').filter(node => {
+      const props = node.props as { className?: string };
+      return props.className?.includes('text-warn') === true;
+    });
+    expect(noticeCopy).toHaveLength(1);
+    const copy = noticeCopy[0]?.props as { children?: string } | undefined;
+    expect(copy?.children).toBe(i18n.t('codeReviewer.instructions.deprecation'));
+    expect(findByHostType(renderer, 'AlertTriangle')).toHaveLength(1);
+  });
+
   it('reads the editor name from the active catalog', async () => {
     await act(async () => {
       await i18n.changeLanguage('ar');