diff --git a/application/single_app/config.py b/application/single_app/config.py
index 028a6ea81..d28611fe9 100644
--- a/application/single_app/config.py
+++ b/application/single_app/config.py
@@ -101,7 +101,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.261.338"
+VERSION = "0.261.340"
 IS_DEVELOPMENT = is_development_env_enabled()
 
 # Opt-out for deployments where App Service Easy Auth is active but the platform
diff --git a/application/v2_ui/src/components/chat/PendingActionSlots.tsx b/application/v2_ui/src/components/chat/PendingActionSlots.tsx
index 5b01d248c..e6972a81d 100644
--- a/application/v2_ui/src/components/chat/PendingActionSlots.tsx
+++ b/application/v2_ui/src/components/chat/PendingActionSlots.tsx
@@ -34,6 +34,7 @@ import type { ChatMessage } from '../../lib/types';
 import { useChatStore } from '../../stores/chatStore';
 import { usePendingActions, usePendingActionsStoreApi } from '../../stores/m365PendingActionsStore';
 import { useUiStore } from '../../stores/uiStore';
+import { SESSION_REQUIRED_MESSAGE } from '../../stores/appSessionStore';
 import { Notice } from '../approvals/ApprovalParts';
 import { PendingActionCard } from '../approvals/PendingActionCard';
 import { GlassButton, GlassPanel } from '../ui/primitives';
@@ -282,6 +283,10 @@ export function PendingActionsConversationSection({
     const continuationToken = usePendingActions((state) => state.continuationToken);
     const loadingMore = usePendingActions((state) => state.loadingMore);
     const listLoading = usePendingActions((state) => state.listStatus === 'loading');
+    const hasActionContext = usePendingActions((state) =>
+        Object.keys(state.entries).length > 0 || state.referenceLoading || Boolean(state.referenceError) ||
+        state.focusRequest?.conversationId === state.conversationId);
+    const contextualListError = hasActionContext && listError !== SESSION_REQUIRED_MESSAGE ? listError : '';
 
     usePendingActionsLifecycle(activeConversationId);
     const { unavailable, dismissUnavailable } = usePendingActionFocus(scrollRef, pauseFollowing);
@@ -290,7 +295,7 @@ export function PendingActionsConversationSection({
     // under its message.
     const showSection =
         !messagesLoading &&
-        (orphanIds.length > 0 || Boolean(listError) || Boolean(referenceError) || Boolean(continuationToken));
+        (orphanIds.length > 0 || Boolean(contextualListError) || Boolean(referenceError) || Boolean(continuationToken));
     if (!unavailable && !showSection) {
         return null;
     }
@@ -328,7 +333,9 @@ export function PendingActionsConversationSection({
                         </p>
                     </div>
 
-                    {listError && <Notice tone="danger" testId="v2-pending-actions-error">{listError}</Notice>}
+                    {contextualListError && (
+                        <Notice tone="danger" testId="v2-pending-actions-error">{contextualListError}</Notice>
+                    )}
                     {referenceError && (
                         <Notice tone="danger" testId="v2-pending-actions-reference-error">{referenceError}</Notice>
                     )}
diff --git a/application/v2_ui/src/components/layout/AppShell.tsx b/application/v2_ui/src/components/layout/AppShell.tsx
index 4475a065e..d4421d729 100644
--- a/application/v2_ui/src/components/layout/AppShell.tsx
+++ b/application/v2_ui/src/components/layout/AppShell.tsx
@@ -16,6 +16,7 @@ import { WorkflowAlertLiveRegion } from '../notifications/WorkflowAlertLiveRegio
 import { useBootstrapStore } from '../../stores/bootstrapStore';
 import { useUiStore } from '../../stores/uiStore';
 import { useCollaborationStore } from '../../stores/collaborationStore';
+import { SessionNotice } from './SessionNotice';
 
 function ClassificationBanner() {
     const banner = useBootstrapStore((state) => state.data?.branding?.classification_banner);
@@ -69,6 +70,7 @@ export function AppShell({ children }: { children: ReactNode }) {
         <MobileNavigationContext.Provider value={{ mobile, register }}>
             <div className="app-shell flex h-full min-h-0 flex-col">
                     <ClassificationBanner />
+                    <SessionNotice />
                     <div className="relative flex min-h-0 min-w-0 flex-1">
                         {mobile && mobileNavOpen && (
                             <button
diff --git a/application/v2_ui/src/components/layout/SessionNotice.tsx b/application/v2_ui/src/components/layout/SessionNotice.tsx
new file mode 100644
index 000000000..bc911391b
--- /dev/null
+++ b/application/v2_ui/src/components/layout/SessionNotice.tsx
@@ -0,0 +1,74 @@
+// SessionNotice.tsx
+
+import { useCallback, useEffect, useState } from 'react';
+import { apiUrl, verifyAppSession } from '../../lib/apiClient';
+import { SESSION_REQUIRED_MESSAGE, useAppSessionStore } from '../../stores/appSessionStore';
+import { GlassButton } from '../ui/primitives';
+
+export function SessionNotice() {
+    const status = useAppSessionStore((state) => state.status);
+    const [checking, setChecking] = useState(false);
+    const [checkFailed, setCheckFailed] = useState(false);
+
+    const checkAgain = useCallback(async (force = false) => {
+        setChecking(true);
+        setCheckFailed(false);
+        try {
+            const confirmed = await verifyAppSession(force);
+            setCheckFailed(!confirmed);
+        } catch (error) {
+            setCheckFailed(true);
+            reportError(error);
+        } finally {
+            setChecking(false);
+        }
+    }, []);
+
+    useEffect(() => {
+        setCheckFailed(false);
+        if (status !== 'required') return undefined;
+        const check = () => {
+            if (document.visibilityState === 'visible') void checkAgain();
+        };
+        window.addEventListener('focus', check);
+        window.addEventListener('online', check);
+        document.addEventListener('visibilitychange', check);
+        return () => {
+            window.removeEventListener('focus', check);
+            window.removeEventListener('online', check);
+            document.removeEventListener('visibilitychange', check);
+        };
+    }, [status, checkAgain]);
+
+    if (status === 'ready') return null;
+
+    return (
+        <div role="alert" data-testid="v2-session-notice"
+            className="shrink-0 space-y-2 border-b border-edge bg-warn-soft px-4 py-3 text-sm text-text-1">
+            <p className="font-medium">
+                {status === 'changed'
+                    ? 'Your signed-in account changed. Copy any unsaved text, then reload SimpleChat before continuing.'
+                    : SESSION_REQUIRED_MESSAGE}
+            </p>
+            <p>Your current page and unsaved draft have been kept. No failed action will be repeated automatically.</p>
+            <div className="flex flex-wrap items-center gap-2">
+                {status === 'changed' ? (
+                    <GlassButton size="sm" onClick={() => window.location.reload()}>Reload SimpleChat</GlassButton>
+                ) : (
+                    <>
+                        <a href={apiUrl('/login')} target="_blank" rel="noopener noreferrer"
+                            className="rounded-lg px-3 py-2 font-medium text-accent underline focus-visible:outline focus-visible:outline-2 focus-visible:outline-accent">
+                            Sign in again (opens a new tab)
+                        </a>
+                        <GlassButton size="sm" variant="ghost" disabled={checking} onClick={() => void checkAgain(true)}>
+                            {checking ? 'Checking session…' : 'Check sign-in'}
+                        </GlassButton>
+                    </>
+                )}
+            </div>
+            {checkFailed && status === 'required' ? (
+                <p role="status">Your sign-in could not be confirmed. Finish signing in, then check again.</p>
+            ) : null}
+        </div>
+    );
+}
diff --git a/application/v2_ui/src/lib/apiClient.ts b/application/v2_ui/src/lib/apiClient.ts
index 23336054e..421f057e3 100644
--- a/application/v2_ui/src/lib/apiClient.ts
+++ b/application/v2_ui/src/lib/apiClient.ts
@@ -5,6 +5,8 @@
 // Service later" decision cheap: switching origins is a change to API_BASE alone, not a
 // change to every call site.
 
+import { SESSION_REQUIRED_MESSAGE, useAppSessionStore } from '../stores/appSessionStore';
+
 /**
  * Base URL for API requests.
  *
@@ -43,6 +45,99 @@ export class ApiError extends Error {
     }
 }
 
+export function isAppSessionRequired(status: number, payload: unknown): boolean {
+    if ((status !== 401 && status !== 403) || !payload || typeof payload !== 'object') return false;
+    const body = payload as Record<string, unknown>;
+    return body.requires_reauth === true ||
+        (status === 401 && (body.error === 'not_logged_in' ||
+            (body.error === 'Unauthorized' && body.message === 'Authentication required')));
+}
+
+export function isAppSessionError(error: unknown): boolean {
+    return error instanceof ApiError && isAppSessionRequired(error.status, error.payload);
+}
+
+function sessionError(): ApiError {
+    return new ApiError(SESSION_REQUIRED_MESSAGE, 401, { requires_reauth: true });
+}
+
+function isSignInRedirect(response: Response): boolean {
+    if (!response.redirected || !response.url) return false;
+    const url = new URL(response.url);
+    return url.pathname === '/login' || url.pathname.startsWith('/.auth/login/') ||
+        /^(login\.microsoftonline\.(com|us|de)|login\.partner\.microsoftonline\.cn)$/.test(url.hostname);
+}
+
+let sessionVerification: Promise<boolean> | null = null;
+let lastSessionVerification = 0;
+
+function checkWriteSession(method: string): void {
+    if (method === 'GET' || method === 'HEAD') return;
+    const { status } = useAppSessionStore.getState();
+    if (status === 'required') throw sessionError();
+    if (status === 'changed') {
+        throw new ApiError('Your signed-in account changed. Reload SimpleChat before continuing.',
+            409, { error: 'app_account_changed' });
+    }
+}
+
+async function fetchWithSessionCheck(path: string, init: RequestInit): Promise<Response> {
+    try {
+        return await fetch(apiUrl(path), init);
+    } catch (error) {
+        if (error instanceof TypeError && !init.signal?.aborted &&
+            useAppSessionStore.getState().viewerId) {
+            await verifyAppSession();
+            if (useAppSessionStore.getState().status === 'required') throw sessionError();
+        }
+        throw error;
+    }
+}
+
+/** A read-only check, never a retry of the request that failed. */
+export function verifyAppSession(force = false): Promise<boolean> {
+    if (sessionVerification) return sessionVerification;
+    if (!force && Date.now() - lastSessionVerification < 15_000) return Promise.resolve(false);
+    lastSessionVerification = Date.now();
+    const { revision } = useAppSessionStore.getState();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 5000);
+    sessionVerification = (async () => {
+        try {
+            const response = await fetch(apiUrl('/api/v2/bootstrap'), {
+                credentials: CREDENTIALS_MODE,
+                cache: 'no-store',
+                headers: { Accept: 'application/json' },
+                signal: controller.signal,
+            });
+            if (isSignInRedirect(response)) {
+                useAppSessionStore.getState().requireSignIn(revision);
+                return false;
+            }
+            if (!response.headers.get('content-type')?.includes('application/json')) return false;
+            const data: unknown = await response.json();
+            if (!response.ok) {
+                if (isAppSessionRequired(response.status, data)) {
+                    useAppSessionStore.getState().requireSignIn(revision);
+                }
+                followServerGate(response.status, data);
+                return false;
+            }
+            const user = (data as { user?: { id?: unknown } } | null)?.user;
+            return typeof user?.id === 'string' &&
+                useAppSessionStore.getState().confirmUser(user.id, revision);
+        } catch (error) {
+            if (error instanceof TypeError || error instanceof SyntaxError ||
+                (error instanceof Error && error.name === 'AbortError')) return false;
+            throw error;
+        } finally {
+            clearTimeout(timer);
+            sessionVerification = null;
+        }
+    })();
+    return sessionVerification;
+}
+
 export function apiUrl(path: string): string {
     if (/^https?:\/\//i.test(path)) {
         return path;
@@ -193,6 +288,8 @@ export interface ApiResponse<T> {
 
 export async function requestWithStatus<T>(path: string, options: RequestOptions = {}): Promise<ApiResponse<T>> {
     const { method = 'GET', body, signal, headers = {}, cache } = options;
+    checkWriteSession(method);
+    const sessionRevision = useAppSessionStore.getState().revision;
 
     const init: RequestInit = {
         method,
@@ -213,11 +310,20 @@ export async function requestWithStatus<T>(path: string, options: RequestOptions
         init.body = JSON.stringify(body);
     }
 
-    const response = await fetch(apiUrl(path), init);
+    const response = await fetchWithSessionCheck(path, init);
+
+    if (isSignInRedirect(response)) {
+        useAppSessionStore.getState().requireSignIn(sessionRevision);
+        throw sessionError();
+    }
 
     if (!response.ok) {
         const { message, payload } = await readErrorMessage(response);
         followServerGate(response.status, payload);
+        if (isAppSessionRequired(response.status, payload)) {
+            useAppSessionStore.getState().requireSignIn(sessionRevision);
+            throw sessionError();
+        }
         throw new ApiError(message, response.status, payload);
     }
 
@@ -260,16 +366,26 @@ export async function uploadFileWithStatus<T>(
     formData: FormData,
     signal?: AbortSignal,
 ): Promise<ApiResponse<T>> {
-    const response = await fetch(apiUrl(path), {
+    checkWriteSession('POST');
+    const sessionRevision = useAppSessionStore.getState().revision;
+    const response = await fetchWithSessionCheck(path, {
         method: 'POST',
         credentials: CREDENTIALS_MODE,
         body: formData,
         signal,
     });
 
+    if (isSignInRedirect(response)) {
+        useAppSessionStore.getState().requireSignIn(sessionRevision);
+        throw sessionError();
+    }
     if (!response.ok) {
         const { message, payload } = await readErrorMessage(response);
         followServerGate(response.status, payload);
+        if (isAppSessionRequired(response.status, payload)) {
+            useAppSessionStore.getState().requireSignIn(sessionRevision);
+            throw sessionError();
+        }
         throw new ApiError(message, response.status, payload);
     }
 
diff --git a/application/v2_ui/src/lib/workflowPlanReplay.ts b/application/v2_ui/src/lib/workflowPlanReplay.ts
index fb044ff2c..90273eccd 100644
--- a/application/v2_ui/src/lib/workflowPlanReplay.ts
+++ b/application/v2_ui/src/lib/workflowPlanReplay.ts
@@ -1,7 +1,8 @@
 // workflowPlanReplay.ts
 // Client contract for saving a completed chat orchestration plan as a read-only replay workflow.
 
-import { ApiError, api, requestWithStatus } from './apiClient';
+import { ApiError, api, isAppSessionError, requestWithStatus } from './apiClient';
+import { SESSION_REQUIRED_MESSAGE } from '../stores/appSessionStore';
 import type { WorkflowDefinition } from './workflowEditor';
 
 export const PLAN_REPLAY_INVALID_RESPONSE = 'The saved chat plan returned an invalid response.';
@@ -266,6 +267,9 @@ function errorTextFor(code: string, status: number, serverText: string): string
 
 export function planReplayError(cause: unknown): WorkflowPlanReplayError {
     if (cause instanceof WorkflowPlanReplayError) return cause;
+    if (isAppSessionError(cause)) {
+        return new WorkflowPlanReplayError('app_session_required', 401, SESSION_REQUIRED_MESSAGE, []);
+    }
     if (cause instanceof ApiError) {
         const payload = isRecord(cause.payload) ? cause.payload : {};
         const code = typeof payload.code === 'string' ? payload.code : '';
diff --git a/application/v2_ui/src/stores/appSessionStore.ts b/application/v2_ui/src/stores/appSessionStore.ts
new file mode 100644
index 000000000..58459b1b7
--- /dev/null
+++ b/application/v2_ui/src/stores/appSessionStore.ts
@@ -0,0 +1,37 @@
+// appSessionStore.ts
+// Runtime sign-in state stays separate from bootstrap so expiry never discards an open draft.
+
+import { create } from 'zustand';
+
+export const SESSION_REQUIRED_MESSAGE = 'Your SimpleChat session needs to be renewed. Sign in again to continue.';
+
+interface AppSessionState {
+    status: 'ready' | 'required' | 'changed';
+    viewerId: string;
+    revision: number;
+    requireSignIn(revision: number): void;
+    confirmUser(viewerId: string, revision: number): boolean;
+}
+
+export const useAppSessionStore = create<AppSessionState>((set, get) => ({
+    status: 'ready',
+    viewerId: '',
+    revision: 0,
+    requireSignIn: (revision) => {
+        const current = get();
+        if (current.revision !== revision || current.status === 'changed') return;
+        set({ status: 'required', revision: revision + 1 });
+    },
+    confirmUser: (viewerId, revision) => {
+        const current = get();
+        if (!viewerId || current.revision !== revision || current.status === 'changed') return false;
+        if (current.viewerId && current.viewerId !== viewerId) {
+            set({ status: 'changed', revision: revision + 1 });
+            return false;
+        }
+        if (current.status !== 'ready' || current.viewerId !== viewerId) {
+            set({ status: 'ready', viewerId, revision: revision + 1 });
+        }
+        return true;
+    },
+}));
diff --git a/application/v2_ui/src/stores/bootstrapStore.ts b/application/v2_ui/src/stores/bootstrapStore.ts
index b8a8f9d50..59b9e2062 100644
--- a/application/v2_ui/src/stores/bootstrapStore.ts
+++ b/application/v2_ui/src/stores/bootstrapStore.ts
@@ -7,6 +7,7 @@ import { create } from 'zustand';
 import { fetchActiveScope, fetchBootstrap } from '../lib/endpoints';
 import { ApiError, isAccessRestricted, isTermsOfUseRequired } from '../lib/apiClient';
 import type { BootstrapPayload, PromptOption } from '../lib/types';
+import { useAppSessionStore } from './appSessionStore';
 
 /**
  * Orders concurrent refreshes so a slower earlier one cannot land after a newer one.
@@ -120,8 +121,13 @@ export const useBootstrapStore = create<BootstrapState>((set, get) => ({
         set({ loading: true, error: null, authExpired: false });
         const settle = startBootstrapRead();
         const startedAtScope = scopeSequence;
+        const sessionRevision = useAppSessionStore.getState().revision;
         try {
             const data = await fetchBootstrap();
+            if (!useAppSessionStore.getState().confirmUser(data.user.id, sessionRevision)) {
+                set({ loading: false });
+                return;
+            }
             set({ data: withCurrentScope(data, startedAtScope, get().data), loading: false });
         } catch (error) {
             // The terms gate or the access gate refused the call and apiClient is already
@@ -152,9 +158,11 @@ export const useBootstrapStore = create<BootstrapState>((set, get) => ({
         const sequence = ++refreshSequence;
         const settle = startBootstrapRead();
         const startedAtScope = scopeSequence;
+        const sessionRevision = useAppSessionStore.getState().revision;
         try {
             const data = await fetchBootstrap();
-            if (sequence === refreshSequence) {
+            if (sequence === refreshSequence &&
+                useAppSessionStore.getState().confirmUser(data.user.id, sessionRevision)) {
                 set({ data: withCurrentScope(data, startedAtScope, get().data) });
             }
         } catch {
@@ -180,6 +188,7 @@ export const useBootstrapStore = create<BootstrapState>((set, get) => ({
         const sequence = ++refreshSequence;
         const settle = startBootstrapRead();
         const startedAtScope = scopeSequence;
+        const sessionRevision = useAppSessionStore.getState().revision;
         let data: BootstrapPayload;
         try {
             data = await fetchBootstrap();
@@ -189,6 +198,9 @@ export const useBootstrapStore = create<BootstrapState>((set, get) => ({
         if (sequence !== refreshSequence) {
             throw new Error('Application availability changed during refresh. Try again.');
         }
+        if (!useAppSessionStore.getState().confirmUser(data.user.id, sessionRevision)) {
+            throw new Error('Your sign-in changed during refresh. Reload the workspace.');
+        }
         if (expectedViewerId && (get().authExpired || get().data?.user?.id !== expectedViewerId
             || data?.user?.id !== expectedViewerId)) {
             throw new Error('Your sign-in changed during refresh. Reload the workspace.');
@@ -204,10 +216,14 @@ export const useBootstrapStore = create<BootstrapState>((set, get) => ({
             throw new Error('Your sign-in changed during refresh. Reload the workspace.');
         }
         const sequence = ++scopeSequence;
+        const sessionRevision = useAppSessionStore.getState().revision;
         const result = await fetchActiveScope();
         if (sequence !== scopeSequence) {
             throw new Error('The active workspace changed during refresh. Try again.');
         }
+        if (!useAppSessionStore.getState().confirmUser(result?.user?.id, sessionRevision)) {
+            throw new Error('Your sign-in changed during refresh. Reload the workspace.');
+        }
         const current = get().data;
         if (!current || get().authExpired || current.user?.id !== expectedViewerId
             || result?.user?.id !== expectedViewerId) {
diff --git a/application/v2_ui/src/stores/m365PendingActionsStore.ts b/application/v2_ui/src/stores/m365PendingActionsStore.ts
index 83db48a81..949586454 100644
--- a/application/v2_ui/src/stores/m365PendingActionsStore.ts
+++ b/application/v2_ui/src/stores/m365PendingActionsStore.ts
@@ -10,7 +10,8 @@
 
 import { createContext, createElement, useContext, type ReactNode } from 'react';
 import { createStore, useStore, type StoreApi } from 'zustand';
-import { ApiError } from '../lib/apiClient';
+import { ApiError, isAppSessionError } from '../lib/apiClient';
+import { SESSION_REQUIRED_MESSAGE } from './appSessionStore';
 import {
     errorMessage,
     fetchConversationPendingActions,
@@ -378,9 +379,11 @@ export function createPendingActionsStore(
                     const changes: Partial<PendingActionEntry> = {
                         needsRefresh: true,
                         denied: status === 403 || status === 404,
-                        notice: warn(status === 403 ? PERMISSION_MESSAGE : STATUS_UNKNOWN_MESSAGE),
+                        notice: warn(isAppSessionError(error) ? SESSION_REQUIRED_MESSAGE :
+                            status === 403 ? PERMISSION_MESSAGE : STATUS_UNKNOWN_MESSAGE),
                     };
-                    if (status === 401 || payload.auth_required === true) {
+                    if (isAppSessionError(error)) changes.auth = null;
+                    if (!isAppSessionError(error) && (status === 401 || payload.auth_required === true)) {
                         changes.authAcknowledgedVersion = '';
                         changes.auth = payload;
                     }
@@ -424,7 +427,8 @@ export function createPendingActionsStore(
                 set((state) => ({
                     detail: {
                         ...state.detail,
-                        [id]: { status: 'error', message: statusOf(error) === 403 ? PERMISSION_MESSAGE : NOT_LOADED_MESSAGE },
+                        [id]: { status: 'error', message: isAppSessionError(error) ? SESSION_REQUIRED_MESSAGE :
+                            statusOf(error) === 403 ? PERMISSION_MESSAGE : NOT_LOADED_MESSAGE },
                     },
                 }));
                 return null;
@@ -499,7 +503,13 @@ export function createPendingActionsStore(
                 const status = statusOf(error);
                 const returned = isPendingAction(payload.pending_action) && payload.pending_action.id === id;
                 if (returned) remember(payload.pending_action as PendingAction, { authoritative: true });
-                if (payload.approval_required === true) {
+                if (isAppSessionError(error)) {
+                    patchEntry(id, key, {
+                        needsRefresh: true,
+                        auth: null,
+                        notice: warn(SESSION_REQUIRED_MESSAGE),
+                    });
+                } else if (payload.approval_required === true) {
                     patchEntry(id, key, {
                         approvalRequired: payload,
                         notice: warn(
@@ -651,12 +661,15 @@ export function createPendingActionsStore(
                 } catch (error) {
                     if (controller.signal.aborted || get().epoch !== epoch) return;
                     const denied = statusOf(error) === 403;
+                    const payload = m365ErrorPayload(error);
+                    const conversationDenied = denied && payload.error === 'forbidden';
                     set((state) => ({
                         entries: Object.fromEntries(
                             Object.entries(state.entries).map(([id, entry]) => [id, { ...entry, needsRefresh: true, denied }]),
                         ),
                         listStatus: 'error',
-                        listError: denied ? LIST_PERMISSION_MESSAGE : LIST_FAILED_MESSAGE,
+                        listError: isAppSessionError(error) ? SESSION_REQUIRED_MESSAGE :
+                            conversationDenied ? LIST_PERMISSION_MESSAGE : LIST_FAILED_MESSAGE,
                         loadingMore: false,
                     }));
                 } finally {
diff --git a/docs/explanation/features/V2_M365_PENDING_ACTION_CARDS.md b/docs/explanation/features/V2_M365_PENDING_ACTION_CARDS.md
index 973b628db..b42da8d3d 100644
--- a/docs/explanation/features/V2_M365_PENDING_ACTION_CARDS.md
+++ b/docs/explanation/features/V2_M365_PENDING_ACTION_CARDS.md
@@ -8,6 +8,8 @@ Email review flow updated in version: **0.261.324** (`application/single_app/con
 
 Review editor implemented in version: **0.261.325** (`application/single_app/config.py`).
 
+Contextual warnings and app-session recovery fixed in version: **0.261.338** (`application/single_app/config.py`).
+
 Tracking issue: [#1722](https://github.com/microsoft/simplechat/issues/1722), gap 2 (Chat, "M365 pending-action card").
 
 An agent that prepares a Microsoft 365 email or calendar invitation for review saves it as a pending action. The action waits until its owner sends or cancels it, and a notification tells the owner it is waiting. Only the classic chat page drew that card, so every such notification opened classic chat.
@@ -34,7 +36,9 @@ A card sits under the reply that saved it, as it does in classic chat. Placement
 4. The last message of the same request, when the action carries a request id.
 5. Otherwise the conversation-level section, **Microsoft 365 outgoing actions for this conversation**, so a pending send is never hidden.
 
-That section also carries the things that belong to the conversation rather than to one reply: a failed or partial read of the list ("Outgoing actions could not be loaded. Refresh to recover saved actions; this is not an empty inbox."), **Load more outgoing actions** when the list has another page, and **Refresh outgoing actions**. Image, file, and content-safety messages never carry a card.
+When a conversation has a saved action, an action reference, or an explicitly opened action link, that section also carries a failed or partial read of the list ("Outgoing actions could not be loaded. Refresh to recover saved actions; this is not an empty inbox."), **Load more outgoing actions** when the list has another page, and **Refresh outgoing actions**. An optional background lookup failure alone does not show an M365 section in an unrelated chat. Background discovery continues, including discovery of actions missing from visible history; failures remain recorded rather than being treated as empty results. Image, file, and content-safety messages never carry a card.
+
+Confirmed SimpleChat session expiry uses the shared app-level sign-in notice, not this section's permission warning. Microsoft 365 provider reconnect and conversation authorization failures remain separate. See [unrelated-chat warnings and session recovery](../fixes/M365_UNRELATED_CHAT_SESSION_WARNING_FIX.md).
 
 ### Where the cards come from
 
@@ -112,12 +116,14 @@ Functional tests:
 * `functional_tests/test_v2_m365_pending_actions_logic.mjs`: snapshot trust, placement, stream and history references, and countdown rules.
 * `functional_tests/test_v2_m365_pending_actions_store.mjs`: the store's state machine, including late responses, version safety, polling, and focus.
 * `functional_tests/test_v2_m365_pending_actions_stream.mjs`: real chat and orchestration SSE readers/controllers, multiple live cards, saved-reply promotion, failed reports, dropped streams, scoped stale-frame rejection and history recovery.
+* `functional_tests/test_v2_app_session_recovery.mjs`: app-session/provider classification, bounded read-only verification, concurrent failures, stale bootstrap responses, identity changes and no mutation replay.
 * `functional_tests/test_v2_pending_review_logic.mjs`: owner/manual edit gates, typed proposals, safe undo, working-copy state, history deduplication and CSRF-protected review contracts.
 * `functional_tests/test_v2_workflow_run_link_routing.mjs`, `functional_tests/test_v2_notifications_bell.py`, `functional_tests/test_v2_user_settings_memory_m365.py`: updated for the new routing and files.
 
 UI tests:
 
 * `ui_tests/test_v2_m365_pending_action_cards.py`: the real message list with inline, streaming, and conversation-level cards, Send and Cancel, and focus; desktop/mobile Orchestrate preparation, report failure, reference-only reload, keyboard body review and explicit mocked Send/Cancel.
+* `ui_tests/test_v2_workflow_plan_replay_card.py`: desktop/mobile session notices, retained composer and schedule-form drafts, explicit same-user recovery and schedule-preview retry without automatic workflow writes.
 * `ui_tests/test_v2_pending_review_editor.py`: real desktop/mobile email editing, direct/AI saves, reopening history, focus return, calendar fields, conflict preservation, owner/timed edit denial and sanitized HTML overflow. All send/Graph operations are mocked.
 * `ui_tests/test_v2_notifications_bell.py`: a notice for a saved action opens its card in V2 chat from another page, from the chat page, for an action the list does not show, and for one that is gone.
 * `ui_tests/test_v2_approvals_and_terms_pages.py` and `ui_tests/test_v2_approvals_dashboard.py`: the Approvals page, which keeps its test ids on the shared card.
diff --git a/docs/explanation/fixes/M365_UNRELATED_CHAT_SESSION_WARNING_FIX.md b/docs/explanation/fixes/M365_UNRELATED_CHAT_SESSION_WARNING_FIX.md
new file mode 100644
index 000000000..7533b46cd
--- /dev/null
+++ b/docs/explanation/fixes/M365_UNRELATED_CHAT_SESSION_WARNING_FIX.md
@@ -0,0 +1,99 @@
+# Unrelated M365 Chat Warnings and Session Recovery (v0.261.340)
+
+Fixed/Implemented in version: **0.261.338**
+
+Application version: `application/single_app/config.py`.
+
+Integrated with the message-action calendar control in version **0.261.339**.
+The merged browser harness retains both calendar placement/eligibility coverage
+and app-session recovery scenarios, including draft preservation after expiry.
+
+## Issue and root cause
+
+A React V2 conversation with no Microsoft 365 work could show an outgoing-actions
+permission banner. Every conversation discovers saved actions in the background,
+including on focus, reconnect and reply completion. A failed list request alone
+made the M365 section visible, and every list HTTP 403 was described as an M365
+permission denial even when it was an app-wide access response.
+
+In the reported incident, **Repeat on a schedule** also failed with a connection
+message until the page was refreshed. That message comes from a rejected fetch,
+not proof of an expired Graph token or app session. Without the original response
+trace, the incident's upstream authentication or network cause remains unconfirmed.
+
+## Changes
+
+`PendingActionSlots.tsx` requires current-conversation action evidence or explicit
+action navigation before showing background list errors. Discovery still runs:
+an orphaned saved action can appear even when no visible message references it.
+The store retains failures, blocks unsafe action changes, and exposes contextual
+recovery if action evidence arrives later.
+
+`apiClient.ts` distinguishes explicit app-session responses and recognized sign-in
+redirects from provider reconnect/consent, object-level denials and server errors.
+Ambiguous protected-request transport failures may trigger one shared read-only
+bootstrap verification, with a five-second timeout and a 15-second automatic-check
+cooldown. A failed probe does not establish expiry. Neither JSON nor multipart
+requests are replayed.
+
+`appSessionStore.ts`, `bootstrapStore.ts` and `SessionNotice.tsx` keep runtime
+recovery separate from startup failure state. One notice in `AppShell.tsx` offers
+the existing sign-in flow in a new tab and **Check sign-in**, preserving the mounted
+chat, composer and open schedule form. Late bootstrap reads cannot clear a newer
+expiry signal. A changed account cannot replace the current bootstrap; users must
+copy unsaved text and explicitly reload. New API writes are blocked while the app
+knows sign-in is required or the account has changed.
+
+`workflowPlanReplay.ts` reports confirmed app-session failures accurately.
+Opening **Repeat on a schedule** still performs reads only; saving or enabling a
+workflow requires a separate explicit action.
+
+No backend authorization, Graph permissions, token lifetime, delivery policy or
+classic UI behavior changes.
+
+### URL-independent verification
+
+Fixed in version: **0.261.340** (`application/single_app/config.py`).
+CodeQL `js/user-controlled-bypass` identified that comparing the caller's request
+path with `/api/v2/bootstrap` could skip the transport-failure session check.
+Verification no longer depends on the requested path. Recursion is prevented by
+the verifier's direct fetch to the fixed bootstrap endpoint, outside the API
+wrapper, rather than by exempting a caller-controlled URL.
+
+Regression tests cover the exact bootstrap path, query variants and dynamic
+feature URLs, and prove that a failed bootstrap read triggers at most one direct
+verification probe. The existing timeout, cooldown, abort handling, identity
+guards and no-mutation-replay behavior remain unchanged.
+
+## Validation
+
+| Before | After |
+| --- | --- |
+| An unrelated failed action-list read could create an M365 permission panel. | Background failures remain internal until actual action context exists. |
+| Runtime expiry could surface only as disconnected feature errors. | Explicit app-session failures produce one app-level recovery notice. |
+| A fetch rejection could only be reported as connectivity failure. | A bounded bootstrap check can confirm expiry; inconclusive checks remain neutral. |
+| A full reload was needed to reset the affected interface. | Same-account sign-in can be confirmed in place; retry remains user-initiated. |
+
+Runtime regression coverage executes real API, bootstrap, replay and pending-action
+modules in `functional_tests/test_v2_app_session_recovery.mjs`, alongside the existing
+bootstrap, pending-action and replay suites. Browser coverage in
+`ui_tests/test_v2_m365_pending_action_cards.py` checks unrelated 401/403/500 reads,
+focus/online refreshes, late action evidence and contextual recovery. Tests in
+`ui_tests/test_v2_workflow_plan_replay_card.py` exercise desktop/mobile session
+recovery with the real shell, retained draft DOM, retained schedule fields and no
+automatic POST replay. HTTP boundaries are mocked; these tests do not prove the
+cause of the original production incident.
+
+The affected browser suites, runtime regression suites, pending-action functional
+wrapper, production V2 build, TypeScript check and documentation coverage/quality
+checks passed. The UI mechanical detector reported no findings.
+
+After base integration in **0.261.339**, all 32 plan-replay and 18 M365 browser
+tests passed, including the calendar message action and session-recovery scenarios.
+The message-action functional suite passed 7 of 8 checks: its existing retry/edit
+source assertion expects `'chat_request': chat_request`, but the unchanged base
+route returns `'chat_request': body`. The new calendar-placement check passed;
+the unrelated retry/edit assertion was not changed by this merge.
+
+See [V2 pending-action cards](../features/V2_M365_PENDING_ACTION_CARDS.md) and
+[chat sign-in controls](../../reference/chat-controls.md#react-v2-sign-in-recovery).
diff --git a/docs/guides/getting-started.md b/docs/guides/getting-started.md
index 92a7e1f19..3d94a686e 100644
--- a/docs/guides/getting-started.md
+++ b/docs/guides/getting-started.md
@@ -165,6 +165,21 @@ Or dive into specific tasks with our [how-to guides]({{ '/guides/' | relative_ur
 
 ## Troubleshooting
 
+### Renewing your SimpleChat session without losing a draft
+
+Fixed/Implemented in version: **0.261.338** (`application/single_app/config.py`).
+In React V2, a confirmed app-session expiry shows a SimpleChat sign-in notice
+while leaving your current chat and unsaved draft open. Choose **Sign in again
+(opens a new tab)**, finish signing in with the same account, then return and
+choose **Check sign-in** if the notice remains. Retry the action you intended
+only after sign-in is confirmed. Recovery never sends a message, submits an
+outgoing action, or saves a schedule automatically.
+
+If a different account is detected, copy any unsaved text before choosing
+**Reload SimpleChat**. A connectivity error alone does not prove session expiry.
+Microsoft 365 reconnect prompts apply to actual Microsoft 365 work, not to an
+unrelated conversation's background lookup.
+
 **Document not uploading?**
 - Check file size limits in Admin Settings
 - Ensure file types are supported
diff --git a/docs/reference/chat-controls.md b/docs/reference/chat-controls.md
index 9bfb31ed4..7f568f600 100644
--- a/docs/reference/chat-controls.md
+++ b/docs/reference/chat-controls.md
@@ -4,7 +4,7 @@ title: "Chat interface controls"
 description: "Reference for every documented control in the SimpleChat chat interface."
 section: "Reference"
 audience: user
-version: "0.261.325"
+version: "0.261.339"
 ---
 
 ## How to use this reference
@@ -25,6 +25,27 @@ Use this page when you can see a control in Chat but are not sure what it does o
 
 ## Conversation header and status
 
+### React V2 sign-in recovery
+
+Fixed/Implemented in version: **0.261.338** (`application/single_app/config.py`).
+When a request confirms that your SimpleChat app session needs sign-in, one
+notice appears above the current page. The chat and unsaved composer or
+schedule-form draft stay open; nothing is sent or saved again automatically.
+An ordinary connection failure or Microsoft 365 consent request does not by
+itself trigger this notice.
+
+| V2 control | Purpose | Availability |
+| --- | --- | --- |
+| Sign in again (opens a new tab) | Opens the existing SimpleChat sign-in flow without navigating away from unsaved work. | Confirmed app-session expiry |
+| Check sign-in | Checks the signed-in account without repeating the failed operation. After successful same-account recovery, choose the original action again. | Session-recovery notice |
+| Reload SimpleChat | Reopens the app after an account change instead of applying another account's settings to the existing chat. Copy unsaved text before reloading. | Recovery detects a different account |
+
+Returning to the tab or coming back online also permits a bounded sign-in
+check. If the check cannot confirm sign-in, the notice stays visible.
+**Reconnect Microsoft 365** remains specific to a real Microsoft 365 action;
+a failed background outgoing-action lookup does not add an M365 banner to
+an unrelated conversation.
+
 ### Personal action credential cards
 
 Fixed/Implemented in version: **0.261.333** (`application/single_app/config.py`).
diff --git a/functional_tests/test_v2_app_session_recovery.mjs b/functional_tests/test_v2_app_session_recovery.mjs
new file mode 100644
index 000000000..c52bc0eba
--- /dev/null
+++ b/functional_tests/test_v2_app_session_recovery.mjs
@@ -0,0 +1,299 @@
+// test_v2_app_session_recovery.mjs
+// Version: 0.261.340
+// Implemented in: 0.261.338
+// Executes real request, bootstrap, replay and pending-action modules with only HTTP replaced.
+
+import assert from 'node:assert/strict';
+import { afterEach, beforeEach, test } from 'node:test';
+import './test_support/tsResolve.mjs';
+
+const { api, isAppSessionError, isAppSessionRequired, verifyAppSession, uploadFile } =
+    await import('../application/v2_ui/src/lib/apiClient.ts');
+const { SESSION_REQUIRED_MESSAGE, useAppSessionStore } =
+    await import('../application/v2_ui/src/stores/appSessionStore.ts');
+const { useBootstrapStore } = await import('../application/v2_ui/src/stores/bootstrapStore.ts');
+const { fetchPlanReplayPreview } = await import('../application/v2_ui/src/lib/workflowPlanReplay.ts');
+const { createPendingActionsStore, canChangeEntry, LIST_FAILED_MESSAGE } =
+    await import('../application/v2_ui/src/stores/m365PendingActionsStore.ts');
+
+const originalFetch = globalThis.fetch;
+const originalNow = Date.now;
+let clock = originalNow();
+let requests;
+let handler;
+const json = (body, status = 200) => new Response(JSON.stringify(body), {
+    status, headers: { 'Content-Type': 'application/json' },
+});
+const expired = () => json({ error: 'Session expired', requires_reauth: true }, 401);
+const bootstrap = (id = 'owner') => ({ user: { id }, features: {} });
+const pendingAction = () => ({
+    id: 'draft', type: 'msgraph_pending_action', conversation_id: 'chat', version: 'v1',
+    status: 'pending', operation: 'send_mail', can_send_now: true, can_cancel: true,
+    viewer_is_owner: true,
+});
+
+beforeEach(() => {
+    clock += 20_000;
+    Date.now = () => clock;
+    useAppSessionStore.setState({ status: 'ready', viewerId: 'owner', revision: 0 });
+    useBootstrapStore.setState({ data: bootstrap(), loading: false, error: null, authExpired: false });
+    requests = [];
+    handler = () => { throw new Error('Install an HTTP response for this test.'); };
+    globalThis.fetch = async (path, init = {}) => {
+        requests.push({ path, ...init });
+        return handler(String(path), init);
+    };
+});
+
+afterEach(() => {
+    globalThis.fetch = originalFetch;
+    Date.now = originalNow;
+    useAppSessionStore.setState({ status: 'ready', viewerId: '', revision: 0 });
+});
+
+test('only explicit app-session failures require app sign-in', () => {
+    for (const [status, body, expected] of [
+        [401, { requires_reauth: true }, true],
+        [401, { error: 'Unauthorized', message: 'Authentication required' }, true],
+        [401, { error: 'not_logged_in' }, true],
+        [403, { requires_reauth: true }, true],
+        [403, { error: 'forbidden' }, false],
+        [403, { error: 'Forbidden', message: 'Insufficient permissions' }, false],
+        [401, { error: 'm365_reconnect_required', auth_required: true }, false],
+        [401, { error: 'consent_required' }, false],
+        [500, { requires_reauth: true }, false],
+        [401, null, false],
+    ]) {
+        assert.equal(isAppSessionRequired(status, body), expected, JSON.stringify(body));
+    }
+});
+
+test('concurrent M365 and schedule failures produce one session state, never M365 permission copy', async () => {
+    handler = () => expired();
+    const store = createPendingActionsStore();
+    store.getState().setConversation('chat');
+    const outcomes = await Promise.allSettled([
+        store.getState().loadList(), fetchPlanReplayPreview('run', 'chat'),
+    ]);
+    assert.equal(useAppSessionStore.getState().status, 'required');
+    assert.equal(useAppSessionStore.getState().revision, 1);
+    assert.equal(store.getState().listStatus, 'error');
+    assert.equal(store.getState().listError, SESSION_REQUIRED_MESSAGE);
+    assert.equal(outcomes[1].reason.code, 'app_session_required');
+    assert.equal(outcomes[1].reason.text, SESSION_REQUIRED_MESSAGE);
+    assert.equal(requests.length, 2);
+    assert.ok(requests.every((request) => !request.method || request.method === 'GET'));
+});
+
+test('a rejected fetch checks the session once without replaying even a POST', async () => {
+    handler = (path) => path === '/api/v2/bootstrap' ? expired() : Promise.reject(new TypeError('Failed to fetch'));
+    const result = await Promise.allSettled([api.post('/save', { value: 'reviewed' }), api.get('/preview')]);
+    assert.ok(result.every((item) => item.status === 'rejected' && isAppSessionError(item.reason)));
+    assert.equal(requests.filter((item) => item.path === '/api/v2/bootstrap').length, 1);
+    assert.equal(requests.filter((item) => item.method === 'POST').length, 1);
+    assert.equal(useAppSessionStore.getState().status, 'required');
+});
+
+test('offline failures remain connection failures and do not recursively probe', async () => {
+    handler = () => Promise.reject(new TypeError('offline'));
+    await assert.rejects(api.get('/preview'), TypeError);
+    assert.deepEqual(requests.map((item) => item.path), ['/preview', '/api/v2/bootstrap']);
+    assert.equal(useAppSessionStore.getState().status, 'ready');
+    await assert.rejects(api.get('/another-preview'), TypeError);
+    assert.equal(requests.length, 3, 'verification is rate limited');
+});
+
+for (const path of [
+    '/api/v2/bootstrap',
+    '/api/v2/bootstrap?refresh=1',
+    '/api/approvals?request_id=caller-selected',
+    '/api/user/agents/caller-selected',
+]) {
+    test(`a request URL cannot bypass session verification: ${path}`, async () => {
+        let first = true;
+        handler = (url) => {
+            if (first) {
+                first = false;
+                return Promise.reject(new TypeError('Failed to fetch'));
+            }
+            assert.equal(url, '/api/v2/bootstrap', 'verification always uses the fixed app endpoint');
+            return expired();
+        };
+        await assert.rejects(api.get(path), isAppSessionError);
+        assert.deepEqual(requests.map((item) => item.path), [path, '/api/v2/bootstrap']);
+        assert.equal(useAppSessionStore.getState().status, 'required');
+    });
+}
+
+test('a rejected bootstrap request has one direct probe, never recursive verification', async () => {
+    handler = () => Promise.reject(new TypeError('offline'));
+    await assert.rejects(api.get('/api/v2/bootstrap'), TypeError);
+    assert.deepEqual(requests.map((item) => item.path), ['/api/v2/bootstrap', '/api/v2/bootstrap']);
+    assert.equal(useAppSessionStore.getState().status, 'ready');
+});
+
+test('provider reconnect and object-level denial never mark the app session expired', async () => {
+    for (const [status, body] of [
+        [401, { error: 'm365_reconnect_required', auth_required: true }],
+        [403, { error: 'forbidden' }],
+        [500, { error: 'service_unavailable' }],
+    ]) {
+        handler = () => json(body, status);
+        await assert.rejects(api.get('/api/msgraph/pending-actions/draft'),
+            (error) => error.status === status && !isAppSessionError(error));
+        assert.equal(useAppSessionStore.getState().status, 'ready');
+    }
+    assert.equal(requests.length, 3);
+});
+
+test('an app-wide role denial is not described as a Microsoft 365 conversation permission error', async () => {
+    handler = () => json({ error: 'Forbidden', message: 'Insufficient permissions (User/Admin role required)' }, 403);
+    const store = createPendingActionsStore();
+    store.getState().setConversation('chat');
+    store.getState().remember(pendingAction(), { authoritative: true });
+    await store.getState().loadList();
+    assert.equal(store.getState().listStatus, 'error');
+    assert.equal(store.getState().listError, LIST_FAILED_MESSAGE);
+    assert.equal(canChangeEntry(store.getState().entries.draft), false);
+    assert.equal(useAppSessionStore.getState().status, 'ready');
+});
+
+test('a known sign-in redirect is not parsed as a successful API response', async () => {
+    handler = () => {
+        const response = new Response('<html>Sign in</html>');
+        Object.defineProperties(response, {
+            redirected: { value: true }, url: { value: 'https://simplechat.example/login' },
+        });
+        return response;
+    };
+    await assert.rejects(api.get('/preview'), isAppSessionError);
+    assert.equal(useAppSessionStore.getState().status, 'required');
+});
+
+test('a session check is bounded and an abort remains unconfirmed, not expired', async () => {
+    handler = (_path, init) => {
+        assert.ok(init.signal);
+        assert.equal(init.cache, 'no-store');
+        return Promise.reject(new DOMException('Check aborted', 'AbortError'));
+    };
+    const confirmed = await verifyAppSession(true);
+    assert.equal(confirmed, false);
+    assert.equal(useAppSessionStore.getState().status, 'ready');
+    assert.equal(requests.length, 1);
+});
+
+test('verification actually aborts after five seconds, not before', async (context) => {
+    context.mock.timers.enable({ apis: ['setTimeout'] });
+    handler = (_path, init) => new Promise((_resolve, reject) => {
+        init.signal.addEventListener('abort', () => reject(new DOMException('Timed out', 'AbortError')));
+    });
+    let settled = false;
+    const checking = verifyAppSession(true).then((result) => {
+        settled = true;
+        return result;
+    });
+    context.mock.timers.tick(4999);
+    await Promise.resolve();
+    assert.equal(settled, false);
+    context.mock.timers.tick(1);
+    const confirmed = await checking;
+    assert.equal(confirmed, false);
+    assert.equal(useAppSessionStore.getState().status, 'ready');
+});
+
+test('automatic verification becomes available again only after the fifteen-second cooldown', async () => {
+    handler = () => Promise.reject(new TypeError('offline'));
+    await assert.rejects(api.get('/preview'), TypeError);
+    clock += 14_999;
+    await assert.rejects(api.get('/preview'), TypeError);
+    assert.equal(requests.filter((item) => item.path === '/api/v2/bootstrap').length, 1);
+    clock += 1;
+    await assert.rejects(api.get('/preview'), TypeError);
+    assert.equal(requests.filter((item) => item.path === '/api/v2/bootstrap').length, 2);
+});
+
+test('successful same-user verification clears the notice but not an operation or draft', async () => {
+    useAppSessionStore.getState().requireSignIn(0);
+    handler = () => json(bootstrap());
+    const confirmed = await verifyAppSession(true);
+    assert.equal(confirmed, true);
+    assert.equal(useAppSessionStore.getState().status, 'ready');
+    assert.deepEqual(requests.map((item) => item.path), ['/api/v2/bootstrap']);
+});
+
+test('a bootstrap read started before expiry cannot clear it', async () => {
+    let finish;
+    handler = () => new Promise((resolve) => { finish = resolve; });
+    const reading = useBootstrapStore.getState().refresh();
+    useAppSessionStore.getState().requireSignIn(0);
+    finish(json(bootstrap()));
+    await reading;
+    assert.equal(useAppSessionStore.getState().status, 'required');
+    assert.equal(useBootstrapStore.getState().loading, false);
+    assert.equal(useBootstrapStore.getState().error, null);
+    assert.equal(useBootstrapStore.getState().authExpired, false);
+});
+
+test('an old request failure cannot expire a newly verified session', async () => {
+    let finish;
+    handler = () => new Promise((resolve) => { finish = resolve; });
+    const stale = api.get('/old-preview');
+    useAppSessionStore.getState().requireSignIn(0);
+    handler = () => json(bootstrap());
+    const confirmed = await verifyAppSession(true);
+    assert.equal(confirmed, true);
+    finish(expired());
+    await assert.rejects(stale, isAppSessionError);
+    assert.equal(useAppSessionStore.getState().status, 'ready');
+});
+
+test('an aborted protected request does not run a session probe', async () => {
+    const controller = new AbortController();
+    controller.abort();
+    handler = () => Promise.reject(new TypeError('aborted'));
+    await assert.rejects(api.get('/preview', controller.signal), TypeError);
+    assert.equal(requests.length, 1);
+    assert.equal(useAppSessionStore.getState().status, 'ready');
+});
+
+test('an account switch cannot install another identity over the old chat', async () => {
+    const previous = useBootstrapStore.getState().data;
+    handler = () => json(bootstrap('someone-else'));
+    await useBootstrapStore.getState().refresh();
+    assert.equal(useAppSessionStore.getState().status, 'changed');
+    assert.equal(useBootstrapStore.getState().data, previous);
+});
+
+test('app-session expiry on a saved draft does not offer a Microsoft 365 reconnect', async () => {
+    const store = createPendingActionsStore();
+    store.getState().setConversation('chat');
+    store.getState().remember(pendingAction(), { authoritative: true });
+    handler = () => expired();
+    await store.getState().refresh('draft');
+    const entry = store.getState().entries.draft;
+    assert.equal(entry.auth, null);
+    assert.equal(entry.notice.text, SESSION_REQUIRED_MESSAGE);
+    assert.equal(canChangeEntry(entry), false);
+});
+
+test('upload session failures use the same app notice without retrying multipart data', async () => {
+    handler = () => expired();
+    await assert.rejects(uploadFile('/upload', new FormData()), isAppSessionError);
+    assert.equal(useAppSessionStore.getState().status, 'required');
+    assert.equal(requests.length, 1);
+});
+
+test('known expiry or an account switch blocks new writes until explicit recovery', async () => {
+    useAppSessionStore.getState().requireSignIn(0);
+    await assert.rejects(api.post('/save', {}), isAppSessionError);
+    await assert.rejects(uploadFile('/upload', new FormData()), isAppSessionError);
+    useAppSessionStore.setState({ status: 'changed' });
+    await assert.rejects(api.post('/save', {}), (error) => error.payload.error === 'app_account_changed');
+    assert.equal(requests.length, 0);
+});
+
+test('ambiguous upload failures share read-only verification without resending the file', async () => {
+    handler = (path) => path === '/api/v2/bootstrap' ? expired() : Promise.reject(new TypeError('Failed to fetch'));
+    await assert.rejects(uploadFile('/upload', new FormData()), isAppSessionError);
+    assert.deepEqual(requests.map((item) => item.path), ['/upload', '/api/v2/bootstrap']);
+});
diff --git a/functional_tests/test_v2_bootstrap_refresh_logic.mjs b/functional_tests/test_v2_bootstrap_refresh_logic.mjs
index ed8fd60f1..14e658a58 100644
--- a/functional_tests/test_v2_bootstrap_refresh_logic.mjs
+++ b/functional_tests/test_v2_bootstrap_refresh_logic.mjs
@@ -1,7 +1,7 @@
 // test_v2_bootstrap_refresh_logic.mjs
 //
 // Runtime test for the V2 bootstrap store's refresh action.
-// Version: 0.261.305
+// Version: 0.261.338
 // Implemented in: 0.261.046
 // Required authoring selection refresh added in: 0.261.096
 // Scope-only refresh for group switching added in: 0.261.305 (#1725)
@@ -57,6 +57,7 @@ let fetchImpl = () => {
 globalThis.fetch = (...args) => fetchImpl(...args);
 
 const { useBootstrapStore } = await import(STORE_URL);
+const { useAppSessionStore } = await import('../application/v2_ui/src/stores/appSessionStore.ts');
 
 /** A minimal Response the api client is happy to read. */
 function jsonResponse(body, status = 200) {
@@ -328,6 +329,8 @@ async function testScopeRefreshRejectsAnotherViewer() {
     fetchImpl = async () => jsonResponse({ user: { id: 'someone-else' }, scope: { active_group_id: 'g2' } });
     await assert.rejects(useBootstrapStore.getState().refreshScope('u1'), /sign-in changed/);
     await assert.rejects(useBootstrapStore.getState().refreshScope('not-u1'), /sign-in changed/);
+    assert.equal(useAppSessionStore.getState().status, 'changed');
+    useAppSessionStore.setState({ status: 'ready', viewerId: 'u1', revision: 0 });
     fetchImpl = async () => jsonResponse({ user: { id: 'u1' } });
     await assert.rejects(useBootstrapStore.getState().refreshScope('u1'), /could not be read/);
     assert.equal(useBootstrapStore.getState().data, loaded);
@@ -425,6 +428,7 @@ let passed = 0;
 for (const test of tests) {
     console.log(`\nRunning ${test.name}...`);
     try {
+        useAppSessionStore.setState({ status: 'ready', viewerId: 'u1', revision: 0 });
         await test();
         passed += 1;
     } catch (error) {
diff --git a/functional_tests/test_v2_m365_pending_actions.py b/functional_tests/test_v2_m365_pending_actions.py
index bca3a01d7..c64e79f85 100644
--- a/functional_tests/test_v2_m365_pending_actions.py
+++ b/functional_tests/test_v2_m365_pending_actions.py
@@ -3,8 +3,9 @@
 """
 Functional test for Microsoft 365 pending-action cards in the V2 chat.
 
-Version: 0.261.325
+Version: 0.261.338
 Implemented in: 0.261.307
+Contextual warnings and session recovery added in: 0.261.338
 
 A Microsoft 365 action the assistant saves for review (an email or a calendar change waiting
 behind Send, Send now and Cancel) used to be drawn only by the classic chat page. V2 sent every
@@ -68,6 +69,7 @@
 LOGIC_TEST = REPO_ROOT / "functional_tests" / "test_v2_m365_pending_actions_logic.mjs"
 STORE_TEST = REPO_ROOT / "functional_tests" / "test_v2_m365_pending_actions_store.mjs"
 STREAM_TEST = REPO_ROOT / "functional_tests" / "test_v2_m365_pending_actions_stream.mjs"
+SESSION_TEST = REPO_ROOT / "functional_tests" / "test_v2_app_session_recovery.mjs"
 NODE_MODULES = REPO_ROOT / "application" / "v2_ui" / "node_modules"
 
 NEW_FILES = (
@@ -508,6 +510,11 @@ def test_the_live_paths_behave():
     return _run_node_test(STREAM_TEST)
 
 
+def test_app_session_recovery_behaves():
+    """App sign-in, provider auth, connectivity and stale identities stay distinct."""
+    return _run_node_test(SESSION_TEST)
+
+
 def test_version_was_incremented():
     """The application version records when this shipped."""
     print("Testing version...")
@@ -535,6 +542,7 @@ def test_version_was_incremented():
         test_pure_rules_behave,
         test_store_behaves,
         test_the_live_paths_behave,
+        test_app_session_recovery_behaves,
         test_version_was_incremented,
     ]
 
diff --git a/ui_tests/fixtures/orchestration/harness_entry.tsx b/ui_tests/fixtures/orchestration/harness_entry.tsx
index 5f82eae96..e30e8e667 100644
--- a/ui_tests/fixtures/orchestration/harness_entry.tsx
+++ b/ui_tests/fixtures/orchestration/harness_entry.tsx
@@ -22,6 +22,7 @@ import * as generatedExportRunStore from '../../../application/v2_ui/src/stores/
 import * as userSettingsStore from '../../../application/v2_ui/src/stores/userSettingsStore';
 import * as assistThreadStore from '../../../application/v2_ui/src/stores/assistThreadStore';
 import * as m365PendingActionsStore from '../../../application/v2_ui/src/stores/m365PendingActionsStore';
+import * as appSessionStore from '../../../application/v2_ui/src/stores/appSessionStore';
 import * as controller from '../../../application/v2_ui/src/lib/orchestrationController';
 import * as plan from '../../../application/v2_ui/src/lib/orchestrationPlan';
 import * as orchestration from '../../../application/v2_ui/src/lib/orchestration';
@@ -141,6 +142,14 @@ function PromptExperience() {
     );
 }
 
+function SessionChatExperience() {
+    return (
+        <div style={{ height: '100dvh' }}>
+            <AppShell><MessageList /><Composer /></AppShell>
+        </div>
+    );
+}
+
 function ContextWorkflow({ nativeChat = false }: { nativeChat?: boolean }) {
     const location = useLocation();
     return (
@@ -215,6 +224,7 @@ type ComponentName =
     | 'ConversationDrawer'
     | 'Composer'
     | 'PromptExperience'
+    | 'SessionChatExperience'
     | 'ChatExperience'
     | 'HomeExperience'
     | 'HeaderExperience'
@@ -245,6 +255,7 @@ const components: Record<ComponentName, (props: any) => ReactElement | null> = {
     ConversationDrawer,
     Composer,
     PromptExperience,
+    SessionChatExperience,
     ChatExperience,
     HomeExperience,
     HeaderExperience,
@@ -366,6 +377,7 @@ function reset(): void {
     // Saved Microsoft 365 actions belong to the conversation they were read for, so a test
     // reusing a conversation id would otherwise start from the previous test's cards.
     m365PendingActionsStore.chatPendingActionsStore.getState().reset();
+    appSessionStore.useAppSessionStore.setState({ status: 'ready', viewerId: '', revision: 0 });
     try {
         window.localStorage.clear();
     } catch {
@@ -391,6 +403,7 @@ const harness = {
         userSettings: userSettingsStore,
         assistThread: assistThreadStore,
         pendingActions: m365PendingActionsStore,
+        appSession: appSessionStore,
     },
     controller,
     plan,
diff --git a/ui_tests/test_v2_m365_pending_action_cards.py b/ui_tests/test_v2_m365_pending_action_cards.py
index e999c1793..da069d3fd 100644
--- a/ui_tests/test_v2_m365_pending_action_cards.py
+++ b/ui_tests/test_v2_m365_pending_action_cards.py
@@ -1,7 +1,7 @@
 # test_v2_m365_pending_action_cards.py
 """
 UI test for Microsoft 365 pending-action cards in the V2 chat.
-Version: 0.261.325
+Version: 0.261.338
 Implemented in: 0.261.307
 
 This test ensures that a saved outgoing Microsoft 365 email or calendar action is drawn in the V2
@@ -66,6 +66,7 @@
     });
     window.requests = [];
     window.listFails = Boolean(config.listFails);
+    window.listStatus = config.listStatus || 500;
     window.changeStatus = 200;
     window.listedActions = config.list;
     window.actionsById = Object.fromEntries(config.byId.map((action) => [action.id, action]));
@@ -90,7 +91,7 @@
         }
         if (path === '/api/msgraph/pending-actions' && method === 'GET') {
             if (window.listFails) {
-                return json({ success: false, message: 'The list is unavailable.' }, 500);
+                return json({ success: false, error: 'forbidden', message: 'The list is unavailable.' }, window.listStatus);
             }
             return json({ success: true, pending_actions: window.listedActions, continuation_token: '' });
         }
@@ -219,11 +220,13 @@ def _collect_page_errors(page):
     return errors
 
 
-def _open_chat(page, origin, *, messages, listed=(), by_id=(), send=None, listing_fails=False):
+def _open_chat(page, origin, *, messages, listed=(), by_id=(), send=None, listing_fails=False, list_status=500):
     response = page.goto(f"{origin}/{harness_build.HARNESS_HTML_REL}")
     assert response is not None and response.ok
     page.wait_for_function("() => Boolean(window.OrchHarness)")
-    page.evaluate(STUB_BACKEND, {"list": list(listed), "byId": list(by_id), "listFails": listing_fails})
+    page.evaluate(STUB_BACKEND, {
+        "list": list(listed), "byId": list(by_id), "listFails": listing_fails, "listStatus": list_status,
+    })
     page.evaluate(SEED_THREAD, {"messages": messages, "send": send})
     return page.locator("#mount-a")
 
@@ -630,12 +633,12 @@ def test_failed_list_is_shown_and_can_be_read_again(page):
     unclaimed = pending_action("act-orphan", subject="Unrelated draft", request_id="req-other")
     with harness_build.start_static_server() as origin:
         root = _open_chat(
-            page, origin, messages=thread(), listed=[unclaimed], by_id=[unclaimed], listing_fails=True,
+            page, origin, messages=thread(unclaimed), listed=[unclaimed], by_id=[unclaimed], listing_fails=True,
         )
         error = root.get_by_test_id("v2-pending-actions-error")
         expect(error).to_be_visible()
         expect(root.get_by_role("region", name=SECTION_NAME)).to_be_visible()
-        expect(root.get_by_test_id("v2-pending-action-card")).to_have_count(0)
+        expect(root.get_by_test_id("v2-pending-action-card")).to_have_count(1)
 
         page.evaluate("() => { window.listFails = false; }")
         root.get_by_test_id("v2-pending-actions-refresh").click()
@@ -645,6 +648,40 @@ def test_failed_list_is_shown_and_can_be_read_again(page):
         assert not _posts_to_actions(page)
     assert errors == []
 
+@pytest.mark.parametrize("status", [401, 403, 500])
+def test_unrelated_chat_does_not_show_an_m365_banner_for_background_failures(page, status):
+    _require_bundle()
+    errors = _collect_page_errors(page)
+    with harness_build.start_static_server() as origin:
+        root = _open_chat(page, origin, messages=thread(), listing_fails=True, list_status=status)
+        page.wait_for_function(
+            "() => window.OrchHarness.stores.pendingActions.chatPendingActionsStore.getState().listStatus === 'error'"
+        )
+        expect(root.get_by_role("region", name=SECTION_NAME)).to_have_count(0)
+        expect(root.get_by_test_id("v2-pending-actions-refresh")).to_have_count(0)
+        page.evaluate("() => { window.dispatchEvent(new Event('focus')); window.dispatchEvent(new Event('online')); }")
+        page.wait_for_function("() => window.requests.filter((r) => r.path === '/api/msgraph/pending-actions').length >= 2")
+        expect(root.get_by_role("region", name=SECTION_NAME)).to_have_count(0)
+        assert not _posts_to_actions(page)
+    assert errors == []
+
+
+def test_a_real_action_arriving_after_a_background_failure_exposes_recovery(page):
+    _require_bundle()
+    with harness_build.start_static_server() as origin:
+        root = _open_chat(page, origin, messages=thread(), listing_fails=True, list_status=403)
+        page.wait_for_function(
+            "() => window.OrchHarness.stores.pendingActions.chatPendingActionsStore.getState().listStatus === 'error'"
+        )
+        expect(root.get_by_role("region", name=SECTION_NAME)).to_have_count(0)
+        page.evaluate(
+            "(action) => window.OrchHarness.stores.pendingActions.chatPendingActionsStore.getState().remember(action)",
+            pending_action("real-draft"),
+        )
+        expect(root.get_by_test_id("v2-pending-actions-error")).to_be_visible()
+        expect(root.get_by_role("region", name=SECTION_NAME)).to_be_visible()
+        assert not _posts_to_actions(page)
+
 
 if __name__ == "__main__":
     sys.exit(pytest.main([__file__, "-q"]))
diff --git a/ui_tests/test_v2_workflow_plan_replay_card.py b/ui_tests/test_v2_workflow_plan_replay_card.py
index b58746abe..66bde1a50 100644
--- a/ui_tests/test_v2_workflow_plan_replay_card.py
+++ b/ui_tests/test_v2_workflow_plan_replay_card.py
@@ -1,8 +1,9 @@
 # test_v2_workflow_plan_replay_card.py
 """
 Real-component browser tests for saving a completed chat orchestration plan as a replay workflow.
-Version: 0.261.338
+Version: 0.261.339
 Implemented in: 0.261.308
+Session recovery coverage added in: 0.261.338
 Calendar message action implemented in: 0.261.338
 Refs: microsoft/simplechat#1550, microsoft/simplechat#1543
 
@@ -174,6 +175,9 @@ def __init__(self, assets):
         self.preview_error = None
         self.save_created = True
         self.expected_errors = set()
+        self.session_expired = False
+        self.list_denied = False
+        self.reject_preview = False
 
     def expect(self, condition, description):
         if not condition:
@@ -201,15 +205,31 @@ def handle(self, route):
         if path == "/favicon.ico":
             route.fulfill(status=204)
             return
-        if is_pending_actions_list(request.method, path):
-            route.fulfill(json=pending_actions_payload())
-            return
-        if request.method == "GET" and path == "/api/action-credentials/pending":
+        if path == "/api/action-credentials/pending" and request.method == "GET":
             route.fulfill(json={"requests": []})
             return
+        if is_pending_actions_list(request.method, path):
+            if self.list_denied:
+                route.fulfill(status=403, json={"error": "forbidden"})
+            else:
+                route.fulfill(json=pending_actions_payload())
+            return
         query = parse_qs(parsed.query)
         body = request.post_data_json if request.method == "POST" else None
         self.requests.append({"method": request.method, "path": path, "query": query, "body": body})
+        if path == "/api/v2/bootstrap" and request.method == "GET":
+            if self.session_expired:
+                route.fulfill(status=401, json={"error": "Session expired", "requires_reauth": True})
+            else:
+                route.fulfill(json={"user": {"id": "plan-replay-tester"}})
+            return
+        if self.session_expired and (path in self.preview_paths or
+                                    (path == EDITOR_OPTIONS_PATH and not self.reject_preview)):
+            if self.reject_preview and path in self.preview_paths:
+                route.abort("failed")
+            else:
+                route.fulfill(status=401, json={"error": "Session expired", "requires_reauth": True})
+            return
         if path == "/api/message/answer-1/metadata" and request.method == "GET":
             route.fulfill(json=answer()[-1])
             return
@@ -306,7 +326,9 @@ def console_error(message):
     assert not dialogs, f"Unexpected browser dialogs: {dialogs}"
 
 
-def mount_messages(page, *, feature=True, features=None, messages=None, kind="personal", conversation=CONVERSATION):
+def mount_messages(
+    page, *, feature=True, features=None, messages=None, kind="personal", conversation=CONVERSATION, shell=False,
+):
     page.goto(ORIGIN + HARNESS)
     page.wait_for_function("() => Boolean(window.OrchHarness)")
     page.evaluate(
@@ -314,7 +336,7 @@ def mount_messages(page, *, feature=True, features=None, messages=None, kind="pe
             const H = window.OrchHarness;
             H.reset();
             H.stores.bootstrap.useBootstrapStore.setState({ data: {
-                version: '0.261.338', settings: {}, branding: { app_title: 'SimpleChat' },
+                version: '0.261.339', settings: {}, branding: { app_title: 'SimpleChat' },
                 features: {
                     enable_chat_orchestration: true,
                     allow_user_workflows: true,
@@ -333,6 +355,11 @@ def mount_messages(page, *, feature=True, features=None, messages=None, kind="pe
                 streamError: null, thoughts: [], messages: spec.messages,
                 conversations: [{ id: spec.conversation, title: 'Plan replay' }],
             });
+            if (spec.shell) {
+                H.stores.appSession.useAppSessionStore.setState({
+                    status: 'ready', viewerId: 'plan-replay-tester', revision: 0,
+                });
+            }
             H.stores.orchestration.useOrchestrationStore.setState({
                 runRecovery: Object.fromEntries(spec.messages
                     .filter((message) => message.metadata?.orchestration?.run_id)
@@ -340,9 +367,9 @@ def mount_messages(page, *, feature=True, features=None, messages=None, kind="pe
                         ...message.metadata.orchestration, detailLoaded: true,
                     }])),
             });
-            H.mount('mount-a', 'MessageList', {}, { strictMode: true });
+            H.mount('mount-a', spec.shell ? 'SessionChatExperience' : 'MessageList', {}, { strictMode: true });
         }""",
-        {"feature": feature, "features": features or {}, "conversation": conversation, "kind": kind,
+        {"feature": feature, "features": features or {}, "conversation": conversation, "kind": kind, "shell": shell,
          "messages": messages if messages is not None else answer(conversation)},
     )
     expect(page.get_by_text("Summarize invoices.")).to_be_visible()
@@ -614,3 +641,85 @@ def test_run_inspector_renders_typed_replay_result(plan_replay_ui):
     expect(page.get_by_text("Final <script>inert</script> answer")).to_be_visible()
     expect(page.get_by_text("image: image-1")).to_be_visible()
     expect(page.get_by_text("The full answer is in the workflow's conversation.", exact=False)).to_be_visible()
+
+
+@pytest.mark.parametrize("viewport", [{"width": 1440, "height": 900}, {"width": 390, "height": 844}])
+@pytest.mark.parametrize("transport_failure", [False, True])
+def test_expired_session_preserves_chat_and_recovers_preview_without_unrelated_m365_warning(
+    plan_replay_ui, viewport, transport_failure,
+):
+    page, api = plan_replay_ui
+    page.set_viewport_size(viewport)
+    api.list_denied = True
+    api.expected_errors.add(("/api/msgraph/pending-actions", 403))
+    mount_messages(page, shell=True)
+    for url in api.assets:
+        if url.endswith(".css"):
+            page.add_style_tag(url=ORIGIN + url)
+
+    composer = page.get_by_role("textbox", name="Message", exact=True)
+    composer.fill("Keep this unsent draft")
+    composer.evaluate("(element) => { window.__originalComposer = element; }")
+    expect(page.get_by_test_id("v2-session-notice")).to_have_count(0)
+    expect(page.get_by_role("region", name="Microsoft 365 outgoing actions for this conversation")).to_have_count(0)
+    api.session_expired = True
+    api.reject_preview = transport_failure
+    api.expected_errors.update({(PREVIEW_PATH, 401), (EDITOR_OPTIONS_PATH, 401)})
+    api.expected_errors.add(("/api/v2/bootstrap", 401))
+    if transport_failure:
+        api.expected_errors.add((PREVIEW_PATH, "net::ERR_FAILED"))
+    page.get_by_role("button", name="Repeat on a schedule").click()
+
+    notice = page.get_by_test_id("v2-session-notice")
+    expect(notice).to_have_count(1)
+    expect(notice).to_contain_text("Your SimpleChat session needs to be renewed.")
+    expect(notice.get_by_role("button", name="Check sign-in")).to_be_visible()
+    expect(notice.get_by_role("link", name="Sign in again")).to_have_attribute("target", "_blank")
+    bounds = notice.bounding_box()
+    assert bounds and bounds["x"] >= 0 and bounds["x"] + bounds["width"] <= viewport["width"]
+    expect(composer).to_have_value("Keep this unsent draft")
+    assert composer.evaluate("(element) => element === window.__originalComposer")
+    expect(page.get_by_role("region", name="Save chat plan as workflow")).to_be_visible()
+    expect(page.get_by_text("SimpleChat could not be reached.", exact=False)).to_have_count(0)
+    expect(page.get_by_role("region", name="Microsoft 365 outgoing actions for this conversation")).to_have_count(0)
+
+    api.expected_errors.add(("/api/v2/bootstrap", 401))
+    notice.get_by_role("button", name="Check sign-in").click()
+    expect(notice.get_by_role("status")).to_contain_text("Your sign-in could not be confirmed.")
+    api.session_expired = False
+    notice.get_by_role("button", name="Check sign-in").click()
+    expect(notice).to_have_count(0)
+    expect(composer).to_have_value("Keep this unsent draft")
+    assert composer.evaluate("(element) => element === window.__originalComposer")
+    assert all(request["method"] == "GET" for request in api.requests)
+
+    page.get_by_role("button", name="Collapse", exact=True).click()
+    page.get_by_role("button", name="Repeat on a schedule").click()
+    expect(page.get_by_role("textbox", name="Workflow name")).to_be_visible()
+    expect(page.get_by_role("button", name="Save workflow")).to_be_enabled()
+    assert all(request["method"] == "GET" for request in api.requests)
+
+
+def test_session_notice_does_not_reset_an_open_schedule_form(plan_replay_ui):
+    page, api = plan_replay_ui
+    mount_messages(page, shell=True)
+    page.get_by_role("button", name="Repeat on a schedule").click()
+    name = page.get_by_role("textbox", name="Workflow name")
+    name.fill("My reviewed schedule")
+    description = page.get_by_role("textbox", name="Description")
+    description.fill("Keep this schedule draft")
+    page.get_by_role("checkbox", name="Run on a schedule").check()
+    api.session_expired = True
+    api.expected_errors.update({(PREVIEW_PATH, 401), (EDITOR_OPTIONS_PATH, 401)})
+    page.get_by_role("button", name="Save workflow").click()
+    expect(page.get_by_test_id("v2-session-notice")).to_have_count(1)
+    expect(name).to_have_value("My reviewed schedule")
+    expect(description).to_have_value("Keep this schedule draft")
+    expect(page.get_by_role("checkbox", name="Run on a schedule")).to_be_checked()
+    writes_before = len([request for request in api.requests if request["method"] == "POST"])
+    assert writes_before == 1
+    api.session_expired = False
+    page.get_by_test_id("v2-session-notice").get_by_role("button", name="Check sign-in").click()
+    expect(page.get_by_test_id("v2-session-notice")).to_have_count(0)
+    expect(name).to_have_value("My reviewed schedule")
+    assert len([request for request in api.requests if request["method"] == "POST"]) == writes_before